From 46fcf22630849f68f92aec64d38f44b0c4b3a943 Mon Sep 17 00:00:00 2001
From: Brandon Black <bblack@wikimedia.org>
Date: Wed, 14 Jan 2026 18:14:43 -0600
Subject: [PATCH 001/499] Io.Select: docs nits

---
 lib/std/Io.zig | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index b4d6efc715f163e0b59300d355284423d8b33382..18aa1e127abb1d679439f4ed8e28be01f2d315d7 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1250,7 +1250,7 @@ pub fn Select(comptime U: type) type {
         /// already been called and completed, or it has successfully been
         /// assigned a unit of concurrency.
         ///
-        /// After this is called, `wait` or `cancel` must be called before the
+        /// After this is called, `await` or `cancel` must be called before the
         /// select is deinitialized.
         ///
         /// Threadsafe.
@@ -1293,12 +1293,12 @@ pub fn Select(comptime U: type) type {
             };
         }
 
-        /// Equivalent to `wait` but requests cancelation on all remaining
+        /// Equivalent to `await` but requests cancelation on all remaining
         /// tasks owned by the select.
         ///
         /// For a description of cancelation and cancelation points, see `Future.cancel`.
         ///
-        /// It is illegal to call `wait` after this.
+        /// It is illegal to call `await` after this.
         ///
         /// Idempotent. Not threadsafe.
         pub fn cancel(s: *S) void {
-- 
2.54.0


From 376320a5e9bfc32162c81b592784e6f54aeae62b Mon Sep 17 00:00:00 2001
From: Brandon Black <bblack@wikimedia.org>
Date: Wed, 14 Jan 2026 18:15:18 -0600
Subject: [PATCH 002/499] Io.Select: do not swallow error.Canceled of task

---
 lib/std/Io.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 18aa1e127abb1d679439f4ed8e28be01f2d315d7..38ed8c865a0eacee50db950cc707d9e2a32b3bc3 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1269,10 +1269,13 @@ pub fn Select(comptime U: type) type {
                 args: @TypeOf(args),
                 fn start(type_erased_context: *const anyopaque) Cancelable!void {
                     const context: *const @This() = @ptrCast(@alignCast(type_erased_context));
-                    const elem = @unionInit(U, @tagName(field), @call(.auto, function, context.args));
+                    const raw_result = @call(.auto, function, context.args);
+                    const elem = @unionInit(U, @tagName(field), raw_result);
                     context.select.queue.putOneUncancelable(context.select.io, elem) catch |err| switch (err) {
                         error.Closed => unreachable,
                     };
+                    if (@typeInfo(@TypeOf(raw_result)) == .error_union)
+                        raw_result catch |err| if (err == error.Canceled) return error.Canceled;
                 }
             };
             const context: Context = .{ .select = s, .args = args };
-- 
2.54.0


From 6b733537abec526a878c3fd2f62d7ec2386ded56 Mon Sep 17 00:00:00 2001
From: Brandon Black <bblack@wikimedia.org>
Date: Wed, 14 Jan 2026 18:18:29 -0600
Subject: [PATCH 003/499] Io.Select: add fn concurrent

---
 lib/std/Io.zig | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 38ed8c865a0eacee50db950cc707d9e2a32b3bc3..f757e747ca0f6b865b91fcc2a3f7dbd1b988cd59 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1283,6 +1283,46 @@ pub fn Select(comptime U: type) type {
             s.io.vtable.groupAsync(s.io.userdata, &s.group, @ptrCast(&context), .of(Context), Context.start);
         }
 
+        /// Calls `function` with `args` concurrently. The resource spawned is
+        /// owned by the select.
+        ///
+        /// `function` must have return type matching the `field` field of `Union`.
+        ///
+        /// After this function returns successfully, it is guaranteed that
+        /// `function` has been assigned a unit of concurrency, and `await` or
+        /// `cancel` must be called before the select is deinitialized.
+        ///
+        ///
+        /// Threadsafe.
+        ///
+        /// Related:
+        /// * `Io.concurrent`
+        /// * `Group.concurrent`
+        pub fn concurrent(
+            s: *S,
+            comptime field: Field,
+            function: anytype,
+            args: std.meta.ArgsTuple(@TypeOf(function)),
+        ) ConcurrentError!void {
+            const Context = struct {
+                select: *S,
+                args: @TypeOf(args),
+                fn start(type_erased_context: *const anyopaque) Cancelable!void {
+                    const context: *const @This() = @ptrCast(@alignCast(type_erased_context));
+                    const raw_result = @call(.auto, function, context.args);
+                    const elem = @unionInit(U, @tagName(field), raw_result);
+                    context.select.queue.putOneUncancelable(context.select.io, elem) catch |err| switch (err) {
+                        error.Closed => unreachable,
+                    };
+                    if (@typeInfo(@TypeOf(raw_result)) == .error_union)
+                        raw_result catch |err| if (err == error.Canceled) return error.Canceled;
+                }
+            };
+            const context: Context = .{ .select = s, .args = args };
+            try s.io.vtable.groupConcurrent(s.io.userdata, &s.group, @ptrCast(&context), .of(Context), Context.start);
+            _ = @atomicRmw(usize, &s.outstanding, .Add, 1, .monotonic);
+        }
+
         /// Blocks until another task of the select finishes.
         ///
         /// Asserts there is at least one more `outstanding` task.
-- 
2.54.0


From f67d21f736fdd058cc8607523a1a370ac1b2f58f Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 20 Jan 2026 23:14:23 +0100
Subject: [PATCH 004/499] chore(libc/musl): remove unused `ffs` impls

* forgot to remove them in the previous PR
---
 lib/libc/musl/src/misc/ffs.c   | 7 -------
 lib/libc/musl/src/misc/ffsl.c  | 7 -------
 lib/libc/musl/src/misc/ffsll.c | 7 -------
 3 files changed, 21 deletions(-)
 delete mode 100644 lib/libc/musl/src/misc/ffs.c
 delete mode 100644 lib/libc/musl/src/misc/ffsl.c
 delete mode 100644 lib/libc/musl/src/misc/ffsll.c

diff --git a/lib/libc/musl/src/misc/ffs.c b/lib/libc/musl/src/misc/ffs.c
deleted file mode 100644
index 673ce5a9758284c7eca182b32de3902c9b353b3f..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/misc/ffs.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <strings.h>
-#include "atomic.h"
-
-int ffs(int i)
-{
-	return i ? a_ctz_l(i)+1 : 0;
-}
diff --git a/lib/libc/musl/src/misc/ffsl.c b/lib/libc/musl/src/misc/ffsl.c
deleted file mode 100644
index 0105c66af9d18946ce9b3f8616c8baa6c7a55cde..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/misc/ffsl.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <strings.h>
-#include "atomic.h"
-
-int ffsl(long i)
-{
-	return i ? a_ctz_l(i)+1 : 0;
-}
diff --git a/lib/libc/musl/src/misc/ffsll.c b/lib/libc/musl/src/misc/ffsll.c
deleted file mode 100644
index 0c5ced826657993210a021f49d76560a03a416d6..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/misc/ffsll.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <strings.h>
-#include "atomic.h"
-
-int ffsll(long long i)
-{
-	return i ? a_ctz_64(i)+1 : 0;
-}
-- 
2.54.0


From 9d3e9054a7a154730261d5fae96631cc04bdef93 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 20 Jan 2026 23:17:04 +0100
Subject: [PATCH 005/499] feat(std.c): add `wasi` definition for `utsname`

---
 lib/std/c.zig | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index 8e9f5e8c44a064965fc8b614e44bd1187af2ae0e..1fa47a3121e26fcfcad7cfb2d34666b6c4d6a4a0 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -7069,6 +7069,14 @@ pub const user_desc = switch (native_os) {
 pub const utsname = switch (native_os) {
     .linux => linux.utsname,
     .emscripten => emscripten.utsname,
+    .wasi => extern struct {
+        sysname: [64:0]u8,
+        nodename: [64:0]u8,
+        release: [64:0]u8,
+        version: [64:0]u8,
+        machine: [64:0]u8,
+        domainname: [64:0]u8,
+    },
     .illumos => extern struct {
         sysname: [256:0]u8,
         nodename: [256:0]u8,
-- 
2.54.0


From 4f652fb4e36c7f2791bb4c7fb1909a897a662c3b Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 20 Jan 2026 23:18:34 +0100
Subject: [PATCH 006/499] feat(libzigc): use common implementations for
 `sys/utsname.h`

* and remove their musl/wasi implementation
---
 lib/c.zig                                     |  2 +
 lib/c/sys.zig                                 |  3 ++
 lib/c/sys/utsname.zig                         | 40 +++++++++++++++++++
 lib/libc/musl/src/misc/uname.c                |  7 ----
 .../wasi/libc-top-half/musl/src/misc/uname.c  | 32 ---------------
 src/libs/musl.zig                             |  1 -
 src/libs/wasi_libc.zig                        |  1 -
 7 files changed, 45 insertions(+), 41 deletions(-)
 create mode 100644 lib/c/sys.zig
 create mode 100644 lib/c/sys/utsname.zig
 delete mode 100644 lib/libc/musl/src/misc/uname.c
 delete mode 100644 lib/libc/wasi/libc-top-half/musl/src/misc/uname.c

diff --git a/lib/c.zig b/lib/c.zig
index dce7ae560831c04bfd3dd9580d6c71d237166694..31176d04c3ead690d17302fcf907afc639ebeced 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -25,6 +25,8 @@ comptime {
     _ = @import("c/strings.zig");
     _ = @import("c/wchar.zig");
 
+    _ = @import("c/sys.zig");
+
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         // Files specific to musl and wasi-libc.
     }
diff --git a/lib/c/sys.zig b/lib/c/sys.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d19baf1b0e963777cc9c2f96d6ed0ffb384c8943
--- /dev/null
+++ b/lib/c/sys.zig
@@ -0,0 +1,3 @@
+comptime {
+    _ = @import("sys/utsname.zig");
+}
diff --git a/lib/c/sys/utsname.zig b/lib/c/sys/utsname.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4aab4124efd2cd544b83f49c687008289127ee21
--- /dev/null
+++ b/lib/c/sys/utsname.zig
@@ -0,0 +1,40 @@
+const std = @import("std");
+const common = @import("../common.zig");
+const builtin = @import("builtin");
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        @export(&unameLinux, .{ .name = "uname", .linkage = common.linkage, .visibility = common.visibility });
+    }
+
+    if (builtin.target.isWasiLibC()) {
+        @export(&unameWasi, .{ .name = "uname", .linkage = common.linkage, .visibility = common.visibility });
+    }
+}
+
+fn unameLinux(uts: *std.os.linux.utsname) callconv(.c) c_int {
+    const linux = std.os.linux;
+
+    return switch (linux.errno(linux.uname(uts))) {
+        .SUCCESS => 0,
+        else => |err| blk: {
+            std.c._errno().* = @intFromEnum(err);
+            break :blk -1;
+        },
+    };
+}
+
+fn unameWasi(uts: *std.c.utsname) callconv(.c) c_int {
+    // note the @bitCast's for NUL termination!
+    uts.sysname[0..5].* = @bitCast("wasi".*);
+    uts.nodename[0..7].* = @bitCast("(none)".*);
+    uts.release[0..6].* = @bitCast("0.0.0".*);
+    uts.version[0..6].* = @bitCast("0.0.0".*);
+    uts.machine[0..7].* = @bitCast(switch (builtin.target.cpu.arch) {
+        .wasm32 => "wasm32",
+        .wasm64 => "wasm64",
+        else => comptime unreachable,
+    }.*);
+    uts.domainname[0..7].* = @bitCast("(none)".*);
+    return 0;
+}
diff --git a/lib/libc/musl/src/misc/uname.c b/lib/libc/musl/src/misc/uname.c
deleted file mode 100644
index 55ea3420232c9999bd3bbcf5f31c5bf74946ac9e..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/misc/uname.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <sys/utsname.h>
-#include "syscall.h"
-
-int uname(struct utsname *uts)
-{
-	return syscall(SYS_uname, uts);
-}
diff --git a/lib/libc/wasi/libc-top-half/musl/src/misc/uname.c b/lib/libc/wasi/libc-top-half/musl/src/misc/uname.c
deleted file mode 100644
index 36e816aa27117a8d0fc3796094fda5569802df6a..0000000000000000000000000000000000000000
--- a/lib/libc/wasi/libc-top-half/musl/src/misc/uname.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <sys/utsname.h>
-#ifdef __wasilibc_unmodified_upstream // Implement uname with placeholders
-#include "syscall.h"
-#else
-#include <string.h>
-#endif
-
-int uname(struct utsname *uts)
-{
-#ifdef __wasilibc_unmodified_upstream // Implement uname with placeholders
-	return syscall(SYS_uname, uts);
-#else
-	// Just fill in the fields with placeholder values.
-	strcpy(uts->sysname, "wasi");
-	strcpy(uts->nodename, "(none)");
-	strcpy(uts->release, "0.0.0");
-	strcpy(uts->version, "0.0.0");
-#if defined(__wasm32__)
-	strcpy(uts->machine, "wasm32");
-#elif defined(__wasm64__)
-	strcpy(uts->machine, "wasm64");
-#else
-	strcpy(uts->machine, "unknown");
-#endif
-#ifdef _GNU_SOURCE
-	strcpy(uts->domainname, "(none)");
-#else
-	strcpy(uts->__domainname, "(none)");
-#endif
-	return 0;
-#endif
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 25d31accf77df2315ee644bfb94c5b550ca33701..295e5169308a3200bbeec50a709b0035b68d72ca 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -1156,7 +1156,6 @@ const src_files = [_][]const u8{
     "musl/src/misc/setrlimit.c",
     "musl/src/misc/syscall.c",
     "musl/src/misc/syslog.c",
-    "musl/src/misc/uname.c",
     "musl/src/misc/wordexp.c",
     "musl/src/mman/madvise.c",
     "musl/src/mman/mincore.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index db222c115f25fcefa3efa7132bbb06e00ba00225..61d0f2cd0cb2d432d130aecd4b5f2b97fef1ad81 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -1054,7 +1054,6 @@ const libc_top_half_src_files = [_][]const u8{
     "wasi/libc-top-half/musl/src/math/sinhf.c",
     "wasi/libc-top-half/musl/src/misc/fmtmsg.c",
     "wasi/libc-top-half/musl/src/misc/nftw.c",
-    "wasi/libc-top-half/musl/src/misc/uname.c",
     "wasi/libc-top-half/musl/src/prng/random.c",
     "wasi/libc-top-half/musl/src/regex/glob.c",
     "wasi/libc-top-half/musl/src/regex/regcomp.c",
-- 
2.54.0


From 1ab6bf59a6722f816edce15574c2dfcaefeebd31 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Wed, 21 Jan 2026 12:02:08 +0100
Subject: [PATCH 007/499] feat(libzigc): add common linux errno syscall helper

---
 lib/c/common.zig      | 14 ++++++++++++++
 lib/c/sys/utsname.zig | 10 +---------
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/lib/c/common.zig b/lib/c/common.zig
index 4419b65cc61a920068cb5fe44bdccf8979256da7..09dc5a8c0cbf2fe18160a2310ab4d33ffbfa7545 100644
--- a/lib/c/common.zig
+++ b/lib/c/common.zig
@@ -13,3 +13,17 @@ pub const visibility: std.builtin.SymbolVisibility = if (linkage != .internal)
     .hidden
 else
     .default;
+
+/// Checks whether the syscall has had an error, storing it in `std.c.errno` and returning -1.
+/// Otherwise returns the result.
+pub fn linuxErrno(r: usize) isize {
+    const linux = std.os.linux;
+
+    return switch (linux.errno(r)) {
+        .SUCCESS => @bitCast(r),
+        else => |err| blk: {
+            std.c._errno().* = @intFromEnum(err);
+            break :blk -1;
+        },
+    };
+}
diff --git a/lib/c/sys/utsname.zig b/lib/c/sys/utsname.zig
index 4aab4124efd2cd544b83f49c687008289127ee21..06f849ba6df4e8aa642e1361e6f9e5d57fff7367 100644
--- a/lib/c/sys/utsname.zig
+++ b/lib/c/sys/utsname.zig
@@ -13,15 +13,7 @@ comptime {
 }
 
 fn unameLinux(uts: *std.os.linux.utsname) callconv(.c) c_int {
-    const linux = std.os.linux;
-
-    return switch (linux.errno(linux.uname(uts))) {
-        .SUCCESS => 0,
-        else => |err| blk: {
-            std.c._errno().* = @intFromEnum(err);
-            break :blk -1;
-        },
-    };
+    return @intCast(common.linuxErrno(std.os.linux.uname(uts)));
 }
 
 fn unameWasi(uts: *std.c.utsname) callconv(.c) c_int {
-- 
2.54.0


From fc59f0e7f0681096cf99fbd27330ed7c5ba5ffaa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 15 Jan 2026 08:18:54 +0100
Subject: [PATCH 008/499] std.Io.test: skip atime check in `setTimestamps` on
 NetBSD

---
 lib/std/Io/test.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 6d06ebacaaefffcec8d1b4f377b38bb983a42f78..0842f5d092ec2a6d2fb5717f5bfe3515cc82d948 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -181,7 +181,10 @@ test "setTimestamps" {
         .modify_timestamp = .{ .new = stat_old.mtime.subDuration(.fromSeconds(5)) },
     });
     const stat_new = try file.stat(io);
-    if (stat_old.atime) |old_atime| try expect(stat_new.atime.?.nanoseconds < old_atime.nanoseconds);
+    // NetBSD with noatime will just not update the timestamp, and noatime is default in at least NetBSD 11+.
+    if (builtin.os.tag != .netbsd) {
+        if (stat_old.atime) |old_atime| try expect(stat_new.atime.?.nanoseconds < old_atime.nanoseconds);
+    }
     try expect(stat_new.mtime.nanoseconds < stat_old.mtime.nanoseconds);
 }
 
-- 
2.54.0


From 32f977a4b7b17b774ff09157a902d4e22adf7384 Mon Sep 17 00:00:00 2001
From: Michael Dusan <michael.dusan@gmail.com>
Date: Fri, 16 Jan 2026 15:38:01 -0500
Subject: [PATCH 009/499] std.fs.test: fix tests using Dir.realPath

* add fn isRealPathSupported
* incorporate into tests that depends on Dir.realPath
---
 lib/std/fs/test.zig    | 60 ++++++++++++++++++++----------------------
 lib/std/posix/test.zig |  5 ++--
 2 files changed, 32 insertions(+), 33 deletions(-)

diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 2d5dd78b23c753bc49d50b02785330728dfa8d60..a1987765659a54263d263d93e6ea2e2c73220414 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -20,6 +20,28 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 const expectError = std.testing.expectError;
 const tmpDir = std.testing.tmpDir;
 
+// This is kept in sync with Io.Threaded.realPath .
+pub inline fn isRealPathSupported() bool {
+    return switch (native_os) {
+        .windows,
+        .driverkit,
+        .ios,
+        .maccatalyst,
+        .macos,
+        .tvos,
+        .visionos,
+        .watchos,
+        .linux,
+        .serenity,
+        .illumos,
+        .freebsd,
+        => true,
+        .dragonfly => builtin.os.version_range.semver.min.order(.{ .major = 6, .minor = 0, .patch = 0 }) != .lt,
+        .netbsd => builtin.os.version_range.semver.min.order(.{ .major = 10, .minor = 0, .patch = 0 }) != .lt,
+        else => false,
+    };
+}
+
 const PathType = enum {
     relative,
     absolute,
@@ -28,25 +50,7 @@ const PathType = enum {
     fn isSupported(self: PathType, target_os: std.Target.Os) bool {
         return switch (self) {
             .relative => true,
-            .absolute => switch (target_os.tag) {
-                .windows,
-                .driverkit,
-                .ios,
-                .maccatalyst,
-                .macos,
-                .tvos,
-                .visionos,
-                .watchos,
-                .linux,
-                .illumos,
-                .freebsd,
-                .serenity,
-                => true,
-
-                .dragonfly => target_os.version_range.semver.max.order(.{ .major = 6, .minor = 0, .patch = 0 }) != .lt,
-                .netbsd => target_os.version_range.semver.max.order(.{ .major = 10, .minor = 0, .patch = 0 }) != .lt,
-                else => false,
-            },
+            .absolute => isRealPathSupported(),
             .unc => target_os.tag == .windows,
         };
     }
@@ -314,8 +318,7 @@ test "openDir" {
 }
 
 test "accessAbsolute" {
-    if (native_os == .wasi) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!isRealPathSupported()) return error.SkipZigTest;
 
     const io = testing.io;
     const gpa = testing.allocator;
@@ -330,8 +333,7 @@ test "accessAbsolute" {
 }
 
 test "openDirAbsolute" {
-    if (native_os == .wasi) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!isRealPathSupported()) return error.SkipZigTest;
 
     const io = testing.io;
     const gpa = testing.allocator;
@@ -428,8 +430,7 @@ test "openDir non-cwd parent '..'" {
 }
 
 test "readLinkAbsolute" {
-    if (native_os == .wasi) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!isRealPathSupported()) return error.SkipZigTest;
 
     const io = testing.io;
 
@@ -645,8 +646,7 @@ fn contains(entries: *const std.array_list.Managed(Dir.Entry), el: Dir.Entry) bo
 }
 
 test "Dir.realPath smoke test" {
-    if (native_os == .wasi) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!isRealPathSupported()) return error.SkipZigTest;
 
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
@@ -1074,8 +1074,7 @@ test "rename" {
 }
 
 test "renameAbsolute" {
-    if (native_os == .wasi) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!isRealPathSupported()) return error.SkipZigTest;
 
     const io = testing.io;
 
@@ -2029,8 +2028,7 @@ test "'.' and '..' in Dir functions" {
 }
 
 test "'.' and '..' in absolute functions" {
-    if (native_os == .wasi) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!isRealPathSupported()) return error.SkipZigTest;
 
     const io = testing.io;
 
diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig
index 616c6901c0a935521288991c4c67c30e095e5fe7..e720c4a4e6d23aee4573fa082582e5e0c4c066e8 100644
--- a/lib/std/posix/test.zig
+++ b/lib/std/posix/test.zig
@@ -20,6 +20,8 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 const expectError = std.testing.expectError;
 const tmpDir = std.testing.tmpDir;
 
+const fstest = @import("../fs/test.zig");
+
 test "check WASI CWD" {
     if (native_os == .wasi) {
         const cwd: Dir = .cwd();
@@ -444,9 +446,8 @@ test "getppid" {
 }
 
 test "rename smoke test" {
-    if (native_os == .wasi) return error.SkipZigTest;
     if (native_os == .windows) return error.SkipZigTest;
-    if (native_os == .openbsd) return error.SkipZigTest;
+    if (!fstest.isRealPathSupported()) return error.SkipZigTest;
 
     const io = testing.io;
     const gpa = testing.allocator;
-- 
2.54.0


From a3ea3bd31dc0b8c6ff98c9bc95ffcd36bd8aba82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 19 Jan 2026 18:46:00 +0100
Subject: [PATCH 010/499] std: NetBSD doesn't have a reliable F_GETPATH

It can fail arbitrarily with ENOENT if the kernel happens to not have the FD in
its name cache. That makes it useless for our purposes.

closes https://codeberg.org/ziglang/zig/issues/30843
---
 lib/std/Io/Threaded.zig | 2 +-
 lib/std/fs/test.zig     | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index daca7bf55ce9819575800e8432f4a40a6e980f19..f190cc7146a2de5a771fc24adcdd2813b92d0b79 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -5209,7 +5209,7 @@ fn fileRealPathPosix(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.R
 
 fn realPathPosix(fd: posix.fd_t, out_buffer: []u8) File.RealPathError!usize {
     switch (native_os) {
-        .netbsd, .dragonfly, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
+        .dragonfly, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
             var sufficient_buffer: [posix.PATH_MAX]u8 = undefined;
             @memset(&sufficient_buffer, 0);
             const syscall: Syscall = try .start();
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index a1987765659a54263d263d93e6ea2e2c73220414..63bd75748b5a3d484ea7eaf65333de5ce6abcfe1 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -37,7 +37,6 @@ pub inline fn isRealPathSupported() bool {
         .freebsd,
         => true,
         .dragonfly => builtin.os.version_range.semver.min.order(.{ .major = 6, .minor = 0, .patch = 0 }) != .lt,
-        .netbsd => builtin.os.version_range.semver.min.order(.{ .major = 10, .minor = 0, .patch = 0 }) != .lt,
         else => false,
     };
 }
-- 
2.54.0


From 35a191ec1ca8b39ce6b9460e00a5efaf56851345 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 21 Jan 2026 13:52:14 +0100
Subject: [PATCH 011/499] std.Io.Threaded: fix futex timeout race handling

---
 lib/std/Io/Threaded.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index f190cc7146a2de5a771fc24adcdd2813b92d0b79..c42545563c37cdf9bdcd2643ec9dc6c16b3c58a2 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -15791,7 +15791,7 @@ const parking_futex = struct {
                 );
                 switch (old_status.cancelation) {
                     .parked => {}, // state updated to `.none`
-                    .none => unreachable, // if another `wake` call is unparking this thread, it should have removed it from the list
+                    .none => continue, // race with timeout; they are about to lock `bucket.mutex` and remove themselves from the bucket
                     .canceling => continue, // race with a canceler who hasn't called `removeCanceledWaiter` yet
                     .canceled => unreachable,
                     .blocked => unreachable,
-- 
2.54.0


From 9f33c339c72d8aff92aefea01331b76a7829eb12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 19 Jan 2026 14:37:09 +0100
Subject: [PATCH 012/499] std.fs.test: fix `file operations on directories` on
 NetBSD

As noted earlier in this test, reading directories does not fail on NetBSD.
---
 lib/std/fs/test.zig | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 63bd75748b5a3d484ea7eaf65333de5ce6abcfe1..4d7077bfc31ed62cf3597e6cf7df24a6dbc058a6 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -845,9 +845,11 @@ test "file operations on directories" {
                 defer handle.close(io);
 
                 // Reading from the handle should fail
-                var buf: [1]u8 = undefined;
-                try expectError(error.IsDir, handle.readStreaming(io, &.{&buf}));
-                try expectError(error.IsDir, handle.readPositional(io, &.{&buf}, 0));
+                if (native_os != .netbsd) {
+                    var buf: [1]u8 = undefined;
+                    try expectError(error.IsDir, handle.readStreaming(io, &.{&buf}));
+                    try expectError(error.IsDir, handle.readPositional(io, &.{&buf}, 0));
+                }
             }
             try expectError(error.IsDir, ctx.dir.openFile(io, test_dir_name, .{ .allow_directory = false, .mode = .read_only }));
 
-- 
2.54.0


From eb3f16db5e20a7de0695e1a42ff32526faaff9f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 19 Jan 2026 18:49:32 +0100
Subject: [PATCH 013/499] test: clarify that `self_exe_symlink` fails on NetBSD
 due to bad F_GETPATH

closes https://codeberg.org/ziglang/zig/issues/30841
---
 test/standalone/self_exe_symlink/build.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/standalone/self_exe_symlink/build.zig b/test/standalone/self_exe_symlink/build.zig
index 1a0c8f054204d687eeeba736863c68363518e92b..9e031dcdaab91b3624ee8ea5ae6c0916d56e53b7 100644
--- a/test/standalone/self_exe_symlink/build.zig
+++ b/test/standalone/self_exe_symlink/build.zig
@@ -9,8 +9,8 @@ pub fn build(b: *std.Build) void {
     const optimize: std.builtin.OptimizeMode = .Debug;
     const target = b.graph.host;
 
-    if (target.result.os.tag == .netbsd) return; // https://codeberg.org/ziglang/zig/issues/30841
-    if (target.result.os.tag == .openbsd) return; // realpath not supported
+    if (target.result.os.tag == .netbsd) return; // F_GETPATH not reliable
+    if (target.result.os.tag == .openbsd) return; // F_GETPATH not supported
 
     const main = b.addExecutable(.{
         .name = "main",
-- 
2.54.0


From b7a4756e1dd4d35da8f4c14dde1e84cca16d4833 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 15 Jan 2026 11:13:20 +0100
Subject: [PATCH 014/499] langref: disable @cImport tests on NetBSD

https://github.com/Vexu/arocc/issues/960
---
 doc/langref/cImport_builtin.zig      | 1 +
 doc/langref/verbose_cimport_flag.zig | 1 +
 2 files changed, 2 insertions(+)

diff --git a/doc/langref/cImport_builtin.zig b/doc/langref/cImport_builtin.zig
index daed710f9ddbf826f361141297d670f6e2fca66d..e0cdf7bc2793a6fd0930f7387c28f7fde8e610f4 100644
--- a/doc/langref/cImport_builtin.zig
+++ b/doc/langref/cImport_builtin.zig
@@ -4,6 +4,7 @@ const c = @cImport({
     @cInclude("stdio.h");
 });
 pub fn main() void {
+    if (@import("builtin").os.tag == .netbsd) return; // https://github.com/Vexu/arocc/issues/960
     _ = c.printf("hello\n");
 }
 
diff --git a/doc/langref/verbose_cimport_flag.zig b/doc/langref/verbose_cimport_flag.zig
index 82b83073782d0d24ed00ab9b24e6e720cffa6a7f..3adc37b5078e961c92a0a6f976037802263e9d6a 100644
--- a/doc/langref/verbose_cimport_flag.zig
+++ b/doc/langref/verbose_cimport_flag.zig
@@ -3,6 +3,7 @@ const c = @cImport({
     @cInclude("stdio.h");
 });
 pub fn main() void {
+    if (@import("builtin").os.tag == .netbsd) return; // https://github.com/Vexu/arocc/issues/960
     _ = c;
 }
 
-- 
2.54.0


From 85580951a7755cf418776ed93ed9c5ad3011c3e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 28 Nov 2025 01:45:23 +0100
Subject: [PATCH 015/499] ci: add x86_64-netbsd scripts

---
 ci/x86_64-netbsd-debug.sh   | 62 +++++++++++++++++++++++++++++++++
 ci/x86_64-netbsd-release.sh | 68 +++++++++++++++++++++++++++++++++++++
 2 files changed, 130 insertions(+)
 create mode 100755 ci/x86_64-netbsd-debug.sh
 create mode 100755 ci/x86_64-netbsd-release.sh

diff --git a/ci/x86_64-netbsd-debug.sh b/ci/x86_64-netbsd-debug.sh
new file mode 100755
index 0000000000000000000000000000000000000000..68e9081f3ba040c83e4116b194ba17a46692798e
--- /dev/null
+++ b/ci/x86_64-netbsd-debug.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+
+# Requires cmake ninja-build
+
+set -x
+set -e
+
+TARGET="x86_64-netbsd-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
+PREFIX="$HOME/deps/$CACHE_BASENAME"
+ZIG="$PREFIX/bin/zig"
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+mkdir build-debug
+cd build-debug
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Debug \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja \
+  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
+  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
+# https://github.com/ziglang/zig/issues/22213
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+stage3-debug/bin/zig build test docs \
+  --maxrss ${ZSF_MAX_RSS:-0} \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib" \
+  --test-timeout 2m
+
+stage3-debug/bin/zig build \
+  --prefix stage4-debug \
+  -Denable-llvm \
+  -Dno-lib \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3-debug/bin/zig version)"
+
+stage4-debug/bin/zig test ../test/behavior.zig
diff --git a/ci/x86_64-netbsd-release.sh b/ci/x86_64-netbsd-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..225a527686ac06cc1da2241f0fb624956f2d5a58
--- /dev/null
+++ b/ci/x86_64-netbsd-release.sh
@@ -0,0 +1,68 @@
+#!/bin/sh
+
+# Requires cmake ninja-build
+
+set -x
+set -e
+
+TARGET="x86_64-netbsd-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
+PREFIX="$HOME/deps/$CACHE_BASENAME"
+ZIG="$PREFIX/bin/zig"
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+mkdir build-release
+cd build-release
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-release" \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja \
+  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
+  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
+# https://github.com/ziglang/zig/issues/22213
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+stage3-release/bin/zig build test docs \
+  --maxrss ${ZSF_MAX_RSS:-0} \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib" \
+  --test-timeout 2m
+
+# Ensure that stage3 and stage4 are byte-for-byte identical.
+stage3-release/bin/zig build \
+  --prefix stage4-release \
+  -Denable-llvm \
+  -Dno-lib \
+  -Doptimize=ReleaseFast \
+  -Dstrip \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3-release/bin/zig version)"
+
+# diff returns an error code if the files differ.
+echo "If the following command fails, it means nondeterminism has been"
+echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
+diff stage3-release/bin/zig stage4-release/bin/zig
-- 
2.54.0


From 7337946875382402ae81ab8f08e27bd5ecd45ef4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 28 Nov 2025 01:46:21 +0100
Subject: [PATCH 016/499] ci: enable x86_64-netbsd in the workflow

---
 .forgejo/workflows/ci.yaml | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 64085d1da6d03820b3ed8b36dacdd16f88df5f10..7cc50e71c302fe054f49f25d3ee8f262a5d4ea77 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -197,6 +197,27 @@ jobs:
         run: sh ci/x86_64-linux-release.sh
         timeout-minutes: 360
 
+  x86_64-netbsd-debug:
+    runs-on: [self-hosted, x86_64-netbsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/x86_64-netbsd-debug.sh
+        timeout-minutes: 120
+  x86_64-netbsd-release:
+    runs-on: [self-hosted, x86_64-netbsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/x86_64-netbsd-release.sh
+        timeout-minutes: 120
+
   x86_64-openbsd-debug:
     runs-on: [self-hosted, x86_64-openbsd]
     steps:
-- 
2.54.0


From 953ca759c2446adc21648a9017b656ac84171291 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 21 Jan 2026 15:15:43 +0100
Subject: [PATCH 017/499] ci: disable incremental tests

Too much flakiness across the board: https://codeberg.org/ziglang/zig/issues?q=&type=all&sort=relevance&labels=747060&state=open&milestone=0&project=0&assignee=0&poster=0
---
 ci/aarch64-linux-debug.sh       | 1 +
 ci/aarch64-linux-release.sh     | 1 +
 ci/aarch64-macos-debug.sh       | 1 +
 ci/aarch64-macos-release.sh     | 1 +
 ci/aarch64-windows.ps1          | 1 +
 ci/loongarch64-linux-debug.sh   | 1 +
 ci/loongarch64-linux-release.sh | 1 +
 ci/powerpc64le-linux-debug.sh   | 1 +
 ci/powerpc64le-linux-release.sh | 1 +
 ci/s390x-linux-debug.sh         | 1 +
 ci/s390x-linux-release.sh       | 1 +
 ci/x86_64-freebsd-debug.sh      | 1 +
 ci/x86_64-freebsd-release.sh    | 1 +
 ci/x86_64-linux-debug-llvm.sh   | 1 +
 ci/x86_64-linux-debug.sh        | 1 +
 ci/x86_64-linux-release.sh      | 1 +
 ci/x86_64-netbsd-debug.sh       | 1 +
 ci/x86_64-netbsd-release.sh     | 1 +
 ci/x86_64-openbsd-debug.sh      | 1 +
 ci/x86_64-openbsd-release.sh    | 1 +
 20 files changed, 20 insertions(+)

diff --git a/ci/aarch64-linux-debug.sh b/ci/aarch64-linux-debug.sh
index 7a4a6daa2aef60e1a9194184b1307f85992db3de..37a09b539845be9864c06f336eca482ab02983c9 100755
--- a/ci/aarch64-linux-debug.sh
+++ b/ci/aarch64-linux-debug.sh
@@ -47,6 +47,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/aarch64-linux-release.sh b/ci/aarch64-linux-release.sh
index 39ad9767ab62264b19846ef8bc22e2d6ad23ed85..8cde024ab11450376913d68816fd9d02a3a9c00e 100755
--- a/ci/aarch64-linux-release.sh
+++ b/ci/aarch64-linux-release.sh
@@ -47,6 +47,7 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/aarch64-macos-debug.sh b/ci/aarch64-macos-debug.sh
index 7dc60c1f4ed13f8835538a2609955423ef8d551e..369afc8d9e94a02ed77965bffc9692a5b5e344c4 100755
--- a/ci/aarch64-macos-debug.sh
+++ b/ci/aarch64-macos-debug.sh
@@ -47,6 +47,7 @@ stage3-debug/bin/zig build test docs \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --test-timeout 2m
 
diff --git a/ci/aarch64-macos-release.sh b/ci/aarch64-macos-release.sh
index 00b6571f170a7fece1dcfb53755f9b271f438aae..f7e6ae6fd3f4dba1970b94f6bc8e98305b2585be 100755
--- a/ci/aarch64-macos-release.sh
+++ b/ci/aarch64-macos-release.sh
@@ -46,6 +46,7 @@ stage3-release/bin/zig build test docs \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --test-timeout 2m
 
diff --git a/ci/aarch64-windows.ps1 b/ci/aarch64-windows.ps1
index 96e07642565019c9a805ecc8c5ac29f461341df1..57d77993519f230c2fc6e14de5a7e6957c51062a 100644
--- a/ci/aarch64-windows.ps1
+++ b/ci/aarch64-windows.ps1
@@ -60,6 +60,7 @@ Write-Output "Main test suite..."
   --search-prefix "$PREFIX_PATH" `
   -Dstatic-llvm `
   -Dskip-non-native `
+  -Dskip-test-incremental `
   -Denable-symlinks-windows `
   --test-timeout 30m
 CheckLastExitCode
diff --git a/ci/loongarch64-linux-debug.sh b/ci/loongarch64-linux-debug.sh
index 4cba17b0319039daf2d132ece4908cfdf542cffa..2d966f37427b1408febbc92abd516cebca096047 100755
--- a/ci/loongarch64-linux-debug.sh
+++ b/ci/loongarch64-linux-debug.sh
@@ -48,6 +48,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/loongarch64-linux-release.sh b/ci/loongarch64-linux-release.sh
index 5b05284d26668d01020f204f09d3a73921883ce5..558177a8d99ea2c6885cb2ab0d405cecf4cb8ca5 100755
--- a/ci/loongarch64-linux-release.sh
+++ b/ci/loongarch64-linux-release.sh
@@ -48,6 +48,7 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/powerpc64le-linux-debug.sh b/ci/powerpc64le-linux-debug.sh
index 1b9a51e44debff61729207ec1529e1d494b8c84b..2875dcba955eeee80cda7eeadc38b3a0526f01be 100755
--- a/ci/powerpc64le-linux-debug.sh
+++ b/ci/powerpc64le-linux-debug.sh
@@ -48,6 +48,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   -Dcpu=native+longcall \
   --search-prefix "$PREFIX" \
diff --git a/ci/powerpc64le-linux-release.sh b/ci/powerpc64le-linux-release.sh
index 77e1ca803ae27db49ed7a2b8fed48392f485c4d4..fffcbe2bd2c8bc72f18f21db76b557df1f1b8798 100755
--- a/ci/powerpc64le-linux-release.sh
+++ b/ci/powerpc64le-linux-release.sh
@@ -48,6 +48,7 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   -Dcpu=native+longcall \
   --search-prefix "$PREFIX" \
diff --git a/ci/s390x-linux-debug.sh b/ci/s390x-linux-debug.sh
index ffe4d0f02b3cada3b36e24fcc3572a1a14d5b389..a76ed6f04df534ee6d124bc0848a0d8ce3b0669f 100755
--- a/ci/s390x-linux-debug.sh
+++ b/ci/s390x-linux-debug.sh
@@ -48,6 +48,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/s390x-linux-release.sh b/ci/s390x-linux-release.sh
index 7fb6cd3641fa73752ca4f6eb1967f1a2de9dd8bf..0a9b82620d5a9176a3542b5fd953054ee4f1feed 100755
--- a/ci/s390x-linux-release.sh
+++ b/ci/s390x-linux-release.sh
@@ -48,6 +48,7 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-freebsd-debug.sh b/ci/x86_64-freebsd-debug.sh
index a4d7034325b33dc92b9d8ba97442d4449ad6a4c5..8bf492540eadd7cc68db8d43d06a5c0296165ab3 100755
--- a/ci/x86_64-freebsd-debug.sh
+++ b/ci/x86_64-freebsd-debug.sh
@@ -53,6 +53,7 @@ stage3-debug/bin/zig build test docs \
   -Dskip-openbsd \
   -Dskip-windows \
   -Dskip-darwin \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-freebsd-release.sh b/ci/x86_64-freebsd-release.sh
index 0ce708c63d7715c4e6ad4e4e3927d4a100b9f65e..44c4e76da2558d4fd399cee1452f4bc76ea8404d 100755
--- a/ci/x86_64-freebsd-release.sh
+++ b/ci/x86_64-freebsd-release.sh
@@ -53,6 +53,7 @@ stage3-release/bin/zig build test docs \
   -Dskip-openbsd \
   -Dskip-windows \
   -Dskip-darwin \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index 2696ac60e79f8c25e7ab493f78df7d3f7dca80cc..6ef1b5a00939d8adfb1e2c52f555ce6593c03a25 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -62,6 +62,7 @@ stage3-debug/bin/zig build test docs \
   -Dskip-openbsd \
   -Dskip-windows \
   -Dskip-darwin \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index baba340333404914f5ed1dbf63c89053a62d6f84..d644d5e6439c586a02f97fc29122d223d8bffa18 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -62,6 +62,7 @@ stage3-debug/bin/zig build test docs \
   -Dskip-windows \
   -Dskip-darwin \
   -Dskip-llvm \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 56ce115e80b18cd4bc310eea8a1bab995eb61212..99781406e273ffd10dccbe3e2f20d3fdda08b55c 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -62,6 +62,7 @@ stage3-release/bin/zig build test docs \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
+  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-netbsd-debug.sh b/ci/x86_64-netbsd-debug.sh
index 68e9081f3ba040c83e4116b194ba17a46692798e..416ab6a5e0168464e4295d1dc54c5e2c19ac4366 100755
--- a/ci/x86_64-netbsd-debug.sh
+++ b/ci/x86_64-netbsd-debug.sh
@@ -47,6 +47,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-netbsd-release.sh b/ci/x86_64-netbsd-release.sh
index 225a527686ac06cc1da2241f0fb624956f2d5a58..d8c54ca28d095b3a7e65a53fab1f572162fc4ea5 100755
--- a/ci/x86_64-netbsd-release.sh
+++ b/ci/x86_64-netbsd-release.sh
@@ -47,6 +47,7 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-openbsd-debug.sh b/ci/x86_64-openbsd-debug.sh
index 133c8dd4d642a9d4a019d297a3648567231d6078..58363e52d3b9339395b4270f35f9e6b9427d7df1 100755
--- a/ci/x86_64-openbsd-debug.sh
+++ b/ci/x86_64-openbsd-debug.sh
@@ -47,6 +47,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-openbsd-release.sh b/ci/x86_64-openbsd-release.sh
index 535b1a147166a1b724dd39358db56f18f17e09cd..ebdaac1ee0c4e0c092929534517096bd5051a450 100755
--- a/ci/x86_64-openbsd-release.sh
+++ b/ci/x86_64-openbsd-release.sh
@@ -47,6 +47,7 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
+  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
-- 
2.54.0


From 3245eddcb12b5023bbbbd63eacb5eaf4968be9cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 21 Jan 2026 17:53:11 +0100
Subject: [PATCH 018/499] musl: fix typo in
 171b1046408bca46508ed205ff4f9a3ee4c95d80

---
 lib/libc/include/loongarch64-linux-musl/bits/fenv.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/libc/include/loongarch64-linux-musl/bits/fenv.h b/lib/libc/include/loongarch64-linux-musl/bits/fenv.h
index 31a10bb78eadf5f1c3c59c2e398cb9b068aeb9c6..6f98053a0dd796d4da73a17700eb31b213f7d66a 100644
--- a/lib/libc/include/loongarch64-linux-musl/bits/fenv.h
+++ b/lib/libc/include/loongarch64-linux-musl/bits/fenv.h
@@ -1,4 +1,4 @@
-#ifdef __longarch_soft_float
+#ifdef __loongarch_soft_float
 #define FE_ALL_EXCEPT 0
 #define FE_TONEAREST  0
 #else
-- 
2.54.0


From 34aa1bb94fd70c36005f08ced380898fecd9d511 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 21 Jan 2026 17:53:38 +0100
Subject: [PATCH 019/499] test-libc: enable loongarch64-linux-muslsf

---
 test/tests.zig | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/test/tests.zig b/test/tests.zig
index 7873774c2a3023995ba2b3f6c62e0d46f11ceada..179f80b3060a48642af431907e220a5966e4887b 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -2885,12 +2885,11 @@ const libc_targets: []const std.Target.Query = &.{
         .os_tag = .linux,
         .abi = .musl,
     },
-    // Macros like FE_INVALID are defined by musl, but they shouldn't.
-    // .{
-    //     .cpu_arch = .loongarch64,
-    //     .os_tag = .linux,
-    //     .abi = .muslsf,
-    // },
+    .{
+        .cpu_arch = .loongarch64,
+        .os_tag = .linux,
+        .abi = .muslsf,
+    },
     // .{
     //     .cpu_arch = .mips,
     //     .os_tag = .linux,
-- 
2.54.0


From 200fb7c2ac460ea40fc032cf95d1bd78e72b046a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 21 Jan 2026 18:46:46 +0100
Subject: [PATCH 020/499] test-libc: disable raise-race.c

---
 test/libc.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/libc.zig b/test/libc.zig
index d7f8c3cceb9f3bf5550b6615d13bad93840647f8..e1d866eb3d22293999b1307e55904147242167b4 100644
--- a/test/libc.zig
+++ b/test/libc.zig
@@ -113,7 +113,7 @@ pub fn addCases(cases: *tests.LibcContext) void {
     cases.addLibcTestCase("regression/pthread_once-deadlock.c", false, .{});
     cases.addLibcTestCase("regression/pthread_rwlock-ebusy.c", false, .{});
     cases.addLibcTestCase("regression/putenv-doublefree.c", true, .{});
-    cases.addLibcTestCase("regression/raise-race.c", false, .{});
+    // cases.addLibcTestCase("regression/raise-race.c", false, .{}); - Sometimes hangs when run natively on x86_64-linux.
     cases.addLibcTestCase("regression/regex-backref-0.c", true, .{});
     cases.addLibcTestCase("regression/regex-bracket-icase.c", true, .{});
     cases.addLibcTestCase("regression/regex-ere-backref.c", true, .{});
-- 
2.54.0


From fd3657bf8c3a2861e1b35cf36d469d342d853880 Mon Sep 17 00:00:00 2001
From: Chadwain Holness <chadwainholness@gmail.com>
Date: Tue, 20 Jan 2026 15:19:36 -0500
Subject: [PATCH 021/499] Io.Threaded: remove WSA_FLAG_OVERLAPPED from socket
 call

---
 lib/std/Io/Threaded.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c42545563c37cdf9bdcd2643ec9dc6c16b3c58a2..849a2d437512946b27cfbaeca5b55055eca32ca1 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -10824,7 +10824,7 @@ fn openSocketWsa(
 ) !ws2_32.SOCKET {
     const mode = posixSocketMode(options.mode);
     const protocol = posixProtocol(options.protocol);
-    const flags: u32 = ws2_32.WSA_FLAG_OVERLAPPED | ws2_32.WSA_FLAG_NO_HANDLE_INHERIT;
+    const flags: u32 = ws2_32.WSA_FLAG_NO_HANDLE_INHERIT;
     var syscall: Syscall = try .start();
     while (true) {
         const rc = ws2_32.WSASocketW(family, @bitCast(mode), @bitCast(protocol), null, 0, flags);
-- 
2.54.0


From 37288e53ae4e617a56fa79d5b718f3b66957d4f5 Mon Sep 17 00:00:00 2001
From: bartimaeusnek <bartimaeusnek@noreply.codeberg.org>
Date: Thu, 22 Jan 2026 19:18:47 +0100
Subject: [PATCH 022/499] std.zig.system.loongarch: implement individual cpu
 feature bit tests (#30915)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

closes #30902

Co-authored-by: bartimaeusnek <33183715+bartimaeusnek@users.noreply.github.com>
Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30915
Reviewed-by: Alex Rønne Petersen <alex@alexrp.com>
Co-authored-by: bartimaeusnek <bartimaeusnek@noreply.codeberg.org>
Co-committed-by: bartimaeusnek <bartimaeusnek@noreply.codeberg.org>
---
 lib/std/zig/system/loongarch.zig | 38 +++++++++++++++++++++++++++++---
 1 file changed, 35 insertions(+), 3 deletions(-)

diff --git a/lib/std/zig/system/loongarch.zig b/lib/std/zig/system/loongarch.zig
index cdeeb10564a140a904c8dbe4803f9a82d4f55053..7a2c62279131a70dafe52759fdb754b48d5e90fc 100644
--- a/lib/std/zig/system/loongarch.zig
+++ b/lib/std/zig/system/loongarch.zig
@@ -1,6 +1,16 @@
 const builtin = @import("builtin");
 const std = @import("std");
 
+inline fn bit(input: u32, offset: u5) bool {
+    return (input >> offset) & 1 != 0;
+}
+
+fn setFeature(cpu: *std.Target.Cpu, feature: std.Target.loongarch.Feature, enabled: bool) void {
+    const idx = @as(std.Target.Cpu.Feature.Set.Index, @intFromEnum(feature));
+
+    if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx);
+}
+
 pub fn detectNativeCpuAndFeatures(
     arch: std.Target.Cpu.Arch,
     os: std.Target.Os,
@@ -9,9 +19,6 @@ pub fn detectNativeCpuAndFeatures(
     _ = os;
     _ = query;
 
-    // Clearly this code could do better in the future by actually querying specific CPU features
-    // with the cpucfg instruction like on x86. But with the small number of well-known LoongArch
-    // models that exist at the moment, simply checking the PRID is plenty.
     var cpu: std.Target.Cpu = .{
         .arch = arch,
         .model = switch (cpucfg(0) & 0xf000) {
@@ -23,6 +30,31 @@ pub fn detectNativeCpuAndFeatures(
     };
 
     cpu.features.addFeatureSet(cpu.model.features);
+
+    const cfg1 = cpucfg(1);
+    const cfg2 = cpucfg(2);
+    const cfg3 = cpucfg(3);
+
+    setFeature(&cpu, .ual, bit(cfg1, 20));
+
+    const has_fpu = bit(cfg2, 0);
+    setFeature(&cpu, .f, has_fpu and bit(cfg2, 1));
+    setFeature(&cpu, .d, has_fpu and bit(cfg2, 2));
+
+    setFeature(&cpu, .lsx, bit(cfg2, 6));
+    setFeature(&cpu, .lasx, bit(cfg2, 7));
+    setFeature(&cpu, .lvz, bit(cfg2, 10));
+
+    setFeature(&cpu, .lbt, bit(cfg2, 18) and bit(cfg2, 19) and bit(cfg2, 20));
+
+    setFeature(&cpu, .frecipe, bit(cfg2, 25));
+    setFeature(&cpu, .div32, bit(cfg2, 26));
+    setFeature(&cpu, .lam_bh, bit(cfg2, 27));
+    setFeature(&cpu, .lamcas, bit(cfg2, 28));
+    setFeature(&cpu, .scq, bit(cfg2, 30));
+
+    setFeature(&cpu, .ld_seq_sa, bit(cfg3, 23));
+
     cpu.features.populateDependencies(cpu.arch.allFeaturesList());
 
     return cpu;
-- 
2.54.0


From 305fd06756d0a90e330c957d85738f195b94bc10 Mon Sep 17 00:00:00 2001
From: InKryption <inkryption07@gmail.com>
Date: Mon, 21 Apr 2025 15:17:39 +0200
Subject: [PATCH 023/499] Build: check if dynamic lib installed for symlinks If
 the library isn't actually installed, `generated_bin` will be null, causing
 this to panic about a missing dependency for itself; checking for this state
 avoids this.

---
 lib/std/Build/Step/Compile.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index 92db0ca0a018030abfcc41753d0c1bd1922cd5ed..941f01dd75549436a497a52b554403d57e78d4b1 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -1786,7 +1786,8 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     }
 
     if (compile.kind == .lib and compile.linkage != null and compile.linkage.? == .dynamic and
-        compile.version != null and std.Build.wantSharedLibSymLinks(compile.rootModuleTarget()))
+        compile.version != null and compile.generated_bin != null and
+        std.Build.wantSharedLibSymLinks(compile.rootModuleTarget()))
     {
         try doAtomicSymLinks(
             step,
-- 
2.54.0


From 1badb2a840c47d49b49fa685db7a1553c0a40ee7 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 22 Jan 2026 18:08:13 -0800
Subject: [PATCH 024/499] std.Io.Threaded: dirCreateFileWindows uses
 NtCreateFile directly

---
 lib/std/Io/Dir.zig           |   6 +-
 lib/std/Io/File.zig          |  30 ++++-
 lib/std/Io/File/Writer.zig   |   2 +-
 lib/std/Io/Threaded.zig      | 229 +++++++++++++++++++++++------------
 lib/std/Progress.zig         |   4 +-
 lib/std/os/windows.zig       | 134 +++++++++++++-------
 lib/std/os/windows/ntdll.zig |  18 ++-
 src/link/Lld.zig             |  14 ++-
 8 files changed, 305 insertions(+), 132 deletions(-)

diff --git a/lib/std/Io/Dir.zig b/lib/std/Io/Dir.zig
index 67d1ec849c6c34360d565ea22ab85b12c8182d07..425e220b1cfdb3d16980a29b394527ccc355cbcf 100644
--- a/lib/std/Io/Dir.zig
+++ b/lib/std/Io/Dir.zig
@@ -12,6 +12,8 @@ const Allocator = std.mem.Allocator;
 
 handle: Handle,
 
+pub const Handle = std.posix.fd_t;
+
 pub const path = std.fs.path;
 
 /// The maximum length of a file path that the operating system will accept.
@@ -396,8 +398,6 @@ pub fn walk(dir: Dir, allocator: Allocator) Allocator.Error!Walker {
     return .{ .inner = try walkSelectively(dir, allocator) };
 }
 
-pub const Handle = std.posix.fd_t;
-
 pub const PathNameError = error{
     /// Returned when an insufficient buffer is provided that cannot fit the
     /// path name.
@@ -1698,7 +1698,7 @@ pub fn copyFile(
     options: CopyFileOptions,
 ) CopyFileError!void {
     const file = try source_dir.openFile(io, source_path, .{});
-    var file_reader: File.Reader = .init(.{ .handle = file.handle }, io, &.{});
+    var file_reader: File.Reader = .init(file, io, &.{});
     defer file_reader.file.close(io);
 
     const permissions = options.permissions orelse blk: {
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index cc1a58a15e2fa78878eca1fd84458397cb4b6412..6323a39454194e58be8a53e4f8f9879cfc1daa0e 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -11,13 +11,14 @@ const Dir = std.Io.Dir;
 
 handle: Handle,
 
+pub const Handle = std.posix.fd_t;
+
 pub const Reader = @import("File/Reader.zig");
 pub const Writer = @import("File/Writer.zig");
 pub const Atomic = @import("File/Atomic.zig");
 /// Memory intended to remain consistent with file contents.
 pub const MemoryMap = @import("File/MemoryMap.zig");
 
-pub const Handle = std.posix.fd_t;
 pub const INode = std.posix.ino_t;
 pub const NLink = std.posix.nlink_t;
 pub const Uid = std.posix.uid_t;
@@ -73,15 +74,36 @@ pub const Stat = struct {
 };
 
 pub fn stdout() File {
-    return .{ .handle = if (is_windows) std.os.windows.peb().ProcessParameters.hStdOutput else std.posix.STDOUT_FILENO };
+    return switch (native_os) {
+        .windows => .{
+            .handle = std.os.windows.peb().ProcessParameters.hStdOutput,
+        },
+        else => .{
+            .handle = std.posix.STDOUT_FILENO,
+        },
+    };
 }
 
 pub fn stderr() File {
-    return .{ .handle = if (is_windows) std.os.windows.peb().ProcessParameters.hStdError else std.posix.STDERR_FILENO };
+    return switch (native_os) {
+        .windows => .{
+            .handle = std.os.windows.peb().ProcessParameters.hStdError,
+        },
+        else => .{
+            .handle = std.posix.STDERR_FILENO,
+        },
+    };
 }
 
 pub fn stdin() File {
-    return .{ .handle = if (is_windows) std.os.windows.peb().ProcessParameters.hStdInput else std.posix.STDIN_FILENO };
+    return switch (native_os) {
+        .windows => .{
+            .handle = std.os.windows.peb().ProcessParameters.hStdInput,
+        },
+        else => .{
+            .handle = std.posix.STDIN_FILENO,
+        },
+    };
 }
 
 pub const StatError = error{
diff --git a/lib/std/Io/File/Writer.zig b/lib/std/Io/File/Writer.zig
index 52bbe83513f26f6b2fdd7b8ed4686a3643363c1c..68a68e28ec706bf9b1863fd3b329c78f4255ad9a 100644
--- a/lib/std/Io/File/Writer.zig
+++ b/lib/std/Io/File/Writer.zig
@@ -101,7 +101,7 @@ pub fn moveToReader(w: *Writer) File.Reader {
     defer w.* = undefined;
     return .{
         .io = w.io,
-        .file = .{ .handle = w.file.handle },
+        .file = w.file,
         .mode = w.mode,
         .pos = w.pos,
         .interface = File.Reader.initInterface(w.interface.buffer),
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 849a2d437512946b27cfbaeca5b55055eca32ca1..42816b52767343192821a7d432568c303bcaeeee 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -571,7 +571,7 @@ const Future = struct {
         num_completed: *std.atomic.Value(u32),
         thread: ?*Thread,
     ) void {
-        var need_signal: bool = thread != null and thread.?.cancelAwaitable(.fromFuture(future));
+        var need_signal: bool = if (thread) |th| th.cancelAwaitable(.fromFuture(future)) else false;
         var timeout_ns: u64 = 1 << 10;
         while (true) {
             need_signal = need_signal and thread.?.signalCanceledSyscall(t, .fromFuture(future));
@@ -628,7 +628,7 @@ const Thread = struct {
 
     const Handle = Handle: {
         if (std.Thread.use_pthreads) break :Handle std.c.pthread_t;
-        if (builtin.target.os.tag == .windows) break :Handle windows.HANDLE;
+        if (is_windows) break :Handle windows.HANDLE;
         break :Handle void;
     };
 
@@ -1364,7 +1364,7 @@ fn worker(t: *Threaded) void {
         .id = std.Thread.getCurrentId(),
         .handle = handle: {
             if (std.Thread.use_pthreads) break :handle std.c.pthread_self();
-            if (builtin.target.os.tag == .windows) break :handle undefined; // populated below
+            if (is_windows) break :handle undefined; // populated below
         },
         .status = .init(.{
             .cancelation = .none,
@@ -1376,7 +1376,7 @@ fn worker(t: *Threaded) void {
     };
     Thread.current = &thread;
 
-    if (builtin.target.os.tag == .windows) {
+    if (is_windows) {
         assert(windows.ntdll.NtOpenThread(
             &thread.handle,
             .{
@@ -1397,7 +1397,7 @@ fn worker(t: *Threaded) void {
             &windows.teb().ClientId,
         ) == .SUCCESS);
     }
-    defer if (builtin.target.os.tag == .windows) {
+    defer if (is_windows) {
         windows.CloseHandle(thread.handle);
     };
 
@@ -3430,53 +3430,133 @@ fn dirCreateFileWindows(
     sub_path: []const u8,
     flags: File.CreateFlags,
 ) File.OpenError!File {
-    const w = windows;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
 
-    const sub_path_w_array = try w.sliceToPrefixedFileW(dir.handle, sub_path);
+    if (std.mem.eql(u8, sub_path, ".")) return error.IsDir;
+    if (std.mem.eql(u8, sub_path, "..")) return error.IsDir;
+
+    const sub_path_w_array = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
     const sub_path_w = sub_path_w_array.span();
+    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
 
-    const handle = handle: {
-        const syscall: Syscall = try .start();
-        while (true) {
-            if (w.OpenFile(sub_path_w, .{
-                .dir = dir.handle,
-                .access_mask = .{
-                    .STANDARD = .{ .SYNCHRONIZE = true },
-                    .GENERIC = .{
-                        .WRITE = true,
-                        .READ = flags.read,
-                    },
-                },
-                .creation = if (flags.exclusive)
-                    .CREATE
-                else if (flags.truncate)
-                    .OVERWRITE_IF
-                else
-                    .OPEN_IF,
-            })) |handle| {
-                syscall.finish();
-                break :handle handle;
-            } else |err| switch (err) {
-                error.OperationCanceled => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => |e| return syscall.fail(e),
-            }
-        }
+    var nt_name: windows.UNICODE_STRING = .{
+        .Length = path_len_bytes,
+        .MaximumLength = path_len_bytes,
+        .Buffer = @constCast(sub_path_w.ptr),
     };
-    errdefer w.CloseHandle(handle);
+    const attr: windows.OBJECT_ATTRIBUTES = .{
+        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
+        .Attributes = .{
+            .INHERIT = false,
+        },
+        .ObjectName = &nt_name,
+        .SecurityDescriptor = null,
+        .SecurityQualityOfService = null,
+    };
+    const create_disposition: windows.FILE.CREATE_DISPOSITION = if (flags.exclusive)
+        .CREATE
+    else if (flags.truncate)
+        .OVERWRITE_IF
+    else
+        .OPEN_IF;
+
+    const access_mask: windows.ACCESS_MASK = .{
+        .STANDARD = .{ .SYNCHRONIZE = true },
+        .GENERIC = .{
+            .WRITE = true,
+            .READ = flags.read,
+        },
+    };
+
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+
+    // There are multiple kernel bugs being worked around with retries.
+    const max_attempts = 13;
+    var attempt: u5 = 0;
+
+    var handle: windows.HANDLE = undefined;
+    var syscall: Syscall = try .start();
+    while (true) switch (windows.ntdll.NtCreateFile(
+        &handle,
+        access_mask,
+        &attr,
+        &io_status_block,
+        null,
+        .{ .NORMAL = true },
+        .VALID_FLAGS, // share access
+        create_disposition,
+        .{
+            .NON_DIRECTORY_FILE = true,
+            .IO = .SYNCHRONOUS_NONALERT,
+        },
+        null,
+        0,
+    )) {
+        .SUCCESS => {
+            syscall.finish();
+            break;
+        },
+        .CANCELLED => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .SHARING_VIOLATION => {
+            // This occurs if the file attempting to be opened is a running
+            // executable. However, there's a kernel bug: the error may be
+            // incorrectly returned for an indeterminate amount of time
+            // after an executable file is closed. Here we work around the
+            // kernel bug with retry attempts.
+            syscall.finish();
+            if (max_attempts - attempt == 0) return error.SharingViolation;
+            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            attempt += 1;
+            syscall = try .start();
+            continue;
+        },
+        .DELETE_PENDING => {
+            // This error means that there *was* a file in this location on
+            // the file system, but it was deleted. However, the OS is not
+            // finished with the deletion operation, and so this CreateFile
+            // call has failed. Here, we simulate the kernel bug being
+            // fixed by sleeping and retrying until the error goes away.
+            syscall.finish();
+            if (max_attempts - attempt == 0) return error.SharingViolation;
+            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            attempt += 1;
+            syscall = try .start();
+            continue;
+        },
+        .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
+        .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .BAD_NETWORK_PATH => return syscall.fail(error.NetworkNotFound), // \\server was not found
+        .BAD_NETWORK_NAME => return syscall.fail(error.NetworkNotFound), // \\server was found but \\server\share wasn't
+        .NO_MEDIA_IN_DEVICE => return syscall.fail(error.NoDevice),
+        .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+        .PIPE_BUSY => return syscall.fail(error.PipeBusy),
+        .PIPE_NOT_AVAILABLE => return syscall.fail(error.NoDevice),
+        .OBJECT_NAME_COLLISION => return syscall.fail(error.PathAlreadyExists),
+        .FILE_IS_A_DIRECTORY => return syscall.fail(error.IsDir),
+        .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
+        .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
+        .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
+        .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err),
+        .OBJECT_PATH_SYNTAX_BAD => |err| return syscall.ntstatusBug(err),
+        .INVALID_HANDLE => |err| return syscall.ntstatusBug(err),
+        else => |err| return syscall.unexpectedNtstatus(err),
+    };
+    errdefer windows.CloseHandle(handle);
 
-    var io_status_block: w.IO_STATUS_BLOCK = undefined;
     const exclusive = switch (flags.lock) {
         .none => return .{ .handle = handle },
         .shared => false,
         .exclusive => true,
     };
-    const syscall: Syscall = try .start();
-    while (true) switch (w.ntdll.NtLockFile(
+
+    syscall = try .start();
+    while (true) switch (windows.ntdll.NtLockFile(
         handle,
         null,
         null,
@@ -3968,7 +4048,10 @@ pub fn dirOpenFileWtf16(
     var attr: w.OBJECT_ATTRIBUTES = .{
         .Length = @sizeOf(w.OBJECT_ATTRIBUTES),
         .RootDirectory = dir_handle,
-        .Attributes = .{},
+        .Attributes = .{
+            // TODO should we set INHERIT=false?
+            //.INHERIT = false,
+        },
         .ObjectName = &nt_name,
         .SecurityDescriptor = null,
         .SecurityQualityOfService = null,
@@ -7923,15 +8006,14 @@ fn fileClose(userdata: ?*anyopaque, files: []const File) void {
     for (files) |file| posix.close(file.handle);
 }
 
-const fileReadStreaming = switch (native_os) {
-    .windows => fileReadStreamingWindows,
-    else => fileReadStreamingPosix,
-};
-
-fn fileReadStreamingPosix(userdata: ?*anyopaque, file: File, data: []const []u8) File.Reader.Error!usize {
+fn fileReadStreaming(userdata: ?*anyopaque, file: File, data: []const []u8) File.Reader.Error!usize {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
+    if (is_windows) return fileReadStreamingWindows(file, data);
+    return fileReadStreamingPosix(file, data);
+}
 
+fn fileReadStreamingPosix(file: File, data: []const []u8) File.Reader.Error!usize {
     var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
     var i: usize = 0;
     for (data) |buf| {
@@ -8013,10 +8095,7 @@ fn fileReadStreamingPosix(userdata: ?*anyopaque, file: File, data: []const []u8)
     }
 }
 
-fn fileReadStreamingWindows(userdata: ?*anyopaque, file: File, data: []const []u8) File.Reader.Error!usize {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-
+fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!usize {
     const DWORD = windows.DWORD;
     var index: usize = 0;
     while (index < data.len and data[index].len == 0) index += 1;
@@ -8059,10 +8138,7 @@ fn fileReadStreamingWindows(userdata: ?*anyopaque, file: File, data: []const []u
     }
 }
 
-fn fileReadPositionalPosix(userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-
+fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
     if (!have_preadv) @compileError("TODO implement fileReadPositionalPosix for cursed operating systems that don't support preadv (it's only Haiku)");
 
     var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
@@ -8144,15 +8220,14 @@ fn fileReadPositionalPosix(userdata: ?*anyopaque, file: File, data: []const []u8
     }
 }
 
-const fileReadPositional = switch (native_os) {
-    .windows => fileReadPositionalWindows,
-    else => fileReadPositionalPosix,
-};
-
-fn fileReadPositionalWindows(userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
+fn fileReadPositional(userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
+    if (is_windows) return fileReadPositionalWindows(file, data, offset);
+    return fileReadPositionalPosix(file, data, offset);
+}
 
+fn fileReadPositionalWindows(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
     var index: usize = 0;
     while (index < data.len and data[index].len == 0) index += 1;
     if (index == data.len) return 0;
@@ -8244,7 +8319,7 @@ fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!voi
         }
     }
 
-    if (native_os == .windows) {
+    if (is_windows) {
         const syscall: Syscall = try .start();
         while (true) {
             if (windows.kernel32.SetFilePointerEx(fd, offset, null, windows.FILE_CURRENT) != 0) {
@@ -8329,7 +8404,7 @@ fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!voi
     _ = t;
     const fd = file.handle;
 
-    if (native_os == .windows) {
+    if (is_windows) {
         // "The starting point is zero or the beginning of the file. If [FILE_BEGIN]
         // is specified, then the liDistanceToMove parameter is interpreted as an unsigned value."
         // https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-setfilepointerex
@@ -11628,7 +11703,7 @@ fn netWriteWindows(
     splat: usize,
 ) net.Stream.Writer.Error!usize {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    comptime assert(native_os == .windows);
+    comptime assert(is_windows);
 
     var iovecs: [max_iovecs_len]ws2_32.WSABUF = undefined;
     var len: u32 = 0;
@@ -11896,7 +11971,7 @@ fn netInterfaceNameResolve(
         }
     }
 
-    if (native_os == .windows) {
+    if (is_windows) {
         try Thread.checkCancel();
         @panic("TODO implement netInterfaceNameResolve for Windows");
     }
@@ -11930,7 +12005,7 @@ fn netInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interfa
         @panic("TODO implement netInterfaceName for linux");
     }
 
-    if (native_os == .windows) {
+    if (is_windows) {
         @panic("TODO implement netInterfaceName for windows");
     }
 
@@ -15247,11 +15322,13 @@ fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
 
     const int = try t.environ.zig_progress_handle;
 
-    return .{ .handle = switch (@typeInfo(Io.File.Handle)) {
-        .int => int,
-        .pointer => @ptrFromInt(int),
-        else => return error.UnsupportedOperation,
-    } };
+    return .{
+        .handle = switch (@typeInfo(Io.File.Handle)) {
+            .int => int,
+            .pointer => @ptrFromInt(int),
+            else => return error.UnsupportedOperation,
+        },
+    };
 }
 
 pub fn environString(t: *Threaded, comptime name: []const u8) ?[:0]const u8 {
@@ -15562,13 +15639,13 @@ test {
     _ = @import("Threaded/test.zig");
 }
 
-const use_parking_futex = switch (builtin.target.os.tag) {
+const use_parking_futex = switch (native_os) {
     .windows => true, // RtlWaitOnAddress is a userland implementation anyway
     .netbsd => true, // NetBSD has `futex(2)`, but it's historically been quite buggy. TODO: evaluate whether it's okay to use now.
     .illumos => true, // Illumos has no futex mechanism
     else => false,
 };
-const use_parking_sleep = switch (builtin.target.os.tag) {
+const use_parking_sleep = switch (native_os) {
     // On Windows, we can implement sleep either with `NtDelayExecution` (which is how `SleepEx` in
     // kernel32 works) or `NtWaitForAlertByThreadId` (thread parking). We're already using the
     // latter for futex, so we may as well use it for sleeping too, to maximise code reuse. I'm
@@ -15926,7 +16003,7 @@ const parking_sleep = struct {
 /// `addr_hint` has no semantic effect, but may allow the OS to optimize this operation.
 fn park(opt_deadline: ?std.Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{Timeout}!void {
     comptime assert(use_parking_futex or use_parking_sleep);
-    switch (builtin.target.os.tag) {
+    switch (native_os) {
         .windows => {
             var timeout_buf: windows.LARGE_INTEGER = undefined;
             const raw_timeout: ?*windows.LARGE_INTEGER = if (opt_deadline) |deadline| timeout: {
@@ -15980,7 +16057,7 @@ fn park(opt_deadline: ?std.Io.Clock.Timestamp, addr_hint: ?*const anyopaque) err
     }
 }
 
-const UnparkTid = switch (builtin.target.os.tag) {
+const UnparkTid = switch (native_os) {
     // `NtAlertMultipleThreadByThreadId` is weird and wants 64-bit thread handles?
     .windows => usize,
     else => std.Thread.Id,
@@ -15988,7 +16065,7 @@ const UnparkTid = switch (builtin.target.os.tag) {
 /// `addr_hint` has no semantic effect, but may allow the OS to optimize this operation.
 fn unpark(tids: []const UnparkTid, addr_hint: ?*const anyopaque) void {
     comptime assert(use_parking_futex or use_parking_sleep);
-    switch (builtin.target.os.tag) {
+    switch (native_os) {
         .windows => {
             // TODO: this condition is currently disabled because mingw-w64 does not contain this
             // symbol. Once it's added, enable this check to use the new bulk API where possible.
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 75ef13ca91f16307ca028977f5db6e0144996e77..5ccc46778b43d0260ee1a6323e13eae20e31a2c9 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -977,7 +977,9 @@ fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buff
         0..,
     ) |main_parent, *main_storage, main_index| {
         if (main_parent == .unused) continue;
-        const file: Io.File = .{ .handle = main_storage.getIpcFd() orelse continue };
+        const file: Io.File = .{
+            .handle = main_storage.getIpcFd() orelse continue,
+        };
         const opt_saved_metadata = findOld(file.handle, old_ipc_metadata_fds, old_ipc_metadata);
         var bytes_read: usize = 0;
         while (true) {
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index c94596de8e55be5c8d5689c5e4a53b815aafc7ae..262eaef049a0a6cb198b70195ad85f8356916346 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -392,6 +392,8 @@ pub const FILE = struct {
         Characteristics: ULONG,
     };
 
+    pub const USE_FILE_POINTER_POSITION = -2;
+
     // ref: um/WinBase.h
 
     pub const ATTRIBUTE_TAG_INFO = extern struct {
@@ -466,9 +468,11 @@ pub const FILE = struct {
     pub const CREATE_DISPOSITION = enum(ULONG) {
         /// If the file already exists, replace it with the given file. If it does not, create the given file.
         SUPERSEDE = 0x00000000,
-        /// If the file already exists, open it instead of creating a new file. If it does not, fail the request and do not create a new file.
+        /// If the file already exists, open it instead of creating a new file.
+        /// If it does not, fail the request and do not create a new file.
         OPEN = 0x00000001,
-        /// If the file already exists, fail the request and do not create or open the given file. If it does not, create the given file.
+        /// If the file already exists, fail the request and do not create or
+        /// open the given file. If it does not, create the given file.
         CREATE = 0x00000002,
         /// If the file already exists, open it. If it does not, create the given file.
         OPEN_IF = 0x00000003,
@@ -482,75 +486,122 @@ pub const FILE = struct {
 
     /// Define the create/open option flags
     pub const MODE = packed struct(ULONG) {
-        /// The file being created or opened is a directory file. With this flag, the CreateDisposition parameter must be set to `.CREATE`, `.FILE_OPEN`, or `.OPEN_IF`.
-        /// With this flag, other compatible CreateOptions flags include only the following: `SYNCHRONOUS_IO`, `WRITE_THROUGH`, `OPEN_FOR_BACKUP_INTENT`, and `OPEN_BY_FILE_ID`.
+        /// The file being created or opened is a directory file. With this
+        /// flag, the CreateDisposition parameter must be set to `.CREATE`,
+        /// `.FILE_OPEN`, or `.OPEN_IF`. With this flag, other compatible
+        /// CreateOptions flags include only the following: `SYNCHRONOUS_IO`,
+        /// `WRITE_THROUGH`, `OPEN_FOR_BACKUP_INTENT`, and `OPEN_BY_FILE_ID`.
         DIRECTORY_FILE: bool = false,
-        /// Applications that write data to the file must actually transfer the data into the file before any requested write operation is considered complete.
-        /// This flag is automatically set if the CreateOptions flag `NO_INTERMEDIATE_BUFFERING` is set.
+        /// Applications that write data to the file must actually transfer the
+        /// data into the file before any requested write operation is
+        /// considered complete. This flag is automatically set if the
+        /// CreateOptions flag `NO_INTERMEDIATE_BUFFERING` is set.
         WRITE_THROUGH: bool = false,
         /// All accesses to the file are sequential.
         SEQUENTIAL_ONLY: bool = false,
-        /// The file cannot be cached or buffered in a driver's internal buffers. This flag is incompatible with the DesiredAccess `FILE_APPEND_DATA` flag.
+        /// The file cannot be cached or buffered in a driver's internal
+        /// buffers. This flag is incompatible with the DesiredAccess
+        /// `FILE_APPEND_DATA` flag.
         NO_INTERMEDIATE_BUFFERING: bool = false,
         IO: enum(u2) {
             /// All operations on the file are performed asynchronously.
             ASYNCHRONOUS = 0b00,
-            /// All operations on the file are performed synchronously. Any wait on behalf of the caller is subject to premature termination from alerts.
-            /// This flag also causes the I/O system to maintain the file position context. If this flag is set, the DesiredAccess `SYNCHRONIZE` flag also must be set.
+            /// All operations on the file are performed synchronously. Any
+            /// wait on behalf of the caller is subject to premature
+            /// termination from alerts. This flag also causes the I/O system
+            /// to maintain the file position context. If this flag is set, the
+            /// DesiredAccess `SYNCHRONIZE` flag also must be set.
             SYNCHRONOUS_ALERT = 0b01,
-            /// All operations on the file are performed synchronously. Waits in the system to synchronize I/O queuing and completion are not subject to alerts.
-            /// This flag also causes the I/O system to maintain the file position context. If this flag is set, the DesiredAccess `SYNCHRONIZE` flag also must be set.
+            /// All operations on the file are performed synchronously. Waits
+            /// in the system to synchronize I/O queuing and completion are not
+            /// subject to alerts. This flag also causes the I/O system to
+            /// maintain the file position context. If this flag is set, the
+            /// DesiredAccess `SYNCHRONIZE` flag also must be set.
             SYNCHRONOUS_NONALERT = 0b10,
             _,
 
             pub const VALID_FLAGS: @This() = @enumFromInt(0b11);
         } = .ASYNCHRONOUS,
-        /// The file being opened must not be a directory file or this call fails. The file object being opened can represent a data file, a logical, virtual, or physical
-        /// device, or a volume.
+        /// The file being opened must not be a directory file or this call
+        /// fails. The file object being opened can represent a data file, a
+        /// logical, virtual, or physical device, or a volume.
         NON_DIRECTORY_FILE: bool = false,
-        /// Create a tree connection for this file in order to open it over the network. This flag is not used by device and intermediate drivers.
+        /// Create a tree connection for this file in order to open it over the
+        /// network. This flag is not used by device and intermediate drivers.
         CREATE_TREE_CONNECTION: bool = false,
-        /// Complete this operation immediately with an alternate success code of `STATUS_OPLOCK_BREAK_IN_PROGRESS` if the target file is oplocked, rather than blocking
-        /// the caller's thread. If the file is oplocked, another caller already has access to the file. This flag is not used by device and intermediate drivers.
+        /// Complete this operation immediately with an alternate success code
+        /// of `STATUS_OPLOCK_BREAK_IN_PROGRESS` if the target file is
+        /// oplocked, rather than blocking the caller's thread. If the file is
+        /// oplocked, another caller already has access to the file. This flag
+        /// is not used by device and intermediate drivers.
         COMPLETE_IF_OPLOCKED: bool = false,
-        /// If the extended attributes on an existing file being opened indicate that the caller must understand EAs to properly interpret the file, fail this request
-        /// because the caller does not understand how to deal with EAs. This flag is irrelevant for device and intermediate drivers.
+        /// If the extended attributes on an existing file being opened
+        /// indicate that the caller must understand EAs to properly interpret
+        /// the file, fail this request because the caller does not understand
+        /// how to deal with EAs. This flag is irrelevant for device and
+        /// intermediate drivers.
         NO_EA_KNOWLEDGE: bool = false,
         OPEN_REMOTE_INSTANCE: bool = false,
-        /// Accesses to the file can be random, so no sequential read-ahead operations should be performed on the file by FSDs or the system.
+        /// Accesses to the file can be random, so no sequential read-ahead
+        /// operations should be performed on the file by FSDs or the system.
         RANDOM_ACCESS: bool = false,
-        /// Delete the file when the last handle to it is passed to `NtClose`. If this flag is set, the `DELETE` flag must be set in the DesiredAccess parameter.
+        /// Delete the file when the last handle to it is passed to `NtClose`.
+        /// If this flag is set, the `DELETE` flag must be set in the
+        /// DesiredAccess parameter.
         DELETE_ON_CLOSE: bool = false,
-        /// The file name that is specified by the `ObjectAttributes` parameter includes the 8-byte file reference number for the file. This number is assigned by and
-        /// specific to the particular file system. If the file is a reparse point, the file name will also include the name of a device. Note that the FAT file system
-        /// does not support this flag. This flag is not used by device and intermediate drivers.
+        /// The file name that is specified by the `ObjectAttributes` parameter
+        /// includes the 8-byte file reference number for the file. This number
+        /// is assigned by and specific to the particular file system. If the
+        /// file is a reparse point, the file name will also include the name
+        /// of a device. Note that the FAT file system does not support this
+        /// flag. This flag is not used by device and intermediate drivers.
         OPEN_BY_FILE_ID: bool = false,
-        /// The file is being opened for backup intent. Therefore, the system should check for certain access rights and grant the caller the appropriate access to the
-        /// file before checking the DesiredAccess parameter against the file's security descriptor. This flag not used by device and intermediate drivers.
+        /// The file is being opened for backup intent. Therefore, the system
+        /// should check for certain access rights and grant the caller the
+        /// appropriate access to the file before checking the DesiredAccess
+        /// parameter against the file's security descriptor. This flag not
+        /// used by device and intermediate drivers.
         OPEN_FOR_BACKUP_INTENT: bool = false,
-        /// Suppress inheritance of `FILE_ATTRIBUTE.COMPRESSED` from the parent directory. This allows creation of a non-compressed file in a directory that is marked
-        /// compressed.
+        /// Suppress inheritance of `FILE_ATTRIBUTE.COMPRESSED` from the parent
+        /// directory. This allows creation of a non-compressed file in a
+        /// directory that is marked compressed.
         NO_COMPRESSION: bool = false,
-        /// The file is being opened and an opportunistic lock on the file is being requested as a single atomic operation. The file system checks for oplocks before it
-        /// performs the create operation and will fail the create with a return code of STATUS_CANNOT_BREAK_OPLOCK if the result would be to break an existing oplock.
-        /// For more information, see the Remarks section.
+        /// The file is being opened and an opportunistic lock on the file is
+        /// being requested as a single atomic operation. The file system
+        /// checks for oplocks before it performs the create operation and will
+        /// fail the create with a return code of STATUS_CANNOT_BREAK_OPLOCK if
+        /// the result would be to break an existing oplock. For more
+        /// information, see the Remarks section.
         ///
-        /// Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:  This flag is not supported.
+        /// Windows Server 2008, Windows Vista, Windows Server 2003 and Windows
+        /// XP:  This flag is not supported.
         ///
-        /// This flag is supported on the following file systems: NTFS, FAT, and exFAT.
+        /// This flag is supported on the following file systems: NTFS, FAT,
+        /// and exFAT.
         OPEN_REQUIRING_OPLOCK: bool = false,
         Reserved17: u3 = 0,
-        /// This flag allows an application to request a filter opportunistic lock to prevent other applications from getting share violations. If there are already open
-        /// handles, the create request will fail with STATUS_OPLOCK_NOT_GRANTED. For more information, see the Remarks section.
+        /// This flag allows an application to request a filter opportunistic
+        /// lock to prevent other applications from getting share violations.
+        /// If there are already open handles, the create request will fail
+        /// with STATUS_OPLOCK_NOT_GRANTED. For more information, see the
+        /// Remarks section.
         RESERVE_OPFILTER: bool = false,
-        /// Open a file with a reparse point and bypass normal reparse point processing for the file. For more information, see the Remarks section.
+        /// Open a file with a reparse point and bypass normal reparse point
+        /// processing for the file. For more information, see the Remarks
+        /// section.
         OPEN_REPARSE_POINT: bool = false,
-        /// Instructs any filters that perform offline storage or virtualization to not recall the contents of the file as a result of this open.
+        /// Instructs any filters that perform offline storage or
+        /// virtualization to not recall the contents of the file as a result
+        /// of this open.
         OPEN_NO_RECALL: bool = false,
-        /// This flag instructs the file system to capture the user associated with the calling thread. Any subsequent calls to `FltQueryVolumeInformation` or
-        /// `ZwQueryVolumeInformationFile` using the returned handle will assume the captured user, rather than the calling user at the time, for purposes of computing
-        /// the free space available to the caller. This applies to the following FsInformationClass values: `FileFsSizeInformation`, `FileFsFullSizeInformation`, and
-        /// `FileFsFullSizeInformationEx`.
+        /// This flag instructs the file system to capture the user associated
+        /// with the calling thread. Any subsequent calls to
+        /// `FltQueryVolumeInformation` or `ZwQueryVolumeInformationFile` using
+        /// the returned handle will assume the captured user, rather than the
+        /// calling user at the time, for purposes of computing the free space
+        /// available to the caller. This applies to the following
+        /// FsInformationClass values: `FileFsSizeInformation`,
+        /// `FileFsFullSizeInformation`, and `FileFsFullSizeInformationEx`.
         OPEN_FOR_FREE_SPACE_QUERY: bool = false,
         Reserved24: u8 = 0,
 
@@ -597,7 +648,8 @@ pub const FILE = struct {
         // ref: km/ntifs.h
 
         pub const INFORMATION = extern struct {
-            /// The set of flags that specify the mode in which the file can be accessed. These flags are a subset of `MODE`.
+            /// The set of flags that specify the mode in which the file can be
+            /// accessed. These flags are a subset of `MODE`.
             Mode: MODE,
         };
     };
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 1cc17c0be6f56ef03909df8af7742c15472c9b93..978987e787f9661259e53335667c76271aa39f99 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -567,9 +567,8 @@ pub extern "ntdll" fn NtWaitForAlertByThreadId(
     Address: ?*const anyopaque,
     Timeout: ?*const LARGE_INTEGER,
 ) callconv(.winapi) NTSTATUS;
-pub extern "ntdll" fn NtAlertThreadByThreadId(
-    ThreadId: DWORD,
-) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtAlertThreadByThreadId(ThreadId: DWORD) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtAlertThread(ThreadHandle: HANDLE) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtAlertMultipleThreadByThreadId(
     ThreadIds: [*]const ULONG_PTR,
     ThreadCount: ULONG,
@@ -589,3 +588,16 @@ pub extern "ntdll" fn NtCancelSynchronousIoFile(
     RequestToCancel: ?*IO_STATUS_BLOCK,
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn NtDelayExecution(
+    Alertable: BOOLEAN,
+    DelayInterval: *const LARGE_INTEGER,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn NtCancelIoFileEx(
+    FileHandle: HANDLE,
+    /// Documentation has this as IO_STATUS_BLOCK but it's actually the APC
+    /// context parameter.
+    IoRequestToCancel: ?*anyopaque,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
diff --git a/src/link/Lld.zig b/src/link/Lld.zig
index dd84da15d41d92f3b3af6454057b58ac72d3da80..a94b1111cd5ee3f5b20ee715d0b557869f0860e4 100644
--- a/src/link/Lld.zig
+++ b/src/link/Lld.zig
@@ -278,7 +278,7 @@ pub fn flush(
     };
     result catch |err| switch (err) {
         error.OutOfMemory, error.LinkFailure => |e| return e,
-        else => |e| return lld.base.comp.link_diags.fail("failed to link with LLD: {s}", .{@errorName(e)}),
+        else => |e| return lld.base.comp.link_diags.fail("failed to link with LLD: {t}", .{e}),
     };
 }
 
@@ -1630,7 +1630,11 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
         }) catch |err| break :term err;
 
         var stderr_reader = child.stderr.?.readerStreaming(io, &.{});
-        stderr = try stderr_reader.interface.allocRemaining(gpa, .unlimited);
+        stderr = stderr_reader.interface.allocRemaining(gpa, .unlimited) catch |err| switch (err) {
+            error.StreamTooLong => unreachable, // unlimited
+            error.OutOfMemory => |e| return e,
+            error.ReadFailed => return stderr_reader.err.?,
+        };
         break :term child.wait(io);
     }) catch |first_err| term: {
         const err = switch (first_err) {
@@ -1682,7 +1686,11 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
                     break :term rsp_child.wait(io) catch |err| break :err err;
                 } else {
                     var stderr_reader = rsp_child.stderr.?.readerStreaming(io, &.{});
-                    stderr = try stderr_reader.interface.allocRemaining(gpa, .unlimited);
+                    stderr = stderr_reader.interface.allocRemaining(gpa, .unlimited) catch |err| switch (err) {
+                        error.StreamTooLong => unreachable, // unlimited
+                        error.OutOfMemory => |e| return e,
+                        error.ReadFailed => return stderr_reader.err.?,
+                    };
                     break :term rsp_child.wait(io) catch |err| break :err err;
                 }
             },
-- 
2.54.0


From 193c747b03da8ec7af55cb5fcb53f8f1bee39d5c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 22 Jan 2026 19:06:52 -0800
Subject: [PATCH 025/499] link.MappedFile: refactor std.Io -> Io

---
 src/link/MappedFile.zig | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/link/MappedFile.zig b/src/link/MappedFile.zig
index 2580ed5c2a36cee4d9cc63c35f3843f2b8ba881d..773959fae62a4a8754fac11120c4322e102c102f 100644
--- a/src/link/MappedFile.zig
+++ b/src/link/MappedFile.zig
@@ -11,7 +11,7 @@ const linux = std.os.linux;
 const windows = std.os.windows;
 
 io: Io,
-file: std.Io.File,
+file: Io.File,
 flags: packed struct {
     block_size: std.mem.Alignment,
     copy_file_range_unsupported: bool,
@@ -29,7 +29,7 @@ writers: std.SinglyLinkedList,
 
 pub const growth_factor = 4;
 
-pub const Error = std.posix.MMapError || std.posix.MRemapError || Io.File.LengthError || error{
+pub const Error = Io.File.MemoryMap.CreateError || Io.File.LengthError || error{
     NotFile,
     SystemResources,
     IsDir,
@@ -42,7 +42,7 @@ pub const Error = std.posix.MMapError || std.posix.MRemapError || Io.File.Length
     NonResizable,
 };
 
-pub fn init(file: std.Io.File, gpa: std.mem.Allocator, io: Io) !MappedFile {
+pub fn init(file: Io.File, gpa: std.mem.Allocator, io: Io) !MappedFile {
     var mf: MappedFile = .{
         .io = io,
         .file = file,
@@ -396,7 +396,7 @@ pub const Node = extern struct {
         mf: *MappedFile,
         writer_node: std.SinglyLinkedList.Node,
         ni: Node.Index,
-        interface: std.Io.Writer,
+        interface: Io.Writer,
         err: ?Error,
 
         pub fn deinit(w: *Writer) void {
@@ -404,18 +404,18 @@ pub const Node = extern struct {
             w.* = undefined;
         }
 
-        const vtable: std.Io.Writer.VTable = .{
+        const vtable: Io.Writer.VTable = .{
             .drain = drain,
             .sendFile = sendFile,
-            .flush = std.Io.Writer.noopFlush,
+            .flush = Io.Writer.noopFlush,
             .rebase = growingRebase,
         };
 
         fn drain(
-            interface: *std.Io.Writer,
+            interface: *Io.Writer,
             data: []const []const u8,
             splat: usize,
-        ) std.Io.Writer.Error!usize {
+        ) Io.Writer.Error!usize {
             const pattern = data[data.len - 1];
             const splat_len = pattern.len * splat;
             const start_len = interface.end;
@@ -442,10 +442,10 @@ pub const Node = extern struct {
         }
 
         fn sendFile(
-            interface: *std.Io.Writer,
-            file_reader: *std.Io.File.Reader,
-            limit: std.Io.Limit,
-        ) std.Io.Writer.FileError!usize {
+            interface: *Io.Writer,
+            file_reader: *Io.File.Reader,
+            limit: Io.Limit,
+        ) Io.Writer.FileError!usize {
             if (limit == .nothing) return 0;
             const pos = file_reader.logicalPos();
             const additional = if (file_reader.getSize()) |size| size - pos else |_| std.atomic.cache_line;
@@ -489,10 +489,10 @@ pub const Node = extern struct {
         }
 
         fn growingRebase(
-            interface: *std.Io.Writer,
+            interface: *Io.Writer,
             preserve: usize,
             unused_capacity: usize,
-        ) std.Io.Writer.Error!void {
+        ) Io.Writer.Error!void {
             _ = preserve;
             const total_capacity = interface.end + unused_capacity;
             if (interface.buffer.len >= total_capacity) return;
@@ -941,7 +941,7 @@ fn copyRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size:
 
 fn copyFileRange(
     mf: *MappedFile,
-    old_file: std.Io.File,
+    old_file: Io.File,
     old_file_offset: u64,
     new_file_offset: u64,
     size: u64,
-- 
2.54.0


From 499ba5d55c00b9d32691dc9ff49db49ba6bbded6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 22 Jan 2026 19:41:13 -0800
Subject: [PATCH 026/499] compiler: use Io.MemoryMap

Also make setLength return error.OperationUnsupported when it cannot be
done atomically.
---
 lib/std/Io.zig                |   2 +-
 lib/std/Io/File/MemoryMap.zig |  16 +--
 lib/std/Io/Threaded.zig       |  36 +-----
 lib/std/Io/Threaded/test.zig  |   9 +-
 lib/std/Io/test.zig           |  11 +-
 src/link.zig                  |  10 +-
 src/link/Elf2.zig             |  15 ++-
 src/link/MappedFile.zig       | 203 +++++++++-------------------------
 8 files changed, 93 insertions(+), 209 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index bf12ee6c6cd6098e3d4a9e218a3b18326724747f..80a0e248074c08ac83b53151fcd8680b20eadc46 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -656,7 +656,7 @@ pub const VTable = struct {
 
     fileMemoryMapCreate: *const fn (?*anyopaque, File, File.MemoryMap.CreateOptions) File.MemoryMap.CreateError!File.MemoryMap,
     fileMemoryMapDestroy: *const fn (?*anyopaque, *File.MemoryMap) void,
-    fileMemoryMapSetLength: *const fn (?*anyopaque, *File.MemoryMap, File.MemoryMap.CreateOptions) File.MemoryMap.SetLengthError!void,
+    fileMemoryMapSetLength: *const fn (?*anyopaque, *File.MemoryMap, usize) File.MemoryMap.SetLengthError!void,
     fileMemoryMapRead: *const fn (?*anyopaque, *File.MemoryMap) File.ReadPositionalError!void,
     fileMemoryMapWrite: *const fn (?*anyopaque, *File.MemoryMap) File.WritePositionalError!void,
 
diff --git a/lib/std/Io/File/MemoryMap.zig b/lib/std/Io/File/MemoryMap.zig
index b3196aab3e420a95113822afd4bf99d584556d3e..2c1265d05a3a205bf28f803deae6107ed9ccce05 100644
--- a/lib/std/Io/File/MemoryMap.zig
+++ b/lib/std/Io/File/MemoryMap.zig
@@ -74,6 +74,9 @@ pub fn destroy(mm: *MemoryMap, io: Io) void {
 }
 
 pub const SetLengthError = error{
+    /// Changing the mapping length could not be done atomically. Caller must
+    /// use `destroy` and `create` to resize the mapping.
+    OperationUnsupported,
     /// One of the following:
     /// * The `File.Kind` is not `file`.
     /// * The file is not open for reading and read access protections enabled.
@@ -91,17 +94,8 @@ pub const SetLengthError = error{
 /// of the file after calling this is unspecified until `write` is called.
 ///
 /// May change the pointer address of `memory`.
-///
-/// `options` is needed because the mapping may need to be destroyed and
-/// re-created. All the same options must be provided except for `len` which is
-/// the new length.
-///
-/// This operation cannot be completed atomically on all operating systems.
-/// When this function fails, the `MemoryMap` may be left in an unmapped state,
-/// which can be detected by checking if `memory.len` is zero. In such case it
-/// is safe to call `destroy` which will have no effect.
-pub fn setLength(mm: *MemoryMap, io: Io, options: CreateOptions) SetLengthError!void {
-    return io.vtable.fileMemoryMapSetLength(io.userdata, mm, options);
+pub fn setLength(mm: *MemoryMap, io: Io, new_len: usize) SetLengthError!void {
+    return io.vtable.fileMemoryMapSetLength(io.userdata, mm, new_len);
 }
 
 /// Synchronizes the contents of `memory` from `file`.
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 42816b52767343192821a7d432568c303bcaeeee..1c588436cea84012ffe653dc19426cecc20c1b1a 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -16466,27 +16466,21 @@ fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
 fn fileMemoryMapSetLength(
     userdata: ?*anyopaque,
     mm: *File.MemoryMap,
-    options: File.MemoryMap.CreateOptions,
+    new_len: usize,
 ) File.MemoryMap.SetLengthError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const page_size = std.heap.pageSize();
     const alignment: Alignment = .fromByteUnits(page_size);
     const page_align = std.heap.page_size_min;
     const old_memory = mm.memory;
-    const new_len = options.len;
 
     if (mm.section) |section| {
+        _ = section;
         if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
             mm.memory.len = new_len;
             return;
         }
         switch (native_os) {
-            .windows => {
-                _ = windows.ntdll.NtUnmapViewOfSection(windows.current_process, old_memory.ptr);
-                windows.CloseHandle(section);
-                mm.section = windows.INVALID_HANDLE_VALUE;
-                mm.memory = &.{};
-            },
             .wasi => unreachable,
             .linux => {
                 const flags: posix.MREMAP = .{ .MAYMOVE = true };
@@ -16516,31 +16510,7 @@ fn fileMemoryMapSetLength(
                 mm.memory = new_memory;
                 return;
             },
-            else => {
-                switch (posix.errno(posix.system.munmap(old_memory.ptr, old_memory.len))) {
-                    .SUCCESS => {},
-                    else => |e| {
-                        if (builtin.mode == .Debug) std.log.err("failed to unmap {d} bytes at {*}: {t}", .{
-                            old_memory.len, old_memory.ptr, e,
-                        });
-                        // munmap must be infallible, or we cannot design reliable software.
-                        return error.Unexpected;
-                    },
-                }
-                mm.memory = &.{};
-            },
-        }
-        if (createFileMap(mm.file, options.protection, mm.offset, options.populate, new_len)) |result| {
-            mm.* = result;
-            return;
-        } else |err| switch (err) {
-            error.OperationUnsupported,
-            error.Unseekable,
-            error.SectionOversize,
-            error.MappingAlreadyExists,
-            error.FileLockConflict,
-            => return error.Unexpected, // It worked before on the same open file.
-            else => |e| return e,
+            else => return error.OperationUnsupported,
         }
     } else {
         const gpa = t.allocator;
diff --git a/lib/std/Io/Threaded/test.zig b/lib/std/Io/Threaded/test.zig
index 9ab9c6dcd98b51414611c7e492663d6e01aa795f..ffda1e7601c81b790c4bf9148a6835d4f448de88 100644
--- a/lib/std/Io/Threaded/test.zig
+++ b/lib/std/Io/Threaded/test.zig
@@ -260,7 +260,14 @@ test "memory mapping fallback" {
 
         try testing.expectEqualStrings("this9is9my", mm.memory);
 
-        try mm.setLength(io, .{ .len = "this9is9my data123".len });
+        const new_len = "this9is9my data123".len;
+        mm.setLength(io, new_len) catch |err| switch (err) {
+            error.OperationUnsupported => {
+                mm.destroy(io);
+                mm = try file.createMemoryMap(io, .{ .len = new_len });
+            },
+            else => |e| return e,
+        };
         try mm.read(io);
 
         try testing.expectEqualStrings("this9is9my data123", mm.memory);
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 0842f5d092ec2a6d2fb5717f5bfe3515cc82d948..b022b10e6e64c91d358aaba4dfff6bf70c986837 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -643,9 +643,14 @@ test "memory mapping" {
         try expectEqualStrings("this9is9my", mm.memory);
 
         // Cross a page boundary to require an actual remap.
-        try mm.setLength(io, .{
-            .len = std.heap.pageSize() * 2,
-        });
+        const new_len = std.heap.pageSize() * 2;
+        mm.setLength(io, new_len) catch |err| switch (err) {
+            error.OperationUnsupported => {
+                mm.destroy(io);
+                mm = try file.createMemoryMap(io, .{ .len = new_len });
+            },
+            else => |e| return e,
+        };
         try mm.read(io);
 
         try expectEqualStrings("this9is9my data123\x00\x00", mm.memory[0.."this9is9my data123\x00\x00".len]);
diff --git a/src/link.zig b/src/link.zig
index 0e897232962b739e6b328d9afcc2312e0c99edf0..6f19ec0e583010a18cc450f9ac22629bf09a141a 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -651,10 +651,10 @@ pub const File = struct {
                     &coff.mf
                 else
                     unreachable;
-                mf.file = try base.emit.root_dir.handle.openFile(io, base.emit.sub_path, .{
+                mf.memory_map.file = try base.emit.root_dir.handle.openFile(io, base.emit.sub_path, .{
                     .mode = .read_write,
                 });
-                base.file = mf.file;
+                base.file = mf.memory_map.file;
                 try mf.ensureTotalCapacity(@intCast(mf.nodes.items[0].location().resolve(mf)[1]));
             },
             .c, .spirv => dev.checkAny(&.{ .c_linker, .spirv_linker }),
@@ -729,9 +729,9 @@ pub const File = struct {
                 else
                     unreachable;
                 mf.unmap();
-                assert(mf.file.handle == f.handle);
-                mf.file.close(io);
-                mf.file = undefined;
+                assert(mf.memory_map.file.handle == f.handle);
+                mf.memory_map.file.close(io);
+                mf.memory_map.file = undefined;
                 base.file = null;
             },
             .c, .spirv => dev.checkAny(&.{ .c_linker, .spirv_linker }),
diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig
index e33cf86696948536db25c5d34b5badb0b454c575..81e6c23af82805f96d09409637b0e14e0dc49165 100644
--- a/src/link/Elf2.zig
+++ b/src/link/Elf2.zig
@@ -1691,10 +1691,10 @@ fn computeNodeVAddr(elf: *Elf, ni: MappedFile.Node.Index) u64 {
 }
 
 pub fn identClass(elf: *const Elf) std.elf.CLASS {
-    return @enumFromInt(elf.mf.contents[std.elf.EI.CLASS]);
+    return @enumFromInt(elf.mf.memory_map.memory[std.elf.EI.CLASS]);
 }
 pub fn identData(elf: *const Elf) std.elf.DATA {
-    return @enumFromInt(elf.mf.contents[std.elf.EI.DATA]);
+    return @enumFromInt(elf.mf.memory_map.memory[std.elf.EI.DATA]);
 }
 
 pub fn targetEndian(elf: *const Elf) std.builtin.Endian {
@@ -2102,7 +2102,7 @@ fn loadObject(
     log.debug("loadObject({f}{f})", .{ path.fmtEscapeString(), fmtMemberString(member) });
     const ident = try r.peek(std.elf.EI.OSABI);
     if (!std.mem.eql(u8, ident[0..std.elf.MAGIC.len], std.elf.MAGIC)) return error.BadMagic;
-    if (!std.mem.eql(u8, ident[std.elf.MAGIC.len..], elf.mf.contents[std.elf.MAGIC.len..ident.len]))
+    if (!std.mem.eql(u8, ident[std.elf.MAGIC.len..], elf.mf.memory_map.memory[std.elf.MAGIC.len..ident.len]))
         return diags.failParse(path, "bad ident", .{});
     try elf.symtab.ensureUnusedCapacity(gpa, 1);
     try elf.inputs.ensureUnusedCapacity(gpa, 1);
@@ -2341,7 +2341,7 @@ fn loadDso(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) !void {
     log.debug("loadDso({f})", .{path.fmtEscapeString()});
     const ident = try r.peek(std.elf.EI.NIDENT);
     if (!std.mem.eql(u8, ident[0..std.elf.MAGIC.len], std.elf.MAGIC)) return error.BadMagic;
-    if (!std.mem.eql(u8, ident[std.elf.MAGIC.len..], elf.mf.contents[std.elf.MAGIC.len..ident.len]))
+    if (!std.mem.eql(u8, ident[std.elf.MAGIC.len..], elf.mf.memory_map.memory[std.elf.MAGIC.len..ident.len]))
         return diags.failParse(path, "bad ident", .{});
     const target_endian = elf.targetEndian();
     switch (elf.identClass()) {
@@ -3090,9 +3090,14 @@ pub fn flush(
     tid: Zcu.PerThread.Id,
     prog_node: std.Progress.Node,
 ) !void {
+    const comp = elf.base.comp;
     _ = arena;
     _ = prog_node;
     while (try elf.idle(tid)) {}
+    elf.mf.flush() catch |err| switch (err) {
+        error.Canceled => |e| return e,
+        else => |e| return comp.link_diags.fail("flush write failed: {t}", .{e}),
+    };
 }
 
 pub fn idle(elf: *Elf, tid: Zcu.PerThread.Id) !bool {
@@ -3839,7 +3844,7 @@ pub fn printNode(
     const line_len = 0x10;
     var line_it = std.mem.window(
         u8,
-        elf.mf.contents[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)],
+        elf.mf.memory_map.memory[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)],
         line_len,
         line_len,
     );
diff --git a/src/link/MappedFile.zig b/src/link/MappedFile.zig
index 773959fae62a4a8754fac11120c4322e102c102f..8ac2e0c6a57d4b4ee92e608caad0984e11274fe4 100644
--- a/src/link/MappedFile.zig
+++ b/src/link/MappedFile.zig
@@ -11,15 +11,13 @@ const linux = std.os.linux;
 const windows = std.os.windows;
 
 io: Io,
-file: Io.File,
 flags: packed struct {
     block_size: std.mem.Alignment,
     copy_file_range_unsupported: bool,
     fallocate_punch_hole_unsupported: bool,
     fallocate_insert_range_unsupported: bool,
 },
-section: if (is_windows) windows.HANDLE else void,
-contents: []align(std.heap.page_size_min) u8,
+memory_map: Io.File.MemoryMap,
 nodes: std.ArrayList(Node),
 free_ni: Node.Index,
 large: std.ArrayList(u64),
@@ -29,26 +27,20 @@ writers: std.SinglyLinkedList,
 
 pub const growth_factor = 4;
 
-pub const Error = Io.File.MemoryMap.CreateError || Io.File.LengthError || error{
+pub const Error = error{
     NotFile,
-    SystemResources,
-    IsDir,
-    Unseekable,
-    NoSpaceLeft,
-
-    InputOutput,
-    FileTooBig,
-    FileBusy,
-    NonResizable,
-};
+} || Io.File.MemoryMap.CreateError || Io.File.MemoryMap.SetLengthError || Io.File.WritePositionalError;
 
 pub fn init(file: Io.File, gpa: std.mem.Allocator, io: Io) !MappedFile {
     var mf: MappedFile = .{
         .io = io,
-        .file = file,
         .flags = undefined,
-        .section = if (is_windows) windows.INVALID_HANDLE_VALUE else {},
-        .contents = &.{},
+        .memory_map = .{
+            .file = file,
+            .memory = &.{},
+            .offset = 0,
+            .section = null,
+        },
         .nodes = .empty,
         .free_ni = .none,
         .large = .empty,
@@ -58,61 +50,9 @@ pub fn init(file: Io.File, gpa: std.mem.Allocator, io: Io) !MappedFile {
     };
     errdefer mf.deinit(gpa);
     const size: u64, const block_size = stat: {
-        if (is_windows) {
-            var sbi: windows.SYSTEM_BASIC_INFORMATION = undefined;
-            break :stat .{
-                try windows.GetFileSizeEx(file.handle),
-                switch (windows.ntdll.NtQuerySystemInformation(
-                    .SystemBasicInformation,
-                    &sbi,
-                    @sizeOf(windows.SYSTEM_BASIC_INFORMATION),
-                    null,
-                )) {
-                    .SUCCESS => @max(sbi.PageSize, sbi.AllocationGranularity),
-                    else => std.heap.page_size_max,
-                },
-            };
-        }
-        if (is_linux) {
-            const use_c = std.c.versionCheck(if (builtin.abi.isAndroid())
-                .{ .major = 30, .minor = 0, .patch = 0 }
-            else
-                .{ .major = 2, .minor = 28, .patch = 0 });
-            const sys = if (use_c) std.c else std.os.linux;
-            while (true) {
-                var statx = std.mem.zeroes(linux.Statx);
-                const rc = sys.statx(
-                    mf.file.handle,
-                    "",
-                    std.posix.AT.EMPTY_PATH,
-                    .{ .TYPE = true, .SIZE = true, .BLOCKS = true },
-                    &statx,
-                );
-                switch (sys.errno(rc)) {
-                    .SUCCESS => {
-                        assert(statx.mask.TYPE);
-                        assert(statx.mask.SIZE);
-                        assert(statx.mask.BLOCKS);
-                        if (!std.posix.S.ISREG(statx.mode)) return error.PathAlreadyExists;
-                        break :stat .{ statx.size, @max(std.heap.pageSize(), statx.blksize) };
-                    },
-                    .INTR => continue,
-                    .ACCES => return error.AccessDenied,
-                    .BADF => if (std.debug.runtime_safety) unreachable else return error.Unexpected,
-                    .FAULT => if (std.debug.runtime_safety) unreachable else return error.Unexpected,
-                    .INVAL => if (std.debug.runtime_safety) unreachable else return error.Unexpected,
-                    .LOOP => return error.SymLinkLoop,
-                    .NAMETOOLONG => return error.NameTooLong,
-                    .NOENT => return error.FileNotFound,
-                    .NOTDIR => return error.FileNotFound,
-                    .NOMEM => return error.SystemResources,
-                    else => |err| return std.posix.unexpectedErrno(err),
-                }
-            }
-        }
-        const stat = try std.posix.fstat(mf.file.handle);
-        if (!std.posix.S.ISREG(stat.mode)) return error.PathAlreadyExists;
-        break :stat .{ @bitCast(stat.size), @max(std.heap.pageSize(), stat.blksize) };
+        const stat = try file.stat(io);
+        if (stat.kind != .file) return error.PathAlreadyExists;
+        break :stat .{ stat.size, @max(std.heap.pageSize(), stat.block_size) };
     };
     mf.flags = .{
         .block_size = .fromByteUnits(std.math.ceilPowerOfTwoAssert(usize, block_size)),
@@ -348,12 +288,12 @@ pub const Node = extern struct {
 
         pub fn slice(ni: Node.Index, mf: *const MappedFile) []u8 {
             const file_loc = ni.fileLocation(mf, true);
-            return mf.contents[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)];
+            return mf.memory_map.memory[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)];
         }
 
         pub fn sliceConst(ni: Node.Index, mf: *const MappedFile) []const u8 {
             const file_loc = ni.fileLocation(mf, false);
-            return mf.contents[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)];
+            return mf.memory_map.memory[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)];
         }
 
         pub fn resize(ni: Node.Index, mf: *MappedFile, gpa: std.mem.Allocator, size: u64) !void {
@@ -661,7 +601,8 @@ fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested
     // Resize the entire file
     if (ni == Node.Index.root) {
         try mf.ensureCapacityForSetLocation(gpa);
-        try mf.file.setLength(io, new_size);
+        try mf.memory_map.write(io);
+        try mf.memory_map.file.setLength(io, new_size);
         try mf.ensureTotalCapacity(@intCast(new_size));
         ni.setLocationAssumeCapacity(mf, old_offset, new_size);
         return;
@@ -685,6 +626,7 @@ fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested
     if (is_linux and !mf.flags.fallocate_insert_range_unsupported and
         node.flags.alignment.order(mf.flags.block_size).compare(.gte))
     insert_range: {
+        try mf.memory_map.write(io);
         // Ask the filesystem driver to insert extents into the file without copying any data
         const last_offset, const last_size = parent.last.location(mf).resolve(mf);
         const last_end = last_offset + last_size;
@@ -696,12 +638,12 @@ fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested
         _, const file_size = Node.Index.root.location(mf).resolve(mf);
         while (true) switch (linux.errno(switch (std.math.order(range_file_offset, file_size)) {
             .lt => linux.fallocate(
-                mf.file.handle,
+                mf.memory_map.file.handle,
                 linux.FALLOC.FL_INSERT_RANGE,
                 @intCast(range_file_offset),
                 @intCast(range_size),
             ),
-            .eq => linux.ftruncate(mf.file.handle, @intCast(range_file_offset + range_size)),
+            .eq => linux.ftruncate(mf.memory_map.file.handle, @intCast(range_file_offset + range_size)),
             .gt => unreachable,
         })) {
             .SUCCESS => {
@@ -908,7 +850,7 @@ fn moveRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size:
     if (is_linux and !mf.flags.fallocate_punch_hole_unsupported and
         size >= mf.flags.block_size.toByteUnits() * 2 - 1) while (true)
         switch (linux.errno(linux.fallocate(
-            mf.file.handle,
+            mf.memory_map.file.handle,
             linux.FALLOC.FL_PUNCH_HOLE | linux.FALLOC.FL_KEEP_SIZE,
             @intCast(old_file_offset),
             @intCast(size),
@@ -928,14 +870,14 @@ fn moveRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size:
             .TXTBSY => return error.FileBusy,
             else => |e| return std.posix.unexpectedErrno(e),
         };
-    @memset(mf.contents[@intCast(old_file_offset)..][0..@intCast(size)], 0);
+    @memset(mf.memory_map.memory[@intCast(old_file_offset)..][0..@intCast(size)], 0);
 }
 
 fn copyRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size: u64) !void {
-    const copy_size = try mf.copyFileRange(mf.file, old_file_offset, new_file_offset, size);
+    const copy_size = try mf.copyFileRange(mf.memory_map.file, old_file_offset, new_file_offset, size);
     if (copy_size < size) @memcpy(
-        mf.contents[@intCast(new_file_offset + copy_size)..][0..@intCast(size - copy_size)],
-        mf.contents[@intCast(old_file_offset + copy_size)..][0..@intCast(size - copy_size)],
+        mf.memory_map.memory[@intCast(new_file_offset + copy_size)..][0..@intCast(size - copy_size)],
+        mf.memory_map.memory[@intCast(old_file_offset + copy_size)..][0..@intCast(size - copy_size)],
     );
 }
 
@@ -946,6 +888,8 @@ fn copyFileRange(
     new_file_offset: u64,
     size: u64,
 ) !u64 {
+    const io = mf.io;
+    try mf.memory_map.write(io);
     var remaining_size = size;
     if (is_linux and !mf.flags.copy_file_range_unsupported) {
         var old_file_offset_mut: i64 = @intCast(old_file_offset);
@@ -954,7 +898,7 @@ fn copyFileRange(
             const copy_len = linux.copy_file_range(
                 old_file.handle,
                 &old_file_offset_mut,
-                mf.file.handle,
+                mf.memory_map.file.handle,
                 &new_file_offset_mut,
                 @intCast(remaining_size),
                 0,
@@ -990,82 +934,41 @@ fn ensureCapacityForSetLocation(mf: *MappedFile, gpa: std.mem.Allocator) !void {
 }
 
 pub fn ensureTotalCapacity(mf: *MappedFile, new_capacity: usize) !void {
-    if (mf.contents.len >= new_capacity) return;
+    if (mf.memory_map.memory.len >= new_capacity) return;
     try mf.ensureTotalCapacityPrecise(new_capacity +| new_capacity / growth_factor);
 }
 
 pub fn ensureTotalCapacityPrecise(mf: *MappedFile, new_capacity: usize) !void {
-    if (mf.contents.len >= new_capacity) return;
+    if (mf.memory_map.memory.len >= new_capacity) return;
+    const io = mf.io;
     const aligned_capacity = mf.flags.block_size.forward(new_capacity);
-    if (!is_linux) mf.unmap() else if (mf.contents.len > 0) {
-        mf.contents = try std.posix.mremap(
-            mf.contents.ptr,
-            mf.contents.len,
-            aligned_capacity,
-            .{ .MAYMOVE = true },
-            null,
-        );
-        return;
-    }
-    if (is_windows) {
-        if (mf.section == windows.INVALID_HANDLE_VALUE) switch (windows.ntdll.NtCreateSection(
-            &mf.section,
-            .{
-                .SPECIFIC = .{ .SECTION = .{
-                    .QUERY = true,
-                    .MAP_WRITE = true,
-                    .MAP_READ = true,
-                    .EXTEND_SIZE = true,
-                } },
-                .STANDARD = .{ .RIGHTS = .REQUIRED },
-            },
-            null,
-            @constCast(&@as(i64, @intCast(aligned_capacity))),
-            .{ .READWRITE = true },
-            .{ .COMMIT = true },
-            mf.file.handle,
-        )) {
-            .SUCCESS => {},
-            else => return error.MemoryMappingNotSupported,
-        };
-        var contents_ptr: ?[*]align(std.heap.page_size_min) u8 = null;
-        var contents_len = aligned_capacity;
-        switch (windows.ntdll.NtMapViewOfSection(
-            mf.section,
-            windows.GetCurrentProcess(),
-            @ptrCast(&contents_ptr),
-            null,
-            0,
-            null,
-            &contents_len,
-            .Unmap,
-            .{},
-            .{ .READWRITE = true },
-        )) {
-            .SUCCESS => mf.contents = contents_ptr.?[0..contents_len],
-            else => return error.MemoryMappingNotSupported,
+
+    if (mf.memory_map.memory.len > 0) {
+        if (mf.memory_map.setLength(io, aligned_capacity)) |_| {
+            return;
+        } else |err| switch (err) {
+            error.OperationUnsupported => {},
+            else => |e| return e,
         }
-    } else mf.contents = try std.posix.mmap(
-        null,
-        aligned_capacity,
-        .{ .READ = true, .WRITE = true },
-        .{ .TYPE = if (is_linux) .SHARED_VALIDATE else .SHARED },
-        mf.file.handle,
-        0,
-    );
+        unmap(mf);
+    }
+
+    const file = mf.memory_map.file;
+    mf.memory_map = try .create(io, file, .{ .len = aligned_capacity });
 }
 
 pub fn unmap(mf: *MappedFile) void {
-    if (mf.contents.len == 0) return;
-    if (is_windows)
-        _ = windows.ntdll.NtUnmapViewOfSection(windows.GetCurrentProcess(), mf.contents.ptr)
-    else
-        std.posix.munmap(mf.contents);
-    mf.contents = &.{};
-    if (is_windows and mf.section != windows.INVALID_HANDLE_VALUE) {
-        windows.CloseHandle(mf.section);
-        mf.section = windows.INVALID_HANDLE_VALUE;
-    }
+    if (mf.memory_map.memory.len == 0) return;
+    const io = mf.io;
+    const file = mf.memory_map.file;
+    mf.memory_map.destroy(io);
+    mf.memory_map.memory = &.{};
+    mf.memory_map.file = file;
+}
+
+pub fn flush(mf: *MappedFile) Io.File.WritePositionalError!void {
+    const io = mf.io;
+    try mf.memory_map.write(io);
 }
 
 fn verify(mf: *MappedFile) void {
-- 
2.54.0


From 2774436a831194b5a97fc2774ad5570762ed0965 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 23 Jan 2026 16:17:36 +0100
Subject: [PATCH 027/499] ci: bump riscv64-linux-debug timeout by 1 hour

---
 .forgejo/workflows/ci.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 7cc50e71c302fe054f49f25d3ee8f262a5d4ea77..48813b9001d0463d39b7ce8e2566ae5dad555b87 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -111,7 +111,7 @@ jobs:
           fetch-depth: 0
       - name: Build and Test
         run: sh ci/riscv64-linux-debug.sh
-        timeout-minutes: 600
+        timeout-minutes: 660
   riscv64-linux-release:
     if: github.event_name != 'pull_request'
     runs-on: [self-hosted, riscv64-linux]
-- 
2.54.0


From 20fae334acb79dd367e74a3b90af5fa1445364cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 23 Jan 2026 19:42:23 +0100
Subject: [PATCH 028/499] compiler: UEFI does not support dynamic linking

---
 src/target.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/target.zig b/src/target.zig
index 87d0522ce7277549364ee6baf464320216eb11c8..100c0f690ba8fd099b13fa4e53626c8daf0234c7 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -12,7 +12,7 @@ pub const default_stack_protector_buffer_size = 4;
 
 pub fn cannotDynamicLink(target: *const std.Target) bool {
     return switch (target.os.tag) {
-        .freestanding => true,
+        .freestanding, .uefi => true,
         else => target.cpu.arch.isSpirV(),
     };
 }
-- 
2.54.0


From 909159ad8ea9203297c0b670446381c537554525 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 23 Jan 2026 19:45:34 +0100
Subject: [PATCH 029/499] compiler: don't enforce PIC for x86-windows and
 thumb-windows

Only x86_64-windows and aarch64-windows actually require PIC.
---
 src/Compilation/Config.zig |  2 +-
 src/Package/Module.zig     |  2 +-
 src/Sema.zig               | 10 +++++++++-
 src/target.zig             | 33 ++++++++++++++++++++++++++++-----
 4 files changed, 39 insertions(+), 8 deletions(-)

diff --git a/src/Compilation/Config.zig b/src/Compilation/Config.zig
index 1506a58497805ab61d5a12bb944eb21edb475aa1..e4f85b7a48094d82911c1831ca00e30b5f75c85d 100644
--- a/src/Compilation/Config.zig
+++ b/src/Compilation/Config.zig
@@ -255,7 +255,7 @@ pub fn resolve(options: Options) ResolveError!Config {
             .Exe => true,
         };
 
-        if (target_util.cannotDynamicLink(target)) {
+        if (!target_util.canDynamicLink(target)) {
             if (options.link_mode == .dynamic) return error.TargetCannotDynamicLink;
             break :b .static;
         }
diff --git a/src/Package/Module.zig b/src/Package/Module.zig
index cd7f573046fd41b8dd15beb54e0a3a189400d690..a922af2da5c26e2c2f2001889c1212d3af57893d 100644
--- a/src/Package/Module.zig
+++ b/src/Package/Module.zig
@@ -178,7 +178,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
                 return error.PieRequiresPic;
             break :b true;
         }
-        if (options.global.link_mode == .dynamic) {
+        if (options.global.link_mode == .dynamic and target_util.requiresPicForDynamicLink(target)) {
             if (options.inherited.pic == false)
                 return error.DynamicLinkingRequiresPic;
             break :b true;
diff --git a/src/Sema.zig b/src/Sema.zig
index 65311cafc188da131802235a34bc2582e76444a8..191da7c30dda58400f157c61d5739412cf08b7e0 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -9180,7 +9180,15 @@ pub fn handleExternLibName(
             );
             break :blk;
         }
-        if (!target.cpu.arch.isWasm() and !block.ownerModule().pic) {
+        if (!target_util.canDynamicLink(target)) {
+            return sema.fail(
+                block,
+                src_loc,
+                "dependency on dynamic library '{s}' cannot be satisfied because target does not support dynamic linking",
+                .{lib_name},
+            );
+        }
+        if (!block.ownerModule().pic and target_util.requiresPicForDynamicLink(target)) {
             return sema.fail(
                 block,
                 src_loc,
diff --git a/src/target.zig b/src/target.zig
index 100c0f690ba8fd099b13fa4e53626c8daf0234c7..fd6edbf0697958c376e82eaa9704459cec37a07e 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -10,10 +10,24 @@ const Feature = @import("Zcu.zig").Feature;
 
 pub const default_stack_protector_buffer_size = 4;
 
-pub fn cannotDynamicLink(target: *const std.Target) bool {
-    return switch (target.os.tag) {
-        .freestanding, .uefi => true,
-        else => target.cpu.arch.isSpirV(),
+pub fn canDynamicLink(target: *const std.Target) bool {
+    return switch (target.cpu.arch) {
+        .amdgcn,
+        .bpfeb,
+        .bpfel,
+        .nvptx,
+        .nvptx64,
+        .spirv32,
+        .spirv64,
+        => false,
+        .wasm32,
+        .wasm64,
+        => true,
+        else => switch (target.os.tag) {
+            // This list is likely incomplete.
+            .freestanding, .uefi => false,
+            else => true,
+        },
     };
 }
 
@@ -41,11 +55,20 @@ pub fn libCxxNeedsLibUnwind(target: *const std.Target) bool {
 /// This function returns whether non-pic code is completely invalid on the given target.
 pub fn requiresPIC(target: *const std.Target, linking_libc: bool) bool {
     return target.abi.isAndroid() or
-        target.os.tag == .windows or target.os.tag == .uefi or
+        ((target.os.tag == .windows or target.os.tag == .uefi) and (target.cpu.arch == .aarch64 or target.cpu.arch == .x86_64)) or
         target.requiresLibC() or
         (linking_libc and target.isGnuLibC());
 }
 
+pub fn requiresPicForDynamicLink(target: *const std.Target) bool {
+    assert(canDynamicLink(target));
+
+    return switch (target.os.tag) {
+        .windows => target.cpu.arch == .aarch64 or target.cpu.arch == .x86_64,
+        else => !target.cpu.arch.isWasm(),
+    };
+}
+
 pub fn picLevel(target: *const std.Target) u32 {
     // MIPS always uses PIC level 1; other platforms vary in their default PIC levels, but they
     // support both level 1 and 2, in which case we prefer 2.
-- 
2.54.0


From c699bb81347dc0c9371c7c6c2cddab457cbe02ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 23 Jan 2026 19:45:39 +0100
Subject: [PATCH 030/499] zig cc: don't bother passing -fPIC to Clang for
 Windows and UEFI targets

It's completely ignored anyway, by design, for compatibility reasons.
---
 src/target.zig | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/target.zig b/src/target.zig
index fd6edbf0697958c376e82eaa9704459cec37a07e..f664a354592ddff2d0c8cebbc5b9629d9c4d9c8c 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -79,9 +79,7 @@ pub fn picLevel(target: *const std.Target) u32 {
 /// C compiler argument is valid to Clang.
 pub fn supports_fpic(target: *const std.Target) bool {
     return switch (target.os.tag) {
-        .windows,
-        .uefi,
-        => target.abi == .gnu,
+        .windows, .uefi => false, // Technically allowed for `Abi.gnu`, but completely ignored by Clang (by design) anyway.
         else => true,
     };
 }
-- 
2.54.0


From e437efd6015cdc369a2ca632565d105e9f04f20f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 23 Jan 2026 19:47:12 +0100
Subject: [PATCH 031/499] test: enable thumb-windows-gnu module tests

We use long calls for these just like thumb*-linux-* to prevent range issues as
the binaries grow larger over time.

We also need function and data sections due to the many __stack_chk_guard
references within the std test binary; without these options, the linker is not
able to insert range thunks in between functions because the std binary just has
one giant .text section that's opaque to the linker.

closes https://codeberg.org/ziglang/zig/issues/30923
---
 test/tests.zig | 65 +++++++++++++++++++++++++++++---------------------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/test/tests.zig b/test/tests.zig
index 179f80b3060a48642af431907e220a5966e4887b..ede30a131d804934f8c0b63355965b80c168c35f 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -28,6 +28,8 @@ const TestTarget = struct {
     use_lld: ?bool = null,
     pic: ?bool = null,
     strip: ?bool = null,
+    function_sections: ?bool = null,
+    data_sections: ?bool = null,
     skip_modules: []const []const u8 = &.{},
 
     // This is intended for targets that, for any reason, shouldn't be run as part of a normal test
@@ -40,7 +42,7 @@ const test_targets = blk: {
     // getBaselineCpuFeatures calls populateDependencies which has a O(N ^ 2) algorithm
     // (where N is roughly 160, which technically makes it O(1), but it adds up to a
     // lot of branches)
-    @setEvalBranchQuota(60000);
+    @setEvalBranchQuota(80_000);
     break :blk [_]TestTarget{
         // Native Targets
 
@@ -1526,36 +1528,43 @@ const test_targets = blk: {
         },
 
         .{
-            .target = .{
-                .cpu_arch = .thumb,
-                .os_tag = .windows,
-                .abi = .msvc,
-            },
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "thumb-windows-msvc",
+                .cpu_features = "baseline+long_calls",
+            }) catch unreachable,
+            .pic = false, // Long calls don't work with PIC.
+            .function_sections = true,
+            .data_sections = true,
         },
         .{
-            .target = .{
-                .cpu_arch = .thumb,
-                .os_tag = .windows,
-                .abi = .msvc,
-            },
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "thumb-windows-msvc",
+                .cpu_features = "baseline+long_calls",
+            }) catch unreachable,
             .link_libc = true,
+            .pic = false, // Long calls don't work with PIC.
+            .function_sections = true,
+            .data_sections = true,
+        },
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "thumb-windows-gnu",
+                .cpu_features = "baseline+long_calls",
+            }) catch unreachable,
+            .pic = false, // Long calls don't work with PIC.
+            .function_sections = true,
+            .data_sections = true,
+        },
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "thumb-windows-gnu",
+                .cpu_features = "baseline+long_calls",
+            }) catch unreachable,
+            .link_libc = true,
+            .pic = false, // Long calls don't work with PIC.
+            .function_sections = true,
+            .data_sections = true,
         },
-        // https://github.com/ziglang/zig/issues/24016
-        // .{
-        //     .target = .{
-        //         .cpu_arch = .thumb,
-        //         .os_tag = .windows,
-        //         .abi = .gnu,
-        //     },
-        // },
-        // .{
-        //     .target = .{
-        //         .cpu_arch = .thumb,
-        //         .os_tag = .windows,
-        //         .abi = .gnu,
-        //     },
-        //     .link_libc = true,
-        // },
 
         .{
             .target = .{
@@ -2454,6 +2463,8 @@ fn addOneModuleTest(
     if (options.build_options) |build_options| {
         these_tests.root_module.addOptions("build_options", build_options);
     }
+    if (test_target.function_sections) |fs| these_tests.link_function_sections = fs;
+    if (test_target.data_sections) |ds| these_tests.link_data_sections = ds;
     const single_threaded_suffix = if (test_target.single_threaded == true) "-single" else "";
     const backend_suffix = if (test_target.use_llvm == true)
         "-llvm"
-- 
2.54.0


From 5c42193b177e4b56ca91acb256cad36dd7cd4dec Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 23 Jan 2026 12:59:36 -0800
Subject: [PATCH 032/499] std.Io.Threaded: rework cancelation

Now it can handle sync cancelation and alertable cancelation on Windows.

Also fix the API of NtCancelIoFileEx
---
 lib/std/Io/Threaded.zig      | 243 +++++++++++++++++++++++++++--------
 lib/std/os/windows/ntdll.zig |   9 +-
 2 files changed, 193 insertions(+), 59 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 42816b52767343192821a7d432568c303bcaeeee..3460a05d7543f28b579dff5fb62c6a2188dde7b6 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -339,7 +339,8 @@ const Group = struct {
                 .canceled => true,
                 .parked => unreachable,
                 .blocked => unreachable,
-                .blocked_windows_dns => unreachable,
+                .blocked_alertable => unreachable,
+                .blocked_alertable_canceling => unreachable,
                 .blocked_canceling => unreachable,
             };
             if (result) {
@@ -542,7 +543,8 @@ const Future = struct {
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
         };
         thread.status.store(.{ .cancelation = .none, .awaitable = .null }, .monotonic);
@@ -650,9 +652,11 @@ const Thread = struct {
             /// To request cancelation, set the status to `.blocked_canceling` and repeatedly interrupt the system call until the status changes.
             blocked = 0b011,
 
-            /// Windows-only: the thread is blocked in a call to `GetAddrInfoExW`.
-            /// To request cancelation, set the status to `.canceling` and call `GetAddrInfoExCancel`.
-            blocked_windows_dns = 0b010,
+            /// Windows-only: the thread is blocked in an alertable wait via
+            /// `NtDelayExecution`. To request cancelation, set the status to
+            /// `blocked_alertable_canceling` and repeatedly alert the thread
+            /// until the status changes.
+            blocked_alertable = 0b010,
 
             /// The thread has an outstanding cancelation request but is not in a cancelable operation.
             /// When it acknowledges the cancelation, it will set the status to `.canceled`.
@@ -663,9 +667,16 @@ const Thread = struct {
             /// will not change for the remainder of this task's execution.
             canceled = 0b111,
 
-            /// The thread is blocked in a cancelable system call, and is being canceled. The thread which triggered the cancelation will send signals to this thread
-            /// until its status changes.
+            /// The thread is blocked in a cancelable system call, and is being
+            /// canceled. The thread which triggered the cancelation will send
+            /// signals to this thread until its status changes.
             blocked_canceling = 0b101,
+
+            /// Windows-only: the thread is blocked in an alertable wait via
+            /// `NtDelayExecution`, and is being canceled. The thread which
+            /// triggered the cancelation will send signals to this thread
+            /// until its status changes.
+            blocked_alertable_canceling = 0b100,
         },
 
         /// We cannot turn this value back into a pointer. Instead, it exists so that a task can be
@@ -694,7 +705,8 @@ const Thread = struct {
         switch (status.cancelation) {
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
             .none, .canceled => {},
             .canceling => {
@@ -1007,19 +1019,14 @@ const Thread = struct {
                     .monotonic,
                 ) orelse return true,
 
-                .blocked_windows_dns => thread.status.cmpxchgWeak(
-                    .{ .cancelation = .blocked_windows_dns, .awaitable = awaitable },
-                    .{ .cancelation = .canceling, .awaitable = awaitable },
+                .blocked_alertable => thread.status.cmpxchgWeak(
+                    .{ .cancelation = .blocked_alertable, .awaitable = awaitable },
+                    .{ .cancelation = .blocked_alertable_canceling, .awaitable = awaitable },
                     .monotonic,
                     .monotonic,
                 ) orelse {
-                    if (builtin.target.os.tag != .windows) unreachable;
-                    if (true) {
-                        // TODO: cancel Windows DNS queries. This code path is currently impossible
-                        // as `netLookupFallible` doesn't actually use `.blocked_windows_dns` yet.
-                        unreachable;
-                    }
-                    return false;
+                    if (!is_windows) unreachable;
+                    return true;
                 },
 
                 .canceling, .canceled => {
@@ -1029,7 +1036,8 @@ const Thread = struct {
                     return false;
                 },
 
-                .blocked_canceling => unreachable,
+                .blocked_canceling => unreachable, // `awaitable` has not been canceled before now
+                .blocked_alertable_canceling => unreachable, // `awaitable` has not been canceled before now
             };
         }
     }
@@ -1044,40 +1052,59 @@ const Thread = struct {
     /// `Group.waitForCancelWithSignaling`: they use exponential backoff starting at a 1us delay and
     /// doubling each call. In practice, it is rare to send more than one signal.
     fn signalCanceledSyscall(thread: *Thread, t: *Threaded, awaitable: AwaitableId) bool {
-        const bad_status: Status = .{ .cancelation = .blocked_canceling, .awaitable = awaitable };
-        if (thread.status.load(.monotonic) != bad_status) return false;
+        const status = thread.status.load(.monotonic);
+        if (status.awaitable != awaitable) {
+            // The thread has moved on and is working on something totally different.
+            return false;
+        }
 
         // The thread ID and/or handle can be read non-atomically because they never change and were
         // released by the store that made `thread` available to us.
 
-        if (std.Thread.use_pthreads) {
-            return switch (std.c.pthread_kill(thread.handle, .IO)) {
-                0 => true,
-                else => false,
-            };
-        } else switch (builtin.target.os.tag) {
-            .linux => {
-                const pid: posix.pid_t = pid: {
-                    const cached_pid = @atomicLoad(Pid, &t.pid, .monotonic);
-                    if (cached_pid != .unknown) break :pid @intFromEnum(cached_pid);
-                    const pid = std.os.linux.getpid();
-                    @atomicStore(Pid, &t.pid, @enumFromInt(pid), .monotonic);
-                    break :pid pid;
-                };
-                return switch (std.os.linux.tgkill(pid, @bitCast(thread.id), .IO)) {
+        switch (status.cancelation) {
+            .blocked_canceling => if (std.Thread.use_pthreads) {
+                return switch (std.c.pthread_kill(thread.handle, .IO)) {
                     0 => true,
                     else => false,
                 };
+            } else switch (native_os) {
+                .linux => {
+                    const pid: posix.pid_t = pid: {
+                        const cached_pid = @atomicLoad(Pid, &t.pid, .monotonic);
+                        if (cached_pid != .unknown) break :pid @intFromEnum(cached_pid);
+                        const pid = std.os.linux.getpid();
+                        @atomicStore(Pid, &t.pid, @enumFromInt(pid), .monotonic);
+                        break :pid pid;
+                    };
+                    return switch (std.os.linux.tgkill(pid, @bitCast(thread.id), .IO)) {
+                        0 => true,
+                        else => false,
+                    };
+                },
+                .windows => {
+                    var iosb: windows.IO_STATUS_BLOCK = undefined;
+                    return switch (windows.ntdll.NtCancelSynchronousIoFile(thread.handle, null, &iosb)) {
+                        .NOT_FOUND => true, // this might mean the operation hasn't started yet
+                        .SUCCESS => false, // the OS confirmed that our cancelation worked
+                        else => false,
+                    };
+                },
+                else => return false,
             },
-            .windows => {
-                var iosb: windows.IO_STATUS_BLOCK = undefined;
-                return switch (windows.ntdll.NtCancelSynchronousIoFile(thread.handle, null, &iosb)) {
-                    .NOT_FOUND => true, // this might mean the operation hasn't started yet
-                    .SUCCESS => false, // the OS confirmed that our cancelation worked
+
+            .blocked_alertable_canceling => {
+                if (!is_windows) unreachable;
+                return switch (windows.ntdll.NtAlertThread(thread.handle)) {
+                    .SUCCESS => true,
                     else => false,
                 };
             },
-            else => return false,
+
+            else => {
+                // The thread is working on `awaitable`, but no longer needs signaling (they already
+                // woke up and saw the cancelation).
+                return false;
+            },
         }
     }
 
@@ -1118,7 +1145,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
             .none => return .{ .thread = thread }, // new status is `.blocked`
             .canceling => return error.Canceled, // new status is `.canceled`
@@ -1137,7 +1165,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
             .blocked => {}, // new status is `.blocked` (unchanged)
@@ -1153,13 +1182,41 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
             .blocked => {}, // new status is `.none`
             .blocked_canceling => {}, // new status is `.canceling`
         }
     }
+    /// Indicates instead of `NtCancelSynchronousIoFile` we need to use
+    /// `NtAlertThread` to interrupt the wait.
+    ///
+    /// Windows only, called from blocked state only.
+    fn toAlertable(s: Syscall) Io.Cancelable!AlertableSyscall {
+        comptime assert(is_windows);
+        const thread = s.thread orelse return .{ .thread = null };
+        var prev = thread.status.load(.monotonic);
+        while (true) prev = switch (prev.cancelation) {
+            .none => unreachable,
+            .parked => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
+            .canceling => unreachable,
+            .canceled => unreachable,
+
+            .blocked => thread.status.cmpxchgWeak(prev, .{
+                .cancelation = .blocked_alertable,
+                .awaitable = prev.awaitable,
+            }, .monotonic, .monotonic) orelse return .{ .thread = thread },
+
+            .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
+                .cancelation = .canceled,
+                .awaitable = prev.awaitable,
+            }, .monotonic, .monotonic) orelse return error.Canceled,
+        };
+    }
     /// Convenience wrapper which calls `finish`, then returns `err`.
     fn fail(s: Syscall, err: anytype) @TypeOf(err) {
         s.finish();
@@ -1191,6 +1248,72 @@ const Syscall = struct {
     }
 };
 
+const AlertableSyscall = struct {
+    thread: ?*Thread,
+
+    comptime {
+        assert(is_windows);
+    }
+
+    fn checkCancel(s: AlertableSyscall) Io.Cancelable!void {
+        comptime assert(is_windows);
+        const thread = s.thread orelse return;
+        const old_status = thread.status.fetchOr(.{
+            .cancelation = @enumFromInt(0b010),
+            .awaitable = .null,
+        }, .monotonic);
+        switch (old_status.cancelation) {
+            .none => unreachable,
+            .parked => unreachable,
+            .blocked => unreachable,
+            .blocked_canceling => unreachable,
+            .canceling => unreachable,
+            .canceled => unreachable,
+            .blocked_alertable => {}, // new status is `.blocked_alertable` (unchanged)
+            .blocked_alertable_canceling => {
+                // New status is `.canceling`---change to `.canceled` before return.
+                thread.status.store(.{ .cancelation = .canceled, .awaitable = old_status.awaitable }, .monotonic);
+                return error.Canceled;
+            },
+        }
+    }
+
+    fn finish(s: AlertableSyscall) void {
+        comptime assert(is_windows);
+        const thread = s.thread orelse return;
+        switch (thread.status.fetchXor(.{
+            .cancelation = @enumFromInt(0b010),
+            .awaitable = .null,
+        }, .monotonic).cancelation) {
+            .none => unreachable,
+            .parked => unreachable,
+            .blocked => unreachable,
+            .blocked_canceling => unreachable,
+            .canceling => unreachable,
+            .canceled => unreachable,
+            .blocked_alertable => {}, // new status is `.none`
+            .blocked_alertable_canceling => {}, // new status is `.canceling`
+        }
+    }
+
+    fn fail(s: AlertableSyscall, err: anytype) @TypeOf(err) {
+        s.finish();
+        return err;
+    }
+
+    fn ntstatusBug(s: AlertableSyscall, status: windows.NTSTATUS) Io.UnexpectedError {
+        @branchHint(.cold);
+        s.finish();
+        return windows.statusBug(status);
+    }
+
+    fn unexpectedNtstatus(s: AlertableSyscall, status: windows.NTSTATUS) Io.UnexpectedError {
+        @branchHint(.cold);
+        s.finish();
+        return windows.unexpectedStatus(status);
+    }
+};
+
 const max_iovecs_len = 8;
 const splat_buffer_size = 64;
 const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
@@ -1977,7 +2100,8 @@ fn groupAsyncEager(
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
         };
     } else false;
@@ -1988,7 +2112,8 @@ fn groupAsyncEager(
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
         };
     } else false;
@@ -2167,7 +2292,8 @@ fn recancelInner() void {
         .canceling => unreachable, // called `recancel` but cancelation was already pending
         .parked => unreachable,
         .blocked => unreachable,
-        .blocked_windows_dns => unreachable,
+        .blocked_alertable => unreachable,
+        .blocked_alertable_canceling => unreachable,
         .blocked_canceling => unreachable,
     }
 }
@@ -12096,8 +12222,7 @@ fn netLookupFallible(
         var res: *ws2_32.ADDRINFOEXW = undefined;
         const timeout: ?*ws2_32.timeval = null;
         while (true) {
-            // TODO: hook this up to cancelation with `Thread.Status.cancelation.blocked_windows_dns`.
-            // See matching TODO in `Thread.cancelAwaitable`.
+            // TODO: hook this up to cancelation with `NtDelayExecution` and APC callbacks.
             try Thread.checkCancel();
             // TODO make this append to the queue eagerly rather than blocking until the whole thing finishes
             const rc: ws2_32.WinsockError = @enumFromInt(ws2_32.GetAddrInfoExW(name_w, port_w, .DNS, null, &hints, &res, timeout, null, null, null));
@@ -15780,7 +15905,8 @@ const parking_futex = struct {
                         .canceled => break :cancelable, // status is still `.canceled`
                         .parked => unreachable,
                         .blocked => unreachable,
-                        .blocked_windows_dns => unreachable,
+                        .blocked_alertable => unreachable,
+                        .blocked_alertable_canceling => unreachable,
                         .blocked_canceling => unreachable,
                     }
                     // We could now be unparked for a cancelation at any time!
@@ -15831,7 +15957,8 @@ const parking_futex = struct {
                 },
                 .canceled => unreachable,
                 .blocked => unreachable,
-                .blocked_windows_dns => unreachable,
+                .blocked_alertable => unreachable,
+                .blocked_alertable_canceling => unreachable,
                 .blocked_canceling => unreachable,
             },
         }
@@ -15872,7 +15999,8 @@ const parking_futex = struct {
                     .canceling => continue, // race with a canceler who hasn't called `removeCanceledWaiter` yet
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_windows_dns => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 }
                 // We're waking this waiter. Remove them from the bucket and add them to our local list.
@@ -15938,7 +16066,8 @@ const parking_sleep = struct {
                 .canceled => break :cancelable, // status is still `.canceled`
                 .parked => unreachable,
                 .blocked => unreachable,
-                .blocked_windows_dns => unreachable,
+                .blocked_alertable => unreachable,
+                .blocked_alertable_canceling => unreachable,
                 .blocked_canceling => unreachable,
             }
             while (park(deadline, null)) {
@@ -15956,7 +16085,8 @@ const parking_sleep = struct {
                     .none => unreachable,
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_windows_dns => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 }
             } else |err| switch (err) {
@@ -15975,7 +16105,8 @@ const parking_sleep = struct {
                     .none => unreachable,
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_windows_dns => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 },
             }
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 978987e787f9661259e53335667c76271aa39f99..ee3cdeb069d01719322a634965dfa0a3882e3a9b 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -596,8 +596,11 @@ pub extern "ntdll" fn NtDelayExecution(
 
 pub extern "ntdll" fn NtCancelIoFileEx(
     FileHandle: HANDLE,
-    /// Documentation has this as IO_STATUS_BLOCK but it's actually the APC
-    /// context parameter.
-    IoRequestToCancel: ?*anyopaque,
+    IoRequestToCancel: *const IO_STATUS_BLOCK,
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn NtCancelIoFile(
+    handle: HANDLE,
+    iosbToCancel: *const IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
-- 
2.54.0


From 5f950884a1390f135ea825b035b460ff680ebea3 Mon Sep 17 00:00:00 2001
From: Lukas Lalinsky <lukas@lalinsky.com>
Date: Sat, 24 Jan 2026 12:26:00 +0100
Subject: [PATCH 033/499] std.c: add IPPROTO_RAW for Darwin platforms

IPPROTO_RAW (255) was missing from the Darwin/macOS IPPROTO struct,
even though it is defined in system headers and supported by the platform.
This is a commonly used protocol for raw IP sockets.
---
 lib/std/c.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index 1fa47a3121e26fcfcad7cfb2d34666b6c4d6a4a0..6bbf3cbe4692dab92e544e066c5a02808d6eae27 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -6026,6 +6026,7 @@ pub const IPPROTO = switch (native_os) {
         pub const UDP = 17;
         pub const IP = 0;
         pub const IPV6 = 41;
+        pub const RAW = 255;
     },
     .freebsd => struct {
         /// dummy for IP
-- 
2.54.0


From cf48041b55fbc2df0a2e12ae2a9490fc39e11486 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 24 Jan 2026 05:30:27 +0100
Subject: [PATCH 034/499] std.Thread.Condition: use pthread_cond_t impl when OS
 has no futex primitive

Same principle as #30835.
---
 lib/std/Thread/Condition.zig | 65 ++++++++++++++++++++++++++++++++----
 1 file changed, 59 insertions(+), 6 deletions(-)

diff --git a/lib/std/Thread/Condition.zig b/lib/std/Thread/Condition.zig
index 788b24038e7131ec67a1aaceae2119f94f7cccdb..8917e07a4fee3191c18ffa2c22ca36b0347fb3a8 100644
--- a/lib/std/Thread/Condition.zig
+++ b/lib/std/Thread/Condition.zig
@@ -107,12 +107,30 @@ pub fn broadcast(self: *Condition) void {
     self.impl.wake(.all);
 }
 
-const Impl = if (builtin.single_threaded)
-    SingleThreadedImpl
-else if (builtin.os.tag == .windows)
-    WindowsImpl
-else
-    FutexImpl;
+const Impl = Impl: {
+    if (builtin.single_threaded) break :Impl SingleThreadedImpl;
+    if (builtin.os.tag == .windows) break :Impl WindowsImpl;
+
+    if (builtin.os.tag.isDarwin() or
+        builtin.target.os.tag == .linux or
+        builtin.target.os.tag == .freebsd or
+        builtin.target.os.tag == .openbsd or
+        builtin.target.os.tag == .dragonfly or
+        builtin.target.cpu.arch.isWasm())
+    {
+        // Futex is the system's synchronization primitive; use that.
+        break :Impl FutexImpl;
+    }
+
+    if (std.Thread.use_pthreads) {
+        // This system doesn't have a futex primitive, so `std.Thread.Futex` is using `PosixImpl`,
+        // which implements futex *on top of* pthread mutexes and conditions. Therefore, instead
+        // of going through that long inefficient path, just use pthread condition variable directly.
+        break :Impl PosixImpl;
+    }
+
+    break :Impl FutexImpl;
+};
 
 const Notify = enum {
     one, // wake up only one thread
@@ -291,6 +309,41 @@ const FutexImpl = struct {
     }
 };
 
+const PosixImpl = struct {
+    cond: std.c.pthread_cond_t = .{},
+
+    fn wait(self: *Impl, mutex: *Mutex, timeout: ?u64) error{Timeout}!void {
+        if (builtin.mode == .Debug) {
+            mutex.impl.locking_thread.store(0, .unordered);
+        }
+        defer if (builtin.mode == .Debug) {
+            mutex.impl.locking_thread.store(std.Thread.getCurrentId(), .unordered);
+        };
+
+        const mtx = if (builtin.mode == .Debug) &mutex.impl.impl.mutex else &mutex.impl.mutex;
+
+        if (timeout) |t| {
+            switch (std.c.pthread_cond_timedwait(&self.cond, mtx, &.{
+                .sec = @intCast(@divFloor(t, std.time.ns_per_s)),
+                .nsec = @intCast(@mod(t, std.time.ns_per_s)),
+            })) {
+                .SUCCESS => return,
+                .TIMEDOUT => return error.Timeout,
+                else => unreachable,
+            }
+        }
+
+        assert(std.c.pthread_cond_wait(&self.cond, mtx) == .SUCCESS);
+    }
+
+    fn wake(self: *Impl, comptime notify: Notify) void {
+        assert(switch (notify) {
+            .one => std.c.pthread_cond_signal(&self.cond),
+            .all => std.c.pthread_cond_broadcast(&self.cond),
+        } == .SUCCESS);
+    }
+};
+
 test "smoke test" {
     var mutex = Mutex{};
     var cond = Condition{};
-- 
2.54.0


From 9d63dfaa81716a87b9c8c6dc5bdf1d07a8278b55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 24 Jan 2026 18:30:17 +0100
Subject: [PATCH 035/499] link.Lld: give better exit status information for the
 lld child process

It's not nice to just throw away useful information.
---
 src/link/Lld.zig | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/link/Lld.zig b/src/link/Lld.zig
index a94b1111cd5ee3f5b20ee715d0b557869f0860e4..fa94e534593a81c853c85911bf7054af03b65eab 100644
--- a/src/link/Lld.zig
+++ b/src/link/Lld.zig
@@ -1707,9 +1707,17 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
             diags.lockAndParseLldStderr(argv[1], stderr);
             return error.LinkFailure;
         },
-        else => {
+        .signal => |sig| {
             if (comp.clang_passthrough_mode) std.process.abort();
-            return diags.fail("{s} terminated with stderr:\n{s}", .{ argv[0], stderr });
+            return diags.fail("{s} terminated with signal {t} and stderr:\n{s}", .{ argv[0], sig, stderr });
+        },
+        .stopped => |sig| {
+            if (comp.clang_passthrough_mode) std.process.abort();
+            return diags.fail("{s} stopped with signal {d} and stderr:\n{s}", .{ argv[0], sig, stderr });
+        },
+        .unknown => |code| {
+            if (comp.clang_passthrough_mode) std.process.abort();
+            return diags.fail("{s} terminated for unknown reason with code {d} and stderr:\n{s}", .{ argv[0], code, stderr });
         },
     }
 
-- 
2.54.0


From a2ea36a51767659edf7feeee87eb237263e0dc4a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 21 Jan 2026 18:11:16 -0800
Subject: [PATCH 036/499] zig libc: modify errno helper to eliminate `@intCast`

The vast majority of libc functions return `c_int` for the return value,
when setting errno. This utility function is for those cases.

Other cases can hand-roll the logic, or additional helpers can be added.
---
 lib/c/common.zig      | 24 ++++++++++++++----------
 lib/c/sys/utsname.zig |  2 +-
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/lib/c/common.zig b/lib/c/common.zig
index 09dc5a8c0cbf2fe18160a2310ab4d33ffbfa7545..8d2a79db54b33515ef75c98bf5eb1defe23cb19a 100644
--- a/lib/c/common.zig
+++ b/lib/c/common.zig
@@ -14,16 +14,20 @@ pub const visibility: std.builtin.SymbolVisibility = if (linkage != .internal)
 else
     .default;
 
-/// Checks whether the syscall has had an error, storing it in `std.c.errno` and returning -1.
-/// Otherwise returns the result.
-pub fn linuxErrno(r: usize) isize {
-    const linux = std.os.linux;
-
-    return switch (linux.errno(r)) {
-        .SUCCESS => @bitCast(r),
-        else => |err| blk: {
-            std.c._errno().* = @intFromEnum(err);
-            break :blk -1;
+/// Given a low-level syscall return value, sets errno and returns `-1`, or on
+/// success returns the result.
+pub fn errno(syscall_return_value: usize) c_int {
+    return switch (builtin.os.tag) {
+        .linux => {
+            const signed: isize = @bitCast(syscall_return_value);
+            const casted: c_int = @intCast(signed);
+            if (casted < 0) {
+                @branchHint(.unlikely);
+                std.c._errno().* = -casted;
+                return -1;
+            }
+            return casted;
         },
+        else => comptime unreachable,
     };
 }
diff --git a/lib/c/sys/utsname.zig b/lib/c/sys/utsname.zig
index 06f849ba6df4e8aa642e1361e6f9e5d57fff7367..6082c1b6cecf6c15c8454cf362fef9e49cc1e3e8 100644
--- a/lib/c/sys/utsname.zig
+++ b/lib/c/sys/utsname.zig
@@ -13,7 +13,7 @@ comptime {
 }
 
 fn unameLinux(uts: *std.os.linux.utsname) callconv(.c) c_int {
-    return @intCast(common.linuxErrno(std.os.linux.uname(uts)));
+    return common.errno(std.os.linux.uname(uts));
 }
 
 fn unameWasi(uts: *std.c.utsname) callconv(.c) c_int {
-- 
2.54.0


From d5c3bf25dc7fedfe57b7142828ac83e49dd9f8d0 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Sat, 24 Jan 2026 15:58:46 +0100
Subject: [PATCH 037/499] feat(std.c): add `_Exit`

---
 lib/std/c.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index 6bbf3cbe4692dab92e544e066c5a02808d6eae27..e68d5a71c51397b3028da96ee1c2d4f6e6f2a847 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -10649,6 +10649,7 @@ pub extern "c" fn fread(noalias ptr: [*]u8, size_of_type: usize, item_count: usi
 pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
 pub extern "c" fn abort() noreturn;
 pub extern "c" fn exit(code: c_int) noreturn;
+pub extern "c" fn _Exit(code: c_int) noreturn;
 pub extern "c" fn _exit(code: c_int) noreturn;
 pub extern "c" fn isatty(fd: fd_t) c_int;
 pub extern "c" fn lseek(fd: fd_t, offset: off_t, whence: whence_t) off_t;
-- 
2.54.0


From b430cd62e40afd30048a4d9992ec62bb34f5e041 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Sat, 24 Jan 2026 16:00:16 +0100
Subject: [PATCH 038/499] feat(std.os.linux): add some missing syscalls

---
 lib/std/os/linux.zig | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 22a5b4299908cb2f6c9b5599a5d5f332c05ce01e..f5868f71e9af718e2464e03a9e241f95f104ae89 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1391,6 +1391,10 @@ pub fn faccessat(dirfd: i32, path: [*:0]const u8, mode: u32, flags: u32) usize {
     return syscall4(.faccessat2, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, flags);
 }
 
+pub fn acct(path: [*:0]const u8) usize {
+    return syscall1(.acct, @intFromPtr(path));
+}
+
 pub fn pipe(fd: *[2]i32) usize {
     if (comptime (native_arch.isMIPS() or native_arch.isSPARC())) {
         return syscall_pipe(fd);
@@ -1601,11 +1605,27 @@ pub fn fchown(fd: i32, owner: uid_t, group: gid_t) usize {
     }
 }
 
+pub fn fchownat(fd: i32, path: [*:0]const u8, owner: uid_t, group: gid_t, flags: u32) usize {
+    return syscall5(.fchownat, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(path), owner, group, flags);
+}
+
 pub fn chown(path: [*:0]const u8, owner: uid_t, group: gid_t) usize {
     if (@hasField(SYS, "chown32")) {
         return syscall3(.chown32, @intFromPtr(path), owner, group);
-    } else {
+    } else if (@hasField(SYS, "chown")) {
         return syscall3(.chown, @intFromPtr(path), owner, group);
+    } else {
+        return fchownat(AT.FDCWD, path, owner, group, 0);
+    }
+}
+
+pub fn lchown(path: [*:0]const u8, owner: uid_t, group: gid_t) usize {
+    if (@hasField(SYS, "lchown32")) {
+        return syscall3(.lchown32, @intFromPtr(path), owner, group);
+    } else if (@hasField(SYS, "lchown")) {
+        return syscall3(.lchown, @intFromPtr(path), owner, group);
+    } else {
+        return fchownat(AT.FDCWD, path, owner, group, AT.SYMLINK_NOFOLLOW);
     }
 }
 
@@ -2064,7 +2084,11 @@ pub fn setpgid(pid: pid_t, pgid: pid_t) usize {
     return syscall2(.setpgid, @intCast(pid), @intCast(pgid));
 }
 
-pub fn getgroups(size: usize, list: ?*gid_t) usize {
+pub fn getpgid(pid: pid_t) usize {
+    return syscall1(.getpgid, @intCast(pid));
+}
+
+pub fn getgroups(size: usize, list: ?[*]gid_t) usize {
     if (@hasField(SYS, "getgroups32")) {
         return syscall2(.getgroups32, size, @intFromPtr(list));
     } else {
@@ -2084,6 +2108,10 @@ pub fn setsid() usize {
     return syscall0(.setsid);
 }
 
+pub fn getsid(pid: pid_t) usize {
+    return syscall1(.getsid, @intCast(pid));
+}
+
 pub fn getpid() pid_t {
     // Casts result to a pid_t, safety-checking >= 0, because getpid() cannot fail
     return @intCast(@as(u32, @truncate(syscall0(.getpid))));
-- 
2.54.0


From 9cf34a8d81f31917acdcf9c25b8cbfe241646c3a Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Sat, 24 Jan 2026 16:01:18 +0100
Subject: [PATCH 039/499] feat(libzigc): move over some linux syscalls

* does not move all of them, only those which map almost 1:1
* also removes their musl implementation
---
 lib/c.zig                               |   1 +
 lib/c/sys.zig                           |   4 +
 lib/c/sys/capability.zig                |  18 +++
 lib/c/sys/file.zig                      |  13 ++
 lib/c/sys/mman.zig                      |  57 ++++++++
 lib/c/sys/reboot.zig                    |  13 ++
 lib/c/unistd.zig                        | 183 ++++++++++++++++++++++++
 lib/libc/musl/src/linux/cap.c           |  11 --
 lib/libc/musl/src/linux/chroot.c        |   8 --
 lib/libc/musl/src/linux/flock.c         |   7 -
 lib/libc/musl/src/linux/reboot.c        |   7 -
 lib/libc/musl/src/mman/madvise.c        |   9 --
 lib/libc/musl/src/mman/mincore.c        |   8 --
 lib/libc/musl/src/mman/mlock.c          |  11 --
 lib/libc/musl/src/mman/mlockall.c       |   7 -
 lib/libc/musl/src/mman/mprotect.c       |  13 --
 lib/libc/musl/src/mman/munlock.c        |   7 -
 lib/libc/musl/src/mman/munlockall.c     |   7 -
 lib/libc/musl/src/mman/posix_madvise.c  |   9 --
 lib/libc/musl/src/process/execve.c      |   8 --
 lib/libc/musl/src/unistd/_exit.c        |   7 -
 lib/libc/musl/src/unistd/access.c       |  12 --
 lib/libc/musl/src/unistd/acct.c         |   8 --
 lib/libc/musl/src/unistd/chdir.c        |   7 -
 lib/libc/musl/src/unistd/chown.c        |  12 --
 lib/libc/musl/src/unistd/ctermid.c      |   7 -
 lib/libc/musl/src/unistd/dup.c          |   7 -
 lib/libc/musl/src/unistd/fchownat.c     |   7 -
 lib/libc/musl/src/unistd/getegid.c      |   7 -
 lib/libc/musl/src/unistd/geteuid.c      |   7 -
 lib/libc/musl/src/unistd/getgid.c       |   7 -
 lib/libc/musl/src/unistd/getgroups.c    |   7 -
 lib/libc/musl/src/unistd/getpgid.c      |   7 -
 lib/libc/musl/src/unistd/getpgrp.c      |   7 -
 lib/libc/musl/src/unistd/getpid.c       |   7 -
 lib/libc/musl/src/unistd/getppid.c      |   7 -
 lib/libc/musl/src/unistd/getsid.c       |   7 -
 lib/libc/musl/src/unistd/getuid.c       |   7 -
 lib/libc/musl/src/unistd/lchown.c       |  12 --
 lib/libc/musl/src/unistd/link.c         |  12 --
 lib/libc/musl/src/unistd/linkat.c       |   7 -
 lib/libc/musl/src/unistd/mips/pipe.s    |  20 ---
 lib/libc/musl/src/unistd/mips64/pipe.s  |  19 ---
 lib/libc/musl/src/unistd/mipsn32/pipe.s |  19 ---
 lib/libc/musl/src/unistd/pipe.c         |  11 --
 lib/libc/musl/src/unistd/renameat.c     |  11 --
 lib/libc/musl/src/unistd/rmdir.c        |  12 --
 lib/libc/musl/src/unistd/setpgid.c      |   7 -
 lib/libc/musl/src/unistd/setpgrp.c      |   6 -
 lib/libc/musl/src/unistd/symlink.c      |  12 --
 lib/libc/musl/src/unistd/symlinkat.c    |   7 -
 lib/libc/musl/src/unistd/sync.c         |   7 -
 lib/libc/musl/src/unistd/unlink.c       |  12 --
 lib/libc/musl/src/unistd/unlinkat.c     |   7 -
 src/libs/musl.zig                       |  47 ------
 55 files changed, 289 insertions(+), 477 deletions(-)
 create mode 100644 lib/c/sys/capability.zig
 create mode 100644 lib/c/sys/file.zig
 create mode 100644 lib/c/sys/mman.zig
 create mode 100644 lib/c/sys/reboot.zig
 create mode 100644 lib/c/unistd.zig
 delete mode 100644 lib/libc/musl/src/linux/cap.c
 delete mode 100644 lib/libc/musl/src/linux/chroot.c
 delete mode 100644 lib/libc/musl/src/linux/flock.c
 delete mode 100644 lib/libc/musl/src/linux/reboot.c
 delete mode 100644 lib/libc/musl/src/mman/madvise.c
 delete mode 100644 lib/libc/musl/src/mman/mincore.c
 delete mode 100644 lib/libc/musl/src/mman/mlock.c
 delete mode 100644 lib/libc/musl/src/mman/mlockall.c
 delete mode 100644 lib/libc/musl/src/mman/mprotect.c
 delete mode 100644 lib/libc/musl/src/mman/munlock.c
 delete mode 100644 lib/libc/musl/src/mman/munlockall.c
 delete mode 100644 lib/libc/musl/src/mman/posix_madvise.c
 delete mode 100644 lib/libc/musl/src/process/execve.c
 delete mode 100644 lib/libc/musl/src/unistd/_exit.c
 delete mode 100644 lib/libc/musl/src/unistd/access.c
 delete mode 100644 lib/libc/musl/src/unistd/acct.c
 delete mode 100644 lib/libc/musl/src/unistd/chdir.c
 delete mode 100644 lib/libc/musl/src/unistd/chown.c
 delete mode 100644 lib/libc/musl/src/unistd/ctermid.c
 delete mode 100644 lib/libc/musl/src/unistd/dup.c
 delete mode 100644 lib/libc/musl/src/unistd/fchownat.c
 delete mode 100644 lib/libc/musl/src/unistd/getegid.c
 delete mode 100644 lib/libc/musl/src/unistd/geteuid.c
 delete mode 100644 lib/libc/musl/src/unistd/getgid.c
 delete mode 100644 lib/libc/musl/src/unistd/getgroups.c
 delete mode 100644 lib/libc/musl/src/unistd/getpgid.c
 delete mode 100644 lib/libc/musl/src/unistd/getpgrp.c
 delete mode 100644 lib/libc/musl/src/unistd/getpid.c
 delete mode 100644 lib/libc/musl/src/unistd/getppid.c
 delete mode 100644 lib/libc/musl/src/unistd/getsid.c
 delete mode 100644 lib/libc/musl/src/unistd/getuid.c
 delete mode 100644 lib/libc/musl/src/unistd/lchown.c
 delete mode 100644 lib/libc/musl/src/unistd/link.c
 delete mode 100644 lib/libc/musl/src/unistd/linkat.c
 delete mode 100644 lib/libc/musl/src/unistd/mips/pipe.s
 delete mode 100644 lib/libc/musl/src/unistd/mips64/pipe.s
 delete mode 100644 lib/libc/musl/src/unistd/mipsn32/pipe.s
 delete mode 100644 lib/libc/musl/src/unistd/pipe.c
 delete mode 100644 lib/libc/musl/src/unistd/renameat.c
 delete mode 100644 lib/libc/musl/src/unistd/rmdir.c
 delete mode 100644 lib/libc/musl/src/unistd/setpgid.c
 delete mode 100644 lib/libc/musl/src/unistd/setpgrp.c
 delete mode 100644 lib/libc/musl/src/unistd/symlink.c
 delete mode 100644 lib/libc/musl/src/unistd/symlinkat.c
 delete mode 100644 lib/libc/musl/src/unistd/sync.c
 delete mode 100644 lib/libc/musl/src/unistd/unlink.c
 delete mode 100644 lib/libc/musl/src/unistd/unlinkat.c

diff --git a/lib/c.zig b/lib/c.zig
index 31176d04c3ead690d17302fcf907afc639ebeced..681a6f73a58d136e9f8f29679cf4c7de91b38286 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -26,6 +26,7 @@ comptime {
     _ = @import("c/wchar.zig");
 
     _ = @import("c/sys.zig");
+    _ = @import("c/unistd.zig");
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         // Files specific to musl and wasi-libc.
diff --git a/lib/c/sys.zig b/lib/c/sys.zig
index d19baf1b0e963777cc9c2f96d6ed0ffb384c8943..71e068616b28b78f8b2f341a313310430106e4cf 100644
--- a/lib/c/sys.zig
+++ b/lib/c/sys.zig
@@ -1,3 +1,7 @@
 comptime {
+    _ = @import("sys/mman.zig");
+    _ = @import("sys/file.zig");
+    _ = @import("sys/reboot.zig");
+    _ = @import("sys/capability.zig");
     _ = @import("sys/utsname.zig");
 }
diff --git a/lib/c/sys/capability.zig b/lib/c/sys/capability.zig
new file mode 100644
index 0000000000000000000000000000000000000000..19718a45e3f925129859d25d738a60b84d4ccd98
--- /dev/null
+++ b/lib/c/sys/capability.zig
@@ -0,0 +1,18 @@
+const std = @import("std");
+const common = @import("../common.zig");
+const builtin = @import("builtin");
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        @export(&capsetLinux, .{ .name = "capset", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&capgetLinux, .{ .name = "capget", .linkage = common.linkage, .visibility = common.visibility });
+    }
+}
+
+fn capsetLinux(hdrp: *anyopaque, datap: *anyopaque) callconv(.c) c_int {
+    return common.errno(std.os.linux.capset(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap))));
+}
+
+fn capgetLinux(hdrp: *anyopaque, datap: *anyopaque) callconv(.c) c_int {
+    return common.errno(std.os.linux.capget(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap))));
+}
diff --git a/lib/c/sys/file.zig b/lib/c/sys/file.zig
new file mode 100644
index 0000000000000000000000000000000000000000..643d3fcd037f9459cdb679e301c8cd9da3f5f28a
--- /dev/null
+++ b/lib/c/sys/file.zig
@@ -0,0 +1,13 @@
+const std = @import("std");
+const common = @import("../common.zig");
+const builtin = @import("builtin");
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        @export(&flockLinux, .{ .name = "flock", .linkage = common.linkage, .visibility = common.visibility });
+    }
+}
+
+fn flockLinux(fd: c_int, operation: c_int) callconv(.c) c_int {
+    return common.errno(std.os.linux.flock(fd, operation));
+}
diff --git a/lib/c/sys/mman.zig b/lib/c/sys/mman.zig
new file mode 100644
index 0000000000000000000000000000000000000000..07ce732bba203db6c5314835fadb4f250913e5b0
--- /dev/null
+++ b/lib/c/sys/mman.zig
@@ -0,0 +1,57 @@
+const std = @import("std");
+const common = @import("../common.zig");
+const builtin = @import("builtin");
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        @export(&madviseLinux, .{ .name = "madvise", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&madviseLinux, .{ .name = "__madvise", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&mlockLinux, .{ .name = "mlock", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&mlockallLinux, .{ .name = "mlockall", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&mprotectLinux, .{ .name = "mprotect", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&mprotectLinux, .{ .name = "__mprotect", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&munlockLinux, .{ .name = "munlock", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&munlockallLinux, .{ .name = "munlockall", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&posix_madviseLinux, .{ .name = "posix_madvise", .linkage = common.linkage, .visibility = common.visibility });
+    }
+}
+
+fn madviseLinux(addr: *anyopaque, len: usize, advice: c_int) callconv(.c) c_int {
+    return common.errno(std.os.linux.madvise(@ptrCast(addr), len, @bitCast(advice)));
+}
+
+fn mincoreLinux(addr: *anyopaque, len: usize, vec: [*]u8) callconv(.c) c_int {
+    return common.errno(std.os.linux.mincore(@ptrCast(addr), len, vec));
+}
+
+fn mlockLinux(addr: *const anyopaque, len: usize) callconv(.c) c_int {
+    return common.errno(std.os.linux.mlock(@ptrCast(addr), len));
+}
+
+fn mlockallLinux(flags: c_int) callconv(.c) c_int {
+    return common.errno(std.os.linux.mlockall(@bitCast(flags)));
+}
+
+fn mprotectLinux(addr: *anyopaque, len: usize, prot: c_int) callconv(.c) c_int {
+    const page_size = std.heap.pageSize();
+    const start = std.mem.alignBackward(usize, @intFromPtr(addr), page_size);
+    const aligned_len = std.mem.alignForward(usize, len, page_size);
+    return common.errno(std.os.linux.mprotect(@ptrFromInt(start), aligned_len, @bitCast(prot)));
+}
+
+fn munlockLinux(addr: *const anyopaque, len: usize) callconv(.c) c_int {
+    return common.errno(std.os.linux.munlock(@ptrCast(addr), len));
+}
+
+fn munlockallLinux() callconv(.c) c_int {
+    return common.errno(std.os.linux.munlockall());
+}
+
+fn posix_madviseLinux(addr: *anyopaque, len: usize, advice: c_int) callconv(.c) c_int {
+    if (advice == std.os.linux.MADV.DONTNEED) return 0;
+    return @intCast(-@as(isize, @bitCast(std.os.linux.madvise(@ptrCast(addr), len, @bitCast(advice)))));
+}
diff --git a/lib/c/sys/reboot.zig b/lib/c/sys/reboot.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8b7b0503bd14ff7868cd17b9b22cc211bf529833
--- /dev/null
+++ b/lib/c/sys/reboot.zig
@@ -0,0 +1,13 @@
+const std = @import("std");
+const common = @import("../common.zig");
+const builtin = @import("builtin");
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        @export(&rebootLinux, .{ .name = "reboot", .linkage = common.linkage, .visibility = common.visibility });
+    }
+}
+
+fn rebootLinux(cmd: c_int) callconv(.c) c_int {
+    return common.errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @enumFromInt(cmd), null));
+}
diff --git a/lib/c/unistd.zig b/lib/c/unistd.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f903ef78a8d16a280b959e48a54b91a7635a5e00
--- /dev/null
+++ b/lib/c/unistd.zig
@@ -0,0 +1,183 @@
+const std = @import("std");
+const common = @import("common.zig");
+const builtin = @import("builtin");
+const linux = std.os.linux;
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        @export(&_exit, .{ .name = "_exit", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&accessLinux, .{ .name = "access", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&acctLinux, .{ .name = "acct", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&chdirLinux, .{ .name = "chdir", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&chownLinux, .{ .name = "chown", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&fchownatLinux, .{ .name = "fchownat", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&lchownLinux, .{ .name = "lchown", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&chrootLinux, .{ .name = "chroot", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&ctermidLinux, .{ .name = "ctermid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&dupLinux, .{ .name = "dup", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&getegidLinux, .{ .name = "getegid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&geteuidLinux, .{ .name = "geteuid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getgidLinux, .{ .name = "getgid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getgroupsLinux, .{ .name = "getgroups", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getpgidLinux, .{ .name = "getpgid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getpgrpLinux, .{ .name = "getpgrp", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&setpgidLinux, .{ .name = "setpgid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&setpgrpLinux, .{ .name = "setpgrp", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getsidLinux, .{ .name = "getsid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getpidLinux, .{ .name = "getpid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getppidLinux, .{ .name = "getppid", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&getuidLinux, .{ .name = "getuid", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&rmdirLinux, .{ .name = "rmdir", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&linkLinux, .{ .name = "link", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&linkatLinux, .{ .name = "linkat", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&pipeLinux, .{ .name = "pipe", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&renameatLinux, .{ .name = "renameat", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&symlinkLinux, .{ .name = "symlink", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&symlinkatLinux, .{ .name = "symlinkat", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&syncLinux, .{ .name = "sync", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&unlinkLinux, .{ .name = "unlink", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&unlinkatLinux, .{ .name = "unlinkat", .linkage = common.linkage, .visibility = common.visibility });
+
+        @export(&execveLinux, .{ .name = "execve", .linkage = common.linkage, .visibility = common.visibility });
+    }
+}
+
+fn _exit(exit_code: c_int) callconv(.c) noreturn {
+    std.c._Exit(exit_code);
+}
+
+fn accessLinux(path: [*:0]const c_char, amode: c_int) callconv(.c) c_int {
+    return common.errno(linux.access(@ptrCast(path), @bitCast(amode)));
+}
+
+fn acctLinux(path: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.acct(@ptrCast(path)));
+}
+
+fn chdirLinux(path: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.chdir(@ptrCast(path)));
+}
+
+fn chownLinux(path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t) callconv(.c) c_int {
+    return common.errno(linux.chown(@ptrCast(path), uid, gid));
+}
+
+fn fchownatLinux(fd: c_int, path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t, flags: c_int) callconv(.c) c_int {
+    return common.errno(linux.fchownat(fd, @ptrCast(path), uid, gid, @bitCast(flags)));
+}
+
+fn lchownLinux(path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t) callconv(.c) c_int {
+    return common.errno(linux.lchown(@ptrCast(path), uid, gid));
+}
+
+fn chrootLinux(path: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.chroot(@ptrCast(path)));
+}
+
+fn ctermidLinux(maybe_path: ?[*]c_char) callconv(.c) [*:0]c_char {
+    const default_tty = "/dev/tty";
+
+    return if (maybe_path) |path| blk: {
+        path[0..(default_tty.len + 1)].* = @bitCast(default_tty.*);
+        break :blk path[0..default_tty.len :0].ptr;
+    } else @ptrCast(@constCast(default_tty));
+}
+
+fn dupLinux(fd: c_int) callconv(.c) c_int {
+    return common.errno(linux.dup(fd));
+}
+
+fn getegidLinux() callconv(.c) linux.gid_t {
+    return linux.getegid();
+}
+
+fn geteuidLinux() callconv(.c) linux.uid_t {
+    return linux.geteuid();
+}
+
+fn getgidLinux() callconv(.c) linux.gid_t {
+    return linux.getgid();
+}
+
+fn getgroupsLinux(size: c_int, list: ?[*]linux.gid_t) callconv(.c) c_int {
+    return common.errno(linux.getgroups(@intCast(size), list));
+}
+
+fn getpgidLinux(pid: linux.pid_t) callconv(.c) linux.pid_t {
+    return common.errno(linux.getpgid(pid));
+}
+
+fn getpgrpLinux() callconv(.c) linux.pid_t {
+    return @intCast(linux.getpgid(0)); // @intCast as it cannot fail
+}
+
+fn setpgidLinux(pid: linux.pid_t, pgid: linux.pid_t) callconv(.c) c_int {
+    return common.errno(linux.setpgid(pid, pgid));
+}
+
+fn setpgrpLinux() callconv(.c) linux.pid_t {
+    return @intCast(linux.setpgid(0, 0)); // @intCast as it cannot fail
+}
+
+fn getpidLinux() callconv(.c) linux.pid_t {
+    return linux.getpid();
+}
+
+fn getppidLinux() callconv(.c) linux.pid_t {
+    return linux.getppid();
+}
+
+fn getsidLinux(pid: linux.pid_t) callconv(.c) linux.pid_t {
+    return common.errno(linux.getsid(pid));
+}
+
+fn getuidLinux() callconv(.c) linux.uid_t {
+    return linux.getuid();
+}
+
+fn linkLinux(old: [*:0]const c_char, new: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.link(@ptrCast(old), @ptrCast(new)));
+}
+
+fn linkatLinux(old_fd: c_int, old: [*:0]const c_char, new_fd: c_int, new: [*:0]const c_char, flags: c_int) callconv(.c) c_int {
+    return common.errno(linux.linkat(old_fd, @ptrCast(old), new_fd, @ptrCast(new), @bitCast(flags)));
+}
+
+fn pipeLinux(fd: *[2]c_int) callconv(.c) c_int {
+    return common.errno(linux.pipe(@ptrCast(fd)));
+}
+
+fn renameatLinux(old_fd: c_int, old: [*:0]const c_char, new_fd: c_int, new: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.renameat(old_fd, @ptrCast(old), new_fd, @ptrCast(new)));
+}
+
+fn rmdirLinux(path: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.rmdir(@ptrCast(path)));
+}
+
+fn symlinkLinux(existing: [*:0]const c_char, new: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.symlink(@ptrCast(existing), @ptrCast(new)));
+}
+
+fn symlinkatLinux(existing: [*:0]const c_char, fd: c_int, new: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.symlinkat(@ptrCast(existing), fd, @ptrCast(new)));
+}
+
+fn syncLinux() callconv(.c) void {
+    linux.sync();
+}
+
+fn unlinkLinux(path: [*:0]const c_char) callconv(.c) c_int {
+    return common.errno(linux.unlink(@ptrCast(path)));
+}
+
+fn unlinkatLinux(fd: c_int, path: [*:0]const c_char, flags: c_int) callconv(.c) c_int {
+    return common.errno(linux.unlinkat(fd, @ptrCast(path), @bitCast(flags)));
+}
+
+fn execveLinux(path: [*:0]const c_char, argv: [*:null]const ?[*:0]c_char, envp: [*:null]const ?[*:0]c_char) callconv(.c) c_int {
+    return common.errno(linux.execve(@ptrCast(path), @ptrCast(argv), @ptrCast(envp)));
+}
diff --git a/lib/libc/musl/src/linux/cap.c b/lib/libc/musl/src/linux/cap.c
deleted file mode 100644
index 8d035e07a4c97896e4fbadfd76ba79a40e1a8ea0..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/linux/cap.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "syscall.h"
-
-int capset(void *a, void *b)
-{
-	return syscall(SYS_capset, a, b);
-}
-
-int capget(void *a, void *b)
-{
-	return syscall(SYS_capget, a, b);
-}
diff --git a/lib/libc/musl/src/linux/chroot.c b/lib/libc/musl/src/linux/chroot.c
deleted file mode 100644
index 0e69f145dee37cbdc865f6cf6e222a1658d58cdc..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/linux/chroot.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#define _GNU_SOURCE
-#include <unistd.h>
-#include "syscall.h"
-
-int chroot(const char *path)
-{
-	return syscall(SYS_chroot, path);
-}
diff --git a/lib/libc/musl/src/linux/flock.c b/lib/libc/musl/src/linux/flock.c
deleted file mode 100644
index 87aa5cfed275bf475f01bcbf63184415d01745f4..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/linux/flock.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <sys/file.h>
-#include "syscall.h"
-
-int flock(int fd, int op)
-{
-	return syscall(SYS_flock, fd, op);
-}
diff --git a/lib/libc/musl/src/linux/reboot.c b/lib/libc/musl/src/linux/reboot.c
deleted file mode 100644
index 7f12af79bc1ba13220cfca6f0c48357546019246..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/linux/reboot.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <sys/reboot.h>
-#include "syscall.h"
-
-int reboot(int type)
-{
-	return syscall(SYS_reboot, 0xfee1dead, 672274793, type);
-}
diff --git a/lib/libc/musl/src/mman/madvise.c b/lib/libc/musl/src/mman/madvise.c
deleted file mode 100644
index e0c7c0ec92b81782fdb6424f842756d434e63881..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/madvise.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <sys/mman.h>
-#include "syscall.h"
-
-int __madvise(void *addr, size_t len, int advice)
-{
-	return syscall(SYS_madvise, addr, len, advice);
-}
-
-weak_alias(__madvise, madvise);
diff --git a/lib/libc/musl/src/mman/mincore.c b/lib/libc/musl/src/mman/mincore.c
deleted file mode 100644
index 4bb19f857c66c8114587908d816dcb2d0c9ce2db..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/mincore.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#define _GNU_SOURCE
-#include <sys/mman.h>
-#include "syscall.h"
-
-int mincore (void *addr, size_t len, unsigned char *vec)
-{
-	return syscall(SYS_mincore, addr, len, vec);
-}
diff --git a/lib/libc/musl/src/mman/mlock.c b/lib/libc/musl/src/mman/mlock.c
deleted file mode 100644
index 71af582fe6a3eb1538a59a1dded009d16ab062b8..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/mlock.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <sys/mman.h>
-#include "syscall.h"
-
-int mlock(const void *addr, size_t len)
-{
-#ifdef SYS_mlock
-	return syscall(SYS_mlock, addr, len);
-#else
-	return syscall(SYS_mlock2, addr, len, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/mman/mlockall.c b/lib/libc/musl/src/mman/mlockall.c
deleted file mode 100644
index 0ba4e662c8fa42a0bfb213f0ca411cb40826bf22..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/mlockall.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <sys/mman.h>
-#include "syscall.h"
-
-int mlockall(int flags)
-{
-	return syscall(SYS_mlockall, flags);
-}
diff --git a/lib/libc/musl/src/mman/mprotect.c b/lib/libc/musl/src/mman/mprotect.c
deleted file mode 100644
index 535787b9ec527bb12acbb80a53aadc4ab760c7b3..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/mprotect.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <sys/mman.h>
-#include "libc.h"
-#include "syscall.h"
-
-int __mprotect(void *addr, size_t len, int prot)
-{
-	size_t start, end;
-	start = (size_t)addr & -PAGE_SIZE;
-	end = (size_t)((char *)addr + len + PAGE_SIZE-1) & -PAGE_SIZE;
-	return syscall(SYS_mprotect, start, end-start, prot);
-}
-
-weak_alias(__mprotect, mprotect);
diff --git a/lib/libc/musl/src/mman/munlock.c b/lib/libc/musl/src/mman/munlock.c
deleted file mode 100644
index 2cccef0c5077f1ec7085ff9bbd2158b4fe297033..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/munlock.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <sys/mman.h>
-#include "syscall.h"
-
-int munlock(const void *addr, size_t len)
-{
-	return syscall(SYS_munlock, addr, len);
-}
diff --git a/lib/libc/musl/src/mman/munlockall.c b/lib/libc/musl/src/mman/munlockall.c
deleted file mode 100644
index 6e9d39d68480150d43c0e8e9d3c98544798328c5..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/munlockall.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <sys/mman.h>
-#include "syscall.h"
-
-int munlockall(void)
-{
-	return syscall(SYS_munlockall);
-}
diff --git a/lib/libc/musl/src/mman/posix_madvise.c b/lib/libc/musl/src/mman/posix_madvise.c
deleted file mode 100644
index e5e5acb84aba85765096b00058c3804aa8a2402a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/mman/posix_madvise.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#define _GNU_SOURCE
-#include <sys/mman.h>
-#include "syscall.h"
-
-int posix_madvise(void *addr, size_t len, int advice)
-{
-	if (advice == MADV_DONTNEED) return 0;
-	return -__syscall(SYS_madvise, addr, len, advice);
-}
diff --git a/lib/libc/musl/src/process/execve.c b/lib/libc/musl/src/process/execve.c
deleted file mode 100644
index 70286a17397da61e6dc31ff6db7f0c4dd2e77ef4..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/process/execve.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int execve(const char *path, char *const argv[], char *const envp[])
-{
-	/* do we need to use environ if envp is null? */
-	return syscall(SYS_execve, path, argv, envp);
-}
diff --git a/lib/libc/musl/src/unistd/_exit.c b/lib/libc/musl/src/unistd/_exit.c
deleted file mode 100644
index 769948232e46e8be03cd2530f37b60b62d864ae1..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/_exit.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include <stdlib.h>
-
-_Noreturn void _exit(int status)
-{
-	_Exit(status);
-}
diff --git a/lib/libc/musl/src/unistd/access.c b/lib/libc/musl/src/unistd/access.c
deleted file mode 100644
index d6eed6839822f32bebf333218b6e020d08bbbd28..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/access.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int access(const char *filename, int amode)
-{
-#ifdef SYS_access
-	return syscall(SYS_access, filename, amode);
-#else
-	return syscall(SYS_faccessat, AT_FDCWD, filename, amode, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/acct.c b/lib/libc/musl/src/unistd/acct.c
deleted file mode 100644
index 308ffc3821f77e8b2ae801c74f21f30cbd551e27..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/acct.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#define _GNU_SOURCE
-#include <unistd.h>
-#include "syscall.h"
-
-int acct(const char *filename)
-{
-	return syscall(SYS_acct, filename);
-}
diff --git a/lib/libc/musl/src/unistd/chdir.c b/lib/libc/musl/src/unistd/chdir.c
deleted file mode 100644
index 5ba78b6317dc34ef50bc3278889b357afcfc978b..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/chdir.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int chdir(const char *path)
-{
-	return syscall(SYS_chdir, path);
-}
diff --git a/lib/libc/musl/src/unistd/chown.c b/lib/libc/musl/src/unistd/chown.c
deleted file mode 100644
index 14b032550d675e6594302a6107c13a599d57443a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/chown.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int chown(const char *path, uid_t uid, gid_t gid)
-{
-#ifdef SYS_chown
-	return syscall(SYS_chown, path, uid, gid);
-#else
-	return syscall(SYS_fchownat, AT_FDCWD, path, uid, gid, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/ctermid.c b/lib/libc/musl/src/unistd/ctermid.c
deleted file mode 100644
index 1612770af158ce068e2b9a1ecc89c4d910d76edd..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/ctermid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *ctermid(char *s)
-{
-	return s ? strcpy(s, "/dev/tty") : "/dev/tty";
-}
diff --git a/lib/libc/musl/src/unistd/dup.c b/lib/libc/musl/src/unistd/dup.c
deleted file mode 100644
index 7fee01201b82709a3cd0b04b3a457a846243d1a8..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/dup.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int dup(int fd)
-{
-	return syscall(SYS_dup, fd);
-}
diff --git a/lib/libc/musl/src/unistd/fchownat.c b/lib/libc/musl/src/unistd/fchownat.c
deleted file mode 100644
index 62457a3ec0eb794d63043f8dc8be0e32415347b7..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/fchownat.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int fchownat(int fd, const char *path, uid_t uid, gid_t gid, int flag)
-{
-	return syscall(SYS_fchownat, fd, path, uid, gid, flag);
-}
diff --git a/lib/libc/musl/src/unistd/getegid.c b/lib/libc/musl/src/unistd/getegid.c
deleted file mode 100644
index 6287490da2c023153ec0bbe856a7bba3801a9d53..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getegid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-gid_t getegid(void)
-{
-	return __syscall(SYS_getegid);
-}
diff --git a/lib/libc/musl/src/unistd/geteuid.c b/lib/libc/musl/src/unistd/geteuid.c
deleted file mode 100644
index 88f2cd538252b679b56ae4af475e0ea89b11c204..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/geteuid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-uid_t geteuid(void)
-{
-	return __syscall(SYS_geteuid);
-}
diff --git a/lib/libc/musl/src/unistd/getgid.c b/lib/libc/musl/src/unistd/getgid.c
deleted file mode 100644
index 1c9fe7157b351c8858c2e6d1e2aba96eb2231e20..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getgid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-gid_t getgid(void)
-{
-	return __syscall(SYS_getgid);
-}
diff --git a/lib/libc/musl/src/unistd/getgroups.c b/lib/libc/musl/src/unistd/getgroups.c
deleted file mode 100644
index 0e6e63af0129d7c9a6cc8ddb8d86a5e534a315b7..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getgroups.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int getgroups(int count, gid_t list[])
-{
-	return syscall(SYS_getgroups, count, list);
-}
diff --git a/lib/libc/musl/src/unistd/getpgid.c b/lib/libc/musl/src/unistd/getpgid.c
deleted file mode 100644
index d295bfd59b0748e6ae0dae27ed2365a1888442b1..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getpgid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-pid_t getpgid(pid_t pid)
-{
-	return syscall(SYS_getpgid, pid);
-}
diff --git a/lib/libc/musl/src/unistd/getpgrp.c b/lib/libc/musl/src/unistd/getpgrp.c
deleted file mode 100644
index 90e9bb07f6e3e19378957524d425847cec6df1c5..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getpgrp.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-pid_t getpgrp(void)
-{
-	return __syscall(SYS_getpgid, 0);
-}
diff --git a/lib/libc/musl/src/unistd/getpid.c b/lib/libc/musl/src/unistd/getpid.c
deleted file mode 100644
index a6d4e6d1bc9fc610a54b3a177a7f34bebfe50eb7..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getpid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-pid_t getpid(void)
-{
-	return __syscall(SYS_getpid);
-}
diff --git a/lib/libc/musl/src/unistd/getppid.c b/lib/libc/musl/src/unistd/getppid.c
deleted file mode 100644
index 05cade53b689226bff4a6726eafe2e97a5535b01..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getppid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-pid_t getppid(void)
-{
-	return __syscall(SYS_getppid);
-}
diff --git a/lib/libc/musl/src/unistd/getsid.c b/lib/libc/musl/src/unistd/getsid.c
deleted file mode 100644
index 93ba690e7ec22dde72bcd902924ae89dfb359306..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getsid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-pid_t getsid(pid_t pid)
-{
-	return syscall(SYS_getsid, pid);
-}
diff --git a/lib/libc/musl/src/unistd/getuid.c b/lib/libc/musl/src/unistd/getuid.c
deleted file mode 100644
index 61309d1b791497663f6942b0b9197078597f14a0..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/getuid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-uid_t getuid(void)
-{
-	return __syscall(SYS_getuid);
-}
diff --git a/lib/libc/musl/src/unistd/lchown.c b/lib/libc/musl/src/unistd/lchown.c
deleted file mode 100644
index ccd5ee0255eea2af0dcec6f134e21ce07a896faf..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/lchown.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int lchown(const char *path, uid_t uid, gid_t gid)
-{
-#ifdef SYS_lchown
-	return syscall(SYS_lchown, path, uid, gid);
-#else
-	return syscall(SYS_fchownat, AT_FDCWD, path, uid, gid, AT_SYMLINK_NOFOLLOW);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/link.c b/lib/libc/musl/src/unistd/link.c
deleted file mode 100644
index feec18e533d9595a2f37dd7fc8005b37c79b60ed..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/link.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int link(const char *existing, const char *new)
-{
-#ifdef SYS_link
-	return syscall(SYS_link, existing, new);
-#else
-	return syscall(SYS_linkat, AT_FDCWD, existing, AT_FDCWD, new, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/linkat.c b/lib/libc/musl/src/unistd/linkat.c
deleted file mode 100644
index 6a9a0b77591a2273ad99d46cd228ead6a60b73f6..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/linkat.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int linkat(int fd1, const char *existing, int fd2, const char *new, int flag)
-{
-	return syscall(SYS_linkat, fd1, existing, fd2, new, flag);
-}
diff --git a/lib/libc/musl/src/unistd/mips/pipe.s b/lib/libc/musl/src/unistd/mips/pipe.s
deleted file mode 100644
index ba2c39a304da9e5085108f3295857b6902d1c1ad..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/mips/pipe.s
+++ /dev/null
@@ -1,20 +0,0 @@
-.set noreorder
-
-.global pipe
-.type   pipe,@function
-pipe:
-	lui $gp, %hi(_gp_disp)
-	addiu $gp, %lo(_gp_disp)
-	addu $gp, $gp, $25
-	li $2, 4042
-	syscall
-	beq $7, $0, 1f
-	nop
-	lw $25, %call16(__syscall_ret)($gp)
-	jr $25
-	subu $4, $0, $2
-1:	sw $2, 0($4)
-	sw $3, 4($4)
-	move $2, $0
-	jr $ra
-	nop
diff --git a/lib/libc/musl/src/unistd/mips64/pipe.s b/lib/libc/musl/src/unistd/mips64/pipe.s
deleted file mode 100644
index f8a27dccfbc2fcccaf92b17ddad60bc05079bc99..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/mips64/pipe.s
+++ /dev/null
@@ -1,19 +0,0 @@
-.set	noreorder
-.global	pipe
-.type	pipe,@function
-pipe:
-	lui	$3, %hi(%neg(%gp_rel(pipe)))
-	daddiu	$3, $3, %lo(%neg(%gp_rel(pipe)))
-	daddu	$3, $3, $25
-	li	$2, 5021
-	syscall
-	beq	$7, $0, 1f
-	nop
-	ld	$25, %got_disp(__syscall_ret)($3)
-	jr	$25
-	dsubu	$4, $0, $2
-1:	sw	$2, 0($4)
-	sw	$3, 4($4)
-	move	$2, $0
-	jr	$ra
-	nop
diff --git a/lib/libc/musl/src/unistd/mipsn32/pipe.s b/lib/libc/musl/src/unistd/mipsn32/pipe.s
deleted file mode 100644
index 80f882e2b1c48a2fccf13a778cba02871786fd44..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/mipsn32/pipe.s
+++ /dev/null
@@ -1,19 +0,0 @@
-.set	noreorder
-.global	pipe
-.type	pipe,@function
-pipe:
-	lui	$3, %hi(%neg(%gp_rel(pipe)))
-	addiu	$3, $3, %lo(%neg(%gp_rel(pipe)))
-	addu	$3, $3, $25
-	li	$2, 6021
-	syscall
-	beq	$7, $0, 1f
-	nop
-	lw	$25, %got_disp(__syscall_ret)($3)
-	jr	$25
-	subu	$4, $0, $2
-1:	sw	$2, 0($4)
-	sw	$3, 4($4)
-	move	$2, $0
-	jr	$ra
-	nop
diff --git a/lib/libc/musl/src/unistd/pipe.c b/lib/libc/musl/src/unistd/pipe.c
deleted file mode 100644
index d07b8d24ae3b1f55126700e64994ab55d453fb16..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/pipe.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int pipe(int fd[2])
-{
-#ifdef SYS_pipe
-	return syscall(SYS_pipe, fd);
-#else
-	return syscall(SYS_pipe2, fd, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/renameat.c b/lib/libc/musl/src/unistd/renameat.c
deleted file mode 100644
index c3b40a258b2822214ce05a0cf1788d9af6298067..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/renameat.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-#include "syscall.h"
-
-int renameat(int oldfd, const char *old, int newfd, const char *new)
-{
-#ifdef SYS_renameat
-	return syscall(SYS_renameat, oldfd, old, newfd, new);
-#else
-	return syscall(SYS_renameat2, oldfd, old, newfd, new, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/rmdir.c b/lib/libc/musl/src/unistd/rmdir.c
deleted file mode 100644
index 6825ffc8359a557790d278c8827061b9ed18564a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/rmdir.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int rmdir(const char *path)
-{
-#ifdef SYS_rmdir
-	return syscall(SYS_rmdir, path);
-#else
-	return syscall(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/setpgid.c b/lib/libc/musl/src/unistd/setpgid.c
deleted file mode 100644
index 061606951d4f170ad9bf80b31ee3414a12c64bac..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/setpgid.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int setpgid(pid_t pid, pid_t pgid)
-{
-	return syscall(SYS_setpgid, pid, pgid);
-}
diff --git a/lib/libc/musl/src/unistd/setpgrp.c b/lib/libc/musl/src/unistd/setpgrp.c
deleted file mode 100644
index a2a37f65f3b7ec1c0aff38da28949b1972ec80a5..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/setpgrp.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <unistd.h>
-
-pid_t setpgrp(void)
-{
-	return setpgid(0, 0);
-}
diff --git a/lib/libc/musl/src/unistd/symlink.c b/lib/libc/musl/src/unistd/symlink.c
deleted file mode 100644
index 0973d78a8936bca2cef633f361abd2401bd82f4a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/symlink.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int symlink(const char *existing, const char *new)
-{
-#ifdef SYS_symlink
-	return syscall(SYS_symlink, existing, new);
-#else
-	return syscall(SYS_symlinkat, existing, AT_FDCWD, new);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/symlinkat.c b/lib/libc/musl/src/unistd/symlinkat.c
deleted file mode 100644
index d1c59b4db0991d18e2d15895709d72c636f09556..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/symlinkat.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int symlinkat(const char *existing, int fd, const char *new)
-{
-	return syscall(SYS_symlinkat, existing, fd, new);
-}
diff --git a/lib/libc/musl/src/unistd/sync.c b/lib/libc/musl/src/unistd/sync.c
deleted file mode 100644
index f18765aa85063b6052ae6d6ffd625cfac617e705..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/sync.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-void sync(void)
-{
-	__syscall(SYS_sync);
-}
diff --git a/lib/libc/musl/src/unistd/unlink.c b/lib/libc/musl/src/unistd/unlink.c
deleted file mode 100644
index c40c28d50be4e59951afb14dea3436f768e01cc1..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/unlink.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unistd.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int unlink(const char *path)
-{
-#ifdef SYS_unlink
-	return syscall(SYS_unlink, path);
-#else
-	return syscall(SYS_unlinkat, AT_FDCWD, path, 0);
-#endif
-}
diff --git a/lib/libc/musl/src/unistd/unlinkat.c b/lib/libc/musl/src/unistd/unlinkat.c
deleted file mode 100644
index e0e25d22a30c47efc6e98df9f2d4c89953039919..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/unlinkat.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <unistd.h>
-#include "syscall.h"
-
-int unlinkat(int fd, const char *path, int flag)
-{
-	return syscall(SYS_unlinkat, fd, path, flag);
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 295e5169308a3200bbeec50a709b0035b68d72ca..3c2c4dd25fed0d205bbbf9d9be0b9f3fb78467a3 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -704,8 +704,6 @@ const src_files = [_][]const u8{
     "musl/src/linux/arch_prctl.c",
     "musl/src/linux/brk.c",
     "musl/src/linux/cache.c",
-    "musl/src/linux/cap.c",
-    "musl/src/linux/chroot.c",
     "musl/src/linux/clock_adjtime.c",
     "musl/src/linux/clone.c",
     "musl/src/linux/copy_file_range.c",
@@ -713,7 +711,6 @@ const src_files = [_][]const u8{
     "musl/src/linux/eventfd.c",
     "musl/src/linux/fallocate.c",
     "musl/src/linux/fanotify.c",
-    "musl/src/linux/flock.c",
     "musl/src/linux/getdents.c",
     "musl/src/linux/getrandom.c",
     "musl/src/linux/gettid.c",
@@ -738,7 +735,6 @@ const src_files = [_][]const u8{
     "musl/src/linux/pwritev2.c",
     "musl/src/linux/quotactl.c",
     "musl/src/linux/readahead.c",
-    "musl/src/linux/reboot.c",
     "musl/src/linux/remap_file_pages.c",
     "musl/src/linux/sbrk.c",
     "musl/src/linux/sendfile.c",
@@ -1157,18 +1153,10 @@ const src_files = [_][]const u8{
     "musl/src/misc/syscall.c",
     "musl/src/misc/syslog.c",
     "musl/src/misc/wordexp.c",
-    "musl/src/mman/madvise.c",
-    "musl/src/mman/mincore.c",
-    "musl/src/mman/mlockall.c",
-    "musl/src/mman/mlock.c",
     "musl/src/mman/mmap.c",
-    "musl/src/mman/mprotect.c",
     "musl/src/mman/mremap.c",
     "musl/src/mman/msync.c",
-    "musl/src/mman/munlockall.c",
-    "musl/src/mman/munlock.c",
     "musl/src/mman/munmap.c",
-    "musl/src/mman/posix_madvise.c",
     "musl/src/mman/shm_open.c",
     "musl/src/mq/mq_close.c",
     "musl/src/mq/mq_getattr.c",
@@ -1304,7 +1292,6 @@ const src_files = [_][]const u8{
     "musl/src/process/execle.c",
     "musl/src/process/execlp.c",
     "musl/src/process/execv.c",
-    "musl/src/process/execve.c",
     "musl/src/process/execvp.c",
     "musl/src/process/fexecve.c",
     "musl/src/process/fork.c",
@@ -1871,51 +1858,26 @@ const src_files = [_][]const u8{
     "musl/src/time/utime.c",
     "musl/src/time/wcsftime.c",
     "musl/src/time/__year_to_secs.c",
-    "musl/src/unistd/access.c",
-    "musl/src/unistd/acct.c",
     "musl/src/unistd/alarm.c",
-    "musl/src/unistd/chdir.c",
-    "musl/src/unistd/chown.c",
     "musl/src/unistd/close.c",
-    "musl/src/unistd/ctermid.c",
     "musl/src/unistd/dup2.c",
     "musl/src/unistd/dup3.c",
-    "musl/src/unistd/dup.c",
-    "musl/src/unistd/_exit.c",
     "musl/src/unistd/faccessat.c",
     "musl/src/unistd/fchdir.c",
-    "musl/src/unistd/fchownat.c",
     "musl/src/unistd/fchown.c",
     "musl/src/unistd/fdatasync.c",
     "musl/src/unistd/fsync.c",
     "musl/src/unistd/ftruncate.c",
     "musl/src/unistd/getcwd.c",
-    "musl/src/unistd/getegid.c",
-    "musl/src/unistd/geteuid.c",
-    "musl/src/unistd/getgid.c",
-    "musl/src/unistd/getgroups.c",
     "musl/src/unistd/gethostname.c",
     "musl/src/unistd/getlogin.c",
     "musl/src/unistd/getlogin_r.c",
-    "musl/src/unistd/getpgid.c",
-    "musl/src/unistd/getpgrp.c",
-    "musl/src/unistd/getpid.c",
-    "musl/src/unistd/getppid.c",
-    "musl/src/unistd/getsid.c",
-    "musl/src/unistd/getuid.c",
     "musl/src/unistd/isatty.c",
-    "musl/src/unistd/lchown.c",
-    "musl/src/unistd/linkat.c",
-    "musl/src/unistd/link.c",
     "musl/src/unistd/lseek.c",
-    "musl/src/unistd/mips64/pipe.s",
     "musl/src/unistd/mipsn32/lseek.c",
-    "musl/src/unistd/mipsn32/pipe.s",
-    "musl/src/unistd/mips/pipe.s",
     "musl/src/unistd/nice.c",
     "musl/src/unistd/pause.c",
     "musl/src/unistd/pipe2.c",
-    "musl/src/unistd/pipe.c",
     "musl/src/unistd/posix_close.c",
     "musl/src/unistd/pread.c",
     "musl/src/unistd/preadv.c",
@@ -1925,13 +1887,9 @@ const src_files = [_][]const u8{
     "musl/src/unistd/readlinkat.c",
     "musl/src/unistd/readlink.c",
     "musl/src/unistd/readv.c",
-    "musl/src/unistd/renameat.c",
-    "musl/src/unistd/rmdir.c",
     "musl/src/unistd/setegid.c",
     "musl/src/unistd/seteuid.c",
     "musl/src/unistd/setgid.c",
-    "musl/src/unistd/setpgid.c",
-    "musl/src/unistd/setpgrp.c",
     "musl/src/unistd/setregid.c",
     "musl/src/unistd/setresgid.c",
     "musl/src/unistd/setresuid.c",
@@ -1940,17 +1898,12 @@ const src_files = [_][]const u8{
     "musl/src/unistd/setuid.c",
     "musl/src/unistd/setxid.c",
     "musl/src/unistd/sleep.c",
-    "musl/src/unistd/symlinkat.c",
-    "musl/src/unistd/symlink.c",
-    "musl/src/unistd/sync.c",
     "musl/src/unistd/tcgetpgrp.c",
     "musl/src/unistd/tcsetpgrp.c",
     "musl/src/unistd/truncate.c",
     "musl/src/unistd/ttyname.c",
     "musl/src/unistd/ttyname_r.c",
     "musl/src/unistd/ualarm.c",
-    "musl/src/unistd/unlinkat.c",
-    "musl/src/unistd/unlink.c",
     "musl/src/unistd/usleep.c",
     "musl/src/unistd/write.c",
     "musl/src/unistd/writev.c",
-- 
2.54.0


From 99ec1ee3536b577bd1d14facde523c503108886d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 24 Jan 2026 21:07:53 +0100
Subject: [PATCH 040/499] ci: temporarily disable x86_64-netbsd while I
 investigate failures

---
 .forgejo/workflows/ci.yaml | 40 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 48813b9001d0463d39b7ce8e2566ae5dad555b87..7e758bb67db1b935fd7fb4efeb7174a8a2f92ba1 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -197,26 +197,26 @@ jobs:
         run: sh ci/x86_64-linux-release.sh
         timeout-minutes: 360
 
-  x86_64-netbsd-debug:
-    runs-on: [self-hosted, x86_64-netbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-netbsd-debug.sh
-        timeout-minutes: 120
-  x86_64-netbsd-release:
-    runs-on: [self-hosted, x86_64-netbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-netbsd-release.sh
-        timeout-minutes: 120
+  #x86_64-netbsd-debug:
+  #  runs-on: [self-hosted, x86_64-netbsd]
+  #  steps:
+  #    - name: Checkout
+  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+  #      with:
+  #        fetch-depth: 0
+  #    - name: Build and Test
+  #      run: sh ci/x86_64-netbsd-debug.sh
+  #      timeout-minutes: 120
+  #x86_64-netbsd-release:
+  #  runs-on: [self-hosted, x86_64-netbsd]
+  #  steps:
+  #    - name: Checkout
+  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+  #      with:
+  #        fetch-depth: 0
+  #    - name: Build and Test
+  #      run: sh ci/x86_64-netbsd-release.sh
+  #      timeout-minutes: 120
 
   x86_64-openbsd-debug:
     runs-on: [self-hosted, x86_64-openbsd]
-- 
2.54.0


From 8709f53d440ed8479f711d871a2d6c2c35dc1014 Mon Sep 17 00:00:00 2001
From: Frank Denis <jedisct1@noreply.codeberg.org>
Date: Sun, 25 Jan 2026 17:42:01 +0100
Subject: [PATCH 041/499] crypto.ff: allow seamless chaining regardless of
 representation (#30913)

Finite field elements can be in regular or Montgomery form, and
chaining different operations use to require manual and error-prone
conversions.

Now:

- `add`, `sub` and `mul` convert the second operand to match the
first operand's form
- `sq` and `pow` preserve the input's Montgomery form
- `toPrimitive` and `toBytes` return `UnexpectedRepresentation` if
the element is in Montgomery form, preventing incorrect serialization

This is fully backwards compatible and allows seamless chaining of
operations regardless of their representation.
---
 lib/std/crypto/ff.zig | 166 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 134 insertions(+), 32 deletions(-)

diff --git a/lib/std/crypto/ff.zig b/lib/std/crypto/ff.zig
index ff018b3c9b04cae4114180601dbd9ede8acc2c43..1b89514db3e46967f99aca8b34df2cfc1aadc520 100644
--- a/lib/std/crypto/ff.zig
+++ b/lib/std/crypto/ff.zig
@@ -329,7 +329,11 @@ fn Fe_(comptime bits: comptime_int) type {
 
         /// Converts the field element to a primitive.
         /// This function may not run in constant time.
-        pub fn toPrimitive(self: Self, comptime T: type) OverflowError!T {
+        /// Returns an error if the element is in Montgomery form.
+        pub fn toPrimitive(self: Self, comptime T: type) (OverflowError || RepresentationError)!T {
+            if (self.montgomery) {
+                return error.UnexpectedRepresentation;
+            }
             return self.v.toPrimitive(T);
         }
 
@@ -343,7 +347,11 @@ fn Fe_(comptime bits: comptime_int) type {
         }
 
         /// Converts the field element to a byte string.
-        pub fn toBytes(self: Self, bytes: []u8, comptime endian: Endian) OverflowError!void {
+        /// Returns an error if the element is in Montgomery form.
+        pub fn toBytes(self: Self, bytes: []u8, comptime endian: Endian) (OverflowError || RepresentationError)!void {
+            if (self.montgomery) {
+                return error.UnexpectedRepresentation;
+            }
             return self.v.toBytes(bytes, endian);
         }
 
@@ -530,19 +538,46 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
         /// Adds two field elements (mod m).
         pub fn add(self: Self, x: Fe, y: Fe) Fe {
             var out = x;
-            const overflow = out.v.addWithOverflow(y.v);
-            const underflow: u1 = @bitCast(ct.limbsCmpLt(out.v, self.v));
-            const need_sub = ct.eql(overflow, underflow);
-            _ = out.v.conditionalSubWithOverflow(need_sub, self.v);
-            return out;
+            if (x.montgomery == y.montgomery) {
+                @branchHint(.likely);
+                const overflow = out.v.addWithOverflow(y.v);
+                const underflow: u1 = @bitCast(ct.limbsCmpLt(out.v, self.v));
+                const need_sub = ct.eql(overflow, underflow);
+                _ = out.v.conditionalSubWithOverflow(need_sub, self.v);
+                return out;
+            } else {
+                var y_ = y;
+                if (y.montgomery) {
+                    self.fromMontgomery(&y_) catch unreachable;
+                } else {
+                    self.toMontgomery(&y_) catch unreachable;
+                }
+                const overflow = out.v.addWithOverflow(y_.v);
+                const underflow: u1 = @bitCast(ct.limbsCmpLt(out.v, self.v));
+                const need_sub = ct.eql(overflow, underflow);
+                _ = out.v.conditionalSubWithOverflow(need_sub, self.v);
+                return out;
+            }
         }
 
         /// Subtracts two field elements (mod m).
         pub fn sub(self: Self, x: Fe, y: Fe) Fe {
             var out = x;
-            const underflow: bool = @bitCast(out.v.subWithOverflow(y.v));
-            _ = out.v.conditionalAddWithOverflow(underflow, self.v);
-            return out;
+            if (x.montgomery == y.montgomery) {
+                const underflow: bool = @bitCast(out.v.subWithOverflow(y.v));
+                _ = out.v.conditionalAddWithOverflow(underflow, self.v);
+                return out;
+            } else {
+                var y_ = y;
+                if (y.montgomery) {
+                    self.fromMontgomery(&y_) catch unreachable;
+                } else {
+                    self.toMontgomery(&y_) catch unreachable;
+                }
+                const underflow: bool = @bitCast(out.v.subWithOverflow(y_.v));
+                _ = out.v.conditionalAddWithOverflow(underflow, self.v);
+                return out;
+            }
         }
 
         /// Converts a field element to the Montgomery form.
@@ -663,13 +698,15 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
             for (e) |b| acc |= b;
             if (acc == 0) return error.NullExponent;
 
+            const was_montgomery = x.montgomery;
+
             var out = self.one();
             self.toMontgomery(&out) catch unreachable;
 
             if (public and e.len < 3 or (e.len == 3 and e[if (endian == .big) 0 else 2] <= 0b1111)) {
                 // Do not use a precomputation table for short, public exponents
                 var x_m = x;
-                if (x.montgomery == false) {
+                if (!x.montgomery) {
                     self.toMontgomery(&x_m) catch unreachable;
                 }
                 var s = switch (endian) {
@@ -702,7 +739,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
             } else {
                 // Use a precomputation table for large exponents
                 var pc = [1]Fe{x} ++ [_]Fe{self.zero} ** 14;
-                if (x.montgomery == false) {
+                if (!x.montgomery) {
                     self.toMontgomery(&pc[0]) catch unreachable;
                 }
                 for (1..pc.len) |i| {
@@ -747,38 +784,55 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
                     }
                 }
             }
-            self.fromMontgomery(&out) catch unreachable;
+            if (!was_montgomery) {
+                self.fromMontgomery(&out) catch unreachable;
+            }
             return out;
         }
 
         /// Multiplies two field elements.
+        /// Result preserves the first operand's form.
         pub fn mul(self: Self, x: Fe, y: Fe) Fe {
-            if (x.montgomery != y.montgomery) {
-                return self.montgomeryMul(x, y);
-            }
-            var a_ = x;
-            if (x.montgomery == false) {
-                self.toMontgomery(&a_) catch unreachable;
+            if (x.montgomery) {
+                const y_ = if (!y.montgomery) blk: {
+                    var yy = y;
+                    self.toMontgomery(&yy) catch unreachable;
+                    break :blk yy;
+                } else y;
+                return self.montgomeryMul(x, y_);
             } else {
-                self.fromMontgomery(&a_) catch unreachable;
+                var x_m = x;
+                var y_m = if (y.montgomery) blk: {
+                    var yy = y;
+                    self.fromMontgomery(&yy) catch unreachable;
+                    break :blk yy;
+                } else y;
+                self.toMontgomery(&x_m) catch unreachable;
+                self.toMontgomery(&y_m) catch unreachable;
+                var out = self.montgomeryMul(x_m, y_m);
+                self.fromMontgomery(&out) catch unreachable;
+                return out;
             }
-            return self.montgomeryMul(a_, y);
         }
 
         /// Squares a field element.
         pub fn sq(self: Self, x: Fe) Fe {
-            var out = x;
-            if (x.montgomery == true) {
+            if (x.montgomery) {
+                return self.montgomerySq(x);
+            } else {
+                var out = x;
+                self.toMontgomery(&out) catch unreachable;
+                out = self.montgomerySq(out);
                 self.fromMontgomery(&out) catch unreachable;
+                return out;
             }
-            out = self.montgomerySq(out);
-            out.montgomery = false;
-            self.toMontgomery(&out) catch unreachable;
-            return out;
         }
 
         /// Returns x^e (mod m) in constant time.
-        pub fn pow(self: Self, x: Fe, e: Fe) NullExponentError!Fe {
+        pub fn pow(self: Self, x: Fe, e: Fe) (NullExponentError || RepresentationError)!Fe {
+            if (e.montgomery) {
+                return error.UnexpectedRepresentation;
+            }
             var buf: [Fe.encoded_bytes]u8 = undefined;
             e.toBytes(&buf, native_endian) catch unreachable;
             return self.powWithEncodedExponent(x, &buf, native_endian);
@@ -786,7 +840,10 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
 
         /// Returns x^e (mod m), assuming that the exponent is public.
         /// The function remains constant time with respect to `x`.
-        pub fn powPublic(self: Self, x: Fe, e: Fe) NullExponentError!Fe {
+        pub fn powPublic(self: Self, x: Fe, e: Fe) (NullExponentError || RepresentationError)!Fe {
+            if (e.montgomery) {
+                return error.UnexpectedRepresentation;
+            }
             var e_normalized = Fe{ .v = e.v.normalize() };
             var buf_: [Fe.encoded_bytes]u8 = undefined;
             var buf = buf_[0 .. math.divCeil(usize, e_normalized.v.limbs_len * t_bits, 8) catch unreachable];
@@ -927,6 +984,8 @@ test "finite field arithmetic" {
 
     try m.toMontgomery(&x);
     x_y = m.mul(x, y);
+    try testing.expect(x_y.montgomery); // result preserves first operand's form
+    try m.fromMontgomery(&x_y);
     try testing.expectEqual(x_y.toPrimitive(u256), 1666576607955767413750776202132407807424848069716933450241);
     try m.fromMontgomery(&x);
 
@@ -941,8 +1000,11 @@ test "finite field arithmetic" {
 
     const x_pow_y = try m.powPublic(x, y);
     try testing.expectEqual(x_pow_y.toPrimitive(u256), 1631933139300737762906024873185789093007782131928298618473);
+    try testing.expect(!x_pow_y.montgomery);
     try m.toMontgomery(&x);
-    const x_pow_y2 = try m.powPublic(x, y);
+    var x_pow_y2 = try m.powPublic(x, y);
+    try testing.expect(x_pow_y2.montgomery);
+    try m.fromMontgomery(&x_pow_y2);
     try m.fromMontgomery(&x);
     try testing.expect(x_pow_y2.eql(x_pow_y));
     try testing.expectError(error.NullExponent, m.powPublic(x, m.zero));
@@ -953,13 +1015,53 @@ test "finite field arithmetic" {
 
     const x_sq = m.sq(x);
     const x_sq2 = m.mul(x, x);
+    try testing.expect(!x_sq.montgomery);
+    try testing.expect(!x_sq2.montgomery);
     try testing.expect(x_sq.eql(x_sq2));
     try m.toMontgomery(&x);
-    const x_sq3 = m.sq(x);
-    const x_sq4 = m.mul(x, x);
+    var x_sq3 = m.sq(x);
+    var x_sq4 = m.mul(x, x);
+    try testing.expect(x_sq3.montgomery);
+    try testing.expect(x_sq4.montgomery);
+    try m.fromMontgomery(&x_sq3);
+    try m.fromMontgomery(&x_sq4);
     try testing.expect(x_sq.eql(x_sq3));
     try testing.expect(x_sq3.eql(x_sq4));
     try m.fromMontgomery(&x);
+
+    var x_mont = x;
+    try m.toMontgomery(&x_mont);
+
+    // Non-montgomery + montgomery
+    const add_nm_m = m.add(x, x_mont);
+    try testing.expect(!add_nm_m.montgomery);
+    var add_m_nm = m.add(x_mont, x);
+    try testing.expect(add_m_nm.montgomery);
+    try m.fromMontgomery(&add_m_nm);
+    try testing.expect(add_nm_m.eql(add_m_nm));
+
+    // Non-montgomery - montgomery
+    const sub_nm_m = m.sub(x, y);
+    try testing.expect(!sub_nm_m.montgomery);
+    var y_mont = y;
+    try m.toMontgomery(&y_mont);
+    var sub_m_nm = m.sub(x_mont, y);
+    try testing.expect(sub_m_nm.montgomery);
+    try m.fromMontgomery(&sub_m_nm);
+    try testing.expect(sub_nm_m.eql(sub_m_nm));
+
+    // mul: preserves first operand's form
+    const mul_nm_m = m.mul(x, x_mont);
+    try testing.expect(!mul_nm_m.montgomery);
+    const mul_nm_nm = m.mul(x, x);
+    try testing.expect(mul_nm_m.eql(mul_nm_nm));
+    var mul_m_nm = m.mul(x_mont, x);
+    try testing.expect(mul_m_nm.montgomery);
+    try m.fromMontgomery(&mul_m_nm);
+    try testing.expect(mul_m_nm.eql(mul_nm_nm));
+
+    try testing.expectEqual(x.toPrimitive(u256), 80169837251094269539116136208111827396136208141182357733);
+    try testing.expectError(error.UnexpectedRepresentation, x_mont.toPrimitive(u256));
 }
 
 fn testCt(ct_: anytype) !void {
-- 
2.54.0


From f186809caf3a14cbfbe6778f946c8597ebe7d561 Mon Sep 17 00:00:00 2001
From: Michael Dusan <michael.dusan@gmail.com>
Date: Sun, 25 Jan 2026 13:03:22 -0500
Subject: [PATCH 042/499] std: impl process.totalSystemMemory for netbsd

---
 lib/std/process.zig | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/std/process.zig b/lib/std/process.zig
index 8c531830e54240c320ffab82f12db006bbdf47d6..dbf2fbe666311a8a7236630e19f20c4b32d54933 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -558,14 +558,17 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
             // Promote to u64 to avoid overflow on systems where info.totalram is a 32-bit usize
             return @as(u64, info.totalram) * info.mem_unit;
         },
-        .freebsd => {
+        .dragonfly, .freebsd, .netbsd => {
+            const name = if (native_os == .netbsd) "hw.physmem64" else "hw.physmem";
             var physmem: c_ulong = undefined;
             var len: usize = @sizeOf(c_ulong);
-            posix.sysctlbynameZ("hw.physmem", &physmem, &len, null, 0) catch |err| switch (err) {
+            posix.sysctlbynameZ(name, &physmem, &len, null, 0) catch |err| switch (err) {
+                error.PermissionDenied => unreachable, // only when setting values,
+                error.SystemResources => unreachable, // memory already on the stack
                 error.UnknownName => unreachable,
                 else => return error.UnknownTotalSystemMemory,
             };
-            return @as(u64, @intCast(physmem));
+            return @intCast(physmem);
         },
         // whole Darwin family
         .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
-- 
2.54.0


From f6ed859cb0f6281680675cd6d8ed118ef3500f02 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 26 Jan 2026 05:35:53 +0100
Subject: [PATCH 043/499] std.zig.target: update glibc triples for loongarch64
 targets

---
 lib/std/zig/target.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/zig/target.zig b/lib/std/zig/target.zig
index 9f1aeb2310acc877a93bd75db4170f2fc1e397ae..b8e13d4a606009e9a6fa551b1af211f7bfb0e37e 100644
--- a/lib/std/zig/target.zig
+++ b/lib/std/zig/target.zig
@@ -46,8 +46,8 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .csky, .os = .linux, .abi = .gnueabi, .os_ver = .{ .major = 4, .minor = 20, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 }, .glibc_triple = "csky-linux-gnuabiv2-soft" },
     .{ .arch = .csky, .os = .linux, .abi = .gnueabihf, .os_ver = .{ .major = 4, .minor = 20, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 }, .glibc_triple = "csky-linux-gnuabiv2" },
     .{ .arch = .hexagon, .os = .linux, .abi = .musl, .os_ver = .{ .major = 3, .minor = 2, .patch = 102 } },
-    .{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnu-lp64d" },
-    .{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnu-lp64s" },
+    .{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnuf64" },
+    .{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnusf" },
     .{ .arch = .loongarch64, .os = .linux, .abi = .musl, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 } },
     .{ .arch = .loongarch64, .os = .linux, .abi = .muslsf, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 } },
     .{ .arch = .m68k, .os = .linux, .abi = .gnu, .os_ver = .{ .major = 1, .minor = 3, .patch = 94 } },
-- 
2.54.0


From 49afd7eee04675a29c388c8b315b66678579075f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 26 Jan 2026 05:55:28 +0100
Subject: [PATCH 044/499] libc: update glibc headers to 2.43

---
 .../include/aarch64-linux-gnu/bits/fcntl.h    |   2 +-
 .../include/aarch64-linux-gnu/bits/fenv.h     |   2 +-
 .../include/aarch64-linux-gnu/bits/fp-fast.h  |   2 +-
 .../include/aarch64-linux-gnu/bits/hwcap.h    |   7 +-
 .../aarch64-linux-gnu/bits/indirect-return.h  |   2 +-
 .../include/aarch64-linux-gnu/bits/link.h     |   2 +-
 .../aarch64-linux-gnu/bits/long-double.h      |   2 +-
 .../aarch64-linux-gnu/bits/math-vector.h      |  42 +++-
 .../include/aarch64-linux-gnu/bits/mman.h     |   2 +-
 .../include/aarch64-linux-gnu/bits/procfs.h   |   2 +-
 .../bits/pthread_stack_min.h                  |   2 +-
 .../bits/pthreadtypes-arch.h                  |   2 +-
 .../include/aarch64-linux-gnu/bits/rseq.h     |   2 +-
 .../aarch64-linux-gnu/bits/semaphore.h        |   2 +-
 .../include/aarch64-linux-gnu/bits/setjmp.h   |   2 +-
 .../include/aarch64-linux-gnu/bits/sigstack.h |   2 +-
 .../aarch64-linux-gnu/bits/struct_rwlock.h    |   2 +-
 .../aarch64-linux-gnu/bits/struct_stat.h      |   2 +-
 .../include/aarch64-linux-gnu/bits/timesize.h |   2 +-
 .../include/aarch64-linux-gnu/bits/wordsize.h |   2 +-
 .../finclude/math-vector-fortran.h            |  59 ++++-
 .../include/aarch64-linux-gnu/fpu_control.h   |   3 +-
 lib/libc/include/aarch64-linux-gnu/ieee754.h  |   2 +-
 lib/libc/include/aarch64-linux-gnu/sys/elf.h  |   2 +-
 .../include/aarch64-linux-gnu/sys/ptrace.h    |   2 +-
 .../include/aarch64-linux-gnu/sys/ucontext.h  |   4 +-
 lib/libc/include/aarch64-linux-gnu/sys/user.h |   2 +-
 lib/libc/include/arc-linux-gnu/bits/fcntl.h   |   2 +-
 lib/libc/include/arc-linux-gnu/bits/fenv.h    |   2 +-
 lib/libc/include/arc-linux-gnu/bits/floatn.h  |   2 +-
 lib/libc/include/arc-linux-gnu/bits/link.h    |   2 +-
 .../include/arc-linux-gnu/bits/long-double.h  |   2 +-
 lib/libc/include/arc-linux-gnu/bits/procfs.h  |   2 +-
 lib/libc/include/arc-linux-gnu/bits/rseq.h    |   2 +-
 lib/libc/include/arc-linux-gnu/bits/setjmp.h  |   2 +-
 .../include/arc-linux-gnu/bits/struct_stat.h  |   2 +-
 .../include/arc-linux-gnu/bits/timesize.h     |   2 +-
 .../include/arc-linux-gnu/bits/wordsize.h     |   2 +-
 lib/libc/include/arc-linux-gnu/fpu_control.h  |   2 +-
 lib/libc/include/arc-linux-gnu/sys/cachectl.h |   2 +-
 lib/libc/include/arc-linux-gnu/sys/ucontext.h |   2 +-
 lib/libc/include/arc-linux-gnu/sys/user.h     |   2 +-
 .../arm-linux-gnu/bits/dl_find_object.h       |   2 +-
 lib/libc/include/arm-linux-gnu/bits/fcntl.h   |   2 +-
 lib/libc/include/arm-linux-gnu/bits/fenv.h    |   2 +-
 lib/libc/include/arm-linux-gnu/bits/floatn.h  |   2 +-
 lib/libc/include/arm-linux-gnu/bits/hwcap.h   |   2 +-
 lib/libc/include/arm-linux-gnu/bits/link.h    |   2 +-
 .../include/arm-linux-gnu/bits/long-double.h  |   2 +-
 .../include/arm-linux-gnu/bits/procfs-id.h    |   2 +-
 lib/libc/include/arm-linux-gnu/bits/procfs.h  |   2 +-
 lib/libc/include/arm-linux-gnu/bits/rseq.h    |   2 +-
 lib/libc/include/arm-linux-gnu/bits/setjmp.h  |   2 +-
 lib/libc/include/arm-linux-gnu/bits/shmlba.h  |   2 +-
 .../include/arm-linux-gnu/bits/struct_stat.h  |   2 +-
 .../include/arm-linux-gnu/bits/timesize.h     |   2 +-
 .../include/arm-linux-gnu/bits/typesizes.h    |   2 +-
 .../include/arm-linux-gnu/bits/wordsize.h     |   2 +-
 lib/libc/include/arm-linux-gnu/fpu_control.h  |   2 +-
 lib/libc/include/arm-linux-gnu/sys/ptrace.h   |   2 +-
 lib/libc/include/arm-linux-gnu/sys/ucontext.h |   2 +-
 lib/libc/include/arm-linux-gnu/sys/user.h     |   2 +-
 lib/libc/include/csky-linux-gnu/bits/fcntl.h  |   2 +-
 lib/libc/include/csky-linux-gnu/bits/fenv.h   |   2 +-
 lib/libc/include/csky-linux-gnu/bits/floatn.h |   2 +-
 lib/libc/include/csky-linux-gnu/bits/link.h   |   2 +-
 .../include/csky-linux-gnu/bits/long-double.h |   2 +-
 lib/libc/include/csky-linux-gnu/bits/procfs.h |   2 +-
 lib/libc/include/csky-linux-gnu/bits/rseq.h   |   2 +-
 lib/libc/include/csky-linux-gnu/bits/setjmp.h |   2 +-
 lib/libc/include/csky-linux-gnu/bits/shmlba.h |   2 +-
 lib/libc/include/csky-linux-gnu/bits/statfs.h |   2 +-
 .../include/csky-linux-gnu/bits/struct_stat.h |   2 +-
 .../include/csky-linux-gnu/bits/timesize.h    |   2 +-
 .../include/csky-linux-gnu/bits/wordsize.h    |   2 +-
 lib/libc/include/csky-linux-gnu/fpu_control.h |   2 +-
 .../include/csky-linux-gnu/sys/cachectl.h     |   2 +-
 .../include/csky-linux-gnu/sys/ucontext.h     |   2 +-
 lib/libc/include/csky-linux-gnu/sys/user.h    |   2 +-
 lib/libc/include/generic-glibc/aio.h          |   2 +-
 lib/libc/include/generic-glibc/aliases.h      |   2 +-
 lib/libc/include/generic-glibc/alloca.h       |   2 +-
 lib/libc/include/generic-glibc/ar.h           |   2 +-
 lib/libc/include/generic-glibc/argp.h         |  12 +-
 lib/libc/include/generic-glibc/argz.h         |   2 +-
 lib/libc/include/generic-glibc/arpa/inet.h    |   2 +-
 lib/libc/include/generic-glibc/assert.h       |  60 +++++-
 .../include/generic-glibc/bits/argp-ldbl.h    |   2 +-
 .../generic-glibc/bits/atomic_wide_counter.h  |   2 +-
 .../include/generic-glibc/bits/byteswap.h     |   2 +-
 .../include/generic-glibc/bits/cmathcalls.h   |   2 +-
 .../include/generic-glibc/bits/confname.h     |   2 +-
 lib/libc/include/generic-glibc/bits/cpu-set.h |   2 +-
 lib/libc/include/generic-glibc/bits/dirent.h  |   2 +-
 .../include/generic-glibc/bits/dirent_ext.h   |   2 +-
 .../generic-glibc/bits/dl_find_object.h       |   2 +-
 lib/libc/include/generic-glibc/bits/dlfcn.h   |   2 +-
 lib/libc/include/generic-glibc/bits/endian.h  |   2 +-
 .../include/generic-glibc/bits/environments.h |   2 +-
 lib/libc/include/generic-glibc/bits/epoll.h   |   2 +-
 .../include/generic-glibc/bits/err-ldbl.h     |   2 +-
 lib/libc/include/generic-glibc/bits/errno.h   |   2 +-
 .../include/generic-glibc/bits/error-ldbl.h   |   2 +-
 lib/libc/include/generic-glibc/bits/error.h   |   2 +-
 lib/libc/include/generic-glibc/bits/eventfd.h |   2 +-
 .../generic-glibc/bits/fcntl-linux-fortify.h  |  49 +++++
 .../include/generic-glibc/bits/fcntl-linux.h  |  37 +++-
 lib/libc/include/generic-glibc/bits/fcntl.h   |   2 +-
 lib/libc/include/generic-glibc/bits/fcntl2.h  |   2 +-
 lib/libc/include/generic-glibc/bits/fenv.h    |   2 +-
 .../generic-glibc/bits/floatn-common.h        |   2 +-
 lib/libc/include/generic-glibc/bits/floatn.h  |   2 +-
 .../generic-glibc/bits/flt-eval-method.h      |   2 +-
 lib/libc/include/generic-glibc/bits/fp-fast.h |   2 +-
 lib/libc/include/generic-glibc/bits/fp-logb.h |   2 +-
 .../include/generic-glibc/bits/getopt_core.h  |   2 +-
 .../include/generic-glibc/bits/getopt_ext.h   |   2 +-
 .../include/generic-glibc/bits/getopt_posix.h |   2 +-
 lib/libc/include/generic-glibc/bits/hwcap.h   |   2 +-
 lib/libc/include/generic-glibc/bits/in.h      |   2 +-
 .../generic-glibc/bits/indirect-return.h      |   2 +-
 .../generic-glibc/bits/inet-fortified-decl.h  |   2 +-
 .../generic-glibc/bits/inet-fortified.h       |  12 +-
 lib/libc/include/generic-glibc/bits/inotify.h |   2 +-
 .../include/generic-glibc/bits/ioctl-types.h  |   2 +-
 lib/libc/include/generic-glibc/bits/ioctls.h  |   2 +-
 .../include/generic-glibc/bits/ipc-perm.h     |   2 +-
 lib/libc/include/generic-glibc/bits/ipc.h     |   2 +-
 .../include/generic-glibc/bits/ipctypes.h     |   2 +-
 .../include/generic-glibc/bits/iscanonical.h  |   2 +-
 .../generic-glibc/bits/libc-header-start.h    |   2 +-
 .../generic-glibc/bits/libm-simd-decl-stubs.h |  57 ++++-
 lib/libc/include/generic-glibc/bits/link.h    |   2 +-
 .../generic-glibc/bits/link_lavcurrent.h      |   2 +-
 .../include/generic-glibc/bits/local_lim.h    |   2 +-
 lib/libc/include/generic-glibc/bits/locale.h  |   2 +-
 .../include/generic-glibc/bits/long-double.h  |   2 +-
 .../include/generic-glibc/bits/math-vector.h  |   2 +-
 .../bits/mathcalls-helper-functions.h         |   2 +-
 .../generic-glibc/bits/mathcalls-macros.h     |   2 +-
 .../generic-glibc/bits/mathcalls-narrow.h     |   2 +-
 .../include/generic-glibc/bits/mathcalls.h    |  24 +--
 lib/libc/include/generic-glibc/bits/mathdef.h |   2 +-
 .../include/generic-glibc/bits/mman-linux.h   |   2 +-
 .../bits/mman-map-flags-generic.h             |   2 +-
 .../include/generic-glibc/bits/mman-shared.h  |  14 +-
 lib/libc/include/generic-glibc/bits/mman.h    |   2 +-
 .../include/generic-glibc/bits/mman_ext.h     |   2 +-
 .../generic-glibc/bits/monetary-ldbl.h        |   2 +-
 lib/libc/include/generic-glibc/bits/mqueue.h  |   2 +-
 lib/libc/include/generic-glibc/bits/mqueue2.h |   2 +-
 lib/libc/include/generic-glibc/bits/msq.h     |   2 +-
 lib/libc/include/generic-glibc/bits/netdb.h   |   2 +-
 lib/libc/include/generic-glibc/bits/openat2.h |  60 ++++++
 lib/libc/include/generic-glibc/bits/param.h   |   2 +-
 .../generic-glibc/bits/platform/features.h    |   2 +-
 .../include/generic-glibc/bits/platform/x86.h |   2 +-
 lib/libc/include/generic-glibc/bits/poll.h    |   2 +-
 lib/libc/include/generic-glibc/bits/poll2.h   |   2 +-
 .../include/generic-glibc/bits/posix1_lim.h   |   2 +-
 .../include/generic-glibc/bits/posix2_lim.h   |   2 +-
 .../include/generic-glibc/bits/posix_opt.h    |   4 +-
 lib/libc/include/generic-glibc/bits/ppc.h     |   2 +-
 .../include/generic-glibc/bits/printf-ldbl.h  |   2 +-
 .../include/generic-glibc/bits/procfs-extra.h |   2 +-
 .../include/generic-glibc/bits/procfs-id.h    |   2 +-
 .../generic-glibc/bits/procfs-prregset.h      |   2 +-
 lib/libc/include/generic-glibc/bits/procfs.h  |   2 +-
 .../bits/pthread_stack_min-dynamic.h          |   2 +-
 .../generic-glibc/bits/pthread_stack_min.h    |   2 +-
 .../generic-glibc/bits/pthreadtypes-arch.h    |   2 +-
 .../include/generic-glibc/bits/pthreadtypes.h |   2 +-
 .../generic-glibc/bits/ptrace-shared.h        |   2 +-
 .../include/generic-glibc/bits/resource.h     |   2 +-
 lib/libc/include/generic-glibc/bits/rseq.h    |   2 +-
 lib/libc/include/generic-glibc/bits/sched.h   |   2 +-
 .../include/generic-glibc/bits/select-decl.h  |   2 +-
 lib/libc/include/generic-glibc/bits/select.h  |   2 +-
 lib/libc/include/generic-glibc/bits/select2.h |   2 +-
 lib/libc/include/generic-glibc/bits/sem.h     |   2 +-
 .../include/generic-glibc/bits/semaphore.h    |   2 +-
 lib/libc/include/generic-glibc/bits/setjmp.h  |   2 +-
 lib/libc/include/generic-glibc/bits/setjmp2.h |   2 +-
 lib/libc/include/generic-glibc/bits/shm.h     |   2 +-
 lib/libc/include/generic-glibc/bits/shmlba.h  |   2 +-
 .../include/generic-glibc/bits/sigaction.h    |   2 +-
 .../include/generic-glibc/bits/sigcontext.h   |   2 +-
 .../generic-glibc/bits/sigevent-consts.h      |   2 +-
 .../generic-glibc/bits/siginfo-consts.h       |  18 +-
 .../include/generic-glibc/bits/signal_ext.h   |   2 +-
 .../include/generic-glibc/bits/signalfd.h     |   2 +-
 .../include/generic-glibc/bits/signum-arch.h  |   2 +-
 .../generic-glibc/bits/signum-generic.h       |   2 +-
 .../include/generic-glibc/bits/sigstack.h     |   2 +-
 .../include/generic-glibc/bits/sigstksz.h     |   2 +-
 .../include/generic-glibc/bits/sigthread.h    |   2 +-
 .../include/generic-glibc/bits/sockaddr.h     |   2 +-
 .../generic-glibc/bits/socket-constants.h     |   2 +-
 lib/libc/include/generic-glibc/bits/socket.h  |   2 +-
 lib/libc/include/generic-glibc/bits/socket2.h |   2 +-
 .../include/generic-glibc/bits/socket_type.h  |   2 +-
 .../include/generic-glibc/bits/spawn_ext.h    |   2 +-
 .../include/generic-glibc/bits/ss_flags.h     |   2 +-
 lib/libc/include/generic-glibc/bits/stab.def  |   2 +-
 lib/libc/include/generic-glibc/bits/stat.h    |   2 +-
 lib/libc/include/generic-glibc/bits/statfs.h  |   2 +-
 lib/libc/include/generic-glibc/bits/statvfs.h |   2 +-
 .../generic-glibc/bits/statx-generic.h        |   3 +-
 lib/libc/include/generic-glibc/bits/statx.h   |   2 +-
 .../include/generic-glibc/bits/stdint-intn.h  |   2 +-
 .../include/generic-glibc/bits/stdint-least.h |   2 +-
 .../include/generic-glibc/bits/stdint-uintn.h |   2 +-
 .../include/generic-glibc/bits/stdio-ldbl.h   |   2 +-
 lib/libc/include/generic-glibc/bits/stdio.h   |   2 +-
 .../include/generic-glibc/bits/stdio2-decl.h  |   2 +-
 lib/libc/include/generic-glibc/bits/stdio2.h  |   2 +-
 .../include/generic-glibc/bits/stdio_lim.h    |   2 +-
 .../generic-glibc/bits/stdlib-bsearch.h       |   2 +-
 .../include/generic-glibc/bits/stdlib-float.h |   2 +-
 .../include/generic-glibc/bits/stdlib-ldbl.h  |   2 +-
 lib/libc/include/generic-glibc/bits/stdlib.h  |   2 +-
 .../generic-glibc/bits/string_fortified.h     |  14 +-
 .../generic-glibc/bits/strings_fortified.h    |   2 +-
 .../include/generic-glibc/bits/struct_mutex.h |  22 +-
 .../generic-glibc/bits/struct_rwlock.h        |   6 +-
 .../include/generic-glibc/bits/struct_stat.h  |   2 +-
 .../bits/struct_stat_time64_helper.h          |   2 +-
 lib/libc/include/generic-glibc/bits/syscall.h |  12 +-
 .../include/generic-glibc/bits/syslog-decl.h  |   2 +-
 .../include/generic-glibc/bits/syslog-ldbl.h  |   2 +-
 .../include/generic-glibc/bits/syslog-path.h  |   2 +-
 lib/libc/include/generic-glibc/bits/syslog.h  |   2 +-
 .../include/generic-glibc/bits/sysmacros.h    |   2 +-
 .../include/generic-glibc/bits/termios-baud.h |   2 +-
 .../include/generic-glibc/bits/termios-c_cc.h |   2 +-
 .../generic-glibc/bits/termios-c_cflag.h      |   2 +-
 .../generic-glibc/bits/termios-c_iflag.h      |   2 +-
 .../generic-glibc/bits/termios-c_lflag.h      |   2 +-
 .../generic-glibc/bits/termios-c_oflag.h      |   2 +-
 .../generic-glibc/bits/termios-cbaud.h        |   2 +-
 .../include/generic-glibc/bits/termios-misc.h |   2 +-
 .../generic-glibc/bits/termios-struct.h       |   2 +-
 .../generic-glibc/bits/termios-tcflow.h       |   2 +-
 lib/libc/include/generic-glibc/bits/termios.h |   2 +-
 .../generic-glibc/bits/thread-shared-types.h  |   4 +-
 lib/libc/include/generic-glibc/bits/time.h    |   2 +-
 lib/libc/include/generic-glibc/bits/time64.h  |   2 +-
 lib/libc/include/generic-glibc/bits/timerfd.h |   2 +-
 .../include/generic-glibc/bits/timesize.h     |   2 +-
 lib/libc/include/generic-glibc/bits/timex.h   |   2 +-
 lib/libc/include/generic-glibc/bits/types.h   |   2 +-
 .../generic-glibc/bits/types/__locale_t.h     |   2 +-
 .../generic-glibc/bits/types/__sigval_t.h     |   2 +-
 .../bits/types/cookie_io_functions_t.h        |   2 +-
 .../generic-glibc/bits/types/error_t.h        |   2 +-
 .../generic-glibc/bits/types/locale_t.h       |   2 +-
 .../bits/types/once_flag.h}                   |  17 +-
 .../generic-glibc/bits/types/stack_t.h        |   2 +-
 .../generic-glibc/bits/types/struct_FILE.h    |   2 +-
 .../bits/types/struct___jmp_buf_tag.h         |   2 +-
 .../generic-glibc/bits/types/struct_iovec.h   |   2 +-
 .../bits/types/struct_msqid64_ds.h            |   2 +-
 .../bits/types/struct_msqid64_ds_helper.h     |   2 +-
 .../bits/types/struct_msqid_ds.h              |   2 +-
 .../generic-glibc/bits/types/struct_rusage.h  |   2 +-
 .../bits/types/struct_sched_param.h           |   2 +-
 .../bits/types/struct_semid64_ds.h            |   2 +-
 .../bits/types/struct_semid64_ds_helper.h     |   2 +-
 .../bits/types/struct_semid_ds.h              |   2 +-
 .../bits/types/struct_shmid64_ds.h            |   2 +-
 .../bits/types/struct_shmid64_ds_helper.h     |   2 +-
 .../bits/types/struct_shmid_ds.h              |   2 +-
 .../bits/types/struct_sigstack.h              |   2 +-
 .../generic-glibc/bits/types/struct_statx.h   |  14 +-
 .../bits/types/struct_statx_timestamp.h       |   2 +-
 .../include/generic-glibc/bits/typesizes.h    |   2 +-
 .../generic-glibc/bits/uintn-identity.h       |   2 +-
 lib/libc/include/generic-glibc/bits/uio-ext.h |   3 +-
 lib/libc/include/generic-glibc/bits/uio_lim.h |   2 +-
 .../include/generic-glibc/bits/unistd-decl.h  |   2 +-
 lib/libc/include/generic-glibc/bits/unistd.h  |   2 +-
 .../include/generic-glibc/bits/unistd_ext.h   |   2 +-
 lib/libc/include/generic-glibc/bits/utmp.h    |   2 +-
 lib/libc/include/generic-glibc/bits/utmpx.h   |   2 +-
 lib/libc/include/generic-glibc/bits/utsname.h |   2 +-
 .../include/generic-glibc/bits/waitflags.h    |   2 +-
 .../include/generic-glibc/bits/waitstatus.h   |   2 +-
 .../include/generic-glibc/bits/wchar-ldbl.h   |   2 +-
 lib/libc/include/generic-glibc/bits/wchar.h   |   2 +-
 .../include/generic-glibc/bits/wchar2-decl.h  |   2 +-
 lib/libc/include/generic-glibc/bits/wchar2.h  |   2 +-
 .../include/generic-glibc/bits/wctype-wchar.h |   2 +-
 .../include/generic-glibc/bits/wordsize.h     |   2 +-
 .../include/generic-glibc/bits/xopen_lim.h    |   2 +-
 lib/libc/include/generic-glibc/byteswap.h     |   2 +-
 lib/libc/include/generic-glibc/complex.h      |   6 +-
 lib/libc/include/generic-glibc/cpio.h         |   2 +-
 lib/libc/include/generic-glibc/ctype.h        |   2 +-
 lib/libc/include/generic-glibc/dirent.h       |   2 +-
 lib/libc/include/generic-glibc/dlfcn.h        |   2 +-
 lib/libc/include/generic-glibc/elf.h          |   4 +-
 lib/libc/include/generic-glibc/endian.h       |   2 +-
 lib/libc/include/generic-glibc/envz.h         |   2 +-
 lib/libc/include/generic-glibc/err.h          |   2 +-
 lib/libc/include/generic-glibc/errno.h        |   2 +-
 lib/libc/include/generic-glibc/error.h        |   2 +-
 lib/libc/include/generic-glibc/execinfo.h     |   2 +-
 lib/libc/include/generic-glibc/fcntl.h        |   4 +-
 .../include/generic-glibc/features-time64.h   |   2 +-
 lib/libc/include/generic-glibc/features.h     |  50 +++--
 lib/libc/include/generic-glibc/fenv.h         |   6 +-
 .../finclude/math-vector-fortran.h            |   2 +-
 lib/libc/include/generic-glibc/fmtmsg.h       |   2 +-
 lib/libc/include/generic-glibc/fnmatch.h      |   2 +-
 lib/libc/include/generic-glibc/fpregdef.h     |   2 +-
 lib/libc/include/generic-glibc/fpu_control.h  |   2 +-
 lib/libc/include/generic-glibc/fts.h          |   2 +-
 lib/libc/include/generic-glibc/ftw.h          |   2 +-
 lib/libc/include/generic-glibc/gconv.h        |   2 +-
 lib/libc/include/generic-glibc/getopt.h       |   2 +-
 lib/libc/include/generic-glibc/glob.h         |   2 +-
 lib/libc/include/generic-glibc/gnu-versions.h |   2 +-
 .../include/generic-glibc/gnu/libc-version.h  |   2 +-
 lib/libc/include/generic-glibc/grp.h          |   2 +-
 lib/libc/include/generic-glibc/gshadow.h      |   2 +-
 lib/libc/include/generic-glibc/iconv.h        |   2 +-
 lib/libc/include/generic-glibc/ieee754.h      |   2 +-
 lib/libc/include/generic-glibc/ifaddrs.h      |   2 +-
 lib/libc/include/generic-glibc/inttypes.h     |  89 ++++----
 lib/libc/include/generic-glibc/langinfo.h     |   2 +-
 lib/libc/include/generic-glibc/libgen.h       |   2 +-
 lib/libc/include/generic-glibc/libintl.h      |   2 +-
 lib/libc/include/generic-glibc/limits.h       |   7 +-
 lib/libc/include/generic-glibc/link.h         |   2 +-
 lib/libc/include/generic-glibc/locale.h       |   2 +-
 lib/libc/include/generic-glibc/malloc.h       |  12 +-
 lib/libc/include/generic-glibc/math.h         | 186 +++++++++++++++-
 lib/libc/include/generic-glibc/mcheck.h       |   2 +-
 lib/libc/include/generic-glibc/memory.h       |   2 +-
 lib/libc/include/generic-glibc/mntent.h       |   2 +-
 lib/libc/include/generic-glibc/monetary.h     |   2 +-
 lib/libc/include/generic-glibc/mqueue.h       |   2 +-
 lib/libc/include/generic-glibc/net/ethernet.h |   2 +-
 lib/libc/include/generic-glibc/net/if.h       |   2 +-
 lib/libc/include/generic-glibc/net/if_arp.h   |   2 +-
 .../include/generic-glibc/net/if_packet.h     |   2 +-
 .../include/generic-glibc/net/if_shaper.h     |   2 +-
 lib/libc/include/generic-glibc/net/if_slip.h  |   2 +-
 lib/libc/include/generic-glibc/net/route.h    |   2 +-
 lib/libc/include/generic-glibc/netash/ash.h   |   2 +-
 lib/libc/include/generic-glibc/netatalk/at.h  |   2 +-
 lib/libc/include/generic-glibc/netax25/ax25.h |   2 +-
 lib/libc/include/generic-glibc/netdb.h        |   2 +-
 lib/libc/include/generic-glibc/neteconet/ec.h |   2 +-
 .../include/generic-glibc/netinet/ether.h     |   2 +-
 .../include/generic-glibc/netinet/icmp6.h     |   2 +-
 .../include/generic-glibc/netinet/if_ether.h  |   2 +-
 .../include/generic-glibc/netinet/if_fddi.h   |   2 +-
 .../include/generic-glibc/netinet/if_tr.h     |   2 +-
 lib/libc/include/generic-glibc/netinet/igmp.h |   2 +-
 lib/libc/include/generic-glibc/netinet/in.h   |   2 +-
 .../include/generic-glibc/netinet/in_systm.h  |   2 +-
 lib/libc/include/generic-glibc/netinet/ip.h   |   2 +-
 lib/libc/include/generic-glibc/netinet/ip6.h  |   2 +-
 .../include/generic-glibc/netinet/ip_icmp.h   |   2 +-
 lib/libc/include/generic-glibc/netinet/tcp.h  | 202 ++++++++++++++++++
 lib/libc/include/generic-glibc/netinet/udp.h  |   2 +-
 lib/libc/include/generic-glibc/netipx/ipx.h   |   2 +-
 lib/libc/include/generic-glibc/netiucv/iucv.h |   2 +-
 .../include/generic-glibc/netpacket/packet.h  |   2 +-
 .../include/generic-glibc/netrom/netrom.h     |   2 +-
 lib/libc/include/generic-glibc/netrose/rose.h |   2 +-
 lib/libc/include/generic-glibc/nl_types.h     |   2 +-
 lib/libc/include/generic-glibc/nss.h          |   2 +-
 lib/libc/include/generic-glibc/obstack.h      |   2 +-
 lib/libc/include/generic-glibc/printf.h       |   2 +-
 lib/libc/include/generic-glibc/proc_service.h |   2 +-
 lib/libc/include/generic-glibc/pthread.h      |   2 +-
 lib/libc/include/generic-glibc/pty.h          |   2 +-
 lib/libc/include/generic-glibc/pwd.h          |   2 +-
 lib/libc/include/generic-glibc/re_comp.h      |   2 +-
 lib/libc/include/generic-glibc/regdef.h       |   2 +-
 lib/libc/include/generic-glibc/regex.h        |   2 +-
 lib/libc/include/generic-glibc/regexp.h       |   2 +-
 lib/libc/include/generic-glibc/resolv.h       |   2 +-
 lib/libc/include/generic-glibc/sched.h        |   2 +-
 lib/libc/include/generic-glibc/scsi/scsi.h    |   2 +-
 .../include/generic-glibc/scsi/scsi_ioctl.h   |   2 +-
 lib/libc/include/generic-glibc/scsi/sg.h      |   2 +-
 lib/libc/include/generic-glibc/search.h       |   2 +-
 lib/libc/include/generic-glibc/semaphore.h    |   2 +-
 lib/libc/include/generic-glibc/setjmp.h       |   6 +-
 lib/libc/include/generic-glibc/sgidefs.h      |   2 +-
 lib/libc/include/generic-glibc/sgtty.h        |   2 +-
 lib/libc/include/generic-glibc/shadow.h       |   2 +-
 lib/libc/include/generic-glibc/signal.h       |   2 +-
 lib/libc/include/generic-glibc/spawn.h        |   2 +-
 lib/libc/include/generic-glibc/stdbit.h       |   2 +-
 lib/libc/include/generic-glibc/stdc-predef.h  |   2 +-
 lib/libc/include/generic-glibc/stdint.h       |   8 +-
 lib/libc/include/generic-glibc/stdio.h        |  12 +-
 lib/libc/include/generic-glibc/stdio_ext.h    |   2 +-
 lib/libc/include/generic-glibc/stdlib.h       |  43 +++-
 lib/libc/include/generic-glibc/string.h       |  36 +++-
 lib/libc/include/generic-glibc/strings.h      |   2 +-
 lib/libc/include/generic-glibc/sys/acct.h     |   2 +-
 lib/libc/include/generic-glibc/sys/asm.h      |  18 +-
 lib/libc/include/generic-glibc/sys/auxv.h     |   2 +-
 lib/libc/include/generic-glibc/sys/cachectl.h |   2 +-
 lib/libc/include/generic-glibc/sys/cdefs.h    |  30 ++-
 lib/libc/include/generic-glibc/sys/debugreg.h |   2 +-
 lib/libc/include/generic-glibc/sys/dir.h      |   2 +-
 lib/libc/include/generic-glibc/sys/elf.h      |   2 +-
 lib/libc/include/generic-glibc/sys/epoll.h    |   2 +-
 lib/libc/include/generic-glibc/sys/eventfd.h  |   2 +-
 lib/libc/include/generic-glibc/sys/fanotify.h |   2 +-
 lib/libc/include/generic-glibc/sys/file.h     |   2 +-
 lib/libc/include/generic-glibc/sys/fpregdef.h |   2 +-
 lib/libc/include/generic-glibc/sys/fsuid.h    |   2 +-
 lib/libc/include/generic-glibc/sys/gmon_out.h |   2 +-
 lib/libc/include/generic-glibc/sys/hwprobe.h  |   2 +-
 lib/libc/include/generic-glibc/sys/ifunc.h    |   2 +-
 lib/libc/include/generic-glibc/sys/inotify.h  |   2 +-
 lib/libc/include/generic-glibc/sys/io.h       |   2 +-
 lib/libc/include/generic-glibc/sys/ioctl.h    |   2 +-
 lib/libc/include/generic-glibc/sys/ipc.h      |   2 +-
 lib/libc/include/generic-glibc/sys/kd.h       |   2 +-
 lib/libc/include/generic-glibc/sys/klog.h     |   2 +-
 lib/libc/include/generic-glibc/sys/mman.h     |   2 +-
 lib/libc/include/generic-glibc/sys/mount.h    |   2 +-
 lib/libc/include/generic-glibc/sys/msg.h      |   2 +-
 lib/libc/include/generic-glibc/sys/mtio.h     |   2 +-
 lib/libc/include/generic-glibc/sys/param.h    |   2 +-
 lib/libc/include/generic-glibc/sys/pci.h      |   2 +-
 lib/libc/include/generic-glibc/sys/perm.h     |   2 +-
 .../include/generic-glibc/sys/personality.h   |   2 +-
 lib/libc/include/generic-glibc/sys/pidfd.h    |  60 +++++-
 .../include/generic-glibc/sys/platform/ppc.h  |   2 +-
 .../include/generic-glibc/sys/platform/x86.h  |   2 +-
 lib/libc/include/generic-glibc/sys/poll.h     |   2 +-
 lib/libc/include/generic-glibc/sys/prctl.h    |   2 +-
 lib/libc/include/generic-glibc/sys/procfs.h   |   2 +-
 lib/libc/include/generic-glibc/sys/profil.h   |   2 +-
 lib/libc/include/generic-glibc/sys/ptrace.h   |   2 +-
 lib/libc/include/generic-glibc/sys/quota.h    |   2 +-
 lib/libc/include/generic-glibc/sys/random.h   |   2 +-
 lib/libc/include/generic-glibc/sys/raw.h      |   2 +-
 lib/libc/include/generic-glibc/sys/reboot.h   |   2 +-
 lib/libc/include/generic-glibc/sys/reg.h      |   2 +-
 lib/libc/include/generic-glibc/sys/regdef.h   |   2 +-
 lib/libc/include/generic-glibc/sys/resource.h |   2 +-
 lib/libc/include/generic-glibc/sys/rseq.h     |   2 +-
 lib/libc/include/generic-glibc/sys/select.h   |   2 +-
 lib/libc/include/generic-glibc/sys/sem.h      |   2 +-
 lib/libc/include/generic-glibc/sys/sendfile.h |   2 +-
 lib/libc/include/generic-glibc/sys/shm.h      |   2 +-
 lib/libc/include/generic-glibc/sys/signalfd.h |   2 +-
 .../generic-glibc/sys/single_threaded.h       |   2 +-
 lib/libc/include/generic-glibc/sys/socket.h   |   2 +-
 lib/libc/include/generic-glibc/sys/stat.h     |   2 +-
 lib/libc/include/generic-glibc/sys/statfs.h   |   2 +-
 lib/libc/include/generic-glibc/sys/statvfs.h  |   2 +-
 lib/libc/include/generic-glibc/sys/swap.h     |   2 +-
 lib/libc/include/generic-glibc/sys/syscall.h  |   2 +-
 lib/libc/include/generic-glibc/sys/sysinfo.h  |   2 +-
 .../include/generic-glibc/sys/sysmacros.h     |   2 +-
 lib/libc/include/generic-glibc/sys/sysmips.h  |   2 +-
 lib/libc/include/generic-glibc/sys/tas.h      |   2 +-
 lib/libc/include/generic-glibc/sys/time.h     |   2 +-
 lib/libc/include/generic-glibc/sys/timeb.h    |   2 +-
 lib/libc/include/generic-glibc/sys/timerfd.h  |   2 +-
 lib/libc/include/generic-glibc/sys/times.h    |   2 +-
 lib/libc/include/generic-glibc/sys/timex.h    |   2 +-
 lib/libc/include/generic-glibc/sys/types.h    |   2 +-
 lib/libc/include/generic-glibc/sys/ucontext.h |   2 +-
 lib/libc/include/generic-glibc/sys/uio.h      |   2 +-
 lib/libc/include/generic-glibc/sys/un.h       |   2 +-
 lib/libc/include/generic-glibc/sys/user.h     |   2 +-
 lib/libc/include/generic-glibc/sys/utsname.h  |   2 +-
 lib/libc/include/generic-glibc/sys/vlimit.h   |   2 +-
 lib/libc/include/generic-glibc/sys/vm86.h     |   2 +-
 lib/libc/include/generic-glibc/sys/wait.h     |   2 +-
 lib/libc/include/generic-glibc/sys/xattr.h    |   2 +-
 lib/libc/include/generic-glibc/tar.h          |   2 +-
 lib/libc/include/generic-glibc/termios.h      |   2 +-
 lib/libc/include/generic-glibc/tgmath.h       |  43 ++--
 lib/libc/include/generic-glibc/thread_db.h    |   2 +-
 lib/libc/include/generic-glibc/threads.h      |   6 +-
 lib/libc/include/generic-glibc/time.h         |  11 +-
 lib/libc/include/generic-glibc/uchar.h        |   6 +-
 lib/libc/include/generic-glibc/ucontext.h     |   2 +-
 lib/libc/include/generic-glibc/ulimit.h       |   2 +-
 lib/libc/include/generic-glibc/unistd.h       |   2 +-
 lib/libc/include/generic-glibc/utime.h        |   2 +-
 lib/libc/include/generic-glibc/utmp.h         |   2 +-
 lib/libc/include/generic-glibc/utmpx.h        |   2 +-
 lib/libc/include/generic-glibc/values.h       |   2 +-
 lib/libc/include/generic-glibc/wchar.h        |  27 ++-
 lib/libc/include/generic-glibc/wctype.h       |   2 +-
 lib/libc/include/generic-glibc/wordexp.h      |   2 +-
 .../include/loongarch-linux-gnu/bits/fcntl.h  |   2 +-
 .../include/loongarch-linux-gnu/bits/fenv.h   |   2 +-
 .../include/loongarch-linux-gnu/bits/hwcap.h  |   2 +-
 .../include/loongarch-linux-gnu/bits/link.h   |   2 +-
 .../bits/link_lavcurrent.h                    |   2 +-
 .../loongarch-linux-gnu/bits/long-double.h    |   2 +-
 .../include/loongarch-linux-gnu/bits/procfs.h |   2 +-
 .../bits/pthread_stack_min.h                  |   2 +-
 .../include/loongarch-linux-gnu/bits/rseq.h   |   2 +-
 .../include/loongarch-linux-gnu/bits/setjmp.h |   2 +-
 .../loongarch-linux-gnu/bits/sigstack.h       |   2 +-
 .../loongarch-linux-gnu/bits/struct_stat.h    |   2 +-
 .../loongarch-linux-gnu/bits/timesize.h       |   2 +-
 .../loongarch-linux-gnu/bits/wordsize.h       |   2 +-
 .../include/loongarch-linux-gnu/fpu_control.h |   2 +-
 .../gnu/lib-names-lp64d.h                     |   0
 .../loongarch-linux-gnu/gnu/lib-names-lp64s.h |  27 +++
 .../gnu/stubs-lp64d.h                         |   0
 .../loongarch-linux-gnu/gnu/stubs-lp64s.h     |   2 +-
 .../include/loongarch-linux-gnu/ieee754.h     |   2 +-
 .../include/loongarch-linux-gnu/sys/asm.h     |   2 +-
 .../loongarch-linux-gnu/sys/ucontext.h        |   2 +-
 .../include/loongarch-linux-gnu/sys/user.h    |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/fcntl.h  |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/fenv.h   |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/floatn.h |   2 +-
 .../m68k-linux-gnu/bits/flt-eval-method.h     |   2 +-
 .../include/m68k-linux-gnu/bits/fp-logb.h     |   2 +-
 .../include/m68k-linux-gnu/bits/iscanonical.h |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/link.h   |   2 +-
 .../include/m68k-linux-gnu/bits/long-double.h |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/poll.h   |   2 +-
 .../include/m68k-linux-gnu/bits/procfs-id.h   |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/procfs.h |   2 +-
 .../m68k-linux-gnu/bits/pthreadtypes-arch.h   |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/rseq.h   |   2 +-
 .../include/m68k-linux-gnu/bits/semaphore.h   |   2 +-
 lib/libc/include/m68k-linux-gnu/bits/setjmp.h |   2 +-
 .../include/m68k-linux-gnu/bits/sockaddr.h    |   2 +-
 .../include/m68k-linux-gnu/bits/struct_stat.h |   2 +-
 .../include/m68k-linux-gnu/bits/timesize.h    |   2 +-
 .../include/m68k-linux-gnu/bits/typesizes.h   |   2 +-
 .../include/m68k-linux-gnu/bits/wordsize.h    |   2 +-
 lib/libc/include/m68k-linux-gnu/fpu_control.h |   2 +-
 lib/libc/include/m68k-linux-gnu/sys/reg.h     |   2 +-
 .../include/m68k-linux-gnu/sys/ucontext.h     |   2 +-
 lib/libc/include/m68k-linux-gnu/sys/user.h    |   2 +-
 lib/libc/include/mips-linux-gnu/bits/dlfcn.h  |   2 +-
 lib/libc/include/mips-linux-gnu/bits/errno.h  |   2 +-
 .../include/mips-linux-gnu/bits/eventfd.h     |   2 +-
 lib/libc/include/mips-linux-gnu/bits/floatn.h |   2 +-
 .../include/mips-linux-gnu/bits/inotify.h     |   2 +-
 .../include/mips-linux-gnu/bits/ioctl-types.h |   2 +-
 .../include/mips-linux-gnu/bits/ipctypes.h    |   2 +-
 lib/libc/include/mips-linux-gnu/bits/mman.h   |   2 +-
 lib/libc/include/mips-linux-gnu/bits/poll.h   |   2 +-
 .../mips-linux-gnu/bits/pthread_stack_min.h   |   2 +-
 .../mips-linux-gnu/bits/pthreadtypes-arch.h   |   2 +-
 .../include/mips-linux-gnu/bits/resource.h    |   2 +-
 .../include/mips-linux-gnu/bits/semaphore.h   |   2 +-
 lib/libc/include/mips-linux-gnu/bits/shmlba.h |   2 +-
 .../include/mips-linux-gnu/bits/sigaction.h   |   2 +-
 .../include/mips-linux-gnu/bits/sigcontext.h  |   2 +-
 .../include/mips-linux-gnu/bits/signalfd.h    |   2 +-
 .../include/mips-linux-gnu/bits/signum-arch.h |   2 +-
 .../mips-linux-gnu/bits/socket-constants.h    |   2 +-
 .../include/mips-linux-gnu/bits/socket_type.h |   2 +-
 lib/libc/include/mips-linux-gnu/bits/statfs.h |   2 +-
 .../mips-linux-gnu/bits/struct_mutex.h        |   2 +-
 .../mips-linux-gnu/bits/struct_rwlock.h       |   2 +-
 .../mips-linux-gnu/bits/termios-c_cc.h        |   2 +-
 .../mips-linux-gnu/bits/termios-c_lflag.h     |   2 +-
 .../mips-linux-gnu/bits/termios-tcflow.h      |   2 +-
 .../include/mips-linux-gnu/bits/timerfd.h     |   2 +-
 .../mips-linux-gnu/bits/types/stack_t.h       |   2 +-
 .../bits/types/struct_msqid_ds.h              |   2 +-
 .../bits/types/struct_semid_ds.h              |   2 +-
 .../bits/types/struct_shmid_ds.h              |   2 +-
 .../include/mips-linux-gnu/bits/typesizes.h   |   2 +-
 lib/libc/include/mips-linux-gnu/ieee754.h     |   2 +-
 .../powerpc-linux-gnu/bits/environments.h     |   2 +-
 .../include/powerpc-linux-gnu/bits/fcntl.h    |   2 +-
 .../include/powerpc-linux-gnu/bits/fenv.h     |   2 +-
 .../include/powerpc-linux-gnu/bits/floatn.h   |   2 +-
 .../include/powerpc-linux-gnu/bits/fp-fast.h  |   2 +-
 .../include/powerpc-linux-gnu/bits/hwcap.h    |   2 +-
 .../powerpc-linux-gnu/bits/ioctl-types.h      |   2 +-
 .../include/powerpc-linux-gnu/bits/ipc-perm.h |   2 +-
 .../powerpc-linux-gnu/bits/iscanonical.h      |   2 +-
 .../include/powerpc-linux-gnu/bits/link.h     |   2 +-
 .../powerpc-linux-gnu/bits/long-double.h      |   2 +-
 .../include/powerpc-linux-gnu/bits/mman.h     |   2 +-
 .../include/powerpc-linux-gnu/bits/procfs.h   |   2 +-
 .../bits/pthread_stack_min.h                  |   2 +-
 .../include/powerpc-linux-gnu/bits/rseq.h     |   2 +-
 .../include/powerpc-linux-gnu/bits/setjmp.h   |   2 +-
 .../include/powerpc-linux-gnu/bits/sigstack.h |   2 +-
 .../powerpc-linux-gnu/bits/socket-constants.h |   2 +-
 .../powerpc-linux-gnu/bits/struct_mutex.h     |  13 +-
 .../powerpc-linux-gnu/bits/struct_rwlock.h    |  13 +-
 .../powerpc-linux-gnu/bits/struct_stat.h      |   2 +-
 .../powerpc-linux-gnu/bits/termios-c_cc.h     |   2 +-
 .../powerpc-linux-gnu/bits/termios-c_cflag.h  |   2 +-
 .../powerpc-linux-gnu/bits/termios-c_iflag.h  |   2 +-
 .../powerpc-linux-gnu/bits/termios-c_lflag.h  |   2 +-
 .../powerpc-linux-gnu/bits/termios-c_oflag.h  |   2 +-
 .../powerpc-linux-gnu/bits/termios-cbaud.h    |   2 +-
 .../powerpc-linux-gnu/bits/termios-misc.h     |   2 +-
 .../include/powerpc-linux-gnu/bits/timesize.h |   2 +-
 .../bits/types/struct_msqid_ds.h              |   2 +-
 .../bits/types/struct_semid_ds.h              |   2 +-
 .../bits/types/struct_shmid_ds.h              |   2 +-
 .../powerpc-linux-gnu/bits/typesizes.h        |   2 +-
 .../include/powerpc-linux-gnu/fpu_control.h   |   2 +-
 lib/libc/include/powerpc-linux-gnu/ieee754.h  |   2 +-
 .../include/powerpc-linux-gnu/sys/ptrace.h    |   2 +-
 .../include/powerpc-linux-gnu/sys/ucontext.h  |   2 +-
 lib/libc/include/powerpc-linux-gnu/sys/user.h |   2 +-
 .../riscv-linux-gnu/bits/environments.h       |   2 +-
 lib/libc/include/riscv-linux-gnu/bits/fcntl.h |   2 +-
 lib/libc/include/riscv-linux-gnu/bits/fenv.h  |   2 +-
 lib/libc/include/riscv-linux-gnu/bits/link.h  |   2 +-
 .../riscv-linux-gnu/bits/long-double.h        |   2 +-
 .../include/riscv-linux-gnu/bits/procfs.h     |   2 +-
 .../riscv-linux-gnu/bits/pthreadtypes-arch.h  |   2 +-
 lib/libc/include/riscv-linux-gnu/bits/rseq.h  |   2 +-
 .../include/riscv-linux-gnu/bits/setjmp.h     |   2 +-
 .../include/riscv-linux-gnu/bits/sigcontext.h |   2 +-
 .../riscv-linux-gnu/bits/struct_rwlock.h      |   2 +-
 .../riscv-linux-gnu/bits/struct_stat.h        |   2 +-
 .../include/riscv-linux-gnu/bits/time64.h     |   2 +-
 .../include/riscv-linux-gnu/bits/timesize.h   |   2 +-
 .../include/riscv-linux-gnu/bits/wordsize.h   |   2 +-
 .../include/riscv-linux-gnu/fpu_control.h     |   4 +-
 lib/libc/include/riscv-linux-gnu/ieee754.h    |   2 +-
 lib/libc/include/riscv-linux-gnu/sys/asm.h    |   2 +-
 .../include/riscv-linux-gnu/sys/cachectl.h    |   2 +-
 .../include/riscv-linux-gnu/sys/ucontext.h    |   2 +-
 lib/libc/include/riscv-linux-gnu/sys/user.h   |   2 +-
 .../include/s390x-linux-gnu/bits/elfclass.h   |   2 +-
 .../s390x-linux-gnu/bits/environments.h       |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/fcntl.h |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/fenv.h  |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/hwcap.h |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/link.h  |   2 +-
 .../s390x-linux-gnu/bits/long-double.h        |   2 +-
 .../s390x-linux-gnu/bits/procfs-extra.h       |   2 +-
 .../include/s390x-linux-gnu/bits/procfs-id.h  |   2 +-
 .../include/s390x-linux-gnu/bits/procfs.h     |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/rseq.h  |   2 +-
 .../include/s390x-linux-gnu/bits/setjmp.h     |   2 +-
 .../include/s390x-linux-gnu/bits/sigaction.h  |   2 +-
 .../include/s390x-linux-gnu/bits/statfs.h     |   2 +-
 .../s390x-linux-gnu/bits/struct_mutex.h       |  13 +-
 .../s390x-linux-gnu/bits/struct_rwlock.h      |   2 +-
 .../s390x-linux-gnu/bits/struct_stat.h        |   2 +-
 .../include/s390x-linux-gnu/bits/timesize.h   |   2 +-
 .../include/s390x-linux-gnu/bits/typesizes.h  |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/utmp.h  |   2 +-
 lib/libc/include/s390x-linux-gnu/bits/utmpx.h |   2 +-
 .../include/s390x-linux-gnu/fpu_control.h     |   2 +-
 lib/libc/include/s390x-linux-gnu/ieee754.h    |   2 +-
 lib/libc/include/s390x-linux-gnu/sys/elf.h    |   2 +-
 lib/libc/include/s390x-linux-gnu/sys/ptrace.h |   2 +-
 .../include/s390x-linux-gnu/sys/ucontext.h    |   2 +-
 lib/libc/include/s390x-linux-gnu/sys/user.h   |   2 +-
 .../sparc-linux-gnu/bits/environments.h       |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/epoll.h |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/errno.h |   2 +-
 .../include/sparc-linux-gnu/bits/eventfd.h    |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/fcntl.h |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/fenv.h  |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/hwcap.h |   2 +-
 .../include/sparc-linux-gnu/bits/inotify.h    |   2 +-
 .../include/sparc-linux-gnu/bits/ioctls.h     |   2 +-
 .../include/sparc-linux-gnu/bits/ipc-perm.h   |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/link.h  |   2 +-
 .../sparc-linux-gnu/bits/long-double.h        |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/mman.h  |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/poll.h  |   2 +-
 .../sparc-linux-gnu/bits/procfs-extra.h       |   2 +-
 .../include/sparc-linux-gnu/bits/procfs-id.h  |   2 +-
 .../include/sparc-linux-gnu/bits/procfs.h     |   2 +-
 .../sparc-linux-gnu/bits/pthread_stack_min.h  |   2 +-
 .../include/sparc-linux-gnu/bits/resource.h   |   2 +-
 lib/libc/include/sparc-linux-gnu/bits/rseq.h  |   2 +-
 .../include/sparc-linux-gnu/bits/setjmp.h     |   2 +-
 .../include/sparc-linux-gnu/bits/shmlba.h     |   2 +-
 .../include/sparc-linux-gnu/bits/sigaction.h  |   2 +-
 .../include/sparc-linux-gnu/bits/sigcontext.h |   2 +-
 .../include/sparc-linux-gnu/bits/signalfd.h   |   2 +-
 .../sparc-linux-gnu/bits/signum-arch.h        |   2 +-
 .../include/sparc-linux-gnu/bits/sigstack.h   |   2 +-
 .../sparc-linux-gnu/bits/socket-constants.h   |   2 +-
 .../sparc-linux-gnu/bits/socket_type.h        |   2 +-
 .../sparc-linux-gnu/bits/struct_rwlock.h      |   2 +-
 .../sparc-linux-gnu/bits/struct_stat.h        |   2 +-
 .../sparc-linux-gnu/bits/termios-c_cc.h       |   2 +-
 .../sparc-linux-gnu/bits/termios-c_oflag.h    |   2 +-
 .../sparc-linux-gnu/bits/termios-cbaud.h      |   2 +-
 .../include/sparc-linux-gnu/bits/timerfd.h    |   2 +-
 .../include/sparc-linux-gnu/bits/timesize.h   |   2 +-
 .../bits/types/struct_msqid_ds.h              |   2 +-
 .../bits/types/struct_semid_ds.h              |   2 +-
 .../bits/types/struct_shmid_ds.h              |   2 +-
 .../include/sparc-linux-gnu/bits/typesizes.h  |   2 +-
 .../include/sparc-linux-gnu/fpu_control.h     |   2 +-
 lib/libc/include/sparc-linux-gnu/ieee754.h    |   2 +-
 lib/libc/include/sparc-linux-gnu/sys/ptrace.h |   2 +-
 .../include/sparc-linux-gnu/sys/ucontext.h    |   2 +-
 lib/libc/include/sparc-linux-gnu/sys/user.h   |   2 +-
 .../x86-linux-gnu/bits/dl_find_object.h       |   2 +-
 .../include/x86-linux-gnu/bits/environments.h |   2 +-
 lib/libc/include/x86-linux-gnu/bits/epoll.h   |   2 +-
 lib/libc/include/x86-linux-gnu/bits/fcntl.h   |   2 +-
 lib/libc/include/x86-linux-gnu/bits/fenv.h    |   2 +-
 lib/libc/include/x86-linux-gnu/bits/floatn.h  |   2 +-
 .../x86-linux-gnu/bits/flt-eval-method.h      |   2 +-
 lib/libc/include/x86-linux-gnu/bits/fp-logb.h |   2 +-
 .../x86-linux-gnu/bits/indirect-return.h      |   2 +-
 .../include/x86-linux-gnu/bits/ipctypes.h     |   2 +-
 .../include/x86-linux-gnu/bits/iscanonical.h  |   2 +-
 lib/libc/include/x86-linux-gnu/bits/link.h    |   2 +-
 .../include/x86-linux-gnu/bits/long-double.h  |   2 +-
 .../include/x86-linux-gnu/bits/math-vector.h  |   2 +-
 lib/libc/include/x86-linux-gnu/bits/mman.h    |   2 +-
 .../include/x86-linux-gnu/bits/procfs-id.h    |   2 +-
 lib/libc/include/x86-linux-gnu/bits/procfs.h  |   2 +-
 .../x86-linux-gnu/bits/pthreadtypes-arch.h    |   2 +-
 lib/libc/include/x86-linux-gnu/bits/rseq.h    |   2 +-
 lib/libc/include/x86-linux-gnu/bits/setjmp.h  |   2 +-
 .../include/x86-linux-gnu/bits/sigcontext.h   |   2 +-
 .../include/x86-linux-gnu/bits/struct_mutex.h |  13 +-
 .../x86-linux-gnu/bits/struct_rwlock.h        |  15 +-
 .../include/x86-linux-gnu/bits/struct_stat.h  |   2 +-
 .../include/x86-linux-gnu/bits/timesize.h     |   2 +-
 .../bits/types/struct_semid_ds.h              |   2 +-
 .../include/x86-linux-gnu/bits/typesizes.h    |   2 +-
 .../finclude/math-vector-fortran.h            |   2 +-
 lib/libc/include/x86-linux-gnu/fpu_control.h  |   2 +-
 lib/libc/include/x86-linux-gnu/sys/elf.h      |   2 +-
 lib/libc/include/x86-linux-gnu/sys/ptrace.h   |   2 +-
 lib/libc/include/x86-linux-gnu/sys/ucontext.h |   2 +-
 lib/libc/include/x86-linux-gnu/sys/user.h     |   2 +-
 744 files changed, 1942 insertions(+), 959 deletions(-)
 create mode 100644 lib/libc/include/generic-glibc/bits/fcntl-linux-fortify.h
 create mode 100644 lib/libc/include/generic-glibc/bits/openat2.h
 rename lib/libc/include/{loongarch-linux-gnu/bits/shmlba.h => generic-glibc/bits/types/once_flag.h} (72%)
 rename lib/libc/include/{generic-glibc => loongarch-linux-gnu}/gnu/lib-names-lp64d.h (100%)
 create mode 100644 lib/libc/include/loongarch-linux-gnu/gnu/lib-names-lp64s.h
 rename lib/libc/include/{generic-glibc => loongarch-linux-gnu}/gnu/stubs-lp64d.h (100%)

diff --git a/lib/libc/include/aarch64-linux-gnu/bits/fcntl.h b/lib/libc/include/aarch64-linux-gnu/bits/fcntl.h
index 52dee64f6f1db38ed4cfb31c5463206d8cb459c7..c317abbbf675f5f01971725bb6dbe588878d63c6 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for the AArch64 Linux ABI.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/fenv.h b/lib/libc/include/aarch64-linux-gnu/bits/fenv.h
index 702717e1e697f9b5bd7bd164dd9b0517cb94c747..d7bd07fc73babe81aa764359b81ef21fd9da6534 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/fp-fast.h b/lib/libc/include/aarch64-linux-gnu/bits/fp-fast.h
index dc002b3edacdc4079152f966cfe24721c17abab5..8a75e4d867769c329c822e802814bc9689709a6f 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/fp-fast.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/fp-fast.h
@@ -1,5 +1,5 @@
 /* Define FP_FAST_* macros.  AArch64 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/hwcap.h b/lib/libc/include/aarch64-linux-gnu/bits/hwcap.h
index a2089de39f7dd89d444ee7cbe16794eb3915285c..f4189aa1bfca6909be4967e00821932faf753c7a 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/hwcap.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP.  AArch64 Linux version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -119,4 +119,7 @@
 #define HWCAP2_SME_SF8FMA	(1UL << 60)
 #define HWCAP2_SME_SF8DP4	(1UL << 61)
 #define HWCAP2_SME_SF8DP2	(1UL << 62)
-#define HWCAP2_POE		(1UL << 63)
\ No newline at end of file
+#define HWCAP2_POE		(1UL << 63)
+
+#define HWCAP3_MTE_FAR		(1UL << 0)
+#define HWCAP3_MTE_STORE_ONLY	(1UL << 1)
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/indirect-return.h b/lib/libc/include/aarch64-linux-gnu/bits/indirect-return.h
index 8f6f790cdf688daab650c7ca7662142aa8a5b6e5..d310966075c0d3a4b867759994024df0f3006170 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/indirect-return.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/indirect-return.h
@@ -1,5 +1,5 @@
 /* Definition of __INDIRECT_RETURN.  AArch64 version.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/link.h b/lib/libc/include/aarch64-linux-gnu/bits/link.h
index 693f135477df5919e330bf286c2b6cbcd39fe2e8..e8d9138f03c78597575905b8baa2c4e3b1d2831f 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/link.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/link.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/long-double.h b/lib/libc/include/aarch64-linux-gnu/bits/long-double.h
index 57d7be04a685d57ab6e8e672e08d7effa853b06b..af7784dbe6dd85cd9538b5a7b437ab45de22eeb8 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-128 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/math-vector.h b/lib/libc/include/aarch64-linux-gnu/bits/math-vector.h
index c4506228796577d29ffb3feef1ae910a36221004..68043a976c58a8f126799f7c386006471a4996eb 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/math-vector.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/math-vector.h
@@ -1,6 +1,6 @@
 /* Platform-specific SIMD declarations of math functions.
 
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -113,6 +113,14 @@
 # define __DECL_SIMD_expm1 __DECL_SIMD_aarch64
 # undef __DECL_SIMD_expm1f
 # define __DECL_SIMD_expm1f __DECL_SIMD_aarch64
+# undef __DECL_SIMD_exp2m1
+# define __DECL_SIMD_exp2m1 __DECL_SIMD_aarch64
+# undef __DECL_SIMD_exp2m1f
+# define __DECL_SIMD_exp2m1f __DECL_SIMD_aarch64
+# undef __DECL_SIMD_exp10m1
+# define __DECL_SIMD_exp10m1 __DECL_SIMD_aarch64
+# undef __DECL_SIMD_exp10m1f
+# define __DECL_SIMD_exp10m1f __DECL_SIMD_aarch64
 # undef __DECL_SIMD_hypot
 # define __DECL_SIMD_hypot __DECL_SIMD_aarch64
 # undef __DECL_SIMD_hypotf
@@ -125,6 +133,10 @@
 # define __DECL_SIMD_log10 __DECL_SIMD_aarch64
 # undef __DECL_SIMD_log10f
 # define __DECL_SIMD_log10f __DECL_SIMD_aarch64
+# undef __DECL_SIMD_log10p1
+# define __DECL_SIMD_log10p1 __DECL_SIMD_aarch64
+# undef __DECL_SIMD_log10p1f
+# define __DECL_SIMD_log10p1f __DECL_SIMD_aarch64
 # undef __DECL_SIMD_log1p
 # define __DECL_SIMD_log1p __DECL_SIMD_aarch64
 # undef __DECL_SIMD_log1pf
@@ -133,6 +145,10 @@
 # define __DECL_SIMD_log2 __DECL_SIMD_aarch64
 # undef __DECL_SIMD_log2f
 # define __DECL_SIMD_log2f __DECL_SIMD_aarch64
+# undef __DECL_SIMD_log2p1
+# define __DECL_SIMD_log2p1 __DECL_SIMD_aarch64
+# undef __DECL_SIMD_log2p1f
+# define __DECL_SIMD_log2p1f __DECL_SIMD_aarch64
 # undef __DECL_SIMD_logp1
 # define __DECL_SIMD_logp1 __DECL_SIMD_aarch64
 # undef __DECL_SIMD_logp1f
@@ -141,6 +157,10 @@
 # define __DECL_SIMD_pow __DECL_SIMD_aarch64
 # undef __DECL_SIMD_powf
 # define __DECL_SIMD_powf __DECL_SIMD_aarch64
+# undef __DECL_SIMD_rsqrt
+# define __DECL_SIMD_rsqrt __DECL_SIMD_aarch64
+# undef __DECL_SIMD_rsqrtf
+# define __DECL_SIMD_rsqrtf __DECL_SIMD_aarch64
 # undef __DECL_SIMD_sin
 # define __DECL_SIMD_sin __DECL_SIMD_aarch64
 # undef __DECL_SIMD_sinf
@@ -212,13 +232,18 @@ __vpcs __f32x4_t _ZGVnN4v_expf (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_exp10f (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_exp2f (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_expm1f (__f32x4_t);
+__vpcs __f32x4_t _ZGVnN4v_exp2m1f (__f32x4_t);
+__vpcs __f32x4_t _ZGVnN4v_exp10m1f (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4vv_hypotf (__f32x4_t, __f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_logf (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_log10f (__f32x4_t);
+__vpcs __f32x4_t _ZGVnN4v_log10p1f (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_log1pf (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_log2f (__f32x4_t);
+__vpcs __f32x4_t _ZGVnN4v_log2p1f (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_logp1f (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4vv_powf (__f32x4_t, __f32x4_t);
+__vpcs __f32x4_t _ZGVnN4v_rsqrtf (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_sinf (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_sinhf (__f32x4_t);
 __vpcs __f32x4_t _ZGVnN4v_sinpif (__f32x4_t);
@@ -247,13 +272,18 @@ __vpcs __f64x2_t _ZGVnN2v_exp (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_exp10 (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_exp2 (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_expm1 (__f64x2_t);
+__vpcs __f64x2_t _ZGVnN2v_exp2m1 (__f64x2_t);
+__vpcs __f64x2_t _ZGVnN2v_exp10m1 (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2vv_hypot (__f64x2_t, __f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_log (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_log10 (__f64x2_t);
+__vpcs __f64x2_t _ZGVnN2v_log10p1 (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_log1p (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_log2 (__f64x2_t);
+__vpcs __f64x2_t _ZGVnN2v_log2p1 (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_logp1 (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2vv_pow (__f64x2_t, __f64x2_t);
+__vpcs __f64x2_t _ZGVnN2v_rsqrt (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_sin (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_sinh (__f64x2_t);
 __vpcs __f64x2_t _ZGVnN2v_sinpi (__f64x2_t);
@@ -287,13 +317,18 @@ __sv_f32_t _ZGVsMxv_expf (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_exp10f (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_exp2f (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_expm1f (__sv_f32_t, __sv_bool_t);
+__sv_f32_t _ZGVsMxv_exp2m1f (__sv_f32_t, __sv_bool_t);
+__sv_f32_t _ZGVsMxv_exp10m1f (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxvv_hypotf (__sv_f32_t, __sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_logf (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_log10f (__sv_f32_t, __sv_bool_t);
+__sv_f32_t _ZGVsMxv_log10p1f (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_log1pf (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_log2f (__sv_f32_t, __sv_bool_t);
+__sv_f32_t _ZGVsMxv_log2p1f (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_logp1f (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxvv_powf (__sv_f32_t, __sv_f32_t, __sv_bool_t);
+__sv_f32_t _ZGVsMxv_rsqrtf (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_sinf (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_sinhf (__sv_f32_t, __sv_bool_t);
 __sv_f32_t _ZGVsMxv_sinpif (__sv_f32_t, __sv_bool_t);
@@ -322,13 +357,18 @@ __sv_f64_t _ZGVsMxv_exp (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_exp10 (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_exp2 (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_expm1 (__sv_f64_t, __sv_bool_t);
+__sv_f64_t _ZGVsMxv_exp2m1 (__sv_f64_t, __sv_bool_t);
+__sv_f64_t _ZGVsMxv_exp10m1 (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxvv_hypot (__sv_f64_t, __sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_log (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_log10 (__sv_f64_t, __sv_bool_t);
+__sv_f64_t _ZGVsMxv_log10p1 (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_log1p (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_log2 (__sv_f64_t, __sv_bool_t);
+__sv_f64_t _ZGVsMxv_log2p1 (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_logp1 (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxvv_pow (__sv_f64_t, __sv_f64_t, __sv_bool_t);
+__sv_f64_t _ZGVsMxv_rsqrt (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_sin (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_sinh (__sv_f64_t, __sv_bool_t);
 __sv_f64_t _ZGVsMxv_sinpi (__sv_f64_t, __sv_bool_t);
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/mman.h b/lib/libc/include/aarch64-linux-gnu/bits/mman.h
index f09eebcbcde3c9fbed42512b6baf3a9801465101..e07d498d15128a41c01c3982245bb02bee8ef168 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/mman.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/AArch64 version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/procfs.h b/lib/libc/include/aarch64-linux-gnu/bits/procfs.h
index 075f1db99b69801636a3235eefcdaeac51e26261..9ecaa7d1fa8e0d4d5df079af7b4f5a8719bbe9e8 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  AArch64 version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/pthread_stack_min.h b/lib/libc/include/aarch64-linux-gnu/bits/pthread_stack_min.h
index 0e0020a9e1c05a1e9ab46fcc5b53e2c26eb962e0..99a96d0d984bd2c0fd9ebcd4654dd69f774a0778 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/pthread_stack_min.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/pthread_stack_min.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN.  Linux/aarch64 version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/pthreadtypes-arch.h b/lib/libc/include/aarch64-linux-gnu/bits/pthreadtypes-arch.h
index 2dbe12da0ca4cdde3426daf253d84375a36b9bd1..d53eef2452b531fc1f5db1621d35eadc4074c852 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/pthreadtypes-arch.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/pthreadtypes-arch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/rseq.h b/lib/libc/include/aarch64-linux-gnu/bits/rseq.h
index f3769e9fe0beff68dd885fad216dd23d7d34d5ef..3e670c7aebdb811cba90543cead0e9bf43b40d53 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux aarch64 architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/semaphore.h b/lib/libc/include/aarch64-linux-gnu/bits/semaphore.h
index 7d3d93431e67f2a62e40c4fdc1c4e169aa71e096..f2e5f3635faf1d0e40aab89c41601d80a59b15b7 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/semaphore.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/semaphore.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/setjmp.h b/lib/libc/include/aarch64-linux-gnu/bits/setjmp.h
index 36912770cb2c44c383ca40e55c6a666e5a1531f1..faecee9c63a5961732cb6e3701a4e8abc31c9c12 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/sigstack.h b/lib/libc/include/aarch64-linux-gnu/bits/sigstack.h
index 0e273c571193ce6f6abb50e37707a8d50005ca7a..3cf88c099f4e3b3f462e2e3d5fd2662329b2a911 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/sigstack.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/sigstack.h
@@ -1,5 +1,5 @@
 /* sigstack, sigaltstack definitions.
-   Copyright (C) 2015-2025 Free Software Foundation, Inc.
+   Copyright (C) 2015-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/aarch64-linux-gnu/bits/struct_rwlock.h
index a05896c684cdc56aa6bf30e46f6677658a6f04d5..e8ceba6bf608315c4c0a8e4451b57a9ac7938266 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* AArch64 internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/struct_stat.h b/lib/libc/include/aarch64-linux-gnu/bits/struct_stat.h
index 724450a6679649260300d400798787a515849f1d..0462d37a6849812f485a6830a7c0dca303332636 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/timesize.h b/lib/libc/include/aarch64-linux-gnu/bits/timesize.h
index 04251ea75c82b9450e5c2bee30c3bbf06cbe55fb..dff2da5ed6bf30ce6f5580aee352e0958d58b623 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, general case.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/bits/wordsize.h b/lib/libc/include/aarch64-linux-gnu/bits/wordsize.h
index 3f84507cc16e18556599b2f90bda882e6e283173..d6528d5b9910b2a503c09b65d6e47f0fcb4a45e9 100644
--- a/lib/libc/include/aarch64-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/aarch64-linux-gnu/bits/wordsize.h
@@ -1,6 +1,6 @@
 /* Determine the wordsize from the preprocessor defines.
 
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/finclude/math-vector-fortran.h b/lib/libc/include/aarch64-linux-gnu/finclude/math-vector-fortran.h
index c17752e02327e7aba89122ed2101c7ba8c0cfa5c..59c7f2db4a8dfefe910714f9a659b8e61680df63 100644
--- a/lib/libc/include/aarch64-linux-gnu/finclude/math-vector-fortran.h
+++ b/lib/libc/include/aarch64-linux-gnu/finclude/math-vector-fortran.h
@@ -1,5 +1,5 @@
 ! Platform-specific declarations of SIMD math functions for Fortran. -*- f90 -*-
-!   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+!   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 !   This file is part of the GNU C Library.
 !
 !   The GNU C Library is free software; you can redistribute it and/or
@@ -15,33 +15,82 @@
 !   You should have received a copy of the GNU Lesser General Public
 !   License along with the GNU C Library; if not, see
 !   <https://www.gnu.org/licenses/>.
+
 !GCC$ builtin (acos) attributes simd (notinbranch)
 !GCC$ builtin (acosf) attributes simd (notinbranch)
+!GCC$ builtin (acosh) attributes simd (notinbranch)
+!GCC$ builtin (acoshf) attributes simd (notinbranch)
+!GCC$ builtin (acospi) attributes simd (notinbranch)
+!GCC$ builtin (acospif) attributes simd (notinbranch)
 !GCC$ builtin (asin) attributes simd (notinbranch)
 !GCC$ builtin (asinf) attributes simd (notinbranch)
+!GCC$ builtin (asinh) attributes simd (notinbranch)
+!GCC$ builtin (asinhf) attributes simd (notinbranch)
+!GCC$ builtin (asinpi) attributes simd (notinbranch)
+!GCC$ builtin (asinpif) attributes simd (notinbranch)
 !GCC$ builtin (atan) attributes simd (notinbranch)
-!GCC$ builtin (atanf) attributes simd (notinbranch)
 !GCC$ builtin (atan2) attributes simd (notinbranch)
 !GCC$ builtin (atan2f) attributes simd (notinbranch)
+!GCC$ builtin (atan2pi) attributes simd (notinbranch)
+!GCC$ builtin (atan2pif) attributes simd (notinbranch)
+!GCC$ builtin (atanf) attributes simd (notinbranch)
+!GCC$ builtin (atanh) attributes simd (notinbranch)
+!GCC$ builtin (atanhf) attributes simd (notinbranch)
+!GCC$ builtin (atanpi) attributes simd (notinbranch)
+!GCC$ builtin (atanpif) attributes simd (notinbranch)
+!GCC$ builtin (cbrt) attributes simd (notinbranch)
+!GCC$ builtin (cbrtf) attributes simd (notinbranch)
 !GCC$ builtin (cos) attributes simd (notinbranch)
 !GCC$ builtin (cosf) attributes simd (notinbranch)
+!GCC$ builtin (cosh) attributes simd (notinbranch)
+!GCC$ builtin (coshf) attributes simd (notinbranch)
+!GCC$ builtin (cospi) attributes simd (notinbranch)
+!GCC$ builtin (cospif) attributes simd (notinbranch)
+!GCC$ builtin (erf) attributes simd (notinbranch)
+!GCC$ builtin (erfc) attributes simd (notinbranch)
+!GCC$ builtin (erfcf) attributes simd (notinbranch)
+!GCC$ builtin (erff) attributes simd (notinbranch)
 !GCC$ builtin (exp) attributes simd (notinbranch)
-!GCC$ builtin (expf) attributes simd (notinbranch)
 !GCC$ builtin (exp10) attributes simd (notinbranch)
 !GCC$ builtin (exp10f) attributes simd (notinbranch)
+!GCC$ builtin (exp10m1) attributes simd (notinbranch)
+!GCC$ builtin (exp10m1f) attributes simd (notinbranch)
 !GCC$ builtin (exp2) attributes simd (notinbranch)
 !GCC$ builtin (exp2f) attributes simd (notinbranch)
+!GCC$ builtin (exp2m1) attributes simd (notinbranch)
+!GCC$ builtin (exp2m1f) attributes simd (notinbranch)
+!GCC$ builtin (expf) attributes simd (notinbranch)
 !GCC$ builtin (expm1) attributes simd (notinbranch)
 !GCC$ builtin (expm1f) attributes simd (notinbranch)
+!GCC$ builtin (hypot) attributes simd (notinbranch)
+!GCC$ builtin (hypotf) attributes simd (notinbranch)
 !GCC$ builtin (log) attributes simd (notinbranch)
-!GCC$ builtin (logf) attributes simd (notinbranch)
 !GCC$ builtin (log10) attributes simd (notinbranch)
 !GCC$ builtin (log10f) attributes simd (notinbranch)
+!GCC$ builtin (log10p1) attributes simd (notinbranch)
+!GCC$ builtin (log10p1f) attributes simd (notinbranch)
 !GCC$ builtin (log1p) attributes simd (notinbranch)
 !GCC$ builtin (log1pf) attributes simd (notinbranch)
 !GCC$ builtin (log2) attributes simd (notinbranch)
 !GCC$ builtin (log2f) attributes simd (notinbranch)
+!GCC$ builtin (log2p1) attributes simd (notinbranch)
+!GCC$ builtin (log2p1f) attributes simd (notinbranch)
+!GCC$ builtin (logf) attributes simd (notinbranch)
+!GCC$ builtin (logp1) attributes simd (notinbranch)
+!GCC$ builtin (logp1f) attributes simd (notinbranch)
+!GCC$ builtin (pow) attributes simd (notinbranch)
+!GCC$ builtin (powf) attributes simd (notinbranch)
+!GCC$ builtin (rsqrt) attributes simd (notinbranch)
+!GCC$ builtin (rsqrtf) attributes simd (notinbranch)
 !GCC$ builtin (sin) attributes simd (notinbranch)
 !GCC$ builtin (sinf) attributes simd (notinbranch)
+!GCC$ builtin (sinh) attributes simd (notinbranch)
+!GCC$ builtin (sinhf) attributes simd (notinbranch)
+!GCC$ builtin (sinpi) attributes simd (notinbranch)
+!GCC$ builtin (sinpif) attributes simd (notinbranch)
 !GCC$ builtin (tan) attributes simd (notinbranch)
-!GCC$ builtin (tanf) attributes simd (notinbranch)
\ No newline at end of file
+!GCC$ builtin (tanf) attributes simd (notinbranch)
+!GCC$ builtin (tanh) attributes simd (notinbranch)
+!GCC$ builtin (tanhf) attributes simd (notinbranch)
+!GCC$ builtin (tanpi) attributes simd (notinbranch)
+!GCC$ builtin (tanpif) attributes simd (notinbranch)
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-linux-gnu/fpu_control.h b/lib/libc/include/aarch64-linux-gnu/fpu_control.h
index fcb6cf7f96221183d0ab59c11717a145bd735f0a..8c7466ad16a84d6d7d4b58ccbfb023133fc87cfe 100644
--- a/lib/libc/include/aarch64-linux-gnu/fpu_control.h
+++ b/lib/libc/include/aarch64-linux-gnu/fpu_control.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
@@ -20,6 +20,7 @@
 #define _AARCH64_FPU_CONTROL_H
 
 #include <features.h>
+#include <sys/types.h>
 
 /* Macros for accessing the FPCR and FPSR.  */
 
diff --git a/lib/libc/include/aarch64-linux-gnu/ieee754.h b/lib/libc/include/aarch64-linux-gnu/ieee754.h
index a49523c3d8faa01c2f79bd6e565578db52ddb727..a19fd8dcd1d39c39a1b5000ca0b4d3f8da2c2299 100644
--- a/lib/libc/include/aarch64-linux-gnu/ieee754.h
+++ b/lib/libc/include/aarch64-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/aarch64-linux-gnu/sys/elf.h b/lib/libc/include/aarch64-linux-gnu/sys/elf.h
index 3611e2908d0f138ab83ef310ed36f55774eb759d..68b7bb210d1161d9a37d55a2f14e2a39a1ce4c76 100644
--- a/lib/libc/include/aarch64-linux-gnu/sys/elf.h
+++ b/lib/libc/include/aarch64-linux-gnu/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/sys/ptrace.h b/lib/libc/include/aarch64-linux-gnu/sys/ptrace.h
index 9dda96614873460fdf7f022d455cce417798125a..cb3ddcbc697a28961d7decde1c349f95c3d82cc7 100644
--- a/lib/libc/include/aarch64-linux-gnu/sys/ptrace.h
+++ b/lib/libc/include/aarch64-linux-gnu/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux/AArch64 version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/aarch64-linux-gnu/sys/ucontext.h b/lib/libc/include/aarch64-linux-gnu/sys/ucontext.h
index 4866e4fd961d35bf24d862c5cbed29e4ff280699..b84911aa1492b04102864e2cb12a692c54bbe00d 100644
--- a/lib/libc/include/aarch64-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/aarch64-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
@@ -63,7 +63,7 @@ typedef struct
     unsigned char __reserved[4096] __attribute__ ((__aligned__ (16)));
   } mcontext_t;
 
-/* Userlevel context.  */
+/* User-level context.  */
 typedef struct ucontext_t
   {
     unsigned long __ctx(uc_flags);
diff --git a/lib/libc/include/aarch64-linux-gnu/sys/user.h b/lib/libc/include/aarch64-linux-gnu/sys/user.h
index b370717dc2f1c3d21038a48e784c84555ce93278..3d622faaecf8e5bf4d50c33c8fb5e73d6bd06f4a 100644
--- a/lib/libc/include/aarch64-linux-gnu/sys/user.h
+++ b/lib/libc/include/aarch64-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2009-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/arc-linux-gnu/bits/fcntl.h b/lib/libc/include/arc-linux-gnu/bits/fcntl.h
index e033990adc664eaa42782c108779ce3c03e63567..000bc724699be2e3240d7be6fdf3b51a79550207 100644
--- a/lib/libc/include/arc-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/arc-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for the generic Linux ABI.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/fenv.h b/lib/libc/include/arc-linux-gnu/bits/fenv.h
index 382f0d08c46c7b63031f564d45cef414276258af..fbda571543a1715844be341cdd255afdd009803a 100644
--- a/lib/libc/include/arc-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/arc-linux-gnu/bits/fenv.h
@@ -1,5 +1,5 @@
 /* Floating point environment.  ARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/floatn.h b/lib/libc/include/arc-linux-gnu/bits/floatn.h
index 9005dc8601d52334aa53591640f009c59f6e6672..d3408f15249d51ab748cb0313f4cc3f36b09cdda 100644
--- a/lib/libc/include/arc-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/arc-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/link.h b/lib/libc/include/arc-linux-gnu/bits/link.h
index 594c6c8098af495baa8ddf23678a6eecc934c6fd..eadaf80a4a7d34d083d1e9a3b636668d282c8e8d 100644
--- a/lib/libc/include/arc-linux-gnu/bits/link.h
+++ b/lib/libc/include/arc-linux-gnu/bits/link.h
@@ -1,5 +1,5 @@
 /* Machine-specific declarations for dynamic linker interface, ARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/long-double.h b/lib/libc/include/arc-linux-gnu/bits/long-double.h
index d07f1a74182121c8f23b5008dada66f34b6b1a86..ffaee6c9be5dc2b72f99833c8773fc72b1f6c2e8 100644
--- a/lib/libc/include/arc-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/arc-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/procfs.h b/lib/libc/include/arc-linux-gnu/bits/procfs.h
index f5c1a9db48d542e3f402d4a6b59e94b7b28d71bf..9d59fd0f3106f124ba59b7ecf2c0d349f61172c7 100644
--- a/lib/libc/include/arc-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/arc-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  ARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/rseq.h b/lib/libc/include/arc-linux-gnu/bits/rseq.h
index 90b3e9804a5b827612f37a31f9805ee0d82ad9a4..a844012dd3a527f6948a027145ecc10a1f01903f 100644
--- a/lib/libc/include/arc-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/arc-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences architecture header.  Stub version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/arc-linux-gnu/bits/setjmp.h b/lib/libc/include/arc-linux-gnu/bits/setjmp.h
index 232c097bd5c940e0fb54f73fff592e131d25f9b1..f6273a7471eff91c10501aeb4c2c54475e686fba 100644
--- a/lib/libc/include/arc-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/arc-linux-gnu/bits/setjmp.h
@@ -1,5 +1,5 @@
 /* Define the machine-dependent type 'jmp_buf'.  ARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/struct_stat.h b/lib/libc/include/arc-linux-gnu/bits/struct_stat.h
index 724450a6679649260300d400798787a515849f1d..0462d37a6849812f485a6830a7c0dca303332636 100644
--- a/lib/libc/include/arc-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/arc-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/timesize.h b/lib/libc/include/arc-linux-gnu/bits/timesize.h
index 04251ea75c82b9450e5c2bee30c3bbf06cbe55fb..dff2da5ed6bf30ce6f5580aee352e0958d58b623 100644
--- a/lib/libc/include/arc-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/arc-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, general case.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/bits/wordsize.h b/lib/libc/include/arc-linux-gnu/bits/wordsize.h
index 6b841cc0f50c1acb397ec38a53ff16cb3b4875e6..3f6991890c6ab3413fe26fe4cbf6f3008db7a1fc 100644
--- a/lib/libc/include/arc-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/arc-linux-gnu/bits/wordsize.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/fpu_control.h b/lib/libc/include/arc-linux-gnu/fpu_control.h
index c4db39e9a64d6c90a561457b54abdd2ad5d6552a..f2d30f37a9c685a09130b6d8e09c640bbcc60cbc 100644
--- a/lib/libc/include/arc-linux-gnu/fpu_control.h
+++ b/lib/libc/include/arc-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.  ARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/sys/cachectl.h b/lib/libc/include/arc-linux-gnu/sys/cachectl.h
index 8300c25094f5d272b13cfca28f320328c9220688..ea9c31999c47a56ae4e057bbe9c22200864f7131 100644
--- a/lib/libc/include/arc-linux-gnu/sys/cachectl.h
+++ b/lib/libc/include/arc-linux-gnu/sys/cachectl.h
@@ -1,5 +1,5 @@
 /* cacheflush - flush contents of instruction and/or data cache.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/sys/ucontext.h b/lib/libc/include/arc-linux-gnu/sys/ucontext.h
index 299dcfa2cf347dff9909ca0d79acaeef895400ba..998d13adf426b7e5686ac9019aec9eb371d17ae0 100644
--- a/lib/libc/include/arc-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/arc-linux-gnu/sys/ucontext.h
@@ -1,5 +1,5 @@
 /* struct ucontext definition, ARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arc-linux-gnu/sys/user.h b/lib/libc/include/arc-linux-gnu/sys/user.h
index f108a30177d779d0372d4c79ae710187d3a9a2fa..661b16287255c5de6ca2abfbc2c91f04a84c9c2c 100644
--- a/lib/libc/include/arc-linux-gnu/sys/user.h
+++ b/lib/libc/include/arc-linux-gnu/sys/user.h
@@ -1,5 +1,5 @@
 /* ptrace register data format definitions.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/dl_find_object.h b/lib/libc/include/arm-linux-gnu/bits/dl_find_object.h
index 46912bb1d346b4c2a0939ce3f44abc24d57845e7..38dad3f062d2b27fdcbbeb0a38fb7bfb8e4bdcae 100644
--- a/lib/libc/include/arm-linux-gnu/bits/dl_find_object.h
+++ b/lib/libc/include/arm-linux-gnu/bits/dl_find_object.h
@@ -1,5 +1,5 @@
 /* arm definitions for finding objects.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/fcntl.h b/lib/libc/include/arm-linux-gnu/bits/fcntl.h
index 14a203d05069acf0b065edfed03e6d0b14d31b19..e0ab5fa08226837096d3f981525ad2177130f5ab 100644
--- a/lib/libc/include/arm-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/arm-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/fenv.h b/lib/libc/include/arm-linux-gnu/bits/fenv.h
index 4815a06d47eebd9626acf0629282c783ef4cc434..e897e42603eeb2d599b1c5607f837abc88ece2aa 100644
--- a/lib/libc/include/arm-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/arm-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/floatn.h b/lib/libc/include/arm-linux-gnu/bits/floatn.h
index 9005dc8601d52334aa53591640f009c59f6e6672..d3408f15249d51ab748cb0313f4cc3f36b09cdda 100644
--- a/lib/libc/include/arm-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/arm-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/hwcap.h b/lib/libc/include/arm-linux-gnu/bits/hwcap.h
index 7b16f0e9d699353c91ea50fece74e44f14a52dea..335e4935c64e5c8d83d79e09b25a7b088a40f91c 100644
--- a/lib/libc/include/arm-linux-gnu/bits/hwcap.h
+++ b/lib/libc/include/arm-linux-gnu/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP.  ARM Linux version.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/link.h b/lib/libc/include/arm-linux-gnu/bits/link.h
index 8060167ec18ad909c5dfc33a06537937f1239922..6d0cdd01968d273a12f5c305443f0aa362acff54 100644
--- a/lib/libc/include/arm-linux-gnu/bits/link.h
+++ b/lib/libc/include/arm-linux-gnu/bits/link.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/long-double.h b/lib/libc/include/arm-linux-gnu/bits/long-double.h
index d07f1a74182121c8f23b5008dada66f34b6b1a86..ffaee6c9be5dc2b72f99833c8773fc72b1f6c2e8 100644
--- a/lib/libc/include/arm-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/arm-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/procfs-id.h b/lib/libc/include/arm-linux-gnu/bits/procfs-id.h
index 58c2162a88389d76131cf50c8642c8fce8b78cdb..8b0d8a502e3c29a3c92e74c49309d5767a15d463 100644
--- a/lib/libc/include/arm-linux-gnu/bits/procfs-id.h
+++ b/lib/libc/include/arm-linux-gnu/bits/procfs-id.h
@@ -1,5 +1,5 @@
 /* Types of pr_uid and pr_gid in struct elf_prpsinfo.  Arm version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/arm-linux-gnu/bits/procfs.h b/lib/libc/include/arm-linux-gnu/bits/procfs.h
index 2a60d31099c9fce19c253ee399477557fa95edd7..37497a28990bb5613503782859c2ff7247306fee 100644
--- a/lib/libc/include/arm-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/arm-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  Arm version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/rseq.h b/lib/libc/include/arm-linux-gnu/bits/rseq.h
index 1d6a1639407b3ce56734e324e3dedb45f541b617..8f53196582e8804bd5dcb1e67c702580130c2211 100644
--- a/lib/libc/include/arm-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/arm-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux arm architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/arm-linux-gnu/bits/setjmp.h b/lib/libc/include/arm-linux-gnu/bits/setjmp.h
index 7fdd2e4f5216d627f37ac28f750c22a9d55bb41d..43c5fc77bdf5cb3338bc7d9ef1acf6530e72f118 100644
--- a/lib/libc/include/arm-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/arm-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/shmlba.h b/lib/libc/include/arm-linux-gnu/bits/shmlba.h
index c615e207966dc2ae9c0b93866329744fa3f20612..b12474c3f126dbdaf523bd9ce019ad719df488f8 100644
--- a/lib/libc/include/arm-linux-gnu/bits/shmlba.h
+++ b/lib/libc/include/arm-linux-gnu/bits/shmlba.h
@@ -1,5 +1,5 @@
 /* Define SHMLBA.  ARM version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/struct_stat.h b/lib/libc/include/arm-linux-gnu/bits/struct_stat.h
index 71196f193f51ff5e39d8d82ce08080e976a4cc19..8a057c16332fbc6c9fd0ab02e1c516c48ed4b5b5 100644
--- a/lib/libc/include/arm-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/arm-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.  Linux/arm version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/timesize.h b/lib/libc/include/arm-linux-gnu/bits/timesize.h
index 3b50f81112d242016b8bdc49619fbc29ef69ee86..9b0a0ec2e9b71a9c51d3a37e00b9bb1b6a03d7bd 100644
--- a/lib/libc/include/arm-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/arm-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/ARM.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/typesizes.h b/lib/libc/include/arm-linux-gnu/bits/typesizes.h
index 11790d7eacb44275ba257c83a60b30396821f92a..200578b9f26caac4d2f4e81867e8bf560771321e 100644
--- a/lib/libc/include/arm-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/arm-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  ARM version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/bits/wordsize.h b/lib/libc/include/arm-linux-gnu/bits/wordsize.h
index db329914346120034ed744f869ca475dda80c060..6e4c479fe4392ef20c85cd861dcde13f3825051d 100644
--- a/lib/libc/include/arm-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/arm-linux-gnu/bits/wordsize.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/fpu_control.h b/lib/libc/include/arm-linux-gnu/fpu_control.h
index 57a0c0548b0804b63ea5b2bc79e997980b122588..4dfc9182f38ba78eae2e45f88d2ade42a2db8a56 100644
--- a/lib/libc/include/arm-linux-gnu/fpu_control.h
+++ b/lib/libc/include/arm-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word definitions.  ARM VFP version.
-   Copyright (C) 2004-2025 Free Software Foundation, Inc.
+   Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/sys/ptrace.h b/lib/libc/include/arm-linux-gnu/sys/ptrace.h
index 781cc3578de338a87b73f8e38a01dc8d019fec8e..de859feabcb089f7eac1be4283a5b0ccdd3ceb8f 100644
--- a/lib/libc/include/arm-linux-gnu/sys/ptrace.h
+++ b/lib/libc/include/arm-linux-gnu/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux/ARM version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/arm-linux-gnu/sys/ucontext.h b/lib/libc/include/arm-linux-gnu/sys/ucontext.h
index 56c60d929a6b53700ca6e930d0ec3378b3f406a5..737037437a7170417776e7a58b6e2d1255a284d1 100644
--- a/lib/libc/include/arm-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/arm-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/arm-linux-gnu/sys/user.h b/lib/libc/include/arm-linux-gnu/sys/user.h
index 37a8cc78f8a436662e529411da779b71c78d08cd..f5669eca1a5f8008fee0fe87509ce8f457b5691a 100644
--- a/lib/libc/include/arm-linux-gnu/sys/user.h
+++ b/lib/libc/include/arm-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/fcntl.h b/lib/libc/include/csky-linux-gnu/bits/fcntl.h
index e033990adc664eaa42782c108779ce3c03e63567..000bc724699be2e3240d7be6fdf3b51a79550207 100644
--- a/lib/libc/include/csky-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/csky-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for the generic Linux ABI.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/fenv.h b/lib/libc/include/csky-linux-gnu/bits/fenv.h
index 474af2596c3c00741feb0fd669e6b3bc35e6826d..0bba92429353378a73114c060c329f0058f49b74 100644
--- a/lib/libc/include/csky-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/csky-linux-gnu/bits/fenv.h
@@ -1,5 +1,5 @@
 /* Floating point environment.  C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/floatn.h b/lib/libc/include/csky-linux-gnu/bits/floatn.h
index 9005dc8601d52334aa53591640f009c59f6e6672..d3408f15249d51ab748cb0313f4cc3f36b09cdda 100644
--- a/lib/libc/include/csky-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/csky-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/link.h b/lib/libc/include/csky-linux-gnu/bits/link.h
index ca027d0e88466c7ab34f449fde90eba92c0fe9d6..9c46039e1b10adb64203f011a981b8bfe5ef3574 100644
--- a/lib/libc/include/csky-linux-gnu/bits/link.h
+++ b/lib/libc/include/csky-linux-gnu/bits/link.h
@@ -1,5 +1,5 @@
 /* Machine-specific declarations for dynamic linker interface.  C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/long-double.h b/lib/libc/include/csky-linux-gnu/bits/long-double.h
index d07f1a74182121c8f23b5008dada66f34b6b1a86..ffaee6c9be5dc2b72f99833c8773fc72b1f6c2e8 100644
--- a/lib/libc/include/csky-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/csky-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/procfs.h b/lib/libc/include/csky-linux-gnu/bits/procfs.h
index 91bc54a3fc7ca5637423570856e0de26422d4dd1..a2faeb5fbdd534fd47fa0ac01be5a92664dded2b 100644
--- a/lib/libc/include/csky-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/csky-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/rseq.h b/lib/libc/include/csky-linux-gnu/bits/rseq.h
index 90b3e9804a5b827612f37a31f9805ee0d82ad9a4..a844012dd3a527f6948a027145ecc10a1f01903f 100644
--- a/lib/libc/include/csky-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/csky-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences architecture header.  Stub version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/csky-linux-gnu/bits/setjmp.h b/lib/libc/include/csky-linux-gnu/bits/setjmp.h
index 8edb4c0c1a6a31027e1ae6e10d670f0122b2f730..5486c273e6db1ebe899671c51b57429547ba3a0f 100644
--- a/lib/libc/include/csky-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/csky-linux-gnu/bits/setjmp.h
@@ -1,5 +1,5 @@
 /* Define the machine-dependent type `jmp_buf'.  C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/shmlba.h b/lib/libc/include/csky-linux-gnu/bits/shmlba.h
index 79e12b823706a000a95fb682e4bfbbe2c183c0ee..5d7d35e3c97ef03db7d72e67cef665e8bcadfadc 100644
--- a/lib/libc/include/csky-linux-gnu/bits/shmlba.h
+++ b/lib/libc/include/csky-linux-gnu/bits/shmlba.h
@@ -1,5 +1,5 @@
 /* Define SHMLBA.  C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/statfs.h b/lib/libc/include/csky-linux-gnu/bits/statfs.h
index 13479a330b5df6558e4bc43694583f8dec07bd00..8188a1106b02625663d4ed15c700543eb70f6f4e 100644
--- a/lib/libc/include/csky-linux-gnu/bits/statfs.h
+++ b/lib/libc/include/csky-linux-gnu/bits/statfs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2011-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/struct_stat.h b/lib/libc/include/csky-linux-gnu/bits/struct_stat.h
index 4064985100f6f71bbc12906020bb3685a7357a3a..b5693ad4ef518fea3870d4045000f3962588e84d 100644
--- a/lib/libc/include/csky-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/csky-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.  Linux/csky version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/timesize.h b/lib/libc/include/csky-linux-gnu/bits/timesize.h
index f97e401df5b1495c5b6c3490df7fc74762c70131..72234351344bad7992324022f8e4608d2b8d61d6 100644
--- a/lib/libc/include/csky-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/csky-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/csky.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/bits/wordsize.h b/lib/libc/include/csky-linux-gnu/bits/wordsize.h
index db329914346120034ed744f869ca475dda80c060..6e4c479fe4392ef20c85cd861dcde13f3825051d 100644
--- a/lib/libc/include/csky-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/csky-linux-gnu/bits/wordsize.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/fpu_control.h b/lib/libc/include/csky-linux-gnu/fpu_control.h
index f7a844d2fd7d7be382c90dc9a94b105ef9984160..99edc54621423c4b1ac23a4c36c29e5c6784c4b7 100644
--- a/lib/libc/include/csky-linux-gnu/fpu_control.h
+++ b/lib/libc/include/csky-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.  C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/sys/cachectl.h b/lib/libc/include/csky-linux-gnu/sys/cachectl.h
index 13ea674214b1e4459208eabbaccf7cb8cf072119..1b855735be55606f0e348b6c542887b9d5091960 100644
--- a/lib/libc/include/csky-linux-gnu/sys/cachectl.h
+++ b/lib/libc/include/csky-linux-gnu/sys/cachectl.h
@@ -1,5 +1,5 @@
 /* C-SKY cache flushing interface.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/sys/ucontext.h b/lib/libc/include/csky-linux-gnu/sys/ucontext.h
index 629a841f77407d923a1e4ce5525dcb67a21b4301..2917185c9f977da8e982e95fbb4c5d86ad016428 100644
--- a/lib/libc/include/csky-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/csky-linux-gnu/sys/ucontext.h
@@ -1,5 +1,5 @@
 /* struct ucontext definition, C-SKY version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/csky-linux-gnu/sys/user.h b/lib/libc/include/csky-linux-gnu/sys/user.h
index b6b16709f710a13bec3159d64ad486bc6c779ef5..8360978ed969855532963410f7929f3fce8237c0 100644
--- a/lib/libc/include/csky-linux-gnu/sys/user.h
+++ b/lib/libc/include/csky-linux-gnu/sys/user.h
@@ -1,6 +1,6 @@
 /* This file is not used by C-SKY GDB. ptrace can use pt_regs definition
    from linux kernel directly.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/aio.h b/lib/libc/include/generic-glibc/aio.h
index 045f9d0897114745537b2ee26739339424beed26..3f25c83b31796402368dd7adf94db7c25c36255a 100644
--- a/lib/libc/include/generic-glibc/aio.h
+++ b/lib/libc/include/generic-glibc/aio.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/aliases.h b/lib/libc/include/generic-glibc/aliases.h
index 4198827e0742971a80069808b108af1ba4d0a77b..a74245fd650c3897a7639048beb9bd847df6c10f 100644
--- a/lib/libc/include/generic-glibc/aliases.h
+++ b/lib/libc/include/generic-glibc/aliases.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/alloca.h b/lib/libc/include/generic-glibc/alloca.h
index 86aaae0ed0ace9520bd93907443766fd19a5fa91..eb230b210418037b2fa3b1d0a09788e166cd4d33 100644
--- a/lib/libc/include/generic-glibc/alloca.h
+++ b/lib/libc/include/generic-glibc/alloca.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/ar.h b/lib/libc/include/generic-glibc/ar.h
index b42f96feddae628d7be05401f0321390e74b87d8..560897719d8caef570a8ec01c755c769bce11bb7 100644
--- a/lib/libc/include/generic-glibc/ar.h
+++ b/lib/libc/include/generic-glibc/ar.h
@@ -1,5 +1,5 @@
 /* Header describing `ar' archive file format.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/argp.h b/lib/libc/include/generic-glibc/argp.h
index cd619e4b197d3c3815000cf3af4e266b2f4b2049..4e510b88e785cb01e9e43adbf524fcd22b4c54dc 100644
--- a/lib/libc/include/generic-glibc/argp.h
+++ b/lib/libc/include/generic-glibc/argp.h
@@ -1,5 +1,5 @@
 /* Hierarchical argument parsing, layered over getopt.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Written by Miles Bader <miles@gnu.ai.mit.edu>.
 
@@ -518,17 +518,13 @@ extern void *__argp_input (const struct argp *__restrict __argp,
 #  define __option_is_end _option_is_end
 # endif
 
-# ifndef ARGP_EI
-#  define ARGP_EI __extern_inline
-# endif
-
-ARGP_EI void
+__extern_inline void
 __argp_usage (const struct argp_state *__state)
 {
   __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE);
 }
 
-ARGP_EI int
+__extern_inline int
 __NTH (__option_is_short (const struct argp_option *__opt))
 {
   if (__opt->flags & OPTION_DOC)
@@ -540,7 +536,7 @@ __NTH (__option_is_short (const struct argp_option *__opt))
     }
 }
 
-ARGP_EI int
+__extern_inline int
 __NTH (__option_is_end (const struct argp_option *__opt))
 {
   return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
diff --git a/lib/libc/include/generic-glibc/argz.h b/lib/libc/include/generic-glibc/argz.h
index dd13743521e27ab76519c10ceb69f89ad1f123ce..6272cbcb569f8ab83fd3c97de44a6f76a8f783d0 100644
--- a/lib/libc/include/generic-glibc/argz.h
+++ b/lib/libc/include/generic-glibc/argz.h
@@ -1,5 +1,5 @@
 /* Routines for dealing with '\0' separated arg vectors.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/arpa/inet.h b/lib/libc/include/generic-glibc/arpa/inet.h
index 07113deb0f0c5a2e80f1f7316332ef1ffa133519..f1b39ad7f8d65438dbefc9488bcd37765f60976a 100644
--- a/lib/libc/include/generic-glibc/arpa/inet.h
+++ b/lib/libc/include/generic-glibc/arpa/inet.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/assert.h b/lib/libc/include/generic-glibc/assert.h
index df877364641b656e76e62c6f62371f8edcdf961c..73562fec4b9cf794aeb03cc1f3e4c5988eeb42cf 100644
--- a/lib/libc/include/generic-glibc/assert.h
+++ b/lib/libc/include/generic-glibc/assert.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -34,12 +34,36 @@
 #define	_ASSERT_H	1
 #include <features.h>
 
+#if __GLIBC_USE (ISOC23)
+# ifndef __STDC_VERSION_ASSERT_H__
+#  define __STDC_VERSION_ASSERT_H__ 202311L
+# endif
+#endif
+
 #if defined __cplusplus && __GNUC_PREREQ (2,95)
 # define __ASSERT_VOID_CAST static_cast<void>
 #else
 # define __ASSERT_VOID_CAST (void)
 #endif
 
+/* C23 makes assert a variadic macro so that expressions with a comma
+   not between parentheses, but that would still be valid as a single
+   function argument, such as those involving compound literals with a
+   comma in the initializer list, can be passed to assert.  This
+   depends on support for variadic macros (added in C99 and GCC 2.95),
+   and on support for _Bool (added in C99 and GCC 3.0) in order to
+   validate that only a single expression is passed as an argument,
+   and is currently implemented only for C.  */
+#if (__GLIBC_USE (ISOC23)						\
+     && (defined __GNUC__						\
+	 ? __GNUC_PREREQ (3, 0)						\
+	 : defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)	\
+     && !defined __cplusplus)
+# define __ASSERT_VARIADIC 1
+#else
+# define __ASSERT_VARIADIC 0
+#endif
+
 /* void assert (int expression);
 
    If NDEBUG is defined, do nothing.
@@ -47,7 +71,11 @@
 
 #ifdef	NDEBUG
 
-# define assert(expr)		(__ASSERT_VOID_CAST (0))
+# if __ASSERT_VARIADIC
+#  define assert(...)		(__ASSERT_VOID_CAST (0))
+# else
+#  define assert(expr)		(__ASSERT_VOID_CAST (0))
+# endif
 
 /* void assert_perror (int errnum);
 
@@ -80,6 +108,13 @@ extern void __assert (const char *__assertion, const char *__file, int __line)
      __THROW __attribute__ ((__noreturn__)) __COLD;
 
 
+# if __ASSERT_VARIADIC
+/* This function is not defined and is not called outside of an
+   unevaluated sizeof, but serves to verify that the argument to
+   assert is a single expression.  */
+extern _Bool __assert_single_arg (_Bool);
+# endif
+
 __END_DECLS
 
 /* When possible, define assert so that it does not add extra
@@ -102,23 +137,40 @@ __END_DECLS
       : __assert_fail (#expr, __ASSERT_FILE, __ASSERT_LINE,             \
                        __ASSERT_FUNCTION))
 # elif !defined __GNUC__ || defined __STRICT_ANSI__
-#  define assert(expr)							\
+#  if __ASSERT_VARIADIC
+#   define assert(...)							\
+    (((void) sizeof (__assert_single_arg (__VA_ARGS__)), __VA_ARGS__)	\
+     ? __ASSERT_VOID_CAST (0)						\
+     : __assert_fail (#__VA_ARGS__, __FILE__, __LINE__, __ASSERT_FUNCTION))
+#  else
+#   define assert(expr)							\
     ((expr)								\
      ? __ASSERT_VOID_CAST (0)						\
      : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+#  endif
 # else
+#  if __ASSERT_VARIADIC
+#   define assert(...)							\
+    ((void) sizeof (__assert_single_arg (__VA_ARGS__)), __extension__ ({ \
+      if (__VA_ARGS__)							\
+        ; /* empty */							\
+      else								\
+        __assert_fail (#__VA_ARGS__, __FILE__, __LINE__, __ASSERT_FUNCTION); \
+    }))
+#  else
 /* The first occurrence of EXPR is not evaluated due to the sizeof,
    but will trigger any pedantic warnings masked by the __extension__
    for the second occurrence.  The ternary operator is required to
    support function pointers and bit fields in this context, and to
    suppress the evaluation of variable length arrays.  */
-#  define assert(expr)							\
+#   define assert(expr)							\
   ((void) sizeof ((expr) ? 1 : 0), __extension__ ({			\
       if (expr)								\
         ; /* empty */							\
       else								\
         __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION);	\
     }))
+#  endif
 # endif
 
 # ifdef	__USE_GNU
diff --git a/lib/libc/include/generic-glibc/bits/argp-ldbl.h b/lib/libc/include/generic-glibc/bits/argp-ldbl.h
index 4ebf41e04a92719cdfe6a2a3c6a6deb8e93e8abe..9ea9c2ad05ee4108fcff137232ede04478b52a1d 100644
--- a/lib/libc/include/generic-glibc/bits/argp-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/argp-ldbl.h
@@ -1,5 +1,5 @@
 /* Redirections for argp functions for -mlong-double-64.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/atomic_wide_counter.h b/lib/libc/include/generic-glibc/bits/atomic_wide_counter.h
index 57e96b70647d7e0565b1358539a3eea7399c887c..d864d71bcba1e3529c40c43c5da2b767b0f13419 100644
--- a/lib/libc/include/generic-glibc/bits/atomic_wide_counter.h
+++ b/lib/libc/include/generic-glibc/bits/atomic_wide_counter.h
@@ -1,5 +1,5 @@
 /* Monotonically increasing wide counters (at least 62 bits).
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/byteswap.h b/lib/libc/include/generic-glibc/bits/byteswap.h
index fd956dbd5577c4aca0c004255fe3d5d5811372ce..b9cdbbc59ae091dd76e3f4fcd09ded2e62445e2d 100644
--- a/lib/libc/include/generic-glibc/bits/byteswap.h
+++ b/lib/libc/include/generic-glibc/bits/byteswap.h
@@ -1,5 +1,5 @@
 /* Macros and inline functions to swap the order of bytes in integer values.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/cmathcalls.h b/lib/libc/include/generic-glibc/bits/cmathcalls.h
index 8babe1b32d66d3dc03368929f013b187cb4ee436..66ebc6e4783c7808136f76115bfcd9623d4459ae 100644
--- a/lib/libc/include/generic-glibc/bits/cmathcalls.h
+++ b/lib/libc/include/generic-glibc/bits/cmathcalls.h
@@ -1,6 +1,6 @@
 /* Prototype declarations for complex math functions;
    helper file for <complex.h>.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/confname.h b/lib/libc/include/generic-glibc/bits/confname.h
index c10efca2fa6907162bf1a1738a80387fb86b216b..8de1e82927cb895d91ab3ae45e2dddbafb812061 100644
--- a/lib/libc/include/generic-glibc/bits/confname.h
+++ b/lib/libc/include/generic-glibc/bits/confname.h
@@ -1,5 +1,5 @@
 /* `sysconf', `pathconf', and `confstr' NAME values.  Generic version.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/cpu-set.h b/lib/libc/include/generic-glibc/bits/cpu-set.h
index b7db570584da24bd50f34a254e31c481b490b7ec..4ba1bb97c8ddf65a05d3c4891fa0db9215bd87fc 100644
--- a/lib/libc/include/generic-glibc/bits/cpu-set.h
+++ b/lib/libc/include/generic-glibc/bits/cpu-set.h
@@ -1,6 +1,6 @@
 /* Definition of the cpu_set_t structure used by the POSIX 1003.1b-1993
    scheduling interface.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/dirent.h b/lib/libc/include/generic-glibc/bits/dirent.h
index 149dce4277a3499bbc42eb5113559363ccd85e19..493665660d6fc3958a2016e3abb632ac092e71cf 100644
--- a/lib/libc/include/generic-glibc/bits/dirent.h
+++ b/lib/libc/include/generic-glibc/bits/dirent.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/dirent_ext.h b/lib/libc/include/generic-glibc/bits/dirent_ext.h
index 34b947227537006385f0793b42739d716ecbd4be..481e0b20e5c6f300fb17e11a09d7be5125ad940c 100644
--- a/lib/libc/include/generic-glibc/bits/dirent_ext.h
+++ b/lib/libc/include/generic-glibc/bits/dirent_ext.h
@@ -1,5 +1,5 @@
 /* System-specific extensions of <dirent.h>.  Linux version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/dl_find_object.h b/lib/libc/include/generic-glibc/bits/dl_find_object.h
index 8bade10008388f57704d0dc3cebfee012739fafe..d9d90e4cba88e4a227e7c5c7f0761edbe09c0a0d 100644
--- a/lib/libc/include/generic-glibc/bits/dl_find_object.h
+++ b/lib/libc/include/generic-glibc/bits/dl_find_object.h
@@ -1,5 +1,5 @@
 /* System dependent definitions for finding objects by address.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/dlfcn.h b/lib/libc/include/generic-glibc/bits/dlfcn.h
index c45163e6aef8bc451c53552d32b7eea7f25b29c6..a2814450ca9b22c49c0d1c7f227b1f718998e65e 100644
--- a/lib/libc/include/generic-glibc/bits/dlfcn.h
+++ b/lib/libc/include/generic-glibc/bits/dlfcn.h
@@ -1,5 +1,5 @@
 /* System dependent definitions for run-time dynamic loading.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/endian.h b/lib/libc/include/generic-glibc/bits/endian.h
index 871f16a18b07be1d1c44657e48f2bed72bcf3acd..3d88d675e4bc86986aaf5d24bf873c5add5c2d00 100644
--- a/lib/libc/include/generic-glibc/bits/endian.h
+++ b/lib/libc/include/generic-glibc/bits/endian.h
@@ -1,5 +1,5 @@
 /* Endian macros for string.h functions
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/environments.h b/lib/libc/include/generic-glibc/bits/environments.h
index bbc4956f1f93df0c470d7417fc0eaecd36c828ef..c6ecdefcf24cbb5109d0c8e56adff7e8504a759c 100644
--- a/lib/libc/include/generic-glibc/bits/environments.h
+++ b/lib/libc/include/generic-glibc/bits/environments.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/epoll.h b/lib/libc/include/generic-glibc/bits/epoll.h
index ced9da193c3fd342c07b3ecea14349a8178b4401..3a794bfbe77c2971736fd09752eadc4396534cdf 100644
--- a/lib/libc/include/generic-glibc/bits/epoll.h
+++ b/lib/libc/include/generic-glibc/bits/epoll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/err-ldbl.h b/lib/libc/include/generic-glibc/bits/err-ldbl.h
index 6e9f330d7d3ac1bbaf831e2a7c359c45f7fdd362..29ad81c3401ec4435859d4d7b4ed5675d9dd731a 100644
--- a/lib/libc/include/generic-glibc/bits/err-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/err-ldbl.h
@@ -1,5 +1,5 @@
 /* Redirections for err.h functions for -mlong-double-64.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/errno.h b/lib/libc/include/generic-glibc/bits/errno.h
index 492ed3b4ffd596d700129f393c3ffa67df73b644..5eecdee6defae228ae31054adb4294e70cc974bf 100644
--- a/lib/libc/include/generic-glibc/bits/errno.h
+++ b/lib/libc/include/generic-glibc/bits/errno.h
@@ -1,5 +1,5 @@
 /* Error constants.  Linux specific version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/error-ldbl.h b/lib/libc/include/generic-glibc/bits/error-ldbl.h
index bd1e5ed6575cdcff147a4543711b6c9956871424..260721848b61283c46f8f8811e72eb191104685e 100644
--- a/lib/libc/include/generic-glibc/bits/error-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/error-ldbl.h
@@ -1,5 +1,5 @@
 /* Redirections for error.h functions for -mlong-double-64.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/error.h b/lib/libc/include/generic-glibc/bits/error.h
index 0713e10a7f01105c47a535623795c2615c42d2fe..4841dc3364a8c6d8d48f8c8ecb1255aa50615ae9 100644
--- a/lib/libc/include/generic-glibc/bits/error.h
+++ b/lib/libc/include/generic-glibc/bits/error.h
@@ -1,5 +1,5 @@
 /* Specializations for error functions.
-   Copyright (C) 2007-2025 Free Software Foundation, Inc.
+   Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/eventfd.h b/lib/libc/include/generic-glibc/bits/eventfd.h
index c5d2dbfa31e9a03f327b0c29bcf2d0a7d7a84f14..c0a1d7e3b649b44fb454c5396469ed5774e9ff3f 100644
--- a/lib/libc/include/generic-glibc/bits/eventfd.h
+++ b/lib/libc/include/generic-glibc/bits/eventfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/fcntl-linux-fortify.h b/lib/libc/include/generic-glibc/bits/fcntl-linux-fortify.h
new file mode 100644
index 0000000000000000000000000000000000000000..86c095b67342902bf33ca8af1e827085630d8720
--- /dev/null
+++ b/lib/libc/include/generic-glibc/bits/fcntl-linux-fortify.h
@@ -0,0 +1,49 @@
+/* Checking macros for fcntl functions.  Linux version.
+   Copyright (C) 2025-2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef	_FCNTL_H
+# error "Never include <bits/fcntl-linux-fortify.h> directly; use <fcntl.h> instead."
+#endif
+
+#ifdef __USE_GNU
+
+extern int __REDIRECT (__openat2_alias, (int __dfd, const char *__filename,
+					 const struct open_how *__how,
+					 size_t __usize), openat2)
+     __nonnull ((2, 3));
+
+#if !__fortify_use_clang
+__errordecl (__openat2_invalid_size,
+	     "the specified size is larger than sizeof (struct open_how)");
+#endif
+
+__fortify_function int
+openat2 (int __dfd, const char *__filename, const struct open_how *__how,
+	 size_t __usize)
+     __fortify_clang_warning (__builtin_constant_p (__usize)
+			      && __usize > sizeof (struct open_how),
+			      "the specified size is larger than sizeof (struct open_how)")
+{
+#if !__fortify_use_clang
+  if (__builtin_constant_p (__usize) && __usize > sizeof (struct open_how))
+    __openat2_invalid_size ();
+#endif
+  return __openat2_alias (__dfd, __filename, __how, __usize);
+}
+
+#endif /* use GNU */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/bits/fcntl-linux.h b/lib/libc/include/generic-glibc/bits/fcntl-linux.h
index 56169a7ba49047e7442aadc3593b6592c04c028b..b6a2979287a93d686f1ca0b44b9faf511eea6b9f 100644
--- a/lib/libc/include/generic-glibc/bits/fcntl-linux.h
+++ b/lib/libc/include/generic-glibc/bits/fcntl-linux.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -219,6 +219,9 @@
 
 /* For F_[GET|SET]FD.  */
 #define FD_CLOEXEC	1	/* Actually anything with low bit set goes */
+#ifdef __USE_GNU
+# define FD_PIDFS_ROOT	-10002	/* Root of the pidfs filesystem */
+#endif
 
 #ifndef F_RDLCK
 /* For posix fcntl() and `l_type' field of a `struct flock' for lockf().  */
@@ -381,6 +384,11 @@ struct file_handle
 						open_by_handle_at.  */
 # define AT_HANDLE_MNT_ID_UNIQUE 1 /* Return the 64-bit unique mount
 				      ID.  */
+# define AT_HANDLE_CONNECTABLE 2 /* Request a connectable file handle */
+
+/* Flags for execveat2(2). */
+# define AT_EXECVE_CHECK 0x10000 /* Only perform a check if execution
+				    would be allowed */
 #endif
 
 __BEGIN_DECLS
@@ -455,6 +463,33 @@ extern int name_to_handle_at (int __dfd, const char *__name,
 extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
 			      int __flags);
 
+#ifdef __has_include
+# if __has_include ("linux/openat2.h")
+#  include "linux/openat2.h"
+#  define __glibc_has_open_how 1
+# endif
+#endif
+
+#include <bits/openat2.h>
+
+/* Similar to `openat' but the arguments are packed on HOW with the size
+   USIZE.  If flags and mode from HOW are non-zero, then openat2 operates
+   like openat.
+
+   Unlike openat, unknown or invalid flags result in an error (EINVAL),
+   rather than being ignored.  The mode must be zero unless one of O_CREAT
+   or O_TMPFILE are set.
+
+   The kernel does not support legacy non-LFS interface.  */
+extern int openat2 (int __dfd, const char * __filename,
+		    const struct open_how * __how,
+		    __SIZE_TYPE__ __usize)
+     __nonnull ((2, 3));
+
 #endif	/* use GNU */
 
+#if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
+# include <bits/fcntl-linux-fortify.h>
+#endif
+
 __END_DECLS
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/bits/fcntl.h b/lib/libc/include/generic-glibc/bits/fcntl.h
index 3f9b254f7dd64e2e4dd41b17c1290d65cbe452d3..588d80193fa2413ec195f56afc2d2092a8b9d866 100644
--- a/lib/libc/include/generic-glibc/bits/fcntl.h
+++ b/lib/libc/include/generic-glibc/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/fcntl2.h b/lib/libc/include/generic-glibc/bits/fcntl2.h
index f09c4a9cc8c11c13b79331fe6c5bea305f3128d5..9878bd99460020aad4ae0c84caf9d831a4a4b2c5 100644
--- a/lib/libc/include/generic-glibc/bits/fcntl2.h
+++ b/lib/libc/include/generic-glibc/bits/fcntl2.h
@@ -1,5 +1,5 @@
 /* Checking macros for fcntl functions.
-   Copyright (C) 2007-2025 Free Software Foundation, Inc.
+   Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/fenv.h b/lib/libc/include/generic-glibc/bits/fenv.h
index 5dab6355dd28921adb95267412d459b3dae02b73..675ec3dc8ca191d58f71c1330507d06dea76c489 100644
--- a/lib/libc/include/generic-glibc/bits/fenv.h
+++ b/lib/libc/include/generic-glibc/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/floatn-common.h b/lib/libc/include/generic-glibc/bits/floatn-common.h
index 6a70ca5d5d5901cb40a3a77de8e6b119d2ead926..e0bcddc9144541da970d5b2b941797c13421a429 100644
--- a/lib/libc/include/generic-glibc/bits/floatn-common.h
+++ b/lib/libc/include/generic-glibc/bits/floatn-common.h
@@ -1,6 +1,6 @@
 /* Macros to control TS 18661-3 glibc features where the same
    definitions are appropriate for all platforms.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/floatn.h b/lib/libc/include/generic-glibc/bits/floatn.h
index 45bed17fddc9035939658e311013dcc6f45a7c41..23dd2abf0a21e6a4733a68c40710086a25b18704 100644
--- a/lib/libc/include/generic-glibc/bits/floatn.h
+++ b/lib/libc/include/generic-glibc/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features on ldbl-128 platforms.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/flt-eval-method.h b/lib/libc/include/generic-glibc/bits/flt-eval-method.h
index 5556c5dae791332638d428a89462c5d6d551d851..a64af2fe400120f246cb41648b0f69280f989263 100644
--- a/lib/libc/include/generic-glibc/bits/flt-eval-method.h
+++ b/lib/libc/include/generic-glibc/bits/flt-eval-method.h
@@ -1,5 +1,5 @@
 /* Define __GLIBC_FLT_EVAL_METHOD.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/fp-fast.h b/lib/libc/include/generic-glibc/bits/fp-fast.h
index f6ba20a204c2205c08613fc3d59f00650e79d358..ae2d8206e49a30a9d187c50d4451183e11f4a4dc 100644
--- a/lib/libc/include/generic-glibc/bits/fp-fast.h
+++ b/lib/libc/include/generic-glibc/bits/fp-fast.h
@@ -1,5 +1,5 @@
 /* Define FP_FAST_* macros.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/fp-logb.h b/lib/libc/include/generic-glibc/bits/fp-logb.h
index 3a4c9b0c343eed2884fa809a65dac6dd2761e726..ae61591f33439d3bf52f26bbd332421c7132d1ca 100644
--- a/lib/libc/include/generic-glibc/bits/fp-logb.h
+++ b/lib/libc/include/generic-glibc/bits/fp-logb.h
@@ -1,5 +1,5 @@
 /* Define __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/getopt_core.h b/lib/libc/include/generic-glibc/bits/getopt_core.h
index 817e7785b5d164d50df092ce02303a4356da371f..dfd4920a57c5cdb174b2ba9cdc5036f77e3a0ece 100644
--- a/lib/libc/include/generic-glibc/bits/getopt_core.h
+++ b/lib/libc/include/generic-glibc/bits/getopt_core.h
@@ -1,5 +1,5 @@
 /* Declarations for getopt (basic, portable features only).
-   Copyright (C) 1989-2025 Free Software Foundation, Inc.
+   Copyright (C) 1989-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library and is also part of gnulib.
    Patches to this file should be submitted to both projects.
 
diff --git a/lib/libc/include/generic-glibc/bits/getopt_ext.h b/lib/libc/include/generic-glibc/bits/getopt_ext.h
index ecbfee5409ed3e404187ffd100e9d0b7c3c660a6..3d6aef5b43af68c7a194eeaf601e455844ddbd19 100644
--- a/lib/libc/include/generic-glibc/bits/getopt_ext.h
+++ b/lib/libc/include/generic-glibc/bits/getopt_ext.h
@@ -1,5 +1,5 @@
 /* Declarations for getopt (GNU extensions).
-   Copyright (C) 1989-2025 Free Software Foundation, Inc.
+   Copyright (C) 1989-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library and is also part of gnulib.
    Patches to this file should be submitted to both projects.
 
diff --git a/lib/libc/include/generic-glibc/bits/getopt_posix.h b/lib/libc/include/generic-glibc/bits/getopt_posix.h
index 7f8096a43c8c3714f589a3811b511fba2cf5514e..6374a0778dc0053a3d674c391aaa3a15e59461ad 100644
--- a/lib/libc/include/generic-glibc/bits/getopt_posix.h
+++ b/lib/libc/include/generic-glibc/bits/getopt_posix.h
@@ -1,5 +1,5 @@
 /* Declarations for getopt (POSIX compatibility shim).
-   Copyright (C) 1989-2025 Free Software Foundation, Inc.
+   Copyright (C) 1989-2026 Free Software Foundation, Inc.
    Unlike the bulk of the getopt implementation, this file is NOT part
    of gnulib.
 
diff --git a/lib/libc/include/generic-glibc/bits/hwcap.h b/lib/libc/include/generic-glibc/bits/hwcap.h
index c978f78936db4314dc0713740c886f81346dbf5c..38f3c42f256dac36df783ac67c4dda597c5e02a3 100644
--- a/lib/libc/include/generic-glibc/bits/hwcap.h
+++ b/lib/libc/include/generic-glibc/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/in.h b/lib/libc/include/generic-glibc/bits/in.h
index 0e940cc5a6ab8c057d1eed352add751451bc7460..e235d430153051b6de2eee70916fbbf65dcbdbf4 100644
--- a/lib/libc/include/generic-glibc/bits/in.h
+++ b/lib/libc/include/generic-glibc/bits/in.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/indirect-return.h b/lib/libc/include/generic-glibc/bits/indirect-return.h
index 7ba1bd20385abe7bcc0634d561034930515ce731..0fc202e8addd671dd350b6f12754e65f08a0f9d8 100644
--- a/lib/libc/include/generic-glibc/bits/indirect-return.h
+++ b/lib/libc/include/generic-glibc/bits/indirect-return.h
@@ -1,5 +1,5 @@
 /* Definition of __INDIRECT_RETURN.  Generic version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/inet-fortified-decl.h b/lib/libc/include/generic-glibc/bits/inet-fortified-decl.h
index a77a0477cda6cc1ee8f12046c3ae501db9eccf2c..018e00209f04eff376922d819c362e52503ef43e 100644
--- a/lib/libc/include/generic-glibc/bits/inet-fortified-decl.h
+++ b/lib/libc/include/generic-glibc/bits/inet-fortified-decl.h
@@ -1,5 +1,5 @@
 /* Declarations of checking macros for inet functions.
-   Copyright (C) 2025 Free Software Foundation, Inc.
+   Copyright (C) 2025-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/inet-fortified.h b/lib/libc/include/generic-glibc/bits/inet-fortified.h
index 88aafbe8b20b48dde9190733f0a80561259f4f66..fe404d4d06d496e9372a2121fb8a996bc9b09b41 100644
--- a/lib/libc/include/generic-glibc/bits/inet-fortified.h
+++ b/lib/libc/include/generic-glibc/bits/inet-fortified.h
@@ -1,5 +1,5 @@
 /* Checking macros for inet functions.
-   Copyright (C) 2025 Free Software Foundation, Inc.
+   Copyright (C) 2025-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -45,15 +45,17 @@ __NTH (inet_pton (int __af,
     __fortify_clang_warning_only_if_bos0_lt
 	(4, __dst, "inet_pton called with destination buffer size less than 4")
 {
-  size_t sz = 0;
+#if !__fortify_use_clang
+  size_t __sz = 0;
   if (__af == AF_INET)
-    sz = sizeof (struct in_addr);
+    __sz = sizeof (struct in_addr);
   else if (__af == AF_INET6)
-    sz = sizeof (struct in6_addr);
+    __sz = sizeof (struct in6_addr);
   else
     return __inet_pton_alias (__af, __src, __dst);
+#endif
 
-  return __glibc_fortify (inet_pton, sz, sizeof (char),
+  return __glibc_fortify (inet_pton, __sz, sizeof (char),
 			  __glibc_objsize (__dst),
 			  __af, __src, __dst);
 };
diff --git a/lib/libc/include/generic-glibc/bits/inotify.h b/lib/libc/include/generic-glibc/bits/inotify.h
index 4bc5510f71e3b6d04d09be53db1060e9889d048a..f646147563dc91be65b1598125c305af863fb283 100644
--- a/lib/libc/include/generic-glibc/bits/inotify.h
+++ b/lib/libc/include/generic-glibc/bits/inotify.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ioctl-types.h b/lib/libc/include/generic-glibc/bits/ioctl-types.h
index 13c5bc0d455f20c1beedf540540d869e075f9c7f..28bbfa7c2c804ddb5baeb4f5222da013941d5304 100644
--- a/lib/libc/include/generic-glibc/bits/ioctl-types.h
+++ b/lib/libc/include/generic-glibc/bits/ioctl-types.h
@@ -1,5 +1,5 @@
 /* Structure types for pre-termios terminal ioctls.  Linux version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ioctls.h b/lib/libc/include/generic-glibc/bits/ioctls.h
index 84594dd239475382b220094e13d871dd45b58682..7dfc0dc801e52e6fcc21a194869c59995919f6da 100644
--- a/lib/libc/include/generic-glibc/bits/ioctls.h
+++ b/lib/libc/include/generic-glibc/bits/ioctls.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ipc-perm.h b/lib/libc/include/generic-glibc/bits/ipc-perm.h
index e5c8cfb66aaca6b277b8e8d699b9b035cc7ad416..2dc2424579751c5694d9485a4b848c87e2bb0f97 100644
--- a/lib/libc/include/generic-glibc/bits/ipc-perm.h
+++ b/lib/libc/include/generic-glibc/bits/ipc-perm.h
@@ -1,5 +1,5 @@
 /* struct ipc_perm definition.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ipc.h b/lib/libc/include/generic-glibc/bits/ipc.h
index ee51271f893ecf9b48b0a68e8bdf2d958fa75a94..c44dc1155d19cd7aa964d14183efad9ec01396b4 100644
--- a/lib/libc/include/generic-glibc/bits/ipc.h
+++ b/lib/libc/include/generic-glibc/bits/ipc.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ipctypes.h b/lib/libc/include/generic-glibc/bits/ipctypes.h
index a747e9c6b745bc22a1aaf912e5b65bb3579f1183..92e5bca75dbe445c45aaca8bbf42971cd5b70ce7 100644
--- a/lib/libc/include/generic-glibc/bits/ipctypes.h
+++ b/lib/libc/include/generic-glibc/bits/ipctypes.h
@@ -1,5 +1,5 @@
 /* bits/ipctypes.h -- Define some types used by SysV IPC/MSG/SHM.  Generic.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/iscanonical.h b/lib/libc/include/generic-glibc/bits/iscanonical.h
index 35d241066f0960dd2dbb5e1790246403db210895..c5295802a2204c042b9f3d0ceeea8abbc5932c9e 100644
--- a/lib/libc/include/generic-glibc/bits/iscanonical.h
+++ b/lib/libc/include/generic-glibc/bits/iscanonical.h
@@ -1,5 +1,5 @@
 /* Define iscanonical macro.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/libc-header-start.h b/lib/libc/include/generic-glibc/bits/libc-header-start.h
index 874d697a9829fd078c353c39bd897d26fae056fb..4a5cd012a0838d8ce20a1256bf1bf28bd68e36cd 100644
--- a/lib/libc/include/generic-glibc/bits/libc-header-start.h
+++ b/lib/libc/include/generic-glibc/bits/libc-header-start.h
@@ -1,5 +1,5 @@
 /* Handle feature test macros at the start of a header.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/libm-simd-decl-stubs.h b/lib/libc/include/generic-glibc/bits/libm-simd-decl-stubs.h
index 15df4ea88fd10afc9e4a47cbce89951aa76477b1..d3b43f59cc01e21655c009ec365eb49b30d15e03 100644
--- a/lib/libc/include/generic-glibc/bits/libm-simd-decl-stubs.h
+++ b/lib/libc/include/generic-glibc/bits/libm-simd-decl-stubs.h
@@ -1,5 +1,5 @@
 /* Empty definitions required for __MATHCALL_VEC unfolding in mathcalls.h.
-   Copyright (C) 2014-2025 Free Software Foundation, Inc.
+   Copyright (C) 2014-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -187,6 +187,28 @@
 #define __DECL_SIMD_expm1f64x
 #define __DECL_SIMD_expm1f128x
 
+#define __DECL_SIMD_exp2m1
+#define __DECL_SIMD_exp2m1f
+#define __DECL_SIMD_exp2m1l
+#define __DECL_SIMD_exp2m1f16
+#define __DECL_SIMD_exp2m1f32
+#define __DECL_SIMD_exp2m1f64
+#define __DECL_SIMD_exp2m1f128
+#define __DECL_SIMD_exp2m1f32x
+#define __DECL_SIMD_exp2m1f64x
+#define __DECL_SIMD_exp2m1f128x
+
+#define __DECL_SIMD_exp10m1
+#define __DECL_SIMD_exp10m1f
+#define __DECL_SIMD_exp10m1l
+#define __DECL_SIMD_exp10m1f16
+#define __DECL_SIMD_exp10m1f32
+#define __DECL_SIMD_exp10m1f64
+#define __DECL_SIMD_exp10m1f128
+#define __DECL_SIMD_exp10m1f32x
+#define __DECL_SIMD_exp10m1f64x
+#define __DECL_SIMD_exp10m1f128x
+
 #define __DECL_SIMD_sinh
 #define __DECL_SIMD_sinhf
 #define __DECL_SIMD_sinhl
@@ -220,6 +242,17 @@
 #define __DECL_SIMD_atan2f64x
 #define __DECL_SIMD_atan2f128x
 
+#define __DECL_SIMD_rsqrt
+#define __DECL_SIMD_rsqrtf
+#define __DECL_SIMD_rsqrtl
+#define __DECL_SIMD_rsqrtf16
+#define __DECL_SIMD_rsqrtf32
+#define __DECL_SIMD_rsqrtf64
+#define __DECL_SIMD_rsqrtf128
+#define __DECL_SIMD_rsqrtf32x
+#define __DECL_SIMD_rsqrtf64x
+#define __DECL_SIMD_rsqrtf128x
+
 #define __DECL_SIMD_log10
 #define __DECL_SIMD_log10f
 #define __DECL_SIMD_log10l
@@ -231,6 +264,17 @@
 #define __DECL_SIMD_log10f64x
 #define __DECL_SIMD_log10f128x
 
+#define __DECL_SIMD_log10p1
+#define __DECL_SIMD_log10p1f
+#define __DECL_SIMD_log10p1l
+#define __DECL_SIMD_log10p1f16
+#define __DECL_SIMD_log10p1f32
+#define __DECL_SIMD_log10p1f64
+#define __DECL_SIMD_log10p1f128
+#define __DECL_SIMD_log10p1f32x
+#define __DECL_SIMD_log10p1f64x
+#define __DECL_SIMD_log10p1f128x
+
 #define __DECL_SIMD_log2
 #define __DECL_SIMD_log2f
 #define __DECL_SIMD_log2l
@@ -242,6 +286,17 @@
 #define __DECL_SIMD_log2f64x
 #define __DECL_SIMD_log2f128x
 
+#define __DECL_SIMD_log2p1
+#define __DECL_SIMD_log2p1f
+#define __DECL_SIMD_log2p1l
+#define __DECL_SIMD_log2p1f16
+#define __DECL_SIMD_log2p1f32
+#define __DECL_SIMD_log2p1f64
+#define __DECL_SIMD_log2p1f128
+#define __DECL_SIMD_log2p1f32x
+#define __DECL_SIMD_log2p1f64x
+#define __DECL_SIMD_log2p1f128x
+
 #define __DECL_SIMD_log1p
 #define __DECL_SIMD_log1pf
 #define __DECL_SIMD_log1pl
diff --git a/lib/libc/include/generic-glibc/bits/link.h b/lib/libc/include/generic-glibc/bits/link.h
index dd48323d4225237bbf5c887f774ef77b023fc749..b3eb6c20bfcae88b2a486ffaf9306a550ef6d81d 100644
--- a/lib/libc/include/generic-glibc/bits/link.h
+++ b/lib/libc/include/generic-glibc/bits/link.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/link_lavcurrent.h b/lib/libc/include/generic-glibc/bits/link_lavcurrent.h
index dab34fb38da0e394ca9fb9697698400116e33976..ee89bde862b73e1edcc462683fa6b17b986c50f6 100644
--- a/lib/libc/include/generic-glibc/bits/link_lavcurrent.h
+++ b/lib/libc/include/generic-glibc/bits/link_lavcurrent.h
@@ -1,6 +1,6 @@
 /* Data structure for communication from the run-time dynamic linker for
    loaded ELF shared objects.  LAV_CURRENT definition.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/local_lim.h b/lib/libc/include/generic-glibc/bits/local_lim.h
index 307c15f46a2bbafe97d33f38a885de15e5d3a876..ac5116dd31858783f8740e6b7a04ad83e373fd5d 100644
--- a/lib/libc/include/generic-glibc/bits/local_lim.h
+++ b/lib/libc/include/generic-glibc/bits/local_lim.h
@@ -1,5 +1,5 @@
 /* Minimum guaranteed maximum values for system limits.  Linux version.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/locale.h b/lib/libc/include/generic-glibc/bits/locale.h
index f327ed10cc48a364f025f7e0617fd6f25594f84c..5f2f5d03c6946c81bda9809ab5cb98a987aa85fd 100644
--- a/lib/libc/include/generic-glibc/bits/locale.h
+++ b/lib/libc/include/generic-glibc/bits/locale.h
@@ -1,5 +1,5 @@
 /* Definition of locale category symbol values.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/long-double.h b/lib/libc/include/generic-glibc/bits/long-double.h
index d745334ed356518141bbc633645156a3c7e78030..ebf6ac878fbf42241d0b2bcaf8c6049d08d827c5 100644
--- a/lib/libc/include/generic-glibc/bits/long-double.h
+++ b/lib/libc/include/generic-glibc/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  MIPS version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/math-vector.h b/lib/libc/include/generic-glibc/bits/math-vector.h
index eb2bb2a25a9e2998a7e1023305f3e75817d20058..02b8a1a937dcf900ef089258abc3155a0676ec66 100644
--- a/lib/libc/include/generic-glibc/bits/math-vector.h
+++ b/lib/libc/include/generic-glibc/bits/math-vector.h
@@ -1,5 +1,5 @@
 /* Platform-specific SIMD declarations of math functions.
-   Copyright (C) 2014-2025 Free Software Foundation, Inc.
+   Copyright (C) 2014-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mathcalls-helper-functions.h b/lib/libc/include/generic-glibc/bits/mathcalls-helper-functions.h
index d43de427bfb37bcfa454e564258b5b952f5dc296..cdfabc8a7375395ee0566a93bdad9e85350126c0 100644
--- a/lib/libc/include/generic-glibc/bits/mathcalls-helper-functions.h
+++ b/lib/libc/include/generic-glibc/bits/mathcalls-helper-functions.h
@@ -1,5 +1,5 @@
 /* Prototype declarations for math classification macros helpers.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mathcalls-macros.h b/lib/libc/include/generic-glibc/bits/mathcalls-macros.h
index d5b71472bb53796288a42f51a99525beefe49a70..3c2c0a600d0bc0f9d8938be45f9e67a371ec0ecd 100644
--- a/lib/libc/include/generic-glibc/bits/mathcalls-macros.h
+++ b/lib/libc/include/generic-glibc/bits/mathcalls-macros.h
@@ -1,5 +1,5 @@
 /* Macros for math function declarations.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mathcalls-narrow.h b/lib/libc/include/generic-glibc/bits/mathcalls-narrow.h
index 9e73c83fe02e237bd0805ddf3ff65553c5ac60c8..fb6ad62951e6550252926631e4347b9d414971d1 100644
--- a/lib/libc/include/generic-glibc/bits/mathcalls-narrow.h
+++ b/lib/libc/include/generic-glibc/bits/mathcalls-narrow.h
@@ -1,5 +1,5 @@
 /* Declare functions returning a narrower type.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mathcalls.h b/lib/libc/include/generic-glibc/bits/mathcalls.h
index 265c1b867503e5f4a763f9c7ae99f3251590667b..7ff83e5acbeebe7f5fd3b1185735822e436aa5dd 100644
--- a/lib/libc/include/generic-glibc/bits/mathcalls.h
+++ b/lib/libc/include/generic-glibc/bits/mathcalls.h
@@ -1,5 +1,5 @@
 /* Prototype declarations for math functions; helper file for <math.h>.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -136,16 +136,16 @@ __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
 __MATHCALL_VEC (exp10,, (_Mdouble_ __x));
 
 /* Return exp2(X) - 1.  */
-__MATHCALL (exp2m1,, (_Mdouble_ __x));
+__MATHCALL_VEC (exp2m1,, (_Mdouble_ __x));
 
 /* Return exp10(X) - 1.  */
-__MATHCALL (exp10m1,, (_Mdouble_ __x));
+__MATHCALL_VEC (exp10m1,, (_Mdouble_ __x));
 
 /* Return log2(1 + X).  */
-__MATHCALL (log2p1,, (_Mdouble_ __x));
+__MATHCALL_VEC (log2p1,, (_Mdouble_ __x));
 
 /* Return log10(1 + X).  */
-__MATHCALL (log10p1,, (_Mdouble_ __x));
+__MATHCALL_VEC (log10p1,, (_Mdouble_ __x));
 
 /* Return log(1 + X).  */
 __MATHCALL_VEC (logp1,, (_Mdouble_ __x));
@@ -203,7 +203,7 @@ __MATHCALL (powr,, (_Mdouble_ __x, _Mdouble_ __y));
 __MATHCALL (rootn,, (_Mdouble_ __x, long long int __y));
 
 /* Return the reciprocal of the square root of X.  */
-__MATHCALL (rsqrt,, (_Mdouble_ __x));
+__MATHCALL_VEC (rsqrt,, (_Mdouble_ __x));
 #endif
 
 
@@ -400,25 +400,21 @@ __MATHCALLX (roundeven,, (_Mdouble_ __x), (__const__));
 
 /* Round X to nearest signed integer value, not raising inexact, with
    control of rounding direction and width of result.  */
-__MATHDECL (__intmax_t, fromfp,, (_Mdouble_ __x, int __round,
-				  unsigned int __width));
+__MATHCALL (fromfp,, (_Mdouble_ __x, int __round, unsigned int __width));
 
 /* Round X to nearest unsigned integer value, not raising inexact,
    with control of rounding direction and width of result.  */
-__MATHDECL (__uintmax_t, ufromfp,, (_Mdouble_ __x, int __round,
-				    unsigned int __width));
+__MATHCALL (ufromfp,, (_Mdouble_ __x, int __round, unsigned int __width));
 
 /* Round X to nearest signed integer value, raising inexact for
    non-integers, with control of rounding direction and width of
    result.  */
-__MATHDECL (__intmax_t, fromfpx,, (_Mdouble_ __x, int __round,
-				   unsigned int __width));
+__MATHCALL (fromfpx,, (_Mdouble_ __x, int __round, unsigned int __width));
 
 /* Round X to nearest unsigned integer value, raising inexact for
    non-integers, with control of rounding direction and width of
    result.  */
-__MATHDECL (__uintmax_t, ufromfpx,, (_Mdouble_ __x, int __round,
-				     unsigned int __width));
+__MATHCALL (ufromfpx,, (_Mdouble_ __x, int __round, unsigned int __width));
 
 /* Canonicalize floating-point representation.  */
 __MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));
diff --git a/lib/libc/include/generic-glibc/bits/mathdef.h b/lib/libc/include/generic-glibc/bits/mathdef.h
index 3dfada4812a19e2cb8ad70389519d830cbdcf371..30700d1f890ae740a9bcc35b06ab549bd98a5347 100644
--- a/lib/libc/include/generic-glibc/bits/mathdef.h
+++ b/lib/libc/include/generic-glibc/bits/mathdef.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mman-linux.h b/lib/libc/include/generic-glibc/bits/mman-linux.h
index 2dbd4d3a06f73383b43724bd45a013a488363277..f1813f9f8eb0a236c2bbf6ab42f7037d6f65cbb6 100644
--- a/lib/libc/include/generic-glibc/bits/mman-linux.h
+++ b/lib/libc/include/generic-glibc/bits/mman-linux.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux generic version.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mman-map-flags-generic.h b/lib/libc/include/generic-glibc/bits/mman-map-flags-generic.h
index 6a1390fcba77e0ef32a4d686e98f44336da2d2f1..1c79e356496cde23b319ec921885909975c3179c 100644
--- a/lib/libc/include/generic-glibc/bits/mman-map-flags-generic.h
+++ b/lib/libc/include/generic-glibc/bits/mman-map-flags-generic.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/generic version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mman-shared.h b/lib/libc/include/generic-glibc/bits/mman-shared.h
index 39e82407cd5a9c722e74b81db37c7c5895187457..6081d111d259bda1708a05d3595991e7e13d113b 100644
--- a/lib/libc/include/generic-glibc/bits/mman-shared.h
+++ b/lib/libc/include/generic-glibc/bits/mman-shared.h
@@ -1,5 +1,5 @@
 /* Memory-mapping-related declarations/definitions, not architecture-specific.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -85,6 +85,16 @@ int pkey_free (int __key) __THROW;
    range.  */
 int pkey_mprotect (void *__addr, size_t __len, int __prot, int __pkey) __THROW;
 
+/* Seal the address range to avoid further modifications, such as remapping to
+   shrink or expand the VMA, changing protection permission with mprotect,
+   unmap with munmap, or destructive semantics such as madvise with
+   MADV_DONTNEED.
+
+   The address range must be a valid VMA, without any gaps (unallocated
+   memory) between the start and end, and ADDR must be page-aligned (LEN will
+   be page-aligned implicitly).  */
+int mseal (void *__addr, size_t __len, unsigned long flags) __THROW;
+
 __END_DECLS
 
-#endif /* __USE_GNU */
+#endif /* __USE_GNU */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/bits/mman.h b/lib/libc/include/generic-glibc/bits/mman.h
index de1d81f6ddacdf5a7294cd3b6494637e130df3dd..d77652012a10439ceb61bf2500dac723e05ed744 100644
--- a/lib/libc/include/generic-glibc/bits/mman.h
+++ b/lib/libc/include/generic-glibc/bits/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/generic version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mman_ext.h b/lib/libc/include/generic-glibc/bits/mman_ext.h
index 20729a008127e4e5d5c02d4da95bd666b18e3693..35570768ac814abf985ddb4eb7708f92cd7302d2 100644
--- a/lib/libc/include/generic-glibc/bits/mman_ext.h
+++ b/lib/libc/include/generic-glibc/bits/mman_ext.h
@@ -1,5 +1,5 @@
 /* System-specific extensions of <sys/mman.h>, Linux version.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/monetary-ldbl.h b/lib/libc/include/generic-glibc/bits/monetary-ldbl.h
index 5ee13e30a5257eaee24fd3d5a737366b6ac8457f..4cd6a82d8197595eb7742acb5dd7952f5681e455 100644
--- a/lib/libc/include/generic-glibc/bits/monetary-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/monetary-ldbl.h
@@ -1,5 +1,5 @@
 /* -mlong-double-64 compatibility mode for monetary functions.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mqueue.h b/lib/libc/include/generic-glibc/bits/mqueue.h
index 8bc2e803ed7ffdd5909838b5c1c9b073841c5edf..7922cee1e484d2935ce5b84c330456f80af51900 100644
--- a/lib/libc/include/generic-glibc/bits/mqueue.h
+++ b/lib/libc/include/generic-glibc/bits/mqueue.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/mqueue2.h b/lib/libc/include/generic-glibc/bits/mqueue2.h
index 5e00de211ddf7d78c7132267e0d05cad758f55ba..49d5e4ccf6cc4a263ba0f47ca5073f6af203c430 100644
--- a/lib/libc/include/generic-glibc/bits/mqueue2.h
+++ b/lib/libc/include/generic-glibc/bits/mqueue2.h
@@ -1,5 +1,5 @@
 /* Checking macros for mq functions.
-   Copyright (C) 2007-2025 Free Software Foundation, Inc.
+   Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/msq.h b/lib/libc/include/generic-glibc/bits/msq.h
index 8df20c3d397e5a7e9149844574170bd4c5bbefcf..a5fa185e6e9be9cf5879c136cdcd00edfe9b9fb6 100644
--- a/lib/libc/include/generic-glibc/bits/msq.h
+++ b/lib/libc/include/generic-glibc/bits/msq.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/netdb.h b/lib/libc/include/generic-glibc/bits/netdb.h
index 17011caa40a9e66a47f01bd804530cd0260ab9e1..e97e5e720a2d0b9e3dc688bc20995f79910d028a 100644
--- a/lib/libc/include/generic-glibc/bits/netdb.h
+++ b/lib/libc/include/generic-glibc/bits/netdb.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/openat2.h b/lib/libc/include/generic-glibc/bits/openat2.h
new file mode 100644
index 0000000000000000000000000000000000000000..4136a174202a79629cb74095628165d973bff01c
--- /dev/null
+++ b/lib/libc/include/generic-glibc/bits/openat2.h
@@ -0,0 +1,60 @@
+/* openat2 definition.  Linux specific.
+   Copyright (C) 2025-2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _FCNTL_H
+# error "Never use <bits/openat2.h> directly; include <fcntl.h> instead."
+#endif
+
+#ifndef __glibc_has_open_how
+/* Arguments for how openat2 should open the target path.  */
+struct open_how
+{
+  __uint64_t flags;
+  __uint64_t mode;
+  __uint64_t resolve;
+};
+#endif
+
+/* how->resolve flags for openat2. */
+#ifndef RESOLVE_NO_XDEV
+# define RESOLVE_NO_XDEV	0x01 /* Block mount-point crossings
+					(includes bind-mounts).  */
+#endif
+#ifndef RESOLVE_NO_MAGICLINKS
+# define RESOLVE_NO_MAGICLINKS	0x02 /* Block traversal through procfs-style
+					"magic-links".  */
+#endif
+#ifndef RESOLVE_NO_SYMLINKS
+# define RESOLVE_NO_SYMLINKS	0x04 /* Block traversal through all symlinks.  */
+#endif
+#ifndef RESOLVE_BENEATH
+# define RESOLVE_BENEATH	0x08 /* Block "lexical" trickery like
+					"..", symlinks, and absolute
+					paths which escape the dirfd.  */
+#endif
+#ifndef RESOLVE_IN_ROOT
+# define RESOLVE_IN_ROOT	0x10 /* Make all jumps to "/" and ".."
+					be scoped inside the dirfd
+					(similar to chroot).  */
+#endif
+#ifndef RESOLVE_CACHED
+# define RESOLVE_CACHED		0x20 /* Only complete if resolution can be
+					completed through cached lookup. May
+					return -EAGAIN if that's not
+					possible.  */
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/bits/param.h b/lib/libc/include/generic-glibc/bits/param.h
index e8c5c9da603f263e4998f2864685e8568743c71d..9a41566e0cb6d0587dda7c976dd14de597db7abd 100644
--- a/lib/libc/include/generic-glibc/bits/param.h
+++ b/lib/libc/include/generic-glibc/bits/param.h
@@ -1,5 +1,5 @@
 /* Old-style Unix parameters and limits.  Linux version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/platform/features.h b/lib/libc/include/generic-glibc/bits/platform/features.h
index 6123494cf60deb90aaec2670b98c6659ac816f21..e26cbc2b45a94d9e028773febba54f0d7bcde339 100644
--- a/lib/libc/include/generic-glibc/bits/platform/features.h
+++ b/lib/libc/include/generic-glibc/bits/platform/features.h
@@ -1,6 +1,6 @@
 /* Inline functions for x86 CPU features.
    This file is part of the GNU C Library.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/generic-glibc/bits/platform/x86.h b/lib/libc/include/generic-glibc/bits/platform/x86.h
index 5b2ad573fe7cee809871fb1f6a3835053a9dac7b..f4a94eec5421181e9ff9c2f732a10723f79df9c7 100644
--- a/lib/libc/include/generic-glibc/bits/platform/x86.h
+++ b/lib/libc/include/generic-glibc/bits/platform/x86.h
@@ -1,6 +1,6 @@
 /* Constants and data structures for x86 CPU features.
    This file is part of the GNU C Library.
-   Copyright (C) 2008-2025 Free Software Foundation, Inc.
+   Copyright (C) 2008-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/generic-glibc/bits/poll.h b/lib/libc/include/generic-glibc/bits/poll.h
index 50cc20cb094c94762f2ad639649514493eae2421..4ba71517ae561932d909f64810bd70876530e281 100644
--- a/lib/libc/include/generic-glibc/bits/poll.h
+++ b/lib/libc/include/generic-glibc/bits/poll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/poll2.h b/lib/libc/include/generic-glibc/bits/poll2.h
index 6e912e6d70ba378d9449b3b7425685c82c4de62f..85cd62dbc6e7037982a63004e686cc5c62d84de8 100644
--- a/lib/libc/include/generic-glibc/bits/poll2.h
+++ b/lib/libc/include/generic-glibc/bits/poll2.h
@@ -1,5 +1,5 @@
 /* Checking macros for poll functions.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/posix1_lim.h b/lib/libc/include/generic-glibc/bits/posix1_lim.h
index 13d18f529713f3dc317ef1a54df4b5d2f0eb019e..63d138f0a467322190f29e66a8ce3af2a1dfdc1b 100644
--- a/lib/libc/include/generic-glibc/bits/posix1_lim.h
+++ b/lib/libc/include/generic-glibc/bits/posix1_lim.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/posix2_lim.h b/lib/libc/include/generic-glibc/bits/posix2_lim.h
index edeab6fc6f52279b8c33547e26e871abd539683d..0a22bd055b257f043ed58c364f2c853f6436a33a 100644
--- a/lib/libc/include/generic-glibc/bits/posix2_lim.h
+++ b/lib/libc/include/generic-glibc/bits/posix2_lim.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/posix_opt.h b/lib/libc/include/generic-glibc/bits/posix_opt.h
index 2bd0c183e8d341d6da876673f006cd614b2109a1..35c13aa7d76830086bac3180d755877fa3e5fb86 100644
--- a/lib/libc/include/generic-glibc/bits/posix_opt.h
+++ b/lib/libc/include/generic-glibc/bits/posix_opt.h
@@ -1,5 +1,5 @@
 /* Define POSIX options for Linux.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -54,7 +54,7 @@
 
 /* `c_cc' member of 'struct termios' structure can be disabled by
    using the value _POSIX_VDISABLE.  */
-#define	_POSIX_VDISABLE	'\0'
+#define	_POSIX_VDISABLE	0
 
 /* Filenames are not silently truncated.  */
 #define	_POSIX_NO_TRUNC	1
diff --git a/lib/libc/include/generic-glibc/bits/ppc.h b/lib/libc/include/generic-glibc/bits/ppc.h
index af91d4ca3ca482bb3d4f4acc88fbd7f9745d12ac..5e98f066e0a95606f78a7129795ff5f06cbe55ad 100644
--- a/lib/libc/include/generic-glibc/bits/ppc.h
+++ b/lib/libc/include/generic-glibc/bits/ppc.h
@@ -1,5 +1,5 @@
 /* Facilities specific to the PowerPC architecture on Linux
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/printf-ldbl.h b/lib/libc/include/generic-glibc/bits/printf-ldbl.h
index c1bd5c3820da49624f678035359281f56c1fcf31..034c5c0ce67bba7965c5e8e1c312ab0fad3cf422 100644
--- a/lib/libc/include/generic-glibc/bits/printf-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/printf-ldbl.h
@@ -1,5 +1,5 @@
 /* -mlong-double-64 compatibility mode for <printf.h> functions.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/procfs-extra.h b/lib/libc/include/generic-glibc/bits/procfs-extra.h
index f89b7d8e9596ec26bc0d74b73c6432e161605ef2..114d9a77a2277b8aae0014fadeed69bdf04d9c54 100644
--- a/lib/libc/include/generic-glibc/bits/procfs-extra.h
+++ b/lib/libc/include/generic-glibc/bits/procfs-extra.h
@@ -1,5 +1,5 @@
 /* Extra sys/procfs.h definitions.  Generic Linux version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/bits/procfs-id.h b/lib/libc/include/generic-glibc/bits/procfs-id.h
index 9ad086fe8007f886f03284a2d2349c5b35a1f02f..ee42fb67e0b0177665bd65734fe19f8bf85bf509 100644
--- a/lib/libc/include/generic-glibc/bits/procfs-id.h
+++ b/lib/libc/include/generic-glibc/bits/procfs-id.h
@@ -1,5 +1,5 @@
 /* Types of pr_uid and pr_gid in struct elf_prpsinfo.  Generic Linux version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/bits/procfs-prregset.h b/lib/libc/include/generic-glibc/bits/procfs-prregset.h
index 2bed448895db7c6503d7288f61ef3b31fe293873..2d51ab3fc26bb09f93f463823b95740c81c9298c 100644
--- a/lib/libc/include/generic-glibc/bits/procfs-prregset.h
+++ b/lib/libc/include/generic-glibc/bits/procfs-prregset.h
@@ -1,5 +1,5 @@
 /* Types of prgregset_t and prfpregset_t.  Generic Linux version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/bits/procfs.h b/lib/libc/include/generic-glibc/bits/procfs.h
index f32dc14a7b34a8b1db8acf358895848e6bdd189d..a0fe6eec91daa3f92ee134e68dbfd340c1d4c8f8 100644
--- a/lib/libc/include/generic-glibc/bits/procfs.h
+++ b/lib/libc/include/generic-glibc/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  MIPS version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/pthread_stack_min-dynamic.h b/lib/libc/include/generic-glibc/bits/pthread_stack_min-dynamic.h
index a0420827bdd0c5cfe9dd9499417904c9b6ba390b..643fa7e903af6905dbfbe8a32979cbc5b08b893e 100644
--- a/lib/libc/include/generic-glibc/bits/pthread_stack_min-dynamic.h
+++ b/lib/libc/include/generic-glibc/bits/pthread_stack_min-dynamic.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN, possibly dynamic.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/pthread_stack_min.h b/lib/libc/include/generic-glibc/bits/pthread_stack_min.h
index ecd3479f6adf5bfa094cc4c8e12d1c7fd99086dc..5a9a10a0d517f49f7b1a15c110c1917bccc7faea 100644
--- a/lib/libc/include/generic-glibc/bits/pthread_stack_min.h
+++ b/lib/libc/include/generic-glibc/bits/pthread_stack_min.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN.  Linux version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/pthreadtypes-arch.h b/lib/libc/include/generic-glibc/bits/pthreadtypes-arch.h
index d86351fd4173058c5dc8d6bec331cc2d602f5ce8..1c332be795b8383278828f8340491ff67f7b82e7 100644
--- a/lib/libc/include/generic-glibc/bits/pthreadtypes-arch.h
+++ b/lib/libc/include/generic-glibc/bits/pthreadtypes-arch.h
@@ -1,5 +1,5 @@
 /* Machine-specific pthread type layouts.  Generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/bits/pthreadtypes.h b/lib/libc/include/generic-glibc/bits/pthreadtypes.h
index 3510b0a208f9f200858ca198ead37dbeff0835b7..a2a29e841c5b56c9bd9c0b20e36e08c2963a19c5 100644
--- a/lib/libc/include/generic-glibc/bits/pthreadtypes.h
+++ b/lib/libc/include/generic-glibc/bits/pthreadtypes.h
@@ -1,5 +1,5 @@
 /* Declaration of common pthread types for all architectures.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ptrace-shared.h b/lib/libc/include/generic-glibc/bits/ptrace-shared.h
index 8016ba27c6c56520f4588559482a01d572e620a1..8ce2e902148728882846661897413a7d95ed3a2b 100644
--- a/lib/libc/include/generic-glibc/bits/ptrace-shared.h
+++ b/lib/libc/include/generic-glibc/bits/ptrace-shared.h
@@ -1,6 +1,6 @@
 /* `ptrace' debugger support interface.  Linux version,
    not architecture-specific.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/bits/resource.h b/lib/libc/include/generic-glibc/bits/resource.h
index 8711f4616420bbeee1aa66a0b035184fea92c649..7ab2550b3cf00f6769f217b7e2a4dea2acb89924 100644
--- a/lib/libc/include/generic-glibc/bits/resource.h
+++ b/lib/libc/include/generic-glibc/bits/resource.h
@@ -1,5 +1,5 @@
 /* Bit values & structures for resource limits.  Linux version.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/rseq.h b/lib/libc/include/generic-glibc/bits/rseq.h
index 60f35a626167aff6da78942735db674168b855fb..520d973af2e6681e6d9e2fd5dae73d7fca86a0be 100644
--- a/lib/libc/include/generic-glibc/bits/rseq.h
+++ b/lib/libc/include/generic-glibc/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux mips architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/generic-glibc/bits/sched.h b/lib/libc/include/generic-glibc/bits/sched.h
index c0e7cd3ead0630fcec65b47a0878b5e57a27c581..aa49876c1c353c46701b02b6f7f19b2f565e06e5 100644
--- a/lib/libc/include/generic-glibc/bits/sched.h
+++ b/lib/libc/include/generic-glibc/bits/sched.h
@@ -1,6 +1,6 @@
 /* Definitions of constants and data structure for POSIX 1003.1b-1993
    scheduling interface.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/select-decl.h b/lib/libc/include/generic-glibc/bits/select-decl.h
index fb3a3a6ae998f298b9f2556667074cf21fb5275f..0796f7f3e4f947290077cee94b78e5db80580b28 100644
--- a/lib/libc/include/generic-glibc/bits/select-decl.h
+++ b/lib/libc/include/generic-glibc/bits/select-decl.h
@@ -1,5 +1,5 @@
 /* Checking routines for select functions. Declaration only.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/select.h b/lib/libc/include/generic-glibc/bits/select.h
index 2683668a052c6feefb2e96f4b7e85a56accefe5b..36cce0ec34056c0442174c4f4c926441ba3d80ec 100644
--- a/lib/libc/include/generic-glibc/bits/select.h
+++ b/lib/libc/include/generic-glibc/bits/select.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/select2.h b/lib/libc/include/generic-glibc/bits/select2.h
index 0144b4092d345751c0d073419a50c1674a8f1686..8d82cd504930cc465650bb9b0e1008ba2e2f7b27 100644
--- a/lib/libc/include/generic-glibc/bits/select2.h
+++ b/lib/libc/include/generic-glibc/bits/select2.h
@@ -1,5 +1,5 @@
 /* Checking macros for select functions.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sem.h b/lib/libc/include/generic-glibc/bits/sem.h
index 8b2d5f5eb4b2e98c798a06b00776940cbf809116..5a6afb70eb5a4f9d04002a25dad500ab58f45a2f 100644
--- a/lib/libc/include/generic-glibc/bits/sem.h
+++ b/lib/libc/include/generic-glibc/bits/sem.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/semaphore.h b/lib/libc/include/generic-glibc/bits/semaphore.h
index c84a8d70a2548e9cbfafbb42f7fdb3688edceab6..bc0b489262428019e3449203d98d4861e52af22e 100644
--- a/lib/libc/include/generic-glibc/bits/semaphore.h
+++ b/lib/libc/include/generic-glibc/bits/semaphore.h
@@ -1,5 +1,5 @@
 /* Generic POSIX semaphore type layout
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/setjmp.h b/lib/libc/include/generic-glibc/bits/setjmp.h
index 5eefe2f900c83ea5e7fd2f5e55a002169c193f55..f7ba985a9f2a49f95184e0b6fdff3d3f7bab6745 100644
--- a/lib/libc/include/generic-glibc/bits/setjmp.h
+++ b/lib/libc/include/generic-glibc/bits/setjmp.h
@@ -1,5 +1,5 @@
 /* Define the machine-dependent type `jmp_buf'.  MIPS version.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/setjmp2.h b/lib/libc/include/generic-glibc/bits/setjmp2.h
index 9542c0560df1e16f311195d3d9350a0aae4f56aa..9f98fe0b7d57c78c387e1138e4837588cf3860a2 100644
--- a/lib/libc/include/generic-glibc/bits/setjmp2.h
+++ b/lib/libc/include/generic-glibc/bits/setjmp2.h
@@ -1,5 +1,5 @@
 /* Checking macros for setjmp functions.
-   Copyright (C) 2009-2025 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/shm.h b/lib/libc/include/generic-glibc/bits/shm.h
index 89562d77a10b61920f33e1a1d97d4c919c4ca1a6..59ebb918b0013b2b75815fcef3cdad444b855cd0 100644
--- a/lib/libc/include/generic-glibc/bits/shm.h
+++ b/lib/libc/include/generic-glibc/bits/shm.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/shmlba.h b/lib/libc/include/generic-glibc/bits/shmlba.h
index 45a3b0713a1e7f691f82f5c680b5357c2225e5ce..396ac08af12492d857b254e9b39d340ec59646de 100644
--- a/lib/libc/include/generic-glibc/bits/shmlba.h
+++ b/lib/libc/include/generic-glibc/bits/shmlba.h
@@ -1,5 +1,5 @@
 /* Define SHMLBA.  Generic version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sigaction.h b/lib/libc/include/generic-glibc/bits/sigaction.h
index 130895b1329823088974b204f515153e14188fa9..64836caa87fb57149b1b42b41abdfc63c4a54a86 100644
--- a/lib/libc/include/generic-glibc/bits/sigaction.h
+++ b/lib/libc/include/generic-glibc/bits/sigaction.h
@@ -1,5 +1,5 @@
 /* The proper definitions for Linux's sigaction.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sigcontext.h b/lib/libc/include/generic-glibc/bits/sigcontext.h
index ac320c03d0b683cb12f5a902edd3c48bd2292580..c551fb8e1e1695c0fe25aa392f7f520117d1b39d 100644
--- a/lib/libc/include/generic-glibc/bits/sigcontext.h
+++ b/lib/libc/include/generic-glibc/bits/sigcontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sigevent-consts.h b/lib/libc/include/generic-glibc/bits/sigevent-consts.h
index 93eb14f80a0f5e3f42e5052df8df5053f0b21536..18a1c9b2a70286d4c929ac99742f4278a65a58e3 100644
--- a/lib/libc/include/generic-glibc/bits/sigevent-consts.h
+++ b/lib/libc/include/generic-glibc/bits/sigevent-consts.h
@@ -1,5 +1,5 @@
 /* sigevent constants.  Linux version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/siginfo-consts.h b/lib/libc/include/generic-glibc/bits/siginfo-consts.h
index 5958670bfa10039712dd4d1357340aa44b86a455..f4a1a39f776a9909d1f805da786749092baf7591 100644
--- a/lib/libc/include/generic-glibc/bits/siginfo-consts.h
+++ b/lib/libc/include/generic-glibc/bits/siginfo-consts.h
@@ -1,5 +1,5 @@
 /* siginfo constants.  Linux version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -168,8 +168,10 @@ enum
 #  define TRAP_BRANCH	TRAP_BRANCH
   TRAP_HWBKPT,			/* Hardware breakpoint/watchpoint.  */
 #  define TRAP_HWBKPT	TRAP_HWBKPT
-  TRAP_UNK			/* Undiagnosed trap.  */
+  TRAP_UNK,			/* Undiagnosed trap.  */
 #  define TRAP_UNK	TRAP_UNK
+  TRAP_PERF			/* Perf event with sigtrap=1.  */
+#  define TRAP_PERF	TRAP_PERF
 };
 # endif
 
@@ -209,6 +211,18 @@ enum
 };
 # endif
 
+/* The Linux-specific SIGSYS values are all considered GNU extensions.  */
+#ifdef __USE_GNU
+/* `si_code' values for SIGSYS signal.  */
+enum
+{
+  SYS_SECCOMP = 1,		/* Seccomp triggered.  */
+#  define SYS_SECCOMP	SYS_SECCOMP
+  SYS_USER_DISPATCH			/* Syscall user dispatch triggered.  */
+#  define SYS_USER_DISPATCH	SYS_USER_DISPATCH
+};
+#endif
+
 /* Architectures might also add architecture-specific constants.
    These are all considered GNU extensions.  */
 #ifdef __USE_GNU
diff --git a/lib/libc/include/generic-glibc/bits/signal_ext.h b/lib/libc/include/generic-glibc/bits/signal_ext.h
index e19d2026ba7e094af15601a986a61bdb2e959fca..1e87f9d2eb88bd8e227d8505d5a23dfe15fde94d 100644
--- a/lib/libc/include/generic-glibc/bits/signal_ext.h
+++ b/lib/libc/include/generic-glibc/bits/signal_ext.h
@@ -1,5 +1,5 @@
 /* System-specific extensions of <signal.h>, Linux version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/signalfd.h b/lib/libc/include/generic-glibc/bits/signalfd.h
index b54daab5623b2b2aeb0ed24c219ed12f7b1b0a99..1cc97d89962497b225b98c3c193e1924111a5793 100644
--- a/lib/libc/include/generic-glibc/bits/signalfd.h
+++ b/lib/libc/include/generic-glibc/bits/signalfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/signum-arch.h b/lib/libc/include/generic-glibc/bits/signum-arch.h
index a1e34a31918499bbbf80fe09e322622cf8991802..5ae8d4973ebc31a464c0e75fa0175c0a00ecc856 100644
--- a/lib/libc/include/generic-glibc/bits/signum-arch.h
+++ b/lib/libc/include/generic-glibc/bits/signum-arch.h
@@ -1,5 +1,5 @@
 /* Signal number definitions.  Linux version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/signum-generic.h b/lib/libc/include/generic-glibc/bits/signum-generic.h
index a6f4511a0608708fdaf2469827389232cd206b5e..7c37e9d40218bdbbe00159447fee42f70659cb17 100644
--- a/lib/libc/include/generic-glibc/bits/signum-generic.h
+++ b/lib/libc/include/generic-glibc/bits/signum-generic.h
@@ -1,5 +1,5 @@
 /* Signal number constants.  Generic template.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sigstack.h b/lib/libc/include/generic-glibc/bits/sigstack.h
index 3f238ad9bd93db95206616b710f88f2e9d3fca1b..bd790e051595371bad56316486fcbe3d71d7d7ab 100644
--- a/lib/libc/include/generic-glibc/bits/sigstack.h
+++ b/lib/libc/include/generic-glibc/bits/sigstack.h
@@ -1,5 +1,5 @@
 /* sigstack, sigaltstack definitions.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sigstksz.h b/lib/libc/include/generic-glibc/bits/sigstksz.h
index dd535d7208325b57f29847b4ae986ee8ce3a32a3..6210586a24aa527f4ca983382c34d0e0e3474997 100644
--- a/lib/libc/include/generic-glibc/bits/sigstksz.h
+++ b/lib/libc/include/generic-glibc/bits/sigstksz.h
@@ -1,5 +1,5 @@
 /* Definition of MINSIGSTKSZ and SIGSTKSZ.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sigthread.h b/lib/libc/include/generic-glibc/bits/sigthread.h
index 752c13ccf65dcb5cd3904b77e32a0a9a185b0bc1..071af39be9300db1aa8b090d5020956ffb4cb3eb 100644
--- a/lib/libc/include/generic-glibc/bits/sigthread.h
+++ b/lib/libc/include/generic-glibc/bits/sigthread.h
@@ -1,5 +1,5 @@
 /* Signal handling function for threaded programs.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sockaddr.h b/lib/libc/include/generic-glibc/bits/sockaddr.h
index cc2e91efcc5414f7f82b5f6283f15f63ab1ddd1f..60095d188f39f87a9a63cce3f4ae495ddd7c57f0 100644
--- a/lib/libc/include/generic-glibc/bits/sockaddr.h
+++ b/lib/libc/include/generic-glibc/bits/sockaddr.h
@@ -1,5 +1,5 @@
 /* Definition of struct sockaddr_* common members and sizes, generic version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/socket-constants.h b/lib/libc/include/generic-glibc/bits/socket-constants.h
index d4efd385d124a72830a2c43f8c9750de8ef26b3b..fd8897fed1300efa66717d61069bcc8da848bed6 100644
--- a/lib/libc/include/generic-glibc/bits/socket-constants.h
+++ b/lib/libc/include/generic-glibc/bits/socket-constants.h
@@ -1,5 +1,5 @@
 /* Socket constants which vary among Linux architectures.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/socket.h b/lib/libc/include/generic-glibc/bits/socket.h
index 22cdb822c6a4474f2a72982479ad2c773fb0f95d..62c91e9ba982e4618eab608c7abe8289d3f7d61d 100644
--- a/lib/libc/include/generic-glibc/bits/socket.h
+++ b/lib/libc/include/generic-glibc/bits/socket.h
@@ -1,5 +1,5 @@
 /* System-specific socket constants and types.  Linux version.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/socket2.h b/lib/libc/include/generic-glibc/bits/socket2.h
index 1365126b680ab47c4d74283bca495f826b9e43cd..326deaf3aaa87ded048e2caf9b9b9910b4065526 100644
--- a/lib/libc/include/generic-glibc/bits/socket2.h
+++ b/lib/libc/include/generic-glibc/bits/socket2.h
@@ -1,5 +1,5 @@
 /* Checking macros for socket functions.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/socket_type.h b/lib/libc/include/generic-glibc/bits/socket_type.h
index a95843234213621771c22648b7edd3d1af8d3ab3..a763872fa93f40a01cc39d0daf897c510fcde1fa 100644
--- a/lib/libc/include/generic-glibc/bits/socket_type.h
+++ b/lib/libc/include/generic-glibc/bits/socket_type.h
@@ -1,5 +1,5 @@
 /* Define enum __socket_type for generic Linux.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/spawn_ext.h b/lib/libc/include/generic-glibc/bits/spawn_ext.h
index 534d1c8fb163ca8347566bab8e204f05175180e2..e70b4be563c407c4f211538a6870319b0ddf788f 100644
--- a/lib/libc/include/generic-glibc/bits/spawn_ext.h
+++ b/lib/libc/include/generic-glibc/bits/spawn_ext.h
@@ -1,5 +1,5 @@
 /* POSIX spawn extensions.   Linux version.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/ss_flags.h b/lib/libc/include/generic-glibc/bits/ss_flags.h
index 642a09231ce73b4ccc626e4d2fde8bd80e12cfc1..2ba640d263e9b2a6911c409c10543cb8b26aaa4e 100644
--- a/lib/libc/include/generic-glibc/bits/ss_flags.h
+++ b/lib/libc/include/generic-glibc/bits/ss_flags.h
@@ -1,5 +1,5 @@
 /* ss_flags values for stack_t.  Linux version.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stab.def b/lib/libc/include/generic-glibc/bits/stab.def
index 2d684acbee010c7aa7cf863a38d971403220f63a..1967bf9983f7e454974ac0ec7a87a636616c7002 100644
--- a/lib/libc/include/generic-glibc/bits/stab.def
+++ b/lib/libc/include/generic-glibc/bits/stab.def
@@ -1,5 +1,5 @@
 /* Table of DBX symbol codes for the GNU system.
-   Copyright (C) 1988, 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stat.h b/lib/libc/include/generic-glibc/bits/stat.h
index 72ff0a8d8b3e1ffd3ff81804475b092814d0694d..aba780ffd3891883d66d12febc04f552e8c05a0b 100644
--- a/lib/libc/include/generic-glibc/bits/stat.h
+++ b/lib/libc/include/generic-glibc/bits/stat.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/statfs.h b/lib/libc/include/generic-glibc/bits/statfs.h
index ed77ad1575c0692a944bde04e93bace1be42e764..15ec2e10ff7aacdc618147e77c1570a23462996e 100644
--- a/lib/libc/include/generic-glibc/bits/statfs.h
+++ b/lib/libc/include/generic-glibc/bits/statfs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/statvfs.h b/lib/libc/include/generic-glibc/bits/statvfs.h
index 38f11407d5d235e7e2e123460ad62656a6541055..a10c21ac5e8cad598a54335a6b682e92b299f6fc 100644
--- a/lib/libc/include/generic-glibc/bits/statvfs.h
+++ b/lib/libc/include/generic-glibc/bits/statvfs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/statx-generic.h b/lib/libc/include/generic-glibc/bits/statx-generic.h
index c197005d8ba28cfca0d4aa0c16491d352943ba7f..6663449e195dd176a92307803c4ed7b5fcfa1f77 100644
--- a/lib/libc/include/generic-glibc/bits/statx-generic.h
+++ b/lib/libc/include/generic-glibc/bits/statx-generic.h
@@ -1,5 +1,5 @@
 /* Generic statx-related definitions and declarations.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -48,6 +48,7 @@
 # define STATX_MNT_ID_UNIQUE 0x4000U
 # define STATX_SUBVOL 0x8000U
 # define STATX_WRITE_ATOMIC 0x00010000U
+# define STATX_DIO_READ_ALIGN 0x00020000U
 # define STATX__RESERVED 0x80000000U
 
 # define STATX_ATTR_COMPRESSED 0x0004
diff --git a/lib/libc/include/generic-glibc/bits/statx.h b/lib/libc/include/generic-glibc/bits/statx.h
index 7b2e0ceb7c0cccc7fd3be145eae86f59ae6427bb..e2b325c216d6afe1265a3fb70b80d4df88db82f5 100644
--- a/lib/libc/include/generic-glibc/bits/statx.h
+++ b/lib/libc/include/generic-glibc/bits/statx.h
@@ -1,5 +1,5 @@
 /* statx-related definitions and declarations.  Linux version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdint-intn.h b/lib/libc/include/generic-glibc/bits/stdint-intn.h
index c66b42ee53084a0bc2d1b03e9033130cefdbd7bf..4ce6b7c45b5d4f0c71498bec5ae0f78f84863b29 100644
--- a/lib/libc/include/generic-glibc/bits/stdint-intn.h
+++ b/lib/libc/include/generic-glibc/bits/stdint-intn.h
@@ -1,5 +1,5 @@
 /* Define intN_t types.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdint-least.h b/lib/libc/include/generic-glibc/bits/stdint-least.h
index 2aae8a7b14f9e9a7457ed3366b3973445b43fd8e..95ec33cabcdfc57b5cb5b086302fb188ae365812 100644
--- a/lib/libc/include/generic-glibc/bits/stdint-least.h
+++ b/lib/libc/include/generic-glibc/bits/stdint-least.h
@@ -1,5 +1,5 @@
 /* Define int_leastN_t and uint_leastN types.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdint-uintn.h b/lib/libc/include/generic-glibc/bits/stdint-uintn.h
index 1a5333937008f2c980cb5a40ef55a700537a55c0..f198de37b14d070343ffb66db6e1aebf518c7455 100644
--- a/lib/libc/include/generic-glibc/bits/stdint-uintn.h
+++ b/lib/libc/include/generic-glibc/bits/stdint-uintn.h
@@ -1,5 +1,5 @@
 /* Define uintN_t types.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdio-ldbl.h b/lib/libc/include/generic-glibc/bits/stdio-ldbl.h
index 87bba9b4b8bd6a3f7433195b8fee1c77fc9b9ec7..4efb79675115f19d88ba576d2dd185fc582b7cc2 100644
--- a/lib/libc/include/generic-glibc/bits/stdio-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/stdio-ldbl.h
@@ -1,5 +1,5 @@
 /* -mlong-double-64 compatibility mode for stdio functions.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdio.h b/lib/libc/include/generic-glibc/bits/stdio.h
index 4dd08a8b2984dc8f932a9ffca1c3f0d237200828..f5d0753a774defcaf8bed7b98fdaf48bb429bc89 100644
--- a/lib/libc/include/generic-glibc/bits/stdio.h
+++ b/lib/libc/include/generic-glibc/bits/stdio.h
@@ -1,5 +1,5 @@
 /* Optimizing macros and inline functions for stdio functions.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdio2-decl.h b/lib/libc/include/generic-glibc/bits/stdio2-decl.h
index 8591cafdf5260d595ad3b48e5c89cbfed6ee676d..59a7d14bca8c38f2b4fca4b0b2206cb443c5e3df 100644
--- a/lib/libc/include/generic-glibc/bits/stdio2-decl.h
+++ b/lib/libc/include/generic-glibc/bits/stdio2-decl.h
@@ -1,5 +1,5 @@
 /* Checking macros for stdio functions. Declarations only.
-   Copyright (C) 2004-2025 Free Software Foundation, Inc.
+   Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdio2.h b/lib/libc/include/generic-glibc/bits/stdio2.h
index 355ab080eddad0418547c6627f85448945be8a73..7761b193e38e31d34430d468bfa789b30f47a63d 100644
--- a/lib/libc/include/generic-glibc/bits/stdio2.h
+++ b/lib/libc/include/generic-glibc/bits/stdio2.h
@@ -1,5 +1,5 @@
 /* Checking macros for stdio functions.
-   Copyright (C) 2004-2025 Free Software Foundation, Inc.
+   Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdio_lim.h b/lib/libc/include/generic-glibc/bits/stdio_lim.h
index 93fa44af20732a8eeb98b0b76cffda1b6e68bec3..71c45757d660c17237d42d11da17fe83f11c3f1e 100644
--- a/lib/libc/include/generic-glibc/bits/stdio_lim.h
+++ b/lib/libc/include/generic-glibc/bits/stdio_lim.h
@@ -1,5 +1,5 @@
 /* System specific stdio.h definitions.  Linux version.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdlib-bsearch.h b/lib/libc/include/generic-glibc/bits/stdlib-bsearch.h
index 959676e3b6958f03e3bdd1952a4623ed10e28282..2168bf70d3b29f27af868df7b173e04e584ad2a5 100644
--- a/lib/libc/include/generic-glibc/bits/stdlib-bsearch.h
+++ b/lib/libc/include/generic-glibc/bits/stdlib-bsearch.h
@@ -1,5 +1,5 @@
 /* Perform binary search - inline version.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdlib-float.h b/lib/libc/include/generic-glibc/bits/stdlib-float.h
index ff5f0a052dfeb7941a24fec7b7a501ebff33c0e6..3df3257fcd91dabdf4abc92bc9037cb66391bcac 100644
--- a/lib/libc/include/generic-glibc/bits/stdlib-float.h
+++ b/lib/libc/include/generic-glibc/bits/stdlib-float.h
@@ -1,5 +1,5 @@
 /* Floating-point inline functions for stdlib.h.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdlib-ldbl.h b/lib/libc/include/generic-glibc/bits/stdlib-ldbl.h
index 332a7af8e1e02dc0b8224a5dd1b08e6e9f1d7687..08d0b18d4ca8b1c77a1d3c416c3320a4e13dec1a 100644
--- a/lib/libc/include/generic-glibc/bits/stdlib-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/stdlib-ldbl.h
@@ -1,5 +1,5 @@
 /* -mlong-double-64 compatibility mode for <stdlib.h> functions.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/stdlib.h b/lib/libc/include/generic-glibc/bits/stdlib.h
index e159bea9c7508edff4f0c7988a9f3ea76b555c99..d52a6d18eed43e81f603c4ec923d82c4404d0382 100644
--- a/lib/libc/include/generic-glibc/bits/stdlib.h
+++ b/lib/libc/include/generic-glibc/bits/stdlib.h
@@ -1,5 +1,5 @@
 /* Checking macros for stdlib functions.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/string_fortified.h b/lib/libc/include/generic-glibc/bits/string_fortified.h
index 9c36d02fb1c87876117aef872b857fdef724b000..b056dbbbf3b2b9b392acc9c1ac842345be9df1e9 100644
--- a/lib/libc/include/generic-glibc/bits/string_fortified.h
+++ b/lib/libc/include/generic-glibc/bits/string_fortified.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -60,6 +60,18 @@ __NTH (memset (void *__dest, int __ch, size_t __len))
 				 __glibc_objsize0 (__dest));
 }
 
+#if defined __USE_MISC || __GLIBC_USE (ISOC23)
+void *__memset_explicit_chk (void *__s, int __c, size_t __n, size_t __destlen)
+     __THROW __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 3);
+
+__fortify_function void *
+__NTH (memset_explicit (void *__dest, int __ch, size_t __len))
+{
+  return __memset_explicit_chk (__dest, __ch, __len,
+				__glibc_objsize0 (__dest));
+}
+#endif
+
 #ifdef __USE_MISC
 # include <bits/strings_fortified.h>
 
diff --git a/lib/libc/include/generic-glibc/bits/strings_fortified.h b/lib/libc/include/generic-glibc/bits/strings_fortified.h
index aad1684f89f40b26f8ae0f1549effa6a110a8ae4..18c423af17e6a904254c36dae1229c0baf58bab0 100644
--- a/lib/libc/include/generic-glibc/bits/strings_fortified.h
+++ b/lib/libc/include/generic-glibc/bits/strings_fortified.h
@@ -1,5 +1,5 @@
 /* Fortify macros for strings.h functions.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/struct_mutex.h b/lib/libc/include/generic-glibc/bits/struct_mutex.h
index d794fea0d5ba70e6f6524e15f6ad1395976aa52b..0476a87aa35e1071a9679e976ab9c2a9ca49b409 100644
--- a/lib/libc/include/generic-glibc/bits/struct_mutex.h
+++ b/lib/libc/include/generic-glibc/bits/struct_mutex.h
@@ -1,5 +1,5 @@
 /* Default mutex implementation struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -21,8 +21,8 @@
 
 /* Generic struct for both POSIX and C11 mutexes.  New ports are expected
    to use the default layout, however architecture can redefine it to
-   add arch-specific extension (such as lock-elision).  The struct have
-   a size of 32 bytes on LP32 and 40 bytes on LP64 architectures.  */
+   add arch-specific extension.  The struct have a size of 32 bytes on LP32
+   and 40 bytes on LP64 architectures.  */
 
 struct __pthread_mutex_s
 {
@@ -40,21 +40,7 @@ struct __pthread_mutex_s
      PTHREAD_MUTEX_INITIALIZER or by a call to pthread_mutex_init.
 
      After a mutex has been initialized, the __kind of a mutex is usually not
-     changed.  BUT it can be set to -1 in pthread_mutex_destroy or elision can
-     be enabled.  This is done concurrently in the pthread_mutex_*lock
-     functions by using the macro FORCE_ELISION. This macro is only defined
-     for architectures which supports lock elision.
-
-     For elision, there are the flags PTHREAD_MUTEX_ELISION_NP and
-     PTHREAD_MUTEX_NO_ELISION_NP which can be set in addition to the already
-     set type of a mutex.  Before a mutex is initialized, only
-     PTHREAD_MUTEX_NO_ELISION_NP can be set with pthread_mutexattr_settype.
-
-     After a mutex has been initialized, the functions pthread_mutex_*lock can
-     enable elision - if the mutex-type and the machine supports it - by
-     setting the flag PTHREAD_MUTEX_ELISION_NP. This is done concurrently.
-     Afterwards the lock / unlock functions are using specific elision
-     code-paths.  */
+     changed.  BUT it can be set to -1 in pthread_mutex_destroy.  */
   int __kind;
 #if __WORDSIZE != 64
   unsigned int __nusers;
diff --git a/lib/libc/include/generic-glibc/bits/struct_rwlock.h b/lib/libc/include/generic-glibc/bits/struct_rwlock.h
index d1f2e41e34e0a66c703ca2840a38eaa1cd9b655e..8fe478d7c82a0436e45e0cfc19d05c37a8cafa12 100644
--- a/lib/libc/include/generic-glibc/bits/struct_rwlock.h
+++ b/lib/libc/include/generic-glibc/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* Default read-write lock implementation struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -23,8 +23,8 @@
 
 /* Generic struct for both POSIX read-write lock.  New ports are expected
    to use the default layout, however archictetures can redefine it to add
-   arch-specific extensions (such as lock-elision).  The struct have a size
-   of 32 bytes on both LP32 and LP64 architectures.  */
+   arch-specific extensions.  The struct have a size of 32 bytes on both LP32
+   and LP64 architectures.  */
 
 struct __pthread_rwlock_arch_t
 {
diff --git a/lib/libc/include/generic-glibc/bits/struct_stat.h b/lib/libc/include/generic-glibc/bits/struct_stat.h
index c07c9a76609b21e947bc9b0e3687ee2ae9a1ce94..231c875e7ab2c703e50746e2191ddc411c0878a2 100644
--- a/lib/libc/include/generic-glibc/bits/struct_stat.h
+++ b/lib/libc/include/generic-glibc/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/struct_stat_time64_helper.h b/lib/libc/include/generic-glibc/bits/struct_stat_time64_helper.h
index 9d927e834f593303263ae00ae8447af38e450743..7dce3ade823ecdd74d69546595c5bd25fd2a4cdc 100644
--- a/lib/libc/include/generic-glibc/bits/struct_stat_time64_helper.h
+++ b/lib/libc/include/generic-glibc/bits/struct_stat_time64_helper.h
@@ -1,5 +1,5 @@
 /* Definition for helper to define struct stat with 64-bit time.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/syscall.h b/lib/libc/include/generic-glibc/bits/syscall.h
index 3c70ff32d493f92febe6d4aaf567c305e35844b9..43e6645f7d238e0805be9874cadff3bfd5889520 100644
--- a/lib/libc/include/generic-glibc/bits/syscall.h
+++ b/lib/libc/include/generic-glibc/bits/syscall.h
@@ -1,11 +1,11 @@
 /* Generated at libc build time from syscall list.  */
-/* The system call list corresponds to kernel 6.15.  */
+/* The system call list corresponds to kernel 6.17.  */
 
 #ifndef _SYSCALL_H
 # error "Never use <bits/syscall.h> directly; include <sys/syscall.h> instead."
 #endif
 
-#define __GLIBC_LINUX_VERSION_CODE 397056
+#define __GLIBC_LINUX_VERSION_CODE 397568
 
 #ifdef __NR_FAST_atomic_update
 # define SYS_FAST_atomic_update __NR_FAST_atomic_update
@@ -411,6 +411,14 @@
 # define SYS_fgetxattr __NR_fgetxattr
 #endif
 
+#ifdef __NR_file_getattr
+# define SYS_file_getattr __NR_file_getattr
+#endif
+
+#ifdef __NR_file_setattr
+# define SYS_file_setattr __NR_file_setattr
+#endif
+
 #ifdef __NR_finit_module
 # define SYS_finit_module __NR_finit_module
 #endif
diff --git a/lib/libc/include/generic-glibc/bits/syslog-decl.h b/lib/libc/include/generic-glibc/bits/syslog-decl.h
index a6984dcd2c1414a95c520aeba7cc50b9848092fc..25786a5a92163ddb44924a6cbd11bf572293adaf 100644
--- a/lib/libc/include/generic-glibc/bits/syslog-decl.h
+++ b/lib/libc/include/generic-glibc/bits/syslog-decl.h
@@ -1,5 +1,5 @@
 /* Checking routines for syslog functions. Declaration only.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/syslog-ldbl.h b/lib/libc/include/generic-glibc/bits/syslog-ldbl.h
index 4b038631dca162fe93633446a1aa03b1024c4594..8d682f900e6b7a961864b1ea2ceca67c9385651e 100644
--- a/lib/libc/include/generic-glibc/bits/syslog-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/syslog-ldbl.h
@@ -1,5 +1,5 @@
 /* -mlong-double-64 compatibility mode for syslog functions.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/syslog-path.h b/lib/libc/include/generic-glibc/bits/syslog-path.h
index 808f2cb1d5f94271ce75f21b5ab5c82b41a024d4..8ee09d71e070f773b777f0e1296b149482cba84a 100644
--- a/lib/libc/include/generic-glibc/bits/syslog-path.h
+++ b/lib/libc/include/generic-glibc/bits/syslog-path.h
@@ -1,5 +1,5 @@
 /* <bits/syslog-path.h> -- _PATH_LOG definition
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/syslog.h b/lib/libc/include/generic-glibc/bits/syslog.h
index 322e9ba010afdbe7dd85992d53c08a8ca2ef2c9b..2c691c8abf510cf8faf75477f4219d01f0437731 100644
--- a/lib/libc/include/generic-glibc/bits/syslog.h
+++ b/lib/libc/include/generic-glibc/bits/syslog.h
@@ -1,5 +1,5 @@
 /* Checking macros for syslog functions.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/sysmacros.h b/lib/libc/include/generic-glibc/bits/sysmacros.h
index 3322015c54fd48ab62b68523c12d785dd265d75b..cf1a1fc11f680bbd72a2a7f3ada6e6a86133dca9 100644
--- a/lib/libc/include/generic-glibc/bits/sysmacros.h
+++ b/lib/libc/include/generic-glibc/bits/sysmacros.h
@@ -1,5 +1,5 @@
 /* Definitions of macros to access `dev_t' values.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-baud.h b/lib/libc/include/generic-glibc/bits/termios-baud.h
index cd11a7e55b5d5a6454b20d66b51ca731104e4102..c270c9ffa4523c3ea94221afa9d9e564e5613799 100644
--- a/lib/libc/include/generic-glibc/bits/termios-baud.h
+++ b/lib/libc/include/generic-glibc/bits/termios-baud.h
@@ -1,5 +1,5 @@
 /* termios baud rate selection definitions. Universal version for sane speed_t.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-c_cc.h b/lib/libc/include/generic-glibc/bits/termios-c_cc.h
index 964069a38e6d0b0fa1fa84e21ec48cc72b62bedd..25b7668a32a7c303757a1a9634c098822e15bddb 100644
--- a/lib/libc/include/generic-glibc/bits/termios-c_cc.h
+++ b/lib/libc/include/generic-glibc/bits/termios-c_cc.h
@@ -1,5 +1,5 @@
 /* termios c_cc symbolic constant definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-c_cflag.h b/lib/libc/include/generic-glibc/bits/termios-c_cflag.h
index 7a4c0a53fe348037f5412d2785151aa1c04fcc1e..9cd9efe0f13fc17bc24da3f9b9e89d33f615c2fe 100644
--- a/lib/libc/include/generic-glibc/bits/termios-c_cflag.h
+++ b/lib/libc/include/generic-glibc/bits/termios-c_cflag.h
@@ -1,5 +1,5 @@
 /* termios control mode definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-c_iflag.h b/lib/libc/include/generic-glibc/bits/termios-c_iflag.h
index af8f549e200796033cd88441f776ce7c6e6c47d0..62771829ec1708d012900690123f9417bd3d61d0 100644
--- a/lib/libc/include/generic-glibc/bits/termios-c_iflag.h
+++ b/lib/libc/include/generic-glibc/bits/termios-c_iflag.h
@@ -1,5 +1,5 @@
 /* termios input mode definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-c_lflag.h b/lib/libc/include/generic-glibc/bits/termios-c_lflag.h
index 35ff14842b774f8dd91fde493be41fa0e84651c1..b407dfd6d51caa56b4fbe63eb44193a807378612 100644
--- a/lib/libc/include/generic-glibc/bits/termios-c_lflag.h
+++ b/lib/libc/include/generic-glibc/bits/termios-c_lflag.h
@@ -1,5 +1,5 @@
 /* termios local mode definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-c_oflag.h b/lib/libc/include/generic-glibc/bits/termios-c_oflag.h
index 0604a35e9aae8aae0dcbb2e5537479946e71358d..4cfeff7ba61a1569a13b3d4b2922684353903040 100644
--- a/lib/libc/include/generic-glibc/bits/termios-c_oflag.h
+++ b/lib/libc/include/generic-glibc/bits/termios-c_oflag.h
@@ -1,5 +1,5 @@
 /* termios output mode definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-cbaud.h b/lib/libc/include/generic-glibc/bits/termios-cbaud.h
index 38bf2ec1aae085543a8e9290793ebf14f6503de9..9f46d9dde901791d6ae0dc4c2631090d068aa97f 100644
--- a/lib/libc/include/generic-glibc/bits/termios-cbaud.h
+++ b/lib/libc/include/generic-glibc/bits/termios-cbaud.h
@@ -1,5 +1,5 @@
 /* termios baud rate selection definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-misc.h b/lib/libc/include/generic-glibc/bits/termios-misc.h
index 42382bfc05c6431cfd2d4d94399b17a39e8e7605..f56475588bf3b7ce7ceb24ac77ea97ec0e60b19f 100644
--- a/lib/libc/include/generic-glibc/bits/termios-misc.h
+++ b/lib/libc/include/generic-glibc/bits/termios-misc.h
@@ -1,5 +1,5 @@
 /* termios baud platform specific definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-struct.h b/lib/libc/include/generic-glibc/bits/termios-struct.h
index 40d20e442d494026e28ffc6813a69f033beaddcf..1c07dc7525657005e0ea16f651a36bb74c24c695 100644
--- a/lib/libc/include/generic-glibc/bits/termios-struct.h
+++ b/lib/libc/include/generic-glibc/bits/termios-struct.h
@@ -1,5 +1,5 @@
 /* struct termios definition.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios-tcflow.h b/lib/libc/include/generic-glibc/bits/termios-tcflow.h
index 7c78b3c7c58b6f75db765390e9aa8f16171af744..dceb13d5b181217bffdb2d94622385a748d81116 100644
--- a/lib/libc/include/generic-glibc/bits/termios-tcflow.h
+++ b/lib/libc/include/generic-glibc/bits/termios-tcflow.h
@@ -1,5 +1,5 @@
 /* termios tcflag symbolic constant definitions.  Linux/generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/termios.h b/lib/libc/include/generic-glibc/bits/termios.h
index 4af6204a30b0b073221afe8f85ee9209881a0e15..38a9e0f173dc05c2303381175cfa9468124a83ec 100644
--- a/lib/libc/include/generic-glibc/bits/termios.h
+++ b/lib/libc/include/generic-glibc/bits/termios.h
@@ -1,5 +1,5 @@
 /* termios type and macro definitions.  Linux version.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/thread-shared-types.h b/lib/libc/include/generic-glibc/bits/thread-shared-types.h
index 119dd8ae559201a8491824dba0e025d9fbc161cd..52c533aa70e61d57a1098d0c33696425b96a330f 100644
--- a/lib/libc/include/generic-glibc/bits/thread-shared-types.h
+++ b/lib/libc/include/generic-glibc/bits/thread-shared-types.h
@@ -1,5 +1,5 @@
 /* Common threading primitives definitions for both POSIX and C11.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -75,7 +75,7 @@ typedef struct __pthread_internal_slist
 
 #include <bits/struct_mutex.h>
 
-/* Arch-sepecific read-write lock definitions.  A generic implementation is
+/* Arch-specific read-write lock definitions.  A generic implementation is
    provided by struct_rwlock.h.  If required, an architecture can override it
    by defining:
 
diff --git a/lib/libc/include/generic-glibc/bits/time.h b/lib/libc/include/generic-glibc/bits/time.h
index 433b755e3be6f5d415d679480aed69b06913fae6..99bddef7f1e0128e3c2efa36b4020534484941a7 100644
--- a/lib/libc/include/generic-glibc/bits/time.h
+++ b/lib/libc/include/generic-glibc/bits/time.h
@@ -1,5 +1,5 @@
 /* System-dependent timing definitions.  Linux version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/time64.h b/lib/libc/include/generic-glibc/bits/time64.h
index cc81e2c3189013717acf4610780b5d551901952e..df1dc0b475d690aabe344651b1254433b1e1c08f 100644
--- a/lib/libc/include/generic-glibc/bits/time64.h
+++ b/lib/libc/include/generic-glibc/bits/time64.h
@@ -1,5 +1,5 @@
 /* bits/time64.h -- underlying types for __time64_t.  Generic version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/timerfd.h b/lib/libc/include/generic-glibc/bits/timerfd.h
index b73c8793b80b2c5541a93d16507f051da05ac334..540e035c925509a38c681a3ae74e233e4c7c5e1b 100644
--- a/lib/libc/include/generic-glibc/bits/timerfd.h
+++ b/lib/libc/include/generic-glibc/bits/timerfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2008-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/timesize.h b/lib/libc/include/generic-glibc/bits/timesize.h
index 5e73e22f26276a7b4f9ea65a9cb951f129277b4b..114eea77753240de1509241efac873c28a59e9d0 100644
--- a/lib/libc/include/generic-glibc/bits/timesize.h
+++ b/lib/libc/include/generic-glibc/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/MIPS.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/timex.h b/lib/libc/include/generic-glibc/bits/timex.h
index 1d02f8a8b893c67638b020aaab9509d9aceb32c8..35559154b131ceabff9db499d7da27fa11c535ea 100644
--- a/lib/libc/include/generic-glibc/bits/timex.h
+++ b/lib/libc/include/generic-glibc/bits/timex.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types.h b/lib/libc/include/generic-glibc/bits/types.h
index 795731e82cc64ebb77b88881b4414bce109caa5b..39dabbe8194a2982fba0339d428b2e3390a406ba 100644
--- a/lib/libc/include/generic-glibc/bits/types.h
+++ b/lib/libc/include/generic-glibc/bits/types.h
@@ -1,5 +1,5 @@
 /* bits/types.h -- definitions of __*_t types underlying *_t types.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/__locale_t.h b/lib/libc/include/generic-glibc/bits/types/__locale_t.h
index 4789e2178d415a7bb10d5470bbba80559cb7c626..796d4c88a7e57e95fb47fd2a431e331262710aaf 100644
--- a/lib/libc/include/generic-glibc/bits/types/__locale_t.h
+++ b/lib/libc/include/generic-glibc/bits/types/__locale_t.h
@@ -1,5 +1,5 @@
 /* Definition of struct __locale_struct and __locale_t.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/__sigval_t.h b/lib/libc/include/generic-glibc/bits/types/__sigval_t.h
index 59ea360f8ed2cb45f11fc7984a4e75a7425f991b..545b2f95f51a73b11a6164993d26d2c6f0408651 100644
--- a/lib/libc/include/generic-glibc/bits/types/__sigval_t.h
+++ b/lib/libc/include/generic-glibc/bits/types/__sigval_t.h
@@ -1,5 +1,5 @@
 /* Define __sigval_t.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/cookie_io_functions_t.h b/lib/libc/include/generic-glibc/bits/types/cookie_io_functions_t.h
index 41f17720467f8424d4c3db51ac0297228311ca41..a23b774821a1f84fe7f5afd952a8475e65601975 100644
--- a/lib/libc/include/generic-glibc/bits/types/cookie_io_functions_t.h
+++ b/lib/libc/include/generic-glibc/bits/types/cookie_io_functions_t.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/error_t.h b/lib/libc/include/generic-glibc/bits/types/error_t.h
index 89be14ed26d0cf61a5ea01c5bf067b802fbeb016..b0486fbc419b6dd6ed8662e0b81858c9974a9acd 100644
--- a/lib/libc/include/generic-glibc/bits/types/error_t.h
+++ b/lib/libc/include/generic-glibc/bits/types/error_t.h
@@ -1,5 +1,5 @@
 /* Define error_t.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/locale_t.h b/lib/libc/include/generic-glibc/bits/types/locale_t.h
index 3c64f46684a35129d960a01861be968adaa46725..5d5f2af6b4c8534fc9dea7ee3f03e8c663fe0270 100644
--- a/lib/libc/include/generic-glibc/bits/types/locale_t.h
+++ b/lib/libc/include/generic-glibc/bits/types/locale_t.h
@@ -1,5 +1,5 @@
 /* Definition of locale_t.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/shmlba.h b/lib/libc/include/generic-glibc/bits/types/once_flag.h
similarity index 72%
rename from lib/libc/include/loongarch-linux-gnu/bits/shmlba.h
rename to lib/libc/include/generic-glibc/bits/types/once_flag.h
index 202e6b651456fc8ef0a9798d2c109772e108cb8e..becbdc248c19fdc58d50fc129743e5154958ba20 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/shmlba.h
+++ b/lib/libc/include/generic-glibc/bits/types/once_flag.h
@@ -1,5 +1,5 @@
-/* Define SHMLBA.  LoongArch version.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+/* Define once_flag and ONCE_FLAG_INIT.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -16,9 +16,12 @@
    License along with the GNU C Library; if not, see
    <https://www.gnu.org/licenses/>.  */
 
-#ifndef _SYS_SHM_H
-# error "Never use <bits/shmlba.h> directly; include <sys/shm.h> instead."
-#endif
+#ifndef __once_flag_defined
+#define __once_flag_defined 1
 
-/* Segment low boundary address multiple.  */
-#define SHMLBA		0x10000
\ No newline at end of file
+#include <bits/thread-shared-types.h>
+
+typedef __once_flag once_flag;
+#define ONCE_FLAG_INIT __ONCE_FLAG_INIT
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/bits/types/stack_t.h b/lib/libc/include/generic-glibc/bits/types/stack_t.h
index 64abc5138b77399316f46d1b5c6e4f02af491199..40822af706d3738ea824774faf0d6f022f7bf128 100644
--- a/lib/libc/include/generic-glibc/bits/types/stack_t.h
+++ b/lib/libc/include/generic-glibc/bits/types/stack_t.h
@@ -1,5 +1,5 @@
 /* Define stack_t.  Linux version.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_FILE.h b/lib/libc/include/generic-glibc/bits/types/struct_FILE.h
index b02bb0c15400c5e8d177cbe0ab006b3c4427e4b6..03f67c5a692741a59c64d21f313142ba5c9a1f81 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_FILE.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_FILE.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/bits/types/struct___jmp_buf_tag.h b/lib/libc/include/generic-glibc/bits/types/struct___jmp_buf_tag.h
index ade4721247a1d2b3471e7da076aba85010477a16..530da903032e72ec8fda6a6aefa2bd1a9f9b5f2a 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct___jmp_buf_tag.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct___jmp_buf_tag.h
@@ -1,5 +1,5 @@
 /* Define struct __jmp_buf_tag.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_iovec.h b/lib/libc/include/generic-glibc/bits/types/struct_iovec.h
index 28b98cdf1a5c9bf1c558d753520993f7eda1820b..3c8b0c36719efed9c30d8d3fb8e498f4645ef655 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_iovec.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_iovec.h
@@ -1,5 +1,5 @@
 /* Define struct iovec.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds.h b/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds.h
index 0f4d5baeab34e2b38fc254f85d0a94a19ede8267..c1dce5edfdbe9b73f4e064a8079a8c645faa4f0e 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds.h
@@ -1,5 +1,5 @@
 /* Generic implementation of the SysV message struct msqid64_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds_helper.h b/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds_helper.h
index 2971aa7bd4174eba450dacf3f06220bce5deb8f3..3359bec9bdf40826d289a337d3953a8594f77ea6 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds_helper.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_msqid64_ds_helper.h
@@ -1,5 +1,5 @@
 /* Common definitions for struct msqid_ds with 64-bit time.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_msqid_ds.h b/lib/libc/include/generic-glibc/bits/types/struct_msqid_ds.h
index d619a22c2b0191ff9951ad3c4b4b83f4f4eb49e5..95c93977ffd6d589360d3164d810e8e9e9dbe025 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_msqid_ds.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_msqid_ds.h
@@ -1,5 +1,5 @@
 /* Generic implementation of the SysV message struct msqid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_rusage.h b/lib/libc/include/generic-glibc/bits/types/struct_rusage.h
index 75a03e2745b86bd197087b29eb4bfffb19793b78..f095b71ef80ed03c95318e24a48fcb38a32584a4 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_rusage.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_rusage.h
@@ -1,5 +1,5 @@
 /* Define struct rusage.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_sched_param.h b/lib/libc/include/generic-glibc/bits/types/struct_sched_param.h
index 8dc14a02b1ca727f52a115013a306942914b92da..301bdf71342e2d9f70eee9875e3b14f4d8a4d084 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_sched_param.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_sched_param.h
@@ -1,5 +1,5 @@
 /* Sched parameter structure.  Generic version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds.h b/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds.h
index c2f60a45b95213055b8e6c4d780f189cec88407c..ddeed6a9fb9099b69530cc1ab986f7947ebd80a2 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds.h
@@ -1,5 +1,5 @@
 /* Generic implementation of the semaphore struct semid64_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds_helper.h b/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds_helper.h
index dd5ae895b0a276900b0f8e703619f8ffc599925e..bef6a93f1e234db4deeb64ab625163b0a280267f 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds_helper.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_semid64_ds_helper.h
@@ -1,5 +1,5 @@
 /* Common definitions for struct semid_ds with 64-bit time.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_semid_ds.h b/lib/libc/include/generic-glibc/bits/types/struct_semid_ds.h
index 842edeeaed41fa6c81ad65b5d75a2fa3553bf4bd..fbafc46cd884c7eadd2daee850e23eeb20c48594 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_semid_ds.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_semid_ds.h
@@ -1,5 +1,5 @@
 /* Generic implementation of the semaphore struct semid_ds.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds.h b/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds.h
index 052eacadcb4fc30df74b5b308ce400af4a3eef61..c4c255c5704ed64191ca0878e3f990b196ce2542 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds.h
@@ -1,5 +1,5 @@
 /* Generic implementation of the shared memory struct shmid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds_helper.h b/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds_helper.h
index d2fb8a3e697f3a0c09a790d10f0c7a0c19b0a3c5..9509db561b2f07666be3561100b7a3e9afd667b6 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds_helper.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_shmid64_ds_helper.h
@@ -1,5 +1,5 @@
 /* Common definitions for struct semid_ds with 64-bit time.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_shmid_ds.h b/lib/libc/include/generic-glibc/bits/types/struct_shmid_ds.h
index 9ec2974b11bcca00c315d38bde186e18b9f401e6..ecb80203a10f1afafc10635dddb832952b908886 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_shmid_ds.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_shmid_ds.h
@@ -1,5 +1,5 @@
 /* Generic implementation of the shared memory struct shmid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_sigstack.h b/lib/libc/include/generic-glibc/bits/types/struct_sigstack.h
index c24f04a7875868b2ea8aab7007a5161e902b8962..c43339e5e0f14e1d5e471b78a3632df5c6dc90f3 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_sigstack.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_sigstack.h
@@ -1,5 +1,5 @@
 /* Define struct sigstack.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_statx.h b/lib/libc/include/generic-glibc/bits/types/struct_statx.h
index 280873cd4867b7d5f20dee632a964adf62e668b0..6f8fa4dacee976722ecbf70bcf78b21be7c7091d 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_statx.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_statx.h
@@ -1,5 +1,5 @@
 /* Definition of the generic version of struct statx.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -49,7 +49,17 @@ struct statx
   __uint32_t stx_rdev_minor;
   __uint32_t stx_dev_major;
   __uint32_t stx_dev_minor;
-  __uint64_t __statx_pad2[14];
+  __uint64_t stx_mnt_id;
+  __uint32_t stx_dio_mem_align;
+  __uint32_t stx_dio_offset_align;
+  __uint64_t stx_subvol;
+  __uint32_t stx_atomic_write_unit_min;
+  __uint32_t stx_atomic_write_unit_max;
+  __uint32_t stx_atomic_write_segments_max;
+  __uint32_t stx_dio_read_offset_align;
+  __uint32_t stx_atomic_write_unit_max_opt;
+  __uint32_t __statx_pad2;
+  __uint64_t __statx_pad3[8];
 };
 
 #endif /* __statx_defined */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/bits/types/struct_statx_timestamp.h b/lib/libc/include/generic-glibc/bits/types/struct_statx_timestamp.h
index 7720e9a5c09fd88d0423273ae3cdc69f8d519731..3861a3b912b73a55a58a35ac5a2ec68b17e9791d 100644
--- a/lib/libc/include/generic-glibc/bits/types/struct_statx_timestamp.h
+++ b/lib/libc/include/generic-glibc/bits/types/struct_statx_timestamp.h
@@ -1,5 +1,5 @@
 /* Definition of the generic version of struct statx_timestamp.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/typesizes.h b/lib/libc/include/generic-glibc/bits/typesizes.h
index 13c7a28ac382da92a8508c0a93deb49101f5010e..6921428cfe8acbd836e6b71c3b82a9241c022084 100644
--- a/lib/libc/include/generic-glibc/bits/typesizes.h
+++ b/lib/libc/include/generic-glibc/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  For the generic Linux ABI.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/uintn-identity.h b/lib/libc/include/generic-glibc/bits/uintn-identity.h
index b60841a5134bbfea5c004b29637c0bf2457497df..658b24e471bb01f425fd312a250d1d391b8298a6 100644
--- a/lib/libc/include/generic-glibc/bits/uintn-identity.h
+++ b/lib/libc/include/generic-glibc/bits/uintn-identity.h
@@ -1,5 +1,5 @@
 /* Inline functions to return unsigned integer values unchanged.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/uio-ext.h b/lib/libc/include/generic-glibc/bits/uio-ext.h
index 2d27c7d94bbeb7b15c8d8d96ec24628e3d7aecf7..e65cf77f433fcc0e7b4ce718f10c093fcc1d2097 100644
--- a/lib/libc/include/generic-glibc/bits/uio-ext.h
+++ b/lib/libc/include/generic-glibc/bits/uio-ext.h
@@ -1,5 +1,5 @@
 /* Operating system-specific extensions to sys/uio.h - Linux version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -50,6 +50,7 @@ extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
 #define RWF_NOAPPEND	0x00000020 /* per-IO negation of O_APPEND */
 #define RWF_ATOMIC	0x00000040 /* Write is to be issued with torn-write
 				      prevention.  */
+#define RWF_DONTCACHE	0x00000080 /* Uncached buffered IO.  */
 
 __END_DECLS
 
diff --git a/lib/libc/include/generic-glibc/bits/uio_lim.h b/lib/libc/include/generic-glibc/bits/uio_lim.h
index 482173177475ad58e28af775df677529805016c2..af26587e6c09b34e6e0b472663004f47e5a29603 100644
--- a/lib/libc/include/generic-glibc/bits/uio_lim.h
+++ b/lib/libc/include/generic-glibc/bits/uio_lim.h
@@ -1,5 +1,5 @@
 /* Implementation limits related to sys/uio.h - Linux version.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/unistd-decl.h b/lib/libc/include/generic-glibc/bits/unistd-decl.h
index fdb6905c0c29a9b45ef73f5bb032e2f607002a6c..eba4d37142fcdc4349d389de8f28c6f5daec8dc2 100644
--- a/lib/libc/include/generic-glibc/bits/unistd-decl.h
+++ b/lib/libc/include/generic-glibc/bits/unistd-decl.h
@@ -1,5 +1,5 @@
 /* Checking routines for unistd functions. Declaration only.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/unistd.h b/lib/libc/include/generic-glibc/bits/unistd.h
index 4af036619d84eb74df3b53967409820ebb200c40..b476e58a43eae931da867dc9256f3f478e540fa1 100644
--- a/lib/libc/include/generic-glibc/bits/unistd.h
+++ b/lib/libc/include/generic-glibc/bits/unistd.h
@@ -1,5 +1,5 @@
 /* Checking macros for unistd functions.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/unistd_ext.h b/lib/libc/include/generic-glibc/bits/unistd_ext.h
index 691a57e30e185e8525fa7b1095402094efc2b1c9..04099e5c58577ddb009debda5f9b3c5bb2fa4879 100644
--- a/lib/libc/include/generic-glibc/bits/unistd_ext.h
+++ b/lib/libc/include/generic-glibc/bits/unistd_ext.h
@@ -1,5 +1,5 @@
 /* System-specific extensions of <unistd.h>, Linux version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/utmp.h b/lib/libc/include/generic-glibc/bits/utmp.h
index e945937f32de6b756a3673f86031dd873d7baa6d..f655ae6d78b036027ce7eda9a7e4c72b655be4da 100644
--- a/lib/libc/include/generic-glibc/bits/utmp.h
+++ b/lib/libc/include/generic-glibc/bits/utmp.h
@@ -1,5 +1,5 @@
 /* The `struct utmp' type, describing entries in the utmp file.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/utmpx.h b/lib/libc/include/generic-glibc/bits/utmpx.h
index ff77f8c4edd7e5c0ebc1c129ad3f13e262b9c90f..d8eed1815693a786843b3093e991ce85b879301b 100644
--- a/lib/libc/include/generic-glibc/bits/utmpx.h
+++ b/lib/libc/include/generic-glibc/bits/utmpx.h
@@ -1,5 +1,5 @@
 /* Structures and definitions for the user accounting database.  GNU version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/utsname.h b/lib/libc/include/generic-glibc/bits/utsname.h
index 625d7e1be6198596bdb27da093db3d4563785df7..0a2e52a78481464deae0d36434842a78b187d386 100644
--- a/lib/libc/include/generic-glibc/bits/utsname.h
+++ b/lib/libc/include/generic-glibc/bits/utsname.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/waitflags.h b/lib/libc/include/generic-glibc/bits/waitflags.h
index 07e69e60041ad43058bb5ab4eee09f9889c4c5a5..e3931616763b6a53755185b45532aab3ff5eaec0 100644
--- a/lib/libc/include/generic-glibc/bits/waitflags.h
+++ b/lib/libc/include/generic-glibc/bits/waitflags.h
@@ -1,5 +1,5 @@
 /* Definitions of flag bits for `waitpid' et al.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/waitstatus.h b/lib/libc/include/generic-glibc/bits/waitstatus.h
index bbc22daaf75cbcd2e8f27153891f61784e9a189e..a6cd056fff97ed26477424b22d268e4724dd6f40 100644
--- a/lib/libc/include/generic-glibc/bits/waitstatus.h
+++ b/lib/libc/include/generic-glibc/bits/waitstatus.h
@@ -1,5 +1,5 @@
 /* Definitions of status bits for `wait' et al.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/wchar-ldbl.h b/lib/libc/include/generic-glibc/bits/wchar-ldbl.h
index d13bf5f5b762b84ed93a34f13d576d48f4f56ef1..4814b417e5a92c9306c51178f22b3b745523c3bc 100644
--- a/lib/libc/include/generic-glibc/bits/wchar-ldbl.h
+++ b/lib/libc/include/generic-glibc/bits/wchar-ldbl.h
@@ -1,5 +1,5 @@
 /* -mlong-double-64 compatibility mode for <wchar.h> functions.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/wchar.h b/lib/libc/include/generic-glibc/bits/wchar.h
index bba9a4687a03e665edf24e0500b935afd73bbd77..936d2d555f857c6652f5d9e2982e7ae45dc51677 100644
--- a/lib/libc/include/generic-glibc/bits/wchar.h
+++ b/lib/libc/include/generic-glibc/bits/wchar.h
@@ -1,5 +1,5 @@
 /* wchar_t type related definitions.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/wchar2-decl.h b/lib/libc/include/generic-glibc/bits/wchar2-decl.h
index 2cf2f7baae5e148d48cd6b8224c2c40dfe580340..ce42c43864d9a77dd64f55ec52f052246a7abde0 100644
--- a/lib/libc/include/generic-glibc/bits/wchar2-decl.h
+++ b/lib/libc/include/generic-glibc/bits/wchar2-decl.h
@@ -1,5 +1,5 @@
 /* Checking macros for wchar functions.  Declarations only.
-   Copyright (C) 2004-2025 Free Software Foundation, Inc.
+   Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/wchar2.h b/lib/libc/include/generic-glibc/bits/wchar2.h
index 0bf64438d15f54b112c2af45d8c6c8a755f278c1..f61b3999b88993c4af48a43c96b2fc93fb26c0d3 100644
--- a/lib/libc/include/generic-glibc/bits/wchar2.h
+++ b/lib/libc/include/generic-glibc/bits/wchar2.h
@@ -1,5 +1,5 @@
 /* Checking macros for wchar functions.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/wctype-wchar.h b/lib/libc/include/generic-glibc/bits/wctype-wchar.h
index 3a73e92364cb19ef02f7a2a6d4d6b124aa55804c..00947a3bae561496b8ac13f96ac5eba1cf989e85 100644
--- a/lib/libc/include/generic-glibc/bits/wctype-wchar.h
+++ b/lib/libc/include/generic-glibc/bits/wctype-wchar.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/wordsize.h b/lib/libc/include/generic-glibc/bits/wordsize.h
index 487102dc9c5379e67fb093f388df3987cf894273..209ee56ebe7bc1a844173125e4a57ac9d071226b 100644
--- a/lib/libc/include/generic-glibc/bits/wordsize.h
+++ b/lib/libc/include/generic-glibc/bits/wordsize.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/bits/xopen_lim.h b/lib/libc/include/generic-glibc/bits/xopen_lim.h
index a6c7c2ca675a702a1b7b7ffdbf6cc2e35c003deb..658583a0bcc0a3b8f736ae8ae4098055d373bbbf 100644
--- a/lib/libc/include/generic-glibc/bits/xopen_lim.h
+++ b/lib/libc/include/generic-glibc/bits/xopen_lim.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/byteswap.h b/lib/libc/include/generic-glibc/byteswap.h
index 08f0786799d686176d2b19e541fbf40e643b9fcf..149dcfbc66a38c721096082f2ad1da53f3df958d 100644
--- a/lib/libc/include/generic-glibc/byteswap.h
+++ b/lib/libc/include/generic-glibc/byteswap.h
@@ -1,5 +1,5 @@
 /* Swap byte order for 16, 32 and 64 bit values
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/complex.h b/lib/libc/include/generic-glibc/complex.h
index 294bfb211f257f16eb4b55eca11d75d739f19d4b..87938c9e0b7438e2cbf9cfb640f520e36c1fbdae 100644
--- a/lib/libc/include/generic-glibc/complex.h
+++ b/lib/libc/include/generic-glibc/complex.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -33,6 +33,10 @@
 
 __BEGIN_DECLS
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_COMPLEX_H__ 202311L
+#endif
+
 /* We might need to add support for more compilers here.  But since ISO
    C99 is out hopefully all maintained compilers will soon provide the data
    types `float complex' and `double complex'.  */
diff --git a/lib/libc/include/generic-glibc/cpio.h b/lib/libc/include/generic-glibc/cpio.h
index 7671ebd3c1d8115d4942a03017219e29519b5d53..6ad236eaf2d59c67d982cf2fe5a97cef3e89b812 100644
--- a/lib/libc/include/generic-glibc/cpio.h
+++ b/lib/libc/include/generic-glibc/cpio.h
@@ -1,6 +1,6 @@
 /* Extended cpio format from POSIX.1.
    This file is part of the GNU C Library.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    NOTE: The canonical source of this file is maintained with the GNU cpio.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/ctype.h b/lib/libc/include/generic-glibc/ctype.h
index 61a1f174d0b78f4de31a4cc118d718a9c66e6173..53f76a935ad67c53942ee28300419ccebfac16d2 100644
--- a/lib/libc/include/generic-glibc/ctype.h
+++ b/lib/libc/include/generic-glibc/ctype.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/dirent.h b/lib/libc/include/generic-glibc/dirent.h
index 39457fdd801a3e843c9773092994de78f70969f9..2e3f38cc6fabaef45f0c910493633f83ecdfd4de 100644
--- a/lib/libc/include/generic-glibc/dirent.h
+++ b/lib/libc/include/generic-glibc/dirent.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/dlfcn.h b/lib/libc/include/generic-glibc/dlfcn.h
index fe5059b8d53fa8b6efecdf8a3f6d34c9b99c3134..f12e3d68cd4e31c856a23e1c63bd5a2d6b597146 100644
--- a/lib/libc/include/generic-glibc/dlfcn.h
+++ b/lib/libc/include/generic-glibc/dlfcn.h
@@ -1,5 +1,5 @@
 /* User functions for run-time dynamic loading.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/elf.h b/lib/libc/include/generic-glibc/elf.h
index 11dc6453b50e5ac3fd639598dfb28ecb9253ab8f..a45dea41210184770afb26e837fb86f03d226b9a 100644
--- a/lib/libc/include/generic-glibc/elf.h
+++ b/lib/libc/include/generic-glibc/elf.h
@@ -1,5 +1,5 @@
 /* This file defines standard ELF types, structures, and macros.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -924,7 +924,7 @@ typedef struct
 #define DT_SYMTAB_SHNDX	34		/* Address of SYMTAB_SHNDX section */
 #define DT_RELRSZ	35		/* Total size of RELR relative relocations */
 #define DT_RELR		36		/* Address of RELR relative relocations */
-#define DT_RELRENT	37		/* Size of one RELR relative relocaction */
+#define DT_RELRENT	37		/* Size of one RELR relative relocation */
 #define	DT_NUM		38		/* Number used */
 #define DT_LOOS		0x6000000d	/* Start of OS-specific */
 #define DT_HIOS		0x6ffff000	/* End of OS-specific */
diff --git a/lib/libc/include/generic-glibc/endian.h b/lib/libc/include/generic-glibc/endian.h
index 2636bb8497e12ed832895cb67b0238aec1591108..e74cf6021064fc63978747cbd9f64946e8069583 100644
--- a/lib/libc/include/generic-glibc/endian.h
+++ b/lib/libc/include/generic-glibc/endian.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/envz.h b/lib/libc/include/generic-glibc/envz.h
index 8e415b0be349c4d383e7bee4440b7ce4bc50805e..543b158f43115dc7bde2f67f647acf7378aca8d6 100644
--- a/lib/libc/include/generic-glibc/envz.h
+++ b/lib/libc/include/generic-glibc/envz.h
@@ -1,5 +1,5 @@
 /* Routines for dealing with '\0' separated environment vectors
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/err.h b/lib/libc/include/generic-glibc/err.h
index fa7e1f0952bf97d9cc337b4dcd56a85ba3f7fc11..015218379c7d384a354f940d55b6d7b04e311562 100644
--- a/lib/libc/include/generic-glibc/err.h
+++ b/lib/libc/include/generic-glibc/err.h
@@ -1,5 +1,5 @@
 /* 4.4BSD utility functions for error messages.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/errno.h b/lib/libc/include/generic-glibc/errno.h
index eeb7a227e02a7a32ddddff73d2fee5f6146e76ef..920eb12c990e994c7ff93379348004c6f0e579a0 100644
--- a/lib/libc/include/generic-glibc/errno.h
+++ b/lib/libc/include/generic-glibc/errno.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/error.h b/lib/libc/include/generic-glibc/error.h
index 47b5752843ea1fc19c837965b1a3c26d99980f20..29191c8255703d84247b97fe0a185433dcc1b7cc 100644
--- a/lib/libc/include/generic-glibc/error.h
+++ b/lib/libc/include/generic-glibc/error.h
@@ -1,5 +1,5 @@
 /* Declaration for error-reporting function
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/execinfo.h b/lib/libc/include/generic-glibc/execinfo.h
index 13ee44029426d6e34c732408a219b39b53f65a3e..ce6ba957393bf28abd59c38aef3537bde835de2e 100644
--- a/lib/libc/include/generic-glibc/execinfo.h
+++ b/lib/libc/include/generic-glibc/execinfo.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/fcntl.h b/lib/libc/include/generic-glibc/fcntl.h
index 51add4e1464e936bddd102d0cd39af9b9e023812..d2254d0441cd34df5354c13c9f064c42fcf8ba5c 100644
--- a/lib/libc/include/generic-glibc/fcntl.h
+++ b/lib/libc/include/generic-glibc/fcntl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -352,4 +352,4 @@ extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
 
 __END_DECLS
 
-#endif /* fcntl.h  */
+#endif /* fcntl.h  */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/features-time64.h b/lib/libc/include/generic-glibc/features-time64.h
index 5842168a3cd53bbfbecc5fb698e9362e40478d21..cd6c8d5492125343313e8ace5b4ce376bd92c7c5 100644
--- a/lib/libc/include/generic-glibc/features-time64.h
+++ b/lib/libc/include/generic-glibc/features-time64.h
@@ -1,5 +1,5 @@
 /* Features part to handle 64-bit time_t support.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/features.h b/lib/libc/include/generic-glibc/features.h
index 8a918c60176d685f3d151830a0c173691f88538d..5ef3af3beb712cf7cbb02d380cc68ef6f1b18d4d 100644
--- a/lib/libc/include/generic-glibc/features.h
+++ b/lib/libc/include/generic-glibc/features.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -44,9 +44,11 @@
 			if >=199506L, add IEEE Std 1003.1c-1995;
 			if >=200112L, all of IEEE 1003.1-2004
 			if >=200809L, all of IEEE 1003.1-2008
+			if >=202405L, all of IEEE 1003.1-2024
    _XOPEN_SOURCE	Includes POSIX and XPG things.  Set to 500 if
 			Single Unix conformance is wanted, to 600 for the
-			sixth revision, to 700 for the seventh revision.
+			sixth revision, to 700 for the seventh revision,
+			to 800 for the eighth revision.
    _XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions.
    _LARGEFILE_SOURCE	Some more functions for correct standard I/O.
    _LARGEFILE64_SOURCE	Additional functionality from LFS for large files.
@@ -69,7 +71,7 @@
    options such as `-std=c99', define __STRICT_ANSI__.  If none of
    these are defined, or if _DEFAULT_SOURCE is defined, the default is
    to have _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to
-   200809L, as well as enabling miscellaneous functions from BSD and
+   202405L, as well as enabling miscellaneous functions from BSD and
    SVID.  If more than one of these are defined, they accumulate.  For
    example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE together
    give you ISO C, 1003.1, and 1003.2, but nothing else.
@@ -96,6 +98,8 @@
    __USE_XOPEN2KXSI     Define XPG6 XSI things.
    __USE_XOPEN2K8       Define XPG7 things.
    __USE_XOPEN2K8XSI    Define XPG7 XSI things.
+   __USE_XOPEN2K24      Define XPG8 things.
+   __USE_XOPEN2K24XSI   Define XPG8 XSI things.
    __USE_LARGEFILE	Define correct standard I/O things.
    __USE_LARGEFILE64	Define LFS things with separate names.
    __USE_FILE_OFFSET64	Define 64bit interface as default.
@@ -141,6 +145,8 @@
 #undef	__USE_XOPEN2KXSI
 #undef	__USE_XOPEN2K8
 #undef	__USE_XOPEN2K8XSI
+#undef	__USE_XOPEN2K24
+#undef	__USE_XOPEN2K24XSI
 #undef	__USE_LARGEFILE
 #undef	__USE_LARGEFILE64
 #undef	__USE_FILE_OFFSET64
@@ -162,14 +168,6 @@
 # define __KERNEL_STRICT_NAMES
 #endif
 
-/* Major and minor version number of the GNU C library package.  Use
-   these macros to test for features in specific releases.  */
-#define	__GLIBC__	2
-/* Zig patch: we pass `-D__GLIBC_MINOR__=XX` depending on the target. */
-
-#define __GLIBC_PREREQ(maj, min) \
-	((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
-
 /* Convenience macro to test the version of gcc.
    Use like this:
    #if __GNUC_PREREQ (2,8)
@@ -231,9 +229,9 @@
 # undef  _POSIX_SOURCE
 # define _POSIX_SOURCE	1
 # undef  _POSIX_C_SOURCE
-# define _POSIX_C_SOURCE	200809L
+# define _POSIX_C_SOURCE	202405L
 # undef  _XOPEN_SOURCE
-# define _XOPEN_SOURCE	700
+# define _XOPEN_SOURCE	800
 # undef  _XOPEN_SOURCE_EXTENDED
 # define _XOPEN_SOURCE_EXTENDED	1
 # undef	 _LARGEFILE64_SOURCE
@@ -314,7 +312,7 @@
 #endif
 
 /* If none of the ANSI/POSIX macros are defined, or if _DEFAULT_SOURCE
-   is defined, use POSIX.1-2008 (or another version depending on
+   is defined, use POSIX.1-2024 (or another version depending on
    _XOPEN_SOURCE).  */
 #ifdef _DEFAULT_SOURCE
 # if !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE
@@ -323,7 +321,7 @@
 # undef  _POSIX_SOURCE
 # define _POSIX_SOURCE	1
 # undef  _POSIX_C_SOURCE
-# define _POSIX_C_SOURCE	200809L
+# define _POSIX_C_SOURCE	202405L
 #endif
 
 #if ((!defined __STRICT_ANSI__					\
@@ -336,8 +334,10 @@
 #  define _POSIX_C_SOURCE	199506L
 # elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 700
 #  define _POSIX_C_SOURCE	200112L
-# else
+# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 800
 #  define _POSIX_C_SOURCE	200809L
+# else
+#  define _POSIX_C_SOURCE	202405L
 # endif
 # define __USE_POSIX_IMPLICITLY	1
 #endif
@@ -387,6 +387,10 @@
 # define _ATFILE_SOURCE	1
 #endif
 
+#if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 202405L
+# define __USE_XOPEN2K24	1
+#endif
+
 #ifdef	_XOPEN_SOURCE
 # define __USE_XOPEN	1
 # if (_XOPEN_SOURCE - 0) >= 500
@@ -398,6 +402,10 @@
 #   if (_XOPEN_SOURCE - 0) >= 700
 #    define __USE_XOPEN2K8	1
 #    define __USE_XOPEN2K8XSI	1
+#    if (_XOPEN_SOURCE - 0) >= 800
+#     define __USE_XOPEN2K24	1
+#     define __USE_XOPEN2K24XSI	1
+#    endif
 #   endif
 #   define __USE_XOPEN2K	1
 #   define __USE_XOPEN2KXSI	1
@@ -534,6 +542,14 @@
 #undef  __GNU_LIBRARY__
 #define __GNU_LIBRARY__ 6
 
+/* Major and minor version number of the GNU C library package.  Use
+   these macros to test for features in specific releases.  */
+#define	__GLIBC__	2
+/* zig patch: we pass `-D__GLIBC_MINOR__=XX` depending on the target. */
+
+#define __GLIBC_PREREQ(maj, min) \
+	((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
+
 /* This is here only because every header file already includes this one.  */
 #ifndef __ASSEMBLER__
 # ifndef _SYS_CDEFS_H
@@ -552,7 +568,7 @@
 /* Decide whether we can define 'extern inline' functions in headers.  */
 #if __GNUC_PREREQ (2, 7) && defined __OPTIMIZE__ \
     && !defined __OPTIMIZE_SIZE__ && !defined __NO_INLINE__ \
-    && defined __extern_inline
+    && defined __extern_inline && !(defined __clang__ && defined _LIBC)
 # define __USE_EXTERN_INLINES	1
 #endif
 
diff --git a/lib/libc/include/generic-glibc/fenv.h b/lib/libc/include/generic-glibc/fenv.h
index 5c9fc5d2c53eed6f7685dee525e5d0626d9eeb4e..e924477486a6c839add7020ff61888275a312815 100644
--- a/lib/libc/include/generic-glibc/fenv.h
+++ b/lib/libc/include/generic-glibc/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -65,6 +65,10 @@
 
 __BEGIN_DECLS
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_FENV_H__ 202311L
+#endif
+
 /* Floating-point exception handling.  */
 
 /* Clear the supported exceptions represented by EXCEPTS.  */
diff --git a/lib/libc/include/generic-glibc/finclude/math-vector-fortran.h b/lib/libc/include/generic-glibc/finclude/math-vector-fortran.h
index 76faab88b48400b8252f56b2db6d741742b21ebb..dc777d841afe06162f3290493d65d8c7cabfad59 100644
--- a/lib/libc/include/generic-glibc/finclude/math-vector-fortran.h
+++ b/lib/libc/include/generic-glibc/finclude/math-vector-fortran.h
@@ -1,5 +1,5 @@
 ! Platform-specific declarations of SIMD math functions for Fortran. -*- f90 -*-
-!   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+!   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 !   This file is part of the GNU C Library.
 !
 !   The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/fmtmsg.h b/lib/libc/include/generic-glibc/fmtmsg.h
index 3d56c4d30e2db0aadd15f476eb964c61d389b35e..8ad0abc1a379e87c548575416d95601ad2d43c7e 100644
--- a/lib/libc/include/generic-glibc/fmtmsg.h
+++ b/lib/libc/include/generic-glibc/fmtmsg.h
@@ -1,5 +1,5 @@
 /* Message display handling.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/fnmatch.h b/lib/libc/include/generic-glibc/fnmatch.h
index b13fe45bfe350f97d45947816eeebcfbaa2e326f..e7909cc1d9b695075a3f2807d4d3e4570de1d406 100644
--- a/lib/libc/include/generic-glibc/fnmatch.h
+++ b/lib/libc/include/generic-glibc/fnmatch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/fpregdef.h b/lib/libc/include/generic-glibc/fpregdef.h
index e4b38635cdc776fc6a123c79256d110bab5f6f31..a0a3d5b7d336c9a783a62e2cfbf4c3b99d921ebe 100644
--- a/lib/libc/include/generic-glibc/fpregdef.h
+++ b/lib/libc/include/generic-glibc/fpregdef.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/fpu_control.h b/lib/libc/include/generic-glibc/fpu_control.h
index 5a1c5154714dd46cad3df09d192a8f4a4897248b..5c893891b0bc34e0429e3495060edc076f1870d3 100644
--- a/lib/libc/include/generic-glibc/fpu_control.h
+++ b/lib/libc/include/generic-glibc/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.  Mips version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/fts.h b/lib/libc/include/generic-glibc/fts.h
index 42cf8da8e98cc339a87a805c582855f5d189bd4f..97d0f4a8a299fb9f4e439232fc9e33cd851b605e 100644
--- a/lib/libc/include/generic-glibc/fts.h
+++ b/lib/libc/include/generic-glibc/fts.h
@@ -1,5 +1,5 @@
 /* File tree traversal functions declarations.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/ftw.h b/lib/libc/include/generic-glibc/ftw.h
index 227a13af6f5d42d957862b011e9527e00fbb6b13..9040142e6720dba0f38db5ac27bb5b9173d28f8b 100644
--- a/lib/libc/include/generic-glibc/ftw.h
+++ b/lib/libc/include/generic-glibc/ftw.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/gconv.h b/lib/libc/include/generic-glibc/gconv.h
index 676935099f84490b4212d7611c11d08b40bacb95..cb8d891822f99dbab8e84be9214131987ec1e9cb 100644
--- a/lib/libc/include/generic-glibc/gconv.h
+++ b/lib/libc/include/generic-glibc/gconv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/getopt.h b/lib/libc/include/generic-glibc/getopt.h
index 33e20a25586d02187654ac494bc59a8f427e05f2..5d68fc3daf06c894825e873d400fcc0bd415b73b 100644
--- a/lib/libc/include/generic-glibc/getopt.h
+++ b/lib/libc/include/generic-glibc/getopt.h
@@ -1,5 +1,5 @@
 /* Declarations for getopt.
-   Copyright (C) 1989-2025 Free Software Foundation, Inc.
+   Copyright (C) 1989-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Unlike the bulk of the getopt implementation, this file is NOT part
    of gnulib; gnulib also has a getopt.h but it is different.
diff --git a/lib/libc/include/generic-glibc/glob.h b/lib/libc/include/generic-glibc/glob.h
index 14340f5fae38311cc1fdb7d72943fe30f037a626..81fb6432529d5718769b466c48ec0d2478e838ae 100644
--- a/lib/libc/include/generic-glibc/glob.h
+++ b/lib/libc/include/generic-glibc/glob.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/gnu-versions.h b/lib/libc/include/generic-glibc/gnu-versions.h
index e46400d801dcf2d8ff28d628ad27d409f1f58044..e750f1f0c45eedb05d0be05b17c71a2153e373f8 100644
--- a/lib/libc/include/generic-glibc/gnu-versions.h
+++ b/lib/libc/include/generic-glibc/gnu-versions.h
@@ -1,5 +1,5 @@
 /* Header with interface version macros for library pieces copied elsewhere.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/gnu/libc-version.h b/lib/libc/include/generic-glibc/gnu/libc-version.h
index c432a2c11407790d710e21e4315c75ea33501825..95099e7cb491245c06bdae938b0a2db1d4af30f8 100644
--- a/lib/libc/include/generic-glibc/gnu/libc-version.h
+++ b/lib/libc/include/generic-glibc/gnu/libc-version.h
@@ -1,5 +1,5 @@
 /* Interface to GNU libc specific functions for version information.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/grp.h b/lib/libc/include/generic-glibc/grp.h
index e6367f2252ada31de2a249801458868105eef6c6..adf73f26759c029c3b939b8bb651ce6502bee69b 100644
--- a/lib/libc/include/generic-glibc/grp.h
+++ b/lib/libc/include/generic-glibc/grp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/gshadow.h b/lib/libc/include/generic-glibc/gshadow.h
index 7e73c0d70c5455c20997db60d14319f4240a6712..88f774a491b85bed81f37aef96515f212f526fa0 100644
--- a/lib/libc/include/generic-glibc/gshadow.h
+++ b/lib/libc/include/generic-glibc/gshadow.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2009-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2009-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/iconv.h b/lib/libc/include/generic-glibc/iconv.h
index 3f45af196833f5651bfbf19be7801c098be53531..a4fb9579e5dcc1b9e99fcf746aa66fee581797f5 100644
--- a/lib/libc/include/generic-glibc/iconv.h
+++ b/lib/libc/include/generic-glibc/iconv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/ieee754.h b/lib/libc/include/generic-glibc/ieee754.h
index 7eb1f762ac616ea500ed717af9f62a56426d5eb3..dc8f15e2398f519c2716e8c65c3890d3898aef02 100644
--- a/lib/libc/include/generic-glibc/ieee754.h
+++ b/lib/libc/include/generic-glibc/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/ifaddrs.h b/lib/libc/include/generic-glibc/ifaddrs.h
index 41bd1048f8f83adc939c332419bb20ae45d2d339..86737f63d3c91e2f2e198b3be428eb71d38cd762 100644
--- a/lib/libc/include/generic-glibc/ifaddrs.h
+++ b/lib/libc/include/generic-glibc/ifaddrs.h
@@ -1,5 +1,5 @@
 /* ifaddrs.h -- declarations for getting network interface addresses
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/inttypes.h b/lib/libc/include/generic-glibc/inttypes.h
index be384f223e52627c68d4feb99c08ab0b3e282ed5..345bed9faa1f64a9b116504872c18249f598e3ea 100644
--- a/lib/libc/include/generic-glibc/inttypes.h
+++ b/lib/libc/include/generic-glibc/inttypes.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -23,6 +23,11 @@
 #define _INTTYPES_H	1
 
 #include <features.h>
+
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_INTTYPES_H__ 202311L
+#endif
+
 /* Get the type definitions.  */
 #include <stdint.h>
 
@@ -51,97 +56,97 @@ typedef wchar_t __gwchar_t;
 /* Macros for printing format specifiers.  */
 
 /* Decimal notation.  */
-# define PRId8		"d"
-# define PRId16		"d"
+# define PRId8		"hhd"
+# define PRId16		"hd"
 # define PRId32		"d"
 # define PRId64		__PRI64_PREFIX "d"
 
-# define PRIdLEAST8	"d"
-# define PRIdLEAST16	"d"
+# define PRIdLEAST8	"hhd"
+# define PRIdLEAST16	"hd"
 # define PRIdLEAST32	"d"
 # define PRIdLEAST64	__PRI64_PREFIX "d"
 
-# define PRIdFAST8	"d"
+# define PRIdFAST8	"hhd"
 # define PRIdFAST16	__PRIPTR_PREFIX "d"
 # define PRIdFAST32	__PRIPTR_PREFIX "d"
 # define PRIdFAST64	__PRI64_PREFIX "d"
 
 
-# define PRIi8		"i"
-# define PRIi16		"i"
+# define PRIi8		"hhi"
+# define PRIi16		"hi"
 # define PRIi32		"i"
 # define PRIi64		__PRI64_PREFIX "i"
 
-# define PRIiLEAST8	"i"
-# define PRIiLEAST16	"i"
+# define PRIiLEAST8	"hhi"
+# define PRIiLEAST16	"hi"
 # define PRIiLEAST32	"i"
 # define PRIiLEAST64	__PRI64_PREFIX "i"
 
-# define PRIiFAST8	"i"
+# define PRIiFAST8	"hhi"
 # define PRIiFAST16	__PRIPTR_PREFIX "i"
 # define PRIiFAST32	__PRIPTR_PREFIX "i"
 # define PRIiFAST64	__PRI64_PREFIX "i"
 
 /* Octal notation.  */
-# define PRIo8		"o"
-# define PRIo16		"o"
+# define PRIo8		"hho"
+# define PRIo16		"ho"
 # define PRIo32		"o"
 # define PRIo64		__PRI64_PREFIX "o"
 
-# define PRIoLEAST8	"o"
-# define PRIoLEAST16	"o"
+# define PRIoLEAST8	"hho"
+# define PRIoLEAST16	"ho"
 # define PRIoLEAST32	"o"
 # define PRIoLEAST64	__PRI64_PREFIX "o"
 
-# define PRIoFAST8	"o"
+# define PRIoFAST8	"hho"
 # define PRIoFAST16	__PRIPTR_PREFIX "o"
 # define PRIoFAST32	__PRIPTR_PREFIX "o"
 # define PRIoFAST64	__PRI64_PREFIX "o"
 
 /* Unsigned integers.  */
-# define PRIu8		"u"
-# define PRIu16		"u"
+# define PRIu8		"hhu"
+# define PRIu16		"hu"
 # define PRIu32		"u"
 # define PRIu64		__PRI64_PREFIX "u"
 
-# define PRIuLEAST8	"u"
-# define PRIuLEAST16	"u"
+# define PRIuLEAST8	"hhu"
+# define PRIuLEAST16	"hu"
 # define PRIuLEAST32	"u"
 # define PRIuLEAST64	__PRI64_PREFIX "u"
 
-# define PRIuFAST8	"u"
+# define PRIuFAST8	"hhu"
 # define PRIuFAST16	__PRIPTR_PREFIX "u"
 # define PRIuFAST32	__PRIPTR_PREFIX "u"
 # define PRIuFAST64	__PRI64_PREFIX "u"
 
 /* lowercase hexadecimal notation.  */
-# define PRIx8		"x"
-# define PRIx16		"x"
+# define PRIx8		"hhx"
+# define PRIx16		"hx"
 # define PRIx32		"x"
 # define PRIx64		__PRI64_PREFIX "x"
 
-# define PRIxLEAST8	"x"
-# define PRIxLEAST16	"x"
+# define PRIxLEAST8	"hhx"
+# define PRIxLEAST16	"hx"
 # define PRIxLEAST32	"x"
 # define PRIxLEAST64	__PRI64_PREFIX "x"
 
-# define PRIxFAST8	"x"
+# define PRIxFAST8	"hhx"
 # define PRIxFAST16	__PRIPTR_PREFIX "x"
 # define PRIxFAST32	__PRIPTR_PREFIX "x"
 # define PRIxFAST64	__PRI64_PREFIX "x"
 
 /* UPPERCASE hexadecimal notation.  */
-# define PRIX8		"X"
-# define PRIX16		"X"
+# define PRIX8		"hhX"
+# define PRIX16		"hX"
 # define PRIX32		"X"
 # define PRIX64		__PRI64_PREFIX "X"
 
-# define PRIXLEAST8	"X"
-# define PRIXLEAST16	"X"
+# define PRIXLEAST8	"hhX"
+# define PRIXLEAST16	"hX"
 # define PRIXLEAST32	"X"
 # define PRIXLEAST64	__PRI64_PREFIX "X"
 
-# define PRIXFAST8	"X"
+# define PRIXFAST8	"hhX"
 # define PRIXFAST16	__PRIPTR_PREFIX "X"
 # define PRIXFAST32	__PRIPTR_PREFIX "X"
 # define PRIXFAST64	__PRI64_PREFIX "X"
@@ -166,17 +171,17 @@ typedef wchar_t __gwchar_t;
 
 /* Binary notation.  */
 # if __GLIBC_USE (ISOC23)
-#  define PRIb8		"b"
-#  define PRIb16	"b"
+#  define PRIb8		"hhb"
+#  define PRIb16	"hb"
 #  define PRIb32	"b"
 #  define PRIb64	__PRI64_PREFIX "b"
 
-#  define PRIbLEAST8	"b"
-#  define PRIbLEAST16	"b"
+#  define PRIbLEAST8	"hhb"
+#  define PRIbLEAST16	"hb"
 #  define PRIbLEAST32	"b"
 #  define PRIbLEAST64	__PRI64_PREFIX "b"
 
-#  define PRIbFAST8	"b"
+#  define PRIbFAST8	"hhb"
 #  define PRIbFAST16	__PRIPTR_PREFIX "b"
 #  define PRIbFAST32	__PRIPTR_PREFIX "b"
 #  define PRIbFAST64	__PRI64_PREFIX "b"
@@ -184,17 +189,17 @@ typedef wchar_t __gwchar_t;
 #  define PRIbMAX	__PRI64_PREFIX "b"
 #  define PRIbPTR	__PRIPTR_PREFIX "b"
 
-#  define PRIB8		"B"
-#  define PRIB16	"B"
+#  define PRIB8		"hhB"
+#  define PRIB16	"hB"
 #  define PRIB32	"B"
 #  define PRIB64	__PRI64_PREFIX "B"
 
-#  define PRIBLEAST8	"B"
-#  define PRIBLEAST16	"B"
+#  define PRIBLEAST8	"hhB"
+#  define PRIBLEAST16	"hB"
 #  define PRIBLEAST32	"B"
 #  define PRIBLEAST64	__PRI64_PREFIX "B"
 
-#  define PRIBFAST8	"B"
+#  define PRIBFAST8	"hhB"
 #  define PRIBFAST16	__PRIPTR_PREFIX "B"
 #  define PRIBFAST32	__PRIPTR_PREFIX "B"
 #  define PRIBFAST64	__PRI64_PREFIX "B"
@@ -352,7 +357,7 @@ extern intmax_t imaxabs (intmax_t __n) __THROW __attribute__ ((__const__));
 
 
 #if __GLIBC_USE (ISOC2Y)
-extern uintmax_t uimaxabs (intmax_t __n) __THROW __attribute__ ((__const__));
+extern uintmax_t umaxabs (intmax_t __n) __THROW __attribute__ ((__const__));
 #endif
 
 /* Return the `imaxdiv_t' representation of the value of NUMER over DENOM. */
diff --git a/lib/libc/include/generic-glibc/langinfo.h b/lib/libc/include/generic-glibc/langinfo.h
index 3a5e70bd239a967ee1b8665aad84ad079ad852e0..cbaccf9ad27a712b021d8414bd2cc339adddc490 100644
--- a/lib/libc/include/generic-glibc/langinfo.h
+++ b/lib/libc/include/generic-glibc/langinfo.h
@@ -1,5 +1,5 @@
 /* Access to locale-dependent parameters.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/libgen.h b/lib/libc/include/generic-glibc/libgen.h
index 4e489e79e3ac807e98571cef98becaf984f89615..981b01cd1e6201c7f1cf07923e05b3fa1f929b06 100644
--- a/lib/libc/include/generic-glibc/libgen.h
+++ b/lib/libc/include/generic-glibc/libgen.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/libintl.h b/lib/libc/include/generic-glibc/libintl.h
index 1032dd899e71a01c4646b7267fb06b1feb9fecc5..4ca85c7bdbada38f5c9108dd305486cfc60801da 100644
--- a/lib/libc/include/generic-glibc/libintl.h
+++ b/lib/libc/include/generic-glibc/libintl.h
@@ -1,5 +1,5 @@
 /* Message catalogs for internationalization.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    This file is derived from the file libgettext.h in the GNU gettext package.
 
diff --git a/lib/libc/include/generic-glibc/limits.h b/lib/libc/include/generic-glibc/limits.h
index 88a0949f70d3c8a24380cbcbdbbf71bde0251fed..f495504af8cd3e9036fa7f7f83752f0aa71aed76 100644
--- a/lib/libc/include/generic-glibc/limits.h
+++ b/lib/libc/include/generic-glibc/limits.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -180,7 +180,7 @@
 
 /* The macros for _Bool are not defined by GCC's <limits.h> before GCC
    11, or if _GNU_SOURCE is defined rather than enabling C23 support
-   with -std.  */
+   with -std; likewise for the version macro before GCC 13.  */
 #if __GLIBC_USE (ISOC23)
 # ifndef BOOL_MAX
 #  define BOOL_MAX 1
@@ -188,6 +188,9 @@
 # ifndef BOOL_WIDTH
 #  define BOOL_WIDTH 1
 # endif
+# ifndef __STDC_VERSION_LIMITS_H__
+#  define __STDC_VERSION_LIMITS_H__ 202311L
+# endif
 #endif
 
 #ifdef	__USE_POSIX
diff --git a/lib/libc/include/generic-glibc/link.h b/lib/libc/include/generic-glibc/link.h
index 23fd442437dca38e9446600e2131f4bc8a07ad77..7c0e06f979b557eaad048982f468f50edf76cd2e 100644
--- a/lib/libc/include/generic-glibc/link.h
+++ b/lib/libc/include/generic-glibc/link.h
@@ -1,6 +1,6 @@
 /* Data structure for communication from the run-time dynamic linker for
    loaded ELF shared objects.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/locale.h b/lib/libc/include/generic-glibc/locale.h
index 405a96d9f2e870cc9b0a7af0d2dc5f936767ee31..99b02fcf828366bb396b9c0b43da33b246d98931 100644
--- a/lib/libc/include/generic-glibc/locale.h
+++ b/lib/libc/include/generic-glibc/locale.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/malloc.h b/lib/libc/include/generic-glibc/malloc.h
index 187457d42131e12c92649a85f52ef0d62c5ca5f9..7332af4a7255f973bf99abaf65e03b2ee9bb0315 100644
--- a/lib/libc/include/generic-glibc/malloc.h
+++ b/lib/libc/include/generic-glibc/malloc.h
@@ -1,5 +1,5 @@
 /* Prototypes and definition for malloc implementation.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
@@ -89,11 +89,11 @@ struct mallinfo
 {
   int arena;    /* non-mmapped space allocated from system */
   int ordblks;  /* number of free chunks */
-  int smblks;   /* number of fastbin blocks */
+  int smblks;   /* number of fastbin blocks (deprecated) */
   int hblks;    /* number of mmapped regions */
   int hblkhd;   /* space in mmapped regions */
   int usmblks;  /* always 0, preserved for backwards compatibility */
-  int fsmblks;  /* space available in freed fastbin blocks */
+  int fsmblks;  /* space available in freed fastbin blocks (deprecated) */
   int uordblks; /* total allocated space */
   int fordblks; /* total free space */
   int keepcost; /* top-most, releasable (via malloc_trim) space */
@@ -106,11 +106,11 @@ struct mallinfo2
 {
   size_t arena;    /* non-mmapped space allocated from system */
   size_t ordblks;  /* number of free chunks */
-  size_t smblks;   /* number of fastbin blocks */
+  size_t smblks;   /* number of fastbin blocks (deprecated) */
   size_t hblks;    /* number of mmapped regions */
   size_t hblkhd;   /* space in mmapped regions */
   size_t usmblks;  /* always 0, preserved for backwards compatibility */
-  size_t fsmblks;  /* space available in freed fastbin blocks */
+  size_t fsmblks;  /* space available in freed fastbin blocks (deprecated) */
   size_t uordblks; /* total allocated space */
   size_t fordblks; /* total free space */
   size_t keepcost; /* top-most, releasable (via malloc_trim) space */
@@ -164,4 +164,4 @@ extern void malloc_stats (void) __THROW;
 extern int malloc_info (int __options, FILE *__fp) __THROW;
 
 __END_DECLS
-#endif /* malloc.h */
+#endif /* malloc.h */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/math.h b/lib/libc/include/generic-glibc/math.h
index 2260d5d0b47e188a38d5a42eb32d39eecbc95f1e..99e75ab8435eb066422a335b40bcebe8058f1942 100644
--- a/lib/libc/include/generic-glibc/math.h
+++ b/lib/libc/include/generic-glibc/math.h
@@ -1,5 +1,5 @@
 /* Declarations for math functions.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -33,15 +33,16 @@
 
 __BEGIN_DECLS
 
-/* Get definitions of __intmax_t and __uintmax_t.  */
-#include <bits/types.h>
-
 /* Get machine-dependent vector math functions declarations.  */
 #include <bits/math-vector.h>
 
 /* Gather machine dependent type support.  */
 #include <bits/floatn.h>
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_MATH_H__ 202311L
+#endif
+
 /* Value returned on overflow.  With IEEE 754 floating point, this is
    +Infinity, otherwise the largest representable positive value.  */
 #if __GNUC_PREREQ (3, 3)
@@ -162,34 +163,201 @@ __BEGIN_DECLS
 		to evaluate `float' expressions
     double_t	floating-point type at least as wide as `double' used
 		to evaluate `double' expressions
+
+   TS 18661-3 and C23 additionally define long_double_t and _FloatN_t.
 */
-# if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
+# if __GLIBC_FLT_EVAL_METHOD == 0
 typedef float float_t;
 typedef double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef float _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float32 _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 1
 typedef double float_t;
 typedef double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef double _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef double _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 2
 typedef long double float_t;
 typedef long double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef long double _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef long double _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+#    ifdef __NO_LONG_DOUBLE_MATH
+typedef _Float64 _Float64_t;
+#    else
+typedef long double _Float64_t;
+#    endif
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
+# elif __GLIBC_FLT_EVAL_METHOD == 16
+typedef float float_t;
+typedef double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef _Float16 _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float32 _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 32
-typedef _Float32 float_t;
+typedef float float_t;
 typedef double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef _Float32 _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float32 _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 33
 typedef _Float32x float_t;
-typedef _Float32x double_t;
+typedef double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef _Float32x _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float32x _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 64
 typedef _Float64 float_t;
-typedef _Float64 double_t;
+typedef double double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef _Float64 _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float64 _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 65
 typedef _Float64x float_t;
 typedef _Float64x double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+typedef long double long_double_t;
+#   if __HAVE_FLOAT16
+typedef _Float64x _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float64x _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float64x _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 128
 typedef _Float128 float_t;
 typedef _Float128 double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+#   if __HAVE_FLOAT128_UNLIKE_LDBL && __LDBL_MANT_DIG__ != 106
+typedef _Float128 long_double_t;
+#   else
+typedef long double long_double_t;
+#   endif
+#   if __HAVE_FLOAT16
+typedef _Float128 _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float128 _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float128 _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128 _Float128_t;
+#   endif
+#  endif
 # elif __GLIBC_FLT_EVAL_METHOD == 129
 typedef _Float128x float_t;
 typedef _Float128x double_t;
+#  if __GLIBC_USE (IEC_60559_TYPES_EXT)
+#   if __LDBL_MANT_DIG__ != 106
+typedef _Float128x long_double_t;
+#   else
+typedef long double long_double_t;
+#   endif
+#   if __HAVE_FLOAT16
+typedef _Float128x _Float16_t;
+#   endif
+#   if __HAVE_FLOAT32
+typedef _Float128x _Float32_t;
+#   endif
+#   if __HAVE_FLOAT64
+typedef _Float128x _Float64_t;
+#   endif
+#   if __HAVE_FLOAT128
+typedef _Float128x _Float128_t;
+#   endif
+#  endif
 # else
 #  error "Unknown __GLIBC_FLT_EVAL_METHOD"
 # endif
@@ -1265,7 +1433,7 @@ iszero (__T __val)
 #endif
 
 #ifdef __USE_ISOC99
-# if __GNUC_PREREQ (3, 1)
+# if __GNUC_PREREQ (3, 1) && !defined __clang__
 /* ISO C99 defines some macros to compare number while taking care for
    unordered numbers.  Many FPUs provide special instructions to support
    these operations.  Generic support in GCC for these as builtins went
diff --git a/lib/libc/include/generic-glibc/mcheck.h b/lib/libc/include/generic-glibc/mcheck.h
index f8c86b7aea38ce353deb07790ecb0b31577ac15b..b189ae152426d083d25bd103303481542185d6d4 100644
--- a/lib/libc/include/generic-glibc/mcheck.h
+++ b/lib/libc/include/generic-glibc/mcheck.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/memory.h b/lib/libc/include/generic-glibc/memory.h
index 9dc8823e45ab36586b5265a89d9de933f30c54fb..7c6d7d96e91a0b52e3277056709148b819a204e5 100644
--- a/lib/libc/include/generic-glibc/memory.h
+++ b/lib/libc/include/generic-glibc/memory.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/mntent.h b/lib/libc/include/generic-glibc/mntent.h
index 3bd819b322cca1fb5ebf57d6bcc0870390984979..352739b033bf1c89b0400bc3ade9daa4e74d89f8 100644
--- a/lib/libc/include/generic-glibc/mntent.h
+++ b/lib/libc/include/generic-glibc/mntent.h
@@ -1,5 +1,5 @@
 /* Utilities for reading/writing fstab, mtab, etc.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/monetary.h b/lib/libc/include/generic-glibc/monetary.h
index 348e044f7e2464795c64e494b1b9f480ce70bec6..046a7ee1c1a12dcd4a8d14dc9c31352ec01d2ce1 100644
--- a/lib/libc/include/generic-glibc/monetary.h
+++ b/lib/libc/include/generic-glibc/monetary.h
@@ -1,5 +1,5 @@
 /* Header file for monetary value formatting functions.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/mqueue.h b/lib/libc/include/generic-glibc/mqueue.h
index 0e5d4bf733fbf306219200dc3fc756669253f147..7b9f7a54ee3a8a4ab522b049e34a7ee9d7fa20eb 100644
--- a/lib/libc/include/generic-glibc/mqueue.h
+++ b/lib/libc/include/generic-glibc/mqueue.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/ethernet.h b/lib/libc/include/generic-glibc/net/ethernet.h
index ff9a5250d0b53916d443a6888581c2ea13b36352..6c2bb4d64d6e126377e62924a1effc7de930ca82 100644
--- a/lib/libc/include/generic-glibc/net/ethernet.h
+++ b/lib/libc/include/generic-glibc/net/ethernet.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/if.h b/lib/libc/include/generic-glibc/net/if.h
index 71e70c3baf790adc81981756cc836d1ff5a4778d..759016aec6fecb5ddfece30e76e585df586c9678 100644
--- a/lib/libc/include/generic-glibc/net/if.h
+++ b/lib/libc/include/generic-glibc/net/if.h
@@ -1,5 +1,5 @@
 /* net/if.h -- declarations for inquiring about network interfaces
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/if_arp.h b/lib/libc/include/generic-glibc/net/if_arp.h
index 59d9a84b53b1c949d22c2bf1b2dc22a4054d7352..929a85efbc507cb135032afab979355ac7caf907 100644
--- a/lib/libc/include/generic-glibc/net/if_arp.h
+++ b/lib/libc/include/generic-glibc/net/if_arp.h
@@ -1,5 +1,5 @@
 /* Definitions for Address Resolution Protocol.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/if_packet.h b/lib/libc/include/generic-glibc/net/if_packet.h
index f89f7f9d8aebf7f3803c0bdae55551012f45ac08..fe64c7cf3e501d01b92811c0dc6f3e0a4136ad49 100644
--- a/lib/libc/include/generic-glibc/net/if_packet.h
+++ b/lib/libc/include/generic-glibc/net/if_packet.h
@@ -1,5 +1,5 @@
 /* Definitions for use with Linux SOCK_PACKET sockets.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/if_shaper.h b/lib/libc/include/generic-glibc/net/if_shaper.h
index 51c5716cc9cded1b5aacfbf1a13cb4e2a6d46cd1..45b0e17f05326c74a77e123a6b505038749be65a 100644
--- a/lib/libc/include/generic-glibc/net/if_shaper.h
+++ b/lib/libc/include/generic-glibc/net/if_shaper.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/if_slip.h b/lib/libc/include/generic-glibc/net/if_slip.h
index a46311d84af576a70cf42d25b6fbd4a3823e9647..08472f5c2d4f4c1a30128ab67101f9d19cfb1896 100644
--- a/lib/libc/include/generic-glibc/net/if_slip.h
+++ b/lib/libc/include/generic-glibc/net/if_slip.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/net/route.h b/lib/libc/include/generic-glibc/net/route.h
index 3cc87c171540579b1f8f23c391d9ddf2e177e3c5..afeef70e524587215389b98972230b775167c6d0 100644
--- a/lib/libc/include/generic-glibc/net/route.h
+++ b/lib/libc/include/generic-glibc/net/route.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netash/ash.h b/lib/libc/include/generic-glibc/netash/ash.h
index 465ec38cb3633b7a7192e80cf810a1a339cbc254..acf28136f0f9754428cdfcf2980e1c547ab2a929 100644
--- a/lib/libc/include/generic-glibc/netash/ash.h
+++ b/lib/libc/include/generic-glibc/netash/ash.h
@@ -1,5 +1,5 @@
 /* Definitions for use with Linux AF_ASH sockets.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netatalk/at.h b/lib/libc/include/generic-glibc/netatalk/at.h
index d3d5fe50d66f378ac354951bb82c4e88e2d845f9..fa25cdc4b1e5b72580533997e44c8b8c5d243173 100644
--- a/lib/libc/include/generic-glibc/netatalk/at.h
+++ b/lib/libc/include/generic-glibc/netatalk/at.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netax25/ax25.h b/lib/libc/include/generic-glibc/netax25/ax25.h
index f08b91f0de248a56211417ce61fcafc6099ec92a..b39eba1afd7a6ab4f62a389c64f4259ee4ce3994 100644
--- a/lib/libc/include/generic-glibc/netax25/ax25.h
+++ b/lib/libc/include/generic-glibc/netax25/ax25.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netdb.h b/lib/libc/include/generic-glibc/netdb.h
index 0c7574af8c3d8e981c8e14fa5cdf437cf32a5e7b..f134a0ef3d927c2d999ec12d708738d7eb968a9d 100644
--- a/lib/libc/include/generic-glibc/netdb.h
+++ b/lib/libc/include/generic-glibc/netdb.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/neteconet/ec.h b/lib/libc/include/generic-glibc/neteconet/ec.h
index 40d4af82b50660e4ee7650a03d96f4745df32358..4fa4d659f04a2be619ff147efd228266cbcba196 100644
--- a/lib/libc/include/generic-glibc/neteconet/ec.h
+++ b/lib/libc/include/generic-glibc/neteconet/ec.h
@@ -1,5 +1,5 @@
 /* Definitions for use with Linux AF_ECONET sockets.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/ether.h b/lib/libc/include/generic-glibc/netinet/ether.h
index 693b4c6f7059cee062904c2f25b2f869d8eab8aa..20b1f4115d8835921c71ae2a32df121739058330 100644
--- a/lib/libc/include/generic-glibc/netinet/ether.h
+++ b/lib/libc/include/generic-glibc/netinet/ether.h
@@ -1,5 +1,5 @@
 /* Functions for storing Ethernet addresses in ASCII and mapping to hostnames.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/icmp6.h b/lib/libc/include/generic-glibc/netinet/icmp6.h
index e45d704e9960797d9a8f91c776728a490b1f0044..0fd25b01f5ad3ea8e2b884651824c4795eb6159b 100644
--- a/lib/libc/include/generic-glibc/netinet/icmp6.h
+++ b/lib/libc/include/generic-glibc/netinet/icmp6.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/if_ether.h b/lib/libc/include/generic-glibc/netinet/if_ether.h
index 6cf2cacd4b95f98c8ef410fe14f20d87a38c0146..63f494284d4c8d7afd90c87e197cad085837a721 100644
--- a/lib/libc/include/generic-glibc/netinet/if_ether.h
+++ b/lib/libc/include/generic-glibc/netinet/if_ether.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/if_fddi.h b/lib/libc/include/generic-glibc/netinet/if_fddi.h
index 1d5b50d32e3302a65d2a6de14ab25936db9b615e..aaf5559c354d6f2843b87e6e01086620af6f44df 100644
--- a/lib/libc/include/generic-glibc/netinet/if_fddi.h
+++ b/lib/libc/include/generic-glibc/netinet/if_fddi.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/if_tr.h b/lib/libc/include/generic-glibc/netinet/if_tr.h
index 003c33f43492806b54e702032e655d0aead4f038..a8abf534c838a85f5862f017a384d156fa4dc5f8 100644
--- a/lib/libc/include/generic-glibc/netinet/if_tr.h
+++ b/lib/libc/include/generic-glibc/netinet/if_tr.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/igmp.h b/lib/libc/include/generic-glibc/netinet/igmp.h
index 58df64655c372a72c17f58ed5a56246b2784a2d3..63e24c6cd037cd8c65e894213c55841847c3a8d3 100644
--- a/lib/libc/include/generic-glibc/netinet/igmp.h
+++ b/lib/libc/include/generic-glibc/netinet/igmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/in.h b/lib/libc/include/generic-glibc/netinet/in.h
index cecb7b9d36620dd8b6c840c9eef9f3ccc387af8b..450338576f11be16bcf50d09d016d593f9ab5ca7 100644
--- a/lib/libc/include/generic-glibc/netinet/in.h
+++ b/lib/libc/include/generic-glibc/netinet/in.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/in_systm.h b/lib/libc/include/generic-glibc/netinet/in_systm.h
index 3f6e4f15c8ee3cf30b96699327e1d2dadee26776..bea6cf82f1b22d481f886699549284f28c65c60a 100644
--- a/lib/libc/include/generic-glibc/netinet/in_systm.h
+++ b/lib/libc/include/generic-glibc/netinet/in_systm.h
@@ -1,5 +1,5 @@
 /* System specific type definitions for networking code.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/ip.h b/lib/libc/include/generic-glibc/netinet/ip.h
index 4ef5f6cd393ba9b23621d2cdbaf86bd5ecd8ba83..eeb5d175f902f0afdcb1f2fc5837045852d3e0a3 100644
--- a/lib/libc/include/generic-glibc/netinet/ip.h
+++ b/lib/libc/include/generic-glibc/netinet/ip.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/ip6.h b/lib/libc/include/generic-glibc/netinet/ip6.h
index 2ef059bea286afb7e1e7a2978ce88219e2ee9e91..e9509ae49146b8b7f08a1021ebf0ffde6ea90d78 100644
--- a/lib/libc/include/generic-glibc/netinet/ip6.h
+++ b/lib/libc/include/generic-glibc/netinet/ip6.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/ip_icmp.h b/lib/libc/include/generic-glibc/netinet/ip_icmp.h
index c5b386ddfda96ba3bd94267117a049ae22d82982..5e09c0efea6399162e2742ba109a4938d50b866d 100644
--- a/lib/libc/include/generic-glibc/netinet/ip_icmp.h
+++ b/lib/libc/include/generic-glibc/netinet/ip_icmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netinet/tcp.h b/lib/libc/include/generic-glibc/netinet/tcp.h
index 357da4371277a57ef430bd1adf5e55affc1d9d45..49764361e72d032438c000c278a16c8f77bbc555 100644
--- a/lib/libc/include/generic-glibc/netinet/tcp.h
+++ b/lib/libc/include/generic-glibc/netinet/tcp.h
@@ -267,8 +267,93 @@ struct tcp_info
   uint32_t	tcpi_rcv_space;
 
   uint32_t	tcpi_total_retrans;
+
+  uint64_t	tcpi_pacing_rate;
+  uint64_t	tcpi_max_pacing_rate;
+  uint64_t	tcpi_bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
+  uint64_t	tcpi_bytes_received; /* RFC4898 tcpEStatsAppHCThruOctetsReceived */
+  uint32_t	tcpi_segs_out;       /* RFC4898 tcpEStatsPerfSegsOut */
+  uint32_t	tcpi_segs_in;        /* RFC4898 tcpEStatsPerfSegsIn */
+
+  uint32_t	tcpi_notsent_bytes;
+  uint32_t	tcpi_min_rtt;
+  uint32_t	tcpi_data_segs_in;    /* RFC4898 tcpEStatsDataSegsIn */
+  uint32_t	tcpi_data_segs_out;   /* RFC4898 tcpEStatsDataSegsOut */
+
+  uint64_t	tcpi_delivery_rate;
+
+  uint64_t	tcpi_busy_time;       /* Time (usec) busy sending data */
+  uint64_t	tcpi_rwnd_limited;    /* Time (usec) limited by receive window */
+  uint64_t	tcpi_sndbuf_limited;  /* Time (usec) limited by send buffer */
+
+  uint32_t	tcpi_delivered;
+  uint32_t	tcpi_delivered_ce;
+
+  uint64_t	tcpi_bytes_sent;    /* RFC4898 tcpEStatsPerfHCDataOctetsOut */
+  uint64_t	tcpi_bytes_retrans; /* RFC4898 tcpEStatsPerfOctetsRetrans */
+  uint32_t	tcpi_dsack_dups;    /* RFC4898 tcpEStatsStackDSACKDups */
+  uint32_t	tcpi_reord_seen;    /* reordering events seen */
+
+
+  uint32_t	tcpi_rcv_ooopack; /* Out-of-order packets received */
+  /* Peer's advertised receive window after scaling (bytes) */
+  uint32_t	tcpi_snd_wnd;
+  /* Local advertised receive window after scaling (bytes) */
+  uint32_t	tcpi_rcv_wnd;
+
+  uint32_t	tcpi_rehash; /* PLB or timeout triggered rehash attempts */
+  /* Total number of RTO timeouts, including
+   * SYN/SYN-ACK and recurring timeouts
+   */
+  uint16_t	tcpi_total_rto;
+  /* Total number of RTO recoveries, including any unfinished recovery. */
+  uint16_t	tcpi_total_rto_recoveries;
+  /* Total time spent in RTO recoveries in milliseconds, including any
+   * unfinished recovery.
+   */
+  uint32_t	tcpi_total_rto_time;
+  uint32_t	tcpi_received_ce;        /* # of CE marks received */
+  uint32_t	tcpi_delivered_e1_bytes; /* Accurate ECN byte counters */
+  uint32_t	tcpi_delivered_e0_bytes;
+  uint32_t	tcpi_delivered_ce_bytes;
+  uint32_t	tcpi_received_e1_bytes;
+  uint32_t	tcpi_received_e0_bytes;
+  uint32_t	tcpi_received_ce_bytes;
+  uint16_t	tcpi_accecn_fail_mode;
+  uint16_t	tcpi_accecn_opt_seen;
 };
 
+/* Netlink attributes types for SCM_TIMESTAMPING_OPT_STATS */
+enum {
+  TCP_NLA_PAD,
+  TCP_NLA_BUSY,                   /* Time (usec) busy sending data */
+  TCP_NLA_RWND_LIMITED,           /* Time (usec) limited by receive window */
+  TCP_NLA_SNDBUF_LIMITED,         /* Time (usec) limited by send buffer */
+  TCP_NLA_DATA_SEGS_OUT,          /* Data pkts sent including retransmission */
+  TCP_NLA_TOTAL_RETRANS,          /* Data pkts retransmitted */
+  TCP_NLA_PACING_RATE,            /* Pacing rate in bytes per second */
+  TCP_NLA_DELIVERY_RATE,          /* Delivery rate in bytes per second */
+  TCP_NLA_SND_CWND,               /* Sending congestion window */
+  TCP_NLA_REORDERING,             /* Reordering metric */
+  TCP_NLA_MIN_RTT,                /* minimum RTT */
+  TCP_NLA_RECUR_RETRANS,          /* Recurring retransmits for the current pkt */
+  TCP_NLA_DELIVERY_RATE_APP_LMT,  /* delivery rate application limited ? */
+  TCP_NLA_SNDQ_SIZE,              /* Data (bytes) pending in send queue */
+  TCP_NLA_CA_STATE,               /* ca_state of socket */
+  TCP_NLA_SND_SSTHRESH,           /* Slow start size threshold */
+  TCP_NLA_DELIVERED,              /* Data pkts delivered incl. out-of-order */
+  TCP_NLA_DELIVERED_CE,           /* Like above but only ones w/ CE marks */
+  TCP_NLA_BYTES_SENT,             /* Data bytes sent including retransmission */
+  TCP_NLA_BYTES_RETRANS,          /* Data bytes retransmitted */
+  TCP_NLA_DSACK_DUPS,             /* DSACK blocks received */
+  TCP_NLA_REORD_SEEN,             /* reordering events seen */
+  TCP_NLA_SRTT,                   /* smoothed RTT in usecs */
+  TCP_NLA_TIMEOUT_REHASH,         /* Timeout-triggered rehash attempts */
+  TCP_NLA_BYTES_NOTSENT,          /* Bytes in write queue not yet sent */
+  TCP_NLA_EDT,                    /* Earliest departure time (CLOCK_MONOTONIC) */
+  TCP_NLA_TTL,                    /* TTL or hop limit of a packet received */
+  TCP_NLA_REHASH,                 /* PLB and timeout triggered rehash attempts */
+};
 
 /* For TCP_MD5SIG socket option.  */
 #define TCP_MD5SIG_MAXKEYLEN	80
@@ -287,6 +372,114 @@ struct tcp_md5sig
   uint8_t	tcpm_key[TCP_MD5SIG_MAXKEYLEN];	/* Key (binary).  */
 };
 
+/* INET_DIAG_MD5SIG */
+struct tcp_diag_md5sig {
+  uint8_t   tcpm_family;
+  uint8_t   tcpm_prefixlen;
+  uint16_t  tcpm_keylen;
+  uint32_t  tcpm_addr[4];
+  uint8_t   tcpm_key[TCP_MD5SIG_MAXKEYLEN];
+};
+
+#define TCP_AO_MAXKEYLEN  80
+
+#define TCP_AO_KEYF_IFINDEX  (1 << 0)     /* L3 ifindex for VRF */
+#define TCP_AO_KEYF_EXCLUDE_OPT  (1 << 1) /* Indicates whether TCP options
+                                           * other than TCP-AO are included
+                                           * in the MAC calculation
+                                           */
+
+struct tcp_ao_add { /* setsockopt(TCP_AO_ADD_KEY) */
+  struct sockaddr_storage addr;   /* Peer's address for the key */
+  int8_t    alg_name[64];         /* Crypto hash algorithm to use */
+  int32_t   ifindex;              /* L3 dev index for VRF */
+  uint32_t  set_current  :1,      /* Set key as Current_key at once */
+            set_rnext    :1,      /* Request it from peer with RNext_key */
+            reserved     :30;     /* Must be 0 */
+  uint16_t  reserved2;            /* Padding, must be 0 */
+  uint8_t   prefix;               /* Peer's address prefix */
+  uint8_t   sndid;                /* SendID for outgoing segments */
+  uint8_t   rcvid;                /* RecvID to match for incoming seg */
+  uint8_t   maclen;               /* length of authentication code (hash) */
+  uint8_t   keyflags;             /* See TCP_AO_KEYF_ */
+  uint8_t   keylen;               /* Length of ::key */
+  uint8_t   key[TCP_AO_MAXKEYLEN];
+} __attribute__((aligned(8)));
+
+struct tcp_ao_del { /* setsockopt(TCP_AO_DEL_KEY) */
+  struct sockaddr_storage addr;   /* Peer's address for the key */
+  int32_t  ifindex;               /* L3 dev index for VRF */
+  uint32_t set_current  :1,       /* Corresponding ::current_key */
+           set_rnext    :1,       /* Corresponding ::rnext */
+           del_async    :1,       /* Only valid for listen sockets */
+           reserved     :29;      /* Must be 0 */
+  uint16_t reserved2;             /* Padding, must be 0 */
+  uint8_t  prefix;                /* Peer's address prefix */
+  uint8_t  sndid;                 /* SendID for outgoing segments */
+  uint8_t  rcvid;                 /* RecvID to match for incoming seg */
+  uint8_t  current_key;           /* KeyID to set as Current_key */
+  uint8_t  rnext;                 /* KeyID to set as Rnext_key */
+  uint8_t  keyflags;              /* See TCP_AO_KEYF_ */
+} __attribute__((aligned(8)));
+
+struct tcp_ao_info_opt { /* setsockopt(TCP_AO_INFO), getsockopt(TCP_AO_INFO)
+                          */
+  /* Here 'in' is for setsockopt(), 'out' is for getsockopt() */
+  uint32_t  set_current   :1,   /* In/out: corresponding ::current_key */
+            set_rnext     :1,   /* In/out: corresponding ::rnext */
+            ao_required   :1,   /* In/out: don't accept non-AO connects */
+            set_counters  :1,   /* In: set/clear ::pkt_* counters */
+            accept_icmps  :1,   /* In/out: accept incoming ICMPs */
+            reserved      :27;  /* must be 0 */
+  uint16_t  reserved2;          /* Padding, must be 0 */
+  uint8_t   current_key;        /* In/out: KeyID of Current_key */
+  uint8_t   rnext;              /* In/out: keyid of RNext_key */
+  uint64_t  pkt_good;           /* In/out: verified segments */
+  uint64_t  pkt_bad;            /* In/out: failed verification */
+  uint64_t  pkt_key_not_found;  /* In/out: could not find a key to verify */
+  uint64_t  pkt_ao_required;    /* In/out: segments missing TCP-AO sign */
+  uint64_t  pkt_dropped_icmp;   /* In/out: ICMPs that were ignored */
+} __attribute__((aligned(8)));
+
+struct tcp_ao_getsockopt { /* getsockopt(TCP_AO_GET_KEYS) */
+  struct sockaddr_storage addr;   /* In/out: dump keys for peer
+                                   * with this address/prefix
+                                   */
+  uint8_t   alg_name[64];         /* out: crypto hash algorithm */
+  uint8_t   key[TCP_AO_MAXKEYLEN];
+  uint32_t  nkeys;                /* In: size of the userspace buffer
+                                   * @optval, measured in @optlen - the
+                                   * sizeof(struct tcp_ao_getsockopt)
+                                   * Out: number of keys that matched
+                                   */
+  uint16_t  is_current  :1,       /* In: match and dump Current_key,
+                                   * Out: the dumped key is Current_key
+                                   */
+            is_rnext    :1,       /* In: match and dump RNext_key,
+                                   * Out: the dumped key is RNext_key
+                                   */
+            get_all     :1,       /* In: dump all keys */
+            reserved    :13;      /* Padding, must be 0 */
+  uint8_t  sndid;                 /* In/out: dump keys with SendID */
+  uint8_t  rcvid;                 /* In/out: dump keys with RecvID */
+  uint8_t  prefix;                /* In/out: dump keys with address/prefix */
+  uint8_t  maclen;                /* Out: key's length of authentication
+                                   * code (hash)
+                                  */
+  uint8_t  keyflags;              /* In/out: see TCP_AO_KEYF_ */
+  uint8_t  keylen;                /* Out: length of ::key */
+  int32_t  ifindex;               /* In/out: L3 dev index for VRF */
+  uint64_t  pkt_good;             /* Out: verified segments */
+  uint64_t  pkt_bad;              /* Out: segments that failed verification */
+} __attribute__((aligned(8)));
+
+struct tcp_ao_repair { /* {s,g}etsockopt(TCP_AO_REPAIR) */
+  uint32_t      snt_isn;
+  uint32_t      rcv_isn;
+  uint32_t      snd_sne;
+  uint32_t      rcv_sne;
+} __attribute__((aligned(8)));
+
 /* For socket repair options.  */
 struct tcp_repair_opt
 {
@@ -346,6 +539,15 @@ struct tcp_zerocopy_receive
   uint64_t address; /* In: address of mapping.  */
   uint32_t length; /* In/out: number of bytes to map/mapped.  */
   uint32_t recv_skip_hint; /* Out: amount of bytes to skip.  */
+  uint32_t inq; /* Out: amount of bytes in read queue.  */
+  int32_t err; /* Out: socket error.  */
+  uint64_t copybuf_address; /* On: copybuf address (small reads).  */
+  int32_t copybuf_len; /* In/Out: copybuf bytes avail/used or error.  */
+  uint32_t flags; /* In: flags.  */
+  uint64_t msg_control; /* Ancillary data.  */
+  uint64_t msg_controllen;
+  uint32_t msg_flags;
+  uint32_t reserved; /* Set to 0 for now.  */
 };
 
 #endif /* Misc.  */
diff --git a/lib/libc/include/generic-glibc/netinet/udp.h b/lib/libc/include/generic-glibc/netinet/udp.h
index c2fd3250821cf1dae2e07652e5f307b79747534a..afc034d3a6ddd77bf5e187db9f66cf4e20385b98 100644
--- a/lib/libc/include/generic-glibc/netinet/udp.h
+++ b/lib/libc/include/generic-glibc/netinet/udp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netipx/ipx.h b/lib/libc/include/generic-glibc/netipx/ipx.h
index d67d3cb86b77365530cf35bbc62356cb4b07d958..f72532980f8f0418af70c11862879950babd68b8 100644
--- a/lib/libc/include/generic-glibc/netipx/ipx.h
+++ b/lib/libc/include/generic-glibc/netipx/ipx.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netiucv/iucv.h b/lib/libc/include/generic-glibc/netiucv/iucv.h
index b1125c1c87a9fcde8c679defd3487059cd65f403..27735c0e52d8f1ead64161c3fe735a2595963c7f 100644
--- a/lib/libc/include/generic-glibc/netiucv/iucv.h
+++ b/lib/libc/include/generic-glibc/netiucv/iucv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netpacket/packet.h b/lib/libc/include/generic-glibc/netpacket/packet.h
index af9f7f49ece5fa4ab2b4b913d0a90cd9fefafb21..15477efb1bede35b87fce20e31f6af07dc669695 100644
--- a/lib/libc/include/generic-glibc/netpacket/packet.h
+++ b/lib/libc/include/generic-glibc/netpacket/packet.h
@@ -1,5 +1,5 @@
 /* Definitions for use with Linux AF_PACKET sockets.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netrom/netrom.h b/lib/libc/include/generic-glibc/netrom/netrom.h
index 78ab32c0f3d49df6d04e3876b35794b5f0726dda..8fd4caf5c4b8b264b02d54c507a89042bf1d2bf8 100644
--- a/lib/libc/include/generic-glibc/netrom/netrom.h
+++ b/lib/libc/include/generic-glibc/netrom/netrom.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/netrose/rose.h b/lib/libc/include/generic-glibc/netrose/rose.h
index d85179ec1320a5562700a9d3de22711bead83af7..ee864a459b1871e048092a8e867dd213f39d0edc 100644
--- a/lib/libc/include/generic-glibc/netrose/rose.h
+++ b/lib/libc/include/generic-glibc/netrose/rose.h
@@ -1,5 +1,5 @@
 /* Definitions for Rose packet radio address family.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/nl_types.h b/lib/libc/include/generic-glibc/nl_types.h
index 87ee5341c0e321ba1a18b24e09b589a0403691ed..54577d60a11a901cf607786cc2b21c0829fae7bb 100644
--- a/lib/libc/include/generic-glibc/nl_types.h
+++ b/lib/libc/include/generic-glibc/nl_types.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/nss.h b/lib/libc/include/generic-glibc/nss.h
index ab632b5b41da86f6d0e21ec9a5acbb04b927f172..a57c1366d3fb8c549cae4bf4e572c22a9a5ee7c6 100644
--- a/lib/libc/include/generic-glibc/nss.h
+++ b/lib/libc/include/generic-glibc/nss.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/obstack.h b/lib/libc/include/generic-glibc/obstack.h
index a80542eb4e05a3686fa57444b5bc830f22126c7d..37d0e9b2c8af66c085bfe5dacbaa1de442ddd172 100644
--- a/lib/libc/include/generic-glibc/obstack.h
+++ b/lib/libc/include/generic-glibc/obstack.h
@@ -1,5 +1,5 @@
 /* obstack.h - object stack macros
-   Copyright (C) 1988-2025 Free Software Foundation, Inc.
+   Copyright (C) 1988-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/printf.h b/lib/libc/include/generic-glibc/printf.h
index 29d0baaa40248698ee2d06442968a760b0232938..321a3375577842281ca580bdadc67367175c342a 100644
--- a/lib/libc/include/generic-glibc/printf.h
+++ b/lib/libc/include/generic-glibc/printf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/proc_service.h b/lib/libc/include/generic-glibc/proc_service.h
index 96fc4872d8c5e69140edd8b0a73514e121321624..47da4c2a9851af9b4c431641154a5826ee809017 100644
--- a/lib/libc/include/generic-glibc/proc_service.h
+++ b/lib/libc/include/generic-glibc/proc_service.h
@@ -1,5 +1,5 @@
 /* Callback interface for libthread_db, functions users must define.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/pthread.h b/lib/libc/include/generic-glibc/pthread.h
index cfce06cef914646764069c7dfbf367fbe76f280e..638d23c8875a5a33b546daa4cced1205d3494f94 100644
--- a/lib/libc/include/generic-glibc/pthread.h
+++ b/lib/libc/include/generic-glibc/pthread.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/pty.h b/lib/libc/include/generic-glibc/pty.h
index d6b4b7ee36e9836601bd35dbe2cb5f7b1d781d33..9091c173219a14b503b834941d995861aa32fb78 100644
--- a/lib/libc/include/generic-glibc/pty.h
+++ b/lib/libc/include/generic-glibc/pty.h
@@ -1,5 +1,5 @@
 /* Functions for pseudo TTY handling.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/pwd.h b/lib/libc/include/generic-glibc/pwd.h
index e4b85ac27e1bb5966e48754f21bfe5f3b6520d49..daf70436bf45ece2e7f9a887010a9e16e736f909 100644
--- a/lib/libc/include/generic-glibc/pwd.h
+++ b/lib/libc/include/generic-glibc/pwd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/re_comp.h b/lib/libc/include/generic-glibc/re_comp.h
index 807da5a58dbbfa910b25acd600575b0686562fb0..baf343bdc19816d3e6b84e1ee2400df69c5ee7c8 100644
--- a/lib/libc/include/generic-glibc/re_comp.h
+++ b/lib/libc/include/generic-glibc/re_comp.h
@@ -1,4 +1,4 @@
-/*  Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/*  Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/regdef.h b/lib/libc/include/generic-glibc/regdef.h
index db737482b10ede5c1be83c37c3213e851a4e23bb..55ce5b9f0497475d0bd914aa3a56325a6e4e8802 100644
--- a/lib/libc/include/generic-glibc/regdef.h
+++ b/lib/libc/include/generic-glibc/regdef.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1994-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/regex.h b/lib/libc/include/generic-glibc/regex.h
index 8bbd92fc4fb036f6b93122d00b78786618213580..29964af5b251c24a729a3326c173a0ae96455d96 100644
--- a/lib/libc/include/generic-glibc/regex.h
+++ b/lib/libc/include/generic-glibc/regex.h
@@ -1,6 +1,6 @@
 /* Definitions for data structures and routines for the regular
    expression library.
-   Copyright (C) 1985, 1989-2025 Free Software Foundation, Inc.
+   Copyright (C) 1985, 1989-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/regexp.h b/lib/libc/include/generic-glibc/regexp.h
index 02ff44637eac509cf85c3031e5d8aea25f64f11b..3ecab12e76ba6a267cf66fd34b2a87f068958834 100644
--- a/lib/libc/include/generic-glibc/regexp.h
+++ b/lib/libc/include/generic-glibc/regexp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/resolv.h b/lib/libc/include/generic-glibc/resolv.h
index 206ff771fb87c2372501d9d7a6345033c628c181..052341aa37f315cb91ed054544bbd8a847e9df30 100644
--- a/lib/libc/include/generic-glibc/resolv.h
+++ b/lib/libc/include/generic-glibc/resolv.h
@@ -336,4 +336,4 @@ void		res_nclose (res_state) __THROW;
 
 __END_DECLS
 
-#endif /* !_RESOLV_H_ */
+#endif /* !_RESOLV_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/sched.h b/lib/libc/include/generic-glibc/sched.h
index 0a44b8d5d8ed6dae107922b8a36de0bffdc69bf5..6a7358c795b410a6fbe56d78f08c1e34099db734 100644
--- a/lib/libc/include/generic-glibc/sched.h
+++ b/lib/libc/include/generic-glibc/sched.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX 1003.1b-1993 (aka POSIX.4) scheduling interface.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/scsi/scsi.h b/lib/libc/include/generic-glibc/scsi/scsi.h
index 925b2d8a313bdf3e21fbf2313bda658cec6f9796..45ec5e91f304eb06b49e15a9dd1ba7ae2132c456 100644
--- a/lib/libc/include/generic-glibc/scsi/scsi.h
+++ b/lib/libc/include/generic-glibc/scsi/scsi.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/scsi/scsi_ioctl.h b/lib/libc/include/generic-glibc/scsi/scsi_ioctl.h
index 59f10b7ce18575a05474527faaa7d1543da6e64f..65ca9f6824a677a3691325bd4df199e541d0acdd 100644
--- a/lib/libc/include/generic-glibc/scsi/scsi_ioctl.h
+++ b/lib/libc/include/generic-glibc/scsi/scsi_ioctl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/scsi/sg.h b/lib/libc/include/generic-glibc/scsi/sg.h
index 6129b0dd620ae426b03b1dca67df0d750c4b746c..c82da1ebc2d3460e77af18ef87b8e54402e622ce 100644
--- a/lib/libc/include/generic-glibc/scsi/sg.h
+++ b/lib/libc/include/generic-glibc/scsi/sg.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/search.h b/lib/libc/include/generic-glibc/search.h
index c28ee21932b994136292354c847f43baa656ab7e..5d930245437201c531b178fbfc8eb2e956ac5d79 100644
--- a/lib/libc/include/generic-glibc/search.h
+++ b/lib/libc/include/generic-glibc/search.h
@@ -1,5 +1,5 @@
 /* Declarations for System V style searching functions.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/semaphore.h b/lib/libc/include/generic-glibc/semaphore.h
index 3f856a5ef7185a7a7d8a4b629e53d4071cfc7328..2724da048deea0c64910a76641165472c99bc2bd 100644
--- a/lib/libc/include/generic-glibc/semaphore.h
+++ b/lib/libc/include/generic-glibc/semaphore.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/setjmp.h b/lib/libc/include/generic-glibc/setjmp.h
index e28e85dfa9eb091f42f791e3dbc587deb8dbdf74..5d726b389cc836d5f940b7a244750b9b94baa60e 100644
--- a/lib/libc/include/generic-glibc/setjmp.h
+++ b/lib/libc/include/generic-glibc/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -26,6 +26,10 @@
 
 __BEGIN_DECLS
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_SETJMP_H__ 202311L
+#endif
+
 #include <bits/setjmp.h>		/* Get `__jmp_buf'.  */
 #include <bits/types/struct___jmp_buf_tag.h>
 
diff --git a/lib/libc/include/generic-glibc/sgidefs.h b/lib/libc/include/generic-glibc/sgidefs.h
index c0ba3fb4580f63420c2f3e55988dcb04733eee7c..dd5a5f49b5e182a6ab423bcf7ca6df70c7b745f7 100644
--- a/lib/libc/include/generic-glibc/sgidefs.h
+++ b/lib/libc/include/generic-glibc/sgidefs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sgtty.h b/lib/libc/include/generic-glibc/sgtty.h
index 0b6dc1ac31149ecb7a3c0643151bfa199f7d90c8..1a1dfe28d1017f6ce7f701316056c6bb0cef0f70 100644
--- a/lib/libc/include/generic-glibc/sgtty.h
+++ b/lib/libc/include/generic-glibc/sgtty.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/shadow.h b/lib/libc/include/generic-glibc/shadow.h
index 090437158ebd1e79d1b097b7e19695ed9fe57a26..663365355b4a550e682570b25daa9cb0e5ab95c8 100644
--- a/lib/libc/include/generic-glibc/shadow.h
+++ b/lib/libc/include/generic-glibc/shadow.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/signal.h b/lib/libc/include/generic-glibc/signal.h
index 13a7fed1262da26f3e58009f9e420c3544a3edae..9c7d3e87b61b2374ec9096f5f920b7f8077223bc 100644
--- a/lib/libc/include/generic-glibc/signal.h
+++ b/lib/libc/include/generic-glibc/signal.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/spawn.h b/lib/libc/include/generic-glibc/spawn.h
index e466dd62d6ac2bb5fb8ec7878b39ebf08bed9d92..b8e1eaee8f8c1432cb21fb069d2134573536827e 100644
--- a/lib/libc/include/generic-glibc/spawn.h
+++ b/lib/libc/include/generic-glibc/spawn.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX spawn interface.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/stdbit.h b/lib/libc/include/generic-glibc/stdbit.h
index 7938eb3b5cf83d134cbb665462eed65009bb2c82..fd9252fbcb25a7ce3df7d6980e8261f8275b8b5e 100644
--- a/lib/libc/include/generic-glibc/stdbit.h
+++ b/lib/libc/include/generic-glibc/stdbit.h
@@ -1,5 +1,5 @@
 /* ISO C23 Standard: 7.18 - Bit and byte utilities <stdbit.h>.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/stdc-predef.h b/lib/libc/include/generic-glibc/stdc-predef.h
index 8bf36b70cab549961488a369a44bab2d9fbf3ea2..6150a345c7b6778eb7f2d5029b5b69285a606ee3 100644
--- a/lib/libc/include/generic-glibc/stdc-predef.h
+++ b/lib/libc/include/generic-glibc/stdc-predef.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/stdint.h b/lib/libc/include/generic-glibc/stdint.h
index 191506080a9cdc3b309fe752db372c0e2d6db784..4e17612886387a8b42e50fdadfb249f7beceef99 100644
--- a/lib/libc/include/generic-glibc/stdint.h
+++ b/lib/libc/include/generic-glibc/stdint.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -28,6 +28,10 @@
 #include <bits/wchar.h>
 #include <bits/wordsize.h>
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_STDINT_H__ 202311L
+#endif
+
 /* Exact integral types.  */
 
 /* Signed.  */
@@ -91,6 +95,8 @@ typedef __intmax_t		intmax_t;
 typedef __uintmax_t		uintmax_t;
 
 
+# undef __INT64_C
+# undef __UINT64_C
 # if __WORDSIZE == 64
 #  define __INT64_C(c)	c ## L
 #  define __UINT64_C(c)	c ## UL
diff --git a/lib/libc/include/generic-glibc/stdio.h b/lib/libc/include/generic-glibc/stdio.h
index e80e85755094b569778e697af1a6c1f6bdfcb342..c4a057b552264b51e6e3f6d410bd0f539db29d8f 100644
--- a/lib/libc/include/generic-glibc/stdio.h
+++ b/lib/libc/include/generic-glibc/stdio.h
@@ -1,5 +1,5 @@
 /* Define ISO C stdio on top of C++ iostreams.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
@@ -29,6 +29,10 @@
 
 __BEGIN_DECLS
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_STDIO_H__ 202311L
+#endif
+
 #define __need_size_t
 #define __need_NULL
 #include <stddef.h>
@@ -168,11 +172,11 @@ extern int renameat (int __oldfd, const char *__old, int __newfd,
 #ifdef __USE_GNU
 /* Flags for renameat2.  */
 # define RENAME_NOREPLACE (1 << 0)
-# define AT_RENAME_NOREPLACE RENAME_NOREPLACE
+# define AT_RENAME_NOREPLACE 0x0001
 # define RENAME_EXCHANGE (1 << 1)
-# define AT_RENAME_EXCHANGE RENAME_EXCHANGE
+# define AT_RENAME_EXCHANGE 0x0002
 # define RENAME_WHITEOUT (1 << 2)
-# define AT_RENAME_WHITEOUT RENAME_WHITEOUT
+# define AT_RENAME_WHITEOUT 0x0004
 
 /* Rename file OLD relative to OLDFD to NEW relative to NEWFD, with
    additional flags.  */
diff --git a/lib/libc/include/generic-glibc/stdio_ext.h b/lib/libc/include/generic-glibc/stdio_ext.h
index 35ba67d43e0065b63d01429884bec7883ff0c94f..984bac3e374325e147ba0f165d1c148c070f891c 100644
--- a/lib/libc/include/generic-glibc/stdio_ext.h
+++ b/lib/libc/include/generic-glibc/stdio_ext.h
@@ -1,5 +1,5 @@
 /* Functions to access FILE structure internals.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/stdlib.h b/lib/libc/include/generic-glibc/stdlib.h
index b6b4ff601ff8b673f9a3de1cacf25723884c2c9d..3ca2bb1f91bc38a0f6244c99113a3fb520f15b20 100644
--- a/lib/libc/include/generic-glibc/stdlib.h
+++ b/lib/libc/include/generic-glibc/stdlib.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
@@ -35,6 +35,10 @@ __BEGIN_DECLS
 
 #define	_STDLIB_H	1
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_STDLIB_H__ 202311L
+#endif
+
 #if (defined __USE_XOPEN || defined __USE_XOPEN2K8) && !defined _SYS_WAIT_H
 /* XPG requires a few symbols from <sys/wait.h> being defined.  */
 # include <bits/waitflags.h>
@@ -692,6 +696,24 @@ extern void *realloc (void *__ptr, size_t __size)
 /* Free a block allocated by `malloc', `realloc' or `calloc'.  */
 extern void free (void *__ptr) __THROW;
 
+#if __GLIBC_USE(ISOC23)
+/* Free a block allocated by `malloc', `realloc' or `calloc' but not
+   `aligned_alloc', `memalign', `posix_memalign', `valloc' or
+   `pvalloc'. SIZE must be equal to the original requested size
+   provided to `malloc', `realloc' or `calloc'. For `calloc' SIZE is
+   NMEMB elements * SIZE bytes. It is forbidden to call `free_sized'
+   for allocations which the caller did not directly allocate but
+   must still deallocate, such as `strdup' or `strndup'. Instead
+   continue using `free` for these cases.  */
+extern void free_sized (void *__ptr, size_t __size) __THROW;
+
+/* Free a block allocated by `aligned_alloc', `memalign' or
+   `posix_memalign'. ALIGNMENT and SIZE must be the same as the values
+   provided to `aligned_alloc', `memalign' or `posix_memalign'.  */
+extern void free_aligned_sized (void *__ptr, size_t __alignment, size_t __size)
+     __THROW;
+#endif
+
 /*
  * zig patch: reallocarray introduced in glibc 2.26
  * https://sourceware.org/git/?p=glibc.git;a=commit;h=2e0bbbfbf95fc9e22692e93658a6fbdd2d4554da
@@ -977,6 +999,12 @@ extern void *bsearch (const void *__key, const void *__base,
 # include <bits/stdlib-bsearch.h>
 #endif
 
+#if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+# define bsearch(KEY, BASE, NMEMB, SIZE, COMPAR)			\
+  __glibc_const_generic (BASE, const void *,				\
+			 bsearch (KEY, BASE, NMEMB, SIZE, COMPAR))
+#endif
+
 /* Sort NMEMB elements of BASE, of SIZE bytes each,
    using COMPAR to perform the comparisons.  */
 extern void qsort (void *__base, size_t __nmemb, size_t __size,
@@ -1170,6 +1198,19 @@ extern int getloadavg (double __loadavg[], int __nelem)
 extern int ttyslot (void) __THROW;
 #endif
 
+#if __GLIBC_USE (ISOC23)
+# ifndef __cplusplus
+#  include <bits/types/once_flag.h>
+
+/* Call function __FUNC exactly once, even if invoked from several threads.
+   All calls must be made with the same __FLAGS object.  */
+extern void call_once (once_flag *__flag, void (*__func)(void));
+# endif /* !__cplusplus */
+
+/* Return the alignment of P.  */
+extern size_t memalignment (const void *__p);
+#endif
+
 #include <bits/stdlib-float.h>
 
 /* Define some macros helping to catch buffer overflows.  */
diff --git a/lib/libc/include/generic-glibc/string.h b/lib/libc/include/generic-glibc/string.h
index d6794d21d1763e1a946e3897e5b30ce8a3bca169..8eb5b75f94132b2b970e0f8c5e528e6265829f49 100644
--- a/lib/libc/include/generic-glibc/string.h
+++ b/lib/libc/include/generic-glibc/string.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -27,6 +27,10 @@
 
 __BEGIN_DECLS
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_STRING_H__ 202311L
+#endif
+
 /* Get size_t and NULL from <stddef.h>.  */
 #define	__need_size_t
 #define	__need_NULL
@@ -60,6 +64,13 @@ extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
 /* Set N bytes of S to C.  */
 extern void *memset (void *__s, int __c, size_t __n) __THROW __nonnull ((1));
 
+#if defined __USE_MISC || __GLIBC_USE (ISOC23)
+/* Like memset, but the compiler will not delete a call to this
+   function, even if S is dead after the call.  */
+extern void *memset_explicit (void *__s, int __c, size_t __n)
+     __THROW __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 3);
+#endif
+
 /* Compare N bytes of S1 and S2.  */
 extern int memcmp (const void *__s1, const void *__s2, size_t __n)
      __THROW __attribute_pure__ __nonnull ((1, 2));
@@ -106,6 +117,10 @@ memchr (const void *__s, int __c, size_t __n) __THROW
 #else
 extern void *memchr (const void *__s, int __c, size_t __n)
       __THROW __attribute_pure__ __nonnull ((1));
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define memchr(S, C, N)					\
+  __glibc_const_generic (S, const void *, memchr (S, C, N))
+# endif
 #endif
 
 #ifdef __USE_GNU
@@ -245,6 +260,10 @@ strchr (const char *__s, int __c) __THROW
 #else
 extern char *strchr (const char *__s, int __c)
      __THROW __attribute_pure__ __nonnull ((1));
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define strchr(S, C)						\
+  __glibc_const_generic (S, const char *, strchr (S, C))
+# endif
 #endif
 /* Find the last occurrence of C in S.  */
 #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
@@ -272,6 +291,10 @@ strrchr (const char *__s, int __c) __THROW
 #else
 extern char *strrchr (const char *__s, int __c)
      __THROW __attribute_pure__ __nonnull ((1));
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define strrchr(S, C)						\
+  __glibc_const_generic (S, const char *, strrchr (S, C))
+# endif
 #endif
 
 #ifdef __USE_MISC
@@ -322,6 +345,10 @@ strpbrk (const char *__s, const char *__accept) __THROW
 #else
 extern char *strpbrk (const char *__s, const char *__accept)
      __THROW __attribute_pure__ __nonnull ((1, 2));
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define strpbrk(S, ACCEPT)					\
+  __glibc_const_generic (S, const char *, strpbrk (S, ACCEPT))
+# endif
 #endif
 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
 #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
@@ -349,6 +376,11 @@ strstr (const char *__haystack, const char *__needle) __THROW
 #else
 extern char *strstr (const char *__haystack, const char *__needle)
      __THROW __attribute_pure__ __nonnull ((1, 2));
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define strstr(HAYSTACK, NEEDLE)			\
+  __glibc_const_generic (HAYSTACK, const char *,	\
+			 strstr (HAYSTACK, NEEDLE))
+# endif
 #endif
 
 
@@ -557,4 +589,4 @@ extern char *basename (const char *__filename) __THROW __nonnull ((1));
 
 __END_DECLS
 
-#endif /* string.h  */
+#endif /* string.h  */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/strings.h b/lib/libc/include/generic-glibc/strings.h
index bcc5399e81efb41696136e1c412ba3a652726f30..ddd4f467eb66bc9a8b6dd733d3ba2ed3e81dd1b1 100644
--- a/lib/libc/include/generic-glibc/strings.h
+++ b/lib/libc/include/generic-glibc/strings.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/acct.h b/lib/libc/include/generic-glibc/sys/acct.h
index a0f6fd6ab24c52520b5068240b9ccf8a59cadadc..6e603afcafc924bd0f4ae07522523cf498c52ce2 100644
--- a/lib/libc/include/generic-glibc/sys/acct.h
+++ b/lib/libc/include/generic-glibc/sys/acct.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/asm.h b/lib/libc/include/generic-glibc/sys/asm.h
index a10baf11efa2d36dc09157c380aa6a577cd675b5..4cd32eccbb35a9465868b723616be34e535faabe 100644
--- a/lib/libc/include/generic-glibc/sys/asm.h
+++ b/lib/libc/include/generic-glibc/sys/asm.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -478,20 +478,4 @@ symbol		=	value
 # define MTC0	dmtc0
 #endif
 
-/* The MIPS architectures do not have a uniform memory model.  Particular
-   platforms may provide additional guarantees - for instance, the R4000
-   LL and SC instructions implicitly perform a SYNC, and the 4K promises
-   strong ordering.
-
-   However, in the absence of those guarantees, we must assume weak ordering
-   and SYNC explicitly where necessary.
-
-   Some obsolete MIPS processors may not support the SYNC instruction.  This
-   applies to "true" MIPS I processors; most of the processors which compile
-   using MIPS I implement parts of MIPS II.  */
-
-#ifndef MIPS_SYNC
-# define MIPS_SYNC	sync
-#endif
-
 #endif /* sys/asm.h */
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/sys/auxv.h b/lib/libc/include/generic-glibc/sys/auxv.h
index ccb6e70ccbcde60ee3b011f5a4f719e2103f1b68..66c0a651adecf60b6f621a78e6d2e9e866ccccc6 100644
--- a/lib/libc/include/generic-glibc/sys/auxv.h
+++ b/lib/libc/include/generic-glibc/sys/auxv.h
@@ -1,5 +1,5 @@
 /* Access to the auxiliary vector.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/cachectl.h b/lib/libc/include/generic-glibc/sys/cachectl.h
index d3a4ba4982d87f87dc63d0e89b3134511fe107e6..daa369ca0bf417e4cd9da6df606acd0f94e53ab6 100644
--- a/lib/libc/include/generic-glibc/sys/cachectl.h
+++ b/lib/libc/include/generic-glibc/sys/cachectl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/cdefs.h b/lib/libc/include/generic-glibc/sys/cdefs.h
index a8315571aa93d2d7a370d4717e6334911bda1075..3970013e72e1c291952b46995437f139e324e3d0 100644
--- a/lib/libc/include/generic-glibc/sys/cdefs.h
+++ b/lib/libc/include/generic-glibc/sys/cdefs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
@@ -438,10 +438,10 @@
 */
 #endif
 
-/* GCC and clang have various useful declarations that can be made with
-   the '__attribute__' syntax.  All of the ways we use this do fine if
-   they are omitted for compilers that don't understand it.  */
-#if !(defined __GNUC__ || defined __clang__)
+/* GCC, clang, and compatible compilers have various useful declarations
+   that can be made with the '__attribute__' syntax.  All of the ways we use
+   this do fine if they are omitted for compilers that don't understand it.  */
+#if !(defined __GNUC__ || defined __clang__ || defined __TINYC__)
 # define __attribute__(xyz)	/* Ignore */
 #endif
 
@@ -606,14 +606,14 @@
 # define __attribute_artificial__ /* Ignore */
 #endif
 
-/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
-   inline semantics, unless -fgnu89-inline is used.  Using __GNUC_STDC_INLINE__
-   or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions
+/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 inline
+   semantics, unless -fgnu89-inline is used.  Using __GNUC_STDC_INLINE__ or
+   __GNUC_GNU_INLINE__ is not a good enough check for gcc because gcc versions
    older than 4.3 may define these macros and still not guarantee GNU inlining
    semantics.
 
    clang++ identifies itself as gcc-4.2, but has support for GNU inlining
-   semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and
+   semantics, that can be checked for by using the __GNUC_STDC_INLINE__ and
    __GNUC_GNU_INLINE__ macro definitions.  */
 #if (!defined __cplusplus || __GNUC_PREREQ (4,3) \
      || (defined __clang__ && (defined __GNUC_STDC_INLINE__ \
@@ -828,6 +828,18 @@ _Static_assert (0, "IEEE 128-bits long double requires redirection on this platf
 # define __HAVE_GENERIC_SELECTION 0
 #endif
 
+#if __HAVE_GENERIC_SELECTION
+/* If PTR is a pointer to const, return CALL cast to type CTYPE,
+   otherwise return CALL.  Pointers to types with non-const qualifiers
+   are not valid.  This should not be defined for C++, as macros are
+   not an appropriate way of implementing such qualifier-generic
+   operations for C++.  */
+# define __glibc_const_generic(PTR, CTYPE, CALL)	\
+  _Generic (0 ? (PTR) : (void *) 1,			\
+	    const void *: (CTYPE) (CALL),		\
+	    default: CALL)
+#endif
+
 #if __GNUC_PREREQ (10, 0)
 /* Designates a 1-based positional argument ref-index of pointer type
    that can be used to access size-index elements of the pointed-to
diff --git a/lib/libc/include/generic-glibc/sys/debugreg.h b/lib/libc/include/generic-glibc/sys/debugreg.h
index 206706490b79c53fed98b71c1f48ee24aa276d71..0915d533cfb538eec7227d53dbb5196a203c40aa 100644
--- a/lib/libc/include/generic-glibc/sys/debugreg.h
+++ b/lib/libc/include/generic-glibc/sys/debugreg.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/dir.h b/lib/libc/include/generic-glibc/sys/dir.h
index 26caaf121e1b2fb74c65b1d63e91a4290b731e59..c664312b4b3050f2e1d9ecc4b383539b2716cee8 100644
--- a/lib/libc/include/generic-glibc/sys/dir.h
+++ b/lib/libc/include/generic-glibc/sys/dir.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/elf.h b/lib/libc/include/generic-glibc/sys/elf.h
index 5517dccb2b01a5d6cab050d8af8832cb3d6f71cc..aae414e6af687ccfae5d24497d2284cca7d1e517 100644
--- a/lib/libc/include/generic-glibc/sys/elf.h
+++ b/lib/libc/include/generic-glibc/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/epoll.h b/lib/libc/include/generic-glibc/sys/epoll.h
index e1beed29ea9a04817285f8ea846b60b2d4ce46fa..0ca1ea780d96469877b1e32a3c126dbb345fc74d 100644
--- a/lib/libc/include/generic-glibc/sys/epoll.h
+++ b/lib/libc/include/generic-glibc/sys/epoll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/eventfd.h b/lib/libc/include/generic-glibc/sys/eventfd.h
index dafde87348ba72acc7c9c0fbb57c05503c155d92..d4e89fbdf81a45d3787b8a7085a231e40506e0d4 100644
--- a/lib/libc/include/generic-glibc/sys/eventfd.h
+++ b/lib/libc/include/generic-glibc/sys/eventfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/fanotify.h b/lib/libc/include/generic-glibc/sys/fanotify.h
index 371384834e8603dddea23b07adf5ac114dd66dc9..4155e61af615b00a2b6891186ebca22d81f6a96a 100644
--- a/lib/libc/include/generic-glibc/sys/fanotify.h
+++ b/lib/libc/include/generic-glibc/sys/fanotify.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/file.h b/lib/libc/include/generic-glibc/sys/file.h
index c791c7b8f982b8cd8ef5f6db6922d9b54a5bf2de..68a1efb13feb06ffd95224cfb86e4893015b0a63 100644
--- a/lib/libc/include/generic-glibc/sys/file.h
+++ b/lib/libc/include/generic-glibc/sys/file.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/fpregdef.h b/lib/libc/include/generic-glibc/sys/fpregdef.h
index a72e1868aef31708482c68f2f2460bfb30ed7429..19db3de6bdbc5c7f95eae059bec5a317e2971675 100644
--- a/lib/libc/include/generic-glibc/sys/fpregdef.h
+++ b/lib/libc/include/generic-glibc/sys/fpregdef.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/fsuid.h b/lib/libc/include/generic-glibc/sys/fsuid.h
index 2975d1b8cf691b8254bc78bcfd9e449a209a0698..635a57bd182bb910326c0b40d3f6501a252a907e 100644
--- a/lib/libc/include/generic-glibc/sys/fsuid.h
+++ b/lib/libc/include/generic-glibc/sys/fsuid.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/gmon_out.h b/lib/libc/include/generic-glibc/sys/gmon_out.h
index 5e29305736dbd20d45568e738b782ae38da0714c..651c3534ab2664a23d8fbfb25d7f9353ca291c80 100644
--- a/lib/libc/include/generic-glibc/sys/gmon_out.h
+++ b/lib/libc/include/generic-glibc/sys/gmon_out.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/hwprobe.h b/lib/libc/include/generic-glibc/sys/hwprobe.h
index 056a98dc5182784e8c74c40331cb5a8b4e7bb00d..6c4c82f9c858123b13ab449406fa079cbc85513f 100644
--- a/lib/libc/include/generic-glibc/sys/hwprobe.h
+++ b/lib/libc/include/generic-glibc/sys/hwprobe.h
@@ -1,5 +1,5 @@
 /* RISC-V architecture probe interface
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/sys/ifunc.h b/lib/libc/include/generic-glibc/sys/ifunc.h
index c4ca0a983ccc513588dc84ce3821e5b0086a7c32..324950053e37c058acfa3fdd018a81bfda28dfa4 100644
--- a/lib/libc/include/generic-glibc/sys/ifunc.h
+++ b/lib/libc/include/generic-glibc/sys/ifunc.h
@@ -1,5 +1,5 @@
 /* Definitions used by AArch64 indirect function resolvers.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/inotify.h b/lib/libc/include/generic-glibc/sys/inotify.h
index a901da49bfc92c7ecc2b2252283ae593b4a1d6c8..af9a9bbe1890fb020917d9cbc0bbae35f2e7ddc4 100644
--- a/lib/libc/include/generic-glibc/sys/inotify.h
+++ b/lib/libc/include/generic-glibc/sys/inotify.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/io.h b/lib/libc/include/generic-glibc/sys/io.h
index 6d9f3e883454fbe9663082d2e90dbc09308a6516..c2780ef5c2a29557037c7dc383de2ffe60142735 100644
--- a/lib/libc/include/generic-glibc/sys/io.h
+++ b/lib/libc/include/generic-glibc/sys/io.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/ioctl.h b/lib/libc/include/generic-glibc/sys/ioctl.h
index c72a90bf7881c39c1b334f4cc1dec6e761153286..b0493878d46373832c1fc9baf84d16df76022a7d 100644
--- a/lib/libc/include/generic-glibc/sys/ioctl.h
+++ b/lib/libc/include/generic-glibc/sys/ioctl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/ipc.h b/lib/libc/include/generic-glibc/sys/ipc.h
index ac30bcaba3849baa13cdf356b8160f79b7b23d03..84a8b6fe189a68f04d16d79db2dab289f5ca95ef 100644
--- a/lib/libc/include/generic-glibc/sys/ipc.h
+++ b/lib/libc/include/generic-glibc/sys/ipc.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/kd.h b/lib/libc/include/generic-glibc/sys/kd.h
index f59730d247691818eadfdd05ed3312d29ec0ebcd..88bbc25a35c934bce9f4dfd466e5f2281f894785 100644
--- a/lib/libc/include/generic-glibc/sys/kd.h
+++ b/lib/libc/include/generic-glibc/sys/kd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/klog.h b/lib/libc/include/generic-glibc/sys/klog.h
index 3d8531cc660599a30111d3ede324f665d1088dfd..ebc6fd7ea3bbfc887030e8a003f0180b66628d8c 100644
--- a/lib/libc/include/generic-glibc/sys/klog.h
+++ b/lib/libc/include/generic-glibc/sys/klog.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/mman.h b/lib/libc/include/generic-glibc/sys/mman.h
index 3577564df0aa784f5b7b83cf83eadb2cfdcab483..f8acac917246e0060e208bfe93232b53e9b95ad2 100644
--- a/lib/libc/include/generic-glibc/sys/mman.h
+++ b/lib/libc/include/generic-glibc/sys/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for BSD-style memory management.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/mount.h b/lib/libc/include/generic-glibc/sys/mount.h
index fbb157810e243939be3b90310458ee8eec739f6e..bf226f5a738b6369caba0558d98357d3cb06e975 100644
--- a/lib/libc/include/generic-glibc/sys/mount.h
+++ b/lib/libc/include/generic-glibc/sys/mount.h
@@ -1,5 +1,5 @@
 /* Header file for mounting/unmount Linux filesystems.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/msg.h b/lib/libc/include/generic-glibc/sys/msg.h
index 8c86c14cf89a75de16d088a3cdc332cba8844ec8..4c05ef89108fad09745bb59e8640f44eb71404a3 100644
--- a/lib/libc/include/generic-glibc/sys/msg.h
+++ b/lib/libc/include/generic-glibc/sys/msg.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/mtio.h b/lib/libc/include/generic-glibc/sys/mtio.h
index 7c53ec28fe2e317cae8f4e4026fcfc9ed4eca7f8..cdb3899009e167ace832cfa92c9301062214401b 100644
--- a/lib/libc/include/generic-glibc/sys/mtio.h
+++ b/lib/libc/include/generic-glibc/sys/mtio.h
@@ -1,5 +1,5 @@
 /* Structures and definitions for magnetic tape I/O control commands.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/param.h b/lib/libc/include/generic-glibc/sys/param.h
index e66c19eaae7ba99b1ac3cf04f12f636f6b372b6d..c4ea4544d45936f0661dd3c5e6457435bd5cb12d 100644
--- a/lib/libc/include/generic-glibc/sys/param.h
+++ b/lib/libc/include/generic-glibc/sys/param.h
@@ -1,5 +1,5 @@
 /* Compatibility header for old-style Unix parameters and limits.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/pci.h b/lib/libc/include/generic-glibc/sys/pci.h
index ec6b7ce780c9722480dcfb3cb294610f7788373a..b5475dd02b24d3a68e27d2a24645cd572d81d551 100644
--- a/lib/libc/include/generic-glibc/sys/pci.h
+++ b/lib/libc/include/generic-glibc/sys/pci.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/perm.h b/lib/libc/include/generic-glibc/sys/perm.h
index 5a95dce3845b5a357e044997081a5154861e6f69..e864375c1931be45f207ca3c9a021d897a8fb013 100644
--- a/lib/libc/include/generic-glibc/sys/perm.h
+++ b/lib/libc/include/generic-glibc/sys/perm.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/personality.h b/lib/libc/include/generic-glibc/sys/personality.h
index 500950aa5ccab951b43ac4ea61fd1f008987498f..54510789bc5fe07ce95ae7759dbe013da3ff5c44 100644
--- a/lib/libc/include/generic-glibc/sys/personality.h
+++ b/lib/libc/include/generic-glibc/sys/personality.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/pidfd.h b/lib/libc/include/generic-glibc/sys/pidfd.h
index 406bf2f5fb90028208fdf7c9bdc33ba372c53b18..3d9ab9430c72d2b947860d9fa6b9525a6ebc11aa 100644
--- a/lib/libc/include/generic-glibc/sys/pidfd.h
+++ b/lib/libc/include/generic-glibc/sys/pidfd.h
@@ -1,5 +1,5 @@
 /* Wrapper for file descriptors that refers to a process functions.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -45,6 +45,64 @@
 #define PIDFD_GET_USER_NAMESPACE              _IO(PIDFS_IOCTL_MAGIC, 9)
 #define PIDFD_GET_UTS_NAMESPACE               _IO(PIDFS_IOCTL_MAGIC, 10)
 
+/* Sentinels to avoid allocating a file descriptor to refer to own process.  */
+#define PIDFD_SELF_THREAD                     -10000
+#define PIDFD_SELF_THREAD_GROUP               -10001
+#define PIDFD_SELF                            PIDFD_SELF_THREAD
+#define PIDFD_SELF_PROCESS                    PIDFD_SELF_THREAD_GROUP
+
+
+/* Flags for pidfd_info.  */
+
+/* Always returned, even if not requested */
+#define PIDFD_INFO_PID                        (1UL << 0)
+/* Always returned, even if not requested */
+#define PIDFD_INFO_CREDS                      (1UL << 1)
+/* Always returned if available, even if not requested */
+#define PIDFD_INFO_CGROUPID                   (1UL << 2)
+/* Only returned if requested. */
+#define PIDFD_INFO_EXIT                       (1UL << 3)
+/* Only returned if requested. */
+#define PIDFD_INFO_COREDUMP                   (1UL << 4)
+
+
+/* Value for coredump_mask in pidfd_info.  Only valid if PIDFD_INFO_COREDUMP
+   is set in mask.  */
+
+/* Did crash and... */
+#define PIDFD_COREDUMPED                      (1U << 0)
+/* coredumping generation was skipped. */
+#define PIDFD_COREDUMP_SKIP                   (1U << 1)
+/* coredump was done as the user. */
+#define PIDFD_COREDUMP_USER                   (1U << 2)
+/* coredump was done as root. */
+#define PIDFD_COREDUMP_ROOT                   (1U << 3)
+
+struct pidfd_info
+{
+  __uint64_t mask;
+  __uint64_t cgroupid;
+  __uint32_t pid;
+  __uint32_t tgid;
+  __uint32_t ppid;
+  __uint32_t ruid;
+  __uint32_t rgid;
+  __uint32_t euid;
+  __uint32_t egid;
+  __uint32_t suid;
+  __uint32_t sgid;
+  __uint32_t fsuid;
+  __uint32_t fsgid;
+  __int32_t  exit_code;
+  __uint32_t coredump_mask;
+  __uint32_t __spare1;
+};
+
+/* sizeof first published struct */
+#define PIDFD_INFO_SIZE_VER0                  64
+
+#define PIDFD_GET_INFO                        _IOWR(PIDFS_IOCTL_MAGIC, 11, struct pidfd_info)
+
 /* Returns a file descriptor that refers to the process PID.  The
    close-on-exec is set on the file descriptor.  */
 extern int pidfd_open (__pid_t __pid, unsigned int __flags) __THROW;
diff --git a/lib/libc/include/generic-glibc/sys/platform/ppc.h b/lib/libc/include/generic-glibc/sys/platform/ppc.h
index 9a4dbd6c3663525df31749143824eb72dd9fda6a..6e7df94235d78f7b3ad6c8644301f8d0441a264e 100644
--- a/lib/libc/include/generic-glibc/sys/platform/ppc.h
+++ b/lib/libc/include/generic-glibc/sys/platform/ppc.h
@@ -1,5 +1,5 @@
 /* Facilities specific to the PowerPC architecture
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/platform/x86.h b/lib/libc/include/generic-glibc/sys/platform/x86.h
index 40c91f375f864e6464ad21baa9a5dc60f47856c8..6ef7dfcec3ed5c8ad1135c000d73bac29892566c 100644
--- a/lib/libc/include/generic-glibc/sys/platform/x86.h
+++ b/lib/libc/include/generic-glibc/sys/platform/x86.h
@@ -1,6 +1,6 @@
 /* Data structure for x86 CPU features.
    This file is part of the GNU C Library.
-   Copyright (C) 2008-2025 Free Software Foundation, Inc.
+   Copyright (C) 2008-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/generic-glibc/sys/poll.h b/lib/libc/include/generic-glibc/sys/poll.h
index 7c4a6caecd48272ff9802368218446ae30939e96..d42c12762217bbe57763f8a43254c745245e0712 100644
--- a/lib/libc/include/generic-glibc/sys/poll.h
+++ b/lib/libc/include/generic-glibc/sys/poll.h
@@ -1,5 +1,5 @@
 /* Compatibility definitions for System V `poll' interface.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/prctl.h b/lib/libc/include/generic-glibc/sys/prctl.h
index 7b9871fa28f3c4fb5953206ed1637d23372c7d3d..e83d37d64d631e5cdc2f048b7ab2043e65353ea1 100644
--- a/lib/libc/include/generic-glibc/sys/prctl.h
+++ b/lib/libc/include/generic-glibc/sys/prctl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/procfs.h b/lib/libc/include/generic-glibc/sys/procfs.h
index 03b03eb154706c077e57fa8e0ef87dcd571b8636..0cb97976cb49c98feef0d864523ecc5a5a49190c 100644
--- a/lib/libc/include/generic-glibc/sys/procfs.h
+++ b/lib/libc/include/generic-glibc/sys/procfs.h
@@ -1,5 +1,5 @@
 /* Definitions for core files and libthread_db.  Generic Linux version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/sys/profil.h b/lib/libc/include/generic-glibc/sys/profil.h
index aa62432612d2a94fb06875deb888036de434be94..77650613858832b6712c934f976e8eced5aeef6f 100644
--- a/lib/libc/include/generic-glibc/sys/profil.h
+++ b/lib/libc/include/generic-glibc/sys/profil.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/ptrace.h b/lib/libc/include/generic-glibc/sys/ptrace.h
index 6a8779c2a3709d9c04a373c081b2905d10230338..ff5510d07fdd87b709875a5ed64eec3162675354 100644
--- a/lib/libc/include/generic-glibc/sys/ptrace.h
+++ b/lib/libc/include/generic-glibc/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/generic-glibc/sys/quota.h b/lib/libc/include/generic-glibc/sys/quota.h
index e057a86392ac58542e5c356b95d40c9727415af4..f9f76f3113d245723fae2bfe9f206a12c99c703e 100644
--- a/lib/libc/include/generic-glibc/sys/quota.h
+++ b/lib/libc/include/generic-glibc/sys/quota.h
@@ -1,5 +1,5 @@
 /* This just represents the non-kernel parts of <linux/quota.h>.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/random.h b/lib/libc/include/generic-glibc/sys/random.h
index b1df7f43385731e1fe014593a4c6f7cb0d30089b..7a2928ba5f52029a80a547f0cf8489334999ca2f 100644
--- a/lib/libc/include/generic-glibc/sys/random.h
+++ b/lib/libc/include/generic-glibc/sys/random.h
@@ -1,5 +1,5 @@
 /* Interfaces for obtaining random bytes.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/raw.h b/lib/libc/include/generic-glibc/sys/raw.h
index a215a84c91d7db36d1408175a59d5332581dda9b..e38181803449cbf45f32f7a4eba1ce929384af93 100644
--- a/lib/libc/include/generic-glibc/sys/raw.h
+++ b/lib/libc/include/generic-glibc/sys/raw.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/reboot.h b/lib/libc/include/generic-glibc/sys/reboot.h
index 95819b9cfb5261ed33d5047783b75a27b81a62ba..04a13f0b1d1d9cf764a95cdad51f51048e550bf0 100644
--- a/lib/libc/include/generic-glibc/sys/reboot.h
+++ b/lib/libc/include/generic-glibc/sys/reboot.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/reg.h b/lib/libc/include/generic-glibc/sys/reg.h
index 5cf5759ef52c931bf05cd1724afe6b4173ccc1e8..819876e9cf786ff8d760fcb38686bfd29f178125 100644
--- a/lib/libc/include/generic-glibc/sys/reg.h
+++ b/lib/libc/include/generic-glibc/sys/reg.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/regdef.h b/lib/libc/include/generic-glibc/sys/regdef.h
index 947681c6db4bcf40b40d8a54d11fd1efd4f39d88..82bf4f9558f2122172222bd099af04a3d6c03eec 100644
--- a/lib/libc/include/generic-glibc/sys/regdef.h
+++ b/lib/libc/include/generic-glibc/sys/regdef.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/resource.h b/lib/libc/include/generic-glibc/sys/resource.h
index 13b06c36e8e2acbb3b354778c72c48e2b1f2a2b2..0752d50d52ecc5b0e115fb9d137b1f2c8f828c1b 100644
--- a/lib/libc/include/generic-glibc/sys/resource.h
+++ b/lib/libc/include/generic-glibc/sys/resource.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/rseq.h b/lib/libc/include/generic-glibc/sys/rseq.h
index 81856aeddf39799e31bbd90f68e3cdcc405aedcc..f6f18e1b4eb8167a0141c8a27963c343dd5055fc 100644
--- a/lib/libc/include/generic-glibc/sys/rseq.h
+++ b/lib/libc/include/generic-glibc/sys/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences exported symbols.  Linux header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/generic-glibc/sys/select.h b/lib/libc/include/generic-glibc/sys/select.h
index cd8c69ee6d9680d3f7e37eeb09fb9053e62ac170..7308c98432e5ea475b46e654a70d098c8e7be52f 100644
--- a/lib/libc/include/generic-glibc/sys/select.h
+++ b/lib/libc/include/generic-glibc/sys/select.h
@@ -1,5 +1,5 @@
 /* `fd_set' type and related macros, and `select'/`pselect' declarations.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/sem.h b/lib/libc/include/generic-glibc/sys/sem.h
index f0d3b00dbe71eec7b9c323008798ab197d475d6d..7c362679feb52e4d474ed6fe27acb359e7d50ead 100644
--- a/lib/libc/include/generic-glibc/sys/sem.h
+++ b/lib/libc/include/generic-glibc/sys/sem.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/sendfile.h b/lib/libc/include/generic-glibc/sys/sendfile.h
index 46b0f3cc8dafbdebad9c3e573906e3ff7ddea706..a980436ceadd12af19beccee9ce4c7a6cbae7290 100644
--- a/lib/libc/include/generic-glibc/sys/sendfile.h
+++ b/lib/libc/include/generic-glibc/sys/sendfile.h
@@ -1,5 +1,5 @@
 /* sendfile -- copy data directly from one file descriptor to another
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/shm.h b/lib/libc/include/generic-glibc/sys/shm.h
index 54ff00ee99d07ca658340dfb76a12a7a6ec23f1d..c7b6bc19d2b7d91a7f9c7dc031ec4b185f496514 100644
--- a/lib/libc/include/generic-glibc/sys/shm.h
+++ b/lib/libc/include/generic-glibc/sys/shm.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/signalfd.h b/lib/libc/include/generic-glibc/sys/signalfd.h
index 33d06ff14742d9dfcd7af1cb64337f31a81b0abc..c8da4d7cfd9ec348d505fd367918102fbe376d23 100644
--- a/lib/libc/include/generic-glibc/sys/signalfd.h
+++ b/lib/libc/include/generic-glibc/sys/signalfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/single_threaded.h b/lib/libc/include/generic-glibc/sys/single_threaded.h
index 5fec9a477c4896039776345c2458b1fa144ba692..1e3dbac23038def741abea8a27cfd181fab9709b 100644
--- a/lib/libc/include/generic-glibc/sys/single_threaded.h
+++ b/lib/libc/include/generic-glibc/sys/single_threaded.h
@@ -1,5 +1,5 @@
 /* Support for single-thread optimizations.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/socket.h b/lib/libc/include/generic-glibc/sys/socket.h
index 890b8cd2e6792788a30e2c5d2502c4f5203056bc..db2c0d50cd58b9de9f0706e58de3b9d50314899b 100644
--- a/lib/libc/include/generic-glibc/sys/socket.h
+++ b/lib/libc/include/generic-glibc/sys/socket.h
@@ -1,5 +1,5 @@
 /* Declarations of socket constants, types, and functions.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/stat.h b/lib/libc/include/generic-glibc/sys/stat.h
index 68c2c889e88307f1dfebcf868a83761333b74337..38d6719324e299a2a8a1e7c9b6a9bae0784d1fc4 100644
--- a/lib/libc/include/generic-glibc/sys/stat.h
+++ b/lib/libc/include/generic-glibc/sys/stat.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/statfs.h b/lib/libc/include/generic-glibc/sys/statfs.h
index 1e7bd78d22512538978fb93203c2c834ee80b0f7..c24106980a9525ad513c27d72db8685194a2005b 100644
--- a/lib/libc/include/generic-glibc/sys/statfs.h
+++ b/lib/libc/include/generic-glibc/sys/statfs.h
@@ -1,5 +1,5 @@
 /* Definitions for getting information about a filesystem.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/statvfs.h b/lib/libc/include/generic-glibc/sys/statvfs.h
index 599ac139f4fa92f5c5784c55c289e6bc5c236a95..5877e0d122f11ef9b2c766c5b719a43a55fa9d2a 100644
--- a/lib/libc/include/generic-glibc/sys/statvfs.h
+++ b/lib/libc/include/generic-glibc/sys/statvfs.h
@@ -1,5 +1,5 @@
 /* Definitions for getting information about a filesystem.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/swap.h b/lib/libc/include/generic-glibc/sys/swap.h
index f67cfebb1f103561a1310536a5ee32d1697667fb..a85f64a57a4604a50906ec4c99bd039a184601d3 100644
--- a/lib/libc/include/generic-glibc/sys/swap.h
+++ b/lib/libc/include/generic-glibc/sys/swap.h
@@ -1,5 +1,5 @@
 /* Calls to enable and disable swapping on specified locations.  Linux version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/syscall.h b/lib/libc/include/generic-glibc/sys/syscall.h
index 20bebd9b72a57de841b38d8995159535e94abdb9..1b589aa1383f67de2680840ef21aa54381bbc193 100644
--- a/lib/libc/include/generic-glibc/sys/syscall.h
+++ b/lib/libc/include/generic-glibc/sys/syscall.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/sysinfo.h b/lib/libc/include/generic-glibc/sys/sysinfo.h
index 2c1456dd16f212807c0a0955cf88c464235466d7..41634f45dc4c4bc52f42e94f0e8c2997f5fffcef 100644
--- a/lib/libc/include/generic-glibc/sys/sysinfo.h
+++ b/lib/libc/include/generic-glibc/sys/sysinfo.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/sysmacros.h b/lib/libc/include/generic-glibc/sys/sysmacros.h
index 08c384dbfae4c1042ac215803e635c4e2d57a95e..54ae56a2cc8cc6baf9040e135953e204d7696fee 100644
--- a/lib/libc/include/generic-glibc/sys/sysmacros.h
+++ b/lib/libc/include/generic-glibc/sys/sysmacros.h
@@ -1,5 +1,5 @@
 /* Definitions of macros to access `dev_t' values.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/sysmips.h b/lib/libc/include/generic-glibc/sys/sysmips.h
index c5ef1a5987041c9557d02d094edc64141f7be739..0b25a9fbbc89d48b6bc9f7c2d77ea747d282b02e 100644
--- a/lib/libc/include/generic-glibc/sys/sysmips.h
+++ b/lib/libc/include/generic-glibc/sys/sysmips.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/tas.h b/lib/libc/include/generic-glibc/sys/tas.h
index 2f9a9bb665b3aaf767c2511a58fb2605a4b9e7b6..5af1c307ce8966ea98a933108874cc34642a5b66 100644
--- a/lib/libc/include/generic-glibc/sys/tas.h
+++ b/lib/libc/include/generic-glibc/sys/tas.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/time.h b/lib/libc/include/generic-glibc/sys/time.h
index 7f9e9e81515f82af290fd41f800f9ead19b47679..c07530e3a2e14d2f0840775bbd82773f4532a6de 100644
--- a/lib/libc/include/generic-glibc/sys/time.h
+++ b/lib/libc/include/generic-glibc/sys/time.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/timeb.h b/lib/libc/include/generic-glibc/sys/timeb.h
index 30cef7dcb76081005a35e00b54020878303809a4..d7c8381c3123fc59430636f274ed5b8527597722 100644
--- a/lib/libc/include/generic-glibc/sys/timeb.h
+++ b/lib/libc/include/generic-glibc/sys/timeb.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1994-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/timerfd.h b/lib/libc/include/generic-glibc/sys/timerfd.h
index 4fcf48d27f961a8f1d07ef6d18f64355db2c7233..f72a5e139bb9b572bccca422ccda83b652fae2ac 100644
--- a/lib/libc/include/generic-glibc/sys/timerfd.h
+++ b/lib/libc/include/generic-glibc/sys/timerfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2008-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/times.h b/lib/libc/include/generic-glibc/sys/times.h
index eccd085d85310b2af9d9198b332d4e7d451038fe..8cd21a5bbcc1a05fdbf32144acfbe6e3be43be62 100644
--- a/lib/libc/include/generic-glibc/sys/times.h
+++ b/lib/libc/include/generic-glibc/sys/times.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/timex.h b/lib/libc/include/generic-glibc/sys/timex.h
index 40e405c0adcb643c9bd44d6cb81593c6db9b6268..3f8c65443fd4769bbe9e0996ea351bba97c2ccf1 100644
--- a/lib/libc/include/generic-glibc/sys/timex.h
+++ b/lib/libc/include/generic-glibc/sys/timex.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/types.h b/lib/libc/include/generic-glibc/sys/types.h
index 3e0c7f44e15b59170ceb58f9f956c6ffce173d9a..595ac4e9e0575a45430a043c6c16159f82ddf77f 100644
--- a/lib/libc/include/generic-glibc/sys/types.h
+++ b/lib/libc/include/generic-glibc/sys/types.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/ucontext.h b/lib/libc/include/generic-glibc/sys/ucontext.h
index 90543bcf30ebbddfdc0627f89438aef709cb78b5..3faf674935dafa18d104764cc0587ce20d4228f5 100644
--- a/lib/libc/include/generic-glibc/sys/ucontext.h
+++ b/lib/libc/include/generic-glibc/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.  This file is part of the GNU C Library.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.  This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/generic-glibc/sys/uio.h b/lib/libc/include/generic-glibc/sys/uio.h
index bfebc145f26db8afd010774d07f06ad5786451ca..856c15c3a0fb95fc3132a3f47e53c4ecfd9502b9 100644
--- a/lib/libc/include/generic-glibc/sys/uio.h
+++ b/lib/libc/include/generic-glibc/sys/uio.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/un.h b/lib/libc/include/generic-glibc/sys/un.h
index 0c77b772616e81f89c541d888191312082cacc56..bb7f12b96d99479f6a039c02e943749f90ec6f00 100644
--- a/lib/libc/include/generic-glibc/sys/un.h
+++ b/lib/libc/include/generic-glibc/sys/un.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/user.h b/lib/libc/include/generic-glibc/sys/user.h
index 08a54ee5a4c4e465d3444ac39a94f41a5433924a..64d46ba5b24dac6d3f65ec0cf49f86f2fbca47cf 100644
--- a/lib/libc/include/generic-glibc/sys/user.h
+++ b/lib/libc/include/generic-glibc/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/utsname.h b/lib/libc/include/generic-glibc/sys/utsname.h
index c48a67a105d469b76c561f5fc284a8e5882a5bbf..c9daa88cf94a0096a6e0453a058bfdfd02c64d59 100644
--- a/lib/libc/include/generic-glibc/sys/utsname.h
+++ b/lib/libc/include/generic-glibc/sys/utsname.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/vlimit.h b/lib/libc/include/generic-glibc/sys/vlimit.h
index 179271da656b936ffdfe19c91854a672300e3631..4730fc37daf4c7e73ebb56c355e5390c699af2a3 100644
--- a/lib/libc/include/generic-glibc/sys/vlimit.h
+++ b/lib/libc/include/generic-glibc/sys/vlimit.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/vm86.h b/lib/libc/include/generic-glibc/sys/vm86.h
index ff38ebedaffa156ec50db044282e271143348900..44d4cdd19959d4e10c8bcf2acab1ee214c261556 100644
--- a/lib/libc/include/generic-glibc/sys/vm86.h
+++ b/lib/libc/include/generic-glibc/sys/vm86.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/wait.h b/lib/libc/include/generic-glibc/sys/wait.h
index f11f89f7cb62784c7753e00359ab45913f2813a3..23d689a05166f4fb3fc32f26196e346f0d2af746 100644
--- a/lib/libc/include/generic-glibc/sys/wait.h
+++ b/lib/libc/include/generic-glibc/sys/wait.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/sys/xattr.h b/lib/libc/include/generic-glibc/sys/xattr.h
index 669781b6a2afa06e885e28ea99e436e9791614d2..736074937f3c530a7959842e2d1b62ea31239be4 100644
--- a/lib/libc/include/generic-glibc/sys/xattr.h
+++ b/lib/libc/include/generic-glibc/sys/xattr.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/tar.h b/lib/libc/include/generic-glibc/tar.h
index 68dddef340f123fcdb303b1f2b29d033b7a2810c..f2da3fd9eb90adae522a0de665db775401cb4a46 100644
--- a/lib/libc/include/generic-glibc/tar.h
+++ b/lib/libc/include/generic-glibc/tar.h
@@ -1,5 +1,5 @@
 /* Extended tar format from POSIX.1.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/termios.h b/lib/libc/include/generic-glibc/termios.h
index ef7b166b4c422e51270f1409f7c2abf8d546a797..cfdf0dfad72de68d495f64e7d65f518b018046c7 100644
--- a/lib/libc/include/generic-glibc/termios.h
+++ b/lib/libc/include/generic-glibc/termios.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/tgmath.h b/lib/libc/include/generic-glibc/tgmath.h
index 4eae43da5e045050d1b0652a308e74ae6c38fee0..d2c5da3436163c2d1cfab0b65005dbcf9d322df0 100644
--- a/lib/libc/include/generic-glibc/tgmath.h
+++ b/lib/libc/include/generic-glibc/tgmath.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -30,6 +30,10 @@
 #include <math.h>
 #include <complex.h>
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_TGMATH_H__ 202311L
+#endif
+
 
 /* There are two variant implementations of type-generic macros in
    this file: one for GCC 8 and later, using __builtin_tgmath and
@@ -386,7 +390,7 @@
 #   define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct)	\
   __TGMATH_3 (Fct, (Val1), (Val2), (Val3))
 #  endif
-#  define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct)	\
+#  define __TGMATH_TERNARY_FIRST_REAL_ONLY(Val1, Val2, Val3, Fct)	\
   __TGMATH_3 (Fct, (Val1), (Val2), (Val3))
 #  define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct)	\
   __TGMATH_1C (Fct, Cfct, (Val))
@@ -520,14 +524,17 @@
 # endif
 
 # if !__HAVE_BUILTIN_TGMATH
-#  define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \
-     (__extension__ ((sizeof (+(Val1)) == sizeof (double)		\
-		      || __builtin_classify_type (Val1) != 8)		\
-		     ? Fct (Val1, Val2, Val3)				\
-		     : (sizeof (+(Val1)) == sizeof (float))		\
-		     ? Fct##f (Val1, Val2, Val3)			\
-		     : __TGMATH_F128 ((Val1), Fct, (Val1, Val2, Val3))	\
-		     __tgml(Fct) (Val1, Val2, Val3)))
+#  define __TGMATH_TERNARY_FIRST_REAL_ONLY(Val1, Val2, Val3, Fct)	      \
+     (__extension__ ((sizeof (+(Val1)) == sizeof (double)		      \
+		      || __builtin_classify_type (Val1) != 8)		      \
+		     ? (__tgmath_real_type (Val1)) Fct (Val1, Val2, Val3)     \
+		     : (sizeof (+(Val1)) == sizeof (float))		      \
+		     ? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2, Val3)  \
+		     : __TGMATH_F128 ((Val1),				      \
+				      (__tgmath_real_type (Val1)) Fct,	      \
+				      (Val1, Val2, Val3))		      \
+		     (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2,     \
+							      Val3)))
 
 /* XXX This definition has to be changed as soon as the compiler understands
    the imaginary keyword.  */
@@ -1056,17 +1063,17 @@
 /* Round X to nearest integer value, rounding halfway cases to even.  */
 # define roundeven(Val) __TGMATH_UNARY_REAL_ONLY (Val, roundeven)
 
-# define fromfp(Val1, Val2, Val3)					\
-  __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfp)
+# define fromfp(Val1, Val2, Val3)				\
+  __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, fromfp)
 
-# define ufromfp(Val1, Val2, Val3)					\
-  __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfp)
+# define ufromfp(Val1, Val2, Val3)				\
+  __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, ufromfp)
 
-# define fromfpx(Val1, Val2, Val3)					\
-  __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfpx)
+# define fromfpx(Val1, Val2, Val3)				\
+  __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, fromfpx)
 
-# define ufromfpx(Val1, Val2, Val3)					\
-  __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfpx)
+# define ufromfpx(Val1, Val2, Val3)				\
+  __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, ufromfpx)
 
 /* Like ilogb, but returning long int.  */
 # define llogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llogb)
diff --git a/lib/libc/include/generic-glibc/thread_db.h b/lib/libc/include/generic-glibc/thread_db.h
index 6097635a684640b5edb19b37a4b720025c644807..cf14aaf04b41fd8439e410bc3acdcc0ed2eed933 100644
--- a/lib/libc/include/generic-glibc/thread_db.h
+++ b/lib/libc/include/generic-glibc/thread_db.h
@@ -1,5 +1,5 @@
 /* thread_db.h -- interface to libthread_db.so library for debugging -lpthread
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/threads.h b/lib/libc/include/generic-glibc/threads.h
index 44febdd5e6118501c36332b378e724f3f50084e5..46982cb74482a030a2b3518243a53197764bc032 100644
--- a/lib/libc/include/generic-glibc/threads.h
+++ b/lib/libc/include/generic-glibc/threads.h
@@ -1,5 +1,5 @@
 /* ISO C11 Standard: 7.26 - Thread support library  <threads.h>.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -31,6 +31,7 @@
 __BEGIN_DECLS
 
 #include <bits/thread-shared-types.h>
+#include <bits/types/once_flag.h>
 #include <bits/types/struct_timespec.h>
 
 #if (!defined __STDC_VERSION__				\
@@ -64,9 +65,6 @@ enum
   mtx_timed     = 2
 };
 
-typedef __once_flag once_flag;
-#define ONCE_FLAG_INIT __ONCE_FLAG_INIT
-
 typedef union
 {
   char __size[__SIZEOF_PTHREAD_MUTEX_T];
diff --git a/lib/libc/include/generic-glibc/time.h b/lib/libc/include/generic-glibc/time.h
index dae39625df6e158eda19e14c413aaae9d0b5eabb..10e59b0fdece92e39220719b33d64774d2e254f6 100644
--- a/lib/libc/include/generic-glibc/time.h
+++ b/lib/libc/include/generic-glibc/time.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -28,6 +28,10 @@
 #define __need_NULL
 #include <stddef.h>
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_TIME_H__ 202311L
+#endif
+
 /* This defines CLOCKS_PER_SEC, which is the number of processor clock
    ticks per second, and possibly a number of other constants.   */
 #include <bits/time.h>
@@ -64,6 +68,11 @@ typedef __pid_t pid_t;
 /* Time base values for timespec_get.  */
 # define TIME_UTC 1
 #endif
+#if __GLIBC_USE (ISOC23)
+# define TIME_MONOTONIC          2
+# define TIME_ACTIVE             3
+# define TIME_THREAD_ACTIVE      4
+#endif
 
 __BEGIN_DECLS
 
diff --git a/lib/libc/include/generic-glibc/uchar.h b/lib/libc/include/generic-glibc/uchar.h
index ba74f0f65b57a2ddc3e2e1ec05df35da460d2a33..d982dbd2d4de91889b45c0e65dda6f62d975859d 100644
--- a/lib/libc/include/generic-glibc/uchar.h
+++ b/lib/libc/include/generic-glibc/uchar.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2011-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -31,6 +31,10 @@
 #include <bits/types.h>
 #include <bits/types/mbstate_t.h>
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_UCHAR_H__ 202311L
+#endif
+
 /* Declare the C23 char8_t typedef in C23 modes, but only if the C++
   __cpp_char8_t feature test macro is not defined.  */
 #if __GLIBC_USE (ISOC23) && !defined __cpp_char8_t
diff --git a/lib/libc/include/generic-glibc/ucontext.h b/lib/libc/include/generic-glibc/ucontext.h
index a5335fb044c0f8ec72d99d2ed88cdfee4459e5fb..647139a8d2f70e80722090f7b05fe562d6129296 100644
--- a/lib/libc/include/generic-glibc/ucontext.h
+++ b/lib/libc/include/generic-glibc/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/ulimit.h b/lib/libc/include/generic-glibc/ulimit.h
index 538a824196e31034615617222d9aff65df0bfe3d..2db9cd138fbd339bf5919f22945db5d3eadc7f8e 100644
--- a/lib/libc/include/generic-glibc/ulimit.h
+++ b/lib/libc/include/generic-glibc/ulimit.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/unistd.h b/lib/libc/include/generic-glibc/unistd.h
index 6aaa1bfa90b37f2ad0071fe5eb3a5fb76623e1cd..84c8077a45220b63e3ee082b9b595252e7d7da7c 100644
--- a/lib/libc/include/generic-glibc/unistd.h
+++ b/lib/libc/include/generic-glibc/unistd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/utime.h b/lib/libc/include/generic-glibc/utime.h
index 104fb07a59dc52dedc5f426c4613dcd08acd9fc9..09c1dd44add59347bd02646fa653920a5cdee718 100644
--- a/lib/libc/include/generic-glibc/utime.h
+++ b/lib/libc/include/generic-glibc/utime.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/utmp.h b/lib/libc/include/generic-glibc/utmp.h
index 7d9d41a12dda15fcd1736466eab00b42255e8b44..a6cf1db1da5058dd71865c87ff174901f2f52f92 100644
--- a/lib/libc/include/generic-glibc/utmp.h
+++ b/lib/libc/include/generic-glibc/utmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1993-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/utmpx.h b/lib/libc/include/generic-glibc/utmpx.h
index 2409d6049d1d6ced24d7c4708a7166ea03b95c7a..708f5b5e9ffd40c9d01912d1acf1ea198fa1eb30 100644
--- a/lib/libc/include/generic-glibc/utmpx.h
+++ b/lib/libc/include/generic-glibc/utmpx.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/values.h b/lib/libc/include/generic-glibc/values.h
index af02e71c9a9076e1ac37eff944c376f7334ac4ee..037e0ff7361ff7fa767903c72c768f17bb97febe 100644
--- a/lib/libc/include/generic-glibc/values.h
+++ b/lib/libc/include/generic-glibc/values.h
@@ -1,5 +1,5 @@
 /* Old compatibility names for <limits.h> and <float.h> constants.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/wchar.h b/lib/libc/include/generic-glibc/wchar.h
index b8fb4b832bef999d106f07ec8d0a9a1b14fe1630..ea02fbe93b8b7b06a547411da8573701c63711c5 100644
--- a/lib/libc/include/generic-glibc/wchar.h
+++ b/lib/libc/include/generic-glibc/wchar.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -60,6 +60,10 @@ typedef __gnuc_va_list va_list;
 # include <bits/types/locale_t.h>
 #endif
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_WCHAR_H__ 202311L
+#endif
+
 /* Tell the caller that we provide correct C++ prototypes.  */
 #if defined __cplusplus && __GNUC_PREREQ (4, 4)
 # define __CORRECT_ISO_CPP_WCHAR_H_PROTO
@@ -188,6 +192,10 @@ extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
 #else
 extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
      __THROW __attribute_pure__;
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define wcschr(WCS, WC)						\
+  __glibc_const_generic (WCS, const wchar_t *, wcschr (WCS, WC))
+# endif
 #endif
 /* Find the last occurrence of WC in WCS.  */
 #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
@@ -198,6 +206,10 @@ extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
 #else
 extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
      __THROW __attribute_pure__;
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define wcsrchr(WCS, WC)						\
+  __glibc_const_generic (WCS, const wchar_t *, wcsrchr (WCS, WC))
+# endif
 #endif
 
 #ifdef __USE_GNU
@@ -225,6 +237,10 @@ extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
 #else
 extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
      __THROW __attribute_pure__;
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define wcspbrk(WCS, ACCEPT)						\
+  __glibc_const_generic (WCS, const wchar_t *, wcspbrk (WCS, ACCEPT))
+# endif
 #endif
 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
 #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
@@ -236,6 +252,11 @@ extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
 #else
 extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
      __THROW __attribute_pure__;
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define wcsstr(HAYSTACK, NEEDLE)			\
+  __glibc_const_generic (HAYSTACK, const wchar_t *,	\
+			 wcsstr (HAYSTACK, NEEDLE))
+# endif
 #endif
 
 /* Divide WCS into tokens separated by characters in DELIM.  */
@@ -277,6 +298,10 @@ extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
 #else
 extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
      __THROW __attribute_pure__;
+# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+#  define wmemchr(S, C, N)					\
+  __glibc_const_generic (S, const wchar_t *, wmemchr (S, C, N))
+# endif
 #endif
 
 /* Compare N wide characters of S1 and S2.  */
diff --git a/lib/libc/include/generic-glibc/wctype.h b/lib/libc/include/generic-glibc/wctype.h
index 200c96e89d6de83b3f7d6be6e9bc13ad7a67a002..097703b08ee774f29f64c03e1b4395a20ff90494 100644
--- a/lib/libc/include/generic-glibc/wctype.h
+++ b/lib/libc/include/generic-glibc/wctype.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/wordexp.h b/lib/libc/include/generic-glibc/wordexp.h
index 115723b859508762cff82aef4f9d261d8b473b93..b0db95f47164a0a665aacb25c1cc05af8fc2989d 100644
--- a/lib/libc/include/generic-glibc/wordexp.h
+++ b/lib/libc/include/generic-glibc/wordexp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/fcntl.h b/lib/libc/include/loongarch-linux-gnu/bits/fcntl.h
index 8b96b7a9c28d97841d610f8c35dbd6c6ce42c2ae..6c36c9f0bd79849ecb06a209ecff9289042a7d4d 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for the generic Linux/LoongArch ABI.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/fenv.h b/lib/libc/include/loongarch-linux-gnu/bits/fenv.h
index 318c579edbc5459e6c76fa99b0293dc09ec0af10..4c19156d32f667c34e7b0953d26da84fda73c275 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/fenv.h
@@ -1,5 +1,5 @@
 /* Floating point environment.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/hwcap.h b/lib/libc/include/loongarch-linux-gnu/bits/hwcap.h
index 4cdf84fec872bb1588fc1cb5dccd3c26003cace1..d6335ffaa97c3c61cd1452cd3f01b8fc0903aa9d 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/hwcap.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP.  LoongArch64 Linux version.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/link.h b/lib/libc/include/loongarch-linux-gnu/bits/link.h
index 787518441210647a1a30b93a8fdf94c802c5567c..7e963fc047f7449ddf5faf540dcf1cba442db0ac 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/link.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/link.h
@@ -1,5 +1,5 @@
 /* Machine-specific declarations for dynamic linker interface.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/link_lavcurrent.h b/lib/libc/include/loongarch-linux-gnu/bits/link_lavcurrent.h
index 0d0fcc213e6f191e5c7d47ad9c95001dd9473f16..d9827f7cb5930ac6836d1956a1a86c9f937e27b9 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/link_lavcurrent.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/link_lavcurrent.h
@@ -1,6 +1,6 @@
 /* Data structure for communication from the run-time dynamic linker for
    loaded ELF shared objects.  LAV_CURRENT definition.
-   Copyright (C) 2023-2025 Free Software Foundation, Inc.
+   Copyright (C) 2023-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/long-double.h b/lib/libc/include/loongarch-linux-gnu/bits/long-double.h
index 57d7be04a685d57ab6e8e672e08d7effa853b06b..af7784dbe6dd85cd9538b5a7b437ab45de22eeb8 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-128 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/procfs.h b/lib/libc/include/loongarch-linux-gnu/bits/procfs.h
index 757bcd0ffa13c485c468d49f7a3050aa6a2e5bc3..82667049ea4da105674708596c0d73bd6c25c0df 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/pthread_stack_min.h b/lib/libc/include/loongarch-linux-gnu/bits/pthread_stack_min.h
index aea77125cb772564b083f4b9a7e93dbc8da67e38..856803a17b4cfbd7e8cc5d2a7778b6e2ab160431 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/pthread_stack_min.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/pthread_stack_min.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN.  LoongArch Linux version.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/rseq.h b/lib/libc/include/loongarch-linux-gnu/bits/rseq.h
index dd0e4a7f8d941f53bd23ae6e866e07456ba0f898..956e00c544d2ca595bcf07c6afcb3daf95121c0f 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux LoongArch architecture header.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/setjmp.h b/lib/libc/include/loongarch-linux-gnu/bits/setjmp.h
index dc384c17178265924e53ada99b1ed3416a274ea6..a22192a8fef78f5d71da8ccd0c922a0a77085aab 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/setjmp.h
@@ -1,5 +1,5 @@
 /* Define the machine-dependent type `jmp_buf'.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/sigstack.h b/lib/libc/include/loongarch-linux-gnu/bits/sigstack.h
index ee18b492d11c013baa4d3abfb4ebcf7ed217bbea..e1e74c25bfb52366a496ad1e848560e20b04cb01 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/sigstack.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/sigstack.h
@@ -1,5 +1,5 @@
 /* sigstack, sigaltstack definitions.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/struct_stat.h b/lib/libc/include/loongarch-linux-gnu/bits/struct_stat.h
index 724450a6679649260300d400798787a515849f1d..0462d37a6849812f485a6830a7c0dca303332636 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/timesize.h b/lib/libc/include/loongarch-linux-gnu/bits/timesize.h
index 04251ea75c82b9450e5c2bee30c3bbf06cbe55fb..dff2da5ed6bf30ce6f5580aee352e0958d58b623 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, general case.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/bits/wordsize.h b/lib/libc/include/loongarch-linux-gnu/bits/wordsize.h
index 5e7e1d15eeccd5d1ea9311d7aa74c7f7b1b412f4..5038df494751b3446f652bcb4d1c5d3e721a61ec 100644
--- a/lib/libc/include/loongarch-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/loongarch-linux-gnu/bits/wordsize.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/fpu_control.h b/lib/libc/include/loongarch-linux-gnu/fpu_control.h
index 8b39333ca06fd342218e70f20d93f66514423cfc..69cd4213c79b5db9e6c6ec60dc454c8177c8ba6d 100644
--- a/lib/libc/include/loongarch-linux-gnu/fpu_control.h
+++ b/lib/libc/include/loongarch-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/generic-glibc/gnu/lib-names-lp64d.h b/lib/libc/include/loongarch-linux-gnu/gnu/lib-names-lp64d.h
similarity index 100%
rename from lib/libc/include/generic-glibc/gnu/lib-names-lp64d.h
rename to lib/libc/include/loongarch-linux-gnu/gnu/lib-names-lp64d.h
diff --git a/lib/libc/include/loongarch-linux-gnu/gnu/lib-names-lp64s.h b/lib/libc/include/loongarch-linux-gnu/gnu/lib-names-lp64s.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c8b796194b2f179d2dfddbd0a7040a76ba37aeb
--- /dev/null
+++ b/lib/libc/include/loongarch-linux-gnu/gnu/lib-names-lp64s.h
@@ -0,0 +1,27 @@
+/* This file is automatically generated.  */
+#ifndef __GNU_LIB_NAMES_H
+# error "Never use <gnu/lib-names-lp64s.h> directly; include <gnu/lib-names.h> instead."
+#endif
+
+#define LD_LINUX_LOONGARCH_LP64S_SO     "ld-linux-loongarch-lp64s.so.1"
+#define LD_SO                           "ld-linux-loongarch-lp64s.so.1"
+#define LIBANL_SO                       "libanl.so.1"
+#define LIBBROKENLOCALE_SO              "libBrokenLocale.so.1"
+#define LIBC_MALLOC_DEBUG_SO            "libc_malloc_debug.so.0"
+#define LIBC_SO                         "libc.so.6"
+#define LIBDL_SO                        "libdl.so.2"
+#define LIBGCC_S_SO                     "libgcc_s.so.1"
+#define LIBMVEC_SO                      "libmvec.so.1"
+#define LIBM_SO                         "libm.so.6"
+#define LIBNSL_SO                       "libnsl.so.1"
+#define LIBNSS_COMPAT_SO                "libnss_compat.so.2"
+#define LIBNSS_DB_SO                    "libnss_db.so.2"
+#define LIBNSS_DNS_SO                   "libnss_dns.so.2"
+#define LIBNSS_FILES_SO                 "libnss_files.so.2"
+#define LIBNSS_HESIOD_SO                "libnss_hesiod.so.2"
+#define LIBNSS_LDAP_SO                  "libnss_ldap.so.2"
+#define LIBPTHREAD_SO                   "libpthread.so.0"
+#define LIBRESOLV_SO                    "libresolv.so.2"
+#define LIBRT_SO                        "librt.so.1"
+#define LIBTHREAD_DB_SO                 "libthread_db.so.1"
+#define LIBUTIL_SO                      "libutil.so.1"
\ No newline at end of file
diff --git a/lib/libc/include/generic-glibc/gnu/stubs-lp64d.h b/lib/libc/include/loongarch-linux-gnu/gnu/stubs-lp64d.h
similarity index 100%
rename from lib/libc/include/generic-glibc/gnu/stubs-lp64d.h
rename to lib/libc/include/loongarch-linux-gnu/gnu/stubs-lp64d.h
diff --git a/lib/libc/include/loongarch-linux-gnu/gnu/stubs-lp64s.h b/lib/libc/include/loongarch-linux-gnu/gnu/stubs-lp64s.h
index b9af396166e6dfc0c19e99ac906269c7008453e3..6ce02418e69609f4642a522910708769e96d6ee9 100644
--- a/lib/libc/include/loongarch-linux-gnu/gnu/stubs-lp64s.h
+++ b/lib/libc/include/loongarch-linux-gnu/gnu/stubs-lp64s.h
@@ -35,4 +35,4 @@
 #define __stub_revoke
 #define __stub_setlogin
 #define __stub_sigreturn
-#define __stub_stty
+#define __stub_stty
\ No newline at end of file
diff --git a/lib/libc/include/loongarch-linux-gnu/ieee754.h b/lib/libc/include/loongarch-linux-gnu/ieee754.h
index a49523c3d8faa01c2f79bd6e565578db52ddb727..a19fd8dcd1d39c39a1b5000ca0b4d3f8da2c2299 100644
--- a/lib/libc/include/loongarch-linux-gnu/ieee754.h
+++ b/lib/libc/include/loongarch-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/sys/asm.h b/lib/libc/include/loongarch-linux-gnu/sys/asm.h
index 9bedcac8e27d42b3b1631092b1073f020a06485a..973feb6effa26ea10d6b1af85ce2784a32ec8135 100644
--- a/lib/libc/include/loongarch-linux-gnu/sys/asm.h
+++ b/lib/libc/include/loongarch-linux-gnu/sys/asm.h
@@ -1,5 +1,5 @@
 /* Miscellaneous macros.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/loongarch-linux-gnu/sys/ucontext.h b/lib/libc/include/loongarch-linux-gnu/sys/ucontext.h
index a36bb8145e2c2168bff5491fd2cd19cb1d155fa4..c13e11dcd83db32e2d9410c58f62d56f5dfd2339 100644
--- a/lib/libc/include/loongarch-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/loongarch-linux-gnu/sys/ucontext.h
@@ -1,5 +1,5 @@
 /* struct ucontext definition.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/loongarch-linux-gnu/sys/user.h b/lib/libc/include/loongarch-linux-gnu/sys/user.h
index 122590639e325ee0e8979781e66c7e202c0ea730..6a8fed0bb79ff4dac6fa989de9d3da7d3a917d56 100644
--- a/lib/libc/include/loongarch-linux-gnu/sys/user.h
+++ b/lib/libc/include/loongarch-linux-gnu/sys/user.h
@@ -1,5 +1,5 @@
 /* struct user_regs_struct definition for LoongArch.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/fcntl.h b/lib/libc/include/m68k-linux-gnu/bits/fcntl.h
index a9dc395f27c48c417cb8a65ed28db4a4a65d66fc..ff8e9ccc93dbcab1548df965bb5267836a4307dc 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/fenv.h b/lib/libc/include/m68k-linux-gnu/bits/fenv.h
index 1edbdff77480583f939a0e0d5710d337b634a333..921c6aa22a7a8c40c314c765b074893d9874623d 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/floatn.h b/lib/libc/include/m68k-linux-gnu/bits/floatn.h
index 9005dc8601d52334aa53591640f009c59f6e6672..d3408f15249d51ab748cb0313f4cc3f36b09cdda 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/flt-eval-method.h b/lib/libc/include/m68k-linux-gnu/bits/flt-eval-method.h
index ff2e29d6d864f44f34dbbb43ead6603e1927f6fb..11283dbeb1d5d07fd8384dd6fe263fef12fa557e 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/flt-eval-method.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/flt-eval-method.h
@@ -1,5 +1,5 @@
 /* Define __GLIBC_FLT_EVAL_METHOD.  M68K version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/fp-logb.h b/lib/libc/include/m68k-linux-gnu/bits/fp-logb.h
index 582b38925cc350bc7d3075dbae395a6c92b3119b..10abc3c0eb83e58907a2d9fa6ab3fb8b090674d1 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/fp-logb.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/fp-logb.h
@@ -1,5 +1,5 @@
 /* Define __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.  M68K version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/iscanonical.h b/lib/libc/include/m68k-linux-gnu/bits/iscanonical.h
index 4d0b3c8c86bf0f2848187b96ff00044ed97e845c..874cd33ddf0ff0491227c49aebecd8e42ecf8cd5 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/iscanonical.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/iscanonical.h
@@ -1,5 +1,5 @@
 /* Define iscanonical macro.  ldbl-96 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/link.h b/lib/libc/include/m68k-linux-gnu/bits/link.h
index f7cff8eea4b910a329656287e1c7e087758c708b..8177a2fa8b2246b9723bf29786080006131b4dda 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/link.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/link.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/long-double.h b/lib/libc/include/m68k-linux-gnu/bits/long-double.h
index 601eef7f1a86f269fc401db183e077ae69990f38..aae8ed389111b6ed9ff725e9f5e12abaf7fe99c1 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-96 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/poll.h b/lib/libc/include/m68k-linux-gnu/bits/poll.h
index 7043ba8468e5200088d81e0e49e31b25518bf46b..4a33b3a969f1a8ebdde7af696221b0adca31b9d3 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/poll.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/poll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/procfs-id.h b/lib/libc/include/m68k-linux-gnu/bits/procfs-id.h
index 29aba43c37acb275bfc9109efeab05491c0f7526..055c426cbf6f1d9b45b138c484754a047b594928 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/procfs-id.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/procfs-id.h
@@ -1,5 +1,5 @@
 /* Types of pr_uid and pr_gid in struct elf_prpsinfo.  M68K version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/m68k-linux-gnu/bits/procfs.h b/lib/libc/include/m68k-linux-gnu/bits/procfs.h
index b9e8923967610d8a278251581c4ee43c3d937a5a..76a9fb481327381ffe7e1ddbb3b2b4a988e7c1c5 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  M68K version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/pthreadtypes-arch.h b/lib/libc/include/m68k-linux-gnu/bits/pthreadtypes-arch.h
index 9fbaf82a3748b8b26eb7b51480114a24f0ecdb43..6e8757a91e316788f05a428e0286a78e971470fd 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/pthreadtypes-arch.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/pthreadtypes-arch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/rseq.h b/lib/libc/include/m68k-linux-gnu/bits/rseq.h
index 90b3e9804a5b827612f37a31f9805ee0d82ad9a4..a844012dd3a527f6948a027145ecc10a1f01903f 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences architecture header.  Stub version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/m68k-linux-gnu/bits/semaphore.h b/lib/libc/include/m68k-linux-gnu/bits/semaphore.h
index a4487453a4f493599e1a0fb59467e31b2a8dd8d1..9df365a63232926bece3bca813648025565217ba 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/semaphore.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/semaphore.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/setjmp.h b/lib/libc/include/m68k-linux-gnu/bits/setjmp.h
index dd73bb69c2f4c4c17e60135863b744c2afdc10dc..86550f920b899baa2065db6eba2e9b8a0702fe0f 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/sockaddr.h b/lib/libc/include/m68k-linux-gnu/bits/sockaddr.h
index 0c44604c6c6e3659f64d8fc6c7dcf55a18c733ac..c142853d6cfb9b4dc9e677f64b3bed2e9689eb62 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/sockaddr.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/sockaddr.h
@@ -1,5 +1,5 @@
 /* Definition of struct sockaddr_* members and sizes, Linux/m68k version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/struct_stat.h b/lib/libc/include/m68k-linux-gnu/bits/struct_stat.h
index 4ac869dc175d4f9a813a04f7feddf3a710f28bd2..0ebb90a43cc14879d8a8f8f72558f780a4892a32 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/timesize.h b/lib/libc/include/m68k-linux-gnu/bits/timesize.h
index 36ba5733d55eaf5ec1367461f4ba7581cde3c118..878982d5afe3f458e666271fb0aa3912fe7b727d 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/m68k.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/typesizes.h b/lib/libc/include/m68k-linux-gnu/bits/typesizes.h
index 74ad928d8e020b7d94579f74501f46b322c77c31..8771f100852620fefa1072f5a9c23a6ee1c16421 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  m68k version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/bits/wordsize.h b/lib/libc/include/m68k-linux-gnu/bits/wordsize.h
index db329914346120034ed744f869ca475dda80c060..6e4c479fe4392ef20c85cd861dcde13f3825051d 100644
--- a/lib/libc/include/m68k-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/m68k-linux-gnu/bits/wordsize.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/fpu_control.h b/lib/libc/include/m68k-linux-gnu/fpu_control.h
index a9ee0ef254fe012a1ff38112c4f6afe1507d2f45..8c3b4b936be93508238a58b042a6d703f480b7bb 100644
--- a/lib/libc/include/m68k-linux-gnu/fpu_control.h
+++ b/lib/libc/include/m68k-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* 68k FPU control word definitions.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/sys/reg.h b/lib/libc/include/m68k-linux-gnu/sys/reg.h
index c2477b54f7e669a1da54e5146eeebde53a27ecc3..59328014e330237ee945b022068b77091f88d5e2 100644
--- a/lib/libc/include/m68k-linux-gnu/sys/reg.h
+++ b/lib/libc/include/m68k-linux-gnu/sys/reg.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/sys/ucontext.h b/lib/libc/include/m68k-linux-gnu/sys/ucontext.h
index fe4b8b295a4c38a62859c9763ab3920f6f1d6467..75ea0dd02f88957d6a8fc41dc1484f2bea300a70 100644
--- a/lib/libc/include/m68k-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/m68k-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/m68k-linux-gnu/sys/user.h b/lib/libc/include/m68k-linux-gnu/sys/user.h
index 577e775b0bc44f3436bf1ec9aeb2a17b75fcaa4d..501b9dcbf65908d9554f71d1663ea48bf80e0690 100644
--- a/lib/libc/include/m68k-linux-gnu/sys/user.h
+++ b/lib/libc/include/m68k-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2008-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/dlfcn.h b/lib/libc/include/mips-linux-gnu/bits/dlfcn.h
index 65b934d43fab299b557ad81b4921579e33a09bb8..24982842aa9a867da89f838f7fb84777d3a86b71 100644
--- a/lib/libc/include/mips-linux-gnu/bits/dlfcn.h
+++ b/lib/libc/include/mips-linux-gnu/bits/dlfcn.h
@@ -1,5 +1,5 @@
 /* System dependent definitions for run-time dynamic loading.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/errno.h b/lib/libc/include/mips-linux-gnu/bits/errno.h
index 73757ea5c33196252864c48b1f07b8a5050b313f..30e850a337b100bad1e433ec8e890685282da384 100644
--- a/lib/libc/include/mips-linux-gnu/bits/errno.h
+++ b/lib/libc/include/mips-linux-gnu/bits/errno.h
@@ -1,5 +1,5 @@
 /* Error constants.  MIPS/Linux specific version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/eventfd.h b/lib/libc/include/mips-linux-gnu/bits/eventfd.h
index 9527e5f5c62dc59a5b16b35bf4bbd0d9454b8851..399250f328cc94b6c08075bcaaeb1c9d9433c01c 100644
--- a/lib/libc/include/mips-linux-gnu/bits/eventfd.h
+++ b/lib/libc/include/mips-linux-gnu/bits/eventfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/floatn.h b/lib/libc/include/mips-linux-gnu/bits/floatn.h
index 3a2de29dee4428e08b0db2fd3241906cb27633e3..e0957c3d3571502c87f6b7add46252baf59082f2 100644
--- a/lib/libc/include/mips-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/mips-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features on MIPS platforms.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/inotify.h b/lib/libc/include/mips-linux-gnu/bits/inotify.h
index 20e56c411d64f12856557c92640fba18d6b31fd5..5b03c30da42d9501eae033d6f52f2861a716de4e 100644
--- a/lib/libc/include/mips-linux-gnu/bits/inotify.h
+++ b/lib/libc/include/mips-linux-gnu/bits/inotify.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/ioctl-types.h b/lib/libc/include/mips-linux-gnu/bits/ioctl-types.h
index 511fe1c96b30153f8acf0c2c8ca845dbb8e1bb3a..6e2a67b789696ca8fbb39a176edabc2b284b0452 100644
--- a/lib/libc/include/mips-linux-gnu/bits/ioctl-types.h
+++ b/lib/libc/include/mips-linux-gnu/bits/ioctl-types.h
@@ -1,5 +1,5 @@
 /* Structure types for pre-termios terminal ioctls.  Linux/MIPS version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/ipctypes.h b/lib/libc/include/mips-linux-gnu/bits/ipctypes.h
index b7bec61581923378c0cb0d8498204101072aaa3e..5ee3ebe38f190945351cba1f01b9b2f8db903580 100644
--- a/lib/libc/include/mips-linux-gnu/bits/ipctypes.h
+++ b/lib/libc/include/mips-linux-gnu/bits/ipctypes.h
@@ -1,5 +1,5 @@
 /* bits/ipctypes.h -- Define some types used by SysV IPC/MSG/SHM.  MIPS version
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/mman.h b/lib/libc/include/mips-linux-gnu/bits/mman.h
index ee158cf726302435303af788d3438267f873c414..0b5f513e076a516fac6facfef40df3bc6b7467e5 100644
--- a/lib/libc/include/mips-linux-gnu/bits/mman.h
+++ b/lib/libc/include/mips-linux-gnu/bits/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/MIPS version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/poll.h b/lib/libc/include/mips-linux-gnu/bits/poll.h
index 7043ba8468e5200088d81e0e49e31b25518bf46b..4a33b3a969f1a8ebdde7af696221b0adca31b9d3 100644
--- a/lib/libc/include/mips-linux-gnu/bits/poll.h
+++ b/lib/libc/include/mips-linux-gnu/bits/poll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/pthread_stack_min.h b/lib/libc/include/mips-linux-gnu/bits/pthread_stack_min.h
index 6bc4157059eca04b6cd5ed13def1c921dbfd46ef..05d4234ed3115af19db8cd532149da255a3ca39c 100644
--- a/lib/libc/include/mips-linux-gnu/bits/pthread_stack_min.h
+++ b/lib/libc/include/mips-linux-gnu/bits/pthread_stack_min.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN.  MIPS Linux version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/pthreadtypes-arch.h b/lib/libc/include/mips-linux-gnu/bits/pthreadtypes-arch.h
index 226d51c2a259ee66b25fe4777ae955a3d41121b7..53ecb74974cc32a401f32c3ed4e7a1172818cd56 100644
--- a/lib/libc/include/mips-linux-gnu/bits/pthreadtypes-arch.h
+++ b/lib/libc/include/mips-linux-gnu/bits/pthreadtypes-arch.h
@@ -1,5 +1,5 @@
 /* Machine-specific pthread type layouts.  MIPS version.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/resource.h b/lib/libc/include/mips-linux-gnu/bits/resource.h
index 021ce359ddf6a28ea1775bbfe8f3614efb55d729..0a5a0769042aafd27f16816ec188ceef878cd8ef 100644
--- a/lib/libc/include/mips-linux-gnu/bits/resource.h
+++ b/lib/libc/include/mips-linux-gnu/bits/resource.h
@@ -1,5 +1,5 @@
 /* Bit values & structures for resource limits.  Linux/MIPS version.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/semaphore.h b/lib/libc/include/mips-linux-gnu/bits/semaphore.h
index b220656c882853bb3350bd05d9030b1e09d7bded..eac6ab0e5cf20330bc93d0ecd2f9acb6206e87c2 100644
--- a/lib/libc/include/mips-linux-gnu/bits/semaphore.h
+++ b/lib/libc/include/mips-linux-gnu/bits/semaphore.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/shmlba.h b/lib/libc/include/mips-linux-gnu/bits/shmlba.h
index 350b518ba81292fcd7f353bcef06b2fb628d210b..7b5b1136f8ceb48c77ac9712e674fc055a1b4e84 100644
--- a/lib/libc/include/mips-linux-gnu/bits/shmlba.h
+++ b/lib/libc/include/mips-linux-gnu/bits/shmlba.h
@@ -1,5 +1,5 @@
 /* Define SHMLBA.  MIPS version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/sigaction.h b/lib/libc/include/mips-linux-gnu/bits/sigaction.h
index 5505891b7ae86e1caa177a604673d539299fabd0..619d56cbf1c0abbf94450e716092c96acefa279f 100644
--- a/lib/libc/include/mips-linux-gnu/bits/sigaction.h
+++ b/lib/libc/include/mips-linux-gnu/bits/sigaction.h
@@ -1,5 +1,5 @@
 /* The proper definitions for Linux/MIPS's sigaction.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/sigcontext.h b/lib/libc/include/mips-linux-gnu/bits/sigcontext.h
index f605e22dae54544a6f2ec4b8f3e404195a1789b0..d47e3e7c5900590b808a3f11724376817d98cdc0 100644
--- a/lib/libc/include/mips-linux-gnu/bits/sigcontext.h
+++ b/lib/libc/include/mips-linux-gnu/bits/sigcontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.  This file is part of the GNU C Library.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.  This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/mips-linux-gnu/bits/signalfd.h b/lib/libc/include/mips-linux-gnu/bits/signalfd.h
index af0460ab2a4bcab1ccccc94d94624efe77481435..35bfe6548e316a34650b4bf822c660a8a705afe1 100644
--- a/lib/libc/include/mips-linux-gnu/bits/signalfd.h
+++ b/lib/libc/include/mips-linux-gnu/bits/signalfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/signum-arch.h b/lib/libc/include/mips-linux-gnu/bits/signum-arch.h
index f8201472e17c6bbdc7c7b0932b705d2d2d890917..c43e83fcf77e1e8d07e642218076d460db85eb06 100644
--- a/lib/libc/include/mips-linux-gnu/bits/signum-arch.h
+++ b/lib/libc/include/mips-linux-gnu/bits/signum-arch.h
@@ -1,5 +1,5 @@
 /* Signal number definitions.  Linux/MIPS version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/socket-constants.h b/lib/libc/include/mips-linux-gnu/bits/socket-constants.h
index ec962210624e20cf27ef3ee6ce3199a1a05a7d3f..24c30f9d98e7de678baaf279ee874dfcfbb7866f 100644
--- a/lib/libc/include/mips-linux-gnu/bits/socket-constants.h
+++ b/lib/libc/include/mips-linux-gnu/bits/socket-constants.h
@@ -1,5 +1,5 @@
 /* Socket constants which vary among Linux architectures.  Version for MIPS.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/socket_type.h b/lib/libc/include/mips-linux-gnu/bits/socket_type.h
index 50649dcc5f71b73d412d732034eb1e5b614a1ecc..92f304d2aa083d12aafa1eb8cbcb2f764af0192c 100644
--- a/lib/libc/include/mips-linux-gnu/bits/socket_type.h
+++ b/lib/libc/include/mips-linux-gnu/bits/socket_type.h
@@ -1,5 +1,5 @@
 /* Define enum __socket_type for Linux/MIPS.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/statfs.h b/lib/libc/include/mips-linux-gnu/bits/statfs.h
index 179b003f888d0f85a02ab3d33b3545bac36cffe1..9e68db3490d5560a0d76ca9b9066f9c9d33c3b1b 100644
--- a/lib/libc/include/mips-linux-gnu/bits/statfs.h
+++ b/lib/libc/include/mips-linux-gnu/bits/statfs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/struct_mutex.h b/lib/libc/include/mips-linux-gnu/bits/struct_mutex.h
index fd005c0b9c34ff11a128721b67e6e786da984153..804676bebf59dffe3fc4708c09827489fab93111 100644
--- a/lib/libc/include/mips-linux-gnu/bits/struct_mutex.h
+++ b/lib/libc/include/mips-linux-gnu/bits/struct_mutex.h
@@ -1,5 +1,5 @@
 /* MIPS internal mutex struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/mips-linux-gnu/bits/struct_rwlock.h
index f1daa9496db2bc9c88eb44f94c226180b9a75091..631c3057516b4b6ac58721a1d3dff26848694967 100644
--- a/lib/libc/include/mips-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/mips-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* MIPS internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/termios-c_cc.h b/lib/libc/include/mips-linux-gnu/bits/termios-c_cc.h
index 530680ff2fde412f04d12a08d23ba41a30bcff90..a572e88edce585c4eeaade0955edc403fa2320e5 100644
--- a/lib/libc/include/mips-linux-gnu/bits/termios-c_cc.h
+++ b/lib/libc/include/mips-linux-gnu/bits/termios-c_cc.h
@@ -1,5 +1,5 @@
 /* termios c_cc symbolic constant definitions.  Linux/mips version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/termios-c_lflag.h b/lib/libc/include/mips-linux-gnu/bits/termios-c_lflag.h
index 0920d035c7d1525bc3b7906e38557552df550332..1ff38be11df1881c4674ca44274a62d2eaab2c84 100644
--- a/lib/libc/include/mips-linux-gnu/bits/termios-c_lflag.h
+++ b/lib/libc/include/mips-linux-gnu/bits/termios-c_lflag.h
@@ -1,5 +1,5 @@
 /* termios local mode definitions.  Linux/mips version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/termios-tcflow.h b/lib/libc/include/mips-linux-gnu/bits/termios-tcflow.h
index 97705b188723bdf56fd4e7ad2de13cfc764b4609..8ab349de28ead813e9e3fb81ee5e3a915cc3238f 100644
--- a/lib/libc/include/mips-linux-gnu/bits/termios-tcflow.h
+++ b/lib/libc/include/mips-linux-gnu/bits/termios-tcflow.h
@@ -1,5 +1,5 @@
 /* termios local mode definitions.  Linux/mips version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/timerfd.h b/lib/libc/include/mips-linux-gnu/bits/timerfd.h
index 58172ec3af9ab6e8216b4cf30d3b1e96311caa95..abcb014125fa67b97434673b45423105819e343e 100644
--- a/lib/libc/include/mips-linux-gnu/bits/timerfd.h
+++ b/lib/libc/include/mips-linux-gnu/bits/timerfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2008-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/types/stack_t.h b/lib/libc/include/mips-linux-gnu/bits/types/stack_t.h
index ca303c5d20b95d948a03919c467c8dbd85736f9b..5869efefaccf445af4cf2f628a668dd4f7749b2e 100644
--- a/lib/libc/include/mips-linux-gnu/bits/types/stack_t.h
+++ b/lib/libc/include/mips-linux-gnu/bits/types/stack_t.h
@@ -1,5 +1,5 @@
 /* Define stack_t.  MIPS Linux version.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/types/struct_msqid_ds.h b/lib/libc/include/mips-linux-gnu/bits/types/struct_msqid_ds.h
index 5539b03f3a2fccf7ff03d021e8c254d892649b68..ca9c04ffbafe038d0810e51eb1ffdd85ce5798b9 100644
--- a/lib/libc/include/mips-linux-gnu/bits/types/struct_msqid_ds.h
+++ b/lib/libc/include/mips-linux-gnu/bits/types/struct_msqid_ds.h
@@ -1,5 +1,5 @@
 /* Linux/MIPS implementation of the SysV message struct msqid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/types/struct_semid_ds.h b/lib/libc/include/mips-linux-gnu/bits/types/struct_semid_ds.h
index 2545ab94013c121db630ad47c44c4f3ee7612f2c..dcbc64f74b714f252195fa1f05851b8834ae3db2 100644
--- a/lib/libc/include/mips-linux-gnu/bits/types/struct_semid_ds.h
+++ b/lib/libc/include/mips-linux-gnu/bits/types/struct_semid_ds.h
@@ -1,5 +1,5 @@
 /* MIPS implementation of the semaphore struct semid_ds
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/types/struct_shmid_ds.h b/lib/libc/include/mips-linux-gnu/bits/types/struct_shmid_ds.h
index bf252474c1018accc728c1f7e109b4c0b303e522..dfd1415c60faa88f5f523f55699bf17b22538276 100644
--- a/lib/libc/include/mips-linux-gnu/bits/types/struct_shmid_ds.h
+++ b/lib/libc/include/mips-linux-gnu/bits/types/struct_shmid_ds.h
@@ -1,5 +1,5 @@
 /* Linux/MIPS implementation of the shared memory struct shmid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/bits/typesizes.h b/lib/libc/include/mips-linux-gnu/bits/typesizes.h
index 8e99e59de9e231b8ac497fb26ab19e80fdb73ec1..b70c6888219450545687944bec6065ff55c4ec9a 100644
--- a/lib/libc/include/mips-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/mips-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  MIPS version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/mips-linux-gnu/ieee754.h b/lib/libc/include/mips-linux-gnu/ieee754.h
index b3800f55945252fcd2cbae85b3edc25e983c99d1..731c2a937e9d0334e5b36f59c351f72ddae1a0d4 100644
--- a/lib/libc/include/mips-linux-gnu/ieee754.h
+++ b/lib/libc/include/mips-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/environments.h b/lib/libc/include/powerpc-linux-gnu/bits/environments.h
index 5a19b4cbd48af000a5e8a98fce1ce4d3db924ed2..1f7533af49568f229f835f8755b8e8f71ad50ea8 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/environments.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/environments.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/fcntl.h b/lib/libc/include/powerpc-linux-gnu/bits/fcntl.h
index 8e255ea462df727986cc25ab6da6b4f438544a0c..01a481d7a46a369c149f9f488fb88351427a1bae 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux/PowerPC.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/fenv.h b/lib/libc/include/powerpc-linux-gnu/bits/fenv.h
index 464f652309cf099dbfe5d9ef213353a7cfc4ec71..b75483708fc0b25365342e3146548fa845b50e53 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/floatn.h b/lib/libc/include/powerpc-linux-gnu/bits/floatn.h
index b07b9abf33c2d01bb101f2bdeadbfa6f76d1cbaa..db53131df6090e3ce3e75e5dd5a27c86b88dd63c 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features on powerpc.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/fp-fast.h b/lib/libc/include/powerpc-linux-gnu/bits/fp-fast.h
index 4d38958f0534be1f022b342909fa984f3cbf5837..99a9b6a68d783d8f5625da2be6026e00c416605b 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/fp-fast.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/fp-fast.h
@@ -1,5 +1,5 @@
 /* Define FP_FAST_* macros.  PowerPC version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/hwcap.h b/lib/libc/include/powerpc-linux-gnu/bits/hwcap.h
index 5e3ab0182b26b4bb2d0463e196a114da1b04591d..17e805f059c5070d2d04349ed8fca5a79b788c0c 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/hwcap.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP and AT_HWCAP2.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/ioctl-types.h b/lib/libc/include/powerpc-linux-gnu/bits/ioctl-types.h
index ecb6295b249bb7a28b282c979ed11a8f38c4ad81..fa0215e5cffaaf371e5b06e58447a0fa5fd1566f 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/ioctl-types.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/ioctl-types.h
@@ -1,5 +1,5 @@
 /* Structure types for pre-termios terminal ioctls.  Linux/powerpc version.
-   Copyright (C) 2014-2025 Free Software Foundation, Inc.
+   Copyright (C) 2014-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/ipc-perm.h b/lib/libc/include/powerpc-linux-gnu/bits/ipc-perm.h
index 06ba7e6ca791cfdcbc0c2a6e449c0a4a87058c64..2ed12c3136828fb79d54efbdab083f5ecf5332e7 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/ipc-perm.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/ipc-perm.h
@@ -1,5 +1,5 @@
 /* struct ipc_perm definition.  Linux/powerpc version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/iscanonical.h b/lib/libc/include/powerpc-linux-gnu/bits/iscanonical.h
index 49ea731c913bdefd284e6ab4ffdbb64a6a3fb5a9..b7cfc3ef410492c7298fc5f580568fce5b3527c5 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/iscanonical.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/iscanonical.h
@@ -1,5 +1,5 @@
 /* Define iscanonical macro.  ldbl-128ibm version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/link.h b/lib/libc/include/powerpc-linux-gnu/bits/link.h
index 90aaa912deebd838f8af252b22d772516cfb57e6..251210f7bcd54174e682b2403cbb0167bd033a51 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/link.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/link.h
@@ -1,5 +1,5 @@
 /* Machine-specific declarations for dynamic linker interface.  PowerPC version
-   Copyright (C) 2004-2025 Free Software Foundation, Inc.
+   Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/long-double.h b/lib/libc/include/powerpc-linux-gnu/bits/long-double.h
index ecf2982b04aa44eb7ff5a290cfa398b4c5db9c27..6c9cf2949f916b13700552fd7c1fe852fa507460 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-opt version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/mman.h b/lib/libc/include/powerpc-linux-gnu/bits/mman.h
index 1fc6762a7a22377f7c8e9170ca37d22d0487df9f..e68abd8cc99504b34592f042821390f878dddc44 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/mman.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/PowerPC version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/procfs.h b/lib/libc/include/powerpc-linux-gnu/bits/procfs.h
index 14652268ec21fe77ace172a4e1a9c0039a8b1b7f..22d5a4af6b39a52b607f8f9c1262bc6070b4cbcc 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  PowerPC version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/pthread_stack_min.h b/lib/libc/include/powerpc-linux-gnu/bits/pthread_stack_min.h
index 0b6dcb9131cf681ecf7069dc7d1e08f699902dec..a54ee42eb098e3ea940be72be4cda38c2275616b 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/pthread_stack_min.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/pthread_stack_min.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN.  Linux/PPC version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/rseq.h b/lib/libc/include/powerpc-linux-gnu/bits/rseq.h
index 5ba280909af90ac5cda1025f0d8c7c03d96dcf02..7d44f470b1af46aad9090006573e7e9da67c557c 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux powerpc architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/setjmp.h b/lib/libc/include/powerpc-linux-gnu/bits/setjmp.h
index b8774299cd565da3c0e3749a500931a71a05f7e8..54cff5c6c8c3079aa1f0bb2ba69c1ca6ff32f75c 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/sigstack.h b/lib/libc/include/powerpc-linux-gnu/bits/sigstack.h
index cc26e7b543aa339d9e1d20c481282e74ade4a9ad..c72ef19072a1d6b6ed9328f71e7ab42e07901c6e 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/sigstack.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/sigstack.h
@@ -1,5 +1,5 @@
 /* sigstack, sigaltstack definitions.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/socket-constants.h b/lib/libc/include/powerpc-linux-gnu/bits/socket-constants.h
index b5b6051a0ce68781c119b349a12fecc88e04ae13..c5e8c71cbf9a922ce58825e45859f2c632b2f313 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/socket-constants.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/socket-constants.h
@@ -1,5 +1,5 @@
 /* Socket constants which vary among Linux architectures.  Version for POWER.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/struct_mutex.h b/lib/libc/include/powerpc-linux-gnu/bits/struct_mutex.h
index c7f90aa47d97f7a4c314e59d785694f658c1ec40..00a85da7667b8540cc89ad17d4c4f51648687920 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/struct_mutex.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/struct_mutex.h
@@ -1,5 +1,5 @@
 /* PowerPC internal mutex struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -32,7 +32,7 @@ struct __pthread_mutex_s
   int __kind;
 #if __WORDSIZE == 64
   short __spins;
-  short __elision;
+  short __unused;
   __pthread_list_t __list;
 # define __PTHREAD_MUTEX_HAVE_PREV      1
 #else
@@ -41,11 +41,10 @@ struct __pthread_mutex_s
   {
     struct
     {
-      short __espins;
-      short __elision;
-# define __spins __elision_data.__espins
-# define __elision __elision_data.__elision
-    } __elision_data;
+      short __data_spins;
+      short __data_unused;
+# define __spins __data.__data_spins
+    } __data;
     __pthread_slist_t __list;
   };
 # define __PTHREAD_MUTEX_HAVE_PREV      0
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/powerpc-linux-gnu/bits/struct_rwlock.h
index 6ca8f577e5a81aff9ce992356d7225bbeabc6bd7..d3e18ca54f01f2e0660bc614c30c22aaef7a830f 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* PowerPC internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
@@ -31,31 +31,28 @@ struct __pthread_rwlock_arch_t
 #if __WORDSIZE == 64
   int __cur_writer;
   int __shared;
-  unsigned char __rwelision;
-  unsigned char __pad1[7];
+  unsigned long int __pad1;
   unsigned long int __pad2;
   /* FLAGS must stay at this position in the structure to maintain
      binary compatibility.  */
   unsigned int __flags;
-# define __PTHREAD_RWLOCK_ELISION_EXTRA 0, {0, 0, 0, 0, 0, 0, 0 }
 #else
-  unsigned char __rwelision;
+  unsigned char __pad1;
   unsigned char __pad2;
   unsigned char __shared;
   /* FLAGS must stay at this position in the structure to maintain
      binary compatibility.  */
   unsigned char __flags;
   int __cur_writer;
-# define __PTHREAD_RWLOCK_ELISION_EXTRA 0
 #endif
 };
 
 #if __WORDSIZE == 64
 # define __PTHREAD_RWLOCK_INITIALIZER(__flags) \
-  0, 0, 0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, __flags
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, __flags
 #else
 # define __PTHREAD_RWLOCK_INITIALIZER(__flags) \
-  0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, 0, __flags, 0
+  0, 0, 0, 0, 0, 0, 0, 0, 0, __flags, 0
 #endif
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/struct_stat.h b/lib/libc/include/powerpc-linux-gnu/bits/struct_stat.h
index 4b2c05e425b44f1662e8343dec8b27d956042315..053329e24cf8bff340a156324430c0be01172400 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cc.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cc.h
index 2a533e982e51ed203c16cc699cebfa45cb66fd9a..47887ecfe146ed4dc6531a5378e4ba8540e2b6cd 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cc.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cc.h
@@ -1,5 +1,5 @@
 /* termios c_cc symbolic constant definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cflag.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cflag.h
index 86d5639c460e9a1b398633b1345c3f1fae8e5baf..37dd83e796403f50ce4d961e53dcf97b577dee2f 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cflag.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_cflag.h
@@ -1,5 +1,5 @@
 /* termios control mode definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_iflag.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_iflag.h
index b19f14d9ea9f3bc0d8f9a621c13ca13c5abc6589..0c4e34104344867d8bffaa4aed0ebd23b6b837b0 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_iflag.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_iflag.h
@@ -1,5 +1,5 @@
 /* termios input mode definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_lflag.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_lflag.h
index 28d361816dde0fec928df76d0afde24771b5d03e..6c8abad464bd1965cbf1f9674fbaed7b8f26deb1 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_lflag.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_lflag.h
@@ -1,5 +1,5 @@
 /* termios local mode definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_oflag.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_oflag.h
index 7884494268e1befff5deaca03326191610a488e7..8d6fd3ceb02011bd4dd6ec1cc7b0d18826927d8b 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-c_oflag.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-c_oflag.h
@@ -1,5 +1,5 @@
 /* termios output mode definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-cbaud.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-cbaud.h
index 6e0257e59d42ad45f0ab7bd0e226195a9cb87c02..1f56bad97b3ae042ceb327b8df9cc347acc9671c 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-cbaud.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-cbaud.h
@@ -1,5 +1,5 @@
 /* termios baud rate selection definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/termios-misc.h b/lib/libc/include/powerpc-linux-gnu/bits/termios-misc.h
index 8d3504478dc42f14366a3c10a95510b9e84392aa..789236ad3163bbf471804f9c26d22f4812cbfc0d 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/termios-misc.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/termios-misc.h
@@ -1,5 +1,5 @@
 /* termios baud platform specific definitions.  Linux/powerpc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/timesize.h b/lib/libc/include/powerpc-linux-gnu/bits/timesize.h
index 9cbad9b500a47a06bfa63c07060a06cc77d6921a..5e47e22bc066d049db2211f5280924c515a469b8 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/PowerPC.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/types/struct_msqid_ds.h b/lib/libc/include/powerpc-linux-gnu/bits/types/struct_msqid_ds.h
index f6b3e4d6552f8aa5d6a7b9bc053ab508e9b09861..8624e326dc77fb09551532e38d89c23831b0baed 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/types/struct_msqid_ds.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/types/struct_msqid_ds.h
@@ -1,5 +1,5 @@
 /* Linux/PowerPC implementation of the SysV message struct msqid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/types/struct_semid_ds.h b/lib/libc/include/powerpc-linux-gnu/bits/types/struct_semid_ds.h
index 3b208ff2fd58f750d232f87d2ee414af31677e75..550efd66075360ffd41b13ef1b797e11c818ba3d 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/types/struct_semid_ds.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/types/struct_semid_ds.h
@@ -1,5 +1,5 @@
 /* PowerPC implementation of the semaphore struct semid_ds.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/types/struct_shmid_ds.h b/lib/libc/include/powerpc-linux-gnu/bits/types/struct_shmid_ds.h
index 2ed27e039d2aa7b7f98220cdd9e702e887a5bdf7..e739d5e857aeb73aa5af800178f74d08947b308d 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/types/struct_shmid_ds.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/types/struct_shmid_ds.h
@@ -1,5 +1,5 @@
 /* Linux/PowerPC implementation of the shared memory struct shmid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/bits/typesizes.h b/lib/libc/include/powerpc-linux-gnu/bits/typesizes.h
index 47bb8610e66cd3ae4f103a3c5b5c6435a784f066..dc1da9054a9ab9c11ee323a45c762475f57a75ca 100644
--- a/lib/libc/include/powerpc-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/powerpc-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  PowerPC version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/fpu_control.h b/lib/libc/include/powerpc-linux-gnu/fpu_control.h
index cdedca96cffd94c0284cf410371009a6fe20cf18..dec65fa0108553f0a62865f4492ce44adbebe01b 100644
--- a/lib/libc/include/powerpc-linux-gnu/fpu_control.h
+++ b/lib/libc/include/powerpc-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word definitions.  PowerPC version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/ieee754.h b/lib/libc/include/powerpc-linux-gnu/ieee754.h
index 38008b560fa7d7fab6e6032c51cc4b2d6dea01c3..18b79270e6d96f0eb54a3f93b4beb6ebc18e7060 100644
--- a/lib/libc/include/powerpc-linux-gnu/ieee754.h
+++ b/lib/libc/include/powerpc-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/sys/ptrace.h b/lib/libc/include/powerpc-linux-gnu/sys/ptrace.h
index 99cf115cb6ac7371c3dc4abbc5ff51a708f83f92..882a09c350ebc7efe4046d8f7951df3c0ebacb73 100644
--- a/lib/libc/include/powerpc-linux-gnu/sys/ptrace.h
+++ b/lib/libc/include/powerpc-linux-gnu/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux/PowerPC version.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/sys/ucontext.h b/lib/libc/include/powerpc-linux-gnu/sys/ucontext.h
index 7d354e529b92e16c592d72ed5d8ff8473014aa7d..df7b7b4a5f7dd59015085064e47840bd58963343 100644
--- a/lib/libc/include/powerpc-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/powerpc-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/powerpc-linux-gnu/sys/user.h b/lib/libc/include/powerpc-linux-gnu/sys/user.h
index 19396e1bc3d520b93c2ecf7d9d4bbf91e5d77837..706662749f14f66a4c5a44dda94597ee6c6f2d22 100644
--- a/lib/libc/include/powerpc-linux-gnu/sys/user.h
+++ b/lib/libc/include/powerpc-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/environments.h b/lib/libc/include/riscv-linux-gnu/bits/environments.h
index 26a15733b3eff99f30f871d07081d59c675addb2..5cf0a2c910cac2102e9dadbc45696e4891c5d975 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/environments.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/environments.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2020-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/fcntl.h b/lib/libc/include/riscv-linux-gnu/bits/fcntl.h
index 7a8e74e78819106a776b428ebe88d47d07f78d8f..ed62d1829d9d9f7c4c1278c902c619570a59623b 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux / RISC-V.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/riscv-linux-gnu/bits/fenv.h b/lib/libc/include/riscv-linux-gnu/bits/fenv.h
index 385b2d68984ec089e8f7dd28dc7b9864a2636d60..aa191274b48a453e090b97172528a7722c5232fb 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/fenv.h
@@ -1,5 +1,5 @@
 /* Floating point environment, RISC-V version.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/link.h b/lib/libc/include/riscv-linux-gnu/bits/link.h
index 044077794837c85bdcf521a2e11986473ed4a03f..c82422106be6c045ea595169d7c3b1710cda79c9 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/link.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/link.h
@@ -1,5 +1,5 @@
 /* Machine-specific declarations for dynamic linker interface.  RISC-V version.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/long-double.h b/lib/libc/include/riscv-linux-gnu/bits/long-double.h
index 57d7be04a685d57ab6e8e672e08d7effa853b06b..af7784dbe6dd85cd9538b5a7b437ab45de22eeb8 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-128 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/procfs.h b/lib/libc/include/riscv-linux-gnu/bits/procfs.h
index 41fe44e0a3adb50375ee7078e596585f1eb488c3..278397840bd2810abf8830666b13ee34bcda2b79 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  RISC-V version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/pthreadtypes-arch.h b/lib/libc/include/riscv-linux-gnu/bits/pthreadtypes-arch.h
index 1e0839e949fa704d24fca3fc53c98561b5ed02ca..6218317e767f617e0686d3134710b3ff5f99142e 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/pthreadtypes-arch.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/pthreadtypes-arch.h
@@ -1,5 +1,5 @@
 /* Machine-specific pthread type layouts.  RISC-V version.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/rseq.h b/lib/libc/include/riscv-linux-gnu/bits/rseq.h
index 0300604af999b73f01db7bb37978d78d2480db4c..5b82daaaaadd95da21f476aec2515bda966efaab 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux riscv architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/riscv-linux-gnu/bits/setjmp.h b/lib/libc/include/riscv-linux-gnu/bits/setjmp.h
index d3dca3d9b1b21f29f65e4b2fb56e0b91213c55b8..75b2d8912398bff370d29f1fc3dc12fb6eed6e57 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/setjmp.h
@@ -1,5 +1,5 @@
 /* Define the machine-dependent type `jmp_buf'.  RISC-V version.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/sigcontext.h b/lib/libc/include/riscv-linux-gnu/bits/sigcontext.h
index 7634c22cff608362909f1f1246d36efd0c693f37..004e0bf5bd6d5414ab7efd769fc257856c73c355 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/sigcontext.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/sigcontext.h
@@ -1,5 +1,5 @@
 /* Machine-dependent signal context structure for Linux.  RISC-V version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.  This file is part of the GNU C Library.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.  This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/riscv-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/riscv-linux-gnu/bits/struct_rwlock.h
index b0674ce80c3f6cf2a7113961852f810d62aea9fc..41ef083aa0b7c68d47dc8b6c419c8fd289784c1f 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* RISC-V internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/riscv-linux-gnu/bits/struct_stat.h b/lib/libc/include/riscv-linux-gnu/bits/struct_stat.h
index 724450a6679649260300d400798787a515849f1d..0462d37a6849812f485a6830a7c0dca303332636 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/time64.h b/lib/libc/include/riscv-linux-gnu/bits/time64.h
index 1f82375244922aa8df2e5599cead61840d4ae66f..81476a4ac047e49282ef9741140afa7e19ae723d 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/time64.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/time64.h
@@ -1,5 +1,5 @@
 /* bits/time64.h -- underlying types for __time64_t.  RISC-V version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/timesize.h b/lib/libc/include/riscv-linux-gnu/bits/timesize.h
index 04251ea75c82b9450e5c2bee30c3bbf06cbe55fb..dff2da5ed6bf30ce6f5580aee352e0958d58b623 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, general case.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/bits/wordsize.h b/lib/libc/include/riscv-linux-gnu/bits/wordsize.h
index 45cc378a99bb4f5c5d31b06989fc34c5ad146882..3c79368ccc13de4bf15eaf9becf336e870abcb6f 100644
--- a/lib/libc/include/riscv-linux-gnu/bits/wordsize.h
+++ b/lib/libc/include/riscv-linux-gnu/bits/wordsize.h
@@ -1,5 +1,5 @@
 /* Determine the wordsize from the preprocessor defines.  RISC-V version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/fpu_control.h b/lib/libc/include/riscv-linux-gnu/fpu_control.h
index 6a621ca8840974c55bc756b19df9a0ba20e96947..838af6f139f326c5f4aebc63534ee363569fe606 100644
--- a/lib/libc/include/riscv-linux-gnu/fpu_control.h
+++ b/lib/libc/include/riscv-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.  RISC-V version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -27,7 +27,7 @@
 # define _FPU_DEFAULT  0x00000000
 typedef unsigned int fpu_control_t;
 # define _FPU_GETCW(cw) (cw) = 0
-# define _FPU_SETCW(cw) do { } while (0)
+# define _FPU_SETCW(cw) (void) (cw)
 extern fpu_control_t __fpu_control;
 
 #else /* __riscv_flen */
diff --git a/lib/libc/include/riscv-linux-gnu/ieee754.h b/lib/libc/include/riscv-linux-gnu/ieee754.h
index a49523c3d8faa01c2f79bd6e565578db52ddb727..a19fd8dcd1d39c39a1b5000ca0b4d3f8da2c2299 100644
--- a/lib/libc/include/riscv-linux-gnu/ieee754.h
+++ b/lib/libc/include/riscv-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/sys/asm.h b/lib/libc/include/riscv-linux-gnu/sys/asm.h
index ff8205da63ec2f829c2d3b790121eb4fc7bdd032..e66bb6eb5e175bf2e6e9e7a34fa8a4c1bb49c86c 100644
--- a/lib/libc/include/riscv-linux-gnu/sys/asm.h
+++ b/lib/libc/include/riscv-linux-gnu/sys/asm.h
@@ -1,5 +1,5 @@
 /* Miscellaneous macros.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/sys/cachectl.h b/lib/libc/include/riscv-linux-gnu/sys/cachectl.h
index 599118a8aac516241a4c8a62ddd245d61b8275ec..3f25ca7fbb214b7ed55b3f3ee7ef161576a99336 100644
--- a/lib/libc/include/riscv-linux-gnu/sys/cachectl.h
+++ b/lib/libc/include/riscv-linux-gnu/sys/cachectl.h
@@ -1,5 +1,5 @@
 /* RISC-V instruction cache flushing interface
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/riscv-linux-gnu/sys/ucontext.h b/lib/libc/include/riscv-linux-gnu/sys/ucontext.h
index 4a110dbafa2ff8178e926799dec486da5c8b54a7..ed06a30fe8acbdfe843453664ce1d22d3bc75b9d 100644
--- a/lib/libc/include/riscv-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/riscv-linux-gnu/sys/ucontext.h
@@ -1,5 +1,5 @@
 /* struct ucontext definition, RISC-V version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/riscv-linux-gnu/sys/user.h b/lib/libc/include/riscv-linux-gnu/sys/user.h
index 3b4e3e9452d632e83c6e2c043a5814ac5c80b989..d8d1d86bfd8c673b4e79f9cac735eb26c7d30afd 100644
--- a/lib/libc/include/riscv-linux-gnu/sys/user.h
+++ b/lib/libc/include/riscv-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/elfclass.h b/lib/libc/include/s390x-linux-gnu/bits/elfclass.h
index a71bd938e73a0deafb92cd7dc3aae0366c9b4b31..325ca0fe4b41d0af0242fb38611aca0b39d4b525 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/elfclass.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/elfclass.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/environments.h b/lib/libc/include/s390x-linux-gnu/bits/environments.h
index 2bfd9501fbcc8f63b84b08ad9d83db1f075d839c..6a5d3e997c9e6592b4c5077da6e5f1d9e40d9b40 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/environments.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/environments.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/fcntl.h b/lib/libc/include/s390x-linux-gnu/bits/fcntl.h
index 4d58e01a3e4875f6b2ac49f950c29b1b3eee77e6..1d209c616c834cb7d1e8c4220a68852418694265 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/fenv.h b/lib/libc/include/s390x-linux-gnu/bits/fenv.h
index d24ac91812d3393ce0e23560ec022656c5b8e314..eafcaa425b6835d5dd985020e748f3aa64e0c4a5 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/hwcap.h b/lib/libc/include/s390x-linux-gnu/bits/hwcap.h
index 3c98a2d6a1a795729f74801b72d546c832d272af..7fbcacd2d629d36d38a2dd1ef86920dfa04d5e1c 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/hwcap.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/link.h b/lib/libc/include/s390x-linux-gnu/bits/link.h
index 059bd600530c32edb76d5263ba39a38c136268c0..96694b37a417838cb4452446e0217fd7e3d4ebed 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/link.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/link.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/long-double.h b/lib/libc/include/s390x-linux-gnu/bits/long-double.h
index c83ef568eb4f7e74fbc7c0d8e77c588da1538d94..eede7634fbfad05505df72b0422e4f16eb2189a2 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-opt version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/procfs-extra.h b/lib/libc/include/s390x-linux-gnu/bits/procfs-extra.h
index 166e47492a3f0141d83632c80bab426c1c8efc8a..7fb00d4146dae8fca24958e976e831c961090952 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/procfs-extra.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/procfs-extra.h
@@ -1,5 +1,5 @@
 /* Extra sys/procfs.h definitions.  S/390 version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/procfs-id.h b/lib/libc/include/s390x-linux-gnu/bits/procfs-id.h
index cf3fd750a4411cb363412ce64c2f06f7ce940cbf..9e8570cfe612efd5d35867d0a70a20593fde16f9 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/procfs-id.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/procfs-id.h
@@ -1,5 +1,5 @@
 /* Types of pr_uid and pr_gid in struct elf_prpsinfo.  S/390 version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/s390x-linux-gnu/bits/procfs.h b/lib/libc/include/s390x-linux-gnu/bits/procfs.h
index b725d09955750f28c43deb86d71fd613b18d9b86..2805da7ab7a4e153ccf4c9baa072477b4003dd14 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  S/390 version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/rseq.h b/lib/libc/include/s390x-linux-gnu/bits/rseq.h
index ec56973f6e31791889552b0c9006e9e1ae15dd8c..44674e28778ce1c0776bc10a6ce628a2e099bfce 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux s390 architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/s390x-linux-gnu/bits/setjmp.h b/lib/libc/include/s390x-linux-gnu/bits/setjmp.h
index 822f0fb3255e78f51f681006951e9866dd087a01..7d660921ab0295c49a77d9fb12cf4b021546d8c3 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/sigaction.h b/lib/libc/include/s390x-linux-gnu/bits/sigaction.h
index 5f38a9cb5c31b23d77b4e9b73aa79c1bd1f3da61..44883efbe768731d6953e626f57588887505c712 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/sigaction.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/sigaction.h
@@ -1,5 +1,5 @@
 /* Definitions for 31 & 64 bit S/390 sigaction.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/statfs.h b/lib/libc/include/s390x-linux-gnu/bits/statfs.h
index 577bb4eace56e7f4c00c1f8ee875701823be1927..b30fb52202dbf66a0d81129b8c7a86b2a58893f2 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/statfs.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/statfs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/struct_mutex.h b/lib/libc/include/s390x-linux-gnu/bits/struct_mutex.h
index 504aec7fef757fde9874b39840d33fb0f0f01f86..7fc73321151dba01025bdf6f61e525f4a82d8e70 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/struct_mutex.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/struct_mutex.h
@@ -1,5 +1,5 @@
 /* S390 internal mutex struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -32,7 +32,7 @@ struct __pthread_mutex_s
   int __kind;
 #if __WORDSIZE == 64
   short __spins;
-  short __elision;
+  short __unused;
   __pthread_list_t __list;
 # define __PTHREAD_MUTEX_HAVE_PREV      1
 #else
@@ -41,11 +41,10 @@ struct __pthread_mutex_s
   {
     struct
     {
-      short __espins;
-      short __elision;
-    } _d;
-#  define __spins _d.__espins
-#  define __elision _d.__elision
+      short __data_spins;
+      short __data_unused;
+    } __data;
+#  define __spins __data.__data_spins
     __pthread_slist_t __list;
   };
 # define __PTHREAD_MUTEX_HAVE_PREV      0
diff --git a/lib/libc/include/s390x-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/s390x-linux-gnu/bits/struct_rwlock.h
index d7abdf7b31dde627028a67f9711ae7f592312102..e532dcddf63eef3facc4ec0021639de7ca1b49bc 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* S390 internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/s390x-linux-gnu/bits/struct_stat.h b/lib/libc/include/s390x-linux-gnu/bits/struct_stat.h
index 95897d90ec94f3936af71742a593b9b16e836a4e..3d77809e22d16b08b9329cb01c33a48e61177218 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/timesize.h b/lib/libc/include/s390x-linux-gnu/bits/timesize.h
index 95574667cb84a3233abe64d57c8017ddcf8503c9..5c231fe380193665c3e791dc1c16ef284787d758 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/s390.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/typesizes.h b/lib/libc/include/s390x-linux-gnu/bits/typesizes.h
index 1a9765ac61186023ad3778f0f0e5afea4dcc9643..5302d79b87a3bcdf2e8f9052fc3404030f9a3b35 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Linux/s390 version.
-   Copyright (C) 2003-2025 Free Software Foundation, Inc.
+   Copyright (C) 2003-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/utmp.h b/lib/libc/include/s390x-linux-gnu/bits/utmp.h
index dfb546be1ad3dab9b20f27cbcf5b091d8b705400..87db119de9415b8be0386c7bca655c4046fb2e36 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/utmp.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/utmp.h
@@ -1,5 +1,5 @@
 /* The `struct utmp' type, describing entries in the utmp file.  GNU version.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/bits/utmpx.h b/lib/libc/include/s390x-linux-gnu/bits/utmpx.h
index 5ee9a5ca3ab07a6cb6f6237ef5ae881f50670b67..00ed2f21a1c4853e7f45dafe7d8ca46a0b4b44a7 100644
--- a/lib/libc/include/s390x-linux-gnu/bits/utmpx.h
+++ b/lib/libc/include/s390x-linux-gnu/bits/utmpx.h
@@ -1,5 +1,5 @@
 /* Structures and definitions for the user accounting database.  GNU version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/fpu_control.h b/lib/libc/include/s390x-linux-gnu/fpu_control.h
index ed1ced78849bb05371fbc628c0c3179cd8c23ae2..fc58388f4fb56a7c82d600a823f6b169e4659f7c 100644
--- a/lib/libc/include/s390x-linux-gnu/fpu_control.h
+++ b/lib/libc/include/s390x-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word definitions.  Stub version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/ieee754.h b/lib/libc/include/s390x-linux-gnu/ieee754.h
index a49523c3d8faa01c2f79bd6e565578db52ddb727..a19fd8dcd1d39c39a1b5000ca0b4d3f8da2c2299 100644
--- a/lib/libc/include/s390x-linux-gnu/ieee754.h
+++ b/lib/libc/include/s390x-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/sys/elf.h b/lib/libc/include/s390x-linux-gnu/sys/elf.h
index ae26bc6b867338796dd19805bf80a8bb681be63f..70e50aba7435922469f88950028aaed3acf30678 100644
--- a/lib/libc/include/s390x-linux-gnu/sys/elf.h
+++ b/lib/libc/include/s390x-linux-gnu/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/sys/ptrace.h b/lib/libc/include/s390x-linux-gnu/sys/ptrace.h
index 524fdcae4bb629bc7d0905cb27cbe319496f560b..d1eb596e8f40cd3d20cc6f571adc7be1df0ab7c0 100644
--- a/lib/libc/include/s390x-linux-gnu/sys/ptrace.h
+++ b/lib/libc/include/s390x-linux-gnu/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux/S390 version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/sys/ucontext.h b/lib/libc/include/s390x-linux-gnu/sys/ucontext.h
index 4e3ece22a75a88f984cac026c3f6bbc330872c9d..a766145563a3c44816cf2985502cfc5f11507948 100644
--- a/lib/libc/include/s390x-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/s390x-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/s390x-linux-gnu/sys/user.h b/lib/libc/include/s390x-linux-gnu/sys/user.h
index 6e93a49d111397138941c834bcf4977f3e6cf999..0155571f744a4d01ebce98386c039ad02fa68bf7 100644
--- a/lib/libc/include/s390x-linux-gnu/sys/user.h
+++ b/lib/libc/include/s390x-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/environments.h b/lib/libc/include/sparc-linux-gnu/bits/environments.h
index 5a19b4cbd48af000a5e8a98fce1ce4d3db924ed2..1f7533af49568f229f835f8755b8e8f71ad50ea8 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/environments.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/environments.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/epoll.h b/lib/libc/include/sparc-linux-gnu/bits/epoll.h
index 424774be9388aa689b07ccb214b47df2e1df8f94..a941b8d08be8550036f96b2921e910905754e4b1 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/epoll.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/epoll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/errno.h b/lib/libc/include/sparc-linux-gnu/bits/errno.h
index 64526c7bf3cc2c557410491f0cc60f489855f09e..906432afa28f59298d76e0d84d216bc86439ec27 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/errno.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/errno.h
@@ -1,5 +1,5 @@
 /* Error constants.  Linux/Sparc specific version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/eventfd.h b/lib/libc/include/sparc-linux-gnu/bits/eventfd.h
index fac0f292271ed34c3136f5c6b2cbc939c915d2e5..df3bb9acddc50159cfeba0a1d701b0f89c95edce 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/eventfd.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/eventfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/fcntl.h b/lib/libc/include/sparc-linux-gnu/bits/fcntl.h
index d51a7873a35a725b4273d69176ecc529cc43f40d..4f14c87748fba6979206e9c2d574b1b40df51d91 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux/SPARC.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/fenv.h b/lib/libc/include/sparc-linux-gnu/bits/fenv.h
index 2fac04873e8539a23a30790bc9ba83ada29f6d49..08a73630a17b5d78a40bdbda8d85335a25855bff 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/hwcap.h b/lib/libc/include/sparc-linux-gnu/bits/hwcap.h
index 409da7f39cbaf29c18c1b33ac5ffb2fe1dc97ddf..75283675a005204a08d31d6ad4c0df8f2d6ee15e 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/hwcap.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/hwcap.h
@@ -1,5 +1,5 @@
 /* Defines for bits in AT_HWCAP.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/inotify.h b/lib/libc/include/sparc-linux-gnu/bits/inotify.h
index e68756189b228003b70ab76f88957f7666af3664..e40de6bae24381fc4b6bb9979b6da075691f43b8 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/inotify.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/inotify.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/ioctls.h b/lib/libc/include/sparc-linux-gnu/bits/ioctls.h
index f35894212f7e28c656107f41be7ed729c910e488..38af369b1265cf47014b274f02101f3f8a25028f 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/ioctls.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/ioctls.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/ipc-perm.h b/lib/libc/include/sparc-linux-gnu/bits/ipc-perm.h
index cfa9c532fc664628d62802fdd6c24b3d4a3af7af..13e4fc3db5f8107c6184482acd689d2444ca16c6 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/ipc-perm.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/ipc-perm.h
@@ -1,5 +1,5 @@
 /* struct ipc_perm definition.  Linux/sparc version.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/link.h b/lib/libc/include/sparc-linux-gnu/bits/link.h
index b785272609be88ec26a4410125513de0e8eb671c..b42bcae68399580466795e3051b227dd20c96b86 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/link.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/link.h
@@ -1,5 +1,5 @@
 /* Machine-specific audit interfaces for dynamic linker.  SPARC version.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/long-double.h b/lib/libc/include/sparc-linux-gnu/bits/long-double.h
index 608d7e066fbe357d5dd4b74591e3a05b5fbd6cbe..da1ea20fb3d14254397e0e0c743fce14918793d6 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  SPARC version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/mman.h b/lib/libc/include/sparc-linux-gnu/bits/mman.h
index 28c384b7618abc6aa8126f48a0d6513b885b7222..1e58534e4540391d1c6c2cab8ab95ec2fc4d845e 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/mman.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/SPARC version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/poll.h b/lib/libc/include/sparc-linux-gnu/bits/poll.h
index b881b0803f0467147d3082391e285f6f8e6bd07c..fedffb047a8513c8ddc3074ced64980f7d74ccd1 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/poll.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/poll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/procfs-extra.h b/lib/libc/include/sparc-linux-gnu/bits/procfs-extra.h
index 3149f4c84e822410d7f6fe888ba935a65dd1b154..3e02bcfcff3d7db069b0e371b6a3a49eb2a7a55e 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/procfs-extra.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/procfs-extra.h
@@ -1,5 +1,5 @@
 /* Extra sys/procfs.h definitions.  SPARC version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/procfs-id.h b/lib/libc/include/sparc-linux-gnu/bits/procfs-id.h
index 08db45b76d2ee46604d2e7c4dabaccfcf92c2aa5..e738ed239cbd06155e3f33ba36d90d557b667a1d 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/procfs-id.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/procfs-id.h
@@ -1,5 +1,5 @@
 /* Types of pr_uid and pr_gid in struct elf_prpsinfo.  SPARC version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/sparc-linux-gnu/bits/procfs.h b/lib/libc/include/sparc-linux-gnu/bits/procfs.h
index f4f204a2bb112a8331e93047fd18e9640a781050..14503b5968c2cbf300d5b960a4928a496b9cd774 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  SPARC version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/pthread_stack_min.h b/lib/libc/include/sparc-linux-gnu/bits/pthread_stack_min.h
index baa588c020eb0354cf607a08251a852779cf3d85..355026a739ebf15e1acd7f854496dfca26be0acf 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/pthread_stack_min.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/pthread_stack_min.h
@@ -1,5 +1,5 @@
 /* Definition of PTHREAD_STACK_MIN.  Linux/SPARC version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/resource.h b/lib/libc/include/sparc-linux-gnu/bits/resource.h
index c9b20dff544cf4d068393045f4c04b3a1e8c6d8e..7947dfc385f5c6e1169fd5eefac17e50ab4855bf 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/resource.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/resource.h
@@ -1,5 +1,5 @@
 /* Bit values & structures for resource limits.  Linux/SPARC version.
-   Copyright (C) 1994-2025 Free Software Foundation, Inc.
+   Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/rseq.h b/lib/libc/include/sparc-linux-gnu/bits/rseq.h
index 90b3e9804a5b827612f37a31f9805ee0d82ad9a4..a844012dd3a527f6948a027145ecc10a1f01903f 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences architecture header.  Stub version.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/sparc-linux-gnu/bits/setjmp.h b/lib/libc/include/sparc-linux-gnu/bits/setjmp.h
index 8fb2bb1167c085865f736ab013b2386b387eed5a..2ed4b06c588648d0b4d82f30734494349a465f42 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/shmlba.h b/lib/libc/include/sparc-linux-gnu/bits/shmlba.h
index 49f9ae58af29f3560109631eaa7a52b4e37c8250..8bc00d9bd044fecf1fdaef51739111316cabc9fb 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/shmlba.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/shmlba.h
@@ -1,5 +1,5 @@
 /* Define SHMLBA.  SPARC version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/sigaction.h b/lib/libc/include/sparc-linux-gnu/bits/sigaction.h
index 3ef3e0d97ad218fc6bea7efd35e3eac1d03ae30d..9b1925e6a7f715c77592e6b014e1da17e5925079 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/sigaction.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/sigaction.h
@@ -1,5 +1,5 @@
 /* The proper definitions for Linux/SPARC sigaction.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/sigcontext.h b/lib/libc/include/sparc-linux-gnu/bits/sigcontext.h
index 20ca9e2435c741188a0ebd7656ad40f3de51dbea..836c2cf39253ef14c1d306cd8fc5de35255caf13 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/sigcontext.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/sigcontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/signalfd.h b/lib/libc/include/sparc-linux-gnu/bits/signalfd.h
index 2dc0e606c927cce246a91a9f4037d9a30d78913d..e4c5fc661527a964ad6afba0ab07b69c7f173a38 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/signalfd.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/signalfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2007-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2007-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/signum-arch.h b/lib/libc/include/sparc-linux-gnu/bits/signum-arch.h
index 152e9a40380debdcee0810b2b21985f3e7f1ba39..f3bdc98869e760e0d9a61a3d6fe8eb7cfc7b91eb 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/signum-arch.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/signum-arch.h
@@ -1,5 +1,5 @@
 /* Signal number definitions.  Linux/SPARC version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/sigstack.h b/lib/libc/include/sparc-linux-gnu/bits/sigstack.h
index 42d3c1ba97907509d1ffb08b474d637638afde2d..54469ca3a68d45721748b3a35fe90de5ed4188fd 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/sigstack.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/sigstack.h
@@ -1,5 +1,5 @@
 /* sigstack, sigaltstack definitions.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/socket-constants.h b/lib/libc/include/sparc-linux-gnu/bits/socket-constants.h
index e9e2715d00dfe015f9819485365ff6ce8f5bb1ce..8f50b2f50a1b4e97b8f4ae772101d0569aadc140 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/socket-constants.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/socket-constants.h
@@ -1,5 +1,5 @@
 /* Socket constants which vary among Linux architectures.  Version for SPARC.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/socket_type.h b/lib/libc/include/sparc-linux-gnu/bits/socket_type.h
index f9acac32675abb21c19c5c2aa899763650910657..d3dcbc2dc46f73dc2a60224842a43a149cbd460e 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/socket_type.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/socket_type.h
@@ -1,5 +1,5 @@
 /* Define enum __socket_type for Linux/SPARC.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/sparc-linux-gnu/bits/struct_rwlock.h
index 462460872476a6997d23c8fd6ea8056967c95fe1..e9df79b378cf799703da6857dae50843e8c60234 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* SPARC internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/sparc-linux-gnu/bits/struct_stat.h b/lib/libc/include/sparc-linux-gnu/bits/struct_stat.h
index a43cb63dde6f7bda638a11baacc4c43c5bc60bdb..4fc383d6e02b478780b6e8f9627e1137d7dde828 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/termios-c_cc.h b/lib/libc/include/sparc-linux-gnu/bits/termios-c_cc.h
index 989b895de675fbb305ced445dbdcc01e985c1f87..164558d553669ef7267d53a4748b37caf51e5fab 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/termios-c_cc.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/termios-c_cc.h
@@ -1,5 +1,5 @@
 /* termios c_cc symbolic constant definitions.  Linux/sparc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/termios-c_oflag.h b/lib/libc/include/sparc-linux-gnu/bits/termios-c_oflag.h
index 036be52447bd28483b7f841b5aa0a99b257012b8..51990c0387d7979d4a0915c8c18175adc4054aad 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/termios-c_oflag.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/termios-c_oflag.h
@@ -1,5 +1,5 @@
 /* termios output mode definitions.  Linux/sparc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/termios-cbaud.h b/lib/libc/include/sparc-linux-gnu/bits/termios-cbaud.h
index e848a18538c9fb8c5880fc6f9cd76cf3e160b07d..7e916fddc9158f6b2f556d4e4d32ec8f1faec5ed 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/termios-cbaud.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/termios-cbaud.h
@@ -1,5 +1,5 @@
 /* termios baud rate selection definitions.  Linux/sparc version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/timerfd.h b/lib/libc/include/sparc-linux-gnu/bits/timerfd.h
index 32e03256e3abd63d1919f4342275d6b7e1e359e9..496aff1cc9237f0fb8ddc219864e56a81b252907 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/timerfd.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/timerfd.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2008-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/timesize.h b/lib/libc/include/sparc-linux-gnu/bits/timesize.h
index d020c10c6e460c908d16dcc8abfa68ff925238ee..06bd725e1ea11418cd9f0e5b25826d554f803fed 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, Linux/sparc.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/types/struct_msqid_ds.h b/lib/libc/include/sparc-linux-gnu/bits/types/struct_msqid_ds.h
index 6d0f2b9a8ee66711c5ace2dfac3630d3527b8b9c..4566442ad07148a6536870f7755de2c0b4a7e5fb 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/types/struct_msqid_ds.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/types/struct_msqid_ds.h
@@ -1,5 +1,5 @@
 /* Linux/SPARC implementation of the SysV message struct msqid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/types/struct_semid_ds.h b/lib/libc/include/sparc-linux-gnu/bits/types/struct_semid_ds.h
index f8db7f00d3e49beb28e688b3d06ff81eb1b4fdca..b3f59d96b82fe1b2170813e4776e927b06759937 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/types/struct_semid_ds.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/types/struct_semid_ds.h
@@ -1,5 +1,5 @@
 /* Sparc implementation of the semaphore struct semid_ds
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/types/struct_shmid_ds.h b/lib/libc/include/sparc-linux-gnu/bits/types/struct_shmid_ds.h
index 88d72bb4af7b6bb262a8b25b3d1bebc6199bdb90..678737c3e4cd10931ee4a24ce71c988d221faf8e 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/types/struct_shmid_ds.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/types/struct_shmid_ds.h
@@ -1,5 +1,5 @@
 /* Linux/SPARC implementation of the shared memory struct shmid_ds.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/bits/typesizes.h b/lib/libc/include/sparc-linux-gnu/bits/typesizes.h
index e283787261ba3f7bff5359f0ae9a5010fb212f08..2eb70bdf1dbf06f3652faa42ee1fcf7e13cb73e9 100644
--- a/lib/libc/include/sparc-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/sparc-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Linux/SPARC version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/fpu_control.h b/lib/libc/include/sparc-linux-gnu/fpu_control.h
index 94d7424edb28ab60428ecc8a815d597ea5b8d7f3..40b1a50e1e042f56592db3637a92273941b0c3a0 100644
--- a/lib/libc/include/sparc-linux-gnu/fpu_control.h
+++ b/lib/libc/include/sparc-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.  SPARC version.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/ieee754.h b/lib/libc/include/sparc-linux-gnu/ieee754.h
index a49523c3d8faa01c2f79bd6e565578db52ddb727..a19fd8dcd1d39c39a1b5000ca0b4d3f8da2c2299 100644
--- a/lib/libc/include/sparc-linux-gnu/ieee754.h
+++ b/lib/libc/include/sparc-linux-gnu/ieee754.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/sys/ptrace.h b/lib/libc/include/sparc-linux-gnu/sys/ptrace.h
index 3add6c11885b6ac0b62224634a959111c7018a33..76ab8464aa11d0355725536a62cd91eb8d61391d 100644
--- a/lib/libc/include/sparc-linux-gnu/sys/ptrace.h
+++ b/lib/libc/include/sparc-linux-gnu/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux/SPARC version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/sys/ucontext.h b/lib/libc/include/sparc-linux-gnu/sys/ucontext.h
index cd5938a7542fd84de224401152d9a0a53c372281..8b386aa17f4ff724caf9eca61b315bb8167ec750 100644
--- a/lib/libc/include/sparc-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/sparc-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/sparc-linux-gnu/sys/user.h b/lib/libc/include/sparc-linux-gnu/sys/user.h
index b45cb81aa6c12f6db5df6dda9a6fd9be6c2b09a3..50bc7604065ed423501aacba5f9e8b7931e0af4c 100644
--- a/lib/libc/include/sparc-linux-gnu/sys/user.h
+++ b/lib/libc/include/sparc-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2003-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/dl_find_object.h b/lib/libc/include/x86-linux-gnu/bits/dl_find_object.h
index dfe01a86516db0c13f58773d7bed10b124d10ba3..00095a2f02c11ec4c2d392b24a50100411642102 100644
--- a/lib/libc/include/x86-linux-gnu/bits/dl_find_object.h
+++ b/lib/libc/include/x86-linux-gnu/bits/dl_find_object.h
@@ -1,5 +1,5 @@
 /* x86 definitions for finding objects.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/environments.h b/lib/libc/include/x86-linux-gnu/bits/environments.h
index a7c4ebb29ceb8c2f640317efe3e3b448217e8739..77316861ec9d8cd31e0190caab9db2524704906a 100644
--- a/lib/libc/include/x86-linux-gnu/bits/environments.h
+++ b/lib/libc/include/x86-linux-gnu/bits/environments.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/epoll.h b/lib/libc/include/x86-linux-gnu/bits/epoll.h
index 3fd9ba0e8f11783059a5b92dbf6063ccaea20b4a..7861c15c74422fc6553ac9b9c03b18e42311394e 100644
--- a/lib/libc/include/x86-linux-gnu/bits/epoll.h
+++ b/lib/libc/include/x86-linux-gnu/bits/epoll.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/fcntl.h b/lib/libc/include/x86-linux-gnu/bits/fcntl.h
index 2fe90f292de1d9157695d3cb702f23487a957678..234f66f87c3a989e97717232d44cc5cd0feaab77 100644
--- a/lib/libc/include/x86-linux-gnu/bits/fcntl.h
+++ b/lib/libc/include/x86-linux-gnu/bits/fcntl.h
@@ -1,5 +1,5 @@
 /* O_*, F_*, FD_* bit values for Linux/x86.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/fenv.h b/lib/libc/include/x86-linux-gnu/bits/fenv.h
index 9f1b96d90d2d15a8ae059bb8e3876e35a7c6dcf3..698f3f47c34b37150b5c5d454a1d33d4d9b662b0 100644
--- a/lib/libc/include/x86-linux-gnu/bits/fenv.h
+++ b/lib/libc/include/x86-linux-gnu/bits/fenv.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/floatn.h b/lib/libc/include/x86-linux-gnu/bits/floatn.h
index b0bab474a1aaffa8ded90c4e5426662d23a080d8..789de21a23a9565d4c763dac566009109112e52b 100644
--- a/lib/libc/include/x86-linux-gnu/bits/floatn.h
+++ b/lib/libc/include/x86-linux-gnu/bits/floatn.h
@@ -1,5 +1,5 @@
 /* Macros to control TS 18661-3 glibc features on x86.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/flt-eval-method.h b/lib/libc/include/x86-linux-gnu/bits/flt-eval-method.h
index 633df10484ef0b386cba73b4b62e7fd87cd3b43a..ff9e1b68a8c4d54ccd577383594354cdd67a1e5e 100644
--- a/lib/libc/include/x86-linux-gnu/bits/flt-eval-method.h
+++ b/lib/libc/include/x86-linux-gnu/bits/flt-eval-method.h
@@ -1,5 +1,5 @@
 /* Define __GLIBC_FLT_EVAL_METHOD.  x86 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/fp-logb.h b/lib/libc/include/x86-linux-gnu/bits/fp-logb.h
index fafda47ccad27bdb7efa3d97d42119d4c9c2aed7..3fc7604558d384cf635ccbdcbd8ce6814ca001ab 100644
--- a/lib/libc/include/x86-linux-gnu/bits/fp-logb.h
+++ b/lib/libc/include/x86-linux-gnu/bits/fp-logb.h
@@ -1,5 +1,5 @@
 /* Define __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.  x86 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/indirect-return.h b/lib/libc/include/x86-linux-gnu/bits/indirect-return.h
index cf42eab6cc91f92ecdb0c1814187d65e9bd21e8a..e740865a9c335ecc0021754e83f04bf908b26ce0 100644
--- a/lib/libc/include/x86-linux-gnu/bits/indirect-return.h
+++ b/lib/libc/include/x86-linux-gnu/bits/indirect-return.h
@@ -1,5 +1,5 @@
 /* Definition of __INDIRECT_RETURN.  x86 version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/ipctypes.h b/lib/libc/include/x86-linux-gnu/bits/ipctypes.h
index 312a812c81bb74bc9d5c05c715f45152ffc609bb..8471589f03880840cfb536c090f9b86c48bd3c2a 100644
--- a/lib/libc/include/x86-linux-gnu/bits/ipctypes.h
+++ b/lib/libc/include/x86-linux-gnu/bits/ipctypes.h
@@ -1,5 +1,5 @@
 /* bits/ipctypes.h -- Define some types used by SysV IPC/MSG/SHM.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/iscanonical.h b/lib/libc/include/x86-linux-gnu/bits/iscanonical.h
index 4d0b3c8c86bf0f2848187b96ff00044ed97e845c..874cd33ddf0ff0491227c49aebecd8e42ecf8cd5 100644
--- a/lib/libc/include/x86-linux-gnu/bits/iscanonical.h
+++ b/lib/libc/include/x86-linux-gnu/bits/iscanonical.h
@@ -1,5 +1,5 @@
 /* Define iscanonical macro.  ldbl-96 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/link.h b/lib/libc/include/x86-linux-gnu/bits/link.h
index 947918ae3ce3aa8aa290d3eb9dad03e08358bcf2..0682716a3adcf7fedb05a80b92e76356c833656e 100644
--- a/lib/libc/include/x86-linux-gnu/bits/link.h
+++ b/lib/libc/include/x86-linux-gnu/bits/link.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/long-double.h b/lib/libc/include/x86-linux-gnu/bits/long-double.h
index 601eef7f1a86f269fc401db183e077ae69990f38..aae8ed389111b6ed9ff725e9f5e12abaf7fe99c1 100644
--- a/lib/libc/include/x86-linux-gnu/bits/long-double.h
+++ b/lib/libc/include/x86-linux-gnu/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.  ldbl-96 version.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/math-vector.h b/lib/libc/include/x86-linux-gnu/bits/math-vector.h
index 7a0ab120220d5ddc93b83a98a144a5fd5decdfdf..fc7dafe11e105a71262fb53bf341891c84570171 100644
--- a/lib/libc/include/x86-linux-gnu/bits/math-vector.h
+++ b/lib/libc/include/x86-linux-gnu/bits/math-vector.h
@@ -1,5 +1,5 @@
 /* Platform-specific SIMD declarations of math functions.
-   Copyright (C) 2014-2025 Free Software Foundation, Inc.
+   Copyright (C) 2014-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/mman.h b/lib/libc/include/x86-linux-gnu/bits/mman.h
index 7a074b1a41901f76b90cfba4554679a9a6f81584..40cfcd79784788da9b19f2f1052cf69395c3417f 100644
--- a/lib/libc/include/x86-linux-gnu/bits/mman.h
+++ b/lib/libc/include/x86-linux-gnu/bits/mman.h
@@ -1,5 +1,5 @@
 /* Definitions for POSIX memory map interface.  Linux/x86_64 version.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/procfs-id.h b/lib/libc/include/x86-linux-gnu/bits/procfs-id.h
index a56dcacb1a1f041d29588d30ab78b8b8928dff83..08758ee9573ece9085470eda83fb159bc57e4985 100644
--- a/lib/libc/include/x86-linux-gnu/bits/procfs-id.h
+++ b/lib/libc/include/x86-linux-gnu/bits/procfs-id.h
@@ -1,5 +1,5 @@
 /* Types of pr_uid and pr_gid in struct elf_prpsinfo.  x86 version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/x86-linux-gnu/bits/procfs.h b/lib/libc/include/x86-linux-gnu/bits/procfs.h
index 7df2897b5d7b22a4d30f8406ce8210f4f606cb90..a0a5f7cb78ab55b6530e7f6f5974a9c8054a3285 100644
--- a/lib/libc/include/x86-linux-gnu/bits/procfs.h
+++ b/lib/libc/include/x86-linux-gnu/bits/procfs.h
@@ -1,5 +1,5 @@
 /* Types for registers for sys/procfs.h.  x86 version.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/pthreadtypes-arch.h b/lib/libc/include/x86-linux-gnu/bits/pthreadtypes-arch.h
index b13a1e4e3ba0206337e347fbea4bfd85502c9399..97e081118efaa3c1326b486844a84b1d5581473a 100644
--- a/lib/libc/include/x86-linux-gnu/bits/pthreadtypes-arch.h
+++ b/lib/libc/include/x86-linux-gnu/bits/pthreadtypes-arch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/rseq.h b/lib/libc/include/x86-linux-gnu/bits/rseq.h
index 2aeee59139bd9dba56ed5a84d3a558215bee38ab..e2fe6feebe37e2051c1c43b83659b351cff106f8 100644
--- a/lib/libc/include/x86-linux-gnu/bits/rseq.h
+++ b/lib/libc/include/x86-linux-gnu/bits/rseq.h
@@ -1,5 +1,5 @@
 /* Restartable Sequences Linux x86 architecture header.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
diff --git a/lib/libc/include/x86-linux-gnu/bits/setjmp.h b/lib/libc/include/x86-linux-gnu/bits/setjmp.h
index a447e3ae1e5cc0f7c5eb02eb0a90fa97115da023..bd649c9a6368c54a4f95ff6b72f53422b414027f 100644
--- a/lib/libc/include/x86-linux-gnu/bits/setjmp.h
+++ b/lib/libc/include/x86-linux-gnu/bits/setjmp.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/sigcontext.h b/lib/libc/include/x86-linux-gnu/bits/sigcontext.h
index fb5a9fec670ad8466621c06222a40935d87e98e0..979232418c1e572a52586d085d5b46cad326d7e1 100644
--- a/lib/libc/include/x86-linux-gnu/bits/sigcontext.h
+++ b/lib/libc/include/x86-linux-gnu/bits/sigcontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/struct_mutex.h b/lib/libc/include/x86-linux-gnu/bits/struct_mutex.h
index 408ed99e4acd62567e07b87faa5aa7694ad9443e..aecbadb5fdbdc2ece477ae5d6c09e96dd5f39f52 100644
--- a/lib/libc/include/x86-linux-gnu/bits/struct_mutex.h
+++ b/lib/libc/include/x86-linux-gnu/bits/struct_mutex.h
@@ -1,5 +1,5 @@
 /* x86 internal mutex struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -32,7 +32,7 @@ struct __pthread_mutex_s
   int __kind;
 #ifdef __x86_64__
   short __spins;
-  short __elision;
+  short __unused;
   __pthread_list_t __list;
 # define __PTHREAD_MUTEX_HAVE_PREV      1
 #else
@@ -41,11 +41,10 @@ struct __pthread_mutex_s
   {
     struct
     {
-      short __espins;
-      short __eelision;
-# define __spins __elision_data.__espins
-# define __elision __elision_data.__eelision
-    } __elision_data;
+      short __data_spins;
+      short __data_unused;
+# define __spins __data.__data_spins
+    } __data;
     __pthread_slist_t __list;
   };
 # define __PTHREAD_MUTEX_HAVE_PREV      0
diff --git a/lib/libc/include/x86-linux-gnu/bits/struct_rwlock.h b/lib/libc/include/x86-linux-gnu/bits/struct_rwlock.h
index 9c97ebdb560f4a52436efaae1498350ceb14f5db..b4fd4d691ede25f7a005c86cdbefee6da4b73e5d 100644
--- a/lib/libc/include/x86-linux-gnu/bits/struct_rwlock.h
+++ b/lib/libc/include/x86-linux-gnu/bits/struct_rwlock.h
@@ -1,5 +1,5 @@
 /* x86 internal rwlock struct definitions.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
@@ -31,14 +31,7 @@ struct __pthread_rwlock_arch_t
 #ifdef __x86_64__
   int __cur_writer;
   int __shared;
-  signed char __rwelision;
-# ifdef  __ILP32__
-  unsigned char __pad1[3];
-#  define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0 }
-# else
-  unsigned char __pad1[7];
-#  define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0, 0, 0, 0, 0 }
-# endif
+  unsigned long int __pad1;
   unsigned long int __pad2;
   /* FLAGS must stay at this position in the structure to maintain
      binary compatibility.  */
@@ -48,7 +41,7 @@ struct __pthread_rwlock_arch_t
      binary compatibility.  */
   unsigned char __flags;
   unsigned char __shared;
-  signed char __rwelision;
+  unsigned char __pad1;
   unsigned char __pad2;
   int __cur_writer;
 #endif
@@ -56,7 +49,7 @@ struct __pthread_rwlock_arch_t
 
 #ifdef __x86_64__
 # define __PTHREAD_RWLOCK_INITIALIZER(__flags) \
-  0, 0, 0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, __flags
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, __flags
 #else
 # define __PTHREAD_RWLOCK_INITIALIZER(__flags) \
   0, 0, 0, 0, 0, 0, __flags, 0, 0, 0, 0
diff --git a/lib/libc/include/x86-linux-gnu/bits/struct_stat.h b/lib/libc/include/x86-linux-gnu/bits/struct_stat.h
index 2978a4dca4cea953ab0e3a46ac23bbbfbf77998d..938ab40b4938c8e2b2130778a7d16c8631f1c61a 100644
--- a/lib/libc/include/x86-linux-gnu/bits/struct_stat.h
+++ b/lib/libc/include/x86-linux-gnu/bits/struct_stat.h
@@ -1,5 +1,5 @@
 /* Definition for struct stat.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/timesize.h b/lib/libc/include/x86-linux-gnu/bits/timesize.h
index 88f07ae6351a951e32377aa42ab0b7ba49bc04db..905260617f04029492b2b24c1b618d82ebffe73c 100644
--- a/lib/libc/include/x86-linux-gnu/bits/timesize.h
+++ b/lib/libc/include/x86-linux-gnu/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, x86-64 and x32 case.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/types/struct_semid_ds.h b/lib/libc/include/x86-linux-gnu/bits/types/struct_semid_ds.h
index 77fcfc080a720f4c8e4c4b854bd1a84e1d4591c9..aa85084d3b13f19614cb7b510d8a0461b050da9e 100644
--- a/lib/libc/include/x86-linux-gnu/bits/types/struct_semid_ds.h
+++ b/lib/libc/include/x86-linux-gnu/bits/types/struct_semid_ds.h
@@ -1,5 +1,5 @@
 /* x86 implementation of the semaphore struct semid_ds.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/bits/typesizes.h b/lib/libc/include/x86-linux-gnu/bits/typesizes.h
index 3210b86ddc459da43ac4571433a6a7a1eebfc44d..02fab5a6ca47feea8aa3074a3321cf36663ed855 100644
--- a/lib/libc/include/x86-linux-gnu/bits/typesizes.h
+++ b/lib/libc/include/x86-linux-gnu/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Linux/x86-64 version.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/finclude/math-vector-fortran.h b/lib/libc/include/x86-linux-gnu/finclude/math-vector-fortran.h
index 7760ea7a8d46a04a25db40ab02eff60f91b215d4..3bb1f569ed0e3fa26b1cd555c83008bb159a56c1 100644
--- a/lib/libc/include/x86-linux-gnu/finclude/math-vector-fortran.h
+++ b/lib/libc/include/x86-linux-gnu/finclude/math-vector-fortran.h
@@ -1,5 +1,5 @@
 ! Platform-specific declarations of SIMD math functions for Fortran. -*- f90 -*-
-!   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+!   Copyright (C) 2019-2026 Free Software Foundation, Inc.
 !   This file is part of the GNU C Library.
 !
 !   The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/fpu_control.h b/lib/libc/include/x86-linux-gnu/fpu_control.h
index 2765f7b4442bdec14160cb4b65721652f3e00c31..64c3614414811732cf7be07aa0dd7c8668b2c660 100644
--- a/lib/libc/include/x86-linux-gnu/fpu_control.h
+++ b/lib/libc/include/x86-linux-gnu/fpu_control.h
@@ -1,5 +1,5 @@
 /* FPU control word bits.  x86 version.
-   Copyright (C) 1993-2025 Free Software Foundation, Inc.
+   Copyright (C) 1993-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/sys/elf.h b/lib/libc/include/x86-linux-gnu/sys/elf.h
index 4a898f9ea5b627161de3e5da158446af2b955f1b..ca9a4c837dd8577b4b7433c18965d1d89047325d 100644
--- a/lib/libc/include/x86-linux-gnu/sys/elf.h
+++ b/lib/libc/include/x86-linux-gnu/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/sys/ptrace.h b/lib/libc/include/x86-linux-gnu/sys/ptrace.h
index bc58b8168ca9188cd1e0593e6da32a7e10d6d846..1d50aaa769ae3fc2881cea25419591b175d1a39b 100644
--- a/lib/libc/include/x86-linux-gnu/sys/ptrace.h
+++ b/lib/libc/include/x86-linux-gnu/sys/ptrace.h
@@ -1,5 +1,5 @@
 /* `ptrace' debugger support interface.  Linux/x86 version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/include/x86-linux-gnu/sys/ucontext.h b/lib/libc/include/x86-linux-gnu/sys/ucontext.h
index f2526fac2c8a3b402fdc8016acccf33d6260f614..d317519d59c59ec0122c1c637b3cc4373f6cfe2b 100644
--- a/lib/libc/include/x86-linux-gnu/sys/ucontext.h
+++ b/lib/libc/include/x86-linux-gnu/sys/ucontext.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/include/x86-linux-gnu/sys/user.h b/lib/libc/include/x86-linux-gnu/sys/user.h
index 4572023bfd1292b7cc6c7dc0bd3fc65c8c5c6878..02527f2dc8d61fed7cc49b1ffca556c1c98dcb07 100644
--- a/lib/libc/include/x86-linux-gnu/sys/user.h
+++ b/lib/libc/include/x86-linux-gnu/sys/user.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
-- 
2.54.0


From e4058f2c27e9b1b91194ab7ed46c74203ac92a24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 26 Jan 2026 05:30:25 +0100
Subject: [PATCH 045/499] libc: update glibc abilists to 2.43

---
 lib/libc/glibc/abilists | Bin 248210 -> 248691 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/lib/libc/glibc/abilists b/lib/libc/glibc/abilists
index be8d67ebfb8ec6c97fa488bf127d6034d8b4e0aa..3dec0a31a51a74d915e94a8c647416555d175a13 100644
GIT binary patch
delta 2695
zcmbtWZERCj7{2G6wOvP{UD!vLt<bF*;8wPE0U3sE-GY%37P1(o0h7Dh-rLpn%iaqa
zCdwTo%lu$6E_%&mfQd+4gv?#_H8Ei%#9#u6`zIk994>x4qW&@Zqu$e{o14Adg!adI
zZ+dUu_c_n|yw5qOW&59R+E3M>mNCyojO#zVaSWTBBV0Tr+m3cA?l3Z|<D|p3%K;AN
zgFfbcY32vQFd+Gv%aSx=V_YCf4#uXfS}3By%~a9gXD(^0WMxdCIvhf2ei=TkoiLSe
z)-ZUXk9mZa-%5)}W~m9(aQ*ed3Z0kF`Q)D2D)r#DR#d6;3CkYg<=>xhs-JIPTjJ(Z
z9LENtk#L*~u|nhpF2tm@pM3}tNiH5u$khXWCCTGL*}d1Yq4s}}{LJQMWbJz^@}%x$
z@0_o61^JS6H9ccxKrTMns7{XbV!eIwvB02mrwvu9&94rbw=X4m$HE|x&V74=_Qs%*
z>fG3<IltDu`&OXF;)S5_d`gt7C)(7m&uU#p#0}rRrQ5GCCyKItPp3M0rwkh<y8U(c
zPCenkjxsb<WRL-7-Dsz!T}L~I`BWmtC;3OWF|W_0(^jqdIW-DxTTl|)se}Szb5>Ds
zr49|-a<>;cb|9~H_fpp$V(u0PWQter{)4-e#52SMfB8|}8lxRQwhw(%o*NYv9XuIA
zj~huJrUp>R@FTB)ZW^@^>_^Zq#Riy_-_DagaBu{DMX(p3`8AX#PMu!#%hkts%jc)e
zFnS8r;=I%iKb}S@Yx$<EBh7tDC6IL{h@C|ji*hrm%=vH=?7xKSS`GFFWAi9r(G_vQ
zuLwv>H8tgP)SIW5M|wKr&Du)6nFh_9X;}8=X}EtMjbq&noc#k0ugj02rw~3+s*C<=
z8J@D_W+<bz$ql%#AU^=@9xUh#S*FB7Bc5Mt)PtW}vCpncQ$sgSI9)6o<6;6QvfN-Y
z8VN>3HrPLqopoh`!}Gcc&hU8LM3vhZ#g`j&*;*LK4Qujaqvt(bwys12nmOZQTwGj2
z*wH|qhMAA>A=K$vaol_Ub4+N@^uVWqswxvTS!Lp~t~{U|_yoV0A5;tAWPPc|Xds%!
z$g+Z%5)&b1_8#trTla7k$*+d%dtB+#oMOd|LX5<?6dz*4%IJRNQ?AwEf?dhTA_nQ>
zMav(ghOeE&5555iM}=S_uAmas34asvQl(>6si?B>9ja6=Y$V4YeujJ9<dwo=dU08C
zVS&3_$WNB?RieyN312jkX~+7*+ASgQtdRYek455258#b3(Lw4e9x$2Y5J{F4dO?W9
og9$<Ly^LI-B*+`<i&t$i%qhqEQ46F_kZz}a)l0bfHo39&Up%GeYXATM

delta 876
zcmY+BTS!z<6oy-Ck8{SmGmbfyHd!gvP&sN>FJTwDc`1^iP%_h*$xuf<Hrhiu355_{
zrcLdFjG`+vNqVRi6qFAJp@>4DU{aCN4Vj{s3Zl+AJ@vNtT5JFRxBmV8V*Gg?e{KP+
z4lcaaJ9rEuBD>s;wPJn{w}`K0Xi~aaQ4GJ?k*}mD)F<hOk&KHGBF}<WrNhy05*1;v
z;322j6^2yhaBczcp=%aHRh8ev&0B5C^vYPP!Pn$&6cB(7JS*3T?H>NlW>-44r)bKB
z%A{-DsVo2Nav={rw1~SFOi=u%f<`gj26@W1^T&<i<`5PrahLZlFotU6=9X4I+Eb{6
zo@Au)k2aeU9v=c8%Pr!;Fk1OpUyhP8k%Ve%j#4_gW35Qdghc9{4S^_aoXXN+t)$Hx
z4|`gC4IbWqEsfRtykbQrZXxp$$V92l*HY_lZ{oq6JnC}5COrm9SOdRJIt=Y9g7#?5
zf<6_)M6$L5ncT2h(rWzofJCkJP@&%_EW=A3M~oDqN!;;ZEY0}gm08Dm(*<?|gdUxS
zKa79zS>PZ)c54$=1i^utEK@nex5aE8ede$|k`KN}qLOa75hYydkWaaH!BL<K9i4`1
zNsZ77eqna0D@V`3br$pN1Dh2HT>bMba#kPj?N~uyz5+*8CXp_Dhm&zS`aZ<cB<(w`
z$#P9~{ei|hx7+Q^UZcJ=1wt*=buu4y6pHzsu#U=YXqUv;2<8*nalb(oD5T0oc<5h9
zQBItS)lv{Q%*;&o^*AqHcPlSNpG~~=;FP|@q!%wmK#1BJ@cwfCbdQDduHf=$9Vc`L
z<Kx8h0GMd(A>IR#lg-k^k9N!ugM@zF@#JIlI_TGXY-VEBY89sE16tGgYdJ=Y8kkFq
zM3RrlHNHlVaF(+TbS8owovZi5Q(zSDXK=PymCic<OGxw%VHW*R%O+M^*T6^RWV*eS
z4NG(?oAo77@kUmXqBBlbvL>s_U)IbXCu*{i*WKFGAba`o-C0y}g6*`a)i~<uW&_Lq
E0x6|eUjP6A

-- 
2.54.0


From ff8dbd010faa1945a796d31a7449e1ba89805f43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 26 Jan 2026 05:30:07 +0100
Subject: [PATCH 046/499] libc: update glibc crt0 code to 2.43

---
 lib/libc/glibc/bits/byteswap.h                |  2 +-
 lib/libc/glibc/bits/floatn-common.h           |  2 +-
 lib/libc/glibc/bits/libc-header-start.h       |  2 +-
 lib/libc/glibc/bits/long-double.h             |  2 +-
 lib/libc/glibc/bits/select.h                  |  2 +-
 lib/libc/glibc/bits/signum-generic.h          |  2 +-
 lib/libc/glibc/bits/stat.h                    |  2 +-
 lib/libc/glibc/bits/stdint-intn.h             |  2 +-
 lib/libc/glibc/bits/stdlib-bsearch.h          |  2 +-
 lib/libc/glibc/bits/time64.h                  |  2 +-
 lib/libc/glibc/bits/timesize.h                |  2 +-
 .../glibc/bits/types/struct_sched_param.h     |  2 +-
 lib/libc/glibc/bits/typesizes.h               |  2 +-
 lib/libc/glibc/bits/uintn-identity.h          |  2 +-
 lib/libc/glibc/bits/waitflags.h               |  2 +-
 lib/libc/glibc/bits/waitstatus.h              |  2 +-
 lib/libc/glibc/csu/errno.c                    |  2 +-
 lib/libc/glibc/csu/init.c                     |  2 +-
 lib/libc/glibc/debug/stack_chk_fail_local.c   |  2 +-
 lib/libc/glibc/elf/elf.h                      |  4 +-
 lib/libc/glibc/include/alloca.h               |  2 +-
 lib/libc/glibc/include/libc-diag.h            | 99 +++++++++++++++++++
 lib/libc/glibc/include/libc-misc.h            |  2 +-
 lib/libc/glibc/include/libc-pointer-arith.h   |  2 +-
 lib/libc/glibc/include/libc-symbols.h         | 22 ++++-
 lib/libc/glibc/include/pthread.h              |  4 -
 lib/libc/glibc/include/stap-probe.h           |  2 +-
 lib/libc/glibc/io/bits/statx.h                |  2 +-
 lib/libc/glibc/io/fcntl.h                     |  2 +-
 lib/libc/glibc/io/mknod.c                     |  2 +-
 lib/libc/glibc/io/sys/stat.h                  |  2 +-
 lib/libc/glibc/locale/bits/types/__locale_t.h |  2 +-
 lib/libc/glibc/locale/bits/types/locale_t.h   |  2 +-
 lib/libc/glibc/misc/sys/cdefs.h               | 30 ++++--
 lib/libc/glibc/misc/sys/select.h              |  2 +-
 lib/libc/glibc/posix/bits/cpu-set.h           |  2 +-
 lib/libc/glibc/posix/bits/types.h             |  2 +-
 lib/libc/glibc/posix/sys/types.h              |  2 +-
 lib/libc/glibc/signal/signal.h                |  2 +-
 lib/libc/glibc/stdlib/alloca.h                |  2 +-
 lib/libc/glibc/stdlib/bits/stdlib-float.h     |  2 +-
 lib/libc/glibc/stdlib/errno.h                 |  2 +-
 lib/libc/glibc/stdlib/exit.h                  |  2 +-
 lib/libc/glibc/stdlib/stdlib.h                | 43 +++++++-
 lib/libc/glibc/string/bits/endian.h           |  2 +-
 lib/libc/glibc/string/endian.h                |  2 +-
 .../aarch64/nptl/bits/pthreadtypes-arch.h     |  2 +-
 lib/libc/glibc/sysdeps/aarch64/start.S        |  2 +-
 lib/libc/glibc/sysdeps/aarch64/sysdep.h       |  2 +-
 lib/libc/glibc/sysdeps/arc/start.S            |  2 +-
 lib/libc/glibc/sysdeps/arc/sysdep.h           |  2 +-
 lib/libc/glibc/sysdeps/arm/arm-features.h     |  2 +-
 lib/libc/glibc/sysdeps/arm/start.S            |  2 +-
 lib/libc/glibc/sysdeps/arm/sysdep.h           |  2 +-
 lib/libc/glibc/sysdeps/csky/abiv2/start.S     |  2 +-
 lib/libc/glibc/sysdeps/csky/sysdep.h          |  2 +-
 lib/libc/glibc/sysdeps/generic/dl-dtprocnum.h |  2 +-
 lib/libc/glibc/sysdeps/generic/dl-sysdep.h    |  2 +-
 lib/libc/glibc/sysdeps/generic/dwarf2.h       |  2 +-
 lib/libc/glibc/sysdeps/generic/libc-lock.h    |  2 +-
 lib/libc/glibc/sysdeps/generic/libc-symver.h  |  2 +-
 .../glibc/sysdeps/generic/single-thread.h     |  2 +-
 lib/libc/glibc/sysdeps/generic/symbol-hacks.h | 16 +++
 lib/libc/glibc/sysdeps/generic/sysdep.h       |  2 +-
 lib/libc/glibc/sysdeps/generic/tls.h          |  2 +-
 lib/libc/glibc/sysdeps/htl/bits/pthread.h     |  2 +-
 .../sysdeps/htl/bits/thread-shared-types.h    |  2 +-
 lib/libc/glibc/sysdeps/htl/libc-lockP.h       | 37 +------
 lib/libc/glibc/sysdeps/htl/pthread.h          |  2 +-
 .../sysdeps/i386/htl/bits/pthreadtypes-arch.h |  2 +-
 lib/libc/glibc/sysdeps/i386/start.S           |  2 +-
 lib/libc/glibc/sysdeps/i386/symbol-hacks.h    |  2 +-
 lib/libc/glibc/sysdeps/i386/sysdep.h          |  2 +-
 lib/libc/glibc/sysdeps/loongarch/start.S      |  2 +-
 lib/libc/glibc/sysdeps/loongarch/sys/regdef.h |  2 +-
 lib/libc/glibc/sysdeps/m68k/coldfire/sysdep.h |  2 +-
 lib/libc/glibc/sysdeps/m68k/m680x0/sysdep.h   |  2 +-
 .../m68k/nptl/bits/pthreadtypes-arch.h        |  2 +-
 lib/libc/glibc/sysdeps/m68k/start.S           |  2 +-
 lib/libc/glibc/sysdeps/m68k/symbol-hacks.h    |  2 +-
 lib/libc/glibc/sysdeps/m68k/sysdep.h          |  2 +-
 lib/libc/glibc/sysdeps/mach/libc-lock.h       |  2 +-
 lib/libc/glibc/sysdeps/mach/sysdep.h          |  2 +-
 lib/libc/glibc/sysdeps/mips/dl-dtprocnum.h    |  2 +-
 lib/libc/glibc/sysdeps/mips/isarev.h          |  8 ++
 .../mips/nptl/bits/pthreadtypes-arch.h        |  2 +-
 lib/libc/glibc/sysdeps/mips/start.S           |  2 +-
 .../glibc/sysdeps/nptl/bits/pthreadtypes.h    |  2 +-
 .../sysdeps/nptl/bits/thread-shared-types.h   |  4 +-
 lib/libc/glibc/sysdeps/nptl/libc-lock.h       |  2 +-
 lib/libc/glibc/sysdeps/nptl/libc-lockP.h      |  9 +-
 lib/libc/glibc/sysdeps/nptl/pthread.h         |  2 +-
 .../glibc/sysdeps/powerpc/powerpc32/start.S   |  2 +-
 .../sysdeps/powerpc/powerpc32/symbol-hacks.h  |  2 +-
 .../glibc/sysdeps/powerpc/powerpc32/sysdep.h  |  2 +-
 .../sysdeps/powerpc/powerpc64/dl-dtprocnum.h  |  2 +-
 .../glibc/sysdeps/powerpc/powerpc64/start.S   |  2 +-
 .../glibc/sysdeps/powerpc/powerpc64/sysdep.h  |  2 +-
 lib/libc/glibc/sysdeps/powerpc/sysdep.h       |  2 +-
 .../riscv/nptl/bits/pthreadtypes-arch.h       |  2 +-
 lib/libc/glibc/sysdeps/riscv/start.S          |  2 +-
 lib/libc/glibc/sysdeps/s390/s390-64/start.S   |  2 +-
 lib/libc/glibc/sysdeps/s390/s390-64/sysdep.h  |  2 +-
 lib/libc/glibc/sysdeps/sparc/dl-dtprocnum.h   |  2 +-
 lib/libc/glibc/sysdeps/sparc/sparc32/start.S  |  2 +-
 lib/libc/glibc/sysdeps/sparc/sparc64/start.S  |  2 +-
 lib/libc/glibc/sysdeps/sparc/sysdep.h         |  2 +-
 lib/libc/glibc/sysdeps/unix/arm/sysdep.h      |  2 +-
 lib/libc/glibc/sysdeps/unix/i386/sysdep.h     |  2 +-
 .../glibc/sysdeps/unix/mips/mips32/sysdep.h   |  2 +-
 .../glibc/sysdeps/unix/mips/mips64/sysdep.h   |  2 +-
 lib/libc/glibc/sysdeps/unix/mips/sysdep.h     |  6 +-
 lib/libc/glibc/sysdeps/unix/powerpc/sysdep.h  |  2 +-
 lib/libc/glibc/sysdeps/unix/sh/sysdep.h       |  2 +-
 lib/libc/glibc/sysdeps/unix/sysdep.h          |  4 +-
 .../unix/sysv/linux/aarch64/kernel-features.h |  2 +-
 .../sysdeps/unix/sysv/linux/aarch64/sys/elf.h |  2 +-
 .../sysdeps/unix/sysv/linux/aarch64/sysdep.h  | 41 +++++++-
 .../sysdeps/unix/sysv/linux/arc/sysdep.h      |  2 +-
 .../unix/sysv/linux/arm/kernel-features.h     |  2 +-
 .../sysdeps/unix/sysv/linux/arm/sys/elf.h     |  2 +-
 .../sysdeps/unix/sysv/linux/arm/sysdep.h      |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/bits/stat.h |  2 +-
 .../sysdeps/unix/sysv/linux/bits/timex.h      |  2 +-
 .../unix/sysv/linux/csky/kernel_stat.h        |  2 +-
 .../sysdeps/unix/sysv/linux/csky/sysdep.h     |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/dl-sysdep.h |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/fstat.c     |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/fstat64.c   |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/fstatat.c   |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/fstatat64.c |  2 +-
 .../sysdeps/unix/sysv/linux/i386/dl-sysdep.h  |  2 +-
 .../unix/sysv/linux/i386/kernel-features.h    |  2 +-
 .../sysdeps/unix/sysv/linux/i386/sysdep.h     |  2 +-
 .../unix/sysv/linux/include/sys/timex.h       |  2 +-
 .../sysdeps/unix/sysv/linux/kernel-features.h |  7 +-
 .../sysdeps/unix/sysv/linux/kernel_stat.h     |  2 +-
 .../unix/sysv/linux/loongarch/sysdep.h        |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/lstat.c     |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/lstat64.c   |  2 +-
 .../unix/sysv/linux/m68k/coldfire/sysdep.h    |  2 +-
 .../unix/sysv/linux/m68k/kernel-features.h    |  2 +-
 .../unix/sysv/linux/m68k/m680x0/sysdep.h      |  2 +-
 .../sysdeps/unix/sysv/linux/m68k/sysdep.h     |  2 +-
 .../unix/sysv/linux/mips/kernel-features.h    |  2 +-
 .../unix/sysv/linux/mips/mips32/sysdep.h      |  2 +-
 .../unix/sysv/linux/mips/mips64/kstat_cp.h    |  2 +-
 .../unix/sysv/linux/mips/mips64/sysdep.h      |  2 +-
 .../sysdeps/unix/sysv/linux/mips/sysdep.h     |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/mknodat.c   |  2 +-
 .../unix/sysv/linux/powerpc/kernel-features.h |  2 +-
 .../linux/powerpc/powerpc32/kernel_stat.h     |  2 +-
 .../sysv/linux/powerpc/powerpc64/sysdep.h     |  2 +-
 .../sysdeps/unix/sysv/linux/powerpc/sysdep.h  |  2 +-
 .../unix/sysv/linux/riscv/kernel-features.h   |  2 +-
 .../sysdeps/unix/sysv/linux/riscv/sysdep.h    |  7 ++
 .../unix/sysv/linux/s390/bits/typesizes.h     |  2 +-
 .../unix/sysv/linux/s390/kernel-features.h    |  2 +-
 .../unix/sysv/linux/s390/s390-64/sysdep.h     |  2 +-
 .../sysdeps/unix/sysv/linux/s390/sys/elf.h    |  2 +-
 .../sysdeps/unix/sysv/linux/s390/sysdep.h     |  2 +-
 .../sysdeps/unix/sysv/linux/single-thread.h   |  2 +-
 .../unix/sysv/linux/sparc/bits/typesizes.h    |  2 +-
 .../unix/sysv/linux/sparc/kernel-features.h   |  2 +-
 .../unix/sysv/linux/sparc/sparc32/sysdep.h    |  2 +-
 .../unix/sysv/linux/sparc/sparc64/kstat_cp.h  |  2 +-
 .../unix/sysv/linux/sparc/sparc64/sysdep.h    |  2 +-
 .../sysdeps/unix/sysv/linux/sparc/sysdep.h    |  2 +-
 lib/libc/glibc/sysdeps/unix/sysv/linux/stat.c |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/stat64.c    |  2 +-
 .../sysdeps/unix/sysv/linux/stat_t64_cp.c     |  2 +-
 .../sysdeps/unix/sysv/linux/stat_t64_cp.h     |  2 +-
 .../unix/sysv/linux/struct_stat_time64.h      |  2 +-
 .../sysdeps/unix/sysv/linux/sys/syscall.h     |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/sys/timex.h |  2 +-
 .../glibc/sysdeps/unix/sysv/linux/sysdep.h    |  2 +-
 .../unix/sysv/linux/x86/bits/typesizes.h      |  2 +-
 .../sysdeps/unix/sysv/linux/x86/sys/elf.h     |  2 +-
 .../unix/sysv/linux/x86_64/kernel-features.h  |  2 +-
 .../sysdeps/unix/sysv/linux/x86_64/sysdep.h   |  2 +-
 .../unix/sysv/linux/x86_64/x32/sysdep.h       |  2 +-
 lib/libc/glibc/sysdeps/unix/x86_64/sysdep.h   |  2 +-
 .../sysdeps/wordsize-32/divdi3-symbol-hacks.h |  2 +-
 .../sysdeps/x86/nptl/bits/pthreadtypes-arch.h |  2 +-
 lib/libc/glibc/sysdeps/x86/sysdep.h           |  2 +-
 lib/libc/glibc/sysdeps/x86_64/start.S         |  2 +-
 lib/libc/glibc/sysdeps/x86_64/sysdep.h        |  2 +-
 lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h    |  2 +-
 188 files changed, 439 insertions(+), 246 deletions(-)
 create mode 100644 lib/libc/glibc/include/libc-diag.h
 create mode 100644 lib/libc/glibc/sysdeps/mips/isarev.h

diff --git a/lib/libc/glibc/bits/byteswap.h b/lib/libc/glibc/bits/byteswap.h
index c0841a3574456dc55401bad1d05a619dc5ce02d8..34533ffd5a3ae4a151d772670105e925818ffd2d 100644
--- a/lib/libc/glibc/bits/byteswap.h
+++ b/lib/libc/glibc/bits/byteswap.h
@@ -1,5 +1,5 @@
 /* Macros and inline functions to swap the order of bytes in integer values.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/floatn-common.h b/lib/libc/glibc/bits/floatn-common.h
index 01a579687e765d9c509535408413c120e6e53e61..4c79094828a93c4e87edae9447f7cfea5d17caef 100644
--- a/lib/libc/glibc/bits/floatn-common.h
+++ b/lib/libc/glibc/bits/floatn-common.h
@@ -1,6 +1,6 @@
 /* Macros to control TS 18661-3 glibc features where the same
    definitions are appropriate for all platforms.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/libc-header-start.h b/lib/libc/glibc/bits/libc-header-start.h
index e8477f972a9216652f2081acd8f5803bc6110ff0..45897cd66316b16f3eba1f5aeb5bc6a10fa63f46 100644
--- a/lib/libc/glibc/bits/libc-header-start.h
+++ b/lib/libc/glibc/bits/libc-header-start.h
@@ -1,5 +1,5 @@
 /* Handle feature test macros at the start of a header.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/long-double.h b/lib/libc/glibc/bits/long-double.h
index 77421347b533f7bc3c06dc18cd9168b5b3b4e5ba..4ff6c03eb124c76f11dad0798658c2c4b704d94e 100644
--- a/lib/libc/glibc/bits/long-double.h
+++ b/lib/libc/glibc/bits/long-double.h
@@ -1,5 +1,5 @@
 /* Properties of long double type.
-   Copyright (C) 2016-2025 Free Software Foundation, Inc.
+   Copyright (C) 2016-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/select.h b/lib/libc/glibc/bits/select.h
index 065e1d1dde6599415ea0083dd212c4067d05d382..5edc32dbbfa1db8f237c52036343e69cf8366bb7 100644
--- a/lib/libc/glibc/bits/select.h
+++ b/lib/libc/glibc/bits/select.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/signum-generic.h b/lib/libc/glibc/bits/signum-generic.h
index 31dc2cd3959299236d0e5439caed2d16fa2892de..12cbe6678f9b1dc576569cd5933bbfef3f6ae505 100644
--- a/lib/libc/glibc/bits/signum-generic.h
+++ b/lib/libc/glibc/bits/signum-generic.h
@@ -1,5 +1,5 @@
 /* Signal number constants.  Generic template.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/stat.h b/lib/libc/glibc/bits/stat.h
index 9dae670f675b2602e64eb0ea4625340e8c64be2d..10fa5aa8a8d0ffdcefbeca57bc180103d32a98a3 100644
--- a/lib/libc/glibc/bits/stat.h
+++ b/lib/libc/glibc/bits/stat.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/stdint-intn.h b/lib/libc/glibc/bits/stdint-intn.h
index a7fde320e125f66e07ded4361fa37d92a4dd84e7..cbe07dff85f145e77a7eea47af10acdfc59ec5b4 100644
--- a/lib/libc/glibc/bits/stdint-intn.h
+++ b/lib/libc/glibc/bits/stdint-intn.h
@@ -1,5 +1,5 @@
 /* Define intN_t types.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/stdlib-bsearch.h b/lib/libc/glibc/bits/stdlib-bsearch.h
index 5ca67857e59f9f88c19149a18fb2183d8d15bf36..0ee8cdb8c632c81db4da43290edb76037db39dce 100644
--- a/lib/libc/glibc/bits/stdlib-bsearch.h
+++ b/lib/libc/glibc/bits/stdlib-bsearch.h
@@ -1,5 +1,5 @@
 /* Perform binary search - inline version.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/time64.h b/lib/libc/glibc/bits/time64.h
index e858cefdffb034f3878e940f8e03412ac629faca..3fd9941f994fd7842fb41126c011ba930ac1877b 100644
--- a/lib/libc/glibc/bits/time64.h
+++ b/lib/libc/glibc/bits/time64.h
@@ -1,5 +1,5 @@
 /* bits/time64.h -- underlying types for __time64_t.  Generic version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/timesize.h b/lib/libc/glibc/bits/timesize.h
index 9accad9658cc1ef7a8a242e71250ad687b170aed..e3ba2b52faadea04fe1a386a9c0497118fe89a39 100644
--- a/lib/libc/glibc/bits/timesize.h
+++ b/lib/libc/glibc/bits/timesize.h
@@ -1,5 +1,5 @@
 /* Bit size of the time_t type at glibc build time, general case.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/types/struct_sched_param.h b/lib/libc/glibc/bits/types/struct_sched_param.h
index 7a2e06b83447ace598f7e8356f4403fad015ee2e..dce2e5772b9577279dd69f3ae31cd4f57cefb7be 100644
--- a/lib/libc/glibc/bits/types/struct_sched_param.h
+++ b/lib/libc/glibc/bits/types/struct_sched_param.h
@@ -1,5 +1,5 @@
 /* Sched parameter structure.  Generic version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/typesizes.h b/lib/libc/glibc/bits/typesizes.h
index b6db5c3637702a760f8318881342f7c327ed3fe0..466dd36681a7364952e49b73067d66174543cffd 100644
--- a/lib/libc/glibc/bits/typesizes.h
+++ b/lib/libc/glibc/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Generic version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/uintn-identity.h b/lib/libc/glibc/bits/uintn-identity.h
index 96c58abe6554ea245dee4ac14cc53831a775624a..d78bda636b4c7b0dcacff2ad80fd6eae3dd25242 100644
--- a/lib/libc/glibc/bits/uintn-identity.h
+++ b/lib/libc/glibc/bits/uintn-identity.h
@@ -1,5 +1,5 @@
 /* Inline functions to return unsigned integer values unchanged.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/waitflags.h b/lib/libc/glibc/bits/waitflags.h
index 5e7c0f506d9b1142ec450e5a687e13cdd9ce4b41..b36e2d0fad244da8c8ad57d90fbf1ac1ce508785 100644
--- a/lib/libc/glibc/bits/waitflags.h
+++ b/lib/libc/glibc/bits/waitflags.h
@@ -1,5 +1,5 @@
 /* Definitions of flag bits for `waitpid' et al.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/bits/waitstatus.h b/lib/libc/glibc/bits/waitstatus.h
index ccc223947371ee9ef2cdd6ac180f7c20c892e2ca..8a8dd047843e42f861cfb67694cc82d04c517bb9 100644
--- a/lib/libc/glibc/bits/waitstatus.h
+++ b/lib/libc/glibc/bits/waitstatus.h
@@ -1,5 +1,5 @@
 /* Definitions of status bits for `wait' et al.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/csu/errno.c b/lib/libc/glibc/csu/errno.c
index 558315365f36cc411e3b01dafdef0de92762186f..efdf6545c9bfc71f7ace93e8fbbc4db5031d223a 100644
--- a/lib/libc/glibc/csu/errno.c
+++ b/lib/libc/glibc/csu/errno.c
@@ -1,5 +1,5 @@
 /* Definition of `errno' variable.  Canonical version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/csu/init.c b/lib/libc/glibc/csu/init.c
index 92a22de162d2873406f8bb5759f58e050d80cbf7..7fe1b387812a5924d0203ab566cebd8bbe0f5734 100644
--- a/lib/libc/glibc/csu/init.c
+++ b/lib/libc/glibc/csu/init.c
@@ -1,5 +1,5 @@
 /* Special startup support.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/debug/stack_chk_fail_local.c b/lib/libc/glibc/debug/stack_chk_fail_local.c
index 4ba407637fb0b510239e1fda7f1dae97595023ab..7feccea23ea95b5825fd850fe8655bc82f16f40a 100644
--- a/lib/libc/glibc/debug/stack_chk_fail_local.c
+++ b/lib/libc/glibc/debug/stack_chk_fail_local.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/elf/elf.h b/lib/libc/glibc/elf/elf.h
index 2f29a47c0bb8c43d2ed0f8faab60dc8840b3f495..46a01281cb0fb5322d5124f0443c11dea4d5b721 100644
--- a/lib/libc/glibc/elf/elf.h
+++ b/lib/libc/glibc/elf/elf.h
@@ -1,5 +1,5 @@
 /* This file defines standard ELF types, structures, and macros.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -924,7 +924,7 @@ typedef struct
 #define DT_SYMTAB_SHNDX	34		/* Address of SYMTAB_SHNDX section */
 #define DT_RELRSZ	35		/* Total size of RELR relative relocations */
 #define DT_RELR		36		/* Address of RELR relative relocations */
-#define DT_RELRENT	37		/* Size of one RELR relative relocaction */
+#define DT_RELRENT	37		/* Size of one RELR relative relocation */
 #define	DT_NUM		38		/* Number used */
 #define DT_LOOS		0x6000000d	/* Start of OS-specific */
 #define DT_HIOS		0x6ffff000	/* End of OS-specific */
diff --git a/lib/libc/glibc/include/alloca.h b/lib/libc/glibc/include/alloca.h
index c0b83954436ed4c1e7c3246e914bc36ac1606dd9..5f2df32b46252a4fb33f2b7800889733b001e502 100644
--- a/lib/libc/glibc/include/alloca.h
+++ b/lib/libc/glibc/include/alloca.h
@@ -4,7 +4,7 @@
 
 # ifndef _ISOMAC
 
-#include <stackinfo.h>
+#include <elf.h>
 
 #undef	__alloca
 
diff --git a/lib/libc/glibc/include/libc-diag.h b/lib/libc/glibc/include/libc-diag.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2f7fb5de02515750bd055e937109612b836152b
--- /dev/null
+++ b/lib/libc/glibc/include/libc-diag.h
@@ -0,0 +1,99 @@
+/* Macros for controlling diagnostic output from the compiler.
+   Copyright (C) 2014-2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _LIBC_DIAG_H
+#define _LIBC_DIAG_H 1
+
+/* Ignore the value of an expression when a cast to void does not
+   suffice (in particular, for a call to a function declared with
+   attribute warn_unused_result).  */
+#define ignore_value(x) \
+  ({ __typeof__ (x) __ignored_value = (x); (void) __ignored_value; })
+
+/* The macros to control diagnostics are structured like this, rather
+   than a single macro that both pushes and pops diagnostic state and
+   takes the affected code as an argument, because the GCC pragmas
+   work by disabling the diagnostic for a range of source locations
+   and do not work when all the pragmas and the affected code are in a
+   single macro expansion.  */
+
+/* Push diagnostic state.  */
+#define DIAG_PUSH_NEEDS_COMMENT _Pragma ("GCC diagnostic push")
+
+/* Pop diagnostic state.  */
+#define DIAG_POP_NEEDS_COMMENT _Pragma ("GCC diagnostic pop")
+
+/* These macros are used to push/pop diagnostic states for warnings only
+   supported by clang.  */
+#ifdef __clang__
+# define DIAG_PUSH_NEEDS_COMMENT_CLANG _Pragma ("clang diagnostic push")
+# define DIAG_POP_NEEDS_COMMENT_CLANG _Pragma ("clang diagnostic pop")
+#else
+# define DIAG_PUSH_NEEDS_COMMENT_CLANG
+# define DIAG_POP_NEEDS_COMMENT_CLANG
+#endif
+
+#define _DIAG_STR1(s) #s
+#define _DIAG_STR(s) _DIAG_STR1(s)
+
+/* Ignore the diagnostic OPTION.  VERSION is the most recent GCC
+   version for which the diagnostic has been confirmed to appear in
+   the absence of the pragma (in the form MAJOR.MINOR for GCC 4.x,
+   just MAJOR for GCC 5 and later).  Uses of this pragma should be
+   reviewed when the GCC version given is no longer supported for
+   building glibc; the version number should always be on the same
+   source line as the macro name, so such uses can be found with grep.
+   Uses should come with a comment giving more details of the
+   diagnostic, and an architecture on which it is seen if possibly
+   optimization-related and not in architecture-specific code.  This
+   macro should only be used if the diagnostic seems hard to fix (for
+   example, optimization-related false positives).  */
+#define DIAG_IGNORE_NEEDS_COMMENT(version, option)     \
+  _Pragma (_DIAG_STR (GCC diagnostic ignored option))
+
+/* Similar to DIAG_IGNORE_NEEDS_COMMENT the following macro ignores the
+   diagnostic OPTION but only if optimizations for size are enabled.
+   This is required because different warnings may be generated for
+   different optimization levels.  For example a key piece of code may
+   only generate a warning when compiled at -Os, but at -O2 you could
+   still want the warning to be enabled to catch errors.  In this case
+   you would use DIAG_IGNORE_Os_NEEDS_COMMENT to disable the warning
+   only for -Os.  */
+#ifdef __OPTIMIZE_SIZE__
+# define DIAG_IGNORE_Os_NEEDS_COMMENT(version, option) \
+  _Pragma (_DIAG_STR (GCC diagnostic ignored option))
+#else
+# define DIAG_IGNORE_Os_NEEDS_COMMENT(version, option)
+#endif
+
+/* Similar to DIAG_IGNORE_NEEDS_COMMENT, these macros should be used
+   to suppress warning supported by the specific compiler.  */
+#ifndef __clang__
+# define DIAG_IGNORE_NEEDS_COMMENT_GCC(VERSION, WARNING) \
+  DIAG_IGNORE_NEEDS_COMMENT (VERSION, WARNING)
+# define DIAG_IGNORE_Os_NEEDS_COMMENT_GCC(VERSION, WARNING) \
+  DIAG_IGNORE_Os_NEEDS_COMMENT (VERSION, WARNING)
+# define DIAG_IGNORE_NEEDS_COMMENT_CLANG(version, option)
+#else
+# define DIAG_IGNORE_NEEDS_COMMENT_GCC(VERSION, WARNING)
+# define DIAG_IGNORE_Os_NEEDS_COMMENT_GCC(VERSION, WARNING)
+# define DIAG_IGNORE_NEEDS_COMMENT_CLANG(version, option) \
+  _Pragma (_DIAG_STR (clang diagnostic ignored option))
+#endif
+
+#endif /* libc-diag.h */
diff --git a/lib/libc/glibc/include/libc-misc.h b/lib/libc/glibc/include/libc-misc.h
index e76a8097d8b5d6ca21002716dd351168fe936fe7..01984398a32aa31dc9118328f0d6b32812bee62f 100644
--- a/lib/libc/glibc/include/libc-misc.h
+++ b/lib/libc/glibc/include/libc-misc.h
@@ -1,5 +1,5 @@
 /* Miscellaneous definitions for both glibc build and test.
-   Copyright (C) 2024-2025 Free Software Foundation, Inc.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/include/libc-pointer-arith.h b/lib/libc/glibc/include/libc-pointer-arith.h
index 815ba65ec9bd55653f905d0ac390a3d47fe38b53..e5b9748559118c9a789abdbd80e08fd7460f7838 100644
--- a/lib/libc/glibc/include/libc-pointer-arith.h
+++ b/lib/libc/glibc/include/libc-pointer-arith.h
@@ -1,5 +1,5 @@
 /* Helper macros for pointer arithmetic.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/include/libc-symbols.h b/lib/libc/glibc/include/libc-symbols.h
index 7f2c8938b6cd9d5aaba9dd4ba1daa3d4cda1a1cf..bebfc67cec098bf106bb9231bd3ff47e8f85d31f 100644
--- a/lib/libc/glibc/include/libc-symbols.h
+++ b/lib/libc/glibc/include/libc-symbols.h
@@ -1,6 +1,6 @@
 /* Support macros for making weak and strong aliases for symbols,
    and for using symbol sets and linker warnings with GNU ld.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -86,6 +86,7 @@
 
 /* Obtain the definition of symbol_version_reference.  */
 #include <libc-symver.h>
+#include <libc-diag.h>
 
 /* When PIC is defined and SHARED isn't defined, we are building PIE
    by default.  */
@@ -167,6 +168,16 @@
     __attribute_copy__ (name);
 #endif
 
+/* Define a strong_alias for SHARED, or weak_alias otherwise.  It is used to
+   avoid potential compiler warnings for weak alias indirection (when a weak
+   alias is always resolved to a symbol even if a weak definition also
+   exists).  */
+# ifdef SHARED
+#  define static_weak_alias(name, aliasname) strong_alias (name, aliasname)
+# else
+#  define static_weak_alias(name, aliasname) weak_alias (name, aliasname)
+# endif
+
 /* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined).  */
 # define weak_extern(symbol) _weak_extern (weak symbol)
 # define _weak_extern(expr) _Pragma (#expr)
@@ -280,7 +291,7 @@ for linking")
 
 
 /*
-
+
 */
 
 #ifdef HAVE_GNU_RETAIN
@@ -683,7 +694,10 @@ for linking")
 # define __ifunc_args(type_name, name, expr, init, ...)			\
   extern __typeof (type_name) name __attribute__			\
 			      ((ifunc (#name "_ifunc")));		\
-  __ifunc_resolver (type_name, name, expr, init, static, __VA_ARGS__)
+  DIAG_PUSH_NEEDS_COMMENT_CLANG;					\
+  DIAG_IGNORE_NEEDS_COMMENT_CLANG (13, "-Wunused-function");		\
+  __ifunc_resolver (type_name, name, expr, init, static, __VA_ARGS__);	\
+  DIAG_POP_NEEDS_COMMENT_CLANG;
 
 # define __ifunc_args_hidden(type_name, name, expr, init, ...)		\
   __ifunc_args (type_name, name, expr, init, __VA_ARGS__)
@@ -807,7 +821,7 @@ for linking")
 #define libm_ifunc_init()
 #define libm_ifunc(name, expr)				\
   __ifunc (name, name, expr, void, libm_ifunc_init)
-
+
 /* These macros facilitate sharing source files with gnulib.
 
    They are here instead of sys/cdefs.h because they should not be
diff --git a/lib/libc/glibc/include/pthread.h b/lib/libc/glibc/include/pthread.h
index 819bf3f235e36d5988c84a9dca5037b23a9cc449..9e31b74916d78c6faa5aa7b05186d76f0a3c731c 100644
--- a/lib/libc/glibc/include/pthread.h
+++ b/lib/libc/glibc/include/pthread.h
@@ -8,14 +8,10 @@ extern int __pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
 				 const pthread_barrierattr_t *__restrict
 				 __attr, unsigned int __count)
      __THROW __nonnull ((1));
-#if PTHREAD_IN_LIBC
 libc_hidden_proto (__pthread_barrier_init)
-#endif
 extern int __pthread_barrier_wait (pthread_barrier_t *__barrier)
      __THROWNL __nonnull ((1));
-#if PTHREAD_IN_LIBC
 libc_hidden_proto (__pthread_barrier_wait)
-#endif
 
 /* This function is called to initialize the pthread library.  */
 extern void __pthread_initialize (void) __attribute__ ((weak));
diff --git a/lib/libc/glibc/include/stap-probe.h b/lib/libc/glibc/include/stap-probe.h
index 9ff4ca83e5a7d720096364b66369baf7a8708333..32e4e77f2a62e64ffcebd87bcb0e9b1b4cfc3cdc 100644
--- a/lib/libc/glibc/include/stap-probe.h
+++ b/lib/libc/glibc/include/stap-probe.h
@@ -1,5 +1,5 @@
 /* Macros for defining Systemtap <sys/sdt.h> static probe points.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/io/bits/statx.h b/lib/libc/glibc/io/bits/statx.h
index 5c1228c3bffc356fd1172500436519d4f29def73..ec94398bdc5442710f2f0d7f8996c09d51d86b91 100644
--- a/lib/libc/glibc/io/bits/statx.h
+++ b/lib/libc/glibc/io/bits/statx.h
@@ -1,5 +1,5 @@
 /* statx-related definitions and declarations.  Generic version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/io/fcntl.h b/lib/libc/glibc/io/fcntl.h
index d99dc68a88742bf898f6ac501d20a8afb989e58e..7bbccf05725b75667448608f6a915d5446d19cd0 100644
--- a/lib/libc/glibc/io/fcntl.h
+++ b/lib/libc/glibc/io/fcntl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/io/mknod.c b/lib/libc/glibc/io/mknod.c
index 66020d58ca3a2c8a25790c1c218ee67feb35207f..bd2a4a1268596dd106bf3882bfc8d24bc8750e71 100644
--- a/lib/libc/glibc/io/mknod.c
+++ b/lib/libc/glibc/io/mknod.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/io/sys/stat.h b/lib/libc/glibc/io/sys/stat.h
index 4bea9e9a7785f51af8eefd035874f475b92bb26d..3069e187b079461dec1d5c699d49b5aa570a205d 100644
--- a/lib/libc/glibc/io/sys/stat.h
+++ b/lib/libc/glibc/io/sys/stat.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/locale/bits/types/__locale_t.h b/lib/libc/glibc/locale/bits/types/__locale_t.h
index 746b1209f1f389bfd135d4206e5400a2fa33118f..c59a107941a2e344a98b26ae7cf7162f813af79f 100644
--- a/lib/libc/glibc/locale/bits/types/__locale_t.h
+++ b/lib/libc/glibc/locale/bits/types/__locale_t.h
@@ -1,5 +1,5 @@
 /* Definition of struct __locale_struct and __locale_t.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/locale/bits/types/locale_t.h b/lib/libc/glibc/locale/bits/types/locale_t.h
index fe8864ca6be90926c3bce77ec58d4a1b588dfa81..a825f11fdfa14407462fe399cca89ee0d545341e 100644
--- a/lib/libc/glibc/locale/bits/types/locale_t.h
+++ b/lib/libc/glibc/locale/bits/types/locale_t.h
@@ -1,5 +1,5 @@
 /* Definition of locale_t.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/misc/sys/cdefs.h b/lib/libc/glibc/misc/sys/cdefs.h
index 215ff937ee9c8eb85ebd9412c0ff5a93c6809f3f..8d27f26da8d9e1dc3a702123c5208095624b3166 100644
--- a/lib/libc/glibc/misc/sys/cdefs.h
+++ b/lib/libc/glibc/misc/sys/cdefs.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
@@ -438,10 +438,10 @@
 */
 #endif
 
-/* GCC and clang have various useful declarations that can be made with
-   the '__attribute__' syntax.  All of the ways we use this do fine if
-   they are omitted for compilers that don't understand it.  */
-#if !(defined __GNUC__ || defined __clang__)
+/* GCC, clang, and compatible compilers have various useful declarations
+   that can be made with the '__attribute__' syntax.  All of the ways we use
+   this do fine if they are omitted for compilers that don't understand it.  */
+#if !(defined __GNUC__ || defined __clang__ || defined __TINYC__)
 # define __attribute__(xyz)	/* Ignore */
 #endif
 
@@ -606,14 +606,14 @@
 # define __attribute_artificial__ /* Ignore */
 #endif
 
-/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
-   inline semantics, unless -fgnu89-inline is used.  Using __GNUC_STDC_INLINE__
-   or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions
+/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 inline
+   semantics, unless -fgnu89-inline is used.  Using __GNUC_STDC_INLINE__ or
+   __GNUC_GNU_INLINE__ is not a good enough check for gcc because gcc versions
    older than 4.3 may define these macros and still not guarantee GNU inlining
    semantics.
 
    clang++ identifies itself as gcc-4.2, but has support for GNU inlining
-   semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and
+   semantics, that can be checked for by using the __GNUC_STDC_INLINE__ and
    __GNUC_GNU_INLINE__ macro definitions.  */
 #if (!defined __cplusplus || __GNUC_PREREQ (4,3) \
      || (defined __clang__ && (defined __GNUC_STDC_INLINE__ \
@@ -828,6 +828,18 @@ _Static_assert (0, "IEEE 128-bits long double requires redirection on this platf
 # define __HAVE_GENERIC_SELECTION 0
 #endif
 
+#if __HAVE_GENERIC_SELECTION
+/* If PTR is a pointer to const, return CALL cast to type CTYPE,
+   otherwise return CALL.  Pointers to types with non-const qualifiers
+   are not valid.  This should not be defined for C++, as macros are
+   not an appropriate way of implementing such qualifier-generic
+   operations for C++.  */
+# define __glibc_const_generic(PTR, CTYPE, CALL)	\
+  _Generic (0 ? (PTR) : (void *) 1,			\
+	    const void *: (CTYPE) (CALL),		\
+	    default: CALL)
+#endif
+
 #if __GNUC_PREREQ (10, 0)
 /* Designates a 1-based positional argument ref-index of pointer type
    that can be used to access size-index elements of the pointed-to
diff --git a/lib/libc/glibc/misc/sys/select.h b/lib/libc/glibc/misc/sys/select.h
index d2cdc0f1cdb82f16c61d85cb766ad83d436ceffd..fdc3c89ce61e447715ee441214576d8470dd2e32 100644
--- a/lib/libc/glibc/misc/sys/select.h
+++ b/lib/libc/glibc/misc/sys/select.h
@@ -1,5 +1,5 @@
 /* `fd_set' type and related macros, and `select'/`pselect' declarations.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/posix/bits/cpu-set.h b/lib/libc/glibc/posix/bits/cpu-set.h
index 9dc2d31fa7c3e0bf054f88888cce8e73adac77d2..ddb79cefc2e5d93003f8da84eca6302f99153a22 100644
--- a/lib/libc/glibc/posix/bits/cpu-set.h
+++ b/lib/libc/glibc/posix/bits/cpu-set.h
@@ -1,6 +1,6 @@
 /* Definition of the cpu_set_t structure used by the POSIX 1003.1b-1993
    scheduling interface.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/posix/bits/types.h b/lib/libc/glibc/posix/bits/types.h
index a6638467c8bcda24edde5bdea54d933dbd65feeb..fdef71b4c2d613acc12836ad6d6da6a924288cd3 100644
--- a/lib/libc/glibc/posix/bits/types.h
+++ b/lib/libc/glibc/posix/bits/types.h
@@ -1,5 +1,5 @@
 /* bits/types.h -- definitions of __*_t types underlying *_t types.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/posix/sys/types.h b/lib/libc/glibc/posix/sys/types.h
index ab3037a9dab25fdbbe4eccb3875b2a3305c7f342..2b524761748fc2e0576e3b86fd5558e8a9ebcb18 100644
--- a/lib/libc/glibc/posix/sys/types.h
+++ b/lib/libc/glibc/posix/sys/types.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/signal/signal.h b/lib/libc/glibc/signal/signal.h
index 413b4fd23f3947ef9922599b310317e8e7458f3a..0cfcdd62176059908ed838e4599612ad4e3c130d 100644
--- a/lib/libc/glibc/signal/signal.h
+++ b/lib/libc/glibc/signal/signal.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/stdlib/alloca.h b/lib/libc/glibc/stdlib/alloca.h
index ec36f825ad123e1881bf97a22add20ef73be445d..5700dd7123359573c175e98618d029818d7db7ad 100644
--- a/lib/libc/glibc/stdlib/alloca.h
+++ b/lib/libc/glibc/stdlib/alloca.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/stdlib/bits/stdlib-float.h b/lib/libc/glibc/stdlib/bits/stdlib-float.h
index 5f2902949e76d6965e7d85dc5040d70018c47fa1..d75221470b35706514264e3f09908a8e0f729d56 100644
--- a/lib/libc/glibc/stdlib/bits/stdlib-float.h
+++ b/lib/libc/glibc/stdlib/bits/stdlib-float.h
@@ -1,5 +1,5 @@
 /* Floating-point inline functions for stdlib.h.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/stdlib/errno.h b/lib/libc/glibc/stdlib/errno.h
index 64517aa2fb70fd74aa1db1c751c09be884de8de3..f7828f0e6a62b6744b7d1b0a68259380ea68868f 100644
--- a/lib/libc/glibc/stdlib/errno.h
+++ b/lib/libc/glibc/stdlib/errno.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/stdlib/exit.h b/lib/libc/glibc/stdlib/exit.h
index bbe80292e4354bdc0df2bdd265274725d06da792..841f64f2d323419f8e89a52276a875228ed6d801 100644
--- a/lib/libc/glibc/stdlib/exit.h
+++ b/lib/libc/glibc/stdlib/exit.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/stdlib/stdlib.h b/lib/libc/glibc/stdlib/stdlib.h
index cd4503c761887324ddda8f0fd630e99c2bff196d..1c67d8e13f348e55e9ef82059213bb1b7a02f734 100644
--- a/lib/libc/glibc/stdlib/stdlib.h
+++ b/lib/libc/glibc/stdlib/stdlib.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    Copyright The GNU Toolchain Authors.
    This file is part of the GNU C Library.
 
@@ -35,6 +35,10 @@ __BEGIN_DECLS
 
 #define	_STDLIB_H	1
 
+#if __GLIBC_USE (ISOC23)
+# define __STDC_VERSION_STDLIB_H__ 202311L
+#endif
+
 #if (defined __USE_XOPEN || defined __USE_XOPEN2K8) && !defined _SYS_WAIT_H
 /* XPG requires a few symbols from <sys/wait.h> being defined.  */
 # include <bits/waitflags.h>
@@ -686,6 +690,24 @@ extern void *realloc (void *__ptr, size_t __size)
 /* Free a block allocated by `malloc', `realloc' or `calloc'.  */
 extern void free (void *__ptr) __THROW;
 
+#if __GLIBC_USE(ISOC23)
+/* Free a block allocated by `malloc', `realloc' or `calloc' but not
+   `aligned_alloc', `memalign', `posix_memalign', `valloc' or
+   `pvalloc'. SIZE must be equal to the original requested size
+   provided to `malloc', `realloc' or `calloc'. For `calloc' SIZE is
+   NMEMB elements * SIZE bytes. It is forbidden to call `free_sized'
+   for allocations which the caller did not directly allocate but
+   must still deallocate, such as `strdup' or `strndup'. Instead
+   continue using `free` for these cases.  */
+extern void free_sized (void *__ptr, size_t __size) __THROW;
+
+/* Free a block allocated by `aligned_alloc', `memalign' or
+   `posix_memalign'. ALIGNMENT and SIZE must be the same as the values
+   provided to `aligned_alloc', `memalign' or `posix_memalign'.  */
+extern void free_aligned_sized (void *__ptr, size_t __alignment, size_t __size)
+     __THROW;
+#endif
+
 #ifdef __USE_MISC
 /* Re-allocate the previously allocated block in PTR, making the new
    block large enough for NMEMB elements of SIZE bytes each.  */
@@ -965,6 +987,12 @@ extern void *bsearch (const void *__key, const void *__base,
 # include <bits/stdlib-bsearch.h>
 #endif
 
+#if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
+# define bsearch(KEY, BASE, NMEMB, SIZE, COMPAR)			\
+  __glibc_const_generic (BASE, const void *,				\
+			 bsearch (KEY, BASE, NMEMB, SIZE, COMPAR))
+#endif
+
 /* Sort NMEMB elements of BASE, of SIZE bytes each,
    using COMPAR to perform the comparisons.  */
 extern void qsort (void *__base, size_t __nmemb, size_t __size,
@@ -1158,6 +1186,19 @@ extern int getloadavg (double __loadavg[], int __nelem)
 extern int ttyslot (void) __THROW;
 #endif
 
+#if __GLIBC_USE (ISOC23)
+# ifndef __cplusplus
+#  include <bits/types/once_flag.h>
+
+/* Call function __FUNC exactly once, even if invoked from several threads.
+   All calls must be made with the same __FLAGS object.  */
+extern void call_once (once_flag *__flag, void (*__func)(void));
+# endif /* !__cplusplus */
+
+/* Return the alignment of P.  */
+extern size_t memalignment (const void *__p);
+#endif
+
 #include <bits/stdlib-float.h>
 
 /* Define some macros helping to catch buffer overflows.  */
diff --git a/lib/libc/glibc/string/bits/endian.h b/lib/libc/glibc/string/bits/endian.h
index e267b2b5135b330159db993a2531b3908bf1ecd6..d60ddfdc12f6b6e026a823479ebfbe176128ca1d 100644
--- a/lib/libc/glibc/string/bits/endian.h
+++ b/lib/libc/glibc/string/bits/endian.h
@@ -1,5 +1,5 @@
 /* Endian macros for string.h functions
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/string/endian.h b/lib/libc/glibc/string/endian.h
index 6b5d65f967af6babdd68b69c3bc03a05b096a2be..5b732541d3bb806083c882fdd30122fed628c204 100644
--- a/lib/libc/glibc/string/endian.h
+++ b/lib/libc/glibc/string/endian.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/aarch64/nptl/bits/pthreadtypes-arch.h b/lib/libc/glibc/sysdeps/aarch64/nptl/bits/pthreadtypes-arch.h
index c2825603353ee2013726ac0ffd8678523453cafe..4dc5245e0608146758e620a73df1c1bbd378c39a 100644
--- a/lib/libc/glibc/sysdeps/aarch64/nptl/bits/pthreadtypes-arch.h
+++ b/lib/libc/glibc/sysdeps/aarch64/nptl/bits/pthreadtypes-arch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/glibc/sysdeps/aarch64/start.S b/lib/libc/glibc/sysdeps/aarch64/start.S
index 694c338c8be3f6ab642e88f84eeec804d6946580..52a1d3bb83386168ac9ebdacd0e69cb0035b731f 100644
--- a/lib/libc/glibc/sysdeps/aarch64/start.S
+++ b/lib/libc/glibc/sysdeps/aarch64/start.S
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/glibc/sysdeps/aarch64/sysdep.h b/lib/libc/glibc/sysdeps/aarch64/sysdep.h
index f5e28cb2427e0f7ce5e1de749b9f93ca86507131..da4b7f3fd32c4fbd62ce777d1857baeda279dcbb 100644
--- a/lib/libc/glibc/sysdeps/aarch64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/aarch64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/glibc/sysdeps/arc/start.S b/lib/libc/glibc/sysdeps/arc/start.S
index 372dd3e299b604d25bff35616be69074c8084fdc..57fe4a15f9287baf9976ef6c222f86e8cf5608e7 100644
--- a/lib/libc/glibc/sysdeps/arc/start.S
+++ b/lib/libc/glibc/sysdeps/arc/start.S
@@ -1,5 +1,5 @@
 /* Startup code for ARC.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/arc/sysdep.h b/lib/libc/glibc/sysdeps/arc/sysdep.h
index b831b5f79b9bad5ce18bf3d49fcd39f9beb12fa3..1e244b040dff4bc842773e72e5452494ddf74b5b 100644
--- a/lib/libc/glibc/sysdeps/arc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/arc/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for ARC.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/arm/arm-features.h b/lib/libc/glibc/sysdeps/arm/arm-features.h
index 04adcc90a84d275e01f51c022855f6ddc33bd96b..b2504ccebb566718d33f328a390395f226933063 100644
--- a/lib/libc/glibc/sysdeps/arm/arm-features.h
+++ b/lib/libc/glibc/sysdeps/arm/arm-features.h
@@ -1,5 +1,5 @@
 /* Macros to test for CPU features on ARM.  Generic ARM version.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/arm/start.S b/lib/libc/glibc/sysdeps/arm/start.S
index 64eead31d5ed49fe18aa6839105363d995b9c9d1..a7e62b39346d18be9d46f64048b092e7c873b068 100644
--- a/lib/libc/glibc/sysdeps/arm/start.S
+++ b/lib/libc/glibc/sysdeps/arm/start.S
@@ -1,5 +1,5 @@
 /* Startup code for ARM & ELF
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/arm/sysdep.h b/lib/libc/glibc/sysdeps/arm/sysdep.h
index 8e66fa5666e9ff09f0d9c785587e4ad4246fe3e1..7f9d740772e1e527a8ab6112c5392bb99f4180b1 100644
--- a/lib/libc/glibc/sysdeps/arm/sysdep.h
+++ b/lib/libc/glibc/sysdeps/arm/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for ARM.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/csky/abiv2/start.S b/lib/libc/glibc/sysdeps/csky/abiv2/start.S
index ce1d7d56f615860361ffd49dea77f2d6e157e94e..973b79693cca4a7ef9cb1674d3b40ca62a121eff 100644
--- a/lib/libc/glibc/sysdeps/csky/abiv2/start.S
+++ b/lib/libc/glibc/sysdeps/csky/abiv2/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF C-SKY ABIV2.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/csky/sysdep.h b/lib/libc/glibc/sysdeps/csky/sysdep.h
index 8ca062b06ddde8dbaa3eabcf8e30df849a3378ec..a2436632c9fc5fabaea8478fc3f2c55857b045bf 100644
--- a/lib/libc/glibc/sysdeps/csky/sysdep.h
+++ b/lib/libc/glibc/sysdeps/csky/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for C-SKY.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/dl-dtprocnum.h b/lib/libc/glibc/sysdeps/generic/dl-dtprocnum.h
index 8cf83a37256d133802f6f65f175a966dd1011aec..0d3a43d17608fd177965a06da3db47d0aeafc85c 100644
--- a/lib/libc/glibc/sysdeps/generic/dl-dtprocnum.h
+++ b/lib/libc/glibc/sysdeps/generic/dl-dtprocnum.h
@@ -1,5 +1,5 @@
 /* Configuration of lookup functions.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/dl-sysdep.h b/lib/libc/glibc/sysdeps/generic/dl-sysdep.h
index d7a90f23d51dc7898d986d3181ac3eca8b818db1..9aac6e7bc707701cd745ef55498c2f7aa4a6521b 100644
--- a/lib/libc/glibc/sysdeps/generic/dl-sysdep.h
+++ b/lib/libc/glibc/sysdeps/generic/dl-sysdep.h
@@ -1,5 +1,5 @@
 /* System-specific settings for dynamic linker code.  Generic version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/dwarf2.h b/lib/libc/glibc/sysdeps/generic/dwarf2.h
index cdd0f96102b37f5c14dfc88aebbcadcff3236cf4..6dfa3c562c30cc1bea3f49169e6a20ff806f409d 100644
--- a/lib/libc/glibc/sysdeps/generic/dwarf2.h
+++ b/lib/libc/glibc/sysdeps/generic/dwarf2.h
@@ -1,6 +1,6 @@
 /* Declarations and definitions of codes relating to the DWARF2 symbolic
    debugging information format.
-   Copyright (C) 1992-2025 Free Software Foundation, Inc.
+   Copyright (C) 1992-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/glibc/sysdeps/generic/libc-lock.h b/lib/libc/glibc/sysdeps/generic/libc-lock.h
index fafaf8c932560d8cae82a694679a5332c2a211bc..4dbd0bed63fdaf162783aea23256a51a67a4d4da 100644
--- a/lib/libc/glibc/sysdeps/generic/libc-lock.h
+++ b/lib/libc/glibc/sysdeps/generic/libc-lock.h
@@ -1,5 +1,5 @@
 /* libc-internal interface for mutex locks.  Stub version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/libc-symver.h b/lib/libc/glibc/sysdeps/generic/libc-symver.h
index 0725e0c8e3eef21740a9c27011f515a99b6c3272..dd0425117c9ae2a0c1d32d7e5def48240e3e1a36 100644
--- a/lib/libc/glibc/sysdeps/generic/libc-symver.h
+++ b/lib/libc/glibc/sysdeps/generic/libc-symver.h
@@ -1,5 +1,5 @@
 /* Symbol version management.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/single-thread.h b/lib/libc/glibc/sysdeps/generic/single-thread.h
index 6a37563e5f9dcb7b867d9343dec6a5a6cd843e33..3f576308a16ae72b473638dc0eebc62b9535f432 100644
--- a/lib/libc/glibc/sysdeps/generic/single-thread.h
+++ b/lib/libc/glibc/sysdeps/generic/single-thread.h
@@ -1,5 +1,5 @@
 /* Single thread optimization, generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/symbol-hacks.h b/lib/libc/glibc/sysdeps/generic/symbol-hacks.h
index 1115e4c0a7af113e21eefb99fb04ca794470e68a..0d728cce9154781be7848eee706d22d309690b12 100644
--- a/lib/libc/glibc/sysdeps/generic/symbol-hacks.h
+++ b/lib/libc/glibc/sysdeps/generic/symbol-hacks.h
@@ -6,6 +6,22 @@ asm ("memmove = __GI_memmove");
 asm ("memset = __GI_memset");
 asm ("memcpy = __GI_memcpy");
 
+/* clang might generate the internal fortfify calls when it is enabled,
+   through the buitintin.  */
+asm ("__vfprintf_chk = __GI___vfprintf_chk");
+asm ("__vsprintf_chk = __GI___vsprintf_chk");
+asm ("__vsyslog_chk = __GI___vsyslog_chk");
+asm ("__memcpy_chk = __GI___memcpy_chk");
+asm ("__memmove_chk = __GI___memmove_chk");
+asm ("__memset_chk = __GI___memset_chk");
+asm ("__mempcpy_chk = __GI___mempcpy_chk");
+asm ("__stpcpy_chk = __GI___stpcpy_chk");
+asm ("__strcpy_chk = __GI___strcpy_chk");
+asm ("strcpy = __GI_strcpy");
+asm ("strncpy = __GI_strncpy");
+asm ("strcat = __GI_strcat");
+asm ("strlen = __GI_strlen");
+
 /* Some targets do not use __stack_chk_fail_local.  In libc.so,
    redirect __stack_chk_fail to a hidden reference
    __stack_chk_fail_local, to avoid the PLT reference.
diff --git a/lib/libc/glibc/sysdeps/generic/sysdep.h b/lib/libc/glibc/sysdeps/generic/sysdep.h
index ef5eba2c87f513ca6083c0dfde8558a25dde6fc2..fb07f6747cd736a1f55d26ed0d102c972cd0418d 100644
--- a/lib/libc/glibc/sysdeps/generic/sysdep.h
+++ b/lib/libc/glibc/sysdeps/generic/sysdep.h
@@ -1,5 +1,5 @@
 /* Generic asm macros used on many machines.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/generic/tls.h b/lib/libc/glibc/sysdeps/generic/tls.h
index f6155b5ba67bb74cbecda2c13b9a467b999ae8f1..a569d074cabb04c45ec845098897795501e545a2 100644
--- a/lib/libc/glibc/sysdeps/generic/tls.h
+++ b/lib/libc/glibc/sysdeps/generic/tls.h
@@ -1,5 +1,5 @@
 /* Definition for thread-local data handling.  Generic version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/htl/bits/pthread.h b/lib/libc/glibc/sysdeps/htl/bits/pthread.h
index c0ec3932ae688000e56050a6ed262f0e85437b64..2209c51e016d02cfef4997c82c11b5a8376718ed 100644
--- a/lib/libc/glibc/sysdeps/htl/bits/pthread.h
+++ b/lib/libc/glibc/sysdeps/htl/bits/pthread.h
@@ -1,5 +1,5 @@
 /* Pthread data structures.  Generic version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/htl/bits/thread-shared-types.h b/lib/libc/glibc/sysdeps/htl/bits/thread-shared-types.h
index 32a545014ce8e6736cbfafe5d408567082cd20de..52a01426b02ea17521b7d0f02a1712664f746782 100644
--- a/lib/libc/glibc/sysdeps/htl/bits/thread-shared-types.h
+++ b/lib/libc/glibc/sysdeps/htl/bits/thread-shared-types.h
@@ -1,5 +1,5 @@
 /* Common threading primitives definitions for both POSIX and C11.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/htl/libc-lockP.h b/lib/libc/glibc/sysdeps/htl/libc-lockP.h
index e9977e46a1a9973fc78e6b7858636fb202acf97d..a88eea4344004d7bcacdcd6bb827547ab9a41026 100644
--- a/lib/libc/glibc/sysdeps/htl/libc-lockP.h
+++ b/lib/libc/glibc/sysdeps/htl/libc-lockP.h
@@ -1,5 +1,5 @@
 /* Private libc-internal interface for mutex locks.
-   Copyright (C) 2015-2025 Free Software Foundation, Inc.
+   Copyright (C) 2015-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -20,7 +20,6 @@
 #define _BITS_LIBC_LOCKP_H 1
 
 #include <pthread.h>
-#include <pthread-functions.h>
 
 /* If we check for a weakly referenced symbol and then perform a
    normal jump to it te code generated for some platforms in case of
@@ -36,40 +35,6 @@
   (FUNC != NULL ? FUNC ARGS : ELSE)
 #endif
 
-/* Call thread functions through the function pointer table.  */
-#if defined SHARED && IS_IN (libc)
-# define PTFAVAIL(NAME) __libc_pthread_functions_init
-# define __libc_ptf_call(FUNC, ARGS, ELSE) \
-  (__libc_pthread_functions_init ? PTHFCT_CALL (ptr_##FUNC, ARGS) : ELSE)
-# define __libc_ptf_call_always(FUNC, ARGS) \
-  PTHFCT_CALL (ptr_##FUNC, ARGS)
-#elif IS_IN (libpthread)
-# define PTFAVAIL(NAME) 1
-# define __libc_ptf_call(FUNC, ARGS, ELSE) \
-  FUNC ARGS
-# define __libc_ptf_call_always(FUNC, ARGS) \
-  FUNC ARGS
-#else
-# define PTFAVAIL(NAME) (NAME != NULL)
-# define __libc_ptf_call(FUNC, ARGS, ELSE) \
-  __libc_maybe_call (FUNC, ARGS, ELSE)
-# define __libc_ptf_call_always(FUNC, ARGS) \
-  FUNC ARGS
-#endif
-
-/* Create thread-specific key.  */
-#define __libc_key_create(KEY, DESTRUCTOR) \
-  __libc_ptf_call (__pthread_key_create, (KEY, DESTRUCTOR), 1)
-
-/* Get thread-specific data.  */
-#define __libc_getspecific(KEY) \
-  __libc_ptf_call (__pthread_getspecific, (KEY), NULL)
-
-/* Set thread-specific data.  */
-#define __libc_setspecific(KEY, VALUE) \
-  __libc_ptf_call (__pthread_setspecific, (KEY, VALUE), 0)
-
-
 /* Functions that are used by this file and are internal to the GNU C
    library.  */
 
diff --git a/lib/libc/glibc/sysdeps/htl/pthread.h b/lib/libc/glibc/sysdeps/htl/pthread.h
index a299fec2783ee8250cb82343e1094d221c3c743f..0db8fef7c33a0e319693bf3713082fb57e78bed6 100644
--- a/lib/libc/glibc/sysdeps/htl/pthread.h
+++ b/lib/libc/glibc/sysdeps/htl/pthread.h
@@ -1,5 +1,5 @@
 /* Posix threads.  Hurd version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/i386/htl/bits/pthreadtypes-arch.h b/lib/libc/glibc/sysdeps/i386/htl/bits/pthreadtypes-arch.h
index 4aed38fc63a004fb14a9059e99f7dc07355320ba..44c051fc48e489d65849a0f88bcf220f447a0cf5 100644
--- a/lib/libc/glibc/sysdeps/i386/htl/bits/pthreadtypes-arch.h
+++ b/lib/libc/glibc/sysdeps/i386/htl/bits/pthreadtypes-arch.h
@@ -1,5 +1,5 @@
 /* Machine-specific pthread type layouts.  Hurd i386 version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/i386/start.S b/lib/libc/glibc/sysdeps/i386/start.S
index 01f8098b58eff02ec5f68504aac2c9cb0f7b840f..135fb06527957a69d607715de3b81f760b2627de 100644
--- a/lib/libc/glibc/sysdeps/i386/start.S
+++ b/lib/libc/glibc/sysdeps/i386/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF i386 ABI.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/i386/symbol-hacks.h b/lib/libc/glibc/sysdeps/i386/symbol-hacks.h
index f263d736a69584bb64d426030071be70bb2c3ed9..da59cb8928eee5efa4de2fe1f23de6486fbbe066 100644
--- a/lib/libc/glibc/sysdeps/i386/symbol-hacks.h
+++ b/lib/libc/glibc/sysdeps/i386/symbol-hacks.h
@@ -1,5 +1,5 @@
 /* Hacks needed for symbol manipulation.  i386 version.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/i386/sysdep.h b/lib/libc/glibc/sysdeps/i386/sysdep.h
index 3aefe7af1e5713e232cd5c2d1633ed78c176d955..d01115d0d6dd4aad4e86c45849f61972d0acb6c7 100644
--- a/lib/libc/glibc/sysdeps/i386/sysdep.h
+++ b/lib/libc/glibc/sysdeps/i386/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for i386.
-   Copyright (C) 1991-2025 Free Software Foundation, Inc.
+   Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/loongarch/start.S b/lib/libc/glibc/sysdeps/loongarch/start.S
index 754c08dc1f9d30bc3338c52a8b5bc561391f9fd2..72452f5307ef430c06fd5852190c68d5f1295366 100644
--- a/lib/libc/glibc/sysdeps/loongarch/start.S
+++ b/lib/libc/glibc/sysdeps/loongarch/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF LoongArch ABI.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/loongarch/sys/regdef.h b/lib/libc/glibc/sysdeps/loongarch/sys/regdef.h
index c65a2c46620a2cf13b4cb40c9fc1c8a176e54d2d..49ac57477a82b7b8199300502203fd9b4c79d20b 100644
--- a/lib/libc/glibc/sysdeps/loongarch/sys/regdef.h
+++ b/lib/libc/glibc/sysdeps/loongarch/sys/regdef.h
@@ -1,5 +1,5 @@
 /* Register Macro definitions
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
 
diff --git a/lib/libc/glibc/sysdeps/m68k/coldfire/sysdep.h b/lib/libc/glibc/sysdeps/m68k/coldfire/sysdep.h
index 563a67266e632d038d2f6010c25787a4d47132cf..353112cc3ff9cf9e2bace8643cd85ade7a81bd3a 100644
--- a/lib/libc/glibc/sysdeps/m68k/coldfire/sysdep.h
+++ b/lib/libc/glibc/sysdeps/m68k/coldfire/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for Coldfire.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/m68k/m680x0/sysdep.h b/lib/libc/glibc/sysdeps/m68k/m680x0/sysdep.h
index 7faceb35dc002c7bc526217e1bb520f5cffb98b3..2139eccce2e450b9ee624d81c12ca7316863a15f 100644
--- a/lib/libc/glibc/sysdeps/m68k/m680x0/sysdep.h
+++ b/lib/libc/glibc/sysdeps/m68k/m680x0/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for m680x0.
-   Copyright (C) 2010-2025 Free Software Foundation, Inc.
+   Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/m68k/nptl/bits/pthreadtypes-arch.h b/lib/libc/glibc/sysdeps/m68k/nptl/bits/pthreadtypes-arch.h
index 56beb0ed19e505f7c693ad4ddb0900f1708cc335..bda8c53eef44d97dfbd4eba3357d38731eb086b8 100644
--- a/lib/libc/glibc/sysdeps/m68k/nptl/bits/pthreadtypes-arch.h
+++ b/lib/libc/glibc/sysdeps/m68k/nptl/bits/pthreadtypes-arch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/m68k/start.S b/lib/libc/glibc/sysdeps/m68k/start.S
index 9b2ea124bab436d34ae30f4630737b9134ca04bc..b091caea4a07780615bfbabe7e60738d5387ec60 100644
--- a/lib/libc/glibc/sysdeps/m68k/start.S
+++ b/lib/libc/glibc/sysdeps/m68k/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF m68k ABI.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/m68k/symbol-hacks.h b/lib/libc/glibc/sysdeps/m68k/symbol-hacks.h
index d9c1f96c2ee8f8e24ef65d5c51a0ac814d1c2b61..d072b08425b515a677a29063d27f3f55cd1e9951 100644
--- a/lib/libc/glibc/sysdeps/m68k/symbol-hacks.h
+++ b/lib/libc/glibc/sysdeps/m68k/symbol-hacks.h
@@ -1,5 +1,5 @@
 /* Hacks needed for symbol manipulation.  m68k version.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/m68k/sysdep.h b/lib/libc/glibc/sysdeps/m68k/sysdep.h
index 26448d26c59401f063b270514a06c1421ea79966..0851d0bc5eeaa2178aee557d1e3a2aa6f470e369 100644
--- a/lib/libc/glibc/sysdeps/m68k/sysdep.h
+++ b/lib/libc/glibc/sysdeps/m68k/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for m68k.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/mach/libc-lock.h b/lib/libc/glibc/sysdeps/mach/libc-lock.h
index 41fd1c6b8513ec87488f4e5d6b6dd16de313a338..236a24ad807ea292bb25258d64ffb5658f5ddcf5 100644
--- a/lib/libc/glibc/sysdeps/mach/libc-lock.h
+++ b/lib/libc/glibc/sysdeps/mach/libc-lock.h
@@ -1,5 +1,5 @@
 /* libc-internal interface for mutex locks.  Mach cthreads version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/mach/sysdep.h b/lib/libc/glibc/sysdeps/mach/sysdep.h
index 581bdcd54d57296c5b17ee2686e94a451e2548d5..06ca34db55adfa99fc2993e0452d6737256de24b 100644
--- a/lib/libc/glibc/sysdeps/mach/sysdep.h
+++ b/lib/libc/glibc/sysdeps/mach/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1994-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/mips/dl-dtprocnum.h b/lib/libc/glibc/sysdeps/mips/dl-dtprocnum.h
index 801f8b71f16d23703f288dd745e34aa9dc6e2792..caa6240990deab9e43c5ae893b2019e00f11485d 100644
--- a/lib/libc/glibc/sysdeps/mips/dl-dtprocnum.h
+++ b/lib/libc/glibc/sysdeps/mips/dl-dtprocnum.h
@@ -1,5 +1,5 @@
 /* Configuration of lookup functions.  MIPS version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/mips/isarev.h b/lib/libc/glibc/sysdeps/mips/isarev.h
new file mode 100644
index 0000000000000000000000000000000000000000..d3da6a9cb362d3a7e00e6f49c80fe52318b5b324
--- /dev/null
+++ b/lib/libc/glibc/sysdeps/mips/isarev.h
@@ -0,0 +1,8 @@
+#ifndef _ISAREV_H
+#define _ISAREV_H
+
+#ifndef __mips_isa_rev
+# define __mips_isa_rev 0
+#endif
+
+#endif
diff --git a/lib/libc/glibc/sysdeps/mips/nptl/bits/pthreadtypes-arch.h b/lib/libc/glibc/sysdeps/mips/nptl/bits/pthreadtypes-arch.h
index ab3cdfb794fef616dd3456641208b28923e3911f..d6e83254568186e0eb47abd21cfca25face784d2 100644
--- a/lib/libc/glibc/sysdeps/mips/nptl/bits/pthreadtypes-arch.h
+++ b/lib/libc/glibc/sysdeps/mips/nptl/bits/pthreadtypes-arch.h
@@ -1,5 +1,5 @@
 /* Machine-specific pthread type layouts.  MIPS version.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/mips/start.S b/lib/libc/glibc/sysdeps/mips/start.S
index c58915c13446360a3a155e6a1a8ea9e974541052..409154dd22b51f6e9308fd1c7c4ca93adfe8a909 100644
--- a/lib/libc/glibc/sysdeps/mips/start.S
+++ b/lib/libc/glibc/sysdeps/mips/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF Mips ABI.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/nptl/bits/pthreadtypes.h b/lib/libc/glibc/sysdeps/nptl/bits/pthreadtypes.h
index 1afb017bec56186662026f6d1d61b0f0fbdf2f09..6f4c5c41712f84c7ee984f4a93be4b7063b6d419 100644
--- a/lib/libc/glibc/sysdeps/nptl/bits/pthreadtypes.h
+++ b/lib/libc/glibc/sysdeps/nptl/bits/pthreadtypes.h
@@ -1,5 +1,5 @@
 /* Declaration of common pthread types for all architectures.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/nptl/bits/thread-shared-types.h b/lib/libc/glibc/sysdeps/nptl/bits/thread-shared-types.h
index e614c7f3c900eba098d978ed4ce972146ad85338..624d616fdc6bc2fc43b1559ec269a70e5c5b46b6 100644
--- a/lib/libc/glibc/sysdeps/nptl/bits/thread-shared-types.h
+++ b/lib/libc/glibc/sysdeps/nptl/bits/thread-shared-types.h
@@ -1,5 +1,5 @@
 /* Common threading primitives definitions for both POSIX and C11.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -75,7 +75,7 @@ typedef struct __pthread_internal_slist
 
 #include <bits/struct_mutex.h>
 
-/* Arch-sepecific read-write lock definitions.  A generic implementation is
+/* Arch-specific read-write lock definitions.  A generic implementation is
    provided by struct_rwlock.h.  If required, an architecture can override it
    by defining:
 
diff --git a/lib/libc/glibc/sysdeps/nptl/libc-lock.h b/lib/libc/glibc/sysdeps/nptl/libc-lock.h
index 37755479946156a605613be09f4f9de7f9ee1e05..28bc23c36f8edde1666e0596981c9d7ac1b2ca07 100644
--- a/lib/libc/glibc/sysdeps/nptl/libc-lock.h
+++ b/lib/libc/glibc/sysdeps/nptl/libc-lock.h
@@ -1,5 +1,5 @@
 /* libc-internal interface for mutex locks.  NPTL version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/nptl/libc-lockP.h b/lib/libc/glibc/sysdeps/nptl/libc-lockP.h
index 1be3dd1ec17a1df2e6a8730f65b879a06032b9b3..9c45c5ce88a507f58b6803bf379e0b2daec22a7e 100644
--- a/lib/libc/glibc/sysdeps/nptl/libc-lockP.h
+++ b/lib/libc/glibc/sysdeps/nptl/libc-lockP.h
@@ -1,5 +1,5 @@
 /* Private libc-internal interface for mutex locks.  NPTL version.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -90,13 +90,6 @@ _Static_assert (LLL_LOCK_INITIALIZER == 0, "LLL_LOCK_INITIALIZER != 0");
   (FUNC != NULL ? FUNC ARGS : ELSE)
 #endif
 
-/* All previously forwarded functions are now called directly (either
-   via local call in libc, or through a __export), but __libc_ptf_call
-   is still used in generic code shared with Hurd.  */
-#define PTFAVAIL(NAME) 1
-#define __libc_ptf_call(FUNC, ARGS, ELSE) FUNC ARGS
-#define __libc_ptf_call_always(FUNC, ARGS) FUNC ARGS
-
 /* Initialize the named lock variable, leaving it in a consistent, unlocked
    state.  */
 #define __libc_lock_init(NAME) ((void) ((NAME) = LLL_LOCK_INITIALIZER))
diff --git a/lib/libc/glibc/sysdeps/nptl/pthread.h b/lib/libc/glibc/sysdeps/nptl/pthread.h
index 92957a620d9584685dbbd2fb3bf5dc8f050d1041..95c0eb7e0341a4a37ec9df767e80fa7245aee1ef 100644
--- a/lib/libc/glibc/sysdeps/nptl/pthread.h
+++ b/lib/libc/glibc/sysdeps/nptl/pthread.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/powerpc32/start.S b/lib/libc/glibc/sysdeps/powerpc/powerpc32/start.S
index d1a7c548596ad246b42bcd1079d60395f52c6227..7832fbc5c751a084675264690cc2e6c74e846cac 100644
--- a/lib/libc/glibc/sysdeps/powerpc/powerpc32/start.S
+++ b/lib/libc/glibc/sysdeps/powerpc/powerpc32/start.S
@@ -1,5 +1,5 @@
 /* Startup code for programs linked with GNU libc.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/powerpc32/symbol-hacks.h b/lib/libc/glibc/sysdeps/powerpc/powerpc32/symbol-hacks.h
index 898495ac00a81327312e97429f2454f1c32a7c70..1faf282601aaade476ff9bf6cea2d8afe734ccb2 100644
--- a/lib/libc/glibc/sysdeps/powerpc/powerpc32/symbol-hacks.h
+++ b/lib/libc/glibc/sysdeps/powerpc/powerpc32/symbol-hacks.h
@@ -1,5 +1,5 @@
 /* Hacks needed for symbol manipulation.  powerpc version.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/powerpc32/sysdep.h b/lib/libc/glibc/sysdeps/powerpc/powerpc32/sysdep.h
index 863b011764bb56fa33da248f0305efd7a9dcdf4c..ef7b62029d5ceb7fb46a981d618d34e5fb4fd48b 100644
--- a/lib/libc/glibc/sysdeps/powerpc/powerpc32/sysdep.h
+++ b/lib/libc/glibc/sysdeps/powerpc/powerpc32/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembly macros for 32-bit PowerPC.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/powerpc64/dl-dtprocnum.h b/lib/libc/glibc/sysdeps/powerpc/powerpc64/dl-dtprocnum.h
index 452e3b82b5f1d211f0f7824d88167eca6d84f557..842ffcd3cdc89f0d7e2f879c536004350f06ef0e 100644
--- a/lib/libc/glibc/sysdeps/powerpc/powerpc64/dl-dtprocnum.h
+++ b/lib/libc/glibc/sysdeps/powerpc/powerpc64/dl-dtprocnum.h
@@ -1,5 +1,5 @@
 /* Configuration of lookup functions.  PowerPC64 version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/powerpc64/start.S b/lib/libc/glibc/sysdeps/powerpc/powerpc64/start.S
index b9a5205edb40a8dc23110349bd94a769a2df3dc7..14e145b4e9516755b6e635ce91694f2b8ad9e854 100644
--- a/lib/libc/glibc/sysdeps/powerpc/powerpc64/start.S
+++ b/lib/libc/glibc/sysdeps/powerpc/powerpc64/start.S
@@ -1,5 +1,5 @@
 /* Startup code for programs linked with GNU libc.  PowerPC64 version.
-   Copyright (C) 1998-2025 Free Software Foundation, Inc.
+   Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/powerpc64/sysdep.h b/lib/libc/glibc/sysdeps/powerpc/powerpc64/sysdep.h
index f05dae71f6fc496c351901c3b49494bba16f778f..26cccbf26913a0a766f2c6f068c4bc9abc802174 100644
--- a/lib/libc/glibc/sysdeps/powerpc/powerpc64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/powerpc/powerpc64/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembly macros for 64-bit PowerPC.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/powerpc/sysdep.h b/lib/libc/glibc/sysdeps/powerpc/sysdep.h
index 8ce71565b17bc91b5d628864a965720154cdd42d..ebbc2d68cde70c634062f0888db5f25eab4e7688 100644
--- a/lib/libc/glibc/sysdeps/powerpc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/powerpc/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/riscv/nptl/bits/pthreadtypes-arch.h b/lib/libc/glibc/sysdeps/riscv/nptl/bits/pthreadtypes-arch.h
index ec246b4f3f14238099d06230b9dc30aefe7ab3e2..6fe9d1cc1fd1ab011ef9364c9c0eb8bf3e3b6c07 100644
--- a/lib/libc/glibc/sysdeps/riscv/nptl/bits/pthreadtypes-arch.h
+++ b/lib/libc/glibc/sysdeps/riscv/nptl/bits/pthreadtypes-arch.h
@@ -1,5 +1,5 @@
 /* Machine-specific pthread type layouts.  RISC-V version.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/riscv/start.S b/lib/libc/glibc/sysdeps/riscv/start.S
index 2db79c0ae6f2481ce7727fa406690a5545b48752..bc3bc04219e820d3a2bf38bcb053fc5435f94055 100644
--- a/lib/libc/glibc/sysdeps/riscv/start.S
+++ b/lib/libc/glibc/sysdeps/riscv/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF RISC-V ABI.
-   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+   Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/s390/s390-64/start.S b/lib/libc/glibc/sysdeps/s390/s390-64/start.S
index ab40519307ac60a884fa679315b656b75092bf62..b555503811657b26de5fef1ea9d1feaaea66e359 100644
--- a/lib/libc/glibc/sysdeps/s390/s390-64/start.S
+++ b/lib/libc/glibc/sysdeps/s390/s390-64/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the 64 bit S/390 ELF ABI.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/s390/s390-64/sysdep.h b/lib/libc/glibc/sysdeps/s390/s390-64/sysdep.h
index cb5e432fc5ff927220efe5b891a980df04012950..18ed5f1b039fe6555493d8e230918bf24a41a2bb 100644
--- a/lib/libc/glibc/sysdeps/s390/s390-64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/s390/s390-64/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for 64 bit S/390.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/sparc/dl-dtprocnum.h b/lib/libc/glibc/sysdeps/sparc/dl-dtprocnum.h
index fca73324af4b346f2bbec1fed1b427f88fe173d5..2e573d8915264733cff80b28307fcedfa246ac38 100644
--- a/lib/libc/glibc/sysdeps/sparc/dl-dtprocnum.h
+++ b/lib/libc/glibc/sysdeps/sparc/dl-dtprocnum.h
@@ -1,5 +1,5 @@
 /* Configuration of lookup functions.  SPARC version.
-   Copyright (C) 2000-2025 Free Software Foundation, Inc.
+   Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/sparc/sparc32/start.S b/lib/libc/glibc/sysdeps/sparc/sparc32/start.S
index 8393760da684d4f333090d2dfb2aecbe8a8e87e9..89be42dcb059979bb88d0666e99b11a8aa45a7ce 100644
--- a/lib/libc/glibc/sysdeps/sparc/sparc32/start.S
+++ b/lib/libc/glibc/sysdeps/sparc/sparc32/start.S
@@ -1,5 +1,5 @@
 /* Startup code for elf32-sparc
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/sparc/sparc64/start.S b/lib/libc/glibc/sysdeps/sparc/sparc64/start.S
index 08e1e77210540cdac66493c22fe9b3c6859c9cd1..5e85fa8aa4b068f378f1a2c3425e20f424bf4e02 100644
--- a/lib/libc/glibc/sysdeps/sparc/sparc64/start.S
+++ b/lib/libc/glibc/sysdeps/sparc/sparc64/start.S
@@ -1,5 +1,5 @@
 /* Startup code for elf64-sparc
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/sparc/sysdep.h b/lib/libc/glibc/sysdeps/sparc/sysdep.h
index 8381b0570de4d0fa7668b2b49b35ebed62cf729d..bac213b470045c74332e6bf9f01913b303ef1d96 100644
--- a/lib/libc/glibc/sysdeps/sparc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/sparc/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2011-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/arm/sysdep.h b/lib/libc/glibc/sysdeps/unix/arm/sysdep.h
index 814d16fbade9f15cdf1f37dc25dea0c083b25459..96614a5df972cfd4171e60a2645f972d2f407903 100644
--- a/lib/libc/glibc/sysdeps/unix/arm/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/arm/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/i386/sysdep.h b/lib/libc/glibc/sysdeps/unix/i386/sysdep.h
index e58f841f8bd6726045cffa71802e5169e6391fed..8a9d35ef080b4cf88b4b498379326b78b8f9f236 100644
--- a/lib/libc/glibc/sysdeps/unix/i386/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/i386/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/mips/mips32/sysdep.h b/lib/libc/glibc/sysdeps/unix/mips/mips32/sysdep.h
index e09e4be5b091de5dbae6592beec7c764e3a305ed..4ea03efb4a9b9c4d581e70bf20d7cc214139a3c3 100644
--- a/lib/libc/glibc/sysdeps/unix/mips/mips32/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/mips/mips32/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/mips/mips64/sysdep.h b/lib/libc/glibc/sysdeps/unix/mips/mips64/sysdep.h
index 206569357ab48981b6e578e67205b7f58124ca32..1304a1752df1f3f15b361c531e2da13ed60e6e30 100644
--- a/lib/libc/glibc/sysdeps/unix/mips/mips64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/mips/mips64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/mips/sysdep.h b/lib/libc/glibc/sysdeps/unix/mips/sysdep.h
index bb2794bd71ac8dbb34aeecabe2fb6e8c797fa938..6ff6da13d198b4ebb891ac41cab58a74412e25b3 100644
--- a/lib/libc/glibc/sysdeps/unix/mips/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/mips/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -15,12 +15,10 @@
    License along with the GNU C Library.  If not, see
    <https://www.gnu.org/licenses/>.  */
 
+#include <isarev.h>
 #include <sgidefs.h>
 #include <sysdeps/unix/sysdep.h>
 
-#ifndef __mips_isa_rev
-# define __mips_isa_rev 0
-#endif
 
 #ifdef __ASSEMBLER__
 
diff --git a/lib/libc/glibc/sysdeps/unix/powerpc/sysdep.h b/lib/libc/glibc/sysdeps/unix/powerpc/sysdep.h
index a58083487243e43b4601e03ba43299f0adda4bdf..0eacbdce1fdba57c81ac716e62ad4de73b94b023 100644
--- a/lib/libc/glibc/sysdeps/unix/powerpc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/powerpc/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sh/sysdep.h b/lib/libc/glibc/sysdeps/unix/sh/sysdep.h
index 28cb75ba1a673561ce9c0cd191db472af2cb9683..9c05baa7ac6212c3b52342d10c45e339b9e21298 100644
--- a/lib/libc/glibc/sysdeps/unix/sh/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sh/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysdep.h
index 2cc98725c386f2f00e46cdca66a80d4a4beebb57..a6ce5348ec30dd4a9d73784fb2827bc496526059 100644
--- a/lib/libc/glibc/sysdeps/unix/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -138,7 +138,7 @@
 #include <syscall_types.h>
 
 /* Adjust both the __syscall_cancel and the SYSCALL_CANCEL macro to support
-   7 arguments instead of default 6 (curently only mip32).  It avoid add
+   7 arguments instead of default 6 (currently only mip32).  It avoid add
    the requirement to each architecture to support 7 argument macros
    {INTERNAL,INLINE}_SYSCALL.  */
 #ifdef HAVE_CANCELABLE_SYSCALL_WITH_7_ARGS
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/kernel-features.h
index 8cdd6ed112f06ad93d8b2372b1b24cc47b56330e..fee03ac76bf17b3970b4655c8ddd23bf779f5c37 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  AArch64 version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sys/elf.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sys/elf.h
index 7ccf9a2588fedea03ef2c9dc0278ff10b7330303..354928e0e1ffc2c88bce82630d9e983bbbc04f64 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sys/elf.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sysdep.h
index f0e8d64eefac3581108d93a96fc60941aec00dc1..16f5a917b37d67299a8515eeee410b3c925f9129 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/aarch64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2005-2026 Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
 
@@ -150,6 +150,19 @@
     mov x8, SYS_ify (syscall_name);		\
     svc 0
 
+/* Clear ZA state of SME (ASM version).  */
+/* The __libc_arm_za_disable function has special calling convention
+   that allows to call it without stack manipulation and preserving
+   most of the registers.  */
+	.macro CALL_LIBC_ARM_ZA_DISABLE
+	cfi_remember_state
+	mov		x13, x30
+	cfi_register(x30, x13)
+	bl		__libc_arm_za_disable
+	mov		x30, x13
+	cfi_restore_state
+	.endm
+
 #else /* not __ASSEMBLER__ */
 
 # define VDSO_NAME  "LINUX_2.6.39"
@@ -230,6 +243,32 @@
 #undef HAVE_INTERNAL_BRK_ADDR_SYMBOL
 #define HAVE_INTERNAL_BRK_ADDR_SYMBOL 1
 
+/* Clear ZA state of SME (C version).  */
+/* The __libc_arm_za_disable function has special calling convention
+   that allows to call it without stack manipulation and preserving
+   most of the registers.  */
+#define CALL_LIBC_ARM_ZA_DISABLE()			\
+({							\
+  unsigned long int __tmp;				\
+  asm volatile (					\
+  "	.cfi_remember_state\n"			\
+  "	mov		%0, x30\n"			\
+  "	.cfi_register x30, %0\n"      \
+  "	bl		__libc_arm_za_disable\n"	\
+  "	mov		x30, %0\n"			\
+  "	.cfi_restore_state\n"			\
+  : "=r" (__tmp)					\
+  :							\
+  : "x14", "x15", "x16", "x17", "x18", "memory" );	\
+})
+
+/* Do clear ZA state of SME before making normal clone syscall.  */
+#define INLINE_CLONE_SYSCALL(a0, a1, a2, a3, a4)	\
+({							\
+  CALL_LIBC_ARM_ZA_DISABLE ();				\
+  INLINE_SYSCALL_CALL (clone, a0, a1, a2, a3, a4);	\
+})
+
 #endif	/* __ASSEMBLER__ */
 
 #endif /* linux/aarch64/sysdep.h */
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/arc/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/arc/sysdep.h
index 06e31404ec0d157da77561dcb0f538088dc05ab9..90cea3f840f177da4e2ec9aa7ff09211c1ee12c5 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/arc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/arc/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for ARC.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/kernel-features.h
index 10caae8b9155b0422b076485e53a517e8106e446..d169bf58946aa365ceca5502d9861bda13954c4a 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.
-   Copyright (C) 2006-2025 Free Software Foundation, Inc.
+   Copyright (C) 2006-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sys/elf.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sys/elf.h
index 9acb39e5ea07416d85576ead7b07e9574aad45c7..779f7c4e092dd8d2a5a6424302af37d6c95edc58 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sys/elf.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sysdep.h
index 6a477068ba1b7ab0bb5fd9ac6d24b6dd3cf2d240..e45b8acac27d262add3e98804ce9569c7b0b0577 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/arm/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/stat.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/stat.h
index e42a3058297a9b9f1660e2100270b129d680b35a..a68992929102b2a26134cbd3f57b61daeb1b6525 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/stat.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/stat.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/timex.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/timex.h
index 56ba6c25bfbc85dd2e3009868f08febaf4765da3..f32cf2b1c0823cbfc8382406c7c81d14252a10ff 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/timex.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/bits/timex.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/kernel_stat.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/kernel_stat.h
index f39c7c1decfe368da7cf9bbc2e3b3080ff9b1d14..be7a2feffffe98c73789b4186d4267c10c0aca27 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/kernel_stat.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/kernel_stat.h
@@ -1,5 +1,5 @@
 /* Internal definitions for stat functions.  Linux/csky.
-   Copyright (C) 2011-2025 Free Software Foundation, Inc.
+   Copyright (C) 2011-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/sysdep.h
index 6ef105d3301ba0ff98f58a2bdbaf5a6f61675b46..305474b873aeff51dd9384b28ebbffb9e11cf383 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/csky/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembly macros for C-SKY.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/dl-sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/dl-sysdep.h
index 6381243a489e7b5b45388b9488cb3575a0f8e0e9..32f17cc221eef1643a4f066fae8c299988021e8f 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/dl-sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/dl-sysdep.h
@@ -1,5 +1,5 @@
 /* System-specific settings for dynamic linker code.  Linux version.
-   Copyright (C) 2005-2025 Free Software Foundation, Inc.
+   Copyright (C) 2005-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat.c
index 0df9da322290ad2d3978e69d2aa05d9fe8f855ba..0c5b1357a5c64683e2756510767d2bcbf74b6e1c 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat64.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat64.c
index 8da9be35e42fb0af8d6b0dadae87e19e9564f41a..b48d5ca66f0f35deb316a36b6205b52c2eae3dc7 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat64.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstat64.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat.c
index f7c13dba0c3edfb92730a35e54d92c6f5a40126f..893958a3f4de27a6bb0cef30a9bd94e6913237a5 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat64.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat64.c
index 0c27744b791313dbdf29928c8bfdcaa9b638e487..0ba58c73498677a144388024258bc60644685e7f 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat64.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/fstatat64.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/dl-sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/dl-sysdep.h
index 60f6d4dc398d232ce8cfec4a2cf0679779e35c27..35f92ed16279a27efd08fbfccde8ff281a132a4c 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/dl-sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/dl-sysdep.h
@@ -1,5 +1,5 @@
 /* System-specific settings for dynamic linker code.  i386 version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/kernel-features.h
index d21e3bae466acc52972fc6684f8fb2e3d3e148fa..e922a501f384c5e0b12e8b889b4717cda64f548a 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  i386 version.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/sysdep.h
index 87806a7a978a9c25062cd5d20b3ee46a2d9b97dc..c6ff0417363c54f68bac79f2d9f57d50137e55e8 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/i386/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/include/sys/timex.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/include/sys/timex.h
index 8af305d4108987c745a6f7737d17fa680f20f28a..0b32ed780915db460fd4b67847aa74d46f653c48 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/include/sys/timex.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/include/sys/timex.h
@@ -1,5 +1,5 @@
 /* Internal declarations for sys/timex.h.
-   Copyright (C) 2014-2025 Free Software Foundation, Inc.
+   Copyright (C) 2014-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel-features.h
index a49a9159cfa7d4496395581e64a2a7ad2d8b99a8..42318b0a6fe51b9f1c6a61ba9b298904c16493d2 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -261,4 +261,9 @@
 # define __ASSUME_FCHMODAT2 0
 #endif
 
+/* The mseal system call was introduced across all architectures in Linux 6.10
+   (although only supported on 64-bit CPUs).  */
+/* zig patch: don't assume kernel version */
+#define __ASSUME_MSEAL 0
+
 #endif /* kernel-features.h */
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel_stat.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel_stat.h
index a861c94a80e6267af9933c4368bec62e2e71e433..db1bb1b7d543b41c9e1b1fdf5b931421de2c0e88 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel_stat.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/kernel_stat.h
@@ -1,5 +1,5 @@
 /* Internal definitions for stat functions.
-   Copyright (C) 2021-2025 Free Software Foundation, Inc.
+   Copyright (C) 2021-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/loongarch/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/loongarch/sysdep.h
index b9835d839158db40826ff44ac5a7c7bf23576c08..ac5b36f8c02218289d06f1f9be3dc40b42952cc1 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/loongarch/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/loongarch/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembly macros for LoongArch.
-   Copyright (C) 2022-2025 Free Software Foundation, Inc.
+   Copyright (C) 2022-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat.c
index 5b441718a479c8afae92db04b2b7b9e20801b775..6f4fd5d63ec385c302a6db43d341bc60dcaaa467 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat64.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat64.c
index 3d70ef8c0049e1b84065dbfb1ca918913482bfd4..490991134312b1b68ab8c471d938e22edd9a8998 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat64.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/lstat64.c
@@ -1,5 +1,5 @@
 /* Get file status.
-   Copyright (C) 1996-2025 Free Software Foundation, Inc.
+   Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/coldfire/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/coldfire/sysdep.h
index 30b182fe1c54c28254c78cb667b8eec0dc7f064d..5b060bc45b664e417ceee4968ede65242ecb7f31 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/coldfire/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/coldfire/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/kernel-features.h
index 3515b20433bfab1ab6326b402cbca2d2860f338b..d66fe16fa8d5eaa79daa5e8dbec27a9756e21a66 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.
-   Copyright (C) 2008-2025 Free Software Foundation, Inc.
+   Copyright (C) 2008-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/m680x0/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/m680x0/sysdep.h
index 02bde90490c3797d35c3976901c20e00deea332a..36b70aa26e71a2e46e766afbfe74c2fb0e70cbd8 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/m680x0/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/m680x0/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/sysdep.h
index 6f6b46e026d33fd46e32dcd3ef179e939d161e14..342b0bfc9091bcec3356c094963ae78e2a42fa1f 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/m68k/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/kernel-features.h
index d86ac9235214632d86b1c576798847ae4303fac2..7790f0d14b58995392f69d30e22899277b444b9b 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h
index 83ccfb08afde878e165e3c1b14f7ce8278712405..4314fc990e251a469cb38d873f7266a3698fb9e3 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips32/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/kstat_cp.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/kstat_cp.h
index 6e8375d54bc8dfd30421c70d9413a65e0974329e..b20a6297883c466dabf9fa64d7388ecfe142b352 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/kstat_cp.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/kstat_cp.h
@@ -1,5 +1,5 @@
 /* Struct stat/stat64 to stat/stat64 conversion for Linux.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h
index 78044d669db84f55542b94008994bb992ee3cb9a..3ee86888d6987e5ff9e0f2149ad5ac2d0e3b8161 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/mips64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/sysdep.h
index 76e121a11f60e127d592df72ba8e62f6773b70c9..6434bd6b8413c29162c2702565f0688af1b15437 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/mips/sysdep.h
@@ -1,5 +1,5 @@
 /* Syscall definitions, Linux MIPS generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/mknodat.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/mknodat.c
index 291b5bc6589c0df04ce71dba024b0ecf34b44407..d6fc150dfd93c72ba79620f88049a0f3d852b4b6 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/mknodat.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/mknodat.c
@@ -1,5 +1,5 @@
 /* Create a special or ordinary file.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/kernel-features.h
index 6e5adb97b3d51b99ac8c1485076c16af2f497c47..40538d89099a54c11f92b6c33a4ce802d170857b 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  PowerPC version.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc32/kernel_stat.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc32/kernel_stat.h
index 40b5163ae9a80df11283e7e0024cc1f733ea3c87..6596c5bdb2b8c7b1e334f79d04a27b58cdfce7db 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc32/kernel_stat.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc32/kernel_stat.h
@@ -1,5 +1,5 @@
 /* Definition of `struct stat' used in the kernel.
-   Copyright (C) 1997-2025 Free Software Foundation, Inc.
+   Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h
index 4018c3079e82274f4ba09cb891dad1a31fed3e47..469cca0f18246d24f42982f4b4cfa1099a2dacab 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/sysdep.h
index 929784df553afde644017b486c0580a2f6763291..855a10d7e802dc0eac8fa750df2af4b3de46ba72 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/powerpc/sysdep.h
@@ -1,5 +1,5 @@
 /* Syscall definitions, Linux PowerPC generic version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/kernel-features.h
index dce50835d1ba796859a03027be648788915160bc..32087c0602c11ed7e0328f97570a8c18fb3a7400 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  RISC-V version.
-   Copyright (C) 2018-2025 Free Software Foundation, Inc.
+   Copyright (C) 2018-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/sysdep.h
index 05e0e0523d3f744cd7ec1341afc5126746bc80e8..7f0eb070455a661cd367bf2ed7085918f299288b 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/riscv/sysdep.h
@@ -355,7 +355,14 @@
 	_sys_result;							\
 })
 
+#ifdef __riscv_v
+# define __SYSCALL_CLOBBERS "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", \
+			     "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", \
+			     "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", \
+			     "v30", "v31", "vl", "vtype", "vxrm", "vxsat", "memory"
+#else
 # define __SYSCALL_CLOBBERS "memory"
+#endif
 
 extern long int __syscall_error (long int neg_errno);
 
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/bits/typesizes.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/bits/typesizes.h
index 2bbf72f71d36a179e4ec1940cacd16d660499de7..826a1e425c1a2b3b1ee712643d53284412275bfa 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/bits/typesizes.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Linux/s390 version.
-   Copyright (C) 2003-2025 Free Software Foundation, Inc.
+   Copyright (C) 2003-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/kernel-features.h
index 4d9f2232e0f3cf2d0ad168b59e7e8ae2733eba65..a955c18738ad557e51a261b279eb2e3111870924 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  S/390 version.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
index a282e1222e99e1434e9f2cfffb3aa597e3f811ab..9c9e2a271f57c5ce5d2efef9fc23c36ea55da6ac 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for 64 bit S/390.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sys/elf.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sys/elf.h
index 1e3581b65f64db8be039e5678825df2f03f5131c..4d7b62442d269cfca2eebe56ca03568f133d15e7 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sys/elf.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sysdep.h
index c802980013ca198b17cbe8fd5d505d4a36818734..ee2d92edff1f0ee2fb8e0a25217e35dccbd0ff30 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/s390/sysdep.h
@@ -1,5 +1,5 @@
 /* Syscall definitions, Linux s390 version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/single-thread.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/single-thread.h
index eecaa2dc66a11e3b449eea6f5d45ac4e2e471bd1..449db8503c26fd7dc5733ded89204e5b40869bed 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/single-thread.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/single-thread.h
@@ -1,5 +1,5 @@
 /* Single thread optimization, Linux version.
-   Copyright (C) 2019-2025 Free Software Foundation, Inc.
+   Copyright (C) 2019-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/bits/typesizes.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/bits/typesizes.h
index 97e9641ab7dcebe5449030822d6618ff3ddc47a4..78c87964a2448563051cea5269bc4de2795add77 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/bits/typesizes.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Linux/SPARC version.
-   Copyright (C) 2002-2025 Free Software Foundation, Inc.
+   Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/kernel-features.h
index 24423db127d1ba2b6096bea190296f50b851fdaf..eb293411135b74dba9ff884bafaf8e2b90ea372b 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  SPARC version.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc32/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc32/sysdep.h
index 9ad5192dec21b0aff1e64115224499ec6b7dae84..d687670f47b95eb2b5d143f2c2b0a5b7a65c1e64 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc32/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc32/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/kstat_cp.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/kstat_cp.h
index 8f4f9f85a7b2c6ed7c54f10d1fb0caddaec611c8..324c614fb519b240aa0a53ce7ae07732a0058ecf 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/kstat_cp.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/kstat_cp.h
@@ -1,5 +1,5 @@
 /* Struct kernel_stat64 to stat64.  Linux/SPARC version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/sysdep.h
index 1781dec0d354cd62b37415a3f723f1d68d0a4391..9da3499e8b5ac9163a64e65542ea05ba8ad70038 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sparc64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sysdep.h
index 0051f8b4ca134b34bccf5d1dfb2f2313f1e21863..180ac83db79816fae6cc1b5d52e348b31e510366 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sparc/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat.c
index ce5175b34c2d504dc5e6daa069c18223c02b4eed..8fb0210397720b66fb2600cb10d322a7545676e8 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat64.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat64.c
index 61b6f5e66918ef1968b31ad6ad4ef38c81fd5e56..a21c758bb6015d2f7c1c6a33ed97213c816080bf 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat64.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat64.c
@@ -1,5 +1,5 @@
 /* Get file status.  Linux version.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.c b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.c
index a409f9580cd12c3b0d1305d5a72a71c0dd966237..54239b8efb4d3e09eea5603b6c988eacada831a8 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.c
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.c
@@ -1,5 +1,5 @@
 /* Struct stat/stat64 to stat/stat64 conversion for Linux.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.h
index 7f34f783e2b67cbf9e1795a1288786435745f650..d68b4075801874cc1055d63ab4ec6f452169077a 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/stat_t64_cp.h
@@ -1,5 +1,5 @@
 /* Copy to/from struct stat with and without 64-bit time_t support.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/struct_stat_time64.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/struct_stat_time64.h
index c2efdff3ac3fa266e5d9d2946c774c98c7a434e7..e3b878e1bed056f461ba298336f28e9582a00ed9 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/struct_stat_time64.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/struct_stat_time64.h
@@ -1,5 +1,5 @@
 /* Struct stat with 64-bit time support.
-   Copyright (C) 2020-2025 Free Software Foundation, Inc.
+   Copyright (C) 2020-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/syscall.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/syscall.h
index 781f1780d0d3b6190be07cd6e46886db194e32f9..216f75704e0119dae819a3080ab8dd59fe9a4bd0 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/syscall.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/syscall.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/timex.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/timex.h
index db67ca26a3ede5bebc0680cb6a5e28ae2c38d946..63e6610c9fbc91bc2f619465ec915ce23bbd5512 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/timex.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sys/timex.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/sysdep.h
index 1385082f7bd75a97a7c9a70f8fc707a28e56dddd..8b221c3ade4b0f79055e7a05cdc039e0ebde16e3 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2015-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2015-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/bits/typesizes.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/bits/typesizes.h
index 8ba6e7fa9562f46d74e7e6a4b1d7303dd7a0275e..18336f844f63c896e6615ba6034388a04196125e 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/bits/typesizes.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/bits/typesizes.h
@@ -1,5 +1,5 @@
 /* bits/typesizes.h -- underlying types for *_t.  Linux/x86-64 version.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/sys/elf.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/sys/elf.h
index e8108efe2c08672fa7bb1c2f54c3bd4bee105db5..1ea28eb13fd2ab52fd4d3913b00576cca7eba6e5 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/sys/elf.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86/sys/elf.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1998-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/kernel-features.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/kernel-features.h
index 77781718751198e665810d74d42f542eef508607..8798309651132ecca594b7d0cce031c9daa854af 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/kernel-features.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/kernel-features.h
@@ -1,6 +1,6 @@
 /* Set flags signalling availability of kernel features based on given
    kernel version number.  x86-64 version.
-   Copyright (C) 1999-2025 Free Software Foundation, Inc.
+   Copyright (C) 1999-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/sysdep.h
index 1d175dfb1338e77dd02b77ed168bd7b7c395c807..104acff3a36cd08ba9bb5953703fc7953cf79613 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/x32/sysdep.h b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/x32/sysdep.h
index 707261ade329f5e669e1c28d3bee7f15305d006a..63e8b99be2bc459a7d9c4871250cb94195e1fe36 100644
--- a/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/x32/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/sysv/linux/x86_64/x32/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2012-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/unix/x86_64/sysdep.h b/lib/libc/glibc/sysdeps/unix/x86_64/sysdep.h
index ac789a9d4591fbd22792aac9f83c89dd4510e02e..830dd099136b135d67d3f2d412a9b03ed7251b79 100644
--- a/lib/libc/glibc/sysdeps/unix/x86_64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/unix/x86_64/sysdep.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-2025 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/wordsize-32/divdi3-symbol-hacks.h b/lib/libc/glibc/sysdeps/wordsize-32/divdi3-symbol-hacks.h
index e51d84780aaefbc33842f5b8c8e0c0067d6f3f81..30a007b3010629d1b1ef386a67df5bed78f47508 100644
--- a/lib/libc/glibc/sysdeps/wordsize-32/divdi3-symbol-hacks.h
+++ b/lib/libc/glibc/sysdeps/wordsize-32/divdi3-symbol-hacks.h
@@ -1,5 +1,5 @@
 /* Hacks needed for divdi3 symbol manipulation.
-   Copyright (C) 2004-2025 Free Software Foundation, Inc.
+   Copyright (C) 2004-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/x86/nptl/bits/pthreadtypes-arch.h b/lib/libc/glibc/sysdeps/x86/nptl/bits/pthreadtypes-arch.h
index bcdd76a2ab1ebc0a72e1881615cb6f9f98da8e0e..403ad38344ed8e05f464cf7ffb2644d867742bb6 100644
--- a/lib/libc/glibc/sysdeps/x86/nptl/bits/pthreadtypes-arch.h
+++ b/lib/libc/glibc/sysdeps/x86/nptl/bits/pthreadtypes-arch.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2025 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/x86/sysdep.h b/lib/libc/glibc/sysdeps/x86/sysdep.h
index b8e963b654c4cb6964e2cf8a10f1fe143ea2c2f2..41b040d51bde0073a6c438384ed27acb05394253 100644
--- a/lib/libc/glibc/sysdeps/x86/sysdep.h
+++ b/lib/libc/glibc/sysdeps/x86/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for x86.
-   Copyright (C) 2017-2025 Free Software Foundation, Inc.
+   Copyright (C) 2017-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/x86_64/start.S b/lib/libc/glibc/sysdeps/x86_64/start.S
index 6cb661bf04eb0657cf63dfd5b2085e8281c17421..40d6ed85b54e6318c5880496d0ff2aa4d5ed941a 100644
--- a/lib/libc/glibc/sysdeps/x86_64/start.S
+++ b/lib/libc/glibc/sysdeps/x86_64/start.S
@@ -1,5 +1,5 @@
 /* Startup code compliant to the ELF x86-64 ABI.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/x86_64/sysdep.h b/lib/libc/glibc/sysdeps/x86_64/sysdep.h
index 0356f09379ac8f5ba665f0b4603c752503bf68f8..017540c78bc6628a4303d63aae977af2b3301b23 100644
--- a/lib/libc/glibc/sysdeps/x86_64/sysdep.h
+++ b/lib/libc/glibc/sysdeps/x86_64/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for x86-64.
-   Copyright (C) 2001-2025 Free Software Foundation, Inc.
+   Copyright (C) 2001-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
diff --git a/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h b/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h
index 91beeabf05ee177cdc163ec68b918a1051d15008..fcd5c1803949667f62053480dfa4f2464831df9f 100644
--- a/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h
+++ b/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h
@@ -1,5 +1,5 @@
 /* Assembler macros for x32.
-   Copyright (C) 2012-2025 Free Software Foundation, Inc.
+   Copyright (C) 2012-2026 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
-- 
2.54.0


From b4c86c850d5fa6c0944549cd0209b333f9f6b004 Mon Sep 17 00:00:00 2001
From: jsentity <jsentity@noreply.codeberg.org>
Date: Mon, 26 Jan 2026 11:41:22 +0100
Subject: [PATCH 047/499] Fix std.uefi.protocol.DevicePath.next() and add
 utility function isEnd() (#30887)

Fix for https://codeberg.org/ziglang/zig/issues/30884 and https://codeberg.org/ziglang/zig/issues/30885

Co-authored-by: jsentity <jsentity@noreply.codeberg.org>
Co-committed-by: jsentity <jsentity@noreply.codeberg.org>
---
 lib/std/os/uefi/protocol/device_path.zig | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/lib/std/os/uefi/protocol/device_path.zig b/lib/std/os/uefi/protocol/device_path.zig
index 7fa8090df78cd208dd85ffb015bba0316570c74a..ebd2463be459451a6b9c9b831315cfb1e790a3d7 100644
--- a/lib/std/os/uefi/protocol/device_path.zig
+++ b/lib/std/os/uefi/protocol/device_path.zig
@@ -26,12 +26,10 @@ pub const DevicePath = extern struct {
 
     /// Returns the next DevicePath node in the sequence, if any.
     pub fn next(self: *const DevicePath) ?*const DevicePath {
+        const subtype: uefi.DevicePath.End.Subtype = @enumFromInt(self.subtype);
+        if (self.type == .end and subtype == .end_entire) return null;
         const bytes: [*]const u8 = @ptrCast(self);
-        const next_node: *const DevicePath = @ptrCast(bytes + self.length);
-        if (next_node.type == .end and @as(uefi.DevicePath.End.Subtype, @enumFromInt(next_node.subtype)) == .end_entire)
-            return null;
-
-        return next_node;
+        return @ptrCast(bytes + self.length);
     }
 
     /// Calculates the total length of the device path structure in bytes, including the end of device path node.
-- 
2.54.0


From 1b235540c1d1acdd59aee3c2a8756bc7f0fa55a3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 26 Jan 2026 14:11:45 -0800
Subject: [PATCH 048/499] Revert "Io.Threaded: remove WSA_FLAG_OVERLAPPED from
 socket call"

The stated reason for this commit was cancelation didn't work. On
further review, we know why cancelation didn't work, and recent
enhancements on master branch make it easy to make it work.

Meanwhile, not using overlapped means that multiple threads cannot use
the same open socket handle. I also added line comments to explain the
choice in this revert commit.

This reverts commit fd3657bf8c3a2861e1b35cf36d469d342d853880.

closes #31011
reopens #30865
---
 lib/std/Io/Threaded.zig | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 4d5073f65924d0a4e0cccec01a46557a5b7e7eda..38f6199f464933112ae6987e13852585805e0428 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -11025,7 +11025,11 @@ fn openSocketWsa(
 ) !ws2_32.SOCKET {
     const mode = posixSocketMode(options.mode);
     const protocol = posixProtocol(options.protocol);
-    const flags: u32 = ws2_32.WSA_FLAG_NO_HANDLE_INHERIT;
+    // WSA_FLAG_OVERLAPPED is chosen here because without this different
+    // threads cannot use the same open socket handle.
+    // TODO: the below code needs to use the AlertableSyscall mechanism instead in
+    // order to make cancelation work.
+    const flags: u32 = ws2_32.WSA_FLAG_OVERLAPPED | ws2_32.WSA_FLAG_NO_HANDLE_INHERIT;
     var syscall: Syscall = try .start();
     while (true) {
         const rc = ws2_32.WSASocketW(family, @bitCast(mode), @bitCast(protocol), null, 0, flags);
-- 
2.54.0


From 97986184ca67abdb877bda39707dd129ed6473ae Mon Sep 17 00:00:00 2001
From: Jay Petacat <jay@jayschwa.net>
Date: Sat, 24 Jan 2026 11:49:26 -0700
Subject: [PATCH 049/499] langref: Add table of largest integer types that can
 coerce to floats

Add vertical margin to the `.table-wrapper` class so that there's space
between the table and the test figures. It does not affect any of the
existing tables because the margin collapses with the adjacent `<p>`.
---
 doc/langref.html.in | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 3671047ec0f3e0db8dad982a2e6f07871292e504..e87decdf4a9ab51de65bc8ae0c8d6a8378b47dcd 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -128,6 +128,7 @@
       }
       .table-wrapper {
         width: 100%;
+        margin: 1em auto;
         overflow-x: auto;
       }
 
@@ -3471,6 +3472,42 @@ void do_a_thing(struct Foo *foo) {
       without rounding (i.e. the integer's precision does not exceed the float's significand precision).
       Larger integer types that cannot be safely coerced must be explicitly casted with {#link|@floatFromInt#}.
       </p>
+      <div class="table-wrapper">
+      <table>
+        <thead>
+        <tr>
+          <th scope="col">Float Type</th>
+          <th scope="col">Largest Integer Types</th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr>
+            <th scope="row">{#syntax#}f16{#endsyntax#}</th>
+            <td>{#syntax#}i12{#endsyntax#} and {#syntax#}u11{#endsyntax#}</td>
+        </tr>
+        <tr>
+            <th scope="row">{#syntax#}f32{#endsyntax#}</th>
+            <td>{#syntax#}i25{#endsyntax#} and {#syntax#}u24{#endsyntax#}</td>
+        </tr>
+        <tr>
+            <th scope="row">{#syntax#}f64{#endsyntax#}</th>
+            <td>{#syntax#}i54{#endsyntax#} and {#syntax#}u53{#endsyntax#}</td>
+        </tr>
+        <tr>
+            <th scope="row">{#syntax#}f80{#endsyntax#}</th>
+            <td>{#syntax#}i65{#endsyntax#} and {#syntax#}u64{#endsyntax#}</td>
+        </tr>
+        <tr>
+            <th scope="row">{#syntax#}f128{#endsyntax#}</th>
+            <td>{#syntax#}i114{#endsyntax#} and {#syntax#}u113{#endsyntax#}</td>
+        </tr>
+        <tr>
+            <th scope="row">{#syntax#}c_longdouble{#endsyntax#}</th>
+            <td>Varies by target</td>
+        </tr>
+        </tbody>
+      </table>
+      </div>
       {#code|test_int_to_float_coercion.zig#}
       {#code|test_failed_int_to_float_coercion.zig#}
 
-- 
2.54.0


From 5e9c484745b2a2dd997d1870b70f0303fa8ae2c7 Mon Sep 17 00:00:00 2001
From: Carmen <carmen@dotcarmen.dev>
Date: Sat, 24 Jan 2026 13:00:38 +0100
Subject: [PATCH 050/499] std.Io.Reader.takeStruct: dont assert buffer capacity
 is sizeOf(T)

---
 lib/std/Io/Reader.zig | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig
index 08df1e99bc9d0ad80c254f66b5aab923dc03f66c..a2b70afc67db4edc9c1a3afed0eb0fe79737d471 100644
--- a/lib/std/Io/Reader.zig
+++ b/lib/std/Io/Reader.zig
@@ -1192,8 +1192,6 @@ pub fn peekStructPointer(r: *Reader, comptime T: type) Error!*align(1) T {
     return @ptrCast(try r.peekArray(@sizeOf(T)));
 }
 
-/// Asserts the buffer was initialized with a capacity at least `@sizeOf(T)`.
-///
 /// This function is inline to avoid referencing `std.mem.byteSwapAllFields`
 /// when `endian` is comptime-known and matches the host endianness.
 ///
@@ -1205,7 +1203,8 @@ pub inline fn takeStruct(r: *Reader, comptime T: type, endian: std.builtin.Endia
         .@"struct" => |info| switch (info.layout) {
             .auto => @compileError("ill-defined memory layout"),
             .@"extern" => {
-                var res = (try r.takeStructPointer(T)).*;
+                var res: T = undefined;
+                try r.readSliceAll(std.mem.asBytes(&res));
                 if (native_endian != endian) std.mem.byteSwapAllFields(T, &res);
                 return res;
             },
-- 
2.54.0


From 73ed3510220d387e17d4a4a25837cb982373f12c Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 27 Jan 2026 00:06:18 +0100
Subject: [PATCH 051/499] fix(libzigc): export `mincore`

---
 lib/c/sys/mman.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/c/sys/mman.zig b/lib/c/sys/mman.zig
index 07ce732bba203db6c5314835fadb4f250913e5b0..92de9ad07660f48af93e334b50b0d63c63b27ff3 100644
--- a/lib/c/sys/mman.zig
+++ b/lib/c/sys/mman.zig
@@ -7,6 +7,8 @@ comptime {
         @export(&madviseLinux, .{ .name = "madvise", .linkage = common.linkage, .visibility = common.visibility });
         @export(&madviseLinux, .{ .name = "__madvise", .linkage = common.linkage, .visibility = common.visibility });
 
+        @export(&mincoreLinux, .{ .name = "mincore", .linkage = common.linkage, .visibility = common.visibility });
+
         @export(&mlockLinux, .{ .name = "mlock", .linkage = common.linkage, .visibility = common.visibility });
         @export(&mlockallLinux, .{ .name = "mlockall", .linkage = common.linkage, .visibility = common.visibility });
 
-- 
2.54.0


From 4e3fadd90ea6ddb24b5f98b049ad3374d1db0ab8 Mon Sep 17 00:00:00 2001
From: Brian Orora <brianorora@gmail.com>
Date: Sat, 24 Jan 2026 20:10:45 +0300
Subject: [PATCH 052/499] std.heap.DebugAllocator: fix account
 `total_requested_bytes` on `resizeSmall`

---
 lib/std/heap/debug_allocator.zig | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/std/heap/debug_allocator.zig b/lib/std/heap/debug_allocator.zig
index c5abf6709c8d4d900f2c862b8e1f3110095303a0..3ea4a28f96f97a34292ba1461b56b0dc3903316b 100644
--- a/lib/std/heap/debug_allocator.zig
+++ b/lib/std/heap/debug_allocator.zig
@@ -1010,7 +1010,14 @@ pub fn DebugAllocator(comptime config: Config) type {
             size_class_index: usize,
         ) bool {
             const new_size_class_index: usize = @max(@bitSizeOf(usize) - @clz(new_len - 1), @intFromEnum(alignment));
-            if (!config.safety) return new_size_class_index == size_class_index;
+            if (!config.safety) {
+                if (new_size_class_index != size_class_index) return false;
+                // Still account for total even if safety is off
+                if (config.enable_memory_limit)
+                    self.total_requested_bytes = self.total_requested_bytes - memory.len + new_len;
+                return true;
+            }
+
             const slot_count = slot_counts[size_class_index];
             const memory_addr = @intFromPtr(memory.ptr);
             const page_addr = memory_addr & ~(page_size - 1);
-- 
2.54.0


From 519f1eb3613a95343d4401f0b3643636b1ee721e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 27 Jan 2026 05:23:02 +0100
Subject: [PATCH 053/499] musl: zero fp/lr registers in _start() and clone() on
 hexagon

---
 lib/libc/musl/arch/hexagon/crt_arch.h    | 1 +
 lib/libc/musl/src/thread/hexagon/clone.s | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/lib/libc/musl/arch/hexagon/crt_arch.h b/lib/libc/musl/arch/hexagon/crt_arch.h
index 9f9428cf1927a98bcd5aac0bf8c90cdb87747c73..395b38d158059480f0bf532f5e6440abe58d618f 100644
--- a/lib/libc/musl/arch/hexagon/crt_arch.h
+++ b/lib/libc/musl/arch/hexagon/crt_arch.h
@@ -13,6 +13,7 @@ START ": \n"
 "       r1 = memw(r2)\n"
 "       r1 = add(r2, r1)\n"
 "	r30 = #0			// Signals the end of backtrace\n"
+"	r31 = #0\n"
 "	r0 = r29			// Pointer to argc/argv\n"
 "	r29 = and(r29, #-16)		// Align\n"
 "	memw(r29+#-8) = r29\n"
diff --git a/lib/libc/musl/src/thread/hexagon/clone.s b/lib/libc/musl/src/thread/hexagon/clone.s
index 42aab67a375923b106c51d77a0a617fadbeefce1..b91bda60eb24c11ed318c5385508496de1dd96ab 100644
--- a/lib/libc/musl/src/thread/hexagon/clone.s
+++ b/lib/libc/musl/src/thread/hexagon/clone.s
@@ -29,6 +29,9 @@ __clone:
 	p0 = cmp.eq(r0, #0)
 	if (!p0) dealloc_return
 
+	{ r30 = #0
+	  r31 = #0 }
+
 	{ r0 = r10
 	  callr r11 }
 
-- 
2.54.0


From 951ab1b18bf43cafa8ef0b07892eeaf704551482 Mon Sep 17 00:00:00 2001
From: Pablo Alessandro Santos Hugen <phugen@redhat.com>
Date: Mon, 26 Jan 2026 22:34:52 -0300
Subject: [PATCH 054/499] std.Build.Step.Compile: pass target by pointer to
 isLibC*LibName

---
 lib/std/Build/Step/Compile.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index 941f01dd75549436a497a52b554403d57e78d4b1..8c3bb5c568387cec06411adbb04f8cdd5dfb7e46 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -637,11 +637,11 @@ pub fn dependsOnSystemLibrary(compile: *Compile, name: []const u8) bool {
 
     const target = compile.rootModuleTarget();
 
-    if (std.zig.target.isLibCLibName(target, name)) {
+    if (std.zig.target.isLibCLibName(&target, name)) {
         return is_linking_libc;
     }
 
-    if (std.zig.target.isLibCxxLibName(target, name)) {
+    if (std.zig.target.isLibCxxLibName(&target, name)) {
         return is_linking_libcpp;
     }
 
-- 
2.54.0


From 0af79e7b8c50e80764e9833767967db038e3cbf1 Mon Sep 17 00:00:00 2001
From: Robert Ancell <robert.ancell@gmail.com>
Date: Tue, 27 Jan 2026 05:29:51 +0100
Subject: [PATCH 055/499] std.mem.readVarInt: Fix type name in doc comment
 (#31007)

Code used `ReturnType`, comment used `T` (which is what is used in similar functions).

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31007
Co-authored-by: Robert Ancell <robert.ancell@gmail.com>
Co-committed-by: Robert Ancell <robert.ancell@gmail.com>
---
 lib/std/mem.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 437faa2eb65a983eef21eaf0e90eafe81c147ad8..1b109cdfa030394d732234950248ad43172905cf 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1823,7 +1823,7 @@ test containsAtLeastScalar2 {
 }
 
 /// Reads an integer from memory with size equal to bytes.len.
-/// T specifies the return type, which must be large enough to store
+/// ReturnType specifies the return type, which must be large enough to store
 /// the result.
 pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: Endian) ReturnType {
     assert(@typeInfo(ReturnType).int.bits >= bytes.len * 8);
-- 
2.54.0


From d4d210fb377fdf34dc29dd1bc54d59dd5b94a75e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 24 Jan 2026 17:24:44 +0100
Subject: [PATCH 056/499] std.Build.WebServer: use Io futex operations instead
 of std.Thread.Futex

---
 lib/std/Build/WebServer.zig | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index cb201e991d78a6256426535d0d86cb3517b998bd..28b85bdcd3590357f343ba82d4fdda4b3b4ddac1 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -24,7 +24,7 @@ time_report_update_times: []i64,
 
 build_status: std.atomic.Value(abi.BuildStatus),
 /// When an event occurs which means WebSocket clients should be sent updates, call `notifyUpdate`
-/// to increment this value. Each client thread waits for this increment with `std.Thread.Futex`, so
+/// to increment this value. Each client thread waits for this increment with `Io.futexWaitTimeout`, so
 /// `notifyUpdate` will wake those threads. Updates are sent on a short interval regardless, so it
 /// is recommended to only use `notifyUpdate` for changes which the user should see immediately. For
 /// instance, we do not call `notifyUpdate` when the number of "unique runs" in the fuzzer changes,
@@ -46,7 +46,7 @@ pub const base_clock: Io.Clock = .awake;
 /// Thread-safe. Triggers updates to be sent to connected WebSocket clients; see `update_id`.
 pub fn notifyUpdate(ws: *WebServer) void {
     _ = ws.update_id.rmw(.Add, 1, .release);
-    std.Thread.Futex.wake(&ws.update_id, 16);
+    ws.graph.io.futexWake(u32, &ws.update_id.raw, 16);
 }
 
 pub const Options = struct {
@@ -377,7 +377,18 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
         }
 
         prev_time = start_time;
-        std.Thread.Futex.timedWait(&ws.update_id, start_update_id, std.time.ns_per_ms * default_update_interval_ms) catch {};
+
+        const old_cp = io.swapCancelProtection(.blocked);
+        defer _ = io.swapCancelProtection(old_cp);
+        io.futexWaitTimeout(
+            u32,
+            &ws.update_id.raw,
+            start_update_id,
+            .{ .duration = .{
+                .clock = .awake,
+                .raw = .fromMilliseconds(default_update_interval_ms),
+            } },
+        ) catch |err| switch (err) { error.Canceled => unreachable };
     }
 }
 fn recvWebSocketMessages(ws: *WebServer, sock: *http.Server.WebSocket) void {
-- 
2.54.0


From 2c7d3c8007dcc8e46c91e92e1d2676af87d1fbcc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 24 Jan 2026 17:00:36 +0100
Subject: [PATCH 057/499] std.debug: use debug_io for the futex in
 waitForOtherThreadToFinishPanicking

---
 lib/std/debug.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index d07988d7ec5baaf9ef6b61e83253a82936fc06e5..4cf8cc5dc626128112bc8f190cfadcdf18026299 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -596,8 +596,8 @@ fn waitForOtherThreadToFinishPanicking() void {
         if (builtin.single_threaded) unreachable;
 
         // Sleep forever without hammering the CPU
-        var futex = std.atomic.Value(u32).init(0);
-        while (true) std.Thread.Futex.wait(&futex, 0);
+        var futex: u32 = 0;
+        while (true) std.Options.debug_io.futexWaitUncancelable(u32, &futex, 0);
         unreachable;
     }
 }
-- 
2.54.0


From 5652288e5d86e906e1558a7fdfc26126e96e9d82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 27 Jan 2026 07:05:14 +0100
Subject: [PATCH 058/499] zig fmt

oops
---
 lib/std/Build/WebServer.zig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index 28b85bdcd3590357f343ba82d4fdda4b3b4ddac1..e1536fb8fa8bb2ad6e30a0e2a6fcaeda8d299c64 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -388,7 +388,9 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
                 .clock = .awake,
                 .raw = .fromMilliseconds(default_update_interval_ms),
             } },
-        ) catch |err| switch (err) { error.Canceled => unreachable };
+        ) catch |err| switch (err) {
+            error.Canceled => unreachable,
+        };
     }
 }
 fn recvWebSocketMessages(ws: *WebServer, sock: *http.Server.WebSocket) void {
-- 
2.54.0


From 29b7214027b0c9bddc4c67587ee75b4adcdab4f8 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Mon, 26 Jan 2026 23:55:17 -0800
Subject: [PATCH 059/499] Disentangle from
 `error.CurrentWorkingDirectoryUnlinked`

This error is actually only ever directly returned from `std.posix.getcwd` (and only on POSIX systems, so never on Windows). Its inclusion in almost all of the error sets its currently found in is a leftover from when `std.fs.path.resolve` called `std.process.getCwdAlloc` (https://github.com/ziglang/zig/issues/13613).
---
 lib/std/posix.zig      | 1 +
 lib/std/process.zig    | 7 ++++---
 lib/std/zig/system.zig | 1 -
 src/Compilation.zig    | 3 ---
 src/Sema.zig           | 4 ----
 src/Zcu/PerThread.zig  | 1 -
 6 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index f1f4e279d1726ad4997dc2f2009755887aa3c520..a12182b4065d1ee518bd7c82ac938c4b4e693ea0 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -521,6 +521,7 @@ pub fn getppid() pid_t {
 
 pub const GetCwdError = error{
     NameTooLong,
+    /// Not possible on Windows.
     CurrentWorkingDirectoryUnlinked,
 } || UnexpectedError;
 
diff --git a/lib/std/process.zig b/lib/std/process.zig
index dbf2fbe666311a8a7236630e19f20c4b32d54933..6798bba675b9cbe98da2d8fe438c04a285e5d1f6 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -73,7 +73,10 @@ pub fn getCwd(out_buffer: []u8) GetCwdError![]u8 {
 }
 
 // Same as GetCwdError, minus error.NameTooLong + Allocator.Error
-pub const GetCwdAllocError = Allocator.Error || error{CurrentWorkingDirectoryUnlinked} || posix.UnexpectedError;
+pub const GetCwdAllocError = Allocator.Error || error{
+    /// Not possible on Windows.
+    CurrentWorkingDirectoryUnlinked,
+} || posix.UnexpectedError;
 
 /// Caller must free the returned memory.
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
@@ -342,8 +345,6 @@ pub const SpawnError = error{
     /// Windows-only. `cwd` or `argv` was provided and it was invalid WTF-8.
     /// https://wtf-8.codeberg.page/
     InvalidWtf8,
-    /// Windows-only. `cwd` was provided, but the path did not exist when spawning the child process.
-    CurrentWorkingDirectoryUnlinked,
     /// Windows-only. NUL (U+0000), LF (U+000A), CR (U+000D) are not allowed
     /// within arguments when executing a `.bat`/`.cmd` script.
     /// - NUL/LF signifiies end of arguments, so anything afterwards
diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig
index 0e7d814a71f1f28f424509d481a1106282924bd2..8bb1678e7d0244a0206ab14952fd5dc3d35fe19a 100644
--- a/lib/std/zig/system.zig
+++ b/lib/std/zig/system.zig
@@ -504,7 +504,6 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target {
     if (builtin.os.tag == .linux and result.isBionicLibC() and query.os_tag == null and query.android_api_level == null) {
         result.os.version_range.linux.android = detectAndroidApiLevel(io) catch |err| return switch (err) {
             error.InvalidWtf8,
-            error.CurrentWorkingDirectoryUnlinked,
             error.InvalidBatchScriptArg,
             => unreachable, // Windows-only
             error.ApiLevelQueryFailed => |e| e,
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 85fceebfb88aab25eeedd87946fb7477c2ce09fc..15c1837ec2dfb6a8f23691868b3f414828d4af5e 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1851,7 +1851,6 @@ fn addModuleTableToCacheHash(
 ) error{
     OutOfMemory,
     Unexpected,
-    CurrentWorkingDirectoryUnlinked,
 }!void {
     assert(zcu.module_roots.count() != 0); // module_roots is populated
 
@@ -1919,7 +1918,6 @@ pub const CreateError = error{
     OutOfMemory,
     Canceled,
     Unexpected,
-    CurrentWorkingDirectoryUnlinked,
     /// An error has been stored to `diag`.
     CreateFail,
 };
@@ -2906,7 +2904,6 @@ pub const UpdateError = error{
     OutOfMemory,
     Canceled,
     Unexpected,
-    CurrentWorkingDirectoryUnlinked,
 };
 
 /// Detect changes to source files, perform semantic analysis, and update the output files.
diff --git a/src/Sema.zig b/src/Sema.zig
index 191da7c30dda58400f157c61d5739412cf08b7e0..ea2890ee6a220a0cc013f6735057f8ee27e92ed3 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -13604,10 +13604,6 @@ fn zirEmbedFile(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         error.ImportOutsideModulePath => {
             return sema.fail(block, operand_src, "embed of file outside package path: '{s}'", .{name});
         },
-        error.CurrentWorkingDirectoryUnlinked => {
-            // TODO: this should be some kind of retryable failure, in case the cwd is put back
-            return sema.fail(block, operand_src, "unable to resolve '{s}': working directory has been unlinked", .{name});
-        },
         error.OutOfMemory => |e| return e,
         error.Canceled => |e| return e,
     };
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index d79b66b7c2a6b8b4216fbd372c01e6871f23c830..950a3e5a19f5c08524df7087aa201f54e4f05400 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -2388,7 +2388,6 @@ pub fn embedFile(
     OutOfMemory,
     Canceled,
     ImportOutsideModulePath,
-    CurrentWorkingDirectoryUnlinked,
 }!Zcu.EmbedFile.Index {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
-- 
2.54.0


From 1655a666d5695ac974e107233a90a75eebe5fc2f Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Tue, 13 Jan 2026 02:36:21 -0800
Subject: [PATCH 060/499] windows_resources standalone test: Load a resource
 and check its data

Just a potential way to catch regressions and to ensure the resources actually make it into the binary correctly.
---
 test/standalone/windows_resources/build.zig |  7 ++-
 test/standalone/windows_resources/main.zig  | 48 ++++++++++++++++++++-
 2 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/test/standalone/windows_resources/build.zig b/test/standalone/windows_resources/build.zig
index d3afadb60d5d4a6e16cc3f98f04a45c75c350307..3b140c90f79e650cc9fb4b944ac1452ac9996c97 100644
--- a/test/standalone/windows_resources/build.zig
+++ b/test/standalone/windows_resources/build.zig
@@ -46,7 +46,10 @@ fn add(
         .gnu => .gnu,
     };
 
-    _ = exe.getEmittedBin();
+    const exe_run_step = b.addRunArtifact(exe);
+    exe_run_step.skip_foreign_checks = true;
+    exe_run_step.expectStdErrEqual("");
+    exe_run_step.expectStdOutEqual("");
 
-    test_step.dependOn(&exe.step);
+    test_step.dependOn(&exe_run_step.step);
 }
diff --git a/test/standalone/windows_resources/main.zig b/test/standalone/windows_resources/main.zig
index f92e18124bb86f9b42fa47ec0a8291c7b0d9ad35..9af794103652656d6dd25c2139cfb2b7a45d6a0d 100644
--- a/test/standalone/windows_resources/main.zig
+++ b/test/standalone/windows_resources/main.zig
@@ -1,5 +1,51 @@
 const std = @import("std");
+const builtin = @import("builtin");
+const w = std.os.windows;
 
 pub fn main() !void {
-    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
+    if (builtin.os.tag == .windows) {
+        const name = std.unicode.wtf8ToWtf16LeStringLiteral("FOO");
+        const RT_RCDATA = MAKEINTRESOURCEW(10);
+        const handle = FindResourceW(null, name, RT_RCDATA) orelse {
+            std.debug.print("unable to find resource: {t}\n", .{w.GetLastError()});
+            return error.FailedToLoadResource;
+        };
+        const res = LoadResource(null, handle) orelse {
+            std.debug.print("unable to load resource: {t}\n", .{w.GetLastError()});
+            return error.FailedToLoadResource;
+        };
+        const data_ptr = LockResource(res) orelse {
+            std.debug.print("unable to lock resource: {t}\n", .{w.GetLastError()});
+            return error.FailedToLoadResource;
+        };
+        const size = SizeofResource(null, handle);
+        const data = @as([*]const u8, @ptrCast(data_ptr))[0..size];
+        try std.testing.expectEqualSlices(u8, "foo", data);
+    }
 }
+
+const HRSRC = *opaque {};
+const HGLOBAL = *opaque {};
+fn MAKEINTRESOURCEW(id: u16) [*:0]align(1) const w.WCHAR {
+    return @ptrFromInt(id);
+}
+
+extern "kernel32" fn FindResourceW(
+    hModule: ?w.HMODULE,
+    lpName: [*:0]align(1) const w.WCHAR,
+    lpType: [*:0]align(1) const w.WCHAR,
+) callconv(.winapi) ?HRSRC;
+
+extern "kernel32" fn LoadResource(
+    hModule: ?w.HMODULE,
+    hResInfo: HRSRC,
+) callconv(.winapi) ?HGLOBAL;
+
+extern "kernel32" fn LockResource(
+    hResData: HGLOBAL,
+) callconv(.winapi) ?w.LPVOID;
+
+extern "kernel32" fn SizeofResource(
+    hModule: ?w.HMODULE,
+    hResInfo: HRSRC,
+) callconv(.winapi) w.DWORD;
-- 
2.54.0


From 06cf86abeb3a062c6c3e21f4379c7fea9e6d71b6 Mon Sep 17 00:00:00 2001
From: just_some_entity <entity@jsentity.dev>
Date: Tue, 27 Jan 2026 23:09:51 +0100
Subject: [PATCH 061/499] Fix BootServices.locateHandleLen() (#30877)

Fixes https://codeberg.org/ziglang/zig/issues/30876

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30877
Reviewed-by: linus <mail@linusgroh.de>
Co-authored-by: just_some_entity <entity@jsentity.dev>
Co-committed-by: just_some_entity <entity@jsentity.dev>
---
 lib/std/os/uefi/tables/boot_services.zig | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/lib/std/os/uefi/tables/boot_services.zig b/lib/std/os/uefi/tables/boot_services.zig
index f2a8b73b832ad0cbb9b1e952e8221129c1ac20d3..506961315dcf2a001b7914072b441a9d8c9c816f 100644
--- a/lib/std/os/uefi/tables/boot_services.zig
+++ b/lib/std/os/uefi/tables/boot_services.zig
@@ -235,9 +235,7 @@ pub const BootServices = extern struct {
         InvalidParameter,
     };
 
-    pub const NumHandlesError = uefi.UnexpectedError || error{
-        OutOfResources,
-    };
+    pub const NumHandlesError = uefi.UnexpectedError;
 
     pub const LocateHandleError = uefi.UnexpectedError || error{
         BufferTooSmall,
@@ -702,8 +700,17 @@ pub const BootServices = extern struct {
             &len,
             null,
         )) {
-            .success => return @divExact(len, @sizeOf(Handle)),
-            .out_of_resources => return error.OutOfResources,
+            // If len is zero, it should return not_found, otherwise buffer_too_small.
+            // This is because it can/should only return success when a valid buffer is
+            // passed with a non zero size, which is not the case.
+            // Thus this status is considered unreachable and will return error.Unexpected
+            // .success => unreachable,
+            .buffer_too_small => return @divExact(len, @sizeOf(uefi.Handle)),
+            .not_found => return 0,
+            // This function accounts for all possible causes of this error code
+            // as per the most recent UEFI spec 2.10A, therefore this branch is
+            // considered unreachable and will return error.Unexpected instead
+            // .invalid_parameter => unreachable
             else => |status| return uefi.unexpectedStatus(status),
         }
     }
-- 
2.54.0


From 0f51f663f06728f38f518073a23d69a7c1b0d792 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 27 Jan 2026 23:24:33 +0100
Subject: [PATCH 062/499] musl: update some hexagon headers from the quic fork

---
 .../include/hexagon-linux-musl/bits/hwcap.h   | 31 +++++++++++++++++++
 .../include/hexagon-linux-musl/bits/signal.h  |  8 ++---
 lib/libc/musl/arch/hexagon/bits/hwcap.h       | 31 +++++++++++++++++++
 lib/libc/musl/arch/hexagon/bits/signal.h      |  5 +--
 4 files changed, 69 insertions(+), 6 deletions(-)
 create mode 100644 lib/libc/include/hexagon-linux-musl/bits/hwcap.h
 create mode 100644 lib/libc/musl/arch/hexagon/bits/hwcap.h

diff --git a/lib/libc/include/hexagon-linux-musl/bits/hwcap.h b/lib/libc/include/hexagon-linux-musl/bits/hwcap.h
new file mode 100644
index 0000000000000000000000000000000000000000..40b13e18f93622c10d83840c3a2add7788421e61
--- /dev/null
+++ b/lib/libc/include/hexagon-linux-musl/bits/hwcap.h
@@ -0,0 +1,31 @@
+/* ISA version encoding in bits 0-6 (7 bits) */
+#define HWCAP_HEXAGON_ISA_MASK	0x7F	/* ISA version mask */
+
+/* ISA version enumeration values */
+#define HWCAP_HEXAGON_ISA_V2	1	/* Hexagon V2 */
+#define HWCAP_HEXAGON_ISA_V3	2	/* Hexagon V3 */
+#define HWCAP_HEXAGON_ISA_V4	3	/* Hexagon V4 */
+#define HWCAP_HEXAGON_ISA_V5	4	/* Hexagon V5 */
+#define HWCAP_HEXAGON_ISA_V55	5	/* Hexagon V55 */
+#define HWCAP_HEXAGON_ISA_V60	6	/* Hexagon V60 */
+#define HWCAP_HEXAGON_ISA_V62	7	/* Hexagon V62 */
+#define HWCAP_HEXAGON_ISA_V65	8	/* Hexagon V65 */
+#define HWCAP_HEXAGON_ISA_V66	9	/* Hexagon V66 */
+#define HWCAP_HEXAGON_ISA_V67	10	/* Hexagon V67 */
+#define HWCAP_HEXAGON_ISA_V68	11	/* Hexagon V68 */
+#define HWCAP_HEXAGON_ISA_V69	12	/* Hexagon V69 */
+#define HWCAP_HEXAGON_ISA_V71	13	/* Hexagon V71 */
+#define HWCAP_HEXAGON_ISA_V73	14	/* Hexagon V73 */
+#define HWCAP_HEXAGON_ISA_V79	15	/* Hexagon V79 */
+
+/* Essential feature flags */
+#define HWCAP_HEXAGON_HVX		(1 << 7)	/* HVX (Hexagon Vector eXtensions) */
+#define HWCAP_HEXAGON_CABAC		(1 << 8)	/* CABAC acceleration */
+#define HWCAP_HEXAGON_HVX_LENGTH_128B	(1 << 9)	/* HVX 128-byte vector length */
+#define HWCAP_HEXAGON_HVX_IEEE_FP	(1 << 10)	/* HVX IEEE floating point */
+#define HWCAP_HEXAGON_AUDIO		(1 << 11)	/* Audio ISA extensions */
+
+/* Utility macros for userspace applications */
+#define HWCAP_HEXAGON_GET_ISA(hwcap)		((hwcap) & HWCAP_HEXAGON_ISA_MASK)
+#define HWCAP_HEXAGON_IS_ISA(hwcap, version)	(HWCAP_HEXAGON_GET_ISA(hwcap) == (version))
+#define HWCAP_HEXAGON_HAS_ISA(hwcap, version)	(HWCAP_HEXAGON_GET_ISA(hwcap) >= (version))
diff --git a/lib/libc/include/hexagon-linux-musl/bits/signal.h b/lib/libc/include/hexagon-linux-musl/bits/signal.h
index ec67d3ba01e005f06f717136a8b9a9cb0837c94d..9753066b6d840cf11d1f86cdc9cd2b48a16952c5 100644
--- a/lib/libc/include/hexagon-linux-musl/bits/signal.h
+++ b/lib/libc/include/hexagon-linux-musl/bits/signal.h
@@ -31,9 +31,10 @@ typedef struct sigcontext
 	unsigned long pc;
 	unsigned long cause;
 	unsigned long badva;
+	unsigned long cs0;
+	unsigned long cs1;
 	unsigned long pad1;
-	unsigned long long pad2;
-} mcontext_t;
+} __attribute__((__aligned__(8))) mcontext_t;
 #else
 typedef struct {
 	unsigned long __regs[48];
@@ -61,7 +62,6 @@ typedef struct __ucontext {
 #define SA_RESTART    0x10000000
 #define SA_NODEFER    0x40000000
 #define SA_RESETHAND  0x80000000
-#define SA_RESTORER   0x04000000
 
 #endif
 
@@ -100,4 +100,4 @@ typedef struct __ucontext {
 #define SIGSYS    31
 #define SIGUNUSED SIGSYS
 
-#define _NSIG 65
\ No newline at end of file
+#define _NSIG 65
diff --git a/lib/libc/musl/arch/hexagon/bits/hwcap.h b/lib/libc/musl/arch/hexagon/bits/hwcap.h
new file mode 100644
index 0000000000000000000000000000000000000000..40b13e18f93622c10d83840c3a2add7788421e61
--- /dev/null
+++ b/lib/libc/musl/arch/hexagon/bits/hwcap.h
@@ -0,0 +1,31 @@
+/* ISA version encoding in bits 0-6 (7 bits) */
+#define HWCAP_HEXAGON_ISA_MASK	0x7F	/* ISA version mask */
+
+/* ISA version enumeration values */
+#define HWCAP_HEXAGON_ISA_V2	1	/* Hexagon V2 */
+#define HWCAP_HEXAGON_ISA_V3	2	/* Hexagon V3 */
+#define HWCAP_HEXAGON_ISA_V4	3	/* Hexagon V4 */
+#define HWCAP_HEXAGON_ISA_V5	4	/* Hexagon V5 */
+#define HWCAP_HEXAGON_ISA_V55	5	/* Hexagon V55 */
+#define HWCAP_HEXAGON_ISA_V60	6	/* Hexagon V60 */
+#define HWCAP_HEXAGON_ISA_V62	7	/* Hexagon V62 */
+#define HWCAP_HEXAGON_ISA_V65	8	/* Hexagon V65 */
+#define HWCAP_HEXAGON_ISA_V66	9	/* Hexagon V66 */
+#define HWCAP_HEXAGON_ISA_V67	10	/* Hexagon V67 */
+#define HWCAP_HEXAGON_ISA_V68	11	/* Hexagon V68 */
+#define HWCAP_HEXAGON_ISA_V69	12	/* Hexagon V69 */
+#define HWCAP_HEXAGON_ISA_V71	13	/* Hexagon V71 */
+#define HWCAP_HEXAGON_ISA_V73	14	/* Hexagon V73 */
+#define HWCAP_HEXAGON_ISA_V79	15	/* Hexagon V79 */
+
+/* Essential feature flags */
+#define HWCAP_HEXAGON_HVX		(1 << 7)	/* HVX (Hexagon Vector eXtensions) */
+#define HWCAP_HEXAGON_CABAC		(1 << 8)	/* CABAC acceleration */
+#define HWCAP_HEXAGON_HVX_LENGTH_128B	(1 << 9)	/* HVX 128-byte vector length */
+#define HWCAP_HEXAGON_HVX_IEEE_FP	(1 << 10)	/* HVX IEEE floating point */
+#define HWCAP_HEXAGON_AUDIO		(1 << 11)	/* Audio ISA extensions */
+
+/* Utility macros for userspace applications */
+#define HWCAP_HEXAGON_GET_ISA(hwcap)		((hwcap) & HWCAP_HEXAGON_ISA_MASK)
+#define HWCAP_HEXAGON_IS_ISA(hwcap, version)	(HWCAP_HEXAGON_GET_ISA(hwcap) == (version))
+#define HWCAP_HEXAGON_HAS_ISA(hwcap, version)	(HWCAP_HEXAGON_GET_ISA(hwcap) >= (version))
diff --git a/lib/libc/musl/arch/hexagon/bits/signal.h b/lib/libc/musl/arch/hexagon/bits/signal.h
index 1a2715dd5496889a3b5ead0b40c5c723a58dadb0..9753066b6d840cf11d1f86cdc9cd2b48a16952c5 100644
--- a/lib/libc/musl/arch/hexagon/bits/signal.h
+++ b/lib/libc/musl/arch/hexagon/bits/signal.h
@@ -31,9 +31,10 @@ typedef struct sigcontext
 	unsigned long pc;
 	unsigned long cause;
 	unsigned long badva;
+	unsigned long cs0;
+	unsigned long cs1;
 	unsigned long pad1;
-	unsigned long long pad2;
-} mcontext_t;
+} __attribute__((__aligned__(8))) mcontext_t;
 #else
 typedef struct {
 	unsigned long __regs[48];
-- 
2.54.0


From 11c3b4bd4178c78af103f5397fc3aafd09a2a979 Mon Sep 17 00:00:00 2001
From: llogick <16590917+llogick@users.noreply.github.com>
Date: Tue, 27 Jan 2026 14:58:24 -0800
Subject: [PATCH 063/499] Fix std.process.run leaking memory if child.wait
 returned an error

---
 lib/std/process.zig | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/lib/std/process.zig b/lib/std/process.zig
index 6798bba675b9cbe98da2d8fe438c04a285e5d1f6..f7dd7e30173504deade22fee09fb361bc629f012 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -533,10 +533,16 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
 
     try child.collectOutput(gpa, &stdout, &stderr, options.max_output_bytes);
 
+    const term = try child.wait(io);
+
+    const owned_stdout = try stdout.toOwnedSlice(gpa);
+    errdefer gpa.free(owned_stdout);
+    const owned_stderr = try stderr.toOwnedSlice(gpa);
+
     return .{
-        .stdout = try stdout.toOwnedSlice(gpa),
-        .stderr = try stderr.toOwnedSlice(gpa),
-        .term = try child.wait(io),
+        .stdout = owned_stdout,
+        .stderr = owned_stderr,
+        .term = term,
     };
 }
 
-- 
2.54.0


From 204fa8959a8f9d5457705f338eb0461e54155796 Mon Sep 17 00:00:00 2001
From: Krzysztof Wolicki <der.teufel.mail@gmail.com>
Date: Tue, 27 Jan 2026 20:49:30 +0100
Subject: [PATCH 064/499] Make functions on EnumMap always take a pointer to
 avoid copies of big EnumMaps

---
 lib/std/enums.zig | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/std/enums.zig b/lib/std/enums.zig
index 76deff5421ad8272804a9fba751442c4a4bc83bc..6e21713e6d28c33e2088e88b3c98e5b75a2e5756 100644
--- a/lib/std/enums.zig
+++ b/lib/std/enums.zig
@@ -504,25 +504,25 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         }
 
         /// The number of items in the map.
-        pub fn count(self: Self) usize {
+        pub fn count(self: *const Self) usize {
             return self.bits.count();
         }
 
         /// Checks if the map contains an item.
-        pub fn contains(self: Self, key: Key) bool {
+        pub fn contains(self: *const Self, key: Key) bool {
             return self.bits.isSet(Indexer.indexOf(key));
         }
 
         /// Gets the value associated with a key.
         /// If the key is not in the map, returns null.
-        pub fn get(self: Self, key: Key) ?Value {
+        pub fn get(self: *const Self, key: Key) ?Value {
             const index = Indexer.indexOf(key);
             return if (self.bits.isSet(index)) self.values[index] else null;
         }
 
         /// Gets the value associated with a key, which must
         /// exist in the map.
-        pub fn getAssertContains(self: Self, key: Key) Value {
+        pub fn getAssertContains(self: *const Self, key: Key) Value {
             const index = Indexer.indexOf(key);
             assert(self.bits.isSet(index));
             return self.values[index];
-- 
2.54.0


From 3b10383114f7aee96f18f7b3aac7c0e08d840b42 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 00:43:20 -0800
Subject: [PATCH 065/499] std.meta: delete declList

dubious. if people want this logic they should take responsibility for
it in their own code.
---
 lib/std/meta.zig | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index a4ce8161327e9ebebe5003810aac81e0d5c18c32..f1afa9bc7a049c5e4e13546e307b551e93e863c9 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -752,25 +752,6 @@ pub fn fieldIndex(comptime T: type, comptime name: []const u8) ?comptime_int {
     return null;
 }
 
-/// Returns a slice of pointers to public declarations of a namespace.
-pub fn declList(comptime Namespace: type, comptime Decl: type) []const *const Decl {
-    const S = struct {
-        fn declNameLessThan(context: void, lhs: *const Decl, rhs: *const Decl) bool {
-            _ = context;
-            return mem.lessThan(u8, lhs.name, rhs.name);
-        }
-    };
-    comptime {
-        const decls = declarations(Namespace);
-        var array: [decls.len]*const Decl = undefined;
-        for (decls, 0..) |decl, i| {
-            array[i] = &@field(Namespace, decl.name);
-        }
-        mem.sort(*const Decl, &array, {}, S.declNameLessThan);
-        return &array;
-    }
-}
-
 /// Deprecated: use @Int
 pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {
     return @Int(signedness, bit_count);
-- 
2.54.0


From 757ec185f0eb91a15c4bdbe0201f0d998f30258c Mon Sep 17 00:00:00 2001
From: lzm-build <3575188313@qq.com>
Date: Wed, 28 Jan 2026 23:33:35 +0100
Subject: [PATCH 066/499] Add `f16`, `f80` and `f128` support for `acos` and
 `asin` (#30997)

The software impl of `acos` and `asin` depends on the `sqrt` op. Since support for `sqrt` in `f16`, `f80`, and `f128` has been added, the impl of `acos` and `asin` for `f16`, `f80`, and `f128` is now being supplemented.

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30997
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: lzm-build <3575188313@qq.com>
Co-committed-by: lzm-build <3575188313@qq.com>
---
 lib/std/math/acos.zig | 409 +++++++++++++++++++++++++++++++--------
 lib/std/math/asin.zig | 434 +++++++++++++++++++++++++++++++++---------
 2 files changed, 675 insertions(+), 168 deletions(-)

diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig
index 6f734dbacb8cb198e606452a9afb5ff3039e1470..dae3f70c82dfa1839e6112ba7135e32e9c65ef1f 100644
--- a/lib/std/math/acos.zig
+++ b/lib/std/math/acos.zig
@@ -3,10 +3,13 @@
 //
 // https://git.musl-libc.org/cgit/musl/tree/src/math/acosf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/acos.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/acosl.c
 
 const std = @import("../std.zig");
 const math = std.math;
-const expect = std.testing.expect;
+const testing = std.testing;
+const builtin = @import("builtin");
+const native_endian = builtin.cpu.arch.endian();
 
 /// Returns the arc-cosine of x.
 ///
@@ -15,71 +18,120 @@ const expect = std.testing.expect;
 pub fn acos(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     return switch (T) {
-        f32 => acos32(x),
-        f64 => acos64(x),
+        f16 => acosBinary16(x),
+        f32 => acosBinary32(x),
+        f64 => acosBinary64(x),
+        f80 => acosExtended80(x),
+        f128 => acosBinary128(x),
         else => @compileError("acos not implemented for " ++ @typeName(T)),
     };
 }
 
-fn r32(z: f32) f32 {
-    const pS0 = 1.6666586697e-01;
-    const pS1 = -4.2743422091e-02;
-    const pS2 = -8.6563630030e-03;
-    const qS1 = -7.0662963390e-01;
+fn approxBinary16(z: f32) f32 {
+    const S0: f32 = 1.0000001e0;
+    const S1: f32 = 1.6664918e-1;
+    const S2: f32 = 7.55022e-2;
+    const S3: f32 = 3.9513987e-2;
+    const S4: f32 = 5.0883885e-2;
+    return S0 + z * (S1 + z * (S2 + z * (S3 + z * S4)));
+}
+
+fn acosBinary16(x: f16) f16 {
+    const pio2: f32 = math.pi / 2.0;
+
+    const hx: u16 = @bitCast(x);
+    const ix: u16 = hx & 0x7fff;
+
+    // |x| >= 1 or nan
+    if (ix >= 0x3c00) {
+        if (ix == 0x3c00) {
+            if (hx >> 15 != 0) {
+                return @floatCast(2.0 * pio2 + 0x1p-120);
+            }
+            return 0.0;
+        }
+        return 0.0 / (x - x);
+    }
+
+    const xf: f32 = @floatCast(x);
+
+    // |x| < 0.5
+    if (ix < 0x3800) {
+        return @floatCast(pio2 - xf * approxBinary16(xf * xf));
+    }
+
+    // x < -0.5
+    if (hx >> 15 != 0) {
+        const z = (1.0 + xf) * 0.5;
+        const s = @sqrt(z);
+        const w = approxBinary16(z) * s;
+        return @floatCast(2.0 * (pio2 - w));
+    }
+
+    // x > 0.5
+    const z = (1.0 - xf) * 0.5;
+    const s = @sqrt(z);
+    const w = approxBinary16(z) * s;
+    return @floatCast(2.0 * w);
+}
+
+fn rationalApproxBinary32(z: f32) f32 {
+    const pS0: f32 = 1.6666586697e-01;
+    const pS1: f32 = -4.2743422091e-02;
+    const pS2: f32 = -8.6563630030e-03;
+    const qS1: f32 = -7.0662963390e-01;
 
     const p = z * (pS0 + z * (pS1 + z * pS2));
     const q = 1.0 + z * qS1;
     return p / q;
 }
 
-fn acos32(x: f32) f32 {
-    const pio2_hi = 1.5707962513e+00;
-    const pio2_lo = 7.5497894159e-08;
+fn acosBinary32(x: f32) f32 {
+    const pio2_hi: f32 = 1.5707962513e+00;
+    const pio2_lo: f32 = 7.5497894159e-08;
 
-    const hx: u32 = @as(u32, @bitCast(x));
-    const ix: u32 = hx & 0x7FFFFFFF;
+    const hx: u32 = @bitCast(x);
+    const ix: u32 = hx & 0x7fff_ffff;
 
     // |x| >= 1 or nan
-    if (ix >= 0x3F800000) {
-        if (ix == 0x3F800000) {
+    if (ix >= 0x3f800000) {
+        if (ix == 0x3f800000) {
             if (hx >> 31 != 0) {
                 return 2.0 * pio2_hi + 0x1.0p-120;
-            } else {
-                return 0.0;
             }
-        } else {
-            return (x - x) / 0;
+            return 0.0;
         }
+        return 0.0 / (x - x);
     }
 
     // |x| < 0.5
-    if (ix < 0x3F000000) {
-        if (ix <= 0x32800000) { // |x| < 2^(-26)
+    if (ix < 0x3f00_0000) {
+        // |x| < 2^(-26)
+        if (ix <= 0x3280_0000) {
             return pio2_hi + 0x1.0p-120;
-        } else {
-            return pio2_hi - (x - (pio2_lo - x * r32(x * x)));
         }
+        return pio2_hi - (x - (pio2_lo - x * rationalApproxBinary32(x * x)));
     }
 
     // x < -0.5
     if (hx >> 31 != 0) {
         const z = (1 + x) * 0.5;
         const s = @sqrt(z);
-        const w = r32(z) * s - pio2_lo;
-        return 2 * (pio2_hi - (s + w));
+        const w = rationalApproxBinary32(z) * s - pio2_lo;
+        return 2.0 * (pio2_hi - (s + w));
     }
 
     // x > 0.5
     const z = (1.0 - x) * 0.5;
     const s = @sqrt(z);
-    const jx = @as(u32, @bitCast(s));
-    const df = @as(f32, @bitCast(jx & 0xFFFFF000));
+    const hs: u32 = @bitCast(s);
+    const df: f32 = @bitCast(hs & 0xffff_f000);
     const c = (z - df * df) / (s + df);
-    const w = r32(z) * s + c;
-    return 2 * (df + w);
+    const w = rationalApproxBinary32(z) * s + c;
+    return 2.0 * (df + w);
 }
 
-fn r64(z: f64) f64 {
+fn rationalApproxBinary64(z: f64) f64 {
     const pS0: f64 = 1.66666666666666657415e-01;
     const pS1: f64 = -3.25565818622400915405e-01;
     const pS2: f64 = 2.01212532134862925881e-01;
@@ -96,91 +148,292 @@ fn r64(z: f64) f64 {
     return p / q;
 }
 
-fn acos64(x: f64) f64 {
+fn acosBinary64(x: f64) f64 {
     const pio2_hi: f64 = 1.57079632679489655800e+00;
     const pio2_lo: f64 = 6.12323399573676603587e-17;
 
-    const ux = @as(u64, @bitCast(x));
-    const hx = @as(u32, @intCast(ux >> 32));
-    const ix = hx & 0x7FFFFFFF;
+    const hx: u32 = @intCast(@as(u64, @bitCast(x)) >> 32);
+    const ix: u32 = hx & 0x7fff_ffff;
 
     // |x| >= 1 or nan
-    if (ix >= 0x3FF00000) {
-        const lx = @as(u32, @intCast(ux & 0xFFFFFFFF));
-
-        // acos(1) = 0, acos(-1) = pi
-        if ((ix - 0x3FF00000) | lx == 0) {
+    if (ix >= 0x3ff0_0000) {
+        const lx: u32 = @truncate(@as(u64, @bitCast(x)));
+        if ((ix - 0x3ff0_0000 | lx) == 0) {
             if (hx >> 31 != 0) {
-                return 2 * pio2_hi + 0x1.0p-120;
-            } else {
-                return 0;
+                return 2.0 * pio2_hi + 0x1.0p-120;
             }
+            return 0.0;
         }
-
-        return (x - x) / 0;
+        return 0.0 / (x - x);
     }
 
     // |x| < 0.5
-    if (ix < 0x3FE00000) {
+    if (ix < 0x3fe0_0000) {
         // |x| < 2^(-57)
-        if (ix <= 0x3C600000) {
+        if (ix <= 0x3c60_0000) {
             return pio2_hi + 0x1.0p-120;
-        } else {
-            return pio2_hi - (x - (pio2_lo - x * r64(x * x)));
         }
+        return pio2_hi - (x - (pio2_lo - x * rationalApproxBinary64(x * x)));
     }
 
     // x < -0.5
     if (hx >> 31 != 0) {
         const z = (1.0 + x) * 0.5;
         const s = @sqrt(z);
-        const w = r64(z) * s - pio2_lo;
+        const w = rationalApproxBinary64(z) * s - pio2_lo;
         return 2 * (pio2_hi - (s + w));
     }
 
     // x > 0.5
     const z = (1.0 - x) * 0.5;
     const s = @sqrt(z);
-    const jx = @as(u64, @bitCast(s));
-    const df = @as(f64, @bitCast(jx & 0xFFFFFFFF00000000));
+    const df: f64 = @bitCast(@as(u64, @bitCast(s)) & 0xffff_ffff_0000_0000);
     const c = (z - df * df) / (s + df);
-    const w = r64(z) * s + c;
-    return 2 * (df + w);
+    const w = rationalApproxBinary64(z) * s + c;
+    return 2.0 * (df + w);
 }
 
-test acos {
-    try expect(acos(@as(f32, 0.0)) == acos32(0.0));
-    try expect(acos(@as(f64, 0.0)) == acos64(0.0));
+fn rationalApproxExtended80(z: f80) f80 {
+    const pS0: f80 = 1.66666666666666666631e-01;
+    const pS1: f80 = -4.16313987993683104320e-01;
+    const pS2: f80 = 3.69068046323246813704e-01;
+    const pS3: f80 = -1.36213932016738603108e-01;
+    const pS4: f80 = 1.78324189708471965733e-02;
+    const pS5: f80 = -2.19216428382605211588e-04;
+    const pS6: f80 = -7.10526623669075243183e-06;
+    const qS1: f80 = -2.94788392796209867269e+00;
+    const qS2: f80 = 3.27309890266528636716e+00;
+    const qS3: f80 = -1.68285799854822427013e+00;
+    const qS4: f80 = 3.90699412641738801874e-01;
+    const qS5: f80 = -3.14365703596053263322e-02;
+
+    const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * (pS5 + z * pS6))))));
+    const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * (qS4 + z * qS5))));
+    return p / q;
+}
+
+fn acosExtended80(x: f80) f80 {
+    const pio2_hi: f80 = 1.57079632679489661926;
+    const pio2_lo: f80 = -2.50827880633416601173e-20;
+
+    const hx: u80 = @bitCast(x);
+    const se: u16 = @truncate(hx >> 64);
+    const e = se & 0x7fff;
+
+    // |x| >= 1 or nan
+    if (e >= 0x3fff) {
+        if (x == 1.0) {
+            return 0.0;
+        }
+        if (x == -1.0) {
+            return 2.0 * pio2_hi + 0x1p-120;
+        }
+        return 0.0 / (x - x);
+    }
+    // |x| < 0.5
+    if (e < 0x3fff - 1) {
+        if (e < 0x3fff - math.floatFractionalBits(f80)) {
+            return pio2_hi + 0x1p-120;
+        }
+        return pio2_hi - (rationalApproxExtended80(x * x) * x - pio2_lo + x);
+    }
+    // x < -0.5
+    if (se >> 15 != 0) {
+        const z = (1 + x) * 0.5;
+        const s = @sqrt(z);
+        return 2.0 * (pio2_hi - (rationalApproxExtended80(z) * s - pio2_lo + s));
+    }
+    // x > 0.5
+    const z = (1.0 - x) * 0.5;
+    const s = @sqrt(z);
+    const hs: u80 = @bitCast(s);
+    const f: f80 = @bitCast(hs & 0xffff_ffff_ffff_0000_0000);
+    const c = (z - f * f) / (s + f);
+    return 2.0 * (rationalApproxExtended80(z) * s + c + f);
+}
+
+fn rationalApproxBinary128(z: f128) f128 {
+    const pS0: f128 = 1.66666666666666666666666666666700314e-01;
+    const pS1: f128 = -7.32816946414566252574527475428622708e-01;
+    const pS2: f128 = 1.34215708714992334609030036562143589e+00;
+    const pS3: f128 = -1.32483151677116409805070261790752040e+00;
+    const pS4: f128 = 7.61206183613632558824485341162121989e-01;
+    const pS5: f128 = -2.56165783329023486777386833928147375e-01;
+    const pS6: f128 = 4.80718586374448793411019434585413855e-02;
+    const pS7: f128 = -4.42523267167024279410230886239774718e-03;
+    const pS8: f128 = 1.44551535183911458253205638280410064e-04;
+    const pS9: f128 = -2.10558957916600254061591040482706179e-07;
+    const qS1: f128 = -4.84690167848739751544716485245697428e+00;
+    const qS2: f128 = 9.96619113536172610135016921140206980e+00;
+    const qS3: f128 = -1.13177895428973036660836798461641458e+01;
+    const qS4: f128 = 7.74004374389488266169304117714658761e+00;
+    const qS5: f128 = -3.25871986053534084709023539900339905e+00;
+    const qS6: f128 = 8.27830318881232209752469022352928864e-01;
+    const qS7: f128 = -1.18768052702942805423330715206348004e-01;
+    const qS8: f128 = 8.32600764660522313269101537926539470e-03;
+    const qS9: f128 = -1.99407384882605586705979504567947007e-04;
+
+    const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * (pS5 + z * (pS6 + z * (pS7 + z * (pS8 + z * pS9)))))))));
+    const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * (qS4 + z * (qS5 + z * (qS6 + z * (qS7 + z * (qS8 + z * qS9))))))));
+    return p / q;
+}
+
+fn acosBinary128(x: f128) f128 {
+    const pio2_hi: f128 = 1.57079632679489661923132169163975140;
+    const pio2_lo: f128 = 4.33590506506189051239852201302167613e-35;
+
+    const hx: u128 = @bitCast(x);
+    const se: u16 = @truncate(hx >> 112);
+    const e = se & 0x7fff;
+
+    // |x| >= 1 or nan
+    if (e >= 0x3fff) {
+        if (x == 1.0) {
+            return 0.0;
+        }
+        if (x == -1.0) {
+            return 2 * pio2_hi + 0x1p-120;
+        }
+        return 0.0 / (x - x);
+    }
+    // |x| < 0.5
+    if (e < 0x3fff - 1) {
+        if (e < 0x3fff - math.floatFractionalBits(f128)) {
+            return pio2_hi + 0x1p-120;
+        }
+        return pio2_hi - (rationalApproxBinary128(x * x) * x - pio2_lo + x);
+    }
+    // x < -0.5
+    if (se >> 15 != 0) {
+        const z = (1 + x) * 0.5;
+        const s = @sqrt(z);
+        return 2 * (pio2_hi - (rationalApproxBinary128(z) * s - pio2_lo + s));
+    }
+    // x > 0.5
+    const z = (1.0 - x) * 0.5;
+    const s = @sqrt(z);
+    const hs: u128 = @bitCast(s);
+    const f: f128 = @bitCast(hs & 0xffff_ffff_ffff_ffff_0000_0000_0000_0000);
+    const c = (z - f * f) / (s + f);
+    return 2.0 * (rationalApproxBinary128(z) * s + c + f);
+}
+
+test "acosBinary16.special" {
+    try testing.expectApproxEqAbs(acosBinary16(0x0p+0), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
+    try testing.expectApproxEqAbs(acosBinary16(-0x1p+0), 0x1.92p1, math.floatEpsAt(f16, 0x1.92p1));
+    try testing.expectEqual(acosBinary16(0x1p+0), 0x0p+0);
+    try testing.expect(math.isNan(acosBinary16(0x1.004p0)));
+    try testing.expect(math.isNan(acosBinary16(-0x1.004p0)));
+    try testing.expect(math.isNan(acosBinary16(math.inf(f16))));
+    try testing.expect(math.isNan(acosBinary16(-math.inf(f16))));
+    try testing.expect(math.isNan(acosBinary16(math.nan(f16))));
 }
 
-test acos32 {
-    const epsilon = 0.000001;
+test "acosBinary16" {
+    try testing.expectApproxEqAbs(acosBinary16(0x1.db4p-5), 0x1.834p0, math.floatEpsAt(f16, 0x1.834p0));
+    try testing.expectApproxEqAbs(acosBinary16(-0x1.068p-2), 0x1.d48p0, math.floatEpsAt(f16, 0x1.d48p0));
+    try testing.expectApproxEqAbs(acosBinary16(-0x1.2c4p-3), 0x1.b7cp0, math.floatEpsAt(f16, 0x1.b7cp0));
+    try testing.expectApproxEqAbs(acosBinary16(0x1.65p-3), 0x1.654p0, math.floatEpsAt(f16, 0x1.654p0));
+    try testing.expectApproxEqAbs(acosBinary16(0x1.dfcp-1), 0x1.6d8p-2, math.floatEpsAt(f16, 0x1.6d8p-2));
+    try testing.expectApproxEqAbs(acosBinary16(-0x1.764p-1), 0x1.32p1, math.floatEpsAt(f16, 0x1.32p1));
+    try testing.expectApproxEqAbs(acosBinary16(0x1.b18p-3), 0x1.5b8p0, math.floatEpsAt(f16, 0x1.5b8p0));
+    try testing.expectApproxEqAbs(acosBinary16(0x1.5acp-3), 0x1.668p0, math.floatEpsAt(f16, 0x1.668p0));
+    try testing.expectApproxEqAbs(acosBinary16(-0x1.18cp-1), 0x1.134p1, math.floatEpsAt(f16, 0x1.134p1));
+    try testing.expectApproxEqAbs(acosBinary16(-0x1.03p-1), 0x1.0dp1, math.floatEpsAt(f16, 0x1.0dp1));
+}
+
+test "acosBinary32.special" {
+    try testing.expectApproxEqAbs(acosBinary32(0x0p+0), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(acosBinary32(-0x1p+0), 0x1.921fb6p+1, math.floatEpsAt(f32, 0x1.921fb6p+1));
+    try testing.expectEqual(acosBinary32(0x1p+0), 0x0p+0);
+    try testing.expect(math.isNan(acosBinary32(0x1.000002p+0)));
+    try testing.expect(math.isNan(acosBinary32(-0x1.000002p+0)));
+    try testing.expect(math.isNan(acosBinary32(math.inf(f32))));
+    try testing.expect(math.isNan(acosBinary32(-math.inf(f32))));
+    try testing.expect(math.isNan(acosBinary32(math.nan(f32))));
+}
 
-    try expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon));
-    try expect(math.approxEqAbs(f32, acos32(0.2), 1.369438, epsilon));
-    try expect(math.approxEqAbs(f32, acos32(0.3434), 1.220262, epsilon));
-    try expect(math.approxEqAbs(f32, acos32(0.5), 1.047198, epsilon));
-    try expect(math.approxEqAbs(f32, acos32(0.8923), 0.468382, epsilon));
-    try expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon));
+test "acosBinary32" {
+    try testing.expectApproxEqAbs(acosBinary32(-0x1.13284cp-2), 0x1.d7c4e6p+0, math.floatEpsAt(f32, 0x1.d7c4e6p+0));
+    try testing.expectApproxEqAbs(acosBinary32(0x1.6ca8ep-1), 0x1.8e6756p-1, math.floatEpsAt(f32, 0x1.8e6756p-1));
+    try testing.expectApproxEqAbs(acosBinary32(0x1.c2ca6p-1), 0x1.f9d74cp-2, math.floatEpsAt(f32, 0x1.f9d74cp-2));
+    try testing.expectApproxEqAbs(acosBinary32(-0x1.55f12p-1), 0x1.26abdcp+1, math.floatEpsAt(f32, 0x1.26abdcp+1));
+    try testing.expectApproxEqAbs(acosBinary32(-0x1.15679ep-2), 0x1.d85a44p+0, math.floatEpsAt(f32, 0x1.d85a44p+0));
+    try testing.expectApproxEqAbs(acosBinary32(-0x1.41e132p-5), 0x1.9c2f68p+0, math.floatEpsAt(f32, 0x1.9c2f68p+0));
+    try testing.expectApproxEqAbs(acosBinary32(0x1.281b0ep-1), 0x1.e881bp-1, math.floatEpsAt(f32, 0x1.e881bp-1));
+    try testing.expectApproxEqAbs(acosBinary32(0x1.b5ce34p-1), 0x1.1713f6p-1, math.floatEpsAt(f32, 0x1.1713f6p-1));
+    try testing.expectApproxEqAbs(acosBinary32(-0x1.583482p-3), 0x1.bd5accp+0, math.floatEpsAt(f32, 0x1.bd5accp+0));
+    try testing.expectApproxEqAbs(acosBinary32(-0x1.ea8224p-1), 0x1.6ce7d8p+1, math.floatEpsAt(f32, 0x1.6ce7d8p+1));
 }
 
-test acos64 {
-    const epsilon = 0.000001;
+test "acosBinary64.special" {
+    try testing.expectApproxEqAbs(acosBinary64(0x0p+0), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(acosBinary64(-0x1p+0), 0x1.921fb54442d18p+1, math.floatEpsAt(f64, 0x1.921fb54442d18p+1));
+    try testing.expectEqual(acosBinary64(0x1p+0), 0x0p+0);
+    try testing.expect(math.isNan(acosBinary64(0x1.0000000000001p+0)));
+    try testing.expect(math.isNan(acosBinary64(-0x1.0000000000001p+0)));
+    try testing.expect(math.isNan(acosBinary64(math.inf(f64))));
+    try testing.expect(math.isNan(acosBinary64(-math.inf(f64))));
+    try testing.expect(math.isNan(acosBinary64(math.nan(f64))));
+}
+
+test "acosBinary64" {
+    try testing.expectApproxEqAbs(acosBinary64(-0x1.13284b2b5006dp-2), 0x1.d7c4e61020905p+0, math.floatEpsAt(f64, 0x1.d7c4e61020905p+0));
+    try testing.expectApproxEqAbs(acosBinary64(0x1.6ca8dfb825911p-1), 0x1.8e6756e27c366p-1, math.floatEpsAt(f64, 0x1.8e6756e27c366p-1));
+    try testing.expectApproxEqAbs(acosBinary64(0x1.c2ca609de7505p-1), 0x1.f9d748eaf956p-2, math.floatEpsAt(f64, 0x1.f9d748eaf956p-2));
+    try testing.expectApproxEqAbs(acosBinary64(-0x1.55f11fba96889p-1), 0x1.26abdc68d07aap+1, math.floatEpsAt(f64, 0x1.26abdc68d07aap+1));
+    try testing.expectApproxEqAbs(acosBinary64(-0x1.15679e27084ddp-2), 0x1.d85a44ea44fe4p+0, math.floatEpsAt(f64, 0x1.d85a44ea44fe4p+0));
+    try testing.expectApproxEqAbs(acosBinary64(-0x1.41e131b093c41p-5), 0x1.9c2f688eee8abp+0, math.floatEpsAt(f64, 0x1.9c2f688eee8abp+0));
+    try testing.expectApproxEqAbs(acosBinary64(0x1.281b0d18455f5p-1), 0x1.e881b1d4eb2a1p-1, math.floatEpsAt(f64, 0x1.e881b1d4eb2a1p-1));
+    try testing.expectApproxEqAbs(acosBinary64(0x1.b5ce34a51b239p-1), 0x1.1713f567a87efp-1, math.floatEpsAt(f64, 0x1.1713f567a87efp-1));
+    try testing.expectApproxEqAbs(acosBinary64(-0x1.583481079de4dp-3), 0x1.bd5acbe8fcc59p+0, math.floatEpsAt(f64, 0x1.bd5acbe8fcc59p+0));
+    try testing.expectApproxEqAbs(acosBinary64(-0x1.ea8223103b871p-1), 0x1.6ce7d66f628e5p+1, math.floatEpsAt(f64, 0x1.6ce7d66f628e5p+1));
+}
+
+test "acosExtended80.special" {
+    try testing.expectApproxEqAbs(acosExtended80(0x0p+0), 0x1.921fb54442d1846ap+0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap+0));
+    try testing.expectApproxEqAbs(acosExtended80(-0x1p+0), 0x1.921fb54442d1846ap+1, math.floatEpsAt(f80, 0x1.921fb54442d1846ap+1));
+    try testing.expectEqual(acosExtended80(0x1p+0), 0x0p+0);
+    try testing.expect(math.isNan(acosExtended80(0x1.0000000000000002p+0)));
+    try testing.expect(math.isNan(acosExtended80(-0x1.0000000000000002p+0)));
+    try testing.expect(math.isNan(acosExtended80(math.inf(f80))));
+    try testing.expect(math.isNan(acosExtended80(-math.inf(f80))));
+    try testing.expect(math.isNan(acosExtended80(math.nan(f80))));
+}
 
-    try expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon));
-    try expect(math.approxEqAbs(f64, acos64(0.2), 1.369438, epsilon));
-    try expect(math.approxEqAbs(f64, acos64(0.3434), 1.220262, epsilon));
-    try expect(math.approxEqAbs(f64, acos64(0.5), 1.047198, epsilon));
-    try expect(math.approxEqAbs(f64, acos64(0.8923), 0.468382, epsilon));
-    try expect(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon));
+test "acosExtended80" {
+    try testing.expectApproxEqAbs(acosExtended80(0x1.72068a321edc8804p-1), 0x1.86b349040d28f794p-1, math.floatEpsAt(f80, 0x1.86b349040d28f794p-1));
+    try testing.expectApproxEqAbs(acosExtended80(-0x1.06d0a467d22977ecp-2), 0x1.d4923ade73ec379cp0, math.floatEpsAt(f80, 0x1.d4923ade73ec379cp0));
+    try testing.expectApproxEqAbs(acosExtended80(0x1.77d21385faa9798ap-3), 0x1.62e0e8898c6d04f2p0, math.floatEpsAt(f80, 0x1.62e0e8898c6d04f2p0));
+    try testing.expectApproxEqAbs(acosExtended80(-0x1.73ee3e8bc2a44dbep-1), 0x1.3123cbcd5dc4bd58p1, math.floatEpsAt(f80, 0x1.3123cbcd5dc4bd58p1));
+    try testing.expectApproxEqAbs(acosExtended80(0x1.0a2dd1f6ffcf668ap-1), 0x1.062a6d562df2d316p0, math.floatEpsAt(f80, 0x1.062a6d562df2d316p0));
+    try testing.expectApproxEqAbs(acosExtended80(0x1.8e835c490a3aff9ep-3), 0x1.5ffd68b520aa55fap0, math.floatEpsAt(f80, 0x1.5ffd68b520aa55fap0));
+    try testing.expectApproxEqAbs(acosExtended80(0x1.add20cdc1565064cp-3), 0x1.5bfe6cabda700684p0, math.floatEpsAt(f80, 0x1.5bfe6cabda700684p0));
+    try testing.expectApproxEqAbs(acosExtended80(0x1.21986d43727fca72p-8), 0x1.90fe1c993b571924p0, math.floatEpsAt(f80, 0x1.90fe1c993b571924p0));
+    try testing.expectApproxEqAbs(acosExtended80(0x1.d61e0b3fae6a0564p-2), 0x1.18044ccc626e7f9ep0, math.floatEpsAt(f80, 0x1.18044ccc626e7f9ep0));
+    try testing.expectApproxEqAbs(acosExtended80(-0x1.171e7c4a41883ccap-4), 0x1.a39513b6c16532b4p0, math.floatEpsAt(f80, 0x1.a39513b6c16532b4p0));
 }
 
-test "acos32.special" {
-    try expect(math.isNan(acos32(-2)));
-    try expect(math.isNan(acos32(1.5)));
+test "acosBinary128.special" {
+    try testing.expectApproxEqAbs(acosBinary128(0x0p+0), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectApproxEqAbs(acosBinary128(-0x1p+0), 0x1.921fb54442d18469898cc51701b8p1, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p1));
+    try testing.expectEqual(acosBinary128(0x1p+0), 0x0p+0);
+    try testing.expect(math.isNan(acosBinary128(0x1.0000000000000000000000000001p0)));
+    try testing.expect(math.isNan(acosBinary128(-0x1.0000000000000000000000000001p0)));
+    try testing.expect(math.isNan(acosBinary128(math.inf(f128))));
+    try testing.expect(math.isNan(acosBinary128(-math.inf(f128))));
+    try testing.expect(math.isNan(acosBinary128(math.nan(f128))));
 }
 
-test "acos64.special" {
-    try expect(math.isNan(acos64(-2)));
-    try expect(math.isNan(acos64(1.5)));
+test "acosBinary128" {
+    try testing.expectApproxEqAbs(acosBinary128(-0x1.511bdb99a3c4373bedf834ef4f68p-1), 0x1.250e9a58f049eeafa99db4360c88p1, math.floatEpsAt(f128, 0x1.250e9a58f049eeafa99db4360c88p1));
+    try testing.expectApproxEqAbs(acosBinary128(-0x1.5879cc3ad6dfd2a52e9891c69808p-1), 0x1.2786664b1c676c99437b68590004p1, math.floatEpsAt(f128, 0x1.2786664b1c676c99437b68590004p1));
+    try testing.expectApproxEqAbs(acosBinary128(0x1.3f988ba64a7eb97a751c5f0b3077p-1), 0x1.cb190cd361c7c03a09c470b4caebp-1, math.floatEpsAt(f128, 0x1.cb190cd361c7c03a09c470b4caebp-1));
+    try testing.expectApproxEqAbs(acosBinary128(-0x1.3f2d96c7768e4c4fa02315727959p-1), 0x1.1f373be697880111758f582b1a96p1, math.floatEpsAt(f128, 0x1.1f373be697880111758f582b1a96p1));
+    try testing.expectApproxEqAbs(acosBinary128(0x1.fad303c2e28c1f4d8f9fd0e5686fp-2), 0x1.0d92fd2a0a6ca3e4853c1de9ea6ap0, math.floatEpsAt(f128, 0x1.0d92fd2a0a6ca3e4853c1de9ea6ap0));
+    try testing.expectApproxEqAbs(acosBinary128(0x1.ddde322bd1a2ee50c5ba30c9c617p-2), 0x1.15d4b306e16fbf9ea4f29e82b154p0, math.floatEpsAt(f128, 0x1.15d4b306e16fbf9ea4f29e82b154p0));
+    try testing.expectApproxEqAbs(acosBinary128(-0x1.b02f6adefcbeb1d48666b827ff17p-1), 0x1.49b0a0355a5539052388e8a6dc11p1, math.floatEpsAt(f128, 0x1.49b0a0355a5539052388e8a6dc11p1));
+    try testing.expectApproxEqAbs(acosBinary128(0x1.c8581cce7cd3f6efab0fc60d9b7dp-2), 0x1.1be0b757f4cef022f5d2422b9c78p0, math.floatEpsAt(f128, 0x1.1be0b757f4cef022f5d2422b9c78p0));
+    try testing.expectApproxEqAbs(acosBinary128(-0x1.bf887b8c4e33cbef59993056f3dep-1), 0x1.513270e671db2d840f20b0186c2cp1, math.floatEpsAt(f128, 0x1.513270e671db2d840f20b0186c2cp1));
+    try testing.expectApproxEqAbs(acosBinary128(0x1.0c0f600ab6f9c84c6102942044cep-3), 0x1.70851a509f0e8bfbe780aa8f29f9p0, math.floatEpsAt(f128, 0x1.70851a509f0e8bfbe780aa8f29f9p0));
 }
diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig
index cb4571c24e6d0471c8b945dcc807a0ce3e707a58..113fb584bbc3fac8c8d0636f692ebfe2b4553623 100644
--- a/lib/std/math/asin.zig
+++ b/lib/std/math/asin.zig
@@ -3,10 +3,14 @@
 //
 // https://git.musl-libc.org/cgit/musl/tree/src/math/asinf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/asin.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/asinl.c
 
 const std = @import("../std.zig");
 const math = std.math;
-const expect = std.testing.expect;
+const mem = std.mem;
+const testing = std.testing;
+const builtin = @import("builtin");
+const native_endian = builtin.cpu.arch.endian();
 
 /// Returns the arc-sin of x.
 ///
@@ -16,62 +20,101 @@ const expect = std.testing.expect;
 pub fn asin(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     return switch (T) {
-        f32 => asin32(x),
-        f64 => asin64(x),
+        f16 => asinBinary16(x),
+        f32 => asinBinary32(x),
+        f64 => asinBinary64(x),
+        f80 => asinExtended80(x),
+        f128 => asinBinary128(x),
         else => @compileError("asin not implemented for " ++ @typeName(T)),
     };
 }
 
-fn r32(z: f32) f32 {
-    const pS0 = 1.6666586697e-01;
-    const pS1 = -4.2743422091e-02;
-    const pS2 = -8.6563630030e-03;
-    const qS1 = -7.0662963390e-01;
+fn approxBinary16(z: f32) f32 {
+    const S0: f32 = 1.0000001e0;
+    const S1: f32 = 1.6664918e-1;
+    const S2: f32 = 7.55022e-2;
+    const S3: f32 = 3.9513987e-2;
+    const S4: f32 = 5.0883885e-2;
+    return S0 + z * (S1 + z * (S2 + z * (S3 + z * S4)));
+}
+
+fn asinBinary16(x: f16) f16 {
+    const pio2: f32 = math.pi / 2.0;
+
+    const hx: u16 = @bitCast(x);
+    const ix = hx & 0x7fff;
+
+    // |x| >= 1
+    if (ix >= 0x3c00) {
+        // |x| == 1
+        if (ix == 0x3c00) {
+            // asin(+-1) = +-pi/2 with inexact
+            return @floatCast(x * pio2 + 0x1.0p-120);
+        }
+        // asin(|x| > 1) is nan
+        return 0.0 / (x - x);
+    }
+
+    // |x| < 0.5
+    if (ix < 0x3800) {
+        return @floatCast(x * approxBinary16(x * x));
+    }
+
+    // 1 > |x| >= 0.5
+    const z = (1.0 - @abs(x)) * 0.5;
+    const s = @sqrt(z);
+    const x_local = pio2 - 2.0 * s * approxBinary16(z);
+    if (hx >> 15 != 0) {
+        return @floatCast(-x_local);
+    }
+    return @floatCast(x_local);
+}
+
+fn rationalApproxBinary32(z: f32) f32 {
+    const pS0: f32 = 1.6666586697e-01;
+    const pS1: f32 = -4.2743422091e-02;
+    const pS2: f32 = -8.6563630030e-03;
+    const qS1: f32 = -7.0662963390e-01;
 
     const p = z * (pS0 + z * (pS1 + z * pS2));
     const q = 1.0 + z * qS1;
     return p / q;
 }
 
-fn asin32(x: f32) f32 {
-    const pio2 = 1.570796326794896558e+00;
+fn asinBinary32(x: f32) f32 {
+    const pio2: f64 = 1.570796326794896558e+00;
 
-    const hx: u32 = @as(u32, @bitCast(x));
-    const ix: u32 = hx & 0x7FFFFFFF;
+    const hx: u32 = @bitCast(x);
+    const ix = hx & 0x7fff_ffff;
 
     // |x| >= 1
-    if (ix >= 0x3F800000) {
-        // |x| >= 1
-        if (ix == 0x3F800000) {
-            return x * pio2 + 0x1.0p-120; // asin(+-1) = +-pi/2 with inexact
-        } else {
-            return math.nan(f32); // asin(|x| > 1) is nan
+    if (ix >= 0x3f80_0000) {
+        // |x| == 1
+        if (ix == 0x3f80_0000) {
+            // asin(+-1) = +-pi/2 with inexact
+            return @floatCast(@as(f64, @floatCast(x)) * pio2 + 0x1.0p-120);
         }
+        // asin(|x| > 1) is nan
+        return 0.0 / (x - x);
     }
 
     // |x| < 0.5
-    if (ix < 0x3F000000) {
+    if (ix < 0x3f00_0000) {
         // 0x1p-126 <= |x| < 0x1p-12
-        if (ix < 0x39800000 and ix >= 0x00800000) {
+        if (ix < 0x3980_0000 and ix >= 0x0080_0000) {
             return x;
-        } else {
-            return x + x * r32(x * x);
         }
+        return x + x * rationalApproxBinary32(x * x);
     }
 
     // 1 > |x| >= 0.5
-    const z = (1 - @abs(x)) * 0.5;
-    const s = @sqrt(z);
-    const fx = pio2 - 2 * (s + s * r32(z));
-
-    if (hx >> 31 != 0) {
-        return -fx;
-    } else {
-        return fx;
-    }
+    const z = (1.0 - @abs(x)) * 0.5;
+    const s: f64 = @floatCast(@sqrt(z));
+    const x_local: f32 = @floatCast(pio2 - 2.0 * (s + s * @as(f64, @floatCast(rationalApproxBinary32(z)))));
+    return if (hx >> 31 != 0) -x_local else x_local;
 }
 
-fn r64(z: f64) f64 {
+fn rationalApproxBinary64(z: f64) f64 {
     const pS0: f64 = 1.66666666666666657415e-01;
     const pS1: f64 = -3.25565818622400915405e-01;
     const pS2: f64 = 2.01212532134862925881e-01;
@@ -88,96 +131,307 @@ fn r64(z: f64) f64 {
     return p / q;
 }
 
-fn asin64(x: f64) f64 {
+fn asinBinary64(x: f64) f64 {
     const pio2_hi: f64 = 1.57079632679489655800e+00;
     const pio2_lo: f64 = 6.12323399573676603587e-17;
 
-    const ux = @as(u64, @bitCast(x));
-    const hx = @as(u32, @intCast(ux >> 32));
-    const ix = hx & 0x7FFFFFFF;
+    const hx: u32 = @intCast(@as(u64, @bitCast(x)) >> 32);
+    const ix = hx & 0x7fffffff;
 
     // |x| >= 1 or nan
-    if (ix >= 0x3FF00000) {
-        const lx = @as(u32, @intCast(ux & 0xFFFFFFFF));
-
+    if (ix >= 0x3ff0_0000) {
+        const lx: u32 = @truncate(@as(u64, @bitCast(x)));
         // asin(1) = +-pi/2 with inexact
-        if ((ix - 0x3FF00000) | lx == 0) {
+        if ((ix - 0x3ff0_0000 | lx) == 0) {
             return x * pio2_hi + 0x1.0p-120;
-        } else {
-            return math.nan(f64);
         }
+        return 0.0 / (x - x);
     }
 
     // |x| < 0.5
-    if (ix < 0x3FE00000) {
+    if (ix < 0x3fe0_0000) {
         // if 0x1p-1022 <= |x| < 0x1p-26 avoid raising overflow
-        if (ix < 0x3E500000 and ix >= 0x00100000) {
+        if (ix < 0x3e50_0000 and ix >= 0x0010_0000) {
             return x;
-        } else {
-            return x + x * r64(x * x);
         }
+        return x + x * rationalApproxBinary64(x * x);
     }
 
     // 1 > |x| >= 0.5
-    const z = (1 - @abs(x)) * 0.5;
+    const z = (1.0 - @abs(x)) * 0.5;
     const s = @sqrt(z);
-    const r = r64(z);
-    var fx: f64 = undefined;
-
+    const r = rationalApproxBinary64(z);
     // |x| > 0.975
-    if (ix >= 0x3FEF3333) {
-        fx = pio2_hi - 2 * (s + s * r);
-    } else {
-        const jx = @as(u64, @bitCast(s));
-        const df = @as(f64, @bitCast(jx & 0xFFFFFFFF00000000));
-        const c = (z - df * df) / (s + df);
-        fx = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * df));
+    if (ix >= 0x3fef_3333) {
+        const x_local = pio2_hi - (2 * (s + s * r) - pio2_lo);
+        return if (hx >> 31 != 0) -x_local else x_local;
+    }
+    // f+c = sqrt(z)
+    const hs: u64 = @bitCast(s);
+    const f: f64 = @bitCast(hs & 0xffff_ffff_0000_0000);
+    const c: f64 = (z - f * f) / (s + f);
+    const x_local = 0.5 * pio2_hi - (2.0 * s * r - (pio2_lo - 2.0 * c) - (0.5 * pio2_hi - 2.0 * f));
+    return if (hx >> 31 != 0) -x_local else x_local;
+}
+
+fn rationalApproxExtended80(z: f80) f80 {
+    const pS0: f80 = 1.66666666666666666631e-01;
+    const pS1: f80 = -4.16313987993683104320e-01;
+    const pS2: f80 = 3.69068046323246813704e-01;
+    const pS3: f80 = -1.36213932016738603108e-01;
+    const pS4: f80 = 1.78324189708471965733e-02;
+    const pS5: f80 = -2.19216428382605211588e-04;
+    const pS6: f80 = -7.10526623669075243183e-06;
+    const qS1: f80 = -2.94788392796209867269e+00;
+    const qS2: f80 = 3.27309890266528636716e+00;
+    const qS3: f80 = -1.68285799854822427013e+00;
+    const qS4: f80 = 3.90699412641738801874e-01;
+    const qS5: f80 = -3.14365703596053263322e-02;
+
+    const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * (pS5 + z * pS6))))));
+    const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * (qS4 + z * qS5))));
+    return p / q;
+}
+
+fn asinExtended80(x: f80) f80 {
+    const pio2_hi: f80 = 1.57079632679489661926;
+    const pio2_lo: f80 = -2.50827880633416601173e-20;
+
+    const hx: u80 = @bitCast(x);
+    const se: u16 = @truncate(hx >> 64);
+    const e = se & 0x7fff;
+    const sign = se >> 15 != 0;
+
+    // |x| >= 1 or nan
+    if (e >= 0x3fff) {
+        // asin(+-1)=+-pi/2 with inexact
+        if (x == 1.0 or x == -1.0) {
+            return x * pio2_hi + 0x1p-120;
+        }
+        return 0.0 / (x - x);
+    }
+
+    // |x| < 0.5
+    if (e < 0x3fff - 1) {
+        if (e < 0x3fff - (math.floatMantissaBits(f80) + 1) / 2) {
+            // return x with inexact if x!=0
+            mem.doNotOptimizeAway(x + 0x1p120);
+            return x;
+        }
+        return x + x * rationalApproxExtended80(x * x);
+    }
+
+    // 1 > |x| >= 0.5
+    const z = (1.0 - @abs(x)) * 0.5;
+    const s = @sqrt(z);
+    const r = rationalApproxExtended80(z);
+
+    const m: u64 = @truncate(hx & 0x0000_ffff_ffff_ffff_ffff);
+    if ((m >> 56) >= 0xf7) {
+        const x_local = pio2_hi - (2.0 * (s + s * r) - pio2_lo);
+        return if (sign) -x_local else x_local;
+    }
+
+    const hs: u80 = @bitCast(s);
+    const f: f80 = @bitCast(hs & 0xffff_ffff_ffff_0000_0000);
+    const c = (z - f * f) / (s + f);
+    const x_local = 0.5 * pio2_hi - (2.0 * s * r - (pio2_lo - 2.0 * c) - (0.5 * pio2_hi - 2.0 * f));
+    return if (sign) -x_local else x_local;
+}
+
+fn rationalApproxBinary128(z: f128) f128 {
+    const pS0: f128 = 1.66666666666666666666666666666700314e-01;
+    const pS1: f128 = -7.32816946414566252574527475428622708e-01;
+    const pS2: f128 = 1.34215708714992334609030036562143589e+00;
+    const pS3: f128 = -1.32483151677116409805070261790752040e+00;
+    const pS4: f128 = 7.61206183613632558824485341162121989e-01;
+    const pS5: f128 = -2.56165783329023486777386833928147375e-01;
+    const pS6: f128 = 4.80718586374448793411019434585413855e-02;
+    const pS7: f128 = -4.42523267167024279410230886239774718e-03;
+    const pS8: f128 = 1.44551535183911458253205638280410064e-04;
+    const pS9: f128 = -2.10558957916600254061591040482706179e-07;
+    const qS1: f128 = -4.84690167848739751544716485245697428e+00;
+    const qS2: f128 = 9.96619113536172610135016921140206980e+00;
+    const qS3: f128 = -1.13177895428973036660836798461641458e+01;
+    const qS4: f128 = 7.74004374389488266169304117714658761e+00;
+    const qS5: f128 = -3.25871986053534084709023539900339905e+00;
+    const qS6: f128 = 8.27830318881232209752469022352928864e-01;
+    const qS7: f128 = -1.18768052702942805423330715206348004e-01;
+    const qS8: f128 = 8.32600764660522313269101537926539470e-03;
+    const qS9: f128 = -1.99407384882605586705979504567947007e-04;
+
+    const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * (pS5 + z * (pS6 + z * (pS7 + z * (pS8 + z * pS9)))))))));
+    const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * (qS4 + z * (qS5 + z * (qS6 + z * (qS7 + z * (qS8 + z * qS9))))))));
+    return p / q;
+}
+
+fn asinBinary128(x: f128) f128 {
+    const pio2_hi: f128 = 1.57079632679489661923132169163975140;
+    const pio2_lo: f128 = 4.33590506506189051239852201302167613e-35;
+
+    const hx: u128 = @bitCast(x);
+    const se: u16 = @truncate(hx >> 112);
+    const e = se & 0x7fff;
+    const sign = se >> 15 != 0;
+
+    // |x| >= 1 or nan
+    if (e >= 0x3fff) {
+        // asin(+-1)=+-pi/2 with inexact
+        if (x == 1.0 or x == -1.0) {
+            return x * pio2_hi + 0x1p-120;
+        }
+        return 0.0 / (x - x);
     }
 
-    if (hx >> 31 != 0) {
-        return -fx;
-    } else {
-        return fx;
+    // |x| < 0.5
+    if (e < 0x3fff - 1) {
+        if (e < 0x3fff - (math.floatMantissaBits(f128) + 2) / 2) {
+            // return x with inexact if x!=0
+            mem.doNotOptimizeAway(x + 0x1p120);
+            return x;
+        }
+        return x + x * rationalApproxBinary128(x * x);
     }
+
+    // 1 > |x| >= 0.5
+    const z = (1.0 - @abs(x)) * 0.5;
+    const s = @sqrt(z);
+    const r = rationalApproxBinary128(z);
+
+    const top: u16 = @truncate((hx >> 96) & 0x0000_ffff);
+    if (top >= 0xee00) {
+        const x_local = pio2_hi - (2.0 * (s + s * r) - pio2_lo);
+        return if (sign) -x_local else x_local;
+    }
+
+    const hs: u128 = @bitCast(s);
+    const f: f128 = @bitCast(hs & 0xffff_ffff_ffff_ffff_0000_0000_0000_0000);
+    const c = (z - f * f) / (s + f);
+    const x_local = 0.5 * pio2_hi - (2.0 * s * r - (pio2_lo - 2.0 * c) - (0.5 * pio2_hi - 2.0 * f));
+    return if (sign) -x_local else x_local;
 }
 
-test asin {
-    try expect(asin(@as(f32, 0.0)) == asin32(0.0));
-    try expect(asin(@as(f64, 0.0)) == asin64(0.0));
+test "asinBinary16.special" {
+    try testing.expectApproxEqAbs(asinBinary16(0x1p+0), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
+    try testing.expectApproxEqAbs(asinBinary16(-0x1p+0), -0x1.92p0, math.floatEpsAt(f16, -0x1.92p0));
+    try testing.expectEqual(asinBinary16(0x0p+0), 0x0p+0);
+    try testing.expectEqual(asinBinary16(-0x0p+0), 0x0p+0);
+    try testing.expect(math.isNan(asinBinary16(0x1.004p0)));
+    try testing.expect(math.isNan(asinBinary16(-0x1.004p0)));
+    try testing.expect(math.isNan(asinBinary16(math.inf(f16))));
+    try testing.expect(math.isNan(asinBinary16(-math.inf(f16))));
+    try testing.expect(math.isNan(asinBinary16(math.nan(f16))));
 }
 
-test asin32 {
-    const epsilon = 0.000001;
+test "asinBinary16" {
+    try testing.expectApproxEqAbs(asinBinary16(-0x1.e4cp-6), -0x1.e4cp-6, math.floatEpsAt(f16, -0x1.e4cp-6));
+    try testing.expectApproxEqAbs(asinBinary16(0x1.d68p-1), 0x1.2a8p0, math.floatEpsAt(f16, 0x1.2a8p0));
+    try testing.expectApproxEqAbs(asinBinary16(-0x1.a4cp-1), -0x1.eep-1, math.floatEpsAt(f16, -0x1.eep-1));
+    try testing.expectApproxEqAbs(asinBinary16(-0x1.0a4p-2), -0x1.0d4p-2, math.floatEpsAt(f16, -0x1.0d4p-2));
+    try testing.expectApproxEqAbs(asinBinary16(0x1.28cp-1), 0x1.3c8p-1, math.floatEpsAt(f16, 0x1.3c8p-1));
+    try testing.expectApproxEqAbs(asinBinary16(0x1.284p-3), 0x1.298p-3, math.floatEpsAt(f16, 0x1.298p-3));
+    try testing.expectApproxEqAbs(asinBinary16(-0x1.574p-1), -0x1.784p-1, math.floatEpsAt(f16, -0x1.784p-1));
+    try testing.expectApproxEqAbs(asinBinary16(-0x1.4ccp-1), -0x1.6a4p-1, math.floatEpsAt(f16, -0x1.6a4p-1));
+    try testing.expectApproxEqAbs(asinBinary16(0x1.a18p-1), 0x1.e84p-1, math.floatEpsAt(f16, 0x1.e84p-1));
+    try testing.expectApproxEqAbs(asinBinary16(0x1.7a8p-2), 0x1.83cp-2, math.floatEpsAt(f16, 0x1.83cp-2));
+}
+
+test "asinBinary32.special" {
+    try testing.expectApproxEqAbs(asinBinary32(0x1p+0), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(asinBinary32(-0x1p+0), -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expectEqual(asinBinary32(0x0p+0), 0x0p+0);
+    try testing.expectEqual(asinBinary32(-0x0p+0), 0x0p+0);
+    try testing.expect(math.isNan(asinBinary32(0x1.000002p+0)));
+    try testing.expect(math.isNan(asinBinary32(-0x1.000002p+0)));
+    try testing.expect(math.isNan(asinBinary32(math.inf(f32))));
+    try testing.expect(math.isNan(asinBinary32(-math.inf(f32))));
+    try testing.expect(math.isNan(asinBinary32(math.nan(f32))));
+}
+
+test "asinBinary32" {
+    try testing.expectApproxEqAbs(asinBinary32(-0x1.4c2906p-4), -0x1.4c868p-4, math.floatEpsAt(f32, -0x1.4c868p-4));
+    try testing.expectApproxEqAbs(asinBinary32(0x1.05fcfap-1), 0x1.130648p-1, math.floatEpsAt(f32, 0x1.130648p-1));
+    try testing.expectApproxEqAbs(asinBinary32(0x1.fab976p-2), 0x1.090abcp-1, math.floatEpsAt(f32, 0x1.090abcp-1));
+    try testing.expectApproxEqAbs(asinBinary32(0x1.8b4b8cp-1), 0x1.c39fa2p-1, math.floatEpsAt(f32, 0x1.c39fa2p-1));
+    try testing.expectApproxEqAbs(asinBinary32(0x1.7117c2p-1), 0x1.9c332p-1, math.floatEpsAt(f32, 0x1.9c332p-1));
+    try testing.expectApproxEqAbs(asinBinary32(0x1.e5e112p-5), 0x1.e62a1cp-5, math.floatEpsAt(f32, 0x1.e62a1cp-5));
+    try testing.expectApproxEqAbs(asinBinary32(-0x1.07673p-2), -0x1.0a65dep-2, math.floatEpsAt(f32, -0x1.0a65dep-2));
+    try testing.expectApproxEqAbs(asinBinary32(-0x1.2108dep-2), -0x1.25046p-2, math.floatEpsAt(f32, -0x1.25046p-2));
+    try testing.expectApproxEqAbs(asinBinary32(-0x1.4e6e6cp-1), -0x1.6c6f0cp-1, math.floatEpsAt(f32, -0x1.6c6f0cp-1));
+    try testing.expectApproxEqAbs(asinBinary32(0x1.22a16ap-1), 0x1.350f7ap-1, math.floatEpsAt(f32, 0x1.350f7ap-1));
+}
+
+test "asinBinary64.special" {
+    try testing.expectApproxEqAbs(asinBinary64(0x1p+0), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1p+0), -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expectEqual(asinBinary64(0x0p+0), 0x0p+0);
+    try testing.expectEqual(asinBinary64(-0x0p+0), 0x0p+0);
+    try testing.expect(math.isNan(asinBinary64(0x1.000002p+0)));
+    try testing.expect(math.isNan(asinBinary64(-0x1.000002p+0)));
+    try testing.expect(math.isNan(asinBinary64(math.inf(f64))));
+    try testing.expect(math.isNan(asinBinary64(-math.inf(f64))));
+    try testing.expect(math.isNan(asinBinary64(math.nan(f64))));
+}
 
-    try expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon));
-    try expect(math.approxEqAbs(f32, asin32(0.2), 0.201358, epsilon));
-    try expect(math.approxEqAbs(f32, asin32(-0.2), -0.201358, epsilon));
-    try expect(math.approxEqAbs(f32, asin32(0.3434), 0.350535, epsilon));
-    try expect(math.approxEqAbs(f32, asin32(0.5), 0.523599, epsilon));
-    try expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon));
+test "asinBinary64" {
+    try testing.expectApproxEqAbs(asinBinary64(0x1.e674fba3e40d5p-2), 0x1.fae86c5941692p-2, math.floatEpsAt(f64, 0x1.fae86c5941692p-2));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.30fd0566fd979p-1), -0x1.46b6ad730c93ap-1, math.floatEpsAt(f64, -0x1.46b6ad730c93ap-1));
+    try testing.expectApproxEqAbs(asinBinary64(0x1.6444a25abfeaap-2), 0x1.6be0be8074eep-2, math.floatEpsAt(f64, 0x1.6be0be8074eep-2));
+    try testing.expectApproxEqAbs(asinBinary64(0x1.40a53228d1a13p-1), 0x1.5a7e98f53f717p-1, math.floatEpsAt(f64, 0x1.5a7e98f53f717p-1));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.ccc6d64845cfdp-1), -0x1.1ea2602d14e8p0, math.floatEpsAt(f64, -0x1.1ea2602d14e8p0));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.94bd91b7fc74bp-1), -0x1.d2c2634193158p-1, math.floatEpsAt(f64, -0x1.d2c2634193158p-1));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.8d741b5797fccp-2), -0x1.982d5f1895d2p-2, math.floatEpsAt(f64, -0x1.982d5f1895d2p-2));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.3e8e7e15881c5p-3), -0x1.3fdaf7dfdc864p-3, math.floatEpsAt(f64, -0x1.3fdaf7dfdc864p-3));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.88222d8ab8ca9p-2), -0x1.9269540735b7bp-2, math.floatEpsAt(f64, -0x1.9269540735b7bp-2));
+    try testing.expectApproxEqAbs(asinBinary64(-0x1.41c0e9babcbd2p-2), -0x1.474c4c6625527p-2, math.floatEpsAt(f64, -0x1.474c4c6625527p-2));
 }
 
-test asin64 {
-    const epsilon = 0.000001;
+test "asinExtended80.special" {
+    try testing.expectApproxEqAbs(asinExtended80(0x1p+0), 0x1.921fb54442d1846ap+0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap+0));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1p+0), -0x1.921fb54442d1846ap+0, math.floatEpsAt(f80, -0x1.921fb54442d1846ap+0));
+    try testing.expectEqual(asinExtended80(0x0p+0), 0x0p+0);
+    try testing.expectEqual(asinExtended80(-0x0p+0), 0x0p+0);
+    try testing.expect(math.isNan(asinExtended80(0x1.0000000000000002p+0)));
+    try testing.expect(math.isNan(asinExtended80(-0x1.0000000000000002p+0)));
+    try testing.expect(math.isNan(asinExtended80(math.inf(f80))));
+    try testing.expect(math.isNan(asinExtended80(-math.inf(f80))));
+    try testing.expect(math.isNan(asinExtended80(math.nan(f80))));
+}
 
-    try expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon));
-    try expect(math.approxEqAbs(f64, asin64(0.2), 0.201358, epsilon));
-    try expect(math.approxEqAbs(f64, asin64(-0.2), -0.201358, epsilon));
-    try expect(math.approxEqAbs(f64, asin64(0.3434), 0.350535, epsilon));
-    try expect(math.approxEqAbs(f64, asin64(0.5), 0.523599, epsilon));
-    try expect(math.approxEqAbs(f64, asin64(0.8923), 1.102415, epsilon));
+test "asinExtended80" {
+    try testing.expectApproxEqAbs(asinExtended80(0x1.63cf98bc52ce0da8p-9), 0x1.63cfb560149daa9p-9, math.floatEpsAt(f80, 0x1.63cfb560149daa9p-9));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.0473756f7ae930dp-1), -0x1.113cbacd8cd1b96cp-1, math.floatEpsAt(f80, -0x1.113cbacd8cd1b96cp-1));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.2310057e005cc288p-2), -0x1.2721b231d197b064p-2, math.floatEpsAt(f80, -0x1.2721b231d197b064p-2));
+    try testing.expectApproxEqAbs(asinExtended80(0x1.f13b03bd685d96eap-1), 0x1.547c408c5d2b05aap0, math.floatEpsAt(f80, 0x1.547c408c5d2b05aap0));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.d5c507e3ef84041cp-1), -0x1.296b76bfadbb5cecp0, math.floatEpsAt(f80, -0x1.296b76bfadbb5cecp0));
+    try testing.expectApproxEqAbs(asinExtended80(0x1.8222cbc9147153d8p-1), 0x1.b572da8729a84f2ap-1, math.floatEpsAt(f80, 0x1.b572da8729a84f2ap-1));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.42c9e6b4a088a246p-11), -0x1.42c9e80ac0524dap-11, math.floatEpsAt(f80, -0x1.42c9e80ac0524dap-11));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.8f78d49deadb521cp-3), -0x1.920ca86aef6c3028p-3, math.floatEpsAt(f80, -0x1.920ca86aef6c3028p-3));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.ab98792783515774p-2), -0x1.b91cb4f7204d92fp-2, math.floatEpsAt(f80, -0x1.b91cb4f7204d92fp-2));
+    try testing.expectApproxEqAbs(asinExtended80(-0x1.104fe30cef6800aap-1), -0x1.1f20815fdc4c5304p-1, math.floatEpsAt(f80, -0x1.1f20815fdc4c5304p-1));
 }
 
-test "asin32.special" {
-    try expect(math.isPositiveZero(asin32(0.0)));
-    try expect(math.isNegativeZero(asin32(-0.0)));
-    try expect(math.isNan(asin32(-2)));
-    try expect(math.isNan(asin32(1.5)));
+test "asinBinary128.special" {
+    try testing.expectApproxEqAbs(asinBinary128(0x1p+0), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1p+0), -0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectEqual(asinBinary128(0x0p+0), 0x0p+0);
+    try testing.expectEqual(asinBinary128(-0x0p+0), 0x0p+0);
+    try testing.expect(math.isNan(asinBinary128(0x1.0000000000000000000000000001p0)));
+    try testing.expect(math.isNan(asinBinary128(-0x1.0000000000000000000000000001p0)));
+    try testing.expect(math.isNan(asinBinary128(math.inf(f128))));
+    try testing.expect(math.isNan(asinBinary128(-math.inf(f128))));
+    try testing.expect(math.isNan(asinBinary128(math.nan(f128))));
 }
 
-test "asin64.special" {
-    try expect(math.isPositiveZero(asin64(0.0)));
-    try expect(math.isNegativeZero(asin64(-0.0)));
-    try expect(math.isNan(asin64(-2)));
-    try expect(math.isNan(asin64(1.5)));
+test "asinBinary128" {
+    try testing.expectApproxEqAbs(asinBinary128(0x1.85868ce287ca0196b01c25fec5ffp-3), 0x1.87e9c740d7837f8e8fa667988fbep-3, math.floatEpsAt(f128, 0x1.87e9c740d7837f8e8fa667988fbep-3));
+    try testing.expectApproxEqAbs(asinBinary128(0x1.8718d6d30b4daed08d04ef59f478p-1), 0x1.bd11a474e864213b48e0f005f1f4p-1, math.floatEpsAt(f128, 0x1.bd11a474e864213b48e0f005f1f4p-1));
+    try testing.expectApproxEqAbs(asinBinary128(0x1.11a67640cd7f0ba5d5e362f3abfap-1), 0x1.20b56f8b42649fe72d1f8d68a378p-1, math.floatEpsAt(f128, 0x1.20b56f8b42649fe72d1f8d68a378p-1));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1.bd13bf14a9dce22188e52650daa7p-1), -0x1.0dc3a7ddb9736e5ad699bf338566p0, math.floatEpsAt(f128, -0x1.0dc3a7ddb9736e5ad699bf338566p0));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1.dee0bc217fc462af57c484eefa71p-2), -0x1.f250716038f70fa50a5826c03802p-2, math.floatEpsAt(f128, -0x1.f250716038f70fa50a5826c03802p-2));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1.ea7df9139371c10b9d6fd2bbccd3p-1), -0x1.47a8b4cdd327f90056722feddbabp0, math.floatEpsAt(f128, -0x1.47a8b4cdd327f90056722feddbabp0));
+    try testing.expectApproxEqAbs(asinBinary128(0x1.04aaea6de3b5a616460702f26dfcp-2), 0x1.079178d52be662dec67e2cd7f6e9p-2, math.floatEpsAt(f128, 0x1.079178d52be662dec67e2cd7f6e9p-2));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1.c7ea85e6b61be666435a7d99444cp-1), -0x1.192df5a8d71702cf1e27014887b2p0, math.floatEpsAt(f128, -0x1.192df5a8d71702cf1e27014887b2p0));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1.6e210214e40edf6c8479998189d1p-1), -0x1.97f1092fd94ac0fdfddae2e1222bp-1, math.floatEpsAt(f128, -0x1.97f1092fd94ac0fdfddae2e1222bp-1));
+    try testing.expectApproxEqAbs(asinBinary128(-0x1.95061bf93ed6986a45d20f0e1064p-3), -0x1.97b62bc5ae6512093828828325e1p-3, math.floatEpsAt(f128, -0x1.97b62bc5ae6512093828828325e1p-3));
 }
-- 
2.54.0


From 57742480414b2060411b0b07f258e9187b4e8ca0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 15:32:40 -0800
Subject: [PATCH 067/499] std.os.windows: delete unused CreateSymbolicLink

---
 lib/std/Io/Threaded.zig |   3 +-
 lib/std/os/windows.zig  | 117 ----------------------------------------
 2 files changed, 1 insertion(+), 119 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 38f6199f464933112ae6987e13852585805e0428..16608c50a9bdbca1a73817642705f9420b162cfa 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -6353,8 +6353,7 @@ fn dirSymLinkWindows(
 
     // Target path does not use sliceToPrefixedFileW because certain paths
     // are handled differently when creating a symlink than they would be
-    // when converting to an NT namespaced path. CreateSymbolicLink in
-    // symLinkW will handle the necessary conversion.
+    // when converting to an NT namespaced path.
     var target_path_w: w.PathSpace = undefined;
     target_path_w.len = try w.wtf8ToWtf16Le(&target_path_w.data, target_path);
     target_path_w.data[target_path_w.len] = 0;
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 262eaef049a0a6cb198b70195ad85f8356916346..7414ec060876b4b837d05dbc15fba9345b66a9fa 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -2908,123 +2908,6 @@ pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
     return buffer[0..end_index];
 }
 
-pub const CreateSymbolicLinkError = error{
-    AccessDenied,
-    PathAlreadyExists,
-    FileNotFound,
-    NameTooLong,
-    NoDevice,
-    NetworkNotFound,
-    BadPathName,
-    Unexpected,
-};
-
-/// Needs either:
-/// - `SeCreateSymbolicLinkPrivilege` privilege
-/// or
-/// - Developer mode on Windows 10
-/// otherwise fails with `error.AccessDenied`. In which case `sym_link_path` may still
-/// be created on the file system but will lack reparse processing data applied to it.
-pub fn CreateSymbolicLink(
-    dir: ?HANDLE,
-    sym_link_path: []const u16,
-    target_path: [:0]const u16,
-    is_directory: bool,
-) CreateSymbolicLinkError!void {
-    const SYMLINK_DATA = extern struct {
-        ReparseTag: IO_REPARSE_TAG,
-        ReparseDataLength: USHORT,
-        Reserved: USHORT,
-        SubstituteNameOffset: USHORT,
-        SubstituteNameLength: USHORT,
-        PrintNameOffset: USHORT,
-        PrintNameLength: USHORT,
-        Flags: ULONG,
-    };
-
-    const symlink_handle = OpenFile(sym_link_path, .{
-        .access_mask = .{
-            .STANDARD = .{ .SYNCHRONIZE = true },
-            .GENERIC = .{ .WRITE = true, .READ = true },
-        },
-        .dir = dir,
-        .creation = .CREATE,
-        .filter = if (is_directory) .dir_only else .non_directory_only,
-    }) catch |err| switch (err) {
-        error.IsDir => return error.PathAlreadyExists,
-        error.NotDir => return error.Unexpected,
-        error.WouldBlock => return error.Unexpected,
-        error.PipeBusy => return error.Unexpected,
-        error.NoDevice => return error.Unexpected,
-        error.AntivirusInterference => return error.Unexpected,
-        else => |e| return e,
-    };
-    defer CloseHandle(symlink_handle);
-
-    // Relevant portions of the documentation:
-    // > Relative links are specified using the following conventions:
-    // > - Root relative—for example, "\Windows\System32" resolves to "current drive:\Windows\System32".
-    // > - Current working directory–relative—for example, if the current working directory is
-    // >   C:\Windows\System32, "C:File.txt" resolves to "C:\Windows\System32\File.txt".
-    // > Note: If you specify a current working directory–relative link, it is created as an absolute
-    // > link, due to the way the current working directory is processed based on the user and the thread.
-    // https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createsymboliclinkw
-    var is_target_absolute = false;
-    const final_target_path = target_path: {
-        if (hasCommonNtPrefix(u16, target_path)) {
-            // Already an NT path, no need to do anything to it
-            break :target_path target_path;
-        } else {
-            switch (std.fs.path.getWin32PathType(u16, target_path)) {
-                // Rooted paths need to avoid getting put through wToPrefixedFileW
-                // (and they are treated as relative in this context)
-                // Note: It seems that rooted paths in symbolic links are relative to
-                //       the drive that the symbolic exists on, not to the CWD's drive.
-                //       So, if the symlink is on C:\ and the CWD is on D:\,
-                //       it will still resolve the path relative to the root of
-                //       the C:\ drive.
-                .rooted => break :target_path target_path,
-                // Keep relative paths relative, but anything else needs to get NT-prefixed.
-                else => if (!std.fs.path.isAbsoluteWindowsWtf16(target_path))
-                    break :target_path target_path,
-            }
-        }
-        var prefixed_target_path = try wToPrefixedFileW(dir, target_path);
-        // We do this after prefixing to ensure that drive-relative paths are treated as absolute
-        is_target_absolute = std.fs.path.isAbsoluteWindowsWtf16(prefixed_target_path.span());
-        break :target_path prefixed_target_path.span();
-    };
-
-    // prepare reparse data buffer
-    var buffer: [MAXIMUM_REPARSE_DATA_BUFFER_SIZE]u8 = undefined;
-    const buf_len = @sizeOf(SYMLINK_DATA) + final_target_path.len * 4;
-    const header_len = @sizeOf(ULONG) + @sizeOf(USHORT) * 2;
-    const target_is_absolute = std.fs.path.isAbsoluteWindowsWtf16(final_target_path);
-    const symlink_data: SYMLINK_DATA = .{
-        .ReparseTag = .SYMLINK,
-        .ReparseDataLength = @intCast(buf_len - header_len),
-        .Reserved = 0,
-        .SubstituteNameOffset = @intCast(final_target_path.len * 2),
-        .SubstituteNameLength = @intCast(final_target_path.len * 2),
-        .PrintNameOffset = 0,
-        .PrintNameLength = @intCast(final_target_path.len * 2),
-        .Flags = if (!target_is_absolute) SYMLINK_FLAG_RELATIVE else 0,
-    };
-
-    @memcpy(buffer[0..@sizeOf(SYMLINK_DATA)], std.mem.asBytes(&symlink_data));
-    @memcpy(buffer[@sizeOf(SYMLINK_DATA)..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
-    const paths_start = @sizeOf(SYMLINK_DATA) + final_target_path.len * 2;
-    @memcpy(buffer[paths_start..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
-    const rc = DeviceIoControl(symlink_handle, FSCTL.SET_REPARSE_POINT, .{ .in = buffer[0..buf_len] });
-    switch (rc) {
-        .SUCCESS => {},
-        .PRIVILEGE_NOT_HELD => return error.AccessDenied,
-        .ACCESS_DENIED => return error.AccessDenied,
-        .INVALID_DEVICE_REQUEST => return error.AccessDenied, // Not supported by the underlying filesystem
-        else => return unexpectedStatus(rc),
-    }
-}
-
 pub const ReadLinkError = error{
     FileNotFound,
     NetworkNotFound,
-- 
2.54.0


From 18c6abc0ba9a58a3d25908c47df3bb9374d51c35 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 16:18:43 -0800
Subject: [PATCH 068/499] std: finish moving os.windows.ReadLink logic to
 Io.Threaded

- remove error.SharingViolation from all error sets since it has the
  same meaning as FileBusy
- add error.FileBusy to CreateFileAtomicError and ReadLinkError
- update dirReadLinkWindows to use NtCreateFile and NtFsControlFile and
  integrate with cancelation properly.
- move windows CTL_CODE constants to the proper namespace
- delete os.windows.ReadLink
---
 lib/std/Io/Dir.zig                 |   6 +-
 lib/std/Io/File.zig                |   3 +-
 lib/std/Io/Threaded.zig            | 273 +++++++++++++++++++++--------
 lib/std/debug/SelfInfo/Windows.zig |   1 -
 lib/std/os/windows.zig             | 104 ++---------
 lib/std/process.zig                |   1 -
 lib/std/zig/system.zig             |   3 +-
 7 files changed, 218 insertions(+), 173 deletions(-)

diff --git a/lib/std/Io/Dir.zig b/lib/std/Io/Dir.zig
index 425e220b1cfdb3d16980a29b394527ccc355cbcf..85ab6b77d4990420c32086efaf634dc0fc830938 100644
--- a/lib/std/Io/Dir.zig
+++ b/lib/std/Io/Dir.zig
@@ -940,6 +940,7 @@ pub const RenameError = error{
     /// Attempted to replace a nonempty directory.
     DirNotEmpty,
     PermissionDenied,
+    /// The file attempted to be moved or replaced is a running executable.
     FileBusy,
     DiskQuota,
     IsDir,
@@ -952,7 +953,6 @@ pub const RenameError = error{
     ReadOnlyFileSystem,
     CrossDevice,
     NoDevice,
-    SharingViolation,
     PipeBusy,
     /// On Windows, `\\server` or `\\server\share` was not found.
     NetworkNotFound,
@@ -1167,6 +1167,8 @@ pub const ReadLinkError = error{
     /// intercepts file system operations and makes them significantly slower
     /// in addition to possibly failing with this error code.
     AntivirusInterference,
+    /// File attempted to be opened is a running executable.
+    FileBusy,
 } || PathNameError || Io.Cancelable || Io.UnexpectedError;
 
 /// Obtain target of a symbolic link.
@@ -1791,6 +1793,8 @@ pub const CreateFileAtomicError = error{
     NotDir,
     WouldBlock,
     ReadOnlyFileSystem,
+    /// The file attempted to be created is a running executable.
+    FileBusy,
 } || Io.Dir.PathNameError || Io.Cancelable || Io.UnexpectedError;
 
 /// Create an unnamed ephemeral file that can eventually be atomically
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index 6323a39454194e58be8a53e4f8f9879cfc1daa0e..e537755a3365de8bab78d79fb55a40da0c33fe03 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -249,7 +249,6 @@ pub const CreateFlags = struct {
 };
 
 pub const OpenError = error{
-    SharingViolation,
     PipeBusy,
     NoDevice,
     /// On Windows, `\\server` or `\\server\share` was not found.
@@ -757,7 +756,7 @@ pub const RealPathError = error{
     NoSpaceLeft,
     FileSystem,
     DeviceBusy,
-    SharingViolation,
+    FileBusy,
     PipeBusy,
     /// On Windows, `\\server` or `\\server\share` was not found.
     NetworkNotFound,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 16608c50a9bdbca1a73817642705f9420b162cfa..01bcacbc2989d5610f01df7a37041623b5262077 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3635,7 +3635,7 @@ fn dirCreateFileWindows(
             // after an executable file is closed. Here we work around the
             // kernel bug with retry attempts.
             syscall.finish();
-            if (max_attempts - attempt == 0) return error.SharingViolation;
+            if (max_attempts - attempt == 0) return error.FileBusy;
             try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
             attempt += 1;
             syscall = try .start();
@@ -3648,7 +3648,7 @@ fn dirCreateFileWindows(
             // call has failed. Here, we simulate the kernel bug being
             // fixed by sleeping and retrying until the error goes away.
             syscall.finish();
-            if (max_attempts - attempt == 0) return error.SharingViolation;
+            if (max_attempts - attempt == 0) return error.FileBusy;
             try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
             attempt += 1;
             syscall = try .start();
@@ -3668,10 +3668,10 @@ fn dirCreateFileWindows(
         .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
         .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
         .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
-        .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err),
-        .OBJECT_PATH_SYNTAX_BAD => |err| return syscall.ntstatusBug(err),
-        .INVALID_HANDLE => |err| return syscall.ntstatusBug(err),
-        else => |err| return syscall.unexpectedNtstatus(err),
+        .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+        .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
+        .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
+        else => |status| return syscall.unexpectedNtstatus(status),
     };
     errdefer windows.CloseHandle(handle);
 
@@ -3819,7 +3819,6 @@ fn dirCreateFileAtomic(
                 error.DiskQuota,
                 error.PathAlreadyExists,
                 error.LinkQuotaExceeded,
-                error.SharingViolation,
                 error.PipeBusy,
                 error.FileTooBig,
                 error.DeviceBusy,
@@ -3889,11 +3888,9 @@ fn dirCreateFileAtomic(
                 error.DiskQuota,
                 error.PathAlreadyExists,
                 error.LinkQuotaExceeded,
-                error.SharingViolation,
                 error.PipeBusy,
                 error.FileTooBig,
                 error.FileLocksUnsupported,
-                error.FileBusy,
                 error.DeviceBusy,
                 => return error.Unexpected,
 
@@ -3926,7 +3923,6 @@ fn atomicFileInit(
             error.PathAlreadyExists => continue,
             error.DeviceBusy => continue,
             error.FileBusy => continue,
-            error.SharingViolation => continue,
 
             error.IsDir => return error.Unexpected, // No path components.
             error.FileTooBig => return error.Unexpected, // Creating, not opening.
@@ -4236,7 +4232,7 @@ pub fn dirOpenFileWtf16(
                 // after an executable file is closed. Here we work around the
                 // kernel bug with retry attempts.
                 syscall.finish();
-                if (max_attempts - attempt == 0) return error.SharingViolation;
+                if (max_attempts - attempt == 0) return error.FileBusy;
                 try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
                 attempt += 1;
                 syscall = try .start();
@@ -4258,7 +4254,7 @@ pub fn dirOpenFileWtf16(
                 // call has failed. Here, we simulate the kernel bug being
                 // fixed by sleeping and retrying until the error goes away.
                 syscall.finish();
-                if (max_attempts - attempt == 0) return error.SharingViolation;
+                if (max_attempts - attempt == 0) return error.FileBusy;
                 try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
                 attempt += 1;
                 syscall = try .start();
@@ -6464,7 +6460,7 @@ fn dirSymLinkWindows(
     @memcpy(buffer[@sizeOf(SYMLINK_DATA)..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
     const paths_start = @sizeOf(SYMLINK_DATA) + final_target_path.len * 2;
     @memcpy(buffer[paths_start..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
-    const rc = w.DeviceIoControl(symlink_handle, w.FSCTL.SET_REPARSE_POINT, .{ .in = buffer[0..buf_len] });
+    const rc = w.DeviceIoControl(symlink_handle, .SET_REPARSE_POINT, .{ .in = buffer[0..buf_len] });
     switch (rc) {
         .SUCCESS => {},
         .PRIVILEGE_NOT_HELD => return error.PermissionDenied,
@@ -6571,44 +6567,189 @@ fn dirSymLinkPosix(
     }
 }
 
-const dirReadLink = switch (native_os) {
-    .windows => dirReadLinkWindows,
-    .wasi => dirReadLinkWasi,
-    else => dirReadLinkPosix,
-};
-
-fn dirReadLinkWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
+fn dirReadLink(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    const w = windows;
+    switch (native_os) {
+        .windows => return dirReadLinkWindows(dir, sub_path, buffer),
+        .wasi => return dirReadLinkWasi(dir, sub_path, buffer),
+        else => return dirReadLinkPosix(dir, sub_path, buffer),
+    }
+}
 
+fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
+    // This gets used once for `sub_path` and then reused again temporarily
+    // before converting back to `buffer`.
     var sub_path_w_buf = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w = sub_path_w_buf.span();
+    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
+    var nt_name: windows.UNICODE_STRING = .{
+        .Length = path_len_bytes,
+        .MaximumLength = path_len_bytes,
+        .Buffer = @constCast(sub_path_w.ptr),
+    };
+    const attr: windows.OBJECT_ATTRIBUTES = .{
+        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
+        .Attributes = .{
+            .INHERIT = false,
+        },
+        .ObjectName = &nt_name,
+        .SecurityDescriptor = null,
+        .SecurityQualityOfService = null,
+    };
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+    var result_handle: windows.HANDLE = undefined;
+
+    // There are multiple kernel bugs being worked around with retries.
+    const max_attempts = 13;
+    var attempt: u5 = 0;
+
+    var syscall: Syscall = try .start();
+    while (true) switch (windows.ntdll.NtCreateFile(
+        &result_handle,
+        .{
+            .SPECIFIC = .{ .FILE = .{
+                .READ_ATTRIBUTES = true,
+            } },
+            .STANDARD = .{ .SYNCHRONIZE = true },
+        },
+        &attr,
+        &io_status_block,
+        null,
+        .{ .NORMAL = true },
+        .VALID_FLAGS,
+        .OPEN,
+        .{
+            .DIRECTORY_FILE = false,
+            .NON_DIRECTORY_FILE = false,
+            .IO = .ASYNCHRONOUS,
+            .OPEN_REPARSE_POINT = true,
+        },
+        null,
+        0,
+    )) {
+        .SUCCESS => {
+            syscall.finish();
+            break;
+        },
+        .CANCELLED => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .SHARING_VIOLATION => {
+            // This occurs if the file attempting to be opened is a running
+            // executable. However, there's a kernel bug: the error may be
+            // incorrectly returned for an indeterminate amount of time
+            // after an executable file is closed. Here we work around the
+            // kernel bug with retry attempts.
+            syscall.finish();
+            if (max_attempts - attempt == 0) return error.FileBusy;
+            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            attempt += 1;
+            syscall = try .start();
+            continue;
+        },
+        .DELETE_PENDING => {
+            // This error means that there *was* a file in this location on
+            // the file system, but it was deleted. However, the OS is not
+            // finished with the deletion operation, and so this CreateFile
+            // call has failed. Here, we simulate the kernel bug being
+            // fixed by sleeping and retrying until the error goes away.
+            syscall.finish();
+            if (max_attempts - attempt == 0) return error.FileBusy;
+            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            attempt += 1;
+            syscall = try .start();
+            continue;
+        },
+        .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
+        .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .BAD_NETWORK_PATH => return syscall.fail(error.NetworkNotFound), // \\server was not found
+        .BAD_NETWORK_NAME => return syscall.fail(error.NetworkNotFound), // \\server was found but \\server\share wasn't
+        .NO_MEDIA_IN_DEVICE => return syscall.fail(error.FileNotFound),
+        .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+        .PIPE_BUSY => return syscall.fail(error.AccessDenied),
+        .PIPE_NOT_AVAILABLE => return syscall.fail(error.FileNotFound),
+        .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
+        .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
+        .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+        .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
+        .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
+        else => |status| return syscall.unexpectedNtstatus(status),
+    };
+    defer windows.CloseHandle(result_handle);
 
-    const syscall: Syscall = try .start();
-    const result_w = while (true) {
-        if (w.ReadLink(dir.handle, sub_path_w_buf.span(), &sub_path_w_buf.data)) |res| {
+    var reparse_buf: [windows.MAXIMUM_REPARSE_DATA_BUFFER_SIZE]u8 align(@alignOf(windows.REPARSE_DATA_BUFFER)) = undefined;
+
+    syscall = try .start();
+    while (true) switch (windows.ntdll.NtFsControlFile(
+        result_handle,
+        null, // event
+        null, // APC routine
+        null, // APC context
+        &io_status_block,
+        .GET_REPARSE_POINT,
+        null, // input buffer
+        0, // input buffer length
+        &reparse_buf,
+        reparse_buf.len,
+    )) {
+        .SUCCESS => {
             syscall.finish();
-            break res;
-        } else |err| switch (err) {
-            error.OperationCanceled => {
-                try syscall.checkCancel();
-                continue;
-            },
-            else => |e| return syscall.fail(e),
-        }
+            break;
+        },
+        .CANCELLED => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .NOT_A_REPARSE_POINT => return syscall.fail(error.NotLink),
+        else => |status| return syscall.unexpectedNtstatus(status),
     };
 
+    const reparse_struct: *const windows.REPARSE_DATA_BUFFER = @ptrCast(@alignCast(&reparse_buf));
+    const IoReparseTagInt = @typeInfo(windows.IO_REPARSE_TAG).@"struct".backing_integer.?;
+    const result_w = switch (@as(IoReparseTagInt, @bitCast(reparse_struct.ReparseTag))) {
+        @as(IoReparseTagInt, @bitCast(windows.IO_REPARSE_TAG.SYMLINK)) => r: {
+            const buf: *const windows.SYMBOLIC_LINK_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
+            const offset = buf.SubstituteNameOffset >> 1;
+            const len = buf.SubstituteNameLength >> 1;
+            const path_buf = @as([*]const u16, &buf.PathBuffer);
+            const is_relative = buf.Flags & windows.SYMLINK_FLAG_RELATIVE != 0;
+            break :r try parseReadLinkPath(path_buf[offset..][0..len], is_relative, &sub_path_w_buf.data);
+        },
+        @as(IoReparseTagInt, @bitCast(windows.IO_REPARSE_TAG.MOUNT_POINT)) => r: {
+            const buf: *const windows.MOUNT_POINT_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
+            const offset = buf.SubstituteNameOffset >> 1;
+            const len = buf.SubstituteNameLength >> 1;
+            const path_buf = @as([*]const u16, &buf.PathBuffer);
+            break :r try parseReadLinkPath(path_buf[offset..][0..len], false, &sub_path_w_buf.data);
+        },
+        else => return error.UnsupportedReparsePointType,
+    };
     const len = std.unicode.calcWtf8Len(result_w);
     if (len > buffer.len) return error.NameTooLong;
 
     return std.unicode.wtf16LeToWtf8(buffer, result_w);
 }
 
-fn dirReadLinkWasi(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
-    if (builtin.link_libc) return dirReadLinkPosix(userdata, dir, sub_path, buffer);
+fn parseReadLinkPath(path: []const u16, is_relative: bool, out_buffer: []u16) error{NameTooLong}![]u16 {
+    path: {
+        if (is_relative) break :path;
+        return windows.ntToWin32Namespace(path, out_buffer) catch |err| switch (err) {
+            error.NameTooLong => |e| return e,
+            error.NotNtPath => break :path,
+        };
+    }
+    if (out_buffer.len < path.len) return error.NameTooLong;
+    const dest = out_buffer[0..path.len];
+    @memcpy(dest, path);
+    return dest;
+}
 
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
+fn dirReadLinkWasi(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
+    if (builtin.link_libc) return dirReadLinkPosix(dir, sub_path, buffer);
 
     var n: usize = undefined;
     const syscall: Syscall = try .start();
@@ -6643,10 +6784,7 @@ fn dirReadLinkWasi(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer
     }
 }
 
-fn dirReadLinkPosix(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-
+fn dirReadLinkPosix(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
     var sub_path_buffer: [posix.PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &sub_path_buffer);
 
@@ -8708,45 +8846,41 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             const symlink_path = std.mem.sliceTo(&symlink_path_buf, 0);
             return Io.Dir.realPathFileAbsolute(ioBasic(t), symlink_path, out_buffer) catch |err| switch (err) {
                 error.NetworkNotFound => unreachable, // Windows-only
+                error.FileBusy => unreachable, // Windows-only
                 else => |e| return e,
             };
         },
         .linux, .serenity => return Io.Dir.readLinkAbsolute(ioBasic(t), "/proc/self/exe", out_buffer) catch |err| switch (err) {
             error.UnsupportedReparsePointType => unreachable, // Windows-only
             error.NetworkNotFound => unreachable, // Windows-only
+            error.FileBusy => unreachable, // Windows-only
             else => |e| return e,
         },
         .illumos => return Io.Dir.readLinkAbsolute(ioBasic(t), "/proc/self/path/a.out", out_buffer) catch |err| switch (err) {
             error.UnsupportedReparsePointType => unreachable, // Windows-only
             error.NetworkNotFound => unreachable, // Windows-only
+            error.FileBusy => unreachable, // Windows-only
             else => |e| return e,
         },
         .freebsd, .dragonfly => {
             var mib: [4]c_int = .{ posix.CTL.KERN, posix.KERN.PROC, posix.KERN.PROC_PATHNAME, -1 };
             var out_len: usize = out_buffer.len;
             const syscall: Syscall = try .start();
-            while (true) {
-                switch (posix.errno(posix.system.sysctl(&mib, mib.len, out_buffer.ptr, &out_len, null, 0))) {
-                    .SUCCESS => {
-                        syscall.finish();
-                        return out_len - 1; // discard terminating NUL
-                    },
-                    .INTR => {
-                        try syscall.checkCancel();
-                        continue;
-                    },
-                    else => |e| {
-                        syscall.finish();
-                        switch (e) {
-                            .FAULT => |err| return errnoBug(err),
-                            .PERM => return error.PermissionDenied,
-                            .NOMEM => return error.SystemResources,
-                            .NOENT => |err| return errnoBug(err),
-                            else => |err| return posix.unexpectedErrno(err),
-                        }
-                    },
-                }
-            }
+            while (true) switch (posix.errno(posix.system.sysctl(&mib, mib.len, out_buffer.ptr, &out_len, null, 0))) {
+                .SUCCESS => {
+                    syscall.finish();
+                    return out_len - 1; // discard terminating NUL
+                },
+                .INTR => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                .PERM => return syscall.fail(error.PermissionDenied),
+                .NOMEM => return syscall.fail(error.SystemResources),
+                .FAULT => |err| return syscall.errnoBug(err),
+                .NOENT => |err| return syscall.errnoBug(err),
+                else => |err| return syscall.unexpectedErrno(err),
+            };
         },
         .netbsd => {
             var mib = [4]c_int{ posix.CTL.KERN, posix.KERN.PROC_ARGS, -1, posix.KERN.PROC_PATHNAME };
@@ -8762,16 +8896,11 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
                         try syscall.checkCancel();
                         continue;
                     },
-                    else => |e| {
-                        syscall.finish();
-                        switch (e) {
-                            .FAULT => |err| return errnoBug(err),
-                            .PERM => return error.PermissionDenied,
-                            .NOMEM => return error.SystemResources,
-                            .NOENT => |err| return errnoBug(err),
-                            else => |err| return posix.unexpectedErrno(err),
-                        }
-                    },
+                    .PERM => return syscall.fail(error.PermissionDenied),
+                    .NOMEM => return syscall.fail(error.SystemResources),
+                    .FAULT => |err| return syscall.errnoBug(err),
+                    .NOENT => |err| return syscall.errnoBug(err),
+                    else => |err| return syscall.unexpectedErrno(err),
                 }
             }
         },
diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig
index 0c81d0012cabe037af3c83bcfa6ea5bb3c4d165b..b26883778dcc803bd3daaf0ce2acae82b55333ef 100644
--- a/lib/std/debug/SelfInfo/Windows.zig
+++ b/lib/std/debug/SelfInfo/Windows.zig
@@ -335,7 +335,6 @@ const Module = struct {
                 error.NoSpaceLeft,
                 error.DeviceBusy,
                 error.NoDevice,
-                error.SharingViolation,
                 error.PathAlreadyExists,
                 error.PipeBusy,
                 error.NetworkNotFound,
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 7414ec060876b4b837d05dbc15fba9345b66a9fa..6f4e80f599908c6d34291a17b8768d331a91d52e 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -1135,19 +1135,7 @@ pub const CTL_CODE = packed struct(ULONG) {
 
         _,
     };
-};
 
-pub const IOCTL = struct {
-    pub const KSEC = struct {
-        pub const GEN_RANDOM: CTL_CODE = .{ .DeviceType = .KSEC, .Function = 2, .Method = .BUFFERED, .Access = .ANY };
-    };
-    pub const MOUNTMGR = struct {
-        pub const QUERY_POINTS: CTL_CODE = .{ .DeviceType = .MOUNTMGRCONTROLTYPE, .Function = 2, .Method = .BUFFERED, .Access = .ANY };
-        pub const QUERY_DOS_VOLUME_PATH: CTL_CODE = .{ .DeviceType = .MOUNTMGRCONTROLTYPE, .Function = 12, .Method = .BUFFERED, .Access = .ANY };
-    };
-};
-
-pub const FSCTL = struct {
     pub const SET_REPARSE_POINT: CTL_CODE = .{ .DeviceType = .FILE_SYSTEM, .Function = 41, .Method = .BUFFERED, .Access = .SPECIAL };
     pub const GET_REPARSE_POINT: CTL_CODE = .{ .DeviceType = .FILE_SYSTEM, .Function = 42, .Method = .BUFFERED, .Access = .ANY };
 
@@ -1177,6 +1165,16 @@ pub const FSCTL = struct {
     };
 };
 
+pub const IOCTL = struct {
+    pub const KSEC = struct {
+        pub const GEN_RANDOM: CTL_CODE = .{ .DeviceType = .KSEC, .Function = 2, .Method = .BUFFERED, .Access = .ANY };
+    };
+    pub const MOUNTMGR = struct {
+        pub const QUERY_POINTS: CTL_CODE = .{ .DeviceType = .MOUNTMGRCONTROLTYPE, .Function = 2, .Method = .BUFFERED, .Access = .ANY };
+        pub const QUERY_DOS_VOLUME_PATH: CTL_CODE = .{ .DeviceType = .MOUNTMGRCONTROLTYPE, .Function = 12, .Method = .BUFFERED, .Access = .ANY };
+    };
+};
+
 pub const MAXIMUM_REPARSE_DATA_BUFFER_SIZE: ULONG = 16 * 1024;
 
 pub const IO_REPARSE_TAG = packed struct(ULONG) {
@@ -2908,88 +2906,6 @@ pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
     return buffer[0..end_index];
 }
 
-pub const ReadLinkError = error{
-    FileNotFound,
-    NetworkNotFound,
-    AccessDenied,
-    Unexpected,
-    NameTooLong,
-    BadPathName,
-    AntivirusInterference,
-    UnsupportedReparsePointType,
-    NotLink,
-    OperationCanceled,
-};
-
-/// `sub_path_w` will never be accessed after `out_buffer` has been written to, so it
-/// is safe to reuse a single buffer for both.
-pub fn ReadLink(dir: ?HANDLE, sub_path_w: []const u16, out_buffer: []u16) ReadLinkError![]u16 {
-    const result_handle = OpenFile(sub_path_w, .{
-        .access_mask = .{
-            .SPECIFIC = .{ .FILE = .{
-                .READ_ATTRIBUTES = true,
-            } },
-            .STANDARD = .{ .SYNCHRONIZE = true },
-        },
-        .dir = dir,
-        .creation = .OPEN,
-        .follow_symlinks = false,
-        .filter = .any,
-    }) catch |err| switch (err) {
-        error.IsDir, error.NotDir => return error.Unexpected, // filter = .any
-        error.PathAlreadyExists => return error.Unexpected, // FILE_OPEN
-        error.WouldBlock => return error.Unexpected,
-        error.NoDevice => return error.FileNotFound,
-        error.PipeBusy => return error.AccessDenied,
-        else => |e| return e,
-    };
-    defer CloseHandle(result_handle);
-
-    var reparse_buf: [MAXIMUM_REPARSE_DATA_BUFFER_SIZE]u8 align(@alignOf(REPARSE_DATA_BUFFER)) = undefined;
-    const rc = DeviceIoControl(result_handle, FSCTL.GET_REPARSE_POINT, .{ .out = reparse_buf[0..] });
-    switch (rc) {
-        .SUCCESS => {},
-        .CANCELLED => return error.OperationCanceled,
-        .NOT_A_REPARSE_POINT => return error.NotLink,
-        else => return unexpectedStatus(rc),
-    }
-
-    const reparse_struct: *const REPARSE_DATA_BUFFER = @ptrCast(@alignCast(&reparse_buf[0]));
-    const IoReparseTagInt = @typeInfo(IO_REPARSE_TAG).@"struct".backing_integer.?;
-    switch (@as(IoReparseTagInt, @bitCast(reparse_struct.ReparseTag))) {
-        @as(IoReparseTagInt, @bitCast(IO_REPARSE_TAG.SYMLINK)) => {
-            const buf: *const SYMBOLIC_LINK_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
-            const offset = buf.SubstituteNameOffset >> 1;
-            const len = buf.SubstituteNameLength >> 1;
-            const path_buf = @as([*]const u16, &buf.PathBuffer);
-            const is_relative = buf.Flags & SYMLINK_FLAG_RELATIVE != 0;
-            return parseReadLinkPath(path_buf[offset..][0..len], is_relative, out_buffer);
-        },
-        @as(IoReparseTagInt, @bitCast(IO_REPARSE_TAG.MOUNT_POINT)) => {
-            const buf: *const MOUNT_POINT_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
-            const offset = buf.SubstituteNameOffset >> 1;
-            const len = buf.SubstituteNameLength >> 1;
-            const path_buf = @as([*]const u16, &buf.PathBuffer);
-            return parseReadLinkPath(path_buf[offset..][0..len], false, out_buffer);
-        },
-        else => return error.UnsupportedReparsePointType,
-    }
-}
-
-fn parseReadLinkPath(path: []const u16, is_relative: bool, out_buffer: []u16) error{NameTooLong}![]u16 {
-    path: {
-        if (is_relative) break :path;
-        return ntToWin32Namespace(path, out_buffer) catch |err| switch (err) {
-            error.NameTooLong => |e| return e,
-            error.NotNtPath => break :path,
-        };
-    }
-    if (out_buffer.len < path.len) return error.NameTooLong;
-    const dest = out_buffer[0..path.len];
-    @memcpy(dest, path);
-    return dest;
-}
-
 pub const DeleteFileError = error{
     FileNotFound,
     AccessDenied,
diff --git a/lib/std/process.zig b/lib/std/process.zig
index f7dd7e30173504deade22fee09fb361bc629f012..a3547e2b0ffebe1164519a056117540868ac54cd 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -704,7 +704,6 @@ pub const ExecutablePathBaseError = error{
     FileSystem,
     BadPathName,
     DeviceBusy,
-    SharingViolation,
     PipeBusy,
     NotLink,
     PathAlreadyExists,
diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig
index 8bb1678e7d0244a0206ab14952fd5dc3d35fe19a..efcf569de5a5ef12170c7c7a3ea82a9774569b1a 100644
--- a/lib/std/zig/system.zig
+++ b/lib/std/zig/system.zig
@@ -723,6 +723,7 @@ fn abiAndDynamicLinkerFromFile(
                 error.UnsupportedReparsePointType => unreachable, // Windows only
                 error.NetworkNotFound => unreachable, // Windows only
                 error.AntivirusInterference => unreachable, // Windows only
+                error.FileBusy => unreachable, // Windows only
 
                 error.AccessDenied,
                 error.PermissionDenied,
@@ -844,7 +845,6 @@ fn glibcVerFromRPath(io: Io, rpath: []const u8) !std.SemanticVersion {
         error.NameTooLong => return error.Unexpected,
         error.BadPathName => return error.Unexpected,
         error.PipeBusy => return error.Unexpected, // Windows-only
-        error.SharingViolation => return error.Unexpected, // Windows-only
         error.NetworkNotFound => return error.Unexpected, // Windows-only
         error.AntivirusInterference => return error.Unexpected, // Windows-only
         error.FileLocksUnsupported => return error.Unexpected, // No lock requested.
@@ -1052,7 +1052,6 @@ fn detectAbiAndDynamicLinker(io: Io, cpu: Target.Cpu, os: Target.Os, query: Targ
                 error.NoSpaceLeft => return error.Unexpected,
                 error.NameTooLong => return error.Unexpected,
                 error.PathAlreadyExists => return error.Unexpected,
-                error.SharingViolation => return error.Unexpected,
                 error.BadPathName => return error.Unexpected,
                 error.PipeBusy => return error.Unexpected,
                 error.FileLocksUnsupported => return error.Unexpected,
-- 
2.54.0


From e7baa09ce46181a5ffd55879a24a8cb72cea3093 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Wed, 28 Jan 2026 20:04:27 +0100
Subject: [PATCH 069/499] feat(Compilation): make libzigc share zcu if possible

---
 src/Compilation.zig | 65 ++++++++++++++++++++++++++++++++++++++++-----
 src/Zcu.zig         |  2 +-
 src/target.zig      |  6 +++++
 3 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 15c1837ec2dfb6a8f23691868b3f414828d4af5e..8047c164cb91d1eb25509a4b5d74f44eb7cd2835 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -80,6 +80,7 @@ sysroot: ?[]const u8,
 root_name: [:0]const u8,
 compiler_rt_strat: RtStrat,
 ubsan_rt_strat: RtStrat,
+zigc_strat: RtStrat,
 /// Resolved into known paths, any GNU ld scripts already resolved.
 link_inputs: []const link.Input,
 /// Needed only for passing -F args to clang.
@@ -2101,6 +2102,47 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             try options.root_mod.deps.putNoClobber(arena, "ubsan_rt", ubsan_rt_mod);
         }
 
+        // Like with ubsan_rt we want to go through the `_ = @import("zigc")`
+        // approach if possible since it uses even more of the standard library
+        // and can thus reduce further unnecesary bloat.
+        const zigc_strat: RtStrat = s: {
+            if (options.skip_linker_dependencies) break :s .none;
+            if (target.ofmt == .c) break :s .none;
+            if (!link_libc or !is_exe_or_dyn_lib) break :s .none;
+            if (!target_util.wantsZigC(target, options.config.link_mode)) break :s .none;
+            if (have_zcu) break :s .zcu;
+            break :s .lib;
+        };
+
+        if (zigc_strat == .zcu) {
+            const zigc_mod = Package.Module.create(arena, .{
+                .paths = .{
+                    .root = .zig_lib_root,
+                    .root_src_path = "c.zig",
+                },
+                .fully_qualified_name = "zigc",
+                .cc_argv = &.{},
+                .inherited = .{},
+                .global = options.config,
+                .parent = options.root_mod,
+            }) catch |err| switch (err) {
+                error.OutOfMemory => |e| return e,
+                // None of these are possible because the configuration matches the root module
+                // which already passed these checks.
+                error.ValgrindUnsupportedOnTarget => unreachable,
+                error.TargetRequiresSingleThreaded => unreachable,
+                error.BackendRequiresSingleThreaded => unreachable,
+                error.TargetRequiresPic => unreachable,
+                error.PieRequiresPic => unreachable,
+                error.DynamicLinkingRequiresPic => unreachable,
+                error.TargetHasNoRedZone => unreachable,
+                error.StackCheckUnsupportedByTarget => unreachable,
+                error.StackProtectorUnsupportedByTarget => unreachable,
+                error.StackProtectorUnavailableWithoutLibC => unreachable,
+            };
+            try options.root_mod.deps.putNoClobber(arena, "zigc", zigc_mod);
+        }
+
         if (options.verbose_llvm_cpu_features) {
             if (options.root_mod.resolved_target.llvm_cpu_features) |cf| {
                 const stderr = try io.lockStderr(&.{}, null);
@@ -2296,6 +2338,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             .libc_installation = libc_dirs.libc_installation,
             .compiler_rt_strat = compiler_rt_strat,
             .ubsan_rt_strat = ubsan_rt_strat,
+            .zigc_strat = zigc_strat,
             .link_inputs = options.link_inputs,
             .framework_dirs = options.framework_dirs,
             .llvm_opt_bisect_limit = options.llvm_opt_bisect_limit,
@@ -2651,13 +2694,6 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
                 } else {
                     return diag.fail(.cross_libc_unavailable);
                 }
-
-                if ((target.isMuslLibC() and comp.config.link_mode == .static) or
-                    target.isWasiLibC() or
-                    target.isMinGW())
-                {
-                    comp.queued_jobs.zigc_lib = true;
-                }
             }
 
             // Generate Windows import libs.
@@ -2711,6 +2747,15 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
                 .dyn_lib => unreachable, // hack for compiler_rt only
             }
 
+            switch (comp.zigc_strat) {
+                .none, .zcu => {},
+                .lib => {
+                    log.debug("queuing a job to build libzigc", .{});
+                    comp.queued_jobs.zigc_lib = true;
+                },
+                .obj, .dyn_lib => unreachable, // only available as a static library or inside an existing ZCU
+            }
+
             if (is_exe_or_dyn_lib and comp.config.any_fuzz) {
                 log.debug("queuing a job to build libfuzzer", .{});
                 comp.queued_jobs.fuzzer_lib = true;
@@ -3100,6 +3145,11 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
             zcu.analysis_roots_buffer[zcu.analysis_roots_len] = ubsan_rt_mod;
             zcu.analysis_roots_len += 1;
         }
+
+        if (zcu.root_mod.deps.get("zigc")) |zigc_mod| {
+            zcu.analysis_roots_buffer[zcu.analysis_roots_len] = zigc_mod;
+            zcu.analysis_roots_len += 1;
+        }
     }
 
     // The linker progress node is set up here instead of in `performAllTheWork`, because
@@ -3531,6 +3581,7 @@ fn addNonIncrementalStuffToCacheManifest(
     man.hash.add(comp.skip_linker_dependencies);
     man.hash.add(comp.compiler_rt_strat);
     man.hash.add(comp.ubsan_rt_strat);
+    man.hash.add(comp.zigc_strat);
     man.hash.add(comp.rc_includes);
     man.hash.addListOfBytes(comp.force_undefined_symbols.keys());
     man.hash.addListOfBytes(comp.framework_dirs);
diff --git a/src/Zcu.zig b/src/Zcu.zig
index d1e20c8551b10cc622a086e0731d4b3132487e41..ceccc2c192cd8a8fef9248179b82535476d34cf3 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -269,7 +269,7 @@ nav_val_analysis_queued: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, voi
 
 /// These are the modules which we initially queue for analysis in `Compilation.update`.
 /// `resolveReferences` will use these as the root of its reachability traversal.
-analysis_roots_buffer: [4]*Package.Module,
+analysis_roots_buffer: [5]*Package.Module,
 analysis_roots_len: usize = 0,
 /// This is the cached result of `Zcu.resolveReferences`. It is computed on-demand, and
 /// reset to `null` when any semantic analysis occurs (since this invalidates the data).
diff --git a/src/target.zig b/src/target.zig
index f664a354592ddff2d0c8cebbc5b9629d9c4d9c8c..ca65239a0950bb4d52508655b9040d1cf2b62872 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -423,6 +423,12 @@ pub fn canBuildLibUbsanRt(target: *const std.Target) enum { no, yes, llvm_only,
     };
 }
 
+/// Whether libzigc can fill-in the gaps of an existing libc
+/// or *is* the libc of the target.
+pub fn wantsZigC(target: *const std.Target, link_mode: std.builtin.LinkMode) bool {
+    return (target.isMuslLibC() and link_mode == .static) or target.isWasiLibC() or target.isMinGW();
+}
+
 pub fn hasRedZone(target: *const std.Target) bool {
     return switch (target.cpu.arch) {
         .aarch64,
-- 
2.54.0


From ed93f0d70f5b3f954a4f52e37cab80383ca61413 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Thu, 29 Jan 2026 10:39:38 +0100
Subject: [PATCH 070/499] fix(libzigc): always apply strong linkage, even when
 testing

* libzigc may be linked into a different test compilation

Co-authored-by: Matthew Lugg <mlugg@mlugg.co.uk>
---
 lib/c/common.zig | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/lib/c/common.zig b/lib/c/common.zig
index 8d2a79db54b33515ef75c98bf5eb1defe23cb19a..5cd94cf0ceedf73986b5b0217d4e285fac45f735 100644
--- a/lib/c/common.zig
+++ b/lib/c/common.zig
@@ -1,18 +1,14 @@
 const builtin = @import("builtin");
 const std = @import("std");
 
-pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
-    .internal
-else
-    .strong;
+/// It is incorrect to make this conditional on `builtin.is_test`, because it is possible that
+/// libzigc is being linked into a different test compilation, as opposed to being tested itself.
+pub const linkage: std.builtin.GlobalLinkage = .strong;
 
 /// Determines the symbol's visibility to other objects.
 /// For WebAssembly this allows the symbol to be resolved to other modules, but will not
 /// export it to the host runtime.
-pub const visibility: std.builtin.SymbolVisibility = if (linkage != .internal)
-    .hidden
-else
-    .default;
+pub const visibility: std.builtin.SymbolVisibility = .hidden;
 
 /// Given a low-level syscall return value, sets errno and returns `-1`, or on
 /// success returns the result.
-- 
2.54.0


From 4d6f4e9cfd00669efc1c688d9509010ddc4e840f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 14:10:27 -0800
Subject: [PATCH 071/499] behavior: add coverage for extern struct field
 overalignment

---
 test/behavior/struct.zig | 49 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 08aca075d7ec8e219b4d3ff699dd5c0fdd1b581c..6422aef034bf3b4fbcf1e16acce3742944828a04 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -2184,3 +2184,52 @@ test "pass a pointer to a comptime-only struct field to a function" {
     const s: struct { x: type } = .{ .x = u42 };
     try S.checkField(&s.x);
 }
+
+test "overaligned extern struct fields" {
+    const A = struct {
+        a: *anyopaque,
+        b: u64,
+        c: [1][]u8,
+        d: ?anyerror,
+    };
+
+    const B = union(enum) {
+        a: struct {
+            a: [2]usize,
+            b: C,
+        },
+        b: struct {
+            a: *anyopaque,
+            b: []const []u8,
+            c: C,
+        },
+        const C = union {
+            a: void,
+            b: *anyopaque,
+            c: anyerror!usize,
+        };
+    };
+
+    const D = extern struct {
+        a: u32,
+    };
+
+    const E = extern struct {
+        a: u32,
+        b: [2][@sizeOf(A)]u8 align(@alignOf(A)),
+        c: [2]u32,
+        d: [2][@sizeOf(B)]u8 align(@alignOf(B)),
+
+        fn cast(e: *@This()) *D {
+            e.a = 2;
+            return @ptrCast(e);
+        }
+    };
+
+    var e: E = undefined;
+    const d = e.cast();
+    try expect(d.a == 2);
+    try expect(std.mem.isAligned(@intFromPtr(&e.b), @alignOf(A)));
+    try expect(std.mem.isAligned(@intFromPtr(&e.c), @alignOf(u32)));
+    try expect(std.mem.isAligned(@intFromPtr(&e.d), @alignOf(B)));
+}
-- 
2.54.0


From 5571c08e6603173378db7cfe1436e33e902f9c0a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 15:26:11 -0800
Subject: [PATCH 072/499] add behavior test for i96 operations

---
 test/behavior/math.zig | 44 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index 867567ea404ddc8550c60b6e4c3041c7128e5fda..841d608d35bce5e28a1807a9633d2b27b344fa2d 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -1946,3 +1946,47 @@ test "comptime float vector multiplication of zero by nan is nan" {
     comptime assert(math.isNan((ct_zero * ct_nan)[0]));
     comptime assert(math.isNan((ct_nan * ct_zero)[0]));
 }
+
+test "i96 operations" {
+    // This is coverage for some stuff used by std.Io timestamps, to catch
+    // issues earlier than bootstrapping.
+    const Op_i96 = union(enum) {
+        a,
+        b: B,
+        c: C,
+
+        const B = struct {
+            inner: struct { x: i96 },
+            flag: bool,
+        };
+
+        const C = struct {
+            inner: struct { x: i96 },
+            flag: bool,
+        };
+
+        fn do(op: @This()) i64 {
+            switch (op) {
+                .a => {
+                    return std.math.minInt(i64);
+                },
+                .b => |b| {
+                    const x = b.inner.x;
+                    return @intCast(@divTrunc(x, 100));
+                },
+                .c => |c| {
+                    const a = get() catch unreachable;
+                    const b = a.x + c.inner.x;
+                    return @intCast(@divTrunc(b, 100));
+                },
+            }
+        }
+
+        fn get() anyerror!struct { x: i96 } {
+            return .{ .x = 999999999 };
+        }
+    };
+    try expect(-9223372036854775808 == Op_i96.do(.{ .a = {} }));
+    try expect(12345678910111213 == Op_i96.do(.{ .b = .{ .inner = .{ .x = 1234567891011121314 }, .flag = true } }));
+    try expect(1234567891021121314 == Op_i96.do(.{ .c = .{ .inner = .{ .x = 123456789101112131415 }, .flag = true } }));
+}
-- 
2.54.0


From 9b415761dd66904aef363e387b4501f3ddd0bf76 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 20:05:20 -0800
Subject: [PATCH 073/499] std.os.windows: delete unused APIs

Intention is to go through std.Io for these things.
---
 lib/std/Io/File/Reader.zig             |   2 +-
 lib/std/Io/Threaded.zig                |  15 +-
 lib/std/os/windows.zig                 | 372 +------------------------
 lib/std/os/windows/kernel32.zig        |  19 --
 test/standalone/windows_argv/fuzz.zig  |   7 +-
 test/standalone/windows_spawn/main.zig |  19 +-
 6 files changed, 36 insertions(+), 398 deletions(-)

diff --git a/lib/std/Io/File/Reader.zig b/lib/std/Io/File/Reader.zig
index f400f2c51439b65bbe7e11ef3dfa0d5b49b4f3bf..2e0e192cb2326bd62eecbfaac6d30ade3ba81f18 100644
--- a/lib/std/Io/File/Reader.zig
+++ b/lib/std/Io/File/Reader.zig
@@ -48,7 +48,7 @@ pub const Error = error{
     LockViolation,
 } || Io.Cancelable || Io.UnexpectedError;
 
-pub const SizeError = std.os.windows.GetFileSizeError || File.StatError || error{
+pub const SizeError = File.StatError || error{
     /// Occurs if, for example, the file handle is a network socket and therefore does not have a size.
     Streaming,
 };
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 01bcacbc2989d5610f01df7a37041623b5262077..c74850ca0a3b653f011cb30ab971f9e5a8c46958 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -13960,8 +13960,19 @@ fn childWaitWindows(child: *process.Child) process.Child.WaitError!process.Child
 fn childCleanupWindows(child: *process.Child) void {
     const handle = child.id orelse return;
 
-    if (child.request_resource_usage_statistics)
-        child.resource_usage_statistics.rusage = windows.GetProcessMemoryInfo(handle) catch null;
+    if (child.request_resource_usage_statistics) {
+        var vmc: windows.VM_COUNTERS = undefined;
+        switch (windows.ntdll.NtQueryInformationProcess(
+            handle,
+            .VmCounters,
+            &vmc,
+            @sizeOf(windows.VM_COUNTERS),
+            null,
+        )) {
+            .SUCCESS => child.resource_usage_statistics.rusage = vmc,
+            else => child.resource_usage_statistics.rusage = null,
+        }
+    }
 
     windows.CloseHandle(handle);
     child.id = null;
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 6f4e80f599908c6d34291a17b8768d331a91d52e..47c5a4d8567326a46709250d6a070fae752cce14 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -2906,275 +2906,6 @@ pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
     return buffer[0..end_index];
 }
 
-pub const DeleteFileError = error{
-    FileNotFound,
-    AccessDenied,
-    NameTooLong,
-    /// Also known as sharing violation.
-    FileBusy,
-    Unexpected,
-    NotDir,
-    IsDir,
-    DirNotEmpty,
-    NetworkNotFound,
-};
-
-pub const DeleteFileOptions = struct {
-    dir: ?HANDLE,
-    remove_dir: bool = false,
-};
-
-pub fn DeleteFile(sub_path_w: []const u16, options: DeleteFileOptions) DeleteFileError!void {
-    const path_len_bytes = @as(u16, @intCast(sub_path_w.len * 2));
-    var nt_name: UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        // The Windows API makes this mutable, but it will not mutate here.
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-
-    if (sub_path_w[0] == '.' and sub_path_w[1] == 0) {
-        // Windows does not recognize this, but it does work with empty string.
-        nt_name.Length = 0;
-    }
-    if (sub_path_w[0] == '.' and sub_path_w[1] == '.' and sub_path_w[2] == 0) {
-        // Can't remove the parent directory with an open handle.
-        return error.FileBusy;
-    }
-
-    var io: IO_STATUS_BLOCK = undefined;
-    var tmp_handle: HANDLE = undefined;
-    var rc = ntdll.NtCreateFile(
-        &tmp_handle,
-        .{ .STANDARD = .{
-            .RIGHTS = .{ .DELETE = true },
-            .SYNCHRONIZE = true,
-        } },
-        &.{
-            .Length = @sizeOf(OBJECT_ATTRIBUTES),
-            .RootDirectory = if (std.fs.path.isAbsoluteWindowsWtf16(sub_path_w)) null else options.dir,
-            .Attributes = .{},
-            .ObjectName = &nt_name,
-            .SecurityDescriptor = null,
-            .SecurityQualityOfService = null,
-        },
-        &io,
-        null,
-        .{},
-        .VALID_FLAGS,
-        .OPEN,
-        .{
-            .DIRECTORY_FILE = options.remove_dir,
-            .NON_DIRECTORY_FILE = !options.remove_dir,
-            .OPEN_REPARSE_POINT = true, // would we ever want to delete the target instead?
-        },
-        null,
-        0,
-    );
-    switch (rc) {
-        .SUCCESS => {},
-        .OBJECT_NAME_INVALID => unreachable,
-        .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
-        .OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
-        .BAD_NETWORK_PATH => return error.NetworkNotFound, // \\server was not found
-        .BAD_NETWORK_NAME => return error.NetworkNotFound, // \\server was found but \\server\share wasn't
-        .INVALID_PARAMETER => unreachable,
-        .FILE_IS_A_DIRECTORY => return error.IsDir,
-        .NOT_A_DIRECTORY => return error.NotDir,
-        .SHARING_VIOLATION => return error.FileBusy,
-        .ACCESS_DENIED => return error.AccessDenied,
-        .DELETE_PENDING => return,
-        else => return unexpectedStatus(rc),
-    }
-    defer CloseHandle(tmp_handle);
-
-    // FileDispositionInformationEx has varying levels of support:
-    // - FILE_DISPOSITION_INFORMATION_EX requires >= win10_rs1
-    //   (INVALID_INFO_CLASS is returned if not supported)
-    // - Requires the NTFS filesystem
-    //   (on filesystems like FAT32, INVALID_PARAMETER is returned)
-    // - FILE_DISPOSITION_POSIX_SEMANTICS requires >= win10_rs1
-    // - FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE requires >= win10_rs5
-    //   (NOT_SUPPORTED is returned if a flag is unsupported)
-    //
-    // The strategy here is just to try using FileDispositionInformationEx and fall back to
-    // FileDispositionInformation if the return value lets us know that some aspect of it is not supported.
-    const need_fallback = need_fallback: {
-        // Deletion with posix semantics if the filesystem supports it.
-        var info: FILE.DISPOSITION.INFORMATION.EX = .{ .Flags = .{
-            .DELETE = true,
-            .POSIX_SEMANTICS = true,
-            .IGNORE_READONLY_ATTRIBUTE = true,
-        } };
-        rc = ntdll.NtSetInformationFile(
-            tmp_handle,
-            &io,
-            &info,
-            @sizeOf(FILE.DISPOSITION.INFORMATION.EX),
-            .DispositionEx,
-        );
-        switch (rc) {
-            .SUCCESS => return,
-            // The filesystem does not support FileDispositionInformationEx
-            .INVALID_PARAMETER,
-            // The operating system does not support FileDispositionInformationEx
-            .INVALID_INFO_CLASS,
-            // The operating system does not support one of the flags
-            .NOT_SUPPORTED,
-            => break :need_fallback true,
-            // For all other statuses, fall down to the switch below to handle them.
-            else => break :need_fallback false,
-        }
-    };
-
-    if (need_fallback) {
-        // Deletion with file pending semantics, which requires waiting or moving
-        // files to get them removed (from here).
-        var file_dispo: FILE.DISPOSITION.INFORMATION = .{
-            .DeleteFile = TRUE,
-        };
-        rc = ntdll.NtSetInformationFile(
-            tmp_handle,
-            &io,
-            &file_dispo,
-            @sizeOf(FILE.DISPOSITION.INFORMATION),
-            .Disposition,
-        );
-    }
-    switch (rc) {
-        .SUCCESS => {},
-        .DIRECTORY_NOT_EMPTY => return error.DirNotEmpty,
-        .INVALID_PARAMETER => unreachable,
-        .CANNOT_DELETE => return error.AccessDenied,
-        .MEDIA_WRITE_PROTECTED => return error.AccessDenied,
-        .ACCESS_DENIED => return error.AccessDenied,
-        else => return unexpectedStatus(rc),
-    }
-}
-
-pub const RenameError = error{
-    IsDir,
-    NotDir,
-    FileNotFound,
-    NoDevice,
-    AccessDenied,
-    PipeBusy,
-    PathAlreadyExists,
-    Unexpected,
-    NameTooLong,
-    NetworkNotFound,
-    AntivirusInterference,
-    BadPathName,
-    CrossDevice,
-} || UnexpectedError;
-
-pub fn RenameFile(
-    /// May only be `null` if `old_path_w` is a fully-qualified absolute path.
-    old_dir_fd: ?HANDLE,
-    old_path_w: []const u16,
-    /// May only be `null` if `new_path_w` is a fully-qualified absolute path,
-    /// or if the file is not being moved to a different directory.
-    new_dir_fd: ?HANDLE,
-    new_path_w: []const u16,
-    replace_if_exists: bool,
-) RenameError!void {
-    const src_fd = OpenFile(old_path_w, .{
-        .dir = old_dir_fd,
-        .access_mask = .{
-            .STANDARD = .{
-                .RIGHTS = .{ .DELETE = true },
-                .SYNCHRONIZE = true,
-            },
-            .GENERIC = .{ .WRITE = true },
-        },
-        .creation = .OPEN,
-        .filter = .any, // This function is supposed to rename both files and directories.
-        .follow_symlinks = false,
-    }) catch |err| switch (err) {
-        error.WouldBlock => unreachable, // Not possible without `.share_access_nonblocking = true`.
-        else => |e| return e,
-    };
-    defer CloseHandle(src_fd);
-
-    var rc: NTSTATUS = undefined;
-    // FileRenameInformationEx has varying levels of support:
-    // - FILE_RENAME_INFORMATION_EX requires >= win10_rs1
-    //   (INVALID_INFO_CLASS is returned if not supported)
-    // - Requires the NTFS filesystem
-    //   (on filesystems like FAT32, INVALID_PARAMETER is returned)
-    // - FILE_RENAME_POSIX_SEMANTICS requires >= win10_rs1
-    // - FILE_RENAME_IGNORE_READONLY_ATTRIBUTE requires >= win10_rs5
-    //   (NOT_SUPPORTED is returned if a flag is unsupported)
-    //
-    // The strategy here is just to try using FileRenameInformationEx and fall back to
-    // FileRenameInformation if the return value lets us know that some aspect of it is not supported.
-    const need_fallback = need_fallback: {
-        var rename_info: FILE.RENAME_INFORMATION = .init(.{
-            .Flags = .{
-                .REPLACE_IF_EXISTS = replace_if_exists,
-                .POSIX_SEMANTICS = true,
-                .IGNORE_READONLY_ATTRIBUTE = true,
-            },
-            .RootDirectory = if (std.fs.path.isAbsoluteWindowsWtf16(new_path_w)) null else new_dir_fd,
-            .FileName = new_path_w,
-        });
-        var io_status_block: IO_STATUS_BLOCK = undefined;
-        const rename_info_buf = rename_info.toBuffer();
-        rc = ntdll.NtSetInformationFile(
-            src_fd,
-            &io_status_block,
-            rename_info_buf.ptr,
-            @intCast(rename_info_buf.len), // already checked for error.NameTooLong
-            .RenameEx,
-        );
-        switch (rc) {
-            .SUCCESS => return,
-            // The filesystem does not support FileDispositionInformationEx
-            .INVALID_PARAMETER,
-            // The operating system does not support FileDispositionInformationEx
-            .INVALID_INFO_CLASS,
-            // The operating system does not support one of the flags
-            .NOT_SUPPORTED,
-            => break :need_fallback true,
-            // For all other statuses, fall down to the switch below to handle them.
-            else => break :need_fallback false,
-        }
-    };
-
-    if (need_fallback) {
-        var rename_info: FILE.RENAME_INFORMATION = .init(.{
-            .Flags = .{ .REPLACE_IF_EXISTS = replace_if_exists },
-            .RootDirectory = if (std.fs.path.isAbsoluteWindowsWtf16(new_path_w)) null else new_dir_fd,
-            .FileName = new_path_w,
-        });
-        var io_status_block: IO_STATUS_BLOCK = undefined;
-        const rename_info_buf = rename_info.toBuffer();
-        rc = ntdll.NtSetInformationFile(
-            src_fd,
-            &io_status_block,
-            rename_info_buf.ptr,
-            @intCast(rename_info_buf.len), // already checked for error.NameTooLong
-            .Rename,
-        );
-    }
-
-    switch (rc) {
-        .SUCCESS => {},
-        .INVALID_HANDLE => unreachable,
-        .INVALID_PARAMETER => unreachable,
-        .OBJECT_PATH_SYNTAX_BAD => unreachable,
-        .ACCESS_DENIED => return error.AccessDenied,
-        .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
-        .OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
-        .NOT_SAME_DEVICE => return error.CrossDevice,
-        .OBJECT_NAME_COLLISION => return error.PathAlreadyExists,
-        .DIRECTORY_NOT_EMPTY => return error.PathAlreadyExists,
-        .FILE_IS_A_DIRECTORY => return error.IsDir,
-        .NOT_A_DIRECTORY => return error.NotDir,
-        else => return unexpectedStatus(rc),
-    }
-}
-
 pub const GetStdHandleError = error{
     NoStandardHandleAttached,
     Unexpected,
@@ -3508,18 +3239,6 @@ test GetFinalPathNameByHandle {
     _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0..required_len_in_u16]);
 }
 
-pub const GetFileSizeError = error{Unexpected};
-
-pub fn GetFileSizeEx(hFile: HANDLE) GetFileSizeError!u64 {
-    var file_size: LARGE_INTEGER = undefined;
-    if (kernel32.GetFileSizeEx(hFile, &file_size) == 0) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-    return @as(u64, @bitCast(file_size));
-}
-
 pub fn getpeername(s: ws2_32.SOCKET, name: *ws2_32.sockaddr, namelen: *ws2_32.socklen_t) i32 {
     return ws2_32.getpeername(s, name, @as(*i32, @ptrCast(namelen)));
 }
@@ -3714,69 +3433,6 @@ pub const CreateProcessFlags = packed struct(u32) {
     create_ignore_system_default: bool = false,
 };
 
-pub fn CreateProcessW(
-    lpApplicationName: ?LPCWSTR,
-    lpCommandLine: ?LPWSTR,
-    lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
-    lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
-    bInheritHandles: BOOL,
-    dwCreationFlags: CreateProcessFlags,
-    lpEnvironment: ?[*:0]u16,
-    lpCurrentDirectory: ?LPCWSTR,
-    lpStartupInfo: *STARTUPINFOW,
-    lpProcessInformation: *PROCESS_INFORMATION,
-) CreateProcessError!void {
-    if (kernel32.CreateProcessW(
-        lpApplicationName,
-        lpCommandLine,
-        lpProcessAttributes,
-        lpThreadAttributes,
-        bInheritHandles,
-        dwCreationFlags,
-        lpEnvironment,
-        lpCurrentDirectory,
-        lpStartupInfo,
-        lpProcessInformation,
-    ) == 0) {
-        switch (GetLastError()) {
-            .FILE_NOT_FOUND => return error.FileNotFound,
-            .PATH_NOT_FOUND => return error.FileNotFound,
-            .DIRECTORY => return error.FileNotFound,
-            .ACCESS_DENIED => return error.AccessDenied,
-            .INVALID_PARAMETER => unreachable,
-            .INVALID_NAME => return error.InvalidName,
-            .FILENAME_EXCED_RANGE => return error.NameTooLong,
-            .SHARING_VIOLATION => return error.FileBusy,
-            // These are all the system errors that are mapped to ENOEXEC by
-            // the undocumented _dosmaperr (old CRT) or __acrt_errno_map_os_error
-            // (newer CRT) functions. Their code can be found in crt/src/dosmap.c (old SDK)
-            // or urt/misc/errno.cpp (newer SDK) in the Windows SDK.
-            .BAD_FORMAT,
-            .INVALID_STARTING_CODESEG, // MIN_EXEC_ERROR in errno.cpp
-            .INVALID_STACKSEG,
-            .INVALID_MODULETYPE,
-            .INVALID_EXE_SIGNATURE,
-            .EXE_MARKED_INVALID,
-            .BAD_EXE_FORMAT,
-            .ITERATED_DATA_EXCEEDS_64k,
-            .INVALID_MINALLOCSIZE,
-            .DYNLINK_FROM_INVALID_RING,
-            .IOPL_NOT_ENABLED,
-            .INVALID_SEGDPL,
-            .AUTODATASEG_EXCEEDS_64k,
-            .RING2SEG_MUST_BE_MOVABLE,
-            .RELOC_CHAIN_XEEDS_SEGLIM,
-            .INFLOOP_IN_RELOC_CHAIN, // MAX_EXEC_ERROR in errno.cpp
-            // This one is not mapped to ENOEXEC but it is possible, for example
-            // when calling CreateProcessW on a plain text file with a .exe extension
-            .EXE_MACHINE_TYPE_MISMATCH,
-            => return error.InvalidExe,
-            .COMMITMENT_LIMIT => return error.SystemResources,
-            else => |err| return unexpectedError(err),
-        }
-    }
-}
-
 pub const LoadLibraryError = error{
     FileNotFound,
     Unexpected,
@@ -3843,10 +3499,6 @@ pub fn QueryPerformanceCounter() u64 {
     return @as(u64, @bitCast(result));
 }
 
-pub fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*anyopaque, Context: ?*anyopaque) void {
-    assert(kernel32.InitOnceExecuteOnce(InitOnce, InitFn, Parameter, Context) != 0);
-}
-
 /// This is a workaround for the C backend until zig has the ability to put
 /// C code in inline assembly.
 extern fn zig_thumb_windows_teb() callconv(.c) *anyopaque;
@@ -6072,24 +5724,6 @@ pub const PROCESS_MEMORY_COUNTERS_EX = extern struct {
     PrivateUsage: SIZE_T,
 };
 
-pub const GetProcessMemoryInfoError = error{
-    AccessDenied,
-    InvalidHandle,
-    Unexpected,
-};
-
-pub fn GetProcessMemoryInfo(hProcess: HANDLE) GetProcessMemoryInfoError!VM_COUNTERS {
-    var vmc: VM_COUNTERS = undefined;
-    const rc = ntdll.NtQueryInformationProcess(hProcess, .VmCounters, &vmc, @sizeOf(VM_COUNTERS), null);
-    switch (rc) {
-        .SUCCESS => return vmc,
-        .ACCESS_DENIED => return error.AccessDenied,
-        .INVALID_HANDLE => return error.InvalidHandle,
-        .INVALID_PARAMETER => unreachable,
-        else => return unexpectedStatus(rc),
-    }
-}
-
 pub const PERFORMANCE_INFORMATION = extern struct {
     cb: DWORD,
     CommitTotal: SIZE_T,
@@ -6623,7 +6257,11 @@ pub fn WriteProcessMemory(handle: HANDLE, addr: ?LPVOID, buffer: []const u8) Wri
     }
 }
 
-pub const ProcessBaseAddressError = GetProcessMemoryInfoError || ReadMemoryError;
+pub const ProcessBaseAddressError = error{
+    AccessDenied,
+    InvalidHandle,
+    Unexpected,
+} || ReadMemoryError;
 
 /// Returns the base address of the process loaded into memory.
 pub fn ProcessBaseAddress(handle: HANDLE) ProcessBaseAddressError!HMODULE {
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index 1ef3d0e55ec6985da80d57881f0a48feeb2dd0c3..ad232046ef87f7790397592cac41c7955722740f 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -117,12 +117,6 @@ pub extern "kernel32" fn WriteFile(
     in_out_lpOverlapped: ?*OVERLAPPED,
 ) callconv(.winapi) BOOL;
 
-// TODO: wrapper for NtQueryInformationFile + `FILE_STANDARD_INFORMATION`
-pub extern "kernel32" fn GetFileSizeEx(
-    hFile: HANDLE,
-    lpFileSize: *LARGE_INTEGER,
-) callconv(.winapi) BOOL;
-
 // TODO: Wrapper around GetStdHandle + NtFlushBuffersFile.
 pub extern "kernel32" fn FlushFileBuffers(
     hFile: HANDLE,
@@ -283,12 +277,6 @@ pub extern "kernel32" fn GetExitCodeProcess(
     lpExitCode: *DWORD,
 ) callconv(.winapi) BOOL;
 
-// TODO: Wrapper around RtlSetEnvironmentVar.
-pub extern "kernel32" fn SetEnvironmentVariableW(
-    lpName: LPCWSTR,
-    lpValue: ?LPCWSTR,
-) callconv(.winapi) BOOL;
-
 pub extern "kernel32" fn CreateToolhelp32Snapshot(
     dwFlags: DWORD,
     th32ProcessID: DWORD,
@@ -311,13 +299,6 @@ pub extern "kernel32" fn CreateThread(
 
 // Locks, critical sections, initializers
 
-pub extern "kernel32" fn InitOnceExecuteOnce(
-    InitOnce: *INIT_ONCE,
-    InitFn: INIT_ONCE_FN,
-    Parameter: ?*anyopaque,
-    Context: ?*anyopaque,
-) callconv(.winapi) BOOL;
-
 // TODO:
 //  - dwMilliseconds -> LARGE_INTEGER.
 //  - RtlSleepConditionVariableSRW
diff --git a/test/standalone/windows_argv/fuzz.zig b/test/standalone/windows_argv/fuzz.zig
index fde26ee5f481ff06a241fbacdac1593577c96266..b955697d3867afe69bf1396699ce96c41c7a7e15 100644
--- a/test/standalone/windows_argv/fuzz.zig
+++ b/test/standalone/windows_argv/fuzz.zig
@@ -129,7 +129,7 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
         };
         var proc_info: windows.PROCESS_INFORMATION = undefined;
 
-        try windows.CreateProcessW(
+        if (windows.kernel32.CreateProcessW(
             @constCast(verify_path.ptr),
             @constCast(cmd_line.ptr),
             null,
@@ -140,7 +140,10 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
             null,
             &startup_info,
             &proc_info,
-        );
+        ) == 0) {
+            std.process.fatal("kernel32 CreateProcessW failed with {t}", .{windows.kernel32.GetLastError()});
+        }
+
         windows.CloseHandle(proc_info.hThread);
 
         break :spawn proc_info.hProcess;
diff --git a/test/standalone/windows_spawn/main.zig b/test/standalone/windows_spawn/main.zig
index e26b581f59db5b97be70c1c483ed42eb851a64b0..add20921b5d4b51bf2570d62077329e6f11efd3b 100644
--- a/test/standalone/windows_spawn/main.zig
+++ b/test/standalone/windows_spawn/main.zig
@@ -31,13 +31,13 @@ pub fn main(init: std.process.Init) !void {
     defer gpa.free(tmp_relative_path);
 
     // Clear PATH
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATH"),
         null,
     ) == windows.TRUE);
 
     // Set PATHEXT to something predictable
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATHEXT"),
         utf16Literal(".COM;.EXE;.BAT;.CMD;.JS"),
     ) == windows.TRUE);
@@ -48,7 +48,7 @@ pub fn main(init: std.process.Init) !void {
     // make sure we don't get error.BadPath traversing out of cwd with a relative path
     try testExecError(error.FileNotFound, gpa, io, "..\\.\\.\\.\\\\..\\more_missing");
 
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATH"),
         tmp_absolute_path_w,
     ) == windows.TRUE);
@@ -131,7 +131,7 @@ pub fn main(init: std.process.Init) !void {
     const something_subdir_abs_path = try std.mem.concatWithSentinel(gpa, u16, &.{ tmp_absolute_path_w, utf16Literal("\\something") }, 0);
     defer gpa.free(something_subdir_abs_path);
 
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATH"),
         something_subdir_abs_path,
     ) == windows.TRUE);
@@ -171,7 +171,7 @@ pub fn main(init: std.process.Init) !void {
     defer gpa.free(denormed_something_subdir_wtf8);
 
     // clear the path to ensure that the match comes from the cwd
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATH"),
         null,
     ) == windows.TRUE);
@@ -179,7 +179,7 @@ pub fn main(init: std.process.Init) !void {
     try testExecWithCwd(gpa, io, "goodbye", denormed_something_subdir_wtf8, "hello from exe\n");
 
     // normalization should also work if the non-normalized path is found in the PATH var.
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATH"),
         denormed_something_subdir_abs_path,
     ) == windows.TRUE);
@@ -193,7 +193,7 @@ pub fn main(init: std.process.Init) !void {
     try std.process.setCurrentDir(io, subdir_cwd);
 
     // clear the PATH again
-    std.debug.assert(windows.kernel32.SetEnvironmentVariableW(
+    std.debug.assert(SetEnvironmentVariableW(
         utf16Literal("PATH"),
         null,
     ) == windows.TRUE);
@@ -235,3 +235,8 @@ fn renameExe(dir: Io.Dir, io: Io, old_sub_path: []const u8, new_sub_path: []cons
         else => |e| return e,
     };
 }
+
+pub extern "kernel32" fn SetEnvironmentVariableW(
+    lpName: windows.LPCWSTR,
+    lpValue: ?windows.LPCWSTR,
+) callconv(.winapi) windows.BOOL;
-- 
2.54.0


From 649aaf4814f8b74d9f90c0aaa09cbaf1901a6650 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 19:40:43 -0800
Subject: [PATCH 074/499] std: migrate getcwd to Io

progress towards #30150
---
 lib/compiler/build_runner.zig                 |  2 +-
 lib/std/Build/Cache.zig                       |  8 +--
 lib/std/Build/Step/Options.zig                |  2 +-
 lib/std/Io.zig                                |  1 +
 lib/std/Io/Threaded.zig                       | 42 ++++++++++++
 lib/std/fs/test.zig                           |  2 +-
 lib/std/os/windows.zig                        | 28 --------
 lib/std/os/windows/kernel32.zig               |  6 --
 lib/std/os/windows/ntdll.zig                  |  5 ++
 lib/std/posix.zig                             | 34 ----------
 lib/std/process.zig                           | 65 ++++++++-----------
 src/Compilation.zig                           |  2 +-
 src/introspect.zig                            | 10 +--
 src/main.zig                                  | 10 +--
 test/standalone/child_process/main.zig        | 16 ++---
 test/standalone/posix/cwd.zig                 | 27 ++++----
 .../self_exe_symlink/create-symlink.zig       |  2 +-
 test/standalone/windows_paths/relative.zig    |  2 +-
 test/standalone/windows_paths/test.zig        |  2 +-
 test/standalone/windows_spawn/main.zig        |  2 +-
 tools/doctest.zig                             |  2 +-
 tools/incr-check.zig                          |  2 +-
 tools/process_headers.zig                     |  2 +-
 tools/update-linux-headers.zig                |  2 +-
 24 files changed, 122 insertions(+), 154 deletions(-)

diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 7efee4bac4c78f0cc2b1db807180cf57d7cd271b..6ef8e71f7eea56aa1d5e7efd58c2f3af716e5b05 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -83,7 +83,7 @@ pub fn main(init: process.Init.Minimal) !void {
             .io = io,
             .gpa = gpa,
             .manifest_dir = try local_cache_directory.handle.createDirPathOpen(io, "h", .{}),
-            .cwd = try process.getCwdAlloc(single_threaded_arena.allocator()),
+            .cwd = try process.currentDirAlloc(io, single_threaded_arena.allocator()),
         },
         .zig_exe = zig_exe,
         .environ_map = try init.environ.createMap(arena),
diff --git a/lib/std/Build/Cache.zig b/lib/std/Build/Cache.zig
index e35beca617d3d1913571195f17e4cb88795f10f2..f595435749554ce81fa8b183792e918ae3ee9aca 100644
--- a/lib/std/Build/Cache.zig
+++ b/lib/std/Build/Cache.zig
@@ -1315,7 +1315,7 @@ test "cache file and then recall it" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.getCwdAlloc(testing.allocator);
+    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_file = "test.txt";
@@ -1383,7 +1383,7 @@ test "check that changing a file makes cache fail" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.getCwdAlloc(testing.allocator);
+    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_file = "cache_hash_change_file_test.txt";
@@ -1459,7 +1459,7 @@ test "no file inputs" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.getCwdAlloc(testing.allocator);
+    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_manifest_dir = "no_file_inputs_manifest_dir";
@@ -1509,7 +1509,7 @@ test "Manifest with files added after initial hash work" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.getCwdAlloc(testing.allocator);
+    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_file1 = "cache_hash_post_file_test1.txt";
diff --git a/lib/std/Build/Step/Options.zig b/lib/std/Build/Step/Options.zig
index 6c316b35fccd47ccf21872fd72a1cb9fb8fab8cd..adef0484237e8bde983662998eee35d764393c1d 100644
--- a/lib/std/Build/Step/Options.zig
+++ b/lib/std/Build/Step/Options.zig
@@ -519,7 +519,7 @@ test Options {
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();
 
-    const cwd = try std.process.getCwdAlloc(std.testing.allocator);
+    const cwd = try std.process.currentDirAlloc(io, std.testing.allocator);
     defer std.testing.allocator.free(cwd);
 
     var graph: std.Build.Graph = .{
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 80a0e248074c08ac83b53151fcd8680b20eadc46..20c23e804ec3b05e9ada2f55fa82f579bc136a09 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -665,6 +665,7 @@ pub const VTable = struct {
     lockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!LockedStderr,
     tryLockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!?LockedStderr,
     unlockStderr: *const fn (?*anyopaque) void,
+    processCurrentDir: *const fn (?*anyopaque, buffer: []u8) std.process.CurrentDirError!usize,
     processSetCurrentDir: *const fn (?*anyopaque, Dir) std.process.SetCurrentDirError!void,
     processReplace: *const fn (?*anyopaque, std.process.ReplaceOptions) std.process.ReplaceError,
     processReplacePath: *const fn (?*anyopaque, Dir, std.process.ReplaceOptions) std.process.ReplaceError,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c74850ca0a3b653f011cb30ab971f9e5a8c46958..2690734e87c60e1fe41a95329e38b2a10cc3bf22 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1643,6 +1643,7 @@ pub fn io(t: *Threaded) Io {
             .lockStderr = lockStderr,
             .tryLockStderr = tryLockStderr,
             .unlockStderr = unlockStderr,
+            .processCurrentDir = processCurrentDir,
             .processSetCurrentDir = processSetCurrentDir,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
@@ -1801,6 +1802,7 @@ pub fn ioBasic(t: *Threaded) Io {
             .lockStderr = lockStderr,
             .tryLockStderr = tryLockStderr,
             .unlockStderr = unlockStderr,
+            .processCurrentDir = processCurrentDir,
             .processSetCurrentDir = processSetCurrentDir,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
@@ -12600,6 +12602,46 @@ fn unlockStderr(userdata: ?*anyopaque) void {
     process.stderr_thread_mutex.unlock();
 }
 
+fn processCurrentDir(userdata: ?*anyopaque, buffer: []u8) process.CurrentDirError!usize {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+    if (is_windows) {
+        var wtf16le_buf: [windows.PATH_MAX_WIDE:0]u16 = undefined;
+        const n = windows.ntdll.RtlGetCurrentDirectory_U(wtf16le_buf.len + 1, &wtf16le_buf);
+        if (n == 0) return error.Unexpected;
+        assert(n <= wtf16le_buf.len);
+        const wtf16le_slice = wtf16le_buf[0..n];
+        var end_index: usize = 0;
+        var it = std.unicode.Wtf16LeIterator.init(wtf16le_slice);
+        while (it.nextCodepoint()) |codepoint| {
+            const seq_len = std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
+            if (end_index + seq_len >= buffer.len)
+                return error.NameTooLong;
+            end_index += std.unicode.wtf8Encode(codepoint, buffer[end_index..]) catch unreachable;
+        }
+        return end_index;
+    } else if (native_os == .wasi and !builtin.link_libc) {
+        if (buffer.len == 0) return error.NameTooLong;
+        buffer[0] = '.';
+        return 1;
+    }
+
+    const err: posix.E = if (builtin.link_libc) err: {
+        const c_err = if (std.c.getcwd(buffer.ptr, buffer.len)) |_| 0 else std.c._errno().*;
+        break :err @enumFromInt(c_err);
+    } else err: {
+        break :err posix.errno(posix.system.getcwd(buffer.ptr, buffer.len));
+    };
+    switch (err) {
+        .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
+        .NOENT => return error.CurrentWorkingDirectoryUnlinked,
+        .RANGE => return error.NameTooLong,
+        .FAULT => |e| return errnoBug(e),
+        .INVAL => |e| return errnoBug(e),
+        else => return posix.unexpectedErrno(err),
+    }
+}
+
 fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
     if (native_os == .wasi) return error.OperationUnsupported;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 4d7077bfc31ed62cf3597e6cf7df24a6dbc058a6..be59393e3da32ee7e1ace2bab04d37fb1fc45b87 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -1787,7 +1787,7 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
 
     const gpa = testing.allocator;
 
-    const cwd = try std.process.getCwdAlloc(gpa);
+    const cwd = try std.process.currentDirAlloc(io, gpa);
     defer gpa.free(cwd);
 
     const filename = try Dir.path.resolve(gpa, &.{ cwd, sub_path });
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 47c5a4d8567326a46709250d6a070fae752cce14..b9653b3ac9979d9eb5144822fb7ed27f802a55a7 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -2878,34 +2878,6 @@ pub fn CloseHandle(hObject: HANDLE) void {
     assert(ntdll.NtClose(hObject) == .SUCCESS);
 }
 
-pub const GetCurrentDirectoryError = error{
-    NameTooLong,
-    Unexpected,
-};
-
-/// The result is a slice of `buffer`, indexed from 0.
-/// The result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
-pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
-    var wtf16le_buf: [PATH_MAX_WIDE:0]u16 = undefined;
-    const result = kernel32.GetCurrentDirectoryW(wtf16le_buf.len + 1, &wtf16le_buf);
-    if (result == 0) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-    assert(result <= wtf16le_buf.len);
-    const wtf16le_slice = wtf16le_buf[0..result];
-    var end_index: usize = 0;
-    var it = std.unicode.Wtf16LeIterator.init(wtf16le_slice);
-    while (it.nextCodepoint()) |codepoint| {
-        const seq_len = std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
-        if (end_index + seq_len >= buffer.len)
-            return error.NameTooLong;
-        end_index += std.unicode.wtf8Encode(codepoint, buffer[end_index..]) catch unreachable;
-    }
-    return buffer[0..end_index];
-}
-
 pub const GetStdHandleError = error{
     NoStandardHandleAttached,
     Unexpected,
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index ad232046ef87f7790397592cac41c7955722740f..fe28e40cbbedbd7381c2b787c27798589d75b7cc 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -128,12 +128,6 @@ pub extern "kernel32" fn SetFileCompletionNotificationModes(
     Flags: UCHAR,
 ) callconv(.winapi) BOOL;
 
-// TODO: `RtlGetCurrentDirectory_U(nBufferLength * 2, lpBuffer)`
-pub extern "kernel32" fn GetCurrentDirectoryW(
-    nBufferLength: DWORD,
-    lpBuffer: ?[*]WCHAR,
-) callconv(.winapi) DWORD;
-
 pub extern "kernel32" fn ReadFile(
     hFile: HANDLE,
     lpBuffer: LPVOID,
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index ee3cdeb069d01719322a634965dfa0a3882e3a9b..52361ed982942864af6bd395a947e35e600b7adc 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -496,6 +496,11 @@ pub extern "ntdll" fn RtlGetFullPathName_U(
     ShortName: ?*[*:0]const u16,
 ) callconv(.winapi) ULONG;
 
+pub extern "ntdll" fn RtlGetCurrentDirectory_U(
+    BufferLength: ULONG,
+    Buffer: [*]u16,
+) callconv(.winapi) ULONG;
+
 pub extern "ntdll" fn RtlGetSystemTimePrecise() callconv(.winapi) LARGE_INTEGER;
 
 pub extern "ntdll" fn RtlInitializeCriticalSection(
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index a12182b4065d1ee518bd7c82ac938c4b4e693ea0..6bcb18155248f291d12848b93da4d6576f819b57 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -519,40 +519,6 @@ pub fn getppid() pid_t {
     return system.getppid();
 }
 
-pub const GetCwdError = error{
-    NameTooLong,
-    /// Not possible on Windows.
-    CurrentWorkingDirectoryUnlinked,
-} || UnexpectedError;
-
-/// The result is a slice of out_buffer, indexed from 0.
-pub fn getcwd(out_buffer: []u8) GetCwdError![]u8 {
-    if (native_os == .windows) {
-        return windows.GetCurrentDirectory(out_buffer);
-    } else if (native_os == .wasi and !builtin.link_libc) {
-        const path = ".";
-        if (out_buffer.len < path.len) return error.NameTooLong;
-        const result = out_buffer[0..path.len];
-        @memcpy(result, path);
-        return result;
-    }
-
-    const err: E = if (builtin.link_libc) err: {
-        const c_err = if (std.c.getcwd(out_buffer.ptr, out_buffer.len)) |_| 0 else std.c._errno().*;
-        break :err @enumFromInt(c_err);
-    } else err: {
-        break :err errno(system.getcwd(out_buffer.ptr, out_buffer.len));
-    };
-    switch (err) {
-        .SUCCESS => return mem.sliceTo(out_buffer, 0),
-        .FAULT => unreachable,
-        .INVAL => unreachable,
-        .NOENT => return error.CurrentWorkingDirectoryUnlinked,
-        .RANGE => return error.NameTooLong,
-        else => return unexpectedErrno(err),
-    }
-}
-
 pub const SocketError = error{
     /// Permission to create a socket of the specified type and/or
     /// pro‐tocol is denied.
diff --git a/lib/std/process.zig b/lib/std/process.zig
index a3547e2b0ffebe1164519a056117540868ac54cd..dd3e07c1eaf62dfd7011eeeaada3f8e44711b0bb 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -63,53 +63,40 @@ pub const Init = struct {
     };
 };
 
-pub const GetCwdError = posix.GetCwdError;
+pub const CurrentDirError = error{
+    NameTooLong,
+    /// Not possible on Windows. Always returned on WASI.
+    CurrentWorkingDirectoryUnlinked,
+} || Io.UnexpectedError;
 
-/// The result is a slice of `out_buffer`, from index `0`.
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
-/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
-pub fn getCwd(out_buffer: []u8) GetCwdError![]u8 {
-    return posix.getcwd(out_buffer);
+/// On other platforms, the result is an opaque sequence of bytes with no
+/// particular encoding.
+pub fn currentDir(io: Io, buffer: []u8) CurrentDirError!usize {
+    return io.vtable.processCurrentDir(io.userdata, buffer);
 }
 
-// Same as GetCwdError, minus error.NameTooLong + Allocator.Error
-pub const GetCwdAllocError = Allocator.Error || error{
-    /// Not possible on Windows.
+pub const CurrentDirAllocError = Allocator.Error || error{
+    /// Not possible on Windows. Always returned on WASI.
     CurrentWorkingDirectoryUnlinked,
-} || posix.UnexpectedError;
+} || Io.UnexpectedError;
 
-/// Caller must free the returned memory.
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
-/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
-pub fn getCwdAlloc(allocator: Allocator) GetCwdAllocError![]u8 {
-    // The use of max_path_bytes here is just a heuristic: most paths will fit
-    // in stack_buf, avoiding an extra allocation in the common case.
-    var stack_buf: [max_path_bytes]u8 = undefined;
-    var heap_buf: ?[]u8 = null;
-    defer if (heap_buf) |buf| allocator.free(buf);
-
-    var current_buf: []u8 = &stack_buf;
-    while (true) {
-        if (posix.getcwd(current_buf)) |slice| {
-            return allocator.dupe(u8, slice);
-        } else |err| switch (err) {
-            error.NameTooLong => {
-                // The path is too long to fit in stack_buf. Allocate geometrically
-                // increasing buffers until we find one that works
-                const new_capacity = current_buf.len * 2;
-                if (heap_buf) |buf| allocator.free(buf);
-                current_buf = try allocator.alloc(u8, new_capacity);
-                heap_buf = current_buf;
-            },
-            else => |e| return e,
-        }
-    }
+/// On other platforms, the result is an opaque sequence of bytes with no
+/// particular encoding.
+///
+/// Caller owns returned memory.
+pub fn currentDirAlloc(io: Io, allocator: Allocator) CurrentDirAllocError![:0]u8 {
+    var buffer: [max_path_bytes]u8 = undefined;
+    const n = currentDir(io, &buffer) catch |err| switch (err) {
+        error.NameTooLong => unreachable,
+        else => |e| return e,
+    };
+    return allocator.dupeZ(u8, buffer[0..n]);
 }
 
-test getCwdAlloc {
-    if (native_os == .wasi) return error.SkipZigTest;
-
-    const cwd = try getCwdAlloc(testing.allocator);
+test currentDirAlloc {
+    const cwd = try currentDirAlloc(testing.io, testing.allocator);
     testing.allocator.free(cwd);
 }
 
@@ -466,7 +453,7 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
     return io.vtable.processSpawnPath(io.userdata, dir, options);
 }
 
-pub const RunError = posix.GetCwdError || posix.ReadError || SpawnError || posix.PollError || error{
+pub const RunError = CurrentDirError || posix.ReadError || SpawnError || posix.PollError || error{
     StdoutStreamTooLong,
     StderrStreamTooLong,
 };
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 15c1837ec2dfb6a8f23691868b3f414828d4af5e..180968ac0cf69716e0d310fbc779f6be7ceda52f 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -767,7 +767,7 @@ pub const Directories = struct {
     ) Directories {
         const wasi = builtin.target.os.tag == .wasi;
 
-        const cwd = introspect.getResolvedCwd(arena) catch |err| {
+        const cwd = introspect.getResolvedCwd(io, arena) catch |err| {
             fatal("unable to get cwd: {t}", .{err});
         };
 
diff --git a/src/introspect.zig b/src/introspect.zig
index fa04e7de58a1fda94f9311fc1bb21a7266558e3f..36e94e979fc14e1ff92408d585544b2524901e7c 100644
--- a/src/introspect.zig
+++ b/src/introspect.zig
@@ -43,7 +43,7 @@ fn testZigInstallPrefix(io: Io, base_dir: Io.Dir) ?Cache.Directory {
 
 /// Both the directory handle and the path are newly allocated resources which the caller now owns.
 pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
-    const cwd_path = try getResolvedCwd(gpa);
+    const cwd_path = try getResolvedCwd(io, gpa);
     defer gpa.free(cwd_path);
     const self_exe_path = try std.process.executablePathAlloc(io, gpa);
     defer gpa.free(self_exe_path);
@@ -51,23 +51,23 @@ pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
     return findZigLibDirFromSelfExe(gpa, io, cwd_path, self_exe_path);
 }
 
-/// Like `std.process.getCwdAlloc`, but also resolves the path with `Dir.path.resolve`. This
+/// Like `std.process.currentDirAlloc`, but also resolves the path with `Dir.path.resolve`. This
 /// means the path has no repeated separators, no "." or ".." components, and no trailing separator.
 /// On WASI, "" is returned instead of ".".
-pub fn getResolvedCwd(gpa: Allocator) error{
+pub fn getResolvedCwd(io: Io, gpa: Allocator) error{
     OutOfMemory,
     CurrentWorkingDirectoryUnlinked,
     Unexpected,
 }![]u8 {
     if (builtin.target.os.tag == .wasi) {
         if (std.debug.runtime_safety) {
-            const cwd = try std.process.getCwdAlloc(gpa);
+            const cwd = try std.process.currentDirAlloc(io, gpa);
             defer gpa.free(cwd);
             assert(mem.eql(u8, cwd, "."));
         }
         return "";
     }
-    const cwd = try std.process.getCwdAlloc(gpa);
+    const cwd = try std.process.currentDirAlloc(io, gpa);
     defer gpa.free(cwd);
     const resolved = try Dir.path.resolve(gpa, &.{cwd});
     assert(Dir.path.isAbsolute(resolved));
diff --git a/src/main.zig b/src/main.zig
index f914593bce3a53cc513c1dec51075f5aad70f5b1..0efab88f6ada4d8f830a0d7614fa2e3462ba0332 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -4775,7 +4775,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
         }
     }
 
-    const cwd_path = try introspect.getResolvedCwd(arena);
+    const cwd_path = try introspect.getResolvedCwd(io, arena);
     const cwd_basename = fs.path.basename(cwd_path);
     const sanitized_root_name = try sanitizeExampleName(arena, cwd_basename);
 
@@ -5141,7 +5141,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
 
     process.raiseFileDescriptorLimit();
 
-    const cwd_path = try introspect.getResolvedCwd(arena);
+    const cwd_path = try introspect.getResolvedCwd(io, arena);
     const build_root = try findBuildRoot(arena, io, .{
         .cwd_path = cwd_path,
         .build_file = build_file,
@@ -7077,7 +7077,7 @@ fn cmdFetch(
         },
     };
 
-    const cwd_path = try introspect.getResolvedCwd(arena);
+    const cwd_path = try introspect.getResolvedCwd(io, arena);
 
     var build_root = try findBuildRoot(arena, io, .{
         .cwd_path = cwd_path,
@@ -7288,7 +7288,7 @@ const FindBuildRootOptions = struct {
 };
 
 fn findBuildRoot(arena: Allocator, io: Io, options: FindBuildRootOptions) !BuildRoot {
-    const cwd_path = options.cwd_path orelse try introspect.getResolvedCwd(arena);
+    const cwd_path = options.cwd_path orelse try introspect.getResolvedCwd(io, arena);
     const build_zig_basename = if (options.build_file) |bf|
         fs.path.basename(bf)
     else
@@ -7490,7 +7490,7 @@ fn writeSimpleTemplateFile(io: Io, file_name: []const u8, comptime fmt: []const
 }
 
 fn findTemplates(gpa: Allocator, arena: Allocator, io: Io) Templates {
-    const cwd_path = introspect.getResolvedCwd(arena) catch |err| {
+    const cwd_path = introspect.getResolvedCwd(io, arena) catch |err| {
         fatal("unable to get cwd: {t}", .{err});
     };
     const self_exe_path = process.executablePathAlloc(io, arena) catch |err| {
diff --git a/test/standalone/child_process/main.zig b/test/standalone/child_process/main.zig
index 2776c3e95c88d5158b9db122d6b9669871ba23e9..159be62a9d1e6beb8495a628baabb18898e126ef 100644
--- a/test/standalone/child_process/main.zig
+++ b/test/standalone/child_process/main.zig
@@ -9,7 +9,14 @@ pub fn main(init: std.process.Init.Minimal) !void {
     };
     const gpa = gpa_state.allocator();
 
-    const process_cwd_path = try std.process.getCwdAlloc(gpa);
+    var threaded: Io.Threaded = .init(gpa, .{
+        .argv0 = .init(init.args),
+        .environ = init.environ,
+    });
+    defer threaded.deinit();
+    const io = threaded.io();
+
+    const process_cwd_path = try std.process.currentDirAlloc(io, gpa);
     defer gpa.free(process_cwd_path);
 
     var environ_map = try init.environ.createMap(gpa);
@@ -27,13 +34,6 @@ pub fn main(init: std.process.Init.Minimal) !void {
     };
     defer if (needs_free) gpa.free(child_path);
 
-    var threaded: Io.Threaded = .init(gpa, .{
-        .argv0 = .init(init.args),
-        .environ = init.environ,
-    });
-    defer threaded.deinit();
-    const io = threaded.io();
-
     var child = try std.process.spawn(io, .{
         .argv = &.{ child_path, "hello arg" },
         .stdin = .pipe,
diff --git a/test/standalone/posix/cwd.zig b/test/standalone/posix/cwd.zig
index 7a9517b412814aa2e6f7f76b28e8220333e82814..e5e376784a1d64dbb2323a10a70680d69edbe399 100644
--- a/test/standalone/posix/cwd.zig
+++ b/test/standalone/posix/cwd.zig
@@ -13,43 +13,44 @@ pub fn main(init: std.process.Init) !void {
         .windows => return, // POSIX is not implemented by Windows
         else => {},
     }
+    const io = init.io;
     const args = try init.minimal.args.toSlice(init.arena.allocator());
     const tmp_dir_path = args[1];
 
     var tmp_dir = try Io.Dir.cwd().openDir(init.io, tmp_dir_path, .{});
     defer tmp_dir.close(init.io);
 
-    try test_chdir_self();
-    try test_chdir_absolute();
-    try test_chdir_relative(init.gpa, init.io, tmp_dir);
+    try test_chdir_self(io);
+    try test_chdir_absolute(io);
+    try test_chdir_relative(init.gpa, io, tmp_dir);
 }
 
 // get current working directory and expect it to match given path
-fn expect_cwd(expected_cwd: []const u8) !void {
+fn expect_cwd(io: Io, expected_cwd: []const u8) !void {
     var cwd_buf: [path_max]u8 = undefined;
-    const actual_cwd = try std.posix.getcwd(cwd_buf[0..]);
+    const actual_cwd = cwd_buf[0..try std.process.currentDir(io, &cwd_buf)];
     try std.testing.expectEqualStrings(actual_cwd, expected_cwd);
 }
 
-fn test_chdir_self() !void {
+fn test_chdir_self(io: Io) !void {
     var old_cwd_buf: [path_max]u8 = undefined;
-    const old_cwd = try std.posix.getcwd(old_cwd_buf[0..]);
+    const old_cwd = old_cwd_buf[0..try std.process.currentDir(io, &old_cwd_buf)];
 
     // Try changing to the current directory
     try std.Io.Threaded.chdir(old_cwd);
-    try expect_cwd(old_cwd);
+    try expect_cwd(io, old_cwd);
 }
 
-fn test_chdir_absolute() !void {
+fn test_chdir_absolute(io: Io) !void {
     var old_cwd_buf: [path_max]u8 = undefined;
-    const old_cwd = try std.posix.getcwd(old_cwd_buf[0..]);
+    const old_cwd = old_cwd_buf[0..try std.process.currentDir(io, &old_cwd_buf)];
 
     const parent = std.fs.path.dirname(old_cwd) orelse unreachable; // old_cwd should be absolute
 
     // Try changing to the parent via a full path
     try std.Io.Threaded.chdir(parent);
 
-    try expect_cwd(parent);
+    try expect_cwd(io, parent);
 }
 
 fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
@@ -61,7 +62,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
 
     // Capture base working directory path, to build expected full path
     var base_cwd_buf: [path_max]u8 = undefined;
-    const base_cwd = try std.posix.getcwd(base_cwd_buf[0..]);
+    const base_cwd = base_cwd_buf[0..try std.process.currentDir(io, &base_cwd_buf)];
 
     const expected_path = try std.fs.path.resolve(gpa, &.{ base_cwd, subdir_path });
     defer gpa.free(expected_path);
@@ -70,7 +71,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
     try std.Io.Threaded.chdir(subdir_path);
 
     var new_cwd_buf: [path_max]u8 = undefined;
-    const new_cwd = try std.posix.getcwd(new_cwd_buf[0..]);
+    const new_cwd = new_cwd_buf[0..try std.process.currentDir(io, &new_cwd_buf)];
 
     // On Windows, fs.path.resolve returns an uppercase drive letter, but the drive letter returned by getcwd may be lowercase
     const resolved_cwd = try std.fs.path.resolve(gpa, &.{new_cwd});
diff --git a/test/standalone/self_exe_symlink/create-symlink.zig b/test/standalone/self_exe_symlink/create-symlink.zig
index 32610ebcde6d07a4d1ef14b1dca4fab3dd3bd90b..aaa015c4b0d4332c5677851072a204d6fcd94e90 100644
--- a/test/standalone/self_exe_symlink/create-symlink.zig
+++ b/test/standalone/self_exe_symlink/create-symlink.zig
@@ -9,7 +9,7 @@ pub fn main(init: std.process.Init) !void {
     const exe_path = it.next() orelse unreachable;
     const symlink_path = it.next() orelse unreachable;
 
-    const cwd = try std.process.getCwdAlloc(init.arena.allocator());
+    const cwd = try std.process.currentDirAlloc(io, init.arena.allocator());
 
     // If `exe_path` is relative to our cwd, we need to convert it to be relative to the dirname of `symlink_path`.
     const exe_rel_path = try std.fs.path.relative(gpa, cwd, init.environ_map, std.fs.path.dirname(symlink_path) orelse ".", exe_path);
diff --git a/test/standalone/windows_paths/relative.zig b/test/standalone/windows_paths/relative.zig
index 7b3725e4eec0b5e5774f7ac3650321b959193504..7dcde62d50dbfc13663251ae4600e3340cd79e8d 100644
--- a/test/standalone/windows_paths/relative.zig
+++ b/test/standalone/windows_paths/relative.zig
@@ -4,7 +4,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const args = try init.minimal.args.toSlice(arena);
     const io = init.io;
-    const cwd_path = try std.process.getCwdAlloc(arena);
+    const cwd_path = try std.process.currentDirAlloc(io, arena);
 
     if (args.len < 3) return error.MissingArgs;
 
diff --git a/test/standalone/windows_paths/test.zig b/test/standalone/windows_paths/test.zig
index 94afe163372b1cfdceaa5bd4ac32908b0c711657..47b13415a8396bb5f499966c9c42c4dbd2cc5665 100644
--- a/test/standalone/windows_paths/test.zig
+++ b/test/standalone/windows_paths/test.zig
@@ -10,7 +10,7 @@ pub fn main(init: std.process.Init) !void {
 
     const exe_path = args[1];
 
-    const cwd_path = try std.process.getCwdAlloc(arena);
+    const cwd_path = try std.process.currentDirAlloc(io, arena);
     const parsed_cwd_path = std.fs.path.parsePathWindows(u8, cwd_path);
 
     if (parsed_cwd_path.kind == .drive_absolute and !std.ascii.isAlphabetic(cwd_path[0])) {
diff --git a/test/standalone/windows_spawn/main.zig b/test/standalone/windows_spawn/main.zig
index add20921b5d4b51bf2570d62077329e6f11efd3b..0bb8e7fe16dfba1676fa08013dddcd857250e0e4 100644
--- a/test/standalone/windows_spawn/main.zig
+++ b/test/standalone/windows_spawn/main.zig
@@ -8,7 +8,7 @@ const utf16Literal = std.unicode.utf8ToUtf16LeStringLiteral;
 pub fn main(init: std.process.Init) !void {
     const gpa = init.gpa;
     const io = init.io;
-    const process_cwd_path = try std.process.getCwdAlloc(init.arena.allocator());
+    const process_cwd_path = try std.process.currentDirAlloc(io, init.arena.allocator());
     var initial_process_cwd = try Io.Dir.cwd().openDir(io, ".", .{});
     defer initial_process_cwd.close(io);
 
diff --git a/tools/doctest.zig b/tools/doctest.zig
index 5037bac2c2fc1aa712e0d3e4217b2925b59e6cd2..5afec8e62c7313b577a5eeb9ab05d88a560f21b2 100644
--- a/tools/doctest.zig
+++ b/tools/doctest.zig
@@ -33,7 +33,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const io = init.io;
     const environ_map = init.environ_map;
-    const cwd_path = try std.process.getCwdAlloc(arena);
+    const cwd_path = try std.process.currentDirAlloc(io, arena);
 
     try environ_map.put("CLICOLOR_FORCE", "1");
 
diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index daf93be73f8e1dcf7beb294fa4307f4d1726d80a..e15a91b548b4f3e74bcd3bd30b23ba56e7287935 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -32,7 +32,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const io = init.io;
     const environ_map = init.environ_map;
-    const cwd_path = try std.process.getCwdAlloc(arena);
+    const cwd_path = try std.process.currentDirAlloc(io, arena);
 
     var opt_zig_exe: ?[]const u8 = null;
     var opt_input_file_name: ?[]const u8 = null;
diff --git a/tools/process_headers.zig b/tools/process_headers.zig
index 0c72299055e11d1c02364d8e8d5afd0da2c460e2..6e5ab387979566901bb7406dc87a9d330b989a2a 100644
--- a/tools/process_headers.zig
+++ b/tools/process_headers.zig
@@ -145,7 +145,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const io = init.io;
     const args = try init.minimal.args.toSlice(arena);
-    const cwd_path = try std.process.getCwdAlloc(arena);
+    const cwd_path = try std.process.currentDirAlloc(io, arena);
     const environ_map = init.environ_map;
 
     var search_paths = std.array_list.Managed([]const u8).init(arena);
diff --git a/tools/update-linux-headers.zig b/tools/update-linux-headers.zig
index e05ba082031cbee62f0aab9638f127bfbc2ae0ff..649459a634b94cd73c6845d656b36e5c078dfbec 100644
--- a/tools/update-linux-headers.zig
+++ b/tools/update-linux-headers.zig
@@ -146,7 +146,7 @@ pub fn main(init: std.process.Init) !void {
     const io = init.io;
     const args = try init.minimal.args.toSlice(arena);
     const environ_map = init.environ_map;
-    const cwd = try std.process.getCwdAlloc(arena);
+    const cwd = try std.process.currentDirAlloc(io, arena);
 
     var search_paths = std.array_list.Managed([]const u8).init(arena);
     var opt_out_dir: ?[]const u8 = null;
-- 
2.54.0


From 3cc5dda7568b845d5002be4dd3181145ecc3f8bd Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 23:18:24 -0800
Subject: [PATCH 075/499] fix RtlGetCurrentDirectory_U parameter

it's the byte length not number of wchars
---
 lib/std/Io/Threaded.zig      | 2 +-
 lib/std/os/windows/ntdll.zig | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 2690734e87c60e1fe41a95329e38b2a10cc3bf22..1a15bae33b89b60895f5130bae24cd61b9da4e4c 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -12607,7 +12607,7 @@ fn processCurrentDir(userdata: ?*anyopaque, buffer: []u8) process.CurrentDirErro
     _ = t;
     if (is_windows) {
         var wtf16le_buf: [windows.PATH_MAX_WIDE:0]u16 = undefined;
-        const n = windows.ntdll.RtlGetCurrentDirectory_U(wtf16le_buf.len + 1, &wtf16le_buf);
+        const n = windows.ntdll.RtlGetCurrentDirectory_U(wtf16le_buf.len * 2 + 2, &wtf16le_buf) / 2;
         if (n == 0) return error.Unexpected;
         assert(n <= wtf16le_buf.len);
         const wtf16le_slice = wtf16le_buf[0..n];
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 52361ed982942864af6bd395a947e35e600b7adc..f61cbbf5b8fe8bc468ad2f93638ca60503c54ed2 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -497,7 +497,7 @@ pub extern "ntdll" fn RtlGetFullPathName_U(
 ) callconv(.winapi) ULONG;
 
 pub extern "ntdll" fn RtlGetCurrentDirectory_U(
-    BufferLength: ULONG,
+    BufferByteLength: ULONG,
     Buffer: [*]u16,
 ) callconv(.winapi) ULONG;
 
-- 
2.54.0


From 0a37ad2ec4daa04a845142508e0dd1326db7ee2d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 01:13:32 -0800
Subject: [PATCH 076/499] std.Io.File: handle DISK_FULL on windows

---
 lib/std/Io/Threaded.zig | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1a15bae33b89b60895f5130bae24cd61b9da4e4c..1a01795213ad9aafa46e8492cfdd13cb4a7c677a 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2730,6 +2730,7 @@ fn dirCreateDirPathOpenWindows(
             // This can happen if the directory has 'List folder contents' permission set to 'Deny'
             // and the directory is trying to be opened for iteration.
             .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .DISK_FULL => return syscall.fail(error.NoSpaceLeft),
             .INVALID_PARAMETER => |s| return syscall.ntstatusBug(s),
             else => |s| return syscall.unexpectedNtstatus(s),
         };
@@ -3670,6 +3671,7 @@ fn dirCreateFileWindows(
         .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
         .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
         .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
+        .DISK_FULL => return syscall.fail(error.NoSpaceLeft),
         .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
         .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
         .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
@@ -9215,6 +9217,7 @@ fn writeFilePositionalWindows(
             .LOCK_VIOLATION => return syscall.fail(error.LockViolation),
             .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
             .WORKING_SET_QUOTA => return syscall.fail(error.SystemResources),
+            .DISK_FULL => return syscall.fail(error.NoSpaceLeft),
             else => |err| {
                 syscall.finish();
                 return windows.unexpectedError(err);
@@ -9375,6 +9378,7 @@ fn writeFileStreamingWindows(
             .LOCK_VIOLATION => return syscall.fail(error.LockViolation),
             .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
             .WORKING_SET_QUOTA => return syscall.fail(error.SystemResources),
+            .DISK_FULL => return syscall.fail(error.NoSpaceLeft),
             else => |err| {
                 syscall.finish();
                 return windows.unexpectedError(err);
-- 
2.54.0


From b1d1806fef56a72d0df14ad3a54c3074b1e55a69 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 18:47:58 -0800
Subject: [PATCH 077/499] std.process: currentDir -> currentPath

In Zig standard library, Dir means an open directory handle. path
represents a file system identifier string. This function is better
named after "current path" than "current dir". "get" and "working" are
superfluous.
---
 lib/compiler/build_runner.zig                 |  2 +-
 lib/std/Build/Cache.zig                       |  8 +++----
 lib/std/Build/Step/Options.zig                |  2 +-
 lib/std/Io.zig                                |  2 +-
 lib/std/Io/Threaded.zig                       |  8 +++----
 lib/std/fs/test.zig                           |  2 +-
 lib/std/process.zig                           | 22 +++++++++----------
 src/introspect.zig                            |  8 +++----
 test/standalone/child_process/main.zig        |  2 +-
 test/standalone/posix/cwd.zig                 | 10 ++++-----
 .../self_exe_symlink/create-symlink.zig       |  2 +-
 test/standalone/windows_paths/relative.zig    |  2 +-
 test/standalone/windows_paths/test.zig        |  2 +-
 test/standalone/windows_spawn/main.zig        |  2 +-
 tools/doctest.zig                             |  2 +-
 tools/incr-check.zig                          |  2 +-
 tools/process_headers.zig                     |  2 +-
 tools/update-linux-headers.zig                |  2 +-
 18 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 6ef8e71f7eea56aa1d5e7efd58c2f3af716e5b05..5ef74adabab9e651d9cc65730b43c4fd783a2aa0 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -83,7 +83,7 @@ pub fn main(init: process.Init.Minimal) !void {
             .io = io,
             .gpa = gpa,
             .manifest_dir = try local_cache_directory.handle.createDirPathOpen(io, "h", .{}),
-            .cwd = try process.currentDirAlloc(io, single_threaded_arena.allocator()),
+            .cwd = try process.currentPathAlloc(io, single_threaded_arena.allocator()),
         },
         .zig_exe = zig_exe,
         .environ_map = try init.environ.createMap(arena),
diff --git a/lib/std/Build/Cache.zig b/lib/std/Build/Cache.zig
index f595435749554ce81fa8b183792e918ae3ee9aca..0cf9dde5313a5c084c7c259542d6c0a83d415339 100644
--- a/lib/std/Build/Cache.zig
+++ b/lib/std/Build/Cache.zig
@@ -1315,7 +1315,7 @@ test "cache file and then recall it" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
+    const cwd = try std.process.currentPathAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_file = "test.txt";
@@ -1383,7 +1383,7 @@ test "check that changing a file makes cache fail" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
+    const cwd = try std.process.currentPathAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_file = "cache_hash_change_file_test.txt";
@@ -1459,7 +1459,7 @@ test "no file inputs" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
+    const cwd = try std.process.currentPathAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_manifest_dir = "no_file_inputs_manifest_dir";
@@ -1509,7 +1509,7 @@ test "Manifest with files added after initial hash work" {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
-    const cwd = try std.process.currentDirAlloc(io, testing.allocator);
+    const cwd = try std.process.currentPathAlloc(io, testing.allocator);
     defer testing.allocator.free(cwd);
 
     const temp_file1 = "cache_hash_post_file_test1.txt";
diff --git a/lib/std/Build/Step/Options.zig b/lib/std/Build/Step/Options.zig
index adef0484237e8bde983662998eee35d764393c1d..34073264e888553f1ff59b74959ede7a675b0241 100644
--- a/lib/std/Build/Step/Options.zig
+++ b/lib/std/Build/Step/Options.zig
@@ -519,7 +519,7 @@ test Options {
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();
 
-    const cwd = try std.process.currentDirAlloc(io, std.testing.allocator);
+    const cwd = try std.process.currentPathAlloc(io, std.testing.allocator);
     defer std.testing.allocator.free(cwd);
 
     var graph: std.Build.Graph = .{
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 20c23e804ec3b05e9ada2f55fa82f579bc136a09..72df9e34f3ec9523577a921a43eb3086586fca4e 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -665,7 +665,7 @@ pub const VTable = struct {
     lockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!LockedStderr,
     tryLockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!?LockedStderr,
     unlockStderr: *const fn (?*anyopaque) void,
-    processCurrentDir: *const fn (?*anyopaque, buffer: []u8) std.process.CurrentDirError!usize,
+    processCurrentPath: *const fn (?*anyopaque, buffer: []u8) std.process.CurrentPathError!usize,
     processSetCurrentDir: *const fn (?*anyopaque, Dir) std.process.SetCurrentDirError!void,
     processReplace: *const fn (?*anyopaque, std.process.ReplaceOptions) std.process.ReplaceError,
     processReplacePath: *const fn (?*anyopaque, Dir, std.process.ReplaceOptions) std.process.ReplaceError,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1a01795213ad9aafa46e8492cfdd13cb4a7c677a..87cf72190c3736ee5e3ca37cc983ce6f14b6e192 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1643,7 +1643,7 @@ pub fn io(t: *Threaded) Io {
             .lockStderr = lockStderr,
             .tryLockStderr = tryLockStderr,
             .unlockStderr = unlockStderr,
-            .processCurrentDir = processCurrentDir,
+            .processCurrentPath = processCurrentPath,
             .processSetCurrentDir = processSetCurrentDir,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
@@ -1802,7 +1802,7 @@ pub fn ioBasic(t: *Threaded) Io {
             .lockStderr = lockStderr,
             .tryLockStderr = tryLockStderr,
             .unlockStderr = unlockStderr,
-            .processCurrentDir = processCurrentDir,
+            .processCurrentPath = processCurrentPath,
             .processSetCurrentDir = processSetCurrentDir,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
@@ -12606,7 +12606,7 @@ fn unlockStderr(userdata: ?*anyopaque) void {
     process.stderr_thread_mutex.unlock();
 }
 
-fn processCurrentDir(userdata: ?*anyopaque, buffer: []u8) process.CurrentDirError!usize {
+fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
     if (is_windows) {
@@ -12638,7 +12638,7 @@ fn processCurrentDir(userdata: ?*anyopaque, buffer: []u8) process.CurrentDirErro
     };
     switch (err) {
         .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
-        .NOENT => return error.CurrentWorkingDirectoryUnlinked,
+        .NOENT => return error.CurrentDirUnlinked,
         .RANGE => return error.NameTooLong,
         .FAULT => |e| return errnoBug(e),
         .INVAL => |e| return errnoBug(e),
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index be59393e3da32ee7e1ace2bab04d37fb1fc45b87..d0ec6b33e9cda1cbf6b5d27eeb1e9e6d1b831dda 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -1787,7 +1787,7 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
 
     const gpa = testing.allocator;
 
-    const cwd = try std.process.currentDirAlloc(io, gpa);
+    const cwd = try std.process.currentPathAlloc(io, gpa);
     defer gpa.free(cwd);
 
     const filename = try Dir.path.resolve(gpa, &.{ cwd, sub_path });
diff --git a/lib/std/process.zig b/lib/std/process.zig
index dd3e07c1eaf62dfd7011eeeaada3f8e44711b0bb..5bcacddc84a993d96586b861411af63148f361ac 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -63,22 +63,22 @@ pub const Init = struct {
     };
 };
 
-pub const CurrentDirError = error{
+pub const CurrentPathError = error{
     NameTooLong,
     /// Not possible on Windows. Always returned on WASI.
-    CurrentWorkingDirectoryUnlinked,
+    CurrentDirUnlinked,
 } || Io.UnexpectedError;
 
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// On other platforms, the result is an opaque sequence of bytes with no
 /// particular encoding.
-pub fn currentDir(io: Io, buffer: []u8) CurrentDirError!usize {
-    return io.vtable.processCurrentDir(io.userdata, buffer);
+pub fn currentPath(io: Io, buffer: []u8) CurrentPathError!usize {
+    return io.vtable.processCurrentPath(io.userdata, buffer);
 }
 
-pub const CurrentDirAllocError = Allocator.Error || error{
+pub const CurrentPathAllocError = Allocator.Error || error{
     /// Not possible on Windows. Always returned on WASI.
-    CurrentWorkingDirectoryUnlinked,
+    CurrentDirUnlinked,
 } || Io.UnexpectedError;
 
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
@@ -86,17 +86,17 @@ pub const CurrentDirAllocError = Allocator.Error || error{
 /// particular encoding.
 ///
 /// Caller owns returned memory.
-pub fn currentDirAlloc(io: Io, allocator: Allocator) CurrentDirAllocError![:0]u8 {
+pub fn currentPathAlloc(io: Io, allocator: Allocator) CurrentPathAllocError![:0]u8 {
     var buffer: [max_path_bytes]u8 = undefined;
-    const n = currentDir(io, &buffer) catch |err| switch (err) {
+    const n = currentPath(io, &buffer) catch |err| switch (err) {
         error.NameTooLong => unreachable,
         else => |e| return e,
     };
     return allocator.dupeZ(u8, buffer[0..n]);
 }
 
-test currentDirAlloc {
-    const cwd = try currentDirAlloc(testing.io, testing.allocator);
+test currentPathAlloc {
+    const cwd = try currentPathAlloc(testing.io, testing.allocator);
     testing.allocator.free(cwd);
 }
 
@@ -453,7 +453,7 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
     return io.vtable.processSpawnPath(io.userdata, dir, options);
 }
 
-pub const RunError = CurrentDirError || posix.ReadError || SpawnError || posix.PollError || error{
+pub const RunError = CurrentPathError || posix.ReadError || SpawnError || posix.PollError || error{
     StdoutStreamTooLong,
     StderrStreamTooLong,
 };
diff --git a/src/introspect.zig b/src/introspect.zig
index 36e94e979fc14e1ff92408d585544b2524901e7c..0cba9fdcc4d5d97f03559ab205d3710f54205176 100644
--- a/src/introspect.zig
+++ b/src/introspect.zig
@@ -51,23 +51,23 @@ pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
     return findZigLibDirFromSelfExe(gpa, io, cwd_path, self_exe_path);
 }
 
-/// Like `std.process.currentDirAlloc`, but also resolves the path with `Dir.path.resolve`. This
+/// Like `std.process.currentPathAlloc`, but also resolves the path with `Dir.path.resolve`. This
 /// means the path has no repeated separators, no "." or ".." components, and no trailing separator.
 /// On WASI, "" is returned instead of ".".
 pub fn getResolvedCwd(io: Io, gpa: Allocator) error{
     OutOfMemory,
-    CurrentWorkingDirectoryUnlinked,
+    CurrentDirUnlinked,
     Unexpected,
 }![]u8 {
     if (builtin.target.os.tag == .wasi) {
         if (std.debug.runtime_safety) {
-            const cwd = try std.process.currentDirAlloc(io, gpa);
+            const cwd = try std.process.currentPathAlloc(io, gpa);
             defer gpa.free(cwd);
             assert(mem.eql(u8, cwd, "."));
         }
         return "";
     }
-    const cwd = try std.process.currentDirAlloc(io, gpa);
+    const cwd = try std.process.currentPathAlloc(io, gpa);
     defer gpa.free(cwd);
     const resolved = try Dir.path.resolve(gpa, &.{cwd});
     assert(Dir.path.isAbsolute(resolved));
diff --git a/test/standalone/child_process/main.zig b/test/standalone/child_process/main.zig
index 159be62a9d1e6beb8495a628baabb18898e126ef..d252ee414d48a546654c939a411bddf99788f57c 100644
--- a/test/standalone/child_process/main.zig
+++ b/test/standalone/child_process/main.zig
@@ -16,7 +16,7 @@ pub fn main(init: std.process.Init.Minimal) !void {
     defer threaded.deinit();
     const io = threaded.io();
 
-    const process_cwd_path = try std.process.currentDirAlloc(io, gpa);
+    const process_cwd_path = try std.process.currentPathAlloc(io, gpa);
     defer gpa.free(process_cwd_path);
 
     var environ_map = try init.environ.createMap(gpa);
diff --git a/test/standalone/posix/cwd.zig b/test/standalone/posix/cwd.zig
index e5e376784a1d64dbb2323a10a70680d69edbe399..2588bde34f018f97b2ef799d2809ef7872a3b7df 100644
--- a/test/standalone/posix/cwd.zig
+++ b/test/standalone/posix/cwd.zig
@@ -28,13 +28,13 @@ pub fn main(init: std.process.Init) !void {
 // get current working directory and expect it to match given path
 fn expect_cwd(io: Io, expected_cwd: []const u8) !void {
     var cwd_buf: [path_max]u8 = undefined;
-    const actual_cwd = cwd_buf[0..try std.process.currentDir(io, &cwd_buf)];
+    const actual_cwd = cwd_buf[0..try std.process.currentPath(io, &cwd_buf)];
     try std.testing.expectEqualStrings(actual_cwd, expected_cwd);
 }
 
 fn test_chdir_self(io: Io) !void {
     var old_cwd_buf: [path_max]u8 = undefined;
-    const old_cwd = old_cwd_buf[0..try std.process.currentDir(io, &old_cwd_buf)];
+    const old_cwd = old_cwd_buf[0..try std.process.currentPath(io, &old_cwd_buf)];
 
     // Try changing to the current directory
     try std.Io.Threaded.chdir(old_cwd);
@@ -43,7 +43,7 @@ fn test_chdir_self(io: Io) !void {
 
 fn test_chdir_absolute(io: Io) !void {
     var old_cwd_buf: [path_max]u8 = undefined;
-    const old_cwd = old_cwd_buf[0..try std.process.currentDir(io, &old_cwd_buf)];
+    const old_cwd = old_cwd_buf[0..try std.process.currentPath(io, &old_cwd_buf)];
 
     const parent = std.fs.path.dirname(old_cwd) orelse unreachable; // old_cwd should be absolute
 
@@ -62,7 +62,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
 
     // Capture base working directory path, to build expected full path
     var base_cwd_buf: [path_max]u8 = undefined;
-    const base_cwd = base_cwd_buf[0..try std.process.currentDir(io, &base_cwd_buf)];
+    const base_cwd = base_cwd_buf[0..try std.process.currentPath(io, &base_cwd_buf)];
 
     const expected_path = try std.fs.path.resolve(gpa, &.{ base_cwd, subdir_path });
     defer gpa.free(expected_path);
@@ -71,7 +71,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
     try std.Io.Threaded.chdir(subdir_path);
 
     var new_cwd_buf: [path_max]u8 = undefined;
-    const new_cwd = new_cwd_buf[0..try std.process.currentDir(io, &new_cwd_buf)];
+    const new_cwd = new_cwd_buf[0..try std.process.currentPath(io, &new_cwd_buf)];
 
     // On Windows, fs.path.resolve returns an uppercase drive letter, but the drive letter returned by getcwd may be lowercase
     const resolved_cwd = try std.fs.path.resolve(gpa, &.{new_cwd});
diff --git a/test/standalone/self_exe_symlink/create-symlink.zig b/test/standalone/self_exe_symlink/create-symlink.zig
index aaa015c4b0d4332c5677851072a204d6fcd94e90..36a0c09080a5d93876ed4fdb7768f406432e23b2 100644
--- a/test/standalone/self_exe_symlink/create-symlink.zig
+++ b/test/standalone/self_exe_symlink/create-symlink.zig
@@ -9,7 +9,7 @@ pub fn main(init: std.process.Init) !void {
     const exe_path = it.next() orelse unreachable;
     const symlink_path = it.next() orelse unreachable;
 
-    const cwd = try std.process.currentDirAlloc(io, init.arena.allocator());
+    const cwd = try std.process.currentPathAlloc(io, init.arena.allocator());
 
     // If `exe_path` is relative to our cwd, we need to convert it to be relative to the dirname of `symlink_path`.
     const exe_rel_path = try std.fs.path.relative(gpa, cwd, init.environ_map, std.fs.path.dirname(symlink_path) orelse ".", exe_path);
diff --git a/test/standalone/windows_paths/relative.zig b/test/standalone/windows_paths/relative.zig
index 7dcde62d50dbfc13663251ae4600e3340cd79e8d..6fd2fc188af1f77fd96da10e784d3874503fd562 100644
--- a/test/standalone/windows_paths/relative.zig
+++ b/test/standalone/windows_paths/relative.zig
@@ -4,7 +4,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const args = try init.minimal.args.toSlice(arena);
     const io = init.io;
-    const cwd_path = try std.process.currentDirAlloc(io, arena);
+    const cwd_path = try std.process.currentPathAlloc(io, arena);
 
     if (args.len < 3) return error.MissingArgs;
 
diff --git a/test/standalone/windows_paths/test.zig b/test/standalone/windows_paths/test.zig
index 47b13415a8396bb5f499966c9c42c4dbd2cc5665..1170de47ac7245480a48585a20089295d4cd82a4 100644
--- a/test/standalone/windows_paths/test.zig
+++ b/test/standalone/windows_paths/test.zig
@@ -10,7 +10,7 @@ pub fn main(init: std.process.Init) !void {
 
     const exe_path = args[1];
 
-    const cwd_path = try std.process.currentDirAlloc(io, arena);
+    const cwd_path = try std.process.currentPathAlloc(io, arena);
     const parsed_cwd_path = std.fs.path.parsePathWindows(u8, cwd_path);
 
     if (parsed_cwd_path.kind == .drive_absolute and !std.ascii.isAlphabetic(cwd_path[0])) {
diff --git a/test/standalone/windows_spawn/main.zig b/test/standalone/windows_spawn/main.zig
index 0bb8e7fe16dfba1676fa08013dddcd857250e0e4..4b37e3cf6ee28066e2424725d5e0412ab5f6764d 100644
--- a/test/standalone/windows_spawn/main.zig
+++ b/test/standalone/windows_spawn/main.zig
@@ -8,7 +8,7 @@ const utf16Literal = std.unicode.utf8ToUtf16LeStringLiteral;
 pub fn main(init: std.process.Init) !void {
     const gpa = init.gpa;
     const io = init.io;
-    const process_cwd_path = try std.process.currentDirAlloc(io, init.arena.allocator());
+    const process_cwd_path = try std.process.currentPathAlloc(io, init.arena.allocator());
     var initial_process_cwd = try Io.Dir.cwd().openDir(io, ".", .{});
     defer initial_process_cwd.close(io);
 
diff --git a/tools/doctest.zig b/tools/doctest.zig
index 5afec8e62c7313b577a5eeb9ab05d88a560f21b2..55b8ca7bfb87fae39b98550812b9dee165538f46 100644
--- a/tools/doctest.zig
+++ b/tools/doctest.zig
@@ -33,7 +33,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const io = init.io;
     const environ_map = init.environ_map;
-    const cwd_path = try std.process.currentDirAlloc(io, arena);
+    const cwd_path = try std.process.currentPathAlloc(io, arena);
 
     try environ_map.put("CLICOLOR_FORCE", "1");
 
diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index e15a91b548b4f3e74bcd3bd30b23ba56e7287935..c9564f85c25ac752e46f744a07fa519a83e54ac2 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -32,7 +32,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const io = init.io;
     const environ_map = init.environ_map;
-    const cwd_path = try std.process.currentDirAlloc(io, arena);
+    const cwd_path = try std.process.currentPathAlloc(io, arena);
 
     var opt_zig_exe: ?[]const u8 = null;
     var opt_input_file_name: ?[]const u8 = null;
diff --git a/tools/process_headers.zig b/tools/process_headers.zig
index 6e5ab387979566901bb7406dc87a9d330b989a2a..3be919b30358c24f46cbb8ef418ddd232c854168 100644
--- a/tools/process_headers.zig
+++ b/tools/process_headers.zig
@@ -145,7 +145,7 @@ pub fn main(init: std.process.Init) !void {
     const arena = init.arena.allocator();
     const io = init.io;
     const args = try init.minimal.args.toSlice(arena);
-    const cwd_path = try std.process.currentDirAlloc(io, arena);
+    const cwd_path = try std.process.currentPathAlloc(io, arena);
     const environ_map = init.environ_map;
 
     var search_paths = std.array_list.Managed([]const u8).init(arena);
diff --git a/tools/update-linux-headers.zig b/tools/update-linux-headers.zig
index 649459a634b94cd73c6845d656b36e5c078dfbec..c5f556f53c9cd2fa595aa3db9fc23cea27910843 100644
--- a/tools/update-linux-headers.zig
+++ b/tools/update-linux-headers.zig
@@ -146,7 +146,7 @@ pub fn main(init: std.process.Init) !void {
     const io = init.io;
     const args = try init.minimal.args.toSlice(arena);
     const environ_map = init.environ_map;
-    const cwd = try std.process.currentDirAlloc(io, arena);
+    const cwd = try std.process.currentPathAlloc(io, arena);
 
     var search_paths = std.array_list.Managed([]const u8).init(arena);
     var opt_out_dir: ?[]const u8 = null;
-- 
2.54.0


From ecb9ddf2672fa1f067c240d914a5baf3a4d2d8a4 Mon Sep 17 00:00:00 2001
From: Brandon Black <bblack@wikimedia.org>
Date: Wed, 28 Jan 2026 16:54:04 -0600
Subject: [PATCH 078/499] Threaded.sleepPosix: fix libc error handling

Confusingly, the POSIX spec for clock_nanosleep() says it returns
*positive* error values directly and does not touch `errno`. Not
detecting EINTR properly here was breaking the cancellation of
threads blocked in this call when linking libc.
---
 lib/std/Io/Threaded.zig | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c74850ca0a3b653f011cb30ab971f9e5a8c46958..b459c4e408695e184f227a22e7018ad009540a0f 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -10083,10 +10083,12 @@ fn sleepPosix(timeout: Io.Timeout) Io.SleepError!void {
     var timespec: posix.timespec = timestampToPosix(deadline_nanoseconds);
     const syscall: Syscall = try .start();
     while (true) {
-        switch (posix.errno(posix.system.clock_nanosleep(clock_id, .{ .ABSTIME = switch (timeout) {
+        const rc = posix.system.clock_nanosleep(clock_id, .{ .ABSTIME = switch (timeout) {
             .none, .duration => false,
             .deadline => true,
-        } }, &timespec, &timespec))) {
+        } }, &timespec, &timespec);
+        // POSIX-standard libc clock_nanosleep() returns *positive* errno values directly
+        switch (if (builtin.link_libc) @as(posix.E, @enumFromInt(rc)) else posix.errno(rc)) {
             .SUCCESS => {
                 syscall.finish();
                 return;
-- 
2.54.0


From ad0458f5826a9283df3e152fea24869d0914634d Mon Sep 17 00:00:00 2001
From: Pablo Alessandro Santos Hugen <phugen@redhat.com>
Date: Thu, 29 Jan 2026 19:24:39 -0300
Subject: [PATCH 079/499] std.Build: Fix wrong error enum

Signed-off-by: Pablo Alessandro Santos Hugen <phugen@redhat.com>
---
 lib/std/Build/Step/Run.zig | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index d822697ae56fa6ac6ab29fa083a8ca9aa53de652..d025e01af40f8d3580e37ad830ee7515f0608cb4 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1033,8 +1033,8 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     if (any_output) {
         const o_sub_path = "o" ++ Dir.path.sep_str ++ &digest;
 
-        b.cache_root.handle.rename(tmp_dir_path, b.cache_root.handle, o_sub_path, io) catch |err| {
-            if (err == error.PathAlreadyExists) {
+        b.cache_root.handle.rename(tmp_dir_path, b.cache_root.handle, o_sub_path, io) catch |err| switch (err) {
+            Dir.RenameError.DirNotEmpty => {
                 b.cache_root.handle.deleteTree(io, o_sub_path) catch |del_err| {
                     return step.fail("unable to remove dir '{f}'{s}: {t}", .{
                         b.cache_root, tmp_dir_path, del_err,
@@ -1045,11 +1045,10 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                         b.cache_root, tmp_dir_path, b.cache_root, o_sub_path, retry_err,
                     });
                 };
-            } else {
-                return step.fail("unable to rename dir '{f}{s}' to '{f}{s}': {t}", .{
-                    b.cache_root, tmp_dir_path, b.cache_root, o_sub_path, err,
-                });
-            }
+            },
+            else => return step.fail("unable to rename dir '{f}{s}' to '{f}{s}': {t}", .{
+                b.cache_root, tmp_dir_path, b.cache_root, o_sub_path, err,
+            }),
         };
     }
 
-- 
2.54.0


From ccd82ae7cc5ce3f708a919a070bffc7572416c62 Mon Sep 17 00:00:00 2001
From: lzm-build <3575188313@qq.com>
Date: Fri, 30 Jan 2026 07:18:13 +0800
Subject: [PATCH 080/499] Add `f16`, `f80` and `f128` support for `atan`

---
 lib/c/math.zig                        |  67 ++-
 lib/libc/musl/src/math/atan.c         | 116 -----
 lib/libc/musl/src/math/atanf.c        |  94 ----
 lib/libc/musl/src/math/atanl.c        | 184 -------
 lib/libc/musl/src/math/i386/atan.s    |  16 -
 lib/libc/musl/src/math/i386/atanf.s   |  18 -
 lib/libc/musl/src/math/i386/atanl.s   |   7 -
 lib/libc/musl/src/math/x32/atanl.s    |   7 -
 lib/libc/musl/src/math/x86_64/atanl.s |   7 -
 lib/std/math/atan.zig                 | 673 +++++++++++++++++++-------
 src/libs/musl.zig                     |   8 -
 src/libs/wasi_libc.zig                |   3 -
 12 files changed, 544 insertions(+), 656 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/atan.c
 delete mode 100644 lib/libc/musl/src/math/atanf.c
 delete mode 100644 lib/libc/musl/src/math/atanl.c
 delete mode 100644 lib/libc/musl/src/math/i386/atan.s
 delete mode 100644 lib/libc/musl/src/math/i386/atanf.s
 delete mode 100644 lib/libc/musl/src/math/i386/atanl.s
 delete mode 100644 lib/libc/musl/src/math/x32/atanl.s
 delete mode 100644 lib/libc/musl/src/math/x86_64/atanl.s

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 8a6c91be2efc735326a5a56d1fe3452f8837bb2b..a9e7c808a80adab4758c439209d9c8470319d442 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const math = std.math;
 const common = @import("common.zig");
 const builtin = @import("builtin");
 
@@ -11,20 +12,20 @@ comptime {
         @export(&isnanl, .{ .name = "isnanl", .linkage = common.linkage, .visibility = common.visibility });
         @export(&isnanl, .{ .name = "__isnanl", .linkage = common.linkage, .visibility = common.visibility });
 
-        @export(&std.math.nan(f64), .{ .name = "__QNAN", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.snan(f64), .{ .name = "__SNAN", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.inf(f64), .{ .name = "__INF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.floatTrueMin(f64), .{ .name = "__DENORM", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.nan(f64), .{ .name = "__QNAN", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.snan(f64), .{ .name = "__SNAN", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.inf(f64), .{ .name = "__INF", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.floatTrueMin(f64), .{ .name = "__DENORM", .linkage = common.linkage, .visibility = common.visibility });
 
-        @export(&std.math.nan(f32), .{ .name = "__QNANF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.snan(f32), .{ .name = "__SNANF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.inf(f32), .{ .name = "__INFF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.floatTrueMin(f32), .{ .name = "__DENORMF", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.nan(f32), .{ .name = "__QNANF", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.snan(f32), .{ .name = "__SNANF", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.inf(f32), .{ .name = "__INFF", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.floatTrueMin(f32), .{ .name = "__DENORMF", .linkage = common.linkage, .visibility = common.visibility });
 
-        @export(&std.math.nan(c_longdouble), .{ .name = "__QNANL", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.snan(c_longdouble), .{ .name = "__SNANL", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.inf(c_longdouble), .{ .name = "__INFL", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&std.math.floatTrueMin(c_longdouble), .{ .name = "__DENORML", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.nan(c_longdouble), .{ .name = "__QNANL", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.snan(c_longdouble), .{ .name = "__SNANL", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.inf(c_longdouble), .{ .name = "__INFL", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&math.floatTrueMin(c_longdouble), .{ .name = "__DENORML", .linkage = common.linkage, .visibility = common.visibility });
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -35,6 +36,9 @@ comptime {
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         @export(&acos, .{ .name = "acos", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&atanf, .{ .name = "atanf", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&atan, .{ .name = "atan", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
     }
 
     if (builtin.target.isMuslLibC()) {
@@ -45,41 +49,60 @@ comptime {
 }
 
 fn acos(x: f64) callconv(.c) f64 {
-    return std.math.acos(x);
+    return math.acos(x);
+}
+
+fn atanf(x: f32) callconv(.c) f32 {
+    return math.atan(x);
+}
+
+fn atan(x: f64) callconv(.c) f64 {
+    return math.atan(x);
+}
+
+fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
+    return switch (@typeInfo(@TypeOf(x)).float.bits) {
+        16 => math.atan(@as(f16, @floatCast(x))),
+        32 => math.atan(@as(f32, @floatCast(x))),
+        64 => math.atan(@as(f64, @floatCast(x))),
+        80 => math.atan(@as(f80, @floatCast(x))),
+        128 => math.atan(@as(f128, @floatCast(x))),
+        else => unreachable,
+    };
 }
 
 fn isnan(x: f64) callconv(.c) c_int {
-    return if (std.math.isNan(x)) 1 else 0;
+    return if (math.isNan(x)) 1 else 0;
 }
 
 fn isnanf(x: f32) callconv(.c) c_int {
-    return if (std.math.isNan(x)) 1 else 0;
+    return if (math.isNan(x)) 1 else 0;
 }
 
 fn isnanl(x: c_longdouble) callconv(.c) c_int {
-    return if (std.math.isNan(x)) 1 else 0;
+    return if (math.isNan(x)) 1 else 0;
 }
 
 fn nan(_: [*:0]const c_char) callconv(.c) f64 {
-    return std.math.nan(f64);
+    return math.nan(f64);
 }
 
 fn nanf(_: [*:0]const c_char) callconv(.c) f32 {
-    return std.math.nan(f32);
+    return math.nan(f32);
 }
 
 fn nanl(_: [*:0]const c_char) callconv(.c) c_longdouble {
-    return std.math.nan(c_longdouble);
+    return math.nan(c_longdouble);
 }
 
 fn copysignf(x: f32, y: f32) callconv(.c) f32 {
-    return std.math.copysign(x, y);
+    return math.copysign(x, y);
 }
 
 fn copysign(x: f64, y: f64) callconv(.c) f64 {
-    return std.math.copysign(x, y);
+    return math.copysign(x, y);
 }
 
 fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return std.math.copysign(x, y);
+    return math.copysign(x, y);
 }
diff --git a/lib/libc/musl/src/math/atan.c b/lib/libc/musl/src/math/atan.c
deleted file mode 100644
index 63b0ab25e3cf02ea81bab5a9ee4d99d6c40bb582..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/atan.c
+++ /dev/null
@@ -1,116 +0,0 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/s_atan.c */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-/* atan(x)
- * Method
- *   1. Reduce x to positive by atan(x) = -atan(-x).
- *   2. According to the integer k=4t+0.25 chopped, t=x, the argument
- *      is further reduced to one of the following intervals and the
- *      arctangent of t is evaluated by the corresponding formula:
- *
- *      [0,7/16]      atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...)
- *      [7/16,11/16]  atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) )
- *      [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) )
- *      [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) )
- *      [39/16,INF]   atan(x) = atan(INF) + atan( -1/t )
- *
- * Constants:
- * The hexadecimal values are the intended ones for the following
- * constants. The decimal values may be used, provided that the
- * compiler will convert from decimal to binary accurately enough
- * to produce the hexadecimal values shown.
- */
-
-
-#include "libm.h"
-
-static const double atanhi[] = {
-  4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
-  7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
-  9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */
-  1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */
-};
-
-static const double atanlo[] = {
-  2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */
-  3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */
-  1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */
-  6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */
-};
-
-static const double aT[] = {
-  3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */
- -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */
-  1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */
- -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */
-  9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */
- -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */
-  6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */
- -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */
-  4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */
- -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */
-  1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
-};
-
-double atan(double x)
-{
-	double_t w,s1,s2,z;
-	uint32_t ix,sign;
-	int id;
-
-	GET_HIGH_WORD(ix, x);
-	sign = ix >> 31;
-	ix &= 0x7fffffff;
-	if (ix >= 0x44100000) {   /* if |x| >= 2^66 */
-		if (isnan(x))
-			return x;
-		z = atanhi[3] + 0x1p-120f;
-		return sign ? -z : z;
-	}
-	if (ix < 0x3fdc0000) {    /* |x| < 0.4375 */
-		if (ix < 0x3e400000) {  /* |x| < 2^-27 */
-			if (ix < 0x00100000)
-				/* raise underflow for subnormal x */
-				FORCE_EVAL((float)x);
-			return x;
-		}
-		id = -1;
-	} else {
-		x = fabs(x);
-		if (ix < 0x3ff30000) {  /* |x| < 1.1875 */
-			if (ix < 0x3fe60000) {  /*  7/16 <= |x| < 11/16 */
-				id = 0;
-				x = (2.0*x-1.0)/(2.0+x);
-			} else {                /* 11/16 <= |x| < 19/16 */
-				id = 1;
-				x = (x-1.0)/(x+1.0);
-			}
-		} else {
-			if (ix < 0x40038000) {  /* |x| < 2.4375 */
-				id = 2;
-				x = (x-1.5)/(1.0+1.5*x);
-			} else {                /* 2.4375 <= |x| < 2^66 */
-				id = 3;
-				x = -1.0/x;
-			}
-		}
-	}
-	/* end of argument reduction */
-	z = x*x;
-	w = z*z;
-	/* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
-	s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
-	s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
-	if (id < 0)
-		return x - x*(s1+s2);
-	z = atanhi[id] - (x*(s1+s2) - atanlo[id] - x);
-	return sign ? -z : z;
-}
diff --git a/lib/libc/musl/src/math/atanf.c b/lib/libc/musl/src/math/atanf.c
deleted file mode 100644
index 178341b670fa249fa50157d878ac2a66bd7f1843..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/atanf.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/s_atanf.c */
-/*
- * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
- */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-
-#include "libm.h"
-
-static const float atanhi[] = {
-  4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
-  7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
-  9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
-  1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
-};
-
-static const float atanlo[] = {
-  5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
-  3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
-  3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
-  7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
-};
-
-static const float aT[] = {
-  3.3333328366e-01,
- -1.9999158382e-01,
-  1.4253635705e-01,
- -1.0648017377e-01,
-  6.1687607318e-02,
-};
-
-float atanf(float x)
-{
-	float_t w,s1,s2,z;
-	uint32_t ix,sign;
-	int id;
-
-	GET_FLOAT_WORD(ix, x);
-	sign = ix>>31;
-	ix &= 0x7fffffff;
-	if (ix >= 0x4c800000) {  /* if |x| >= 2**26 */
-		if (isnan(x))
-			return x;
-		z = atanhi[3] + 0x1p-120f;
-		return sign ? -z : z;
-	}
-	if (ix < 0x3ee00000) {   /* |x| < 0.4375 */
-		if (ix < 0x39800000) {  /* |x| < 2**-12 */
-			if (ix < 0x00800000)
-				/* raise underflow for subnormal x */
-				FORCE_EVAL(x*x);
-			return x;
-		}
-		id = -1;
-	} else {
-		x = fabsf(x);
-		if (ix < 0x3f980000) {  /* |x| < 1.1875 */
-			if (ix < 0x3f300000) {  /*  7/16 <= |x| < 11/16 */
-				id = 0;
-				x = (2.0f*x - 1.0f)/(2.0f + x);
-			} else {                /* 11/16 <= |x| < 19/16 */
-				id = 1;
-				x = (x - 1.0f)/(x + 1.0f);
-			}
-		} else {
-			if (ix < 0x401c0000) {  /* |x| < 2.4375 */
-				id = 2;
-				x = (x - 1.5f)/(1.0f + 1.5f*x);
-			} else {                /* 2.4375 <= |x| < 2**26 */
-				id = 3;
-				x = -1.0f/x;
-			}
-		}
-	}
-	/* end of argument reduction */
-	z = x*x;
-	w = z*z;
-	/* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
-	s1 = z*(aT[0]+w*(aT[2]+w*aT[4]));
-	s2 = w*(aT[1]+w*aT[3]);
-	if (id < 0)
-		return x - x*(s1+s2);
-	z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
-	return sign ? -z : z;
-}
diff --git a/lib/libc/musl/src/math/atanl.c b/lib/libc/musl/src/math/atanl.c
deleted file mode 100644
index c3b0c9268db309060614a94e11d3755e2d26110a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/atanl.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/s_atanl.c */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-/*
- * See comments in atan.c.
- * Converted to long double by David Schultz <das@FreeBSD.ORG>.
- */
-
-#include "libm.h"
-
-#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double atanl(long double x)
-{
-	return atan(x);
-}
-#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-
-#if LDBL_MANT_DIG == 64
-#define EXPMAN(u) ((u.i.se & 0x7fff)<<8 | (u.i.m>>55 & 0xff))
-
-static const long double atanhi[] = {
-	 4.63647609000806116202e-01L,
-	 7.85398163397448309628e-01L,
-	 9.82793723247329067960e-01L,
-	 1.57079632679489661926e+00L,
-};
-
-static const long double atanlo[] = {
-	 1.18469937025062860669e-20L,
-	-1.25413940316708300586e-20L,
-	 2.55232234165405176172e-20L,
-	-2.50827880633416601173e-20L,
-};
-
-static const long double aT[] = {
-	 3.33333333333333333017e-01L,
-	-1.99999999999999632011e-01L,
-	 1.42857142857046531280e-01L,
-	-1.11111111100562372733e-01L,
-	 9.09090902935647302252e-02L,
-	-7.69230552476207730353e-02L,
-	 6.66661718042406260546e-02L,
-	-5.88158892835030888692e-02L,
-	 5.25499891539726639379e-02L,
-	-4.70119845393155721494e-02L,
-	 4.03539201366454414072e-02L,
-	-2.91303858419364158725e-02L,
-	 1.24822046299269234080e-02L,
-};
-
-static long double T_even(long double x)
-{
-	return aT[0] + x * (aT[2] + x * (aT[4] + x * (aT[6] +
-		x * (aT[8] + x * (aT[10] + x * aT[12])))));
-}
-
-static long double T_odd(long double x)
-{
-	return aT[1] + x * (aT[3] + x * (aT[5] + x * (aT[7] +
-		x * (aT[9] + x * aT[11]))));
-}
-#elif LDBL_MANT_DIG == 113
-#define EXPMAN(u) ((u.i.se & 0x7fff)<<8 | u.i.top>>8)
-
-static const long double atanhi[] = {
-	 4.63647609000806116214256231461214397e-01L,
-	 7.85398163397448309615660845819875699e-01L,
-	 9.82793723247329067985710611014666038e-01L,
-	 1.57079632679489661923132169163975140e+00L,
-};
-
-static const long double atanlo[] = {
-	 4.89509642257333492668618435220297706e-36L,
-	 2.16795253253094525619926100651083806e-35L,
-	-2.31288434538183565909319952098066272e-35L,
-	 4.33590506506189051239852201302167613e-35L,
-};
-
-static const long double aT[] = {
-	 3.33333333333333333333333333333333125e-01L,
-	-1.99999999999999999999999999999180430e-01L,
-	 1.42857142857142857142857142125269827e-01L,
-	-1.11111111111111111111110834490810169e-01L,
-	 9.09090909090909090908522355708623681e-02L,
-	-7.69230769230769230696553844935357021e-02L,
-	 6.66666666666666660390096773046256096e-02L,
-	-5.88235294117646671706582985209643694e-02L,
-	 5.26315789473666478515847092020327506e-02L,
-	-4.76190476189855517021024424991436144e-02L,
-	 4.34782608678695085948531993458097026e-02L,
-	-3.99999999632663469330634215991142368e-02L,
-	 3.70370363987423702891250829918659723e-02L,
-	-3.44827496515048090726669907612335954e-02L,
-	 3.22579620681420149871973710852268528e-02L,
-	-3.03020767654269261041647570626778067e-02L,
-	 2.85641979882534783223403715930946138e-02L,
-	-2.69824879726738568189929461383741323e-02L,
-	 2.54194698498808542954187110873675769e-02L,
-	-2.35083879708189059926183138130183215e-02L,
-	 2.04832358998165364349957325067131428e-02L,
-	-1.54489555488544397858507248612362957e-02L,
-	 8.64492360989278761493037861575248038e-03L,
-	-2.58521121597609872727919154569765469e-03L,
-};
-
-static long double T_even(long double x)
-{
-	return (aT[0] + x * (aT[2] + x * (aT[4] + x * (aT[6] + x * (aT[8] +
-		x * (aT[10] + x * (aT[12] + x * (aT[14] + x * (aT[16] +
-		x * (aT[18] + x * (aT[20] + x * aT[22])))))))))));
-}
-
-static long double T_odd(long double x)
-{
-	return (aT[1] + x * (aT[3] + x * (aT[5] + x * (aT[7] + x * (aT[9] +
-		x * (aT[11] + x * (aT[13] + x * (aT[15] + x * (aT[17] +
-		x * (aT[19] + x * (aT[21] + x * aT[23])))))))))));
-}
-#endif
-
-long double atanl(long double x)
-{
-	union ldshape u = {x};
-	long double w, s1, s2, z;
-	int id;
-	unsigned e = u.i.se & 0x7fff;
-	unsigned sign = u.i.se >> 15;
-	unsigned expman;
-
-	if (e >= 0x3fff + LDBL_MANT_DIG + 1) { /* if |x| is large, atan(x)~=pi/2 */
-		if (isnan(x))
-			return x;
-		return sign ? -atanhi[3] : atanhi[3];
-	}
-	/* Extract the exponent and the first few bits of the mantissa. */
-	expman = EXPMAN(u);
-	if (expman < ((0x3fff - 2) << 8) + 0xc0) {  /* |x| < 0.4375 */
-		if (e < 0x3fff - (LDBL_MANT_DIG+1)/2) {   /* if |x| is small, atanl(x)~=x */
-			/* raise underflow if subnormal */
-			if (e == 0)
-				FORCE_EVAL((float)x);
-			return x;
-		}
-		id = -1;
-	} else {
-		x = fabsl(x);
-		if (expman < (0x3fff << 8) + 0x30) {  /* |x| < 1.1875 */
-			if (expman < ((0x3fff - 1) << 8) + 0x60) { /*  7/16 <= |x| < 11/16 */
-				id = 0;
-				x = (2.0*x-1.0)/(2.0+x);
-			} else {                                 /* 11/16 <= |x| < 19/16 */
-				id = 1;
-				x = (x-1.0)/(x+1.0);
-			}
-		} else {
-			if (expman < ((0x3fff + 1) << 8) + 0x38) { /* |x| < 2.4375 */
-				id = 2;
-				x = (x-1.5)/(1.0+1.5*x);
-			} else {                                 /* 2.4375 <= |x| */
-				id = 3;
-				x = -1.0/x;
-			}
-		}
-	}
-	/* end of argument reduction */
-	z = x*x;
-	w = z*z;
-	/* break sum aT[i]z**(i+1) into odd and even poly */
-	s1 = z*T_even(w);
-	s2 = w*T_odd(w);
-	if (id < 0)
-		return x - x*(s1+s2);
-	z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
-	return sign ? -z : z;
-}
-#endif
diff --git a/lib/libc/musl/src/math/i386/atan.s b/lib/libc/musl/src/math/i386/atan.s
deleted file mode 100644
index 2c57f6b309d3d5e54430f17db69171e0ce5bc833..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/atan.s
+++ /dev/null
@@ -1,16 +0,0 @@
-.global atan
-.type atan,@function
-atan:
-	fldl 4(%esp)
-	mov 8(%esp),%eax
-	add %eax,%eax
-	cmp $0x00200000,%eax
-	jb 1f
-	fld1
-	fpatan
-	fstpl 4(%esp)
-	fldl 4(%esp)
-	ret
-		# subnormal x, return x with underflow
-1:	fsts 4(%esp)
-	ret
diff --git a/lib/libc/musl/src/math/i386/atanf.s b/lib/libc/musl/src/math/i386/atanf.s
deleted file mode 100644
index c2cbe2e0267f93272a195725489afcbbc24c8876..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/atanf.s
+++ /dev/null
@@ -1,18 +0,0 @@
-.global atanf
-.type atanf,@function
-atanf:
-	flds 4(%esp)
-	mov 4(%esp),%eax
-	add %eax,%eax
-	cmp $0x01000000,%eax
-	jb 1f
-	fld1
-	fpatan
-	fstps 4(%esp)
-	flds 4(%esp)
-	ret
-		# subnormal x, return x with underflow
-1:	fld %st(0)
-	fmul %st(1)
-	fstps 4(%esp)
-	ret
diff --git a/lib/libc/musl/src/math/i386/atanl.s b/lib/libc/musl/src/math/i386/atanl.s
deleted file mode 100644
index c508bc465b1a510efca440808bc88fe6c2a7d426..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/atanl.s
+++ /dev/null
@@ -1,7 +0,0 @@
-.global atanl
-.type atanl,@function
-atanl:
-	fldt 4(%esp)
-	fld1
-	fpatan
-	ret
diff --git a/lib/libc/musl/src/math/x32/atanl.s b/lib/libc/musl/src/math/x32/atanl.s
deleted file mode 100644
index f475fe0e9ee73ca2940fd47c9326323769207953..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/x32/atanl.s
+++ /dev/null
@@ -1,7 +0,0 @@
-.global atanl
-.type atanl,@function
-atanl:
-	fldt 8(%esp)
-	fld1
-	fpatan
-	ret
diff --git a/lib/libc/musl/src/math/x86_64/atanl.s b/lib/libc/musl/src/math/x86_64/atanl.s
deleted file mode 100644
index df76de5de4f12834a4a3710a2e7370d10245e862..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/x86_64/atanl.s
+++ /dev/null
@@ -1,7 +0,0 @@
-.global atanl
-.type atanl,@function
-atanl:
-	fldt 8(%rsp)
-	fld1
-	fpatan
-	ret
diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig
index 377d96897ff7acad0e76aece1866fdbc4fd31d4e..8b783bf3474b7cf260c9ca4930e35200dd6704bd 100644
--- a/lib/std/math/atan.zig
+++ b/lib/std/math/atan.zig
@@ -3,11 +3,12 @@
 //
 // https://git.musl-libc.org/cgit/musl/tree/src/math/atanf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/atan.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atanl.c
 
 const std = @import("../std.zig");
 const math = std.math;
 const mem = std.mem;
-const expect = std.testing.expect;
+const testing = std.testing;
 
 /// Returns the arc-tangent of x.
 ///
@@ -17,28 +18,100 @@ const expect = std.testing.expect;
 pub fn atan(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     return switch (T) {
-        f32 => atan32(x),
-        f64 => atan64(x),
+        f16 => atanBinary16(x),
+        f32 => atanBinary32(x),
+        f64 => atanBinary64(x),
+        f80 => atanExtended80(x),
+        f128 => atanBinary128(x),
         else => @compileError("atan not implemented for " ++ @typeName(T)),
     };
 }
 
-fn atan32(x_: f32) f32 {
-    const atanhi = [_]f32{
-        4.6364760399e-01, // atan(0.5)hi
-        7.8539812565e-01, // atan(1.0)hi
-        9.8279368877e-01, // atan(1.5)hi
-        1.5707962513e+00, // atan(inf)hi
+fn atanBinary16(x: f16) f16 {
+    const atanhi: []const f32 = &.{
+        4.6364760399e-01, // atan(0.5)hi 0x3eed6338
+        7.8539812565e-01, // atan(1.0)hi 0x3f490fda
+        9.8279368877e-01, // atan(1.5)hi 0x3f7b985e
+        1.5707962513e+00, // atan(inf)hi 0x3fc90fda
+    };
+    const aT: []const f32 = &.{
+        0x1.fffcccp-1,
+        -0x1.52e8ccp-2,
+        0x1.522336p-3,
     };
 
-    const atanlo = [_]f32{
-        5.0121582440e-09, // atan(0.5)lo
-        3.7748947079e-08, // atan(1.0)lo
-        3.4473217170e-08, // atan(1.5)lo
-        7.5497894159e-08, // atan(inf)lo
+    const hx: u16 = @bitCast(x);
+    const ix = hx & 0x7fff;
+    const sign = (hx >> 15) != 0;
+    // if |x| >= 2^11
+    if (ix >= 0x6800) {
+        if (math.isNan(x)) {
+            return x;
+        }
+        const z = atanhi[3] + 0x1p-120;
+        return @floatCast(if (sign) -z else z);
+    }
+    const x_: f32, const id: ?usize = blk: {
+        // |x| < 0.4375
+        if (ix < 0x3700) {
+            // |x| < 2^(-6)
+            if (ix < 0x2400) {
+                if (ix < 0x400) {
+                    // raise underflow for subnormal x
+                    mem.doNotOptimizeAway(x * x);
+                }
+                return x;
+            }
+            break :blk .{ @floatCast(x), null };
+        } else {
+            const x_: f32 = @floatCast(@abs(x));
+            // |x| < 1.1875
+            if (ix < 0x3cc0) {
+                // 7/16 <= |x| < 11/16
+                if (ix < 0x3980) {
+                    break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
+                }
+                // 11/16 <= |x| < 19/16
+                else {
+                    break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
+                }
+            } else {
+                // |x| < 2.4375
+                if (ix < 0x40e0) {
+                    break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
+                }
+                // 2.4375 <= |x| < 2^11
+                else {
+                    break :blk .{ -1.0 / x_, 3 };
+                }
+            }
+        }
     };
+    // end of argument reduction
+    const z = x_ * x_;
+    const s = aT[0] + z * (aT[1] + z * aT[2]);
+    if (id) |id_| {
+        const z_ = atanhi[id_] + x_ * s;
+        return @floatCast(if (sign) -z_ else z_);
+    } else {
+        return @floatCast(x_ * s);
+    }
+}
 
-    const aT = [_]f32{
+fn atanBinary32(x: f32) f32 {
+    const atanhi: []const f32 = &.{
+        4.6364760399e-01, // atan(0.5)hi 0x3eed6338
+        7.8539812565e-01, // atan(1.0)hi 0x3f490fda
+        9.8279368877e-01, // atan(1.5)hi 0x3f7b985e
+        1.5707962513e+00, // atan(inf)hi 0x3fc90fda
+    };
+    const atanlo: []const f32 = &.{
+        5.0121582440e-09, // atan(0.5)lo 0x31ac3769
+        3.7748947079e-08, // atan(1.0)lo 0x33222168
+        3.4473217170e-08, // atan(1.5)lo 0x33140fb4
+        7.5497894159e-08, // atan(inf)lo 0x33a22168
+    };
+    const aT: []const f32 = &.{
         3.3333328366e-01,
         -1.9999158382e-01,
         1.4253635705e-01,
@@ -46,211 +119,463 @@ fn atan32(x_: f32) f32 {
         6.1687607318e-02,
     };
 
-    var x = x_;
-    var ix: u32 = @as(u32, @bitCast(x));
-    const sign = ix >> 31;
-    ix &= 0x7FFFFFFF;
-
-    // |x| >= 2^26
-    if (ix >= 0x4C800000) {
+    const hx: u32 = @bitCast(x);
+    const ix = hx & 0x7fff_ffff;
+    const sign = (hx >> 31) != 0;
+    // if |x| >= 2^26
+    if (ix >= 0x4c80_0000) {
         if (math.isNan(x)) {
             return x;
-        } else {
-            const z = atanhi[3] + 0x1.0p-120;
-            return if (sign != 0) -z else z;
         }
+        const z = atanhi[3] + 0x1p-120;
+        return if (sign) -z else z;
     }
-
-    var id: ?usize = undefined;
-
-    // |x| < 0.4375
-    if (ix < 0x3EE00000) {
-        // |x| < 2^(-12)
-        if (ix < 0x39800000) {
-            if (ix < 0x00800000) {
-                mem.doNotOptimizeAway(x * x);
-            }
-            return x;
-        }
-        id = null;
-    } else {
-        x = @abs(x);
-        // |x| < 1.1875
-        if (ix < 0x3F980000) {
-            // 7/16 <= |x| < 11/16
-            if (ix < 0x3F300000) {
-                id = 0;
-                x = (2.0 * x - 1.0) / (2.0 + x);
-            }
-            // 11/16 <= |x| < 19/16
-            else {
-                id = 1;
-                x = (x - 1.0) / (x + 1.0);
+    const x_, const id: ?usize = blk: {
+        // |x| < 0.4375
+        if (ix < 0x3ee00000) {
+            // |x| < 2^(-12)
+            if (ix < 0x39800000) {
+                if (ix < 0x00800000) {
+                    // raise underflow for subnormal x
+                    mem.doNotOptimizeAway(x * x);
+                }
+                return x;
             }
+            break :blk .{ x, null };
         } else {
-            // |x| < 2.4375
-            if (ix < 0x401C0000) {
-                id = 2;
-                x = (x - 1.5) / (1.0 + 1.5 * x);
-            }
-            // 2.4375 <= |x| < 2^26
-            else {
-                id = 3;
-                x = -1.0 / x;
+            const x_ = @abs(x);
+            // |x| < 1.1875
+            if (ix < 0x3f98_0000) {
+                // 7/16 <= |x| < 11/16
+                if (ix < 0x3f30_0000) {
+                    break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
+                }
+                // 11/16 <= |x| < 19/16
+                else {
+                    break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
+                }
+            } else {
+                // |x| < 2.4375
+                if (ix < 0x401c_0000) {
+                    break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
+                }
+                // 2.4375 <= |x| < 2^26
+                else {
+                    break :blk .{ -1.0 / x_, 3 };
+                }
             }
         }
-    }
-
-    const z = x * x;
+    };
+    // end of argument reduction
+    const z = x_ * x_;
     const w = z * z;
+    // break sum from i=0 to 10 aT[i]z^(i+1) into odd and even poly
     const s1 = z * (aT[0] + w * (aT[2] + w * aT[4]));
     const s2 = w * (aT[1] + w * aT[3]);
-
-    if (id) |id_value| {
-        const zz = atanhi[id_value] - ((x * (s1 + s2) - atanlo[id_value]) - x);
-        return if (sign != 0) -zz else zz;
+    if (id) |id_| {
+        const z_ = atanhi[id_] - ((x_ * (s1 + s2) - atanlo[id_]) - x_);
+        return if (sign) -z_ else z_;
     } else {
-        return x - x * (s1 + s2);
+        return x_ - x_ * (s1 + s2);
     }
 }
 
-fn atan64(x_: f64) f64 {
-    const atanhi = [_]f64{
-        4.63647609000806093515e-01, // atan(0.5)hi
-        7.85398163397448278999e-01, // atan(1.0)hi
-        9.82793723247329054082e-01, // atan(1.5)hi
-        1.57079632679489655800e+00, // atan(inf)hi
+fn atanBinary64(x: f64) f64 {
+    const atanhi: []const f64 = &.{
+        4.63647609000806093515e-01, // atan(0.5)hi 0x3FDDAC67, 0x0561BB4F
+        7.85398163397448278999e-01, // atan(1.0)hi 0x3FE921FB, 0x54442D18
+        9.82793723247329054082e-01, // atan(1.5)hi 0x3FEF730B, 0xD281F69B
+        1.57079632679489655800e+00, // atan(inf)hi 0x3FF921FB, 0x54442D18
     };
-
-    const atanlo = [_]f64{
-        2.26987774529616870924e-17, // atan(0.5)lo
-        3.06161699786838301793e-17, // atan(1.0)lo
-        1.39033110312309984516e-17, // atan(1.5)lo
-        6.12323399573676603587e-17, // atan(inf)lo
+    const atanlo: []const f64 = &.{
+        2.26987774529616870924e-17, // atan(0.5)lo 0x3C7A2B7F, 0x222F65E2
+        3.06161699786838301793e-17, // atan(1.0)lo 0x3C81A626, 0x33145C07
+        1.39033110312309984516e-17, // atan(1.5)lo 0x3C700788, 0x7AF0CBBD
+        6.12323399573676603587e-17, // atan(inf)lo 0x3C91A626, 0x33145C07
     };
-
-    const aT = [_]f64{
-        3.33333333333329318027e-01,
-        -1.99999999998764832476e-01,
-        1.42857142725034663711e-01,
-        -1.11111104054623557880e-01,
-        9.09088713343650656196e-02,
-        -7.69187620504482999495e-02,
-        6.66107313738753120669e-02,
-        -5.83357013379057348645e-02,
-        4.97687799461593236017e-02,
-        -3.65315727442169155270e-02,
-        1.62858201153657823623e-02,
+    const aT: []const f64 = &.{
+        3.33333333333329318027e-01, // 0x3FD55555, 0x5555550D
+        -1.99999999998764832476e-01, // 0xBFC99999, 0x9998EBC4
+        1.42857142725034663711e-01, // 0x3FC24924, 0x920083FF
+        -1.11111104054623557880e-01, // 0xBFBC71C6, 0xFE231671
+        9.09088713343650656196e-02, // 0x3FB745CD, 0xC54C206E
+        -7.69187620504482999495e-02, // 0xBFB3B0F2, 0xAF749A6D
+        6.66107313738753120669e-02, // 0x3FB10D66, 0xA0D03D51
+        -5.83357013379057348645e-02, // 0xBFADDE2D, 0x52DEFD9A
+        4.97687799461593236017e-02, // 0x3FA97B4B, 0x24760DEB
+        -3.65315727442169155270e-02, // 0xBFA2B444, 0x2C6A6C2F
+        1.62858201153657823623e-02, // 0x3F90AD3A, 0xE322DA11
     };
 
-    var x = x_;
-    const ux: u64 = @bitCast(x);
-    var ix: u32 = @intCast(ux >> 32);
-    const sign = ix >> 31;
-    ix &= 0x7FFFFFFF;
-
-    // |x| >= 2^66
+    const hx: u64 = @bitCast(x);
+    const ix: u32 = @truncate((hx >> 32) & 0x7fffffff);
+    const sign = (hx >> 63) != 0;
+    // if |x| >= 2^66
     if (ix >= 0x44100000) {
         if (math.isNan(x)) {
             return x;
-        } else {
-            const z = atanhi[3] + 0x1.0p-120;
-            return if (sign != 0) -z else z;
         }
+        const z = atanhi[3] + 0x1p-120;
+        return if (sign) -z else z;
     }
-
-    var id: ?usize = undefined;
-
-    // |x| < 0.4375
-    if (ix < 0x3FDC0000) {
-        // |x| < 2^(-27)
-        if (ix < 0x3E400000) {
-            if (ix < 0x00100000) {
-                mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
-            }
-            return x;
-        }
-        id = null;
-    } else {
-        x = @abs(x);
-        // |x| < 1.1875
-        if (ix < 0x3FF30000) {
-            // 7/16 <= |x| < 11/16
-            if (ix < 0x3FE60000) {
-                id = 0;
-                x = (2.0 * x - 1.0) / (2.0 + x);
-            }
-            // 11/16 <= |x| < 19/16
-            else {
-                id = 1;
-                x = (x - 1.0) / (x + 1.0);
+    const x_, const id: ?usize = blk: {
+        // |x| < 0.4375
+        if (ix < 0x3fdc_0000) {
+            // |x| < 2^(-27)
+            if (ix < 0x3e40_0000) {
+                if (ix < 0x0010_0000) {
+                    // raise underflow for subnormal x
+                    mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
+                }
+                return x;
             }
+            break :blk .{ x, null };
         } else {
-            // |x| < 2.4375
-            if (ix < 0x40038000) {
-                id = 2;
-                x = (x - 1.5) / (1.0 + 1.5 * x);
-            }
-            // 2.4375 <= |x| < 2^66
-            else {
-                id = 3;
-                x = -1.0 / x;
+            const x_ = @abs(x);
+            // |x| < 1.1875
+            if (ix < 0x3ff3_0000) {
+                // 7/16 <= |x| < 11/16
+                if (ix < 0x3fe6_0000) {
+                    break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
+                }
+                // 11/16 <= |x| < 19/16
+                else {
+                    break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
+                }
+            } else {
+                // |x| < 2.4375
+                if (ix < 0x4003_8000) {
+                    break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
+                }
+                // 2.4375 <= |x| < 2^66
+                else {
+                    break :blk .{ -1.0 / x_, 3 };
+                }
             }
         }
-    }
-
-    const z = x * x;
+    };
+    // end of argument reduction
+    const z = x_ * x_;
     const w = z * z;
+    // break sum from i=0 to 10 aT[i]z^(i+1) into odd and even poly
     const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
     const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
+    if (id) |id_| {
+        const z_ = atanhi[id_] - (x_ * (s1 + s2) - atanlo[id_] - x_);
+        return if (sign) -z_ else z_;
+    } else {
+        return x_ - x_ * (s1 + s2);
+    }
+}
 
-    if (id) |id_value| {
-        const zz = atanhi[id_value] - ((x * (s1 + s2) - atanlo[id_value]) - x);
-        return if (sign != 0) -zz else zz;
+fn atanExtended80(x: f80) f80 {
+    const atanhi: []const f80 = &.{
+        4.63647609000806116202e-01,
+        7.85398163397448309628e-01,
+        9.82793723247329067960e-01,
+        1.57079632679489661926e+00,
+    };
+    const atanlo: []const f80 = &.{
+        1.18469937025062860669e-20,
+        -1.25413940316708300586e-20,
+        2.55232234165405176172e-20,
+        -2.50827880633416601173e-20,
+    };
+    const aT: []const f80 = &.{
+        3.33333333333333333017e-01,
+        -1.99999999999999632011e-01,
+        1.42857142857046531280e-01,
+        -1.11111111100562372733e-01,
+        9.09090902935647302252e-02,
+        -7.69230552476207730353e-02,
+        6.66661718042406260546e-02,
+        -5.88158892835030888692e-02,
+        5.25499891539726639379e-02,
+        -4.70119845393155721494e-02,
+        4.03539201366454414072e-02,
+        -2.91303858419364158725e-02,
+        1.24822046299269234080e-02,
+    };
+
+    const hx: u80 = @bitCast(x);
+    const se: u16 = @truncate(hx >> 64);
+    const e = se & 0x7fff;
+    const sign = se >> 15 != 0;
+    // if |x| is large, atan(x)~=pi/2
+    if (e >= 0x3fff + math.floatMantissaBits(f80) + 1) {
+        if (math.isNan(x)) {
+            return x;
+        }
+        return if (sign) -atanhi[3] else atanhi[3];
+    }
+    // Extract the exponent and the first few bits of the mantissa.
+    const m: u64 = @truncate(hx & 0x0000_ffff_ffff_ffff_ffff);
+    const expman = ((@as(u32, @intCast(se)) & 0x7fff) << 8) | (@as(u32, @truncate(m >> 55)) & 0xff);
+    const x_, const id: ?usize = blk: {
+        // |x| < 0.4375
+        if (expman < ((0x3fff - 2) << 8) + 0xc0) {
+            // if |x| is small, atanl(x)~=x
+            if (e < 0x3fff - (math.floatMantissaBits(f80) + 1) / 2) {
+                // raise underflow if subnormal
+                if (e == 0) {
+                    std.mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
+                }
+                return x;
+            }
+            break :blk .{ x, null };
+        } else {
+            const x_ = @abs(x);
+            // |x| < 1.1875
+            if (expman < (0x3fff << 8) + 0x30) {
+                // 7/16 <= |x| < 11/16
+                if (expman < ((0x3fff - 1) << 8) + 0x60) {
+                    break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
+                }
+                // 11/16 <= |x| < 19/16
+                else {
+                    break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
+                }
+            } else {
+                // |x| < 2.4375
+                if (expman < ((0x3fff + 1) << 8) + 0x38) {
+                    break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
+                }
+                // 2.4375 <= |x|
+                else {
+                    break :blk .{ -1.0 / x_, 3 };
+                }
+            }
+        }
+    };
+    // end of argument reduction
+    const z = x_ * x_;
+    const w = z * z;
+    // break sum aT[i]z^(i+1) into odd and even poly
+    const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * (aT[10] + w * aT[12]))))));
+    const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * (aT[9] + w * aT[11])))));
+    if (id) |id_| {
+        const z_ = atanhi[id_] - ((x_ * (s1 + s2) - atanlo[id_]) - x_);
+        return if (sign) -z_ else z_;
     } else {
-        return x - x * (s1 + s2);
+        return x_ - x_ * (s1 + s2);
     }
 }
 
-test atan {
-    try expect(@as(u32, @bitCast(atan(@as(f32, 0.2)))) == @as(u32, @bitCast(atan32(0.2))));
-    try expect(atan(@as(f64, 0.2)) == atan64(0.2));
+fn atanBinary128(x: f128) f128 {
+    const atanhi: []const f128 = &.{
+        4.63647609000806116214256231461214397e-01,
+        7.85398163397448309615660845819875699e-01,
+        9.82793723247329067985710611014666038e-01,
+        1.57079632679489661923132169163975140e+00,
+    };
+    const atanlo: []const f128 = &.{
+        4.89509642257333492668618435220297706e-36,
+        2.16795253253094525619926100651083806e-35,
+        -2.31288434538183565909319952098066272e-35,
+        4.33590506506189051239852201302167613e-35,
+    };
+    const aT: []const f128 = &.{
+        3.33333333333333333333333333333333125e-01,
+        -1.99999999999999999999999999999180430e-01,
+        1.42857142857142857142857142125269827e-01,
+        -1.11111111111111111111110834490810169e-01,
+        9.09090909090909090908522355708623681e-02,
+        -7.69230769230769230696553844935357021e-02,
+        6.66666666666666660390096773046256096e-02,
+        -5.88235294117646671706582985209643694e-02,
+        5.26315789473666478515847092020327506e-02,
+        -4.76190476189855517021024424991436144e-02,
+        4.34782608678695085948531993458097026e-02,
+        -3.99999999632663469330634215991142368e-02,
+        3.70370363987423702891250829918659723e-02,
+        -3.44827496515048090726669907612335954e-02,
+        3.22579620681420149871973710852268528e-02,
+        -3.03020767654269261041647570626778067e-02,
+        2.85641979882534783223403715930946138e-02,
+        -2.69824879726738568189929461383741323e-02,
+        2.54194698498808542954187110873675769e-02,
+        -2.35083879708189059926183138130183215e-02,
+        2.04832358998165364349957325067131428e-02,
+        -1.54489555488544397858507248612362957e-02,
+        8.64492360989278761493037861575248038e-03,
+        -2.58521121597609872727919154569765469e-03,
+    };
+
+    const hx: u128 = @bitCast(x);
+    const se: u16 = @truncate(hx >> 112);
+    const e = se & 0x7fff;
+    const sign = se >> 15 != 0;
+    // if |x| is large, atan(x)~=pi/2
+    if (e >= 0x3fff + math.floatMantissaBits(f128) + 2) {
+        if (math.isNan(x)) {
+            return x;
+        }
+        return if (sign) -atanhi[3] else atanhi[3];
+    }
+    // Extract the exponent and the first few bits of the mantissa.
+    const top: u16 = @truncate((hx >> 96) & 0x0000_ffff);
+    const expman = ((@as(u32, @intCast(se)) & 0x7fff) << 8) | (@as(u32, @intCast(top)) >> 8);
+    const x_, const id: ?usize = blk: {
+        // |x| < 0.4375
+        if (expman < ((0x3fff - 2) << 8) + 0xc0) {
+            // if |x| is small, atanl(x)~=x
+            if (e < 0x3fff - (math.floatMantissaBits(f128) + 2) / 2) {
+                // raise underflow if subnormal
+                if (e == 0) {
+                    mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
+                }
+                return x;
+            }
+            break :blk .{ x, null };
+        } else {
+            const x_ = @abs(x);
+            // |x| < 1.1875
+            if (expman < (0x3fff << 8) + 0x30) {
+                // 7/16 <= |x| < 11/16
+                if (expman < ((0x3fff - 1) << 8) + 0x60) {
+                    break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
+                }
+                // 11/16 <= |x| < 19/16
+                else {
+                    break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
+                }
+            } else {
+                // |x| < 2.4375
+                if (expman < ((0x3fff + 1) << 8) + 0x38) {
+                    break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
+                }
+                // 2.4375 <= |x|
+                else {
+                    break :blk .{ -1.0 / x_, 3 };
+                }
+            }
+        }
+    };
+    // end of argument reduction
+    const z = x_ * x_;
+    const w = z * z;
+    // break sum aT[i]z^(i+1) into odd and even poly
+    const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * (aT[10] + w * (aT[12] + w * (aT[14] + w * (aT[16] + w * (aT[18] + w * (aT[20] + w * aT[22])))))))))));
+    const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * (aT[9] + w * (aT[11] + w * (aT[13] + w * (aT[15] + w * (aT[17] + w * (aT[19] + w * (aT[21] + w * aT[23])))))))))));
+    if (id) |id_| {
+        const z_ = atanhi[id_] - ((x_ * (s1 + s2) - atanlo[id_]) - x_);
+        return if (sign) -z_ else z_;
+    } else {
+        return x_ - x_ * (s1 + s2);
+    }
 }
 
-test atan32 {
-    const epsilon = 0.000001;
+test "atanBinary16.special" {
+    try testing.expectEqual(atanBinary16(0x0p+0), 0x0p+0);
+    try testing.expectEqual(atanBinary16(-0x0p+0), -0x0p+0);
+    try testing.expectApproxEqAbs(atanBinary16(0x1p+0), 0x1.92p-1, math.floatEpsAt(f16, 0x1.92p-1));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1p+0), -0x1.92p-1, math.floatEpsAt(f16, -0x1.92p-1));
+    try testing.expectApproxEqAbs(atanBinary16(math.inf(f16)), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
+    try testing.expectApproxEqAbs(atanBinary16(-math.inf(f16)), -0x1.92p0, math.floatEpsAt(f16, -0x1.92p0));
+    try testing.expect(math.isNan(atanBinary16(math.nan(f16))));
+}
+
+test "atanBinary16" {
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.864p-2), -0x1.74cp-2, math.floatEpsAt(f16, -0x1.74cp-2));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.59cp1), -0x1.374p0, math.floatEpsAt(f16, -0x1.374p0));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.d2cp0), -0x1.11cp0, math.floatEpsAt(f16, -0x1.11cp0));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.5f4p-1), -0x1.33cp-1, math.floatEpsAt(f16, -0x1.33cp-1));
+    try testing.expectApproxEqAbs(atanBinary16(0x1.588p1), 0x1.37p0, math.floatEpsAt(f16, 0x1.37p0));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.b14p-2), -0x1.99cp-2, math.floatEpsAt(f16, -0x1.99cp-2));
+    try testing.expectApproxEqAbs(atanBinary16(0x1.3ccp1), 0x1.2fcp0, math.floatEpsAt(f16, 0x1.2fcp0));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.0ecp-2), -0x1.08cp-2, math.floatEpsAt(f16, -0x1.08cp-2));
+    try testing.expectApproxEqAbs(atanBinary16(0x1.298p1), 0x1.2ap0, math.floatEpsAt(f16, 0x1.2ap0));
+    try testing.expectApproxEqAbs(atanBinary16(-0x1.028p1), -0x1.1c8p0, math.floatEpsAt(f16, -0x1.1c8p0));
+}
+
+test "atanBinary32.special" {
+    try testing.expectEqual(atanBinary32(0x0p+0), 0x0p+0);
+    try testing.expectEqual(atanBinary32(-0x0p+0), -0x0p+0);
+    try testing.expectApproxEqAbs(atanBinary32(0x1p+0), 0x1.921fb6p-1, math.floatEpsAt(f32, 0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1p+0), -0x1.921fb6p-1, math.floatEpsAt(f32, -0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(atanBinary32(math.inf(f32)), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(atanBinary32(-math.inf(f32)), -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expect(math.isNan(atanBinary32(math.nan(f32))));
+}
 
-    try expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));
-    try expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon));
-    try expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon));
-    try expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon));
-    try expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));
+test "atanBinary32" {
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.8629dp-2), -0x1.74c62p-2, math.floatEpsAt(f32, -0x1.74c62p-2));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.59d42ep1), -0x1.375fd8p0, math.floatEpsAt(f32, -0x1.375fd8p0));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.d2dbe2p0), -0x1.11b8aep0, math.floatEpsAt(f32, -0x1.11b8aep0));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.5f314ep-1), -0x1.33d28cp-1, math.floatEpsAt(f32, -0x1.33d28cp-1));
+    try testing.expectApproxEqAbs(atanBinary32(0x1.5869bp1), 0x1.37082ep0, math.floatEpsAt(f32, 0x1.37082ep0));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.b13a06p-2), -0x1.99d7cap-2, math.floatEpsAt(f32, -0x1.99d7cap-2));
+    try testing.expectApproxEqAbs(atanBinary32(0x1.3cb0f2p1), 0x1.2fcb12p0, math.floatEpsAt(f32, 0x1.2fcb12p0));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.0ed746p-2), -0x1.08c71ap-2, math.floatEpsAt(f32, -0x1.08c71ap-2));
+    try testing.expectApproxEqAbs(atanBinary32(0x1.299d54p1), 0x1.2a24e2p0, math.floatEpsAt(f32, 0x1.2a24e2p0));
+    try testing.expectApproxEqAbs(atanBinary32(-0x1.0264fcp1), -0x1.1c6178p0, math.floatEpsAt(f32, -0x1.1c6178p0));
 }
 
-test atan64 {
-    const epsilon = 0.000001;
+test "atanBinary64.special" {
+    try testing.expectEqual(atanBinary64(0x0p+0), 0x0p+0);
+    try testing.expectEqual(atanBinary64(-0x0p+0), -0x0p+0);
+    try testing.expectApproxEqAbs(atanBinary64(0x1p+0), 0x1.921fb54442d18p-1, math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1p+0), -0x1.921fb54442d18p-1, math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(atanBinary64(math.inf(f64)), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(atanBinary64(-math.inf(f64)), -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expect(math.isNan(atanBinary64(math.nan(f64))));
+}
 
-    try expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));
-    try expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon));
-    try expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon));
-    try expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon));
-    try expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));
+test "atanBinary64" {
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.8629d0244cdccp-2), -0x1.74c61f4377016p-2, math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.59d42d4659937p1), -0x1.375fd7987cc2p0, math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.d2dbe23d04f06p0), -0x1.11b8adeba5616p0, math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.5f314e72398e8p-1), -0x1.33d28ca762539p-1, math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
+    try testing.expectApproxEqAbs(atanBinary64(0x1.5869af37b7d08p1), 0x1.37082ce2dd03p0, math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.b13a05a662618p-2), -0x1.99d7cac66dd44p-2, math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
+    try testing.expectApproxEqAbs(atanBinary64(0x1.3cb0f12f39d8ap1), 0x1.2fcb120468e8ep0, math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.0ed746b39cbb7p-2), -0x1.08c71aa0e509p-2, math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
+    try testing.expectApproxEqAbs(atanBinary64(0x1.299d54ac7d6bp1), 0x1.2a24e22d861dfp0, math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
+    try testing.expectApproxEqAbs(atanBinary64(-0x1.0264fb9f3d50ep1), -0x1.1c617825f9751p0, math.floatEpsAt(f64, -0x1.1c617825f9751p0));
 }
 
-test "atan32.special" {
-    const epsilon = 0.000001;
+test "atanExtended80.special" {
+    try testing.expectEqual(atanExtended80(0x0p+0), 0x0p+0);
+    try testing.expectEqual(atanExtended80(-0x0p+0), -0x0p+0);
+    try testing.expectApproxEqAbs(atanExtended80(0x1p+0), 0x1.921fb54442d1846ap-1, math.floatEpsAt(f80, 0x1.921fb54442d1846ap-1));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1p+0), -0x1.921fb54442d1846ap-1, math.floatEpsAt(f80, -0x1.921fb54442d1846ap-1));
+    try testing.expectApproxEqAbs(atanExtended80(math.inf(f80)), 0x1.921fb54442d1846ap0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap0));
+    try testing.expectApproxEqAbs(atanExtended80(-math.inf(f80)), -0x1.921fb54442d1846ap0, math.floatEpsAt(f80, -0x1.921fb54442d1846ap0));
+    try testing.expect(math.isNan(atanExtended80(math.nan(f80))));
+}
 
-    try expect(math.isPositiveZero(atan32(0.0)));
-    try expect(math.isNegativeZero(atan32(-0.0)));
-    try expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
-    try expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
+test "atanExtended80" {
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.8629d0244cdcbed8p-2), -0x1.74c61f437701661p-2, math.floatEpsAt(f80, -0x1.74c61f437701661p-2));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.59d42d4659936d9ep1), -0x1.375fd7987cc1fd02p0, math.floatEpsAt(f80, -0x1.375fd7987cc1fd02p0));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.d2dbe23d04f067b4p0), -0x1.11b8adeba5615e04p0, math.floatEpsAt(f80, -0x1.11b8adeba5615e04p0));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.5f314e72398e7dbcp-1), -0x1.33d28ca76253964cp-1, math.floatEpsAt(f80, -0x1.33d28ca76253964cp-1));
+    try testing.expectApproxEqAbs(atanExtended80(0x1.5869af37b7d078cap1), 0x1.37082ce2dd03010cp0, math.floatEpsAt(f80, 0x1.37082ce2dd03010cp0));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.b13a05a66261821ap-2), -0x1.99d7cac66dd4438p-2, math.floatEpsAt(f80, -0x1.99d7cac66dd4438p-2));
+    try testing.expectApproxEqAbs(atanExtended80(0x1.3cb0f12f39d899cp1), 0x1.2fcb120468e8d9ecp0, math.floatEpsAt(f80, 0x1.2fcb120468e8d9ecp0));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.0ed746b39cbb7614p-2), -0x1.08c71aa0e5090998p-2, math.floatEpsAt(f80, -0x1.08c71aa0e5090998p-2));
+    try testing.expectApproxEqAbs(atanExtended80(0x1.299d54ac7d6afc52p1), 0x1.2a24e22d861debfep0, math.floatEpsAt(f80, 0x1.2a24e22d861debfep0));
+    try testing.expectApproxEqAbs(atanExtended80(-0x1.0264fb9f3d50e4fp1), -0x1.1c617825f97512b8p0, math.floatEpsAt(f80, -0x1.1c617825f97512b8p0));
 }
 
-test "atan64.special" {
-    const epsilon = 0.000001;
+test "atanBinary128.special" {
+    try testing.expectEqual(atanBinary128(0x0p+0), 0x0p+0);
+    try testing.expectEqual(atanBinary128(-0x0p+0), -0x0p+0);
+    try testing.expectApproxEqAbs(atanBinary128(0x1p+0), 0x1.921fb54442d18469898cc51701b8p-1, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p-1));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1p+0), -0x1.921fb54442d18469898cc51701b8p-1, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p-1));
+    try testing.expectApproxEqAbs(atanBinary128(math.inf(f128)), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectApproxEqAbs(atanBinary128(-math.inf(f128)), -0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expect(math.isNan(atanBinary128(math.nan(f128))));
+}
 
-    try expect(math.isPositiveZero(atan64(0.0)));
-    try expect(math.isNegativeZero(atan64(-0.0)));
-    try expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
-    try expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
+test "atanBinary128" {
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.8629d0244cdcbed71792ccdec26dp-2), -0x1.74c61f437701660ff76989d23707p-2, math.floatEpsAt(f128, -0x1.74c61f437701660ff76989d23707p-2));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.59d42d4659936d9e22b5dea4faefp1), -0x1.375fd7987cc1fd0119cf0cc5b708p0, math.floatEpsAt(f128, -0x1.375fd7987cc1fd0119cf0cc5b708p0));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.d2dbe23d04f067b42da3f8efdf57p0), -0x1.11b8adeba5615e0370722b511231p0, math.floatEpsAt(f128, -0x1.11b8adeba5615e0370722b511231p0));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.5f314e72398e7dbbe70fb072983ep-1), -0x1.33d28ca76253964cb5d3581cdd88p-1, math.floatEpsAt(f128, -0x1.33d28ca76253964cb5d3581cdd88p-1));
+    try testing.expectApproxEqAbs(atanBinary128(0x1.5869af37b7d078caa3456c44aecep1), 0x1.37082ce2dd03010bbea814dc5882p0, math.floatEpsAt(f128, 0x1.37082ce2dd03010bbea814dc5882p0));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.b13a05a66261821a364ad8c6c999p-2), -0x1.99d7cac66dd4438077284b491a91p-2, math.floatEpsAt(f128, -0x1.99d7cac66dd4438077284b491a91p-2));
+    try testing.expectApproxEqAbs(atanBinary128(0x1.3cb0f12f39d899c0d963ac413297p1), 0x1.2fcb120468e8d9ebdb74702314c8p0, math.floatEpsAt(f128, 0x1.2fcb120468e8d9ebdb74702314c8p0));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.0ed746b39cbb7614d8735e8315a8p-2), -0x1.08c71aa0e5090998206fbbe2090fp-2, math.floatEpsAt(f128, -0x1.08c71aa0e5090998206fbbe2090fp-2));
+    try testing.expectApproxEqAbs(atanBinary128(0x1.299d54ac7d6afc5154643b601519p1), 0x1.2a24e22d861debfd6f974500567fp0, math.floatEpsAt(f128, 0x1.2a24e22d861debfd6f974500567fp0));
+    try testing.expectApproxEqAbs(atanBinary128(-0x1.0264fb9f3d50e4f0f966f0686064p1), -0x1.1c617825f97512b7f38656ab12cdp0, math.floatEpsAt(f128, -0x1.1c617825f97512b7f38656ab12cdp0));
 }
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 3c2c4dd25fed0d205bbbf9d9be0b9f3fb78467a3..28602cd6f6ec14f15f586c01bf857234bf1ce8b7 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -836,12 +836,9 @@ const src_files = [_][]const u8{
     "musl/src/math/atan2.c",
     "musl/src/math/atan2f.c",
     "musl/src/math/atan2l.c",
-    "musl/src/math/atan.c",
-    "musl/src/math/atanf.c",
     "musl/src/math/atanh.c",
     "musl/src/math/atanhf.c",
     "musl/src/math/atanhl.c",
-    "musl/src/math/atanl.c",
     "musl/src/math/cbrt.c",
     "musl/src/math/cbrtf.c",
     "musl/src/math/cbrtl.c",
@@ -892,9 +889,6 @@ const src_files = [_][]const u8{
     "musl/src/math/i386/atan2f.s",
     "musl/src/math/i386/atan2l.s",
     "musl/src/math/i386/atan2.s",
-    "musl/src/math/i386/atanf.s",
-    "musl/src/math/i386/atanl.s",
-    "musl/src/math/i386/atan.s",
     "musl/src/math/i386/exp2l.s",
     "musl/src/math/i386/exp_ld.s",
     "musl/src/math/i386/expl.s",
@@ -1076,7 +1070,6 @@ const src_files = [_][]const u8{
     "musl/src/math/x32/acosl.s",
     "musl/src/math/x32/asinl.s",
     "musl/src/math/x32/atan2l.s",
-    "musl/src/math/x32/atanl.s",
     "musl/src/math/x32/exp2l.s",
     "musl/src/math/x32/expl.s",
     "musl/src/math/x32/expm1l.s",
@@ -1098,7 +1091,6 @@ const src_files = [_][]const u8{
     "musl/src/math/x86_64/acosl.s",
     "musl/src/math/x86_64/asinl.s",
     "musl/src/math/x86_64/atan2l.s",
-    "musl/src/math/x86_64/atanl.s",
     "musl/src/math/x86_64/exp2l.s",
     "musl/src/math/x86_64/expl.s",
     "musl/src/math/x86_64/expm1l.s",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 61d0f2cd0cb2d432d130aecd4b5f2b97fef1ad81..b1a1159778257d4b16297f1ce87f5431635dad23 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -698,12 +698,9 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/atan2.c",
     "musl/src/math/atan2f.c",
     "musl/src/math/atan2l.c",
-    "musl/src/math/atan.c",
-    "musl/src/math/atanf.c",
     "musl/src/math/atanh.c",
     "musl/src/math/atanhf.c",
     "musl/src/math/atanhl.c",
-    "musl/src/math/atanl.c",
     "musl/src/math/cbrt.c",
     "musl/src/math/cbrtf.c",
     "musl/src/math/cbrtl.c",
-- 
2.54.0


From b9819fce69e0f208e9e20071071a40863fbdb8a9 Mon Sep 17 00:00:00 2001
From: rpkak <rpkak@noreply.codeberg.org>
Date: Thu, 29 Jan 2026 23:28:20 +0100
Subject: [PATCH 081/499] Io.Threaded: limit copy_file_range len to prevent
 EOVERFLOW

---
 lib/std/Io/Threaded.zig | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 385bade400e548bdcb769a9c5fb78de2bd8ba0da..d265c5fdc94c681a24149d18ecb3cec891cefaf5 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -9675,10 +9675,12 @@ fn fileWriteFileStreaming(
             file_reader.interface.toss(n -| header.len);
             return n;
         }
+        var len: usize = @intFromEnum(limit);
         var off_in: i64 = undefined;
         const off_in_ptr: ?*i64 = switch (file_reader.mode) {
             .positional_simple, .streaming_simple => return error.Unimplemented,
             .positional => p: {
+                len = @min(len, std.math.maxInt(usize) - file_reader.pos);
                 off_in = @intCast(file_reader.pos);
                 break :p &off_in;
             },
@@ -9689,7 +9691,7 @@ fn fileWriteFileStreaming(
             .linux => n: {
                 const syscall: Syscall = try .start();
                 while (true) {
-                    const rc = linux_copy_file_range_sys.copy_file_range(in_fd, off_in_ptr, out_fd, null, @intFromEnum(limit), 0);
+                    const rc = linux_copy_file_range_sys.copy_file_range(in_fd, off_in_ptr, out_fd, null, len, 0);
                     switch (linux_copy_file_range_sys.errno(rc)) {
                         .SUCCESS => {
                             syscall.finish();
@@ -9849,10 +9851,12 @@ fn fileWriteFilePositional(
             file_reader.interface.toss(n -| header.len);
             return n;
         }
+        var len: usize = @min(@intFromEnum(limit), std.math.maxInt(usize) - offset);
         var off_in: i64 = undefined;
         const off_in_ptr: ?*i64 = switch (file_reader.mode) {
             .positional_simple, .streaming_simple => return error.Unimplemented,
             .positional => p: {
+                len = @min(len, std.math.maxInt(usize) - file_reader.pos);
                 off_in = @intCast(file_reader.pos);
                 break :p &off_in;
             },
@@ -9864,7 +9868,7 @@ fn fileWriteFilePositional(
             .linux => n: {
                 const syscall: Syscall = try .start();
                 while (true) {
-                    const rc = linux_copy_file_range_sys.copy_file_range(in_fd, off_in_ptr, out_fd, &off_out, @intFromEnum(limit), 0);
+                    const rc = linux_copy_file_range_sys.copy_file_range(in_fd, off_in_ptr, out_fd, &off_out, len, 0);
                     switch (linux_copy_file_range_sys.errno(rc)) {
                         .SUCCESS => {
                             syscall.finish();
@@ -9888,7 +9892,7 @@ fn fileWriteFilePositional(
                                 .IO => return error.InputOutput,
                                 .NOMEM => return error.SystemResources,
                                 .NOSPC => return error.NoSpaceLeft,
-                                .OVERFLOW => return error.Unseekable,
+                                .OVERFLOW => |err| errnoBug(err), // We avoid passing too large a count.
                                 .NXIO => return error.Unseekable,
                                 .SPIPE => return error.Unseekable,
                                 .PERM => return error.PermissionDenied,
-- 
2.54.0


From e7e168727e3c024869de9d114a7dd49d2a80de4d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 20:11:18 -0800
Subject: [PATCH 082/499] std.posix: goodbye connect, eventfd

---
 lib/std/os/linux/IoUring/test.zig | 17 +++++--
 lib/std/posix.zig                 | 78 +++----------------------------
 2 files changed, 19 insertions(+), 76 deletions(-)

diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig
index 2b152daf8e1e29b1b234b5cbbf38768ad6e90b45..ac2d5ddea54772253084d2699be4180cad7a794a 100644
--- a/lib/std/os/linux/IoUring/test.zig
+++ b/lib/std/os/linux/IoUring/test.zig
@@ -1755,7 +1755,7 @@ test "accept multishot" {
         // connect client
         const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
         errdefer posix.close(client);
-        try posix.connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
+        try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
 
         // test accept completion
         var cqe = try ring.copy_cqe();
@@ -1865,7 +1865,7 @@ test "accept_direct" {
 
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-            try posix.connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
+            try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
             defer posix.close(client);
 
             // accept completion
@@ -1899,7 +1899,7 @@ test "accept_direct" {
             try testing.expectEqual(@as(u32, 1), try ring.submit());
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-            try posix.connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
+            try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
             defer posix.close(client);
             // completion with error
             const cqe_accept = try ring.copy_cqe();
@@ -1949,7 +1949,7 @@ test "accept_multishot_direct" {
         for (registered_fds) |_| {
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-            try posix.connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
+            try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
             defer posix.close(client);
 
             // accept completion
@@ -1964,7 +1964,7 @@ test "accept_multishot_direct" {
         {
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-            try posix.connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
+            try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
             defer posix.close(client);
             // completion with error
             const cqe_accept = try ring.copy_cqe();
@@ -2734,3 +2734,10 @@ fn send(sockfd: posix.socket_t, buf: []const u8, flags: u32) !usize {
         else => return error.SendFailed,
     }
 }
+
+fn connect(sock: posix.socket_t, sock_addr: *const posix.sockaddr, len: posix.socklen_t) !void {
+    switch (posix.errno(posix.system.connect(sock, sock_addr, len))) {
+        .SUCCESS => return,
+        else => return error.ConnectFailed,
+    }
+}
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index 6bcb18155248f291d12848b93da4d6576f819b57..f5f3b73a594615de3b402588067afcafd839e945 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -1,27 +1,18 @@
 //! POSIX API layer.
 //!
 //! This is more cross platform than using OS-specific APIs, however, it is
-//! lower-level and less portable than other namespaces such as `std.fs` and
+//! lower-level and less portable than other namespaces such as `std.Io` and
 //! `std.process`.
 //!
 //! These APIs are generally lowered to libc function calls if and only if libc
 //! is linked. Most operating systems other than Windows, Linux, and WASI
 //! require always linking libc because they use it as the stable syscall ABI.
-//!
-//! Operating systems that are not POSIX-compliant are sometimes supported by
-//! this API layer; sometimes not. Generally, an implementation will be
-//! provided only if such implementation is straightforward on that operating
-//! system. Otherwise, programmers are expected to use OS-specific logic to
-//! deal with the exception.
-
 const builtin = @import("builtin");
 const native_os = builtin.os.tag;
 
 const std = @import("std.zig");
 const Io = std.Io;
 const mem = std.mem;
-const fs = std.fs;
-const max_path_bytes = std.fs.max_path_bytes;
 const maxInt = std.math.maxInt;
 const cast = std.math.cast;
 const assert = std.debug.assert;
@@ -122,15 +113,14 @@ pub const STDIN_FILENO = system.STDIN_FILENO;
 pub const STDOUT_FILENO = system.STDOUT_FILENO;
 pub const SYS = system.SYS;
 pub const Sigaction = system.Sigaction;
+/// Windows has no concept of `stat`.
+///
+/// On Linux, the `stat` bits/wrappers are removed due to having to maintain
+/// the different varying stat structs per target and libc, leading to runtime
+/// errors. Users targeting Linux should add a comptime check and use statx,
+/// similar to how `Io.File.stat` does.
 pub const Stat = switch (native_os) {
-    // Has no concept of `stat`.
     .windows => void,
-    // The `stat` bits/wrappers are removed due to having to maintain the
-    // different varying `struct stat`s per target and libc, leading to runtime
-    // errors.
-    //
-    // Users targeting linux should add a comptime check and use `statx`,
-    // similar to how `std.fs.File.stat` does.
     .linux => void,
     else => system.Stat,
 };
@@ -645,26 +635,6 @@ fn setSockFlags(sock: socket_t, flags: u32) !void {
     }
 }
 
-pub const EventFdError = error{
-    SystemResources,
-    ProcessFdQuotaExceeded,
-    SystemFdQuotaExceeded,
-} || UnexpectedError;
-
-pub fn eventfd(initval: u32, flags: u32) EventFdError!i32 {
-    const rc = system.eventfd(initval, flags);
-    switch (errno(rc)) {
-        .SUCCESS => return @intCast(rc),
-        else => |err| return unexpectedErrno(err),
-
-        .INVAL => unreachable, // invalid parameters
-        .MFILE => return error.ProcessFdQuotaExceeded,
-        .NFILE => return error.SystemFdQuotaExceeded,
-        .NODEV => return error.SystemResources,
-        .NOMEM => return error.SystemResources,
-    }
-}
-
 pub const GetSockNameError = error{
     /// Insufficient resources were available in the system to perform the operation.
     SystemResources,
@@ -707,40 +677,6 @@ pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSock
     }
 }
 
-pub const ConnectError = std.Io.net.IpAddress.ConnectError || std.Io.net.UnixAddress.ConnectError;
-
-pub fn connect(sock: socket_t, sock_addr: *const sockaddr, len: socklen_t) ConnectError!void {
-    if (native_os == .windows) {
-        @compileError("use std.Io instead");
-    }
-
-    while (true) {
-        switch (errno(system.connect(sock, sock_addr, len))) {
-            .SUCCESS => return,
-            .ACCES => return error.AccessDenied,
-            .PERM => return error.PermissionDenied,
-            .ADDRNOTAVAIL => return error.AddressUnavailable,
-            .AFNOSUPPORT => return error.AddressFamilyUnsupported,
-            .AGAIN, .INPROGRESS => return error.WouldBlock,
-            .ALREADY => return error.ConnectionPending,
-            .BADF => unreachable, // sockfd is not a valid open file descriptor.
-            .CONNREFUSED => return error.ConnectionRefused,
-            .CONNRESET => return error.ConnectionResetByPeer,
-            .FAULT => unreachable, // The socket structure address is outside the user's address space.
-            .INTR => continue,
-            .ISCONN => @panic("AlreadyConnected"), // The socket is already connected.
-            .HOSTUNREACH => return error.NetworkUnreachable,
-            .NETUNREACH => return error.NetworkUnreachable,
-            .NOTSOCK => unreachable, // The file descriptor sockfd does not refer to a socket.
-            .PROTOTYPE => unreachable, // The socket type does not support the requested communications protocol.
-            .TIMEDOUT => return error.Timeout,
-            .NOENT => return error.FileNotFound, // Returned when socket is AF.UNIX and the given path does not exist.
-            .CONNABORTED => unreachable, // Tried to reuse socket that previously received error.ConnectionRefused.
-            else => |err| return unexpectedErrno(err),
-        }
-    }
-}
-
 pub const FStatError = std.Io.File.StatError;
 
 /// Return information about a file descriptor.
-- 
2.54.0


From 36eb8dec98c743f369a2badf6a56599c736a45ae Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 20:24:33 -0800
Subject: [PATCH 083/499] std.posix: goodbye to some functions

- fstat
- inotify_init1
- inotify_add_watch, inotify_add_watchZ
- inotify_rm_watch
- sysctlbynameZ
---
 lib/std/Thread.zig                  |  15 ++--
 lib/std/posix.zig                   | 113 ----------------------------
 lib/std/process.zig                 |  26 ++++---
 lib/std/zig/system.zig              |  14 ++--
 lib/std/zig/system/darwin/macos.zig |  15 ++--
 5 files changed, 40 insertions(+), 143 deletions(-)

diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index ad25b1728e88abe10f4fe14c36b53a66c15b4b6a..33fd4c0234cddd970e478caf40f43cc7d7edba2b 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -809,12 +809,15 @@ const PosixThreadImpl = struct {
             else => {
                 var count: c_int = undefined;
                 var count_len: usize = @sizeOf(c_int);
-                const name = if (comptime target.os.tag.isDarwin()) "hw.logicalcpu" else "hw.ncpu";
-                posix.sysctlbynameZ(name, &count, &count_len, null, 0) catch |err| switch (err) {
-                    error.UnknownName => unreachable,
-                    else => |e| return e,
-                };
-                return @as(usize, @intCast(count));
+                const name = comptime if (target.os.tag.isDarwin()) "hw.logicalcpu" else "hw.ncpu";
+                switch (posix.errno(posix.system.sysctlbyname(name, &count, &count_len, null, 0))) {
+                    .SUCCESS => return @intCast(count),
+                    .FAULT => unreachable,
+                    .PERM => return error.PermissionDenied,
+                    .NOMEM => return error.SystemResources,
+                    .NOENT => unreachable,
+                    else => |err| return posix.unexpectedErrno(err),
+                }
             },
         }
     }
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index f5f3b73a594615de3b402588067afcafd839e945..6b5686b20a3531d04dfc975d5625022932b89782 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -677,89 +677,6 @@ pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSock
     }
 }
 
-pub const FStatError = std.Io.File.StatError;
-
-/// Return information about a file descriptor.
-pub fn fstat(fd: fd_t) FStatError!Stat {
-    if (native_os == .wasi and !builtin.link_libc) {
-        @compileError("unsupported OS");
-    }
-
-    var stat = mem.zeroes(Stat);
-    switch (errno(system.fstat(fd, &stat))) {
-        .SUCCESS => return stat,
-        .INVAL => unreachable,
-        .BADF => unreachable, // Always a race condition.
-        .NOMEM => return error.SystemResources,
-        .ACCES => return error.AccessDenied,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
-pub const INotifyInitError = error{
-    ProcessFdQuotaExceeded,
-    SystemFdQuotaExceeded,
-    SystemResources,
-} || UnexpectedError;
-
-/// initialize an inotify instance
-pub fn inotify_init1(flags: u32) INotifyInitError!i32 {
-    const rc = system.inotify_init1(flags);
-    switch (errno(rc)) {
-        .SUCCESS => return @intCast(rc),
-        .INVAL => unreachable,
-        .MFILE => return error.ProcessFdQuotaExceeded,
-        .NFILE => return error.SystemFdQuotaExceeded,
-        .NOMEM => return error.SystemResources,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
-pub const INotifyAddWatchError = error{
-    AccessDenied,
-    NameTooLong,
-    FileNotFound,
-    SystemResources,
-    UserResourceLimitReached,
-    NotDir,
-    WatchAlreadyExists,
-} || UnexpectedError;
-
-/// add a watch to an initialized inotify instance
-pub fn inotify_add_watch(inotify_fd: i32, pathname: []const u8, mask: u32) INotifyAddWatchError!i32 {
-    const pathname_c = try toPosixPath(pathname);
-    return inotify_add_watchZ(inotify_fd, &pathname_c, mask);
-}
-
-/// Same as `inotify_add_watch` except pathname is null-terminated.
-pub fn inotify_add_watchZ(inotify_fd: i32, pathname: [*:0]const u8, mask: u32) INotifyAddWatchError!i32 {
-    const rc = system.inotify_add_watch(inotify_fd, pathname, mask);
-    switch (errno(rc)) {
-        .SUCCESS => return @intCast(rc),
-        .ACCES => return error.AccessDenied,
-        .BADF => unreachable,
-        .FAULT => unreachable,
-        .INVAL => unreachable,
-        .NAMETOOLONG => return error.NameTooLong,
-        .NOENT => return error.FileNotFound,
-        .NOMEM => return error.SystemResources,
-        .NOSPC => return error.UserResourceLimitReached,
-        .NOTDIR => return error.NotDir,
-        .EXIST => return error.WatchAlreadyExists,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
-/// remove an existing watch from an inotify instance
-pub fn inotify_rm_watch(inotify_fd: i32, wd: i32) void {
-    switch (errno(system.inotify_rm_watch(inotify_fd, wd))) {
-        .SUCCESS => return,
-        .BADF => unreachable,
-        .INVAL => unreachable,
-        else => unreachable,
-    }
-}
-
 pub const FanotifyInitError = error{
     ProcessFdQuotaExceeded,
     SystemFdQuotaExceeded,
@@ -996,36 +913,6 @@ pub fn sysctl(
     }
 }
 
-pub const SysCtlByNameError = error{
-    PermissionDenied,
-    SystemResources,
-    UnknownName,
-} || UnexpectedError;
-
-pub fn sysctlbynameZ(
-    name: [*:0]const u8,
-    oldp: ?*anyopaque,
-    oldlenp: ?*usize,
-    newp: ?*anyopaque,
-    newlen: usize,
-) SysCtlByNameError!void {
-    if (native_os == .wasi) {
-        @compileError("sysctl not supported on WASI");
-    }
-    if (native_os == .haiku) {
-        @compileError("sysctl not supported on Haiku");
-    }
-
-    switch (errno(system.sysctlbyname(name, oldp, oldlenp, newp, newlen))) {
-        .SUCCESS => return,
-        .FAULT => unreachable,
-        .PERM => return error.PermissionDenied,
-        .NOMEM => return error.SystemResources,
-        .NOENT => return error.UnknownName,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
 pub fn gettimeofday(tv: ?*timeval, tz: ?*timezone) void {
     switch (errno(system.gettimeofday(tv, tz))) {
         .SUCCESS => return,
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 5bcacddc84a993d96586b861411af63148f361ac..8395882c167cbe0149f081cd7fb4af413ec24e08 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -556,26 +556,28 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
             const name = if (native_os == .netbsd) "hw.physmem64" else "hw.physmem";
             var physmem: c_ulong = undefined;
             var len: usize = @sizeOf(c_ulong);
-            posix.sysctlbynameZ(name, &physmem, &len, null, 0) catch |err| switch (err) {
-                error.PermissionDenied => unreachable, // only when setting values,
-                error.SystemResources => unreachable, // memory already on the stack
-                error.UnknownName => unreachable,
+            switch (posix.errno(posix.system.sysctlbyname(name, &physmem, &len, null, 0))) {
+                .SUCCESS => return @intCast(physmem),
+                .FAULT => unreachable,
+                .PERM => unreachable, // only when setting values
+                .NOMEM => unreachable, // memory already on the stack
+                .NOENT => unreachable,
                 else => return error.UnknownTotalSystemMemory,
-            };
-            return @intCast(physmem);
+            }
         },
         // whole Darwin family
         .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
             // "hw.memsize" returns uint64_t
             var physmem: u64 = undefined;
             var len: usize = @sizeOf(u64);
-            posix.sysctlbynameZ("hw.memsize", &physmem, &len, null, 0) catch |err| switch (err) {
-                error.PermissionDenied => unreachable, // only when setting values,
-                error.SystemResources => unreachable, // memory already on the stack
-                error.UnknownName => unreachable, // constant, known good value
+            switch (posix.errno(posix.system.sysctlbyname("hw.memsize", &physmem, &len, null, 0))) {
+                .SUCCESS => return physmem,
+                .FAULT => unreachable,
+                .PERM => unreachable, // only when setting values
+                .NOMEM => unreachable, // memory already on the stack
+                .NOENT => unreachable, // constant, known good value
                 else => return error.UnknownTotalSystemMemory,
-            };
-            return physmem;
+            }
         },
         .openbsd => {
             const mib: [2]c_int = [_]c_int{
diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig
index efcf569de5a5ef12170c7c7a3ea82a9774569b1a..5046e2f51b081b77c95a9e08020eb24b688498a5 100644
--- a/lib/std/zig/system.zig
+++ b/lib/std/zig/system.zig
@@ -260,12 +260,14 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target {
                 var value: u32 = undefined;
                 var len: usize = @sizeOf(@TypeOf(value));
 
-                posix.sysctlbynameZ(key, &value, &len, null, 0) catch |err| switch (err) {
-                    error.PermissionDenied => unreachable, // only when setting values,
-                    error.SystemResources => unreachable, // memory already on the stack
-                    error.UnknownName => unreachable, // constant, known good value
-                    error.Unexpected => return error.OSVersionDetectionFail,
-                };
+                switch (posix.errno(posix.system.sysctlbyname(key, &value, &len, null, 0))) {
+                    .SUCCESS => {},
+                    .FAULT => unreachable,
+                    .PERM => unreachable, // only when setting values,
+                    .NOMEM => unreachable, // memory already on the stack
+                    .NOENT => unreachable, // constant, known good value
+                    else => return error.OSVersionDetectionFail,
+                }
 
                 switch (builtin.target.os.tag) {
                     .freebsd => {
diff --git a/lib/std/zig/system/darwin/macos.zig b/lib/std/zig/system/darwin/macos.zig
index 7d80c2b588e6a6587ae7437d454666a9d8d2fed4..c9dc8b57ce5928ba1e3eca5135f243d797643728 100644
--- a/lib/std/zig/system/darwin/macos.zig
+++ b/lib/std/zig/system/darwin/macos.zig
@@ -2,6 +2,7 @@ const builtin = @import("builtin");
 
 const std = @import("std");
 const Io = std.Io;
+const posix = std.posix;
 const assert = std.debug.assert;
 const mem = std.mem;
 const testing = std.testing;
@@ -399,12 +400,14 @@ test "detect" {
 pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
     var cpu_family: std.c.CPUFAMILY = undefined;
     var len: usize = @sizeOf(std.c.CPUFAMILY);
-    std.posix.sysctlbynameZ("hw.cpufamily", &cpu_family, &len, null, 0) catch |err| switch (err) {
-        error.PermissionDenied => unreachable, // only when setting values,
-        error.SystemResources => unreachable, // memory already on the stack
-        error.UnknownName => unreachable, // constant, known good value
-        error.Unexpected => unreachable, // EFAULT: stack should be safe, EISDIR/ENOTDIR: constant, known good value
-    };
+    switch (posix.errno(posix.system.sysctlbyname("hw.cpufamily", &cpu_family, &len, null, 0))) {
+        .SUCCESS => {},
+        .FAULT => unreachable, // segmentation fault
+        .PERM => unreachable, // only when setting values,
+        .NOMEM => unreachable, // memory already on the stack
+        .NOENT => unreachable, // constant, known good value
+        else => unreachable,
+    }
 
     const current_arch = builtin.cpu.arch;
     switch (current_arch) {
-- 
2.54.0


From 0c67d9ebdec86a5faac9336c9ed912d798050e17 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 20:27:01 -0800
Subject: [PATCH 084/499] std.posix: goodbye gettimeofday

---
 lib/std/posix.zig | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index 6b5686b20a3531d04dfc975d5625022932b89782..660551fee40ff1b1d7c850412aabefa636fe192b 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -913,14 +913,6 @@ pub fn sysctl(
     }
 }
 
-pub fn gettimeofday(tv: ?*timeval, tz: ?*timezone) void {
-    switch (errno(system.gettimeofday(tv, tz))) {
-        .SUCCESS => return,
-        .INVAL => unreachable,
-        else => unreachable,
-    }
-}
-
 pub const FcntlError = error{
     PermissionDenied,
     FileBusy,
-- 
2.54.0


From 6a3226c43cd63fd331c3f4340d4331a8875138e3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 21:07:57 -0800
Subject: [PATCH 085/499] std.Io: add net.Socket.createPair

and remove the following from std.posix:
- socketpair
- fcntl
---
 lib/std/Io.zig          |   1 +
 lib/std/Io/Threaded.zig | 206 +++++++++++++++++++++++++---------------
 lib/std/Io/net.zig      |  29 ++++++
 lib/std/posix.zig       | 155 ------------------------------
 lib/std/posix/test.zig  |  10 +-
 5 files changed, 162 insertions(+), 239 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 72df9e34f3ec9523577a921a43eb3086586fca4e..0c252492180404d6e41bd9b72d61421a5fda10e0 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -688,6 +688,7 @@ pub const VTable = struct {
     netConnectIp: *const fn (?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ConnectOptions) net.IpAddress.ConnectError!net.Stream,
     netListenUnix: *const fn (?*anyopaque, *const net.UnixAddress, net.UnixAddress.ListenOptions) net.UnixAddress.ListenError!net.Socket.Handle,
     netConnectUnix: *const fn (?*anyopaque, *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle,
+    netSocketCreatePair: *const fn (?*anyopaque, net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket,
     netSend: *const fn (?*anyopaque, net.Socket.Handle, []net.OutgoingMessage, net.SendFlags) struct { ?net.Socket.SendError, usize },
     netReceive: *const fn (?*anyopaque, net.Socket.Handle, message_buffer: []net.IncomingMessage, data_buffer: []u8, net.ReceiveFlags, Timeout) struct { ?net.Socket.ReceiveTimeoutError, usize },
     /// Returns 0 on end of stream.
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index d265c5fdc94c681a24149d18ecb3cec891cefaf5..f0562504fd5e4b833ed19ddea38638b0824bd5f1 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1684,6 +1684,7 @@ pub fn io(t: *Threaded) Io {
                 .windows => netConnectUnixWindows,
                 else => netConnectUnixPosix,
             },
+            .netSocketCreatePair = netSocketCreatePair,
             .netClose = netClose,
             .netShutdown = switch (native_os) {
                 .windows => netShutdownWindows,
@@ -1824,6 +1825,7 @@ pub fn ioBasic(t: *Threaded) Io {
             .netAccept = netAcceptUnavailable,
             .netBindIp = netBindIpUnavailable,
             .netConnectIp = netConnectIpUnavailable,
+            .netSocketCreatePair = netSocketCreatePairUnavailable,
             .netConnectUnix = netConnectUnixUnavailable,
             .netClose = netCloseUnavailable,
             .netShutdown = netShutdownUnavailable,
@@ -10612,43 +10614,36 @@ fn posixConnect(
     addr_len: posix.socklen_t,
 ) !void {
     const syscall: Syscall = try .start();
-    while (true) {
-        switch (posix.errno(posix.system.connect(socket_fd, addr, addr_len))) {
-            .SUCCESS => {
-                syscall.finish();
-                return;
-            },
-            .INTR => {
-                try syscall.checkCancel();
-                continue;
-            },
-            else => |e| {
-                syscall.finish();
-                switch (e) {
-                    .ADDRNOTAVAIL => return error.AddressUnavailable,
-                    .AFNOSUPPORT => return error.AddressFamilyUnsupported,
-                    .AGAIN, .INPROGRESS => return error.WouldBlock,
-                    .ALREADY => return error.ConnectionPending,
-                    .BADF => |err| return errnoBug(err), // File descriptor used after closed.
-                    .CONNREFUSED => return error.ConnectionRefused,
-                    .CONNRESET => return error.ConnectionResetByPeer,
-                    .FAULT => |err| return errnoBug(err),
-                    .ISCONN => |err| return errnoBug(err),
-                    .HOSTUNREACH => return error.HostUnreachable,
-                    .NETUNREACH => return error.NetworkUnreachable,
-                    .NOTSOCK => |err| return errnoBug(err),
-                    .PROTOTYPE => |err| return errnoBug(err),
-                    .TIMEDOUT => return error.Timeout,
-                    .CONNABORTED => |err| return errnoBug(err),
-                    .ACCES => return error.AccessDenied,
-                    .PERM => |err| return errnoBug(err),
-                    .NOENT => |err| return errnoBug(err),
-                    .NETDOWN => return error.NetworkDown,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
-        }
-    }
+    while (true) switch (posix.errno(posix.system.connect(socket_fd, addr, addr_len))) {
+        .SUCCESS => {
+            syscall.finish();
+            return;
+        },
+        .INTR => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .ADDRNOTAVAIL => return syscall.fail(error.AddressUnavailable),
+        .AFNOSUPPORT => return syscall.fail(error.AddressFamilyUnsupported),
+        .AGAIN, .INPROGRESS => return syscall.fail(error.WouldBlock),
+        .ALREADY => return syscall.fail(error.ConnectionPending),
+        .CONNREFUSED => return syscall.fail(error.ConnectionRefused),
+        .CONNRESET => return syscall.fail(error.ConnectionResetByPeer),
+        .HOSTUNREACH => return syscall.fail(error.HostUnreachable),
+        .NETUNREACH => return syscall.fail(error.NetworkUnreachable),
+        .TIMEDOUT => return syscall.fail(error.Timeout),
+        .ACCES => return syscall.fail(error.AccessDenied),
+        .NETDOWN => return syscall.fail(error.NetworkDown),
+        .BADF => |err| return syscall.errnoBug(err), // File descriptor used after closed.
+        .CONNABORTED => |err| return syscall.errnoBug(err),
+        .FAULT => |err| return syscall.errnoBug(err),
+        .ISCONN => |err| return syscall.errnoBug(err),
+        .NOENT => |err| return syscall.errnoBug(err),
+        .NOTSOCK => |err| return syscall.errnoBug(err),
+        .PERM => |err| return syscall.errnoBug(err),
+        .PROTOTYPE => |err| return syscall.errnoBug(err),
+        else => |err| return syscall.unexpectedErrno(err),
+    };
 }
 
 fn posixConnectUnix(
@@ -11106,46 +11101,31 @@ fn openSocketPosix(
 }!posix.socket_t {
     const mode = posixSocketMode(options.mode);
     const protocol = posixProtocol(options.protocol);
+    const flags: u32 = mode | if (socket_flags_unsupported) 0 else posix.SOCK.CLOEXEC;
     const syscall: Syscall = try .start();
     const socket_fd = while (true) {
-        const flags: u32 = mode | if (socket_flags_unsupported) 0 else posix.SOCK.CLOEXEC;
-        const socket_rc = posix.system.socket(family, flags, protocol);
-        switch (posix.errno(socket_rc)) {
+        const rc = posix.system.socket(family, flags, protocol);
+        switch (posix.errno(rc)) {
             .SUCCESS => {
-                const fd: posix.fd_t = @intCast(socket_rc);
+                syscall.finish();
+                const fd: posix.fd_t = @intCast(rc);
                 errdefer posix.close(fd);
-                if (socket_flags_unsupported) while (true) {
-                    try syscall.checkCancel();
-                    switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
-                        .SUCCESS => break,
-                        .INTR => continue,
-                        else => |err| {
-                            syscall.finish();
-                            return posix.unexpectedErrno(err);
-                        },
-                    }
-                };
-                syscall.finish();
+                if (socket_flags_unsupported) try setCloexec(fd);
                 break fd;
             },
             .INTR => {
                 try syscall.checkCancel();
                 continue;
             },
-            else => |e| {
-                syscall.finish();
-                switch (e) {
-                    .AFNOSUPPORT => return error.AddressFamilyUnsupported,
-                    .INVAL => return error.ProtocolUnsupportedBySystem,
-                    .MFILE => return error.ProcessFdQuotaExceeded,
-                    .NFILE => return error.SystemFdQuotaExceeded,
-                    .NOBUFS => return error.SystemResources,
-                    .NOMEM => return error.SystemResources,
-                    .PROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
-                    .PROTOTYPE => return error.SocketModeUnsupported,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
+            .AFNOSUPPORT => return syscall.fail(error.AddressFamilyUnsupported),
+            .INVAL => return syscall.fail(error.ProtocolUnsupportedBySystem),
+            .MFILE => return syscall.fail(error.ProcessFdQuotaExceeded),
+            .NFILE => return syscall.fail(error.SystemFdQuotaExceeded),
+            .NOBUFS => return syscall.fail(error.SystemResources),
+            .NOMEM => return syscall.fail(error.SystemResources),
+            .PROTONOSUPPORT => return syscall.fail(error.ProtocolUnsupportedByAddressFamily),
+            .PROTOTYPE => return syscall.fail(error.SocketModeUnsupported),
+            else => |err| return syscall.unexpectedErrno(err),
         }
     };
     errdefer posix.close(socket_fd);
@@ -11158,6 +11138,84 @@ fn openSocketPosix(
     return socket_fd;
 }
 
+fn setCloexec(fd: posix.fd_t) error{ Canceled, Unexpected }!void {
+    const syscall: Syscall = try .start();
+    while (true) switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
+        .SUCCESS => return syscall.finish(),
+        .INTR => {
+            try syscall.checkCancel();
+            continue;
+        },
+        else => |err| return syscall.unexpectedErrno(err),
+    };
+}
+
+fn netSocketCreatePair(
+    userdata: ?*anyopaque,
+    options: net.Socket.CreatePairOptions,
+) net.Socket.CreatePairError![2]net.Socket {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+    if (!have_networking) return error.OperationUnsupported;
+    if (@TypeOf(posix.system.socketpair) == void) return error.OperationUnsupported;
+    if (native_os == .haiku) @panic("TODO");
+
+    const family: posix.sa_family_t = switch (options.family) {
+        .ip4 => posix.AF.INET,
+        .ip6 => posix.AF.INET6,
+    };
+    const mode = posixSocketMode(options.mode);
+    const protocol = posixProtocol(options.protocol);
+    const flags: u32 = mode | if (socket_flags_unsupported) 0 else posix.SOCK.CLOEXEC;
+
+    var sockets: [2]posix.socket_t = undefined;
+    const syscall: Syscall = try .start();
+    while (true) switch (posix.errno(posix.system.socketpair(family, flags, protocol, &sockets))) {
+        .SUCCESS => {
+            syscall.finish();
+            errdefer {
+                posix.close(sockets[0]);
+                posix.close(sockets[1]);
+            }
+            if (socket_flags_unsupported) {
+                try setCloexec(sockets[0]);
+                try setCloexec(sockets[1]);
+            }
+            var storages: [2]PosixAddress = undefined;
+            var addr_lens: [2]posix.socklen_t = .{ @sizeOf(PosixAddress), @sizeOf(PosixAddress) };
+            try posixGetSockName(sockets[0], &storages[0].any, &addr_lens[0]);
+            try posixGetSockName(sockets[1], &storages[1].any, &addr_lens[1]);
+            return .{
+                .{ .handle = sockets[0], .address = addressFromPosix(&storages[0]) },
+                .{ .handle = sockets[1], .address = addressFromPosix(&storages[1]) },
+            };
+        },
+        .INTR => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .ACCES => return syscall.fail(error.AccessDenied),
+        .AFNOSUPPORT => return syscall.fail(error.AddressFamilyUnsupported),
+        .INVAL => return syscall.fail(error.ProtocolUnsupportedBySystem),
+        .MFILE => return syscall.fail(error.ProcessFdQuotaExceeded),
+        .NFILE => return syscall.fail(error.SystemFdQuotaExceeded),
+        .NOBUFS => return syscall.fail(error.SystemResources),
+        .NOMEM => return syscall.fail(error.SystemResources),
+        .PROTONOSUPPORT => return syscall.fail(error.ProtocolUnsupportedByAddressFamily),
+        .PROTOTYPE => return syscall.fail(error.SocketModeUnsupported),
+        else => |err| return syscall.unexpectedErrno(err),
+    };
+}
+
+fn netSocketCreatePairUnavailable(
+    userdata: ?*anyopaque,
+    options: net.Socket.CreatePairOptions,
+) net.Socket.CreatePairError![2]net.Socket {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
 fn openSocketWsa(
     t: *Threaded,
     family: posix.sa_family_t,
@@ -11216,20 +11274,10 @@ fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Serve
             posix.system.accept(listen_fd, &storage.any, &addr_len);
         switch (posix.errno(rc)) {
             .SUCCESS => {
+                syscall.finish();
                 const fd: posix.fd_t = @intCast(rc);
                 errdefer posix.close(fd);
-                if (!have_accept4) while (true) {
-                    try syscall.checkCancel();
-                    switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
-                        .SUCCESS => break,
-                        .INTR => continue,
-                        else => |err| {
-                            syscall.finish();
-                            return posix.unexpectedErrno(err);
-                        },
-                    }
-                };
-                syscall.finish();
+                if (!have_accept4) try setCloexec(fd);
                 break fd;
             },
             .INTR => {
diff --git a/lib/std/Io/net.zig b/lib/std/Io/net.zig
index 76a581180d10ae2f256fe407413a2f15911e4f70..21bd13caf387e758d91333809879e87469250677 100644
--- a/lib/std/Io/net.zig
+++ b/lib/std/Io/net.zig
@@ -1187,6 +1187,35 @@ pub const Socket = struct {
     ) struct { ?ReceiveTimeoutError, usize } {
         return io.vtable.netReceive(io.userdata, s.handle, message_buffer, data_buffer, flags, timeout);
     }
+
+    pub const CreatePairError = error{
+        OperationUnsupported,
+        AccessDenied,
+        AddressFamilyUnsupported,
+        ProtocolUnsupportedBySystem,
+        /// The per-process limit on the number of open file descriptors has been reached.
+        ProcessFdQuotaExceeded,
+        /// The system-wide limit on the total number of open files has been reached.
+        SystemFdQuotaExceeded,
+        /// Insufficient memory is available. The socket cannot be created
+        /// until sufficient resources are freed.
+        SystemResources,
+        ProtocolUnsupportedByAddressFamily,
+        SocketModeUnsupported,
+    } || Io.UnexpectedError || Io.Cancelable;
+
+    pub const CreatePairOptions = struct {
+        family: IpAddress.Family = .ip4,
+        mode: Mode = .stream,
+        protocol: ?Protocol = null,
+    };
+
+    /// Create a set of two sockets that are connected to each other.
+    ///
+    /// Also known as "socketpair".
+    pub fn createPair(io: Io, options: CreatePairOptions) CreatePairError![2]Socket {
+        return io.vtable.netSocketCreatePair(io.userdata, options);
+    }
 };
 
 /// An open socket connection with a network protocol that guarantees
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index 660551fee40ff1b1d7c850412aabefa636fe192b..5e2cde9aa52421fc3f74a8b3baf92eb37c3cc562 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -509,132 +509,6 @@ pub fn getppid() pid_t {
     return system.getppid();
 }
 
-pub const SocketError = error{
-    /// Permission to create a socket of the specified type and/or
-    /// pro‐tocol is denied.
-    AccessDenied,
-
-    /// The implementation does not support the specified address family.
-    AddressFamilyUnsupported,
-
-    /// Unknown protocol, or protocol family not available.
-    ProtocolFamilyNotAvailable,
-
-    /// The per-process limit on the number of open file descriptors has been reached.
-    ProcessFdQuotaExceeded,
-
-    /// The system-wide limit on the total number of open files has been reached.
-    SystemFdQuotaExceeded,
-
-    /// Insufficient memory is available. The socket cannot be created until sufficient
-    /// resources are freed.
-    SystemResources,
-
-    /// The protocol type or the specified protocol is not supported within this domain.
-    ProtocolNotSupported,
-
-    /// The socket type is not supported by the protocol.
-    SocketTypeNotSupported,
-} || UnexpectedError;
-
-pub fn socketpair(domain: u32, socket_type: u32, protocol: u32) SocketError![2]socket_t {
-    // Note to the future: we could provide a shim here for e.g. windows which
-    // creates a listening socket, then creates a second socket and connects it
-    // to the listening socket, and then returns the two.
-    if (@TypeOf(system.socketpair) == void)
-        @compileError("socketpair() not supported by this OS");
-
-    // I'm not really sure if haiku supports flags here.  I'm following the
-    // existing filter here from pipe2(), because it sure seems like it
-    // supports flags there too, but haiku can be hard to understand.
-    const have_sock_flags = !builtin.target.os.tag.isDarwin() and native_os != .haiku;
-    const filtered_sock_type = if (!have_sock_flags)
-        socket_type & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC)
-    else
-        socket_type;
-    var socks: [2]socket_t = undefined;
-    const rc = system.socketpair(domain, filtered_sock_type, protocol, &socks);
-    switch (errno(rc)) {
-        .SUCCESS => {
-            errdefer close(socks[0]);
-            errdefer close(socks[1]);
-            if (!have_sock_flags) {
-                try setSockFlags(socks[0], socket_type);
-                try setSockFlags(socks[1], socket_type);
-            }
-            return socks;
-        },
-        .ACCES => return error.AccessDenied,
-        .AFNOSUPPORT => return error.AddressFamilyUnsupported,
-        .INVAL => return error.ProtocolFamilyNotAvailable,
-        .MFILE => return error.ProcessFdQuotaExceeded,
-        .NFILE => return error.SystemFdQuotaExceeded,
-        .NOBUFS => return error.SystemResources,
-        .NOMEM => return error.SystemResources,
-        .PROTONOSUPPORT => return error.ProtocolNotSupported,
-        .PROTOTYPE => return error.SocketTypeNotSupported,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
-fn setSockFlags(sock: socket_t, flags: u32) !void {
-    if ((flags & SOCK.CLOEXEC) != 0) {
-        if (native_os == .windows) {
-            // TODO: Find out if this is supported for sockets
-        } else {
-            var fd_flags = fcntl(sock, F.GETFD, 0) catch |err| switch (err) {
-                error.FileBusy => unreachable,
-                error.Locked => unreachable,
-                error.PermissionDenied => unreachable,
-                error.DeadLock => unreachable,
-                error.LockedRegionLimitExceeded => unreachable,
-                else => |e| return e,
-            };
-            fd_flags |= FD_CLOEXEC;
-            _ = fcntl(sock, F.SETFD, fd_flags) catch |err| switch (err) {
-                error.FileBusy => unreachable,
-                error.Locked => unreachable,
-                error.PermissionDenied => unreachable,
-                error.DeadLock => unreachable,
-                error.LockedRegionLimitExceeded => unreachable,
-                else => |e| return e,
-            };
-        }
-    }
-    if ((flags & SOCK.NONBLOCK) != 0) {
-        if (native_os == .windows) {
-            var mode: c_ulong = 1;
-            if (windows.ws2_32.ioctlsocket(sock, windows.ws2_32.FIONBIO, &mode) == windows.ws2_32.SOCKET_ERROR) {
-                switch (windows.ws2_32.WSAGetLastError()) {
-                    .NOTINITIALISED => unreachable,
-                    .ENETDOWN => return error.NetworkDown,
-                    .ENOTSOCK => return error.FileDescriptorNotASocket,
-                    // TODO: handle more errors
-                    else => |err| return windows.unexpectedWSAError(err),
-                }
-            }
-        } else {
-            var fl_flags = fcntl(sock, F.GETFL, 0) catch |err| switch (err) {
-                error.FileBusy => unreachable,
-                error.Locked => unreachable,
-                error.PermissionDenied => unreachable,
-                error.DeadLock => unreachable,
-                error.LockedRegionLimitExceeded => unreachable,
-                else => |e| return e,
-            };
-            fl_flags |= 1 << @bitOffsetOf(O, "NONBLOCK");
-            _ = fcntl(sock, F.SETFL, fl_flags) catch |err| switch (err) {
-                error.FileBusy => unreachable,
-                error.Locked => unreachable,
-                error.PermissionDenied => unreachable,
-                error.DeadLock => unreachable,
-                error.LockedRegionLimitExceeded => unreachable,
-                else => |e| return e,
-            };
-        }
-    }
-}
-
 pub const GetSockNameError = error{
     /// Insufficient resources were available in the system to perform the operation.
     SystemResources,
@@ -913,35 +787,6 @@ pub fn sysctl(
     }
 }
 
-pub const FcntlError = error{
-    PermissionDenied,
-    FileBusy,
-    ProcessFdQuotaExceeded,
-    Locked,
-    DeadLock,
-    LockedRegionLimitExceeded,
-} || UnexpectedError;
-
-pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) FcntlError!usize {
-    while (true) {
-        const rc = system.fcntl(fd, cmd, arg);
-        switch (errno(rc)) {
-            .SUCCESS => return @intCast(rc),
-            .INTR => continue,
-            .AGAIN, .ACCES => return error.Locked,
-            .BADF => unreachable,
-            .BUSY => return error.FileBusy,
-            .INVAL => unreachable, // invalid parameters
-            .PERM => return error.PermissionDenied,
-            .MFILE => return error.ProcessFdQuotaExceeded,
-            .NOTDIR => unreachable, // invalid parameter
-            .DEADLK => return error.DeadLock,
-            .NOLCK => return error.LockedRegionLimitExceeded,
-            else => |err| return unexpectedErrno(err),
-        }
-    }
-}
-
 pub fn getSelfPhdrs() []std.elf.ElfN.Phdr {
     const getauxval = if (builtin.link_libc) std.c.getauxval else std.os.linux.getauxval;
     assert(getauxval(std.elf.AT_PHENT) == @sizeOf(std.elf.ElfN.Phdr));
diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig
index e720c4a4e6d23aee4573fa082582e5e0c4c066e8..5838595fcf50cec130595089b7d38c26b17f19b8 100644
--- a/lib/std/posix/test.zig
+++ b/lib/std/posix/test.zig
@@ -273,17 +273,17 @@ test "fcntl" {
 
     // Note: The test assumes createFile opens the file with CLOEXEC
     {
-        const flags = try posix.fcntl(file.handle, posix.F.GETFD, 0);
+        const flags = posix.system.fcntl(file.handle, posix.F.GETFD, @as(usize, 0));
         try expect((flags & posix.FD_CLOEXEC) != 0);
     }
     {
-        _ = try posix.fcntl(file.handle, posix.F.SETFD, 0);
-        const flags = try posix.fcntl(file.handle, posix.F.GETFD, 0);
+        _ = posix.system.fcntl(file.handle, posix.F.SETFD, @as(usize, 0));
+        const flags = posix.system.fcntl(file.handle, posix.F.GETFD, @as(usize, 0));
         try expect((flags & posix.FD_CLOEXEC) == 0);
     }
     {
-        _ = try posix.fcntl(file.handle, posix.F.SETFD, posix.FD_CLOEXEC);
-        const flags = try posix.fcntl(file.handle, posix.F.GETFD, 0);
+        _ = posix.system.fcntl(file.handle, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC));
+        const flags = posix.system.fcntl(file.handle, posix.F.GETFD, @as(usize, 0));
         try expect((flags & posix.FD_CLOEXEC) != 0);
     }
 }
-- 
2.54.0


From fa988e88ed21485830a70276b5c7567efb122f80 Mon Sep 17 00:00:00 2001
From: mercenary <mercenary@noreply.codeberg.org>
Date: Fri, 30 Jan 2026 20:19:19 +0100
Subject: [PATCH 086/499] zstd.Decompress: smarter rebase when discarding
 (#30891)

The call to `rebase` in `discardIndirect` and `discardDirect` was inappropriate. As `rebase` expects the `capacity` parameter to exclude the sliding window, this call was asking for ANOTHER `d.window_len` bytes. This was impossible to fulfill with a buffer smaller than 2*`d.window_len`, and caused [#25764](https://github.com/ziglang/zig/issues/25764).

This PR adds a basic test to do a discard (which does trigger [#25764](https://github.com/ziglang/zig/issues/25764)), and rebases only as much as is required to make the discard succeed ([or no rebase at all](https://github.com/ziglang/zig/issues/25764#issuecomment-3484716253)). That means: ideally rebase to fit `limit`, or if the buffer is too small, as much as possible.

I must say, `discardDirect` does not make much sense to me, but I replaced it anyway. `rebaseForDiscard` works fine with `d.reader.buffer.len == 0`. Let me know if anything should be changed.

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30891
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: mercenary <mercenary@noreply.codeberg.org>
Co-committed-by: mercenary <mercenary@noreply.codeberg.org>
---
 lib/std/Io.zig                       |  8 ++++++++
 lib/std/compress/zstd.zig            | 13 +++++++++++++
 lib/std/compress/zstd/Decompress.zig | 24 ++++++++++++++++++++++--
 3 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 0c252492180404d6e41bd9b72d61421a5fda10e0..6dc0e247315c4a69ed02332c9935131a5d6812fc 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -728,6 +728,14 @@ pub const Limit = enum(usize) {
         return @enumFromInt(@min(@intFromEnum(a), @intFromEnum(b)));
     }
 
+    pub fn max(a: Limit, b: Limit) Limit {
+        if (a == .unlimited or b == .unlimited) {
+            return .unlimited;
+        }
+
+        return @enumFromInt(@max(@intFromEnum(a), @intFromEnum(b)));
+    }
+
     pub fn minInt(l: Limit, n: usize) usize {
         return @min(n, @intFromEnum(l));
     }
diff --git a/lib/std/compress/zstd.zig b/lib/std/compress/zstd.zig
index 39073b51c58b3b91a68f6db2adb5dfdd3ce8025b..51168889c6355b7952e9fe54576c7b74edc6d197 100644
--- a/lib/std/compress/zstd.zig
+++ b/lib/std/compress/zstd.zig
@@ -88,6 +88,17 @@ fn testDecompress(gpa: std.mem.Allocator, compressed: []const u8) ![]u8 {
     return out.toOwnedSlice();
 }
 
+/// Create a `Decompress` from `compressed` and immediately discard all output. Returns the number
+/// of discarded bytes.
+fn testDiscard(gpa: std.mem.Allocator, compressed: []const u8) !usize {
+    const buf: []u8 = try gpa.alloc(u8, default_window_len + block_size_max);
+    defer gpa.free(buf);
+
+    var in: std.Io.Reader = .fixed(compressed);
+    var zstd_stream: Decompress = .init(&in, buf, .{});
+    return try zstd_stream.reader.discardRemaining();
+}
+
 fn testExpectDecompress(uncompressed: []const u8, compressed: []const u8) !void {
     const gpa = std.testing.allocator;
     const result = try testDecompress(gpa, compressed);
@@ -117,6 +128,8 @@ test Decompress {
 
     try testExpectDecompress(uncompressed, compressed3);
     try testExpectDecompress(uncompressed, compressed19);
+    try std.testing.expectEqual(uncompressed.len, testDiscard(std.testing.allocator, compressed3));
+    try std.testing.expectEqual(uncompressed.len, testDiscard(std.testing.allocator, compressed19));
 }
 
 test "partial magic number" {
diff --git a/lib/std/compress/zstd/Decompress.zig b/lib/std/compress/zstd/Decompress.zig
index 0acef462e78d59485124ce975e94c8124dbd6b56..cab1ee99f4baf55169479eaf214363901ebd6791 100644
--- a/lib/std/compress/zstd/Decompress.zig
+++ b/lib/std/compress/zstd/Decompress.zig
@@ -123,9 +123,13 @@ fn rebaseFallible(r: *Reader, capacity: usize) Reader.RebaseError!void {
     rebase(r, capacity);
 }
 
+// Rebase the buffer, keeping at least the sliding window (`d.window_len` bytes) buffered
 fn rebase(r: *Reader, capacity: usize) void {
     const d: *Decompress = @alignCast(@fieldParentPtr("reader", r));
+    // `capacity` must fit in the buffer along with the required sliding window
     assert(capacity <= r.buffer.len - d.window_len);
+    // According to the vtable contract, this function will only be called if the free space in the
+    // buffer cannot already fit `capacity` bytes
     assert(r.end + capacity > r.buffer.len);
     const discard_n = @min(r.seek, r.end - d.window_len);
     const keep = r.buffer[discard_n..r.end];
@@ -134,11 +138,27 @@ fn rebase(r: *Reader, capacity: usize) void {
     r.seek -= discard_n;
 }
 
+/// Rebase `d.reader.buffer` as much as needed for a discard limited by `limit`
+fn rebaseForDiscard(d: *Decompress, limit: std.Io.Limit) void {
+    // Number of bytes desired to rebase, always rebase for at least block_size
+    const desire_n = limit.max(Limit.limited(zstd.block_size_max));
+    // Maximum number of bytes possible to rebase
+    const max_n = d.reader.buffer.len -| d.window_len;
+    // Number of bytes to rebase
+    const n = desire_n.minInt(max_n);
+
+    // Current buffer free space
+    const current_cap = d.reader.buffer.len - d.reader.end;
+    if (current_cap < n) {
+        rebase(&d.reader, n);
+    }
+}
+
 /// This could be improved so that when an amount is discarded that includes an
 /// entire frame, skip decoding that frame.
 fn discardDirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize {
     const d: *Decompress = @alignCast(@fieldParentPtr("reader", r));
-    rebase(r, d.window_len);
+    rebaseForDiscard(d, limit);
     var writer: Writer = .{
         .vtable = &.{
             .drain = std.Io.Writer.Discarding.drain,
@@ -162,7 +182,7 @@ fn discardDirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize {
 
 fn discardIndirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize {
     const d: *Decompress = @alignCast(@fieldParentPtr("reader", r));
-    rebase(r, d.window_len);
+    rebaseForDiscard(d, limit);
     var writer: Writer = .{
         .buffer = r.buffer,
         .end = r.end,
-- 
2.54.0


From c6538b70f5f0a5a1da8895c169c2cb9189148d85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 30 Jan 2026 23:58:47 +0100
Subject: [PATCH 087/499] llvm: handle packed structs in C ABI integer
 promotion

---
 src/codegen/llvm.zig | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 358d4ac469df1db0a3c7c8b507635f696797725e..26369d2ce98193f191a1d27fd96d58a569cc4fd3 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -12608,8 +12608,7 @@ fn ccAbiPromoteInt(cc: std.builtin.CallingConvention, zcu: *Zcu, ty: Type) ?std.
     }
     const int_info = switch (ty.zigTypeTag(zcu)) {
         .bool => Type.u1.intInfo(zcu),
-        .int, .@"enum", .error_set => ty.intInfo(zcu),
-        else => return null,
+        else => if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else return null,
     };
     return switch (target.os.tag) {
         .driverkit, .ios, .maccatalyst, .macos, .watchos, .tvos, .visionos => switch (int_info.bits) {
-- 
2.54.0


From cbe38f771c0cb7d098878e8e703ed23620f868f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 30 Jan 2026 23:58:17 +0100
Subject: [PATCH 088/499] std.Io.Threaded: consider EOPNOTSUPP to be programmer
 error in createFileMap()

Not doing so was hiding bugs (e.g. on s390x-linux).
---
 lib/std/Io/Threaded.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index f0562504fd5e4b833ed19ddea38638b0824bd5f1..918b0f43f96ce4e64f9e10311b0e4c93a5de48f3 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -16796,6 +16796,7 @@ fn createFileMap(
                 .OVERFLOW => return error.Unseekable,
                 .BADF => return errnoBug(err), // Always a race condition.
                 .INVAL => return errnoBug(err), // Invalid parameters to mmap()
+                .OPNOTSUPP => return errnoBug(err), // Bad flags with MAP.SHARED_VALIDATE on Linux.
                 else => return posix.unexpectedErrno(err),
             }
         };
-- 
2.54.0


From 7c68ab1d1085925ec33dc0f8a6695006b2d7a85d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 30 Jan 2026 23:47:42 +0100
Subject: [PATCH 089/499] std.os.linux: add MAP.DROPPABLE

Introduced in Linux 6.11.
---
 lib/std/os/linux.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index f5868f71e9af718e2464e03a9e241f95f104ae89..501ba44557b4a817d7de516795bd4ee4d3361c24 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -146,6 +146,7 @@ pub const MAP_TYPE = enum(u4) {
     SHARED = 0x01,
     PRIVATE = 0x02,
     SHARED_VALIDATE = 0x03,
+    DROPPABLE = 0x08,
 };
 
 pub const MAP = switch (native_arch) {
-- 
2.54.0


From c7c4e8d802c5c8ab2dc9d064c3985836e6677115 Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Wed, 28 Jan 2026 11:27:10 +0100
Subject: [PATCH 090/499] Sema: harden `switch` logic against undef IB

Most places where `undefined` was previously (intentionally) passed across
function calls now use `Air.Inst.Ref.none` instead to ensure that these
`undefined` references don't accidentally outlive the `switch` logic they
belong to.
---
 src/Sema.zig | 82 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 47 insertions(+), 35 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index ea2890ee6a220a0cc013f6735057f8ee27e92ed3..fc71a58f776518edf6d0dd745469bb1c1f77e1ef 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -10761,7 +10761,7 @@ fn analyzeSwitchBlock(
         const val, const ref = if (operand_is_ref)
             .{ try sema.analyzeLoad(block, src, raw_operand, operand_src), raw_operand }
         else
-            .{ raw_operand, undefined };
+            .{ raw_operand, .none };
 
         const operand_ty = sema.typeOf(val);
         const maybe_operand_opv = try sema.typeHasOnePossibleValue(operand_ty);
@@ -10785,7 +10785,7 @@ fn analyzeSwitchBlock(
                 const operand_alloc = try block.addTy(.alloc, operand_ptr_ty);
                 _ = try block.addBinOp(.store, operand_alloc, raw_operand);
                 break :alloc operand_alloc;
-            } else undefined;
+            } else .none;
             break :operand .{ .{ .loop = .{
                 .operand_alloc = operand_alloc,
                 .operand_is_ref = operand_is_ref,
@@ -10857,7 +10857,7 @@ fn analyzeSwitchBlock(
                     const new_val, const new_ref = if (operand_is_ref)
                         .{ try sema.analyzeLoad(child_block, src, new_operand, new_operand_src), new_operand }
                     else
-                        .{ new_operand, undefined };
+                        .{ new_operand, .none };
 
                     const new_cond_ref = if (union_originally)
                         try sema.unionToTag(child_block, item_ty, new_val, src)
@@ -10953,7 +10953,7 @@ fn analyzeSwitchBlock(
                                         const by_val = try sema.analyzeLoad(block, src, loaded, src);
                                         break :load_operand .{ by_val, loaded };
                                     } else {
-                                        break :load_operand .{ loaded, undefined };
+                                        break :load_operand .{ loaded, .none };
                                     }
                                 },
                             };
@@ -11393,33 +11393,31 @@ fn finishSwitchBr(
         var emit_bb = false;
         if (has_else and else_case.is_inline) {
             const else_prong_src = block.src(.{ .node_offset_switch_else_prong = src_node_offset });
-            var error_names: InternPool.NullTerminatedString.Slice = undefined;
-            var min_int: Value = undefined;
-            check_enumerable: {
+            const error_names, const min_int = check_enumerable: {
                 switch (item_ty.zigTypeTag(zcu)) {
                     .@"union" => unreachable,
                     .@"enum" => if (else_is_named_only or
                         !item_ty.isNonexhaustiveEnum(zcu) or union_originally)
                     {
                         try branch_hints.ensureUnusedCapacity(gpa, @intCast(validated_switch.seen_enum_fields.len));
-                        break :check_enumerable;
+                        break :check_enumerable .{ undefined, undefined };
                     },
                     .error_set => if (!operand_ty.isAnyError(zcu)) {
-                        error_names = item_ty.errorSetNames(zcu);
+                        const error_names = item_ty.errorSetNames(zcu);
                         try branch_hints.ensureUnusedCapacity(gpa, error_names.len);
-                        break :check_enumerable;
+                        break :check_enumerable .{ error_names, undefined };
                     },
                     .int => {
-                        min_int = try item_ty.minInt(pt, item_ty);
-                        break :check_enumerable;
+                        const min_int = try item_ty.minInt(pt, item_ty);
+                        break :check_enumerable .{ undefined, min_int };
                     },
-                    .bool, .void => break :check_enumerable,
+                    .bool, .void => break :check_enumerable .{ undefined, undefined },
                     else => {},
                 }
                 return sema.fail(block, else_prong_src, "cannot enumerate values of type '{f}' for 'inline else'", .{
                     item_ty.fmt(pt),
                 });
-            }
+            };
             var unhandled_it = validated_switch.iterateUnhandledItems(error_names, min_int);
             while (try unhandled_it.next(sema, item_ty)) |item_val| {
                 cases_len += 1;
@@ -11660,7 +11658,7 @@ fn fixupSwitchContinues(
     operand_is_ref: bool,
     item_ty: Type,
     mode: enum { normal, opv },
-    any_non_inline_capture: bool,
+    any_maybe_runtime_capture: bool,
     merges: *const Block.Merges,
 ) CompileError!void {
     const pt = sema.pt;
@@ -11686,7 +11684,7 @@ fn fixupSwitchContinues(
         assert(sema.air_instructions.items(.tag)[@intFromEnum(placeholder_inst)] == .br);
         const new_operand_maybe_ref = sema.air_instructions.items(.data)[@intFromEnum(placeholder_inst)].br.operand;
 
-        if (any_non_inline_capture and mode != .opv) {
+        if (any_maybe_runtime_capture and mode != .opv) {
             _ = try replacement_block.addBinOp(.store, operand.loop.operand_alloc, new_operand_maybe_ref);
         }
 
@@ -12431,6 +12429,8 @@ fn resolveSwitchBlock(
         }
     }
 
+    assert(zir_switch.else_case != null or under_prong != null); // switch exhaustion check wrong
+
     const else_case = validated_switch.else_case;
     const else_is_named_only = zir_switch.else_case != null and under_prong != null;
 
@@ -12507,8 +12507,8 @@ const SwitchOperand = union(enum) {
     simple: struct {
         /// The raw switch operand value. Always defined.
         by_val: Air.Inst.Ref,
-        /// The switch operand *pointer*. Defined only if there is a prong
-        /// with a by-ref capture.
+        /// The switch operand *pointer*. `none` if there are no prongs with a
+        /// by-ref capture.
         by_ref: Air.Inst.Ref,
         /// The switch condition value. For unions, `operand` is the union
         /// and `cond` is its enum tag value.
@@ -12519,7 +12519,7 @@ const SwitchOperand = union(enum) {
     loop: struct {
         /// The `alloc` containing the `switch` operand for the active dispatch.
         /// Each prong must load from this `alloc` to get captures.
-        /// If there are no captures, this may be undefined.
+        /// If there are no captures, this may be `none`.
         operand_alloc: Air.Inst.Ref,
         /// Whether `operand_alloc` contains a by-val operand or a by-ref
         /// operand.
@@ -12665,19 +12665,31 @@ fn analyzeSwitchProng(
         }
     }
 
-    const operand_val, const operand_ptr = load_operand: {
+    const need_load: bool = need_load: {
         if (capture == .none and !has_tag_capture) {
             // No need to load the operand for this prong!
-            break :load_operand .{ undefined, undefined };
+            break :need_load false;
         }
-        if (kind == .inline_ref and
-            !(capture != .none and operand_ty.zigTypeTag(zcu) == .@"union"))
-        {
-            // We only need to load the operand if there's a union payload capture
-            // since it's always runtime-known; only the tag is comptime-known here.
-            break :load_operand .{ undefined, undefined };
+        if (capture != .none and operand_ty.zigTypeTag(zcu) == .@"union") {
+            // Non-OPV union payload captures are always runtime-known.
+            break :need_load true;
+        }
+        if (kind == .inline_ref) {
+            // `inline_ref` *is* the (comptime-known) capture.
+            break :need_load false;
         }
         assert(zir_switch.any_maybe_runtime_capture); // should have caught everything else by now
+        if (capture != .by_ref and
+            kind == .item_refs and kind.item_refs.len == 1)
+        {
+            // Capture is comptime-known because it's the only prong item
+            break :need_load false;
+        }
+        break :need_load true;
+    };
+
+    const operand_val: Air.Inst.Ref, const operand_ptr: Air.Inst.Ref = load_operand: {
+        if (!need_load) break :load_operand .{ .none, .none };
         switch (operand) {
             .simple => |s| break :load_operand .{ s.by_val, s.by_ref },
             .loop => |l| {
@@ -12686,7 +12698,7 @@ fn analyzeSwitchProng(
                     const by_val = try sema.analyzeLoad(case_block, operand_src, loaded, operand_src);
                     break :load_operand .{ by_val, loaded };
                 } else {
-                    break :load_operand .{ loaded, undefined };
+                    break :load_operand .{ loaded, .none };
                 }
             },
         }
@@ -12735,7 +12747,7 @@ fn analyzeSwitchProng(
 fn analyzeSwitchTagCapture(
     sema: *Sema,
     case_block: *Block,
-    /// May be `undefined` if `inline_case_capture` is not `.none`.
+    /// May be `none` if this is an inline capture or if `kind.item_refs.len == 1`.
     operand_val: Air.Inst.Ref,
     operand_ty: Type,
     capture_src: LazySrcLoc,
@@ -12768,9 +12780,11 @@ fn analyzeSwitchPayloadCapture(
     sema: *Sema,
     case_block: *Block,
     operand: SwitchOperand,
-    /// May be `undefined` if this is an inline capture and operand is not a union.
+    /// Always has to be not-`none` if this is a union payload capture.
+    /// For non-union captures, this may be `none` if this is an inline capture
+    /// or if `kind.item_refs.len == 1` and capture is by val.
     operand_val: Air.Inst.Ref,
-    /// May be `undefined` if `capture_by_ref` is `false` or if `operand_val` is also `undefined`.
+    /// May be `none` if `capture_by_ref` is `false` or if `operand_val` is also `none`.
     operand_ptr: Air.Inst.Ref,
     operand_ty: Type,
     operand_src: LazySrcLoc,
@@ -12816,8 +12830,6 @@ fn analyzeSwitchPayloadCapture(
         }
     }
 
-    const operand_ptr_ty = if (capture_by_ref) sema.typeOf(operand_ptr) else undefined;
-
     if (kind == .special) {
         if (capture_by_ref) return operand_ptr;
         return switch (operand_ty.zigTypeTag(zcu)) {
@@ -12894,7 +12906,7 @@ fn analyzeSwitchPayloadCapture(
 
             // By-reference captures have some further restrictions which make them easier to emit
             if (capture_by_ref) {
-                const operand_ptr_info = operand_ptr_ty.ptrInfo(zcu);
+                const operand_ptr_info = sema.typeOf(operand_ptr).ptrInfo(zcu);
                 const capture_ptr_ty = resolve: {
                     // By-ref captures of hetereogeneous types are only allowed if all field
                     // pointer types are peer resolvable to each other.
@@ -13136,7 +13148,7 @@ fn analyzeSwitchPayloadCapture(
             if (case_vals.len == 1) {
                 const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, case_vals[0], undefined) catch unreachable;
                 const item_ty = try pt.singleErrorSetType(item_val.getErrorName(zcu).unwrap().?);
-                return sema.bitCast(case_block, item_ty, operand_val, operand_src, null);
+                return sema.bitCast(case_block, item_ty, .fromValue(item_val), operand_src, null);
             }
 
             var names: InferredErrorSet.NameMap = .{};
-- 
2.54.0


From cb7be96644819e2e903c191e712d33b22f30a52a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 20 Jan 2026 17:05:14 -0800
Subject: [PATCH 091/499] std.Io: give File a nonblocking bit on Windows

This tracks whether it is a file opened in synchronous mode, or
something that supports APC.

This will be needed in order to know whether concurrent batch operations
on the file should return error.ConcurrencyUnavailable, or use APC to
complete the batch.

This patch also switches to using NtCreateFile directly in
std.Io.Threaded for dirCreateFile, as well as NtReadFile for
fileReadStreaming, making it handle files opened in synchronous mode as
well as files opened in asynchronous mode.
---
 lib/std/Io/File.zig          |  15 +++++
 lib/std/Io/Threaded.zig      | 123 +++++++++++++++++++++++------------
 lib/std/Progress.zig         |   1 +
 lib/std/os/windows/ntdll.zig |   2 +-
 4 files changed, 100 insertions(+), 41 deletions(-)

diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index e537755a3365de8bab78d79fb55a40da0c33fe03..d0f487b911a4f37474d0dfc18925f6021ceda6c3 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -10,8 +10,20 @@ const assert = std.debug.assert;
 const Dir = std.Io.Dir;
 
 handle: Handle,
+flags: Flags = .{},
 
 pub const Handle = std.posix.fd_t;
+pub const Flags = switch (native_os) {
+    .windows => packed struct(u1) {
+        /// * true: opened with MODE.IO.ASYNCHRONOUS
+        /// * false: opened with SYNCHRONOUS_ALERT or SYNCHRONOUS_NONALERT, or
+        ///   not a file.
+        /// This is default-initialized to false as a workaround for
+        /// https://codeberg.org/ziglang/zig/issues/30842
+        nonblocking: bool = false,
+    },
+    else => packed struct(u0) {},
+};
 
 pub const Reader = @import("File/Reader.zig");
 pub const Writer = @import("File/Writer.zig");
@@ -77,6 +89,7 @@ pub fn stdout() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdOutput,
+            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDOUT_FILENO,
@@ -88,6 +101,7 @@ pub fn stderr() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdError,
+            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDERR_FILENO,
@@ -99,6 +113,7 @@ pub fn stdin() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdInput,
+            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDIN_FILENO,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index f0562504fd5e4b833ed19ddea38638b0824bd5f1..cdbb0fd18291dd7ea75fbd229969573cd161eed0 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1173,6 +1173,11 @@ const Syscall = struct {
             .blocked_canceling => return error.Canceled, // new status is `.canceled`
         }
     }
+    fn toApc(s: Syscall) Io.Cancelable!void {
+        // TODO set state to indicate instead of NtCancelSynchronousIoFile we
+        // need to use NtCancelIoFileEx
+        return s.checkCancel();
+    }
     /// Marks this syscall as finished.
     fn finish(s: Syscall) void {
         const thread = s.thread orelse return;
@@ -2759,7 +2764,12 @@ fn dirCreateDirPathOpenWasi(
 
 fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const file: File = .{ .handle = dir.handle };
+    const file: File = if (is_windows) .{
+        .handle = dir.handle,
+        .flags = .{ .nonblocking = false },
+    } else .{
+        .handle = dir.handle,
+    };
     return fileStat(t, file);
 }
 
@@ -3682,7 +3692,10 @@ fn dirCreateFileWindows(
     errdefer windows.CloseHandle(handle);
 
     const exclusive = switch (flags.lock) {
-        .none => return .{ .handle = handle },
+        .none => return .{
+            .handle = handle,
+            .flags = .{ .nonblocking = false },
+        },
         .shared => false,
         .exclusive => true,
     };
@@ -3702,7 +3715,10 @@ fn dirCreateFileWindows(
     )) {
         .SUCCESS => {
             syscall.finish();
-            return .{ .handle = handle };
+            return .{
+                .handle = handle,
+                .flags = .{ .nonblocking = false },
+            };
         },
         .INSUFFICIENT_RESOURCES => return syscall.fail(error.SystemResources),
         .LOCK_NOT_GRANTED => return syscall.fail(error.WouldBlock),
@@ -4273,7 +4289,10 @@ pub fn dirOpenFileWtf16(
     errdefer w.CloseHandle(handle);
 
     const exclusive = switch (flags.lock) {
-        .none => return .{ .handle = handle },
+        .none => return .{
+            .handle = handle,
+            .flags = .{ .nonblocking = false },
+        },
         .shared => false,
         .exclusive => true,
     };
@@ -4296,7 +4315,10 @@ pub fn dirOpenFileWtf16(
         .ACCESS_VIOLATION => |err| return syscall.ntstatusBug(err), // bad io_status_block pointer
         else => |status| return syscall.unexpectedNtstatus(status),
     };
-    return .{ .handle = handle };
+    return .{
+        .handle = handle,
+        .flags = .{ .nonblocking = false },
+    };
 }
 
 fn dirOpenFileWasi(
@@ -8365,46 +8387,66 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.Reader.Error!usiz
 }
 
 fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!usize {
-    const DWORD = windows.DWORD;
     var index: usize = 0;
     while (index < data.len and data[index].len == 0) index += 1;
     if (index == data.len) return 0;
     const buffer = data[index];
-    const want_read_count: DWORD = @min(std.math.maxInt(DWORD), buffer.len);
 
-    const syscall: Syscall = try .start();
-    while (true) {
-        var n: DWORD = undefined;
-        if (windows.kernel32.ReadFile(file.handle, buffer.ptr, want_read_count, &n, null) != 0) {
-            syscall.finish();
-            return n;
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+
+    read: {
+        const syscall: Syscall = try .start();
+        while (true) {
+            switch (windows.ntdll.NtReadFile(
+                file.handle,
+                null, // event
+                noopApc, // apc callback
+                null, // apc context
+                &io_status_block,
+                buffer.ptr,
+                @min(std.math.maxInt(u32), buffer.len),
+                null, // byte offset
+                null, // key
+            )) {
+                .SUCCESS => break :read syscall.finish(),
+                .PENDING => break,
+                .CANCELLED => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // wrong value for flags.nonblocking
+                else => |status| return syscall.unexpectedNtstatus(status),
+            }
         }
-        switch (windows.GetLastError()) {
-            .IO_PENDING => |err| {
-                syscall.finish();
-                return windows.errorBug(err);
-            },
-            .OPERATION_ABORTED => {
-                try syscall.checkCancel();
-                continue;
-            },
-            .BROKEN_PIPE, .HANDLE_EOF => {
-                syscall.finish();
-                return 0;
-            },
-            .NETNAME_DELETED => if (is_debug) unreachable else return error.Unexpected,
-            .LOCK_VIOLATION => return syscall.fail(error.LockViolation),
-            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-            .INVALID_HANDLE => if (is_debug) unreachable else return error.Unexpected,
-            // TODO: Determine if INVALID_FUNCTION is possible in more scenarios than just passing
-            // a handle to a directory.
-            .INVALID_FUNCTION => return syscall.fail(error.IsDir),
-            else => |err| {
-                syscall.finish();
-                return windows.unexpectedError(err);
-            },
+        try syscall.toApc();
+        while (true) {
+            switch (windows.ntdll.NtDelayExecution(1, null)) {
+                .USER_APC => break syscall.finish(),
+                .SUCCESS, .CANCELLED => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                else => |status| return syscall.unexpectedNtstatus(status),
+            }
         }
     }
+
+    switch (io_status_block.u.Status) {
+        .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {},
+        .ACCESS_DENIED => return error.AccessDenied,
+        else => |status| return windows.unexpectedStatus(status),
+    }
+    return io_status_block.Information;
+}
+
+fn noopApc(
+    apc_context: ?*anyopaque,
+    io_status_block: *windows.IO_STATUS_BLOCK,
+    unused: windows.ULONG,
+) callconv(.winapi) void {
+    _ = apc_context;
+    _ = io_status_block;
+    _ = unused;
 }
 
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
@@ -14560,9 +14602,9 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     return .{
         .id = piProcInfo.hProcess,
         .thread_handle = piProcInfo.hThread,
-        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h } else null,
-        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h } else null,
-        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h } else null,
+        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
+        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
+        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
         .request_resource_usage_statistics = options.request_resource_usage_statistics,
     };
 }
@@ -15696,6 +15738,7 @@ fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
             .pointer => @ptrFromInt(int),
             else => return error.UnsupportedOperation,
         },
+        .flags = if (is_windows) .{ .nonblocking = true } else .{},
     };
 }
 
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 5ccc46778b43d0260ee1a6323e13eae20e31a2c9..5da61110796cd72016782b78ae7b83561ec0083d 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -979,6 +979,7 @@ fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buff
         if (main_parent == .unused) continue;
         const file: Io.File = .{
             .handle = main_storage.getIpcFd() orelse continue,
+            .flags = if (is_windows) .{ .nonblocking = true } else .{},
         };
         const opt_saved_metadata = findOld(file.handle, old_ipc_metadata_fds, old_ipc_metadata);
         var bytes_read: usize = 0;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index f61cbbf5b8fe8bc468ad2f93638ca60503c54ed2..774ca28f19064bc66ad96840aa3114e9fb039cee 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -596,7 +596,7 @@ pub extern "ntdll" fn NtCancelSynchronousIoFile(
 
 pub extern "ntdll" fn NtDelayExecution(
     Alertable: BOOLEAN,
-    DelayInterval: *const LARGE_INTEGER,
+    DelayInterval: ?*const LARGE_INTEGER,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtCancelIoFileEx(
-- 
2.54.0


From 8827488fcd556e6e95d97e838f781e6141ebde8c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 21 Jan 2026 19:08:52 -0800
Subject: [PATCH 092/499] std: back out the flags field of Io.File

For now, let us refrain from putting the sync mode into the Io.File
struct, and document that to do concurrent batch operations, any Windows
file handles must be in asynchronous mode. The consequences for
violating this requirement is neither illegal behavior, nor an error,
but that concurrency is lost. In other words, deadlock might occur. This
prevents the addition of flags field.

partial revert of 2faf14200f58ee72ec3a13e894d765f59e6483a9
---
 lib/std/Io/File.zig     | 15 ---------------
 lib/std/Io/Threaded.zig | 36 +++++++++---------------------------
 lib/std/Progress.zig    |  1 -
 3 files changed, 9 insertions(+), 43 deletions(-)

diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index d0f487b911a4f37474d0dfc18925f6021ceda6c3..e537755a3365de8bab78d79fb55a40da0c33fe03 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -10,20 +10,8 @@ const assert = std.debug.assert;
 const Dir = std.Io.Dir;
 
 handle: Handle,
-flags: Flags = .{},
 
 pub const Handle = std.posix.fd_t;
-pub const Flags = switch (native_os) {
-    .windows => packed struct(u1) {
-        /// * true: opened with MODE.IO.ASYNCHRONOUS
-        /// * false: opened with SYNCHRONOUS_ALERT or SYNCHRONOUS_NONALERT, or
-        ///   not a file.
-        /// This is default-initialized to false as a workaround for
-        /// https://codeberg.org/ziglang/zig/issues/30842
-        nonblocking: bool = false,
-    },
-    else => packed struct(u0) {},
-};
 
 pub const Reader = @import("File/Reader.zig");
 pub const Writer = @import("File/Writer.zig");
@@ -89,7 +77,6 @@ pub fn stdout() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdOutput,
-            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDOUT_FILENO,
@@ -101,7 +88,6 @@ pub fn stderr() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdError,
-            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDERR_FILENO,
@@ -113,7 +99,6 @@ pub fn stdin() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdInput,
-            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDIN_FILENO,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index cdbb0fd18291dd7ea75fbd229969573cd161eed0..1a2ca61c00eea211c1f4998325d7f1c6d3b7cd2b 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2764,12 +2764,7 @@ fn dirCreateDirPathOpenWasi(
 
 fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const file: File = if (is_windows) .{
-        .handle = dir.handle,
-        .flags = .{ .nonblocking = false },
-    } else .{
-        .handle = dir.handle,
-    };
+    const file: File = .{ .handle = dir.handle };
     return fileStat(t, file);
 }
 
@@ -3692,10 +3687,7 @@ fn dirCreateFileWindows(
     errdefer windows.CloseHandle(handle);
 
     const exclusive = switch (flags.lock) {
-        .none => return .{
-            .handle = handle,
-            .flags = .{ .nonblocking = false },
-        },
+        .none => return .{ .handle = handle },
         .shared => false,
         .exclusive => true,
     };
@@ -3715,10 +3707,7 @@ fn dirCreateFileWindows(
     )) {
         .SUCCESS => {
             syscall.finish();
-            return .{
-                .handle = handle,
-                .flags = .{ .nonblocking = false },
-            };
+            return .{ .handle = handle };
         },
         .INSUFFICIENT_RESOURCES => return syscall.fail(error.SystemResources),
         .LOCK_NOT_GRANTED => return syscall.fail(error.WouldBlock),
@@ -4289,10 +4278,7 @@ pub fn dirOpenFileWtf16(
     errdefer w.CloseHandle(handle);
 
     const exclusive = switch (flags.lock) {
-        .none => return .{
-            .handle = handle,
-            .flags = .{ .nonblocking = false },
-        },
+        .none => return .{ .handle = handle },
         .shared => false,
         .exclusive => true,
     };
@@ -4315,10 +4301,7 @@ pub fn dirOpenFileWtf16(
         .ACCESS_VIOLATION => |err| return syscall.ntstatusBug(err), // bad io_status_block pointer
         else => |status| return syscall.unexpectedNtstatus(status),
     };
-    return .{
-        .handle = handle,
-        .flags = .{ .nonblocking = false },
-    };
+    return .{ .handle = handle };
 }
 
 fn dirOpenFileWasi(
@@ -8414,7 +8397,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                     try syscall.checkCancel();
                     continue;
                 },
-                .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // wrong value for flags.nonblocking
+                .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
                 else => |status| return syscall.unexpectedNtstatus(status),
             }
         }
@@ -14602,9 +14585,9 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     return .{
         .id = piProcInfo.hProcess,
         .thread_handle = piProcInfo.hThread,
-        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
-        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
-        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
+        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h } else null,
+        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h } else null,
+        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h } else null,
         .request_resource_usage_statistics = options.request_resource_usage_statistics,
     };
 }
@@ -15738,7 +15721,6 @@ fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
             .pointer => @ptrFromInt(int),
             else => return error.UnsupportedOperation,
         },
-        .flags = if (is_windows) .{ .nonblocking = true } else .{},
     };
 }
 
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 5da61110796cd72016782b78ae7b83561ec0083d..5ccc46778b43d0260ee1a6323e13eae20e31a2c9 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -979,7 +979,6 @@ fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buff
         if (main_parent == .unused) continue;
         const file: Io.File = .{
             .handle = main_storage.getIpcFd() orelse continue,
-            .flags = if (is_windows) .{ .nonblocking = true } else .{},
         };
         const opt_saved_metadata = findOld(file.handle, old_ipc_metadata_fds, old_ipc_metadata);
         var bytes_read: usize = 0;
-- 
2.54.0


From 558025759632806c9d5b22b5a88d2cc4165c7fac Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 21 Jan 2026 19:16:35 -0800
Subject: [PATCH 093/499] std.Io.Threaded: add some temporary, choice panics

---
 lib/std/Io/Threaded.zig | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1a2ca61c00eea211c1f4998325d7f1c6d3b7cd2b..7a04d23e5436289e2477a77d1b355db375a5325d 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8398,7 +8398,8 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                     continue;
                 },
                 .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
-                else => |status| return syscall.unexpectedNtstatus(status),
+                else => |status| std.debug.panic("fileReadStreamingWindows NtReadFile returned {t}", .{status}),
+                //else => |status| return syscall.unexpectedNtstatus(status),
             }
         }
         try syscall.toApc();
@@ -8409,7 +8410,8 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                     try syscall.checkCancel();
                     continue;
                 },
-                else => |status| return syscall.unexpectedNtstatus(status),
+                else => |status| std.debug.panic("fileReadStreamingWindows NtDelayExecution returned {t}", .{status}),
+                //else => |status| return syscall.unexpectedNtstatus(status),
             }
         }
     }
@@ -8417,7 +8419,8 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
     switch (io_status_block.u.Status) {
         .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {},
         .ACCESS_DENIED => return error.AccessDenied,
-        else => |status| return windows.unexpectedStatus(status),
+        else => |status| std.debug.panic("fileReadStreamingWindows IO_STATUS_BLOCK returned {t}", .{status}),
+        //else => |status| return windows.unexpectedStatus(status),
     }
     return io_status_block.Information;
 }
-- 
2.54.0


From 1e3072ec4664200934c13adf8452de490130a00f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 21 Jan 2026 21:05:15 -0800
Subject: [PATCH 094/499] std.Io.Threaded: introduce Thread.InterruptMethod

implements APC cancelation except for the actual call to NtCancelIoFileEx
---
 lib/std/Io/Threaded.zig | 241 +++++++++++++++++++++++++---------------
 1 file changed, 149 insertions(+), 92 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 7a04d23e5436289e2477a77d1b355db375a5325d..a02ccb826811063d3ee34c2914644478422b3f69 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -339,8 +339,8 @@ const Group = struct {
                 .canceled => true,
                 .parked => unreachable,
                 .blocked => unreachable,
-                .blocked_alertable => unreachable,
-                .blocked_alertable_canceling => unreachable,
+                .blocked_apc => unreachable,
+                .blocked_windows_dns => unreachable,
                 .blocked_canceling => unreachable,
             };
             if (result) {
@@ -379,7 +379,10 @@ const Group = struct {
         while (it) |thread| : (it = thread.next) {
             // This non-mutating RMW exists for ordering reasons: see comment in `Group.Task.start` for reasons.
             _ = thread.status.fetchOr(.{ .cancelation = @enumFromInt(0), .awaitable = .null }, .release);
-            if (thread.cancelAwaitable(.fromGroup(g.ptr))) any_blocked = true;
+            if (thread.cancelAwaitable(.fromGroup(g.ptr))) |method| {
+                thread.interrupt_method = method;
+                any_blocked = true;
+            }
         }
         return any_blocked;
     }
@@ -391,7 +394,7 @@ const Group = struct {
         var any_signaled = false;
         var it = t.worker_threads.load(.acquire); // acquire `Thread` values
         while (it) |thread| : (it = thread.next) {
-            if (thread.signalCanceledSyscall(t, .fromGroup(g.ptr))) any_signaled = true;
+            if (thread.signalCanceledSyscall(t, .fromGroup(g.ptr), thread.interrupt_method)) any_signaled = true;
         }
         return any_signaled;
     }
@@ -543,8 +546,8 @@ const Future = struct {
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .blocked_canceling => unreachable,
         };
         thread.status.store(.{ .cancelation = .none, .awaitable = .null }, .monotonic);
@@ -573,11 +576,15 @@ const Future = struct {
         num_completed: *std.atomic.Value(u32),
         thread: ?*Thread,
     ) void {
-        var need_signal: bool = if (thread) |th| th.cancelAwaitable(.fromFuture(future)) else false;
+        var interrupt_method: ?Thread.InterruptMethod =
+            if (thread) |th| th.cancelAwaitable(.fromFuture(future)) else null;
         var timeout_ns: u64 = 1 << 10;
         while (true) {
-            need_signal = need_signal and thread.?.signalCanceledSyscall(t, .fromFuture(future));
-            Thread.futexWaitUncancelable(&num_completed.raw, 0, if (need_signal) timeout_ns else null);
+            if (interrupt_method) |method| {
+                if (!thread.?.signalCanceledSyscall(t, .fromFuture(future), method))
+                    interrupt_method = null;
+            }
+            Thread.futexWaitUncancelable(&num_completed.raw, 0, if (interrupt_method != null) timeout_ns else null);
             switch (num_completed.load(.acquire)) { // acquire task results
                 0 => {},
                 1 => break,
@@ -625,6 +632,9 @@ const Thread = struct {
     cancel_protection: Io.CancelProtection,
     /// Always released when `Status.cancelation` is set to `.parked`.
     futex_waiter: if (use_parking_futex) ?*parking_futex.Waiter else ?noreturn,
+    apc_context: if (is_windows) ?*anyopaque else void,
+    /// Used only by group cancelation code for temporary storage.
+    interrupt_method: InterruptMethod,
 
     csprng: Csprng,
 
@@ -652,11 +662,13 @@ const Thread = struct {
             /// To request cancelation, set the status to `.blocked_canceling` and repeatedly interrupt the system call until the status changes.
             blocked = 0b011,
 
-            /// Windows-only: the thread is blocked in an alertable wait via
-            /// `NtDelayExecution`. To request cancelation, set the status to
-            /// `blocked_alertable_canceling` and repeatedly alert the thread
-            /// until the status changes.
-            blocked_alertable = 0b010,
+            /// Windows-only: the thread is blocked in a call to `NtDelayExecution`.
+            /// To request cancelation, set the status to `.canceling` and call `NtCancelIoFileEx`.
+            blocked_apc = 0b100,
+
+            /// Windows-only: the thread is blocked in a call to `GetAddrInfoExW`.
+            /// To request cancelation, set the status to `.canceling` and call `GetAddrInfoExCancel`.
+            blocked_windows_dns = 0b010,
 
             /// The thread has an outstanding cancelation request but is not in a cancelable operation.
             /// When it acknowledges the cancelation, it will set the status to `.canceled`.
@@ -705,8 +717,8 @@ const Thread = struct {
         switch (status.cancelation) {
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .blocked_canceling => unreachable,
             .none, .canceled => {},
             .canceling => {
@@ -986,17 +998,17 @@ const Thread = struct {
     /// It is possible that `thread` gets canceled by this function, but is blocked in a syscall. In
     /// that case, the thread may need to be sent a signal to interrupt the call. This function will
     /// return `true` to indicate this, in which case the caller must call `signalCanceledSyscall`.
-    fn cancelAwaitable(thread: *Thread, awaitable: AwaitableId) bool {
+    fn cancelAwaitable(thread: *Thread, awaitable: AwaitableId) ?InterruptMethod {
         var status = thread.status.load(.monotonic);
         while (true) {
-            if (status.awaitable != awaitable) return false; // thread is working on something else
+            if (status.awaitable != awaitable) return null; // thread is working on something else
             status = switch (status.cancelation) {
                 .none => thread.status.cmpxchgWeak(
                     .{ .cancelation = .none, .awaitable = awaitable },
                     .{ .cancelation = .canceling, .awaitable = awaitable },
                     .monotonic,
                     .monotonic,
-                ) orelse return false,
+                ) orelse return null,
 
                 .parked => thread.status.cmpxchgWeak(
                     .{ .cancelation = .parked, .awaitable = awaitable },
@@ -1009,7 +1021,7 @@ const Thread = struct {
                         parking_futex.removeCanceledWaiter(futex_waiter);
                     }
                     unpark(&.{thread.id}, null);
-                    return false;
+                    return null;
                 },
 
                 .blocked => thread.status.cmpxchgWeak(
@@ -1017,7 +1029,17 @@ const Thread = struct {
                     .{ .cancelation = .blocked_canceling, .awaitable = awaitable },
                     .monotonic,
                     .monotonic,
-                ) orelse return true,
+                ) orelse return .sync,
+
+                .blocked_apc => thread.status.cmpxchgWeak(
+                    .{ .cancelation = .blocked_apc, .awaitable = awaitable },
+                    .{ .cancelation = .canceling, .awaitable = awaitable },
+                    .monotonic,
+                    .monotonic,
+                ) orelse {
+                    if (!is_windows) unreachable;
+                    return .apc;
+                },
 
                 .blocked_alertable => thread.status.cmpxchgWeak(
                     .{ .cancelation = .blocked_alertable, .awaitable = awaitable },
@@ -1026,14 +1048,14 @@ const Thread = struct {
                     .monotonic,
                 ) orelse {
                     if (!is_windows) unreachable;
-                    return true;
+                    return .dns;
                 },
 
                 .canceling, .canceled => {
                     // This can happen when the task start raced with the cancelation, so the thread
                     // saw the cancelation on the future/group *and* we are trying to signal the
                     // thread here.
-                    return false;
+                    return null;
                 },
 
                 .blocked_canceling => unreachable, // `awaitable` has not been canceled before now
@@ -1042,6 +1064,11 @@ const Thread = struct {
         }
     }
 
+    const InterruptMethod = switch (native_os) {
+        .windows => enum { sync, dns, apc },
+        else => enum { sync },
+    };
+
     /// Sends a signal to `thread` if it is still blocked in a syscall (i.e. has not yet observed
     /// the cancelation request from `cancelAwaitable`).
     ///
@@ -1051,24 +1078,21 @@ const Thread = struct {
     /// the thread is still blocked. For the implementation, `Future.waitForCancelWithSignaling` and
     /// `Group.waitForCancelWithSignaling`: they use exponential backoff starting at a 1us delay and
     /// doubling each call. In practice, it is rare to send more than one signal.
-    fn signalCanceledSyscall(thread: *Thread, t: *Threaded, awaitable: AwaitableId) bool {
-        const status = thread.status.load(.monotonic);
-        if (status.awaitable != awaitable) {
-            // The thread has moved on and is working on something totally different.
-            return false;
-        }
+    fn signalCanceledSyscall(thread: *Thread, t: *Threaded, awaitable: AwaitableId, method: InterruptMethod) bool {
+        const bad_status: Status = .{ .cancelation = .blocked_canceling, .awaitable = awaitable };
+        if (thread.status.load(.monotonic) != bad_status) return false;
 
         // The thread ID and/or handle can be read non-atomically because they never change and were
         // released by the store that made `thread` available to us.
 
-        switch (status.cancelation) {
-            .blocked_canceling => if (std.Thread.use_pthreads) {
-                return switch (std.c.pthread_kill(thread.handle, .IO)) {
-                    0 => true,
-                    else => false,
-                };
-            } else switch (native_os) {
-                .linux => {
+        if (std.Thread.use_pthreads) switch (method) {
+            .sync => return switch (std.c.pthread_kill(thread.handle, .IO)) {
+                0 => true,
+                else => false,
+            },
+        } else switch (native_os) {
+            .linux => switch (method) {
+                .sync => {
                     const pid: posix.pid_t = pid: {
                         const cached_pid = @atomicLoad(Pid, &t.pid, .monotonic);
                         if (cached_pid != .unknown) break :pid @intFromEnum(cached_pid);
@@ -1081,7 +1105,9 @@ const Thread = struct {
                         else => false,
                     };
                 },
-                .windows => {
+            },
+            .windows => switch (method) {
+                .sync => {
                     var iosb: windows.IO_STATUS_BLOCK = undefined;
                     return switch (windows.ntdll.NtCancelSynchronousIoFile(thread.handle, null, &iosb)) {
                         .NOT_FOUND => true, // this might mean the operation hasn't started yet
@@ -1089,15 +1115,8 @@ const Thread = struct {
                         else => false,
                     };
                 },
-                else => return false,
-            },
-
-            .blocked_alertable_canceling => {
-                if (!is_windows) unreachable;
-                return switch (windows.ntdll.NtAlertThread(thread.handle)) {
-                    .SUCCESS => true,
-                    else => false,
-                };
+                .dns => @panic("TODO call GetAddrInfoExCancel"),
+                .apc => @panic("TODO call NtCancelIoFileEx"),
             },
 
             else => {
@@ -1145,8 +1164,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .blocked_canceling => unreachable,
             .none => return .{ .thread = thread }, // new status is `.blocked`
             .canceling => return error.Canceled, // new status is `.canceled`
@@ -1165,19 +1184,14 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
             .blocked => {}, // new status is `.blocked` (unchanged)
             .blocked_canceling => return error.Canceled, // new status is `.canceled`
         }
     }
-    fn toApc(s: Syscall) Io.Cancelable!void {
-        // TODO set state to indicate instead of NtCancelSynchronousIoFile we
-        // need to use NtCancelIoFileEx
-        return s.checkCancel();
-    }
     /// Marks this syscall as finished.
     fn finish(s: Syscall) void {
         const thread = s.thread orelse return;
@@ -1187,8 +1201,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
             .blocked => {}, // new status is `.none`
@@ -1196,25 +1210,25 @@ const Syscall = struct {
         }
     }
     /// Indicates instead of `NtCancelSynchronousIoFile` we need to use
-    /// `NtAlertThread` to interrupt the wait.
+    /// `NtCancelIoFileEx` to interrupt the wait.
     ///
     /// Windows only, called from blocked state only.
-    fn toAlertable(s: Syscall) Io.Cancelable!AlertableSyscall {
-        comptime assert(is_windows);
-        const thread = s.thread orelse return .{ .thread = null };
+    fn toApc(s: Syscall, apc_context: ?*anyopaque) Io.Cancelable!void {
+        const thread = s.thread orelse return;
+        thread.apc_context = apc_context;
         var prev = thread.status.load(.monotonic);
         while (true) prev = switch (prev.cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
 
             .blocked => thread.status.cmpxchgWeak(prev, .{
-                .cancelation = .blocked_alertable,
+                .cancelation = .blocked_apc,
                 .awaitable = prev.awaitable,
-            }, .monotonic, .monotonic) orelse return .{ .thread = thread },
+            }, .monotonic, .monotonic) orelse return,
 
             .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
                 .cancelation = .canceled,
@@ -1222,6 +1236,45 @@ const Syscall = struct {
             }, .monotonic, .monotonic) orelse return error.Canceled,
         };
     }
+    /// Windows only, called from blocked_apc state only.
+    fn checkCancelApc(s: Syscall) Io.Cancelable!void {
+        const thread = s.thread orelse return;
+        var prev = thread.status.load(.monotonic);
+        while (true) prev = switch (prev.cancelation) {
+            .none => unreachable,
+            .parked => unreachable,
+            .blocked_windows_dns => unreachable,
+            .blocked => unreachable,
+            .canceling => unreachable,
+            .canceled => unreachable,
+            .blocked_apc => return,
+            .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
+                .cancelation = .canceled,
+                .awaitable = prev.awaitable,
+            }, .monotonic, .monotonic) orelse return error.Canceled,
+        };
+    }
+    /// Windows only, called from blocked_apc state only.
+    fn finishApc(s: Syscall) void {
+        const thread = s.thread orelse return;
+        var prev = thread.status.load(.monotonic);
+        while (true) prev = switch (prev.cancelation) {
+            .none => unreachable,
+            .parked => unreachable,
+            .blocked_windows_dns => unreachable,
+            .blocked => unreachable,
+            .canceling => unreachable,
+            .canceled => unreachable,
+            .blocked_apc => thread.status.cmpxchgWeak(prev, .{
+                .cancelation = .none,
+                .awaitable = prev.awaitable,
+            }, .monotonic, .monotonic) orelse return,
+            .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
+                .cancelation = .canceling,
+                .awaitable = prev.awaitable,
+            }, .monotonic, .monotonic) orelse return,
+        };
+    }
     /// Convenience wrapper which calls `finish`, then returns `err`.
     fn fail(s: Syscall, err: anytype) @TypeOf(err) {
         s.finish();
@@ -1501,6 +1554,8 @@ fn worker(t: *Threaded) void {
         .cancel_protection = .unblocked,
         .futex_waiter = undefined,
         .csprng = .{},
+        .apc_context = undefined,
+        .interrupt_method = undefined,
     };
     Thread.current = &thread;
 
@@ -2109,8 +2164,8 @@ fn groupAsyncEager(
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .blocked_canceling => unreachable,
         };
     } else false;
@@ -2121,8 +2176,8 @@ fn groupAsyncEager(
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
+            .blocked_apc => unreachable,
+            .blocked_windows_dns => unreachable,
             .blocked_canceling => unreachable,
         };
     } else false;
@@ -2301,8 +2356,8 @@ fn recancelInner() void {
         .canceling => unreachable, // called `recancel` but cancelation was already pending
         .parked => unreachable,
         .blocked => unreachable,
-        .blocked_alertable => unreachable,
-        .blocked_alertable_canceling => unreachable,
+        .blocked_apc => unreachable,
+        .blocked_windows_dns => unreachable,
         .blocked_canceling => unreachable,
     }
 }
@@ -8376,6 +8431,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
     const buffer = data[index];
 
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+    var done: bool = false;
 
     read: {
         const syscall: Syscall = try .start();
@@ -8383,8 +8439,8 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
             switch (windows.ntdll.NtReadFile(
                 file.handle,
                 null, // event
-                noopApc, // apc callback
-                null, // apc context
+                flagApc, // apc callback
+                &done, // apc context
                 &io_status_block,
                 buffer.ptr,
                 @min(std.math.maxInt(u32), buffer.len),
@@ -8402,12 +8458,12 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                 //else => |status| return syscall.unexpectedNtstatus(status),
             }
         }
-        try syscall.toApc();
+        try syscall.toApc(&done);
         while (true) {
             switch (windows.ntdll.NtDelayExecution(1, null)) {
-                .USER_APC => break syscall.finish(),
+                .USER_APC => break syscall.finishApc(),
                 .SUCCESS, .CANCELLED => {
-                    try syscall.checkCancel();
+                    try syscall.checkCancelApc();
                     continue;
                 },
                 else => |status| std.debug.panic("fileReadStreamingWindows NtDelayExecution returned {t}", .{status}),
@@ -8425,12 +8481,13 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
     return io_status_block.Information;
 }
 
-fn noopApc(
+fn flagApc(
     apc_context: ?*anyopaque,
     io_status_block: *windows.IO_STATUS_BLOCK,
     unused: windows.ULONG,
 ) callconv(.winapi) void {
-    _ = apc_context;
+    const flag: *bool = @ptrCast(apc_context);
+    flag.* = true;
     _ = io_status_block;
     _ = unused;
 }
@@ -12442,7 +12499,7 @@ fn netLookupFallible(
         var res: *ws2_32.ADDRINFOEXW = undefined;
         const timeout: ?*ws2_32.timeval = null;
         while (true) {
-            // TODO: hook this up to cancelation with `NtDelayExecution` and APC callbacks.
+            // TODO: hook this up to cancelation with `Thread.Status.cancelation.blocked_windows_dns`.
             try Thread.checkCancel();
             // TODO make this append to the queue eagerly rather than blocking until the whole thing finishes
             const rc: ws2_32.WinsockError = @enumFromInt(ws2_32.GetAddrInfoExW(name_w, port_w, .DNS, null, &hints, &res, timeout, null, null, null));
@@ -16176,8 +16233,8 @@ const parking_futex = struct {
                         .canceled => break :cancelable, // status is still `.canceled`
                         .parked => unreachable,
                         .blocked => unreachable,
-                        .blocked_alertable => unreachable,
-                        .blocked_alertable_canceling => unreachable,
+                        .blocked_apc => unreachable,
+                        .blocked_windows_dns => unreachable,
                         .blocked_canceling => unreachable,
                     }
                     // We could now be unparked for a cancelation at any time!
@@ -16228,8 +16285,8 @@ const parking_futex = struct {
                 },
                 .canceled => unreachable,
                 .blocked => unreachable,
-                .blocked_alertable => unreachable,
-                .blocked_alertable_canceling => unreachable,
+                .blocked_apc => unreachable,
+                .blocked_windows_dns => unreachable,
                 .blocked_canceling => unreachable,
             },
         }
@@ -16270,8 +16327,8 @@ const parking_futex = struct {
                     .canceling => continue, // race with a canceler who hasn't called `removeCanceledWaiter` yet
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_alertable => unreachable,
-                    .blocked_alertable_canceling => unreachable,
+                    .blocked_apc => unreachable,
+                    .blocked_windows_dns => unreachable,
                     .blocked_canceling => unreachable,
                 }
                 // We're waking this waiter. Remove them from the bucket and add them to our local list.
@@ -16337,8 +16394,8 @@ const parking_sleep = struct {
                 .canceled => break :cancelable, // status is still `.canceled`
                 .parked => unreachable,
                 .blocked => unreachable,
-                .blocked_alertable => unreachable,
-                .blocked_alertable_canceling => unreachable,
+                .blocked_apc => unreachable,
+                .blocked_windows_dns => unreachable,
                 .blocked_canceling => unreachable,
             }
             while (park(deadline, null)) {
@@ -16356,8 +16413,8 @@ const parking_sleep = struct {
                     .none => unreachable,
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_alertable => unreachable,
-                    .blocked_alertable_canceling => unreachable,
+                    .blocked_apc => unreachable,
+                    .blocked_windows_dns => unreachable,
                     .blocked_canceling => unreachable,
                 }
             } else |err| switch (err) {
@@ -16376,8 +16433,8 @@ const parking_sleep = struct {
                     .none => unreachable,
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_alertable => unreachable,
-                    .blocked_alertable_canceling => unreachable,
+                    .blocked_apc => unreachable,
+                    .blocked_windows_dns => unreachable,
                     .blocked_canceling => unreachable,
                 },
             }
-- 
2.54.0


From e705ad83028b339314fa668ec04d57987ca73e87 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 21 Jan 2026 21:28:15 -0800
Subject: [PATCH 095/499] std.Io.Threaded: implement APC cancelation

specifically the call to NtCancelIoFileEx
---
 lib/std/Io/Threaded.zig      | 33 ++++++++++++++++++++++++++-------
 lib/std/os/windows/ntdll.zig |  6 +++---
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index a02ccb826811063d3ee34c2914644478422b3f69..08d67a69975d0e63c3ff0ff9571fcc4d2d86d3ce 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -632,12 +632,17 @@ const Thread = struct {
     cancel_protection: Io.CancelProtection,
     /// Always released when `Status.cancelation` is set to `.parked`.
     futex_waiter: if (use_parking_futex) ?*parking_futex.Waiter else ?noreturn,
-    apc_context: if (is_windows) ?*anyopaque else void,
+    apc: Apc,
     /// Used only by group cancelation code for temporary storage.
     interrupt_method: InterruptMethod,
 
     csprng: Csprng,
 
+    const Apc = if (is_windows) struct {
+        handle: windows.HANDLE,
+        iosb: ?*windows.IO_STATUS_BLOCK,
+    } else void;
+
     const Handle = Handle: {
         if (std.Thread.use_pthreads) break :Handle std.c.pthread_t;
         if (is_windows) break :Handle windows.HANDLE;
@@ -1116,7 +1121,14 @@ const Thread = struct {
                     };
                 },
                 .dns => @panic("TODO call GetAddrInfoExCancel"),
-                .apc => @panic("TODO call NtCancelIoFileEx"),
+                .apc => {
+                    var iosb: windows.IO_STATUS_BLOCK = undefined;
+                    return switch (windows.ntdll.NtCancelIoFileEx(thread.apc.handle, thread.apc.iosb, &iosb)) {
+                        .NOT_FOUND => true, // this might mean the operation hasn't started yet
+                        .SUCCESS => false, // the OS confirmed that our cancelation worked
+                        else => false,
+                    };
+                },
             },
 
             else => {
@@ -1213,9 +1225,9 @@ const Syscall = struct {
     /// `NtCancelIoFileEx` to interrupt the wait.
     ///
     /// Windows only, called from blocked state only.
-    fn toApc(s: Syscall, apc_context: ?*anyopaque) Io.Cancelable!void {
+    fn toApc(s: Syscall, apc: Thread.Apc) Io.Cancelable!void {
         const thread = s.thread orelse return;
-        thread.apc_context = apc_context;
+        thread.apc = apc;
         var prev = thread.status.load(.monotonic);
         while (true) prev = switch (prev.cancelation) {
             .none => unreachable,
@@ -1554,7 +1566,7 @@ fn worker(t: *Threaded) void {
         .cancel_protection = .unblocked,
         .futex_waiter = undefined,
         .csprng = .{},
-        .apc_context = undefined,
+        .apc = undefined,
         .interrupt_method = undefined,
     };
     Thread.current = &thread;
@@ -8458,10 +8470,17 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                 //else => |status| return syscall.unexpectedNtstatus(status),
             }
         }
-        try syscall.toApc(&done);
+        try syscall.toApc(.{ .handle = file.handle, .iosb = &io_status_block });
         while (true) {
             switch (windows.ntdll.NtDelayExecution(1, null)) {
-                .USER_APC => break syscall.finishApc(),
+                .USER_APC => {
+                    if (!done) {
+                        // Other APC work was queued before calling into this function.
+                        try syscall.checkCancelApc();
+                        continue;
+                    }
+                    break syscall.finishApc();
+                },
                 .SUCCESS, .CANCELLED => {
                     try syscall.checkCancelApc();
                     continue;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 774ca28f19064bc66ad96840aa3114e9fb039cee..a6d5b21322e29333aeaef3d64c7b20c3d74a9fc2 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -601,11 +601,11 @@ pub extern "ntdll" fn NtDelayExecution(
 
 pub extern "ntdll" fn NtCancelIoFileEx(
     FileHandle: HANDLE,
-    IoRequestToCancel: *const IO_STATUS_BLOCK,
+    IoRequestToCancel: ?*IO_STATUS_BLOCK,
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtCancelIoFile(
-    handle: HANDLE,
-    iosbToCancel: *const IO_STATUS_BLOCK,
+    FileHandle: HANDLE,
+    IoRequestToCancel: ?*IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
-- 
2.54.0


From a933d7a6f88332a1ab7e1e6079e72a91320d0d4c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 21 Jan 2026 21:42:23 -0800
Subject: [PATCH 096/499] std.Io.Threaded: don't pass null to NtDelayExecution

Windows returns ACCESS_VIOLATION if you do that.
---
 lib/std/Io/Threaded.zig      | 5 +++--
 lib/std/os/windows/ntdll.zig | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 08d67a69975d0e63c3ff0ff9571fcc4d2d86d3ce..a9a8586da682b3423b177509145a83a9e11405ee 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8444,6 +8444,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
 
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var done: bool = false;
+    const infinite: windows.LARGE_INTEGER = windows.INFINITE;
 
     read: {
         const syscall: Syscall = try .start();
@@ -8472,7 +8473,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
         }
         try syscall.toApc(.{ .handle = file.handle, .iosb = &io_status_block });
         while (true) {
-            switch (windows.ntdll.NtDelayExecution(1, null)) {
+            switch (windows.ntdll.NtDelayExecution(1, &infinite)) {
                 .USER_APC => {
                     if (!done) {
                         // Other APC work was queued before calling into this function.
@@ -8481,7 +8482,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                     }
                     break syscall.finishApc();
                 },
-                .SUCCESS, .CANCELLED => {
+                .SUCCESS, .CANCELLED, .TIMEOUT, .ALERTED => {
                     try syscall.checkCancelApc();
                     continue;
                 },
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index a6d5b21322e29333aeaef3d64c7b20c3d74a9fc2..04b0a288debe648de202ed988570f1bb97bbaa6f 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -596,7 +596,7 @@ pub extern "ntdll" fn NtCancelSynchronousIoFile(
 
 pub extern "ntdll" fn NtDelayExecution(
     Alertable: BOOLEAN,
-    DelayInterval: ?*const LARGE_INTEGER,
+    DelayInterval: *const LARGE_INTEGER,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtCancelIoFileEx(
-- 
2.54.0


From 6d9e6e2c385650521289088968e16e0b5a1eed60 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 22 Jan 2026 14:32:39 -0800
Subject: [PATCH 097/499] std.Io.Threaded: avoid extra fields of Thread

As mlugg pointed out those race when a thread finishes an operation just
after it is canceled and then that thread to picks up another task,
resulting in these fields being potentially overwritten.

This updates fileReadStreaming on Windows to handle being alerted, and
then manage its own cancelation of the file I/O.
---
 lib/std/Io/Threaded.zig      | 275 +++++++++++++----------------------
 lib/std/os/windows/ntdll.zig |   2 +-
 2 files changed, 103 insertions(+), 174 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index a9a8586da682b3423b177509145a83a9e11405ee..3d7520dbe375716629ad6447ba92c2959230289c 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -339,8 +339,8 @@ const Group = struct {
                 .canceled => true,
                 .parked => unreachable,
                 .blocked => unreachable,
-                .blocked_apc => unreachable,
-                .blocked_windows_dns => unreachable,
+                .blocked_alertable => unreachable,
+                .blocked_alertable_canceling => unreachable,
                 .blocked_canceling => unreachable,
             };
             if (result) {
@@ -379,10 +379,7 @@ const Group = struct {
         while (it) |thread| : (it = thread.next) {
             // This non-mutating RMW exists for ordering reasons: see comment in `Group.Task.start` for reasons.
             _ = thread.status.fetchOr(.{ .cancelation = @enumFromInt(0), .awaitable = .null }, .release);
-            if (thread.cancelAwaitable(.fromGroup(g.ptr))) |method| {
-                thread.interrupt_method = method;
-                any_blocked = true;
-            }
+            if (thread.cancelAwaitable(.fromGroup(g.ptr))) any_blocked = true;
         }
         return any_blocked;
     }
@@ -394,7 +391,7 @@ const Group = struct {
         var any_signaled = false;
         var it = t.worker_threads.load(.acquire); // acquire `Thread` values
         while (it) |thread| : (it = thread.next) {
-            if (thread.signalCanceledSyscall(t, .fromGroup(g.ptr), thread.interrupt_method)) any_signaled = true;
+            if (thread.signalCanceledSyscall(t, .fromGroup(g.ptr))) any_signaled = true;
         }
         return any_signaled;
     }
@@ -546,8 +543,8 @@ const Future = struct {
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
         };
         thread.status.store(.{ .cancelation = .none, .awaitable = .null }, .monotonic);
@@ -576,15 +573,11 @@ const Future = struct {
         num_completed: *std.atomic.Value(u32),
         thread: ?*Thread,
     ) void {
-        var interrupt_method: ?Thread.InterruptMethod =
-            if (thread) |th| th.cancelAwaitable(.fromFuture(future)) else null;
+        var need_signal: bool = if (thread) |th| th.cancelAwaitable(.fromFuture(future)) else false;
         var timeout_ns: u64 = 1 << 10;
         while (true) {
-            if (interrupt_method) |method| {
-                if (!thread.?.signalCanceledSyscall(t, .fromFuture(future), method))
-                    interrupt_method = null;
-            }
-            Thread.futexWaitUncancelable(&num_completed.raw, 0, if (interrupt_method != null) timeout_ns else null);
+            need_signal = need_signal and thread.?.signalCanceledSyscall(t, .fromFuture(future));
+            Thread.futexWaitUncancelable(&num_completed.raw, 0, if (need_signal) timeout_ns else null);
             switch (num_completed.load(.acquire)) { // acquire task results
                 0 => {},
                 1 => break,
@@ -632,17 +625,9 @@ const Thread = struct {
     cancel_protection: Io.CancelProtection,
     /// Always released when `Status.cancelation` is set to `.parked`.
     futex_waiter: if (use_parking_futex) ?*parking_futex.Waiter else ?noreturn,
-    apc: Apc,
-    /// Used only by group cancelation code for temporary storage.
-    interrupt_method: InterruptMethod,
 
     csprng: Csprng,
 
-    const Apc = if (is_windows) struct {
-        handle: windows.HANDLE,
-        iosb: ?*windows.IO_STATUS_BLOCK,
-    } else void;
-
     const Handle = Handle: {
         if (std.Thread.use_pthreads) break :Handle std.c.pthread_t;
         if (is_windows) break :Handle windows.HANDLE;
@@ -667,13 +652,11 @@ const Thread = struct {
             /// To request cancelation, set the status to `.blocked_canceling` and repeatedly interrupt the system call until the status changes.
             blocked = 0b011,
 
-            /// Windows-only: the thread is blocked in a call to `NtDelayExecution`.
-            /// To request cancelation, set the status to `.canceling` and call `NtCancelIoFileEx`.
-            blocked_apc = 0b100,
-
-            /// Windows-only: the thread is blocked in a call to `GetAddrInfoExW`.
-            /// To request cancelation, set the status to `.canceling` and call `GetAddrInfoExCancel`.
-            blocked_windows_dns = 0b010,
+            /// Windows-only: the thread is blocked in an alertable wait via
+            /// `NtDelayExecution`. To request cancelation, set the status to
+            /// `blocked_alertable_canceling` and repeatedly alert the thread
+            /// until the status changes.
+            blocked_alertable = 0b010,
 
             /// The thread has an outstanding cancelation request but is not in a cancelable operation.
             /// When it acknowledges the cancelation, it will set the status to `.canceled`.
@@ -722,8 +705,8 @@ const Thread = struct {
         switch (status.cancelation) {
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
             .none, .canceled => {},
             .canceling => {
@@ -1003,17 +986,17 @@ const Thread = struct {
     /// It is possible that `thread` gets canceled by this function, but is blocked in a syscall. In
     /// that case, the thread may need to be sent a signal to interrupt the call. This function will
     /// return `true` to indicate this, in which case the caller must call `signalCanceledSyscall`.
-    fn cancelAwaitable(thread: *Thread, awaitable: AwaitableId) ?InterruptMethod {
+    fn cancelAwaitable(thread: *Thread, awaitable: AwaitableId) bool {
         var status = thread.status.load(.monotonic);
         while (true) {
-            if (status.awaitable != awaitable) return null; // thread is working on something else
+            if (status.awaitable != awaitable) return false; // thread is working on something else
             status = switch (status.cancelation) {
                 .none => thread.status.cmpxchgWeak(
                     .{ .cancelation = .none, .awaitable = awaitable },
                     .{ .cancelation = .canceling, .awaitable = awaitable },
                     .monotonic,
                     .monotonic,
-                ) orelse return null,
+                ) orelse return false,
 
                 .parked => thread.status.cmpxchgWeak(
                     .{ .cancelation = .parked, .awaitable = awaitable },
@@ -1026,7 +1009,7 @@ const Thread = struct {
                         parking_futex.removeCanceledWaiter(futex_waiter);
                     }
                     unpark(&.{thread.id}, null);
-                    return null;
+                    return false;
                 },
 
                 .blocked => thread.status.cmpxchgWeak(
@@ -1034,17 +1017,7 @@ const Thread = struct {
                     .{ .cancelation = .blocked_canceling, .awaitable = awaitable },
                     .monotonic,
                     .monotonic,
-                ) orelse return .sync,
-
-                .blocked_apc => thread.status.cmpxchgWeak(
-                    .{ .cancelation = .blocked_apc, .awaitable = awaitable },
-                    .{ .cancelation = .canceling, .awaitable = awaitable },
-                    .monotonic,
-                    .monotonic,
-                ) orelse {
-                    if (!is_windows) unreachable;
-                    return .apc;
-                },
+                ) orelse return true,
 
                 .blocked_alertable => thread.status.cmpxchgWeak(
                     .{ .cancelation = .blocked_alertable, .awaitable = awaitable },
@@ -1053,14 +1026,14 @@ const Thread = struct {
                     .monotonic,
                 ) orelse {
                     if (!is_windows) unreachable;
-                    return .dns;
+                    return true;
                 },
 
                 .canceling, .canceled => {
                     // This can happen when the task start raced with the cancelation, so the thread
                     // saw the cancelation on the future/group *and* we are trying to signal the
                     // thread here.
-                    return null;
+                    return false;
                 },
 
                 .blocked_canceling => unreachable, // `awaitable` has not been canceled before now
@@ -1069,11 +1042,6 @@ const Thread = struct {
         }
     }
 
-    const InterruptMethod = switch (native_os) {
-        .windows => enum { sync, dns, apc },
-        else => enum { sync },
-    };
-
     /// Sends a signal to `thread` if it is still blocked in a syscall (i.e. has not yet observed
     /// the cancelation request from `cancelAwaitable`).
     ///
@@ -1083,21 +1051,24 @@ const Thread = struct {
     /// the thread is still blocked. For the implementation, `Future.waitForCancelWithSignaling` and
     /// `Group.waitForCancelWithSignaling`: they use exponential backoff starting at a 1us delay and
     /// doubling each call. In practice, it is rare to send more than one signal.
-    fn signalCanceledSyscall(thread: *Thread, t: *Threaded, awaitable: AwaitableId, method: InterruptMethod) bool {
-        const bad_status: Status = .{ .cancelation = .blocked_canceling, .awaitable = awaitable };
-        if (thread.status.load(.monotonic) != bad_status) return false;
+    fn signalCanceledSyscall(thread: *Thread, t: *Threaded, awaitable: AwaitableId) bool {
+        const status = thread.status.load(.monotonic);
+        if (status.awaitable != awaitable) {
+            // The thread has moved on and is working on something totally different.
+            return false;
+        }
 
         // The thread ID and/or handle can be read non-atomically because they never change and were
         // released by the store that made `thread` available to us.
 
-        if (std.Thread.use_pthreads) switch (method) {
-            .sync => return switch (std.c.pthread_kill(thread.handle, .IO)) {
-                0 => true,
-                else => false,
-            },
-        } else switch (native_os) {
-            .linux => switch (method) {
-                .sync => {
+        switch (status.cancelation) {
+            .blocked_canceling => if (std.Thread.use_pthreads) {
+                return switch (std.c.pthread_kill(thread.handle, .IO)) {
+                    0 => true,
+                    else => false,
+                };
+            } else switch (native_os) {
+                .linux => {
                     const pid: posix.pid_t = pid: {
                         const cached_pid = @atomicLoad(Pid, &t.pid, .monotonic);
                         if (cached_pid != .unknown) break :pid @intFromEnum(cached_pid);
@@ -1110,9 +1081,7 @@ const Thread = struct {
                         else => false,
                     };
                 },
-            },
-            .windows => switch (method) {
-                .sync => {
+                .windows => {
                     var iosb: windows.IO_STATUS_BLOCK = undefined;
                     return switch (windows.ntdll.NtCancelSynchronousIoFile(thread.handle, null, &iosb)) {
                         .NOT_FOUND => true, // this might mean the operation hasn't started yet
@@ -1120,15 +1089,15 @@ const Thread = struct {
                         else => false,
                     };
                 },
-                .dns => @panic("TODO call GetAddrInfoExCancel"),
-                .apc => {
-                    var iosb: windows.IO_STATUS_BLOCK = undefined;
-                    return switch (windows.ntdll.NtCancelIoFileEx(thread.apc.handle, thread.apc.iosb, &iosb)) {
-                        .NOT_FOUND => true, // this might mean the operation hasn't started yet
-                        .SUCCESS => false, // the OS confirmed that our cancelation worked
-                        else => false,
-                    };
-                },
+                else => return false,
+            },
+
+            .blocked_alertable_canceling => {
+                if (!is_windows) unreachable;
+                return switch (windows.ntdll.NtAlertThread(thread.handle)) {
+                    .SUCCESS => true,
+                    else => false,
+                };
             },
 
             else => {
@@ -1176,8 +1145,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
             .none => return .{ .thread = thread }, // new status is `.blocked`
             .canceling => return error.Canceled, // new status is `.canceled`
@@ -1196,8 +1165,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
             .blocked => {}, // new status is `.blocked` (unchanged)
@@ -1213,8 +1182,8 @@ const Syscall = struct {
         }, .monotonic).cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
             .blocked => {}, // new status is `.none`
@@ -1222,25 +1191,25 @@ const Syscall = struct {
         }
     }
     /// Indicates instead of `NtCancelSynchronousIoFile` we need to use
-    /// `NtCancelIoFileEx` to interrupt the wait.
+    /// `NtAlertThread` to interrupt the wait.
     ///
     /// Windows only, called from blocked state only.
-    fn toApc(s: Syscall, apc: Thread.Apc) Io.Cancelable!void {
-        const thread = s.thread orelse return;
-        thread.apc = apc;
+    fn toAlertable(s: Syscall) Io.Cancelable!AlertableSyscall {
+        comptime assert(is_windows);
+        const thread = s.thread orelse return .{ .thread = null };
         var prev = thread.status.load(.monotonic);
         while (true) prev = switch (prev.cancelation) {
             .none => unreachable,
             .parked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .canceling => unreachable,
             .canceled => unreachable,
 
             .blocked => thread.status.cmpxchgWeak(prev, .{
-                .cancelation = .blocked_apc,
+                .cancelation = .blocked_alertable,
                 .awaitable = prev.awaitable,
-            }, .monotonic, .monotonic) orelse return,
+            }, .monotonic, .monotonic) orelse return .{ .thread = thread },
 
             .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
                 .cancelation = .canceled,
@@ -1248,45 +1217,6 @@ const Syscall = struct {
             }, .monotonic, .monotonic) orelse return error.Canceled,
         };
     }
-    /// Windows only, called from blocked_apc state only.
-    fn checkCancelApc(s: Syscall) Io.Cancelable!void {
-        const thread = s.thread orelse return;
-        var prev = thread.status.load(.monotonic);
-        while (true) prev = switch (prev.cancelation) {
-            .none => unreachable,
-            .parked => unreachable,
-            .blocked_windows_dns => unreachable,
-            .blocked => unreachable,
-            .canceling => unreachable,
-            .canceled => unreachable,
-            .blocked_apc => return,
-            .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
-                .cancelation = .canceled,
-                .awaitable = prev.awaitable,
-            }, .monotonic, .monotonic) orelse return error.Canceled,
-        };
-    }
-    /// Windows only, called from blocked_apc state only.
-    fn finishApc(s: Syscall) void {
-        const thread = s.thread orelse return;
-        var prev = thread.status.load(.monotonic);
-        while (true) prev = switch (prev.cancelation) {
-            .none => unreachable,
-            .parked => unreachable,
-            .blocked_windows_dns => unreachable,
-            .blocked => unreachable,
-            .canceling => unreachable,
-            .canceled => unreachable,
-            .blocked_apc => thread.status.cmpxchgWeak(prev, .{
-                .cancelation = .none,
-                .awaitable = prev.awaitable,
-            }, .monotonic, .monotonic) orelse return,
-            .blocked_canceling => thread.status.cmpxchgWeak(prev, .{
-                .cancelation = .canceling,
-                .awaitable = prev.awaitable,
-            }, .monotonic, .monotonic) orelse return,
-        };
-    }
     /// Convenience wrapper which calls `finish`, then returns `err`.
     fn fail(s: Syscall, err: anytype) @TypeOf(err) {
         s.finish();
@@ -1566,8 +1496,6 @@ fn worker(t: *Threaded) void {
         .cancel_protection = .unblocked,
         .futex_waiter = undefined,
         .csprng = .{},
-        .apc = undefined,
-        .interrupt_method = undefined,
     };
     Thread.current = &thread;
 
@@ -2176,8 +2104,8 @@ fn groupAsyncEager(
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
         };
     } else false;
@@ -2188,8 +2116,8 @@ fn groupAsyncEager(
             .canceled => true,
             .parked => unreachable,
             .blocked => unreachable,
-            .blocked_apc => unreachable,
-            .blocked_windows_dns => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_alertable_canceling => unreachable,
             .blocked_canceling => unreachable,
         };
     } else false;
@@ -2368,8 +2296,8 @@ fn recancelInner() void {
         .canceling => unreachable, // called `recancel` but cancelation was already pending
         .parked => unreachable,
         .blocked => unreachable,
-        .blocked_apc => unreachable,
-        .blocked_windows_dns => unreachable,
+        .blocked_alertable => unreachable,
+        .blocked_alertable_canceling => unreachable,
         .blocked_canceling => unreachable,
     }
 }
@@ -8467,36 +8395,37 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                     continue;
                 },
                 .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
-                else => |status| std.debug.panic("fileReadStreamingWindows NtReadFile returned {t}", .{status}),
-                //else => |status| return syscall.unexpectedNtstatus(status),
+                else => |status| return syscall.unexpectedNtstatus(status),
             }
         }
-        try syscall.toApc(.{ .handle = file.handle, .iosb = &io_status_block });
-        while (true) {
-            switch (windows.ntdll.NtDelayExecution(1, &infinite)) {
-                .USER_APC => {
-                    if (!done) {
-                        // Other APC work was queued before calling into this function.
-                        try syscall.checkCancelApc();
-                        continue;
-                    }
-                    break syscall.finishApc();
+        // Once we get here we received PENDING so we must not return from the
+        // function until the operation completes.
+        defer while (!done) {
+            _ = windows.ntdll.NtDelayExecution(1, &infinite);
+        };
+
+        const alertable_syscall = syscall.toAlertable() catch |err| switch (err) {
+            error.Canceled => |e| {
+                _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
+                return e;
+            },
+        };
+        defer alertable_syscall.finish();
+        while (!done) {
+            _ = windows.ntdll.NtDelayExecution(1, &infinite);
+            alertable_syscall.checkCancel() catch |err| switch (err) {
+                error.Canceled => |e| {
+                    _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
+                    return e;
                 },
-                .SUCCESS, .CANCELLED, .TIMEOUT, .ALERTED => {
-                    try syscall.checkCancelApc();
-                    continue;
-                },
-                else => |status| std.debug.panic("fileReadStreamingWindows NtDelayExecution returned {t}", .{status}),
-                //else => |status| return syscall.unexpectedNtstatus(status),
-            }
+            };
         }
     }
 
     switch (io_status_block.u.Status) {
         .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {},
         .ACCESS_DENIED => return error.AccessDenied,
-        else => |status| std.debug.panic("fileReadStreamingWindows IO_STATUS_BLOCK returned {t}", .{status}),
-        //else => |status| return windows.unexpectedStatus(status),
+        else => |status| return windows.unexpectedStatus(status),
     }
     return io_status_block.Information;
 }
@@ -12519,7 +12448,7 @@ fn netLookupFallible(
         var res: *ws2_32.ADDRINFOEXW = undefined;
         const timeout: ?*ws2_32.timeval = null;
         while (true) {
-            // TODO: hook this up to cancelation with `Thread.Status.cancelation.blocked_windows_dns`.
+            // TODO: hook this up to cancelation with `NtDelayExecution` and APC callbacks.
             try Thread.checkCancel();
             // TODO make this append to the queue eagerly rather than blocking until the whole thing finishes
             const rc: ws2_32.WinsockError = @enumFromInt(ws2_32.GetAddrInfoExW(name_w, port_w, .DNS, null, &hints, &res, timeout, null, null, null));
@@ -16253,8 +16182,8 @@ const parking_futex = struct {
                         .canceled => break :cancelable, // status is still `.canceled`
                         .parked => unreachable,
                         .blocked => unreachable,
-                        .blocked_apc => unreachable,
-                        .blocked_windows_dns => unreachable,
+                        .blocked_alertable => unreachable,
+                        .blocked_alertable_canceling => unreachable,
                         .blocked_canceling => unreachable,
                     }
                     // We could now be unparked for a cancelation at any time!
@@ -16305,8 +16234,8 @@ const parking_futex = struct {
                 },
                 .canceled => unreachable,
                 .blocked => unreachable,
-                .blocked_apc => unreachable,
-                .blocked_windows_dns => unreachable,
+                .blocked_alertable => unreachable,
+                .blocked_alertable_canceling => unreachable,
                 .blocked_canceling => unreachable,
             },
         }
@@ -16347,8 +16276,8 @@ const parking_futex = struct {
                     .canceling => continue, // race with a canceler who hasn't called `removeCanceledWaiter` yet
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_apc => unreachable,
-                    .blocked_windows_dns => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 }
                 // We're waking this waiter. Remove them from the bucket and add them to our local list.
@@ -16414,8 +16343,8 @@ const parking_sleep = struct {
                 .canceled => break :cancelable, // status is still `.canceled`
                 .parked => unreachable,
                 .blocked => unreachable,
-                .blocked_apc => unreachable,
-                .blocked_windows_dns => unreachable,
+                .blocked_alertable => unreachable,
+                .blocked_alertable_canceling => unreachable,
                 .blocked_canceling => unreachable,
             }
             while (park(deadline, null)) {
@@ -16433,8 +16362,8 @@ const parking_sleep = struct {
                     .none => unreachable,
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_apc => unreachable,
-                    .blocked_windows_dns => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 }
             } else |err| switch (err) {
@@ -16453,8 +16382,8 @@ const parking_sleep = struct {
                     .none => unreachable,
                     .canceled => unreachable,
                     .blocked => unreachable,
-                    .blocked_apc => unreachable,
-                    .blocked_windows_dns => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 },
             }
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 04b0a288debe648de202ed988570f1bb97bbaa6f..d68cd1494b8392381187de4316a7155351687eae 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -601,7 +601,7 @@ pub extern "ntdll" fn NtDelayExecution(
 
 pub extern "ntdll" fn NtCancelIoFileEx(
     FileHandle: HANDLE,
-    IoRequestToCancel: ?*IO_STATUS_BLOCK,
+    IoRequestToCancel: *const IO_STATUS_BLOCK,
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
 
-- 
2.54.0


From 11b0a504df219b09db1d7364cc8b6a12b631ac64 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 22 Jan 2026 16:54:32 -0800
Subject: [PATCH 098/499] std.Io.Threaded: handle some more error codes from
 NtReadFile

---
 lib/std/Io/Threaded.zig | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 3d7520dbe375716629ad6447ba92c2959230289c..36fb28db04b7f85a8498fd9c8d5aa2923978a853 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8388,12 +8388,15 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                 null, // byte offset
                 null, // key
             )) {
-                .SUCCESS => break :read syscall.finish(),
+                .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => break :read syscall.finish(),
                 .PENDING => break,
                 .CANCELLED => {
                     try syscall.checkCancel();
                     continue;
                 },
+                .INVALID_DEVICE_REQUEST => return syscall.fail(error.IsDir),
+                .LOCK_NOT_GRANTED => return syscall.fail(error.LockViolation),
+                .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
                 .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
                 else => |status| return syscall.unexpectedNtstatus(status),
             }
@@ -8424,6 +8427,8 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
 
     switch (io_status_block.u.Status) {
         .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {},
+        .INVALID_DEVICE_REQUEST => return error.IsDir,
+        .LOCK_NOT_GRANTED => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
         else => |status| return windows.unexpectedStatus(status),
     }
-- 
2.54.0


From 9862518797f79c946ccfad3339260597ce37ca18 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 23 Jan 2026 00:03:37 -0800
Subject: [PATCH 099/499] std.Io.Threaded: fix NtDelayExecution delay interval

---
 lib/std/Io/Threaded.zig | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 36fb28db04b7f85a8498fd9c8d5aa2923978a853..9db284b8feb2b0bb48521a8f23e50f3e7568a64c 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8372,7 +8372,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
 
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var done: bool = false;
-    const infinite: windows.LARGE_INTEGER = windows.INFINITE;
+    const max_delay_interval: windows.LARGE_INTEGER = std.math.minInt(i64);
 
     read: {
         const syscall: Syscall = try .start();
@@ -8404,7 +8404,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
         // Once we get here we received PENDING so we must not return from the
         // function until the operation completes.
         defer while (!done) {
-            _ = windows.ntdll.NtDelayExecution(1, &infinite);
+            _ = windows.ntdll.NtDelayExecution(1, &max_delay_interval);
         };
 
         const alertable_syscall = syscall.toAlertable() catch |err| switch (err) {
@@ -8415,7 +8415,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
         };
         defer alertable_syscall.finish();
         while (!done) {
-            _ = windows.ntdll.NtDelayExecution(1, &infinite);
+            _ = windows.ntdll.NtDelayExecution(1, &max_delay_interval);
             alertable_syscall.checkCancel() catch |err| switch (err) {
                 error.Canceled => |e| {
                     _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
-- 
2.54.0


From 90890fcb5cf39e53dc470db8260964f95b607937 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sat, 24 Jan 2026 03:37:43 -0500
Subject: [PATCH 100/499] Io.Threaded: fix UAF-induced crashes during
 asynchronous operations

When `NtReadFile` returns `SUCCESS`, the APC routine still runs when
next alertable, which was previously clobbering an out of scope `done`.
Instead of adding an extra syscall to the success path, avoid all APC
side effects, allowing instant completions to return immediately.
---
 lib/std/Io/Threaded.zig | 93 ++++++++++++++++++++---------------------
 src/codegen/c/Type.zig  |  4 +-
 src/link.zig            | 11 ++++-
 3 files changed, 56 insertions(+), 52 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 9db284b8feb2b0bb48521a8f23e50f3e7568a64c..4fd2ab170355613846117d199054457d52dffb27 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1314,6 +1314,13 @@ const AlertableSyscall = struct {
     }
 };
 
+fn noopApc(_: ?*anyopaque, _: *windows.IO_STATUS_BLOCK, _: windows.ULONG) callconv(.winapi) void {}
+
+fn waitForApcOrAlert() void {
+    const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
+    _ = windows.ntdll.NtDelayExecution(windows.TRUE, &infinite_timeout);
+}
+
 const max_iovecs_len = 8;
 const splat_buffer_size = 64;
 const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
@@ -8371,40 +8378,41 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
     const buffer = data[index];
 
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
-    var done: bool = false;
-    const max_delay_interval: windows.LARGE_INTEGER = std.math.minInt(i64);
-
-    read: {
-        const syscall: Syscall = try .start();
-        while (true) {
-            switch (windows.ntdll.NtReadFile(
-                file.handle,
-                null, // event
-                flagApc, // apc callback
-                &done, // apc context
-                &io_status_block,
-                buffer.ptr,
-                @min(std.math.maxInt(u32), buffer.len),
-                null, // byte offset
-                null, // key
-            )) {
-                .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => break :read syscall.finish(),
-                .PENDING => break,
-                .CANCELLED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                .INVALID_DEVICE_REQUEST => return syscall.fail(error.IsDir),
-                .LOCK_NOT_GRANTED => return syscall.fail(error.LockViolation),
-                .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-                .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
-                else => |status| return syscall.unexpectedNtstatus(status),
-            }
+    const syscall: Syscall = try .start();
+    while (true) {
+        io_status_block.u.Status = .PENDING;
+        switch (windows.ntdll.NtReadFile(
+            file.handle,
+            null, // event
+            noopApc, // apc callback
+            null, // apc context
+            &io_status_block,
+            buffer.ptr,
+            @min(std.math.maxInt(u32), buffer.len),
+            null, // byte offset
+            null, // key
+        )) {
+            .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {
+                syscall.finish();
+                return io_status_block.Information;
+            },
+            .PENDING => break,
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .INVALID_DEVICE_REQUEST => return syscall.fail(error.IsDir),
+            .LOCK_NOT_GRANTED => return syscall.fail(error.LockViolation),
+            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
+            else => |status| return syscall.unexpectedNtstatus(status),
         }
+    }
+    {
         // Once we get here we received PENDING so we must not return from the
         // function until the operation completes.
-        defer while (!done) {
-            _ = windows.ntdll.NtDelayExecution(1, &max_delay_interval);
+        defer while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
+            waitForApcOrAlert();
         };
 
         const alertable_syscall = syscall.toAlertable() catch |err| switch (err) {
@@ -8414,36 +8422,25 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
             },
         };
         defer alertable_syscall.finish();
-        while (!done) {
-            _ = windows.ntdll.NtDelayExecution(1, &max_delay_interval);
+        waitForApcOrAlert();
+        while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
             alertable_syscall.checkCancel() catch |err| switch (err) {
                 error.Canceled => |e| {
                     _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
                     return e;
                 },
             };
+            waitForApcOrAlert();
         }
     }
-
     switch (io_status_block.u.Status) {
-        .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {},
+        .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => return io_status_block.Information,
+        .PENDING => unreachable, // cannot return until the operation completes
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
         else => |status| return windows.unexpectedStatus(status),
     }
-    return io_status_block.Information;
-}
-
-fn flagApc(
-    apc_context: ?*anyopaque,
-    io_status_block: *windows.IO_STATUS_BLOCK,
-    unused: windows.ULONG,
-) callconv(.winapi) void {
-    const flag: *bool = @ptrCast(apc_context);
-    flag.* = true;
-    _ = io_status_block;
-    _ = unused;
 }
 
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
@@ -14646,7 +14643,7 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
             t.mutex.lock(); // Another thread might have won the race.
             defer t.mutex.unlock();
             if (t.random_file.handle) |prev_handle| {
-                _ = windows.ntdll.NtClose(fresh_handle);
+                windows.CloseHandle(fresh_handle);
                 return prev_handle;
             } else {
                 t.random_file.handle = fresh_handle;
diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig
index fb37b60580b3aa655f1a633f6ed49d87e5d5c590..0bcdb207fc693b3acb38cd2a2c458dee9d61dbe3 100644
--- a/src/codegen/c/Type.zig
+++ b/src/codegen/c/Type.zig
@@ -2389,7 +2389,7 @@ pub const Pool = struct {
                             .nonstring = elem_ctype.isAnyChar() and switch (ptr_info.sentinel) {
                                 .none => true,
                                 .zero_u8 => false,
-                                else => |sentinel| Value.fromInterned(sentinel).orderAgainstZero(zcu).compare(.neq),
+                                else => |sentinel| !Value.fromInterned(sentinel).compareAllWithZero(.eq, zcu),
                             },
                         });
                     },
@@ -2438,7 +2438,7 @@ pub const Pool = struct {
                         .nonstring = elem_ctype.isAnyChar() and switch (array_info.sentinel) {
                             .none => true,
                             .zero_u8 => false,
-                            else => |sentinel| Value.fromInterned(sentinel).orderAgainstZero(zcu).compare(.neq),
+                            else => |sentinel| !Value.fromInterned(sentinel).compareAllWithZero(.eq, zcu),
                         },
                     });
                     if (!kind.isParameter()) return array_ctype;
diff --git a/src/link.zig b/src/link.zig
index 6f19ec0e583010a18cc450f9ac22629bf09a141a..3af768a363733e5b2dc25e8f46412c601b2e05a0 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -605,8 +605,8 @@ pub const File = struct {
         switch (base.tag) {
             .lld => assert(base.file == null),
             .elf, .macho, .wasm => {
-                if (base.file != null) return;
                 dev.checkAny(&.{ .coff_linker, .elf_linker, .macho_linker, .plan9_linker, .wasm_linker });
+                if (base.file != null) return;
                 const emit = base.emit;
                 if (base.child_pid) |pid| {
                     if (builtin.os.tag == .windows) {
@@ -645,6 +645,7 @@ pub const File = struct {
                 base.file = try emit.root_dir.handle.openFile(io, emit.sub_path, .{ .mode = .read_write });
             },
             .elf2, .coff2 => if (base.file == null) {
+                dev.checkAny(&.{ .elf2_linker, .coff2_linker });
                 const mf = if (base.cast(.elf2)) |elf|
                     &elf.mf
                 else if (base.cast(.coff2)) |coff|
@@ -657,7 +658,13 @@ pub const File = struct {
                 base.file = mf.memory_map.file;
                 try mf.ensureTotalCapacity(@intCast(mf.nodes.items[0].location().resolve(mf)[1]));
             },
-            .c, .spirv => dev.checkAny(&.{ .c_linker, .spirv_linker }),
+            .c => if (base.file == null) {
+                dev.check(.c_linker);
+                base.file = try base.emit.root_dir.handle.openFile(io, base.emit.sub_path, .{
+                    .mode = .write_only,
+                });
+            },
+            .spirv => dev.check(.spirv_linker),
             .plan9 => unreachable,
         }
     }
-- 
2.54.0


From bd4b6d8b14e24e0bc6c072e5fb1bba3c666564d2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 5 Jan 2026 22:19:08 -0800
Subject: [PATCH 101/499] std.Io: delete the poll API

---
 lib/std/Io.zig | 466 +------------------------------------------------
 1 file changed, 8 insertions(+), 458 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 6dc0e247315c4a69ed02332c9935131a5d6812fc..506203418fe49264546d9d400912fafa220c923f 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -15,463 +15,13 @@
 const Io = @This();
 
 const builtin = @import("builtin");
-const is_windows = builtin.os.tag == .windows;
 
 const std = @import("std.zig");
-const windows = std.os.windows;
-const posix = std.posix;
 const math = std.math;
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const Alignment = std.mem.Alignment;
 
-pub fn poll(
-    gpa: Allocator,
-    comptime StreamEnum: type,
-    files: PollFiles(StreamEnum),
-) Poller(StreamEnum) {
-    const enum_fields = @typeInfo(StreamEnum).@"enum".fields;
-    var result: Poller(StreamEnum) = .{
-        .gpa = gpa,
-        .readers = @splat(.failing),
-        .poll_fds = undefined,
-        .windows = if (is_windows) .{
-            .first_read_done = false,
-            .overlapped = [1]windows.OVERLAPPED{
-                std.mem.zeroes(windows.OVERLAPPED),
-            } ** enum_fields.len,
-            .small_bufs = undefined,
-            .active = .{
-                .count = 0,
-                .handles_buf = undefined,
-                .stream_map = undefined,
-            },
-        } else {},
-    };
-
-    inline for (enum_fields, 0..) |field, i| {
-        if (is_windows) {
-            result.windows.active.handles_buf[i] = @field(files, field.name).handle;
-        } else {
-            result.poll_fds[i] = .{
-                .fd = @field(files, field.name).handle,
-                .events = posix.POLL.IN,
-                .revents = undefined,
-            };
-        }
-    }
-
-    return result;
-}
-
-pub fn Poller(comptime StreamEnum: type) type {
-    return struct {
-        const enum_fields = @typeInfo(StreamEnum).@"enum".fields;
-        const PollFd = if (is_windows) void else posix.pollfd;
-
-        gpa: Allocator,
-        readers: [enum_fields.len]Reader,
-        poll_fds: [enum_fields.len]PollFd,
-        windows: if (is_windows) struct {
-            first_read_done: bool,
-            overlapped: [enum_fields.len]windows.OVERLAPPED,
-            small_bufs: [enum_fields.len][128]u8,
-            active: struct {
-                count: math.IntFittingRange(0, enum_fields.len),
-                handles_buf: [enum_fields.len]windows.HANDLE,
-                stream_map: [enum_fields.len]StreamEnum,
-
-                pub fn removeAt(self: *@This(), index: u32) void {
-                    assert(index < self.count);
-                    for (index + 1..self.count) |i| {
-                        self.handles_buf[i - 1] = self.handles_buf[i];
-                        self.stream_map[i - 1] = self.stream_map[i];
-                    }
-                    self.count -= 1;
-                }
-            },
-        } else void,
-
-        const Self = @This();
-
-        pub fn deinit(self: *Self) void {
-            const gpa = self.gpa;
-            if (is_windows) {
-                // cancel any pending IO to prevent clobbering OVERLAPPED value
-                for (self.windows.active.handles_buf[0..self.windows.active.count]) |h| {
-                    _ = windows.kernel32.CancelIo(h);
-                }
-            }
-            inline for (&self.readers) |*r| gpa.free(r.buffer);
-            self.* = undefined;
-        }
-
-        pub fn poll(self: *Self) !bool {
-            if (is_windows) {
-                return pollWindows(self, null);
-            } else {
-                return pollPosix(self, null);
-            }
-        }
-
-        pub fn pollTimeout(self: *Self, nanoseconds: u64) !bool {
-            if (is_windows) {
-                return pollWindows(self, nanoseconds);
-            } else {
-                return pollPosix(self, nanoseconds);
-            }
-        }
-
-        pub fn reader(self: *Self, which: StreamEnum) *Reader {
-            return &self.readers[@intFromEnum(which)];
-        }
-
-        pub fn toOwnedSlice(self: *Self, which: StreamEnum) error{OutOfMemory}![]u8 {
-            const gpa = self.gpa;
-            const r = reader(self, which);
-            if (r.seek == 0) {
-                const new = try gpa.realloc(r.buffer, r.end);
-                r.buffer = &.{};
-                r.end = 0;
-                return new;
-            }
-            const new = try gpa.dupe(u8, r.buffered());
-            gpa.free(r.buffer);
-            r.buffer = &.{};
-            r.seek = 0;
-            r.end = 0;
-            return new;
-        }
-
-        fn pollWindows(self: *Self, nanoseconds: ?u64) !bool {
-            const bump_amt = 512;
-            const gpa = self.gpa;
-
-            if (!self.windows.first_read_done) {
-                var already_read_data = false;
-                for (0..enum_fields.len) |i| {
-                    const handle = self.windows.active.handles_buf[i];
-                    switch (try windowsAsyncReadToFifoAndQueueSmallRead(
-                        gpa,
-                        handle,
-                        &self.windows.overlapped[i],
-                        &self.readers[i],
-                        &self.windows.small_bufs[i],
-                        bump_amt,
-                    )) {
-                        .populated, .empty => |state| {
-                            if (state == .populated) already_read_data = true;
-                            self.windows.active.handles_buf[self.windows.active.count] = handle;
-                            self.windows.active.stream_map[self.windows.active.count] = @as(StreamEnum, @enumFromInt(i));
-                            self.windows.active.count += 1;
-                        },
-                        .closed => {}, // don't add to the wait_objects list
-                        .closed_populated => {
-                            // don't add to the wait_objects list, but we did already get data
-                            already_read_data = true;
-                        },
-                    }
-                }
-                self.windows.first_read_done = true;
-                if (already_read_data) return true;
-            }
-
-            while (true) {
-                if (self.windows.active.count == 0) return false;
-
-                const status = windows.kernel32.WaitForMultipleObjects(
-                    self.windows.active.count,
-                    &self.windows.active.handles_buf,
-                    0,
-                    if (nanoseconds) |ns|
-                        @min(std.math.cast(u32, ns / std.time.ns_per_ms) orelse (windows.INFINITE - 1), windows.INFINITE - 1)
-                    else
-                        windows.INFINITE,
-                );
-                if (status == windows.WAIT_FAILED)
-                    return windows.unexpectedError(windows.GetLastError());
-                if (status == windows.WAIT_TIMEOUT)
-                    return true;
-
-                if (status < windows.WAIT_OBJECT_0 or status > windows.WAIT_OBJECT_0 + enum_fields.len - 1)
-                    unreachable;
-
-                const active_idx = status - windows.WAIT_OBJECT_0;
-
-                const stream_idx = @intFromEnum(self.windows.active.stream_map[active_idx]);
-                const handle = self.windows.active.handles_buf[active_idx];
-
-                const overlapped = &self.windows.overlapped[stream_idx];
-                const stream_reader = &self.readers[stream_idx];
-                const small_buf = &self.windows.small_bufs[stream_idx];
-
-                const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, false)) {
-                    .success => |n| n,
-                    .closed => {
-                        self.windows.active.removeAt(active_idx);
-                        continue;
-                    },
-                    .aborted => unreachable,
-                };
-                const buf = small_buf[0..num_bytes_read];
-                const dest = try writableSliceGreedyAlloc(stream_reader, gpa, buf.len);
-                @memcpy(dest[0..buf.len], buf);
-                advanceBufferEnd(stream_reader, buf.len);
-
-                switch (try windowsAsyncReadToFifoAndQueueSmallRead(
-                    gpa,
-                    handle,
-                    overlapped,
-                    stream_reader,
-                    small_buf,
-                    bump_amt,
-                )) {
-                    .empty => {}, // irrelevant, we already got data from the small buffer
-                    .populated => {},
-                    .closed,
-                    .closed_populated, // identical, since we already got data from the small buffer
-                    => self.windows.active.removeAt(active_idx),
-                }
-                return true;
-            }
-        }
-
-        fn pollPosix(self: *Self, nanoseconds: ?u64) !bool {
-            const gpa = self.gpa;
-            // We ask for ensureUnusedCapacity with this much extra space. This
-            // has more of an effect on small reads because once the reads
-            // start to get larger the amount of space an ArrayList will
-            // allocate grows exponentially.
-            const bump_amt = 512;
-
-            const err_mask = posix.POLL.ERR | posix.POLL.NVAL | posix.POLL.HUP;
-
-            const events_len = try posix.poll(&self.poll_fds, if (nanoseconds) |ns|
-                std.math.cast(i32, ns / std.time.ns_per_ms) orelse std.math.maxInt(i32)
-            else
-                -1);
-            if (events_len == 0) {
-                for (self.poll_fds) |poll_fd| {
-                    if (poll_fd.fd != -1) return true;
-                } else return false;
-            }
-
-            var keep_polling = false;
-            for (&self.poll_fds, &self.readers) |*poll_fd, *r| {
-                // Try reading whatever is available before checking the error
-                // conditions.
-                // It's still possible to read after a POLL.HUP is received,
-                // always check if there's some data waiting to be read first.
-                if (poll_fd.revents & posix.POLL.IN != 0) {
-                    const buf = try writableSliceGreedyAlloc(r, gpa, bump_amt);
-                    const amt = posix.read(poll_fd.fd, buf) catch |err| switch (err) {
-                        error.BrokenPipe => 0, // Handle the same as EOF.
-                        else => |e| return e,
-                    };
-                    advanceBufferEnd(r, amt);
-                    if (amt == 0) {
-                        // Remove the fd when the EOF condition is met.
-                        poll_fd.fd = -1;
-                    } else {
-                        keep_polling = true;
-                    }
-                } else if (poll_fd.revents & err_mask != 0) {
-                    // Exclude the fds that signaled an error.
-                    poll_fd.fd = -1;
-                } else if (poll_fd.fd != -1) {
-                    keep_polling = true;
-                }
-            }
-            return keep_polling;
-        }
-
-        /// Returns a slice into the unused capacity of `buffer` with at least
-        /// `min_len` bytes, extending `buffer` by resizing it with `gpa` as necessary.
-        ///
-        /// After calling this function, typically the caller will follow up with a
-        /// call to `advanceBufferEnd` to report the actual number of bytes buffered.
-        fn writableSliceGreedyAlloc(r: *Reader, allocator: Allocator, min_len: usize) Allocator.Error![]u8 {
-            {
-                const unused = r.buffer[r.end..];
-                if (unused.len >= min_len) return unused;
-            }
-            if (r.seek > 0) {
-                const data = r.buffer[r.seek..r.end];
-                @memmove(r.buffer[0..data.len], data);
-                r.seek = 0;
-                r.end = data.len;
-            }
-            {
-                var list: std.ArrayList(u8) = .{
-                    .items = r.buffer[0..r.end],
-                    .capacity = r.buffer.len,
-                };
-                defer r.buffer = list.allocatedSlice();
-                try list.ensureUnusedCapacity(allocator, min_len);
-            }
-            const unused = r.buffer[r.end..];
-            assert(unused.len >= min_len);
-            return unused;
-        }
-
-        /// After writing directly into the unused capacity of `buffer`, this function
-        /// updates `end` so that users of `Reader` can receive the data.
-        fn advanceBufferEnd(r: *Reader, n: usize) void {
-            assert(n <= r.buffer.len - r.end);
-            r.end += n;
-        }
-
-        /// The `ReadFile` docuementation states that `lpNumberOfBytesRead` does not have a meaningful
-        /// result when using overlapped I/O, but also that it cannot be `null` on Windows 7. For
-        /// compatibility, we point it to this dummy variables, which we never otherwise access.
-        /// See: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile
-        var win_dummy_bytes_read: u32 = undefined;
-
-        /// Read as much data as possible from `handle` with `overlapped`, and write it to the FIFO. Before
-        /// returning, queue a read into `small_buf` so that `WaitForMultipleObjects` returns when more data
-        /// is available. `handle` must have no pending asynchronous operation.
-        fn windowsAsyncReadToFifoAndQueueSmallRead(
-            gpa: Allocator,
-            handle: windows.HANDLE,
-            overlapped: *windows.OVERLAPPED,
-            r: *Reader,
-            small_buf: *[128]u8,
-            bump_amt: usize,
-        ) !enum { empty, populated, closed_populated, closed } {
-            var read_any_data = false;
-            while (true) {
-                const fifo_read_pending = while (true) {
-                    const buf = try writableSliceGreedyAlloc(r, gpa, bump_amt);
-                    const buf_len = math.cast(u32, buf.len) orelse math.maxInt(u32);
-
-                    if (0 == windows.kernel32.ReadFile(
-                        handle,
-                        buf.ptr,
-                        buf_len,
-                        &win_dummy_bytes_read,
-                        overlapped,
-                    )) switch (windows.GetLastError()) {
-                        .IO_PENDING => break true,
-                        .BROKEN_PIPE => return if (read_any_data) .closed_populated else .closed,
-                        else => |err| return windows.unexpectedError(err),
-                    };
-
-                    const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, false)) {
-                        .success => |n| n,
-                        .closed => return if (read_any_data) .closed_populated else .closed,
-                        .aborted => unreachable,
-                    };
-
-                    read_any_data = true;
-                    advanceBufferEnd(r, num_bytes_read);
-
-                    if (num_bytes_read == buf_len) {
-                        // We filled the buffer, so there's probably more data available.
-                        continue;
-                    } else {
-                        // We didn't fill the buffer, so assume we're out of data.
-                        // There is no pending read.
-                        break false;
-                    }
-                };
-
-                if (fifo_read_pending) cancel_read: {
-                    // Cancel the pending read into the FIFO.
-                    _ = windows.kernel32.CancelIo(handle);
-
-                    // We have to wait for the handle to be signalled, i.e. for the cancelation to complete.
-                    switch (windows.kernel32.WaitForSingleObject(handle, windows.INFINITE)) {
-                        windows.WAIT_OBJECT_0 => {},
-                        windows.WAIT_FAILED => return windows.unexpectedError(windows.GetLastError()),
-                        else => unreachable,
-                    }
-
-                    // If it completed before we canceled, make sure to tell the FIFO!
-                    const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, true)) {
-                        .success => |n| n,
-                        .closed => return if (read_any_data) .closed_populated else .closed,
-                        .aborted => break :cancel_read,
-                    };
-                    read_any_data = true;
-                    advanceBufferEnd(r, num_bytes_read);
-                }
-
-                // Try to queue the 1-byte read.
-                if (0 == windows.kernel32.ReadFile(
-                    handle,
-                    small_buf,
-                    small_buf.len,
-                    &win_dummy_bytes_read,
-                    overlapped,
-                )) switch (windows.GetLastError()) {
-                    .IO_PENDING => {
-                        // 1-byte read pending as intended
-                        return if (read_any_data) .populated else .empty;
-                    },
-                    .BROKEN_PIPE => return if (read_any_data) .closed_populated else .closed,
-                    else => |err| return windows.unexpectedError(err),
-                };
-
-                // We got data back this time. Write it to the FIFO and run the main loop again.
-                const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, false)) {
-                    .success => |n| n,
-                    .closed => return if (read_any_data) .closed_populated else .closed,
-                    .aborted => unreachable,
-                };
-                const buf = small_buf[0..num_bytes_read];
-                const dest = try writableSliceGreedyAlloc(r, gpa, buf.len);
-                @memcpy(dest[0..buf.len], buf);
-                advanceBufferEnd(r, buf.len);
-                read_any_data = true;
-            }
-        }
-
-        /// Simple wrapper around `GetOverlappedResult` to determine the result of a `ReadFile` operation.
-        /// If `!allow_aborted`, then `aborted` is never returned (`OPERATION_ABORTED` is considered unexpected).
-        ///
-        /// The `ReadFile` documentation states that the number of bytes read by an overlapped `ReadFile` must be determined using `GetOverlappedResult`, even if the
-        /// operation immediately returns data:
-        /// "Use NULL for [lpNumberOfBytesRead] if this is an asynchronous operation to avoid potentially
-        /// erroneous results."
-        /// "If `hFile` was opened with `FILE_FLAG_OVERLAPPED`, the following conditions are in effect: [...]
-        /// The lpNumberOfBytesRead parameter should be set to NULL. Use the GetOverlappedResult function to
-        /// get the actual number of bytes read."
-        /// See: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile
-        fn windowsGetReadResult(
-            handle: windows.HANDLE,
-            overlapped: *windows.OVERLAPPED,
-            allow_aborted: bool,
-        ) !union(enum) {
-            success: u32,
-            closed,
-            aborted,
-        } {
-            var num_bytes_read: u32 = undefined;
-            if (0 == windows.kernel32.GetOverlappedResult(
-                handle,
-                overlapped,
-                &num_bytes_read,
-                0,
-            )) switch (windows.GetLastError()) {
-                .BROKEN_PIPE => return .closed,
-                .OPERATION_ABORTED => |err| if (allow_aborted) {
-                    return .aborted;
-                } else {
-                    return windows.unexpectedError(err);
-                },
-                else => |err| return windows.unexpectedError(err),
-            };
-            return .{ .success = num_bytes_read };
-        }
-    };
-}
-
-/// Given an enum, returns a struct with fields of that enum, each field
-/// representing an I/O stream for polling.
-pub fn PollFiles(comptime StreamEnum: type) type {
-    return @Struct(.auto, null, std.meta.fieldNames(StreamEnum), &@splat(Io.File), &@splat(.{}));
-}
-
 userdata: ?*anyopaque,
 vtable: *const VTable,
 
@@ -704,18 +254,18 @@ pub const VTable = struct {
 
 pub const Limit = enum(usize) {
     nothing = 0,
-    unlimited = std.math.maxInt(usize),
+    unlimited = math.maxInt(usize),
     _,
 
-    /// `std.math.maxInt(usize)` is interpreted to mean `.unlimited`.
+    /// `math.maxInt(usize)` is interpreted to mean `.unlimited`.
     pub fn limited(n: usize) Limit {
         return @enumFromInt(n);
     }
 
-    /// Any value grater than `std.math.maxInt(usize)` is interpreted to mean
+    /// Any value grater than `math.maxInt(usize)` is interpreted to mean
     /// `.unlimited`.
     pub fn limited64(n: u64) Limit {
-        return @enumFromInt(@min(n, std.math.maxInt(usize)));
+        return @enumFromInt(@min(n, math.maxInt(usize)));
     }
 
     pub fn countVec(data: []const []const u8) Limit {
@@ -929,9 +479,9 @@ pub const Clock = enum {
             };
         }
 
-        pub fn compare(lhs: Clock.Timestamp, op: std.math.CompareOperator, rhs: Clock.Timestamp) bool {
+        pub fn compare(lhs: Clock.Timestamp, op: math.CompareOperator, rhs: Clock.Timestamp) bool {
             assert(lhs.clock == rhs.clock);
-            return std.math.compare(lhs.raw.nanoseconds, op, rhs.raw.nanoseconds);
+            return math.compare(lhs.raw.nanoseconds, op, rhs.raw.nanoseconds);
         }
     };
 
@@ -996,7 +546,7 @@ pub const Duration = struct {
     nanoseconds: i96,
 
     pub const zero: Duration = .{ .nanoseconds = 0 };
-    pub const max: Duration = .{ .nanoseconds = std.math.maxInt(i96) };
+    pub const max: Duration = .{ .nanoseconds = math.maxInt(i96) };
 
     pub fn fromNanoseconds(x: i96) Duration {
         return .{ .nanoseconds = x };
@@ -1652,7 +1202,7 @@ pub const Event = enum(u32) {
     pub fn set(e: *Event, io: Io) void {
         switch (@atomicRmw(Event, e, .Xchg, .is_set, .release)) {
             .unset, .is_set => {},
-            .waiting => io.futexWake(Event, e, std.math.maxInt(u32)),
+            .waiting => io.futexWake(Event, e, math.maxInt(u32)),
         }
     }
 
-- 
2.54.0


From 0a0ecc4fb132d086c0f816a304a9fd8fde4a803e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 7 Jan 2026 18:38:19 -0800
Subject: [PATCH 102/499] std.Io: proof-of-concept "operations" API

This commit shows a proof-of-concept direction for std.Io.VTable to go,
which is to have general support for batching, timeouts, and
non-blocking.

I'm not sure if this is a good idea or not so I'm putting it up for
scrutiny.

This commit introduces `std.Io.operate`, `std.Io.Operation`, and
implements it experimentally for `FileReadStreaming`.

In `std.Io.Threaded`, the implementation is based on poll().

This commit shows how it can be used in `std.process.run` to collect
both stdout and stderr in a single-threaded program using
`std.Threaded.Io`.

It also demonstrates how to upgrade code that was previously using
`std.Io.poll` (*not* integrated with the interface!) using concurrency.
This may not be ideal since it makes the build runner no longer support
single-threaded mode. There is still a needed abstraction for
conveniently reading multiple File streams concurrently without
io.concurrent, but this commit demonstrates that such an API can be
built on top of the new `std.Io.operate` functionality.
---
 lib/std/Build/Step.zig     |  47 ++++++++++-----
 lib/std/Io.zig             |  36 ++++++++++-
 lib/std/Io/File.zig        |   8 ++-
 lib/std/Io/File/Reader.zig |   4 +-
 lib/std/Io/Reader.zig      |  21 +++++++
 lib/std/Io/Threaded.zig    |  87 ++++++++++++++++++++++++++-
 lib/std/process.zig        |  23 ++++++--
 lib/std/process/Child.zig  | 118 ++++++++++++++++++++++---------------
 8 files changed, 272 insertions(+), 72 deletions(-)

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 24e00bea5ed8629d0fbd2580169687ad0274ba10..bacc81cbfabe24938358d75653019443c892f03c 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -381,10 +381,15 @@ pub fn addError(step: *Step, comptime fmt: []const u8, args: anytype) error{OutO
 
 pub const ZigProcess = struct {
     child: std.process.Child,
-    poller: Io.Poller(StreamEnum),
     progress_ipc_fd: if (std.Progress.have_ipc) ?std.posix.fd_t else void,
 
     pub const StreamEnum = enum { stdout, stderr };
+
+    pub fn deinit(zp: *ZigProcess, gpa: Allocator, io: Io) void {
+        _ = gpa;
+        zp.child.kill(io);
+        zp.* = undefined;
+    }
 };
 
 /// Assumes that argv contains `--listen=-` and that the process being spawned
@@ -459,14 +464,10 @@ pub fn evalZigProcess(
 
     zp.* = .{
         .child = zp.child,
-        .poller = Io.poll(gpa, ZigProcess.StreamEnum, .{
-            .stdout = zp.child.stdout.?,
-            .stderr = zp.child.stderr.?,
-        }),
         .progress_ipc_fd = if (std.Progress.have_ipc) prog_node.getIpcFd() else {},
     };
     if (watch) s.setZigProcess(zp);
-    defer if (!watch) zp.poller.deinit();
+    defer if (!watch) zp.deinit(gpa, io);
 
     const result = try zigProcessUpdate(s, zp, watch, web_server, gpa);
 
@@ -526,6 +527,9 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     const arena = b.allocator;
     const io = b.graph.io;
 
+    var stderr_task = try io.concurrent(readStreamAlloc, .{ gpa, io, zp.child.stderr.?, .unlimited });
+    defer if (stderr_task.cancel(io)) |slice| gpa.free(slice) else |_| {};
+
     var timer = try std.time.Timer.start();
 
     try sendMessage(io, zp.child.stdin.?, .update);
@@ -533,14 +537,18 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
 
     var result: ?Path = null;
 
-    const stdout = zp.poller.reader(.stdout);
+    var stdout_buffer: [512]u8 = undefined;
+    var stdout_reader: Io.File.Reader = .initStreaming(zp.child.stdout.?, io, &stdout_buffer);
+    const stdout = &stdout_reader.interface;
 
-    poll: while (true) {
+    var body_buffer: std.ArrayList(u8) = .empty;
+
+    while (true) {
         const Header = std.zig.Server.Message.Header;
-        while (stdout.buffered().len < @sizeOf(Header)) if (!try zp.poller.poll()) break :poll;
-        const header = stdout.takeStruct(Header, .little) catch unreachable;
-        while (stdout.buffered().len < header.bytes_len) if (!try zp.poller.poll()) break :poll;
-        const body = stdout.take(header.bytes_len) catch unreachable;
+        const header = try stdout.takeStruct(Header, .little);
+        body_buffer.clearRetainingCapacity();
+        try stdout.appendExact(gpa, &body_buffer, header.bytes_len);
+        const body = body_buffer.items;
         switch (header.tag) {
             .zig_version => {
                 if (!std.mem.eql(u8, builtin.zig_version_string, body)) {
@@ -553,11 +561,11 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
             .error_bundle => {
                 s.result_error_bundle = try std.zig.Server.allocErrorBundle(gpa, body);
                 // This message indicates the end of the update.
-                if (watch) break :poll;
+                if (watch) break;
             },
             .emit_digest => {
                 const EmitDigest = std.zig.Server.Message.EmitDigest;
-                const emit_digest = @as(*align(1) const EmitDigest, @ptrCast(body));
+                const emit_digest: *align(1) const EmitDigest = @ptrCast(body);
                 s.result_cached = emit_digest.flags.cache_hit;
                 const digest = body[@sizeOf(EmitDigest)..][0..Cache.bin_digest_len];
                 result = .{
@@ -631,7 +639,8 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
 
     s.result_duration_ns = timer.read();
 
-    const stderr_contents = try zp.poller.toOwnedSlice(.stderr);
+    const stderr_contents = try stderr_task.await(io);
+    defer gpa.free(stderr_contents);
     if (stderr_contents.len > 0) {
         try s.result_error_msgs.append(arena, try arena.dupe(u8, stderr_contents));
     }
@@ -639,6 +648,14 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     return result;
 }
 
+fn readStreamAlloc(gpa: Allocator, io: Io, file: Io.File, limit: Io.Limit) ![]u8 {
+    var file_reader: Io.File.Reader = .initStreaming(file, io, &.{});
+    return file_reader.interface.allocRemaining(gpa, limit) catch |err| switch (err) {
+        error.ReadFailed => return file_reader.err.?,
+        else => |e| return e,
+    };
+}
+
 pub fn getZigProcess(s: *Step) ?*ZigProcess {
     return switch (s.id) {
         .compile => s.cast(Compile).?.zig_process,
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 506203418fe49264546d9d400912fafa220c923f..3663e9b8d7279747c022e291e08a908bd2cc9e5a 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -149,6 +149,8 @@ pub const VTable = struct {
     futexWaitUncancelable: *const fn (?*anyopaque, ptr: *const u32, expected: u32) void,
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
 
+    operate: *const fn (?*anyopaque, []Operation, n_wait: usize, Timeout) OperateError!void,
+
     dirCreateDir: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirError!void,
     dirCreateDirPath: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus,
     dirCreateDirPathOpen: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions, Dir.OpenOptions) Dir.CreateDirPathOpenError!Dir,
@@ -184,8 +186,6 @@ pub const VTable = struct {
     fileWriteFileStreaming: *const fn (?*anyopaque, File, header: []const u8, *Io.File.Reader, Io.Limit) File.Writer.WriteFileError!usize,
     fileWriteFilePositional: *const fn (?*anyopaque, File, header: []const u8, *Io.File.Reader, Io.Limit, offset: u64) File.WriteFilePositionalError!usize,
     /// Returns 0 on end of stream.
-    fileReadStreaming: *const fn (?*anyopaque, File, data: []const []u8) File.Reader.Error!usize,
-    /// Returns 0 on end of stream.
     fileReadPositional: *const fn (?*anyopaque, File, data: []const []u8, offset: u64) File.ReadPositionalError!usize,
     fileSeekBy: *const fn (?*anyopaque, File, relative_offset: i64) File.SeekError!void,
     fileSeekTo: *const fn (?*anyopaque, File, absolute_offset: u64) File.SeekError!void,
@@ -252,6 +252,38 @@ pub const VTable = struct {
     netLookup: *const fn (?*anyopaque, net.HostName, *Queue(net.HostName.LookupResult), net.HostName.LookupOptions) net.HostName.LookupError!void,
 };
 
+pub const Operation = union(enum) {
+    noop,
+    file_read_streaming: FileReadStreaming,
+
+    pub const FileReadStreaming = struct {
+        file: File,
+        data: []const []u8,
+        /// Causes `result` to return `error.WouldBlock` instead of blocking.
+        nonblocking: bool = false,
+        /// Returns 0 on end of stream.
+        result: File.Reader.Error!usize,
+    };
+};
+
+pub const OperateError = error{ Canceled, Timeout };
+
+/// Performs all `operations` in a non-deterministic order. Returns after all
+/// `operations` have been attempted. The degree to which the operations are
+/// performed concurrently is determined by the `Io` implementation.
+///
+/// `n_wait` is an amount of operations between `0` and `operations.len` that
+/// determines how many attempted operations must complete before `operate`
+/// returns. Operation completion is defined by returning a value other than
+/// `error.WouldBlock`. If the operation cannot return `error.WouldBlock`, it
+/// always counts as completing.
+///
+/// In the event `error.Canceled` is returned, any number of `operations` may
+/// still have been completed successfully.
+pub fn operate(io: Io, operations: []Operation, n_wait: usize, timeout: Timeout) OperateError!void {
+    return io.vtable.operate(io.userdata, operations, n_wait, timeout);
+}
+
 pub const Limit = enum(usize) {
     nothing = 0,
     unlimited = math.maxInt(usize),
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index e537755a3365de8bab78d79fb55a40da0c33fe03..303cb43908bf5d65c900c3601b51be0626e436f0 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -554,7 +554,13 @@ pub fn setTimestampsNow(file: File, io: Io) SetTimestampsError!void {
 /// See also:
 /// * `reader`
 pub fn readStreaming(file: File, io: Io, buffer: []const []u8) Reader.Error!usize {
-    return io.vtable.fileReadStreaming(io.userdata, file, buffer);
+    var operation: Io.Operation = .{ .file_read_streaming = .{
+        .file = file,
+        .data = buffer,
+        .result = undefined,
+    } };
+    io.vtable.operate(io.userdata, (&operation)[0..1], 1, .none) catch unreachable;
+    return operation.file_read_streaming.result;
 }
 
 pub const ReadPositionalError = error{
diff --git a/lib/std/Io/File/Reader.zig b/lib/std/Io/File/Reader.zig
index 2e0e192cb2326bd62eecbfaac6d30ade3ba81f18..d3d1c05e3f30edf81614e0109239cb547668043a 100644
--- a/lib/std/Io/File/Reader.zig
+++ b/lib/std/Io/File/Reader.zig
@@ -300,7 +300,7 @@ fn readVecStreaming(r: *Reader, data: [][]u8) Io.Reader.Error!usize {
     const dest_n, const data_size = try r.interface.writableVector(&iovecs_buffer, data);
     const dest = iovecs_buffer[0..dest_n];
     assert(dest[0].len > 0);
-    const n = io.vtable.fileReadStreaming(io.userdata, r.file, dest) catch |err| {
+    const n = r.file.readStreaming(io, dest) catch |err| {
         r.err = err;
         return error.ReadFailed;
     };
@@ -355,7 +355,7 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
                 const dest_n, const data_size = try r.interface.writableVector(&iovecs_buffer, &data);
                 const dest = iovecs_buffer[0..dest_n];
                 assert(dest[0].len > 0);
-                const n = io.vtable.fileReadStreaming(io.userdata, file, dest) catch |err| {
+                const n = file.readStreaming(io, dest) catch |err| {
                     r.err = err;
                     return error.ReadFailed;
                 };
diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig
index a2b70afc67db4edc9c1a3afed0eb0fe79737d471..9c5c762844c0f1e296fbd389ed016ebb991abfcf 100644
--- a/lib/std/Io/Reader.zig
+++ b/lib/std/Io/Reader.zig
@@ -315,6 +315,27 @@ pub fn allocRemainingAlignedSentinel(
     }
 }
 
+pub const AppendExactError = Allocator.Error || Error;
+
+/// Transfers exactly `n` bytes from the reader to the `ArrayList`.
+///
+/// See also:
+/// * `appendRemaining`
+pub fn appendExact(
+    r: *Reader,
+    gpa: Allocator,
+    list: *ArrayList(u8),
+    n: usize,
+) AppendExactError!void {
+    try list.ensureUnusedCapacity(gpa, n);
+    var a = std.Io.Writer.Allocating.fromArrayList(gpa, list);
+    defer list.* = a.toArrayList();
+    streamExact(r, &a.writer, n) catch |err| switch (err) {
+        error.ReadFailed, error.EndOfStream => |e| return e,
+        error.WriteFailed => unreachable,
+    };
+}
+
 /// Transfers all bytes from the current position to the end of the stream, up
 /// to `limit`, appending them to `list`.
 ///
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 4fd2ab170355613846117d199054457d52dffb27..3710527f47cc14b5ff7f80dc7fb31c132f5082fb 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1586,6 +1586,8 @@ pub fn io(t: *Threaded) Io {
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
 
+            .operate = operate,
+
             .dirCreateDir = dirCreateDir,
             .dirCreateDirPath = dirCreateDirPath,
             .dirCreateDirPathOpen = dirCreateDirPathOpen,
@@ -1620,7 +1622,6 @@ pub fn io(t: *Threaded) Io {
             .fileWritePositional = fileWritePositional,
             .fileWriteFileStreaming = fileWriteFileStreaming,
             .fileWriteFilePositional = fileWriteFilePositional,
-            .fileReadStreaming = fileReadStreaming,
             .fileReadPositional = fileReadPositional,
             .fileSeekBy = fileSeekBy,
             .fileSeekTo = fileSeekTo,
@@ -1746,6 +1747,8 @@ pub fn ioBasic(t: *Threaded) Io {
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
 
+            .operate = operate,
+
             .dirCreateDir = dirCreateDir,
             .dirCreateDirPath = dirCreateDirPath,
             .dirCreateDirPathOpen = dirCreateDirPathOpen,
@@ -1780,7 +1783,6 @@ pub fn ioBasic(t: *Threaded) Io {
             .fileWritePositional = fileWritePositional,
             .fileWriteFileStreaming = fileWriteFileStreaming,
             .fileWriteFilePositional = fileWriteFilePositional,
-            .fileReadStreaming = fileReadStreaming,
             .fileReadPositional = fileReadPositional,
             .fileSeekBy = fileSeekBy,
             .fileSeekTo = fileSeekTo,
@@ -2447,6 +2449,87 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
     Thread.futexWake(ptr, max_waiters);
 }
 
+fn operate(userdata: ?*anyopaque, operations: []Io.Operation, n_wait: usize, timeout: Io.Timeout) Io.OperateError!void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    const t_io = ioBasic(t);
+
+    if (is_windows) @panic("TODO");
+
+    const deadline = timeout.toDeadline(t_io) catch |err| switch (err) {
+        error.UnsupportedClock, error.Unexpected => null,
+    };
+
+    var poll_buffer: [100]posix.pollfd = undefined;
+    var map_buffer: [poll_buffer.len]u8 = undefined; // poll_buffer index to operations index
+    var poll_i: usize = 0;
+    var completed: usize = 0;
+
+    // Put all the file reads with nonblocking enabled into the poll set.
+    if (operations.len > poll_buffer.len) @panic("TODO");
+
+    // TODO if any operation is canceled, cancel the rest
+
+    for (operations, 0..) |*operation, operation_index| switch (operation.*) {
+        .noop => continue,
+        .file_read_streaming => |*o| {
+            if (o.nonblocking) {
+                o.result = error.WouldBlock;
+                poll_buffer[poll_i] = .{
+                    .fd = o.file.handle,
+                    .events = posix.POLL.IN,
+                    .revents = undefined,
+                };
+                map_buffer[poll_i] = @intCast(operation_index);
+                poll_i += 1;
+            } else {
+                o.result = fileReadStreaming(o.file, o.data);
+                completed += 1;
+            }
+        },
+    };
+
+    if (poll_i == 0) {
+        @branchHint(.likely);
+        return;
+    }
+
+    const max_poll_ms = std.math.maxInt(i32);
+
+    while (completed < n_wait) {
+        const timeout_ms: i32 = if (deadline) |d| t: {
+            const duration = d.durationFromNow(t_io) catch @panic("TODO make this unreachable");
+            if (duration.raw.nanoseconds <= 0) return error.Timeout;
+            break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
+        } else -1;
+        const syscall = try Syscall.start();
+        const poll_rc = posix.system.poll(&poll_buffer, poll_i, timeout_ms);
+        syscall.finish();
+        switch (posix.errno(poll_rc)) {
+            .SUCCESS => {
+                if (poll_rc == 0) {
+                    // Although spurious timeouts are OK, when no deadline
+                    // is passed we must not return `error.Timeout`.
+                    if (deadline == null) continue;
+                    return error.Timeout;
+                }
+                for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, operation_index| {
+                    if (poll_fd.revents == 0) continue;
+                    poll_fd.fd = -1; // Disarm this operation.
+                    switch (operations[operation_index]) {
+                        .noop => unreachable,
+                        .file_read_streaming => |*o| {
+                            o.result = fileReadStreaming(o.file, o.data);
+                            completed += 1;
+                        },
+                    }
+                }
+            },
+            .INTR => continue,
+            else => @panic("TODO handle unexpected error from poll()"),
+        }
+    }
+}
+
 const dirCreateDir = switch (native_os) {
     .windows => dirCreateDirWindows,
     .wasi => dirCreateDirWasi,
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 8395882c167cbe0149f081cd7fb4af413ec24e08..10bcc7649740b82baf6bd492ed99d93f38e35e37 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -454,13 +454,17 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
 }
 
 pub const RunError = CurrentPathError || posix.ReadError || SpawnError || posix.PollError || error{
-    StdoutStreamTooLong,
-    StderrStreamTooLong,
+    StreamTooLong,
 };
 
 pub const RunOptions = struct {
     argv: []const []const u8,
-    max_output_bytes: usize = 50 * 1024,
+    stderr_limit: Io.Limit = .unlimited,
+    stdout_limit: Io.Limit = .unlimited,
+    /// How many bytes to initially allocate for stderr.
+    stderr_reserve_amount: usize = 1,
+    /// How many bytes to initially allocate for stdout.
+    stdout_reserve_amount: usize = 1,
 
     /// Set to change the current working directory when spawning the child process.
     cwd: ?[]const u8 = null,
@@ -486,6 +490,7 @@ pub const RunOptions = struct {
     create_no_window: bool = true,
     /// Darwin-only. Disable ASLR for the child process.
     disable_aslr: bool = false,
+    timeout: Io.Timeout = .none,
 };
 
 pub const RunResult = struct {
@@ -518,7 +523,17 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
     var stderr: std.ArrayList(u8) = .empty;
     defer stderr.deinit(gpa);
 
-    try child.collectOutput(gpa, &stdout, &stderr, options.max_output_bytes);
+    try stdout.ensureUnusedCapacity(gpa, options.stdout_reserve_amount);
+    try stderr.ensureUnusedCapacity(gpa, options.stderr_reserve_amount);
+
+    try child.collectOutput(io, .{
+        .allocator = gpa,
+        .stdout = &stdout,
+        .stderr = &stderr,
+        .stdout_limit = options.stdout_limit,
+        .stderr_limit = options.stderr_limit,
+        .timeout = options.timeout,
+    });
 
     const term = try child.wait(io);
 
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 17e15f208da5fbb7155ada08fe2a9006127be258..6675c7bbe76e4df3712ba524f7919b0db2aa2e8a 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -9,7 +9,6 @@ const process = std.process;
 const File = std.Io.File;
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
-const ArrayList = std.ArrayList;
 
 pub const Id = switch (native_os) {
     .windows => std.os.windows.HANDLE,
@@ -126,53 +125,80 @@ pub fn wait(child: *Child, io: Io) WaitError!Term {
     return io.vtable.childWait(io.userdata, child);
 }
 
-/// Collect the output from the process's stdout and stderr. Will return once all output
-/// has been collected. This does not mean that the process has ended. `wait` should still
-/// be called to wait for and clean up the process.
+pub const CollectOutputError = error{
+    Timeout,
+    StreamTooLong,
+} || Allocator.Error || Io.File.Reader.Error;
+
+pub const CollectOutputOptions = struct {
+    stdout: *std.ArrayList(u8),
+    stderr: *std.ArrayList(u8),
+    /// Used for `stdout` and `stderr`. If not provided, only the existing
+    /// capacity will be used.
+    allocator: ?Allocator = null,
+    stdout_limit: Io.Limit = .unlimited,
+    stderr_limit: Io.Limit = .unlimited,
+    timeout: Io.Timeout = .none,
+};
+
+/// Collect the output from the process's stdout and stderr. Will return once
+/// all output has been collected. This does not mean that the process has
+/// ended. `wait` should still be called to wait for and clean up the process.
 ///
 /// The process must have been started with stdout and stderr set to
 /// `process.SpawnOptions.StdIo.pipe`.
-pub fn collectOutput(
-    child: *const Child,
-    /// Used for `stdout` and `stderr`.
-    allocator: Allocator,
-    stdout: *ArrayList(u8),
-    stderr: *ArrayList(u8),
-    max_output_bytes: usize,
-) !void {
-    var poller = std.Io.poll(allocator, enum { stdout, stderr }, .{
-        .stdout = child.stdout.?,
-        .stderr = child.stderr.?,
-    });
-    defer poller.deinit();
-
-    const stdout_r = poller.reader(.stdout);
-    stdout_r.buffer = stdout.allocatedSlice();
-    stdout_r.seek = 0;
-    stdout_r.end = stdout.items.len;
-
-    const stderr_r = poller.reader(.stderr);
-    stderr_r.buffer = stderr.allocatedSlice();
-    stderr_r.seek = 0;
-    stderr_r.end = stderr.items.len;
-
-    defer {
-        stdout.* = .{
-            .items = stdout_r.buffer[0..stdout_r.end],
-            .capacity = stdout_r.buffer.len,
-        };
-        stderr.* = .{
-            .items = stderr_r.buffer[0..stderr_r.end],
-            .capacity = stderr_r.buffer.len,
-        };
-        stdout_r.buffer = &.{};
-        stderr_r.buffer = &.{};
-    }
-
-    while (try poller.poll()) {
-        if (stdout_r.bufferedLen() > max_output_bytes)
-            return error.StdoutStreamTooLong;
-        if (stderr_r.bufferedLen() > max_output_bytes)
-            return error.StderrStreamTooLong;
+pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions) CollectOutputError!void {
+    const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
+    const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
+    const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
+    var dones: [2]bool = .{ false, false };
+    var reads: [2]Io.Operation = undefined;
+    var vecs: [2][1][]u8 = undefined;
+    while (true) {
+        for (&reads, &lists, &files, dones, &vecs) |*read, list, file, done, *vec| {
+            if (done) {
+                read.* = .noop;
+                continue;
+            }
+            if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
+            const cap = list.unusedCapacitySlice();
+            if (cap.len == 0) return error.StreamTooLong;
+            vec[0] = cap;
+            read.* = .{ .file_read_streaming = .{
+                .file = file,
+                .data = vec,
+                .nonblocking = true,
+                .result = undefined,
+            } };
+        }
+        var all_done = true;
+        var any_canceled = false;
+        var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
+        const op_result = io.vtable.operate(io.userdata, &reads, 1, options.timeout);
+        for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
+            if (done.*) continue;
+            const n = read.file_read_streaming.result catch |err| switch (err) {
+                error.Canceled => {
+                    any_canceled = true;
+                    continue;
+                },
+                error.WouldBlock => continue,
+                else => |e| {
+                    other_err = e;
+                    continue;
+                },
+            };
+            if (n == 0) {
+                done.* = true;
+            } else {
+                all_done = false;
+            }
+            list.items.len += n;
+            if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
+        }
+        if (any_canceled) return error.Canceled;
+        try op_result; // could be error.Canceled
+        try other_err;
+        if (all_done) return;
     }
 }
-- 
2.54.0


From 05064e128137e6c7b1afe6d648b33ebfa60877f2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 12:55:38 -0800
Subject: [PATCH 103/499] std.Io: simplify operate function

- no timeout
- no n_wait
- infallible
---
 lib/std/Io.zig            | 19 +++---------
 lib/std/Io/File.zig       |  2 +-
 lib/std/Io/Threaded.zig   | 63 ++++++++++++++++++---------------------
 lib/std/process.zig       |  2 --
 lib/std/process/Child.zig |  4 +--
 5 files changed, 35 insertions(+), 55 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 3663e9b8d7279747c022e291e08a908bd2cc9e5a..c52b51e00a4dc996e9f59a04b499449cc732d96a 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -149,7 +149,7 @@ pub const VTable = struct {
     futexWaitUncancelable: *const fn (?*anyopaque, ptr: *const u32, expected: u32) void,
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
 
-    operate: *const fn (?*anyopaque, []Operation, n_wait: usize, Timeout) OperateError!void,
+    operate: *const fn (?*anyopaque, []Operation) void,
 
     dirCreateDir: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirError!void,
     dirCreateDirPath: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus,
@@ -266,22 +266,11 @@ pub const Operation = union(enum) {
     };
 };
 
-pub const OperateError = error{ Canceled, Timeout };
-
 /// Performs all `operations` in a non-deterministic order. Returns after all
-/// `operations` have been attempted. The degree to which the operations are
+/// `operations` have been completed. The degree to which the operations are
 /// performed concurrently is determined by the `Io` implementation.
-///
-/// `n_wait` is an amount of operations between `0` and `operations.len` that
-/// determines how many attempted operations must complete before `operate`
-/// returns. Operation completion is defined by returning a value other than
-/// `error.WouldBlock`. If the operation cannot return `error.WouldBlock`, it
-/// always counts as completing.
-///
-/// In the event `error.Canceled` is returned, any number of `operations` may
-/// still have been completed successfully.
-pub fn operate(io: Io, operations: []Operation, n_wait: usize, timeout: Timeout) OperateError!void {
-    return io.vtable.operate(io.userdata, operations, n_wait, timeout);
+pub fn operate(io: Io, operations: []Operation) void {
+    return io.vtable.operate(io.userdata, operations);
 }
 
 pub const Limit = enum(usize) {
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index 303cb43908bf5d65c900c3601b51be0626e436f0..16663eb48488dc8d229a53ffee243e2d294e4b62 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -559,7 +559,7 @@ pub fn readStreaming(file: File, io: Io, buffer: []const []u8) Reader.Error!usiz
         .data = buffer,
         .result = undefined,
     } };
-    io.vtable.operate(io.userdata, (&operation)[0..1], 1, .none) catch unreachable;
+    io.vtable.operate(io.userdata, (&operation)[0..1]);
     return operation.file_read_streaming.result;
 }
 
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 3710527f47cc14b5ff7f80dc7fb31c132f5082fb..8ee79a7ae360d18a5f9f57b672841bbe7cfee5e8 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2449,20 +2449,15 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
     Thread.futexWake(ptr, max_waiters);
 }
 
-fn operate(userdata: ?*anyopaque, operations: []Io.Operation, n_wait: usize, timeout: Io.Timeout) Io.OperateError!void {
+fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const t_io = ioBasic(t);
+    _ = t;
 
     if (is_windows) @panic("TODO");
 
-    const deadline = timeout.toDeadline(t_io) catch |err| switch (err) {
-        error.UnsupportedClock, error.Unexpected => null,
-    };
-
     var poll_buffer: [100]posix.pollfd = undefined;
     var map_buffer: [poll_buffer.len]u8 = undefined; // poll_buffer index to operations index
     var poll_i: usize = 0;
-    var completed: usize = 0;
 
     // Put all the file reads with nonblocking enabled into the poll set.
     if (operations.len > poll_buffer.len) @panic("TODO");
@@ -2483,7 +2478,6 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation, n_wait: usize, tim
                 poll_i += 1;
             } else {
                 o.result = fileReadStreaming(o.file, o.data);
-                completed += 1;
             }
         },
     };
@@ -2493,41 +2487,42 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation, n_wait: usize, tim
         return;
     }
 
-    const max_poll_ms = std.math.maxInt(i32);
-
-    while (completed < n_wait) {
-        const timeout_ms: i32 = if (deadline) |d| t: {
-            const duration = d.durationFromNow(t_io) catch @panic("TODO make this unreachable");
-            if (duration.raw.nanoseconds <= 0) return error.Timeout;
-            break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
-        } else -1;
-        const syscall = try Syscall.start();
-        const poll_rc = posix.system.poll(&poll_buffer, poll_i, timeout_ms);
-        syscall.finish();
-        switch (posix.errno(poll_rc)) {
-            .SUCCESS => {
-                if (poll_rc == 0) {
-                    // Although spurious timeouts are OK, when no deadline
-                    // is passed we must not return `error.Timeout`.
-                    if (deadline == null) continue;
-                    return error.Timeout;
-                }
-                for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, operation_index| {
-                    if (poll_fd.revents == 0) continue;
-                    poll_fd.fd = -1; // Disarm this operation.
+    while (true) {
+        const syscall = Syscall.start() catch |err| switch (err) {
+            error.Canceled => {
+                for (map_buffer[0..poll_i]) |operation_index| {
                     switch (operations[operation_index]) {
                         .noop => unreachable,
-                        .file_read_streaming => |*o| {
-                            o.result = fileReadStreaming(o.file, o.data);
-                            completed += 1;
-                        },
+                        inline else => |*o| o.result = error.Canceled,
                     }
                 }
+                return;
+            },
+        };
+        const poll_rc = posix.system.poll(&poll_buffer, poll_i, -1);
+        syscall.finish();
+        switch (posix.errno(poll_rc)) {
+            .SUCCESS => {
+                if (poll_rc == 0) {
+                    // Spurious timeout; handle same as INTR.
+                    continue;
+                }
+                break;
             },
             .INTR => continue,
             else => @panic("TODO handle unexpected error from poll()"),
         }
     }
+
+    for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, operation_index| {
+        if (poll_fd.revents == 0) continue;
+        switch (operations[operation_index]) {
+            .noop => unreachable,
+            .file_read_streaming => |*o| {
+                o.result = fileReadStreaming(o.file, o.data);
+            },
+        }
+    }
 }
 
 const dirCreateDir = switch (native_os) {
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 10bcc7649740b82baf6bd492ed99d93f38e35e37..4a021879a55f257a8b453182972be038aff77138 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -490,7 +490,6 @@ pub const RunOptions = struct {
     create_no_window: bool = true,
     /// Darwin-only. Disable ASLR for the child process.
     disable_aslr: bool = false,
-    timeout: Io.Timeout = .none,
 };
 
 pub const RunResult = struct {
@@ -532,7 +531,6 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
         .stderr = &stderr,
         .stdout_limit = options.stdout_limit,
         .stderr_limit = options.stderr_limit,
-        .timeout = options.timeout,
     });
 
     const term = try child.wait(io);
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 6675c7bbe76e4df3712ba524f7919b0db2aa2e8a..e541ca4e6534cadf6c5f1c68abd1564a21669ce3 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -138,7 +138,6 @@ pub const CollectOutputOptions = struct {
     allocator: ?Allocator = null,
     stdout_limit: Io.Limit = .unlimited,
     stderr_limit: Io.Limit = .unlimited,
-    timeout: Io.Timeout = .none,
 };
 
 /// Collect the output from the process's stdout and stderr. Will return once
@@ -174,7 +173,7 @@ pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions)
         var all_done = true;
         var any_canceled = false;
         var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
-        const op_result = io.vtable.operate(io.userdata, &reads, 1, options.timeout);
+        io.vtable.operate(io.userdata, &reads);
         for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
             if (done.*) continue;
             const n = read.file_read_streaming.result catch |err| switch (err) {
@@ -197,7 +196,6 @@ pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions)
             if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
         }
         if (any_canceled) return error.Canceled;
-        try op_result; // could be error.Canceled
         try other_err;
         if (all_done) return;
     }
-- 
2.54.0


From 93f5c99149948b104ab504eff3a171b6c1bff065 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 14:10:31 -0800
Subject: [PATCH 104/499] std.Io.Threaded.operate: handle cancelation and poll
 errors

---
 lib/std/Io/Threaded.zig | 49 +++++++++++++++++++++++++++++++----------
 1 file changed, 37 insertions(+), 12 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 8ee79a7ae360d18a5f9f57b672841bbe7cfee5e8..1f4bcf34787a144a8ead404fc7b64c85e92d5add 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1323,6 +1323,7 @@ fn waitForApcOrAlert() void {
 
 const max_iovecs_len = 8;
 const splat_buffer_size = 64;
+const poll_buffer_len = 100;
 const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
 
 comptime {
@@ -2455,15 +2456,13 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
 
     if (is_windows) @panic("TODO");
 
-    var poll_buffer: [100]posix.pollfd = undefined;
-    var map_buffer: [poll_buffer.len]u8 = undefined; // poll_buffer index to operations index
+    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
+    var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
     var poll_i: usize = 0;
 
     // Put all the file reads with nonblocking enabled into the poll set.
     if (operations.len > poll_buffer.len) @panic("TODO");
 
-    // TODO if any operation is canceled, cancel the rest
-
     for (operations, 0..) |*operation, operation_index| switch (operation.*) {
         .noop => continue,
         .file_read_streaming => |*o| {
@@ -2477,7 +2476,13 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
                 map_buffer[poll_i] = @intCast(operation_index);
                 poll_i += 1;
             } else {
-                o.result = fileReadStreaming(o.file, o.data);
+                o.result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+                    error.Canceled => {
+                        setOperationsCanceled(operations[operation_index..]);
+                        return;
+                    },
+                    else => err,
+                };
             }
         },
     };
@@ -2490,12 +2495,7 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
     while (true) {
         const syscall = Syscall.start() catch |err| switch (err) {
             error.Canceled => {
-                for (map_buffer[0..poll_i]) |operation_index| {
-                    switch (operations[operation_index]) {
-                        .noop => unreachable,
-                        inline else => |*o| o.result = error.Canceled,
-                    }
-                }
+                setAllOperationsError(operations, map_buffer[0..poll_i], error.Canceled);
                 return;
             },
         };
@@ -2510,7 +2510,14 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
                 break;
             },
             .INTR => continue,
-            else => @panic("TODO handle unexpected error from poll()"),
+            .NOMEM => {
+                setAllOperationsError(operations, map_buffer[0..poll_i], error.SystemResources);
+                return;
+            },
+            else => {
+                setAllOperationsError(operations, map_buffer[0..poll_i], error.Unexpected);
+                return;
+            },
         }
     }
 
@@ -2525,6 +2532,24 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
     }
 }
 
+fn setAllOperationsError(
+    operations: []Io.Operation,
+    map: []const u8,
+    err: error{ Canceled, SystemResources, Unexpected },
+) void {
+    for (map) |operation_index| switch (operations[operation_index]) {
+        .noop => unreachable,
+        inline else => |*o| o.result = err,
+    };
+}
+
+fn setOperationsCanceled(operations: []Io.Operation) void {
+    for (operations) |*op| switch (op.*) {
+        .noop => unreachable,
+        inline else => |*o| o.result = error.Canceled,
+    };
+}
+
 const dirCreateDir = switch (native_os) {
     .windows => dirCreateDirWindows,
     .wasi => dirCreateDirWasi,
-- 
2.54.0


From 6a7fe61d74f80456b32cb46ef21715bbffaf49a7 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 15:07:03 -0800
Subject: [PATCH 105/499] std.Io.Threaded.operate: handle poll buffer exceeded

---
 lib/std/Io/Threaded.zig | 139 ++++++++++++++++++++--------------------
 1 file changed, 71 insertions(+), 68 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1f4bcf34787a144a8ead404fc7b64c85e92d5add..e58d923793ef84b22e2132255604dd09633d5364 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2458,81 +2458,84 @@ fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
 
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
-    var poll_i: usize = 0;
+    var operation_index: usize = 0;
 
-    // Put all the file reads with nonblocking enabled into the poll set.
-    if (operations.len > poll_buffer.len) @panic("TODO");
-
-    for (operations, 0..) |*operation, operation_index| switch (operation.*) {
-        .noop => continue,
-        .file_read_streaming => |*o| {
-            if (o.nonblocking) {
-                o.result = error.WouldBlock;
-                poll_buffer[poll_i] = .{
-                    .fd = o.file.handle,
-                    .events = posix.POLL.IN,
-                    .revents = undefined,
-                };
-                map_buffer[poll_i] = @intCast(operation_index);
-                poll_i += 1;
-            } else {
-                o.result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
-                    error.Canceled => {
-                        setOperationsCanceled(operations[operation_index..]);
-                        return;
-                    },
-                    else => err,
-                };
+    while (operation_index < operations.len) {
+        var poll_i: usize = 0;
+        while (operation_index < operations.len) : (operation_index += 1) {
+            switch (operations[operation_index]) {
+                .noop => continue,
+                .file_read_streaming => |*o| {
+                    if (o.nonblocking) {
+                        o.result = error.WouldBlock;
+                        poll_buffer[poll_i] = .{
+                            .fd = o.file.handle,
+                            .events = posix.POLL.IN,
+                            .revents = 0,
+                        };
+                        if (map_buffer.len - poll_i == 0) break;
+                        map_buffer[poll_i] = @intCast(operation_index);
+                        poll_i += 1;
+                    } else {
+                        o.result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+                            error.Canceled => {
+                                setOperationsError(operations[operation_index..], error.Canceled);
+                                return;
+                            },
+                            else => err,
+                        };
+                    }
+                },
             }
-        },
-    };
-
-    if (poll_i == 0) {
-        @branchHint(.likely);
-        return;
-    }
+        }
 
-    while (true) {
-        const syscall = Syscall.start() catch |err| switch (err) {
-            error.Canceled => {
-                setAllOperationsError(operations, map_buffer[0..poll_i], error.Canceled);
-                return;
-            },
-        };
-        const poll_rc = posix.system.poll(&poll_buffer, poll_i, -1);
-        syscall.finish();
-        switch (posix.errno(poll_rc)) {
-            .SUCCESS => {
-                if (poll_rc == 0) {
-                    // Spurious timeout; handle same as INTR.
-                    continue;
-                }
-                break;
-            },
-            .INTR => continue,
-            .NOMEM => {
-                setAllOperationsError(operations, map_buffer[0..poll_i], error.SystemResources);
-                return;
-            },
-            else => {
-                setAllOperationsError(operations, map_buffer[0..poll_i], error.Unexpected);
-                return;
-            },
+        if (poll_i == 0) {
+            @branchHint(.likely);
+            return;
         }
-    }
 
-    for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, operation_index| {
-        if (poll_fd.revents == 0) continue;
-        switch (operations[operation_index]) {
-            .noop => unreachable,
-            .file_read_streaming => |*o| {
-                o.result = fileReadStreaming(o.file, o.data);
-            },
+        while (true) {
+            const syscall = Syscall.start() catch |err| switch (err) {
+                error.Canceled => {
+                    setPollOperationsError(operations, map_buffer[0..poll_i], error.Canceled);
+                    setOperationsError(operations[operation_index..], error.Canceled);
+                    return;
+                },
+            };
+            const poll_rc = posix.system.poll(&poll_buffer, poll_i, -1);
+            syscall.finish();
+            switch (posix.errno(poll_rc)) {
+                .SUCCESS => {
+                    if (poll_rc == 0) {
+                        // Spurious timeout; handle same as INTR.
+                        continue;
+                    }
+                    for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, i| {
+                        if (poll_fd.revents == 0) continue;
+                        switch (operations[i]) {
+                            .noop => unreachable,
+                            .file_read_streaming => |*o| {
+                                o.result = fileReadStreaming(o.file, o.data);
+                            },
+                        }
+                    }
+                    break;
+                },
+                .INTR => continue,
+                .NOMEM => {
+                    setPollOperationsError(operations, map_buffer[0..poll_i], error.SystemResources);
+                    break;
+                },
+                else => {
+                    setPollOperationsError(operations, map_buffer[0..poll_i], error.Unexpected);
+                    break;
+                },
+            }
         }
     }
 }
 
-fn setAllOperationsError(
+fn setPollOperationsError(
     operations: []Io.Operation,
     map: []const u8,
     err: error{ Canceled, SystemResources, Unexpected },
@@ -2543,10 +2546,10 @@ fn setAllOperationsError(
     };
 }
 
-fn setOperationsCanceled(operations: []Io.Operation) void {
+fn setOperationsError(operations: []Io.Operation, err: error{ Canceled, SystemResources, Unexpected }) void {
     for (operations) |*op| switch (op.*) {
         .noop => unreachable,
-        inline else => |*o| o.result = error.Canceled,
+        inline else => |*o| o.result = err,
     };
 }
 
-- 
2.54.0


From e0d06b40e3681cc9aad09764987d079fb0f9e0fa Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 15:20:21 -0800
Subject: [PATCH 106/499] std.Io.Threaded: set poll_buffer_len to 32

reasoning is that polling with large amount of operations will be rarely
done with std.Io.Threaded. However this still provides the opportunity
to provide concurrency for any real world use cases that need it.
---
 lib/std/Io/Threaded.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index e58d923793ef84b22e2132255604dd09633d5364..55b3596ee79b47343ea391462488683aa734f418 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1323,7 +1323,7 @@ fn waitForApcOrAlert() void {
 
 const max_iovecs_len = 8;
 const splat_buffer_size = 64;
-const poll_buffer_len = 100;
+const poll_buffer_len = 32;
 const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
 
 comptime {
-- 
2.54.0


From b996675dcf5533e506eee0ed44c64aebab69af6e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 16:36:18 -0800
Subject: [PATCH 107/499] fix error set

---
 lib/std/process/Child.zig | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index e541ca4e6534cadf6c5f1c68abd1564a21669ce3..fc31014520a93b791f10048d17d2ef6046440c66 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -125,10 +125,7 @@ pub fn wait(child: *Child, io: Io) WaitError!Term {
     return io.vtable.childWait(io.userdata, child);
 }
 
-pub const CollectOutputError = error{
-    Timeout,
-    StreamTooLong,
-} || Allocator.Error || Io.File.Reader.Error;
+pub const CollectOutputError = error{StreamTooLong} || Allocator.Error || Io.File.Reader.Error;
 
 pub const CollectOutputOptions = struct {
     stdout: *std.ArrayList(u8),
-- 
2.54.0


From 87408f8addac76b8b4811fbfede30a1c0f637a8f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 16:55:26 -0800
Subject: [PATCH 108/499] std.process.Child: rewrite using concurrent

I plan to immediately revert this, but here's a commit for posterity
---
 lib/std/process.zig       |  1 +
 lib/std/process/Child.zig | 81 ++++++++++++---------------------------
 2 files changed, 26 insertions(+), 56 deletions(-)

diff --git a/lib/std/process.zig b/lib/std/process.zig
index 4a021879a55f257a8b453182972be038aff77138..b203838e3fc2aa4a9293cc54a6a192bdd9991fc6 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -455,6 +455,7 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
 
 pub const RunError = CurrentPathError || posix.ReadError || SpawnError || posix.PollError || error{
     StreamTooLong,
+    ConcurrencyUnavailable,
 };
 
 pub const RunOptions = struct {
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index fc31014520a93b791f10048d17d2ef6046440c66..e64f6106fa99fb6468aa4c0c398933f245f1c083 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -125,14 +125,15 @@ pub fn wait(child: *Child, io: Io) WaitError!Term {
     return io.vtable.childWait(io.userdata, child);
 }
 
-pub const CollectOutputError = error{StreamTooLong} || Allocator.Error || Io.File.Reader.Error;
+pub const CollectOutputError = error{
+    StreamTooLong,
+    ConcurrencyUnavailable,
+} || Allocator.Error || Io.File.Reader.Error;
 
 pub const CollectOutputOptions = struct {
     stdout: *std.ArrayList(u8),
     stderr: *std.ArrayList(u8),
-    /// Used for `stdout` and `stderr`. If not provided, only the existing
-    /// capacity will be used.
-    allocator: ?Allocator = null,
+    allocator: Allocator,
     stdout_limit: Io.Limit = .unlimited,
     stderr_limit: Io.Limit = .unlimited,
 };
@@ -144,56 +145,24 @@ pub const CollectOutputOptions = struct {
 /// The process must have been started with stdout and stderr set to
 /// `process.SpawnOptions.StdIo.pipe`.
 pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions) CollectOutputError!void {
-    const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
-    const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
-    const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
-    var dones: [2]bool = .{ false, false };
-    var reads: [2]Io.Operation = undefined;
-    var vecs: [2][1][]u8 = undefined;
-    while (true) {
-        for (&reads, &lists, &files, dones, &vecs) |*read, list, file, done, *vec| {
-            if (done) {
-                read.* = .noop;
-                continue;
-            }
-            if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
-            const cap = list.unusedCapacitySlice();
-            if (cap.len == 0) return error.StreamTooLong;
-            vec[0] = cap;
-            read.* = .{ .file_read_streaming = .{
-                .file = file,
-                .data = vec,
-                .nonblocking = true,
-                .result = undefined,
-            } };
-        }
-        var all_done = true;
-        var any_canceled = false;
-        var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
-        io.vtable.operate(io.userdata, &reads);
-        for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
-            if (done.*) continue;
-            const n = read.file_read_streaming.result catch |err| switch (err) {
-                error.Canceled => {
-                    any_canceled = true;
-                    continue;
-                },
-                error.WouldBlock => continue,
-                else => |e| {
-                    other_err = e;
-                    continue;
-                },
-            };
-            if (n == 0) {
-                done.* = true;
-            } else {
-                all_done = false;
-            }
-            list.items.len += n;
-            if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
-        }
-        if (any_canceled) return error.Canceled;
-        try other_err;
-        if (all_done) return;
-    }
+    var stdout = try io.concurrent(collectStream, .{
+        io, options.allocator, child.stdout.?, options.stdout, options.stdout_limit,
+    });
+    defer stdout.cancel(io) catch {};
+
+    var stderr = try io.concurrent(collectStream, .{
+        io, options.allocator, child.stderr.?, options.stderr, options.stderr_limit,
+    });
+    defer stderr.cancel(io) catch {};
+
+    try stdout.await(io);
+    try stderr.await(io);
+}
+
+fn collectStream(io: Io, gpa: Allocator, file: File, list: *std.ArrayList(u8), limit: Io.Limit) CollectOutputError!void {
+    var fr = file.readerStreaming(io, &.{});
+    fr.interface.appendRemaining(gpa, list, limit) catch |err| switch (err) {
+        error.ReadFailed => return fr.err.?,
+        else => |e| return e,
+    };
 }
-- 
2.54.0


From e2a266e744adaa7ee84a512fdf4cea44686ca0b6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 8 Jan 2026 16:55:51 -0800
Subject: [PATCH 109/499] Revert "std.process.Child: rewrite using concurrent"

This reverts commit 76e1ba8f490812c6e2ebf6f6becd89a71275d21e.
---
 lib/std/process.zig       |  1 -
 lib/std/process/Child.zig | 81 +++++++++++++++++++++++++++------------
 2 files changed, 56 insertions(+), 26 deletions(-)

diff --git a/lib/std/process.zig b/lib/std/process.zig
index b203838e3fc2aa4a9293cc54a6a192bdd9991fc6..4a021879a55f257a8b453182972be038aff77138 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -455,7 +455,6 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
 
 pub const RunError = CurrentPathError || posix.ReadError || SpawnError || posix.PollError || error{
     StreamTooLong,
-    ConcurrencyUnavailable,
 };
 
 pub const RunOptions = struct {
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index e64f6106fa99fb6468aa4c0c398933f245f1c083..fc31014520a93b791f10048d17d2ef6046440c66 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -125,15 +125,14 @@ pub fn wait(child: *Child, io: Io) WaitError!Term {
     return io.vtable.childWait(io.userdata, child);
 }
 
-pub const CollectOutputError = error{
-    StreamTooLong,
-    ConcurrencyUnavailable,
-} || Allocator.Error || Io.File.Reader.Error;
+pub const CollectOutputError = error{StreamTooLong} || Allocator.Error || Io.File.Reader.Error;
 
 pub const CollectOutputOptions = struct {
     stdout: *std.ArrayList(u8),
     stderr: *std.ArrayList(u8),
-    allocator: Allocator,
+    /// Used for `stdout` and `stderr`. If not provided, only the existing
+    /// capacity will be used.
+    allocator: ?Allocator = null,
     stdout_limit: Io.Limit = .unlimited,
     stderr_limit: Io.Limit = .unlimited,
 };
@@ -145,24 +144,56 @@ pub const CollectOutputOptions = struct {
 /// The process must have been started with stdout and stderr set to
 /// `process.SpawnOptions.StdIo.pipe`.
 pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions) CollectOutputError!void {
-    var stdout = try io.concurrent(collectStream, .{
-        io, options.allocator, child.stdout.?, options.stdout, options.stdout_limit,
-    });
-    defer stdout.cancel(io) catch {};
-
-    var stderr = try io.concurrent(collectStream, .{
-        io, options.allocator, child.stderr.?, options.stderr, options.stderr_limit,
-    });
-    defer stderr.cancel(io) catch {};
-
-    try stdout.await(io);
-    try stderr.await(io);
-}
-
-fn collectStream(io: Io, gpa: Allocator, file: File, list: *std.ArrayList(u8), limit: Io.Limit) CollectOutputError!void {
-    var fr = file.readerStreaming(io, &.{});
-    fr.interface.appendRemaining(gpa, list, limit) catch |err| switch (err) {
-        error.ReadFailed => return fr.err.?,
-        else => |e| return e,
-    };
+    const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
+    const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
+    const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
+    var dones: [2]bool = .{ false, false };
+    var reads: [2]Io.Operation = undefined;
+    var vecs: [2][1][]u8 = undefined;
+    while (true) {
+        for (&reads, &lists, &files, dones, &vecs) |*read, list, file, done, *vec| {
+            if (done) {
+                read.* = .noop;
+                continue;
+            }
+            if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
+            const cap = list.unusedCapacitySlice();
+            if (cap.len == 0) return error.StreamTooLong;
+            vec[0] = cap;
+            read.* = .{ .file_read_streaming = .{
+                .file = file,
+                .data = vec,
+                .nonblocking = true,
+                .result = undefined,
+            } };
+        }
+        var all_done = true;
+        var any_canceled = false;
+        var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
+        io.vtable.operate(io.userdata, &reads);
+        for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
+            if (done.*) continue;
+            const n = read.file_read_streaming.result catch |err| switch (err) {
+                error.Canceled => {
+                    any_canceled = true;
+                    continue;
+                },
+                error.WouldBlock => continue,
+                else => |e| {
+                    other_err = e;
+                    continue;
+                },
+            };
+            if (n == 0) {
+                done.* = true;
+            } else {
+                all_done = false;
+            }
+            list.items.len += n;
+            if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
+        }
+        if (any_canceled) return error.Canceled;
+        try other_err;
+        if (all_done) return;
+    }
 }
-- 
2.54.0


From 642f329ac91d69d02588ba15714edafb09e709da Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 9 Jan 2026 15:06:50 -0800
Subject: [PATCH 110/499] std.Io: exploring a different batch API proposal

---
 lib/std/Io.zig            |  95 ++++++++++++--
 lib/std/Io/File.zig       |   5 +-
 lib/std/Io/Threaded.zig   | 256 +++++++++++++++++++++++++-------------
 lib/std/process.zig       |  16 +--
 lib/std/process/Child.zig |  92 +++++++-------
 5 files changed, 312 insertions(+), 152 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index c52b51e00a4dc996e9f59a04b499449cc732d96a..d916bb699582ccc976007a2952a76da5e7956b54 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -149,7 +149,10 @@ pub const VTable = struct {
     futexWaitUncancelable: *const fn (?*anyopaque, ptr: *const u32, expected: u32) void,
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
 
-    operate: *const fn (?*anyopaque, []Operation) void,
+    batch: *const fn (?*anyopaque, []Operation) ConcurrentError!void,
+    batchSubmit: *const fn (?*anyopaque, *Batch) void,
+    batchWait: *const fn (?*anyopaque, *Batch, resubmissions: []const usize, Timeout) Batch.WaitError!usize,
+    batchCancel: *const fn (?*anyopaque, *Batch) void,
 
     dirCreateDir: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirError!void,
     dirCreateDirPath: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus,
@@ -253,26 +256,96 @@ pub const VTable = struct {
 };
 
 pub const Operation = union(enum) {
-    noop,
+    noop: Noop,
     file_read_streaming: FileReadStreaming,
 
+    pub const Noop = struct {
+        reserved: [2]usize,
+        status: Status(void) = .{ .result = {} },
+    };
+
+    /// Returns 0 on end of stream.
     pub const FileReadStreaming = struct {
         file: File,
         data: []const []u8,
-        /// Causes `result` to return `error.WouldBlock` instead of blocking.
-        nonblocking: bool = false,
-        /// Returns 0 on end of stream.
-        result: File.Reader.Error!usize,
+        status: Status(File.Reader.Error!usize) = .{ .unstarted = {} },
     };
+
+    pub fn Status(Result: type) type {
+        return union {
+            unstarted: void,
+            pending: usize,
+            result: Result,
+        };
+    }
 };
 
-/// Performs all `operations` in a non-deterministic order. Returns after all
-/// `operations` have been completed. The degree to which the operations are
-/// performed concurrently is determined by the `Io` implementation.
-pub fn operate(io: Io, operations: []Operation) void {
-    return io.vtable.operate(io.userdata, operations);
+/// Performs all `operations` in an unspecified order, concurrently.
+///
+/// Returns after all `operations` have been completed. If the operations could
+/// not be completed concurrently, returns `error.ConcurrencyUnavailable`.
+///
+/// With this API, it is rare for concurrency to not be available. Even a
+/// single-threaded `Io` implementation can, for example, take advantage of
+/// poll() to implement this. Note that poll() is fallible however.
+///
+/// If `operations.len` is one, `error.ConcurrencyUnavailable` is unreachable.
+///
+/// On entry, all operations must already have `.status = .unstarted` except
+/// noops must have `.status = .{ .result = {} }`, to safety check the state
+/// transitions.
+///
+/// On return, all operations have `.status = .{ .result = ... }`.
+pub fn batch(io: Io, operations: []Operation) ConcurrentError!void {
+    return io.vtable.batch(io.userdata, operations);
+}
+
+/// Performs one `Operation`.
+pub fn operate(io: Io, operation: *Operation) void {
+    return io.vtable.batch(io.userdata, (operation)[0..1]) catch unreachable;
 }
 
+/// Submits many operations together without waiting for all of them to
+/// complete.
+///
+/// This is a low-level abstraction based on `Operation`. For a higher
+/// level API that operates on `Future`, see `Select`.
+pub const Batch = struct {
+    operations: []Operation,
+    index: usize,
+    reserved: ?*anyopaque,
+
+    pub fn init(operations: []Operation) Batch {
+        return .{ .operations = operations, .index = 0, .reserved = null };
+    }
+
+    /// Submits all non-noop `operations`.
+    pub fn submit(b: *Batch, io: Io) void {
+        return io.vtable.batchSubmit(io.userdata, b);
+    }
+
+    pub const WaitError = ConcurrentError || Cancelable || Timeout.Error;
+
+    /// Resubmits the previously completed or noop-initialized `operations` at
+    /// indexes given by `resubmissions`. This set of indexes typically will be empty
+    /// on the first call to `await` since all operations have already been
+    /// submitted via `async`.
+    ///
+    /// Returns the index of a completed `Operation`, or `operations.len` if
+    /// all operations are completed.
+    ///
+    /// When `error.Canceled` is returned, all operations have already completed.
+    pub fn wait(b: *Batch, io: Io, resubmissions: []const usize, timeout: Timeout) WaitError!usize {
+        return io.vtable.batchWait(io.userdata, b, resubmissions, timeout);
+    }
+
+    /// Returns after all `operations` have completed. Each operation
+    /// independently may or may not have been canceled.
+    pub fn cancel(b: *Batch, io: Io) void {
+        return io.vtable.batchCancel(io.userdata, b);
+    }
+};
+
 pub const Limit = enum(usize) {
     nothing = 0,
     unlimited = math.maxInt(usize),
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index 16663eb48488dc8d229a53ffee243e2d294e4b62..f27f249975ea85e9e2917fed2b0a2408406e9eaa 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -557,10 +557,9 @@ pub fn readStreaming(file: File, io: Io, buffer: []const []u8) Reader.Error!usiz
     var operation: Io.Operation = .{ .file_read_streaming = .{
         .file = file,
         .data = buffer,
-        .result = undefined,
     } };
-    io.vtable.operate(io.userdata, (&operation)[0..1]);
-    return operation.file_read_streaming.result;
+    io.operate(&operation);
+    return operation.file_read_streaming.status.result;
 }
 
 pub const ReadPositionalError = error{
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 55b3596ee79b47343ea391462488683aa734f418..0eda4e8fdc73d10cc7dded447ecc506e6d7250d5 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1587,7 +1587,10 @@ pub fn io(t: *Threaded) Io {
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
 
-            .operate = operate,
+            .batch = batch,
+            .batchSubmit = batchSubmit,
+            .batchWait = batchWait,
+            .batchCancel = batchCancel,
 
             .dirCreateDir = dirCreateDir,
             .dirCreateDirPath = dirCreateDirPath,
@@ -1748,7 +1751,10 @@ pub fn ioBasic(t: *Threaded) Io {
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
 
-            .operate = operate,
+            .batch = batch,
+            .batchSubmit = batchSubmit,
+            .batchWait = batchWait,
+            .batchCancel = batchCancel,
 
             .dirCreateDir = dirCreateDir,
             .dirCreateDirPath = dirCreateDirPath,
@@ -2450,107 +2456,187 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
     Thread.futexWake(ptr, max_waiters);
 }
 
-fn operate(userdata: ?*anyopaque, operations: []Io.Operation) void {
+fn batchSubmit(userdata: ?*anyopaque, b: *Io.Batch) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
+    _ = b;
+    return;
+}
+
+fn operate(op: *Io.Operation) void {
+    switch (op.*) {
+        .noop => {},
+        .file_read_streaming => |*o| o.status = .{ .result = fileReadStreaming(o.file, o.data) },
+    }
+}
 
+fn batchWait(
+    userdata: ?*anyopaque,
+    b: *Io.Batch,
+    resubmissions: []const usize,
+    timeout: Io.Timeout,
+) Io.Batch.WaitError!usize {
+    _ = resubmissions;
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    const operations = b.operations;
+    if (operations.len == 1) {
+        operate(&operations[0]);
+        return b.operations.len;
+    }
     if (is_windows) @panic("TODO");
 
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
-    var operation_index: usize = 0;
-
-    while (operation_index < operations.len) {
-        var poll_i: usize = 0;
-        while (operation_index < operations.len) : (operation_index += 1) {
-            switch (operations[operation_index]) {
-                .noop => continue,
-                .file_read_streaming => |*o| {
-                    if (o.nonblocking) {
-                        o.result = error.WouldBlock;
-                        poll_buffer[poll_i] = .{
-                            .fd = o.file.handle,
-                            .events = posix.POLL.IN,
-                            .revents = 0,
-                        };
-                        if (map_buffer.len - poll_i == 0) break;
-                        map_buffer[poll_i] = @intCast(operation_index);
-                        poll_i += 1;
-                    } else {
-                        o.result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
-                            error.Canceled => {
-                                setOperationsError(operations[operation_index..], error.Canceled);
-                                return;
-                            },
-                            else => err,
-                        };
-                    }
-                },
-            }
-        }
+    var poll_i: usize = 0;
 
-        if (poll_i == 0) {
-            @branchHint(.likely);
-            return;
+    for (operations, 0..) |*op, operation_index| switch (op.*) {
+        .noop => continue,
+        .file_read_streaming => |*o| {
+            if (poll_buffer.len - poll_i == 0) return error.ConcurrencyUnavailable;
+            poll_buffer[poll_i] = .{
+                .fd = o.file.handle,
+                .events = posix.POLL.IN,
+                .revents = 0,
+            };
+            map_buffer[poll_i] = @intCast(operation_index);
+            poll_i += 1;
+        },
+    };
+
+    if (poll_i == 0) return operations.len;
+
+    const t_io = ioBasic(t);
+    const deadline = timeout.toDeadline(t_io) catch return error.UnsupportedClock;
+    const max_poll_ms = std.math.maxInt(i32);
+
+    while (true) {
+        const timeout_ms: i32 = if (deadline) |d| t: {
+            const duration = d.durationFromNow(t_io) catch return error.UnsupportedClock;
+            if (duration.raw.nanoseconds <= 0) return error.Timeout;
+            break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
+        } else -1;
+        const syscall = try Syscall.start();
+        const rc = posix.system.poll(&poll_buffer, poll_i, timeout_ms);
+        syscall.finish();
+        switch (posix.errno(rc)) {
+            .SUCCESS => {
+                if (rc == 0) {
+                    // Although spurious timeouts are OK, when no deadline is
+                    // passed we must not return `error.Timeout`.
+                    if (deadline == null) continue;
+                    return error.Timeout;
+                }
+                for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, i| {
+                    if (poll_fd.revents == 0) continue;
+                    operate(&operations[i]);
+                    return i;
+                }
+            },
+            .INTR => continue,
+            else => return error.ConcurrencyUnavailable,
         }
+    }
+}
+
+fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+    _ = b;
+    return;
+}
+
+fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+
+    if (operations.len == 1) {
+        @branchHint(.likely);
+        return operate(&operations[0]);
+    }
 
-        while (true) {
-            const syscall = Syscall.start() catch |err| switch (err) {
-                error.Canceled => {
-                    setPollOperationsError(operations, map_buffer[0..poll_i], error.Canceled);
-                    setOperationsError(operations[operation_index..], error.Canceled);
-                    return;
-                },
+    if (is_windows) @panic("TODO");
+
+    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
+    var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
+    var poll_i: usize = 0;
+
+    for (operations, 0..) |*op, operation_index| switch (op.*) {
+        .noop => continue,
+        .file_read_streaming => |*o| {
+            if (poll_buffer.len - poll_i == 0) return error.ConcurrencyUnavailable;
+            poll_buffer[poll_i] = .{
+                .fd = o.file.handle,
+                .events = posix.POLL.IN,
+                .revents = 0,
             };
-            const poll_rc = posix.system.poll(&poll_buffer, poll_i, -1);
-            syscall.finish();
-            switch (posix.errno(poll_rc)) {
-                .SUCCESS => {
-                    if (poll_rc == 0) {
-                        // Spurious timeout; handle same as INTR.
-                        continue;
-                    }
-                    for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, i| {
-                        if (poll_fd.revents == 0) continue;
-                        switch (operations[i]) {
-                            .noop => unreachable,
-                            .file_read_streaming => |*o| {
-                                o.result = fileReadStreaming(o.file, o.data);
-                            },
-                        }
-                    }
-                    break;
-                },
-                .INTR => continue,
-                .NOMEM => {
-                    setPollOperationsError(operations, map_buffer[0..poll_i], error.SystemResources);
-                    break;
-                },
-                else => {
-                    setPollOperationsError(operations, map_buffer[0..poll_i], error.Unexpected);
-                    break;
-                },
-            }
+            map_buffer[poll_i] = @intCast(operation_index);
+            poll_i += 1;
+        },
+    };
+
+    const polls = poll_buffer[0..poll_i];
+    const map = map_buffer[0..poll_i];
+
+    var pending = poll_i;
+    while (pending > 1) {
+        const syscall = Syscall.start() catch |err| switch (err) {
+            error.Canceled => {
+                if (!setOperationsError(operations, polls, map, error.Canceled))
+                    recancelInner();
+                return;
+            },
+        };
+        const rc = posix.system.poll(polls.ptr, polls.len, -1);
+        syscall.finish();
+        switch (posix.errno(rc)) {
+            .SUCCESS => {
+                if (rc == 0) {
+                    // Spurious timeout; handle the same as INTR.
+                    continue;
+                }
+                for (polls, map) |*poll_fd, i| {
+                    if (poll_fd.revents == 0) continue;
+                    poll_fd.fd = -1;
+                    pending -= 1;
+                    operate(&operations[i]);
+                }
+            },
+            .INTR => continue,
+            .NOMEM => {
+                assert(setOperationsError(operations, polls, map, error.SystemResources));
+                return;
+            },
+            else => {
+                assert(setOperationsError(operations, polls, map, error.Unexpected));
+                return;
+            },
         }
     }
+
+    if (pending == 1) for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, i| {
+        if (poll_fd.fd == -1) continue;
+        operate(&operations[i]);
+    };
 }
 
-fn setPollOperationsError(
+fn setOperationsError(
     operations: []Io.Operation,
+    polls: []const posix.pollfd,
     map: []const u8,
     err: error{ Canceled, SystemResources, Unexpected },
-) void {
-    for (map) |operation_index| switch (operations[operation_index]) {
-        .noop => unreachable,
-        inline else => |*o| o.result = err,
-    };
-}
-
-fn setOperationsError(operations: []Io.Operation, err: error{ Canceled, SystemResources, Unexpected }) void {
-    for (operations) |*op| switch (op.*) {
-        .noop => unreachable,
-        inline else => |*o| o.result = err,
-    };
+) bool {
+    var marked = false;
+    for (polls, map) |*poll_fd, i| {
+        if (poll_fd.fd == -1) continue;
+        switch (operations[i]) {
+            .noop => unreachable,
+            inline else => |*o| {
+                o.status = .{ .result = err };
+                marked = true;
+            },
+        }
+    }
+    return marked;
 }
 
 const dirCreateDir = switch (native_os) {
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 4a021879a55f257a8b453182972be038aff77138..b5de41f5d88551df6a7c8a7af173b104838511d3 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -453,9 +453,7 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
     return io.vtable.processSpawnPath(io.userdata, dir, options);
 }
 
-pub const RunError = CurrentPathError || posix.ReadError || SpawnError || posix.PollError || error{
-    StreamTooLong,
-};
+pub const RunError = SpawnError || Child.CollectOutputError;
 
 pub const RunOptions = struct {
     argv: []const []const u8,
@@ -535,13 +533,15 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
 
     const term = try child.wait(io);
 
-    const owned_stdout = try stdout.toOwnedSlice(gpa);
-    errdefer gpa.free(owned_stdout);
-    const owned_stderr = try stderr.toOwnedSlice(gpa);
+    const stdout_slice = try stdout.toOwnedSlice(gpa);
+    errdefer gpa.free(stdout_slice);
+
+    const stderr_slice = try stderr.toOwnedSlice(gpa);
+    errdefer gpa.free(stderr_slice);
 
     return .{
-        .stdout = owned_stdout,
-        .stderr = owned_stderr,
+        .stdout = stdout_slice,
+        .stderr = stderr_slice,
         .term = term,
     };
 }
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index fc31014520a93b791f10048d17d2ef6046440c66..9d31b7708099cf2b2c5b2810f9ec107f8d13f098 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -125,7 +125,9 @@ pub fn wait(child: *Child, io: Io) WaitError!Term {
     return io.vtable.childWait(io.userdata, child);
 }
 
-pub const CollectOutputError = error{StreamTooLong} || Allocator.Error || Io.File.Reader.Error;
+pub const CollectOutputError = error{
+    StreamTooLong,
+} || Io.ConcurrentError || Allocator.Error || Io.File.Reader.Error || Io.Timeout.Error;
 
 pub const CollectOutputOptions = struct {
     stdout: *std.ArrayList(u8),
@@ -135,6 +137,7 @@ pub const CollectOutputOptions = struct {
     allocator: ?Allocator = null,
     stdout_limit: Io.Limit = .unlimited,
     stderr_limit: Io.Limit = .unlimited,
+    timeout: Io.Timeout = .none,
 };
 
 /// Collect the output from the process's stdout and stderr. Will return once
@@ -144,56 +147,55 @@ pub const CollectOutputOptions = struct {
 /// The process must have been started with stdout and stderr set to
 /// `process.SpawnOptions.StdIo.pipe`.
 pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions) CollectOutputError!void {
-    const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
     const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
     const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
-    var dones: [2]bool = .{ false, false };
-    var reads: [2]Io.Operation = undefined;
+
+    if (options.allocator) |gpa| {
+        for (lists) |list| try list.ensureUnusedCapacity(gpa, 1);
+    } else {
+        for (lists) |list| {
+            if (list.unusedCapacitySlice().len == 0)
+                return error.StreamTooLong;
+        }
+    }
+
     var vecs: [2][1][]u8 = undefined;
-    while (true) {
-        for (&reads, &lists, &files, dones, &vecs) |*read, list, file, done, *vec| {
-            if (done) {
-                read.* = .noop;
-                continue;
-            }
+    for (lists, &vecs) |list, *vec|
+        vec[0] = list.unusedCapacitySlice();
+
+    var operations: [2]Io.Operation = .{
+        .{ .file_read_streaming = .{
+            .file = child.stdout.?,
+            .data = &vecs[0],
+        } },
+        .{ .file_read_streaming = .{
+            .file = child.stderr.?,
+            .data = &vecs[1],
+        } },
+    };
+
+    var batch: Io.Batch = .init(&operations);
+    batch.submit(io);
+    defer batch.cancel(io);
+
+    var pending = operations.len;
+    var retry_index: ?usize = null;
+    while (pending > 0) {
+        const resubmissions: []const usize = if (retry_index) |i| &.{i} else &.{};
+        const index = try batch.wait(io, resubmissions, options.timeout);
+        const n = try operations[index].file_read_streaming.status.result;
+        if (n == 0) {
+            pending -= 1;
+        } else {
+            retry_index = index;
+            const list = lists[index];
+            const limit = limits[index];
+            list.items.len += n;
+            if (list.items.len >= @intFromEnum(limit)) return error.StreamTooLong;
             if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
             const cap = list.unusedCapacitySlice();
             if (cap.len == 0) return error.StreamTooLong;
-            vec[0] = cap;
-            read.* = .{ .file_read_streaming = .{
-                .file = file,
-                .data = vec,
-                .nonblocking = true,
-                .result = undefined,
-            } };
+            vecs[index][0] = cap;
         }
-        var all_done = true;
-        var any_canceled = false;
-        var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
-        io.vtable.operate(io.userdata, &reads);
-        for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
-            if (done.*) continue;
-            const n = read.file_read_streaming.result catch |err| switch (err) {
-                error.Canceled => {
-                    any_canceled = true;
-                    continue;
-                },
-                error.WouldBlock => continue,
-                else => |e| {
-                    other_err = e;
-                    continue;
-                },
-            };
-            if (n == 0) {
-                done.* = true;
-            } else {
-                all_done = false;
-            }
-            list.items.len += n;
-            if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
-        }
-        if (any_canceled) return error.Canceled;
-        try other_err;
-        if (all_done) return;
     }
 }
-- 
2.54.0


From 23d25dbb9e4e469eb2e59d50bd888b7a61ffb876 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 9 Jan 2026 19:21:59 -0800
Subject: [PATCH 111/499] std.process.Child.collectOutput: change back to other
 impl

this one avoids calling poll() more than necessary
---
 lib/std/Io.zig            |  2 +-
 lib/std/process/Child.zig | 86 +++++++++++++++++++--------------------
 2 files changed, 43 insertions(+), 45 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index d916bb699582ccc976007a2952a76da5e7956b54..2f34dc07e4c4100adc2a521d0f830fb56642882a 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -260,7 +260,7 @@ pub const Operation = union(enum) {
     file_read_streaming: FileReadStreaming,
 
     pub const Noop = struct {
-        reserved: [2]usize,
+        reserved: [2]usize = .{ 0, 0 },
         status: Status(void) = .{ .result = {} },
     };
 
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 9d31b7708099cf2b2c5b2810f9ec107f8d13f098..364c52446f8691a3e7505e89a40ca514125c5e59 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -137,7 +137,6 @@ pub const CollectOutputOptions = struct {
     allocator: ?Allocator = null,
     stdout_limit: Io.Limit = .unlimited,
     stderr_limit: Io.Limit = .unlimited,
-    timeout: Io.Timeout = .none,
 };
 
 /// Collect the output from the process's stdout and stderr. Will return once
@@ -147,55 +146,54 @@ pub const CollectOutputOptions = struct {
 /// The process must have been started with stdout and stderr set to
 /// `process.SpawnOptions.StdIo.pipe`.
 pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions) CollectOutputError!void {
+    const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
     const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
     const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
-
-    if (options.allocator) |gpa| {
-        for (lists) |list| try list.ensureUnusedCapacity(gpa, 1);
-    } else {
-        for (lists) |list| {
-            if (list.unusedCapacitySlice().len == 0)
-                return error.StreamTooLong;
-        }
-    }
-
+    var dones: [2]bool = .{ false, false };
+    var reads: [2]Io.Operation = undefined;
     var vecs: [2][1][]u8 = undefined;
-    for (lists, &vecs) |list, *vec|
-        vec[0] = list.unusedCapacitySlice();
-
-    var operations: [2]Io.Operation = .{
-        .{ .file_read_streaming = .{
-            .file = child.stdout.?,
-            .data = &vecs[0],
-        } },
-        .{ .file_read_streaming = .{
-            .file = child.stderr.?,
-            .data = &vecs[1],
-        } },
-    };
-
-    var batch: Io.Batch = .init(&operations);
-    batch.submit(io);
-    defer batch.cancel(io);
-
-    var pending = operations.len;
-    var retry_index: ?usize = null;
-    while (pending > 0) {
-        const resubmissions: []const usize = if (retry_index) |i| &.{i} else &.{};
-        const index = try batch.wait(io, resubmissions, options.timeout);
-        const n = try operations[index].file_read_streaming.status.result;
-        if (n == 0) {
-            pending -= 1;
-        } else {
-            retry_index = index;
-            const list = lists[index];
-            const limit = limits[index];
-            list.items.len += n;
-            if (list.items.len >= @intFromEnum(limit)) return error.StreamTooLong;
+    while (true) {
+        for (&reads, &lists, &files, dones, &vecs) |*read, list, file, done, *vec| {
+            if (done) {
+                read.* = .{ .noop = .{} };
+                continue;
+            }
             if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
             const cap = list.unusedCapacitySlice();
             if (cap.len == 0) return error.StreamTooLong;
-            vecs[index][0] = cap;
+            vec[0] = cap;
+            read.* = .{ .file_read_streaming = .{
+                .file = file,
+                .data = vec,
+            } };
         }
+        var all_done = true;
+        var any_canceled = false;
+        var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
+        try io.vtable.batch(io.userdata, &reads);
+        for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
+            if (done.*) continue;
+            const n = read.file_read_streaming.status.result catch |err| switch (err) {
+                error.Canceled => {
+                    any_canceled = true;
+                    continue;
+                },
+                error.WouldBlock => continue,
+                else => |e| {
+                    other_err = e;
+                    continue;
+                },
+            };
+            if (n == 0) {
+                done.* = true;
+            } else {
+                all_done = false;
+            }
+            list.items.len += n;
+            if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
+        }
+        if (any_canceled) return error.Canceled;
+        try other_err;
+        if (all_done) return;
     }
 }
-- 
2.54.0


From 0a379513afdf807c357993ac4508449ec933c55b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 9 Jan 2026 20:46:51 -0800
Subject: [PATCH 112/499] std.Io.Threaded: super broken Windows impl of batch

this is a cry for help
---
 lib/std/Io/Threaded.zig | 83 ++++++++++++++++++++++++++++++++---------
 1 file changed, 66 insertions(+), 17 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0eda4e8fdc73d10cc7dded447ecc506e6d7250d5..f7b4b73b33ae4150b612aba2b97cfc33230abc57 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2547,14 +2547,13 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
 
 fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
 
     if (operations.len == 1) {
         @branchHint(.likely);
         return operate(&operations[0]);
     }
 
-    if (is_windows) @panic("TODO");
+    if (is_windows) return batchWindows(t, operations);
 
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
@@ -2578,7 +2577,7 @@ fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!v
     const map = map_buffer[0..poll_i];
 
     var pending = poll_i;
-    while (pending > 1) {
+    while (pending > 0) {
         const syscall = Syscall.start() catch |err| switch (err) {
             error.Canceled => {
                 if (!setOperationsError(operations, polls, map, error.Canceled))
@@ -2589,17 +2588,11 @@ fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!v
         const rc = posix.system.poll(polls.ptr, polls.len, -1);
         syscall.finish();
         switch (posix.errno(rc)) {
-            .SUCCESS => {
-                if (rc == 0) {
-                    // Spurious timeout; handle the same as INTR.
-                    continue;
-                }
-                for (polls, map) |*poll_fd, i| {
-                    if (poll_fd.revents == 0) continue;
-                    poll_fd.fd = -1;
-                    pending -= 1;
-                    operate(&operations[i]);
-                }
+            .SUCCESS => for (polls, map) |*poll_fd, i| {
+                if (poll_fd.revents == 0) continue;
+                poll_fd.fd = -1;
+                pending -= 1;
+                operate(&operations[i]);
             },
             .INTR => continue,
             .NOMEM => {
@@ -2612,11 +2605,67 @@ fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!v
             },
         }
     }
+}
 
-    if (pending == 1) for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, i| {
-        if (poll_fd.fd == -1) continue;
-        operate(&operations[i]);
+fn batchWindows(t: *Threaded, operations: []Io.Operation) Io.ConcurrentError!void {
+    _ = t;
+    var overlapped_buffer: [poll_buffer_len]windows.OVERLAPPED = undefined;
+    var handles_buffer: [poll_buffer_len]windows.HANDLE = undefined;
+    var map_buffer: [poll_buffer_len]u8 = undefined; // handles_buffer index to operations index
+    var buffer_i: usize = 0;
+
+    for (operations, 0..) |*op, operation_index| switch (op.*) {
+        .noop => continue,
+        .file_read_streaming => |*o| {
+            if (handles_buffer.len - buffer_i == 0) return error.ConcurrencyUnavailable;
+
+            const overlapped = &overlapped_buffer[buffer_i];
+            overlapped.* = .{
+                .Internal = 0,
+                .InternalHigh = 0,
+                .DUMMYUNIONNAME = .{
+                    .DUMMYSTRUCTNAME = .{
+                        .Offset = 0,
+                        .OffsetHigh = 0,
+                    },
+                    .Pointer = null,
+                },
+                .hEvent = null,
+            };
+            var n: windows.DWORD = undefined;
+            const buf = o.data[0];
+            if (windows.kernel32.ReadFile(o.file.handle, buf.ptr, buf.len, &n, overlapped) == 0) {
+                @panic("TODO");
+            }
+            handles_buffer[buffer_i] = o.file.handle;
+            map_buffer[buffer_i] = @intCast(operation_index);
+            buffer_i += 1;
+        },
     };
+
+    const handles = handles_buffer[0..buffer_i];
+    const map = map_buffer[0..buffer_i];
+    var pending = buffer_i;
+
+    while (pending > 0) {
+        const syscall: Syscall = try .start();
+        const index = windows.WaitForMultipleObjectsEx(handles, false, windows.INFINITE, true);
+        syscall.finish();
+        var n: windows.DWORD = undefined;
+        if (0 == windows.kernel32.GetOverlappedResult(handles[index], overlapped_buffer[index], &n, 0)) {
+            switch (windows.GetLastError()) {
+                .BROKEN_PIPE => @panic("TODO"),
+                .OPERATION_ABORTED => @panic("TODO"),
+                else => @panic("TODO"),
+            }
+        } else switch (operations[map[index]]) {
+            .noop => unreachable,
+            .file_read_streaming => |*o| {
+                o.status = .{ .result = n };
+                pending -= 1;
+            },
+        }
+    }
 }
 
 fn setOperationsError(
-- 
2.54.0


From 8146ccfeccd17e6ee5adaa59112899a89ad409bd Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:34:36 -0500
Subject: [PATCH 113/499] Io: add ring to `Batch` API

---
 lib/std/Io.zig             | 171 ++++++++++++++++++++++++++-----------
 lib/std/Io/File.zig        |   2 +-
 lib/std/Io/File/Reader.zig |  22 +----
 lib/std/Io/Threaded.zig    | 151 +++++++++++++++++++++-----------
 lib/std/process/Child.zig  |  72 +++++++---------
 5 files changed, 259 insertions(+), 159 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 2f34dc07e4c4100adc2a521d0f830fb56642882a..b503979fda68d5db200da632970f114f40de819d 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -149,9 +149,8 @@ pub const VTable = struct {
     futexWaitUncancelable: *const fn (?*anyopaque, ptr: *const u32, expected: u32) void,
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
 
-    batch: *const fn (?*anyopaque, []Operation) ConcurrentError!void,
-    batchSubmit: *const fn (?*anyopaque, *Batch) void,
-    batchWait: *const fn (?*anyopaque, *Batch, resubmissions: []const usize, Timeout) Batch.WaitError!usize,
+    operate: *const fn (?*anyopaque, *Operation) Cancelable!void,
+    batchWait: *const fn (?*anyopaque, *Batch, Timeout) Batch.WaitError!void,
     batchCancel: *const fn (?*anyopaque, *Batch) void,
 
     dirCreateDir: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirError!void,
@@ -261,48 +260,50 @@ pub const Operation = union(enum) {
 
     pub const Noop = struct {
         reserved: [2]usize = .{ 0, 0 },
-        status: Status(void) = .{ .result = {} },
+        status: Status(void) = .{ .unstarted = {} },
     };
 
     /// Returns 0 on end of stream.
     pub const FileReadStreaming = struct {
         file: File,
         data: []const []u8,
-        status: Status(File.Reader.Error!usize) = .{ .unstarted = {} },
+        status: Status(Error!usize) = .{ .unstarted = {} },
+
+        pub const Error = error{
+            InputOutput,
+            SystemResources,
+            /// Trying to read a directory file descriptor as if it were a file.
+            IsDir,
+            BrokenPipe,
+            ConnectionResetByPeer,
+            /// File was not opened with read capability.
+            NotOpenForReading,
+            SocketUnconnected,
+            /// Non-blocking has been enabled, and reading from the file descriptor
+            /// would block.
+            WouldBlock,
+            /// In WASI, this error occurs when the file descriptor does
+            /// not hold the required rights to read from it.
+            AccessDenied,
+            /// Unable to read file due to lock. Depending on the `Io` implementation,
+            /// reading from a locked file may return this error, or may ignore the
+            /// lock.
+            LockViolation,
+        } || Io.UnexpectedError;
     };
 
     pub fn Status(Result: type) type {
         return union {
             unstarted: void,
-            pending: usize,
+            pending: *Batch,
             result: Result,
         };
     }
 };
 
-/// Performs all `operations` in an unspecified order, concurrently.
-///
-/// Returns after all `operations` have been completed. If the operations could
-/// not be completed concurrently, returns `error.ConcurrencyUnavailable`.
-///
-/// With this API, it is rare for concurrency to not be available. Even a
-/// single-threaded `Io` implementation can, for example, take advantage of
-/// poll() to implement this. Note that poll() is fallible however.
-///
-/// If `operations.len` is one, `error.ConcurrencyUnavailable` is unreachable.
-///
-/// On entry, all operations must already have `.status = .unstarted` except
-/// noops must have `.status = .{ .result = {} }`, to safety check the state
-/// transitions.
-///
-/// On return, all operations have `.status = .{ .result = ... }`.
-pub fn batch(io: Io, operations: []Operation) ConcurrentError!void {
-    return io.vtable.batch(io.userdata, operations);
-}
-
 /// Performs one `Operation`.
-pub fn operate(io: Io, operation: *Operation) void {
-    return io.vtable.batch(io.userdata, (operation)[0..1]) catch unreachable;
+pub fn operate(io: Io, operation: *Operation) Cancelable!void {
+    return io.vtable.operate(io.userdata, operation) catch unreachable;
 }
 
 /// Submits many operations together without waiting for all of them to
@@ -312,35 +313,107 @@ pub fn operate(io: Io, operation: *Operation) void {
 /// level API that operates on `Future`, see `Select`.
 pub const Batch = struct {
     operations: []Operation,
-    index: usize,
-    reserved: ?*anyopaque,
+    ring: [*]u32,
+    user: struct {
+        submit_tail: RingIndex,
+        complete_head: RingIndex,
+        complete_tail: RingIndex,
+    },
+    impl: struct {
+        submit_head: RingIndex,
+        submit_tail: RingIndex,
+        complete_tail: RingIndex,
+        reserved: ?*anyopaque,
+    },
 
-    pub fn init(operations: []Operation) Batch {
-        return .{ .operations = operations, .index = 0, .reserved = null };
-    }
+    pub const RingIndex = enum(u32) {
+        _,
 
-    /// Submits all non-noop `operations`.
-    pub fn submit(b: *Batch, io: Io) void {
-        return io.vtable.batchSubmit(io.userdata, b);
-    }
+        pub fn index(ri: RingIndex, len: u31) u31 {
+            const i = @intFromEnum(ri);
+            assert(i < @as(u32, len) * 2);
+            return @intCast(if (i < len) i else i - len);
+        }
+
+        pub fn prev(ri: RingIndex, len: u31) RingIndex {
+            const i = @intFromEnum(ri);
+            const double_len = @as(u32, len) * 2;
+            assert(i <= double_len);
+            return @enumFromInt((if (i > 0) i else double_len) - 1);
+        }
+
+        pub fn next(ri: RingIndex, len: u31) RingIndex {
+            const i = @intFromEnum(ri) + 1;
+            const double_len = @as(u32, len) * 2;
+            assert(i <= double_len);
+            return @enumFromInt(if (i < double_len) i else 0);
+        }
+    };
 
     pub const WaitError = ConcurrentError || Cancelable || Timeout.Error;
 
-    /// Resubmits the previously completed or noop-initialized `operations` at
-    /// indexes given by `resubmissions`. This set of indexes typically will be empty
-    /// on the first call to `await` since all operations have already been
-    /// submitted via `async`.
-    ///
-    /// Returns the index of a completed `Operation`, or `operations.len` if
-    /// all operations are completed.
+    pub fn init(operations: []Operation, ring: []u32) Batch {
+        const len: u31 = @intCast(operations.len);
+        assert(ring.len == len);
+        return .{
+            .operations = operations,
+            .ring = ring.ptr,
+            .user = .{
+                .submit_tail = @enumFromInt(0),
+                .complete_head = @enumFromInt(0),
+                .complete_tail = @enumFromInt(0),
+            },
+            .impl = .{
+                .submit_head = @enumFromInt(0),
+                .submit_tail = @enumFromInt(0),
+                .complete_tail = @enumFromInt(0),
+                .reserved = null,
+            },
+        };
+    }
+
+    /// Adds `b.operations[operation]` to the list of submitted operations
+    /// that will be performed when `wait` is called.
+    pub fn add(b: *Batch, operation: usize) void {
+        const tail = b.user.submit_tail;
+        const len: u31 = @intCast(b.operations.len);
+        b.user.submit_tail = tail.next(len);
+        b.ring[0..len][tail.index(len)] = @intCast(operation);
+    }
+
+    fn flush(b: *Batch) void {
+        @atomicStore(RingIndex, &b.impl.submit_tail, b.user.submit_tail, .release);
+    }
+
+    /// Returns `operation` such that `b.operations[operation]` has completed.
+    /// Returns `null` when `wait` should be called.
+    pub fn next(b: *Batch) ?u32 {
+        const head = b.user.complete_head;
+        if (head == b.user.complete_tail) {
+            @branchHint(.unlikely);
+            b.flush();
+            const tail = @atomicLoad(RingIndex, &b.impl.complete_tail, .acquire);
+            if (head == tail) {
+                @branchHint(.unlikely);
+                return null;
+            }
+            assert(head != tail);
+            b.user.complete_tail = tail;
+        }
+        const len: u31 = @intCast(b.operations.len);
+        b.user.complete_head = head.next(len);
+        return b.ring[0..len][head.index(len)];
+    }
+
+    /// Starts work on any submitted operations and returns when at least one has completeed.
     ///
-    /// When `error.Canceled` is returned, all operations have already completed.
-    pub fn wait(b: *Batch, io: Io, resubmissions: []const usize, timeout: Timeout) WaitError!usize {
-        return io.vtable.batchWait(io.userdata, b, resubmissions, timeout);
+    /// Returns `error.Timeout` if `timeout` expires first.
+    pub fn wait(b: *Batch, io: Io, timeout: Timeout) WaitError!void {
+        return io.vtable.batchWait(io.userdata, b, timeout);
     }
 
-    /// Returns after all `operations` have completed. Each operation
-    /// independently may or may not have been canceled.
+    /// Returns after all `operations` have completed. Operations which have not completed
+    /// after this function returns were successfully dropped and had no side effects.
     pub fn cancel(b: *Batch, io: Io) void {
         return io.vtable.batchCancel(io.userdata, b);
     }
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index f27f249975ea85e9e2917fed2b0a2408406e9eaa..cc7042d443d0ca250e3a853012d4241462e908b5 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -558,7 +558,7 @@ pub fn readStreaming(file: File, io: Io, buffer: []const []u8) Reader.Error!usiz
         .file = file,
         .data = buffer,
     } };
-    io.operate(&operation);
+    try io.operate(&operation);
     return operation.file_read_streaming.status.result;
 }
 
diff --git a/lib/std/Io/File/Reader.zig b/lib/std/Io/File/Reader.zig
index d3d1c05e3f30edf81614e0109239cb547668043a..7703521d7ebb8b177d40335e06490af4a74cfd69 100644
--- a/lib/std/Io/File/Reader.zig
+++ b/lib/std/Io/File/Reader.zig
@@ -26,27 +26,7 @@ size_err: ?SizeError = null,
 seek_err: ?SeekError = null,
 interface: Io.Reader,
 
-pub const Error = error{
-    InputOutput,
-    SystemResources,
-    /// Trying to read a directory file descriptor as if it were a file.
-    IsDir,
-    BrokenPipe,
-    ConnectionResetByPeer,
-    /// File was not opened with read capability.
-    NotOpenForReading,
-    SocketUnconnected,
-    /// Non-blocking has been enabled, and reading from the file descriptor
-    /// would block.
-    WouldBlock,
-    /// In WASI, this error occurs when the file descriptor does
-    /// not hold the required rights to read from it.
-    AccessDenied,
-    /// Unable to read file due to lock. Depending on the `Io` implementation,
-    /// reading from a locked file may return this error, or may ignore the
-    /// lock.
-    LockViolation,
-} || Io.Cancelable || Io.UnexpectedError;
+pub const Error = Io.Operation.FileReadStreaming.Error || Io.Cancelable;
 
 pub const SizeError = File.StatError || error{
     /// Occurs if, for example, the file handle is a network socket and therefore does not have a size.
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index f7b4b73b33ae4150b612aba2b97cfc33230abc57..fefa8fe84dcacd0a61007145e0a15d9fd0e67e82 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1587,8 +1587,7 @@ pub fn io(t: *Threaded) Io {
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
 
-            .batch = batch,
-            .batchSubmit = batchSubmit,
+            .operate = operate,
             .batchWait = batchWait,
             .batchCancel = batchCancel,
 
@@ -1751,8 +1750,7 @@ pub fn ioBasic(t: *Threaded) Io {
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
 
-            .batch = batch,
-            .batchSubmit = batchSubmit,
+            .operate = operate,
             .batchWait = batchWait,
             .batchCancel = batchCancel,
 
@@ -2456,59 +2454,82 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
     Thread.futexWake(ptr, max_waiters);
 }
 
-fn batchSubmit(userdata: ?*anyopaque, b: *Io.Batch) void {
+fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    _ = b;
-    return;
-}
-
-fn operate(op: *Io.Operation) void {
     switch (op.*) {
-        .noop => {},
-        .file_read_streaming => |*o| o.status = .{ .result = fileReadStreaming(o.file, o.data) },
+        .noop => |*o| {
+            _ = o.status.unstarted;
+            o.status = .{ .result = {} };
+        },
+        .file_read_streaming => |*o| {
+            _ = o.status.unstarted;
+            o.status = .{ .result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+                error.Canceled => return error.Canceled,
+                else => |e| e,
+            } };
+        },
     }
 }
 
-fn batchWait(
-    userdata: ?*anyopaque,
-    b: *Io.Batch,
-    resubmissions: []const usize,
-    timeout: Io.Timeout,
-) Io.Batch.WaitError!usize {
-    _ = resubmissions;
+fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const operations = b.operations;
-    if (operations.len == 1) {
-        operate(&operations[0]);
-        return b.operations.len;
+    const len: u31 = @intCast(operations.len);
+    const ring = b.ring[0..len];
+    var submit_head = b.impl.submit_head;
+    const submit_tail = b.user.submit_tail;
+    b.impl.submit_tail = submit_tail;
+    var complete_tail = b.impl.complete_tail;
+    var map_buffer: [poll_buffer_len]u32 = undefined; // poll_buffer index to operations index
+    var poll_i: usize = 0;
+    defer {
+        for (map_buffer[0..poll_i]) |op| {
+            submit_head = submit_head.prev(len);
+            ring[submit_head.index(len)] = op;
+        }
+        b.impl.submit_head = submit_head;
+        b.impl.complete_tail = complete_tail;
+        b.user.complete_tail = complete_tail;
     }
     if (is_windows) @panic("TODO");
-
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
-    var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
-    var poll_i: usize = 0;
-
-    for (operations, 0..) |*op, operation_index| switch (op.*) {
-        .noop => continue,
-        .file_read_streaming => |*o| {
-            if (poll_buffer.len - poll_i == 0) return error.ConcurrencyUnavailable;
-            poll_buffer[poll_i] = .{
-                .fd = o.file.handle,
-                .events = posix.POLL.IN,
-                .revents = 0,
-            };
-            map_buffer[poll_i] = @intCast(operation_index);
-            poll_i += 1;
+    while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
+        const op = ring[submit_head.index(len)];
+        const operation = &operations[op];
+        switch (operation.*) {
+            else => {
+                try operate(t, operation);
+                ring[complete_tail.index(len)] = op;
+                complete_tail = complete_tail.next(len);
+            },
+            .file_read_streaming => |*o| {
+                _ = o.status.unstarted;
+                if (poll_buffer.len - poll_i == 0) return error.ConcurrencyUnavailable;
+                poll_buffer[poll_i] = .{
+                    .fd = o.file.handle,
+                    .events = posix.POLL.IN,
+                    .revents = 0,
+                };
+                map_buffer[poll_i] = op;
+                poll_i += 1;
+            },
+        }
+    }
+    switch (poll_i) {
+        0 => return,
+        1 => if (timeout == .none) {
+            const op = map_buffer[0];
+            try operate(t, &operations[op]);
+            ring[complete_tail.index(len)] = op;
+            complete_tail = complete_tail.next(len);
+            return;
         },
-    };
-
-    if (poll_i == 0) return operations.len;
-
+        else => {},
+    }
     const t_io = ioBasic(t);
     const deadline = timeout.toDeadline(t_io) catch return error.UnsupportedClock;
     const max_poll_ms = std.math.maxInt(i32);
-
     while (true) {
         const timeout_ms: i32 = if (deadline) |d| t: {
             const duration = d.durationFromNow(t_io) catch return error.UnsupportedClock;
@@ -2526,11 +2547,24 @@ fn batchWait(
                     if (deadline == null) continue;
                     return error.Timeout;
                 }
-                for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, i| {
-                    if (poll_fd.revents == 0) continue;
-                    operate(&operations[i]);
-                    return i;
+                var canceled = false;
+                for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, op| {
+                    if (poll_fd.revents == 0) {
+                        submit_head = submit_head.prev(len);
+                        ring[submit_head.index(len)] = op;
+                    } else {
+                        operate(t, &operations[op]) catch |err| switch (err) {
+                            error.Canceled => {
+                                canceled = true;
+                                continue;
+                            },
+                        };
+                        ring[complete_tail.index(len)] = op;
+                        complete_tail = complete_tail.next(len);
+                    }
                 }
+                poll_i = 0;
+                return if (canceled) error.Canceled;
             },
             .INTR => continue,
             else => return error.ConcurrencyUnavailable,
@@ -2540,9 +2574,27 @@ fn batchWait(
 
 fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-    _ = b;
-    return;
+    const operations = b.operations;
+    const len: u31 = @intCast(operations.len);
+    const ring = b.ring[0..len];
+    var submit_head = b.impl.submit_head;
+    const submit_tail = b.user.submit_tail;
+    b.impl.submit_tail = submit_tail;
+    var complete_tail = b.impl.complete_tail;
+    while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
+        const op = ring[submit_head.index(len)];
+        switch (operations[op]) {
+            .noop => {
+                operate(t, &operations[op]) catch unreachable;
+                ring[complete_tail.index(len)] = op;
+                complete_tail = complete_tail.next(len);
+            },
+            .file_read_streaming => |*o| _ = o.status.unstarted,
+        }
+    }
+    b.impl.submit_head = submit_tail;
+    b.impl.complete_tail = complete_tail;
+    b.user.complete_tail = complete_tail;
 }
 
 fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!void {
@@ -10352,6 +10404,7 @@ fn nowWasi(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
 
 fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
+    if (timeout == .none) return;
     if (use_parking_sleep) return parking_sleep.sleep(try timeout.toDeadline(ioBasic(t)));
     if (native_os == .wasi) return sleepWasi(t, timeout);
     if (@TypeOf(posix.system.clock_nanosleep) != void) return sleepPosix(timeout);
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 364c52446f8691a3e7505e89a40ca514125c5e59..19c974ff9f65c9beec210ea6498d76a65c28ac67 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -149,51 +149,45 @@ pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions)
     const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
     const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
     const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
-    var dones: [2]bool = .{ false, false };
     var reads: [2]Io.Operation = undefined;
     var vecs: [2][1][]u8 = undefined;
-    while (true) {
-        for (&reads, &lists, &files, dones, &vecs) |*read, list, file, done, *vec| {
-            if (done) {
-                read.* = .{ .noop = .{} };
-                continue;
-            }
-            if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
-            const cap = list.unusedCapacitySlice();
-            if (cap.len == 0) return error.StreamTooLong;
-            vec[0] = cap;
-            read.* = .{ .file_read_streaming = .{
-                .file = file,
-                .data = vec,
-            } };
+    var ring: [2]u32 = undefined;
+    var batch: Io.Batch = .init(&reads, &ring);
+    defer {
+        batch.cancel(io);
+        while (batch.next()) |op| {
+            lists[op].items.len += reads[op].file_read_streaming.status.result catch continue;
         }
-        var all_done = true;
-        var any_canceled = false;
-        var other_err: (error{StreamTooLong} || Io.File.Reader.Error)!void = {};
-        try io.vtable.batch(io.userdata, &reads);
-        for (&reads, &lists, &limits, &dones) |*read, list, limit, *done| {
-            if (done.*) continue;
-            const n = read.file_read_streaming.status.result catch |err| switch (err) {
-                error.Canceled => {
-                    any_canceled = true;
-                    continue;
-                },
-                error.WouldBlock => continue,
-                else => |e| {
-                    other_err = e;
-                    continue;
-                },
-            };
+    }
+    var remaining: usize = 0;
+    for (0.., &reads, &lists, &files, &vecs) |op, *read, list, file, *vec| {
+        if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
+        const cap = list.unusedCapacitySlice();
+        if (cap.len == 0) return error.StreamTooLong;
+        vec[0] = cap;
+        read.* = .{ .file_read_streaming = .{
+            .file = file,
+            .data = vec,
+        } };
+        batch.add(op);
+        remaining += 1;
+    }
+    while (remaining > 0) {
+        try batch.wait(io, .none);
+        while (batch.next()) |op| {
+            const n = try reads[op].file_read_streaming.status.result;
             if (n == 0) {
-                done.* = true;
+                remaining -= 1;
             } else {
-                all_done = false;
+                lists[op].items.len += n;
+                if (lists[op].items.len > @intFromEnum(limits[op])) return error.StreamTooLong;
+                if (options.allocator) |gpa| try lists[op].ensureUnusedCapacity(gpa, 1);
+                const cap = lists[op].unusedCapacitySlice();
+                if (cap.len == 0) return error.StreamTooLong;
+                vecs[op][0] = cap;
+                reads[op].file_read_streaming.status = .{ .unstarted = {} };
+                batch.add(op);
             }
-            list.items.len += n;
-            if (list.items.len > @intFromEnum(limit)) other_err = error.StreamTooLong;
         }
-        if (any_canceled) return error.Canceled;
-        try other_err;
-        if (all_done) return;
     }
 }
-- 
2.54.0


From 78a1476475047d0ae591fd838ec55b6b87561dd3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 12 Jan 2026 17:41:08 -0800
Subject: [PATCH 114/499] Build.WebServer: update concurrency API usage

---
 lib/std/Build/Step.zig      |  1 +
 lib/std/Build/WebServer.zig | 36 +++++++++++++++++++++++-------------
 2 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index bacc81cbfabe24938358d75653019443c892f03c..e2c51cc6fe91216ba8f8188324a4b30c50d62443 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -542,6 +542,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     const stdout = &stdout_reader.interface;
 
     var body_buffer: std.ArrayList(u8) = .empty;
+    defer body_buffer.deinit(gpa);
 
     while (true) {
         const Header = std.zig.Server.Message.Header;
diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index e1536fb8fa8bb2ad6e30a0e2a6fcaeda8d299c64..1f380b6c50d4f1aae6066362f37a4e2f6cd9c627 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -588,11 +588,12 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     });
     defer child.kill(io);
 
-    var poller = Io.poll(gpa, enum { stdout, stderr }, .{
-        .stdout = child.stdout.?,
-        .stderr = child.stderr.?,
-    });
-    defer poller.deinit();
+    var stderr_task = try io.concurrent(readStreamAlloc, .{ gpa, io, child.stderr.?, .unlimited });
+    defer if (stderr_task.cancel(io)) |slice| gpa.free(slice) else |_| {};
+
+    var stdout_buffer: [512]u8 = undefined;
+    var stdout_reader: Io.File.Reader = .initStreaming(child.stdout.?, io, &stdout_buffer);
+    const stdout = &stdout_reader.interface;
 
     try child.stdin.?.writeStreamingAll(io, @ptrCast(@as([]const std.zig.Client.Message.Header, &.{
         .{ .tag = .update, .bytes_len = 0 },
@@ -600,16 +601,17 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     })));
 
     const Header = std.zig.Server.Message.Header;
+
     var result: ?Cache.Path = null;
     var result_error_bundle = std.zig.ErrorBundle.empty;
+    var body_buffer: std.ArrayList(u8) = .empty;
+    defer body_buffer.deinit(gpa);
 
-    const stdout = poller.reader(.stdout);
-
-    poll: while (true) {
-        while (stdout.buffered().len < @sizeOf(Header)) if (!(try poller.poll())) break :poll;
-        const header = stdout.takeStruct(Header, .little) catch unreachable;
-        while (stdout.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll;
-        const body = stdout.take(header.bytes_len) catch unreachable;
+    while (true) {
+        const header = try stdout.takeStruct(Header, .little);
+        body_buffer.clearRetainingCapacity();
+        try stdout.appendExact(gpa, &body_buffer, header.bytes_len);
+        const body = body_buffer.items;
 
         switch (header.tag) {
             .zig_version => {
@@ -636,7 +638,7 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
         }
     }
 
-    const stderr_contents = try poller.toOwnedSlice(.stderr);
+    const stderr_contents = try stderr_task.await(io);
     if (stderr_contents.len > 0) {
         std.debug.print("{s}", .{stderr_contents});
     }
@@ -697,6 +699,14 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     return base_path.join(arena, bin_name);
 }
 
+fn readStreamAlloc(gpa: Allocator, io: Io, file: Io.File, limit: Io.Limit) ![]u8 {
+    var file_reader: Io.File.Reader = .initStreaming(file, io, &.{});
+    return file_reader.interface.allocRemaining(gpa, limit) catch |err| switch (err) {
+        error.ReadFailed => return file_reader.err.?,
+        else => |e| return e,
+    };
+}
+
 pub fn updateTimeReportCompile(ws: *WebServer, opts: struct {
     compile: *Build.Step.Compile,
 
-- 
2.54.0


From a0c2645948682b4bfdd2971f7512376605a45502 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 12 Jan 2026 18:04:56 -0800
Subject: [PATCH 115/499] std.Io.Threaded: delete dead code

---
 lib/std/Io/Threaded.zig | 209 +++++++++++++++-------------------------
 1 file changed, 80 insertions(+), 129 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index fefa8fe84dcacd0a61007145e0a15d9fd0e67e82..2167baa5e48ced7aa41f4f9b6581b0e6e62c1c04 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2474,6 +2474,7 @@ fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
 
 fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
+    if (is_windows) return batchWaitWindows(t, b, timeout);
     const operations = b.operations;
     const len: u31 = @intCast(operations.len);
     const ring = b.ring[0..len];
@@ -2492,13 +2493,12 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
         b.impl.complete_tail = complete_tail;
         b.user.complete_tail = complete_tail;
     }
-    if (is_windows) @panic("TODO");
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
         const op = ring[submit_head.index(len)];
         const operation = &operations[op];
         switch (operation.*) {
-            else => {
+            .noop => {
                 try operate(t, operation);
                 ring[complete_tail.index(len)] = op;
                 complete_tail = complete_tail.next(len);
@@ -2597,149 +2597,100 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
     b.user.complete_tail = complete_tail;
 }
 
-fn batch(userdata: ?*anyopaque, operations: []Io.Operation) Io.ConcurrentError!void {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
+fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.ConcurrentError!void {
+    const operations = b.operations;
+    const len: u31 = @intCast(operations.len);
+    const ring = b.ring[0..len];
+    var submit_head = b.impl.submit_head;
+    const submit_tail = b.user.submit_tail;
+    b.impl.submit_tail = submit_tail;
+    var complete_tail = b.impl.complete_tail;
 
-    if (operations.len == 1) {
-        @branchHint(.likely);
-        return operate(&operations[0]);
-    }
-
-    if (is_windows) return batchWindows(t, operations);
-
-    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
-    var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
-    var poll_i: usize = 0;
-
-    for (operations, 0..) |*op, operation_index| switch (op.*) {
-        .noop => continue,
-        .file_read_streaming => |*o| {
-            if (poll_buffer.len - poll_i == 0) return error.ConcurrencyUnavailable;
-            poll_buffer[poll_i] = .{
-                .fd = o.file.handle,
-                .events = posix.POLL.IN,
-                .revents = 0,
-            };
-            map_buffer[poll_i] = @intCast(operation_index);
-            poll_i += 1;
-        },
-    };
-
-    const polls = poll_buffer[0..poll_i];
-    const map = map_buffer[0..poll_i];
-
-    var pending = poll_i;
-    while (pending > 0) {
-        const syscall = Syscall.start() catch |err| switch (err) {
-            error.Canceled => {
-                if (!setOperationsError(operations, polls, map, error.Canceled))
-                    recancelInner();
-                return;
-            },
-        };
-        const rc = posix.system.poll(polls.ptr, polls.len, -1);
-        syscall.finish();
-        switch (posix.errno(rc)) {
-            .SUCCESS => for (polls, map) |*poll_fd, i| {
-                if (poll_fd.revents == 0) continue;
-                poll_fd.fd = -1;
-                pending -= 1;
-                operate(&operations[i]);
-            },
-            .INTR => continue,
-            .NOMEM => {
-                assert(setOperationsError(operations, polls, map, error.SystemResources));
-                return;
-            },
-            else => {
-                assert(setOperationsError(operations, polls, map, error.Unexpected));
-                return;
-            },
-        }
-    }
-}
-
-fn batchWindows(t: *Threaded, operations: []Io.Operation) Io.ConcurrentError!void {
-    _ = t;
     var overlapped_buffer: [poll_buffer_len]windows.OVERLAPPED = undefined;
     var handles_buffer: [poll_buffer_len]windows.HANDLE = undefined;
-    var map_buffer: [poll_buffer_len]u8 = undefined; // handles_buffer index to operations index
+    var map_buffer: [poll_buffer_len]u32 = undefined; // handles_buffer index to operations index
     var buffer_i: usize = 0;
 
-    for (operations, 0..) |*op, operation_index| switch (op.*) {
-        .noop => continue,
-        .file_read_streaming => |*o| {
-            if (handles_buffer.len - buffer_i == 0) return error.ConcurrencyUnavailable;
+    defer {
+        for (map_buffer[0..buffer_i]) |op| {
+            submit_head = submit_head.prev(len);
+            ring[submit_head.index(len)] = op;
+        }
+        b.impl.submit_head = submit_head;
+        b.impl.complete_tail = complete_tail;
+        b.user.complete_tail = complete_tail;
+    }
 
-            const overlapped = &overlapped_buffer[buffer_i];
-            overlapped.* = .{
-                .Internal = 0,
-                .InternalHigh = 0,
-                .DUMMYUNIONNAME = .{
-                    .DUMMYSTRUCTNAME = .{
-                        .Offset = 0,
-                        .OffsetHigh = 0,
+    while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
+        const op = ring[submit_head.index(len)];
+        const operation = &operations[op];
+        switch (operation.*) {
+            .noop => {
+                try operate(t, operation);
+                ring[complete_tail.index(len)] = op;
+                complete_tail = complete_tail.next(len);
+            },
+            .file_read_streaming => |*o| {
+                _ = o.status.unstarted;
+                if (handles_buffer.len - buffer_i == 0) return error.ConcurrencyUnavailable;
+                const overlapped = &overlapped_buffer[buffer_i];
+                overlapped.* = .{
+                    .Internal = 0,
+                    .InternalHigh = 0,
+                    .DUMMYUNIONNAME = .{
+                        .DUMMYSTRUCTNAME = .{
+                            .Offset = 0,
+                            .OffsetHigh = 0,
+                        },
+                        .Pointer = null,
                     },
-                    .Pointer = null,
-                },
-                .hEvent = null,
-            };
-            var n: windows.DWORD = undefined;
-            const buf = o.data[0];
-            if (windows.kernel32.ReadFile(o.file.handle, buf.ptr, buf.len, &n, overlapped) == 0) {
-                @panic("TODO");
-            }
-            handles_buffer[buffer_i] = o.file.handle;
-            map_buffer[buffer_i] = @intCast(operation_index);
-            buffer_i += 1;
+                    .hEvent = null,
+                };
+                var n: windows.DWORD = undefined;
+                const buf = o.data[0];
+                if (windows.kernel32.ReadFile(o.file.handle, buf.ptr, buf.len, &n, overlapped) == 0) {
+                    @panic("TODO");
+                }
+                handles_buffer[buffer_i] = o.file.handle;
+                map_buffer[buffer_i] = op;
+                buffer_i += 1;
+            },
+        }
+    }
+
+    switch (buffer_i) {
+        0 => return,
+        1 => if (timeout == .none) {
+            const op = map_buffer[0];
+            try operate(t, &operations[op]);
+            ring[complete_tail.index(len)] = op;
+            complete_tail = complete_tail.next(len);
+            return;
         },
-    };
+        else => {},
+    }
 
     const handles = handles_buffer[0..buffer_i];
     const map = map_buffer[0..buffer_i];
-    var pending = buffer_i;
 
-    while (pending > 0) {
-        const syscall: Syscall = try .start();
-        const index = windows.WaitForMultipleObjectsEx(handles, false, windows.INFINITE, true);
-        syscall.finish();
-        var n: windows.DWORD = undefined;
-        if (0 == windows.kernel32.GetOverlappedResult(handles[index], overlapped_buffer[index], &n, 0)) {
-            switch (windows.GetLastError()) {
-                .BROKEN_PIPE => @panic("TODO"),
-                .OPERATION_ABORTED => @panic("TODO"),
-                else => @panic("TODO"),
-            }
-        } else switch (operations[map[index]]) {
-            .noop => unreachable,
-            .file_read_streaming => |*o| {
-                o.status = .{ .result = n };
-                pending -= 1;
-            },
+    const syscall: Syscall = try .start();
+    const index = windows.WaitForMultipleObjectsEx(handles, false, windows.INFINITE, true);
+    syscall.finish();
+    var n: windows.DWORD = undefined;
+    if (0 == windows.kernel32.GetOverlappedResult(handles[index], overlapped_buffer[index], &n, 0)) {
+        switch (windows.GetLastError()) {
+            .BROKEN_PIPE => @panic("TODO"),
+            .OPERATION_ABORTED => @panic("TODO"),
+            else => @panic("TODO"),
         }
+    } else switch (operations[map[index]]) {
+        .noop => unreachable,
+        .file_read_streaming => |*o| {
+            o.status = .{ .result = n };
+        },
     }
 }
 
-fn setOperationsError(
-    operations: []Io.Operation,
-    polls: []const posix.pollfd,
-    map: []const u8,
-    err: error{ Canceled, SystemResources, Unexpected },
-) bool {
-    var marked = false;
-    for (polls, map) |*poll_fd, i| {
-        if (poll_fd.fd == -1) continue;
-        switch (operations[i]) {
-            .noop => unreachable,
-            inline else => |*o| {
-                o.status = .{ .result = err };
-                marked = true;
-            },
-        }
-    }
-    return marked;
-}
-
 const dirCreateDir = switch (native_os) {
     .windows => dirCreateDirWindows,
     .wasi => dirCreateDirWasi,
-- 
2.54.0


From 20cadd60aa71d500913fdf03f50ba2de01cf918b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 12 Jan 2026 23:21:55 -0800
Subject: [PATCH 116/499] std.Io.File: introduce MultiReader

Concurrently read from multiple file streams, eliminating risk of
deadlocking.
---
 lib/std/Build/Step.zig          |  29 ++--
 lib/std/Io.zig                  |   4 +-
 lib/std/Io/File.zig             |   3 +
 lib/std/Io/File/MultiReader.zig | 240 ++++++++++++++++++++++++++++++++
 lib/std/Io/Reader.zig           |   8 +-
 5 files changed, 256 insertions(+), 28 deletions(-)
 create mode 100644 lib/std/Io/File/MultiReader.zig

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index e2c51cc6fe91216ba8f8188324a4b30c50d62443..40845f75c31ccbfe5b931fabbb7f40c997212ffb 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -527,9 +527,6 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     const arena = b.allocator;
     const io = b.graph.io;
 
-    var stderr_task = try io.concurrent(readStreamAlloc, .{ gpa, io, zp.child.stderr.?, .unlimited });
-    defer if (stderr_task.cancel(io)) |slice| gpa.free(slice) else |_| {};
-
     var timer = try std.time.Timer.start();
 
     try sendMessage(io, zp.child.stdin.?, .update);
@@ -537,19 +534,18 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
 
     var result: ?Path = null;
 
-    var stdout_buffer: [512]u8 = undefined;
-    var stdout_reader: Io.File.Reader = .initStreaming(zp.child.stdout.?, io, &stdout_buffer);
-    const stdout = &stdout_reader.interface;
+    var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+    var multi_reader: Io.File.MultiReader = undefined;
+    multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ zp.child.stdout.?, zp.child.stderr.? });
+    defer multi_reader.deinit();
 
-    var body_buffer: std.ArrayList(u8) = .empty;
-    defer body_buffer.deinit(gpa);
+    const stdout = multi_reader.reader(0);
+    const stderr = multi_reader.reader(1);
 
     while (true) {
         const Header = std.zig.Server.Message.Header;
         const header = try stdout.takeStruct(Header, .little);
-        body_buffer.clearRetainingCapacity();
-        try stdout.appendExact(gpa, &body_buffer, header.bytes_len);
-        const body = body_buffer.items;
+        const body = try stdout.take(header.bytes_len);
         switch (header.tag) {
             .zig_version => {
                 if (!std.mem.eql(u8, builtin.zig_version_string, body)) {
@@ -640,8 +636,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
 
     s.result_duration_ns = timer.read();
 
-    const stderr_contents = try stderr_task.await(io);
-    defer gpa.free(stderr_contents);
+    const stderr_contents = stderr.buffered();
     if (stderr_contents.len > 0) {
         try s.result_error_msgs.append(arena, try arena.dupe(u8, stderr_contents));
     }
@@ -649,14 +644,6 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     return result;
 }
 
-fn readStreamAlloc(gpa: Allocator, io: Io, file: Io.File, limit: Io.Limit) ![]u8 {
-    var file_reader: Io.File.Reader = .initStreaming(file, io, &.{});
-    return file_reader.interface.allocRemaining(gpa, limit) catch |err| switch (err) {
-        error.ReadFailed => return file_reader.err.?,
-        else => |e| return e,
-    };
-}
-
 pub fn getZigProcess(s: *Step) ?*ZigProcess {
     return switch (s.id) {
         .compile => s.cast(Compile).?.zig_process,
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index b503979fda68d5db200da632970f114f40de819d..980379b72b985fdd5107e522eda9bdbee475caf0 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -350,8 +350,6 @@ pub const Batch = struct {
         }
     };
 
-    pub const WaitError = ConcurrentError || Cancelable || Timeout.Error;
-
     pub fn init(operations: []Operation, ring: []u32) Batch {
         const len: u31 = @intCast(operations.len);
         assert(ring.len == len);
@@ -405,6 +403,8 @@ pub const Batch = struct {
         return b.ring[0..len][head.index(len)];
     }
 
+    pub const WaitError = ConcurrentError || Cancelable || Timeout.Error;
+
     /// Starts work on any submitted operations and returns when at least one has completeed.
     ///
     /// Returns `error.Timeout` if `timeout` expires first.
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index cc7042d443d0ca250e3a853012d4241462e908b5..c545b6022278d5043d8890a39a91a7baae81d1dc 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -18,6 +18,9 @@ pub const Writer = @import("File/Writer.zig");
 pub const Atomic = @import("File/Atomic.zig");
 /// Memory intended to remain consistent with file contents.
 pub const MemoryMap = @import("File/MemoryMap.zig");
+/// Concurrently read from multiple file streams, eliminating risk of
+/// deadlocking.
+pub const MultiReader = @import("File/MultiReader.zig");
 
 pub const INode = std.posix.ino_t;
 pub const NLink = std.posix.nlink_t;
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1cf3f7b4042e01c2038575d69c583ea0afe23f7b
--- /dev/null
+++ b/lib/std/Io/File/MultiReader.zig
@@ -0,0 +1,240 @@
+const MultiReader = @This();
+
+const std = @import("../../std.zig");
+const Io = std.Io;
+const File = Io.File;
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+
+gpa: Allocator,
+streams: *Streams,
+batch: Io.Batch,
+
+pub const Context = struct {
+    mr: *MultiReader,
+    fr: File.Reader,
+    vec: [1][]u8,
+    err: ?Error,
+    eos: bool,
+};
+
+pub const Error = Allocator.Error || File.Reader.Error || Io.ConcurrentError;
+
+/// Trailing:
+/// * `contexts: [len]Context`
+/// * `ring: [len]u32`
+/// * `operations: [len]Io.Operation`
+pub const Streams = extern struct {
+    len: u32,
+
+    pub fn contexts(s: *Streams) []Context {
+        _ = s;
+        @panic("TODO");
+    }
+
+    pub fn ring(s: *Streams) []u32 {
+        _ = s;
+        @panic("TODO");
+    }
+
+    pub fn operations(s: *Streams) []Io.Operation {
+        _ = s;
+        @panic("TODO");
+    }
+};
+
+pub fn Buffer(comptime n: usize) type {
+    return extern struct {
+        len: u32,
+        contexts: [n][@sizeOf(Context)]u8 align(@alignOf(Context)),
+        ring: [n]u32,
+        operations: [n][@sizeOf(Io.Operation)]u8 align(@alignOf(Io.Operation)),
+
+        pub fn toStreams(b: *@This()) *Streams {
+            return @ptrCast(b);
+        }
+    };
+}
+
+/// See `Streams.Buffer` for convenience API to obtain the `streams` parameter.
+pub fn init(mr: *MultiReader, gpa: Allocator, io: Io, streams: *Streams, files: []const File) void {
+    const contexts = streams.contexts();
+    for (contexts, files) |*context, file| context.* = .{
+        .mr = mr,
+        .fr = .{
+            .io = io,
+            .file = file,
+            .mode = .streaming,
+            .interface = .{
+                .vtable = &.{
+                    .stream = stream,
+                    .discard = discard,
+                    .readVec = readVec,
+                    .rebase = rebase,
+                },
+                .buffer = &.{},
+                .seek = 0,
+                .end = 0,
+            },
+        },
+        .vec = .{&.{}},
+        .err = null,
+        .eos = false,
+    };
+    const operations = streams.operations();
+    const ring = streams.ring();
+    mr.* = .{
+        .gpa = gpa,
+        .streams = streams,
+        .batch = .init(operations, ring),
+    };
+    for (operations, contexts, files, 0..) |*op, *context, file, i| {
+        const r = &context.fr.interface;
+        op.* = .{ .file_read_streaming = .{
+            .file = file,
+            .data = &context.vec,
+        } };
+        rebaseGrowing(mr, context, 1) catch |err| {
+            context.err = err;
+            continue;
+        };
+        context.vec[0] = r.buffer;
+        mr.batch.add(i);
+    }
+}
+
+pub fn deinit(mr: *MultiReader) void {
+    const gpa = mr.gpa;
+    const contexts = mr.streams.contexts();
+    const io = contexts[0].fr.io;
+    mr.batch.cancel(io);
+    for (contexts) |*context| {
+        gpa.free(context.fr.interface.buffer);
+    }
+}
+
+pub fn reader(mr: *MultiReader, index: usize) *Io.Reader {
+    return &mr.streams.contexts()[index].fr.interface;
+}
+
+pub fn toOwnedSlice(mr: *MultiReader, index: usize) Allocator.Error![]u8 {
+    const gpa = mr.gpa;
+    const r: *Io.Reader = reader(mr, index);
+    if (r.seek == 0) {
+        const new = try gpa.realloc(r.buffer, r.end);
+        r.buffer = &.{};
+        r.end = 0;
+        return new;
+    }
+    const new = try gpa.dupe(u8, r.buffered());
+    gpa.free(r.buffer);
+    r.buffer = &.{};
+    r.seek = 0;
+    r.end = 0;
+    return new;
+}
+
+fn stream(r: *Io.Reader, w: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!usize {
+    _ = limit;
+    _ = w;
+    const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
+    const context: *Context = @fieldParentPtr("fr", fr);
+    const mr = context.mr;
+    return fill(mr, context);
+}
+
+fn discard(r: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
+    _ = limit;
+    const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
+    const context: *Context = @fieldParentPtr("fr", fr);
+    const mr = context.mr;
+    return fill(mr, context);
+}
+
+fn readVec(r: *Io.Reader, data: [][]u8) Io.Reader.Error!usize {
+    _ = data;
+    const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
+    const context: *Context = @fieldParentPtr("fr", fr);
+    const mr = context.mr;
+    return fill(mr, context);
+}
+
+fn rebase(r: *Io.Reader, capacity: usize) Io.Reader.RebaseError!void {
+    const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
+    const context: *Context = @fieldParentPtr("fr", fr);
+    const mr = context.mr;
+
+    return rebaseGrowing(mr, context, capacity) catch |err| {
+        context.err = err;
+        return error.ReadFailed;
+    };
+}
+
+fn rebaseGrowing(mr: *MultiReader, context: *Context, capacity: usize) Allocator.Error!void {
+    const gpa = mr.gpa;
+    const r = &context.fr.interface;
+    if (r.buffer.len >= capacity) {
+        const data = r.buffer[r.seek..r.end];
+        @memmove(r.buffer[0..data.len], data);
+        r.seek = 0;
+        r.end = data.len;
+    } else {
+        const adjusted_capacity = std.ArrayList(u8).growCapacity(capacity);
+
+        if (r.seek == 0) {
+            if (gpa.remap(r.buffer, adjusted_capacity)) |new_memory| {
+                r.buffer = new_memory;
+                return;
+            }
+        }
+
+        const data = r.buffer[r.seek..r.end];
+        const new = try gpa.alloc(u8, adjusted_capacity);
+        @memcpy(new[0..data.len], data);
+        r.seek = 0;
+        r.end = data.len;
+    }
+}
+
+fn fill(mr: *MultiReader, original_context: *Context) Io.Reader.Error!usize {
+    const contexts = mr.streams.contexts();
+    const operations = mr.streams.operations();
+    const io = contexts[0].fr.io;
+
+    mr.batch.wait(io, .none) catch |err| switch (err) {
+        error.Timeout, error.UnsupportedClock => unreachable,
+        else => |e| {
+            original_context.err = e;
+            return error.ReadFailed;
+        },
+    };
+
+    while (mr.batch.next()) |i| {
+        const context = &contexts[i];
+        const operation = &operations[i];
+        const n = operation.file_read_streaming.status.result catch |err| {
+            context.err = err;
+            continue;
+        };
+        if (n == 0) {
+            context.eos = true;
+            continue;
+        }
+        const r = &context.fr.interface;
+        r.end += n;
+        if (r.buffer.len - r.end == 0) {
+            rebaseGrowing(mr, context, r.bufferedLen() + 1) catch |err| {
+                context.err = err;
+                continue;
+            };
+            assert(r.seek == 0);
+            context.vec[0] = r.buffer;
+        }
+        operation.file_read_streaming.status = .{ .unstarted = {} };
+        mr.batch.add(i);
+    }
+
+    if (original_context.err != null) return error.ReadFailed;
+    if (original_context.eos) return error.EndOfStream;
+    return 0;
+}
diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig
index 9c5c762844c0f1e296fbd389ed016ebb991abfcf..9ff025a637c87e15f852d09234fd8d6570ad2ee4 100644
--- a/lib/std/Io/Reader.zig
+++ b/lib/std/Io/Reader.zig
@@ -127,9 +127,7 @@ pub const ShortError = error{
     ReadFailed,
 };
 
-pub const RebaseError = error{
-    EndOfStream,
-};
+pub const RebaseError = Error;
 
 pub const failing: Reader = .{
     .vtable = &.{
@@ -1402,7 +1400,7 @@ pub fn takeLeb128(r: *Reader, comptime T: type) TakeLeb128Error!T {
 }
 
 /// Ensures `capacity` data can be buffered without rebasing.
-pub fn rebase(r: *Reader, capacity: usize) RebaseError!void {
+pub fn rebase(r: *Reader, capacity: usize) Error!void {
     if (r.buffer.len - r.seek >= capacity) {
         @branchHint(.likely);
         return;
@@ -1410,7 +1408,7 @@ pub fn rebase(r: *Reader, capacity: usize) RebaseError!void {
     return r.vtable.rebase(r, capacity);
 }
 
-pub fn defaultRebase(r: *Reader, capacity: usize) RebaseError!void {
+pub fn defaultRebase(r: *Reader, capacity: usize) Error!void {
     assert(r.buffer.len - r.seek < capacity);
     const data = r.buffer[r.seek..r.end];
     @memmove(r.buffer[0..data.len], data);
-- 
2.54.0


From 12cfc96e1b25d4c75fd08b9af72226502982195a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 13 Jan 2026 18:42:00 -0800
Subject: [PATCH 117/499] std: update rest of build runner to new
 File.MultiReader API

---
 lib/std/Build/Step/Run.zig      | 110 ++++++++++++++++++--------------
 lib/std/Io/File/MultiReader.zig |  59 +++++++++++++----
 2 files changed, 109 insertions(+), 60 deletions(-)

diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index d025e01af40f8d3580e37ad830ee7515f0608cb4..82c15531d00576c6d1aa0db121a36c521455dd4b 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1669,39 +1669,44 @@ fn evalZigTest(
 
     while (true) {
         var child = try process.spawn(io, spawn_options);
-        var poller = std.Io.poll(gpa, StdioPollEnum, .{
-            .stdout = child.stdout.?,
-            .stderr = child.stderr.?,
-        });
+        var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+        var multi_reader: Io.File.MultiReader = undefined;
+        multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
         var child_killed = false;
         defer if (!child_killed) {
             child.kill(io);
-            poller.deinit();
+            multi_reader.deinit();
             run.step.result_peak_rss = @max(
                 run.step.result_peak_rss,
                 child.resource_usage_statistics.getMaxRss() orelse 0,
             );
         };
 
-        switch (try pollZigTest(
+        switch (try waitZigTest(
             run,
             &child,
             options,
             fuzz_context,
-            &poller,
+            &multi_reader,
             &test_metadata,
             &test_results,
         )) {
             .write_failed => |err| {
                 // The runner unexpectedly closed a stdio pipe, which means a crash. Make sure we've captured
                 // all available stderr to make our error output as useful as possible.
-                while (try poller.poll()) {}
-                run.step.result_stderr = try arena.dupe(u8, poller.reader(.stderr).buffered());
+                const stderr_fr = multi_reader.fileReader(1);
+                while (true) {
+                    stderr_fr.interface.fillMore() catch |e| switch (e) {
+                        error.ReadFailed => return stderr_fr.err.?,
+                        error.EndOfStream => break,
+                    };
+                }
+                run.step.result_stderr = try arena.dupe(u8, stderr_fr.interface.buffered());
 
                 // Clean up everything and wait for the child to exit.
                 child.stdin.?.close(io);
                 child.stdin = null;
-                poller.deinit();
+                multi_reader.deinit();
                 child_killed = true;
                 const term = try child.wait(io);
                 run.step.result_peak_rss = @max(
@@ -1716,13 +1721,14 @@ fn evalZigTest(
             .no_poll => |no_poll| {
                 // This might be a success (we requested exit and the child dutifully closed stdout) or
                 // a crash of some kind. Either way, the child will terminate by itself -- wait for it.
-                const stderr_owned = try arena.dupe(u8, poller.reader(.stderr).buffered());
-                poller.reader(.stderr).tossBuffered();
+                const stderr_reader = multi_reader.reader(1);
+                const stderr_owned = try arena.dupe(u8, stderr_reader.buffered());
+                stderr_reader.tossBuffered();
 
                 // Clean up everything and wait for the child to exit.
                 child.stdin.?.close(io);
                 child.stdin = null;
-                poller.deinit();
+                multi_reader.deinit();
                 child_killed = true;
                 const term = try child.wait(io);
                 run.step.result_peak_rss = @max(
@@ -1770,8 +1776,9 @@ fn evalZigTest(
                 return;
             },
             .timeout => |timeout| {
-                const stderr = poller.reader(.stderr).buffered();
-                poller.reader(.stderr).tossBuffered();
+                const stderr_reader = multi_reader.reader(1);
+                const stderr = stderr_reader.buffered();
+                stderr_reader.tossBuffered();
                 if (timeout.active_test_index) |test_index| {
                     // A test was running. Report the timeout against that test, and continue on to
                     // the next test.
@@ -1796,16 +1803,16 @@ fn evalZigTest(
     }
 }
 
-/// Polls stdout of a Zig test process until a termination condition is reached:
+/// Reads stdout of a Zig test process until a termination condition is reached:
 /// * A write fails, indicating the child unexpectedly closed stdin
 /// * A test (or a response from the test runner) times out
-/// * `poll` fails, indicating the child closed stdout and stderr
-fn pollZigTest(
+/// * The wait fails, indicating the child closed stdout and stderr
+fn waitZigTest(
     run: *Run,
     child: *process.Child,
     options: Step.MakeOptions,
     fuzz_context: ?FuzzContext,
-    poller: *std.Io.Poller(StdioPollEnum),
+    multi_reader: *Io.File.MultiReader,
     opt_metadata: *?TestMetadata,
     results: *Step.TestResults,
 ) !union(enum) {
@@ -1874,12 +1881,11 @@ fn pollZigTest(
         break :ns @max(options.unit_test_timeout_ns orelse 0, 60 * std.time.ns_per_s);
     };
 
-    const stdout = poller.reader(.stdout);
-    const stderr = poller.reader(.stderr);
+    const stdout = multi_reader.reader(0);
+    const stderr = multi_reader.reader(1);
+    const Header = std.zig.Server.Message.Header;
 
     while (true) {
-        const Header = std.zig.Server.Message.Header;
-
         // This block is exited when `stdout` contains enough bytes for a `Header`.
         header_ready: {
             if (stdout.buffered().len >= @sizeOf(Header)) {
@@ -1894,18 +1900,22 @@ fn pollZigTest(
                 break :ns options.unit_test_timeout_ns;
             };
 
-            if (opt_timeout_ns) |timeout_ns| {
-                const remaining_ns = timeout_ns -| timer.?.read();
-                if (!try poller.pollTimeout(remaining_ns)) return .{ .no_poll = .{
+            const timeout: Io.Timeout = if (opt_timeout_ns) |timeout_ns| .{ .duration = .{
+                .raw = .fromNanoseconds(timeout_ns -| timer.?.read()),
+                .clock = .awake,
+            } } else .none;
+
+            multi_reader.fill(timeout) catch |err| switch (err) {
+                error.Timeout, error.EndOfStream => return .{ .no_poll = .{
                     .active_test_index = active_test_index,
                     .ns_elapsed = if (timer) |*t| t.read() else 0,
-                } };
-            } else {
-                if (!try poller.poll()) return .{ .no_poll = .{
-                    .active_test_index = active_test_index,
-                    .ns_elapsed = if (timer) |*t| t.read() else 0,
-                } };
-            }
+                } },
+                error.UnsupportedClock => {
+                    timer = null;
+                    continue;
+                },
+                else => |e| return e,
+            };
 
             if (stdout.buffered().len >= @sizeOf(Header)) {
                 // There wasn't a header before, but there is one after the `poll`.
@@ -1923,11 +1933,8 @@ fn pollZigTest(
         }
         // There is definitely a header available now -- read it.
         const header = stdout.takeStruct(Header, .little) catch unreachable;
+        try stdout.fill(header.bytes_len);
 
-        while (stdout.buffered().len < header.bytes_len) if (!try poller.poll()) return .{ .no_poll = .{
-            .active_test_index = active_test_index,
-            .ns_elapsed = if (timer) |*t| t.read() else 0,
-        } };
         const body = stdout.take(header.bytes_len) catch unreachable;
         var body_r: std.Io.Reader = .fixed(body);
         switch (header.tag) {
@@ -2164,6 +2171,7 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
     const b = run.step.owner;
     const io = b.graph.io;
     const arena = b.allocator;
+    const gpa = b.allocator;
 
     var child = try process.spawn(io, spawn_options);
     defer child.kill(io);
@@ -2211,23 +2219,31 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
 
     if (child.stdout) |stdout| {
         if (child.stderr) |stderr| {
-            var poller = std.Io.poll(arena, enum { stdout, stderr }, .{
-                .stdout = stdout,
-                .stderr = stderr,
-            });
-            defer poller.deinit();
+            var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+            var multi_reader: Io.File.MultiReader = undefined;
+            multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ stdout, stderr });
+            defer multi_reader.deinit();
 
-            while (try poller.poll()) {
+            const stdout_reader = multi_reader.reader(0);
+            const stderr_reader = multi_reader.reader(1);
+
+            while (multi_reader.fill(.none)) |_| {
                 if (run.stdio_limit.toInt()) |limit| {
-                    if (poller.reader(.stderr).buffered().len > limit)
+                    if (stdout_reader.buffered().len > limit)
                         return error.StdoutStreamTooLong;
-                    if (poller.reader(.stderr).buffered().len > limit)
+                    if (stderr_reader.buffered().len > limit)
                         return error.StderrStreamTooLong;
                 }
+            } else |err| switch (err) {
+                error.UnsupportedClock, error.Timeout => unreachable,
+                error.EndOfStream => {},
+                else => |e| return e,
             }
 
-            stdout_bytes = try poller.toOwnedSlice(.stdout);
-            stderr_bytes = try poller.toOwnedSlice(.stderr);
+            try multi_reader.checkAnyError();
+
+            stdout_bytes = try multi_reader.toOwnedSlice(0);
+            stderr_bytes = try multi_reader.toOwnedSlice(1);
         } else {
             var stdout_reader = stdout.readerStreaming(io, &.{});
             stdout_bytes = stdout_reader.interface.allocRemaining(arena, run.stdio_limit) catch |err| switch (err) {
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index 1cf3f7b4042e01c2038575d69c583ea0afe23f7b..d4024ef914c17bfffcafac1ab2559828689abdf4 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -113,10 +113,28 @@ pub fn deinit(mr: *MultiReader) void {
     }
 }
 
+pub fn fileReader(mr: *MultiReader, index: usize) *File.Reader {
+    return &mr.streams.contexts()[index].fr;
+}
+
 pub fn reader(mr: *MultiReader, index: usize) *Io.Reader {
     return &mr.streams.contexts()[index].fr.interface;
 }
 
+/// Checks for errors in all streams, prioritizing `error.Canceled` if it
+/// occurred anywhere.
+pub fn checkAnyError(mr: *const MultiReader) Error!void {
+    const contexts = mr.streams.contexts();
+    var other: Error!void = {};
+    for (contexts) |*context| {
+        if (context.err) |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| other = e,
+        };
+    }
+    return other;
+}
+
 pub fn toOwnedSlice(mr: *MultiReader, index: usize) Allocator.Error![]u8 {
     const gpa = mr.gpa;
     const r: *Io.Reader = reader(mr, index);
@@ -140,7 +158,7 @@ fn stream(r: *Io.Reader, w: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!u
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
     const mr = context.mr;
-    return fill(mr, context);
+    return fillUntimed(mr, context);
 }
 
 fn discard(r: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
@@ -148,7 +166,7 @@ fn discard(r: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
     const mr = context.mr;
-    return fill(mr, context);
+    return fillUntimed(mr, context);
 }
 
 fn readVec(r: *Io.Reader, data: [][]u8) Io.Reader.Error!usize {
@@ -156,7 +174,7 @@ fn readVec(r: *Io.Reader, data: [][]u8) Io.Reader.Error!usize {
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
     const mr = context.mr;
-    return fill(mr, context);
+    return fillUntimed(mr, context);
 }
 
 fn rebase(r: *Io.Reader, capacity: usize) Io.Reader.RebaseError!void {
@@ -196,20 +214,23 @@ fn rebaseGrowing(mr: *MultiReader, context: *Context, capacity: usize) Allocator
     }
 }
 
-fn fill(mr: *MultiReader, original_context: *Context) Io.Reader.Error!usize {
+pub const FillError = Io.Batch.WaitError || error{
+    /// `fill` was called when all streams already have failed or reached the
+    /// end.
+    EndOfStream,
+};
+
+/// Wait until at least one stream receives more data.
+pub fn fill(mr: *MultiReader, timeout: Io.Timeout) FillError!void {
     const contexts = mr.streams.contexts();
     const operations = mr.streams.operations();
     const io = contexts[0].fr.io;
+    var any_completed = false;
 
-    mr.batch.wait(io, .none) catch |err| switch (err) {
-        error.Timeout, error.UnsupportedClock => unreachable,
-        else => |e| {
-            original_context.err = e;
-            return error.ReadFailed;
-        },
-    };
+    try mr.batch.wait(io, timeout);
 
     while (mr.batch.next()) |i| {
+        any_completed = true;
         const context = &contexts[i];
         const operation = &operations[i];
         const n = operation.file_read_streaming.status.result catch |err| {
@@ -234,7 +255,19 @@ fn fill(mr: *MultiReader, original_context: *Context) Io.Reader.Error!usize {
         mr.batch.add(i);
     }
 
-    if (original_context.err != null) return error.ReadFailed;
-    if (original_context.eos) return error.EndOfStream;
+    if (!any_completed) return error.EndOfStream;
+}
+
+fn fillUntimed(mr: *MultiReader, context: *Context) Io.Reader.Error!usize {
+    fill(mr, .none) catch |err| switch (err) {
+        error.Timeout, error.UnsupportedClock => unreachable,
+        error.Canceled, error.ConcurrencyUnavailable => |e| {
+            context.err = e;
+            return error.ReadFailed;
+        },
+        error.EndOfStream => |e| return e,
+    };
+    if (context.err != null) return error.ReadFailed;
+    if (context.eos) return error.EndOfStream;
     return 0;
 }
-- 
2.54.0


From e56563ce3fb7ae2fb13f66ba6045ffb1f828ae08 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 13 Jan 2026 21:23:44 -0800
Subject: [PATCH 118/499] std.Io.File.MultiReader: implementation fixes

---
 lib/std/Build/Step.zig          |  34 +++++----
 lib/std/Build/Step/Run.zig      |  12 ++--
 lib/std/Io/File/MultiReader.zig | 118 ++++++++++++++++----------------
 lib/std/crypto/tls/Client.zig   |   3 +-
 4 files changed, 87 insertions(+), 80 deletions(-)

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 40845f75c31ccbfe5b931fabbb7f40c997212ffb..37fc2ca023f4ff9ebec6b2a88172b31e4f6182fe 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -381,13 +381,15 @@ pub fn addError(step: *Step, comptime fmt: []const u8, args: anytype) error{OutO
 
 pub const ZigProcess = struct {
     child: std.process.Child,
+    multi_reader_buffer: Io.File.MultiReader.Buffer(2),
+    multi_reader: Io.File.MultiReader,
     progress_ipc_fd: if (std.Progress.have_ipc) ?std.posix.fd_t else void,
 
     pub const StreamEnum = enum { stdout, stderr };
 
-    pub fn deinit(zp: *ZigProcess, gpa: Allocator, io: Io) void {
-        _ = gpa;
+    pub fn deinit(zp: *ZigProcess, io: Io) void {
         zp.child.kill(io);
+        zp.multi_reader.deinit();
         zp.* = undefined;
     }
 };
@@ -460,14 +462,18 @@ pub fn evalZigProcess(
         .request_resource_usage_statistics = true,
         .progress_node = prog_node,
     }) catch |err| return s.fail("failed to spawn zig compiler {s}: {t}", .{ argv[0], err });
-    defer if (!watch) zp.child.kill(io);
 
     zp.* = .{
         .child = zp.child,
+        .multi_reader_buffer = undefined,
+        .multi_reader = undefined,
         .progress_ipc_fd = if (std.Progress.have_ipc) prog_node.getIpcFd() else {},
     };
+    zp.multi_reader.init(gpa, io, zp.multi_reader_buffer.toStreams(), &.{
+        zp.child.stdout.?, zp.child.stderr.?,
+    });
     if (watch) s.setZigProcess(zp);
-    defer if (!watch) zp.deinit(gpa, io);
+    defer if (!watch) zp.deinit(io);
 
     const result = try zigProcessUpdate(s, zp, watch, web_server, gpa);
 
@@ -534,18 +540,18 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
 
     var result: ?Path = null;
 
-    var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
-    var multi_reader: Io.File.MultiReader = undefined;
-    multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ zp.child.stdout.?, zp.child.stderr.? });
-    defer multi_reader.deinit();
-
-    const stdout = multi_reader.reader(0);
-    const stderr = multi_reader.reader(1);
+    const stdout = zp.multi_reader.fileReader(0);
 
     while (true) {
         const Header = std.zig.Server.Message.Header;
-        const header = try stdout.takeStruct(Header, .little);
-        const body = try stdout.take(header.bytes_len);
+        const header = stdout.interface.takeStruct(Header, .little) catch |err| switch (err) {
+            error.EndOfStream => break,
+            error.ReadFailed => return stdout.err.?,
+        };
+        const body = stdout.interface.take(header.bytes_len) catch |err| switch (err) {
+            error.EndOfStream => |e| return e,
+            error.ReadFailed => return stdout.err.?,
+        };
         switch (header.tag) {
             .zig_version => {
                 if (!std.mem.eql(u8, builtin.zig_version_string, body)) {
@@ -636,7 +642,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
 
     s.result_duration_ns = timer.read();
 
-    const stderr_contents = stderr.buffered();
+    const stderr_contents = zp.multi_reader.reader(1).buffered();
     if (stderr_contents.len > 0) {
         try s.result_error_msgs.append(arena, try arena.dupe(u8, stderr_contents));
     }
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 82c15531d00576c6d1aa0db121a36c521455dd4b..c74286f61bfb6e6709223c40a12ed646ef46ef0b 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1695,11 +1695,9 @@ fn evalZigTest(
                 // The runner unexpectedly closed a stdio pipe, which means a crash. Make sure we've captured
                 // all available stderr to make our error output as useful as possible.
                 const stderr_fr = multi_reader.fileReader(1);
-                while (true) {
-                    stderr_fr.interface.fillMore() catch |e| switch (e) {
-                        error.ReadFailed => return stderr_fr.err.?,
-                        error.EndOfStream => break,
-                    };
+                while (stderr_fr.interface.fillMore()) |_| {} else |e| switch (e) {
+                    error.ReadFailed => return stderr_fr.err.?,
+                    error.EndOfStream => {},
                 }
                 run.step.result_stderr = try arena.dupe(u8, stderr_fr.interface.buffered());
 
@@ -1905,7 +1903,7 @@ fn waitZigTest(
                 .clock = .awake,
             } } else .none;
 
-            multi_reader.fill(timeout) catch |err| switch (err) {
+            multi_reader.fill(64, timeout) catch |err| switch (err) {
                 error.Timeout, error.EndOfStream => return .{ .no_poll = .{
                     .active_test_index = active_test_index,
                     .ns_elapsed = if (timer) |*t| t.read() else 0,
@@ -2227,7 +2225,7 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
             const stdout_reader = multi_reader.reader(0);
             const stderr_reader = multi_reader.reader(1);
 
-            while (multi_reader.fill(.none)) |_| {
+            while (multi_reader.fill(64, .none)) |_| {
                 if (run.stdio_limit.toInt()) |limit| {
                     if (stdout_reader.buffered().len > limit)
                         return error.StdoutStreamTooLong;
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index d4024ef914c17bfffcafac1ab2559828689abdf4..a1ea42a7d8e98c261032357d482e41e199c80e74 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -28,18 +28,23 @@ pub const Streams = extern struct {
     len: u32,
 
     pub fn contexts(s: *Streams) []Context {
-        _ = s;
-        @panic("TODO");
+        const base: usize = @intFromPtr(s);
+        const ptr: [*]Context = @ptrFromInt(std.mem.alignForward(usize, base + @sizeOf(Streams), @alignOf(Context)));
+        return ptr[0..s.len];
     }
 
     pub fn ring(s: *Streams) []u32 {
-        _ = s;
-        @panic("TODO");
+        const prev = contexts(s);
+        const end = prev.ptr + prev.len;
+        const ptr: [*]u32 = @ptrFromInt(std.mem.alignForward(usize, @intFromPtr(end), @alignOf(u32)));
+        return ptr[0..s.len];
     }
 
     pub fn operations(s: *Streams) []Io.Operation {
-        _ = s;
-        @panic("TODO");
+        const prev = ring(s);
+        const end = prev.ptr + prev.len;
+        const ptr: [*]Io.Operation = @ptrFromInt(std.mem.alignForward(usize, @intFromPtr(end), @alignOf(Io.Operation)));
+        return ptr[0..s.len];
     }
 };
 
@@ -51,6 +56,7 @@ pub fn Buffer(comptime n: usize) type {
         operations: [n][@sizeOf(Io.Operation)]u8 align(@alignOf(Io.Operation)),
 
         pub fn toStreams(b: *@This()) *Streams {
+            b.len = n;
             return @ptrCast(b);
         }
     };
@@ -157,61 +163,43 @@ fn stream(r: *Io.Reader, w: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!u
     _ = w;
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
-    const mr = context.mr;
-    return fillUntimed(mr, context);
+    try fillUntimed(context, 1);
+    return 0;
 }
 
 fn discard(r: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
     _ = limit;
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
-    const mr = context.mr;
-    return fillUntimed(mr, context);
+    try fillUntimed(context, 1);
+    return 0;
 }
 
 fn readVec(r: *Io.Reader, data: [][]u8) Io.Reader.Error!usize {
     _ = data;
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
-    const mr = context.mr;
-    return fillUntimed(mr, context);
+    try fillUntimed(context, 1);
+    return 0;
 }
 
 fn rebase(r: *Io.Reader, capacity: usize) Io.Reader.RebaseError!void {
     const fr: *File.Reader = @alignCast(@fieldParentPtr("interface", r));
     const context: *Context = @fieldParentPtr("fr", fr);
-    const mr = context.mr;
-
-    return rebaseGrowing(mr, context, capacity) catch |err| {
-        context.err = err;
-        return error.ReadFailed;
-    };
+    try fillUntimed(context, capacity);
 }
 
-fn rebaseGrowing(mr: *MultiReader, context: *Context, capacity: usize) Allocator.Error!void {
-    const gpa = mr.gpa;
-    const r = &context.fr.interface;
-    if (r.buffer.len >= capacity) {
-        const data = r.buffer[r.seek..r.end];
-        @memmove(r.buffer[0..data.len], data);
-        r.seek = 0;
-        r.end = data.len;
-    } else {
-        const adjusted_capacity = std.ArrayList(u8).growCapacity(capacity);
-
-        if (r.seek == 0) {
-            if (gpa.remap(r.buffer, adjusted_capacity)) |new_memory| {
-                r.buffer = new_memory;
-                return;
-            }
-        }
-
-        const data = r.buffer[r.seek..r.end];
-        const new = try gpa.alloc(u8, adjusted_capacity);
-        @memcpy(new[0..data.len], data);
-        r.seek = 0;
-        r.end = data.len;
-    }
+fn fillUntimed(context: *Context, capacity: usize) Io.Reader.Error!void {
+    fill(context.mr, capacity, .none) catch |err| switch (err) {
+        error.Timeout, error.UnsupportedClock => unreachable,
+        error.Canceled, error.ConcurrencyUnavailable => |e| {
+            context.err = e;
+            return error.ReadFailed;
+        },
+        error.EndOfStream => |e| return e,
+    };
+    if (context.err != null) return error.ReadFailed;
+    if (context.eos) return error.EndOfStream;
 }
 
 pub const FillError = Io.Batch.WaitError || error{
@@ -221,7 +209,7 @@ pub const FillError = Io.Batch.WaitError || error{
 };
 
 /// Wait until at least one stream receives more data.
-pub fn fill(mr: *MultiReader, timeout: Io.Timeout) FillError!void {
+pub fn fill(mr: *MultiReader, unused_capacity: usize, timeout: Io.Timeout) FillError!void {
     const contexts = mr.streams.contexts();
     const operations = mr.streams.operations();
     const io = contexts[0].fr.io;
@@ -243,14 +231,14 @@ pub fn fill(mr: *MultiReader, timeout: Io.Timeout) FillError!void {
         }
         const r = &context.fr.interface;
         r.end += n;
-        if (r.buffer.len - r.end == 0) {
-            rebaseGrowing(mr, context, r.bufferedLen() + 1) catch |err| {
+        if (r.buffer.len - r.end < unused_capacity) {
+            rebaseGrowing(mr, context, r.bufferedLen() + unused_capacity) catch |err| {
                 context.err = err;
                 continue;
             };
             assert(r.seek == 0);
-            context.vec[0] = r.buffer;
         }
+        context.vec[0] = r.buffer[r.end..];
         operation.file_read_streaming.status = .{ .unstarted = {} };
         mr.batch.add(i);
     }
@@ -258,16 +246,30 @@ pub fn fill(mr: *MultiReader, timeout: Io.Timeout) FillError!void {
     if (!any_completed) return error.EndOfStream;
 }
 
-fn fillUntimed(mr: *MultiReader, context: *Context) Io.Reader.Error!usize {
-    fill(mr, .none) catch |err| switch (err) {
-        error.Timeout, error.UnsupportedClock => unreachable,
-        error.Canceled, error.ConcurrencyUnavailable => |e| {
-            context.err = e;
-            return error.ReadFailed;
-        },
-        error.EndOfStream => |e| return e,
-    };
-    if (context.err != null) return error.ReadFailed;
-    if (context.eos) return error.EndOfStream;
-    return 0;
+fn rebaseGrowing(mr: *MultiReader, context: *Context, capacity: usize) Allocator.Error!void {
+    const gpa = mr.gpa;
+    const r = &context.fr.interface;
+    if (r.buffer.len >= capacity) {
+        const data = r.buffer[r.seek..r.end];
+        @memmove(r.buffer[0..data.len], data);
+        r.seek = 0;
+        r.end = data.len;
+    } else {
+        const adjusted_capacity = std.ArrayList(u8).growCapacity(capacity);
+
+        if (r.seek == 0) {
+            if (gpa.remap(r.buffer, adjusted_capacity)) |new_memory| {
+                r.buffer = new_memory;
+                return;
+            }
+        }
+
+        const data = r.buffer[r.seek..r.end];
+        const new = try gpa.alloc(u8, adjusted_capacity);
+        @memcpy(new[0..data.len], data);
+        gpa.free(r.buffer);
+        r.buffer = new;
+        r.seek = 0;
+        r.end = data.len;
+    }
 }
diff --git a/lib/std/crypto/tls/Client.zig b/lib/std/crypto/tls/Client.zig
index 44a73c344a5703e1b9e7b1eb99f06e41bb2232bb..eeeb7d05373a527a8c1fbde2ff5bd8eb7aecc9a8 100644
--- a/lib/std/crypto/tls/Client.zig
+++ b/lib/std/crypto/tls/Client.zig
@@ -336,10 +336,11 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
         // Ensure the input buffer pointer is stable in this scope.
         input.rebase(tls.max_ciphertext_record_len) catch |err| switch (err) {
             error.EndOfStream => {}, // We have assurance the remainder of stream can be buffered.
+            error.ReadFailed => |e| return e,
         };
         const record_header = input.peek(tls.record_header_len) catch |err| switch (err) {
             error.EndOfStream => return error.TlsConnectionTruncated,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         const record_ct = input.takeEnumNonexhaustive(tls.ContentType, .big) catch unreachable; // already peeked
         input.toss(2); // legacy_version
-- 
2.54.0


From dd0153b91b55e3b32227562ed68fdaee31c5b844 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 14 Jan 2026 00:23:33 -0800
Subject: [PATCH 119/499] std.Io.operate: fix bogus catch

this used to have a different error set. just goes to show you how
useful switching on error set is even when there is only 1 prong
---
 lib/std/Io.zig          | 2 +-
 lib/std/Io/Threaded.zig | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 980379b72b985fdd5107e522eda9bdbee475caf0..a63a89e4ee020f91a959e62ee91782d120348c6b 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -303,7 +303,7 @@ pub const Operation = union(enum) {
 
 /// Performs one `Operation`.
 pub fn operate(io: Io, operation: *Operation) Cancelable!void {
-    return io.vtable.operate(io.userdata, operation) catch unreachable;
+    return io.vtable.operate(io.userdata, operation);
 }
 
 /// Submits many operations together without waiting for all of them to
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 2167baa5e48ced7aa41f4f9b6581b0e6e62c1c04..55a4c8aad73c59bb4c19bb4435877d33db033dac 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2465,7 +2465,7 @@ fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
         .file_read_streaming => |*o| {
             _ = o.status.unstarted;
             o.status = .{ .result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
-                error.Canceled => return error.Canceled,
+                error.Canceled => |e| return e,
                 else => |e| e,
             } };
         },
-- 
2.54.0


From 372e8e54d3d7d09bc8805262c4034b7779467842 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 14 Jan 2026 00:56:00 -0800
Subject: [PATCH 120/499] compiler: update for std.Io.File.MultiReader API

---
 lib/std/Build/Step.zig           | 11 ++++++-
 lib/std/Io/File/MultiReader.zig  |  8 +++++
 lib/std/process.zig              |  2 ++
 lib/std/process/Child.zig        |  3 +-
 lib/std/zig/LibCInstallation.zig |  6 ++--
 src/Compilation.zig              | 51 +++++++++++++++++++++-----------
 6 files changed, 59 insertions(+), 22 deletions(-)

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 37fc2ca023f4ff9ebec6b2a88172b31e4f6182fe..0dd4b932800b3ee9c3e65dd2347381263f0eb34b 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -539,6 +539,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     if (!watch) try sendMessage(io, zp.child.stdin.?, .exit);
 
     var result: ?Path = null;
+    var eos_err: error{EndOfStream}!void = {};
 
     const stdout = zp.multi_reader.fileReader(0);
 
@@ -549,7 +550,13 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
             error.ReadFailed => return stdout.err.?,
         };
         const body = stdout.interface.take(header.bytes_len) catch |err| switch (err) {
-            error.EndOfStream => |e| return e,
+            error.EndOfStream => |e| {
+                // Better to report the crash with stderr below, but we set
+                // this in case the child exits successfully while violating
+                // this protocol.
+                eos_err = e;
+                break;
+            },
             error.ReadFailed => return stdout.err.?,
         };
         switch (header.tag) {
@@ -647,6 +654,8 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
         try s.result_error_msgs.append(arena, try arena.dupe(u8, stderr_contents));
     }
 
+    try eos_err;
+
     return result;
 }
 
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index a1ea42a7d8e98c261032357d482e41e199c80e74..0cfa777e9687c35b8651700ad831fd6b6b69b9a2 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -246,6 +246,14 @@ pub fn fill(mr: *MultiReader, unused_capacity: usize, timeout: Io.Timeout) FillE
     if (!any_completed) return error.EndOfStream;
 }
 
+/// Wait until all streams fail or reach the end.
+pub fn fillRemaining(mr: *MultiReader, timeout: Io.Timeout) Io.Batch.WaitError!void {
+    while (fill(mr, 1, timeout)) |_| {} else |err| switch (err) {
+        error.EndOfStream => return,
+        else => |e| return e,
+    }
+}
+
 fn rebaseGrowing(mr: *MultiReader, context: *Context, capacity: usize) Allocator.Error!void {
     const gpa = mr.gpa;
     const r = &context.fr.interface;
diff --git a/lib/std/process.zig b/lib/std/process.zig
index b5de41f5d88551df6a7c8a7af173b104838511d3..6f3c155f6d6712c71e582a047ab1c41ee160c4f7 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -488,6 +488,7 @@ pub const RunOptions = struct {
     create_no_window: bool = true,
     /// Darwin-only. Disable ASLR for the child process.
     disable_aslr: bool = false,
+    timeout: Io.Timeout = .none,
 };
 
 pub const RunResult = struct {
@@ -529,6 +530,7 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
         .stderr = &stderr,
         .stdout_limit = options.stdout_limit,
         .stderr_limit = options.stderr_limit,
+        .timeout = options.timeout,
     });
 
     const term = try child.wait(io);
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 19c974ff9f65c9beec210ea6498d76a65c28ac67..fe6dfa389d92a302fb3667d696b1b8e771dab42e 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -137,6 +137,7 @@ pub const CollectOutputOptions = struct {
     allocator: ?Allocator = null,
     stdout_limit: Io.Limit = .unlimited,
     stderr_limit: Io.Limit = .unlimited,
+    timeout: Io.Timeout = .none,
 };
 
 /// Collect the output from the process's stdout and stderr. Will return once
@@ -173,7 +174,7 @@ pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions)
         remaining += 1;
     }
     while (remaining > 0) {
-        try batch.wait(io, .none);
+        try batch.wait(io, options.timeout);
         while (batch.next()) |op| {
             const n = try reads[op].file_read_streaming.status.result;
             if (n == 0) {
diff --git a/lib/std/zig/LibCInstallation.zig b/lib/std/zig/LibCInstallation.zig
index 02b3df54dce74ee89913d717747f3740d08c8d37..6a3f4b4813aa84dd89e2e214c36273442f9a024c 100644
--- a/lib/std/zig/LibCInstallation.zig
+++ b/lib/std/zig/LibCInstallation.zig
@@ -268,7 +268,8 @@ fn findNativeIncludeDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, ar
     });
 
     const run_res = std.process.run(gpa, io, .{
-        .max_output_bytes = 1024 * 1024,
+        .stdout_limit = .limited(1024 * 1024),
+        .stderr_limit = .limited(1024 * 1024),
         .argv = argv.items,
         .environ_map = &environ_map,
         // Some C compilers, such as Clang, are known to rely on argv[0] to find the path
@@ -584,7 +585,8 @@ fn ccPrintFileName(gpa: Allocator, io: Io, args: CCPrintFileNameOptions) ![]u8 {
     try argv.append(arg1);
 
     const run_res = std.process.run(gpa, io, .{
-        .max_output_bytes = 1024 * 1024,
+        .stdout_limit = .limited(1024 * 1024),
+        .stderr_limit = .limited(1024 * 1024),
         .argv = argv.items,
         .environ_map = &environ_map,
         // Some C compilers, such as Clang, are known to rely on argv[0] to find the path
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 98c1b56e3855c919e2e0f80cb8af02e634a7154d..6b6021ab3c5e51351dd99a3e1e5b73a1ee18b33c 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -6873,6 +6873,7 @@ fn spawnZigRc(
     child_progress_node: std.Progress.Node,
 ) !void {
     const io = comp.io;
+    const gpa = comp.gpa;
     var node_name: std.ArrayList(u8) = .empty;
     defer node_name.deinit(arena);
 
@@ -6887,55 +6888,69 @@ fn spawnZigRc(
     });
     defer child.kill(io);
 
-    var poller = std.Io.poll(comp.gpa, enum { stdout, stderr }, .{
-        .stdout = child.stdout.?,
-        .stderr = child.stderr.?,
-    });
-    defer poller.deinit();
+    var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+    var multi_reader: Io.File.MultiReader = undefined;
+    multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
+    defer multi_reader.deinit();
 
-    const stdout = poller.reader(.stdout);
+    const stdout = multi_reader.fileReader(0);
+    const MessageHeader = std.zig.Server.Message.Header;
 
-    poll: while (true) {
-        const MessageHeader = std.zig.Server.Message.Header;
-        while (stdout.buffered().len < @sizeOf(MessageHeader)) if (!try poller.poll()) break :poll;
-        const header = stdout.takeStruct(MessageHeader, .little) catch unreachable;
-        while (stdout.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll;
-        const body = stdout.take(header.bytes_len) catch unreachable;
+    var eos_err: error{EndOfStream}!void = {};
 
+    while (true) {
+        const header = stdout.interface.takeStruct(MessageHeader, .little) catch |err| switch (err) {
+            error.EndOfStream => break,
+            error.ReadFailed => return stdout.err.?,
+        };
+        const body = stdout.interface.take(header.bytes_len) catch |err| switch (err) {
+            error.EndOfStream => |e| {
+                // Better to report the crash with stderr below, but we set
+                // this in case the child exits successfully while violating
+                // this protocol.
+                eos_err = e;
+                break;
+            },
+            error.ReadFailed => return stdout.err.?,
+        };
         switch (header.tag) {
             // We expect exactly one ErrorBundle, and if any error_bundle header is
             // sent then it's a fatal error.
             .error_bundle => {
-                const error_bundle = try std.zig.Server.allocErrorBundle(comp.gpa, body);
+                const error_bundle = try std.zig.Server.allocErrorBundle(gpa, body);
                 return comp.failWin32ResourceWithOwnedBundle(win32_resource, error_bundle);
             },
             else => {}, // ignore other messages
         }
     }
 
+    try multi_reader.fillRemaining(.none);
+
     // Just in case there's a failure that didn't send an ErrorBundle (e.g. an error return trace)
-    const stderr = poller.reader(.stderr);
-
     const term = child.wait(io) catch |err| {
         return comp.failWin32Resource(win32_resource, "unable to wait for {s} rc: {t}", .{ argv[0], err });
     };
 
+    const stderr = multi_reader.reader(1).buffered();
+
     switch (term) {
         .exited => |code| {
             if (code != 0) {
-                log.err("zig rc failed with stderr:\n{s}", .{stderr.buffered()});
+                log.err("zig rc failed with stderr:\n{s}", .{stderr});
                 return comp.failWin32Resource(win32_resource, "zig rc exited with code {d}", .{code});
             }
         },
         .signal => |sig| {
-            log.err("zig rc signaled {t} with stderr:\n{s}", .{ sig, stderr.buffered() });
+            log.err("zig rc signaled {t} with stderr:\n{s}", .{ sig, stderr });
             return comp.failWin32Resource(win32_resource, "zig rc terminated unexpectedly", .{});
         },
         else => {
-            log.err("zig rc terminated with stderr:\n{s}", .{stderr.buffered()});
+            log.err("zig rc terminated with stderr:\n{s}", .{stderr});
             return comp.failWin32Resource(win32_resource, "zig rc terminated unexpectedly", .{});
         },
     }
+
+    try eos_err;
 }
 
 pub fn tmpFilePath(comp: Compilation, ally: Allocator, suffix: []const u8) error{OutOfMemory}![]const u8 {
-- 
2.54.0


From 68a34df0257b4baec32617bf8c70c223849b59e2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 16 Jan 2026 21:07:59 -0800
Subject: [PATCH 121/499] std.Io.Threaded: fix error set

---
 lib/std/Io/Threaded.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 55a4c8aad73c59bb4c19bb4435877d33db033dac..0bddff2fc2b8695bf26d2de3d22328d8d087f027 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2475,6 +2475,7 @@ fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
 fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) return batchWaitWindows(t, b, timeout);
+    if (native_os == .wasi and !builtin.link_libc) @panic("TODO");
     const operations = b.operations;
     const len: u31 = @intCast(operations.len);
     const ring = b.ring[0..len];
@@ -2597,7 +2598,7 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
     b.user.complete_tail = complete_tail;
 }
 
-fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.ConcurrentError!void {
+fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
     const operations = b.operations;
     const len: u31 = @intCast(operations.len);
     const ring = b.ring[0..len];
-- 
2.54.0


From 9134430387bb99504c5813abc8b566a97ba5b1f0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 16 Jan 2026 21:21:56 -0800
Subject: [PATCH 122/499] std.Io.Threaded: fix batchWait impl

---
 lib/std/Io/Threaded.zig | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0bddff2fc2b8695bf26d2de3d22328d8d087f027..cfb690e634c1c13f812f22527abee1e97da594b5 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2524,6 +2524,7 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
             try operate(t, &operations[op]);
             ring[complete_tail.index(len)] = op;
             complete_tail = complete_tail.next(len);
+            poll_i = 0;
             return;
         },
         else => {},
@@ -2548,24 +2549,20 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
                     if (deadline == null) continue;
                     return error.Timeout;
                 }
-                var canceled = false;
-                for (poll_buffer[0..poll_i], map_buffer[0..poll_i]) |*poll_fd, op| {
+                while (poll_i != 0) {
+                    poll_i -= 1;
+                    const poll_fd = &poll_buffer[poll_i];
+                    const op = map_buffer[poll_i];
                     if (poll_fd.revents == 0) {
                         submit_head = submit_head.prev(len);
                         ring[submit_head.index(len)] = op;
                     } else {
-                        operate(t, &operations[op]) catch |err| switch (err) {
-                            error.Canceled => {
-                                canceled = true;
-                                continue;
-                            },
-                        };
+                        try operate(t, &operations[op]);
                         ring[complete_tail.index(len)] = op;
                         complete_tail = complete_tail.next(len);
                     }
                 }
-                poll_i = 0;
-                return if (canceled) error.Canceled;
+                return;
             },
             .INTR => continue,
             else => return error.ConcurrencyUnavailable,
-- 
2.54.0


From 54241bc770cbd610f48c365dce3c7ebf69336d73 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 16 Jan 2026 21:38:44 -0800
Subject: [PATCH 123/499] tools: update for std.process API changes

---
 tools/update_clang_options.zig | 1 -
 tools/update_cpu_features.zig  | 1 -
 2 files changed, 2 deletions(-)

diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig
index b52267a3fbd2c7efe37b58efe19615c5c8a8c556..a073062d88c6885f3d4237eaa6cc158e1942e21f 100644
--- a/tools/update_clang_options.zig
+++ b/tools/update_clang_options.zig
@@ -676,7 +676,6 @@ pub fn main(init: std.process.Init) !void {
 
     const child_result = try std.process.run(arena, io, .{
         .argv = &child_args,
-        .max_output_bytes = 100 * 1024 * 1024,
     });
 
     std.debug.print("{s}\n", .{child_result.stderr});
diff --git a/tools/update_cpu_features.zig b/tools/update_cpu_features.zig
index 3041ee6acc5129a3bfbe9b8d1295a94f69a529e7..eaa6a9afd262299842eeb842c3004b9c9a99bc7b 100644
--- a/tools/update_cpu_features.zig
+++ b/tools/update_cpu_features.zig
@@ -1987,7 +1987,6 @@ fn processOneTarget(io: Io, job: Job) void {
 
         const child_result = try std.process.run(arena, io, .{
             .argv = &child_args,
-            .max_output_bytes = 500 * 1024 * 1024,
         });
         tblgen_progress.end();
         if (child_result.stderr.len != 0) {
-- 
2.54.0


From a4d438562d794023e64e50c6826eb20aeef20eab Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 16 Jan 2026 21:39:03 -0800
Subject: [PATCH 124/499] std.Io.Threaded: fix compilation failures on Windows

it's still broken as hell tho
---
 lib/std/Io/Threaded.zig | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index cfb690e634c1c13f812f22527abee1e97da594b5..0adaa60a81e563a7ea638d64894fb8b7abe24f71 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1323,7 +1323,10 @@ fn waitForApcOrAlert() void {
 
 const max_iovecs_len = 8;
 const splat_buffer_size = 64;
-const poll_buffer_len = 32;
+/// Happens to be the same number that matches maximum number of handles that
+/// NtWaitForMultipleObjects accepts. We use this value also for poll() on
+/// posix systems.
+const poll_buffer_len = 64;
 const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
 
 comptime {
@@ -2635,18 +2638,13 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
                 overlapped.* = .{
                     .Internal = 0,
                     .InternalHigh = 0,
-                    .DUMMYUNIONNAME = .{
-                        .DUMMYSTRUCTNAME = .{
-                            .Offset = 0,
-                            .OffsetHigh = 0,
-                        },
-                        .Pointer = null,
-                    },
+                    .DUMMYUNIONNAME = .{ .Pointer = null },
                     .hEvent = null,
                 };
                 var n: windows.DWORD = undefined;
                 const buf = o.data[0];
-                if (windows.kernel32.ReadFile(o.file.handle, buf.ptr, buf.len, &n, overlapped) == 0) {
+                const buf_len = std.math.lossyCast(windows.DWORD, buf.len);
+                if (windows.kernel32.ReadFile(o.file.handle, buf.ptr, buf_len, &n, overlapped) == 0) {
                     @panic("TODO");
                 }
                 handles_buffer[buffer_i] = o.file.handle;
@@ -2663,6 +2661,7 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
             try operate(t, &operations[op]);
             ring[complete_tail.index(len)] = op;
             complete_tail = complete_tail.next(len);
+            buffer_i = 0;
             return;
         },
         else => {},
@@ -2672,10 +2671,15 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
     const map = map_buffer[0..buffer_i];
 
     const syscall: Syscall = try .start();
-    const index = windows.WaitForMultipleObjectsEx(handles, false, windows.INFINITE, true);
+    const index_result = windows.WaitForMultipleObjectsEx(handles, false, windows.INFINITE, true);
     syscall.finish();
+    const index = index_result catch |err| switch (err) {
+        error.Unexpected => @panic("TODO"),
+        error.WaitAbandoned => @panic("TODO"),
+        error.WaitTimeOut => @panic("TODO"),
+    };
     var n: windows.DWORD = undefined;
-    if (0 == windows.kernel32.GetOverlappedResult(handles[index], overlapped_buffer[index], &n, 0)) {
+    if (0 == windows.kernel32.GetOverlappedResult(handles[index], &overlapped_buffer[index], &n, 0)) {
         switch (windows.GetLastError()) {
             .BROKEN_PIPE => @panic("TODO"),
             .OPERATION_ABORTED => @panic("TODO"),
-- 
2.54.0


From 15ca46d1e70f24a1b37ac332630f6949552e4bda Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 16 Jan 2026 21:50:54 -0800
Subject: [PATCH 125/499] std.Io.Threaded: fix compilation error on some
 systems

---
 lib/std/Io/Threaded.zig | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0adaa60a81e563a7ea638d64894fb8b7abe24f71..4024263f4fc89b34e2df96084ce2b824c6553f13 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2486,8 +2486,8 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
     const submit_tail = b.user.submit_tail;
     b.impl.submit_tail = submit_tail;
     var complete_tail = b.impl.complete_tail;
-    var map_buffer: [poll_buffer_len]u32 = undefined; // poll_buffer index to operations index
-    var poll_i: usize = 0;
+    var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
+    var poll_i: u8 = 0;
     defer {
         for (map_buffer[0..poll_i]) |op| {
             submit_head = submit_head.prev(len);
@@ -2515,7 +2515,7 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
                     .events = posix.POLL.IN,
                     .revents = 0,
                 };
-                map_buffer[poll_i] = op;
+                map_buffer[poll_i] = @intCast(op);
                 poll_i += 1;
             },
         }
-- 
2.54.0


From a901ea23b0a53f6feba0111886156262fcff469d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 16 Jan 2026 22:39:23 -0800
Subject: [PATCH 126/499] update doctest API usage

---
 tools/doctest.zig | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tools/doctest.zig b/tools/doctest.zig
index 55b8ca7bfb87fae39b98550812b9dee165538f46..97a9a0be3f27e079d5028403749ba68bb3b7240f 100644
--- a/tools/doctest.zig
+++ b/tools/doctest.zig
@@ -201,7 +201,6 @@ fn printOutput(
                     .argv = build_args.items,
                     .cwd = tmp_dir_path,
                     .environ_map = environ_map,
-                    .max_output_bytes = max_doc_file_size,
                 });
                 switch (result.term) {
                     .exited => |exit_code| {
@@ -257,7 +256,6 @@ fn printOutput(
                     .argv = run_args,
                     .environ_map = environ_map,
                     .cwd = tmp_dir_path,
-                    .max_output_bytes = max_doc_file_size,
                 });
                 switch (result.term) {
                     .exited => |exit_code| {
@@ -376,7 +374,6 @@ fn printOutput(
                 .argv = test_args.items,
                 .environ_map = environ_map,
                 .cwd = tmp_dir_path,
-                .max_output_bytes = max_doc_file_size,
             });
             switch (result.term) {
                 .exited => |exit_code| {
@@ -432,7 +429,6 @@ fn printOutput(
                 .argv = test_args.items,
                 .environ_map = environ_map,
                 .cwd = tmp_dir_path,
-                .max_output_bytes = max_doc_file_size,
             });
             switch (result.term) {
                 .exited => |exit_code| {
@@ -508,7 +504,6 @@ fn printOutput(
                     .argv = build_args.items,
                     .environ_map = environ_map,
                     .cwd = tmp_dir_path,
-                    .max_output_bytes = max_doc_file_size,
                 });
                 switch (result.term) {
                     .exited => |exit_code| {
@@ -1132,7 +1127,6 @@ fn run(
         .argv = args,
         .environ_map = environ_map,
         .cwd = cwd,
-        .max_output_bytes = max_doc_file_size,
     });
     switch (result.term) {
         .exited => |exit_code| {
-- 
2.54.0


From ec74d650fe5ba6b5fddd0277b06b43a94383a0e0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 19 Jan 2026 15:14:43 -0800
Subject: [PATCH 127/499] incr-check: update to std.Io.File.MultiReader

from std.Io.poll
---
 tools/incr-check.zig | 80 ++++++++++++++++++++++++--------------------
 1 file changed, 44 insertions(+), 36 deletions(-)

diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index c9564f85c25ac752e46f744a07fa519a83e54ac2..840faf6f275aad2dc662183bd162698df443ee2d 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -28,6 +28,7 @@ fn logImpl(
 }
 
 pub fn main(init: std.process.Init) !void {
+    const gpa = init.gpa;
     const fatal = std.process.fatal;
     const arena = init.arena.allocator();
     const io = init.io;
@@ -224,11 +225,10 @@ pub fn main(init: std.process.Init) !void {
             .enable_darling = enable_darling,
         };
 
-        var poller = Io.poll(arena, Eval.StreamEnum, .{
-            .stdout = child.stdout.?,
-            .stderr = child.stderr.?,
-        });
-        defer poller.deinit();
+        var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+        var multi_reader: Io.File.MultiReader = undefined;
+        multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
+        defer multi_reader.deinit();
 
         for (case.updates) |update| {
             var update_node = target_prog_node.start(update.name, 0);
@@ -243,10 +243,10 @@ pub fn main(init: std.process.Init) !void {
 
             eval.write(update);
             try eval.requestUpdate();
-            try eval.check(&poller, update, update_node);
+            try eval.check(&multi_reader, update, update_node);
         }
 
-        try eval.end(&poller);
+        try eval.end(&multi_reader);
 
         waitChild(&child, &eval);
     }
@@ -272,9 +272,6 @@ const Eval = struct {
     enable_wasmtime: bool,
     enable_darling: bool,
 
-    const StreamEnum = enum { stdout, stderr };
-    const Poller = Io.Poller(StreamEnum);
-
     /// Currently this function assumes the previous updates have already been written.
     fn write(eval: *Eval, update: Case.Update) void {
         const io = eval.io;
@@ -293,23 +290,29 @@ const Eval = struct {
         }
     }
 
-    fn check(eval: *Eval, poller: *Poller, update: Case.Update, prog_node: std.Progress.Node) !void {
+    fn check(eval: *Eval, mr: *Io.File.MultiReader, update: Case.Update, prog_node: std.Progress.Node) !void {
         const arena = eval.arena;
-        const stdout = poller.reader(.stdout);
-        const stderr = poller.reader(.stderr);
+        const stdout = mr.fileReader(0);
+        const stderr = &mr.fileReader(1).interface;
+        const Header = std.zig.Server.Message.Header;
 
-        poll: while (true) {
-            const Header = std.zig.Server.Message.Header;
-            while (stdout.buffered().len < @sizeOf(Header)) if (!try poller.poll()) break :poll;
-            const header = stdout.takeStruct(Header, .little) catch unreachable;
-            while (stdout.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll;
-            const body = stdout.take(header.bytes_len) catch unreachable;
+        while (true) {
+            const header = stdout.interface.takeStruct(Header, .little) catch |err| switch (err) {
+                error.EndOfStream => break,
+                error.ReadFailed => return stdout.err.?,
+            };
+            const body = stdout.interface.take(header.bytes_len) catch |err| switch (err) {
+                // If this panic triggers it might be helpful to rework this
+                // code to print the stderr from the abnormally terminated child.
+                error.EndOfStream => @panic("unexpected mid-message end of stream"),
+                error.ReadFailed => return stdout.err.?,
+            };
 
             switch (header.tag) {
                 .error_bundle => {
                     const result_error_bundle = try std.zig.Server.allocErrorBundle(arena, body);
                     if (stderr.bufferedLen() > 0) {
-                        const stderr_data = try poller.toOwnedSlice(.stderr);
+                        const stderr_data = try mr.toOwnedSlice(1);
                         if (eval.allow_stderr) {
                             std.log.info("error_bundle stderr:\n{s}", .{stderr_data});
                         } else {
@@ -326,7 +329,7 @@ const Eval = struct {
                     var r: std.Io.Reader = .fixed(body);
                     _ = r.takeStruct(std.zig.Server.Message.EmitDigest, .little) catch unreachable;
                     if (stderr.bufferedLen() > 0) {
-                        const stderr_data = try poller.toOwnedSlice(.stderr);
+                        const stderr_data = try mr.toOwnedSlice(1);
                         if (eval.allow_stderr) {
                             std.log.info("emit_digest stderr:\n{s}", .{stderr_data});
                         } else {
@@ -358,11 +361,12 @@ const Eval = struct {
             }
         }
 
-        if (stderr.bufferedLen() > 0) {
+        const buffered_stderr = stderr.buffered();
+        if (buffered_stderr.len > 0) {
             if (eval.allow_stderr) {
-                std.log.info("stderr:\n{s}", .{stderr.buffered()});
+                std.log.info("stderr:\n{s}", .{buffered_stderr});
             } else {
-                eval.fatal("unexpected stderr:\n{s}", .{stderr.buffered()});
+                eval.fatal("unexpected stderr:\n{s}", .{buffered_stderr});
             }
         }
 
@@ -588,23 +592,27 @@ const Eval = struct {
         };
     }
 
-    fn end(eval: *Eval, poller: *Poller) !void {
+    fn end(eval: *Eval, mr: *Io.File.MultiReader) !void {
         requestExit(eval.child, eval);
 
-        const stdout = poller.reader(.stdout);
-        const stderr = poller.reader(.stderr);
+        const stdout = mr.fileReader(0);
+        const Header = std.zig.Server.Message.Header;
 
-        poll: while (true) {
-            const Header = std.zig.Server.Message.Header;
-            while (stdout.buffered().len < @sizeOf(Header)) if (!try poller.poll()) break :poll;
-            const header = stdout.takeStruct(Header, .little) catch unreachable;
-            while (stdout.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll;
-            stdout.toss(header.bytes_len);
+        while (true) {
+            const header = stdout.interface.takeStruct(Header, .little) catch |err| switch (err) {
+                error.EndOfStream => break,
+                error.ReadFailed => return stdout.err.?,
+            };
+            stdout.interface.discardAll(header.bytes_len) catch |err| switch (err) {
+                error.ReadFailed => return stdout.err.?,
+                error.EndOfStream => |e| return e,
+            };
         }
 
-        if (stderr.bufferedLen() > 0) {
-            eval.fatal("unexpected stderr:\n{s}", .{stderr.buffered()});
-        }
+        try mr.fillRemaining(.none);
+
+        const stderr = mr.reader(1).buffered();
+        if (stderr.len > 0) eval.fatal("unexpected stderr:\n{s}", .{stderr});
     }
 
     fn buildCOutput(eval: *Eval, c_path: []const u8, out_path: []const u8, prog_node: std.Progress.Node) !void {
-- 
2.54.0


From 276ca77bf04f574a730923aa77757ac0d2a464df Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 19 Jan 2026 15:16:51 -0800
Subject: [PATCH 128/499] build: adjust max_rss for behavior tests

observed error: memory usage peaked at 0.70GB (699138048 bytes),
exceeding the declared upper bound of 0.66GB (659809075 bytes)
---
 build.zig | 22 +---------------------
 1 file changed, 1 insertion(+), 21 deletions(-)

diff --git a/build.zig b/build.zig
index 9835714efd1dddf29af115c3c2a89dba528a6e06..aee378bdb2a0075c3d614b676d55631faacbd74c 100644
--- a/build.zig
+++ b/build.zig
@@ -472,27 +472,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = switch (b.graph.host.result.os.tag) {
-            .freebsd => 2_000_000_000,
-            .linux => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 659_809_075,
-                .loongarch64 => 598_902_374,
-                .powerpc64le => 627_431_833,
-                .riscv64 => 827_043_430,
-                .s390x => 580_596_121,
-                .x86_64 => 3_290_894_745,
-                else => 3_300_000_000,
-            },
-            .macos => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 767_736_217,
-                else => 800_000_000,
-            },
-            .windows => switch (b.graph.host.result.cpu.arch) {
-                .x86_64 => 603_070_054,
-                else => 700_000_000,
-            },
-            else => 3_300_000_000,
-        },
+        .max_rss = 3_300_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
-- 
2.54.0


From 37316a3cf61a0b193003a19b44116da346c6cd3e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 26 Jan 2026 16:25:58 -0800
Subject: [PATCH 129/499] std.Io.Threaded: resolve merge conflicts

---
 lib/std/Io/Threaded.zig | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 4024263f4fc89b34e2df96084ce2b824c6553f13..e60959abd00f7f3dc107abae88534138e5d4d3a3 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2459,7 +2459,6 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
 
 fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
     switch (op.*) {
         .noop => |*o| {
             _ = o.status.unstarted;
@@ -2467,7 +2466,7 @@ fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
         },
         .file_read_streaming => |*o| {
             _ = o.status.unstarted;
-            o.status = .{ .result = fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+            o.status = .{ .result = fileReadStreaming(t, o.file, o.data) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 else => |e| e,
             } };
-- 
2.54.0


From 523aa213c9f7466bdff5c7030de7d221f1547621 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 26 Jan 2026 19:07:01 -0800
Subject: [PATCH 130/499] std.Io.Threaded: batchWait and batchCancel for
 Windows

---
 lib/std/Build/Step/Run.zig |   1 -
 lib/std/Io.zig             |   8 +
 lib/std/Io/Threaded.zig    | 350 +++++++++++++++++++++++--------------
 3 files changed, 226 insertions(+), 133 deletions(-)

diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index c74286f61bfb6e6709223c40a12ed646ef46ef0b..a2d678275a40b49cd363686466067f5594774712 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1721,7 +1721,6 @@ fn evalZigTest(
                 // a crash of some kind. Either way, the child will terminate by itself -- wait for it.
                 const stderr_reader = multi_reader.reader(1);
                 const stderr_owned = try arena.dupe(u8, stderr_reader.buffered());
-                stderr_reader.tossBuffered();
 
                 // Clean up everything and wait for the child to exit.
                 child.stdin.?.close(io);
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index a63a89e4ee020f91a959e62ee91782d120348c6b..438fb0152957445d65bd3be978936ab0f5225448 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -350,6 +350,8 @@ pub const Batch = struct {
         }
     };
 
+    /// After calling this, it is safe to unconditionally defer a call to
+    /// `cancel`.
     pub fn init(operations: []Operation, ring: []u32) Batch {
         const len: u31 = @intCast(operations.len);
         assert(ring.len == len);
@@ -408,12 +410,18 @@ pub const Batch = struct {
     /// Starts work on any submitted operations and returns when at least one has completeed.
     ///
     /// Returns `error.Timeout` if `timeout` expires first.
+    ///
+    /// Depending on the `Io` implementation, may allocate resources that are
+    /// freed with `cancel`, even if an error is returned.
     pub fn wait(b: *Batch, io: Io, timeout: Timeout) WaitError!void {
         return io.vtable.batchWait(io.userdata, b, timeout);
     }
 
     /// Returns after all `operations` have completed. Operations which have not completed
     /// after this function returns were successfully dropped and had no side effects.
+    ///
+    /// This function is idempotent with respect to itself and `wait`. It is
+    /// safe to unconditionally `defer` a call to this function after `init`.
     pub fn cancel(b: *Batch, io: Io) void {
         return io.vtable.batchCancel(io.userdata, b);
     }
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index e60959abd00f7f3dc107abae88534138e5d4d3a3..0a17e58a67a14837aef66e20f4f7888540b84972 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1255,6 +1255,32 @@ const AlertableSyscall = struct {
         assert(is_windows);
     }
 
+    fn start() Io.Cancelable!AlertableSyscall {
+        const thread = Thread.current orelse return .{ .thread = null };
+        switch (thread.cancel_protection) {
+            .blocked => return .{ .thread = null },
+            .unblocked => {},
+        }
+        const old_status = thread.status.fetchOr(.{
+            .cancelation = @enumFromInt(0b010),
+            .awaitable = .null,
+        }, .monotonic);
+        switch (old_status.cancelation) {
+            .parked => unreachable,
+            .blocked => unreachable,
+            .blocked_alertable => unreachable,
+            .blocked_canceling => unreachable,
+            .blocked_alertable_canceling => unreachable,
+            .none => return .{ .thread = thread }, // new status is `.blocked_alertable`
+            .canceling => {
+                // Status is unchanged (still `.canceling`)---change to `.canceled` before return.
+                thread.status.store(.{ .cancelation = .canceled, .awaitable = old_status.awaitable }, .monotonic);
+                return error.Canceled;
+            },
+            .canceled => return .{ .thread = null }, // new status is `.canceled` (unchanged)
+        }
+    }
+
     fn checkCancel(s: AlertableSyscall) Io.Cancelable!void {
         comptime assert(is_windows);
         const thread = s.thread orelse return;
@@ -2501,10 +2527,10 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
         const op = ring[submit_head.index(len)];
         const operation = &operations[op];
         switch (operation.*) {
-            .noop => {
-                try operate(t, operation);
-                ring[complete_tail.index(len)] = op;
-                complete_tail = complete_tail.next(len);
+            .noop => |*o| {
+                _ = o.status.unstarted;
+                o.status = .{ .result = {} };
+                submitComplete(ring, &complete_tail, op);
             },
             .file_read_streaming => |*o| {
                 _ = o.status.unstarted;
@@ -2524,8 +2550,7 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
         1 => if (timeout == .none) {
             const op = map_buffer[0];
             try operate(t, &operations[op]);
-            ring[complete_tail.index(len)] = op;
-            complete_tail = complete_tail.next(len);
+            submitComplete(ring, &complete_tail, op);
             poll_i = 0;
             return;
         },
@@ -2560,8 +2585,7 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
                         ring[submit_head.index(len)] = op;
                     } else {
                         try operate(t, &operations[op]);
-                        ring[complete_tail.index(len)] = op;
-                        complete_tail = complete_tail.next(len);
+                        submitComplete(ring, &complete_tail, op);
                     }
                 }
                 return;
@@ -2584,19 +2608,49 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
     while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
         const op = ring[submit_head.index(len)];
         switch (operations[op]) {
-            .noop => {
-                operate(t, &operations[op]) catch unreachable;
-                ring[complete_tail.index(len)] = op;
-                complete_tail = complete_tail.next(len);
+            .noop => |*o| {
+                _ = o.status.unstarted;
+                o.status = .{ .result = {} };
+                submitComplete(ring, &complete_tail, op);
             },
             .file_read_streaming => |*o| _ = o.status.unstarted,
         }
     }
+    if (is_windows) {
+        // Iterate over pending and issue cancelations, then free the allocation for IO_STATUS_BLOCK
+        if (b.impl.reserved) |reserved| {
+            const gpa = t.allocator;
+            const metadatas_ptr: [*]WinOpMetadata = @ptrCast(@alignCast(reserved));
+            const metadatas = metadatas_ptr[0..b.operations.len];
+            for (metadatas, 0..) |*metadata, op| {
+                const done = @atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) != .PENDING;
+                if (done) continue;
+                switch (operations[op]) {
+                    .noop => unreachable,
+                    .file_read_streaming => |*o| {
+                        _ = windows.ntdll.NtCancelIoFile(o.file.handle, &metadata.iosb);
+                    },
+                }
+            }
+            for (metadatas) |*metadata| {
+                while (@atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) == .PENDING) {
+                    waitForApcOrAlert();
+                }
+            }
+            gpa.free(metadatas);
+            b.impl.reserved = null;
+        }
+    }
     b.impl.submit_head = submit_tail;
     b.impl.complete_tail = complete_tail;
     b.user.complete_tail = complete_tail;
 }
 
+const WinOpMetadata = struct {
+    iosb: windows.IO_STATUS_BLOCK,
+    pending: bool,
+};
+
 fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
     const operations = b.operations;
     const len: u31 = @intCast(operations.len);
@@ -2606,16 +2660,16 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
     b.impl.submit_tail = submit_tail;
     var complete_tail = b.impl.complete_tail;
 
-    var overlapped_buffer: [poll_buffer_len]windows.OVERLAPPED = undefined;
-    var handles_buffer: [poll_buffer_len]windows.HANDLE = undefined;
-    var map_buffer: [poll_buffer_len]u32 = undefined; // handles_buffer index to operations index
-    var buffer_i: usize = 0;
+    const metadatas_ptr: [*]WinOpMetadata = if (b.impl.reserved) |reserved| @ptrCast(@alignCast(reserved)) else a: {
+        const gpa = t.allocator;
+        const metadatas = gpa.alloc(WinOpMetadata, operations.len) catch return error.ConcurrencyUnavailable;
+        b.impl.reserved = metadatas.ptr;
+        @memset(metadatas, .{ .iosb = undefined, .pending = false });
+        break :a metadatas.ptr;
+    };
+    const metadatas = metadatas_ptr[0..operations.len];
 
     defer {
-        for (map_buffer[0..buffer_i]) |op| {
-            submit_head = submit_head.prev(len);
-            ring[submit_head.index(len)] = op;
-        }
         b.impl.submit_head = submit_head;
         b.impl.complete_tail = complete_tail;
         b.user.complete_tail = complete_tail;
@@ -2624,74 +2678,76 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
     while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
         const op = ring[submit_head.index(len)];
         const operation = &operations[op];
+        const metadata = &metadatas[op];
+        metadata.* = .{ .iosb = undefined, .pending = false };
         switch (operation.*) {
-            .noop => {
-                try operate(t, operation);
-                ring[complete_tail.index(len)] = op;
-                complete_tail = complete_tail.next(len);
+            .noop => |*o| {
+                _ = o.status.unstarted;
+                o.status = .{ .result = {} };
+                submitComplete(ring, &complete_tail, op);
             },
             .file_read_streaming => |*o| {
                 _ = o.status.unstarted;
-                if (handles_buffer.len - buffer_i == 0) return error.ConcurrencyUnavailable;
-                const overlapped = &overlapped_buffer[buffer_i];
-                overlapped.* = .{
-                    .Internal = 0,
-                    .InternalHigh = 0,
-                    .DUMMYUNIONNAME = .{ .Pointer = null },
-                    .hEvent = null,
-                };
-                var n: windows.DWORD = undefined;
-                const buf = o.data[0];
-                const buf_len = std.math.lossyCast(windows.DWORD, buf.len);
-                if (windows.kernel32.ReadFile(o.file.handle, buf.ptr, buf_len, &n, overlapped) == 0) {
-                    @panic("TODO");
+                switch (try ntReadFile(o.file.handle, o.data, &metadata.iosb)) {
+                    .status => {
+                        o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
+                        submitComplete(ring, &complete_tail, op);
+                    },
+                    .pending => {
+                        o.status = .{ .pending = b };
+                        metadata.pending = true;
+                    },
                 }
-                handles_buffer[buffer_i] = o.file.handle;
-                map_buffer[buffer_i] = op;
-                buffer_i += 1;
             },
         }
     }
 
-    switch (buffer_i) {
-        0 => return,
-        1 => if (timeout == .none) {
-            const op = map_buffer[0];
-            try operate(t, &operations[op]);
-            ring[complete_tail.index(len)] = op;
-            complete_tail = complete_tail.next(len);
-            buffer_i = 0;
-            return;
-        },
-        else => {},
-    }
-
-    const handles = handles_buffer[0..buffer_i];
-    const map = map_buffer[0..buffer_i];
+    var delay_interval: windows.LARGE_INTEGER = timeoutToWindowsInterval(timeout);
 
-    const syscall: Syscall = try .start();
-    const index_result = windows.WaitForMultipleObjectsEx(handles, false, windows.INFINITE, true);
-    syscall.finish();
-    const index = index_result catch |err| switch (err) {
-        error.Unexpected => @panic("TODO"),
-        error.WaitAbandoned => @panic("TODO"),
-        error.WaitTimeOut => @panic("TODO"),
-    };
-    var n: windows.DWORD = undefined;
-    if (0 == windows.kernel32.GetOverlappedResult(handles[index], &overlapped_buffer[index], &n, 0)) {
-        switch (windows.GetLastError()) {
-            .BROKEN_PIPE => @panic("TODO"),
-            .OPERATION_ABORTED => @panic("TODO"),
-            else => @panic("TODO"),
+    while (true) {
+        const alertable_syscall = try AlertableSyscall.start();
+        const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
+        alertable_syscall.finish();
+        switch (delay_rc) {
+            .SUCCESS => {
+                // The thread woke due to the timeout. Although spurious
+                // timeouts are OK, when no deadline is passed we must not
+                // return `error.Timeout`.
+                if (timeout != .none) return error.Timeout;
+            },
+            else => {},
         }
-    } else switch (operations[map[index]]) {
-        .noop => unreachable,
-        .file_read_streaming => |*o| {
-            o.status = .{ .result = n };
-        },
+        var any_done = false;
+        var any_pending = false;
+        for (metadatas, 0..) |*metadata, op_usize| {
+            if (!metadata.pending) continue;
+            any_pending = true;
+            const op: u31 = @intCast(op_usize);
+            const done = @atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) != .PENDING;
+            switch (operations[op]) {
+                .noop => unreachable,
+                .file_read_streaming => |*o| {
+                    assert(o.status.pending == b);
+                    if (!done) continue;
+                    o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
+                },
+            }
+            any_done = true;
+            metadata.pending = false;
+            submitComplete(ring, &complete_tail, op);
+        }
+        if (any_done) return;
+        if (!any_pending) return;
     }
 }
 
+fn submitComplete(ring: []u32, complete_tail: *Io.Batch.RingIndex, op: u32) void {
+    const ct = complete_tail.*;
+    const len: u31 = @intCast(ring.len);
+    ring[ct.index(len)] = op;
+    complete_tail.* = ct.next(len);
+}
+
 const dirCreateDir = switch (native_os) {
     .windows => dirCreateDirWindows,
     .wasi => dirCreateDirWasi,
@@ -5529,7 +5585,7 @@ fn dirRealPathFileWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8,
 
 fn realPathWindows(h_file: windows.HANDLE, out_buffer: []u8) File.RealPathError!usize {
     var wide_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
-    // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
+    // TODO move GetFinalPathNameByHandle logic into Io.Threaded and add cancel checks
     try Thread.checkCancel();
     const wide_slice = try windows.GetFinalPathNameByHandle(h_file, .{}, &wide_buf);
 
@@ -8617,70 +8673,42 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.Reader.Error!usiz
 }
 
 fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!usize {
-    var index: usize = 0;
-    while (index < data.len and data[index].len == 0) index += 1;
-    if (index == data.len) return 0;
-    const buffer = data[index];
-
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
-    const syscall: Syscall = try .start();
-    while (true) {
-        io_status_block.u.Status = .PENDING;
-        switch (windows.ntdll.NtReadFile(
-            file.handle,
-            null, // event
-            noopApc, // apc callback
-            null, // apc context
-            &io_status_block,
-            buffer.ptr,
-            @min(std.math.maxInt(u32), buffer.len),
-            null, // byte offset
-            null, // key
-        )) {
-            .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => {
-                syscall.finish();
-                return io_status_block.Information;
-            },
-            .PENDING => break,
-            .CANCELLED => {
-                try syscall.checkCancel();
-                continue;
-            },
-            .INVALID_DEVICE_REQUEST => return syscall.fail(error.IsDir),
-            .LOCK_NOT_GRANTED => return syscall.fail(error.LockViolation),
-            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-            .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err), // streaming read of async mode file
-            else => |status| return syscall.unexpectedNtstatus(status),
-        }
-    }
-    {
-        // Once we get here we received PENDING so we must not return from the
-        // function until the operation completes.
-        defer while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
-            waitForApcOrAlert();
-        };
+    if (ntReadFile(file.handle, data, &io_status_block)) |result| switch (result) {
+        .status => return ntReadFileResult(&io_status_block),
+        .pending => {
+            // Once we get here we received PENDING so we must not return from the
+            // function until the operation completes.
+            defer while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
+                waitForApcOrAlert();
+            };
 
-        const alertable_syscall = syscall.toAlertable() catch |err| switch (err) {
-            error.Canceled => |e| {
-                _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
-                return e;
-            },
-        };
-        defer alertable_syscall.finish();
-        waitForApcOrAlert();
-        while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
-            alertable_syscall.checkCancel() catch |err| switch (err) {
+            const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
                 error.Canceled => |e| {
                     _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
                     return e;
                 },
             };
+            defer alertable_syscall.finish();
             waitForApcOrAlert();
-        }
-    }
+            while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
+                alertable_syscall.checkCancel() catch |err| switch (err) {
+                    error.Canceled => |e| {
+                        _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
+                        return e;
+                    },
+                };
+                waitForApcOrAlert();
+            }
+        },
+    } else |err| return err;
+    return ntReadFileResult(&io_status_block);
+}
+
+fn ntReadFileResult(io_status_block: *windows.IO_STATUS_BLOCK) !usize {
     switch (io_status_block.u.Status) {
         .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => return io_status_block.Information,
-        .PENDING => unreachable, // cannot return until the operation completes
+        .PENDING => unreachable,
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
@@ -8688,6 +8716,47 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
     }
 }
 
+fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STATUS_BLOCK) Io.Cancelable!enum { status, pending } {
+    var index: usize = 0;
+    while (index < data.len and data[index].len == 0) index += 1;
+    if (index == data.len) {
+        iosb.u.Status = .SUCCESS;
+        iosb.Information = 0;
+        return .status;
+    }
+    const buffer = data[index];
+
+    const syscall: Syscall = try .start();
+    while (true) {
+        iosb.u.Status = .PENDING;
+        switch (windows.ntdll.NtReadFile(
+            handle,
+            null, // event
+            noopApc, // apc callback
+            null, // apc context
+            iosb,
+            buffer.ptr,
+            @min(std.math.maxInt(u32), buffer.len),
+            null, // byte offset
+            null, // key
+        )) {
+            .PENDING => {
+                syscall.finish();
+                return .pending;
+            },
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            else => |status| {
+                syscall.finish();
+                iosb.u.Status = status;
+                return .status;
+            },
+        }
+    }
+}
+
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
     if (!have_preadv) @compileError("TODO implement fileReadPositionalPosix for cursed operating systems that don't support preadv (it's only Haiku)");
 
@@ -9318,7 +9387,7 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             };
             defer w.CloseHandle(h_file);
 
-            // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
+            // TODO move GetFinalPathNameByHandle logic into Io.Threaded and add cancel checks
             try Thread.checkCancel();
             const wide_slice = try w.GetFinalPathNameByHandle(h_file, .{}, &path_name_w_buf.data);
 
@@ -12989,7 +13058,7 @@ fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirEr
 
     if (is_windows) {
         var dir_path_buffer: [windows.PATH_MAX_WIDE]u16 = undefined;
-        // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
+        // TODO move GetFinalPathNameByHandle logic into Io.Threaded and add cancel checks
         try Thread.checkCancel();
         const dir_path = try windows.GetFinalPathNameByHandle(dir.handle, .{}, &dir_path_buffer);
         const path_len_bytes = std.math.cast(u16, dir_path.len * 2) orelse return error.NameTooLong;
@@ -16657,7 +16726,7 @@ const parking_sleep = struct {
 /// Spurious wakeups are possible.
 ///
 /// `addr_hint` has no semantic effect, but may allow the OS to optimize this operation.
-fn park(opt_deadline: ?std.Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{Timeout}!void {
+fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{Timeout}!void {
     comptime assert(use_parking_futex or use_parking_sleep);
     switch (native_os) {
         .windows => {
@@ -16713,6 +16782,23 @@ fn park(opt_deadline: ?std.Io.Clock.Timestamp, addr_hint: ?*const anyopaque) err
     }
 }
 
+fn timeoutToWindowsInterval(timeout: Io.Timeout) windows.LARGE_INTEGER {
+    switch (timeout) {
+        .none => {
+            return std.math.minInt(windows.LARGE_INTEGER); // infinite timeout
+        },
+        .deadline => |deadline| {
+            const nanoseconds = deadline.raw.nanoseconds;
+            return @intCast(@divTrunc(nanoseconds, 100));
+        },
+        .duration => |duration| {
+            const now_timestamp = nowWindows(duration.clock) catch unreachable;
+            const deadline_ns = now_timestamp.nanoseconds + duration.raw.nanoseconds;
+            return @intCast(@divTrunc(deadline_ns, 100));
+        },
+    }
+}
+
 const UnparkTid = switch (native_os) {
     // `NtAlertMultipleThreadByThreadId` is weird and wants 64-bit thread handles?
     .windows => usize,
-- 
2.54.0


From efa502a1cd0333860848c2b6e15978f6551e02f3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jan 2026 11:29:03 -0800
Subject: [PATCH 131/499] std.Build.Step.Run: gracefully handle test runner
 misbehavior

specifically if it misbehaves after sending a message header but not the
body
---
 lib/std/Build/Step/Run.zig | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index a2d678275a40b49cd363686466067f5594774712..4d3cda54c948417c175caccdc0924da5cadfaf27 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1930,7 +1930,28 @@ fn waitZigTest(
         }
         // There is definitely a header available now -- read it.
         const header = stdout.takeStruct(Header, .little) catch unreachable;
-        try stdout.fill(header.bytes_len);
+
+        while (stdout.buffered().len < header.bytes_len) {
+            const timeout: Io.Timeout = t: {
+                const t = if (timer) |*t| t else break :t .none;
+                if (response_timeout_ns) |timeout_ns| break :t .{ .duration = .{
+                    .raw = .fromNanoseconds(timeout_ns -| t.read()),
+                    .clock = .awake,
+                } };
+                break :t .none;
+            };
+            multi_reader.fill(64, timeout) catch |err| switch (err) {
+                error.Timeout, error.EndOfStream => return .{ .no_poll = .{
+                    .active_test_index = active_test_index,
+                    .ns_elapsed = if (timer) |*t| t.read() else 0,
+                } },
+                error.UnsupportedClock => {
+                    timer = null;
+                    continue;
+                },
+                else => |e| return e,
+            };
+        }
 
         const body = stdout.take(header.bytes_len) catch unreachable;
         var body_r: std.Io.Reader = .fixed(body);
-- 
2.54.0


From 2fb224cb845c18044186c1348ca9a1b2a3152948 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jan 2026 11:33:07 -0800
Subject: [PATCH 132/499] std.Io.Threaded: fix bad use of AlertableSyscall

The defer would cause two problems:
1. keeping the state active during call to NtCancelIoFile
2. invalid state transition. after canceled is returned from
   checkCancel, new status is already canceled. calling finish after
   that is illegal.
---
 lib/std/Io/Threaded.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0a17e58a67a14837aef66e20f4f7888540b84972..0f0b043ce03e64344da90862c34bb287cc4aeb2a 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8689,7 +8689,6 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                     return e;
                 },
             };
-            defer alertable_syscall.finish();
             waitForApcOrAlert();
             while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
                 alertable_syscall.checkCancel() catch |err| switch (err) {
@@ -8700,6 +8699,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
                 };
                 waitForApcOrAlert();
             }
+            alertable_syscall.finish();
         },
     } else |err| return err;
     return ntReadFileResult(&io_status_block);
-- 
2.54.0


From fdf1ee973e9f3cb01f6fec9e460950622cdf92e4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jan 2026 13:24:27 -0800
Subject: [PATCH 133/499] std.Io.Threaded: move the NtDelayExecution later in
 batchWait

also guard against receiving SUCCESS with 0 byte read

ms docs say that pipes can do this if there is a 0 byte write
---
 lib/std/Io/Threaded.zig         | 42 +++++++++++++++++++++++----------
 lib/std/os/windows/kernel32.zig |  3 ---
 2 files changed, 29 insertions(+), 16 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0f0b043ce03e64344da90862c34bb287cc4aeb2a..00f14ed7412e851442dea2df6fec1a6b35f4df84 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2705,18 +2705,6 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
     var delay_interval: windows.LARGE_INTEGER = timeoutToWindowsInterval(timeout);
 
     while (true) {
-        const alertable_syscall = try AlertableSyscall.start();
-        const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
-        alertable_syscall.finish();
-        switch (delay_rc) {
-            .SUCCESS => {
-                // The thread woke due to the timeout. Although spurious
-                // timeouts are OK, when no deadline is passed we must not
-                // return `error.Timeout`.
-                if (timeout != .none) return error.Timeout;
-            },
-            else => {},
-        }
         var any_done = false;
         var any_pending = false;
         for (metadatas, 0..) |*metadata, op_usize| {
@@ -2738,6 +2726,18 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         }
         if (any_done) return;
         if (!any_pending) return;
+        const alertable_syscall = try AlertableSyscall.start();
+        const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
+        alertable_syscall.finish();
+        switch (delay_rc) {
+            .SUCCESS => {
+                // The thread woke due to the timeout. Although spurious
+                // timeouts are OK, when no deadline is passed we must not
+                // return `error.Timeout`.
+                if (timeout != .none) return error.Timeout;
+            },
+            else => {},
+        }
     }
 }
 
@@ -8707,7 +8707,11 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
 
 fn ntReadFileResult(io_status_block: *windows.IO_STATUS_BLOCK) !usize {
     switch (io_status_block.u.Status) {
-        .SUCCESS, .END_OF_FILE, .PIPE_BROKEN => return io_status_block.Information,
+        .SUCCESS => {
+            assert(io_status_block.Information != 0);
+            return io_status_block.Information;
+        },
+        .END_OF_FILE, .PIPE_BROKEN => return 0,
         .PENDING => unreachable,
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
@@ -8744,6 +8748,17 @@ fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STAT
                 syscall.finish();
                 return .pending;
             },
+            .SUCCESS => {
+                // Only END_OF_FILE is the true end.
+                if (iosb.Information == 0) {
+                    try syscall.checkCancel();
+                    continue;
+                } else {
+                    syscall.finish();
+                    iosb.u.Status = .SUCCESS;
+                    return .status;
+                }
+            },
             .CANCELLED => {
                 try syscall.checkCancel();
                 continue;
@@ -9709,6 +9724,7 @@ fn writeFileStreamingWindows(
     handle: windows.HANDLE,
     bytes: []const u8,
 ) File.Writer.Error!usize {
+    assert(bytes.len != 0);
     var bytes_written: windows.DWORD = undefined;
     const adjusted_len = std.math.lossyCast(u32, bytes.len);
     const syscall: Syscall = try .start();
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index fe28e40cbbedbd7381c2b787c27798589d75b7cc..b6785e4a33fb79eeed57e2786696f5d8ef49bb5e 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -188,9 +188,6 @@ pub extern "kernel32" fn PostQueuedCompletionStatus(
     lpOverlapped: ?*OVERLAPPED,
 ) callconv(.winapi) BOOL;
 
-// TODO:
-// GetOverlappedResultEx with bAlertable=false, which calls: GetStdHandle + WaitForSingleObjectEx.
-// Uses the SwitchBack system to run implementations for older programs; Do we care about this?
 pub extern "kernel32" fn GetOverlappedResult(
     hFile: HANDLE,
     lpOverlapped: *OVERLAPPED,
-- 
2.54.0


From 8a80b5464022a9fb4320e37f9dfc2aa83539ff07 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jan 2026 15:31:23 -0800
Subject: [PATCH 134/499] std: remove error.BrokenPipe from file reads, add
 error.EndOfStream

and make reading file streaming allowed to return 0 byte reads.
According to Microsoft documentation, on Windows it is possible to get
0-byte reads from pipes when 0-byte writes are made.
---
 lib/std/Io.zig                  |  8 ++--
 lib/std/Io/File.zig             |  5 +-
 lib/std/Io/File/MultiReader.zig | 14 ++----
 lib/std/Io/File/Reader.zig      | 34 +++++++------
 lib/std/Io/Threaded.zig         | 85 ++++++++++++++-------------------
 lib/std/Progress.zig            |  3 +-
 lib/std/process/Child.zig       | 28 ++++++-----
 lib/std/zig/system.zig          |  1 -
 8 files changed, 82 insertions(+), 96 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 438fb0152957445d65bd3be978936ab0f5225448..c00e4619e830a2fcd5a7e87bfce67b4a0201fa70 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -187,7 +187,7 @@ pub const VTable = struct {
     fileWritePositional: *const fn (?*anyopaque, File, header: []const u8, data: []const []const u8, splat: usize, offset: u64) File.WritePositionalError!usize,
     fileWriteFileStreaming: *const fn (?*anyopaque, File, header: []const u8, *Io.File.Reader, Io.Limit) File.Writer.WriteFileError!usize,
     fileWriteFilePositional: *const fn (?*anyopaque, File, header: []const u8, *Io.File.Reader, Io.Limit, offset: u64) File.WriteFilePositionalError!usize,
-    /// Returns 0 on end of stream.
+    /// Returns 0 if reading at or past the end.
     fileReadPositional: *const fn (?*anyopaque, File, data: []const []u8, offset: u64) File.ReadPositionalError!usize,
     fileSeekBy: *const fn (?*anyopaque, File, relative_offset: i64) File.SeekError!void,
     fileSeekTo: *const fn (?*anyopaque, File, absolute_offset: u64) File.SeekError!void,
@@ -263,18 +263,18 @@ pub const Operation = union(enum) {
         status: Status(void) = .{ .unstarted = {} },
     };
 
-    /// Returns 0 on end of stream.
+    /// May return 0 reads which is different than `error.EndOfStream`.
     pub const FileReadStreaming = struct {
         file: File,
         data: []const []u8,
         status: Status(Error!usize) = .{ .unstarted = {} },
 
-        pub const Error = error{
+        pub const Error = UnendingError || error{EndOfStream};
+        pub const UnendingError = error{
             InputOutput,
             SystemResources,
             /// Trying to read a directory file descriptor as if it were a file.
             IsDir,
-            BrokenPipe,
             ConnectionResetByPeer,
             /// File was not opened with read capability.
             NotOpenForReading,
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index c545b6022278d5043d8890a39a91a7baae81d1dc..df5b3b5a532239e1996287021d74d14ee37fd2ef 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -552,11 +552,13 @@ pub fn setTimestampsNow(file: File, io: Io) SetTimestampsError!void {
     });
 }
 
+pub const ReadStreamingError = error{EndOfStream} || Reader.Error;
+
 /// Returns 0 on stream end or if `buffer` has no space available for data.
 ///
 /// See also:
 /// * `reader`
-pub fn readStreaming(file: File, io: Io, buffer: []const []u8) Reader.Error!usize {
+pub fn readStreaming(file: File, io: Io, buffer: []const []u8) ReadStreamingError!usize {
     var operation: Io.Operation = .{ .file_read_streaming = .{
         .file = file,
         .data = buffer,
@@ -570,7 +572,6 @@ pub const ReadPositionalError = error{
     SystemResources,
     /// Trying to read a directory file descriptor as if it were a file.
     IsDir,
-    BrokenPipe,
     /// Non-blocking has been enabled, and reading from the file descriptor
     /// would block.
     WouldBlock,
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index 0cfa777e9687c35b8651700ad831fd6b6b69b9a2..08ad76000ca65a049e1537633b1d93ae18eef1f2 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -15,10 +15,9 @@ pub const Context = struct {
     fr: File.Reader,
     vec: [1][]u8,
     err: ?Error,
-    eos: bool,
 };
 
-pub const Error = Allocator.Error || File.Reader.Error || Io.ConcurrentError;
+pub const Error = Allocator.Error || File.ReadStreamingError || Io.ConcurrentError;
 
 /// Trailing:
 /// * `contexts: [len]Context`
@@ -85,7 +84,6 @@ pub fn init(mr: *MultiReader, gpa: Allocator, io: Io, streams: *Streams, files:
         },
         .vec = .{&.{}},
         .err = null,
-        .eos = false,
     };
     const operations = streams.operations();
     const ring = streams.ring();
@@ -198,8 +196,10 @@ fn fillUntimed(context: *Context, capacity: usize) Io.Reader.Error!void {
         },
         error.EndOfStream => |e| return e,
     };
-    if (context.err != null) return error.ReadFailed;
-    if (context.eos) return error.EndOfStream;
+    if (context.err) |err| switch (err) {
+        error.EndOfStream => |e| return e,
+        else => return error.ReadFailed,
+    };
 }
 
 pub const FillError = Io.Batch.WaitError || error{
@@ -225,10 +225,6 @@ pub fn fill(mr: *MultiReader, unused_capacity: usize, timeout: Io.Timeout) FillE
             context.err = err;
             continue;
         };
-        if (n == 0) {
-            context.eos = true;
-            continue;
-        }
         const r = &context.fr.interface;
         r.end += n;
         if (r.buffer.len - r.end < unused_capacity) {
diff --git a/lib/std/Io/File/Reader.zig b/lib/std/Io/File/Reader.zig
index 7703521d7ebb8b177d40335e06490af4a74cfd69..effd000df8d675e29368039c93f17fea053013f8 100644
--- a/lib/std/Io/File/Reader.zig
+++ b/lib/std/Io/File/Reader.zig
@@ -26,7 +26,7 @@ size_err: ?SizeError = null,
 seek_err: ?SeekError = null,
 interface: Io.Reader,
 
-pub const Error = Io.Operation.FileReadStreaming.Error || Io.Cancelable;
+pub const Error = Io.Operation.FileReadStreaming.UnendingError || Io.Cancelable;
 
 pub const SizeError = File.StatError || error{
     /// Occurs if, for example, the file handle is a network socket and therefore does not have a size.
@@ -280,14 +280,16 @@ fn readVecStreaming(r: *Reader, data: [][]u8) Io.Reader.Error!usize {
     const dest_n, const data_size = try r.interface.writableVector(&iovecs_buffer, data);
     const dest = iovecs_buffer[0..dest_n];
     assert(dest[0].len > 0);
-    const n = r.file.readStreaming(io, dest) catch |err| {
-        r.err = err;
-        return error.ReadFailed;
+    const n = r.file.readStreaming(io, dest) catch |err| switch (err) {
+        error.EndOfStream => {
+            r.size = r.pos;
+            return error.EndOfStream;
+        },
+        else => |e| {
+            r.err = e;
+            return error.ReadFailed;
+        },
     };
-    if (n == 0) {
-        r.size = r.pos;
-        return error.EndOfStream;
-    }
     r.pos += n;
     if (n > data_size) {
         r.interface.end += n - data_size;
@@ -335,14 +337,16 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
                 const dest_n, const data_size = try r.interface.writableVector(&iovecs_buffer, &data);
                 const dest = iovecs_buffer[0..dest_n];
                 assert(dest[0].len > 0);
-                const n = file.readStreaming(io, dest) catch |err| {
-                    r.err = err;
-                    return error.ReadFailed;
+                const n = file.readStreaming(io, dest) catch |err| switch (err) {
+                    error.EndOfStream => {
+                        r.size = r.pos;
+                        return error.EndOfStream;
+                    },
+                    else => |e| {
+                        r.err = e;
+                        return error.ReadFailed;
+                    },
                 };
-                if (n == 0) {
-                    r.size = r.pos;
-                    return error.EndOfStream;
-                }
                 r.pos += n;
                 if (n > data_size) {
                     r.interface.end += n - data_size;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 00f14ed7412e851442dea2df6fec1a6b35f4df84..c9c38c6b29a348b15112b9e3b82e884df416aefa 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8583,14 +8583,14 @@ fn fileClose(userdata: ?*anyopaque, files: []const File) void {
     for (files) |file| posix.close(file.handle);
 }
 
-fn fileReadStreaming(userdata: ?*anyopaque, file: File, data: []const []u8) File.Reader.Error!usize {
+fn fileReadStreaming(userdata: ?*anyopaque, file: File, data: []const []u8) File.ReadStreamingError!usize {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
     if (is_windows) return fileReadStreamingWindows(file, data);
     return fileReadStreamingPosix(file, data);
 }
 
-fn fileReadStreamingPosix(file: File, data: []const []u8) File.Reader.Error!usize {
+fn fileReadStreamingPosix(file: File, data: []const []u8) File.ReadStreamingError!usize {
     var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
     var i: usize = 0;
     for (data) |buf| {
@@ -8611,28 +8611,24 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.Reader.Error!usiz
             switch (std.os.wasi.fd_read(file.handle, dest.ptr, dest.len, &nread)) {
                 .SUCCESS => {
                     syscall.finish();
+                    if (nread == 0) return error.EndOfStream;
                     return nread;
                 },
                 .INTR, .TIMEDOUT => {
                     try syscall.checkCancel();
                     continue;
                 },
-                else => |e| {
-                    syscall.finish();
-                    switch (e) {
-                        .INVAL => |err| return errnoBug(err),
-                        .FAULT => |err| return errnoBug(err),
-                        .BADF => return error.IsDir, // File operation on directory.
-                        .IO => return error.InputOutput,
-                        .ISDIR => return error.IsDir,
-                        .NOBUFS => return error.SystemResources,
-                        .NOMEM => return error.SystemResources,
-                        .NOTCONN => return error.SocketUnconnected,
-                        .CONNRESET => return error.ConnectionResetByPeer,
-                        .NOTCAPABLE => return error.AccessDenied,
-                        else => |err| return posix.unexpectedErrno(err),
-                    }
-                },
+                .BADF => return syscall.fail(error.IsDir), // File operation on directory.
+                .IO => return syscall.fail(error.InputOutput),
+                .ISDIR => return syscall.fail(error.IsDir),
+                .NOBUFS => return syscall.fail(error.SystemResources),
+                .NOMEM => return syscall.fail(error.SystemResources),
+                .NOTCONN => return syscall.fail(error.SocketUnconnected),
+                .CONNRESET => return syscall.fail(error.ConnectionResetByPeer),
+                .NOTCAPABLE => return syscall.fail(error.AccessDenied),
+                .INVAL => |err| return syscall.errnoBug(err),
+                .FAULT => |err| return syscall.errnoBug(err),
+                else => |err| return syscall.unexpectedErrno(err),
             }
         }
     }
@@ -8643,36 +8639,33 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.Reader.Error!usiz
         switch (posix.errno(rc)) {
             .SUCCESS => {
                 syscall.finish();
+                if (rc == 0) return error.EndOfStream;
                 return @intCast(rc);
             },
             .INTR, .TIMEDOUT => {
                 try syscall.checkCancel();
                 continue;
             },
-            else => |e| {
+            .BADF => {
                 syscall.finish();
-                switch (e) {
-                    .INVAL => |err| return errnoBug(err),
-                    .FAULT => |err| return errnoBug(err),
-                    .AGAIN => return error.WouldBlock,
-                    .BADF => {
-                        if (native_os == .wasi) return error.IsDir; // File operation on directory.
-                        return error.NotOpenForReading;
-                    },
-                    .IO => return error.InputOutput,
-                    .ISDIR => return error.IsDir,
-                    .NOBUFS => return error.SystemResources,
-                    .NOMEM => return error.SystemResources,
-                    .NOTCONN => return error.SocketUnconnected,
-                    .CONNRESET => return error.ConnectionResetByPeer,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
+                if (native_os == .wasi) return error.IsDir; // File operation on directory.
+                return error.NotOpenForReading;
             },
+            .AGAIN => return syscall.fail(error.WouldBlock),
+            .IO => return syscall.fail(error.InputOutput),
+            .ISDIR => return syscall.fail(error.IsDir),
+            .NOBUFS => return syscall.fail(error.SystemResources),
+            .NOMEM => return syscall.fail(error.SystemResources),
+            .NOTCONN => return syscall.fail(error.SocketUnconnected),
+            .CONNRESET => return syscall.fail(error.ConnectionResetByPeer),
+            .INVAL => |err| return syscall.errnoBug(err),
+            .FAULT => |err| return syscall.errnoBug(err),
+            else => |err| return syscall.unexpectedErrno(err),
         }
     }
 }
 
-fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!usize {
+fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingError!usize {
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     if (ntReadFile(file.handle, data, &io_status_block)) |result| switch (result) {
         .status => return ntReadFileResult(&io_status_block),
@@ -8707,11 +8700,9 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.Reader.Error!us
 
 fn ntReadFileResult(io_status_block: *windows.IO_STATUS_BLOCK) !usize {
     switch (io_status_block.u.Status) {
-        .SUCCESS => {
-            assert(io_status_block.Information != 0);
-            return io_status_block.Information;
-        },
-        .END_OF_FILE, .PIPE_BROKEN => return 0,
+        .SUCCESS => return io_status_block.Information,
+        .END_OF_FILE => return error.EndOfStream,
+        .PIPE_BROKEN => return error.EndOfStream,
         .PENDING => unreachable,
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
@@ -8749,15 +8740,9 @@ fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STAT
                 return .pending;
             },
             .SUCCESS => {
-                // Only END_OF_FILE is the true end.
-                if (iosb.Information == 0) {
-                    try syscall.checkCancel();
-                    continue;
-                } else {
-                    syscall.finish();
-                    iosb.u.Status = .SUCCESS;
-                    return .status;
-                }
+                syscall.finish();
+                iosb.u.Status = .SUCCESS;
+                return .status;
             },
             .CANCELLED => {
                 try syscall.checkCancel();
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 5ccc46778b43d0260ee1a6323e13eae20e31a2c9..d0ee9e556f5c384cf7eef6952900447d7c45a07b 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -984,7 +984,7 @@ fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buff
         var bytes_read: usize = 0;
         while (true) {
             const n = file.readStreaming(io, &.{pipe_buf[bytes_read..]}) catch |err| switch (err) {
-                error.WouldBlock => break,
+                error.WouldBlock, error.EndOfStream => break,
                 else => |e| {
                     std.log.debug("failed to read child progress data: {t}", .{e});
                     main_storage.completed_count = 0;
@@ -992,7 +992,6 @@ fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buff
                     continue :main_loop;
                 },
             };
-            if (n == 0) break;
             if (opt_saved_metadata) |m| {
                 if (m.remaining_read_trash_bytes > 0) {
                     assert(bytes_read == 0);
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index fe6dfa389d92a302fb3667d696b1b8e771dab42e..e226fb7a9b27c4b48647798fb715a65401d964f1 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -176,19 +176,21 @@ pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions)
     while (remaining > 0) {
         try batch.wait(io, options.timeout);
         while (batch.next()) |op| {
-            const n = try reads[op].file_read_streaming.status.result;
-            if (n == 0) {
-                remaining -= 1;
-            } else {
-                lists[op].items.len += n;
-                if (lists[op].items.len > @intFromEnum(limits[op])) return error.StreamTooLong;
-                if (options.allocator) |gpa| try lists[op].ensureUnusedCapacity(gpa, 1);
-                const cap = lists[op].unusedCapacitySlice();
-                if (cap.len == 0) return error.StreamTooLong;
-                vecs[op][0] = cap;
-                reads[op].file_read_streaming.status = .{ .unstarted = {} };
-                batch.add(op);
-            }
+            const n = reads[op].file_read_streaming.status.result catch |err| switch (err) {
+                error.EndOfStream => {
+                    remaining -= 1;
+                    continue;
+                },
+                else => |e| return e,
+            };
+            lists[op].items.len += n;
+            if (lists[op].items.len > @intFromEnum(limits[op])) return error.StreamTooLong;
+            if (options.allocator) |gpa| try lists[op].ensureUnusedCapacity(gpa, 1);
+            const cap = lists[op].unusedCapacitySlice();
+            if (cap.len == 0) return error.StreamTooLong;
+            vecs[op][0] = cap;
+            reads[op].file_read_streaming.status = .{ .unstarted = {} };
+            batch.add(op);
         }
     }
 }
diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig
index 5046e2f51b081b77c95a9e08020eb24b688498a5..b32b554dee373c371084740ae91294ef264c1206 100644
--- a/lib/std/zig/system.zig
+++ b/lib/std/zig/system.zig
@@ -420,7 +420,6 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target {
         error.Canceled => |e| return e,
         error.Unexpected => |e| return e,
         error.WouldBlock => return error.Unexpected,
-        error.BrokenPipe => return error.Unexpected,
         error.ConnectionResetByPeer => return error.Unexpected,
         error.NotOpenForReading => return error.Unexpected,
         error.SocketUnconnected => return error.Unexpected,
-- 
2.54.0


From 6a1fd3c69db486df7a805d211e484c60efe294ae Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 00:01:41 -0800
Subject: [PATCH 135/499] std.Io.File.MultiReader: make checkAnyError exclude
 EndOfStream

---
 lib/std/Build/Step/Run.zig      |  6 ++----
 lib/std/Io/File/MultiReader.zig | 10 ++++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 4d3cda54c948417c175caccdc0924da5cadfaf27..55fee9a2868b74b0a6006cb67c7a366b7b477ed4 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1385,14 +1385,12 @@ fn runCommand(
             break :term spawnChildAndCollect(run, interp_argv.items, &environ_map, has_side_effects, options, fuzz_context) catch |e| {
                 if (!run.failing_to_execute_foreign_is_an_error) return error.MakeSkipped;
                 if (e == error.MakeFailed) return error.MakeFailed; // error already reported
-                return step.fail("unable to spawn interpreter {s}: {s}", .{
-                    interp_argv.items[0], @errorName(e),
-                });
+                return step.fail("unable to spawn interpreter {s}: {t}", .{ interp_argv.items[0], e });
             };
         }
         if (err == error.MakeFailed) return error.MakeFailed; // error already reported
 
-        return step.fail("failed to spawn and capture stdio from {s}: {s}", .{ argv[0], @errorName(err) });
+        return step.fail("failed to spawn and capture stdio from {s}: {t}", .{ argv[0], err });
     };
 
     const generic_result = opt_generic_result orelse {
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index 08ad76000ca65a049e1537633b1d93ae18eef1f2..7a0f8de068d5912b8ba903665eba0b1c19fb7265 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -17,7 +17,8 @@ pub const Context = struct {
     err: ?Error,
 };
 
-pub const Error = Allocator.Error || File.ReadStreamingError || Io.ConcurrentError;
+pub const Error = UnendingError || error{EndOfStream};
+pub const UnendingError = Allocator.Error || File.Reader.Error || Io.ConcurrentError;
 
 /// Trailing:
 /// * `contexts: [len]Context`
@@ -126,13 +127,14 @@ pub fn reader(mr: *MultiReader, index: usize) *Io.Reader {
 }
 
 /// Checks for errors in all streams, prioritizing `error.Canceled` if it
-/// occurred anywhere.
-pub fn checkAnyError(mr: *const MultiReader) Error!void {
+/// occurred anywhere, and ignoring `error.EndOfStream`.
+pub fn checkAnyError(mr: *const MultiReader) UnendingError!void {
     const contexts = mr.streams.contexts();
-    var other: Error!void = {};
+    var other: UnendingError!void = {};
     for (contexts) |*context| {
         if (context.err) |err| switch (err) {
             error.Canceled => |e| return e,
+            error.EndOfStream => continue,
             else => |e| other = e,
         };
     }
-- 
2.54.0


From b2816f26980f7ac9f0d87c844320e29dfbb6269e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 02:27:20 -0800
Subject: [PATCH 136/499] build.zig: only-c implies no-lib

---
 build.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.zig b/build.zig
index aee378bdb2a0075c3d614b676d55631faacbd74c..3ed237fa5ea851ee8412851715038400ec29e1b7 100644
--- a/build.zig
+++ b/build.zig
@@ -29,7 +29,7 @@ pub fn build(b: *std.Build) !void {
     const use_zig_libcxx = b.option(bool, "use-zig-libcxx", "If libc++ is needed, use zig's bundled version, don't try to integrate with the system") orelse false;
 
     const test_step = b.step("test", "Run all the tests");
-    const skip_install_lib_files = b.option(bool, "no-lib", "skip copying of lib/ files and langref to installation prefix. Useful for development") orelse false;
+    const skip_install_lib_files = b.option(bool, "no-lib", "skip copying of lib/ files and langref to installation prefix. Useful for development") orelse only_c;
     const skip_install_langref = b.option(bool, "no-langref", "skip copying of langref to the installation prefix") orelse skip_install_lib_files;
     const std_docs = b.option(bool, "std-docs", "include standard library autodocs") orelse false;
     const no_bin = b.option(bool, "no-bin", "skip emitting compiler binary") orelse false;
-- 
2.54.0


From 687123a85eaac8b7c290b21c346e8aeb8470dfcb Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 17:43:42 -0800
Subject: [PATCH 137/499] std.process.run: use Io.File.MultiReader

and delete the special-cased function
---
 lib/std/process.zig       | 49 +++++++++++++++------------
 lib/std/process/Child.zig | 70 ---------------------------------------
 2 files changed, 28 insertions(+), 91 deletions(-)

diff --git a/lib/std/process.zig b/lib/std/process.zig
index 6f3c155f6d6712c71e582a047ab1c41ee160c4f7..739027da0754f922f9418a7d1b124f08a26a408e 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -453,16 +453,16 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
     return io.vtable.processSpawnPath(io.userdata, dir, options);
 }
 
-pub const RunError = SpawnError || Child.CollectOutputError;
+pub const RunError = SpawnError || error{
+    StreamTooLong,
+} || Io.ConcurrentError || Allocator.Error || Io.File.Reader.Error || Io.Timeout.Error;
 
 pub const RunOptions = struct {
     argv: []const []const u8,
     stderr_limit: Io.Limit = .unlimited,
     stdout_limit: Io.Limit = .unlimited,
-    /// How many bytes to initially allocate for stderr.
-    stderr_reserve_amount: usize = 1,
-    /// How many bytes to initially allocate for stdout.
-    stdout_reserve_amount: usize = 1,
+    /// How many bytes to initially allocate for stderr and stdout.
+    reserve_amount: usize = 64,
 
     /// Set to change the current working directory when spawning the child process.
     cwd: ?[]const u8 = null,
@@ -516,29 +516,36 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
     });
     defer child.kill(io);
 
-    var stdout: std.ArrayList(u8) = .empty;
-    defer stdout.deinit(gpa);
-    var stderr: std.ArrayList(u8) = .empty;
-    defer stderr.deinit(gpa);
+    var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+    var multi_reader: Io.File.MultiReader = undefined;
+    multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
+    defer multi_reader.deinit();
 
-    try stdout.ensureUnusedCapacity(gpa, options.stdout_reserve_amount);
-    try stderr.ensureUnusedCapacity(gpa, options.stderr_reserve_amount);
+    const stdout_reader = multi_reader.reader(0);
+    const stderr_reader = multi_reader.reader(1);
 
-    try child.collectOutput(io, .{
-        .allocator = gpa,
-        .stdout = &stdout,
-        .stderr = &stderr,
-        .stdout_limit = options.stdout_limit,
-        .stderr_limit = options.stderr_limit,
-        .timeout = options.timeout,
-    });
+    while (multi_reader.fill(options.reserve_amount, options.timeout)) |_| {
+        if (options.stdout_limit.toInt()) |limit| {
+            if (stdout_reader.buffered().len > limit)
+                return error.StreamTooLong;
+        }
+        if (options.stderr_limit.toInt()) |limit| {
+            if (stderr_reader.buffered().len > limit)
+                return error.StreamTooLong;
+        }
+    } else |err| switch (err) {
+        error.EndOfStream => {},
+        else => |e| return e,
+    }
+
+    try multi_reader.checkAnyError();
 
     const term = try child.wait(io);
 
-    const stdout_slice = try stdout.toOwnedSlice(gpa);
+    const stdout_slice = try multi_reader.toOwnedSlice(0);
     errdefer gpa.free(stdout_slice);
 
-    const stderr_slice = try stderr.toOwnedSlice(gpa);
+    const stderr_slice = try multi_reader.toOwnedSlice(1);
     errdefer gpa.free(stderr_slice);
 
     return .{
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index e226fb7a9b27c4b48647798fb715a65401d964f1..c87d221a95c4ecdff81b467f8db72495a32a642f 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -124,73 +124,3 @@ pub fn wait(child: *Child, io: Io) WaitError!Term {
     assert(child.id != null);
     return io.vtable.childWait(io.userdata, child);
 }
-
-pub const CollectOutputError = error{
-    StreamTooLong,
-} || Io.ConcurrentError || Allocator.Error || Io.File.Reader.Error || Io.Timeout.Error;
-
-pub const CollectOutputOptions = struct {
-    stdout: *std.ArrayList(u8),
-    stderr: *std.ArrayList(u8),
-    /// Used for `stdout` and `stderr`. If not provided, only the existing
-    /// capacity will be used.
-    allocator: ?Allocator = null,
-    stdout_limit: Io.Limit = .unlimited,
-    stderr_limit: Io.Limit = .unlimited,
-    timeout: Io.Timeout = .none,
-};
-
-/// Collect the output from the process's stdout and stderr. Will return once
-/// all output has been collected. This does not mean that the process has
-/// ended. `wait` should still be called to wait for and clean up the process.
-///
-/// The process must have been started with stdout and stderr set to
-/// `process.SpawnOptions.StdIo.pipe`.
-pub fn collectOutput(child: *const Child, io: Io, options: CollectOutputOptions) CollectOutputError!void {
-    const files: [2]Io.File = .{ child.stdout.?, child.stderr.? };
-    const lists: [2]*std.ArrayList(u8) = .{ options.stdout, options.stderr };
-    const limits: [2]Io.Limit = .{ options.stdout_limit, options.stderr_limit };
-    var reads: [2]Io.Operation = undefined;
-    var vecs: [2][1][]u8 = undefined;
-    var ring: [2]u32 = undefined;
-    var batch: Io.Batch = .init(&reads, &ring);
-    defer {
-        batch.cancel(io);
-        while (batch.next()) |op| {
-            lists[op].items.len += reads[op].file_read_streaming.status.result catch continue;
-        }
-    }
-    var remaining: usize = 0;
-    for (0.., &reads, &lists, &files, &vecs) |op, *read, list, file, *vec| {
-        if (options.allocator) |gpa| try list.ensureUnusedCapacity(gpa, 1);
-        const cap = list.unusedCapacitySlice();
-        if (cap.len == 0) return error.StreamTooLong;
-        vec[0] = cap;
-        read.* = .{ .file_read_streaming = .{
-            .file = file,
-            .data = vec,
-        } };
-        batch.add(op);
-        remaining += 1;
-    }
-    while (remaining > 0) {
-        try batch.wait(io, options.timeout);
-        while (batch.next()) |op| {
-            const n = reads[op].file_read_streaming.status.result catch |err| switch (err) {
-                error.EndOfStream => {
-                    remaining -= 1;
-                    continue;
-                },
-                else => |e| return e,
-            };
-            lists[op].items.len += n;
-            if (lists[op].items.len > @intFromEnum(limits[op])) return error.StreamTooLong;
-            if (options.allocator) |gpa| try lists[op].ensureUnusedCapacity(gpa, 1);
-            const cap = lists[op].unusedCapacitySlice();
-            if (cap.len == 0) return error.StreamTooLong;
-            vecs[op][0] = cap;
-            reads[op].file_read_streaming.status = .{ .unstarted = {} };
-            batch.add(op);
-        }
-    }
-}
-- 
2.54.0


From 7a13d57916aae2840047cc3461aa44c3a72ca546 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 17:59:46 -0800
Subject: [PATCH 138/499] std.Io.Threaded: add missing check for pending status
 in batchCancel

---
 lib/std/Io/Threaded.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c9c38c6b29a348b15112b9e3b82e884df416aefa..05ff37b76e40867ff7f0df62196aac07b3072353 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2623,6 +2623,7 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
             const metadatas_ptr: [*]WinOpMetadata = @ptrCast(@alignCast(reserved));
             const metadatas = metadatas_ptr[0..b.operations.len];
             for (metadatas, 0..) |*metadata, op| {
+                if (!metadata.pending) continue;
                 const done = @atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) != .PENDING;
                 if (done) continue;
                 switch (operations[op]) {
@@ -2633,6 +2634,7 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
                 }
             }
             for (metadatas) |*metadata| {
+                if (!metadata.pending) continue;
                 while (@atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) == .PENDING) {
                     waitForApcOrAlert();
                 }
-- 
2.54.0


From d770e14e001daaea9eb921c1630af69c518468a2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 18:19:12 -0800
Subject: [PATCH 139/499] std.Io.Threaded.batchWaitWindows: eager result sets
 any_done true

Thanks jacobly for finding the bug
---
 lib/std/Io/Threaded.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 05ff37b76e40867ff7f0df62196aac07b3072353..cfcb9f65dfb4aaba360f593f1f7442c545f302e1 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2677,6 +2677,8 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         b.user.complete_tail = complete_tail;
     }
 
+    var any_done = false;
+
     while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
         const op = ring[submit_head.index(len)];
         const operation = &operations[op];
@@ -2686,6 +2688,7 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
             .noop => |*o| {
                 _ = o.status.unstarted;
                 o.status = .{ .result = {} };
+                any_done = true;
                 submitComplete(ring, &complete_tail, op);
             },
             .file_read_streaming => |*o| {
@@ -2693,6 +2696,7 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
                 switch (try ntReadFile(o.file.handle, o.data, &metadata.iosb)) {
                     .status => {
                         o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
+                        any_done = true;
                         submitComplete(ring, &complete_tail, op);
                     },
                     .pending => {
@@ -2707,7 +2711,6 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
     var delay_interval: windows.LARGE_INTEGER = timeoutToWindowsInterval(timeout);
 
     while (true) {
-        var any_done = false;
         var any_pending = false;
         for (metadatas, 0..) |*metadata, op_usize| {
             if (!metadata.pending) continue;
-- 
2.54.0


From 3320e6a1ae453d40dd78ff3abf6c8543bec2555d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 18:40:48 -0800
Subject: [PATCH 140/499] std.Io.Threaded.batchWait better fix for any_done

It is legal to call batchWait with already completed operations in the
ring. In such case, we need to avoid waiting in the syscall. The
any_done flag was a poor way of tracking state we already have: whether
the completion queue is empty.

This problem affects the posix poll implementation as well.

Thanks again to jacobly for finding the problem.
---
 lib/std/Io/Threaded.zig | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index cfcb9f65dfb4aaba360f593f1f7442c545f302e1..29f578757444279ebe7070d6c249b15167ad4726 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2560,17 +2560,31 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
     const deadline = timeout.toDeadline(t_io) catch return error.UnsupportedClock;
     const max_poll_ms = std.math.maxInt(i32);
     while (true) {
-        const timeout_ms: i32 = if (deadline) |d| t: {
+        const timeout_ms: i32 = t: {
+            if (b.user.complete_head != complete_tail) {
+                // It is legal to call batchWait with already completed
+                // operations in the ring. In such case, we need to avoid
+                // blocking in the poll syscall, but we can still take this
+                // opportunity to find additional ready operations.
+                break :t 0;
+            }
+            const d = deadline orelse break :t -1;
             const duration = d.durationFromNow(t_io) catch return error.UnsupportedClock;
             if (duration.raw.nanoseconds <= 0) return error.Timeout;
             break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
-        } else -1;
+        };
         const syscall = try Syscall.start();
         const rc = posix.system.poll(&poll_buffer, poll_i, timeout_ms);
         syscall.finish();
         switch (posix.errno(rc)) {
             .SUCCESS => {
                 if (rc == 0) {
+                    if (b.user.complete_head != complete_tail) {
+                        // Since there are already completions available in the
+                        // queue, this is neither a timeout nor a case for
+                        // retrying.
+                        return;
+                    }
                     // Although spurious timeouts are OK, when no deadline is
                     // passed we must not return `error.Timeout`.
                     if (deadline == null) continue;
@@ -2677,8 +2691,6 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         b.user.complete_tail = complete_tail;
     }
 
-    var any_done = false;
-
     while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
         const op = ring[submit_head.index(len)];
         const operation = &operations[op];
@@ -2688,7 +2700,6 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
             .noop => |*o| {
                 _ = o.status.unstarted;
                 o.status = .{ .result = {} };
-                any_done = true;
                 submitComplete(ring, &complete_tail, op);
             },
             .file_read_streaming => |*o| {
@@ -2696,7 +2707,6 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
                 switch (try ntReadFile(o.file.handle, o.data, &metadata.iosb)) {
                     .status => {
                         o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
-                        any_done = true;
                         submitComplete(ring, &complete_tail, op);
                     },
                     .pending => {
@@ -2725,11 +2735,10 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
                     o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
                 },
             }
-            any_done = true;
             metadata.pending = false;
             submitComplete(ring, &complete_tail, op);
         }
-        if (any_done) return;
+        if (b.user.complete_head != complete_tail) return;
         if (!any_pending) return;
         const alertable_syscall = try AlertableSyscall.start();
         const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
-- 
2.54.0


From 4dd7fe90a2b541a44aafc3a9596445387a3aed49 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 28 Jan 2026 21:02:43 -0800
Subject: [PATCH 141/499] std.Io.Threaded: compress ntReadFile logic

Just use the ntstatus field rather than an additional enum
---
 lib/std/Io/Threaded.zig | 137 ++++++++++++++++++----------------------
 1 file changed, 61 insertions(+), 76 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 29f578757444279ebe7070d6c249b15167ad4726..fbe12ada55850624b850c7c791c6d474d008b5d1 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2695,7 +2695,10 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         const op = ring[submit_head.index(len)];
         const operation = &operations[op];
         const metadata = &metadatas[op];
-        metadata.* = .{ .iosb = undefined, .pending = false };
+        metadata.* = .{ .iosb = .{
+            .u = .{ .Status = .PENDING },
+            .Information = 0,
+        }, .pending = false };
         switch (operation.*) {
             .noop => |*o| {
                 _ = o.status.unstarted;
@@ -2704,15 +2707,13 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
             },
             .file_read_streaming => |*o| {
                 _ = o.status.unstarted;
-                switch (try ntReadFile(o.file.handle, o.data, &metadata.iosb)) {
-                    .status => {
-                        o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
-                        submitComplete(ring, &complete_tail, op);
-                    },
-                    .pending => {
-                        o.status = .{ .pending = b };
-                        metadata.pending = true;
-                    },
+                try ntReadFile(o.file.handle, o.data, &metadata.iosb);
+                if (@atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) == .PENDING) {
+                    o.status = .{ .pending = b };
+                    metadata.pending = true;
+                } else {
+                    o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
+                    submitComplete(ring, &complete_tail, op);
                 }
             },
         }
@@ -8680,44 +8681,36 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.ReadStreamingErro
 }
 
 fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingError!usize {
-    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
-    if (ntReadFile(file.handle, data, &io_status_block)) |result| switch (result) {
-        .status => return ntReadFileResult(&io_status_block),
-        .pending => {
-            // Once we get here we received PENDING so we must not return from the
-            // function until the operation completes.
-            defer while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
-                waitForApcOrAlert();
-            };
-
-            const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
-                error.Canceled => |e| {
-                    _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
-                    return e;
-                },
-            };
-            waitForApcOrAlert();
-            while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
-                alertable_syscall.checkCancel() catch |err| switch (err) {
-                    error.Canceled => |e| {
-                        _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
-                        return e;
-                    },
-                };
-                waitForApcOrAlert();
-            }
-            alertable_syscall.finish();
-        },
-    } else |err| return err;
+    var io_status_block: windows.IO_STATUS_BLOCK = .{
+        .u = .{ .Status = .PENDING },
+        .Information = 0,
+    };
+    try ntReadFile(file.handle, data, &io_status_block);
+    while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
+        // Once we get here we must not return from the function until the
+        // operation completes, thereby releasing reference to io_status_block.
+        const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+            error.Canceled => |e| {
+                _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
+                while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
+                    waitForApcOrAlert();
+                }
+                return e;
+            },
+        };
+        waitForApcOrAlert();
+        alertable_syscall.finish();
+    }
     return ntReadFileResult(&io_status_block);
 }
 
-fn ntReadFileResult(io_status_block: *windows.IO_STATUS_BLOCK) !usize {
+fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
     switch (io_status_block.u.Status) {
+        .PENDING => unreachable,
+        .CANCELLED => unreachable,
         .SUCCESS => return io_status_block.Information,
         .END_OF_FILE => return error.EndOfStream,
         .PIPE_BROKEN => return error.EndOfStream,
-        .PENDING => unreachable,
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
@@ -8725,50 +8718,42 @@ fn ntReadFileResult(io_status_block: *windows.IO_STATUS_BLOCK) !usize {
     }
 }
 
-fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STATUS_BLOCK) Io.Cancelable!enum { status, pending } {
+fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STATUS_BLOCK) Io.Cancelable!void {
     var index: usize = 0;
     while (index < data.len and data[index].len == 0) index += 1;
     if (index == data.len) {
         iosb.u.Status = .SUCCESS;
         iosb.Information = 0;
-        return .status;
+        return;
     }
     const buffer = data[index];
 
     const syscall: Syscall = try .start();
-    while (true) {
-        iosb.u.Status = .PENDING;
-        switch (windows.ntdll.NtReadFile(
-            handle,
-            null, // event
-            noopApc, // apc callback
-            null, // apc context
-            iosb,
-            buffer.ptr,
-            @min(std.math.maxInt(u32), buffer.len),
-            null, // byte offset
-            null, // key
-        )) {
-            .PENDING => {
-                syscall.finish();
-                return .pending;
-            },
-            .SUCCESS => {
-                syscall.finish();
-                iosb.u.Status = .SUCCESS;
-                return .status;
-            },
-            .CANCELLED => {
-                try syscall.checkCancel();
-                continue;
-            },
-            else => |status| {
-                syscall.finish();
-                iosb.u.Status = status;
-                return .status;
-            },
-        }
-    }
+    while (true) switch (windows.ntdll.NtReadFile(
+        handle,
+        null, // event
+        noopApc, // apc callback
+        null, // apc context
+        iosb,
+        buffer.ptr,
+        @min(std.math.maxInt(u32), buffer.len),
+        null, // byte offset
+        null, // key
+    )) {
+        .PENDING => {
+            syscall.finish();
+            return;
+        },
+        .CANCELLED => {
+            try syscall.checkCancel();
+            continue;
+        },
+        else => |status| {
+            syscall.finish();
+            iosb.u.Status = status;
+            return;
+        },
+    };
 }
 
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
-- 
2.54.0


From 8f8aa8346a8babe43fb85d7033db2a329d602366 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 13:31:44 -0800
Subject: [PATCH 142/499] std.Io.Threaded: ntReadFileResult handles EOF + bytes
 available

---
 lib/std/Io/Threaded.zig | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index fbe12ada55850624b850c7c791c6d474d008b5d1..8e820f71d0c795f4a218509203ee79ff636a1620 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8709,8 +8709,10 @@ fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
         .PENDING => unreachable,
         .CANCELLED => unreachable,
         .SUCCESS => return io_status_block.Information,
-        .END_OF_FILE => return error.EndOfStream,
-        .PIPE_BROKEN => return error.EndOfStream,
+        .END_OF_FILE, .PIPE_BROKEN => {
+            if (io_status_block.Information == 0) return error.EndOfStream;
+            return io_status_block.Information;
+        },
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
-- 
2.54.0


From c2679feaaab26cc76fc381c61d49488a96f1f63c Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 30 Jan 2026 00:44:08 +0000
Subject: [PATCH 143/499] std.Io.Threaded: fix ntdll timeouts on Windows

---
 lib/std/Io/Threaded.zig | 41 ++++++++++++++++++++++++++++-------------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 8e820f71d0c795f4a218509203ee79ff636a1620..287bed5d0994ff9aeed1b86b7eeb0bdef57dacd5 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2719,7 +2719,13 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         }
     }
 
-    var delay_interval: windows.LARGE_INTEGER = timeoutToWindowsInterval(timeout);
+    const deadline: ?Io.Clock.Timestamp = timeout.toDeadline(ioBasic(t)) catch |err| switch (err) {
+        error.Unexpected => deadline: {
+            recoverableOsBugDetected();
+            break :deadline .{ .raw = .{ .nanoseconds = 0 }, .clock = .awake };
+        },
+        error.UnsupportedClock => |e| return e,
+    };
 
     while (true) {
         var any_pending = false;
@@ -2741,6 +2747,16 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         }
         if (b.user.complete_head != complete_tail) return;
         if (!any_pending) return;
+        var delay_interval: windows.LARGE_INTEGER = interval: {
+            const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
+            break :interval t.deadlineToWindowsInterval(d) catch |err| switch (err) {
+                error.UnsupportedClock => |e| return e,
+                error.Unexpected => {
+                    recoverableOsBugDetected();
+                    break :interval -1;
+                },
+            };
+        };
         const alertable_syscall = try AlertableSyscall.start();
         const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
         alertable_syscall.finish();
@@ -16784,19 +16800,18 @@ fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{T
     }
 }
 
-fn timeoutToWindowsInterval(timeout: Io.Timeout) windows.LARGE_INTEGER {
-    switch (timeout) {
-        .none => {
-            return std.math.minInt(windows.LARGE_INTEGER); // infinite timeout
+fn deadlineToWindowsInterval(t: *Io.Threaded, deadline: Io.Clock.Timestamp) Io.Clock.Error!windows.LARGE_INTEGER {
+    // ntdll only supports two combinations:
+    // * real-time (`.real`) sleeps with absolute deadlines
+    // * monotonic (`.awake`/`.boot`) sleeps with relative durations
+    switch (deadline.clock) {
+        .cpu_process, .cpu_thread => unreachable, // cannot sleep for CPU time
+        .real => {
+            return @intCast(@max(@divTrunc(deadline.raw.nanoseconds, 100), 0));
         },
-        .deadline => |deadline| {
-            const nanoseconds = deadline.raw.nanoseconds;
-            return @intCast(@divTrunc(nanoseconds, 100));
-        },
-        .duration => |duration| {
-            const now_timestamp = nowWindows(duration.clock) catch unreachable;
-            const deadline_ns = now_timestamp.nanoseconds + duration.raw.nanoseconds;
-            return @intCast(@divTrunc(deadline_ns, 100));
+        .awake, .boot => {
+            const duration = try deadline.durationFromNow(ioBasic(t));
+            return @intCast(@min(@divTrunc(-duration.raw.nanoseconds, 100), -1));
         },
     }
 }
-- 
2.54.0


From f8828e543ab6331395ef4d9f9a2b53770028b6b2 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 30 Jan 2026 00:44:29 +0000
Subject: [PATCH 144/499] std.Build: fully upgrade Step.Run to std.Io timing
 (and fix a typo)

---
 lib/std/Build/Step/Run.zig | 108 +++++++++++++++++--------------------
 1 file changed, 48 insertions(+), 60 deletions(-)

diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 55fee9a2868b74b0a6006cb67c7a366b7b477ed4..68d0ec480c77e7099a8230dd422ad0b21f155bf9 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1587,9 +1587,13 @@ fn spawnChildAndCollect(
     };
 
     if (run.stdio == .zig_test) {
-        var timer = try std.time.Timer.start();
-        defer run.step.result_duration_ns = timer.read();
-        try evalZigTest(run, spawn_options, options, fuzz_context);
+        const started: Io.Clock.Timestamp = try .now(io, .awake);
+        const result = evalZigTest(run, spawn_options, options, fuzz_context) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| e,
+        };
+        run.step.result_duration_ns = @intCast((try started.untilNow(io)).raw.nanoseconds);
+        try result;
         return null;
     } else {
         const inherit = spawn_options.stdout == .inherit or spawn_options.stderr == .inherit;
@@ -1602,10 +1606,14 @@ fn spawnChildAndCollect(
         } else .no_color;
         defer if (inherit) io.unlockStderr();
         try setColorEnvironmentVariables(run, environ_map, terminal_mode);
-        var timer = try std.time.Timer.start();
-        const res = try evalGeneric(run, spawn_options);
-        run.step.result_duration_ns = timer.read();
-        return .{ .term = res.term, .stdout = res.stdout, .stderr = res.stderr };
+
+        const started: Io.Clock.Timestamp = try .now(io, .awake);
+        const result = evalGeneric(run, spawn_options) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| e,
+        };
+        run.step.result_duration_ns = @intCast((try started.untilNow(io)).raw.nanoseconds);
+        return try result;
     }
 }
 
@@ -1861,9 +1869,7 @@ fn waitZigTest(
 
     var active_test_index: ?u32 = null;
 
-    // `null` means this host does not support `std.time.Timer`. This timer is `reset()` whenever we
-    // change `active_test_index`, i.e. whenever a test starts or finishes.
-    var timer: ?std.time.Timer = std.time.Timer.start() catch null;
+    var last_update: Io.Clock.Timestamp = try .now(io, .awake);
 
     var coverage_id: ?u64 = null;
 
@@ -1871,16 +1877,27 @@ fn waitZigTest(
     // test. For instance, if the test runner leaves this much time between us requesting a test to
     // start and it acknowledging the test starting, we terminate the child and raise an error. This
     // *should* never happen, but could in theory be caused by some very unlucky IB in a test.
-    const response_timeout_ns: ?u64 = ns: {
-        if (fuzz_context != null) break :ns null; // don't timeout fuzz tests
-        break :ns @max(options.unit_test_timeout_ns orelse 0, 60 * std.time.ns_per_s);
+    const response_timeout: ?Io.Clock.Duration = t: {
+        if (fuzz_context != null) break :t null; // don't timeout fuzz tests
+        const ns = @max(options.unit_test_timeout_ns orelse 0, 60 * std.time.ns_per_s);
+        break :t .{ .clock = .awake, .raw = .fromNanoseconds(ns) };
     };
+    const test_timeout: ?Io.Clock.Duration = if (options.unit_test_timeout_ns) |ns| .{
+        .clock = .awake,
+        .raw = .fromNanoseconds(ns),
+    } else null;
 
     const stdout = multi_reader.reader(0);
     const stderr = multi_reader.reader(1);
     const Header = std.zig.Server.Message.Header;
 
     while (true) {
+        const timeout: Io.Timeout = t: {
+            const opt_duration = if (active_test_index == null) response_timeout else test_timeout;
+            const duration = opt_duration orelse break :t .none;
+            break :t .{ .deadline = last_update.addDuration(duration) };
+        };
+
         // This block is exited when `stdout` contains enough bytes for a `Header`.
         header_ready: {
             if (stdout.buffered().len >= @sizeOf(Header)) {
@@ -1888,65 +1905,33 @@ fn waitZigTest(
                 break :header_ready;
             }
 
-            // Always `null` if `timer` is `null`.
-            const opt_timeout_ns: ?u64 = ns: {
-                if (timer == null) break :ns null;
-                if (active_test_index == null) break :ns response_timeout_ns;
-                break :ns options.unit_test_timeout_ns;
-            };
-
-            const timeout: Io.Timeout = if (opt_timeout_ns) |timeout_ns| .{ .duration = .{
-                .raw = .fromNanoseconds(timeout_ns -| timer.?.read()),
-                .clock = .awake,
-            } } else .none;
-
             multi_reader.fill(64, timeout) catch |err| switch (err) {
-                error.Timeout, error.EndOfStream => return .{ .no_poll = .{
+                error.Timeout => return .{ .timeout = .{
                     .active_test_index = active_test_index,
-                    .ns_elapsed = if (timer) |*t| t.read() else 0,
+                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
+                } },
+                error.EndOfStream => return .{ .no_poll = .{
+                    .active_test_index = active_test_index,
+                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
                 } },
-                error.UnsupportedClock => {
-                    timer = null;
-                    continue;
-                },
                 else => |e| return e,
             };
 
-            if (stdout.buffered().len >= @sizeOf(Header)) {
-                // There wasn't a header before, but there is one after the `poll`.
-                break :header_ready;
-            }
-
-            if (opt_timeout_ns) |timeout_ns| {
-                const cur_ns = timer.?.read();
-                if (cur_ns >= timeout_ns) return .{ .timeout = .{
-                    .active_test_index = active_test_index,
-                    .ns_elapsed = cur_ns,
-                } };
-            }
             continue;
         }
         // There is definitely a header available now -- read it.
         const header = stdout.takeStruct(Header, .little) catch unreachable;
 
         while (stdout.buffered().len < header.bytes_len) {
-            const timeout: Io.Timeout = t: {
-                const t = if (timer) |*t| t else break :t .none;
-                if (response_timeout_ns) |timeout_ns| break :t .{ .duration = .{
-                    .raw = .fromNanoseconds(timeout_ns -| t.read()),
-                    .clock = .awake,
-                } };
-                break :t .none;
-            };
             multi_reader.fill(64, timeout) catch |err| switch (err) {
-                error.Timeout, error.EndOfStream => return .{ .no_poll = .{
+                error.Timeout => return .{ .timeout = .{
                     .active_test_index = active_test_index,
-                    .ns_elapsed = if (timer) |*t| t.read() else 0,
+                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
+                } },
+                error.EndOfStream => return .{ .no_poll = .{
+                    .active_test_index = active_test_index,
+                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
                 } },
-                error.UnsupportedClock => {
-                    timer = null;
-                    continue;
-                },
                 else => |e| return e,
             };
         }
@@ -1991,13 +1976,13 @@ fn waitZigTest(
                 @memset(opt_metadata.*.?.ns_per_test, std.math.maxInt(u64));
 
                 active_test_index = null;
-                if (timer) |*t| t.reset();
+                last_update = try .now(io, .awake);
 
                 requestNextTest(io, child.stdin.?, &opt_metadata.*.?, &sub_prog_node) catch |err| return .{ .write_failed = err };
             },
             .test_started => {
                 active_test_index = opt_metadata.*.?.next_index - 1;
-                if (timer) |*t| t.reset();
+                last_update = try .now(io, .awake);
             },
             .test_results => {
                 assert(fuzz_context == null);
@@ -2040,7 +2025,10 @@ fn waitZigTest(
                 }
 
                 active_test_index = null;
-                if (timer) |*t| md.ns_per_test[tr_hdr.index] = t.lap();
+
+                const now: Io.Clock.Timestamp = try .now(io, .awake);
+                md.ns_per_test[tr_hdr.index] = @intCast(last_update.durationTo(now).raw.nanoseconds);
+                last_update = now;
 
                 requestNextTest(io, child.stdin.?, md, &sub_prog_node) catch |err| return .{ .write_failed = err };
             },
-- 
2.54.0


From 866ee4f1c52ae3e5a8ac95c9c5e61b019aa5eadb Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 15:03:33 -0800
Subject: [PATCH 145/499] std.Io.Threaded: handle TIMEOUT from NtDelayExceution

---
 lib/std/Io/Threaded.zig      | 2 +-
 lib/std/os/windows/ntdll.zig | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 287bed5d0994ff9aeed1b86b7eeb0bdef57dacd5..bccaf24ecd9c969b55b60a94a90d8a064b5cac7b 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2761,7 +2761,7 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
         alertable_syscall.finish();
         switch (delay_rc) {
-            .SUCCESS => {
+            .SUCCESS, .TIMEOUT => {
                 // The thread woke due to the timeout. Although spurious
                 // timeouts are OK, when no deadline is passed we must not
                 // return `error.Timeout`.
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index d68cd1494b8392381187de4316a7155351687eae..195a457d3b86167051c1a6f9d9eb4415673eb021 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -594,6 +594,13 @@ pub extern "ntdll" fn NtCancelSynchronousIoFile(
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
 
+/// This function has been observed to return SUCCESS on timeout on Windows 10
+/// and TIMEOUT on Wine 10.0.
+///
+/// This function has been observed on Windows 11 such that positive interval
+/// is real time, which can cause waits to be interrupted by changing system
+/// time, however negative intervals are not affected by changes to system
+/// time.
 pub extern "ntdll" fn NtDelayExecution(
     Alertable: BOOLEAN,
     DelayInterval: *const LARGE_INTEGER,
-- 
2.54.0


From a41ee5994d7f1f8dbecf54cdba0d56864d95ef99 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 17:13:17 -0800
Subject: [PATCH 146/499] std.Build.Step: evalZigProcess handles EndOfStream

and a happy little info log when the process needs to be restarted
---
 lib/std/Build/Step.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 0dd4b932800b3ee9c3e65dd2347381263f0eb34b..cfc263b7701e34f0ef762ae3f2524d0cac850f37 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -416,7 +416,8 @@ pub fn evalZigProcess(
         assert(watch);
         if (std.Progress.have_ipc) if (zp.progress_ipc_fd) |fd| prog_node.setIpcFd(fd);
         const result = zigProcessUpdate(s, zp, watch, web_server, gpa) catch |err| switch (err) {
-            error.BrokenPipe => {
+            error.BrokenPipe, error.EndOfStream => |reason| {
+                std.log.info("{s} restart required: {t}", .{ argv[0], reason });
                 // Process restart required.
                 const term = zp.child.wait(io) catch |e| {
                     return s.fail("unable to wait for {s}: {t}", .{ argv[0], e });
-- 
2.54.0


From a520355e4ca8f190d5c470413308bb4c8cb8b526 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jan 2026 22:58:54 -0800
Subject: [PATCH 147/499] std.process: simplify RunError set

---
 lib/std/process.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/process.zig b/lib/std/process.zig
index 739027da0754f922f9418a7d1b124f08a26a408e..3b5a0ecebd5e38ced3748bd0a012adc6d1d6d0a2 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -453,9 +453,9 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
     return io.vtable.processSpawnPath(io.userdata, dir, options);
 }
 
-pub const RunError = SpawnError || error{
+pub const RunError = error{
     StreamTooLong,
-} || Io.ConcurrentError || Allocator.Error || Io.File.Reader.Error || Io.Timeout.Error;
+} || SpawnError || Io.File.MultiReader.UnendingError || Io.Timeout.Error;
 
 pub const RunOptions = struct {
     argv: []const []const u8,
-- 
2.54.0


From 2674acdb77f8a144eaedbfa57a1b7fdc70dc1e60 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Fri, 30 Jan 2026 01:44:07 -0500
Subject: [PATCH 148/499] Io.Batch: implement alternate API

---
 lib/std/Io.zig                  | 241 ++++++++------
 lib/std/Io/File.zig             |   7 +-
 lib/std/Io/File/MultiReader.zig |  52 ++-
 lib/std/Io/Threaded.zig         | 569 +++++++++++++++++++-------------
 4 files changed, 505 insertions(+), 364 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index c00e4619e830a2fcd5a7e87bfce67b4a0201fa70..ca77a9836ad4df4993f3f64ccbb3c2af6228bcc2 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -149,8 +149,9 @@ pub const VTable = struct {
     futexWaitUncancelable: *const fn (?*anyopaque, ptr: *const u32, expected: u32) void,
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
 
-    operate: *const fn (?*anyopaque, *Operation) Cancelable!void,
-    batchWait: *const fn (?*anyopaque, *Batch, Timeout) Batch.WaitError!void,
+    operate: *const fn (?*anyopaque, Operation) Cancelable!Operation.Result,
+    batchAwaitAsync: *const fn (?*anyopaque, *Batch) Batch.AwaitAsyncError!void,
+    batchAwaitConcurrent: *const fn (?*anyopaque, *Batch, Timeout) Batch.AwaitConcurrentError!void,
     batchCancel: *const fn (?*anyopaque, *Batch) void,
 
     dirCreateDir: *const fn (?*anyopaque, Dir, []const u8, Dir.Permissions) Dir.CreateDirError!void,
@@ -255,19 +256,14 @@ pub const VTable = struct {
 };
 
 pub const Operation = union(enum) {
-    noop: Noop,
     file_read_streaming: FileReadStreaming,
 
-    pub const Noop = struct {
-        reserved: [2]usize = .{ 0, 0 },
-        status: Status(void) = .{ .unstarted = {} },
-    };
+    pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
     /// May return 0 reads which is different than `error.EndOfStream`.
     pub const FileReadStreaming = struct {
         file: File,
         data: []const []u8,
-        status: Status(Error!usize) = .{ .unstarted = {} },
 
         pub const Error = UnendingError || error{EndOfStream};
         pub const UnendingError = error{
@@ -290,19 +286,72 @@ pub const Operation = union(enum) {
             /// lock.
             LockViolation,
         } || Io.UnexpectedError;
+
+        pub const Result = usize;
+    };
+
+    pub const Result = Result: {
+        const operation_fields = @typeInfo(Operation).@"union".fields;
+        var field_names: [operation_fields.len][]const u8 = undefined;
+        var field_types: [operation_fields.len]type = undefined;
+        for (operation_fields, &field_names, &field_types) |field, *field_name, *field_type| {
+            field_name.* = field.name;
+            field_type.* = field.type.Error!field.type.Result;
+        }
+        break :Result @Union(.auto, Tag, &field_names, &field_types, &@splat(.{}));
     };
 
-    pub fn Status(Result: type) type {
-        return union {
-            unstarted: void,
-            pending: *Batch,
+    pub const Storage = union {
+        unused: List.DoubleNode,
+        submission: Submission,
+        pending: Pending,
+        completion: Completion,
+
+        pub const Submission = struct {
+            node: List.SingleNode,
+            operation: Operation,
+        };
+
+        pub const Pending = struct {
+            node: List.DoubleNode,
+            tag: Tag,
+            context: [3]usize,
+        };
+
+        pub const Completion = struct {
+            node: List.SingleNode,
             result: Result,
         };
-    }
+    };
+
+    pub const OptionalIndex = enum(u32) {
+        none = std.math.maxInt(u32),
+        _,
+
+        pub fn fromIndex(i: usize) OptionalIndex {
+            const oi: OptionalIndex = @enumFromInt(i);
+            assert(oi != .none);
+            return oi;
+        }
+
+        pub fn toIndex(oi: OptionalIndex) u32 {
+            assert(oi != .none);
+            return @intFromEnum(oi);
+        }
+    };
+    pub const List = struct {
+        head: OptionalIndex,
+        tail: OptionalIndex,
+
+        pub const empty: List = .{ .head = .none, .tail = .none };
+
+        pub const SingleNode = struct { next: OptionalIndex };
+        pub const DoubleNode = struct { prev: OptionalIndex, next: OptionalIndex };
+    };
 };
 
 /// Performs one `Operation`.
-pub fn operate(io: Io, operation: *Operation) Cancelable!void {
+pub fn operate(io: Io, operation: Operation) Cancelable!Operation.Result {
     return io.vtable.operate(io.userdata, operation);
 }
 
@@ -312,116 +361,96 @@ pub fn operate(io: Io, operation: *Operation) Cancelable!void {
 /// This is a low-level abstraction based on `Operation`. For a higher
 /// level API that operates on `Future`, see `Select`.
 pub const Batch = struct {
-    operations: []Operation,
-    ring: [*]u32,
-    user: struct {
-        submit_tail: RingIndex,
-        complete_head: RingIndex,
-        complete_tail: RingIndex,
-    },
-    impl: struct {
-        submit_head: RingIndex,
-        submit_tail: RingIndex,
-        complete_tail: RingIndex,
-        reserved: ?*anyopaque,
-    },
-
-    pub const RingIndex = enum(u32) {
-        _,
-
-        pub fn index(ri: RingIndex, len: u31) u31 {
-            const i = @intFromEnum(ri);
-            assert(i < @as(u32, len) * 2);
-            return @intCast(if (i < len) i else i - len);
-        }
-
-        pub fn prev(ri: RingIndex, len: u31) RingIndex {
-            const i = @intFromEnum(ri);
-            const double_len = @as(u32, len) * 2;
-            assert(i <= double_len);
-            return @enumFromInt((if (i > 0) i else double_len) - 1);
-        }
-
-        pub fn next(ri: RingIndex, len: u31) RingIndex {
-            const i = @intFromEnum(ri) + 1;
-            const double_len = @as(u32, len) * 2;
-            assert(i <= double_len);
-            return @enumFromInt(if (i < double_len) i else 0);
-        }
-    };
+    storage: []Operation.Storage,
+    unused: Operation.List,
+    submissions: Operation.List,
+    pending: Operation.List,
+    completions: Operation.List,
+    context: ?*anyopaque,
 
     /// After calling this, it is safe to unconditionally defer a call to
     /// `cancel`.
-    pub fn init(operations: []Operation, ring: []u32) Batch {
-        const len: u31 = @intCast(operations.len);
-        assert(ring.len == len);
+    pub fn init(storage: []Operation.Storage) Batch {
+        var prev: Operation.OptionalIndex = .none;
+        for (storage, 0..) |*operation, index| {
+            operation.* = .{ .unused = .{ .prev = prev, .next = .fromIndex(index + 1) } };
+            prev = .fromIndex(index);
+        }
+        storage[storage.len - 1].unused.next = .none;
         return .{
-            .operations = operations,
-            .ring = ring.ptr,
-            .user = .{
-                .submit_tail = @enumFromInt(0),
-                .complete_head = @enumFromInt(0),
-                .complete_tail = @enumFromInt(0),
-            },
-            .impl = .{
-                .submit_head = @enumFromInt(0),
-                .submit_tail = @enumFromInt(0),
-                .complete_tail = @enumFromInt(0),
-                .reserved = null,
+            .storage = storage,
+            .unused = .{
+                .head = .fromIndex(0),
+                .tail = .fromIndex(storage.len - 1),
             },
+            .submissions = .empty,
+            .pending = .empty,
+            .completions = .empty,
+            .context = null,
         };
     }
 
-    /// Adds `b.operations[operation]` to the list of submitted operations
-    /// that will be performed when `wait` is called.
-    pub fn add(b: *Batch, operation: usize) void {
-        const tail = b.user.submit_tail;
-        const len: u31 = @intCast(b.operations.len);
-        b.user.submit_tail = tail.next(len);
-        b.ring[0..len][tail.index(len)] = @intCast(operation);
+    /// Adds an operation to be performed at the next await call.
+    /// Returns the index that will be returned by `next` after the operation completes.
+    /// Asserts that no more than `storage.len` operations are active at a time.
+    pub fn add(b: *Batch, operation: Operation) u32 {
+        const index = b.unused.next;
+        b.addAt(index.toIndex(), operation);
+        return index;
     }
 
-    fn flush(b: *Batch) void {
-        @atomicStore(RingIndex, &b.impl.submit_tail, b.user.submit_tail, .release);
+    /// Adds an operation to be performed at the next await call.
+    /// After the operation completes, `next` will return `index`.
+    /// Asserts that the operation at `index` is not active.
+    pub fn addAt(b: *Batch, index: u32, operation: Operation) void {
+        const storage = &b.storage[index];
+        const unused = storage.unused;
+        switch (unused.prev) {
+            .none => b.unused.head = .none,
+            else => |prev_index| b.storage[prev_index.toIndex()].unused.next = unused.next,
+        }
+        switch (unused.next) {
+            .none => b.unused.tail = .none,
+            else => |next_index| b.storage[next_index.toIndex()].unused.prev = unused.prev,
+        }
+
+        switch (b.submissions.tail) {
+            .none => b.submissions.head = .fromIndex(index),
+            else => |tail_index| b.storage[tail_index.toIndex()].submission.node.next = .fromIndex(index),
+        }
+        storage.* = .{ .submission = .{ .node = .{ .next = .none }, .operation = operation } };
+        b.submissions.tail = .fromIndex(index);
     }
 
-    /// Returns `operation` such that `b.operations[operation]` has completed.
-    /// Returns `null` when `wait` should be called.
-    pub fn next(b: *Batch) ?u32 {
-        const head = b.user.complete_head;
-        if (head == b.user.complete_tail) {
-            @branchHint(.unlikely);
-            b.flush();
-            const tail = @atomicLoad(RingIndex, &b.impl.complete_tail, .acquire);
-            if (head == tail) {
-                @branchHint(.unlikely);
-                return null;
-            }
-            assert(head != tail);
-            b.user.complete_tail = tail;
+    pub fn next(b: *Batch) ?struct { index: u32, result: Operation.Result } {
+        const index = b.completions.head;
+        if (index == .none) return null;
+        const storage = &b.storage[index.toIndex()];
+        const completion = storage.completion;
+        const next_index = completion.node.next;
+        b.completions.head = next_index;
+        if (next_index == .none) b.completions.tail = .none;
+
+        const tail_index = b.unused.tail;
+        switch (tail_index) {
+            .none => b.unused.head = index,
+            else => b.storage[tail_index.toIndex()].unused.next = index,
         }
-        const len: u31 = @intCast(b.operations.len);
-        b.user.complete_head = head.next(len);
-        return b.ring[0..len][head.index(len)];
+        storage.* = .{ .unused = .{ .prev = tail_index, .next = .none } };
+        b.unused.tail = index;
+        return .{ .index = index.toIndex(), .result = completion.result };
     }
 
-    pub const WaitError = ConcurrentError || Cancelable || Timeout.Error;
+    pub const AwaitAsyncError = Cancelable;
+    pub fn awaitAsync(b: *Batch, io: Io) AwaitAsyncError!void {
+        return io.vtable.batchAwaitAsync(io.userdata, b);
+    }
 
-    /// Starts work on any submitted operations and returns when at least one has completeed.
-    ///
-    /// Returns `error.Timeout` if `timeout` expires first.
-    ///
-    /// Depending on the `Io` implementation, may allocate resources that are
-    /// freed with `cancel`, even if an error is returned.
-    pub fn wait(b: *Batch, io: Io, timeout: Timeout) WaitError!void {
-        return io.vtable.batchWait(io.userdata, b, timeout);
+    pub const AwaitConcurrentError = ConcurrentError || Cancelable || Timeout.Error;
+    pub fn awaitConcurrent(b: *Batch, io: Io, timeout: Timeout) AwaitConcurrentError!void {
+        return io.vtable.batchAwaitConcurrent(io.userdata, b, timeout);
     }
 
-    /// Returns after all `operations` have completed. Operations which have not completed
-    /// after this function returns were successfully dropped and had no side effects.
-    ///
-    /// This function is idempotent with respect to itself and `wait`. It is
-    /// safe to unconditionally `defer` a call to this function after `init`.
     pub fn cancel(b: *Batch, io: Io) void {
         return io.vtable.batchCancel(io.userdata, b);
     }
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index df5b3b5a532239e1996287021d74d14ee37fd2ef..5db6f81ac6f8e2b2ade7fcd49916af06b1317c7d 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -559,12 +559,11 @@ pub const ReadStreamingError = error{EndOfStream} || Reader.Error;
 /// See also:
 /// * `reader`
 pub fn readStreaming(file: File, io: Io, buffer: []const []u8) ReadStreamingError!usize {
-    var operation: Io.Operation = .{ .file_read_streaming = .{
+    const result = try io.operate(.{ .file_read_streaming = .{
         .file = file,
         .data = buffer,
-    } };
-    try io.operate(&operation);
-    return operation.file_read_streaming.status.result;
+    } });
+    return result.file_read_streaming;
 }
 
 pub const ReadPositionalError = error{
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index 7a0f8de068d5912b8ba903665eba0b1c19fb7265..217215a3636e40b4fe4ad805be2df88fa2830947 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -22,8 +22,7 @@ pub const UnendingError = Allocator.Error || File.Reader.Error || Io.ConcurrentE
 
 /// Trailing:
 /// * `contexts: [len]Context`
-/// * `ring: [len]u32`
-/// * `operations: [len]Io.Operation`
+/// * `storage: [len]Io.Operation.Storage`
 pub const Streams = extern struct {
     len: u32,
 
@@ -33,17 +32,10 @@ pub const Streams = extern struct {
         return ptr[0..s.len];
     }
 
-    pub fn ring(s: *Streams) []u32 {
+    pub fn storage(s: *Streams) []Io.Operation.Storage {
         const prev = contexts(s);
         const end = prev.ptr + prev.len;
-        const ptr: [*]u32 = @ptrFromInt(std.mem.alignForward(usize, @intFromPtr(end), @alignOf(u32)));
-        return ptr[0..s.len];
-    }
-
-    pub fn operations(s: *Streams) []Io.Operation {
-        const prev = ring(s);
-        const end = prev.ptr + prev.len;
-        const ptr: [*]Io.Operation = @ptrFromInt(std.mem.alignForward(usize, @intFromPtr(end), @alignOf(Io.Operation)));
+        const ptr: [*]Io.Operation.Storage = @ptrFromInt(std.mem.alignForward(usize, @intFromPtr(end), @alignOf(Io.Operation.Storage)));
         return ptr[0..s.len];
     }
 };
@@ -52,8 +44,7 @@ pub fn Buffer(comptime n: usize) type {
     return extern struct {
         len: u32,
         contexts: [n][@sizeOf(Context)]u8 align(@alignOf(Context)),
-        ring: [n]u32,
-        operations: [n][@sizeOf(Io.Operation)]u8 align(@alignOf(Io.Operation)),
+        storage: [n][@sizeOf(Io.Operation.Storage)]u8 align(@alignOf(Io.Operation.Storage)),
 
         pub fn toStreams(b: *@This()) *Streams {
             b.len = n;
@@ -86,25 +77,22 @@ pub fn init(mr: *MultiReader, gpa: Allocator, io: Io, streams: *Streams, files:
         .vec = .{&.{}},
         .err = null,
     };
-    const operations = streams.operations();
-    const ring = streams.ring();
     mr.* = .{
         .gpa = gpa,
         .streams = streams,
-        .batch = .init(operations, ring),
+        .batch = .init(streams.storage()),
     };
-    for (operations, contexts, files, 0..) |*op, *context, file, i| {
+    for (contexts, 0..) |*context, i| {
         const r = &context.fr.interface;
-        op.* = .{ .file_read_streaming = .{
-            .file = file,
-            .data = &context.vec,
-        } };
         rebaseGrowing(mr, context, 1) catch |err| {
             context.err = err;
             continue;
         };
         context.vec[0] = r.buffer;
-        mr.batch.add(i);
+        mr.batch.addAt(@intCast(i), .{ .file_read_streaming = .{
+            .file = context.fr.file,
+            .data = &context.vec,
+        } });
     }
 }
 
@@ -204,7 +192,7 @@ fn fillUntimed(context: *Context, capacity: usize) Io.Reader.Error!void {
     };
 }
 
-pub const FillError = Io.Batch.WaitError || error{
+pub const FillError = Io.Batch.AwaitConcurrentError || error{
     /// `fill` was called when all streams already have failed or reached the
     /// end.
     EndOfStream,
@@ -213,17 +201,15 @@ pub const FillError = Io.Batch.WaitError || error{
 /// Wait until at least one stream receives more data.
 pub fn fill(mr: *MultiReader, unused_capacity: usize, timeout: Io.Timeout) FillError!void {
     const contexts = mr.streams.contexts();
-    const operations = mr.streams.operations();
     const io = contexts[0].fr.io;
     var any_completed = false;
 
-    try mr.batch.wait(io, timeout);
+    try mr.batch.awaitConcurrent(io, timeout);
 
-    while (mr.batch.next()) |i| {
+    while (mr.batch.next()) |operation| {
         any_completed = true;
-        const context = &contexts[i];
-        const operation = &operations[i];
-        const n = operation.file_read_streaming.status.result catch |err| {
+        const context = &contexts[operation.index];
+        const n = operation.result.file_read_streaming catch |err| {
             context.err = err;
             continue;
         };
@@ -237,15 +223,17 @@ pub fn fill(mr: *MultiReader, unused_capacity: usize, timeout: Io.Timeout) FillE
             assert(r.seek == 0);
         }
         context.vec[0] = r.buffer[r.end..];
-        operation.file_read_streaming.status = .{ .unstarted = {} };
-        mr.batch.add(i);
+        mr.batch.addAt(operation.index, .{ .file_read_streaming = .{
+            .file = context.fr.file,
+            .data = &context.vec,
+        } });
     }
 
     if (!any_completed) return error.EndOfStream;
 }
 
 /// Wait until all streams fail or reach the end.
-pub fn fillRemaining(mr: *MultiReader, timeout: Io.Timeout) Io.Batch.WaitError!void {
+pub fn fillRemaining(mr: *MultiReader, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
     while (fill(mr, 1, timeout)) |_| {} else |err| switch (err) {
         error.EndOfStream => return,
         else => |e| return e,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index bccaf24ecd9c969b55b60a94a90d8a064b5cac7b..18f24eb40cefdabe8fca2820e239edac1046aafc 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1617,7 +1617,8 @@ pub fn io(t: *Threaded) Io {
             .futexWake = futexWake,
 
             .operate = operate,
-            .batchWait = batchWait,
+            .batchAwaitAsync = batchAwaitAsync,
+            .batchAwaitConcurrent = batchAwaitConcurrent,
             .batchCancel = batchCancel,
 
             .dirCreateDir = dirCreateDir,
@@ -1780,7 +1781,8 @@ pub fn ioBasic(t: *Threaded) Io {
             .futexWake = futexWake,
 
             .operate = operate,
-            .batchWait = batchWait,
+            .batchAwaitAsync = batchAwaitAsync,
+            .batchAwaitConcurrent = batchAwaitConcurrent,
             .batchCancel = batchCancel,
 
             .dirCreateDir = dirCreateDir,
@@ -2483,85 +2485,227 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
     Thread.futexWake(ptr, max_waiters);
 }
 
-fn operate(userdata: ?*anyopaque, op: *Io.Operation) Io.Cancelable!void {
+fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    switch (op.*) {
-        .noop => |*o| {
-            _ = o.status.unstarted;
-            o.status = .{ .result = {} };
-        },
-        .file_read_streaming => |*o| {
-            _ = o.status.unstarted;
-            o.status = .{ .result = fileReadStreaming(t, o.file, o.data) catch |err| switch (err) {
+    switch (operation) {
+        .file_read_streaming => |o| return .{
+            .file_read_streaming = fileReadStreaming(t, o.file, o.data) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 else => |e| e,
-            } };
+            },
         },
     }
 }
 
-fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
+fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Batch.AwaitAsyncError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    if (is_windows) return batchWaitWindows(t, b, timeout);
+    if (is_windows) {
+        try batchAwaitWindows(b);
+        const alertable_syscall = try AlertableSyscall.start();
+        while (b.pending.head != .none and b.completions.head == .none) waitForApcOrAlert();
+        alertable_syscall.finish();
+        return;
+    }
     if (native_os == .wasi and !builtin.link_libc) @panic("TODO");
-    const operations = b.operations;
-    const len: u31 = @intCast(operations.len);
-    const ring = b.ring[0..len];
-    var submit_head = b.impl.submit_head;
-    const submit_tail = b.user.submit_tail;
-    b.impl.submit_tail = submit_tail;
-    var complete_tail = b.impl.complete_tail;
-    var map_buffer: [poll_buffer_len]u8 = undefined; // poll_buffer index to operations index
-    var poll_i: u8 = 0;
-    defer {
-        for (map_buffer[0..poll_i]) |op| {
-            submit_head = submit_head.prev(len);
-            ring[submit_head.index(len)] = op;
+    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
+    var poll_len: u32 = 0;
+    {
+        var index = b.submissions.head;
+        while (index != .none and poll_len < poll_buffer_len) {
+            const submission = &b.storage[index.toIndex()].submission;
+            switch (submission.operation) {
+                .file_read_streaming => |o| {
+                    poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.IN, .revents = 0 };
+                    poll_len += 1;
+                },
+            }
+            index = submission.node.next;
         }
-        b.impl.submit_head = submit_head;
-        b.impl.complete_tail = complete_tail;
-        b.user.complete_tail = complete_tail;
     }
-    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
-    while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
-        const op = ring[submit_head.index(len)];
-        const operation = &operations[op];
-        switch (operation.*) {
-            .noop => |*o| {
-                _ = o.status.unstarted;
-                o.status = .{ .result = {} };
-                submitComplete(ring, &complete_tail, op);
+    switch (poll_len) {
+        0 => return,
+        1 => {},
+        else => while (true) {
+            const timeout_ms: i32 = t: {
+                if (b.completions.head != .none) {
+                    // It is legal to call batchWait with already completed
+                    // operations in the ring. In such case, we need to avoid
+                    // blocking in the poll syscall, but we can still take this
+                    // opportunity to find additional ready operations.
+                    break :t 0;
+                }
+                const max_poll_ms = std.math.maxInt(i32);
+                break :t max_poll_ms;
+            };
+            const syscall = try Syscall.start();
+            const rc = posix.system.poll(&poll_buffer, poll_len, timeout_ms);
+            syscall.finish();
+            switch (posix.errno(rc)) {
+                .SUCCESS => {
+                    if (rc == 0) {
+                        if (b.completions.head != .none) {
+                            // Since there are already completions available in the
+                            // queue, this is neither a timeout nor a case for
+                            // retrying.
+                            return;
+                        }
+                        continue;
+                    }
+                    var prev_index: Io.Operation.OptionalIndex = .none;
+                    var index = b.submissions.head;
+                    for (poll_buffer[0..poll_len]) |poll_entry| {
+                        const storage = &b.storage[index.toIndex()];
+                        const submission = &storage.submission;
+                        const next_index = submission.node.next;
+                        if (poll_entry.revents != 0) {
+                            const result = try operate(t, submission.operation);
+
+                            switch (prev_index) {
+                                .none => b.submissions.head = next_index,
+                                else => b.storage[prev_index.toIndex()].submission.node.next = next_index,
+                            }
+                            if (next_index == .none) b.submissions.tail = prev_index;
+
+                            switch (b.completions.tail) {
+                                .none => b.completions.head = index,
+                                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
+                            }
+                            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+                            b.completions.tail = index;
+                        } else prev_index = index;
+                        index = next_index;
+                    }
+                    assert(index == .none);
+                    return;
+                },
+                .INTR => continue,
+                else => break,
+            }
+        },
+    }
+    {
+        var tail_index = b.completions.tail;
+        defer b.completions.tail = tail_index;
+        var index = b.submissions.head;
+        errdefer b.submissions.head = index;
+        while (index != .none) {
+            const storage = &b.storage[index.toIndex()];
+            const submission = &storage.submission;
+            const next_index = submission.node.next;
+            const result = try operate(t, submission.operation);
+
+            switch (tail_index) {
+                .none => b.completions.head = index,
+                else => b.storage[tail_index.toIndex()].completion.node.next = index,
+            }
+            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+            tail_index = index;
+            index = next_index;
+        }
+        b.submissions = .{ .head = .none, .tail = .none };
+    }
+}
+
+fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    if (is_windows) {
+        const deadline: ?Io.Clock.Timestamp = timeout.toDeadline(ioBasic(t)) catch |err| switch (err) {
+            error.Unexpected => deadline: {
+                recoverableOsBugDetected();
+                break :deadline .{ .raw = .{ .nanoseconds = 0 }, .clock = .awake };
             },
-            .file_read_streaming => |*o| {
-                _ = o.status.unstarted;
-                if (poll_buffer.len - poll_i == 0) return error.ConcurrencyUnavailable;
-                poll_buffer[poll_i] = .{
-                    .fd = o.file.handle,
-                    .events = posix.POLL.IN,
-                    .revents = 0,
+            error.UnsupportedClock => |e| return e,
+        };
+        try batchAwaitWindows(b);
+        while (b.pending.head != .none and b.completions.head == .none) {
+            var delay_interval: windows.LARGE_INTEGER = interval: {
+                const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
+                break :interval t.deadlineToWindowsInterval(d) catch |err| switch (err) {
+                    error.UnsupportedClock => |e| return e,
+                    error.Unexpected => {
+                        recoverableOsBugDetected();
+                        break :interval -1;
+                    },
                 };
-                map_buffer[poll_i] = @intCast(op);
-                poll_i += 1;
-            },
+            };
+            const alertable_syscall = try AlertableSyscall.start();
+            const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
+            alertable_syscall.finish();
+            switch (delay_rc) {
+                .SUCCESS, .TIMEOUT => {
+                    // The thread woke due to the timeout. Although spurious
+                    // timeouts are OK, when no deadline is passed we must not
+                    // return `error.Timeout`.
+                    if (timeout != .none and b.completions.head == .none) return error.Timeout;
+                },
+                else => {},
+            }
+        }
+        return;
+    }
+    if (native_os == .wasi and !builtin.link_libc) @panic("TODO");
+    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
+    var poll_storage: struct {
+        gpa: std.mem.Allocator,
+        b: *Io.Batch,
+        slice: []posix.pollfd,
+        len: u32,
+
+        fn add(storage: *@This(), file: Io.File, events: @FieldType(posix.pollfd, "events")) Io.ConcurrentError!void {
+            const len = storage.len;
+            if (len == poll_buffer_len) {
+                const slice: []posix.pollfd = if (storage.b.context) |context|
+                    @as([*]posix.pollfd, @ptrCast(@alignCast(context)))[0..storage.b.storage.len]
+                else allocation: {
+                    const allocation = storage.gpa.alloc(posix.pollfd, storage.b.storage.len) catch
+                        return error.ConcurrencyUnavailable;
+                    storage.b.context = allocation.ptr;
+                    break :allocation allocation;
+                };
+                @memcpy(slice[0..poll_buffer_len], storage.slice);
+            }
+            storage.slice[len] = .{
+                .fd = file.handle,
+                .events = events,
+                .revents = 0,
+            };
+            storage.len = len + 1;
+        }
+    } = .{ .gpa = t.allocator, .b = b, .slice = &poll_buffer, .len = 0 };
+    {
+        var index = b.submissions.head;
+        while (index != .none) {
+            const submission = &b.storage[index.toIndex()].submission;
+            switch (submission.operation) {
+                .file_read_streaming => |o| try poll_storage.add(o.file, posix.POLL.IN),
+            }
+            index = submission.node.next;
         }
     }
-    switch (poll_i) {
+    switch (poll_storage.len) {
         0 => return,
         1 => if (timeout == .none) {
-            const op = map_buffer[0];
-            try operate(t, &operations[op]);
-            submitComplete(ring, &complete_tail, op);
-            poll_i = 0;
+            const index = b.submissions.head;
+            const storage = &b.storage[index.toIndex()];
+            const result = try operate(t, storage.submission.operation);
+
+            b.submissions = .{ .head = .none, .tail = .none };
+
+            switch (b.completions.tail) {
+                .none => b.completions.head = index,
+                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
+            }
+            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+            b.completions.tail = index;
             return;
         },
         else => {},
     }
     const t_io = ioBasic(t);
     const deadline = timeout.toDeadline(t_io) catch return error.UnsupportedClock;
-    const max_poll_ms = std.math.maxInt(i32);
     while (true) {
         const timeout_ms: i32 = t: {
-            if (b.user.complete_head != complete_tail) {
+            if (b.completions.head != .none) {
                 // It is legal to call batchWait with already completed
                 // operations in the ring. In such case, we need to avoid
                 // blocking in the poll syscall, but we can still take this
@@ -2571,15 +2715,16 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
             const d = deadline orelse break :t -1;
             const duration = d.durationFromNow(t_io) catch return error.UnsupportedClock;
             if (duration.raw.nanoseconds <= 0) return error.Timeout;
+            const max_poll_ms = std.math.maxInt(i32);
             break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
         };
         const syscall = try Syscall.start();
-        const rc = posix.system.poll(&poll_buffer, poll_i, timeout_ms);
+        const rc = posix.system.poll(&poll_buffer, poll_storage.len, timeout_ms);
         syscall.finish();
         switch (posix.errno(rc)) {
             .SUCCESS => {
                 if (rc == 0) {
-                    if (b.user.complete_head != complete_tail) {
+                    if (b.completions.head != .none) {
                         // Since there are already completions available in the
                         // queue, this is neither a timeout nor a case for
                         // retrying.
@@ -2590,18 +2735,30 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
                     if (deadline == null) continue;
                     return error.Timeout;
                 }
-                while (poll_i != 0) {
-                    poll_i -= 1;
-                    const poll_fd = &poll_buffer[poll_i];
-                    const op = map_buffer[poll_i];
-                    if (poll_fd.revents == 0) {
-                        submit_head = submit_head.prev(len);
-                        ring[submit_head.index(len)] = op;
-                    } else {
-                        try operate(t, &operations[op]);
-                        submitComplete(ring, &complete_tail, op);
-                    }
+                var prev_index: Io.Operation.OptionalIndex = .none;
+                var index = b.submissions.head;
+                for (poll_storage.slice[0..poll_storage.len]) |poll_entry| {
+                    const submission = &b.storage[index.toIndex()].submission;
+                    const next_index = submission.node.next;
+                    if (poll_entry.revents != 0) {
+                        const result = try operate(t, submission.operation);
+
+                        switch (prev_index) {
+                            .none => b.submissions.head = next_index,
+                            else => b.storage[prev_index.toIndex()].submission.node.next = next_index,
+                        }
+                        if (next_index == .none) b.submissions.tail = prev_index;
+
+                        switch (b.completions.tail) {
+                            .none => b.completions.head = index,
+                            else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
+                        }
+                        b.completions.tail = index;
+                        b.storage[index.toIndex()] = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+                    } else prev_index = index;
+                    index = next_index;
                 }
+                assert(index == .none);
                 return;
             },
             .INTR => continue,
@@ -2610,166 +2767,126 @@ fn batchWait(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.
     }
 }
 
-fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const operations = b.operations;
-    const len: u31 = @intCast(operations.len);
-    const ring = b.ring[0..len];
-    var submit_head = b.impl.submit_head;
-    const submit_tail = b.user.submit_tail;
-    b.impl.submit_tail = submit_tail;
-    var complete_tail = b.impl.complete_tail;
-    while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
-        const op = ring[submit_head.index(len)];
-        switch (operations[op]) {
-            .noop => |*o| {
-                _ = o.status.unstarted;
-                o.status = .{ .result = {} };
-                submitComplete(ring, &complete_tail, op);
-            },
-            .file_read_streaming => |*o| _ = o.status.unstarted,
-        }
-    }
-    if (is_windows) {
-        // Iterate over pending and issue cancelations, then free the allocation for IO_STATUS_BLOCK
-        if (b.impl.reserved) |reserved| {
-            const gpa = t.allocator;
-            const metadatas_ptr: [*]WinOpMetadata = @ptrCast(@alignCast(reserved));
-            const metadatas = metadatas_ptr[0..b.operations.len];
-            for (metadatas, 0..) |*metadata, op| {
-                if (!metadata.pending) continue;
-                const done = @atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) != .PENDING;
-                if (done) continue;
-                switch (operations[op]) {
-                    .noop => unreachable,
-                    .file_read_streaming => |*o| {
-                        _ = windows.ntdll.NtCancelIoFile(o.file.handle, &metadata.iosb);
-                    },
-                }
-            }
-            for (metadatas) |*metadata| {
-                if (!metadata.pending) continue;
-                while (@atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) == .PENDING) {
-                    waitForApcOrAlert();
-                }
-            }
-            gpa.free(metadatas);
-            b.impl.reserved = null;
-        }
-    }
-    b.impl.submit_head = submit_tail;
-    b.impl.complete_tail = complete_tail;
-    b.user.complete_tail = complete_tail;
-}
-
-const WinOpMetadata = struct {
+const WindowsBatchPendingOperationContext = extern struct {
+    file: windows.HANDLE,
     iosb: windows.IO_STATUS_BLOCK,
-    pending: bool,
+
+    const Erased = [3]usize;
+
+    comptime {
+        assert(@sizeOf(Erased) <= @sizeOf(WindowsBatchPendingOperationContext));
+    }
+
+    fn toErased(context: *WindowsBatchPendingOperationContext) *Erased {
+        return @ptrCast(context);
+    }
+
+    fn fromErased(erased: *Erased) *WindowsBatchPendingOperationContext {
+        return @ptrCast(erased);
+    }
 };
 
-fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.WaitError!void {
-    const operations = b.operations;
-    const len: u31 = @intCast(operations.len);
-    const ring = b.ring[0..len];
-    var submit_head = b.impl.submit_head;
-    const submit_tail = b.user.submit_tail;
-    b.impl.submit_tail = submit_tail;
-    var complete_tail = b.impl.complete_tail;
-
-    const metadatas_ptr: [*]WinOpMetadata = if (b.impl.reserved) |reserved| @ptrCast(@alignCast(reserved)) else a: {
-        const gpa = t.allocator;
-        const metadatas = gpa.alloc(WinOpMetadata, operations.len) catch return error.ConcurrencyUnavailable;
-        b.impl.reserved = metadatas.ptr;
-        @memset(metadatas, .{ .iosb = undefined, .pending = false });
-        break :a metadatas.ptr;
-    };
-    const metadatas = metadatas_ptr[0..operations.len];
-
-    defer {
-        b.impl.submit_head = submit_head;
-        b.impl.complete_tail = complete_tail;
-        b.user.complete_tail = complete_tail;
+fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    {
+        var tail_index = b.unused.tail;
+        defer b.unused.tail = tail_index;
+        var index = b.submissions.head;
+        errdefer b.submissions.head = index;
+        while (index != .none) {
+            const next_index = b.storage[index.toIndex()].submission.node.next;
+            switch (tail_index) {
+                .none => b.unused.head = index,
+                else => b.storage[tail_index.toIndex()].unused.next = index,
+            }
+            b.storage[index.toIndex()] = .{ .unused = .{ .prev = tail_index, .next = .none } };
+            tail_index = index;
+            index = next_index;
+        }
+        b.submissions = .{ .head = .none, .tail = .none };
     }
-
-    while (submit_head != submit_tail) : (submit_head = submit_head.next(len)) {
-        const op = ring[submit_head.index(len)];
-        const operation = &operations[op];
-        const metadata = &metadatas[op];
-        metadata.* = .{ .iosb = .{
-            .u = .{ .Status = .PENDING },
-            .Information = 0,
-        }, .pending = false };
-        switch (operation.*) {
-            .noop => |*o| {
-                _ = o.status.unstarted;
-                o.status = .{ .result = {} };
-                submitComplete(ring, &complete_tail, op);
-            },
-            .file_read_streaming => |*o| {
-                _ = o.status.unstarted;
-                try ntReadFile(o.file.handle, o.data, &metadata.iosb);
-                if (@atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) == .PENDING) {
-                    o.status = .{ .pending = b };
-                    metadata.pending = true;
-                } else {
-                    o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
-                    submitComplete(ring, &complete_tail, op);
-                }
-            },
+    if (is_windows) {
+        var index = b.pending.head;
+        while (index != .none) {
+            const pending = &b.storage[index.toIndex()].pending;
+            const context: *WindowsBatchPendingOperationContext = .fromErased(&pending.context);
+            _ = windows.ntdll.NtCancelIoFile(context.file, &context.iosb);
+            index = pending.node.next;
         }
+        while (b.pending.head != .none) waitForApcOrAlert();
+    } else if (b.context) |context| {
+        t.allocator.free(@as([*]posix.pollfd, @ptrCast(@alignCast(context)))[0..b.storage.len]);
+        b.context = null;
     }
+    assert(b.pending.head == .none);
+}
 
-    const deadline: ?Io.Clock.Timestamp = timeout.toDeadline(ioBasic(t)) catch |err| switch (err) {
-        error.Unexpected => deadline: {
-            recoverableOsBugDetected();
-            break :deadline .{ .raw = .{ .nanoseconds = 0 }, .clock = .awake };
+fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows.ULONG) callconv(.winapi) void {
+    const b: *Io.Batch = @ptrCast(@alignCast(apc_context));
+    const context: *WindowsBatchPendingOperationContext = @fieldParentPtr("iosb", iosb);
+    const erased_context = context.toErased();
+    const pending: *Io.Operation.Storage.Pending = @fieldParentPtr("context", erased_context);
+    switch (pending.node.prev) {
+        .none => b.pending.head = pending.node.next,
+        else => |prev_index| b.storage[prev_index.toIndex()].pending.node.next = pending.node.next,
+    }
+    switch (pending.node.next) {
+        .none => b.pending.tail = pending.node.prev,
+        else => |next_index| b.storage[next_index.toIndex()].pending.node.prev = pending.node.prev,
+    }
+    const storage: *Io.Operation.Storage = @fieldParentPtr("pending", pending);
+    const index = storage - b.storage.ptr;
+    switch (iosb.u.Status) {
+        .CANCELLED => {
+            const tail_index = b.unused.tail;
+            switch (tail_index) {
+                .none => b.unused.head = .fromIndex(index),
+                else => b.storage[tail_index.toIndex()].unused.next = .fromIndex(index),
+            }
+            storage.* = .{ .unused = .{ .prev = tail_index, .next = .none } };
+            b.unused.tail = .fromIndex(index);
         },
-        error.UnsupportedClock => |e| return e,
-    };
-
-    while (true) {
-        var any_pending = false;
-        for (metadatas, 0..) |*metadata, op_usize| {
-            if (!metadata.pending) continue;
-            any_pending = true;
-            const op: u31 = @intCast(op_usize);
-            const done = @atomicLoad(windows.NTSTATUS, &metadata.iosb.u.Status, .acquire) != .PENDING;
-            switch (operations[op]) {
-                .noop => unreachable,
-                .file_read_streaming => |*o| {
-                    assert(o.status.pending == b);
-                    if (!done) continue;
-                    o.status = .{ .result = ntReadFileResult(&metadata.iosb) };
-                },
+        else => {
+            switch (b.completions.tail) {
+                .none => b.completions.head = .fromIndex(index),
+                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = .fromIndex(index),
             }
-            metadata.pending = false;
-            submitComplete(ring, &complete_tail, op);
-        }
-        if (b.user.complete_head != complete_tail) return;
-        if (!any_pending) return;
-        var delay_interval: windows.LARGE_INTEGER = interval: {
-            const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
-            break :interval t.deadlineToWindowsInterval(d) catch |err| switch (err) {
-                error.UnsupportedClock => |e| return e,
-                error.Unexpected => {
-                    recoverableOsBugDetected();
-                    break :interval -1;
-                },
+            b.completions.tail = .fromIndex(index);
+            const result: Io.Operation.Result = switch (pending.tag) {
+                .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
             };
-        };
-        const alertable_syscall = try AlertableSyscall.start();
-        const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
-        alertable_syscall.finish();
-        switch (delay_rc) {
-            .SUCCESS, .TIMEOUT => {
-                // The thread woke due to the timeout. Although spurious
-                // timeouts are OK, when no deadline is passed we must not
-                // return `error.Timeout`.
-                if (timeout != .none) return error.Timeout;
+            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+        },
+    }
+}
+
+fn batchAwaitWindows(b: *Io.Batch) Io.Cancelable!void {
+    var index = b.submissions.head;
+    errdefer b.submissions.head = index;
+    while (index != .none) {
+        const storage = &b.storage[index.toIndex()];
+        const submission = storage.submission;
+        errdefer storage.* = .{ .submission = submission };
+        storage.* = .{ .pending = .{
+            .node = .{ .prev = b.pending.tail, .next = .none },
+            .tag = submission.operation,
+            .context = undefined,
+        } };
+        const context: *WindowsBatchPendingOperationContext = .fromErased(&storage.pending.context);
+        switch (submission.operation) {
+            .file_read_streaming => |o| {
+                context.file = o.file.handle;
+                try ntReadFile(o.file.handle, o.data, &batchApc, b, &context.iosb);
             },
-            else => {},
         }
+        switch (b.pending.tail) {
+            .none => b.pending.head = index,
+            else => |tail_index| b.storage[tail_index.toIndex()].pending.node.next = index,
+        }
+        b.pending.tail = index;
+        index = submission.node.next;
     }
+    b.submissions = .{ .head = .none, .tail = .none };
 }
 
 fn submitComplete(ring: []u32, complete_tail: *Io.Batch.RingIndex, op: u32) void {
@@ -8701,7 +8818,7 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingEr
         .u = .{ .Status = .PENDING },
         .Information = 0,
     };
-    try ntReadFile(file.handle, data, &io_status_block);
+    try ntReadFile(file.handle, data, &noopApc, null, &io_status_block);
     while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
         // Once we get here we must not return from the function until the
         // operation completes, thereby releasing reference to io_status_block.
@@ -8736,12 +8853,20 @@ fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
     }
 }
 
-fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STATUS_BLOCK) Io.Cancelable!void {
+fn ntReadFile(
+    handle: windows.HANDLE,
+    data: []const []u8,
+    apcRoutine: ?*const windows.IO_APC_ROUTINE,
+    apc_context: ?*anyopaque,
+    iosb: *windows.IO_STATUS_BLOCK,
+) Io.Cancelable!void {
     var index: usize = 0;
     while (index < data.len and data[index].len == 0) index += 1;
     if (index == data.len) {
-        iosb.u.Status = .SUCCESS;
-        iosb.Information = 0;
+        iosb.* = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
+        if (apcRoutine) |routine| if (routine != &noopApc) {
+            _ = windows.ntdll.NtQueueApcThread(windows.current_process, routine, apc_context, iosb, null);
+        };
         return;
     }
     const buffer = data[index];
@@ -8750,8 +8875,8 @@ fn ntReadFile(handle: windows.HANDLE, data: []const []u8, iosb: *windows.IO_STAT
     while (true) switch (windows.ntdll.NtReadFile(
         handle,
         null, // event
-        noopApc, // apc callback
-        null, // apc context
+        apcRoutine,
+        apc_context,
         iosb,
         buffer.ptr,
         @min(std.math.maxInt(u32), buffer.len),
-- 
2.54.0


From 62c97b745d508a5ed7011bf3b8400fde4677b839 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 12:27:27 -0800
Subject: [PATCH 149/499] std.Io.Threaded: stop checking bytes read with
 END_OF_FILE

---
 lib/std/Io/Threaded.zig | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 18f24eb40cefdabe8fca2820e239edac1046aafc..45184e6d595d9106176c0a7029fdb017dcc3ec49 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -8816,9 +8816,10 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.ReadStreamingErro
 fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingError!usize {
     var io_status_block: windows.IO_STATUS_BLOCK = .{
         .u = .{ .Status = .PENDING },
-        .Information = 0,
+        .Information = undefined,
     };
     try ntReadFile(file.handle, data, &noopApc, null, &io_status_block);
+
     while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
         // Once we get here we must not return from the function until the
         // operation completes, thereby releasing reference to io_status_block.
@@ -8842,10 +8843,7 @@ fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
         .PENDING => unreachable,
         .CANCELLED => unreachable,
         .SUCCESS => return io_status_block.Information,
-        .END_OF_FILE, .PIPE_BROKEN => {
-            if (io_status_block.Information == 0) return error.EndOfStream;
-            return io_status_block.Information;
-        },
+        .END_OF_FILE, .PIPE_BROKEN => return error.EndOfStream,
         .INVALID_DEVICE_REQUEST => return error.IsDir,
         .LOCK_NOT_GRANTED => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
-- 
2.54.0


From 39a6d5d1c5db32e9648fba6a46f3fef4ef83974a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 17:59:48 -0800
Subject: [PATCH 150/499] std.Io.File: add non-blocking flag

On Windows, we need to know ahead of time whether a file was opened in
synchronous mode or asynchronous mode. There may be advantages to
tracking this state for POSIX operating systems as well.
---
 lib/std/Io/File.zig          | 18 +++++++++
 lib/std/Io/Threaded.zig      | 71 ++++++++++++++++++++++++++----------
 lib/std/Io/Threaded/test.zig |  4 +-
 lib/std/Progress.zig         |  1 +
 lib/std/posix/test.zig       |  9 +++--
 5 files changed, 79 insertions(+), 24 deletions(-)

diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index 5db6f81ac6f8e2b2ade7fcd49916af06b1317c7d..e0297e0573c06dc35cbc169bd822832b4cf80648 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -10,6 +10,18 @@ const assert = std.debug.assert;
 const Dir = std.Io.Dir;
 
 handle: Handle,
+flags: Flags,
+
+pub const Flags = struct {
+    /// * true:
+    ///   - windows: opened with MODE.IO.ASYNCHRONOUS
+    ///   - POSIX: O_NONBLOCK is set
+    /// * false:
+    ///   - windows: opened with SYNCHRONOUS_ALERT or SYNCHRONOUS_NONALERT, or
+    ///     not a file.
+    ///   - POSIX: O_NONBLOCK is unset
+    nonblocking: bool,
+};
 
 pub const Handle = std.posix.fd_t;
 
@@ -80,9 +92,11 @@ pub fn stdout() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdOutput,
+            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDOUT_FILENO,
+            .flags = .{ .nonblocking = false },
         },
     };
 }
@@ -91,9 +105,11 @@ pub fn stderr() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdError,
+            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDERR_FILENO,
+            .flags = .{ .nonblocking = false },
         },
     };
 }
@@ -102,9 +118,11 @@ pub fn stdin() File {
     return switch (native_os) {
         .windows => .{
             .handle = std.os.windows.peb().ProcessParameters.hStdInput,
+            .flags = .{ .nonblocking = false },
         },
         else => .{
             .handle = std.posix.STDIN_FILENO,
+            .flags = .{ .nonblocking = false },
         },
     };
 }
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 45184e6d595d9106176c0a7029fdb017dcc3ec49..8fdd2a58e9dd687e79e0a0457cfbc9342c0c5970 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3215,8 +3215,10 @@ fn dirCreateDirPathOpenWasi(
 
 fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const file: File = .{ .handle = dir.handle };
-    return fileStat(t, file);
+    return fileStat(t, .{
+        .handle = dir.handle,
+        .flags = .{ .nonblocking = false },
+    });
 }
 
 const dirStatFile = switch (native_os) {
@@ -4008,7 +4010,10 @@ fn dirCreateFilePosix(
         }
     }
 
-    return .{ .handle = fd };
+    return .{
+        .handle = fd,
+        .flags = .{ .nonblocking = false },
+    };
 }
 
 fn dirCreateFileWindows(
@@ -4138,7 +4143,10 @@ fn dirCreateFileWindows(
     errdefer windows.CloseHandle(handle);
 
     const exclusive = switch (flags.lock) {
-        .none => return .{ .handle = handle },
+        .none => return .{
+            .handle = handle,
+            .flags = .{ .nonblocking = false },
+        },
         .shared => false,
         .exclusive => true,
     };
@@ -4158,7 +4166,10 @@ fn dirCreateFileWindows(
     )) {
         .SUCCESS => {
             syscall.finish();
-            return .{ .handle = handle };
+            return .{
+                .handle = handle,
+                .flags = .{ .nonblocking = false },
+            };
         },
         .INSUFFICIENT_RESOURCES => return syscall.fail(error.SystemResources),
         .LOCK_NOT_GRANTED => return syscall.fail(error.WouldBlock),
@@ -4207,7 +4218,10 @@ fn dirCreateFileWasi(
         switch (wasi.path_open(dir.handle, lookup_flags, sub_path.ptr, sub_path.len, oflags, base, inheriting, fdflags, &fd)) {
             .SUCCESS => {
                 syscall.finish();
-                return .{ .handle = fd };
+                return .{
+                    .handle = fd,
+                    .flags = .{ .nonblocking = false },
+                };
             },
             .INTR => {
                 try syscall.checkCancel();
@@ -4302,7 +4316,10 @@ fn dirCreateFileAtomic(
                 .SUCCESS => {
                     syscall.finish();
                     return .{
-                        .file = .{ .handle = @intCast(rc) },
+                        .file = .{
+                            .handle = @intCast(rc),
+                            .flags = .{ .nonblocking = false },
+                        },
                         .file_basename_hex = 0,
                         .dest_sub_path = dest_path,
                         .file_open = true,
@@ -4510,7 +4527,10 @@ fn dirOpenFilePosix(
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
-            const stat = fileStat(t, .{ .handle = fd }) catch |err| switch (err) {
+            const stat = fileStat(t, .{
+                .handle = fd,
+                .flags = .{ .nonblocking = false },
+            }) catch |err| switch (err) {
                 // The directory-ness is either unknown or unknowable
                 error.Streaming => break :is_dir false,
                 else => |e| return e,
@@ -4596,7 +4616,10 @@ fn dirOpenFilePosix(
         }
     }
 
-    return .{ .handle = fd };
+    return .{
+        .handle = fd,
+        .flags = .{ .nonblocking = false },
+    };
 }
 
 fn dirOpenFileWindows(
@@ -4729,7 +4752,10 @@ pub fn dirOpenFileWtf16(
     errdefer w.CloseHandle(handle);
 
     const exclusive = switch (flags.lock) {
-        .none => return .{ .handle = handle },
+        .none => return .{
+            .handle = handle,
+            .flags = .{ .nonblocking = false },
+        },
         .shared => false,
         .exclusive => true,
     };
@@ -4752,7 +4778,10 @@ pub fn dirOpenFileWtf16(
         .ACCESS_VIOLATION => |err| return syscall.ntstatusBug(err), // bad io_status_block pointer
         else => |status| return syscall.unexpectedNtstatus(status),
     };
-    return .{ .handle = handle };
+    return .{
+        .handle = handle,
+        .flags = .{ .nonblocking = false },
+    };
 }
 
 fn dirOpenFileWasi(
@@ -4834,7 +4863,7 @@ fn dirOpenFileWasi(
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
-            const stat = fileStat(t, .{ .handle = fd }) catch |err| switch (err) {
+            const stat = fileStat(t, .{ .handle = fd, .flags = .{ .nonblocking = false } }) catch |err| switch (err) {
                 // The directory-ness is either unknown or unknowable
                 error.Streaming => break :is_dir false,
                 else => |e| return e,
@@ -4844,7 +4873,10 @@ fn dirOpenFileWasi(
         if (is_dir) return error.IsDir;
     }
 
-    return .{ .handle = fd };
+    return .{
+        .handle = fd,
+        .flags = .{ .nonblocking = false },
+    };
 }
 
 const dirOpenDir = switch (native_os) {
@@ -14390,15 +14422,15 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
         .pid = pid,
         .err_fd = err_pipe[0],
         .stdin = switch (options.stdin) {
-            .pipe => .{ .handle = stdin_pipe[1] },
+            .pipe => .{ .handle = stdin_pipe[1], .flags = .{ .nonblocking = false } },
             else => null,
         },
         .stdout = switch (options.stdout) {
-            .pipe => .{ .handle = stdout_pipe[0] },
+            .pipe => .{ .handle = stdout_pipe[0], .flags = .{ .nonblocking = false } },
             else => null,
         },
         .stderr = switch (options.stderr) {
-            .pipe => .{ .handle = stderr_pipe[0] },
+            .pipe => .{ .handle = stderr_pipe[0], .flags = .{ .nonblocking = false } },
             else => null,
         },
     };
@@ -15052,9 +15084,9 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     return .{
         .id = piProcInfo.hProcess,
         .thread_handle = piProcInfo.hThread,
-        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h } else null,
-        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h } else null,
-        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h } else null,
+        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h, .flags = .{ .nonblocking = false } } else null,
+        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
+        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
         .request_resource_usage_statistics = options.request_resource_usage_statistics,
     };
 }
@@ -16188,6 +16220,7 @@ fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
             .pointer => @ptrFromInt(int),
             else => return error.UnsupportedOperation,
         },
+        .flags = .{ .nonblocking = false },
     };
 }
 
diff --git a/lib/std/Io/Threaded/test.zig b/lib/std/Io/Threaded/test.zig
index ffda1e7601c81b790c4bf9148a6835d4f448de88..593580d1f62511b7ce1d73248cc50a0bca5a45a2 100644
--- a/lib/std/Io/Threaded/test.zig
+++ b/lib/std/Io/Threaded/test.zig
@@ -188,8 +188,8 @@ test "cancel blocked read from pipe" {
         }),
         else => {
             const pipe = try std.Io.Threaded.pipe2(.{});
-            read_end = .{ .handle = pipe[0] };
-            write_end = .{ .handle = pipe[1] };
+            read_end = .{ .handle = pipe[0], .flags = .{ .nonblocking = false } };
+            write_end = .{ .handle = pipe[1], .flags = .{ .nonblocking = false } };
         },
     }
     defer {
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index d0ee9e556f5c384cf7eef6952900447d7c45a07b..0fefc77a32e788267a10f9fc2b613c96abeb5e19 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -979,6 +979,7 @@ fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buff
         if (main_parent == .unused) continue;
         const file: Io.File = .{
             .handle = main_storage.getIpcFd() orelse continue,
+            .flags = .{ .nonblocking = true },
         };
         const opt_saved_metadata = findOld(file.handle, old_ipc_metadata_fds, old_ipc_metadata);
         var bytes_read: usize = 0;
diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig
index 5838595fcf50cec130595089b7d38c26b17f19b8..e2a52473f3862ea1332a82abd0d0ab98d428b153 100644
--- a/lib/std/posix/test.zig
+++ b/lib/std/posix/test.zig
@@ -126,8 +126,8 @@ test "pipe" {
     const io = testing.io;
 
     const fds = try std.Io.Threaded.pipe2(.{});
-    const out: Io.File = .{ .handle = fds[0] };
-    const in: Io.File = .{ .handle = fds[1] };
+    const out: Io.File = .{ .handle = fds[0], .flags = .{ .nonblocking = false } };
+    const in: Io.File = .{ .handle = fds[1], .flags = .{ .nonblocking = false } };
     try in.writeStreamingAll(io, "hello");
     var buf: [16]u8 = undefined;
     try expect((try out.readStreaming(io, &.{&buf})) == 5);
@@ -150,7 +150,10 @@ test "memfd_create" {
         else => return error.SkipZigTest,
     }
 
-    const file: Io.File = .{ .handle = try posix.memfd_create("test", 0) };
+    const file: Io.File = .{
+        .handle = try posix.memfd_create("test", 0),
+        .flags = .{ .nonblocking = false },
+    };
     defer file.close(io);
     try file.writePositionalAll(io, "test", 0);
 
-- 
2.54.0


From 25aef0dd8786c5b5342eda167a609529efa09353 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 19:10:44 -0800
Subject: [PATCH 151/499] std.Io.Threaded: rework file reading to observe
 nonblocking flag

- batchAwaitAsync does blocking reads with NtReadFile (no APC, no event)
  when the nonblocking flag is unset, but still takes advantage of
  APCs when nonblocking flag is set.
- batchAwaitConcurrent returns error.ConcurrencyUnavailable when it
  encounters a file_read_streaming operation on a file in blocking mode.
- fileReadStreaming avoids pointlessly checking sync cancelation status
  when nonblocking flag is set, uses an APC with a done flag, and waits
  on that value to change in NtDelayExecution before returning.
- fix incorrect use of NtCancelIoFile (ntdll function prototype was
  wrong, leading to misuse)
---
 lib/std/Io/Threaded.zig      | 224 +++++++++++++++++++++++------------
 lib/std/os/windows/ntdll.zig |   2 +-
 2 files changed, 147 insertions(+), 79 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 8fdd2a58e9dd687e79e0a0457cfbc9342c0c5970..e9e5ece521e9276c11a0523ae53eac44ce548ef4 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1340,8 +1340,6 @@ const AlertableSyscall = struct {
     }
 };
 
-fn noopApc(_: ?*anyopaque, _: *windows.IO_STATUS_BLOCK, _: windows.ULONG) callconv(.winapi) void {}
-
 fn waitForApcOrAlert() void {
     const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
     _ = windows.ntdll.NtDelayExecution(windows.TRUE, &infinite_timeout);
@@ -2500,7 +2498,10 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
 fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Batch.AwaitAsyncError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
-        try batchAwaitWindows(b);
+        batchAwaitWindows(b, false) catch |err| switch (err) {
+            error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
+            else => |e| return e,
+        };
         const alertable_syscall = try AlertableSyscall.start();
         while (b.pending.head != .none and b.completions.head == .none) waitForApcOrAlert();
         alertable_syscall.finish();
@@ -2616,7 +2617,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
             },
             error.UnsupportedClock => |e| return e,
         };
-        try batchAwaitWindows(b);
+        try batchAwaitWindows(b, true);
         while (b.pending.head != .none and b.completions.head == .none) {
             var delay_interval: windows.LARGE_INTEGER = interval: {
                 const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
@@ -2810,7 +2811,8 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
         while (index != .none) {
             const pending = &b.storage[index.toIndex()].pending;
             const context: *WindowsBatchPendingOperationContext = .fromErased(&pending.context);
-            _ = windows.ntdll.NtCancelIoFile(context.file, &context.iosb);
+            var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+            _ = windows.ntdll.NtCancelIoFileEx(context.file, &context.iosb, &cancel_iosb);
             index = pending.node.next;
         }
         while (b.pending.head != .none) waitForApcOrAlert();
@@ -2860,30 +2862,94 @@ fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows
     }
 }
 
-fn batchAwaitWindows(b: *Io.Batch) Io.Cancelable!void {
+/// If `concurrency` is false, `error.ConcurrencyUnavailable` is unreachable.
+fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, ConcurrencyUnavailable }!void {
     var index = b.submissions.head;
     errdefer b.submissions.head = index;
     while (index != .none) {
         const storage = &b.storage[index.toIndex()];
         const submission = storage.submission;
-        errdefer storage.* = .{ .submission = submission };
         storage.* = .{ .pending = .{
             .node = .{ .prev = b.pending.tail, .next = .none },
             .tag = submission.operation,
             .context = undefined,
         } };
-        const context: *WindowsBatchPendingOperationContext = .fromErased(&storage.pending.context);
-        switch (submission.operation) {
-            .file_read_streaming => |o| {
-                context.file = o.file.handle;
-                try ntReadFile(o.file.handle, o.data, &batchApc, b, &context.iosb);
-            },
-        }
         switch (b.pending.tail) {
             .none => b.pending.head = index,
             else => |tail_index| b.storage[tail_index.toIndex()].pending.node.next = index,
         }
         b.pending.tail = index;
+        const context: *WindowsBatchPendingOperationContext = .fromErased(&storage.pending.context);
+        errdefer {
+            context.iosb.u.Status = .CANCELLED;
+            batchApc(b, &context.iosb, 0);
+        }
+        switch (submission.operation) {
+            .file_read_streaming => |o| o: {
+                var data_index: usize = 0;
+                while (o.data.len - data_index != 0 and o.data[data_index].len == 0) data_index += 1;
+                if (o.data.len - data_index == 0) {
+                    context.iosb = .{
+                        .u = .{ .Status = .SUCCESS },
+                        .Information = 0,
+                    };
+                    batchApc(b, &context.iosb, 0);
+                    break :o;
+                }
+                const buffer = o.data[data_index];
+                const short_buffer_len = @min(std.math.maxInt(u32), buffer.len);
+
+                if (o.file.flags.nonblocking) {
+                    context.file = o.file.handle;
+                    switch (windows.ntdll.NtReadFile(
+                        o.file.handle,
+                        null, // event
+                        &batchApc,
+                        b,
+                        &context.iosb,
+                        buffer.ptr,
+                        short_buffer_len,
+                        null, // byte offset
+                        null, // key
+                    )) {
+                        .PENDING, .SUCCESS => {},
+                        .CANCELLED => unreachable,
+                        else => |status| {
+                            context.iosb.u.Status = status;
+                            batchApc(b, &context.iosb, 0);
+                        },
+                    }
+                } else {
+                    if (concurrency) return error.ConcurrencyUnavailable;
+
+                    const syscall: Syscall = try .start();
+                    while (true) switch (windows.ntdll.NtReadFile(
+                        o.file.handle,
+                        null, // event
+                        null, // APC routine
+                        null, // APC context
+                        &context.iosb,
+                        buffer.ptr,
+                        short_buffer_len,
+                        null, // byte offset
+                        null, // key
+                    )) {
+                        .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+                        .CANCELLED => {
+                            try syscall.checkCancel();
+                            continue;
+                        },
+                        else => |status| {
+                            syscall.finish();
+
+                            context.iosb.u.Status = status;
+                            batchApc(b, &context.iosb, 0);
+                            break;
+                        },
+                    };
+                }
+            },
+        }
         index = submission.node.next;
     }
     b.submissions = .{ .head = .none, .tail = .none };
@@ -8846,28 +8912,76 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.ReadStreamingErro
 }
 
 fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingError!usize {
-    var io_status_block: windows.IO_STATUS_BLOCK = .{
-        .u = .{ .Status = .PENDING },
-        .Information = undefined,
-    };
-    try ntReadFile(file.handle, data, &noopApc, null, &io_status_block);
+    var index: usize = 0;
+    while (data.len - index != 0 and data[index].len == 0) index += 1;
+    if (data.len - index == 0) return 0;
+    const buffer = data[index];
+    const short_buffer_len = @min(std.math.maxInt(u32), buffer.len);
 
-    while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
-        // Once we get here we must not return from the function until the
-        // operation completes, thereby releasing reference to io_status_block.
-        const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
-            error.Canceled => |e| {
-                _ = windows.ntdll.NtCancelIoFile(file.handle, &io_status_block);
-                while (@atomicLoad(windows.NTSTATUS, &io_status_block.u.Status, .acquire) == .PENDING) {
-                    waitForApcOrAlert();
-                }
-                return e;
+    var iosb: windows.IO_STATUS_BLOCK = undefined;
+
+    if (!file.flags.nonblocking) {
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtReadFile(
+            file.handle,
+            null, // event
+            null, // APC routine
+            null, // APC context
+            &iosb,
+            buffer.ptr,
+            short_buffer_len,
+            null, // byte offset
+            null, // key
+        )) {
+            .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            else => |status| {
+                syscall.finish();
+                iosb.u.Status = status;
+                return ntReadFileResult(&iosb);
             },
         };
-        waitForApcOrAlert();
-        alertable_syscall.finish();
     }
-    return ntReadFileResult(&io_status_block);
+
+    var done: bool = false;
+
+    switch (windows.ntdll.NtReadFile(
+        file.handle,
+        null, // event
+        flagApc,
+        &done, // APC context
+        &iosb,
+        buffer.ptr,
+        short_buffer_len,
+        null, // byte offset
+        null, // key
+    )) {
+        // We must wait for the APC routine.
+        .PENDING, .SUCCESS => while (!done) {
+            // Once we get here we must not return from the function until the
+            // operation completes, thereby releasing reference to io_status_block.
+            const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                error.Canceled => |e| {
+                    var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                    _ = windows.ntdll.NtCancelIoFileEx(file.handle, &iosb, &cancel_iosb);
+                    while (!done) waitForApcOrAlert();
+                    return e;
+                },
+            };
+            waitForApcOrAlert();
+            alertable_syscall.finish();
+        },
+        else => |status| iosb.u.Status = status,
+    }
+    return ntReadFileResult(&iosb);
+}
+
+fn flagApc(userdata: ?*anyopaque, _: *windows.IO_STATUS_BLOCK, _: windows.ULONG) callconv(.winapi) void {
+    const flag: *bool = @ptrCast(userdata);
+    flag.* = true;
 }
 
 fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
@@ -8883,52 +8997,6 @@ fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
     }
 }
 
-fn ntReadFile(
-    handle: windows.HANDLE,
-    data: []const []u8,
-    apcRoutine: ?*const windows.IO_APC_ROUTINE,
-    apc_context: ?*anyopaque,
-    iosb: *windows.IO_STATUS_BLOCK,
-) Io.Cancelable!void {
-    var index: usize = 0;
-    while (index < data.len and data[index].len == 0) index += 1;
-    if (index == data.len) {
-        iosb.* = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
-        if (apcRoutine) |routine| if (routine != &noopApc) {
-            _ = windows.ntdll.NtQueueApcThread(windows.current_process, routine, apc_context, iosb, null);
-        };
-        return;
-    }
-    const buffer = data[index];
-
-    const syscall: Syscall = try .start();
-    while (true) switch (windows.ntdll.NtReadFile(
-        handle,
-        null, // event
-        apcRoutine,
-        apc_context,
-        iosb,
-        buffer.ptr,
-        @min(std.math.maxInt(u32), buffer.len),
-        null, // byte offset
-        null, // key
-    )) {
-        .PENDING => {
-            syscall.finish();
-            return;
-        },
-        .CANCELLED => {
-            try syscall.checkCancel();
-            continue;
-        },
-        else => |status| {
-            syscall.finish();
-            iosb.u.Status = status;
-            return;
-        },
-    };
-}
-
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
     if (!have_preadv) @compileError("TODO implement fileReadPositionalPosix for cursed operating systems that don't support preadv (it's only Haiku)");
 
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 195a457d3b86167051c1a6f9d9eb4415673eb021..d9e68e54f9f275fbf254098e8b7716aad2cead5e 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -614,5 +614,5 @@ pub extern "ntdll" fn NtCancelIoFileEx(
 
 pub extern "ntdll" fn NtCancelIoFile(
     FileHandle: HANDLE,
-    IoRequestToCancel: ?*IO_STATUS_BLOCK,
+    IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
-- 
2.54.0


From b6f4bb91c41bb78276ad54725ae5c61a160defd6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 11:45:08 -0800
Subject: [PATCH 152/499] std.Io: add documentation to Batch

---
 lib/std/Io.zig          | 34 ++++++++++++++++++++++++++++++----
 lib/std/Io/Threaded.zig |  2 +-
 2 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index ca77a9836ad4df4993f3f64ccbb3c2af6228bcc2..c3ba3575e477ddce5c2cf5fb9ed7bbe5b6a02acb 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -150,7 +150,7 @@ pub const VTable = struct {
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
 
     operate: *const fn (?*anyopaque, Operation) Cancelable!Operation.Result,
-    batchAwaitAsync: *const fn (?*anyopaque, *Batch) Batch.AwaitAsyncError!void,
+    batchAwaitAsync: *const fn (?*anyopaque, *Batch) Cancelable!void,
     batchAwaitConcurrent: *const fn (?*anyopaque, *Batch, Timeout) Batch.AwaitConcurrentError!void,
     batchCancel: *const fn (?*anyopaque, *Batch) void,
 
@@ -359,7 +359,7 @@ pub fn operate(io: Io, operation: Operation) Cancelable!Operation.Result {
 /// complete.
 ///
 /// This is a low-level abstraction based on `Operation`. For a higher
-/// level API that operates on `Future`, see `Select`.
+/// level API that operates on `Future`, see `Select` and `Group`.
 pub const Batch = struct {
     storage: []Operation.Storage,
     unused: Operation.List,
@@ -422,6 +422,11 @@ pub const Batch = struct {
         b.submissions.tail = .fromIndex(index);
     }
 
+    /// After calling `awaitAsync`, `awaitConcurrent`, or `cancel`, this
+    /// function iterates over the completed operations.
+    ///
+    /// Each completion returned from this function dequeues from the `Batch`.
+    /// It is not required to dequeue all completions before awaiting again.
     pub fn next(b: *Batch) ?struct { index: u32, result: Operation.Result } {
         const index = b.completions.head;
         if (index == .none) return null;
@@ -441,16 +446,37 @@ pub const Batch = struct {
         return .{ .index = index.toIndex(), .result = completion.result };
     }
 
-    pub const AwaitAsyncError = Cancelable;
-    pub fn awaitAsync(b: *Batch, io: Io) AwaitAsyncError!void {
+    /// Waits for at least one of the submitted operations to complete. After
+    /// this function returns the completed operations can be iterated with
+    /// `next`.
+    ///
+    /// This function provides opportunity for the implementation to introduce
+    /// concurrency into the batched operations, but unlike `awaitConcurrent`,
+    /// does not require it, and therefore cannot fail with
+    /// `error.ConcurrencyUnavailable`.
+    pub fn awaitAsync(b: *Batch, io: Io) Cancelable!void {
         return io.vtable.batchAwaitAsync(io.userdata, b);
     }
 
     pub const AwaitConcurrentError = ConcurrentError || Cancelable || Timeout.Error;
+
+    /// Waits for at least one of the submitted operations to complete. After
+    /// this function returns the completed operations can be iterated with
+    /// `next`.
+    ///
+    /// Unlike `awaitAsync`, this function requires the implementation to
+    /// perform the operations concurrently and therefore can fail with
+    /// `error.ConcurrencyUnavailable`.
     pub fn awaitConcurrent(b: *Batch, io: Io, timeout: Timeout) AwaitConcurrentError!void {
         return io.vtable.batchAwaitConcurrent(io.userdata, b, timeout);
     }
 
+    /// Requests all pending operations to be interrupted, then waits for all
+    /// pending operations to complete. After this returns, the `Batch` is in a
+    /// well-defined state, ready to be iterated with `next`. Successfully
+    /// canceled operations will be absent from the iteration. Some operations
+    /// may have successfully completed regardless of the cancel request and
+    /// will appear in the iteration.
     pub fn cancel(b: *Batch, io: Io) void {
         return io.vtable.batchCancel(io.userdata, b);
     }
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index e9e5ece521e9276c11a0523ae53eac44ce548ef4..f9002567a2cc0fbb9a3db8dfed8dcfe6211ffa37 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2495,7 +2495,7 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
     }
 }
 
-fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Batch.AwaitAsyncError!void {
+fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
         batchAwaitWindows(b, false) catch |err| switch (err) {
-- 
2.54.0


From 43866f743978ef6cf4755760cc96d4c00665fde3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 21:57:51 -0800
Subject: [PATCH 153/499] build.zig: bump max_rss

encountered error: memory usage peaked at 0.66GB (656060416 bytes),
exceeding the declared upper bound of 0.64GB (639565414 bytes)
---
 build.zig | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/build.zig b/build.zig
index 3ed237fa5ea851ee8412851715038400ec29e1b7..84cbba38bdb6026dc3691463ac40d1fcad33419e 100644
--- a/build.zig
+++ b/build.zig
@@ -498,23 +498,7 @@ pub fn build(b: *std.Build) !void {
         .skip_llvm = skip_llvm,
         .skip_libc = true,
         .no_builtin = true,
-        .max_rss = switch (b.graph.host.result.os.tag) {
-            .freebsd => 800_000_000,
-            .linux => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 639_565_414,
-                .loongarch64 => 598_884_352,
-                .powerpc64le => 597_897_625,
-                .riscv64 => 636_429_516,
-                .s390x => 574_166_630,
-                .x86_64 => 978_463_129,
-                else => 900_000_000,
-            },
-            .macos => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 701_413_785,
-                else => 800_000_000,
-            },
-            else => 900_000_000,
-        },
+        .max_rss = 900_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
-- 
2.54.0


From 14e1e5f6d872a7a8a8d98fa48cc6f41f002a7d1f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 22:00:02 -0800
Subject: [PATCH 154/499] std: IoUring test handles EINTR

---
 lib/std/os/linux/IoUring/test.zig | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig
index ac2d5ddea54772253084d2699be4180cad7a794a..644b9b7c77c2666a0493a84eab6cc6b8065b4e2d 100644
--- a/lib/std/os/linux/IoUring/test.zig
+++ b/lib/std/os/linux/IoUring/test.zig
@@ -2736,8 +2736,9 @@ fn send(sockfd: posix.socket_t, buf: []const u8, flags: u32) !usize {
 }
 
 fn connect(sock: posix.socket_t, sock_addr: *const posix.sockaddr, len: posix.socklen_t) !void {
-    switch (posix.errno(posix.system.connect(sock, sock_addr, len))) {
+    while (true) switch (posix.errno(posix.system.connect(sock, sock_addr, len))) {
         .SUCCESS => return,
+        .INTR => continue,
         else => return error.ConnectFailed,
-    }
+    };
 }
-- 
2.54.0


From 9646801bed8f0f36b59deecff32ef02868ed72f2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 22:06:33 -0800
Subject: [PATCH 155/499] std: fix Preopens compilation error

---
 lib/std/process/Preopens.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/process/Preopens.zig b/lib/std/process/Preopens.zig
index 8223c29f83fadce644c49c874e0039d9e090ed96..3baf696ee9a5d95dbf2bed352ea4867e8c3fde8c 100644
--- a/lib/std/process/Preopens.zig
+++ b/lib/std/process/Preopens.zig
@@ -29,7 +29,10 @@ pub fn get(p: *const Preopens, name: []const u8) ?Resource {
     switch (native_os) {
         .wasi => {
             const index = p.map.getIndex(name) orelse return null;
-            if (index <= 2) return .{ .file = .{ .handle = @intCast(index) } };
+            if (index <= 2) return .{ .file = .{
+                .handle = @intCast(index),
+                .flags = .{ .nonblocking = false },
+            } };
             return .{ .dir = .{ .handle = @intCast(index) } };
         },
         else => {
-- 
2.54.0


From 5ccc2ea85d5d4c23daae8a3afe6b7784071597ac Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 22:00:02 -0800
Subject: [PATCH 156/499] std: IoUring test handles EINTR

---
 lib/std/os/linux/IoUring/test.zig | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig
index ac2d5ddea54772253084d2699be4180cad7a794a..644b9b7c77c2666a0493a84eab6cc6b8065b4e2d 100644
--- a/lib/std/os/linux/IoUring/test.zig
+++ b/lib/std/os/linux/IoUring/test.zig
@@ -2736,8 +2736,9 @@ fn send(sockfd: posix.socket_t, buf: []const u8, flags: u32) !usize {
 }
 
 fn connect(sock: posix.socket_t, sock_addr: *const posix.sockaddr, len: posix.socklen_t) !void {
-    switch (posix.errno(posix.system.connect(sock, sock_addr, len))) {
+    while (true) switch (posix.errno(posix.system.connect(sock, sock_addr, len))) {
         .SUCCESS => return,
+        .INTR => continue,
         else => return error.ConnectFailed,
-    }
+    };
 }
-- 
2.54.0


From e60ba21114bc4514acc535be7106ce6c16e9bf04 Mon Sep 17 00:00:00 2001
From: "kj4tmp@gmail.com" <kj4tmp@gmail.com>
Date: Thu, 29 Jan 2026 21:07:12 -0800
Subject: [PATCH 157/499] libzigc: roundl

---
 lib/libc/mingw/math/roundl.c          | 26 --------------------------
 lib/libc/musl/src/math/s390x/roundl.c | 15 ---------------
 src/libs/mingw.zig                    |  1 -
 src/libs/musl.zig                     |  2 --
 src/libs/wasi_libc.zig                |  1 -
 test/libc.zig                         |  2 +-
 6 files changed, 1 insertion(+), 46 deletions(-)
 delete mode 100644 lib/libc/mingw/math/roundl.c
 delete mode 100644 lib/libc/musl/src/math/s390x/roundl.c

diff --git a/lib/libc/mingw/math/roundl.c b/lib/libc/mingw/math/roundl.c
deleted file mode 100644
index 9879a82cc2a3ad98f89c263efec3236c5387d1c7..0000000000000000000000000000000000000000
--- a/lib/libc/mingw/math/roundl.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <math.h>
-
-long double
-roundl (long double x)
-{
-  long double res = 0.0L;
-  if (x >= 0.0L)
-    {
-      res = ceill (x);
-      if (res - x > 0.5L)
-	res -= 1.0L;
-    }
-  else
-    {
-      res = ceill (-x);
-      if (res + x > 0.5L)
-	res -= 1.0L;
-      res = -res;
-    }
-  return res;
-}
diff --git a/lib/libc/musl/src/math/s390x/roundl.c b/lib/libc/musl/src/math/s390x/roundl.c
deleted file mode 100644
index ce644ddd7953eaa5975bfdb06d875375e4f7f226..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/s390x/roundl.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <math.h>
-
-#if defined(__HTM__) || __ARCH__ >= 9
-
-long double roundl(long double x)
-{
-	__asm__ ("fixbra %0, 1, %1, 4" : "=f"(x) : "f"(x));
-	return x;
-}
-
-#else
-
-#include "../roundl.c"
-
-#endif
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index 8f20b8cd0baf737631f88e813b216feab99436a9..568dd945512c23023823b9eced149bc2004832f0 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -936,7 +936,6 @@ const mingw32_x86_src = [_][]const u8{
     "math" ++ path.sep_str ++ "lrintl.c",
     "math" ++ path.sep_str ++ "lroundl.c",
     "math" ++ path.sep_str ++ "rintl.c",
-    "math" ++ path.sep_str ++ "roundl.c",
     "math" ++ path.sep_str ++ "tgammal.c",
     "math" ++ path.sep_str ++ "x86" ++ path.sep_str ++ "_chgsignl.S",
     "math" ++ path.sep_str ++ "x86" ++ path.sep_str ++ "acoshl.c",
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 28602cd6f6ec14f15f586c01bf857234bf1ce8b7..c6bdac314c2c4f9dbf114e9c031d2a867b43ee15 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -1023,7 +1023,6 @@ const src_files = [_][]const u8{
     "musl/src/math/riscv64/fmaf.c",
     "musl/src/math/round.c",
     "musl/src/math/roundf.c",
-    "musl/src/math/roundl.c",
     "musl/src/math/s390x/fma.c",
     "musl/src/math/s390x/fmaf.c",
     "musl/src/math/s390x/nearbyint.c",
@@ -1034,7 +1033,6 @@ const src_files = [_][]const u8{
     "musl/src/math/s390x/rintl.c",
     "musl/src/math/s390x/round.c",
     "musl/src/math/s390x/roundf.c",
-    "musl/src/math/s390x/roundl.c",
     "musl/src/math/scalb.c",
     "musl/src/math/scalbf.c",
     "musl/src/math/scalbln.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index b1a1159778257d4b16297f1ce87f5431635dad23..19b820eef9bd305b4a0b45bf9a54b5e12d6acaa3 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -810,7 +810,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/rintl.c",
     "musl/src/math/round.c",
     "musl/src/math/roundf.c",
-    "musl/src/math/roundl.c",
     "musl/src/math/scalb.c",
     "musl/src/math/scalbf.c",
     "musl/src/math/scalbln.c",
diff --git a/test/libc.zig b/test/libc.zig
index e1d866eb3d22293999b1307e55904147242167b4..ee7343493051d79533d75df6e314843e1bce2ab3 100644
--- a/test/libc.zig
+++ b/test/libc.zig
@@ -298,7 +298,7 @@ pub fn addCases(cases: *tests.LibcContext) void {
     // cases.addLibcTestCase("math/rintl.c", true, .{});
     // cases.addLibcTestCase("math/round.c", true, .{});
     // cases.addLibcTestCase("math/roundf.c", true, .{});
-    // cases.addLibcTestCase("math/roundl.c", true, .{});
+    cases.addLibcTestCase("math/roundl.c", true, .{});
     cases.addLibcTestCase("math/scalb.c", true, .{});
     cases.addLibcTestCase("math/scalbf.c", true, .{});
     cases.addLibcTestCase("math/scalbln.c", true, .{});
-- 
2.54.0


From 69a95571ed6e0f2c4562b70dc222f427b3366858 Mon Sep 17 00:00:00 2001
From: Jeff Anderson <kj4tmp@gmail.com>
Date: Sat, 31 Jan 2026 17:15:00 -0800
Subject: [PATCH 158/499] libzigc: round

---
 lib/libc/musl/src/math/aarch64/round.c   |  7 -----
 lib/libc/musl/src/math/powerpc64/round.c | 15 ----------
 lib/libc/musl/src/math/round.c           | 35 ------------------------
 lib/libc/musl/src/math/s390x/round.c     | 15 ----------
 src/libs/musl.zig                        |  4 ---
 src/libs/wasi_libc.zig                   |  1 -
 test/libc.zig                            |  2 +-
 7 files changed, 1 insertion(+), 78 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/aarch64/round.c
 delete mode 100644 lib/libc/musl/src/math/powerpc64/round.c
 delete mode 100644 lib/libc/musl/src/math/round.c
 delete mode 100644 lib/libc/musl/src/math/s390x/round.c

diff --git a/lib/libc/musl/src/math/aarch64/round.c b/lib/libc/musl/src/math/aarch64/round.c
deleted file mode 100644
index 897a84cc2a043b2e8fdaef03fc2bbd665bde5366..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/aarch64/round.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <math.h>
-
-double round(double x)
-{
-	__asm__ ("frinta %d0, %d1" : "=w"(x) : "w"(x));
-	return x;
-}
diff --git a/lib/libc/musl/src/math/powerpc64/round.c b/lib/libc/musl/src/math/powerpc64/round.c
deleted file mode 100644
index 4b9318e09fa70fe0c8193c10bfbd1f761fd15654..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/powerpc64/round.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <math.h>
-
-#ifdef _ARCH_PWR5X
-
-double round(double x)
-{
-	__asm__ ("frin %0, %1" : "=d"(x) : "d"(x));
-	return x;
-}
-
-#else
-
-#include "../round.c"
-
-#endif
diff --git a/lib/libc/musl/src/math/round.c b/lib/libc/musl/src/math/round.c
deleted file mode 100644
index 130d58d2571e77cc15a67b355010e11c5ebebe91..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/round.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "libm.h"
-
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
-#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
-#define EPS LDBL_EPSILON
-#endif
-static const double_t toint = 1/EPS;
-
-double round(double x)
-{
-	union {double f; uint64_t i;} u = {x};
-	int e = u.i >> 52 & 0x7ff;
-	double_t y;
-
-	if (e >= 0x3ff+52)
-		return x;
-	if (u.i >> 63)
-		x = -x;
-	if (e < 0x3ff-1) {
-		/* raise inexact if x!=0 */
-		FORCE_EVAL(x + toint);
-		return 0*u.f;
-	}
-	y = x + toint - toint - x;
-	if (y > 0.5)
-		y = y + x - 1;
-	else if (y <= -0.5)
-		y = y + x + 1;
-	else
-		y = y + x;
-	if (u.i >> 63)
-		y = -y;
-	return y;
-}
diff --git a/lib/libc/musl/src/math/s390x/round.c b/lib/libc/musl/src/math/s390x/round.c
deleted file mode 100644
index 71f80251184bf1430f3a134dfd081568346af31e..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/s390x/round.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <math.h>
-
-#if defined(__HTM__) || __ARCH__ >= 9
-
-double round(double x)
-{
-	__asm__ ("fidbra %0, 1, %1, 4" : "=f"(x) : "f"(x));
-	return x;
-}
-
-#else
-
-#include "../round.c"
-
-#endif
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index c6bdac314c2c4f9dbf114e9c031d2a867b43ee15..97f1d4e2f0de422ea79ff53cb9627b38ee364576 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -818,7 +818,6 @@ const src_files = [_][]const u8{
     "musl/src/math/aarch64/nearbyintf.c",
     "musl/src/math/aarch64/rint.c",
     "musl/src/math/aarch64/rintf.c",
-    "musl/src/math/aarch64/round.c",
     "musl/src/math/aarch64/roundf.c",
     "musl/src/math/acosf.c",
     "musl/src/math/acosh.c",
@@ -997,7 +996,6 @@ const src_files = [_][]const u8{
     "musl/src/math/powerpc64/lrintf.c",
     "musl/src/math/powerpc64/lround.c",
     "musl/src/math/powerpc64/lroundf.c",
-    "musl/src/math/powerpc64/round.c",
     "musl/src/math/powerpc64/roundf.c",
     "musl/src/math/powerpc/fma.c",
     "musl/src/math/powerpc/fmaf.c",
@@ -1021,7 +1019,6 @@ const src_files = [_][]const u8{
     "musl/src/math/riscv32/fmaf.c",
     "musl/src/math/riscv64/fma.c",
     "musl/src/math/riscv64/fmaf.c",
-    "musl/src/math/round.c",
     "musl/src/math/roundf.c",
     "musl/src/math/s390x/fma.c",
     "musl/src/math/s390x/fmaf.c",
@@ -1031,7 +1028,6 @@ const src_files = [_][]const u8{
     "musl/src/math/s390x/rint.c",
     "musl/src/math/s390x/rintf.c",
     "musl/src/math/s390x/rintl.c",
-    "musl/src/math/s390x/round.c",
     "musl/src/math/s390x/roundf.c",
     "musl/src/math/scalb.c",
     "musl/src/math/scalbf.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 19b820eef9bd305b4a0b45bf9a54b5e12d6acaa3..743812e93c05efe1c4e33b18e13ad2b5ad2325e7 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -808,7 +808,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/remquof.c",
     "musl/src/math/remquol.c",
     "musl/src/math/rintl.c",
-    "musl/src/math/round.c",
     "musl/src/math/roundf.c",
     "musl/src/math/scalb.c",
     "musl/src/math/scalbf.c",
diff --git a/test/libc.zig b/test/libc.zig
index ee7343493051d79533d75df6e314843e1bce2ab3..cf61d1ba4d06dcccc34b752c432e2ae310bdd960 100644
--- a/test/libc.zig
+++ b/test/libc.zig
@@ -296,7 +296,7 @@ pub fn addCases(cases: *tests.LibcContext) void {
     // cases.addLibcTestCase("math/rint.c", true, .{});
     cases.addLibcTestCase("math/rintf.c", true, .{});
     // cases.addLibcTestCase("math/rintl.c", true, .{});
-    // cases.addLibcTestCase("math/round.c", true, .{});
+    cases.addLibcTestCase("math/round.c", true, .{});
     // cases.addLibcTestCase("math/roundf.c", true, .{});
     cases.addLibcTestCase("math/roundl.c", true, .{});
     cases.addLibcTestCase("math/scalb.c", true, .{});
-- 
2.54.0


From 3abc96a601d2349cc1743774f0cebb2eb0ea0c61 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 31 Jan 2026 14:58:02 -0800
Subject: [PATCH 159/499] std.Io: add test for batchAwaitAsync

and make it always work for all targets including WASI

This function guarantees no additional failure modes introduced.
---
 lib/std/Io.zig          |  14 ++-
 lib/std/Io/Threaded.zig | 188 +++++++++++++++++++++-------------------
 lib/std/Io/test.zig     |  60 +++++++++++++
 3 files changed, 170 insertions(+), 92 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index c3ba3575e477ddce5c2cf5fb9ed7bbe5b6a02acb..16d056ed0f18ec12cb0843d6d0c5d34e7ad70400 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -369,7 +369,9 @@ pub const Batch = struct {
     context: ?*anyopaque,
 
     /// After calling this, it is safe to unconditionally defer a call to
-    /// `cancel`.
+    /// `cancel`. `storage` is a pre-allocated buffer of undefined memory that
+    /// determines the maximum number of active operations that can be
+    /// submitted via `add` and `addAt`.
     pub fn init(storage: []Operation.Storage) Batch {
         var prev: Operation.OptionalIndex = .none;
         for (storage, 0..) |*operation, index| {
@@ -422,12 +424,20 @@ pub const Batch = struct {
         b.submissions.tail = .fromIndex(index);
     }
 
+    pub const Completion = struct {
+        /// The element within the provided operation storage that completed.
+        /// `addAt` can be used to re-arm the `Batch` using this `index`.
+        index: u32,
+        /// The return value of the operation.
+        result: Operation.Result,
+    };
+
     /// After calling `awaitAsync`, `awaitConcurrent`, or `cancel`, this
     /// function iterates over the completed operations.
     ///
     /// Each completion returned from this function dequeues from the `Batch`.
     /// It is not required to dequeue all completions before awaiting again.
-    pub fn next(b: *Batch) ?struct { index: u32, result: Operation.Result } {
+    pub fn next(b: *Batch) ?Completion {
         const index = b.completions.head;
         if (index == .none) return null;
         const storage = &b.storage[index.toIndex()];
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index e9b62ca5f5c325a70f06f27cb3d6d79f35125bff..12521ea1af03a29dfb73672de61e52b69723ec26 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1938,6 +1938,10 @@ const have_mmap = switch (native_os) {
     .wasi, .windows => false,
     else => true,
 };
+const have_poll = switch (native_os) {
+    .wasi, .windows => false,
+    else => true,
+};
 
 const open_sym = if (posix.lfs64_abi) posix.system.open64 else posix.system.open;
 const openat_sym = if (posix.lfs64_abi) posix.system.openat64 else posix.system.openat;
@@ -2507,104 +2511,104 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
         alertable_syscall.finish();
         return;
     }
-    if (native_os == .wasi and !builtin.link_libc) @panic("TODO");
-    var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
-    var poll_len: u32 = 0;
-    {
-        var index = b.submissions.head;
-        while (index != .none and poll_len < poll_buffer_len) {
-            const submission = &b.storage[index.toIndex()].submission;
-            switch (submission.operation) {
-                .file_read_streaming => |o| {
-                    poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.IN, .revents = 0 };
-                    poll_len += 1;
-                },
+    if (have_poll) {
+        var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
+        var poll_len: u32 = 0;
+        {
+            var index = b.submissions.head;
+            while (index != .none and poll_len < poll_buffer_len) {
+                const submission = &b.storage[index.toIndex()].submission;
+                switch (submission.operation) {
+                    .file_read_streaming => |o| {
+                        poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.IN, .revents = 0 };
+                        poll_len += 1;
+                    },
+                }
+                index = submission.node.next;
             }
-            index = submission.node.next;
         }
-    }
-    switch (poll_len) {
-        0 => return,
-        1 => {},
-        else => while (true) {
-            const timeout_ms: i32 = t: {
-                if (b.completions.head != .none) {
-                    // It is legal to call batchWait with already completed
-                    // operations in the ring. In such case, we need to avoid
-                    // blocking in the poll syscall, but we can still take this
-                    // opportunity to find additional ready operations.
-                    break :t 0;
-                }
-                const max_poll_ms = std.math.maxInt(i32);
-                break :t max_poll_ms;
-            };
-            const syscall = try Syscall.start();
-            const rc = posix.system.poll(&poll_buffer, poll_len, timeout_ms);
-            syscall.finish();
-            switch (posix.errno(rc)) {
-                .SUCCESS => {
-                    if (rc == 0) {
-                        if (b.completions.head != .none) {
-                            // Since there are already completions available in the
-                            // queue, this is neither a timeout nor a case for
-                            // retrying.
-                            return;
-                        }
-                        continue;
+        switch (poll_len) {
+            0 => return,
+            1 => {},
+            else => while (true) {
+                const timeout_ms: i32 = t: {
+                    if (b.completions.head != .none) {
+                        // It is legal to call batchWait with already completed
+                        // operations in the ring. In such case, we need to avoid
+                        // blocking in the poll syscall, but we can still take this
+                        // opportunity to find additional ready operations.
+                        break :t 0;
                     }
-                    var prev_index: Io.Operation.OptionalIndex = .none;
-                    var index = b.submissions.head;
-                    for (poll_buffer[0..poll_len]) |poll_entry| {
-                        const storage = &b.storage[index.toIndex()];
-                        const submission = &storage.submission;
-                        const next_index = submission.node.next;
-                        if (poll_entry.revents != 0) {
-                            const result = try operate(t, submission.operation);
-
-                            switch (prev_index) {
-                                .none => b.submissions.head = next_index,
-                                else => b.storage[prev_index.toIndex()].submission.node.next = next_index,
+                    const max_poll_ms = std.math.maxInt(i32);
+                    break :t max_poll_ms;
+                };
+                const syscall = try Syscall.start();
+                const rc = posix.system.poll(&poll_buffer, poll_len, timeout_ms);
+                syscall.finish();
+                switch (posix.errno(rc)) {
+                    .SUCCESS => {
+                        if (rc == 0) {
+                            if (b.completions.head != .none) {
+                                // Since there are already completions available in the
+                                // queue, this is neither a timeout nor a case for
+                                // retrying.
+                                return;
                             }
-                            if (next_index == .none) b.submissions.tail = prev_index;
+                            continue;
+                        }
+                        var prev_index: Io.Operation.OptionalIndex = .none;
+                        var index = b.submissions.head;
+                        for (poll_buffer[0..poll_len]) |poll_entry| {
+                            const storage = &b.storage[index.toIndex()];
+                            const submission = &storage.submission;
+                            const next_index = submission.node.next;
+                            if (poll_entry.revents != 0) {
+                                const result = try operate(t, submission.operation);
 
-                            switch (b.completions.tail) {
-                                .none => b.completions.head = index,
-                                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
-                            }
-                            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
-                            b.completions.tail = index;
-                        } else prev_index = index;
-                        index = next_index;
-                    }
-                    assert(index == .none);
-                    return;
-                },
-                .INTR => continue,
-                else => break,
-            }
-        },
+                                switch (prev_index) {
+                                    .none => b.submissions.head = next_index,
+                                    else => b.storage[prev_index.toIndex()].submission.node.next = next_index,
+                                }
+                                if (next_index == .none) b.submissions.tail = prev_index;
+
+                                switch (b.completions.tail) {
+                                    .none => b.completions.head = index,
+                                    else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
+                                }
+                                storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+                                b.completions.tail = index;
+                            } else prev_index = index;
+                            index = next_index;
+                        }
+                        assert(index == .none);
+                        return;
+                    },
+                    .INTR => continue,
+                    else => break,
+                }
+            },
+        }
     }
-    {
-        var tail_index = b.completions.tail;
-        defer b.completions.tail = tail_index;
-        var index = b.submissions.head;
-        errdefer b.submissions.head = index;
-        while (index != .none) {
-            const storage = &b.storage[index.toIndex()];
-            const submission = &storage.submission;
-            const next_index = submission.node.next;
-            const result = try operate(t, submission.operation);
 
-            switch (tail_index) {
-                .none => b.completions.head = index,
-                else => b.storage[tail_index.toIndex()].completion.node.next = index,
-            }
-            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
-            tail_index = index;
-            index = next_index;
+    var tail_index = b.completions.tail;
+    defer b.completions.tail = tail_index;
+    var index = b.submissions.head;
+    errdefer b.submissions.head = index;
+    while (index != .none) {
+        const storage = &b.storage[index.toIndex()];
+        const submission = &storage.submission;
+        const next_index = submission.node.next;
+        const result = try operate(t, submission.operation);
+
+        switch (tail_index) {
+            .none => b.completions.head = index,
+            else => b.storage[tail_index.toIndex()].completion.node.next = index,
         }
-        b.submissions = .{ .head = .none, .tail = .none };
+        storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+        tail_index = index;
+        index = next_index;
     }
+    b.submissions = .{ .head = .none, .tail = .none };
 }
 
 fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
@@ -2644,7 +2648,11 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         }
         return;
     }
-    if (native_os == .wasi and !builtin.link_libc) @panic("TODO");
+    if (native_os == .wasi) {
+        // TODO call poll_oneoff
+        return error.ConcurrencyUnavailable;
+    }
+    if (!have_poll) return error.ConcurrencyUnavailable;
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     var poll_storage: struct {
         gpa: std.mem.Allocator,
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index b022b10e6e64c91d358aaba4dfff6bf70c986837..930a176b015c9ee966bab3e643b37f14d5648f4f 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -656,3 +656,63 @@ test "memory mapping" {
         try expectEqualStrings("this9is9my data123\x00\x00", mm.memory[0.."this9is9my data123\x00\x00".len]);
     }
 }
+
+test "read from a file using Batch.awaitAsync API" {
+    const io = testing.io;
+
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
+
+    try tmp.dir.writeFile(io, .{
+        .sub_path = "eyes.txt",
+        .data = "Heaven's been cheating the Hell out of me",
+    });
+    try tmp.dir.writeFile(io, .{
+        .sub_path = "saviour.txt",
+        .data = "Burn your thoughts, erase your will / to gods of suffering and tears",
+    });
+
+    var eyes_file = try tmp.dir.openFile(io, "eyes.txt", .{});
+    defer eyes_file.close(io);
+
+    var saviour_file = try tmp.dir.openFile(io, "saviour.txt", .{});
+    defer saviour_file.close(io);
+
+    var eyes_buf: [100]u8 = undefined;
+    var saviour_buf: [100]u8 = undefined;
+    var storage: [2]Io.Operation.Storage = undefined;
+    var batch: Io.Batch = .init(&storage);
+
+    batch.addAt(0, .{ .file_read_streaming = .{
+        .file = eyes_file,
+        .data = &.{&eyes_buf},
+    } });
+    batch.addAt(1, .{ .file_read_streaming = .{
+        .file = saviour_file,
+        .data = &.{&saviour_buf},
+    } });
+
+    // This API is supposed to *always* work even if the target has no
+    // concurrency primitives available.
+    try batch.awaitAsync(io);
+
+    while (batch.next()) |completion| {
+        switch (completion.index) {
+            0 => {
+                const n = try completion.result.file_read_streaming;
+                try expectEqualStrings(
+                    "Heaven's been cheating the Hell out of me"[0..n],
+                    eyes_buf[0..n],
+                );
+            },
+            1 => {
+                const n = try completion.result.file_read_streaming;
+                try expectEqualStrings(
+                    "Burn your thoughts, erase your will / to gods of suffering and tears"[0..n],
+                    saviour_buf[0..n],
+                );
+            },
+            else => return error.TestFailure,
+        }
+    }
+}
-- 
2.54.0


From 379d128cba904a7599ebb191afa0873ef1a633cc Mon Sep 17 00:00:00 2001
From: Jeff Anderson <kj4tmp@gmail.com>
Date: Sat, 31 Jan 2026 17:18:42 -0800
Subject: [PATCH 160/499] libzigc: roundf

---
 lib/libc/musl/src/math/aarch64/roundf.c   |  7 -----
 lib/libc/musl/src/math/powerpc64/roundf.c | 15 ----------
 lib/libc/musl/src/math/roundf.c           | 36 -----------------------
 lib/libc/musl/src/math/s390x/roundf.c     | 15 ----------
 src/libs/musl.zig                         |  4 ---
 src/libs/wasi_libc.zig                    |  1 -
 test/libc.zig                             |  2 +-
 7 files changed, 1 insertion(+), 79 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/aarch64/roundf.c
 delete mode 100644 lib/libc/musl/src/math/powerpc64/roundf.c
 delete mode 100644 lib/libc/musl/src/math/roundf.c
 delete mode 100644 lib/libc/musl/src/math/s390x/roundf.c

diff --git a/lib/libc/musl/src/math/aarch64/roundf.c b/lib/libc/musl/src/math/aarch64/roundf.c
deleted file mode 100644
index 91637eaa1204ad92c451722b87c972231ecf55af..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/aarch64/roundf.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <math.h>
-
-float roundf(float x)
-{
-	__asm__ ("frinta %s0, %s1" : "=w"(x) : "w"(x));
-	return x;
-}
diff --git a/lib/libc/musl/src/math/powerpc64/roundf.c b/lib/libc/musl/src/math/powerpc64/roundf.c
deleted file mode 100644
index ae93f999abb868de89898337d849ffb928436e47..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/powerpc64/roundf.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <math.h>
-
-#ifdef _ARCH_PWR5X
-
-float roundf(float x)
-{
-	__asm__ ("frin %0, %1" : "=f"(x) : "f"(x));
-	return x;
-}
-
-#else
-
-#include "../roundf.c"
-
-#endif
diff --git a/lib/libc/musl/src/math/roundf.c b/lib/libc/musl/src/math/roundf.c
deleted file mode 100644
index e8210af5621aa392543616d308200ddb22523281..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/roundf.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "libm.h"
-
-#if FLT_EVAL_METHOD==0
-#define EPS FLT_EPSILON
-#elif FLT_EVAL_METHOD==1
-#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
-#define EPS LDBL_EPSILON
-#endif
-static const float_t toint = 1/EPS;
-
-float roundf(float x)
-{
-	union {float f; uint32_t i;} u = {x};
-	int e = u.i >> 23 & 0xff;
-	float_t y;
-
-	if (e >= 0x7f+23)
-		return x;
-	if (u.i >> 31)
-		x = -x;
-	if (e < 0x7f-1) {
-		FORCE_EVAL(x + toint);
-		return 0*u.f;
-	}
-	y = x + toint - toint - x;
-	if (y > 0.5f)
-		y = y + x - 1;
-	else if (y <= -0.5f)
-		y = y + x + 1;
-	else
-		y = y + x;
-	if (u.i >> 31)
-		y = -y;
-	return y;
-}
diff --git a/lib/libc/musl/src/math/s390x/roundf.c b/lib/libc/musl/src/math/s390x/roundf.c
deleted file mode 100644
index 46d2e10c8766787e91838fec4d0d7c5176eb0131..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/s390x/roundf.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <math.h>
-
-#if defined(__HTM__) || __ARCH__ >= 9
-
-float roundf(float x)
-{
-	__asm__ ("fiebra %0, 1, %1, 4" : "=f"(x) : "f"(x));
-	return x;
-}
-
-#else
-
-#include "../roundf.c"
-
-#endif
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 97f1d4e2f0de422ea79ff53cb9627b38ee364576..b8f7068e5c77b9678e4a14f748b66c255a2aaffd 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -818,7 +818,6 @@ const src_files = [_][]const u8{
     "musl/src/math/aarch64/nearbyintf.c",
     "musl/src/math/aarch64/rint.c",
     "musl/src/math/aarch64/rintf.c",
-    "musl/src/math/aarch64/roundf.c",
     "musl/src/math/acosf.c",
     "musl/src/math/acosh.c",
     "musl/src/math/acoshf.c",
@@ -996,7 +995,6 @@ const src_files = [_][]const u8{
     "musl/src/math/powerpc64/lrintf.c",
     "musl/src/math/powerpc64/lround.c",
     "musl/src/math/powerpc64/lroundf.c",
-    "musl/src/math/powerpc64/roundf.c",
     "musl/src/math/powerpc/fma.c",
     "musl/src/math/powerpc/fmaf.c",
     "musl/src/math/powf.c",
@@ -1019,7 +1017,6 @@ const src_files = [_][]const u8{
     "musl/src/math/riscv32/fmaf.c",
     "musl/src/math/riscv64/fma.c",
     "musl/src/math/riscv64/fmaf.c",
-    "musl/src/math/roundf.c",
     "musl/src/math/s390x/fma.c",
     "musl/src/math/s390x/fmaf.c",
     "musl/src/math/s390x/nearbyint.c",
@@ -1028,7 +1025,6 @@ const src_files = [_][]const u8{
     "musl/src/math/s390x/rint.c",
     "musl/src/math/s390x/rintf.c",
     "musl/src/math/s390x/rintl.c",
-    "musl/src/math/s390x/roundf.c",
     "musl/src/math/scalb.c",
     "musl/src/math/scalbf.c",
     "musl/src/math/scalbln.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 743812e93c05efe1c4e33b18e13ad2b5ad2325e7..239f8b477704b3ac2f6d891214aae6a7056916a1 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -808,7 +808,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/remquof.c",
     "musl/src/math/remquol.c",
     "musl/src/math/rintl.c",
-    "musl/src/math/roundf.c",
     "musl/src/math/scalb.c",
     "musl/src/math/scalbf.c",
     "musl/src/math/scalbln.c",
diff --git a/test/libc.zig b/test/libc.zig
index cf61d1ba4d06dcccc34b752c432e2ae310bdd960..57581ca32e9e51710a300588a12d61a3a44caba2 100644
--- a/test/libc.zig
+++ b/test/libc.zig
@@ -297,7 +297,7 @@ pub fn addCases(cases: *tests.LibcContext) void {
     cases.addLibcTestCase("math/rintf.c", true, .{});
     // cases.addLibcTestCase("math/rintl.c", true, .{});
     cases.addLibcTestCase("math/round.c", true, .{});
-    // cases.addLibcTestCase("math/roundf.c", true, .{});
+    cases.addLibcTestCase("math/roundf.c", true, .{});
     cases.addLibcTestCase("math/roundl.c", true, .{});
     cases.addLibcTestCase("math/scalb.c", true, .{});
     cases.addLibcTestCase("math/scalbf.c", true, .{});
-- 
2.54.0


From 9bd648bd4099d4ba14785bea4d7e0aa9e81fb105 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 20:54:06 -0800
Subject: [PATCH 161/499] std.Io.Operation: support non-fallible results

---
 lib/std/Io.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 16d056ed0f18ec12cb0843d6d0c5d34e7ad70400..74ddd1dccf72863945c4d0025d1b19e9522a49f1 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -287,7 +287,7 @@ pub const Operation = union(enum) {
             LockViolation,
         } || Io.UnexpectedError;
 
-        pub const Result = usize;
+        pub const Result = Error!usize;
     };
 
     pub const Result = Result: {
@@ -296,7 +296,7 @@ pub const Operation = union(enum) {
         var field_types: [operation_fields.len]type = undefined;
         for (operation_fields, &field_names, &field_types) |field, *field_name, *field_type| {
             field_name.* = field.name;
-            field_type.* = field.type.Error!field.type.Result;
+            field_type.* = field.type.Result;
         }
         break :Result @Union(.auto, Tag, &field_names, &field_types, &@splat(.{}));
     };
-- 
2.54.0


From cc442d24ab172a6a2e5ee5210eca3e2f822629f8 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jan 2026 22:00:45 -0800
Subject: [PATCH 162/499] std.Io: move fileWriteStreaming to Operation

This serves as an example to contributors of how to move VTable
functions to becoming an Operation, thereby enabling Batch API and
timeouts.
---
 lib/std/Io.zig             |  36 ++++++-
 lib/std/Io/File.zig        |  21 +++-
 lib/std/Io/File/Writer.zig |  27 +----
 lib/std/Io/Threaded.zig    | 200 ++++++++++++++++++++++++++++++-------
 lib/std/Progress.zig       |   4 +-
 5 files changed, 217 insertions(+), 71 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 74ddd1dccf72863945c4d0025d1b19e9522a49f1..a892c0123c7179d1f203ba231e087ec7bd92a105 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -184,7 +184,6 @@ pub const VTable = struct {
     fileStat: *const fn (?*anyopaque, File) File.StatError!File.Stat,
     fileLength: *const fn (?*anyopaque, File) File.LengthError!u64,
     fileClose: *const fn (?*anyopaque, []const File) void,
-    fileWriteStreaming: *const fn (?*anyopaque, File, header: []const u8, data: []const []const u8, splat: usize) File.Writer.Error!usize,
     fileWritePositional: *const fn (?*anyopaque, File, header: []const u8, data: []const []const u8, splat: usize, offset: u64) File.WritePositionalError!usize,
     fileWriteFileStreaming: *const fn (?*anyopaque, File, header: []const u8, *Io.File.Reader, Io.Limit) File.Writer.WriteFileError!usize,
     fileWriteFilePositional: *const fn (?*anyopaque, File, header: []const u8, *Io.File.Reader, Io.Limit, offset: u64) File.WriteFilePositionalError!usize,
@@ -257,6 +256,7 @@ pub const VTable = struct {
 
 pub const Operation = union(enum) {
     file_read_streaming: FileReadStreaming,
+    file_write_streaming: FileWriteStreaming,
 
     pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
@@ -290,6 +290,40 @@ pub const Operation = union(enum) {
         pub const Result = Error!usize;
     };
 
+    pub const FileWriteStreaming = struct {
+        file: File,
+        header: []const u8 = &.{},
+        data: []const []const u8,
+        splat: usize = 1,
+
+        pub const Error = error{
+            DiskQuota,
+            FileTooBig,
+            InputOutput,
+            NoSpaceLeft,
+            DeviceBusy,
+            /// File descriptor does not hold the required rights to write to it.
+            AccessDenied,
+            PermissionDenied,
+            /// File is an unconnected socket, or closed its read end.
+            BrokenPipe,
+            /// Insufficient kernel memory to read from in_fd.
+            SystemResources,
+            NotOpenForWriting,
+            /// The process cannot access the file because another process has locked
+            /// a portion of the file. Windows-only.
+            LockViolation,
+            /// Non-blocking has been enabled and this operation would block.
+            WouldBlock,
+            /// This error occurs when a device gets disconnected before or mid-flush
+            /// while it's being written to - errno(6): No such device or address.
+            NoDevice,
+            FileBusy,
+        } || Io.UnexpectedError;
+
+        pub const Result = Error!usize;
+    };
+
     pub const Result = Result: {
         const operation_fields = @typeInfo(Operation).@"union".fields;
         var field_names: [operation_fields.len][]const u8 = undefined;
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index e0297e0573c06dc35cbc169bd822832b4cf80648..ba7f5d01e051c25436bbbe11f06951aae89b314c 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -572,16 +572,16 @@ pub fn setTimestampsNow(file: File, io: Io) SetTimestampsError!void {
 
 pub const ReadStreamingError = error{EndOfStream} || Reader.Error;
 
-/// Returns 0 on stream end or if `buffer` has no space available for data.
+/// May return fewer bytes than buffer space available, including 0.
+/// End-of-stream is indicated by `error.EndOfStream`.
 ///
 /// See also:
 /// * `reader`
 pub fn readStreaming(file: File, io: Io, buffer: []const []u8) ReadStreamingError!usize {
-    const result = try io.operate(.{ .file_read_streaming = .{
+    return (try io.operate(.{ .file_read_streaming = .{
         .file = file,
         .data = buffer,
-    } });
-    return result.file_read_streaming;
+    } })).file_read_streaming;
 }
 
 pub const ReadPositionalError = error{
@@ -714,11 +714,22 @@ pub fn writerStreaming(file: File, io: Io, buffer: []u8) Writer {
     return .initStreaming(file, io, buffer);
 }
 
+/// This is a low-level API that calls the `Io` interface function directly.
+/// For a higher level API, see `writerStreaming`.
+pub fn writeStreaming(file: File, io: Io, header: []const u8, data: []const []const u8, splat: usize) Writer.Error!usize {
+    return (try io.operate(.{ .file_write_streaming = .{
+        .file = file,
+        .header = header,
+        .data = data,
+        .splat = splat,
+    } })).file_write_streaming;
+}
+
 /// Equivalent to creating a streaming writer, writing `bytes`, and then flushing.
 pub fn writeStreamingAll(file: File, io: Io, bytes: []const u8) Writer.Error!void {
     var index: usize = 0;
     while (index < bytes.len) {
-        index += try io.vtable.fileWriteStreaming(io.userdata, file, &.{}, &.{bytes[index..]}, 1);
+        index += try writeStreaming(file, io, &.{}, &.{bytes[index..]}, 1);
     }
 }
 
diff --git a/lib/std/Io/File/Writer.zig b/lib/std/Io/File/Writer.zig
index 68a68e28ec706bf9b1863fd3b329c78f4255ad9a..83f99d2ffcd062336b300817572e01d657d4c15e 100644
--- a/lib/std/Io/File/Writer.zig
+++ b/lib/std/Io/File/Writer.zig
@@ -20,30 +20,7 @@ interface: Io.Writer,
 
 pub const Mode = File.Reader.Mode;
 
-pub const Error = error{
-    DiskQuota,
-    FileTooBig,
-    InputOutput,
-    NoSpaceLeft,
-    DeviceBusy,
-    /// File descriptor does not hold the required rights to write to it.
-    AccessDenied,
-    PermissionDenied,
-    /// File is an unconnected socket, or closed its read end.
-    BrokenPipe,
-    /// Insufficient kernel memory to read from in_fd.
-    SystemResources,
-    NotOpenForWriting,
-    /// The process cannot access the file because another process has locked
-    /// a portion of the file. Windows-only.
-    LockViolation,
-    /// Non-blocking has been enabled and this operation would block.
-    WouldBlock,
-    /// This error occurs when a device gets disconnected before or mid-flush
-    /// while it's being written to - errno(6): No such device or address.
-    NoDevice,
-    FileBusy,
-} || Io.Cancelable || Io.UnexpectedError;
+pub const Error = Io.Operation.FileWriteStreaming.Error || Io.Cancelable;
 
 pub const WriteFileError = Error || error{
     /// Descriptor is not valid or locked, or an mmap(2)-like operation is not available for in_fd.
@@ -146,7 +123,7 @@ fn drainPositional(w: *Writer, data: []const []const u8, splat: usize) Io.Writer
 fn drainStreaming(w: *Writer, data: []const []const u8, splat: usize) Io.Writer.Error!usize {
     const io = w.io;
     const header = w.interface.buffered();
-    const n = io.vtable.fileWriteStreaming(io.userdata, w.file, header, data, splat) catch |err| {
+    const n = w.file.writeStreaming(io, header, data, splat) catch |err| {
         w.err = err;
         return error.WriteFailed;
     };
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 12521ea1af03a29dfb73672de61e52b69723ec26..8de5e2692a89a3da983db7a76f9033a3822d084b 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1649,7 +1649,6 @@ pub fn io(t: *Threaded) Io {
             .fileStat = fileStat,
             .fileLength = fileLength,
             .fileClose = fileClose,
-            .fileWriteStreaming = fileWriteStreaming,
             .fileWritePositional = fileWritePositional,
             .fileWriteFileStreaming = fileWriteFileStreaming,
             .fileWriteFilePositional = fileWriteFilePositional,
@@ -1813,7 +1812,6 @@ pub fn ioBasic(t: *Threaded) Io {
             .fileStat = fileStat,
             .fileLength = fileLength,
             .fileClose = fileClose,
-            .fileWriteStreaming = fileWriteStreaming,
             .fileWritePositional = fileWritePositional,
             .fileWriteFileStreaming = fileWriteFileStreaming,
             .fileWriteFilePositional = fileWriteFilePositional,
@@ -2496,6 +2494,12 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
                 else => |e| e,
             },
         },
+        .file_write_streaming => |o| return .{
+            .file_write_streaming = fileWriteStreaming(t, o.file, o.header, o.data, o.splat) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                else => |e| e,
+            },
+        },
     }
 }
 
@@ -2523,6 +2527,10 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                         poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.IN, .revents = 0 };
                         poll_len += 1;
                     },
+                    .file_write_streaming => |o| {
+                        poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.OUT, .revents = 0 };
+                        poll_len += 1;
+                    },
                 }
                 index = submission.node.next;
             }
@@ -2687,6 +2695,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
             const submission = &b.storage[index.toIndex()].submission;
             switch (submission.operation) {
                 .file_read_streaming => |o| try poll_storage.add(o.file, posix.POLL.IN),
+                .file_write_streaming => |o| try poll_storage.add(o.file, posix.POLL.OUT),
             }
             index = submission.node.next;
         }
@@ -2864,6 +2873,7 @@ fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows
             b.completions.tail = .fromIndex(index);
             const result: Io.Operation.Result = switch (pending.tag) {
                 .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
+                .file_write_streaming => .{ .file_write_streaming = ntWriteFileResult(iosb) },
             };
             storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
         },
@@ -2950,6 +2960,66 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
                         else => |status| {
                             syscall.finish();
 
+                            context.iosb.u.Status = status;
+                            batchApc(b, &context.iosb, 0);
+                            break;
+                        },
+                    };
+                }
+            },
+            .file_write_streaming => |o| o: {
+                const buffer = windowsWriteBuffer(o.header, o.data, o.splat);
+                if (buffer.len == 0) {
+                    context.iosb = .{
+                        .u = .{ .Status = .SUCCESS },
+                        .Information = 0,
+                    };
+                    batchApc(b, &context.iosb, 0);
+                    break :o;
+                }
+                if (o.file.flags.nonblocking) {
+                    context.file = o.file.handle;
+                    switch (windows.ntdll.NtWriteFile(
+                        o.file.handle,
+                        null, // event
+                        &batchApc,
+                        b,
+                        &context.iosb,
+                        buffer.ptr,
+                        @intCast(buffer.len),
+                        null, // byte offset
+                        null, // key
+                    )) {
+                        .PENDING, .SUCCESS => {},
+                        .CANCELLED => unreachable,
+                        else => |status| {
+                            context.iosb.u.Status = status;
+                            batchApc(b, &context.iosb, 0);
+                        },
+                    }
+                } else {
+                    if (concurrency) return error.ConcurrencyUnavailable;
+
+                    const syscall: Syscall = try .start();
+                    while (true) switch (windows.ntdll.NtWriteFile(
+                        o.file.handle,
+                        null, // event
+                        null, // APC routine
+                        null, // APC context
+                        &context.iosb,
+                        buffer.ptr,
+                        @intCast(buffer.len),
+                        null, // byte offset
+                        null, // key
+                    )) {
+                        .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+                        .CANCELLED => {
+                            try syscall.checkCancel();
+                            continue;
+                        },
+                        else => |status| {
+                            syscall.finish();
+
                             context.iosb.u.Status = status;
                             batchApc(b, &context.iosb, 0);
                             break;
@@ -2963,6 +3033,21 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
     b.submissions = .{ .head = .none, .tail = .none };
 }
 
+/// Since Windows only supports writing one contiguous buffer, returns the
+/// first one, while also limiting it to a length representable by 32-bit
+/// unsigned integer.
+fn windowsWriteBuffer(header: []const u8, data: []const []const u8, splat: usize) []const u8 {
+    const buffer = b: {
+        if (header.len != 0) break :b header;
+        for (data[0 .. data.len - 1]) |buffer| {
+            if (buffer.len != 0) break :b buffer;
+        }
+        if (splat == 0) return &.{};
+        break :b data[data.len - 1];
+    };
+    return buffer[0..@min(buffer.len, std.math.maxInt(u32))];
+}
+
 fn submitComplete(ring: []u32, complete_tail: *Io.Batch.RingIndex, op: u32) void {
     const ct = complete_tail.*;
     const len: u31 = @intCast(ring.len);
@@ -9005,6 +9090,24 @@ fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
     }
 }
 
+fn ntWriteFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
+    switch (io_status_block.u.Status) {
+        .PENDING => unreachable,
+        .CANCELLED => unreachable,
+        .SUCCESS => return io_status_block.Information,
+        .INVALID_USER_BUFFER => return error.SystemResources,
+        .NO_MEMORY => return error.SystemResources,
+        .QUOTA_EXCEEDED => return error.SystemResources,
+        .PIPE_BROKEN => return error.BrokenPipe,
+        .INVALID_HANDLE => return error.NotOpenForWriting,
+        .LOCK_NOT_GRANTED => return error.LockViolation,
+        .ACCESS_DENIED => return error.AccessDenied,
+        .WORKING_SET_QUOTA => return error.SystemResources,
+        .DISK_FULL => return error.NoSpaceLeft,
+        else => |status| return windows.unexpectedStatus(status),
+    }
+}
+
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
     if (!have_preadv) @compileError("TODO implement fileReadPositionalPosix for cursed operating systems that don't support preadv (it's only Haiku)");
 
@@ -9837,16 +9940,9 @@ fn fileWriteStreaming(
     _ = t;
 
     if (is_windows) {
-        if (header.len != 0) {
-            return writeFileStreamingWindows(file.handle, header);
-        }
-        for (data[0 .. data.len - 1]) |buf| {
-            if (buf.len == 0) continue;
-            return writeFileStreamingWindows(file.handle, buf);
-        }
-        const pattern = data[data.len - 1];
-        if (pattern.len == 0 or splat == 0) return 0;
-        return writeFileStreamingWindows(file.handle, pattern);
+        const buffer = windowsWriteBuffer(header, data, splat);
+        if (buffer.len == 0) return 0;
+        return fileWriteStreamingWindows(file, buffer);
     }
 
     var iovecs: [max_iovecs_len]posix.iovec_const = undefined;
@@ -9953,38 +10049,66 @@ fn fileWriteStreaming(
     }
 }
 
-fn writeFileStreamingWindows(
-    handle: windows.HANDLE,
-    bytes: []const u8,
-) File.Writer.Error!usize {
-    assert(bytes.len != 0);
-    var bytes_written: windows.DWORD = undefined;
-    const adjusted_len = std.math.lossyCast(u32, bytes.len);
-    const syscall: Syscall = try .start();
-    while (true) {
-        if (windows.kernel32.WriteFile(handle, bytes.ptr, adjusted_len, &bytes_written, null) != 0) {
-            syscall.finish();
-            return bytes_written;
+fn fileWriteStreamingWindows(file: File, buffer: []const u8) File.Writer.Error!usize {
+    assert(buffer.len != 0);
+
+    var iosb: windows.IO_STATUS_BLOCK = undefined;
+
+    if (file.flags.nonblocking) {
+        var done: bool = false;
+        switch (windows.ntdll.NtWriteFile(
+            file.handle,
+            null, // event
+            flagApc,
+            &done, // APC context
+            &iosb,
+            buffer.ptr,
+            @intCast(buffer.len),
+            null, // byte offset
+            null, // key
+        )) {
+            // We must wait for the APC routine.
+            .PENDING, .SUCCESS => while (!done) {
+                // Once we get here we must not return from the function until the
+                // operation completes, thereby releasing reference to io_status_block.
+                const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                    error.Canceled => |e| {
+                        var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                        _ = windows.ntdll.NtCancelIoFileEx(file.handle, &iosb, &cancel_iosb);
+                        while (!done) waitForApcOrAlert();
+                        return e;
+                    },
+                };
+                waitForApcOrAlert();
+                alertable_syscall.finish();
+            },
+            else => |status| iosb.u.Status = status,
         }
-        switch (windows.GetLastError()) {
-            .OPERATION_ABORTED => {
+        return ntWriteFileResult(&iosb);
+    } else {
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtWriteFile(
+            file.handle,
+            null, // event
+            null, // APC routine
+            null, // APC context
+            &iosb,
+            buffer.ptr,
+            @intCast(buffer.len),
+            null, // byte offset
+            null, // key
+        )) {
+            .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+            .CANCELLED => {
                 try syscall.checkCancel();
                 continue;
             },
-            .INVALID_USER_BUFFER => return syscall.fail(error.SystemResources),
-            .NOT_ENOUGH_MEMORY => return syscall.fail(error.SystemResources),
-            .NOT_ENOUGH_QUOTA => return syscall.fail(error.SystemResources),
-            .NO_DATA => return syscall.fail(error.BrokenPipe),
-            .INVALID_HANDLE => return syscall.fail(error.NotOpenForWriting),
-            .LOCK_VIOLATION => return syscall.fail(error.LockViolation),
-            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-            .WORKING_SET_QUOTA => return syscall.fail(error.SystemResources),
-            .DISK_FULL => return syscall.fail(error.NoSpaceLeft),
-            else => |err| {
+            else => |status| {
                 syscall.finish();
-                return windows.unexpectedError(err);
+                iosb.u.Status = status;
+                return ntWriteFileResult(&iosb);
             },
-        }
+        };
     }
 }
 
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 0fefc77a32e788267a10f9fc2b613c96abeb5e19..ee2a993a4de04b472db56faed611e6d598fcf103 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -1437,7 +1437,7 @@ fn writeIpc(io: Io, file: Io.File, serialized: Serialized) error{BrokenPipe}!voi
         // We do this in a separate write call to give a better chance for the
         // writev below to be in a single packet.
         const n = @min(parents.len, remaining_write_trash_bytes);
-        if (io.vtable.fileWriteStreaming(io.userdata, file, &.{}, &.{parents[0..n]}, 1)) |written| {
+        if (file.writeStreaming(io, &.{}, &.{parents[0..n]}, 1)) |written| {
             remaining_write_trash_bytes -= written;
             continue;
         } else |err| switch (err) {
@@ -1478,7 +1478,7 @@ fn writevNonblock(io: Io, file: Io.File, iov: [][]const u8) Io.File.Writer.Error
             return total_written) : (iov_index += 1) written -= iov[iov_index].len;
         iov[iov_index].ptr += written;
         iov[iov_index].len -= written;
-        written = try io.vtable.fileWriteStreaming(io.userdata, file, &.{}, iov, 1);
+        written = try file.writeStreaming(io, &.{}, iov, 1);
         if (written == 0) return total_written;
         total_written += written;
     }
-- 
2.54.0


From 0aae9768aab8e1b534eb9a7682ad36ab4ef0487d Mon Sep 17 00:00:00 2001
From: Jeff Anderson <kj4tmp@gmail.com>
Date: Sat, 31 Jan 2026 21:54:25 -0800
Subject: [PATCH 163/499] libzigc: cbrt

---
 lib/c/math.zig                |   5 ++
 lib/libc/musl/src/math/cbrt.c | 103 ----------------------------------
 src/libs/musl.zig             |   1 -
 src/libs/wasi_libc.zig        |   1 -
 4 files changed, 5 insertions(+), 105 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/cbrt.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index a9e7c808a80adab4758c439209d9c8470319d442..bb0a424b7db08f54aed34e034dd52eed9007b28f 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -39,6 +39,7 @@ comptime {
         @export(&atanf, .{ .name = "atanf", .linkage = common.linkage, .visibility = common.visibility });
         @export(&atan, .{ .name = "atan", .linkage = common.linkage, .visibility = common.visibility });
         @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&cbrt, .{ .name = "cbrt", .linkage = common.linkage, .visibility = common.visibility });
     }
 
     if (builtin.target.isMuslLibC()) {
@@ -106,3 +107,7 @@ fn copysign(x: f64, y: f64) callconv(.c) f64 {
 fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     return math.copysign(x, y);
 }
+
+fn cbrt(x: f64) callconv(.c) f64 {
+    return math.cbrt(x);
+}
diff --git a/lib/libc/musl/src/math/cbrt.c b/lib/libc/musl/src/math/cbrt.c
deleted file mode 100644
index 7599d3e37d2f6f81f21321b62f1e97aae5e34167..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/cbrt.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrt.c */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- *
- * Optimized by Bruce D. Evans.
- */
-/* cbrt(x)
- * Return cube root of x
- */
-
-#include <math.h>
-#include <stdint.h>
-
-static const uint32_t
-B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
-B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
-
-/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */
-static const double
-P0 =  1.87595182427177009643,  /* 0x3ffe03e6, 0x0f61e692 */
-P1 = -1.88497979543377169875,  /* 0xbffe28e0, 0x92f02420 */
-P2 =  1.621429720105354466140, /* 0x3ff9f160, 0x4a49d6c2 */
-P3 = -0.758397934778766047437, /* 0xbfe844cb, 0xbee751d9 */
-P4 =  0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */
-
-double cbrt(double x)
-{
-	union {double f; uint64_t i;} u = {x};
-	double_t r,s,t,w;
-	uint32_t hx = u.i>>32 & 0x7fffffff;
-
-	if (hx >= 0x7ff00000)  /* cbrt(NaN,INF) is itself */
-		return x+x;
-
-	/*
-	 * Rough cbrt to 5 bits:
-	 *    cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
-	 * where e is integral and >= 0, m is real and in [0, 1), and "/" and
-	 * "%" are integer division and modulus with rounding towards minus
-	 * infinity.  The RHS is always >= the LHS and has a maximum relative
-	 * error of about 1 in 16.  Adding a bias of -0.03306235651 to the
-	 * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE
-	 * floating point representation, for finite positive normal values,
-	 * ordinary integer divison of the value in bits magically gives
-	 * almost exactly the RHS of the above provided we first subtract the
-	 * exponent bias (1023 for doubles) and later add it back.  We do the
-	 * subtraction virtually to keep e >= 0 so that ordinary integer
-	 * division rounds towards minus infinity; this is also efficient.
-	 */
-	if (hx < 0x00100000) { /* zero or subnormal? */
-		u.f = x*0x1p54;
-		hx = u.i>>32 & 0x7fffffff;
-		if (hx == 0)
-			return x;  /* cbrt(0) is itself */
-		hx = hx/3 + B2;
-	} else
-		hx = hx/3 + B1;
-	u.i &= 1ULL<<63;
-	u.i |= (uint64_t)hx << 32;
-	t = u.f;
-
-	/*
-	 * New cbrt to 23 bits:
-	 *    cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)
-	 * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)
-	 * to within 2**-23.5 when |r - 1| < 1/10.  The rough approximation
-	 * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this
-	 * gives us bounds for r = t**3/x.
-	 *
-	 * Try to optimize for parallel evaluation as in __tanf.c.
-	 */
-	r = (t*t)*(t/x);
-	t = t*((P0+r*(P1+r*P2))+((r*r)*r)*(P3+r*P4));
-
-	/*
-	 * Round t away from zero to 23 bits (sloppily except for ensuring that
-	 * the result is larger in magnitude than cbrt(x) but not much more than
-	 * 2 23-bit ulps larger).  With rounding towards zero, the error bound
-	 * would be ~5/6 instead of ~4/6.  With a maximum error of 2 23-bit ulps
-	 * in the rounded t, the infinite-precision error in the Newton
-	 * approximation barely affects third digit in the final error
-	 * 0.667; the error in the rounded t can be up to about 3 23-bit ulps
-	 * before the final error is larger than 0.667 ulps.
-	 */
-	u.f = t;
-	u.i = (u.i + 0x80000000) & 0xffffffffc0000000ULL;
-	t = u.f;
-
-	/* one step Newton iteration to 53 bits with error < 0.667 ulps */
-	s = t*t;         /* t*t is exact */
-	r = x/s;         /* error <= 0.5 ulps; |r| < |t| */
-	w = t+t;         /* t+t is exact */
-	r = (r-t)/(w+r); /* r-t is exact; w+r ~= 3*t */
-	t = t+t*r;       /* error <= 0.5 + 0.5/3 + epsilon */
-	return t;
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index c6bdac314c2c4f9dbf114e9c031d2a867b43ee15..e42c12b7f01a5bfd2e112fc8af754c2b4f572f90 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -839,7 +839,6 @@ const src_files = [_][]const u8{
     "musl/src/math/atanh.c",
     "musl/src/math/atanhf.c",
     "musl/src/math/atanhl.c",
-    "musl/src/math/cbrt.c",
     "musl/src/math/cbrtf.c",
     "musl/src/math/cbrtl.c",
     "musl/src/math/__cos.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 19b820eef9bd305b4a0b45bf9a54b5e12d6acaa3..ea113d3b2e94f1c9db90629406a8f61786a52ab6 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -701,7 +701,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/atanh.c",
     "musl/src/math/atanhf.c",
     "musl/src/math/atanhl.c",
-    "musl/src/math/cbrt.c",
     "musl/src/math/cbrtf.c",
     "musl/src/math/cbrtl.c",
     "musl/src/math/__cos.c",
-- 
2.54.0


From 4aadb5e4a5e09d6b2018fecb364c0fabec028c9a Mon Sep 17 00:00:00 2001
From: Jeff Anderson <kj4tmp@gmail.com>
Date: Sat, 31 Jan 2026 22:55:11 -0800
Subject: [PATCH 164/499] libzigc: cbrtf

---
 lib/c/math.zig                 |  5 +++
 lib/libc/musl/src/math/cbrtf.c | 66 ----------------------------------
 src/libs/musl.zig              |  1 -
 src/libs/wasi_libc.zig         |  1 -
 4 files changed, 5 insertions(+), 68 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/cbrtf.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index bb0a424b7db08f54aed34e034dd52eed9007b28f..3811142769073deb3c2b9b1deba3c3f583b25a1f 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -40,6 +40,7 @@ comptime {
         @export(&atan, .{ .name = "atan", .linkage = common.linkage, .visibility = common.visibility });
         @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
         @export(&cbrt, .{ .name = "cbrt", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&cbrtf, .{ .name = "cbrtf", .linkage = common.linkage, .visibility = common.visibility });
     }
 
     if (builtin.target.isMuslLibC()) {
@@ -111,3 +112,7 @@ fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
 fn cbrt(x: f64) callconv(.c) f64 {
     return math.cbrt(x);
 }
+
+fn cbrtf(x: f32) callconv(.c) f32 {
+    return math.cbrt(x);
+}
diff --git a/lib/libc/musl/src/math/cbrtf.c b/lib/libc/musl/src/math/cbrtf.c
deleted file mode 100644
index 89c2c8655da46a37a737dfed63ae8c619f9c7350..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/cbrtf.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrtf.c */
-/*
- * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
- * Debugged and optimized by Bruce D. Evans.
- */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-/* cbrtf(x)
- * Return cube root of x
- */
-
-#include <math.h>
-#include <stdint.h>
-
-static const unsigned
-B1 = 709958130, /* B1 = (127-127.0/3-0.03306235651)*2**23 */
-B2 = 642849266; /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */
-
-float cbrtf(float x)
-{
-	double_t r,T;
-	union {float f; uint32_t i;} u = {x};
-	uint32_t hx = u.i & 0x7fffffff;
-
-	if (hx >= 0x7f800000)  /* cbrt(NaN,INF) is itself */
-		return x + x;
-
-	/* rough cbrt to 5 bits */
-	if (hx < 0x00800000) {  /* zero or subnormal? */
-		if (hx == 0)
-			return x;  /* cbrt(+-0) is itself */
-		u.f = x*0x1p24f;
-		hx = u.i & 0x7fffffff;
-		hx = hx/3 + B2;
-	} else
-		hx = hx/3 + B1;
-	u.i &= 0x80000000;
-	u.i |= hx;
-
-	/*
-	 * First step Newton iteration (solving t*t-x/t == 0) to 16 bits.  In
-	 * double precision so that its terms can be arranged for efficiency
-	 * without causing overflow or underflow.
-	 */
-	T = u.f;
-	r = T*T*T;
-	T = T*((double_t)x+x+r)/(x+r+r);
-
-	/*
-	 * Second step Newton iteration to 47 bits.  In double precision for
-	 * efficiency and accuracy.
-	 */
-	r = T*T*T;
-	T = T*((double_t)x+x+r)/(x+r+r);
-
-	/* rounding to 24 bits is perfect in round-to-nearest mode */
-	return T;
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index e42c12b7f01a5bfd2e112fc8af754c2b4f572f90..763869a0bdbf9ba9a60db5cd35f623d1edadb258 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -839,7 +839,6 @@ const src_files = [_][]const u8{
     "musl/src/math/atanh.c",
     "musl/src/math/atanhf.c",
     "musl/src/math/atanhl.c",
-    "musl/src/math/cbrtf.c",
     "musl/src/math/cbrtl.c",
     "musl/src/math/__cos.c",
     "musl/src/math/__cosdf.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index ea113d3b2e94f1c9db90629406a8f61786a52ab6..3f069de0c20e55f381c57445306cc328c6d90fd1 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -701,7 +701,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/atanh.c",
     "musl/src/math/atanhf.c",
     "musl/src/math/atanhl.c",
-    "musl/src/math/cbrtf.c",
     "musl/src/math/cbrtl.c",
     "musl/src/math/__cos.c",
     "musl/src/math/__cosdf.c",
-- 
2.54.0


From 59073484baf89072aa02f23fe9a09662e5def100 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 01:08:01 -0800
Subject: [PATCH 165/499] std.Io: add ioctl / DeviceIoControlFile API

---
 lib/std/Io.zig          |  29 ++++++-
 lib/std/Io/Threaded.zig | 188 ++++++++++++++++++++++++++++++++++------
 lib/std/Progress.zig    |  23 +++--
 lib/std/c.zig           |   7 +-
 lib/std/posix.zig       |  22 -----
 5 files changed, 211 insertions(+), 58 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index a892c0123c7179d1f203ba231e087ec7bd92a105..d2b9648245d822660b871aaabe1d29f496edd573 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -257,6 +257,9 @@ pub const VTable = struct {
 pub const Operation = union(enum) {
     file_read_streaming: FileReadStreaming,
     file_write_streaming: FileWriteStreaming,
+    /// On Windows this is NtDeviceIoControlFile. On POSIX this is ioctl. On
+    /// other systems this tag is unreachable.
+    device_io_control: DeviceIoControl,
 
     pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
@@ -324,13 +327,37 @@ pub const Operation = union(enum) {
         pub const Result = Error!usize;
     };
 
+    pub const DeviceIoControl = switch (builtin.os.tag) {
+        .wasi => noreturn,
+        .windows => struct {
+            file: File,
+            IoControlCode: std.os.windows.CTL_CODE,
+            InputBuffer: ?*const anyopaque,
+            InputBufferLength: u32,
+            OutputBuffer: ?*anyopaque,
+            OutputBufferLength: u32,
+
+            pub const Result = std.os.windows.IO_STATUS_BLOCK;
+        },
+        else => struct {
+            file: File,
+            /// Device-dependent operation code.
+            code: u32,
+            arg: ?*anyopaque,
+
+            /// Device and operation dependent result. Negative values are
+            /// negative errno.
+            pub const Result = i32;
+        },
+    };
+
     pub const Result = Result: {
         const operation_fields = @typeInfo(Operation).@"union".fields;
         var field_names: [operation_fields.len][]const u8 = undefined;
         var field_types: [operation_fields.len]type = undefined;
         for (operation_fields, &field_names, &field_types) |field, *field_name, *field_type| {
             field_name.* = field.name;
-            field_type.* = field.type.Result;
+            field_type.* = if (field.type == noreturn) noreturn else field.type.Result;
         }
         break :Result @Union(.auto, Tag, &field_names, &field_types, &@splat(.{}));
     };
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 8de5e2692a89a3da983db7a76f9033a3822d084b..0feec928fca854237041a140b644a38e0bd1c1e4 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2500,6 +2500,9 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
                 else => |e| e,
             },
         },
+        .device_io_control => |*o| return .{
+            .device_io_control = try deviceIoControl(t, o),
+        },
     }
 }
 
@@ -2531,6 +2534,14 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                         poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.OUT, .revents = 0 };
                         poll_len += 1;
                     },
+                    .device_io_control => |o| {
+                        poll_buffer[poll_len] = .{
+                            .fd = o.file.handle,
+                            .events = posix.POLL.OUT | posix.POLL.IN | posix.POLL.ERR,
+                            .revents = 0,
+                        };
+                        poll_len += 1;
+                    },
                 }
                 index = submission.node.next;
             }
@@ -2696,6 +2707,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
             switch (submission.operation) {
                 .file_read_streaming => |o| try poll_storage.add(o.file, posix.POLL.IN),
                 .file_write_streaming => |o| try poll_storage.add(o.file, posix.POLL.OUT),
+                .device_io_control => |o| try poll_storage.add(o.file, posix.POLL.IN | posix.POLL.OUT | posix.POLL.ERR),
             }
             index = submission.node.next;
         }
@@ -2874,6 +2886,7 @@ fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows
             const result: Io.Operation.Result = switch (pending.tag) {
                 .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
                 .file_write_streaming => .{ .file_write_streaming = ntWriteFileResult(iosb) },
+                .device_io_control => .{ .device_io_control = iosb.* },
             };
             storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
         },
@@ -3020,6 +3033,59 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
                         else => |status| {
                             syscall.finish();
 
+                            context.iosb.u.Status = status;
+                            batchApc(b, &context.iosb, 0);
+                            break;
+                        },
+                    };
+                }
+            },
+            .device_io_control => |o| {
+                if (o.file.flags.nonblocking) {
+                    context.file = o.file.handle;
+                    switch (windows.ntdll.NtDeviceIoControlFile(
+                        o.file.handle,
+                        null, // event
+                        &batchApc,
+                        b,
+                        &context.iosb,
+                        o.IoControlCode,
+                        o.InputBuffer,
+                        o.InputBufferLength,
+                        o.OutputBuffer,
+                        o.OutputBufferLength,
+                    )) {
+                        .PENDING, .SUCCESS => {},
+                        .CANCELLED => unreachable,
+                        else => |status| {
+                            context.iosb.u.Status = status;
+                            batchApc(b, &context.iosb, 0);
+                        },
+                    }
+                } else {
+                    if (concurrency) return error.ConcurrencyUnavailable;
+
+                    const syscall: Syscall = try .start();
+                    while (true) switch (windows.ntdll.NtDeviceIoControlFile(
+                        o.file.handle,
+                        null, // event
+                        null, // APC routine
+                        null, // APC context
+                        &context.iosb,
+                        o.IoControlCode,
+                        o.InputBuffer,
+                        o.InputBufferLength,
+                        o.OutputBuffer,
+                        o.OutputBufferLength,
+                    )) {
+                        .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+                        .CANCELLED => {
+                            try syscall.checkCancel();
+                            continue;
+                        },
+                        else => |status| {
+                            syscall.finish();
+
                             context.iosb.u.Status = status;
                             batchApc(b, &context.iosb, 0);
                             break;
@@ -12986,31 +13052,18 @@ fn netInterfaceNameResolve(
         };
 
         const syscall: Syscall = try .start();
-        while (true) {
-            switch (posix.errno(posix.system.ioctl(sock_fd, posix.SIOCGIFINDEX, @intFromPtr(&ifr)))) {
-                .SUCCESS => {
-                    syscall.finish();
-                    return .{ .index = @bitCast(ifr.ifru.ivalue) };
-                },
-                .INTR => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => |e| {
-                    syscall.finish();
-                    switch (e) {
-                        .INVAL => |err| return errnoBug(err), // Bad parameters.
-                        .NOTTY => |err| return errnoBug(err),
-                        .NXIO => |err| return errnoBug(err),
-                        .BADF => |err| return errnoBug(err), // File descriptor used after closed.
-                        .FAULT => |err| return errnoBug(err), // Bad pointer parameter.
-                        .IO => |err| return errnoBug(err), // sock_fd is not a file descriptor
-                        .NODEV => return error.InterfaceNotFound,
-                        else => |err| return posix.unexpectedErrno(err),
-                    }
-                },
-            }
-        }
+        while (true) switch (posix.errno(posix.system.ioctl(sock_fd, posix.SIOCGIFINDEX, @intFromPtr(&ifr)))) {
+            .SUCCESS => {
+                syscall.finish();
+                return .{ .index = @bitCast(ifr.ifru.ivalue) };
+            },
+            .INTR => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .NODEV => return syscall.fail(error.InterfaceNotFound),
+            else => |err| return syscall.unexpectedErrno(err),
+        };
     }
 
     if (is_windows) {
@@ -17849,3 +17902,88 @@ fn mmSyncWrite(file: File, memory: []u8, offset: u64) File.WritePositionalError!
         }
     }
 }
+
+fn deviceIoControl(t: *Threaded, o: *const Io.Operation.DeviceIoControl) Io.Cancelable!Io.Operation.DeviceIoControl.Result {
+    _ = t;
+    if (is_windows) {
+        var iosb: windows.IO_STATUS_BLOCK = undefined;
+        if (o.file.flags.nonblocking) {
+            var done: bool = false;
+            switch (windows.ntdll.NtDeviceIoControlFile(
+                o.file.handle,
+                null, // event
+                flagApc,
+                &done, // APC context
+                &iosb,
+                o.IoControlCode,
+                o.InputBuffer,
+                o.InputBufferLength,
+                o.OutputBuffer,
+                o.OutputBufferLength,
+            )) {
+                // We must wait for the APC routine.
+                .PENDING, .SUCCESS => while (!done) {
+                    // Once we get here we must not return from the function until the
+                    // operation completes, thereby releasing reference to io_status_block.
+                    const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                        error.Canceled => |e| {
+                            var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                            _ = windows.ntdll.NtCancelIoFileEx(o.file.handle, &iosb, &cancel_iosb);
+                            while (!done) waitForApcOrAlert();
+                            return e;
+                        },
+                    };
+                    waitForApcOrAlert();
+                    alertable_syscall.finish();
+                },
+                else => |status| iosb.u.Status = status,
+            }
+        } else {
+            const syscall: Syscall = try .start();
+            while (true) switch (windows.ntdll.NtDeviceIoControlFile(
+                o.file.handle,
+                null, // event
+                null, // APC routine
+                null, // APC context
+                &iosb,
+                o.IoControlCode,
+                o.InputBuffer,
+                o.InputBufferLength,
+                o.OutputBuffer,
+                o.OutputBufferLength,
+            )) {
+                .PENDING => unreachable, // unrecoverable: wrong asynchronous flag
+                .CANCELLED => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                else => |status| {
+                    syscall.finish();
+                    iosb.u.Status = status;
+                    break;
+                },
+            };
+        }
+        return iosb;
+    } else {
+        const syscall: Syscall = try .start();
+        while (true) {
+            const rc = posix.system.ioctl(o.file.handle, @bitCast(o.code), @intFromPtr(o.arg));
+            switch (posix.errno(rc)) {
+                .SUCCESS => {
+                    syscall.finish();
+                    if (@TypeOf(rc) == usize) return @bitCast(@as(u32, @truncate(rc)));
+                    return rc;
+                },
+                .INTR => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                else => |err| {
+                    syscall.finish();
+                    return -@as(i32, @intFromEnum(err));
+                },
+            }
+        }
+    }
+}
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index ee2a993a4de04b472db56faed611e6d598fcf103..e2f3ed52322ef30a89747bbbd0c394c4bf27389d 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -573,7 +573,7 @@ fn updateTask(io: Io) void {
     {
         const resize_flag = wait(io, global_progress.initial_delay_ns);
         if (@atomicLoad(bool, &global_progress.done, .monotonic)) return;
-        maybeUpdateSize(resize_flag);
+        maybeUpdateSize(io, resize_flag) catch return;
 
         const buffer, _ = computeRedraw(&serialized_buffer);
         if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
@@ -592,7 +592,7 @@ fn updateTask(io: Io) void {
             return clearWrittenWithEscapeCodes(stderr.file_writer) catch {};
         }
 
-        maybeUpdateSize(resize_flag);
+        maybeUpdateSize(io, resize_flag) catch return;
 
         const buffer, _ = computeRedraw(&serialized_buffer);
         if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
@@ -622,7 +622,7 @@ fn windowsApiUpdateTask(io: Io) void {
     {
         const resize_flag = wait(io, global_progress.initial_delay_ns);
         if (@atomicLoad(bool, &global_progress.done, .monotonic)) return;
-        maybeUpdateSize(resize_flag);
+        maybeUpdateSize(io, resize_flag) catch return;
 
         const buffer, const nl_n = computeRedraw(&serialized_buffer);
         if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
@@ -643,7 +643,7 @@ fn windowsApiUpdateTask(io: Io) void {
             return clearWrittenWindowsApi() catch {};
         }
 
-        maybeUpdateSize(resize_flag);
+        maybeUpdateSize(io, resize_flag) catch return;
 
         const buffer, const nl_n = computeRedraw(&serialized_buffer);
         if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
@@ -1484,15 +1484,15 @@ fn writevNonblock(io: Io, file: Io.File, iov: [][]const u8) Io.File.Writer.Error
     }
 }
 
-fn maybeUpdateSize(resize_flag: bool) void {
+fn maybeUpdateSize(io: Io, resize_flag: bool) !void {
     if (!resize_flag) return;
 
-    const fd = global_progress.terminal.handle;
+    const file = global_progress.terminal;
 
     if (is_windows) {
         var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
 
-        if (windows.kernel32.GetConsoleScreenBufferInfo(fd, &info) != windows.FALSE) {
+        if (windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) != windows.FALSE) {
             // In the old Windows console, dwSize.Y is the line count of the
             // entire scrollback buffer, so we use this instead so that we
             // always get the size of the screen.
@@ -1512,8 +1512,13 @@ fn maybeUpdateSize(resize_flag: bool) void {
             .ypixel = 0,
         };
 
-        const err = posix.system.ioctl(fd, posix.T.IOCGWINSZ, @intFromPtr(&winsize));
-        if (posix.errno(err) == .SUCCESS) {
+        const err = (try io.operate(.{ .device_io_control = .{
+            .file = file,
+            .code = posix.T.IOCGWINSZ,
+            .arg = &winsize,
+        } })).device_io_control;
+
+        if (err >= 0) {
             global_progress.rows = winsize.row;
             global_progress.cols = winsize.col;
         } else {
diff --git a/lib/std/c.zig b/lib/std/c.zig
index e68d5a71c51397b3028da96ee1c2d4f6e6f2a847..809ce29a472e61529c8c079ac24d8c71d5745ca2 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -10731,7 +10731,6 @@ pub extern "c" fn sysctlnametomib(name: [*:0]const u8, mibp: ?*c_int, sizep: ?*u
 pub extern "c" fn tcgetattr(fd: fd_t, termios_p: *termios) c_int;
 pub extern "c" fn tcsetattr(fd: fd_t, optional_action: TCSA, termios_p: *const termios) c_int;
 pub extern "c" fn fcntl(fd: fd_t, cmd: c_int, ...) c_int;
-pub extern "c" fn ioctl(fd: fd_t, request: c_int, ...) c_int;
 pub extern "c" fn uname(buf: *utsname) c_int;
 
 pub extern "c" fn gethostname(name: [*]u8, len: usize) c_int;
@@ -11108,6 +11107,11 @@ pub const clock_nanosleep = switch (native_os) {
     else => {},
 };
 
+pub const ioctl = switch (native_os) {
+    .windows, .wasi => {},
+    else => private.ioctl,
+};
+
 // OS-specific bits. These are protected from being used on the wrong OS by
 // comptime assertions inside each OS-specific file.
 
@@ -11495,6 +11499,7 @@ const private = struct {
     };
     extern "c" fn getrusage(who: c_int, usage: *rusage) c_int;
     extern "c" fn gettimeofday(noalias tv: ?*timeval, noalias tz: ?*timezone) c_int;
+    extern "c" fn ioctl(fd: fd_t, request: c_int, ...) c_int;
     extern "c" fn msync(addr: *align(page_size) const anyopaque, len: usize, flags: c_int) c_int;
     extern "c" fn nanosleep(rqtp: *const timespec, rmtp: ?*timespec) c_int;
     extern "c" fn clock_nanosleep(clockid: clockid_t, flags: TIMER, t: *const timespec, remain: ?*timespec) c_int;
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index 5e2cde9aa52421fc3f74a8b3baf92eb37c3cc562..7c03e7953b5be7a4eba881adb33fd6a71310fa01 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -1800,28 +1800,6 @@ pub fn name_to_handle_atZ(
     }
 }
 
-pub const IoCtl_SIOCGIFINDEX_Error = error{
-    FileSystem,
-    InterfaceNotFound,
-} || UnexpectedError;
-
-pub fn ioctl_SIOCGIFINDEX(fd: fd_t, ifr: *ifreq) IoCtl_SIOCGIFINDEX_Error!void {
-    while (true) {
-        switch (errno(system.ioctl(fd, SIOCGIFINDEX, @intFromPtr(ifr)))) {
-            .SUCCESS => return,
-            .INVAL => unreachable, // Bad parameters.
-            .NOTTY => unreachable,
-            .NXIO => unreachable,
-            .BADF => unreachable, // Always a race condition.
-            .FAULT => unreachable, // Bad pointer parameter.
-            .INTR => continue,
-            .IO => return error.FileSystem,
-            .NODEV => return error.InterfaceNotFound,
-            else => |err| return unexpectedErrno(err),
-        }
-    }
-}
-
 pub const lfs64_abi = native_os == .linux and builtin.link_libc and (builtin.abi.isGnu() or builtin.abi.isAndroid());
 
 /// Whether or not `error.Unexpected` will print its value and a stack trace.
-- 
2.54.0


From aacf8ce03d2b52e52830873c40eabb1cb1eb8272 Mon Sep 17 00:00:00 2001
From: Jake Greenfield <jake@greenfield.sh>
Date: Sun, 1 Feb 2026 22:04:20 -0500
Subject: [PATCH 166/499] Use MultiReader in `zig std`

---
 lib/compiler/std-docs.zig | 42 +++++++++++++++++++++++++--------------
 1 file changed, 27 insertions(+), 15 deletions(-)

diff --git a/lib/compiler/std-docs.zig b/lib/compiler/std-docs.zig
index 55f49c44e27d2aef6d0a7d513317454f1a3a44d2..72a8c74ff2ce89925f087a32517453b612226b43 100644
--- a/lib/compiler/std-docs.zig
+++ b/lib/compiler/std-docs.zig
@@ -324,11 +324,10 @@ fn buildWasmBinary(
         .stderr = .pipe,
     });
 
-    var poller = Io.poll(gpa, enum { stdout, stderr }, .{
-        .stdout = child.stdout.?,
-        .stderr = child.stderr.?,
-    });
-    defer poller.deinit();
+    var multi_reader_buffer: Io.File.MultiReader.Buffer(2) = undefined;
+    var multi_reader: Io.File.MultiReader = undefined;
+    multi_reader.init(gpa, io, multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
+    defer multi_reader.deinit();
 
     try sendMessage(io, child.stdin.?, .update);
     try sendMessage(io, child.stdin.?, .exit);
@@ -336,14 +335,23 @@ fn buildWasmBinary(
     var result: ?Cache.Path = null;
     var result_error_bundle = std.zig.ErrorBundle.empty;
 
-    const stdout = poller.reader(.stdout);
+    const stdout = multi_reader.fileReader(0);
+    const MessageHeader = std.zig.Server.Message.Header;
 
-    poll: while (true) {
-        const Header = std.zig.Server.Message.Header;
-        while (stdout.buffered().len < @sizeOf(Header)) if (!try poller.poll()) break :poll;
-        const header = stdout.takeStruct(Header, .little) catch unreachable;
-        while (stdout.buffered().len < header.bytes_len) if (!try poller.poll()) break :poll;
-        const body = stdout.take(header.bytes_len) catch unreachable;
+    var eos_err: error{EndOfStream}!void = {};
+
+    while (true) {
+        const header = stdout.interface.takeStruct(MessageHeader, .little) catch |err| switch (err) {
+            error.EndOfStream => break,
+            error.ReadFailed => return stdout.err.?,
+        };
+        const body = stdout.interface.take(header.bytes_len) catch |err| switch (err) {
+            error.EndOfStream => |e| {
+                eos_err = e;
+                break;
+            },
+            error.ReadFailed => return stdout.err.?,
+        };
 
         switch (header.tag) {
             .zig_version => {
@@ -372,11 +380,15 @@ fn buildWasmBinary(
         }
     }
 
-    const stderr = poller.reader(.stderr);
-    if (stderr.bufferedLen() > 0) {
-        std.debug.print("{s}", .{stderr.buffered()});
+    try multi_reader.fillRemaining(.none);
+    const stderr = multi_reader.reader(1).buffered();
+
+    if (stderr.len > 0) {
+        std.debug.print("{s}", .{stderr});
     }
 
+    try eos_err;
+
     // Send EOF to stdin.
     child.stdin.?.close(io);
     child.stdin = null;
-- 
2.54.0


From 60ac4e78ebb6de925b7bd1dc8571af55d096f964 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 18:44:08 -0800
Subject: [PATCH 167/499] std.Io.Mutex: fix tryLock

`@cmpxchgWeak` can return the expected value sometimes.
---
 lib/std/Io.zig | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index d2b9648245d822660b871aaabe1d29f496edd573..bb9610c0904b670b1eff8933efac16bd3138eca2 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1236,15 +1236,7 @@ pub const Mutex = extern struct {
     };
 
     pub fn tryLock(m: *Mutex) bool {
-        switch (m.state.cmpxchgWeak(
-            .unlocked,
-            .locked_once,
-            .acquire,
-            .monotonic,
-        ) orelse return true) {
-            .unlocked => unreachable,
-            .locked_once, .contended => return false,
-        }
+        return m.state.cmpxchgWeak(.unlocked, .locked_once, .acquire, .monotonic) == null;
     }
 
     pub fn lock(m: *Mutex, io: Io) Cancelable!void {
-- 
2.54.0


From b191e50be58cde6589a70410fb2f40ec43d0ffad Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 14:42:12 -0800
Subject: [PATCH 168/499] std.Thread: remove ResetEvent and WaitGroup

* std.Thread.ResetEvent -> Io.Event
* std.Thread.WaitGroup -> Io.Group
---
 CMakeLists.txt               |   1 -
 lib/std/Io/Threaded.zig      |  61 +++++++-
 lib/std/Io/test.zig          | 133 +++++++++++++++++
 lib/std/Thread.zig           | 276 +++--------------------------------
 lib/std/Thread/WaitGroup.zig |  87 -----------
 lib/std/fs/test.zig          |  19 ++-
 6 files changed, 224 insertions(+), 353 deletions(-)
 delete mode 100644 lib/std/Thread/WaitGroup.zig

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fe8660559c39614153329c69f0e74f48041a9e38..05fb9c4805fdb0b8fadcc4bd05167e70ed9668e7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -410,7 +410,6 @@ set(ZIG_STAGE2_SOURCES
     lib/std/Thread.zig
     lib/std/Thread/Futex.zig
     lib/std/Thread/Mutex.zig
-    lib/std/Thread/WaitGroup.zig
     lib/std/array_hash_map.zig
     lib/std/array_list.zig
     lib/std/ascii.zig
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0feec928fca854237041a140b644a38e0bd1c1e4..46ff3a7f38df43edaa06cca3fad6b043d913b95f 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -35,7 +35,7 @@ run_queue: std.SinglyLinkedList = .{},
 join_requested: bool = false,
 stack_size: usize,
 /// All threads are spawned detached; this is how we wait until they all exit.
-wait_group: std.Thread.WaitGroup = .{},
+wait_group: WaitGroup = .init,
 async_limit: Io.Limit,
 concurrent_limit: Io.Limit = .unlimited,
 /// Error from calling `std.Thread.getCpuCount` in `init`.
@@ -17987,3 +17987,62 @@ fn deviceIoControl(t: *Threaded, o: *const Io.Operation.DeviceIoControl) Io.Canc
         }
     }
 }
+
+const WaitGroup = struct {
+    state: std.atomic.Value(usize),
+    event: Io.Event,
+
+    const init: WaitGroup = .{ .state = .{ .raw = 0 }, .event = .unset };
+
+    const is_waiting: usize = 1 << 0;
+    const one_pending: usize = 1 << 1;
+
+    fn start(wg: *WaitGroup) void {
+        const prev_state = wg.state.fetchAdd(one_pending, .monotonic);
+        assert((prev_state / one_pending) < (std.math.maxInt(usize) / one_pending));
+    }
+
+    fn value(wg: *WaitGroup) usize {
+        return wg.state.load(.monotonic) / one_pending;
+    }
+
+    fn wait(wg: *WaitGroup) void {
+        const prev_state = wg.state.fetchAdd(is_waiting, .acquire);
+        assert(prev_state & is_waiting == 0);
+        if ((prev_state / one_pending) > 0) eventWait(&wg.event);
+    }
+
+    fn finish(wg: *WaitGroup) void {
+        const state = wg.state.fetchSub(one_pending, .acq_rel);
+        assert((state / one_pending) > 0);
+
+        if (state == (one_pending | is_waiting)) {
+            eventSet(&wg.event);
+        }
+    }
+};
+
+/// Same as `Io.Event.wait` but avoids the VTable.
+fn eventWait(event: *Io.Event) void {
+    if (@cmpxchgStrong(Io.Event, event, .unset, .waiting, .acquire, .acquire)) |prev| switch (prev) {
+        .unset => unreachable,
+        .waiting => {},
+        .is_set => return,
+    };
+    while (true) {
+        Thread.futexWaitUncancelable(@ptrCast(event), @intFromEnum(Io.Event.waiting), null);
+        switch (@atomicLoad(Io.Event, event, .acquire)) {
+            .unset => unreachable, // `reset` called before pending `wait` returned
+            .waiting => continue,
+            .is_set => return,
+        }
+    }
+}
+
+/// Same as `Io.Event.set` but avoids the VTable.
+fn eventSet(event: *Io.Event) void {
+    switch (@atomicRmw(Io.Event, event, .Xchg, .is_set, .release)) {
+        .unset, .is_set => {},
+        .waiting => Thread.futexWake(@ptrCast(event), std.math.maxInt(u32)),
+    }
+}
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 930a176b015c9ee966bab3e643b37f14d5648f4f..a9e2eb28d4125826143239ccc3d6ff5ceef70ffc 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -716,3 +716,136 @@ test "read from a file using Batch.awaitAsync API" {
         }
     }
 }
+
+test "Event smoke test" {
+    const io = testing.io;
+
+    var event: Io.Event = .unset;
+    try testing.expectEqual(false, event.isSet());
+
+    // make sure the event gets set
+    event.set(io);
+    try testing.expectEqual(true, event.isSet());
+
+    // make sure the event gets unset again
+    event.reset();
+    try testing.expectEqual(false, event.isSet());
+
+    // waits should timeout as there's no other thread to set the event
+    try testing.expectError(error.Timeout, event.waitTimeout(io, .{ .duration = .{
+        .raw = .zero,
+        .clock = .awake,
+    } }));
+    try testing.expectError(error.Timeout, event.waitTimeout(io, .{ .duration = .{
+        .raw = .fromMilliseconds(1),
+        .clock = .awake,
+    } }));
+
+    // set the event again and make sure waits complete
+    event.set(io);
+    try event.wait(io);
+    try event.waitTimeout(io, .{ .duration = .{ .raw = .fromMilliseconds(1), .clock = .awake } });
+    try testing.expectEqual(true, event.isSet());
+}
+
+test "Event signaling" {
+    if (builtin.single_threaded) {
+        // This test requires spawning threads.
+        return error.SkipZigTest;
+    }
+
+    const io = testing.io;
+
+    const Context = struct {
+        in: Io.Event = .unset,
+        out: Io.Event = .unset,
+        value: usize = 0,
+
+        fn input(self: *@This()) !void {
+            // wait for the value to become 1
+            try self.in.wait(io);
+            self.in.reset();
+            try testing.expectEqual(self.value, 1);
+
+            // bump the value and wake up output()
+            self.value = 2;
+            self.out.set(io);
+
+            // wait for output to receive 2, bump the value and wake us up with 3
+            try self.in.wait(io);
+            self.in.reset();
+            try testing.expectEqual(self.value, 3);
+
+            // bump the value and wake up output() for it to see 4
+            self.value = 4;
+            self.out.set(io);
+        }
+
+        fn output(self: *@This()) !void {
+            // start with 0 and bump the value for input to see 1
+            try testing.expectEqual(self.value, 0);
+            self.value = 1;
+            self.in.set(io);
+
+            // wait for input to receive 1, bump the value to 2 and wake us up
+            try self.out.wait(io);
+            self.out.reset();
+            try testing.expectEqual(self.value, 2);
+
+            // bump the value to 3 for input to see (rhymes)
+            self.value = 3;
+            self.in.set(io);
+
+            // wait for input to bump the value to 4 and receive no more (rhymes)
+            try self.out.wait(io);
+            self.out.reset();
+            try testing.expectEqual(self.value, 4);
+        }
+    };
+
+    var ctx = Context{};
+
+    const thread = try std.Thread.spawn(.{}, Context.output, .{&ctx});
+    defer thread.join();
+
+    try ctx.input();
+}
+
+test "Event broadcast" {
+    if (builtin.single_threaded) {
+        // This test requires spawning threads.
+        return error.SkipZigTest;
+    }
+
+    const io = testing.io;
+
+    const num_threads = 10;
+    const Barrier = struct {
+        event: Io.Event = .unset,
+        counter: std.atomic.Value(usize) = std.atomic.Value(usize).init(num_threads),
+
+        fn wait(self: *@This()) void {
+            if (self.counter.fetchSub(1, .acq_rel) == 1) {
+                self.event.set(io);
+            }
+        }
+    };
+
+    const Context = struct {
+        start_barrier: Barrier = .{},
+        finish_barrier: Barrier = .{},
+
+        fn run(self: *@This()) void {
+            self.start_barrier.wait();
+            self.finish_barrier.wait();
+        }
+    };
+
+    var ctx = Context{};
+    var threads: [num_threads - 1]std.Thread = undefined;
+
+    for (&threads) |*t| t.* = try std.Thread.spawn(.{}, Context.run, .{&ctx});
+    defer for (threads) |t| t.join();
+
+    ctx.run();
+}
diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 33fd4c0234cddd970e478caf40f43cc7d7edba2b..ef35422e1d2c7013d739dc6a05791de888292b9c 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -19,129 +19,11 @@ pub const Mutex = @import("Thread/Mutex.zig");
 pub const Semaphore = @import("Thread/Semaphore.zig");
 pub const Condition = @import("Thread/Condition.zig");
 pub const RwLock = @import("Thread/RwLock.zig");
-pub const WaitGroup = @import("Thread/WaitGroup.zig");
 
 pub const Pool = @compileError("deprecated; consider using 'std.Io.Group' with 'std.Io.Threaded'");
 
 pub const use_pthreads = native_os != .windows and native_os != .wasi and builtin.link_libc;
 
-/// A thread-safe logical boolean value which can be `set` and `unset`.
-///
-/// It can also block threads until the value is set with cancelation via timed
-/// waits. Statically initializable; four bytes on all targets.
-pub const ResetEvent = enum(u32) {
-    unset = 0,
-    waiting = 1,
-    is_set = 2,
-
-    /// Returns whether the logical boolean is `set`.
-    ///
-    /// Once `reset` is called, this returns false until the next `set`.
-    ///
-    /// The memory accesses before the `set` can be said to happen before
-    /// `isSet` returns true.
-    pub fn isSet(re: *const ResetEvent) bool {
-        if (builtin.single_threaded) return switch (re.*) {
-            .unset => false,
-            .waiting => unreachable,
-            .is_set => true,
-        };
-        // Acquire barrier ensures memory accesses before `set` happen before
-        // returning true.
-        return @atomicLoad(ResetEvent, re, .acquire) == .is_set;
-    }
-
-    /// Blocks the calling thread until `set` is called.
-    ///
-    /// This is effectively a more efficient version of `while (!isSet()) {}`.
-    ///
-    /// The memory accesses before the `set` can be said to happen before `wait` returns.
-    pub fn wait(re: *ResetEvent) void {
-        if (builtin.single_threaded) switch (re.*) {
-            .unset => unreachable, // Deadlock, no other threads to wake us up.
-            .waiting => unreachable, // Invalid state.
-            .is_set => return,
-        };
-        if (!re.isSet()) return timedWaitInner(re, null) catch |err| switch (err) {
-            error.Timeout => unreachable, // No timeout specified.
-        };
-    }
-
-    /// Blocks the calling thread until `set` is called, or until the
-    /// corresponding timeout expires, returning `error.Timeout`.
-    ///
-    /// This is effectively a more efficient version of `while (!isSet()) {}`.
-    ///
-    /// The memory accesses before the set() can be said to happen before
-    /// timedWait() returns without error.
-    pub fn timedWait(re: *ResetEvent, timeout_ns: u64) error{Timeout}!void {
-        if (builtin.single_threaded) switch (re.*) {
-            .unset => return error.Timeout,
-            .waiting => unreachable, // Invalid state.
-            .is_set => return,
-        };
-        if (!re.isSet()) return timedWaitInner(re, timeout_ns);
-    }
-
-    fn timedWaitInner(re: *ResetEvent, timeout: ?u64) error{Timeout}!void {
-        @branchHint(.cold);
-
-        // Try to set the state from `unset` to `waiting` to indicate to the
-        // `set` thread that others are blocked on the ResetEvent. Avoid using
-        // any strict barriers until we know the ResetEvent is set.
-        var state = @atomicLoad(ResetEvent, re, .acquire);
-        if (state == .unset) {
-            state = @cmpxchgStrong(ResetEvent, re, state, .waiting, .acquire, .acquire) orelse .waiting;
-        }
-
-        // Wait until the ResetEvent is set since the state is waiting.
-        if (state == .waiting) {
-            var futex_deadline = Futex.Deadline.init(timeout);
-            while (true) {
-                const wait_result = futex_deadline.wait(@ptrCast(re), @intFromEnum(ResetEvent.waiting));
-
-                // Check if the ResetEvent was set before possibly reporting error.Timeout below.
-                state = @atomicLoad(ResetEvent, re, .acquire);
-                if (state != .waiting) break;
-
-                try wait_result;
-            }
-        }
-
-        assert(state == .is_set);
-    }
-
-    /// Marks the logical boolean as `set` and unblocks any threads in `wait`
-    /// or `timedWait` to observe the new state.
-    ///
-    /// The logical boolean stays `set` until `reset` is called, making future
-    /// `set` calls do nothing semantically.
-    ///
-    /// The memory accesses before `set` can be said to happen before `isSet`
-    /// returns true or `wait`/`timedWait` return successfully.
-    pub fn set(re: *ResetEvent) void {
-        if (builtin.single_threaded) {
-            re.* = .is_set;
-            return;
-        }
-        if (@atomicRmw(ResetEvent, re, .Xchg, .is_set, .release) == .waiting) {
-            Futex.wake(@ptrCast(re), std.math.maxInt(u32));
-        }
-    }
-
-    /// Unmarks the ResetEvent as if `set` was never called.
-    ///
-    /// Assumes no threads are blocked in `wait` or `timedWait`. Concurrent
-    /// calls to `set`, `isSet` and `reset` are allowed.
-    pub fn reset(re: *ResetEvent) void {
-        if (builtin.single_threaded) {
-            re.* = .unset;
-            return;
-        }
-        @atomicStore(ResetEvent, re, .unset, .monotonic);
-    }
-};
-
 const Thread = @This();
 const Impl = if (native_os == .windows)
     WindowsThreadImpl
@@ -1676,16 +1558,16 @@ test "setName, getName" {
     const io = testing.io;
 
     const Context = struct {
-        start_wait_event: ResetEvent = .unset,
-        test_done_event: ResetEvent = .unset,
-        thread_done_event: ResetEvent = .unset,
+        start_wait_event: Io.Event = .unset,
+        test_done_event: Io.Event = .unset,
+        thread_done_event: Io.Event = .unset,
 
         done: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
         thread: Thread = undefined,
 
         pub fn run(ctx: *@This()) !void {
             // Wait for the main thread to have set the thread field in the context.
-            ctx.start_wait_event.wait();
+            try ctx.start_wait_event.wait(io);
 
             switch (native_os) {
                 .windows => testThreadName(io, &ctx.thread) catch |err| switch (err) {
@@ -1696,10 +1578,10 @@ test "setName, getName" {
             }
 
             // Signal our test is done
-            ctx.test_done_event.set();
+            ctx.test_done_event.set(io);
 
             // wait for the thread to property exit
-            ctx.thread_done_event.wait();
+            try ctx.thread_done_event.wait(io);
         }
     };
 
@@ -1707,8 +1589,8 @@ test "setName, getName" {
     var thread = try spawn(.{}, Context.run, .{&context});
 
     context.thread = thread;
-    context.start_wait_event.set();
-    context.test_done_event.wait();
+    context.start_wait_event.set(io);
+    try context.test_done_event.wait(io);
 
     switch (native_os) {
         .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
@@ -1722,31 +1604,32 @@ test "setName, getName" {
         else => try testThreadName(io, &thread),
     }
 
-    context.thread_done_event.set();
+    context.thread_done_event.set(io);
     thread.join();
 }
 
 test {
     _ = Futex;
-    _ = ResetEvent;
     _ = Mutex;
     _ = Semaphore;
     _ = Condition;
     _ = RwLock;
 }
 
-fn testIncrementNotify(value: *usize, event: *ResetEvent) void {
+fn testIncrementNotify(io: Io, value: *usize, event: *Io.Event) void {
     value.* += 1;
-    event.set();
+    event.set(io);
 }
 
 test join {
     if (builtin.single_threaded) return error.SkipZigTest;
 
+    const io = testing.io;
+
     var value: usize = 0;
-    var event: ResetEvent = .unset;
+    var event: Io.Event = .unset;
 
-    const thread = try Thread.spawn(.{}, testIncrementNotify, .{ &value, &event });
+    const thread = try Thread.spawn(.{}, testIncrementNotify, .{ io, &value, &event });
     thread.join();
 
     try std.testing.expectEqual(value, 1);
@@ -1755,13 +1638,15 @@ test join {
 test detach {
     if (builtin.single_threaded) return error.SkipZigTest;
 
+    const io = testing.io;
+
     var value: usize = 0;
-    var event: ResetEvent = .unset;
+    var event: Io.Event = .unset;
 
-    const thread = try Thread.spawn(.{}, testIncrementNotify, .{ &value, &event });
+    const thread = try Thread.spawn(.{}, testIncrementNotify, .{ io, &value, &event });
     thread.detach();
 
-    event.wait();
+    try event.wait(io);
     try std.testing.expectEqual(value, 1);
 }
 
@@ -1803,127 +1688,6 @@ fn testTls() !void {
     if (x != 1235) return error.TlsBadEndValue;
 }
 
-test "ResetEvent smoke test" {
-    var event: ResetEvent = .unset;
-    try testing.expectEqual(false, event.isSet());
-
-    // make sure the event gets set
-    event.set();
-    try testing.expectEqual(true, event.isSet());
-
-    // make sure the event gets unset again
-    event.reset();
-    try testing.expectEqual(false, event.isSet());
-
-    // waits should timeout as there's no other thread to set the event
-    try testing.expectError(error.Timeout, event.timedWait(0));
-    try testing.expectError(error.Timeout, event.timedWait(std.time.ns_per_ms));
-
-    // set the event again and make sure waits complete
-    event.set();
-    event.wait();
-    try event.timedWait(std.time.ns_per_ms);
-    try testing.expectEqual(true, event.isSet());
-}
-
-test "ResetEvent signaling" {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const Context = struct {
-        in: ResetEvent = .unset,
-        out: ResetEvent = .unset,
-        value: usize = 0,
-
-        fn input(self: *@This()) !void {
-            // wait for the value to become 1
-            self.in.wait();
-            self.in.reset();
-            try testing.expectEqual(self.value, 1);
-
-            // bump the value and wake up output()
-            self.value = 2;
-            self.out.set();
-
-            // wait for output to receive 2, bump the value and wake us up with 3
-            self.in.wait();
-            self.in.reset();
-            try testing.expectEqual(self.value, 3);
-
-            // bump the value and wake up output() for it to see 4
-            self.value = 4;
-            self.out.set();
-        }
-
-        fn output(self: *@This()) !void {
-            // start with 0 and bump the value for input to see 1
-            try testing.expectEqual(self.value, 0);
-            self.value = 1;
-            self.in.set();
-
-            // wait for input to receive 1, bump the value to 2 and wake us up
-            self.out.wait();
-            self.out.reset();
-            try testing.expectEqual(self.value, 2);
-
-            // bump the value to 3 for input to see (rhymes)
-            self.value = 3;
-            self.in.set();
-
-            // wait for input to bump the value to 4 and receive no more (rhymes)
-            self.out.wait();
-            self.out.reset();
-            try testing.expectEqual(self.value, 4);
-        }
-    };
-
-    var ctx = Context{};
-
-    const thread = try std.Thread.spawn(.{}, Context.output, .{&ctx});
-    defer thread.join();
-
-    try ctx.input();
-}
-
-test "ResetEvent broadcast" {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 10;
-    const Barrier = struct {
-        event: ResetEvent = .unset,
-        counter: std.atomic.Value(usize) = std.atomic.Value(usize).init(num_threads),
-
-        fn wait(self: *@This()) void {
-            if (self.counter.fetchSub(1, .acq_rel) == 1) {
-                self.event.set();
-            }
-        }
-    };
-
-    const Context = struct {
-        start_barrier: Barrier = .{},
-        finish_barrier: Barrier = .{},
-
-        fn run(self: *@This()) void {
-            self.start_barrier.wait();
-            self.finish_barrier.wait();
-        }
-    };
-
-    var ctx = Context{};
-    var threads: [num_threads - 1]std.Thread = undefined;
-
-    for (&threads) |*t| t.* = try std.Thread.spawn(.{}, Context.run, .{&ctx});
-    defer for (threads) |t| t.join();
-
-    ctx.run();
-}
-
 /// Configures the per-thread alternative signal stack requested by `std.options.signal_stack_size`.
 pub fn maybeAttachSignalStack() void {
     const size = std.options.signal_stack_size orelse return;
diff --git a/lib/std/Thread/WaitGroup.zig b/lib/std/Thread/WaitGroup.zig
deleted file mode 100644
index 8a9107192dac15e3541e0daf410d284e860f6e91..0000000000000000000000000000000000000000
--- a/lib/std/Thread/WaitGroup.zig
+++ /dev/null
@@ -1,87 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const assert = std.debug.assert;
-const WaitGroup = @This();
-
-const is_waiting: usize = 1 << 0;
-const one_pending: usize = 1 << 1;
-
-state: std.atomic.Value(usize) = std.atomic.Value(usize).init(0),
-event: std.Thread.ResetEvent = .unset,
-
-pub fn start(self: *WaitGroup) void {
-    return startStateless(&self.state);
-}
-
-pub fn startStateless(state: *std.atomic.Value(usize)) void {
-    const prev_state = state.fetchAdd(one_pending, .monotonic);
-    assert((prev_state / one_pending) < (std.math.maxInt(usize) / one_pending));
-}
-
-pub fn startMany(self: *WaitGroup, n: usize) void {
-    const state = self.state.fetchAdd(one_pending * n, .monotonic);
-    assert((state / one_pending) < (std.math.maxInt(usize) / one_pending));
-}
-
-pub fn finish(self: *WaitGroup) void {
-    const state = self.state.fetchSub(one_pending, .acq_rel);
-    assert((state / one_pending) > 0);
-
-    if (state == (one_pending | is_waiting)) {
-        self.event.set();
-    }
-}
-
-pub fn finishStateless(state: *std.atomic.Value(usize), event: *std.Thread.ResetEvent) void {
-    const prev_state = state.fetchSub(one_pending, .acq_rel);
-    assert((prev_state / one_pending) > 0);
-    if (prev_state == (one_pending | is_waiting)) event.set();
-}
-
-pub fn wait(wg: *WaitGroup) void {
-    return waitStateless(&wg.state, &wg.event);
-}
-
-pub fn waitStateless(state: *std.atomic.Value(usize), event: *std.Thread.ResetEvent) void {
-    const prev_state = state.fetchAdd(is_waiting, .acquire);
-    assert(prev_state & is_waiting == 0);
-    if ((prev_state / one_pending) > 0) event.wait();
-}
-
-pub fn reset(self: *WaitGroup) void {
-    self.state.store(0, .monotonic);
-    self.event.reset();
-}
-
-pub fn isDone(wg: *WaitGroup) bool {
-    const state = wg.state.load(.acquire);
-    assert(state & is_waiting == 0);
-
-    return (state / one_pending) == 0;
-}
-
-pub fn value(wg: *WaitGroup) usize {
-    return wg.state.load(.monotonic) / one_pending;
-}
-
-// Spawns a new thread for the task. This is appropriate when the callee
-// delegates all work.
-pub fn spawnManager(
-    wg: *WaitGroup,
-    comptime func: anytype,
-    args: anytype,
-) void {
-    if (builtin.single_threaded) {
-        @call(.auto, func, args);
-        return;
-    }
-    const Manager = struct {
-        fn run(wg_inner: *WaitGroup, args_inner: @TypeOf(args)) void {
-            defer wg_inner.finish();
-            @call(.auto, func, args_inner);
-        }
-    };
-    wg.start();
-    const t = std.Thread.spawn(.{}, Manager.run, .{ wg, args }) catch return Manager.run(wg, args);
-    t.detach();
-}
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index d0ec6b33e9cda1cbf6b5d27eeb1e9e6d1b831dda..977a285fb4cc122d6cc82da157844df143973494 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -1745,29 +1745,32 @@ test "open file with exclusive lock twice, make sure second lock waits" {
             errdefer file.close(io);
 
             const S = struct {
-                fn checkFn(inner_ctx: *TestContext, path: []const u8, started: *std.Thread.ResetEvent, locked: *std.Thread.ResetEvent) !void {
-                    started.set();
+                fn checkFn(inner_ctx: *TestContext, path: []const u8, started: *Io.Event, locked: *Io.Event) !void {
+                    started.set(inner_ctx.io);
                     const file1 = try inner_ctx.dir.createFile(inner_ctx.io, path, .{ .lock = .exclusive });
 
-                    locked.set();
+                    locked.set(inner_ctx.io);
                     file1.close(inner_ctx.io);
                 }
             };
 
-            var started: std.Thread.ResetEvent = .unset;
-            var locked: std.Thread.ResetEvent = .unset;
+            var started: Io.Event = .unset;
+            var locked: Io.Event = .unset;
 
             const t = try std.Thread.spawn(.{}, S.checkFn, .{ ctx, filename, &started, &locked });
             defer t.join();
 
             // Wait for the spawned thread to start trying to acquire the exclusive file lock.
             // Then wait a bit to make sure that can't acquire it since we currently hold the file lock.
-            started.wait();
-            try expectError(error.Timeout, locked.timedWait(10 * std.time.ns_per_ms));
+            try started.wait(io);
+            try expectError(error.Timeout, locked.waitTimeout(io, .{ .duration = .{
+                .raw = .fromMilliseconds(10),
+                .clock = .awake,
+            } }));
 
             // Release the file lock which should unlock the thread to lock it and set the locked event.
             file.close(io);
-            locked.wait();
+            try locked.wait(io);
         }
     }.impl);
 }
-- 
2.54.0


From 83abd73801a6ab3125c1b0b8ba432be188c9e7ca Mon Sep 17 00:00:00 2001
From: Tom Winter <readcuttingt@gmail.com>
Date: Wed, 3 Dec 2025 07:06:16 +0000
Subject: [PATCH 169/499] Windows: Support directory handle for cwd instead of
 string for Child.process

This implementation is a bit of a hacky workaround, as we use a ntdll
API to grab the full path of the directory handle. As far as I can tell
this might be the only solution to the problem, as
kernel32.CreateProcessW takes a directory path as a string only.

I might be wrong though as haven't researched the problem thoroughly.
---
 lib/std/Io/Threaded.zig | 28 ++++++++++++++++++++++------
 lib/std/process.zig     |  3 +++
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 0feec928fca854237041a140b644a38e0bd1c1e4..60be4a8d4c8211d9045e20ee291fab0541f441bb 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -15193,7 +15193,26 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 
-    const cwd_w = if (options.cwd) |cwd| try std.unicode.wtf8ToWtf16LeAllocZ(arena, cwd) else null;
+    const cwd_w = cwd_w: {
+        if (options.cwd_dir) |cwd_dir| {
+            var dir_path_buffer = try arena.alloc(u16, windows.PATH_MAX_WIDE + 1);
+            // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
+            try Thread.checkCancel();
+            const dir_path = try windows.GetFinalPathNameByHandle(
+                cwd_dir.handle,
+                .{},
+                dir_path_buffer[0..windows.PATH_MAX_WIDE],
+            );
+            dir_path_buffer[dir_path.len] = 0;
+            // Shrink the allocation down to just the path buffer + sentinel
+            dir_path_buffer = try arena.realloc(dir_path_buffer, dir_path.len + 1);
+            break :cwd_w dir_path_buffer[0..dir_path.len :0];
+        } else if (options.cwd) |cwd| {
+            break :cwd_w try std.unicode.wtf8ToWtf16LeAllocZ(arena, cwd);
+        } else {
+            break :cwd_w null;
+        }
+    };
     const cwd_w_ptr = if (cwd_w) |cwd| cwd.ptr else null;
 
     const maybe_envp_buf = if (options.environ_map) |environ_map| try environ_map.createBlockWindows(arena) else null;
@@ -15204,16 +15223,13 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
 
     // The cwd provided by options is in effect when choosing the executable
     // path to match POSIX semantics.
-    var cwd_path_w_needs_free = false;
     const cwd_path_w = x: {
         // If the app name is absolute, then we need to use its dirname as the cwd
         if (app_name_is_absolute) {
-            cwd_path_w_needs_free = true;
             const dir = Dir.path.dirname(app_name_wtf8).?;
             break :x try std.unicode.wtf8ToWtf16LeAllocZ(arena, dir);
-        } else if (options.cwd) |cwd| {
-            cwd_path_w_needs_free = true;
-            break :x try std.unicode.wtf8ToWtf16LeAllocZ(arena, cwd);
+        } else if (cwd_w) |cwd| {
+            break :x cwd;
         } else {
             break :x &[_:0]u16{}; // empty for cwd
         }
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 3b5a0ecebd5e38ced3748bd0a012adc6d1d6d0a2..d4e5e689316db4d356c25362bfae6b0aea844f18 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -359,6 +359,9 @@ pub const SpawnError = error{
     /// children of the calling process and the child had already performed an
     /// image replacement.
     ProcessAlreadyExec,
+    /// On Windows, the volume does not contain a recognized file system. File
+    /// system drivers might not be loaded, or the volume may be corrupt.
+    UnrecognizedVolume,
 } || Io.Dir.PathNameError || Io.Cancelable || Io.UnexpectedError;
 
 pub const SpawnOptions = struct {
-- 
2.54.0


From 05346e123bc5dbc20a7a60655b06b55030a84f47 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Sun, 7 Dec 2025 02:56:41 -0800
Subject: [PATCH 170/499] Add process.Child.Cwd, use it for cwd and remove
 cwd_dir field

The user must now explicitly choose between inheriting the current CWD, passing a path for the CWD, or passing a Dir for the CWD.
---
 lib/compiler/std-docs.zig              | 10 +++---
 lib/std/Build.zig                      |  4 +--
 lib/std/Build/Step.zig                 | 28 ++++++++-------
 lib/std/Build/Step/InstallArtifact.zig |  2 +-
 lib/std/Build/Step/Run.zig             |  4 +--
 lib/std/Build/WebServer.zig            | 10 +++---
 lib/std/Io/Threaded.zig                | 48 +++++++++++++++-----------
 lib/std/process.zig                    | 13 ++-----
 lib/std/process/Child.zig              | 11 ++++++
 test/standalone/windows_paths/test.zig | 42 +++++++++++-----------
 test/standalone/windows_spawn/main.zig | 14 ++++++--
 tools/doctest.zig                      | 12 +++----
 tools/incr-check.zig                   |  9 ++---
 13 files changed, 112 insertions(+), 95 deletions(-)

diff --git a/lib/compiler/std-docs.zig b/lib/compiler/std-docs.zig
index 72a8c74ff2ce89925f087a32517453b612226b43..c9ce1700519bcb31692cd4623ce81801d7559a83 100644
--- a/lib/compiler/std-docs.zig
+++ b/lib/compiler/std-docs.zig
@@ -398,7 +398,7 @@ fn buildWasmBinary(
             if (code != 0) {
                 std.log.err(
                     "the following command exited with error code {d}:\n{s}",
-                    .{ code, try std.Build.Step.allocPrintCmd(arena, null, null, argv.items) },
+                    .{ code, try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
                 );
                 return error.WasmCompilationFailed;
             }
@@ -406,14 +406,14 @@ fn buildWasmBinary(
         .signal => |sig| {
             std.log.err(
                 "the following command terminated with signal {t}:\n{s}",
-                .{ sig, try std.Build.Step.allocPrintCmd(arena, null, null, argv.items) },
+                .{ sig, try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
             );
             return error.WasmCompilationFailed;
         },
         .stopped, .unknown => {
             std.log.err(
                 "the following command terminated unexpectedly:\n{s}",
-                .{try std.Build.Step.allocPrintCmd(arena, null, null, argv.items)},
+                .{try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items)},
             );
             return error.WasmCompilationFailed;
         },
@@ -423,14 +423,14 @@ fn buildWasmBinary(
         try result_error_bundle.renderToStderr(io, .{}, .auto);
         std.log.err("the following command failed with {d} compilation errors:\n{s}", .{
             result_error_bundle.errorMessageCount(),
-            try std.Build.Step.allocPrintCmd(arena, null, null, argv.items),
+            try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items),
         });
         return error.WasmCompilationFailed;
     }
 
     return result orelse {
         std.log.err("child process failed to report result\n{s}", .{
-            try std.Build.Step.allocPrintCmd(arena, null, null, argv.items),
+            try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items),
         });
         return error.WasmCompilationFailed;
     };
diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index 242949605cb5af1d4eb35e99506d13a620e73514..4517ce75b04fb4e2fec2d101bbfccdee92109835 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -1868,7 +1868,7 @@ pub fn runAllowFail(
     const io = graph.io;
 
     const max_output_size = 400 * 1024;
-    try Step.handleVerbose2(b, null, &graph.environ_map, argv);
+    try Step.handleVerbose2(b, .inherit, &graph.environ_map, argv);
 
     var child = try std.process.spawn(io, .{
         .argv = argv,
@@ -1911,7 +1911,7 @@ pub fn run(b: *Build, argv: []const []const u8) []u8 {
     var code: u8 = undefined;
     return b.runAllowFail(argv, &code, .inherit) catch |err| process.fatal(
         "the following command failed with {t}:\n{s}",
-        .{ err, Step.allocPrintCmd(b.allocator, null, null, argv) catch @panic("OOM") },
+        .{ err, Step.allocPrintCmd(b.allocator, .inherit, null, argv) catch @panic("OOM") },
     );
 }
 
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index cfc263b7701e34f0ef762ae3f2524d0cac850f37..2f5e4316d47cb32e1dee00c79bee977333b3bc79 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -350,10 +350,10 @@ pub fn captureChildProcess(
 
     // If an error occurs, it's happened in this command:
     assert(s.result_failed_command == null);
-    s.result_failed_command = try allocPrintCmd(gpa, null, null, argv);
+    s.result_failed_command = try allocPrintCmd(gpa, .inherit, null, argv);
 
     try handleChildProcUnsupported(s);
-    try handleVerbose(s.owner, null, argv);
+    try handleVerbose(s.owner, .inherit, argv);
 
     const result = std.process.run(arena, io, .{
         .argv = argv,
@@ -410,7 +410,7 @@ pub fn evalZigProcess(
 
     // If an error occurs, it's happened in this command:
     assert(s.result_failed_command == null);
-    s.result_failed_command = try allocPrintCmd(gpa, null, null, argv);
+    s.result_failed_command = try allocPrintCmd(gpa, .inherit, null, argv);
 
     if (s.getZigProcess()) |zp| update: {
         assert(watch);
@@ -449,7 +449,7 @@ pub fn evalZigProcess(
     assert(argv.len != 0);
 
     try handleChildProcUnsupported(s);
-    try handleVerbose(s.owner, null, argv);
+    try handleVerbose(s.owner, .inherit, argv);
 
     const zp = try gpa.create(ZigProcess);
     defer if (!watch) gpa.destroy(zp);
@@ -515,7 +515,7 @@ pub fn installFile(s: *Step, src_lazy_path: Build.LazyPath, dest_path: []const u
     const b = s.owner;
     const io = b.graph.io;
     const src_path = src_lazy_path.getPath3(b, s);
-    try handleVerbose(b, null, &.{ "install", "-C", b.fmt("{f}", .{src_path}), dest_path });
+    try handleVerbose(b, .inherit, &.{ "install", "-C", b.fmt("{f}", .{src_path}), dest_path });
     return Io.Dir.updateFile(src_path.root_dir.handle, io, src_path.sub_path, .cwd(), dest_path, .{}) catch |err|
         return s.fail("unable to update file from '{f}' to '{s}': {t}", .{ src_path, dest_path, err });
 }
@@ -524,7 +524,7 @@ pub fn installFile(s: *Step, src_lazy_path: Build.LazyPath, dest_path: []const u
 pub fn installDir(s: *Step, dest_path: []const u8) !Io.Dir.CreatePathStatus {
     const b = s.owner;
     const io = b.graph.io;
-    try handleVerbose(b, null, &.{ "install", "-d", dest_path });
+    try handleVerbose(b, .inherit, &.{ "install", "-d", dest_path });
     return Io.Dir.cwd().createDirPathStatus(io, dest_path, .default_dir) catch |err|
         return s.fail("unable to create dir '{s}': {t}", .{ dest_path, err });
 }
@@ -700,15 +700,15 @@ fn sendMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag) !void {
 
 pub fn handleVerbose(
     b: *Build,
-    opt_cwd: ?[]const u8,
+    cwd: std.process.Child.Cwd,
     argv: []const []const u8,
 ) error{OutOfMemory}!void {
-    return handleVerbose2(b, opt_cwd, null, argv);
+    return handleVerbose2(b, cwd, null, argv);
 }
 
 pub fn handleVerbose2(
     b: *Build,
-    opt_cwd: ?[]const u8,
+    cwd: std.process.Child.Cwd,
     opt_env: ?*const std.process.Environ.Map,
     argv: []const []const u8,
 ) error{OutOfMemory}!void {
@@ -716,7 +716,7 @@ pub fn handleVerbose2(
         const graph = b.graph;
         // Intention of verbose is to print all sub-process command lines to
         // stderr before spawning them.
-        const text = try allocPrintCmd(b.allocator, opt_cwd, if (opt_env) |env| .{
+        const text = try allocPrintCmd(b.allocator, cwd, if (opt_env) |env| .{
             .child = env,
             .parent = &graph.environ_map,
         } else null, argv);
@@ -751,7 +751,7 @@ pub fn handleChildProcessTerm(s: *Step, term: std.process.Child.Term) error{ Mak
 
 pub fn allocPrintCmd(
     gpa: Allocator,
-    opt_cwd: ?[]const u8,
+    cwd: std.process.Child.Cwd,
     opt_env: ?struct {
         child: *const std.process.Environ.Map,
         parent: *const std.process.Environ.Map,
@@ -796,7 +796,11 @@ pub fn allocPrintCmd(
     var aw: Io.Writer.Allocating = .init(gpa);
     defer aw.deinit();
     const writer = &aw.writer;
-    if (opt_cwd) |cwd| writer.print("cd {s} && ", .{cwd}) catch return error.OutOfMemory;
+    switch (cwd) {
+        .inherit => {},
+        .path => |path| writer.print("cd {s} && ", .{path}) catch return error.OutOfMemory,
+        .dir => @panic("TODO"),
+    }
     if (opt_env) |env| {
         var it = env.child.iterator();
         while (it.next()) |entry| {
diff --git a/lib/std/Build/Step/InstallArtifact.zig b/lib/std/Build/Step/InstallArtifact.zig
index 019d465f01d6b2784e337ed410bd2b073bffb210..c3c9d6c85395358a91eddfc31b9f0b0872b77fd7 100644
--- a/lib/std/Build/Step/InstallArtifact.zig
+++ b/lib/std/Build/Step/InstallArtifact.zig
@@ -187,7 +187,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                     const full_dest_path = b.pathJoin(&.{ full_h_prefix, entry.path });
                     switch (entry.kind) {
                         .directory => {
-                            try Step.handleVerbose(b, null, &.{ "install", "-d", full_dest_path });
+                            try Step.handleVerbose(b, .inherit, &.{ "install", "-d", full_dest_path });
                             const p = try step.installDir(full_dest_path);
                             all_cached = all_cached and p == .existed;
                         },
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 68d0ec480c77e7099a8230dd422ad0b21f155bf9..3f5df9f2ae351db03282648d3ce38c488f8b3288 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1227,7 +1227,7 @@ fn runCommand(
     const gpa = options.gpa;
     const io = b.graph.io;
 
-    const cwd: ?[]const u8 = if (run.cwd) |lazy_cwd| lazy_cwd.getPath2(b, step) else null;
+    const cwd: process.Child.Cwd = if (run.cwd) |lazy_cwd| .{ .path = lazy_cwd.getPath2(b, step) } else .inherit;
 
     try step.handleChildProcUnsupported();
     try Step.handleVerbose2(step.owner, cwd, run.environ_map, argv);
@@ -1549,7 +1549,7 @@ fn spawnChildAndCollect(
         assert(run.stdio == .zig_test);
     }
 
-    const child_cwd = if (run.cwd) |lazy_cwd| lazy_cwd.getPath2(b, &run.step) else null;
+    const child_cwd: process.Child.Cwd = if (run.cwd) |lazy_cwd| .{ .path = lazy_cwd.getPath2(b, &run.step) } else .inherit;
 
     // If an error occurs, it's caused by this command:
     assert(run.step.result_failed_command == null);
diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index 1f380b6c50d4f1aae6066362f37a4e2f6cd9c627..7205291400ab81d6a693f6361ebc6c2975ce9a40 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -652,7 +652,7 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
             if (code != 0) {
                 log.err(
                     "the following command exited with error code {d}:\n{s}",
-                    .{ code, try Build.Step.allocPrintCmd(arena, null, null, argv.items) },
+                    .{ code, try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
                 );
                 return error.WasmCompilationFailed;
             }
@@ -660,14 +660,14 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
         .signal => |sig| {
             log.err(
                 "the following command terminated with signal {t}:\n{s}",
-                .{ sig, try Build.Step.allocPrintCmd(arena, null, null, argv.items) },
+                .{ sig, try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
             );
             return error.WasmCompilationFailed;
         },
         .stopped, .unknown => {
             log.err(
                 "the following command terminated unexpectedly:\n{s}",
-                .{try Build.Step.allocPrintCmd(arena, null, null, argv.items)},
+                .{try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items)},
             );
             return error.WasmCompilationFailed;
         },
@@ -677,14 +677,14 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
         try result_error_bundle.renderToStderr(io, .{}, .auto);
         log.err("the following command failed with {d} compilation errors:\n{s}", .{
             result_error_bundle.errorMessageCount(),
-            try Build.Step.allocPrintCmd(arena, null, null, argv.items),
+            try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items),
         });
         return error.WasmCompilationFailed;
     }
 
     const base_path = result orelse {
         log.err("child process failed to report result\n{s}", .{
-            try Build.Step.allocPrintCmd(arena, null, null, argv.items),
+            try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items),
         });
         return error.WasmCompilationFailed;
     };
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 60be4a8d4c8211d9045e20ee291fab0541f441bb..298c3c167f6e6c044d41cf1e83e03f3664e54df6 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -14606,10 +14606,14 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
         setUpChildIo(options.stdout, stdout_pipe[1], posix.STDOUT_FILENO, dev_null_fd) catch |err| forkBail(ep1, err);
         setUpChildIo(options.stderr, stderr_pipe[1], posix.STDERR_FILENO, dev_null_fd) catch |err| forkBail(ep1, err);
 
-        if (options.cwd_dir) |cwd| {
-            fchdir(cwd.handle) catch |err| forkBail(ep1, err);
-        } else if (options.cwd) |cwd| {
-            chdir(cwd) catch |err| forkBail(ep1, err);
+        switch (options.cwd) {
+            .inherit => {},
+            .dir => |cwd| {
+                fchdir(cwd.handle) catch |err| forkBail(ep1, err);
+            },
+            .path => |cwd| {
+                chdir(cwd) catch |err| forkBail(ep1, err);
+            },
         }
 
         // Must happen after fchdir above, the cwd file descriptor might be
@@ -15194,23 +15198,25 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     const arena = arena_allocator.allocator();
 
     const cwd_w = cwd_w: {
-        if (options.cwd_dir) |cwd_dir| {
-            var dir_path_buffer = try arena.alloc(u16, windows.PATH_MAX_WIDE + 1);
-            // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
-            try Thread.checkCancel();
-            const dir_path = try windows.GetFinalPathNameByHandle(
-                cwd_dir.handle,
-                .{},
-                dir_path_buffer[0..windows.PATH_MAX_WIDE],
-            );
-            dir_path_buffer[dir_path.len] = 0;
-            // Shrink the allocation down to just the path buffer + sentinel
-            dir_path_buffer = try arena.realloc(dir_path_buffer, dir_path.len + 1);
-            break :cwd_w dir_path_buffer[0..dir_path.len :0];
-        } else if (options.cwd) |cwd| {
-            break :cwd_w try std.unicode.wtf8ToWtf16LeAllocZ(arena, cwd);
-        } else {
-            break :cwd_w null;
+        switch (options.cwd) {
+            .inherit => break :cwd_w null,
+            .dir => |cwd_dir| {
+                var dir_path_buffer = try arena.alloc(u16, windows.PATH_MAX_WIDE + 1);
+                // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
+                try Thread.checkCancel();
+                const dir_path = try windows.GetFinalPathNameByHandle(
+                    cwd_dir.handle,
+                    .{},
+                    dir_path_buffer[0..windows.PATH_MAX_WIDE],
+                );
+                dir_path_buffer[dir_path.len] = 0;
+                // Shrink the allocation down to just the path buffer + sentinel
+                dir_path_buffer = try arena.realloc(dir_path_buffer, dir_path.len + 1);
+                break :cwd_w dir_path_buffer[0..dir_path.len :0];
+            },
+            .path => |cwd| {
+                break :cwd_w try std.unicode.wtf8ToWtf16LeAllocZ(arena, cwd);
+            },
         }
     };
     const cwd_w_ptr = if (cwd_w) |cwd| cwd.ptr else null;
diff --git a/lib/std/process.zig b/lib/std/process.zig
index d4e5e689316db4d356c25362bfae6b0aea844f18..d09239dbc2e0de28b0fd9f51a886b241fdbf4b21 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -368,11 +368,7 @@ pub const SpawnOptions = struct {
     argv: []const []const u8,
 
     /// Set to change the current working directory when spawning the child process.
-    cwd: ?[]const u8 = null,
-    /// Set to change the current working directory when spawning the child process.
-    /// This is not yet implemented for Windows. See https://github.com/ziglang/zig/issues/5190
-    /// Once that is done, `cwd` will be deprecated in favor of this field.
-    cwd_dir: ?Io.Dir = null,
+    cwd: Child.Cwd = .inherit,
     /// Replaces the child environment when provided. The PATH value from here
     /// is not used to resolve `argv[0]`; that resolution always uses parent
     /// environment.
@@ -468,11 +464,7 @@ pub const RunOptions = struct {
     reserve_amount: usize = 64,
 
     /// Set to change the current working directory when spawning the child process.
-    cwd: ?[]const u8 = null,
-    /// Set to change the current working directory when spawning the child process.
-    /// This is not yet implemented for Windows. See https://github.com/ziglang/zig/issues/5190
-    /// Once that is done, `cwd` will be deprecated in favor of this field.
-    cwd_dir: ?Io.Dir = null,
+    cwd: Child.Cwd = .inherit,
     /// Replaces the child environment when provided. The PATH value from here
     /// is not used to resolve `argv[0]`; that resolution always uses parent
     /// environment.
@@ -506,7 +498,6 @@ pub fn run(gpa: Allocator, io: Io, options: RunOptions) RunError!RunResult {
     var child = try spawn(io, .{
         .argv = options.argv,
         .cwd = options.cwd,
-        .cwd_dir = options.cwd_dir,
         .environ_map = options.environ_map,
         .expand_arg0 = options.expand_arg0,
         .progress_node = options.progress_node,
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index c87d221a95c4ecdff81b467f8db72495a32a642f..7ce3143b362de6f5f837f7e513304d54b47fea4b 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -98,6 +98,17 @@ pub const Term = union(enum) {
     unknown: u32,
 };
 
+pub const Cwd = union(enum) {
+    /// CWD of the child is the same as the current CWD.
+    inherit,
+    /// On POSIX systems, `fchdir` is called after `fork` using this handle.
+    /// On Windows, the path is inferred from the provided handle and that path is used when calling `CreateProcessW`.
+    dir: Io.Dir,
+    /// On POSIX systems, `chdir` is called after `fork` using this path.
+    /// On Windows, this path is used when calling `CreateProcessW`.
+    path: []const u8,
+};
+
 /// Requests for the operating system to forcibly terminate the child process,
 /// then blocks until it terminates, then cleans up all resources.
 ///
diff --git a/test/standalone/windows_paths/test.zig b/test/standalone/windows_paths/test.zig
index 1170de47ac7245480a48585a20089295d4cd82a4..36f2a8be0e7659d783db4fb64ea79ed3c87c6bed 100644
--- a/test/standalone/windows_paths/test.zig
+++ b/test/standalone/windows_paths/test.zig
@@ -32,39 +32,39 @@ pub fn main(init: std.process.Init) !void {
 
         // With the special =X: environment variable set, drive-relative paths that
         // don't match the CWD's drive letter are resolved against that env var.
-        try checkRelative(arena, io, "..\\..\\bar", &.{ exe_path, drive_rel, drive_abs }, null, &alt_drive_env_map);
-        try checkRelative(arena, io, "..\\baz\\foo", &.{ exe_path, drive_abs, drive_rel }, null, &alt_drive_env_map);
+        try checkRelative(arena, io, "..\\..\\bar", &.{ exe_path, drive_rel, drive_abs }, &alt_drive_env_map);
+        try checkRelative(arena, io, "..\\baz\\foo", &.{ exe_path, drive_abs, drive_rel }, &alt_drive_env_map);
 
         // Without that environment variable set, drive-relative paths that don't match the
         // CWD's drive letter are resolved against the root of the drive.
-        try checkRelative(arena, io, "..\\bar", &.{ exe_path, drive_rel, drive_abs }, null, &empty_env);
-        try checkRelative(arena, io, "..\\foo", &.{ exe_path, drive_abs, drive_rel }, null, &empty_env);
+        try checkRelative(arena, io, "..\\bar", &.{ exe_path, drive_rel, drive_abs }, &empty_env);
+        try checkRelative(arena, io, "..\\foo", &.{ exe_path, drive_abs, drive_rel }, &empty_env);
 
         // Bare drive-relative path with no components
-        try checkRelative(arena, io, "bar", &.{ exe_path, drive_rel[0..2], drive_abs }, null, &empty_env);
-        try checkRelative(arena, io, "..", &.{ exe_path, drive_abs, drive_rel[0..2] }, null, &empty_env);
+        try checkRelative(arena, io, "bar", &.{ exe_path, drive_rel[0..2], drive_abs }, &empty_env);
+        try checkRelative(arena, io, "..", &.{ exe_path, drive_abs, drive_rel[0..2] }, &empty_env);
 
         // Bare drive-relative path with no components, drive-CWD set
-        try checkRelative(arena, io, "..\\bar", &.{ exe_path, drive_rel[0..2], drive_abs }, null, &alt_drive_env_map);
-        try checkRelative(arena, io, "..\\baz", &.{ exe_path, drive_abs, drive_rel[0..2] }, null, &alt_drive_env_map);
+        try checkRelative(arena, io, "..\\bar", &.{ exe_path, drive_rel[0..2], drive_abs }, &alt_drive_env_map);
+        try checkRelative(arena, io, "..\\baz", &.{ exe_path, drive_abs, drive_rel[0..2] }, &alt_drive_env_map);
 
         // Bare drive-relative path relative to the CWD should be equivalent if drive-CWD is set
-        try checkRelative(arena, io, "", &.{ exe_path, alt_drive_cwd, drive_rel[0..2] }, null, &alt_drive_env_map);
-        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], alt_drive_cwd }, null, &alt_drive_env_map);
+        try checkRelative(arena, io, "", &.{ exe_path, alt_drive_cwd, drive_rel[0..2] }, &alt_drive_env_map);
+        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], alt_drive_cwd }, &alt_drive_env_map);
 
         // Bare drive-relative should always be equivalent to itself
-        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, null, &alt_drive_env_map);
-        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, null, &alt_drive_env_map);
-        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, null, &empty_env);
-        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, null, &empty_env);
+        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, &alt_drive_env_map);
+        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, &alt_drive_env_map);
+        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, &empty_env);
+        try checkRelative(arena, io, "", &.{ exe_path, drive_rel[0..2], drive_rel[0..2] }, &empty_env);
     }
 
     if (parsed_cwd_path.kind == .unc_absolute) {
         const drive_abs_path = try std.fmt.allocPrint(arena, "{c}:\\foo\\bar", .{alt_drive_letter});
 
         {
-            try checkRelative(arena, io, drive_abs_path, &.{ exe_path, cwd_path, drive_abs_path }, null, &empty_env);
-            try checkRelative(arena, io, cwd_path, &.{ exe_path, drive_abs_path, cwd_path }, null, &empty_env);
+            try checkRelative(arena, io, drive_abs_path, &.{ exe_path, cwd_path, drive_abs_path }, &empty_env);
+            try checkRelative(arena, io, cwd_path, &.{ exe_path, drive_abs_path, cwd_path }, &empty_env);
         }
     } else if (parsed_cwd_path.kind == .drive_absolute) {
         const cur_drive_letter = parsed_cwd_path.root[0];
@@ -72,14 +72,14 @@ pub fn main(init: std.process.Init) !void {
         const unc_cwd = try std.fmt.allocPrint(arena, "\\\\127.0.0.1\\{c}$\\{s}", .{ cur_drive_letter, path_beyond_root });
 
         {
-            try checkRelative(arena, io, cwd_path, &.{ exe_path, unc_cwd, cwd_path }, null, &empty_env);
-            try checkRelative(arena, io, unc_cwd, &.{ exe_path, cwd_path, unc_cwd }, null, &empty_env);
+            try checkRelative(arena, io, cwd_path, &.{ exe_path, unc_cwd, cwd_path }, &empty_env);
+            try checkRelative(arena, io, unc_cwd, &.{ exe_path, cwd_path, unc_cwd }, &empty_env);
         }
         {
             const drive_abs = cwd_path;
             const drive_rel = parsed_cwd_path.root[0..2];
-            try checkRelative(arena, io, "", &.{ exe_path, drive_abs, drive_rel }, null, &empty_env);
-            try checkRelative(arena, io, "", &.{ exe_path, drive_rel, drive_abs }, null, &empty_env);
+            try checkRelative(arena, io, "", &.{ exe_path, drive_abs, drive_rel }, &empty_env);
+            try checkRelative(arena, io, "", &.{ exe_path, drive_rel, drive_abs }, &empty_env);
         }
     } else {
         return error.UnexpectedPathType;
@@ -91,12 +91,10 @@ fn checkRelative(
     io: Io,
     expected_stdout: []const u8,
     argv: []const []const u8,
-    cwd: ?[]const u8,
     environ_map: ?*const std.process.Environ.Map,
 ) !void {
     const result = try std.process.run(allocator, io, .{
         .argv = argv,
-        .cwd = cwd,
         .environ_map = environ_map,
     });
     defer allocator.free(result.stdout);
diff --git a/test/standalone/windows_spawn/main.zig b/test/standalone/windows_spawn/main.zig
index 4b37e3cf6ee28066e2424725d5e0412ab5f6764d..18c9a68c57b9194e72c8f8b29859dd382307cb65 100644
--- a/test/standalone/windows_spawn/main.zig
+++ b/test/standalone/windows_spawn/main.zig
@@ -207,10 +207,20 @@ fn testExecError(err: anyerror, gpa: Allocator, io: Io, command: []const u8) !vo
 }
 
 fn testExec(gpa: Allocator, io: Io, command: []const u8, expected_stdout: []const u8) !void {
-    return testExecWithCwd(gpa, io, command, null, expected_stdout);
+    return testExecWithCwdInner(gpa, io, command, .inherit, expected_stdout);
 }
 
-fn testExecWithCwd(gpa: Allocator, io: Io, command: []const u8, cwd: ?[]const u8, expected_stdout: []const u8) !void {
+fn testExecWithCwd(gpa: Allocator, io: Io, command: []const u8, cwd: []const u8, expected_stdout: []const u8) !void {
+    // Test by passing CWD as both a path and a Dir
+    try testExecWithCwdInner(gpa, io, command, .{ .path = cwd }, expected_stdout);
+
+    var cwd_dir = try Io.Dir.cwd().openDir(io, cwd, .{});
+    defer cwd_dir.close(io);
+
+    try testExecWithCwdInner(gpa, io, command, .{ .dir = cwd_dir }, expected_stdout);
+}
+
+fn testExecWithCwdInner(gpa: Allocator, io: Io, command: []const u8, cwd: std.process.Child.Cwd, expected_stdout: []const u8) !void {
     const result = try std.process.run(gpa, io, .{
         .argv = &[_][]const u8{command},
         .cwd = cwd,
diff --git a/tools/doctest.zig b/tools/doctest.zig
index 97a9a0be3f27e079d5028403749ba68bb3b7240f..0e29b2b983f6f5915fae5f9ae0fc759ba1abcdfa 100644
--- a/tools/doctest.zig
+++ b/tools/doctest.zig
@@ -199,7 +199,7 @@ fn printOutput(
             if (expected_outcome == .build_fail) {
                 const result = try process.run(arena, io, .{
                     .argv = build_args.items,
-                    .cwd = tmp_dir_path,
+                    .cwd = .{ .path = tmp_dir_path },
                     .environ_map = environ_map,
                 });
                 switch (result.term) {
@@ -255,7 +255,7 @@ fn printOutput(
                 const result = try process.run(arena, io, .{
                     .argv = run_args,
                     .environ_map = environ_map,
-                    .cwd = tmp_dir_path,
+                    .cwd = .{ .path = tmp_dir_path },
                 });
                 switch (result.term) {
                     .exited => |exit_code| {
@@ -373,7 +373,7 @@ fn printOutput(
             const result = try process.run(arena, io, .{
                 .argv = test_args.items,
                 .environ_map = environ_map,
-                .cwd = tmp_dir_path,
+                .cwd = .{ .path = tmp_dir_path },
             });
             switch (result.term) {
                 .exited => |exit_code| {
@@ -428,7 +428,7 @@ fn printOutput(
             const result = try process.run(arena, io, .{
                 .argv = test_args.items,
                 .environ_map = environ_map,
-                .cwd = tmp_dir_path,
+                .cwd = .{ .path = tmp_dir_path },
             });
             switch (result.term) {
                 .exited => |exit_code| {
@@ -503,7 +503,7 @@ fn printOutput(
                 const result = try process.run(arena, io, .{
                     .argv = build_args.items,
                     .environ_map = environ_map,
-                    .cwd = tmp_dir_path,
+                    .cwd = .{ .path = tmp_dir_path },
                 });
                 switch (result.term) {
                     .exited => |exit_code| {
@@ -1126,7 +1126,7 @@ fn run(
     const result = try process.run(allocator, io, .{
         .argv = args,
         .environ_map = environ_map,
-        .cwd = cwd,
+        .cwd = .{ .path = cwd },
     });
     switch (result.term) {
         .exited => |exit_code| {
diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index 840faf6f275aad2dc662183bd162698df443ee2d..171af570361c4986b3ddd75ac909d2ba6b1a7551 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -202,8 +202,7 @@ pub fn main(init: std.process.Init) !void {
             .stdout = .pipe,
             .stderr = .pipe,
             .progress_node = zig_prog_node,
-            .cwd_dir = tmp_dir,
-            .cwd = tmp_dir_path,
+            .cwd = .{ .path = tmp_dir_path },
         });
         defer child.kill(io);
 
@@ -533,8 +532,7 @@ const Eval = struct {
 
         const result = std.process.run(eval.arena, io, .{
             .argv = argv,
-            .cwd_dir = eval.tmp_dir,
-            .cwd = eval.tmp_dir_path,
+            .cwd = .{ .path = eval.tmp_dir_path },
         }) catch |err| {
             if (is_foreign) {
                 // Chances are the foreign executor isn't available. Skip this evaluation.
@@ -626,8 +624,7 @@ const Eval = struct {
 
         const result = std.process.run(eval.arena, eval.io, .{
             .argv = eval.cc_child_args.items,
-            .cwd_dir = eval.tmp_dir,
-            .cwd = eval.tmp_dir_path,
+            .cwd = .{ .path = eval.tmp_dir_path },
             .progress_node = child_prog_node,
         }) catch |err| {
             eval.fatal("failed to spawn zig cc for '{s}': {t}", .{ c_path, err });
-- 
2.54.0


From 633eb247ab819d7120fea2e0178100cc8fca8ac3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 14:57:27 -0800
Subject: [PATCH 171/499] std.Io.Event: fix single-threaded implementation

---
 lib/std/Io.zig          | 2 +-
 lib/std/Io/Threaded.zig | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index bb9610c0904b670b1eff8933efac16bd3138eca2..ea182c680390e17133749ec28ddd520c32b5c21d 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1467,7 +1467,7 @@ pub const Event = enum(u32) {
     pub fn waitTimeout(event: *Event, io: Io, timeout: Timeout) WaitTimeoutError!void {
         if (@cmpxchgStrong(Event, event, .unset, .waiting, .acquire, .acquire)) |prev| switch (prev) {
             .unset => unreachable,
-            .waiting => assert(!builtin.single_threaded), // invalid state
+            .waiting => {},
             .is_set => return,
         };
         errdefer {
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 46ff3a7f38df43edaa06cca3fad6b043d913b95f..ca7127128766286a4e9b0dc9bae758239b8a4da0 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2461,7 +2461,10 @@ fn cancel(
 }
 
 fn futexWait(userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Io.Timeout) Io.Cancelable!void {
-    if (builtin.single_threaded) unreachable; // Deadlock.
+    if (builtin.single_threaded) {
+        assert(timeout != .none); // Deadlock.
+        return;
+    }
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const t_io = ioBasic(t);
     const timeout_ns: ?u64 = ns: {
@@ -2479,7 +2482,7 @@ fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32)
 }
 
 fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
-    if (builtin.single_threaded) unreachable; // Nothing to wake up.
+    if (builtin.single_threaded) return; // Nothing to wake up.
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
     Thread.futexWake(ptr, max_waiters);
-- 
2.54.0


From 1cd3af43fd74a8481b35d58c351ae056c1cba362 Mon Sep 17 00:00:00 2001
From: Krzysztof Antonowski <krzysztofantonowski@proton.me>
Date: Mon, 2 Feb 2026 22:19:19 +0100
Subject: [PATCH 172/499] std.Io.Threaded: implement CPU-based clocks on
 Windows (#31093)

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31093
Co-authored-by: Krzysztof Antonowski <krzysztofantonowski@proton.me>
Co-committed-by: Krzysztof Antonowski <krzysztofantonowski@proton.me>
---
 lib/std/Io/Threaded.zig | 37 ++++++++++++++++++++++++++++++++++---
 lib/std/os/windows.zig  |  8 ++++++++
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 298c3c167f6e6c044d41cf1e83e03f3664e54df6..3f4affcc5ca17b83d5cb99b398b735c363cd4919 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -10849,9 +10849,40 @@ fn nowWindows(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
             const result = (@as(u96, qpc) * scale) >> 32;
             return .{ .nanoseconds = @intCast(result) };
         },
-        .cpu_process,
-        .cpu_thread,
-        => return error.UnsupportedClock,
+        .cpu_process => {
+            const handle = windows.GetCurrentProcess();
+            var times: windows.KERNEL_USER_TIMES = undefined;
+
+            // https://github.com/reactos/reactos/blob/master/ntoskrnl/ps/query.c#L442-L485
+            if (windows.ntdll.NtQueryInformationProcess(
+                handle,
+                windows.PROCESSINFOCLASS.Times,
+                &times,
+                @sizeOf(windows.KERNEL_USER_TIMES),
+                null,
+            ) != .SUCCESS)
+                return error.Unexpected;
+
+            const sum = @as(i96, times.UserTime) + @as(i96, times.KernelTime);
+            return .{ .nanoseconds = sum * 100 };
+        },
+        .cpu_thread => {
+            const handle = windows.GetCurrentThread();
+            var times: windows.KERNEL_USER_TIMES = undefined;
+
+            // https://github.com/reactos/reactos/blob/master/ntoskrnl/ps/query.c#L2971-L3019
+            if (windows.ntdll.NtQueryInformationThread(
+                handle,
+                windows.THREADINFOCLASS.Times,
+                &times,
+                @sizeOf(windows.KERNEL_USER_TIMES),
+                null,
+            ) != .SUCCESS)
+                return error.Unexpected;
+
+            const sum = @as(i96, times.UserTime) + @as(i96, times.KernelTime);
+            return .{ .nanoseconds = sum * 100 };
+        },
     }
 }
 
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index b9653b3ac9979d9eb5144822fb7ed27f802a55a7..0f57eed766eba130ece4bafc3b76e5684de2239b 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -6191,6 +6191,14 @@ pub const PROCESS_BASIC_INFORMATION = extern struct {
     InheritedFromUniqueProcessId: ULONG_PTR,
 };
 
+// https://github.com/reactos/reactos/blob/master/sdk/include/ndk/pstypes.h#L977-L983
+pub const KERNEL_USER_TIMES = extern struct {
+    CreationTime: LARGE_INTEGER,
+    ExitTime: LARGE_INTEGER,
+    KernelTime: LARGE_INTEGER,
+    UserTime: LARGE_INTEGER,
+};
+
 pub const ReadMemoryError = error{
     Unexpected,
 };
-- 
2.54.0


From eb74e23e7ba4f2000bbe4e908bf74c5c9dd7adcc Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 16:13:51 -0800
Subject: [PATCH 173/499] std.Io.Threaded: sever dependency on std.Thread Mutex
 and Condition

---
 lib/std/Io/Threaded.zig | 253 +++++++++++++++++++++++++++++-----------
 1 file changed, 186 insertions(+), 67 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 4b1ebbc59b26339ae5783ee14fe478b9a682f256..11708af071376e65f1a120789fb6020271958ae9 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -29,8 +29,8 @@ const ws2_32 = std.os.windows.ws2_32;
 /// * scanning environment variables on some targets
 /// * memory-mapping when mmap or equivalent is not available
 allocator: Allocator,
-mutex: std.Thread.Mutex = .{},
-cond: std.Thread.Condition = .{},
+mutex: Io.Mutex = .init,
+cond: Io.Condition = .init,
 run_queue: std.SinglyLinkedList = .{},
 join_requested: bool = false,
 stack_size: usize,
@@ -1486,8 +1486,8 @@ var global_single_threaded_instance: Threaded = .init_single_threaded;
 pub const global_single_threaded: *Threaded = &global_single_threaded_instance;
 
 pub fn setAsyncLimit(t: *Threaded, new_limit: Io.Limit) void {
-    t.mutex.lock();
-    defer t.mutex.unlock();
+    mutexLockUncancelable(&t.mutex);
+    defer mutexUnlock(&t.mutex);
     t.async_limit = new_limit;
 }
 
@@ -1508,11 +1508,11 @@ pub fn deinit(t: *Threaded) void {
 fn join(t: *Threaded) void {
     if (builtin.single_threaded) return;
     {
-        t.mutex.lock();
-        defer t.mutex.unlock();
+        mutexLockUncancelable(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         t.join_requested = true;
     }
-    t.cond.broadcast();
+    condBroadcast(&t.cond);
     t.wait_group.wait();
 }
 
@@ -1574,20 +1574,20 @@ fn worker(t: *Threaded) void {
 
     defer t.wait_group.finish();
 
-    t.mutex.lock();
-    defer t.mutex.unlock();
+    mutexLockUncancelable(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     while (true) {
         while (t.run_queue.popFirst()) |runnable_node| {
-            t.mutex.unlock();
+            mutexUnlock(&t.mutex);
             thread.cancel_protection = .unblocked;
             const runnable: *Runnable = @fieldParentPtr("node", runnable_node);
             runnable.startFn(runnable, &thread, t);
-            t.mutex.lock();
+            mutexLockUncancelable(&t.mutex);
             t.busy_count -= 1;
         }
         if (t.join_requested) break;
-        t.cond.wait(&t.mutex);
+        condWait(&t.cond, &t.mutex);
     }
 }
 
@@ -2004,12 +2004,12 @@ fn async(
         },
     };
 
-    t.mutex.lock();
+    mutexLockUncancelable(&t.mutex);
 
     const busy_count = t.busy_count;
 
     if (busy_count >= @intFromEnum(t.async_limit)) {
-        t.mutex.unlock();
+        mutexUnlock(&t.mutex);
         future.destroy(gpa);
         start(context.ptr, result.ptr);
         return null;
@@ -2023,7 +2023,7 @@ fn async(
         const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
             t.wait_group.finish();
             t.busy_count = busy_count;
-            t.mutex.unlock();
+            mutexUnlock(&t.mutex);
             future.destroy(gpa);
             start(context.ptr, result.ptr);
             return null;
@@ -2033,8 +2033,8 @@ fn async(
 
     t.run_queue.prepend(&future.runnable.node);
 
-    t.mutex.unlock();
-    t.cond.signal();
+    mutexUnlock(&t.mutex);
+    condSignal(&t.cond);
     return @ptrCast(future);
 }
 
@@ -2056,8 +2056,8 @@ fn concurrent(
     };
     errdefer future.destroy(gpa);
 
-    t.mutex.lock();
-    defer t.mutex.unlock();
+    mutexLockUncancelable(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     const busy_count = t.busy_count;
 
@@ -2080,7 +2080,7 @@ fn concurrent(
 
     t.run_queue.prepend(&future.runnable.node);
 
-    t.cond.signal();
+    condSignal(&t.cond);
     return @ptrCast(future);
 }
 
@@ -2101,12 +2101,12 @@ fn groupAsync(
         error.OutOfMemory => return groupAsyncEager(start, context.ptr),
     };
 
-    t.mutex.lock();
+    mutexLockUncancelable(&t.mutex);
 
     const busy_count = t.busy_count;
 
     if (busy_count >= @intFromEnum(t.async_limit)) {
-        t.mutex.unlock();
+        mutexUnlock(&t.mutex);
         task.destroy(gpa);
         return groupAsyncEager(start, context.ptr);
     }
@@ -2119,7 +2119,7 @@ fn groupAsync(
         const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
             t.wait_group.finish();
             t.busy_count = busy_count;
-            t.mutex.unlock();
+            mutexUnlock(&t.mutex);
             task.destroy(gpa);
             return groupAsyncEager(start, context.ptr);
         };
@@ -2136,8 +2136,8 @@ fn groupAsync(
     }, .monotonic);
     t.run_queue.prepend(&task.runnable.node);
 
-    t.mutex.unlock();
-    t.cond.signal();
+    mutexUnlock(&t.mutex);
+    condSignal(&t.cond);
 }
 fn groupAsyncEager(
     start: *const fn (context: *const anyopaque) Io.Cancelable!void,
@@ -2201,8 +2201,8 @@ fn groupConcurrent(
     };
     errdefer task.destroy(gpa);
 
-    t.mutex.lock();
-    defer t.mutex.unlock();
+    mutexLockUncancelable(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     const busy_count = t.busy_count;
 
@@ -2233,7 +2233,7 @@ fn groupConcurrent(
     }, .monotonic);
     t.run_queue.prepend(&task.runnable.node);
 
-    t.cond.signal();
+    condSignal(&t.cond);
 }
 
 fn groupAwait(userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *anyopaque) Io.Cancelable!void {
@@ -3838,8 +3838,8 @@ fn fileStatWindows(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
 
 fn systemBasicInformation(t: *Threaded) ?*const windows.SYSTEM_BASIC_INFORMATION {
     if (!t.system_basic_information.initialized.load(.acquire)) {
-        t.mutex.lock();
-        defer t.mutex.unlock();
+        mutexLockUncancelable(&t.mutex);
+        defer mutexUnlock(&t.mutex);
 
         switch (windows.ntdll.NtQuerySystemInformation(
             .SystemBasicInformation,
@@ -14299,10 +14299,9 @@ const Wsa = struct {
 };
 
 fn initializeWsa(t: *Threaded) error{ NetworkDown, Canceled }!void {
-    const t_io = io(t);
     const wsa = &t.wsa;
-    try wsa.mutex.lock(t_io);
-    defer wsa.mutex.unlock(t_io);
+    try mutexLock(&wsa.mutex);
+    defer mutexUnlock(&wsa.mutex);
     switch (wsa.status) {
         .uninitialized => {
             var wsa_data: ws2_32.WSADATA = undefined;
@@ -14373,8 +14372,8 @@ const WindowsEnvironStrings = struct {
 };
 
 fn scanEnviron(t: *Threaded) void {
-    t.mutex.lock();
-    defer t.mutex.unlock();
+    mutexLockUncancelable(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     if (t.environ.initialized) return;
     t.environ.initialized = true;
@@ -14729,8 +14728,8 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
 
 fn getDevNullFd(t: *Threaded) !posix.fd_t {
     {
-        t.mutex.lock();
-        defer t.mutex.unlock();
+        mutexLockUncancelable(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         if (t.null_file.fd != -1) return t.null_file.fd;
     }
     const mode: u32 = 0;
@@ -14741,8 +14740,8 @@ fn getDevNullFd(t: *Threaded) !posix.fd_t {
             .SUCCESS => {
                 syscall.finish();
                 const fresh_fd: posix.fd_t = @intCast(rc);
-                t.mutex.lock(); // Another thread might have won the race.
-                defer t.mutex.unlock();
+                mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
+                defer mutexUnlock(&t.mutex);
                 if (t.null_file.fd != -1) {
                     posix.close(fresh_fd);
                     return t.null_file.fd;
@@ -15402,8 +15401,8 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
 
 fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     {
-        t.mutex.lock();
-        defer t.mutex.unlock();
+        mutexLockUncancelable(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         if (t.random_file.handle) |handle| return handle;
     }
 
@@ -15437,8 +15436,8 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     )) {
         .SUCCESS => {
             syscall.finish();
-            t.mutex.lock(); // Another thread might have won the race.
-            defer t.mutex.unlock();
+            mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlock(&t.mutex);
             if (t.random_file.handle) |prev_handle| {
                 windows.CloseHandle(fresh_handle);
                 return prev_handle;
@@ -15458,8 +15457,8 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
 
 fn getNulHandle(t: *Threaded) !windows.HANDLE {
     {
-        t.mutex.lock();
-        defer t.mutex.unlock();
+        mutexLockUncancelable(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         if (t.null_file.handle) |handle| return handle;
     }
 
@@ -15505,8 +15504,8 @@ fn getNulHandle(t: *Threaded) !windows.HANDLE {
     )) {
         .SUCCESS => {
             syscall.finish();
-            t.mutex.lock(); // Another thread might have won the race.
-            defer t.mutex.unlock();
+            mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlock(&t.mutex);
             if (t.null_file.handle) |prev_handle| {
                 windows.CloseHandle(fresh_handle);
                 return prev_handle;
@@ -16551,15 +16550,15 @@ fn random(userdata: ?*anyopaque, buffer: []u8) void {
 }
 
 fn randomMainThread(t: *Threaded, buffer: []u8) void {
-    t.mutex.lock();
-    defer t.mutex.unlock();
+    mutexLockUncancelable(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     if (!t.csprng.isInitialized()) {
         @branchHint(.unlikely);
         var seed: [Csprng.seed_len]u8 = undefined;
         {
-            t.mutex.unlock();
-            defer t.mutex.lock();
+            mutexUnlock(&t.mutex);
+            defer mutexLockUncancelable(&t.mutex);
 
             const prev = swapCancelProtection(t, .blocked);
             defer _ = swapCancelProtection(t, prev);
@@ -16744,8 +16743,8 @@ fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
 
 fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
     {
-        t.mutex.lock();
-        defer t.mutex.unlock();
+        mutexLockUncancelable(&t.mutex);
+        defer mutexUnlock(&t.mutex);
 
         if (t.random_file.fd == -2) return error.EntropyUnavailable;
         if (t.random_file.fd != -1) return t.random_file.fd;
@@ -16785,8 +16784,8 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                     .SUCCESS => {
                         syscall.finish();
                         if (!statx.mask.TYPE) return error.EntropyUnavailable;
-                        t.mutex.lock(); // Another thread might have won the race.
-                        defer t.mutex.unlock();
+                        mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
+                        defer mutexUnlock(&t.mutex);
                         if (t.random_file.fd >= 0) {
                             posix.close(fd);
                             return t.random_file.fd;
@@ -16813,8 +16812,8 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                 switch (posix.errno(fstat_sym(fd, &stat))) {
                     .SUCCESS => {
                         syscall.finish();
-                        t.mutex.lock(); // Another thread might have won the race.
-                        defer t.mutex.unlock();
+                        mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
+                        defer mutexUnlock(&t.mutex);
                         if (t.random_file.fd >= 0) {
                             posix.close(fd);
                             return t.random_file.fd;
@@ -16878,13 +16877,13 @@ const parking_futex = struct {
         /// avoid a race.
         num_waiters: std.atomic.Value(u32),
         /// Protects `waiters`.
-        mutex: std.Thread.Mutex,
+        mutex: Io.Mutex,
         waiters: std.DoublyLinkedList,
 
         /// Prevent false sharing between buckets.
         _: void align(std.atomic.cache_line) = {},
 
-        const init: Bucket = .{ .num_waiters = .init(0), .mutex = .{}, .waiters = .{} };
+        const init: Bucket = .{ .num_waiters = .init(0), .mutex = .init, .waiters = .{} };
     };
 
     const Waiter = struct {
@@ -16947,8 +16946,8 @@ const parking_futex = struct {
         var status_buf: std.atomic.Value(Thread.Status) = undefined;
 
         {
-            bucket.mutex.lock();
-            defer bucket.mutex.unlock();
+            mutexLockUncancelable(&bucket.mutex);
+            defer mutexUnlock(&bucket.mutex);
 
             _ = bucket.num_waiters.fetchAdd(1, .acquire);
 
@@ -17017,8 +17016,8 @@ const parking_futex = struct {
                 .parked => {
                     // We saw a timeout and updated our own status from `.parked` to `.none`. It is
                     // our responsibility to remove `waiter` from `bucket`.
-                    bucket.mutex.lock();
-                    defer bucket.mutex.unlock();
+                    mutexLockUncancelable(&bucket.mutex);
+                    defer mutexUnlock(&bucket.mutex);
                     bucket.waiters.remove(&waiter.node);
                     assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
                 },
@@ -17057,8 +17056,8 @@ const parking_futex = struct {
         // of the critical section. This forms a singly-linked list of waiters using `Waiter.node.next`.
         var waking_head: ?*std.DoublyLinkedList.Node = null;
         {
-            bucket.mutex.lock();
-            defer bucket.mutex.unlock();
+            mutexLockUncancelable(&bucket.mutex);
+            defer mutexUnlock(&bucket.mutex);
 
             var num_removed: u32 = 0;
             var it = bucket.waiters.first;
@@ -17113,8 +17112,8 @@ const parking_futex = struct {
 
     fn removeCanceledWaiter(waiter: *Waiter) void {
         const bucket = bucketForAddress(waiter.address);
-        bucket.mutex.lock();
-        defer bucket.mutex.unlock();
+        mutexLockUncancelable(&bucket.mutex);
+        defer mutexUnlock(&bucket.mutex);
         bucket.waiters.remove(&waiter.node);
         assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
         waiter.done.store(true, .release); // potentially invalidates `waiter.*`
@@ -18102,3 +18101,123 @@ fn eventSet(event: *Io.Event) void {
         .waiting => Thread.futexWake(@ptrCast(event), std.math.maxInt(u32)),
     }
 }
+
+/// Same as `Io.Condition.broadcast` but avoids the VTable.
+fn condBroadcast(cond: *Io.Condition) void {
+    var prev_state = cond.state.load(.monotonic);
+    while (prev_state.waiters > prev_state.signals) {
+        @branchHint(.unlikely);
+        prev_state = cond.state.cmpxchgWeak(prev_state, .{
+            .waiters = prev_state.waiters,
+            .signals = prev_state.waiters,
+        }, .release, .monotonic) orelse {
+            // Update the epoch to tell the waiting threads that there are new signals for them.
+            // Note that a waiting thread could miss a take if *exactly* (1<<32)-1 wakes happen
+            // between it observing the epoch and sleeping on it, but this is extraordinarily
+            // unlikely due to the precise number of calls required.
+            _ = cond.epoch.fetchAdd(1, .release); // `.release` to ensure ordered after `state` update
+            Thread.futexWake(&cond.epoch.raw, prev_state.waiters - prev_state.signals);
+            return;
+        };
+    }
+}
+
+/// Same as `Io.Condition.signal` but avoids the VTable.
+fn condSignal(cond: *Io.Condition) void {
+    var prev_state = cond.state.load(.monotonic);
+    while (prev_state.waiters > prev_state.signals) {
+        @branchHint(.unlikely);
+        prev_state = cond.state.cmpxchgWeak(prev_state, .{
+            .waiters = prev_state.waiters,
+            .signals = prev_state.signals + 1,
+        }, .release, .monotonic) orelse {
+            // Update the epoch to tell the waiting threads that there are new signals for them.
+            // Note that a waiting thread could miss a take if *exactly* (1<<32)-1 wakes happen
+            // between it observing the epoch and sleeping on it, but this is extraordinarily
+            // unlikely due to the precise number of calls required.
+            _ = cond.epoch.fetchAdd(1, .release); // `.release` to ensure ordered after `state` update
+            Thread.futexWake(&cond.epoch.raw, 1);
+            return;
+        };
+    }
+}
+
+/// Same as `Io.Condition.waitUncancelable` but avoids the VTable.
+fn condWait(cond: *Io.Condition, mutex: *Io.Mutex) void {
+    var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
+
+    {
+        const prev_state = cond.state.fetchAdd(.{ .waiters = 1, .signals = 0 }, .monotonic);
+        assert(prev_state.waiters < std.math.maxInt(u16)); // overflow caused by too many waiters
+    }
+
+    mutexUnlock(mutex);
+    defer mutexLockUncancelable(mutex);
+
+    while (true) {
+        Thread.futexWaitUncancelable(&cond.epoch.raw, epoch, null);
+
+        epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
+
+        var prev_state = cond.state.load(.monotonic);
+        while (prev_state.signals > 0) {
+            prev_state = cond.state.cmpxchgWeak(prev_state, .{
+                .waiters = prev_state.waiters - 1,
+                .signals = prev_state.signals - 1,
+            }, .acquire, .monotonic) orelse {
+                // We successfully consumed a signal.
+                return;
+            };
+        }
+    }
+}
+
+/// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
+fn mutexLock(m: *Io.Mutex) Io.Cancelable!void {
+    const initial_state = m.state.cmpxchgWeak(
+        .unlocked,
+        .locked_once,
+        .acquire,
+        .monotonic,
+    ) orelse {
+        @branchHint(.likely);
+        return;
+    };
+    if (initial_state == .contended) {
+        try Thread.futexWait(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
+    }
+    while (m.state.swap(.contended, .acquire) != .unlocked) {
+        try Thread.futexWait(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
+    }
+}
+
+/// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
+fn mutexLockUncancelable(m: *Io.Mutex) void {
+    const initial_state = m.state.cmpxchgWeak(
+        .unlocked,
+        .locked_once,
+        .acquire,
+        .monotonic,
+    ) orelse {
+        @branchHint(.likely);
+        return;
+    };
+    if (initial_state == .contended) {
+        Thread.futexWaitUncancelable(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
+    }
+    while (m.state.swap(.contended, .acquire) != .unlocked) {
+        Thread.futexWaitUncancelable(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
+    }
+}
+
+/// Same as `Io.Mutex.unlock` but avoids the VTable.
+fn mutexUnlock(m: *Io.Mutex) void {
+    switch (m.state.swap(.unlocked, .release)) {
+        .unlocked => unreachable,
+        .locked_once => {},
+        .contended => {
+            @branchHint(.unlikely);
+            Thread.futexWake(@ptrCast(&m.state.raw), 1);
+        },
+    }
+}
-- 
2.54.0


From 5312063138e787a09493e5f5affb5c8652b66dbc Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 2 Feb 2026 14:25:27 -0800
Subject: [PATCH 174/499] std.Io.Threaded: work around parking futex bug

This commit should be reverted - it's testing a hypothesis that Windows
is deadlocking due to bug in the implementation of
std.Io.Threaded.parking_futex
---
 lib/std/Io/Threaded.zig | 39 +++++++++++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 10 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 11708af071376e65f1a120789fb6020271958ae9..60df1bdd81eef7dd7885e315dbc80ee188681144 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -29,8 +29,8 @@ const ws2_32 = std.os.windows.ws2_32;
 /// * scanning environment variables on some targets
 /// * memory-mapping when mmap or equivalent is not available
 allocator: Allocator,
-mutex: Io.Mutex = .init,
-cond: Io.Condition = .init,
+mutex: Mutex = .init,
+cond: Condition = .init,
 run_queue: std.SinglyLinkedList = .{},
 join_requested: bool = false,
 stack_size: usize,
@@ -14299,9 +14299,10 @@ const Wsa = struct {
 };
 
 fn initializeWsa(t: *Threaded) error{ NetworkDown, Canceled }!void {
+    const t_io = io(t);
     const wsa = &t.wsa;
-    try mutexLock(&wsa.mutex);
-    defer mutexUnlock(&wsa.mutex);
+    try wsa.mutex.lock(t_io);
+    defer wsa.mutex.unlock(t_io);
     switch (wsa.status) {
         .uninitialized => {
             var wsa_data: ws2_32.WSADATA = undefined;
@@ -16877,7 +16878,7 @@ const parking_futex = struct {
         /// avoid a race.
         num_waiters: std.atomic.Value(u32),
         /// Protects `waiters`.
-        mutex: Io.Mutex,
+        mutex: Mutex,
         waiters: std.DoublyLinkedList,
 
         /// Prevent false sharing between buckets.
@@ -18102,8 +18103,14 @@ fn eventSet(event: *Io.Event) void {
     }
 }
 
+const Condition = if (!is_windows) Io.Condition else struct {
+    condition: windows.CONDITION_VARIABLE,
+    const init: @This() = .{ .condition = .{} };
+};
+
 /// Same as `Io.Condition.broadcast` but avoids the VTable.
-fn condBroadcast(cond: *Io.Condition) void {
+fn condBroadcast(cond: *Condition) void {
+    if (is_windows) return windows.ntdll.RtlWakeAllConditionVariable(&cond.condition);
     var prev_state = cond.state.load(.monotonic);
     while (prev_state.waiters > prev_state.signals) {
         @branchHint(.unlikely);
@@ -18123,7 +18130,8 @@ fn condBroadcast(cond: *Io.Condition) void {
 }
 
 /// Same as `Io.Condition.signal` but avoids the VTable.
-fn condSignal(cond: *Io.Condition) void {
+fn condSignal(cond: *Condition) void {
+    if (is_windows) return windows.ntdll.RtlWakeConditionVariable(&cond.condition);
     var prev_state = cond.state.load(.monotonic);
     while (prev_state.waiters > prev_state.signals) {
         @branchHint(.unlikely);
@@ -18143,7 +18151,11 @@ fn condSignal(cond: *Io.Condition) void {
 }
 
 /// Same as `Io.Condition.waitUncancelable` but avoids the VTable.
-fn condWait(cond: *Io.Condition, mutex: *Io.Mutex) void {
+fn condWait(cond: *Condition, mutex: *Mutex) void {
+    if (is_windows) {
+        _ = windows.kernel32.SleepConditionVariableSRW(&cond.condition, &mutex.srwlock, windows.INFINITE, 0);
+        return;
+    }
     var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
 
     {
@@ -18172,6 +18184,11 @@ fn condWait(cond: *Io.Condition, mutex: *Io.Mutex) void {
     }
 }
 
+const Mutex = if (!is_windows) Io.Mutex else struct {
+    srwlock: windows.SRWLOCK,
+    const init: @This() = .{ .srwlock = .{} };
+};
+
 /// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
 fn mutexLock(m: *Io.Mutex) Io.Cancelable!void {
     const initial_state = m.state.cmpxchgWeak(
@@ -18192,7 +18209,8 @@ fn mutexLock(m: *Io.Mutex) Io.Cancelable!void {
 }
 
 /// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
-fn mutexLockUncancelable(m: *Io.Mutex) void {
+fn mutexLockUncancelable(m: *Mutex) void {
+    if (is_windows) return windows.ntdll.RtlAcquireSRWLockExclusive(&m.srwlock);
     const initial_state = m.state.cmpxchgWeak(
         .unlocked,
         .locked_once,
@@ -18211,7 +18229,8 @@ fn mutexLockUncancelable(m: *Io.Mutex) void {
 }
 
 /// Same as `Io.Mutex.unlock` but avoids the VTable.
-fn mutexUnlock(m: *Io.Mutex) void {
+fn mutexUnlock(m: *Mutex) void {
+    if (is_windows) return windows.ntdll.RtlReleaseSRWLockExclusive(&m.srwlock);
     switch (m.state.swap(.unlocked, .release)) {
         .unlocked => unreachable,
         .locked_once => {},
-- 
2.54.0


From 255aeb57b24bc24b604744460a61ebf7c44e42ea Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 14:57:27 -0800
Subject: [PATCH 175/499] std: introduce atomic.Mutex and use it in
 heap.SmpAllocator

This allocator implementation uses only lock-free operations.
---
 lib/std/atomic.zig            | 25 +++++++++++++++++++++----
 lib/std/heap/SmpAllocator.zig |  2 +-
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/lib/std/atomic.zig b/lib/std/atomic.zig
index 0b35b61e9babe01ab206756ce129451ee95806e9..0040dbf735eeaabad5c5d532663757bfb5de5491 100644
--- a/lib/std/atomic.zig
+++ b/lib/std/atomic.zig
@@ -1,3 +1,10 @@
+const builtin = @import("builtin");
+
+const std = @import("std.zig");
+const AtomicOrder = std.builtin.AtomicOrder;
+const testing = std.testing;
+const assert = std.debug.assert;
+
 /// This is a thin wrapper around a primitive value to prevent accidental data races.
 pub fn Value(comptime T: type) type {
     return extern struct {
@@ -496,7 +503,17 @@ test "current CPU has a cache line size" {
     _ = cache_line;
 }
 
-const std = @import("std.zig");
-const builtin = @import("builtin");
-const AtomicOrder = std.builtin.AtomicOrder;
-const testing = std.testing;
+/// A lock-free single-owner resource.
+pub const Mutex = enum(u8) {
+    unlocked,
+    locked,
+
+    pub fn tryLock(m: *Mutex) bool {
+        return @cmpxchgWeak(Mutex, m, .unlocked, .locked, .acquire, .monotonic) == null;
+    }
+
+    pub fn unlock(m: *Mutex) void {
+        assert(m.* == .locked);
+        @atomicStore(Mutex, m, .unlocked, .release);
+    }
+};
diff --git a/lib/std/heap/SmpAllocator.zig b/lib/std/heap/SmpAllocator.zig
index f9637c70a29f0ae7a25388143403a59cb13edf69..e51e4975b68dce33c3c9d2e78691f8b9bec32159 100644
--- a/lib/std/heap/SmpAllocator.zig
+++ b/lib/std/heap/SmpAllocator.zig
@@ -62,7 +62,7 @@ const Thread = struct {
     ///
     /// Threads lock this before accessing their own state in order
     /// to support freelist reclamation.
-    mutex: std.Thread.Mutex = .{},
+    mutex: std.atomic.Mutex = .unlocked,
 
     /// For each size class, tracks the next address to be returned from
     /// `alloc` when the freelist is empty.
-- 
2.54.0


From 550da1b676d059ae39a629d60da0f9cd155a5e89 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 17:33:49 -0800
Subject: [PATCH 176/499] std: migrate remaining sync primitives to Io

- delete std.Thread.Futex
- delete std.Thread.Mutex
- delete std.Thread.Semaphore
- delete std.Thread.Condition
- delete std.Thread.RwLock
- delete std.once

std.Thread.Mutex.Recursive remains... for now. it will be replaced with
a special purpose mechanism used only by panic logic.

std.Io.Threaded exposes mutexLock and mutexUnlock for the advanced case
when you need to call them directly.
---
 CMakeLists.txt                       |    2 -
 lib/compiler/build_runner.zig        |   19 +-
 lib/compiler_rt/emutls.zig           |    9 +-
 lib/fuzzer.zig                       |    2 +-
 lib/std/Io/Threaded.zig              |  166 ++--
 lib/std/Thread.zig                   |   14 +-
 lib/std/Thread/Condition.zig         |  683 -----------------
 lib/std/Thread/Futex.zig             | 1063 --------------------------
 lib/std/Thread/Mutex.zig             |  367 ---------
 lib/std/Thread/Mutex/Recursive.zig   |   14 +-
 lib/std/Thread/RwLock.zig            |  386 ----------
 lib/std/Thread/Semaphore.zig         |  111 ---
 lib/std/debug.zig                    |    9 +-
 lib/std/debug/Coverage.zig           |   20 +-
 lib/std/debug/Info.zig               |    4 +-
 lib/std/debug/SelfInfo/Elf.zig       |   50 +-
 lib/std/debug/SelfInfo/MachO.zig     |   32 +-
 lib/std/debug/SelfInfo/Windows.zig   |   20 +-
 lib/std/heap/ThreadSafeAllocator.zig |   35 +-
 lib/std/heap/debug_allocator.zig     |   51 +-
 lib/std/heap/sbrk_allocator.zig      |   18 +-
 lib/std/http/Client.zig              |   67 +-
 lib/std/once.zig                     |   71 --
 lib/std/std.zig                      |    1 -
 24 files changed, 260 insertions(+), 2954 deletions(-)
 delete mode 100644 lib/std/Thread/Condition.zig
 delete mode 100644 lib/std/Thread/Futex.zig
 delete mode 100644 lib/std/Thread/Mutex.zig
 delete mode 100644 lib/std/Thread/RwLock.zig
 delete mode 100644 lib/std/Thread/Semaphore.zig
 delete mode 100644 lib/std/once.zig

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 05fb9c4805fdb0b8fadcc4bd05167e70ed9668e7..38dbd6ca6afae4f08df1cac61913794890e393de 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -408,8 +408,6 @@ set(ZIG_STAGE2_SOURCES
     lib/std/Target/wasm.zig
     lib/std/Target/x86.zig
     lib/std/Thread.zig
-    lib/std/Thread/Futex.zig
-    lib/std/Thread/Mutex.zig
     lib/std/array_hash_map.zig
     lib/std/array_list.zig
     lib/std/ascii.zig
diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 5ef74adabab9e651d9cc65730b43c4fd783a2aa0..04ceb6212c84ce9c91633fa3ad10c316702a1855 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -30,14 +30,6 @@ pub fn main(init: process.Init.Minimal) !void {
     defer _ = debug_gpa_state.deinit();
     const gpa = debug_gpa_state.allocator();
 
-    // ...but we'll back our arena by `std.heap.page_allocator` for efficiency.
-    var single_threaded_arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
-    defer single_threaded_arena.deinit();
-    var thread_safe_arena: std.heap.ThreadSafeAllocator = .{ .child_allocator = single_threaded_arena.allocator() };
-    const arena = thread_safe_arena.allocator();
-
-    const args = try init.args.toSlice(arena);
-
     var threaded: std.Io.Threaded = .init(gpa, .{
         .environ = init.environ,
         .argv0 = .init(init.args),
@@ -45,6 +37,17 @@ pub fn main(init: process.Init.Minimal) !void {
     defer threaded.deinit();
     const io = threaded.io();
 
+    // ...but we'll back our arena by `std.heap.page_allocator` for efficiency.
+    var single_threaded_arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+    defer single_threaded_arena.deinit();
+    var thread_safe_arena: std.heap.ThreadSafeAllocator = .{
+        .child_allocator = single_threaded_arena.allocator(),
+        .io = io,
+    };
+    const arena = thread_safe_arena.allocator();
+
+    const args = try init.args.toSlice(arena);
+
     // skip my own exe name
     var arg_idx: usize = 1;
 
diff --git a/lib/compiler_rt/emutls.zig b/lib/compiler_rt/emutls.zig
index c52ce020edddb269e4f0f52e789e6381092384cd..d702597cd24ec3189b5296d5610aefcc57c10fce 100644
--- a/lib/compiler_rt/emutls.zig
+++ b/lib/compiler_rt/emutls.zig
@@ -147,7 +147,8 @@ const ObjectArray = struct {
 // It provides thread-safety for on-demand storage of Thread Objects.
 const current_thread_storage = struct {
     var key: std.c.pthread_key_t = undefined;
-    var init_once = std.once(current_thread_storage.init);
+    var init_mutex: std.c.pthread_mutex_t = std.c.PTHREAD_MUTEX_INITIALIZER;
+    var init_done: bool = false;
 
     /// Return a per thread ObjectArray with at least the expected index.
     pub fn getArray(index: usize) *ObjectArray {
@@ -183,9 +184,13 @@ const current_thread_storage = struct {
 
     /// Initialize pthread_key_t.
     fn init() void {
+        if (@atomicLoad(bool, &init_done, .monotonic)) return;
+        _ = std.c.pthread_mutex_lock(&init_mutex);
         if (std.c.pthread_key_create(&current_thread_storage.key, current_thread_storage.deinit) != .SUCCESS) {
             abort();
         }
+        @atomicStore(bool, &init_done, true, .release);
+        _ = std.c.pthread_mutex_unlock(&init_mutex);
     }
 
     /// Invoked by pthread specific destructor. the passed argument is the ObjectArray pointer.
@@ -283,7 +288,7 @@ const emutls_control = extern struct {
     /// Get the pointer on allocated storage for emutls variable.
     pub fn getPointer(self: *emutls_control) *anyopaque {
         // ensure current_thread_storage initialization is done
-        current_thread_storage.init_once.call();
+        current_thread_storage.init();
 
         const index = self.getIndex();
         var array = current_thread_storage.getArray(index);
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index 1030128d48d5de94f11fd9b036a9f77078c93b13..37ca752d1fa962d0b97d9035fb5823c6e0b61507 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -632,7 +632,7 @@ export fn fuzzer_main(limit_kind: abi.LimitKind, amount: u64) void {
 
 export fn fuzzer_unslide_address(addr: usize) usize {
     const si = std.debug.getSelfDebugInfo() catch @compileError("unsupported");
-    const slide = si.getModuleSlide(std.debug.getDebugInfoAllocator(), addr) catch |err| {
+    const slide = si.getModuleSlide(std.debug.getDebugInfoAllocator(), io, addr) catch |err| {
         std.debug.panic("failed to find virtual address slide: {t}", .{err});
     };
     return addr - slide;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 60df1bdd81eef7dd7885e315dbc80ee188681144..b2ff7533849f1b3d8e41b7bfb5a2c2920bc6ee35 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1126,6 +1126,25 @@ const Thread = struct {
             return @ptrFromInt(@as(usize, @bitCast(split)));
         }
     };
+
+    /// Same as `Io.Mutex.lock` but avoids the VTable.
+    fn mutexLock(m: *Io.Mutex) Io.Cancelable!void {
+        const initial_state = m.state.cmpxchgWeak(
+            .unlocked,
+            .locked_once,
+            .acquire,
+            .monotonic,
+        ) orelse {
+            @branchHint(.likely);
+            return;
+        };
+        if (initial_state == .contended) {
+            try Thread.futexWait(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
+        }
+        while (m.state.swap(.contended, .acquire) != .unlocked) {
+            try Thread.futexWait(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
+        }
+    }
 };
 
 const Syscall = struct {
@@ -1486,8 +1505,8 @@ var global_single_threaded_instance: Threaded = .init_single_threaded;
 pub const global_single_threaded: *Threaded = &global_single_threaded_instance;
 
 pub fn setAsyncLimit(t: *Threaded, new_limit: Io.Limit) void {
-    mutexLockUncancelable(&t.mutex);
-    defer mutexUnlock(&t.mutex);
+    mutexLockInternal(&t.mutex);
+    defer mutexUnlockInternal(&t.mutex);
     t.async_limit = new_limit;
 }
 
@@ -1508,8 +1527,8 @@ pub fn deinit(t: *Threaded) void {
 fn join(t: *Threaded) void {
     if (builtin.single_threaded) return;
     {
-        mutexLockUncancelable(&t.mutex);
-        defer mutexUnlock(&t.mutex);
+        mutexLockInternal(&t.mutex);
+        defer mutexUnlockInternal(&t.mutex);
         t.join_requested = true;
     }
     condBroadcast(&t.cond);
@@ -1574,16 +1593,16 @@ fn worker(t: *Threaded) void {
 
     defer t.wait_group.finish();
 
-    mutexLockUncancelable(&t.mutex);
-    defer mutexUnlock(&t.mutex);
+    mutexLockInternal(&t.mutex);
+    defer mutexUnlockInternal(&t.mutex);
 
     while (true) {
         while (t.run_queue.popFirst()) |runnable_node| {
-            mutexUnlock(&t.mutex);
+            mutexUnlockInternal(&t.mutex);
             thread.cancel_protection = .unblocked;
             const runnable: *Runnable = @fieldParentPtr("node", runnable_node);
             runnable.startFn(runnable, &thread, t);
-            mutexLockUncancelable(&t.mutex);
+            mutexLockInternal(&t.mutex);
             t.busy_count -= 1;
         }
         if (t.join_requested) break;
@@ -2004,12 +2023,12 @@ fn async(
         },
     };
 
-    mutexLockUncancelable(&t.mutex);
+    mutexLockInternal(&t.mutex);
 
     const busy_count = t.busy_count;
 
     if (busy_count >= @intFromEnum(t.async_limit)) {
-        mutexUnlock(&t.mutex);
+        mutexUnlockInternal(&t.mutex);
         future.destroy(gpa);
         start(context.ptr, result.ptr);
         return null;
@@ -2023,7 +2042,7 @@ fn async(
         const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
             t.wait_group.finish();
             t.busy_count = busy_count;
-            mutexUnlock(&t.mutex);
+            mutexUnlockInternal(&t.mutex);
             future.destroy(gpa);
             start(context.ptr, result.ptr);
             return null;
@@ -2033,7 +2052,7 @@ fn async(
 
     t.run_queue.prepend(&future.runnable.node);
 
-    mutexUnlock(&t.mutex);
+    mutexUnlockInternal(&t.mutex);
     condSignal(&t.cond);
     return @ptrCast(future);
 }
@@ -2056,8 +2075,8 @@ fn concurrent(
     };
     errdefer future.destroy(gpa);
 
-    mutexLockUncancelable(&t.mutex);
-    defer mutexUnlock(&t.mutex);
+    mutexLockInternal(&t.mutex);
+    defer mutexUnlockInternal(&t.mutex);
 
     const busy_count = t.busy_count;
 
@@ -2101,12 +2120,12 @@ fn groupAsync(
         error.OutOfMemory => return groupAsyncEager(start, context.ptr),
     };
 
-    mutexLockUncancelable(&t.mutex);
+    mutexLockInternal(&t.mutex);
 
     const busy_count = t.busy_count;
 
     if (busy_count >= @intFromEnum(t.async_limit)) {
-        mutexUnlock(&t.mutex);
+        mutexUnlockInternal(&t.mutex);
         task.destroy(gpa);
         return groupAsyncEager(start, context.ptr);
     }
@@ -2119,7 +2138,7 @@ fn groupAsync(
         const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
             t.wait_group.finish();
             t.busy_count = busy_count;
-            mutexUnlock(&t.mutex);
+            mutexUnlockInternal(&t.mutex);
             task.destroy(gpa);
             return groupAsyncEager(start, context.ptr);
         };
@@ -2136,7 +2155,7 @@ fn groupAsync(
     }, .monotonic);
     t.run_queue.prepend(&task.runnable.node);
 
-    mutexUnlock(&t.mutex);
+    mutexUnlockInternal(&t.mutex);
     condSignal(&t.cond);
 }
 fn groupAsyncEager(
@@ -2201,8 +2220,8 @@ fn groupConcurrent(
     };
     errdefer task.destroy(gpa);
 
-    mutexLockUncancelable(&t.mutex);
-    defer mutexUnlock(&t.mutex);
+    mutexLockInternal(&t.mutex);
+    defer mutexUnlockInternal(&t.mutex);
 
     const busy_count = t.busy_count;
 
@@ -3838,8 +3857,8 @@ fn fileStatWindows(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
 
 fn systemBasicInformation(t: *Threaded) ?*const windows.SYSTEM_BASIC_INFORMATION {
     if (!t.system_basic_information.initialized.load(.acquire)) {
-        mutexLockUncancelable(&t.mutex);
-        defer mutexUnlock(&t.mutex);
+        mutexLockInternal(&t.mutex);
+        defer mutexUnlockInternal(&t.mutex);
 
         switch (windows.ntdll.NtQuerySystemInformation(
             .SystemBasicInformation,
@@ -14373,8 +14392,8 @@ const WindowsEnvironStrings = struct {
 };
 
 fn scanEnviron(t: *Threaded) void {
-    mutexLockUncancelable(&t.mutex);
-    defer mutexUnlock(&t.mutex);
+    mutexLockInternal(&t.mutex);
+    defer mutexUnlockInternal(&t.mutex);
 
     if (t.environ.initialized) return;
     t.environ.initialized = true;
@@ -14729,8 +14748,8 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
 
 fn getDevNullFd(t: *Threaded) !posix.fd_t {
     {
-        mutexLockUncancelable(&t.mutex);
-        defer mutexUnlock(&t.mutex);
+        mutexLockInternal(&t.mutex);
+        defer mutexUnlockInternal(&t.mutex);
         if (t.null_file.fd != -1) return t.null_file.fd;
     }
     const mode: u32 = 0;
@@ -14741,8 +14760,8 @@ fn getDevNullFd(t: *Threaded) !posix.fd_t {
             .SUCCESS => {
                 syscall.finish();
                 const fresh_fd: posix.fd_t = @intCast(rc);
-                mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
-                defer mutexUnlock(&t.mutex);
+                mutexLockInternal(&t.mutex); // Another thread might have won the race.
+                defer mutexUnlockInternal(&t.mutex);
                 if (t.null_file.fd != -1) {
                     posix.close(fresh_fd);
                     return t.null_file.fd;
@@ -15402,8 +15421,8 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
 
 fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     {
-        mutexLockUncancelable(&t.mutex);
-        defer mutexUnlock(&t.mutex);
+        mutexLockInternal(&t.mutex);
+        defer mutexUnlockInternal(&t.mutex);
         if (t.random_file.handle) |handle| return handle;
     }
 
@@ -15437,8 +15456,8 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     )) {
         .SUCCESS => {
             syscall.finish();
-            mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
-            defer mutexUnlock(&t.mutex);
+            mutexLockInternal(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlockInternal(&t.mutex);
             if (t.random_file.handle) |prev_handle| {
                 windows.CloseHandle(fresh_handle);
                 return prev_handle;
@@ -15458,8 +15477,8 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
 
 fn getNulHandle(t: *Threaded) !windows.HANDLE {
     {
-        mutexLockUncancelable(&t.mutex);
-        defer mutexUnlock(&t.mutex);
+        mutexLockInternal(&t.mutex);
+        defer mutexUnlockInternal(&t.mutex);
         if (t.null_file.handle) |handle| return handle;
     }
 
@@ -15505,8 +15524,8 @@ fn getNulHandle(t: *Threaded) !windows.HANDLE {
     )) {
         .SUCCESS => {
             syscall.finish();
-            mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
-            defer mutexUnlock(&t.mutex);
+            mutexLockInternal(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlockInternal(&t.mutex);
             if (t.null_file.handle) |prev_handle| {
                 windows.CloseHandle(fresh_handle);
                 return prev_handle;
@@ -16551,15 +16570,15 @@ fn random(userdata: ?*anyopaque, buffer: []u8) void {
 }
 
 fn randomMainThread(t: *Threaded, buffer: []u8) void {
-    mutexLockUncancelable(&t.mutex);
-    defer mutexUnlock(&t.mutex);
+    mutexLockInternal(&t.mutex);
+    defer mutexUnlockInternal(&t.mutex);
 
     if (!t.csprng.isInitialized()) {
         @branchHint(.unlikely);
         var seed: [Csprng.seed_len]u8 = undefined;
         {
-            mutexUnlock(&t.mutex);
-            defer mutexLockUncancelable(&t.mutex);
+            mutexUnlockInternal(&t.mutex);
+            defer mutexLockInternal(&t.mutex);
 
             const prev = swapCancelProtection(t, .blocked);
             defer _ = swapCancelProtection(t, prev);
@@ -16744,8 +16763,8 @@ fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
 
 fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
     {
-        mutexLockUncancelable(&t.mutex);
-        defer mutexUnlock(&t.mutex);
+        mutexLockInternal(&t.mutex);
+        defer mutexUnlockInternal(&t.mutex);
 
         if (t.random_file.fd == -2) return error.EntropyUnavailable;
         if (t.random_file.fd != -1) return t.random_file.fd;
@@ -16785,8 +16804,8 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                     .SUCCESS => {
                         syscall.finish();
                         if (!statx.mask.TYPE) return error.EntropyUnavailable;
-                        mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
-                        defer mutexUnlock(&t.mutex);
+                        mutexLockInternal(&t.mutex); // Another thread might have won the race.
+                        defer mutexUnlockInternal(&t.mutex);
                         if (t.random_file.fd >= 0) {
                             posix.close(fd);
                             return t.random_file.fd;
@@ -16813,8 +16832,8 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                 switch (posix.errno(fstat_sym(fd, &stat))) {
                     .SUCCESS => {
                         syscall.finish();
-                        mutexLockUncancelable(&t.mutex); // Another thread might have won the race.
-                        defer mutexUnlock(&t.mutex);
+                        mutexLockInternal(&t.mutex); // Another thread might have won the race.
+                        defer mutexUnlockInternal(&t.mutex);
                         if (t.random_file.fd >= 0) {
                             posix.close(fd);
                             return t.random_file.fd;
@@ -16947,8 +16966,8 @@ const parking_futex = struct {
         var status_buf: std.atomic.Value(Thread.Status) = undefined;
 
         {
-            mutexLockUncancelable(&bucket.mutex);
-            defer mutexUnlock(&bucket.mutex);
+            mutexLockInternal(&bucket.mutex);
+            defer mutexUnlockInternal(&bucket.mutex);
 
             _ = bucket.num_waiters.fetchAdd(1, .acquire);
 
@@ -17017,8 +17036,8 @@ const parking_futex = struct {
                 .parked => {
                     // We saw a timeout and updated our own status from `.parked` to `.none`. It is
                     // our responsibility to remove `waiter` from `bucket`.
-                    mutexLockUncancelable(&bucket.mutex);
-                    defer mutexUnlock(&bucket.mutex);
+                    mutexLockInternal(&bucket.mutex);
+                    defer mutexUnlockInternal(&bucket.mutex);
                     bucket.waiters.remove(&waiter.node);
                     assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
                 },
@@ -17057,8 +17076,8 @@ const parking_futex = struct {
         // of the critical section. This forms a singly-linked list of waiters using `Waiter.node.next`.
         var waking_head: ?*std.DoublyLinkedList.Node = null;
         {
-            mutexLockUncancelable(&bucket.mutex);
-            defer mutexUnlock(&bucket.mutex);
+            mutexLockInternal(&bucket.mutex);
+            defer mutexUnlockInternal(&bucket.mutex);
 
             var num_removed: u32 = 0;
             var it = bucket.waiters.first;
@@ -17113,8 +17132,8 @@ const parking_futex = struct {
 
     fn removeCanceledWaiter(waiter: *Waiter) void {
         const bucket = bucketForAddress(waiter.address);
-        mutexLockUncancelable(&bucket.mutex);
-        defer mutexUnlock(&bucket.mutex);
+        mutexLockInternal(&bucket.mutex);
+        defer mutexUnlockInternal(&bucket.mutex);
         bucket.waiters.remove(&waiter.node);
         assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
         waiter.done.store(true, .release); // potentially invalidates `waiter.*`
@@ -18163,8 +18182,8 @@ fn condWait(cond: *Condition, mutex: *Mutex) void {
         assert(prev_state.waiters < std.math.maxInt(u16)); // overflow caused by too many waiters
     }
 
-    mutexUnlock(mutex);
-    defer mutexLockUncancelable(mutex);
+    mutexUnlockInternal(mutex);
+    defer mutexLockInternal(mutex);
 
     while (true) {
         Thread.futexWaitUncancelable(&cond.epoch.raw, epoch, null);
@@ -18189,28 +18208,13 @@ const Mutex = if (!is_windows) Io.Mutex else struct {
     const init: @This() = .{ .srwlock = .{} };
 };
 
-/// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
-fn mutexLock(m: *Io.Mutex) Io.Cancelable!void {
-    const initial_state = m.state.cmpxchgWeak(
-        .unlocked,
-        .locked_once,
-        .acquire,
-        .monotonic,
-    ) orelse {
-        @branchHint(.likely);
-        return;
-    };
-    if (initial_state == .contended) {
-        try Thread.futexWait(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
-    }
-    while (m.state.swap(.contended, .acquire) != .unlocked) {
-        try Thread.futexWait(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null);
-    }
-}
-
-/// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
-fn mutexLockUncancelable(m: *Mutex) void {
+fn mutexLockInternal(m: *Mutex) void {
     if (is_windows) return windows.ntdll.RtlAcquireSRWLockExclusive(&m.srwlock);
+    return mutexLock(m);
+}
+
+/// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
+pub fn mutexLock(m: *Io.Mutex) void {
     const initial_state = m.state.cmpxchgWeak(
         .unlocked,
         .locked_once,
@@ -18228,9 +18232,13 @@ fn mutexLockUncancelable(m: *Mutex) void {
     }
 }
 
-/// Same as `Io.Mutex.unlock` but avoids the VTable.
-fn mutexUnlock(m: *Mutex) void {
+fn mutexUnlockInternal(m: *Mutex) void {
     if (is_windows) return windows.ntdll.RtlReleaseSRWLockExclusive(&m.srwlock);
+    return mutexUnlock(m);
+}
+
+/// Same as `Io.Mutex.unlock` but avoids the VTable.
+pub fn mutexUnlock(m: *Io.Mutex) void {
     switch (m.state.swap(.unlocked, .release)) {
         .unlocked => unreachable,
         .locked_once => {},
diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index ef35422e1d2c7013d739dc6a05791de888292b9c..3191dd26ce4563cb10ee2803edf49c9ae59c3e1d 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -14,13 +14,9 @@ const posix = std.posix;
 const windows = std.os.windows;
 const testing = std.testing;
 
-pub const Futex = @import("Thread/Futex.zig");
-pub const Mutex = @import("Thread/Mutex.zig");
-pub const Semaphore = @import("Thread/Semaphore.zig");
-pub const Condition = @import("Thread/Condition.zig");
-pub const RwLock = @import("Thread/RwLock.zig");
-
-pub const Pool = @compileError("deprecated; consider using 'std.Io.Group' with 'std.Io.Threaded'");
+pub const Mutex = struct {
+    pub const Recursive = @import("Thread/Mutex/Recursive.zig");
+};
 
 pub const use_pthreads = native_os != .windows and native_os != .wasi and builtin.link_libc;
 
@@ -1609,11 +1605,7 @@ test "setName, getName" {
 }
 
 test {
-    _ = Futex;
     _ = Mutex;
-    _ = Semaphore;
-    _ = Condition;
-    _ = RwLock;
 }
 
 fn testIncrementNotify(io: Io, value: *usize, event: *Io.Event) void {
diff --git a/lib/std/Thread/Condition.zig b/lib/std/Thread/Condition.zig
deleted file mode 100644
index 8917e07a4fee3191c18ffa2c22ca36b0347fb3a8..0000000000000000000000000000000000000000
--- a/lib/std/Thread/Condition.zig
+++ /dev/null
@@ -1,683 +0,0 @@
-//! Condition variables are used with a Mutex to efficiently wait for an arbitrary condition to occur.
-//! It does this by atomically unlocking the mutex, blocking the thread until notified, and finally re-locking the mutex.
-//! Condition can be statically initialized and is at most `@sizeOf(u64)` large.
-//!
-//! Example:
-//! ```
-//! var m = Mutex{};
-//! var c = Condition{};
-//! var predicate = false;
-//!
-//! fn consumer() void {
-//!     m.lock();
-//!     defer m.unlock();
-//!
-//!     while (!predicate) {
-//!         c.wait(&m);
-//!     }
-//! }
-//!
-//! fn producer() void {
-//!     {
-//!         m.lock();
-//!         defer m.unlock();
-//!         predicate = true;
-//!     }
-//!     c.signal();
-//! }
-//!
-//! const thread = try std.Thread.spawn(.{}, producer, .{});
-//! consumer();
-//! thread.join();
-//! ```
-//!
-//! Note that condition variables can only reliably unblock threads that are sequenced before them using the same Mutex.
-//! This means that the following is allowed to deadlock:
-//! ```
-//! thread-1: mutex.lock()
-//! thread-1: condition.wait(&mutex)
-//!
-//! thread-2: // mutex.lock() (without this, the following signal may not see the waiting thread-1)
-//! thread-2: // mutex.unlock() (this is optional for correctness once locked above, as signal can be called while holding the mutex)
-//! thread-2: condition.signal()
-//! ```
-
-const std = @import("../std.zig");
-const builtin = @import("builtin");
-const Condition = @This();
-const Mutex = std.Thread.Mutex;
-
-const os = std.os;
-const assert = std.debug.assert;
-const testing = std.testing;
-const Futex = std.Thread.Futex;
-
-impl: Impl = .{},
-
-/// Atomically releases the Mutex, blocks the caller thread, then re-acquires the Mutex on return.
-/// "Atomically" here refers to accesses done on the Condition after acquiring the Mutex.
-///
-/// The Mutex must be locked by the caller's thread when this function is called.
-/// A Mutex can have multiple Conditions waiting with it concurrently, but not the opposite.
-/// It is undefined behavior for multiple threads to wait ith different mutexes using the same Condition concurrently.
-/// Once threads have finished waiting with one Mutex, the Condition can be used to wait with another Mutex.
-///
-/// A blocking call to wait() is unblocked from one of the following conditions:
-/// - a spurious ("at random") wake up occurs
-/// - a future call to `signal()` or `broadcast()` which has acquired the Mutex and is sequenced after this `wait()`.
-///
-/// Given wait() can be interrupted spuriously, the blocking condition should be checked continuously
-/// irrespective of any notifications from `signal()` or `broadcast()`.
-pub fn wait(self: *Condition, mutex: *Mutex) void {
-    self.impl.wait(mutex, null) catch |err| switch (err) {
-        error.Timeout => unreachable, // no timeout provided so we shouldn't have timed-out
-    };
-}
-
-/// Atomically releases the Mutex, blocks the caller thread, then re-acquires the Mutex on return.
-/// "Atomically" here refers to accesses done on the Condition after acquiring the Mutex.
-///
-/// The Mutex must be locked by the caller's thread when this function is called.
-/// A Mutex can have multiple Conditions waiting with it concurrently, but not the opposite.
-/// It is undefined behavior for multiple threads to wait ith different mutexes using the same Condition concurrently.
-/// Once threads have finished waiting with one Mutex, the Condition can be used to wait with another Mutex.
-///
-/// A blocking call to `timedWait()` is unblocked from one of the following conditions:
-/// - a spurious ("at random") wake occurs
-/// - the caller was blocked for around `timeout_ns` nanoseconds, in which `error.Timeout` is returned.
-/// - a future call to `signal()` or `broadcast()` which has acquired the Mutex and is sequenced after this `timedWait()`.
-///
-/// Given `timedWait()` can be interrupted spuriously, the blocking condition should be checked continuously
-/// irrespective of any notifications from `signal()` or `broadcast()`.
-pub fn timedWait(self: *Condition, mutex: *Mutex, timeout_ns: u64) error{Timeout}!void {
-    return self.impl.wait(mutex, timeout_ns);
-}
-
-/// Unblocks at least one thread blocked in a call to `wait()` or `timedWait()` with a given Mutex.
-/// The blocked thread must be sequenced before this call with respect to acquiring the same Mutex in order to be observable for unblocking.
-/// `signal()` can be called with or without the relevant Mutex being acquired and have no "effect" if there's no observable blocked threads.
-pub fn signal(self: *Condition) void {
-    self.impl.wake(.one);
-}
-
-/// Unblocks all threads currently blocked in a call to `wait()` or `timedWait()` with a given Mutex.
-/// The blocked threads must be sequenced before this call with respect to acquiring the same Mutex in order to be observable for unblocking.
-/// `broadcast()` can be called with or without the relevant Mutex being acquired and have no "effect" if there's no observable blocked threads.
-pub fn broadcast(self: *Condition) void {
-    self.impl.wake(.all);
-}
-
-const Impl = Impl: {
-    if (builtin.single_threaded) break :Impl SingleThreadedImpl;
-    if (builtin.os.tag == .windows) break :Impl WindowsImpl;
-
-    if (builtin.os.tag.isDarwin() or
-        builtin.target.os.tag == .linux or
-        builtin.target.os.tag == .freebsd or
-        builtin.target.os.tag == .openbsd or
-        builtin.target.os.tag == .dragonfly or
-        builtin.target.cpu.arch.isWasm())
-    {
-        // Futex is the system's synchronization primitive; use that.
-        break :Impl FutexImpl;
-    }
-
-    if (std.Thread.use_pthreads) {
-        // This system doesn't have a futex primitive, so `std.Thread.Futex` is using `PosixImpl`,
-        // which implements futex *on top of* pthread mutexes and conditions. Therefore, instead
-        // of going through that long inefficient path, just use pthread condition variable directly.
-        break :Impl PosixImpl;
-    }
-
-    break :Impl FutexImpl;
-};
-
-const Notify = enum {
-    one, // wake up only one thread
-    all, // wake up all threads
-};
-
-const SingleThreadedImpl = struct {
-    fn wait(self: *Impl, mutex: *Mutex, timeout: ?u64) error{Timeout}!void {
-        _ = self;
-        _ = mutex;
-        // There are no other threads to wake us up.
-        // So if we wait without a timeout we would never wake up.
-        assert(timeout != null); // Deadlock detected.
-        return error.Timeout;
-    }
-
-    fn wake(self: *Impl, comptime notify: Notify) void {
-        // There are no other threads to wake up.
-        _ = self;
-        _ = notify;
-    }
-};
-
-const WindowsImpl = struct {
-    condition: os.windows.CONDITION_VARIABLE = .{},
-
-    fn wait(self: *Impl, mutex: *Mutex, timeout: ?u64) error{Timeout}!void {
-        var timeout_overflowed = false;
-        var timeout_ms: os.windows.DWORD = os.windows.INFINITE;
-
-        if (timeout) |timeout_ns| {
-            // Round the nanoseconds to the nearest millisecond,
-            // then saturating cast it to windows DWORD for use in kernel32 call.
-            const ms = (timeout_ns +| (std.time.ns_per_ms / 2)) / std.time.ns_per_ms;
-            timeout_ms = std.math.cast(os.windows.DWORD, ms) orelse std.math.maxInt(os.windows.DWORD);
-
-            // Track if the timeout overflowed into INFINITE and make sure not to wait forever.
-            if (timeout_ms == os.windows.INFINITE) {
-                timeout_overflowed = true;
-                timeout_ms -= 1;
-            }
-        }
-
-        if (builtin.mode == .Debug) {
-            // The internal state of the DebugMutex needs to be handled here as well.
-            mutex.impl.locking_thread.store(0, .unordered);
-        }
-        const rc = os.windows.kernel32.SleepConditionVariableSRW(
-            &self.condition,
-            if (builtin.mode == .Debug) &mutex.impl.impl.srwlock else &mutex.impl.srwlock,
-            timeout_ms,
-            0, // the srwlock was assumed to acquired in exclusive mode not shared
-        );
-        if (builtin.mode == .Debug) {
-            // The internal state of the DebugMutex needs to be handled here as well.
-            mutex.impl.locking_thread.store(std.Thread.getCurrentId(), .unordered);
-        }
-
-        // Return error.Timeout if we know the timeout elapsed correctly.
-        if (rc == os.windows.FALSE) {
-            assert(os.windows.GetLastError() == .TIMEOUT);
-            if (!timeout_overflowed) return error.Timeout;
-        }
-    }
-
-    fn wake(self: *Impl, comptime notify: Notify) void {
-        switch (notify) {
-            .one => os.windows.ntdll.RtlWakeConditionVariable(&self.condition),
-            .all => os.windows.ntdll.RtlWakeAllConditionVariable(&self.condition),
-        }
-    }
-};
-
-const FutexImpl = struct {
-    state: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    epoch: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-
-    const one_waiter = 1;
-    const waiter_mask = 0xffff;
-
-    const one_signal = 1 << 16;
-    const signal_mask = 0xffff << 16;
-
-    fn wait(self: *Impl, mutex: *Mutex, timeout: ?u64) error{Timeout}!void {
-        // Observe the epoch, then check the state again to see if we should wake up.
-        // The epoch must be observed before we check the state or we could potentially miss a wake() and deadlock:
-        //
-        // - T1: s = LOAD(&state)
-        // - T2: UPDATE(&s, signal)
-        // - T2: UPDATE(&epoch, 1) + FUTEX_WAKE(&epoch)
-        // - T1: e = LOAD(&epoch) (was reordered after the state load)
-        // - T1: s & signals == 0 -> FUTEX_WAIT(&epoch, e) (missed the state update + the epoch change)
-        //
-        // Acquire barrier to ensure the epoch load happens before the state load.
-        var epoch = self.epoch.load(.acquire);
-        var state = self.state.fetchAdd(one_waiter, .monotonic);
-        assert(state & waiter_mask != waiter_mask);
-        state += one_waiter;
-
-        mutex.unlock();
-        defer mutex.lock();
-
-        var futex_deadline = Futex.Deadline.init(timeout);
-
-        while (true) {
-            futex_deadline.wait(&self.epoch, epoch) catch |err| switch (err) {
-                // On timeout, we must decrement the waiter we added above.
-                error.Timeout => {
-                    while (true) {
-                        // If there's a signal when we're timing out, consume it and report being woken up instead.
-                        // Acquire barrier ensures code before the wake() which added the signal happens before we decrement it and return.
-                        while (state & signal_mask != 0) {
-                            const new_state = state - one_waiter - one_signal;
-                            state = self.state.cmpxchgWeak(state, new_state, .acquire, .monotonic) orelse return;
-                        }
-
-                        // Remove the waiter we added and officially return timed out.
-                        const new_state = state - one_waiter;
-                        state = self.state.cmpxchgWeak(state, new_state, .monotonic, .monotonic) orelse return err;
-                    }
-                },
-            };
-
-            epoch = self.epoch.load(.acquire);
-            state = self.state.load(.monotonic);
-
-            // Try to wake up by consuming a signal and decremented the waiter we added previously.
-            // Acquire barrier ensures code before the wake() which added the signal happens before we decrement it and return.
-            while (state & signal_mask != 0) {
-                const new_state = state - one_waiter - one_signal;
-                state = self.state.cmpxchgWeak(state, new_state, .acquire, .monotonic) orelse return;
-            }
-        }
-    }
-
-    fn wake(self: *Impl, comptime notify: Notify) void {
-        var state = self.state.load(.monotonic);
-        while (true) {
-            const waiters = (state & waiter_mask) / one_waiter;
-            const signals = (state & signal_mask) / one_signal;
-
-            // Reserves which waiters to wake up by incrementing the signals count.
-            // Therefore, the signals count is always less than or equal to the waiters count.
-            // We don't need to Futex.wake if there's nothing to wake up or if other wake() threads have reserved to wake up the current waiters.
-            const wakeable = waiters - signals;
-            if (wakeable == 0) {
-                return;
-            }
-
-            const to_wake = switch (notify) {
-                .one => 1,
-                .all => wakeable,
-            };
-
-            // Reserve the amount of waiters to wake by incrementing the signals count.
-            // Release barrier ensures code before the wake() happens before the signal it posted and consumed by the wait() threads.
-            const new_state = state + (one_signal * to_wake);
-            state = self.state.cmpxchgWeak(state, new_state, .release, .monotonic) orelse {
-                // Wake up the waiting threads we reserved above by changing the epoch value.
-                // NOTE: a waiting thread could miss a wake up if *exactly* ((1<<32)-1) wake()s happen between it observing the epoch and sleeping on it.
-                // This is very unlikely due to how many precise amount of Futex.wake() calls that would be between the waiting thread's potential preemption.
-                //
-                // Release barrier ensures the signal being added to the state happens before the epoch is changed.
-                // If not, the waiting thread could potentially deadlock from missing both the state and epoch change:
-                //
-                // - T2: UPDATE(&epoch, 1) (reordered before the state change)
-                // - T1: e = LOAD(&epoch)
-                // - T1: s = LOAD(&state)
-                // - T2: UPDATE(&state, signal) + FUTEX_WAKE(&epoch)
-                // - T1: s & signals == 0 -> FUTEX_WAIT(&epoch, e) (missed both epoch change and state change)
-                _ = self.epoch.fetchAdd(1, .release);
-                Futex.wake(&self.epoch, to_wake);
-                return;
-            };
-        }
-    }
-};
-
-const PosixImpl = struct {
-    cond: std.c.pthread_cond_t = .{},
-
-    fn wait(self: *Impl, mutex: *Mutex, timeout: ?u64) error{Timeout}!void {
-        if (builtin.mode == .Debug) {
-            mutex.impl.locking_thread.store(0, .unordered);
-        }
-        defer if (builtin.mode == .Debug) {
-            mutex.impl.locking_thread.store(std.Thread.getCurrentId(), .unordered);
-        };
-
-        const mtx = if (builtin.mode == .Debug) &mutex.impl.impl.mutex else &mutex.impl.mutex;
-
-        if (timeout) |t| {
-            switch (std.c.pthread_cond_timedwait(&self.cond, mtx, &.{
-                .sec = @intCast(@divFloor(t, std.time.ns_per_s)),
-                .nsec = @intCast(@mod(t, std.time.ns_per_s)),
-            })) {
-                .SUCCESS => return,
-                .TIMEDOUT => return error.Timeout,
-                else => unreachable,
-            }
-        }
-
-        assert(std.c.pthread_cond_wait(&self.cond, mtx) == .SUCCESS);
-    }
-
-    fn wake(self: *Impl, comptime notify: Notify) void {
-        assert(switch (notify) {
-            .one => std.c.pthread_cond_signal(&self.cond),
-            .all => std.c.pthread_cond_broadcast(&self.cond),
-        } == .SUCCESS);
-    }
-};
-
-test "smoke test" {
-    var mutex = Mutex{};
-    var cond = Condition{};
-
-    // Try to wake outside the mutex
-    defer cond.signal();
-    defer cond.broadcast();
-
-    mutex.lock();
-    defer mutex.unlock();
-
-    // Try to wait with a timeout (should not deadlock)
-    try testing.expectError(error.Timeout, cond.timedWait(&mutex, 0));
-    try testing.expectError(error.Timeout, cond.timedWait(&mutex, std.time.ns_per_ms));
-
-    // Try to wake inside the mutex.
-    cond.signal();
-    cond.broadcast();
-}
-
-// Inspired from: https://github.com/Amanieu/parking_lot/pull/129
-test "wait and signal" {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const io = testing.io;
-
-    const num_threads = 4;
-
-    const MultiWait = struct {
-        mutex: Mutex = .{},
-        cond: Condition = .{},
-        threads: [num_threads]std.Thread = undefined,
-        spawn_count: std.math.IntFittingRange(0, num_threads) = 0,
-
-        fn run(self: *@This()) void {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-            self.spawn_count += 1;
-
-            self.cond.wait(&self.mutex);
-            self.cond.timedWait(&self.mutex, std.time.ns_per_ms) catch {};
-            self.cond.signal();
-        }
-    };
-
-    var multi_wait = MultiWait{};
-    for (&multi_wait.threads) |*t| {
-        t.* = try std.Thread.spawn(.{}, MultiWait.run, .{&multi_wait});
-    }
-
-    while (true) {
-        try std.Io.Clock.Duration.sleep(.{ .clock = .awake, .raw = .fromMilliseconds(100) }, io);
-
-        multi_wait.mutex.lock();
-        defer multi_wait.mutex.unlock();
-        // Make sure all of the threads have finished spawning to avoid a deadlock.
-        if (multi_wait.spawn_count == num_threads) break;
-    }
-
-    multi_wait.cond.signal();
-    for (multi_wait.threads) |t| {
-        t.join();
-    }
-}
-
-test signal {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const io = testing.io;
-
-    const num_threads = 4;
-
-    const SignalTest = struct {
-        mutex: Mutex = .{},
-        cond: Condition = .{},
-        notified: bool = false,
-        threads: [num_threads]std.Thread = undefined,
-        spawn_count: std.math.IntFittingRange(0, num_threads) = 0,
-
-        fn run(self: *@This()) void {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-            self.spawn_count += 1;
-
-            // Use timedWait() a few times before using wait()
-            // to test multiple threads timing out frequently.
-            var i: usize = 0;
-            while (!self.notified) : (i +%= 1) {
-                if (i < 5) {
-                    self.cond.timedWait(&self.mutex, 1) catch {};
-                } else {
-                    self.cond.wait(&self.mutex);
-                }
-            }
-
-            // Once we received the signal, notify another thread (inside the lock).
-            assert(self.notified);
-            self.cond.signal();
-        }
-    };
-
-    var signal_test = SignalTest{};
-    for (&signal_test.threads) |*t| {
-        t.* = try std.Thread.spawn(.{}, SignalTest.run, .{&signal_test});
-    }
-
-    while (true) {
-        try std.Io.Clock.Duration.sleep(.{ .clock = .awake, .raw = .fromMilliseconds(10) }, io);
-
-        signal_test.mutex.lock();
-        defer signal_test.mutex.unlock();
-        // Make sure at least one thread has finished spawning to avoid testing nothing.
-        if (signal_test.spawn_count > 0) break;
-    }
-
-    {
-        // Wake up one of them (outside the lock) after setting notified=true.
-        defer signal_test.cond.signal();
-
-        signal_test.mutex.lock();
-        defer signal_test.mutex.unlock();
-
-        try testing.expect(!signal_test.notified);
-        signal_test.notified = true;
-    }
-
-    for (signal_test.threads) |t| {
-        t.join();
-    }
-}
-
-test "multi signal" {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 4;
-    const num_iterations = 4;
-
-    const Paddle = struct {
-        mutex: Mutex = .{},
-        cond: Condition = .{},
-        value: u32 = 0,
-
-        fn hit(self: *@This()) void {
-            defer self.cond.signal();
-
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            self.value += 1;
-        }
-
-        fn run(self: *@This(), hit_to: *@This()) !void {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            var current: u32 = 0;
-            while (current < num_iterations) : (current += 1) {
-                // Wait for the value to change from hit()
-                while (self.value == current) {
-                    self.cond.wait(&self.mutex);
-                }
-
-                // hit the next paddle
-                try testing.expectEqual(self.value, current + 1);
-                hit_to.hit();
-            }
-        }
-    };
-
-    var paddles = [_]Paddle{.{}} ** num_threads;
-    var threads = [_]std.Thread{undefined} ** num_threads;
-
-    // Create a circle of paddles which hit each other
-    for (&threads, 0..) |*t, i| {
-        const paddle = &paddles[i];
-        const hit_to = &paddles[(i + 1) % paddles.len];
-        t.* = try std.Thread.spawn(.{}, Paddle.run, .{ paddle, hit_to });
-    }
-
-    // Hit the first paddle and wait for them all to complete by hitting each other for num_iterations.
-    paddles[0].hit();
-    for (threads) |t| t.join();
-
-    // The first paddle will be hit one last time by the last paddle.
-    for (paddles, 0..) |p, i| {
-        const expected = @as(u32, num_iterations) + @intFromBool(i == 0);
-        try testing.expectEqual(p.value, expected);
-    }
-}
-
-test broadcast {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 10;
-
-    const BroadcastTest = struct {
-        mutex: Mutex = .{},
-        cond: Condition = .{},
-        completed: Condition = .{},
-        count: usize = 0,
-        threads: [num_threads]std.Thread = undefined,
-
-        fn run(self: *@This()) void {
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            // The last broadcast thread to start tells the main test thread it's completed.
-            self.count += 1;
-            if (self.count == num_threads) {
-                self.completed.signal();
-            }
-
-            // Waits for the count to reach zero after the main test thread observes it at num_threads.
-            // Tries to use timedWait() a bit before falling back to wait() to test multiple threads timing out.
-            var i: usize = 0;
-            while (self.count != 0) : (i +%= 1) {
-                if (i < 10) {
-                    self.cond.timedWait(&self.mutex, 1) catch {};
-                } else {
-                    self.cond.wait(&self.mutex);
-                }
-            }
-        }
-    };
-
-    var broadcast_test = BroadcastTest{};
-    for (&broadcast_test.threads) |*t| {
-        t.* = try std.Thread.spawn(.{}, BroadcastTest.run, .{&broadcast_test});
-    }
-
-    {
-        broadcast_test.mutex.lock();
-        defer broadcast_test.mutex.unlock();
-
-        // Wait for all the broadcast threads to spawn.
-        // timedWait() to detect any potential deadlocks.
-        while (broadcast_test.count != num_threads) {
-            broadcast_test.completed.timedWait(
-                &broadcast_test.mutex,
-                1 * std.time.ns_per_s,
-            ) catch {};
-        }
-
-        // Reset the counter and wake all the threads to exit.
-        broadcast_test.count = 0;
-        broadcast_test.cond.broadcast();
-    }
-
-    for (broadcast_test.threads) |t| {
-        t.join();
-    }
-}
-
-test "broadcasting - wake all threads" {
-    // Tests issue #12877
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    var num_runs: usize = 1;
-    const num_threads = 10;
-
-    while (num_runs > 0) : (num_runs -= 1) {
-        const BroadcastTest = struct {
-            mutex: Mutex = .{},
-            cond: Condition = .{},
-            completed: Condition = .{},
-            count: usize = 0,
-            thread_id_to_wake: usize = 0,
-            threads: [num_threads]std.Thread = undefined,
-            wakeups: usize = 0,
-
-            fn run(self: *@This(), thread_id: usize) void {
-                self.mutex.lock();
-                defer self.mutex.unlock();
-
-                // The last broadcast thread to start tells the main test thread it's completed.
-                self.count += 1;
-                if (self.count == num_threads) {
-                    self.completed.signal();
-                }
-
-                while (self.thread_id_to_wake != thread_id) {
-                    self.cond.timedWait(&self.mutex, 1 * std.time.ns_per_s) catch {};
-                    self.wakeups += 1;
-                }
-                if (self.thread_id_to_wake <= num_threads) {
-                    // Signal next thread to wake up.
-                    self.thread_id_to_wake += 1;
-                    self.cond.broadcast();
-                }
-            }
-        };
-
-        var broadcast_test = BroadcastTest{};
-        var thread_id: usize = 1;
-        for (&broadcast_test.threads) |*t| {
-            t.* = try std.Thread.spawn(.{}, BroadcastTest.run, .{ &broadcast_test, thread_id });
-            thread_id += 1;
-        }
-
-        {
-            broadcast_test.mutex.lock();
-            defer broadcast_test.mutex.unlock();
-
-            // Wait for all the broadcast threads to spawn.
-            // timedWait() to detect any potential deadlocks.
-            while (broadcast_test.count != num_threads) {
-                broadcast_test.completed.timedWait(
-                    &broadcast_test.mutex,
-                    1 * std.time.ns_per_s,
-                ) catch {};
-            }
-
-            // Signal thread 1 to wake up
-            broadcast_test.thread_id_to_wake = 1;
-            broadcast_test.cond.broadcast();
-        }
-
-        for (broadcast_test.threads) |t| {
-            t.join();
-        }
-    }
-}
diff --git a/lib/std/Thread/Futex.zig b/lib/std/Thread/Futex.zig
deleted file mode 100644
index 7c44621d7221797a14e6163ce92c6b9e019c8cfd..0000000000000000000000000000000000000000
--- a/lib/std/Thread/Futex.zig
+++ /dev/null
@@ -1,1063 +0,0 @@
-//! A mechanism used to block (`wait`) and unblock (`wake`) threads using a
-//! 32bit memory address as hints.
-//!
-//! Blocking a thread is acknowledged only if the 32bit memory address is equal
-//! to a given value. This check helps avoid block/unblock deadlocks which
-//! occur if a `wake()` happens before a `wait()`.
-//!
-//! Using Futex, other Thread synchronization primitives can be built which
-//! efficiently wait for cross-thread events or signals.
-
-const std = @import("../std.zig");
-const builtin = @import("builtin");
-const Futex = @This();
-const windows = std.os.windows;
-const linux = std.os.linux;
-const c = std.c;
-
-const assert = std.debug.assert;
-const testing = std.testing;
-const atomic = std.atomic;
-
-/// Checks if `ptr` still contains the value `expect` and, if so, blocks the caller until either:
-/// - The value at `ptr` is no longer equal to `expect` and `wake()` is called on the same address.
-/// - The caller is unblocked spuriously ("at random").
-///
-/// The checking of `ptr` and `expect`, along with blocking the caller, is done atomically
-/// and totally ordered (sequentially consistent) with respect to other wait()/wake() calls on the same `ptr`.
-pub fn wait(ptr: *const atomic.Value(u32), expect: u32) void {
-    @branchHint(.cold);
-
-    Impl.wait(ptr, expect, null) catch |err| switch (err) {
-        error.Timeout => unreachable, // null timeout meant to wait forever
-    };
-}
-
-/// Checks if `ptr` still contains the value `expect` and, if so, blocks the caller until either:
-/// - The value at `ptr` is no longer equal to `expect`.
-/// - The caller is unblocked by a matching `wake()`.
-/// - The caller is unblocked spuriously ("at random").
-/// - The caller blocks for longer than the given timeout. In which case, `error.Timeout` is returned.
-///
-/// The checking of `ptr` and `expect`, along with blocking the caller, is done atomically
-/// and totally ordered (sequentially consistent) with respect to other wait()/wake() calls on the same `ptr`.
-pub fn timedWait(ptr: *const atomic.Value(u32), expect: u32, timeout_ns: u64) error{Timeout}!void {
-    @branchHint(.cold);
-
-    // Avoid calling into the OS for no-op timeouts.
-    if (timeout_ns == 0) {
-        if (ptr.load(.seq_cst) != expect) return;
-        return error.Timeout;
-    }
-
-    return Impl.wait(ptr, expect, timeout_ns);
-}
-
-/// Unblocks at most `max_waiters` callers blocked in a `wait()` call on `ptr`.
-pub fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-    @branchHint(.cold);
-
-    // Avoid calling into the OS if there's nothing to wake up.
-    if (max_waiters == 0) {
-        return;
-    }
-
-    Impl.wake(ptr, max_waiters);
-}
-
-const Impl = if (builtin.single_threaded)
-    SingleThreadedImpl
-else if (builtin.os.tag == .windows)
-    WindowsImpl
-else if (builtin.os.tag.isDarwin())
-    DarwinImpl
-else if (builtin.os.tag == .linux)
-    LinuxImpl
-else if (builtin.os.tag == .freebsd)
-    FreebsdImpl
-else if (builtin.os.tag == .openbsd)
-    OpenbsdImpl
-else if (builtin.os.tag == .dragonfly)
-    DragonflyImpl
-else if (builtin.target.cpu.arch.isWasm())
-    WasmImpl
-else if (std.Thread.use_pthreads)
-    PosixImpl
-else
-    UnsupportedImpl;
-
-/// We can't do @compileError() in the `Impl` switch statement above as its eagerly evaluated.
-/// So instead, we @compileError() on the methods themselves for platforms which don't support futex.
-const UnsupportedImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        return unsupported(.{ ptr, expect, timeout });
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        return unsupported(.{ ptr, max_waiters });
-    }
-
-    fn unsupported(unused: anytype) noreturn {
-        _ = unused;
-        @compileError("Unsupported operating system " ++ @tagName(builtin.target.os.tag));
-    }
-};
-
-const SingleThreadedImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        if (ptr.raw != expect) {
-            return;
-        }
-
-        // There are no threads to wake us up.
-        // So if we wait without a timeout we would never wake up.
-        const delay = timeout orelse {
-            unreachable; // deadlock detected
-        };
-
-        _ = delay;
-        return error.Timeout;
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        // There are no other threads to possibly wake up
-        _ = ptr;
-        _ = max_waiters;
-    }
-};
-
-// We use WaitOnAddress through NtDll instead of API-MS-Win-Core-Synch-l1-2-0.dll
-// as it's generally already a linked target and is autoloaded into all processes anyway.
-const WindowsImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        var timeout_value: windows.LARGE_INTEGER = undefined;
-        var timeout_ptr: ?*const windows.LARGE_INTEGER = null;
-
-        // NTDLL functions work with time in units of 100 nanoseconds.
-        // Positive values are absolute deadlines while negative values are relative durations.
-        if (timeout) |delay| {
-            timeout_value = @as(windows.LARGE_INTEGER, @intCast(delay / 100));
-            timeout_value = -timeout_value;
-            timeout_ptr = &timeout_value;
-        }
-
-        const rc = windows.ntdll.RtlWaitOnAddress(
-            ptr,
-            &expect,
-            @sizeOf(@TypeOf(expect)),
-            timeout_ptr,
-        );
-
-        switch (rc) {
-            .SUCCESS => {},
-            .TIMEOUT => {
-                assert(timeout != null);
-                return error.Timeout;
-            },
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        const address: ?*const anyopaque = ptr;
-        assert(max_waiters != 0);
-
-        switch (max_waiters) {
-            1 => windows.ntdll.RtlWakeAddressSingle(address),
-            else => windows.ntdll.RtlWakeAddressAll(address),
-        }
-    }
-};
-
-const DarwinImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        // Darwin XNU 7195.50.7.100.1 introduced __ulock_wait2 and migrated code paths (notably pthread_cond_t) towards it:
-        // https://github.com/apple/darwin-xnu/commit/d4061fb0260b3ed486147341b72468f836ed6c8f#diff-08f993cc40af475663274687b7c326cc6c3031e0db3ac8de7b24624610616be6
-        //
-        // This XNU version appears to correspond to 11.0.1:
-        // https://kernelshaman.blogspot.com/2021/01/building-xnu-for-macos-big-sur-1101.html
-        //
-        // ulock_wait() uses 32-bit micro-second timeouts where 0 = INFINITE or no-timeout
-        // ulock_wait2() uses 64-bit nano-second timeouts (with the same convention)
-        const supports_ulock_wait2 = builtin.target.os.version_range.semver.min.major >= 11;
-
-        var timeout_ns: u64 = 0;
-        if (timeout) |delay| {
-            assert(delay != 0); // handled by timedWait()
-            timeout_ns = delay;
-        }
-
-        // If we're using `__ulock_wait` and `timeout` is too big to fit inside a `u32` count of
-        // micro-seconds (around 70min), we'll request a shorter timeout. This is fine (users
-        // should handle spurious wakeups), but we need to remember that we did so, so that
-        // we don't return `Timeout` incorrectly. If that happens, we set this variable to
-        // true so that we we know to ignore the ETIMEDOUT result.
-        var timeout_overflowed = false;
-
-        const addr: *const anyopaque = ptr;
-        const flags: c.UL = .{
-            .op = .COMPARE_AND_WAIT,
-            .NO_ERRNO = true,
-        };
-        const status = blk: {
-            if (supports_ulock_wait2) {
-                break :blk c.__ulock_wait2(flags, addr, expect, timeout_ns, 0);
-            }
-
-            const timeout_us = std.math.cast(u32, timeout_ns / std.time.ns_per_us) orelse overflow: {
-                timeout_overflowed = true;
-                break :overflow std.math.maxInt(u32);
-            };
-
-            break :blk c.__ulock_wait(flags, addr, expect, timeout_us);
-        };
-
-        if (status >= 0) return;
-        switch (@as(c.E, @enumFromInt(-status))) {
-            // Wait was interrupted by the OS or other spurious signalling.
-            .INTR => {},
-            // Address of the futex was paged out. This is unlikely, but possible in theory, and
-            // pthread/libdispatch on darwin bother to handle it. In this case we'll return
-            // without waiting, but the caller should retry anyway.
-            .FAULT => {},
-            // Only report Timeout if we didn't have to cap the timeout
-            .TIMEDOUT => {
-                assert(timeout != null);
-                if (!timeout_overflowed) return error.Timeout;
-            },
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        const flags: c.UL = .{
-            .op = .COMPARE_AND_WAIT,
-            .NO_ERRNO = true,
-            .WAKE_ALL = max_waiters > 1,
-        };
-
-        while (true) {
-            const addr: *const anyopaque = ptr;
-            const status = c.__ulock_wake(flags, addr, 0);
-
-            if (status >= 0) return;
-            switch (@as(c.E, @enumFromInt(-status))) {
-                .INTR => continue, // spurious wake()
-                .FAULT => unreachable, // __ulock_wake doesn't generate EFAULT according to darwin pthread_cond_t
-                .NOENT => return, // nothing was woken up
-                .ALREADY => unreachable, // only for UL.Op.WAKE_THREAD
-                else => unreachable,
-            }
-        }
-    }
-};
-
-// https://man7.org/linux/man-pages/man2/futex.2.html
-const LinuxImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        var ts: linux.timespec = undefined;
-        if (timeout) |timeout_ns| {
-            ts.sec = @as(@TypeOf(ts.sec), @intCast(timeout_ns / std.time.ns_per_s));
-            ts.nsec = @as(@TypeOf(ts.nsec), @intCast(timeout_ns % std.time.ns_per_s));
-        }
-
-        const rc = linux.futex_4arg(
-            &ptr.raw,
-            .{ .cmd = .WAIT, .private = true },
-            expect,
-            if (timeout != null) &ts else null,
-        );
-
-        switch (linux.errno(rc)) {
-            .SUCCESS => {}, // notified by `wake()`
-            .INTR => {}, // spurious wakeup
-            .AGAIN => {}, // ptr.* != expect
-            .TIMEDOUT => {
-                assert(timeout != null);
-                return error.Timeout;
-            },
-            .INVAL => {}, // possibly timeout overflow
-            .FAULT => unreachable, // ptr was invalid
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        const rc = linux.futex_3arg(
-            &ptr.raw,
-            .{ .cmd = .WAKE, .private = true },
-            @min(max_waiters, std.math.maxInt(i32)),
-        );
-
-        switch (linux.errno(rc)) {
-            .SUCCESS => {}, // successful wake up
-            .INVAL => {}, // invalid futex_wait() on ptr done elsewhere
-            .FAULT => {}, // pointer became invalid while doing the wake
-            else => unreachable,
-        }
-    }
-};
-
-// https://www.freebsd.org/cgi/man.cgi?query=_umtx_op&sektion=2&n=1
-const FreebsdImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        var tm_size: usize = 0;
-        var tm: c._umtx_time = undefined;
-        var tm_ptr: ?*const c._umtx_time = null;
-
-        if (timeout) |timeout_ns| {
-            tm_ptr = &tm;
-            tm_size = @sizeOf(@TypeOf(tm));
-
-            tm.flags = 0; // use relative time not UMTX_ABSTIME
-            tm.clockid = .MONOTONIC;
-            tm.timeout.sec = @as(@TypeOf(tm.timeout.sec), @intCast(timeout_ns / std.time.ns_per_s));
-            tm.timeout.nsec = @as(@TypeOf(tm.timeout.nsec), @intCast(timeout_ns % std.time.ns_per_s));
-        }
-
-        const rc = c._umtx_op(
-            @intFromPtr(&ptr.raw),
-            @intFromEnum(c.UMTX_OP.WAIT_UINT_PRIVATE),
-            @as(c_ulong, expect),
-            tm_size,
-            @intFromPtr(tm_ptr),
-        );
-
-        switch (std.posix.errno(rc)) {
-            .SUCCESS => {},
-            .FAULT => unreachable, // one of the args points to invalid memory
-            .INVAL => unreachable, // arguments should be correct
-            .TIMEDOUT => {
-                assert(timeout != null);
-                return error.Timeout;
-            },
-            .INTR => {}, // spurious wake
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        const rc = c._umtx_op(
-            @intFromPtr(&ptr.raw),
-            @intFromEnum(c.UMTX_OP.WAKE_PRIVATE),
-            @as(c_ulong, max_waiters),
-            0, // there is no timeout struct
-            0, // there is no timeout struct pointer
-        );
-
-        switch (std.posix.errno(rc)) {
-            .SUCCESS => {},
-            .FAULT => {}, // it's ok if the ptr doesn't point to valid memory
-            .INVAL => unreachable, // arguments should be correct
-            else => unreachable,
-        }
-    }
-};
-
-// https://man.openbsd.org/futex.2
-const OpenbsdImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        var ts: c.timespec = undefined;
-        if (timeout) |timeout_ns| {
-            ts.sec = @as(@TypeOf(ts.sec), @intCast(timeout_ns / std.time.ns_per_s));
-            ts.nsec = @as(@TypeOf(ts.nsec), @intCast(timeout_ns % std.time.ns_per_s));
-        }
-
-        const rc = c.futex(
-            @as(*const volatile u32, @ptrCast(&ptr.raw)),
-            c.FUTEX.WAIT | c.FUTEX.PRIVATE_FLAG,
-            @as(c_int, @bitCast(expect)),
-            if (timeout != null) &ts else null,
-            null, // FUTEX.WAIT takes no requeue address
-        );
-
-        switch (std.posix.errno(rc)) {
-            .SUCCESS => {}, // woken up by wake
-            .NOSYS => unreachable, // the futex operation shouldn't be invalid
-            .FAULT => unreachable, // ptr was invalid
-            .AGAIN => {}, // ptr != expect
-            .INVAL => unreachable, // invalid timeout
-            .TIMEDOUT => {
-                assert(timeout != null);
-                return error.Timeout;
-            },
-            .INTR => {}, // spurious wake from signal
-            .CANCELED => {}, // spurious wake from signal with SA_RESTART
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        const rc = c.futex(
-            @as(*const volatile u32, @ptrCast(&ptr.raw)),
-            c.FUTEX.WAKE | c.FUTEX.PRIVATE_FLAG,
-            std.math.cast(c_int, max_waiters) orelse std.math.maxInt(c_int),
-            null, // FUTEX.WAKE takes no timeout ptr
-            null, // FUTEX.WAKE takes no requeue address
-        );
-
-        // returns number of threads woken up.
-        assert(rc >= 0);
-    }
-};
-
-// https://man.dragonflybsd.org/?command=umtx&section=2
-const DragonflyImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        // Dragonfly uses a scheme where 0 timeout means wait until signaled or spurious wake.
-        // It's reporting of timeout's is also unrealiable so we use an external timing source (Timer) instead.
-        var timeout_us: c_int = 0;
-        var timeout_overflowed = false;
-        var sleep_timer: std.time.Timer = undefined;
-
-        if (timeout) |delay| {
-            assert(delay != 0); // handled by timedWait().
-            timeout_us = std.math.cast(c_int, delay / std.time.ns_per_us) orelse blk: {
-                timeout_overflowed = true;
-                break :blk std.math.maxInt(c_int);
-            };
-
-            // Only need to record the start time if we can provide somewhat accurate error.Timeout's
-            if (!timeout_overflowed) {
-                sleep_timer = std.time.Timer.start() catch unreachable;
-            }
-        }
-
-        const value = @as(c_int, @bitCast(expect));
-        const addr = @as(*const volatile c_int, @ptrCast(&ptr.raw));
-        const rc = c.umtx_sleep(addr, value, timeout_us);
-
-        switch (std.posix.errno(rc)) {
-            .SUCCESS => {},
-            .BUSY => {}, // ptr != expect
-            .AGAIN => { // maybe timed out, or paged out, or hit 2s kernel refresh
-                if (timeout) |timeout_ns| {
-                    // Report error.Timeout only if we know the timeout duration has passed.
-                    // If not, there's not much choice other than treating it as a spurious wake.
-                    if (!timeout_overflowed and sleep_timer.read() >= timeout_ns) {
-                        return error.Timeout;
-                    }
-                }
-            },
-            .INTR => {}, // spurious wake
-            .INVAL => unreachable, // invalid timeout
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        // A count of zero means wake all waiters.
-        assert(max_waiters != 0);
-        const to_wake = std.math.cast(c_int, max_waiters) orelse 0;
-
-        // https://man.dragonflybsd.org/?command=umtx&section=2
-        // > umtx_wakeup() will generally return 0 unless the address is bad.
-        // We are fine with the address being bad (e.g. for Semaphore.post() where Semaphore.wait() frees the Semaphore)
-        const addr = @as(*const volatile c_int, @ptrCast(&ptr.raw));
-        _ = c.umtx_wakeup(addr, to_wake);
-    }
-};
-
-const WasmImpl = struct {
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        if (!comptime builtin.cpu.has(.wasm, .atomics)) @compileError("WASI target missing cpu feature 'atomics'");
-
-        const to: i64 = if (timeout) |to| @intCast(to) else -1;
-        const result = asm volatile (
-            \\local.get %[ptr]
-            \\local.get %[expected]
-            \\local.get %[timeout]
-            \\memory.atomic.wait32 0
-            \\local.set %[ret]
-            : [ret] "=r" (-> u32),
-            : [ptr] "r" (&ptr.raw),
-              [expected] "r" (@as(i32, @bitCast(expect))),
-              [timeout] "r" (to),
-        );
-        switch (result) {
-            0 => {}, // ok
-            1 => {}, // expected =! loaded
-            2 => return error.Timeout,
-            else => unreachable,
-        }
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        if (!comptime builtin.cpu.has(.wasm, .atomics)) @compileError("WASI target missing cpu feature 'atomics'");
-
-        assert(max_waiters != 0);
-        const woken_count = asm volatile (
-            \\local.get %[ptr]
-            \\local.get %[waiters]
-            \\memory.atomic.notify 0
-            \\local.set %[ret]
-            : [ret] "=r" (-> u32),
-            : [ptr] "r" (&ptr.raw),
-              [waiters] "r" (max_waiters),
-        );
-        _ = woken_count; // can be 0 when linker flag 'shared-memory' is not enabled
-    }
-};
-
-/// Modified version of linux's futex and Go's sema to implement userspace wait queues with pthread:
-/// https://code.woboq.org/linux/linux/kernel/futex.c.html
-/// https://go.dev/src/runtime/sema.go
-const PosixImpl = struct {
-    const Event = struct {
-        cond: c.pthread_cond_t,
-        mutex: c.pthread_mutex_t,
-        state: enum { empty, waiting, notified },
-
-        fn init(self: *Event) void {
-            // Use static init instead of pthread_cond/mutex_init() since this is generally faster.
-            self.cond = .{};
-            self.mutex = .{};
-            self.state = .empty;
-        }
-
-        fn deinit(self: *Event) void {
-            // Some platforms reportedly give EINVAL for statically initialized pthread types.
-            const rc = c.pthread_cond_destroy(&self.cond);
-            assert(rc == .SUCCESS or rc == .INVAL);
-
-            const rm = c.pthread_mutex_destroy(&self.mutex);
-            assert(rm == .SUCCESS or rm == .INVAL);
-
-            self.* = undefined;
-        }
-
-        fn wait(self: *Event, timeout: ?u64) error{Timeout}!void {
-            assert(c.pthread_mutex_lock(&self.mutex) == .SUCCESS);
-            defer assert(c.pthread_mutex_unlock(&self.mutex) == .SUCCESS);
-
-            // Early return if the event was already set.
-            if (self.state == .notified) {
-                return;
-            }
-
-            // Compute the absolute timeout if one was specified.
-            // POSIX requires that REALTIME is used by default for the pthread timedwait functions.
-            // This can be changed with pthread_condattr_setclock, but it's an extension and may not be available everywhere.
-            var ts: c.timespec = undefined;
-            if (timeout) |timeout_ns| {
-                ts = std.posix.clock_gettime(c.CLOCK.REALTIME) catch unreachable;
-                ts.sec +|= @as(@TypeOf(ts.sec), @intCast(timeout_ns / std.time.ns_per_s));
-                ts.nsec += @as(@TypeOf(ts.nsec), @intCast(timeout_ns % std.time.ns_per_s));
-
-                if (ts.nsec >= std.time.ns_per_s) {
-                    ts.sec +|= 1;
-                    ts.nsec -= std.time.ns_per_s;
-                }
-            }
-
-            // Start waiting on the event - there can be only one thread waiting.
-            assert(self.state == .empty);
-            self.state = .waiting;
-
-            while (true) {
-                // Block using either pthread_cond_wait or pthread_cond_timewait if there's an absolute timeout.
-                const rc = blk: {
-                    if (timeout == null) break :blk c.pthread_cond_wait(&self.cond, &self.mutex);
-                    break :blk c.pthread_cond_timedwait(&self.cond, &self.mutex, &ts);
-                };
-
-                // After waking up, check if the event was set.
-                if (self.state == .notified) {
-                    return;
-                }
-
-                assert(self.state == .waiting);
-                switch (rc) {
-                    .SUCCESS => {},
-                    .TIMEDOUT => {
-                        // If timed out, reset the event to avoid the set() thread doing an unnecessary signal().
-                        self.state = .empty;
-                        return error.Timeout;
-                    },
-                    .INVAL => unreachable, // cond, mutex, and potentially ts should all be valid
-                    .PERM => unreachable, // mutex is locked when cond_*wait() functions are called
-                    else => unreachable,
-                }
-            }
-        }
-
-        fn set(self: *Event) void {
-            assert(c.pthread_mutex_lock(&self.mutex) == .SUCCESS);
-            defer assert(c.pthread_mutex_unlock(&self.mutex) == .SUCCESS);
-
-            // Make sure that multiple calls to set() were not done on the same Event.
-            const old_state = self.state;
-            assert(old_state != .notified);
-
-            // Mark the event as set and wake up the waiting thread if there was one.
-            // This must be done while the mutex as the wait() thread could deallocate
-            // the condition variable once it observes the new state, potentially causing a UAF if done unlocked.
-            self.state = .notified;
-            if (old_state == .waiting) {
-                assert(c.pthread_cond_signal(&self.cond) == .SUCCESS);
-            }
-        }
-    };
-
-    const Treap = std.Treap(usize, std.math.order);
-    const Waiter = struct {
-        node: Treap.Node,
-        prev: ?*Waiter,
-        next: ?*Waiter,
-        tail: ?*Waiter,
-        is_queued: bool,
-        event: Event,
-    };
-
-    // An unordered set of Waiters
-    const WaitList = struct {
-        top: ?*Waiter = null,
-        len: usize = 0,
-
-        fn push(self: *WaitList, waiter: *Waiter) void {
-            waiter.next = self.top;
-            self.top = waiter;
-            self.len += 1;
-        }
-
-        fn pop(self: *WaitList) ?*Waiter {
-            const waiter = self.top orelse return null;
-            self.top = waiter.next;
-            self.len -= 1;
-            return waiter;
-        }
-    };
-
-    const WaitQueue = struct {
-        fn insert(treap: *Treap, address: usize, waiter: *Waiter) void {
-            // prepare the waiter to be inserted.
-            waiter.next = null;
-            waiter.is_queued = true;
-
-            // Find the wait queue entry associated with the address.
-            // If there isn't a wait queue on the address, this waiter creates the queue.
-            var entry = treap.getEntryFor(address);
-            const entry_node = entry.node orelse {
-                waiter.prev = null;
-                waiter.tail = waiter;
-                entry.set(&waiter.node);
-                return;
-            };
-
-            // There's a wait queue on the address; get the queue head and tail.
-            const head: *Waiter = @fieldParentPtr("node", entry_node);
-            const tail = head.tail orelse unreachable;
-
-            // Push the waiter to the tail by replacing it and linking to the previous tail.
-            head.tail = waiter;
-            tail.next = waiter;
-            waiter.prev = tail;
-        }
-
-        fn remove(treap: *Treap, address: usize, max_waiters: usize) WaitList {
-            // Find the wait queue associated with this address and get the head/tail if any.
-            var entry = treap.getEntryFor(address);
-            var queue_head: ?*Waiter = if (entry.node) |node| @fieldParentPtr("node", node) else null;
-            const queue_tail = if (queue_head) |head| head.tail else null;
-
-            // Once we're done updating the head, fix it's tail pointer and update the treap's queue head as well.
-            defer entry.set(blk: {
-                const new_head = queue_head orelse break :blk null;
-                new_head.tail = queue_tail;
-                break :blk &new_head.node;
-            });
-
-            var removed = WaitList{};
-            while (removed.len < max_waiters) {
-                // dequeue and collect waiters from their wait queue.
-                const waiter = queue_head orelse break;
-                queue_head = waiter.next;
-                removed.push(waiter);
-
-                // When dequeueing, we must mark is_queued as false.
-                // This ensures that a waiter which calls tryRemove() returns false.
-                assert(waiter.is_queued);
-                waiter.is_queued = false;
-            }
-
-            return removed;
-        }
-
-        fn tryRemove(treap: *Treap, address: usize, waiter: *Waiter) bool {
-            if (!waiter.is_queued) {
-                return false;
-            }
-
-            queue_remove: {
-                // Find the wait queue associated with the address.
-                var entry = blk: {
-                    // A waiter without a previous link means it's the queue head that's in the treap so we can avoid lookup.
-                    if (waiter.prev == null) {
-                        assert(waiter.node.key == address);
-                        break :blk treap.getEntryForExisting(&waiter.node);
-                    }
-                    break :blk treap.getEntryFor(address);
-                };
-
-                // The queue head and tail must exist if we're removing a queued waiter.
-                const head: *Waiter = @fieldParentPtr("node", entry.node orelse unreachable);
-                const tail = head.tail orelse unreachable;
-
-                // A waiter with a previous link is never the head of the queue.
-                if (waiter.prev) |prev| {
-                    assert(waiter != head);
-                    prev.next = waiter.next;
-
-                    // A waiter with both a previous and next link is in the middle.
-                    // We only need to update the surrounding waiter's links to remove it.
-                    if (waiter.next) |next| {
-                        assert(waiter != tail);
-                        next.prev = waiter.prev;
-                        break :queue_remove;
-                    }
-
-                    // A waiter with a previous but no next link means it's the tail of the queue.
-                    // In that case, we need to update the head's tail reference.
-                    assert(waiter == tail);
-                    head.tail = waiter.prev;
-                    break :queue_remove;
-                }
-
-                // A waiter with no previous link means it's the queue head of queue.
-                // We must replace (or remove) the head waiter reference in the treap.
-                assert(waiter == head);
-                entry.set(blk: {
-                    const new_head = waiter.next orelse break :blk null;
-                    new_head.tail = head.tail;
-                    break :blk &new_head.node;
-                });
-            }
-
-            // Mark the waiter as successfully removed.
-            waiter.is_queued = false;
-            return true;
-        }
-    };
-
-    const Bucket = struct {
-        mutex: c.pthread_mutex_t align(atomic.cache_line) = .{},
-        pending: atomic.Value(usize) = atomic.Value(usize).init(0),
-        treap: Treap = .{},
-
-        // Global array of buckets that addresses map to.
-        // Bucket array size is pretty much arbitrary here, but it must be a power of two for fibonacci hashing.
-        var buckets = [_]Bucket{.{}} ** @bitSizeOf(usize);
-
-        // https://github.com/Amanieu/parking_lot/blob/1cf12744d097233316afa6c8b7d37389e4211756/core/src/parking_lot.rs#L343-L353
-        fn from(address: usize) *Bucket {
-            // The upper `@bitSizeOf(usize)` bits of the fibonacci golden ratio.
-            // Hashing this via (h * k) >> (64 - b) where k=golden-ration and b=bitsize-of-array
-            // evenly lays out h=hash values over the bit range even when the hash has poor entropy (identity-hash for pointers).
-            const max_multiplier_bits = @bitSizeOf(usize);
-            const fibonacci_multiplier = 0x9E3779B97F4A7C15 >> (64 - max_multiplier_bits);
-
-            const max_bucket_bits = @ctz(buckets.len);
-            comptime assert(std.math.isPowerOfTwo(buckets.len));
-
-            const index = (address *% fibonacci_multiplier) >> (max_multiplier_bits - max_bucket_bits);
-            return &buckets[index];
-        }
-    };
-
-    const Address = struct {
-        fn from(ptr: *const atomic.Value(u32)) usize {
-            // Get the alignment of the pointer.
-            const alignment = @alignOf(atomic.Value(u32));
-            comptime assert(std.math.isPowerOfTwo(alignment));
-
-            // Make sure the pointer is aligned,
-            // then cut off the zero bits from the alignment to get the unique address.
-            const addr = @intFromPtr(ptr);
-            assert(addr & (alignment - 1) == 0);
-            return addr >> @ctz(@as(usize, alignment));
-        }
-    };
-
-    fn wait(ptr: *const atomic.Value(u32), expect: u32, timeout: ?u64) error{Timeout}!void {
-        const address = Address.from(ptr);
-        const bucket = Bucket.from(address);
-
-        // Announce that there's a waiter in the bucket before checking the ptr/expect condition.
-        // If the announcement is reordered after the ptr check, the waiter could deadlock:
-        //
-        // - T1: checks ptr == expect which is true
-        // - T2: updates ptr to != expect
-        // - T2: does Futex.wake(), sees no pending waiters, exits
-        // - T1: bumps pending waiters (was reordered after the ptr == expect check)
-        // - T1: goes to sleep and misses both the ptr change and T2's wake up
-        //
-        // acquire barrier to ensure the announcement happens before the ptr check below.
-        var pending = bucket.pending.fetchAdd(1, .acquire);
-        assert(pending < std.math.maxInt(usize));
-
-        // If the wait gets canceled, remove the pending count we previously added.
-        // This is done outside the mutex lock to keep the critical section short in case of contention.
-        var canceled = false;
-        defer if (canceled) {
-            pending = bucket.pending.fetchSub(1, .monotonic);
-            assert(pending > 0);
-        };
-
-        var waiter: Waiter = undefined;
-        {
-            assert(c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);
-            defer assert(c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);
-
-            canceled = ptr.load(.monotonic) != expect;
-            if (canceled) {
-                return;
-            }
-
-            waiter.event.init();
-            WaitQueue.insert(&bucket.treap, address, &waiter);
-        }
-
-        defer {
-            assert(!waiter.is_queued);
-            waiter.event.deinit();
-        }
-
-        waiter.event.wait(timeout) catch {
-            // If we fail to cancel after a timeout, it means a wake() thread dequeued us and will wake us up.
-            // We must wait until the event is set as that's a signal that the wake() thread won't access the waiter memory anymore.
-            // If we return early without waiting, the waiter on the stack would be invalidated and the wake() thread risks a UAF.
-            defer if (!canceled) waiter.event.wait(null) catch unreachable;
-
-            assert(c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);
-            defer assert(c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);
-
-            canceled = WaitQueue.tryRemove(&bucket.treap, address, &waiter);
-            if (canceled) {
-                return error.Timeout;
-            }
-        };
-    }
-
-    fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
-        const address = Address.from(ptr);
-        const bucket = Bucket.from(address);
-
-        // Quick check if there's even anything to wake up.
-        // The change to the ptr's value must happen before we check for pending waiters.
-        // If not, the wake() thread could miss a sleeping waiter and have it deadlock:
-        //
-        // - T2: p = has pending waiters (reordered before the ptr update)
-        // - T1: bump pending waiters
-        // - T1: if ptr == expected: sleep()
-        // - T2: update ptr != expected
-        // - T2: p is false from earlier so doesn't wake (T1 missed ptr update and T2 missed T1 sleeping)
-        //
-        // What we really want here is a Release load, but that doesn't exist under the C11 memory model.
-        // We could instead do `bucket.pending.fetchAdd(0, Release) == 0` which achieves effectively the same thing,
-        // LLVM lowers the fetchAdd(0, .release) into an mfence+load which avoids gaining ownership of the cache-line.
-        if (bucket.pending.fetchAdd(0, .release) == 0) {
-            return;
-        }
-
-        // Keep a list of all the waiters notified and wake then up outside the mutex critical section.
-        var notified = WaitList{};
-        defer if (notified.len > 0) {
-            const pending = bucket.pending.fetchSub(notified.len, .monotonic);
-            assert(pending >= notified.len);
-
-            while (notified.pop()) |waiter| {
-                assert(!waiter.is_queued);
-                waiter.event.set();
-            }
-        };
-
-        assert(c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);
-        defer assert(c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);
-
-        // Another pending check again to avoid the WaitQueue lookup if not necessary.
-        if (bucket.pending.load(.monotonic) > 0) {
-            notified = WaitQueue.remove(&bucket.treap, address, max_waiters);
-        }
-    }
-};
-
-test "smoke test" {
-    var value = atomic.Value(u32).init(0);
-
-    // Try waits with invalid values.
-    Futex.wait(&value, 0xdeadbeef);
-    Futex.timedWait(&value, 0xdeadbeef, 0) catch {};
-
-    // Try timeout waits.
-    try testing.expectError(error.Timeout, Futex.timedWait(&value, 0, 0));
-    try testing.expectError(error.Timeout, Futex.timedWait(&value, 0, std.time.ns_per_ms));
-
-    // Try wakes
-    Futex.wake(&value, 0);
-    Futex.wake(&value, 1);
-    Futex.wake(&value, std.math.maxInt(u32));
-}
-
-test "signaling" {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 4;
-    const num_iterations = 4;
-
-    const Paddle = struct {
-        value: atomic.Value(u32) = atomic.Value(u32).init(0),
-        current: u32 = 0,
-
-        fn hit(self: *@This()) void {
-            _ = self.value.fetchAdd(1, .release);
-            Futex.wake(&self.value, 1);
-        }
-
-        fn run(self: *@This(), hit_to: *@This()) !void {
-            while (self.current < num_iterations) {
-                // Wait for the value to change from hit()
-                var new_value: u32 = undefined;
-                while (true) {
-                    new_value = self.value.load(.acquire);
-                    if (new_value != self.current) break;
-                    Futex.wait(&self.value, self.current);
-                }
-
-                // change the internal "current" value
-                try testing.expectEqual(new_value, self.current + 1);
-                self.current = new_value;
-
-                // hit the next paddle
-                hit_to.hit();
-            }
-        }
-    };
-
-    var paddles = [_]Paddle{.{}} ** num_threads;
-    var threads = [_]std.Thread{undefined} ** num_threads;
-
-    // Create a circle of paddles which hit each other
-    for (&threads, 0..) |*t, i| {
-        const paddle = &paddles[i];
-        const hit_to = &paddles[(i + 1) % paddles.len];
-        t.* = try std.Thread.spawn(.{}, Paddle.run, .{ paddle, hit_to });
-    }
-
-    // Hit the first paddle and wait for them all to complete by hitting each other for num_iterations.
-    paddles[0].hit();
-    for (threads) |t| t.join();
-    for (paddles) |p| try testing.expectEqual(p.current, num_iterations);
-}
-
-test "broadcasting" {
-    // This test requires spawning threads
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 4;
-    const num_iterations = 4;
-
-    const Barrier = struct {
-        count: atomic.Value(u32) = atomic.Value(u32).init(num_threads),
-        futex: atomic.Value(u32) = atomic.Value(u32).init(0),
-
-        fn wait(self: *@This()) !void {
-            // Decrement the counter.
-            // Release ensures stuff before this barrier.wait() happens before the last one.
-            // Acquire for the last counter ensures stuff before previous barrier.wait()s happened before it.
-            const count = self.count.fetchSub(1, .acq_rel);
-            try testing.expect(count <= num_threads);
-            try testing.expect(count > 0);
-
-            // First counter to reach zero wakes all other threads.
-            // Release on futex update ensures stuff before all barrier.wait()'s happens before they all return.
-            if (count - 1 == 0) {
-                self.futex.store(1, .release);
-                Futex.wake(&self.futex, num_threads - 1);
-                return;
-            }
-
-            // Other threads wait until last counter wakes them up.
-            // Acquire on futex synchronizes with last barrier count to ensure stuff before all barrier.wait()'s happen before us.
-            while (self.futex.load(.acquire) == 0) {
-                Futex.wait(&self.futex, 0);
-            }
-        }
-    };
-
-    const Broadcast = struct {
-        barriers: [num_iterations]Barrier = [_]Barrier{.{}} ** num_iterations,
-        threads: [num_threads]std.Thread = undefined,
-
-        fn run(self: *@This()) !void {
-            for (&self.barriers) |*barrier| {
-                try barrier.wait();
-            }
-        }
-    };
-
-    var broadcast = Broadcast{};
-    for (&broadcast.threads) |*t| t.* = try std.Thread.spawn(.{}, Broadcast.run, .{&broadcast});
-    for (broadcast.threads) |t| t.join();
-}
-
-/// Deadline is used to wait efficiently for a pointer's value to change using Futex and a fixed timeout.
-///
-/// Futex's timedWait() api uses a relative duration which suffers from over-waiting
-/// when used in a loop which is often required due to the possibility of spurious wakeups.
-///
-/// Deadline instead converts the relative timeout to an absolute one so that multiple calls
-/// to Futex timedWait() can block for and report more accurate error.Timeouts.
-pub const Deadline = struct {
-    timeout: ?u64,
-    started: std.time.Timer,
-
-    /// Create the deadline to expire after the given amount of time in nanoseconds passes.
-    /// Pass in `null` to have the deadline call `Futex.wait()` and never expire.
-    pub fn init(expires_in_ns: ?u64) Deadline {
-        var deadline: Deadline = undefined;
-        deadline.timeout = expires_in_ns;
-
-        // std.time.Timer is required to be supported for somewhat accurate reportings of error.Timeout.
-        if (deadline.timeout != null) {
-            deadline.started = std.time.Timer.start() catch unreachable;
-        }
-
-        return deadline;
-    }
-
-    /// Wait until either:
-    /// - the `ptr`'s value changes from `expect`.
-    /// - `Futex.wake()` is called on the `ptr`.
-    /// - A spurious wake occurs.
-    /// - The deadline expires; In which case `error.Timeout` is returned.
-    pub fn wait(self: *Deadline, ptr: *const atomic.Value(u32), expect: u32) error{Timeout}!void {
-        @branchHint(.cold);
-
-        // Check if we actually have a timeout to wait until.
-        // If not just wait "forever".
-        const timeout_ns = self.timeout orelse {
-            return Futex.wait(ptr, expect);
-        };
-
-        // Get how much time has passed since we started waiting
-        // then subtract that from the init() timeout to get how much longer to wait.
-        // Use overflow to detect when we've been waiting longer than the init() timeout.
-        const elapsed_ns = self.started.read();
-        const until_timeout_ns = std.math.sub(u64, timeout_ns, elapsed_ns) catch 0;
-        return Futex.timedWait(ptr, expect, until_timeout_ns);
-    }
-};
-
-test "Deadline" {
-    var deadline = Deadline.init(100 * std.time.ns_per_ms);
-    var futex_word = atomic.Value(u32).init(0);
-
-    while (true) {
-        deadline.wait(&futex_word, 0) catch break;
-    }
-}
diff --git a/lib/std/Thread/Mutex.zig b/lib/std/Thread/Mutex.zig
deleted file mode 100644
index eb0dd42ceb6bb7e024e3fdbec12d1e4802d1863b..0000000000000000000000000000000000000000
--- a/lib/std/Thread/Mutex.zig
+++ /dev/null
@@ -1,367 +0,0 @@
-//! Mutex is a synchronization primitive which enforces atomic access to a
-//! shared region of code known as the "critical section".
-//!
-//! It does this by blocking ensuring only one thread is in the critical
-//! section at any given point in time by blocking the others.
-//!
-//! Mutex can be statically initialized and is at most `@sizeOf(u64)` large.
-//! Use `lock()` or `tryLock()` to enter the critical section and `unlock()` to leave it.
-
-const std = @import("../std.zig");
-const builtin = @import("builtin");
-const Mutex = @This();
-
-const assert = std.debug.assert;
-const testing = std.testing;
-const Thread = std.Thread;
-const Futex = Thread.Futex;
-
-impl: Impl = .{},
-
-pub const Recursive = @import("Mutex/Recursive.zig");
-
-/// Tries to acquire the mutex without blocking the caller's thread.
-/// Returns `false` if the calling thread would have to block to acquire it.
-/// Otherwise, returns `true` and the caller should `unlock()` the Mutex to release it.
-pub fn tryLock(self: *Mutex) bool {
-    return self.impl.tryLock();
-}
-
-/// Acquires the mutex, blocking the caller's thread until it can.
-/// It is undefined behavior if the mutex is already held by the caller's thread.
-/// Once acquired, call `unlock()` on the Mutex to release it.
-pub fn lock(self: *Mutex) void {
-    self.impl.lock();
-}
-
-/// Releases the mutex which was previously acquired with `lock()` or `tryLock()`.
-/// It is undefined behavior if the mutex is unlocked from a different thread that it was locked from.
-pub fn unlock(self: *Mutex) void {
-    self.impl.unlock();
-}
-
-const Impl = if (builtin.mode == .Debug and !builtin.single_threaded)
-    DebugImpl
-else
-    ReleaseImpl;
-
-const ReleaseImpl = Impl: {
-    if (builtin.single_threaded) break :Impl SingleThreadedImpl;
-    if (builtin.os.tag == .windows) break :Impl WindowsImpl;
-    if (builtin.os.tag.isDarwin()) break :Impl DarwinImpl;
-
-    if (builtin.target.os.tag == .linux or
-        builtin.target.os.tag == .freebsd or
-        builtin.target.os.tag == .openbsd or
-        builtin.target.os.tag == .dragonfly or
-        builtin.target.cpu.arch.isWasm())
-    {
-        // Futex is the system's synchronization primitive; use that.
-        break :Impl FutexImpl;
-    }
-
-    if (std.Thread.use_pthreads) {
-        // This system doesn't have a futex primitive, so `std.Thread.Futex` is using `PosixImpl`,
-        // which implements futex *on top of* pthread mutexes and conditions. Therefore, instead
-        // of going through that long inefficient path, just use pthread mutex directly.
-        break :Impl PosixImpl;
-    }
-
-    break :Impl FutexImpl;
-};
-
-const DebugImpl = struct {
-    locking_thread: std.atomic.Value(Thread.Id) = std.atomic.Value(Thread.Id).init(0), // 0 means it's not locked.
-    impl: ReleaseImpl = .{},
-
-    inline fn tryLock(self: *@This()) bool {
-        const locking = self.impl.tryLock();
-        if (locking) {
-            self.locking_thread.store(Thread.getCurrentId(), .unordered);
-        }
-        return locking;
-    }
-
-    inline fn lock(self: *@This()) void {
-        const current_id = Thread.getCurrentId();
-        if (self.locking_thread.load(.unordered) == current_id and current_id != 0) {
-            @panic("Deadlock detected");
-        }
-        self.impl.lock();
-        self.locking_thread.store(current_id, .unordered);
-    }
-
-    inline fn unlock(self: *@This()) void {
-        assert(self.locking_thread.load(.unordered) == Thread.getCurrentId());
-        self.locking_thread.store(0, .unordered);
-        self.impl.unlock();
-    }
-};
-
-const SingleThreadedImpl = struct {
-    is_locked: bool = false,
-
-    fn tryLock(self: *@This()) bool {
-        if (self.is_locked) return false;
-        self.is_locked = true;
-        return true;
-    }
-
-    fn lock(self: *@This()) void {
-        if (!self.tryLock()) {
-            unreachable; // deadlock detected
-        }
-    }
-
-    fn unlock(self: *@This()) void {
-        assert(self.is_locked);
-        self.is_locked = false;
-    }
-};
-
-/// SRWLOCK on windows is almost always faster than Futex solution.
-/// It also implements an efficient Condition with requeue support for us.
-const WindowsImpl = struct {
-    srwlock: windows.SRWLOCK = .{},
-
-    fn tryLock(self: *@This()) bool {
-        return windows.ntdll.RtlTryAcquireSRWLockExclusive(&self.srwlock) != windows.FALSE;
-    }
-
-    fn lock(self: *@This()) void {
-        windows.ntdll.RtlAcquireSRWLockExclusive(&self.srwlock);
-    }
-
-    fn unlock(self: *@This()) void {
-        windows.ntdll.RtlReleaseSRWLockExclusive(&self.srwlock);
-    }
-
-    const windows = std.os.windows;
-};
-
-/// os_unfair_lock on darwin supports priority inheritance and is generally faster than Futex solutions.
-const DarwinImpl = struct {
-    oul: c.os_unfair_lock = .{},
-
-    fn tryLock(self: *@This()) bool {
-        return c.os_unfair_lock_trylock(&self.oul);
-    }
-
-    fn lock(self: *@This()) void {
-        c.os_unfair_lock_lock(&self.oul);
-    }
-
-    fn unlock(self: *@This()) void {
-        c.os_unfair_lock_unlock(&self.oul);
-    }
-
-    const c = std.c;
-};
-
-const FutexImpl = struct {
-    state: std.atomic.Value(u32) = std.atomic.Value(u32).init(unlocked),
-
-    const unlocked: u32 = 0b00;
-    const locked: u32 = 0b01;
-    const contended: u32 = 0b11; // must contain the `locked` bit for x86 optimization below
-
-    fn lock(self: *@This()) void {
-        if (!self.tryLock())
-            self.lockSlow();
-    }
-
-    fn tryLock(self: *@This()) bool {
-        // On x86, use `lock bts` instead of `lock cmpxchg` as:
-        // - they both seem to mark the cache-line as modified regardless: https://stackoverflow.com/a/63350048
-        // - `lock bts` is smaller instruction-wise which makes it better for inlining
-        if (builtin.target.cpu.arch.isX86()) {
-            const locked_bit = @ctz(locked);
-            return self.state.bitSet(locked_bit, .acquire) == 0;
-        }
-
-        // Acquire barrier ensures grabbing the lock happens before the critical section
-        // and that the previous lock holder's critical section happens before we grab the lock.
-        return self.state.cmpxchgWeak(unlocked, locked, .acquire, .monotonic) == null;
-    }
-
-    fn lockSlow(self: *@This()) void {
-        @branchHint(.cold);
-
-        // Avoid doing an atomic swap below if we already know the state is contended.
-        // An atomic swap unconditionally stores which marks the cache-line as modified unnecessarily.
-        if (self.state.load(.monotonic) == contended) {
-            Futex.wait(&self.state, contended);
-        }
-
-        // Try to acquire the lock while also telling the existing lock holder that there are threads waiting.
-        //
-        // Once we sleep on the Futex, we must acquire the mutex using `contended` rather than `locked`.
-        // If not, threads sleeping on the Futex wouldn't see the state change in unlock and potentially deadlock.
-        // The downside is that the last mutex unlocker will see `contended` and do an unnecessary Futex wake
-        // but this is better than having to wake all waiting threads on mutex unlock.
-        //
-        // Acquire barrier ensures grabbing the lock happens before the critical section
-        // and that the previous lock holder's critical section happens before we grab the lock.
-        while (self.state.swap(contended, .acquire) != unlocked) {
-            Futex.wait(&self.state, contended);
-        }
-    }
-
-    fn unlock(self: *@This()) void {
-        // Unlock the mutex and wake up a waiting thread if any.
-        //
-        // A waiting thread will acquire with `contended` instead of `locked`
-        // which ensures that it wakes up another thread on the next unlock().
-        //
-        // Release barrier ensures the critical section happens before we let go of the lock
-        // and that our critical section happens before the next lock holder grabs the lock.
-        const state = self.state.swap(unlocked, .release);
-        assert(state != unlocked);
-
-        if (state == contended) {
-            Futex.wake(&self.state, 1);
-        }
-    }
-};
-
-const PosixImpl = struct {
-    mutex: std.c.pthread_mutex_t = .{},
-
-    fn tryLock(impl: *PosixImpl) bool {
-        switch (std.c.pthread_mutex_trylock(&impl.mutex)) {
-            .SUCCESS => return true,
-            .BUSY => return false,
-            .INVAL => unreachable, // mutex is initialized correctly
-            else => unreachable,
-        }
-    }
-
-    fn lock(impl: *PosixImpl) void {
-        switch (std.c.pthread_mutex_lock(&impl.mutex)) {
-            .SUCCESS => return,
-            .INVAL => unreachable, // mutex is initialized correctly
-            .DEADLK => unreachable, // not an error checking mutex
-            else => unreachable,
-        }
-    }
-
-    fn unlock(impl: *PosixImpl) void {
-        switch (std.c.pthread_mutex_unlock(&impl.mutex)) {
-            .SUCCESS => return,
-            .INVAL => unreachable, // mutex is initialized correctly
-            .PERM => unreachable, // not an error checking mutex
-            else => unreachable,
-        }
-    }
-};
-
-test "smoke test" {
-    var mutex = Mutex{};
-
-    try testing.expect(mutex.tryLock());
-    try testing.expect(!mutex.tryLock());
-    mutex.unlock();
-
-    mutex.lock();
-    try testing.expect(!mutex.tryLock());
-    mutex.unlock();
-}
-
-// A counter which is incremented without atomic instructions
-const NonAtomicCounter = struct {
-    // direct u128 could maybe use xmm ops on x86 which are atomic
-    value: [2]u64 = [_]u64{ 0, 0 },
-
-    fn get(self: NonAtomicCounter) u128 {
-        return @as(u128, @bitCast(self.value));
-    }
-
-    fn inc(self: *NonAtomicCounter) void {
-        for (@as([2]u64, @bitCast(self.get() + 1)), 0..) |v, i| {
-            @as(*volatile u64, @ptrCast(&self.value[i])).* = v;
-        }
-    }
-};
-
-test "many uncontended" {
-    // This test requires spawning threads.
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 4;
-    const num_increments = 1000;
-
-    const Runner = struct {
-        mutex: Mutex = .{},
-        thread: Thread = undefined,
-        counter: NonAtomicCounter = .{},
-
-        fn run(self: *@This()) void {
-            var i: usize = num_increments;
-            while (i > 0) : (i -= 1) {
-                self.mutex.lock();
-                defer self.mutex.unlock();
-
-                self.counter.inc();
-            }
-        }
-    };
-
-    var runners = [_]Runner{.{}} ** num_threads;
-    for (&runners) |*r| r.thread = try Thread.spawn(.{}, Runner.run, .{r});
-    for (runners) |r| r.thread.join();
-    for (runners) |r| try testing.expectEqual(r.counter.get(), num_increments);
-}
-
-test "many contended" {
-    // This test requires spawning threads.
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const num_threads = 4;
-    const num_increments = 1000;
-
-    const Runner = struct {
-        mutex: Mutex = .{},
-        counter: NonAtomicCounter = .{},
-
-        fn run(self: *@This()) void {
-            var i: usize = num_increments;
-            while (i > 0) : (i -= 1) {
-                // Occasionally hint to let another thread run.
-                defer if (i % 100 == 0) Thread.yield() catch {};
-
-                self.mutex.lock();
-                defer self.mutex.unlock();
-
-                self.counter.inc();
-            }
-        }
-    };
-
-    var runner = Runner{};
-
-    var threads: [num_threads]Thread = undefined;
-    for (&threads) |*t| t.* = try Thread.spawn(.{}, Runner.run, .{&runner});
-    for (threads) |t| t.join();
-
-    try testing.expectEqual(runner.counter.get(), num_increments * num_threads);
-}
-
-// https://github.com/ziglang/zig/issues/19295
-//test @This() {
-//    var m: Mutex = .{};
-//
-//    {
-//        m.lock();
-//        defer m.unlock();
-//        // ... critical section code
-//    }
-//
-//    if (m.tryLock()) {
-//        defer m.unlock();
-//        // ... critical section code
-//    }
-//}
diff --git a/lib/std/Thread/Mutex/Recursive.zig b/lib/std/Thread/Mutex/Recursive.zig
index d6d90ed648429d52df84ad8e0cc49402002bc131..8fa0563fb36b1eeaa0edd9c7d9b9d864b379db73 100644
--- a/lib/std/Thread/Mutex/Recursive.zig
+++ b/lib/std/Thread/Mutex/Recursive.zig
@@ -7,18 +7,18 @@
 //! A recursive mutex is an abstraction layer on top of a regular mutex;
 //! therefore it is recommended to use instead `std.Mutex` unless there is a
 //! specific reason a recursive mutex is warranted.
-
-const std = @import("../../std.zig");
 const Recursive = @This();
-const Mutex = std.Thread.Mutex;
+
+const std = @import("../../std.zig");
+const Io = std.Io;
 const assert = std.debug.assert;
 
-mutex: Mutex,
+mutex: Io.Mutex,
 thread_id: std.Thread.Id,
 lock_count: usize,
 
 pub const init: Recursive = .{
-    .mutex = .{},
+    .mutex = .init,
     .thread_id = invalid_thread_id,
     .lock_count = 0,
 };
@@ -49,7 +49,7 @@ pub fn tryLock(r: *Recursive) bool {
 pub fn lock(r: *Recursive) void {
     const current_thread_id = std.Thread.getCurrentId();
     if (@atomicLoad(std.Thread.Id, &r.thread_id, .unordered) != current_thread_id) {
-        r.mutex.lock();
+        Io.Threaded.mutexLock(&r.mutex);
         assert(r.lock_count == 0);
         @atomicStore(std.Thread.Id, &r.thread_id, current_thread_id, .unordered);
     }
@@ -64,7 +64,7 @@ pub fn unlock(r: *Recursive) void {
     r.lock_count -= 1;
     if (r.lock_count == 0) {
         @atomicStore(std.Thread.Id, &r.thread_id, invalid_thread_id, .unordered);
-        r.mutex.unlock();
+        Io.Threaded.mutexUnlock(&r.mutex);
     }
 }
 
diff --git a/lib/std/Thread/RwLock.zig b/lib/std/Thread/RwLock.zig
deleted file mode 100644
index 3e032c7c00cc85335df4d5172c89afb0bb5a8c51..0000000000000000000000000000000000000000
--- a/lib/std/Thread/RwLock.zig
+++ /dev/null
@@ -1,386 +0,0 @@
-//! A lock that supports one writer or many readers.
-//! This API is for kernel threads, not evented I/O.
-//! This API requires being initialized at runtime, and initialization
-//! can fail. Once initialized, the core operations cannot fail.
-
-impl: Impl = .{},
-
-const RwLock = @This();
-const std = @import("../std.zig");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-const testing = std.testing;
-
-pub const Impl = if (builtin.single_threaded)
-    SingleThreadedRwLock
-else if (std.Thread.use_pthreads)
-    PthreadRwLock
-else
-    DefaultRwLock;
-
-/// Attempts to obtain exclusive lock ownership.
-/// Returns `true` if the lock is obtained, `false` otherwise.
-pub fn tryLock(rwl: *RwLock) bool {
-    return rwl.impl.tryLock();
-}
-
-/// Blocks until exclusive lock ownership is acquired.
-pub fn lock(rwl: *RwLock) void {
-    return rwl.impl.lock();
-}
-
-/// Releases a held exclusive lock.
-/// Asserts the lock is held exclusively.
-pub fn unlock(rwl: *RwLock) void {
-    return rwl.impl.unlock();
-}
-
-/// Attempts to obtain shared lock ownership.
-/// Returns `true` if the lock is obtained, `false` otherwise.
-pub fn tryLockShared(rwl: *RwLock) bool {
-    return rwl.impl.tryLockShared();
-}
-
-/// Obtains shared lock ownership.
-/// Blocks if another thread has exclusive ownership.
-/// May block if another thread is attempting to get exclusive ownership.
-pub fn lockShared(rwl: *RwLock) void {
-    return rwl.impl.lockShared();
-}
-
-/// Releases a held shared lock.
-pub fn unlockShared(rwl: *RwLock) void {
-    return rwl.impl.unlockShared();
-}
-
-/// Single-threaded applications use this for deadlock checks in
-/// debug mode, and no-ops in release modes.
-pub const SingleThreadedRwLock = struct {
-    state: enum { unlocked, locked_exclusive, locked_shared } = .unlocked,
-    shared_count: usize = 0,
-
-    /// Attempts to obtain exclusive lock ownership.
-    /// Returns `true` if the lock is obtained, `false` otherwise.
-    pub fn tryLock(rwl: *SingleThreadedRwLock) bool {
-        switch (rwl.state) {
-            .unlocked => {
-                assert(rwl.shared_count == 0);
-                rwl.state = .locked_exclusive;
-                return true;
-            },
-            .locked_exclusive, .locked_shared => return false,
-        }
-    }
-
-    /// Blocks until exclusive lock ownership is acquired.
-    pub fn lock(rwl: *SingleThreadedRwLock) void {
-        assert(rwl.state == .unlocked); // deadlock detected
-        assert(rwl.shared_count == 0); // corrupted state detected
-        rwl.state = .locked_exclusive;
-    }
-
-    /// Releases a held exclusive lock.
-    /// Asserts the lock is held exclusively.
-    pub fn unlock(rwl: *SingleThreadedRwLock) void {
-        assert(rwl.state == .locked_exclusive);
-        assert(rwl.shared_count == 0); // corrupted state detected
-        rwl.state = .unlocked;
-    }
-
-    /// Attempts to obtain shared lock ownership.
-    /// Returns `true` if the lock is obtained, `false` otherwise.
-    pub fn tryLockShared(rwl: *SingleThreadedRwLock) bool {
-        switch (rwl.state) {
-            .unlocked => {
-                rwl.state = .locked_shared;
-                assert(rwl.shared_count == 0);
-                rwl.shared_count = 1;
-                return true;
-            },
-            .locked_shared => {
-                rwl.shared_count += 1;
-                return true;
-            },
-            .locked_exclusive => return false,
-        }
-    }
-
-    /// Blocks until shared lock ownership is acquired.
-    pub fn lockShared(rwl: *SingleThreadedRwLock) void {
-        switch (rwl.state) {
-            .unlocked => {
-                rwl.state = .locked_shared;
-                assert(rwl.shared_count == 0);
-                rwl.shared_count = 1;
-            },
-            .locked_shared => {
-                rwl.shared_count += 1;
-            },
-            .locked_exclusive => unreachable, // deadlock detected
-        }
-    }
-
-    /// Releases a held shared lock.
-    pub fn unlockShared(rwl: *SingleThreadedRwLock) void {
-        switch (rwl.state) {
-            .unlocked => unreachable, // too many calls to `unlockShared`
-            .locked_exclusive => unreachable, // exclusively held lock
-            .locked_shared => {
-                rwl.shared_count -= 1;
-                if (rwl.shared_count == 0) {
-                    rwl.state = .unlocked;
-                }
-            },
-        }
-    }
-};
-
-pub const PthreadRwLock = struct {
-    rwlock: std.c.pthread_rwlock_t = .{},
-
-    pub fn tryLock(rwl: *PthreadRwLock) bool {
-        return std.c.pthread_rwlock_trywrlock(&rwl.rwlock) == .SUCCESS;
-    }
-
-    pub fn lock(rwl: *PthreadRwLock) void {
-        const rc = std.c.pthread_rwlock_wrlock(&rwl.rwlock);
-        assert(rc == .SUCCESS);
-    }
-
-    pub fn unlock(rwl: *PthreadRwLock) void {
-        const rc = std.c.pthread_rwlock_unlock(&rwl.rwlock);
-        assert(rc == .SUCCESS);
-    }
-
-    pub fn tryLockShared(rwl: *PthreadRwLock) bool {
-        return std.c.pthread_rwlock_tryrdlock(&rwl.rwlock) == .SUCCESS;
-    }
-
-    pub fn lockShared(rwl: *PthreadRwLock) void {
-        const rc = std.c.pthread_rwlock_rdlock(&rwl.rwlock);
-        assert(rc == .SUCCESS);
-    }
-
-    pub fn unlockShared(rwl: *PthreadRwLock) void {
-        const rc = std.c.pthread_rwlock_unlock(&rwl.rwlock);
-        assert(rc == .SUCCESS);
-    }
-};
-
-pub const DefaultRwLock = struct {
-    state: usize = 0,
-    mutex: std.Thread.Mutex = .{},
-    semaphore: std.Thread.Semaphore = .{},
-
-    const IS_WRITING: usize = 1;
-    const WRITER: usize = 1 << 1;
-    const READER: usize = 1 << (1 + @bitSizeOf(Count));
-    const WRITER_MASK: usize = std.math.maxInt(Count) << @ctz(WRITER);
-    const READER_MASK: usize = std.math.maxInt(Count) << @ctz(READER);
-    const Count = std.meta.Int(.unsigned, @divFloor(@bitSizeOf(usize) - 1, 2));
-
-    pub fn tryLock(rwl: *DefaultRwLock) bool {
-        if (rwl.mutex.tryLock()) {
-            const state = @atomicLoad(usize, &rwl.state, .seq_cst);
-            if (state & READER_MASK == 0) {
-                _ = @atomicRmw(usize, &rwl.state, .Or, IS_WRITING, .seq_cst);
-                return true;
-            }
-
-            rwl.mutex.unlock();
-        }
-
-        return false;
-    }
-
-    pub fn lock(rwl: *DefaultRwLock) void {
-        _ = @atomicRmw(usize, &rwl.state, .Add, WRITER, .seq_cst);
-        rwl.mutex.lock();
-
-        const state = @atomicRmw(usize, &rwl.state, .Add, IS_WRITING -% WRITER, .seq_cst);
-        if (state & READER_MASK != 0)
-            rwl.semaphore.wait();
-    }
-
-    pub fn unlock(rwl: *DefaultRwLock) void {
-        _ = @atomicRmw(usize, &rwl.state, .And, ~IS_WRITING, .seq_cst);
-        rwl.mutex.unlock();
-    }
-
-    pub fn tryLockShared(rwl: *DefaultRwLock) bool {
-        const state = @atomicLoad(usize, &rwl.state, .seq_cst);
-        if (state & (IS_WRITING | WRITER_MASK) == 0) {
-            _ = @cmpxchgStrong(
-                usize,
-                &rwl.state,
-                state,
-                state + READER,
-                .seq_cst,
-                .seq_cst,
-            ) orelse return true;
-        }
-
-        if (rwl.mutex.tryLock()) {
-            _ = @atomicRmw(usize, &rwl.state, .Add, READER, .seq_cst);
-            rwl.mutex.unlock();
-            return true;
-        }
-
-        return false;
-    }
-
-    pub fn lockShared(rwl: *DefaultRwLock) void {
-        var state = @atomicLoad(usize, &rwl.state, .seq_cst);
-        while (state & (IS_WRITING | WRITER_MASK) == 0) {
-            state = @cmpxchgWeak(
-                usize,
-                &rwl.state,
-                state,
-                state + READER,
-                .seq_cst,
-                .seq_cst,
-            ) orelse return;
-        }
-
-        rwl.mutex.lock();
-        _ = @atomicRmw(usize, &rwl.state, .Add, READER, .seq_cst);
-        rwl.mutex.unlock();
-    }
-
-    pub fn unlockShared(rwl: *DefaultRwLock) void {
-        const state = @atomicRmw(usize, &rwl.state, .Sub, READER, .seq_cst);
-
-        if ((state & READER_MASK == READER) and (state & IS_WRITING != 0))
-            rwl.semaphore.post();
-    }
-};
-
-test "DefaultRwLock - internal state" {
-    var rwl = DefaultRwLock{};
-
-    // The following failed prior to the fix for Issue #13163,
-    // where the WRITER flag was subtracted by the lock method.
-
-    rwl.lock();
-    rwl.unlock();
-    try testing.expectEqual(rwl, DefaultRwLock{});
-}
-
-test "smoke test" {
-    var rwl = RwLock{};
-
-    rwl.lock();
-    try testing.expect(!rwl.tryLock());
-    try testing.expect(!rwl.tryLockShared());
-    rwl.unlock();
-
-    try testing.expect(rwl.tryLock());
-    try testing.expect(!rwl.tryLock());
-    try testing.expect(!rwl.tryLockShared());
-    rwl.unlock();
-
-    rwl.lockShared();
-    try testing.expect(!rwl.tryLock());
-    try testing.expect(rwl.tryLockShared());
-    rwl.unlockShared();
-    rwl.unlockShared();
-
-    try testing.expect(rwl.tryLockShared());
-    try testing.expect(!rwl.tryLock());
-    try testing.expect(rwl.tryLockShared());
-    rwl.unlockShared();
-    rwl.unlockShared();
-
-    rwl.lock();
-    rwl.unlock();
-}
-
-test "concurrent access" {
-    if (builtin.single_threaded)
-        return;
-
-    const num_writers: usize = 2;
-    const num_readers: usize = 4;
-    const num_writes: usize = 1000;
-    const num_reads: usize = 2000;
-
-    const Runner = struct {
-        const Runner = @This();
-
-        rwl: RwLock,
-        writes: usize,
-        reads: std.atomic.Value(usize),
-
-        val_a: usize,
-        val_b: usize,
-
-        fn reader(run: *Runner, thread_idx: usize) !void {
-            var prng = std.Random.DefaultPrng.init(thread_idx);
-            const rnd = prng.random();
-            while (true) {
-                run.rwl.lockShared();
-                defer run.rwl.unlockShared();
-
-                try testing.expect(run.writes <= num_writes);
-                if (run.reads.fetchAdd(1, .monotonic) >= num_reads) break;
-
-                // We use `volatile` accesses so that we can make sure the memory is accessed either
-                // side of a yield, maximising chances of a race.
-                const a_ptr: *const volatile usize = &run.val_a;
-                const b_ptr: *const volatile usize = &run.val_b;
-
-                const old_a = a_ptr.*;
-                if (rnd.boolean()) try std.Thread.yield();
-                const old_b = b_ptr.*;
-                try testing.expect(old_a == old_b);
-            }
-        }
-
-        fn writer(run: *Runner, thread_idx: usize) !void {
-            var prng = std.Random.DefaultPrng.init(thread_idx);
-            const rnd = prng.random();
-            while (true) {
-                run.rwl.lock();
-                defer run.rwl.unlock();
-
-                try testing.expect(run.writes <= num_writes);
-                if (run.writes == num_writes) break;
-
-                // We use `volatile` accesses so that we can make sure the memory is accessed either
-                // side of a yield, maximising chances of a race.
-                const a_ptr: *volatile usize = &run.val_a;
-                const b_ptr: *volatile usize = &run.val_b;
-
-                const new_val = rnd.int(usize);
-
-                const old_a = a_ptr.*;
-                a_ptr.* = new_val;
-                if (rnd.boolean()) try std.Thread.yield();
-                const old_b = b_ptr.*;
-                b_ptr.* = new_val;
-                try testing.expect(old_a == old_b);
-
-                run.writes += 1;
-            }
-        }
-    };
-
-    var run: Runner = .{
-        .rwl = .{},
-        .writes = 0,
-        .reads = .init(0),
-        .val_a = 0,
-        .val_b = 0,
-    };
-    var write_threads: [num_writers]std.Thread = undefined;
-    var read_threads: [num_readers]std.Thread = undefined;
-
-    for (&write_threads, 0..) |*t, i| t.* = try .spawn(.{}, Runner.writer, .{ &run, i });
-    for (&read_threads, num_writers..) |*t, i| t.* = try .spawn(.{}, Runner.reader, .{ &run, i });
-
-    for (write_threads) |t| t.join();
-    for (read_threads) |t| t.join();
-
-    try testing.expect(run.writes == num_writes);
-    try testing.expect(run.reads.raw >= num_reads);
-}
diff --git a/lib/std/Thread/Semaphore.zig b/lib/std/Thread/Semaphore.zig
deleted file mode 100644
index a82ae3d002b1fb4f0147be5e2747958ad8b93dc2..0000000000000000000000000000000000000000
--- a/lib/std/Thread/Semaphore.zig
+++ /dev/null
@@ -1,111 +0,0 @@
-//! A semaphore is an unsigned integer that blocks the kernel thread if
-//! the number would become negative.
-//! This API supports static initialization and does not require deinitialization.
-//!
-//! Example:
-//! ```
-//! var s = Semaphore{};
-//!
-//! fn consumer() void {
-//!     s.wait();
-//! }
-//!
-//! fn producer() void {
-//!     s.post();
-//! }
-//!
-//! const thread = try std.Thread.spawn(.{}, producer, .{});
-//! consumer();
-//! thread.join();
-//! ```
-
-mutex: Mutex = .{},
-cond: Condition = .{},
-/// It is OK to initialize this field to any value.
-permits: usize = 0,
-
-const Semaphore = @This();
-const std = @import("../std.zig");
-const Mutex = std.Thread.Mutex;
-const Condition = std.Thread.Condition;
-const builtin = @import("builtin");
-const testing = std.testing;
-
-pub fn wait(sem: *Semaphore) void {
-    sem.mutex.lock();
-    defer sem.mutex.unlock();
-
-    while (sem.permits == 0)
-        sem.cond.wait(&sem.mutex);
-
-    sem.permits -= 1;
-    if (sem.permits > 0)
-        sem.cond.signal();
-}
-
-pub fn timedWait(sem: *Semaphore, timeout_ns: u64) error{Timeout}!void {
-    var timeout_timer = std.time.Timer.start() catch unreachable;
-
-    sem.mutex.lock();
-    defer sem.mutex.unlock();
-
-    while (sem.permits == 0) {
-        const elapsed = timeout_timer.read();
-        if (elapsed > timeout_ns)
-            return error.Timeout;
-
-        const local_timeout_ns = timeout_ns - elapsed;
-        try sem.cond.timedWait(&sem.mutex, local_timeout_ns);
-    }
-
-    sem.permits -= 1;
-    if (sem.permits > 0)
-        sem.cond.signal();
-}
-
-pub fn post(sem: *Semaphore) void {
-    sem.mutex.lock();
-    defer sem.mutex.unlock();
-
-    sem.permits += 1;
-    sem.cond.signal();
-}
-
-test Semaphore {
-    if (builtin.single_threaded) {
-        return error.SkipZigTest;
-    }
-
-    const TestContext = struct {
-        sem: *Semaphore,
-        n: *i32,
-        fn worker(ctx: *@This()) void {
-            ctx.sem.wait();
-            ctx.n.* += 1;
-            ctx.sem.post();
-        }
-    };
-    const num_threads = 3;
-    var sem = Semaphore{ .permits = 1 };
-    var threads: [num_threads]std.Thread = undefined;
-    var n: i32 = 0;
-    var ctx = TestContext{ .sem = &sem, .n = &n };
-
-    for (&threads) |*t| t.* = try std.Thread.spawn(.{}, TestContext.worker, .{&ctx});
-    for (threads) |t| t.join();
-    sem.wait();
-    try testing.expect(n == num_threads);
-}
-
-test timedWait {
-    var sem = Semaphore{};
-    try testing.expectEqual(0, sem.permits);
-
-    try testing.expectError(error.Timeout, sem.timedWait(1));
-
-    sem.post();
-    try testing.expectEqual(1, sem.permits);
-
-    try sem.timedWait(1);
-    try testing.expectEqual(0, sem.permits);
-}
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 4cf8cc5dc626128112bc8f190cfadcdf18026299..8f83bf19c8704aa41e2dbfae6429ed961cd12bbf 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -696,7 +696,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
                 .useless, .unsafe => {},
                 .safe, .ideal => continue, // no need to even warn
             }
-            const module_name = di.getModuleName(di_gpa, unwind_error.address) catch "???";
+            const module_name = di.getModuleName(di_gpa, io, unwind_error.address) catch "???";
             const caption: []const u8 = switch (unwind_error.err) {
                 error.MissingDebugInfo => "unwind info unavailable",
                 error.InvalidDebugInfo => "unwind info invalid",
@@ -1141,7 +1141,7 @@ fn printSourceAtAddress(
         symbol.source_location,
         address,
         symbol.name orelse "???",
-        symbol.compile_unit_name orelse debug_info.getModuleName(gpa, address) catch "???",
+        symbol.compile_unit_name orelse debug_info.getModuleName(gpa, io, address) catch "???",
     );
 }
 fn printLineInfo(
@@ -1356,7 +1356,10 @@ pub fn getDebugInfoAllocator() Allocator {
     // Otherwise, use a global arena backed by the page allocator
     const S = struct {
         var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
-        var ts_arena: std.heap.ThreadSafeAllocator = .{ .child_allocator = arena.allocator() };
+        var ts_arena: std.heap.ThreadSafeAllocator = .{
+            .child_allocator = arena.allocator(),
+            .io = std.Options.debug_io,
+        };
     };
     return S.ts_arena.allocator();
 }
diff --git a/lib/std/debug/Coverage.zig b/lib/std/debug/Coverage.zig
index 749b992a025683d4770b8a4c315d5d190735d287..81dfce853e0e66c706be73f09407de80d37f339f 100644
--- a/lib/std/debug/Coverage.zig
+++ b/lib/std/debug/Coverage.zig
@@ -1,11 +1,12 @@
+const Coverage = @This();
+
 const std = @import("../std.zig");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const Hash = std.hash.Wyhash;
 const Dwarf = std.debug.Dwarf;
 const assert = std.debug.assert;
 
-const Coverage = @This();
-
 /// Provides a globally-scoped integer index for directories.
 ///
 /// As opposed to, for example, a directory index that is compilation-unit
@@ -23,12 +24,12 @@ directories: std.ArrayHashMapUnmanaged(String, void, String.MapContext, false),
 files: std.ArrayHashMapUnmanaged(File, void, File.MapContext, false),
 string_bytes: std.ArrayList(u8),
 /// Protects the other fields.
-mutex: std.Thread.Mutex,
+mutex: Io.Mutex,
 
 pub const init: Coverage = .{
     .directories = .{},
     .files = .{},
-    .mutex = .{},
+    .mutex = .init,
     .string_bytes = .{},
 };
 
@@ -140,11 +141,12 @@ pub fn stringAt(cov: *Coverage, index: String) [:0]const u8 {
     return span(cov.string_bytes.items[@intFromEnum(index)..]);
 }
 
-pub const ResolveAddressesDwarfError = Dwarf.ScanError;
+pub const ResolveAddressesDwarfError = Dwarf.ScanError || Io.Cancelable;
 
 pub fn resolveAddressesDwarf(
     cov: *Coverage,
     gpa: Allocator,
+    io: Io,
     endian: std.builtin.Endian,
     /// Asserts the addresses are in ascending order.
     sorted_pc_addrs: []const u64,
@@ -161,8 +163,8 @@ pub fn resolveAddressesDwarf(
     var prev_pc: u64 = 0;
     var prev_cu: ?*std.debug.Dwarf.CompileUnit = null;
     // Protects directories and files tables from other threads.
-    cov.mutex.lock();
-    defer cov.mutex.unlock();
+    try cov.mutex.lock(io);
+    defer cov.mutex.unlock(io);
     next_pc: for (sorted_pc_addrs, output) |pc, *out| {
         assert(pc >= prev_pc);
         prev_pc = pc;
@@ -183,8 +185,8 @@ pub fn resolveAddressesDwarf(
         if (cu != prev_cu) {
             prev_cu = cu;
             if (cu.src_loc_cache == null) {
-                cov.mutex.unlock();
-                defer cov.mutex.lock();
+                cov.mutex.unlock(io);
+                defer cov.mutex.lockUncancelable(io);
                 d.populateSrcLocCache(gpa, endian, cu) catch |err| switch (err) {
                     error.MissingDebugInfo, error.InvalidDebugInfo => {
                         out.* = SourceLocation.invalid;
diff --git a/lib/std/debug/Info.zig b/lib/std/debug/Info.zig
index 34e79227d1375c621648d3c0eb74e9fb92dc736d..d16db5d69544c7591bc4230e60a2061cc5121400 100644
--- a/lib/std/debug/Info.zig
+++ b/lib/std/debug/Info.zig
@@ -93,7 +93,7 @@ pub fn resolveAddresses(
 ) ResolveAddressesError!void {
     assert(sorted_pc_addrs.len == output.len);
     switch (info.impl) {
-        .elf => |*ef| return info.coverage.resolveAddressesDwarf(gpa, ef.endian, sorted_pc_addrs, output, &ef.dwarf.?),
+        .elf => |*ef| return info.coverage.resolveAddressesDwarf(gpa, io, ef.endian, sorted_pc_addrs, output, &ef.dwarf.?),
         .macho => |*mf| {
             // Resolving all of the addresses at once unfortunately isn't so easy in Mach-O binaries
             // due to split debug information. For now, we'll just resolve the addreses one by one.
@@ -112,7 +112,7 @@ pub fn resolveAddresses(
                         else => |e| return e,
                     };
                 }
-                try info.coverage.resolveAddressesDwarf(gpa, .little, &.{dwarf_pc_addr}, src_loc[0..1], dwarf);
+                try info.coverage.resolveAddressesDwarf(gpa, io, .little, &.{dwarf_pc_addr}, src_loc[0..1], dwarf);
             }
         },
     }
diff --git a/lib/std/debug/SelfInfo/Elf.zig b/lib/std/debug/SelfInfo/Elf.zig
index ffcb4dfd26fdb9b1a80d030221d83b87283ef499..a2868fcee1429b0ab4757d4cb32603c27904250f 100644
--- a/lib/std/debug/SelfInfo/Elf.zig
+++ b/lib/std/debug/SelfInfo/Elf.zig
@@ -1,4 +1,4 @@
-rwlock: std.Thread.RwLock,
+mutex: Io.Mutex,
 
 modules: std.ArrayList(Module),
 ranges: std.ArrayList(Module.Range),
@@ -6,7 +6,7 @@ ranges: std.ArrayList(Module.Range),
 unwind_cache: if (can_unwind) ?[]Dwarf.SelfUnwinder.CacheEntry else ?noreturn,
 
 pub const init: SelfInfo = .{
-    .rwlock = .{},
+    .mutex = .init,
     .modules = .empty,
     .ranges = .empty,
     .unwind_cache = null,
@@ -29,8 +29,8 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
 }
 
 pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
-    const module = try si.findModule(gpa, address, .exclusive);
-    defer si.rwlock.unlock();
+    const module = try si.findModule(gpa, io, address, .exclusive);
+    defer si.mutex.unlock(io);
 
     const vaddr = address - module.load_offset;
 
@@ -73,15 +73,15 @@ pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!st
         error.OutOfMemory => |e| return e,
     };
 }
-pub fn getModuleName(si: *SelfInfo, gpa: Allocator, address: usize) Error![]const u8 {
-    const module = try si.findModule(gpa, address, .shared);
-    defer si.rwlock.unlockShared();
+pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
+    const module = try si.findModule(gpa, io, address, .shared);
+    defer si.mutex.unlock(io);
     if (module.name.len == 0) return error.MissingDebugInfo;
     return module.name;
 }
-pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, address: usize) Error!usize {
-    const module = try si.findModule(gpa, address, .shared);
-    defer si.rwlock.unlockShared();
+pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
+    const module = try si.findModule(gpa, io, address, .shared);
+    defer si.mutex.unlock(io);
     return module.load_offset;
 }
 
@@ -183,8 +183,8 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
     comptime assert(can_unwind);
 
     {
-        si.rwlock.lockShared();
-        defer si.rwlock.unlockShared();
+        try si.mutex.lock(io);
+        defer si.mutex.unlock(io);
         if (si.unwind_cache) |cache| {
             if (Dwarf.SelfUnwinder.CacheEntry.find(cache, context.pc)) |entry| {
                 return context.next(gpa, entry);
@@ -192,8 +192,8 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
         }
     }
 
-    const module = try si.findModule(gpa, context.pc, .exclusive);
-    defer si.rwlock.unlock();
+    const module = try si.findModule(gpa, io, context.pc, .exclusive);
+    defer si.mutex.unlock(io);
 
     if (si.unwind_cache == null) {
         si.unwind_cache = try gpa.alloc(Dwarf.SelfUnwinder.CacheEntry, 2048);
@@ -375,11 +375,11 @@ const Module = struct {
     }
 };
 
-fn findModule(si: *SelfInfo, gpa: Allocator, address: usize, lock: enum { shared, exclusive }) Error!*Module {
+fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum { shared, exclusive }) Error!*Module {
     // With the requested lock, scan the module ranges looking for `address`.
     switch (lock) {
-        .shared => si.rwlock.lockShared(),
-        .exclusive => si.rwlock.lock(),
+        .shared => try si.mutex.lock(io),
+        .exclusive => try si.mutex.lock(io),
     }
     for (si.ranges.items) |*range| {
         if (address >= range.start and address < range.start + range.len) {
@@ -389,15 +389,12 @@ fn findModule(si: *SelfInfo, gpa: Allocator, address: usize, lock: enum { shared
     // The address wasn't in a known range. We will rebuild the module/range lists, since it's possible
     // a new module was loaded. Upgrade to an exclusive lock if necessary.
     switch (lock) {
-        .shared => {
-            si.rwlock.unlockShared();
-            si.rwlock.lock();
-        },
+        .shared => {},
         .exclusive => {},
     }
     // Rebuild module list with the exclusive lock.
     {
-        errdefer si.rwlock.unlock();
+        errdefer si.mutex.unlock(io);
         for (si.modules.items) |*mod| {
             unwind: {
                 const u = &(mod.unwind orelse break :unwind catch break :unwind);
@@ -415,10 +412,7 @@ fn findModule(si: *SelfInfo, gpa: Allocator, address: usize, lock: enum { shared
     }
     // Downgrade the lock back to shared if necessary.
     switch (lock) {
-        .shared => {
-            si.rwlock.unlock();
-            si.rwlock.lockShared();
-        },
+        .shared => {},
         .exclusive => {},
     }
     // Scan the newly rebuilt module ranges.
@@ -429,8 +423,8 @@ fn findModule(si: *SelfInfo, gpa: Allocator, address: usize, lock: enum { shared
     }
     // Still nothing; unlock and error.
     switch (lock) {
-        .shared => si.rwlock.unlockShared(),
-        .exclusive => si.rwlock.unlock(),
+        .shared => si.mutex.unlock(io),
+        .exclusive => si.mutex.unlock(io),
     }
     return error.MissingDebugInfo;
 }
diff --git a/lib/std/debug/SelfInfo/MachO.zig b/lib/std/debug/SelfInfo/MachO.zig
index 774ee5815ab6c89be015ecdf941ea79b16e021fc..1cc2ebed53939959c2e1712d7afdf58dfe1178e5 100644
--- a/lib/std/debug/SelfInfo/MachO.zig
+++ b/lib/std/debug/SelfInfo/MachO.zig
@@ -1,9 +1,9 @@
-mutex: std.Thread.Mutex,
+mutex: Io.Mutex,
 /// Accessed through `Module.Adapter`.
 modules: std.ArrayHashMapUnmanaged(Module, void, Module.Context, false),
 
 pub const init: SelfInfo = .{
-    .mutex = .{},
+    .mutex = .init,
     .modules = .empty,
 };
 pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
@@ -21,8 +21,8 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
 }
 
 pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
-    const module = try si.findModule(gpa, address);
-    defer si.mutex.unlock();
+    const module = try si.findModule(gpa, io, address);
+    defer si.mutex.unlock(io);
 
     const file = try module.getFile(gpa, io);
 
@@ -76,9 +76,10 @@ pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!st
         ) catch null,
     };
 }
-pub fn getModuleName(si: *SelfInfo, gpa: Allocator, address: usize) Error![]const u8 {
+pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
     _ = si;
     _ = gpa;
+    _ = io;
     // This function is marked as deprecated; however, it is significantly more
     // performant than `dladdr` (since the latter also does a very slow symbol
     // lookup), so let's use it since it's still available.
@@ -86,9 +87,9 @@ pub fn getModuleName(si: *SelfInfo, gpa: Allocator, address: usize) Error![]cons
         @ptrFromInt(address),
     ) orelse return error.MissingDebugInfo);
 }
-pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, address: usize) Error!usize {
-    const module = try si.findModule(gpa, address);
-    defer si.mutex.unlock();
+pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
+    const module = try si.findModule(gpa, io, address);
+    defer si.mutex.unlock(io);
     const header: *std.macho.mach_header_64 = @ptrFromInt(module.text_base);
     const raw_macho: [*]u8 = @ptrCast(header);
     var it = macho.LoadCommandIterator.init(header, raw_macho[@sizeOf(macho.mach_header_64)..][0..header.sizeofcmds]) catch unreachable;
@@ -107,8 +108,7 @@ pub const UnwindContext = std.debug.Dwarf.SelfUnwinder;
 /// If the compact encoding can't encode a way to unwind a frame, it will
 /// defer unwinding to DWARF, in which case `__eh_frame` will be used if available.
 pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
-    _ = io;
-    return unwindFrameInner(si, gpa, context) catch |err| switch (err) {
+    return unwindFrameInner(si, gpa, io, context) catch |err| switch (err) {
         error.InvalidDebugInfo,
         error.MissingDebugInfo,
         error.UnsupportedDebugInfo,
@@ -134,9 +134,9 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
         => return error.InvalidDebugInfo,
     };
 }
-fn unwindFrameInner(si: *SelfInfo, gpa: Allocator, context: *UnwindContext) !usize {
-    const module = try si.findModule(gpa, context.pc);
-    defer si.mutex.unlock();
+fn unwindFrameInner(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) !usize {
+    const module = try si.findModule(gpa, io, context.pc);
+    defer si.mutex.unlock(io);
 
     const unwind: *Module.Unwind = try module.getUnwindInfo(gpa);
 
@@ -430,15 +430,15 @@ fn unwindFrameInner(si: *SelfInfo, gpa: Allocator, context: *UnwindContext) !usi
 }
 
 /// Acquires the mutex on success.
-fn findModule(si: *SelfInfo, gpa: Allocator, address: usize) Error!*Module {
+fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!*Module {
     // This function is marked as deprecated; however, it is significantly more
     // performant than `dladdr` (since the latter also does a very slow symbol
     // lookup), so let's use it since it's still available.
     const text_base = std.c._dyld_get_image_header_containing_address(
         @ptrFromInt(address),
     ) orelse return error.MissingDebugInfo;
-    si.mutex.lock();
-    errdefer si.mutex.unlock();
+    try si.mutex.lock(io);
+    errdefer si.mutex.unlock(io);
     const gop = try si.modules.getOrPutAdapted(gpa, @intFromPtr(text_base), Module.Adapter{});
     errdefer comptime unreachable;
     if (!gop.found_existing) gop.key_ptr.* = .{
diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig
index b26883778dcc803bd3daaf0ce2acae82b55333ef..75cc329c3b0606846302234a8e93273e8e58b484 100644
--- a/lib/std/debug/SelfInfo/Windows.zig
+++ b/lib/std/debug/SelfInfo/Windows.zig
@@ -1,9 +1,9 @@
-mutex: std.Thread.Mutex,
+mutex: Io.Mutex,
 modules: std.ArrayList(Module),
 module_name_arena: std.heap.ArenaAllocator.State,
 
 pub const init: SelfInfo = .{
-    .mutex = .{},
+    .mutex = .init,
     .modules = .empty,
     .module_name_arena = .{},
 };
@@ -21,21 +21,21 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
 }
 
 pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
-    si.mutex.lock();
-    defer si.mutex.unlock();
+    try si.mutex.lock(io);
+    defer si.mutex.unlock(io);
     const module = try si.findModule(gpa, address);
     const di = try module.getDebugInfo(gpa, io);
     return di.getSymbol(gpa, address - module.base_address);
 }
-pub fn getModuleName(si: *SelfInfo, gpa: Allocator, address: usize) Error![]const u8 {
-    si.mutex.lock();
-    defer si.mutex.unlock();
+pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
+    try si.mutex.lock(io);
+    defer si.mutex.unlock(io);
     const module = try si.findModule(gpa, address);
     return module.name;
 }
-pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, address: usize) Error!usize {
-    si.mutex.lock();
-    defer si.mutex.unlock();
+pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
+    try si.mutex.lock(io);
+    defer si.mutex.unlock(io);
     const module = try si.findModule(gpa, address);
     return module.base_address;
 }
diff --git a/lib/std/heap/ThreadSafeAllocator.zig b/lib/std/heap/ThreadSafeAllocator.zig
index dc8bf89017b726da122683a5cfd2fb9fc15ba192..6999213937a95fa1792b964c0237e46e5b8c0ba7 100644
--- a/lib/std/heap/ThreadSafeAllocator.zig
+++ b/lib/std/heap/ThreadSafeAllocator.zig
@@ -1,7 +1,14 @@
-//! Wraps a non-thread-safe allocator and makes it thread-safe.
+//! Deprecated. Thread safety should be built into each Allocator instance
+//! directly rather than trying to do this "composable allocators" thing.
+const ThreadSafeAllocator = @This();
+
+const std = @import("../std.zig");
+const Io = std.Io;
+const Allocator = std.mem.Allocator;
 
 child_allocator: Allocator,
-mutex: std.Thread.Mutex = .{},
+io: Io,
+mutex: Io.Mutex = .init,
 
 pub fn allocator(self: *ThreadSafeAllocator) Allocator {
     return .{
@@ -17,39 +24,39 @@ pub fn allocator(self: *ThreadSafeAllocator) Allocator {
 
 fn alloc(ctx: *anyopaque, n: usize, alignment: std.mem.Alignment, ra: usize) ?[*]u8 {
     const self: *ThreadSafeAllocator = @ptrCast(@alignCast(ctx));
-    self.mutex.lock();
-    defer self.mutex.unlock();
+    const io = self.io;
+    self.mutex.lockUncancelable(io);
+    defer self.mutex.unlock(io);
 
     return self.child_allocator.rawAlloc(n, alignment, ra);
 }
 
 fn resize(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ret_addr: usize) bool {
     const self: *ThreadSafeAllocator = @ptrCast(@alignCast(ctx));
+    const io = self.io;
 
-    self.mutex.lock();
-    defer self.mutex.unlock();
+    self.mutex.lockUncancelable(io);
+    defer self.mutex.unlock(io);
 
     return self.child_allocator.rawResize(buf, alignment, new_len, ret_addr);
 }
 
 fn remap(context: *anyopaque, memory: []u8, alignment: std.mem.Alignment, new_len: usize, return_address: usize) ?[*]u8 {
     const self: *ThreadSafeAllocator = @ptrCast(@alignCast(context));
+    const io = self.io;
 
-    self.mutex.lock();
-    defer self.mutex.unlock();
+    self.mutex.lockUncancelable(io);
+    defer self.mutex.unlock(io);
 
     return self.child_allocator.rawRemap(memory, alignment, new_len, return_address);
 }
 
 fn free(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, ret_addr: usize) void {
     const self: *ThreadSafeAllocator = @ptrCast(@alignCast(ctx));
+    const io = self.io;
 
-    self.mutex.lock();
-    defer self.mutex.unlock();
+    self.mutex.lockUncancelable(io);
+    defer self.mutex.unlock(io);
 
     return self.child_allocator.rawFree(buf, alignment, ret_addr);
 }
-
-const std = @import("../std.zig");
-const ThreadSafeAllocator = @This();
-const Allocator = std.mem.Allocator;
diff --git a/lib/std/heap/debug_allocator.zig b/lib/std/heap/debug_allocator.zig
index 3ea4a28f96f97a34292ba1461b56b0dc3903316b..d150bb09279c48da6f2c48ba6cee97a54bb07c9e 100644
--- a/lib/std/heap/debug_allocator.zig
+++ b/lib/std/heap/debug_allocator.zig
@@ -126,16 +126,6 @@ pub const Config = struct {
     /// Whether the allocator may be used simultaneously from multiple threads.
     thread_safe: bool = !builtin.single_threaded,
 
-    /// What type of mutex you'd like to use, for thread safety.
-    /// when specified, the mutex type must have the same shape as `std.Thread.Mutex` and
-    /// `DummyMutex`, and have no required fields. Specifying this field causes
-    /// the `thread_safe` field to be ignored.
-    ///
-    /// when null (default):
-    /// * the mutex type defaults to `std.Thread.Mutex` when thread_safe is enabled.
-    /// * the mutex type defaults to `DummyMutex` otherwise.
-    MutexType: ?type = null,
-
     /// This is a temporary debugging trick you can use to turn segfaults into more helpful
     /// logged error messages with stack trace details. The downside is that every allocation
     /// will be leaked, unless used with retain_metadata!
@@ -204,17 +194,8 @@ pub fn DebugAllocator(comptime config: Config) type {
         const total_requested_bytes_init = if (config.enable_memory_limit) @as(usize, 0) else {};
         const requested_memory_limit_init = if (config.enable_memory_limit) @as(usize, math.maxInt(usize)) else {};
 
-        const mutex_init = if (config.MutexType) |T|
-            T{}
-        else if (config.thread_safe)
-            std.Thread.Mutex{}
-        else
-            DummyMutex{};
-
-        const DummyMutex = struct {
-            inline fn lock(_: DummyMutex) void {}
-            inline fn unlock(_: DummyMutex) void {}
-        };
+        const have_mutex = config.thread_safe;
+        const mutex_init = if (have_mutex) std.Io.Mutex.init else {};
 
         const stack_n = config.stack_trace_frames;
         const one_trace_size = @sizeOf(usize) * stack_n;
@@ -737,8 +718,8 @@ pub fn DebugAllocator(comptime config: Config) type {
 
         fn alloc(context: *anyopaque, len: usize, alignment: mem.Alignment, ret_addr: usize) ?[*]u8 {
             const self: *Self = @ptrCast(@alignCast(context));
-            self.mutex.lock();
-            defer self.mutex.unlock();
+            if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex);
+            defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex);
 
             if (config.enable_memory_limit) {
                 const new_req_bytes = self.total_requested_bytes + len;
@@ -850,8 +831,8 @@ pub fn DebugAllocator(comptime config: Config) type {
             return_address: usize,
         ) bool {
             const self: *Self = @ptrCast(@alignCast(context));
-            self.mutex.lock();
-            defer self.mutex.unlock();
+            if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex);
+            defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex);
 
             const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(memory.len - 1), @intFromEnum(alignment));
             if (size_class_index >= self.buckets.len) {
@@ -869,8 +850,8 @@ pub fn DebugAllocator(comptime config: Config) type {
             return_address: usize,
         ) ?[*]u8 {
             const self: *Self = @ptrCast(@alignCast(context));
-            self.mutex.lock();
-            defer self.mutex.unlock();
+            if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex);
+            defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex);
 
             const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(memory.len - 1), @intFromEnum(alignment));
             if (size_class_index >= self.buckets.len) {
@@ -887,8 +868,8 @@ pub fn DebugAllocator(comptime config: Config) type {
             return_address: usize,
         ) void {
             const self: *Self = @ptrCast(@alignCast(context));
-            self.mutex.lock();
-            defer self.mutex.unlock();
+            if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex);
+            defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex);
 
             const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(old_memory.len - 1), @intFromEnum(alignment));
             if (size_class_index >= self.buckets.len) {
@@ -1331,18 +1312,6 @@ test "realloc large object to small object" {
     try std.testing.expect(slice[16] == 0x34);
 }
 
-test "overridable mutexes" {
-    var gpa = DebugAllocator(.{ .MutexType = std.Thread.Mutex }){
-        .backing_allocator = std.testing.allocator,
-        .mutex = std.Thread.Mutex{},
-    };
-    defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak");
-    const allocator = gpa.allocator();
-
-    const ptr = try allocator.create(i32);
-    defer allocator.destroy(ptr);
-}
-
 test "non-page-allocator backing allocator" {
     var gpa: DebugAllocator(.{
         .backing_allocator_zeroes = false,
diff --git a/lib/std/heap/sbrk_allocator.zig b/lib/std/heap/sbrk_allocator.zig
index a67cd517cfffdf42301883ee3e2f4dd8bb754cba..c4006d332239c38bc9fbeb7f770f81fd5f77bb22 100644
--- a/lib/std/heap/sbrk_allocator.zig
+++ b/lib/std/heap/sbrk_allocator.zig
@@ -1,5 +1,7 @@
-const std = @import("../std.zig");
 const builtin = @import("builtin");
+
+const std = @import("../std.zig");
+const Io = std.Io;
 const math = std.math;
 const Allocator = std.mem.Allocator;
 const mem = std.mem;
@@ -39,12 +41,12 @@ pub fn SbrkAllocator(comptime sbrk: *const fn (n: usize) usize) type {
         var big_frees = [1]usize{0} ** big_size_class_count;
 
         // TODO don't do the naive locking strategy
-        var lock: std.Thread.Mutex = .{};
+        var mutex: Io.Mutex = .{};
         fn alloc(ctx: *anyopaque, len: usize, alignment: mem.Alignment, return_address: usize) ?[*]u8 {
             _ = ctx;
             _ = return_address;
-            lock.lock();
-            defer lock.unlock();
+            Io.Threaded.mutexLock(&mutex);
+            defer Io.Threaded.mutexUnlock(&mutex);
             // Make room for the freelist next pointer.
             const actual_len = @max(len +| @sizeOf(usize), alignment.toByteUnits());
             const slot_size = math.ceilPowerOfTwo(usize, actual_len) catch return null;
@@ -88,8 +90,8 @@ pub fn SbrkAllocator(comptime sbrk: *const fn (n: usize) usize) type {
         ) bool {
             _ = ctx;
             _ = return_address;
-            lock.lock();
-            defer lock.unlock();
+            Io.Threaded.mutexLock(&mutex);
+            defer Io.Threaded.mutexUnlock(&mutex);
             // We don't want to move anything from one size class to another, but we
             // can recover bytes in between powers of two.
             const buf_align = alignment.toByteUnits();
@@ -127,8 +129,8 @@ pub fn SbrkAllocator(comptime sbrk: *const fn (n: usize) usize) type {
         ) void {
             _ = ctx;
             _ = return_address;
-            lock.lock();
-            defer lock.unlock();
+            Io.Threaded.mutexLock(&mutex);
+            defer Io.Threaded.mutexUnlock(&mutex);
             const buf_align = alignment.toByteUnits();
             const actual_len = @max(buf.len + @sizeOf(usize), buf_align);
             const slot_size = math.ceilPowerOfTwoAssert(usize, actual_len);
diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig
index ddfcd96b6ab374045897dd86a834f12be331c897..a46e12ecf4846dd56c31de2444ebd3c1700f85bc 100644
--- a/lib/std/http/Client.zig
+++ b/lib/std/http/Client.zig
@@ -3,22 +3,25 @@
 //! Connections are opened in a thread-safe manner, but individual Requests are not.
 //!
 //! TLS support may be disabled via `std.options.http_disable_tls`.
+//!
+//! TODO all the lockUncancelable in this file should be changed to regular lock and
+//! `error.Canceled` added to more error sets.
+const Client = @This();
 
-const std = @import("../std.zig");
 const builtin = @import("builtin");
+
+const std = @import("../std.zig");
+const Io = std.Io;
 const testing = std.testing;
 const http = std.http;
 const mem = std.mem;
 const Uri = std.Uri;
-const Allocator = mem.Allocator;
+const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
-const Io = std.Io;
 const Writer = std.Io.Writer;
 const Reader = std.Io.Reader;
 const HostName = std.Io.net.HostName;
 
-const Client = @This();
-
 pub const disable_tls = std.options.http_disable_tls;
 
 /// Used for all client allocations. Must be thread-safe.
@@ -27,7 +30,7 @@ allocator: Allocator,
 io: Io,
 
 ca_bundle: if (disable_tls) void else std.crypto.Certificate.Bundle = if (disable_tls) {} else .{},
-ca_bundle_mutex: std.Thread.Mutex = .{},
+ca_bundle_mutex: Io.Mutex = .init,
 /// Used both for the reader and writer buffers.
 tls_buffer_size: if (disable_tls) u0 else usize = if (disable_tls) 0 else std.crypto.tls.Client.min_buffer_len,
 /// If non-null, ssl secrets are logged to a stream. Creating such a stream
@@ -62,7 +65,7 @@ https_proxy: ?*Proxy = null,
 
 /// A Least-Recently-Used cache of open connections to be reused.
 pub const ConnectionPool = struct {
-    mutex: std.Thread.Mutex = .{},
+    mutex: Io.Mutex = .init,
     /// Open connections that are currently in use.
     used: std.DoublyLinkedList = .{},
     /// Open connections that are not currently in use.
@@ -81,9 +84,9 @@ pub const ConnectionPool = struct {
     /// If no connection is found, null is returned.
     ///
     /// Threadsafe.
-    pub fn findConnection(pool: *ConnectionPool, criteria: Criteria) ?*Connection {
-        pool.mutex.lock();
-        defer pool.mutex.unlock();
+    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) ?*Connection {
+        pool.mutex.lockUncancelable(io);
+        defer pool.mutex.unlock(io);
 
         var next = pool.free.last;
         while (next) |node| : (next = node.prev) {
@@ -110,9 +113,9 @@ pub const ConnectionPool = struct {
     }
 
     /// Acquires an existing connection from the connection pool. This function is threadsafe.
-    pub fn acquire(pool: *ConnectionPool, connection: *Connection) void {
-        pool.mutex.lock();
-        defer pool.mutex.unlock();
+    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) void {
+        pool.mutex.lockUncancelable(io);
+        defer pool.mutex.unlock(io);
 
         return pool.acquireUnsafe(connection);
     }
@@ -122,8 +125,8 @@ pub const ConnectionPool = struct {
     ///
     /// Threadsafe.
     pub fn release(pool: *ConnectionPool, connection: *Connection, io: Io) void {
-        pool.mutex.lock();
-        defer pool.mutex.unlock();
+        pool.mutex.lockUncancelable(io);
+        defer pool.mutex.unlock(io);
 
         pool.used.remove(&connection.pool_node);
 
@@ -147,9 +150,9 @@ pub const ConnectionPool = struct {
     }
 
     /// Adds a newly created node to the pool of used connections. This function is threadsafe.
-    pub fn addUsed(pool: *ConnectionPool, connection: *Connection) void {
-        pool.mutex.lock();
-        defer pool.mutex.unlock();
+    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) void {
+        pool.mutex.lockUncancelable(io);
+        defer pool.mutex.unlock(io);
 
         pool.used.append(&connection.pool_node);
     }
@@ -159,9 +162,9 @@ pub const ConnectionPool = struct {
     /// If the new size is smaller than the current size, then idle connections will be closed until the pool is the new size.
     ///
     /// Threadsafe.
-    pub fn resize(pool: *ConnectionPool, allocator: Allocator, new_size: usize) void {
-        pool.mutex.lock();
-        defer pool.mutex.unlock();
+    pub fn resize(pool: *ConnectionPool, io: Io, allocator: Allocator, new_size: usize) void {
+        pool.mutex.lockUncancelable(io);
+        defer pool.mutex.unlock(io);
 
         const next = pool.free.first;
         _ = next;
@@ -182,7 +185,7 @@ pub const ConnectionPool = struct {
     ///
     /// Threadsafe.
     pub fn deinit(pool: *ConnectionPool, io: Io) void {
-        pool.mutex.lock();
+        pool.mutex.lockUncancelable(io);
 
         var next = pool.free.first;
         while (next) |node| {
@@ -1308,9 +1311,11 @@ pub fn deinit(client: *Client) void {
 /// Uses `arena` for a few small allocations that must outlive the client, or
 /// at least until those fields are set to different values.
 pub fn initDefaultProxies(client: *Client, arena: Allocator, environ_map: *std.process.Environ.Map) !void {
+    const io = client.io;
+
     // Prevent any new connections from being created.
-    client.connection_pool.mutex.lock();
-    defer client.connection_pool.mutex.unlock();
+    client.connection_pool.mutex.lockUncancelable(io);
+    defer client.connection_pool.mutex.unlock(io);
 
     assert(client.connection_pool.used.first == null); // There are active requests.
 
@@ -1437,7 +1442,7 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
     const proxied_host = options.proxied_host orelse host;
     const proxied_port = options.proxied_port orelse port;
 
-    if (client.connection_pool.findConnection(.{
+    if (client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = protocol,
@@ -1455,12 +1460,12 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
                 error.Canceled => |e| return e,
                 else => return error.TlsInitializationFailed,
             };
-            client.connection_pool.addUsed(&tc.connection);
+            client.connection_pool.addUsed(io, &tc.connection);
             return &tc.connection;
         },
         .plain => {
             const pc = try Connection.Plain.create(client, proxied_host, proxied_port, stream);
-            client.connection_pool.addUsed(&pc.connection);
+            client.connection_pool.addUsed(io, &pc.connection);
             return &pc.connection;
         },
     }
@@ -1474,7 +1479,7 @@ pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{N
 pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connection {
     const io = client.io;
 
-    if (client.connection_pool.findConnection(.{
+    if (client.connection_pool.findConnection(io, .{
         .host = path,
         .port = 0,
         .protocol = .plain,
@@ -1516,7 +1521,7 @@ pub fn connectProxied(
     const io = client.io;
     if (!proxy.supports_connect) return error.TunnelNotSupported;
 
-    if (client.connection_pool.findConnection(.{
+    if (client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = proxy.protocol,
@@ -1691,8 +1696,8 @@ pub fn request(
     if (protocol == .tls) {
         if (disable_tls) unreachable;
         {
-            client.ca_bundle_mutex.lock();
-            defer client.ca_bundle_mutex.unlock();
+            client.ca_bundle_mutex.lockUncancelable(io);
+            defer client.ca_bundle_mutex.unlock(io);
 
             if (client.now == null) {
                 const now = try Io.Clock.real.now(io);
diff --git a/lib/std/once.zig b/lib/std/once.zig
deleted file mode 100644
index 326487df076dcc242e25cec9d7c40c6fdb87da84..0000000000000000000000000000000000000000
--- a/lib/std/once.zig
+++ /dev/null
@@ -1,71 +0,0 @@
-const std = @import("std.zig");
-const builtin = @import("builtin");
-const testing = std.testing;
-
-pub fn once(comptime f: fn () void) Once(f) {
-    return Once(f){};
-}
-
-/// An object that executes the function `f` just once.
-/// It is undefined behavior if `f` re-enters the same Once instance.
-pub fn Once(comptime f: fn () void) type {
-    return struct {
-        done: bool = false,
-        mutex: std.Thread.Mutex = std.Thread.Mutex{},
-
-        /// Call the function `f`.
-        /// If `call` is invoked multiple times `f` will be executed only the
-        /// first time.
-        /// The invocations are thread-safe.
-        pub fn call(self: *@This()) void {
-            if (@atomicLoad(bool, &self.done, .acquire))
-                return;
-
-            return self.callSlow();
-        }
-
-        fn callSlow(self: *@This()) void {
-            @branchHint(.cold);
-
-            self.mutex.lock();
-            defer self.mutex.unlock();
-
-            // The first thread to acquire the mutex gets to run the initializer
-            if (!self.done) {
-                f();
-                @atomicStore(bool, &self.done, true, .release);
-            }
-        }
-    };
-}
-
-var global_number: i32 = 0;
-var global_once = once(incr);
-
-fn incr() void {
-    global_number += 1;
-}
-
-test "Once executes its function just once" {
-    if (builtin.single_threaded) {
-        global_once.call();
-        global_once.call();
-    } else {
-        var threads: [10]std.Thread = undefined;
-        var thread_count: usize = 0;
-        defer for (threads[0..thread_count]) |handle| handle.join();
-
-        for (&threads) |*handle| {
-            handle.* = try std.Thread.spawn(.{}, struct {
-                fn thread_fn(x: u8) void {
-                    _ = x;
-                    global_once.call();
-                    if (global_number != 1) @panic("memory ordering bug");
-                }
-            }.thread_fn, .{0});
-            thread_count += 1;
-        }
-    }
-
-    try testing.expectEqual(@as(i32, 1), global_number);
-}
diff --git a/lib/std/std.zig b/lib/std/std.zig
index 81ccf6a309b52a226e0e9582ff8eca15b591201b..3998b3247a53c6a8373fa7521e9f57164769dce2 100644
--- a/lib/std/std.zig
+++ b/lib/std/std.zig
@@ -86,7 +86,6 @@ pub const math = @import("math.zig");
 pub const mem = @import("mem.zig");
 pub const meta = @import("meta.zig");
 pub const os = @import("os.zig");
-pub const once = @import("once.zig").once;
 pub const pdb = @import("pdb.zig");
 pub const pie = @import("pie.zig");
 pub const posix = @import("posix.zig");
-- 
2.54.0


From 4c4e9d054e37afe82a856f5845c548f177996bd4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 2 Feb 2026 20:18:14 -0800
Subject: [PATCH 177/499] std.Io: add RwLock and Semaphore sync primitives

and restore usage by std.debug.SelfInfo.Elf
---
 lib/std/Io.zig                 |  15 ++-
 lib/std/Io/RwLock.zig          | 238 +++++++++++++++++++++++++++++++++
 lib/std/Io/Semaphore.zig       |  65 +++++++++
 lib/std/Io/Threaded.zig        |   8 +-
 lib/std/debug/SelfInfo/Elf.zig |  36 ++---
 5 files changed, 342 insertions(+), 20 deletions(-)
 create mode 100644 lib/std/Io/RwLock.zig
 create mode 100644 lib/std/Io/Semaphore.zig

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index ea182c680390e17133749ec28ddd520c32b5c21d..22ca78fd2b1a8552e0e6fb599c299638add1046e 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -47,6 +47,9 @@ pub const Dir = @import("Io/Dir.zig");
 pub const File = @import("Io/File.zig");
 pub const Terminal = @import("Io/Terminal.zig");
 
+pub const RwLock = @import("Io/RwLock.zig");
+pub const Semaphore = @import("Io/Semaphore.zig");
+
 pub const VTable = struct {
     /// If it returns `null` it means `result` has been already populated and
     /// `await` will be a no-op.
@@ -882,7 +885,7 @@ pub const Timeout = union(enum) {
 
     pub const Error = error{ Timeout, UnsupportedClock };
 
-    pub fn toDeadline(t: Timeout, io: Io) Clock.Error!?Clock.Timestamp {
+    pub fn toTimestamp(t: Timeout, io: Io) Clock.Error!?Clock.Timestamp {
         return switch (t) {
             .none => null,
             .duration => |d| try .fromNow(io, d),
@@ -890,6 +893,14 @@ pub const Timeout = union(enum) {
         };
     }
 
+    pub fn toDeadline(t: Timeout, io: Io) Timeout {
+        return switch (t) {
+            .none => .none,
+            .duration => |d| .{ .deadline = Clock.Timestamp.fromNow(io, d) catch @panic("TODO") },
+            .deadline => |d| .{ .deadline = d },
+        };
+    }
+
     pub fn toDurationFromNow(t: Timeout, io: Io) Clock.Error!?Clock.Duration {
         return switch (t) {
             .none => null,
@@ -2153,5 +2164,7 @@ test {
     _ = Writer;
     _ = Evented;
     _ = Threaded;
+    _ = RwLock;
+    _ = Semaphore;
     _ = @import("Io/test.zig");
 }
diff --git a/lib/std/Io/RwLock.zig b/lib/std/Io/RwLock.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7be4f026e16c150feef443286315567add6bf69c
--- /dev/null
+++ b/lib/std/Io/RwLock.zig
@@ -0,0 +1,238 @@
+//! A lock that supports one writer or many readers.
+const RwLock = @This();
+
+const builtin = @import("builtin");
+
+const std = @import("../std.zig");
+const Io = std.Io;
+const assert = std.debug.assert;
+const testing = std.testing;
+
+state: usize,
+mutex: Io.Mutex,
+semaphore: Io.Semaphore,
+
+pub const init: RwLock = .{
+    .state = 0,
+    .mutex = .init,
+    .semaphore = .{},
+};
+
+const is_writing: usize = 1;
+const writer: usize = 1 << 1;
+const reader: usize = 1 << (1 + @bitSizeOf(Count));
+const writer_mask: usize = std.math.maxInt(Count) << @ctz(writer);
+const reader_mask: usize = std.math.maxInt(Count) << @ctz(reader);
+const Count = @Int(.unsigned, @divFloor(@bitSizeOf(usize) - 1, 2));
+
+pub fn tryLock(rl: *RwLock, io: Io) bool {
+    if (rl.mutex.tryLock()) {
+        const state = @atomicLoad(usize, &rl.state, .seq_cst);
+        if (state & reader_mask == 0) {
+            _ = @atomicRmw(usize, &rl.state, .Or, is_writing, .seq_cst);
+            return true;
+        }
+
+        rl.mutex.unlock(io);
+    }
+
+    return false;
+}
+
+pub fn lockUncancelable(rl: *RwLock, io: Io) void {
+    _ = @atomicRmw(usize, &rl.state, .Add, writer, .seq_cst);
+    rl.mutex.lockUncancelable(io);
+
+    const state = @atomicRmw(usize, &rl.state, .Add, is_writing -% writer, .seq_cst);
+    if (state & reader_mask != 0)
+        rl.semaphore.waitUncancelable(io);
+}
+
+pub fn unlock(rl: *RwLock, io: Io) void {
+    _ = @atomicRmw(usize, &rl.state, .And, ~is_writing, .seq_cst);
+    rl.mutex.unlock(io);
+}
+
+pub fn tryLockShared(rl: *RwLock, io: Io) bool {
+    const state = @atomicLoad(usize, &rl.state, .seq_cst);
+    if (state & (is_writing | writer_mask) == 0) {
+        _ = @cmpxchgStrong(
+            usize,
+            &rl.state,
+            state,
+            state + reader,
+            .seq_cst,
+            .seq_cst,
+        ) orelse return true;
+    }
+
+    if (rl.mutex.tryLock()) {
+        _ = @atomicRmw(usize, &rl.state, .Add, reader, .seq_cst);
+        rl.mutex.unlock(io);
+        return true;
+    }
+
+    return false;
+}
+
+pub fn lockSharedUncancelable(rl: *RwLock, io: Io) void {
+    var state = @atomicLoad(usize, &rl.state, .seq_cst);
+    while (state & (is_writing | writer_mask) == 0) {
+        state = @cmpxchgWeak(
+            usize,
+            &rl.state,
+            state,
+            state + reader,
+            .seq_cst,
+            .seq_cst,
+        ) orelse return;
+    }
+
+    rl.mutex.lockUncancelable(io);
+    _ = @atomicRmw(usize, &rl.state, .Add, reader, .seq_cst);
+    rl.mutex.unlock(io);
+}
+
+pub fn unlockShared(rl: *RwLock, io: Io) void {
+    const state = @atomicRmw(usize, &rl.state, .Sub, reader, .seq_cst);
+
+    if ((state & reader_mask == reader) and (state & is_writing != 0))
+        rl.semaphore.post(io);
+}
+
+test "internal state" {
+    const io = testing.io;
+
+    var rl: Io.RwLock = .init;
+
+    // The following failed prior to the fix for Issue #13163,
+    // where the WRITER flag was subtracted by the lock method.
+
+    rl.lockUncancelable(io);
+    rl.unlock(io);
+    try testing.expectEqual(rl, Io.RwLock.init);
+}
+
+test "smoke test" {
+    const io = testing.io;
+
+    var rl: Io.RwLock = .init;
+
+    rl.lockUncancelable(io);
+    try testing.expect(!rl.tryLock(io));
+    try testing.expect(!rl.tryLockShared(io));
+    rl.unlock(io);
+
+    try testing.expect(rl.tryLock(io));
+    try testing.expect(!rl.tryLock(io));
+    try testing.expect(!rl.tryLockShared(io));
+    rl.unlock(io);
+
+    rl.lockSharedUncancelable(io);
+    try testing.expect(!rl.tryLock(io));
+    try testing.expect(rl.tryLockShared(io));
+    rl.unlockShared(io);
+    rl.unlockShared(io);
+
+    try testing.expect(rl.tryLockShared(io));
+    try testing.expect(!rl.tryLock(io));
+    try testing.expect(rl.tryLockShared(io));
+    rl.unlockShared(io);
+    rl.unlockShared(io);
+
+    rl.lockUncancelable(io);
+    rl.unlock(io);
+}
+
+test "concurrent access" {
+    if (builtin.single_threaded) return;
+
+    const io = testing.io;
+    const num_writers: usize = 2;
+    const num_readers: usize = 4;
+    const num_writes: usize = 1000;
+    const num_reads: usize = 2000;
+
+    const Runner = struct {
+        const Runner = @This();
+
+        io: Io,
+
+        rl: Io.RwLock,
+        writes: usize,
+        reads: std.atomic.Value(usize),
+
+        val_a: usize,
+        val_b: usize,
+
+        fn reader(run: *Runner, thread_idx: usize) !void {
+            var prng = std.Random.DefaultPrng.init(thread_idx);
+            const rnd = prng.random();
+            while (true) {
+                run.rl.lockSharedUncancelable(run.io);
+                defer run.rl.unlockShared(run.io);
+
+                try testing.expect(run.writes <= num_writes);
+                if (run.reads.fetchAdd(1, .monotonic) >= num_reads) break;
+
+                // We use `volatile` accesses so that we can make sure the memory is accessed either
+                // side of a yield, maximising chances of a race.
+                const a_ptr: *const volatile usize = &run.val_a;
+                const b_ptr: *const volatile usize = &run.val_b;
+
+                const old_a = a_ptr.*;
+                if (rnd.boolean()) try std.Thread.yield();
+                const old_b = b_ptr.*;
+                try testing.expect(old_a == old_b);
+            }
+        }
+
+        fn writer(run: *Runner, thread_idx: usize) !void {
+            var prng = std.Random.DefaultPrng.init(thread_idx);
+            const rnd = prng.random();
+            while (true) {
+                run.rl.lockUncancelable(run.io);
+                defer run.rl.unlock(run.io);
+
+                try testing.expect(run.writes <= num_writes);
+                if (run.writes == num_writes) break;
+
+                // We use `volatile` accesses so that we can make sure the memory is accessed either
+                // side of a yield, maximising chances of a race.
+                const a_ptr: *volatile usize = &run.val_a;
+                const b_ptr: *volatile usize = &run.val_b;
+
+                const new_val = rnd.int(usize);
+
+                const old_a = a_ptr.*;
+                a_ptr.* = new_val;
+                if (rnd.boolean()) try std.Thread.yield();
+                const old_b = b_ptr.*;
+                b_ptr.* = new_val;
+                try testing.expect(old_a == old_b);
+
+                run.writes += 1;
+            }
+        }
+    };
+
+    var run: Runner = .{
+        .io = io,
+        .rl = .init,
+        .writes = 0,
+        .reads = .init(0),
+        .val_a = 0,
+        .val_b = 0,
+    };
+    var write_threads: [num_writers]std.Thread = undefined;
+    var read_threads: [num_readers]std.Thread = undefined;
+
+    for (&write_threads, 0..) |*t, i| t.* = try .spawn(.{}, Runner.writer, .{ &run, i });
+    for (&read_threads, num_writers..) |*t, i| t.* = try .spawn(.{}, Runner.reader, .{ &run, i });
+
+    for (write_threads) |t| t.join();
+    for (read_threads) |t| t.join();
+
+    try testing.expect(run.writes == num_writes);
+    try testing.expect(run.reads.raw >= num_reads);
+}
diff --git a/lib/std/Io/Semaphore.zig b/lib/std/Io/Semaphore.zig
new file mode 100644
index 0000000000000000000000000000000000000000..248e6ab4d071dc82a5cd626765628de299b142b8
--- /dev/null
+++ b/lib/std/Io/Semaphore.zig
@@ -0,0 +1,65 @@
+//! An unsigned integer that blocks the kernel thread if the number would
+//! become negative.
+//!
+//! This API supports static initialization and does not require deinitialization.
+const Semaphore = @This();
+
+const builtin = @import("builtin");
+
+const std = @import("../std.zig");
+const Io = std.Io;
+const testing = std.testing;
+
+mutex: Io.Mutex = .init,
+cond: Io.Condition = .init,
+/// It is OK to initialize this field to any value.
+permits: usize = 0,
+
+pub fn wait(s: *Semaphore, io: Io) Io.Cancelable!void {
+    try s.mutex.lock(io);
+    defer s.mutex.unlock(io);
+    while (s.permits == 0) try s.cond.wait(io, &s.mutex);
+    s.permits -= 1;
+    if (s.permits > 0) s.cond.signal(io);
+}
+
+pub fn waitUncancelable(s: *Semaphore, io: Io) void {
+    s.mutex.lockUncancelable(io);
+    defer s.mutex.unlock(io);
+    while (s.permits == 0) s.cond.waitUncancelable(io, &s.mutex);
+    s.permits -= 1;
+    if (s.permits > 0) s.cond.signal(io);
+}
+
+pub fn post(s: *Semaphore, io: Io) void {
+    s.mutex.lockUncancelable(io);
+    defer s.mutex.unlock(io);
+
+    s.permits += 1;
+    s.cond.signal(io);
+}
+
+test Semaphore {
+    if (builtin.single_threaded) return error.SkipZigTest;
+    const io = testing.io;
+
+    const TestContext = struct {
+        sem: *Semaphore,
+        n: *i32,
+        fn worker(ctx: *@This()) !void {
+            try ctx.sem.wait(io);
+            ctx.n.* += 1;
+            ctx.sem.post(io);
+        }
+    };
+    const num_threads = 3;
+    var sem: Semaphore = .{ .permits = 1 };
+    var threads: [num_threads]std.Thread = undefined;
+    var n: i32 = 0;
+    var ctx = TestContext{ .sem = &sem, .n = &n };
+
+    for (&threads) |*t| t.* = try std.Thread.spawn(.{}, TestContext.worker, .{&ctx});
+    for (threads) |t| t.join();
+    try sem.wait(io);
+    try testing.expect(n == num_threads);
+}
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index b2ff7533849f1b3d8e41b7bfb5a2c2920bc6ee35..053a87b27c8809bfdb0aca8efd2629e4afd14879 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2655,7 +2655,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
 fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
-        const deadline: ?Io.Clock.Timestamp = timeout.toDeadline(ioBasic(t)) catch |err| switch (err) {
+        const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(ioBasic(t)) catch |err| switch (err) {
             error.Unexpected => deadline: {
                 recoverableOsBugDetected();
                 break :deadline .{ .raw = .{ .nanoseconds = 0 }, .clock = .awake };
@@ -2754,7 +2754,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         else => {},
     }
     const t_io = ioBasic(t);
-    const deadline = timeout.toDeadline(t_io) catch return error.UnsupportedClock;
+    const deadline = timeout.toTimestamp(t_io) catch return error.UnsupportedClock;
     while (true) {
         const timeout_ms: i32 = t: {
             if (b.completions.head != .none) {
@@ -10918,7 +10918,7 @@ fn nowWasi(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
 fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (timeout == .none) return;
-    if (use_parking_sleep) return parking_sleep.sleep(try timeout.toDeadline(ioBasic(t)));
+    if (use_parking_sleep) return parking_sleep.sleep(try timeout.toTimestamp(ioBasic(t)));
     if (native_os == .wasi) return sleepWasi(t, timeout);
     if (@TypeOf(posix.system.clock_nanosleep) != void) return sleepPosix(timeout);
     return sleepNanosleep(t, timeout);
@@ -12630,7 +12630,7 @@ fn netReceivePosix(
     var message_i: usize = 0;
     var data_i: usize = 0;
 
-    const deadline = timeout.toDeadline(t_io) catch |err| return .{ err, message_i };
+    const deadline = timeout.toTimestamp(t_io) catch |err| return .{ err, message_i };
 
     recv: while (true) {
         if (message_buffer.len - message_i == 0) return .{ null, message_i };
diff --git a/lib/std/debug/SelfInfo/Elf.zig b/lib/std/debug/SelfInfo/Elf.zig
index a2868fcee1429b0ab4757d4cb32603c27904250f..40841bac2c351d824604556c7c67f1548aa964a0 100644
--- a/lib/std/debug/SelfInfo/Elf.zig
+++ b/lib/std/debug/SelfInfo/Elf.zig
@@ -1,4 +1,4 @@
-mutex: Io.Mutex,
+rwlock: Io.RwLock,
 
 modules: std.ArrayList(Module),
 ranges: std.ArrayList(Module.Range),
@@ -6,7 +6,7 @@ ranges: std.ArrayList(Module.Range),
 unwind_cache: if (can_unwind) ?[]Dwarf.SelfUnwinder.CacheEntry else ?noreturn,
 
 pub const init: SelfInfo = .{
-    .mutex = .init,
+    .rwlock = .init,
     .modules = .empty,
     .ranges = .empty,
     .unwind_cache = null,
@@ -30,7 +30,7 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
 
 pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
     const module = try si.findModule(gpa, io, address, .exclusive);
-    defer si.mutex.unlock(io);
+    defer si.rwlock.unlock(io);
 
     const vaddr = address - module.load_offset;
 
@@ -75,13 +75,13 @@ pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!st
 }
 pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
     const module = try si.findModule(gpa, io, address, .shared);
-    defer si.mutex.unlock(io);
+    defer si.rwlock.unlockShared(io);
     if (module.name.len == 0) return error.MissingDebugInfo;
     return module.name;
 }
 pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
     const module = try si.findModule(gpa, io, address, .shared);
-    defer si.mutex.unlock(io);
+    defer si.rwlock.unlockShared(io);
     return module.load_offset;
 }
 
@@ -183,8 +183,8 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
     comptime assert(can_unwind);
 
     {
-        try si.mutex.lock(io);
-        defer si.mutex.unlock(io);
+        si.rwlock.lockSharedUncancelable(io);
+        defer si.rwlock.unlockShared(io);
         if (si.unwind_cache) |cache| {
             if (Dwarf.SelfUnwinder.CacheEntry.find(cache, context.pc)) |entry| {
                 return context.next(gpa, entry);
@@ -193,7 +193,7 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
     }
 
     const module = try si.findModule(gpa, io, context.pc, .exclusive);
-    defer si.mutex.unlock(io);
+    defer si.rwlock.unlock(io);
 
     if (si.unwind_cache == null) {
         si.unwind_cache = try gpa.alloc(Dwarf.SelfUnwinder.CacheEntry, 2048);
@@ -378,8 +378,8 @@ const Module = struct {
 fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum { shared, exclusive }) Error!*Module {
     // With the requested lock, scan the module ranges looking for `address`.
     switch (lock) {
-        .shared => try si.mutex.lock(io),
-        .exclusive => try si.mutex.lock(io),
+        .shared => si.rwlock.lockSharedUncancelable(io),
+        .exclusive => si.rwlock.lockUncancelable(io),
     }
     for (si.ranges.items) |*range| {
         if (address >= range.start and address < range.start + range.len) {
@@ -389,12 +389,15 @@ fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum
     // The address wasn't in a known range. We will rebuild the module/range lists, since it's possible
     // a new module was loaded. Upgrade to an exclusive lock if necessary.
     switch (lock) {
-        .shared => {},
+        .shared => {
+            si.rwlock.unlockShared(io);
+            si.rwlock.lockUncancelable(io);
+        },
         .exclusive => {},
     }
     // Rebuild module list with the exclusive lock.
     {
-        errdefer si.mutex.unlock(io);
+        errdefer si.rwlock.unlock(io);
         for (si.modules.items) |*mod| {
             unwind: {
                 const u = &(mod.unwind orelse break :unwind catch break :unwind);
@@ -412,7 +415,10 @@ fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum
     }
     // Downgrade the lock back to shared if necessary.
     switch (lock) {
-        .shared => {},
+        .shared => {
+            si.rwlock.unlock(io);
+            si.rwlock.lockSharedUncancelable(io);
+        },
         .exclusive => {},
     }
     // Scan the newly rebuilt module ranges.
@@ -423,8 +429,8 @@ fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum
     }
     // Still nothing; unlock and error.
     switch (lock) {
-        .shared => si.mutex.unlock(io),
-        .exclusive => si.mutex.unlock(io),
+        .shared => si.rwlock.unlockShared(io),
+        .exclusive => si.rwlock.unlock(io),
     }
     return error.MissingDebugInfo;
 }
-- 
2.54.0


From 922ab8b8bc3b6dc14da9393b65ca2601f9a82728 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 18:09:39 -0800
Subject: [PATCH 178/499] std: finish moving time to Io interface

Importantly, adds ability to get Clock resolution, which may be zero.
This allows error.Unexpected and error.ClockUnsupported to be removed
from timeout and clock reading error sets.
---
 lib/compiler/aro/aro/Compilation.zig  |   2 +-
 lib/compiler/aro/aro/Preprocessor.zig |   2 +-
 lib/compiler/build_runner.zig         |   2 +-
 lib/std/Build/Step.zig                |  19 +--
 lib/std/Build/Step/Run.zig            |  26 ++--
 lib/std/Build/WebServer.zig           |   6 +-
 lib/std/Io.zig                        | 122 ++++++++++++-----
 lib/std/Io/File/MultiReader.zig       |   2 +-
 lib/std/Io/Threaded.zig               | 160 +++++++++++++---------
 lib/std/Io/net.zig                    |   2 +-
 lib/std/Io/net/HostName.zig           |   2 +-
 lib/std/Io/test.zig                   |   6 -
 lib/std/crypto/Certificate/Bundle.zig |   4 +-
 lib/std/http/Client.zig               |   2 +-
 lib/std/os/linux.zig                  |  10 +-
 lib/std/os/linux/IoUring/test.zig     |   4 +-
 lib/std/posix.zig                     |  52 --------
 lib/std/time.zig                      | 182 --------------------------
 src/Compilation.zig                   |  35 +++--
 src/Zcu.zig                           |  10 +-
 src/Zcu/PerThread.zig                 |   6 +-
 src/link.zig                          |   8 +-
 22 files changed, 258 insertions(+), 406 deletions(-)

diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig
index c5f400f1d9f1cbf6e18daafa5eaa9dbb3f2d92ef..44e0248b8b519799b647078cbcf8c369e04b705a 100644
--- a/lib/compiler/aro/aro/Compilation.zig
+++ b/lib/compiler/aro/aro/Compilation.zig
@@ -107,7 +107,7 @@ pub const Environment = struct {
             if (parsed > max_timestamp) return error.InvalidEpoch;
             return .{ .provided = parsed };
         } else {
-            const timestamp = try Io.Clock.real.now(io);
+            const timestamp = Io.Clock.real.now(io);
             const seconds = std.math.cast(u64, timestamp.toSeconds()) orelse return error.InvalidEpoch;
             return .{ .system = std.math.clamp(seconds, 0, max_timestamp) };
         }
diff --git a/lib/compiler/aro/aro/Preprocessor.zig b/lib/compiler/aro/aro/Preprocessor.zig
index 6e36703df14a100feca2b200e1998962d2d7c99f..854c3afbf38b25e2b622da064e99e1033c819385 100644
--- a/lib/compiler/aro/aro/Preprocessor.zig
+++ b/lib/compiler/aro/aro/Preprocessor.zig
@@ -301,7 +301,7 @@ pub fn init(comp: *Compilation, source_epoch: SourceEpoch) Preprocessor {
 /// Initialize Preprocessor with builtin macros.
 pub fn initDefault(comp: *Compilation) !Preprocessor {
     const source_epoch: SourceEpoch = comp.environment.sourceEpoch(comp.io) catch |er| switch (er) {
-        error.InvalidEpoch, error.UnsupportedClock, error.Unexpected => blk: {
+        error.InvalidEpoch => blk: {
             const diagnostic: Diagnostic = .invalid_source_epoch;
             try comp.diagnostics.add(.{ .text = diagnostic.fmt, .kind = diagnostic.kind, .opt = diagnostic.opt, .location = null });
             break :blk .default;
diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 04ceb6212c84ce9c91633fa3ad10c316702a1855..2dd18d4f0dcaa426988c8747fa03c49859830d72 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -548,7 +548,7 @@ pub fn main(init: process.Init.Minimal) !void {
         break :w try .init(graph.cache.cwd);
     };
 
-    const now = Io.Clock.Timestamp.now(io, .awake) catch |err| fatal("failed to collect timestamp: {t}", .{err});
+    const now = Io.Clock.Timestamp.now(io, .awake);
 
     run.web_server = if (webui_listen) |listen_address| ws: {
         if (builtin.single_threaded) unreachable; // `fatal` above
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 2f5e4316d47cb32e1dee00c79bee977333b3bc79..b9581196c0ec59e125a8d0da6f607264f2afddb0 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -266,16 +266,19 @@ pub fn init(options: StepOptions) Step {
 /// here.
 pub fn make(s: *Step, options: MakeOptions) error{ MakeFailed, MakeSkipped }!void {
     const arena = s.owner.allocator;
+    const graph = s.owner.graph;
+    const io = graph.io;
 
-    var timer: ?std.time.Timer = t: {
-        if (!s.owner.graph.time_report) break :t null;
+    var start_ts: ?Io.Timestamp = t: {
+        if (!graph.time_report) break :t null;
         if (s.id == .compile) break :t null;
         if (s.id == .run and s.cast(Run).?.stdio == .zig_test) break :t null;
-        break :t std.time.Timer.start() catch @panic("--time-report not supported on this host");
+        break :t Io.Clock.awake.now(io);
     };
     const make_result = s.makeFn(s, options);
-    if (timer) |*t| {
-        options.web_server.?.updateTimeReportGeneric(s, t.read());
+    if (start_ts) |*ts| {
+        const duration = ts.untilNow(io, .awake);
+        options.web_server.?.updateTimeReportGeneric(s, duration);
     }
 
     make_result catch |err| switch (err) {
@@ -534,7 +537,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
     const arena = b.allocator;
     const io = b.graph.io;
 
-    var timer = try std.time.Timer.start();
+    const start_ts = Io.Clock.awake.now(io);
 
     try sendMessage(io, zp.child.stdin.?, .update);
     if (!watch) try sendMessage(io, zp.child.stdin.?, .exit);
@@ -637,7 +640,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
                     .compile = s.cast(Step.Compile).?,
                     .use_llvm = tr.flags.use_llvm,
                     .stats = tr.stats,
-                    .ns_total = timer.read(),
+                    .ns_total = @intCast(start_ts.untilNow(io, .awake).toNanoseconds()),
                     .llvm_pass_timings_len = tr.llvm_pass_timings_len,
                     .files_len = tr.files_len,
                     .decls_len = tr.decls_len,
@@ -648,7 +651,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*Build.
         }
     }
 
-    s.result_duration_ns = timer.read();
+    s.result_duration_ns = @intCast(start_ts.untilNow(io, .awake).toNanoseconds());
 
     const stderr_contents = zp.multi_reader.reader(1).buffered();
     if (stderr_contents.len > 0) {
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 3f5df9f2ae351db03282648d3ce38c488f8b3288..e80f57f0bc33db759b32ef03b37c5a355e680f84 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1587,12 +1587,12 @@ fn spawnChildAndCollect(
     };
 
     if (run.stdio == .zig_test) {
-        const started: Io.Clock.Timestamp = try .now(io, .awake);
+        const started: Io.Clock.Timestamp = .now(io, .awake);
         const result = evalZigTest(run, spawn_options, options, fuzz_context) catch |err| switch (err) {
             error.Canceled => |e| return e,
             else => |e| e,
         };
-        run.step.result_duration_ns = @intCast((try started.untilNow(io)).raw.nanoseconds);
+        run.step.result_duration_ns = @intCast(started.untilNow(io).raw.nanoseconds);
         try result;
         return null;
     } else {
@@ -1607,12 +1607,12 @@ fn spawnChildAndCollect(
         defer if (inherit) io.unlockStderr();
         try setColorEnvironmentVariables(run, environ_map, terminal_mode);
 
-        const started: Io.Clock.Timestamp = try .now(io, .awake);
+        const started: Io.Clock.Timestamp = .now(io, .awake);
         const result = evalGeneric(run, spawn_options) catch |err| switch (err) {
             error.Canceled => |e| return e,
             else => |e| e,
         };
-        run.step.result_duration_ns = @intCast((try started.untilNow(io)).raw.nanoseconds);
+        run.step.result_duration_ns = @intCast(started.untilNow(io).raw.nanoseconds);
         return try result;
     }
 }
@@ -1869,7 +1869,7 @@ fn waitZigTest(
 
     var active_test_index: ?u32 = null;
 
-    var last_update: Io.Clock.Timestamp = try .now(io, .awake);
+    var last_update: Io.Clock.Timestamp = .now(io, .awake);
 
     var coverage_id: ?u64 = null;
 
@@ -1908,11 +1908,11 @@ fn waitZigTest(
             multi_reader.fill(64, timeout) catch |err| switch (err) {
                 error.Timeout => return .{ .timeout = .{
                     .active_test_index = active_test_index,
-                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
+                    .ns_elapsed = @intCast(last_update.untilNow(io).raw.nanoseconds),
                 } },
                 error.EndOfStream => return .{ .no_poll = .{
                     .active_test_index = active_test_index,
-                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
+                    .ns_elapsed = @intCast(last_update.untilNow(io).raw.nanoseconds),
                 } },
                 else => |e| return e,
             };
@@ -1926,11 +1926,11 @@ fn waitZigTest(
             multi_reader.fill(64, timeout) catch |err| switch (err) {
                 error.Timeout => return .{ .timeout = .{
                     .active_test_index = active_test_index,
-                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
+                    .ns_elapsed = @intCast(last_update.untilNow(io).raw.nanoseconds),
                 } },
                 error.EndOfStream => return .{ .no_poll = .{
                     .active_test_index = active_test_index,
-                    .ns_elapsed = @intCast((try last_update.untilNow(io)).raw.nanoseconds),
+                    .ns_elapsed = @intCast(last_update.untilNow(io).raw.nanoseconds),
                 } },
                 else => |e| return e,
             };
@@ -1976,13 +1976,13 @@ fn waitZigTest(
                 @memset(opt_metadata.*.?.ns_per_test, std.math.maxInt(u64));
 
                 active_test_index = null;
-                last_update = try .now(io, .awake);
+                last_update = .now(io, .awake);
 
                 requestNextTest(io, child.stdin.?, &opt_metadata.*.?, &sub_prog_node) catch |err| return .{ .write_failed = err };
             },
             .test_started => {
                 active_test_index = opt_metadata.*.?.next_index - 1;
-                last_update = try .now(io, .awake);
+                last_update = .now(io, .awake);
             },
             .test_results => {
                 assert(fuzz_context == null);
@@ -2026,7 +2026,7 @@ fn waitZigTest(
 
                 active_test_index = null;
 
-                const now: Io.Clock.Timestamp = try .now(io, .awake);
+                const now: Io.Clock.Timestamp = .now(io, .awake);
                 md.ns_per_test[tr_hdr.index] = @intCast(last_update.durationTo(now).raw.nanoseconds);
                 last_update = now;
 
@@ -2239,7 +2239,7 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
                         return error.StderrStreamTooLong;
                 }
             } else |err| switch (err) {
-                error.UnsupportedClock, error.Timeout => unreachable,
+                error.Timeout => unreachable,
                 error.EndOfStream => {},
                 else => |e| return e,
             }
diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index 7205291400ab81d6a693f6361ebc6c2975ce9a40..08bc584522683423c04ee33fe6b03f96f68b64e8 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -243,7 +243,7 @@ pub fn finishBuild(ws: *WebServer, opts: struct {
 
 pub fn now(s: *const WebServer) i64 {
     const io = s.graph.io;
-    const ts = base_clock.now(io) catch s.base_timestamp;
+    const ts = base_clock.now(io);
     return @intCast(s.base_timestamp.durationTo(ts).toNanoseconds());
 }
 
@@ -761,7 +761,7 @@ pub fn updateTimeReportCompile(ws: *WebServer, opts: struct {
     ws.notifyUpdate();
 }
 
-pub fn updateTimeReportGeneric(ws: *WebServer, step: *Build.Step, ns_total: u64) void {
+pub fn updateTimeReportGeneric(ws: *WebServer, step: *Build.Step, duration: Io.Duration) void {
     const gpa = ws.gpa;
     const io = ws.graph.io;
 
@@ -780,7 +780,7 @@ pub fn updateTimeReportGeneric(ws: *WebServer, step: *Build.Step, ns_total: u64)
     const out: *align(1) abi.time_report.GenericResult = @ptrCast(buf);
     out.* = .{
         .step_idx = step_idx,
-        .ns_total = ns_total,
+        .ns_total = @intCast(duration.toNanoseconds()),
     };
     {
         ws.time_report_mutex.lock(io) catch return;
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 22ca78fd2b1a8552e0e6fb599c299638add1046e..09da9b533acdcfa58bc443992015c646660ee141 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -231,8 +231,9 @@ pub const VTable = struct {
 
     progressParentFile: *const fn (?*anyopaque) std.Progress.ParentFileError!File,
 
-    now: *const fn (?*anyopaque, Clock) Clock.Error!Timestamp,
-    sleep: *const fn (?*anyopaque, Timeout) SleepError!void,
+    now: *const fn (?*anyopaque, Clock) Timestamp,
+    clockResolution: *const fn (?*anyopaque, Clock) Duration,
+    sleep: *const fn (?*anyopaque, Timeout) Cancelable!void,
 
     random: *const fn (?*anyopaque, buffer: []u8) void,
     randomSecure: *const fn (?*anyopaque, buffer: []u8) RandomSecureError!void,
@@ -701,30 +702,48 @@ pub const Clock = enum {
     /// thread.
     cpu_thread,
 
-    pub const Error = error{UnsupportedClock} || UnexpectedError;
-
-    /// This function is not cancelable because first of all it does not block,
-    /// but more importantly, the cancelation logic itself may want to check
-    /// the time.
-    pub fn now(clock: Clock, io: Io) Error!Io.Timestamp {
+    /// This function is not cancelable because it does not block.
+    ///
+    /// Resolution is determined by `resolution` which may be 0 if the
+    /// clock is unsupported.
+    ///
+    /// See also:
+    /// * `Clock.Timestamp.now`
+    pub fn now(clock: Clock, io: Io) Io.Timestamp {
         return io.vtable.now(io.userdata, clock);
     }
 
+    /// Reveals the granularity of `clock`. May be zero, indicating
+    /// unsupported clock.
+    pub fn resolution(clock: Clock, io: Io) Io.Duration {
+        return io.vtable.clockResolution(io.userdata, clock);
+    }
+
     pub const Timestamp = struct {
         raw: Io.Timestamp,
         clock: Clock,
 
-        /// This function is not cancelable because first of all it does not block,
-        /// but more importantly, the cancelation logic itself may want to check
-        /// the time.
-        pub fn now(io: Io, clock: Clock) Error!Clock.Timestamp {
+        /// This function is not cancelable because it does not block.
+        ///
+        /// Resolution is determined by `resolution` which may be 0 if
+        /// the clock is unsupported.
+        ///
+        /// See also:
+        /// * `Clock.now`
+        pub fn now(io: Io, clock: Clock) Clock.Timestamp {
             return .{
-                .raw = try io.vtable.now(io.userdata, clock),
+                .raw = io.vtable.now(io.userdata, clock),
                 .clock = clock,
             };
         }
 
-        pub fn wait(t: Clock.Timestamp, io: Io) SleepError!void {
+        /// Sleeps until the timestamp arrives.
+        ///
+        /// See also:
+        /// * `Io.sleep`
+        /// * `Clock.Duration.sleep`
+        /// * `Timeout.sleep`
+        pub fn wait(t: Clock.Timestamp, io: Io) Cancelable!void {
             return io.vtable.sleep(io.userdata, .{ .deadline = t });
         }
 
@@ -752,30 +771,38 @@ pub const Clock = enum {
             };
         }
 
-        pub fn fromNow(io: Io, duration: Clock.Duration) Error!Clock.Timestamp {
+        /// Resolution is determined by `resolution` which may be 0 if
+        /// the clock is unsupported.
+        pub fn fromNow(io: Io, duration: Clock.Duration) Clock.Timestamp {
             return .{
                 .clock = duration.clock,
-                .raw = (try duration.clock.now(io)).addDuration(duration.raw),
+                .raw = duration.clock.now(io).addDuration(duration.raw),
             };
         }
 
-        pub fn untilNow(timestamp: Clock.Timestamp, io: Io) Error!Clock.Duration {
-            const now_ts = try Clock.Timestamp.now(io, timestamp.clock);
+        /// Resolution is determined by `resolution` which may be 0 if
+        /// the clock is unsupported.
+        pub fn untilNow(timestamp: Clock.Timestamp, io: Io) Clock.Duration {
+            const now_ts = Clock.Timestamp.now(io, timestamp.clock);
             return timestamp.durationTo(now_ts);
         }
 
-        pub fn durationFromNow(timestamp: Clock.Timestamp, io: Io) Error!Clock.Duration {
-            const now_ts = try timestamp.clock.now(io);
+        /// Resolution is determined by `resolution` which may be 0 if
+        /// the clock is unsupported.
+        pub fn durationFromNow(timestamp: Clock.Timestamp, io: Io) Clock.Duration {
+            const now_ts = timestamp.clock.now(io);
             return .{
                 .clock = timestamp.clock,
                 .raw = now_ts.durationTo(timestamp.raw),
             };
         }
 
-        pub fn toClock(t: Clock.Timestamp, io: Io, clock: Clock) Error!Clock.Timestamp {
+        /// Resolution is determined by `resolution` which may be 0 if
+        /// the clock is unsupported.
+        pub fn toClock(t: Clock.Timestamp, io: Io, clock: Clock) Clock.Timestamp {
             if (t.clock == clock) return t;
-            const now_old = try t.clock.now(io);
-            const now_new = try clock.now(io);
+            const now_old = t.clock.now(io);
+            const now_new = clock.now(io);
             const duration = now_old.durationTo(t);
             return .{
                 .clock = clock,
@@ -793,7 +820,13 @@ pub const Clock = enum {
         raw: Io.Duration,
         clock: Clock,
 
-        pub fn sleep(duration: Clock.Duration, io: Io) SleepError!void {
+        /// Waits until a specified amount of time has passed on `clock`.
+        ///
+        /// See also:
+        /// * `Io.sleep`
+        /// * `Clock.Timestamp.wait`
+        /// * `Timeout.sleep`
+        pub fn sleep(duration: Clock.Duration, io: Io) Cancelable!void {
             return io.vtable.sleep(io.userdata, .{ .duration = duration });
         }
     };
@@ -802,6 +835,10 @@ pub const Clock = enum {
 pub const Timestamp = struct {
     nanoseconds: i96,
 
+    pub fn now(io: Io, clock: Clock) Io.Timestamp {
+        return io.vtable.now(io.userdata, clock);
+    }
+
     pub const zero: Timestamp = .{ .nanoseconds = 0 };
 
     pub fn durationTo(from: Timestamp, to: Timestamp) Duration {
@@ -844,6 +881,13 @@ pub const Timestamp = struct {
             .fill = n.fill,
         });
     }
+
+    /// Resolution is determined by `Clock.resolution` which may be 0 if
+    /// the clock is unsupported.
+    pub fn untilNow(t: Timestamp, io: Io, clock: Clock) Duration {
+        const now_ts = clock.now(io);
+        return t.durationTo(now_ts);
+    }
 };
 
 pub const Duration = struct {
@@ -883,12 +927,12 @@ pub const Timeout = union(enum) {
     duration: Clock.Duration,
     deadline: Clock.Timestamp,
 
-    pub const Error = error{ Timeout, UnsupportedClock };
+    pub const Error = error{Timeout};
 
-    pub fn toTimestamp(t: Timeout, io: Io) Clock.Error!?Clock.Timestamp {
+    pub fn toTimestamp(t: Timeout, io: Io) ?Clock.Timestamp {
         return switch (t) {
             .none => null,
-            .duration => |d| try .fromNow(io, d),
+            .duration => |d| .fromNow(io, d),
             .deadline => |d| d,
         };
     }
@@ -896,20 +940,26 @@ pub const Timeout = union(enum) {
     pub fn toDeadline(t: Timeout, io: Io) Timeout {
         return switch (t) {
             .none => .none,
-            .duration => |d| .{ .deadline = Clock.Timestamp.fromNow(io, d) catch @panic("TODO") },
+            .duration => |d| .{ .deadline = .fromNow(io, d) },
             .deadline => |d| .{ .deadline = d },
         };
     }
 
-    pub fn toDurationFromNow(t: Timeout, io: Io) Clock.Error!?Clock.Duration {
+    pub fn toDurationFromNow(t: Timeout, io: Io) ?Clock.Duration {
         return switch (t) {
             .none => null,
             .duration => |d| d,
-            .deadline => |d| try d.durationFromNow(io),
+            .deadline => |d| d.durationFromNow(io),
         };
     }
 
-    pub fn sleep(timeout: Timeout, io: Io) SleepError!void {
+    /// Waits until the timeout has passed.
+    ///
+    /// See also:
+    /// * `Io.sleep`
+    /// * `Clock.Duration.sleep`
+    /// * `Clock.Timestamp.wait`
+    pub fn sleep(timeout: Timeout, io: Io) Cancelable!void {
         return io.vtable.sleep(io.userdata, timeout);
     }
 };
@@ -2027,9 +2077,13 @@ pub fn concurrent(
     return future;
 }
 
-pub const SleepError = error{UnsupportedClock} || UnexpectedError || Cancelable;
-
-pub fn sleep(io: Io, duration: Duration, clock: Clock) SleepError!void {
+/// Waits until a specified amount of time has passed on `clock`.
+///
+/// See also:
+/// * `Clock.Duration.sleep`
+/// * `Clock.Timestamp.wait`
+/// * `Timeout.sleep`
+pub fn sleep(io: Io, duration: Duration, clock: Clock) Cancelable!void {
     return io.vtable.sleep(io.userdata, .{ .duration = .{
         .raw = duration,
         .clock = clock,
diff --git a/lib/std/Io/File/MultiReader.zig b/lib/std/Io/File/MultiReader.zig
index 217215a3636e40b4fe4ad805be2df88fa2830947..85841d4a976d90a396685be689e8ea04cc8e4e24 100644
--- a/lib/std/Io/File/MultiReader.zig
+++ b/lib/std/Io/File/MultiReader.zig
@@ -179,7 +179,7 @@ fn rebase(r: *Io.Reader, capacity: usize) Io.Reader.RebaseError!void {
 
 fn fillUntimed(context: *Context, capacity: usize) Io.Reader.Error!void {
     fill(context.mr, capacity, .none) catch |err| switch (err) {
-        error.Timeout, error.UnsupportedClock => unreachable,
+        error.Timeout => unreachable,
         error.Canceled, error.ConcurrencyUnavailable => |e| {
             context.err = e;
             return error.ReadFailed;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 053a87b27c8809bfdb0aca8efd2629e4afd14879..2cd350f58c9efcddba6f9bb9704fbaa21de0644e 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1712,6 +1712,7 @@ pub fn io(t: *Threaded) Io {
             .progressParentFile = progressParentFile,
 
             .now = now,
+            .clockResolution = clockResolution,
             .sleep = sleep,
 
             .random = random,
@@ -1875,6 +1876,7 @@ pub fn ioBasic(t: *Threaded) Io {
             .progressParentFile = progressParentFile,
 
             .now = now,
+            .clockResolution = clockResolution,
             .sleep = sleep,
 
             .random = random,
@@ -2487,7 +2489,7 @@ fn futexWait(userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Io.
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const t_io = ioBasic(t);
     const timeout_ns: ?u64 = ns: {
-        const d = (timeout.toDurationFromNow(t_io) catch break :ns 10) orelse break :ns null;
+        const d = timeout.toDurationFromNow(t_io) orelse break :ns null;
         break :ns std.math.lossyCast(u64, d.raw.toNanoseconds());
     };
     return Thread.futexWait(ptr, expected, timeout_ns);
@@ -2655,24 +2657,12 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
 fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
-        const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(ioBasic(t)) catch |err| switch (err) {
-            error.Unexpected => deadline: {
-                recoverableOsBugDetected();
-                break :deadline .{ .raw = .{ .nanoseconds = 0 }, .clock = .awake };
-            },
-            error.UnsupportedClock => |e| return e,
-        };
+        const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(ioBasic(t));
         try batchAwaitWindows(b, true);
         while (b.pending.head != .none and b.completions.head == .none) {
             var delay_interval: windows.LARGE_INTEGER = interval: {
                 const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
-                break :interval t.deadlineToWindowsInterval(d) catch |err| switch (err) {
-                    error.UnsupportedClock => |e| return e,
-                    error.Unexpected => {
-                        recoverableOsBugDetected();
-                        break :interval -1;
-                    },
-                };
+                break :interval t.deadlineToWindowsInterval(d);
             };
             const alertable_syscall = try AlertableSyscall.start();
             const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
@@ -2754,7 +2744,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         else => {},
     }
     const t_io = ioBasic(t);
-    const deadline = timeout.toTimestamp(t_io) catch return error.UnsupportedClock;
+    const deadline = timeout.toTimestamp(t_io);
     while (true) {
         const timeout_ms: i32 = t: {
             if (b.completions.head != .none) {
@@ -2765,7 +2755,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
                 break :t 0;
             }
             const d = deadline orelse break :t -1;
-            const duration = d.durationFromNow(t_io) catch return error.UnsupportedClock;
+            const duration = d.durationFromNow(t_io);
             if (duration.raw.nanoseconds <= 0) return error.Timeout;
             const max_poll_ms = std.math.maxInt(i32);
             break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
@@ -10821,22 +10811,21 @@ fn fileWriteFilePositional(
     return error.Unimplemented;
 }
 
-fn nowPosix(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
+fn nowPosix(clock: Io.Clock) Io.Timestamp {
     const clock_id: posix.clockid_t = clockToPosix(clock);
-    var tp: posix.timespec = undefined;
-    switch (posix.errno(posix.system.clock_gettime(clock_id, &tp))) {
-        .SUCCESS => return timestampFromPosix(&tp),
-        .INVAL => return error.UnsupportedClock,
-        else => |err| return posix.unexpectedErrno(err),
+    var timespec: posix.timespec = undefined;
+    switch (posix.errno(posix.system.clock_gettime(clock_id, &timespec))) {
+        .SUCCESS => return timestampFromPosix(&timespec),
+        else => return .zero,
     }
 }
 
-fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
+fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Timestamp {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
     return nowInner(clock);
 }
-fn nowInner(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
+fn nowInner(clock: Io.Clock) Io.Timestamp {
     return switch (native_os) {
         .windows => nowWindows(clock),
         .wasi => nowWasi(clock),
@@ -10844,7 +10833,55 @@ fn nowInner(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
     };
 }
 
-fn nowWindows(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
+fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Duration {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+    return switch (native_os) {
+        .windows => switch (clock) {
+            .awake, .boot, .real => {
+                // We don't need to cache QPF as it's internally just a memory read to KUSER_SHARED_DATA
+                // (a read-only page of info updated and mapped by the kernel to all processes):
+                // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntddk-kuser_shared_data
+                // https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntexapi_x/kuser_shared_data/index.htm
+                var qpf: windows.LARGE_INTEGER = undefined;
+                if (windows.ntdll.RtlQueryPerformanceFrequency(&qpf) != 0) {
+                    recoverableOsBugDetected();
+                    return .zero;
+                }
+                // 10Mhz (1 qpc tick every 100ns) is a common enough QPF value that we can optimize on it.
+                // https://github.com/microsoft/STL/blob/785143a0c73f030238ef618890fd4d6ae2b3a3a0/stl/inc/chrono#L694-L701
+                const common_qpf = 10_000_000;
+                if (qpf == common_qpf) return .fromNanoseconds(std.time.ns_per_s / common_qpf);
+
+                // Convert to ns using fixed point.
+                const scale = @as(u64, std.time.ns_per_s << 32) / @as(u32, @intCast(qpf));
+                const result = scale >> 32;
+                return .fromNanoseconds(result);
+            },
+            .cpu_process, .cpu_thread => return .zero,
+        },
+        .wasi => {
+            if (builtin.link_libc) return clockResolutionPosix(clock);
+            var ns: std.os.wasi.timestamp_t = undefined;
+            return switch (std.os.wasi.clock_res_get(clockToWasi(clock), &ns)) {
+                .SUCCESS => .fromNanoseconds(ns),
+                else => .zero,
+            };
+        },
+        else => return clockResolutionPosix(clock),
+    };
+}
+
+fn clockResolutionPosix(clock: Io.Clock) Io.Duration {
+    const clock_id: posix.clockid_t = clockToPosix(clock);
+    var timespec: posix.timespec = undefined;
+    return switch (posix.errno(posix.system.clock_getres(clock_id, &timespec))) {
+        .SUCCESS => .fromNanoseconds(nanosecondsFromPosix(&timespec)),
+        else => .zero,
+    };
+}
+
+fn nowWindows(clock: Io.Clock) Io.Timestamp {
     switch (clock) {
         .real => {
             // RtlGetSystemTimePrecise() has a granularity of 100 nanoseconds
@@ -10882,8 +10919,7 @@ fn nowWindows(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
                 &times,
                 @sizeOf(windows.KERNEL_USER_TIMES),
                 null,
-            ) != .SUCCESS)
-                return error.Unexpected;
+            ) != .SUCCESS) return .zero;
 
             const sum = @as(i96, times.UserTime) + @as(i96, times.KernelTime);
             return .{ .nanoseconds = sum * 100 };
@@ -10899,8 +10935,7 @@ fn nowWindows(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
                 &times,
                 @sizeOf(windows.KERNEL_USER_TIMES),
                 null,
-            ) != .SUCCESS)
-                return error.Unexpected;
+            ) != .SUCCESS) return .zero;
 
             const sum = @as(i96, times.UserTime) + @as(i96, times.KernelTime);
             return .{ .nanoseconds = sum * 100 };
@@ -10908,23 +10943,23 @@ fn nowWindows(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
     }
 }
 
-fn nowWasi(clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
+fn nowWasi(clock: Io.Clock) Io.Timestamp {
     var ns: std.os.wasi.timestamp_t = undefined;
     const err = std.os.wasi.clock_time_get(clockToWasi(clock), 1, &ns);
-    if (err != .SUCCESS) return error.Unexpected;
+    if (err != .SUCCESS) return .zero;
     return .fromNanoseconds(ns);
 }
 
-fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
+fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (timeout == .none) return;
-    if (use_parking_sleep) return parking_sleep.sleep(try timeout.toTimestamp(ioBasic(t)));
+    if (use_parking_sleep) return parking_sleep.sleep(timeout.toTimestamp(ioBasic(t)));
     if (native_os == .wasi) return sleepWasi(t, timeout);
     if (@TypeOf(posix.system.clock_nanosleep) != void) return sleepPosix(timeout);
     return sleepNanosleep(t, timeout);
 }
 
-fn sleepPosix(timeout: Io.Timeout) Io.SleepError!void {
+fn sleepPosix(timeout: Io.Timeout) Io.Cancelable!void {
     const clock_id: posix.clockid_t = clockToPosix(switch (timeout) {
         .none => .awake,
         .duration => |d| d.clock,
@@ -10944,25 +10979,27 @@ fn sleepPosix(timeout: Io.Timeout) Io.SleepError!void {
         } }, &timespec, &timespec);
         // POSIX-standard libc clock_nanosleep() returns *positive* errno values directly
         switch (if (builtin.link_libc) @as(posix.E, @enumFromInt(rc)) else posix.errno(rc)) {
-            .SUCCESS => {
-                syscall.finish();
-                return;
-            },
             .INTR => {
                 try syscall.checkCancel();
                 continue;
             },
-            .INVAL => return syscall.fail(error.UnsupportedClock),
-            else => |err| return syscall.unexpectedErrno(err),
+            // Handles SUCCESS as well as clock not available and unexpected
+            // errors. The user had a chance to check clock resolution before
+            // getting here, which would have reported 0, making this a legal
+            // amount of time to sleep.
+            else => {
+                syscall.finish();
+                return;
+            },
         }
     }
 }
 
-fn sleepWasi(t: *Threaded, timeout: Io.Timeout) Io.SleepError!void {
+fn sleepWasi(t: *Threaded, timeout: Io.Timeout) Io.Cancelable!void {
     const t_io = ioBasic(t);
     const w = std.os.wasi;
 
-    const clock: w.subscription_clock_t = if (try timeout.toDurationFromNow(t_io)) |d| .{
+    const clock: w.subscription_clock_t = if (timeout.toDurationFromNow(t_io)) |d| .{
         .id = clockToWasi(d.clock),
         .timeout = std.math.lossyCast(u64, d.raw.nanoseconds),
         .precision = 0,
@@ -10987,13 +11024,13 @@ fn sleepWasi(t: *Threaded, timeout: Io.Timeout) Io.SleepError!void {
     syscall.finish();
 }
 
-fn sleepNanosleep(t: *Threaded, timeout: Io.Timeout) Io.SleepError!void {
+fn sleepNanosleep(t: *Threaded, timeout: Io.Timeout) Io.Cancelable!void {
     const t_io = ioBasic(t);
     const sec_type = @typeInfo(posix.timespec).@"struct".fields[0].type;
     const nsec_type = @typeInfo(posix.timespec).@"struct".fields[1].type;
 
     var timespec: posix.timespec = t: {
-        const d = (try timeout.toDurationFromNow(t_io)) orelse break :t .{
+        const d = timeout.toDurationFromNow(t_io) orelse break :t .{
             .sec = std.math.maxInt(sec_type),
             .nsec = std.math.maxInt(nsec_type),
         };
@@ -12630,7 +12667,7 @@ fn netReceivePosix(
     var message_i: usize = 0;
     var data_i: usize = 0;
 
-    const deadline = timeout.toTimestamp(t_io) catch |err| return .{ err, message_i };
+    const deadline = timeout.toTimestamp(t_io);
 
     recv: while (true) {
         if (message_buffer.len - message_i == 0) return .{ null, message_i };
@@ -12678,7 +12715,7 @@ fn netReceivePosix(
 
                 const max_poll_ms = std.math.maxInt(u31);
                 const timeout_ms: u31 = if (deadline) |d| t: {
-                    const duration = d.durationFromNow(t_io) catch |err| return .{ err, message_i };
+                    const duration = d.durationFromNow(t_io);
                     if (duration.raw.nanoseconds <= 0) return .{ error.Timeout, message_i };
                     break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
                 } else max_poll_ms;
@@ -13875,7 +13912,11 @@ fn statFromWasi(st: *const std.os.wasi.filestat_t) File.Stat {
 }
 
 fn timestampFromPosix(timespec: *const posix.timespec) Io.Timestamp {
-    return .{ .nanoseconds = @intCast(@as(i128, timespec.sec) * std.time.ns_per_s + timespec.nsec) };
+    return .{ .nanoseconds = nanosecondsFromPosix(timespec) };
+}
+
+fn nanosecondsFromPosix(timespec: *const posix.timespec) i96 {
+    return @intCast(@as(i128, timespec.sec) * std.time.ns_per_s + timespec.nsec);
 }
 
 fn timestampToPosix(nanoseconds: i96) posix.timespec {
@@ -14013,13 +14054,13 @@ fn lookupDns(
     // boot clock is chosen because time the computer is suspended should count
     // against time spent waiting for external messages to arrive.
     const clock: Io.Clock = .boot;
-    var now_ts = try clock.now(t_io);
+    var now_ts = clock.now(t_io);
     const final_ts = now_ts.addDuration(.fromSeconds(rc.timeout_seconds));
     const attempt_duration: Io.Duration = .{
         .nanoseconds = (std.time.ns_per_s / rc.attempts) * @as(i96, rc.timeout_seconds),
     };
 
-    send: while (now_ts.nanoseconds < final_ts.nanoseconds) : (now_ts = try clock.now(t_io)) {
+    send: while (now_ts.nanoseconds < final_ts.nanoseconds) : (now_ts = clock.now(t_io)) {
         const max_messages = queries_buffer.len * HostName.ResolvConf.max_nameservers;
         {
             var message_buffer: [max_messages]Io.net.OutgoingMessage = undefined;
@@ -17021,7 +17062,7 @@ const parking_futex = struct {
         const deadline: ?Io.Clock.Timestamp = switch (timeout) {
             .none => null,
             .duration => |d| .{
-                .raw = (nowInner(d.clock) catch unreachable).addDuration(d.raw),
+                .raw = nowInner(d.clock).addDuration(d.raw),
                 .clock = d.clock,
             },
             .deadline => |d| d,
@@ -17143,7 +17184,7 @@ const parking_sleep = struct {
     comptime {
         assert(use_parking_sleep);
     }
-    fn sleep(deadline: ?Io.Clock.Timestamp) Io.SleepError!void {
+    fn sleep(deadline: ?Io.Clock.Timestamp) Io.Cancelable!void {
         const opt_thread = Thread.current;
         cancelable: {
             const thread = opt_thread orelse break :cancelable;
@@ -17216,12 +17257,9 @@ const parking_sleep = struct {
     }
     /// Sleep for approximately `ms` awake milliseconds in an attempt to work around Windows kernel bugs.
     fn windowsRetrySleep(ms: u32) (Io.Cancelable || Io.UnexpectedError)!void {
-        const now_timestamp = nowWindows(.awake) catch unreachable; // '.awake' is supported on Windows
+        const now_timestamp = nowWindows(.awake); // '.awake' is supported on Windows
         const deadline = now_timestamp.addDuration(.fromMilliseconds(ms));
-        parking_sleep.sleep(.{ .raw = deadline, .clock = .awake }) catch |err| switch (err) {
-            error.UnsupportedClock => unreachable,
-            else => |e| return e,
-        };
+        try parking_sleep.sleep(.{ .raw = deadline, .clock = .awake });
     }
 };
 
@@ -17234,7 +17272,7 @@ fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{T
         .windows => {
             var timeout_buf: windows.LARGE_INTEGER = undefined;
             const raw_timeout: ?*windows.LARGE_INTEGER = if (opt_deadline) |deadline| timeout: {
-                const now_timestamp = nowWindows(deadline.clock) catch unreachable;
+                const now_timestamp = nowWindows(deadline.clock);
                 const nanoseconds = now_timestamp.durationTo(deadline.raw).nanoseconds;
                 timeout_buf = @intCast(@divTrunc(-nanoseconds, 100));
                 break :timeout &timeout_buf;
@@ -17284,17 +17322,17 @@ fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{T
     }
 }
 
-fn deadlineToWindowsInterval(t: *Io.Threaded, deadline: Io.Clock.Timestamp) Io.Clock.Error!windows.LARGE_INTEGER {
+fn deadlineToWindowsInterval(t: *Io.Threaded, deadline: Io.Clock.Timestamp) windows.LARGE_INTEGER {
     // ntdll only supports two combinations:
     // * real-time (`.real`) sleeps with absolute deadlines
     // * monotonic (`.awake`/`.boot`) sleeps with relative durations
     switch (deadline.clock) {
-        .cpu_process, .cpu_thread => unreachable, // cannot sleep for CPU time
+        .cpu_process, .cpu_thread => return 0,
         .real => {
             return @intCast(@max(@divTrunc(deadline.raw.nanoseconds, 100), 0));
         },
         .awake, .boot => {
-            const duration = try deadline.durationFromNow(ioBasic(t));
+            const duration = deadline.durationFromNow(ioBasic(t));
             return @intCast(@min(@divTrunc(-duration.raw.nanoseconds, 100), -1));
         },
     }
diff --git a/lib/std/Io/net.zig b/lib/std/Io/net.zig
index 21bd13caf387e758d91333809879e87469250677..72daee6f94625f9ce88fb2e71b7802a0b3bfbbd4 100644
--- a/lib/std/Io/net.zig
+++ b/lib/std/Io/net.zig
@@ -1137,7 +1137,7 @@ pub const Socket = struct {
         const maybe_err, const count = io.vtable.netReceive(io.userdata, s.handle, (&message)[0..1], buffer, .{}, .none);
         if (maybe_err) |err| switch (err) {
             // No timeout is passed to `netReceieve`, so it must not return timeout related errors.
-            error.Timeout, error.UnsupportedClock => unreachable,
+            error.Timeout => unreachable,
             else => |e| return e,
         };
         assert(1 == count);
diff --git a/lib/std/Io/net/HostName.zig b/lib/std/Io/net/HostName.zig
index 66b5b648a665e05c26bf93f469d3a1a114d2faca..db669c958b910f9c568fa1bd1251a916e85de14b 100644
--- a/lib/std/Io/net/HostName.zig
+++ b/lib/std/Io/net/HostName.zig
@@ -145,7 +145,7 @@ pub const LookupError = error{
     NoAddressReturned,
     /// Failed to open or read "/etc/hosts" or "/etc/resolv.conf".
     DetectingNetworkConfigurationFailed,
-} || Io.Clock.Error || IpAddress.BindError || Io.Cancelable;
+} || IpAddress.BindError || Io.Cancelable;
 
 pub const LookupResult = union(enum) {
     address: IpAddress,
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index a9e2eb28d4125826143239ccc3d6ff5ceef70ffc..70af7a25ee2c909492ff53fb56ecfdfb337e5ac7 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -216,14 +216,12 @@ test "Group.cancel" {
             defer result.* = 1;
             io.sleep(.fromSeconds(100_000), .awake) catch |err| switch (err) {
                 error.Canceled => |e| return e,
-                else => {},
             };
         }
 
         fn sleepRecancel(io: Io, result: *usize) void {
             io.sleep(.fromSeconds(100_000), .awake) catch |err| switch (err) {
                 error.Canceled => io.recancel(),
-                else => {},
             };
             result.* = 1;
         }
@@ -523,8 +521,6 @@ test "cancel sleep" {
         fn blockUntilCanceled(io: Io) void {
             while (true) io.sleep(.fromSeconds(100_000), .awake) catch |err| switch (err) {
                 error.Canceled => return,
-                error.UnsupportedClock => @panic("unsupported clock"),
-                error.Unexpected => @panic("unexpected"),
             };
         }
     };
@@ -552,8 +548,6 @@ test "tasks spawned in group after Group.cancel are canceled" {
         fn blockUntilCanceled(io: Io) Io.Cancelable!void {
             while (true) io.sleep(.fromSeconds(100_000), .awake) catch |err| switch (err) {
                 error.Canceled => |e| return e,
-                error.UnsupportedClock => @panic("unsupported clock"),
-                error.Unexpected => @panic("unexpected"),
             };
         }
     };
diff --git a/lib/std/crypto/Certificate/Bundle.zig b/lib/std/crypto/Certificate/Bundle.zig
index 385ef23c9c7ee205a24263472b08ee107ed95234..5a07ff8a390b5a3402d61660059bcee3265ef031 100644
--- a/lib/std/crypto/Certificate/Bundle.zig
+++ b/lib/std/crypto/Certificate/Bundle.zig
@@ -212,7 +212,7 @@ pub fn addCertsFromDir(cb: *Bundle, gpa: Allocator, io: Io, now: Io.Timestamp, i
     }
 }
 
-pub const AddCertsFromFilePathError = Io.File.OpenError || AddCertsFromFileError || Io.Clock.Error;
+pub const AddCertsFromFilePathError = Io.File.OpenError || AddCertsFromFileError;
 
 pub fn addCertsFromFilePathAbsolute(
     cb: *Bundle,
@@ -338,7 +338,7 @@ test "scan for OS-provided certificates" {
     var bundle: Bundle = .{};
     defer bundle.deinit(gpa);
 
-    const now = try Io.Clock.real.now(io);
+    const now = Io.Clock.real.now(io);
 
     try bundle.rescan(gpa, io, now);
 }
diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig
index a46e12ecf4846dd56c31de2444ebd3c1700f85bc..bc0e3ec0ff10c80d090ac1361f7e999684bed60e 100644
--- a/lib/std/http/Client.zig
+++ b/lib/std/http/Client.zig
@@ -1700,7 +1700,7 @@ pub fn request(
             defer client.ca_bundle_mutex.unlock(io);
 
             if (client.now == null) {
-                const now = try Io.Clock.real.now(io);
+                const now = Io.Clock.real.now(io);
                 client.now = now;
                 client.ca_bundle.rescan(client.allocator, io, now) catch
                     return error.CertificateBundleLoadFailure;
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 501ba44557b4a817d7de516795bd4ee4d3361c24..4539aaff4e3aaf9df611d7a7da04b5557438394e 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1914,21 +1914,21 @@ fn init_vdso_clock_gettime(clk: clockid_t, ts: *timespec) callconv(.c) usize {
     @atomicStore(?VdsoClockGettime, &vdso_clock_gettime, ptr, .monotonic);
     // Call into the VDSO if available
     if (ptr) |f| return f(clk, ts);
-    return @as(usize, @bitCast(-@as(isize, @intFromEnum(E.NOSYS))));
+    return @bitCast(-@as(isize, @intFromEnum(E.NOSYS)));
 }
 
-pub fn clock_getres(clk_id: i32, tp: *timespec) usize {
+pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize {
     return syscall2(
         if (@hasField(SYS, "clock_getres") and native_arch != .hexagon) .clock_getres else .clock_getres_time64,
-        @as(usize, @bitCast(@as(isize, clk_id))),
+        @as(usize, @intFromEnum(clk_id)),
         @intFromPtr(tp),
     );
 }
 
-pub fn clock_settime(clk_id: i32, tp: *const timespec) usize {
+pub fn clock_settime(clk_id: clockid_t, tp: *const timespec) usize {
     return syscall2(
         if (@hasField(SYS, "clock_settime") and native_arch != .hexagon) .clock_settime else .clock_settime64,
-        @as(usize, @bitCast(@as(isize, clk_id))),
+        @as(usize, @intFromEnum(clk_id)),
         @intFromPtr(tp),
     );
 }
diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig
index 644b9b7c77c2666a0493a84eab6cc6b8065b4e2d..240a60c2e7a59b555bd2954e2c6b07e1239db4e9 100644
--- a/lib/std/os/linux/IoUring/test.zig
+++ b/lib/std/os/linux/IoUring/test.zig
@@ -620,12 +620,12 @@ test "timeout (after a relative time)" {
     const margin = 5;
     const ts: linux.kernel_timespec = .{ .sec = 0, .nsec = ms * 1000000 };
 
-    const started = try std.Io.Clock.awake.now(io);
+    const started = std.Io.Clock.awake.now(io);
     const sqe = try ring.timeout(0x55555555, &ts, 0, 0);
     try testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe.opcode);
     try testing.expectEqual(@as(u32, 1), try ring.submit());
     const cqe = try ring.copy_cqe();
-    const stopped = try std.Io.Clock.awake.now(io);
+    const stopped = std.Io.Clock.awake.now(io);
 
     try testing.expectEqual(linux.io_uring_cqe{
         .user_data = 0x55555555,
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index 7c03e7953b5be7a4eba881adb33fd6a71310fa01..1742325026ed269ef38c78ddb61d80ec750e8390 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -864,58 +864,6 @@ pub fn dl_iterate_phdr(
     }
 }
 
-pub const ClockGetTimeError = error{UnsupportedClock} || UnexpectedError;
-
-pub fn clock_gettime(clock_id: clockid_t) ClockGetTimeError!timespec {
-    var tp: timespec = undefined;
-
-    if (native_os == .windows) {
-        @compileError("Windows does not support POSIX; use Windows-specific API or cross-platform std.time API");
-    } else if (native_os == .wasi and !builtin.link_libc) {
-        var ts: timestamp_t = undefined;
-        switch (system.clock_time_get(clock_id, 1, &ts)) {
-            .SUCCESS => {
-                tp = .{
-                    .sec = @intCast(ts / std.time.ns_per_s),
-                    .nsec = @intCast(ts % std.time.ns_per_s),
-                };
-            },
-            .INVAL => return error.UnsupportedClock,
-            else => |err| return unexpectedErrno(err),
-        }
-        return tp;
-    }
-
-    switch (errno(system.clock_gettime(clock_id, &tp))) {
-        .SUCCESS => return tp,
-        .FAULT => unreachable,
-        .INVAL => return error.UnsupportedClock,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
-pub fn clock_getres(clock_id: clockid_t, res: *timespec) ClockGetTimeError!void {
-    if (native_os == .wasi and !builtin.link_libc) {
-        var ts: timestamp_t = undefined;
-        switch (system.clock_res_get(@bitCast(clock_id), &ts)) {
-            .SUCCESS => res.* = .{
-                .sec = @intCast(ts / std.time.ns_per_s),
-                .nsec = @intCast(ts % std.time.ns_per_s),
-            },
-            .INVAL => return error.UnsupportedClock,
-            else => |err| return unexpectedErrno(err),
-        }
-        return;
-    }
-
-    switch (errno(system.clock_getres(clock_id, res))) {
-        .SUCCESS => return,
-        .FAULT => unreachable,
-        .INVAL => return error.UnsupportedClock,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
 pub const SchedGetAffinityError = error{PermissionDenied} || UnexpectedError;
 
 pub fn sched_getaffinity(pid: pid_t) SchedGetAffinityError!cpu_set_t {
diff --git a/lib/std/time.zig b/lib/std/time.zig
index c47a3121a7bbff32875e274abf7d23510d32b482..562d2042c7a7afc26cf4441600ca49abe183371b 100644
--- a/lib/std/time.zig
+++ b/lib/std/time.zig
@@ -1,11 +1,3 @@
-const std = @import("std.zig");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-const testing = std.testing;
-const math = std.math;
-const windows = std.os.windows;
-const posix = std.posix;
-
 pub const epoch = @import("time/epoch.zig");
 
 // Divisions of a nanosecond.
@@ -38,180 +30,6 @@ pub const s_per_hour = s_per_min * 60;
 pub const s_per_day = s_per_hour * 24;
 pub const s_per_week = s_per_day * 7;
 
-/// An Instant represents a timestamp with respect to the currently
-/// executing program that ticks during suspend and can be used to
-/// record elapsed time unlike `nanoTimestamp`.
-///
-/// It tries to sample the system's fastest and most precise timer available.
-/// It also tries to be monotonic, but this is not a guarantee due to OS/hardware bugs.
-/// If you need monotonic readings for elapsed time, consider `Timer` instead.
-pub const Instant = struct {
-    timestamp: if (is_posix) posix.timespec else u64,
-
-    // true if we should use clock_gettime()
-    const is_posix = switch (builtin.os.tag) {
-        .windows, .uefi, .wasi => false,
-        else => true,
-    };
-
-    /// Queries the system for the current moment of time as an Instant.
-    /// This is not guaranteed to be monotonic or steadily increasing, but for
-    /// most implementations it is.
-    /// Returns `error.Unsupported` when a suitable clock is not detected.
-    pub fn now() error{Unsupported}!Instant {
-        const clock_id = switch (builtin.os.tag) {
-            .windows => {
-                // QPC on windows doesn't fail on >= XP/2000 and includes time suspended.
-                return .{ .timestamp = windows.QueryPerformanceCounter() };
-            },
-            .wasi => {
-                var ns: std.os.wasi.timestamp_t = undefined;
-                const rc = std.os.wasi.clock_time_get(.MONOTONIC, 1, &ns);
-                if (rc != .SUCCESS) return error.Unsupported;
-                return .{ .timestamp = ns };
-            },
-            .uefi => {
-                const value, _ = std.os.uefi.system_table.runtime_services.getTime() catch return error.Unsupported;
-                return .{ .timestamp = value.toEpoch() };
-            },
-            // On darwin, use UPTIME_RAW instead of MONOTONIC as it ticks while
-            // suspended.
-            .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => posix.CLOCK.UPTIME_RAW,
-            // On freebsd derivatives, use MONOTONIC_FAST as currently there's
-            // no precision tradeoff.
-            .freebsd, .dragonfly => posix.CLOCK.MONOTONIC_FAST,
-            // On linux, use BOOTTIME instead of MONOTONIC as it ticks while
-            // suspended.
-            .linux => posix.CLOCK.BOOTTIME,
-            // On other posix systems, MONOTONIC is generally the fastest and
-            // ticks while suspended.
-            else => posix.CLOCK.MONOTONIC,
-        };
-
-        const ts = posix.clock_gettime(clock_id) catch return error.Unsupported;
-        return .{ .timestamp = ts };
-    }
-
-    /// Quickly compares two instances between each other.
-    pub fn order(self: Instant, other: Instant) std.math.Order {
-        // windows and wasi timestamps are in u64 which is easily comparible
-        if (!is_posix) {
-            return std.math.order(self.timestamp, other.timestamp);
-        }
-
-        var ord = std.math.order(self.timestamp.sec, other.timestamp.sec);
-        if (ord == .eq) {
-            ord = std.math.order(self.timestamp.nsec, other.timestamp.nsec);
-        }
-        return ord;
-    }
-
-    /// Returns elapsed time in nanoseconds since the `earlier` Instant.
-    /// This assumes that the `earlier` Instant represents a moment in time before or equal to `self`.
-    /// This also assumes that the time that has passed between both Instants fits inside a u64 (~585 yrs).
-    pub fn since(self: Instant, earlier: Instant) u64 {
-        switch (builtin.os.tag) {
-            .windows => {
-                // We don't need to cache QPF as it's internally just a memory read to KUSER_SHARED_DATA
-                // (a read-only page of info updated and mapped by the kernel to all processes):
-                // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntddk-kuser_shared_data
-                // https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntexapi_x/kuser_shared_data/index.htm
-                const qpc = self.timestamp - earlier.timestamp;
-                const qpf = windows.QueryPerformanceFrequency();
-
-                // 10Mhz (1 qpc tick every 100ns) is a common enough QPF value that we can optimize on it.
-                // https://github.com/microsoft/STL/blob/785143a0c73f030238ef618890fd4d6ae2b3a3a0/stl/inc/chrono#L694-L701
-                const common_qpf = 10_000_000;
-                if (qpf == common_qpf) {
-                    return qpc * (ns_per_s / common_qpf);
-                }
-
-                // Convert to ns using fixed point.
-                const scale = @as(u64, std.time.ns_per_s << 32) / @as(u32, @intCast(qpf));
-                const result = (@as(u96, qpc) * scale) >> 32;
-                return @as(u64, @truncate(result));
-            },
-            .uefi, .wasi => {
-                // UEFI and WASI timestamps are directly in nanoseconds
-                return self.timestamp - earlier.timestamp;
-            },
-            else => {
-                // Convert timespec diff to ns
-                const seconds = @as(u64, @intCast(self.timestamp.sec - earlier.timestamp.sec));
-                const elapsed = (seconds * ns_per_s) + @as(u32, @intCast(self.timestamp.nsec));
-                return elapsed - @as(u32, @intCast(earlier.timestamp.nsec));
-            },
-        }
-    }
-};
-
-/// A monotonic, high performance timer.
-///
-/// Timer.start() is used to initialize the timer
-/// and gives the caller an opportunity to check for the existence of a supported clock.
-/// Once a supported clock is discovered,
-/// it is assumed that it will be available for the duration of the Timer's use.
-///
-/// Monotonicity is ensured by saturating on the most previous sample.
-/// This means that while timings reported are monotonic,
-/// they're not guaranteed to tick at a steady rate as this is up to the underlying system.
-pub const Timer = struct {
-    started: Instant,
-    previous: Instant,
-
-    pub const Error = error{TimerUnsupported};
-
-    /// Initialize the timer by querying for a supported clock.
-    /// Returns `error.TimerUnsupported` when such a clock is unavailable.
-    /// This should only fail in hostile environments such as linux seccomp misuse.
-    pub fn start() Error!Timer {
-        const current = Instant.now() catch return error.TimerUnsupported;
-        return Timer{ .started = current, .previous = current };
-    }
-
-    /// Reads the timer value since start or the last reset in nanoseconds.
-    pub fn read(self: *Timer) u64 {
-        const current = self.sample();
-        return current.since(self.started);
-    }
-
-    /// Resets the timer value to 0/now.
-    pub fn reset(self: *Timer) void {
-        const current = self.sample();
-        self.started = current;
-    }
-
-    /// Returns the current value of the timer in nanoseconds, then resets it.
-    pub fn lap(self: *Timer) u64 {
-        const current = self.sample();
-        defer self.started = current;
-        return current.since(self.started);
-    }
-
-    /// Returns an Instant sampled at the callsite that is
-    /// guaranteed to be monotonic with respect to the timer's starting point.
-    fn sample(self: *Timer) Instant {
-        const current = Instant.now() catch unreachable;
-        if (current.order(self.previous) == .gt) {
-            self.previous = current;
-        }
-        return self.previous;
-    }
-};
-
-test Timer {
-    const io = std.testing.io;
-
-    var timer = try Timer.start();
-
-    try std.Io.Clock.Duration.sleep(.{ .clock = .awake, .raw = .fromMilliseconds(10) }, io);
-    const time_0 = timer.read();
-    try testing.expect(time_0 > 0);
-
-    const time_1 = timer.lap();
-    try testing.expect(time_1 >= time_0);
-}
-
 test {
     _ = epoch;
 }
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 6b6021ab3c5e51351dd99a3e1e5b73a1ee18b33c..4f671b71b944886940d74f1dd6639b76b28e1aaf 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -331,48 +331,42 @@ const QueuedJobs = struct {
 pub const Timer = union(enum) {
     unused,
     active: struct {
-        start: std.time.Instant,
+        start: Io.Timestamp,
         saved_ns: u64,
     },
     paused: u64,
     stopped,
 
-    pub fn pause(t: *Timer) void {
+    pub fn pause(t: *Timer, io: Io) void {
         switch (t.*) {
             .unused => return,
             .active => |a| {
-                const current = std.time.Instant.now() catch unreachable;
-                const new_ns = switch (current.order(a.start)) {
-                    .lt, .eq => 0,
-                    .gt => current.since(a.start),
-                };
+                const current: Io.Timestamp = .now(io, .awake);
+                const new_ns: u64 = @intCast(current.nanoseconds -| a.start.nanoseconds);
                 t.* = .{ .paused = a.saved_ns + new_ns };
             },
             .paused => unreachable,
             .stopped => unreachable,
         }
     }
-    pub fn @"resume"(t: *Timer) void {
+    pub fn @"resume"(t: *Timer, io: Io) void {
         switch (t.*) {
             .unused => return,
             .active => unreachable,
             .paused => |saved_ns| t.* = .{ .active = .{
-                .start = std.time.Instant.now() catch unreachable,
+                .start = .now(io, .awake),
                 .saved_ns = saved_ns,
             } },
             .stopped => unreachable,
         }
     }
-    pub fn finish(t: *Timer) ?u64 {
+    pub fn finish(t: *Timer, io: Io) ?u64 {
         defer t.* = .stopped;
         switch (t.*) {
             .unused => return null,
             .active => |a| {
-                const current = std.time.Instant.now() catch unreachable;
-                const new_ns = switch (current.order(a.start)) {
-                    .lt, .eq => 0,
-                    .gt => current.since(a.start),
-                };
+                const current: Io.Timestamp = .now(io, .awake);
+                const new_ns: u64 = @intCast(current.nanoseconds -| a.start.nanoseconds);
                 return a.saved_ns + new_ns;
             },
             .paused => |ns| return ns,
@@ -387,7 +381,8 @@ pub const Timer = union(enum) {
 /// is set.
 pub fn startTimer(comp: *Compilation) Timer {
     if (comp.time_report == null) return .unused;
-    const now = std.time.Instant.now() catch @panic("std.time.Timer unsupported; cannot emit time report");
+    const io = comp.io;
+    const now: Io.Timestamp = .now(io, .awake);
     return .{ .active = .{
         .start = now,
         .saved_ns = 0,
@@ -3408,7 +3403,7 @@ fn flush(comp: *Compilation, arena: Allocator, tid: Zcu.PerThread.Id) (Io.Cancel
             defer sub_prog_node.end();
 
             var timer = comp.startTimer();
-            defer if (timer.finish()) |ns| {
+            defer if (timer.finish(io)) |ns| {
                 comp.mutex.lockUncancelable(io);
                 defer comp.mutex.unlock(io);
                 comp.time_report.?.stats.real_ns_llvm_emit = ns;
@@ -3453,7 +3448,7 @@ fn flush(comp: *Compilation, arena: Allocator, tid: Zcu.PerThread.Id) (Io.Cancel
     }
     if (comp.bin_file) |lf| {
         var timer = comp.startTimer();
-        defer if (timer.finish()) |ns| {
+        defer if (timer.finish(io)) |ns| {
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
             comp.time_report.?.stats.real_ns_link_flush = ns;
@@ -4686,7 +4681,7 @@ fn performAllTheWork(
     var decl_work_timer: ?Timer = null;
     defer commit_timer: {
         const t = &(decl_work_timer orelse break :commit_timer);
-        const ns = t.finish() orelse break :commit_timer;
+        const ns = t.finish(io) orelse break :commit_timer;
         comp.mutex.lockUncancelable(io);
         defer comp.mutex.unlock(io);
         comp.time_report.?.stats.real_ns_decls = ns;
@@ -4719,7 +4714,7 @@ fn performAllTheWork(
         defer zir_prog_node.end();
 
         var timer = comp.startTimer();
-        defer if (timer.finish()) |ns| {
+        defer if (timer.finish(io)) |ns| {
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
             comp.time_report.?.stats.real_ns_files = ns;
diff --git a/src/Zcu.zig b/src/Zcu.zig
index ceccc2c192cd8a8fef9248179b82535476d34cf3..6a2872eae8fa3c0d3ce1beed7a29c1b080c4d1b2 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4754,6 +4754,7 @@ const TrackedUnitSema = struct {
     analysis_timer_decl: ?InternPool.TrackedInst.Index,
     pub fn end(tus: TrackedUnitSema, zcu: *Zcu) void {
         const comp = zcu.comp;
+        const io = comp.io;
         if (tus.old_name) |old_name| {
             zcu.sema_prog_node.completeOne(); // we're just renaming, but it's effectively completion
             zcu.cur_sema_prog_node.setName(&old_name);
@@ -4762,9 +4763,8 @@ const TrackedUnitSema = struct {
             zcu.cur_sema_prog_node = .none;
         }
         report_time: {
-            const sema_ns = zcu.cur_analysis_timer.?.finish() orelse break :report_time;
+            const sema_ns = zcu.cur_analysis_timer.?.finish(io) orelse break :report_time;
             const zir_decl = tus.analysis_timer_decl orelse break :report_time;
-            const io = comp.io;
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
             comp.time_report.?.stats.cpu_ns_sema += sema_ns;
@@ -4779,11 +4779,13 @@ const TrackedUnitSema = struct {
             gop.value_ptr.count += 1;
         }
         zcu.cur_analysis_timer = tus.old_analysis_timer;
-        if (zcu.cur_analysis_timer) |*t| t.@"resume"();
+        if (zcu.cur_analysis_timer) |*t| t.@"resume"(io);
     }
 };
 pub fn trackUnitSema(zcu: *Zcu, name: []const u8, zir_inst: ?InternPool.TrackedInst.Index) TrackedUnitSema {
-    if (zcu.cur_analysis_timer) |*t| t.pause();
+    const comp = zcu.comp;
+    const io = comp.io;
+    if (zcu.cur_analysis_timer) |*t| t.pause(io);
     const old_analysis_timer = zcu.cur_analysis_timer;
     zcu.cur_analysis_timer = zcu.comp.startTimer();
     const old_name: ?[std.Progress.Node.max_name_len]u8 = old_name: {
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 950a3e5a19f5c08524df7087aa201f54e4f05400..56b09d9da1110eaf2491bff1ff03e7b5e6b50c53 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -263,7 +263,7 @@ pub fn updateFile(
         var timer = comp.startTimer();
         // Any potential AST errors are converted to ZIR errors when we run AstGen/ZonGen.
         file.tree = try Ast.parse(gpa, source, file.getMode());
-        if (timer.finish()) |ns_parse| {
+        if (timer.finish(io)) |ns_parse| {
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
             comp.time_report.?.stats.cpu_ns_parse += ns_parse;
@@ -295,7 +295,7 @@ pub fn updateFile(
             else => |e| return e,
         };
 
-        if (timer.finish()) |ns_astgen| {
+        if (timer.finish(io)) |ns_astgen| {
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
             comp.time_report.?.stats.cpu_ns_astgen += ns_astgen;
@@ -4485,7 +4485,7 @@ pub fn runCodegen(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air) Ru
 
     const codegen_result = runCodegenInner(pt, func_index, air);
 
-    if (timer.finish()) |ns_codegen| report_time: {
+    if (timer.finish(io)) |ns_codegen| report_time: {
         const ip = &zcu.intern_pool;
         const nav = ip.indexToKey(func_index).func.owner_nav;
         const zir_decl = ip.getNav(nav).srcInst(ip);
diff --git a/src/link.zig b/src/link.zig
index 3af768a363733e5b2dc25e8f46412c601b2e05a0..c8e46540bac608301ee75b5c315b5c9b2ac05b72 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -1388,7 +1388,7 @@ pub fn doPrelinkTask(comp: *Compilation, task: PrelinkTask) void {
     };
 
     var timer = comp.startTimer();
-    defer if (timer.finish()) |ns| {
+    defer if (timer.finish(io)) |ns| {
         comp.mutex.lockUncancelable(io);
         defer comp.mutex.unlock(io);
         comp.time_report.?.stats.cpu_ns_link += ns;
@@ -1535,12 +1535,12 @@ pub fn doZcuTask(comp: *Compilation, tid: usize, task: ZcuTask) void {
             break :nav nav_index;
         },
         .link_func => |codegen_task| nav: {
-            timer.pause();
+            timer.pause(io);
             const func, var mir = codegen_task.wait(&zcu.codegen_task_pool, io) catch |err| switch (err) {
                 error.Canceled, error.AlreadyReported => return,
             };
             defer mir.deinit(zcu);
-            timer.@"resume"();
+            timer.@"resume"(io);
 
             const nav = zcu.funcInfo(func).owner_nav;
             const fqn_slice = ip.getNav(nav).fqn.toSlice(ip);
@@ -1592,7 +1592,7 @@ pub fn doZcuTask(comp: *Compilation, tid: usize, task: ZcuTask) void {
         },
     };
 
-    if (timer.finish()) |ns_link| report_time: {
+    if (timer.finish(io)) |ns_link| report_time: {
         comp.mutex.lockUncancelable(io);
         defer comp.mutex.unlock(io);
         const tr = &zcu.comp.time_report.?;
-- 
2.54.0


From 11476d83c9218ad2b22ab59b2fee3a4a4bf36367 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Feb 2026 22:32:48 -0800
Subject: [PATCH 179/499] stage1: add wasi_snapshot_preview1_clock_res_get to
 wasi.c

---
 stage1/wasi.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/stage1/wasi.c b/stage1/wasi.c
index e4772735d9ada66cc977d7c681a4930faebc203e..3be4bd00248a7da45f643c070fa3576970024798 100644
--- a/stage1/wasi.c
+++ b/stage1/wasi.c
@@ -924,6 +924,15 @@ uint32_t wasi_snapshot_preview1_clock_time_get(uint32_t id, uint64_t precision,
     return wasi_errno_success;
 }
 
+uint32_t wasi_snapshot_preview1_clock_res_get(uint32_t id, uint32_t res_timestamp) {
+    uint8_t *const m = *wasm_memory;
+    uint64_t *res_timestamp_ptr = (uint64_t *)&m[res_timestamp];
+#if LOG_TRACE
+    fprintf(stderr, "wasi_snapshot_preview1_clock_res_get(%u, %llu)\n", id, (unsigned long long)res_timestamp);
+#endif
+    return wasi_errno_notcapable;
+}
+
 uint32_t wasi_snapshot_preview1_path_remove_directory(uint32_t fd, uint32_t path, uint32_t path_len) {
     uint8_t *const m = *wasm_memory;
     const char *path_ptr = (const char *)&m[path];
-- 
2.54.0


From fe5da36aa3b1dbeb02276c6628640c68a5922191 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Feb 2026 01:02:48 -0800
Subject: [PATCH 180/499] std.Io make Clock.resolution fallible

---
 lib/std/Io.zig          | 9 +++++++--
 lib/std/Io/Threaded.zig | 4 ++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 09da9b533acdcfa58bc443992015c646660ee141..92327e0f5d16f0e83cd3cfabe0c86f463a68f03c 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -232,7 +232,7 @@ pub const VTable = struct {
     progressParentFile: *const fn (?*anyopaque) std.Progress.ParentFileError!File,
 
     now: *const fn (?*anyopaque, Clock) Timestamp,
-    clockResolution: *const fn (?*anyopaque, Clock) Duration,
+    clockResolution: *const fn (?*anyopaque, Clock) Clock.ResolutionError!Duration,
     sleep: *const fn (?*anyopaque, Timeout) Cancelable!void,
 
     random: *const fn (?*anyopaque, buffer: []u8) void,
@@ -713,9 +713,14 @@ pub const Clock = enum {
         return io.vtable.now(io.userdata, clock);
     }
 
+    pub const ResolutionError = error{
+        ClockUnavailable,
+        Unexpected,
+    };
+
     /// Reveals the granularity of `clock`. May be zero, indicating
     /// unsupported clock.
-    pub fn resolution(clock: Clock, io: Io) Io.Duration {
+    pub fn resolution(clock: Clock, io: Io) ResolutionError!Io.Duration {
         return io.vtable.clockResolution(io.userdata, clock);
     }
 
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 2cd350f58c9efcddba6f9bb9704fbaa21de0644e..6255d96978405cc0d1b1fc4908644facea0ef4b0 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -10833,7 +10833,7 @@ fn nowInner(clock: Io.Clock) Io.Timestamp {
     };
 }
 
-fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Duration {
+fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
     return switch (native_os) {
@@ -10872,7 +10872,7 @@ fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Duration {
     };
 }
 
-fn clockResolutionPosix(clock: Io.Clock) Io.Duration {
+fn clockResolutionPosix(clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
     const clock_id: posix.clockid_t = clockToPosix(clock);
     var timespec: posix.timespec = undefined;
     return switch (posix.errno(posix.system.clock_getres(clock_id, &timespec))) {
-- 
2.54.0


From 02599bccb5c0b75e6dcdf950fa2dc1ece40c19f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 3 Feb 2026 13:31:24 +0100
Subject: [PATCH 181/499] build: bump test-libc max_rss to 3_500_000_000

error: memory usage peaked at 3.11GB (3105054720 bytes), exceeding the declared upper bound of 2.90GB (2900000000 bytes)
---
 build.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.zig b/build.zig
index 84cbba38bdb6026dc3691463ac40d1fcad33419e..8006715735ab97eb3d2b216c5688e6e8a85de356 100644
--- a/build.zig
+++ b/build.zig
@@ -681,7 +681,7 @@ pub fn build(b: *std.Build) !void {
         .test_filters = test_filters,
         .test_target_filters = test_target_filters,
         .skip_wasm = skip_wasm,
-        .max_rss = 2_496_066_355,
+        .max_rss = 3_500_000_000,
     })) |test_libc_step| test_step.dependOn(test_libc_step);
 }
 
-- 
2.54.0


From 6ce0dd1a81d52e5e2e331e88628c89e989dc15ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 18 Dec 2025 14:26:11 +0100
Subject: [PATCH 182/499] ci: run test-libc on x86_64-linux-debug-llvm and
 x86_64-linux-release

---
 ci/x86_64-linux-debug-llvm.sh | 1 +
 ci/x86_64-linux-release.sh    | 1 +
 2 files changed, 2 insertions(+)

diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index 6ef1b5a00939d8adfb1e2c52f555ce6593c03a25..26d3911c135b0bdbf91ae0004788349e1cdc998b 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -54,6 +54,7 @@ stage3-debug/bin/zig build \
 stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dlldb=$HOME/deps/lldb-zig/Debug-e0a42bb34/bin/lldb \
+  -Dlibc-test-path=$HOME/deps/libc-test-f2bac77 \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 99781406e273ffd10dccbe3e2f20d3fdda08b55c..94e6e93bbdc0f9fd5146c300624efb3f16a222c0 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -59,6 +59,7 @@ stage3-release/bin/zig build \
 stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dlldb=$HOME/deps/lldb-zig/Release-e0a42bb34/bin/lldb \
+  -Dlibc-test-path=$HOME/deps/libc-test-f2bac77 \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
-- 
2.54.0


From 7aae7dd3f4d4b85837369fa591e566ae812f87dc Mon Sep 17 00:00:00 2001
From: Ivel <ivel.santos@proton.me>
Date: Tue, 3 Feb 2026 00:53:58 -0300
Subject: [PATCH 183/499] libzigc: pow

---
 lib/c/math.zig               |   5 +
 lib/libc/musl/src/math/pow.c | 343 -----------------------------------
 src/libs/musl.zig            |   1 -
 src/libs/wasi_libc.zig       |   1 -
 4 files changed, 5 insertions(+), 345 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/pow.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 3811142769073deb3c2b9b1deba3c3f583b25a1f..8fc7c0322878b7b6862392abe3158a05b7adda11 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -41,6 +41,7 @@ comptime {
         @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
         @export(&cbrt, .{ .name = "cbrt", .linkage = common.linkage, .visibility = common.visibility });
         @export(&cbrtf, .{ .name = "cbrtf", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&pow, .{ .name = "pow", .linkage = common.linkage, .visibility = common.visibility });
     }
 
     if (builtin.target.isMuslLibC()) {
@@ -116,3 +117,7 @@ fn cbrt(x: f64) callconv(.c) f64 {
 fn cbrtf(x: f32) callconv(.c) f32 {
     return math.cbrt(x);
 }
+
+fn pow(x: f64, y: f64) callconv(.c) f64 {
+    return math.pow(f64, x, y);
+}
diff --git a/lib/libc/musl/src/math/pow.c b/lib/libc/musl/src/math/pow.c
deleted file mode 100644
index 694c2ef64d008cf78696a6d660353e83792d22f3..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/pow.c
+++ /dev/null
@@ -1,343 +0,0 @@
-/*
- * Double-precision x^y function.
- *
- * Copyright (c) 2018, Arm Limited.
- * SPDX-License-Identifier: MIT
- */
-
-#include <math.h>
-#include <stdint.h>
-#include "libm.h"
-#include "exp_data.h"
-#include "pow_data.h"
-
-/*
-Worst-case error: 0.54 ULP (~= ulperr_exp + 1024*Ln2*relerr_log*2^53)
-relerr_log: 1.3 * 2^-68 (Relative error of log, 1.5 * 2^-68 without fma)
-ulperr_exp: 0.509 ULP (ULP error of exp, 0.511 ULP without fma)
-*/
-
-#define T __pow_log_data.tab
-#define A __pow_log_data.poly
-#define Ln2hi __pow_log_data.ln2hi
-#define Ln2lo __pow_log_data.ln2lo
-#define N (1 << POW_LOG_TABLE_BITS)
-#define OFF 0x3fe6955500000000
-
-/* Top 12 bits of a double (sign and exponent bits).  */
-static inline uint32_t top12(double x)
-{
-	return asuint64(x) >> 52;
-}
-
-/* Compute y+TAIL = log(x) where the rounded result is y and TAIL has about
-   additional 15 bits precision.  IX is the bit representation of x, but
-   normalized in the subnormal range using the sign bit for the exponent.  */
-static inline double_t log_inline(uint64_t ix, double_t *tail)
-{
-	/* double_t for better performance on targets with FLT_EVAL_METHOD==2.  */
-	double_t z, r, y, invc, logc, logctail, kd, hi, t1, t2, lo, lo1, lo2, p;
-	uint64_t iz, tmp;
-	int k, i;
-
-	/* x = 2^k z; where z is in range [OFF,2*OFF) and exact.
-	   The range is split into N subintervals.
-	   The ith subinterval contains z and c is near its center.  */
-	tmp = ix - OFF;
-	i = (tmp >> (52 - POW_LOG_TABLE_BITS)) % N;
-	k = (int64_t)tmp >> 52; /* arithmetic shift */
-	iz = ix - (tmp & 0xfffULL << 52);
-	z = asdouble(iz);
-	kd = (double_t)k;
-
-	/* log(x) = k*Ln2 + log(c) + log1p(z/c-1).  */
-	invc = T[i].invc;
-	logc = T[i].logc;
-	logctail = T[i].logctail;
-
-	/* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and
-     |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.  */
-#if __FP_FAST_FMA
-	r = __builtin_fma(z, invc, -1.0);
-#else
-	/* Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.  */
-	double_t zhi = asdouble((iz + (1ULL << 31)) & (-1ULL << 32));
-	double_t zlo = z - zhi;
-	double_t rhi = zhi * invc - 1.0;
-	double_t rlo = zlo * invc;
-	r = rhi + rlo;
-#endif
-
-	/* k*Ln2 + log(c) + r.  */
-	t1 = kd * Ln2hi + logc;
-	t2 = t1 + r;
-	lo1 = kd * Ln2lo + logctail;
-	lo2 = t1 - t2 + r;
-
-	/* Evaluation is optimized assuming superscalar pipelined execution.  */
-	double_t ar, ar2, ar3, lo3, lo4;
-	ar = A[0] * r; /* A[0] = -0.5.  */
-	ar2 = r * ar;
-	ar3 = r * ar2;
-	/* k*Ln2 + log(c) + r + A[0]*r*r.  */
-#if __FP_FAST_FMA
-	hi = t2 + ar2;
-	lo3 = __builtin_fma(ar, r, -ar2);
-	lo4 = t2 - hi + ar2;
-#else
-	double_t arhi = A[0] * rhi;
-	double_t arhi2 = rhi * arhi;
-	hi = t2 + arhi2;
-	lo3 = rlo * (ar + arhi);
-	lo4 = t2 - hi + arhi2;
-#endif
-	/* p = log1p(r) - r - A[0]*r*r.  */
-	p = (ar3 * (A[1] + r * A[2] +
-		    ar2 * (A[3] + r * A[4] + ar2 * (A[5] + r * A[6]))));
-	lo = lo1 + lo2 + lo3 + lo4 + p;
-	y = hi + lo;
-	*tail = hi - y + lo;
-	return y;
-}
-
-#undef N
-#undef T
-#define N (1 << EXP_TABLE_BITS)
-#define InvLn2N __exp_data.invln2N
-#define NegLn2hiN __exp_data.negln2hiN
-#define NegLn2loN __exp_data.negln2loN
-#define Shift __exp_data.shift
-#define T __exp_data.tab
-#define C2 __exp_data.poly[5 - EXP_POLY_ORDER]
-#define C3 __exp_data.poly[6 - EXP_POLY_ORDER]
-#define C4 __exp_data.poly[7 - EXP_POLY_ORDER]
-#define C5 __exp_data.poly[8 - EXP_POLY_ORDER]
-#define C6 __exp_data.poly[9 - EXP_POLY_ORDER]
-
-/* Handle cases that may overflow or underflow when computing the result that
-   is scale*(1+TMP) without intermediate rounding.  The bit representation of
-   scale is in SBITS, however it has a computed exponent that may have
-   overflown into the sign bit so that needs to be adjusted before using it as
-   a double.  (int32_t)KI is the k used in the argument reduction and exponent
-   adjustment of scale, positive k here means the result may overflow and
-   negative k means the result may underflow.  */
-static inline double specialcase(double_t tmp, uint64_t sbits, uint64_t ki)
-{
-	double_t scale, y;
-
-	if ((ki & 0x80000000) == 0) {
-		/* k > 0, the exponent of scale might have overflowed by <= 460.  */
-		sbits -= 1009ull << 52;
-		scale = asdouble(sbits);
-		y = 0x1p1009 * (scale + scale * tmp);
-		return eval_as_double(y);
-	}
-	/* k < 0, need special care in the subnormal range.  */
-	sbits += 1022ull << 52;
-	/* Note: sbits is signed scale.  */
-	scale = asdouble(sbits);
-	y = scale + scale * tmp;
-	if (fabs(y) < 1.0) {
-		/* Round y to the right precision before scaling it into the subnormal
-		   range to avoid double rounding that can cause 0.5+E/2 ulp error where
-		   E is the worst-case ulp error outside the subnormal range.  So this
-		   is only useful if the goal is better than 1 ulp worst-case error.  */
-		double_t hi, lo, one = 1.0;
-		if (y < 0.0)
-			one = -1.0;
-		lo = scale - y + scale * tmp;
-		hi = one + y;
-		lo = one - hi + y + lo;
-		y = eval_as_double(hi + lo) - one;
-		/* Fix the sign of 0.  */
-		if (y == 0.0)
-			y = asdouble(sbits & 0x8000000000000000);
-		/* The underflow exception needs to be signaled explicitly.  */
-		fp_force_eval(fp_barrier(0x1p-1022) * 0x1p-1022);
-	}
-	y = 0x1p-1022 * y;
-	return eval_as_double(y);
-}
-
-#define SIGN_BIAS (0x800 << EXP_TABLE_BITS)
-
-/* Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.
-   The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.  */
-static inline double exp_inline(double_t x, double_t xtail, uint32_t sign_bias)
-{
-	uint32_t abstop;
-	uint64_t ki, idx, top, sbits;
-	/* double_t for better performance on targets with FLT_EVAL_METHOD==2.  */
-	double_t kd, z, r, r2, scale, tail, tmp;
-
-	abstop = top12(x) & 0x7ff;
-	if (predict_false(abstop - top12(0x1p-54) >=
-			  top12(512.0) - top12(0x1p-54))) {
-		if (abstop - top12(0x1p-54) >= 0x80000000) {
-			/* Avoid spurious underflow for tiny x.  */
-			/* Note: 0 is common input.  */
-			double_t one = WANT_ROUNDING ? 1.0 + x : 1.0;
-			return sign_bias ? -one : one;
-		}
-		if (abstop >= top12(1024.0)) {
-			/* Note: inf and nan are already handled.  */
-			if (asuint64(x) >> 63)
-				return __math_uflow(sign_bias);
-			else
-				return __math_oflow(sign_bias);
-		}
-		/* Large x is special cased below.  */
-		abstop = 0;
-	}
-
-	/* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].  */
-	/* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].  */
-	z = InvLn2N * x;
-#if TOINT_INTRINSICS
-	kd = roundtoint(z);
-	ki = converttoint(z);
-#elif EXP_USE_TOINT_NARROW
-	/* z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.  */
-	kd = eval_as_double(z + Shift);
-	ki = asuint64(kd) >> 16;
-	kd = (double_t)(int32_t)ki;
-#else
-	/* z - kd is in [-1, 1] in non-nearest rounding modes.  */
-	kd = eval_as_double(z + Shift);
-	ki = asuint64(kd);
-	kd -= Shift;
-#endif
-	r = x + kd * NegLn2hiN + kd * NegLn2loN;
-	/* The code assumes 2^-200 < |xtail| < 2^-8/N.  */
-	r += xtail;
-	/* 2^(k/N) ~= scale * (1 + tail).  */
-	idx = 2 * (ki % N);
-	top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);
-	tail = asdouble(T[idx]);
-	/* This is only a valid scale when -1023*N < k < 1024*N.  */
-	sbits = T[idx + 1] + top;
-	/* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).  */
-	/* Evaluation is optimized assuming superscalar pipelined execution.  */
-	r2 = r * r;
-	/* Without fma the worst case error is 0.25/N ulp larger.  */
-	/* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.  */
-	tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);
-	if (predict_false(abstop == 0))
-		return specialcase(tmp, sbits, ki);
-	scale = asdouble(sbits);
-	/* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there
-	   is no spurious underflow here even without fma.  */
-	return eval_as_double(scale + scale * tmp);
-}
-
-/* Returns 0 if not int, 1 if odd int, 2 if even int.  The argument is
-   the bit representation of a non-zero finite floating-point value.  */
-static inline int checkint(uint64_t iy)
-{
-	int e = iy >> 52 & 0x7ff;
-	if (e < 0x3ff)
-		return 0;
-	if (e > 0x3ff + 52)
-		return 2;
-	if (iy & ((1ULL << (0x3ff + 52 - e)) - 1))
-		return 0;
-	if (iy & (1ULL << (0x3ff + 52 - e)))
-		return 1;
-	return 2;
-}
-
-/* Returns 1 if input is the bit representation of 0, infinity or nan.  */
-static inline int zeroinfnan(uint64_t i)
-{
-	return 2 * i - 1 >= 2 * asuint64(INFINITY) - 1;
-}
-
-double pow(double x, double y)
-{
-	uint32_t sign_bias = 0;
-	uint64_t ix, iy;
-	uint32_t topx, topy;
-
-	ix = asuint64(x);
-	iy = asuint64(y);
-	topx = top12(x);
-	topy = top12(y);
-	if (predict_false(topx - 0x001 >= 0x7ff - 0x001 ||
-			  (topy & 0x7ff) - 0x3be >= 0x43e - 0x3be)) {
-		/* Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0
-		   and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.  */
-		/* Special cases: (x < 0x1p-126 or inf or nan) or
-		   (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).  */
-		if (predict_false(zeroinfnan(iy))) {
-			if (2 * iy == 0)
-				return issignaling_inline(x) ? x + y : 1.0;
-			if (ix == asuint64(1.0))
-				return issignaling_inline(y) ? x + y : 1.0;
-			if (2 * ix > 2 * asuint64(INFINITY) ||
-			    2 * iy > 2 * asuint64(INFINITY))
-				return x + y;
-			if (2 * ix == 2 * asuint64(1.0))
-				return 1.0;
-			if ((2 * ix < 2 * asuint64(1.0)) == !(iy >> 63))
-				return 0.0; /* |x|<1 && y==inf or |x|>1 && y==-inf.  */
-			return y * y;
-		}
-		if (predict_false(zeroinfnan(ix))) {
-			double_t x2 = x * x;
-			if (ix >> 63 && checkint(iy) == 1)
-				x2 = -x2;
-			/* Without the barrier some versions of clang hoist the 1/x2 and
-			   thus division by zero exception can be signaled spuriously.  */
-			return iy >> 63 ? fp_barrier(1 / x2) : x2;
-		}
-		/* Here x and y are non-zero finite.  */
-		if (ix >> 63) {
-			/* Finite x < 0.  */
-			int yint = checkint(iy);
-			if (yint == 0)
-				return __math_invalid(x);
-			if (yint == 1)
-				sign_bias = SIGN_BIAS;
-			ix &= 0x7fffffffffffffff;
-			topx &= 0x7ff;
-		}
-		if ((topy & 0x7ff) - 0x3be >= 0x43e - 0x3be) {
-			/* Note: sign_bias == 0 here because y is not odd.  */
-			if (ix == asuint64(1.0))
-				return 1.0;
-			if ((topy & 0x7ff) < 0x3be) {
-				/* |y| < 2^-65, x^y ~= 1 + y*log(x).  */
-				if (WANT_ROUNDING)
-					return ix > asuint64(1.0) ? 1.0 + y :
-								    1.0 - y;
-				else
-					return 1.0;
-			}
-			return (ix > asuint64(1.0)) == (topy < 0x800) ?
-				       __math_oflow(0) :
-				       __math_uflow(0);
-		}
-		if (topx == 0) {
-			/* Normalize subnormal x so exponent becomes negative.  */
-			ix = asuint64(x * 0x1p52);
-			ix &= 0x7fffffffffffffff;
-			ix -= 52ULL << 52;
-		}
-	}
-
-	double_t lo;
-	double_t hi = log_inline(ix, &lo);
-	double_t ehi, elo;
-#if __FP_FAST_FMA
-	ehi = y * hi;
-	elo = y * lo + __builtin_fma(y, hi, -ehi);
-#else
-	double_t yhi = asdouble(iy & -1ULL << 27);
-	double_t ylo = y - yhi;
-	double_t lhi = asdouble(asuint64(hi) & -1ULL << 27);
-	double_t llo = hi - lhi + lo;
-	ehi = yhi * lhi;
-	elo = ylo * lhi + y * llo; /* |elo| < |ehi| * 2^-25.  */
-#endif
-	return exp_inline(ehi, elo, sign_bias);
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 553be9b070a7240992df02c5dfff9b2514870e51..1974e0e4ea3765ca3de2c8f7adaedc817280dc0d 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -985,7 +985,6 @@ const src_files = [_][]const u8{
     "musl/src/math/nexttowardf.c",
     "musl/src/math/nexttowardl.c",
     "musl/src/math/__polevll.c",
-    "musl/src/math/pow.c",
     "musl/src/math/pow_data.c",
     "musl/src/math/powerpc64/fma.c",
     "musl/src/math/powerpc64/fmaf.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 5cae320e9c905dfa7bb569f0e5904b5b62f0a40c..8e0ade2a0d0f678c6a028c324f46611a644ccf92 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -794,7 +794,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/nexttowardf.c",
     "musl/src/math/nexttowardl.c",
     "musl/src/math/__polevll.c",
-    "musl/src/math/pow.c",
     "musl/src/math/pow_data.c",
     "musl/src/math/powf.c",
     "musl/src/math/powf_data.c",
-- 
2.54.0


From 2fce12b42a3662e018ad30ca874f4e7cfcdf33d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 2 Feb 2026 11:24:42 +0100
Subject: [PATCH 184/499] test: improve logic for generating stack trace test
 combinations

---
 test/src/StackTrace.zig | 50 +++++++++++++++++++++++++++++++++++------
 1 file changed, 43 insertions(+), 7 deletions(-)

diff --git a/test/src/StackTrace.zig b/test/src/StackTrace.zig
index 4e5c946682681ad47f458e67de7b7fd7c8a3dc24..ff0b145ff88e1591744b0d6de1fb75e945127d44 100644
--- a/test/src/StackTrace.zig
+++ b/test/src/StackTrace.zig
@@ -55,7 +55,7 @@ fn addCaseTarget(
         };
     };
     const both_pie = switch (target.result.os.tag) {
-        .fuchsia, .openbsd => false,
+        .fuchsia => false,
         else => true,
     };
     const both_libc = switch (target.result.os.tag) {
@@ -63,8 +63,30 @@ fn addCaseTarget(
         else => !target.result.requiresLibC(),
     };
 
-    // On aarch64-macos, FP unwinding is blessed by Apple to always be reliable, and std.debug knows this.
-    const fp_unwind_is_safe = target.result.cpu.arch == .aarch64 and target.result.os.tag.isDarwin();
+    // See `std.debug.StackIterator.fp_usability` logic.
+    const fp_usability: enum { useless, unsafe, safe, ideal } = switch (target.result.cpu.arch) {
+        .alpha,
+        .csky,
+        .microblaze,
+        .microblazeel,
+        .mips,
+        .mipsel,
+        .mips64,
+        .mips64el,
+        .sh,
+        .sheb,
+        => .useless,
+        .hexagon,
+        .powerpc,
+        .powerpcle,
+        .powerpc64,
+        .powerpc64le,
+        .sparc,
+        .sparc64,
+        => .ideal,
+        .aarch64 => if (target.result.os.tag.isDarwin()) .safe else .unsafe,
+        else => .unsafe,
+    };
     const supports_unwind_tables = switch (target.result.os.tag) {
         // x86-windows just has no way to do stack unwinding other then using frame pointers.
         .windows => target.result.cpu.arch != .x86,
@@ -86,10 +108,24 @@ fn addCaseTarget(
         const only_fp: @This() = .{ .tables = false, .fp = true };
     };
     const unwind_info_vals: []const UnwindInfo = switch (config.unwind) {
-        .none => &.{.none},
-        .any => &.{ .only_tables, .only_fp, .both },
-        .safe => if (fp_unwind_is_safe) &.{ .only_tables, .only_fp, .both } else &.{ .only_tables, .both },
-        .no_safe => if (fp_unwind_is_safe) &.{.none} else &.{ .none, .only_fp },
+        .none => switch (fp_usability) {
+            .useless => &.{ .none, .only_fp },
+            .unsafe, .safe => &.{.none},
+            .ideal => &.{},
+        },
+        .any => switch (fp_usability) {
+            .useless => &.{ .only_tables, .both },
+            .unsafe, .safe, .ideal => &.{ .only_tables, .only_fp, .both },
+        },
+        .safe => switch (fp_usability) {
+            .useless, .unsafe => &.{ .only_tables, .both },
+            .safe, .ideal => &.{ .only_tables, .only_fp, .both },
+        },
+        .no_safe => switch (fp_usability) {
+            .useless, .unsafe => &.{ .none, .only_fp },
+            .safe => &.{.none},
+            .ideal => &.{},
+        },
     };
 
     for (use_llvm_vals) |use_llvm| {
-- 
2.54.0


From e9b442db5a2b03c09f8286cab94d9ce4976bc077 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Feb 2026 06:35:13 +0100
Subject: [PATCH 185/499] llvm: fix C ABI integer promotion for more targets

Also stop pretending that this function handles _BitInt types correctly.

Handling 32-bit integers on MIPS properly is blocked on: https://github.com/llvm/llvm-project/issues/179088
---
 src/codegen/llvm.zig | 82 ++++++++++++++++++++++++++++++--------------
 1 file changed, 56 insertions(+), 26 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 26369d2ce98193f191a1d27fd96d58a569cc4fd3..a178604a6874b68dc30e69f00b7d50bc0e0bfa86 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -12600,46 +12600,76 @@ fn iterateParamTypes(object: *Object, pt: Zcu.PerThread, fn_info: InternPool.Key
     };
 }
 
+/// This function deliberately does not handle `_BitInt` because it typically
+/// has different ABI than regular integer types, and there is no currently no
+/// way to determine whether a Zig integer type is meant to represent e.g. `int`
+/// or `_BitInt(32)`.
 fn ccAbiPromoteInt(cc: std.builtin.CallingConvention, zcu: *Zcu, ty: Type) ?std.builtin.Signedness {
-    const target = zcu.getTarget();
     switch (cc) {
         .auto, .@"inline", .async => return null,
         else => {},
     }
+
     const int_info = switch (ty.zigTypeTag(zcu)) {
         .bool => Type.u1.intInfo(zcu),
         else => if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else return null,
     };
-    return switch (target.os.tag) {
-        .driverkit, .ios, .maccatalyst, .macos, .watchos, .tvos, .visionos => switch (int_info.bits) {
-            0...16 => int_info.signedness,
-            else => null,
-        },
-        else => switch (target.cpu.arch) {
-            .loongarch64, .riscv64, .riscv64be => switch (int_info.bits) {
-                0...16 => int_info.signedness,
-                32 => .signed, // LLVM always signextends 32 bit ints, unsure if bug.
-                17...31, 33...63 => int_info.signedness,
-                else => null,
-            },
+    assert(int_info.bits >= 0);
 
-            .sparc64,
-            .powerpc64,
-            .powerpc64le,
-            .s390x,
-            => switch (int_info.bits) {
-                0...63 => int_info.signedness,
+    const target = zcu.getTarget();
+    return switch (target.cpu.arch) {
+        .aarch64,
+        .aarch64_be,
+        => switch (target.os.tag) {
+            .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => switch (int_info.bits) {
+                8, 16 => int_info.signedness,
                 else => null,
             },
+            else => null,
+        },
 
-            .aarch64,
-            .aarch64_be,
-            => null,
+        .avr,
+        => switch (int_info.bits) {
+            8 => int_info.signedness,
+            else => null,
+        },
 
-            else => switch (int_info.bits) {
-                0...16 => int_info.signedness,
-                else => null,
-            },
+        .lanai,
+        => null,
+
+        .loongarch64,
+        .riscv64,
+        .riscv64be,
+        => switch (int_info.bits) {
+            8, 16 => int_info.signedness,
+            32 => .signed,
+            else => null,
+        },
+
+        .mips,
+        .mipsel,
+        .mips64,
+        .mips64el,
+        => switch (int_info.bits) {
+            8, 16, 64 => int_info.signedness,
+            // https://github.com/llvm/llvm-project/issues/179088
+            // 32 => .signed,
+            else => null,
+        },
+
+        .powerpc64,
+        .powerpc64le,
+        .s390x,
+        .sparc64,
+        .ve,
+        => switch (int_info.bits) {
+            8, 16, 32 => int_info.signedness,
+            else => null,
+        },
+
+        else => switch (int_info.bits) {
+            8, 16 => int_info.signedness,
+            else => null,
         },
     };
 }
-- 
2.54.0


From 184c8f9545944333bf122203c8d813785b43df8a Mon Sep 17 00:00:00 2001
From: rpkak <rpkak@noreply.codeberg.org>
Date: Sun, 1 Feb 2026 11:21:16 +0100
Subject: [PATCH 186/499] std.heap.PageAllocator: align hint

---
 lib/std/heap/PageAllocator.zig | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/lib/std/heap/PageAllocator.zig b/lib/std/heap/PageAllocator.zig
index d62432905bd7a14fe82a0053cddf128f43e13618..4ca3ec944fc5f47ebb61dba0360afdf21c0b76ce 100644
--- a/lib/std/heap/PageAllocator.zig
+++ b/lib/std/heap/PageAllocator.zig
@@ -87,12 +87,14 @@ pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
     }
 
     const aligned_len = mem.alignForward(usize, n, page_size);
-    const max_drop_len = alignment_bytes - @min(alignment_bytes, page_size);
-    const overalloc_len = if (max_drop_len <= aligned_len - n)
-        aligned_len
-    else
-        mem.alignForward(usize, aligned_len + max_drop_len, page_size);
-    const hint = @atomicLoad(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, .unordered);
+    const max_drop_len = alignment_bytes -| page_size;
+    const overalloc_len = aligned_len + max_drop_len;
+    const maybe_unaligned_hint = @atomicLoad(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, .unordered);
+
+    // Aligning hint does not use mem.alignPointer, because it is slow.
+    // Aligning hint does not use mem.alignForward, because it asserts that there will be no overflow.
+    const hint: ?[*]align(page_size_min) u8 = @ptrFromInt(((@intFromPtr(maybe_unaligned_hint)) +% (alignment_bytes - 1)) & ~(alignment_bytes - 1));
+
     const slice = posix.mmap(
         hint,
         overalloc_len,
@@ -110,7 +112,7 @@ pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
     const remaining_len = overalloc_len - drop_len;
     if (remaining_len > aligned_len) posix.munmap(@alignCast(result_ptr[aligned_len..remaining_len]));
     const new_hint: [*]align(page_size_min) u8 = @alignCast(result_ptr + aligned_len);
-    _ = @cmpxchgStrong(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, hint, new_hint, .monotonic, .monotonic);
+    _ = @cmpxchgStrong(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, maybe_unaligned_hint, new_hint, .monotonic, .monotonic);
     return result_ptr;
 }
 
-- 
2.54.0


From 1ab5a58474d69ba8b9cc63a7ce3eb9b5338c5d2d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Feb 2026 12:00:14 -0800
Subject: [PATCH 187/499] std.Io.Threaded: handle errors from clockResolution

---
 lib/std/Io/Threaded.zig | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 6255d96978405cc0d1b1fc4908644facea0ef4b0..621dfb28d8c4be0c8538c2f4b418900eda41fde9 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -10858,14 +10858,15 @@ fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionEr
                 const result = scale >> 32;
                 return .fromNanoseconds(result);
             },
-            .cpu_process, .cpu_thread => return .zero,
+            .cpu_process, .cpu_thread => return error.ClockUnavailable,
         },
         .wasi => {
             if (builtin.link_libc) return clockResolutionPosix(clock);
             var ns: std.os.wasi.timestamp_t = undefined;
             return switch (std.os.wasi.clock_res_get(clockToWasi(clock), &ns)) {
                 .SUCCESS => .fromNanoseconds(ns),
-                else => .zero,
+                .INVAL => return error.ClockUnavailable,
+                else => |err| return posix.unexpectedErrno(err),
             };
         },
         else => return clockResolutionPosix(clock),
@@ -10877,7 +10878,8 @@ fn clockResolutionPosix(clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
     var timespec: posix.timespec = undefined;
     return switch (posix.errno(posix.system.clock_getres(clock_id, &timespec))) {
         .SUCCESS => .fromNanoseconds(nanosecondsFromPosix(&timespec)),
-        else => .zero,
+        .INVAL => return error.ClockUnavailable,
+        else => |err| return posix.unexpectedErrno(err),
     };
 }
 
-- 
2.54.0


From 56a43fb86f5127171709033fb43e19bc3b8a1cdc Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 3 Feb 2026 19:42:54 +0000
Subject: [PATCH 188/499] Revert "std.Io.Threaded: work around parking futex
 bug"

This reverts commit 5312063138e787a09493e5f5affb5c8652b66dbc.
---
 lib/std/Io/Threaded.zig | 155 +++++++++++++++++-----------------------
 1 file changed, 64 insertions(+), 91 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 6255d96978405cc0d1b1fc4908644facea0ef4b0..5464330bd0095ddcfb8d638ab82aec09fc3d48d2 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -29,8 +29,8 @@ const ws2_32 = std.os.windows.ws2_32;
 /// * scanning environment variables on some targets
 /// * memory-mapping when mmap or equivalent is not available
 allocator: Allocator,
-mutex: Mutex = .init,
-cond: Condition = .init,
+mutex: Io.Mutex = .init,
+cond: Io.Condition = .init,
 run_queue: std.SinglyLinkedList = .{},
 join_requested: bool = false,
 stack_size: usize,
@@ -1505,8 +1505,8 @@ var global_single_threaded_instance: Threaded = .init_single_threaded;
 pub const global_single_threaded: *Threaded = &global_single_threaded_instance;
 
 pub fn setAsyncLimit(t: *Threaded, new_limit: Io.Limit) void {
-    mutexLockInternal(&t.mutex);
-    defer mutexUnlockInternal(&t.mutex);
+    mutexLock(&t.mutex);
+    defer mutexUnlock(&t.mutex);
     t.async_limit = new_limit;
 }
 
@@ -1527,8 +1527,8 @@ pub fn deinit(t: *Threaded) void {
 fn join(t: *Threaded) void {
     if (builtin.single_threaded) return;
     {
-        mutexLockInternal(&t.mutex);
-        defer mutexUnlockInternal(&t.mutex);
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         t.join_requested = true;
     }
     condBroadcast(&t.cond);
@@ -1593,16 +1593,16 @@ fn worker(t: *Threaded) void {
 
     defer t.wait_group.finish();
 
-    mutexLockInternal(&t.mutex);
-    defer mutexUnlockInternal(&t.mutex);
+    mutexLock(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     while (true) {
         while (t.run_queue.popFirst()) |runnable_node| {
-            mutexUnlockInternal(&t.mutex);
+            mutexUnlock(&t.mutex);
             thread.cancel_protection = .unblocked;
             const runnable: *Runnable = @fieldParentPtr("node", runnable_node);
             runnable.startFn(runnable, &thread, t);
-            mutexLockInternal(&t.mutex);
+            mutexLock(&t.mutex);
             t.busy_count -= 1;
         }
         if (t.join_requested) break;
@@ -2025,12 +2025,12 @@ fn async(
         },
     };
 
-    mutexLockInternal(&t.mutex);
+    mutexLock(&t.mutex);
 
     const busy_count = t.busy_count;
 
     if (busy_count >= @intFromEnum(t.async_limit)) {
-        mutexUnlockInternal(&t.mutex);
+        mutexUnlock(&t.mutex);
         future.destroy(gpa);
         start(context.ptr, result.ptr);
         return null;
@@ -2044,7 +2044,7 @@ fn async(
         const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
             t.wait_group.finish();
             t.busy_count = busy_count;
-            mutexUnlockInternal(&t.mutex);
+            mutexUnlock(&t.mutex);
             future.destroy(gpa);
             start(context.ptr, result.ptr);
             return null;
@@ -2054,7 +2054,7 @@ fn async(
 
     t.run_queue.prepend(&future.runnable.node);
 
-    mutexUnlockInternal(&t.mutex);
+    mutexUnlock(&t.mutex);
     condSignal(&t.cond);
     return @ptrCast(future);
 }
@@ -2077,8 +2077,8 @@ fn concurrent(
     };
     errdefer future.destroy(gpa);
 
-    mutexLockInternal(&t.mutex);
-    defer mutexUnlockInternal(&t.mutex);
+    mutexLock(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     const busy_count = t.busy_count;
 
@@ -2122,12 +2122,12 @@ fn groupAsync(
         error.OutOfMemory => return groupAsyncEager(start, context.ptr),
     };
 
-    mutexLockInternal(&t.mutex);
+    mutexLock(&t.mutex);
 
     const busy_count = t.busy_count;
 
     if (busy_count >= @intFromEnum(t.async_limit)) {
-        mutexUnlockInternal(&t.mutex);
+        mutexUnlock(&t.mutex);
         task.destroy(gpa);
         return groupAsyncEager(start, context.ptr);
     }
@@ -2140,7 +2140,7 @@ fn groupAsync(
         const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
             t.wait_group.finish();
             t.busy_count = busy_count;
-            mutexUnlockInternal(&t.mutex);
+            mutexUnlock(&t.mutex);
             task.destroy(gpa);
             return groupAsyncEager(start, context.ptr);
         };
@@ -2157,7 +2157,7 @@ fn groupAsync(
     }, .monotonic);
     t.run_queue.prepend(&task.runnable.node);
 
-    mutexUnlockInternal(&t.mutex);
+    mutexUnlock(&t.mutex);
     condSignal(&t.cond);
 }
 fn groupAsyncEager(
@@ -2222,8 +2222,8 @@ fn groupConcurrent(
     };
     errdefer task.destroy(gpa);
 
-    mutexLockInternal(&t.mutex);
-    defer mutexUnlockInternal(&t.mutex);
+    mutexLock(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     const busy_count = t.busy_count;
 
@@ -3847,8 +3847,8 @@ fn fileStatWindows(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
 
 fn systemBasicInformation(t: *Threaded) ?*const windows.SYSTEM_BASIC_INFORMATION {
     if (!t.system_basic_information.initialized.load(.acquire)) {
-        mutexLockInternal(&t.mutex);
-        defer mutexUnlockInternal(&t.mutex);
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
 
         switch (windows.ntdll.NtQuerySystemInformation(
             .SystemBasicInformation,
@@ -14359,10 +14359,9 @@ const Wsa = struct {
 };
 
 fn initializeWsa(t: *Threaded) error{ NetworkDown, Canceled }!void {
-    const t_io = io(t);
     const wsa = &t.wsa;
-    try wsa.mutex.lock(t_io);
-    defer wsa.mutex.unlock(t_io);
+    try mutexLock(&wsa.mutex);
+    defer mutexUnlock(&wsa.mutex);
     switch (wsa.status) {
         .uninitialized => {
             var wsa_data: ws2_32.WSADATA = undefined;
@@ -14433,8 +14432,8 @@ const WindowsEnvironStrings = struct {
 };
 
 fn scanEnviron(t: *Threaded) void {
-    mutexLockInternal(&t.mutex);
-    defer mutexUnlockInternal(&t.mutex);
+    mutexLock(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     if (t.environ.initialized) return;
     t.environ.initialized = true;
@@ -14789,8 +14788,8 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
 
 fn getDevNullFd(t: *Threaded) !posix.fd_t {
     {
-        mutexLockInternal(&t.mutex);
-        defer mutexUnlockInternal(&t.mutex);
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         if (t.null_file.fd != -1) return t.null_file.fd;
     }
     const mode: u32 = 0;
@@ -14801,8 +14800,8 @@ fn getDevNullFd(t: *Threaded) !posix.fd_t {
             .SUCCESS => {
                 syscall.finish();
                 const fresh_fd: posix.fd_t = @intCast(rc);
-                mutexLockInternal(&t.mutex); // Another thread might have won the race.
-                defer mutexUnlockInternal(&t.mutex);
+                mutexLock(&t.mutex); // Another thread might have won the race.
+                defer mutexUnlock(&t.mutex);
                 if (t.null_file.fd != -1) {
                     posix.close(fresh_fd);
                     return t.null_file.fd;
@@ -15462,8 +15461,8 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
 
 fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     {
-        mutexLockInternal(&t.mutex);
-        defer mutexUnlockInternal(&t.mutex);
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         if (t.random_file.handle) |handle| return handle;
     }
 
@@ -15497,8 +15496,8 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     )) {
         .SUCCESS => {
             syscall.finish();
-            mutexLockInternal(&t.mutex); // Another thread might have won the race.
-            defer mutexUnlockInternal(&t.mutex);
+            mutexLock(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlock(&t.mutex);
             if (t.random_file.handle) |prev_handle| {
                 windows.CloseHandle(fresh_handle);
                 return prev_handle;
@@ -15518,8 +15517,8 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
 
 fn getNulHandle(t: *Threaded) !windows.HANDLE {
     {
-        mutexLockInternal(&t.mutex);
-        defer mutexUnlockInternal(&t.mutex);
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
         if (t.null_file.handle) |handle| return handle;
     }
 
@@ -15565,8 +15564,8 @@ fn getNulHandle(t: *Threaded) !windows.HANDLE {
     )) {
         .SUCCESS => {
             syscall.finish();
-            mutexLockInternal(&t.mutex); // Another thread might have won the race.
-            defer mutexUnlockInternal(&t.mutex);
+            mutexLock(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlock(&t.mutex);
             if (t.null_file.handle) |prev_handle| {
                 windows.CloseHandle(fresh_handle);
                 return prev_handle;
@@ -16611,15 +16610,15 @@ fn random(userdata: ?*anyopaque, buffer: []u8) void {
 }
 
 fn randomMainThread(t: *Threaded, buffer: []u8) void {
-    mutexLockInternal(&t.mutex);
-    defer mutexUnlockInternal(&t.mutex);
+    mutexLock(&t.mutex);
+    defer mutexUnlock(&t.mutex);
 
     if (!t.csprng.isInitialized()) {
         @branchHint(.unlikely);
         var seed: [Csprng.seed_len]u8 = undefined;
         {
-            mutexUnlockInternal(&t.mutex);
-            defer mutexLockInternal(&t.mutex);
+            mutexUnlock(&t.mutex);
+            defer mutexLock(&t.mutex);
 
             const prev = swapCancelProtection(t, .blocked);
             defer _ = swapCancelProtection(t, prev);
@@ -16804,8 +16803,8 @@ fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
 
 fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
     {
-        mutexLockInternal(&t.mutex);
-        defer mutexUnlockInternal(&t.mutex);
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
 
         if (t.random_file.fd == -2) return error.EntropyUnavailable;
         if (t.random_file.fd != -1) return t.random_file.fd;
@@ -16845,8 +16844,8 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                     .SUCCESS => {
                         syscall.finish();
                         if (!statx.mask.TYPE) return error.EntropyUnavailable;
-                        mutexLockInternal(&t.mutex); // Another thread might have won the race.
-                        defer mutexUnlockInternal(&t.mutex);
+                        mutexLock(&t.mutex); // Another thread might have won the race.
+                        defer mutexUnlock(&t.mutex);
                         if (t.random_file.fd >= 0) {
                             posix.close(fd);
                             return t.random_file.fd;
@@ -16873,8 +16872,8 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                 switch (posix.errno(fstat_sym(fd, &stat))) {
                     .SUCCESS => {
                         syscall.finish();
-                        mutexLockInternal(&t.mutex); // Another thread might have won the race.
-                        defer mutexUnlockInternal(&t.mutex);
+                        mutexLock(&t.mutex); // Another thread might have won the race.
+                        defer mutexUnlock(&t.mutex);
                         if (t.random_file.fd >= 0) {
                             posix.close(fd);
                             return t.random_file.fd;
@@ -16938,7 +16937,7 @@ const parking_futex = struct {
         /// avoid a race.
         num_waiters: std.atomic.Value(u32),
         /// Protects `waiters`.
-        mutex: Mutex,
+        mutex: Io.Mutex,
         waiters: std.DoublyLinkedList,
 
         /// Prevent false sharing between buckets.
@@ -17007,8 +17006,8 @@ const parking_futex = struct {
         var status_buf: std.atomic.Value(Thread.Status) = undefined;
 
         {
-            mutexLockInternal(&bucket.mutex);
-            defer mutexUnlockInternal(&bucket.mutex);
+            mutexLock(&bucket.mutex);
+            defer mutexUnlock(&bucket.mutex);
 
             _ = bucket.num_waiters.fetchAdd(1, .acquire);
 
@@ -17077,8 +17076,8 @@ const parking_futex = struct {
                 .parked => {
                     // We saw a timeout and updated our own status from `.parked` to `.none`. It is
                     // our responsibility to remove `waiter` from `bucket`.
-                    mutexLockInternal(&bucket.mutex);
-                    defer mutexUnlockInternal(&bucket.mutex);
+                    mutexLock(&bucket.mutex);
+                    defer mutexUnlock(&bucket.mutex);
                     bucket.waiters.remove(&waiter.node);
                     assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
                 },
@@ -17117,8 +17116,8 @@ const parking_futex = struct {
         // of the critical section. This forms a singly-linked list of waiters using `Waiter.node.next`.
         var waking_head: ?*std.DoublyLinkedList.Node = null;
         {
-            mutexLockInternal(&bucket.mutex);
-            defer mutexUnlockInternal(&bucket.mutex);
+            mutexLock(&bucket.mutex);
+            defer mutexUnlock(&bucket.mutex);
 
             var num_removed: u32 = 0;
             var it = bucket.waiters.first;
@@ -17173,8 +17172,8 @@ const parking_futex = struct {
 
     fn removeCanceledWaiter(waiter: *Waiter) void {
         const bucket = bucketForAddress(waiter.address);
-        mutexLockInternal(&bucket.mutex);
-        defer mutexUnlockInternal(&bucket.mutex);
+        mutexLock(&bucket.mutex);
+        defer mutexUnlock(&bucket.mutex);
         bucket.waiters.remove(&waiter.node);
         assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
         waiter.done.store(true, .release); // potentially invalidates `waiter.*`
@@ -18160,14 +18159,8 @@ fn eventSet(event: *Io.Event) void {
     }
 }
 
-const Condition = if (!is_windows) Io.Condition else struct {
-    condition: windows.CONDITION_VARIABLE,
-    const init: @This() = .{ .condition = .{} };
-};
-
 /// Same as `Io.Condition.broadcast` but avoids the VTable.
-fn condBroadcast(cond: *Condition) void {
-    if (is_windows) return windows.ntdll.RtlWakeAllConditionVariable(&cond.condition);
+fn condBroadcast(cond: *Io.Condition) void {
     var prev_state = cond.state.load(.monotonic);
     while (prev_state.waiters > prev_state.signals) {
         @branchHint(.unlikely);
@@ -18187,8 +18180,7 @@ fn condBroadcast(cond: *Condition) void {
 }
 
 /// Same as `Io.Condition.signal` but avoids the VTable.
-fn condSignal(cond: *Condition) void {
-    if (is_windows) return windows.ntdll.RtlWakeConditionVariable(&cond.condition);
+fn condSignal(cond: *Io.Condition) void {
     var prev_state = cond.state.load(.monotonic);
     while (prev_state.waiters > prev_state.signals) {
         @branchHint(.unlikely);
@@ -18208,11 +18200,7 @@ fn condSignal(cond: *Condition) void {
 }
 
 /// Same as `Io.Condition.waitUncancelable` but avoids the VTable.
-fn condWait(cond: *Condition, mutex: *Mutex) void {
-    if (is_windows) {
-        _ = windows.kernel32.SleepConditionVariableSRW(&cond.condition, &mutex.srwlock, windows.INFINITE, 0);
-        return;
-    }
+fn condWait(cond: *Io.Condition, mutex: *Io.Mutex) void {
     var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
 
     {
@@ -18220,8 +18208,8 @@ fn condWait(cond: *Condition, mutex: *Mutex) void {
         assert(prev_state.waiters < std.math.maxInt(u16)); // overflow caused by too many waiters
     }
 
-    mutexUnlockInternal(mutex);
-    defer mutexLockInternal(mutex);
+    mutexUnlock(mutex);
+    defer mutexLock(mutex);
 
     while (true) {
         Thread.futexWaitUncancelable(&cond.epoch.raw, epoch, null);
@@ -18241,16 +18229,6 @@ fn condWait(cond: *Condition, mutex: *Mutex) void {
     }
 }
 
-const Mutex = if (!is_windows) Io.Mutex else struct {
-    srwlock: windows.SRWLOCK,
-    const init: @This() = .{ .srwlock = .{} };
-};
-
-fn mutexLockInternal(m: *Mutex) void {
-    if (is_windows) return windows.ntdll.RtlAcquireSRWLockExclusive(&m.srwlock);
-    return mutexLock(m);
-}
-
 /// Same as `Io.Mutex.lockUncancelable` but avoids the VTable.
 pub fn mutexLock(m: *Io.Mutex) void {
     const initial_state = m.state.cmpxchgWeak(
@@ -18270,11 +18248,6 @@ pub fn mutexLock(m: *Io.Mutex) void {
     }
 }
 
-fn mutexUnlockInternal(m: *Mutex) void {
-    if (is_windows) return windows.ntdll.RtlReleaseSRWLockExclusive(&m.srwlock);
-    return mutexUnlock(m);
-}
-
 /// Same as `Io.Mutex.unlock` but avoids the VTable.
 pub fn mutexUnlock(m: *Io.Mutex) void {
     switch (m.state.swap(.unlocked, .release)) {
-- 
2.54.0


From 7c08f77efa6052750118881b506f7b59918993e0 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 3 Feb 2026 19:50:31 +0000
Subject: [PATCH 189/499] Revert "std.Io.Threaded: spurious unparks are
 possible"

It turns out that at least on Windows, spurious unparks are *not*
possible, and in fact triggering them breaks some RTL synchronization
primitives. For instance, if you have a pending unpark going into a
contended `RtlEnterCriticalSection` call, it will never unblock. In
other words, the Windows API worked exactly how I thought it did, and
it's only the NetBSD/Illumos one which is dumb. This is actually exactly
why Windows 8 introduced the parking API despite alertable sleeps being
a thing!

This commit doesn't yet deal with making NetBSD work, nor does it even
compile I imagine. The next commit will fix everything back up.

This reverts commit c518593e9793a2aed4e0173348aff2cbef58b717.
---
 lib/std/Io/Threaded.zig | 244 ++++++++++++++++++++--------------------
 1 file changed, 123 insertions(+), 121 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 5464330bd0095ddcfb8d638ab82aec09fc3d48d2..558263a0102d755cc75e9dce78249428e8f8f3ec 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -4955,7 +4955,10 @@ pub fn dirOpenFileWtf16(
                 // kernel bug with retry attempts.
                 syscall.finish();
                 if (max_attempts - attempt == 0) return error.FileBusy;
-                try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+                try parking_sleep.sleep(.{ .duration = .{
+                    .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                    .clock = .awake,
+                } });
                 attempt += 1;
                 syscall = try .start();
                 continue;
@@ -4977,7 +4980,10 @@ pub fn dirOpenFileWtf16(
                 // fixed by sleeping and retrying until the error goes away.
                 syscall.finish();
                 if (max_attempts - attempt == 0) return error.FileBusy;
-                try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+                try parking_sleep.sleep(.{ .duration = .{
+                    .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                    .clock = .awake,
+                } });
                 attempt += 1;
                 syscall = try .start();
                 continue;
@@ -10823,9 +10829,6 @@ fn nowPosix(clock: Io.Clock) Io.Timestamp {
 fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Timestamp {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    return nowInner(clock);
-}
-fn nowInner(clock: Io.Clock) Io.Timestamp {
     return switch (native_os) {
         .windows => nowWindows(clock),
         .wasi => nowWasi(clock),
@@ -15582,7 +15585,10 @@ fn getNulHandle(t: *Threaded) !windows.HANDLE {
             // this other than retrying the creation after the OS finishes
             // the deletion.
             syscall.finish();
-            try parking_sleep.windowsRetrySleep(1);
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds(1),
+                .clock = .awake,
+            } });
             syscall = try .start();
             continue;
         },
@@ -16955,13 +16961,9 @@ const parking_futex = struct {
         ///
         /// * Removing the `Waiter` from `Bucket.waiters`
         /// * Decrementing `Bucket.num_waiters`
-        /// * Atomically setting `done` (after this, the `Waiter` may go out of scope at any time,
-        ///   so must not be referenced again)
-        /// * Unparking the thread (last, so that the unparked thread definitely sees `done`)
+        /// * Unparking the thread (*after* the above, so that the `Waiter` does not go out of scope
+        ///   while it is still in the `Bucket`).
         thread_status: *std.atomic.Value(Thread.Status),
-        /// Initially `false`. Whoever updates `thread_status` to `.none`/`.canceling` will update
-        /// this to `true` once they are done with the `Waiter`, just before unparking `tid`.
-        done: std.atomic.Value(bool),
     };
 
     fn bucketForAddress(address: usize) *Bucket {
@@ -17000,7 +17002,6 @@ const parking_futex = struct {
             .address = @intFromPtr(ptr),
             .tid = self_tid,
             .thread_status = undefined, // populated in critical section
-            .done = .init(false),
         };
 
         var status_buf: std.atomic.Value(Thread.Status) = undefined;
@@ -17058,44 +17059,41 @@ const parking_futex = struct {
             bucket.waiters.append(&waiter.node);
         }
 
-        const deadline: ?Io.Clock.Timestamp = switch (timeout) {
-            .none => null,
-            .duration => |d| .{
-                .raw = nowInner(d.clock).addDuration(d.raw),
-                .clock = d.clock,
-            },
-            .deadline => |d| d,
-        };
-        while (park(deadline, ptr)) {
-            if (waiter.done.load(.acquire)) return; // all done!
+        if (park(timeout, ptr)) {
+            // We were unparked by either `wake` or cancelation, so our current status is either
+            // `.none` or `.canceling`. In either case, they've already removed `waiter` from
+            // `bucket`, so we have nothing more to do!
         } else |err| switch (err) {
-            error.Timeout => switch (waiter.thread_status.fetchAnd(
-                .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones },
-                .monotonic,
-            ).cancelation) {
-                .parked => {
-                    // We saw a timeout and updated our own status from `.parked` to `.none`. It is
-                    // our responsibility to remove `waiter` from `bucket`.
-                    mutexLock(&bucket.mutex);
-                    defer mutexUnlock(&bucket.mutex);
-                    bucket.waiters.remove(&waiter.node);
-                    assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
-                },
-                .none, .canceling => {
-                    // Race condition: the timeout was reached, then `wake` or a cancelation tried
-                    // to update our status. They won the race, so wait for them to do the cleanup.
-                    // They'll tell us by setting `waiter.done` and unparking us.
-                    while (!waiter.done.load(.acquire)) {
-                        park(null, ptr) catch |e| switch (e) {
+            error.Timeout => {
+                // We're not out of the woods yet: an unpark could race with the timeout.
+                const old_status = waiter.thread_status.fetchAnd(
+                    .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones },
+                    .monotonic,
+                );
+                switch (old_status.cancelation) {
+                    .parked => {
+                        // No race. It is our responsibility to remove `waiter` from `bucket`.
+                        // New status is `.none`.
+                        bucket.mutex.lock();
+                        defer bucket.mutex.unlock();
+                        bucket.waiters.remove(&waiter.node);
+                        assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
+                    },
+                    .none, .canceling => {
+                        // Race condition: the timeout was reached, then `wake` or a canceler tried
+                        // to unpark us. Whoever did that will remove us from `bucket`. Wait for
+                        // that (and drop the unpark request in doing so).
+                        // New status is `.none` or `.canceling` respectively.
+                        park(.none, ptr) catch |e| switch (e) {
                             error.Timeout => unreachable,
                         };
-                    }
-                },
-                .canceled => unreachable,
-                .blocked => unreachable,
-                .blocked_alertable => unreachable,
-                .blocked_alertable_canceling => unreachable,
-                .blocked_canceling => unreachable,
+                    },
+                    .canceled => unreachable,
+                    .blocked => unreachable,
+                    .blocked_alertable => unreachable,
+                    .blocked_canceling => unreachable,
+                    .blocked_alertable_canceling => unreachable,
+                }
             },
         }
     }
@@ -17144,6 +17142,9 @@ const parking_futex = struct {
                 waiter.node.next = waking_head;
                 waking_head = &waiter.node;
                 num_removed += 1;
+                // Signal to `waiter` that they're about to be unparked, in case we're racing with their
+                // timeout. See corresponding logic in `wake`.
+                waiter.address = 0;
             }
 
             _ = bucket.num_waiters.fetchSub(num_removed, .monotonic);
@@ -17158,8 +17159,6 @@ const parking_futex = struct {
             const waiter: *Waiter = @fieldParentPtr("node", node);
             unpark_buf[unpark_len] = waiter.tid;
             unpark_len += 1;
-            waiter.done.store(true, .release);
-            // `waiter.*` is now potentially invalid so must not be referenced again.
             if (unpark_len == unpark_buf.len) {
                 unpark(&unpark_buf, ptr);
                 unpark_len = 0;
@@ -17176,14 +17175,13 @@ const parking_futex = struct {
         defer mutexUnlock(&bucket.mutex);
         bucket.waiters.remove(&waiter.node);
         assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
-        waiter.done.store(true, .release); // potentially invalidates `waiter.*`
     }
 };
 const parking_sleep = struct {
     comptime {
         assert(use_parking_sleep);
     }
-    fn sleep(deadline: ?Io.Clock.Timestamp) Io.Cancelable!void {
+    fn sleep(timeout: Io.Timeout) Io.Cancelable!void {
         const opt_thread = Thread.current;
         cancelable: {
             const thread = opt_thread orelse break :cancelable;
@@ -17192,90 +17190,87 @@ const parking_sleep = struct {
                 .unblocked => {},
             }
             thread.futex_waiter = null;
-            const orig_status = thread.status.fetchOr(
-                .{ .cancelation = @enumFromInt(0b001), .awaitable = .null },
-                .release, // release `thread.futex_waiter`
-            );
-            switch (orig_status.cancelation) {
-                .none => {}, // status is now `.parked`
-                .canceling => return error.Canceled, // status is now `.canceled`
-                .canceled => break :cancelable, // status is still `.canceled`
-                .parked => unreachable,
-                .blocked => unreachable,
-                .blocked_alertable => unreachable,
-                .blocked_alertable_canceling => unreachable,
-                .blocked_canceling => unreachable,
-            }
-            while (park(deadline, null)) {
-                // Either a cancelation or a spurious unpark; let's see which!
-                switch (thread.status.load(.monotonic).cancelation) {
-                    .parked => continue, // spurious unpark; keep sleeping
-                    .canceling => {
-                        // We got canceled; update our state and return.
-                        thread.status.store(
-                            .{ .cancelation = .canceled, .awaitable = orig_status.awaitable },
-                            .monotonic,
-                        );
-                        return error.Canceled;
-                    },
-                    .none => unreachable,
-                    .canceled => unreachable,
+            {
+                const old_status = thread.status.fetchOr(
+                    .{ .cancelation = @enumFromInt(0b001), .awaitable = .null },
+                    .release, // release `thread.futex_waiter`
+                );
+                switch (old_status.cancelation) {
+                    .none => {}, // status is now `.parked`
+                    .canceling => return error.Canceled, // status is now `.canceled`
+                    .canceled => break :cancelable, // status is still `.canceled`
+                    .parked => unreachable,
                     .blocked => unreachable,
                     .blocked_alertable => unreachable,
                     .blocked_alertable_canceling => unreachable,
                     .blocked_canceling => unreachable,
                 }
-            } else |err| switch (err) {
-                error.Timeout => switch (thread.status.fetchAnd(
-                    .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones },
+            }
+            if (park(timeout, null)) {
+                // The only reason this could possibly happen is cancelation.
+                const old_status = thread.status.load(.monotonic);
+                assert(old_status.cancelation == .canceling);
+                thread.status.store(
+                    .{ .cancelation = .canceled, .awaitable = old_status.awaitable },
                     .monotonic,
-                ).cancelation) {
-                    // We updated our own status from `.parked` to `.none`.
-                    .parked => return, // new status is `.none`
-                    .canceling => {
-                        // Timeout raced with a cancelation. We don't need to do anything, but
-                        // the next `park` on this thread will see a spurious unpark.
-                        // Status is still `.canceling`.
-                        return;
-                    },
-                    .none => unreachable,
-                    .canceled => unreachable,
-                    .blocked => unreachable,
-                    .blocked_alertable => unreachable,
-                    .blocked_alertable_canceling => unreachable,
-                    .blocked_canceling => unreachable,
+                );
+                return error.Canceled;
+            } else |err| switch (err) {
+                error.Timeout => {
+                    // We're not out of the woods yet: an unpark could race with the timeout.
+                    const old_status = thread.status.fetchAnd(
+                        .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones },
+                        .monotonic,
+                    );
+                    switch (old_status.cancelation) {
+                        .parked => return, // No race; new status is `.none`
+                        .canceling => {
+                            // Race condition: the timeout was reached, then someone tried to unpark
+                            // us for a cancelation. Whoever did that will have called `unpark`, so
+                            // drop that unpark request by waiting for it.
+                            // Status is still `.canceling`.
+                            park(.none, null) catch |e| switch (e) {
+                                error.Timeout => unreachable,
+                            };
+                            return;
+                        },
+                        .none => unreachable,
+                        .canceled => unreachable,
+                        .blocked => unreachable,
+                        .blocked_alertable => unreachable,
+                        .blocked_canceling => unreachable,
+                        .blocked_alertable_canceling => unreachable,
+                    }
                 },
             }
         }
-        // Uncancelable sleep; this case is very simple.
-        while (park(deadline, null)) {
-            // Definitely spurious; nothing to do.
+        // Uncancelable sleep; we expect not to be manually unparked.
+        if (park(timeout, null)) {
+            unreachable; // unexpected unpark
         } else |err| switch (err) {
             error.Timeout => return,
         }
     }
-    /// Sleep for approximately `ms` awake milliseconds in an attempt to work around Windows kernel bugs.
-    fn windowsRetrySleep(ms: u32) (Io.Cancelable || Io.UnexpectedError)!void {
-        const now_timestamp = nowWindows(.awake); // '.awake' is supported on Windows
-        const deadline = now_timestamp.addDuration(.fromMilliseconds(ms));
-        try parking_sleep.sleep(.{ .raw = deadline, .clock = .awake });
-    }
 };
 
-/// Spurious wakeups are possible.
-///
 /// `addr_hint` has no semantic effect, but may allow the OS to optimize this operation.
-fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{Timeout}!void {
+fn park(timeout: Io.Timeout, addr_hint: ?*const anyopaque) error{Timeout}!void {
     comptime assert(use_parking_futex or use_parking_sleep);
     switch (native_os) {
         .windows => {
             var timeout_buf: windows.LARGE_INTEGER = undefined;
-            const raw_timeout: ?*windows.LARGE_INTEGER = if (opt_deadline) |deadline| timeout: {
-                const now_timestamp = nowWindows(deadline.clock);
-                const nanoseconds = now_timestamp.durationTo(deadline.raw).nanoseconds;
-                timeout_buf = @intCast(@divTrunc(-nanoseconds, 100));
-                break :timeout &timeout_buf;
-            } else null;
+            const raw_timeout: ?*windows.LARGE_INTEGER = timeout: switch (timeout) {
+                .none => null,
+                .deadline => |timestamp| continue :timeout .{ .duration = .{
+                    .clock = timestamp.clock,
+                    .raw = (nowWindows(timestamp.clock) catch unreachable).durationTo(timestamp.raw),
+                } },
+                .duration => |duration| {
+                    _ = duration.clock; // Windows only supports monotonic
+                    timeout_buf = @intCast(@divTrunc(-duration.raw.nanoseconds, 100));
+                    break :timeout &timeout_buf;
+                },
+            };
             // `RtlWaitOnAddress` passes the futex address in as the first argument to this call,
             // but it's unclear what that actually does, especially since `NtAlertThreadByThreadId`
             // does *not* accept the address so the kernel can't really be using it as a hint. An
@@ -17297,13 +17292,20 @@ fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{T
         },
         .netbsd => {
             var ts_buf: posix.timespec = undefined;
-            const ts: ?*posix.timespec, const clock_real: bool = if (opt_deadline) |deadline| timeout: {
-                ts_buf = timestampToPosix(deadline.raw.nanoseconds);
-                break :timeout .{ &ts_buf, deadline.clock == .real };
-            } else .{ null, true };
+            const ts: ?*posix.timespec, const abstime: bool, const clock_real: bool = switch (timeout) {
+                .none => .{ null, false, false },
+                .deadline => |timestamp| timeout: {
+                    ts_buf = timestampToPosix(timestamp.raw.nanoseconds);
+                    break :timeout .{ &ts_buf, true, timestamp.clock == .real };
+                },
+                .duration => |duration| timeout: {
+                    ts_buf = timestampToPosix(duration.raw.nanoseconds);
+                    break :timeout .{ &ts_buf, false, duration.clock == .real };
+                },
+            };
             switch (posix.errno(std.c._lwp_park(
                 if (clock_real) .REALTIME else .MONOTONIC,
-                .{ .ABSTIME = true },
+                .{ .ABSTIME = abstime },
                 ts,
                 0,
                 addr_hint,
-- 
2.54.0


From 6d6532dd9eb862dfd6e59ceed5c762342d2cc0d5 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 3 Feb 2026 22:14:42 +0000
Subject: [PATCH 190/499] Io.Threaded: add ParkingMutex, and deal with spurious
 unparks on NetBSD

We can't use Io.Mutex in parking_futex; instead, we need a simple
parking-based mutex implementation. That's fairly simple to do.

Also deal with spurious unparks on NetBSD, where they *can* happen (as
opposed to Windows, where they cannot).
---
 lib/std/Io/Threaded.zig | 284 +++++++++++++++++++++++++++++++---------
 1 file changed, 219 insertions(+), 65 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 558263a0102d755cc75e9dce78249428e8f8f3ec..59d816f62ceac38c2bcc385695c2f4616119842d 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2662,7 +2662,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         while (b.pending.head != .none and b.completions.head == .none) {
             var delay_interval: windows.LARGE_INTEGER = interval: {
                 const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
-                break :interval t.deadlineToWindowsInterval(d);
+                break :interval timeoutToWindowsInterval(.{ .deadline = d }).?;
             };
             const alertable_syscall = try AlertableSyscall.start();
             const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
@@ -4339,7 +4339,10 @@ fn dirCreateFileWindows(
             // kernel bug with retry attempts.
             syscall.finish();
             if (max_attempts - attempt == 0) return error.FileBusy;
-            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                .clock = .awake,
+            } });
             attempt += 1;
             syscall = try .start();
             continue;
@@ -4352,7 +4355,10 @@ fn dirCreateFileWindows(
             // fixed by sleeping and retrying until the error goes away.
             syscall.finish();
             if (max_attempts - attempt == 0) return error.FileBusy;
-            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                .clock = .awake,
+            } });
             attempt += 1;
             syscall = try .start();
             continue;
@@ -7382,7 +7388,10 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
             // kernel bug with retry attempts.
             syscall.finish();
             if (max_attempts - attempt == 0) return error.FileBusy;
-            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                .clock = .awake,
+            } });
             attempt += 1;
             syscall = try .start();
             continue;
@@ -7395,7 +7404,10 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
             // fixed by sleeping and retrying until the error goes away.
             syscall.finish();
             if (max_attempts - attempt == 0) return error.FileBusy;
-            try parking_sleep.windowsRetrySleep((@as(u32, 1) << attempt) >> 1);
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                .clock = .awake,
+            } });
             attempt += 1;
             syscall = try .start();
             continue;
@@ -10956,7 +10968,7 @@ fn nowWasi(clock: Io.Clock) Io.Timestamp {
 fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (timeout == .none) return;
-    if (use_parking_sleep) return parking_sleep.sleep(timeout.toTimestamp(ioBasic(t)));
+    if (use_parking_sleep) return parking_sleep.sleep(timeout);
     if (native_os == .wasi) return sleepWasi(t, timeout);
     if (@TypeOf(posix.system.clock_nanosleep) != void) return sleepPosix(timeout);
     return sleepNanosleep(t, timeout);
@@ -14363,7 +14375,7 @@ const Wsa = struct {
 
 fn initializeWsa(t: *Threaded) error{ NetworkDown, Canceled }!void {
     const wsa = &t.wsa;
-    try mutexLock(&wsa.mutex);
+    mutexLock(&wsa.mutex);
     defer mutexUnlock(&wsa.mutex);
     switch (wsa.status) {
         .uninitialized => {
@@ -16943,7 +16955,7 @@ const parking_futex = struct {
         /// avoid a race.
         num_waiters: std.atomic.Value(u32),
         /// Protects `waiters`.
-        mutex: Io.Mutex,
+        mutex: ParkingMutex,
         waiters: std.DoublyLinkedList,
 
         /// Prevent false sharing between buckets.
@@ -17007,8 +17019,8 @@ const parking_futex = struct {
         var status_buf: std.atomic.Value(Thread.Status) = undefined;
 
         {
-            mutexLock(&bucket.mutex);
-            defer mutexUnlock(&bucket.mutex);
+            bucket.mutex.lock();
+            defer bucket.mutex.unlock();
 
             _ = bucket.num_waiters.fetchAdd(1, .acquire);
 
@@ -17059,7 +17071,7 @@ const parking_futex = struct {
             bucket.waiters.append(&waiter.node);
         }
 
-        if (park(timeout, ptr)) {
+        if (park(timeout, ptr, waiter.thread_status)) {
             // We were unparked by either `wake` or cancelation, so our current status is either
             // `.none` or `.canceling`. In either case, they've already removed `waiter` from
             // `bucket`, so we have nothing more to do!
@@ -17084,7 +17096,7 @@ const parking_futex = struct {
                         // to unpark us. Whoever did that will remove us from `bucket`. Wait for
                         // that (and drop the unpark request in doing so).
                         // New status is `.none` or `.canceling` respectively.
-                        park(.none, ptr) catch |e| switch (e) {
+                        park(.none, ptr, waiter.thread_status) catch |e| switch (e) {
                             error.Timeout => unreachable,
                         };
                     },
@@ -17114,8 +17126,8 @@ const parking_futex = struct {
         // of the critical section. This forms a singly-linked list of waiters using `Waiter.node.next`.
         var waking_head: ?*std.DoublyLinkedList.Node = null;
         {
-            mutexLock(&bucket.mutex);
-            defer mutexUnlock(&bucket.mutex);
+            bucket.mutex.lock();
+            defer bucket.mutex.unlock();
 
             var num_removed: u32 = 0;
             var it = bucket.waiters.first;
@@ -17171,8 +17183,8 @@ const parking_futex = struct {
 
     fn removeCanceledWaiter(waiter: *Waiter) void {
         const bucket = bucketForAddress(waiter.address);
-        mutexLock(&bucket.mutex);
-        defer mutexUnlock(&bucket.mutex);
+        bucket.mutex.lock();
+        defer bucket.mutex.unlock();
         bucket.waiters.remove(&waiter.node);
         assert(bucket.num_waiters.fetchSub(1, .monotonic) > 0);
     }
@@ -17206,7 +17218,7 @@ const parking_sleep = struct {
                     .blocked_canceling => unreachable,
                 }
             }
-            if (park(timeout, null)) {
+            if (park(timeout, null, &thread.status)) {
                 // The only reason this could possibly happen is cancelation.
                 const old_status = thread.status.load(.monotonic);
                 assert(old_status.cancelation == .canceling);
@@ -17229,7 +17241,7 @@ const parking_sleep = struct {
                             // us for a cancelation. Whoever did that will have called `unpark`, so
                             // drop that unpark request by waiting for it.
                             // Status is still `.canceling`.
-                            park(.none, null) catch |e| switch (e) {
+                            park(.none, null, &thread.status) catch |e| switch (e) {
                                 error.Timeout => unreachable,
                             };
                             return;
@@ -17245,32 +17257,183 @@ const parking_sleep = struct {
             }
         }
         // Uncancelable sleep; we expect not to be manually unparked.
-        if (park(timeout, null)) {
+        var dummy_status: std.atomic.Value(Thread.Status) = .init(.{ .cancelation = .parked, .awaitable = .null });
+        if (park(timeout, null, &dummy_status)) {
             unreachable; // unexpected unpark
         } else |err| switch (err) {
             error.Timeout => return,
         }
     }
 };
+const ParkingMutex = struct {
+    state: std.atomic.Value(State),
 
-/// `addr_hint` has no semantic effect, but may allow the OS to optimize this operation.
-fn park(timeout: Io.Timeout, addr_hint: ?*const anyopaque) error{Timeout}!void {
+    const init: ParkingMutex = .{ .state = .init(.unlocked) };
+
+    comptime {
+        assert(use_parking_futex);
+    }
+
+    const State = enum(usize) {
+        unlocked = 1,
+        /// This value is intentionally 0 so that `waiter` returns `null`.
+        locked_once = 0,
+        /// Contended; value is a `*Waiter`.
+        _,
+        /// Returns the head of the waiter list. Illegal to call if `s == .unlocked`.
+        fn waiter(s: State) ?*Waiter {
+            return @ptrFromInt(@intFromEnum(s));
+        }
+        /// Returns a locked state where `w` is contending the lock.
+        /// If `w` is `null`, returns `.locked_once`.
+        fn fromWaiter(w: ?*Waiter) State {
+            return @enumFromInt(@intFromPtr(w));
+        }
+    };
+    const Waiter = struct {
+        status: std.atomic.Value(Thread.Status),
+        /// Never modified once the `Waiter` is in the linked list.
+        next: ?*Waiter,
+        /// Never modified once the `Waiter` is in the linked list.
+        tid: std.Thread.Id,
+    };
+    fn lock(m: *ParkingMutex) void {
+        state: switch (State.unlocked) { // assume 'unlocked' to optimize for uncontended case
+            .unlocked => continue :state m.state.cmpxchgWeak(
+                .unlocked,
+                .locked_once,
+                .acquire, // acquire lock
+                .monotonic,
+            ) orelse {
+                @branchHint(.likely);
+                return;
+            },
+
+            .locked_once, _ => |last_state| {
+                const old_waiter = last_state.waiter();
+                const self_tid = if (Thread.current) |t| t.id else std.Thread.getCurrentId();
+                var waiter: Waiter = .{
+                    .next = old_waiter,
+                    .status = .init(.{ .cancelation = .parked, .awaitable = .null }),
+                    .tid = self_tid,
+                };
+                if (m.state.cmpxchgWeak(
+                    .fromWaiter(old_waiter),
+                    .fromWaiter(&waiter),
+                    .release, // release `waiter`
+                    .monotonic,
+                )) |new_state| {
+                    continue :state new_state;
+                }
+                // We're now in the list of waiters---park until we're given the lock.
+                park(.none, m, &waiter.status) catch |err| switch (err) {
+                    error.Timeout => unreachable,
+                };
+                // We now hold the lock.
+                assert(waiter.status.load(.monotonic).cancelation == .none);
+                return;
+            },
+        }
+    }
+    fn unlock(m: *ParkingMutex) void {
+        state: switch (State.locked_once) { // assume 'locked_once' to optimize for uncontended case
+            .unlocked => unreachable, // we hold the lock
+
+            .locked_once => continue :state m.state.cmpxchgWeak(
+                .locked_once,
+                .unlocked,
+                .release, // release lock
+                .acquire, // acquire any `Waiter` memory
+            ) orelse {
+                @branchHint(.likely);
+                return;
+            },
+
+            _ => |last_state| {
+                // The logic here does not have ABA problems, and does some accesses non-atomically,
+                // because `Waiter.next` is owned by the lock holder (that's us!) once the waiter is
+                // in the linked list, up until we set `Waiter.status` to `.none`.
+
+                // Run through the waiter list to the end to ensure fairness. This is obviously not
+                // ideal, but it shouldn't be a big deal in practice provided the critical section
+                // is fairly small (so we won't get too many threads contending the mutex at once).
+                // There's a *chance* we could get away with a LIFO queue for our use case, but I
+                // don't wanna risk that.
+                var parent: ?*Waiter = null;
+                var waiter: *Waiter = last_state.waiter().?;
+                while (waiter.next) |next| {
+                    parent = waiter;
+                    waiter = next;
+                }
+                // `waiter` is next in line for the lock. Remove them from the list.
+                if (parent) |p| {
+                    assert(p.next == waiter);
+                    p.next = null;
+                } else {
+                    // We're waking the last waiter, so clear the list head.
+                    if (m.state.cmpxchgWeak(
+                        .fromWaiter(last_state.waiter().?),
+                        .locked_once,
+                        .acquire,
+                        .acquire, // acquire any new `Waiter` memory
+                    )) |new_state| {
+                        continue :state new_state;
+                    }
+                }
+                // Now we're ready to actually hand the lock over to them.
+                const tid = waiter.tid; // load this before the store below potentially invalidates `waiter`
+                waiter.status.store(.{ .cancelation = .none, .awaitable = .null }, .release); // release lock
+                unpark(&.{tid}, m);
+                return;
+            },
+        }
+    }
+};
+
+fn timeoutToWindowsInterval(timeout: Io.Timeout) ?windows.LARGE_INTEGER {
+    // ntdll only supports two combinations:
+    // * real-time (`.real`) sleeps with absolute deadlines
+    // * monotonic (`.awake`/`.boot`) sleeps with relative durations
+    const clock = switch (timeout) {
+        .none => return null,
+        .duration => |d| d.clock,
+        .deadline => |d| d.clock,
+    };
+    switch (clock) {
+        .cpu_process, .cpu_thread => unreachable, // cannot sleep for CPU time
+        .real => {
+            const deadline = switch (timeout) {
+                .none => unreachable,
+                .duration => |d| nowWindows(clock).addDuration(d.raw),
+                .deadline => |d| d.raw,
+            };
+            return @intCast(@max(@divTrunc(deadline.nanoseconds, 100), 0));
+        },
+        .awake, .boot => {
+            const duration = switch (timeout) {
+                .none => unreachable,
+                .duration => |d| d.raw,
+                .deadline => |d| nowWindows(clock).durationTo(d.raw),
+            };
+            return @intCast(@min(@divTrunc(-duration.nanoseconds, 100), -1));
+        },
+    }
+}
+
+fn park(
+    timeout: Io.Timeout,
+    /// This value has no semantic effect, but may allow the OS to optimize the operation.
+    addr_hint: ?*const anyopaque,
+    /// The API on NetBSD and Illumos sucks and can unpark spuriously (well, it *can't*, but signals
+    /// cause an indistinguishable unblock, and libpthread really likes to leave unparks pending).
+    /// As such, on these targets only, this `status` is checked to determine if an unpark is real.
+    /// no way to differentiate
+    status: *std.atomic.Value(Thread.Status),
+) error{Timeout}!void {
     comptime assert(use_parking_futex or use_parking_sleep);
     switch (native_os) {
         .windows => {
-            var timeout_buf: windows.LARGE_INTEGER = undefined;
-            const raw_timeout: ?*windows.LARGE_INTEGER = timeout: switch (timeout) {
-                .none => null,
-                .deadline => |timestamp| continue :timeout .{ .duration = .{
-                    .clock = timestamp.clock,
-                    .raw = (nowWindows(timestamp.clock) catch unreachable).durationTo(timestamp.raw),
-                } },
-                .duration => |duration| {
-                    _ = duration.clock; // Windows only supports monotonic
-                    timeout_buf = @intCast(@divTrunc(-duration.raw.nanoseconds, 100));
-                    break :timeout &timeout_buf;
-                },
-            };
+            const raw_timeout = timeoutToWindowsInterval(timeout);
             // `RtlWaitOnAddress` passes the futex address in as the first argument to this call,
             // but it's unclear what that actually does, especially since `NtAlertThreadByThreadId`
             // does *not* accept the address so the kernel can't really be using it as a hint. An
@@ -17284,7 +17447,10 @@ fn park(timeout: Io.Timeout, addr_hint: ?*const anyopaque) error{Timeout}!void {
             // this parameter). However, to err on the side of caution, let's match the behavior of
             // `RtlWaitOnAddress` and pass the pointer, in case the kernel ever does something
             // stupid such as trying to dereference it.
-            switch (windows.ntdll.NtWaitForAlertByThreadId(addr_hint, raw_timeout)) {
+            switch (windows.ntdll.NtWaitForAlertByThreadId(
+                addr_hint,
+                if (raw_timeout) |*t| t else null,
+            )) {
                 .ALERTED => return,
                 .TIMEOUT => return error.Timeout,
                 else => unreachable,
@@ -17303,19 +17469,23 @@ fn park(timeout: Io.Timeout, addr_hint: ?*const anyopaque) error{Timeout}!void {
                     break :timeout .{ &ts_buf, false, duration.clock == .real };
                 },
             };
-            switch (posix.errno(std.c._lwp_park(
-                if (clock_real) .REALTIME else .MONOTONIC,
-                .{ .ABSTIME = abstime },
-                ts,
-                0,
-                addr_hint,
-                null,
-            ))) {
-                .SUCCESS, .ALREADY, .INTR => return,
-                .TIMEDOUT => return error.Timeout,
-                .INVAL => unreachable,
-                .SRCH => unreachable,
-                else => unreachable,
+            // It's okay to pass the same timeout in a loop. If it's a duration, the OS actually
+            // writes the remaining time into the buffer when the syscall returns.
+            while (status.load(.monotonic).cancelation == .parked) {
+                switch (posix.errno(std.c._lwp_park(
+                    if (clock_real) .REALTIME else .MONOTONIC,
+                    .{ .ABSTIME = abstime },
+                    ts,
+                    0,
+                    addr_hint,
+                    null,
+                ))) {
+                    .SUCCESS, .ALREADY, .INTR => {},
+                    .TIMEDOUT => return error.Timeout,
+                    .INVAL => unreachable,
+                    .SRCH => unreachable,
+                    else => unreachable,
+                }
             }
         },
         .illumos => @panic("TODO: illumos lwp_park"),
@@ -17323,24 +17493,8 @@ fn park(timeout: Io.Timeout, addr_hint: ?*const anyopaque) error{Timeout}!void {
     }
 }
 
-fn deadlineToWindowsInterval(t: *Io.Threaded, deadline: Io.Clock.Timestamp) windows.LARGE_INTEGER {
-    // ntdll only supports two combinations:
-    // * real-time (`.real`) sleeps with absolute deadlines
-    // * monotonic (`.awake`/`.boot`) sleeps with relative durations
-    switch (deadline.clock) {
-        .cpu_process, .cpu_thread => return 0,
-        .real => {
-            return @intCast(@max(@divTrunc(deadline.raw.nanoseconds, 100), 0));
-        },
-        .awake, .boot => {
-            const duration = deadline.durationFromNow(ioBasic(t));
-            return @intCast(@min(@divTrunc(-duration.raw.nanoseconds, 100), -1));
-        },
-    }
-}
-
 const UnparkTid = switch (native_os) {
-    // `NtAlertMultipleThreadByThreadId` is weird and wants 64-bit thread handles?
+    // `NtAlertMultipleThreadByThreadId` is weird and wants 64-bit thread IDs?
     .windows => usize,
     else => std.Thread.Id,
 };
-- 
2.54.0


From d45f9aca14bd36a710293b3d0092039fd91a571b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Feb 2026 20:06:50 -0800
Subject: [PATCH 191/499] std.Thread: delete Mutex.Recursive

Replaced by the lockStderr functions of std.Io. Trying to make
`std.process.stderr_thread_mutex` be a bridge across different Io
implementations didn't work in practice.
---
 lib/std/Io.zig                     |  3 +-
 lib/std/Io/IoUring.zig             |  2 +-
 lib/std/Io/Kqueue.zig              |  2 +-
 lib/std/Io/Threaded.zig            | 39 +++++++++++++---
 lib/std/Thread.zig                 | 14 +-----
 lib/std/Thread/Mutex/Recursive.zig | 72 ------------------------------
 lib/std/process.zig                |  7 ---
 7 files changed, 39 insertions(+), 100 deletions(-)
 delete mode 100644 lib/std/Thread/Mutex/Recursive.zig

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 92327e0f5d16f0e83cd3cfabe0c86f463a68f03c..0eb1df2d1a7decb3787d74c6baeb7c49a507a4fe 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -2160,8 +2160,7 @@ pub const LockedStderr = struct {
 
 /// For doing application-level writes to the standard error stream.
 /// Coordinates also with debug-level writes that are ignorant of Io interface
-/// and implementations. When this returns, `std.process.stderr_thread_mutex`
-/// will be locked.
+/// and implementations.
 ///
 /// See also:
 /// * `tryLockStderr`
diff --git a/lib/std/Io/IoUring.zig b/lib/std/Io/IoUring.zig
index 81cdc242018d6129a52afd0b4232006f52811d77..8ff3ae22ef230ab9a503c6d9867347e961c65008 100644
--- a/lib/std/Io/IoUring.zig
+++ b/lib/std/Io/IoUring.zig
@@ -10,7 +10,7 @@ const IoUring = std.os.linux.IoUring;
 
 /// Must be a thread-safe allocator.
 gpa: Allocator,
-mutex: std.Thread.Mutex,
+mutex: Io.Mutex,
 main_fiber_buffer: [@sizeOf(Fiber) + Fiber.max_result_size]u8 align(@alignOf(Fiber)),
 threads: Thread.List,
 
diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig
index f998d5cef8b41461ad47cbcbe31595acbc557927..23cd1b39286ac6f4a0c5041b5b94b9c2896121b1 100644
--- a/lib/std/Io/Kqueue.zig
+++ b/lib/std/Io/Kqueue.zig
@@ -15,7 +15,7 @@ const posix = std.posix;
 
 /// Must be a thread-safe allocator.
 gpa: Allocator,
-mutex: std.Thread.Mutex,
+mutex: Io.Mutex,
 main_fiber_buffer: [@sizeOf(Fiber) + Fiber.max_result_size]u8 align(@alignOf(Fiber)),
 threads: Thread.List,
 
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 4a84a782b641b13244f0ea3d170b7128c0e56c15..c1c63067817b99ea620173ce6807e86ce279cd9e 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -67,6 +67,9 @@ stderr_writer: File.Writer = .{
 },
 stderr_mode: Io.Terminal.Mode = .no_color,
 stderr_writer_initialized: bool = false,
+stderr_mutex: Io.Mutex = .init,
+stderr_mutex_locker: std.Thread.Id = Thread.invalid_id,
+stderr_mutex_lock_count: usize = 0,
 
 argv0: Argv0,
 environ: Environ,
@@ -689,6 +692,13 @@ const Thread = struct {
 
     threadlocal var current: ?*Thread = null;
 
+    /// A value that does not alias any other thread id.
+    const invalid_id: std.Thread.Id = std.math.maxInt(std.Thread.Id);
+
+    fn currentId() std.Thread.Id {
+        return if (current) |t| t.id else std.Thread.getCurrentId();
+    }
+
     /// The thread is neither in a syscall nor entering one, but we want to check for cancelation
     /// anyway. If there is a pending cancel request, acknowledge it and return `error.Canceled`.
     fn checkCancel() Io.Cancelable!void {
@@ -13502,15 +13512,29 @@ fn netLookupFallible(
 
 fn lockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    // Only global mutex since this is Threaded.
-    process.stderr_thread_mutex.lock();
+    const current_thread_id = Thread.currentId();
+
+    if (@atomicLoad(std.Thread.Id, &t.stderr_mutex_locker, .unordered) != current_thread_id) {
+        mutexLock(&t.stderr_mutex);
+        assert(t.stderr_mutex_lock_count == 0);
+        @atomicStore(std.Thread.Id, &t.stderr_mutex_locker, current_thread_id, .unordered);
+    }
+    t.stderr_mutex_lock_count += 1;
+
     return initLockedStderr(t, terminal_mode);
 }
 
 fn tryLockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!?Io.LockedStderr {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    // Only global mutex since this is Threaded.
-    if (!process.stderr_thread_mutex.tryLock()) return null;
+    const current_thread_id = Thread.currentId();
+
+    if (@atomicLoad(std.Thread.Id, &t.stderr_mutex_locker, .unordered) != current_thread_id) {
+        if (!t.stderr_mutex.tryLock()) return null;
+        assert(t.stderr_mutex_lock_count == 0);
+        @atomicStore(std.Thread.Id, &t.stderr_mutex_locker, current_thread_id, .unordered);
+    }
+    t.stderr_mutex_lock_count += 1;
+
     return try initLockedStderr(t, terminal_mode);
 }
 
@@ -13541,7 +13565,12 @@ fn unlockStderr(userdata: ?*anyopaque) void {
     };
     t.stderr_writer.interface.end = 0;
     t.stderr_writer.interface.buffer = &.{};
-    process.stderr_thread_mutex.unlock();
+
+    t.stderr_mutex_lock_count -= 1;
+    if (t.stderr_mutex_lock_count == 0) {
+        @atomicStore(std.Thread.Id, &t.stderr_mutex_locker, Thread.invalid_id, .unordered);
+        mutexUnlock(&t.stderr_mutex);
+    }
 }
 
 fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize {
diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 3191dd26ce4563cb10ee2803edf49c9ae59c3e1d..4d0e992e975b847ae0332172a1505f2924a9d906 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -1,6 +1,5 @@
-//! This struct represents a kernel thread, and acts as a namespace for
-//! concurrency primitives that operate on kernel threads. For concurrency
-//! primitives that interact with the I/O interface, see `std.Io`.
+//! This struct represents a kernel thread.
+const Thread = @This();
 
 const builtin = @import("builtin");
 const target = builtin.target;
@@ -14,13 +13,8 @@ const posix = std.posix;
 const windows = std.os.windows;
 const testing = std.testing;
 
-pub const Mutex = struct {
-    pub const Recursive = @import("Thread/Mutex/Recursive.zig");
-};
-
 pub const use_pthreads = native_os != .windows and native_os != .wasi and builtin.link_libc;
 
-const Thread = @This();
 const Impl = if (native_os == .windows)
     WindowsThreadImpl
 else if (use_pthreads)
@@ -1604,10 +1598,6 @@ test "setName, getName" {
     thread.join();
 }
 
-test {
-    _ = Mutex;
-}
-
 fn testIncrementNotify(io: Io, value: *usize, event: *Io.Event) void {
     value.* += 1;
     event.set(io);
diff --git a/lib/std/Thread/Mutex/Recursive.zig b/lib/std/Thread/Mutex/Recursive.zig
deleted file mode 100644
index 8fa0563fb36b1eeaa0edd9c7d9b9d864b379db73..0000000000000000000000000000000000000000
--- a/lib/std/Thread/Mutex/Recursive.zig
+++ /dev/null
@@ -1,72 +0,0 @@
-//! A synchronization primitive enforcing atomic access to a shared region of
-//! code known as the "critical section".
-//!
-//! Equivalent to `std.Mutex` except it allows the same thread to obtain the
-//! lock multiple times.
-//!
-//! A recursive mutex is an abstraction layer on top of a regular mutex;
-//! therefore it is recommended to use instead `std.Mutex` unless there is a
-//! specific reason a recursive mutex is warranted.
-const Recursive = @This();
-
-const std = @import("../../std.zig");
-const Io = std.Io;
-const assert = std.debug.assert;
-
-mutex: Io.Mutex,
-thread_id: std.Thread.Id,
-lock_count: usize,
-
-pub const init: Recursive = .{
-    .mutex = .init,
-    .thread_id = invalid_thread_id,
-    .lock_count = 0,
-};
-
-/// Acquires the `Mutex` without blocking the caller's thread.
-///
-/// Returns `false` if the calling thread would have to block to acquire it.
-///
-/// Otherwise, returns `true` and the caller should `unlock()` the Mutex to release it.
-pub fn tryLock(r: *Recursive) bool {
-    const current_thread_id = std.Thread.getCurrentId();
-    if (@atomicLoad(std.Thread.Id, &r.thread_id, .unordered) != current_thread_id) {
-        if (!r.mutex.tryLock()) return false;
-        assert(r.lock_count == 0);
-        @atomicStore(std.Thread.Id, &r.thread_id, current_thread_id, .unordered);
-    }
-    r.lock_count += 1;
-    return true;
-}
-
-/// Acquires the `Mutex`, blocking the current thread while the mutex is
-/// already held by another thread.
-///
-/// The `Mutex` can be held multiple times by the same thread.
-///
-/// Once acquired, call `unlock` on the `Mutex` to release it, regardless
-/// of whether the lock was already held by the same thread.
-pub fn lock(r: *Recursive) void {
-    const current_thread_id = std.Thread.getCurrentId();
-    if (@atomicLoad(std.Thread.Id, &r.thread_id, .unordered) != current_thread_id) {
-        Io.Threaded.mutexLock(&r.mutex);
-        assert(r.lock_count == 0);
-        @atomicStore(std.Thread.Id, &r.thread_id, current_thread_id, .unordered);
-    }
-    r.lock_count += 1;
-}
-
-/// Releases the `Mutex` which was previously acquired with `lock` or `tryLock`.
-///
-/// It is undefined behavior to unlock from a different thread that it was
-/// locked from.
-pub fn unlock(r: *Recursive) void {
-    r.lock_count -= 1;
-    if (r.lock_count == 0) {
-        @atomicStore(std.Thread.Id, &r.thread_id, invalid_thread_id, .unordered);
-        Io.Threaded.mutexUnlock(&r.mutex);
-    }
-}
-
-/// A value that does not alias any other thread id.
-const invalid_thread_id: std.Thread.Id = std.math.maxInt(std.Thread.Id);
diff --git a/lib/std/process.zig b/lib/std/process.zig
index d09239dbc2e0de28b0fd9f51a886b241fdbf4b21..618d7f8f5bc3cbc1b62e05693d5d550fdcbb5eb1 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -20,13 +20,6 @@ pub const Args = @import("process/Args.zig");
 pub const Environ = @import("process/Environ.zig");
 pub const Preopens = @import("process/Preopens.zig");
 
-/// This is the global, process-wide protection to coordinate stderr writes.
-///
-/// The primary motivation for recursive mutex here is so that a panic while
-/// stderr mutex is held still dumps the stack trace and other debug
-/// information.
-pub var stderr_thread_mutex: std.Thread.Mutex.Recursive = .init;
-
 /// A standard set of pre-initialized useful APIs for programs to take
 /// advantage of. This is the type of the first parameter of the main function.
 /// Applications wanting more flexibility can accept `Init.Minimal` instead.
-- 
2.54.0


From fce7878a9149caa80433e6d650e0bd7f60d345fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Feb 2026 11:11:39 +0100
Subject: [PATCH 192/499] test: disable hexagon-linux-musl C ABI tests for now

https://gitlab.com/qemu-project/qemu/-/issues/3291
---
 test/tests.zig | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/test/tests.zig b/test/tests.zig
index ede30a131d804934f8c0b63355965b80c168c35f..81fc9ae7d074971c31f80d11042e66ed5dc55a95 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -1714,13 +1714,14 @@ const c_abi_targets = blk: {
             },
         },
 
-        .{
-            .target = .{
-                .cpu_arch = .hexagon,
-                .os_tag = .linux,
-                .abi = .musl,
-            },
-        },
+        // https://gitlab.com/qemu-project/qemu/-/issues/3291
+        // .{
+        //     .target = .{
+        //         .cpu_arch = .hexagon,
+        //         .os_tag = .linux,
+        //         .abi = .musl,
+        //     },
+        // },
 
         .{
             .target = .{
-- 
2.54.0


From ffc6da29e3fa53a9c81bcb8af7467cdd6345538f Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Fri, 30 Jan 2026 13:07:41 -0500
Subject: [PATCH 193/499] std.Io.Threaded: implement and cleanup windows
 codepaths

---
 build.zig                              |   1 +
 lib/std/Build/Watch.zig                |  18 +-
 lib/std/Io/Threaded.zig                | 716 +++++++++++++------------
 lib/std/Io/Threaded/test.zig           |  16 +-
 lib/std/Progress.zig                   |  37 +-
 lib/std/Thread.zig                     |   6 +-
 lib/std/mem/Allocator.zig              |  15 +-
 lib/std/os/windows.zig                 | 269 +---------
 lib/std/os/windows/kernel32.zig        | 108 ----
 lib/std/os/windows/ntdll.zig           |  17 +-
 lib/std/process/Environ.zig            | 706 ++++++++++++++----------
 lib/std/start.zig                      |  17 +-
 test/standalone/env_vars/main.zig      |  23 -
 test/standalone/windows_argv/fuzz.zig  |   9 +-
 test/standalone/windows_spawn/main.zig |   7 +-
 15 files changed, 920 insertions(+), 1045 deletions(-)

diff --git a/build.zig b/build.zig
index 84cbba38bdb6026dc3691463ac40d1fcad33419e..3df6969ddad159576ac3cb06c39c25c6586aa17c 100644
--- a/build.zig
+++ b/build.zig
@@ -1498,6 +1498,7 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
     defer dir.close(io);
 
     var wf = b.addWriteFiles();
+    b.step("test-docs", "Test code snippets from the docs").dependOn(&wf.step);
 
     var it = dir.iterateAssumeFirstIteration();
     while (it.next(io) catch @panic("failed to read dir")) |entry| {
diff --git a/lib/std/Build/Watch.zig b/lib/std/Build/Watch.zig
index c4ac62b216604a89ed3a91c078bbe17bca8826ce..5920a227cb192f75c7e8224e211240d814acaf0b 100644
--- a/lib/std/Build/Watch.zig
+++ b/lib/std/Build/Watch.zig
@@ -366,15 +366,7 @@ const Os = switch (builtin.os.tag) {
                     .MaximumLength = @intCast(path_len_bytes),
                     .Buffer = @constCast(sub_path_w.span().ptr),
                 };
-                var attr = windows.OBJECT_ATTRIBUTES{
-                    .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
-                    .RootDirectory = if (std.fs.path.isAbsoluteWindowsW(sub_path_w.span())) null else root_fd,
-                    .Attributes = .{},
-                    .ObjectName = &nt_name,
-                    .SecurityDescriptor = null,
-                    .SecurityQualityOfService = null,
-                };
-                var io: windows.IO_STATUS_BLOCK = undefined;
+                var iosb: windows.IO_STATUS_BLOCK = undefined;
 
                 switch (windows.ntdll.NtCreateFile(
                     &dir_handle,
@@ -385,14 +377,18 @@ const Os = switch (builtin.os.tag) {
                         .STANDARD = .{ .SYNCHRONIZE = true },
                         .GENERIC = .{ .READ = true },
                     },
-                    &attr,
-                    &io,
+                    &.{
+                        .RootDirectory = if (std.fs.path.isAbsoluteWindowsW(sub_path_w.span())) null else root_fd,
+                        .ObjectName = &nt_name,
+                    },
+                    &iosb,
                     null,
                     .{},
                     .VALID_FLAGS,
                     .OPEN,
                     .{
                         .DIRECTORY_FILE = true,
+                        .IO = .ASYNCHRONOUS,
                         .OPEN_FOR_BACKUP_INTENT = true,
                     },
                     null,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c1c63067817b99ea620173ce6807e86ce279cd9e..49132e79189842591b6b0a443bcd6cecd5a4fc85 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -76,6 +76,7 @@ environ: Environ,
 
 null_file: NullFile = .{},
 random_file: RandomFile = .{},
+pipe_file: PipeFile = .{},
 
 csprng: Csprng = .{},
 
@@ -121,7 +122,7 @@ pub const Argv0 = switch (native_os) {
 
 const Environ = struct {
     /// Unmodified data directly from the OS.
-    process_environ: process.Environ = .empty,
+    process_environ: process.Environ,
     /// Protected by `mutex`. Determines whether the other fields have been
     /// memoized based on `process_environ`.
     initialized: bool = false,
@@ -131,13 +132,15 @@ const Environ = struct {
     /// Protected by `mutex`. Memoized based on `process_environ`.
     string: String = .{},
     /// ZIG_PROGRESS
-    zig_progress_handle: std.Progress.ParentFileError!u31 = error.EnvironmentVariableMissing,
+    zig_progress_file: std.Progress.ParentFileError!File = error.EnvironmentVariableMissing,
     /// Protected by `mutex`. Tracks the problem, if any, that occurred when
     /// trying to scan environment variables.
     ///
     /// Errors are only possible on WASI.
     err: ?Error = null,
 
+    pub const empty: Environ = .{ .process_environ = .empty };
+
     pub const Error = Allocator.Error || Io.UnexpectedError;
 
     pub const Exist = struct {
@@ -193,6 +196,24 @@ pub const RandomFile = switch (native_os) {
     },
 };
 
+pub const PipeFile = switch (native_os) {
+    .windows => struct {
+        handle: ?windows.HANDLE = null,
+
+        fn deinit(this: *@This()) void {
+            if (this.handle) |handle| {
+                windows.CloseHandle(handle);
+                this.handle = null;
+            }
+        }
+    },
+    else => struct {
+        fn deinit(this: @This()) void {
+            _ = this;
+        }
+    },
+};
+
 pub const Pid = if (native_os == .linux) enum(posix.pid_t) {
     unknown = 0,
     _,
@@ -1496,7 +1517,9 @@ pub const init_single_threaded: Threaded = .{
     .old_sig_pipe = undefined,
     .have_signal_handler = false,
     .argv0 = .empty,
-    .environ = .{},
+    .environ = .{ .process_environ = .{
+        .block = if (process.Environ.Block == process.Environ.GlobalBlock) .global else .empty,
+    } },
     .worker_threads = .init(null),
     .disable_memory_mapping = false,
 };
@@ -1531,6 +1554,7 @@ pub fn deinit(t: *Threaded) void {
     }
     t.null_file.deinit();
     t.random_file.deinit();
+    t.pipe_file.deinit();
     t.* = undefined;
 }
 
@@ -1573,14 +1597,7 @@ fn worker(t: *Threaded) void {
                     },
                 },
             },
-            &.{
-                .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
-                .RootDirectory = null,
-                .ObjectName = null,
-                .Attributes = .{},
-                .SecurityDescriptor = null,
-                .SecurityQualityOfService = null,
-            },
+            &.{ .ObjectName = null },
             &windows.teb().ClientId,
         ) == .SUCCESS);
     }
@@ -3376,12 +3393,8 @@ fn dirCreateDirPathOpenWindows(
                 },
             },
             &.{
-                .Length = @sizeOf(w.OBJECT_ATTRIBUTES),
                 .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-                .Attributes = .{},
                 .ObjectName = &nt_name,
-                .SecurityDescriptor = null,
-                .SecurityQualityOfService = null,
             },
             &io_status_block,
             null,
@@ -4063,13 +4076,9 @@ fn dirAccessWindows(
         .MaximumLength = path_len_bytes,
         .Buffer = @constCast(sub_path_w.ptr),
     };
-    var attr: windows.OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
+    const attr: windows.OBJECT_ATTRIBUTES = .{
         .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .Attributes = .{},
         .ObjectName = &nt_name,
-        .SecurityDescriptor = null,
-        .SecurityQualityOfService = null,
     };
     var basic_info: windows.FILE.BASIC_INFORMATION = undefined;
     const syscall: Syscall = try .start();
@@ -4285,14 +4294,8 @@ fn dirCreateFileWindows(
         .Buffer = @constCast(sub_path_w.ptr),
     };
     const attr: windows.OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
         .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .Attributes = .{
-            .INHERIT = false,
-        },
         .ObjectName = &nt_name,
-        .SecurityDescriptor = null,
-        .SecurityQualityOfService = null,
     };
     const create_disposition: windows.FILE.CREATE_DISPOSITION = if (flags.exclusive)
         .CREATE
@@ -4905,17 +4908,6 @@ pub fn dirOpenFileWtf16(
         .MaximumLength = path_len_bytes,
         .Buffer = @constCast(sub_path_w.ptr),
     };
-    var attr: w.OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(w.OBJECT_ATTRIBUTES),
-        .RootDirectory = dir_handle,
-        .Attributes = .{
-            // TODO should we set INHERIT=false?
-            //.INHERIT = false,
-        },
-        .ObjectName = &nt_name,
-        .SecurityDescriptor = null,
-        .SecurityQualityOfService = null,
-    };
     var io_status_block: w.IO_STATUS_BLOCK = undefined;
 
     // There are multiple kernel bugs being worked around with retries.
@@ -4934,7 +4926,10 @@ pub fn dirOpenFileWtf16(
                     .WRITE = flags.isWrite(),
                 },
             },
-            &attr,
+            &.{
+                .RootDirectory = dir_handle,
+                .ObjectName = &nt_name,
+            },
             &io_status_block,
             null,
             .{ .NORMAL = true },
@@ -5302,12 +5297,8 @@ pub fn dirOpenDirWindows(
             },
         },
         &.{
-            .Length = @sizeOf(w.OBJECT_ATTRIBUTES),
             .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-            .Attributes = .{},
             .ObjectName = &nt_name,
-            .SecurityDescriptor = null,
-            .SecurityQualityOfService = null,
         },
         &io_status_block,
         null,
@@ -6517,12 +6508,8 @@ fn dirDeleteWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, remov
                 .SYNCHRONIZE = true,
             } },
             &.{
-                .Length = @sizeOf(w.OBJECT_ATTRIBUTES),
                 .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-                .Attributes = .{},
                 .ObjectName = &nt_name,
-                .SecurityDescriptor = null,
-                .SecurityQualityOfService = null,
             },
             &io_status_block,
             null,
@@ -6531,6 +6518,7 @@ fn dirDeleteWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, remov
             .OPEN,
             .{
                 .DIRECTORY_FILE = remove_dir,
+                .IO = .SYNCHRONOUS_NONALERT,
                 .NON_DIRECTORY_FILE = !remove_dir,
                 .OPEN_REPARSE_POINT = true, // would we ever want to delete the target instead?
             },
@@ -7342,14 +7330,8 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
         .Buffer = @constCast(sub_path_w.ptr),
     };
     const attr: windows.OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
         .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .Attributes = .{
-            .INHERIT = false,
-        },
         .ObjectName = &nt_name,
-        .SecurityDescriptor = null,
-        .SecurityQualityOfService = null,
     };
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var result_handle: windows.HANDLE = undefined;
@@ -7906,24 +7888,19 @@ fn fileSyncWindows(userdata: ?*anyopaque, file: File) File.SyncError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
 
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     const syscall: Syscall = try .start();
     while (true) {
-        if (windows.kernel32.FlushFileBuffers(file.handle) != 0) {
-            return syscall.finish();
-        }
-        switch (windows.GetLastError()) {
-            .SUCCESS => unreachable, // `FlushFileBuffers` returned nonzero
+        switch (windows.ntdll.NtFlushBuffersFile(file.handle, &io_status_block)) {
+            .SUCCESS => break syscall.finish(),
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
             .INVALID_HANDLE => unreachable,
             .ACCESS_DENIED => return syscall.fail(error.AccessDenied), // a sync was performed but the system couldn't update the access time
-            .UNEXP_NET_ERR => return syscall.fail(error.InputOutput),
-            .OPERATION_ABORTED => {
-                try syscall.checkCancel();
-                continue;
-            },
-            else => |err| {
-                syscall.finish();
-                return windows.unexpectedError(err);
-            },
+            .UNEXPECTED_NETWORK_ERROR => return syscall.fail(error.InputOutput),
+            else => |status| return syscall.unexpectedNtstatus(status),
         }
     }
 }
@@ -14556,22 +14533,39 @@ fn scanEnviron(t: *Threaded) void {
             comptime assert(@sizeOf(Environ.String) == 0);
         }
     } else {
-        for (t.environ.process_environ.block) |opt_line| {
-            const line = opt_line.?;
-            var line_i: usize = 0;
-            while (line[line_i] != 0 and line[line_i] != '=') : (line_i += 1) {}
-            const key = line[0..line_i];
+        for (t.environ.process_environ.block.slice) |opt_entry| {
+            const entry = opt_entry.?;
+            var entry_i: usize = 0;
+            while (entry[entry_i] != 0 and entry[entry_i] != '=') : (entry_i += 1) {}
+            const key = entry[0..entry_i];
 
-            var end_i: usize = line_i;
-            while (line[end_i] != 0) : (end_i += 1) {}
-            const value = line[line_i + 1 .. end_i :0];
+            var end_i: usize = entry_i;
+            while (entry[end_i] != 0) : (end_i += 1) {}
+            const value = entry[entry_i + 1 .. end_i :0];
 
             if (std.mem.eql(u8, key, "NO_COLOR")) {
                 t.environ.exist.NO_COLOR = true;
             } else if (std.mem.eql(u8, key, "CLICOLOR_FORCE")) {
                 t.environ.exist.CLICOLOR_FORCE = true;
             } else if (std.mem.eql(u8, key, "ZIG_PROGRESS")) {
-                t.environ.zig_progress_handle = std.fmt.parseInt(u31, value, 10) catch error.UnrecognizedFormat;
+                t.environ.zig_progress_file = file: {
+                    const int = std.fmt.parseInt(switch (@typeInfo(File.Handle)) {
+                        .int => |int_info| @Int(
+                            .unsigned,
+                            int_info.bits - @intFromBool(int_info.signedness == .signed),
+                        ),
+                        .pointer => usize,
+                        else => break :file error.UnsupportedOperation,
+                    }, value, 10) catch break :file error.UnrecognizedFormat;
+                    break :file .{
+                        .handle = switch (@typeInfo(File.Handle)) {
+                            .int => int,
+                            .pointer => @ptrFromInt(int),
+                            else => comptime unreachable,
+                        },
+                        .flags = .{ .nonblocking = true },
+                    };
+                };
             } else inline for (@typeInfo(Environ.String).@"struct".fields) |field| {
                 if (std.mem.eql(u8, key, field.name)) @field(t.environ.string, field.name) = value;
             }
@@ -14594,19 +14588,17 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
     for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
 
-    const envp: [*:null]const ?[*:0]const u8 = m: {
+    const env_block = env_block: {
         const prog_fd: i32 = -1;
-        if (options.environ_map) |environ_map| {
-            break :m (try environ_map.createBlockPosix(arena, .{
-                .zig_progress_fd = prog_fd,
-            })).ptr;
-        }
-        break :m (try process.Environ.createBlockPosix(t.environ.process_environ, arena, .{
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
             .zig_progress_fd = prog_fd,
-        })).ptr;
+        });
+        break :env_block try t.environ.process_environ.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
     };
 
-    return posixExecv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, envp, PATH);
+    return posixExecv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
 }
 
 fn processReplacePath(userdata: ?*anyopaque, dir: Dir, options: process.ReplaceOptions) process.ReplaceError {
@@ -14705,16 +14697,14 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     const prog_fileno = 3;
     comptime assert(@max(posix.STDIN_FILENO, posix.STDOUT_FILENO, posix.STDERR_FILENO) + 1 == prog_fileno);
 
-    const envp: [*:null]const ?[*:0]const u8 = m: {
+    const env_block = env_block: {
         const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;
-        if (options.environ_map) |environ_map| {
-            break :m (try environ_map.createBlockPosix(arena, .{
-                .zig_progress_fd = prog_fd,
-            })).ptr;
-        }
-        break :m (try process.Environ.createBlockPosix(t.environ.process_environ, arena, .{
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
             .zig_progress_fd = prog_fd,
-        })).ptr;
+        });
+        break :env_block try t.environ.process_environ.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
     };
 
     // This pipe communicates to the parent errors in the child between `fork` and `execvpe`.
@@ -14797,7 +14787,7 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
             }
         }
 
-        const err = posixExecv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, envp, PATH);
+        const err = posixExecv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
         forkBail(ep1, err);
     }
 
@@ -14811,7 +14801,6 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     if (options.stderr == .pipe) posix.close(stderr_pipe[1]);
 
     if (prog_pipe[1] != -1) posix.close(prog_pipe[1]);
-
     options.progress_node.setIpcFd(prog_pipe[0]);
 
     return .{
@@ -14935,42 +14924,44 @@ fn childKillWindows(t: *Threaded, child: *process.Child, exit_code: windows.UINT
                 // some rare edge cases where our process handle no longer has the
                 // PROCESS_TERMINATE access right, so let's do another check to make
                 // sure the process is really no longer running:
-                windows.WaitForSingleObjectEx(handle, 0, false) catch return error.AccessDenied;
-                return error.AlreadyTerminated;
+                const minimal_timeout: windows.LARGE_INTEGER = -1;
+                switch (windows.ntdll.NtWaitForSingleObject(handle, windows.FALSE, &minimal_timeout)) {
+                    .SUCCESS => return error.AlreadyTerminated,
+                    else => return error.AccessDenied,
+                }
             },
             else => |err| return windows.unexpectedError(err),
         }
     }
-    _ = windows.kernel32.WaitForSingleObjectEx(handle, windows.INFINITE, windows.FALSE);
+    const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
+    _ = windows.ntdll.NtWaitForSingleObject(handle, windows.FALSE, &infinite_timeout);
     childCleanupWindows(child);
 }
 
 fn childWaitWindows(child: *process.Child) process.Child.WaitError!process.Child.Term {
     const handle = child.id.?;
 
-    const syscall: Syscall = try .start();
-    while (true) switch (windows.kernel32.WaitForSingleObjectEx(handle, windows.INFINITE, windows.FALSE)) {
-        windows.WAIT_OBJECT_0 => break syscall.finish(),
-        windows.WAIT_ABANDONED, windows.WAIT_TIMEOUT => {
-            try syscall.checkCancel();
+    const alertable_syscall: AlertableSyscall = try .start();
+    const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
+    while (true) switch (windows.ntdll.NtWaitForSingleObject(handle, windows.TRUE, &infinite_timeout)) {
+        windows.NTSTATUS.WAIT_0 => break alertable_syscall.finish(),
+        .USER_APC, .ALERTED, .TIMEOUT => {
+            try alertable_syscall.checkCancel();
             continue;
         },
-        windows.WAIT_FAILED => {
-            syscall.finish();
-            switch (windows.GetLastError()) {
-                else => |err| return windows.unexpectedError(err),
-            }
-        },
-        else => return syscall.fail(error.Unexpected),
+        else => |status| return alertable_syscall.unexpectedNtstatus(status),
     };
 
-    const term: process.Child.Term = x: {
-        var exit_code: windows.DWORD = undefined;
-        if (windows.kernel32.GetExitCodeProcess(handle, &exit_code) == 0) {
-            break :x .{ .unknown = 0 };
-        } else {
-            break :x .{ .exited = @as(u8, @truncate(exit_code)) };
-        }
+    var info: windows.PROCESS_BASIC_INFORMATION = undefined;
+    const term: process.Child.Term = switch (windows.ntdll.NtQueryInformationProcess(
+        handle,
+        .BasicInformation,
+        &info,
+        @sizeOf(windows.PROCESS_BASIC_INFORMATION),
+        null,
+    )) {
+        .SUCCESS => .{ .exited = @as(u8, @truncate(@intFromEnum(info.ExitStatus))) },
+        else => .{ .unknown = 0 },
     };
 
     childCleanupWindows(child);
@@ -15233,88 +15224,70 @@ fn setUpChildIo(stdio: process.SpawnOptions.StdIo, pipe_fd: i32, std_fileno: i32
 fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
 
-    var saAttr: windows.SECURITY_ATTRIBUTES = .{
-        .nLength = @sizeOf(windows.SECURITY_ATTRIBUTES),
-        .bInheritHandle = windows.TRUE,
-        .lpSecurityDescriptor = null,
-    };
-
     const any_ignore =
         options.stdin == .ignore or
         options.stdout == .ignore or
         options.stderr == .ignore;
+    const nul_handle = if (any_ignore) try getNulDevice(t) else undefined;
 
-    const nul_handle = if (any_ignore) try getNulHandle(t) else undefined;
+    const any_inherit =
+        options.stdin == .inherit or
+        options.stdout == .inherit or
+        options.stderr == .inherit;
+    const peb = if (any_inherit) windows.peb() else undefined;
 
-    var g_hChildStd_IN_Rd: ?windows.HANDLE = null;
-    var g_hChildStd_IN_Wr: ?windows.HANDLE = null;
-    switch (options.stdin) {
-        .pipe => {
-            try windowsMakePipeIn(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr);
-        },
-        .ignore => {
-            g_hChildStd_IN_Rd = nul_handle;
-        },
-        .inherit => {
-            g_hChildStd_IN_Rd = windows.GetStdHandle(windows.STD_INPUT_HANDLE) catch null;
-        },
-        .close => {
-            g_hChildStd_IN_Rd = null;
-        },
-        .file => @panic("TODO implement passing file stdio in processSpawnWindows"),
-    }
-    errdefer if (options.stdin == .pipe) {
-        windowsDestroyPipe(g_hChildStd_IN_Rd, g_hChildStd_IN_Wr);
-    };
+    const stdin_pipe = if (options.stdin == .pipe) try t.windowsCreatePipe(.{
+        .server = .{ .attributes = .{ .INHERIT = false }, .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+        .client = .{ .attributes = .{ .INHERIT = true }, .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+        .outbound = true,
+    }) else undefined;
+    errdefer if (options.stdin == .pipe) for (stdin_pipe) |handle| windows.CloseHandle(handle);
 
-    var g_hChildStd_OUT_Rd: ?windows.HANDLE = null;
-    var g_hChildStd_OUT_Wr: ?windows.HANDLE = null;
-    switch (options.stdout) {
-        .pipe => {
-            try windowsMakeAsyncPipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr);
-        },
-        .ignore => {
-            g_hChildStd_OUT_Wr = nul_handle;
-        },
-        .inherit => {
-            g_hChildStd_OUT_Wr = windows.GetStdHandle(windows.STD_OUTPUT_HANDLE) catch null;
-        },
-        .close => {
-            g_hChildStd_OUT_Wr = null;
-        },
-        .file => @panic("TODO implement passing file stdio in processSpawnWindows"),
-    }
-    errdefer if (options.stdout == .pipe) {
-        windowsDestroyPipe(g_hChildStd_OUT_Rd, g_hChildStd_OUT_Wr);
-    };
+    const stdout_pipe = if (options.stdout == .pipe) try t.windowsCreatePipe(.{
+        .server = .{ .attributes = .{ .INHERIT = false }, .mode = .{ .IO = .ASYNCHRONOUS } },
+        .client = .{ .attributes = .{ .INHERIT = true }, .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+        .inbound = true,
+    }) else undefined;
+    errdefer if (options.stdout == .pipe) for (stdout_pipe) |handle| windows.CloseHandle(handle);
 
-    var g_hChildStd_ERR_Rd: ?windows.HANDLE = null;
-    var g_hChildStd_ERR_Wr: ?windows.HANDLE = null;
-    switch (options.stderr) {
-        .pipe => {
-            try windowsMakeAsyncPipe(&g_hChildStd_ERR_Rd, &g_hChildStd_ERR_Wr, &saAttr);
-        },
-        .ignore => {
-            g_hChildStd_ERR_Wr = nul_handle;
-        },
-        .inherit => {
-            g_hChildStd_ERR_Wr = windows.GetStdHandle(windows.STD_ERROR_HANDLE) catch null;
-        },
-        .close => {
-            g_hChildStd_ERR_Wr = null;
-        },
-        .file => @panic("TODO implement passing file stdio in processSpawnWindows"),
-    }
-    errdefer if (options.stderr == .pipe) {
-        windowsDestroyPipe(g_hChildStd_ERR_Rd, g_hChildStd_ERR_Wr);
-    };
+    const stderr_pipe = if (options.stderr == .pipe) try t.windowsCreatePipe(.{
+        .server = .{ .attributes = .{ .INHERIT = false }, .mode = .{ .IO = .ASYNCHRONOUS } },
+        .client = .{ .attributes = .{ .INHERIT = true }, .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+        .inbound = true,
+    }) else undefined;
+    errdefer if (options.stderr == .pipe) for (stderr_pipe) |handle| windows.CloseHandle(handle);
+
+    const prog_pipe = if (options.progress_node.index != .none) try t.windowsCreatePipe(.{
+        .server = .{ .attributes = .{ .INHERIT = false }, .mode = .{ .IO = .ASYNCHRONOUS } },
+        .client = .{ .attributes = .{ .INHERIT = true }, .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+        .inbound = true,
+    }) else undefined;
+    errdefer if (options.progress_node.index != .none) for (prog_pipe) |handle| windows.CloseHandle(handle);
 
     var siStartInfo: windows.STARTUPINFOW = .{
         .cb = @sizeOf(windows.STARTUPINFOW),
-        .hStdError = g_hChildStd_ERR_Wr,
-        .hStdOutput = g_hChildStd_OUT_Wr,
-        .hStdInput = g_hChildStd_IN_Rd,
         .dwFlags = windows.STARTF_USESTDHANDLES,
+        .hStdInput = switch (options.stdin) {
+            .inherit => peb.ProcessParameters.hStdInput,
+            .file => |file| file.handle,
+            .ignore => nul_handle,
+            .pipe => stdin_pipe[1],
+            .close => null,
+        },
+        .hStdOutput = switch (options.stdout) {
+            .inherit => peb.ProcessParameters.hStdOutput,
+            .file => |file| file.handle,
+            .ignore => nul_handle,
+            .pipe => stdout_pipe[1],
+            .close => null,
+        },
+        .hStdError = switch (options.stderr) {
+            .inherit => peb.ProcessParameters.hStdError,
+            .file => |file| file.handle,
+            .ignore => nul_handle,
+            .pipe => stderr_pipe[1],
+            .close => null,
+        },
 
         .lpReserved = null,
         .lpDesktop = null,
@@ -15360,8 +15333,18 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     };
     const cwd_w_ptr = if (cwd_w) |cwd| cwd.ptr else null;
 
-    const maybe_envp_buf = if (options.environ_map) |environ_map| try environ_map.createBlockWindows(arena) else null;
-    const envp_ptr = if (maybe_envp_buf) |envp_buf| envp_buf.ptr else null;
+    const env_block = env_block: {
+        const prog_handle = if (options.progress_node.index != .none)
+            prog_pipe[1]
+        else
+            windows.INVALID_HANDLE_VALUE;
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createWindowsBlock(arena, .{
+            .zig_progress_handle = prog_handle,
+        });
+        break :env_block try t.environ.process_environ.createWindowsBlock(arena, .{
+            .zig_progress_handle = if (options.progress_node.index != .none) prog_pipe[1] else windows.INVALID_HANDLE_VALUE,
+        });
+    };
 
     const app_name_wtf8 = options.argv[0];
     const app_name_is_absolute = Dir.path.isAbsolute(app_name_wtf8);
@@ -15436,7 +15419,7 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
             &app_buf,
             PATHEXT,
             &cmd_line_cache,
-            envp_ptr,
+            env_block,
             cwd_w_ptr,
             flags,
             &siStartInfo,
@@ -15471,7 +15454,7 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
                     &app_buf,
                     PATHEXT,
                     &cmd_line_cache,
-                    envp_ptr,
+                    env_block,
                     cwd_w_ptr,
                     flags,
                     &siStartInfo,
@@ -15491,21 +15474,40 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
         };
     }
 
-    if (options.stdin == .pipe) windows.CloseHandle(g_hChildStd_IN_Rd.?);
-    if (options.stderr == .pipe) windows.CloseHandle(g_hChildStd_ERR_Wr.?);
-    if (options.stdout == .pipe) windows.CloseHandle(g_hChildStd_OUT_Wr.?);
+    if (options.progress_node.index != .none) {
+        windows.CloseHandle(prog_pipe[1]);
+        options.progress_node.setIpcFd(prog_pipe[0]);
+    }
 
     return .{
         .id = piProcInfo.hProcess,
         .thread_handle = piProcInfo.hThread,
-        .stdin = if (g_hChildStd_IN_Wr) |h| .{ .handle = h, .flags = .{ .nonblocking = false } } else null,
-        .stdout = if (g_hChildStd_OUT_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
-        .stderr = if (g_hChildStd_ERR_Rd) |h| .{ .handle = h, .flags = .{ .nonblocking = true } } else null,
+        .stdin = stdin: switch (options.stdin) {
+            .pipe => {
+                windows.CloseHandle(stdin_pipe[1]);
+                break :stdin .{ .handle = stdin_pipe[0], .flags = .{ .nonblocking = false } };
+            },
+            else => null,
+        },
+        .stdout = stdout: switch (options.stdout) {
+            .pipe => {
+                windows.CloseHandle(stdout_pipe[1]);
+                break :stdout .{ .handle = stdout_pipe[0], .flags = .{ .nonblocking = true } };
+            },
+            else => null,
+        },
+        .stderr = stderr: switch (options.stderr) {
+            .pipe => {
+                windows.CloseHandle(stderr_pipe[1]);
+                break :stderr .{ .handle = stderr_pipe[0], .flags = .{ .nonblocking = true } };
+            },
+            else => null,
+        },
         .request_resource_usage_statistics = options.request_resource_usage_statistics,
     };
 }
 
-fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
+fn getCngDevice(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     {
         mutexLock(&t.mutex);
         defer mutexUnlock(&t.mutex);
@@ -15513,12 +15515,6 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     }
 
     const device_path = [_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'C', 'N', 'G' };
-
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = device_path.len * 2,
-        .MaximumLength = 0,
-        .Buffer = @constCast(&device_path),
-    };
     var fresh_handle: windows.HANDLE = undefined;
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var syscall: Syscall = try .start();
@@ -15529,12 +15525,11 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
             .SPECIFIC = .{ .FILE = .{ .READ_DATA = true } },
         },
         &.{
-            .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
-            .RootDirectory = null,
-            .ObjectName = &nt_name,
-            .Attributes = .{},
-            .SecurityDescriptor = null,
-            .SecurityQualityOfService = null,
+            .ObjectName = @constCast(&windows.UNICODE_STRING{
+                .Length = @sizeOf(@TypeOf(device_path)),
+                .MaximumLength = 0,
+                .Buffer = @constCast(&device_path),
+            }),
         },
         &io_status_block,
         .VALID_FLAGS,
@@ -15561,7 +15556,7 @@ fn getCngHandle(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     };
 }
 
-fn getNulHandle(t: *Threaded) !windows.HANDLE {
+fn getNulDevice(t: *Threaded) !windows.HANDLE {
     {
         mutexLock(&t.mutex);
         defer mutexUnlock(&t.mutex);
@@ -15569,44 +15564,26 @@ fn getNulHandle(t: *Threaded) !windows.HANDLE {
     }
 
     const device_path = [_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'u', 'l', 'l' };
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = device_path.len * 2,
-        .MaximumLength = 0,
-        .Buffer = @constCast(&device_path),
-    };
-    const attr: windows.OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
-        .RootDirectory = null,
-        .Attributes = .{
-            .INHERIT = true,
-        },
-        .ObjectName = &nt_name,
-        .SecurityDescriptor = null,
-        .SecurityQualityOfService = null,
-    };
-    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var fresh_handle: windows.HANDLE = undefined;
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var syscall: Syscall = try .start();
-    while (true) switch (windows.ntdll.NtCreateFile(
+    while (true) switch (windows.ntdll.NtOpenFile(
         &fresh_handle,
         .{
             .STANDARD = .{ .SYNCHRONIZE = true },
-            .GENERIC = .{ .WRITE = true, .READ = true },
+            .SPECIFIC = .{ .FILE = .{ .READ_DATA = true, .WRITE_DATA = true } },
+        },
+        &.{
+            .Attributes = .{ .INHERIT = true },
+            .ObjectName = @constCast(&windows.UNICODE_STRING{
+                .Length = @sizeOf(@TypeOf(device_path)),
+                .MaximumLength = 0,
+                .Buffer = @constCast(&device_path),
+            }),
         },
-        &attr,
         &io_status_block,
-        null,
-        .{ .NORMAL = true },
         .VALID_FLAGS,
-        .OPEN,
-        .{
-            .DIRECTORY_FILE = false,
-            .NON_DIRECTORY_FILE = true,
-            .IO = .SYNCHRONOUS_NONALERT,
-            .OPEN_REPARSE_POINT = false,
-        },
-        null,
-        0,
+        .{ .IO = .SYNCHRONOUS_NONALERT },
     )) {
         .SUCCESS => {
             syscall.finish();
@@ -15620,6 +15597,64 @@ fn getNulHandle(t: *Threaded) !windows.HANDLE {
                 return fresh_handle;
             }
         },
+        .CANCELLED => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+        .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
+        .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
+        .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
+        .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .NO_MEDIA_IN_DEVICE => return syscall.fail(error.NoDevice),
+        .SHARING_VIOLATION => return syscall.fail(error.AccessDenied),
+        .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+        .PIPE_NOT_AVAILABLE => return syscall.fail(error.NoDevice),
+        .FILE_IS_A_DIRECTORY => return syscall.fail(error.IsDir),
+        .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
+        .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
+        else => |status| return syscall.unexpectedNtstatus(status),
+    };
+}
+
+fn getNamedPipeDevice(t: *Threaded) !windows.HANDLE {
+    {
+        mutexLock(&t.mutex);
+        defer mutexUnlock(&t.mutex);
+        if (t.pipe_file.handle) |handle| return handle;
+    }
+
+    const device_path = [_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'a', 'm', 'e', 'd', 'P', 'i', 'p', 'e', '\\' };
+    var fresh_handle: windows.HANDLE = undefined;
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+    var syscall: Syscall = try .start();
+    while (true) switch (windows.ntdll.NtOpenFile(
+        &fresh_handle,
+        .{ .STANDARD = .{ .SYNCHRONIZE = true } },
+        &.{
+            .ObjectName = @constCast(&windows.UNICODE_STRING{
+                .Length = @sizeOf(@TypeOf(device_path)),
+                .MaximumLength = 0,
+                .Buffer = @constCast(&device_path),
+            }),
+        },
+        &io_status_block,
+        .VALID_FLAGS,
+        .{ .IO = .SYNCHRONOUS_NONALERT },
+    )) {
+        .SUCCESS => {
+            syscall.finish();
+            mutexLock(&t.mutex); // Another thread might have won the race.
+            defer mutexUnlock(&t.mutex);
+            if (t.pipe_file.handle) |prev_handle| {
+                windows.CloseHandle(fresh_handle);
+                return prev_handle;
+            } else {
+                t.pipe_file.handle = fresh_handle;
+                return fresh_handle;
+            }
+        },
         .DELETE_PENDING => {
             // This error means that there *was* a file in this location on
             // the file system, but it was deleted. However, the OS is not
@@ -15666,7 +15701,7 @@ fn windowsCreateProcessPathExt(
     app_buf: *std.ArrayList(u16),
     pathext: [:0]const u16,
     cmd_line_cache: *WindowsCommandLineCache,
-    envp_ptr: ?[*:0]const u16,
+    env_block: ?process.Environ.WindowsBlock,
     cwd_ptr: ?[*:0]u16,
     flags: windows.CreateProcessFlags,
     lpStartupInfo: *windows.STARTUPINFOW,
@@ -15843,7 +15878,7 @@ fn windowsCreateProcessPathExt(
             if (windowsCreateProcess(
                 app_name_w.ptr,
                 cmd_line_w.ptr,
-                envp_ptr,
+                env_block,
                 cwd_ptr,
                 flags,
                 lpStartupInfo,
@@ -15903,7 +15938,7 @@ fn windowsCreateProcessPathExt(
         else
             full_app_name;
 
-        if (windowsCreateProcess(app_name_w.ptr, cmd_line_w.ptr, envp_ptr, cwd_ptr, flags, lpStartupInfo, lpProcessInformation)) |_| {
+        if (windowsCreateProcess(app_name_w.ptr, cmd_line_w.ptr, env_block, cwd_ptr, flags, lpStartupInfo, lpProcessInformation)) |_| {
             return;
         } else |err| switch (err) {
             error.FileNotFound => continue,
@@ -15927,7 +15962,7 @@ fn windowsCreateProcessPathExt(
 fn windowsCreateProcess(
     app_name: [*:0]u16,
     cmd_line: [*:0]u16,
-    env_ptr: ?[*:0]const u16,
+    env_block: ?process.Environ.WindowsBlock,
     cwd_ptr: ?[*:0]u16,
     flags: windows.CreateProcessFlags,
     lpStartupInfo: *windows.STARTUPINFOW,
@@ -15942,7 +15977,7 @@ fn windowsCreateProcess(
             null,
             windows.TRUE,
             flags,
-            env_ptr,
+            if (env_block) |block| block.slice.ptr else null,
             cwd_ptr,
             lpStartupInfo,
             lpProcessInformation,
@@ -16463,11 +16498,11 @@ fn posixExecv(
     arg0_expand: process.ArgExpansion,
     file: [*:0]const u8,
     child_argv: [*:null]?[*:0]const u8,
-    envp: [*:null]const ?[*:0]const u8,
+    env_block: process.Environ.PosixBlock,
     PATH: []const u8,
 ) process.ReplaceError {
     const file_slice = std.mem.sliceTo(file, 0);
-    if (std.mem.findScalar(u8, file_slice, '/') != null) return posixExecvPath(file, child_argv, envp);
+    if (std.mem.findScalar(u8, file_slice, '/') != null) return posixExecvPath(file, child_argv, env_block);
 
     // Use of PATH_MAX here is valid as the path_buf will be passed
     // directly to the operating system in posixExecvPath.
@@ -16495,7 +16530,7 @@ fn posixExecv(
             .expand => child_argv[0] = full_path,
             .no_expand => {},
         }
-        err = posixExecvPath(full_path, child_argv, envp);
+        err = posixExecvPath(full_path, child_argv, env_block);
         switch (err) {
             error.AccessDenied => seen_eacces = true,
             error.FileNotFound, error.NotDir => {},
@@ -16510,10 +16545,10 @@ fn posixExecv(
 pub fn posixExecvPath(
     path: [*:0]const u8,
     child_argv: [*:null]const ?[*:0]const u8,
-    envp: [*:null]const ?[*:0]const u8,
+    env_block: process.Environ.PosixBlock,
 ) process.ReplaceError {
     try Thread.checkCancel();
-    switch (posix.errno(posix.system.execve(path, child_argv, envp))) {
+    switch (posix.errno(posix.system.execve(path, child_argv, env_block.slice.ptr))) {
         .FAULT => |err| return errnoBug(err), // Bad pointer parameter.
         .@"2BIG" => return error.SystemResources,
         .MFILE => return error.ProcessFdQuotaExceeded,
@@ -16545,100 +16580,105 @@ pub fn posixExecvPath(
     }
 }
 
-fn windowsMakePipeIn(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const windows.SECURITY_ATTRIBUTES) !void {
-    var rd_h: windows.HANDLE = undefined;
-    var wr_h: windows.HANDLE = undefined;
-    try windows.CreatePipe(&rd_h, &wr_h, sattr);
-    errdefer windowsDestroyPipe(rd_h, wr_h);
-    try windows.SetHandleInformation(wr_h, windows.HANDLE_FLAG_INHERIT, 0);
-    rd.* = rd_h;
-    wr.* = wr_h;
-}
-
-fn windowsDestroyPipe(rd: ?windows.HANDLE, wr: ?windows.HANDLE) void {
-    if (rd) |h| posix.close(h);
-    if (wr) |h| posix.close(h);
-}
+pub const CreatePipeOptions = struct {
+    server: End,
+    client: End,
+    inbound: bool = false,
+    outbound: bool = false,
+    maximum_instances: u32 = 1,
+    quota: u32 = 4096,
+    default_timeout: windows.LARGE_INTEGER = -120 * std.time.ns_per_s / 100,
 
-fn windowsMakeAsyncPipe(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const windows.SECURITY_ATTRIBUTES) !void {
-    var tmp_bufw: [128]u16 = undefined;
-
-    // Anonymous pipes are built upon Named pipes.
-    // https://docs.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-createpipe
-    // Asynchronous (overlapped) read and write operations are not supported by anonymous pipes.
-    // https://docs.microsoft.com/en-us/windows/win32/ipc/anonymous-pipe-operations
-    const pipe_path = blk: {
-        var tmp_buf: [128]u8 = undefined;
-        // Forge a random path for the pipe.
-        const pipe_path = std.fmt.bufPrintSentinel(
-            &tmp_buf,
-            "\\\\.\\pipe\\zig-childprocess-{d}-{d}",
-            .{ windows.GetCurrentProcessId(), pipe_name_counter.fetchAdd(1, .monotonic) },
-            0,
-        ) catch unreachable;
-        const len = std.unicode.wtf8ToWtf16Le(&tmp_bufw, pipe_path) catch unreachable;
-        tmp_bufw[len] = 0;
-        break :blk tmp_bufw[0..len :0];
+    pub const End = struct {
+        attributes: windows.OBJECT_ATTRIBUTES.ATTRIBUTES = .{},
+        mode: windows.FILE.MODE,
     };
-
-    // Create the read handle that can be used with overlapped IO ops.
-    const read_handle = windows.kernel32.CreateNamedPipeW(
-        pipe_path.ptr,
-        windows.PIPE_ACCESS_INBOUND | windows.FILE_FLAG_OVERLAPPED,
-        windows.PIPE_TYPE_BYTE,
-        1,
-        4096,
-        4096,
-        0,
-        sattr,
-    );
-    if (read_handle == windows.INVALID_HANDLE_VALUE) {
-        switch (windows.GetLastError()) {
-            else => |err| return windows.unexpectedError(err),
-        }
-    }
-    errdefer posix.close(read_handle);
-
-    var sattr_copy = sattr.*;
-    const write_handle = windows.kernel32.CreateFileW(
-        pipe_path.ptr,
-        .{ .GENERIC = .{ .WRITE = true } },
-        0,
-        &sattr_copy,
-        windows.OPEN_EXISTING,
-        @bitCast(windows.FILE.ATTRIBUTE{ .NORMAL = true }),
-        null,
-    );
-    if (write_handle == windows.INVALID_HANDLE_VALUE) {
-        switch (windows.GetLastError()) {
-            else => |err| return windows.unexpectedError(err),
-        }
-    }
-    errdefer posix.close(write_handle);
-
-    try windows.SetHandleInformation(read_handle, windows.HANDLE_FLAG_INHERIT, 0);
-
-    rd.* = read_handle;
-    wr.* = write_handle;
+};
+pub fn windowsCreatePipe(t: *Threaded, options: CreatePipeOptions) ![2]windows.HANDLE {
+    const named_pipe_device = try t.getNamedPipeDevice();
+    const server_handle = server_handle: {
+        var handle: windows.HANDLE = undefined;
+        var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtCreateNamedPipeFile(
+            &handle,
+            .{
+                .SPECIFIC = .{ .FILE_PIPE = .{
+                    .READ_DATA = options.inbound,
+                    .WRITE_DATA = options.outbound,
+                    .WRITE_ATTRIBUTES = true,
+                } },
+                .STANDARD = .{ .SYNCHRONIZE = true },
+            },
+            &.{
+                .RootDirectory = named_pipe_device,
+                .Attributes = options.server.attributes,
+            },
+            &io_status_block,
+            .{ .READ = true, .WRITE = true },
+            .CREATE,
+            options.server.mode,
+            .{ .TYPE = .BYTE_STREAM },
+            .{ .MODE = .BYTE_STREAM },
+            .{ .OPERATION = .QUEUE },
+            options.maximum_instances,
+            if (options.inbound) options.quota else 0,
+            if (options.outbound) options.quota else 0,
+            &options.default_timeout,
+        )) {
+            .SUCCESS => break syscall.finish(),
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+            .INSUFFICIENT_RESOURCES => return syscall.fail(error.SystemResources),
+            else => |status| return syscall.unexpectedNtstatus(status),
+        };
+        break :server_handle handle;
+    };
+    errdefer windows.CloseHandle(server_handle);
+    const client_handle = client_handle: {
+        var handle: windows.HANDLE = undefined;
+        var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtOpenFile(
+            &handle,
+            .{
+                .SPECIFIC = .{ .FILE_PIPE = .{
+                    .READ_DATA = options.outbound,
+                    .WRITE_DATA = options.inbound,
+                    .WRITE_ATTRIBUTES = true,
+                } },
+                .STANDARD = .{ .SYNCHRONIZE = true },
+            },
+            &.{
+                .RootDirectory = server_handle,
+                .Attributes = options.client.attributes,
+            },
+            &io_status_block,
+            .{ .READ = true, .WRITE = true },
+            options.client.mode,
+        )) {
+            .SUCCESS => break syscall.finish(),
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+            .INSUFFICIENT_RESOURCES => return syscall.fail(error.SystemResources),
+            else => |status| return syscall.unexpectedNtstatus(status),
+        };
+        break :client_handle handle;
+    };
+    errdefer windows.CloseHandle(client_handle);
+    return .{ server_handle, client_handle };
 }
 
-var pipe_name_counter = std.atomic.Value(u32).init(1);
-
 fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-
     t.scanEnviron();
-
-    const int = try t.environ.zig_progress_handle;
-
-    return .{
-        .handle = switch (@typeInfo(Io.File.Handle)) {
-            .int => int,
-            .pointer => @ptrFromInt(int),
-            else => return error.UnsupportedOperation,
-        },
-        .flags = .{ .nonblocking = false },
-    };
+    return t.environ.zig_progress_file;
 }
 
 pub fn environString(t: *Threaded, comptime name: []const u8) ?[:0]const u8 {
@@ -16734,7 +16774,7 @@ fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
         //   despite the function being documented to always return TRUE
         // * reads from "\\Device\\CNG" which then seeds a per-CPU AES CSPRNG
         // Therefore, that function is avoided in favor of using the device directly.
-        const cng_device = try getCngHandle(t);
+        const cng_device = try getCngDevice(t);
         var io_status_block: windows.IO_STATUS_BLOCK = undefined;
         var i: usize = 0;
         const syscall: Syscall = try .start();
diff --git a/lib/std/Io/Threaded/test.zig b/lib/std/Io/Threaded/test.zig
index 593580d1f62511b7ce1d73248cc50a0bca5a45a2..81c7be9170e8479c231e5f30931b38de39723f20 100644
--- a/lib/std/Io/Threaded/test.zig
+++ b/lib/std/Io/Threaded/test.zig
@@ -181,13 +181,17 @@ test "cancel blocked read from pipe" {
     var write_end: Io.File = undefined;
     switch (builtin.target.os.tag) {
         .wasi => return error.SkipZigTest,
-        .windows => try std.os.windows.CreatePipe(&read_end.handle, &write_end.handle, &.{
-            .nLength = @sizeOf(std.os.windows.SECURITY_ATTRIBUTES),
-            .lpSecurityDescriptor = null,
-            .bInheritHandle = std.os.windows.FALSE,
-        }),
+        .windows => {
+            const pipe = try threaded.windowsCreatePipe(.{
+                .server = .{ .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+                .client = .{ .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+                .inbound = true,
+            });
+            read_end = .{ .handle = pipe[0], .flags = .{ .nonblocking = false } };
+            write_end = .{ .handle = pipe[1], .flags = .{ .nonblocking = false } };
+        },
         else => {
-            const pipe = try std.Io.Threaded.pipe2(.{});
+            const pipe = try std.Io.Threaded.pipe2(.{ .CLOEXEC = true });
             read_end = .{ .handle = pipe[0], .flags = .{ .nonblocking = false } };
             write_end = .{ .handle = pipe[1], .flags = .{ .nonblocking = false } };
         },
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index e2f3ed52322ef30a89747bbbd0c394c4bf27389d..780f27ec75a89b11c414a2463c3ff68fb9041b57 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -139,7 +139,7 @@ pub const Node = struct {
         fn setIpcFd(s: *Storage, fd: Io.File.Handle) void {
             const integer: u32 = switch (@typeInfo(Io.File.Handle)) {
                 .int => @bitCast(fd),
-                .pointer => @intFromPtr(fd),
+                .pointer => @intCast(@intFromPtr(fd)),
                 else => @compileError("unsupported fd_t of " ++ @typeName(Io.File.Handle)),
             };
             // `estimated_total_count` max int indicates the special state that
@@ -342,10 +342,18 @@ pub const Node = struct {
     /// Posix-only. Used by `std.process.Child`. Thread-safe.
     pub fn setIpcFd(node: Node, fd: Io.File.Handle) void {
         const index = node.index.unwrap() orelse return;
-        assert(fd >= 0);
-        assert(fd != posix.STDOUT_FILENO);
-        assert(fd != posix.STDIN_FILENO);
-        assert(fd != posix.STDERR_FILENO);
+        switch (@typeInfo(Io.File.Handle)) {
+            .int => {
+                assert(fd >= 0);
+                assert(fd != posix.STDOUT_FILENO);
+                assert(fd != posix.STDIN_FILENO);
+                assert(fd != posix.STDERR_FILENO);
+            },
+            .pointer => {
+                assert(fd != windows.INVALID_HANDLE_VALUE);
+            },
+            else => @compileError("unsupported fd_t of " ++ @typeName(Io.File.Handle)),
+        }
         storageByIndex(index).setIpcFd(fd);
     }
 
@@ -477,21 +485,18 @@ pub fn start(io: Io, options: Options) Node {
     global_progress.refresh_rate_ns = @intCast(options.refresh_rate_ns.toNanoseconds());
     global_progress.initial_delay_ns = @intCast(options.initial_delay_ns.toNanoseconds());
 
-    if (noop_impl)
-        return Node.none;
+    if (noop_impl) return .none;
 
     global_progress.io = io;
 
     if (io.vtable.progressParentFile(io.userdata)) |ipc_file| {
         global_progress.update_worker = io.concurrent(ipcThreadRun, .{ io, ipc_file }) catch |err| {
             global_progress.start_failure = .{ .spawn_ipc_worker = err };
-            return Node.none;
+            return .none;
         };
     } else |env_err| switch (env_err) {
         error.EnvironmentVariableMissing => {
-            if (options.disable_printing) {
-                return Node.none;
-            }
+            if (options.disable_printing) return .none;
             const stderr: Io.File = .stderr();
             global_progress.terminal = stderr;
             if (stderr.enableAnsiEscapeCodes(io)) |_| {
@@ -504,14 +509,12 @@ pub fn start(io: Io, options: Options) Node {
                 } else |err| switch (err) {
                     error.Canceled => {
                         io.recancel();
-                        return Node.none;
+                        return .none;
                     },
                 }
             }
 
-            if (global_progress.terminal_mode == .off) {
-                return Node.none;
-            }
+            if (global_progress.terminal_mode == .off) return .none;
 
             if (have_sigwinch) {
                 const act: posix.Sigaction = .{
@@ -530,12 +533,12 @@ pub fn start(io: Io, options: Options) Node {
                 global_progress.update_worker = future;
             } else |err| {
                 global_progress.start_failure = .{ .spawn_update_worker = err };
-                return Node.none;
+                return .none;
             }
         },
         else => |e| {
             global_progress.start_failure = .{ .parent_ipc = e };
-            return Node.none;
+            return .none;
         },
     }
 
diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 4d0e992e975b847ae0332172a1505f2924a9d906..131f57dcf860d59d89b5cec88aa491bbf06fc719 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -598,7 +598,11 @@ const WindowsThreadImpl = struct {
     }
 
     fn join(self: Impl) void {
-        windows.WaitForSingleObjectEx(self.thread.thread_handle, windows.INFINITE, false) catch unreachable;
+        const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
+        switch (windows.ntdll.NtWaitForSingleObject(self.thread.thread_handle, windows.FALSE, &infinite_timeout)) {
+            windows.NTSTATUS.WAIT_0 => {},
+            else => |status| windows.unexpectedStatus(status) catch unreachable,
+        }
         windows.CloseHandle(self.thread.thread_handle);
         assert(self.thread.completion.load(.seq_cst) == .completed);
         self.thread.free();
diff --git a/lib/std/mem/Allocator.zig b/lib/std/mem/Allocator.zig
index 72581236e6dffbcb3104024d714af5ec03a2a672..db1ea978eaf21d31fa846db8dc591fb9749f746d 100644
--- a/lib/std/mem/Allocator.zig
+++ b/lib/std/mem/Allocator.zig
@@ -452,12 +452,23 @@ pub fn dupe(allocator: Allocator, comptime T: type, m: []const T) Error![]T {
     return new_buf;
 }
 
+/// Deprecated in favor of `dupeSentinel`
 /// Copies `m` to newly allocated memory, with a null-terminated element. Caller owns the memory.
 pub fn dupeZ(allocator: Allocator, comptime T: type, m: []const T) Error![:0]T {
+    return allocator.dupeSentinel(T, m, 0);
+}
+
+/// Copies `m` to newly allocated memory, with a null-terminated element. Caller owns the memory.
+pub fn dupeSentinel(
+    allocator: Allocator,
+    comptime T: type,
+    m: []const T,
+    comptime sentinel: T,
+) Error![:sentinel]T {
     const new_buf = try allocator.alloc(T, m.len + 1);
     @memcpy(new_buf[0..m.len], m);
-    new_buf[m.len] = 0;
-    return new_buf[0..m.len :0];
+    new_buf[m.len] = sentinel;
+    return new_buf[0..m.len :sentinel];
 }
 
 /// An allocator that always fails to allocate.
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 0f57eed766eba130ece4bafc3b76e5684de2239b..dcb9087f136c664b9133e03c0b71458ddd8ed9c3 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -521,7 +521,7 @@ pub const FILE = struct {
             _,
 
             pub const VALID_FLAGS: @This() = @enumFromInt(0b11);
-        } = .ASYNCHRONOUS,
+        },
         /// The file being opened must not be a directory file or this call
         /// fails. The file object being opened can represent a data file, a
         /// logical, virtual, or physical device, or a volume.
@@ -2324,12 +2324,12 @@ pub fn GetProcessHeap() ?*HEAP {
 // ref: um/winternl.h
 
 pub const OBJECT_ATTRIBUTES = extern struct {
-    Length: ULONG,
-    RootDirectory: ?HANDLE,
-    ObjectName: ?*UNICODE_STRING,
-    Attributes: ATTRIBUTES,
-    SecurityDescriptor: ?*anyopaque,
-    SecurityQualityOfService: ?*anyopaque,
+    Length: ULONG = @sizeOf(OBJECT_ATTRIBUTES),
+    RootDirectory: ?HANDLE = null,
+    ObjectName: ?*UNICODE_STRING = @constCast(&UNICODE_STRING.empty),
+    Attributes: ATTRIBUTES = .{},
+    SecurityDescriptor: ?*anyopaque = null,
+    SecurityQualityOfService: ?*anyopaque = null,
 
     // Valid values for the Attributes field
     pub const ATTRIBUTES = packed struct(ULONG) {
@@ -2420,14 +2420,10 @@ pub fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!HAN
         .Buffer = @constCast(sub_path_w.ptr),
     };
     const attr: OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(OBJECT_ATTRIBUTES),
         .RootDirectory = if (std.fs.path.isAbsoluteWindowsWtf16(sub_path_w)) null else options.dir,
-        .Attributes = .{
-            .INHERIT = if (options.sa) |sa| sa.bInheritHandle != FALSE else false,
-        },
+        .Attributes = .{ .INHERIT = if (options.sa) |sa| sa.bInheritHandle != FALSE else false },
         .ObjectName = &nt_name,
         .SecurityDescriptor = if (options.sa) |ptr| ptr.lpSecurityDescriptor else null,
-        .SecurityQualityOfService = null,
     };
     var io: IO_STATUS_BLOCK = undefined;
     while (true) {
@@ -2475,7 +2471,8 @@ pub fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!HAN
                 // call has failed. There is not really a sane way to handle
                 // this other than retrying the creation after the OS finishes
                 // the deletion.
-                _ = kernel32.SleepEx(1, TRUE);
+                const delay_one_ms: LARGE_INTEGER = -(std.time.ns_per_ms / 100);
+                _ = ntdll.NtDelayExecution(TRUE, &delay_one_ms);
                 continue;
             },
             .VIRUS_INFECTED, .VIRUS_DELETED => return error.AntivirusInterference,
@@ -2506,151 +2503,6 @@ pub fn GetCurrentThreadId() DWORD {
 pub fn GetLastError() Win32Error {
     return @enumFromInt(teb().LastErrorValue);
 }
-
-pub const CreatePipeError = error{ Unexpected, SystemResources };
-
-var npfs: ?HANDLE = null;
-
-/// A Zig wrapper around `NtCreateNamedPipeFile` and `NtCreateFile` syscalls.
-/// It implements similar behavior to `CreatePipe` and is meant to serve
-/// as a direct substitute for that call.
-pub fn CreatePipe(rd: *HANDLE, wr: *HANDLE, sattr: *const SECURITY_ATTRIBUTES) CreatePipeError!void {
-    // Up to NT 5.2 (Windows XP/Server 2003), `CreatePipe` would generate a pipe similar to:
-    //
-    //      \??\pipe\Win32Pipes.{pid}.{count}
-    //
-    // where `pid` is the process id and count is a incrementing counter.
-    // The implementation was changed after NT 6.0 (Vista) to open a handle to the Named Pipe File System
-    // and use that as the root directory for `NtCreateNamedPipeFile`.
-    // This object is visible under the NPFS but has no filename attached to it.
-    //
-    // This implementation replicates how `CreatePipe` works in modern Windows versions.
-    const opt_dev_handle = @atomicLoad(?HANDLE, &npfs, .seq_cst);
-    const dev_handle = opt_dev_handle orelse blk: {
-        const str = std.unicode.utf8ToUtf16LeStringLiteral("\\Device\\NamedPipe\\");
-        const len: u16 = @truncate(str.len * @sizeOf(u16));
-        const name: UNICODE_STRING = .{
-            .Length = len,
-            .MaximumLength = len,
-            .Buffer = @ptrCast(@constCast(str)),
-        };
-        const attrs: OBJECT_ATTRIBUTES = .{
-            .ObjectName = @constCast(&name),
-            .Length = @sizeOf(OBJECT_ATTRIBUTES),
-            .RootDirectory = null,
-            .Attributes = .{},
-            .SecurityDescriptor = null,
-            .SecurityQualityOfService = null,
-        };
-
-        var iosb: IO_STATUS_BLOCK = undefined;
-        var handle: HANDLE = undefined;
-        switch (ntdll.NtCreateFile(
-            &handle,
-            .{
-                .STANDARD = .{ .SYNCHRONIZE = true },
-                .GENERIC = .{ .READ = true },
-            },
-            @constCast(&attrs),
-            &iosb,
-            null,
-            .{},
-            .VALID_FLAGS,
-            .OPEN,
-            .{ .IO = .SYNCHRONOUS_NONALERT },
-            null,
-            0,
-        )) {
-            .SUCCESS => {},
-            // Judging from the ReactOS sources this is technically possible.
-            .INSUFFICIENT_RESOURCES => return error.SystemResources,
-            .INVALID_PARAMETER => unreachable,
-            else => |e| return unexpectedStatus(e),
-        }
-        if (@cmpxchgStrong(?HANDLE, &npfs, null, handle, .seq_cst, .seq_cst)) |xchg| {
-            CloseHandle(handle);
-            break :blk xchg.?;
-        } else break :blk handle;
-    };
-
-    const name: UNICODE_STRING = .{ .Buffer = null, .Length = 0, .MaximumLength = 0 };
-    var attrs: OBJECT_ATTRIBUTES = .{
-        .ObjectName = @constCast(&name),
-        .Length = @sizeOf(OBJECT_ATTRIBUTES),
-        .RootDirectory = dev_handle,
-        .Attributes = .{ .INHERIT = sattr.bInheritHandle != FALSE },
-        .SecurityDescriptor = sattr.lpSecurityDescriptor,
-        .SecurityQualityOfService = null,
-    };
-
-    // 120 second relative timeout in 100ns units.
-    const default_timeout: LARGE_INTEGER = (-120 * std.time.ns_per_s) / 100;
-    var iosb: IO_STATUS_BLOCK = undefined;
-    var read: HANDLE = undefined;
-    switch (ntdll.NtCreateNamedPipeFile(
-        &read,
-        .{
-            .SPECIFIC = .{ .FILE_PIPE = .{
-                .WRITE_ATTRIBUTES = true,
-            } },
-            .STANDARD = .{ .SYNCHRONIZE = true },
-            .GENERIC = .{ .READ = true },
-        },
-        &attrs,
-        &iosb,
-        .{ .READ = true, .WRITE = true },
-        .CREATE,
-        .{ .IO = .SYNCHRONOUS_NONALERT },
-        .{ .TYPE = .BYTE_STREAM },
-        .{ .MODE = .BYTE_STREAM },
-        .{ .OPERATION = .QUEUE },
-        1,
-        4096,
-        4096,
-        @constCast(&default_timeout),
-    )) {
-        .SUCCESS => {},
-        .INVALID_PARAMETER => unreachable,
-        .INSUFFICIENT_RESOURCES => return error.SystemResources,
-        else => |e| return unexpectedStatus(e),
-    }
-    errdefer CloseHandle(read);
-
-    attrs.RootDirectory = read;
-
-    var write: HANDLE = undefined;
-    switch (ntdll.NtCreateFile(
-        &write,
-        .{
-            .SPECIFIC = .{ .FILE_PIPE = .{
-                .READ_ATTRIBUTES = true,
-            } },
-            .STANDARD = .{ .SYNCHRONIZE = true },
-            .GENERIC = .{ .WRITE = true },
-        },
-        &attrs,
-        &iosb,
-        null,
-        .{},
-        .VALID_FLAGS,
-        .OPEN,
-        .{
-            .IO = .SYNCHRONOUS_NONALERT,
-            .NON_DIRECTORY_FILE = true,
-        },
-        null,
-        0,
-    )) {
-        .SUCCESS => {},
-        .INVALID_PARAMETER => unreachable,
-        .INSUFFICIENT_RESOURCES => return error.SystemResources,
-        else => |e| return unexpectedStatus(e),
-    }
-
-    rd.* = read;
-    wr.* = write;
-}
-
 /// A Zig wrapper around `NtDeviceIoControlFile` and `NtFsControlFile` syscalls.
 /// It implements similar behavior to `DeviceIoControl` and is meant to serve
 /// as a direct substitute for that call.
@@ -2707,66 +2559,6 @@ pub fn GetOverlappedResult(h: HANDLE, overlapped: *OVERLAPPED, wait: bool) !DWOR
     return bytes;
 }
 
-pub const SetHandleInformationError = error{Unexpected};
-
-pub fn SetHandleInformation(h: HANDLE, mask: DWORD, flags: DWORD) SetHandleInformationError!void {
-    if (kernel32.SetHandleInformation(h, mask, flags) == 0) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-}
-
-pub const WaitForSingleObjectError = error{
-    WaitAbandoned,
-    WaitTimeOut,
-    Unexpected,
-};
-
-pub fn WaitForSingleObject(handle: HANDLE, milliseconds: DWORD) WaitForSingleObjectError!void {
-    return WaitForSingleObjectEx(handle, milliseconds, false);
-}
-
-pub fn WaitForSingleObjectEx(handle: HANDLE, milliseconds: DWORD, alertable: bool) WaitForSingleObjectError!void {
-    switch (kernel32.WaitForSingleObjectEx(handle, milliseconds, @intFromBool(alertable))) {
-        WAIT_ABANDONED => return error.WaitAbandoned,
-        WAIT_OBJECT_0 => return,
-        WAIT_TIMEOUT => return error.WaitTimeOut,
-        WAIT_FAILED => switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        },
-        else => return error.Unexpected,
-    }
-}
-
-pub fn WaitForMultipleObjectsEx(handles: []const HANDLE, waitAll: bool, milliseconds: DWORD, alertable: bool) !u32 {
-    assert(handles.len > 0 and handles.len <= MAXIMUM_WAIT_OBJECTS);
-    const nCount: DWORD = @as(DWORD, @intCast(handles.len));
-    switch (kernel32.WaitForMultipleObjectsEx(
-        nCount,
-        handles.ptr,
-        @intFromBool(waitAll),
-        milliseconds,
-        @intFromBool(alertable),
-    )) {
-        WAIT_OBJECT_0...WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS => |n| {
-            const handle_index = n - WAIT_OBJECT_0;
-            assert(handle_index < nCount);
-            return handle_index;
-        },
-        WAIT_ABANDONED_0...WAIT_ABANDONED_0 + MAXIMUM_WAIT_OBJECTS => |n| {
-            const handle_index = n - WAIT_ABANDONED_0;
-            assert(handle_index < nCount);
-            return error.WaitAbandoned;
-        },
-        WAIT_TIMEOUT => return error.WaitTimeOut,
-        WAIT_FAILED => switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        },
-        else => return error.Unexpected,
-    }
-}
-
 pub const CreateIoCompletionPortError = error{Unexpected};
 
 pub fn CreateIoCompletionPort(
@@ -2878,21 +2670,6 @@ pub fn CloseHandle(hObject: HANDLE) void {
     assert(ntdll.NtClose(hObject) == .SUCCESS);
 }
 
-pub const GetStdHandleError = error{
-    NoStandardHandleAttached,
-    Unexpected,
-};
-
-pub fn GetStdHandle(handle_id: DWORD) GetStdHandleError!HANDLE {
-    const handle = kernel32.GetStdHandle(handle_id) orelse return error.NoStandardHandleAttached;
-    if (handle == INVALID_HANDLE_VALUE) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-    return handle;
-}
-
 pub const QueryObjectNameError = error{
     AccessDenied,
     InvalidHandle,
@@ -3545,6 +3322,12 @@ pub fn nanoSecondsToFileTime(ns: Io.Timestamp) FILETIME {
     };
 }
 
+/// Use RtlUpcaseUnicodeChar on Windows when not in comptime to avoid including a
+/// redundant copy of the uppercase data.
+pub inline fn toUpperWtf16(c: u16) u16 {
+    return (if (builtin.os.tag != .windows or @inComptime()) nls.upcaseW else ntdll.RtlUpcaseUnicodeChar)(c);
+}
+
 /// Compares two WTF16 strings using the equivalent functionality of
 /// `RtlEqualUnicodeString` (with case insensitive comparison enabled).
 /// This function can be called on any target.
@@ -3598,19 +3381,12 @@ pub fn eqlIgnoreCaseWtf8(a: []const u8, b: []const u8) bool {
     var a_wtf8_it = std.unicode.Wtf8View.initUnchecked(a).iterator();
     var b_wtf8_it = std.unicode.Wtf8View.initUnchecked(b).iterator();
 
-    // Use RtlUpcaseUnicodeChar on Windows when not in comptime to avoid including a
-    // redundant copy of the uppercase data.
-    const upcaseImpl = switch (builtin.os.tag) {
-        .windows => if (@inComptime()) nls.upcaseW else ntdll.RtlUpcaseUnicodeChar,
-        else => nls.upcaseW,
-    };
-
     while (true) {
         const a_cp = a_wtf8_it.nextCodepoint() orelse break;
         const b_cp = b_wtf8_it.nextCodepoint() orelse return false;
 
         if (a_cp <= maxInt(u16) and b_cp <= maxInt(u16)) {
-            if (a_cp != b_cp and upcaseImpl(@intCast(a_cp)) != upcaseImpl(@intCast(b_cp))) {
+            if (a_cp != b_cp and toUpperWtf16(@intCast(a_cp)) != toUpperWtf16(@intCast(b_cp))) {
                 return false;
             }
         } else if (a_cp != b_cp) {
@@ -4098,15 +3874,6 @@ pub const Win32Error = @import("windows/win32error.zig").Win32Error;
 pub const LANG = @import("windows/lang.zig");
 pub const SUBLANG = @import("windows/sublang.zig");
 
-/// The standard input device. Initially, this is the console input buffer, CONIN$.
-pub const STD_INPUT_HANDLE = maxInt(DWORD) - 10 + 1;
-
-/// The standard output device. Initially, this is the active console screen buffer, CONOUT$.
-pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
-
-/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
-pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
-
 pub const BOOL = c_int;
 pub const BOOLEAN = BYTE;
 pub const BYTE = u8;
@@ -5244,6 +5011,8 @@ pub const UNICODE_STRING = extern struct {
     Length: c_ushort,
     MaximumLength: c_ushort,
     Buffer: ?[*]WCHAR,
+
+    pub const empty: UNICODE_STRING = .{ .Length = 0, .MaximumLength = 0, .Buffer = null };
 };
 
 pub const ACTIVATION_CONTEXT_DATA = opaque {};
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index b6785e4a33fb79eeed57e2786696f5d8ef49bb5e..d6af93cfc3add89352135762670270333ef7147c 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -12,8 +12,6 @@ const FILETIME = windows.FILETIME;
 const HANDLE = windows.HANDLE;
 const HANDLER_ROUTINE = windows.HANDLER_ROUTINE;
 const HMODULE = windows.HMODULE;
-const INIT_ONCE = windows.INIT_ONCE;
-const INIT_ONCE_FN = windows.INIT_ONCE_FN;
 const LARGE_INTEGER = windows.LARGE_INTEGER;
 const LPCSTR = windows.LPCSTR;
 const LPCVOID = windows.LPCVOID;
@@ -24,7 +22,6 @@ const LPWSTR = windows.LPWSTR;
 const MODULEENTRY32 = windows.MODULEENTRY32;
 const OVERLAPPED = windows.OVERLAPPED;
 const OVERLAPPED_ENTRY = windows.OVERLAPPED_ENTRY;
-const PMEMORY_BASIC_INFORMATION = windows.PMEMORY_BASIC_INFORMATION;
 const PROCESS_INFORMATION = windows.PROCESS_INFORMATION;
 const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
 const SIZE_T = windows.SIZE_T;
@@ -37,7 +34,6 @@ const ULONG = windows.ULONG;
 const ULONG_PTR = windows.ULONG_PTR;
 const va_list = windows.va_list;
 const WCHAR = windows.WCHAR;
-const WIN32_FIND_DATAW = windows.WIN32_FIND_DATAW;
 const Win32Error = windows.Win32Error;
 const WORD = windows.WORD;
 
@@ -59,39 +55,6 @@ pub extern "kernel32" fn CancelIo(
     hFile: HANDLE,
 ) callconv(.winapi) BOOL;
 
-// TODO: Wrapper around NtCancelIoFileEx.
-pub extern "kernel32" fn CancelIoEx(
-    hFile: HANDLE,
-    lpOverlapped: ?*OVERLAPPED,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn CreateFileW(
-    lpFileName: LPCWSTR,
-    dwDesiredAccess: ACCESS_MASK,
-    dwShareMode: DWORD,
-    lpSecurityAttributes: ?*SECURITY_ATTRIBUTES,
-    dwCreationDisposition: DWORD,
-    dwFlagsAndAttributes: DWORD,
-    hTemplateFile: ?HANDLE,
-) callconv(.winapi) HANDLE;
-
-// TODO A bunch of logic around NtCreateNamedPipe
-pub extern "kernel32" fn CreateNamedPipeW(
-    lpName: LPCWSTR,
-    dwOpenMode: DWORD,
-    dwPipeMode: DWORD,
-    nMaxInstances: DWORD,
-    nOutBufferSize: DWORD,
-    nInBufferSize: DWORD,
-    nDefaultTimeOut: DWORD,
-    lpSecurityAttributes: ?*const SECURITY_ATTRIBUTES,
-) callconv(.winapi) HANDLE;
-
-// TODO: Matches `STD_*_HANDLE` to peb().ProcessParameters.Standard*
-pub extern "kernel32" fn GetStdHandle(
-    nStdHandle: DWORD,
-) callconv(.winapi) ?HANDLE;
-
 // TODO: Wrapper around NtSetInformationFile + `FILE_POSITION_INFORMATION`.
 //  `FILE_STANDARD_INFORMATION` is also used if dwMoveMethod is `FILE_END`
 pub extern "kernel32" fn SetFilePointerEx(
@@ -117,11 +80,6 @@ pub extern "kernel32" fn WriteFile(
     in_out_lpOverlapped: ?*OVERLAPPED,
 ) callconv(.winapi) BOOL;
 
-// TODO: Wrapper around GetStdHandle + NtFlushBuffersFile.
-pub extern "kernel32" fn FlushFileBuffers(
-    hFile: HANDLE,
-) callconv(.winapi) BOOL;
-
 // TODO: Wrapper around NtSetInformationFile + `FILE_IO_COMPLETION_NOTIFICATION_INFORMATION`.
 pub extern "kernel32" fn SetFileCompletionNotificationModes(
     FileHandle: HANDLE,
@@ -143,24 +101,6 @@ pub extern "kernel32" fn GetSystemDirectoryW(
 
 // I/O - Kernel Objects
 
-// TODO: Wrapper around GetStdHandle + NtDuplicateObject.
-pub extern "kernel32" fn DuplicateHandle(
-    hSourceProcessHandle: HANDLE,
-    hSourceHandle: HANDLE,
-    hTargetProcessHandle: HANDLE,
-    lpTargetHandle: *HANDLE,
-    dwDesiredAccess: ACCESS_MASK,
-    bInheritHandle: BOOL,
-    dwOptions: DWORD,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around GetStdHandle + NtQueryObject + NtSetInformationObject with .ObjectHandleFlagInformation.
-pub extern "kernel32" fn SetHandleInformation(
-    hObject: HANDLE,
-    dwMask: DWORD,
-    dwFlags: DWORD,
-) callconv(.winapi) BOOL;
-
 // TODO: Wrapper around NtRemoveIoCompletion.
 pub extern "kernel32" fn GetQueuedCompletionStatus(
     CompletionPort: HANDLE,
@@ -210,37 +150,6 @@ pub extern "kernel32" fn TerminateProcess(
     uExitCode: UINT,
 ) callconv(.winapi) BOOL;
 
-// TODO: WaitForSingleObjectEx with bAlertable=false.
-pub extern "kernel32" fn WaitForSingleObject(
-    hHandle: HANDLE,
-    dwMilliseconds: DWORD,
-) callconv(.winapi) DWORD;
-
-// TODO: Wrapper for GetStdHandle + NtWaitForSingleObject.
-// Sets up an activation context before calling NtWaitForSingleObject.
-pub extern "kernel32" fn WaitForSingleObjectEx(
-    hHandle: HANDLE,
-    dwMilliseconds: DWORD,
-    bAlertable: BOOL,
-) callconv(.winapi) DWORD;
-
-// TODO: WaitForMultipleObjectsEx with alertable=false
-pub extern "kernel32" fn WaitForMultipleObjects(
-    nCount: DWORD,
-    lpHandle: [*]const HANDLE,
-    bWaitAll: BOOL,
-    dwMilliseconds: DWORD,
-) callconv(.winapi) DWORD;
-
-// TODO: Wrapper around NtWaitForMultipleObjects.
-pub extern "kernel32" fn WaitForMultipleObjectsEx(
-    nCount: DWORD,
-    lpHandle: [*]const HANDLE,
-    bWaitAll: BOOL,
-    dwMilliseconds: DWORD,
-    bAlertable: BOOL,
-) callconv(.winapi) DWORD;
-
 // Process Management
 
 pub extern "kernel32" fn CreateProcessW(
@@ -256,12 +165,6 @@ pub extern "kernel32" fn CreateProcessW(
     lpProcessInformation: *PROCESS_INFORMATION,
 ) callconv(.winapi) BOOL;
 
-// TODO: implement via ntdll instead
-pub extern "kernel32" fn SleepEx(
-    dwMilliseconds: DWORD,
-    bAlertable: BOOL,
-) callconv(.winapi) DWORD;
-
 // TODO: Wrapper around NtQueryInformationProcess with `PROCESS_BASIC_INFORMATION`.
 pub extern "kernel32" fn GetExitCodeProcess(
     hProcess: HANDLE,
@@ -436,14 +339,3 @@ pub extern "kernel32" fn FormatMessageW(
 
 // TODO: Getter for teb().LastErrorValue.
 pub extern "kernel32" fn GetLastError() callconv(.winapi) Win32Error;
-
-// TODO: Wrapper around RtlSetLastWin32Error.
-pub extern "kernel32" fn SetLastError(
-    dwErrCode: Win32Error,
-) callconv(.winapi) void;
-
-// Everything Else
-
-pub extern "kernel32" fn GetSystemInfo(
-    lpSystemInfo: *SYSTEM_INFO,
-) callconv(.winapi) void;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index d9e68e54f9f275fbf254098e8b7716aad2cead5e..bda9fee828b6dc33c44b4a40b090c1d0f6761d84 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -407,6 +407,11 @@ pub extern "ntdll" fn NtCreateNamedPipeFile(
     DefaultTimeout: ?*const LARGE_INTEGER,
 ) callconv(.winapi) NTSTATUS;
 
+pub extern "ntdll" fn NtFlushBuffersFile(
+    FileHandle: HANDLE,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
+
 pub extern "ntdll" fn NtMapViewOfSection(
     SectionHandle: HANDLE,
     ProcessHandle: HANDLE,
@@ -590,7 +595,7 @@ pub extern "ntdll" fn NtOpenThread(
 
 pub extern "ntdll" fn NtCancelSynchronousIoFile(
     ThreadHandle: HANDLE,
-    RequestToCancel: ?*IO_STATUS_BLOCK,
+    IoRequestToCancel: ?*IO_STATUS_BLOCK,
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
 
@@ -606,13 +611,13 @@ pub extern "ntdll" fn NtDelayExecution(
     DelayInterval: *const LARGE_INTEGER,
 ) callconv(.winapi) NTSTATUS;
 
+pub extern "ntdll" fn NtCancelIoFile(
+    FileHandle: HANDLE,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
+
 pub extern "ntdll" fn NtCancelIoFileEx(
     FileHandle: HANDLE,
     IoRequestToCancel: *const IO_STATUS_BLOCK,
     IoStatusBlock: *IO_STATUS_BLOCK,
 ) callconv(.winapi) NTSTATUS;
-
-pub extern "ntdll" fn NtCancelIoFile(
-    FileHandle: HANDLE,
-    IoStatusBlock: *IO_STATUS_BLOCK,
-) callconv(.winapi) NTSTATUS;
diff --git a/lib/std/process/Environ.zig b/lib/std/process/Environ.zig
index 5255e1af16ab86f4e1e29158cbfda3c8c8830c66..e33024de3525fcabfaa08a5be5fc8e80dd4dd026 100644
--- a/lib/std/process/Environ.zig
+++ b/lib/std/process/Environ.zig
@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 const native_os = builtin.os.tag;
 
 const std = @import("../std.zig");
-const Allocator = std.mem.Allocator;
+const Allocator = mem.Allocator;
 const assert = std.debug.assert;
 const testing = std.testing;
 const unicode = std.unicode;
@@ -14,12 +14,7 @@ const mem = std.mem;
 /// Unmodified, unprocessed data provided by the operating system.
 block: Block,
 
-pub const empty: Environ = .{
-    .block = switch (Block) {
-        void => {},
-        else => &.{},
-    },
-};
+pub const empty: Environ = .{ .block = .empty };
 
 /// On WASI without libc, this is `void` because the environment has to be
 /// queried and heap-allocated at runtime.
@@ -28,13 +23,65 @@ pub const empty: Environ = .{
 /// is modified, so a long-lived pointer cannot be used. Therefore, on this
 /// operating system `void` is also used.
 pub const Block = switch (native_os) {
-    .windows => void,
+    .windows => GlobalBlock,
     .wasi => switch (builtin.link_libc) {
-        false => void,
-        true => [:null]const ?[*:0]const u8,
+        false => GlobalBlock,
+        true => PosixBlock,
     },
-    .freestanding, .other => void,
-    else => [:null]const ?[*:0]const u8,
+    .freestanding, .other => GlobalBlock,
+    else => PosixBlock,
+};
+
+pub const GlobalBlock = struct {
+    use_global: bool,
+
+    pub const empty: GlobalBlock = .{ .use_global = false };
+    pub const global: GlobalBlock = .{ .use_global = true };
+
+    pub fn deinit(_: GlobalBlock, _: Allocator) void {}
+};
+
+pub const PosixBlock = struct {
+    slice: [:null]const ?[*:0]const u8,
+
+    pub const empty: PosixBlock = .{ .slice = &.{} };
+
+    pub fn deinit(block: PosixBlock, gpa: Allocator) void {
+        for (block.slice) |entry| gpa.free(mem.span(entry.?));
+        gpa.free(block.slice);
+    }
+
+    pub const View = struct {
+        slice: []const [*:0]const u8,
+
+        pub fn isEmpty(v: View) bool {
+            return v.slice.len == 0;
+        }
+    };
+    pub fn view(block: PosixBlock) View {
+        return .{ .slice = @ptrCast(block.slice) };
+    }
+};
+
+pub const WindowsBlock = struct {
+    slice: [:0]const u16,
+
+    pub const empty: WindowsBlock = .{ .slice = &.{0} };
+
+    pub fn deinit(block: WindowsBlock, gpa: Allocator) void {
+        gpa.free(block.slice);
+    }
+
+    pub const View = struct {
+        ptr: [*:0]const u16,
+
+        pub fn isEmpty(v: View) bool {
+            return v.ptr[0] == 0;
+        }
+    };
+    pub fn view(block: WindowsBlock) View {
+        return .{ .ptr = block.slice.ptr };
+    }
 };
 
 pub const Map = struct {
@@ -46,47 +93,60 @@ pub const Map = struct {
     pub const Size = usize;
 
     pub const EnvNameHashContext = struct {
-        fn upcase(c: u21) u21 {
-            if (c <= std.math.maxInt(u16))
-                return std.os.windows.ntdll.RtlUpcaseUnicodeChar(@as(u16, @intCast(c)));
-            return c;
-        }
-
         pub fn hash(self: @This(), s: []const u8) u32 {
             _ = self;
-            if (native_os == .windows) {
-                var h = std.hash.Wyhash.init(0);
-                var it = unicode.Wtf8View.initUnchecked(s).iterator();
-                while (it.nextCodepoint()) |cp| {
-                    const cp_upper = upcase(cp);
-                    h.update(&[_]u8{
-                        @as(u8, @intCast((cp_upper >> 16) & 0xff)),
-                        @as(u8, @intCast((cp_upper >> 8) & 0xff)),
-                        @as(u8, @intCast((cp_upper >> 0) & 0xff)),
-                    });
-                }
-                return @truncate(h.final());
+            switch (native_os) {
+                else => return std.array_hash_map.hashString(s),
+                .windows => {
+                    var h = std.hash.Wyhash.init(0);
+                    var it = unicode.Wtf8View.initUnchecked(s).iterator();
+                    while (it.nextCodepoint()) |cp| {
+                        const cp_upper = if (std.math.cast(u16, cp)) |wtf16|
+                            std.os.windows.toUpperWtf16(wtf16)
+                        else
+                            cp;
+                        h.update(&[_]u8{
+                            @truncate(cp_upper >> 0),
+                            @truncate(cp_upper >> 8),
+                            @truncate(cp_upper >> 16),
+                        });
+                    }
+                    return @truncate(h.final());
+                },
             }
-            return std.array_hash_map.hashString(s);
         }
 
         pub fn eql(self: @This(), a: []const u8, b: []const u8, b_index: usize) bool {
             _ = self;
             _ = b_index;
-            if (native_os == .windows) {
-                var it_a = unicode.Wtf8View.initUnchecked(a).iterator();
-                var it_b = unicode.Wtf8View.initUnchecked(b).iterator();
-                while (true) {
-                    const c_a = it_a.nextCodepoint() orelse break;
-                    const c_b = it_b.nextCodepoint() orelse return false;
-                    if (upcase(c_a) != upcase(c_b))
-                        return false;
-                }
-                return if (it_b.nextCodepoint()) |_| false else true;
-            }
-            return std.array_hash_map.eqlString(a, b);
+            return eqlKeys(a, b);
         }
     };
+    fn eqlKeys(a: []const u8, b: []const u8) bool {
+        return switch (native_os) {
+            else => std.array_hash_map.eqlString(a, b),
+            .windows => std.os.windows.eqlIgnoreCaseWtf8(a, b),
+        };
+    }
+
+    pub fn validateKey(key: []const u8) bool {
+        switch (native_os) {
+            else => return key.len > 0 and mem.findAny(u8, key, &.{ 0, '=' }) == null,
+            .windows => {
+                if (!unicode.wtf8ValidateSlice(key)) return false;
+                var it = unicode.Wtf8View.initUnchecked(key).iterator();
+                switch (it.nextCodepoint() orelse return false) {
+                    0 => return false,
+                    else => {},
+                }
+                while (it.nextCodepoint()) |cp| switch (cp) {
+                    0, '=' => return false,
+                    else => {},
+                };
+                return true;
+            },
+        }
+    }
 
     /// Create a Map backed by a specific allocator.
     /// That allocator will be used for both backing allocations
@@ -99,30 +159,71 @@ pub const Map = struct {
     /// of the stored keys and values.
     pub fn deinit(self: *Map) void {
         const gpa = self.allocator;
-        var it = self.array_hash_map.iterator();
-        while (it.next()) |entry| {
-            gpa.free(entry.key_ptr.*);
-            gpa.free(entry.value_ptr.*);
-        }
+        for (self.keys()) |key| gpa.free(key);
+        for (self.values()) |value| gpa.free(value);
         self.array_hash_map.deinit(gpa);
         self.* = undefined;
     }
 
-    pub fn keys(m: *const Map) [][]const u8 {
-        return m.array_hash_map.keys();
+    pub fn keys(map: *const Map) [][]const u8 {
+        return map.array_hash_map.keys();
     }
 
-    pub fn values(m: *const Map) [][]const u8 {
-        return m.array_hash_map.values();
+    pub fn values(map: *const Map) [][]const u8 {
+        return map.array_hash_map.values();
+    }
+
+    pub fn putPosixBlock(map: *Map, view: PosixBlock.View) Allocator.Error!void {
+        for (view.slice) |entry| {
+            var entry_i: usize = 0;
+            while (entry[entry_i] != 0 and entry[entry_i] != '=') : (entry_i += 1) {}
+            const key = entry[0..entry_i];
+
+            var end_i: usize = entry_i;
+            while (entry[end_i] != 0) : (end_i += 1) {}
+            const value = entry[entry_i + 1 .. end_i];
+
+            try map.put(key, value);
+        }
+    }
+
+    pub fn putWindowsBlock(map: *Map, view: WindowsBlock.View) Allocator.Error!void {
+        var i: usize = 0;
+        while (view.ptr[i] != 0) {
+            const key_start = i;
+
+            // There are some special environment variables that start with =,
+            // so we need a special case to not treat = as a key/value separator
+            // if it's the first character.
+            // https://devblogs.microsoft.com/oldnewthing/20100506-00/?p=14133
+            if (view.ptr[key_start] == '=') i += 1;
+
+            while (view.ptr[i] != 0 and view.ptr[i] != '=') : (i += 1) {}
+            const key_w = view.ptr[key_start..i];
+            const key = try unicode.wtf16LeToWtf8Alloc(map.allocator, key_w);
+            errdefer map.allocator.free(key);
+
+            if (view.ptr[i] == '=') i += 1;
+
+            const value_start = i;
+            while (view.ptr[i] != 0) : (i += 1) {}
+            const value_w = view.ptr[value_start..i];
+            const value = try unicode.wtf16LeToWtf8Alloc(map.allocator, value_w);
+            errdefer map.allocator.free(value);
+
+            i += 1; // skip over null byte
+
+            try map.putMove(key, value);
+        }
     }
 
     /// Same as `put` but the key and value become owned by the Map rather
     /// than being copied.
     /// If `putMove` fails, the ownership of key and value does not transfer.
     /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
-    pub fn putMove(self: *Map, key: []u8, value: []u8) !void {
+    pub fn putMove(self: *Map, key: []u8, value: []u8) Allocator.Error!void {
+        assert(validateKey(key));
         const gpa = self.allocator;
-        assert(unicode.wtf8ValidateSlice(key));
         const get_or_put = try self.array_hash_map.getOrPut(gpa, key);
         if (get_or_put.found_existing) {
             gpa.free(get_or_put.key_ptr.*);
@@ -134,8 +235,8 @@ pub const Map = struct {
 
     /// `key` and `value` are copied into the Map.
     /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
-    pub fn put(self: *Map, key: []const u8, value: []const u8) !void {
-        assert(unicode.wtf8ValidateSlice(key));
+    pub fn put(self: *Map, key: []const u8, value: []const u8) Allocator.Error!void {
+        assert(validateKey(key));
         const gpa = self.allocator;
         const value_copy = try gpa.dupe(u8, value);
         errdefer gpa.free(value_copy);
@@ -155,7 +256,7 @@ pub const Map = struct {
     /// The returned pointer is invalidated if the map resizes.
     /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
     pub fn getPtr(self: Map, key: []const u8) ?*[]const u8 {
-        assert(unicode.wtf8ValidateSlice(key));
+        assert(validateKey(key));
         return self.array_hash_map.getPtr(key);
     }
 
@@ -164,11 +265,12 @@ pub const Map = struct {
     /// key is removed from the map.
     /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
     pub fn get(self: Map, key: []const u8) ?[]const u8 {
-        assert(unicode.wtf8ValidateSlice(key));
+        assert(validateKey(key));
         return self.array_hash_map.get(key);
     }
 
     pub fn contains(m: *const Map, key: []const u8) bool {
+        assert(validateKey(key));
         return m.array_hash_map.contains(key);
     }
 
@@ -181,7 +283,7 @@ pub const Map = struct {
     /// This invalidates the value returned by get() for this key.
     /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
     pub fn swapRemove(self: *Map, key: []const u8) bool {
-        assert(unicode.wtf8ValidateSlice(key));
+        assert(validateKey(key));
         const kv = self.array_hash_map.fetchSwapRemove(key) orelse return false;
         const gpa = self.allocator;
         gpa.free(kv.key);
@@ -198,7 +300,7 @@ pub const Map = struct {
     /// This invalidates the value returned by get() for this key.
     /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
     pub fn orderedRemove(self: *Map, key: []const u8) bool {
-        assert(unicode.wtf8ValidateSlice(key));
+        assert(validateKey(key));
         const kv = self.array_hash_map.fetchOrderedRemove(key) orelse return false;
         const gpa = self.allocator;
         gpa.free(kv.key);
@@ -233,105 +335,120 @@ pub const Map = struct {
 
     /// Creates a null-delimited environment variable block in the format
     /// expected by POSIX, from a hash map plus options.
-    pub fn createBlockPosix(
+    pub fn createPosixBlock(
         map: *const Map,
-        arena: Allocator,
-        options: CreateBlockPosixOptions,
-    ) Allocator.Error![:null]?[*:0]u8 {
+        gpa: Allocator,
+        options: CreatePosixBlockOptions,
+    ) Allocator.Error!PosixBlock {
         const ZigProgressAction = enum { nothing, edit, delete, add };
-        const zig_progress_action: ZigProgressAction = a: {
-            const fd = options.zig_progress_fd orelse break :a .nothing;
-            const exists = map.get("ZIG_PROGRESS") != null;
+        const zig_progress_action: ZigProgressAction = action: {
+            const fd = options.zig_progress_fd orelse break :action .nothing;
+            const exists = map.contains("ZIG_PROGRESS");
             if (fd >= 0) {
-                break :a if (exists) .edit else .add;
+                break :action if (exists) .edit else .add;
             } else {
-                if (exists) break :a .delete;
+                if (exists) break :action .delete;
             }
-            break :a .nothing;
+            break :action .nothing;
         };
 
-        const envp_count: usize = c: {
-            var c: usize = map.count();
+        const envp = try gpa.allocSentinel(?[*:0]u8, len: {
+            var len: usize = map.count();
             switch (zig_progress_action) {
-                .add => c += 1,
-                .delete => c -= 1,
+                .add => len += 1,
+                .delete => len -= 1,
                 .nothing, .edit => {},
             }
-            break :c c;
-        };
-
-        const envp_buf = try arena.allocSentinel(?[*:0]u8, envp_count, null);
-        var i: usize = 0;
+            break :len len;
+        }, null);
+        var envp_len: usize = 0;
+        errdefer {
+            envp[envp_len] = null;
+            PosixBlock.deinit(.{ .slice = envp[0..envp_len :null] }, gpa);
+        }
 
         if (zig_progress_action == .add) {
-            envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
-            i += 1;
+            envp[envp_len] = try std.fmt.allocPrintSentinel(gpa, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
+            envp_len += 1;
         }
 
-        {
-            var it = map.iterator();
-            while (it.next()) |pair| {
-                if (mem.eql(u8, pair.key_ptr.*, "ZIG_PROGRESS")) switch (zig_progress_action) {
-                    .add => unreachable,
-                    .delete => continue,
-                    .edit => {
-                        envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "{s}={d}", .{
-                            pair.key_ptr.*, options.zig_progress_fd.?,
-                        }, 0);
-                        i += 1;
-                        continue;
-                    },
-                    .nothing => {},
-                };
+        for (map.keys(), map.values()) |key, value| {
+            if (mem.eql(u8, key, "ZIG_PROGRESS")) switch (zig_progress_action) {
+                .add => unreachable,
+                .delete => continue,
+                .edit => {
+                    envp[envp_len] = try std.fmt.allocPrintSentinel(gpa, "{s}={d}", .{
+                        key, options.zig_progress_fd.?,
+                    }, 0);
+                    envp_len += 1;
+                    continue;
+                },
+                .nothing => {},
+            };
 
-                envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "{s}={s}", .{ pair.key_ptr.*, pair.value_ptr.* }, 0);
-                i += 1;
-            }
+            envp[envp_len] = try std.fmt.allocPrintSentinel(gpa, "{s}={s}", .{ key, value }, 0);
+            envp_len += 1;
         }
 
-        assert(i == envp_count);
-        return envp_buf;
+        assert(envp_len == envp.len);
+        return .{ .slice = envp };
     }
 
     /// Caller owns result.
-    pub fn createBlockWindows(map: *const Map, gpa: Allocator) error{ OutOfMemory, InvalidWtf8 }![:0]u16 {
+    pub fn createWindowsBlock(
+        map: *const Map,
+        gpa: Allocator,
+        options: CreateWindowsBlockOptions,
+    ) error{ OutOfMemory, InvalidWtf8 }!WindowsBlock {
         // count bytes needed
-        const max_chars_needed = x: {
-            // Only need 2 trailing NUL code units for an empty environment
-            var max_chars_needed: usize = if (map.count() == 0) 2 else 1;
-            var it = map.iterator();
-            while (it.next()) |pair| {
-                // +1 for '='
-                // +1 for null byte
-                max_chars_needed += pair.key_ptr.len + pair.value_ptr.len + 2;
+        const max_chars_needed = max_chars_needed: {
+            var max_chars_needed: usize = "\x00".len;
+            if (options.zig_progress_handle) |handle| if (handle != std.os.windows.INVALID_HANDLE_VALUE) {
+                max_chars_needed += std.fmt.count("ZIG_PROGRESS={d}\x00", .{@intFromPtr(handle)});
+            };
+            for (map.keys(), map.values()) |key, value| {
+                if (options.zig_progress_handle != null and eqlKeys(key, "ZIG_PROGRESS")) continue;
+                max_chars_needed += key.len + "=".len + value.len + "\x00".len;
             }
-            break :x max_chars_needed;
+            break :max_chars_needed @max("\x00\x00".len, max_chars_needed);
         };
-        const result = try gpa.alloc(u16, max_chars_needed);
-        errdefer gpa.free(result);
+        const block = try gpa.alloc(u16, max_chars_needed);
+        errdefer gpa.free(block);
 
-        var it = map.iterator();
         var i: usize = 0;
-        while (it.next()) |pair| {
-            i += try unicode.wtf8ToWtf16Le(result[i..], pair.key_ptr.*);
-            result[i] = '=';
+        if (options.zig_progress_handle) |handle| if (handle != std.os.windows.INVALID_HANDLE_VALUE) {
+            @memcpy(
+                block[i..][0.."ZIG_PROGRESS=".len],
+                &[_]u16{ 'Z', 'I', 'G', '_', 'P', 'R', 'O', 'G', 'R', 'E', 'S', 'S', '=' },
+            );
+            i += "ZIG_PROGRESS=".len;
+            var value_buf: [std.fmt.count("{d}", .{std.math.maxInt(usize)})]u8 = undefined;
+            const value = std.fmt.bufPrint(&value_buf, "{d}", .{@intFromPtr(handle)}) catch unreachable;
+            for (block[i..][0..value.len], value) |*r, v| r.* = v;
+            i += value.len;
+            block[i] = 0;
             i += 1;
-            i += try unicode.wtf8ToWtf16Le(result[i..], pair.value_ptr.*);
-            result[i] = 0;
+        };
+        for (map.keys(), map.values()) |key, value| {
+            if (options.zig_progress_handle != null and eqlKeys(key, "ZIG_PROGRESS")) continue;
+            i += try unicode.wtf8ToWtf16Le(block[i..], key);
+            block[i] = '=';
+            i += 1;
+            i += try unicode.wtf8ToWtf16Le(block[i..], value);
+            block[i] = 0;
             i += 1;
         }
-        result[i] = 0;
-        i += 1;
         // An empty environment is a special case that requires a redundant
         // NUL terminator. CreateProcess will read the second code unit even
         // though theoretically the first should be enough to recognize that the
         // environment is empty (see https://nullprogram.com/blog/2023/08/23/)
-        if (map.count() == 0) {
-            result[i] = 0;
+        for (0..2) |_| {
+            block[i] = 0;
             i += 1;
-        }
-        const reallocated = try gpa.realloc(result, i);
-        return reallocated[0 .. i - 1 :0];
+            if (i >= 2) break;
+        } else unreachable;
+        const reallocated = try gpa.realloc(block, i);
+        return .{ .slice = reallocated[0 .. i - 1 :0] };
     }
 };
 
@@ -344,13 +461,18 @@ pub const CreateMapError = error{
 
 /// Allocates a `Map` and copies environment block into it.
 pub fn createMap(env: Environ, allocator: Allocator) CreateMapError!Map {
-    if (native_os == .windows)
-        return createMapWide(std.os.windows.peb().ProcessParameters.Environment, allocator);
+    var map = Map.init(allocator);
+    errdefer map.deinit();
+    if (native_os == .windows) empty: {
+        if (!env.block.use_global) break :empty;
 
-    var result = Map.init(allocator);
-    errdefer result.deinit();
+        const peb = std.os.windows.peb();
+        assert(std.os.windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
+        defer assert(std.os.windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
+        try map.putWindowsBlock(.{ .ptr = peb.ProcessParameters.Environment });
+    } else if (native_os == .wasi and !builtin.link_libc) empty: {
+        if (!env.block.use_global) break :empty;
 
-    if (native_os == .wasi and !builtin.link_libc) {
         var environ_count: usize = undefined;
         var environ_buf_size: usize = undefined;
 
@@ -360,7 +482,7 @@ pub fn createMap(env: Environ, allocator: Allocator) CreateMapError!Map {
         }
 
         if (environ_count == 0) {
-            return result;
+            return map;
         }
 
         const environ = try allocator.alloc([*:0]u8, environ_count);
@@ -373,63 +495,9 @@ pub fn createMap(env: Environ, allocator: Allocator) CreateMapError!Map {
             return posix.unexpectedErrno(environ_get_ret);
         }
 
-        for (environ) |line| {
-            const pair = mem.sliceTo(line, 0);
-            var parts = mem.splitScalar(u8, pair, '=');
-            const key = parts.first();
-            const value = parts.rest();
-            try result.put(key, value);
-        }
-        return result;
-    } else {
-        for (env.block) |opt_line| {
-            const line = opt_line.?;
-            var line_i: usize = 0;
-            while (line[line_i] != 0 and line[line_i] != '=') : (line_i += 1) {}
-            const key = line[0..line_i];
-
-            var end_i: usize = line_i;
-            while (line[end_i] != 0) : (end_i += 1) {}
-            const value = line[line_i + 1 .. end_i];
-
-            try result.put(key, value);
-        }
-        return result;
-    }
-}
-
-pub fn createMapWide(ptr: [*:0]u16, gpa: Allocator) CreateMapError!Map {
-    var result = Map.init(gpa);
-    errdefer result.deinit();
-
-    var i: usize = 0;
-    while (ptr[i] != 0) {
-        const key_start = i;
-
-        // There are some special environment variables that start with =,
-        // so we need a special case to not treat = as a key/value separator
-        // if it's the first character.
-        // https://devblogs.microsoft.com/oldnewthing/20100506-00/?p=14133
-        if (ptr[key_start] == '=') i += 1;
-
-        while (ptr[i] != 0 and ptr[i] != '=') : (i += 1) {}
-        const key_w = ptr[key_start..i];
-        const key = try unicode.wtf16LeToWtf8Alloc(gpa, key_w);
-        errdefer gpa.free(key);
-
-        if (ptr[i] == '=') i += 1;
-
-        const value_start = i;
-        while (ptr[i] != 0) : (i += 1) {}
-        const value_w = ptr[value_start..i];
-        const value = try unicode.wtf16LeToWtf8Alloc(gpa, value_w);
-        errdefer gpa.free(value);
-
-        i += 1; // skip over null byte
-
-        try result.putMove(key, value);
-    }
-    return result;
+        try map.putPosixBlock(.{ .slice = environ });
+    } else try map.putPosixBlock(env.block.view());
+    return map;
 }
 
 pub const ContainsError = error{
@@ -451,6 +519,7 @@ pub const ContainsError = error{
 /// * `containsConstant`
 /// * `containsUnempty`
 pub fn contains(environ: Environ, gpa: Allocator, key: []const u8) ContainsError!bool {
+    if (native_os == .windows and !unicode.wtf8ValidateSlice(key)) return error.InvalidWtf8;
     var map = try createMap(environ, gpa);
     defer map.deinit();
     return map.contains(key);
@@ -464,6 +533,7 @@ pub fn contains(environ: Environ, gpa: Allocator, key: []const u8) ContainsError
 /// * `containsUnemptyConstant`
 /// * `contains`
 pub fn containsUnempty(environ: Environ, gpa: Allocator, key: []const u8) ContainsError!bool {
+    if (native_os == .windows and !unicode.wtf8ValidateSlice(key)) return error.InvalidWtf8;
     var map = try createMap(environ, gpa);
     defer map.deinit();
     const value = map.get(key) orelse return false;
@@ -516,16 +586,15 @@ pub inline fn containsUnemptyConstant(environ: Environ, comptime key: []const u8
 /// * `createMap`
 pub fn getPosix(environ: Environ, key: []const u8) ?[:0]const u8 {
     if (mem.findScalar(u8, key, '=') != null) return null;
-    for (environ.block) |opt_line| {
-        const line = opt_line.?;
-        var line_i: usize = 0;
-        while (line[line_i] != 0) : (line_i += 1) {
-            if (line_i == key.len) break;
-            if (line[line_i] != key[line_i]) break;
+    for (environ.block.view().slice) |entry| {
+        var entry_i: usize = 0;
+        while (entry[entry_i] != 0) : (entry_i += 1) {
+            if (entry_i == key.len) break;
+            if (entry[entry_i] != key[entry_i]) break;
         }
-        if ((line_i != key.len) or (line[line_i] != '=')) continue;
+        if ((entry_i != key.len) or (entry[entry_i] != '=')) continue;
 
-        return mem.sliceTo(line + line_i + 1, 0);
+        return mem.sliceTo(entry + entry_i + 1, 0);
     }
     return null;
 }
@@ -541,14 +610,16 @@ pub fn getPosix(environ: Environ, key: []const u8) ?[:0]const u8 {
 /// * `containsConstant`
 /// * `contains`
 pub fn getWindows(environ: Environ, key: [*:0]const u16) ?[:0]const u16 {
-    comptime assert(native_os == .windows);
-    comptime assert(@TypeOf(environ.block) == void);
-
     // '=' anywhere but the start makes this an invalid environment variable name.
     const key_slice = mem.sliceTo(key, 0);
-    if (key_slice.len > 0 and mem.findScalar(u16, key_slice[1..], '=') != null) return null;
+    assert(key_slice.len > 0 and mem.findScalar(u16, key_slice[1..], '=') == null);
 
-    const ptr = std.os.windows.peb().ProcessParameters.Environment;
+    if (!environ.block.use_global) return null;
+
+    const peb = std.os.windows.peb();
+    assert(std.os.windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
+    defer assert(std.os.windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
+    const ptr = peb.ProcessParameters.Environment;
 
     var i: usize = 0;
     while (ptr[i] != 0) {
@@ -558,8 +629,7 @@ pub fn getWindows(environ: Environ, key: [*:0]const u16) ?[:0]const u16 {
         // so we need a special case to not treat = as a key/value separator
         // if it's the first character.
         // https://devblogs.microsoft.com/oldnewthing/20100506-00/?p=14133
-        const equal_search_start: usize = if (key_value[0] == '=') 1 else 0;
-        const equal_index = mem.findScalarPos(u16, key_value, equal_search_start, '=') orelse {
+        const equal_index = mem.findScalarPos(u16, key_value, 1, '=') orelse {
             // This is enforced by CreateProcess.
             // If violated, CreateProcess will fail with INVALID_PARAMETER.
             unreachable; // must contain a =
@@ -598,13 +668,14 @@ pub const GetAllocError = error{
 /// See also:
 /// * `createMap`
 pub fn getAlloc(environ: Environ, gpa: Allocator, key: []const u8) GetAllocError![]u8 {
+    if (native_os == .windows and !unicode.wtf8ValidateSlice(key)) return error.InvalidWtf8;
     var map = createMap(environ, gpa) catch return error.OutOfMemory;
     defer map.deinit();
     const val = map.get(key) orelse return error.EnvironmentVariableMissing;
     return gpa.dupe(u8, val);
 }
 
-pub const CreateBlockPosixOptions = struct {
+pub const CreatePosixBlockOptions = struct {
     /// `null` means to leave the `ZIG_PROGRESS` environment variable unmodified.
     /// If non-null, negative means to remove the environment variable, and >= 0
     /// means to provide it with the given integer.
@@ -613,67 +684,147 @@ pub const CreateBlockPosixOptions = struct {
 
 /// Creates a null-delimited environment variable block in the format expected
 /// by POSIX, from a different one.
-pub fn createBlockPosix(
+pub fn createPosixBlock(
     existing: Environ,
-    arena: Allocator,
-    options: CreateBlockPosixOptions,
-) Allocator.Error![:null]?[*:0]u8 {
-    const contains_zig_progress = for (existing.block) |opt_line| {
-        if (mem.eql(u8, mem.sliceTo(opt_line.?, '='), "ZIG_PROGRESS")) break true;
+    gpa: Allocator,
+    options: CreatePosixBlockOptions,
+) Allocator.Error!PosixBlock {
+    const contains_zig_progress = for (existing.block.view().slice) |entry| {
+        if (mem.eql(u8, mem.sliceTo(entry, '='), "ZIG_PROGRESS")) break true;
     } else false;
 
     const ZigProgressAction = enum { nothing, edit, delete, add };
-    const zig_progress_action: ZigProgressAction = a: {
-        const fd = options.zig_progress_fd orelse break :a .nothing;
+    const zig_progress_action: ZigProgressAction = action: {
+        const fd = options.zig_progress_fd orelse break :action .nothing;
         if (fd >= 0) {
-            break :a if (contains_zig_progress) .edit else .add;
+            break :action if (contains_zig_progress) .edit else .add;
         } else {
-            if (contains_zig_progress) break :a .delete;
+            if (contains_zig_progress) break :action .delete;
         }
-        break :a .nothing;
+        break :action .nothing;
     };
 
-    const envp_count: usize = c: {
-        var count: usize = existing.block.len;
+    const envp = try gpa.allocSentinel(?[*:0]u8, len: {
+        var len: usize = existing.block.slice.len;
         switch (zig_progress_action) {
-            .add => count += 1,
-            .delete => count -= 1,
+            .add => len += 1,
+            .delete => len -= 1,
             .nothing, .edit => {},
         }
-        break :c count;
-    };
-
-    const envp_buf = try arena.allocSentinel(?[*:0]u8, envp_count, null);
-    var i: usize = 0;
-    var existing_index: usize = 0;
-
+        break :len len;
+    }, null);
+    var envp_len: usize = 0;
+    errdefer {
+        envp[envp_len] = null;
+        PosixBlock.deinit(.{ .slice = envp[0..envp_len :null] }, gpa);
+    }
     if (zig_progress_action == .add) {
-        envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
-        i += 1;
+        envp[envp_len] = try std.fmt.allocPrintSentinel(gpa, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
+        envp_len += 1;
     }
 
-    while (existing.block[existing_index]) |line| : (existing_index += 1) {
-        if (mem.eql(u8, mem.sliceTo(line, '='), "ZIG_PROGRESS")) switch (zig_progress_action) {
+    var existing_index: usize = 0;
+    while (existing.block.slice[existing_index]) |entry| : (existing_index += 1) {
+        if (mem.eql(u8, mem.sliceTo(entry, '='), "ZIG_PROGRESS")) switch (zig_progress_action) {
             .add => unreachable,
             .delete => continue,
             .edit => {
-                envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
-                i += 1;
+                envp[envp_len] = try std.fmt.allocPrintSentinel(gpa, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
+                envp_len += 1;
                 continue;
             },
             .nothing => {},
         };
-        envp_buf[i] = try arena.dupeZ(u8, mem.span(line));
-        i += 1;
+        envp[envp_len] = try gpa.dupeZ(u8, mem.span(entry));
+        envp_len += 1;
     }
 
-    assert(i == envp_count);
-    return envp_buf;
+    assert(envp_len == envp.len);
+    return .{ .slice = envp };
+}
+
+pub const CreateWindowsBlockOptions = struct {
+    /// `null` means to leave the `ZIG_PROGRESS` environment variable unmodified.
+    /// If non-null, `std.os.windows.INVALID_HANDLE_VALUE` means to remove the
+    /// environment variable, otherwise provide it with the given handle as an integer.
+    zig_progress_handle: ?std.os.windows.HANDLE = null,
+};
+
+/// Creates a null-delimited environment variable block in the format expected
+/// by POSIX, from a different one.
+pub fn createWindowsBlock(
+    existing: Environ,
+    gpa: Allocator,
+    options: CreateWindowsBlockOptions,
+) Allocator.Error!WindowsBlock {
+    if (!existing.block.use_global) return .{
+        .slice = try gpa.dupeSentinel(u16, WindowsBlock.empty.slice, 0),
+    };
+    const peb = std.os.windows.peb();
+    assert(std.os.windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
+    defer assert(std.os.windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
+    const existing_block = peb.ProcessParameters.Environment;
+    var ranges: [2]struct { start: usize, end: usize } = undefined;
+    var ranges_len: usize = 0;
+    ranges[ranges_len].start = 0;
+    const zig_progress_key = [_]u16{ 'Z', 'I', 'G', '_', 'P', 'R', 'O', 'G', 'R', 'E', 'S', 'S', '=' };
+    const needed_len = needed_len: {
+        var needed_len: usize = "\x00".len;
+        if (options.zig_progress_handle) |handle| if (handle != std.os.windows.INVALID_HANDLE_VALUE) {
+            needed_len += std.fmt.count("ZIG_PROGRESS={d}\x00", .{@intFromPtr(handle)});
+        };
+        var i: usize = 0;
+        while (existing_block[i] != 0) {
+            const start = i;
+            const entry = mem.sliceTo(existing_block[start..], 0);
+            i += entry.len + "\x00".len;
+            if (options.zig_progress_handle != null and entry.len >= zig_progress_key.len and
+                std.os.windows.eqlIgnoreCaseWtf16(entry[0..zig_progress_key.len], &zig_progress_key))
+            {
+                ranges[ranges_len].end = start;
+                ranges_len += 1;
+                ranges[ranges_len].start = i;
+            } else needed_len += entry.len + "\x00".len;
+        }
+        ranges[ranges_len].end = i;
+        ranges_len += 1;
+        break :needed_len @max("\x00\x00".len, needed_len);
+    };
+    const block = try gpa.alloc(u16, needed_len);
+    errdefer gpa.free(block);
+    var i: usize = 0;
+    if (options.zig_progress_handle) |handle| if (handle != std.os.windows.INVALID_HANDLE_VALUE) {
+        @memcpy(block[i..][0..zig_progress_key.len], &zig_progress_key);
+        i += zig_progress_key.len;
+        var value_buf: [std.fmt.count("{d}", .{std.math.maxInt(usize)})]u8 = undefined;
+        const value = std.fmt.bufPrint(&value_buf, "{d}", .{@intFromPtr(handle)}) catch unreachable;
+        for (block[i..][0..value.len], value) |*r, v| r.* = v;
+        i += value.len;
+        block[i] = 0;
+        i += 1;
+    };
+    for (ranges[0..ranges_len]) |range| {
+        const range_len = range.end - range.start;
+        @memcpy(block[i..][0..range_len], existing_block[range.start..range.end]);
+        i += range_len;
+    }
+    // An empty environment is a special case that requires a redundant
+    // NUL terminator. CreateProcess will read the second code unit even
+    // though theoretically the first should be enough to recognize that the
+    // environment is empty (see https://nullprogram.com/blog/2023/08/23/)
+    for (0..2) |_| {
+        block[i] = 0;
+        i += 1;
+        if (i >= 2) break;
+    } else unreachable;
+    assert(i == block.len);
+    return .{ .slice = block[0 .. i - 1 :0] };
 }
 
-test "Map.createBlock" {
-    const allocator = testing.allocator;
-    var envmap = Map.init(allocator);
+test "Map.createPosixBlock" {
+    const gpa = testing.allocator;
+
+    var envmap = Map.init(gpa);
     defer envmap.deinit();
 
     try envmap.put("HOME", "/home/ifreund");
@@ -682,29 +833,24 @@ test "Map.createBlock" {
     try envmap.put("DEBUGINFOD_URLS", " ");
     try envmap.put("XCURSOR_SIZE", "24");
 
-    var arena = std.heap.ArenaAllocator.init(allocator);
-    defer arena.deinit();
-    const environ = try envmap.createBlockPosix(arena.allocator(), .{});
+    const block = try envmap.createPosixBlock(gpa, .{});
+    defer block.deinit(gpa);
 
-    try testing.expectEqual(@as(usize, 5), environ.len);
+    try testing.expectEqual(@as(usize, 5), block.slice.len);
 
-    inline for (.{
+    for (&[_][]const u8{
         "HOME=/home/ifreund",
         "WAYLAND_DISPLAY=wayland-1",
         "DISPLAY=:1",
         "DEBUGINFOD_URLS= ",
         "XCURSOR_SIZE=24",
-    }) |target| {
-        for (environ) |variable| {
-            if (mem.eql(u8, mem.span(variable orelse continue), target)) break;
-        } else {
-            try testing.expect(false); // Environment variable not found
-        }
-    }
+    }, block.slice) |expected, actual| try testing.expectEqualStrings(expected, mem.span(actual.?));
 }
 
 test Map {
-    var env = Map.init(testing.allocator);
+    const gpa = testing.allocator;
+
+    var env: Map = .init(gpa);
     defer env.deinit();
 
     try env.put("SOMETHING_NEW", "hello");
@@ -740,6 +886,7 @@ test Map {
     try testing.expect(env.swapRemove("SOMETHING_NEW"));
     try testing.expect(!env.swapRemove("SOMETHING_NEW"));
     try testing.expect(env.get("SOMETHING_NEW") == null);
+    try testing.expect(!env.contains("SOMETHING_NEW"));
 
     try testing.expectEqual(@as(Map.Size, 1), env.count());
 
@@ -749,10 +896,10 @@ test Map {
         try testing.expectEqualStrings("something else", env.get("кириллица").?);
 
         // and WTF-8 that's not valid UTF-8
-        const wtf8_with_surrogate_pair = try unicode.wtf16LeToWtf8Alloc(testing.allocator, &[_]u16{
+        const wtf8_with_surrogate_pair = try unicode.wtf16LeToWtf8Alloc(gpa, &[_]u16{
             mem.nativeToLittle(u16, 0xD83D), // unpaired high surrogate
         });
-        defer testing.allocator.free(wtf8_with_surrogate_pair);
+        defer gpa.free(wtf8_with_surrogate_pair);
 
         try env.put(wtf8_with_surrogate_pair, wtf8_with_surrogate_pair);
         try testing.expectEqualSlices(u8, wtf8_with_surrogate_pair, env.get(wtf8_with_surrogate_pair).?);
@@ -769,13 +916,9 @@ test "convert from Environ to Map and back again" {
     defer map.deinit();
     try map.put("FOO", "BAR");
     try map.put("A", "");
-    try map.put("", "B");
 
-    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
-    defer arena_allocator.deinit();
-    const arena = arena_allocator.allocator();
-
-    const environ: Environ = .{ .block = try map.createBlockPosix(arena, .{}) };
+    const environ: Environ = .{ .block = try map.createPosixBlock(gpa, .{}) };
+    defer environ.block.deinit(gpa);
 
     try testing.expectEqual(true, environ.contains(gpa, "FOO"));
     try testing.expectEqual(false, environ.contains(gpa, "BAR"));
@@ -783,7 +926,6 @@ test "convert from Environ to Map and back again" {
     try testing.expectEqual(true, environ.containsConstant("A"));
     try testing.expectEqual(false, environ.containsUnempty(gpa, "A"));
     try testing.expectEqual(false, environ.containsUnemptyConstant("A"));
-    try testing.expectEqual(true, environ.contains(gpa, ""));
     try testing.expectEqual(false, environ.contains(gpa, "B"));
 
     try testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(gpa, "BOGUS"));
@@ -800,23 +942,47 @@ test "convert from Environ to Map and back again" {
     try testing.expectEqualDeep(map.values(), map2.values());
 }
 
-test createMapWide {
-    if (builtin.cpu.arch.endian() == .big) return error.SkipZigTest; // TODO
+test "Map.putPosixBlock" {
+    const gpa = testing.allocator;
+
+    var map: Map = .init(gpa);
+    defer map.deinit();
+
+    try map.put("FOO", "BAR");
+    try map.put("A", "");
+    try map.put("ZIG_PROGRESS", "unchanged");
+
+    const block = try map.createPosixBlock(gpa, .{});
+    defer block.deinit(gpa);
+
+    var map2: Map = .init(gpa);
+    defer map2.deinit();
+    try map2.putPosixBlock(block.view());
+
+    try testing.expectEqualDeep(&[_][]const u8{ "FOO", "A", "ZIG_PROGRESS" }, map2.keys());
+    try testing.expectEqualDeep(&[_][]const u8{ "BAR", "", "unchanged" }, map2.values());
+}
+
+test "Map.putWindowsBlock" {
+    if (native_os != .windows) return;
 
     const gpa = testing.allocator;
 
     var map: Map = .init(gpa);
     defer map.deinit();
+
     try map.put("FOO", "BAR");
     try map.put("A", "");
-    try map.put("", "B");
+    try map.put("=B", "");
+    try map.put("ZIG_PROGRESS", "unchanged");
 
-    const environ: [:0]u16 = try map.createBlockWindows(gpa);
-    defer gpa.free(environ);
+    const block = try map.createWindowsBlock(gpa, .{});
+    defer block.deinit(gpa);
 
-    var map2 = try createMapWide(environ, gpa);
+    var map2: Map = .init(gpa);
     defer map2.deinit();
+    try map2.putWindowsBlock(block.view());
 
-    try testing.expectEqualDeep(&[_][]const u8{ "FOO", "A", "=B" }, map2.keys());
-    try testing.expectEqualDeep(&[_][]const u8{ "BAR", "", "" }, map2.values());
+    try testing.expectEqualDeep(&[_][]const u8{ "FOO", "A", "=B", "ZIG_PROGRESS" }, map2.keys());
+    try testing.expectEqualDeep(&[_][]const u8{ "BAR", "", "", "unchanged" }, map2.values());
 }
diff --git a/lib/std/start.zig b/lib/std/start.zig
index a8c281ae160f75bdf5c63d1d6c55484ed9a29f7e..e39465fe9b395b0cc4a4395eb589d98b42ac3232 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -90,15 +90,15 @@ fn _DllMainCRTStartup(
 fn wasm_freestanding_start() callconv(.c) void {
     // This is marked inline because for some reason LLVM in
     // release mode fails to inline it, and we want fewer call frames in stack traces.
-    _ = @call(.always_inline, callMain, .{ {}, {} });
+    _ = @call(.always_inline, callMain, .{ {}, std.process.Environ.Block.global });
 }
 
 fn startWasi() callconv(.c) void {
     // The function call is marked inline because for some reason LLVM in
     // release mode fails to inline it, and we want fewer call frames in stack traces.
     switch (builtin.wasi_exec_model) {
-        .reactor => _ = @call(.always_inline, callMain, .{ {}, {} }),
-        .command => std.os.wasi.proc_exit(@call(.always_inline, callMain, .{ {}, {} })),
+        .reactor => _ = @call(.always_inline, callMain, .{ {}, std.process.Environ.Block.global }),
+        .command => std.os.wasi.proc_exit(@call(.always_inline, callMain, .{ {}, std.process.Environ.Block.global })),
     }
 }
 
@@ -476,7 +476,7 @@ fn WinStartup() callconv(.withStackAlign(.c, 1)) noreturn {
     const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
     const cmd_line_w = cmd_line.Buffer.?[0..@divExact(cmd_line.Length, 2)];
 
-    std.os.windows.ntdll.RtlExitUserProcess(callMain(cmd_line_w, {}));
+    std.os.windows.ntdll.RtlExitUserProcess(callMain(cmd_line_w, .global));
 }
 
 fn wWinMainCRTStartup() callconv(.withStackAlign(.c, 1)) noreturn {
@@ -620,13 +620,14 @@ fn expandStackSize(phdrs: []elf.Phdr) void {
 }
 
 inline fn callMainWithArgs(argc: usize, argv: [*][*:0]u8, envp: [:null]?[*:0]u8) u8 {
+    const env_block: std.process.Environ.Block = .{ .slice = envp };
     if (std.Options.debug_threaded_io) |t| {
         if (@sizeOf(std.Io.Threaded.Argv0) != 0) t.argv0.value = argv[0];
-        t.environ = .{ .process_environ = .{ .block = envp } };
+        t.environ = .{ .process_environ = .{ .block = env_block } };
     }
     std.Thread.maybeAttachSignalStack();
     std.debug.maybeEnableSegfaultHandler();
-    return callMain(argv[0..argc], envp);
+    return callMain(argv[0..argc], env_block);
 }
 
 fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) callconv(.c) c_int {
@@ -648,7 +649,7 @@ fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) cal
             std.debug.maybeEnableSegfaultHandler();
             const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
             const cmd_line_w = cmd_line.Buffer.?[0..@divExact(cmd_line.Length, 2)];
-            return callMain(cmd_line_w, {});
+            return callMain(cmd_line_w, .global);
         },
         else => {},
     }
@@ -661,7 +662,7 @@ fn mainWithoutEnv(c_argc: c_int, c_argv: [*][*:0]c_char) callconv(.c) c_int {
     if (@sizeOf(std.Io.Threaded.Argv0) != 0) {
         if (std.Options.debug_threaded_io) |t| t.argv0.value = argv[0];
     }
-    return callMain(argv, &.{});
+    return callMain(argv, .empty);
 }
 
 /// General error message for a malformed return type
diff --git a/test/standalone/env_vars/main.zig b/test/standalone/env_vars/main.zig
index 09167f285fe9960fbedb8f9fcb179bc354ca15f4..6ffcae81aecb867afbcf91cdbf92b2678ff575ac 100644
--- a/test/standalone/env_vars/main.zig
+++ b/test/standalone/env_vars/main.zig
@@ -12,14 +12,10 @@ pub fn main(init: std.process.Init) !void {
     // containsUnempty
     {
         try std.testing.expect(try environ.containsUnempty(allocator, "FOO"));
-        try std.testing.expect(!(try environ.containsUnempty(allocator, "FOO=")));
-        try std.testing.expect(!(try environ.containsUnempty(allocator, "FO")));
-        try std.testing.expect(!(try environ.containsUnempty(allocator, "FOOO")));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.containsUnempty(allocator, "foo"));
         }
         try std.testing.expect(try environ.containsUnempty(allocator, "EQUALS"));
-        try std.testing.expect(!(try environ.containsUnempty(allocator, "EQUALS=ABC")));
         try std.testing.expect(try environ.containsUnempty(allocator, "КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.containsUnempty(allocator, "кирИЛЛица"));
@@ -35,14 +31,10 @@ pub fn main(init: std.process.Init) !void {
     // containsUnemptyConstant
     {
         try std.testing.expect(environ.containsUnemptyConstant("FOO"));
-        try std.testing.expect(!environ.containsUnemptyConstant("FOO="));
-        try std.testing.expect(!environ.containsUnemptyConstant("FO"));
-        try std.testing.expect(!environ.containsUnemptyConstant("FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsUnemptyConstant("foo"));
         }
         try std.testing.expect(environ.containsUnemptyConstant("EQUALS"));
-        try std.testing.expect(!environ.containsUnemptyConstant("EQUALS=ABC"));
         try std.testing.expect(environ.containsUnemptyConstant("КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsUnemptyConstant("кирИЛЛица"));
@@ -58,14 +50,10 @@ pub fn main(init: std.process.Init) !void {
     // contains
     {
         try std.testing.expect(try environ.contains(allocator, "FOO"));
-        try std.testing.expect(!(try environ.contains(allocator, "FOO=")));
-        try std.testing.expect(!(try environ.contains(allocator, "FO")));
-        try std.testing.expect(!(try environ.contains(allocator, "FOOO")));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.contains(allocator, "foo"));
         }
         try std.testing.expect(try environ.contains(allocator, "EQUALS"));
-        try std.testing.expect(!(try environ.contains(allocator, "EQUALS=ABC")));
         try std.testing.expect(try environ.contains(allocator, "КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.contains(allocator, "кирИЛЛица"));
@@ -81,14 +69,10 @@ pub fn main(init: std.process.Init) !void {
     // containsConstant
     {
         try std.testing.expect(environ.containsConstant("FOO"));
-        try std.testing.expect(!environ.containsConstant("FOO="));
-        try std.testing.expect(!environ.containsConstant("FO"));
-        try std.testing.expect(!environ.containsConstant("FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsConstant("foo"));
         }
         try std.testing.expect(environ.containsConstant("EQUALS"));
-        try std.testing.expect(!environ.containsConstant("EQUALS=ABC"));
         try std.testing.expect(environ.containsConstant("КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsConstant("кирИЛЛица"));
@@ -104,14 +88,10 @@ pub fn main(init: std.process.Init) !void {
     // getAlloc
     {
         try std.testing.expectEqualSlices(u8, "123", try environ.getAlloc(arena, "FOO"));
-        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "FOO="));
-        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "FO"));
-        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "123", try environ.getAlloc(arena, "foo"));
         }
         try std.testing.expectEqualSlices(u8, "ABC=123", try environ.getAlloc(arena, "EQUALS"));
-        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "EQUALS=ABC"));
         try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try environ.getAlloc(arena, "КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try environ.getAlloc(arena, "кирИЛЛица"));
@@ -130,13 +110,10 @@ pub fn main(init: std.process.Init) !void {
         defer environ_map.deinit();
 
         try std.testing.expectEqualSlices(u8, "123", environ_map.get("FOO").?);
-        try std.testing.expectEqual(null, environ_map.get("FO"));
-        try std.testing.expectEqual(null, environ_map.get("FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "123", environ_map.get("foo").?);
         }
         try std.testing.expectEqualSlices(u8, "ABC=123", environ_map.get("EQUALS").?);
-        try std.testing.expectEqual(null, environ_map.get("EQUALS=ABC"));
         try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", environ_map.get("КИРиллИЦА").?);
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", environ_map.get("кирИЛЛица").?);
diff --git a/test/standalone/windows_argv/fuzz.zig b/test/standalone/windows_argv/fuzz.zig
index b955697d3867afe69bf1396699ce96c41c7a7e15..9227bb6f893306686dc0ad08de2cfca89410b815 100644
--- a/test/standalone/windows_argv/fuzz.zig
+++ b/test/standalone/windows_argv/fuzz.zig
@@ -125,7 +125,7 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
             .lpReserved2 = null,
             .hStdInput = null,
             .hStdOutput = null,
-            .hStdError = windows.GetStdHandle(windows.STD_ERROR_HANDLE) catch null,
+            .hStdError = windows.peb().ProcessParameters.hStdError,
         };
         var proc_info: windows.PROCESS_INFORMATION = undefined;
 
@@ -149,7 +149,12 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
         break :spawn proc_info.hProcess;
     };
     defer windows.CloseHandle(child_proc);
-    try windows.WaitForSingleObjectEx(child_proc, windows.INFINITE, false);
+    const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
+    switch (windows.ntdll.NtWaitForSingleObject(child_proc, windows.FALSE, &infinite_timeout)) {
+        windows.NTSTATUS.WAIT_0 => {},
+        .TIMEOUT => return error.WaitTimeOut,
+        else => |status| return windows.unexpectedStatus(status),
+    }
 
     var exit_code: windows.DWORD = undefined;
     if (windows.kernel32.GetExitCodeProcess(child_proc, &exit_code) == 0) {
diff --git a/test/standalone/windows_spawn/main.zig b/test/standalone/windows_spawn/main.zig
index 18c9a68c57b9194e72c8f8b29859dd382307cb65..ea28900dac55e76b1c971a55cc9206383a902817 100644
--- a/test/standalone/windows_spawn/main.zig
+++ b/test/standalone/windows_spawn/main.zig
@@ -233,12 +233,13 @@ fn testExecWithCwdInner(gpa: Allocator, io: Io, command: []const u8, cwd: std.pr
 }
 
 fn renameExe(dir: Io.Dir, io: Io, old_sub_path: []const u8, new_sub_path: []const u8) !void {
-    var attempt: u5 = 0;
+    var attempt: u5 = 10;
     while (true) break dir.rename(old_sub_path, dir, new_sub_path, io) catch |err| switch (err) {
         error.AccessDenied => {
-            if (attempt == 13) return error.AccessDenied;
+            if (attempt == 26) return error.AccessDenied;
             // give the kernel a chance to finish closing the executable handle
-            _ = std.os.windows.kernel32.SleepEx(@as(u32, 1) << attempt >> 1, std.os.windows.FALSE);
+            const interval = @as(std.os.windows.LARGE_INTEGER, -1) << attempt;
+            _ = std.os.windows.ntdll.NtDelayExecution(std.os.windows.FALSE, &interval);
             attempt += 1;
             continue;
         },
-- 
2.54.0


From fcdde3e4c796fcaf160b6161040df8d458523e95 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Feb 2026 15:36:25 +0100
Subject: [PATCH 194/499] std.Io.Threaded: gracefully handle race leading to
 ESRCH in unpark()

---
 lib/std/Io/Threaded.zig | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c1c63067817b99ea620173ce6807e86ce279cd9e..129ad59543d5a6bd59f441c681dbabdd89d7fdd8 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -17548,8 +17548,8 @@ fn unpark(tids: []const UnparkTid, addr_hint: ?*const anyopaque) void {
             switch (posix.errno(std.c._lwp_unpark_all(@ptrCast(tids.ptr), tids.len, addr_hint))) {
                 .SUCCESS => return,
                 // For errors, fall through to a loop over `tids`, though this is only expected to
-                // be possible for ENOMEM (and even that is questionable).
-                .SRCH => recoverableOsBugDetected(),
+                // be possible for ENOMEM (even that is questionable) and ESRCH (see comment below).
+                .SRCH => {},
                 .FAULT => recoverableOsBugDetected(),
                 .INVAL => recoverableOsBugDetected(),
                 .NOMEM => {},
@@ -17558,7 +17558,11 @@ fn unpark(tids: []const UnparkTid, addr_hint: ?*const anyopaque) void {
             for (tids) |tid| {
                 switch (posix.errno(std.c._lwp_unpark(@bitCast(tid), addr_hint))) {
                     .SUCCESS => {},
-                    .SRCH => recoverableOsBugDetected(),
+                    .SRCH => {
+                        // This can happen in a rare race: the thread might have been spuriously
+                        // unparked, so already observed the changing status, and from there have
+                        // exited. That's okay, because the thread has woken up like we wanted.
+                    },
                     else => recoverableOsBugDetected(),
                 }
             }
-- 
2.54.0


From a816f9e245b7f0db96fddc727e2c7004bdb88056 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Feb 2026 17:59:21 +0000
Subject: [PATCH 195/499] std.Io.Threaded: use _lwp_park correctly for real
 this time?

---
 lib/std/Io/Threaded.zig | 76 +++++++++++++++++++++++++----------------
 1 file changed, 47 insertions(+), 29 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 129ad59543d5a6bd59f441c681dbabdd89d7fdd8..be0bb284c3bda515d55ca6a39060dccdfa38bf18 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -628,6 +628,7 @@ const Thread = struct {
     cancel_protection: Io.CancelProtection,
     /// Always released when `Status.cancelation` is set to `.parked`.
     futex_waiter: if (use_parking_futex) ?*parking_futex.Waiter else ?noreturn,
+    unpark_flag: UnparkFlag,
 
     csprng: Csprng,
 
@@ -1018,6 +1019,7 @@ const Thread = struct {
                     if (thread.futex_waiter) |futex_waiter| {
                         parking_futex.removeCanceledWaiter(futex_waiter);
                     }
+                    if (need_unpark_flag) setUnparkFlag(&thread.unpark_flag);
                     unpark(&.{thread.id}, null);
                     return false;
                 },
@@ -1559,6 +1561,7 @@ fn worker(t: *Threaded) void {
         }),
         .cancel_protection = .unblocked,
         .futex_waiter = undefined,
+        .unpark_flag = unpark_flag_init,
         .csprng = .{},
     };
     Thread.current = &thread;
@@ -17007,6 +17010,7 @@ const parking_futex = struct {
         /// * Unparking the thread (*after* the above, so that the `Waiter` does not go out of scope
         ///   while it is still in the `Bucket`).
         thread_status: *std.atomic.Value(Thread.Status),
+        unpark_flag: if (need_unpark_flag) *UnparkFlag else void,
     };
 
     fn bucketForAddress(address: usize) *Bucket {
@@ -17045,9 +17049,11 @@ const parking_futex = struct {
             .address = @intFromPtr(ptr),
             .tid = self_tid,
             .thread_status = undefined, // populated in critical section
+            .unpark_flag = undefined, // populated in critical section
         };
 
         var status_buf: std.atomic.Value(Thread.Status) = undefined;
+        var unpark_flag_buf: UnparkFlag = unpark_flag_init;
 
         {
             bucket.mutex.lock();
@@ -17062,7 +17068,7 @@ const parking_futex = struct {
 
             // This is in the critical section to avoid marking the thread as parked until we're
             // certain that we're actually going to park.
-            waiter.thread_status = status: {
+            waiter.thread_status, waiter.unpark_flag = status: {
                 cancelable: {
                     if (uncancelable) break :cancelable;
                     const thread = opt_thread orelse break :cancelable;
@@ -17090,19 +17096,19 @@ const parking_futex = struct {
                         .blocked_canceling => unreachable,
                     }
                     // We could now be unparked for a cancelation at any time!
-                    break :status &thread.status;
+                    break :status .{ &thread.status, if (need_unpark_flag) &thread.unpark_flag };
                 }
                 // This is an uncancelable wait, so just use `status_buf`. Note that the value of
                 // `status_buf.awaitable` is irrelevant because this is only visible to futex code,
                 // while only cancelation cares about `awaitable`.
                 status_buf.raw = .{ .cancelation = .parked, .awaitable = .null };
-                break :status &status_buf;
+                break :status .{ &status_buf, if (need_unpark_flag) &unpark_flag_buf };
             };
 
             bucket.waiters.append(&waiter.node);
         }
 
-        if (park(timeout, ptr, waiter.thread_status)) {
+        if (park(timeout, ptr, waiter.unpark_flag)) {
             // We were unparked by either `wake` or cancelation, so our current status is either
             // `.none` or `.canceling`. In either case, they've already removed `waiter` from
             // `bucket`, so we have nothing more to do!
@@ -17127,7 +17133,7 @@ const parking_futex = struct {
                         // to unpark us. Whoever did that will remove us from `bucket`. Wait for
                         // that (and drop the unpark request in doing so).
                         // New status is `.none` or `.canceling` respectively.
-                        park(.none, ptr, waiter.thread_status) catch |e| switch (e) {
+                        park(.none, ptr, waiter.unpark_flag) catch |e| switch (e) {
                             error.Timeout => unreachable,
                         };
                     },
@@ -17201,6 +17207,7 @@ const parking_futex = struct {
             waking_head = node.next;
             const waiter: *Waiter = @fieldParentPtr("node", node);
             unpark_buf[unpark_len] = waiter.tid;
+            if (need_unpark_flag) setUnparkFlag(waiter.unpark_flag);
             unpark_len += 1;
             if (unpark_len == unpark_buf.len) {
                 unpark(&unpark_buf, ptr);
@@ -17249,7 +17256,7 @@ const parking_sleep = struct {
                     .blocked_canceling => unreachable,
                 }
             }
-            if (park(timeout, null, &thread.status)) {
+            if (park(timeout, null, if (need_unpark_flag) &thread.unpark_flag)) {
                 // The only reason this could possibly happen is cancelation.
                 const old_status = thread.status.load(.monotonic);
                 assert(old_status.cancelation == .canceling);
@@ -17272,7 +17279,7 @@ const parking_sleep = struct {
                             // us for a cancelation. Whoever did that will have called `unpark`, so
                             // drop that unpark request by waiting for it.
                             // Status is still `.canceling`.
-                            park(.none, null, &thread.status) catch |e| switch (e) {
+                            park(.none, null, if (need_unpark_flag) &thread.unpark_flag) catch |e| switch (e) {
                                 error.Timeout => unreachable,
                             };
                             return;
@@ -17288,8 +17295,8 @@ const parking_sleep = struct {
             }
         }
         // Uncancelable sleep; we expect not to be manually unparked.
-        var dummy_status: std.atomic.Value(Thread.Status) = .init(.{ .cancelation = .parked, .awaitable = .null });
-        if (park(timeout, null, &dummy_status)) {
+        var dummy_flag: UnparkFlag = unpark_flag_init;
+        if (park(timeout, null, if (need_unpark_flag) &dummy_flag)) {
             unreachable; // unexpected unpark
         } else |err| switch (err) {
             error.Timeout => return,
@@ -17322,7 +17329,7 @@ const ParkingMutex = struct {
         }
     };
     const Waiter = struct {
-        status: std.atomic.Value(Thread.Status),
+        unpark_flag: UnparkFlag,
         /// Never modified once the `Waiter` is in the linked list.
         next: ?*Waiter,
         /// Never modified once the `Waiter` is in the linked list.
@@ -17345,7 +17352,7 @@ const ParkingMutex = struct {
                 const self_tid = if (Thread.current) |t| t.id else std.Thread.getCurrentId();
                 var waiter: Waiter = .{
                     .next = old_waiter,
-                    .status = .init(.{ .cancelation = .parked, .awaitable = .null }),
+                    .unpark_flag = unpark_flag_init,
                     .tid = self_tid,
                 };
                 if (m.state.cmpxchgWeak(
@@ -17357,11 +17364,9 @@ const ParkingMutex = struct {
                     continue :state new_state;
                 }
                 // We're now in the list of waiters---park until we're given the lock.
-                park(.none, m, &waiter.status) catch |err| switch (err) {
+                park(.none, m, if (need_unpark_flag) &waiter.unpark_flag) catch |err| switch (err) {
                     error.Timeout => unreachable,
                 };
-                // We now hold the lock.
-                assert(waiter.status.load(.monotonic).cancelation == .none);
                 return;
             },
         }
@@ -17383,7 +17388,7 @@ const ParkingMutex = struct {
             _ => |last_state| {
                 // The logic here does not have ABA problems, and does some accesses non-atomically,
                 // because `Waiter.next` is owned by the lock holder (that's us!) once the waiter is
-                // in the linked list, up until we set `Waiter.status` to `.none`.
+                // in the linked list, up until we unpark the waiter.
 
                 // Run through the waiter list to the end to ensure fairness. This is obviously not
                 // ideal, but it shouldn't be a big deal in practice provided the critical section
@@ -17412,8 +17417,8 @@ const ParkingMutex = struct {
                     }
                 }
                 // Now we're ready to actually hand the lock over to them.
-                const tid = waiter.tid; // load this before the store below potentially invalidates `waiter`
-                waiter.status.store(.{ .cancelation = .none, .awaitable = .null }, .release); // release lock
+                const tid = waiter.tid; // load before the unpark below potentially invalidates `waiter`
+                if (need_unpark_flag) setUnparkFlag(&waiter.unpark_flag);
                 unpark(&.{tid}, m);
                 return;
             },
@@ -17451,15 +17456,34 @@ fn timeoutToWindowsInterval(timeout: Io.Timeout) ?windows.LARGE_INTEGER {
     }
 }
 
+/// The API on NetBSD and Illumos sucks and can unpark spuriously (well, it *can't*, but signals
+/// cause an indistinguishable unblock, and libpthread really likes to leave unparks pending).
+/// As such, on these targets only, we need to pass around a flag to track whether a thread is
+/// "actually" being unparked.
+const need_unpark_flag = switch (native_os) {
+    .netbsd, .illumos => true,
+    else => false,
+};
+const UnparkFlag = if (need_unpark_flag) std.atomic.Value(bool) else void;
+const unpark_flag_init: UnparkFlag = if (need_unpark_flag) .init(false);
+/// Must be called before `unpark`. After this function is called, the thread may be unparked at any
+/// time, so the caller must not reference values on its stack.
+fn setUnparkFlag(f: *UnparkFlag) void {
+    f.store(true, .release);
+}
+
+/// The type passed into `unpark` for the thread ID. You'd think this was just a `std.Thread.Id`,
+/// but it seems that someone at Microsoft forgot how big their TIDs are supposed to be.
+const UnparkTid = switch (native_os) {
+    .windows => usize,
+    else => std.Thread.Id,
+};
+
 fn park(
     timeout: Io.Timeout,
     /// This value has no semantic effect, but may allow the OS to optimize the operation.
     addr_hint: ?*const anyopaque,
-    /// The API on NetBSD and Illumos sucks and can unpark spuriously (well, it *can't*, but signals
-    /// cause an indistinguishable unblock, and libpthread really likes to leave unparks pending).
-    /// As such, on these targets only, this `status` is checked to determine if an unpark is real.
-    /// no way to differentiate
-    status: *std.atomic.Value(Thread.Status),
+    unpark_flag: if (need_unpark_flag) *UnparkFlag else void,
 ) error{Timeout}!void {
     comptime assert(use_parking_futex or use_parking_sleep);
     switch (native_os) {
@@ -17502,7 +17526,7 @@ fn park(
             };
             // It's okay to pass the same timeout in a loop. If it's a duration, the OS actually
             // writes the remaining time into the buffer when the syscall returns.
-            while (status.load(.monotonic).cancelation == .parked) {
+            while (!unpark_flag.swap(false, .acquire)) {
                 switch (posix.errno(std.c._lwp_park(
                     if (clock_real) .REALTIME else .MONOTONIC,
                     .{ .ABSTIME = abstime },
@@ -17523,12 +17547,6 @@ fn park(
         else => comptime unreachable,
     }
 }
-
-const UnparkTid = switch (native_os) {
-    // `NtAlertMultipleThreadByThreadId` is weird and wants 64-bit thread IDs?
-    .windows => usize,
-    else => std.Thread.Id,
-};
 /// `addr_hint` has no semantic effect, but may allow the OS to optimize this operation.
 fn unpark(tids: []const UnparkTid, addr_hint: ?*const anyopaque) void {
     comptime assert(use_parking_futex or use_parking_sleep);
-- 
2.54.0


From 06879041acfe73e62f549a412d9f012a190113a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Feb 2026 00:00:06 +0100
Subject: [PATCH 196/499] link.Lld: disable parallel linking on NetBSD host

To work around NetBSD 10.1 malloc bugs.
---
 src/link/Lld.zig | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/link/Lld.zig b/src/link/Lld.zig
index fa94e534593a81c853c85911bf7054af03b65eab..5c7ba84623bde145063b4ff87b08434840ec43d9 100644
--- a/src/link/Lld.zig
+++ b/src/link/Lld.zig
@@ -356,6 +356,16 @@ fn linkAsArchive(lld: *Lld, arena: Allocator) !void {
     if (bad) return error.UnableToWriteArchive;
 }
 
+fn addCommonArgs(argv: *std.array_list.Managed([]const u8), coff: bool) !void {
+    if (builtin.os.tag == .netbsd) {
+        // NetBSD 10.1's `malloc` appears to have some nasty bugs that occur
+        // when doing parallel linking in LLD, manifesting as input and/or
+        // output section memory randomly being unmapped. So just don't do
+        // parallel linking for now.
+        try argv.append(if (coff) "-threads:1" else "--threads=1");
+    }
+}
+
 fn coffLink(lld: *Lld, arena: Allocator) !void {
     const comp = lld.base.comp;
     const gpa = comp.gpa;
@@ -418,6 +428,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void {
         // it calls exit() and does not reset all global data between invocations.
         const linker_command = "lld-link";
         try argv.appendSlice(&[_][]const u8{ comp.self_exe_path.?, linker_command });
+        try addCommonArgs(&argv, true);
 
         if (target.isMinGW()) {
             try argv.append("-lldmingw");
@@ -836,6 +847,8 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
         // it calls exit() and does not reset all global data between invocations.
         const linker_command = "ld.lld";
         try argv.appendSlice(&[_][]const u8{ comp.self_exe_path.?, linker_command });
+        try addCommonArgs(&argv, false);
+
         if (is_obj) {
             try argv.append("-r");
         }
@@ -1401,6 +1414,8 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void {
         // it calls exit() and does not reset all global data between invocations.
         const linker_command = "wasm-ld";
         try argv.appendSlice(&[_][]const u8{ comp.self_exe_path.?, linker_command });
+        try addCommonArgs(&argv, false);
+
         try argv.append("--error-limit=0");
 
         if (comp.config.lto != .none) {
@@ -1724,6 +1739,7 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
     if (stderr.len > 0) log.warn("unexpected LLD stderr:\n{s}", .{stderr});
 }
 
+const builtin = @import("builtin");
 const std = @import("std");
 const Io = std.Io;
 const Allocator = std.mem.Allocator;
-- 
2.54.0


From 012be3efd779764de8cb910f3d07a25c13861c48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 3 Feb 2026 23:45:46 +0100
Subject: [PATCH 197/499] Revert "ci: temporarily disable x86_64-netbsd while I
 investigate failures"

This reverts commit 99ec1ee3536b577bd1d14facde523c503108886d.
---
 .forgejo/workflows/ci.yaml | 40 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 7e758bb67db1b935fd7fb4efeb7174a8a2f92ba1..48813b9001d0463d39b7ce8e2566ae5dad555b87 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -197,26 +197,26 @@ jobs:
         run: sh ci/x86_64-linux-release.sh
         timeout-minutes: 360
 
-  #x86_64-netbsd-debug:
-  #  runs-on: [self-hosted, x86_64-netbsd]
-  #  steps:
-  #    - name: Checkout
-  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-  #      with:
-  #        fetch-depth: 0
-  #    - name: Build and Test
-  #      run: sh ci/x86_64-netbsd-debug.sh
-  #      timeout-minutes: 120
-  #x86_64-netbsd-release:
-  #  runs-on: [self-hosted, x86_64-netbsd]
-  #  steps:
-  #    - name: Checkout
-  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-  #      with:
-  #        fetch-depth: 0
-  #    - name: Build and Test
-  #      run: sh ci/x86_64-netbsd-release.sh
-  #      timeout-minutes: 120
+  x86_64-netbsd-debug:
+    runs-on: [self-hosted, x86_64-netbsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/x86_64-netbsd-debug.sh
+        timeout-minutes: 120
+  x86_64-netbsd-release:
+    runs-on: [self-hosted, x86_64-netbsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/x86_64-netbsd-release.sh
+        timeout-minutes: 120
 
   x86_64-openbsd-debug:
     runs-on: [self-hosted, x86_64-openbsd]
-- 
2.54.0


From 71156aff806856d5d48e72cd8aeb9315b9ae0b62 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sat, 31 Jan 2026 20:22:53 -0500
Subject: [PATCH 198/499] std.Progress: implement ipc resource cleanup

---
 lib/std/Build/Step.zig  |  52 +--
 lib/std/Io/Threaded.zig |  93 ++--
 lib/std/Progress.zig    | 938 ++++++++++++++++++++--------------------
 lib/std/os/linux.zig    |  18 +
 4 files changed, 557 insertions(+), 544 deletions(-)

diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index b9581196c0ec59e125a8d0da6f607264f2afddb0..b518826843caad753b23051f92840af7b6143a22 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -386,10 +386,14 @@ pub const ZigProcess = struct {
     child: std.process.Child,
     multi_reader_buffer: Io.File.MultiReader.Buffer(2),
     multi_reader: Io.File.MultiReader,
-    progress_ipc_fd: if (std.Progress.have_ipc) ?std.posix.fd_t else void,
+    progress_ipc_index: ?if (std.Progress.have_ipc) std.Progress.Ipc.Index else noreturn,
 
     pub const StreamEnum = enum { stdout, stderr };
 
+    pub fn saveState(zp: *ZigProcess, prog_node: std.Progress.Node) void {
+        zp.progress_ipc_index = if (std.Progress.have_ipc) prog_node.takeIpcIndex() else null;
+    }
+
     pub fn deinit(zp: *ZigProcess, io: Io) void {
         zp.child.kill(io);
         zp.multi_reader.deinit();
@@ -417,7 +421,14 @@ pub fn evalZigProcess(
 
     if (s.getZigProcess()) |zp| update: {
         assert(watch);
-        if (std.Progress.have_ipc) if (zp.progress_ipc_fd) |fd| prog_node.setIpcFd(fd);
+        if (zp.progress_ipc_index) |ipc_index| prog_node.setIpcIndex(ipc_index);
+        zp.progress_ipc_index = null;
+        var exited = false;
+        defer if (exited) {
+            s.cast(Compile).?.zig_process = null;
+            zp.deinit(io);
+            gpa.destroy(zp);
+        } else zp.saveState(prog_node);
         const result = zigProcessUpdate(s, zp, watch, web_server, gpa) catch |err| switch (err) {
             error.BrokenPipe, error.EndOfStream => |reason| {
                 std.log.info("{s} restart required: {t}", .{ argv[0], reason });
@@ -426,7 +437,7 @@ pub fn evalZigProcess(
                     return s.fail("unable to wait for {s}: {t}", .{ argv[0], e });
                 };
                 _ = term;
-                s.clearZigProcess(gpa);
+                exited = true;
                 break :update;
             },
             else => |e| return e,
@@ -442,7 +453,7 @@ pub fn evalZigProcess(
                 return s.fail("unable to wait for {s}: {t}", .{ argv[0], e });
             };
             s.result_peak_rss = zp.child.resource_usage_statistics.getMaxRss() orelse 0;
-            s.clearZigProcess(gpa);
+            exited = true;
             try handleChildProcessTerm(s, term);
             return error.MakeFailed;
         }
@@ -467,19 +478,16 @@ pub fn evalZigProcess(
         .progress_node = prog_node,
     }) catch |err| return s.fail("failed to spawn zig compiler {s}: {t}", .{ argv[0], err });
 
-    zp.* = .{
-        .child = zp.child,
-        .multi_reader_buffer = undefined,
-        .multi_reader = undefined,
-        .progress_ipc_fd = if (std.Progress.have_ipc) prog_node.getIpcFd() else {},
-    };
     zp.multi_reader.init(gpa, io, zp.multi_reader_buffer.toStreams(), &.{
         zp.child.stdout.?, zp.child.stderr.?,
     });
-    if (watch) s.setZigProcess(zp);
+    if (watch) s.cast(Compile).?.zig_process = zp;
     defer if (!watch) zp.deinit(io);
 
-    const result = try zigProcessUpdate(s, zp, watch, web_server, gpa);
+    const result = result: {
+        defer if (watch) zp.saveState(prog_node);
+        break :result try zigProcessUpdate(s, zp, watch, web_server, gpa);
+    };
 
     if (!watch) {
         // Send EOF to stdin.
@@ -670,26 +678,6 @@ pub fn getZigProcess(s: *Step) ?*ZigProcess {
     };
 }
 
-fn setZigProcess(s: *Step, zp: *ZigProcess) void {
-    switch (s.id) {
-        .compile => s.cast(Compile).?.zig_process = zp,
-        else => unreachable,
-    }
-}
-
-fn clearZigProcess(s: *Step, gpa: Allocator) void {
-    switch (s.id) {
-        .compile => {
-            const compile = s.cast(Compile).?;
-            if (compile.zig_process) |zp| {
-                gpa.destroy(zp);
-                compile.zig_process = null;
-            }
-        },
-        else => unreachable,
-    }
-}
-
 fn sendMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag) !void {
     const header: std.zig.Client.Message.Header = .{
         .tag = tag,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 49132e79189842591b6b0a443bcd6cecd5a4fc85..197cc6c6574027cec15af7ede2edc49e265dee7e 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -19,7 +19,7 @@ const Alignment = std.mem.Alignment;
 const assert = std.debug.assert;
 const posix = std.posix;
 const windows = std.os.windows;
-const ws2_32 = std.os.windows.ws2_32;
+const ws2_32 = windows.ws2_32;
 
 /// Thread-safe.
 ///
@@ -2609,8 +2609,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                         // opportunity to find additional ready operations.
                         break :t 0;
                     }
-                    const max_poll_ms = std.math.maxInt(i32);
-                    break :t max_poll_ms;
+                    break :t std.math.maxInt(i32);
                 };
                 const syscall = try Syscall.start();
                 const rc = posix.system.poll(&poll_buffer, poll_len, timeout_ms);
@@ -2730,6 +2729,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
                     break :allocation allocation;
                 };
                 @memcpy(slice[0..poll_buffer_len], storage.slice);
+                storage.slice = slice;
             }
             storage.slice[len] = .{
                 .fd = file.handle,
@@ -2783,9 +2783,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
             }
             const d = deadline orelse break :t -1;
             const duration = d.durationFromNow(t_io);
-            if (duration.raw.nanoseconds <= 0) return error.Timeout;
-            const max_poll_ms = std.math.maxInt(i32);
-            break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
+            break :t @min(@max(0, duration.raw.toMilliseconds()), std.math.maxInt(i32));
         };
         const syscall = try Syscall.start();
         const rc = posix.system.poll(&poll_buffer, poll_storage.len, timeout_ms);
@@ -14420,7 +14418,10 @@ const WindowsEnvironStrings = struct {
     PATHEXT: ?[:0]const u16 = null,
 
     fn scan() WindowsEnvironStrings {
-        const ptr = windows.peb().ProcessParameters.Environment;
+        const peb = windows.peb();
+        assert(windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
+        defer assert(windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
+        const ptr = peb.ProcessParameters.Environment;
 
         var result: WindowsEnvironStrings = .{};
         var i: usize = 0;
@@ -14446,7 +14447,7 @@ const WindowsEnvironStrings = struct {
 
             inline for (@typeInfo(WindowsEnvironStrings).@"struct".fields) |field| {
                 const field_name_w = comptime std.unicode.wtf8ToWtf16LeStringLiteral(field.name);
-                if (std.os.windows.eqlIgnoreCaseWtf16(key_w, field_name_w)) @field(result, field.name) = value_w;
+                if (windows.eqlIgnoreCaseWtf16(key_w, field_name_w)) @field(result, field.name) = value_w;
             }
         }
 
@@ -14465,29 +14466,46 @@ fn scanEnviron(t: *Threaded) void {
         // This value expires with any call that modifies the environment,
         // which is outside of this Io implementation's control, so references
         // must be short-lived.
-        const ptr = windows.peb().ProcessParameters.Environment;
+        const peb = windows.peb();
+        assert(windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
+        defer assert(windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
+        const ptr = peb.ProcessParameters.Environment;
 
         var i: usize = 0;
         while (ptr[i] != 0) {
-            const key_start = i;
 
             // There are some special environment variables that start with =,
             // so we need a special case to not treat = as a key/value separator
             // if it's the first character.
             // https://devblogs.microsoft.com/oldnewthing/20100506-00/?p=14133
-            if (ptr[key_start] == '=') i += 1;
-
+            const key_start = i;
+            if (ptr[i] == '=') i += 1;
             while (ptr[i] != 0 and ptr[i] != '=') : (i += 1) {}
             const key_w = ptr[key_start..i];
-            if (std.mem.eql(u16, key_w, &.{ 'N', 'O', '_', 'C', 'O', 'L', 'O', 'R' })) {
-                t.environ.exist.NO_COLOR = true;
-            } else if (std.mem.eql(u16, key_w, &.{ 'C', 'L', 'I', 'C', 'O', 'L', 'O', 'R', '_', 'F', 'O', 'R', 'C', 'E' })) {
-                t.environ.exist.CLICOLOR_FORCE = true;
-            }
-            comptime assert(@sizeOf(Environ.String) == 0);
 
+            const value_start = i + 1;
             while (ptr[i] != 0) : (i += 1) {} // skip over '=' and value
+            const value_w = ptr[value_start..i];
             i += 1; // skip over null byte
+
+            if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'N', 'O', '_', 'C', 'O', 'L', 'O', 'R' })) {
+                t.environ.exist.NO_COLOR = true;
+            } else if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'C', 'L', 'I', 'C', 'O', 'L', 'O', 'R', '_', 'F', 'O', 'R', 'C', 'E' })) {
+                t.environ.exist.CLICOLOR_FORCE = true;
+            } else if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'Z', 'I', 'G', '_', 'P', 'R', 'O', 'G', 'R', 'E', 'S', 'S' })) {
+                t.environ.zig_progress_file = file: {
+                    var value_buf: [std.fmt.count("{d}", .{std.math.maxInt(usize)})]u8 = undefined;
+                    const len = std.unicode.calcWtf8Len(value_w);
+                    if (len > value_buf.len) break :file error.UnrecognizedFormat;
+                    assert(std.unicode.wtf16LeToWtf8(&value_buf, value_w) == len);
+                    break :file .{
+                        .handle = @ptrFromInt(std.fmt.parseInt(usize, value_buf[0..len], 10) catch
+                            break :file error.UnrecognizedFormat),
+                        .flags = .{ .nonblocking = true },
+                    };
+                };
+            }
+            comptime assert(@sizeOf(Environ.String) == 0);
         }
     } else if (native_os == .wasi and !builtin.link_libc) {
         var environ_count: usize = undefined;
@@ -14549,20 +14567,9 @@ fn scanEnviron(t: *Threaded) void {
                 t.environ.exist.CLICOLOR_FORCE = true;
             } else if (std.mem.eql(u8, key, "ZIG_PROGRESS")) {
                 t.environ.zig_progress_file = file: {
-                    const int = std.fmt.parseInt(switch (@typeInfo(File.Handle)) {
-                        .int => |int_info| @Int(
-                            .unsigned,
-                            int_info.bits - @intFromBool(int_info.signedness == .signed),
-                        ),
-                        .pointer => usize,
-                        else => break :file error.UnsupportedOperation,
-                    }, value, 10) catch break :file error.UnrecognizedFormat;
                     break :file .{
-                        .handle = switch (@typeInfo(File.Handle)) {
-                            .int => int,
-                            .pointer => @ptrFromInt(int),
-                            else => comptime unreachable,
-                        },
+                        .handle = std.fmt.parseInt(u31, value, 10) catch
+                            break :file error.UnrecognizedFormat,
                         .flags = .{ .nonblocking = true },
                     };
                 };
@@ -14668,16 +14675,17 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     const any_ignore = (options.stdin == .ignore or options.stdout == .ignore or options.stderr == .ignore);
     const dev_null_fd = if (any_ignore) try getDevNullFd(t) else undefined;
 
-    const prog_pipe: [2]posix.fd_t = p: {
-        if (options.progress_node.index == .none) {
-            break :p .{ -1, -1 };
-        } else {
-            // We use CLOEXEC for the same reason as in `pipe_flags`.
-            break :p try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true });
-        }
-    };
+    const prog_pipe: [2]posix.fd_t = if (options.progress_node.index != .none)
+        // We use CLOEXEC for the same reason as in `pipe_flags`.
+        try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true })
+    else
+        .{ -1, -1 };
     errdefer destroyPipe(prog_pipe);
 
+    if (native_os == .linux and prog_pipe[0] != -1) {
+        _ = posix.system.fcntl(prog_pipe[0], posix.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2));
+    }
+
     var arena_allocator = std.heap.ArenaAllocator.init(t.allocator);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
@@ -14801,7 +14809,7 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     if (options.stderr == .pipe) posix.close(stderr_pipe[1]);
 
     if (prog_pipe[1] != -1) posix.close(prog_pipe[1]);
-    options.progress_node.setIpcFd(prog_pipe[0]);
+    options.progress_node.setIpcFile(t, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
 
     return .{
         .pid = pid,
@@ -15259,8 +15267,9 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
 
     const prog_pipe = if (options.progress_node.index != .none) try t.windowsCreatePipe(.{
         .server = .{ .attributes = .{ .INHERIT = false }, .mode = .{ .IO = .ASYNCHRONOUS } },
-        .client = .{ .attributes = .{ .INHERIT = true }, .mode = .{ .IO = .SYNCHRONOUS_NONALERT } },
+        .client = .{ .attributes = .{ .INHERIT = true }, .mode = .{ .IO = .ASYNCHRONOUS } },
         .inbound = true,
+        .quota = std.Progress.max_packet_len * 2,
     }) else undefined;
     errdefer if (options.progress_node.index != .none) for (prog_pipe) |handle| windows.CloseHandle(handle);
 
@@ -15476,7 +15485,7 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
 
     if (options.progress_node.index != .none) {
         windows.CloseHandle(prog_pipe[1]);
-        options.progress_node.setIpcFd(prog_pipe[0]);
+        options.progress_node.setIpcFile(t, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
     }
 
     return .{
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 780f27ec75a89b11c414a2463c3ff68fb9041b57..f17fed0a5bc20a5810ceec5853e478a4bf11321a 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -11,7 +11,7 @@ const windows = std.os.windows;
 const testing = std.testing;
 const assert = std.debug.assert;
 const posix = std.posix;
-const Writer = std.Io.Writer;
+const Writer = Io.Writer;
 
 /// Currently this API only supports this value being set to stderr, which
 /// happens automatically inside `start`.
@@ -21,13 +21,10 @@ io: Io,
 
 terminal_mode: TerminalMode,
 
-update_worker: ?Io.Future(void),
+update_worker: ?Io.Future(WorkerError!void),
 
 /// Atomically set by SIGWINCH as well as the root done() function.
 redraw_event: Io.Event,
-/// Indicates a request to shut down and reset global state.
-/// Accessed atomically.
-done: bool,
 need_clear: bool,
 status: Status,
 
@@ -43,15 +40,19 @@ draw_buffer: []u8,
 /// This is in a separate array from `node_storage` but with the same length so
 /// that it can be iterated over efficiently without trashing too much of the
 /// CPU cache.
-node_parents: []Node.Parent,
-node_storage: []Node.Storage,
-node_freelist_next: []Node.OptionalIndex,
+node_parents: [node_storage_buffer_len]Node.Parent,
+node_storage: [node_storage_buffer_len]Node.Storage,
+node_freelist_next: [node_storage_buffer_len]Node.OptionalIndex,
 node_freelist: Freelist,
 /// This is the number of elements in node arrays which have been used so far. Nodes before this
 /// index are either active, or on the freelist. The remaining nodes are implicitly free. This
 /// value may at times temporarily exceed the node count.
 node_end_index: u32,
 
+ipc_next: Ipc.SlotAtomic,
+ipc: [ipc_storage_buffer_len]Ipc,
+ipc_files: [ipc_storage_buffer_len]Io.File,
+
 start_failure: StartFailure,
 
 pub const Status = enum {
@@ -77,6 +78,80 @@ const Freelist = packed struct(u32) {
     generation: u24,
 };
 
+pub const Ipc = packed struct(u32) {
+    /// mutex protecting `file` use, only locked by `serializeIpc`
+    locked: bool,
+    /// when unlocked: whether `file` is defined
+    /// when locked: whether `file` does not need to be closed
+    valid: bool,
+    unused: @Int(.unsigned, 32 - 2 - @bitSizeOf(Generation)) = 0,
+    generation: Generation,
+
+    pub const Slot = std.math.IntFittingRange(0, ipc_storage_buffer_len - 1);
+    pub const Generation = @Int(.unsigned, 32 - @bitSizeOf(Slot));
+
+    const SlotAtomic = @Int(.unsigned, std.math.ceilPowerOfTwoAssert(usize, @min(@bitSizeOf(Slot), 8)));
+
+    pub const Index = packed struct(u32) {
+        slot: Slot,
+        generation: Generation,
+    };
+
+    const Data = struct {
+        state: State,
+        bytes_read: u16,
+        main_index: u8,
+        start_index: u8,
+        nodes_len: u8,
+
+        const State = enum { unused, pending, ready };
+
+        /// No operations have been started on this file.
+        const unused: Data = .{
+            .state = .unused,
+            .bytes_read = 0,
+            .main_index = 0,
+            .start_index = 0,
+            .nodes_len = 0,
+        };
+
+        fn findLastPacket(data: *const Data, buffer: *const [max_packet_len]u8) struct { u16, u16 } {
+            assert(data.state == .ready);
+            var packet_start: u16 = 0;
+            var packet_end: u16 = 0;
+            const bytes_read = data.bytes_read;
+            while (bytes_read - packet_end >= 1) {
+                const nodes_len: u16 = buffer[packet_end];
+                const packet_len = 1 + nodes_len * (@sizeOf(Node.Storage) + @sizeOf(Node.Parent));
+                if (packet_end + packet_len > bytes_read) break;
+                packet_start = packet_end;
+                packet_end += packet_len;
+            }
+            return .{ packet_start, packet_end };
+        }
+
+        fn rebase(
+            data: *Data,
+            buffer: *[max_packet_len]u8,
+            vec: *[1][]u8,
+            batch: *std.Io.Batch,
+            slot: Slot,
+            packet_end: u16,
+        ) void {
+            assert(data.state == .ready);
+            const remaining = buffer[packet_end..data.bytes_read];
+            @memmove(buffer[0..remaining.len], remaining);
+            vec.* = .{buffer[remaining.len..]};
+            batch.addAt(slot, .{ .file_read_streaming = .{
+                .file = global_progress.ipc_files[slot],
+                .data = vec,
+            } });
+            data.state = .pending;
+            data.bytes_read = @intCast(remaining.len);
+        }
+    };
+};
+
 pub const TerminalMode = union(enum) {
     off,
     ansi_escape_codes,
@@ -116,7 +191,7 @@ pub const Node = struct {
 
     pub const none: Node = .{ .index = .none };
 
-    pub const max_name_len = 40;
+    pub const max_name_len = 120;
 
     const Storage = extern struct {
         /// Little endian.
@@ -127,25 +202,16 @@ pub const Node = struct {
         name: [max_name_len]u8 align(@alignOf(usize)),
 
         /// Not thread-safe.
-        fn getIpcFd(s: Storage) ?Io.File.Handle {
-            return if (s.estimated_total_count == std.math.maxInt(u32)) switch (@typeInfo(Io.File.Handle)) {
-                .int => @bitCast(s.completed_count),
-                .pointer => @ptrFromInt(s.completed_count),
-                else => @compileError("unsupported fd_t of " ++ @typeName(Io.File.Handle)),
-            } else null;
+        fn getIpcIndex(s: Storage) ?Ipc.Index {
+            return if (s.estimated_total_count == std.math.maxInt(u32)) @bitCast(s.completed_count) else null;
         }
 
         /// Thread-safe.
-        fn setIpcFd(s: *Storage, fd: Io.File.Handle) void {
-            const integer: u32 = switch (@typeInfo(Io.File.Handle)) {
-                .int => @bitCast(fd),
-                .pointer => @intCast(@intFromPtr(fd)),
-                else => @compileError("unsupported fd_t of " ++ @typeName(Io.File.Handle)),
-            };
+        fn setIpcIndex(s: *Storage, ipc_index: Ipc.Index) void {
             // `estimated_total_count` max int indicates the special state that
             // causes `completed_count` to be treated as a file descriptor, so
             // the order here matters.
-            @atomicStore(u32, &s.completed_count, integer, .monotonic);
+            @atomicStore(u32, &s.completed_count, @bitCast(ipc_index), .monotonic);
             @atomicStore(u32, &s.estimated_total_count, std.math.maxInt(u32), .release); // synchronizes with acquire in `serialize`
         }
 
@@ -155,6 +221,14 @@ pub const Node = struct {
             s.estimated_total_count = @byteSwap(s.estimated_total_count);
         }
 
+        fn copyRoot(dest: *Node.Storage, src: *align(1) const Node.Storage) void {
+            dest.* = .{
+                .completed_count = src.completed_count,
+                .estimated_total_count = src.estimated_total_count,
+                .name = if (src.name[0] == 0) dest.name else src.name,
+            };
+        }
+
         comptime {
             assert((@sizeOf(Storage) % 4) == 0);
         }
@@ -242,7 +316,7 @@ pub const Node = struct {
         }
 
         const free_index = @atomicRmw(u32, &global_progress.node_end_index, .Add, 1, .monotonic);
-        if (free_index >= global_progress.node_storage.len) {
+        if (free_index >= node_storage_buffer_len) {
             // Ran out of node storage memory. Progress for this node will not be tracked.
             _ = @atomicRmw(u32, &global_progress.node_end_index, .Sub, 1, .monotonic);
             return Node.none;
@@ -292,15 +366,17 @@ pub const Node = struct {
         const index = n.index.unwrap() orelse return;
         const storage = storageByIndex(index);
         // Avoid u32 max int which is used to indicate a special state.
-        const saturated = @min(std.math.maxInt(u32) - 1, count);
-        @atomicStore(u32, &storage.estimated_total_count, saturated, .monotonic);
+        const saturated_total_count = @min(std.math.maxInt(u32) - 1, count);
+        @atomicStore(u32, &storage.estimated_total_count, saturated_total_count, .monotonic);
     }
 
     /// Thread-safe.
     pub fn increaseEstimatedTotalItems(n: Node, count: usize) void {
         const index = n.index.unwrap() orelse return;
         const storage = storageByIndex(index);
-        _ = @atomicRmw(u32, &storage.estimated_total_count, .Add, std.math.lossyCast(u32, count), .monotonic);
+        // Avoid u32 max int which is used to indicate a special state.
+        const saturated_total_count = @min(std.math.maxInt(u32) - 1, count);
+        _ = @atomicRmw(u32, &storage.estimated_total_count, .Add, saturated_total_count, .monotonic);
     }
 
     /// Finish a started `Node`. Thread-safe.
@@ -310,11 +386,25 @@ pub const Node = struct {
             return;
         }
         const index = n.index.unwrap() orelse return;
+        const io = global_progress.io;
         const parent_ptr = parentByIndex(index);
         if (@atomicLoad(Node.Parent, parent_ptr, .monotonic).unwrap()) |parent_index| {
             _ = @atomicRmw(u32, &storageByIndex(parent_index).completed_count, .Add, 1, .monotonic);
             @atomicStore(Node.Parent, parent_ptr, .unused, .monotonic);
 
+            if (storageByIndex(index).getIpcIndex()) |ipc_index| {
+                const file = global_progress.ipc_files[ipc_index.slot];
+                const ipc = @atomicRmw(
+                    Ipc,
+                    &global_progress.ipc[ipc_index.slot],
+                    .And,
+                    .{ .locked = true, .valid = false, .generation = std.math.maxInt(Ipc.Generation) },
+                    .release,
+                );
+                assert(ipc.valid and ipc.generation == ipc_index.generation);
+                if (!ipc.locked) file.close(io);
+            }
+
             const freelist = &global_progress.node_freelist;
             var old_freelist = @atomicLoad(Freelist, freelist, .monotonic);
             while (true) {
@@ -332,42 +422,52 @@ pub const Node = struct {
                 };
             }
         } else {
-            @atomicStore(bool, &global_progress.done, true, .monotonic);
-            const io = global_progress.io;
-            global_progress.redraw_event.set(io);
-            if (global_progress.update_worker) |*worker| worker.await(io);
+            if (global_progress.update_worker) |*worker| worker.cancel(io) catch {};
+            for (&global_progress.ipc, &global_progress.ipc_files) |ipc, ipc_file| {
+                assert(!ipc.locked or !ipc.valid); // missing call to end()
+                if (ipc.locked or ipc.valid) ipc_file.close(io);
+            }
         }
     }
 
-    /// Posix-only. Used by `std.process.Child`. Thread-safe.
-    pub fn setIpcFd(node: Node, fd: Io.File.Handle) void {
+    /// Used by `std.process.Child`. Thread-safe.
+    pub fn setIpcFile(node: Node, expected_io_userdata: ?*anyopaque, file: Io.File) void {
         const index = node.index.unwrap() orelse return;
-        switch (@typeInfo(Io.File.Handle)) {
-            .int => {
-                assert(fd >= 0);
-                assert(fd != posix.STDOUT_FILENO);
-                assert(fd != posix.STDIN_FILENO);
-                assert(fd != posix.STDERR_FILENO);
-            },
-            .pointer => {
-                assert(fd != windows.INVALID_HANDLE_VALUE);
-            },
-            else => @compileError("unsupported fd_t of " ++ @typeName(Io.File.Handle)),
-        }
-        storageByIndex(index).setIpcFd(fd);
+        const io = global_progress.io;
+        assert(io.userdata == expected_io_userdata);
+        for (0..ipc_storage_buffer_len) |_| {
+            const slot: Ipc.Slot = @truncate(
+                @atomicRmw(Ipc.SlotAtomic, &global_progress.ipc_next, .Add, 1, .monotonic),
+            );
+            if (slot >= ipc_storage_buffer_len) continue;
+            const ipc_ptr = &global_progress.ipc[slot];
+            const ipc = @atomicLoad(Ipc, ipc_ptr, .monotonic);
+            if (ipc.locked or ipc.valid) continue;
+            const generation = ipc.generation +% 1;
+            if (@cmpxchgWeak(
+                Ipc,
+                ipc_ptr,
+                ipc,
+                .{ .locked = false, .valid = true, .generation = generation },
+                .acquire,
+                .monotonic,
+            )) |_| continue;
+            global_progress.ipc_files[slot] = file;
+            storageByIndex(index).setIpcIndex(.{ .slot = slot, .generation = generation });
+            break;
+        } else file.close(io);
     }
 
-    /// Posix-only. Thread-safe. Assumes the node is storing an IPC file
-    /// descriptor.
-    pub fn getIpcFd(node: Node) ?Io.File.Handle {
-        const index = node.index.unwrap() orelse return null;
-        const storage = storageByIndex(index);
-        const int = @atomicLoad(u32, &storage.completed_count, .monotonic);
-        return switch (@typeInfo(Io.File.Handle)) {
-            .int => @bitCast(int),
-            .pointer => @ptrFromInt(int),
-            else => @compileError("unsupported fd_t of " ++ @typeName(Io.File.Handle)),
-        };
+    pub fn setIpcIndex(node: Node, ipc_index: Ipc.Index) void {
+        storageByIndex(node.index.unwrap() orelse return).setIpcIndex(ipc_index);
+    }
+
+    /// Not thread-safe.
+    pub fn takeIpcIndex(node: Node) ?Ipc.Index {
+        const storage = storageByIndex(node.index.unwrap() orelse return null);
+        assert(storage.estimated_total_count == std.math.maxInt(u32));
+        @atomicStore(u32, &storage.estimated_total_count, 0, .monotonic);
+        return @bitCast(storage.completed_count);
     }
 
     fn storageByIndex(index: Node.Index) *Node.Storage {
@@ -387,7 +487,9 @@ pub const Node = struct {
 
         const storage = storageByIndex(free_index);
         @atomicStore(u32, &storage.completed_count, 0, .monotonic);
-        @atomicStore(u32, &storage.estimated_total_count, std.math.lossyCast(u32, estimated_total_items), .monotonic);
+        // Avoid u32 max int which is used to indicate a special state.
+        const saturated_total_count = @min(std.math.maxInt(u32) - 1, estimated_total_items);
+        @atomicStore(u32, &storage.estimated_total_count, saturated_total_count, .monotonic);
         const name_len = @min(max_name_len, name.len);
         copyAtomicStore(storage.name[0..name_len], name[0..name_len]);
         if (name_len < storage.name.len)
@@ -414,16 +516,20 @@ var global_progress: Progress = .{
     .rows = 0,
     .cols = 0,
     .draw_buffer = undefined,
-    .done = false,
     .need_clear = false,
     .status = .working,
-    .start_failure = .unstarted,
 
-    .node_parents = &node_parents_buffer,
-    .node_storage = &node_storage_buffer,
-    .node_freelist_next = &node_freelist_next_buffer,
+    .node_parents = undefined,
+    .node_storage = undefined,
+    .node_freelist_next = undefined,
     .node_freelist = .{ .head = .none, .generation = 0 },
     .node_end_index = 0,
+
+    .ipc_next = 0,
+    .ipc = undefined,
+    .ipc_files = undefined,
+
+    .start_failure = .unstarted,
 };
 
 pub const StartFailure = union(enum) {
@@ -433,17 +539,23 @@ pub const StartFailure = union(enum) {
     parent_ipc: error{ UnsupportedOperation, UnrecognizedFormat },
 };
 
-const node_storage_buffer_len = 83;
-var node_parents_buffer: [node_storage_buffer_len]Node.Parent = undefined;
-var node_storage_buffer: [node_storage_buffer_len]Node.Storage = undefined;
-var node_freelist_next_buffer: [node_storage_buffer_len]Node.OptionalIndex = undefined;
+/// One less than a power of two ensures `max_packet_len` is already a power of two.
+const node_storage_buffer_len = ipc_storage_buffer_len - 1;
+
+/// Power of two to avoid wasted `ipc_next` increments.
+const ipc_storage_buffer_len = 128;
+
+pub const max_packet_len = std.math.ceilPowerOfTwoAssert(
+    usize,
+    1 + node_storage_buffer_len * (@sizeOf(Node.Storage) + @sizeOf(Node.OptionalIndex)),
+);
 
 var default_draw_buffer: [4096]u8 = undefined;
 
 var debug_start_trace = std.debug.Trace.init;
 
 pub const have_ipc = switch (builtin.os.tag) {
-    .wasi, .freestanding, .windows => false,
+    .wasi, .freestanding => false,
     else => true,
 };
 
@@ -475,9 +587,9 @@ pub fn start(io: Io, options: Options) Node {
     }
     debug_start_trace.add("first initialized here");
 
-    @memset(global_progress.node_parents, .unused);
+    @memset(&global_progress.node_parents, .unused);
+    @memset(&global_progress.ipc, .{ .locked = false, .valid = false, .generation = 0 });
     const root_node = Node.init(@enumFromInt(0), .none, options.root_name, options.estimated_total_items);
-    global_progress.done = false;
     global_progress.node_end_index = 1;
 
     assert(options.draw_buffer.len >= 200);
@@ -551,58 +663,55 @@ pub fn setStatus(new_status: Status) void {
 }
 
 /// Returns whether a resize is needed to learn the terminal size.
-fn wait(io: Io, timeout_ns: u64) bool {
+fn wait(io: Io, timeout_ns: u64) Io.Cancelable!bool {
     const timeout: Io.Timeout = .{ .duration = .{
         .clock = .awake,
         .raw = .fromNanoseconds(timeout_ns),
     } };
     const resize_flag = if (global_progress.redraw_event.waitTimeout(io, timeout)) |_| true else |err| switch (err) {
-        error.Timeout, error.Canceled => false,
+        error.Timeout => false,
+        error.Canceled => |e| return e,
     };
     global_progress.redraw_event.reset();
     return resize_flag or (global_progress.cols == 0);
 }
 
-fn updateTask(io: Io) void {
+const WorkerError = error{WindowTooSmall} || Io.ConcurrentError || Io.Cancelable ||
+    Io.File.Writer.Error || Io.Operation.FileReadStreaming.Error;
+
+fn updateTask(io: Io) WorkerError!void {
     // Store this data in the thread so that it does not need to be part of the
     // linker data of the main executable.
     var serialized_buffer: Serialized.Buffer = undefined;
+    serialized_buffer.init();
+    defer serialized_buffer.batch.cancel(io);
 
     // In this function we bypass the wrapper code inside `Io.lockStderr` /
     // `Io.tryLockStderr` in order to avoid clearing the terminal twice.
     // We still want to go through the `Io` instance however in case it uses a
     // task-switching mutex.
 
-    {
-        const resize_flag = wait(io, global_progress.initial_delay_ns);
-        if (@atomicLoad(bool, &global_progress.done, .monotonic)) return;
-        maybeUpdateSize(io, resize_flag) catch return;
-
-        const buffer, _ = computeRedraw(&serialized_buffer);
-        if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
-            defer io.unlockStderr();
-            global_progress.need_clear = true;
-            locked_stderr.file_writer.interface.writeAll(buffer) catch return;
-        }
+    try maybeUpdateSize(io, try wait(io, global_progress.initial_delay_ns));
+    errdefer {
+        const cancel_protection = io.swapCancelProtection(.blocked);
+        defer _ = io.swapCancelProtection(cancel_protection);
+        const stderr = io.vtable.lockStderr(io.userdata, null) catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
+        defer io.unlockStderr();
+        clearWrittenWithEscapeCodes(stderr.file_writer) catch {};
     }
-
     while (true) {
-        const resize_flag = wait(io, global_progress.refresh_rate_ns);
-
-        if (@atomicLoad(bool, &global_progress.done, .monotonic)) {
-            const stderr = io.vtable.lockStderr(io.userdata, null) catch return;
-            defer io.unlockStderr();
-            return clearWrittenWithEscapeCodes(stderr.file_writer) catch {};
-        }
-
-        maybeUpdateSize(io, resize_flag) catch return;
-
-        const buffer, _ = computeRedraw(&serialized_buffer);
-        if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
+        const buffer, _ = try computeRedraw(io, &serialized_buffer);
+        if (try io.vtable.tryLockStderr(io.userdata, null)) |locked_stderr| {
             defer io.unlockStderr();
             global_progress.need_clear = true;
-            locked_stderr.file_writer.interface.writeAll(buffer) catch return;
+            locked_stderr.file_writer.interface.writeAll(buffer) catch |err| switch (err) {
+                error.WriteFailed => return locked_stderr.file_writer.err.?,
+            };
         }
+
+        try maybeUpdateSize(io, try wait(io, global_progress.refresh_rate_ns));
     }
 }
 
@@ -614,79 +723,60 @@ fn windowsApiWriteMarker() void {
     _ = windows.kernel32.WriteConsoleW(handle, &[_]u16{windows_api_start_marker}, 1, &num_chars_written, null);
 }
 
-fn windowsApiUpdateTask(io: Io) void {
+fn windowsApiUpdateTask(io: Io) WorkerError!void {
+    // Store this data in the thread so that it does not need to be part of the
+    // linker data of the main executable.
     var serialized_buffer: Serialized.Buffer = undefined;
+    serialized_buffer.init();
+    defer serialized_buffer.batch.cancel(io);
 
     // In this function we bypass the wrapper code inside `Io.lockStderr` /
     // `Io.tryLockStderr` in order to avoid clearing the terminal twice.
     // We still want to go through the `Io` instance however in case it uses a
     // task-switching mutex.
 
-    {
-        const resize_flag = wait(io, global_progress.initial_delay_ns);
-        if (@atomicLoad(bool, &global_progress.done, .monotonic)) return;
-        maybeUpdateSize(io, resize_flag) catch return;
-
-        const buffer, const nl_n = computeRedraw(&serialized_buffer);
-        if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
-            defer io.unlockStderr();
-            windowsApiWriteMarker();
-            global_progress.need_clear = true;
-            locked_stderr.file_writer.interface.writeAll(buffer) catch return;
-            windowsApiMoveToMarker(nl_n) catch return;
-        }
+    try maybeUpdateSize(io, try wait(io, global_progress.initial_delay_ns));
+    errdefer {
+        const cancel_protection = io.swapCancelProtection(.blocked);
+        defer _ = io.swapCancelProtection(cancel_protection);
+        _ = io.vtable.lockStderr(io.userdata, null) catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
+        defer io.unlockStderr();
+        clearWrittenWindowsApi() catch {};
     }
-
     while (true) {
-        const resize_flag = wait(io, global_progress.refresh_rate_ns);
-
-        if (@atomicLoad(bool, &global_progress.done, .monotonic)) {
-            _ = io.vtable.lockStderr(io.userdata, null) catch return;
-            defer io.unlockStderr();
-            return clearWrittenWindowsApi() catch {};
-        }
-
-        maybeUpdateSize(io, resize_flag) catch return;
-
-        const buffer, const nl_n = computeRedraw(&serialized_buffer);
+        const buffer, const nl_n = try computeRedraw(io, &serialized_buffer);
         if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
             defer io.unlockStderr();
-            clearWrittenWindowsApi() catch return;
+            try clearWrittenWindowsApi();
             windowsApiWriteMarker();
             global_progress.need_clear = true;
-            locked_stderr.file_writer.interface.writeAll(buffer) catch return;
+            locked_stderr.file_writer.interface.writeAll(buffer) catch |err| switch (err) {
+                error.WriteFailed => return locked_stderr.file_writer.err.?,
+            };
             windowsApiMoveToMarker(nl_n) catch return;
         }
+
+        try maybeUpdateSize(io, try wait(io, global_progress.refresh_rate_ns));
     }
 }
 
-fn ipcThreadRun(io: Io, file: Io.File) void {
+fn ipcThreadRun(io: Io, file: Io.File) WorkerError!void {
     // Store this data in the thread so that it does not need to be part of the
     // linker data of the main executable.
     var serialized_buffer: Serialized.Buffer = undefined;
+    serialized_buffer.init();
+    defer serialized_buffer.batch.cancel(io);
+    var fw = file.writerStreaming(io, &.{});
 
-    {
-        _ = wait(io, global_progress.initial_delay_ns);
-
-        if (@atomicLoad(bool, &global_progress.done, .monotonic))
-            return;
-
-        const serialized = serialize(&serialized_buffer);
-        writeIpc(io, file, serialized) catch |err| switch (err) {
-            error.BrokenPipe => return,
-        };
-    }
-
+    _ = try io.sleep(.fromNanoseconds(global_progress.initial_delay_ns), .awake);
     while (true) {
-        _ = wait(io, global_progress.refresh_rate_ns);
-
-        if (@atomicLoad(bool, &global_progress.done, .monotonic))
-            return;
-
-        const serialized = serialize(&serialized_buffer);
-        writeIpc(io, file, serialized) catch |err| switch (err) {
-            error.BrokenPipe => return,
+        writeIpc(&fw.interface, try serialize(io, &serialized_buffer)) catch |err| switch (err) {
+            error.WriteFailed => return fw.err.?,
         };
+
+        _ = try io.sleep(.fromNanoseconds(global_progress.refresh_rate_ns), .awake);
     }
 }
 
@@ -865,31 +955,49 @@ const Serialized = struct {
     const Buffer = struct {
         parents: [node_storage_buffer_len]Node.Parent,
         storage: [node_storage_buffer_len]Node.Storage,
-        map: [node_storage_buffer_len]Node.OptionalIndex,
 
-        parents_copy: [node_storage_buffer_len]Node.Parent,
-        storage_copy: [node_storage_buffer_len]Node.Storage,
-        ipc_metadata_fds_copy: [node_storage_buffer_len]Fd,
-        ipc_metadata_copy: [node_storage_buffer_len]SavedMetadata,
+        ipc_start: u8,
+        ipc_end: u8,
+        ipc_data: [ipc_storage_buffer_len]Ipc.Data,
+        ipc_buffers: [ipc_storage_buffer_len][max_packet_len]u8,
+        ipc_vecs: [ipc_storage_buffer_len][1][]u8,
+        batch_storage: [ipc_storage_buffer_len]Io.Operation.Storage,
+        batch: Io.Batch,
 
-        ipc_metadata_fds: [node_storage_buffer_len]Fd,
-        ipc_metadata: [node_storage_buffer_len]SavedMetadata,
+        fn init(buffer: *Buffer) void {
+            buffer.ipc_start = 0;
+            buffer.ipc_end = 0;
+            @memset(&buffer.ipc_data, .unused);
+            buffer.batch = .init(&buffer.batch_storage);
+        }
     };
 };
 
-fn serialize(serialized_buffer: *Serialized.Buffer) Serialized {
-    var serialized_len: usize = 0;
-    var any_ipc = false;
+fn serialize(io: Io, serialized_buffer: *Serialized.Buffer) !Serialized {
+    var prev_parents: [node_storage_buffer_len]Node.Parent = undefined;
+    var prev_storage: [node_storage_buffer_len]Node.Storage = undefined;
+    {
+        const ipc_start = serialized_buffer.ipc_start;
+        const ipc_end = serialized_buffer.ipc_end;
+        @memcpy(prev_parents[ipc_start..ipc_end], serialized_buffer.parents[ipc_start..ipc_end]);
+        @memcpy(prev_storage[ipc_start..ipc_end], serialized_buffer.storage[ipc_start..ipc_end]);
+    }
 
     // Iterate all of the nodes and construct a serializable copy of the state that can be examined
     // without atomics. The `@min` call is here because `node_end_index` might briefly exceed the
     // node count sometimes.
-    const end_index = @min(@atomicLoad(u32, &global_progress.node_end_index, .monotonic), global_progress.node_storage.len);
+    const end_index = @min(
+        @atomicLoad(u32, &global_progress.node_end_index, .monotonic),
+        node_storage_buffer_len,
+    );
+    var map: [node_storage_buffer_len]Node.OptionalIndex = undefined;
+    var serialized_len: u8 = 0;
+    var maybe_ipc_start: ?u8 = null;
     for (
         global_progress.node_parents[0..end_index],
         global_progress.node_storage[0..end_index],
-        serialized_buffer.map[0..end_index],
-    ) |*parent_ptr, *storage_ptr, *map| {
+        map[0..end_index],
+    ) |*parent_ptr, *storage_ptr, *map_entry| {
         const parent = @atomicLoad(Node.Parent, parent_ptr, .monotonic);
         if (parent == .unused) {
             // We might read "mixed" node data in this loop, due to weird atomic things
@@ -903,17 +1011,17 @@ fn serialize(serialized_buffer: *Serialized.Buffer) Serialized {
             // parent, it will just not be printed at all. The general idea here is that performance
             // is more important than 100% correct output every frame, given that this API is likely
             // to be used in hot paths!
-            map.* = .none;
+            map_entry.* = .none;
             continue;
         }
         const dest_storage = &serialized_buffer.storage[serialized_len];
         copyAtomicLoad(&dest_storage.name, &storage_ptr.name);
-        dest_storage.estimated_total_count = @atomicLoad(u32, &storage_ptr.estimated_total_count, .acquire); // sychronizes with release in `setIpcFd`
+        dest_storage.estimated_total_count = @atomicLoad(u32, &storage_ptr.estimated_total_count, .acquire); // sychronizes with release in `setIpcIndex`
         dest_storage.completed_count = @atomicLoad(u32, &storage_ptr.completed_count, .monotonic);
 
-        any_ipc = any_ipc or (dest_storage.getIpcFd() != null);
         serialized_buffer.parents[serialized_len] = parent;
-        map.* = @enumFromInt(serialized_len);
+        map_entry.* = @enumFromInt(serialized_len);
+        if (maybe_ipc_start == null and dest_storage.getIpcIndex() != null) maybe_ipc_start = serialized_len;
         serialized_len += 1;
     }
 
@@ -922,13 +1030,201 @@ fn serialize(serialized_buffer: *Serialized.Buffer) Serialized {
         parent.* = switch (parent.*) {
             .unused => unreachable,
             .none => .none,
-            _ => |p| serialized_buffer.map[@intFromEnum(p)].toParent(),
+            _ => |p| map[@intFromEnum(p)].toParent(),
         };
     }
 
+    // Fill pipe buffers.
+    const batch = &serialized_buffer.batch;
+    batch.awaitConcurrent(io, .{
+        .duration = .{ .raw = .zero, .clock = .awake },
+    }) catch |err| switch (err) {
+        error.Timeout => {},
+        else => |e| return e,
+    };
+    var ready_len: u8 = 0;
+    while (batch.next()) |operation| switch (operation.index) {
+        0...ipc_storage_buffer_len - 1 => {
+            const ipc_data = &serialized_buffer.ipc_data[operation.index];
+            ipc_data.bytes_read += @intCast(
+                operation.result.file_read_streaming catch |err| switch (err) {
+                    error.EndOfStream => {
+                        const file = global_progress.ipc_files[operation.index];
+                        const ipc = @atomicRmw(
+                            Ipc,
+                            &global_progress.ipc[operation.index],
+                            .And,
+                            .{
+                                .locked = false,
+                                .valid = true,
+                                .generation = std.math.maxInt(Ipc.Generation),
+                            },
+                            .release,
+                        );
+                        assert(ipc.locked);
+                        if (!ipc.valid) file.close(io);
+                        ipc_data.* = .unused;
+                        continue;
+                    },
+                    else => |e| return e,
+                },
+            );
+            assert(ipc_data.state == .pending);
+            ipc_data.state = .ready;
+            ready_len += 1;
+        },
+        else => unreachable,
+    };
+
     // Find nodes which correspond to child processes.
-    if (any_ipc)
-        serialized_len = serializeIpc(serialized_len, serialized_buffer);
+    const ipc_start = maybe_ipc_start orelse serialized_len;
+    serialized_buffer.ipc_start = ipc_start;
+    for (
+        serialized_buffer.parents[ipc_start..serialized_len],
+        serialized_buffer.storage[ipc_start..serialized_len],
+        ipc_start..,
+    ) |main_parent, *main_storage, main_index| {
+        if (main_parent == .unused) continue;
+        const ipc_index = main_storage.getIpcIndex() orelse continue;
+        const ipc = &global_progress.ipc[ipc_index.slot];
+        const ipc_data = &serialized_buffer.ipc_data[ipc_index.slot];
+        state: switch (ipc_data.state) {
+            .unused => {
+                if (@cmpxchgWeak(
+                    Ipc,
+                    ipc,
+                    .{ .locked = false, .valid = true, .generation = ipc_index.generation },
+                    .{ .locked = true, .valid = true, .generation = ipc_index.generation },
+                    .acquire,
+                    .monotonic,
+                )) |_| continue;
+
+                const ipc_vec = &serialized_buffer.ipc_vecs[ipc_index.slot];
+                ipc_vec.* = .{&serialized_buffer.ipc_buffers[ipc_index.slot]};
+                batch.addAt(ipc_index.slot, .{ .file_read_streaming = .{
+                    .file = global_progress.ipc_files[ipc_index.slot],
+                    .data = ipc_vec,
+                } });
+
+                ipc_data.* = .{
+                    .state = .pending,
+                    .bytes_read = 0,
+                    .main_index = @intCast(main_index),
+                    .start_index = serialized_len,
+                    .nodes_len = 0,
+                };
+                main_storage.completed_count = 0;
+                main_storage.estimated_total_count = 0;
+            },
+            .pending => {
+                const start_index = ipc_data.start_index;
+                const nodes_len = @min(ipc_data.nodes_len, node_storage_buffer_len - serialized_len);
+
+                main_storage.copyRoot(&prev_storage[ipc_data.main_index]);
+                @memcpy(
+                    serialized_buffer.storage[serialized_len..][0..nodes_len],
+                    prev_storage[start_index..][0..nodes_len],
+                );
+                for (
+                    serialized_buffer.parents[serialized_len..][0..nodes_len],
+                    prev_parents[serialized_len..][0..nodes_len],
+                ) |*parent, prev_parent| parent.* = switch (prev_parent) {
+                    .none, .unused => .none,
+                    _ => if (@intFromEnum(prev_parent) == ipc_data.main_index)
+                        @enumFromInt(main_index)
+                    else if (@intFromEnum(prev_parent) >= start_index and
+                        @intFromEnum(prev_parent) < start_index + nodes_len)
+                        @enumFromInt(@intFromEnum(prev_parent) - start_index + serialized_len)
+                    else
+                        .none,
+                };
+
+                ipc_data.main_index = @intCast(main_index);
+                ipc_data.start_index = serialized_len;
+                ipc_data.nodes_len = nodes_len;
+                serialized_len += nodes_len;
+            },
+            .ready => {
+                const ipc_buffer = &serialized_buffer.ipc_buffers[ipc_index.slot];
+                const packet_start, const packet_end = ipc_data.findLastPacket(ipc_buffer);
+                const packet_is_empty = packet_end - packet_start <= 1;
+                if (!packet_is_empty) {
+                    const storage, const parents, const nodes_len = packet_contents: {
+                        var packet_index: usize = packet_start;
+                        const nodes_len: u16 = ipc_buffer[packet_index];
+                        packet_index += 1;
+                        const storage_bytes =
+                            ipc_buffer[packet_index..][0 .. nodes_len * @sizeOf(Node.Storage)];
+                        packet_index += storage_bytes.len;
+                        const parents_bytes =
+                            ipc_buffer[packet_index..][0 .. nodes_len * @sizeOf(Node.Parent)];
+                        packet_index += parents_bytes.len;
+                        assert(packet_index == packet_end);
+                        const storage: []align(1) const Node.Storage = @ptrCast(storage_bytes);
+                        const parents: []align(1) const Node.Parent = @ptrCast(parents_bytes);
+                        const children_nodes_len =
+                            @min(nodes_len - 1, node_storage_buffer_len - serialized_len);
+                        break :packet_contents .{ storage, parents, children_nodes_len };
+                    };
+
+                    // Mount the root here.
+                    main_storage.copyRoot(&storage[0]);
+                    if (is_big_endian) main_storage.byteSwap();
+
+                    // Copy the rest of the tree to the end.
+                    const serialized_storage =
+                        serialized_buffer.storage[serialized_len..][0..nodes_len];
+                    @memcpy(serialized_storage, storage[1..][0..nodes_len]);
+                    if (is_big_endian) for (serialized_storage) |*s| s.byteSwap();
+
+                    // Patch up parent pointers taking into account how the subtree is mounted.
+                    for (
+                        serialized_buffer.parents[serialized_len..][0..nodes_len],
+                        parents[1..][0..nodes_len],
+                    ) |*parent, prev_parent| parent.* = switch (prev_parent) {
+                        // Fix bad data so the rest of the code does not see `unused`.
+                        .none, .unused => .none,
+                        // Root node is being mounted here.
+                        @as(Node.Parent, @enumFromInt(0)) => @enumFromInt(main_index),
+                        // Other nodes mounted at the end.
+                        // Don't trust child data; if the data is outside the expected range,
+                        // ignore the data. This also handles the case when data was truncated.
+                        _ => if (@intFromEnum(prev_parent) <= nodes_len)
+                            @enumFromInt(@intFromEnum(prev_parent) - 1 + serialized_len)
+                        else
+                            .none,
+                    };
+
+                    ipc_data.main_index = @intCast(main_index);
+                    ipc_data.start_index = serialized_len;
+                    ipc_data.nodes_len = nodes_len;
+                    serialized_len += nodes_len;
+                }
+                const ipc_vec = &serialized_buffer.ipc_vecs[ipc_index.slot];
+                ipc_data.rebase(ipc_buffer, ipc_vec, batch, ipc_index.slot, packet_end);
+                ready_len -= 1;
+                if (packet_is_empty) continue :state .pending;
+            },
+        }
+    }
+    serialized_buffer.ipc_end = serialized_len;
+
+    // Ignore data from unused pipes. This ensures that if a child process exists we will
+    // eventually see `EndOfStream` and close the pipe.
+    if (ready_len > 0) for (
+        &serialized_buffer.ipc_data,
+        &serialized_buffer.ipc_buffers,
+        &serialized_buffer.ipc_vecs,
+        0..,
+    ) |*ipc_data, *ipc_buffer, *ipc_vec, ipc_slot| switch (ipc_data.state) {
+        .unused, .pending => {},
+        .ready => {
+            _, const packet_end = ipc_data.findLastPacket(ipc_buffer);
+            ipc_data.rebase(ipc_buffer, ipc_vec, batch, @intCast(ipc_slot), packet_end);
+            ready_len -= 1;
+        },
+    };
+    assert(ready_len == 0);
 
     return .{
         .parents = serialized_buffer.parents[0..serialized_len],
@@ -936,252 +1232,10 @@ fn serialize(serialized_buffer: *Serialized.Buffer) Serialized {
     };
 }
 
-const SavedMetadata = struct {
-    remaining_read_trash_bytes: u16,
-    main_index: u8,
-    start_index: u8,
-    nodes_len: u8,
-};
+fn computeRedraw(io: Io, serialized_buffer: *Serialized.Buffer) !struct { []u8, usize } {
+    if (global_progress.rows == 0 or global_progress.cols == 0) return error.WindowTooSmall;
 
-const Fd = enum(i32) {
-    _,
-
-    fn init(fd: Io.File.Handle) Fd {
-        return @enumFromInt(if (is_windows) @as(isize, @bitCast(@intFromPtr(fd))) else fd);
-    }
-
-    fn get(fd: Fd) Io.File.Handle {
-        return if (is_windows)
-            @ptrFromInt(@as(usize, @bitCast(@as(isize, @intFromEnum(fd)))))
-        else
-            @intFromEnum(fd);
-    }
-};
-
-var ipc_metadata_len: u8 = 0;
-
-fn serializeIpc(start_serialized_len: usize, serialized_buffer: *Serialized.Buffer) usize {
-    const io = global_progress.io;
-    const ipc_metadata_fds_copy = &serialized_buffer.ipc_metadata_fds_copy;
-    const ipc_metadata_copy = &serialized_buffer.ipc_metadata_copy;
-    const ipc_metadata_fds = &serialized_buffer.ipc_metadata_fds;
-    const ipc_metadata = &serialized_buffer.ipc_metadata;
-
-    var serialized_len = start_serialized_len;
-    var pipe_buf: [2 * 4096]u8 = undefined;
-
-    const old_ipc_metadata_fds = ipc_metadata_fds_copy[0..ipc_metadata_len];
-    const old_ipc_metadata = ipc_metadata_copy[0..ipc_metadata_len];
-    ipc_metadata_len = 0;
-
-    main_loop: for (
-        serialized_buffer.parents[0..serialized_len],
-        serialized_buffer.storage[0..serialized_len],
-        0..,
-    ) |main_parent, *main_storage, main_index| {
-        if (main_parent == .unused) continue;
-        const file: Io.File = .{
-            .handle = main_storage.getIpcFd() orelse continue,
-            .flags = .{ .nonblocking = true },
-        };
-        const opt_saved_metadata = findOld(file.handle, old_ipc_metadata_fds, old_ipc_metadata);
-        var bytes_read: usize = 0;
-        while (true) {
-            const n = file.readStreaming(io, &.{pipe_buf[bytes_read..]}) catch |err| switch (err) {
-                error.WouldBlock, error.EndOfStream => break,
-                else => |e| {
-                    std.log.debug("failed to read child progress data: {t}", .{e});
-                    main_storage.completed_count = 0;
-                    main_storage.estimated_total_count = 0;
-                    continue :main_loop;
-                },
-            };
-            if (opt_saved_metadata) |m| {
-                if (m.remaining_read_trash_bytes > 0) {
-                    assert(bytes_read == 0);
-                    if (m.remaining_read_trash_bytes >= n) {
-                        m.remaining_read_trash_bytes = @intCast(m.remaining_read_trash_bytes - n);
-                        continue;
-                    }
-                    const src = pipe_buf[m.remaining_read_trash_bytes..n];
-                    @memmove(pipe_buf[0..src.len], src);
-                    m.remaining_read_trash_bytes = 0;
-                    bytes_read = src.len;
-                    continue;
-                }
-            }
-            bytes_read += n;
-        }
-        // Ignore all but the last message on the pipe.
-        var input: []u8 = pipe_buf[0..bytes_read];
-        if (input.len == 0) {
-            serialized_len = useSavedIpcData(serialized_len, serialized_buffer, main_storage, main_index, opt_saved_metadata, 0, file.handle);
-            continue;
-        }
-
-        const storage, const parents = while (true) {
-            const subtree_len: usize = input[0];
-            const expected_bytes = 1 + subtree_len * (@sizeOf(Node.Storage) + @sizeOf(Node.Parent));
-            if (input.len < expected_bytes) {
-                // Ignore short reads. We'll handle the next full message when it comes instead.
-                const remaining_read_trash_bytes: u16 = @intCast(expected_bytes - input.len);
-                serialized_len = useSavedIpcData(serialized_len, serialized_buffer, main_storage, main_index, opt_saved_metadata, remaining_read_trash_bytes, file.handle);
-                continue :main_loop;
-            }
-            if (input.len > expected_bytes) {
-                input = input[expected_bytes..];
-                continue;
-            }
-            const storage_bytes = input[1..][0 .. subtree_len * @sizeOf(Node.Storage)];
-            const parents_bytes = input[1 + storage_bytes.len ..][0 .. subtree_len * @sizeOf(Node.Parent)];
-            break .{
-                std.mem.bytesAsSlice(Node.Storage, storage_bytes),
-                std.mem.bytesAsSlice(Node.Parent, parents_bytes),
-            };
-        };
-
-        const nodes_len: u8 = @intCast(@min(parents.len - 1, serialized_buffer.storage.len - serialized_len));
-
-        // Remember in case the pipe is empty on next update.
-        ipc_metadata_fds[ipc_metadata_len] = Fd.init(file.handle);
-        ipc_metadata[ipc_metadata_len] = .{
-            .remaining_read_trash_bytes = 0,
-            .start_index = @intCast(serialized_len),
-            .nodes_len = nodes_len,
-            .main_index = @intCast(main_index),
-        };
-        ipc_metadata_len += 1;
-
-        // Mount the root here.
-        copyRoot(main_storage, &storage[0]);
-        if (is_big_endian) main_storage.byteSwap();
-
-        // Copy the rest of the tree to the end.
-        const storage_dest = serialized_buffer.storage[serialized_len..][0..nodes_len];
-        @memcpy(storage_dest, storage[1..][0..nodes_len]);
-
-        // Always little-endian over the pipe.
-        if (is_big_endian) for (storage_dest) |*s| s.byteSwap();
-
-        // Patch up parent pointers taking into account how the subtree is mounted.
-        for (serialized_buffer.parents[serialized_len..][0..nodes_len], parents[1..][0..nodes_len]) |*dest, p| {
-            dest.* = switch (p) {
-                // Fix bad data so the rest of the code does not see `unused`.
-                .none, .unused => .none,
-                // Root node is being mounted here.
-                @as(Node.Parent, @enumFromInt(0)) => @enumFromInt(main_index),
-                // Other nodes mounted at the end.
-                // Don't trust child data; if the data is outside the expected range, ignore the data.
-                // This also handles the case when data was truncated.
-                _ => |off| if (@intFromEnum(off) > nodes_len)
-                    .none
-                else
-                    @enumFromInt(serialized_len + @intFromEnum(off) - 1),
-            };
-        }
-
-        serialized_len += nodes_len;
-    }
-
-    // Save a copy in case any pipes are empty on the next update.
-    @memcpy(serialized_buffer.parents_copy[0..serialized_len], serialized_buffer.parents[0..serialized_len]);
-    @memcpy(serialized_buffer.storage_copy[0..serialized_len], serialized_buffer.storage[0..serialized_len]);
-    @memcpy(ipc_metadata_fds_copy[0..ipc_metadata_len], ipc_metadata_fds[0..ipc_metadata_len]);
-    @memcpy(ipc_metadata_copy[0..ipc_metadata_len], ipc_metadata[0..ipc_metadata_len]);
-
-    return serialized_len;
-}
-
-fn copyRoot(dest: *Node.Storage, src: *align(1) Node.Storage) void {
-    dest.* = .{
-        .completed_count = src.completed_count,
-        .estimated_total_count = src.estimated_total_count,
-        .name = if (src.name[0] == 0) dest.name else src.name,
-    };
-}
-
-fn findOld(
-    ipc_fd: Io.File.Handle,
-    old_metadata_fds: []Fd,
-    old_metadata: []SavedMetadata,
-) ?*SavedMetadata {
-    for (old_metadata_fds, old_metadata) |fd, *m| {
-        if (fd.get() == ipc_fd)
-            return m;
-    }
-    return null;
-}
-
-fn useSavedIpcData(
-    start_serialized_len: usize,
-    serialized_buffer: *Serialized.Buffer,
-    main_storage: *Node.Storage,
-    main_index: usize,
-    opt_saved_metadata: ?*SavedMetadata,
-    remaining_read_trash_bytes: u16,
-    fd: Io.File.Handle,
-) usize {
-    const parents_copy = &serialized_buffer.parents_copy;
-    const storage_copy = &serialized_buffer.storage_copy;
-    const ipc_metadata_fds = &serialized_buffer.ipc_metadata_fds;
-    const ipc_metadata = &serialized_buffer.ipc_metadata;
-
-    const saved_metadata = opt_saved_metadata orelse {
-        main_storage.completed_count = 0;
-        main_storage.estimated_total_count = 0;
-        if (remaining_read_trash_bytes > 0) {
-            ipc_metadata_fds[ipc_metadata_len] = Fd.init(fd);
-            ipc_metadata[ipc_metadata_len] = .{
-                .remaining_read_trash_bytes = remaining_read_trash_bytes,
-                .start_index = @intCast(start_serialized_len),
-                .nodes_len = 0,
-                .main_index = @intCast(main_index),
-            };
-            ipc_metadata_len += 1;
-        }
-        return start_serialized_len;
-    };
-
-    const start_index = saved_metadata.start_index;
-    const nodes_len = @min(saved_metadata.nodes_len, serialized_buffer.storage.len - start_serialized_len);
-    const old_main_index = saved_metadata.main_index;
-
-    ipc_metadata_fds[ipc_metadata_len] = Fd.init(fd);
-    ipc_metadata[ipc_metadata_len] = .{
-        .remaining_read_trash_bytes = remaining_read_trash_bytes,
-        .start_index = @intCast(start_serialized_len),
-        .nodes_len = nodes_len,
-        .main_index = @intCast(main_index),
-    };
-    ipc_metadata_len += 1;
-
-    const parents = parents_copy[start_index..][0..nodes_len];
-    const storage = storage_copy[start_index..][0..nodes_len];
-
-    copyRoot(main_storage, &storage_copy[old_main_index]);
-
-    @memcpy(serialized_buffer.storage[start_serialized_len..][0..storage.len], storage);
-
-    for (serialized_buffer.parents[start_serialized_len..][0..parents.len], parents) |*dest, p| {
-        dest.* = switch (p) {
-            .none, .unused => .none,
-            _ => |prev| d: {
-                if (@intFromEnum(prev) == old_main_index) {
-                    break :d @enumFromInt(main_index);
-                } else if (@intFromEnum(prev) > nodes_len) {
-                    break :d .none;
-                } else {
-                    break :d @enumFromInt(@intFromEnum(prev) - start_index + start_serialized_len);
-                }
-            },
-        };
-    }
-
-    return start_serialized_len + storage.len;
-}
-
-fn computeRedraw(serialized_buffer: *Serialized.Buffer) struct { []u8, usize } {
-    const serialized = serialize(serialized_buffer);
+    const serialized = try serialize(io, serialized_buffer);
 
     // Now we can analyze our copy of the graph without atomics, reconstructing
     // children lists which do not exist in the canonical data. These are
@@ -1416,9 +1470,7 @@ fn withinRowLimit(p: *Progress, nl_n: usize) bool {
     return nl_n + 2 < p.rows;
 }
 
-var remaining_write_trash_bytes: usize = 0;
-
-fn writeIpc(io: Io, file: Io.File, serialized: Serialized) error{BrokenPipe}!void {
+fn writeIpc(writer: *Io.Writer, serialized: Serialized) Io.Writer.Error!void {
     // Byteswap if necessary to ensure little endian over the pipe. This is
     // needed because the parent or child process might be running in qemu.
     if (is_big_endian) for (serialized.storage) |*s| s.byteSwap();
@@ -1429,62 +1481,8 @@ fn writeIpc(io: Io, file: Io.File, serialized: Serialized) error{BrokenPipe}!voi
     const storage = std.mem.sliceAsBytes(serialized.storage);
     const parents = std.mem.sliceAsBytes(serialized.parents);
 
-    var vecs: [3][]const u8 = .{ header, storage, parents };
-
-    // Ensures the packet can fit in the pipe buffer.
-    const upper_bound_msg_len = 1 + node_storage_buffer_len * @sizeOf(Node.Storage) +
-        node_storage_buffer_len * @sizeOf(Node.OptionalIndex);
-    comptime assert(upper_bound_msg_len <= 4096);
-
-    while (remaining_write_trash_bytes > 0) {
-        // We do this in a separate write call to give a better chance for the
-        // writev below to be in a single packet.
-        const n = @min(parents.len, remaining_write_trash_bytes);
-        if (file.writeStreaming(io, &.{}, &.{parents[0..n]}, 1)) |written| {
-            remaining_write_trash_bytes -= written;
-            continue;
-        } else |err| switch (err) {
-            error.WouldBlock => return,
-            error.BrokenPipe => return error.BrokenPipe,
-            else => |e| {
-                std.log.debug("failed to send progress to parent process: {t}", .{e});
-                return error.BrokenPipe;
-            },
-        }
-    }
-
-    // If this write would block we do not want to keep trying, but we need to
-    // know if a partial message was written.
-    if (writevNonblock(io, file, &vecs)) |written| {
-        const total = header.len + storage.len + parents.len;
-        if (written < total) {
-            remaining_write_trash_bytes = total - written;
-        }
-    } else |err| switch (err) {
-        error.WouldBlock => {},
-        error.BrokenPipe => return error.BrokenPipe,
-        else => |e| {
-            std.log.debug("failed to send progress to parent process: {t}", .{e});
-            return error.BrokenPipe;
-        },
-    }
-}
-
-fn writevNonblock(io: Io, file: Io.File, iov: [][]const u8) Io.File.Writer.Error!usize {
-    var iov_index: usize = 0;
-    var written: usize = 0;
-    var total_written: usize = 0;
-    while (true) {
-        while (if (iov_index < iov.len)
-            written >= iov[iov_index].len
-        else
-            return total_written) : (iov_index += 1) written -= iov[iov_index].len;
-        iov[iov_index].ptr += written;
-        iov[iov_index].len -= written;
-        written = try file.writeStreaming(io, &.{}, iov, 1);
-        if (written == 0) return total_written;
-        total_written += written;
-    }
+    var vec = [3][]const u8{ header, storage, parents };
+    try writer.writeVecAll(&vec);
 }
 
 fn maybeUpdateSize(io: Io, resize_flag: bool) !void {
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 4539aaff4e3aaf9df611d7a7da04b5557438394e..ef4616b111062dd8f5b1bd34794a9fbd15d8d7a6 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1848,6 +1848,24 @@ pub const F = struct {
     pub const RDLCK = if (is_sparc) 1 else 0;
     pub const WRLCK = if (is_sparc) 2 else 1;
     pub const UNLCK = if (is_sparc) 3 else 2;
+
+    pub const LINUX_SPECIFIC_BASE = 1024;
+
+    pub const SETLEASE = LINUX_SPECIFIC_BASE + 0;
+    pub const GETLEASE = LINUX_SPECIFIC_BASE + 1;
+    pub const NOTIFY = LINUX_SPECIFIC_BASE + 2;
+    pub const DUPFD_QUERY = LINUX_SPECIFIC_BASE + 3;
+    pub const CREATED_QUERY = LINUX_SPECIFIC_BASE + 4;
+    pub const CANCELLK = LINUX_SPECIFIC_BASE + 5;
+    pub const DUPFD_CLOEXEC = LINUX_SPECIFIC_BASE + 6;
+    pub const SETPIPE_SZ = LINUX_SPECIFIC_BASE + 7;
+    pub const GETPIPE_SZ = LINUX_SPECIFIC_BASE + 8;
+    pub const ADD_SEALS = LINUX_SPECIFIC_BASE + 9;
+    pub const GET_SEALS = LINUX_SPECIFIC_BASE + 10;
+    pub const GET_RW_HINT = LINUX_SPECIFIC_BASE + 11;
+    pub const SET_RW_HINT = LINUX_SPECIFIC_BASE + 12;
+    pub const GET_FILE_RW_HINT = LINUX_SPECIFIC_BASE + 13;
+    pub const SET_FILE_RW_HINT = LINUX_SPECIFIC_BASE + 14;
 };
 
 pub const F_OWNER = enum(i32) {
-- 
2.54.0


From b49dc5eb70b804a2354a01bd60c686f0f2279f2d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 10:54:02 -0800
Subject: [PATCH 199/499] build: bump max_rss for C ABI tests on Windows

---
 build.zig | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/build.zig b/build.zig
index 3df6969ddad159576ac3cb06c39c25c6586aa17c..964c180d757d74f39d7a2ba0f86dd27583ded0cc 100644
--- a/build.zig
+++ b/build.zig
@@ -625,10 +625,7 @@ pub fn build(b: *std.Build) !void {
                 .aarch64 => 1_813_612_134,
                 else => 1_900_000_000,
             },
-            .windows => switch (b.graph.host.result.cpu.arch) {
-                .x86_64 => 386_287_616,
-                else => 400_000_000,
-            },
+            .windows => 400_000_000,
             else => 2_200_000_000,
         },
     }));
-- 
2.54.0


From 2a193a39871ad098931cecc1154cc42278c28a2b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Feb 2026 21:08:42 -0800
Subject: [PATCH 200/499] std: move GetFinalPathNameByHandle to Io.Threaded

unfortunately this function calls NtCreateFile so it has to participate
in cancelation
---
 lib/std/Build/Watch.zig                       |   2 +-
 lib/std/Io/Threaded.zig                       | 598 +++++++++++++++++-
 lib/std/Io/Threaded/test.zig                  | 335 ++++++++++
 lib/std/dynamic_library.zig                   |  71 +--
 lib/std/os/windows.zig                        | 565 -----------------
 lib/std/os/windows/test.zig                   | 339 ----------
 lib/std/zig/parser_test.zig                   |   2 +-
 .../standalone/load_dynamic_library/build.zig |   1 +
 8 files changed, 907 insertions(+), 1006 deletions(-)
 delete mode 100644 lib/std/os/windows/test.zig

diff --git a/lib/std/Build/Watch.zig b/lib/std/Build/Watch.zig
index 5920a227cb192f75c7e8224e211240d814acaf0b..15ccfcfdf9cde96d937b3fde8424c2e1bfbf200d 100644
--- a/lib/std/Build/Watch.zig
+++ b/lib/std/Build/Watch.zig
@@ -358,7 +358,7 @@ const Os = switch (builtin.os.tag) {
                 var dir_handle: windows.HANDLE = undefined;
                 const root_fd = path.root_dir.handle.handle;
                 const sub_path = path.subPathOrDot();
-                const sub_path_w = try windows.sliceToPrefixedFileW(root_fd, sub_path);
+                const sub_path_w = try std.Io.Threaded.sliceToPrefixedFileW(root_fd, sub_path); // TODO eliminate this call
                 const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
 
                 var nt_name = windows.UNICODE_STRING{
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index fdef4ef47e5a33c9770fae9967bba34821946678..1c171d7321b8575d01a82fcbe712078a662c8ee6 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3257,7 +3257,7 @@ fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, pe
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
 
-    const sub_path_w = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
     _ = permissions; // TODO use this value
 
     const syscall: Syscall = try .start();
@@ -3363,7 +3363,7 @@ fn dirCreateDirPathOpenWindows(
     };
 
     components: while (true) {
-        const sub_path_w_array = try w.sliceToPrefixedFileW(dir.handle, component.path);
+        const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, component.path);
         const sub_path_w = sub_path_w_array.span();
         const is_last = it.peekNext() == null;
         const create_disposition: w.FILE.CREATE_DISPOSITION = if (is_last) .OPEN_IF else .CREATE;
@@ -4064,7 +4064,7 @@ fn dirAccessWindows(
 
     _ = options; // TODO
 
-    const sub_path_w_array = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
     const sub_path_w = sub_path_w_array.span();
 
     if (sub_path_w[0] == '.' and sub_path_w[1] == 0) return;
@@ -4285,7 +4285,7 @@ fn dirCreateFileWindows(
     if (std.mem.eql(u8, sub_path, ".")) return error.IsDir;
     if (std.mem.eql(u8, sub_path, "..")) return error.IsDir;
 
-    const sub_path_w_array = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
     const sub_path_w = sub_path_w_array.span();
     const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
 
@@ -4887,7 +4887,7 @@ fn dirOpenFileWindows(
 ) File.OpenError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    const sub_path_w_array = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
     const sub_path_w = sub_path_w_array.span();
     const dir_handle = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle;
     return dirOpenFileWtf16(dir_handle, sub_path_w, flags);
@@ -5151,7 +5151,7 @@ fn dirOpenDirPosix(
     _ = t;
 
     if (is_windows) {
-        const sub_path_w = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+        const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
         return dirOpenDirWindows(dir, sub_path_w.span(), options);
     }
 
@@ -5984,7 +5984,7 @@ fn dirRealPathFileWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8,
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
 
-    var path_name_w = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    var path_name_w = try sliceToPrefixedFileW(dir.handle, sub_path);
 
     const h_file = handle: {
         const syscall: Syscall = try .start();
@@ -6016,9 +6016,7 @@ fn dirRealPathFileWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8,
 
 fn realPathWindows(h_file: windows.HANDLE, out_buffer: []u8) File.RealPathError!usize {
     var wide_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
-    // TODO move GetFinalPathNameByHandle logic into Io.Threaded and add cancel checks
-    try Thread.checkCancel();
-    const wide_slice = try windows.GetFinalPathNameByHandle(h_file, .{}, &wide_buf);
+    const wide_slice = try GetFinalPathNameByHandle(h_file, .{}, &wide_buf);
 
     const len = std.unicode.calcWtf8Len(wide_slice);
     if (len > out_buffer.len)
@@ -6027,6 +6025,552 @@ fn realPathWindows(h_file: windows.HANDLE, out_buffer: []u8) File.RealPathError!
     return std.unicode.wtf16LeToWtf8(out_buffer, wide_slice);
 }
 
+/// Specifies how to format volume path in the result of `GetFinalPathNameByHandle`.
+/// Defaults to DOS volume names.
+pub const GetFinalPathNameByHandleFormat = struct {
+    volume_name: enum {
+        /// Format as DOS volume name
+        Dos,
+        /// Format as NT volume name
+        Nt,
+    } = .Dos,
+};
+
+pub const GetFinalPathNameByHandleError = error{
+    AccessDenied,
+    FileNotFound,
+    NameTooLong,
+    /// The volume does not contain a recognized file system. File system
+    /// drivers might not be loaded, or the volume may be corrupt.
+    UnrecognizedVolume,
+} || Io.Cancelable || Io.UnexpectedError;
+
+/// Returns canonical (normalized) path of handle.
+/// Use `GetFinalPathNameByHandleFormat` to specify whether the path is meant to include
+/// NT or DOS volume name (e.g., `\Device\HarddiskVolume0\foo.txt` versus `C:\foo.txt`).
+/// If DOS volume name format is selected, note that this function does *not* prepend
+/// `\\?\` prefix to the resultant path.
+pub fn GetFinalPathNameByHandle(
+    hFile: windows.HANDLE,
+    fmt: GetFinalPathNameByHandleFormat,
+    out_buffer: []u16,
+) GetFinalPathNameByHandleError![]u16 {
+    const final_path = QueryObjectName(hFile, out_buffer) catch |err| switch (err) {
+        // we assume InvalidHandle is close enough to FileNotFound in semantics
+        // to not further complicate the error set
+        error.InvalidHandle => return error.FileNotFound,
+        else => |e| return e,
+    };
+
+    switch (fmt.volume_name) {
+        .Nt => {
+            // the returned path is already in .Nt format
+            return final_path;
+        },
+        .Dos => {
+            // parse the string to separate volume path from file path
+            const device_prefix = std.unicode.utf8ToUtf16LeStringLiteral("\\Device\\");
+
+            // We aren't entirely sure of the structure of the path returned by
+            // QueryObjectName in all contexts/environments.
+            // This code is written to cover the various cases that have
+            // been encountered and solved appropriately. But note that there's
+            // no easy way to verify that they have all been tackled!
+            // (Unless you, the reader knows of one then please do action that!)
+            if (!std.mem.startsWith(u16, final_path, device_prefix)) {
+                // Wine seems to return NT namespaced paths starting with \??\ from QueryObjectName
+                // (e.g. `\??\Z:\some\path\to\a\file.txt`), in which case we can just strip the
+                // prefix to turn it into an absolute path.
+                // https://github.com/ziglang/zig/issues/26029
+                // https://bugs.winehq.org/show_bug.cgi?id=39569
+                return windows.ntToWin32Namespace(final_path, out_buffer) catch |err| switch (err) {
+                    error.NotNtPath => return error.Unexpected,
+                    error.NameTooLong => |e| return e,
+                };
+            }
+
+            const file_path_begin_index = std.mem.findPos(u16, final_path, device_prefix.len, &[_]u16{'\\'}) orelse unreachable;
+            const volume_name_u16 = final_path[0..file_path_begin_index];
+            const device_name_u16 = volume_name_u16[device_prefix.len..];
+            const file_name_u16 = final_path[file_path_begin_index..];
+
+            // MUP is Multiple UNC Provider, and indicates that the path is a UNC
+            // path. In this case, the canonical UNC path can be gotten by just
+            // dropping the \Device\Mup\ and making sure the path begins with \\
+            if (std.mem.eql(u16, device_name_u16, std.unicode.utf8ToUtf16LeStringLiteral("Mup"))) {
+                out_buffer[0] = '\\';
+                @memmove(out_buffer[1..][0..file_name_u16.len], file_name_u16);
+                return out_buffer[0 .. 1 + file_name_u16.len];
+            }
+
+            // Get DOS volume name. DOS volume names are actually symbolic link objects to the
+            // actual NT volume. For example:
+            // (NT) \Device\HarddiskVolume4 => (DOS) \DosDevices\C: == (DOS) C:
+            const MIN_SIZE = @sizeOf(windows.MOUNTMGR_MOUNT_POINT) + windows.MAX_PATH;
+            // We initialize the input buffer to all zeros for convenience since
+            // `DeviceIoControl` with `IOCTL_MOUNTMGR_QUERY_POINTS` expects this.
+            var input_buf: [MIN_SIZE]u8 align(@alignOf(windows.MOUNTMGR_MOUNT_POINT)) = [_]u8{0} ** MIN_SIZE;
+            var output_buf: [MIN_SIZE * 4]u8 align(@alignOf(windows.MOUNTMGR_MOUNT_POINTS)) = undefined;
+
+            // This surprising path is a filesystem path to the mount manager on Windows.
+            // Source: https://stackoverflow.com/questions/3012828/using-ioctl-mountmgr-query-points
+            // This is the NT namespaced version of \\.\MountPointManager
+            const mgmt_path_u16 = std.unicode.utf8ToUtf16LeStringLiteral("\\??\\MountPointManager");
+            const mgmt_handle = windows.OpenFile(mgmt_path_u16, .{
+                .access_mask = .{ .STANDARD = .{ .SYNCHRONIZE = true } },
+                .creation = .OPEN,
+            }) catch |err| switch (err) {
+                error.IsDir => return error.Unexpected,
+                error.NotDir => return error.Unexpected,
+                error.NoDevice => return error.Unexpected,
+                error.AccessDenied => return error.Unexpected,
+                error.PipeBusy => return error.Unexpected,
+                error.PathAlreadyExists => return error.Unexpected,
+                error.WouldBlock => return error.Unexpected,
+                error.NetworkNotFound => return error.Unexpected,
+                error.AntivirusInterference => return error.Unexpected,
+                error.BadPathName => return error.Unexpected,
+                error.OperationCanceled => @panic("TODO: better integrate cancelation"),
+                else => |e| return e,
+            };
+            defer windows.CloseHandle(mgmt_handle);
+
+            var input_struct: *windows.MOUNTMGR_MOUNT_POINT = @ptrCast(&input_buf[0]);
+            input_struct.DeviceNameOffset = @sizeOf(windows.MOUNTMGR_MOUNT_POINT);
+            input_struct.DeviceNameLength = @intCast(volume_name_u16.len * 2);
+            @memcpy(input_buf[@sizeOf(windows.MOUNTMGR_MOUNT_POINT)..][0 .. volume_name_u16.len * 2], @as([*]const u8, @ptrCast(volume_name_u16.ptr)));
+
+            {
+                const rc = windows.DeviceIoControl(mgmt_handle, windows.IOCTL.MOUNTMGR.QUERY_POINTS, .{ .in = &input_buf, .out = &output_buf });
+                switch (rc) {
+                    .SUCCESS => {},
+                    .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
+                    else => return windows.unexpectedStatus(rc),
+                }
+            }
+            const mount_points_struct: *const windows.MOUNTMGR_MOUNT_POINTS = @ptrCast(&output_buf[0]);
+
+            const mount_points = @as(
+                [*]const windows.MOUNTMGR_MOUNT_POINT,
+                @ptrCast(&mount_points_struct.MountPoints[0]),
+            )[0..mount_points_struct.NumberOfMountPoints];
+
+            for (mount_points) |mount_point| {
+                const symlink = @as(
+                    [*]const u16,
+                    @ptrCast(@alignCast(&output_buf[mount_point.SymbolicLinkNameOffset])),
+                )[0 .. mount_point.SymbolicLinkNameLength / 2];
+
+                // Look for `\DosDevices\` prefix. We don't really care if there are more than one symlinks
+                // with traditional DOS drive letters, so pick the first one available.
+                var prefix_buf = std.unicode.utf8ToUtf16LeStringLiteral("\\DosDevices\\");
+                const prefix = prefix_buf[0..prefix_buf.len];
+
+                if (std.mem.startsWith(u16, symlink, prefix)) {
+                    const drive_letter = symlink[prefix.len..];
+
+                    if (out_buffer.len < drive_letter.len + file_name_u16.len) return error.NameTooLong;
+
+                    @memcpy(out_buffer[0..drive_letter.len], drive_letter);
+                    @memmove(out_buffer[drive_letter.len..][0..file_name_u16.len], file_name_u16);
+                    const total_len = drive_letter.len + file_name_u16.len;
+
+                    // Validate that DOS does not contain any spurious nul bytes.
+                    assert(std.mem.findScalar(u16, out_buffer[0..total_len], 0) == null);
+
+                    return out_buffer[0..total_len];
+                } else if (mountmgrIsVolumeName(symlink)) {
+                    // If the symlink is a volume GUID like \??\Volume{383da0b0-717f-41b6-8c36-00500992b58d},
+                    // then it is a volume mounted as a path rather than a drive letter. We need to
+                    // query the mount manager again to get the DOS path for the volume.
+
+                    // 49 is the maximum length accepted by mountmgrIsVolumeName
+                    const vol_input_size = @sizeOf(windows.MOUNTMGR_TARGET_NAME) + (49 * 2);
+                    var vol_input_buf: [vol_input_size]u8 align(@alignOf(windows.MOUNTMGR_TARGET_NAME)) = [_]u8{0} ** vol_input_size;
+                    // Note: If the path exceeds MAX_PATH, the Disk Management GUI doesn't accept the full path,
+                    // and instead if must be specified using a shortened form (e.g. C:\FOO~1\BAR~1\<...>).
+                    // However, just to be sure we can handle any path length, we use PATH_MAX_WIDE here.
+                    const min_output_size = @sizeOf(windows.MOUNTMGR_VOLUME_PATHS) + (windows.PATH_MAX_WIDE * 2);
+                    var vol_output_buf: [min_output_size]u8 align(@alignOf(windows.MOUNTMGR_VOLUME_PATHS)) = undefined;
+
+                    var vol_input_struct: *windows.MOUNTMGR_TARGET_NAME = @ptrCast(&vol_input_buf[0]);
+                    vol_input_struct.DeviceNameLength = @intCast(symlink.len * 2);
+                    @memcpy(@as([*]windows.WCHAR, &vol_input_struct.DeviceName)[0..symlink.len], symlink);
+
+                    const rc = windows.DeviceIoControl(mgmt_handle, windows.IOCTL.MOUNTMGR.QUERY_DOS_VOLUME_PATH, .{ .in = &vol_input_buf, .out = &vol_output_buf });
+                    switch (rc) {
+                        .SUCCESS => {},
+                        .UNRECOGNIZED_VOLUME => return error.UnrecognizedVolume,
+                        else => return windows.unexpectedStatus(rc),
+                    }
+                    const volume_paths_struct: *const windows.MOUNTMGR_VOLUME_PATHS = @ptrCast(&vol_output_buf[0]);
+                    const volume_path = std.mem.sliceTo(@as(
+                        [*]const u16,
+                        &volume_paths_struct.MultiSz,
+                    )[0 .. volume_paths_struct.MultiSzLength / 2], 0);
+
+                    if (out_buffer.len < volume_path.len + file_name_u16.len) return error.NameTooLong;
+
+                    // `out_buffer` currently contains the memory of `file_name_u16`, so it can overlap with where
+                    // we want to place the filename before returning. Here are the possible overlapping cases:
+                    //
+                    // out_buffer:       [filename]
+                    //       dest: [___(a)___] [___(b)___]
+                    //
+                    // In the case of (a), we need to copy forwards, and in the case of (b) we need
+                    // to copy backwards. We also need to do this before copying the volume path because
+                    // it could overwrite the file_name_u16 memory.
+                    const file_name_dest = out_buffer[volume_path.len..][0..file_name_u16.len];
+                    @memmove(file_name_dest, file_name_u16);
+                    @memcpy(out_buffer[0..volume_path.len], volume_path);
+                    const total_len = volume_path.len + file_name_u16.len;
+
+                    // Validate that DOS does not contain any spurious nul bytes.
+                    assert(std.mem.findScalar(u16, out_buffer[0..total_len], 0) == null);
+
+                    return out_buffer[0..total_len];
+                }
+            }
+
+            // If we've ended up here, then something went wrong/is corrupted in the OS,
+            // so error out!
+            return error.FileNotFound;
+        },
+    }
+}
+
+test GetFinalPathNameByHandle {
+    if (builtin.os.tag != .windows)
+        return;
+
+    //any file will do
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+    const handle = tmp.dir.handle;
+    var buffer: [windows.PATH_MAX_WIDE]u16 = undefined;
+
+    //check with sufficient size
+    const nt_path = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, &buffer);
+    _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, &buffer);
+
+    const required_len_in_u16 = nt_path.len + @divExact(@intFromPtr(nt_path.ptr) - @intFromPtr(&buffer), 2) + 1;
+    //check with insufficient size
+    try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1]));
+    try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1]));
+
+    //check with exactly-sufficient size
+    _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0..required_len_in_u16]);
+    _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0..required_len_in_u16]);
+}
+
+/// Equivalent to the MOUNTMGR_IS_VOLUME_NAME macro in mountmgr.h
+fn mountmgrIsVolumeName(name: []const u16) bool {
+    return (name.len == 48 or (name.len == 49 and name[48] == std.mem.nativeToLittle(u16, '\\'))) and
+        name[0] == std.mem.nativeToLittle(u16, '\\') and
+        (name[1] == std.mem.nativeToLittle(u16, '?') or name[1] == std.mem.nativeToLittle(u16, '\\')) and
+        name[2] == std.mem.nativeToLittle(u16, '?') and
+        name[3] == std.mem.nativeToLittle(u16, '\\') and
+        std.mem.startsWith(u16, name[4..], std.unicode.utf8ToUtf16LeStringLiteral("Volume{")) and
+        name[19] == std.mem.nativeToLittle(u16, '-') and
+        name[24] == std.mem.nativeToLittle(u16, '-') and
+        name[29] == std.mem.nativeToLittle(u16, '-') and
+        name[34] == std.mem.nativeToLittle(u16, '-') and
+        name[47] == std.mem.nativeToLittle(u16, '}');
+}
+
+test mountmgrIsVolumeName {
+    @setEvalBranchQuota(2000);
+    const L = std.unicode.utf8ToUtf16LeStringLiteral;
+    try std.testing.expect(mountmgrIsVolumeName(L("\\\\?\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
+    try std.testing.expect(mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
+    try std.testing.expect(mountmgrIsVolumeName(L("\\\\?\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\")));
+    try std.testing.expect(mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\")));
+    try std.testing.expect(!mountmgrIsVolumeName(L("\\\\.\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
+    try std.testing.expect(!mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\foo")));
+    try std.testing.expect(!mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58}")));
+}
+
+pub const QueryObjectNameError = error{
+    AccessDenied,
+    InvalidHandle,
+    NameTooLong,
+    Unexpected,
+};
+
+pub fn QueryObjectName(handle: windows.HANDLE, out_buffer: []u16) QueryObjectNameError![]u16 {
+    const out_buffer_aligned = std.mem.alignInSlice(out_buffer, @alignOf(windows.OBJECT_NAME_INFORMATION)) orelse return error.NameTooLong;
+
+    const info: *windows.OBJECT_NAME_INFORMATION = @ptrCast(out_buffer_aligned);
+    // buffer size is specified in bytes
+    const out_buffer_len = std.math.cast(windows.ULONG, out_buffer_aligned.len * 2) orelse std.math.maxInt(windows.ULONG);
+    // last argument would return the length required for full_buffer, not exposed here
+    return switch (windows.ntdll.NtQueryObject(handle, .ObjectNameInformation, info, out_buffer_len, null)) {
+        .SUCCESS => blk: {
+            // info.Name.Buffer from ObQueryNameString is documented to be null (and MaximumLength == 0)
+            // if the object was "unnamed", not sure if this can happen for file handles
+            if (info.Name.MaximumLength == 0) break :blk error.Unexpected;
+            // resulting string length is specified in bytes
+            const path_length_unterminated = @divExact(info.Name.Length, 2);
+            break :blk info.Name.Buffer.?[0..path_length_unterminated];
+        },
+        .ACCESS_DENIED => error.AccessDenied,
+        .INVALID_HANDLE => error.InvalidHandle,
+        // triggered when the buffer is too small for the OBJECT_NAME_INFORMATION object (.INFO_LENGTH_MISMATCH),
+        // or if the buffer is too small for the file path returned (.BUFFER_OVERFLOW, .BUFFER_TOO_SMALL)
+        .INFO_LENGTH_MISMATCH, .BUFFER_OVERFLOW, .BUFFER_TOO_SMALL => error.NameTooLong,
+        else => |e| windows.unexpectedStatus(e),
+    };
+}
+
+test QueryObjectName {
+    if (builtin.os.tag != .windows)
+        return;
+
+    //any file will do; canonicalization works on NTFS junctions and symlinks, hardlinks remain separate paths.
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+    const handle = tmp.dir.handle;
+    var out_buffer: [windows.PATH_MAX_WIDE]u16 = undefined;
+
+    const result_path = try QueryObjectName(handle, &out_buffer);
+    const required_len_in_u16 = result_path.len + @divExact(@intFromPtr(result_path.ptr) - @intFromPtr(&out_buffer), 2) + 1;
+    //insufficient size
+    try std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1]));
+    //exactly-sufficient size
+    _ = try QueryObjectName(handle, out_buffer[0..required_len_in_u16]);
+}
+
+const Wtf16ToPrefixedFileWError = error{
+    AccessDenied,
+    FileNotFound,
+} || Dir.PathNameError || Io.Cancelable || Io.UnexpectedError;
+
+/// Converts the `path` to WTF16, null-terminated. If the path contains any
+/// namespace prefix, or is anything but a relative path (rooted, drive relative,
+/// etc) the result will have the NT-style prefix `\??\`.
+///
+/// Similar to RtlDosPathNameToNtPathName_U with a few differences:
+/// - Does not allocate on the heap.
+/// - Relative paths are kept as relative unless they contain too many ..
+///   components, in which case they are resolved against the `dir` if it
+///   is non-null, or the CWD if it is null.
+/// - Special case device names like COM1, NUL, etc are not handled specially (TODO)
+/// - . and space are not stripped from the end of relative paths (potential TODO)
+pub fn wToPrefixedFileW(dir: ?windows.HANDLE, path: [:0]const u16) Wtf16ToPrefixedFileWError!WindowsPathSpace {
+    const nt_prefix = [_]u16{ '\\', '?', '?', '\\' };
+    if (windows.hasCommonNtPrefix(u16, path)) {
+        // TODO: Figure out a way to design an API that can avoid the copy for NT,
+        //       since it is always returned fully unmodified.
+        var path_space: WindowsPathSpace = undefined;
+        path_space.data[0..nt_prefix.len].* = nt_prefix;
+        const len_after_prefix = path.len - nt_prefix.len;
+        @memcpy(path_space.data[nt_prefix.len..][0..len_after_prefix], path[nt_prefix.len..]);
+        path_space.len = path.len;
+        path_space.data[path_space.len] = 0;
+        return path_space;
+    } else {
+        const path_type = Dir.path.getWin32PathType(u16, path);
+        var path_space: WindowsPathSpace = undefined;
+        if (path_type == .local_device) {
+            switch (getLocalDevicePathType(u16, path)) {
+                .verbatim => {
+                    path_space.data[0..nt_prefix.len].* = nt_prefix;
+                    const len_after_prefix = path.len - nt_prefix.len;
+                    @memcpy(path_space.data[nt_prefix.len..][0..len_after_prefix], path[nt_prefix.len..]);
+                    path_space.len = path.len;
+                    path_space.data[path_space.len] = 0;
+                    return path_space;
+                },
+                .local_device, .fake_verbatim => {
+                    const path_byte_len = windows.ntdll.RtlGetFullPathName_U(
+                        path.ptr,
+                        path_space.data.len * 2,
+                        &path_space.data,
+                        null,
+                    );
+                    if (path_byte_len == 0) {
+                        // TODO: This may not be the right error
+                        return error.BadPathName;
+                    } else if (path_byte_len / 2 > path_space.data.len) {
+                        return error.NameTooLong;
+                    }
+                    path_space.len = path_byte_len / 2;
+                    // Both prefixes will be normalized but retained, so all
+                    // we need to do now is replace them with the NT prefix
+                    path_space.data[0..nt_prefix.len].* = nt_prefix;
+                    return path_space;
+                },
+            }
+        }
+        relative: {
+            if (path_type == .relative) {
+                // TODO: Handle special case device names like COM1, AUX, NUL, CONIN$, CONOUT$, etc.
+                //       See https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
+
+                // TODO: Potentially strip all trailing . and space characters from the
+                //       end of the path. This is something that both RtlDosPathNameToNtPathName_U
+                //       and RtlGetFullPathName_U do. Technically, trailing . and spaces
+                //       are allowed, but such paths may not interact well with Windows (i.e.
+                //       files with these paths can't be deleted from explorer.exe, etc).
+                //       This could be something that normalizePath may want to do.
+
+                @memcpy(path_space.data[0..path.len], path);
+                // Try to normalize, but if we get too many parent directories,
+                // then we need to start over and use RtlGetFullPathName_U instead.
+                path_space.len = windows.normalizePath(u16, path_space.data[0..path.len]) catch |err| switch (err) {
+                    error.TooManyParentDirs => break :relative,
+                };
+                path_space.data[path_space.len] = 0;
+                return path_space;
+            }
+        }
+        // We now know we are going to return an absolute NT path, so
+        // we can unconditionally prefix it with the NT prefix.
+        path_space.data[0..nt_prefix.len].* = nt_prefix;
+        if (path_type == .root_local_device) {
+            // `\\.` and `\\?` always get converted to `\??\` exactly, so
+            // we can just stop here
+            path_space.len = nt_prefix.len;
+            path_space.data[path_space.len] = 0;
+            return path_space;
+        }
+        const path_buf_offset = switch (path_type) {
+            // UNC paths will always start with `\\`. However, we want to
+            // end up with something like `\??\UNC\server\share`, so to get
+            // RtlGetFullPathName to write into the spot we want the `server`
+            // part to end up, we need to provide an offset such that
+            // the `\\` part gets written where the `C\` of `UNC\` will be
+            // in the final NT path.
+            .unc_absolute => nt_prefix.len + 2,
+            else => nt_prefix.len,
+        };
+        const buf_len: u32 = @intCast(path_space.data.len - path_buf_offset);
+        const path_to_get: [:0]const u16 = path_to_get: {
+            // If dir is null, then we don't need to bother with GetFinalPathNameByHandle because
+            // RtlGetFullPathName_U will resolve relative paths against the CWD for us.
+            if (path_type != .relative or dir == null) {
+                break :path_to_get path;
+            }
+            // We can also skip GetFinalPathNameByHandle if the handle matches
+            // the handle returned by Io.Dir.cwd()
+            if (dir.? == Io.Dir.cwd().handle) {
+                break :path_to_get path;
+            }
+            // At this point, we know we have a relative path that had too many
+            // `..` components to be resolved by normalizePath, so we need to
+            // convert it into an absolute path and let RtlGetFullPathName_U
+            // canonicalize it. We do this by getting the path of the `dir`
+            // and appending the relative path to it.
+            var dir_path_buf: [windows.PATH_MAX_WIDE:0]u16 = undefined;
+            const dir_path = GetFinalPathNameByHandle(dir.?, .{}, &dir_path_buf) catch |err| switch (err) {
+                // This mapping is not correct; it is actually expected
+                // that calling GetFinalPathNameByHandle might return
+                // error.UnrecognizedVolume, and in fact has been observed
+                // in the wild. The problem is that wToPrefixedFileW was
+                // never intended to make *any* OS syscall APIs. It's only
+                // supposed to convert a string to one that is eligible to
+                // be used in the ntdll syscalls.
+                //
+                // To solve this, this function needs to no longer call
+                // GetFinalPathNameByHandle under any conditions, or the
+                // calling function needs to get reworked to not need to
+                // call this function.
+                //
+                // This may involve making breaking API changes.
+                error.UnrecognizedVolume => return error.Unexpected,
+                else => |e| return e,
+            };
+            if (dir_path.len + 1 + path.len > windows.PATH_MAX_WIDE) {
+                return error.NameTooLong;
+            }
+            // We don't have to worry about potentially doubling up path separators
+            // here since RtlGetFullPathName_U will handle canonicalizing it.
+            dir_path_buf[dir_path.len] = '\\';
+            @memcpy(dir_path_buf[dir_path.len + 1 ..][0..path.len], path);
+            const full_len = dir_path.len + 1 + path.len;
+            dir_path_buf[full_len] = 0;
+            break :path_to_get dir_path_buf[0..full_len :0];
+        };
+        const path_byte_len = windows.ntdll.RtlGetFullPathName_U(
+            path_to_get.ptr,
+            buf_len * 2,
+            path_space.data[path_buf_offset..].ptr,
+            null,
+        );
+        if (path_byte_len == 0) {
+            // TODO: This may not be the right error
+            return error.BadPathName;
+        } else if (path_byte_len / 2 > buf_len) {
+            return error.NameTooLong;
+        }
+        path_space.len = path_buf_offset + (path_byte_len / 2);
+        if (path_type == .unc_absolute) {
+            // Now add in the UNC, the `C` should overwrite the first `\` of the
+            // FullPathName, ultimately resulting in `\??\UNC\<the rest of the path>`
+            assert(path_space.data[path_buf_offset] == '\\');
+            assert(path_space.data[path_buf_offset + 1] == '\\');
+            const unc = [_]u16{ 'U', 'N', 'C' };
+            path_space.data[nt_prefix.len..][0..unc.len].* = unc;
+        }
+        return path_space;
+    }
+}
+
+const LocalDevicePathType = enum {
+    /// `\\.\` (path separators can be `\` or `/`)
+    local_device,
+    /// `\\?\`
+    /// When converted to an NT path, everything past the prefix is left
+    /// untouched and `\\?\` is replaced by `\??\`.
+    verbatim,
+    /// `\\?\` without all path separators being `\`.
+    /// This seems to be recognized as a prefix, but the 'verbatim' aspect
+    /// is not respected (i.e. if `//?/C:/foo` is converted to an NT path,
+    /// it will become `\??\C:\foo` [it will be canonicalized and the //?/ won't
+    /// be treated as part of the final path])
+    fake_verbatim,
+};
+
+/// Only relevant for Win32 -> NT path conversion.
+/// Asserts `path` is of type `Dir.path.Win32PathType.local_device`.
+fn getLocalDevicePathType(comptime T: type, path: []const T) LocalDevicePathType {
+    if (std.debug.runtime_safety) {
+        assert(Dir.path.getWin32PathType(T, path) == .local_device);
+    }
+
+    const backslash = std.mem.nativeToLittle(T, '\\');
+    const all_backslash = path[0] == backslash and
+        path[1] == backslash and
+        path[3] == backslash;
+    return switch (path[2]) {
+        std.mem.nativeToLittle(T, '?') => if (all_backslash) .verbatim else .fake_verbatim,
+        std.mem.nativeToLittle(T, '.') => .local_device,
+        else => unreachable,
+    };
+}
+
+pub const Wtf8ToPrefixedFileWError = Wtf16ToPrefixedFileWError;
+
+/// Same as `wToPrefixedFileW` but accepts a WTF-8 encoded path.
+/// https://wtf-8.codeberg.page/
+pub fn sliceToPrefixedFileW(dir: ?windows.HANDLE, path: []const u8) Wtf8ToPrefixedFileWError!WindowsPathSpace {
+    var temp_path: WindowsPathSpace = undefined;
+    temp_path.len = std.unicode.wtf8ToWtf16Le(&temp_path.data, path) catch |err| switch (err) {
+        error.InvalidWtf8 => return error.BadPathName,
+    };
+    temp_path.data[temp_path.len] = 0;
+    return wToPrefixedFileW(dir, temp_path.span());
+}
+
+pub const WindowsPathSpace = struct {
+    data: [windows.PATH_MAX_WIDE:0]u16,
+    len: usize,
+
+    pub fn span(self: *const WindowsPathSpace) [:0]const u16 {
+        return self.data[0..self.len :0];
+    }
+};
+
 fn dirRealPathFilePosix(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, out_buffer: []u8) Dir.RealPathFileError!usize {
     if (native_os == .wasi) return error.OperationUnsupported;
 
@@ -6478,7 +7022,7 @@ fn dirDeleteWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, remov
     _ = t;
     const w = windows;
 
-    const sub_path_w_buf = try w.sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w_buf = try sliceToPrefixedFileW(dir.handle, sub_path);
     const sub_path_w = sub_path_w_buf.span();
 
     const path_len_bytes = @as(u16, @intCast(sub_path_w.len * 2));
@@ -6759,9 +7303,9 @@ fn dirRenameWindowsInner(
     replace_if_exists: bool,
 ) Dir.RenamePreserveError!void {
     const w = windows;
-    const old_path_w_buf = try windows.sliceToPrefixedFileW(old_dir.handle, old_sub_path);
+    const old_path_w_buf = try sliceToPrefixedFileW(old_dir.handle, old_sub_path);
     const old_path_w = old_path_w_buf.span();
-    const new_path_w_buf = try windows.sliceToPrefixedFileW(new_dir.handle, new_sub_path);
+    const new_path_w_buf = try sliceToPrefixedFileW(new_dir.handle, new_sub_path);
     const new_path_w = new_path_w_buf.span();
 
     const src_fd = src_fd: {
@@ -7092,7 +7636,7 @@ fn dirSymLinkWindows(
     // Target path does not use sliceToPrefixedFileW because certain paths
     // are handled differently when creating a symlink than they would be
     // when converting to an NT namespaced path.
-    var target_path_w: w.PathSpace = undefined;
+    var target_path_w: WindowsPathSpace = undefined;
     target_path_w.len = try w.wtf8ToWtf16Le(&target_path_w.data, target_path);
     target_path_w.data[target_path_w.len] = 0;
     // However, we need to canonicalize any path separators to `\`, since if
@@ -7104,7 +7648,7 @@ fn dirSymLinkWindows(
         std.mem.nativeToLittle(u16, '\\'),
     );
 
-    const sym_link_path_w = try w.sliceToPrefixedFileW(dir.handle, sym_link_path);
+    const sym_link_path_w = try sliceToPrefixedFileW(dir.handle, sym_link_path);
 
     const SYMLINK_DATA = extern struct {
         ReparseTag: w.IO_REPARSE_TAG,
@@ -7158,7 +7702,7 @@ fn dirSymLinkWindows(
     // https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createsymboliclinkw
     var is_target_absolute = false;
     const final_target_path = target_path: {
-        if (w.hasCommonNtPrefix(u16, target_path_w.span())) {
+        if (windows.hasCommonNtPrefix(u16, target_path_w.span())) {
             // Already an NT path, no need to do anything to it
             break :target_path target_path_w.span();
         } else {
@@ -7176,7 +7720,7 @@ fn dirSymLinkWindows(
                     break :target_path target_path_w.span(),
             }
         }
-        var prefixed_target_path = try w.wToPrefixedFileW(dir.handle, target_path_w.span());
+        var prefixed_target_path = try wToPrefixedFileW(dir.handle, target_path_w.span());
         // We do this after prefixing to ensure that drive-relative paths are treated as absolute
         is_target_absolute = Dir.path.isAbsoluteWindowsWtf16(prefixed_target_path.span());
         break :target_path prefixed_target_path.span();
@@ -7322,7 +7866,7 @@ fn dirReadLink(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []
 fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
     // This gets used once for `sub_path` and then reused again temporarily
     // before converting back to `buffer`.
-    var sub_path_w_buf = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
+    var sub_path_w_buf = try sliceToPrefixedFileW(dir.handle, sub_path);
     const sub_path_w = sub_path_w_buf.span();
     const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
     var nt_name: windows.UNICODE_STRING = .{
@@ -9586,7 +10130,7 @@ fn processExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) process.O
             // the file, we can let the openFileW call follow the symlink for us.
             const image_path_unicode_string = &windows.peb().ProcessParameters.ImagePathName;
             const image_path_name = image_path_unicode_string.Buffer.?[0 .. image_path_unicode_string.Length / 2 :0];
-            const prefixed_path_w = try windows.wToPrefixedFileW(null, image_path_name);
+            const prefixed_path_w = try wToPrefixedFileW(null, image_path_name);
             return dirOpenFileWtf16(null, prefixed_path_w.span(), flags);
         },
         .driverkit,
@@ -9794,7 +10338,7 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             // If ImagePathName is a symlink, then it will contain the path of the
             // symlink, not the path that the symlink points to. We want the path
             // that the symlink points to, though, so we need to get the realpath.
-            var path_name_w_buf = try w.wToPrefixedFileW(null, image_path_name);
+            var path_name_w_buf = try wToPrefixedFileW(null, image_path_name);
 
             const h_file = handle: {
                 const syscall: Syscall = try .start();
@@ -9822,9 +10366,7 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             };
             defer w.CloseHandle(h_file);
 
-            // TODO move GetFinalPathNameByHandle logic into Io.Threaded and add cancel checks
-            try Thread.checkCancel();
-            const wide_slice = try w.GetFinalPathNameByHandle(h_file, .{}, &path_name_w_buf.data);
+            const wide_slice = try GetFinalPathNameByHandle(h_file, .{}, &path_name_w_buf.data);
 
             const len = std.unicode.calcWtf8Len(wide_slice);
             if (len > out_buffer.len)
@@ -13598,9 +14140,7 @@ fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirEr
 
     if (is_windows) {
         var dir_path_buffer: [windows.PATH_MAX_WIDE]u16 = undefined;
-        // TODO move GetFinalPathNameByHandle logic into Io.Threaded and add cancel checks
-        try Thread.checkCancel();
-        const dir_path = try windows.GetFinalPathNameByHandle(dir.handle, .{}, &dir_path_buffer);
+        const dir_path = try GetFinalPathNameByHandle(dir.handle, .{}, &dir_path_buffer);
         const path_len_bytes = std.math.cast(u16, dir_path.len * 2) orelse return error.NameTooLong;
         var nt_name: windows.UNICODE_STRING = .{
             .Length = path_len_bytes,
@@ -15326,9 +15866,7 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
             .inherit => break :cwd_w null,
             .dir => |cwd_dir| {
                 var dir_path_buffer = try arena.alloc(u16, windows.PATH_MAX_WIDE + 1);
-                // TODO move GetFinalPathNameByHandle logic into std.Io.Threaded and add cancel checks
-                try Thread.checkCancel();
-                const dir_path = try windows.GetFinalPathNameByHandle(
+                const dir_path = try GetFinalPathNameByHandle(
                     cwd_dir.handle,
                     .{},
                     dir_path_buffer[0..windows.PATH_MAX_WIDE],
@@ -15752,7 +16290,7 @@ fn windowsCreateProcessPathExt(
         try dir_buf.append(arena, 0);
         defer dir_buf.shrinkRetainingCapacity(dir_path_len);
         const dir_path_z = dir_buf.items[0 .. dir_buf.items.len - 1 :0];
-        const prefixed_path = try windows.wToPrefixedFileW(null, dir_path_z);
+        const prefixed_path = try wToPrefixedFileW(null, dir_path_z);
         break :dir dirOpenDirWindows(.cwd(), prefixed_path.span(), .{
             .iterate = true,
         }) catch |err| switch (err) {
diff --git a/lib/std/Io/Threaded/test.zig b/lib/std/Io/Threaded/test.zig
index 81c7be9170e8479c231e5f30931b38de39723f20..1c9b188584b588a44c225e51450390787eb81557 100644
--- a/lib/std/Io/Threaded/test.zig
+++ b/lib/std/Io/Threaded/test.zig
@@ -6,6 +6,7 @@ const std = @import("std");
 const Io = std.Io;
 const testing = std.testing;
 const assert = std.debug.assert;
+const windows = std.os.windows;
 
 test "concurrent vs main prevents deadlock via oversubscription" {
     if (true) {
@@ -277,3 +278,337 @@ test "memory mapping fallback" {
         try testing.expectEqualStrings("this9is9my data123", mm.memory);
     }
 }
+
+/// Wrapper around RtlDosPathNameToNtPathName_U for use in comparing
+/// the behavior of RtlDosPathNameToNtPathName_U with wToPrefixedFileW
+/// Note: RtlDosPathNameToNtPathName_U is not used in the Zig implementation
+//        because it allocates.
+fn RtlDosPathNameToNtPathName_U(path: [:0]const u16) !Io.Threaded.WindowsPathSpace {
+    var out: windows.UNICODE_STRING = undefined;
+    const rc = windows.ntdll.RtlDosPathNameToNtPathName_U(path, &out, null, null);
+    if (rc != windows.TRUE) return error.BadPathName;
+    defer windows.ntdll.RtlFreeUnicodeString(&out);
+
+    var path_space: Io.Threaded.WindowsPathSpace = undefined;
+    const out_path = out.Buffer.?[0 .. out.Length / 2];
+    @memcpy(path_space.data[0..out_path.len], out_path);
+    path_space.len = out.Length / 2;
+    path_space.data[path_space.len] = 0;
+
+    return path_space;
+}
+
+/// Test that the Zig conversion matches the expected_path (for instances where
+/// the Zig implementation intentionally diverges from what RtlDosPathNameToNtPathName_U does).
+fn testToPrefixedFileNoOracle(comptime path: []const u8, comptime expected_path: []const u8) !void {
+    const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);
+    const expected_path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(expected_path);
+    const actual_path = try Io.Threaded.wToPrefixedFileW(null, path_utf16);
+    std.testing.expectEqualSlices(u16, expected_path_utf16, actual_path.span()) catch |e| {
+        std.debug.print("got '{f}', expected '{f}'\n", .{ std.unicode.fmtUtf16Le(actual_path.span()), std.unicode.fmtUtf16Le(expected_path_utf16) });
+        return e;
+    };
+}
+
+/// Test that the Zig conversion matches the expected_path and that the
+/// expected_path matches the conversion that RtlDosPathNameToNtPathName_U does.
+fn testToPrefixedFileWithOracle(comptime path: []const u8, comptime expected_path: []const u8) !void {
+    try testToPrefixedFileNoOracle(path, expected_path);
+    try testToPrefixedFileOnlyOracle(path);
+}
+
+/// Test that the Zig conversion matches the conversion that RtlDosPathNameToNtPathName_U does.
+fn testToPrefixedFileOnlyOracle(comptime path: []const u8) !void {
+    const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);
+    const zig_result = try Io.Threaded.wToPrefixedFileW(null, path_utf16);
+    const win32_api_result = try RtlDosPathNameToNtPathName_U(path_utf16);
+    std.testing.expectEqualSlices(u16, win32_api_result.span(), zig_result.span()) catch |e| {
+        std.debug.print("got '{f}', expected '{f}'\n", .{ std.unicode.fmtUtf16Le(zig_result.span()), std.unicode.fmtUtf16Le(win32_api_result.span()) });
+        return e;
+    };
+}
+
+test "toPrefixedFileW" {
+    if (builtin.os.tag != .windows) return error.SkipZigTest;
+
+    // Most test cases come from https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
+    // Note that these tests do not actually touch the filesystem or care about whether or not
+    // any of the paths actually exist or are otherwise valid.
+
+    // Drive Absolute
+    try testToPrefixedFileWithOracle("X:\\ABC\\DEF", "\\??\\X:\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("X:\\", "\\??\\X:\\");
+    try testToPrefixedFileWithOracle("X:\\ABC\\", "\\??\\X:\\ABC\\");
+    // Trailing . and space characters are stripped
+    try testToPrefixedFileWithOracle("X:\\ABC\\DEF. .", "\\??\\X:\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("X:/ABC/DEF", "\\??\\X:\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("X:\\ABC\\..\\XYZ", "\\??\\X:\\XYZ");
+    try testToPrefixedFileWithOracle("X:\\ABC\\..\\..\\..", "\\??\\X:\\");
+    // Drive letter casing is unchanged
+    try testToPrefixedFileWithOracle("x:\\", "\\??\\x:\\");
+
+    // Drive Relative
+    // These tests depend on the CWD of the specified drive letter which can vary,
+    // so instead we just test that the Zig implementation matches the result of
+    // RtlDosPathNameToNtPathName_U.
+    // TODO: Setting the =X: environment variable didn't seem to affect
+    //       RtlDosPathNameToNtPathName_U, not sure why that is but getting that
+    //       to work could be an avenue to making these cases environment-independent.
+    // All -> are examples of the result if the X drive's cwd was X:\ABC
+    try testToPrefixedFileOnlyOracle("X:DEF\\GHI"); // -> \??\X:\ABC\DEF\GHI
+    try testToPrefixedFileOnlyOracle("X:"); // -> \??\X:\ABC
+    try testToPrefixedFileOnlyOracle("X:DEF. ."); // -> \??\X:\ABC\DEF
+    try testToPrefixedFileOnlyOracle("X:ABC\\..\\XYZ"); // -> \??\X:\ABC\XYZ
+    try testToPrefixedFileOnlyOracle("X:ABC\\..\\..\\.."); // -> \??\X:\
+    try testToPrefixedFileOnlyOracle("x:"); // -> \??\X:\ABC
+
+    // Rooted
+    // These tests depend on the drive letter of the CWD which can vary, so
+    // instead we just test that the Zig implementation matches the result of
+    // RtlDosPathNameToNtPathName_U.
+    // TODO: Getting the CWD path, getting the drive letter from it, and using it to
+    //       construct the expected NT paths could be an avenue to making these cases
+    //       environment-independent and therefore able to use testToPrefixedFileWithOracle.
+    // All -> are examples of the result if the CWD's drive letter was X
+    try testToPrefixedFileOnlyOracle("\\ABC\\DEF"); // -> \??\X:\ABC\DEF
+    try testToPrefixedFileOnlyOracle("\\"); // -> \??\X:\
+    try testToPrefixedFileOnlyOracle("\\ABC\\DEF. ."); // -> \??\X:\ABC\DEF
+    try testToPrefixedFileOnlyOracle("/ABC/DEF"); // -> \??\X:\ABC\DEF
+    try testToPrefixedFileOnlyOracle("\\ABC\\..\\XYZ"); // -> \??\X:\XYZ
+    try testToPrefixedFileOnlyOracle("\\ABC\\..\\..\\.."); // -> \??\X:\
+
+    // Relative
+    // These cases differ in functionality to RtlDosPathNameToNtPathName_U.
+    // Relative paths remain relative if they don't have enough .. components
+    // to error with TooManyParentDirs
+    try testToPrefixedFileNoOracle("ABC\\DEF", "ABC\\DEF");
+    // TODO: enable this if trailing . and spaces are stripped from relative paths
+    //try testToPrefixedFileNoOracle("ABC\\DEF. .", "ABC\\DEF");
+    try testToPrefixedFileNoOracle("ABC/DEF", "ABC\\DEF");
+    try testToPrefixedFileNoOracle("./ABC/.././DEF", "DEF");
+    // TooManyParentDirs, so resolved relative to the CWD
+    // All -> are examples of the result if the CWD was X:\ABC\DEF
+    try testToPrefixedFileOnlyOracle("..\\GHI"); // -> \??\X:\ABC\GHI
+    try testToPrefixedFileOnlyOracle("GHI\\..\\..\\.."); // -> \??\X:\
+
+    // UNC Absolute
+    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC\\DEF", "\\??\\UNC\\server\\share\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("\\\\server", "\\??\\UNC\\server");
+    try testToPrefixedFileWithOracle("\\\\server\\share", "\\??\\UNC\\server\\share");
+    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC. .", "\\??\\UNC\\server\\share\\ABC");
+    try testToPrefixedFileWithOracle("//server/share/ABC/DEF", "\\??\\UNC\\server\\share\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC\\..\\XYZ", "\\??\\UNC\\server\\share\\XYZ");
+    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC\\..\\..\\..", "\\??\\UNC\\server\\share");
+
+    // Local Device
+    try testToPrefixedFileWithOracle("\\\\.\\COM20", "\\??\\COM20");
+    try testToPrefixedFileWithOracle("\\\\.\\pipe\\mypipe", "\\??\\pipe\\mypipe");
+    try testToPrefixedFileWithOracle("\\\\.\\X:\\ABC\\DEF. .", "\\??\\X:\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("\\\\.\\X:/ABC/DEF", "\\??\\X:\\ABC\\DEF");
+    try testToPrefixedFileWithOracle("\\\\.\\X:\\ABC\\..\\XYZ", "\\??\\X:\\XYZ");
+    // Can replace the first component of the path (contrary to drive absolute and UNC absolute paths)
+    try testToPrefixedFileWithOracle("\\\\.\\X:\\ABC\\..\\..\\C:\\", "\\??\\C:\\");
+    try testToPrefixedFileWithOracle("\\\\.\\pipe\\mypipe\\..\\notmine", "\\??\\pipe\\notmine");
+
+    // Special-case device names
+    // TODO: Enable once these are supported
+    //       more cases to test here: https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
+    //try testToPrefixedFileWithOracle("COM1", "\\??\\COM1");
+    // Sometimes the special-cased device names are not respected
+    try testToPrefixedFileWithOracle("\\\\.\\X:\\COM1", "\\??\\X:\\COM1");
+    try testToPrefixedFileWithOracle("\\\\abc\\xyz\\COM1", "\\??\\UNC\\abc\\xyz\\COM1");
+
+    // Verbatim
+    // Left untouched except \\?\ is replaced by \??\
+    try testToPrefixedFileWithOracle("\\\\?\\X:", "\\??\\X:");
+    try testToPrefixedFileWithOracle("\\\\?\\X:\\COM1", "\\??\\X:\\COM1");
+    try testToPrefixedFileWithOracle("\\\\?\\X:/ABC/DEF. .", "\\??\\X:/ABC/DEF. .");
+    try testToPrefixedFileWithOracle("\\\\?\\X:\\ABC\\..\\..\\..", "\\??\\X:\\ABC\\..\\..\\..");
+    // NT Namespace
+    // Fully unmodified
+    try testToPrefixedFileWithOracle("\\??\\X:", "\\??\\X:");
+    try testToPrefixedFileWithOracle("\\??\\X:\\COM1", "\\??\\X:\\COM1");
+    try testToPrefixedFileWithOracle("\\??\\X:/ABC/DEF. .", "\\??\\X:/ABC/DEF. .");
+    try testToPrefixedFileWithOracle("\\??\\X:\\ABC\\..\\..\\..", "\\??\\X:\\ABC\\..\\..\\..");
+
+    // 'Fake' Verbatim
+    // If the prefix looks like the verbatim prefix but not all path separators in the
+    // prefix are backslashes, then it gets canonicalized and the prefix is dropped in favor
+    // of the NT prefix.
+    try testToPrefixedFileWithOracle("//?/C:/ABC", "\\??\\C:\\ABC");
+    // 'Fake' NT
+    // If the prefix looks like the NT prefix but not all path separators in the prefix
+    // are backslashes, then it gets canonicalized and the /??/ is not dropped but
+    // rather treated as part of the path. In other words, the path is treated
+    // as a rooted path, so the final path is resolved relative to the CWD's
+    // drive letter.
+    // The -> shows an example of the result if the CWD's drive letter was X
+    try testToPrefixedFileOnlyOracle("/??/C:/ABC"); // -> \??\X:\??\C:\ABC
+
+    // Root Local Device
+    // \\. and \\? always get converted to \??\
+    try testToPrefixedFileWithOracle("\\\\.", "\\??\\");
+    try testToPrefixedFileWithOracle("\\\\?", "\\??\\");
+    try testToPrefixedFileWithOracle("//?", "\\??\\");
+    try testToPrefixedFileWithOracle("//.", "\\??\\");
+}
+
+fn testRemoveDotDirs(str: []const u8, expected: []const u8) !void {
+    const mutable = try testing.allocator.dupe(u8, str);
+    defer testing.allocator.free(mutable);
+    const actual = mutable[0..try windows.removeDotDirsSanitized(u8, mutable)];
+    try testing.expect(std.mem.eql(u8, actual, expected));
+}
+fn testRemoveDotDirsError(err: anyerror, str: []const u8) !void {
+    const mutable = try testing.allocator.dupe(u8, str);
+    defer testing.allocator.free(mutable);
+    try testing.expectError(err, windows.removeDotDirsSanitized(u8, mutable));
+}
+test "removeDotDirs" {
+    try testRemoveDotDirs("", "");
+    try testRemoveDotDirs(".", "");
+    try testRemoveDotDirs(".\\", "");
+    try testRemoveDotDirs(".\\.", "");
+    try testRemoveDotDirs(".\\.\\", "");
+    try testRemoveDotDirs(".\\.\\.", "");
+
+    try testRemoveDotDirs("a", "a");
+    try testRemoveDotDirs("a\\", "a\\");
+    try testRemoveDotDirs("a\\b", "a\\b");
+    try testRemoveDotDirs("a\\.", "a\\");
+    try testRemoveDotDirs("a\\b\\.", "a\\b\\");
+    try testRemoveDotDirs("a\\.\\b", "a\\b");
+
+    try testRemoveDotDirs(".a", ".a");
+    try testRemoveDotDirs(".a\\", ".a\\");
+    try testRemoveDotDirs(".a\\.b", ".a\\.b");
+    try testRemoveDotDirs(".a\\.", ".a\\");
+    try testRemoveDotDirs(".a\\.\\.", ".a\\");
+    try testRemoveDotDirs(".a\\.\\.\\.b", ".a\\.b");
+    try testRemoveDotDirs(".a\\.\\.\\.b\\", ".a\\.b\\");
+
+    try testRemoveDotDirsError(error.TooManyParentDirs, "..");
+    try testRemoveDotDirsError(error.TooManyParentDirs, "..\\");
+    try testRemoveDotDirsError(error.TooManyParentDirs, ".\\..\\");
+    try testRemoveDotDirsError(error.TooManyParentDirs, ".\\.\\..\\");
+
+    try testRemoveDotDirs("a\\..", "");
+    try testRemoveDotDirs("a\\..\\", "");
+    try testRemoveDotDirs("a\\..\\.", "");
+    try testRemoveDotDirs("a\\..\\.\\", "");
+    try testRemoveDotDirs("a\\..\\.\\.", "");
+    try testRemoveDotDirsError(error.TooManyParentDirs, "a\\..\\.\\.\\..");
+
+    try testRemoveDotDirs("a\\..\\.\\.\\b", "b");
+    try testRemoveDotDirs("a\\..\\.\\.\\b\\", "b\\");
+    try testRemoveDotDirs("a\\..\\.\\.\\b\\.", "b\\");
+    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\", "b\\");
+    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\..", "");
+    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\..\\", "");
+    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\..\\.", "");
+    try testRemoveDotDirsError(error.TooManyParentDirs, "a\\..\\.\\.\\b\\.\\..\\.\\..");
+
+    try testRemoveDotDirs("a\\b\\..\\", "a\\");
+    try testRemoveDotDirs("a\\b\\..\\c", "a\\c");
+}
+
+const RTL_PATH_TYPE = enum(c_int) {
+    Unknown,
+    UncAbsolute,
+    DriveAbsolute,
+    DriveRelative,
+    Rooted,
+    Relative,
+    LocalDevice,
+    RootLocalDevice,
+};
+
+pub extern "ntdll" fn RtlDetermineDosPathNameType_U(
+    Path: [*:0]const u16,
+) callconv(.winapi) RTL_PATH_TYPE;
+
+test "getWin32PathType vs RtlDetermineDosPathNameType_U" {
+    if (builtin.os.tag != .windows) return error.SkipZigTest;
+
+    var buf: std.ArrayList(u16) = .empty;
+    defer buf.deinit(std.testing.allocator);
+
+    var wtf8_buf: std.ArrayList(u8) = .empty;
+    defer wtf8_buf.deinit(std.testing.allocator);
+
+    var random = std.Random.DefaultPrng.init(std.testing.random_seed);
+    const rand = random.random();
+
+    for (0..1000) |_| {
+        buf.clearRetainingCapacity();
+        const path = try getRandomWtf16Path(std.testing.allocator, &buf, rand);
+        wtf8_buf.clearRetainingCapacity();
+        const wtf8_len = std.unicode.calcWtf8Len(path);
+        try wtf8_buf.ensureTotalCapacity(std.testing.allocator, wtf8_len);
+        wtf8_buf.items.len = wtf8_len;
+        std.debug.assert(std.unicode.wtf16LeToWtf8(wtf8_buf.items, path) == wtf8_len);
+
+        const windows_type = RtlDetermineDosPathNameType_U(path);
+        const wtf16_type = std.fs.path.getWin32PathType(u16, path);
+        const wtf8_type = std.fs.path.getWin32PathType(u8, wtf8_buf.items);
+
+        checkPathType(windows_type, wtf16_type) catch |err| {
+            std.debug.print("expected type {}, got {} for path: {f}\n", .{ windows_type, wtf16_type, std.unicode.fmtUtf16Le(path) });
+            std.debug.print("path bytes:\n", .{});
+            std.debug.dumpHex(std.mem.sliceAsBytes(path));
+            return err;
+        };
+
+        if (wtf16_type != wtf8_type) {
+            std.debug.print("type mismatch between wtf8: {} and wtf16: {} for path: {f}\n", .{ wtf8_type, wtf16_type, std.unicode.fmtUtf16Le(path) });
+            std.debug.print("wtf-16 path bytes:\n", .{});
+            std.debug.dumpHex(std.mem.sliceAsBytes(path));
+            std.debug.print("wtf-8 path bytes:\n", .{});
+            std.debug.dumpHex(std.mem.sliceAsBytes(wtf8_buf.items));
+            return error.Wtf8Wtf16Mismatch;
+        }
+    }
+}
+
+fn checkPathType(windows_type: RTL_PATH_TYPE, zig_type: std.fs.path.Win32PathType) !void {
+    const expected_windows_type: RTL_PATH_TYPE = switch (zig_type) {
+        .unc_absolute => .UncAbsolute,
+        .drive_absolute => .DriveAbsolute,
+        .drive_relative => .DriveRelative,
+        .rooted => .Rooted,
+        .relative => .Relative,
+        .local_device => .LocalDevice,
+        .root_local_device => .RootLocalDevice,
+    };
+    if (windows_type != expected_windows_type) return error.PathTypeMismatch;
+}
+
+fn getRandomWtf16Path(allocator: std.mem.Allocator, buf: *std.ArrayList(u16), rand: std.Random) ![:0]const u16 {
+    const Choice = enum {
+        backslash,
+        slash,
+        control,
+        printable,
+        non_ascii,
+    };
+
+    const choices = rand.uintAtMostBiased(u16, 32);
+
+    for (0..choices) |_| {
+        const choice = rand.enumValue(Choice);
+        const code_unit = switch (choice) {
+            .backslash => '\\',
+            .slash => '/',
+            .control => switch (rand.uintAtMostBiased(u8, 0x20)) {
+                0x20 => '\x7F',
+                else => |b| b + 1, // no NUL
+            },
+            .printable => '!' + rand.uintAtMostBiased(u8, '~' - '!'),
+            .non_ascii => rand.intRangeAtMostBiased(u16, 0x80, 0xFFFF),
+        };
+        try buf.append(allocator, std.mem.nativeToLittle(u16, code_unit));
+    }
+
+    try buf.append(allocator, 0);
+    return buf.items[0 .. buf.items.len - 1 :0];
+}
diff --git a/lib/std/dynamic_library.zig b/lib/std/dynamic_library.zig
index 16a82c874bd05fdabf0c462f592e4e6d6930a4a9..d7cea3b3cd3699e4e0a4d5700b241fdc4656ac4e 100644
--- a/lib/std/dynamic_library.zig
+++ b/lib/std/dynamic_library.zig
@@ -17,7 +17,6 @@ pub const DynLib = struct {
             ElfDynLib
         else
             DlDynLib,
-        .windows => WindowsDynLib,
         .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos, .freebsd, .netbsd, .openbsd, .dragonfly, .illumos => DlDynLib,
         else => struct {
             const open = @compileError("unsupported platform");
@@ -27,7 +26,7 @@ pub const DynLib = struct {
 
     inner: InnerType,
 
-    pub const Error = ElfDynLibError || DlDynLibError || WindowsDynLibError;
+    pub const Error = ElfDynLibError || DlDynLibError;
 
     /// Trusts the file. Malicious file will be able to execute arbitrary code.
     pub fn open(path: []const u8) Error!DynLib {
@@ -558,73 +557,6 @@ test "ElfDynLib" {
     try testing.expectError(error.FileNotFound, ElfDynLib.openZ("invalid_so.so", null));
 }
 
-/// Separated to avoid referencing `WindowsDynLib`, because its field types may not
-/// be valid on other targets.
-const WindowsDynLibError = error{
-    FileNotFound,
-    InvalidPath,
-} || windows.LoadLibraryError;
-
-pub const WindowsDynLib = struct {
-    pub const Error = WindowsDynLibError;
-
-    dll: windows.HMODULE,
-
-    pub fn open(path: []const u8) Error!WindowsDynLib {
-        return openEx(path, .none);
-    }
-
-    /// WindowsDynLib specific
-    /// Opens dynamic library with specified library loading flags.
-    pub fn openEx(path: []const u8, flags: windows.LoadLibraryFlags) Error!WindowsDynLib {
-        const path_w = windows.sliceToPrefixedFileW(null, path) catch return error.InvalidPath;
-        return openExW(path_w.span().ptr, flags);
-    }
-
-    pub fn openZ(path_c: [*:0]const u8) Error!WindowsDynLib {
-        return openExZ(path_c, .none);
-    }
-
-    /// WindowsDynLib specific
-    /// Opens dynamic library with specified library loading flags.
-    pub fn openExZ(path_c: [*:0]const u8, flags: windows.LoadLibraryFlags) Error!WindowsDynLib {
-        const path_w = windows.cStrToPrefixedFileW(null, path_c) catch return error.InvalidPath;
-        return openExW(path_w.span().ptr, flags);
-    }
-
-    /// WindowsDynLib specific
-    pub fn openW(path_w: [*:0]const u16) Error!WindowsDynLib {
-        return openExW(path_w, .none);
-    }
-
-    /// WindowsDynLib specific
-    /// Opens dynamic library with specified library loading flags.
-    pub fn openExW(path_w: [*:0]const u16, flags: windows.LoadLibraryFlags) Error!WindowsDynLib {
-        var offset: usize = 0;
-        if (path_w[0] == '\\' and path_w[1] == '?' and path_w[2] == '?' and path_w[3] == '\\') {
-            // + 4 to skip over the \??\
-            offset = 4;
-        }
-
-        return .{
-            .dll = try windows.LoadLibraryExW(path_w + offset, flags),
-        };
-    }
-
-    pub fn close(self: *WindowsDynLib) void {
-        windows.FreeLibrary(self.dll);
-        self.* = undefined;
-    }
-
-    pub fn lookup(self: *WindowsDynLib, comptime T: type, name: [:0]const u8) ?T {
-        if (windows.kernel32.GetProcAddress(self.dll, name.ptr)) |addr| {
-            return @as(T, @ptrCast(@alignCast(addr)));
-        } else {
-            return null;
-        }
-    }
-};
-
 /// Separated to avoid referencing `DlDynLib`, because its field types may not
 /// be valid on other targets.
 const DlDynLibError = error{ FileNotFound, NameTooLong };
@@ -676,7 +608,6 @@ pub const DlDynLib = struct {
 test "dynamic_library" {
     const libname = switch (native_os) {
         .linux, .freebsd, .openbsd, .illumos => "invalid_so.so",
-        .windows => "invalid_dll.dll",
         .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => "invalid_dylib.dylib",
         else => return error.SkipZigTest,
     };
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index dcb9087f136c664b9133e03c0b71458ddd8ed9c3..ac36e77ac35d75e52fe356ba6139e2c864160039 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -15,12 +15,6 @@ const math = std.math;
 const maxInt = std.math.maxInt;
 const UnexpectedError = std.posix.UnexpectedError;
 
-test {
-    if (builtin.os.tag == .windows) {
-        _ = @import("windows/test.zig");
-    }
-}
-
 pub const advapi32 = @import("windows/advapi32.zig");
 pub const kernel32 = @import("windows/kernel32.zig");
 pub const ntdll = @import("windows/ntdll.zig");
@@ -2670,324 +2664,6 @@ pub fn CloseHandle(hObject: HANDLE) void {
     assert(ntdll.NtClose(hObject) == .SUCCESS);
 }
 
-pub const QueryObjectNameError = error{
-    AccessDenied,
-    InvalidHandle,
-    NameTooLong,
-    Unexpected,
-};
-
-pub fn QueryObjectName(handle: HANDLE, out_buffer: []u16) QueryObjectNameError![]u16 {
-    const out_buffer_aligned = mem.alignInSlice(out_buffer, @alignOf(OBJECT_NAME_INFORMATION)) orelse return error.NameTooLong;
-
-    const info = @as(*OBJECT_NAME_INFORMATION, @ptrCast(out_buffer_aligned));
-    // buffer size is specified in bytes
-    const out_buffer_len = std.math.cast(ULONG, out_buffer_aligned.len * 2) orelse maxInt(ULONG);
-    // last argument would return the length required for full_buffer, not exposed here
-    return switch (ntdll.NtQueryObject(handle, .ObjectNameInformation, info, out_buffer_len, null)) {
-        .SUCCESS => blk: {
-            // info.Name.Buffer from ObQueryNameString is documented to be null (and MaximumLength == 0)
-            // if the object was "unnamed", not sure if this can happen for file handles
-            if (info.Name.MaximumLength == 0) break :blk error.Unexpected;
-            // resulting string length is specified in bytes
-            const path_length_unterminated = @divExact(info.Name.Length, 2);
-            break :blk info.Name.Buffer.?[0..path_length_unterminated];
-        },
-        .ACCESS_DENIED => error.AccessDenied,
-        .INVALID_HANDLE => error.InvalidHandle,
-        // triggered when the buffer is too small for the OBJECT_NAME_INFORMATION object (.INFO_LENGTH_MISMATCH),
-        // or if the buffer is too small for the file path returned (.BUFFER_OVERFLOW, .BUFFER_TOO_SMALL)
-        .INFO_LENGTH_MISMATCH, .BUFFER_OVERFLOW, .BUFFER_TOO_SMALL => error.NameTooLong,
-        else => |e| unexpectedStatus(e),
-    };
-}
-
-test QueryObjectName {
-    if (builtin.os.tag != .windows)
-        return;
-
-    //any file will do; canonicalization works on NTFS junctions and symlinks, hardlinks remain separate paths.
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-    const handle = tmp.dir.handle;
-    var out_buffer: [PATH_MAX_WIDE]u16 = undefined;
-
-    const result_path = try QueryObjectName(handle, &out_buffer);
-    const required_len_in_u16 = result_path.len + @divExact(@intFromPtr(result_path.ptr) - @intFromPtr(&out_buffer), 2) + 1;
-    //insufficient size
-    try std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1]));
-    //exactly-sufficient size
-    _ = try QueryObjectName(handle, out_buffer[0..required_len_in_u16]);
-}
-
-pub const GetFinalPathNameByHandleError = error{
-    AccessDenied,
-    FileNotFound,
-    NameTooLong,
-    /// The volume does not contain a recognized file system. File system
-    /// drivers might not be loaded, or the volume may be corrupt.
-    UnrecognizedVolume,
-    Unexpected,
-};
-
-/// Specifies how to format volume path in the result of `GetFinalPathNameByHandle`.
-/// Defaults to DOS volume names.
-pub const GetFinalPathNameByHandleFormat = struct {
-    volume_name: enum {
-        /// Format as DOS volume name
-        Dos,
-        /// Format as NT volume name
-        Nt,
-    } = .Dos,
-};
-
-/// Returns canonical (normalized) path of handle.
-/// Use `GetFinalPathNameByHandleFormat` to specify whether the path is meant to include
-/// NT or DOS volume name (e.g., `\Device\HarddiskVolume0\foo.txt` versus `C:\foo.txt`).
-/// If DOS volume name format is selected, note that this function does *not* prepend
-/// `\\?\` prefix to the resultant path.
-///
-/// TODO move this function into std.Io.Threaded and add cancelation checks
-pub fn GetFinalPathNameByHandle(
-    hFile: HANDLE,
-    fmt: GetFinalPathNameByHandleFormat,
-    out_buffer: []u16,
-) GetFinalPathNameByHandleError![]u16 {
-    const final_path = QueryObjectName(hFile, out_buffer) catch |err| switch (err) {
-        // we assume InvalidHandle is close enough to FileNotFound in semantics
-        // to not further complicate the error set
-        error.InvalidHandle => return error.FileNotFound,
-        else => |e| return e,
-    };
-
-    switch (fmt.volume_name) {
-        .Nt => {
-            // the returned path is already in .Nt format
-            return final_path;
-        },
-        .Dos => {
-            // parse the string to separate volume path from file path
-            const device_prefix = std.unicode.utf8ToUtf16LeStringLiteral("\\Device\\");
-
-            // We aren't entirely sure of the structure of the path returned by
-            // QueryObjectName in all contexts/environments.
-            // This code is written to cover the various cases that have
-            // been encountered and solved appropriately. But note that there's
-            // no easy way to verify that they have all been tackled!
-            // (Unless you, the reader knows of one then please do action that!)
-            if (!mem.startsWith(u16, final_path, device_prefix)) {
-                // Wine seems to return NT namespaced paths starting with \??\ from QueryObjectName
-                // (e.g. `\??\Z:\some\path\to\a\file.txt`), in which case we can just strip the
-                // prefix to turn it into an absolute path.
-                // https://github.com/ziglang/zig/issues/26029
-                // https://bugs.winehq.org/show_bug.cgi?id=39569
-                return ntToWin32Namespace(final_path, out_buffer) catch |err| switch (err) {
-                    error.NotNtPath => return error.Unexpected,
-                    error.NameTooLong => |e| return e,
-                };
-            }
-
-            const file_path_begin_index = mem.findPos(u16, final_path, device_prefix.len, &[_]u16{'\\'}) orelse unreachable;
-            const volume_name_u16 = final_path[0..file_path_begin_index];
-            const device_name_u16 = volume_name_u16[device_prefix.len..];
-            const file_name_u16 = final_path[file_path_begin_index..];
-
-            // MUP is Multiple UNC Provider, and indicates that the path is a UNC
-            // path. In this case, the canonical UNC path can be gotten by just
-            // dropping the \Device\Mup\ and making sure the path begins with \\
-            if (mem.eql(u16, device_name_u16, std.unicode.utf8ToUtf16LeStringLiteral("Mup"))) {
-                out_buffer[0] = '\\';
-                @memmove(out_buffer[1..][0..file_name_u16.len], file_name_u16);
-                return out_buffer[0 .. 1 + file_name_u16.len];
-            }
-
-            // Get DOS volume name. DOS volume names are actually symbolic link objects to the
-            // actual NT volume. For example:
-            // (NT) \Device\HarddiskVolume4 => (DOS) \DosDevices\C: == (DOS) C:
-            const MIN_SIZE = @sizeOf(MOUNTMGR_MOUNT_POINT) + MAX_PATH;
-            // We initialize the input buffer to all zeros for convenience since
-            // `DeviceIoControl` with `IOCTL_MOUNTMGR_QUERY_POINTS` expects this.
-            var input_buf: [MIN_SIZE]u8 align(@alignOf(MOUNTMGR_MOUNT_POINT)) = [_]u8{0} ** MIN_SIZE;
-            var output_buf: [MIN_SIZE * 4]u8 align(@alignOf(MOUNTMGR_MOUNT_POINTS)) = undefined;
-
-            // This surprising path is a filesystem path to the mount manager on Windows.
-            // Source: https://stackoverflow.com/questions/3012828/using-ioctl-mountmgr-query-points
-            // This is the NT namespaced version of \\.\MountPointManager
-            const mgmt_path_u16 = std.unicode.utf8ToUtf16LeStringLiteral("\\??\\MountPointManager");
-            const mgmt_handle = OpenFile(mgmt_path_u16, .{
-                .access_mask = .{ .STANDARD = .{ .SYNCHRONIZE = true } },
-                .creation = .OPEN,
-            }) catch |err| switch (err) {
-                error.IsDir => return error.Unexpected,
-                error.NotDir => return error.Unexpected,
-                error.NoDevice => return error.Unexpected,
-                error.AccessDenied => return error.Unexpected,
-                error.PipeBusy => return error.Unexpected,
-                error.PathAlreadyExists => return error.Unexpected,
-                error.WouldBlock => return error.Unexpected,
-                error.NetworkNotFound => return error.Unexpected,
-                error.AntivirusInterference => return error.Unexpected,
-                error.BadPathName => return error.Unexpected,
-                error.OperationCanceled => @panic("TODO: better integrate cancelation"),
-                else => |e| return e,
-            };
-            defer CloseHandle(mgmt_handle);
-
-            var input_struct: *MOUNTMGR_MOUNT_POINT = @ptrCast(&input_buf[0]);
-            input_struct.DeviceNameOffset = @sizeOf(MOUNTMGR_MOUNT_POINT);
-            input_struct.DeviceNameLength = @intCast(volume_name_u16.len * 2);
-            @memcpy(input_buf[@sizeOf(MOUNTMGR_MOUNT_POINT)..][0 .. volume_name_u16.len * 2], @as([*]const u8, @ptrCast(volume_name_u16.ptr)));
-
-            {
-                const rc = DeviceIoControl(mgmt_handle, IOCTL.MOUNTMGR.QUERY_POINTS, .{ .in = &input_buf, .out = &output_buf });
-                switch (rc) {
-                    .SUCCESS => {},
-                    .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
-                    else => return unexpectedStatus(rc),
-                }
-            }
-            const mount_points_struct: *const MOUNTMGR_MOUNT_POINTS = @ptrCast(&output_buf[0]);
-
-            const mount_points = @as(
-                [*]const MOUNTMGR_MOUNT_POINT,
-                @ptrCast(&mount_points_struct.MountPoints[0]),
-            )[0..mount_points_struct.NumberOfMountPoints];
-
-            for (mount_points) |mount_point| {
-                const symlink = @as(
-                    [*]const u16,
-                    @ptrCast(@alignCast(&output_buf[mount_point.SymbolicLinkNameOffset])),
-                )[0 .. mount_point.SymbolicLinkNameLength / 2];
-
-                // Look for `\DosDevices\` prefix. We don't really care if there are more than one symlinks
-                // with traditional DOS drive letters, so pick the first one available.
-                var prefix_buf = std.unicode.utf8ToUtf16LeStringLiteral("\\DosDevices\\");
-                const prefix = prefix_buf[0..prefix_buf.len];
-
-                if (mem.startsWith(u16, symlink, prefix)) {
-                    const drive_letter = symlink[prefix.len..];
-
-                    if (out_buffer.len < drive_letter.len + file_name_u16.len) return error.NameTooLong;
-
-                    @memcpy(out_buffer[0..drive_letter.len], drive_letter);
-                    @memmove(out_buffer[drive_letter.len..][0..file_name_u16.len], file_name_u16);
-                    const total_len = drive_letter.len + file_name_u16.len;
-
-                    // Validate that DOS does not contain any spurious nul bytes.
-                    assert(mem.findScalar(u16, out_buffer[0..total_len], 0) == null);
-
-                    return out_buffer[0..total_len];
-                } else if (mountmgrIsVolumeName(symlink)) {
-                    // If the symlink is a volume GUID like \??\Volume{383da0b0-717f-41b6-8c36-00500992b58d},
-                    // then it is a volume mounted as a path rather than a drive letter. We need to
-                    // query the mount manager again to get the DOS path for the volume.
-
-                    // 49 is the maximum length accepted by mountmgrIsVolumeName
-                    const vol_input_size = @sizeOf(MOUNTMGR_TARGET_NAME) + (49 * 2);
-                    var vol_input_buf: [vol_input_size]u8 align(@alignOf(MOUNTMGR_TARGET_NAME)) = [_]u8{0} ** vol_input_size;
-                    // Note: If the path exceeds MAX_PATH, the Disk Management GUI doesn't accept the full path,
-                    // and instead if must be specified using a shortened form (e.g. C:\FOO~1\BAR~1\<...>).
-                    // However, just to be sure we can handle any path length, we use PATH_MAX_WIDE here.
-                    const min_output_size = @sizeOf(MOUNTMGR_VOLUME_PATHS) + (PATH_MAX_WIDE * 2);
-                    var vol_output_buf: [min_output_size]u8 align(@alignOf(MOUNTMGR_VOLUME_PATHS)) = undefined;
-
-                    var vol_input_struct: *MOUNTMGR_TARGET_NAME = @ptrCast(&vol_input_buf[0]);
-                    vol_input_struct.DeviceNameLength = @intCast(symlink.len * 2);
-                    @memcpy(@as([*]WCHAR, &vol_input_struct.DeviceName)[0..symlink.len], symlink);
-
-                    const rc = DeviceIoControl(mgmt_handle, IOCTL.MOUNTMGR.QUERY_DOS_VOLUME_PATH, .{ .in = &vol_input_buf, .out = &vol_output_buf });
-                    switch (rc) {
-                        .SUCCESS => {},
-                        .UNRECOGNIZED_VOLUME => return error.UnrecognizedVolume,
-                        else => return unexpectedStatus(rc),
-                    }
-                    const volume_paths_struct: *const MOUNTMGR_VOLUME_PATHS = @ptrCast(&vol_output_buf[0]);
-                    const volume_path = std.mem.sliceTo(@as(
-                        [*]const u16,
-                        &volume_paths_struct.MultiSz,
-                    )[0 .. volume_paths_struct.MultiSzLength / 2], 0);
-
-                    if (out_buffer.len < volume_path.len + file_name_u16.len) return error.NameTooLong;
-
-                    // `out_buffer` currently contains the memory of `file_name_u16`, so it can overlap with where
-                    // we want to place the filename before returning. Here are the possible overlapping cases:
-                    //
-                    // out_buffer:       [filename]
-                    //       dest: [___(a)___] [___(b)___]
-                    //
-                    // In the case of (a), we need to copy forwards, and in the case of (b) we need
-                    // to copy backwards. We also need to do this before copying the volume path because
-                    // it could overwrite the file_name_u16 memory.
-                    const file_name_dest = out_buffer[volume_path.len..][0..file_name_u16.len];
-                    @memmove(file_name_dest, file_name_u16);
-                    @memcpy(out_buffer[0..volume_path.len], volume_path);
-                    const total_len = volume_path.len + file_name_u16.len;
-
-                    // Validate that DOS does not contain any spurious nul bytes.
-                    assert(mem.findScalar(u16, out_buffer[0..total_len], 0) == null);
-
-                    return out_buffer[0..total_len];
-                }
-            }
-
-            // If we've ended up here, then something went wrong/is corrupted in the OS,
-            // so error out!
-            return error.FileNotFound;
-        },
-    }
-}
-
-/// Equivalent to the MOUNTMGR_IS_VOLUME_NAME macro in mountmgr.h
-fn mountmgrIsVolumeName(name: []const u16) bool {
-    return (name.len == 48 or (name.len == 49 and name[48] == mem.nativeToLittle(u16, '\\'))) and
-        name[0] == mem.nativeToLittle(u16, '\\') and
-        (name[1] == mem.nativeToLittle(u16, '?') or name[1] == mem.nativeToLittle(u16, '\\')) and
-        name[2] == mem.nativeToLittle(u16, '?') and
-        name[3] == mem.nativeToLittle(u16, '\\') and
-        mem.startsWith(u16, name[4..], std.unicode.utf8ToUtf16LeStringLiteral("Volume{")) and
-        name[19] == mem.nativeToLittle(u16, '-') and
-        name[24] == mem.nativeToLittle(u16, '-') and
-        name[29] == mem.nativeToLittle(u16, '-') and
-        name[34] == mem.nativeToLittle(u16, '-') and
-        name[47] == mem.nativeToLittle(u16, '}');
-}
-
-test mountmgrIsVolumeName {
-    @setEvalBranchQuota(2000);
-    const L = std.unicode.utf8ToUtf16LeStringLiteral;
-    try std.testing.expect(mountmgrIsVolumeName(L("\\\\?\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
-    try std.testing.expect(mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
-    try std.testing.expect(mountmgrIsVolumeName(L("\\\\?\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\")));
-    try std.testing.expect(mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\")));
-    try std.testing.expect(!mountmgrIsVolumeName(L("\\\\.\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}")));
-    try std.testing.expect(!mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58d}\\foo")));
-    try std.testing.expect(!mountmgrIsVolumeName(L("\\??\\Volume{383da0b0-717f-41b6-8c36-00500992b58}")));
-}
-
-test GetFinalPathNameByHandle {
-    if (builtin.os.tag != .windows)
-        return;
-
-    //any file will do
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-    const handle = tmp.dir.handle;
-    var buffer: [PATH_MAX_WIDE]u16 = undefined;
-
-    //check with sufficient size
-    const nt_path = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, &buffer);
-    _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, &buffer);
-
-    const required_len_in_u16 = nt_path.len + @divExact(@intFromPtr(nt_path.ptr) - @intFromPtr(&buffer), 2) + 1;
-    //check with insufficient size
-    try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1]));
-    try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1]));
-
-    //check with exactly-sufficient size
-    _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0..required_len_in_u16]);
-    _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0..required_len_in_u16]);
-}
-
 pub fn getpeername(s: ws2_32.SOCKET, name: *ws2_32.sockaddr, namelen: *ws2_32.socklen_t) i32 {
     return ws2_32.getpeername(s, name, @as(*i32, @ptrCast(namelen)));
 }
@@ -3419,15 +3095,6 @@ test "eqlIgnoreCaseWtf16/Wtf8" {
     try testEqlIgnoreCase(false, "𐓏", "𐓷");
 }
 
-pub const PathSpace = struct {
-    data: [PATH_MAX_WIDE:0]u16,
-    len: usize,
-
-    pub fn span(self: *const PathSpace) [:0]const u16 {
-        return self.data[0..self.len :0];
-    }
-};
-
 /// The error type for `removeDotDirsSanitized`
 pub const RemoveDotDirsError = error{TooManyParentDirs};
 
@@ -3503,205 +3170,6 @@ pub fn normalizePath(comptime T: type, path: []T) RemoveDotDirsError!usize {
     return prefix_len + try removeDotDirsSanitized(T, path[prefix_len..new_len]);
 }
 
-pub const Wtf8ToPrefixedFileWError = Wtf16ToPrefixedFileWError;
-
-/// Same as `sliceToPrefixedFileW` but accepts a pointer
-/// to a null-terminated WTF-8 encoded path.
-/// https://wtf-8.codeberg.page/
-pub fn cStrToPrefixedFileW(dir: ?HANDLE, s: [*:0]const u8) Wtf8ToPrefixedFileWError!PathSpace {
-    return sliceToPrefixedFileW(dir, mem.sliceTo(s, 0));
-}
-
-/// Same as `wToPrefixedFileW` but accepts a WTF-8 encoded path.
-/// https://wtf-8.codeberg.page/
-pub fn sliceToPrefixedFileW(dir: ?HANDLE, path: []const u8) Wtf8ToPrefixedFileWError!PathSpace {
-    var temp_path: PathSpace = undefined;
-    temp_path.len = std.unicode.wtf8ToWtf16Le(&temp_path.data, path) catch |err| switch (err) {
-        error.InvalidWtf8 => return error.BadPathName,
-    };
-    temp_path.data[temp_path.len] = 0;
-    return wToPrefixedFileW(dir, temp_path.span());
-}
-
-pub const Wtf16ToPrefixedFileWError = error{
-    AccessDenied,
-    BadPathName,
-    FileNotFound,
-    NameTooLong,
-    Unexpected,
-};
-
-/// Converts the `path` to WTF16, null-terminated. If the path contains any
-/// namespace prefix, or is anything but a relative path (rooted, drive relative,
-/// etc) the result will have the NT-style prefix `\??\`.
-///
-/// Similar to RtlDosPathNameToNtPathName_U with a few differences:
-/// - Does not allocate on the heap.
-/// - Relative paths are kept as relative unless they contain too many ..
-///   components, in which case they are resolved against the `dir` if it
-///   is non-null, or the CWD if it is null.
-/// - Special case device names like COM1, NUL, etc are not handled specially (TODO)
-/// - . and space are not stripped from the end of relative paths (potential TODO)
-pub fn wToPrefixedFileW(dir: ?HANDLE, path: [:0]const u16) Wtf16ToPrefixedFileWError!PathSpace {
-    const nt_prefix = [_]u16{ '\\', '?', '?', '\\' };
-    if (hasCommonNtPrefix(u16, path)) {
-        // TODO: Figure out a way to design an API that can avoid the copy for NT,
-        //       since it is always returned fully unmodified.
-        var path_space: PathSpace = undefined;
-        path_space.data[0..nt_prefix.len].* = nt_prefix;
-        const len_after_prefix = path.len - nt_prefix.len;
-        @memcpy(path_space.data[nt_prefix.len..][0..len_after_prefix], path[nt_prefix.len..]);
-        path_space.len = path.len;
-        path_space.data[path_space.len] = 0;
-        return path_space;
-    } else {
-        const path_type = std.fs.path.getWin32PathType(u16, path);
-        var path_space: PathSpace = undefined;
-        if (path_type == .local_device) {
-            switch (getLocalDevicePathType(u16, path)) {
-                .verbatim => {
-                    path_space.data[0..nt_prefix.len].* = nt_prefix;
-                    const len_after_prefix = path.len - nt_prefix.len;
-                    @memcpy(path_space.data[nt_prefix.len..][0..len_after_prefix], path[nt_prefix.len..]);
-                    path_space.len = path.len;
-                    path_space.data[path_space.len] = 0;
-                    return path_space;
-                },
-                .local_device, .fake_verbatim => {
-                    const path_byte_len = ntdll.RtlGetFullPathName_U(
-                        path.ptr,
-                        path_space.data.len * 2,
-                        &path_space.data,
-                        null,
-                    );
-                    if (path_byte_len == 0) {
-                        // TODO: This may not be the right error
-                        return error.BadPathName;
-                    } else if (path_byte_len / 2 > path_space.data.len) {
-                        return error.NameTooLong;
-                    }
-                    path_space.len = path_byte_len / 2;
-                    // Both prefixes will be normalized but retained, so all
-                    // we need to do now is replace them with the NT prefix
-                    path_space.data[0..nt_prefix.len].* = nt_prefix;
-                    return path_space;
-                },
-            }
-        }
-        relative: {
-            if (path_type == .relative) {
-                // TODO: Handle special case device names like COM1, AUX, NUL, CONIN$, CONOUT$, etc.
-                //       See https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
-
-                // TODO: Potentially strip all trailing . and space characters from the
-                //       end of the path. This is something that both RtlDosPathNameToNtPathName_U
-                //       and RtlGetFullPathName_U do. Technically, trailing . and spaces
-                //       are allowed, but such paths may not interact well with Windows (i.e.
-                //       files with these paths can't be deleted from explorer.exe, etc).
-                //       This could be something that normalizePath may want to do.
-
-                @memcpy(path_space.data[0..path.len], path);
-                // Try to normalize, but if we get too many parent directories,
-                // then we need to start over and use RtlGetFullPathName_U instead.
-                path_space.len = normalizePath(u16, path_space.data[0..path.len]) catch |err| switch (err) {
-                    error.TooManyParentDirs => break :relative,
-                };
-                path_space.data[path_space.len] = 0;
-                return path_space;
-            }
-        }
-        // We now know we are going to return an absolute NT path, so
-        // we can unconditionally prefix it with the NT prefix.
-        path_space.data[0..nt_prefix.len].* = nt_prefix;
-        if (path_type == .root_local_device) {
-            // `\\.` and `\\?` always get converted to `\??\` exactly, so
-            // we can just stop here
-            path_space.len = nt_prefix.len;
-            path_space.data[path_space.len] = 0;
-            return path_space;
-        }
-        const path_buf_offset = switch (path_type) {
-            // UNC paths will always start with `\\`. However, we want to
-            // end up with something like `\??\UNC\server\share`, so to get
-            // RtlGetFullPathName to write into the spot we want the `server`
-            // part to end up, we need to provide an offset such that
-            // the `\\` part gets written where the `C\` of `UNC\` will be
-            // in the final NT path.
-            .unc_absolute => nt_prefix.len + 2,
-            else => nt_prefix.len,
-        };
-        const buf_len: u32 = @intCast(path_space.data.len - path_buf_offset);
-        const path_to_get: [:0]const u16 = path_to_get: {
-            // If dir is null, then we don't need to bother with GetFinalPathNameByHandle because
-            // RtlGetFullPathName_U will resolve relative paths against the CWD for us.
-            if (path_type != .relative or dir == null) {
-                break :path_to_get path;
-            }
-            // We can also skip GetFinalPathNameByHandle if the handle matches
-            // the handle returned by Io.Dir.cwd()
-            if (dir.? == Io.Dir.cwd().handle) {
-                break :path_to_get path;
-            }
-            // At this point, we know we have a relative path that had too many
-            // `..` components to be resolved by normalizePath, so we need to
-            // convert it into an absolute path and let RtlGetFullPathName_U
-            // canonicalize it. We do this by getting the path of the `dir`
-            // and appending the relative path to it.
-            var dir_path_buf: [PATH_MAX_WIDE:0]u16 = undefined;
-            const dir_path = GetFinalPathNameByHandle(dir.?, .{}, &dir_path_buf) catch |err| switch (err) {
-                // This mapping is not correct; it is actually expected
-                // that calling GetFinalPathNameByHandle might return
-                // error.UnrecognizedVolume, and in fact has been observed
-                // in the wild. The problem is that wToPrefixedFileW was
-                // never intended to make *any* OS syscall APIs. It's only
-                // supposed to convert a string to one that is eligible to
-                // be used in the ntdll syscalls.
-                //
-                // To solve this, this function needs to no longer call
-                // GetFinalPathNameByHandle under any conditions, or the
-                // calling function needs to get reworked to not need to
-                // call this function.
-                //
-                // This may involve making breaking API changes.
-                error.UnrecognizedVolume => return error.Unexpected,
-                else => |e| return e,
-            };
-            if (dir_path.len + 1 + path.len > PATH_MAX_WIDE) {
-                return error.NameTooLong;
-            }
-            // We don't have to worry about potentially doubling up path separators
-            // here since RtlGetFullPathName_U will handle canonicalizing it.
-            dir_path_buf[dir_path.len] = '\\';
-            @memcpy(dir_path_buf[dir_path.len + 1 ..][0..path.len], path);
-            const full_len = dir_path.len + 1 + path.len;
-            dir_path_buf[full_len] = 0;
-            break :path_to_get dir_path_buf[0..full_len :0];
-        };
-        const path_byte_len = ntdll.RtlGetFullPathName_U(
-            path_to_get.ptr,
-            buf_len * 2,
-            path_space.data[path_buf_offset..].ptr,
-            null,
-        );
-        if (path_byte_len == 0) {
-            // TODO: This may not be the right error
-            return error.BadPathName;
-        } else if (path_byte_len / 2 > buf_len) {
-            return error.NameTooLong;
-        }
-        path_space.len = path_buf_offset + (path_byte_len / 2);
-        if (path_type == .unc_absolute) {
-            // Now add in the UNC, the `C` should overwrite the first `\` of the
-            // FullPathName, ultimately resulting in `\??\UNC\<the rest of the path>`
-            assert(path_space.data[path_buf_offset] == '\\');
-            assert(path_space.data[path_buf_offset + 1] == '\\');
-            const unc = [_]u16{ 'U', 'N', 'C' };
-            path_space.data[nt_prefix.len..][0..unc.len].* = unc;
-        }
-        return path_space;
-    }
-}
-
 /// Returns true if the path starts with `\??\`, which is indicative of an NT path
 /// but is not enough to fully distinguish between NT paths and Win32 paths, as
 /// `\??\` is not actually a distinct prefix but rather the path to a special virtual
@@ -3725,39 +3193,6 @@ pub fn hasCommonNtPrefix(comptime T: type, path: []const T) bool {
     return mem.startsWith(T, path, expected_prefix);
 }
 
-const LocalDevicePathType = enum {
-    /// `\\.\` (path separators can be `\` or `/`)
-    local_device,
-    /// `\\?\`
-    /// When converted to an NT path, everything past the prefix is left
-    /// untouched and `\\?\` is replaced by `\??\`.
-    verbatim,
-    /// `\\?\` without all path separators being `\`.
-    /// This seems to be recognized as a prefix, but the 'verbatim' aspect
-    /// is not respected (i.e. if `//?/C:/foo` is converted to an NT path,
-    /// it will become `\??\C:\foo` [it will be canonicalized and the //?/ won't
-    /// be treated as part of the final path])
-    fake_verbatim,
-};
-
-/// Only relevant for Win32 -> NT path conversion.
-/// Asserts `path` is of type `std.fs.path.Win32PathType.local_device`.
-fn getLocalDevicePathType(comptime T: type, path: []const T) LocalDevicePathType {
-    if (std.debug.runtime_safety) {
-        assert(std.fs.path.getWin32PathType(T, path) == .local_device);
-    }
-
-    const backslash = mem.nativeToLittle(T, '\\');
-    const all_backslash = path[0] == backslash and
-        path[1] == backslash and
-        path[3] == backslash;
-    return switch (path[2]) {
-        mem.nativeToLittle(T, '?') => if (all_backslash) .verbatim else .fake_verbatim,
-        mem.nativeToLittle(T, '.') => .local_device,
-        else => unreachable,
-    };
-}
-
 /// Similar to `RtlNtPathNameToDosPathName` but does not do any heap allocation.
 /// The possible transformations are:
 ///   \??\C:\Some\Path -> C:\Some\Path
diff --git a/lib/std/os/windows/test.zig b/lib/std/os/windows/test.zig
deleted file mode 100644
index 58eb4e0b97645bf59699d0b3939a4deb1bda0d73..0000000000000000000000000000000000000000
--- a/lib/std/os/windows/test.zig
+++ /dev/null
@@ -1,339 +0,0 @@
-const std = @import("../../std.zig");
-const builtin = @import("builtin");
-const windows = std.os.windows;
-const mem = std.mem;
-const testing = std.testing;
-
-/// Wrapper around RtlDosPathNameToNtPathName_U for use in comparing
-/// the behavior of RtlDosPathNameToNtPathName_U with wToPrefixedFileW
-/// Note: RtlDosPathNameToNtPathName_U is not used in the Zig implementation
-//        because it allocates.
-fn RtlDosPathNameToNtPathName_U(path: [:0]const u16) !windows.PathSpace {
-    var out: windows.UNICODE_STRING = undefined;
-    const rc = windows.ntdll.RtlDosPathNameToNtPathName_U(path, &out, null, null);
-    if (rc != windows.TRUE) return error.BadPathName;
-    defer windows.ntdll.RtlFreeUnicodeString(&out);
-
-    var path_space: windows.PathSpace = undefined;
-    const out_path = out.Buffer.?[0 .. out.Length / 2];
-    @memcpy(path_space.data[0..out_path.len], out_path);
-    path_space.len = out.Length / 2;
-    path_space.data[path_space.len] = 0;
-
-    return path_space;
-}
-
-/// Test that the Zig conversion matches the expected_path (for instances where
-/// the Zig implementation intentionally diverges from what RtlDosPathNameToNtPathName_U does).
-fn testToPrefixedFileNoOracle(comptime path: []const u8, comptime expected_path: []const u8) !void {
-    const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);
-    const expected_path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(expected_path);
-    const actual_path = try windows.wToPrefixedFileW(null, path_utf16);
-    std.testing.expectEqualSlices(u16, expected_path_utf16, actual_path.span()) catch |e| {
-        std.debug.print("got '{f}', expected '{f}'\n", .{ std.unicode.fmtUtf16Le(actual_path.span()), std.unicode.fmtUtf16Le(expected_path_utf16) });
-        return e;
-    };
-}
-
-/// Test that the Zig conversion matches the expected_path and that the
-/// expected_path matches the conversion that RtlDosPathNameToNtPathName_U does.
-fn testToPrefixedFileWithOracle(comptime path: []const u8, comptime expected_path: []const u8) !void {
-    try testToPrefixedFileNoOracle(path, expected_path);
-    try testToPrefixedFileOnlyOracle(path);
-}
-
-/// Test that the Zig conversion matches the conversion that RtlDosPathNameToNtPathName_U does.
-fn testToPrefixedFileOnlyOracle(comptime path: []const u8) !void {
-    const path_utf16 = std.unicode.utf8ToUtf16LeStringLiteral(path);
-    const zig_result = try windows.wToPrefixedFileW(null, path_utf16);
-    const win32_api_result = try RtlDosPathNameToNtPathName_U(path_utf16);
-    std.testing.expectEqualSlices(u16, win32_api_result.span(), zig_result.span()) catch |e| {
-        std.debug.print("got '{f}', expected '{f}'\n", .{ std.unicode.fmtUtf16Le(zig_result.span()), std.unicode.fmtUtf16Le(win32_api_result.span()) });
-        return e;
-    };
-}
-
-test "toPrefixedFileW" {
-    if (builtin.os.tag != .windows) return error.SkipZigTest;
-
-    // Most test cases come from https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
-    // Note that these tests do not actually touch the filesystem or care about whether or not
-    // any of the paths actually exist or are otherwise valid.
-
-    // Drive Absolute
-    try testToPrefixedFileWithOracle("X:\\ABC\\DEF", "\\??\\X:\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("X:\\", "\\??\\X:\\");
-    try testToPrefixedFileWithOracle("X:\\ABC\\", "\\??\\X:\\ABC\\");
-    // Trailing . and space characters are stripped
-    try testToPrefixedFileWithOracle("X:\\ABC\\DEF. .", "\\??\\X:\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("X:/ABC/DEF", "\\??\\X:\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("X:\\ABC\\..\\XYZ", "\\??\\X:\\XYZ");
-    try testToPrefixedFileWithOracle("X:\\ABC\\..\\..\\..", "\\??\\X:\\");
-    // Drive letter casing is unchanged
-    try testToPrefixedFileWithOracle("x:\\", "\\??\\x:\\");
-
-    // Drive Relative
-    // These tests depend on the CWD of the specified drive letter which can vary,
-    // so instead we just test that the Zig implementation matches the result of
-    // RtlDosPathNameToNtPathName_U.
-    // TODO: Setting the =X: environment variable didn't seem to affect
-    //       RtlDosPathNameToNtPathName_U, not sure why that is but getting that
-    //       to work could be an avenue to making these cases environment-independent.
-    // All -> are examples of the result if the X drive's cwd was X:\ABC
-    try testToPrefixedFileOnlyOracle("X:DEF\\GHI"); // -> \??\X:\ABC\DEF\GHI
-    try testToPrefixedFileOnlyOracle("X:"); // -> \??\X:\ABC
-    try testToPrefixedFileOnlyOracle("X:DEF. ."); // -> \??\X:\ABC\DEF
-    try testToPrefixedFileOnlyOracle("X:ABC\\..\\XYZ"); // -> \??\X:\ABC\XYZ
-    try testToPrefixedFileOnlyOracle("X:ABC\\..\\..\\.."); // -> \??\X:\
-    try testToPrefixedFileOnlyOracle("x:"); // -> \??\X:\ABC
-
-    // Rooted
-    // These tests depend on the drive letter of the CWD which can vary, so
-    // instead we just test that the Zig implementation matches the result of
-    // RtlDosPathNameToNtPathName_U.
-    // TODO: Getting the CWD path, getting the drive letter from it, and using it to
-    //       construct the expected NT paths could be an avenue to making these cases
-    //       environment-independent and therefore able to use testToPrefixedFileWithOracle.
-    // All -> are examples of the result if the CWD's drive letter was X
-    try testToPrefixedFileOnlyOracle("\\ABC\\DEF"); // -> \??\X:\ABC\DEF
-    try testToPrefixedFileOnlyOracle("\\"); // -> \??\X:\
-    try testToPrefixedFileOnlyOracle("\\ABC\\DEF. ."); // -> \??\X:\ABC\DEF
-    try testToPrefixedFileOnlyOracle("/ABC/DEF"); // -> \??\X:\ABC\DEF
-    try testToPrefixedFileOnlyOracle("\\ABC\\..\\XYZ"); // -> \??\X:\XYZ
-    try testToPrefixedFileOnlyOracle("\\ABC\\..\\..\\.."); // -> \??\X:\
-
-    // Relative
-    // These cases differ in functionality to RtlDosPathNameToNtPathName_U.
-    // Relative paths remain relative if they don't have enough .. components
-    // to error with TooManyParentDirs
-    try testToPrefixedFileNoOracle("ABC\\DEF", "ABC\\DEF");
-    // TODO: enable this if trailing . and spaces are stripped from relative paths
-    //try testToPrefixedFileNoOracle("ABC\\DEF. .", "ABC\\DEF");
-    try testToPrefixedFileNoOracle("ABC/DEF", "ABC\\DEF");
-    try testToPrefixedFileNoOracle("./ABC/.././DEF", "DEF");
-    // TooManyParentDirs, so resolved relative to the CWD
-    // All -> are examples of the result if the CWD was X:\ABC\DEF
-    try testToPrefixedFileOnlyOracle("..\\GHI"); // -> \??\X:\ABC\GHI
-    try testToPrefixedFileOnlyOracle("GHI\\..\\..\\.."); // -> \??\X:\
-
-    // UNC Absolute
-    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC\\DEF", "\\??\\UNC\\server\\share\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("\\\\server", "\\??\\UNC\\server");
-    try testToPrefixedFileWithOracle("\\\\server\\share", "\\??\\UNC\\server\\share");
-    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC. .", "\\??\\UNC\\server\\share\\ABC");
-    try testToPrefixedFileWithOracle("//server/share/ABC/DEF", "\\??\\UNC\\server\\share\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC\\..\\XYZ", "\\??\\UNC\\server\\share\\XYZ");
-    try testToPrefixedFileWithOracle("\\\\server\\share\\ABC\\..\\..\\..", "\\??\\UNC\\server\\share");
-
-    // Local Device
-    try testToPrefixedFileWithOracle("\\\\.\\COM20", "\\??\\COM20");
-    try testToPrefixedFileWithOracle("\\\\.\\pipe\\mypipe", "\\??\\pipe\\mypipe");
-    try testToPrefixedFileWithOracle("\\\\.\\X:\\ABC\\DEF. .", "\\??\\X:\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("\\\\.\\X:/ABC/DEF", "\\??\\X:\\ABC\\DEF");
-    try testToPrefixedFileWithOracle("\\\\.\\X:\\ABC\\..\\XYZ", "\\??\\X:\\XYZ");
-    // Can replace the first component of the path (contrary to drive absolute and UNC absolute paths)
-    try testToPrefixedFileWithOracle("\\\\.\\X:\\ABC\\..\\..\\C:\\", "\\??\\C:\\");
-    try testToPrefixedFileWithOracle("\\\\.\\pipe\\mypipe\\..\\notmine", "\\??\\pipe\\notmine");
-
-    // Special-case device names
-    // TODO: Enable once these are supported
-    //       more cases to test here: https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
-    //try testToPrefixedFileWithOracle("COM1", "\\??\\COM1");
-    // Sometimes the special-cased device names are not respected
-    try testToPrefixedFileWithOracle("\\\\.\\X:\\COM1", "\\??\\X:\\COM1");
-    try testToPrefixedFileWithOracle("\\\\abc\\xyz\\COM1", "\\??\\UNC\\abc\\xyz\\COM1");
-
-    // Verbatim
-    // Left untouched except \\?\ is replaced by \??\
-    try testToPrefixedFileWithOracle("\\\\?\\X:", "\\??\\X:");
-    try testToPrefixedFileWithOracle("\\\\?\\X:\\COM1", "\\??\\X:\\COM1");
-    try testToPrefixedFileWithOracle("\\\\?\\X:/ABC/DEF. .", "\\??\\X:/ABC/DEF. .");
-    try testToPrefixedFileWithOracle("\\\\?\\X:\\ABC\\..\\..\\..", "\\??\\X:\\ABC\\..\\..\\..");
-    // NT Namespace
-    // Fully unmodified
-    try testToPrefixedFileWithOracle("\\??\\X:", "\\??\\X:");
-    try testToPrefixedFileWithOracle("\\??\\X:\\COM1", "\\??\\X:\\COM1");
-    try testToPrefixedFileWithOracle("\\??\\X:/ABC/DEF. .", "\\??\\X:/ABC/DEF. .");
-    try testToPrefixedFileWithOracle("\\??\\X:\\ABC\\..\\..\\..", "\\??\\X:\\ABC\\..\\..\\..");
-
-    // 'Fake' Verbatim
-    // If the prefix looks like the verbatim prefix but not all path separators in the
-    // prefix are backslashes, then it gets canonicalized and the prefix is dropped in favor
-    // of the NT prefix.
-    try testToPrefixedFileWithOracle("//?/C:/ABC", "\\??\\C:\\ABC");
-    // 'Fake' NT
-    // If the prefix looks like the NT prefix but not all path separators in the prefix
-    // are backslashes, then it gets canonicalized and the /??/ is not dropped but
-    // rather treated as part of the path. In other words, the path is treated
-    // as a rooted path, so the final path is resolved relative to the CWD's
-    // drive letter.
-    // The -> shows an example of the result if the CWD's drive letter was X
-    try testToPrefixedFileOnlyOracle("/??/C:/ABC"); // -> \??\X:\??\C:\ABC
-
-    // Root Local Device
-    // \\. and \\? always get converted to \??\
-    try testToPrefixedFileWithOracle("\\\\.", "\\??\\");
-    try testToPrefixedFileWithOracle("\\\\?", "\\??\\");
-    try testToPrefixedFileWithOracle("//?", "\\??\\");
-    try testToPrefixedFileWithOracle("//.", "\\??\\");
-}
-
-fn testRemoveDotDirs(str: []const u8, expected: []const u8) !void {
-    const mutable = try testing.allocator.dupe(u8, str);
-    defer testing.allocator.free(mutable);
-    const actual = mutable[0..try windows.removeDotDirsSanitized(u8, mutable)];
-    try testing.expect(mem.eql(u8, actual, expected));
-}
-fn testRemoveDotDirsError(err: anyerror, str: []const u8) !void {
-    const mutable = try testing.allocator.dupe(u8, str);
-    defer testing.allocator.free(mutable);
-    try testing.expectError(err, windows.removeDotDirsSanitized(u8, mutable));
-}
-test "removeDotDirs" {
-    try testRemoveDotDirs("", "");
-    try testRemoveDotDirs(".", "");
-    try testRemoveDotDirs(".\\", "");
-    try testRemoveDotDirs(".\\.", "");
-    try testRemoveDotDirs(".\\.\\", "");
-    try testRemoveDotDirs(".\\.\\.", "");
-
-    try testRemoveDotDirs("a", "a");
-    try testRemoveDotDirs("a\\", "a\\");
-    try testRemoveDotDirs("a\\b", "a\\b");
-    try testRemoveDotDirs("a\\.", "a\\");
-    try testRemoveDotDirs("a\\b\\.", "a\\b\\");
-    try testRemoveDotDirs("a\\.\\b", "a\\b");
-
-    try testRemoveDotDirs(".a", ".a");
-    try testRemoveDotDirs(".a\\", ".a\\");
-    try testRemoveDotDirs(".a\\.b", ".a\\.b");
-    try testRemoveDotDirs(".a\\.", ".a\\");
-    try testRemoveDotDirs(".a\\.\\.", ".a\\");
-    try testRemoveDotDirs(".a\\.\\.\\.b", ".a\\.b");
-    try testRemoveDotDirs(".a\\.\\.\\.b\\", ".a\\.b\\");
-
-    try testRemoveDotDirsError(error.TooManyParentDirs, "..");
-    try testRemoveDotDirsError(error.TooManyParentDirs, "..\\");
-    try testRemoveDotDirsError(error.TooManyParentDirs, ".\\..\\");
-    try testRemoveDotDirsError(error.TooManyParentDirs, ".\\.\\..\\");
-
-    try testRemoveDotDirs("a\\..", "");
-    try testRemoveDotDirs("a\\..\\", "");
-    try testRemoveDotDirs("a\\..\\.", "");
-    try testRemoveDotDirs("a\\..\\.\\", "");
-    try testRemoveDotDirs("a\\..\\.\\.", "");
-    try testRemoveDotDirsError(error.TooManyParentDirs, "a\\..\\.\\.\\..");
-
-    try testRemoveDotDirs("a\\..\\.\\.\\b", "b");
-    try testRemoveDotDirs("a\\..\\.\\.\\b\\", "b\\");
-    try testRemoveDotDirs("a\\..\\.\\.\\b\\.", "b\\");
-    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\", "b\\");
-    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\..", "");
-    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\..\\", "");
-    try testRemoveDotDirs("a\\..\\.\\.\\b\\.\\..\\.", "");
-    try testRemoveDotDirsError(error.TooManyParentDirs, "a\\..\\.\\.\\b\\.\\..\\.\\..");
-
-    try testRemoveDotDirs("a\\b\\..\\", "a\\");
-    try testRemoveDotDirs("a\\b\\..\\c", "a\\c");
-}
-
-const RTL_PATH_TYPE = enum(c_int) {
-    Unknown,
-    UncAbsolute,
-    DriveAbsolute,
-    DriveRelative,
-    Rooted,
-    Relative,
-    LocalDevice,
-    RootLocalDevice,
-};
-
-pub extern "ntdll" fn RtlDetermineDosPathNameType_U(
-    Path: [*:0]const u16,
-) callconv(.winapi) RTL_PATH_TYPE;
-
-test "getWin32PathType vs RtlDetermineDosPathNameType_U" {
-    if (builtin.os.tag != .windows) return error.SkipZigTest;
-
-    var buf: std.ArrayList(u16) = .empty;
-    defer buf.deinit(std.testing.allocator);
-
-    var wtf8_buf: std.ArrayList(u8) = .empty;
-    defer wtf8_buf.deinit(std.testing.allocator);
-
-    var random = std.Random.DefaultPrng.init(std.testing.random_seed);
-    const rand = random.random();
-
-    for (0..1000) |_| {
-        buf.clearRetainingCapacity();
-        const path = try getRandomWtf16Path(std.testing.allocator, &buf, rand);
-        wtf8_buf.clearRetainingCapacity();
-        const wtf8_len = std.unicode.calcWtf8Len(path);
-        try wtf8_buf.ensureTotalCapacity(std.testing.allocator, wtf8_len);
-        wtf8_buf.items.len = wtf8_len;
-        std.debug.assert(std.unicode.wtf16LeToWtf8(wtf8_buf.items, path) == wtf8_len);
-
-        const windows_type = RtlDetermineDosPathNameType_U(path);
-        const wtf16_type = std.fs.path.getWin32PathType(u16, path);
-        const wtf8_type = std.fs.path.getWin32PathType(u8, wtf8_buf.items);
-
-        checkPathType(windows_type, wtf16_type) catch |err| {
-            std.debug.print("expected type {}, got {} for path: {f}\n", .{ windows_type, wtf16_type, std.unicode.fmtUtf16Le(path) });
-            std.debug.print("path bytes:\n", .{});
-            std.debug.dumpHex(std.mem.sliceAsBytes(path));
-            return err;
-        };
-
-        if (wtf16_type != wtf8_type) {
-            std.debug.print("type mismatch between wtf8: {} and wtf16: {} for path: {f}\n", .{ wtf8_type, wtf16_type, std.unicode.fmtUtf16Le(path) });
-            std.debug.print("wtf-16 path bytes:\n", .{});
-            std.debug.dumpHex(std.mem.sliceAsBytes(path));
-            std.debug.print("wtf-8 path bytes:\n", .{});
-            std.debug.dumpHex(std.mem.sliceAsBytes(wtf8_buf.items));
-            return error.Wtf8Wtf16Mismatch;
-        }
-    }
-}
-
-fn checkPathType(windows_type: RTL_PATH_TYPE, zig_type: std.fs.path.Win32PathType) !void {
-    const expected_windows_type: RTL_PATH_TYPE = switch (zig_type) {
-        .unc_absolute => .UncAbsolute,
-        .drive_absolute => .DriveAbsolute,
-        .drive_relative => .DriveRelative,
-        .rooted => .Rooted,
-        .relative => .Relative,
-        .local_device => .LocalDevice,
-        .root_local_device => .RootLocalDevice,
-    };
-    if (windows_type != expected_windows_type) return error.PathTypeMismatch;
-}
-
-fn getRandomWtf16Path(allocator: std.mem.Allocator, buf: *std.ArrayList(u16), rand: std.Random) ![:0]const u16 {
-    const Choice = enum {
-        backslash,
-        slash,
-        control,
-        printable,
-        non_ascii,
-    };
-
-    const choices = rand.uintAtMostBiased(u16, 32);
-
-    for (0..choices) |_| {
-        const choice = rand.enumValue(Choice);
-        const code_unit = switch (choice) {
-            .backslash => '\\',
-            .slash => '/',
-            .control => switch (rand.uintAtMostBiased(u8, 0x20)) {
-                0x20 => '\x7F',
-                else => |b| b + 1, // no NUL
-            },
-            .printable => '!' + rand.uintAtMostBiased(u8, '~' - '!'),
-            .non_ascii => rand.intRangeAtMostBiased(u16, 0x80, 0xFFFF),
-        };
-        try buf.append(allocator, std.mem.nativeToLittle(u16, code_unit));
-    }
-
-    try buf.append(allocator, 0);
-    return buf.items[0 .. buf.items.len - 1 :0];
-}
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 1f1195633006e461cb352b161f0dcebf12f700ad..46aa82f10fb5b7fe42f13b6c7b3c31a4cbf5dd79 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -639,7 +639,7 @@ test "zig fmt: array types last token" {
 
 test "zig fmt: sentinel-terminated array type" {
     try testCanonical(
-        \\pub fn cStrToPrefixedFileW(s: [*:0]const u8) ![PATH_MAX_WIDE:0]u16 {
+        \\pub fn foobar(s: [*:0]const u8) ![PATH_MAX_WIDE:0]u16 {
         \\    return sliceToPrefixedFileW(mem.toSliceConst(u8, s));
         \\}
         \\
diff --git a/test/standalone/load_dynamic_library/build.zig b/test/standalone/load_dynamic_library/build.zig
index 305ffde56506cf97cd0465d1af85f8680b7445b7..2160b2b3e474a558725d9f2c39eb98f7a1be9d8a 100644
--- a/test/standalone/load_dynamic_library/build.zig
+++ b/test/standalone/load_dynamic_library/build.zig
@@ -9,6 +9,7 @@ pub fn build(b: *std.Build) void {
     const target = b.graph.host;
 
     if (builtin.os.tag == .wasi) return;
+    if (builtin.os.tag == .windows) return;
 
     const lib = b.addLibrary(.{
         .linkage = .dynamic,
-- 
2.54.0


From 3a5fff45ec04f4b713acae51a38510c316e42445 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Feb 2026 21:27:27 -0800
Subject: [PATCH 201/499] std: move os.windows.OpenFile into Io.Threaded

it needs cancelation integration
---
 lib/std/Io/Threaded.zig | 345 ++++++++++++++++++++++++++--------------
 lib/std/os/windows.zig  | 117 --------------
 2 files changed, 228 insertions(+), 234 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1c171d7321b8575d01a82fcbe712078a662c8ee6..ac9b4fd7f46e17c10d4ec9e0b18fd79e7dd08739 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3260,30 +3260,23 @@ fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, pe
     const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
     _ = permissions; // TODO use this value
 
-    const syscall: Syscall = try .start();
-    const sub_dir_handle = while (true) {
-        break windows.OpenFile(sub_path_w.span(), .{
-            .dir = dir.handle,
-            .access_mask = .{
-                .GENERIC = .{ .READ = true },
-                .STANDARD = .{ .SYNCHRONIZE = true },
-            },
-            .creation = .CREATE,
-            .filter = .dir_only,
-        }) catch |err| switch (err) {
-            error.IsDir => return syscall.fail(error.Unexpected),
-            error.PipeBusy => return syscall.fail(error.Unexpected),
-            error.NoDevice => return syscall.fail(error.Unexpected),
-            error.WouldBlock => return syscall.fail(error.Unexpected),
-            error.AntivirusInterference => return syscall.fail(error.Unexpected),
-            error.OperationCanceled => {
-                try syscall.checkCancel();
-                continue;
-            },
-            else => |e| return syscall.fail(e),
-        };
+    const sub_dir_handle = OpenFile(sub_path_w.span(), .{
+        .dir = dir.handle,
+        .access_mask = .{
+            .GENERIC = .{ .READ = true },
+            .STANDARD = .{ .SYNCHRONIZE = true },
+        },
+        .creation = .CREATE,
+        .filter = .dir_only,
+    }) catch |err| switch (err) {
+        error.IsDir => return error.Unexpected,
+        error.PipeBusy => return error.Unexpected,
+        error.FileBusy => return error.Unexpected,
+        error.NoDevice => return error.Unexpected,
+        error.WouldBlock => return error.Unexpected,
+        error.AntivirusInterference => return error.Unexpected,
+        else => |e| return e,
     };
-    syscall.finish();
     windows.CloseHandle(sub_dir_handle);
 }
 
@@ -5987,27 +5980,19 @@ fn dirRealPathFileWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8,
     var path_name_w = try sliceToPrefixedFileW(dir.handle, sub_path);
 
     const h_file = handle: {
-        const syscall: Syscall = try .start();
-        while (true) {
-            if (windows.OpenFile(path_name_w.span(), .{
-                .dir = dir.handle,
-                .access_mask = .{
-                    .GENERIC = .{ .READ = true },
-                    .STANDARD = .{ .SYNCHRONIZE = true },
-                },
-                .creation = .OPEN,
-                .filter = .any,
-            })) |handle| {
-                syscall.finish();
-                break :handle handle;
-            } else |err| switch (err) {
-                error.WouldBlock => unreachable,
-                error.OperationCanceled => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => |e| return syscall.fail(e),
-            }
+        if (OpenFile(path_name_w.span(), .{
+            .dir = dir.handle,
+            .access_mask = .{
+                .GENERIC = .{ .READ = true },
+                .STANDARD = .{ .SYNCHRONIZE = true },
+            },
+            .creation = .OPEN,
+            .filter = .any,
+        })) |handle| {
+            break :handle handle;
+        } else |err| switch (err) {
+            error.WouldBlock => unreachable,
+            else => |e| return e,
         }
     };
     defer windows.CloseHandle(h_file);
@@ -6116,7 +6101,7 @@ pub fn GetFinalPathNameByHandle(
             // Source: https://stackoverflow.com/questions/3012828/using-ioctl-mountmgr-query-points
             // This is the NT namespaced version of \\.\MountPointManager
             const mgmt_path_u16 = std.unicode.utf8ToUtf16LeStringLiteral("\\??\\MountPointManager");
-            const mgmt_handle = windows.OpenFile(mgmt_path_u16, .{
+            const mgmt_handle = OpenFile(mgmt_path_u16, .{
                 .access_mask = .{ .STANDARD = .{ .SYNCHRONIZE = true } },
                 .creation = .OPEN,
             }) catch |err| switch (err) {
@@ -6125,12 +6110,12 @@ pub fn GetFinalPathNameByHandle(
                 error.NoDevice => return error.Unexpected,
                 error.AccessDenied => return error.Unexpected,
                 error.PipeBusy => return error.Unexpected,
+                error.FileBusy => return error.Unexpected,
                 error.PathAlreadyExists => return error.Unexpected,
                 error.WouldBlock => return error.Unexpected,
                 error.NetworkNotFound => return error.Unexpected,
                 error.AntivirusInterference => return error.Unexpected,
                 error.BadPathName => return error.Unexpected,
-                error.OperationCanceled => @panic("TODO: better integrate cancelation"),
                 else => |e| return e,
             };
             defer windows.CloseHandle(mgmt_handle);
@@ -7309,31 +7294,23 @@ fn dirRenameWindowsInner(
     const new_path_w = new_path_w_buf.span();
 
     const src_fd = src_fd: {
-        const syscall: Syscall = try .start();
-        while (true) {
-            if (w.OpenFile(old_path_w, .{
-                .dir = old_dir.handle,
-                .access_mask = .{
-                    .GENERIC = .{ .WRITE = true },
-                    .STANDARD = .{
-                        .RIGHTS = .{ .DELETE = true },
-                        .SYNCHRONIZE = true,
-                    },
+        if (OpenFile(old_path_w, .{
+            .dir = old_dir.handle,
+            .access_mask = .{
+                .GENERIC = .{ .WRITE = true },
+                .STANDARD = .{
+                    .RIGHTS = .{ .DELETE = true },
+                    .SYNCHRONIZE = true,
                 },
-                .creation = .OPEN,
-                .filter = .any, // This function is supposed to rename both files and directories.
-                .follow_symlinks = false,
-            })) |handle| {
-                syscall.finish();
-                break :src_fd handle;
-            } else |err| switch (err) {
-                error.WouldBlock => unreachable, // Not possible without `.share_access_nonblocking = true`.
-                error.OperationCanceled => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => |e| return e,
-            }
+            },
+            .creation = .OPEN,
+            .filter = .any, // This function is supposed to rename both files and directories.
+            .follow_symlinks = false,
+        })) |handle| {
+            break :src_fd handle;
+        } else |err| switch (err) {
+            error.WouldBlock => unreachable, // Not possible without `.share_access_nonblocking = true`.
+            else => |e| return e,
         }
     };
     defer w.CloseHandle(src_fd);
@@ -7662,32 +7639,25 @@ fn dirSymLinkWindows(
     };
 
     const symlink_handle = handle: {
-        const syscall: Syscall = try .start();
-        while (true) {
-            if (w.OpenFile(sym_link_path_w.span(), .{
-                .access_mask = .{
-                    .GENERIC = .{ .READ = true, .WRITE = true },
-                    .STANDARD = .{ .SYNCHRONIZE = true },
-                },
-                .dir = dir.handle,
-                .creation = .CREATE,
-                .filter = if (flags.is_directory) .dir_only else .non_directory_only,
-            })) |handle| {
-                syscall.finish();
-                break :handle handle;
-            } else |err| switch (err) {
-                error.IsDir => return syscall.fail(error.PathAlreadyExists),
-                error.NotDir => return syscall.fail(error.Unexpected),
-                error.WouldBlock => return syscall.fail(error.Unexpected),
-                error.PipeBusy => return syscall.fail(error.Unexpected),
-                error.NoDevice => return syscall.fail(error.Unexpected),
-                error.AntivirusInterference => return syscall.fail(error.Unexpected),
-                error.OperationCanceled => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => |e| return e,
-            }
+        if (OpenFile(sym_link_path_w.span(), .{
+            .access_mask = .{
+                .GENERIC = .{ .READ = true, .WRITE = true },
+                .STANDARD = .{ .SYNCHRONIZE = true },
+            },
+            .dir = dir.handle,
+            .creation = .CREATE,
+            .filter = if (flags.is_directory) .dir_only else .non_directory_only,
+        })) |handle| {
+            break :handle handle;
+        } else |err| switch (err) {
+            error.IsDir => return error.PathAlreadyExists,
+            error.NotDir => return error.Unexpected,
+            error.WouldBlock => return error.Unexpected,
+            error.PipeBusy => return error.Unexpected,
+            error.FileBusy => return error.Unexpected,
+            error.NoDevice => return error.Unexpected,
+            error.AntivirusInterference => return error.Unexpected,
+            else => |e| return e,
         }
     };
     defer w.CloseHandle(symlink_handle);
@@ -10341,27 +10311,20 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             var path_name_w_buf = try wToPrefixedFileW(null, image_path_name);
 
             const h_file = handle: {
-                const syscall: Syscall = try .start();
-                while (true) {
-                    if (w.OpenFile(path_name_w_buf.span(), .{
-                        .dir = null,
-                        .access_mask = .{
-                            .GENERIC = .{ .READ = true },
-                            .STANDARD = .{ .SYNCHRONIZE = true },
-                        },
-                        .creation = .OPEN,
-                        .filter = .any,
-                    })) |handle| {
-                        syscall.finish();
-                        break :handle handle;
-                    } else |err| switch (err) {
-                        error.WouldBlock => unreachable,
-                        error.OperationCanceled => {
-                            try syscall.checkCancel();
-                            continue;
-                        },
-                        else => |e| return e,
-                    }
+                if (OpenFile(path_name_w_buf.span(), .{
+                    .dir = null,
+                    .access_mask = .{
+                        .GENERIC = .{ .READ = true },
+                        .STANDARD = .{ .SYNCHRONIZE = true },
+                    },
+                    .creation = .OPEN,
+                    .filter = .any,
+                })) |handle| {
+                    break :handle handle;
+                } else |err| switch (err) {
+                    error.WouldBlock => unreachable,
+                    error.FileBusy => unreachable,
+                    else => |e| return e,
                 }
             };
             defer w.CloseHandle(h_file);
@@ -19055,3 +19018,151 @@ pub fn mutexUnlock(m: *Io.Mutex) void {
         },
     }
 }
+
+const OpenError = error{
+    IsDir,
+    NotDir,
+    FileNotFound,
+    NoDevice,
+    AccessDenied,
+    PipeBusy,
+    PathAlreadyExists,
+    WouldBlock,
+    NetworkNotFound,
+    AntivirusInterference,
+    FileBusy,
+} || Dir.PathNameError || Io.Cancelable || Io.UnexpectedError;
+
+const OpenFileOptions = struct {
+    access_mask: windows.ACCESS_MASK,
+    dir: ?windows.HANDLE = null,
+    sa: ?*windows.SECURITY_ATTRIBUTES = null,
+    share_access: windows.FILE.SHARE = .VALID_FLAGS,
+    creation: windows.FILE.CREATE_DISPOSITION,
+    filter: Filter = .non_directory_only,
+    /// If false, tries to open path as a reparse point without dereferencing it.
+    /// Defaults to true.
+    follow_symlinks: bool = true,
+
+    pub const Filter = enum {
+        /// Causes `OpenFile` to return `error.IsDir` if the opened handle would be a directory.
+        non_directory_only,
+        /// Causes `OpenFile` to return `error.NotDir` if the opened handle is not a directory.
+        dir_only,
+        /// `OpenFile` does not discriminate between opening files and directories.
+        any,
+    };
+};
+
+/// TODO: inline this logic everywhere and delete this function
+fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows.HANDLE {
+    if (std.mem.eql(u16, sub_path_w, &[_]u16{'.'}) and options.filter == .non_directory_only) {
+        return error.IsDir;
+    }
+    if (std.mem.eql(u16, sub_path_w, &[_]u16{ '.', '.' }) and options.filter == .non_directory_only) {
+        return error.IsDir;
+    }
+
+    var result: windows.HANDLE = undefined;
+
+    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
+    var nt_name: windows.UNICODE_STRING = .{
+        .Length = path_len_bytes,
+        .MaximumLength = path_len_bytes,
+        .Buffer = @constCast(sub_path_w.ptr),
+    };
+    const attr: windows.OBJECT_ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else options.dir,
+        .Attributes = .{ .INHERIT = if (options.sa) |sa| sa.bInheritHandle != windows.FALSE else false },
+        .ObjectName = &nt_name,
+        .SecurityDescriptor = if (options.sa) |ptr| ptr.lpSecurityDescriptor else null,
+    };
+
+    var iosb: windows.IO_STATUS_BLOCK = undefined;
+
+    // There are multiple kernel bugs being worked around with retries.
+    const max_attempts = 13;
+    var attempt: u5 = 0;
+
+    var syscall: Syscall = try .start();
+    while (true) {
+        switch (windows.ntdll.NtCreateFile(
+            &result,
+            options.access_mask,
+            &attr,
+            &iosb,
+            null,
+            .{ .NORMAL = true },
+            options.share_access,
+            options.creation,
+            .{
+                .DIRECTORY_FILE = options.filter == .dir_only,
+                .NON_DIRECTORY_FILE = options.filter == .non_directory_only,
+                .IO = if (options.follow_symlinks) .SYNCHRONOUS_NONALERT else .ASYNCHRONOUS,
+                .OPEN_REPARSE_POINT = !options.follow_symlinks,
+            },
+            null,
+            0,
+        )) {
+            .SUCCESS => {
+                syscall.finish();
+                return result;
+            },
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .SHARING_VIOLATION => {
+                // This occurs if the file attempting to be opened is a running
+                // executable. However, there's a kernel bug: the error may be
+                // incorrectly returned for an indeterminate amount of time
+                // after an executable file is closed. Here we work around the
+                // kernel bug with retry attempts.
+                syscall.finish();
+                if (max_attempts - attempt == 0) return error.FileBusy;
+                try parking_sleep.sleep(.{ .duration = .{
+                    .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                    .clock = .awake,
+                } });
+                attempt += 1;
+                syscall = try .start();
+                continue;
+            },
+            .DELETE_PENDING => {
+                // This error means that there *was* a file in this location on
+                // the file system, but it was deleted. However, the OS is not
+                // finished with the deletion operation, and so this CreateFile
+                // call has failed. There is not really a sane way to handle
+                // this other than retrying the creation after the OS finishes
+                // the deletion.
+                syscall.finish();
+                if (max_attempts - attempt == 0) return error.FileBusy;
+                try parking_sleep.sleep(.{ .duration = .{
+                    .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                    .clock = .awake,
+                } });
+                attempt += 1;
+                syscall = try .start();
+                continue;
+            },
+            .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
+            .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
+            .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
+            .BAD_NETWORK_PATH => return syscall.fail(error.NetworkNotFound), // \\server was not found
+            .BAD_NETWORK_NAME => return syscall.fail(error.NetworkNotFound), // \\server was found but \\server\share wasn't
+            .NO_MEDIA_IN_DEVICE => return syscall.fail(error.NoDevice),
+            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .PIPE_BUSY => return syscall.fail(error.PipeBusy),
+            .PIPE_NOT_AVAILABLE => return syscall.fail(error.NoDevice),
+            .OBJECT_NAME_COLLISION => return syscall.fail(error.PathAlreadyExists),
+            .FILE_IS_A_DIRECTORY => return syscall.fail(error.IsDir),
+            .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
+            .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
+            .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
+            .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+            .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
+            .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
+            else => |status| return syscall.unexpectedNtstatus(status),
+        }
+    }
+}
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index ac36e77ac35d75e52fe356ba6139e2c864160039..0180138a0fbb4c7258181ed1d7ee6a572eb40db6 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -2359,123 +2359,6 @@ pub const OBJECT_ATTRIBUTES = extern struct {
 
 // ref none
 
-pub const OpenError = error{
-    IsDir,
-    NotDir,
-    FileNotFound,
-    NoDevice,
-    AccessDenied,
-    PipeBusy,
-    PathAlreadyExists,
-    Unexpected,
-    NameTooLong,
-    WouldBlock,
-    NetworkNotFound,
-    AntivirusInterference,
-    BadPathName,
-    OperationCanceled,
-};
-
-pub const OpenFileOptions = struct {
-    access_mask: ACCESS_MASK,
-    dir: ?HANDLE = null,
-    sa: ?*SECURITY_ATTRIBUTES = null,
-    share_access: FILE.SHARE = .VALID_FLAGS,
-    creation: FILE.CREATE_DISPOSITION,
-    filter: Filter = .non_directory_only,
-    /// If false, tries to open path as a reparse point without dereferencing it.
-    /// Defaults to true.
-    follow_symlinks: bool = true,
-
-    pub const Filter = enum {
-        /// Causes `OpenFile` to return `error.IsDir` if the opened handle would be a directory.
-        non_directory_only,
-        /// Causes `OpenFile` to return `error.NotDir` if the opened handle is not a directory.
-        dir_only,
-        /// `OpenFile` does not discriminate between opening files and directories.
-        any,
-    };
-};
-
-pub fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!HANDLE {
-    if (mem.eql(u16, sub_path_w, &[_]u16{'.'}) and options.filter == .non_directory_only) {
-        return error.IsDir;
-    }
-    if (mem.eql(u16, sub_path_w, &[_]u16{ '.', '.' }) and options.filter == .non_directory_only) {
-        return error.IsDir;
-    }
-
-    var result: HANDLE = undefined;
-
-    const path_len_bytes = math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
-    var nt_name: UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-    const attr: OBJECT_ATTRIBUTES = .{
-        .RootDirectory = if (std.fs.path.isAbsoluteWindowsWtf16(sub_path_w)) null else options.dir,
-        .Attributes = .{ .INHERIT = if (options.sa) |sa| sa.bInheritHandle != FALSE else false },
-        .ObjectName = &nt_name,
-        .SecurityDescriptor = if (options.sa) |ptr| ptr.lpSecurityDescriptor else null,
-    };
-    var io: IO_STATUS_BLOCK = undefined;
-    while (true) {
-        const rc = ntdll.NtCreateFile(
-            &result,
-            options.access_mask,
-            &attr,
-            &io,
-            null,
-            .{ .NORMAL = true },
-            options.share_access,
-            options.creation,
-            .{
-                .DIRECTORY_FILE = options.filter == .dir_only,
-                .NON_DIRECTORY_FILE = options.filter == .non_directory_only,
-                .IO = if (options.follow_symlinks) .SYNCHRONOUS_NONALERT else .ASYNCHRONOUS,
-                .OPEN_REPARSE_POINT = !options.follow_symlinks,
-            },
-            null,
-            0,
-        );
-        switch (rc) {
-            .SUCCESS => return result,
-            .OBJECT_NAME_INVALID => return error.BadPathName,
-            .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
-            .OBJECT_PATH_NOT_FOUND => return error.FileNotFound,
-            .BAD_NETWORK_PATH => return error.NetworkNotFound, // \\server was not found
-            .BAD_NETWORK_NAME => return error.NetworkNotFound, // \\server was found but \\server\share wasn't
-            .NO_MEDIA_IN_DEVICE => return error.NoDevice,
-            .INVALID_PARAMETER => unreachable,
-            .SHARING_VIOLATION => return error.AccessDenied,
-            .ACCESS_DENIED => return error.AccessDenied,
-            .PIPE_BUSY => return error.PipeBusy,
-            .PIPE_NOT_AVAILABLE => return error.NoDevice,
-            .OBJECT_PATH_SYNTAX_BAD => unreachable,
-            .OBJECT_NAME_COLLISION => return error.PathAlreadyExists,
-            .FILE_IS_A_DIRECTORY => return error.IsDir,
-            .NOT_A_DIRECTORY => return error.NotDir,
-            .USER_MAPPED_FILE => return error.AccessDenied,
-            .INVALID_HANDLE => unreachable,
-            .DELETE_PENDING => {
-                // This error means that there *was* a file in this location on
-                // the file system, but it was deleted. However, the OS is not
-                // finished with the deletion operation, and so this CreateFile
-                // call has failed. There is not really a sane way to handle
-                // this other than retrying the creation after the OS finishes
-                // the deletion.
-                const delay_one_ms: LARGE_INTEGER = -(std.time.ns_per_ms / 100);
-                _ = ntdll.NtDelayExecution(TRUE, &delay_one_ms);
-                continue;
-            },
-            .VIRUS_INFECTED, .VIRUS_DELETED => return error.AntivirusInterference,
-            .CANCELLED => return error.OperationCanceled,
-            else => return unexpectedStatus(rc),
-        }
-    }
-}
-
 pub fn GetCurrentProcess() HANDLE {
     const process_pseudo_handle: usize = @bitCast(@as(isize, -1));
     return @ptrFromInt(process_pseudo_handle);
-- 
2.54.0


From 0e7d00776e5468b53c2ba07ebfe9fef5abda310a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 12:44:11 -0800
Subject: [PATCH 202/499] std.Io.Threaded: inline OpenFile into
 dirCreateDirWindows

---
 lib/std/Io/Threaded.zig | 152 +++++++++++++++++++++++++++++-----------
 1 file changed, 112 insertions(+), 40 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index ac9b4fd7f46e17c10d4ec9e0b18fd79e7dd08739..5db2d6cfd0ac2dc72999547ec8f5b05ded309650 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1404,6 +1404,8 @@ const splat_buffer_size = 64;
 /// posix systems.
 const poll_buffer_len = 64;
 const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
+/// There are multiple kernel bugs being worked around with retries.
+const max_windows_kernel_bug_retries = 13;
 
 comptime {
     if (@TypeOf(posix.IOV_MAX) != void) assert(max_iovecs_len <= posix.IOV_MAX);
@@ -3256,28 +3258,114 @@ fn dirCreateDirWasi(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permi
 fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-
-    const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
     _ = permissions; // TODO use this value
 
-    const sub_dir_handle = OpenFile(sub_path_w.span(), .{
-        .dir = dir.handle,
-        .access_mask = .{
+    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
+    const sub_path_w = sub_path_w_array.span();
+    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
+
+    var nt_name: windows.UNICODE_STRING = .{
+        .Length = path_len_bytes,
+        .MaximumLength = path_len_bytes,
+        .Buffer = @constCast(sub_path_w.ptr),
+    };
+    const attr: windows.OBJECT_ATTRIBUTES = .{
+        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
+        .Attributes = .{
+            .INHERIT = false,
+        },
+        .ObjectName = &nt_name,
+        .SecurityDescriptor = null,
+        .SecurityQualityOfService = null,
+    };
+
+    var sub_dir_handle: windows.HANDLE = undefined;
+    var io_status_block: windows.IO_STATUS_BLOCK = undefined;
+    var attempt: u5 = 0;
+    var syscall: Syscall = try .start();
+    while (true) switch (windows.ntdll.NtCreateFile(
+        &sub_dir_handle,
+        .{
             .GENERIC = .{ .READ = true },
             .STANDARD = .{ .SYNCHRONIZE = true },
         },
-        .creation = .CREATE,
-        .filter = .dir_only,
-    }) catch |err| switch (err) {
-        error.IsDir => return error.Unexpected,
-        error.PipeBusy => return error.Unexpected,
-        error.FileBusy => return error.Unexpected,
-        error.NoDevice => return error.Unexpected,
-        error.WouldBlock => return error.Unexpected,
-        error.AntivirusInterference => return error.Unexpected,
-        else => |e| return e,
+        &attr,
+        &io_status_block,
+        null,
+        .{ .NORMAL = true },
+        .VALID_FLAGS,
+        .CREATE,
+        .{
+            .DIRECTORY_FILE = true,
+            .NON_DIRECTORY_FILE = false,
+            .IO = .SYNCHRONOUS_NONALERT,
+            .OPEN_REPARSE_POINT = false,
+        },
+        null,
+        0,
+    )) {
+        .SUCCESS => {
+            syscall.finish();
+            windows.CloseHandle(sub_dir_handle);
+            return;
+        },
+        .CANCELLED => {
+            try syscall.checkCancel();
+            continue;
+        },
+        .SHARING_VIOLATION => {
+            // This occurs if the file attempting to be opened is a running
+            // executable. However, there's a kernel bug: the error may be
+            // incorrectly returned for an indeterminate amount of time
+            // after an executable file is closed. Here we work around the
+            // kernel bug with retry attempts.
+            syscall.finish();
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                .clock = .awake,
+            } });
+            attempt += 1;
+            syscall = try .start();
+            continue;
+        },
+        .DELETE_PENDING => {
+            // This error means that there *was* a file in this location on
+            // the file system, but it was deleted. However, the OS is not
+            // finished with the deletion operation, and so this CreateFile
+            // call has failed. There is not really a sane way to handle
+            // this other than retrying the creation after the OS finishes
+            // the deletion.
+            syscall.finish();
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
+            try parking_sleep.sleep(.{ .duration = .{
+                .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
+                .clock = .awake,
+            } });
+            attempt += 1;
+            syscall = try .start();
+            continue;
+        },
+        .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
+        .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
+        .BAD_NETWORK_PATH => return syscall.fail(error.NetworkNotFound), // \\server was not found
+        .BAD_NETWORK_NAME => return syscall.fail(error.NetworkNotFound), // \\server was found but \\server\share wasn't
+        .NO_MEDIA_IN_DEVICE => return syscall.fail(error.NoDevice),
+        .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+        .PIPE_BUSY => return syscall.fail(error.PipeBusy),
+        .PIPE_NOT_AVAILABLE => return syscall.fail(error.NoDevice),
+        .OBJECT_NAME_COLLISION => return syscall.fail(error.PathAlreadyExists),
+        .FILE_IS_A_DIRECTORY => return syscall.fail(error.IsDir),
+        .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
+        .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
+        .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
+        .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
+        .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
+        .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
+        else => |status| return syscall.unexpectedNtstatus(status),
     };
-    windows.CloseHandle(sub_dir_handle);
 }
 
 fn dirCreateDirPath(
@@ -4307,11 +4395,7 @@ fn dirCreateFileWindows(
     };
 
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
-
-    // There are multiple kernel bugs being worked around with retries.
-    const max_attempts = 13;
     var attempt: u5 = 0;
-
     var handle: windows.HANDLE = undefined;
     var syscall: Syscall = try .start();
     while (true) switch (windows.ntdll.NtCreateFile(
@@ -4345,7 +4429,7 @@ fn dirCreateFileWindows(
             // after an executable file is closed. Here we work around the
             // kernel bug with retry attempts.
             syscall.finish();
-            if (max_attempts - attempt == 0) return error.FileBusy;
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
             try parking_sleep.sleep(.{ .duration = .{
                 .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                 .clock = .awake,
@@ -4361,7 +4445,7 @@ fn dirCreateFileWindows(
             // call has failed. Here, we simulate the kernel bug being
             // fixed by sleeping and retrying until the error goes away.
             syscall.finish();
-            if (max_attempts - attempt == 0) return error.FileBusy;
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
             try parking_sleep.sleep(.{ .duration = .{
                 .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                 .clock = .awake,
@@ -4903,11 +4987,7 @@ pub fn dirOpenFileWtf16(
         .Buffer = @constCast(sub_path_w.ptr),
     };
     var io_status_block: w.IO_STATUS_BLOCK = undefined;
-
-    // There are multiple kernel bugs being worked around with retries.
-    const max_attempts = 13;
     var attempt: u5 = 0;
-
     var syscall: Syscall = try .start();
     const handle = while (true) {
         var result: w.HANDLE = undefined;
@@ -4959,7 +5039,7 @@ pub fn dirOpenFileWtf16(
                 // after an executable file is closed. Here we work around the
                 // kernel bug with retry attempts.
                 syscall.finish();
-                if (max_attempts - attempt == 0) return error.FileBusy;
+                if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
                 try parking_sleep.sleep(.{ .duration = .{
                     .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                     .clock = .awake,
@@ -4984,7 +5064,7 @@ pub fn dirOpenFileWtf16(
                 // call has failed. Here, we simulate the kernel bug being
                 // fixed by sleeping and retrying until the error goes away.
                 syscall.finish();
-                if (max_attempts - attempt == 0) return error.FileBusy;
+                if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
                 try parking_sleep.sleep(.{ .duration = .{
                     .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                     .clock = .awake,
@@ -7850,11 +7930,7 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
     };
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var result_handle: windows.HANDLE = undefined;
-
-    // There are multiple kernel bugs being worked around with retries.
-    const max_attempts = 13;
     var attempt: u5 = 0;
-
     var syscall: Syscall = try .start();
     while (true) switch (windows.ntdll.NtCreateFile(
         &result_handle,
@@ -7894,7 +7970,7 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
             // after an executable file is closed. Here we work around the
             // kernel bug with retry attempts.
             syscall.finish();
-            if (max_attempts - attempt == 0) return error.FileBusy;
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
             try parking_sleep.sleep(.{ .duration = .{
                 .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                 .clock = .awake,
@@ -7910,7 +7986,7 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
             // call has failed. Here, we simulate the kernel bug being
             // fixed by sleeping and retrying until the error goes away.
             syscall.finish();
-            if (max_attempts - attempt == 0) return error.FileBusy;
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
             try parking_sleep.sleep(.{ .duration = .{
                 .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                 .clock = .awake,
@@ -19079,11 +19155,7 @@ fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows
     };
 
     var iosb: windows.IO_STATUS_BLOCK = undefined;
-
-    // There are multiple kernel bugs being worked around with retries.
-    const max_attempts = 13;
     var attempt: u5 = 0;
-
     var syscall: Syscall = try .start();
     while (true) {
         switch (windows.ntdll.NtCreateFile(
@@ -19119,7 +19191,7 @@ fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows
                 // after an executable file is closed. Here we work around the
                 // kernel bug with retry attempts.
                 syscall.finish();
-                if (max_attempts - attempt == 0) return error.FileBusy;
+                if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
                 try parking_sleep.sleep(.{ .duration = .{
                     .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                     .clock = .awake,
@@ -19136,7 +19208,7 @@ fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows
                 // this other than retrying the creation after the OS finishes
                 // the deletion.
                 syscall.finish();
-                if (max_attempts - attempt == 0) return error.FileBusy;
+                if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
                 try parking_sleep.sleep(.{ .duration = .{
                     .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                     .clock = .awake,
-- 
2.54.0


From 3078a3197bce73f6ce70117989ea09f991470f50 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 12:46:56 -0800
Subject: [PATCH 203/499] std.Io.Threaded.dirCreateDirWindows: remove
 unexpected error handling

---
 lib/std/Io/Threaded.zig | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 5db2d6cfd0ac2dc72999547ec8f5b05ded309650..c467615f9cb2579c6e0ac539eb735515d3e723ab 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3321,7 +3321,7 @@ fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, pe
             // after an executable file is closed. Here we work around the
             // kernel bug with retry attempts.
             syscall.finish();
-            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.Unexpected;
             try parking_sleep.sleep(.{ .duration = .{
                 .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                 .clock = .awake,
@@ -3338,7 +3338,7 @@ fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, pe
             // this other than retrying the creation after the OS finishes
             // the deletion.
             syscall.finish();
-            if (max_windows_kernel_bug_retries - attempt == 0) return error.FileBusy;
+            if (max_windows_kernel_bug_retries - attempt == 0) return error.Unexpected;
             try parking_sleep.sleep(.{ .duration = .{
                 .raw = .fromMilliseconds((@as(u32, 1) << attempt) >> 1),
                 .clock = .awake,
@@ -3352,15 +3352,10 @@ fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, pe
         .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
         .BAD_NETWORK_PATH => return syscall.fail(error.NetworkNotFound), // \\server was not found
         .BAD_NETWORK_NAME => return syscall.fail(error.NetworkNotFound), // \\server was found but \\server\share wasn't
-        .NO_MEDIA_IN_DEVICE => return syscall.fail(error.NoDevice),
         .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-        .PIPE_BUSY => return syscall.fail(error.PipeBusy),
-        .PIPE_NOT_AVAILABLE => return syscall.fail(error.NoDevice),
         .OBJECT_NAME_COLLISION => return syscall.fail(error.PathAlreadyExists),
-        .FILE_IS_A_DIRECTORY => return syscall.fail(error.IsDir),
         .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
         .USER_MAPPED_FILE => return syscall.fail(error.AccessDenied),
-        .VIRUS_INFECTED, .VIRUS_DELETED => return syscall.fail(error.AntivirusInterference),
         .INVALID_PARAMETER => |status| return syscall.ntstatusBug(status),
         .OBJECT_PATH_SYNTAX_BAD => |status| return syscall.ntstatusBug(status),
         .INVALID_HANDLE => |status| return syscall.ntstatusBug(status),
-- 
2.54.0


From c77e7146f5fa8e83c06cd6612b7298df06912974 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Wed, 4 Feb 2026 18:12:29 -0500
Subject: [PATCH 204/499] std.Threaded: replace console kernel32 functions with
 ntdll

---
 lib/std/Io.zig                  |   8 +-
 lib/std/Io/Terminal.zig         |  26 +--
 lib/std/Io/Threaded.zig         | 208 ++++++++++-------------
 lib/std/Progress.zig            | 171 +++++++++++--------
 lib/std/log.zig                 |   5 +-
 lib/std/os/windows.zig          | 289 ++++++++++++++++++++++++++++----
 lib/std/os/windows/kernel32.zig |  84 ----------
 lib/std/std.zig                 |   6 +-
 src/libs/mingw.zig              |   2 +-
 9 files changed, 477 insertions(+), 322 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 0eb1df2d1a7decb3787d74c6baeb7c49a507a4fe..47ba7c2072c7bc1d954bdc21c85577cb71703bbe 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -335,11 +335,9 @@ pub const Operation = union(enum) {
         .wasi => noreturn,
         .windows => struct {
             file: File,
-            IoControlCode: std.os.windows.CTL_CODE,
-            InputBuffer: ?*const anyopaque,
-            InputBufferLength: u32,
-            OutputBuffer: ?*anyopaque,
-            OutputBufferLength: u32,
+            code: std.os.windows.CTL_CODE,
+            in: []const u8 = &.{},
+            out: []u8 = &.{},
 
             pub const Result = std.os.windows.IO_STATUS_BLOCK;
         },
diff --git a/lib/std/Io/Terminal.zig b/lib/std/Io/Terminal.zig
index beacc4d301c782144c58cccffe52df0ec058ab3d..27805f5e4d5f88ab7eaa7ebdb6326a248d54afd6 100644
--- a/lib/std/Io/Terminal.zig
+++ b/lib/std/Io/Terminal.zig
@@ -40,7 +40,8 @@ pub const Mode = union(enum) {
     windows_api: WindowsApi,
 
     pub const WindowsApi = if (!is_windows) noreturn else struct {
-        handle: File.Handle,
+        io: Io,
+        file: File,
         reset_attributes: u16,
     };
 
@@ -65,20 +66,21 @@ pub const Mode = union(enum) {
         }
 
         if (is_windows and try file.isTty(io)) {
-            const windows = std.os.windows;
-            var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
-            if (windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) != 0) {
-                return .{ .windows_api = .{
-                    .handle = file.handle,
-                    .reset_attributes = info.wAttributes,
-                } };
+            var get_console_info = std.os.windows.CONSOLE.USER_IO.GET_SCREEN_BUFFER_INFO;
+            switch (try get_console_info.operate(io, file)) {
+                .SUCCESS => return .{ .windows_api = .{
+                    .io = io,
+                    .file = file,
+                    .reset_attributes = get_console_info.Data.wAttributes,
+                } },
+                else => {},
             }
         }
         return if (force_color == true) .escape_codes else .no_color;
     }
 };
 
-pub const SetColorError = std.os.windows.SetConsoleTextAttributeError || Io.Writer.Error;
+pub const SetColorError = Io.Cancelable || Io.UnexpectedError || Io.Writer.Error;
 
 pub fn setColor(t: Terminal, color: Color) SetColorError!void {
     switch (t.mode) {
@@ -132,7 +134,11 @@ pub fn setColor(t: Terminal, color: Color) SetColorError!void {
                 .reset => wa.reset_attributes,
             };
             try t.writer.flush();
-            try windows.SetConsoleTextAttribute(wa.handle, attributes);
+            var set_text_attribute = windows.CONSOLE.USER_IO.SET_TEXT_ATTRIBUTE(attributes);
+            switch (try set_text_attribute.operate(wa.io, wa.file)) {
+                .SUCCESS => {},
+                else => |status| return windows.unexpectedStatus(status),
+            }
         },
     }
 }
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c467615f9cb2579c6e0ac539eb735515d3e723ab..ab2e9af75765de1f30b6fa6c2f087921ffa54e9b 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3083,19 +3083,23 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
                 }
             },
             .device_io_control => |o| {
+                const NtControlFile = switch (o.code.DeviceType) {
+                    .FILE_SYSTEM, .NAMED_PIPE => &windows.ntdll.NtFsControlFile,
+                    else => &windows.ntdll.NtDeviceIoControlFile,
+                };
                 if (o.file.flags.nonblocking) {
                     context.file = o.file.handle;
-                    switch (windows.ntdll.NtDeviceIoControlFile(
+                    switch (NtControlFile(
                         o.file.handle,
                         null, // event
                         &batchApc,
                         b,
                         &context.iosb,
-                        o.IoControlCode,
-                        o.InputBuffer,
-                        o.InputBufferLength,
-                        o.OutputBuffer,
-                        o.OutputBufferLength,
+                        o.code,
+                        if (o.in.len > 0) o.in.ptr else null,
+                        @intCast(o.in.len),
+                        if (o.out.len > 0) o.out.ptr else null,
+                        @intCast(o.out.len),
                     )) {
                         .PENDING, .SUCCESS => {},
                         .CANCELLED => unreachable,
@@ -3108,17 +3112,17 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
                     if (concurrency) return error.ConcurrencyUnavailable;
 
                     const syscall: Syscall = try .start();
-                    while (true) switch (windows.ntdll.NtDeviceIoControlFile(
+                    while (true) switch (NtControlFile(
                         o.file.handle,
                         null, // event
                         null, // APC routine
                         null, // APC context
                         &context.iosb,
-                        o.IoControlCode,
-                        o.InputBuffer,
-                        o.InputBufferLength,
-                        o.OutputBuffer,
-                        o.OutputBufferLength,
+                        o.code,
+                        if (o.in.len > 0) o.in.ptr else null,
+                        @intCast(o.in.len),
+                        if (o.out.len > 0) o.out.ptr else null,
+                        @intCast(o.out.len),
                     )) {
                         .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
                         .CANCELLED => {
@@ -8547,29 +8551,24 @@ fn fileSyncWasi(userdata: ?*anyopaque, file: File) File.SyncError!void {
 
 fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-    return isTty(file);
+    return t.isTty(file);
 }
 
-fn isTty(file: File) Io.Cancelable!bool {
+fn isTty(t: *Threaded, file: File) Io.Cancelable!bool {
     if (is_windows) {
-        if (try isCygwinPty(file)) return true;
-        var out: windows.DWORD = undefined;
-        const syscall: Syscall = try .start();
-        while (windows.kernel32.GetConsoleMode(file.handle, &out) == 0) {
-            switch (windows.GetLastError()) {
-                .OPERATION_ABORTED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => {
-                    syscall.finish();
-                    return false;
-                },
-            }
+        var get_console_mode = windows.CONSOLE.USER_IO.GET_MODE;
+        switch ((try t.deviceIoControl(&.{
+            .file = .{
+                .handle = windows.peb().ProcessParameters.ConsoleHandle,
+                .flags = .{ .nonblocking = false },
+            },
+            .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
+            .in = @ptrCast(&get_console_mode.request(file, 0, .{}, 0, .{})),
+        })).u.Status) {
+            .SUCCESS => return true,
+            .INVALID_HANDLE => return isCygwinPty(file),
+            else => return false,
         }
-        syscall.finish();
-        return true;
     }
 
     if (builtin.link_libc) {
@@ -8637,35 +8636,26 @@ fn isTty(file: File) Io.Cancelable!bool {
 
 fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
 
-    if (!is_windows) {
-        if (try supportsAnsiEscapeCodes(file)) return;
-        return error.NotTerminalDevice;
-    }
+    if (!is_windows) return if (!try t.supportsAnsiEscapeCodes(file)) error.NotTerminalDevice;
 
     // For Windows Terminal, VT Sequences processing is enabled by default.
-    var original_console_mode: windows.DWORD = 0;
-
-    {
-        const syscall: Syscall = try .start();
-        while (windows.kernel32.GetConsoleMode(file.handle, &original_console_mode) == 0) {
-            switch (windows.GetLastError()) {
-                .OPERATION_ABORTED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => {
-                    syscall.finish();
-                    if (try isCygwinPty(file)) return;
-                    return error.NotTerminalDevice;
-                },
-            }
-        }
-        syscall.finish();
+    const console: File = .{
+        .handle = windows.peb().ProcessParameters.ConsoleHandle,
+        .flags = .{ .nonblocking = false },
+    };
+    var get_console_mode = windows.CONSOLE.USER_IO.GET_MODE;
+    switch ((try t.deviceIoControl(&.{
+        .file = console,
+        .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
+        .in = @ptrCast(&get_console_mode.request(file, 0, .{}, 0, .{})),
+    })).u.Status) {
+        .SUCCESS => {},
+        .INVALID_HANDLE => return if (!try isCygwinPty(file)) error.NotTerminalDevice,
+        else => return error.NotTerminalDevice,
     }
 
-    if (original_console_mode & windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0) return;
+    if (get_console_mode.Data & windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0) return;
 
     // For Windows Console, VT Sequences processing support was added in Windows 10 build 14361, but disabled by default.
     // https://devblogs.microsoft.com/commandline/tmux-support-arrives-for-bash-on-ubuntu-on-windows/
@@ -8678,58 +8668,40 @@ fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiE
     // Additionally, the default console mode in Windows Terminal does not have
     // `DISABLE_NEWLINE_AUTO_RETURN` set, so by only enabling `ENABLE_VIRTUAL_TERMINAL_PROCESSING`
     // we end up matching the mode of Windows Terminal.
-    const requested_console_modes = windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-    const console_mode = original_console_mode | requested_console_modes;
-
-    {
-        const syscall: Syscall = try .start();
-        while (windows.kernel32.SetConsoleMode(file.handle, console_mode) == 0) {
-            switch (windows.GetLastError()) {
-                .OPERATION_ABORTED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => {
-                    syscall.finish();
-                    if (try isCygwinPty(file)) return;
-                    return error.NotTerminalDevice;
-                },
-            }
-        }
-        syscall.finish();
+    var set_console_mode = windows.CONSOLE.USER_IO.SET_MODE(
+        get_console_mode.Data | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+    );
+    switch ((try t.deviceIoControl(&.{
+        .file = console,
+        .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
+        .in = @ptrCast(&set_console_mode.request(file, 0, .{}, 0, .{})),
+    })).u.Status) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
     }
 }
 
 fn fileSupportsAnsiEscapeCodes(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-    return supportsAnsiEscapeCodes(file);
+    return t.supportsAnsiEscapeCodes(file);
 }
 
-fn supportsAnsiEscapeCodes(file: File) Io.Cancelable!bool {
+fn supportsAnsiEscapeCodes(t: *Threaded, file: File) Io.Cancelable!bool {
     if (is_windows) {
-        var console_mode: windows.DWORD = 0;
-
-        const syscall: Syscall = try .start();
-        while (windows.kernel32.GetConsoleMode(file.handle, &console_mode) == 0) {
-            switch (windows.GetLastError()) {
-                .OPERATION_ABORTED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => {
-                    syscall.finish();
-                    break;
-                },
-            }
-        } else {
-            syscall.finish();
-            if (console_mode & windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0) {
-                return true;
-            }
+        var get_console_mode = windows.CONSOLE.USER_IO.GET_MODE;
+        switch ((try t.deviceIoControl(&.{
+            .file = .{
+                .handle = windows.peb().ProcessParameters.ConsoleHandle,
+                .flags = .{ .nonblocking = false },
+            },
+            .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
+            .in = @ptrCast(&get_console_mode.request(file, 0, .{}, 0, .{})),
+        })).u.Status) {
+            .SUCCESS => if (get_console_mode.Data & windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0)
+                return true,
+            .INVALID_HANDLE => return isCygwinPty(file),
+            else => return false,
         }
-
-        return isCygwinPty(file);
     }
 
     if (native_os == .wasi) {
@@ -8739,7 +8711,7 @@ fn supportsAnsiEscapeCodes(file: File) Io.Cancelable!bool {
         return false;
     }
 
-    if (try isTty(file)) return true;
+    if (try t.isTty(file)) return true;
 
     return false;
 }
@@ -14111,12 +14083,14 @@ fn initLockedStderr(t: *Threaded, terminal_mode: ?Io.Terminal.Mode) Io.Cancelabl
 
 fn unlockStderr(userdata: ?*anyopaque) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    t.stderr_writer.interface.flush() catch |err| switch (err) {
-        error.WriteFailed => switch (t.stderr_writer.err.?) {
+    if (t.stderr_writer.err == null) t.stderr_writer.interface.flush() catch {};
+    if (t.stderr_writer.err) |err| {
+        switch (err) {
             error.Canceled => recancelInner(),
             else => {},
-        },
-    };
+        }
+        t.stderr_writer.err = null;
+    }
     t.stderr_writer.interface.end = 0;
     t.stderr_writer.interface.buffer = &.{};
 
@@ -18848,20 +18822,24 @@ fn mmSyncWrite(file: File, memory: []u8, offset: u64) File.WritePositionalError!
 fn deviceIoControl(t: *Threaded, o: *const Io.Operation.DeviceIoControl) Io.Cancelable!Io.Operation.DeviceIoControl.Result {
     _ = t;
     if (is_windows) {
+        const NtControlFile = switch (o.code.DeviceType) {
+            .FILE_SYSTEM, .NAMED_PIPE => &windows.ntdll.NtFsControlFile,
+            else => &windows.ntdll.NtDeviceIoControlFile,
+        };
         var iosb: windows.IO_STATUS_BLOCK = undefined;
         if (o.file.flags.nonblocking) {
             var done: bool = false;
-            switch (windows.ntdll.NtDeviceIoControlFile(
+            switch (NtControlFile(
                 o.file.handle,
                 null, // event
                 flagApc,
                 &done, // APC context
                 &iosb,
-                o.IoControlCode,
-                o.InputBuffer,
-                o.InputBufferLength,
-                o.OutputBuffer,
-                o.OutputBufferLength,
+                o.code,
+                if (o.in.len > 0) o.in.ptr else null,
+                @intCast(o.in.len),
+                if (o.out.len > 0) o.out.ptr else null,
+                @intCast(o.out.len),
             )) {
                 // We must wait for the APC routine.
                 .PENDING, .SUCCESS => while (!done) {
@@ -18882,17 +18860,17 @@ fn deviceIoControl(t: *Threaded, o: *const Io.Operation.DeviceIoControl) Io.Canc
             }
         } else {
             const syscall: Syscall = try .start();
-            while (true) switch (windows.ntdll.NtDeviceIoControlFile(
+            while (true) switch (NtControlFile(
                 o.file.handle,
                 null, // event
                 null, // APC routine
                 null, // APC context
                 &iosb,
-                o.IoControlCode,
-                o.InputBuffer,
-                o.InputBufferLength,
-                o.OutputBuffer,
-                o.OutputBufferLength,
+                o.code,
+                if (o.in.len > 0) o.in.ptr else null,
+                @intCast(o.in.len),
+                if (o.out.len > 0) o.out.ptr else null,
+                @intCast(o.out.len),
             )) {
                 .PENDING => unreachable, // unrecoverable: wrong asynchronous flag
                 .CANCELLED => {
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index f17fed0a5bc20a5810ceec5853e478a4bf11321a..2240f95fddd65b97681d6803f4e9ffef0d0c8369 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -157,7 +157,7 @@ pub const TerminalMode = union(enum) {
     ansi_escape_codes,
     /// This is not the same as being run on windows because other terminals
     /// exist like MSYS/git-bash.
-    windows_api: if (is_windows) WindowsApi else void,
+    windows_api: if (is_windows) WindowsApi else noreturn,
 
     pub const WindowsApi = struct {
         /// The output code page of the console.
@@ -614,33 +614,39 @@ pub fn start(io: Io, options: Options) Node {
             if (stderr.enableAnsiEscapeCodes(io)) |_| {
                 global_progress.terminal_mode = .ansi_escape_codes;
             } else |_| if (is_windows) {
-                if (stderr.isTty(io)) |is_tty| {
-                    if (is_tty) global_progress.terminal_mode = TerminalMode{ .windows_api = .{
-                        .code_page = windows.kernel32.GetConsoleOutputCP(),
-                    } };
-                } else |err| switch (err) {
+                var get_console_cp = windows.CONSOLE.USER_IO.GET_CP(.Output);
+                // Normally, we would pass `null` to `operate` here as the kernel32
+                // function does not accept a handle, however, if we pass one anyway,
+                // then we will get an error if the handle is not associated with
+                // this process's console, effectively combining an `isTty` check
+                // into the same syscall.
+                switch (get_console_cp.operate(io, stderr) catch |err| switch (err) {
                     error.Canceled => {
                         io.recancel();
                         return .none;
                     },
+                }) {
+                    .SUCCESS => global_progress.terminal_mode = .{ .windows_api = .{
+                        .code_page = get_console_cp.Data.CodePage,
+                    } },
+                    .INVALID_HANDLE => {},
+                    else => {},
                 }
             }
-
-            if (global_progress.terminal_mode == .off) return .none;
-
-            if (have_sigwinch) {
-                const act: posix.Sigaction = .{
-                    .handler = .{ .sigaction = handleSigWinch },
-                    .mask = posix.sigemptyset(),
-                    .flags = (posix.SA.SIGINFO | posix.SA.RESTART),
-                };
-                posix.sigaction(.WINCH, &act, null);
-            }
-
-            if (switch (global_progress.terminal_mode) {
-                .off => unreachable, // handled a few lines above
-                .ansi_escape_codes => io.concurrent(updateTask, .{io}),
-                .windows_api => if (is_windows) io.concurrent(windowsApiUpdateTask, .{io}) else unreachable,
+            if (future: switch (global_progress.terminal_mode) {
+                .off => return .none,
+                .ansi_escape_codes => {
+                    if (have_sigwinch) {
+                        const act: posix.Sigaction = .{
+                            .handler = .{ .sigaction = handleSigWinch },
+                            .mask = posix.sigemptyset(),
+                            .flags = (posix.SA.SIGINFO | posix.SA.RESTART),
+                        };
+                        posix.sigaction(.WINCH, &act, null);
+                    }
+                    break :future io.concurrent(updateTask, .{io});
+                },
+                .windows_api => io.concurrent(windowsApiUpdateTask, .{io}),
             }) |future| {
                 global_progress.update_worker = future;
             } else |err| {
@@ -715,12 +721,24 @@ fn updateTask(io: Io) WorkerError!void {
     }
 }
 
-fn windowsApiWriteMarker() void {
+const WindowsApiError = Io.Cancelable || Io.UnexpectedError;
+
+fn windowsApiWriteMarker(io: Io) WindowsApiError!void {
     // Write the marker that we will use to find the beginning of the progress when clearing.
     // Note: This doesn't have to use WriteConsoleW, but doing so avoids dealing with the code page.
-    var num_chars_written: windows.DWORD = undefined;
-    const handle = global_progress.terminal.handle;
-    _ = windows.kernel32.WriteConsoleW(handle, &[_]u16{windows_api_start_marker}, 1, &num_chars_written, null);
+    const terminal = global_progress.terminal;
+    var write_console = windows.CONSOLE.USER_IO.WRITE(.WideCharacter);
+    const buffer = [1]windows.WCHAR{windows_api_start_marker};
+    switch ((try io.operate(.{ .device_io_control = .{
+        .file = terminal,
+        .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
+        .in = @ptrCast(&write_console.request(null, 1, .{
+            .{ .Size = @sizeOf(@TypeOf(buffer)), .Pointer = &buffer },
+        }, 0, .{})),
+    } })).device_io_control.u.Status) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
+    }
 }
 
 fn windowsApiUpdateTask(io: Io) WorkerError!void {
@@ -743,19 +761,19 @@ fn windowsApiUpdateTask(io: Io) WorkerError!void {
             error.Canceled => unreachable, // blocked
         };
         defer io.unlockStderr();
-        clearWrittenWindowsApi() catch {};
+        clearWrittenWindowsApi(io) catch {};
     }
     while (true) {
         const buffer, const nl_n = try computeRedraw(io, &serialized_buffer);
         if (io.vtable.tryLockStderr(io.userdata, null) catch return) |locked_stderr| {
             defer io.unlockStderr();
-            try clearWrittenWindowsApi();
-            windowsApiWriteMarker();
+            try clearWrittenWindowsApi(io);
+            try windowsApiWriteMarker(io);
             global_progress.need_clear = true;
             locked_stderr.file_writer.interface.writeAll(buffer) catch |err| switch (err) {
                 error.WriteFailed => return locked_stderr.file_writer.err.?,
             };
-            windowsApiMoveToMarker(nl_n) catch return;
+            windowsApiMoveToMarker(io, nl_n) catch return;
         }
 
         try maybeUpdateSize(io, try wait(io, global_progress.refresh_rate_ns));
@@ -859,7 +877,7 @@ fn appendTreeSymbol(symbol: TreeSymbol, buf: []u8, start_i: usize) usize {
             return start_i + bytes.len;
         },
         .windows_api => |windows_api| {
-            const bytes = if (!is_windows) unreachable else switch (windows_api.code_page) {
+            const bytes = switch (windows_api.code_page) {
                 // Code page 437 is the default code page and contains the box drawing symbols
                 437 => symbol.bytes(.code_page_437),
                 // UTF-8
@@ -882,7 +900,7 @@ pub fn clearWrittenWithEscapeCodes(file_writer: *Io.File.Writer) Io.Writer.Error
 /// U+25BA or ►
 const windows_api_start_marker = 0x25BA;
 
-fn clearWrittenWindowsApi() error{Unexpected}!void {
+fn clearWrittenWindowsApi(io: Io) WindowsApiError!void {
     // This uses a 'marker' strategy. The idea is:
     // - Always write a marker (in this case U+25BA or ►) at the beginning of the progress
     // - Get the current cursor position (at the end of the progress)
@@ -903,43 +921,60 @@ fn clearWrittenWindowsApi() error{Unexpected}!void {
     //   character in order to be readable via ReadConsoleOutputAttribute. It doesn't seem
     //   like any of the available attributes are invisible/benign.
     if (!global_progress.need_clear) return;
-    const handle = global_progress.terminal.handle;
+    const terminal = global_progress.terminal;
     const screen_area = @as(windows.DWORD, global_progress.cols) * global_progress.rows;
 
-    var console_info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
-    if (windows.kernel32.GetConsoleScreenBufferInfo(handle, &console_info) == 0) {
-        return error.Unexpected;
+    var get_console_info = windows.CONSOLE.USER_IO.GET_SCREEN_BUFFER_INFO;
+    switch (try get_console_info.operate(io, terminal)) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
     }
-    var num_chars_written: windows.DWORD = undefined;
-    if (windows.kernel32.FillConsoleOutputCharacterW(handle, ' ', screen_area, console_info.dwCursorPosition, &num_chars_written) == 0) {
-        return error.Unexpected;
+    var fill_spaces = windows.CONSOLE.USER_IO.FILL(
+        .{ .WideCharacter = ' ' },
+        screen_area,
+        get_console_info.Data.dwCursorPosition,
+    );
+    switch (try fill_spaces.operate(io, terminal)) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
     }
 }
 
-fn windowsApiMoveToMarker(nl_n: usize) error{Unexpected}!void {
-    const handle = global_progress.terminal.handle;
-    var console_info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
-    if (windows.kernel32.GetConsoleScreenBufferInfo(handle, &console_info) == 0) {
-        return error.Unexpected;
+fn windowsApiMoveToMarker(io: Io, nl_n: usize) WindowsApiError!void {
+    const terminal = global_progress.terminal;
+    var get_console_info = windows.CONSOLE.USER_IO.GET_SCREEN_BUFFER_INFO;
+    switch (try get_console_info.operate(io, terminal)) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
     }
-    const cursor_pos = console_info.dwCursorPosition;
+    const cursor_pos = get_console_info.Data.dwCursorPosition;
     const expected_y = cursor_pos.Y - @as(i16, @intCast(nl_n));
     var start_pos: windows.COORD = .{ .X = 0, .Y = expected_y };
-    while (start_pos.Y >= 0) {
-        var wchar: [1]u16 = undefined;
-        var num_console_chars_read: windows.DWORD = undefined;
-        if (windows.kernel32.ReadConsoleOutputCharacterW(handle, &wchar, wchar.len, start_pos, &num_console_chars_read) == 0) {
-            return error.Unexpected;
+    while (start_pos.Y >= 0) : (start_pos.Y -= 1) {
+        var read_output_char = windows.CONSOLE.USER_IO.READ_OUTPUT_CHARACTER(start_pos, .WideCharacter);
+        var buffer: [1]windows.WCHAR = undefined;
+        switch ((try io.operate(.{ .device_io_control = .{
+            .file = .{
+                .handle = windows.peb().ProcessParameters.ConsoleHandle,
+                .flags = .{ .nonblocking = false },
+            },
+            .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
+            .in = @ptrCast(&read_output_char.request(terminal, 0, .{}, 1, .{
+                .{ .Size = @sizeOf(@TypeOf(buffer)), .Pointer = &buffer },
+            })),
+        } })).device_io_control.u.Status) {
+            .SUCCESS => {},
+            else => |status| return windows.unexpectedStatus(status),
         }
-
-        if (wchar[0] == windows_api_start_marker) break;
-        start_pos.Y -= 1;
+        if (read_output_char.Data.nLength >= 1 and buffer[0] == windows_api_start_marker) break;
     } else {
         // If we couldn't find the marker, then just assume that no lines wrapped
         start_pos = .{ .X = 0, .Y = expected_y };
     }
-    if (windows.kernel32.SetConsoleCursorPosition(handle, start_pos) == 0) {
-        return error.Unexpected;
+    var set_cursor_position = windows.CONSOLE.USER_IO.SET_CURSOR_POSITION(start_pos);
+    switch (try set_cursor_position.operate(io, terminal)) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
     }
 }
 
@@ -1279,7 +1314,7 @@ fn computeRedraw(io: Io, serialized_buffer: *Serialized.Buffer) !struct { []u8,
             buf[i..][0..clear.len].* = clear.*;
             i += clear.len;
         },
-        .windows_api => if (!is_windows) unreachable,
+        .windows_api => {},
     }
 
     const root_node_index: Node.Index = @enumFromInt(0);
@@ -1491,19 +1526,17 @@ fn maybeUpdateSize(io: Io, resize_flag: bool) !void {
     const file = global_progress.terminal;
 
     if (is_windows) {
-        var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
-
-        if (windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) != windows.FALSE) {
-            // In the old Windows console, dwSize.Y is the line count of the
-            // entire scrollback buffer, so we use this instead so that we
-            // always get the size of the screen.
-            const screen_height = info.srWindow.Bottom - info.srWindow.Top;
-            global_progress.rows = @intCast(screen_height);
-            global_progress.cols = @intCast(info.dwSize.X);
-        } else {
-            std.log.debug("failed to determine terminal size; using conservative guess 80x25", .{});
-            global_progress.rows = 25;
-            global_progress.cols = 80;
+        var get_console_info = windows.CONSOLE.USER_IO.GET_SCREEN_BUFFER_INFO;
+        switch (try get_console_info.operate(io, file)) {
+            .SUCCESS => {
+                global_progress.rows = @intCast(get_console_info.Data.dwWindowSize.Y);
+                global_progress.cols = @intCast(get_console_info.Data.dwWindowSize.X);
+            },
+            else => {
+                std.log.debug("failed to determine terminal size; using conservative guess 80x25", .{});
+                global_progress.rows = 25;
+                global_progress.cols = 80;
+            },
         }
     } else {
         var winsize: posix.winsize = .{
diff --git a/lib/std/log.zig b/lib/std/log.zig
index df11fe205b4cefce36bc9d666e4d3718416bccf8..f66cb4e04d1550a7f6825cfcbc03f61ee2438cb3 100644
--- a/lib/std/log.zig
+++ b/lib/std/log.zig
@@ -80,7 +80,7 @@ pub fn logEnabled(comptime level: Level, comptime scope: @EnumLiteral()) bool {
     return @intFromEnum(level) <= @intFromEnum(std.options.log_level);
 }
 
-pub const terminalMode = std.options.logTerminalMode;
+pub const terminalMode = std.Options.logTerminalMode;
 
 pub fn defaultTerminalMode() std.Io.Terminal.Mode {
     const stderr = std.debug.lockStderr(&.{}).terminal();
@@ -99,6 +99,9 @@ pub fn defaultLog(
     comptime format: []const u8,
     args: anytype,
 ) void {
+    const io = std.Options.debug_io;
+    const prev = io.swapCancelProtection(.blocked);
+    defer _ = io.swapCancelProtection(prev);
     var buffer: [64]u8 = undefined;
     const stderr = std.debug.lockStderr(&buffer).terminal();
     defer std.debug.unlockStderr();
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 0180138a0fbb4c7258181ed1d7ee6a572eb40db6..86d4ce0efd3b8170ef819544d41f2ccc16351be3 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -649,6 +649,235 @@ pub const FILE = struct {
     };
 };
 
+pub const CONSOLE = struct {
+    pub const USER_IO = struct {
+        pub const INFO = struct {
+            pub const CP = extern struct {
+                /// GetCP: output
+                /// SetCP: input
+                CodePage: UINT,
+                /// input
+                Mode: MODE,
+
+                pub const MODE = enum(BOOLEAN) {
+                    Input = FALSE,
+                    Output = TRUE,
+                };
+            };
+
+            pub const WRITE = extern struct {
+                /// output, in bytes
+                Size: DWORD,
+                /// input
+                Mode: MODE,
+
+                pub const MODE = enum(BOOLEAN) {
+                    Character = FALSE,
+                    WideCharacter = TRUE,
+                };
+            };
+
+            pub const FILL = extern struct {
+                /// input
+                dwWriteCoord: COORD,
+                /// input
+                Tag: WITH.Tag,
+                /// input
+                With: WITH.Payload,
+                /// input/output, in characters
+                nLength: DWORD,
+
+                pub const WITH = union(enum(DWORD)) {
+                    Character: CHAR = 1,
+                    WideCharacter: WCHAR = 2,
+                    Attribute: WORD = 3,
+
+                    pub const Tag = @typeInfo(WITH).@"union".tag_type.?;
+                    pub const Payload = PAYLOAD: {
+                        const with_fields = @typeInfo(WITH).@"union".fields;
+                        var field_names: [with_fields.len][]const u8 = undefined;
+                        var field_types: [with_fields.len]type = undefined;
+                        for (with_fields, &field_names, &field_types) |field, *field_name, *field_type| {
+                            field_name.* = field.name;
+                            field_type.* = field.type;
+                        }
+                        break :PAYLOAD @Union(.@"extern", null, &field_names, &field_types, &@splat(.{}));
+                    };
+                };
+            };
+
+            /// all output
+            pub const SCREEN_BUFFER = extern struct {
+                dwSize: COORD,
+                dwCursorPosition: COORD,
+                dwWindowPosition: COORD,
+                wAttributes: WORD,
+                dwWindowSize: COORD,
+                dwMaximumWindowSize: COORD,
+                wPopupAttributes: WORD,
+                bFullscreenSupported: BOOL,
+                ColorTable: [16]COLORREF,
+            };
+
+            pub const READ_OUTPUT_CHARACTER = extern struct {
+                /// input
+                dwReadCoord: COORD,
+                Mode: MODE,
+                /// output, in characters
+                nLength: DWORD,
+
+                pub const MODE = enum(DWORD) {
+                    Character = 1,
+                    WideCharacter = 2,
+                };
+            };
+        };
+
+        pub fn GET_CP(mode: INFO.CP.MODE) Header.With(INFO.CP) {
+            return .init(.GetCP, .{ .CodePage = undefined, .Mode = mode });
+        }
+        pub const GET_MODE: Header.With(DWORD) = .init(.GetMode, undefined);
+        pub fn SET_MODE(mode: DWORD) Header.With(DWORD) {
+            return .init(.SetMode, mode);
+        }
+        pub fn WRITE(mode: INFO.WRITE.MODE) Header.With(INFO.WRITE) {
+            return .init(.Write, .{ .Size = undefined, .Mode = mode });
+        }
+        pub fn FILL(with: INFO.FILL.WITH, len: DWORD, coord: COORD) Header.With(INFO.FILL) {
+            return .init(.Fill, .{
+                .dwWriteCoord = coord,
+                .Tag = with,
+                .With = switch (with) {
+                    inline else => |payload, tag| @unionInit(
+                        INFO.FILL.WITH.Payload,
+                        @tagName(tag),
+                        payload,
+                    ),
+                },
+                .nLength = len,
+            });
+        }
+        pub fn SET_CP(mode: INFO.CP.MODE, cp: UINT) Header.With(INFO.CP) {
+            return .init(.SetCP, .{ .CodePage = cp, .Mode = mode });
+        }
+        pub const GET_SCREEN_BUFFER_INFO: Header.With(INFO.SCREEN_BUFFER) =
+            .init(.GetScreenBufferInfo, undefined);
+        pub fn SET_CURSOR_POSITION(coord: COORD) Header.With(COORD) {
+            return .init(.SetCursorPosition, coord);
+        }
+        pub fn SET_TEXT_ATTRIBUTE(attribute: WORD) Header.With(WORD) {
+            return .init(.SetTextAttribute, attribute);
+        }
+        pub fn READ_OUTPUT_CHARACTER(
+            coord: COORD,
+            mode: INFO.READ_OUTPUT_CHARACTER.MODE,
+        ) Header.With(INFO.READ_OUTPUT_CHARACTER) {
+            return .init(.ReadOutputCharacter, .{
+                .dwReadCoord = coord,
+                .Mode = mode,
+                .nLength = undefined,
+            });
+        }
+
+        pub const InputBuffer = extern struct {
+            Size: u32,
+            Pointer: *const anyopaque,
+        };
+
+        pub const OutputBuffer = extern struct {
+            Size: u32,
+            Pointer: *anyopaque,
+        };
+
+        pub fn Request(comptime in_len: u32, comptime out_len: u32) type {
+            return extern struct {
+                Handle: ?HANDLE,
+                InputBuffersLength: u32,
+                OutputBuffersLength: u32,
+                InputBuffers: [in_len]InputBuffer,
+                OutputBuffers: [out_len]OutputBuffer,
+
+                pub fn init(
+                    handle: ?HANDLE,
+                    in: [in_len]InputBuffer,
+                    out: [out_len]OutputBuffer,
+                ) @This() {
+                    return .{
+                        .Handle = handle,
+                        .InputBuffersLength = in_len,
+                        .OutputBuffersLength = out_len,
+                        .InputBuffers = in,
+                        .OutputBuffers = out,
+                    };
+                }
+            };
+        }
+
+        pub const Header = extern struct {
+            Operation: Operation,
+            Size: u32,
+
+            pub fn With(comptime Data: type) type {
+                return extern struct {
+                    Header: Header,
+                    Data: Data,
+
+                    pub fn init(operation: Operation, data: Data) @This() {
+                        return .{
+                            .Header = .{ .Operation = operation, .Size = @sizeOf(Data) },
+                            .Data = data,
+                        };
+                    }
+
+                    pub fn request(
+                        with: *@This(),
+                        file: ?Io.File,
+                        comptime in_len: u32,
+                        in: [in_len]InputBuffer,
+                        comptime out_len: u32,
+                        out: [out_len]OutputBuffer,
+                    ) Request(1 + in_len, 1 + out_len) {
+                        return .init(
+                            if (file) |f| f.handle else null,
+                            [1]InputBuffer{.{
+                                .Size = @offsetOf(@This(), "Data") + @sizeOf(Data),
+                                .Pointer = with,
+                            }} ++ in,
+                            [1]OutputBuffer{.{ .Size = @sizeOf(Data), .Pointer = &with.Data }} ++ out,
+                        );
+                    }
+
+                    pub fn operate(with: *@This(), io: Io, file: ?Io.File) Io.Cancelable!NTSTATUS {
+                        return (try io.operate(.{ .device_io_control = .{
+                            .file = .{
+                                .handle = peb().ProcessParameters.ConsoleHandle,
+                                .flags = .{ .nonblocking = false },
+                            },
+                            .code = IOCTL.CONDRV.ISSUE_USER_IO,
+                            .in = @ptrCast(&with.request(file, 0, .{}, 0, .{})),
+                        } })).device_io_control.u.Status;
+                    }
+                };
+            }
+        };
+
+        pub const Operation = enum(u32) {
+            GetCP = 0x1000000,
+            GetMode = 0x1000001,
+            SetMode = 0x1000002,
+            Read = 0x1000005,
+            Write = 0x1000006,
+            Fill = 0x2000000,
+            SetCP = 0x2000004,
+            GetScreenBufferInfo = 0x2000007,
+            SetCursorPosition = 0x200000a,
+            SetTextAttribute = 0x200000d,
+            ReadOutputCharacter = 0x200000f,
+            _,
+        };
+    };
+};
+
 // ref: km/ntddk.h
 
 pub const PROCESSINFOCLASS = enum(c_int) {
@@ -1160,6 +1389,22 @@ pub const CTL_CODE = packed struct(ULONG) {
 };
 
 pub const IOCTL = struct {
+    pub const CONDRV = struct {
+        pub const READ_IO: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 1, .Method = .OUT_DIRECT, .Access = .ANY };
+        pub const COMPLETE_IO: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 2, .Method = .NEITHER, .Access = .ANY };
+        pub const READ_INPUT: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 3, .Method = .NEITHER, .Access = .ANY };
+        pub const WRITE_OUTPUT: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 4, .Method = .NEITHER, .Access = .ANY };
+        pub const ISSUE_USER_IO: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 5, .Method = .OUT_DIRECT, .Access = .ANY };
+        pub const DISCONNECT_PIPE: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 6, .Method = .NEITHER, .Access = .ANY };
+        pub const SET_SERVER_INFORMATION: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 7, .Method = .NEITHER, .Access = .ANY };
+        pub const GET_SERVER_PID: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 8, .Method = .NEITHER, .Access = .ANY };
+        pub const GET_DISPLAY_SIZE: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 9, .Method = .NEITHER, .Access = .ANY };
+        pub const UPDATE_DISPLAY: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 10, .Method = .NEITHER, .Access = .ANY };
+        pub const SET_CURSOR: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 11, .Method = .NEITHER, .Access = .ANY };
+        pub const ALLOW_VIA_UIACCESS: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 12, .Method = .NEITHER, .Access = .ANY };
+        pub const LAUNCH_SERVER: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 13, .Method = .NEITHER, .Access = .ANY };
+        pub const GET_FONT_SIZE: CTL_CODE = .{ .DeviceType = .CONSOLE, .Function = 14, .Method = .NEITHER, .Access = .ANY };
+    };
     pub const KSEC = struct {
         pub const GEN_RANDOM: CTL_CODE = .{ .DeviceType = .KSEC, .Function = 2, .Method = .BUFFERED, .Access = .ANY };
     };
@@ -2663,29 +2908,6 @@ pub fn NtFreeVirtualMemory(hProcess: HANDLE, addr: ?*PVOID, size: *SIZE_T, free_
     };
 }
 
-pub const SetConsoleTextAttributeError = error{Unexpected};
-
-pub fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) SetConsoleTextAttributeError!void {
-    if (kernel32.SetConsoleTextAttribute(hConsoleOutput, wAttributes) == 0) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-}
-
-pub fn SetConsoleCtrlHandler(handler_routine: ?HANDLER_ROUTINE, add: bool) !void {
-    const success = kernel32.SetConsoleCtrlHandler(
-        handler_routine,
-        if (add) TRUE else FALSE,
-    );
-
-    if (success == FALSE) {
-        return switch (GetLastError()) {
-            else => |err| unexpectedError(err),
-        };
-    }
-}
-
 pub fn SetFileCompletionNotificationModes(handle: HANDLE, flags: UCHAR) !void {
     const success = kernel32.SetFileCompletionNotificationModes(handle, flags);
     if (success == FALSE) {
@@ -3244,6 +3466,7 @@ pub const ULONGLONG = u64;
 pub const LONGLONG = i64;
 pub const HLOCAL = HANDLE;
 pub const LANGID = c_ushort;
+pub const COLORREF = DWORD;
 
 pub const WPARAM = usize;
 pub const LPARAM = LONG_PTR;
@@ -3784,21 +4007,17 @@ pub const FileNotifyChangeFilter = packed struct(DWORD) {
     _pad: u20 = 0,
 };
 
-pub const CONSOLE_SCREEN_BUFFER_INFO = extern struct {
-    dwSize: COORD,
-    dwCursorPosition: COORD,
-    wAttributes: WORD,
-    srWindow: SMALL_RECT,
-    dwMaximumWindowSize: COORD,
-};
-
 pub const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4;
 pub const DISABLE_NEWLINE_AUTO_RETURN = 0x8;
 
-pub const FOREGROUND_BLUE = 1;
-pub const FOREGROUND_GREEN = 2;
-pub const FOREGROUND_RED = 4;
-pub const FOREGROUND_INTENSITY = 8;
+pub const FOREGROUND_BLUE = 0x0001;
+pub const FOREGROUND_GREEN = 0x0002;
+pub const FOREGROUND_RED = 0x0004;
+pub const FOREGROUND_INTENSITY = 0x0008;
+pub const BACKGROUND_BLUE = 0x0010;
+pub const BACKGROUND_GREEN = 0x0020;
+pub const BACKGROUND_RED = 0x0040;
+pub const BACKGROUND_INTENSITY = 0x0080;
 
 pub const LIST_ENTRY = extern struct {
     Flink: *LIST_ENTRY,
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index d6af93cfc3add89352135762670270333ef7147c..ed9af392a3a09b5ba649f965f6ff1798eada944d 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -4,7 +4,6 @@ const windows = std.os.windows;
 const ACCESS_MASK = windows.ACCESS_MASK;
 const BOOL = windows.BOOL;
 const CONDITION_VARIABLE = windows.CONDITION_VARIABLE;
-const CONSOLE_SCREEN_BUFFER_INFO = windows.CONSOLE_SCREEN_BUFFER_INFO;
 const COORD = windows.COORD;
 const DWORD = windows.DWORD;
 const FARPROC = windows.FARPROC;
@@ -191,89 +190,6 @@ pub extern "kernel32" fn CreateThread(
     lpThreadId: ?*DWORD,
 ) callconv(.winapi) ?HANDLE;
 
-// Locks, critical sections, initializers
-
-// TODO:
-//  - dwMilliseconds -> LARGE_INTEGER.
-//  - RtlSleepConditionVariableSRW
-//  - return rc != .TIMEOUT
-pub extern "kernel32" fn SleepConditionVariableSRW(
-    ConditionVariable: *CONDITION_VARIABLE,
-    SRWLock: *SRWLOCK,
-    dwMilliseconds: DWORD,
-    Flags: ULONG,
-) callconv(.winapi) BOOL;
-
-// Console management
-
-pub extern "kernel32" fn GetConsoleMode(
-    hConsoleHandle: HANDLE,
-    lpMode: *DWORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn SetConsoleMode(
-    hConsoleHandle: HANDLE,
-    dwMode: DWORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn GetConsoleScreenBufferInfo(
-    hConsoleOutput: HANDLE,
-    lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn SetConsoleTextAttribute(
-    hConsoleOutput: HANDLE,
-    wAttributes: WORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn SetConsoleCtrlHandler(
-    HandlerRoutine: ?HANDLER_ROUTINE,
-    Add: BOOL,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn SetConsoleOutputCP(
-    wCodePageID: UINT,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn GetConsoleOutputCP() callconv(.winapi) UINT;
-
-pub extern "kernel32" fn FillConsoleOutputAttribute(
-    hConsoleOutput: HANDLE,
-    wAttribute: WORD,
-    nLength: DWORD,
-    dwWriteCoord: COORD,
-    lpNumberOfAttrsWritten: *DWORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn FillConsoleOutputCharacterW(
-    hConsoleOutput: HANDLE,
-    cCharacter: WCHAR,
-    nLength: DWORD,
-    dwWriteCoord: COORD,
-    lpNumberOfCharsWritten: *DWORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn SetConsoleCursorPosition(
-    hConsoleOutput: HANDLE,
-    dwCursorPosition: COORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn WriteConsoleW(
-    hConsoleOutput: HANDLE,
-    lpBuffer: [*]const u16,
-    nNumberOfCharsToWrite: DWORD,
-    lpNumberOfCharsWritten: ?*DWORD,
-    lpReserved: ?LPVOID,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn ReadConsoleOutputCharacterW(
-    hConsoleOutput: HANDLE,
-    lpCharacter: [*]u16,
-    nLength: DWORD,
-    dwReadCoord: COORD,
-    lpNumberOfCharsRead: *DWORD,
-) callconv(.winapi) BOOL;
-
 // Code Libraries/Modules
 
 // TODO: Wrapper around LdrGetDllFullName.
diff --git a/lib/std/std.zig b/lib/std/std.zig
index 3998b3247a53c6a8373fa7521e9f57164769dce2..d563cdfae7aac1003fb7d91472cd6653f78a5cee 100644
--- a/lib/std/std.zig
+++ b/lib/std/std.zig
@@ -135,8 +135,6 @@ pub const Options = struct {
         args: anytype,
     ) void = log.defaultLog,
 
-    logTerminalMode: fn () Io.Terminal.Mode = log.defaultTerminalMode,
-
     /// Overrides `std.heap.page_size_min`.
     page_size_min: ?usize = null,
     /// Overrides `std.heap.page_size_max`.
@@ -176,6 +174,10 @@ pub const Options = struct {
     /// stack traces will just print an error to the relevant `Io.Writer` and return.
     allow_stack_tracing: bool = !@import("builtin").strip_debug_info,
 
+    /// TODO This is a separate decl instead of a field as a workaround around
+    /// compilation errors due to zig not being lazy enough.
+    pub const logTerminalMode: fn () Io.Terminal.Mode = log.defaultTerminalMode;
+
     /// TODO This is a separate decl instead of a field as a workaround around
     /// compilation errors due to zig not being lazy enough.
     pub const elf_debug_info_search_paths: ?fn (exe_path: []const u8) switch (@import("builtin").object_format) {
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index 568dd945512c23023823b9eced149bc2004832f0..a863f56913530548a5a83df8877d6a1db2467b2b 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -347,7 +347,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
             if (msg.kind == .@"fatal error" or msg.kind == .@"error") {
                 msg.write(stderr.terminal(), true) catch |err| switch (err) {
                     error.WriteFailed => return stderr.file_writer.err.?,
-                    error.Unexpected => |e| return e,
+                    error.Canceled, error.Unexpected => |e| return e,
                 };
                 return error.AroPreprocessorFailed;
             }
-- 
2.54.0


From fa3228ae42d3bc92ad66fe91e108511583129ffd Mon Sep 17 00:00:00 2001
From: Ivel <ivel.santos@proton.me>
Date: Thu, 5 Feb 2026 20:21:41 +0100
Subject: [PATCH 205/499] libc: reimplement swab in Zig (#31130)

This PR replaces the bundled musl swab() implementation with zig's one.

Contributes towards #30978.

It looks like there are not test cases for swab() in test-libc.

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31130
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: Ivel <ivel.santos@proton.me>
Co-committed-by: Ivel <ivel.santos@proton.me>
---
 lib/c/unistd.zig                | 42 +++++++++++++++++++++++++++++++++
 lib/libc/musl/src/string/swab.c | 13 ----------
 src/libs/musl.zig               |  1 -
 src/libs/wasi_libc.zig          |  1 -
 4 files changed, 42 insertions(+), 15 deletions(-)
 delete mode 100644 lib/libc/musl/src/string/swab.c

diff --git a/lib/c/unistd.zig b/lib/c/unistd.zig
index f903ef78a8d16a280b959e48a54b91a7635a5e00..98290f0e04a0621d43ff521ecebde45beafdf965 100644
--- a/lib/c/unistd.zig
+++ b/lib/c/unistd.zig
@@ -43,6 +43,9 @@ comptime {
 
         @export(&execveLinux, .{ .name = "execve", .linkage = common.linkage, .visibility = common.visibility });
     }
+    if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        @export(&swab, .{ .name = "swab", .linkage = common.linkage, .visibility = common.visibility });
+    }
 }
 
 fn _exit(exit_code: c_int) callconv(.c) noreturn {
@@ -181,3 +184,42 @@ fn unlinkatLinux(fd: c_int, path: [*:0]const c_char, flags: c_int) callconv(.c)
 fn execveLinux(path: [*:0]const c_char, argv: [*:null]const ?[*:0]c_char, envp: [*:null]const ?[*:0]c_char) callconv(.c) c_int {
     return common.errno(linux.execve(@ptrCast(path), @ptrCast(argv), @ptrCast(envp)));
 }
+
+fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isize) callconv(.c) void {
+    var src: [*]const u8 = @ptrCast(src_ptr);
+    var dest: [*]u8 = @ptrCast(dest_ptr);
+    var i = n;
+
+    while (i > 1) : (i -= 2) {
+        dest[0] = src[1];
+        dest[1] = src[0];
+        dest += 2;
+        src += 2;
+    }
+}
+
+test swab {
+    var a: [4]u8 = undefined;
+    @memset(a[0..], '\x00');
+    swab("abcd", &a, 4);
+    try std.testing.expectEqualSlices(u8, "badc", &a);
+
+    // Partial copy
+    @memset(a[0..], '\x00');
+    swab("abcd", &a, 2);
+    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
+
+    // n < 1
+    @memset(a[0..], '\x00');
+    swab("abcd", &a, 0);
+    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
+    swab("abcd", &a, -1);
+    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
+
+    // Odd n
+    @memset(a[0..], '\x00');
+    swab("abcd", &a, 1);
+    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
+    swab("abcd", &a, 3);
+    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
+}
diff --git a/lib/libc/musl/src/string/swab.c b/lib/libc/musl/src/string/swab.c
deleted file mode 100644
index ace0f4666dd613d58bcf2c93cfd70b37d3f3ae28..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/string/swab.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <unistd.h>
-
-void swab(const void *restrict _src, void *restrict _dest, ssize_t n)
-{
-	const char *src = _src;
-	char *dest = _dest;
-	for (; n>1; n-=2) {
-		dest[0] = src[1];
-		dest[1] = src[0];
-		dest += 2;
-		src += 2;
-	}
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 1974e0e4ea3765ca3de2c8f7adaedc817280dc0d..ebbd28566529c41fc3529ff361bc4228f7c9299a 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -1579,7 +1579,6 @@ const src_files = [_][]const u8{
     "musl/src/string/strndup.c",
     "musl/src/string/strsignal.c",
     "musl/src/string/strverscmp.c",
-    "musl/src/string/swab.c",
     "musl/src/string/wcscasecmp.c",
     "musl/src/string/wcscasecmp_l.c",
     "musl/src/string/wcsdup.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 8e0ade2a0d0f678c6a028c324f46611a644ccf92..24a0ead5988a761b1a86b16e38cd438177cceb89 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -957,7 +957,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/string/strerror_r.c",
     "musl/src/string/strndup.c",
     "musl/src/string/strverscmp.c",
-    "musl/src/string/swab.c",
     "musl/src/string/wcscasecmp.c",
     "musl/src/string/wcscasecmp_l.c",
     "musl/src/string/wcsdup.c",
-- 
2.54.0


From bcb5218a2b2bce189831e68b3396cfd6f246caa2 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Wed, 4 Feb 2026 18:12:06 -0800
Subject: [PATCH 206/499] Environ: reinstate `null` return on `=` in
 environment variable keys

Changes an assert back into a conditional to match the behavior of `getPosix`, see https://codeberg.org/ziglang/zig/pulls/31113#issuecomment-10371698 and https://github.com/ziglang/zig/issues/23331.
Note: the conditional has been updated to also return null early on 0-length key lookups, since there's no need to iterate the block in that case.

For `Environ.Map`, validation of keys has been split into two categories: 'put' and 'fetch', each of which are tailored to the constraints that the implementation actually relies upon. Specifically:
- Hashing (fetching) requires the keys to be valid WTF-8 on Windows, but does not rely on any other properties of the keys (attempting to fetch `F\x00=` is not a problem, it just won't be found)
- `create{Posix,Windows}Block` relies on the Map to always have fully valid keys (no NUL, no `=` in an invalid location, no zero-length keys), which means that the 'put' APIs need to validate that incoming keys adhere to those properties.
The relevant assertions are now documented on each of the Map functions.

Also reinstates some test cases in the `env_vars` standalone test. Some of the reinstated tests are effectively just testing the Environ.Map implementation due to how `Environ.contains`, `Environ.getAlloc`, etc are implemented, but that is not inherent to those functions so the tests are still potentially relevant if e.g. `contains` is implemented in terms of `getPosix`/`getWindows` in the future (which is totally possible and maybe a good idea since constructing the whole map is not necessary for looking up one key).
---
 lib/std/process/Environ.zig       | 57 +++++++++++++++++--------------
 test/standalone/env_vars/main.zig | 23 +++++++++++++
 2 files changed, 55 insertions(+), 25 deletions(-)

diff --git a/lib/std/process/Environ.zig b/lib/std/process/Environ.zig
index e33024de3525fcabfaa08a5be5fc8e80dd4dd026..45e2385c99a6d56317714b40f2b1161f1613caea 100644
--- a/lib/std/process/Environ.zig
+++ b/lib/std/process/Environ.zig
@@ -129,25 +129,21 @@ pub const Map = struct {
         };
     }
 
-    pub fn validateKey(key: []const u8) bool {
+    pub fn validateKeyForPut(key: []const u8) bool {
         switch (native_os) {
             else => return key.len > 0 and mem.findAny(u8, key, &.{ 0, '=' }) == null,
             .windows => {
                 if (!unicode.wtf8ValidateSlice(key)) return false;
-                var it = unicode.Wtf8View.initUnchecked(key).iterator();
-                switch (it.nextCodepoint() orelse return false) {
-                    0 => return false,
-                    else => {},
-                }
-                while (it.nextCodepoint()) |cp| switch (cp) {
-                    0, '=' => return false,
-                    else => {},
-                };
-                return true;
+                return key.len > 0 and key[0] != 0 and mem.findAnyPos(u8, key, 1, &.{ 0, '=' }) == null;
             },
         }
     }
 
+    pub fn validateKeyForFetch(key: []const u8) bool {
+        if (native_os == .windows and !unicode.wtf8ValidateSlice(key)) return false;
+        return true;
+    }
+
     /// Create a Map backed by a specific allocator.
     /// That allocator will be used for both backing allocations
     /// and string deduplication.
@@ -220,9 +216,14 @@ pub const Map = struct {
     /// Same as `put` but the key and value become owned by the Map rather
     /// than being copied.
     /// If `putMove` fails, the ownership of key and value does not transfer.
-    /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
+    ///
+    /// Asserts that `key` is valid:
+    /// - It cannot contain a NUL (`'\x00') byte.
+    /// - It must have a length > 0.
+    /// - It cannot contain `=`, except on Windows where only the first code point is allowed to be `=`.
+    /// - On Windows, it must be valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn putMove(self: *Map, key: []u8, value: []u8) Allocator.Error!void {
-        assert(validateKey(key));
+        assert(validateKeyForPut(key));
         const gpa = self.allocator;
         const get_or_put = try self.array_hash_map.getOrPut(gpa, key);
         if (get_or_put.found_existing) {
@@ -234,9 +235,14 @@ pub const Map = struct {
     }
 
     /// `key` and `value` are copied into the Map.
-    /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
+    ///
+    /// Asserts that `key` is valid:
+    /// - It cannot contain a NUL (`'\x00') byte.
+    /// - It must have a length > 0.
+    /// - It cannot contain `=`, except on Windows where only the first code point is allowed to be `=`.
+    /// - On Windows, it must be valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn put(self: *Map, key: []const u8, value: []const u8) Allocator.Error!void {
-        assert(validateKey(key));
+        assert(validateKeyForPut(key));
         const gpa = self.allocator;
         const value_copy = try gpa.dupe(u8, value);
         errdefer gpa.free(value_copy);
@@ -254,23 +260,24 @@ pub const Map = struct {
 
     /// Find the address of the value associated with a key.
     /// The returned pointer is invalidated if the map resizes.
-    /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
+    /// On Windows, asserts that `key` is valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn getPtr(self: Map, key: []const u8) ?*[]const u8 {
-        assert(validateKey(key));
+        assert(validateKeyForFetch(key));
         return self.array_hash_map.getPtr(key);
     }
 
     /// Return the map's copy of the value associated with
     /// a key.  The returned string is invalidated if this
     /// key is removed from the map.
-    /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
+    /// On Windows, asserts that `key` is valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn get(self: Map, key: []const u8) ?[]const u8 {
-        assert(validateKey(key));
+        assert(validateKeyForFetch(key));
         return self.array_hash_map.get(key);
     }
 
+    /// On Windows, asserts that `key` is valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn contains(m: *const Map, key: []const u8) bool {
-        assert(validateKey(key));
+        assert(validateKeyForFetch(key));
         return m.array_hash_map.contains(key);
     }
 
@@ -281,9 +288,9 @@ pub const Map = struct {
     /// Returns true if an entry was removed, false otherwise.
     ///
     /// This invalidates the value returned by get() for this key.
-    /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
+    /// On Windows, asserts that `key` is valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn swapRemove(self: *Map, key: []const u8) bool {
-        assert(validateKey(key));
+        assert(validateKeyForFetch(key));
         const kv = self.array_hash_map.fetchSwapRemove(key) orelse return false;
         const gpa = self.allocator;
         gpa.free(kv.key);
@@ -298,9 +305,9 @@ pub const Map = struct {
     /// Returns true if an entry was removed, false otherwise.
     ///
     /// This invalidates the value returned by get() for this key.
-    /// On Windows `key` must be a valid [WTF-8](https://wtf-8.codeberg.page/) string.
+    /// On Windows, asserts that `key` is valid [WTF-8](https://wtf-8.codeberg.page/).
     pub fn orderedRemove(self: *Map, key: []const u8) bool {
-        assert(validateKey(key));
+        assert(validateKeyForFetch(key));
         const kv = self.array_hash_map.fetchOrderedRemove(key) orelse return false;
         const gpa = self.allocator;
         gpa.free(kv.key);
@@ -612,7 +619,7 @@ pub fn getPosix(environ: Environ, key: []const u8) ?[:0]const u8 {
 pub fn getWindows(environ: Environ, key: [*:0]const u16) ?[:0]const u16 {
     // '=' anywhere but the start makes this an invalid environment variable name.
     const key_slice = mem.sliceTo(key, 0);
-    assert(key_slice.len > 0 and mem.findScalar(u16, key_slice[1..], '=') == null);
+    if (key_slice.len == 0 or mem.findScalar(u16, key_slice[1..], '=') != null) return null;
 
     if (!environ.block.use_global) return null;
 
diff --git a/test/standalone/env_vars/main.zig b/test/standalone/env_vars/main.zig
index 6ffcae81aecb867afbcf91cdbf92b2678ff575ac..09167f285fe9960fbedb8f9fcb179bc354ca15f4 100644
--- a/test/standalone/env_vars/main.zig
+++ b/test/standalone/env_vars/main.zig
@@ -12,10 +12,14 @@ pub fn main(init: std.process.Init) !void {
     // containsUnempty
     {
         try std.testing.expect(try environ.containsUnempty(allocator, "FOO"));
+        try std.testing.expect(!(try environ.containsUnempty(allocator, "FOO=")));
+        try std.testing.expect(!(try environ.containsUnempty(allocator, "FO")));
+        try std.testing.expect(!(try environ.containsUnempty(allocator, "FOOO")));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.containsUnempty(allocator, "foo"));
         }
         try std.testing.expect(try environ.containsUnempty(allocator, "EQUALS"));
+        try std.testing.expect(!(try environ.containsUnempty(allocator, "EQUALS=ABC")));
         try std.testing.expect(try environ.containsUnempty(allocator, "КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.containsUnempty(allocator, "кирИЛЛица"));
@@ -31,10 +35,14 @@ pub fn main(init: std.process.Init) !void {
     // containsUnemptyConstant
     {
         try std.testing.expect(environ.containsUnemptyConstant("FOO"));
+        try std.testing.expect(!environ.containsUnemptyConstant("FOO="));
+        try std.testing.expect(!environ.containsUnemptyConstant("FO"));
+        try std.testing.expect(!environ.containsUnemptyConstant("FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsUnemptyConstant("foo"));
         }
         try std.testing.expect(environ.containsUnemptyConstant("EQUALS"));
+        try std.testing.expect(!environ.containsUnemptyConstant("EQUALS=ABC"));
         try std.testing.expect(environ.containsUnemptyConstant("КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsUnemptyConstant("кирИЛЛица"));
@@ -50,10 +58,14 @@ pub fn main(init: std.process.Init) !void {
     // contains
     {
         try std.testing.expect(try environ.contains(allocator, "FOO"));
+        try std.testing.expect(!(try environ.contains(allocator, "FOO=")));
+        try std.testing.expect(!(try environ.contains(allocator, "FO")));
+        try std.testing.expect(!(try environ.contains(allocator, "FOOO")));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.contains(allocator, "foo"));
         }
         try std.testing.expect(try environ.contains(allocator, "EQUALS"));
+        try std.testing.expect(!(try environ.contains(allocator, "EQUALS=ABC")));
         try std.testing.expect(try environ.contains(allocator, "КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(try environ.contains(allocator, "кирИЛЛица"));
@@ -69,10 +81,14 @@ pub fn main(init: std.process.Init) !void {
     // containsConstant
     {
         try std.testing.expect(environ.containsConstant("FOO"));
+        try std.testing.expect(!environ.containsConstant("FOO="));
+        try std.testing.expect(!environ.containsConstant("FO"));
+        try std.testing.expect(!environ.containsConstant("FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsConstant("foo"));
         }
         try std.testing.expect(environ.containsConstant("EQUALS"));
+        try std.testing.expect(!environ.containsConstant("EQUALS=ABC"));
         try std.testing.expect(environ.containsConstant("КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expect(environ.containsConstant("кирИЛЛица"));
@@ -88,10 +104,14 @@ pub fn main(init: std.process.Init) !void {
     // getAlloc
     {
         try std.testing.expectEqualSlices(u8, "123", try environ.getAlloc(arena, "FOO"));
+        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "FOO="));
+        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "FO"));
+        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "123", try environ.getAlloc(arena, "foo"));
         }
         try std.testing.expectEqualSlices(u8, "ABC=123", try environ.getAlloc(arena, "EQUALS"));
+        try std.testing.expectError(error.EnvironmentVariableMissing, environ.getAlloc(arena, "EQUALS=ABC"));
         try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try environ.getAlloc(arena, "КИРиллИЦА"));
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", try environ.getAlloc(arena, "кирИЛЛица"));
@@ -110,10 +130,13 @@ pub fn main(init: std.process.Init) !void {
         defer environ_map.deinit();
 
         try std.testing.expectEqualSlices(u8, "123", environ_map.get("FOO").?);
+        try std.testing.expectEqual(null, environ_map.get("FO"));
+        try std.testing.expectEqual(null, environ_map.get("FOOO"));
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "123", environ_map.get("foo").?);
         }
         try std.testing.expectEqualSlices(u8, "ABC=123", environ_map.get("EQUALS").?);
+        try std.testing.expectEqual(null, environ_map.get("EQUALS=ABC"));
         try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", environ_map.get("КИРиллИЦА").?);
         if (builtin.os.tag == .windows) {
             try std.testing.expectEqualSlices(u8, "non-ascii አማርኛ \u{10FFFF}", environ_map.get("кирИЛЛица").?);
-- 
2.54.0


From c38f9336a3157ae863a795b005db670c6cc04906 Mon Sep 17 00:00:00 2001
From: brickmonster <92665597+brickmonster@users.noreply.github.com>
Date: Wed, 4 Feb 2026 23:50:42 +0000
Subject: [PATCH 207/499] std.os.linux: fix test not building

---
 lib/std/os/linux/bpf.zig | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/os/linux/bpf.zig b/lib/std/os/linux/bpf.zig
index b7c5c7d4e9b81a4cc8627743ea64913d958bf3b4..85f7d677e8f335871f0b751c5b5634bcf4205533 100644
--- a/lib/std/os/linux/bpf.zig
+++ b/lib/std/os/linux/bpf.zig
@@ -1555,7 +1555,7 @@ pub fn map_create(map_type: MapType, key_size: u32, value_size: u32, max_entries
 
 test "map_create" {
     const map = try map_create(.hash, 4, 4, 32);
-    defer std.os.close(map);
+    defer _ = std.os.linux.close(map);
 }
 
 pub fn map_lookup_elem(fd: fd_t, key: []const u8, value: []u8) !void {
@@ -1647,7 +1647,7 @@ test "map lookup, update, and delete" {
     const key_size = 4;
     const value_size = 4;
     const map = try map_create(.hash, key_size, value_size, 1);
-    defer std.os.close(map);
+    defer _ = std.os.linux.close(map);
 
     const key = std.mem.zeroes([key_size]u8);
     var value = std.mem.zeroes([value_size]u8);
@@ -1729,7 +1729,7 @@ test "prog_load" {
     };
 
     const prog = try prog_load(.socket_filter, &good_prog, null, "MIT", 0, 0);
-    defer std.os.close(prog);
+    defer _ = std.os.linux.close(prog);
 
     try expectError(error.UnsafeProgram, prog_load(.socket_filter, &bad_prog, null, "MIT", 0, 0));
 }
-- 
2.54.0


From d0b39c7f2b95522c262a92b97bf5654721ace1c7 Mon Sep 17 00:00:00 2001
From: Pivok <pivoc@protonmail.com>
Date: Thu, 5 Feb 2026 21:57:32 +0100
Subject: [PATCH 208/499] libzigc: hypot (#31104)

First time contribution.

Implements hypot for libzigc #30978.

Commands i run:
```
$ stage3/bin/zig build -p stage4 -Denable-llvm -Dno-lib

$ stage4/bin/zig build test-libc -Dlibc-test-path=../../libc-test -Dtest-filter=hypot --summary line -fqemu -fwasmtime
Build Summary: 725/737 steps succeeded (12 skipped)
```

I also changed std.math.hypot becuase some libc-tests raised fp exceptions. Example:
```
../../libc-test/src/math/special/hypot.h:8: bad fp exception: RN hypot(0x1p-1074,0x0p+0)=0x1p-1074, want 0 got INEXACT|UNDERFLOW
../../libc-test/src/math/special/hypot.h:9: bad fp exception: RN hypot(0x1p-1074,-0x0p+0)=0x1p-1074, want 0 got INEXACT|UNDERFLOW
```

I also run this command as a quick sanity check:
```
$ stage4/bin/zig build test-std -Dtest-filter=hypot -Dtest-target-filter=x86_64-linux-musl --summary line
Build Summary: 5/5 steps succeeded; 136/136 tests passed
```

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31104
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: Pivok <pivoc@protonmail.com>
Co-committed-by: Pivok <pivoc@protonmail.com>
---
 lib/c/math.zig                      |  5 +++
 lib/libc/musl/src/math/hypot.c      | 67 -----------------------------
 lib/libc/musl/src/math/i386/hypot.s | 45 -------------------
 lib/std/math/hypot.zig              |  8 ++--
 src/libs/musl.zig                   |  2 -
 src/libs/wasi_libc.zig              |  1 -
 6 files changed, 9 insertions(+), 119 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/hypot.c
 delete mode 100644 lib/libc/musl/src/math/i386/hypot.s

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 8fc7c0322878b7b6862392abe3158a05b7adda11..403e8f9d471fefee67c667c7afa73c443ccd34c3 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -41,6 +41,7 @@ comptime {
         @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
         @export(&cbrt, .{ .name = "cbrt", .linkage = common.linkage, .visibility = common.visibility });
         @export(&cbrtf, .{ .name = "cbrtf", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&hypot, .{ .name = "hypot", .linkage = common.linkage, .visibility = common.visibility });
         @export(&pow, .{ .name = "pow", .linkage = common.linkage, .visibility = common.visibility });
     }
 
@@ -118,6 +119,10 @@ fn cbrtf(x: f32) callconv(.c) f32 {
     return math.cbrt(x);
 }
 
+fn hypot(x: f64, y: f64) callconv(.c) f64 {
+    return math.hypot(x, y);
+}
+
 fn pow(x: f64, y: f64) callconv(.c) f64 {
     return math.pow(f64, x, y);
 }
diff --git a/lib/libc/musl/src/math/hypot.c b/lib/libc/musl/src/math/hypot.c
deleted file mode 100644
index 6071bf1e284f376f417dbab5bc306964a7491f3f..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/hypot.c
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <math.h>
-#include <stdint.h>
-#include <float.h>
-
-#if FLT_EVAL_METHOD > 1U && LDBL_MANT_DIG == 64
-#define SPLIT (0x1p32 + 1)
-#else
-#define SPLIT (0x1p27 + 1)
-#endif
-
-static void sq(double_t *hi, double_t *lo, double x)
-{
-	double_t xh, xl, xc;
-
-	xc = (double_t)x*SPLIT;
-	xh = x - xc + xc;
-	xl = x - xh;
-	*hi = (double_t)x*x;
-	*lo = xh*xh - *hi + 2*xh*xl + xl*xl;
-}
-
-double hypot(double x, double y)
-{
-	union {double f; uint64_t i;} ux = {x}, uy = {y}, ut;
-	int ex, ey;
-	double_t hx, lx, hy, ly, z;
-
-	/* arrange |x| >= |y| */
-	ux.i &= -1ULL>>1;
-	uy.i &= -1ULL>>1;
-	if (ux.i < uy.i) {
-		ut = ux;
-		ux = uy;
-		uy = ut;
-	}
-
-	/* special cases */
-	ex = ux.i>>52;
-	ey = uy.i>>52;
-	x = ux.f;
-	y = uy.f;
-	/* note: hypot(inf,nan) == inf */
-	if (ey == 0x7ff)
-		return y;
-	if (ex == 0x7ff || uy.i == 0)
-		return x;
-	/* note: hypot(x,y) ~= x + y*y/x/2 with inexact for small y/x */
-	/* 64 difference is enough for ld80 double_t */
-	if (ex - ey > 64)
-		return x + y;
-
-	/* precise sqrt argument in nearest rounding mode without overflow */
-	/* xh*xh must not overflow and xl*xl must not underflow in sq */
-	z = 1;
-	if (ex > 0x3ff+510) {
-		z = 0x1p700;
-		x *= 0x1p-700;
-		y *= 0x1p-700;
-	} else if (ey < 0x3ff-450) {
-		z = 0x1p-700;
-		x *= 0x1p700;
-		y *= 0x1p700;
-	}
-	sq(&hx, &lx, x);
-	sq(&hy, &ly, y);
-	return z*sqrt(ly+lx+hy+hx);
-}
diff --git a/lib/libc/musl/src/math/i386/hypot.s b/lib/libc/musl/src/math/i386/hypot.s
deleted file mode 100644
index 299c2e186cab4d9287e08e7eb79522790a35b6fc..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/hypot.s
+++ /dev/null
@@ -1,45 +0,0 @@
-.global hypot
-.type hypot,@function
-hypot:
-	mov 8(%esp),%eax
-	mov 16(%esp),%ecx
-	add %eax,%eax
-	add %ecx,%ecx
-	and %eax,%ecx
-	cmp $0xffe00000,%ecx
-	jae 2f
-	or 4(%esp),%eax
-	jnz 1f
-	fldl 12(%esp)
-	fabs
-	ret
-1:	mov 16(%esp),%eax
-	add %eax,%eax
-	or 12(%esp),%eax
-	jnz 1f
-	fldl 4(%esp)
-	fabs
-	ret
-1:	fldl 4(%esp)
-	fld %st(0)
-	fmulp
-	fldl 12(%esp)
-	fld %st(0)
-	fmulp
-	faddp
-	fsqrt
-	ret
-2:	sub $0xffe00000,%eax
-	or 4(%esp),%eax
-	jnz 1f
-	fldl 4(%esp)
-	fabs
-	ret
-1:	mov 16(%esp),%eax
-	add %eax,%eax
-	sub $0xffe00000,%eax
-	or 12(%esp),%eax
-	fldl 12(%esp)
-	jnz 1f
-	fabs
-1:	ret
diff --git a/lib/std/math/hypot.zig b/lib/std/math/hypot.zig
index f95c3c0bd4b95cc8fdaa748e60b3450e258499ef..40a9518cf49dcbb207af382e0083c8dc2fb2b919 100644
--- a/lib/std/math/hypot.zig
+++ b/lib/std/math/hypot.zig
@@ -6,10 +6,10 @@ const isNan = math.isNan;
 const isInf = math.isInf;
 const inf = math.inf;
 const nan = math.nan;
-const floatEpsAt = math.floatEpsAt;
 const floatEps = math.floatEps;
 const floatMin = math.floatMin;
 const floatMax = math.floatMax;
+const floatTrueMin = math.floatTrueMin;
 
 /// Returns sqrt(x * x + y * y), avoiding unnecessary overflow and underflow.
 ///
@@ -30,8 +30,7 @@ pub fn hypot(x: anytype, y: anytype) @TypeOf(x, y) {
     }
     const lower = @sqrt(floatMin(T));
     const upper = @sqrt(floatMax(T) / 2);
-    const incre = @sqrt(floatEps(T) / 2);
-    const scale = floatEpsAt(T, incre);
+    const scale = floatTrueMin(T) * upper;
     const hypfn = if (emulateFma(T)) hypotUnfused else hypotFused;
     var major: T = x;
     var minor: T = y;
@@ -46,7 +45,8 @@ pub fn hypot(x: anytype, y: anytype) @TypeOf(x, y) {
         major = minor;
         minor = tempo;
     }
-    if (major * incre >= minor) return major;
+    if (minor == 0.0) return major;
+    if (major - minor == major) return major;
     if (major > upper) return hypfn(T, major * scale, minor * scale) / scale;
     if (minor < lower) return hypfn(T, major / scale, minor / scale) * scale;
     return hypfn(T, major, minor);
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index ebbd28566529c41fc3529ff361bc4228f7c9299a..8fd59eb36f7253676408b7a93b91c218b85aef7e 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -874,7 +874,6 @@ const src_files = [_][]const u8{
     "musl/src/math/frexp.c",
     "musl/src/math/frexpf.c",
     "musl/src/math/frexpl.c",
-    "musl/src/math/hypot.c",
     "musl/src/math/hypotf.c",
     "musl/src/math/hypotl.c",
     "musl/src/math/i386/acosf.s",
@@ -890,7 +889,6 @@ const src_files = [_][]const u8{
     "musl/src/math/i386/expl.s",
     "musl/src/math/i386/expm1l.s",
     "musl/src/math/i386/hypotf.s",
-    "musl/src/math/i386/hypot.s",
     "musl/src/math/i386/__invtrigl.s",
     "musl/src/math/i386/ldexpf.s",
     "musl/src/math/i386/ldexpl.s",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 24a0ead5988a761b1a86b16e38cd438177cceb89..350a4184bfef6351a934e6efdb17b7aebed21f0f 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -730,7 +730,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/frexp.c",
     "musl/src/math/frexpf.c",
     "musl/src/math/frexpl.c",
-    "musl/src/math/hypot.c",
     "musl/src/math/hypotf.c",
     "musl/src/math/hypotl.c",
     "musl/src/math/ilogb.c",
-- 
2.54.0


From 076f7e5bd5389e159865d99e0e86edc905cffc42 Mon Sep 17 00:00:00 2001
From: bgthompson <benjamin.btstudios@pm.me>
Date: Sat, 31 Jan 2026 22:44:21 +1000
Subject: [PATCH 209/499] removed reduntant @as() from switch in getDaysInMonth

---
 lib/std/time/epoch.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/time/epoch.zig b/lib/std/time/epoch.zig
index fa7499aec7ec4e86ecd17f200baec90bb8be63d3..4139e82429e5ede0e9afb3f2fb6c488e475cda5c 100644
--- a/lib/std/time/epoch.zig
+++ b/lib/std/time/epoch.zig
@@ -89,10 +89,10 @@ pub const Month = enum(u4) {
 pub fn getDaysInMonth(year: Year, month: Month) u5 {
     return switch (month) {
         .jan => 31,
-        .feb => @as(u5, switch (isLeapYear(year)) {
+        .feb => switch (isLeapYear(year)) {
             true => 29,
             false => 28,
-        }),
+        },
         .mar => 31,
         .apr => 30,
         .may => 31,
-- 
2.54.0


From 387d550b6c3e73989513ea720437fdc5aac195d3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 13:15:53 -0800
Subject: [PATCH 210/499] compiler: remove btrfs workaround functionality

has been fixed in the kernel code for a while now
---
 lib/std/zig.zig       |  1 -
 src/Package/Fetch.zig | 13 +------------
 src/main.zig          | 10 +---------
 3 files changed, 2 insertions(+), 22 deletions(-)

diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index 4f0f47b11f3dfe5b39bcbbef50b562f7a3f87189..16c15e51097200758df482cc5b6487619011234d 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -737,7 +737,6 @@ pub const EnvVar = enum {
     ZIG_BUILD_MULTILINE_ERRORS,
     ZIG_VERBOSE_LINK,
     ZIG_VERBOSE_CC,
-    ZIG_BTRFS_WORKAROUND,
     ZIG_DEBUG_CMD,
     ZIG_IS_DETECTING_LIBC_PATHS,
     ZIG_IS_TRYING_TO_NOT_CALL_ITSELF,
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index d42e441d77c72736ebb35c1c5e70fcbdb315d884..5a600421e9e24c5eb905290dcd57512f94668548 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -129,7 +129,6 @@ pub const JobQueue = struct {
     /// two hashes of the same package do not match.
     /// If this is true, `recursive` must be false.
     debug_hash: bool,
-    work_around_btrfs_bug: bool,
     mode: Mode,
     /// Set of hashes that will be additionally fetched even if they are marked
     /// as lazy.
@@ -524,16 +523,7 @@ fn runResource(
         // Fetch and unpack a resource into a temporary directory.
         var unpack_result = try unpackResource(f, resource, uri_path, tmp_directory);
 
-        var pkg_path: Cache.Path = .{ .root_dir = tmp_directory, .sub_path = unpack_result.root_dir };
-
-        // Apply btrfs workaround if needed. Reopen tmp_directory.
-        if (native_os == .linux and f.job_queue.work_around_btrfs_bug) {
-            // https://github.com/ziglang/zig/issues/17095
-            pkg_path.root_dir.handle.close(io);
-            pkg_path.root_dir.handle = cache_root.handle.createDirPathOpen(io, tmp_dir_sub_path, .{
-                .open_options = .{ .iterate = true },
-            }) catch @panic("btrfs workaround failed");
-        }
+        const pkg_path: Cache.Path = .{ .root_dir = tmp_directory, .sub_path = unpack_result.root_dir };
 
         // Load, parse, and validate the unpacked build.zig.zon file. It is allowed
         // for the file to be missing, in which case this fetched package is
@@ -2276,7 +2266,6 @@ const TestFetchBuilder = struct {
             .recursive = false,
             .read_only = false,
             .debug_hash = false,
-            .work_around_btrfs_bug = false,
             .mode = .needed,
         };
 
diff --git a/src/main.zig b/src/main.zig
index 0efab88f6ada4d8f830a0d7614fa2e3462ba0332..1e9c0de6564be4e81661182f07877fd3a7a17cbc 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5098,8 +5098,6 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
         }
     }
 
-    const work_around_btrfs_bug = native_os == .linux and
-        EnvVar.ZIG_BTRFS_WORKAROUND.isSet(environ_map);
     const root_prog_node = std.Progress.start(io, .{
         .disable_printing = (color == .off),
         .root_name = "Compile Build Script",
@@ -5244,7 +5242,6 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     .read_only = false,
                     .recursive = true,
                     .debug_hash = false,
-                    .work_around_btrfs_bug = work_around_btrfs_bug,
                     .unlazy_set = unlazy_set,
                     .mode = fetch_mode,
                 };
@@ -5254,9 +5251,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     job_queue.global_cache = .{
                         .path = p,
                         .handle = Io.Dir.cwd().openDir(io, p, .{}) catch |err| {
-                            fatal("unable to open system package directory '{s}': {s}", .{
-                                p, @errorName(err),
-                            });
+                            fatal("unable to open system package directory '{s}': {t}", .{ p, err });
                         },
                     };
                     job_queue.read_only = true;
@@ -6938,8 +6933,6 @@ fn cmdFetch(
     dev.check(.fetch_command);
 
     const color: Color = .auto;
-    const work_around_btrfs_bug = native_os == .linux and
-        EnvVar.ZIG_BTRFS_WORKAROUND.isSet(environ_map);
     var opt_path_or_url: ?[]const u8 = null;
     var override_global_cache_dir: ?[]const u8 = EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map);
     var debug_hash: bool = false;
@@ -7010,7 +7003,6 @@ fn cmdFetch(
         .recursive = false,
         .read_only = false,
         .debug_hash = debug_hash,
-        .work_around_btrfs_bug = work_around_btrfs_bug,
         .mode = .all,
     };
     defer job_queue.deinit();
-- 
2.54.0


From 76d275b20f4ba420f741e019a7456ca392c040e4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 15:31:42 -0800
Subject: [PATCH 211/499] std.Io.Threaded: flatten some switch cases

---
 lib/std/Io/Threaded.zig | 80 ++++++++++++++++++-----------------------
 1 file changed, 35 insertions(+), 45 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index ab2e9af75765de1f30b6fa6c2f087921ffa54e9b..f998466e6e4b2aac295f4f40bd1d64b676aca179 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -3191,29 +3191,24 @@ fn dirCreateDirPosix(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, perm
                 try syscall.checkCancel();
                 continue;
             },
-            else => |e| {
-                syscall.finish();
-                switch (e) {
-                    .ACCES => return error.AccessDenied,
-                    .BADF => |err| return errnoBug(err), // File descriptor used after closed.
-                    .PERM => return error.PermissionDenied,
-                    .DQUOT => return error.DiskQuota,
-                    .EXIST => return error.PathAlreadyExists,
-                    .FAULT => |err| return errnoBug(err),
-                    .LOOP => return error.SymLinkLoop,
-                    .MLINK => return error.LinkQuotaExceeded,
-                    .NAMETOOLONG => return error.NameTooLong,
-                    .NOENT => return error.FileNotFound,
-                    .NOMEM => return error.SystemResources,
-                    .NOSPC => return error.NoSpaceLeft,
-                    .NOTDIR => return error.NotDir,
-                    .ROFS => return error.ReadOnlyFileSystem,
-                    // dragonfly: when dir_fd is unlinked from filesystem
-                    .NOTCONN => return error.FileNotFound,
-                    .ILSEQ => return error.BadPathName,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
+            .ACCES => return syscall.fail(error.AccessDenied),
+            .PERM => return syscall.fail(error.PermissionDenied),
+            .DQUOT => return syscall.fail(error.DiskQuota),
+            .EXIST => return syscall.fail(error.PathAlreadyExists),
+            .LOOP => return syscall.fail(error.SymLinkLoop),
+            .MLINK => return syscall.fail(error.LinkQuotaExceeded),
+            .NAMETOOLONG => return syscall.fail(error.NameTooLong),
+            .NOENT => return syscall.fail(error.FileNotFound),
+            .NOMEM => return syscall.fail(error.SystemResources),
+            .NOSPC => return syscall.fail(error.NoSpaceLeft),
+            .NOTDIR => return syscall.fail(error.NotDir),
+            .ROFS => return syscall.fail(error.ReadOnlyFileSystem),
+            // dragonfly: when dir_fd is unlinked from filesystem
+            .NOTCONN => return syscall.fail(error.FileNotFound),
+            .ILSEQ => return syscall.fail(error.BadPathName),
+            .BADF => |err| return syscall.errnoBug(err), // File descriptor used after closed.
+            .FAULT => |err| return syscall.errnoBug(err),
+            else => |err| return syscall.unexpectedErrno(err),
         }
     }
 }
@@ -5261,28 +5256,23 @@ fn dirOpenDirPosix(
                 try syscall.checkCancel();
                 continue;
             },
-            else => |e| {
-                syscall.finish();
-                switch (e) {
-                    .FAULT => |err| return errnoBug(err),
-                    .INVAL => return error.BadPathName,
-                    .BADF => |err| return errnoBug(err), // File descriptor used after closed.
-                    .ACCES => return error.AccessDenied,
-                    .LOOP => return error.SymLinkLoop,
-                    .MFILE => return error.ProcessFdQuotaExceeded,
-                    .NAMETOOLONG => return error.NameTooLong,
-                    .NFILE => return error.SystemFdQuotaExceeded,
-                    .NODEV => return error.NoDevice,
-                    .NOENT => return error.FileNotFound,
-                    .NOMEM => return error.SystemResources,
-                    .NOTDIR => return error.NotDir,
-                    .PERM => return error.PermissionDenied,
-                    .BUSY => |err| return errnoBug(err), // O_EXCL not passed
-                    .NXIO => return error.NoDevice,
-                    .ILSEQ => return error.BadPathName,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
+            .INVAL => return syscall.fail(error.BadPathName),
+            .ACCES => return syscall.fail(error.AccessDenied),
+            .LOOP => return syscall.fail(error.SymLinkLoop),
+            .MFILE => return syscall.fail(error.ProcessFdQuotaExceeded),
+            .NAMETOOLONG => return syscall.fail(error.NameTooLong),
+            .NFILE => return syscall.fail(error.SystemFdQuotaExceeded),
+            .NODEV => return syscall.fail(error.NoDevice),
+            .NOENT => return syscall.fail(error.FileNotFound),
+            .NOMEM => return syscall.fail(error.SystemResources),
+            .NOTDIR => return syscall.fail(error.NotDir),
+            .PERM => return syscall.fail(error.PermissionDenied),
+            .NXIO => return syscall.fail(error.NoDevice),
+            .ILSEQ => return syscall.fail(error.BadPathName),
+            .FAULT => |err| return syscall.errnoBug(err),
+            .BADF => |err| return syscall.errnoBug(err), // File descriptor used after closed.
+            .BUSY => |err| return syscall.errnoBug(err), // O_EXCL not passed
+            else => |err| return syscall.unexpectedErrno(err),
         }
     }
 }
-- 
2.54.0


From 64dc1cdad8faf1fd8330d4b0f9149817b5205abf Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 15:55:56 -0800
Subject: [PATCH 212/499] fetch: download to local zig-pkg directory

rather than global cache p/ directory.

closes #14283

does not recompress packages into global cache yet
---
 src/Package/Fetch.zig | 148 ++++++++++++++++++++++--------------------
 src/main.zig          |  52 +++++++++++----
 2 files changed, 115 insertions(+), 85 deletions(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 5a600421e9e24c5eb905290dcd57512f94668548..96018851ce47e19ede2a6855eb6dad6a07745527 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -68,8 +68,7 @@ use_latest_commit: bool,
 // Above this are fields provided as inputs to `run`.
 // Below this are fields populated by `run`.
 
-/// This will either be relative to `global_cache`, or to the build root of
-/// the root package.
+/// Relative to the build root of the root package.
 package_root: Cache.Path,
 error_bundle: ErrorBundle.Wip,
 manifest: ?Manifest,
@@ -115,6 +114,9 @@ pub const JobQueue = struct {
     http_client: *std.http.Client,
     group: Io.Group = .init,
     global_cache: Cache.Directory,
+    local_cache: Cache.Path,
+    /// Path to "zig-pkg" inside the package in which the user ran `zig build`.
+    root_pkg_path: Cache.Path,
     /// If true then, no fetching occurs, and:
     /// * The `global_cache` directory is assumed to be the direct parent
     ///   directory of on-disk packages rather than having the "p/" directory
@@ -325,11 +327,12 @@ pub const RunError = error{
 };
 
 pub fn run(f: *Fetch) RunError!void {
-    const io = f.job_queue.io;
+    const job_queue = f.job_queue;
+    const io = job_queue.io;
     const eb = &f.error_bundle;
     const arena = f.arena.allocator();
     const gpa = f.arena.child_allocator;
-    const cache_root = f.job_queue.global_cache;
+    const local_cache_root = job_queue.local_cache;
 
     try eb.init(gpa);
 
@@ -350,13 +353,13 @@ pub fn run(f: *Fetch) RunError!void {
             );
             // Packages fetched by URL may not use relative paths to escape outside the
             // fetched package directory from within the package cache.
-            if (pkg_root.root_dir.eql(cache_root)) {
+            if (pkg_root.root_dir.eql(local_cache_root.root_dir)) {
                 // `parent_package_root.sub_path` contains a path like this:
                 // "p/$hash", or
                 // "p/$hash/foo", with possibly more directories after "foo".
                 // We want to fail unless the resolved relative path has a
                 // prefix of "p/$hash/".
-                const prefix_len: usize = if (f.job_queue.read_only) 0 else "p/".len;
+                const prefix_len: usize = if (job_queue.read_only) 0 else "p/".len;
                 const parent_sub_path = f.parent_package_root.sub_path;
                 const end = find_end: {
                     if (parent_sub_path.len > prefix_len) {
@@ -379,7 +382,7 @@ pub fn run(f: *Fetch) RunError!void {
             f.package_root = pkg_root;
             try loadManifest(f, pkg_root);
             if (!f.has_build_zig) try checkBuildFileExistence(f);
-            if (!f.job_queue.recursive) return;
+            if (!job_queue.recursive) return;
             return queueJobsForDeps(f);
         },
         .remote => |remote| remote,
@@ -411,51 +414,39 @@ pub fn run(f: *Fetch) RunError!void {
     };
 
     if (remote.hash) |expected_hash| {
-        var prefixed_pkg_sub_path_buffer: [Package.Hash.max_len + 2]u8 = undefined;
-        prefixed_pkg_sub_path_buffer[0] = 'p';
-        prefixed_pkg_sub_path_buffer[1] = fs.path.sep;
-        const hash_slice = expected_hash.toSlice();
-        @memcpy(prefixed_pkg_sub_path_buffer[2..][0..hash_slice.len], hash_slice);
-        const prefixed_pkg_sub_path = prefixed_pkg_sub_path_buffer[0 .. 2 + hash_slice.len];
-        const prefix_len: usize = if (f.job_queue.read_only) "p/".len else 0;
-        const pkg_sub_path = prefixed_pkg_sub_path[prefix_len..];
-        if (cache_root.handle.access(io, pkg_sub_path, .{})) |_| {
+        const package_root = try job_queue.root_pkg_path.join(arena, expected_hash.toSlice());
+        if (package_root.root_dir.handle.access(io, package_root.sub_path, .{})) |_| {
             assert(f.lazy_status != .unavailable);
-            f.package_root = .{
-                .root_dir = cache_root,
-                .sub_path = try arena.dupe(u8, pkg_sub_path),
-            };
+            f.package_root = package_root;
             try loadManifest(f, f.package_root);
             try checkBuildFileExistence(f);
-            if (!f.job_queue.recursive) return;
+            if (!job_queue.recursive) return;
             return queueJobsForDeps(f);
         } else |err| switch (err) {
             error.FileNotFound => {
                 switch (f.lazy_status) {
                     .eager => {},
-                    .available => if (!f.job_queue.unlazy_set.contains(expected_hash)) {
+                    .available => if (!job_queue.unlazy_set.contains(expected_hash)) {
                         f.lazy_status = .unavailable;
                         return;
                     },
                     .unavailable => unreachable,
                 }
-                if (f.job_queue.read_only) return f.fail(
+                if (job_queue.read_only) return f.fail(
                     f.name_tok,
-                    try eb.printString("package not found at '{f}{s}'", .{
-                        cache_root, pkg_sub_path,
-                    }),
+                    try eb.printString("package not found at '{f}'", .{package_root}),
                 );
             },
             else => |e| {
                 try eb.addRootErrorMessage(.{
-                    .msg = try eb.printString("unable to open global package cache directory '{f}{s}': {s}", .{
-                        cache_root, pkg_sub_path, @errorName(e),
+                    .msg = try eb.printString("unable to open package cache directory {f}: {t}", .{
+                        package_root, e,
                     }),
                 });
                 return error.FetchFailed;
             },
         }
-    } else if (f.job_queue.read_only) {
+    } else if (job_queue.read_only) {
         try eb.addRootErrorMessage(.{
             .msg = try eb.addString("dependency is missing hash field"),
             .src_loc = try f.srcLoc(f.location_tok),
@@ -467,7 +458,7 @@ pub fn run(f: *Fetch) RunError!void {
 
     const uri = std.Uri.parse(remote.url) catch |err| return f.fail(
         f.location_tok,
-        try eb.printString("invalid URI: {s}", .{@errorName(err)}),
+        try eb.printString("invalid URI: {t}", .{err}),
     );
     var buffer: [init_resource_buffer_size]u8 = undefined;
     var resource: Resource = undefined;
@@ -487,29 +478,30 @@ fn runResource(
     resource: *Resource,
     remote_hash: ?Package.Hash,
 ) RunError!void {
-    const io = f.job_queue.io;
+    const job_queue = f.job_queue;
+    const io = job_queue.io;
     defer resource.deinit(io);
     const arena = f.arena.allocator();
     const eb = &f.error_bundle;
     const s = fs.path.sep_str;
-    const cache_root = f.job_queue.global_cache;
+    const local_cache_root = job_queue.local_cache;
     const rand_int = r: {
         var x: u64 = undefined;
         io.random(@ptrCast(&x));
         break :r x;
     };
     const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(rand_int);
+    const tmp_directory_path = try local_cache_root.join(arena, tmp_dir_sub_path);
 
     const package_sub_path = blk: {
-        const tmp_directory_path = try cache_root.join(arena, &.{tmp_dir_sub_path});
         var tmp_directory: Cache.Directory = .{
-            .path = tmp_directory_path,
+            .path = tmp_directory_path.sub_path,
             .handle = handle: {
-                const dir = cache_root.handle.createDirPathOpen(io, tmp_dir_sub_path, .{
+                const dir = tmp_directory_path.root_dir.handle.createDirPathOpen(io, tmp_directory_path.sub_path, .{
                     .open_options = .{ .iterate = true },
                 }) catch |err| {
                     try eb.addRootErrorMessage(.{
-                        .msg = try eb.printString("unable to create temporary directory '{s}': {t}", .{
+                        .msg = try eb.printString("unable to create temporary directory '{f}': {t}", .{
                             tmp_directory_path, err,
                         }),
                     });
@@ -545,36 +537,33 @@ fn runResource(
         // directory.
         f.computed_hash = try computeHash(f, pkg_path, filter);
 
-        break :blk if (unpack_result.root_dir.len > 0)
-            try fs.path.join(arena, &.{ tmp_dir_sub_path, unpack_result.root_dir })
-        else
-            tmp_dir_sub_path;
+        if (unpack_result.root_dir.len > 0)
+            break :blk try tmp_directory_path.join(arena, unpack_result.root_dir);
+
+        break :blk tmp_directory_path;
     };
 
     const computed_package_hash = computedPackageHash(f);
 
-    // Rename the temporary directory into the global zig package cache
-    // directory. If the hash already exists, delete the temporary directory
-    // and leave the zig package cache directory untouched as it may be in use
-    // by the system. This is done even if the hash is invalid, in case the
-    // package with the different hash is used in the future.
-
-    f.package_root = .{
-        .root_dir = cache_root,
-        .sub_path = try std.fmt.allocPrint(arena, "p" ++ s ++ "{s}", .{computed_package_hash.toSlice()}),
-    };
-    renameTmpIntoCache(io, cache_root.handle, package_sub_path, f.package_root.sub_path) catch |err| {
-        const src = try cache_root.join(arena, &.{tmp_dir_sub_path});
-        const dest = try cache_root.join(arena, &.{f.package_root.sub_path});
+    // Rename the temporary directory into the local zig package directory. If
+    // the hash already exists, delete the temporary directory and leave the
+    // zig package directory untouched as it may be in use. This is done even
+    // if the hash is invalid, in case the package with the different hash is
+    // used in the future.
+    f.package_root = try job_queue.root_pkg_path.join(arena, computed_package_hash.toSlice());
+    renameTmpIntoCache(io, package_sub_path, f.package_root) catch |err| {
         try eb.addRootErrorMessage(.{ .msg = try eb.printString(
-            "unable to rename temporary directory '{s}' into package cache directory '{s}': {s}",
-            .{ src, dest, @errorName(err) },
+            "unable to rename temporary directory {f} into package cache directory {f}: {t}",
+            .{ package_sub_path, f.package_root, err },
         ) });
         return error.FetchFailed;
     };
     // Remove temporary directory root if not already renamed to global cache.
-    if (!std.mem.eql(u8, package_sub_path, tmp_dir_sub_path)) {
-        cache_root.handle.deleteDir(io, tmp_dir_sub_path) catch {};
+    if (!package_sub_path.eql(tmp_directory_path)) {
+        tmp_directory_path.root_dir.handle.deleteDir(io, tmp_directory_path.sub_path) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| std.log.warn("failed to delete temporary directory {f}: {t}", .{ tmp_directory_path, e }),
+        };
     }
 
     // Validate the computed hash against the expected hash. If invalid, this
@@ -614,7 +603,7 @@ fn runResource(
 
     // Spawn a new fetch job for each dependency in the manifest file. Use
     // a mutex and a hash map so that redundant jobs do not get queued up.
-    if (!f.job_queue.recursive) return;
+    if (!job_queue.recursive) return;
     return queueJobsForDeps(f);
 }
 
@@ -641,8 +630,8 @@ fn checkBuildFileExistence(f: *Fetch) RunError!void {
         error.FileNotFound => {},
         else => |e| {
             try eb.addRootErrorMessage(.{
-                .msg = try eb.printString("unable to access '{f}{s}': {s}", .{
-                    f.package_root, Package.build_zig_basename, @errorName(e),
+                .msg = try eb.printString("unable to access '{f}{s}': {t}", .{
+                    f.package_root, Package.build_zig_basename, e,
                 }),
             });
             return error.FetchFailed;
@@ -667,9 +656,7 @@ fn loadManifest(f: *Fetch, pkg_root: Cache.Path) RunError!void {
         else => |e| {
             const file_path = try pkg_root.join(arena, Manifest.basename);
             try eb.addRootErrorMessage(.{
-                .msg = try eb.printString("unable to load package manifest '{f}': {s}", .{
-                    file_path, @errorName(e),
-                }),
+                .msg = try eb.printString("unable to load package manifest '{f}': {t}", .{ file_path, e }),
             });
             return error.FetchFailed;
         },
@@ -1453,14 +1440,20 @@ fn recursiveDirectoryCopy(f: *Fetch, dir: Io.Dir, tmp_dir: Io.Dir) anyerror!void
     }
 }
 
-pub fn renameTmpIntoCache(io: Io, cache_dir: Io.Dir, tmp_dir_sub_path: []const u8, dest_dir_sub_path: []const u8) !void {
-    assert(dest_dir_sub_path[1] == fs.path.sep);
+pub fn renameTmpIntoCache(io: Io, tmp_path: Cache.Path, dest_path: Cache.Path) !void {
     var handled_missing_dir = false;
     while (true) {
-        cache_dir.rename(tmp_dir_sub_path, cache_dir, dest_dir_sub_path, io) catch |err| switch (err) {
+        Io.Dir.rename(
+            tmp_path.root_dir.handle,
+            tmp_path.sub_path,
+            dest_path.root_dir.handle,
+            dest_path.sub_path,
+            io,
+        ) catch |err| switch (err) {
             error.FileNotFound => {
                 if (handled_missing_dir) return err;
-                cache_dir.createDir(io, dest_dir_sub_path[0..1], .default_dir) catch |mkd_err| switch (mkd_err) {
+                const parent_sub_path = Io.Dir.path.dirname(dest_path.sub_path).?;
+                dest_path.root_dir.handle.createDir(io, parent_sub_path, .default_dir) catch |er| switch (er) {
                     error.PathAlreadyExists => handled_missing_dir = true,
                     else => |e| return e,
                 };
@@ -1468,9 +1461,11 @@ pub fn renameTmpIntoCache(io: Io, cache_dir: Io.Dir, tmp_dir_sub_path: []const u
             },
             error.DirNotEmpty, error.AccessDenied => {
                 // Package has been already downloaded and may already be in use on the system.
-                cache_dir.deleteTree(io, tmp_dir_sub_path) catch {
+                tmp_path.root_dir.handle.deleteTree(io, tmp_path.sub_path) catch |er| switch (er) {
+                    error.Canceled => |e| return e,
                     // Garbage files leftover in zig-cache/tmp/ is, as they say
                     // on Star Trek, "operating within normal parameters".
+                    else => |e| std.log.warn("failed to delete temporary directory {f}: {t}", .{ tmp_path, e }),
                 };
             },
             else => |e| return e,
@@ -2244,6 +2239,7 @@ fn saveEmbedFile(io: Io, comptime tarball_name: []const u8, dir: Io.Dir) !void {
 const TestFetchBuilder = struct {
     http_client: std.http.Client,
     global_cache_directory: Cache.Directory,
+    local_cache_path: Cache.Path,
     job_queue: Fetch.JobQueue,
     fetch: Fetch,
 
@@ -2254,15 +2250,25 @@ const TestFetchBuilder = struct {
         cache_parent_dir: std.Io.Dir,
         path_or_url: []const u8,
     ) !*Fetch {
-        const cache_dir = try cache_parent_dir.createDirPathOpen(io, "zig-global-cache", .{});
+        const global_cache_dir = try cache_parent_dir.createDirPathOpen(io, "zig-global-cache", .{});
+        const package_root_dir = try cache_parent_dir.createDirPathOpen(io, "local-project-root", .{});
 
         self.http_client = .{ .allocator = allocator, .io = io };
-        self.global_cache_directory = .{ .handle = cache_dir, .path = null };
+        self.global_cache_directory = .{ .handle = global_cache_dir, .path = "zig-global-cache" };
+        self.local_cache_path = .{
+            .root_dir = .{ .handle = package_root_dir, .path = "local-project-root" },
+            .sub_path = ".zig-cache",
+        };
 
         self.job_queue = .{
             .io = io,
             .http_client = &self.http_client,
             .global_cache = self.global_cache_directory,
+            .local_cache = self.local_cache_path,
+            .root_pkg_path = .{
+                .root_dir = .{ .handle = package_root_dir, .path = "local-project-root" },
+                .sub_path = "zig-pkg",
+            },
             .recursive = false,
             .read_only = false,
             .debug_hash = false,
@@ -2276,7 +2282,7 @@ const TestFetchBuilder = struct {
             .hash_tok = .none,
             .name_tok = 0,
             .lazy_status = .eager,
-            .parent_package_root = Cache.Path{ .root_dir = Cache.Directory{ .handle = cache_dir, .path = null } },
+            .parent_package_root = .{ .root_dir = .{ .handle = package_root_dir, .path = null } },
             .parent_manifest_ast = null,
             .prog_node = std.Progress.Node.none,
             .job_queue = &self.job_queue,
diff --git a/src/main.zig b/src/main.zig
index 1e9c0de6564be4e81661182f07877fd3a7a17cbc..02a49ef3e04aab0c27981d373dc3924192387927 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5239,6 +5239,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     .io = io,
                     .http_client = &http_client,
                     .global_cache = dirs.global_cache,
+                    .local_cache = .{ .root_dir = dirs.local_cache, .sub_path = "" },
+                    .root_pkg_path = .{ .root_dir = build_root.directory, .sub_path = "zig-pkg" },
                     .read_only = false,
                     .recursive = true,
                     .debug_hash = false,
@@ -5248,12 +5250,17 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                 defer job_queue.deinit();
 
                 if (system_pkg_dir_path) |p| {
-                    job_queue.global_cache = .{
-                        .path = p,
-                        .handle = Io.Dir.cwd().openDir(io, p, .{}) catch |err| {
-                            fatal("unable to open system package directory '{s}': {t}", .{ p, err });
+                    const system_pkg_path: Path = .{
+                        .root_dir = .{
+                            .path = p,
+                            .handle = Io.Dir.cwd().openDir(io, p, .{}) catch |err| {
+                                fatal("unable to open system package directory '{s}': {t}", .{ p, err });
+                            },
                         },
+                        .sub_path = "",
                     };
+                    job_queue.global_cache = system_pkg_path.root_dir;
+                    job_queue.root_pkg_path = system_pkg_path;
                     job_queue.read_only = true;
                     cleanup_build_dir = job_queue.global_cache.handle;
                 } else {
@@ -6996,10 +7003,27 @@ fn cmdFetch(
     };
     defer global_cache_directory.handle.close(io);
 
+    const cwd_path = try introspect.getResolvedCwd(io, arena);
+
+    var build_root = try findBuildRoot(arena, io, .{
+        .cwd_path = cwd_path,
+    });
+    defer build_root.deinit(io);
+
+    const local_cache_path: Path = .{
+        .root_dir = build_root.directory,
+        .sub_path = ".zig-cache",
+    };
+
     var job_queue: Package.Fetch.JobQueue = .{
         .io = io,
         .http_client = &http_client,
         .global_cache = global_cache_directory,
+        .local_cache = local_cache_path,
+        .root_pkg_path = .{
+            .root_dir = build_root.directory,
+            .sub_path = "zig-pkg",
+        },
         .recursive = false,
         .read_only = false,
         .debug_hash = debug_hash,
@@ -7069,13 +7093,6 @@ fn cmdFetch(
         },
     };
 
-    const cwd_path = try introspect.getResolvedCwd(io, arena);
-
-    var build_root = try findBuildRoot(arena, io, .{
-        .cwd_path = cwd_path,
-    });
-    defer build_root.deinit(io);
-
     // The name to use in case the manifest file needs to be created now.
     const init_root_name = fs.path.basename(build_root.directory.path orelse cwd_path);
     var manifest, var ast = try loadManifest(gpa, arena, io, .{
@@ -7239,18 +7256,25 @@ fn createDependenciesModule(
         defer tmp_dir.close(io);
         try tmp_dir.writeFile(io, .{ .sub_path = basename, .data = source });
     }
+    const tmp_dir_path: Path = .{
+        .root_dir = dirs.local_cache,
+        .sub_path = tmp_dir_sub_path,
+    };
 
     var hh: Cache.HashHelper = .{};
     hh.addBytes(build_options.version);
     hh.addBytes(source);
     const hex_digest = hh.final();
 
-    const o_dir_sub_path = try arena.dupe(u8, "o" ++ fs.path.sep_str ++ hex_digest);
-    try Package.Fetch.renameTmpIntoCache(io, dirs.local_cache.handle, tmp_dir_sub_path, o_dir_sub_path);
+    const o_dir_path: Path = .{
+        .root_dir = dirs.local_cache,
+        .sub_path = try arena.dupe(u8, "o" ++ fs.path.sep_str ++ hex_digest),
+    };
+    try Package.Fetch.renameTmpIntoCache(io, tmp_dir_path, o_dir_path);
 
     const deps_mod = try Package.Module.create(arena, .{
         .paths = .{
-            .root = try .fromRoot(arena, dirs, .local_cache, o_dir_sub_path),
+            .root = try .fromRoot(arena, dirs, .local_cache, o_dir_path.sub_path),
             .root_src_path = basename,
         },
         .fully_qualified_name = "root.@dependencies",
-- 
2.54.0


From df64a3a36815fce6cc8671d047e52795655b3b9b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 17:40:54 -0800
Subject: [PATCH 213/499] build: packages now require fingerprint

also the name must be an enum literal.

delete some .tar.gz test data. Test data should be in text form when it
can be, and this could definitely be.
---
 src/Package/Fetch.zig                         | 132 ------------------
 .../Fetch/testdata/duplicate_paths.tar.gz     | Bin 3230 -> 0 bytes
 .../testdata/duplicate_paths_excluded.tar.gz  | Bin 3237 -> 0 bytes
 src/Package/Fetch/testdata/no_root.tar.gz     | Bin 3172 -> 0 bytes
 src/Package/Manifest.zig                      |  34 +----
 src/main.zig                                  |   4 -
 6 files changed, 7 insertions(+), 163 deletions(-)
 delete mode 100644 src/Package/Fetch/testdata/duplicate_paths.tar.gz
 delete mode 100644 src/Package/Fetch/testdata/duplicate_paths_excluded.tar.gz
 delete mode 100644 src/Package/Fetch/testdata/no_root.tar.gz

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 96018851ce47e19ede2a6855eb6dad6a07745527..a9cc86b398ef5ee6d3d83835f41f556ade34782e 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -60,8 +60,6 @@ omit_missing_hash_error: bool,
 /// which specifies inclusion rules. This is intended to be true for the first
 /// fetch task and false for the recursive dependencies.
 allow_missing_paths_field: bool,
-allow_missing_fingerprint: bool,
-allow_name_string: bool,
 /// If true and URL points to a Git repository, will use the latest commit.
 use_latest_commit: bool,
 
@@ -675,8 +673,6 @@ fn loadManifest(f: *Fetch, pkg_root: Cache.Path) RunError!void {
 
     f.manifest = try Manifest.parse(arena, ast.*, rng.interface(), .{
         .allow_missing_paths_field = f.allow_missing_paths_field,
-        .allow_missing_fingerprint = f.allow_missing_fingerprint,
-        .allow_name_string = f.allow_name_string,
     });
     const manifest = &f.manifest.?;
 
@@ -794,8 +790,6 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
                 .job_queue = f.job_queue,
                 .omit_missing_hash_error = false,
                 .allow_missing_paths_field = true,
-                .allow_missing_fingerprint = true,
-                .allow_name_string = true,
                 .use_latest_commit = false,
 
                 .package_root = undefined,
@@ -2049,130 +2043,6 @@ const UnpackResult = struct {
     }
 };
 
-test "tarball with duplicate paths" {
-    // This tarball has duplicate path 'dir1/file1' to simulate case sensitve
-    // file system on any file sytstem.
-    //
-    //     duplicate_paths/
-    //     duplicate_paths/dir1/
-    //     duplicate_paths/dir1/file1
-    //     duplicate_paths/dir1/file1
-    //     duplicate_paths/build.zig.zon
-    //     duplicate_paths/src/
-    //     duplicate_paths/src/main.zig
-    //     duplicate_paths/src/root.zig
-    //     duplicate_paths/build.zig
-    //
-
-    const gpa = std.testing.allocator;
-    const io = std.testing.io;
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-
-    const tarball_name = "duplicate_paths.tar.gz";
-    try saveEmbedFile(io, tarball_name, tmp.dir);
-    const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
-    defer gpa.free(tarball_path);
-
-    // Run tarball fetch, expect to fail
-    var fb: TestFetchBuilder = undefined;
-    var fetch = try fb.build(gpa, io, tmp.dir, tarball_path);
-    defer fb.deinit();
-    try std.testing.expectError(error.FetchFailed, fetch.run());
-
-    try fb.expectFetchErrors(1,
-        \\error: unable to unpack tarball
-        \\    note: unable to create file 'dir1/file1': PathAlreadyExists
-        \\
-    );
-}
-
-test "tarball with excluded duplicate paths" {
-    // Same as previous tarball but has build.zig.zon wich excludes 'dir1'.
-    //
-    //     .paths = .{
-    //        "build.zig",
-    //        "build.zig.zon",
-    //        "src",
-    //    }
-    //
-
-    const gpa = std.testing.allocator;
-    const io = std.testing.io;
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-
-    const tarball_name = "duplicate_paths_excluded.tar.gz";
-    try saveEmbedFile(io, tarball_name, tmp.dir);
-    const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
-    defer gpa.free(tarball_path);
-
-    // Run tarball fetch, should succeed
-    var fb: TestFetchBuilder = undefined;
-    var fetch = try fb.build(gpa, io, tmp.dir, tarball_path);
-    defer fb.deinit();
-    try fetch.run();
-
-    const hex_digest = Package.multiHashHexDigest(fetch.computed_hash.digest);
-    try std.testing.expectEqualStrings(
-        "12200bafe035cbb453dd717741b66e9f9d1e6c674069d06121dafa1b2e62eb6b22da",
-        &hex_digest,
-    );
-
-    const expected_files: []const []const u8 = &.{
-        "build.zig",
-        "build.zig.zon",
-        "src/main.zig",
-        "src/root.zig",
-    };
-    try fb.expectPackageFiles(expected_files);
-}
-
-test "tarball without root folder" {
-    // Tarball with root folder. Manifest excludes dir1 and dir2.
-    //
-    //    build.zig
-    //    build.zig.zon
-    //    dir1/
-    //    dir1/file2
-    //    dir1/file1
-    //    dir2/
-    //    dir2/file2
-    //    src/
-    //    src/main.zig
-    //
-
-    const gpa = std.testing.allocator;
-    const io = std.testing.io;
-
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-
-    const tarball_name = "no_root.tar.gz";
-    try saveEmbedFile(io, tarball_name, tmp.dir);
-    const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
-    defer gpa.free(tarball_path);
-
-    // Run tarball fetch, should succeed
-    var fb: TestFetchBuilder = undefined;
-    var fetch = try fb.build(gpa, io, tmp.dir, tarball_path);
-    defer fb.deinit();
-    try fetch.run();
-
-    const hex_digest = Package.multiHashHexDigest(fetch.computed_hash.digest);
-    try std.testing.expectEqualStrings(
-        "12209f939bfdcb8b501a61bb4a43124dfa1b2848adc60eec1e4624c560357562b793",
-        &hex_digest,
-    );
-
-    const expected_files: []const []const u8 = &.{
-        "build.zig",
-        "build.zig.zon",
-        "src/main.zig",
-    };
-    try fb.expectPackageFiles(expected_files);
-}
-
 test "set executable bit based on file content" {
     if (!Io.File.Permissions.has_executable_bit) return error.SkipZigTest;
     const gpa = std.testing.allocator;
@@ -2288,8 +2158,6 @@ const TestFetchBuilder = struct {
             .job_queue = &self.job_queue,
             .omit_missing_hash_error = true,
             .allow_missing_paths_field = false,
-            .allow_missing_fingerprint = true, // so we can keep using the old testdata .tar.gz
-            .allow_name_string = true, // so we can keep using the old testdata .tar.gz
             .use_latest_commit = true,
 
             .package_root = undefined,
diff --git a/src/Package/Fetch/testdata/duplicate_paths.tar.gz b/src/Package/Fetch/testdata/duplicate_paths.tar.gz
deleted file mode 100644
index 118a934c1b03d764e4854f9aeb60ed684467caad..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3230
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
Q<99Uv2QI@^xByT905N}g`2YX_

diff --git a/src/Package/Fetch/testdata/duplicate_paths_excluded.tar.gz b/src/Package/Fetch/testdata/duplicate_paths_excluded.tar.gz
deleted file mode 100644
index 760b37cd40fe43e0907f14943a33ae8341f2f649..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3237
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
Xe)OXs{pd$OenaEGmP{QK08jt`nu}hw

diff --git a/src/Package/Fetch/testdata/no_root.tar.gz b/src/Package/Fetch/testdata/no_root.tar.gz
deleted file mode 100644
index a3a4baf40fd1d6b2bd101ee59f27f88c6a61f97f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3172
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
KksQ4MPyhh%Hx@Dg

diff --git a/src/Package/Manifest.zig b/src/Package/Manifest.zig
index a8bc8b501384a01c782719602c321bb7d4525818..e66a78ae14b7c93bd233fe9327e6631b82702170 100644
--- a/src/Package/Manifest.zig
+++ b/src/Package/Manifest.zig
@@ -49,10 +49,6 @@ arena_state: std.heap.ArenaAllocator.State,
 
 pub const ParseOptions = struct {
     allow_missing_paths_field: bool = false,
-    /// Deprecated, to be removed after 0.14.0 is tagged.
-    allow_name_string: bool = true,
-    /// Deprecated, to be removed after 0.14.0 is tagged.
-    allow_missing_fingerprint: bool = true,
 };
 
 pub const Error = Allocator.Error;
@@ -77,8 +73,6 @@ pub fn parse(gpa: Allocator, ast: Ast, rng: std.Random, options: ParseOptions) E
         .dependencies_node = .none,
         .paths = .{},
         .allow_missing_paths_field = options.allow_missing_paths_field,
-        .allow_name_string = options.allow_name_string,
-        .allow_missing_fingerprint = options.allow_missing_fingerprint,
         .minimum_zig_version = null,
         .buf = .{},
     };
@@ -151,8 +145,6 @@ const Parse = struct {
     dependencies_node: Ast.Node.OptionalIndex,
     paths: std.StringArrayHashMapUnmanaged(void),
     allow_missing_paths_field: bool,
-    allow_name_string: bool,
-    allow_missing_fingerprint: bool,
     minimum_zig_version: ?std.SemanticVersion,
 
     const InnerError = error{ ParseFailure, OutOfMemory };
@@ -221,12 +213,10 @@ const Parse = struct {
                     });
                 }
                 p.id = n.id;
-            } else if (!p.allow_missing_fingerprint) {
+            } else {
                 try appendError(p, main_token, "missing top-level 'fingerprint' field; suggested value: 0x{x}", .{
                     Package.Fingerprint.generate(rng, p.name).int(),
                 });
-            } else {
-                p.id = 0;
             }
         }
 
@@ -395,19 +385,6 @@ const Parse = struct {
         const ast = p.ast;
         const main_token = ast.nodeMainToken(node);
 
-        if (p.allow_name_string and ast.nodeTag(node) == .string_literal) {
-            const name = try parseString(p, node);
-            if (!std.zig.isValidId(name))
-                return fail(p, main_token, "name must be a valid bare zig identifier (hint: switch from string to enum literal)", .{});
-
-            if (name.len > max_name_len)
-                return fail(p, main_token, "name '{f}' exceeds max length of {d}", .{
-                    std.zig.fmtId(name), max_name_len,
-                });
-
-            return name;
-        }
-
         if (ast.nodeTag(node) != .enum_literal)
             return fail(p, main_token, "expected enum literal", .{});
 
@@ -606,7 +583,8 @@ test "basic" {
 
     const example =
         \\.{
-        \\    .name = "foo",
+        \\    .name = .foo,
+        \\    .fingerprint = 0x8c736521490b23df,
         \\    .version = "3.2.1",
         \\    .paths = .{""},
         \\    .dependencies = .{
@@ -656,7 +634,8 @@ test "minimum_zig_version" {
 
     const example =
         \\.{
-        \\    .name = "foo",
+        \\    .name = .foo,
+        \\    .fingerprint = 0x8c736521490b23df,
         \\    .version = "3.2.1",
         \\    .paths = .{""},
         \\    .minimum_zig_version = "0.11.1",
@@ -690,7 +669,8 @@ test "minimum_zig_version - invalid version" {
 
     const example =
         \\.{
-        \\    .name = "foo",
+        \\    .name = .foo,
+        \\    .fingerprint = 0x8c736521490b23df,
         \\    .version = "3.2.1",
         \\    .minimum_zig_version = "X.11.1",
         \\    .paths = .{""},
diff --git a/src/main.zig b/src/main.zig
index 02a49ef3e04aab0c27981d373dc3924192387927..4ef99de0aee390d513ca7cea2948aeaf8e163645 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5285,8 +5285,6 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     .job_queue = &job_queue,
                     .omit_missing_hash_error = true,
                     .allow_missing_paths_field = false,
-                    .allow_missing_fingerprint = false,
-                    .allow_name_string = false,
                     .use_latest_commit = false,
 
                     .package_root = undefined,
@@ -7044,8 +7042,6 @@ fn cmdFetch(
         .job_queue = &job_queue,
         .omit_missing_hash_error = true,
         .allow_missing_paths_field = false,
-        .allow_missing_fingerprint = true,
-        .allow_name_string = true,
         .use_latest_commit = true,
 
         .package_root = undefined,
-- 
2.54.0


From ee21a1f988f05a5d45bcb1724095c27cc2c7259b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Feb 2026 21:40:06 -0800
Subject: [PATCH 214/499] fetch: implement recompression

After fetching a package and applying the filter by deleting files that
are not part of the hash, creates a recompressed $GLOBAL_CACHE/p/$PKG_HASH.tar.gz

Checking this cache before fetching network URLs is not yet implemented.
---
 lib/std/Io.zig                      |   6 ++
 lib/std/compress/flate/Compress.zig |   2 +-
 src/Package/Fetch.zig               | 142 +++++++++++++++++++++++++---
 3 files changed, 136 insertions(+), 14 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 47ba7c2072c7bc1d954bdc21c85577cb71703bbe..c56ec6886683d707fc5f14db62e9dc7468159430 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1031,6 +1031,9 @@ pub const Group = struct {
     /// Once this function is called, there are resources associated with the
     /// group. To release those resources, `Group.await` or `Group.cancel` must
     /// eventually be called.
+    ///
+    /// If `error.Canceled` is returned from any operation this task performs,
+    /// it is asserted that `function` returns `error.Canceled`.
     pub fn async(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
@@ -1050,6 +1053,9 @@ pub const Group = struct {
     /// Once this function is called, there are resources associated with the
     /// group. To release those resources, `Group.await` or `Group.cancel` must
     /// eventually be called.
+    ///
+    /// If `error.Canceled` is returned from any operation this task performs,
+    /// it is asserted that `function` returns `error.Canceled`.
     pub fn concurrent(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) ConcurrentError!void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
diff --git a/lib/std/compress/flate/Compress.zig b/lib/std/compress/flate/Compress.zig
index 41b7d8bf04ccf29fa9f35f2906848f62b36f294e..0a85dd9d0a3c2ce53d7735bd8e4dd1aaec52b2b2 100644
--- a/lib/std/compress/flate/Compress.zig
+++ b/lib/std/compress/flate/Compress.zig
@@ -267,7 +267,7 @@ pub const Options = struct {
     pub const best = level_9;
 };
 
-/// It is asserted `buffer` is least `flate.max_history_len` bytes.
+/// It is asserted `buffer` is least `flate.max_window_len` bytes.
 /// It is asserted `output` has a capacity of at least 8 bytes.
 pub fn init(
     output: *Writer,
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index a9cc86b398ef5ee6d3d83835f41f556ade34782e..e9e340c099e57e5a072e7107785253bc34c85e70 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -1,28 +1,34 @@
 //! Represents one independent job whose responsibility is to:
 //!
-//! 1. Check the global zig package cache to see if the hash already exists.
+//! 1. Check the local zig package directory to see if the hash already exists.
 //!    If so, load, parse, and validate the build.zig.zon file therein, and
-//!    goto step 8. Likewise if the location is a relative path, treat this
+//!    goto step 9. Likewise if the location is a relative path, treat this
 //!    the same as a cache hit. Otherwise, proceed.
-//! 2. Fetch and unpack a URL into a temporary directory.
-//! 3. Load, parse, and validate the build.zig.zon file therein. It is allowed
+//! 2. Check the global package cache for a compressed tarball matching the
+//!    hash. If it is found, unpack the contents into a temporary directory inside
+//!    project local zig cache. Rename this directory into the local zig package
+//!    directory and goto step 9, skipping step 10.
+//! 3. Fetch and unpack a URL into a temporary directory.
+//! 4. Load, parse, and validate the build.zig.zon file therein. It is allowed
 //!    for the file to be missing, in which case this fetched package is considered
 //!    to be a "naked" package.
-//! 4. Apply inclusion rules of the build.zig.zon to the temporary directory by
+//! 5. Apply inclusion rules of the build.zig.zon to the temporary directory by
 //!    deleting excluded files. If any files had errors for files that were
 //!    ultimately excluded, those errors should be ignored, such as failure to
 //!    create symlinks that weren't supposed to be included anyway.
-//! 5. Compute the package hash based on the remaining files in the temporary
+//! 6. Compute the package hash based on the remaining files in the temporary
 //!    directory.
-//! 6. Rename the temporary directory into the global zig package cache
-//!    directory. If the hash already exists, delete the temporary directory and
-//!    leave the zig package cache directory untouched as it may be in use by the
-//!    system. This is done even if the hash is invalid, in case the package with
-//!    the different hash is used in the future.
-//! 7. Validate the computed hash against the expected hash. If invalid,
+//! 7. Rename the temporary directory into the local zig package directory. If
+//!    the hash already exists, delete the temporary directory and leave the zig
+//!    package directory untouched as it may be in use. This is done even if
+//!    the hash is invalid, in case the package with the different hash is used
+//!    in the future.
+//! 8. Validate the computed hash against the expected hash. If invalid,
 //!    this job is done.
-//! 8. Spawn a new fetch job for each dependency in the manifest file. Use
+//! 9. Spawn a new fetch job for each dependency in the manifest file. Use
 //!    a mutex and a hash map so that redundant jobs do not get queued up.
+//! 10.Compress the package directory and store it into the global package
+//!    cache.
 //!
 //! All of this must be done with only referring to the state inside this struct
 //! because this work will be done in a dedicated thread.
@@ -110,6 +116,7 @@ pub const JobQueue = struct {
     all_fetches: std.ArrayList(*Fetch) = .empty,
 
     http_client: *std.http.Client,
+    /// This tracks `Fetch` tasks as well as recompression tasks.
     group: Io.Group = .init,
     global_cache: Cache.Directory,
     local_cache: Cache.Path,
@@ -293,8 +300,109 @@ pub const JobQueue = struct {
             \\
         );
     }
+
+    fn recompress(jq: *JobQueue, package_hash: Package.Hash) Io.Cancelable!void {
+        var dest_sub_path_buffer: ["p/".len + Package.Hash.max_len + ".tar.gz".len]u8 = undefined;
+        const dest_path: Cache.Path = .{
+            .root_dir = jq.global_cache,
+            .sub_path = std.fmt.bufPrint(&dest_sub_path_buffer, "p/{s}.tar.gz", .{
+                package_hash.toSlice(),
+            }) catch unreachable,
+        };
+
+        const gpa = jq.http_client.allocator;
+
+        var arena_instance = std.heap.ArenaAllocator.init(gpa);
+        defer arena_instance.deinit();
+        const arena = arena_instance.allocator();
+
+        recompressFallible(jq, arena, dest_path, package_hash.toSlice()) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            error.ReadFailed => comptime unreachable,
+            error.WriteFailed => comptime unreachable,
+            else => |e| std.log.warn("failed caching recompressed tarball to {f}: {t}", .{ dest_path, e }),
+        };
+    }
+
+    fn recompressFallible(jq: *JobQueue, arena: Allocator, dest_path: Cache.Path, package_hash: []const u8) !void {
+        const gpa = jq.http_client.allocator;
+        const io = jq.io;
+
+        // We have to walk the file system up front in order to sort the file
+        // list for determinism purposes. The hash of the recompressed file is
+        // not critical because the true hash is based on the content alone.
+        // However, if we want Zig users to be able to share cached package
+        // data with each other via peer-to-peer protocols, we benefit greatly
+        // from the data being identical on everyone's computers.
+        var scanned_files: std.ArrayList([]const u8) = .empty;
+        defer scanned_files.deinit(gpa);
+
+        var pkg_dir = try jq.root_pkg_path.openDir(io, package_hash, .{ .iterate = true });
+        defer pkg_dir.close(io);
+
+        {
+            var walker = try pkg_dir.walk(gpa);
+            defer walker.deinit();
+
+            while (try walker.next(io)) |entry| {
+                switch (entry.kind) {
+                    .directory => continue,
+                    .file, .sym_link => {},
+                    else => {
+                        return error.IllegalFileType;
+                    },
+                }
+                const entry_path = try arena.dupe(u8, entry.path);
+                try scanned_files.append(gpa, entry_path);
+            }
+
+            std.mem.sortUnstable([]const u8, scanned_files.items, {}, stringCmp);
+        }
+
+        var atomic_file = try dest_path.root_dir.handle.createFileAtomic(io, dest_path.sub_path, .{
+            .make_path = true,
+            .replace = true,
+        });
+        defer atomic_file.deinit(io);
+
+        var file_write_buffer: [4096]u8 = undefined;
+        var file_writer = atomic_file.file.writer(io, &file_write_buffer);
+
+        var compress_buffer: [std.compress.flate.max_window_len]u8 = undefined;
+        var compress = std.compress.flate.Compress.init(&file_writer.interface, &compress_buffer, .gzip, .level_9) catch |err| switch (err) {
+            error.WriteFailed => return file_writer.err.?,
+        };
+
+        var archiver: std.tar.Writer = .{ .underlying_writer = &compress.writer };
+        archiver.prefix = package_hash;
+
+        var file_read_buffer: [4096]u8 = undefined;
+
+        for (scanned_files.items) |entry_path| {
+            var file = try pkg_dir.openFile(io, entry_path, .{});
+            defer file.close(io);
+            var file_reader: Io.File.Reader = .init(file, io, &file_read_buffer);
+            archiver.writeFile(entry_path, &file_reader, 0) catch |err| switch (err) {
+                error.ReadFailed => return file_reader.err.?,
+                error.WriteFailed => return file_writer.err.?,
+                else => |e| return e,
+            };
+        }
+
+        // intentionally omitting the pointless trailer
+        //try archiver.finish();
+        compress.writer.flush() catch |err| switch (err) {
+            error.WriteFailed => return file_writer.err.?,
+        };
+        try file_writer.flush();
+        try atomic_file.replace(io);
+    }
 };
 
+fn stringCmp(_: void, lhs: []const u8, rhs: []const u8) bool {
+    return std.mem.lessThan(u8, lhs, rhs);
+}
+
 pub const Location = union(enum) {
     remote: Remote,
     /// A directory found inside the parent package.
@@ -477,8 +585,11 @@ fn runResource(
     remote_hash: ?Package.Hash,
 ) RunError!void {
     const job_queue = f.job_queue;
+    assert(!job_queue.read_only);
+
     const io = job_queue.io;
     defer resource.deinit(io);
+
     const arena = f.arena.allocator();
     const eb = &f.error_bundle;
     const s = fs.path.sep_str;
@@ -556,6 +667,11 @@ fn runResource(
         ) });
         return error.FetchFailed;
     };
+
+    // Spin off a task to recompress the tarball, with filtered files deleted, into
+    // the global cache.
+    job_queue.group.async(io, JobQueue.recompress, .{ job_queue, computed_package_hash });
+
     // Remove temporary directory root if not already renamed to global cache.
     if (!package_sub_path.eql(tmp_directory_path)) {
         tmp_directory_path.root_dir.handle.deleteDir(io, tmp_directory_path.sub_path) catch |err| switch (err) {
-- 
2.54.0


From 7246eee1e706b142abf8183e960fd692fde52bb0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Feb 2026 16:44:37 -0800
Subject: [PATCH 215/499] std.Progress: add Node.startFmt

convenience method for starting a child node with a formatted string as
a name.
---
 lib/std/Progress.zig | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 2240f95fddd65b97681d6803f4e9ffef0d0c8369..aee7602bf58a2b30d47afe98387ebeff4024fc22 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -325,6 +325,12 @@ pub const Node = struct {
         return init(@enumFromInt(free_index), parent, name, estimated_total_items);
     }
 
+    pub fn startFmt(node: Node, estimated_total_items: usize, comptime format: []const u8, args: anytype) Node {
+        var buffer: [max_name_len]u8 = undefined;
+        const name = std.fmt.bufPrint(&buffer, format, args) catch &buffer;
+        return Node.start(node, name, estimated_total_items);
+    }
+
     /// This is the same as calling `start` and then `end` on the returned `Node`. Thread-safe.
     pub fn completeOne(n: Node) void {
         const index = n.index.unwrap() orelse return;
-- 
2.54.0


From 1f65e7cccc3124ce2fa9a5e8107c32367a39ec29 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Feb 2026 16:46:20 -0800
Subject: [PATCH 216/499] fetch: recompress task integrates with std.Progress

---
 src/Package/Fetch.zig | 30 ++++++++++++++++++++++--------
 src/main.zig          |  2 ++
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index e9e340c099e57e5a072e7107785253bc34c85e70..7d69265f5c42b8475b2354ca6ea5544ffbdcfea8 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -114,6 +114,7 @@ pub const JobQueue = struct {
     /// field contains references to all of them.
     /// Protected by `mutex`.
     all_fetches: std.ArrayList(*Fetch) = .empty,
+    prog_node: std.Progress.Node,
 
     http_client: *std.http.Client,
     /// This tracks `Fetch` tasks as well as recompression tasks.
@@ -302,12 +303,15 @@ pub const JobQueue = struct {
     }
 
     fn recompress(jq: *JobQueue, package_hash: Package.Hash) Io.Cancelable!void {
-        var dest_sub_path_buffer: ["p/".len + Package.Hash.max_len + ".tar.gz".len]u8 = undefined;
+        const pkg_hash_slice = package_hash.toSlice();
+
+        const prog_node = jq.prog_node.startFmt(0, "recompress {s}", .{pkg_hash_slice});
+        defer prog_node.end();
+
+        var dest_sub_path_buf: ["p/".len + Package.Hash.max_len + ".tar.gz".len]u8 = undefined;
         const dest_path: Cache.Path = .{
             .root_dir = jq.global_cache,
-            .sub_path = std.fmt.bufPrint(&dest_sub_path_buffer, "p/{s}.tar.gz", .{
-                package_hash.toSlice(),
-            }) catch unreachable,
+            .sub_path = std.fmt.bufPrint(&dest_sub_path_buf, "p/{s}.tar.gz", .{pkg_hash_slice}) catch unreachable,
         };
 
         const gpa = jq.http_client.allocator;
@@ -316,7 +320,7 @@ pub const JobQueue = struct {
         defer arena_instance.deinit();
         const arena = arena_instance.allocator();
 
-        recompressFallible(jq, arena, dest_path, package_hash.toSlice()) catch |err| switch (err) {
+        recompressFallible(jq, arena, dest_path, pkg_hash_slice, prog_node) catch |err| switch (err) {
             error.Canceled => |e| return e,
             error.ReadFailed => comptime unreachable,
             error.WriteFailed => comptime unreachable,
@@ -324,7 +328,13 @@ pub const JobQueue = struct {
         };
     }
 
-    fn recompressFallible(jq: *JobQueue, arena: Allocator, dest_path: Cache.Path, package_hash: []const u8) !void {
+    fn recompressFallible(
+        jq: *JobQueue,
+        arena: Allocator,
+        dest_path: Cache.Path,
+        pkg_hash_slice: []const u8,
+        prog_node: std.Progress.Node,
+    ) !void {
         const gpa = jq.http_client.allocator;
         const io = jq.io;
 
@@ -337,7 +347,7 @@ pub const JobQueue = struct {
         var scanned_files: std.ArrayList([]const u8) = .empty;
         defer scanned_files.deinit(gpa);
 
-        var pkg_dir = try jq.root_pkg_path.openDir(io, package_hash, .{ .iterate = true });
+        var pkg_dir = try jq.root_pkg_path.openDir(io, pkg_hash_slice, .{ .iterate = true });
         defer pkg_dir.close(io);
 
         {
@@ -359,6 +369,8 @@ pub const JobQueue = struct {
             std.mem.sortUnstable([]const u8, scanned_files.items, {}, stringCmp);
         }
 
+        prog_node.setEstimatedTotalItems(scanned_files.items.len);
+
         var atomic_file = try dest_path.root_dir.handle.createFileAtomic(io, dest_path.sub_path, .{
             .make_path = true,
             .replace = true,
@@ -374,7 +386,7 @@ pub const JobQueue = struct {
         };
 
         var archiver: std.tar.Writer = .{ .underlying_writer = &compress.writer };
-        archiver.prefix = package_hash;
+        archiver.prefix = pkg_hash_slice;
 
         var file_read_buffer: [4096]u8 = undefined;
 
@@ -387,6 +399,7 @@ pub const JobQueue = struct {
                 error.WriteFailed => return file_writer.err.?,
                 else => |e| return e,
             };
+            prog_node.completeOne();
         }
 
         // intentionally omitting the pointless trailer
@@ -2259,6 +2272,7 @@ const TestFetchBuilder = struct {
             .read_only = false,
             .debug_hash = false,
             .mode = .needed,
+            .prog_node = std.Progress.Node.none,
         };
 
         self.fetch = .{
diff --git a/src/main.zig b/src/main.zig
index 4ef99de0aee390d513ca7cea2948aeaf8e163645..dba52807f544973724264eb1eda73f8c0452d28a 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5246,6 +5246,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     .debug_hash = false,
                     .unlazy_set = unlazy_set,
                     .mode = fetch_mode,
+                    .prog_node = fetch_prog_node,
                 };
                 defer job_queue.deinit();
 
@@ -7026,6 +7027,7 @@ fn cmdFetch(
         .read_only = false,
         .debug_hash = debug_hash,
         .mode = .all,
+        .prog_node = root_prog_node,
     };
     defer job_queue.deinit();
 
-- 
2.54.0


From d8171e8a2ee56e76bcd91f187d5ca5664b87bc83 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Feb 2026 17:36:14 -0800
Subject: [PATCH 217/499] fetch: check global cache for compressed tarball

before remote URL
---
 src/Package/Fetch.zig | 72 ++++++++++++++++++++++++++++++-------------
 1 file changed, 51 insertions(+), 21 deletions(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 7d69265f5c42b8475b2354ca6ea5544ffbdcfea8..d873fc9bd9a3eb4d5c316c273a6e4e05e3e77dc4 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -40,6 +40,7 @@ const native_os = builtin.os.tag;
 const std = @import("std");
 const Io = std.Io;
 const fs = std.fs;
+const log = std.log.scoped(.fetch);
 const assert = std.debug.assert;
 const ascii = std.ascii;
 const Allocator = std.mem.Allocator;
@@ -324,7 +325,7 @@ pub const JobQueue = struct {
             error.Canceled => |e| return e,
             error.ReadFailed => comptime unreachable,
             error.WriteFailed => comptime unreachable,
-            else => |e| std.log.warn("failed caching recompressed tarball to {f}: {t}", .{ dest_path, e }),
+            else => |e| log.warn("failed caching recompressed tarball to {f}: {t}", .{ dest_path, e }),
         };
     }
 
@@ -508,14 +509,14 @@ pub fn run(f: *Fetch) RunError!void {
         .path_or_url => |path_or_url| {
             if (Io.Dir.cwd().openDir(io, path_or_url, .{ .iterate = true })) |dir| {
                 var resource: Resource = .{ .dir = dir };
-                return f.runResource(path_or_url, &resource, null);
+                return f.runResource(path_or_url, &resource, null, false);
             } else |dir_err| {
                 var server_header_buffer: [init_resource_buffer_size]u8 = undefined;
 
                 const file_err = if (dir_err == error.NotDir) e: {
                     if (Io.Dir.cwd().openFile(io, path_or_url, .{})) |file| {
                         var resource: Resource = .{ .file = file.reader(io, &server_header_buffer) };
-                        return f.runResource(path_or_url, &resource, null);
+                        return f.runResource(path_or_url, &resource, null, false);
                     } else |err| break :e err;
                 } else dir_err;
 
@@ -527,11 +528,13 @@ pub fn run(f: *Fetch) RunError!void {
                 };
                 var resource: Resource = undefined;
                 try f.initResource(uri, &resource, &server_header_buffer);
-                return f.runResource(try uri.path.toRawMaybeAlloc(arena), &resource, null);
+                return f.runResource(try uri.path.toRawMaybeAlloc(arena), &resource, null, false);
             }
         },
     };
 
+    var resource_buffer: [init_resource_buffer_size]u8 = undefined;
+
     if (remote.hash) |expected_hash| {
         const package_root = try job_queue.root_pkg_path.join(arena, expected_hash.toSlice());
         if (package_root.root_dir.handle.access(io, package_root.sub_path, .{})) |_| {
@@ -543,19 +546,13 @@ pub fn run(f: *Fetch) RunError!void {
             return queueJobsForDeps(f);
         } else |err| switch (err) {
             error.FileNotFound => {
-                switch (f.lazy_status) {
-                    .eager => {},
-                    .available => if (!job_queue.unlazy_set.contains(expected_hash)) {
-                        f.lazy_status = .unavailable;
-                        return;
-                    },
-                    .unavailable => unreachable,
-                }
+                log.debug("FileNotFound: {f}", .{package_root});
                 if (job_queue.read_only) return f.fail(
                     f.name_tok,
                     try eb.printString("package not found at '{f}'", .{package_root}),
                 );
             },
+            error.Canceled => |e| return e,
             else => |e| {
                 try eb.addRootErrorMessage(.{
                     .msg = try eb.printString("unable to open package cache directory {f}: {t}", .{
@@ -565,6 +562,38 @@ pub fn run(f: *Fetch) RunError!void {
                 return error.FetchFailed;
             },
         }
+
+        // Check global cache before remote fetch.
+        const cached_tarball_sub_path = try std.fmt.allocPrint(arena, "p/{s}.tar.gz", .{expected_hash.toSlice()});
+        const cached_tarball_path: Cache.Path = .{
+            .root_dir = job_queue.global_cache,
+            .sub_path = cached_tarball_sub_path,
+        };
+        if (cached_tarball_path.root_dir.handle.openFile(io, cached_tarball_path.sub_path, .{})) |file| {
+            log.debug("found global cached tarball {f}", .{cached_tarball_path});
+            var resource: Resource = .{ .file = file.reader(io, &resource_buffer) };
+            return f.runResource(cached_tarball_sub_path, &resource, remote.hash, true);
+        } else |err| switch (err) {
+            error.FileNotFound => log.debug("FileNotFound: {f}", .{cached_tarball_path}),
+            error.Canceled => |e| return e,
+            else => |e| {
+                try eb.addRootErrorMessage(.{
+                    .msg = try eb.printString("unable to open globally cached package {f}: {t}", .{
+                        cached_tarball_path, e,
+                    }),
+                });
+                return error.FetchFailed;
+            },
+        }
+
+        switch (f.lazy_status) {
+            .eager => {},
+            .available => if (!job_queue.unlazy_set.contains(expected_hash)) {
+                f.lazy_status = .unavailable;
+                return;
+            },
+            .unavailable => unreachable,
+        }
     } else if (job_queue.read_only) {
         try eb.addRootErrorMessage(.{
             .msg = try eb.addString("dependency is missing hash field"),
@@ -574,15 +603,13 @@ pub fn run(f: *Fetch) RunError!void {
     }
 
     // Fetch and unpack the remote into a temporary directory.
-
     const uri = std.Uri.parse(remote.url) catch |err| return f.fail(
         f.location_tok,
         try eb.printString("invalid URI: {t}", .{err}),
     );
-    var buffer: [init_resource_buffer_size]u8 = undefined;
     var resource: Resource = undefined;
-    try f.initResource(uri, &resource, &buffer);
-    return f.runResource(try uri.path.toRawMaybeAlloc(arena), &resource, remote.hash);
+    try f.initResource(uri, &resource, &resource_buffer);
+    return f.runResource(try uri.path.toRawMaybeAlloc(arena), &resource, remote.hash, false);
 }
 
 pub fn deinit(f: *Fetch) void {
@@ -596,6 +623,7 @@ fn runResource(
     uri_path: []const u8,
     resource: *Resource,
     remote_hash: ?Package.Hash,
+    disable_recompress: bool,
 ) RunError!void {
     const job_queue = f.job_queue;
     assert(!job_queue.read_only);
@@ -681,15 +709,17 @@ fn runResource(
         return error.FetchFailed;
     };
 
-    // Spin off a task to recompress the tarball, with filtered files deleted, into
-    // the global cache.
-    job_queue.group.async(io, JobQueue.recompress, .{ job_queue, computed_package_hash });
+    if (!disable_recompress) {
+        // Spin off a task to recompress the tarball, with filtered files deleted, into
+        // the global cache.
+        job_queue.group.async(io, JobQueue.recompress, .{ job_queue, computed_package_hash });
+    }
 
     // Remove temporary directory root if not already renamed to global cache.
     if (!package_sub_path.eql(tmp_directory_path)) {
         tmp_directory_path.root_dir.handle.deleteDir(io, tmp_directory_path.sub_path) catch |err| switch (err) {
             error.Canceled => |e| return e,
-            else => |e| std.log.warn("failed to delete temporary directory {f}: {t}", .{ tmp_directory_path, e }),
+            else => |e| log.warn("failed to delete temporary directory {f}: {t}", .{ tmp_directory_path, e }),
         };
     }
 
@@ -1588,7 +1618,7 @@ pub fn renameTmpIntoCache(io: Io, tmp_path: Cache.Path, dest_path: Cache.Path) !
                     error.Canceled => |e| return e,
                     // Garbage files leftover in zig-cache/tmp/ is, as they say
                     // on Star Trek, "operating within normal parameters".
-                    else => |e| std.log.warn("failed to delete temporary directory {f}: {t}", .{ tmp_path, e }),
+                    else => |e| log.warn("failed to delete temporary directory {f}: {t}", .{ tmp_path, e }),
                 };
             },
             else => |e| return e,
-- 
2.54.0


From 36b65ab59e5e514ad06a11cde96b87c565d86ac8 Mon Sep 17 00:00:00 2001
From: Mathieu Suen <mathieusuen@yahoo.fr>
Date: Tue, 20 Jan 2026 15:15:57 +0100
Subject: [PATCH 218/499] Air: add "unwrap" functions for loading extra data

---
 src/Air.zig                     | 281 +++++++++++++++++++++++++++++---
 src/Air/Liveness.zig            |  91 +++++------
 src/Air/Liveness/Verify.zig     |  70 +++-----
 src/Air/print.zig               | 138 ++++++----------
 src/Air/types_resolved.zig      |  52 +++---
 src/Sema.zig                    |  12 +-
 src/codegen/aarch64/Select.zig  | 198 ++++++++++------------
 src/codegen/c.zig               | 157 +++++++-----------
 src/codegen/llvm.zig            | 147 +++++++----------
 src/codegen/riscv64/CodeGen.zig | 120 ++++++--------
 src/codegen/sparc64/CodeGen.zig | 102 +++++-------
 src/codegen/spirv/CodeGen.zig   | 126 ++++++--------
 src/codegen/wasm/CodeGen.zig    |  60 +++----
 src/codegen/x86_64/CodeGen.zig  | 203 ++++++++++-------------
 14 files changed, 864 insertions(+), 893 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index b5cb950d493278244cb5cc9e859d6a69c5aaf338..28b7a27ba992f375fffa3a96e7045f5de5952d1e 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -281,16 +281,21 @@ pub const Inst = struct {
         /// also supports enums and pointers.
         /// Uses the `ty_op` field.
         bitcast,
-        /// Uses the `ty_pl` field with payload `Block`.  A block runs its body which always ends
-        /// with a `noreturn` instruction, so the only way to proceed to the code after the `block`
-        /// is to encounter a `br` that targets this `block`.  If the `block` type is `noreturn`,
+        /// A block runs its body which always ends with a `noreturn` instruction,
+        /// so the only way to proceed to the code after the `block` is to encounter a `br`
+        /// that targets this `block`.  If the `block` type is `noreturn`,
         /// then there do not exist any `br` instructions targeting this `block`.
+        /// Uses the `ty_pl` field with payload `Block`.
+        ///
+        /// See `unwrapBlock` for a way to load this tag's data.
         block,
         /// A labeled block of code that loops forever. The body must be `noreturn`: loops
         /// occur through an explicit `repeat` instruction pointing back to this one.
         /// Result type is always `noreturn`; no instructions in a block follow this one.
         /// There is always at least one `repeat` instruction referencing the loop.
         /// Uses the `ty_pl` field. Payload is `Block`.
+        ///
+        /// See `unwrapBlock` for a way to load this tag's data.
         loop,
         /// Sends control flow back to the beginning of a parent `loop` body.
         /// Uses the `repeat` field.
@@ -319,6 +324,8 @@ pub const Inst = struct {
         /// Result type is the return type of the function being called.
         /// Uses the `pl_op` field with the `Call` payload. operand is the callee.
         /// Triggers `resolveTypeLayout` on the return type of the callee.
+        ///
+        /// See `unwrapCall` for a way to load this tag's data.
         call,
         /// Same as `call` except with the `always_tail` attribute.
         call_always_tail,
@@ -436,14 +443,20 @@ pub const Inst = struct {
         /// Conditional branch.
         /// Result type is always noreturn; no instructions in a block follow this one.
         /// Uses the `pl_op` field. Operand is the condition. Payload is `CondBr`.
+        ///
+        /// See `unwrapCondBr` for a way to load this tags's data.
         cond_br,
         /// Switch branch.
         /// Result type is always noreturn; no instructions in a block follow this one.
         /// Uses the `pl_op` field. Operand is the condition. Payload is `SwitchBr`.
+        ///
+        /// See `unwrapSwitch` for a way to load this tags's data.
         switch_br,
         /// Switch branch which can dispatch back to itself with a different operand.
         /// Result type is always noreturn; no instructions in a block follow this one.
         /// Uses the `pl_op` field. Operand is the condition. Payload is `SwitchBr`.
+        ///
+        /// See `unwrapSwitch` for a way to load this tags's data.
         loop_switch_br,
         /// Dispatches back to a branch of a parent `loop_switch_br`.
         /// Result type is always noreturn; no instructions in a block follow this one.
@@ -458,6 +471,8 @@ pub const Inst = struct {
         /// payload value, as if `unwrap_errunion_payload` was executed on the operand.
         /// The error branch is considered to have a branch hint of `.unlikely`.
         /// Uses the `pl_op` field. Payload is `Try`.
+        ///
+        /// See `unwrapTry` for a way to load this tag's data.
         @"try",
         /// Same as `try` except the error branch hint is `.cold`.
         try_cold,
@@ -465,6 +480,8 @@ pub const Inst = struct {
         /// result is a pointer to the payload. Result is as if `unwrap_errunion_payload_ptr`
         /// was executed on the operand.
         /// Uses the `ty_pl` field. Payload is `TryPtr`.
+        ///
+        /// See `unwrapTryPtr` for a way to load this tag's data.
         try_ptr,
         /// Same as `try_ptr` except the error branch hint is `.cold`.
         try_ptr_cold,
@@ -476,6 +493,8 @@ pub const Inst = struct {
         dbg_empty_stmt,
         /// A block that represents an inlined function call.
         /// Uses the `ty_pl` field. Payload is `DbgInlineBlock`.
+        ///
+        /// See `unwrapBlock` for a way to load this tag's data.
         dbg_inline_block,
         /// Marks the beginning of a local variable. The operand is a pointer pointing
         /// to the storage for the variable. The local may be a const or a var.
@@ -715,7 +734,7 @@ pub const Inst = struct {
         /// Uses the `ty_pl` field, where the payload index points to:
         /// 1. mask_elem: ShuffleOneMask  // for each `mask_len`, which comes from `ty_pl.ty`
         /// 2. operand: Ref               // guaranteed not to be an interned value
-        /// See `unwrapShuffleOne`.
+        /// See `unwrapShuffleOne` for a way to load this tag's data.
         shuffle_one,
         /// Constructs a vector by selecting elements from two vectors based on a mask. Each mask
         /// element is either an index into one of the vectors, or "undef".
@@ -723,7 +742,7 @@ pub const Inst = struct {
         /// 1. mask_elem: ShuffleOneMask  // for each `mask_len`, which comes from `ty_pl.ty`
         /// 2. operand_a: Ref             // guaranteed not to be an interned value
         /// 3. operand_b: Ref             // guaranteed not to be an interned value
-        /// See `unwrapShuffleTwo`.
+        /// See `unwrapShuffleTwo` for a way to load this tag's data..
         shuffle_two,
         /// Constructs a vector element-wise from `a` or `b` based on `pred`.
         /// Uses the `pl_op` field with `pred` as operand, and payload `Bin`.
@@ -944,6 +963,8 @@ pub const Inst = struct {
         /// The calling convention is given by `func.@"callconv"(target)`.
         /// The return type (and hence the result type of this instruction) is `func.returnType()`.
         /// The parameter types are the types of the arguments given in `Air.Call`.
+        ///
+        /// See `unwrapCompilerRtCall` for a way to load this tag's data.
         legalize_compiler_rt_call,
 
         pub fn fromCmpOp(op: std.math.CompareOperator, optimized: bool) Tag {
@@ -1445,18 +1466,18 @@ pub const ShuffleTwoMask = enum(u32) {
 /// Trailing:
 /// 0. `Inst.Ref` for every outputs_len
 /// 1. `Inst.Ref` for every inputs_len
-/// 2. for every outputs_len
-///    - constraint: memory at this position is reinterpreted as a null
-///      terminated string.
-///    - name: memory at this position is reinterpreted as a null
-///      terminated string. pad to the next u32 after the null byte.
-/// 3. for every inputs_len
-///    - constraint: memory at this position is reinterpreted as a null
-///      terminated string.
-///    - name: memory at this position is reinterpreted as a null
-///      terminated string. pad to the next u32 after the null byte.
-/// 4. A number of u32 elements follow according to the equation `(source_len + 3) / 4`.
+/// 2. A number of u32 elements follow according to the equation `(source_len + 3) / 4`.
 ///    Memory starting at this position is reinterpreted as the source bytes.
+/// 3. for every outputs_len
+///    - constraint: memory at this position is reinterpreted as a null
+///      terminated string.
+///    - name: memory at this position is reinterpreted as a null
+///      terminated string. pad to the next u32 after the null byte.
+/// 4. for every inputs_len
+///    - constraint: memory at this position is reinterpreted as a null
+///      terminated string.
+///    - name: memory at this position is reinterpreted as a null
+///      terminated string. pad to the next u32 after the null byte.
 pub const Asm = struct {
     /// Length of the assembly source in bytes.
     source_len: u32,
@@ -2157,11 +2178,229 @@ pub fn unwrapSwitch(air: *const Air, switch_inst: Inst.Index) UnwrappedSwitch {
     };
 }
 
-pub fn unwrapShuffleOne(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index) struct {
+pub const UnwrappedDbgInlineBlock = struct {
+    func: InternPool.Index,
+    body: []const Inst.Index,
+    ty: Type,
+};
+
+pub fn unwrapDbgBlock(air: *const Air, inst_index: Inst.Index) UnwrappedDbgInlineBlock {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    assert(tag == .dbg_inline_block);
+    const payload = data.ty_pl.payload;
+    const extra = air.extraData(Air.DbgInlineBlock, payload);
+    return .{
+        .func = extra.data.func,
+        .ty = data.ty_pl.ty.toType(),
+        .body = @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+    };
+}
+
+pub const UnwrappedBlock = struct {
+    body: []const Inst.Index,
+    ty: Type,
+};
+
+pub fn unwrapBlock(air: *const Air, inst_index: Inst.Index) UnwrappedBlock {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    const payload = switch (tag) {
+        .block, .loop => data.ty_pl.payload,
+        else => unreachable,
+    };
+    const extra = air.extraData(Air.Block, payload);
+    return .{
+        .ty = data.ty_pl.ty.toType(),
+        .body = @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+    };
+}
+
+pub const UnwrappedCall = struct {
+    callee: Inst.Ref,
+    args: []const Air.Inst.Ref,
+};
+
+pub fn unwrapCall(air: *const Air, inst_index: Inst.Index) UnwrappedCall {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    const payload = switch (tag) {
+        .call, .call_always_tail, .call_never_tail, .call_never_inline => data.pl_op.payload,
+        else => unreachable,
+    };
+    const extra = air.extraData(Air.Call, payload);
+    return .{
+        .callee = data.pl_op.operand,
+        .args = @ptrCast(air.extra.items[extra.end..][0..extra.data.args_len]),
+    };
+}
+
+pub const UnwrappedCompilerRtCall = struct {
+    func: CompilerRtFunc,
+    args: []const Air.Inst.Ref,
+};
+
+pub fn unwrapCompilerRtCall(air: *const Air, inst_index: Inst.Index) UnwrappedCompilerRtCall {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    assert(tag == .legalize_compiler_rt_call);
+    const payload = data.legalize_compiler_rt_call.payload;
+    const extra = air.extraData(Air.Call, payload);
+    return .{
+        .func = data.legalize_compiler_rt_call.func,
+        .args = @ptrCast(air.extra.items[extra.end..][0..extra.data.args_len]),
+    };
+}
+
+pub const UnwrappedCondBr = struct {
+    condition: Inst.Ref,
+    then_body: []const Inst.Index,
+    else_body: []const Inst.Index,
+    branch_hints: CondBr.BranchHints,
+};
+
+pub fn unwrapCondBr(air: *const Air, inst_index: Inst.Index) UnwrappedCondBr {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    assert(tag == .cond_br);
+    const payload = data.pl_op.payload;
+    const extra = air.extraData(Air.CondBr, payload);
+    return .{
+        .condition = data.pl_op.operand,
+        .then_body = @ptrCast(air.extra.items[extra.end..][0..extra.data.then_body_len]),
+        .else_body = @ptrCast(air.extra.items[extra.end + extra.data.then_body_len ..][0..extra.data.else_body_len]),
+        .branch_hints = extra.data.branch_hints,
+    };
+}
+
+pub const UnwrappedTry = struct {
+    error_union: Inst.Ref,
+    else_body: []const Inst.Index,
+};
+
+pub fn unwrapTry(air: *const Air, inst_index: Inst.Index) UnwrappedTry {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    assert(tag == .@"try" or tag == .try_cold);
+    const payload = data.pl_op.payload;
+    const extra = air.extraData(Air.Try, payload);
+    return .{
+        .error_union = data.pl_op.operand,
+        .else_body = @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+    };
+}
+
+pub const UnwrappedTryPtr = struct {
+    error_union_payload_ptr_ty: Inst.Ref,
+    error_union_ptr: Inst.Ref,
+    else_body: []const Inst.Index,
+};
+
+pub fn unwrapTryPtr(air: *const Air, inst_index: Inst.Index) UnwrappedTryPtr {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    assert(tag == .try_ptr or tag == .try_ptr_cold);
+    const payload = data.ty_pl.payload;
+    const extra = air.extraData(Air.TryPtr, payload);
+    return .{
+        .error_union_ptr = extra.data.ptr,
+        .error_union_payload_ptr_ty = data.ty_pl.ty,
+        .else_body = @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+    };
+}
+
+pub const UnwrappedAsm = struct {
+    outputs: []const Air.Inst.Ref,
+    inputs: []const Air.Inst.Ref,
+    source: [:0]u8,
+    input_constraint_names: []const u32,
+    output_constraint_names: []const u32,
+    clobbers: InternPool.Index,
+    is_volatile: bool,
+
+    const AsmIterator = struct {
+        current: u32,
+        operands: []const Air.Inst.Ref,
+        constraint_names: []const u32,
+
+        pub fn next(self: *AsmIterator) ?struct { constraint: []const u8, operand: Inst.Ref, name: []const u8, index: u32 } {
+            if (self.current >= self.operands.len) {
+                return null;
+            }
+            defer {
+                self.current += 1;
+            }
+
+            const constraint_name = std.mem.sliceAsBytes(self.constraint_names);
+            const constraint = std.mem.sliceTo(constraint_name, 0);
+            const name = std.mem.sliceTo(constraint_name[constraint.len + 1 ..], 0);
+            // This equation accounts for the fact that even if we have exactly 4 bytes
+            // for the string, we still use the next u32 for the null terminator.
+            const next_offset = std.math.divCeil(usize, constraint.len + 1 + name.len + 1, @sizeOf(u32)) catch unreachable;
+            self.constraint_names = self.constraint_names[next_offset..];
+
+            return .{
+                .constraint = constraint,
+                .operand = self.operands[self.current],
+                .name = name,
+                .index = self.current,
+            };
+        }
+    };
+
+    pub fn iterateInputs(self: *const UnwrappedAsm) AsmIterator {
+        return .{
+            .current = 0,
+            .operands = self.inputs,
+            .constraint_names = self.input_constraint_names,
+        };
+    }
+
+    pub fn iterateOutputs(self: *const UnwrappedAsm) AsmIterator {
+        return .{
+            .current = 0,
+            .operands = self.outputs,
+            .constraint_names = self.output_constraint_names,
+        };
+    }
+};
+
+pub fn unwrapAsm(air: *const Air, inst_index: Inst.Index) UnwrappedAsm {
+    const data = air.instructions.items(.data)[@intFromEnum(inst_index)];
+    const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)];
+    assert(tag == .assembly);
+    const payload = data.ty_pl.payload;
+    const extra = air.extraData(Air.Asm, payload);
+    const source_start = extra.end + extra.data.flags.outputs_len + extra.data.inputs_len;
+    const output_constraint_name_start = source_start + (extra.data.source_len / 4) + 1;
+    const output_constraint_name = air.extra.items[output_constraint_name_start..];
+    const outputs: []Inst.Ref = @ptrCast(air.extra.items[extra.end..][0..extra.data.flags.outputs_len]);
+    // Get the input names and constraints offset place after the output.
+    var it = UnwrappedAsm.AsmIterator{
+        .current = 0,
+        .constraint_names = output_constraint_name,
+        .operands = outputs,
+    };
+    while (it.next()) |_| {}
+
+    return .{
+        .clobbers = extra.data.clobbers,
+        .is_volatile = extra.data.flags.is_volatile,
+        .inputs = @ptrCast(air.extra.items[extra.end + extra.data.flags.outputs_len ..][0..extra.data.inputs_len]),
+        .outputs = outputs,
+        .source = std.mem.sliceAsBytes(air.extra.items[source_start..])[0..extra.data.source_len :0],
+        .output_constraint_names = output_constraint_name,
+        .input_constraint_names = it.constraint_names,
+    };
+}
+
+pub const UnwrappedShuffleOne = struct {
     result_ty: Type,
     operand: Inst.Ref,
     mask: []const ShuffleOneMask,
-} {
+};
+
+pub fn unwrapShuffleOne(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index) UnwrappedShuffleOne {
     const inst = air.instructions.get(@intFromEnum(inst_index));
     switch (inst.tag) {
         .shuffle_one => {},
@@ -2177,12 +2416,14 @@ pub fn unwrapShuffleOne(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index
     };
 }
 
-pub fn unwrapShuffleTwo(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index) struct {
+pub const UnwrappedShuffleTwo = struct {
     result_ty: Type,
     operand_a: Inst.Ref,
     operand_b: Inst.Ref,
     mask: []const ShuffleTwoMask,
-} {
+};
+
+pub fn unwrapShuffleTwo(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index) UnwrappedShuffleTwo {
     const inst = air.instructions.get(@intFromEnum(inst_index));
     switch (inst.tag) {
         .shuffle_two => {},
diff --git a/src/Air/Liveness.zig b/src/Air/Liveness.zig
index 9b722973a66672d5b4f3d071f6dda99ee76ab084..a85944c4678455126d04403e1c48486db9d6e860 100644
--- a/src/Air/Liveness.zig
+++ b/src/Air/Liveness.zig
@@ -17,6 +17,7 @@ const trace = @import("../tracy.zig").trace;
 const Air = @import("../Air.zig");
 const InternPool = @import("../InternPool.zig");
 const Zcu = @import("../Zcu.zig");
+const Type = @import("../Type.zig");
 
 pub const Verify = @import("Liveness/Verify.zig");
 
@@ -609,13 +610,11 @@ fn analyzeInst(
         },
 
         .call, .call_always_tail, .call_never_tail, .call_never_inline => {
-            const inst_data = inst_datas[@intFromEnum(inst)].pl_op;
-            const callee = inst_data.operand;
-            const extra = a.air.extraData(Air.Call, inst_data.payload);
-            const args = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra.items[extra.end..][0..extra.data.args_len]));
+            const call = a.air.unwrapCall(inst);
+            const args = call.args;
             if (args.len + 1 <= bpi - 1) {
                 var buf = [1]Air.Inst.Ref{.none} ** (bpi - 1);
-                buf[0] = callee;
+                buf[0] = call.callee;
                 @memcpy(buf[1..][0..args.len], args);
                 return analyzeOperands(a, pass, data, inst, buf);
             }
@@ -627,7 +626,7 @@ fn analyzeInst(
                 i -= 1;
                 try big.feed(args[i]);
             }
-            try big.feed(callee);
+            try big.feed(call.callee);
             return big.finish();
         },
         .select => {
@@ -708,18 +707,15 @@ fn analyzeInst(
         .switch_dispatch => return analyzeInstSwitchDispatch(a, pass, data, inst),
 
         .assembly => {
-            const extra = a.air.extraData(Air.Asm, inst_datas[@intFromEnum(inst)].ty_pl.payload);
-            const outputs_len = extra.data.flags.outputs_len;
-            var extra_i: usize = extra.end;
-            const outputs = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra.items[extra_i..][0..outputs_len]));
-            extra_i += outputs.len;
-            const inputs = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra.items[extra_i..][0..extra.data.inputs_len]));
-            extra_i += inputs.len;
+            const unwrapped_asm = a.air.unwrapAsm(inst);
+
+            const outputs = unwrapped_asm.outputs;
+            const inputs = unwrapped_asm.inputs;
 
             const num_operands = simple: {
                 var buf = [1]Air.Inst.Ref{.none} ** (bpi - 1);
                 var buf_index: usize = 0;
-                for (outputs) |output| {
+                for (unwrapped_asm.outputs) |output| {
                     if (output != .none) {
                         if (buf_index < buf.len) buf[buf_index] = output;
                         buf_index += 1;
@@ -748,15 +744,13 @@ fn analyzeInst(
             }
             return big.finish();
         },
-
-        inline .block, .dbg_inline_block => |comptime_tag| {
-            const ty_pl = inst_datas[@intFromEnum(inst)].ty_pl;
-            const extra = a.air.extraData(switch (comptime_tag) {
-                .block => Air.Block,
-                .dbg_inline_block => Air.DbgInlineBlock,
-                else => unreachable,
-            }, ty_pl.payload);
-            return analyzeInstBlock(a, pass, data, inst, ty_pl.ty, @ptrCast(a.air.extra.items[extra.end..][0..extra.data.body_len]));
+        .dbg_inline_block => {
+            const block = a.air.unwrapDbgBlock(inst);
+            return analyzeInstBlock(a, pass, data, inst, block.ty, block.body);
+        },
+        .block => {
+            const block = a.air.unwrapBlock(inst);
+            return analyzeInstBlock(a, pass, data, inst, block.ty, block.body);
         },
         .loop => return analyzeInstLoop(a, pass, data, inst),
 
@@ -778,8 +772,8 @@ fn analyzeInst(
         },
 
         .legalize_compiler_rt_call => {
-            const extra = a.air.extraData(Air.Call, inst_datas[@intFromEnum(inst)].legalize_compiler_rt_call.payload);
-            const args: []const Air.Inst.Ref = @ptrCast(a.air.extra.items[extra.end..][0..extra.data.args_len]);
+            const rt_call = a.air.unwrapCompilerRtCall(inst);
+            const args = rt_call.args;
             if (args.len <= bpi - 1) {
                 var buf: [bpi - 1]Air.Inst.Ref = @splat(.none);
                 @memcpy(buf[0..args.len], args);
@@ -972,7 +966,7 @@ fn analyzeInstBlock(
     comptime pass: LivenessPass,
     data: *LivenessPassData(pass),
     inst: Air.Inst.Index,
-    ty: Air.Inst.Ref,
+    ty: Type,
     body: []const Air.Inst.Index,
 ) !void {
     const gpa = a.gpa;
@@ -1005,7 +999,7 @@ fn analyzeInstBlock(
 
             // If the block is noreturn, block deaths not only aren't useful, they're impossible to
             // find: there could be more stuff alive after the block than before it!
-            if (!a.intern_pool.isNoReturn(ty.toType().toIntern())) {
+            if (!a.intern_pool.isNoReturn(ty.toIntern())) {
                 // The block kills the difference in the live sets
                 const block_scope = data.block_scopes.get(inst).?;
                 const num_deaths = data.live_set.count() - block_scope.live_set.count();
@@ -1139,9 +1133,8 @@ fn analyzeInstLoop(
     data: *LivenessPassData(pass),
     inst: Air.Inst.Index,
 ) !void {
-    const inst_datas = a.air.instructions.items(.data);
-    const extra = a.air.extraData(Air.Block, inst_datas[@intFromEnum(inst)].ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(a.air.extra.items[extra.end..][0..extra.data.body_len]);
+    const block = a.air.unwrapBlock(inst);
+    const body = block.body;
     const gpa = a.gpa;
 
     try analyzeOperands(a, pass, data, inst, .{ .none, .none, .none });
@@ -1187,44 +1180,38 @@ fn analyzeInstCondBr(
     inst: Air.Inst.Index,
     comptime inst_type: enum { cond_br, @"try", try_ptr },
 ) !void {
-    const inst_datas = a.air.instructions.items(.data);
     const gpa = a.gpa;
 
-    const extra = switch (inst_type) {
-        .cond_br => a.air.extraData(Air.CondBr, inst_datas[@intFromEnum(inst)].pl_op.payload),
-        .@"try" => a.air.extraData(Air.Try, inst_datas[@intFromEnum(inst)].pl_op.payload),
-        .try_ptr => a.air.extraData(Air.TryPtr, inst_datas[@intFromEnum(inst)].ty_pl.payload),
+    const unwrapped_cond = switch (inst_type) {
+        .cond_br => a.air.unwrapCondBr(inst),
+        .@"try" => a.air.unwrapTry(inst),
+        .try_ptr => a.air.unwrapTryPtr(inst),
     };
 
     const condition = switch (inst_type) {
-        .cond_br, .@"try" => inst_datas[@intFromEnum(inst)].pl_op.operand,
-        .try_ptr => extra.data.ptr,
+        .cond_br => unwrapped_cond.condition,
+        .@"try" => unwrapped_cond.error_union,
+        .try_ptr => unwrapped_cond.error_union_ptr,
     };
 
-    const then_body: []const Air.Inst.Index = switch (inst_type) {
-        .cond_br => @ptrCast(a.air.extra.items[extra.end..][0..extra.data.then_body_len]),
-        else => &.{}, // we won't use this
+    const then_body = switch (inst_type) {
+        .cond_br => unwrapped_cond.then_body,
+        // The "then body" is just the remainder of this block
+        else => &.{},
     };
 
-    const else_body: []const Air.Inst.Index = @ptrCast(switch (inst_type) {
-        .cond_br => a.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len],
-        .@"try", .try_ptr => a.air.extra.items[extra.end..][0..extra.data.body_len],
-    });
+    const else_body = switch (inst_type) {
+        .cond_br, .@"try", .try_ptr => unwrapped_cond.else_body,
+    };
 
     switch (pass) {
         .loop_analysis => {
-            switch (inst_type) {
-                .cond_br => try analyzeBody(a, pass, data, then_body),
-                .@"try", .try_ptr => {},
-            }
+            try analyzeBody(a, pass, data, then_body);
             try analyzeBody(a, pass, data, else_body);
         },
 
         .main_analysis => {
-            switch (inst_type) {
-                .cond_br => try analyzeBody(a, pass, data, then_body),
-                .@"try", .try_ptr => {}, // The "then body" is just the remainder of this block
-            }
+            try analyzeBody(a, pass, data, then_body);
             var then_live = data.live_set.move();
             defer then_live.deinit(gpa);
 
diff --git a/src/Air/Liveness/Verify.zig b/src/Air/Liveness/Verify.zig
index cdb5786921bb9fe005daa93479db0f9f2ce2c152..fc83574d070c018fc54ed095d4c67f0bf7698fb2 100644
--- a/src/Air/Liveness/Verify.zig
+++ b/src/Air/Liveness/Verify.zig
@@ -345,37 +345,26 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
                 try self.verifyInst(inst);
             },
             .call, .call_always_tail, .call_never_tail, .call_never_inline => {
-                const pl_op = data[@intFromEnum(inst)].pl_op;
-                const extra = self.air.extraData(Air.Call, pl_op.payload);
-                const args = @as(
-                    []const Air.Inst.Ref,
-                    @ptrCast(self.air.extra.items[extra.end..][0..extra.data.args_len]),
-                );
+                const call = self.air.unwrapCall(inst);
+                const args = call.args;
 
                 var bt = self.liveness.iterateBigTomb(inst);
-                try self.verifyOperand(inst, pl_op.operand, bt.feed());
+                try self.verifyOperand(inst, call.callee, bt.feed());
                 for (args) |arg| {
                     try self.verifyOperand(inst, arg, bt.feed());
                 }
                 try self.verifyInst(inst);
             },
             .assembly => {
-                const ty_pl = data[@intFromEnum(inst)].ty_pl;
-                const extra = self.air.extraData(Air.Asm, ty_pl.payload);
-                const outputs_len = extra.data.flags.outputs_len;
-                var extra_i = extra.end;
-                const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..outputs_len]);
-                extra_i += outputs.len;
-                const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..extra.data.inputs_len]);
-                extra_i += inputs.len;
+                const unwrapped_asm = self.air.unwrapAsm(inst);
 
                 var bt = self.liveness.iterateBigTomb(inst);
-                for (outputs) |output| {
+                for (unwrapped_asm.outputs) |output| {
                     if (output != .none) {
                         try self.verifyOperand(inst, output, bt.feed());
                     }
                 }
-                for (inputs) |input| {
+                for (unwrapped_asm.inputs) |input| {
                     try self.verifyOperand(inst, input, bt.feed());
                 }
                 try self.verifyInst(inst);
@@ -383,13 +372,12 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
 
             // control flow
             .@"try", .try_cold => {
-                const pl_op = data[@intFromEnum(inst)].pl_op;
-                const extra = self.air.extraData(Air.Try, pl_op.payload);
-                const try_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
+                const unwrapped_try = self.air.unwrapTry(inst);
+                const try_body = unwrapped_try.else_body;
 
                 const cond_br_liveness = self.liveness.getCondBr(inst);
 
-                try self.verifyOperand(inst, pl_op.operand, self.liveness.operandDies(inst, 0));
+                try self.verifyOperand(inst, unwrapped_try.error_union, self.liveness.operandDies(inst, 0));
 
                 var live = try self.live.clone(self.gpa);
                 defer live.deinit(self.gpa);
@@ -405,13 +393,12 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
                 try self.verifyInst(inst);
             },
             .try_ptr, .try_ptr_cold => {
-                const ty_pl = data[@intFromEnum(inst)].ty_pl;
-                const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
-                const try_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
+                const unwrapped_try = self.air.unwrapTryPtr(inst);
+                const try_body = unwrapped_try.else_body;
 
                 const cond_br_liveness = self.liveness.getCondBr(inst);
 
-                try self.verifyOperand(inst, extra.data.ptr, self.liveness.operandDies(inst, 0));
+                try self.verifyOperand(inst, unwrapped_try.error_union_ptr, self.liveness.operandDies(inst, 0));
 
                 var live = try self.live.clone(self.gpa);
                 defer live.deinit(self.gpa);
@@ -458,17 +445,11 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
             .block, .dbg_inline_block => |tag| {
                 const ty_pl = data[@intFromEnum(inst)].ty_pl;
                 const block_ty = ty_pl.ty.toType();
-                const block_body: []const Air.Inst.Index = @ptrCast(switch (tag) {
-                    inline .block, .dbg_inline_block => |comptime_tag| body: {
-                        const extra = self.air.extraData(switch (comptime_tag) {
-                            .block => Air.Block,
-                            .dbg_inline_block => Air.DbgInlineBlock,
-                            else => unreachable,
-                        }, ty_pl.payload);
-                        break :body self.air.extra.items[extra.end..][0..extra.data.body_len];
-                    },
+                const block_body = switch (tag) {
+                    .block => self.air.unwrapBlock(inst).body,
+                    .dbg_inline_block => self.air.unwrapDbgBlock(inst).body,
                     else => unreachable,
-                });
+                };
                 const block_liveness = self.liveness.getBlock(inst);
 
                 var orig_live = try self.live.clone(self.gpa);
@@ -501,9 +482,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
                 try self.verifyInstOperands(inst, .{ .none, .none, .none });
             },
             .loop => {
-                const ty_pl = data[@intFromEnum(inst)].ty_pl;
-                const extra = self.air.extraData(Air.Block, ty_pl.payload);
-                const loop_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
+                const block = self.air.unwrapBlock(inst);
 
                 // The same stuff should be alive after the loop as before it.
                 const gop = try self.loops.getOrPut(self.gpa, inst);
@@ -514,18 +493,17 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
                 }
                 gop.value_ptr.* = try self.live.clone(self.gpa);
 
-                try self.verifyBody(loop_body);
+                try self.verifyBody(block.body);
 
                 try self.verifyInstOperands(inst, .{ .none, .none, .none });
             },
             .cond_br => {
-                const pl_op = data[@intFromEnum(inst)].pl_op;
-                const extra = self.air.extraData(Air.CondBr, pl_op.payload);
-                const then_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-                const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+                const cond_br = self.air.unwrapCondBr(inst);
+                const then_body = cond_br.then_body;
+                const else_body = cond_br.else_body;
                 const cond_br_liveness = self.liveness.getCondBr(inst);
 
-                try self.verifyOperand(inst, pl_op.operand, self.liveness.operandDies(inst, 0));
+                try self.verifyOperand(inst, cond_br.condition, self.liveness.operandDies(inst, 0));
 
                 var live = try self.live.clone(self.gpa);
                 defer live.deinit(self.gpa);
@@ -589,8 +567,8 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
                 try self.verifyInstOperands(inst, .{ pl_op.operand, bin.lhs, bin.rhs });
             },
             .legalize_compiler_rt_call => {
-                const extra = self.air.extraData(Air.Call, data[@intFromEnum(inst)].legalize_compiler_rt_call.payload);
-                const args: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.args_len]);
+                const rt_call = self.air.unwrapCompilerRtCall(inst);
+                const args = rt_call.args;
                 var bt = self.liveness.iterateBigTomb(inst);
                 for (args) |arg| {
                     try self.verifyOperand(inst, arg, bt.feed());
diff --git a/src/Air/print.zig b/src/Air/print.zig
index 98b0a0b242ab7b7c41976c35f76756a5efbd7dec..0c126fab22d364b97c49ed6d896801fe4c66451e 100644
--- a/src/Air/print.zig
+++ b/src/Air/print.zig
@@ -395,25 +395,17 @@ const Writer = struct {
     fn writeBlock(w: *Writer, s: *std.Io.Writer, tag: Air.Inst.Tag, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         try w.writeType(s, ty_pl.ty.toType());
-        const body: []const Air.Inst.Index = @ptrCast(switch (tag) {
-            inline .block, .dbg_inline_block => |comptime_tag| body: {
-                const extra = w.air.extraData(switch (comptime_tag) {
-                    .block => Air.Block,
-                    .dbg_inline_block => Air.DbgInlineBlock,
-                    else => unreachable,
-                }, ty_pl.payload);
-                switch (comptime_tag) {
-                    .block => {},
-                    .dbg_inline_block => {
-                        try s.writeAll(", ");
-                        try w.writeInstRef(s, Air.internedToRef(extra.data.func), false);
-                    },
-                    else => unreachable,
-                }
-                break :body w.air.extra.items[extra.end..][0..extra.data.body_len];
+
+        const body = switch (tag) {
+            .block => w.air.unwrapBlock(inst).body,
+            .dbg_inline_block => body: {
+                const dbg_block = w.air.unwrapDbgBlock(inst);
+                try s.writeAll(", ");
+                try w.writeInstRef(s, Air.internedToRef(dbg_block.func), false);
+                break :body dbg_block.body;
             },
             else => unreachable,
-        });
+        };
         if (w.skip_body) return s.writeAll(", ...");
         const liveness_block: Air.Liveness.BlockSlices = if (w.liveness) |liveness|
             liveness.getBlock(inst)
@@ -434,16 +426,14 @@ const Writer = struct {
     }
 
     fn writeLoop(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = w.air.extraData(Air.Block, ty_pl.payload);
-        const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
+        const block = w.air.unwrapBlock(inst);
 
-        try w.writeType(s, ty_pl.ty.toType());
+        try w.writeType(s, block.ty);
         if (w.skip_body) return s.writeAll(", ...");
         try s.writeAll(", {\n");
         const old_indent = w.indent;
         w.indent += 2;
-        try w.writeBody(s, body);
+        try w.writeBody(s, block.body);
         w.indent = old_indent;
         try s.splatByteAll(' ', w.indent);
         try s.writeAll("}");
@@ -532,11 +522,10 @@ const Writer = struct {
     }
 
     fn writeLegalizeCompilerRtCall(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const inst_data = w.air.instructions.items(.data)[@intFromEnum(inst)].legalize_compiler_rt_call;
-        const extra = w.air.extraData(Air.Call, inst_data.payload);
-        const args: []const Air.Inst.Ref = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.args_len]);
+        const rt_call = w.air.unwrapCompilerRtCall(inst);
+        const args = rt_call.args;
 
-        try s.print("{t}, [", .{inst_data.func});
+        try s.print("{t}, [", .{rt_call.func});
         for (args, 0..) |arg, i| {
             if (i != 0) try s.writeAll(", ");
             try w.writeOperand(s, inst, i, arg);
@@ -666,11 +655,8 @@ const Writer = struct {
     }
 
     fn writeAssembly(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = w.air.extraData(Air.Asm, ty_pl.payload);
-        const is_volatile = extra.data.flags.is_volatile;
-        const outputs_len = extra.data.flags.outputs_len;
-        var extra_i: usize = extra.end;
+        const unwrapped_asm = w.air.unwrapAsm(inst);
+        const is_volatile = unwrapped_asm.is_volatile;
         var op_index: usize = 0;
 
         const ret_ty = w.typeOfIndex(inst);
@@ -680,49 +666,33 @@ const Writer = struct {
             try s.writeAll(", volatile");
         }
 
-        const outputs = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra_i..][0..outputs_len]));
-        extra_i += outputs.len;
-        const inputs = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra_i..][0..extra.data.inputs_len]));
-        extra_i += inputs.len;
-
-        for (outputs) |output| {
-            const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
-            const constraint = std.mem.sliceTo(extra_bytes, 0);
-            const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the strings and their null terminators, we still use the next u32
-            // for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-
-            if (output == .none) {
+        var it = unwrapped_asm.iterateOutputs();
+        while (it.next()) |out| {
+            const name = out.name;
+            const constraint = out.constraint;
+            if (out.operand == .none) {
                 try s.print(", [{s}] -> {s}", .{ name, constraint });
             } else {
                 try s.print(", [{s}] out {s} = (", .{ name, constraint });
-                try w.writeOperand(s, inst, op_index, output);
+                try w.writeOperand(s, inst, op_index, out.operand);
                 op_index += 1;
                 try s.writeByte(')');
             }
         }
 
-        for (inputs) |input| {
-            const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
-            const constraint = std.mem.sliceTo(extra_bytes, 0);
-            const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the strings and their null terminators, we still use the next u32
-            // for the null terminator.
-            extra_i += (constraint.len + name.len + 1) / 4 + 1;
-
+        it = unwrapped_asm.iterateInputs();
+        while (it.next()) |in| {
+            const name = in.name;
+            const constraint = in.constraint;
             try s.print(", [{s}] in {s} = (", .{ name, constraint });
-            try w.writeOperand(s, inst, op_index, input);
+            try w.writeOperand(s, inst, op_index, in.operand);
             op_index += 1;
             try s.writeByte(')');
         }
 
         const zcu = w.pt.zcu;
         const ip = &zcu.intern_pool;
-        const aggregate = ip.indexToKey(extra.data.clobbers).aggregate;
+        const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
         const struct_type: Type = .fromInterned(aggregate.ty);
         switch (aggregate.storage) {
             .elems => |elems| for (elems, 0..) |elem, i| {
@@ -750,7 +720,7 @@ const Writer = struct {
                 try s.print(", {x}", .{bytes});
             },
         }
-        const asm_source = std.mem.sliceAsBytes(w.air.extra.items[extra_i..])[0..extra.data.source_len];
+        const asm_source = unwrapped_asm.source;
         try s.print(", \"{f}\"", .{std.zig.fmtString(asm_source)});
     }
 
@@ -767,10 +737,9 @@ const Writer = struct {
     }
 
     fn writeCall(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-        const extra = w.air.extraData(Air.Call, pl_op.payload);
-        const args = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra.end..][0..extra.data.args_len]));
-        try w.writeOperand(s, inst, 0, pl_op.operand);
+        const call = w.air.unwrapCall(inst);
+        const args = call.args;
+        try w.writeOperand(s, inst, 0, call.callee);
         try s.writeAll(", [");
         for (args, 0..) |arg, i| {
             if (i != 0) try s.writeAll(", ");
@@ -792,15 +761,14 @@ const Writer = struct {
     }
 
     fn writeTry(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-        const extra = w.air.extraData(Air.Try, pl_op.payload);
-        const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
+        const unwrapped_try = w.air.unwrapTry(inst);
+        const body = unwrapped_try.else_body;
         const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) |liveness|
             liveness.getCondBr(inst)
         else
             .{ .then_deaths = &.{}, .else_deaths = &.{} };
 
-        try w.writeOperand(s, inst, 0, pl_op.operand);
+        try w.writeOperand(s, inst, 0, unwrapped_try.error_union);
         if (w.skip_body) return s.writeAll(", ...");
         try s.writeAll(", {\n");
         const old_indent = w.indent;
@@ -826,18 +794,17 @@ const Writer = struct {
     }
 
     fn writeTryPtr(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = w.air.extraData(Air.TryPtr, ty_pl.payload);
-        const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
+        const unwrapped_try = w.air.unwrapTryPtr(inst);
+        const body = unwrapped_try.else_body;
         const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) |liveness|
             liveness.getCondBr(inst)
         else
             .{ .then_deaths = &.{}, .else_deaths = &.{} };
 
-        try w.writeOperand(s, inst, 0, extra.data.ptr);
+        try w.writeOperand(s, inst, 0, unwrapped_try.error_union_ptr);
 
         try s.writeAll(", ");
-        try w.writeType(s, ty_pl.ty.toType());
+        try w.writeType(s, unwrapped_try.error_union_payload_ptr_ty.toType());
         if (w.skip_body) return s.writeAll(", ...");
         try s.writeAll(", {\n");
         const old_indent = w.indent;
@@ -863,23 +830,22 @@ const Writer = struct {
     }
 
     fn writeCondBr(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void {
-        const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-        const extra = w.air.extraData(Air.CondBr, pl_op.payload);
-        const then_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-        const else_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+        const cond_br = w.air.unwrapCondBr(inst);
+        const then_body = cond_br.then_body;
+        const else_body = cond_br.else_body;
         const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) |liveness|
             liveness.getCondBr(inst)
         else
             .{ .then_deaths = &.{}, .else_deaths = &.{} };
 
-        try w.writeOperand(s, inst, 0, pl_op.operand);
+        try w.writeOperand(s, inst, 0, cond_br.condition);
         if (w.skip_body) return s.writeAll(", ...");
         try s.writeAll(",");
-        if (extra.data.branch_hints.true != .none) {
-            try s.print(" {s}", .{@tagName(extra.data.branch_hints.true)});
+        if (cond_br.branch_hints.true != .none) {
+            try s.print(" {s}", .{@tagName(cond_br.branch_hints.true)});
         }
-        if (extra.data.branch_hints.then_cov != .none) {
-            try s.print(" {s}", .{@tagName(extra.data.branch_hints.then_cov)});
+        if (cond_br.branch_hints.then_cov != .none) {
+            try s.print(" {s}", .{@tagName(cond_br.branch_hints.then_cov)});
         }
         try s.writeAll(" {\n");
         const old_indent = w.indent;
@@ -897,11 +863,11 @@ const Writer = struct {
         try w.writeBody(s, then_body);
         try s.splatByteAll(' ', old_indent);
         try s.writeAll("},");
-        if (extra.data.branch_hints.false != .none) {
-            try s.print(" {s}", .{@tagName(extra.data.branch_hints.false)});
+        if (cond_br.branch_hints.false != .none) {
+            try s.print(" {s}", .{@tagName(cond_br.branch_hints.false)});
         }
-        if (extra.data.branch_hints.else_cov != .none) {
-            try s.print(" {s}", .{@tagName(extra.data.branch_hints.else_cov)});
+        if (cond_br.branch_hints.else_cov != .none) {
+            try s.print(" {s}", .{@tagName(cond_br.branch_hints.else_cov)});
         }
         try s.writeAll(" {\n");
 
diff --git a/src/Air/types_resolved.zig b/src/Air/types_resolved.zig
index 752b4eccc325fd4123d088da8a3e3ec7cf24be6e..216f690414abdf2daea6993536b303812a05866e 100644
--- a/src/Air/types_resolved.zig
+++ b/src/Air/types_resolved.zig
@@ -170,21 +170,21 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
             .block,
             .loop,
             => {
-                const extra = air.extraData(Air.Block, data.ty_pl.payload);
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
+                const block = air.unwrapBlock(inst);
+                if (!checkType(block.ty, zcu)) return false;
                 if (!checkBody(
                     air,
-                    @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+                    block.body,
                     zcu,
                 )) return false;
             },
 
             .dbg_inline_block => {
-                const extra = air.extraData(Air.DbgInlineBlock, data.ty_pl.payload);
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
+                const block = air.unwrapDbgBlock(inst);
+                if (!checkType(block.ty, zcu)) return false;
                 if (!checkBody(
                     air,
-                    @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+                    block.body,
                     zcu,
                 )) return false;
             },
@@ -342,9 +342,9 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
             .call_never_tail,
             .call_never_inline,
             => {
-                const extra = air.extraData(Air.Call, data.pl_op.payload);
-                const args: []const Air.Inst.Ref = @ptrCast(air.extra.items[extra.end..][0..extra.data.args_len]);
-                if (!checkRef(data.pl_op.operand, zcu)) return false;
+                const call = air.unwrapCall(inst);
+                const args = call.args;
+                if (!checkRef(call.callee, zcu)) return false;
                 for (args) |arg| if (!checkRef(arg, zcu)) return false;
             },
 
@@ -356,37 +356,37 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
             },
 
             .@"try", .try_cold => {
-                const extra = air.extraData(Air.Try, data.pl_op.payload);
-                if (!checkRef(data.pl_op.operand, zcu)) return false;
+                const unwrapped_try = air.unwrapTry(inst);
+                if (!checkRef(unwrapped_try.error_union, zcu)) return false;
                 if (!checkBody(
                     air,
-                    @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+                    unwrapped_try.else_body,
                     zcu,
                 )) return false;
             },
 
             .try_ptr, .try_ptr_cold => {
-                const extra = air.extraData(Air.TryPtr, data.ty_pl.payload);
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(extra.data.ptr, zcu)) return false;
+                const unwrapped_try = air.unwrapTryPtr(inst);
+                if (!checkType(unwrapped_try.error_union_payload_ptr_ty.toType(), zcu)) return false;
+                if (!checkRef(unwrapped_try.error_union_ptr, zcu)) return false;
                 if (!checkBody(
                     air,
-                    @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]),
+                    unwrapped_try.else_body,
                     zcu,
                 )) return false;
             },
 
             .cond_br => {
-                const extra = air.extraData(Air.CondBr, data.pl_op.payload);
-                if (!checkRef(data.pl_op.operand, zcu)) return false;
+                const cond_br = air.unwrapCondBr(inst);
+                if (!checkRef(cond_br.condition, zcu)) return false;
                 if (!checkBody(
                     air,
-                    @ptrCast(air.extra.items[extra.end..][0..extra.data.then_body_len]),
+                    cond_br.then_body,
                     zcu,
                 )) return false;
                 if (!checkBody(
                     air,
-                    @ptrCast(air.extra.items[extra.end + extra.data.then_body_len ..][0..extra.data.else_body_len]),
+                    cond_br.else_body,
                     zcu,
                 )) return false;
             },
@@ -407,20 +407,20 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
             },
 
             .assembly => {
-                const extra = air.extraData(Air.Asm, data.ty_pl.payload);
+                const unwrapped_asm = air.unwrapAsm(inst);
                 if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
                 // Luckily, we only care about the inputs and outputs, so we don't have to do
                 // the whole null-terminated string dance.
-                const outputs_len = extra.data.flags.outputs_len;
-                const outputs: []const Air.Inst.Ref = @ptrCast(air.extra.items[extra.end..][0..outputs_len]);
-                const inputs: []const Air.Inst.Ref = @ptrCast(air.extra.items[extra.end + outputs_len ..][0..extra.data.inputs_len]);
+                const outputs = unwrapped_asm.outputs;
+                const inputs = unwrapped_asm.inputs;
+
                 for (outputs) |output| if (output != .none and !checkRef(output, zcu)) return false;
                 for (inputs) |input| if (input != .none and !checkRef(input, zcu)) return false;
             },
 
             .legalize_compiler_rt_call => {
-                const extra = air.extraData(Air.Call, data.legalize_compiler_rt_call.payload);
-                const args: []const Air.Inst.Ref = @ptrCast(air.extra.items[extra.end..][0..extra.data.args_len]);
+                const rt_call = air.unwrapCompilerRtCall(inst);
+                const args = rt_call.args;
                 for (args) |arg| if (!checkRef(arg, zcu)) return false;
             },
 
diff --git a/src/Sema.zig b/src/Sema.zig
index fc71a58f776518edf6d0dd745469bb1c1f77e1ef..87dd6a83bbc9fed4e1533a20499793f10024cdcf 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -16226,6 +16226,12 @@ fn zirAsm(
     });
     sema.appendRefsAssumeCapacity(out_args);
     sema.appendRefsAssumeCapacity(args);
+    {
+        const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
+        @memcpy(buffer[0..asm_source.len], asm_source);
+        buffer[asm_source.len] = 0;
+        sema.air_extra.items.len += asm_source.len / 4 + 1;
+    }
     for (outputs) |o| {
         const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
         @memcpy(buffer[0..o.c.len], o.c);
@@ -16242,12 +16248,6 @@ fn zirAsm(
         buffer[input.c.len + 1 + input.n.len] = 0;
         sema.air_extra.items.len += (input.c.len + input.n.len + (2 + 3)) / 4;
     }
-    {
-        const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-        @memcpy(buffer[0..asm_source.len], asm_source);
-        buffer[asm_source.len] = 0;
-        sema.air_extra.items.len += asm_source.len / 4 + 1;
-    }
     return asm_air;
 }
 
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index 49de055b47b6b55a3119ce52065888af61d8b0f8..55f0d7fcc0e37b35198f01c2ff88c96cfd72aca4 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -274,10 +274,9 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
         },
         .assembly => {
             const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl;
-            const extra = isel.air.extraData(Air.Asm, ty_pl.payload);
-            const operands: []const Air.Inst.Ref = @ptrCast(isel.air.extra.items[extra.end..][0 .. extra.data.flags.outputs_len + extra.data.inputs_len]);
+            const unwrapped_asm = isel.air.unwrapAsm(air_inst_index);
 
-            for (operands) |operand| if (operand != .none) try isel.analyzeUse(operand);
+            for (unwrapped_asm.outputs) |operand| if (operand != .none) try isel.analyzeUse(operand);
             if (ty_pl.ty != .void_type) try isel.def_order.putNoClobber(gpa, air_inst_index, {});
 
             air_body_index += 1;
@@ -355,23 +354,23 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
             continue :air_tag air_tags[@intFromEnum(air_inst_index)];
         },
         inline .block, .dbg_inline_block => |air_tag| {
-            const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl;
-            const extra = isel.air.extraData(switch (air_tag) {
+            const air_body_block = switch (air_tag) {
                 else => comptime unreachable,
-                .block => Air.Block,
-                .dbg_inline_block => Air.DbgInlineBlock,
-            }, ty_pl.payload);
-            const result_ty = ty_pl.ty.toInterned().?;
+                .block => isel.air.unwrapBlock(air_inst_index),
+                .dbg_inline_block => isel.air.unwrapDbgBlock(air_inst_index),
+            };
+
+            const result_ty = air_body_block.ty.toIntern();
 
             if (result_ty == .noreturn_type) {
-                try isel.analyze(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+                try isel.analyze(air_body_block.body);
 
                 air_body_index += 1;
                 break :air_tag;
             }
 
             assert(!(try isel.blocks.getOrPut(gpa, air_inst_index)).found_existing);
-            try isel.analyze(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.analyze(air_body_block.body);
             const block_entry = isel.blocks.pop().?;
             assert(block_entry.key == air_inst_index);
 
@@ -382,8 +381,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
             continue :air_tag air_tags[@intFromEnum(air_inst_index)];
         },
         .loop => {
-            const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl;
-            const extra = isel.air.extraData(Air.Block, ty_pl.payload);
+            const air_body_block = isel.air.unwrapBlock(air_inst_index);
 
             const initial_dom_start = isel.dom_start;
             const initial_dom_len = isel.dom_len;
@@ -399,7 +397,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
                 .repeat_list = undefined,
             });
             try isel.dom.appendNTimes(gpa, 0, std.math.divCeil(usize, isel.dom_len, @bitSizeOf(DomInt)) catch unreachable);
-            try isel.analyze(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.analyze(air_body_block.body);
             for (
                 isel.dom.items[initial_dom_start..].ptr,
                 isel.dom.items[isel.dom_start..][0 .. std.math.divCeil(usize, initial_dom_len, @bitSizeOf(DomInt)) catch unreachable],
@@ -429,18 +427,17 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
         .call_never_tail,
         .call_never_inline,
         => {
-            const pl_op = air_data[@intFromEnum(air_inst_index)].pl_op;
-            const extra = isel.air.extraData(Air.Call, pl_op.payload);
-            const args: []const Air.Inst.Ref = @ptrCast(isel.air.extra.items[extra.end..][0..extra.data.args_len]);
+            const air_call = isel.air.unwrapCall(air_inst_index);
+            const args = air_call.args;
             isel.saved_registers.insert(.lr);
-            const callee_ty = isel.air.typeOf(pl_op.operand, ip);
+            const callee_ty = isel.air.typeOf(air_call.callee, ip);
             const func_info = switch (ip.indexToKey(callee_ty.toIntern())) {
                 else => unreachable,
                 .func_type => |func_type| func_type,
                 .ptr_type => |ptr_type| ip.indexToKey(ptr_type.child).func_type,
             };
 
-            try isel.analyzeUse(pl_op.operand);
+            try isel.analyzeUse(air_call.callee);
             var param_it: CallAbiIterator = .init;
             for (args, 0..) |arg, arg_index| {
                 const restore_values_len = isel.values.items.len;
@@ -549,13 +546,12 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
             continue :air_tag air_tags[@intFromEnum(air_inst_index)];
         },
         .cond_br => {
-            const pl_op = air_data[@intFromEnum(air_inst_index)].pl_op;
-            const extra = isel.air.extraData(Air.CondBr, pl_op.payload);
+            const cond_br = isel.air.unwrapCondBr(air_inst_index);
 
-            try isel.analyzeUse(pl_op.operand);
+            try isel.analyzeUse(cond_br.condition);
 
-            try isel.analyze(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.then_body_len]));
-            try isel.analyze(@ptrCast(isel.air.extra.items[extra.end + extra.data.then_body_len ..][0..extra.data.else_body_len]));
+            try isel.analyze(cond_br.then_body);
+            try isel.analyze(cond_br.else_body);
 
             air_body_index += 1;
         },
@@ -610,11 +606,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
             air_body_index += 1;
         },
         .@"try", .try_cold => {
-            const pl_op = air_data[@intFromEnum(air_inst_index)].pl_op;
-            const extra = isel.air.extraData(Air.Try, pl_op.payload);
+            const unwrapped_try = isel.air.unwrapTry(air_inst_index);
 
-            try isel.analyzeUse(pl_op.operand);
-            try isel.analyze(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.analyzeUse(unwrapped_try.error_union);
+            try isel.analyze(unwrapped_try.else_body);
             try isel.def_order.putNoClobber(gpa, air_inst_index, {});
 
             air_body_index += 1;
@@ -622,11 +617,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void {
             continue :air_tag air_tags[@intFromEnum(air_inst_index)];
         },
         .try_ptr, .try_ptr_cold => {
-            const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl;
-            const extra = isel.air.extraData(Air.TryPtr, ty_pl.payload);
+            const unwrapped_try = isel.air.unwrapTryPtr(air_inst_index);
 
-            try isel.analyzeUse(extra.data.ptr);
-            try isel.analyze(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.analyzeUse(unwrapped_try.error_union_ptr);
+            try isel.analyze(unwrapped_try.else_body);
             try isel.def_order.putNoClobber(gpa, air_inst_index, {});
 
             air_body_index += 1;
@@ -2698,12 +2692,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
         .inferred_alloc, .inferred_alloc_comptime => unreachable,
         .assembly => {
             const ty_pl = air.data(air.inst_index).ty_pl;
-            const extra = isel.air.extraData(Air.Asm, ty_pl.payload);
-            var extra_index = extra.end;
-            const outputs: []const Air.Inst.Ref = @ptrCast(isel.air.extra.items[extra_index..][0..extra.data.flags.outputs_len]);
-            extra_index += outputs.len;
-            const inputs: []const Air.Inst.Ref = @ptrCast(isel.air.extra.items[extra_index..][0..extra.data.inputs_len]);
-            extra_index += inputs.len;
+            const unwrapped_asm = isel.air.unwrapAsm(air.inst_index);
+            const inputs = unwrapped_asm.inputs;
 
             var as: codegen.aarch64.Assemble = .{
                 .source = undefined,
@@ -2711,15 +2701,12 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             };
             defer as.operands.deinit(gpa);
 
-            for (outputs) |output| {
-                const extra_bytes = std.mem.sliceAsBytes(isel.air.extra.items[extra_index..]);
-                const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(isel.air.extra.items[extra_index..]), 0);
-                const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-                // This equation accounts for the fact that even if we have exactly 4 bytes
-                // for the string, we still use the next u32 for the null terminator.
-                extra_index += (constraint.len + name.len + (2 + 3)) / 4;
+            var it = unwrapped_asm.iterateOutputs();
+            while (it.next()) |output| {
+                const constraint = output.constraint;
+                const name = output.name;
 
-                switch (output) {
+                switch (output.operand) {
                     else => return isel.fail("invalid constraint: '{s}'", .{constraint}),
                     .none => if (std.mem.startsWith(u8, constraint, "={") and std.mem.endsWith(u8, constraint, "}")) {
                         const output_reg = Register.parse(constraint["={".len .. constraint.len - "}".len]) orelse
@@ -2760,54 +2747,51 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             }
 
             const input_mats = try gpa.alloc(Value.Materialize, inputs.len);
+            var index: u32 = 0;
             defer gpa.free(input_mats);
-            const inputs_extra_index = extra_index;
-            for (inputs, input_mats) |input, *input_mat| {
-                const extra_bytes = std.mem.sliceAsBytes(isel.air.extra.items[extra_index..]);
-                const constraint = std.mem.sliceTo(extra_bytes, 0);
-                const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-                // This equation accounts for the fact that even if we have exactly 4 bytes
-                // for the string, we still use the next u32 for the null terminator.
-                extra_index += (constraint.len + name.len + (2 + 3)) / 4;
+            it = unwrapped_asm.iterateInputs();
+            while (it.next()) |input| : (index += 1) {
+                const constraint = input.constraint;
+                const name = input.name;
 
                 if (std.mem.startsWith(u8, constraint, "{") and std.mem.endsWith(u8, constraint, "}")) {
                     const input_reg = Register.parse(constraint["{".len .. constraint.len - "}".len]) orelse
                         return isel.fail("invalid constraint: '{s}'", .{constraint});
-                    input_mat.* = .{ .vi = try isel.use(input), .ra = input_reg.alias };
+                    input_mats[index] = .{ .vi = try isel.use(input.operand), .ra = input_reg.alias };
                     if (!std.mem.eql(u8, name, "_")) {
                         const operand_gop = try as.operands.getOrPut(gpa, name);
                         if (operand_gop.found_existing) return isel.fail("duplicate input name: '{s}'", .{name});
-                        const input_ty = isel.air.typeOf(input, ip);
+                        const input_ty = isel.air.typeOf(input.operand, ip);
                         operand_gop.value_ptr.* = .{ .register = switch (input_ty.abiSize(zcu)) {
                             0 => unreachable,
                             1...4 => input_reg.alias.w(),
                             5...8 => input_reg.alias.x(),
                             else => return isel.fail("too big input type: '{f}'", .{
-                                isel.fmtType(isel.air.typeOf(input, ip)),
+                                isel.fmtType(isel.air.typeOf(input.operand, ip)),
                             }),
                         } };
                     }
                 } else if (std.mem.eql(u8, constraint, "r")) {
-                    const input_vi = try isel.use(input);
-                    input_mat.* = try input_vi.matReg(isel);
+                    const input_vi = try isel.use(input.operand);
+                    input_mats[index] = try input_vi.matReg(isel);
                     if (!std.mem.eql(u8, name, "_")) {
                         const operand_gop = try as.operands.getOrPut(gpa, name);
                         if (operand_gop.found_existing) return isel.fail("duplicate input name: '{s}'", .{name});
                         operand_gop.value_ptr.* = .{ .register = switch (input_vi.size(isel)) {
                             0 => unreachable,
-                            1...4 => input_mat.ra.w(),
-                            5...8 => input_mat.ra.x(),
+                            1...4 => input_mats[index].ra.w(),
+                            5...8 => input_mats[index].ra.x(),
                             else => return isel.fail("too big input type: '{f}'", .{
-                                isel.fmtType(isel.air.typeOf(input, ip)),
+                                isel.fmtType(isel.air.typeOf(input.operand, ip)),
                             }),
                         } };
                     }
                 } else if (std.mem.eql(u8, name, "_")) {
-                    input_mat.vi = try isel.use(input);
+                    input_mats[index].vi = try isel.use(input.operand);
                 } else return isel.fail("invalid constraint: '{s}'", .{constraint});
             }
 
-            const clobbers = ip.indexToKey(extra.data.clobbers).aggregate;
+            const clobbers = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
             const clobbers_ty: ZigType = .fromInterned(clobbers.ty);
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
                 switch (switch (clobbers.storage) {
@@ -2858,7 +2842,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 }
             }
 
-            as.source = std.mem.sliceAsBytes(isel.air.extra.items[extra_index..])[0..extra.data.source_len :0];
+            as.source = unwrapped_asm.source;
             const asm_start = isel.instructions.items.len;
             while (as.nextInstruction() catch |err| switch (err) {
                 error.InvalidSyntax => {
@@ -2872,21 +2856,18 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             }) |instruction| try isel.emit(instruction);
             std.mem.reverse(codegen.aarch64.encoding.Instruction, isel.instructions.items[asm_start..]);
 
-            extra_index = inputs_extra_index;
-            for (input_mats) |input_mat| {
-                const extra_bytes = std.mem.sliceAsBytes(isel.air.extra.items[extra_index..]);
-                const constraint = std.mem.sliceTo(extra_bytes, 0);
-                const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-                // This equation accounts for the fact that even if we have exactly 4 bytes
-                // for the string, we still use the next u32 for the null terminator.
-                extra_index += (constraint.len + name.len + (2 + 3)) / 4;
+            it = unwrapped_asm.iterateInputs();
+            index = 0;
+            while (it.next()) |input| : (index += 1) {
+                const constraint = input.constraint;
+                const name = input.name;
 
                 if (std.mem.startsWith(u8, constraint, "{") and std.mem.endsWith(u8, constraint, "}")) {
-                    try input_mat.vi.liveOut(isel, input_mat.ra);
+                    try input_mats[index].vi.liveOut(isel, input_mats[index].ra);
                 } else if (std.mem.eql(u8, constraint, "r")) {
-                    try input_mat.finish(isel);
+                    try input_mats[index].finish(isel);
                 } else if (std.mem.eql(u8, name, "_")) {
-                    try input_mat.vi.mat(isel);
+                    try input_mats[index].vi.mat(isel);
                 } else unreachable;
             }
 
@@ -3515,16 +3496,16 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .block => {
-            const ty_pl = air.data(air.inst_index).ty_pl;
-            const extra = isel.air.extraData(Air.Block, ty_pl.payload);
-            try isel.block(air.inst_index, ty_pl.ty.toType(), @ptrCast(
-                isel.air.extra.items[extra.end..][0..extra.data.body_len],
-            ));
+            const unwrapped_block = isel.air.unwrapBlock(air.inst_index);
+            try isel.block(
+                air.inst_index,
+                unwrapped_block.ty,
+                unwrapped_block.body,
+            );
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .loop => {
-            const ty_pl = air.data(air.inst_index).ty_pl;
-            const extra = isel.air.extraData(Air.Block, ty_pl.payload);
+            const unwrapped_block = isel.air.unwrapBlock(air.inst_index);
             const loops = isel.loops.values();
             const loop_index = isel.loops.getIndex(air.inst_index).?;
             const loop = &loops[loop_index];
@@ -3558,7 +3539,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
 
             loop.live_registers = isel.live_registers;
             loop.repeat_list = Loop.empty_list;
-            try isel.body(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.body(unwrapped_block.body);
             try isel.merge(&loop.live_registers, .{ .fill_extra = true });
 
             var repeat_label = loop.repeat_list;
@@ -3608,10 +3589,9 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .call => {
-            const pl_op = air.data(air.inst_index).pl_op;
-            const extra = isel.air.extraData(Air.Call, pl_op.payload);
-            const args: []const Air.Inst.Ref = @ptrCast(isel.air.extra.items[extra.end..][0..extra.data.args_len]);
-            const callee_ty = isel.air.typeOf(pl_op.operand, ip);
+            const air_call = isel.air.unwrapCall(air.inst_index);
+            const args = air_call.args;
+            const callee_ty = isel.air.typeOf(air_call.callee, ip);
             const func_info = switch (ip.indexToKey(callee_ty.toIntern())) {
                 else => unreachable,
                 .func_type => |func_type| func_type,
@@ -3649,7 +3629,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             try call.finishReturn(isel);
 
             try call.prepareCallee(isel);
-            if (pl_op.operand.toInterned()) |ct_callee| {
+            if (air_call.callee.toInterned()) |ct_callee| {
                 try isel.nav_relocs.append(gpa, switch (ip.indexToKey(ct_callee)) {
                     else => unreachable,
                     inline .@"extern", .func => |func| .{
@@ -3666,7 +3646,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 });
                 try isel.emit(.bl(0));
             } else {
-                const callee_vi = try isel.use(pl_op.operand);
+                const callee_vi = try isel.use(air_call.callee);
                 const callee_mat = try callee_vi.matReg(isel);
                 try isel.emit(.blr(callee_mat.ra.x()));
                 try callee_mat.finish(isel);
@@ -4523,16 +4503,15 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .cond_br => {
-            const pl_op = air.data(air.inst_index).pl_op;
-            const extra = isel.air.extraData(Air.CondBr, pl_op.payload);
+            const cond_br = isel.air.unwrapCondBr(air.inst_index);
 
-            try isel.body(@ptrCast(isel.air.extra.items[extra.end + extra.data.then_body_len ..][0..extra.data.else_body_len]));
+            try isel.body(cond_br.then_body);
             const else_label = isel.instructions.items.len;
             const else_live_registers = isel.live_registers;
-            try isel.body(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.then_body_len]));
+            try isel.body(cond_br.else_body);
             try isel.merge(&else_live_registers, .{});
 
-            const cond_vi = try isel.use(pl_op.operand);
+            const cond_vi = try isel.use(cond_br.condition);
             const cond_mat = try cond_vi.matReg(isel);
             try isel.emit(.tbz(
                 cond_mat.ra.x(),
@@ -4819,13 +4798,12 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .@"try", .try_cold => {
-            const pl_op = air.data(air.inst_index).pl_op;
-            const extra = isel.air.extraData(Air.Try, pl_op.payload);
-            const error_union_ty = isel.air.typeOf(pl_op.operand, ip);
+            const unwrapped_try = isel.air.unwrapTry(air.inst_index);
+            const error_union_ty = isel.air.typeOf(unwrapped_try.error_union, &zcu.intern_pool);
             const error_union_info = ip.indexToKey(error_union_ty.toIntern()).error_union_type;
             const payload_ty: ZigType = .fromInterned(error_union_info.payload_type);
 
-            const error_union_vi = try isel.use(pl_op.operand);
+            const error_union_vi = try isel.use(unwrapped_try.error_union);
             if (isel.live_values.fetchRemove(air.inst_index)) |payload_vi| {
                 defer payload_vi.value.deref(isel);
 
@@ -4840,7 +4818,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
 
             const cont_label = isel.instructions.items.len;
             const cont_live_registers = isel.live_registers;
-            try isel.body(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.body(unwrapped_try.else_body);
             try isel.merge(&cont_live_registers, .{});
 
             var error_set_part_it = error_union_vi.field(
@@ -4859,18 +4837,17 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .try_ptr, .try_ptr_cold => {
-            const ty_pl = air.data(air.inst_index).ty_pl;
-            const extra = isel.air.extraData(Air.TryPtr, ty_pl.payload);
-            const error_union_ty = isel.air.typeOf(extra.data.ptr, ip).childType(zcu);
+            const unwrapped_try = isel.air.unwrapTryPtr(air.inst_index);
+            const error_union_ty = isel.air.typeOf(unwrapped_try.error_union_ptr, ip).childType(zcu);
             const error_union_info = ip.indexToKey(error_union_ty.toIntern()).error_union_type;
             const payload_ty: ZigType = .fromInterned(error_union_info.payload_type);
 
-            const error_union_ptr_vi = try isel.use(extra.data.ptr);
+            const error_union_ptr_vi = try isel.use(unwrapped_try.error_union_ptr);
             const error_union_ptr_mat = try error_union_ptr_vi.matReg(isel);
             if (isel.live_values.fetchRemove(air.inst_index)) |payload_ptr_vi| unused: {
                 defer payload_ptr_vi.value.deref(isel);
-                switch (codegen.errUnionPayloadOffset(ty_pl.ty.toType().childType(zcu), zcu)) {
-                    0 => try payload_ptr_vi.value.move(isel, extra.data.ptr),
+                switch (codegen.errUnionPayloadOffset(unwrapped_try.error_union_payload_ptr_ty.toType().childType(zcu), zcu)) {
+                    0 => try payload_ptr_vi.value.move(isel, unwrapped_try.error_union_ptr),
                     else => |payload_offset| {
                         const payload_ptr_ra = try payload_ptr_vi.value.defReg(isel) orelse break :unused;
                         const lo12: u12 = @truncate(payload_offset >> 0);
@@ -4887,7 +4864,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
 
             const cont_label = isel.instructions.items.len;
             const cont_live_registers = isel.live_registers;
-            try isel.body(@ptrCast(isel.air.extra.items[extra.end..][0..extra.data.body_len]));
+            try isel.body(unwrapped_try.else_body);
             try isel.merge(&cont_live_registers, .{});
 
             const error_set_ra = try isel.allocIntReg();
@@ -4913,11 +4890,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .dbg_inline_block => {
-            const ty_pl = air.data(air.inst_index).ty_pl;
-            const extra = isel.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
-            try isel.block(air.inst_index, ty_pl.ty.toType(), @ptrCast(
-                isel.air.extra.items[extra.end..][0..extra.data.body_len],
-            ));
+            const dbg_block = isel.air.unwrapDbgBlock(air.inst_index);
+            try isel.block(air.inst_index, dbg_block.ty, dbg_block.body);
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
         .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => {
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index f55dd408b52460bad630bf4efd1a2f251a5b8d91..106737a8331c523f9ecddad0e0138f31a10ea06f 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -4622,9 +4622,8 @@ fn airCall(
     const gpa = f.object.dg.gpa;
     const w = &f.object.code.writer;
 
-    const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = f.air.extraData(Air.Call, pl_op.payload);
-    const args: []const Air.Inst.Ref = @ptrCast(f.air.extra.items[extra.end..][0..extra.data.args_len]);
+    const call = f.air.unwrapCall(inst);
+    const args = call.args;
 
     const resolved_args = try gpa.alloc(CValue, args.len);
     defer gpa.free(resolved_args);
@@ -4653,15 +4652,15 @@ fn airCall(
         }
     }
 
-    const callee = try f.resolveInst(pl_op.operand);
+    const callee = try f.resolveInst(call.callee);
 
     {
         var bt = iterateBigTomb(f, inst);
-        try bt.feed(pl_op.operand);
+        try bt.feed(call.callee);
         for (args) |arg| try bt.feed(arg);
     }
 
-    const callee_ty = f.typeOf(pl_op.operand);
+    const callee_ty = f.typeOf(call.callee);
     const callee_is_ptr = switch (callee_ty.zigTypeTag(zcu)) {
         .@"fn" => false,
         .pointer => true,
@@ -4698,7 +4697,7 @@ fn airCall(
 
     callee: {
         known: {
-            const callee_val = (try f.air.value(pl_op.operand, pt)) orelse break :known;
+            const callee_val = (try f.air.value(call.callee, pt)) orelse break :known;
             const fn_nav, const need_cast = switch (ip.indexToKey(callee_val.toIntern())) {
                 .@"extern" => |@"extern"| .{ @"extern".owner_nav, false },
                 .func => |func| .{ func.owner_nav, Type.fromInterned(func.ty).fnCallingConvention(zcu) != .naked and
@@ -4796,13 +4795,12 @@ fn airDbgInlineBlock(f: *Function, inst: Air.Inst.Index) !CValue {
     const pt = f.object.dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = f.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
-    const owner_nav = ip.getNav(zcu.funcInfo(extra.data.func).owner_nav);
+    const block = f.air.unwrapDbgBlock(inst);
+    const owner_nav = ip.getNav(zcu.funcInfo(block.func).owner_nav);
     const w = &f.object.code.writer;
     try w.print("/* inline:{f} */", .{owner_nav.fqn.fmt(&zcu.intern_pool)});
     try f.object.newline();
-    return lowerBlock(f, inst, @ptrCast(f.air.extra.items[extra.end..][0..extra.data.body_len]));
+    return lowerBlock(f, inst, block.body);
 }
 
 fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue {
@@ -4822,9 +4820,8 @@ fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airBlock(f: *Function, inst: Air.Inst.Index) !CValue {
-    const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = f.air.extraData(Air.Block, ty_pl.payload);
-    return lowerBlock(f, inst, @ptrCast(f.air.extra.items[extra.end..][0..extra.data.body_len]));
+    const block = f.air.unwrapBlock(inst);
+    return lowerBlock(f, inst, block.body);
 }
 
 fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index) !CValue {
@@ -4873,21 +4870,19 @@ fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index)
 }
 
 fn airTry(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = f.air.extraData(Air.Try, pl_op.payload);
-    const body: []const Air.Inst.Index = @ptrCast(f.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const err_union_ty = f.typeOf(pl_op.operand);
-    return lowerTry(f, inst, pl_op.operand, body, err_union_ty, false);
+    const pt = f.object.dg.pt;
+    const unwrapped_try = f.air.unwrapTry(inst);
+    const body = unwrapped_try.else_body;
+    const err_union_ty = f.air.typeOf(unwrapped_try.error_union, &pt.zcu.intern_pool);
+    return lowerTry(f, inst, unwrapped_try.error_union, body, err_union_ty, false);
 }
 
 fn airTryPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
-    const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = f.air.extraData(Air.TryPtr, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(f.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const err_union_ty = f.typeOf(extra.data.ptr).childType(zcu);
-    return lowerTry(f, inst, extra.data.ptr, body, err_union_ty, true);
+    const unwrapped_try = f.air.unwrapTryPtr(inst);
+    const body = unwrapped_try.else_body;
+    const err_union_ty = f.air.typeOf(unwrapped_try.error_union_ptr, &pt.zcu.intern_pool).childType(pt.zcu);
+    return lowerTry(f, inst, unwrapped_try.error_union_ptr, body, err_union_ty, true);
 }
 
 fn lowerTry(
@@ -5216,9 +5211,7 @@ fn airUnreach(o: *Object) !void {
 }
 
 fn airLoop(f: *Function, inst: Air.Inst.Index) !void {
-    const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const loop = f.air.extraData(Air.Block, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(f.air.extra.items[loop.end..][0..loop.data.body_len]);
+    const block = f.air.unwrapBlock(inst);
     const w = &f.object.code.writer;
 
     // `repeat` instructions matching this loop will branch to
@@ -5227,16 +5220,15 @@ fn airLoop(f: *Function, inst: Air.Inst.Index) !void {
     // construct at all!
     try w.print("zig_loop_{d}:", .{@intFromEnum(inst)});
     try f.object.newline();
-    try genBodyInner(f, body); // no need to restore state, we're noreturn
+    try genBodyInner(f, block.body); // no need to restore state, we're noreturn
 }
 
 fn airCondBr(f: *Function, inst: Air.Inst.Index) !void {
-    const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const cond = try f.resolveInst(pl_op.operand);
-    try reap(f, inst, &.{pl_op.operand});
-    const extra = f.air.extraData(Air.CondBr, pl_op.payload);
-    const then_body: []const Air.Inst.Index = @ptrCast(f.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-    const else_body: []const Air.Inst.Index = @ptrCast(f.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+    const cond_br = f.air.unwrapCondBr(inst);
+    const cond = try f.resolveInst(cond_br.condition);
+    try reap(f, inst, &.{cond_br.condition});
+    const then_body = cond_br.then_body;
+    const else_body = cond_br.else_body;
     const liveness_condbr = f.liveness.getCondBr(inst);
     const w = &f.object.code.writer;
 
@@ -5439,16 +5431,11 @@ fn asmInputNeedsLocal(f: *Function, constraint: []const u8, value: CValue) bool
 fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
     const pt = f.object.dg.pt;
     const zcu = pt.zcu;
-    const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = f.air.extraData(Air.Asm, ty_pl.payload);
-    const is_volatile = extra.data.flags.is_volatile;
-    const outputs_len = extra.data.flags.outputs_len;
+    const unwrapped_asm = f.air.unwrapAsm(inst);
+    const is_volatile = unwrapped_asm.is_volatile;
     const gpa = f.object.dg.gpa;
-    var extra_i: usize = extra.end;
-    const outputs: []const Air.Inst.Ref = @ptrCast(f.air.extra.items[extra_i..][0..outputs_len]);
-    extra_i += outputs.len;
-    const inputs: []const Air.Inst.Ref = @ptrCast(f.air.extra.items[extra_i..][0..extra.data.inputs_len]);
-    extra_i += inputs.len;
+    const outputs = unwrapped_asm.outputs;
+    const inputs = unwrapped_asm.inputs;
 
     const result = result: {
         const w = &f.object.code.writer;
@@ -5469,14 +5456,9 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
         } else .none;
 
         const locals_begin: LocalIndex = @intCast(f.locals.items.len);
-        const constraints_extra_begin = extra_i;
-        for (outputs) |output| {
-            const extra_bytes = mem.sliceAsBytes(f.air.extra.items[extra_i..]);
-            const constraint = mem.sliceTo(extra_bytes, 0);
-            const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+        var it = unwrapped_asm.iterateOutputs();
+        while (it.next()) |output| {
+            const constraint = output.constraint;
 
             if (constraint.len < 2 or constraint[0] != '=' or
                 (constraint[1] == '{' and constraint[constraint.len - 1] != '}'))
@@ -5486,7 +5468,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
 
             const is_reg = constraint[1] == '{';
             if (is_reg) {
-                const output_ty = if (output == .none) inst_ty else f.typeOf(output).childType(zcu);
+                const output_ty = if (output.operand == .none) inst_ty else f.typeOf(output.operand).childType(zcu);
                 try w.writeAll("register ");
                 const output_local = try f.allocLocalValue(.{
                     .ctype = try f.ctypeFromType(output_ty, .complete),
@@ -5505,13 +5487,10 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
                 try f.object.newline();
             }
         }
-        for (inputs) |input| {
-            const extra_bytes = mem.sliceAsBytes(f.air.extra.items[extra_i..]);
-            const constraint = mem.sliceTo(extra_bytes, 0);
-            const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+
+        it = unwrapped_asm.iterateInputs();
+        while (it.next()) |input| {
+            const constraint = input.constraint;
 
             if (constraint.len < 1 or mem.indexOfScalar(u8, "=+&%", constraint[0]) != null or
                 (constraint[0] == '{' and constraint[constraint.len - 1] != '}'))
@@ -5520,9 +5499,9 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
             }
 
             const is_reg = constraint[0] == '{';
-            const input_val = try f.resolveInst(input);
+            const input_val = try f.resolveInst(input.operand);
             if (asmInputNeedsLocal(f, constraint, input_val)) {
-                const input_ty = f.typeOf(input);
+                const input_ty = f.typeOf(input.operand);
                 if (is_reg) try w.writeAll("register ");
                 const input_local = try f.allocLocalValue(.{
                     .ctype = try f.ctypeFromType(input_ty, .complete),
@@ -5545,7 +5524,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
         }
 
         {
-            const asm_source = mem.sliceAsBytes(f.air.extra.items[extra_i..])[0..extra.data.source_len];
+            const asm_source = unwrapped_asm.source;
 
             var stack = std.heap.stackFallback(256, f.object.dg.gpa);
             const allocator = stack.get();
@@ -5599,18 +5578,15 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
             try w.print("({f}", .{fmtStringLiteral(fixed_asm_source[0..dst_i], null)});
         }
 
-        extra_i = constraints_extra_begin;
         var locals_index = locals_begin;
         try w.writeByte(':');
-        for (outputs, 0..) |output, index| {
-            const extra_bytes = mem.sliceAsBytes(f.air.extra.items[extra_i..]);
-            const constraint = mem.sliceTo(extra_bytes, 0);
-            const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
 
-            if (index > 0) try w.writeByte(',');
+        it = unwrapped_asm.iterateOutputs();
+        while (it.next()) |output| {
+            const constraint = output.constraint;
+            const name = output.name;
+
+            if (output.index > 0) try w.writeByte(',');
             try w.writeByte(' ');
             if (!mem.eql(u8, name, "_")) try w.print("[{s}]", .{name});
             const is_reg = constraint[1] == '{';
@@ -5618,28 +5594,26 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
             if (is_reg) {
                 try f.writeCValue(w, .{ .local = locals_index }, .Other);
                 locals_index += 1;
-            } else if (output == .none) {
+            } else if (output.operand == .none) {
                 try f.writeCValue(w, inst_local, .FunctionArgument);
             } else {
-                try f.writeCValueDeref(w, try f.resolveInst(output));
+                try f.writeCValueDeref(w, try f.resolveInst(output.operand));
             }
             try w.writeByte(')');
         }
         try w.writeByte(':');
-        for (inputs, 0..) |input, index| {
-            const extra_bytes = mem.sliceAsBytes(f.air.extra.items[extra_i..]);
-            const constraint = mem.sliceTo(extra_bytes, 0);
-            const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
 
-            if (index > 0) try w.writeByte(',');
+        it = unwrapped_asm.iterateInputs();
+        while (it.next()) |input| {
+            const constraint = input.constraint;
+            const name = input.name;
+
+            if (input.index > 0) try w.writeByte(',');
             try w.writeByte(' ');
             if (!mem.eql(u8, name, "_")) try w.print("[{s}]", .{name});
 
             const is_reg = constraint[0] == '{';
-            const input_val = try f.resolveInst(input);
+            const input_val = try f.resolveInst(input.operand);
             try w.print("{f}(", .{fmtStringLiteral(if (is_reg) "r" else constraint, null)});
             try f.writeCValue(w, if (asmInputNeedsLocal(f, constraint, input_val)) local: {
                 const input_local_idx = locals_index;
@@ -5650,7 +5624,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
         }
         try w.writeByte(':');
         const ip = &zcu.intern_pool;
-        const aggregate = ip.indexToKey(extra.data.clobbers).aggregate;
+        const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
         const struct_type: Type = .fromInterned(aggregate.ty);
         switch (aggregate.storage) {
             .elems => |elems| for (elems, 0..) |elem, i| switch (elem) {
@@ -5697,22 +5671,17 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
         try w.writeAll(");");
         try f.object.newline();
 
-        extra_i = constraints_extra_begin;
         locals_index = locals_begin;
-        for (outputs) |output| {
-            const extra_bytes = mem.sliceAsBytes(f.air.extra.items[extra_i..]);
-            const constraint = mem.sliceTo(extra_bytes, 0);
-            const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+        it = unwrapped_asm.iterateOutputs();
+        while (it.next()) |output| {
+            const constraint = output.constraint;
 
             const is_reg = constraint[1] == '{';
             if (is_reg) {
-                try f.writeCValueDeref(w, if (output == .none)
+                try f.writeCValueDeref(w, if (output.operand == .none)
                     .{ .local_ref = inst_local.new_local }
                 else
-                    try f.resolveInst(output));
+                    try f.resolveInst(output.operand));
                 try w.writeAll(" = ");
                 try f.writeCValue(w, .{ .local = locals_index }, .Other);
                 locals_index += 1;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index a178604a6874b68dc30e69f00b7d50bc0e0bfa86..b2a7d230ce7b695f715c2421e9ef2c5f1588f998 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -5258,14 +5258,13 @@ pub const FuncGen = struct {
     };
 
     fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !Builder.Value {
-        const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-        const extra = self.air.extraData(Air.Call, pl_op.payload);
-        const args: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.args_len]);
+        const air_call = self.air.unwrapCall(inst);
+        const args = air_call.args;
         const o = self.ng.object;
         const pt = self.ng.pt;
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
-        const callee_ty = self.typeOf(pl_op.operand);
+        const callee_ty = self.typeOf(air_call.callee);
         const zig_fn_ty = switch (callee_ty.zigTypeTag(zcu)) {
             .@"fn" => callee_ty,
             .pointer => callee_ty.childType(zcu),
@@ -5273,7 +5272,7 @@ pub const FuncGen = struct {
         };
         const fn_info = zcu.typeToFunc(zig_fn_ty).?;
         const return_type = Type.fromInterned(fn_info.return_type);
-        const llvm_fn = try self.resolveInst(pl_op.operand);
+        const llvm_fn = try self.resolveInst(air_call.callee);
         const target = zcu.getTarget();
         const sret = firstParamSRet(fn_info, zcu, target);
 
@@ -5934,9 +5933,8 @@ pub const FuncGen = struct {
     }
 
     fn airBlock(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
-        const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = self.air.extraData(Air.Block, ty_pl.payload);
-        return self.lowerBlock(inst, null, @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]));
+        const block = self.air.unwrapBlock(inst);
+        return self.lowerBlock(inst, null, block.body);
     }
 
     fn lowerBlock(
@@ -6216,11 +6214,10 @@ pub const FuncGen = struct {
     }
 
     fn airCondBr(self: *FuncGen, inst: Air.Inst.Index) !void {
-        const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-        const cond = try self.resolveInst(pl_op.operand);
-        const extra = self.air.extraData(Air.CondBr, pl_op.payload);
-        const then_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-        const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+        const cond_br = self.air.unwrapCondBr(inst);
+        const cond = try self.resolveInst(cond_br.condition);
+        const then_body = cond_br.then_body;
+        const else_body = cond_br.else_body;
 
         const Hint = enum {
             none,
@@ -6230,22 +6227,22 @@ pub const FuncGen = struct {
             then_cold,
             else_cold,
         };
-        const hint: Hint = switch (extra.data.branch_hints.true) {
-            .none => switch (extra.data.branch_hints.false) {
+        const hint: Hint = switch (cond_br.branch_hints.true) {
+            .none => switch (cond_br.branch_hints.false) {
                 .none => .none,
                 .likely => .else_likely,
                 .unlikely => .then_likely,
                 .cold => .else_cold,
                 .unpredictable => .unpredictable,
             },
-            .likely => switch (extra.data.branch_hints.false) {
+            .likely => switch (cond_br.branch_hints.false) {
                 .none => .then_likely,
                 .likely => .unpredictable,
                 .unlikely => .then_likely,
                 .cold => .else_cold,
                 .unpredictable => .unpredictable,
             },
-            .unlikely => switch (extra.data.branch_hints.false) {
+            .unlikely => switch (cond_br.branch_hints.false) {
                 .none => .else_likely,
                 .likely => .else_likely,
                 .unlikely => .unpredictable,
@@ -6267,35 +6264,33 @@ pub const FuncGen = struct {
 
         self.wip.cursor = .{ .block = then_block };
         if (hint == .then_cold) _ = try self.wip.callIntrinsicAssumeCold();
-        try self.genBodyDebugScope(null, then_body, extra.data.branch_hints.then_cov);
+        try self.genBodyDebugScope(null, then_body, cond_br.branch_hints.then_cov);
 
         self.wip.cursor = .{ .block = else_block };
         if (hint == .else_cold) _ = try self.wip.callIntrinsicAssumeCold();
-        try self.genBodyDebugScope(null, else_body, extra.data.branch_hints.else_cov);
+        try self.genBodyDebugScope(null, else_body, cond_br.branch_hints.else_cov);
 
         // No need to reset the insert cursor since this instruction is noreturn.
     }
 
     fn airTry(self: *FuncGen, inst: Air.Inst.Index, err_cold: bool) !Builder.Value {
-        const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-        const err_union = try self.resolveInst(pl_op.operand);
-        const extra = self.air.extraData(Air.Try, pl_op.payload);
-        const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
-        const err_union_ty = self.typeOf(pl_op.operand);
+        const unwrapped_try = self.air.unwrapTry(inst);
+        const err_union = try self.resolveInst(unwrapped_try.error_union);
+        const body = unwrapped_try.else_body;
+        const err_union_ty = self.typeOf(unwrapped_try.error_union);
         const is_unused = self.liveness.isUnused(inst);
         return lowerTry(self, err_union, body, err_union_ty, false, false, is_unused, err_cold);
     }
 
     fn airTryPtr(self: *FuncGen, inst: Air.Inst.Index, err_cold: bool) !Builder.Value {
         const zcu = self.ng.pt.zcu;
-        const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
-        const err_union_ptr = try self.resolveInst(extra.data.ptr);
-        const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
-        const err_union_ty = self.typeOf(extra.data.ptr).childType(zcu);
+        const unwrapped_try = self.air.unwrapTryPtr(inst);
+        const err_union_ptr = try self.resolveInst(unwrapped_try.error_union_ptr);
+        const body = unwrapped_try.else_body;
+        const err_union_ty = self.typeOf(unwrapped_try.error_union_ptr).childType(zcu);
         const is_unused = self.liveness.isUnused(inst);
 
-        self.maybeMarkAllowZeroAccess(self.typeOf(extra.data.ptr).ptrInfo(zcu));
+        self.maybeMarkAllowZeroAccess(self.typeOf(unwrapped_try.error_union_ptr).ptrInfo(zcu));
 
         return lowerTry(self, err_union_ptr, body, err_union_ty, true, true, is_unused, err_cold);
     }
@@ -6627,9 +6622,8 @@ pub const FuncGen = struct {
     }
 
     fn airLoop(self: *FuncGen, inst: Air.Inst.Index) !void {
-        const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const loop = self.air.extraData(Air.Block, ty_pl.payload);
-        const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[loop.end..][0..loop.data.body_len]);
+        const block = self.air.unwrapBlock(inst);
+        const body = block.body;
         const loop_block = try self.wip.block(1, "Loop"); // `airRepeat` will increment incoming each time
         _ = try self.wip.br(loop_block);
 
@@ -7137,10 +7131,9 @@ pub const FuncGen = struct {
     }
 
     fn airDbgInlineBlock(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
-        const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
+        const block = self.air.unwrapDbgBlock(inst);
         self.arg_inline_index = 0;
-        return self.lowerBlock(inst, extra.data.func, @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]));
+        return self.lowerBlock(inst, block.func, block.body);
     }
 
     fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
@@ -7262,17 +7255,12 @@ pub const FuncGen = struct {
         // this implementation feeds the inline assembly code directly to LLVM.
 
         const o = self.ng.object;
-        const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-        const extra = self.air.extraData(Air.Asm, ty_pl.payload);
-        const is_volatile = extra.data.flags.is_volatile;
-        const outputs_len = extra.data.flags.outputs_len;
+        const unwrapped_asm = self.air.unwrapAsm(inst);
+        const is_volatile = unwrapped_asm.is_volatile;
         const gpa = self.gpa;
-        var extra_i: usize = extra.end;
 
-        const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..outputs_len]);
-        extra_i += outputs.len;
-        const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..extra.data.inputs_len]);
-        extra_i += inputs.len;
+        const outputs = unwrapped_asm.outputs;
+        const inputs = unwrapped_asm.inputs;
 
         var llvm_constraints: std.ArrayList(u8) = .empty;
         defer llvm_constraints.deinit(gpa);
@@ -7305,14 +7293,10 @@ pub const FuncGen = struct {
         var name_map: std.StringArrayHashMapUnmanaged(u16) = .empty;
         try name_map.ensureUnusedCapacity(arena, max_param_count);
 
-        var rw_extra_i = extra_i;
-        for (outputs, llvm_ret_indirect, llvm_rw_vals) |output, *is_indirect, *llvm_rw_val| {
-            const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
-            const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[extra_i..]), 0);
-            const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+        var it = unwrapped_asm.iterateOutputs();
+        while (it.next()) |output| {
+            const constraint = output.constraint;
+            const name = output.name;
 
             try llvm_constraints.ensureUnusedCapacity(gpa, constraint.len + 3);
             if (total_i != 0) {
@@ -7320,15 +7304,15 @@ pub const FuncGen = struct {
             }
             llvm_constraints.appendAssumeCapacity('=');
 
-            if (output != .none) {
-                const output_inst = try self.resolveInst(output);
-                const output_ty = self.typeOf(output);
+            if (output.operand != .none) {
+                const output_inst = try self.resolveInst(output.operand);
+                const output_ty = self.typeOf(output.operand);
                 assert(output_ty.zigTypeTag(zcu) == .pointer);
                 const elem_llvm_ty = try o.lowerPtrElemTy(pt, output_ty.childType(zcu));
 
                 switch (constraint[0]) {
                     '=' => {},
-                    '+' => llvm_rw_val.* = output_inst,
+                    '+' => llvm_rw_vals[output.index] = output_inst,
                     else => return self.todo("unsupported output constraint on output type '{c}'", .{
                         constraint[0],
                     }),
@@ -7337,8 +7321,8 @@ pub const FuncGen = struct {
                 self.maybeMarkAllowZeroAccess(output_ty.ptrInfo(zcu));
 
                 // Pass any non-return outputs indirectly, if the constraint accepts a memory location
-                is_indirect.* = constraintAllowsMemory(constraint);
-                if (is_indirect.*) {
+                llvm_ret_indirect[output.index] = constraintAllowsMemory(constraint);
+                if (llvm_ret_indirect[output.index]) {
                     // Pass the result by reference as an indirect output (e.g. "=*m")
                     llvm_constraints.appendAssumeCapacity('*');
 
@@ -7359,7 +7343,7 @@ pub const FuncGen = struct {
                     }),
                 }
 
-                is_indirect.* = false;
+                llvm_ret_indirect[output.index] = false;
 
                 const ret_ty = self.typeOfIndex(inst);
                 llvm_ret_types[llvm_ret_i] = try o.lowerType(pt, ret_ty);
@@ -7387,16 +7371,13 @@ pub const FuncGen = struct {
             total_i += 1;
         }
 
-        for (inputs) |input| {
-            const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
-            const constraint = std.mem.sliceTo(extra_bytes, 0);
-            const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+        it = unwrapped_asm.iterateInputs();
+        while (it.next()) |input| {
+            const constraint = input.constraint;
+            const name = input.name;
 
-            const arg_llvm_value = try self.resolveInst(input);
-            const arg_ty = self.typeOf(input);
+            const arg_llvm_value = try self.resolveInst(input.operand);
+            const arg_ty = self.typeOf(input.operand);
             const is_by_ref = isByRef(arg_ty, zcu);
             if (is_by_ref) {
                 if (constraintAllowsMemory(constraint)) {
@@ -7452,27 +7433,23 @@ pub const FuncGen = struct {
             total_i += 1;
         }
 
-        for (outputs, llvm_ret_indirect, llvm_rw_vals, 0..) |output, is_indirect, llvm_rw_val, output_index| {
-            const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[rw_extra_i..]);
-            const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[rw_extra_i..]), 0);
-            const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            rw_extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+        it = unwrapped_asm.iterateOutputs();
+        while (it.next()) |output| {
+            const constraint = output.constraint;
 
             if (constraint[0] != '+') continue;
 
-            const rw_ty = self.typeOf(output);
+            const rw_ty = self.typeOf(output.operand);
             const llvm_elem_ty = try o.lowerPtrElemTy(pt, rw_ty.childType(zcu));
-            if (is_indirect) {
-                llvm_param_values[llvm_param_i] = llvm_rw_val;
-                llvm_param_types[llvm_param_i] = llvm_rw_val.typeOfWip(&self.wip);
+            if (llvm_ret_indirect[output.index]) {
+                llvm_param_values[llvm_param_i] = llvm_rw_vals[output.index];
+                llvm_param_types[llvm_param_i] = llvm_rw_vals[output.index].typeOfWip(&self.wip);
             } else {
                 const alignment = rw_ty.abiAlignment(zcu).toLlvm();
                 const loaded = try self.wip.load(
                     if (rw_ty.isVolatilePtr(zcu)) .@"volatile" else .normal,
                     llvm_elem_ty,
-                    llvm_rw_val,
+                    llvm_rw_vals[output.index],
                     alignment,
                     "",
                 );
@@ -7480,18 +7457,18 @@ pub const FuncGen = struct {
                 llvm_param_types[llvm_param_i] = llvm_elem_ty;
             }
 
-            try llvm_constraints.print(gpa, ",{d}", .{output_index});
+            try llvm_constraints.print(gpa, ",{d}", .{output.index});
 
             // In the case of indirect inputs, LLVM requires the callsite to have
             // an elementtype(<ty>) attribute.
-            llvm_param_attrs[llvm_param_i] = if (is_indirect) llvm_elem_ty else .none;
+            llvm_param_attrs[llvm_param_i] = if (llvm_ret_indirect[output.index]) llvm_elem_ty else .none;
 
             llvm_param_i += 1;
             total_i += 1;
         }
 
         const ip = &zcu.intern_pool;
-        const aggregate = ip.indexToKey(extra.data.clobbers).aggregate;
+        const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
         const struct_type: Type = .fromInterned(aggregate.ty);
         if (total_i != 0) try llvm_constraints.append(gpa, ',');
         switch (aggregate.storage) {
@@ -7539,7 +7516,7 @@ pub const FuncGen = struct {
 
         if (std.mem.endsWith(u8, llvm_constraints.items, ",")) llvm_constraints.items.len -= 1;
 
-        const asm_source = std.mem.sliceAsBytes(self.air.extra.items[extra_i..])[0..extra.data.source_len];
+        const asm_source = unwrapped_asm.source;
 
         // hackety hacks until stage2 has proper inline asm in the frontend.
         var rendered_template = std.array_list.Managed(u8).init(gpa);
diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig
index 5dc89d9af916d5c6f6cc47dfd32982622b3e9412..1f70f5f4de379ad0e01f75be35f0d13695f5b766 100644
--- a/src/codegen/riscv64/CodeGen.zig
+++ b/src/codegen/riscv64/CodeGen.zig
@@ -3627,11 +3627,11 @@ fn airRuntimeNavPtr(func: *Func, inst: Air.Inst.Index) !void {
 }
 
 fn airTry(func: *Func, inst: Air.Inst.Index) !void {
-    const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = func.air.extraData(Air.Try, pl_op.payload);
-    const body: []const Air.Inst.Index = @ptrCast(func.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const operand_ty = func.typeOf(pl_op.operand);
-    const result = try func.genTry(inst, pl_op.operand, body, operand_ty, false);
+    const zcu = func.pt.zcu;
+    const unwrapped_try = func.air.unwrapTry(inst);
+    const body = unwrapped_try.else_body;
+    const operand_ty = func.air.typeOf(unwrapped_try.error_union, &zcu.intern_pool);
+    const result = try func.genTry(inst, unwrapped_try.error_union, body, operand_ty, false);
     return func.finishAir(inst, result, .{ .none, .none, .none });
 }
 
@@ -4801,10 +4801,8 @@ fn airFrameAddress(func: *Func, inst: Air.Inst.Index) !void {
 
 fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
     if (modifier == .always_tail) return func.fail("TODO implement tail calls for riscv64", .{});
-    const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const callee = pl_op.operand;
-    const extra = func.air.extraData(Air.Call, pl_op.payload);
-    const arg_refs: []const Air.Inst.Ref = @ptrCast(func.air.extra.items[extra.end..][0..extra.data.args_len]);
+    const call = func.air.unwrapCall(inst);
+    const arg_refs = call.args;
 
     const expected_num_args = 8;
     const ExpectedContents = extern struct {
@@ -4822,10 +4820,10 @@ fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
     defer allocator.free(arg_vals);
     for (arg_vals, arg_refs) |*arg_val, arg_ref| arg_val.* = .{ .air_ref = arg_ref };
 
-    const call_ret = try func.genCall(.{ .air = callee }, arg_tys, arg_vals);
+    const call_ret = try func.genCall(.{ .air = call.callee }, arg_tys, arg_vals);
 
     var bt = func.liveness.iterateBigTomb(inst);
-    try func.feed(&bt, pl_op.operand);
+    try func.feed(&bt, call.callee);
     for (arg_refs) |arg_ref| try func.feed(&bt, arg_ref);
 
     const result = if (func.liveness.isUnused(inst)) .unreach else call_ret;
@@ -5218,9 +5216,8 @@ fn airDbgStmt(func: *Func, inst: Air.Inst.Index) !void {
 }
 
 fn airDbgInlineBlock(func: *Func, inst: Air.Inst.Index) !void {
-    const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = func.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
-    try func.lowerBlock(inst, @ptrCast(func.air.extra.items[extra.end..][0..extra.data.body_len]));
+    const block = func.air.unwrapDbgBlock(inst);
+    try func.lowerBlock(inst, block.body);
 }
 
 fn airDbgVar(func: *Func, inst: Air.Inst.Index) InnerError!void {
@@ -5271,19 +5268,18 @@ fn genVarDbgInfo(
 }
 
 fn airCondBr(func: *Func, inst: Air.Inst.Index) !void {
-    const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const cond = try func.resolveInst(pl_op.operand);
-    const cond_ty = func.typeOf(pl_op.operand);
-    const extra = func.air.extraData(Air.CondBr, pl_op.payload);
-    const then_body: []const Air.Inst.Index = @ptrCast(func.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-    const else_body: []const Air.Inst.Index = @ptrCast(func.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+    const cond_br = func.air.unwrapCondBr(inst);
+    const cond = try func.resolveInst(cond_br.condition);
+    const cond_ty = func.typeOf(cond_br.condition);
+    const then_body = cond_br.then_body;
+    const else_body = cond_br.else_body;
     const liveness_cond_br = func.liveness.getCondBr(inst);
 
     // If the condition dies here in this condbr instruction, process
     // that death now instead of later as this has an effect on
     // whether it needs to be spilled in the branches
     if (func.liveness.operandDies(inst, 0)) {
-        if (pl_op.operand.toIndex()) |op_inst| try func.processDeath(op_inst);
+        if (cond_br.condition.toIndex()) |op_inst| try func.processDeath(op_inst);
     }
 
     func.scope_generation += 1;
@@ -5633,10 +5629,7 @@ fn airIsNonErrPtr(func: *Func, inst: Air.Inst.Index) !void {
 
 fn airLoop(func: *Func, inst: Air.Inst.Index) !void {
     // A loop is a setup to be able to jump back to the beginning.
-    const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const loop = func.air.extraData(Air.Block, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(func.air.extra.items[loop.end..][0..loop.data.body_len]);
-
+    const body = func.air.unwrapBlock(inst);
     func.scope_generation += 1;
     const state = try func.saveState();
 
@@ -5646,7 +5639,7 @@ fn airLoop(func: *Func, inst: Air.Inst.Index) !void {
     });
     defer assert(func.loops.remove(inst));
 
-    try func.genBody(body);
+    try func.genBody(body.body);
 
     func.finishAirBookkeeping();
 }
@@ -5663,9 +5656,8 @@ fn jump(func: *Func, index: Mir.Inst.Index) !Mir.Inst.Index {
 }
 
 fn airBlock(func: *Func, inst: Air.Inst.Index) !void {
-    const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = func.air.extraData(Air.Block, ty_pl.payload);
-    try func.lowerBlock(inst, @ptrCast(func.air.extra.items[extra.end..][0..extra.data.body_len]));
+    const block = func.air.unwrapBlock(inst);
+    try func.lowerBlock(inst, block.body);
 }
 
 fn lowerBlock(func: *Func, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
@@ -6053,15 +6045,9 @@ fn airBoolOp(func: *Func, inst: Air.Inst.Index) !void {
 }
 
 fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
-    const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = func.air.extraData(Air.Asm, ty_pl.payload);
-    const outputs_len = extra.data.flags.outputs_len;
-    var extra_i: usize = extra.end;
-    const outputs: []const Air.Inst.Ref =
-        @ptrCast(func.air.extra.items[extra_i..][0..outputs_len]);
-    extra_i += outputs.len;
-    const inputs: []const Air.Inst.Ref = @ptrCast(func.air.extra.items[extra_i..][0..extra.data.inputs_len]);
-    extra_i += inputs.len;
+    const unwrapped_asm = func.air.unwrapAsm(inst);
+    const outputs = unwrapped_asm.outputs;
+    const inputs = unwrapped_asm.inputs;
 
     var result: MCValue = .none;
     var args = std.array_list.Managed(MCValue).init(func.gpa);
@@ -6076,19 +6062,15 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
     try arg_map.ensureTotalCapacity(@intCast(outputs.len + inputs.len));
     defer arg_map.deinit();
 
-    var outputs_extra_i = extra_i;
-    for (outputs) |output| {
-        const extra_bytes = mem.sliceAsBytes(func.air.extra.items[extra_i..]);
-        const constraint = mem.sliceTo(mem.sliceAsBytes(func.air.extra.items[extra_i..]), 0);
-        const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+    var it = unwrapped_asm.iterateOutputs();
+    while (it.next()) |output| {
+        const constraint = output.constraint;
+        const name = output.name;
 
         const is_read = switch (constraint[0]) {
             '=' => false,
             '+' => read: {
-                if (output == .none) return func.fail(
+                if (output.operand == .none) return func.fail(
                     "read-write constraint unsupported for asm result: '{s}'",
                     .{constraint},
                 );
@@ -6100,7 +6082,7 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
         const rest = constraint[@as(usize, 1) + @intFromBool(is_early_clobber) ..];
         const arg_mcv: MCValue = arg_mcv: {
             const arg_maybe_reg: ?Register = if (mem.eql(u8, rest, "m"))
-                if (output != .none) null else return func.fail(
+                if (output.operand != .none) null else return func.fail(
                     "memory constraint unsupported for asm result: '{s}'",
                     .{constraint},
                 )
@@ -6115,7 +6097,7 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
                 break :arg_mcv args.items[index];
             } else return func.fail("invalid constraint: '{s}'", .{constraint});
             break :arg_mcv if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
-                const ptr_mcv = try func.resolveInst(output);
+                const ptr_mcv = try func.resolveInst(output.operand);
                 switch (ptr_mcv) {
                     .immediate => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |_|
                         break :arg ptr_mcv.deref(),
@@ -6131,20 +6113,17 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
         if (!mem.eql(u8, name, "_"))
             arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
         args.appendAssumeCapacity(arg_mcv);
-        if (output == .none) result = arg_mcv;
-        if (is_read) try func.load(arg_mcv, .{ .air_ref = output }, func.typeOf(output));
+        if (output.operand == .none) result = arg_mcv;
+        if (is_read) try func.load(arg_mcv, .{ .air_ref = output.operand }, func.typeOf(output.operand));
     }
 
-    for (inputs) |input| {
-        const input_bytes = mem.sliceAsBytes(func.air.extra.items[extra_i..]);
-        const constraint = mem.sliceTo(input_bytes, 0);
-        const name = mem.sliceTo(input_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+    it = unwrapped_asm.iterateInputs();
+    while (it.next()) |input| {
+        const constraint = input.constraint;
+        const name = input.name;
 
-        const ty = func.typeOf(input);
-        const input_mcv = try func.resolveInst(input);
+        const ty = func.typeOf(input.operand);
+        const input_mcv = try func.resolveInst(input.operand);
         const arg_mcv: MCValue = if (mem.eql(u8, constraint, "X"))
             input_mcv
         else if (mem.startsWith(u8, constraint, "{") and mem.endsWith(u8, constraint, "}")) arg: {
@@ -6171,7 +6150,7 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
 
     const zcu = func.pt.zcu;
     const ip = &zcu.intern_pool;
-    const aggregate = ip.indexToKey(extra.data.clobbers).aggregate;
+    const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
     const struct_type: Type = .fromInterned(aggregate.ty);
     switch (aggregate.storage) {
         .elems => |elems| for (elems, 0..) |elem, i| {
@@ -6231,7 +6210,7 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
         labels.deinit(func.gpa);
     }
 
-    const asm_source = std.mem.sliceAsBytes(func.air.extra.items[extra_i..])[0..extra.data.source_len];
+    const asm_source = unwrapped_asm.source;
     var line_it = mem.tokenizeAny(u8, asm_source, "\n\r;");
     next_line: while (line_it.next()) |line| {
         var mnem_it = mem.tokenizeAny(u8, line, " \t");
@@ -6499,19 +6478,14 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
     while (label_it.next()) |label| if (label.value_ptr.pending_relocs.items.len > 0)
         return func.fail("undefined label: '{s}'", .{label.key_ptr.*});
 
-    for (outputs, args.items[0..outputs.len]) |output, arg_mcv| {
-        const extra_bytes = mem.sliceAsBytes(func.air.extra.items[outputs_extra_i..]);
-        const constraint =
-            mem.sliceTo(mem.sliceAsBytes(func.air.extra.items[outputs_extra_i..]), 0);
-        const name = mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        outputs_extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+    it = unwrapped_asm.iterateOutputs();
+    while (it.next()) |output| {
+        const constraint = output.constraint;
 
-        if (output == .none) continue;
-        if (arg_mcv != .register) continue;
+        if (output.operand == .none) continue;
+        if (args.items[output.index] != .register) continue;
         if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) continue;
-        try func.store(.{ .air_ref = output }, arg_mcv, func.typeOf(output));
+        try func.store(.{ .air_ref = output.operand }, args.items[output.index], func.typeOf(output.operand));
     }
 
     simple: {
diff --git a/src/codegen/sparc64/CodeGen.zig b/src/codegen/sparc64/CodeGen.zig
index b3416dcedfd7a3f0b9f1c9cb5a80e5e26f387d69..a246df12c59f3277001ba28fd671b6c42fe769e7 100644
--- a/src/codegen/sparc64/CodeGen.zig
+++ b/src/codegen/sparc64/CodeGen.zig
@@ -877,15 +877,10 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.Asm, ty_pl.payload);
-    const is_volatile = extra.data.flags.is_volatile;
-    const outputs_len = extra.data.flags.outputs_len;
-    var extra_i: usize = extra.end;
-    const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i .. extra_i + outputs_len]);
-    extra_i += outputs.len;
-    const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i .. extra_i + extra.data.inputs_len]);
-    extra_i += inputs.len;
+    const unwrapped_asm = self.air.unwrapAsm(inst);
+    const is_volatile = unwrapped_asm.is_volatile;
+    const outputs = unwrapped_asm.outputs;
+    const inputs = unwrapped_asm.inputs;
 
     const dead = !is_volatile and self.liveness.isUnused(inst);
     const result: MCValue = if (dead) .dead else result: {
@@ -893,27 +888,18 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
             return self.fail("TODO implement codegen for asm with more than 1 output", .{});
         }
 
-        const output_constraint: ?[]const u8 = for (outputs) |output| {
-            if (output != .none) {
+        var it = unwrapped_asm.iterateOutputs();
+        const output_constraint: ?[]const u8 = while (it.next()) |output| {
+            if (output.operand != .none) {
                 return self.fail("TODO implement codegen for non-expr asm", .{});
             }
-            const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
-            const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[extra_i..]), 0);
-            const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
 
-            break constraint;
+            break output.constraint;
         } else null;
 
-        for (inputs) |input| {
-            const input_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
-            const constraint = std.mem.sliceTo(input_bytes, 0);
-            const name = std.mem.sliceTo(input_bytes[constraint.len + 1 ..], 0);
-            // This equation accounts for the fact that even if we have exactly 4 bytes
-            // for the string, we still use the next u32 for the null terminator.
-            extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+        it = unwrapped_asm.iterateInputs();
+        while (it.next()) |input| {
+            const constraint = input.constraint;
 
             if (constraint.len < 3 or constraint[0] != '{' or constraint[constraint.len - 1] != '}') {
                 return self.fail("unrecognized asm input constraint: '{s}'", .{constraint});
@@ -922,15 +908,15 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
             const reg = parseRegName(reg_name) orelse
                 return self.fail("unrecognized register: '{s}'", .{reg_name});
 
-            const arg_mcv = try self.resolveInst(input);
+            const arg_mcv = try self.resolveInst(input.operand);
             try self.register_manager.getReg(reg, null);
-            try self.genSetReg(self.typeOf(input), reg, arg_mcv);
+            try self.genSetReg(self.typeOf(input.operand), reg, arg_mcv);
         }
 
         // TODO honor the clobbers
-        _ = extra.data.clobbers;
+        _ = unwrapped_asm.clobbers;
 
-        const asm_source = std.mem.sliceAsBytes(self.air.extra.items[extra_i..])[0..extra.data.source_len];
+        const asm_source = unwrapped_asm.source;
 
         if (mem.eql(u8, asm_source, "ta 0x6d")) {
             _ = try self.addInst(.{
@@ -1109,9 +1095,8 @@ fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.Block, ty_pl.payload);
-    try self.lowerBlock(inst, @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]));
+    const block = self.air.unwrapBlock(inst);
+    try self.lowerBlock(inst, block.body);
 }
 
 fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
@@ -1276,11 +1261,9 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
 fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
     if (modifier == .always_tail) return self.fail("TODO implement tail calls for {}", .{self.target.cpu.arch});
 
-    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const callee = pl_op.operand;
-    const extra = self.air.extraData(Air.Call, pl_op.payload);
-    const args: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra.end .. extra.end + extra.data.args_len]);
-    const ty = self.typeOf(callee);
+    const call = self.air.unwrapCall(inst);
+    const args = call.args;
+    const ty = self.typeOf(call.callee);
     const pt = self.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -1327,7 +1310,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
 
     // Due to incremental compilation, how function calls are generated depends
     // on linking.
-    if (try self.air.value(callee, pt)) |func_value| switch (ip.indexToKey(func_value.toIntern())) {
+    if (try self.air.value(call.callee, pt)) |func_value| switch (ip.indexToKey(func_value.toIntern())) {
         .func => {
             return self.fail("TODO implement calling functions", .{});
         },
@@ -1339,7 +1322,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
         },
     } else {
         assert(ty.zigTypeTag(zcu) == .pointer);
-        const mcv = try self.resolveInst(callee);
+        const mcv = try self.resolveInst(call.callee);
         try self.genSetReg(ty, .o7, mcv);
 
         _ = try self.addInst(.{
@@ -1365,13 +1348,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
 
     if (args.len + 1 <= Air.Liveness.bpi - 1) {
         var buf = [1]Air.Inst.Ref{.none} ** (Air.Liveness.bpi - 1);
-        buf[0] = callee;
+        buf[0] = call.callee;
         @memcpy(buf[1..][0..args.len], args);
         return self.finishAir(inst, result, buf);
     }
 
     var bt = try self.iterateBigTomb(inst, 1 + args.len);
-    bt.feed(callee);
+    bt.feed(call.callee);
     for (args) |arg| {
         bt.feed(arg);
     }
@@ -1451,9 +1434,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.Block, ty_pl.payload);
-    _ = extra;
+    _ = inst;
 
     return self.fail("TODO implement airCmpxchg for {}", .{
         self.target.cpu.arch,
@@ -1461,11 +1442,10 @@ fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
-    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const condition = try self.resolveInst(pl_op.operand);
-    const extra = self.air.extraData(Air.CondBr, pl_op.payload);
-    const then_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-    const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+    const cond_br = self.air.unwrapCondBr(inst);
+    const condition = try self.resolveInst(cond_br.condition);
+    const then_body = cond_br.then_body;
+    const else_body = cond_br.else_body;
     const liveness_condbr = self.liveness.getCondBr(inst);
 
     // Here we emit a branch to the false section.
@@ -1475,7 +1455,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     // that death now instead of later as this has an effect on
     // whether it needs to be spilled in the branches
     if (self.liveness.operandDies(inst, 0)) {
-        if (pl_op.operand.toIndex()) |op_index| {
+        if (cond_br.condition.toIndex()) |op_index| {
             self.processDeath(op_index);
         }
     }
@@ -1613,10 +1593,9 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
+    const block = self.air.unwrapDbgBlock(inst);
     // TODO emit debug info for function change
-    try self.lowerBlock(inst, @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]));
+    try self.lowerBlock(inst, block.body);
 }
 
 fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
@@ -1780,12 +1759,10 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
 
 fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
     // A loop is a setup to be able to jump back to the beginning.
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const loop = self.air.extraData(Air.Block, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[loop.end .. loop.end + loop.data.body_len]);
+    const block = self.air.unwrapBlock(inst);
     const start: u32 = @intCast(self.mir_instructions.len);
 
-    try self.genBody(body);
+    try self.genBody(block.body);
     try self.jump(start);
 
     return self.finishAirBookkeeping();
@@ -2606,12 +2583,11 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airTry(self: *Self, inst: Air.Inst.Index) !void {
-    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = self.air.extraData(Air.Try, pl_op.payload);
-    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
+    const unwrapped_try = self.air.unwrapTry(inst);
+    const body = unwrapped_try.else_body;
     const result: MCValue = result: {
-        const error_union_ty = self.typeOf(pl_op.operand);
-        const error_union = try self.resolveInst(pl_op.operand);
+        const error_union_ty = self.air.typeOf(unwrapped_try.error_union, &self.pt.zcu.intern_pool);
+        const error_union = try self.resolveInst(unwrapped_try.error_union);
         const is_err_result = try self.isErr(error_union_ty, error_union);
         const reloc = try self.condBr(is_err_result);
 
@@ -2620,7 +2596,7 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
         try self.performReloc(reloc);
         break :result try self.errUnionPayload(error_union, error_union_ty);
     };
-    return self.finishAir(inst, result, .{ pl_op.operand, .none, .none });
+    return self.finishAir(inst, result, .{ unwrapped_try.error_union, .none, .none });
 }
 
 fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index d4227ddff6acb6acd3fa72bdfd22f7bacba07d64..f7212b6e1b1f449368872d27aa3688f12b891aa9 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -5002,9 +5002,8 @@ fn genStructuredBody(
 }
 
 fn airBlock(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
-    const inst_datas = cg.air.instructions.items(.data);
-    const extra = cg.air.extraData(Air.Block, inst_datas[@intFromEnum(inst)].ty_pl.payload);
-    return cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]));
+    const block = cg.air.unwrapBlock(inst);
+    return cg.lowerBlock(inst, block.body);
 }
 
 fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !?Id {
@@ -5188,11 +5187,10 @@ fn airBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
 
 fn airCondBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
     const gpa = cg.module.gpa;
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const cond_br = cg.air.extraData(Air.CondBr, pl_op.payload);
-    const then_body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[cond_br.end..][0..cond_br.data.then_body_len]);
-    const else_body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[cond_br.end + then_body.len ..][0..cond_br.data.else_body_len]);
-    const condition_id = try cg.resolve(pl_op.operand);
+    const cond_br = cg.air.unwrapCondBr(inst);
+    const then_body = cond_br.then_body;
+    const else_body = cond_br.else_body;
+    const condition_id = try cg.resolve(cond_br.condition);
 
     const then_label = cg.module.allocId();
     const else_label = cg.module.allocId();
@@ -5251,9 +5249,7 @@ fn airCondBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
 
 fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) !void {
     const gpa = cg.module.gpa;
-    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const loop = cg.air.extraData(Air.Block, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[loop.end..][0..loop.data.body_len]);
+    const block = cg.air.unwrapBlock(inst);
 
     const body_label = cg.module.allocId();
 
@@ -5284,7 +5280,7 @@ fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) !void {
             const next_block = try cg.genStructuredBody(.{ .loop = .{
                 .merge_label = merge_label,
                 .continue_label = continue_label,
-            } }, body);
+            } }, block.body);
             try cg.structuredBreak(next_block);
 
             try cg.beginSpvBlock(continue_label);
@@ -5294,7 +5290,7 @@ fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) !void {
         .unstructured => {
             try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label });
             try cg.beginSpvBlock(body_label);
-            try cg.genBody(body);
+            try cg.genBody(block.body);
 
             try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label });
         },
@@ -5375,12 +5371,11 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) !void {
 fn airTry(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const gpa = cg.module.gpa;
     const zcu = cg.module.zcu;
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const err_union_id = try cg.resolve(pl_op.operand);
-    const extra = cg.air.extraData(Air.Try, pl_op.payload);
-    const body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]);
+    const unwrapped_try = cg.air.unwrapTry(inst);
+    const body = unwrapped_try.else_body;
 
-    const err_union_ty = cg.typeOf(pl_op.operand);
+    const err_union_id = try cg.resolve(unwrapped_try.error_union);
+    const err_union_ty = cg.air.typeOf(unwrapped_try.error_union, &zcu.intern_pool);
     const payload_ty = cg.typeOfIndex(inst);
 
     const bool_ty_id = try cg.resolveType(.bool, .direct);
@@ -5882,12 +5877,11 @@ fn airDbgStmt(cg: *CodeGen, inst: Air.Inst.Index) !void {
 
 fn airDbgInlineBlock(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const zcu = cg.module.zcu;
-    const inst_datas = cg.air.instructions.items(.data);
-    const extra = cg.air.extraData(Air.DbgInlineBlock, inst_datas[@intFromEnum(inst)].ty_pl.payload);
+    const block = cg.air.unwrapDbgBlock(inst);
     const old_base_line = cg.base_line;
     defer cg.base_line = old_base_line;
-    cg.base_line = zcu.navSrcLine(zcu.funcInfo(extra.data.func).owner_nav);
-    return cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]));
+    cg.base_line = zcu.navSrcLine(zcu.funcInfo(block.func).owner_nav);
+    return cg.lowerBlock(inst, block.body);
 }
 
 fn airDbgVar(cg: *CodeGen, inst: Air.Inst.Index) !void {
@@ -5900,52 +5894,34 @@ fn airDbgVar(cg: *CodeGen, inst: Air.Inst.Index) !void {
 fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const gpa = cg.module.gpa;
     const zcu = cg.module.zcu;
-    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = cg.air.extraData(Air.Asm, ty_pl.payload);
+    const unwrapped_asm = cg.air.unwrapAsm(inst);
 
-    const is_volatile = extra.data.flags.is_volatile;
-    const outputs_len = extra.data.flags.outputs_len;
+    const is_volatile = unwrapped_asm.is_volatile;
+    const outputs_len = unwrapped_asm.outputs.len;
 
     if (!is_volatile and cg.liveness.isUnused(inst)) return null;
 
-    var extra_i: usize = extra.end;
-    const outputs: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[extra_i..][0..outputs_len]);
-    extra_i += outputs.len;
-    const inputs: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[extra_i..][0..extra.data.inputs_len]);
-    extra_i += inputs.len;
-
-    if (outputs.len > 1) {
+    if (outputs_len > 1) {
         return cg.todo("implement inline asm with more than 1 output", .{});
     }
 
     var ass: Assembler = .{ .cg = cg };
     defer ass.deinit();
 
-    var output_extra_i = extra_i;
-    for (outputs) |output| {
-        if (output != .none) {
+    var it = unwrapped_asm.iterateOutputs();
+    while (it.next()) |out| {
+        if (out.operand != .none) {
             return cg.todo("implement inline asm with non-returned output", .{});
         }
-        const extra_bytes = std.mem.sliceAsBytes(cg.air.extra.items[extra_i..]);
-        const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(cg.air.extra.items[extra_i..]), 0);
-        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-        // TODO: Record output and use it somewhere.
     }
 
-    for (inputs) |input| {
-        const extra_bytes = std.mem.sliceAsBytes(cg.air.extra.items[extra_i..]);
-        const constraint = std.mem.sliceTo(extra_bytes, 0);
-        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        extra_i += (constraint.len + name.len + (2 + 3)) / 4;
+    it = unwrapped_asm.iterateInputs();
+    while (it.next()) |in| {
+        const input_ty = cg.typeOf(in.operand);
 
-        const input_ty = cg.typeOf(input);
-
-        if (std.mem.eql(u8, constraint, "c")) {
+        if (std.mem.eql(u8, in.constraint, "c")) {
             // constant
-            const val = (try cg.air.value(input, cg.pt)) orelse {
+            const val = (try cg.air.value(in.operand, cg.pt)) orelse {
                 return cg.fail("assembly inputs with 'c' constraint have to be compile-time known", .{});
             };
 
@@ -5971,37 +5947,36 @@ fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
 
                 .undef => return cg.fail("assembly input with 'c' constraint cannot be undefined", .{}),
 
-                .int => try ass.value_map.put(gpa, name, .{ .constant = @intCast(val.toUnsignedInt(zcu)) }),
-                .enum_literal => |str| try ass.value_map.put(gpa, name, .{ .string = str.toSlice(ip) }),
+                .int => try ass.value_map.put(gpa, in.name, .{ .constant = @intCast(val.toUnsignedInt(zcu)) }),
+                .enum_literal => |str| try ass.value_map.put(gpa, in.name, .{ .string = str.toSlice(ip) }),
 
                 else => unreachable, // TODO
             }
-        } else if (std.mem.eql(u8, constraint, "t")) {
+        } else if (std.mem.eql(u8, in.constraint, "t")) {
             // type
             if (input_ty.zigTypeTag(zcu) == .type) {
                 // This assembly input is a type instead of a value.
                 // That's fine for now, just make sure to resolve it as such.
-                const val = (try cg.air.value(input, cg.pt)).?;
+                const val = (try cg.air.value(in.operand, cg.pt)).?;
                 const ty_id = try cg.resolveType(val.toType(), .direct);
-                try ass.value_map.put(gpa, name, .{ .ty = ty_id });
+                try ass.value_map.put(gpa, in.name, .{ .ty = ty_id });
             } else {
                 const ty_id = try cg.resolveType(input_ty, .direct);
-                try ass.value_map.put(gpa, name, .{ .ty = ty_id });
+                try ass.value_map.put(gpa, in.name, .{ .ty = ty_id });
             }
         } else {
             if (input_ty.zigTypeTag(zcu) == .type) {
                 return cg.fail("use the 't' constraint to supply types to SPIR-V inline assembly", .{});
             }
 
-            const val_id = try cg.resolve(input);
-            try ass.value_map.put(gpa, name, .{ .value = val_id });
+            const val_id = try cg.resolve(in.operand);
+            try ass.value_map.put(gpa, in.name, .{ .value = val_id });
         }
     }
-
     // TODO: do something with clobbers
-    _ = extra.data.clobbers;
+    _ = unwrapped_asm.clobbers;
 
-    const asm_source = std.mem.sliceAsBytes(cg.air.extra.items[extra_i..])[0..extra.data.source_len];
+    const asm_source = unwrapped_asm.source;
 
     ass.assemble(asm_source) catch |err| switch (err) {
         error.AssembleFail => {
@@ -6033,26 +6008,20 @@ fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
         else => |others| return others,
     };
 
-    for (outputs) |output| {
-        _ = output;
-        const extra_bytes = std.mem.sliceAsBytes(cg.air.extra.items[output_extra_i..]);
-        const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(cg.air.extra.items[output_extra_i..]), 0);
-        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        output_extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-
-        const result = ass.value_map.get(name) orelse return {
-            return cg.fail("invalid asm output '{s}'", .{name});
+    it = unwrapped_asm.iterateOutputs();
+    while (it.next()) |out| {
+        const result = ass.value_map.get(out.name) orelse return {
+            return cg.fail("invalid asm output '{s}'", .{out.name});
         };
-
         switch (result) {
             .just_declared, .unresolved_forward_reference => unreachable,
             .ty => return cg.fail("cannot return spir-v type as value from assembly", .{}),
             .value => |ref| return ref,
             .constant, .string => return cg.fail("cannot return constant from assembly", .{}),
         }
-
         // TODO: Multiple results
         // TODO: Check that the output type from assembly is the same as the type actually expected by Zig.
+
     }
 
     return null;
@@ -6063,10 +6032,9 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
 
     const gpa = cg.module.gpa;
     const zcu = cg.module.zcu;
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = cg.air.extraData(Air.Call, pl_op.payload);
-    const args: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.args_len]);
-    const callee_ty = cg.typeOf(pl_op.operand);
+    const air_call = cg.air.unwrapCall(inst);
+    const args = air_call.args;
+    const callee_ty = cg.typeOf(air_call.callee);
     const zig_fn_ty = switch (callee_ty.zigTypeTag(zcu)) {
         .@"fn" => callee_ty,
         .pointer => return cg.fail("cannot call function pointers", .{}),
@@ -6077,7 +6045,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
 
     const result_type_id = try cg.resolveFnReturnType(.fromInterned(return_type));
     const result_id = cg.module.allocId();
-    const callee_id = try cg.resolve(pl_op.operand);
+    const callee_id = try cg.resolve(air_call.callee);
 
     comptime assert(zig_call_abi_ver == 3);
 
diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig
index b6f8145875b6abe0f63dee3eecf0d791295ba3fc..90de3461cacbfdb90b07a3f2898598ed27be9ac7 100644
--- a/src/codegen/wasm/CodeGen.zig
+++ b/src/codegen/wasm/CodeGen.zig
@@ -2137,10 +2137,9 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 
 fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) InnerError!void {
     if (modifier == .always_tail) return cg.fail("TODO implement tail calls for wasm", .{});
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = cg.air.extraData(Air.Call, pl_op.payload);
-    const args: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.args_len]);
-    const ty = cg.typeOf(pl_op.operand);
+    const call = cg.air.unwrapCall(inst);
+    const args = call.args;
+    const ty = cg.typeOf(call.callee);
 
     const pt = cg.pt;
     const zcu = pt.zcu;
@@ -2155,7 +2154,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
     const first_param_sret = firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), zcu, cg.target);
 
     const callee: ?InternPool.Nav.Index = blk: {
-        const func_val = (try cg.air.value(pl_op.operand, pt)) orelse break :blk null;
+        const func_val = (try cg.air.value(call.callee, pt)) orelse break :blk null;
 
         switch (ip.indexToKey(func_val.toIntern())) {
             inline .func, .@"extern" => |x| break :blk x.owner_nav,
@@ -2189,7 +2188,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
         // in this case we call a function pointer
         // so load its value onto the stack
         assert(ty.zigTypeTag(zcu) == .pointer);
-        const operand = try cg.resolveInst(pl_op.operand);
+        const operand = try cg.resolveInst(call.callee);
         try cg.emitWValue(operand);
 
         try cg.mir_func_tys.put(cg.gpa, fn_ty.toIntern(), {});
@@ -2233,7 +2232,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
     };
 
     var bt = try cg.iterateBigTomb(inst, 1 + args.len);
-    bt.feed(pl_op.operand);
+    bt.feed(call.callee);
     for (args) |arg| bt.feed(arg);
     return bt.finishAir(result_value);
 }
@@ -3335,9 +3334,8 @@ fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue {
 }
 
 fn airBlock(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = cg.air.extraData(Air.Block, ty_pl.payload);
-    try cg.lowerBlock(inst, ty_pl.ty.toType(), @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]));
+    const block = cg.air.unwrapBlock(inst);
+    try cg.lowerBlock(inst, block.ty, block.body);
 }
 
 fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, block_ty: Type, body: []const Air.Inst.Index) InnerError!void {
@@ -3381,9 +3379,7 @@ fn endBlock(cg: *CodeGen) !void {
 }
 
 fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const loop = cg.air.extraData(Air.Block, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[loop.end..][0..loop.data.body_len]);
+    const block = cg.air.unwrapBlock(inst);
 
     // result type of loop is always 'noreturn', meaning we can always
     // emit the wasm type 'block_empty'.
@@ -3392,18 +3388,17 @@ fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     try cg.loops.putNoClobber(cg.gpa, inst, cg.block_depth);
     defer assert(cg.loops.remove(inst));
 
-    try cg.genBody(body);
+    try cg.genBody(block.body);
     try cg.endBlock();
 
     return cg.finishAir(inst, .none, &.{});
 }
 
 fn airCondBr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const condition = try cg.resolveInst(pl_op.operand);
-    const extra = cg.air.extraData(Air.CondBr, pl_op.payload);
-    const then_body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-    const else_body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+    const cond_br = cg.air.unwrapCondBr(inst);
+    const condition = try cg.resolveInst(cond_br.condition);
+    const then_body = cond_br.then_body;
+    const else_body = cond_br.else_body;
     const liveness_condbr = cg.liveness.getCondBr(inst);
 
     // result type is always noreturn, so use `block_empty` as type.
@@ -6423,10 +6418,9 @@ fn airDbgStmt(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 
 fn airDbgInlineBlock(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
+    const block = cg.air.unwrapDbgBlock(inst);
     // TODO
-    try cg.lowerBlock(inst, ty_pl.ty.toType(), @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]));
+    try cg.lowerBlock(inst, block.ty, block.body);
 }
 
 fn airDbgVar(
@@ -6441,24 +6435,22 @@ fn airDbgVar(
 }
 
 fn airTry(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const err_union = try cg.resolveInst(pl_op.operand);
-    const extra = cg.air.extraData(Air.Try, pl_op.payload);
-    const body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const err_union_ty = cg.typeOf(pl_op.operand);
+    const unwrapped_try = cg.air.unwrapTry(inst);
+    const body = unwrapped_try.else_body;
+    const err_union = try cg.resolveInst(unwrapped_try.error_union);
+    const err_union_ty = cg.typeOf(unwrapped_try.error_union);
     const result = try lowerTry(cg, inst, err_union, body, err_union_ty, false);
-    return cg.finishAir(inst, result, &.{pl_op.operand});
+    return cg.finishAir(inst, result, &.{unwrapped_try.error_union});
 }
 
 fn airTryPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const zcu = cg.pt.zcu;
-    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = cg.air.extraData(Air.TryPtr, ty_pl.payload);
-    const err_union_ptr = try cg.resolveInst(extra.data.ptr);
-    const body: []const Air.Inst.Index = @ptrCast(cg.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const err_union_ty = cg.typeOf(extra.data.ptr).childType(zcu);
+    const unwrapped_try = cg.air.unwrapTryPtr(inst);
+    const err_union_ptr = try cg.resolveInst(unwrapped_try.error_union_ptr);
+    const body = unwrapped_try.else_body;
+    const err_union_ty = cg.typeOf(unwrapped_try.error_union_ptr).childType(zcu);
     const result = try lowerTry(cg, inst, err_union_ptr, body, err_union_ty, true);
-    return cg.finishAir(inst, result, &.{extra.data.ptr});
+    return cg.finishAir(inst, result, &.{unwrapped_try.error_union_ptr});
 }
 
 fn lowerTry(
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 382c9e9c3cb1ff24aa64abe5572cd12779dcca00..7da423f4299b1d791ed32d39eca8b28ab2874d7f 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -67348,21 +67348,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             },
             .bitcast => try cg.airBitCast(inst),
             .block => {
-                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
-                const block = cg.air.extraData(Air.Block, ty_pl.payload);
+                const block = cg.air.unwrapBlock(inst);
                 if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_enter_block_none);
-                try cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[block.end..][0..block.data.body_len]));
+                try cg.lowerBlock(inst, block.body);
                 if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_leave_block_none);
             },
             .loop => {
-                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
-                const block = cg.air.extraData(Air.Block, ty_pl.payload);
+                const block = cg.air.unwrapBlock(inst);
                 try cg.loops.putNoClobber(cg.gpa, inst, .{
                     .state = try cg.saveState(),
                     .target = @intCast(cg.mir_instructions.len),
                 });
                 defer assert(cg.loops.remove(inst));
-                try cg.genBodyBlock(@ptrCast(cg.air.extra.items[block.end..][0..block.data.body_len]));
+                try cg.genBodyBlock(block.body);
             },
             .repeat => {
                 const repeat = air_datas[@intFromEnum(inst)].repeat;
@@ -89048,17 +89046,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try cg.asmOpOnly(.{ ._, .nop });
             },
             .dbg_inline_block => {
-                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
-                const dbg_inline_block = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
+                const dbg_inline_block = cg.air.unwrapDbgBlock(inst);
                 const old_inline_func = cg.inline_func;
                 defer cg.inline_func = old_inline_func;
-                cg.inline_func = dbg_inline_block.data.func;
+                cg.inline_func = dbg_inline_block.func;
                 if (!cg.mod.strip) _ = try cg.addInst(.{
                     .tag = .pseudo,
                     .ops = .pseudo_dbg_enter_inline_func,
-                    .data = .{ .ip_index = dbg_inline_block.data.func },
+                    .data = .{ .ip_index = dbg_inline_block.func },
                 });
-                try cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[dbg_inline_block.end..][0..dbg_inline_block.data.body_len]));
+                try cg.lowerBlock(inst, dbg_inline_block.body);
                 if (!cg.mod.strip) _ = try cg.addInst(.{
                     .tag = .pseudo,
                     .ops = .pseudo_dbg_leave_inline_func,
@@ -175916,10 +175913,8 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue
 fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier, opts: CopyOptions) !void {
     if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});
 
-    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = self.air.extraData(Air.Call, pl_op.payload);
-    const arg_refs: []const Air.Inst.Ref =
-        @ptrCast(self.air.extra.items[extra.end..][0..extra.data.args_len]);
+    const call = self.air.unwrapCall(inst);
+    const arg_refs = call.args;
 
     const ExpectedContents = extern struct {
         tys: [32][@sizeOf(Type)]u8 align(@alignOf(Type)),
@@ -175937,10 +175932,10 @@ fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
     defer allocator.free(arg_vals);
     for (arg_vals, arg_refs) |*arg_val, arg_ref| arg_val.* = .{ .air_ref = arg_ref };
 
-    const ret = try self.genCall(.{ .air = pl_op.operand }, arg_tys, arg_vals, opts);
+    const ret = try self.genCall(.{ .air = call.callee }, arg_tys, arg_vals, opts);
 
     var bt = self.liveness.iterateBigTomb(inst);
-    try self.feed(&bt, pl_op.operand);
+    try self.feed(&bt, call.callee);
     for (arg_refs) |arg_ref| try self.feed(&bt, arg_ref);
 
     const result = if (self.liveness.isUnused(inst)) .unreach else ret;
@@ -176300,20 +176295,18 @@ fn airRetLoad(self: *CodeGen, inst: Air.Inst.Index) !void {
 }
 
 fn airTry(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const extra = self.air.extraData(Air.Try, pl_op.payload);
-    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const operand_ty = self.typeOf(pl_op.operand);
-    const result = try self.genTry(inst, pl_op.operand, body, operand_ty, false);
+    const unwrapped_try = self.air.unwrapTry(inst);
+    const body = unwrapped_try.else_body;
+    const operand_ty = self.typeOf(unwrapped_try.error_union);
+    const result = try self.genTry(inst, unwrapped_try.error_union, body, operand_ty, false);
     return self.finishAir(inst, result, .{ .none, .none, .none });
 }
 
 fn airTryPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
-    const operand_ty = self.typeOf(extra.data.ptr);
-    const result = try self.genTry(inst, extra.data.ptr, body, operand_ty, true);
+    const unwrapped_try = self.air.unwrapTryPtr(inst);
+    const body = unwrapped_try.else_body;
+    const operand_ty = self.typeOf(unwrapped_try.error_union_ptr);
+    const result = try self.genTry(inst, unwrapped_try.error_union_ptr, body, operand_ty, true);
     return self.finishAir(inst, result, .{ .none, .none, .none });
 }
 
@@ -176391,21 +176384,20 @@ fn genCondBrMir(self: *CodeGen, ty: Type, mcv: MCValue) !Mir.Inst.Index {
 }
 
 fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const cond = try self.resolveInst(pl_op.operand);
-    const cond_ty = self.typeOf(pl_op.operand);
-    const extra = self.air.extraData(Air.CondBr, pl_op.payload);
-    const then_body: []const Air.Inst.Index =
-        @ptrCast(self.air.extra.items[extra.end..][0..extra.data.then_body_len]);
-    const else_body: []const Air.Inst.Index =
-        @ptrCast(self.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
+    const cond_br = self.air.unwrapCondBr(inst);
+    const then_body = cond_br.then_body;
+    const else_body = cond_br.else_body;
+
+    const cond = try self.resolveInst(cond_br.condition);
+    const cond_ty = self.typeOf(cond_br.condition);
+
     const liveness_cond_br = self.liveness.getCondBr(inst);
 
     // If the condition dies here in this condbr instruction, process
     // that death now instead of later as this has an effect on
     // whether it needs to be spilled in the branches
     if (self.liveness.operandDies(inst, 0)) {
-        if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
+        if (cond_br.condition.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
     }
 
     const state = try self.saveState();
@@ -177124,14 +177116,10 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
     @setEvalBranchQuota(1_100);
     const pt = self.pt;
     const zcu = pt.zcu;
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.Asm, ty_pl.payload);
-    const outputs_len = extra.data.flags.outputs_len;
-    var extra_i: usize = extra.end;
-    const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..outputs_len]);
-    extra_i += outputs.len;
-    const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..extra.data.inputs_len]);
-    extra_i += inputs.len;
+    const unwrapped_asm = self.air.unwrapAsm(inst);
+
+    const outputs = unwrapped_asm.outputs;
+    const inputs = unwrapped_asm.inputs;
 
     var result: MCValue = .none;
     var args: std.array_list.Managed(MCValue) = .init(self.gpa);
@@ -177146,36 +177134,29 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
     try arg_map.ensureTotalCapacity(@intCast(outputs.len + inputs.len));
     defer arg_map.deinit();
 
-    var outputs_extra_i = extra_i;
-    for (outputs) |output| {
-        const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
-        const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[extra_i..]), 0);
-        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-
-        const maybe_inst = switch (output) {
+    var it = unwrapped_asm.iterateOutputs();
+    while (it.next()) |out| {
+        const maybe_inst = switch (out.operand) {
             .none => inst,
             else => null,
         };
-        const ty = switch (output) {
+        const ty = switch (out.operand) {
             .none => self.typeOfIndex(inst),
-            else => self.typeOf(output).childType(zcu),
+            else => self.typeOf(out.operand).childType(zcu),
         };
-        const is_read = switch (constraint[0]) {
+        const is_read = switch (out.constraint[0]) {
             '=' => false,
             '+' => read: {
-                if (output == .none) return self.fail(
+                if (out.operand == .none) return self.fail(
                     "read-write constraint unsupported for asm result: '{s}'",
-                    .{constraint},
+                    .{out.constraint},
                 );
                 break :read true;
             },
-            else => return self.fail("invalid constraint: '{s}'", .{constraint}),
+            else => return self.fail("invalid constraint: '{s}'", .{out.constraint}),
         };
-        const is_early_clobber = constraint[1] == '&';
-        const rest = constraint[@as(usize, 1) + @intFromBool(is_early_clobber) ..];
+        const is_early_clobber = out.constraint[1] == '&';
+        const rest = out.constraint[@as(usize, 1) + @intFromBool(is_early_clobber) ..];
         const arg_mcv: MCValue = arg_mcv: {
             const arg_maybe_reg: ?Register = if (std.mem.eql(u8, rest, "r") or
                 std.mem.eql(u8, rest, "f") or std.mem.eql(u8, rest, "x"))
@@ -177189,30 +177170,30 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                     @intCast(ty.abiSize(zcu)),
                 )
             else if (std.mem.eql(u8, rest, "m"))
-                if (output != .none) null else return self.fail(
+                if (out.operand != .none) null else return self.fail(
                     "memory constraint unsupported for asm result: '{s}'",
-                    .{constraint},
+                    .{out.constraint},
                 )
             else if (std.mem.eql(u8, rest, "g") or
                 std.mem.eql(u8, rest, "rm") or std.mem.eql(u8, rest, "mr") or
                 std.mem.eql(u8, rest, "r,m") or std.mem.eql(u8, rest, "m,r"))
                 self.register_manager.tryAllocReg(maybe_inst, abi.RegisterClass.gp) orelse
-                    if (output != .none)
+                    if (out.operand != .none)
                         null
                     else
                         return self.fail("ran out of registers lowering inline asm", .{})
             else if (std.mem.startsWith(u8, rest, "{") and std.mem.endsWith(u8, rest, "}"))
                 parseRegName(rest["{".len .. rest.len - "}".len]) orelse
-                    return self.fail("invalid register constraint: '{s}'", .{constraint})
+                    return self.fail("invalid register constraint: '{s}'", .{out.constraint})
             else if (rest.len == 1 and std.ascii.isDigit(rest[0])) {
                 const index = std.fmt.charToDigit(rest[0], 10) catch unreachable;
                 if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{
-                    constraint,
+                    out.constraint,
                 });
                 break :arg_mcv args.items[index];
-            } else return self.fail("invalid constraint: '{s}'", .{constraint});
+            } else return self.fail("invalid constraint: '{s}'", .{out.constraint});
             break :arg_mcv if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
-                const ptr_mcv = try self.resolveInst(output);
+                const ptr_mcv = try self.resolveInst(out.operand);
                 switch (ptr_mcv) {
                     .immediate => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |_|
                         break :arg ptr_mcv.deref(),
@@ -177223,30 +177204,24 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             };
         };
         if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |tracked_index| {
-            try self.register_manager.getRegIndex(tracked_index, if (output == .none) inst else null);
+            try self.register_manager.getRegIndex(tracked_index, if (out.operand == .none) inst else null);
             _ = self.register_manager.lockRegIndexAssumeUnused(tracked_index);
         };
-        if (!std.mem.eql(u8, name, "_"))
-            arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
+        if (!std.mem.eql(u8, out.name, "_"))
+            arg_map.putAssumeCapacityNoClobber(out.name, @intCast(args.items.len));
         args.appendAssumeCapacity(arg_mcv);
-        if (output == .none) result = arg_mcv;
-        if (is_read) try self.load(arg_mcv, self.typeOf(output), .{ .air_ref = output });
+        if (out.operand == .none) result = arg_mcv;
+        if (is_read) try self.load(arg_mcv, self.typeOf(out.operand), .{ .air_ref = out.operand });
     }
 
-    for (inputs) |input| {
-        const input_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
-        const constraint = std.mem.sliceTo(input_bytes, 0);
-        const name = std.mem.sliceTo(input_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-
-        const ty = self.typeOf(input);
-        const input_mcv = try self.resolveInst(input);
-        const arg_mcv: MCValue = if (std.mem.eql(u8, constraint, "r") or
-            std.mem.eql(u8, constraint, "f") or std.mem.eql(u8, constraint, "x"))
+    it = unwrapped_asm.iterateInputs();
+    while (it.next()) |in| {
+        const ty = self.typeOf(in.operand);
+        const input_mcv = try self.resolveInst(in.operand);
+        const arg_mcv: MCValue = if (std.mem.eql(u8, in.constraint, "r") or
+            std.mem.eql(u8, in.constraint, "f") or std.mem.eql(u8, in.constraint, "x"))
         arg: {
-            const rc = switch (constraint[0]) {
+            const rc = switch (in.constraint[0]) {
                 'r' => abi.RegisterClass.gp,
                 'f' => abi.RegisterClass.x87,
                 'x' => abi.RegisterClass.sse,
@@ -177258,14 +177233,14 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             const reg = try self.register_manager.allocReg(null, rc);
             try self.genSetReg(reg, ty, input_mcv, .{});
             break :arg .{ .register = registerAlias(reg, @intCast(ty.abiSize(zcu))) };
-        } else if (std.mem.eql(u8, constraint, "i") or std.mem.eql(u8, constraint, "n"))
+        } else if (std.mem.eql(u8, in.constraint, "i") or std.mem.eql(u8, in.constraint, "n"))
             switch (input_mcv) {
                 .immediate => |imm| .{ .immediate = imm },
                 else => return self.fail("immediate operand requires comptime value: '{s}'", .{
-                    constraint,
+                    in.constraint,
                 }),
             }
-        else if (std.mem.eql(u8, constraint, "m")) arg: {
+        else if (std.mem.eql(u8, in.constraint, "m")) arg: {
             switch (input_mcv) {
                 .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |_|
                     break :arg input_mcv,
@@ -177284,9 +177259,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             };
             try self.genSetReg(addr_reg, .usize, input_mcv.address(), .{});
             break :arg .{ .indirect = .{ .reg = addr_reg } };
-        } else if (std.mem.eql(u8, constraint, "g") or
-            std.mem.eql(u8, constraint, "rm") or std.mem.eql(u8, constraint, "mr") or
-            std.mem.eql(u8, constraint, "r,m") or std.mem.eql(u8, constraint, "m,r"))
+        } else if (std.mem.eql(u8, in.constraint, "g") or
+            std.mem.eql(u8, in.constraint, "rm") or std.mem.eql(u8, in.constraint, "mr") or
+            std.mem.eql(u8, in.constraint, "r,m") or std.mem.eql(u8, in.constraint, "m,r"))
         arg: {
             switch (input_mcv) {
                 .register, .indirect, .load_frame => break :arg input_mcv,
@@ -177297,30 +177272,30 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             const temp_mcv = try self.allocTempRegOrMem(ty, true);
             try self.genCopy(ty, temp_mcv, input_mcv, .{});
             break :arg temp_mcv;
-        } else if (std.mem.eql(u8, constraint, "X"))
+        } else if (std.mem.eql(u8, in.constraint, "X"))
             input_mcv
-        else if (std.mem.startsWith(u8, constraint, "{") and std.mem.endsWith(u8, constraint, "}")) arg: {
-            const reg = parseRegName(constraint["{".len .. constraint.len - "}".len]) orelse
-                return self.fail("invalid register constraint: '{s}'", .{constraint});
+        else if (std.mem.startsWith(u8, in.constraint, "{") and std.mem.endsWith(u8, in.constraint, "}")) arg: {
+            const reg = parseRegName(in.constraint["{".len .. in.constraint.len - "}".len]) orelse
+                return self.fail("invalid register constraint: '{s}'", .{in.constraint});
             try self.register_manager.getReg(reg, null);
             try self.genSetReg(reg, ty, input_mcv, .{});
             break :arg .{ .register = reg };
-        } else if (constraint.len == 1 and std.ascii.isDigit(constraint[0])) arg: {
-            const index = std.fmt.charToDigit(constraint[0], 10) catch unreachable;
-            if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{constraint});
+        } else if (in.constraint.len == 1 and std.ascii.isDigit(in.constraint[0])) arg: {
+            const index = std.fmt.charToDigit(in.constraint[0], 10) catch unreachable;
+            if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{in.constraint});
             try self.genCopy(ty, args.items[index], input_mcv, .{});
             break :arg args.items[index];
-        } else return self.fail("invalid constraint: '{s}'", .{constraint});
+        } else return self.fail("invalid constraint: '{s}'", .{in.constraint});
         if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| {
             _ = self.register_manager.lockReg(reg);
         };
-        if (!std.mem.eql(u8, name, "_"))
-            arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
+        if (!std.mem.eql(u8, in.name, "_"))
+            arg_map.putAssumeCapacityNoClobber(in.name, @intCast(args.items.len));
         args.appendAssumeCapacity(arg_mcv);
     }
 
     const ip = &zcu.intern_pool;
-    const aggregate = ip.indexToKey(extra.data.clobbers).aggregate;
+    const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
     const struct_type: Type = .fromInterned(aggregate.ty);
     switch (aggregate.storage) {
         .elems => |elems| for (elems, 0..) |elem, i| switch (elem) {
@@ -177390,7 +177365,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
         labels.deinit(self.gpa);
     }
 
-    const asm_source = std.mem.sliceAsBytes(self.air.extra.items[extra_i..])[0..extra.data.source_len];
+    const asm_source = unwrapped_asm.source;
     var line_it = std.mem.tokenizeAny(u8, asm_source, "\n\r;");
     next_line: while (line_it.next()) |line| {
         var mnem_it = std.mem.tokenizeAny(u8, line, " \t");
@@ -177821,19 +177796,13 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
     while (label_it.next()) |label| if (label.value_ptr.pending_relocs.items.len > 0)
         return self.fail("undefined label: '{s}'", .{label.key_ptr.*});
 
-    for (outputs, args.items[0..outputs.len]) |output, arg_mcv| {
-        const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[outputs_extra_i..]);
-        const constraint =
-            std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[outputs_extra_i..]), 0);
-        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
-        // This equation accounts for the fact that even if we have exactly 4 bytes
-        // for the string, we still use the next u32 for the null terminator.
-        outputs_extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-
-        if (output == .none) continue;
+    it = unwrapped_asm.iterateOutputs();
+    while (it.next()) |out| {
+        const arg_mcv = args.items[it.current - 1];
+        if (out.operand == .none) continue;
         if (arg_mcv != .register) continue;
-        if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) continue;
-        try self.store(self.typeOf(output), .{ .air_ref = output }, arg_mcv, .{});
+        if (out.constraint.len == 2 and std.ascii.isDigit(out.constraint[1])) continue;
+        try self.store(self.typeOf(out.operand), .{ .air_ref = out.operand }, arg_mcv, .{});
     }
 
     simple: {
-- 
2.54.0


From 3d33735d73de269278fb87d2c9ae8fb7d83977be Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 00:29:31 -0800
Subject: [PATCH 219/499] zig build: add --fork CLI argument

closes #31124
---
 lib/compiler/build_runner.zig |  63 ++++++++++---------
 src/Package.zig               |  37 +++++++++++
 src/Package/Fetch.zig         |  45 +++++---------
 src/Package/Manifest.zig      |  46 +++++++++++++-
 src/main.zig                  | 113 +++++++++++++++++++++++++++++-----
 5 files changed, 228 insertions(+), 76 deletions(-)

diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 2dd18d4f0dcaa426988c8747fa03c49859830d72..4d6b640e88fd5852b03bfa9eb12fbbeb6c237735 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -1573,33 +1573,6 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
         \\  -fsys=[name]                 Enable a system integration
         \\  -fno-sys=[name]              Disable a system integration
         \\
-        \\  Available System Integrations:                Enabled:
-        \\
-    );
-    if (b.graph.system_library_options.entries.len == 0) {
-        try w.writeAll("  (none)                                        -\n");
-    } else {
-        for (b.graph.system_library_options.keys(), b.graph.system_library_options.values()) |k, v| {
-            const status = switch (v) {
-                .declared_enabled => "yes",
-                .declared_disabled => "no",
-                .user_enabled, .user_disabled => unreachable, // already emitted error
-            };
-            try w.print("    {s:<43} {s}\n", .{ k, status });
-        }
-    }
-
-    try w.writeAll(
-        \\
-        \\General Options:
-        \\  -p, --prefix [path]          Where to install files (default: zig-out)
-        \\  --prefix-lib-dir [path]      Where to install libraries
-        \\  --prefix-exe-dir [path]      Where to install executables
-        \\  --prefix-include-dir [path]  Where to install C header files
-        \\
-        \\  --release[=mode]             Request release mode, optionally specifying a
-        \\                               preferred optimization mode: fast, safe, small
-        \\
         \\  -fdarling,  -fno-darling     Integration with system-installed Darling to
         \\                               execute macOS programs on Linux hosts
         \\                               (default: no)
@@ -1617,8 +1590,35 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
         \\  -fwine,     -fno-wine        Integration with system-installed Wine to execute
         \\                               Windows programs on Linux hosts. (default: no)
         \\
+        \\  Available System Integrations:                Enabled:
+        \\
+    );
+    if (b.graph.system_library_options.entries.len == 0) {
+        try w.writeAll("  (none)                                        -\n");
+    } else {
+        for (b.graph.system_library_options.keys(), b.graph.system_library_options.values()) |k, v| {
+            const status = switch (v) {
+                .declared_enabled => "yes",
+                .declared_disabled => "no",
+                .user_enabled, .user_disabled => unreachable, // already emitted error
+            };
+            try w.print("    {s:<43} {s}\n", .{ k, status });
+        }
+    }
+
+    try w.writeAll(
+        \\
+        \\General Options:
         \\  -h, --help                   Print this help and exit
         \\  -l, --list-steps             Print available steps
+        \\
+        \\  -p, --prefix [path]          Where to install files (default: zig-out)
+        \\  --prefix-lib-dir [path]      Where to install libraries
+        \\  --prefix-exe-dir [path]      Where to install executables
+        \\  --prefix-include-dir [path]  Where to install C header files
+        \\  --release[=mode]             Request release mode, optionally specifying a
+        \\                               preferred optimization mode: fast, safe, small
+        \\
         \\  --verbose                    Print commands before executing them
         \\  --color [auto|off|on]        Enable or disable colored error messages
         \\  --error-style [style]        Control how build errors are printed
@@ -1641,9 +1641,6 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
         \\  --skip-oom-steps             Instead of failing, skip steps that would exceed --maxrss
         \\  --test-timeout <timeout>     Limit execution time of unit tests, terminating if exceeded.
         \\                               The timeout must include a unit: ns, us, ms, s, m, h
-        \\  --fetch[=mode]               Fetch dependency tree (optionally choose laziness) and exit
-        \\    needed                     (Default) Lazy dependencies are fetched as needed
-        \\    all                        Lazy dependencies are always fetched
         \\  --watch                      Continuously rebuild when source files are modified
         \\  --debounce <ms>              Delay before rebuilding after changed file detected
         \\  --webui[=ip]                 Enable the web interface on the given IP address
@@ -1656,6 +1653,12 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
         \\     -fincremental             Enable incremental compilation
         \\  -fno-incremental             Disable incremental compilation
         \\
+        \\Package Management Options:
+        \\  --fetch[=mode]               Fetch dependency tree (optionally choose laziness) and exit
+        \\    needed                     (Default) Lazy dependencies are fetched as needed
+        \\    all                        Lazy dependencies are always fetched
+        \\  --fork=[path]                Override one or more packages from dependency tree
+        \\
         \\Advanced Options:
         \\  -freference-trace[=num]      How many lines of reference trace should be shown per compile error
         \\  -fno-reference-trace         Disable reference trace
diff --git a/src/Package.zig b/src/Package.zig
index fda4c1c1783b64d40cd67be3cdeab98b480b9b12..1307b8e9f998fe97725068d6c94911bc64955a43 100644
--- a/src/Package.zig
+++ b/src/Package.zig
@@ -137,6 +137,43 @@ pub const Hash = struct {
         _ = std.fmt.bufPrint(result.bytes[i..], "{x}", .{&bin_digest}) catch unreachable;
         return result;
     }
+
+    pub fn projectId(hash: *const Hash) ProjectId {
+        const name = std.mem.sliceTo(&hash.bytes, '-');
+        const hashplus = hash.bytes[std.mem.findScalarLast(u8, &hash.bytes, '-').? + 1 ..];
+        var decoded: [6]u8 = undefined;
+        std.base64.url_safe_no_pad.Decoder.decode(&decoded, hashplus[0..8]) catch unreachable;
+        const fingerprint_id = std.mem.readInt(u32, decoded[0..4], .little);
+        return .init(name, fingerprint_id);
+    }
+
+    test projectId {
+        const hash: Hash = .fromSlice("pulseaudio-16.1.1-9-mk_62MZkNwBaFwiZ7ZVrYRIf_3dTqqJR5PbMRCJzSuLw");
+        const project_id = hash.projectId();
+
+        var expected_name: [32]u8 = @splat(0);
+        expected_name[0.."pulseaudio".len].* = "pulseaudio".*;
+        try std.testing.expectEqualSlices(u8, &expected_name, &project_id.padded_name);
+
+        try std.testing.expectEqual(0xd8fa4f9a, project_id.fingerprint_id);
+    }
+};
+
+/// Minimum information required to identify whether a package is an artifact
+/// of a given project.
+pub const ProjectId = struct {
+    /// Bytes after name.len are set to zero.
+    padded_name: [32]u8,
+    fingerprint_id: u32,
+
+    pub fn init(name: []const u8, fingerprint_id: u32) ProjectId {
+        var padded_name: [32]u8 = @splat(0);
+        @memcpy(padded_name[0..name.len], name);
+        return .{
+            .padded_name = padded_name,
+            .fingerprint_id = fingerprint_id,
+        };
+    }
 };
 
 pub const MultihashFunction = enum(u16) {
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index d873fc9bd9a3eb4d5c316c273a6e4e05e3e77dc4..7aa3cee00114dcfdd4b700996e845f2e825ba911 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -142,6 +142,8 @@ pub const JobQueue = struct {
     /// Set of hashes that will be additionally fetched even if they are marked
     /// as lazy.
     unlazy_set: UnlazySet = .{},
+    /// Identifies paths that override all packages in the tree matching
+    fork_set: ForkSet = .{},
 
     pub const Mode = enum {
         /// Non-lazy dependencies are always fetched.
@@ -152,6 +154,7 @@ pub const JobQueue = struct {
     };
     pub const Table = std.AutoArrayHashMapUnmanaged(Package.Hash, *Fetch);
     pub const UnlazySet = std.AutoArrayHashMapUnmanaged(Package.Hash, void);
+    pub const ForkSet = std.AutoArrayHashMapUnmanaged(Package.ProjectId, Cache.Path);
 
     pub fn deinit(jq: *JobQueue) void {
         const io = jq.io;
@@ -801,45 +804,29 @@ fn loadManifest(f: *Fetch, pkg_root: Cache.Path) RunError!void {
     const io = f.job_queue.io;
     const eb = &f.error_bundle;
     const arena = f.arena.allocator();
-    const manifest_bytes = pkg_root.root_dir.handle.readFileAllocOptions(
+    const manifest_path = try pkg_root.join(arena, Manifest.basename);
+
+    f.manifest = @as(Manifest, undefined);
+
+    Manifest.load(
         io,
-        try fs.path.join(arena, &.{ pkg_root.sub_path, Manifest.basename }),
         arena,
-        .limited(Manifest.max_bytes),
-        .@"1",
-        0,
+        manifest_path,
+        &f.manifest_ast,
+        eb,
+        &f.manifest.?,
+        f.allow_missing_paths_field,
     ) catch |err| switch (err) {
         error.FileNotFound => return,
+        error.Canceled => |e| return e,
+        error.ErrorsBundled => return error.FetchFailed,
         else => |e| {
-            const file_path = try pkg_root.join(arena, Manifest.basename);
             try eb.addRootErrorMessage(.{
-                .msg = try eb.printString("unable to load package manifest '{f}': {t}", .{ file_path, e }),
+                .msg = try eb.printString("unable to load package manifest '{f}': {t}", .{ manifest_path, e }),
             });
             return error.FetchFailed;
         },
     };
-
-    const ast = &f.manifest_ast;
-    ast.* = try std.zig.Ast.parse(arena, manifest_bytes, .zon);
-
-    if (ast.errors.len > 0) {
-        const file_path = try std.fmt.allocPrint(arena, "{f}" ++ fs.path.sep_str ++ Manifest.basename, .{pkg_root});
-        try std.zig.putAstErrorsIntoBundle(arena, ast.*, file_path, eb);
-        return error.FetchFailed;
-    }
-
-    const rng: std.Random.IoSource = .{ .io = io };
-
-    f.manifest = try Manifest.parse(arena, ast.*, rng.interface(), .{
-        .allow_missing_paths_field = f.allow_missing_paths_field,
-    });
-    const manifest = &f.manifest.?;
-
-    if (manifest.errors.len > 0) {
-        const src_path = try eb.printString("{f}" ++ fs.path.sep_str ++ "{s}", .{ pkg_root, Manifest.basename });
-        try manifest.copyErrorsIntoBundle(ast.*, src_path, eb);
-        return error.FetchFailed;
-    }
 }
 
 fn queueJobsForDeps(f: *Fetch) RunError!void {
diff --git a/src/Package/Manifest.zig b/src/Package/Manifest.zig
index e66a78ae14b7c93bd233fe9327e6631b82702170..4a71d15c814f5f90c0373d9383f594987c649d0d 100644
--- a/src/Package/Manifest.zig
+++ b/src/Package/Manifest.zig
@@ -1,10 +1,13 @@
 const Manifest = @This();
+
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const Ast = std.zig.Ast;
 const testing = std.testing;
+
 const Package = @import("../Package.zig");
 
 pub const max_bytes = 10 * 1024 * 1024;
@@ -53,7 +56,7 @@ pub const ParseOptions = struct {
 
 pub const Error = Allocator.Error;
 
-pub fn parse(gpa: Allocator, ast: Ast, rng: std.Random, options: ParseOptions) Error!Manifest {
+pub fn parse(gpa: Allocator, ast: *const Ast, rng: std.Random, options: ParseOptions) Error!Manifest {
     const main_node_index = ast.nodeData(.root).node;
 
     var arena_instance = std.heap.ArenaAllocator.init(gpa);
@@ -61,7 +64,7 @@ pub fn parse(gpa: Allocator, ast: Ast, rng: std.Random, options: ParseOptions) E
 
     var p: Parse = .{
         .gpa = gpa,
-        .ast = ast,
+        .ast = ast.*,
         .arena = arena_instance.allocator(),
         .errors = .{},
 
@@ -578,6 +581,45 @@ const Parse = struct {
     }
 };
 
+pub fn load(
+    io: Io,
+    arena: Allocator,
+    manifest_path: std.Build.Cache.Path,
+    ast: *std.zig.Ast,
+    error_bundle: *std.zig.ErrorBundle.Wip,
+    manifest: *Manifest,
+    allow_missing_paths_field: bool,
+) !void {
+    const manifest_bytes = try manifest_path.root_dir.handle.readFileAllocOptions(
+        io,
+        manifest_path.sub_path,
+        arena,
+        .limited(max_bytes),
+        .@"1",
+        0,
+    );
+
+    ast.* = try std.zig.Ast.parse(arena, manifest_bytes, .zon);
+
+    if (ast.errors.len > 0) {
+        const file_path = try manifest_path.joinString(arena, "");
+        try std.zig.putAstErrorsIntoBundle(arena, ast.*, file_path, error_bundle);
+        return error.ErrorsBundled;
+    }
+
+    const rng: std.Random.IoSource = .{ .io = io };
+
+    manifest.* = try parse(arena, ast, rng.interface(), .{
+        .allow_missing_paths_field = allow_missing_paths_field,
+    });
+
+    if (manifest.errors.len > 0) {
+        const src_path = try error_bundle.printString("{f}", .{manifest_path});
+        try manifest.copyErrorsIntoBundle(ast.*, src_path, error_bundle);
+        return error.ErrorsBundled;
+    }
+}
+
 test "basic" {
     const gpa = testing.allocator;
 
diff --git a/src/main.zig b/src/main.zig
index dba52807f544973724264eb1eda73f8c0452d28a..a59c289ce37d41558ad4265de67acf6a55d0b9b5 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -4896,7 +4896,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
     var override_global_cache_dir: ?[]const u8 = EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map);
     var override_local_cache_dir: ?[]const u8 = EnvVar.ZIG_LOCAL_CACHE_DIR.get(environ_map);
     var override_build_runner: ?[]const u8 = EnvVar.ZIG_BUILD_RUNNER.get(environ_map);
-    var child_argv = std.array_list.Managed([]const u8).init(arena);
+    var child_argv: std.ArrayList([]const u8) = .empty;
+    var forks: std.ArrayList(Fork) = .empty;
     var reference_trace: ?u32 = null;
     var debug_compile_errors = false;
     var verbose_link = (native_os != .wasi or builtin.link_libc) and
@@ -4917,24 +4918,24 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
     var debug_libc_paths_file: ?[]const u8 = null;
 
     const argv_index_exe = child_argv.items.len;
-    _ = try child_argv.addOne();
+    _ = try child_argv.addOne(arena);
 
     const self_exe_path = try process.executablePathAlloc(io, arena);
-    try child_argv.append(self_exe_path);
+    try child_argv.append(arena, self_exe_path);
 
     const argv_index_zig_lib_dir = child_argv.items.len;
-    _ = try child_argv.addOne();
+    _ = try child_argv.addOne(arena);
 
     const argv_index_build_file = child_argv.items.len;
-    _ = try child_argv.addOne();
+    _ = try child_argv.addOne(arena);
 
     const argv_index_cache_dir = child_argv.items.len;
-    _ = try child_argv.addOne();
+    _ = try child_argv.addOne(arena);
 
     const argv_index_global_cache_dir = child_argv.items.len;
-    _ = try child_argv.addOne();
+    _ = try child_argv.addOne(arena);
 
-    try child_argv.appendSlice(&.{
+    try child_argv.appendSlice(arena, &.{
         "--seed",
         try std.fmt.allocPrint(arena, "0x{x}", .{randInt(io, u32)}),
     });
@@ -4955,7 +4956,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
     // read this file in the parent to obtain the results, in the case the child
     // exits with code 3.
     const results_tmp_file_nonce = std.fmt.hex(randInt(io, u64));
-    try child_argv.append("-Z" ++ results_tmp_file_nonce);
+    try child_argv.append(arena, "-Z" ++ results_tmp_file_nonce);
 
     var color: Color = .auto;
     var n_jobs: ?u32 = null;
@@ -5000,11 +5001,19 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                         fatal("expected [needed|all] after '--fetch=', found '{s}'", .{
                             sub_arg,
                         });
+                } else if (mem.cutPrefix(u8, arg, "--fork=")) |sub_arg| {
+                    try forks.append(arena, .{
+                        .project_id = undefined,
+                        .path = .{
+                            .root_dir = .cwd(),
+                            .sub_path = sub_arg,
+                        },
+                    });
                 } else if (mem.eql(u8, arg, "--system")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
                     i += 1;
                     system_pkg_dir_path = args[i];
-                    try child_argv.append("--system");
+                    try child_argv.append(arena, "--system");
                     continue;
                 } else if (mem.cutPrefix(u8, arg, "-freference-trace=")) |num| {
                     reference_trace = std.fmt.parseUnsigned(u32, num, 10) catch |err| {
@@ -5014,7 +5023,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     reference_trace = null;
                 } else if (mem.eql(u8, arg, "--debug-log")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
-                    try child_argv.appendSlice(args[i .. i + 2]);
+                    try child_argv.appendSlice(arena, args[i .. i + 2]);
                     i += 1;
                     if (!build_options.enable_logging) {
                         warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{});
@@ -5070,7 +5079,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     color = std.meta.stringToEnum(Color, args[i]) orelse {
                         fatal("expected [auto|on|off] after {s}, found '{s}'", .{ arg, args[i] });
                     };
-                    try child_argv.appendSlice(&.{ arg, args[i] });
+                    try child_argv.appendSlice(arena, &.{ arg, args[i] });
                     continue;
                 } else if (mem.cutPrefix(u8, arg, "-j")) |str| {
                     const num = std.fmt.parseUnsigned(u32, str, 10) catch |err| {
@@ -5090,11 +5099,11 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                 } else if (mem.eql(u8, arg, "--")) {
                     // The rest of the args are supposed to get passed onto
                     // build runner's `build.args`
-                    try child_argv.appendSlice(args[i..]);
+                    try child_argv.appendSlice(arena, args[i..]);
                     break;
                 }
             }
-            try child_argv.append(arg);
+            try child_argv.append(arena, arg);
         }
     }
 
@@ -5182,6 +5191,25 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
     defer http_client.deinit();
 
     var unlazy_set: Package.Fetch.JobQueue.UnlazySet = .{};
+    var fork_set: Package.Fetch.JobQueue.ForkSet = .{};
+
+    {
+        // Populate fork_set.
+        var group: Io.Group = .init;
+        defer group.cancel(io);
+
+        for (forks.items) |*fork|
+            group.async(io, loadFork, .{ io, gpa, fork, color });
+
+        try group.await(io);
+
+        for (forks.items) |*fork| {
+            const project_id = fork.project_id catch |err| switch (err) {
+                error.AlreadyReported => process.exit(1),
+            };
+            try fork_set.put(arena, project_id, fork.path);
+        }
+    }
 
     // This loop is re-evaluated when the build script exits with an indication that it
     // could not continue due to missing lazy dependencies.
@@ -5518,6 +5546,61 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
     }
 }
 
+const Fork = struct {
+    path: Path,
+    project_id: error{AlreadyReported}!Package.ProjectId,
+};
+
+fn loadFork(io: Io, gpa: Allocator, fork: *Fork, color: Color) Io.Cancelable!void {
+    fork.project_id = loadForkFallible(io, gpa, fork, color) catch |err| switch (err) {
+        error.Canceled => |e| return e,
+        error.AlreadyReported => |e| e,
+        else => |e| e: {
+            std.log.err("failed to load fork at {f}: {t}", .{ fork.path, e });
+            break :e error.AlreadyReported;
+        },
+    };
+}
+
+fn loadForkFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !Package.ProjectId {
+    var arena_instance = std.heap.ArenaAllocator.init(gpa);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
+
+    var error_bundle: std.zig.ErrorBundle.Wip = undefined;
+    try error_bundle.init(gpa);
+    defer error_bundle.deinit();
+
+    const manifest_path = try fork.path.join(arena, Package.Manifest.basename);
+
+    var manifest_ast: std.zig.Ast = undefined;
+    var manifest: Package.Manifest = undefined;
+
+    Package.Manifest.load(
+        io,
+        arena,
+        manifest_path,
+        &manifest_ast,
+        &error_bundle,
+        &manifest,
+        true,
+    ) catch |err| switch (err) {
+        error.Canceled => |e| return e,
+        error.ErrorsBundled => {
+            assert(error_bundle.root_list.items.len > 0);
+            var errors = try error_bundle.toOwnedBundle("");
+            errors.renderToStderr(io, .{}, color) catch {};
+            return error.AlreadyReported;
+        },
+        else => |e| {
+            std.log.err("failed to load package manifest {f}: {t}", .{ manifest_path, e });
+            return error.AlreadyReported;
+        },
+    };
+
+    return .init(manifest.name, manifest.id);
+}
+
 const JitCmdOptions = struct {
     cmd_name: []const u8,
     root_src_path: []const u8,
@@ -7410,7 +7493,7 @@ fn loadManifest(
         process.exit(2);
     }
 
-    var manifest = try Package.Manifest.parse(gpa, ast, rng.interface(), .{});
+    var manifest = try Package.Manifest.parse(gpa, &ast, rng.interface(), .{});
     errdefer manifest.deinit(gpa);
 
     if (manifest.errors.len > 0) {
-- 
2.54.0


From e661e78256e195e23ef7ffded47c2256d0a7620f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 13:21:13 -0800
Subject: [PATCH 220/499] store the Manifest in the fork set

---
 lib/compiler/build_runner.zig |  2 +-
 src/Package.zig               |  9 ++++++++
 src/Package/Fetch.zig         | 21 ++++++++++++++++++-
 src/main.zig                  | 39 +++++++++++++++++++----------------
 4 files changed, 51 insertions(+), 20 deletions(-)

diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 4d6b640e88fd5852b03bfa9eb12fbbeb6c237735..4aa513ec74caa2ecb606078b181fcba8227d2de8 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -1657,7 +1657,7 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
         \\  --fetch[=mode]               Fetch dependency tree (optionally choose laziness) and exit
         \\    needed                     (Default) Lazy dependencies are fetched as needed
         \\    all                        Lazy dependencies are always fetched
-        \\  --fork=[path]                Override one or more packages from dependency tree
+        \\  --fork=[path]                Override one or more projects from dependency tree
         \\
         \\Advanced Options:
         \\  -freference-trace[=num]      How many lines of reference trace should be shown per compile error
diff --git a/src/Package.zig b/src/Package.zig
index 1307b8e9f998fe97725068d6c94911bc64955a43..d8bab480f0ecdc4b2f703185466f0dfd0cbfe358 100644
--- a/src/Package.zig
+++ b/src/Package.zig
@@ -174,6 +174,15 @@ pub const ProjectId = struct {
             .fingerprint_id = fingerprint_id,
         };
     }
+
+    pub fn eql(a: *const ProjectId, b: *const ProjectId) bool {
+        return a.fingerprint_id == b.fingerprint_id and std.mem.eql(u8, &a.padded_name, &b.padded_name);
+    }
+
+    pub fn hash(a: *const ProjectId) u64 {
+        const x: u64 = @bitCast(a.padded_name[0..8].*);
+        return std.hash.int(x | a.fingerprint_id);
+    }
 };
 
 pub const MultihashFunction = enum(u16) {
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 7aa3cee00114dcfdd4b700996e845f2e825ba911..1c0f0df7e4cc4b94ba30b3c5e512ddae79009ac8 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -154,7 +154,26 @@ pub const JobQueue = struct {
     };
     pub const Table = std.AutoArrayHashMapUnmanaged(Package.Hash, *Fetch);
     pub const UnlazySet = std.AutoArrayHashMapUnmanaged(Package.Hash, void);
-    pub const ForkSet = std.AutoArrayHashMapUnmanaged(Package.ProjectId, Cache.Path);
+    pub const ForkSet = std.ArrayHashMapUnmanaged(Fork, void, Fork.Context, false);
+
+    pub const Fork = struct {
+        path: Cache.Path,
+        manifest_ast: std.zig.Ast,
+        manifest: Package.Manifest,
+
+        pub const Context = struct {
+            pub fn hash(_: @This(), a: Fork) u32 {
+                const project_id: Package.ProjectId = .init(a.manifest.name, a.manifest.id);
+                return @truncate(project_id.hash());
+            }
+
+            pub fn eql(_: @This(), a: Fork, b: Fork, _: usize) bool {
+                const a_project_id: Package.ProjectId = .init(a.manifest.name, a.manifest.id);
+                const b_project_id: Package.ProjectId = .init(b.manifest.name, b.manifest.id);
+                return a_project_id.eql(&b_project_id);
+            }
+        };
+    };
 
     pub fn deinit(jq: *JobQueue) void {
         const io = jq.io;
diff --git a/src/main.zig b/src/main.zig
index a59c289ce37d41558ad4265de67acf6a55d0b9b5..a6510f1a4ce02b917a09b62e641a575d1c8421be 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5003,11 +5003,14 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                         });
                 } else if (mem.cutPrefix(u8, arg, "--fork=")) |sub_arg| {
                     try forks.append(arena, .{
-                        .project_id = undefined,
+                        .manifest_ast = undefined,
+                        .manifest = undefined,
+                        .error_bundle = undefined,
                         .path = .{
                             .root_dir = .cwd(),
                             .sub_path = sub_arg,
                         },
+                        .failed = false,
                     });
                 } else if (mem.eql(u8, arg, "--system")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
@@ -5204,10 +5207,12 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
         try group.await(io);
 
         for (forks.items) |*fork| {
-            const project_id = fork.project_id catch |err| switch (err) {
-                error.AlreadyReported => process.exit(1),
-            };
-            try fork_set.put(arena, project_id, fork.path);
+            if (fork.failed) process.exit(1);
+            try fork_set.put(arena, .{
+                .path = fork.path,
+                .manifest_ast = fork.manifest_ast,
+                .manifest = fork.manifest,
+            }, {});
         }
     }
 
@@ -5548,21 +5553,24 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
 
 const Fork = struct {
     path: Path,
-    project_id: error{AlreadyReported}!Package.ProjectId,
+    manifest_ast: std.zig.Ast,
+    manifest: Package.Manifest,
+    error_bundle: std.zig.ErrorBundle.Wip,
+    failed: bool,
 };
 
 fn loadFork(io: Io, gpa: Allocator, fork: *Fork, color: Color) Io.Cancelable!void {
-    fork.project_id = loadForkFallible(io, gpa, fork, color) catch |err| switch (err) {
+    loadForkFallible(io, gpa, fork, color) catch |err| switch (err) {
         error.Canceled => |e| return e,
-        error.AlreadyReported => |e| e,
-        else => |e| e: {
+        error.AlreadyReported => fork.failed = true,
+        else => |e| {
             std.log.err("failed to load fork at {f}: {t}", .{ fork.path, e });
-            break :e error.AlreadyReported;
+            fork.failed = true;
         },
     };
 }
 
-fn loadForkFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !Package.ProjectId {
+fn loadForkFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !void {
     var arena_instance = std.heap.ArenaAllocator.init(gpa);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
@@ -5573,16 +5581,13 @@ fn loadForkFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !Package.
 
     const manifest_path = try fork.path.join(arena, Package.Manifest.basename);
 
-    var manifest_ast: std.zig.Ast = undefined;
-    var manifest: Package.Manifest = undefined;
-
     Package.Manifest.load(
         io,
         arena,
         manifest_path,
-        &manifest_ast,
+        &fork.manifest_ast,
         &error_bundle,
-        &manifest,
+        &fork.manifest,
         true,
     ) catch |err| switch (err) {
         error.Canceled => |e| return e,
@@ -5597,8 +5602,6 @@ fn loadForkFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !Package.
             return error.AlreadyReported;
         },
     };
-
-    return .init(manifest.name, manifest.id);
 }
 
 const JitCmdOptions = struct {
-- 
2.54.0


From 699063c5a0e1bba14710c76ef5b2ed1cb1343b62 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 13:38:03 -0800
Subject: [PATCH 221/499] fetch: implement the fork override

---
 src/Package/Fetch.zig | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 1c0f0df7e4cc4b94ba30b3c5e512ddae79009ac8..26e016dea5e4a4245e63d81a6ad69b297098c766 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -142,7 +142,8 @@ pub const JobQueue = struct {
     /// Set of hashes that will be additionally fetched even if they are marked
     /// as lazy.
     unlazy_set: UnlazySet = .{},
-    /// Identifies paths that override all packages in the tree matching
+    /// Identifies paths that override all packages in the tree with matching
+    /// project ids.
     fork_set: ForkSet = .{},
 
     pub const Mode = enum {
@@ -173,6 +174,17 @@ pub const JobQueue = struct {
                 return a_project_id.eql(&b_project_id);
             }
         };
+
+        pub const Adapter = struct {
+            pub fn hash(_: @This(), a: Package.ProjectId) u32 {
+                return @truncate(a.hash());
+            }
+
+            pub fn eql(_: @This(), a_project_id: Package.ProjectId, b: Fork, _: usize) bool {
+                const b_project_id: Package.ProjectId = .init(b.manifest.name, b.manifest.id);
+                return a_project_id.eql(&b_project_id);
+            }
+        };
     };
 
     pub fn deinit(jq: *JobQueue) void {
@@ -558,6 +570,15 @@ pub fn run(f: *Fetch) RunError!void {
     var resource_buffer: [init_resource_buffer_size]u8 = undefined;
 
     if (remote.hash) |expected_hash| {
+        const expected_project_id: Package.ProjectId = expected_hash.projectId();
+        if (job_queue.fork_set.getKeyPtrAdapted(expected_project_id, @as(JobQueue.Fork.Adapter, .{}))) |fork| {
+            f.package_root = fork.path;
+            f.manifest_ast = fork.manifest_ast;
+            f.manifest = fork.manifest;
+            if (!job_queue.recursive) return;
+            return queueJobsForDeps(f);
+        }
+
         const package_root = try job_queue.root_pkg_path.join(arena, expected_hash.toSlice());
         if (package_root.root_dir.handle.access(io, package_root.sub_path, .{})) |_| {
             assert(f.lazy_status != .unavailable);
-- 
2.54.0


From 5f453b45d395239d1b26d6cec3d3ac7f407e0fb0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 14:03:09 -0800
Subject: [PATCH 222/499] Package: fix Hash.projectId decoding

---
 src/Package.zig | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/Package.zig b/src/Package.zig
index d8bab480f0ecdc4b2f703185466f0dfd0cbfe358..0215db24a8cf7361c5e19f9a0f6085e86001dad7 100644
--- a/src/Package.zig
+++ b/src/Package.zig
@@ -139,11 +139,12 @@ pub const Hash = struct {
     }
 
     pub fn projectId(hash: *const Hash) ProjectId {
-        const name = std.mem.sliceTo(&hash.bytes, '-');
-        const hashplus = hash.bytes[std.mem.findScalarLast(u8, &hash.bytes, '-').? + 1 ..];
-        var decoded: [6]u8 = undefined;
-        std.base64.url_safe_no_pad.Decoder.decode(&decoded, hashplus[0..8]) catch unreachable;
-        const fingerprint_id = std.mem.readInt(u32, decoded[0..4], .little);
+        const bytes = hash.toSlice();
+        const name = std.mem.sliceTo(bytes, '-');
+        const encoded_hashplus = bytes[bytes.len - 44 ..];
+        var hashplus: [33]u8 = undefined;
+        std.base64.url_safe_no_pad.Decoder.decode(&hashplus, encoded_hashplus) catch unreachable;
+        const fingerprint_id = std.mem.readInt(u32, hashplus[0..4], .little);
         return .init(name, fingerprint_id);
     }
 
@@ -157,6 +158,17 @@ pub const Hash = struct {
 
         try std.testing.expectEqual(0xd8fa4f9a, project_id.fingerprint_id);
     }
+
+    test "projectId with dashes in the base64" {
+        const hash: Hash = .fromSlice("dvui-0.4.0-dev-AQFJmayi2gAKE7FeJoF61v5U1IV9-SupoEcFutIZYpkC");
+        const project_id = hash.projectId();
+
+        var expected_name: [32]u8 = @splat(0);
+        expected_name[0.."dvui".len].* = "dvui".*;
+        try std.testing.expectEqualSlices(u8, &expected_name, &project_id.padded_name);
+
+        try std.testing.expectEqual(0x99490101, project_id.fingerprint_id);
+    }
 };
 
 /// Minimum information required to identify whether a package is an artifact
-- 
2.54.0


From 632d1fb948f46ae09c8e3a5e12acedafde56084a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 14:03:43 -0800
Subject: [PATCH 223/499] fetch: fix manifest memory management

---
 src/Package/Fetch.zig    | 30 ++++++++++++++++++------------
 src/Package/Manifest.zig |  6 +++---
 src/main.zig             | 13 ++++++++-----
 3 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 26e016dea5e4a4245e63d81a6ad69b297098c766..1eebea4b89ce52507d552221eea60f4b8fea89ee 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -76,8 +76,9 @@ use_latest_commit: bool,
 /// Relative to the build root of the root package.
 package_root: Cache.Path,
 error_bundle: ErrorBundle.Wip,
-manifest: ?Manifest,
+manifest: Manifest,
 manifest_ast: std.zig.Ast,
+have_manifest: bool,
 computed_hash: ComputedHash,
 /// Fetch logic notices whether a package has a build.zig file and sets this flag.
 has_build_zig: bool,
@@ -282,7 +283,8 @@ pub const JobQueue = struct {
                 , .{std.zig.fmtString(hash_slice)});
             }
 
-            if (fetch.manifest) |*manifest| {
+            if (fetch.have_manifest) {
+                const manifest = &fetch.manifest;
                 try buf.appendSlice(
                     \\        pub const deps: []const struct { []const u8, []const u8 } = &.{
                     \\
@@ -317,7 +319,8 @@ pub const JobQueue = struct {
         );
 
         const root_fetch = jq.all_fetches.items[0];
-        const root_manifest = &root_fetch.manifest.?;
+        assert(root_fetch.have_manifest);
+        const root_manifest = &root_fetch.manifest;
 
         for (root_manifest.dependencies.keys(), root_manifest.dependencies.values()) |name, dep| {
             const h = depDigest(root_fetch.package_root, jq.global_cache, dep) orelse continue;
@@ -716,7 +719,7 @@ fn runResource(
         try loadManifest(f, pkg_path);
 
         const filter: Filter = .{
-            .include_paths = if (f.manifest) |m| m.paths else .{},
+            .include_paths = if (f.have_manifest) f.manifest.paths else .{},
         };
 
         // Ignore errors that were excluded by manifest, such as failure to
@@ -809,7 +812,8 @@ fn runResource(
 
 pub fn computedPackageHash(f: *const Fetch) Package.Hash {
     const saturated_size = std.math.cast(u32, f.computed_hash.total_size) orelse std.math.maxInt(u32);
-    if (f.manifest) |man| {
+    if (f.have_manifest) {
+        const man = &f.manifest;
         var version_buffer: [32]u8 = undefined;
         const version: []const u8 = std.fmt.bufPrint(&version_buffer, "{f}", .{man.version}) catch &version_buffer;
         return .init(f.computed_hash.digest, man.name, version, man.id, saturated_size);
@@ -846,15 +850,13 @@ fn loadManifest(f: *Fetch, pkg_root: Cache.Path) RunError!void {
     const arena = f.arena.allocator();
     const manifest_path = try pkg_root.join(arena, Manifest.basename);
 
-    f.manifest = @as(Manifest, undefined);
-
     Manifest.load(
         io,
         arena,
         manifest_path,
         &f.manifest_ast,
         eb,
-        &f.manifest.?,
+        &f.manifest,
         f.allow_missing_paths_field,
     ) catch |err| switch (err) {
         error.FileNotFound => return,
@@ -867,6 +869,7 @@ fn loadManifest(f: *Fetch, pkg_root: Cache.Path) RunError!void {
             return error.FetchFailed;
         },
     };
+    f.have_manifest = true;
 }
 
 fn queueJobsForDeps(f: *Fetch) RunError!void {
@@ -875,7 +878,8 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
     assert(f.job_queue.recursive);
 
     // If the package does not have a build.zig.zon file then there are no dependencies.
-    const manifest = f.manifest orelse return;
+    if (!f.have_manifest) return;
+    const manifest = &f.manifest;
 
     const new_fetches, const prog_names = nf: {
         const parent_arena = f.arena.allocator();
@@ -980,8 +984,9 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
 
                 .package_root = undefined,
                 .error_bundle = undefined,
-                .manifest = null,
+                .manifest = undefined,
                 .manifest_ast = undefined,
+                .have_manifest = false,
                 .computed_hash = undefined,
                 .has_build_zig = false,
                 .oom_flag = false,
@@ -1958,7 +1963,7 @@ const Filter = struct {
     include_paths: std.StringArrayHashMapUnmanaged(void) = .empty,
 
     /// sub_path is relative to the package root.
-    pub fn includePath(self: Filter, sub_path: []const u8) bool {
+    pub fn includePath(self: *const Filter, sub_path: []const u8) bool {
         if (self.include_paths.count() == 0) return true;
         if (self.include_paths.contains("")) return true;
         if (self.include_paths.contains(".")) return true;
@@ -2349,8 +2354,9 @@ const TestFetchBuilder = struct {
 
             .package_root = undefined,
             .error_bundle = undefined,
-            .manifest = null,
+            .manifest = undefined,
             .manifest_ast = undefined,
+            .have_manifest = false,
             .computed_hash = undefined,
             .has_build_zig = false,
             .oom_flag = false,
diff --git a/src/Package/Manifest.zig b/src/Package/Manifest.zig
index 4a71d15c814f5f90c0373d9383f594987c649d0d..3370ef1d47dd6c771c5428adabe7160ea4964992 100644
--- a/src/Package/Manifest.zig
+++ b/src/Package/Manifest.zig
@@ -645,7 +645,7 @@ test "basic" {
 
     var rng = std.Random.DefaultPrng.init(0);
 
-    var manifest = try Manifest.parse(gpa, ast, rng.random(), .{});
+    var manifest = try Manifest.parse(gpa, &ast, rng.random(), .{});
     defer manifest.deinit(gpa);
 
     try testing.expect(manifest.errors.len == 0);
@@ -691,7 +691,7 @@ test "minimum_zig_version" {
 
     var rng = std.Random.DefaultPrng.init(0);
 
-    var manifest = try Manifest.parse(gpa, ast, rng.random(), .{});
+    var manifest = try Manifest.parse(gpa, &ast, rng.random(), .{});
     defer manifest.deinit(gpa);
 
     try testing.expect(manifest.errors.len == 0);
@@ -726,7 +726,7 @@ test "minimum_zig_version - invalid version" {
 
     var rng = std.Random.DefaultPrng.init(0);
 
-    var manifest = try Manifest.parse(gpa, ast, rng.random(), .{});
+    var manifest = try Manifest.parse(gpa, &ast, rng.random(), .{});
     defer manifest.deinit(gpa);
 
     try testing.expect(manifest.errors.len == 1);
diff --git a/src/main.zig b/src/main.zig
index a6510f1a4ce02b917a09b62e641a575d1c8421be..9a8b1d31a8307be45072483fba56114e866f3715 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5323,8 +5323,9 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
 
                     .package_root = undefined,
                     .error_bundle = undefined,
-                    .manifest = null,
+                    .manifest = undefined,
                     .manifest_ast = undefined,
+                    .have_manifest = false,
                     .computed_hash = undefined,
                     .has_build_zig = true,
                     .oom_flag = false,
@@ -5402,7 +5403,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     // dependencies' build.zig modules by name.
                     for (fetches) |f| {
                         const mod = f.module orelse continue;
-                        const man = f.manifest orelse continue;
+                        if (!f.have_manifest) continue;
+                        const man = &f.manifest;
                         const dep_names = man.dependencies.keys();
                         try mod.deps.ensureUnusedCapacity(arena, @intCast(dep_names.len));
                         for (dep_names, man.dependencies.values()) |name, dep| {
@@ -7134,8 +7136,9 @@ fn cmdFetch(
 
         .package_root = undefined,
         .error_bundle = undefined,
-        .manifest = null,
+        .manifest = undefined,
         .manifest_ast = undefined,
+        .have_manifest = false,
         .computed_hash = undefined,
         .has_build_zig = false,
         .oom_flag = false,
@@ -7171,9 +7174,9 @@ fn cmdFetch(
         },
         .yes, .exact => |name| name: {
             if (name) |n| break :name n;
-            const fetched_manifest = fetch.manifest orelse
+            if (!fetch.have_manifest)
                 fatal("unable to determine name; fetched package has no build.zig.zon file", .{});
-            break :name fetched_manifest.name;
+            break :name fetch.manifest.name;
         },
     };
 
-- 
2.54.0


From 9d0256271758d24354aff7e5ba1d6927f5fe94f9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 14:12:52 -0800
Subject: [PATCH 224/499] zig build: don't add --fork to build runner args

---
 src/main.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main.zig b/src/main.zig
index 9a8b1d31a8307be45072483fba56114e866f3715..80921fc02f4d217ac3f568f4da0d5f1508f825ce 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5012,6 +5012,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                         },
                         .failed = false,
                     });
+                    continue;
                 } else if (mem.eql(u8, arg, "--system")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
                     i += 1;
-- 
2.54.0


From 9f3b60b23af226c7e62645daa1df27419f0a1b6a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 14:29:45 -0800
Subject: [PATCH 225/499] fetch: ensure that forks are actually used

---
 src/Package/Fetch.zig |  3 +++
 src/main.zig          | 22 ++++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 1eebea4b89ce52507d552221eea60f4b8fea89ee..00b1bd8f539e5096979ed236c896e7a1847e7d62 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -162,6 +162,7 @@ pub const JobQueue = struct {
         path: Cache.Path,
         manifest_ast: std.zig.Ast,
         manifest: Package.Manifest,
+        uses: usize,
 
         pub const Context = struct {
             pub fn hash(_: @This(), a: Fork) u32 {
@@ -575,6 +576,8 @@ pub fn run(f: *Fetch) RunError!void {
     if (remote.hash) |expected_hash| {
         const expected_project_id: Package.ProjectId = expected_hash.projectId();
         if (job_queue.fork_set.getKeyPtrAdapted(expected_project_id, @as(JobQueue.Fork.Adapter, .{}))) |fork| {
+            log.debug("using fork {f} for {s}", .{ fork.path, fork.manifest.name });
+            fork.uses += 1;
             f.package_root = fork.path;
             f.manifest_ast = fork.manifest_ast;
             f.manifest = fork.manifest;
diff --git a/src/main.zig b/src/main.zig
index 80921fc02f4d217ac3f568f4da0d5f1508f825ce..ef5c9ec732c147fc207aa68c217177f144eca3f6 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5213,6 +5213,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                 .path = fork.path,
                 .manifest_ast = fork.manifest_ast,
                 .manifest = fork.manifest,
+                .uses = 0,
             }, {});
         }
     }
@@ -5279,6 +5280,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                     .recursive = true,
                     .debug_hash = false,
                     .unlazy_set = unlazy_set,
+                    .fork_set = fork_set,
                     .mode = fetch_mode,
                     .prog_node = fetch_prog_node,
                 };
@@ -5344,6 +5346,26 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                 job_queue.group.async(io, Package.Fetch.workerRun, .{ &fetch, "root" });
                 try job_queue.group.await(io);
 
+                {
+                    // Ensure that forks were actually used. This is done
+                    // before printing manifest errors because using a fork can
+                    // prevent them.
+                    var any_unused = false;
+                    for (fork_set.keys()) |*fork| {
+                        if (fork.uses == 0) {
+                            std.log.err("fork {f} matched no {s} packages", .{
+                                fork.path, fork.manifest.name,
+                            });
+                            any_unused = true;
+                        } else {
+                            std.log.info("fork {f} matched {d} {s} packages", .{
+                                fork.path, fork.uses, fork.manifest.name,
+                            });
+                        }
+                    }
+                    if (any_unused) process.exit(1);
+                }
+
                 try job_queue.consolidateErrors();
 
                 if (fetch.error_bundle.root_list.items.len > 0) {
-- 
2.54.0


From b24b0479f6be4e29d9ac4b9c6d2886aa21c412ab Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 15:10:54 -0800
Subject: [PATCH 226/499] fetch: fix missing check for build.zig existence

---
 src/Package/Fetch.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 00b1bd8f539e5096979ed236c896e7a1847e7d62..d597aa0a87a6114da08e9006d5862ecc87d1f65b 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -581,6 +581,8 @@ pub fn run(f: *Fetch) RunError!void {
             f.package_root = fork.path;
             f.manifest_ast = fork.manifest_ast;
             f.manifest = fork.manifest;
+            f.have_manifest = true;
+            try checkBuildFileExistence(f);
             if (!job_queue.recursive) return;
             return queueJobsForDeps(f);
         }
-- 
2.54.0


From 6f18aca09e8ba3a3e4987cc17f6b92b6b433537d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 15:11:06 -0800
Subject: [PATCH 227/499] main: fix cleanup of forks

---
 src/main.zig | 101 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 55 insertions(+), 46 deletions(-)

diff --git a/src/main.zig b/src/main.zig
index ef5c9ec732c147fc207aa68c217177f144eca3f6..a02927298750296aecbdb27d16c62fe7e811505f 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5006,6 +5006,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                         .manifest_ast = undefined,
                         .manifest = undefined,
                         .error_bundle = undefined,
+                        .arena_allocator = undefined,
                         .path = .{
                             .root_dir = .cwd(),
                             .sub_path = sub_arg,
@@ -5203,7 +5204,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
         defer group.cancel(io);
 
         for (forks.items) |*fork|
-            group.async(io, loadFork, .{ io, gpa, fork, color });
+            group.async(io, Fork.load, .{ io, gpa, fork, color });
 
         try group.await(io);
 
@@ -5217,6 +5218,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
             }, {});
         }
     }
+    defer Fork.deinitList(forks.items);
 
     // This loop is re-evaluated when the build script exits with an indication that it
     // could not continue due to missing lazy dependencies.
@@ -5270,6 +5272,9 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
                 const fetch_prog_node = root_prog_node.start("Fetch Packages", 0);
                 defer fetch_prog_node.end();
 
+                // Reset fork match counts.
+                for (fork_set.keys()) |*fork| fork.uses = 0;
+
                 var job_queue: Package.Fetch.JobQueue = .{
                     .io = io,
                     .http_client = &http_client,
@@ -5582,53 +5587,57 @@ const Fork = struct {
     manifest: Package.Manifest,
     error_bundle: std.zig.ErrorBundle.Wip,
     failed: bool,
+    arena_allocator: std.heap.ArenaAllocator,
+
+    fn load(io: Io, gpa: Allocator, fork: *Fork, color: Color) Io.Cancelable!void {
+        loadFallible(io, gpa, fork, color) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            error.AlreadyReported => fork.failed = true,
+            else => |e| {
+                std.log.err("failed to load fork at {f}: {t}", .{ fork.path, e });
+                fork.failed = true;
+            },
+        };
+    }
+
+    fn loadFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !void {
+        fork.arena_allocator = .init(gpa);
+        const arena = fork.arena_allocator.allocator();
+
+        var error_bundle: std.zig.ErrorBundle.Wip = undefined;
+        try error_bundle.init(gpa);
+        defer error_bundle.deinit();
+
+        const manifest_path = try fork.path.join(arena, Package.Manifest.basename);
+
+        Package.Manifest.load(
+            io,
+            arena,
+            manifest_path,
+            &fork.manifest_ast,
+            &error_bundle,
+            &fork.manifest,
+            true,
+        ) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            error.ErrorsBundled => {
+                assert(error_bundle.root_list.items.len > 0);
+                var errors = try error_bundle.toOwnedBundle("");
+                errors.renderToStderr(io, .{}, color) catch {};
+                return error.AlreadyReported;
+            },
+            else => |e| {
+                std.log.err("failed to load package manifest {f}: {t}", .{ manifest_path, e });
+                return error.AlreadyReported;
+            },
+        };
+    }
+
+    fn deinitList(forks: []Fork) void {
+        for (forks) |*fork| fork.arena_allocator.deinit();
+    }
 };
 
-fn loadFork(io: Io, gpa: Allocator, fork: *Fork, color: Color) Io.Cancelable!void {
-    loadForkFallible(io, gpa, fork, color) catch |err| switch (err) {
-        error.Canceled => |e| return e,
-        error.AlreadyReported => fork.failed = true,
-        else => |e| {
-            std.log.err("failed to load fork at {f}: {t}", .{ fork.path, e });
-            fork.failed = true;
-        },
-    };
-}
-
-fn loadForkFallible(io: Io, gpa: Allocator, fork: *Fork, color: Color) !void {
-    var arena_instance = std.heap.ArenaAllocator.init(gpa);
-    defer arena_instance.deinit();
-    const arena = arena_instance.allocator();
-
-    var error_bundle: std.zig.ErrorBundle.Wip = undefined;
-    try error_bundle.init(gpa);
-    defer error_bundle.deinit();
-
-    const manifest_path = try fork.path.join(arena, Package.Manifest.basename);
-
-    Package.Manifest.load(
-        io,
-        arena,
-        manifest_path,
-        &fork.manifest_ast,
-        &error_bundle,
-        &fork.manifest,
-        true,
-    ) catch |err| switch (err) {
-        error.Canceled => |e| return e,
-        error.ErrorsBundled => {
-            assert(error_bundle.root_list.items.len > 0);
-            var errors = try error_bundle.toOwnedBundle("");
-            errors.renderToStderr(io, .{}, color) catch {};
-            return error.AlreadyReported;
-        },
-        else => |e| {
-            std.log.err("failed to load package manifest {f}: {t}", .{ manifest_path, e });
-            return error.AlreadyReported;
-        },
-    };
-}
-
 const JitCmdOptions = struct {
     cmd_name: []const u8,
     root_src_path: []const u8,
-- 
2.54.0


From 355c6260015292642badf0e8b786e676fbb8c961 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Feb 2026 15:22:54 -0800
Subject: [PATCH 228/499] fetch: delete legacy hash functionality

This also removes a unit test that violates project policy of having
binary artifacts as test data when they can be created during the test
instead.
---
 src/Package.zig                               |  66 ------
 src/Package/Fetch.zig                         | 221 +-----------------
 src/Package/Fetch/testdata/executables.tar.gz | Bin 430 -> 0 bytes
 3 files changed, 5 insertions(+), 282 deletions(-)
 delete mode 100644 src/Package/Fetch/testdata/executables.tar.gz

diff --git a/src/Package.zig b/src/Package.zig
index 0215db24a8cf7361c5e19f9a0f6085e86001dad7..0dca095833309542439b83270d219f6894e40502 100644
--- a/src/Package.zig
+++ b/src/Package.zig
@@ -6,10 +6,6 @@ pub const Fetch = @import("Package/Fetch.zig");
 pub const build_zig_basename = "build.zig";
 pub const Manifest = @import("Package/Manifest.zig");
 
-pub const multihash_len = 1 + 1 + Hash.Algo.digest_length;
-pub const multihash_hex_digest_len = 2 * multihash_len;
-pub const MultiHashHexDigest = [multihash_hex_digest_len]u8;
-
 pub const Fingerprint = packed struct(u64) {
     id: u32,
     checksum: u32,
@@ -77,20 +73,6 @@ pub const Hash = struct {
         return std.mem.eql(u8, &a.bytes, &b.bytes);
     }
 
-    /// Distinguishes whether the legacy multihash format is being stored here.
-    pub fn isOld(h: *const Hash) bool {
-        if (h.bytes.len < 2) return false;
-        const their_multihash_func = std.fmt.parseInt(u8, h.bytes[0..2], 16) catch return false;
-        if (@as(MultihashFunction, @enumFromInt(their_multihash_func)) != multihash_function) return false;
-        if (h.toSlice().len != multihash_hex_digest_len) return false;
-        return std.mem.indexOfScalar(u8, &h.bytes, '-') == null;
-    }
-
-    test isOld {
-        const h: Hash = .fromSlice("1220138f4aba0c01e66b68ed9e1e1e74614c06e4743d88bc58af4f1c3dd0aae5fea7");
-        try std.testing.expect(h.isOld());
-    }
-
     /// Produces "$name-$semver-$hashplus".
     /// * name is the name field from build.zig.zon, asserted to be at most 32
     ///   bytes and assumed be a valid zig identifier
@@ -197,54 +179,6 @@ pub const ProjectId = struct {
     }
 };
 
-pub const MultihashFunction = enum(u16) {
-    identity = 0x00,
-    sha1 = 0x11,
-    @"sha2-256" = 0x12,
-    @"sha2-512" = 0x13,
-    @"sha3-512" = 0x14,
-    @"sha3-384" = 0x15,
-    @"sha3-256" = 0x16,
-    @"sha3-224" = 0x17,
-    @"sha2-384" = 0x20,
-    @"sha2-256-trunc254-padded" = 0x1012,
-    @"sha2-224" = 0x1013,
-    @"sha2-512-224" = 0x1014,
-    @"sha2-512-256" = 0x1015,
-    @"blake2b-256" = 0xb220,
-    _,
-};
-
-pub const multihash_function: MultihashFunction = switch (Hash.Algo) {
-    std.crypto.hash.sha2.Sha256 => .@"sha2-256",
-    else => unreachable,
-};
-
-pub fn multiHashHexDigest(digest: Hash.Digest) MultiHashHexDigest {
-    const hex_charset = std.fmt.hex_charset;
-
-    var result: MultiHashHexDigest = undefined;
-
-    result[0] = hex_charset[@intFromEnum(multihash_function) >> 4];
-    result[1] = hex_charset[@intFromEnum(multihash_function) & 15];
-
-    result[2] = hex_charset[Hash.Algo.digest_length >> 4];
-    result[3] = hex_charset[Hash.Algo.digest_length & 15];
-
-    for (digest, 0..) |byte, i| {
-        result[4 + i * 2] = hex_charset[byte >> 4];
-        result[5 + i * 2] = hex_charset[byte & 15];
-    }
-    return result;
-}
-
-comptime {
-    // We avoid unnecessary uleb128 code in hexDigest by asserting here the
-    // values are small enough to be contained in the one-byte encoding.
-    assert(@intFromEnum(multihash_function) < 127);
-    assert(Hash.Algo.digest_length < 127);
-}
-
 test Hash {
     const example_digest: Hash.Digest = .{
         0xc7, 0xf5, 0x71, 0xb7, 0xb4, 0xe7, 0x6f, 0x3c, 0xdb, 0x87, 0x7a, 0x7f, 0xdd, 0xf9, 0x77, 0x87,
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index d597aa0a87a6114da08e9006d5862ecc87d1f65b..f51532b10596a21be4ac665d34f0600b4c78b097 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -779,21 +779,11 @@ fn runResource(
 
     if (remote_hash) |declared_hash| {
         const hash_tok = f.hash_tok.unwrap().?;
-        if (declared_hash.isOld()) {
-            const actual_hex = Package.multiHashHexDigest(f.computed_hash.digest);
-            if (!std.mem.eql(u8, declared_hash.toSlice(), &actual_hex)) {
-                return f.fail(hash_tok, try eb.printString(
-                    "hash mismatch: manifest declares '{s}' but the fetched package has '{s}'",
-                    .{ declared_hash.toSlice(), actual_hex },
-                ));
-            }
-        } else {
-            if (!computed_package_hash.eql(&declared_hash)) {
-                return f.fail(hash_tok, try eb.printString(
-                    "hash mismatch: manifest declares '{s}' but the fetched package has '{s}'",
-                    .{ declared_hash.toSlice(), computed_package_hash.toSlice() },
-                ));
-            }
+        if (!computed_package_hash.eql(&declared_hash)) {
+            return f.fail(hash_tok, try eb.printString(
+                "hash mismatch: manifest declares '{s}' but the fetched package has '{s}'",
+                .{ declared_hash.toSlice(), computed_package_hash.toSlice() },
+            ));
         }
     } else if (!f.omit_missing_hash_error) {
         const notes_len = 1;
@@ -2239,207 +2229,6 @@ const UnpackResult = struct {
     }
 };
 
-test "set executable bit based on file content" {
-    if (!Io.File.Permissions.has_executable_bit) return error.SkipZigTest;
-    const gpa = std.testing.allocator;
-    const io = std.testing.io;
-
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-
-    const tarball_name = "executables.tar.gz";
-    try saveEmbedFile(io, tarball_name, tmp.dir);
-    const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
-    defer gpa.free(tarball_path);
-
-    // $ tar -tvf executables.tar.gz
-    // drwxrwxr-x        0  executables/
-    // -rwxrwxr-x      170  executables/hello
-    // lrwxrwxrwx        0  executables/hello_ln -> hello
-    // -rw-rw-r--        0  executables/file1
-    // -rw-rw-r--       17  executables/script_with_shebang_without_exec_bit
-    // -rwxrwxr-x        7  executables/script_without_shebang
-    // -rwxrwxr-x       17  executables/script
-
-    var fb: TestFetchBuilder = undefined;
-    var fetch = try fb.build(gpa, io, tmp.dir, tarball_path);
-    defer fb.deinit();
-
-    try fetch.run();
-    try std.testing.expectEqualStrings(
-        "1220fecb4c06a9da8673c87fe8810e15785f1699212f01728eadce094d21effeeef3",
-        &Package.multiHashHexDigest(fetch.computed_hash.digest),
-    );
-
-    var out = try fb.packageDir();
-    defer out.close(io);
-    const S = std.posix.S;
-    // expect executable bit not set
-    try std.testing.expect((try out.statFile(io, "file1", .{})).permissions.toMode() & S.IXUSR == 0);
-    try std.testing.expect((try out.statFile(io, "script_without_shebang", .{})).permissions.toMode() & S.IXUSR == 0);
-    // expect executable bit set
-    try std.testing.expect((try out.statFile(io, "hello", .{})).permissions.toMode() & S.IXUSR != 0);
-    try std.testing.expect((try out.statFile(io, "script", .{})).permissions.toMode() & S.IXUSR != 0);
-    try std.testing.expect((try out.statFile(io, "script_with_shebang_without_exec_bit", .{})).permissions.toMode() & S.IXUSR != 0);
-    try std.testing.expect((try out.statFile(io, "hello_ln", .{})).permissions.toMode() & S.IXUSR != 0);
-
-    //
-    // $ ls -al zig-cache/tmp/OCz9ovUcstDjTC_U/zig-global-cache/p/1220fecb4c06a9da8673c87fe8810e15785f1699212f01728eadce094d21effeeef3
-    // -rw-rw-r-- 1     0 Apr   file1
-    // -rwxrwxr-x 1   170 Apr   hello
-    // lrwxrwxrwx 1     5 Apr   hello_ln -> hello
-    // -rwxrwxr-x 1    17 Apr   script
-    // -rw-rw-r-- 1     7 Apr   script_without_shebang
-    // -rwxrwxr-x 1    17 Apr   script_with_shebang_without_exec_bit
-}
-
-fn saveEmbedFile(io: Io, comptime tarball_name: []const u8, dir: Io.Dir) !void {
-    //const tarball_name = "duplicate_paths_excluded.tar.gz";
-    const tarball_content = @embedFile("Fetch/testdata/" ++ tarball_name);
-    var tmp_file = try dir.createFile(io, tarball_name, .{});
-    defer tmp_file.close(io);
-    try tmp_file.writeStreamingAll(io, tarball_content);
-}
-
-// Builds Fetch with required dependencies, clears dependencies on deinit().
-const TestFetchBuilder = struct {
-    http_client: std.http.Client,
-    global_cache_directory: Cache.Directory,
-    local_cache_path: Cache.Path,
-    job_queue: Fetch.JobQueue,
-    fetch: Fetch,
-
-    fn build(
-        self: *TestFetchBuilder,
-        allocator: std.mem.Allocator,
-        io: Io,
-        cache_parent_dir: std.Io.Dir,
-        path_or_url: []const u8,
-    ) !*Fetch {
-        const global_cache_dir = try cache_parent_dir.createDirPathOpen(io, "zig-global-cache", .{});
-        const package_root_dir = try cache_parent_dir.createDirPathOpen(io, "local-project-root", .{});
-
-        self.http_client = .{ .allocator = allocator, .io = io };
-        self.global_cache_directory = .{ .handle = global_cache_dir, .path = "zig-global-cache" };
-        self.local_cache_path = .{
-            .root_dir = .{ .handle = package_root_dir, .path = "local-project-root" },
-            .sub_path = ".zig-cache",
-        };
-
-        self.job_queue = .{
-            .io = io,
-            .http_client = &self.http_client,
-            .global_cache = self.global_cache_directory,
-            .local_cache = self.local_cache_path,
-            .root_pkg_path = .{
-                .root_dir = .{ .handle = package_root_dir, .path = "local-project-root" },
-                .sub_path = "zig-pkg",
-            },
-            .recursive = false,
-            .read_only = false,
-            .debug_hash = false,
-            .mode = .needed,
-            .prog_node = std.Progress.Node.none,
-        };
-
-        self.fetch = .{
-            .arena = std.heap.ArenaAllocator.init(allocator),
-            .location = .{ .path_or_url = path_or_url },
-            .location_tok = 0,
-            .hash_tok = .none,
-            .name_tok = 0,
-            .lazy_status = .eager,
-            .parent_package_root = .{ .root_dir = .{ .handle = package_root_dir, .path = null } },
-            .parent_manifest_ast = null,
-            .prog_node = std.Progress.Node.none,
-            .job_queue = &self.job_queue,
-            .omit_missing_hash_error = true,
-            .allow_missing_paths_field = false,
-            .use_latest_commit = true,
-
-            .package_root = undefined,
-            .error_bundle = undefined,
-            .manifest = undefined,
-            .manifest_ast = undefined,
-            .have_manifest = false,
-            .computed_hash = undefined,
-            .has_build_zig = false,
-            .oom_flag = false,
-            .latest_commit = null,
-
-            .module = null,
-        };
-        return &self.fetch;
-    }
-
-    fn deinit(self: *TestFetchBuilder) void {
-        const io = self.job_queue.io;
-        self.fetch.deinit();
-        self.job_queue.deinit();
-        self.fetch.prog_node.end();
-        self.global_cache_directory.handle.close(io);
-        self.http_client.deinit();
-    }
-
-    fn packageDir(self: *TestFetchBuilder) !Io.Dir {
-        const io = self.job_queue.io;
-        const root = self.fetch.package_root;
-        return try root.root_dir.handle.openDir(io, root.sub_path, .{ .iterate = true });
-    }
-
-    // Test helper, asserts thet package dir constains expected_files.
-    // expected_files must be sorted.
-    fn expectPackageFiles(self: *TestFetchBuilder, expected_files: []const []const u8) !void {
-        const io = self.job_queue.io;
-        const gpa = std.testing.allocator;
-
-        var package_dir = try self.packageDir();
-        defer package_dir.close(io);
-
-        var actual_files: std.ArrayList([]u8) = .empty;
-        defer actual_files.deinit(gpa);
-        defer for (actual_files.items) |file| gpa.free(file);
-        var walker = try package_dir.walk(gpa);
-        defer walker.deinit();
-        while (try walker.next(io)) |entry| {
-            if (entry.kind != .file) continue;
-            const path = try gpa.dupe(u8, entry.path);
-            errdefer gpa.free(path);
-            std.mem.replaceScalar(u8, path, std.fs.path.sep, '/');
-            try actual_files.append(gpa, path);
-        }
-        std.mem.sortUnstable([]u8, actual_files.items, {}, struct {
-            fn lessThan(_: void, a: []u8, b: []u8) bool {
-                return std.mem.lessThan(u8, a, b);
-            }
-        }.lessThan);
-
-        try std.testing.expectEqual(expected_files.len, actual_files.items.len);
-        for (expected_files, 0..) |file_name, i| {
-            try std.testing.expectEqualStrings(file_name, actual_files.items[i]);
-        }
-        try std.testing.expectEqualDeep(expected_files, actual_files.items);
-    }
-
-    // Test helper, asserts that fetch has failed with `msg` error message.
-    fn expectFetchErrors(self: *TestFetchBuilder, notes_len: usize, msg: []const u8) !void {
-        const gpa = std.testing.allocator;
-
-        var errors = try self.fetch.error_bundle.toOwnedBundle("");
-        defer errors.deinit(gpa);
-
-        const em = errors.getErrorMessage(errors.getMessages()[0]);
-        try std.testing.expectEqual(1, em.count);
-        if (notes_len > 0) {
-            try std.testing.expectEqual(notes_len, em.notes_len);
-        }
-        var aw: Io.Writer.Allocating = .init(gpa);
-        defer aw.deinit();
-        try errors.renderToWriter(.{}, &aw.writer);
-        try std.testing.expectEqualStrings(msg, aw.written());
-    }
-};
-
 test {
     _ = Filter;
     _ = FileType;
diff --git a/src/Package/Fetch/testdata/executables.tar.gz b/src/Package/Fetch/testdata/executables.tar.gz
deleted file mode 100644
index abc650801ea6d416ad3cef2b87a6df205c71663b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 430
zcmV;f0a5-RiwFP!000001MQd5PJ=KMhPx%ZSz_iR)Of2|TPXFynB8c+@Er)uDkKdv
zgJrw(NqhmHVDUm9P1_Af<5Z>&66JgsoE&I#AV2?UD;IJ+%YsnJbckw#XoTP<Qo)HG
z3lMcZ;u6nc)Io$YM+eO7dLf%xngvsgQ5+=k_=|B>&;KaW(m#?)O=_r7r9a~=*PnC3
zsn*|dTo++d!@F$Ia{cemuP(ZsPMLSn88X=djaK>SgE=E~f{Ga?_TD|U<71u`5$&(T
z(oB3Ym&@meeC*Snz6^THQ*)QT4tlE}@(9l-Q+3_{{<i_uZ1~?-$*yax{V%rY|D021
z{IA;pLzvaokZfA+e_Q{XSV>w#4I{AUxm)Q^7%}~y>E8hQe*@V1r{igSm-+KJi~KZ_
zVUXOelF2Od%{V`dv!B$c)L)BT?*Cl9PheCK0s1$=;lVJBlVKY5Rf>-T1<P!^_{9Il
z@_7sReU0k#pD6uLi8=oXeFOymHvzc5-E8`Q_cbd0U#|ap|8MpQ)ZuXcZw6TZ0RR91
Y00000000000O0@f22hJGm;fjM0E5QW<^TWy

-- 
2.54.0


From b5bd4946067d3796855e0b4b12219dfc28e15e8f Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Fri, 6 Feb 2026 04:36:32 -0500
Subject: [PATCH 229/499] std.Threaded: replace more kernel32 functions with
 ntdll

---
 ci/x86_64-windows-debug.ps1           |   35 +-
 ci/x86_64-windows-release.ps1         |   37 +-
 lib/compiler/build_runner.zig         |    2 +-
 lib/fuzzer.zig                        |    2 +-
 lib/std/Build/Watch.zig               |  278 ++--
 lib/std/Io/Threaded.zig               |  990 +++++++--------
 lib/std/Io/Threaded/test.zig          |    2 +-
 lib/std/Thread.zig                    |   16 +-
 lib/std/debug.zig                     |   45 +-
 lib/std/debug/Dwarf/SelfUnwinder.zig  |    3 +-
 lib/std/debug/SelfInfo/Elf.zig        |   16 +-
 lib/std/debug/SelfInfo/MachO.zig      |   20 +-
 lib/std/debug/SelfInfo/Windows.zig    |  237 ++--
 lib/std/heap.zig                      |    6 +-
 lib/std/os/windows.zig                | 1693 +++++++++----------------
 lib/std/os/windows/kernel32.zig       |  201 +--
 lib/std/os/windows/ntdll.zig          |  247 ++--
 lib/std/os/windows/win32error.zig     |    2 +-
 lib/std/process.zig                   |    8 +-
 lib/std/process/Child.zig             |    2 +-
 lib/std/start.zig                     |   14 +-
 lib/std/zig/system/windows.zig        |   10 +-
 lib/zig.h                             |   28 +-
 stage1/zig.h                          |   28 +-
 test/standalone/coff_dwarf/main.zig   |    7 +-
 test/standalone/windows_argv/fuzz.zig |   18 +-
 test/standalone/windows_argv/lib.zig  |    6 +-
 27 files changed, 1693 insertions(+), 2260 deletions(-)

diff --git a/ci/x86_64-windows-debug.ps1 b/ci/x86_64-windows-debug.ps1
index e6ba8b0861b18003daaca0ab1974dc8f3cfb6ad7..b1486f31bc6f6d57de99ea640bf44865e43861a4 100644
--- a/ci/x86_64-windows-debug.ps1
+++ b/ci/x86_64-windows-debug.ps1
@@ -35,7 +35,7 @@ Set-Location -Path 'build-debug'
 
 # CMake gives a syntax error when file paths with backward slashes are used.
 # Here, we use forward slashes only to work around this.
-& cmake .. `
+cmake .. `
   -GNinja `
   -DCMAKE_INSTALL_PREFIX="stage3-debug" `
   -DCMAKE_PREFIX_PATH="$($PREFIX_PATH -Replace "\\", "/")" `
@@ -54,7 +54,7 @@ ninja install
 CheckLastExitCode
 
 Write-Output "Main test suite..."
-& "stage3-debug\bin\zig.exe" build test docs `
+stage3-debug\bin\zig build test docs `
   --maxrss $ZSF_MAX_RSS `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   --search-prefix "$PREFIX_PATH" `
@@ -66,26 +66,25 @@ Write-Output "Main test suite..."
 CheckLastExitCode
 
 Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
-& "stage3-debug\bin\zig.exe" test `
-  ..\test\behavior.zig `
-  --zig-lib-dir "$ZIG_LIB_DIR" `
-  -ofmt=c `
-  -femit-bin="test-x86_64-windows-msvc.c" `
-  --test-no-exec `
-  -target x86_64-windows-msvc `
-  -lc
-CheckLastExitCode
-
-& "stage3-debug\bin\zig.exe" build-obj `
+stage3-debug\bin\zig build-obj `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   -ofmt=c `
   -OReleaseSmall `
   --name compiler_rt `
   -femit-bin="compiler_rt-x86_64-windows-msvc.c" `
-  --dep build_options `
   -target x86_64-windows-msvc `
-  -Mroot="..\lib\compiler_rt.zig" `
-  -Mbuild_options="config.zig"
+  -lc `
+  ..\lib\compiler_rt.zig
+CheckLastExitCode
+
+stage3-debug\bin\zig test `
+  --zig-lib-dir "$ZIG_LIB_DIR" `
+  -ofmt=c `
+  -femit-bin="behavior-x86_64-windows-msvc.c" `
+  --test-no-exec `
+  -target x86_64-windows-msvc `
+  -lc `
+  ..\test\behavior.zig
 CheckLastExitCode
 
 Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
@@ -97,8 +96,8 @@ Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
+cl /I..\lib /W3 /Z7 behavior-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /link /nologo /debug /subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
 CheckLastExitCode
 
-& .\test-x86_64-windows-msvc.exe
+.\behavior-x86_64-windows-msvc
 CheckLastExitCode
diff --git a/ci/x86_64-windows-release.ps1 b/ci/x86_64-windows-release.ps1
index e22e3af1c79d670d7e488664a715b21f2b9331ef..a8674d1d3dcc6b57e775bd9dec11faf04f1279ab 100644
--- a/ci/x86_64-windows-release.ps1
+++ b/ci/x86_64-windows-release.ps1
@@ -35,7 +35,7 @@ Set-Location -Path 'build-release'
 
 # CMake gives a syntax error when file paths with backward slashes are used.
 # Here, we use forward slashes only to work around this.
-& cmake .. `
+cmake .. `
   -GNinja `
   -DCMAKE_INSTALL_PREFIX="stage3-release" `
   -DCMAKE_PREFIX_PATH="$($PREFIX_PATH -Replace "\\", "/")" `
@@ -54,7 +54,7 @@ ninja install
 CheckLastExitCode
 
 Write-Output "Main test suite..."
-& "stage3-release\bin\zig.exe" build test docs `
+stage3-release\bin\zig.exe build test docs `
   --maxrss $ZSF_MAX_RSS `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   --search-prefix "$PREFIX_PATH" `
@@ -67,7 +67,7 @@ CheckLastExitCode
 
 # Ensure that stage3 and stage4 are byte-for-byte identical.
 Write-Output "Build and compare stage4..."
-& "stage3-release\bin\zig.exe" build `
+stage3-release\bin\zig.exe build `
   --prefix stage4-release `
   -Denable-llvm `
   -Dno-lib `
@@ -85,26 +85,25 @@ Compare-Object (Get-Content stage3-release\bin\zig.exe) (Get-Content stage4-rele
 CheckLastExitCode
 
 Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
-& "stage3-release\bin\zig.exe" test `
-  ..\test\behavior.zig `
-  --zig-lib-dir "$ZIG_LIB_DIR" `
-  -ofmt=c `
-  -femit-bin="test-x86_64-windows-msvc.c" `
-  --test-no-exec `
-  -target x86_64-windows-msvc `
-  -lc
-CheckLastExitCode
-
-& "stage3-release\bin\zig.exe" build-obj `
+stage3-release\bin\zig.exe build-obj `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   -ofmt=c `
   -OReleaseSmall `
   --name compiler_rt `
   -femit-bin="compiler_rt-x86_64-windows-msvc.c" `
-  --dep build_options `
   -target x86_64-windows-msvc `
-  -Mroot="..\lib\compiler_rt.zig" `
-  -Mbuild_options="config.zig"
+  -lc `
+  ..\lib\compiler_rt.zig
+CheckLastExitCode
+
+stage3-release\bin\zig.exe test `
+  --zig-lib-dir "$ZIG_LIB_DIR" `
+  -ofmt=c `
+  -femit-bin="behavior-x86_64-windows-msvc.c" `
+  --test-no-exec `
+  -target x86_64-windows-msvc `
+  -lc `
+  ..\test\behavior.zig
 CheckLastExitCode
 
 Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
@@ -116,8 +115,8 @@ Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
+cl /I..\lib /W3 /Z7 behavior-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /link /nologo /debug /subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
 CheckLastExitCode
 
-& .\test-x86_64-windows-msvc.exe
+.\behavior-x86_64-windows-msvc
 CheckLastExitCode
diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 4aa513ec74caa2ecb606078b181fcba8227d2de8..faf81194a993db9e0ff90e7a34269a57a216f653 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -621,7 +621,7 @@ pub fn main(init: process.Init.Minimal) !void {
         }) catch &caption_buf;
         var debouncing_node = main_progress_node.start(caption, 0);
         var in_debounce = false;
-        while (true) switch (try w.wait(gpa, if (in_debounce) .{ .ms = debounce_interval_ms } else .none)) {
+        while (true) switch (try w.wait(gpa, io, if (in_debounce) .{ .ms = debounce_interval_ms } else .none)) {
             .timeout => {
                 assert(in_debounce);
                 debouncing_node.end();
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index 37ca752d1fa962d0b97d9035fb5823c6e0b61507..9e0c5c6ad649e7cdd454ed6725aec751a490ba77 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -632,7 +632,7 @@ export fn fuzzer_main(limit_kind: abi.LimitKind, amount: u64) void {
 
 export fn fuzzer_unslide_address(addr: usize) usize {
     const si = std.debug.getSelfDebugInfo() catch @compileError("unsupported");
-    const slide = si.getModuleSlide(std.debug.getDebugInfoAllocator(), io, addr) catch |err| {
+    const slide = si.getModuleSlide(io, addr) catch |err| {
         std.debug.panic("failed to find virtual address slide: {t}", .{err});
     };
     return addr - slide;
diff --git a/lib/std/Build/Watch.zig b/lib/std/Build/Watch.zig
index 15ccfcfdf9cde96d937b3fde8424c2e1bfbf200d..c559210b9268d9c0cc44c52f765b81af39b87652 100644
--- a/lib/std/Build/Watch.zig
+++ b/lib/std/Build/Watch.zig
@@ -180,7 +180,7 @@ const Os = switch (builtin.os.tag) {
                         const gop = try w.dir_table.getOrPut(gpa, path);
                         if (!gop.found_existing) {
                             var mount_id: MountId = undefined;
-                            const dir_handle = Os.getDirHandle(gpa, path, &mount_id) catch |err| switch (err) {
+                            const dir_handle = getDirHandle(gpa, path, &mount_id) catch |err| switch (err) {
                                 error.FileNotFound => {
                                     std.debug.assert(w.dir_table.swapRemove(path));
                                     continue;
@@ -291,12 +291,13 @@ const Os = switch (builtin.os.tag) {
             w.dir_count = w.dir_table.count();
         }
 
-        fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
+        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+            _ = io;
             const events_len = try std.posix.poll(w.os.poll_fds.values(), timeout.to_i32_ms());
             if (events_len == 0)
                 return .timeout;
             for (w.os.poll_fds.values()) |poll_fd| {
-                if (poll_fd.revents & std.posix.POLL.IN == std.posix.POLL.IN and try Os.markDirtySteps(w, gpa, poll_fd.fd))
+                if (poll_fd.revents & std.posix.POLL.IN == std.posix.POLL.IN and try markDirtySteps(w, gpa, poll_fd.fd))
                     return .dirty;
             }
             return .clean;
@@ -306,12 +307,8 @@ const Os = switch (builtin.os.tag) {
         const windows = std.os.windows;
 
         /// Keyed differently but indexes correspond 1:1 with `dir_table`.
-        handle_table: HandleTable,
-        dir_list: std.AutoArrayHashMapUnmanaged(usize, *Directory),
-        io_cp: ?windows.HANDLE,
-        counter: usize = 0,
-
-        const HandleTable = std.AutoArrayHashMapUnmanaged(FileId, ReactionSet);
+        handle_table: std.ArrayHashMapUnmanaged(*Directory, void, Directory.TableAdapter, false),
+        ready_dirs: std.DoublyLinkedList,
 
         const FileId = struct {
             volumeSerialNumber: windows.ULONG,
@@ -319,55 +316,61 @@ const Os = switch (builtin.os.tag) {
         };
 
         const Directory = struct {
-            handle: windows.HANDLE,
+            reaction_set: ReactionSet,
             id: FileId,
-            overlapped: windows.OVERLAPPED,
+            file: Io.File,
+            state: enum { idle, listening, ready },
+            iosb: windows.IO_STATUS_BLOCK,
             // 64 KB is the packet size limit when monitoring over a network.
             // https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-readdirectorychangesw#remarks
-            buffer: [64 * 1024]u8 align(@alignOf(windows.FILE_NOTIFY_INFORMATION)) = undefined,
+            buffer: [64 * 1024]u8 align(@alignOf(windows.FILE.NOTIFY.INFORMATION)),
+            ready_node: std.DoublyLinkedList.Node,
 
             /// Start listening for events, buffer field will be overwritten eventually.
-            fn startListening(self: *@This()) !void {
-                const r = windows.kernel32.ReadDirectoryChangesW(
-                    self.handle,
-                    @ptrCast(&self.buffer),
-                    self.buffer.len,
-                    0,
+            fn startListening(dir: *Directory, w: *Watch) !void {
+                assert(dir.file.flags.nonblocking);
+                assert(dir.state == .idle);
+                switch (windows.ntdll.NtNotifyChangeDirectoryFileEx(
+                    dir.file.handle,
+                    null,
+                    &notifyApc,
+                    w,
+                    &dir.iosb,
+                    &dir.buffer,
+                    dir.buffer.len,
                     .{
-                        .creation = true,
-                        .dir_name = true,
-                        .file_name = true,
-                        .last_write = true,
-                        .size = true,
+                        .FILE_NAME = true,
+                        .DIR_NAME = true,
+                        .SIZE = true,
+                        .LAST_WRITE = true,
+                        .CREATION = true,
                     },
-                    null,
-                    &self.overlapped,
-                    null,
-                );
-                if (r == windows.FALSE) {
-                    switch (windows.GetLastError()) {
-                        .INVALID_FUNCTION => return error.ReadDirectoryChangesUnsupported,
-                        else => |err| return windows.unexpectedError(err),
-                    }
+                    windows.FALSE,
+                    .Notify,
+                )) {
+                    .SUCCESS, .PENDING => dir.state = .listening,
+                    .ILLEGAL_FUNCTION => return error.ReadDirectoryChangesUnsupported,
+                    else => |status| return windows.unexpectedStatus(status),
                 }
             }
 
-            fn init(gpa: Allocator, path: Cache.Path) !*@This() {
+            fn notifyApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows.ULONG) callconv(.winapi) void {
+                const w: *Watch = @ptrCast(@alignCast(apc_context));
+                const dir: *Directory = @fieldParentPtr("iosb", iosb);
+                assert(iosb.u.Status != .PENDING);
+                assert(dir.state == .listening);
+                w.os.ready_dirs.append(&dir.ready_node);
+                dir.state = .ready;
+            }
+
+            fn init(gpa: Allocator, path: Cache.Path) !*Directory {
                 // The following code is a drawn out NtCreateFile call. (mostly adapted from Io.Dir.makeOpenDirAccessMaskW)
                 // It's necessary in order to get the specific flags that are required when calling ReadDirectoryChangesW.
                 var dir_handle: windows.HANDLE = undefined;
                 const root_fd = path.root_dir.handle.handle;
                 const sub_path = path.subPathOrDot();
-                const sub_path_w = try std.Io.Threaded.sliceToPrefixedFileW(root_fd, sub_path); // TODO eliminate this call
-                const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
-
-                var nt_name = windows.UNICODE_STRING{
-                    .Length = @intCast(path_len_bytes),
-                    .MaximumLength = @intCast(path_len_bytes),
-                    .Buffer = @constCast(sub_path_w.span().ptr),
-                };
+                const sub_path_w = try Io.Threaded.sliceToPrefixedFileW(root_fd, sub_path); // TODO eliminate this call
                 var iosb: windows.IO_STATUS_BLOCK = undefined;
-
                 switch (windows.ntdll.NtCreateFile(
                     &dir_handle,
                     .{
@@ -379,7 +382,7 @@ const Os = switch (builtin.os.tag) {
                     },
                     &.{
                         .RootDirectory = if (std.fs.path.isAbsoluteWindowsW(sub_path_w.span())) null else root_fd,
-                        .ObjectName = &nt_name,
+                        .ObjectName = @constCast(&sub_path_w.string()),
                     },
                     &iosb,
                     null,
@@ -410,20 +413,49 @@ const Os = switch (builtin.os.tag) {
 
                 const dir_id = try getFileId(dir_handle);
 
-                const dir_ptr = try gpa.create(@This());
-                dir_ptr.* = .{
-                    .handle = dir_handle,
+                const dir = try gpa.create(Directory);
+                dir.* = .{
+                    .reaction_set = .empty,
                     .id = dir_id,
-                    .overlapped = std.mem.zeroes(windows.OVERLAPPED),
+                    .file = .{ .handle = dir_handle, .flags = .{ .nonblocking = true } },
+                    .state = .idle,
+                    .iosb = undefined,
+                    .buffer = undefined,
+                    .ready_node = undefined,
                 };
-                return dir_ptr;
+                return dir;
             }
 
-            fn deinit(self: *@This(), gpa: Allocator) void {
-                _ = windows.kernel32.CancelIo(self.handle);
-                windows.CloseHandle(self.handle);
-                gpa.destroy(self);
+            fn deinit(dir: *Directory, gpa: Allocator, w: *Watch) void {
+                state: switch (dir.state) {
+                    .idle => {},
+                    .listening => {
+                        var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                        _ = windows.ntdll.NtCancelIoFileEx(dir.file.handle, &dir.iosb, &cancel_iosb);
+                        while (switch (dir.state) {
+                            .idle => unreachable,
+                            .listening => true,
+                            .ready => false,
+                        }) Io.Threaded.waitForApcOrAlert();
+                        continue :state .ready;
+                    },
+                    .ready => w.os.ready_dirs.remove(&dir.ready_node),
+                }
+                windows.CloseHandle(dir.file.handle);
+                gpa.destroy(dir);
             }
+
+            /// Useful to make `*Directory` a key in `std.ArrayHashMap`.
+            const TableAdapter = struct {
+                pub fn hash(_: TableAdapter, lhs_dir: *Directory) u32 {
+                    return @truncate(Hash.hash(lhs_dir.id.volumeSerialNumber, @ptrCast(&lhs_dir.id.indexNumber)));
+                }
+                pub fn eql(_: TableAdapter, lhs_dir: *Directory, rhs_dir: *Directory, rhs_index: usize) bool {
+                    _ = rhs_index;
+                    return lhs_dir.id.volumeSerialNumber == rhs_dir.id.volumeSerialNumber and
+                        lhs_dir.id.indexNumber == rhs_dir.id.indexNumber;
+                }
+            };
         };
 
         fn init(cwd_path: []const u8) !Watch {
@@ -433,9 +465,8 @@ const Os = switch (builtin.os.tag) {
                 .dir_count = 0,
                 .os = switch (builtin.os.tag) {
                     .windows => .{
-                        .handle_table = .{},
-                        .dir_list = .{},
-                        .io_cp = null,
+                        .handle_table = .empty,
+                        .ready_dirs = .{},
                     },
                     else => {},
                 },
@@ -479,29 +510,22 @@ const Os = switch (builtin.os.tag) {
 
         fn markDirtySteps(w: *Watch, gpa: Allocator, dir: *Directory) !bool {
             var any_dirty = false;
-            const bytes_returned = try windows.GetOverlappedResult(dir.handle, &dir.overlapped, false);
+            const bytes_returned = dir.iosb.Information;
             if (bytes_returned == 0) {
                 std.log.warn("file system watch queue overflowed; falling back to fstat", .{});
                 markAllFilesDirty(w, gpa);
-                try dir.startListening();
+                try dir.startListening(w);
                 return true;
             }
             var file_name_buf: [std.fs.max_path_bytes]u8 = undefined;
-            var notify: *align(1) windows.FILE_NOTIFY_INFORMATION = undefined;
             var offset: usize = 0;
             while (true) {
-                notify = @ptrCast(&dir.buffer[offset]);
-                const file_name_field: [*]u16 = @ptrFromInt(@intFromPtr(notify) + @sizeOf(windows.FILE_NOTIFY_INFORMATION));
-                const file_name_len = std.unicode.wtf16LeToWtf8(&file_name_buf, file_name_field[0 .. notify.FileNameLength / 2]);
-                const file_name = file_name_buf[0..file_name_len];
-                if (w.os.handle_table.getIndex(dir.id)) |reaction_set_i| {
-                    const reaction_set = w.os.handle_table.values()[reaction_set_i];
-                    if (reaction_set.getPtr(".")) |glob_set|
-                        any_dirty = markStepSetDirty(gpa, glob_set, any_dirty);
-                    if (reaction_set.getPtr(file_name)) |step_set| {
-                        any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
-                    }
-                }
+                const notify: *windows.FILE.NOTIFY.INFORMATION = @ptrCast(@alignCast(&dir.buffer[offset]));
+                const file_name = file_name_buf[0..std.unicode.wtf16LeToWtf8(&file_name_buf, notify.fileName())];
+                if (dir.reaction_set.getPtr(".")) |glob_set|
+                    any_dirty = markStepSetDirty(gpa, glob_set, any_dirty);
+                if (dir.reaction_set.getPtr(file_name)) |step_set|
+                    any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
                 if (notify.NextEntryOffset == 0)
                     break;
 
@@ -509,7 +533,7 @@ const Os = switch (builtin.os.tag) {
             }
 
             // We call this now since at this point we have finished reading dir.buffer.
-            try dir.startListening();
+            try dir.startListening(w);
             return any_dirty;
         }
 
@@ -517,41 +541,32 @@ const Os = switch (builtin.os.tag) {
             // Add missing marks and note persisted ones.
             for (steps) |step| {
                 for (step.inputs.table.keys(), step.inputs.table.values()) |path, *files| {
-                    const reaction_set = rs: {
+                    const dir = dir: {
                         const gop = try w.dir_table.getOrPut(gpa, path);
                         if (!gop.found_existing) {
-                            const dir = try Os.Directory.init(gpa, path);
-                            errdefer dir.deinit(gpa);
+                            const dir: *Directory = try .init(gpa, path);
+                            errdefer dir.deinit(gpa, w);
                             // `dir.id` may already be present in the table in
                             // the case that we have multiple Cache.Path instances
                             // that compare inequal but ultimately point to the same
                             // directory on the file system.
                             // In such case, we must revert adding this directory, but keep
                             // the additions to the step set.
-                            const dh_gop = try w.os.handle_table.getOrPut(gpa, dir.id);
+                            const dh_gop = try w.os.handle_table.getOrPut(gpa, dir);
                             if (dh_gop.found_existing) {
-                                dir.deinit(gpa);
+                                dir.deinit(gpa, w);
                                 _ = w.dir_table.pop();
+                                break :dir w.os.handle_table.keys()[dh_gop.index];
                             } else {
                                 assert(dh_gop.index == gop.index);
-                                dh_gop.value_ptr.* = .{};
-                                try dir.startListening();
-                                const key = w.os.counter;
-                                w.os.counter +%= 1;
-                                try w.os.dir_list.put(gpa, key, dir);
-                                w.os.io_cp = try windows.CreateIoCompletionPort(
-                                    dir.handle,
-                                    w.os.io_cp,
-                                    key,
-                                    0,
-                                );
+                                try dir.startListening(w);
+                                break :dir dir;
                             }
-                            break :rs &w.os.handle_table.values()[dh_gop.index];
                         }
-                        break :rs &w.os.handle_table.values()[gop.index];
+                        break :dir w.os.handle_table.keys()[gop.index];
                     };
                     for (files.items) |basename| {
-                        const gop = try reaction_set.getOrPut(gpa, basename);
+                        const gop = try dir.reaction_set.getOrPut(gpa, basename);
                         if (!gop.found_existing) gop.value_ptr.* = .{};
                         try gop.value_ptr.put(gpa, step, w.generation);
                     }
@@ -562,11 +577,11 @@ const Os = switch (builtin.os.tag) {
                 // Remove marks for files that are no longer inputs.
                 var i: usize = 0;
                 while (i < w.os.handle_table.entries.len) {
+                    const dir = w.os.handle_table.keys()[i];
                     {
-                        const reaction_set = &w.os.handle_table.values()[i];
                         var step_set_i: usize = 0;
-                        while (step_set_i < reaction_set.entries.len) {
-                            const step_set = &reaction_set.values()[step_set_i];
+                        while (step_set_i < dir.reaction_set.entries.len) {
+                            const step_set = &dir.reaction_set.values()[step_set_i];
                             var dirent_i: usize = 0;
                             while (dirent_i < step_set.entries.len) {
                                 const generations = step_set.values();
@@ -580,53 +595,45 @@ const Os = switch (builtin.os.tag) {
                                 step_set_i += 1;
                                 continue;
                             }
-                            reaction_set.swapRemoveAt(step_set_i);
+                            dir.reaction_set.swapRemoveAt(step_set_i);
                         }
-                        if (reaction_set.entries.len > 0) {
+                        if (dir.reaction_set.entries.len > 0) {
                             i += 1;
                             continue;
                         }
                     }
 
-                    w.os.dir_list.values()[i].deinit(gpa);
-                    w.os.dir_list.swapRemoveAt(i);
                     w.dir_table.swapRemoveAt(i);
                     w.os.handle_table.swapRemoveAt(i);
+                    dir.deinit(gpa, w);
                 }
                 w.generation +%= 1;
             }
             w.dir_count = w.dir_table.count();
         }
 
-        fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
-            var bytes_transferred: std.os.windows.DWORD = undefined;
-            var key: usize = undefined;
-            var overlapped_ptr: ?*std.os.windows.OVERLAPPED = undefined;
-            return while (true) switch (std.os.windows.GetQueuedCompletionStatus(
-                w.os.io_cp.?,
-                &bytes_transferred,
-                &key,
-                &overlapped_ptr,
-                @bitCast(timeout.to_i32_ms()),
-            )) {
-                .Normal => {
-                    if (bytes_transferred == 0)
-                        break error.Unexpected;
-
-                    // This 'orelse' detects a race condition that happens when we receive a
-                    // completion notification for a directory that no longer exists in our list.
-                    const dir = w.os.dir_list.get(key) orelse break .clean;
-
-                    break if (try Os.markDirtySteps(w, gpa, dir))
-                        .dirty
-                    else
-                        .clean;
-                },
-                .Timeout => break .timeout,
-                // This status is issued because CancelIo was called, skip and try again.
-                .Canceled => continue,
-                else => break error.Unexpected,
-            };
+        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+            for (0..2) |attempt| {
+                while (w.os.ready_dirs.popFirst()) |ready_node| {
+                    const dir: *Directory = @fieldParentPtr("ready_node", ready_node);
+                    assert(dir.state == .ready);
+                    dir.state = .idle;
+                    switch (dir.iosb.u.Status) {
+                        .SUCCESS => return if (try markDirtySteps(w, gpa, dir)) .dirty else .clean,
+                        .PENDING => unreachable,
+                        .CANCELLED => {},
+                        else => |status| return windows.unexpectedStatus(status),
+                    }
+                    try dir.startListening(w);
+                }
+                try io.checkCancel();
+                if (attempt == 1) return .timeout;
+                const delay_interval: windows.LARGE_INTEGER = switch (timeout) {
+                    .none => std.math.minInt(windows.LARGE_INTEGER),
+                    .ms => |ms| -@as(windows.LARGE_INTEGER, ms) * (std.time.ns_per_ms / 100),
+                };
+                _ = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
+            } else unreachable;
         }
     },
     .dragonfly, .freebsd, .netbsd, .openbsd, .ios, .tvos, .visionos, .watchos => struct {
@@ -796,7 +803,8 @@ const Os = switch (builtin.os.tag) {
             w.dir_count = w.dir_table.count();
         }
 
-        fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
+        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+            _ = io;
             var timespec_buffer: posix.timespec = undefined;
             var event_buffer: [100]posix.Kevent = undefined;
             var n = try Io.Kqueue.kevent(w.os.kq_fd, &.{}, &event_buffer, timeout.toTimespec(&timespec_buffer));
@@ -852,7 +860,8 @@ const Os = switch (builtin.os.tag) {
             try w.os.fse.setPaths(gpa, steps);
             w.dir_count = w.os.fse.watch_roots.len;
         }
-        fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
+        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+            _ = io;
             return w.os.fse.wait(gpa, switch (timeout) {
                 .none => null,
                 .ms => |ms| @as(u64, ms) * std.time.ns_per_ms,
@@ -890,10 +899,13 @@ pub const Match = struct {
 };
 
 fn markAllFilesDirty(w: *Watch, gpa: Allocator) void {
-    for (w.os.handle_table.values()) |value| {
+    for (switch (builtin.os.tag) {
+        .windows => w.os.handle_table.keys(),
+        else => w.os.handle_table.values(),
+    }) |item| {
         const reaction_set = switch (builtin.os.tag) {
-            .linux => value.reaction_set,
-            else => value,
+            .linux, .windows => item.reaction_set,
+            else => item,
         };
         for (reaction_set.values()) |step_set| {
             for (step_set.keys()) |step| {
@@ -951,6 +963,6 @@ pub const WaitResult = enum {
     clean,
 };
 
-pub fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
-    return Os.wait(w, gpa, timeout);
+pub fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+    return Os.wait(w, gpa, io, timeout);
 }
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index f998466e6e4b2aac295f4f40bd1d64b676aca179..1f450d1dacd6d93992d885e92294d34d66202628 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -83,7 +83,7 @@ csprng: Csprng = .{},
 system_basic_information: SystemBasicInformation = .{},
 
 const SystemBasicInformation = if (!is_windows) struct {} else struct {
-    buffer: windows.SYSTEM_BASIC_INFORMATION = undefined,
+    buffer: windows.SYSTEM.BASIC_INFORMATION = undefined,
     initialized: std.atomic.Value(bool) = .{ .raw = false },
 };
 
@@ -1392,7 +1392,7 @@ const AlertableSyscall = struct {
     }
 };
 
-fn waitForApcOrAlert() void {
+pub fn waitForApcOrAlert() void {
     const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
     _ = windows.ntdll.NtDelayExecution(windows.TRUE, &infinite_timeout);
 }
@@ -2556,9 +2556,7 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
                 else => |e| e,
             },
         },
-        .device_io_control => |*o| return .{
-            .device_io_control = try deviceIoControl(t, o),
-        },
+        .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
     }
 }
 
@@ -2970,7 +2968,7 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
                     break :o;
                 }
                 const buffer = o.data[data_index];
-                const short_buffer_len = @min(std.math.maxInt(u32), buffer.len);
+                const short_buffer_len = std.math.lossyCast(u32, buffer.len);
 
                 if (o.file.flags.nonblocking) {
                     context.file = o.file.handle;
@@ -3259,22 +3257,11 @@ fn dirCreateDirWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, pe
     _ = t;
     _ = permissions; // TODO use this value
 
-    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
-    const sub_path_w = sub_path_w_array.span();
-    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
-
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-    const attr: windows.OBJECT_ATTRIBUTES = .{
-        .Length = @sizeOf(windows.OBJECT_ATTRIBUTES),
-        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .Attributes = .{
-            .INHERIT = false,
-        },
-        .ObjectName = &nt_name,
+    const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
+    const attr: windows.OBJECT.ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w.span())) null else dir.handle,
+        .Attributes = .{ .INHERIT = false },
+        .ObjectName = @constCast(&windows.UNICODE_STRING.init(sub_path_w.span())),
         .SecurityDescriptor = null,
         .SecurityQualityOfService = null,
     };
@@ -3438,21 +3425,14 @@ fn dirCreateDirPathOpenWindows(
     };
 
     components: while (true) {
-        const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, component.path);
-        const sub_path_w = sub_path_w_array.span();
+        const sub_path_w = try sliceToPrefixedFileW(dir.handle, component.path);
+        const attr: windows.OBJECT.ATTRIBUTES = .{
+            .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w.span())) null else dir.handle,
+            .ObjectName = @constCast(&sub_path_w.string()),
+        };
         const is_last = it.peekNext() == null;
-        const create_disposition: w.FILE.CREATE_DISPOSITION = if (is_last) .OPEN_IF else .CREATE;
-
         var result: Dir = .{ .handle = undefined };
-
-        const path_len_bytes: u16 = @intCast(sub_path_w.len * 2);
-        var nt_name: w.UNICODE_STRING = .{
-            .Length = path_len_bytes,
-            .MaximumLength = path_len_bytes,
-            .Buffer = @constCast(sub_path_w.ptr),
-        };
-        var io_status_block: w.IO_STATUS_BLOCK = undefined;
-
+        var iosb: w.IO_STATUS_BLOCK = undefined;
         const syscall: Syscall = try .start();
         while (true) switch (w.ntdll.NtCreateFile(
             &result.handle,
@@ -3468,15 +3448,12 @@ fn dirCreateDirPathOpenWindows(
                     .SYNCHRONIZE = true,
                 },
             },
-            &.{
-                .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-                .ObjectName = &nt_name,
-            },
-            &io_status_block,
+            &attr,
+            &iosb,
             null,
             .{ .NORMAL = true },
             .VALID_FLAGS,
-            create_disposition,
+            if (is_last) .OPEN_IF else .CREATE,
             .{
                 .DIRECTORY_FILE = true,
                 .IO = .SYNCHRONOUS_NONALERT,
@@ -3944,15 +3921,15 @@ fn fileStatWindows(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
     };
 }
 
-fn systemBasicInformation(t: *Threaded) ?*const windows.SYSTEM_BASIC_INFORMATION {
+fn systemBasicInformation(t: *Threaded) ?*const windows.SYSTEM.BASIC_INFORMATION {
     if (!t.system_basic_information.initialized.load(.acquire)) {
         mutexLock(&t.mutex);
         defer mutexUnlock(&t.mutex);
 
         switch (windows.ntdll.NtQuerySystemInformation(
-            .SystemBasicInformation,
+            .Basic,
             &t.system_basic_information.buffer,
-            @sizeOf(windows.SYSTEM_BASIC_INFORMATION),
+            @sizeOf(windows.SYSTEM.BASIC_INFORMATION),
             null,
         )) {
             .SUCCESS => {},
@@ -4139,22 +4116,11 @@ fn dirAccessWindows(
 
     _ = options; // TODO
 
-    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
-    const sub_path_w = sub_path_w_array.span();
-
-    if (sub_path_w[0] == '.' and sub_path_w[1] == 0) return;
-    if (sub_path_w[0] == '.' and sub_path_w[1] == '.' and sub_path_w[2] == 0) return;
-
-    const path_len_bytes = std.math.cast(u16, std.mem.sliceTo(sub_path_w, 0).len * 2) orelse
-        return error.NameTooLong;
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-    const attr: windows.OBJECT_ATTRIBUTES = .{
-        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .ObjectName = &nt_name,
+    if (std.mem.eql(u8, sub_path, ".") or std.mem.eql(u8, sub_path, "..")) return;
+    const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
+    const attr: windows.OBJECT.ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w.span())) null else dir.handle,
+        .ObjectName = @constCast(&sub_path_w.string()),
     };
     var basic_info: windows.FILE.BASIC_INFORMATION = undefined;
     const syscall: Syscall = try .start();
@@ -4360,18 +4326,10 @@ fn dirCreateFileWindows(
     if (std.mem.eql(u8, sub_path, ".")) return error.IsDir;
     if (std.mem.eql(u8, sub_path, "..")) return error.IsDir;
 
-    const sub_path_w_array = try sliceToPrefixedFileW(dir.handle, sub_path);
-    const sub_path_w = sub_path_w_array.span();
-    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
-
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-    const attr: windows.OBJECT_ATTRIBUTES = .{
-        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .ObjectName = &nt_name,
+    const sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
+    const attr: windows.OBJECT.ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w.span())) null else dir.handle,
+        .ObjectName = @constCast(&sub_path_w.string()),
     };
     const create_disposition: windows.FILE.CREATE_DISPOSITION = if (flags.exclusive)
         .CREATE
@@ -4966,20 +4924,14 @@ fn dirOpenFileWindows(
 
 pub fn dirOpenFileWtf16(
     dir_handle: ?windows.HANDLE,
-    sub_path_w: [:0]const u16,
+    sub_path_w: []const u16,
     flags: File.OpenFlags,
 ) File.OpenError!File {
     const allow_directory = flags.allow_directory and !flags.isWrite();
     if (!allow_directory and std.mem.eql(u16, sub_path_w, &.{'.'})) return error.IsDir;
     if (!allow_directory and std.mem.eql(u16, sub_path_w, &.{ '.', '.' })) return error.IsDir;
-    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
     const w = windows;
 
-    var nt_name: w.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
     var io_status_block: w.IO_STATUS_BLOCK = undefined;
     var attempt: u5 = 0;
     var syscall: Syscall = try .start();
@@ -4996,7 +4948,7 @@ pub fn dirOpenFileWtf16(
             },
             &.{
                 .RootDirectory = dir_handle,
-                .ObjectName = &nt_name,
+                .ObjectName = @constCast(&w.UNICODE_STRING.init(sub_path_w)),
             },
             &io_status_block,
             null,
@@ -5329,20 +5281,19 @@ fn dirOpenDirHaiku(
 
 pub fn dirOpenDirWindows(
     dir: Dir,
-    sub_path_w: [:0]const u16,
+    sub_path_w: []const u16,
     options: Dir.OpenOptions,
 ) Dir.OpenError!Dir {
     const w = windows;
 
-    const path_len_bytes: u16 = @intCast(sub_path_w.len * 2);
-    var nt_name: w.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
     var io_status_block: w.IO_STATUS_BLOCK = undefined;
     var result: Dir = .{ .handle = undefined };
 
+    const attr: w.OBJECT.ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
+        .ObjectName = @constCast(&w.UNICODE_STRING.init(sub_path_w)),
+    };
+
     const syscall: Syscall = try .start();
     while (true) switch (w.ntdll.NtCreateFile(
         &result.handle,
@@ -5359,10 +5310,7 @@ pub fn dirOpenDirWindows(
                 .SYNCHRONIZE = true,
             },
         },
-        &.{
-            .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-            .ObjectName = &nt_name,
-        },
+        &attr,
         &io_status_block,
         null,
         .{ .NORMAL = true },
@@ -6194,13 +6142,15 @@ pub fn GetFinalPathNameByHandle(
             input_struct.DeviceNameLength = @intCast(volume_name_u16.len * 2);
             @memcpy(input_buf[@sizeOf(windows.MOUNTMGR_MOUNT_POINT)..][0 .. volume_name_u16.len * 2], @as([*]const u8, @ptrCast(volume_name_u16.ptr)));
 
-            {
-                const rc = windows.DeviceIoControl(mgmt_handle, windows.IOCTL.MOUNTMGR.QUERY_POINTS, .{ .in = &input_buf, .out = &output_buf });
-                switch (rc) {
-                    .SUCCESS => {},
-                    .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
-                    else => return windows.unexpectedStatus(rc),
-                }
+            switch ((try deviceIoControl(&.{
+                .file = .{ .handle = mgmt_handle, .flags = .{ .nonblocking = false } },
+                .code = windows.IOCTL.MOUNTMGR.QUERY_POINTS,
+                .in = &input_buf,
+                .out = &output_buf,
+            })).u.Status) {
+                .SUCCESS => {},
+                .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
+                else => |status| return windows.unexpectedStatus(status),
             }
             const mount_points_struct: *const windows.MOUNTMGR_MOUNT_POINTS = @ptrCast(&output_buf[0]);
 
@@ -6251,11 +6201,15 @@ pub fn GetFinalPathNameByHandle(
                     vol_input_struct.DeviceNameLength = @intCast(symlink.len * 2);
                     @memcpy(@as([*]windows.WCHAR, &vol_input_struct.DeviceName)[0..symlink.len], symlink);
 
-                    const rc = windows.DeviceIoControl(mgmt_handle, windows.IOCTL.MOUNTMGR.QUERY_DOS_VOLUME_PATH, .{ .in = &vol_input_buf, .out = &vol_output_buf });
-                    switch (rc) {
+                    switch ((try deviceIoControl(&.{
+                        .file = .{ .handle = mgmt_handle, .flags = .{ .nonblocking = true } },
+                        .code = windows.IOCTL.MOUNTMGR.QUERY_DOS_VOLUME_PATH,
+                        .in = &vol_input_buf,
+                        .out = &vol_output_buf,
+                    })).u.Status) {
                         .SUCCESS => {},
                         .UNRECOGNIZED_VOLUME => return error.UnrecognizedVolume,
-                        else => return windows.unexpectedStatus(rc),
+                        else => |status| return windows.unexpectedStatus(status),
                     }
                     const volume_paths_struct: *const windows.MOUNTMGR_VOLUME_PATHS = @ptrCast(&vol_output_buf[0]);
                     const volume_path = std.mem.sliceTo(@as(
@@ -6352,20 +6306,17 @@ pub const QueryObjectNameError = error{
 };
 
 pub fn QueryObjectName(handle: windows.HANDLE, out_buffer: []u16) QueryObjectNameError![]u16 {
-    const out_buffer_aligned = std.mem.alignInSlice(out_buffer, @alignOf(windows.OBJECT_NAME_INFORMATION)) orelse return error.NameTooLong;
+    const out_buffer_aligned = std.mem.alignInSlice(out_buffer, @alignOf(windows.OBJECT.NAME_INFORMATION)) orelse return error.NameTooLong;
 
-    const info: *windows.OBJECT_NAME_INFORMATION = @ptrCast(out_buffer_aligned);
+    const info: *windows.OBJECT.NAME_INFORMATION = @ptrCast(out_buffer_aligned);
     // buffer size is specified in bytes
     const out_buffer_len = std.math.cast(windows.ULONG, out_buffer_aligned.len * 2) orelse std.math.maxInt(windows.ULONG);
     // last argument would return the length required for full_buffer, not exposed here
-    return switch (windows.ntdll.NtQueryObject(handle, .ObjectNameInformation, info, out_buffer_len, null)) {
-        .SUCCESS => blk: {
-            // info.Name.Buffer from ObQueryNameString is documented to be null (and MaximumLength == 0)
-            // if the object was "unnamed", not sure if this can happen for file handles
-            if (info.Name.MaximumLength == 0) break :blk error.Unexpected;
-            // resulting string length is specified in bytes
-            const path_length_unterminated = @divExact(info.Name.Length, 2);
-            break :blk info.Name.Buffer.?[0..path_length_unterminated];
+    return switch (windows.ntdll.NtQueryObject(handle, .Name, info, out_buffer_len, null)) {
+        .SUCCESS => {
+            // info.Name from ObQueryNameString is documented to be empty if the object
+            // was "unnamed", not sure if this can happen for file handles
+            return if (info.Name.isEmpty()) error.Unexpected else info.Name.slice();
         },
         .ACCESS_DENIED => error.AccessDenied,
         .INVALID_HANDLE => error.InvalidHandle,
@@ -6620,8 +6571,12 @@ pub const WindowsPathSpace = struct {
     data: [windows.PATH_MAX_WIDE:0]u16,
     len: usize,
 
-    pub fn span(self: *const WindowsPathSpace) [:0]const u16 {
-        return self.data[0..self.len :0];
+    pub fn span(wps: *const WindowsPathSpace) [:0]const u16 {
+        return wps.data[0..wps.len :0];
+    }
+
+    pub fn string(wps: *const WindowsPathSpace) windows.UNICODE_STRING {
+        return .init(wps.span());
     }
 };
 
@@ -7076,25 +7031,19 @@ fn dirDeleteWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, remov
     _ = t;
     const w = windows;
 
-    const sub_path_w_buf = try sliceToPrefixedFileW(dir.handle, sub_path);
-    const sub_path_w = sub_path_w_buf.span();
-
-    const path_len_bytes = @as(u16, @intCast(sub_path_w.len * 2));
-    var nt_name: w.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        // The Windows API makes this mutable, but it will not mutate here.
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-
-    if (sub_path_w[0] == '.' and sub_path_w[1] == 0) {
-        // Windows does not recognize this, but it does work with empty string.
-        nt_name.Length = 0;
-    }
-    if (sub_path_w[0] == '.' and sub_path_w[1] == '.' and sub_path_w[2] == 0) {
+    if (std.mem.eql(u8, sub_path, "..")) {
         // Can't remove the parent directory with an open handle.
         return error.FileBusy;
     }
+    var sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
+    if (std.mem.eql(u8, sub_path, ".")) {
+        // Windows does not recognize this, but it does work with empty string.
+        sub_path_w.len = 0;
+    }
+    const attr: w.OBJECT.ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w.span())) null else dir.handle,
+        .ObjectName = @constCast(&sub_path_w.string()),
+    };
 
     var io_status_block: w.IO_STATUS_BLOCK = undefined;
     var tmp_handle: w.HANDLE = undefined;
@@ -7106,10 +7055,7 @@ fn dirDeleteWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, remov
                 .RIGHTS = .{ .DELETE = true },
                 .SYNCHRONIZE = true,
             } },
-            &.{
-                .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-                .ObjectName = &nt_name,
-            },
+            &attr,
             &io_status_block,
             null,
             .{},
@@ -7741,7 +7687,7 @@ fn dirSymLinkWindows(
     // https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createsymboliclinkw
     var is_target_absolute = false;
     const final_target_path = target_path: {
-        if (windows.hasCommonNtPrefix(u16, target_path_w.span())) {
+        if (w.hasCommonNtPrefix(u16, target_path_w.span())) {
             // Already an NT path, no need to do anything to it
             break :target_path target_path_w.span();
         } else {
@@ -7785,13 +7731,16 @@ fn dirSymLinkWindows(
     @memcpy(buffer[@sizeOf(SYMLINK_DATA)..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
     const paths_start = @sizeOf(SYMLINK_DATA) + final_target_path.len * 2;
     @memcpy(buffer[paths_start..][0 .. final_target_path.len * 2], @as([*]const u8, @ptrCast(final_target_path)));
-    const rc = w.DeviceIoControl(symlink_handle, .SET_REPARSE_POINT, .{ .in = buffer[0..buf_len] });
-    switch (rc) {
+    switch ((try deviceIoControl(&.{
+        .file = .{ .handle = symlink_handle, .flags = .{ .nonblocking = false } },
+        .code = .SET_REPARSE_POINT,
+        .in = buffer[0..buf_len],
+    })).u.Status) {
         .SUCCESS => {},
         .PRIVILEGE_NOT_HELD => return error.PermissionDenied,
         .ACCESS_DENIED => return error.AccessDenied,
         .INVALID_DEVICE_REQUEST => return error.FileSystem,
-        else => return windows.unexpectedStatus(rc),
+        else => |status| return w.unexpectedStatus(status),
     }
 }
 
@@ -7905,17 +7854,10 @@ fn dirReadLink(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []
 fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
     // This gets used once for `sub_path` and then reused again temporarily
     // before converting back to `buffer`.
-    var sub_path_w_buf = try sliceToPrefixedFileW(dir.handle, sub_path);
-    const sub_path_w = sub_path_w_buf.span();
-    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-    const attr: windows.OBJECT_ATTRIBUTES = .{
-        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else dir.handle,
-        .ObjectName = &nt_name,
+    var sub_path_w = try sliceToPrefixedFileW(dir.handle, sub_path);
+    const attr: windows.OBJECT.ATTRIBUTES = .{
+        .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w.span())) null else dir.handle,
+        .ObjectName = @constCast(&sub_path_w.string()),
     };
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var result_handle: windows.HANDLE = undefined;
@@ -8038,14 +7980,14 @@ fn dirReadLinkWindows(dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLink
             const len = buf.SubstituteNameLength >> 1;
             const path_buf = @as([*]const u16, &buf.PathBuffer);
             const is_relative = buf.Flags & windows.SYMLINK_FLAG_RELATIVE != 0;
-            break :r try parseReadLinkPath(path_buf[offset..][0..len], is_relative, &sub_path_w_buf.data);
+            break :r try parseReadLinkPath(path_buf[offset..][0..len], is_relative, &sub_path_w.data);
         },
         @as(IoReparseTagInt, @bitCast(windows.IO_REPARSE_TAG.MOUNT_POINT)) => r: {
             const buf: *const windows.MOUNT_POINT_REPARSE_BUFFER = @ptrCast(@alignCast(&reparse_struct.DataBuffer[0]));
             const offset = buf.SubstituteNameOffset >> 1;
             const len = buf.SubstituteNameLength >> 1;
             const path_buf = @as([*]const u16, &buf.PathBuffer);
-            break :r try parseReadLinkPath(path_buf[offset..][0..len], false, &sub_path_w_buf.data);
+            break :r try parseReadLinkPath(path_buf[offset..][0..len], false, &sub_path_w.data);
         },
         else => return error.UnsupportedReparsePointType,
     };
@@ -8541,13 +8483,14 @@ fn fileSyncWasi(userdata: ?*anyopaque, file: File) File.SyncError!void {
 
 fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    return t.isTty(file);
+    _ = t;
+    return isTty(file);
 }
 
-fn isTty(t: *Threaded, file: File) Io.Cancelable!bool {
+fn isTty(file: File) Io.Cancelable!bool {
     if (is_windows) {
         var get_console_mode = windows.CONSOLE.USER_IO.GET_MODE;
-        switch ((try t.deviceIoControl(&.{
+        switch ((try deviceIoControl(&.{
             .file = .{
                 .handle = windows.peb().ProcessParameters.ConsoleHandle,
                 .flags = .{ .nonblocking = false },
@@ -8626,8 +8569,9 @@ fn isTty(t: *Threaded, file: File) Io.Cancelable!bool {
 
 fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
 
-    if (!is_windows) return if (!try t.supportsAnsiEscapeCodes(file)) error.NotTerminalDevice;
+    if (!is_windows) return if (!try supportsAnsiEscapeCodes(file)) error.NotTerminalDevice;
 
     // For Windows Terminal, VT Sequences processing is enabled by default.
     const console: File = .{
@@ -8635,7 +8579,7 @@ fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiE
         .flags = .{ .nonblocking = false },
     };
     var get_console_mode = windows.CONSOLE.USER_IO.GET_MODE;
-    switch ((try t.deviceIoControl(&.{
+    switch ((try deviceIoControl(&.{
         .file = console,
         .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
         .in = @ptrCast(&get_console_mode.request(file, 0, .{}, 0, .{})),
@@ -8661,7 +8605,7 @@ fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiE
     var set_console_mode = windows.CONSOLE.USER_IO.SET_MODE(
         get_console_mode.Data | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING,
     );
-    switch ((try t.deviceIoControl(&.{
+    switch ((try deviceIoControl(&.{
         .file = console,
         .code = windows.IOCTL.CONDRV.ISSUE_USER_IO,
         .in = @ptrCast(&set_console_mode.request(file, 0, .{}, 0, .{})),
@@ -8673,13 +8617,14 @@ fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiE
 
 fn fileSupportsAnsiEscapeCodes(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    return t.supportsAnsiEscapeCodes(file);
+    _ = t;
+    return supportsAnsiEscapeCodes(file);
 }
 
-fn supportsAnsiEscapeCodes(t: *Threaded, file: File) Io.Cancelable!bool {
+fn supportsAnsiEscapeCodes(file: File) Io.Cancelable!bool {
     if (is_windows) {
         var get_console_mode = windows.CONSOLE.USER_IO.GET_MODE;
-        switch ((try t.deviceIoControl(&.{
+        switch ((try deviceIoControl(&.{
             .file = .{
                 .handle = windows.peb().ProcessParameters.ConsoleHandle,
                 .flags = .{ .nonblocking = false },
@@ -8701,7 +8646,7 @@ fn supportsAnsiEscapeCodes(t: *Threaded, file: File) Io.Cancelable!bool {
         return false;
     }
 
-    if (try t.isTty(file)) return true;
+    if (try isTty(file)) return true;
 
     return false;
 }
@@ -8775,7 +8720,7 @@ fn isCygwinPty(file: File) Io.Cancelable!bool {
         },
     };
 
-    const name_info: *const windows.FILE_NAME_INFO = @ptrCast(&name_info_bytes);
+    const name_info: *const windows.FILE.NAME_INFORMATION = @ptrCast(&name_info_bytes);
     const name_bytes = name_info_bytes[name_bytes_offset .. name_bytes_offset + name_info.FileNameLength];
     const name_wide = std.mem.bytesAsSlice(u16, name_bytes);
     // The name we get from NtQueryInformationFile will be prefixed with a '\', e.g. \msys-1888ae32e00d56aa-pty0-to-master
@@ -9002,49 +8947,38 @@ fn fileSetTimestamps(
     _ = t;
 
     if (is_windows) {
-        var access_time_buffer: windows.FILETIME = undefined;
-        var modify_time_buffer: windows.FILETIME = undefined;
-        var system_time_buffer: windows.LARGE_INTEGER = undefined;
-
-        if (options.access_timestamp == .now or options.modify_timestamp == .now) {
-            system_time_buffer = windows.ntdll.RtlGetSystemTimePrecise();
-        }
-
-        const access_ptr = switch (options.access_timestamp) {
-            .unchanged => null,
-            .now => @panic("TODO do SystemTimeToFileTime logic here"),
-            .new => |ts| p: {
-                access_time_buffer = windows.nanoSecondsToFileTime(ts);
-                break :p &access_time_buffer;
+        const now_sys = if (options.access_timestamp == .now or options.modify_timestamp == .now)
+            windows.ntdll.RtlGetSystemTimePrecise()
+        else
+            undefined;
+        var iosb: windows.IO_STATUS_BLOCK = undefined;
+        var info: windows.FILE.BASIC_INFORMATION = .{
+            .CreationTime = 0,
+            .LastAccessTime = switch (options.access_timestamp) {
+                .unchanged => 0,
+                .now => now_sys,
+                .new => |ts| windows.toSysTime(ts),
             },
-        };
-
-        const modify_ptr = switch (options.modify_timestamp) {
-            .unchanged => null,
-            .now => @panic("TODO do SystemTimeToFileTime logic here"),
-            .new => |ts| p: {
-                modify_time_buffer = windows.nanoSecondsToFileTime(ts);
-                break :p &modify_time_buffer;
+            .LastWriteTime = switch (options.modify_timestamp) {
+                .unchanged => 0,
+                .now => now_sys,
+                .new => |ts| windows.toSysTime(ts),
             },
+            .ChangeTime = 0,
+            .FileAttributes = .{},
+        };
+        var syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtSetInformationFile(
+            file.handle,
+            &iosb,
+            &info,
+            @sizeOf(windows.FILE.BASIC_INFORMATION),
+            .Basic,
+        )) {
+            .SUCCESS => return syscall.finish(),
+            .CANCELLED => try syscall.checkCancel(),
+            else => |status| return syscall.unexpectedNtstatus(status),
         };
-
-        // https://github.com/ziglang/zig/issues/1840
-        const syscall: Syscall = try .start();
-        while (true) {
-            switch (windows.kernel32.SetFileTime(file.handle, null, access_ptr, modify_ptr)) {
-                0 => switch (windows.GetLastError()) {
-                    .OPERATION_ABORTED => {
-                        try syscall.checkCancel();
-                        continue;
-                    },
-                    else => |err| {
-                        syscall.finish();
-                        return windows.unexpectedError(err);
-                    },
-                },
-                else => return syscall.finish(),
-            }
-        }
     }
 
     if (native_os == .wasi and !builtin.link_libc) {
@@ -9636,15 +9570,43 @@ fn fileReadStreamingPosix(file: File, data: []const []u8) File.ReadStreamingErro
 }
 
 fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingError!usize {
+    var iosb: windows.IO_STATUS_BLOCK = undefined;
     var index: usize = 0;
     while (data.len - index != 0 and data[index].len == 0) index += 1;
     if (data.len - index == 0) return 0;
     const buffer = data[index];
-    const short_buffer_len = @min(std.math.maxInt(u32), buffer.len);
-
-    var iosb: windows.IO_STATUS_BLOCK = undefined;
-
-    if (!file.flags.nonblocking) {
+    const short_buffer_len = std.math.lossyCast(u32, buffer.len);
+    if (file.flags.nonblocking) {
+        var done: bool = false;
+        switch (windows.ntdll.NtReadFile(
+            file.handle,
+            null, // event
+            flagApc,
+            &done, // APC context
+            &iosb,
+            buffer.ptr,
+            short_buffer_len,
+            null, // byte offset
+            null, // key
+        )) {
+            // We must wait for the APC routine.
+            .PENDING, .SUCCESS => while (!done) {
+                // Once we get here we must not return from the function until the
+                // operation completes, thereby releasing reference to the iosb.
+                const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                    error.Canceled => |e| {
+                        var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                        _ = windows.ntdll.NtCancelIoFileEx(file.handle, &iosb, &cancel_iosb);
+                        while (!done) waitForApcOrAlert();
+                        return e;
+                    },
+                };
+                waitForApcOrAlert();
+                alertable_syscall.finish();
+            },
+            else => |status| iosb.u.Status = status,
+        }
+    } else {
         const syscall: Syscall = try .start();
         while (true) switch (windows.ntdll.NtReadFile(
             file.handle,
@@ -9665,41 +9627,10 @@ fn fileReadStreamingWindows(file: File, data: []const []u8) File.ReadStreamingEr
             else => |status| {
                 syscall.finish();
                 iosb.u.Status = status;
-                return ntReadFileResult(&iosb);
+                break;
             },
         };
     }
-
-    var done: bool = false;
-
-    switch (windows.ntdll.NtReadFile(
-        file.handle,
-        null, // event
-        flagApc,
-        &done, // APC context
-        &iosb,
-        buffer.ptr,
-        short_buffer_len,
-        null, // byte offset
-        null, // key
-    )) {
-        // We must wait for the APC routine.
-        .PENDING, .SUCCESS => while (!done) {
-            // Once we get here we must not return from the function until the
-            // operation completes, thereby releasing reference to io_status_block.
-            const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
-                error.Canceled => |e| {
-                    var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
-                    _ = windows.ntdll.NtCancelIoFileEx(file.handle, &iosb, &cancel_iosb);
-                    while (!done) waitForApcOrAlert();
-                    return e;
-                },
-            };
-            waitForApcOrAlert();
-            alertable_syscall.finish();
-        },
-        else => |status| iosb.u.Status = status,
-    }
     return ntReadFileResult(&iosb);
 }
 
@@ -9714,8 +9645,9 @@ fn ntReadFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
         .CANCELLED => unreachable,
         .SUCCESS => return io_status_block.Information,
         .END_OF_FILE, .PIPE_BROKEN => return error.EndOfStream,
+        .INVALID_HANDLE => return error.NotOpenForReading,
         .INVALID_DEVICE_REQUEST => return error.IsDir,
-        .LOCK_NOT_GRANTED => return error.LockViolation,
+        .FILE_LOCK_CONFLICT => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
         else => |status| return windows.unexpectedStatus(status),
     }
@@ -9731,7 +9663,7 @@ fn ntWriteFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
         .QUOTA_EXCEEDED => return error.SystemResources,
         .PIPE_BROKEN => return error.BrokenPipe,
         .INVALID_HANDLE => return error.NotOpenForWriting,
-        .LOCK_NOT_GRANTED => return error.LockViolation,
+        .FILE_LOCK_CONFLICT => return error.LockViolation,
         .ACCESS_DENIED => return error.AccessDenied,
         .WORKING_SET_QUOTA => return error.SystemResources,
         .DISK_FULL => return error.NoSpaceLeft,
@@ -9740,8 +9672,6 @@ fn ntWriteFileResult(io_status_block: *const windows.IO_STATUS_BLOCK) !usize {
 }
 
 fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
-    if (!have_preadv) @compileError("TODO implement fileReadPositionalPosix for cursed operating systems that don't support preadv (it's only Haiku)");
-
     var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
     var i: usize = 0;
     for (data) |buf| {
@@ -9787,9 +9717,44 @@ fn fileReadPositionalPosix(file: File, data: []const []u8, offset: u64) File.Rea
         }
     }
 
+    if (have_preadv) {
+        const syscall: Syscall = try .start();
+        while (true) {
+            const rc = preadv_sym(file.handle, dest.ptr, @intCast(dest.len), @bitCast(offset));
+            switch (posix.errno(rc)) {
+                .SUCCESS => {
+                    syscall.finish();
+                    return @bitCast(rc);
+                },
+                .INTR, .TIMEDOUT => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                .NXIO => return syscall.fail(error.Unseekable),
+                .SPIPE => return syscall.fail(error.Unseekable),
+                .OVERFLOW => return syscall.fail(error.Unseekable),
+                .NOBUFS => return syscall.fail(error.SystemResources),
+                .NOMEM => return syscall.fail(error.SystemResources),
+                .AGAIN => return syscall.fail(error.WouldBlock),
+                .IO => return syscall.fail(error.InputOutput),
+                .ISDIR => return syscall.fail(error.IsDir),
+                .NOTCONN => |err| return syscall.errnoBug(err), // not a socket
+                .CONNRESET => |err| return syscall.errnoBug(err), // not a socket
+                .INVAL => |err| return syscall.errnoBug(err),
+                .FAULT => |err| return syscall.errnoBug(err),
+                .BADF => {
+                    syscall.finish();
+                    if (native_os == .wasi) return error.IsDir; // File operation on directory.
+                    return error.NotOpenForReading;
+                },
+                else => |err| return syscall.unexpectedErrno(err),
+            }
+        }
+    }
+
     const syscall: Syscall = try .start();
     while (true) {
-        const rc = preadv_sym(file.handle, dest.ptr, @intCast(dest.len), @bitCast(offset));
+        const rc = posix.pread(file.handle, dest[0].ptr, @intCast(dest[0].len), @bitCast(offset));
         switch (posix.errno(rc)) {
             .SUCCESS => {
                 syscall.finish();
@@ -9838,116 +9803,119 @@ fn fileReadPositionalWindows(file: File, data: []const []u8, offset: u64) File.R
 }
 
 fn readFilePositionalWindows(file: File, buffer: []u8, offset: u64) File.ReadPositionalError!usize {
-    const DWORD = windows.DWORD;
-    const want_read_count: DWORD = @min(std.math.maxInt(DWORD), buffer.len);
-    var overlapped: windows.OVERLAPPED = .{
-        .Internal = 0,
-        .InternalHigh = 0,
-        .DUMMYUNIONNAME = .{
-            .DUMMYSTRUCTNAME = .{
-                .Offset = @truncate(offset),
-                .OffsetHigh = @truncate(offset >> 32),
+    var iosb: windows.IO_STATUS_BLOCK = undefined;
+    const short_buffer_len = std.math.lossyCast(u32, buffer.len);
+    const signed_offset: windows.LARGE_INTEGER = @intCast(offset);
+    if (file.flags.nonblocking) {
+        var done: bool = false;
+        switch (windows.ntdll.NtReadFile(
+            file.handle,
+            null, // event
+            flagApc,
+            &done, // APC context
+            &iosb,
+            buffer.ptr,
+            short_buffer_len,
+            &signed_offset,
+            null, // key
+        )) {
+            // We must wait for the APC routine.
+            .PENDING, .SUCCESS => while (!done) {
+                // Once we get here we must not return from the function until the
+                // operation completes, thereby releasing reference to the iosb.
+                const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                    error.Canceled => |e| {
+                        var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                        _ = windows.ntdll.NtCancelIoFileEx(file.handle, &iosb, &cancel_iosb);
+                        while (!done) waitForApcOrAlert();
+                        return e;
+                    },
+                };
+                waitForApcOrAlert();
+                alertable_syscall.finish();
             },
-        },
-        .hEvent = null,
-    };
-
-    const syscall: Syscall = try .start();
-    while (true) {
-        var n: DWORD = undefined;
-        if (windows.kernel32.ReadFile(file.handle, buffer.ptr, want_read_count, &n, &overlapped) != 0) {
-            syscall.finish();
-            return n;
+            else => |status| iosb.u.Status = status,
         }
-        switch (windows.GetLastError()) {
-            .IO_PENDING => |err| {
+    } else {
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtReadFile(
+            file.handle,
+            null, // event
+            null, // APC routine
+            null, // APC context
+            &iosb,
+            buffer.ptr,
+            short_buffer_len,
+            &signed_offset,
+            null, // key
+        )) {
+            .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+            .CANCELLED => try syscall.checkCancel(),
+            else => |status| {
                 syscall.finish();
-                return windows.errorBug(err);
+                iosb.u.Status = status;
+                break;
             },
-            .OPERATION_ABORTED => {
-                try syscall.checkCancel();
-                continue;
-            },
-            .BROKEN_PIPE, .HANDLE_EOF => {
-                syscall.finish();
-                return 0;
-            },
-            .NETNAME_DELETED => if (is_debug) unreachable else return error.Unexpected,
-            .LOCK_VIOLATION => return syscall.fail(error.LockViolation),
-            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-            .INVALID_HANDLE => if (is_debug) unreachable else return error.Unexpected,
-            // TODO: Determine if INVALID_FUNCTION is possible in more scenarios than just passing
-            // a handle to a directory.
-            .INVALID_FUNCTION => return syscall.fail(error.IsDir),
-            else => |err| {
-                syscall.finish();
-                return windows.unexpectedError(err);
-            },
-        }
+        };
     }
+    return ntReadFileResult(&iosb) catch |err| switch (err) {
+        error.EndOfStream => 0,
+        else => |e| e,
+    };
 }
 
 fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    const fd = file.handle;
-
-    if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
-        var result: u64 = undefined;
-        const syscall: Syscall = try .start();
-        while (true) {
-            switch (posix.errno(posix.system.llseek(fd, @bitCast(offset), &result, posix.SEEK.CUR))) {
-                .SUCCESS => {
-                    syscall.finish();
-                    return;
-                },
-                .INTR => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                else => |e| {
-                    syscall.finish();
-                    switch (e) {
-                        .BADF => |err| return errnoBug(err), // File descriptor used after closed.
-                        .INVAL => return error.Unseekable,
-                        .OVERFLOW => return error.Unseekable,
-                        .SPIPE => return error.Unseekable,
-                        .NXIO => return error.Unseekable,
-                        else => |err| return posix.unexpectedErrno(err),
-                    }
-                },
-            }
-        }
-    }
 
     if (is_windows) {
+        var iosb: windows.IO_STATUS_BLOCK = undefined;
+        var info: windows.FILE.POSITION_INFORMATION = undefined;
         const syscall: Syscall = try .start();
-        while (true) {
-            if (windows.kernel32.SetFilePointerEx(fd, offset, null, windows.FILE_CURRENT) != 0) {
-                return syscall.finish();
-            }
-            switch (windows.GetLastError()) {
-                .OPERATION_ABORTED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                .INVALID_FUNCTION => return syscall.fail(error.Unseekable),
-                .NEGATIVE_SEEK => return syscall.fail(error.Unseekable),
-                .INVALID_PARAMETER => unreachable,
-                .INVALID_HANDLE => unreachable,
-                else => |err| {
-                    syscall.finish();
-                    return windows.unexpectedError(err);
-                },
-            }
-        }
+        while (true) switch (windows.ntdll.NtQueryInformationFile(
+            file.handle,
+            &iosb,
+            &info,
+            @sizeOf(windows.FILE.POSITION_INFORMATION),
+            .Position,
+        )) {
+            .SUCCESS => break,
+            .CANCELLED => try syscall.checkCancel(),
+            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .PIPE_NOT_AVAILABLE => return syscall.fail(error.Unseekable),
+            else => |status| return syscall.unexpectedNtstatus(status),
+        };
+        info.CurrentByteOffset = @bitCast((if (offset >= 0) std.math.add(
+            u64,
+            @bitCast(info.CurrentByteOffset),
+            @intCast(offset),
+        ) else std.math.sub(
+            u64,
+            @bitCast(info.CurrentByteOffset),
+            @intCast(-offset),
+        )) catch |err| switch (err) {
+            error.Overflow => return syscall.fail(error.Unseekable),
+        });
+        while (true) switch (windows.ntdll.NtSetInformationFile(
+            file.handle,
+            &iosb,
+            &info,
+            @sizeOf(windows.FILE.POSITION_INFORMATION),
+            .Position,
+        )) {
+            .SUCCESS => return syscall.finish(),
+            .CANCELLED => try syscall.checkCancel(),
+            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .PIPE_NOT_AVAILABLE => return syscall.fail(error.Unseekable),
+            else => |status| return syscall.unexpectedNtstatus(status),
+        };
     }
 
     if (native_os == .wasi and !builtin.link_libc) {
         var new_offset: std.os.wasi.filesize_t = undefined;
         const syscall: Syscall = try .start();
         while (true) {
-            switch (std.os.wasi.fd_seek(fd, offset, .CUR, &new_offset)) {
+            switch (std.os.wasi.fd_seek(file.handle, offset, .CUR, &new_offset)) {
                 .SUCCESS => {
                     syscall.finish();
                     return;
@@ -9974,9 +9942,37 @@ fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!voi
 
     if (posix.SEEK == void) return error.Unseekable;
 
+    if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
+        var result: u64 = undefined;
+        const syscall: Syscall = try .start();
+        while (true) {
+            switch (posix.errno(posix.system.llseek(file.handle, @bitCast(offset), &result, posix.SEEK.CUR))) {
+                .SUCCESS => {
+                    syscall.finish();
+                    return;
+                },
+                .INTR => {
+                    try syscall.checkCancel();
+                    continue;
+                },
+                else => |e| {
+                    syscall.finish();
+                    switch (e) {
+                        .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+                        .INVAL => return error.Unseekable,
+                        .OVERFLOW => return error.Unseekable,
+                        .SPIPE => return error.Unseekable,
+                        .NXIO => return error.Unseekable,
+                        else => |err| return posix.unexpectedErrno(err),
+                    }
+                },
+            }
+        }
+    }
+
     const syscall: Syscall = try .start();
     while (true) {
-        switch (posix.errno(lseek_sym(fd, offset, posix.SEEK.CUR))) {
+        switch (posix.errno(lseek_sym(file.handle, offset, posix.SEEK.CUR))) {
             .SUCCESS => {
                 syscall.finish();
                 return;
@@ -10003,41 +9999,31 @@ fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!voi
 fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    const fd = file.handle;
 
     if (is_windows) {
-        // "The starting point is zero or the beginning of the file. If [FILE_BEGIN]
-        // is specified, then the liDistanceToMove parameter is interpreted as an unsigned value."
-        // https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-setfilepointerex
-        const ipos: windows.LARGE_INTEGER = @bitCast(offset);
-
+        var iosb: windows.IO_STATUS_BLOCK = undefined;
+        var info: windows.FILE.POSITION_INFORMATION = .{ .CurrentByteOffset = @bitCast(offset) };
         const syscall: Syscall = try .start();
-        while (true) {
-            if (windows.kernel32.SetFilePointerEx(fd, ipos, null, windows.FILE_BEGIN) != 0) {
-                return syscall.finish();
-            }
-            switch (windows.GetLastError()) {
-                .OPERATION_ABORTED => {
-                    try syscall.checkCancel();
-                    continue;
-                },
-                .INVALID_FUNCTION => return syscall.fail(error.Unseekable),
-                .NEGATIVE_SEEK => return syscall.fail(error.Unseekable),
-                .INVALID_PARAMETER => unreachable,
-                .INVALID_HANDLE => unreachable,
-                else => |err| {
-                    syscall.finish();
-                    return windows.unexpectedError(err);
-                },
-            }
-        }
+        while (true) switch (windows.ntdll.NtSetInformationFile(
+            file.handle,
+            &iosb,
+            &info,
+            @sizeOf(windows.FILE.POSITION_INFORMATION),
+            .Position,
+        )) {
+            .SUCCESS => return syscall.finish(),
+            .CANCELLED => try syscall.checkCancel(),
+            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .PIPE_NOT_AVAILABLE => return syscall.fail(error.Unseekable),
+            else => |status| return syscall.unexpectedNtstatus(status),
+        };
     }
 
     if (native_os == .wasi and !builtin.link_libc) {
         const syscall: Syscall = try .start();
         while (true) {
             var new_offset: std.os.wasi.filesize_t = undefined;
-            switch (std.os.wasi.fd_seek(fd, @bitCast(offset), .SET, &new_offset)) {
+            switch (std.os.wasi.fd_seek(file.handle, @bitCast(offset), .SET, &new_offset)) {
                 .SUCCESS => {
                     syscall.finish();
                     return;
@@ -10064,7 +10050,7 @@ fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!voi
 
     if (posix.SEEK == void) return error.Unseekable;
 
-    return posixSeekTo(fd, offset);
+    return posixSeekTo(file.handle, offset);
 }
 
 fn posixSeekTo(fd: posix.fd_t, offset: u64) File.SeekError!void {
@@ -10131,8 +10117,7 @@ fn processExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) process.O
             // If ImagePathName is a symlink, then it will contain the path of the symlink,
             // not the path that the symlink points to. However, because we are opening
             // the file, we can let the openFileW call follow the symlink for us.
-            const image_path_unicode_string = &windows.peb().ProcessParameters.ImagePathName;
-            const image_path_name = image_path_unicode_string.Buffer.?[0 .. image_path_unicode_string.Length / 2 :0];
+            const image_path_name = windows.peb().ProcessParameters.ImagePathName.sliceZ();
             const prefixed_path_w = try wToPrefixedFileW(null, image_path_name);
             return dirOpenFileWtf16(null, prefixed_path_w.span(), flags);
         },
@@ -10334,14 +10319,13 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             return error.FileNotFound;
         },
         .windows => {
-            const w = windows;
-            const image_path_unicode_string = &w.peb().ProcessParameters.ImagePathName;
-            const image_path_name = image_path_unicode_string.Buffer.?[0 .. image_path_unicode_string.Length / 2 :0];
-
             // If ImagePathName is a symlink, then it will contain the path of the
             // symlink, not the path that the symlink points to. We want the path
             // that the symlink points to, though, so we need to get the realpath.
-            var path_name_w_buf = try wToPrefixedFileW(null, image_path_name);
+            var path_name_w_buf = try wToPrefixedFileW(
+                null,
+                windows.peb().ProcessParameters.ImagePathName.sliceZ(),
+            );
 
             const h_file = handle: {
                 if (OpenFile(path_name_w_buf.span(), .{
@@ -10360,7 +10344,7 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
                     else => |e| return e,
                 }
             };
-            defer w.CloseHandle(h_file);
+            defer windows.CloseHandle(h_file);
 
             const wide_slice = try GetFinalPathNameByHandle(h_file, .{}, &path_name_w_buf.data);
 
@@ -10388,15 +10372,15 @@ fn fileWritePositional(
 
     if (is_windows) {
         if (header.len != 0) {
-            return writeFilePositionalWindows(file.handle, header, offset);
+            return writeFilePositionalWindows(file, header, offset);
         }
         for (data[0 .. data.len - 1]) |buf| {
             if (buf.len == 0) continue;
-            return writeFilePositionalWindows(file.handle, buf, offset);
+            return writeFilePositionalWindows(file, buf, offset);
         }
         const pattern = data[data.len - 1];
         if (pattern.len == 0 or splat == 0) return 0;
-        return writeFilePositionalWindows(file.handle, pattern, offset);
+        return writeFilePositionalWindows(file, pattern, offset);
     }
 
     var iovecs: [max_iovecs_len]posix.iovec_const = undefined;
@@ -10505,50 +10489,64 @@ fn fileWritePositional(
     }
 }
 
-fn writeFilePositionalWindows(
-    handle: windows.HANDLE,
-    bytes: []const u8,
-    offset: u64,
-) File.WritePositionalError!usize {
-    var bytes_written: windows.DWORD = undefined;
-    var overlapped: windows.OVERLAPPED = .{
-        .Internal = 0,
-        .InternalHigh = 0,
-        .DUMMYUNIONNAME = .{
-            .DUMMYSTRUCTNAME = .{
-                .Offset = @truncate(offset),
-                .OffsetHigh = @truncate(offset >> 32),
+fn writeFilePositionalWindows(file: File, buffer: []const u8, offset: u64) File.WritePositionalError!usize {
+    assert(buffer.len != 0);
+    var iosb: windows.IO_STATUS_BLOCK = undefined;
+    const short_buffer_len = std.math.lossyCast(u32, buffer.len);
+    const signed_offset: windows.LARGE_INTEGER = @intCast(offset);
+    if (file.flags.nonblocking) {
+        var done: bool = false;
+        switch (windows.ntdll.NtWriteFile(
+            file.handle,
+            null, // event
+            flagApc,
+            &done, // APC context
+            &iosb,
+            buffer.ptr,
+            short_buffer_len,
+            &signed_offset,
+            null, // key
+        )) {
+            // We must wait for the APC routine.
+            .PENDING, .SUCCESS => while (!done) {
+                // Once we get here we must not return from the function until the
+                // operation completes, thereby releasing reference to the iosb.
+                const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                    error.Canceled => |e| {
+                        var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
+                        _ = windows.ntdll.NtCancelIoFileEx(file.handle, &iosb, &cancel_iosb);
+                        while (!done) waitForApcOrAlert();
+                        return e;
+                    },
+                };
+                waitForApcOrAlert();
+                alertable_syscall.finish();
             },
-        },
-        .hEvent = null,
-    };
-    const adjusted_len = std.math.lossyCast(u32, bytes.len);
-    const syscall: Syscall = try .start();
-    while (true) {
-        if (windows.kernel32.WriteFile(handle, bytes.ptr, adjusted_len, &bytes_written, &overlapped) != 0) {
-            syscall.finish();
-            return bytes_written;
+            else => |status| iosb.u.Status = status,
         }
-        switch (windows.GetLastError()) {
-            .OPERATION_ABORTED => {
-                try syscall.checkCancel();
-                continue;
-            },
-            .INVALID_USER_BUFFER => return syscall.fail(error.SystemResources),
-            .NOT_ENOUGH_MEMORY => return syscall.fail(error.SystemResources),
-            .NOT_ENOUGH_QUOTA => return syscall.fail(error.SystemResources),
-            .NO_DATA => return syscall.fail(error.BrokenPipe),
-            .INVALID_HANDLE => if (is_debug) unreachable else return error.Unexpected, // use after free
-            .LOCK_VIOLATION => return syscall.fail(error.LockViolation),
-            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
-            .WORKING_SET_QUOTA => return syscall.fail(error.SystemResources),
-            .DISK_FULL => return syscall.fail(error.NoSpaceLeft),
-            else => |err| {
+    } else {
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.NtWriteFile(
+            file.handle,
+            null, // event
+            null, // APC routine
+            null, // APC context
+            &iosb,
+            buffer.ptr,
+            short_buffer_len,
+            &signed_offset,
+            null, // key
+        )) {
+            .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
+            .CANCELLED => try syscall.checkCancel(),
+            else => |status| {
                 syscall.finish();
-                return windows.unexpectedError(err);
+                iosb.u.Status = status;
+                return ntWriteFileResult(&iosb);
             },
-        }
+        };
     }
+    return ntWriteFileResult(&iosb);
 }
 
 fn fileWriteStreaming(
@@ -10673,9 +10671,7 @@ fn fileWriteStreaming(
 
 fn fileWriteStreamingWindows(file: File, buffer: []const u8) File.Writer.Error!usize {
     assert(buffer.len != 0);
-
     var iosb: windows.IO_STATUS_BLOCK = undefined;
-
     if (file.flags.nonblocking) {
         var done: bool = false;
         switch (windows.ntdll.NtWriteFile(
@@ -10706,7 +10702,6 @@ fn fileWriteStreamingWindows(file: File, buffer: []const u8) File.Writer.Error!u
             },
             else => |status| iosb.u.Status = status,
         }
-        return ntWriteFileResult(&iosb);
     } else {
         const syscall: Syscall = try .start();
         while (true) switch (windows.ntdll.NtWriteFile(
@@ -10721,17 +10716,15 @@ fn fileWriteStreamingWindows(file: File, buffer: []const u8) File.Writer.Error!u
             null, // key
         )) {
             .PENDING => unreachable, // unrecoverable: wrong File nonblocking flag
-            .CANCELLED => {
-                try syscall.checkCancel();
-                continue;
-            },
+            .CANCELLED => try syscall.checkCancel(),
             else => |status| {
                 syscall.finish();
                 iosb.u.Status = status;
-                return ntWriteFileResult(&iosb);
+                break;
             },
         };
     }
+    return ntWriteFileResult(&iosb);
 }
 
 fn fileWriteFileStreaming(
@@ -11433,13 +11426,22 @@ fn nowWindows(clock: Io.Clock) Io.Timestamp {
             return .{ .nanoseconds = @as(i96, windows.ntdll.RtlGetSystemTimePrecise()) * 100 + epoch_ns };
         },
         .awake, .boot => {
-            // QPC on windows doesn't fail on >= XP/2000 and includes time suspended.
-            const qpc = windows.QueryPerformanceCounter();
             // We don't need to cache QPF as it's internally just a memory read to KUSER_SHARED_DATA
             // (a read-only page of info updated and mapped by the kernel to all processes):
             // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntddk-kuser_shared_data
             // https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntexapi_x/kuser_shared_data/index.htm
-            const qpf = windows.QueryPerformanceFrequency();
+            const qpf: u64 = qpf: {
+                var qpf: windows.LARGE_INTEGER = undefined;
+                assert(windows.ntdll.RtlQueryPerformanceFrequency(&qpf) != windows.FALSE);
+                break :qpf @bitCast(qpf);
+            };
+
+            // QPC on windows doesn't fail on >= XP/2000 and includes time suspended.
+            const qpc: u64 = qpc: {
+                var qpc: windows.LARGE_INTEGER = undefined;
+                assert(windows.ntdll.RtlQueryPerformanceCounter(&qpc) != windows.FALSE);
+                break :qpc @bitCast(qpc);
+            };
 
             // 10Mhz (1 qpc tick every 100ns) is a common enough QPF value that we can optimize on it.
             // https://github.com/microsoft/STL/blob/785143a0c73f030238ef618890fd4d6ae2b3a3a0/stl/inc/chrono#L694-L701
@@ -11458,7 +11460,7 @@ fn nowWindows(clock: Io.Clock) Io.Timestamp {
             // https://github.com/reactos/reactos/blob/master/ntoskrnl/ps/query.c#L442-L485
             if (windows.ntdll.NtQueryInformationProcess(
                 handle,
-                windows.PROCESSINFOCLASS.Times,
+                .Times,
                 &times,
                 @sizeOf(windows.KERNEL_USER_TIMES),
                 null,
@@ -11474,7 +11476,7 @@ fn nowWindows(clock: Io.Clock) Io.Timestamp {
             // https://github.com/reactos/reactos/blob/master/ntoskrnl/ps/query.c#L2971-L3019
             if (windows.ntdll.NtQueryInformationThread(
                 handle,
-                windows.THREADINFOCLASS.Times,
+                .Times,
                 &times,
                 @sizeOf(windows.KERNEL_USER_TIMES),
                 null,
@@ -14132,21 +14134,16 @@ fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathEr
 }
 
 fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
-    if (native_os == .wasi) return error.OperationUnsupported;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
 
+    if (native_os == .wasi) return error.OperationUnsupported;
+
     if (is_windows) {
-        var dir_path_buffer: [windows.PATH_MAX_WIDE]u16 = undefined;
-        const dir_path = try GetFinalPathNameByHandle(dir.handle, .{}, &dir_path_buffer);
-        const path_len_bytes = std.math.cast(u16, dir_path.len * 2) orelse return error.NameTooLong;
-        var nt_name: windows.UNICODE_STRING = .{
-            .Length = path_len_bytes,
-            .MaximumLength = path_len_bytes,
-            .Buffer = @constCast(dir_path.ptr),
-        };
+        var dir_path_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
+        const dir_path = try GetFinalPathNameByHandle(dir.handle, .{}, &dir_path_buf);
         const syscall: Syscall = try .start();
-        while (true) switch (windows.ntdll.RtlSetCurrentDirectory_U(&nt_name)) {
+        while (true) switch (windows.ntdll.RtlSetCurrentDirectory_U(&.init(dir_path))) {
             .SUCCESS => return syscall.finish(),
             .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
             .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
@@ -15465,26 +15462,27 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
 fn childKillWindows(t: *Threaded, child: *process.Child, exit_code: windows.UINT) !void {
     _ = t; // TODO cancelation
     const handle = child.id.?;
-    if (windows.kernel32.TerminateProcess(handle, exit_code) == 0) {
-        switch (windows.GetLastError()) {
-            .ACCESS_DENIED => {
-                // Usually when TerminateProcess triggers a ACCESS_DENIED error, it
-                // indicates that the process has already exited, but there may be
-                // some rare edge cases where our process handle no longer has the
-                // PROCESS_TERMINATE access right, so let's do another check to make
-                // sure the process is really no longer running:
-                const minimal_timeout: windows.LARGE_INTEGER = -1;
-                switch (windows.ntdll.NtWaitForSingleObject(handle, windows.FALSE, &minimal_timeout)) {
-                    .SUCCESS => return error.AlreadyTerminated,
-                    else => return error.AccessDenied,
-                }
-            },
-            else => |err| return windows.unexpectedError(err),
-        }
+    _ = windows.ntdll.RtlReportSilentProcessExit(handle, @enumFromInt(exit_code));
+    switch (windows.ntdll.NtTerminateProcess(handle, @enumFromInt(exit_code))) {
+        .SUCCESS => {
+            const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
+            _ = windows.ntdll.NtWaitForSingleObject(handle, windows.FALSE, &infinite_timeout);
+            childCleanupWindows(child);
+        },
+        .ACCESS_DENIED => {
+            // Usually when TerminateProcess triggers a ACCESS_DENIED error, it
+            // indicates that the process has already exited, but there may be
+            // some rare edge cases where our process handle no longer has the
+            // PROCESS_TERMINATE access right, so let's do another check to make
+            // sure the process is really no longer running:
+            const minimal_timeout: windows.LARGE_INTEGER = -1;
+            return switch (windows.ntdll.NtWaitForSingleObject(handle, windows.FALSE, &minimal_timeout)) {
+                windows.NTSTATUS.WAIT_0 => error.AlreadyTerminated,
+                else => error.AccessDenied,
+            };
+        },
+        else => |status| return windows.unexpectedStatus(status),
     }
-    const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER);
-    _ = windows.ntdll.NtWaitForSingleObject(handle, windows.FALSE, &infinite_timeout);
-    childCleanupWindows(child);
 }
 
 fn childWaitWindows(child: *process.Child) process.Child.WaitError!process.Child.Term {
@@ -15501,12 +15499,12 @@ fn childWaitWindows(child: *process.Child) process.Child.WaitError!process.Child
         else => |status| return alertable_syscall.unexpectedNtstatus(status),
     };
 
-    var info: windows.PROCESS_BASIC_INFORMATION = undefined;
+    var info: windows.PROCESS.BASIC_INFORMATION = undefined;
     const term: process.Child.Term = switch (windows.ntdll.NtQueryInformationProcess(
         handle,
         .BasicInformation,
         &info,
-        @sizeOf(windows.PROCESS_BASIC_INFORMATION),
+        @sizeOf(windows.PROCESS.BASIC_INFORMATION),
         null,
     )) {
         .SUCCESS => .{ .exited = @as(u8, @truncate(@intFromEnum(info.ExitStatus))) },
@@ -15521,12 +15519,12 @@ fn childCleanupWindows(child: *process.Child) void {
     const handle = child.id orelse return;
 
     if (child.request_resource_usage_statistics) {
-        var vmc: windows.VM_COUNTERS = undefined;
+        var vmc: windows.PROCESS.VM_COUNTERS = undefined;
         switch (windows.ntdll.NtQueryInformationProcess(
             handle,
             .VmCounters,
             &vmc,
-            @sizeOf(windows.VM_COUNTERS),
+            @sizeOf(windows.PROCESS.VM_COUNTERS),
             null,
         )) {
             .SUCCESS => child.resource_usage_statistics.rusage = vmc,
@@ -15853,7 +15851,7 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
         .cbReserved2 = 0,
         .lpReserved2 = null,
     };
-    var piProcInfo: windows.PROCESS_INFORMATION = undefined;
+    var piProcInfo: windows.PROCESS.INFORMATION = undefined;
 
     var arena_allocator = std.heap.ArenaAllocator.init(t.allocator);
     defer arena_allocator.deinit();
@@ -16062,7 +16060,6 @@ fn getCngDevice(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
         if (t.random_file.handle) |handle| return handle;
     }
 
-    const device_path = [_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'C', 'N', 'G' };
     var fresh_handle: windows.HANDLE = undefined;
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var syscall: Syscall = try .start();
@@ -16072,13 +16069,9 @@ fn getCngDevice(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
             .STANDARD = .{ .SYNCHRONIZE = true },
             .SPECIFIC = .{ .FILE = .{ .READ_DATA = true } },
         },
-        &.{
-            .ObjectName = @constCast(&windows.UNICODE_STRING{
-                .Length = @sizeOf(@TypeOf(device_path)),
-                .MaximumLength = 0,
-                .Buffer = @constCast(&device_path),
-            }),
-        },
+        &.{ .ObjectName = @constCast(&windows.UNICODE_STRING.init(
+            &.{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'C', 'N', 'G' },
+        )) },
         &io_status_block,
         .VALID_FLAGS,
         .{ .IO = .SYNCHRONOUS_NONALERT },
@@ -16111,7 +16104,6 @@ fn getNulDevice(t: *Threaded) !windows.HANDLE {
         if (t.null_file.handle) |handle| return handle;
     }
 
-    const device_path = [_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'u', 'l', 'l' };
     var fresh_handle: windows.HANDLE = undefined;
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var syscall: Syscall = try .start();
@@ -16123,11 +16115,9 @@ fn getNulDevice(t: *Threaded) !windows.HANDLE {
         },
         &.{
             .Attributes = .{ .INHERIT = true },
-            .ObjectName = @constCast(&windows.UNICODE_STRING{
-                .Length = @sizeOf(@TypeOf(device_path)),
-                .MaximumLength = 0,
-                .Buffer = @constCast(&device_path),
-            }),
+            .ObjectName = @constCast(&windows.UNICODE_STRING.init(
+                &.{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'u', 'l', 'l' },
+            )),
         },
         &io_status_block,
         .VALID_FLAGS,
@@ -16173,7 +16163,6 @@ fn getNamedPipeDevice(t: *Threaded) !windows.HANDLE {
         if (t.pipe_file.handle) |handle| return handle;
     }
 
-    const device_path = [_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'a', 'm', 'e', 'd', 'P', 'i', 'p', 'e', '\\' };
     var fresh_handle: windows.HANDLE = undefined;
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     var syscall: Syscall = try .start();
@@ -16181,11 +16170,9 @@ fn getNamedPipeDevice(t: *Threaded) !windows.HANDLE {
         &fresh_handle,
         .{ .STANDARD = .{ .SYNCHRONIZE = true } },
         &.{
-            .ObjectName = @constCast(&windows.UNICODE_STRING{
-                .Length = @sizeOf(@TypeOf(device_path)),
-                .MaximumLength = 0,
-                .Buffer = @constCast(&device_path),
-            }),
+            .ObjectName = @constCast(&windows.UNICODE_STRING.init(
+                &.{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'a', 'm', 'e', 'd', 'P', 'i', 'p', 'e', '\\' },
+            )),
         },
         &io_status_block,
         .VALID_FLAGS,
@@ -16253,7 +16240,7 @@ fn windowsCreateProcessPathExt(
     cwd_ptr: ?[*:0]u16,
     flags: windows.CreateProcessFlags,
     lpStartupInfo: *windows.STARTUPINFOW,
-    lpProcessInformation: *windows.PROCESS_INFORMATION,
+    lpProcessInformation: *windows.PROCESS.INFORMATION,
 ) !void {
     const app_name_len = app_buf.items.len;
     const dir_path_len = dir_buf.items.len;
@@ -16341,13 +16328,9 @@ fn windowsCreateProcessPathExt(
     //       On NTFS, `blah.exe*` will always return `blah.exe` first if it exists.
     //       On FAT32, it's possible for something like `blah.exe.obj` to be returned first.
     while (true) {
-        const app_name_len_bytes = std.math.cast(u16, app_name_wildcard.len * 2) orelse return error.NameTooLong;
-        var app_name_unicode_string = windows.UNICODE_STRING{
-            .Length = app_name_len_bytes,
-            .MaximumLength = app_name_len_bytes,
-            .Buffer = @constCast(app_name_wildcard.ptr),
-        };
-        const rc = windows.ntdll.NtQueryDirectoryFile(
+        // If we get nothing with the wildcard, then we can just bail out
+        // as we know appending PATHEXT will not yield anything.
+        switch (windows.ntdll.NtQueryDirectoryFile(
             dir.handle,
             null,
             null,
@@ -16357,18 +16340,14 @@ fn windowsCreateProcessPathExt(
             file_information_buf.len,
             .Directory,
             windows.FALSE, // single result
-            &app_name_unicode_string,
+            &.init(app_name_wildcard),
             windows.FALSE, // restart iteration
-        );
-
-        // If we get nothing with the wildcard, then we can just bail out
-        // as we know appending PATHEXT will not yield anything.
-        switch (rc) {
+        )) {
             .SUCCESS => {},
             .NO_SUCH_FILE => return error.FileNotFound,
             .NO_MORE_FILES => break,
             .ACCESS_DENIED => return error.AccessDenied,
-            else => return windows.unexpectedStatus(rc),
+            else => |status| return windows.unexpectedStatus(status),
         }
 
         // According to the docs, this can only happen if there is not enough room in the
@@ -16514,7 +16493,7 @@ fn windowsCreateProcess(
     cwd_ptr: ?[*:0]u16,
     flags: windows.CreateProcessFlags,
     lpStartupInfo: *windows.STARTUPINFOW,
-    lpProcessInformation: *windows.PROCESS_INFORMATION,
+    lpProcessInformation: *windows.PROCESS.INFORMATION,
 ) !void {
     const syscall: Syscall = try .start();
     while (true) {
@@ -17138,7 +17117,7 @@ pub const CreatePipeOptions = struct {
     default_timeout: windows.LARGE_INTEGER = -120 * std.time.ns_per_s / 100,
 
     pub const End = struct {
-        attributes: windows.OBJECT_ATTRIBUTES.ATTRIBUTES = .{},
+        attributes: windows.OBJECT.ATTRIBUTES.Flags = .{},
         mode: windows.FILE.MODE,
     };
 };
@@ -18373,7 +18352,7 @@ const CreateFileMapError = error{
     OutOfMemory,
     MappingAlreadyExists,
     Unseekable,
-    FileLockConflict,
+    LockViolation,
 } || Io.Cancelable || Io.UnexpectedError;
 
 fn createFileMap(
@@ -18408,7 +18387,7 @@ fn createFileMap(
             file.handle,
         )) {
             .SUCCESS => {},
-            .FILE_LOCK_CONFLICT => return error.FileLockConflict,
+            .FILE_LOCK_CONFLICT => return error.LockViolation,
             .INVALID_FILE_FOR_SECTION => return error.OperationUnsupported,
             .ACCESS_DENIED => return error.AccessDenied,
             .SECTION_TOO_BIG => return error.SectionOversize,
@@ -18724,7 +18703,7 @@ fn mmSyncWrite(file: File, memory: []u8, offset: u64) File.WritePositionalError!
         while (true) {
             const buf = memory[i..];
             if (buf.len == 0) break;
-            i += try writeFilePositionalWindows(file.handle, memory[i..], offset + i);
+            i += try writeFilePositionalWindows(file, memory[i..], offset + i);
         }
     } else if (native_os == .wasi and !builtin.link_libc) {
         var i: usize = 0;
@@ -18809,8 +18788,7 @@ fn mmSyncWrite(file: File, memory: []u8, offset: u64) File.WritePositionalError!
     }
 }
 
-fn deviceIoControl(t: *Threaded, o: *const Io.Operation.DeviceIoControl) Io.Cancelable!Io.Operation.DeviceIoControl.Result {
-    _ = t;
+fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!Io.Operation.DeviceIoControl.Result {
     if (is_windows) {
         const NtControlFile = switch (o.code.DeviceType) {
             .FILE_SYSTEM, .NAMED_PIPE => &windows.ntdll.NtFsControlFile,
@@ -19104,16 +19082,10 @@ fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows
 
     var result: windows.HANDLE = undefined;
 
-    const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
-    var nt_name: windows.UNICODE_STRING = .{
-        .Length = path_len_bytes,
-        .MaximumLength = path_len_bytes,
-        .Buffer = @constCast(sub_path_w.ptr),
-    };
-    const attr: windows.OBJECT_ATTRIBUTES = .{
+    const attr: windows.OBJECT.ATTRIBUTES = .{
         .RootDirectory = if (Dir.path.isAbsoluteWindowsWtf16(sub_path_w)) null else options.dir,
         .Attributes = .{ .INHERIT = if (options.sa) |sa| sa.bInheritHandle != windows.FALSE else false },
-        .ObjectName = &nt_name,
+        .ObjectName = @constCast(&windows.UNICODE_STRING.init(sub_path_w)),
         .SecurityDescriptor = if (options.sa) |ptr| ptr.lpSecurityDescriptor else null,
     };
 
diff --git a/lib/std/Io/Threaded/test.zig b/lib/std/Io/Threaded/test.zig
index 1c9b188584b588a44c225e51450390787eb81557..fff802b1913734a2baaa9f3b43b626645530ce67 100644
--- a/lib/std/Io/Threaded/test.zig
+++ b/lib/std/Io/Threaded/test.zig
@@ -290,7 +290,7 @@ fn RtlDosPathNameToNtPathName_U(path: [:0]const u16) !Io.Threaded.WindowsPathSpa
     defer windows.ntdll.RtlFreeUnicodeString(&out);
 
     var path_space: Io.Threaded.WindowsPathSpace = undefined;
-    const out_path = out.Buffer.?[0 .. out.Length / 2];
+    const out_path = out.slice();
     @memcpy(path_space.data[0..out_path.len], out_path);
     path_space.len = out.Length / 2;
     path_space.data[path_space.len] = 0;
diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 131f57dcf860d59d89b5cec88aa491bbf06fc719..11466fb9a251a7ad44363995425ea9eccb8a19d1 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -88,20 +88,10 @@ pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void {
         },
         .windows => {
             var buf: [max_name_len]u16 = undefined;
-            const len = try std.unicode.wtf8ToWtf16Le(&buf, name);
-            const byte_len = math.cast(c_ushort, len * 2) orelse return error.NameTooLong;
-
-            // Note: NT allocates its own copy, no use-after-free here.
-            const unicode_string = windows.UNICODE_STRING{
-                .Length = byte_len,
-                .MaximumLength = byte_len,
-                .Buffer = &buf,
-            };
-
             switch (windows.ntdll.NtSetInformationThread(
                 self.getHandle(),
                 .NameInformation,
-                &unicode_string,
+                &windows.UNICODE_STRING.init(buf[0..try std.unicode.wtf8ToWtf16Le(&buf, name)]),
                 @sizeOf(windows.UNICODE_STRING),
             )) {
                 .SUCCESS => return,
@@ -217,8 +207,8 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co
                 null,
             )) {
                 .SUCCESS => {
-                    const string = @as(*const windows.UNICODE_STRING, @ptrCast(&buf));
-                    const len = std.unicode.wtf16LeToWtf8(buffer, string.Buffer.?[0 .. string.Length / 2]);
+                    const string: *const windows.UNICODE_STRING = @ptrCast(&buf);
+                    const len = std.unicode.wtf16LeToWtf8(buffer, string.slice());
                     return if (len > 0) buffer[0..len] else null;
                 },
                 .NOT_IMPLEMENTED => return error.Unsupported,
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 8f83bf19c8704aa41e2dbfae6429ed961cd12bbf..a2b5467c1f4aec44657b58f8c33eab8adac47de0 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -37,12 +37,13 @@ pub const cpu_context = @import("debug/cpu_context.zig");
 ///
 /// ```
 /// pub const init: SelfInfo;
-/// pub fn deinit(si: *SelfInfo, gpa: Allocator) void;
+/// pub fn deinit(si: *SelfInfo, io: Io) void;
 ///
 /// /// Returns the symbol and source location of the instruction at `address`.
-/// pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) SelfInfoError!Symbol;
+/// pub fn getSymbol(si: *SelfInfo, io: Io, address: usize) SelfInfoError!Symbol;
 /// /// Returns a name for the "module" (e.g. shared library or executable image) containing `address`.
-/// pub fn getModuleName(si: *SelfInfo, gpa: Allocator, address: usize) SelfInfoError![]const u8;
+/// pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) SelfInfoError![]const u8;
+/// pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) SelfInfoError!usize;
 ///
 /// /// Whether a reliable stack unwinding strategy, such as DWARF unwinding, is available.
 /// pub const can_unwind: bool;
@@ -51,15 +52,15 @@ pub const cpu_context = @import("debug/cpu_context.zig");
 ///     /// An address representing the instruction pointer in the last frame.
 ///     pc: usize,
 ///
-///     pub fn init(ctx: *cpu_context.Native, gpa: Allocator) Allocator.Error!UnwindContext;
-///     pub fn deinit(ctx: *UnwindContext, gpa: Allocator) void;
+///     pub fn init(ctx: *cpu_context.Native) Allocator.Error!UnwindContext;
+///     pub fn deinit(ctx: *UnwindContext) void;
 ///     /// Returns the frame pointer associated with the last unwound stack frame.
 ///     /// If the frame pointer is unknown, 0 may be returned instead.
 ///     pub fn getFp(uc: *UnwindContext) usize;
 /// };
 /// /// Only required if `can_unwind == true`. Unwinds a single stack frame, returning the frame's
 /// /// return address, or 0 if the end of the stack has been reached.
-/// pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) SelfInfoError!usize;
+/// pub fn unwindFrame(si: *SelfInfo, io: Io, context: *UnwindContext) SelfInfoError!usize;
 /// ```
 pub const SelfInfo = if (@hasDecl(root, "debug") and @hasDecl(root.debug, "SelfInfo"))
     root.debug.SelfInfo
@@ -669,7 +670,6 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
         t.setColor(.reset) catch {};
         return;
     }
-    const di_gpa = getDebugInfoAllocator();
     const di = getSelfDebugInfo() catch |err| switch (err) {
         error.UnsupportedTarget => {
             t.setColor(.dim) catch {};
@@ -696,7 +696,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
                 .useless, .unsafe => {},
                 .safe, .ideal => continue, // no need to even warn
             }
-            const module_name = di.getModuleName(di_gpa, io, unwind_error.address) catch "???";
+            const module_name = di.getModuleName(io, unwind_error.address) catch "???";
             const caption: []const u8 = switch (unwind_error.err) {
                 error.MissingDebugInfo => "unwind info unavailable",
                 error.InvalidDebugInfo => "unwind info invalid",
@@ -741,7 +741,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
             }
             // `ret_addr` is the return address, which is *after* the function call.
             // Subtract 1 to get an address *in* the function call for a better source location.
-            try printSourceAtAddress(di_gpa, io, di, t, ret_addr -| StackIterator.ra_call_offset);
+            try printSourceAtAddress(io, di, t, ret_addr -| StackIterator.ra_call_offset);
             printed_any_frame = true;
         },
     };
@@ -788,7 +788,6 @@ pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void
     // `st` is `@errorReturnTrace()` and errors are encountered while writing the stack trace.
     const n_frames = st.index;
     if (n_frames == 0) return writer.writeAll("(empty stack trace)\n");
-    const di_gpa = getDebugInfoAllocator();
     const di = getSelfDebugInfo() catch |err| switch (err) {
         error.UnsupportedTarget => {
             t.setColor(.dim) catch {};
@@ -802,7 +801,7 @@ pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void
     for (st.instruction_addresses[0..captured_frames]) |ret_addr| {
         // `ret_addr` is the return address, which is *after* the function call.
         // Subtract 1 to get an address *in* the function call for a better source location.
-        try printSourceAtAddress(di_gpa, io, di, t, ret_addr -| StackIterator.ra_call_offset);
+        try printSourceAtAddress(io, di, t, ret_addr -| StackIterator.ra_call_offset);
     }
     if (n_frames > captured_frames) {
         t.setColor(.bold) catch {};
@@ -875,7 +874,7 @@ const StackIterator = union(enum) {
         switch (si.*) {
             .ctx_first => {},
             .fp => {},
-            .di => |*unwind_context| unwind_context.deinit(getDebugInfoAllocator()),
+            .di => |*unwind_context| unwind_context.deinit(),
         }
     }
 
@@ -980,8 +979,7 @@ const StackIterator = union(enum) {
             },
             .di => |*unwind_context| {
                 const di = getSelfDebugInfo() catch unreachable;
-                const di_gpa = getDebugInfoAllocator();
-                const ret_addr = di.unwindFrame(di_gpa, io, unwind_context) catch |err| {
+                const ret_addr = di.unwindFrame(io, unwind_context) catch |err| {
                     const pc = unwind_context.pc;
                     const fp = unwind_context.getFp();
                     it.* = .{ .fp = fp };
@@ -1109,14 +1107,8 @@ pub inline fn stripInstructionPtrAuthCode(ptr: usize) usize {
     return ptr;
 }
 
-fn printSourceAtAddress(
-    gpa: Allocator,
-    io: Io,
-    debug_info: *SelfInfo,
-    t: Io.Terminal,
-    address: usize,
-) Writer.Error!void {
-    const symbol: Symbol = debug_info.getSymbol(gpa, io, address) catch |err| switch (err) {
+fn printSourceAtAddress(io: Io, debug_info: *SelfInfo, t: Io.Terminal, address: usize) Writer.Error!void {
+    const symbol: Symbol = debug_info.getSymbol(io, address) catch |err| switch (err) {
         error.MissingDebugInfo,
         error.UnsupportedDebugInfo,
         error.InvalidDebugInfo,
@@ -1134,14 +1126,14 @@ fn printSourceAtAddress(
             break :s .unknown;
         },
     };
-    defer if (symbol.source_location) |sl| gpa.free(sl.file_name);
+    defer if (symbol.source_location) |sl| getDebugInfoAllocator().free(sl.file_name);
     return printLineInfo(
         io,
         t,
         symbol.source_location,
         address,
         symbol.name orelse "???",
-        symbol.compile_unit_name orelse debug_info.getModuleName(gpa, io, address) catch "???",
+        symbol.compile_unit_name orelse debug_info.getModuleName(io, address) catch "???",
     );
 }
 fn printLineInfo(
@@ -1608,14 +1600,13 @@ test "manage resources correctly" {
             return @returnAddress();
         }
     };
-    const gpa = testing.allocator;
     const io = testing.io;
 
     var discarding: Writer.Discarding = .init(&.{});
     var di: SelfInfo = .init;
-    defer di.deinit(gpa);
+    defer di.deinit(io);
     const t: Io.Terminal = .{ .writer = &discarding.writer, .mode = .no_color };
-    try printSourceAtAddress(gpa, io, &di, t, S.showMyTrace());
+    try printSourceAtAddress(io, &di, t, S.showMyTrace());
 }
 
 /// This API helps you track where a value originated and where it was mutated,
diff --git a/lib/std/debug/Dwarf/SelfUnwinder.zig b/lib/std/debug/Dwarf/SelfUnwinder.zig
index 80908e84bb9eb5f5a1257c3069b1b96157825715..0f5253844de3cdcd97d57e18c8d0ca6c4ed231c8 100644
--- a/lib/std/debug/Dwarf/SelfUnwinder.zig
+++ b/lib/std/debug/Dwarf/SelfUnwinder.zig
@@ -55,7 +55,8 @@ pub fn init(cpu_context: *const std.debug.cpu_context.Native) SelfUnwinder {
     };
 }
 
-pub fn deinit(unwinder: *SelfUnwinder, gpa: Allocator) void {
+pub fn deinit(unwinder: *SelfUnwinder) void {
+    const gpa = std.debug.getDebugInfoAllocator();
     unwinder.cfi_vm.deinit(gpa);
     unwinder.expr_vm.deinit(gpa);
     unwinder.* = undefined;
diff --git a/lib/std/debug/SelfInfo/Elf.zig b/lib/std/debug/SelfInfo/Elf.zig
index 40841bac2c351d824604556c7c67f1548aa964a0..a264b1170db05e5ee5510b75b0bdf354e3ae3026 100644
--- a/lib/std/debug/SelfInfo/Elf.zig
+++ b/lib/std/debug/SelfInfo/Elf.zig
@@ -11,7 +11,9 @@ pub const init: SelfInfo = .{
     .ranges = .empty,
     .unwind_cache = null,
 };
-pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
+pub fn deinit(si: *SelfInfo, io: Io) void {
+    _ = io;
+    const gpa = std.debug.getDebugInfoAllocator();
     for (si.modules.items) |*mod| {
         unwind: {
             const u = &(mod.unwind orelse break :unwind catch break :unwind);
@@ -28,7 +30,8 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
     if (si.unwind_cache) |cache| gpa.free(cache);
 }
 
-pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
+pub fn getSymbol(si: *SelfInfo, io: Io, address: usize) Error!std.debug.Symbol {
+    const gpa = std.debug.getDebugInfoAllocator();
     const module = try si.findModule(gpa, io, address, .exclusive);
     defer si.rwlock.unlock(io);
 
@@ -73,13 +76,15 @@ pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!st
         error.OutOfMemory => |e| return e,
     };
 }
-pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
+pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
+    const gpa = std.debug.getDebugInfoAllocator();
     const module = try si.findModule(gpa, io, address, .shared);
     defer si.rwlock.unlockShared(io);
     if (module.name.len == 0) return error.MissingDebugInfo;
     return module.name;
 }
-pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
+pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
+    const gpa = std.debug.getDebugInfoAllocator();
     const module = try si.findModule(gpa, io, address, .shared);
     defer si.rwlock.unlockShared(io);
     return module.load_offset;
@@ -179,8 +184,9 @@ comptime {
     }
 }
 pub const UnwindContext = Dwarf.SelfUnwinder;
-pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
+pub fn unwindFrame(si: *SelfInfo, io: Io, context: *UnwindContext) Error!usize {
     comptime assert(can_unwind);
+    const gpa = std.debug.getDebugInfoAllocator();
 
     {
         si.rwlock.lockSharedUncancelable(io);
diff --git a/lib/std/debug/SelfInfo/MachO.zig b/lib/std/debug/SelfInfo/MachO.zig
index 1cc2ebed53939959c2e1712d7afdf58dfe1178e5..6b184fec7a16066397c6961b7cc55492ef4fb26e 100644
--- a/lib/std/debug/SelfInfo/MachO.zig
+++ b/lib/std/debug/SelfInfo/MachO.zig
@@ -6,7 +6,9 @@ pub const init: SelfInfo = .{
     .mutex = .init,
     .modules = .empty,
 };
-pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
+pub fn deinit(si: *SelfInfo, io: Io) void {
+    _ = io;
+    const gpa = std.debug.getDebugInfoAllocator();
     for (si.modules.keys()) |*module| {
         unwind: {
             const u = &(module.unwind orelse break :unwind catch break :unwind);
@@ -20,7 +22,8 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
     si.modules.deinit(gpa);
 }
 
-pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
+pub fn getSymbol(si: *SelfInfo, io: Io, address: usize) Error!std.debug.Symbol {
+    const gpa = std.debug.getDebugInfoAllocator();
     const module = try si.findModule(gpa, io, address);
     defer si.mutex.unlock(io);
 
@@ -76,9 +79,8 @@ pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!st
         ) catch null,
     };
 }
-pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
+pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
     _ = si;
-    _ = gpa;
     _ = io;
     // This function is marked as deprecated; however, it is significantly more
     // performant than `dladdr` (since the latter also does a very slow symbol
@@ -87,7 +89,8 @@ pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Erro
         @ptrFromInt(address),
     ) orelse return error.MissingDebugInfo);
 }
-pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
+pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
+    const gpa = std.debug.getDebugInfoAllocator();
     const module = try si.findModule(gpa, io, address);
     defer si.mutex.unlock(io);
     const header: *std.macho.mach_header_64 = @ptrFromInt(module.text_base);
@@ -107,8 +110,8 @@ pub const UnwindContext = std.debug.Dwarf.SelfUnwinder;
 /// Unwind a frame using MachO compact unwind info (from `__unwind_info`).
 /// If the compact encoding can't encode a way to unwind a frame, it will
 /// defer unwinding to DWARF, in which case `__eh_frame` will be used if available.
-pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
-    return unwindFrameInner(si, gpa, io, context) catch |err| switch (err) {
+pub fn unwindFrame(si: *SelfInfo, io: Io, context: *UnwindContext) Error!usize {
+    return unwindFrameInner(si, io, context) catch |err| switch (err) {
         error.InvalidDebugInfo,
         error.MissingDebugInfo,
         error.UnsupportedDebugInfo,
@@ -134,7 +137,8 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
         => return error.InvalidDebugInfo,
     };
 }
-fn unwindFrameInner(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) !usize {
+fn unwindFrameInner(si: *SelfInfo, io: Io, context: *UnwindContext) !usize {
+    const gpa = std.debug.getDebugInfoAllocator();
     const module = try si.findModule(gpa, io, context.pc);
     defer si.mutex.unlock(io);
 
diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig
index 75cc329c3b0606846302234a8e93273e8e58b484..7cac79d72759eab9c4e1b66b2923aab96b9a17cc 100644
--- a/lib/std/debug/SelfInfo/Windows.zig
+++ b/lib/std/debug/SelfInfo/Windows.zig
@@ -1,39 +1,51 @@
 mutex: Io.Mutex,
+ntdll_handle: ?if (load_dll_notification_procs) *anyopaque else noreturn,
+notification_cookie: ?LDR.DLL_NOTIFICATION.COOKIE,
 modules: std.ArrayList(Module),
-module_name_arena: std.heap.ArenaAllocator.State,
 
 pub const init: SelfInfo = .{
     .mutex = .init,
+    .ntdll_handle = null,
+    .notification_cookie = null,
     .modules = .empty,
-    .module_name_arena = .{},
 };
-pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
-    for (si.modules.items) |*module| {
-        di: {
-            const di = &(module.di orelse break :di catch break :di);
-            di.deinit(gpa);
+pub fn deinit(si: *SelfInfo, io: Io) void {
+    const gpa = std.debug.getDebugInfoAllocator();
+    if (si.notification_cookie) |cookie| unregister: {
+        switch ((si.getNtdllProc(.LdrUnregisterDllNotification) catch break :unregister)(cookie)) {
+            .SUCCESS => {},
+            else => |status| windows.unexpectedStatus(status) catch break :unregister,
         }
     }
+    if (si.ntdll_handle) |handle| switch (windows.ntdll.LdrUnloadDll(handle)) {
+        .SUCCESS => {},
+        else => |status| windows.unexpectedStatus(status) catch {},
+    };
+    for (si.modules.items) |*module| module.deinit(gpa, io);
     si.modules.deinit(gpa);
-
-    var module_name_arena = si.module_name_arena.promote(gpa);
-    module_name_arena.deinit();
 }
 
-pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
+pub fn getSymbol(si: *SelfInfo, io: Io, address: usize) Error!std.debug.Symbol {
+    const gpa = std.debug.getDebugInfoAllocator();
     try si.mutex.lock(io);
     defer si.mutex.unlock(io);
     const module = try si.findModule(gpa, address);
     const di = try module.getDebugInfo(gpa, io);
-    return di.getSymbol(gpa, address - module.base_address);
+    return di.getSymbol(gpa, address - @intFromPtr(module.entry.DllBase));
 }
-pub fn getModuleName(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error![]const u8 {
+pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
+    const gpa = std.debug.getDebugInfoAllocator();
     try si.mutex.lock(io);
     defer si.mutex.unlock(io);
     const module = try si.findModule(gpa, address);
-    return module.name;
+    return module.name orelse {
+        const name = try std.unicode.wtf16LeToWtf8Alloc(gpa, module.entry.BaseDllName.slice());
+        module.name = name;
+        return name;
+    };
 }
-pub fn getModuleSlide(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!usize {
+pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
+    const gpa = std.debug.getDebugInfoAllocator();
     try si.mutex.lock(io);
     defer si.mutex.unlock(io);
     const module = try si.findModule(gpa, address);
@@ -141,18 +153,16 @@ pub const UnwindContext = struct {
             .history_table = std.mem.zeroes(windows.UNWIND_HISTORY_TABLE),
         };
     }
-    pub fn deinit(ctx: *UnwindContext, gpa: Allocator) void {
+    pub fn deinit(ctx: *UnwindContext) void {
         _ = ctx;
-        _ = gpa;
     }
     pub fn getFp(ctx: *UnwindContext) usize {
         return ctx.cur.getRegs().bp;
     }
 };
-pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
+pub fn unwindFrame(si: *SelfInfo, io: Io, context: *UnwindContext) Error!usize {
     _ = si;
     _ = io;
-    _ = gpa;
 
     const current_regs = context.cur.getRegs();
     var image_base: usize = undefined;
@@ -188,16 +198,12 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContex
 }
 
 const Module = struct {
-    base_address: usize,
-    size: u32,
-    name: []const u8,
-    handle: windows.HMODULE,
-
+    entry: *const LDR.DATA_TABLE_ENTRY,
+    name: ?[]const u8,
     di: ?(Error!DebugInfo),
 
     const DebugInfo = struct {
         arena: std.heap.ArenaAllocator.State,
-        io: Io,
         coff_image_base: u64,
         mapped_file: ?MappedFile,
         dwarf: ?Dwarf,
@@ -210,14 +216,19 @@ const Module = struct {
             section_view: []const u8,
             fn deinit(mf: *const MappedFile, io: Io) void {
                 const process_handle = windows.GetCurrentProcess();
-                assert(windows.ntdll.NtUnmapViewOfSection(process_handle, @constCast(mf.section_view.ptr)) == .SUCCESS);
+                switch (windows.ntdll.NtUnmapViewOfSection(
+                    process_handle,
+                    @constCast(mf.section_view.ptr),
+                )) {
+                    .SUCCESS => {},
+                    else => |status| windows.unexpectedStatus(status) catch {},
+                }
                 windows.CloseHandle(mf.section_handle);
                 mf.file.close(io);
             }
         };
 
-        fn deinit(di: *DebugInfo, gpa: Allocator) void {
-            const io = di.io;
+        fn deinit(di: *DebugInfo, gpa: Allocator, io: Io) void {
             if (di.dwarf) |*dwarf| dwarf.deinit(gpa);
             if (di.pdb) |*pdb| {
                 pdb.file_reader.file.close(io);
@@ -262,7 +273,10 @@ const Module = struct {
                 return .{
                     .name = pdb.getSymbolName(module, vaddr - coff_section.virtual_address),
                     .compile_unit_name = fs.path.basename(module.obj_file_name),
-                    .source_location = pdb.getLineNumberInfo(module, vaddr - coff_section.virtual_address) catch null,
+                    .source_location = pdb.getLineNumberInfo(
+                        module,
+                        vaddr - coff_section.virtual_address,
+                    ) catch null,
                 };
             }
             dwarf: {
@@ -286,13 +300,19 @@ const Module = struct {
         }
     };
 
+    fn deinit(module: *Module, gpa: Allocator, io: Io) void {
+        if (module.name) |name| gpa.free(name);
+        if (module.di) |*di_or_err| if (di_or_err.*) |*di| di.deinit(gpa, io) else |_| {};
+        module.* = undefined;
+    }
+
     fn getDebugInfo(module: *Module, gpa: Allocator, io: Io) Error!*DebugInfo {
         if (module.di == null) module.di = loadDebugInfo(module, gpa, io);
         return if (module.di.?) |*di| di else |err| err;
     }
     fn loadDebugInfo(module: *const Module, gpa: Allocator, io: Io) Error!DebugInfo {
-        const mapped_ptr: [*]const u8 = @ptrFromInt(module.base_address);
-        const mapped = mapped_ptr[0..module.size];
+        const mapped_ptr: [*]const u8 = @ptrCast(module.entry.DllBase);
+        const mapped = mapped_ptr[0..module.entry.SizeOfImage];
         var coff_obj = coff.Coff.init(mapped, true) catch return error.InvalidDebugInfo;
 
         var arena_instance: std.heap.ArenaAllocator = .init(gpa);
@@ -304,18 +324,15 @@ const Module = struct {
         // a binary is produced with -gdwarf, since the section names are longer than 8 bytes.
         const mapped_file: ?DebugInfo.MappedFile = mapped: {
             if (!coff_obj.strtabRequired()) break :mapped null;
-            var name_buffer: [windows.PATH_MAX_WIDE + 4:0]u16 = undefined;
-            name_buffer[0..4].* = .{ '\\', '?', '?', '\\' }; // openFileAbsoluteW requires the prefix to be present
-            const process_handle = windows.GetCurrentProcess();
-            const len = windows.kernel32.GetModuleFileNameExW(
-                process_handle,
-                module.handle,
-                name_buffer[4..],
-                windows.PATH_MAX_WIDE,
-            );
-            if (len == 0) return error.MissingDebugInfo;
-            const name_w = name_buffer[0 .. len + 4 :0];
-            const coff_file = Io.Threaded.dirOpenFileWtf16(null, name_w, .{}) catch |err| switch (err) {
+            var path_buffer: [4 + windows.PATH_MAX_WIDE]u16 = undefined;
+            path_buffer[0..4].* = .{ '\\', '?', '?', '\\' }; // openFileAbsoluteW requires the prefix to be present
+            const path_slice = module.entry.FullDllName.slice();
+            @memcpy(path_buffer[4..][0..path_slice.len], path_slice);
+            const coff_file = Io.Threaded.dirOpenFileWtf16(
+                null,
+                path_buffer[0 .. 4 + path_slice.len],
+                .{},
+            ) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 error.Unexpected => |e| return e,
                 error.FileNotFound => return error.MissingDebugInfo,
@@ -359,7 +376,8 @@ const Module = struct {
                 null,
                 null,
                 .{ .READONLY = true },
-                // The documentation states that if no AllocationAttribute is specified, then SEC_COMMIT is the default.
+                // The documentation states that if no AllocationAttribute is specified,
+                // then SEC_COMMIT is the default.
                 // In practice, this isn't the case and specifying 0 will result in INVALID_PARAMETER_6.
                 .{ .COMMIT = true },
                 coff_file.handle,
@@ -368,6 +386,7 @@ const Module = struct {
             errdefer windows.CloseHandle(section_handle);
             var coff_len: usize = 0;
             var section_view_ptr: ?[*]const u8 = null;
+            const process_handle = windows.GetCurrentProcess();
             const map_section_rc = windows.ntdll.NtMapViewOfSection(
                 section_handle,
                 process_handle,
@@ -381,7 +400,13 @@ const Module = struct {
                 .{ .READONLY = true },
             );
             if (map_section_rc != .SUCCESS) return error.MissingDebugInfo;
-            errdefer assert(windows.ntdll.NtUnmapViewOfSection(process_handle, @constCast(section_view_ptr.?)) == .SUCCESS);
+            errdefer switch (windows.ntdll.NtUnmapViewOfSection(
+                process_handle,
+                @constCast(section_view_ptr.?),
+            )) {
+                .SUCCESS => {},
+                else => |status| windows.unexpectedStatus(status) catch {},
+            };
             const section_view = section_view_ptr.?[0..coff_len];
             coff_obj = coff.Coff.init(section_view, false) catch return error.InvalidDebugInfo;
             break :mapped .{
@@ -496,7 +521,6 @@ const Module = struct {
 
         return .{
             .arena = arena_instance.state,
-            .io = io,
             .coff_image_base = coff_image_base,
             .mapped_file = mapped_file,
             .dwarf = opt_dwarf,
@@ -509,52 +533,82 @@ const Module = struct {
 /// Assumes we already hold `si.mutex`.
 fn findModule(si: *SelfInfo, gpa: Allocator, address: usize) error{ MissingDebugInfo, OutOfMemory, Unexpected }!*Module {
     for (si.modules.items) |*mod| {
-        if (address >= mod.base_address and address < mod.base_address + mod.size) {
-            return mod;
-        }
+        const base = @intFromPtr(mod.entry.DllBase);
+        if (address >= base and address < base + mod.entry.SizeOfImage) return mod;
     }
-
-    // A new module might have been loaded; rebuild the list.
-    {
-        for (si.modules.items) |*mod| {
-            const di = &(mod.di orelse continue catch continue);
-            di.deinit(gpa);
-        }
-        si.modules.clearRetainingCapacity();
-
-        var module_name_arena = si.module_name_arena.promote(gpa);
-        defer si.module_name_arena = module_name_arena.state;
-        _ = module_name_arena.reset(.retain_capacity);
-
-        const handle = windows.kernel32.CreateToolhelp32Snapshot(windows.TH32CS_SNAPMODULE | windows.TH32CS_SNAPMODULE32, 0);
-        if (handle == windows.INVALID_HANDLE_VALUE) {
-            return windows.unexpectedError(windows.GetLastError());
-        }
-        defer windows.CloseHandle(handle);
-        var entry: windows.MODULEENTRY32 = undefined;
-        entry.dwSize = @sizeOf(windows.MODULEENTRY32);
-        var result = windows.kernel32.Module32First(handle, &entry);
-        while (result != 0) : (result = windows.kernel32.Module32Next(handle, &entry)) {
-            try si.modules.append(gpa, .{
-                .base_address = @intFromPtr(entry.modBaseAddr),
-                .size = entry.modBaseSize,
-                .name = try module_name_arena.allocator().dupe(
-                    u8,
-                    std.mem.sliceTo(&entry.szModule, 0),
-                ),
-                .handle = entry.hModule,
-                .di = null,
-            });
+    try si.modules.ensureUnusedCapacity(gpa, 1);
+    var entry: *LDR.DATA_TABLE_ENTRY = undefined;
+    switch (windows.ntdll.LdrFindEntryForAddress(@ptrFromInt(address), &entry)) {
+        .SUCCESS => {},
+        .DLL_NOT_FOUND => return error.MissingDebugInfo,
+        else => |status| return windows.unexpectedStatus(status),
+    }
+    if (si.notification_cookie == null) {
+        var notification_cookie: LDR.DLL_NOTIFICATION.COOKIE = undefined;
+        switch ((try si.getNtdllProc(.LdrRegisterDllNotification))(
+            .{},
+            &dllNotification,
+            si,
+            &notification_cookie,
+        )) {
+            .SUCCESS => si.notification_cookie = notification_cookie,
+            else => |status| return windows.unexpectedStatus(status),
         }
     }
+    const mod = si.modules.addOneAssumeCapacity();
+    mod.* = .{ .entry = entry, .name = null, .di = null };
+    return mod;
+}
 
-    for (si.modules.items) |*mod| {
-        if (address >= mod.base_address and address < mod.base_address + mod.size) {
-            return mod;
+inline fn getNtdllProc(
+    si: *SelfInfo,
+    comptime proc: std.meta.DeclEnum(windows.ntdll),
+) !@TypeOf(&@field(windows.ntdll, @tagName(proc))) {
+    return if (load_dll_notification_procs)
+        @ptrCast(try si.loadNtdllProc(@tagName(proc)))
+    else
+        &@field(windows.ntdll, @tagName(proc));
+}
+fn loadNtdllProc(si: *SelfInfo, name: []const u8) Io.UnexpectedError!*anyopaque {
+    const ntdll_handle = si.ntdll_handle orelse ntdll_handle: {
+        var ntdll_handle: *anyopaque = undefined;
+        switch (windows.ntdll.LdrLoadDll(null, null, &.init(
+            &.{ 'n', 't', 'd', 'l', 'l', '.', 'd', 'l', 'l' },
+        ), &ntdll_handle)) {
+            .SUCCESS => {},
+            else => |status| return windows.unexpectedStatus(status),
         }
+        si.ntdll_handle = ntdll_handle;
+        break :ntdll_handle ntdll_handle;
+    };
+    var proc_addr: *anyopaque = undefined;
+    switch (windows.ntdll.LdrGetProcedureAddress(ntdll_handle, &.init(name), 0, &proc_addr)) {
+        .SUCCESS => {},
+        else => |status| return windows.unexpectedStatus(status),
     }
+    return proc_addr;
+}
 
-    return error.MissingDebugInfo;
+fn dllNotification(
+    reason: LDR.DLL_NOTIFICATION.REASON,
+    data: *const LDR.DLL_NOTIFICATION.DATA,
+    context: ?*anyopaque,
+) callconv(.winapi) void {
+    const si: *SelfInfo = @ptrCast(@alignCast(context));
+    switch (reason) {
+        .LOADED => {},
+        .UNLOADED => {
+            const io = std.Options.debug_io;
+            si.mutex.lockUncancelable(io);
+            defer si.mutex.unlock(io);
+            for (si.modules.items, 0..) |*mod, mod_index| {
+                if (mod.entry.DllBase != data.Unloaded.DllBase) continue;
+                mod.deinit(std.debug.getDebugInfoAllocator(), io);
+                _ = si.modules.swapRemove(mod_index);
+                break;
+            }
+        },
+    }
 }
 
 const std = @import("std");
@@ -563,12 +617,23 @@ const Allocator = std.mem.Allocator;
 const Dwarf = std.debug.Dwarf;
 const Pdb = std.debug.Pdb;
 const Error = std.debug.SelfInfoError;
-const assert = std.debug.assert;
 const coff = std.coff;
 const fs = std.fs;
 const windows = std.os.windows;
+const LDR = windows.LDR;
 
 const builtin = @import("builtin");
 const native_endian = builtin.target.cpu.arch.endian();
+const load_dll_notification_procs = builtin.abi == .msvc and switch (builtin.zig_backend) {
+    .stage2_c => true,
+    else => switch (builtin.output_mode) {
+        .Exe => false,
+        .Lib => switch (builtin.link_mode) {
+            .static => true,
+            .dynamic => false,
+        },
+        .Obj => true,
+    },
+};
 
 const SelfInfo = @This();
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index cfe943fc2bfe6c373418e59d540a48f507a5bc8a..ba7ef0aabf4c77ef905aa14836ab0e91102b0ba1 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -110,11 +110,11 @@ pub fn defaultQueryPageSize() usize {
             break :size @intCast(vm_info.page_size);
         },
         .windows => {
-            var sbi: windows.SYSTEM_BASIC_INFORMATION = undefined;
+            var sbi: windows.SYSTEM.BASIC_INFORMATION = undefined;
             switch (windows.ntdll.NtQuerySystemInformation(
-                .SystemBasicInformation,
+                .Basic,
                 &sbi,
-                @sizeOf(windows.SYSTEM_BASIC_INFORMATION),
+                @sizeOf(windows.SYSTEM.BASIC_INFORMATION),
                 null,
             )) {
                 .SUCCESS => break :size sbi.PageSize,
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 86d4ce0efd3b8170ef819544d41f2ccc16351be3..0c91f11ff5693ef51e10bfdf9a8f528c3d15e5e5 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -24,6 +24,66 @@ pub const nls = @import("windows/nls.zig");
 
 pub const current_process: HANDLE = @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))));
 
+pub const OBJECT = struct {
+    // ref: um/winternl.h
+
+    pub const ATTRIBUTES = extern struct {
+        Length: ULONG = @sizeOf(ATTRIBUTES),
+        RootDirectory: ?HANDLE = null,
+        ObjectName: ?*UNICODE_STRING = @constCast(&UNICODE_STRING.empty),
+        Attributes: Flags = .{},
+        SecurityDescriptor: ?*anyopaque = null,
+        SecurityQualityOfService: ?*anyopaque = null,
+
+        // Valid values for the Attributes field
+        pub const Flags = packed struct(ULONG) {
+            Reserved0: u1 = 0,
+            INHERIT: bool = false,
+            Reserved2: u2 = 0,
+            PERMANENT: bool = false,
+            EXCLUSIVE: bool = false,
+            /// If name-lookup code should ignore the case of the ObjectName member rather than performing an exact-match search.
+            CASE_INSENSITIVE: bool = true,
+            OPENIF: bool = false,
+            OPENLINK: bool = false,
+            KERNEL_HANDLE: bool = false,
+            FORCE_ACCESS_CHECK: bool = false,
+            IGNORE_IMPERSONATED_DEVICEMAP: bool = false,
+            DONT_REPARSE: bool = false,
+            Reserved13: u19 = 0,
+
+            pub const VALID_ATTRIBUTES: ATTRIBUTES = .{
+                .INHERIT = true,
+                .PERMANENT = true,
+                .EXCLUSIVE = true,
+                .CASE_INSENSITIVE = true,
+                .OPENIF = true,
+                .OPENLINK = true,
+                .KERNEL_HANDLE = true,
+                .FORCE_ACCESS_CHECK = true,
+                .IGNORE_IMPERSONATED_DEVICEMAP = true,
+                .DONT_REPARSE = true,
+            };
+        };
+    };
+
+    pub const INFORMATION_CLASS = enum(c_int) {
+        Basic = 0,
+        Name = 1,
+        Type = 2,
+        Types = 3,
+        HandleFlag = 4,
+        Session = 5,
+        _,
+
+        pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".fields.len;
+    };
+
+    pub const NAME_INFORMATION = extern struct {
+        Name: UNICODE_STRING,
+    };
+};
+
 pub const FILE = struct {
     // ref: km/ntddk.h
 
@@ -73,6 +133,94 @@ pub const FILE = struct {
 
     // ref: km/ntifs.h
 
+    pub const NAME_FLAGS = packed struct(UCHAR) {
+        NTFS: bool = false,
+        DOS: bool = false,
+        Reserved2: u5 = 0,
+        UNSPECIFIED: bool = false,
+    };
+
+    pub const NOTIFY = struct {
+        pub const CHANGE = packed struct(ULONG) {
+            FILE_NAME: bool = false,
+            DIR_NAME: bool = false,
+            ATTRIBUTES: bool = false,
+            SIZE: bool = false,
+            LAST_WRITE: bool = false,
+            LAST_ACCESS: bool = false,
+            CREATION: bool = false,
+            EA: bool = false,
+            SECURITY: bool = false,
+            STREAM_NAME: bool = false,
+            STREAM_SIZE: bool = false,
+            STREAM_WRITE: bool = false,
+            Reserved12: u20 = 0,
+        };
+
+        pub const INFORMATION = extern struct {
+            NextEntryOffset: ULONG,
+            Action: ULONG,
+            FileNameLength: ULONG,
+            FileName: [0]WCHAR,
+
+            pub fn fileName(info: *INFORMATION) []WCHAR {
+                const ptr: [*]WCHAR = @ptrCast(&info.FileName);
+                return ptr[0..@divExact(info.FileNameLength, @sizeOf(WCHAR))];
+            }
+        };
+
+        pub const EXTENDED_INFORMATION = extern struct {
+            NextEntryOffset: ULONG,
+            Action: ULONG,
+            CreationTime: LARGE_INTEGER,
+            LastModificationTime: LARGE_INTEGER,
+            LastChangeTime: LARGE_INTEGER,
+            LastAccessTime: LARGE_INTEGER,
+            AllocatedLength: LARGE_INTEGER,
+            FileSize: LARGE_INTEGER,
+            FileAttributes: ATTRIBUTE,
+            u: extern union {
+                ReparsePointTag: ULONG,
+                EaSize: ULONG,
+            },
+            FileId: LARGE_INTEGER,
+            ParentFileId: LARGE_INTEGER,
+            FileNameLength: ULONG,
+            FileName: [0]WCHAR,
+
+            pub fn fileName(info: *INFORMATION) []WCHAR {
+                const ptr: [*]WCHAR = @ptrCast(&info.FileName);
+                return ptr[0..@divExact(info.FileNameLength, @sizeOf(WCHAR))];
+            }
+        };
+
+        pub const FULL_INFORMATION = extern struct {
+            NextEntryOffset: ULONG,
+            Action: ULONG,
+            CreationTime: LARGE_INTEGER,
+            LastModificationTime: LARGE_INTEGER,
+            LastChangeTime: LARGE_INTEGER,
+            LastAccessTime: LARGE_INTEGER,
+            AllocatedLength: LARGE_INTEGER,
+            FileSize: LARGE_INTEGER,
+            FileAttributes: ATTRIBUTE,
+            u: extern union {
+                ReparsePointTag: ULONG,
+                EaSize: ULONG,
+            },
+            FileId: LARGE_INTEGER,
+            ParentFileId: LARGE_INTEGER,
+            FileNameLength: ULONG,
+            FileNameFlags: NAME_FLAGS,
+            FileName: [0]WCHAR,
+
+            pub fn fileName(info: *INFORMATION) []WCHAR {
+                const ptr: [*]WCHAR = @ptrCast(&info.FileName);
+                return ptr[0..@divExact(info.FileNameLength, @sizeOf(WCHAR))];
+            }
+        };
+    };
+
     pub const PIPE = struct {
         /// Define the `NamedPipeType` flags for `NtCreateNamedPipeFile`
         pub const TYPE = packed struct(ULONG) {
@@ -357,6 +505,7 @@ pub const FILE = struct {
         IdAllExtdBothDirectory = 81,
         StreamReservation = 82,
         MupProvider = 83,
+        _,
 
         pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".fields.len;
     };
@@ -647,6 +796,19 @@ pub const FILE = struct {
             Mode: MODE,
         };
     };
+
+    // ref: km/
+};
+
+pub const DIRECTORY = struct {
+    pub const NOTIFY_INFORMATION_CLASS = enum(c_int) {
+        Notify = 1,
+        NotifyExtended = 2,
+        NotifyFull = 3,
+        _,
+
+        pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".fields.len;
+    };
 };
 
 pub const CONSOLE = struct {
@@ -880,141 +1042,229 @@ pub const CONSOLE = struct {
 
 // ref: km/ntddk.h
 
-pub const PROCESSINFOCLASS = enum(c_int) {
-    BasicInformation = 0,
-    QuotaLimits = 1,
-    IoCounters = 2,
-    VmCounters = 3,
-    Times = 4,
-    BasePriority = 5,
-    RaisePriority = 6,
-    DebugPort = 7,
-    ExceptionPort = 8,
-    AccessToken = 9,
-    LdtInformation = 10,
-    LdtSize = 11,
-    DefaultHardErrorMode = 12,
-    IoPortHandlers = 13,
-    PooledUsageAndLimits = 14,
-    WorkingSetWatch = 15,
-    UserModeIOPL = 16,
-    EnableAlignmentFaultFixup = 17,
-    PriorityClass = 18,
-    Wx86Information = 19,
-    HandleCount = 20,
-    AffinityMask = 21,
-    PriorityBoost = 22,
-    DeviceMap = 23,
-    SessionInformation = 24,
-    ForegroundInformation = 25,
-    Wow64Information = 26,
-    ImageFileName = 27,
-    LUIDDeviceMapsEnabled = 28,
-    BreakOnTermination = 29,
-    DebugObjectHandle = 30,
-    DebugFlags = 31,
-    HandleTracing = 32,
-    IoPriority = 33,
-    ExecuteFlags = 34,
-    TlsInformation = 35,
-    Cookie = 36,
-    ImageInformation = 37,
-    CycleTime = 38,
-    PagePriority = 39,
-    InstrumentationCallback = 40,
-    ThreadStackAllocation = 41,
-    WorkingSetWatchEx = 42,
-    ImageFileNameWin32 = 43,
-    ImageFileMapping = 44,
-    AffinityUpdateMode = 45,
-    MemoryAllocationMode = 46,
-    GroupInformation = 47,
-    TokenVirtualizationEnabled = 48,
-    OwnerInformation = 49,
-    WindowInformation = 50,
-    HandleInformation = 51,
-    MitigationPolicy = 52,
-    DynamicFunctionTableInformation = 53,
-    HandleCheckingMode = 54,
-    KeepAliveCount = 55,
-    RevokeFileHandles = 56,
-    WorkingSetControl = 57,
-    HandleTable = 58,
-    CheckStackExtentsMode = 59,
-    CommandLineInformation = 60,
-    ProtectionInformation = 61,
-    MemoryExhaustion = 62,
-    FaultInformation = 63,
-    TelemetryIdInformation = 64,
-    CommitReleaseInformation = 65,
-    Reserved1Information = 66,
-    Reserved2Information = 67,
-    SubsystemProcess = 68,
-    InPrivate = 70,
-    RaiseUMExceptionOnInvalidHandleClose = 71,
-    SubsystemInformation = 75,
-    Win32kSyscallFilterInformation = 79,
-    EnergyTrackingState = 82,
-    NetworkIoCounters = 114,
-    _,
+pub const SYSTEM = struct {
+    pub const INFORMATION_CLASS = enum(c_int) {
+        Basic = 0,
+        Performance = 2,
+        TimeOfDay = 3,
+        Process = 5,
+        ProcessorPerformance = 8,
+        Interrupt = 23,
+        Exception = 33,
+        RegistryQuota = 37,
+        Lookaside = 45,
+        CodeIntegrity = 103,
+        Policy = 134,
+        _,
+    };
 
-    pub const Max: @typeInfo(@This()).@"enum".tag_type = 117;
+    pub const BASIC_INFORMATION = extern struct {
+        Reserved: ULONG,
+        TimerResolution: ULONG,
+        PageSize: ULONG,
+        NumberOfPhysicalPages: ULONG,
+        LowestPhysicalPageNumber: ULONG,
+        HighestPhysicalPageNumber: ULONG,
+        AllocationGranularity: ULONG,
+        MinimumUserModeAddress: ULONG_PTR,
+        MaximumUserModeAddress: ULONG_PTR,
+        ActiveProcessorsAffinityMask: KAFFINITY,
+        NumberOfProcessors: UCHAR,
+    };
 };
 
-pub const THREADINFOCLASS = enum(c_int) {
-    BasicInformation = 0,
-    Times = 1,
-    Priority = 2,
-    BasePriority = 3,
-    AffinityMask = 4,
-    ImpersonationToken = 5,
-    DescriptorTableEntry = 6,
-    EnableAlignmentFaultFixup = 7,
-    EventPair_Reusable = 8,
-    QuerySetWin32StartAddress = 9,
-    ZeroTlsCell = 10,
-    PerformanceCount = 11,
-    AmILastThread = 12,
-    IdealProcessor = 13,
-    PriorityBoost = 14,
-    SetTlsArrayAddress = 15,
-    IsIoPending = 16,
-    // Windows 2000+ from here
-    HideFromDebugger = 17,
-    // Windows XP+ from here
-    BreakOnTermination = 18,
-    SwitchLegacyState = 19,
-    IsTerminated = 20,
-    // Windows Vista+ from here
-    LastSystemCall = 21,
-    IoPriority = 22,
-    CycleTime = 23,
-    PagePriority = 24,
-    ActualBasePriority = 25,
-    TebInformation = 26,
-    CSwitchMon = 27,
-    // Windows 7+ from here
-    CSwitchPmu = 28,
-    Wow64Context = 29,
-    GroupInformation = 30,
-    UmsInformation = 31,
-    CounterProfiling = 32,
-    IdealProcessorEx = 33,
-    // Windows 8+ from here
-    CpuAccountingInformation = 34,
-    // Windows 8.1+ from here
-    SuspendCount = 35,
-    // Windows 10+ from here
-    HeterogeneousCpuPolicy = 36,
-    ContainerId = 37,
-    NameInformation = 38,
-    SelectedCpuSets = 39,
-    SystemThreadInformation = 40,
-    ActualGroupAffinity = 41,
-    DynamicCodePolicyInfo = 42,
-    SubsystemInformation = 45,
+pub const PROCESS = struct {
+    pub const INFORMATION = extern struct {
+        hProcess: HANDLE,
+        hThread: HANDLE,
+        dwProcessId: DWORD,
+        dwThreadId: DWORD,
+    };
 
-    pub const Max: @typeInfo(@This()).@"enum".tag_type = 60;
+    pub const INFOCLASS = enum(c_int) {
+        BasicInformation = 0,
+        QuotaLimits = 1,
+        IoCounters = 2,
+        VmCounters = 3,
+        Times = 4,
+        BasePriority = 5,
+        RaisePriority = 6,
+        DebugPort = 7,
+        ExceptionPort = 8,
+        AccessToken = 9,
+        LdtInformation = 10,
+        LdtSize = 11,
+        DefaultHardErrorMode = 12,
+        IoPortHandlers = 13,
+        PooledUsageAndLimits = 14,
+        WorkingSetWatch = 15,
+        UserModeIOPL = 16,
+        EnableAlignmentFaultFixup = 17,
+        PriorityClass = 18,
+        Wx86Information = 19,
+        HandleCount = 20,
+        AffinityMask = 21,
+        PriorityBoost = 22,
+        DeviceMap = 23,
+        SessionInformation = 24,
+        ForegroundInformation = 25,
+        Wow64Information = 26,
+        ImageFileName = 27,
+        LUIDDeviceMapsEnabled = 28,
+        BreakOnTermination = 29,
+        DebugObjectHandle = 30,
+        DebugFlags = 31,
+        HandleTracing = 32,
+        IoPriority = 33,
+        ExecuteFlags = 34,
+        TlsInformation = 35,
+        Cookie = 36,
+        ImageInformation = 37,
+        CycleTime = 38,
+        PagePriority = 39,
+        InstrumentationCallback = 40,
+        ThreadStackAllocation = 41,
+        WorkingSetWatchEx = 42,
+        ImageFileNameWin32 = 43,
+        ImageFileMapping = 44,
+        AffinityUpdateMode = 45,
+        MemoryAllocationMode = 46,
+        GroupInformation = 47,
+        TokenVirtualizationEnabled = 48,
+        OwnerInformation = 49,
+        WindowInformation = 50,
+        HandleInformation = 51,
+        MitigationPolicy = 52,
+        DynamicFunctionTableInformation = 53,
+        HandleCheckingMode = 54,
+        KeepAliveCount = 55,
+        RevokeFileHandles = 56,
+        WorkingSetControl = 57,
+        HandleTable = 58,
+        CheckStackExtentsMode = 59,
+        CommandLineInformation = 60,
+        ProtectionInformation = 61,
+        MemoryExhaustion = 62,
+        FaultInformation = 63,
+        TelemetryIdInformation = 64,
+        CommitReleaseInformation = 65,
+        Reserved1Information = 66,
+        Reserved2Information = 67,
+        SubsystemProcess = 68,
+        InPrivate = 70,
+        RaiseUMExceptionOnInvalidHandleClose = 71,
+        SubsystemInformation = 75,
+        Win32kSyscallFilterInformation = 79,
+        EnergyTrackingState = 82,
+        NetworkIoCounters = 114,
+        _,
+
+        pub const Max: @typeInfo(@This()).@"enum".tag_type = 117;
+    };
+
+    pub const BASIC_INFORMATION = extern struct {
+        ExitStatus: NTSTATUS,
+        PebBaseAddress: *PEB,
+        AffinityMask: ULONG_PTR,
+        BasePriority: KPRIORITY,
+        UniqueProcessId: ULONG_PTR,
+        InheritedFromUniqueProcessId: ULONG_PTR,
+    };
+
+    pub const VM_COUNTERS = extern struct {
+        PeakVirtualSize: SIZE_T,
+        VirtualSize: SIZE_T,
+        PageFaultCount: ULONG,
+        PeakWorkingSetSize: SIZE_T,
+        WorkingSetSize: SIZE_T,
+        QuotaPeakPagedPoolUsage: SIZE_T,
+        QuotaPagedPoolUsage: SIZE_T,
+        QuotaPeakNonPagedPoolUsage: SIZE_T,
+        QuotaNonPagedPoolUsage: SIZE_T,
+        PagefileUsage: SIZE_T,
+        PeakPagefileUsage: SIZE_T,
+    };
+};
+
+pub const THREAD = struct {
+    pub const INFOCLASS = enum(c_int) {
+        BasicInformation = 0,
+        Times = 1,
+        Priority = 2,
+        BasePriority = 3,
+        AffinityMask = 4,
+        ImpersonationToken = 5,
+        DescriptorTableEntry = 6,
+        EnableAlignmentFaultFixup = 7,
+        EventPair_Reusable = 8,
+        QuerySetWin32StartAddress = 9,
+        ZeroTlsCell = 10,
+        PerformanceCount = 11,
+        AmILastThread = 12,
+        IdealProcessor = 13,
+        PriorityBoost = 14,
+        SetTlsArrayAddress = 15,
+        IsIoPending = 16,
+        // Windows 2000+ from here
+        HideFromDebugger = 17,
+        // Windows XP+ from here
+        BreakOnTermination = 18,
+        SwitchLegacyState = 19,
+        IsTerminated = 20,
+        // Windows Vista+ from here
+        LastSystemCall = 21,
+        IoPriority = 22,
+        CycleTime = 23,
+        PagePriority = 24,
+        ActualBasePriority = 25,
+        TebInformation = 26,
+        CSwitchMon = 27,
+        // Windows 7+ from here
+        CSwitchPmu = 28,
+        Wow64Context = 29,
+        GroupInformation = 30,
+        UmsInformation = 31,
+        CounterProfiling = 32,
+        IdealProcessorEx = 33,
+        // Windows 8+ from here
+        CpuAccountingInformation = 34,
+        // Windows 8.1+ from here
+        SuspendCount = 35,
+        // Windows 10+ from here
+        HeterogeneousCpuPolicy = 36,
+        ContainerId = 37,
+        NameInformation = 38,
+        SelectedCpuSets = 39,
+        SystemThreadInformation = 40,
+        ActualGroupAffinity = 41,
+        DynamicCodePolicyInfo = 42,
+        SubsystemInformation = 45,
+        _,
+
+        pub const Max: @typeInfo(@This()).@"enum".tag_type = 60;
+    };
+
+    pub const BASIC_INFORMATION = extern struct {
+        ExitStatus: NTSTATUS,
+        TebBaseAddress: PVOID,
+        ClientId: CLIENT_ID,
+        AffinityMask: KAFFINITY,
+        Priority: KPRIORITY,
+        BasePriority: KPRIORITY,
+    };
+};
+
+pub const MEMORY = struct {
+    pub const BASIC_INFORMATION = extern struct {
+        BaseAddress: PVOID,
+        AllocationBase: PVOID,
+        AllocationProtect: DWORD,
+        PartitionId: WORD,
+        RegionSize: SIZE_T,
+        State: DWORD,
+        Protect: DWORD,
+        Type: DWORD,
+    };
 };
 
 // ref: km/ntifs.h
@@ -2560,48 +2810,6 @@ pub fn GetProcessHeap() ?*HEAP {
     return peb().ProcessHeap;
 }
 
-// ref: um/winternl.h
-
-pub const OBJECT_ATTRIBUTES = extern struct {
-    Length: ULONG = @sizeOf(OBJECT_ATTRIBUTES),
-    RootDirectory: ?HANDLE = null,
-    ObjectName: ?*UNICODE_STRING = @constCast(&UNICODE_STRING.empty),
-    Attributes: ATTRIBUTES = .{},
-    SecurityDescriptor: ?*anyopaque = null,
-    SecurityQualityOfService: ?*anyopaque = null,
-
-    // Valid values for the Attributes field
-    pub const ATTRIBUTES = packed struct(ULONG) {
-        Reserved0: u1 = 0,
-        INHERIT: bool = false,
-        Reserved2: u2 = 0,
-        PERMANENT: bool = false,
-        EXCLUSIVE: bool = false,
-        /// If name-lookup code should ignore the case of the ObjectName member rather than performing an exact-match search.
-        CASE_INSENSITIVE: bool = true,
-        OPENIF: bool = false,
-        OPENLINK: bool = false,
-        KERNEL_HANDLE: bool = false,
-        FORCE_ACCESS_CHECK: bool = false,
-        IGNORE_IMPERSONATED_DEVICEMAP: bool = false,
-        DONT_REPARSE: bool = false,
-        Reserved13: u19 = 0,
-
-        pub const VALID_ATTRIBUTES: ATTRIBUTES = .{
-            .INHERIT = true,
-            .PERMANENT = true,
-            .EXCLUSIVE = true,
-            .CASE_INSENSITIVE = true,
-            .OPENIF = true,
-            .OPENLINK = true,
-            .KERNEL_HANDLE = true,
-            .FORCE_ACCESS_CHECK = true,
-            .IGNORE_IMPERSONATED_DEVICEMAP = true,
-            .DONT_REPARSE = true,
-        };
-    };
-};
-
 // ref none
 
 pub fn GetCurrentProcess() HANDLE {
@@ -2623,297 +2831,13 @@ pub fn GetCurrentThreadId() DWORD {
 }
 
 pub fn GetLastError() Win32Error {
-    return @enumFromInt(teb().LastErrorValue);
-}
-/// A Zig wrapper around `NtDeviceIoControlFile` and `NtFsControlFile` syscalls.
-/// It implements similar behavior to `DeviceIoControl` and is meant to serve
-/// as a direct substitute for that call.
-/// TODO work out if we need to expose other arguments to the underlying syscalls.
-pub fn DeviceIoControl(
-    device: HANDLE,
-    io_control_code: CTL_CODE,
-    opts: struct {
-        event: ?HANDLE = null,
-        apc_routine: ?*const IO_APC_ROUTINE = null,
-        apc_context: ?*anyopaque = null,
-        io_status_block: ?*IO_STATUS_BLOCK = null,
-        in: []const u8 = &.{},
-        out: []u8 = &.{},
-    },
-) NTSTATUS {
-    var io_status_block: IO_STATUS_BLOCK = undefined;
-    return switch (io_control_code.DeviceType) {
-        .FILE_SYSTEM, .NAMED_PIPE => ntdll.NtFsControlFile(
-            device,
-            opts.event,
-            opts.apc_routine,
-            opts.apc_context,
-            opts.io_status_block orelse &io_status_block,
-            io_control_code,
-            if (opts.in.len > 0) opts.in.ptr else null,
-            @intCast(opts.in.len),
-            if (opts.out.len > 0) opts.out.ptr else null,
-            @intCast(opts.out.len),
-        ),
-        else => ntdll.NtDeviceIoControlFile(
-            device,
-            opts.event,
-            opts.apc_routine,
-            opts.apc_context,
-            opts.io_status_block orelse &io_status_block,
-            io_control_code,
-            if (opts.in.len > 0) opts.in.ptr else null,
-            @intCast(opts.in.len),
-            if (opts.out.len > 0) opts.out.ptr else null,
-            @intCast(opts.out.len),
-        ),
-    };
-}
-
-pub fn GetOverlappedResult(h: HANDLE, overlapped: *OVERLAPPED, wait: bool) !DWORD {
-    var bytes: DWORD = undefined;
-    if (kernel32.GetOverlappedResult(h, overlapped, &bytes, @intFromBool(wait)) == 0) {
-        switch (GetLastError()) {
-            .IO_INCOMPLETE => if (!wait) return error.WouldBlock else unreachable,
-            else => |err| return unexpectedError(err),
-        }
-    }
-    return bytes;
-}
-
-pub const CreateIoCompletionPortError = error{Unexpected};
-
-pub fn CreateIoCompletionPort(
-    file_handle: HANDLE,
-    existing_completion_port: ?HANDLE,
-    completion_key: usize,
-    concurrent_thread_count: DWORD,
-) CreateIoCompletionPortError!HANDLE {
-    const handle = kernel32.CreateIoCompletionPort(file_handle, existing_completion_port, completion_key, concurrent_thread_count) orelse {
-        switch (GetLastError()) {
-            .INVALID_PARAMETER => unreachable,
-            else => |err| return unexpectedError(err),
-        }
-    };
-    return handle;
-}
-
-pub const PostQueuedCompletionStatusError = error{Unexpected};
-
-pub fn PostQueuedCompletionStatus(
-    completion_port: HANDLE,
-    bytes_transferred_count: DWORD,
-    completion_key: usize,
-    lpOverlapped: ?*OVERLAPPED,
-) PostQueuedCompletionStatusError!void {
-    if (kernel32.PostQueuedCompletionStatus(completion_port, bytes_transferred_count, completion_key, lpOverlapped) == 0) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-}
-
-pub const GetQueuedCompletionStatusResult = enum {
-    Normal,
-    Aborted,
-    Canceled,
-    EOF,
-    Timeout,
-};
-
-pub fn GetQueuedCompletionStatus(
-    completion_port: HANDLE,
-    bytes_transferred_count: *DWORD,
-    lpCompletionKey: *usize,
-    lpOverlapped: *?*OVERLAPPED,
-    dwMilliseconds: DWORD,
-) GetQueuedCompletionStatusResult {
-    if (kernel32.GetQueuedCompletionStatus(
-        completion_port,
-        bytes_transferred_count,
-        lpCompletionKey,
-        lpOverlapped,
-        dwMilliseconds,
-    ) == FALSE) {
-        switch (GetLastError()) {
-            .ABANDONED_WAIT_0 => return GetQueuedCompletionStatusResult.Aborted,
-            .OPERATION_ABORTED => return GetQueuedCompletionStatusResult.Canceled,
-            .HANDLE_EOF => return GetQueuedCompletionStatusResult.EOF,
-            .WAIT_TIMEOUT => return GetQueuedCompletionStatusResult.Timeout,
-            else => |err| {
-                if (std.debug.runtime_safety) {
-                    @setEvalBranchQuota(2500);
-                    std.debug.panic("unexpected error: {}\n", .{err});
-                }
-            },
-        }
-    }
-    return GetQueuedCompletionStatusResult.Normal;
-}
-
-pub const GetQueuedCompletionStatusError = error{
-    Aborted,
-    Canceled,
-    EOF,
-    Timeout,
-} || UnexpectedError;
-
-pub fn GetQueuedCompletionStatusEx(
-    completion_port: HANDLE,
-    completion_port_entries: []OVERLAPPED_ENTRY,
-    timeout_ms: ?DWORD,
-    alertable: bool,
-) GetQueuedCompletionStatusError!u32 {
-    var num_entries_removed: u32 = 0;
-
-    const success = kernel32.GetQueuedCompletionStatusEx(
-        completion_port,
-        completion_port_entries.ptr,
-        @as(ULONG, @intCast(completion_port_entries.len)),
-        &num_entries_removed,
-        timeout_ms orelse INFINITE,
-        @intFromBool(alertable),
-    );
-
-    if (success == FALSE) {
-        return switch (GetLastError()) {
-            .ABANDONED_WAIT_0 => error.Aborted,
-            .OPERATION_ABORTED => error.Canceled,
-            .HANDLE_EOF => error.EOF,
-            .WAIT_TIMEOUT => error.Timeout,
-            else => |err| unexpectedError(err),
-        };
-    }
-
-    return num_entries_removed;
+    return teb().LastErrorValue;
 }
 
 pub fn CloseHandle(hObject: HANDLE) void {
-    assert(ntdll.NtClose(hObject) == .SUCCESS);
-}
-
-pub fn getpeername(s: ws2_32.SOCKET, name: *ws2_32.sockaddr, namelen: *ws2_32.socklen_t) i32 {
-    return ws2_32.getpeername(s, name, @as(*i32, @ptrCast(namelen)));
-}
-
-pub fn sendmsg(
-    s: ws2_32.SOCKET,
-    msg: *ws2_32.WSAMSG_const,
-    flags: u32,
-) i32 {
-    var bytes_send: DWORD = undefined;
-    if (ws2_32.WSASendMsg(s, msg, flags, &bytes_send, null, null) == ws2_32.SOCKET_ERROR) {
-        return ws2_32.SOCKET_ERROR;
-    } else {
-        return @as(i32, @as(u31, @intCast(bytes_send)));
-    }
-}
-
-pub fn sendto(s: ws2_32.SOCKET, buf: [*]const u8, len: usize, flags: u32, to: ?*const ws2_32.sockaddr, to_len: ws2_32.socklen_t) i32 {
-    var buffer = ws2_32.WSABUF{ .len = @as(u31, @truncate(len)), .buf = @constCast(buf) };
-    var bytes_send: DWORD = undefined;
-    if (ws2_32.WSASendTo(s, @as([*]ws2_32.WSABUF, @ptrCast(&buffer)), 1, &bytes_send, flags, to, @as(i32, @intCast(to_len)), null, null) == ws2_32.SOCKET_ERROR) {
-        return ws2_32.SOCKET_ERROR;
-    } else {
-        return @as(i32, @as(u31, @intCast(bytes_send)));
-    }
-}
-
-pub fn recvfrom(s: ws2_32.SOCKET, buf: [*]u8, len: usize, flags: u32, from: ?*ws2_32.sockaddr, from_len: ?*ws2_32.socklen_t) i32 {
-    var buffer = ws2_32.WSABUF{ .len = @as(u31, @truncate(len)), .buf = buf };
-    var bytes_received: DWORD = undefined;
-    var flags_inout = flags;
-    if (ws2_32.WSARecvFrom(s, @as([*]ws2_32.WSABUF, @ptrCast(&buffer)), 1, &bytes_received, &flags_inout, from, @as(?*i32, @ptrCast(from_len)), null, null) == ws2_32.SOCKET_ERROR) {
-        return ws2_32.SOCKET_ERROR;
-    } else {
-        return @as(i32, @as(u31, @intCast(bytes_received)));
-    }
-}
-
-pub fn poll(fds: [*]ws2_32.pollfd, n: c_ulong, timeout: i32) i32 {
-    return ws2_32.WSAPoll(fds, n, timeout);
-}
-
-pub fn WSAIoctl(
-    s: ws2_32.SOCKET,
-    dwIoControlCode: DWORD,
-    inBuffer: ?[]const u8,
-    outBuffer: []u8,
-    overlapped: ?*OVERLAPPED,
-    completionRoutine: ?ws2_32.LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) !DWORD {
-    var bytes: DWORD = undefined;
-    switch (ws2_32.WSAIoctl(
-        s,
-        dwIoControlCode,
-        if (inBuffer) |i| i.ptr else null,
-        if (inBuffer) |i| @as(DWORD, @intCast(i.len)) else 0,
-        outBuffer.ptr,
-        @as(DWORD, @intCast(outBuffer.len)),
-        &bytes,
-        overlapped,
-        completionRoutine,
-    )) {
-        0 => {},
-        ws2_32.SOCKET_ERROR => switch (ws2_32.WSAGetLastError()) {
-            else => |err| return unexpectedWSAError(err),
-        },
-        else => unreachable,
-    }
-    return bytes;
-}
-
-const GetModuleFileNameError = error{Unexpected};
-
-pub fn GetModuleFileNameW(hModule: ?HMODULE, buf_ptr: [*]u16, buf_len: DWORD) GetModuleFileNameError![:0]u16 {
-    const rc = kernel32.GetModuleFileNameW(hModule, buf_ptr, buf_len);
-    if (rc == 0) {
-        switch (GetLastError()) {
-            else => |err| return unexpectedError(err),
-        }
-    }
-    return buf_ptr[0..rc :0];
-}
-
-pub const NtAllocateVirtualMemoryError = error{
-    AccessDenied,
-    InvalidParameter,
-    NoMemory,
-    Unexpected,
-};
-
-pub fn NtAllocateVirtualMemory(hProcess: HANDLE, addr: ?*PVOID, zero_bits: ULONG_PTR, size: ?*SIZE_T, alloc_type: ULONG, protect: ULONG) NtAllocateVirtualMemoryError!void {
-    return switch (ntdll.NtAllocateVirtualMemory(hProcess, addr, zero_bits, size, alloc_type, protect)) {
-        .SUCCESS => return,
-        .ACCESS_DENIED => NtAllocateVirtualMemoryError.AccessDenied,
-        .INVALID_PARAMETER => NtAllocateVirtualMemoryError.InvalidParameter,
-        .NO_MEMORY => NtAllocateVirtualMemoryError.NoMemory,
-        else => |st| unexpectedStatus(st),
-    };
-}
-
-pub const NtFreeVirtualMemoryError = error{
-    AccessDenied,
-    InvalidParameter,
-    Unexpected,
-};
-
-pub fn NtFreeVirtualMemory(hProcess: HANDLE, addr: ?*PVOID, size: *SIZE_T, free_type: ULONG) NtFreeVirtualMemoryError!void {
-    // TODO: If the return value is .INVALID_PAGE_PROTECTION, call RtlFlushSecureMemoryCache and try again.
-    return switch (ntdll.NtFreeVirtualMemory(hProcess, addr, size, free_type)) {
-        .SUCCESS => return,
-        .ACCESS_DENIED => NtFreeVirtualMemoryError.AccessDenied,
-        .INVALID_PARAMETER => NtFreeVirtualMemoryError.InvalidParameter,
-        else => NtFreeVirtualMemoryError.Unexpected,
-    };
-}
-
-pub fn SetFileCompletionNotificationModes(handle: HANDLE, flags: UCHAR) !void {
-    const success = kernel32.SetFileCompletionNotificationModes(handle, flags);
-    if (success == FALSE) {
-        return switch (GetLastError()) {
-            else => |err| unexpectedError(err),
-        };
+    switch (ntdll.NtClose(hObject)) {
+        .SUCCESS => {},
+        else => |status| unexpectedStatus(status) catch {},
     }
 }
 
@@ -2963,114 +2887,75 @@ pub const CreateProcessFlags = packed struct(u32) {
     create_ignore_system_default: bool = false,
 };
 
-pub const LoadLibraryError = error{
-    FileNotFound,
-    Unexpected,
-};
-
-pub fn LoadLibraryW(lpLibFileName: [*:0]const u16) LoadLibraryError!HMODULE {
-    return kernel32.LoadLibraryW(lpLibFileName) orelse {
-        switch (GetLastError()) {
-            .FILE_NOT_FOUND => return error.FileNotFound,
-            .PATH_NOT_FOUND => return error.FileNotFound,
-            .MOD_NOT_FOUND => return error.FileNotFound,
-            else => |err| return unexpectedError(err),
-        }
-    };
-}
-
-pub const LoadLibraryFlags = enum(DWORD) {
-    none = 0,
-    dont_resolve_dll_references = 0x00000001,
-    load_ignore_code_authz_level = 0x00000010,
-    load_library_as_datafile = 0x00000002,
-    load_library_as_datafile_exclusive = 0x00000040,
-    load_library_as_image_resource = 0x00000020,
-    load_library_search_application_dir = 0x00000200,
-    load_library_search_default_dirs = 0x00001000,
-    load_library_search_dll_load_dir = 0x00000100,
-    load_library_search_system32 = 0x00000800,
-    load_library_search_user_dirs = 0x00000400,
-    load_with_altered_search_path = 0x00000008,
-    load_library_require_signed_target = 0x00000080,
-    load_library_safe_current_dirs = 0x00002000,
-};
-
-pub fn LoadLibraryExW(lpLibFileName: [*:0]const u16, dwFlags: LoadLibraryFlags) LoadLibraryError!HMODULE {
-    return kernel32.LoadLibraryExW(lpLibFileName, null, @intFromEnum(dwFlags)) orelse {
-        switch (GetLastError()) {
-            .FILE_NOT_FOUND => return error.FileNotFound,
-            .PATH_NOT_FOUND => return error.FileNotFound,
-            .MOD_NOT_FOUND => return error.FileNotFound,
-            else => |err| return unexpectedError(err),
-        }
-    };
-}
-
-pub fn FreeLibrary(hModule: HMODULE) void {
-    assert(kernel32.FreeLibrary(hModule) != 0);
-}
-
-pub fn QueryPerformanceFrequency() u64 {
-    // "On systems that run Windows XP or later, the function will always succeed"
-    // https://docs.microsoft.com/en-us/windows/desktop/api/profileapi/nf-profileapi-queryperformancefrequency
-    var result: LARGE_INTEGER = undefined;
-    assert(ntdll.RtlQueryPerformanceFrequency(&result) != 0);
-    // The kernel treats this integer as unsigned.
-    return @as(u64, @bitCast(result));
-}
-
-pub fn QueryPerformanceCounter() u64 {
-    // "On systems that run Windows XP or later, the function will always succeed"
-    // https://docs.microsoft.com/en-us/windows/desktop/api/profileapi/nf-profileapi-queryperformancecounter
-    var result: LARGE_INTEGER = undefined;
-    assert(ntdll.RtlQueryPerformanceCounter(&result) != 0);
-    // The kernel treats this integer as unsigned.
-    return @as(u64, @bitCast(result));
-}
-
-/// This is a workaround for the C backend until zig has the ability to put
-/// C code in inline assembly.
-extern fn zig_thumb_windows_teb() callconv(.c) *anyopaque;
-extern fn zig_aarch64_windows_teb() callconv(.c) *anyopaque;
-extern fn zig_x86_windows_teb() callconv(.c) *anyopaque;
-extern fn zig_x86_64_windows_teb() callconv(.c) *anyopaque;
-
 pub fn teb() *TEB {
-    return switch (native_arch) {
-        .thumb => if (builtin.zig_backend == .stage2_c)
-            @ptrCast(@alignCast(zig_thumb_windows_teb()))
-        else
-            asm (
-                \\ mrc p15, 0, %[ptr], c13, c0, 2
-                : [ptr] "=r" (-> *TEB),
-            ),
-        .aarch64 => if (builtin.zig_backend == .stage2_c)
-            @ptrCast(@alignCast(zig_aarch64_windows_teb()))
-        else
-            asm (
-                \\ mov %[ptr], x18
-                : [ptr] "=r" (-> *TEB),
-            ),
-        .x86 => if (builtin.zig_backend == .stage2_c)
-            @ptrCast(@alignCast(zig_x86_windows_teb()))
-        else
-            asm (
+    if (builtin.zig_backend == .stage2_c) return @ptrCast(@alignCast(struct {
+        /// This is a workaround for the C backend until zig has the ability to put
+        /// C code in inline assembly.
+        extern fn zig_windows_teb() callconv(.c) *anyopaque;
+    }.zig_windows_teb()));
+    switch (native_arch) {
+        .thumb => return asm (
+            \\ mrc p15, 0, %[ptr], c13, c0, 2
+            : [ptr] "=r" (-> *TEB),
+        ),
+        .aarch64 => return asm (
+            \\ mov %[ptr], x18
+            : [ptr] "=r" (-> *TEB),
+        ),
+        .x86 => {
+            comptime assert(
+                @offsetOf(TEB, "NtTib") + @offsetOf(@FieldType(TEB, "NtTib"), "Self") == 0x18,
+            );
+            return asm (
                 \\ movl %%fs:0x18, %[ptr]
                 : [ptr] "=r" (-> *TEB),
-            ),
-        .x86_64 => if (builtin.zig_backend == .stage2_c)
-            @ptrCast(@alignCast(zig_x86_64_windows_teb()))
-        else
-            asm (
+            );
+        },
+        .x86_64 => {
+            comptime assert(
+                @offsetOf(TEB, "NtTib") + @offsetOf(@FieldType(TEB, "NtTib"), "Self") == 0x30,
+            );
+            return asm (
                 \\ movq %%gs:0x30, %[ptr]
                 : [ptr] "=r" (-> *TEB),
-            ),
+            );
+        },
         else => @compileError("unsupported arch"),
-    };
+    }
 }
 
 pub fn peb() *PEB {
+    if (builtin.zig_backend == .stage2_c) switch (native_arch) {
+        .x86, .x86_64 => return @ptrCast(@alignCast(struct {
+            /// This is a workaround for the C backend until zig has the ability to put
+            /// C code in inline assembly.
+            extern fn zig_windows_peb() callconv(.c) *anyopaque;
+        }.zig_windows_peb())),
+        else => {},
+    } else switch (native_arch) {
+        .aarch64 => {
+            comptime assert(@offsetOf(TEB, "ProcessEnvironmentBlock") == 0x60);
+            return asm (
+                \\ ldr %[ptr], [x18, #0x60]
+                : [ptr] "=r" (-> *PEB),
+            );
+        },
+        .x86 => {
+            comptime assert(@offsetOf(TEB, "ProcessEnvironmentBlock") == 0x30);
+            return asm (
+                \\ movl %%fs:0x30, %[ptr]
+                : [ptr] "=r" (-> *PEB),
+            );
+        },
+        .x86_64 => {
+            comptime assert(@offsetOf(TEB, "ProcessEnvironmentBlock") == 0x60);
+            return asm (
+                \\ movq %%gs:0x60, %[ptr]
+                : [ptr] "=r" (-> *PEB),
+            );
+        },
+        else => {},
+    }
     return teb().ProcessEnvironmentBlock;
 }
 
@@ -3089,20 +2974,6 @@ pub fn toSysTime(ns: Io.Timestamp) i64 {
     return @as(i64, @intCast(hns)) - std.time.epoch.windows * (std.time.ns_per_s / 100);
 }
 
-pub fn fileTimeToNanoSeconds(ft: FILETIME) Io.Timestamp {
-    const hns = (@as(i64, ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
-    return fromSysTime(hns);
-}
-
-/// Converts a number of nanoseconds since the POSIX epoch to a Windows FILETIME.
-pub fn nanoSecondsToFileTime(ns: Io.Timestamp) FILETIME {
-    const adjusted: u64 = @bitCast(toSysTime(ns));
-    return .{
-        .dwHighDateTime = @as(u32, @truncate(adjusted >> 32)),
-        .dwLowDateTime = @as(u32, @truncate(adjusted)),
-    };
-}
-
 /// Use RtlUpcaseUnicodeChar on Windows when not in comptime to avoid including a
 /// redundant copy of the uppercase data.
 pub inline fn toUpperWtf16(c: u16) u16 {
@@ -3126,7 +2997,7 @@ pub fn eqlIgnoreCaseWtf16(a: []const u16, b: []const u16) bool {
             // endianness for the uppercasing
             const a_c_native = std.mem.littleToNative(u16, a_c);
             const b_c_native = std.mem.littleToNative(u16, b_c);
-            if (a_c != b_c and nls.upcaseW(a_c_native) != nls.upcaseW(b_c_native)) {
+            if (a_c != b_c and toUpperWtf16(a_c_native) != toUpperWtf16(b_c_native)) {
                 return false;
             }
         }
@@ -3134,19 +3005,7 @@ pub fn eqlIgnoreCaseWtf16(a: []const u16, b: []const u16) bool {
     }
     // Use RtlEqualUnicodeString on Windows when not in comptime to avoid including a
     // redundant copy of the uppercase data.
-    const a_bytes = @as(u16, @intCast(a.len * 2));
-    const a_string: UNICODE_STRING = .{
-        .Length = a_bytes,
-        .MaximumLength = a_bytes,
-        .Buffer = @constCast(a.ptr),
-    };
-    const b_bytes = @as(u16, @intCast(b.len * 2));
-    const b_string: UNICODE_STRING = .{
-        .Length = b_bytes,
-        .MaximumLength = b_bytes,
-        .Buffer = @constCast(b.ptr),
-    };
-    return ntdll.RtlEqualUnicodeString(&a_string, &b_string, TRUE) == TRUE;
+    return ntdll.RtlEqualUnicodeString(&.init(a), &.init(b), TRUE) == TRUE;
 }
 
 /// Compares two WTF-8 strings using the equivalent functionality of
@@ -3464,13 +3323,10 @@ pub const LONG = i32;
 pub const ULONG64 = u64;
 pub const ULONGLONG = u64;
 pub const LONGLONG = i64;
-pub const HLOCAL = HANDLE;
 pub const LANGID = c_ushort;
 pub const COLORREF = DWORD;
 
-pub const WPARAM = usize;
 pub const LPARAM = LONG_PTR;
-pub const LRESULT = LONG_PTR;
 
 pub const va_list = *opaque {};
 
@@ -3480,6 +3336,40 @@ pub const LPCTSTR = @compileError("Deprecated: choose between `LPCSTR` or `LPCWS
 pub const PTSTR = @compileError("Deprecated: choose between `PSTR` or `PWSTR` directly instead.");
 pub const PCTSTR = @compileError("Deprecated: choose between `PCSTR` or `PCWSTR` directly instead.");
 
+fn STRING(comptime C: type) type {
+    return extern struct {
+        Length: USHORT,
+        MaximumLength: USHORT,
+        Buffer: ?[*]C,
+
+        pub const empty: @This() = .{ .Length = 0, .MaximumLength = 0, .Buffer = null };
+
+        pub fn init(string: []const C) @This() {
+            const len: USHORT = @intCast(@sizeOf(C) * string.len);
+            return .{
+                .Length = len,
+                .MaximumLength = len,
+                .Buffer = @constCast(string.ptr),
+            };
+        }
+
+        pub fn isEmpty(string: *const @This()) bool {
+            return string.Length == 0;
+        }
+
+        pub fn slice(string: *const @This()) []C {
+            return if (string.isEmpty()) &.{} else string.Buffer.?[0..@divExact(string.Length, @sizeOf(C))];
+        }
+
+        pub fn sliceZ(string: *const @This()) [:0]C {
+            assert(string.Length + @sizeOf(C) <= string.MaximumLength);
+            return string.Buffer.?[0..@divExact(string.Length, @sizeOf(C)) :0];
+        }
+    };
+}
+pub const ANSI_STRING = STRING(CHAR);
+pub const UNICODE_STRING = STRING(WCHAR);
+
 pub const TRUE = 1;
 pub const FALSE = 0;
 
@@ -3509,111 +3399,14 @@ pub const OVERLAPPED = extern struct {
     hEvent: ?HANDLE,
 };
 
-pub const OVERLAPPED_ENTRY = extern struct {
-    lpCompletionKey: ULONG_PTR,
-    lpOverlapped: *OVERLAPPED,
-    Internal: ULONG_PTR,
-    dwNumberOfBytesTransferred: DWORD,
-};
-
 pub const MAX_PATH = 260;
 
-pub const FILE_INFO_BY_HANDLE_CLASS = enum(u32) {
-    FileBasicInfo = 0,
-    FileStandardInfo = 1,
-    FileNameInfo = 2,
-    FileRenameInfo = 3,
-    FileDispositionInfo = 4,
-    FileAllocationInfo = 5,
-    FileEndOfFileInfo = 6,
-    FileStreamInfo = 7,
-    FileCompressionInfo = 8,
-    FileAttributeTagInfo = 9,
-    FileIdBothDirectoryInfo = 10,
-    FileIdBothDirectoryRestartInfo = 11,
-    FileIoPriorityHintInfo = 12,
-    FileRemoteProtocolInfo = 13,
-    FileFullDirectoryInfo = 14,
-    FileFullDirectoryRestartInfo = 15,
-    FileStorageInfo = 16,
-    FileAlignmentInfo = 17,
-    FileIdInfo = 18,
-    FileIdExtdDirectoryInfo = 19,
-    FileIdExtdDirectoryRestartInfo = 20,
-};
-
-pub const BY_HANDLE_FILE_INFORMATION = extern struct {
-    dwFileAttributes: DWORD,
-    ftCreationTime: FILETIME,
-    ftLastAccessTime: FILETIME,
-    ftLastWriteTime: FILETIME,
-    dwVolumeSerialNumber: DWORD,
-    nFileSizeHigh: DWORD,
-    nFileSizeLow: DWORD,
-    nNumberOfLinks: DWORD,
-    nFileIndexHigh: DWORD,
-    nFileIndexLow: DWORD,
-};
-
-pub const FILE_NAME_INFO = extern struct {
-    FileNameLength: DWORD,
-    FileName: [1]WCHAR,
-};
-
-/// Return the normalized drive name. This is the default.
-pub const FILE_NAME_NORMALIZED = 0x0;
-
-/// Return the opened file name (not normalized).
-pub const FILE_NAME_OPENED = 0x8;
-
-/// Return the path with the drive letter. This is the default.
-pub const VOLUME_NAME_DOS = 0x0;
-
-/// Return the path with a volume GUID path instead of the drive name.
-pub const VOLUME_NAME_GUID = 0x1;
-
-/// Return the path with no drive information.
-pub const VOLUME_NAME_NONE = 0x4;
-
-/// Return the path with the volume device path.
-pub const VOLUME_NAME_NT = 0x2;
-
 pub const SECURITY_ATTRIBUTES = extern struct {
     nLength: DWORD,
     lpSecurityDescriptor: ?*anyopaque,
     bInheritHandle: BOOL,
 };
 
-pub const PIPE_ACCESS_INBOUND = 0x00000001;
-pub const PIPE_ACCESS_OUTBOUND = 0x00000002;
-pub const PIPE_ACCESS_DUPLEX = 0x00000003;
-
-pub const PIPE_TYPE_BYTE = 0x00000000;
-pub const PIPE_TYPE_MESSAGE = 0x00000004;
-
-pub const PIPE_READMODE_BYTE = 0x00000000;
-pub const PIPE_READMODE_MESSAGE = 0x00000002;
-
-pub const PIPE_WAIT = 0x00000000;
-pub const PIPE_NOWAIT = 0x00000001;
-
-pub const CREATE_ALWAYS = 2;
-pub const CREATE_NEW = 1;
-pub const OPEN_ALWAYS = 4;
-pub const OPEN_EXISTING = 3;
-pub const TRUNCATE_EXISTING = 5;
-
-// flags for CreateEvent
-pub const CREATE_EVENT_INITIAL_SET = 0x00000002;
-pub const CREATE_EVENT_MANUAL_RESET = 0x00000001;
-
-pub const PROCESS_INFORMATION = extern struct {
-    hProcess: HANDLE,
-    hThread: HANDLE,
-    dwProcessId: DWORD,
-    dwThreadId: DWORD,
-};
-
 pub const STARTUPINFOW = extern struct {
     cb: DWORD,
     lpReserved: ?LPWSTR,
@@ -3650,50 +3443,7 @@ pub const STARTF_USESHOWWINDOW = 0x00000001;
 pub const STARTF_USESIZE = 0x00000002;
 pub const STARTF_USESTDHANDLES = 0x00000100;
 
-pub const INFINITE = 4294967295;
-
-pub const MAXIMUM_WAIT_OBJECTS = 64;
-
-pub const WAIT_ABANDONED = 0x00000080;
-pub const WAIT_ABANDONED_0 = WAIT_ABANDONED + 0;
-pub const WAIT_OBJECT_0 = 0x00000000;
-pub const WAIT_TIMEOUT = 0x00000102;
-pub const WAIT_FAILED = 0xFFFFFFFF;
-
-pub const HANDLE_FLAG_INHERIT = 0x00000001;
-pub const HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x00000002;
-
-pub const MOVEFILE_COPY_ALLOWED = 2;
-pub const MOVEFILE_CREATE_HARDLINK = 16;
-pub const MOVEFILE_DELAY_UNTIL_REBOOT = 4;
-pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE = 32;
-pub const MOVEFILE_REPLACE_EXISTING = 1;
-pub const MOVEFILE_WRITE_THROUGH = 8;
-
-pub const FILE_BEGIN = 0;
-pub const FILE_CURRENT = 1;
-pub const FILE_END = 2;
-
-pub const PTHREAD_START_ROUTINE = *const fn (LPVOID) callconv(.winapi) DWORD;
-pub const LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
-
-pub const WIN32_FIND_DATAW = extern struct {
-    dwFileAttributes: DWORD,
-    ftCreationTime: FILETIME,
-    ftLastAccessTime: FILETIME,
-    ftLastWriteTime: FILETIME,
-    nFileSizeHigh: DWORD,
-    nFileSizeLow: DWORD,
-    dwReserved0: DWORD,
-    dwReserved1: DWORD,
-    cFileName: [260]u16,
-    cAlternateFileName: [14]u16,
-};
-
-pub const FILETIME = extern struct {
-    dwLowDateTime: DWORD,
-    dwHighDateTime: DWORD,
-};
+pub const THREAD_START_ROUTINE = fn (LPVOID) callconv(.winapi) DWORD;
 
 pub const SYSTEM_INFO = extern struct {
     anon1: extern union {
@@ -3716,7 +3466,6 @@ pub const SYSTEM_INFO = extern struct {
 
 pub const HRESULT = c_long;
 
-pub const KNOWNFOLDERID = GUID;
 pub const GUID = extern struct {
     Data1: u32,
     Data2: u16,
@@ -3771,75 +3520,11 @@ test GUID {
     );
 }
 
-pub const FOLDERID_LocalAppData = GUID.parse("{F1B32785-6FBA-4FCF-9D55-7B8E7F157091}");
-
-pub const KF_FLAG_DEFAULT = 0;
-pub const KF_FLAG_NO_APPCONTAINER_REDIRECTION = 65536;
-pub const KF_FLAG_CREATE = 32768;
-pub const KF_FLAG_DONT_VERIFY = 16384;
-pub const KF_FLAG_DONT_UNEXPAND = 8192;
-pub const KF_FLAG_NO_ALIAS = 4096;
-pub const KF_FLAG_INIT = 2048;
-pub const KF_FLAG_DEFAULT_PATH = 1024;
-pub const KF_FLAG_NOT_PARENT_RELATIVE = 512;
-pub const KF_FLAG_SIMPLE_IDLIST = 256;
-pub const KF_FLAG_ALIAS_ONLY = -2147483648;
-
-pub const S_OK = 0;
-pub const S_FALSE = 0x00000001;
-pub const E_NOTIMPL = @as(c_long, @bitCast(@as(c_ulong, 0x80004001)));
-pub const E_NOINTERFACE = @as(c_long, @bitCast(@as(c_ulong, 0x80004002)));
-pub const E_POINTER = @as(c_long, @bitCast(@as(c_ulong, 0x80004003)));
-pub const E_ABORT = @as(c_long, @bitCast(@as(c_ulong, 0x80004004)));
-pub const E_FAIL = @as(c_long, @bitCast(@as(c_ulong, 0x80004005)));
-pub const E_UNEXPECTED = @as(c_long, @bitCast(@as(c_ulong, 0x8000FFFF)));
-pub const E_ACCESSDENIED = @as(c_long, @bitCast(@as(c_ulong, 0x80070005)));
-pub const E_HANDLE = @as(c_long, @bitCast(@as(c_ulong, 0x80070006)));
-pub const E_OUTOFMEMORY = @as(c_long, @bitCast(@as(c_ulong, 0x8007000E)));
-pub const E_INVALIDARG = @as(c_long, @bitCast(@as(c_ulong, 0x80070057)));
-
-pub fn HRESULT_CODE(hr: HRESULT) Win32Error {
-    return @enumFromInt(hr & 0xFFFF);
-}
-
-pub const FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
-pub const FILE_FLAG_DELETE_ON_CLOSE = 0x04000000;
-pub const FILE_FLAG_NO_BUFFERING = 0x20000000;
-pub const FILE_FLAG_OPEN_NO_RECALL = 0x00100000;
-pub const FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000;
-pub const FILE_FLAG_OVERLAPPED = 0x40000000;
-pub const FILE_FLAG_POSIX_SEMANTICS = 0x0100000;
-pub const FILE_FLAG_RANDOM_ACCESS = 0x10000000;
-pub const FILE_FLAG_SESSION_AWARE = 0x00800000;
-pub const FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;
-pub const FILE_FLAG_WRITE_THROUGH = 0x80000000;
-
-pub const RECT = extern struct {
-    left: LONG,
-    top: LONG,
-    right: LONG,
-    bottom: LONG,
-};
-
-pub const SMALL_RECT = extern struct {
-    Left: SHORT,
-    Top: SHORT,
-    Right: SHORT,
-    Bottom: SHORT,
-};
-
-pub const POINT = extern struct {
-    x: LONG,
-    y: LONG,
-};
-
 pub const COORD = extern struct {
     X: SHORT,
     Y: SHORT,
 };
 
-pub const CREATE_UNICODE_ENVIRONMENT = 1024;
-
 pub const TLS_OUT_OF_INDEXES = 4294967295;
 pub const IMAGE_TLS_DIRECTORY = extern struct {
     StartAddressOfRawData: usize,
@@ -3854,8 +3539,6 @@ pub const IMAGE_TLS_DIRECTORY32 = IMAGE_TLS_DIRECTORY;
 
 pub const PIMAGE_TLS_CALLBACK = ?*const fn (PVOID, DWORD, PVOID) callconv(.winapi) void;
 
-pub const PROV_RSA_FULL = 1;
-
 pub const REGSAM = ACCESS_MASK;
 pub const LSTATUS = LONG;
 
@@ -3872,9 +3555,6 @@ pub const HKEY_CURRENT_CONFIG: HKEY = @ptrFromInt(0x80000005);
 pub const HKEY_DYN_DATA: HKEY = @ptrFromInt(0x80000006);
 pub const HKEY_CURRENT_USER_LOCAL_SETTINGS: HKEY = @ptrFromInt(0x80000007);
 
-/// Open symbolic link.
-pub const REG_OPTION_OPEN_LINK: DWORD = 0x8;
-
 pub const RTL_QUERY_REGISTRY_TABLE = extern struct {
     QueryRoutine: RTL_QUERY_REGISTRY_ROUTINE,
     Flags: ULONG,
@@ -3975,38 +3655,6 @@ pub const REG = struct {
     pub const QWORD_LITTLE_ENDIAN: ULONG = 11;
 };
 
-pub const FILE_NOTIFY_INFORMATION = extern struct {
-    NextEntryOffset: DWORD,
-    Action: DWORD,
-    FileNameLength: DWORD,
-    // Flexible array member
-    // FileName: [1]WCHAR,
-};
-
-pub const FILE_ACTION_ADDED = 0x00000001;
-pub const FILE_ACTION_REMOVED = 0x00000002;
-pub const FILE_ACTION_MODIFIED = 0x00000003;
-pub const FILE_ACTION_RENAMED_OLD_NAME = 0x00000004;
-pub const FILE_ACTION_RENAMED_NEW_NAME = 0x00000005;
-
-pub const LPOVERLAPPED_COMPLETION_ROUTINE = ?*const fn (DWORD, DWORD, *OVERLAPPED) callconv(.winapi) void;
-
-pub const FileNotifyChangeFilter = packed struct(DWORD) {
-    file_name: bool = false,
-    dir_name: bool = false,
-    attributes: bool = false,
-    size: bool = false,
-    last_write: bool = false,
-    last_access: bool = false,
-    creation: bool = false,
-    ea: bool = false,
-    security: bool = false,
-    stream_name: bool = false,
-    stream_size: bool = false,
-    stream_write: bool = false,
-    _pad: u20 = 0,
-};
-
 pub const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4;
 pub const DISABLE_NEWLINE_AUTO_RETURN = 0x8;
 
@@ -4056,26 +3704,6 @@ pub const RTL_RUN_ONCE = extern struct {
 
 pub const RTL_RUN_ONCE_INIT = RTL_RUN_ONCE{ .Ptr = null };
 
-pub const COINIT = struct {
-    pub const APARTMENTTHREADED = 2;
-    pub const MULTITHREADED = 0;
-    pub const DISABLE_OLE1DDE = 4;
-    pub const SPEED_OVER_MEMORY = 8;
-};
-
-pub const MEMORY_BASIC_INFORMATION = extern struct {
-    BaseAddress: PVOID,
-    AllocationBase: PVOID,
-    AllocationProtect: DWORD,
-    PartitionId: WORD,
-    RegionSize: SIZE_T,
-    State: DWORD,
-    Protect: DWORD,
-    Type: DWORD,
-};
-
-pub const PMEMORY_BASIC_INFORMATION = *MEMORY_BASIC_INFORMATION;
-
 /// > The maximum path of 32,767 characters is approximate, because the "\\?\"
 /// > prefix may be expanded to a longer string by the system at run time, and
 /// > this expansion applies to the total length.
@@ -4544,14 +4172,6 @@ pub const UNW_FLAG_EHANDLER = 0x1;
 pub const UNW_FLAG_UHANDLER = 0x2;
 pub const UNW_FLAG_CHAININFO = 0x4;
 
-pub const UNICODE_STRING = extern struct {
-    Length: c_ushort,
-    MaximumLength: c_ushort,
-    Buffer: ?[*]WCHAR,
-
-    pub const empty: UNICODE_STRING = .{ .Length = 0, .MaximumLength = 0, .Buffer = null };
-};
-
 pub const ACTIVATION_CONTEXT_DATA = opaque {};
 pub const ASSEMBLY_STORAGE_MAP = opaque {};
 pub const FLS_CALLBACK_INFO = opaque {};
@@ -4564,15 +4184,6 @@ pub const CLIENT_ID = extern struct {
     UniqueThread: HANDLE,
 };
 
-pub const THREAD_BASIC_INFORMATION = extern struct {
-    ExitStatus: NTSTATUS,
-    TebBaseAddress: PVOID,
-    ClientId: CLIENT_ID,
-    AffinityMask: KAFFINITY,
-    Priority: KPRIORITY,
-    BasePriority: KPRIORITY,
-};
-
 pub const TEB = extern struct {
     NtTib: NT_TIB,
     EnvironmentPointer: PVOID,
@@ -4580,7 +4191,7 @@ pub const TEB = extern struct {
     ActiveRpcHandle: PVOID,
     ThreadLocalStoragePointer: PVOID,
     ProcessEnvironmentBlock: *PEB,
-    LastErrorValue: ULONG,
+    LastErrorValue: Win32Error,
     Reserved2: [399 * @sizeOf(PVOID) - @sizeOf(ULONG)]u8,
     Reserved3: [1952]u8,
     TlsSlots: [64]PVOID,
@@ -4793,7 +4404,7 @@ pub const PEB = extern struct {
 };
 
 /// The `PEB_LDR_DATA` structure is the main record of what modules are loaded in a process.
-/// It is essentially the head of three double-linked lists of `LDR_DATA_TABLE_ENTRY` structures which each represent one loaded module.
+/// It is essentially the head of three double-linked lists of `LDR.DATA_TABLE_ENTRY` structures which each represent one loaded module.
 ///
 /// Microsoft documentation of this is incomplete, the fields here are taken from various resources including:
 ///  - https://www.geoffchappell.com/studies/windows/win32/ntdll/structs/peb_ldr_data.htm
@@ -4825,24 +4436,89 @@ pub const PEB_LDR_DATA = extern struct {
     ShutdownThreadId: HANDLE,
 };
 
-/// Microsoft documentation of this is incomplete, the fields here are taken from various resources including:
-///  - https://docs.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data
-///  - https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntldr/ldr_data_table_entry.htm
-pub const LDR_DATA_TABLE_ENTRY = extern struct {
-    InLoadOrderLinks: LIST_ENTRY,
-    InMemoryOrderLinks: LIST_ENTRY,
-    InInitializationOrderLinks: LIST_ENTRY,
-    DllBase: PVOID,
-    EntryPoint: PVOID,
-    SizeOfImage: ULONG,
-    FullDllName: UNICODE_STRING,
-    BaseDllName: UNICODE_STRING,
-    Reserved5: [3]PVOID,
-    DUMMYUNIONNAME: extern union {
-        CheckSum: ULONG,
-        Reserved6: PVOID,
-    },
-    TimeDateStamp: ULONG,
+pub const LDR = struct {
+    /// Microsoft documentation of this is incomplete, the fields here are taken from various resources including:
+    ///  - https://docs.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data
+    ///  - https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntldr/ldr_data_table_entry.htm
+    pub const DATA_TABLE_ENTRY = extern struct {
+        InLoadOrderLinks: LIST_ENTRY,
+        InMemoryOrderLinks: LIST_ENTRY,
+        InInitializationOrderLinks: LIST_ENTRY,
+        DllBase: PVOID,
+        EntryPoint: PVOID,
+        SizeOfImage: ULONG,
+        FullDllName: UNICODE_STRING,
+        BaseDllName: UNICODE_STRING,
+        Reserved5: [3]PVOID,
+        DUMMYUNIONNAME: extern union {
+            CheckSum: ULONG,
+            Reserved6: PVOID,
+        },
+        TimeDateStamp: ULONG,
+    };
+
+    pub const DLL_NOTIFICATION = struct {
+        pub const REASON = enum(ULONG) { LOADED = 1, UNLOADED = 2 };
+
+        pub const DATA = extern union {
+            Loaded: LOADED,
+            Unloaded: UNLOADED,
+
+            pub const LOADED = extern struct {
+                Flags: REGISTER,
+                FullDllName: *const UNICODE_STRING,
+                BaseDllName: *const UNICODE_STRING,
+                DllBase: PVOID,
+                SizeOfImage: ULONG,
+            };
+
+            pub const UNLOADED = extern struct {
+                Flags: REGISTER,
+                FullDllName: *const UNICODE_STRING,
+                BaseDllName: *const UNICODE_STRING,
+                DllBase: PVOID,
+                SizeOfImage: ULONG,
+            };
+        };
+
+        pub const COOKIE = *opaque {};
+
+        pub const FUNCTION = fn (
+            NotificationReason: REASON,
+            NotificationData: *const DATA,
+            Context: ?PVOID,
+        ) callconv(.winapi) void;
+
+        pub const REGISTER = packed struct(ULONG) {
+            Reserved0: u32 = 0,
+        };
+    };
+
+    pub const GET_DLL_HANDLE_EX = packed struct(ULONG) {
+        UNCHANGED_REFCOUNT: bool = false,
+        PIN: bool = false,
+        Reserved2: u30 = 0,
+    };
+
+    pub const GET_PROCEDURE_ADDRESS = packed struct(ULONG) {
+        DONT_RECORD_FORWARDER: bool = false,
+        Reserved1: u31 = 0,
+    };
+
+    pub const LOAD = packed struct(ULONG) {
+        DONT_RESOLVE_DLL_REFERENCES: bool = false,
+        LIBRARY_AS_DATAFILE: bool = false,
+        PACKAGED_LIBRARY: bool = false,
+        WITH_ALTERED_SEARCH_PATH: bool = false,
+        IGNORE_CODE_AUTHZ_LEVEL: bool = false,
+        LIBRARY_AS_IMAGE_RESOURCE: bool = false,
+        LIBRARY_AS_DATAFILE_EXCLUSIVE: bool = false,
+        LIBRARY_REQUERE_SIGNED_TARGET: bool = false,
+        LIBRARY_SEARCH_DLL_LOAD_DIR: bool = false,
+        LIBRARY_SEARCH_USER_DIRS: bool = false,
+        LIBRARY_SEARCH_SYSTEM32: bool = false,
+        LIBRARY_SEARCH_DEFAULT_DIRS: bool = false,
+    };
 };
 
 pub const RTL_USER_PROCESS_PARAMETERS = extern struct {
@@ -4956,86 +4632,6 @@ pub const MODULEINFO = extern struct {
     EntryPoint: LPVOID,
 };
 
-pub const PSAPI_WS_WATCH_INFORMATION = extern struct {
-    FaultingPc: LPVOID,
-    FaultingVa: LPVOID,
-};
-
-pub const VM_COUNTERS = extern struct {
-    PeakVirtualSize: SIZE_T,
-    VirtualSize: SIZE_T,
-    PageFaultCount: ULONG,
-    PeakWorkingSetSize: SIZE_T,
-    WorkingSetSize: SIZE_T,
-    QuotaPeakPagedPoolUsage: SIZE_T,
-    QuotaPagedPoolUsage: SIZE_T,
-    QuotaPeakNonPagedPoolUsage: SIZE_T,
-    QuotaNonPagedPoolUsage: SIZE_T,
-    PagefileUsage: SIZE_T,
-    PeakPagefileUsage: SIZE_T,
-};
-
-pub const PROCESS_MEMORY_COUNTERS = extern struct {
-    cb: DWORD,
-    PageFaultCount: DWORD,
-    PeakWorkingSetSize: SIZE_T,
-    WorkingSetSize: SIZE_T,
-    QuotaPeakPagedPoolUsage: SIZE_T,
-    QuotaPagedPoolUsage: SIZE_T,
-    QuotaPeakNonPagedPoolUsage: SIZE_T,
-    QuotaNonPagedPoolUsage: SIZE_T,
-    PagefileUsage: SIZE_T,
-    PeakPagefileUsage: SIZE_T,
-};
-
-pub const PROCESS_MEMORY_COUNTERS_EX = extern struct {
-    cb: DWORD,
-    PageFaultCount: DWORD,
-    PeakWorkingSetSize: SIZE_T,
-    WorkingSetSize: SIZE_T,
-    QuotaPeakPagedPoolUsage: SIZE_T,
-    QuotaPagedPoolUsage: SIZE_T,
-    QuotaPeakNonPagedPoolUsage: SIZE_T,
-    QuotaNonPagedPoolUsage: SIZE_T,
-    PagefileUsage: SIZE_T,
-    PeakPagefileUsage: SIZE_T,
-    PrivateUsage: SIZE_T,
-};
-
-pub const PERFORMANCE_INFORMATION = extern struct {
-    cb: DWORD,
-    CommitTotal: SIZE_T,
-    CommitLimit: SIZE_T,
-    CommitPeak: SIZE_T,
-    PhysicalTotal: SIZE_T,
-    PhysicalAvailable: SIZE_T,
-    SystemCache: SIZE_T,
-    KernelTotal: SIZE_T,
-    KernelPaged: SIZE_T,
-    KernelNonpaged: SIZE_T,
-    PageSize: SIZE_T,
-    HandleCount: DWORD,
-    ProcessCount: DWORD,
-    ThreadCount: DWORD,
-};
-
-pub const ENUM_PAGE_FILE_INFORMATION = extern struct {
-    cb: DWORD,
-    Reserved: DWORD,
-    TotalSize: SIZE_T,
-    TotalInUse: SIZE_T,
-    PeakUsage: SIZE_T,
-};
-
-pub const PENUM_PAGE_FILE_CALLBACKW = ?*const fn (?LPVOID, *ENUM_PAGE_FILE_INFORMATION, LPCWSTR) callconv(.winapi) BOOL;
-pub const PENUM_PAGE_FILE_CALLBACKA = ?*const fn (?LPVOID, *ENUM_PAGE_FILE_INFORMATION, LPCSTR) callconv(.winapi) BOOL;
-
-pub const PSAPI_WS_WATCH_INFORMATION_EX = extern struct {
-    BasicInfo: PSAPI_WS_WATCH_INFORMATION,
-    FaultingThreadId: ULONG_PTR,
-    Flags: ULONG_PTR,
-};
-
 pub const OSVERSIONINFOW = extern struct {
     dwOSVersionInfoSize: ULONG,
     dwMajorVersion: ULONG,
@@ -5098,20 +4694,6 @@ pub const MOUNTMGR_VOLUME_PATHS = extern struct {
     MultiSz: [1]WCHAR,
 };
 
-pub const OBJECT_INFORMATION_CLASS = enum(c_int) {
-    ObjectBasicInformation = 0,
-    ObjectNameInformation = 1,
-    ObjectTypeInformation = 2,
-    ObjectTypesInformation = 3,
-    ObjectHandleFlagInformation = 4,
-    ObjectSessionInformation = 5,
-    MaxObjectInfoClass,
-};
-
-pub const OBJECT_NAME_INFORMATION = extern struct {
-    Name: UNICODE_STRING,
-};
-
 pub const SRWLOCK_INIT = SRWLOCK{};
 pub const SRWLOCK = extern struct {
     Ptr: ?PVOID = null,
@@ -5122,17 +4704,6 @@ pub const CONDITION_VARIABLE = extern struct {
     Ptr: ?PVOID = null,
 };
 
-pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS = 0x1;
-pub const FILE_SKIP_SET_EVENT_ON_HANDLE = 0x2;
-
-pub const CTRL_C_EVENT: DWORD = 0;
-pub const CTRL_BREAK_EVENT: DWORD = 1;
-pub const CTRL_CLOSE_EVENT: DWORD = 2;
-pub const CTRL_LOGOFF_EVENT: DWORD = 5;
-pub const CTRL_SHUTDOWN_EVENT: DWORD = 6;
-
-pub const HANDLER_ROUTINE = *const fn (dwCtrlType: DWORD) callconv(.winapi) BOOL;
-
 /// Processor feature enumeration.
 pub const PF = enum(DWORD) {
     /// On a Pentium, a floating-point precision error can occur in rare circumstances.
@@ -5431,72 +5002,13 @@ pub const KUSER_SHARED_DATA = extern struct {
 /// Read-only user-mode address for the shared data.
 /// https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntexapi_x/kuser_shared_data/index.htm
 /// https://msrc-blog.microsoft.com/2022/04/05/randomizing-the-kuser_shared_data-structure-on-windows/
-pub const SharedUserData: *const KUSER_SHARED_DATA = @as(*const KUSER_SHARED_DATA, @ptrFromInt(0x7FFE0000));
+pub const SharedUserData: *const KUSER_SHARED_DATA = @ptrFromInt(0x7FFE0000);
 
 pub fn IsProcessorFeaturePresent(feature: PF) bool {
     if (@intFromEnum(feature) >= PROCESSOR_FEATURE_MAX) return false;
     return SharedUserData.ProcessorFeatures[@intFromEnum(feature)] == 1;
 }
 
-pub const TH32CS_SNAPHEAPLIST = 0x00000001;
-pub const TH32CS_SNAPPROCESS = 0x00000002;
-pub const TH32CS_SNAPTHREAD = 0x00000004;
-pub const TH32CS_SNAPMODULE = 0x00000008;
-pub const TH32CS_SNAPMODULE32 = 0x00000010;
-pub const TH32CS_SNAPALL = TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE;
-pub const TH32CS_INHERIT = 0x80000000;
-
-pub const MAX_MODULE_NAME32 = 255;
-pub const MODULEENTRY32 = extern struct {
-    dwSize: DWORD,
-    th32ModuleID: DWORD,
-    th32ProcessID: DWORD,
-    GlblcntUsage: DWORD,
-    ProccntUsage: DWORD,
-    modBaseAddr: *BYTE,
-    modBaseSize: DWORD,
-    hModule: HMODULE,
-    szModule: [MAX_MODULE_NAME32 + 1]CHAR,
-    szExePath: [MAX_PATH]CHAR,
-};
-
-pub const SYSTEM_INFORMATION_CLASS = enum(c_int) {
-    SystemBasicInformation = 0,
-    SystemPerformanceInformation = 2,
-    SystemTimeOfDayInformation = 3,
-    SystemProcessInformation = 5,
-    SystemProcessorPerformanceInformation = 8,
-    SystemInterruptInformation = 23,
-    SystemExceptionInformation = 33,
-    SystemRegistryQuotaInformation = 37,
-    SystemLookasideInformation = 45,
-    SystemCodeIntegrityInformation = 103,
-    SystemPolicyInformation = 134,
-};
-
-pub const SYSTEM_BASIC_INFORMATION = extern struct {
-    Reserved: ULONG,
-    TimerResolution: ULONG,
-    PageSize: ULONG,
-    NumberOfPhysicalPages: ULONG,
-    LowestPhysicalPageNumber: ULONG,
-    HighestPhysicalPageNumber: ULONG,
-    AllocationGranularity: ULONG,
-    MinimumUserModeAddress: ULONG_PTR,
-    MaximumUserModeAddress: ULONG_PTR,
-    ActiveProcessorsAffinityMask: KAFFINITY,
-    NumberOfProcessors: UCHAR,
-};
-
-pub const PROCESS_BASIC_INFORMATION = extern struct {
-    ExitStatus: NTSTATUS,
-    PebBaseAddress: *PEB,
-    AffinityMask: ULONG_PTR,
-    BasePriority: KPRIORITY,
-    UniqueProcessId: ULONG_PTR,
-    InheritedFromUniqueProcessId: ULONG_PTR,
-};
-
 // https://github.com/reactos/reactos/blob/master/sdk/include/ndk/pstypes.h#L977-L983
 pub const KERNEL_USER_TIMES = extern struct {
     CreationTime: LARGE_INTEGER,
@@ -5505,75 +5017,6 @@ pub const KERNEL_USER_TIMES = extern struct {
     UserTime: LARGE_INTEGER,
 };
 
-pub const ReadMemoryError = error{
-    Unexpected,
-};
-
-pub fn ReadProcessMemory(handle: HANDLE, addr: ?LPVOID, buffer: []u8) ReadMemoryError![]u8 {
-    var nread: usize = 0;
-    switch (ntdll.NtReadVirtualMemory(
-        handle,
-        addr,
-        buffer.ptr,
-        buffer.len,
-        &nread,
-    )) {
-        .SUCCESS => return buffer[0..nread],
-        // TODO: map errors
-        else => |rc| return unexpectedStatus(rc),
-    }
-}
-
-pub const WriteMemoryError = error{
-    Unexpected,
-};
-
-pub fn WriteProcessMemory(handle: HANDLE, addr: ?LPVOID, buffer: []const u8) WriteMemoryError!usize {
-    var nwritten: usize = 0;
-    switch (ntdll.NtWriteVirtualMemory(
-        handle,
-        addr,
-        buffer.ptr,
-        buffer.len,
-        &nwritten,
-    )) {
-        .SUCCESS => return nwritten,
-        // TODO: map errors
-        else => |rc| return unexpectedStatus(rc),
-    }
-}
-
-pub const ProcessBaseAddressError = error{
-    AccessDenied,
-    InvalidHandle,
-    Unexpected,
-} || ReadMemoryError;
-
-/// Returns the base address of the process loaded into memory.
-pub fn ProcessBaseAddress(handle: HANDLE) ProcessBaseAddressError!HMODULE {
-    var info: PROCESS_BASIC_INFORMATION = undefined;
-    var nread: DWORD = 0;
-    const rc = ntdll.NtQueryInformationProcess(
-        handle,
-        .BasicInformation,
-        &info,
-        @sizeOf(PROCESS_BASIC_INFORMATION),
-        &nread,
-    );
-    switch (rc) {
-        .SUCCESS => {},
-        .ACCESS_DENIED => return error.AccessDenied,
-        .INVALID_HANDLE => return error.InvalidHandle,
-        .INVALID_PARAMETER => unreachable,
-        else => return unexpectedStatus(rc),
-    }
-
-    var peb_buf: [@sizeOf(PEB)]u8 align(@alignOf(PEB)) = undefined;
-    const peb_out = try ReadProcessMemory(handle, info.PebBaseAddress, &peb_buf);
-    const ppeb: *const PEB = @ptrCast(@alignCast(peb_out.ptr));
-    return ppeb.ImageBaseAddress;
-}
-
 pub fn wtf8ToWtf16Le(wtf16le: []u16, wtf8: []const u8) error{ BadPathName, NameTooLong }!usize {
     // Each u8 in UTF-8/WTF-8 correlates to at most one u16 in UTF-16LE/WTF-16LE.
     if (wtf16le.len < wtf8.len) {
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index ed9af392a3a09b5ba649f965f6ff1798eada944d..30a9a220222f6856a98b08c81577996c204d19f0 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -1,154 +1,29 @@
 const std = @import("../../std.zig");
 const windows = std.os.windows;
 
-const ACCESS_MASK = windows.ACCESS_MASK;
 const BOOL = windows.BOOL;
-const CONDITION_VARIABLE = windows.CONDITION_VARIABLE;
-const COORD = windows.COORD;
 const DWORD = windows.DWORD;
-const FARPROC = windows.FARPROC;
-const FILETIME = windows.FILETIME;
 const HANDLE = windows.HANDLE;
-const HANDLER_ROUTINE = windows.HANDLER_ROUTINE;
-const HMODULE = windows.HMODULE;
-const LARGE_INTEGER = windows.LARGE_INTEGER;
-const LPCSTR = windows.LPCSTR;
 const LPCVOID = windows.LPCVOID;
 const LPCWSTR = windows.LPCWSTR;
-const LPTHREAD_START_ROUTINE = windows.LPTHREAD_START_ROUTINE;
 const LPVOID = windows.LPVOID;
 const LPWSTR = windows.LPWSTR;
-const MODULEENTRY32 = windows.MODULEENTRY32;
-const OVERLAPPED = windows.OVERLAPPED;
-const OVERLAPPED_ENTRY = windows.OVERLAPPED_ENTRY;
-const PROCESS_INFORMATION = windows.PROCESS_INFORMATION;
+const PROCESS = windows.PROCESS;
+const THREAD_START_ROUTINE = windows.THREAD_START_ROUTINE;
 const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
 const SIZE_T = windows.SIZE_T;
-const SRWLOCK = windows.SRWLOCK;
 const STARTUPINFOW = windows.STARTUPINFOW;
-const SYSTEM_INFO = windows.SYSTEM_INFO;
-const UCHAR = windows.UCHAR;
 const UINT = windows.UINT;
-const ULONG = windows.ULONG;
-const ULONG_PTR = windows.ULONG_PTR;
 const va_list = windows.va_list;
-const WCHAR = windows.WCHAR;
 const Win32Error = windows.Win32Error;
-const WORD = windows.WORD;
 
 // I/O - Filesystem
 
-pub extern "kernel32" fn ReadDirectoryChangesW(
-    hDirectory: HANDLE,
-    lpBuffer: [*]align(@alignOf(windows.FILE_NOTIFY_INFORMATION)) u8,
-    nBufferLength: DWORD,
-    bWatchSubtree: BOOL,
-    dwNotifyFilter: windows.FileNotifyChangeFilter,
-    lpBytesReturned: ?*DWORD,
-    lpOverlapped: ?*OVERLAPPED,
-    lpCompletionRoutine: windows.LPOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtCancelIoFile.
-pub extern "kernel32" fn CancelIo(
-    hFile: HANDLE,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtSetInformationFile + `FILE_POSITION_INFORMATION`.
-//  `FILE_STANDARD_INFORMATION` is also used if dwMoveMethod is `FILE_END`
-pub extern "kernel32" fn SetFilePointerEx(
-    hFile: HANDLE,
-    liDistanceToMove: LARGE_INTEGER,
-    lpNewFilePointer: ?*LARGE_INTEGER,
-    dwMoveMethod: DWORD,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtSetInformationFile + `FILE_BASIC_INFORMATION`
-pub extern "kernel32" fn SetFileTime(
-    hFile: HANDLE,
-    lpCreationTime: ?*const FILETIME,
-    lpLastAccessTime: ?*const FILETIME,
-    lpLastWriteTime: ?*const FILETIME,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn WriteFile(
-    in_hFile: HANDLE,
-    in_lpBuffer: [*]const u8,
-    in_nNumberOfBytesToWrite: DWORD,
-    out_lpNumberOfBytesWritten: ?*DWORD,
-    in_out_lpOverlapped: ?*OVERLAPPED,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtSetInformationFile + `FILE_IO_COMPLETION_NOTIFICATION_INFORMATION`.
-pub extern "kernel32" fn SetFileCompletionNotificationModes(
-    FileHandle: HANDLE,
-    Flags: UCHAR,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn ReadFile(
-    hFile: HANDLE,
-    lpBuffer: LPVOID,
-    nNumberOfBytesToRead: DWORD,
-    lpNumberOfBytesRead: ?*DWORD,
-    lpOverlapped: ?*OVERLAPPED,
-) callconv(.winapi) BOOL;
-
 pub extern "kernel32" fn GetSystemDirectoryW(
     lpBuffer: LPWSTR,
     uSize: UINT,
 ) callconv(.winapi) UINT;
 
-// I/O - Kernel Objects
-
-// TODO: Wrapper around NtRemoveIoCompletion.
-pub extern "kernel32" fn GetQueuedCompletionStatus(
-    CompletionPort: HANDLE,
-    lpNumberOfBytesTransferred: *DWORD,
-    lpCompletionKey: *ULONG_PTR,
-    lpOverlapped: *?*OVERLAPPED,
-    dwMilliseconds: DWORD,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtRemoveIoCompletionEx.
-pub extern "kernel32" fn GetQueuedCompletionStatusEx(
-    CompletionPort: HANDLE,
-    lpCompletionPortEntries: [*]OVERLAPPED_ENTRY,
-    ulCount: ULONG,
-    ulNumEntriesRemoved: *ULONG,
-    dwMilliseconds: DWORD,
-    fAlertable: BOOL,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtSetIoCompletion with `IoStatus = .SUCCESS`.
-pub extern "kernel32" fn PostQueuedCompletionStatus(
-    CompletionPort: HANDLE,
-    dwNumberOfBytesTransferred: DWORD,
-    dwCompletionKey: ULONG_PTR,
-    lpOverlapped: ?*OVERLAPPED,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn GetOverlappedResult(
-    hFile: HANDLE,
-    lpOverlapped: *OVERLAPPED,
-    lpNumberOfBytesTransferred: *DWORD,
-    bWait: BOOL,
-) callconv(.winapi) BOOL;
-
-// TODO: Wrapper around NtCreateIoCompletion + NtSetInformationFile with FILE_COMPLETION_INFORMATION.
-// This would be better splitting into two functions.
-pub extern "kernel32" fn CreateIoCompletionPort(
-    FileHandle: HANDLE,
-    ExistingCompletionPort: ?HANDLE,
-    CompletionKey: ULONG_PTR,
-    NumberOfConcurrentThreads: DWORD,
-) callconv(.winapi) ?HANDLE;
-
-// TODO: Wrapper around RtlReportSilentProcessExit + NtTerminateProcess.
-pub extern "kernel32" fn TerminateProcess(
-    hProcess: HANDLE,
-    uExitCode: UINT,
-) callconv(.winapi) BOOL;
-
 // Process Management
 
 pub extern "kernel32" fn CreateProcessW(
@@ -161,86 +36,21 @@ pub extern "kernel32" fn CreateProcessW(
     lpEnvironment: ?[*:0]const u16,
     lpCurrentDirectory: ?LPCWSTR,
     lpStartupInfo: *STARTUPINFOW,
-    lpProcessInformation: *PROCESS_INFORMATION,
+    lpProcessInformation: *PROCESS.INFORMATION,
 ) callconv(.winapi) BOOL;
 
-// TODO: Wrapper around NtQueryInformationProcess with `PROCESS_BASIC_INFORMATION`.
-pub extern "kernel32" fn GetExitCodeProcess(
-    hProcess: HANDLE,
-    lpExitCode: *DWORD,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn CreateToolhelp32Snapshot(
-    dwFlags: DWORD,
-    th32ProcessID: DWORD,
-) callconv(.winapi) HANDLE;
-
 // Threading
 
-// TODO: Already a wrapper for this, see `windows.GetCurrentThreadId`.
-pub extern "kernel32" fn GetCurrentThreadId() callconv(.winapi) DWORD;
-
 // TODO: CreateRemoteThread with hProcess=NtCurrentProcess().
 pub extern "kernel32" fn CreateThread(
     lpThreadAttributes: ?*SECURITY_ATTRIBUTES,
     dwStackSize: SIZE_T,
-    lpStartAddress: LPTHREAD_START_ROUTINE,
+    lpStartAddress: *const THREAD_START_ROUTINE,
     lpParameter: ?LPVOID,
     dwCreationFlags: DWORD,
     lpThreadId: ?*DWORD,
 ) callconv(.winapi) ?HANDLE;
 
-// Code Libraries/Modules
-
-// TODO: Wrapper around LdrGetDllFullName.
-pub extern "kernel32" fn GetModuleFileNameW(
-    hModule: ?HMODULE,
-    lpFilename: [*]WCHAR,
-    nSize: DWORD,
-) callconv(.winapi) DWORD;
-
-extern "kernel32" fn K32GetModuleFileNameExW(
-    hProcess: HANDLE,
-    hModule: ?HMODULE,
-    lpFilename: LPWSTR,
-    nSize: DWORD,
-) callconv(.winapi) DWORD;
-pub const GetModuleFileNameExW = K32GetModuleFileNameExW;
-
-// TODO: Wrapper around ntdll.LdrGetDllHandle, which is a wrapper around LdrGetDllHandleEx
-pub extern "kernel32" fn GetModuleHandleW(
-    lpModuleName: ?LPCWSTR,
-) callconv(.winapi) ?HMODULE;
-
-pub extern "kernel32" fn Module32First(
-    hSnapshot: HANDLE,
-    lpme: *MODULEENTRY32,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn Module32Next(
-    hSnapshot: HANDLE,
-    lpme: *MODULEENTRY32,
-) callconv(.winapi) BOOL;
-
-pub extern "kernel32" fn LoadLibraryW(
-    lpLibFileName: LPCWSTR,
-) callconv(.winapi) ?HMODULE;
-
-pub extern "kernel32" fn LoadLibraryExW(
-    lpLibFileName: LPCWSTR,
-    hFile: ?HANDLE,
-    dwFlags: DWORD,
-) callconv(.winapi) ?HMODULE;
-
-pub extern "kernel32" fn GetProcAddress(
-    hModule: HMODULE,
-    lpProcName: LPCSTR,
-) callconv(.winapi) ?FARPROC;
-
-pub extern "kernel32" fn FreeLibrary(
-    hModule: HMODULE,
-) callconv(.winapi) BOOL;
-
 // Error Management
 
 pub extern "kernel32" fn FormatMessageW(
@@ -252,6 +62,3 @@ pub extern "kernel32" fn FormatMessageW(
     nSize: DWORD,
     Arguments: ?*va_list,
 ) callconv(.winapi) DWORD;
-
-// TODO: Getter for teb().LastErrorValue.
-pub extern "kernel32" fn GetLastError() callconv(.winapi) Win32Error;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index bda9fee828b6dc33c44b4a40b090c1d0f6761d84..77799bc1b4d762d7ba67753ccc232d3a63d90ca8 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -2,6 +2,7 @@ const std = @import("../../std.zig");
 const windows = std.os.windows;
 
 const ACCESS_MASK = windows.ACCESS_MASK;
+const ANSI_STRING = windows.ANSI_STRING;
 const BOOL = windows.BOOL;
 const BOOLEAN = windows.BOOLEAN;
 const CONDITION_VARIABLE = windows.CONDITION_VARIABLE;
@@ -9,6 +10,7 @@ const CONTEXT = windows.CONTEXT;
 const CRITICAL_SECTION = windows.CRITICAL_SECTION;
 const CTL_CODE = windows.CTL_CODE;
 const CURDIR = windows.CURDIR;
+const DIRECTORY = windows.DIRECTORY;
 const DWORD = windows.DWORD;
 const DWORD64 = windows.DWORD64;
 const ERESOURCE = windows.ERESOURCE;
@@ -22,18 +24,19 @@ const IO_APC_ROUTINE = windows.IO_APC_ROUTINE;
 const IO_STATUS_BLOCK = windows.IO_STATUS_BLOCK;
 const KNONVOLATILE_CONTEXT_POINTERS = windows.KNONVOLATILE_CONTEXT_POINTERS;
 const LARGE_INTEGER = windows.LARGE_INTEGER;
+const LDR = windows.LDR;
 const LOGICAL = windows.LOGICAL;
 const LONG = windows.LONG;
 const LPCVOID = windows.LPCVOID;
 const LPVOID = windows.LPVOID;
 const MEM = windows.MEM;
 const NTSTATUS = windows.NTSTATUS;
-const OBJECT_ATTRIBUTES = windows.OBJECT_ATTRIBUTES;
-const OBJECT_INFORMATION_CLASS = windows.OBJECT_INFORMATION_CLASS;
+const OBJECT = windows.OBJECT;
 const PAGE = windows.PAGE;
 const PCWSTR = windows.PCWSTR;
-const PROCESSINFOCLASS = windows.PROCESSINFOCLASS;
+const PROCESS = windows.PROCESS;
 const PVOID = windows.PVOID;
+const PWSTR = windows.PWSTR;
 const RTL_OSVERSIONINFOW = windows.RTL_OSVERSIONINFOW;
 const RTL_QUERY_REGISTRY_TABLE = windows.RTL_QUERY_REGISTRY_TABLE;
 const RUNTIME_FUNCTION = windows.RUNTIME_FUNCTION;
@@ -41,8 +44,8 @@ const SEC = windows.SEC;
 const SECTION_INHERIT = windows.SECTION_INHERIT;
 const SIZE_T = windows.SIZE_T;
 const SRWLOCK = windows.SRWLOCK;
-const SYSTEM_INFORMATION_CLASS = windows.SYSTEM_INFORMATION_CLASS;
-const THREADINFOCLASS = windows.THREADINFOCLASS;
+const SYSTEM = windows.SYSTEM;
+const THREAD = windows.THREAD;
 const ULONG = windows.ULONG;
 const ULONG_PTR = windows.ULONG_PTR;
 const UNICODE_STRING = windows.UNICODE_STRING;
@@ -91,7 +94,7 @@ pub extern "ntdll" fn RtlCaptureContext(
 
 pub extern "ntdll" fn NtSetInformationThread(
     ThreadHandle: HANDLE,
-    ThreadInformationClass: THREADINFOCLASS,
+    ThreadInformationClass: THREAD.INFOCLASS,
     ThreadInformation: *const anyopaque,
     ThreadInformationLength: ULONG,
 ) callconv(.winapi) NTSTATUS;
@@ -99,7 +102,7 @@ pub extern "ntdll" fn NtSetInformationThread(
 pub extern "ntdll" fn NtCreateFile(
     FileHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: *const OBJECT_ATTRIBUTES,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
     IoStatusBlock: *IO_STATUS_BLOCK,
     AllocationSize: ?*const LARGE_INTEGER,
     FileAttributes: FILE.ATTRIBUTE,
@@ -152,7 +155,7 @@ pub extern "ntdll" fn NtLockFile(
 pub extern "ntdll" fn NtOpenFile(
     FileHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: *const OBJECT_ATTRIBUTES,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
     IoStatusBlock: *IO_STATUS_BLOCK,
     ShareAccess: FILE.SHARE,
     OpenOptions: FILE.MODE,
@@ -233,7 +236,7 @@ pub extern "ntdll" fn NtUnlockFile(
 
 pub extern "ntdll" fn NtQueryObject(
     Handle: HANDLE,
-    ObjectInformationClass: OBJECT_INFORMATION_CLASS,
+    ObjectInformationClass: OBJECT.INFORMATION_CLASS,
     ObjectInformation: ?PVOID,
     ObjectInformationLength: ULONG,
     ReturnLength: ?*ULONG,
@@ -246,7 +249,7 @@ pub extern "ntdll" fn NtClose(
 pub extern "ntdll" fn NtCreateSection(
     SectionHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: ?*const OBJECT_ATTRIBUTES,
+    ObjectAttributes: ?*const OBJECT.ATTRIBUTES,
     MaximumSize: ?*const LARGE_INTEGER,
     SectionPageProtection: PAGE,
     AllocationAttributes: SEC,
@@ -331,7 +334,7 @@ pub extern "ntdll" fn NtWaitForSingleObject(
 
 pub extern "ntdll" fn NtQueryInformationProcess(
     ProcessHandle: HANDLE,
-    ProcessInformationClass: PROCESSINFOCLASS,
+    ProcessInformationClass: PROCESS.INFOCLASS,
     ProcessInformation: *anyopaque,
     ProcessInformationLength: ULONG,
     ReturnLength: ?*ULONG,
@@ -339,14 +342,14 @@ pub extern "ntdll" fn NtQueryInformationProcess(
 
 pub extern "ntdll" fn NtQueryInformationThread(
     ThreadHandle: HANDLE,
-    ThreadInformationClass: THREADINFOCLASS,
+    ThreadInformationClass: THREAD.INFOCLASS,
     ThreadInformation: *anyopaque,
     ThreadInformationLength: ULONG,
     ReturnLength: ?*ULONG,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQuerySystemInformation(
-    SystemInformationClass: SYSTEM_INFORMATION_CLASS,
+    SystemInformationClass: SYSTEM.INFORMATION_CLASS,
     SystemInformation: PVOID,
     SystemInformationLength: ULONG,
     ReturnLength: ?*ULONG,
@@ -354,15 +357,99 @@ pub extern "ntdll" fn NtQuerySystemInformation(
 
 // ref none
 
+pub extern "ntdll" fn LdrAddRefDll(
+    Flags: ULONG,
+    DllHandle: PVOID,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrLoadDll(
+    DllPath: ?PCWSTR,
+    DllCharacteristics: ?*const ULONG,
+    DllName: *const UNICODE_STRING,
+    DllHandle: *PVOID,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrUnloadDll(
+    DllHandle: PVOID,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn LdrFindEntryForAddress(
+    DllHandle: PVOID,
+    Entry: **LDR.DATA_TABLE_ENTRY,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetDllFullName(
+    DllHandle: ?PVOID,
+    FullDllName: *UNICODE_STRING,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetDllPath(
+    DllName: PCWSTR,
+    Flags: LDR.LOAD,
+    DllPath: *PWSTR,
+    SearchPaths: *PWSTR,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn LdrGetDllHandle(
+    DllPath: ?PCWSTR,
+    DllCharacteristics: ?*const ULONG,
+    DllName: *const UNICODE_STRING,
+    DllHandle: *PVOID,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetDllHandleByMapping(
+    BaseAddress: PVOID,
+    DllHandle: *PVOID,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetDllHandleByName(
+    BaseDllName: *const UNICODE_STRING,
+    FullDllName: *const UNICODE_STRING,
+    DllHandle: *PVOID,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetDllHandleEx(
+    Flags: LDR.GET_DLL_HANDLE_EX,
+    DllPath: ?PCWSTR,
+    DllCharacteristics: ?*const ULONG,
+    DllName: *const UNICODE_STRING,
+    DllHandle: *PVOID,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn LdrGetProcedureAddress(
+    DllHandle: PVOID,
+    ProcedureName: *const ANSI_STRING,
+    ProcedureNumber: ULONG,
+    ProcedureAddress: *PVOID,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetProcedureAddressEx(
+    DllHandle: PVOID,
+    ProcedureName: *const ANSI_STRING,
+    ProcedureNumber: ULONG,
+    ProcedureAddress: *PVOID,
+    Flags: LDR.GET_PROCEDURE_ADDRESS,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrGetProcedureAddressForCaller(
+    DllHandle: PVOID,
+    ProcedureName: *const ANSI_STRING,
+    ProcedureNumber: ULONG,
+    ProcedureAddress: *PVOID,
+    Flags: LDR.GET_PROCEDURE_ADDRESS,
+    CallerAddress: PVOID,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn LdrRegisterDllNotification(
+    Flags: LDR.DLL_NOTIFICATION.REGISTER,
+    NotificationFunction: *const LDR.DLL_NOTIFICATION.FUNCTION,
+    Context: ?PVOID,
+    Cookie: *LDR.DLL_NOTIFICATION.COOKIE,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn LdrUnregisterDllNotification(
+    Cookie: LDR.DLL_NOTIFICATION.COOKIE,
+) callconv(.winapi) NTSTATUS;
+
 pub extern "ntdll" fn NtQueryAttributesFile(
-    ObjectAttributes: *const OBJECT_ATTRIBUTES,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
     FileAttributes: *FILE.BASIC_INFORMATION,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtCreateEvent(
     EventHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: ?*const OBJECT_ATTRIBUTES,
+    ObjectAttributes: ?*const OBJECT.ATTRIBUTES,
     EventType: EVENT_TYPE,
     InitialState: BOOLEAN,
 ) callconv(.winapi) NTSTATUS;
@@ -374,7 +461,7 @@ pub extern "ntdll" fn NtSetEvent(
 pub extern "ntdll" fn NtCreateKeyedEvent(
     KeyedEventHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: ?*const OBJECT_ATTRIBUTES,
+    ObjectAttributes: ?*const OBJECT.ATTRIBUTES,
     Flags: ULONG,
 ) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtReleaseKeyedEvent(
@@ -390,10 +477,57 @@ pub extern "ntdll" fn NtWaitForKeyedEvent(
     Timeout: ?*const LARGE_INTEGER,
 ) callconv(.winapi) NTSTATUS;
 
+pub extern "ntdll" fn NtCancelSynchronousIoFile(
+    ThreadHandle: HANDLE,
+    IoRequestToCancel: ?*IO_STATUS_BLOCK,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtCancelIoFile(
+    FileHandle: HANDLE,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtCancelIoFileEx(
+    FileHandle: HANDLE,
+    IoRequestToCancel: *const IO_STATUS_BLOCK,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+) callconv(.winapi) NTSTATUS;
+
+/// This function has been observed to return SUCCESS on timeout on Windows 10
+/// and TIMEOUT on Wine 10.0.
+///
+/// This function has been observed on Windows 11 such that positive interval
+/// is real time, which can cause waits to be interrupted by changing system
+/// time, however negative intervals are not affected by changes to system
+/// time.
+pub extern "ntdll" fn NtDelayExecution(
+    Alertable: BOOLEAN,
+    DelayInterval: *const LARGE_INTEGER,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn NtNotifyChangeDirectoryFileEx(
+    FileHandle: HANDLE,
+    Event: ?HANDLE,
+    ApcRoutine: ?*const IO_APC_ROUTINE,
+    ApcContext: ?*anyopaque,
+    IoStatusBlock: *IO_STATUS_BLOCK,
+    Buffer: *anyopaque,
+    Length: ULONG,
+    CompletionFilter: FILE.NOTIFY.CHANGE,
+    WatchTree: BOOLEAN,
+    DirectoryNotifyInformationClass: DIRECTORY.NOTIFY_INFORMATION_CLASS,
+) callconv(.winapi) NTSTATUS;
+
+pub extern "ntdll" fn NtOpenThread(
+    ThreadHandle: *HANDLE,
+    DesiredAccess: ACCESS_MASK,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
+    ClientId: *const windows.CLIENT_ID,
+) callconv(.winapi) NTSTATUS;
+
 pub extern "ntdll" fn NtCreateNamedPipeFile(
     FileHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: *const OBJECT_ATTRIBUTES,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
     IoStatusBlock: *IO_STATUS_BLOCK,
     ShareAccess: FILE.SHARE,
     CreateDisposition: FILE.CREATE_DISPOSITION,
@@ -437,7 +571,7 @@ pub extern "ntdll" fn NtUnmapViewOfSectionEx(
 pub extern "ntdll" fn NtOpenKey(
     KeyHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: *const OBJECT_ATTRIBUTES,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQueueApcThread(
@@ -470,6 +604,19 @@ pub extern "ntdll" fn NtProtectVirtualMemory(
     OldAccessProtection: *PAGE,
 ) callconv(.winapi) NTSTATUS;
 
+pub extern "ntdll" fn NtWaitForAlertByThreadId(
+    Address: ?*const anyopaque,
+    Timeout: ?*const LARGE_INTEGER,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtAlertThreadByThreadId(ThreadId: DWORD) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtAlertThread(ThreadHandle: HANDLE) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtAlertMultipleThreadByThreadId(
+    ThreadIds: [*]const ULONG_PTR,
+    ThreadCount: ULONG,
+    Unknown1: ?*const anyopaque,
+    Unknown2: ?*const anyopaque,
+) callconv(.winapi) NTSTATUS;
+
 pub extern "ntdll" fn NtYieldExecution() callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlAddVectoredExceptionHandler(
@@ -527,10 +674,6 @@ pub extern "ntdll" fn RtlQueryPerformanceCounter(
 pub extern "ntdll" fn RtlQueryPerformanceFrequency(
     PerformanceFrequency: *LARGE_INTEGER,
 ) callconv(.winapi) BOOL;
-pub extern "ntdll" fn NtQueryPerformanceCounter(
-    PerformanceCounter: *LARGE_INTEGER,
-    PerformanceFrequency: ?*LARGE_INTEGER,
-) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlReAllocateHeap(
     HeapHandle: *HEAP,
@@ -539,8 +682,17 @@ pub extern "ntdll" fn RtlReAllocateHeap(
     Size: SIZE_T,
 ) callconv(.winapi) ?PVOID;
 
+pub extern "ntdll" fn RtlReportSilentProcessExit(
+    ProcessHandle: HANDLE,
+    ExitStatus: NTSTATUS,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtTerminateProcess(
+    ProcessHandle: ?HANDLE,
+    ExitStatus: NTSTATUS,
+) callconv(.winapi) NTSTATUS;
+
 pub extern "ntdll" fn RtlSetCurrentDirectory_U(
-    PathName: *UNICODE_STRING,
+    PathName: *const UNICODE_STRING,
 ) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlTryAcquireSRWLockExclusive(
@@ -572,52 +724,3 @@ pub extern "ntdll" fn RtlWakeConditionVariable(
 pub extern "ntdll" fn RtlWakeAllConditionVariable(
     ConditionVariable: *CONDITION_VARIABLE,
 ) callconv(.winapi) void;
-
-pub extern "ntdll" fn NtWaitForAlertByThreadId(
-    Address: ?*const anyopaque,
-    Timeout: ?*const LARGE_INTEGER,
-) callconv(.winapi) NTSTATUS;
-pub extern "ntdll" fn NtAlertThreadByThreadId(ThreadId: DWORD) callconv(.winapi) NTSTATUS;
-pub extern "ntdll" fn NtAlertThread(ThreadHandle: HANDLE) callconv(.winapi) NTSTATUS;
-pub extern "ntdll" fn NtAlertMultipleThreadByThreadId(
-    ThreadIds: [*]const ULONG_PTR,
-    ThreadCount: ULONG,
-    Unknown1: ?*const anyopaque,
-    Unknown2: ?*const anyopaque,
-) callconv(.winapi) NTSTATUS;
-
-pub extern "ntdll" fn NtOpenThread(
-    ThreadHandle: *HANDLE,
-    DesiredAccess: ACCESS_MASK,
-    ObjectAttributes: *const OBJECT_ATTRIBUTES,
-    ClientId: *const windows.CLIENT_ID,
-) callconv(.winapi) NTSTATUS;
-
-pub extern "ntdll" fn NtCancelSynchronousIoFile(
-    ThreadHandle: HANDLE,
-    IoRequestToCancel: ?*IO_STATUS_BLOCK,
-    IoStatusBlock: *IO_STATUS_BLOCK,
-) callconv(.winapi) NTSTATUS;
-
-/// This function has been observed to return SUCCESS on timeout on Windows 10
-/// and TIMEOUT on Wine 10.0.
-///
-/// This function has been observed on Windows 11 such that positive interval
-/// is real time, which can cause waits to be interrupted by changing system
-/// time, however negative intervals are not affected by changes to system
-/// time.
-pub extern "ntdll" fn NtDelayExecution(
-    Alertable: BOOLEAN,
-    DelayInterval: *const LARGE_INTEGER,
-) callconv(.winapi) NTSTATUS;
-
-pub extern "ntdll" fn NtCancelIoFile(
-    FileHandle: HANDLE,
-    IoStatusBlock: *IO_STATUS_BLOCK,
-) callconv(.winapi) NTSTATUS;
-
-pub extern "ntdll" fn NtCancelIoFileEx(
-    FileHandle: HANDLE,
-    IoRequestToCancel: *const IO_STATUS_BLOCK,
-    IoStatusBlock: *IO_STATUS_BLOCK,
-) callconv(.winapi) NTSTATUS;
diff --git a/lib/std/os/windows/win32error.zig b/lib/std/os/windows/win32error.zig
index a71256228c3faea3ed46def3b64035592581f5a8..4dc826cbb9a8a983c9d998e477273bc5eb883ae9 100644
--- a/lib/std/os/windows/win32error.zig
+++ b/lib/std/os/windows/win32error.zig
@@ -1,5 +1,5 @@
 /// Codes are from https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-erref/18d8fbe8-a967-4f1c-ae50-99ca8e491d2d
-pub const Win32Error = enum(u16) {
+pub const Win32Error = enum(u32) {
     /// The operation completed successfully.
     SUCCESS = 0,
     /// Incorrect function.
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 618d7f8f5bc3cbc1b62e05693d5d550fdcbb5eb1..2e3056b96099412d672fcc8f6fd4b5eca8768096 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -243,7 +243,7 @@ pub fn getBaseAddress() usize {
         .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
             return @intFromPtr(&std.c._mh_execute_header);
         },
-        .windows => return @intFromPtr(windows.kernel32.GetModuleHandleW(null)),
+        .windows => return @intFromPtr(windows.peb().ImageBaseAddress),
         else => @compileError("Unsupported OS"),
     }
 }
@@ -606,11 +606,11 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
             return @as(u64, @bitCast(physmem));
         },
         .windows => {
-            var sbi: windows.SYSTEM_BASIC_INFORMATION = undefined;
+            var sbi: windows.SYSTEM.BASIC_INFORMATION = undefined;
             const rc = windows.ntdll.NtQuerySystemInformation(
-                .SystemBasicInformation,
+                .Basic,
                 &sbi,
-                @sizeOf(windows.SYSTEM_BASIC_INFORMATION),
+                @sizeOf(windows.SYSTEM.BASIC_INFORMATION),
                 null,
             );
             if (rc != .SUCCESS) {
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 7ce3143b362de6f5f837f7e513304d54b47fea4b..0cc60a23e999239401c7531cade47eff2d27e52d 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -86,7 +86,7 @@ pub const ResourceUsageStatistics = struct {
         .visionos,
         .watchos,
         => @as(?std.posix.rusage, null),
-        .windows => @as(?std.os.windows.VM_COUNTERS, null),
+        .windows => @as(?std.os.windows.PROCESS.VM_COUNTERS, null),
         else => {},
     };
 };
diff --git a/lib/std/start.zig b/lib/std/start.zig
index e39465fe9b395b0cc4a4395eb589d98b42ac3232..9bc001fe598b5182943be40b85794ba95e7c7158 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -473,10 +473,9 @@ fn WinStartup() callconv(.withStackAlign(.c, 1)) noreturn {
     std.Thread.maybeAttachSignalStack();
     std.debug.maybeEnableSegfaultHandler();
 
-    const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
-    const cmd_line_w = cmd_line.Buffer.?[0..@divExact(cmd_line.Length, 2)];
-
-    std.os.windows.ntdll.RtlExitUserProcess(callMain(cmd_line_w, .global));
+    std.os.windows.ntdll.RtlExitUserProcess(
+        callMain(std.os.windows.peb().ProcessParameters.CommandLine.slice(), .global),
+    );
 }
 
 fn wWinMainCRTStartup() callconv(.withStackAlign(.c, 1)) noreturn {
@@ -647,9 +646,7 @@ fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) cal
             // values in their intended encoding from the PEB instead.
             std.Thread.maybeAttachSignalStack();
             std.debug.maybeEnableSegfaultHandler();
-            const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
-            const cmd_line_w = cmd_line.Buffer.?[0..@divExact(cmd_line.Length, 2)];
-            return callMain(cmd_line_w, .global);
+            return callMain(std.os.windows.peb().ProcessParameters.CommandLine.slice(), .global);
         },
         else => {},
     }
@@ -776,8 +773,7 @@ fn call_wWinMain() std.os.windows.INT {
         // - With STARTF_USESHOWWINDOW unset:
         //   - nShowCmd is always SW_SHOWDEFAULT
         const SW_SHOWDEFAULT = 10;
-        const STARTF_USESHOWWINDOW = 1;
-        if (peb.ProcessParameters.dwFlags & STARTF_USESHOWWINDOW != 0) {
+        if (peb.ProcessParameters.dwFlags & std.os.windows.STARTF_USESHOWWINDOW != 0) {
             break :nShowCmd @truncate(peb.ProcessParameters.dwShowWindow);
         }
         break :nShowCmd SW_SHOWDEFAULT;
diff --git a/lib/std/zig/system/windows.zig b/lib/std/zig/system/windows.zig
index 43d407c3a0a0a26b850d0eb8c9fa12cf7707f33a..0a752dd7f9d55d18073830b1bdcfcc6c12af45f7 100644
--- a/lib/std/zig/system/windows.zig
+++ b/lib/std/zig/system/windows.zig
@@ -100,11 +100,11 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
                 REG.MULTI_SZ,
                 => {
                     comptime assert(@sizeOf(std.os.windows.UNICODE_STRING) % 2 == 0);
-                    const unicode = @as(*std.os.windows.UNICODE_STRING, @ptrCast(&tmp_bufs[i]));
+                    const unicode: *std.os.windows.UNICODE_STRING = @ptrCast(&tmp_bufs[i]);
                     unicode.* = .{
                         .Length = 0,
                         .MaximumLength = max_value_len - @sizeOf(std.os.windows.UNICODE_STRING),
-                        .Buffer = @as([*]u16, @ptrCast(tmp_bufs[i][@sizeOf(std.os.windows.UNICODE_STRING)..])),
+                        .Buffer = @ptrCast(tmp_bufs[i][@sizeOf(std.os.windows.UNICODE_STRING)..]),
                     };
                     break :blk unicode;
                 },
@@ -159,8 +159,8 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
                 REG.MULTI_SZ,
                 => {
                     var buf = @field(args, field.name).value_buf;
-                    const entry = @as(*align(1) const std.os.windows.UNICODE_STRING, @ptrCast(table[i + 1].EntryContext));
-                    const len = try std.unicode.utf16LeToUtf8(buf, entry.Buffer.?[0 .. entry.Length / 2]);
+                    const entry: *const std.os.windows.UNICODE_STRING = @ptrCast(table[i + 1].EntryContext);
+                    const len = try std.unicode.utf16LeToUtf8(buf, entry.slice());
                     buf[len] = 0;
                 },
 
@@ -168,7 +168,7 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
                 REG.DWORD_BIG_ENDIAN,
                 REG.QWORD,
                 => {
-                    const entry = @as([*]align(1) const u8, @ptrCast(table[i + 1].EntryContext));
+                    const entry: [*]const u8 = @ptrCast(table[i + 1].EntryContext);
                     switch (@field(args, field.name).value_type) {
                         REG.DWORD, REG.DWORD_BIG_ENDIAN => {
                             @memcpy(@field(args, field.name).value_buf[0..4], entry[0..4]);
diff --git a/lib/zig.h b/lib/zig.h
index 7a7a22b17ba14ff003c3b64964f61a88bafb76f7..81a815ab5568b57f5d48c8da91a04b761d4f9a2a 100644
--- a/lib/zig.h
+++ b/lib/zig.h
@@ -4148,7 +4148,7 @@ static inline void zig_msvc_atomic_store_i128(zig_i128 volatile* obj, zig_i128 a
 
 #if defined(zig_thumb)
 
-static inline void* zig_thumb_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)_MoveFromCoprocessor(15, 0, 13, 0, 2);
@@ -4160,7 +4160,7 @@ static inline void* zig_thumb_windows_teb(void) {
 
 #elif defined(zig_aarch64)
 
-static inline void* zig_aarch64_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)__readx18qword(0x0);
@@ -4172,7 +4172,7 @@ static inline void* zig_aarch64_windows_teb(void) {
 
 #elif defined(zig_x86_32)
 
-static inline void* zig_x86_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)__readfsdword(0x18);
@@ -4182,9 +4182,19 @@ static inline void* zig_x86_windows_teb(void) {
     return teb;
 }
 
+static inline void* zig_windows_peb(void) {
+    void* peb = 0;
+#if defined(zig_msvc)
+    peb = (void*)__readfsdword(0x30);
+#elif defined(zig_gnuc_asm)
+    __asm__ ("movl %%fs:0x30, %[ptr]" : [ptr] "=r" (peb));
+#endif
+    return peb;
+}
+
 #elif defined(zig_x86_64)
 
-static inline void* zig_x86_64_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)__readgsqword(0x30);
@@ -4194,6 +4204,16 @@ static inline void* zig_x86_64_windows_teb(void) {
     return teb;
 }
 
+static inline void* zig_windows_peb(void) {
+    void* peb = 0;
+#if defined(zig_msvc)
+    peb = (void*)__readgsqword(0x60);
+#elif defined(zig_gnuc_asm)
+    __asm__ ("movq %%gs:0x60, %[ptr]" : [ptr] "=r" (peb));
+#endif
+    return peb;
+}
+
 #endif
 
 #if defined(zig_loongarch)
diff --git a/stage1/zig.h b/stage1/zig.h
index 7a7a22b17ba14ff003c3b64964f61a88bafb76f7..81a815ab5568b57f5d48c8da91a04b761d4f9a2a 100644
--- a/stage1/zig.h
+++ b/stage1/zig.h
@@ -4148,7 +4148,7 @@ static inline void zig_msvc_atomic_store_i128(zig_i128 volatile* obj, zig_i128 a
 
 #if defined(zig_thumb)
 
-static inline void* zig_thumb_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)_MoveFromCoprocessor(15, 0, 13, 0, 2);
@@ -4160,7 +4160,7 @@ static inline void* zig_thumb_windows_teb(void) {
 
 #elif defined(zig_aarch64)
 
-static inline void* zig_aarch64_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)__readx18qword(0x0);
@@ -4172,7 +4172,7 @@ static inline void* zig_aarch64_windows_teb(void) {
 
 #elif defined(zig_x86_32)
 
-static inline void* zig_x86_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)__readfsdword(0x18);
@@ -4182,9 +4182,19 @@ static inline void* zig_x86_windows_teb(void) {
     return teb;
 }
 
+static inline void* zig_windows_peb(void) {
+    void* peb = 0;
+#if defined(zig_msvc)
+    peb = (void*)__readfsdword(0x30);
+#elif defined(zig_gnuc_asm)
+    __asm__ ("movl %%fs:0x30, %[ptr]" : [ptr] "=r" (peb));
+#endif
+    return peb;
+}
+
 #elif defined(zig_x86_64)
 
-static inline void* zig_x86_64_windows_teb(void) {
+static inline void* zig_windows_teb(void) {
     void* teb = 0;
 #if defined(zig_msvc)
     teb = (void*)__readgsqword(0x30);
@@ -4194,6 +4204,16 @@ static inline void* zig_x86_64_windows_teb(void) {
     return teb;
 }
 
+static inline void* zig_windows_peb(void) {
+    void* peb = 0;
+#if defined(zig_msvc)
+    peb = (void*)__readgsqword(0x60);
+#elif defined(zig_gnuc_asm)
+    __asm__ ("movq %%gs:0x60, %[ptr]" : [ptr] "=r" (peb));
+#endif
+    return peb;
+}
+
 #endif
 
 #if defined(zig_loongarch)
diff --git a/test/standalone/coff_dwarf/main.zig b/test/standalone/coff_dwarf/main.zig
index 79caaeb95a2f569e7a0a4e62e35083216b49cdec..24684d3830e7ff35719fe9d6a90f037d8a984630 100644
--- a/test/standalone/coff_dwarf/main.zig
+++ b/test/standalone/coff_dwarf/main.zig
@@ -4,17 +4,16 @@ const fatal = std.process.fatal;
 extern fn add(a: u32, b: u32, addr: *usize) u32;
 
 pub fn main(init: std.process.Init) void {
-    const gpa = init.gpa;
     const io = init.io;
 
     var di: std.debug.SelfInfo = .init;
-    defer di.deinit(gpa);
+    defer di.deinit(io);
 
     var add_addr: usize = undefined;
     _ = add(1, 2, &add_addr);
 
-    const symbol = di.getSymbol(gpa, io, add_addr) catch |err| fatal("failed to get symbol: {t}", .{err});
-    defer if (symbol.source_location) |sl| gpa.free(sl.file_name);
+    const symbol = di.getSymbol(io, add_addr) catch |err| fatal("failed to get symbol: {t}", .{err});
+    defer if (symbol.source_location) |sl| std.debug.getDebugInfoAllocator().free(sl.file_name);
 
     if (symbol.name == null) fatal("failed to resolve symbol name", .{});
     if (symbol.compile_unit_name == null) fatal("failed to resolve compile unit", .{});
diff --git a/test/standalone/windows_argv/fuzz.zig b/test/standalone/windows_argv/fuzz.zig
index 9227bb6f893306686dc0ad08de2cfca89410b815..27b0ba3f06b3bc59387e4369c731bcca628e2685 100644
--- a/test/standalone/windows_argv/fuzz.zig
+++ b/test/standalone/windows_argv/fuzz.zig
@@ -127,7 +127,7 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
             .hStdOutput = null,
             .hStdError = windows.peb().ProcessParameters.hStdError,
         };
-        var proc_info: windows.PROCESS_INFORMATION = undefined;
+        var proc_info: windows.PROCESS.INFORMATION = undefined;
 
         if (windows.kernel32.CreateProcessW(
             @constCast(verify_path.ptr),
@@ -141,7 +141,7 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
             &startup_info,
             &proc_info,
         ) == 0) {
-            std.process.fatal("kernel32 CreateProcessW failed with {t}", .{windows.kernel32.GetLastError()});
+            std.process.fatal("kernel32 CreateProcessW failed with {t}", .{windows.GetLastError()});
         }
 
         windows.CloseHandle(proc_info.hThread);
@@ -156,9 +156,15 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO
         else => |status| return windows.unexpectedStatus(status),
     }
 
-    var exit_code: windows.DWORD = undefined;
-    if (windows.kernel32.GetExitCodeProcess(child_proc, &exit_code) == 0) {
-        return error.UnableToGetExitCode;
+    var info: windows.PROCESS.BASIC_INFORMATION = undefined;
+    switch (windows.ntdll.NtQueryInformationProcess(
+        child_proc,
+        .BasicInformation,
+        &info,
+        @sizeOf(windows.PROCESS.BASIC_INFORMATION),
+        null,
+    )) {
+        .SUCCESS => return @intFromEnum(info.ExitStatus),
+        else => return error.UnableToGetExitCode,
     }
-    return exit_code;
 }
diff --git a/test/standalone/windows_argv/lib.zig b/test/standalone/windows_argv/lib.zig
index 750501edd21539e5eebe51848aaabd3ace812f59..370e62b7991e172b8a00dadea05d8e4f0b6ed3e3 100644
--- a/test/standalone/windows_argv/lib.zig
+++ b/test/standalone/windows_argv/lib.zig
@@ -16,9 +16,9 @@ fn testArgv(expected_args: []const [*:0]const u16) !void {
     defer arena_state.deinit();
     const allocator = arena_state.allocator();
 
-    const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
-    const cmd_line_w = cmd_line.Buffer.?[0..@divExact(cmd_line.Length, 2)];
-    const raw_args: std.process.Args = .{ .vector = cmd_line_w };
+    const raw_args: std.process.Args = .{
+        .vector = std.os.windows.peb().ProcessParameters.CommandLine.slice(),
+    };
     const args = try raw_args.toSlice(allocator);
     var wtf8_buf = std.array_list.Managed(u8).init(allocator);
 
-- 
2.54.0


From 703df73f389dae88776caa3a0a026eb8acc7d8f4 Mon Sep 17 00:00:00 2001
From: angus <s1712180@ed.ac.uk>
Date: Sat, 7 Feb 2026 14:19:29 +0000
Subject: [PATCH 230/499] initialize mutex correctly in kqueue.zig

---
 lib/std/Io/Kqueue.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig
index 23cd1b39286ac6f4a0c5041b5b94b9c2896121b1..822c34f789f16bc135a1ca6dab48fe1c7d5a384a 100644
--- a/lib/std/Io/Kqueue.zig
+++ b/lib/std/Io/Kqueue.zig
@@ -169,7 +169,7 @@ pub fn init(k: *Kqueue, gpa: Allocator, options: InitOptions) !void {
     errdefer gpa.free(allocated_slice);
     k.* = .{
         .gpa = gpa,
-        .mutex = .{},
+        .mutex = .init,
         .main_fiber_buffer = undefined,
         .threads = .{
             .allocated = @ptrCast(allocated_slice[0..threads_size]),
-- 
2.54.0


From 52a6242443e30265ff9e0961ff39bdea8607db45 Mon Sep 17 00:00:00 2001
From: Ben Buhse <me@benbuhse.email>
Date: Sat, 7 Feb 2026 16:21:42 -0600
Subject: [PATCH 231/499] std.os.linux: add F_SEAL constants to F struct

Add the missing F_SEAL_SEAL, F_SEAL_SHRINK, F_SEAL_GROW, F_SEAL_WRITE,
F_SEAL_FUTURE_WRITE, and F_SEAL_EXEC constants used with
F.ADD_SEALS/F.GET_SEALS for memfd file sealing. These are defined in the
Linux kernel at include/uapi/linux/fcntl.h.

The FreeBSD equivalents already exist in std.c (freebsd.F),
but the Linux side was missing them.
---
 lib/std/os/linux.zig | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index ef4616b111062dd8f5b1bd34794a9fbd15d8d7a6..c89585b9ba82c0ae6896a8284b91974bf2ceaeb2 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1862,6 +1862,14 @@ pub const F = struct {
     pub const GETPIPE_SZ = LINUX_SPECIFIC_BASE + 8;
     pub const ADD_SEALS = LINUX_SPECIFIC_BASE + 9;
     pub const GET_SEALS = LINUX_SPECIFIC_BASE + 10;
+
+    pub const SEAL_SEAL = 0x0001;
+    pub const SEAL_SHRINK = 0x0002;
+    pub const SEAL_GROW = 0x0004;
+    pub const SEAL_WRITE = 0x0008;
+    pub const SEAL_FUTURE_WRITE = 0x0010;
+    pub const SEAL_EXEC = 0x0020;
+
     pub const GET_RW_HINT = LINUX_SPECIFIC_BASE + 11;
     pub const SET_RW_HINT = LINUX_SPECIFIC_BASE + 12;
     pub const GET_FILE_RW_HINT = LINUX_SPECIFIC_BASE + 13;
-- 
2.54.0


From f061c0dc2851e5fab34dca1991ebe64cfd156bd5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 8 Feb 2026 23:32:18 +0100
Subject: [PATCH 232/499] ci: disable loongarch64-linux

https://codeberg.org/ziglang/zig/issues/30800
---
 .forgejo/workflows/ci.yaml | 41 +++++++++++++++++++-------------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 48813b9001d0463d39b7ce8e2566ae5dad555b87..8ae897599a521ee72f7cbfe3ecde10e7110ff15a 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -59,26 +59,27 @@ jobs:
         run: sh ci/aarch64-macos-release.sh
         timeout-minutes: 120
 
-  loongarch64-linux-debug:
-    runs-on: [self-hosted, loongarch64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/loongarch64-linux-debug.sh
-        timeout-minutes: 240
-  loongarch64-linux-release:
-    runs-on: [self-hosted, loongarch64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/loongarch64-linux-release.sh
-        timeout-minutes: 180
+  # https://codeberg.org/ziglang/zig/issues/30800
+  #loongarch64-linux-debug:
+  #  runs-on: [self-hosted, loongarch64-linux]
+  #  steps:
+  #    - name: Checkout
+  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+  #      with:
+  #        fetch-depth: 0
+  #    - name: Build and Test
+  #      run: sh ci/loongarch64-linux-debug.sh
+  #      timeout-minutes: 240
+  #loongarch64-linux-release:
+  #  runs-on: [self-hosted, loongarch64-linux]
+  #  steps:
+  #    - name: Checkout
+  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+  #      with:
+  #        fetch-depth: 0
+  #    - name: Build and Test
+  #      run: sh ci/loongarch64-linux-release.sh
+  #      timeout-minutes: 180
 
   powerpc64le-linux-debug:
     runs-on: [self-hosted, powerpc64le-linux]
-- 
2.54.0


From 6c6392633329c3654498409d2b02c16c3f5f9dc7 Mon Sep 17 00:00:00 2001
From: Sam K <sam.d.killen@gmail.com>
Date: Tue, 7 Jan 2025 16:33:41 +1100
Subject: [PATCH 233/499] Autodoc: display line numbers in source code display

---
 lib/docs/index.html           | 18 +++++++++++++++++-
 lib/docs/main.js              |  9 +++++++++
 lib/docs/wasm/html_render.zig | 14 ++++++++++++++
 lib/docs/wasm/main.zig        | 11 +++++++++++
 4 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index e60a3f960a26a12c436a8a3589cc8f48f05350f1..75c0daf79795c28fd288235e675dfb3ccbe85f92 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -40,6 +40,15 @@
       code a {
         color: #000000;
       }
+      .source-code {
+        display: grid;
+        grid-template-columns: auto 1fr;
+        align-items: start;
+      }
+      .source-line-numbers pre {
+        text-align: right;
+        color: #666;
+      }
       #listFields > div, #listParams > div {
         margin-bottom: 1em;
       }
@@ -429,7 +438,14 @@
     </div>
     <div id="sectSource" class="hidden">
       <h2>Source Code</h2>
-      <pre><code id="sourceText"></code></pre>
+      <div class="source-code">
+        <div class="source-line-numbers">
+          <pre><code id="sourceLineNumbers"></code></pre>
+        </div>
+        <div class="source-text">
+          <pre><code id="sourceText"></code></pre>
+        </div>
+      </div>
     </div>
     </section>
     <div id="helpDialog" class="hidden">
diff --git a/lib/docs/main.js b/lib/docs/main.js
index 71a14516cbe39e6d1b53509fd6ec99225ac5a83d..a9bf4a745e491e9e7486e258c2ad83d80ed3cfc7 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -50,6 +50,7 @@
     const domSectTypes = document.getElementById("sectTypes");
     const domSectValues = document.getElementById("sectValues");
     const domSourceText = document.getElementById("sourceText");
+    const domSourceLineNumbers = document.getElementById("sourceLineNumbers");
     const domStatus = document.getElementById("status");
     const domTableFnErrors = document.getElementById("tableFnErrors");
     const domTldDocs = document.getElementById("tldDocs");
@@ -238,6 +239,7 @@
         href: location.hash,
       }]);
 
+      domSourceLineNumbers.innerHTML = declLineNumbersHtml(decl_index);
       domSourceText.innerHTML = declSourceHtml(decl_index);
 
       domSectSource.classList.remove("hidden");
@@ -389,6 +391,7 @@
       if (members.length !== 0 || fields.length !== 0) {
         renderNamespace(decl_index, members, fields);
       } else {
+        domSourceLineNumbers.innerHTML = declLineNumbersHtml(decl_index);
         domSourceText.innerHTML = declSourceHtml(decl_index);
         domSectSource.classList.remove("hidden");
       }
@@ -419,6 +422,7 @@
         renderErrorSet(base_decl, errorSetNodeList(decl_index, errorSetNode));
       }
 
+      domSourceLineNumbers.innerHTML = declLineNumbersHtml(decl_index);
       domSourceText.innerHTML = declSourceHtml(decl_index);
       domSectSource.classList.remove("hidden");
     }
@@ -433,6 +437,7 @@
         domTldDocs.classList.remove("hidden");
       }
 
+      domSourceLineNumbers.innerHTML = declLineNumbersHtml(decl_index);
       domSourceText.innerHTML = declSourceHtml(decl_index);
       domSectSource.classList.remove("hidden");
     }
@@ -918,6 +923,10 @@
       return unwrapString(wasm_exports.decl_source_html(decl_index));
     }
 
+    function declLineNumbersHtml(decl_index) {
+        return unwrapString(wasm_exports.decl_line_numbers_html(decl_index));
+    }
+
     function declDoctestHtml(decl_index) {
       return unwrapString(wasm_exports.decl_doctest_html(decl_index));
     }
diff --git a/lib/docs/wasm/html_render.zig b/lib/docs/wasm/html_render.zig
index 13d2ec05c51f7c12efe25f23d116bbbab7d64bce..0b41e6b835bbf1a0a595a6c3ae936e69e0859d95 100644
--- a/lib/docs/wasm/html_render.zig
+++ b/lib/docs/wasm/html_render.zig
@@ -30,6 +30,20 @@ pub const Annotation = struct {
     dom_id: u32,
 };
 
+pub fn fileSourceLineNumbersHtml(
+    file_index: Walk.File.Index,
+    out: *std.ArrayListUnmanaged(u8),
+    root_node: Ast.Node.Index,
+) !void {
+    const ast = file_index.get_ast();
+    const first_token_line = ast.tokenLocation(0, ast.firstToken(root_node)).line;
+    const last_token_line = ast.tokenLocation(0, ast.lastToken(root_node)).line;
+    const writer = out.writer(gpa);
+    for (first_token_line..last_token_line + 1) |i| {
+        try std.fmt.format(writer, "<span>{d}</span>\n", .{i + 1});
+    }
+}
+
 pub fn fileSourceHtml(
     file_index: Walk.File.Index,
     out: *ArrayList(u8),
diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index 2a093886f54cbe46bb084032e2d87aa44d336a6f..b2ebac2c2fb801ccec9c47f2db64cd018562d8fb 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -9,6 +9,7 @@ const ArrayList = std.ArrayList;
 const Writer = std.Io.Writer;
 
 const fileSourceHtml = @import("html_render.zig").fileSourceHtml;
+const fileSourceLineNumbersHtml = @import("html_render.zig").fileSourceLineNumbersHtml;
 const appendEscaped = @import("html_render.zig").appendEscaped;
 const resolveDeclLink = @import("html_render.zig").resolveDeclLink;
 const missing_feature_url_escape = @import("html_render.zig").missing_feature_url_escape;
@@ -543,6 +544,16 @@ export fn decl_fn_proto_html(decl_index: Decl.Index, linkify_fn_name: bool) Stri
     return String.init(string_result.items);
 }
 
+export fn decl_line_numbers_html(decl_index: Decl.Index) String {
+    const decl = decl_index.get();
+
+    string_result.clearRetainingCapacity();
+    fileSourceLineNumbersHtml(decl.file, &string_result, decl.ast_node) catch |err| {
+        fatal("unable to render source line numbers: {s}", .{@errorName(err)});
+    };
+    return String.init(string_result.items);
+}
+
 export fn decl_source_html(decl_index: Decl.Index) String {
     const decl = decl_index.get();
 
-- 
2.54.0


From e4438a58ae7de9496e64be318f10184c1b830188 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Sun, 8 Feb 2026 21:24:05 -0800
Subject: [PATCH 234/499] fatal removed in
 b745a96d20e8159a68be53478d30c72f8c216dd3

---
 lib/docs/wasm/main.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index b2ebac2c2fb801ccec9c47f2db64cd018562d8fb..bee3e4acbcc370261f3b137d40584ea2ad2f8065 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -549,7 +549,7 @@ export fn decl_line_numbers_html(decl_index: Decl.Index) String {
 
     string_result.clearRetainingCapacity();
     fileSourceLineNumbersHtml(decl.file, &string_result, decl.ast_node) catch |err| {
-        fatal("unable to render source line numbers: {s}", .{@errorName(err)});
+        std.debug.panic("unable to render source line numbers: {s}", .{@errorName(err)});
     };
     return String.init(string_result.items);
 }
-- 
2.54.0


From c99b43e3da014f943018f3baabf590122cd216a6 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Sun, 8 Feb 2026 21:24:22 -0800
Subject: [PATCH 235/499] ArrayList.writer() removed in
 57dbc9e74a3f19802e4592f35061f1524c218a8f

---
 lib/docs/wasm/html_render.zig | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/docs/wasm/html_render.zig b/lib/docs/wasm/html_render.zig
index 0b41e6b835bbf1a0a595a6c3ae936e69e0859d95..f88e6eb1dd78bcfcb25bafd1461dbab4f32247ce 100644
--- a/lib/docs/wasm/html_render.zig
+++ b/lib/docs/wasm/html_render.zig
@@ -38,9 +38,8 @@ pub fn fileSourceLineNumbersHtml(
     const ast = file_index.get_ast();
     const first_token_line = ast.tokenLocation(0, ast.firstToken(root_node)).line;
     const last_token_line = ast.tokenLocation(0, ast.lastToken(root_node)).line;
-    const writer = out.writer(gpa);
     for (first_token_line..last_token_line + 1) |i| {
-        try std.fmt.format(writer, "<span>{d}</span>\n", .{i + 1});
+        try out.print(gpa, "<span>{d}</span>\n", .{i + 1});
     }
 }
 
-- 
2.54.0


From fb18f2096aaff3a26c309da635472a2fb8b303cd Mon Sep 17 00:00:00 2001
From: antme0 <anthonyem@gmail.com>
Date: Sun, 8 Feb 2026 18:48:54 +0100
Subject: [PATCH 236/499] Allow build.zig scripts to define module definition
 files (.def) when building win32 dlls.

---
 lib/std/Build.zig              |  3 +++
 lib/std/Build/Step/Compile.zig | 17 +++++++++++++++++
 src/main.zig                   |  5 ++++-
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index 4517ce75b04fb4e2fec2d101bbfccdee92109835..257b7abef37c05e379079a7fea536ba8b3d4f452 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -832,6 +832,8 @@ pub const LibraryOptions = struct {
     /// Can be set regardless of target. The `.manifest` file will be ignored
     /// if the target object format does not support embedded manifests.
     win32_manifest: ?LazyPath = null,
+    /// Win32 module definition file (.def).
+    win32_module_definition: ?LazyPath = null,
 };
 
 pub fn addLibrary(b: *Build, options: LibraryOptions) *Step.Compile {
@@ -846,6 +848,7 @@ pub fn addLibrary(b: *Build, options: LibraryOptions) *Step.Compile {
         .use_lld = options.use_lld,
         .zig_lib_dir = options.zig_lib_dir,
         .win32_manifest = options.win32_manifest,
+        .win32_module_definition = options.win32_module_definition,
     });
 }
 
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index 8c3bb5c568387cec06411adbb04f8cdd5dfb7e46..d9bbe844f6aece8512496cf622a85523e425b5d5 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -79,6 +79,10 @@ rc_includes: std.zig.RcIncludes = .any,
 /// Set via options; intended to be read-only after that.
 win32_manifest: ?LazyPath = null,
 
+/// (Windows) .def file to embed in the compilation (dll)
+/// Set via options; intended to be read-only after that.
+win32_module_definition: ?LazyPath = null,
+
 installed_path: ?[]const u8,
 
 /// Base address for an executable image.
@@ -284,6 +288,8 @@ pub const Options = struct {
     /// Can be set regardless of target. The `.manifest` file will be ignored
     /// if the target object format does not support embedded manifests.
     win32_manifest: ?LazyPath = null,
+    /// Win32 module definition file.
+    win32_module_definition: ?LazyPath = null,
 };
 
 pub const Kind = enum {
@@ -467,6 +473,13 @@ pub fn create(owner: *std.Build, options: Options) *Compile {
             compile.win32_manifest = lp.dupe(compile.step.owner);
             lp.addStepDependencies(&compile.step);
         }
+        if (compile.kind == .lib and compile.linkage != null and compile.linkage.? == .dynamic) {
+            // Building a Win32 DLL, check for win32 .def file.
+            if (options.win32_module_definition) |lp| {
+                compile.win32_module_definition = lp.dupe(compile.step.owner);
+                lp.addStepDependencies(&compile.step);
+            }
+        }
     }
 
     if (compile.kind == .lib) {
@@ -1332,6 +1345,10 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         try zig_args.append(manifest_file.getPath2(b, step));
     }
 
+    if (compile.win32_module_definition) |module_file| {
+        try zig_args.append(module_file.getPath2(b, step));
+    }
+
     if (compile.image_base) |image_base| {
         try zig_args.append("--image-base");
         try zig_args.append(b.fmt("0x{x}", .{image_base}));
diff --git a/src/main.zig b/src/main.zig
index a02927298750296aecbdb27d16c62fe7e811505f..ed194b476776ffd6f597227dac5498b71eff967e 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1809,6 +1809,9 @@ fn buildOutputType(
                             fatal("only one manifest file can be specified, found '{s}' after '{s}'", .{ arg, other });
                         } else manifest_file = arg;
                     },
+                    .def => {
+                        linker_module_definition_file = arg;
+                    },
                     .assembly, .assembly_with_cpp, .c, .cpp, .h, .hpp, .hm, .hmm, .ll, .bc, .m, .mm => {
                         dev.check(.c_compiler);
                         try create_module.c_source_files.append(arena, .{
@@ -1834,7 +1837,7 @@ fn buildOutputType(
                             fatal("found another zig file '{s}' after root source file '{s}'", .{ arg, other });
                         } else root_src_file = arg;
                     },
-                    .def, .unknown => {
+                    .unknown => {
                         if (std.ascii.eqlIgnoreCase(".xml", fs.path.extension(arg))) {
                             warn("embedded manifest files must have the extension '.manifest'", .{});
                         }
-- 
2.54.0


From f1b255402377b41e47cec65b4dbc2633e1dd7b83 Mon Sep 17 00:00:00 2001
From: Pivok <pivoc@protonmail.com>
Date: Mon, 9 Feb 2026 07:59:40 +0100
Subject: [PATCH 237/499] libzigc: hypotf, hypotl (#31150)

Implements hypotf and hypotl for libzigc #30978.

Continuation of #31104

Commands i run:

```
$ stage3/bin/zig build -p stage4 -Denable-llvm -Dno-lib

$ stage4/bin/zig build test-libc -Dlibc-test-path=../../libc-test -Dtest-filter=hypotf -fqemu -fwasmtime --summary line
Build Summary: 365/369 steps succeeded (4 skipped)

$ stage4/bin/zig build test-modules -Dtest-target-filter=windows -Dtest-filter=hypotf --summary line
Build Summary: 53/101 steps succeeded (48 skipped)
```

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31150
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: Pivok <pivoc@protonmail.com>
Co-committed-by: Pivok <pivoc@protonmail.com>
---
 lib/c/math.zig                       | 10 ++++
 lib/libc/mingw/math/hypotf.c         | 23 --------
 lib/libc/mingw/math/hypotl.c         | 82 ----------------------------
 lib/libc/musl/src/math/hypotf.c      | 35 ------------
 lib/libc/musl/src/math/hypotl.c      | 66 ----------------------
 lib/libc/musl/src/math/i386/hypotf.s | 42 --------------
 src/libs/mingw.zig                   |  2 -
 src/libs/musl.zig                    |  3 -
 src/libs/wasi_libc.zig               |  2 -
 9 files changed, 10 insertions(+), 255 deletions(-)
 delete mode 100644 lib/libc/mingw/math/hypotf.c
 delete mode 100644 lib/libc/mingw/math/hypotl.c
 delete mode 100644 lib/libc/musl/src/math/hypotf.c
 delete mode 100644 lib/libc/musl/src/math/hypotl.c
 delete mode 100644 lib/libc/musl/src/math/i386/hypotf.s

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 403e8f9d471fefee67c667c7afa73c443ccd34c3..e9d92002c4fc391eb352fe024e567338fc74e145 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -29,6 +29,8 @@ comptime {
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        @export(&hypotf, .{ .name = "hypotf", .linkage = common.linkage, .visibility = common.visibility });
+        @export(&hypotl, .{ .name = "hypotl", .linkage = common.linkage, .visibility = common.visibility });
         @export(&nan, .{ .name = "nan", .linkage = common.linkage, .visibility = common.visibility });
         @export(&nanf, .{ .name = "nanf", .linkage = common.linkage, .visibility = common.visibility });
         @export(&nanl, .{ .name = "nanl", .linkage = common.linkage, .visibility = common.visibility });
@@ -123,6 +125,14 @@ fn hypot(x: f64, y: f64) callconv(.c) f64 {
     return math.hypot(x, y);
 }
 
+fn hypotf(x: f32, y: f32) callconv(.c) f32 {
+    return math.hypot(x, y);
+}
+
+fn hypotl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
+    return math.hypot(x, y);
+}
+
 fn pow(x: f64, y: f64) callconv(.c) f64 {
     return math.pow(f64, x, y);
 }
diff --git a/lib/libc/mingw/math/hypotf.c b/lib/libc/mingw/math/hypotf.c
deleted file mode 100644
index 5cd1a279292b791bb1085afec92a7390fa4a9db7..0000000000000000000000000000000000000000
--- a/lib/libc/mingw/math/hypotf.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER within this package.
- */
-#define _NEW_COMPLEX_FLOAT 1
-
-#include "../complex/complex_internal.h"
-#include <errno.h>
-#include <math.h>
-
-float hypotf (float x, float y)
-{
-  int x_class = fpclassify (x);
-  int y_class = fpclassify (y);
-
-  if (x_class == FP_INFINITE || y_class == FP_INFINITE)
-    return __FLT_HUGE_VAL;
-  else if (x_class == FP_NAN || y_class == FP_NAN)
-    return __FLT_NAN;
-
-  return (float) _hypot (x, y);
-}
-
diff --git a/lib/libc/mingw/math/hypotl.c b/lib/libc/mingw/math/hypotl.c
deleted file mode 100644
index 563aeb49878f1e21c60b76ccc6391df86bffb3fd..0000000000000000000000000000000000000000
--- a/lib/libc/mingw/math/hypotl.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <math.h>
-#include <float.h>
-#include <errno.h>
-
-/*
-This implementation is based largely on Cephes library
-function cabsl (cmplxl.c), which bears the following notice:
-
-Cephes Math Library Release 2.1:  January, 1989
-Copyright 1984, 1987, 1989 by Stephen L. Moshier
-Direct inquiries to 30 Frost Street, Cambridge, MA 02140
-*/
-
-/*
-   Modified for use in libmingwex.a
-   02 Sept 2002  Danny Smith  <dannysmith@users.sourceforege.net>
-   Calls to ldexpl replaced by logbl and calls to frexpl replaced
-   by scalbnl to avoid duplicated range checks.
-*/
-
-#define PRECL 32
-
-long double
-hypotl (long double x, long double y)
-{
-  int exx;
-  int eyy;
-  int  scale;
-  long double xx =fabsl(x);
-  long double yy =fabsl(y);
-  if (!isfinite(xx) || !isfinite(yy))
-    {
-      /* Annex F.9.4.3, hypot returns +infinity if
-         either component is an infinity, even when the
-         other component is NaN.  */
-      return (isinf(xx) || isinf(yy)) ? INFINITY : NAN;
-    }
-
-  if (xx == 0.0L)
-     return yy;
-  if (yy == 0.0L)
-     return xx;
-
-  /* Get exponents */
-  exx =  logbl (xx);
-  eyy =  logbl (yy);
-
-  /* Check if large differences in scale */
-  scale = exx - eyy;
-  if ( scale > PRECL)
-     return xx;
-  if ( scale < -PRECL)
-     return yy;
-
-  /* Exponent of approximate geometric mean (x 2) */
-  scale = (exx + eyy) >> 1;
-
-  /*  Rescale: Geometric mean is now about 2 */  
-  x = scalbnl(xx, -scale);
-  y = scalbnl(yy, -scale);
-
-  xx = sqrtl(x * x  + y * y);
-
-  /* Check for overflow and underflow */
-  exx = logbl(xx);   
-  exx += scale;
-    if (exx > LDBL_MAX_EXP)
-    {
-      errno = ERANGE; 
-      return INFINITY;
-    }
-  if (exx < LDBL_MIN_EXP)
-    return 0.0L;
-
-  /* Undo scaling */
-  return (scalbnl (xx, scale));
-}
diff --git a/lib/libc/musl/src/math/hypotf.c b/lib/libc/musl/src/math/hypotf.c
deleted file mode 100644
index 2fc214b7232e09ab52d5f8b5bb1b10f024b9b8d3..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/hypotf.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <math.h>
-#include <stdint.h>
-
-float hypotf(float x, float y)
-{
-	union {float f; uint32_t i;} ux = {x}, uy = {y}, ut;
-	float_t z;
-
-	ux.i &= -1U>>1;
-	uy.i &= -1U>>1;
-	if (ux.i < uy.i) {
-		ut = ux;
-		ux = uy;
-		uy = ut;
-	}
-
-	x = ux.f;
-	y = uy.f;
-	if (uy.i == 0xff<<23)
-		return y;
-	if (ux.i >= 0xff<<23 || uy.i == 0 || ux.i - uy.i >= 25<<23)
-		return x + y;
-
-	z = 1;
-	if (ux.i >= (0x7f+60)<<23) {
-		z = 0x1p90f;
-		x *= 0x1p-90f;
-		y *= 0x1p-90f;
-	} else if (uy.i < (0x7f-60)<<23) {
-		z = 0x1p-90f;
-		x *= 0x1p90f;
-		y *= 0x1p90f;
-	}
-	return z*sqrtf((double)x*x + (double)y*y);
-}
diff --git a/lib/libc/musl/src/math/hypotl.c b/lib/libc/musl/src/math/hypotl.c
deleted file mode 100644
index 479aa92c3dc29b235c8f6200863f73d22cd1fcef..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/hypotl.c
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "libm.h"
-
-#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double hypotl(long double x, long double y)
-{
-	return hypot(x, y);
-}
-#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-#if LDBL_MANT_DIG == 64
-#define SPLIT (0x1p32L+1)
-#elif LDBL_MANT_DIG == 113
-#define SPLIT (0x1p57L+1)
-#endif
-
-static void sq(long double *hi, long double *lo, long double x)
-{
-	long double xh, xl, xc;
-	xc = x*SPLIT;
-	xh = x - xc + xc;
-	xl = x - xh;
-	*hi = x*x;
-	*lo = xh*xh - *hi + 2*xh*xl + xl*xl;
-}
-
-long double hypotl(long double x, long double y)
-{
-	union ldshape ux = {x}, uy = {y};
-	int ex, ey;
-	long double hx, lx, hy, ly, z;
-
-	ux.i.se &= 0x7fff;
-	uy.i.se &= 0x7fff;
-	if (ux.i.se < uy.i.se) {
-		ex = uy.i.se;
-		ey = ux.i.se;
-		x = uy.f;
-		y = ux.f;
-	} else {
-		ex = ux.i.se;
-		ey = uy.i.se;
-		x = ux.f;
-		y = uy.f;
-	}
-
-	if (ex == 0x7fff && isinf(y))
-		return y;
-	if (ex == 0x7fff || y == 0)
-		return x;
-	if (ex - ey > LDBL_MANT_DIG)
-		return x + y;
-
-	z = 1;
-	if (ex > 0x3fff+8000) {
-		z = 0x1p10000L;
-		x *= 0x1p-10000L;
-		y *= 0x1p-10000L;
-	} else if (ey < 0x3fff-8000) {
-		z = 0x1p-10000L;
-		x *= 0x1p10000L;
-		y *= 0x1p10000L;
-	}
-	sq(&hx, &lx, x);
-	sq(&hy, &ly, y);
-	return z*sqrtl(ly+lx+hy+hx);
-}
-#endif
diff --git a/lib/libc/musl/src/math/i386/hypotf.s b/lib/libc/musl/src/math/i386/hypotf.s
deleted file mode 100644
index 068935e2d3466e714d53de737daed042a28c8827..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/hypotf.s
+++ /dev/null
@@ -1,42 +0,0 @@
-.global hypotf
-.type hypotf,@function
-hypotf:
-	mov 4(%esp),%eax
-	mov 8(%esp),%ecx
-	add %eax,%eax
-	add %ecx,%ecx
-	and %eax,%ecx
-	cmp $0xff000000,%ecx
-	jae 2f
-	test %eax,%eax
-	jnz 1f
-	flds 8(%esp)
-	fabs
-	ret
-1:	mov 8(%esp),%eax
-	add %eax,%eax
-	jnz 1f
-	flds 4(%esp)
-	fabs
-	ret
-1:	flds 4(%esp)
-	fld %st(0)
-	fmulp
-	flds 8(%esp)
-	fld %st(0)
-	fmulp
-	faddp
-	fsqrt
-	ret
-2:	cmp $0xff000000,%eax
-	jnz 1f
-	flds 4(%esp)
-	fabs
-	ret
-1:	mov 8(%esp),%eax
-	add %eax,%eax
-	cmp $0xff000000,%eax
-	flds 8(%esp)
-	jnz 1f
-	fabs
-1:	ret
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index a863f56913530548a5a83df8877d6a1db2467b2b..0be2b7c0a8c4a13faaac25ad2b3d654d8bd23d1e 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -615,8 +615,6 @@ const mingw32_generic_src = [_][]const u8{
     "math" ++ path.sep_str ++ "fpclassifyl.c",
     "math" ++ path.sep_str ++ "frexpf.c",
     "math" ++ path.sep_str ++ "frexpl.c",
-    "math" ++ path.sep_str ++ "hypotf.c",
-    "math" ++ path.sep_str ++ "hypotl.c",
     "math" ++ path.sep_str ++ "ldexpf.c",
     "math" ++ path.sep_str ++ "lgamma.c",
     "math" ++ path.sep_str ++ "lgammaf.c",
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 8fd59eb36f7253676408b7a93b91c218b85aef7e..d0c87ada315066e3ee8997466fa8506bd41f57c4 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -874,8 +874,6 @@ const src_files = [_][]const u8{
     "musl/src/math/frexp.c",
     "musl/src/math/frexpf.c",
     "musl/src/math/frexpl.c",
-    "musl/src/math/hypotf.c",
-    "musl/src/math/hypotl.c",
     "musl/src/math/i386/acosf.s",
     "musl/src/math/i386/acosl.s",
     "musl/src/math/i386/asinf.s",
@@ -888,7 +886,6 @@ const src_files = [_][]const u8{
     "musl/src/math/i386/exp_ld.s",
     "musl/src/math/i386/expl.s",
     "musl/src/math/i386/expm1l.s",
-    "musl/src/math/i386/hypotf.s",
     "musl/src/math/i386/__invtrigl.s",
     "musl/src/math/i386/ldexpf.s",
     "musl/src/math/i386/ldexpl.s",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 350a4184bfef6351a934e6efdb17b7aebed21f0f..1ca5ba3e70018d296e3c47c4bd0bc64ec2490615 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -730,8 +730,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/frexp.c",
     "musl/src/math/frexpf.c",
     "musl/src/math/frexpl.c",
-    "musl/src/math/hypotf.c",
-    "musl/src/math/hypotl.c",
     "musl/src/math/ilogb.c",
     "musl/src/math/ilogbf.c",
     "musl/src/math/ilogbl.c",
-- 
2.54.0


From 2961cf1dac78df07ba14bfee1d3dc1ef94a778c5 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Thu, 8 Jan 2026 10:30:08 -0500
Subject: [PATCH 238/499] tracy: update API

---
 build.zig     |  4 +---
 src/tracy.zig | 58 +++++++++++++++++++++++++--------------------------
 2 files changed, 29 insertions(+), 33 deletions(-)

diff --git a/build.zig b/build.zig
index c9dd27fe0326b64f2acf9b53e8ad427c756cb9cb..ed16d78dadb45462e4c9216d7bd79077f32ed46c 100644
--- a/build.zig
+++ b/build.zig
@@ -371,10 +371,8 @@ pub fn build(b: *std.Build) !void {
 
         exe.root_module.addIncludePath(.{ .cwd_relative = tracy_path });
         exe.root_module.addCSourceFile(.{ .file = .{ .cwd_relative = client_cpp }, .flags = tracy_c_flags });
-        if (!enable_llvm) {
-            exe.root_module.linkSystemLibrary("c++", .{ .use_pkg_config = .no });
-        }
         exe.root_module.link_libc = true;
+        exe.root_module.link_libcpp = true;
 
         if (target.result.os.tag == .windows) {
             exe.root_module.linkSystemLibrary("dbghelp", .{});
diff --git a/src/tracy.zig b/src/tracy.zig
index 50d1b2e1a70cc7cc82845665affb197a28bc33d3..1a106d22d6dc9a9210603ce01401a848e1246f72 100644
--- a/src/tracy.zig
+++ b/src/tracy.zig
@@ -9,7 +9,7 @@ pub const callstack_depth = if (enable_callstack and build_options.tracy_callsta
 
 const ___tracy_c_zone_context = extern struct {
     id: u32,
-    active: c_int,
+    active: i32,
 
     pub inline fn end(self: @This()) void {
         ___tracy_emit_zone_end(self);
@@ -197,24 +197,22 @@ pub fn TracyAllocator(comptime name: ?[:0]const u8) type {
 
 // This function only accepts comptime-known strings, see `messageCopy` for runtime strings
 pub inline fn message(comptime msg: [:0]const u8) void {
-    if (!enable) return;
-    ___tracy_emit_messageL(msg.ptr, if (enable_callstack) callstack_depth else 0);
+    messageColor(msg, 0);
 }
 
 // This function only accepts comptime-known strings, see `messageColorCopy` for runtime strings
-pub inline fn messageColor(comptime msg: [:0]const u8, color: u32) void {
+pub inline fn messageColor(comptime msg: [:0]const u8, color: u24) void {
     if (!enable) return;
-    ___tracy_emit_messageLC(msg.ptr, color, if (enable_callstack) callstack_depth else 0);
+    ___tracy_emit_logStringL(.Info, color, if (enable_callstack) callstack_depth else 0, msg.ptr);
 }
 
 pub inline fn messageCopy(msg: []const u8) void {
-    if (!enable) return;
-    ___tracy_emit_message(msg.ptr, msg.len, if (enable_callstack) callstack_depth else 0);
+    messageColorCopy(msg, 0);
 }
 
-pub inline fn messageColorCopy(msg: [:0]const u8, color: u32) void {
+pub inline fn messageColorCopy(msg: []const u8, color: u24) void {
     if (!enable) return;
-    ___tracy_emit_messageC(msg.ptr, msg.len, color, if (enable_callstack) callstack_depth else 0);
+    ___tracy_emit_logString(.Info, color, if (enable_callstack) callstack_depth else 0, msg.len, msg.ptr);
 }
 
 pub inline fn frameMark() void {
@@ -293,32 +291,32 @@ inline fn freeNamed(ptr: [*]u8, comptime name: [:0]const u8) void {
     }
 }
 
-extern fn ___tracy_emit_zone_begin(
-    srcloc: *const ___tracy_source_location_data,
-    active: c_int,
-) ___tracy_c_zone_context;
-extern fn ___tracy_emit_zone_begin_callstack(
-    srcloc: *const ___tracy_source_location_data,
-    depth: c_int,
-    active: c_int,
-) ___tracy_c_zone_context;
+pub const MessageSeverity = enum(i8) {
+    Trace, // Broadly track variable states and events in the software program.
+    Debug, // Describes variable states and details about specific internal events in the software, that are useful for investigations.
+    Info, // Describes normal events, which inform on the expected progress and state of your software.
+    Warning, // Describes potentially dangerous situations caused by unexpected events and states.
+    Error, // Describes the occurance of unexpected behavior. Does not interrupt the execution of the software.
+    Fatal, // Describes a critical event that will lead to a software failure/crash.
+};
+
+extern fn ___tracy_emit_zone_begin(srcloc: *const ___tracy_source_location_data, active: i32) ___tracy_c_zone_context;
+extern fn ___tracy_emit_zone_begin_callstack(srcloc: *const ___tracy_source_location_data, depth: i32, active: i32) ___tracy_c_zone_context;
 extern fn ___tracy_emit_zone_text(ctx: ___tracy_c_zone_context, txt: [*]const u8, size: usize) void;
 extern fn ___tracy_emit_zone_name(ctx: ___tracy_c_zone_context, txt: [*]const u8, size: usize) void;
 extern fn ___tracy_emit_zone_color(ctx: ___tracy_c_zone_context, color: u32) void;
 extern fn ___tracy_emit_zone_value(ctx: ___tracy_c_zone_context, value: u64) void;
 extern fn ___tracy_emit_zone_end(ctx: ___tracy_c_zone_context) void;
-extern fn ___tracy_emit_memory_alloc(ptr: *const anyopaque, size: usize, secure: c_int) void;
-extern fn ___tracy_emit_memory_alloc_callstack(ptr: *const anyopaque, size: usize, depth: c_int, secure: c_int) void;
-extern fn ___tracy_emit_memory_free(ptr: *const anyopaque, secure: c_int) void;
-extern fn ___tracy_emit_memory_free_callstack(ptr: *const anyopaque, depth: c_int, secure: c_int) void;
-extern fn ___tracy_emit_memory_alloc_named(ptr: *const anyopaque, size: usize, secure: c_int, name: [*:0]const u8) void;
-extern fn ___tracy_emit_memory_alloc_callstack_named(ptr: *const anyopaque, size: usize, depth: c_int, secure: c_int, name: [*:0]const u8) void;
-extern fn ___tracy_emit_memory_free_named(ptr: *const anyopaque, secure: c_int, name: [*:0]const u8) void;
-extern fn ___tracy_emit_memory_free_callstack_named(ptr: *const anyopaque, depth: c_int, secure: c_int, name: [*:0]const u8) void;
-extern fn ___tracy_emit_message(txt: [*]const u8, size: usize, callstack: c_int) void;
-extern fn ___tracy_emit_messageL(txt: [*:0]const u8, callstack: c_int) void;
-extern fn ___tracy_emit_messageC(txt: [*]const u8, size: usize, color: u32, callstack: c_int) void;
-extern fn ___tracy_emit_messageLC(txt: [*:0]const u8, color: u32, callstack: c_int) void;
+extern fn ___tracy_emit_memory_alloc(ptr: *const anyopaque, size: usize, secure: i32) void;
+extern fn ___tracy_emit_memory_alloc_callstack(ptr: *const anyopaque, size: usize, depth: i32, secure: i32) void;
+extern fn ___tracy_emit_memory_free(ptr: *const anyopaque, secure: i32) void;
+extern fn ___tracy_emit_memory_free_callstack(ptr: *const anyopaque, depth: i32, secure: i32) void;
+extern fn ___tracy_emit_memory_alloc_named(ptr: *const anyopaque, size: usize, secure: i32, name: [*:0]const u8) void;
+extern fn ___tracy_emit_memory_alloc_callstack_named(ptr: *const anyopaque, size: usize, depth: i32, secure: i32, name: [*:0]const u8) void;
+extern fn ___tracy_emit_memory_free_named(ptr: *const anyopaque, secure: i32, name: [*:0]const u8) void;
+extern fn ___tracy_emit_memory_free_callstack_named(ptr: *const anyopaque, depth: i32, secure: i32, name: [*:0]const u8) void;
+extern fn ___tracy_emit_logString(severity: MessageSeverity, color: i32, callstack_depth: i32, size: usize, txt: [*]const u8) void;
+extern fn ___tracy_emit_logStringL(severity: MessageSeverity, color: i32, callstack_depth: i32, txt: [*:0]const u8) void;
 extern fn ___tracy_emit_frame_mark(name: ?[*:0]const u8) void;
 
 const ___tracy_source_location_data = extern struct {
-- 
2.54.0


From b48599c5492448241a5c37cf17ff6caffa3dd302 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Thu, 8 Jan 2026 10:31:07 -0500
Subject: [PATCH 239/499] Sema: fix crash compiling an evented compiler

---
 src/Sema.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Sema.zig b/src/Sema.zig
index 87dd6a83bbc9fed4e1533a20499793f10024cdcf..58fa1af124239ff05093bc9cf857a16f36de09e4 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -23090,6 +23090,7 @@ fn checkAtomicPtrOperand(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    try elem_ty.resolveLayout(pt);
     var diag: Zcu.AtomicPtrAlignmentDiagnostics = .{};
     const alignment = zcu.atomicPtrAlignment(elem_ty, &diag) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-- 
2.54.0


From a28d57292f86dfdacf88453509d0b7a1a49443eb Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Tue, 6 Jan 2026 05:10:33 -0500
Subject: [PATCH 240/499] IoUring: update to new Io APIs

---
 bootstrap.c             |    1 +
 build.zig               |    4 +
 lib/std/Io.zig          |   61 +-
 lib/std/Io/File.zig     |    9 +-
 lib/std/Io/IoUring.zig  | 6152 ++++++++++++++++++++++++++++++++++-----
 lib/std/Io/Threaded.zig |  450 ++-
 lib/std/os/linux.zig    |    9 +-
 lib/std/process.zig     |    6 +-
 lib/std/tar.zig         |    8 +-
 src/Compilation.zig     |   46 +-
 src/InternPool.zig      |   13 +-
 src/Zcu.zig             |   12 +-
 src/Zcu/PerThread.zig   |   77 +-
 src/crash_report.zig    |   47 +-
 src/introspect.zig      |    6 +-
 src/link.zig            |    8 +-
 src/link/Queue.zig      |   12 +-
 src/main.zig            |  142 +-
 stage1/config.zig.in    |    1 +
 19 files changed, 5883 insertions(+), 1181 deletions(-)

diff --git a/bootstrap.c b/bootstrap.c
index 1f17fc8455532ae947964db60d0f8fbfe5124a7f..44ba0714764a387eff427c118e4a66c8bcfb3a69 100644
--- a/bootstrap.c
+++ b/bootstrap.c
@@ -143,6 +143,7 @@ int main(int argc, char **argv) {
             "pub const skip_non_native = false;\n"
             "pub const debug_gpa = false;\n"
             "pub const dev = .core;\n"
+            "pub const io_mode: enum { threaded, evented } = .threaded;\n"
             "pub const value_interpret_mode = .direct;\n"
         , zig_version);
         if (written < 100)
diff --git a/build.zig b/build.zig
index ed16d78dadb45462e4c9216d7bd79077f32ed46c..1ec1fa9caf7f8fc2af988ccc0ea733d388f3c0cc 100644
--- a/build.zig
+++ b/build.zig
@@ -13,6 +13,7 @@ const DevEnv = @import("src/dev.zig").Env;
 const zig_version: std.SemanticVersion = .{ .major = 0, .minor = 16, .patch = 0 };
 const stack_size = 46 * 1024 * 1024;
 
+const IoMode = enum { threaded, evented };
 const ValueInterpretMode = enum { direct, by_name };
 
 pub fn build(b: *std.Build) !void {
@@ -188,6 +189,7 @@ pub fn build(b: *std.Build) !void {
     const strip = b.option(bool, "strip", "Omit debug information");
     const valgrind = b.option(bool, "valgrind", "Enable valgrind integration");
     const pie = b.option(bool, "pie", "Produce a Position Independent Executable");
+    const io_mode = b.option(IoMode, "io-mode", "How the compiler performs IO") orelse .threaded;
     const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.builtin' types and its internal datastructures") orelse .direct;
     const value_tracing = b.option(bool, "value-tracing", "Enable extra state tracking to help troubleshoot bugs in the compiler (using the std.debug.Trace API)") orelse false;
 
@@ -236,6 +238,7 @@ pub fn build(b: *std.Build) !void {
     exe_options.addOption(bool, "llvm_has_xtensa", llvm_has_xtensa);
     exe_options.addOption(bool, "debug_gpa", debug_gpa);
     exe_options.addOption(DevEnv, "dev", b.option(DevEnv, "dev", "Build a compiler with a reduced feature set for development of specific features") orelse if (only_c) .bootstrap else .full);
+    exe_options.addOption(IoMode, "io_mode", io_mode);
     exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode);
 
     if (link_libc) {
@@ -710,6 +713,7 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
     exe_options.addOption(u32, "tracy_callstack_depth", 0);
     exe_options.addOption(bool, "value_tracing", false);
     exe_options.addOption(DevEnv, "dev", .bootstrap);
+    exe_options.addOption(IoMode, "io_mode", .threaded);
 
     // zig1 chooses to interpret values by name. The tradeoff is as follows:
     //
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index c56ec6886683d707fc5f14db62e9dc7468159430..b22345ed94a96eb31dff8a2b29d8a2cb21247759 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -378,7 +378,9 @@ pub const Operation = union(enum) {
         pub const Pending = struct {
             node: List.DoubleNode,
             tag: Tag,
-            context: [3]usize,
+            context: Context align(@max(@alignOf(usize), 4)),
+
+            pub const Context = [3]usize;
         };
 
         pub const Completion = struct {
@@ -426,10 +428,10 @@ pub fn operate(io: Io, operation: Operation) Cancelable!Operation.Result {
 pub const Batch = struct {
     storage: []Operation.Storage,
     unused: Operation.List,
-    submissions: Operation.List,
+    submitted: Operation.List,
     pending: Operation.List,
-    completions: Operation.List,
-    context: ?*anyopaque,
+    completed: Operation.List,
+    context: ?*anyopaque align(@max(@alignOf(?*anyopaque), 4)),
 
     /// After calling this, it is safe to unconditionally defer a call to
     /// `cancel`. `storage` is a pre-allocated buffer of undefined memory that
@@ -448,9 +450,9 @@ pub const Batch = struct {
                 .head = .fromIndex(0),
                 .tail = .fromIndex(storage.len - 1),
             },
-            .submissions = .empty,
+            .submitted = .empty,
             .pending = .empty,
-            .completions = .empty,
+            .completed = .empty,
             .context = null,
         };
     }
@@ -471,20 +473,20 @@ pub const Batch = struct {
         const storage = &b.storage[index];
         const unused = storage.unused;
         switch (unused.prev) {
-            .none => b.unused.head = .none,
+            .none => b.unused.head = unused.next,
             else => |prev_index| b.storage[prev_index.toIndex()].unused.next = unused.next,
         }
         switch (unused.next) {
-            .none => b.unused.tail = .none,
+            .none => b.unused.tail = unused.prev,
             else => |next_index| b.storage[next_index.toIndex()].unused.prev = unused.prev,
         }
 
-        switch (b.submissions.tail) {
-            .none => b.submissions.head = .fromIndex(index),
+        switch (b.submitted.tail) {
+            .none => b.submitted.head = .fromIndex(index),
             else => |tail_index| b.storage[tail_index.toIndex()].submission.node.next = .fromIndex(index),
         }
         storage.* = .{ .submission = .{ .node = .{ .next = .none }, .operation = operation } };
-        b.submissions.tail = .fromIndex(index);
+        b.submitted.tail = .fromIndex(index);
     }
 
     pub const Completion = struct {
@@ -501,13 +503,13 @@ pub const Batch = struct {
     /// Each completion returned from this function dequeues from the `Batch`.
     /// It is not required to dequeue all completions before awaiting again.
     pub fn next(b: *Batch) ?Completion {
-        const index = b.completions.head;
+        const index = b.completed.head;
         if (index == .none) return null;
         const storage = &b.storage[index.toIndex()];
         const completion = storage.completion;
         const next_index = completion.node.next;
-        b.completions.head = next_index;
-        if (next_index == .none) b.completions.tail = .none;
+        b.completed.head = next_index;
+        if (next_index == .none) b.completed.tail = .none;
 
         const tail_index = b.unused.tail;
         switch (tail_index) {
@@ -551,7 +553,27 @@ pub const Batch = struct {
     /// may have successfully completed regardless of the cancel request and
     /// will appear in the iteration.
     pub fn cancel(b: *Batch, io: Io) void {
-        return io.vtable.batchCancel(io.userdata, b);
+        { // abort pending submissions
+            var tail_index = b.unused.tail;
+            defer b.unused.tail = tail_index;
+            var index = b.submitted.head;
+            errdefer b.submissions.head = index;
+            while (index != .none) {
+                const next_index = b.storage[index.toIndex()].submission.node.next;
+                switch (tail_index) {
+                    .none => b.unused.head = index,
+                    else => b.storage[tail_index.toIndex()].unused.next = index,
+                }
+                b.storage[index.toIndex()] = .{ .unused = .{ .prev = tail_index, .next = .none } };
+                tail_index = index;
+                index = next_index;
+            }
+            b.submitted = .{ .head = .none, .tail = .none };
+        }
+        io.vtable.batchCancel(io.userdata, b);
+        assert(b.submitted.head == .none and b.submitted.tail == .none);
+        assert(b.pending.head == .none and b.pending.tail == .none);
+        assert(b.context == null); // that was the last chance to deallocate resources
     }
 };
 
@@ -1117,13 +1139,13 @@ pub fn recancel(io: Io) void {
 /// To modify a task's cancel protection state, see `swapCancelProtection`.
 ///
 /// For a description of cancelation and cancelation points, see `Future.cancel`.
-pub const CancelProtection = enum {
+pub const CancelProtection = enum(u1) {
     /// Any call to an `Io` function with `error.Canceled` in its error set is a cancelation point.
     ///
     /// This is the default state, which all tasks are created in.
-    unblocked,
+    unblocked = 0,
     /// No `Io` function introduces a cancelation point (`error.Canceled` will never be returned).
-    blocked,
+    blocked = 1,
 };
 /// Updates the current task's cancel protection state (see `CancelProtection`).
 ///
@@ -1292,8 +1314,7 @@ pub fn futexWake(io: Io, comptime T: type, ptr: *align(@alignOf(u32)) const T, m
 /// shared region of code known as the "critical section".
 ///
 /// Mutex is an extern struct so that it may be used as a field inside another
-/// extern struct. Having a guaranteed memory layout including mutexes is
-/// important for IPC over shared memory (mmap).
+/// extern struct.
 pub const Mutex = extern struct {
     state: std.atomic.Value(State),
 
diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig
index ba7f5d01e051c25436bbbe11f06951aae89b314c..07f4285ceff04f7acc16bc00b07e816656ba6e44 100644
--- a/lib/std/Io/File.zig
+++ b/lib/std/Io/File.zig
@@ -477,12 +477,17 @@ pub const Permissions = std.Options.FilePermissions orelse if (is_windows) enum(
     /// libc implementations use `0o666` inside `fopen` and then rely on the
     /// process-scoped "umask" setting to adjust this number for file creation.
     default_file = 0o666,
-    default_dir = 0o755,
-    executable_file = 0o777,
+    /// This is the default mode given to POSIX operating systems for creating
+    /// directories. `0o777` is "-rwxrwxrwx" which is counter-intuitive at first,
+    /// since most people would expect "-rwxr-xr-x", for example, when using
+    /// the `touch` command, which would correspond to `0o755`.
+    default_dir = 0o777,
     _,
 
     pub const has_executable_bit = native_os != .wasi;
 
+    pub const executable_file: @This() = .default_dir;
+
     pub fn toMode(self: @This()) std.posix.mode_t {
         return @intFromEnum(self);
     }
diff --git a/lib/std/Io/IoUring.zig b/lib/std/Io/IoUring.zig
index 8ff3ae22ef230ab9a503c6d9867347e961c65008..f853aaa08f20a2df3fb8f1b623f68d92300a062d 100644
--- a/lib/std/Io/IoUring.zig
+++ b/lib/std/Io/IoUring.zig
@@ -1,21 +1,80 @@
-const EventLoop = @This();
+const addressFromPosix = Io.Threaded.addressFromPosix;
+const addressToPosix = Io.Threaded.addressToPosix;
+const Alignment = std.mem.Alignment;
+const Allocator = std.mem.Allocator;
+const Argv0 = Io.Threaded.Argv0;
+const assert = std.debug.assert;
 const builtin = @import("builtin");
-
-const std = @import("../std.zig");
+const ChdirError = Io.Threaded.ChdirError;
+const clockToPosix = Io.Threaded.clockToPosix;
+const Csprng = Io.Threaded.Csprng;
+const default_PATH = Io.Threaded.default_PATH;
+const Dir = Io.Dir;
+const Environ = Io.Threaded.Environ;
+const errnoBug = Io.Threaded.errnoBug;
+const Evented = @This();
+const fallbackSeed = Io.Threaded.fallbackSeed;
+const fd_t = linux.fd_t;
+const File = Io.File;
 const Io = std.Io;
-const assert = std.debug.assert;
-const Allocator = std.mem.Allocator;
-const Alignment = std.mem.Alignment;
-const IoUring = std.os.linux.IoUring;
+const IoUring = linux.IoUring;
+const iovec = std.posix.iovec;
+const iovec_const = std.posix.iovec_const;
+const linux = std.os.linux;
+const linux_statx_request = Io.Threaded.linux_statx_request;
+const LOCK = std.posix.LOCK;
+const log = std.log.scoped(.@"io-uring");
+const max_iovecs_len = Io.Threaded.max_iovecs_len;
+const nanosecondsFromPosix = Io.Threaded.nanosecondsFromPosix;
+const net = Io.net;
+const PATH_MAX = linux.PATH_MAX;
+const pathToPosix = Io.Threaded.pathToPosix;
+const pid_t = linux.pid_t;
+const PosixAddress = Io.Threaded.PosixAddress;
+const posixAddressFamily = Io.Threaded.posixAddressFamily;
+const posixProtocol = Io.Threaded.posixProtocol;
+const posixSocketMode = Io.Threaded.posixSocketMode;
+const process = std.process;
+const recoverableOsBugDetected = Io.Threaded.recoverableOsBugDetected;
+const setTimestampToPosix = Io.Threaded.setTimestampToPosix;
+const splat_buffer_size = Io.Threaded.splat_buffer_size;
+const statFromLinux = Io.Threaded.statFromLinux;
+const std = @import("../std.zig");
+const timestampFromPosix = Io.Threaded.timestampFromPosix;
+const unexpectedErrno = std.posix.unexpectedErrno;
+const winsize = std.posix.winsize;
 
-/// Must be a thread-safe allocator.
-gpa: Allocator,
-mutex: Io.Mutex,
-main_fiber_buffer: [@sizeOf(Fiber) + Fiber.max_result_size]u8 align(@alignOf(Fiber)),
+backing_allocator_needs_mutex: bool,
+backing_allocator_mutex: Io.Mutex,
+/// Does not need to be thread-safe if not used elsewhere.
+backing_allocator: Allocator,
+main_fiber_buffer: [
+    std.mem.alignForward(usize, @sizeOf(Fiber), @alignOf(Completion)) + @sizeOf(Completion)
+]u8 align(@max(@alignOf(Fiber), @alignOf(Completion))),
 threads: Thread.List,
 
+stderr_mutex: Io.Mutex,
+stderr_writer: File.Writer = .{
+    .io = undefined,
+    .interface = Io.File.Writer.initInterface(&.{}),
+    .file = .stderr(),
+    .mode = .streaming,
+},
+stderr_mode: Io.Terminal.Mode = .no_color,
+stderr_writer_initialized: bool = false,
+
+environ_mutex: Io.Mutex,
+environ: Environ,
+
+null_fd: CachedFd,
+random_fd: CachedFd,
+
+csprng_mutex: Io.Mutex,
+csprng: Csprng,
+
 /// Empirically saw >128KB being used by the self-hosted backend to panic.
-const idle_stack_size = 256 * 1024;
+/// Empirically saw glibc complain about 256KB.
+const idle_stack_size = 512 * 1024;
 
 const max_idle_search = 4;
 const max_steal_ready_search = 4;
@@ -23,6 +82,7 @@ const max_steal_ready_search = 4;
 const io_uring_entries = 64;
 
 const Thread = struct {
+    required_align: void align(4),
     thread: std.Thread,
     idle_context: Context,
     current_context: *Context,
@@ -30,19 +90,33 @@ const Thread = struct {
     io_uring: IoUring,
     idle_search_index: u32,
     steal_ready_search_index: u32,
+    csprng: Csprng,
 
-    const canceling: ?*Thread = @ptrFromInt(@alignOf(Thread));
+    threadlocal var self: ?*Thread = null;
 
-    threadlocal var self: *Thread = undefined;
-
-    fn current() *Thread {
-        return self;
+    noinline fn current() *Thread {
+        return self.?;
     }
 
     fn currentFiber(thread: *Thread) *Fiber {
+        assert(thread.current_context != &thread.idle_context);
         return @fieldParentPtr("context", thread.current_context);
     }
 
+    fn enqueue(thread: *Thread) *linux.io_uring_sqe {
+        while (true) return thread.io_uring.get_sqe() catch {
+            thread.submit();
+            continue;
+        };
+    }
+
+    fn submit(thread: *Thread) void {
+        _ = thread.io_uring.submit() catch |err| switch (err) {
+            error.SignalInterrupt => {},
+            else => |e| @panic(@errorName(e)),
+        };
+    }
+
     const List = struct {
         allocated: []Thread,
         reserved: u32,
@@ -53,18 +127,109 @@ const Thread = struct {
 const Fiber = struct {
     required_align: void align(4),
     context: Context,
-    awaiter: ?*Fiber,
-    queue_next: ?*Fiber,
-    cancel_thread: ?*Thread,
-    awaiting_completions: std.StaticBitSet(3),
+    await_count: i32,
+    link: union {
+        awaiter: ?*Fiber,
+        group: struct { prev: ?*Fiber, next: ?*Fiber },
+    },
+    status: union(enum) {
+        queue_next: ?*Fiber,
+        awaiting_group: Group,
+    },
+    cancel_status: CancelStatus,
+    cancel_protection: CancelProtection,
+
+    const CancelStatus = packed struct(u32) {
+        requested: bool,
+        awaiting: Awaiting,
+
+        const unrequested: CancelStatus = .{ .requested = false, .awaiting = .nothing };
+
+        const Awaiting = enum(u31) {
+            nothing = std.math.maxInt(u31),
+            group = std.math.maxInt(u31) - 1,
+            select = std.math.maxInt(u31) - 2,
+            /// An io_uring fd.
+            _,
+
+            fn subWrap(lhs: Awaiting, rhs: Awaiting) Awaiting {
+                return @enumFromInt(@intFromEnum(lhs) -% @intFromEnum(rhs));
+            }
+
+            fn fromIoUringFd(fd: fd_t) Awaiting {
+                const awaiting: Awaiting = @enumFromInt(fd);
+                switch (awaiting) {
+                    .nothing, .group, .select => unreachable,
+                    _ => return awaiting,
+                }
+            }
+
+            fn toIoUringFd(awaiting: Awaiting) fd_t {
+                switch (awaiting) {
+                    .nothing, .group => unreachable,
+                    _ => return @intFromEnum(awaiting),
+                }
+            }
+        };
+
+        fn changeAwaiting(
+            cancel_status: *CancelStatus,
+            old_awaiting: Awaiting,
+            new_awaiting: Awaiting,
+        ) bool {
+            const old_cancel_status = @atomicRmw(CancelStatus, cancel_status, .Add, .{
+                .requested = false,
+                .awaiting = new_awaiting.subWrap(old_awaiting),
+            }, .monotonic);
+            assert(old_cancel_status.awaiting == old_awaiting);
+            return old_cancel_status.requested;
+        }
+    };
+
+    const CancelProtection = packed struct {
+        user: Io.CancelProtection,
+        acknowledged: bool,
+
+        const unblocked: CancelProtection = .{ .user = .unblocked, .acknowledged = false };
+
+        fn check(cancel_protection: CancelProtection) Io.CancelProtection {
+            return @enumFromInt(@intFromBool(cancel_protection != unblocked));
+        }
+
+        fn acknowledge(cancel_protection: *CancelProtection) void {
+            assert(!cancel_protection.acknowledged);
+            cancel_protection.acknowledged = true;
+        }
+
+        fn recancel(cancel_protection: *CancelProtection) void {
+            assert(cancel_protection.acknowledged);
+            cancel_protection.acknowledged = false;
+        }
+
+        test check {
+            try std.testing.expectEqual(Io.CancelProtection.unblocked, check(.unblocked));
+            try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
+                .user = .unblocked,
+                .acknowledged = true,
+            }));
+            try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
+                .user = .blocked,
+                .acknowledged = false,
+            }));
+            try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
+                .user = .blocked,
+                .acknowledged = true,
+            }));
+        }
+    };
 
     const finished: ?*Fiber = @ptrFromInt(@alignOf(Thread));
 
     const max_result_align: Alignment = .@"16";
-    const max_result_size = max_result_align.forward(64);
+    const max_result_size = max_result_align.forward(512);
     /// This includes any stack realignments that need to happen, and also the
     /// initial frame return address slot and argument frame, depending on target.
-    const min_stack_size = 4 * 1024 * 1024;
+    const min_stack_size = 60 * 1024 * 1024;
     const max_context_align: Alignment = .@"16";
     const max_context_size = max_context_align.forward(1024);
     const max_closure_size: usize = @sizeOf(AsyncClosure);
@@ -76,9 +241,19 @@ const Fiber = struct {
         ) + max_closure_size + max_context_size,
         std.heap.page_size_max,
     );
+    comptime {
+        assert(max_result_align.compare(.gte, .of(Completion)));
+        assert(max_result_size >= @sizeOf(Completion));
+    }
 
-    fn allocate(el: *EventLoop) error{OutOfMemory}!*Fiber {
-        return @ptrCast(try el.gpa.alignedAlloc(u8, .of(Fiber), allocation_size));
+    fn create(ev: *Evented) error{OutOfMemory}!*Fiber {
+        return @ptrCast(try ev.allocator().alignedAlloc(u8, .of(Fiber), allocation_size));
+    }
+
+    fn destroy(fiber: *Fiber, gpa: std.mem.Allocator) void {
+        log.debug("destroying {*}", .{fiber});
+        assert(fiber.status.queue_next == null);
+        gpa.free(fiber.allocatedSlice());
     }
 
     fn allocatedSlice(f: *Fiber) []align(@alignOf(Fiber)) u8 {
@@ -98,98 +273,513 @@ const Fiber = struct {
         return @ptrFromInt(alignment.forward(@intFromPtr(f) + @sizeOf(Fiber)));
     }
 
-    fn enterCancelRegion(fiber: *Fiber, thread: *Thread) error{Canceled}!void {
-        if (@cmpxchgStrong(
-            ?*Thread,
-            &fiber.cancel_thread,
-            null,
-            thread,
-            .acq_rel,
-            .acquire,
-        )) |cancel_thread| {
-            assert(cancel_thread == Thread.canceling);
-            return error.Canceled;
-        }
-    }
-
-    fn exitCancelRegion(fiber: *Fiber, thread: *Thread) void {
-        if (@cmpxchgStrong(
-            ?*Thread,
-            &fiber.cancel_thread,
-            thread,
-            null,
-            .acq_rel,
-            .acquire,
-        )) |cancel_thread| assert(cancel_thread == Thread.canceling);
-    }
-
     const Queue = struct { head: *Fiber, tail: *Fiber };
+
+    /// Like a `*Fiber`, but 2 bits smaller than a pointer (because the LSBs are always 0 due to
+    /// alignment) so that those two bits can be used in a `packed struct`.
+    const PackedPtr = enum(@Int(.unsigned, @bitSizeOf(usize) - 2)) {
+        null = 0,
+        all_ones = std.math.maxInt(@Int(.unsigned, @bitSizeOf(usize) - 2)),
+        _,
+
+        const Split = packed struct(usize) { low: u2, high: PackedPtr };
+        fn pack(ptr: ?*Fiber) PackedPtr {
+            const split: Split = @bitCast(@intFromPtr(ptr));
+            assert(split.low == 0);
+            return split.high;
+        }
+        fn unpack(ptr: PackedPtr) ?*Fiber {
+            const split: Split = .{ .low = 0, .high = ptr };
+            return @ptrFromInt(@as(usize, @bitCast(split)));
+        }
+    };
+
+    fn requestCancel(fiber: *Fiber, ev: *Evented) void {
+        const cancel_status = @atomicRmw(
+            Fiber.CancelStatus,
+            &fiber.cancel_status,
+            .Or,
+            .{ .requested = true, .awaiting = @enumFromInt(0) },
+            .acq_rel,
+        );
+        assert(!cancel_status.requested);
+        switch (cancel_status.awaiting) {
+            .nothing => {},
+            .group => {
+                // The awaiter received a cancelation request while awaiting a group,
+                // so propagate the cancelation to the group.
+                if (fiber.status.awaiting_group.cancel(ev, null)) {
+                    fiber.status = .{ .queue_next = null };
+                    _ = ev.schedule(.current(), .{ .head = fiber, .tail = fiber });
+                }
+            },
+            .select => if (@atomicRmw(i32, &fiber.await_count, .Add, 1, .monotonic) == -1) {
+                _ = ev.schedule(.current(), .{ .head = fiber, .tail = fiber });
+            },
+            _ => |cancel_io_uring_fd| {
+                const thread: *Thread = .current();
+                thread.enqueue().* = if (thread.io_uring.fd == @intFromEnum(cancel_io_uring_fd)) .{
+                    .opcode = .ASYNC_CANCEL,
+                    .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+                    .ioprio = 0,
+                    .fd = 0,
+                    .off = 0,
+                    .addr = @intFromPtr(fiber),
+                    .len = 0,
+                    .rw_flags = 0,
+                    .user_data = @intFromEnum(Completion.UserData.wakeup),
+                    .buf_index = 0,
+                    .personality = 0,
+                    .splice_fd_in = 0,
+                    .addr3 = 0,
+                    .resv = 0,
+                } else .{
+                    .opcode = .MSG_RING,
+                    .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+                    .ioprio = 0,
+                    .fd = @intFromEnum(cancel_io_uring_fd),
+                    .off = @intFromPtr(fiber) | 0b01,
+                    .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA),
+                    .len = 0,
+                    .rw_flags = 0,
+                    .user_data = @intFromEnum(Completion.UserData.cleanup),
+                    .buf_index = 0,
+                    .personality = 0,
+                    .splice_fd_in = 0,
+                    .addr3 = 0,
+                    .resv = 0,
+                };
+            },
+        }
+    }
 };
 
-fn recycle(el: *EventLoop, fiber: *Fiber) void {
-    std.log.debug("recyling {*}", .{fiber});
-    assert(fiber.queue_next == null);
-    el.gpa.free(fiber.allocatedSlice());
+const CancelRegion = struct {
+    fiber: *Fiber,
+    status: Fiber.CancelStatus,
+    fn init() CancelRegion {
+        const fiber = Thread.current().currentFiber();
+        return .{
+            .fiber = fiber,
+            .status = .{
+                .requested = fiber.cancel_protection.check() == .unblocked,
+                .awaiting = .nothing,
+            },
+        };
+    }
+    fn initBlocked() CancelRegion {
+        return .{
+            .fiber = Thread.current().currentFiber(),
+            .status = .{ .requested = false, .awaiting = .nothing },
+        };
+    }
+    fn deinit(cancel_region: *CancelRegion) void {
+        if (cancel_region.status.requested) _ = cancel_region.fiber.cancel_status.changeAwaiting(
+            cancel_region.status.awaiting,
+            .nothing,
+        );
+        cancel_region.* = undefined;
+    }
+    fn await(cancel_region: *CancelRegion, awaiting: Fiber.CancelStatus.Awaiting) Io.Cancelable!void {
+        if (!cancel_region.status.requested) return;
+        const status: Fiber.CancelStatus = .{ .requested = true, .awaiting = awaiting };
+        if (cancel_region.fiber.cancel_status.changeAwaiting(
+            cancel_region.status.awaiting,
+            status.awaiting,
+        )) {
+            cancel_region.fiber.cancel_protection.acknowledge();
+            cancel_region.status = .unrequested;
+            return error.Canceled;
+        }
+        cancel_region.status = status;
+    }
+    fn awaitIoUring(cancel_region: *CancelRegion) Io.Cancelable!*Thread {
+        const thread: *Thread = .current();
+        try cancel_region.await(.fromIoUringFd(thread.io_uring.fd));
+        return thread;
+    }
+    fn completion(cancel_region: *const CancelRegion) Completion {
+        return cancel_region.fiber.resultPointer(Completion).*;
+    }
+    fn errno(cancel_region: *const CancelRegion) linux.E {
+        return cancel_region.completion().errno();
+    }
+};
+
+const CachedFd = struct {
+    once: Once,
+
+    const Once = enum(fd_t) {
+        uninitialized = -1,
+        initializing = -2,
+        /// fd
+        _,
+
+        fn fromFd(fd: fd_t) Once {
+            return @enumFromInt(@as(u31, @intCast(fd)));
+        }
+
+        fn toFd(once: Once) fd_t {
+            return @as(u31, @intCast(@intFromEnum(once)));
+        }
+    };
+
+    const init: CachedFd = .{ .once = .uninitialized };
+
+    fn close(cached_fd: *CachedFd) void {
+        switch (cached_fd.once) {
+            .uninitialized => {},
+            .initializing => unreachable,
+            _ => |fd| {
+                assert(@intFromEnum(fd) >= 0);
+                std.posix.close(@intFromEnum(fd));
+                cached_fd.* = .init;
+            },
+        }
+    }
+
+    fn open(
+        cached_fd: *CachedFd,
+        ev: *Evented,
+        cancel_region: *CancelRegion,
+        path: [*:0]const u8,
+        flags: linux.O,
+    ) File.OpenError!fd_t {
+        var once = @atomicLoad(Once, &cached_fd.once, .monotonic);
+        while (true) {
+            switch (once) {
+                .uninitialized => {},
+                .initializing => try futexWait(
+                    ev,
+                    @ptrCast(&cached_fd.once),
+                    @bitCast(@intFromEnum(once)),
+                    .none,
+                ),
+                _ => |fd| {
+                    @branchHint(.likely);
+                    return fd.toFd();
+                },
+            }
+            once = @cmpxchgWeak(
+                Once,
+                &cached_fd.once,
+                .uninitialized,
+                .initializing,
+                .monotonic,
+                .monotonic,
+            ) orelse {
+                errdefer {
+                    @atomicStore(Once, &cached_fd.once, .uninitialized, .monotonic);
+                    futexWake(ev, @ptrCast(&cached_fd.once), 1);
+                }
+                const fd = try ev.openat(cancel_region, linux.AT.FDCWD, path, flags, 0);
+                @atomicStore(Once, &cached_fd.once, .fromFd(fd), .monotonic);
+                futexWake(ev, @ptrCast(&cached_fd.once), std.math.maxInt(u32));
+                return fd;
+            };
+        }
+    }
+};
+
+pub fn allocator(ev: *Evented) std.mem.Allocator {
+    return if (ev.backing_allocator_needs_mutex) .{
+        .ptr = ev,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    } else ev.backing_allocator;
+}
+
+fn alloc(userdata: *anyopaque, len: usize, alignment: std.mem.Alignment, ret_addr: usize) ?[*]u8 {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+    ev.backing_allocator_mutex.lockUncancelable(ev_io);
+    defer ev.backing_allocator_mutex.unlock(ev_io);
+    return ev.backing_allocator.rawAlloc(len, alignment, ret_addr);
+}
+
+fn resize(
+    userdata: *anyopaque,
+    memory: []u8,
+    alignment: std.mem.Alignment,
+    new_len: usize,
+    ret_addr: usize,
+) bool {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+    ev.backing_allocator_mutex.lockUncancelable(ev_io);
+    defer ev.backing_allocator_mutex.unlock(ev_io);
+    return ev.backing_allocator.rawResize(memory, alignment, new_len, ret_addr);
+}
+
+fn remap(
+    userdata: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    ret_addr: usize,
+) ?[*]u8 {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+    ev.backing_allocator_mutex.lockUncancelable(ev_io);
+    defer ev.backing_allocator_mutex.unlock(ev_io);
+    return ev.backing_allocator.rawRemap(memory, alignment, new_len, ret_addr);
+}
+
+fn free(userdata: *anyopaque, memory: []u8, alignment: std.mem.Alignment, ret_addr: usize) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+    ev.backing_allocator_mutex.lockUncancelable(ev_io);
+    defer ev.backing_allocator_mutex.unlock(ev_io);
+    return ev.backing_allocator.rawFree(memory, alignment, ret_addr);
 }
 
-pub fn io(el: *EventLoop) Io {
+pub fn io(ev: *Evented) Io {
     return .{
-        .userdata = el,
+        .userdata = ev,
         .vtable = &.{
             .async = async,
             .concurrent = concurrent,
             .await = await,
-            .select = select,
             .cancel = cancel,
-            .cancelRequested = cancelRequested,
 
-            .mutexLock = mutexLock,
-            .mutexUnlock = mutexUnlock,
+            .groupAsync = groupAsync,
+            .groupConcurrent = groupConcurrent,
+            .groupAwait = groupAwait,
+            .groupCancel = groupCancel,
 
-            .conditionWait = conditionWait,
-            .conditionWake = conditionWake,
+            .recancel = recancel,
+            .swapCancelProtection = swapCancelProtection,
+            .checkCancel = checkCancel,
 
-            .createFile = createFile,
-            .fileOpen = fileOpen,
+            .select = select,
+
+            .futexWait = futexWait,
+            .futexWaitUncancelable = futexWaitUncancelable,
+            .futexWake = futexWake,
+
+            .operate = operate,
+            .batchAwaitAsync = batchAwaitAsync,
+            .batchAwaitConcurrent = batchAwaitConcurrent,
+            .batchCancel = batchCancel,
+
+            .dirCreateDir = dirCreateDir,
+            .dirCreateDirPath = dirCreateDirPath,
+            .dirCreateDirPathOpen = dirCreateDirPathOpen,
+            .dirOpenDir = dirOpenDir,
+            .dirStat = dirStat,
+            .dirStatFile = dirStatFile,
+            .dirAccess = dirAccess,
+            .dirCreateFile = dirCreateFile,
+            .dirCreateFileAtomic = dirCreateFileAtomic,
+            .dirOpenFile = dirOpenFile,
+            .dirClose = dirClose,
+            .dirRead = dirRead,
+            .dirRealPath = dirRealPath,
+            .dirRealPathFile = dirRealPathFile,
+            .dirDeleteFile = dirDeleteFile,
+            .dirDeleteDir = dirDeleteDir,
+            .dirRename = dirRename,
+            .dirRenamePreserve = dirRenamePreserve,
+            .dirSymLink = dirSymLink,
+            .dirReadLink = dirReadLink,
+            .dirSetOwner = dirSetOwner,
+            .dirSetFileOwner = dirSetFileOwner,
+            .dirSetPermissions = dirSetPermissions,
+            .dirSetFilePermissions = dirSetFilePermissions,
+            .dirSetTimestamps = dirSetTimestamps,
+            .dirHardLink = dirHardLink,
+
+            .fileStat = fileStat,
+            .fileLength = fileLength,
             .fileClose = fileClose,
-            .pread = pread,
-            .pwrite = pwrite,
+            .fileWritePositional = fileWritePositional,
+            .fileWriteFileStreaming = fileWriteFileStreaming,
+            .fileWriteFilePositional = fileWriteFilePositional,
+            .fileReadPositional = fileReadPositional,
+            .fileSeekBy = fileSeekBy,
+            .fileSeekTo = fileSeekTo,
+            .fileSync = fileSync,
+            .fileIsTty = fileIsTty,
+            .fileEnableAnsiEscapeCodes = fileEnableAnsiEscapeCodes,
+            .fileSupportsAnsiEscapeCodes = fileIsTty,
+            .fileSetLength = fileSetLength,
+            .fileSetOwner = fileSetOwner,
+            .fileSetPermissions = fileSetPermissions,
+            .fileSetTimestamps = fileSetTimestamps,
+            .fileLock = fileLock,
+            .fileTryLock = fileTryLock,
+            .fileUnlock = fileUnlock,
+            .fileDowngradeLock = fileDowngradeLock,
+            .fileRealPath = fileRealPath,
+            .fileHardLink = fileHardLink,
+
+            .fileMemoryMapCreate = fileMemoryMapCreate,
+            .fileMemoryMapDestroy = fileMemoryMapDestroy,
+            .fileMemoryMapSetLength = fileMemoryMapSetLength,
+            .fileMemoryMapRead = fileMemoryMapRead,
+            .fileMemoryMapWrite = fileMemoryMapWrite,
+
+            .processExecutableOpen = processExecutableOpen,
+            .processExecutablePath = processExecutablePath,
+            .lockStderr = lockStderr,
+            .tryLockStderr = tryLockStderr,
+            .unlockStderr = unlockStderr,
+            .processCurrentPath = processCurrentPath,
+            .processSetCurrentDir = processSetCurrentDir,
+            .processReplace = processReplace,
+            .processReplacePath = processReplacePath,
+            .processSpawn = processSpawn,
+            .processSpawnPath = processSpawnPath,
+            .childWait = childWait,
+            .childKill = childKill,
+
+            .progressParentFile = progressParentFile,
 
             .now = now,
+            .clockResolution = clockResolution,
             .sleep = sleep,
+
+            .random = random,
+            .randomSecure = randomSecure,
+
+            .netListenIp = netListenIpUnavailable,
+            .netAccept = netAcceptUnavailable,
+            .netBindIp = netBindIp,
+            .netConnectIp = netConnectIpUnavailable,
+            .netListenUnix = netListenUnixUnavailable,
+            .netConnectUnix = netConnectUnixUnavailable,
+            .netSocketCreatePair = netSocketCreatePairUnavailable,
+            .netSend = netSendUnavailable,
+            .netReceive = netReceive,
+            .netRead = netReadUnavailable,
+            .netWrite = netWriteUnavailable,
+            .netWriteFile = netWriteFileUnavailable,
+            .netClose = netClose,
+            .netShutdown = netShutdown,
+            .netInterfaceNameResolve = netInterfaceNameResolveUnavailable,
+            .netInterfaceName = netInterfaceNameUnavailable,
+            .netLookup = netLookupUnavailable,
         },
     };
 }
 
-pub fn init(el: *EventLoop, gpa: Allocator) !void {
+fn fileMemoryMapSetLength(
+    userdata: ?*anyopaque,
+    mm: *File.MemoryMap,
+    new_len: usize,
+) File.MemoryMap.SetLengthError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const page_size = std.heap.pageSize();
+    const alignment: Alignment = .fromByteUnits(page_size);
+    const page_align = std.heap.page_size_min;
+    const old_memory = mm.memory;
+
+    if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
+        mm.memory.len = new_len;
+        return;
+    }
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const flags: linux.MREMAP = .{ .MAYMOVE = true };
+    const addr_hint: ?[*]const u8 = null;
+    const new_memory = while (true) {
+        try cancel_region.await(.nothing);
+        const rc = linux.mremap(old_memory.ptr, old_memory.len, new_len, flags, addr_hint);
+        switch (linux.errno(rc)) {
+            .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len],
+            .INTR => continue,
+            .AGAIN => return error.LockedMemoryLimitExceeded,
+            .NOMEM => return error.OutOfMemory,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    mm.memory = new_memory;
+}
+
+fn fileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = mm;
+}
+
+fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = mm;
+}
+
+pub const InitOptions = struct {
+    backing_allocator_needs_mutex: bool = true,
+
+    /// Affects the following operations:
+    /// * `processExecutablePath` on OpenBSD and Haiku.
+    argv0: Argv0 = .empty,
+    /// Affects the following operations:
+    /// * `fileIsTty`
+    /// * `processSpawn`, `processSpawnPath`, `processReplace`, `processReplacePath`
+    environ: process.Environ,
+};
+
+pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !void {
     const threads_size = @max(std.Thread.getCpuCount() catch 1, 1) * @sizeOf(Thread);
-    const idle_stack_end_offset = std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.page_size_max);
-    const allocated_slice = try gpa.alignedAlloc(u8, .of(Thread), idle_stack_end_offset);
-    errdefer gpa.free(allocated_slice);
-    el.* = .{
-        .gpa = gpa,
-        .mutex = .{},
+    const idle_stack_end_offset =
+        std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.page_size_max);
+    const allocated_slice = try backing_allocator.alignedAlloc(u8, .of(Thread), idle_stack_end_offset);
+    errdefer backing_allocator.free(allocated_slice);
+    ev.* = .{
+        .backing_allocator_needs_mutex = options.backing_allocator_needs_mutex,
+        .backing_allocator_mutex = .init,
+        .backing_allocator = backing_allocator,
         .main_fiber_buffer = undefined,
         .threads = .{
             .allocated = @ptrCast(allocated_slice[0..threads_size]),
             .reserved = 1,
             .active = 1,
         },
+
+        .stderr_mutex = .init,
+        .stderr_writer = .{
+            .io = ev.io(),
+            .interface = Io.File.Writer.initInterface(&.{}),
+            .file = .stderr(),
+            .mode = .streaming,
+        },
+        .stderr_mode = .no_color,
+        .stderr_writer_initialized = false,
+
+        .environ_mutex = .init,
+        .environ = .{ .process_environ = options.environ },
+
+        .null_fd = .init,
+        .random_fd = .init,
+
+        .csprng_mutex = .init,
+        .csprng = .uninitialized,
     };
-    const main_fiber: *Fiber = @ptrCast(&el.main_fiber_buffer);
+    const main_fiber: *Fiber = @ptrCast(&ev.main_fiber_buffer);
     main_fiber.* = .{
         .required_align = {},
         .context = undefined,
-        .awaiter = null,
-        .queue_next = null,
-        .cancel_thread = null,
-        .awaiting_completions = .initEmpty(),
+        .await_count = 0,
+        .link = .{ .awaiter = null },
+        .status = .{ .queue_next = null },
+        .cancel_status = .unrequested,
+        .cancel_protection = .unblocked,
     };
-    const main_thread = &el.threads.allocated[0];
+    const main_thread = &ev.threads.allocated[0];
     Thread.self = main_thread;
-    const idle_stack_end: [*]align(16) usize = @ptrCast(@alignCast(allocated_slice[idle_stack_end_offset..].ptr));
-    (idle_stack_end - 1)[0..1].* = .{@intFromPtr(el)};
+    const idle_stack_end: [*]align(16) usize =
+        @ptrCast(@alignCast(allocated_slice[idle_stack_end_offset..].ptr));
+    (idle_stack_end - 1)[0..1].* = .{@intFromPtr(ev)};
     main_thread.* = .{
+        .required_align = {},
         .thread = undefined,
         .idle_context = switch (builtin.cpu.arch) {
             .aarch64 => .{
@@ -206,42 +796,56 @@ pub fn init(el: *EventLoop, gpa: Allocator) !void {
         },
         .current_context = &main_fiber.context,
         .ready_queue = null,
-        .io_uring = try IoUring.init(io_uring_entries, 0),
+        .io_uring = try .init(
+            io_uring_entries,
+            linux.IORING_SETUP_COOP_TASKRUN | linux.IORING_SETUP_SINGLE_ISSUER,
+        ),
         .idle_search_index = 1,
         .steal_ready_search_index = 1,
+        .csprng = .uninitialized,
     };
     errdefer main_thread.io_uring.deinit();
-    std.log.debug("created main idle {*}", .{&main_thread.idle_context});
-    std.log.debug("created main {*}", .{main_fiber});
+    log.debug("created main idle {*}", .{&main_thread.idle_context});
+    log.debug("created main {*}", .{main_fiber});
 }
 
-pub fn deinit(el: *EventLoop) void {
-    const active_threads = @atomicLoad(u32, &el.threads.active, .acquire);
-    for (el.threads.allocated[0..active_threads]) |*thread| {
+pub fn deinit(ev: *Evented) void {
+    const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
+    for (ev.threads.allocated[0..active_threads]) |*thread| {
         const ready_fiber = @atomicLoad(?*Fiber, &thread.ready_queue, .monotonic);
         assert(ready_fiber == null or ready_fiber == Fiber.finished); // pending async
     }
-    el.yield(null, .exit);
-    const allocated_ptr: [*]align(@alignOf(Thread)) u8 = @ptrCast(@alignCast(el.threads.allocated.ptr));
-    const idle_stack_end_offset = std.mem.alignForward(usize, el.threads.allocated.len * @sizeOf(Thread) + idle_stack_size, std.heap.page_size_max);
-    for (el.threads.allocated[1..active_threads]) |*thread| thread.thread.join();
-    el.gpa.free(allocated_ptr[0..idle_stack_end_offset]);
-    el.* = undefined;
+    ev.yield(null, .exit);
+    ev.threads.allocated[0].io_uring.deinit();
+    ev.null_fd.close();
+    ev.random_fd.close();
+    const allocated_ptr: [*]align(@alignOf(Thread)) u8 = @ptrCast(@alignCast(ev.threads.allocated.ptr));
+    const idle_stack_end_offset = std.mem.alignForward(
+        usize,
+        ev.threads.allocated.len * @sizeOf(Thread) + idle_stack_size,
+        std.heap.page_size_max,
+    );
+    for (ev.threads.allocated[1..active_threads]) |*thread| thread.thread.join();
+    assert(active_threads == ev.threads.active); // spawned threads while there was no pending async?
+    ev.backing_allocator.free(allocated_ptr[0..idle_stack_end_offset]);
+    ev.* = undefined;
 }
 
-fn findReadyFiber(el: *EventLoop, thread: *Thread) ?*Fiber {
+fn findReadyFiber(ev: *Evented, thread: *Thread) ?*Fiber {
     if (@atomicRmw(?*Fiber, &thread.ready_queue, .Xchg, Fiber.finished, .acquire)) |ready_fiber| {
-        @atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.queue_next, .release);
-        ready_fiber.queue_next = null;
+        @atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.status.queue_next, .release);
+        ready_fiber.status.queue_next = null;
         return ready_fiber;
     }
-    const active_threads = @atomicLoad(u32, &el.threads.active, .acquire);
+    const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
     for (0..@min(max_steal_ready_search, active_threads)) |_| {
         defer thread.steal_ready_search_index += 1;
         if (thread.steal_ready_search_index == active_threads) thread.steal_ready_search_index = 0;
-        const steal_ready_search_thread = &el.threads.allocated[0..active_threads][thread.steal_ready_search_index];
+        const steal_ready_search_thread =
+            &ev.threads.allocated[0..active_threads][thread.steal_ready_search_index];
         if (steal_ready_search_thread == thread) continue;
-        const ready_fiber = @atomicLoad(?*Fiber, &steal_ready_search_thread.ready_queue, .acquire) orelse continue;
+        const ready_fiber =
+            @atomicLoad(?*Fiber, &steal_ready_search_thread.ready_queue, .acquire) orelse continue;
         if (ready_fiber == Fiber.finished) continue;
         if (@cmpxchgWeak(
             ?*Fiber,
@@ -251,8 +855,8 @@ fn findReadyFiber(el: *EventLoop, thread: *Thread) ?*Fiber {
             .acquire,
             .monotonic,
         )) |_| continue;
-        @atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.queue_next, .release);
-        ready_fiber.queue_next = null;
+        @atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.status.queue_next, .release);
+        ready_fiber.status.queue_next = null;
         return ready_fiber;
     }
     // couldn't find anything to do, so we are now open for business
@@ -260,9 +864,9 @@ fn findReadyFiber(el: *EventLoop, thread: *Thread) ?*Fiber {
     return null;
 }
 
-fn yield(el: *EventLoop, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.PendingTask) void {
+fn yield(ev: *Evented, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.PendingTask) void {
     const thread: *Thread = .current();
-    const ready_context = if (maybe_ready_fiber orelse el.findReadyFiber(thread)) |ready_fiber|
+    const ready_context = if (maybe_ready_fiber orelse ev.findReadyFiber(thread)) |ready_fiber|
         &ready_fiber.context
     else
         &thread.idle_context;
@@ -273,25 +877,25 @@ fn yield(el: *EventLoop, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage
         },
         .pending_task = pending_task,
     };
-    std.log.debug("switching from {*} to {*}", .{ message.contexts.prev, message.contexts.ready });
-    contextSwitch(&message).handle(el);
+    log.debug("switching from {*} to {*}", .{ message.contexts.prev, message.contexts.ready });
+    contextSwitch(&message).handle(ev);
 }
 
-fn schedule(el: *EventLoop, thread: *Thread, ready_queue: Fiber.Queue) void {
+fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
     {
         var fiber = ready_queue.head;
         while (true) {
-            std.log.debug("scheduling {*}", .{fiber});
-            fiber = fiber.queue_next orelse break;
+            log.debug("scheduling {*}", .{fiber});
+            fiber = fiber.status.queue_next orelse break;
         }
         assert(fiber == ready_queue.tail);
     }
     // shared fields of previous `Thread` must be initialized before later ones are marked as active
-    const new_thread_index = @atomicLoad(u32, &el.threads.active, .acquire);
+    const new_thread_index = @atomicLoad(u32, &ev.threads.active, .acquire);
     for (0..@min(max_idle_search, new_thread_index)) |_| {
         defer thread.idle_search_index += 1;
         if (thread.idle_search_index == new_thread_index) thread.idle_search_index = 0;
-        const idle_search_thread = &el.threads.allocated[0..new_thread_index][thread.idle_search_index];
+        const idle_search_thread = &ev.threads.allocated[0..new_thread_index][thread.idle_search_index];
         if (idle_search_thread == thread) continue;
         if (@cmpxchgWeak(
             ?*Fiber,
@@ -301,13 +905,13 @@ fn schedule(el: *EventLoop, thread: *Thread, ready_queue: Fiber.Queue) void {
             .release,
             .monotonic,
         )) |_| continue;
-        getSqe(&thread.io_uring).* = .{
+        thread.enqueue().* = .{
             .opcode = .MSG_RING,
-            .flags = std.os.linux.IOSQE_CQE_SKIP_SUCCESS,
+            .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
             .ioprio = 0,
             .fd = idle_search_thread.io_uring.fd,
             .off = @intFromEnum(Completion.UserData.wakeup),
-            .addr = 0,
+            .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA),
             .len = 0,
             .rw_flags = 0,
             .user_data = @intFromEnum(Completion.UserData.wakeup),
@@ -317,145 +921,221 @@ fn schedule(el: *EventLoop, thread: *Thread, ready_queue: Fiber.Queue) void {
             .addr3 = 0,
             .resv = 0,
         };
-        return;
+        return true;
     }
     spawn_thread: {
         // previous failed reservations must have completed before retrying
-        if (new_thread_index == el.threads.allocated.len or @cmpxchgWeak(
+        if (new_thread_index == ev.threads.allocated.len or @cmpxchgWeak(
             u32,
-            &el.threads.reserved,
+            &ev.threads.reserved,
             new_thread_index,
             new_thread_index + 1,
             .acquire,
             .monotonic,
         ) != null) break :spawn_thread;
-        const new_thread = &el.threads.allocated[new_thread_index];
+        const new_thread = &ev.threads.allocated[new_thread_index];
         const next_thread_index = new_thread_index + 1;
+        var params = std.mem.zeroInit(linux.io_uring_params, .{
+            .flags = linux.IORING_SETUP_ATTACH_WQ |
+                linux.IORING_SETUP_R_DISABLED |
+                linux.IORING_SETUP_COOP_TASKRUN |
+                linux.IORING_SETUP_SINGLE_ISSUER,
+            .wq_fd = @as(u32, @intCast(ev.threads.allocated[0].io_uring.fd)),
+        });
         new_thread.* = .{
+            .required_align = {},
             .thread = undefined,
             .idle_context = undefined,
             .current_context = &new_thread.idle_context,
             .ready_queue = ready_queue.head,
-            .io_uring = IoUring.init(io_uring_entries, 0) catch |err| {
-                @atomicStore(u32, &el.threads.reserved, new_thread_index, .release);
+            .io_uring = IoUring.init_params(io_uring_entries, &params) catch |err| {
+                @atomicStore(u32, &ev.threads.reserved, new_thread_index, .release);
                 // no more access to `thread` after giving up reservation
-                std.log.warn("unable to create worker thread due to io_uring init failure: {s}", .{@errorName(err)});
+                log.warn("unable to create worker thread due to io_uring init failure: {s}", .{
+                    @errorName(err),
+                });
                 break :spawn_thread;
             },
             .idle_search_index = 0,
             .steal_ready_search_index = 0,
+            .csprng = .uninitialized,
         };
         new_thread.thread = std.Thread.spawn(.{
             .stack_size = idle_stack_size,
-            .allocator = el.gpa,
-        }, threadEntry, .{ el, new_thread_index }) catch |err| {
+            .allocator = ev.allocator(),
+        }, threadEntry, .{ ev, new_thread_index }) catch |err| {
             new_thread.io_uring.deinit();
-            @atomicStore(u32, &el.threads.reserved, new_thread_index, .release);
+            @atomicStore(u32, &ev.threads.reserved, new_thread_index, .release);
             // no more access to `thread` after giving up reservation
-            std.log.warn("unable to create worker thread due spawn failure: {s}", .{@errorName(err)});
+            log.warn("unable to create worker thread due spawn failure: {s}", .{@errorName(err)});
             break :spawn_thread;
         };
         // shared fields of `Thread` must be initialized before being marked active
-        @atomicStore(u32, &el.threads.active, next_thread_index, .release);
-        return;
+        @atomicStore(u32, &ev.threads.active, next_thread_index, .release);
+        return false;
     }
     // nobody wanted it, so just queue it on ourselves
     while (@cmpxchgWeak(
         ?*Fiber,
         &thread.ready_queue,
-        ready_queue.tail.queue_next,
+        ready_queue.tail.status.queue_next,
         ready_queue.head,
         .acq_rel,
         .acquire,
-    )) |old_head| ready_queue.tail.queue_next = old_head;
+    )) |old_head| ready_queue.tail.status.queue_next = old_head;
+    return false;
 }
 
-fn mainIdle(el: *EventLoop, message: *const SwitchMessage) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Context)))) noreturn {
-    message.handle(el);
-    el.idle(&el.threads.allocated[0]);
-    el.yield(@ptrCast(&el.main_fiber_buffer), .nothing);
+fn mainIdle(
+    ev: *Evented,
+    message: *const SwitchMessage,
+) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Context)))) noreturn {
+    message.handle(ev);
+    ev.idle(&ev.threads.allocated[0]);
+    ev.yield(@ptrCast(&ev.main_fiber_buffer), .nothing);
     unreachable; // switched to dead fiber
 }
 
-fn threadEntry(el: *EventLoop, index: u32) void {
-    const thread: *Thread = &el.threads.allocated[index];
+fn threadEntry(ev: *Evented, index: u32) void {
+    const thread: *Thread = &ev.threads.allocated[index];
     Thread.self = thread;
-    std.log.debug("created thread idle {*}", .{&thread.idle_context});
-    el.idle(thread);
+    defer thread.io_uring.deinit();
+    log.debug("created thread idle {*}", .{&thread.idle_context});
+    switch (linux.errno(linux.io_uring_register(thread.io_uring.fd, .REGISTER_ENABLE_RINGS, null, 0))) {
+        .SUCCESS => ev.idle(thread),
+        else => |err| @panic(@tagName(err)),
+    }
 }
 
 const Completion = struct {
+    result: i32,
+    flags: u32,
+
     const UserData = enum(usize) {
         unused,
         wakeup,
+        futex_wake,
         cleanup,
         exit,
-        /// *Fiber
+        /// If bit 0 is 1, a pointer to the `context` field of `Io.Batch.Storage.Pending`.
+        /// If bits 0 and 1 are 0, a `*Fiber`.
         _,
     };
-    result: i32,
-    flags: u32,
+
+    fn errno(completion: Completion) linux.E {
+        return linux.errno(@bitCast(@as(isize, completion.result)));
+    }
 };
 
-fn idle(el: *EventLoop, thread: *Thread) void {
+fn idle(ev: *Evented, thread: *Thread) void {
     var maybe_ready_fiber: ?*Fiber = null;
     while (true) {
-        while (maybe_ready_fiber orelse el.findReadyFiber(thread)) |ready_fiber| {
-            el.yield(ready_fiber, .nothing);
+        while (maybe_ready_fiber orelse ev.findReadyFiber(thread)) |ready_fiber| {
+            ev.yield(ready_fiber, .nothing);
             maybe_ready_fiber = null;
         }
         _ = thread.io_uring.submit_and_wait(1) catch |err| switch (err) {
-            error.SignalInterrupt => std.log.warn("submit_and_wait failed with SignalInterrupt", .{}),
+            error.SignalInterrupt => {},
             else => |e| @panic(@errorName(e)),
         };
-        var cqes_buffer: [io_uring_entries]std.os.linux.io_uring_cqe = undefined;
+        var cqes_buffer: [io_uring_entries]linux.io_uring_cqe = undefined;
         var maybe_ready_queue: ?Fiber.Queue = null;
         for (cqes_buffer[0 .. thread.io_uring.copy_cqes(&cqes_buffer, 0) catch |err| switch (err) {
-            error.SignalInterrupt => cqes_len: {
-                std.log.warn("copy_cqes failed with SignalInterrupt", .{});
-                break :cqes_len 0;
-            },
+            error.SignalInterrupt => 0,
             else => |e| @panic(@errorName(e)),
-        }]) |cqe| switch (@as(Completion.UserData, @enumFromInt(cqe.user_data))) {
+        }]) |cqe| if (cqe.flags & linux.IORING_CQE_F_SKIP == 0) switch (@as(
+            Completion.UserData,
+            @enumFromInt(cqe.user_data),
+        )) {
             .unused => unreachable, // bad submission queued?
             .wakeup => {},
+            .futex_wake => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
+                .SUCCESS => recoverableOsBugDetected(), // success is skipped
+                .INVAL => {}, // invalid futex_wait() on ptr done elsewhere
+                .INTR, .CANCELED => recoverableOsBugDetected(), // `Completion.UserData.futex_wake` is not cancelable
+                .FAULT => {}, // pointer became invalid while doing the wake
+                else => recoverableOsBugDetected(), // deadlock due to operating system bug
+            },
             .cleanup => @panic("failed to notify other threads that we are exiting"),
             .exit => {
                 assert(maybe_ready_fiber == null and maybe_ready_queue == null); // pending async
                 return;
             },
-            _ => switch (errno(cqe.res)) {
-                .INTR => getSqe(&thread.io_uring).* = .{
-                    .opcode = .ASYNC_CANCEL,
-                    .flags = std.os.linux.IOSQE_CQE_SKIP_SUCCESS,
-                    .ioprio = 0,
-                    .fd = 0,
-                    .off = 0,
-                    .addr = cqe.user_data,
-                    .len = 0,
-                    .rw_flags = 0,
-                    .user_data = @intFromEnum(Completion.UserData.wakeup),
-                    .buf_index = 0,
-                    .personality = 0,
-                    .splice_fd_in = 0,
-                    .addr3 = 0,
-                    .resv = 0,
-                },
-                else => {
-                    const fiber: *Fiber = @ptrFromInt(cqe.user_data);
-                    assert(fiber.queue_next == null);
-                    fiber.resultPointer(Completion).* = .{
+            _ => if (@as(?*Fiber, ready_fiber: switch (@as(u2, @truncate(cqe.user_data))) {
+                0b00 => {
+                    const ready_fiber: *Fiber = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
+                    ready_fiber.resultPointer(Completion).* = .{
                         .result = cqe.res,
                         .flags = cqe.flags,
                     };
-                    if (maybe_ready_fiber == null) maybe_ready_fiber = fiber else if (maybe_ready_queue) |*ready_queue| {
-                        ready_queue.tail.queue_next = fiber;
-                        ready_queue.tail = fiber;
-                    } else maybe_ready_queue = .{ .head = fiber, .tail = fiber };
+                    break :ready_fiber ready_fiber;
                 },
+                0b01 => {
+                    thread.enqueue().* = .{
+                        .opcode = .ASYNC_CANCEL,
+                        .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+                        .ioprio = 0,
+                        .fd = 0,
+                        .off = 0,
+                        .addr = cqe.user_data & ~@as(usize, 0b11),
+                        .len = 0,
+                        .rw_flags = 0,
+                        .user_data = @intFromEnum(Completion.UserData.wakeup),
+                        .buf_index = 0,
+                        .personality = 0,
+                        .splice_fd_in = 0,
+                        .addr3 = 0,
+                        .resv = 0,
+                    };
+                    break :ready_fiber null;
+                },
+                0b10 => {
+                    const context: *Io.Operation.Storage.Pending.Context =
+                        @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
+                    const batch: *Io.Batch = @ptrFromInt(context[0]);
+                    var next: usize = 0b00;
+                    context[0..3].* = .{ next, @as(u32, @bitCast(cqe.res)), cqe.flags };
+                    while (true) {
+                        next = @cmpxchgWeak(
+                            usize,
+                            @as(*usize, @ptrCast(&batch.context)),
+                            next,
+                            cqe.user_data,
+                            .release,
+                            .acquire,
+                        ) orelse break;
+                        context[0] = next;
+                    }
+                    break :ready_fiber switch (@as(u2, @truncate(next))) {
+                        0b00, 0b01 => @ptrFromInt(next & ~@as(usize, 0b11)),
+                        0b10, 0b11 => null,
+                    };
+                },
+                0b11 => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
+                    .SUCCESS => unreachable, // no event count specified
+                    .TIME => {
+                        const context: *usize = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
+                        const fiber = @atomicRmw(usize, context, .Add, 0b01, .acquire);
+                        break :ready_fiber switch (@as(u2, @truncate(fiber))) {
+                            else => unreachable, // timeout completed multiple times
+                            0b00 => @ptrFromInt(fiber & ~@as(usize, 0b11)),
+                            0b10 => null,
+                        };
+                    },
+                    .CANCELED => null, // user data may have been invalidated
+                    else => |err| unexpectedErrno(err) catch null,
+                },
+            })) |ready_fiber| {
+                assert(ready_fiber.status.queue_next == null);
+                if (maybe_ready_fiber == null) {
+                    maybe_ready_fiber = ready_fiber;
+                } else if (maybe_ready_queue) |*ready_queue| {
+                    ready_queue.tail.status.queue_next = ready_fiber;
+                    ready_queue.tail = ready_fiber;
+                } else maybe_ready_queue = .{ .head = ready_fiber, .tail = ready_fiber };
             },
         };
-        if (maybe_ready_queue) |ready_queue| el.schedule(thread, ready_queue);
+        if (maybe_ready_queue) |ready_queue| _ = ev.schedule(thread, ready_queue);
     }
 }
 
@@ -469,113 +1149,68 @@ const SwitchMessage = struct {
     const PendingTask = union(enum) {
         nothing,
         reschedule,
-        recycle: *Fiber,
-        register_awaiter: *?*Fiber,
-        register_select: []const *Io.AnyFuture,
-        mutex_lock: struct {
-            prev_state: Io.Mutex.State,
-            mutex: *Io.Mutex,
-        },
-        condition_wait: struct {
-            cond: *Io.Condition,
-            mutex: *Io.Mutex,
-        },
+        await: u31,
+        group_await: Group,
+        group_cancel: Group,
+        batch_await: *Io.Batch,
+        destroy,
         exit,
     };
 
-    fn handle(message: *const SwitchMessage, el: *EventLoop) void {
+    fn handle(message: *const SwitchMessage, ev: *Evented) void {
         const thread: *Thread = .current();
         thread.current_context = message.contexts.ready;
         switch (message.pending_task) {
             .nothing => {},
             .reschedule => if (message.contexts.prev != &thread.idle_context) {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
-                assert(prev_fiber.queue_next == null);
-                el.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                assert(fiber.status.queue_next == null);
+                _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
-            .recycle => |fiber| {
-                el.recycle(fiber);
+            .await => |count| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                if (@atomicRmw(i32, &fiber.await_count, .Sub, count, .monotonic) > 0)
+                    _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
-            .register_awaiter => |awaiter| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
-                assert(prev_fiber.queue_next == null);
-                if (@atomicRmw(?*Fiber, awaiter, .Xchg, prev_fiber, .acq_rel) == Fiber.finished)
-                    el.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
+            .group_await => |group| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                if (group.await(ev, fiber))
+                    _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
-            .register_select => |futures| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
-                assert(prev_fiber.queue_next == null);
-                for (futures) |any_future| {
-                    const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
-                    if (@atomicRmw(?*Fiber, &future_fiber.awaiter, .Xchg, prev_fiber, .acq_rel) == Fiber.finished) {
-                        const closure: *AsyncClosure = .fromFiber(future_fiber);
-                        if (!@atomicRmw(bool, &closure.already_awaited, .Xchg, true, .seq_cst)) {
-                            el.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
-                        }
-                    }
-                }
+            .group_cancel => |group| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                if (group.cancel(ev, fiber))
+                    _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
-            .mutex_lock => |mutex_lock| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
-                assert(prev_fiber.queue_next == null);
-                var prev_state = mutex_lock.prev_state;
-                while (switch (prev_state) {
-                    else => next_state: {
-                        prev_fiber.queue_next = @ptrFromInt(@intFromEnum(prev_state));
-                        break :next_state @cmpxchgWeak(
-                            Io.Mutex.State,
-                            &mutex_lock.mutex.state,
-                            prev_state,
-                            @enumFromInt(@intFromPtr(prev_fiber)),
-                            .release,
-                            .acquire,
-                        );
-                    },
-                    .unlocked => @cmpxchgWeak(
-                        Io.Mutex.State,
-                        &mutex_lock.mutex.state,
-                        .unlocked,
-                        .locked_once,
-                        .acquire,
-                        .acquire,
-                    ) orelse {
-                        prev_fiber.queue_next = null;
-                        el.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
-                        return;
-                    },
-                }) |next_state| prev_state = next_state;
-            },
-            .condition_wait => |condition_wait| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
-                assert(prev_fiber.queue_next == null);
-                const cond_impl = prev_fiber.resultPointer(ConditionImpl);
-                cond_impl.* = .{
-                    .tail = prev_fiber,
-                    .event = .queued,
-                };
+            .batch_await => |batch| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
                 if (@cmpxchgStrong(
-                    ?*Fiber,
-                    @as(*?*Fiber, @ptrCast(&condition_wait.cond.state)),
+                    ?*anyopaque,
+                    &batch.context,
                     null,
-                    prev_fiber,
+                    fiber,
                     .release,
-                    .acquire,
-                )) |waiting_fiber| {
-                    const waiting_cond_impl = waiting_fiber.?.resultPointer(ConditionImpl);
-                    assert(waiting_cond_impl.tail.queue_next == null);
-                    waiting_cond_impl.tail.queue_next = prev_fiber;
-                    waiting_cond_impl.tail = prev_fiber;
+                    .monotonic,
+                )) |head| {
+                    assert(@as(u2, @truncate(@intFromPtr(head))) != 0b00);
+                    _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
                 }
-                condition_wait.mutex.unlock(el.io());
             },
-            .exit => for (el.threads.allocated[0..@atomicLoad(u32, &el.threads.active, .acquire)]) |*each_thread| {
-                getSqe(&thread.io_uring).* = .{
+            .destroy => {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                fiber.destroy(ev.backing_allocator);
+                ev.backing_allocator_mutex.unlock(ev.io());
+            },
+            .exit => for (
+                ev.threads.allocated[0..@atomicLoad(u32, &ev.threads.active, .acquire)],
+            ) |*each_thread| {
+                thread.enqueue().* = .{
                     .opcode = .MSG_RING,
-                    .flags = std.os.linux.IOSQE_CQE_SKIP_SUCCESS,
+                    .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
                     .ioprio = 0,
                     .fd = each_thread.io_uring.fd,
                     .off = @intFromEnum(Completion.UserData.exit),
-                    .addr = 0,
+                    .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA),
                     .len = 0,
                     .rw_flags = 0,
                     .user_data = @intFromEnum(Completion.UserData.cleanup),
@@ -784,65 +1419,73 @@ inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage {
 
 fn mainIdleEntry() callconv(.naked) void {
     switch (builtin.cpu.arch) {
-        .x86_64 => asm volatile (
-            \\ movq (%%rsp), %%rdi
-            \\ jmp %[mainIdle:P]
-            :
-            : [mainIdle] "X" (&mainIdle),
-        ),
         .aarch64 => asm volatile (
             \\ ldr x0, [sp, #-8]
             \\ b %[mainIdle]
             :
             : [mainIdle] "X" (&mainIdle),
         ),
-        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
-    }
-}
-
-fn fiberEntry() callconv(.naked) void {
-    switch (builtin.cpu.arch) {
         .x86_64 => asm volatile (
-            \\ leaq 8(%%rsp), %%rdi
-            \\ jmp %[AsyncClosure_call:P]
+            \\ movq (%%rsp), %%rdi
+            \\ jmp %[mainIdle:P]
             :
-            : [AsyncClosure_call] "X" (&AsyncClosure.call),
+            : [mainIdle] "X" (&mainIdle),
         ),
         else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
     }
 }
 
 const AsyncClosure = struct {
-    event_loop: *EventLoop,
+    ev: *Evented,
     fiber: *Fiber,
     start: *const fn (context: *const anyopaque, result: *anyopaque) void,
     result_align: Alignment,
-    already_awaited: bool,
+
+    fn fromFiber(fiber: *Fiber) *AsyncClosure {
+        return @ptrFromInt(Fiber.max_context_align.max(.of(AsyncClosure)).backward(
+            @intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
+        ) - @sizeOf(AsyncClosure));
+    }
 
     fn contextPointer(closure: *AsyncClosure) [*]align(Fiber.max_context_align.toByteUnits()) u8 {
         return @alignCast(@as([*]u8, @ptrCast(closure)) + @sizeOf(AsyncClosure));
     }
 
-    fn call(closure: *AsyncClosure, message: *const SwitchMessage) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
-        message.handle(closure.event_loop);
+    fn entry() callconv(.naked) void {
+        switch (builtin.cpu.arch) {
+            .aarch64 => asm volatile (
+                \\ mov x0, sp
+                \\ b %[call]
+                :
+                : [call] "X" (&call),
+            ),
+            .x86_64 => asm volatile (
+                \\ leaq 8(%%rsp), %%rdi
+                \\ jmp %[call:P]
+                :
+                : [call] "X" (&call),
+            ),
+            else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+        }
+    }
+
+    fn call(
+        closure: *AsyncClosure,
+        message: *const SwitchMessage,
+    ) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
+        message.handle(closure.ev);
         const fiber = closure.fiber;
-        std.log.debug("{*} performing async", .{fiber});
+        log.debug("{*} performing async", .{fiber});
         closure.start(closure.contextPointer(), fiber.resultBytes(closure.result_align));
-        const awaiter = @atomicRmw(?*Fiber, &fiber.awaiter, .Xchg, Fiber.finished, .acq_rel);
-        const ready_awaiter = r: {
-            const a = awaiter orelse break :r null;
-            if (@atomicRmw(bool, &closure.already_awaited, .Xchg, true, .acq_rel)) break :r null;
-            break :r a;
-        };
-        closure.event_loop.yield(ready_awaiter, .nothing);
+        closure.ev.yield(
+            if (@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel)) |awaiter|
+                if (@atomicRmw(i32, &awaiter.await_count, .Add, 1, .monotonic) == -1) awaiter else null
+            else
+                null,
+            .nothing,
+        );
         unreachable; // switched to dead fiber
     }
-
-    fn fromFiber(fiber: *Fiber) *AsyncClosure {
-        return @ptrFromInt(Fiber.max_context_align.max(.of(AsyncClosure)).backward(
-            @intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
-        ) - @sizeOf(AsyncClosure));
-    }
 };
 
 fn async(
@@ -853,7 +1496,8 @@ fn async(
     context_alignment: Alignment,
     start: *const fn (context: *const anyopaque, result: *anyopaque) void,
 ) ?*std.Io.AnyFuture {
-    return concurrent(userdata, result.len, result_alignment, context, context_alignment, start) catch {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return concurrent(ev, result.len, result_alignment, context, context_alignment, start) catch {
         start(context.ptr, result.ptr);
         return null;
     };
@@ -872,509 +1516,3330 @@ fn concurrent(
     assert(result_len <= Fiber.max_result_size); // TODO
     assert(context.len <= Fiber.max_context_size); // TODO
 
-    const event_loop: *EventLoop = @ptrCast(@alignCast(userdata));
-    const fiber = try Fiber.allocate(event_loop);
-    std.log.debug("allocated {*}", .{fiber});
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const fiber = Fiber.create(ev) catch |err| switch (err) {
+        error.OutOfMemory => return error.ConcurrencyUnavailable,
+    };
+    log.debug("allocated {*}", .{fiber});
 
     const closure: *AsyncClosure = .fromFiber(fiber);
     fiber.* = .{
         .required_align = {},
         .context = switch (builtin.cpu.arch) {
-            .x86_64 => .{
-                .rsp = @intFromPtr(closure) - @sizeOf(usize),
-                .rbp = 0,
-                .rip = @intFromPtr(&fiberEntry),
-            },
             .aarch64 => .{
                 .sp = @intFromPtr(closure),
                 .fp = 0,
-                .pc = @intFromPtr(&fiberEntry),
+                .pc = @intFromPtr(&AsyncClosure.entry),
+            },
+            .x86_64 => .{
+                .rsp = @intFromPtr(closure) - @sizeOf(usize),
+                .rbp = 0,
+                .rip = @intFromPtr(&AsyncClosure.entry),
             },
             else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
         },
-        .awaiter = null,
-        .queue_next = null,
-        .cancel_thread = null,
-        .awaiting_completions = .initEmpty(),
+        .await_count = 0,
+        .link = .{ .awaiter = null },
+        .status = .{ .queue_next = null },
+        .cancel_status = .unrequested,
+        .cancel_protection = .unblocked,
     };
     closure.* = .{
-        .event_loop = event_loop,
+        .ev = ev,
         .fiber = fiber,
         .start = start,
         .result_align = result_alignment,
-        .already_awaited = false,
     };
     @memcpy(closure.contextPointer(), context);
 
-    event_loop.schedule(.current(), .{ .head = fiber, .tail = fiber });
+    const thread: *Thread = .current();
+    if (ev.schedule(thread, .{ .head = fiber, .tail = fiber })) thread.submit();
     return @ptrCast(fiber);
 }
 
 fn await(
     userdata: ?*anyopaque,
-    any_future: *std.Io.AnyFuture,
+    future: *std.Io.AnyFuture,
     result: []u8,
     result_alignment: Alignment,
 ) void {
-    const event_loop: *EventLoop = @ptrCast(@alignCast(userdata));
-    const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
-    if (@atomicLoad(?*Fiber, &future_fiber.awaiter, .acquire) != Fiber.finished)
-        event_loop.yield(null, .{ .register_awaiter = &future_fiber.awaiter });
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const fiber = Thread.current().currentFiber();
+    const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+    if (@atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, fiber, .acq_rel)) |awaiter| {
+        assert(awaiter == Fiber.finished);
+    } else while (true) {
+        ev.yield(null, .{ .await = 1 });
+        const awaiter = @atomicLoad(?*Fiber, &future_fiber.link.awaiter, .acquire);
+        if (awaiter == Fiber.finished) break;
+        assert(awaiter == fiber); // spurious wakeup
+    }
     @memcpy(result, future_fiber.resultBytes(result_alignment));
-    event_loop.recycle(future_fiber);
-}
-
-fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) usize {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-
-    // Optimization to avoid the yield below.
-    for (futures, 0..) |any_future, i| {
-        const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
-        if (@atomicLoad(?*Fiber, &future_fiber.awaiter, .acquire) == Fiber.finished)
-            return i;
-    }
-
-    el.yield(null, .{ .register_select = futures });
-
-    std.log.debug("back from select yield", .{});
-
-    const my_thread: *Thread = .current();
-    const my_fiber = my_thread.currentFiber();
-    var result: ?usize = null;
-
-    for (futures, 0..) |any_future, i| {
-        const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
-        if (@cmpxchgStrong(?*Fiber, &future_fiber.awaiter, my_fiber, null, .seq_cst, .seq_cst)) |awaiter| {
-            if (awaiter == Fiber.finished) {
-                if (result == null) result = i;
-            } else if (awaiter) |a| {
-                const closure: *AsyncClosure = .fromFiber(a);
-                closure.already_awaited = false;
-            }
-        } else {
-            const closure: *AsyncClosure = .fromFiber(my_fiber);
-            closure.already_awaited = false;
-        }
-    }
-
-    return result.?;
+    future_fiber.destroy(ev.allocator());
 }
 
 fn cancel(
     userdata: ?*anyopaque,
-    any_future: *std.Io.AnyFuture,
+    future: *std.Io.AnyFuture,
     result: []u8,
     result_alignment: Alignment,
 ) void {
-    const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
-    if (@atomicRmw(
-        ?*Thread,
-        &future_fiber.cancel_thread,
-        .Xchg,
-        Thread.canceling,
-        .acq_rel,
-    )) |cancel_thread| if (cancel_thread != Thread.canceling) {
-        getSqe(&Thread.current().io_uring).* = .{
-            .opcode = .MSG_RING,
-            .flags = std.os.linux.IOSQE_CQE_SKIP_SUCCESS,
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+    future_fiber.requestCancel(ev);
+    await(ev, future, result, result_alignment);
+}
+
+const Group = struct {
+    ptr: *Io.Group,
+
+    const List = packed struct(usize) {
+        cancel_requested: bool,
+        awaiter_delayed: bool,
+        fibers: Fiber.PackedPtr,
+    };
+    fn listPtr(group: Group) *List {
+        return @ptrCast(&group.ptr.token);
+    }
+
+    const Mutex = packed struct(u32) {
+        locked: bool,
+        contended: bool,
+        shared2: u30,
+    };
+    fn mutexPtr(group: Group) *Mutex {
+        return switch (comptime builtin.cpu.arch.endian()) {
+            .little => @ptrCast(&group.ptr.state),
+            .big => @ptrCast(@alignCast(
+                @as([*]u8, @ptrCast(&group.ptr.state)) + @sizeOf(usize) - @sizeOf(u32),
+            )),
+        };
+    }
+
+    const Awaiter = packed struct(usize) {
+        locked: bool,
+        contended: bool,
+        awaiter: Fiber.PackedPtr,
+    };
+    fn awaiterPtr(group: Group) *Awaiter {
+        return @ptrCast(&group.ptr.state);
+    }
+
+    fn lock(group: Group, ev: *Evented) void {
+        const mutex = group.mutexPtr();
+        {
+            const old_state = @atomicRmw(
+                Mutex,
+                mutex,
+                .Or,
+                .{ .locked = true, .contended = false, .shared2 = 0 },
+                .acquire,
+            );
+            if (!old_state.locked) {
+                @branchHint(.likely);
+                return;
+            }
+            if (old_state.contended) {
+                futexWaitUncancelable(ev, @ptrCast(mutex), @bitCast(old_state));
+            }
+        }
+        while (true) {
+            var old_state = @atomicRmw(
+                Mutex,
+                mutex,
+                .Or,
+                .{ .locked = true, .contended = true, .shared2 = 0 },
+                .acquire,
+            );
+            if (!old_state.locked) {
+                @branchHint(.likely);
+                return;
+            }
+            old_state.contended = true;
+            futexWaitUncancelable(ev, @ptrCast(mutex), @bitCast(old_state));
+        }
+    }
+
+    fn unlock(group: Group, ev: *Evented) void {
+        const mutex = group.mutexPtr();
+        const old_state = @atomicRmw(
+            Mutex,
+            mutex,
+            .And,
+            .{ .locked = false, .contended = false, .shared2 = std.math.maxInt(u30) },
+            .release,
+        );
+        assert(old_state.locked);
+        if (old_state.contended) futexWake(ev, @ptrCast(mutex), 1);
+    }
+
+    fn addFiber(group: Group, ev: *Evented, fiber: *Fiber) void {
+        group.lock(ev);
+        defer group.unlock(ev);
+        const list_ptr = group.listPtr();
+        const list = @atomicLoad(List, list_ptr, .monotonic);
+        if (list.cancel_requested) fiber.cancel_status = .{ .requested = true, .awaiting = .nothing };
+        const old_head = list.fibers.unpack();
+        if (old_head) |head| head.link.group.prev = fiber;
+        fiber.link.group.next = old_head;
+        @atomicStore(List, list_ptr, .{
+            .cancel_requested = list.cancel_requested,
+            .awaiter_delayed = list.awaiter_delayed,
+            .fibers = .pack(fiber),
+        }, .monotonic);
+    }
+
+    fn removeFiber(group: Group, ev: *Evented, fiber: *Fiber) ?*Fiber {
+        group.lock(ev);
+        defer group.unlock(ev);
+        const list_ptr = group.listPtr();
+        const list = @atomicLoad(List, list_ptr, .monotonic);
+        if (fiber.link.group.next) |next| next.link.group.prev = fiber.link.group.prev;
+        if (fiber.link.group.prev) |prev| {
+            prev.link.group.next = fiber.link.group.next;
+        } else if (fiber.link.group.next) |new_head| {
+            @atomicStore(List, list_ptr, .{
+                .cancel_requested = list.cancel_requested,
+                .awaiter_delayed = list.awaiter_delayed,
+                .fibers = .pack(new_head),
+            }, .monotonic);
+        } else if (@atomicLoad(Awaiter, group.awaiterPtr(), .monotonic).awaiter.unpack()) |awaiter| {
+            if (!awaiter.cancel_status.changeAwaiting(.group, .nothing) or list.cancel_requested) {
+                @atomicStore(List, list_ptr, .{
+                    .cancel_requested = false,
+                    .awaiter_delayed = false,
+                    .fibers = .null,
+                }, .release);
+                assert(awaiter.status.awaiting_group.ptr == group.ptr);
+                awaiter.status = .{ .queue_next = null };
+                return awaiter;
+            }
+            // Race with `Fiber.requestCancel`
+            @atomicStore(List, list_ptr, .{
+                .cancel_requested = false,
+                .awaiter_delayed = true,
+                .fibers = .null,
+            }, .monotonic);
+        } else @atomicStore(List, list_ptr, .{
+            .cancel_requested = false,
+            .awaiter_delayed = false,
+            .fibers = .null,
+        }, .release);
+        return null;
+    }
+
+    fn await(group: Group, ev: *Evented, awaiter: *Fiber) bool {
+        group.lock(ev);
+        defer group.unlock(ev);
+        if (@atomicLoad(List, group.listPtr(), .monotonic).fibers.unpack()) |_| {
+            if (group.registerAwaiter(awaiter) and awaiter.cancel_protection.check() == .unblocked) {
+                // The awaiter already had an unacknowledged cancelation request before
+                // attempting to await a group, so propagate the cancelation to the group.
+                assert(!group.cancelLocked(ev, null));
+            }
+            return false;
+        }
+        return true;
+    }
+
+    fn cancel(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool {
+        group.lock(ev);
+        defer group.unlock(ev);
+        return group.cancelLocked(ev, maybe_awaiter);
+    }
+
+    /// Assumes the mutex is held.
+    fn cancelLocked(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool {
+        const list_ptr = group.listPtr();
+        const list = @atomicRmw(
+            List,
+            list_ptr,
+            .Add,
+            .{ .cancel_requested = true, .awaiter_delayed = false, .fibers = .null },
+            .monotonic,
+        );
+        assert(!list.cancel_requested);
+        if (list.fibers.unpack()) |head| {
+            var maybe_fiber: ?*Fiber = head;
+            while (maybe_fiber) |fiber| {
+                fiber.requestCancel(ev);
+                maybe_fiber = fiber.link.group.next;
+            }
+            if (maybe_awaiter) |awaiter| _ = group.registerAwaiter(awaiter);
+            return false;
+        }
+        @atomicStore(
+            List,
+            list_ptr,
+            .{ .cancel_requested = false, .awaiter_delayed = false, .fibers = .null },
+            .release,
+        );
+        return if (maybe_awaiter) |_| true else list.awaiter_delayed;
+    }
+
+    /// Assumes the mutex is held.
+    fn registerAwaiter(group: Group, awaiter: *Fiber) bool {
+        assert(awaiter.status.queue_next == null);
+        awaiter.status = .{ .awaiting_group = group };
+        assert(@atomicRmw(
+            Awaiter,
+            group.awaiterPtr(),
+            .Add,
+            .{ .locked = false, .contended = false, .awaiter = .pack(awaiter) },
+            .monotonic,
+        ).awaiter == .null);
+        return awaiter.cancel_status.changeAwaiting(.nothing, .group);
+    }
+
+    const AsyncClosure = struct {
+        ev: *Evented,
+        group: Group,
+        fiber: *Fiber,
+        start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+
+        fn fromFiber(fiber: *Fiber) *Group.AsyncClosure {
+            return @ptrFromInt(Fiber.max_context_align.max(.of(Group.AsyncClosure)).backward(
+                @intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
+            ) - @sizeOf(Group.AsyncClosure));
+        }
+
+        fn contextPointer(
+            closure: *Group.AsyncClosure,
+        ) [*]align(Fiber.max_context_align.toByteUnits()) u8 {
+            return @alignCast(@as([*]u8, @ptrCast(closure)) + @sizeOf(Group.AsyncClosure));
+        }
+
+        fn entry() callconv(.naked) void {
+            switch (builtin.cpu.arch) {
+                .aarch64 => asm volatile (
+                    \\ mov x0, sp
+                    \\ b %[call]
+                    :
+                    : [call] "X" (&call),
+                ),
+                .x86_64 => asm volatile (
+                    \\ leaq 8(%%rsp), %%rdi
+                    \\ jmp %[call:P]
+                    :
+                    : [call] "X" (&call),
+                ),
+                else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+            }
+        }
+
+        fn call(
+            closure: *Group.AsyncClosure,
+            message: *const SwitchMessage,
+        ) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn {
+            message.handle(closure.ev);
+            assert(closure.fiber.status.queue_next == null);
+            log.debug("{*} performing group async", .{closure.fiber});
+            const result = closure.start(closure.contextPointer());
+            const ev = closure.ev;
+            const group = closure.group;
+            const fiber = closure.fiber;
+            const cancel_acknowledged = fiber.cancel_protection.acknowledged;
+            if (result) {
+                assert(!cancel_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
+            } else |err| switch (err) {
+                error.Canceled => assert(cancel_acknowledged), // group task returned `error.Canceled` but was never canceled
+            }
+            const awaiter = group.removeFiber(ev, fiber);
+            ev.backing_allocator_mutex.lockUncancelable(ev.io());
+            ev.yield(awaiter, .destroy);
+            unreachable; // switched to dead fiber
+        }
+    };
+};
+
+fn groupAsync(
+    userdata: ?*anyopaque,
+    type_erased: *Io.Group,
+    context: []const u8,
+    context_alignment: Alignment,
+    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return groupConcurrent(ev, type_erased, context, context_alignment, start) catch {
+        const fiber = Thread.current().currentFiber();
+        const pre_acknowledged = fiber.cancel_protection.acknowledged;
+        const result = start(context.ptr);
+        const post_acknowledged = fiber.cancel_protection.acknowledged;
+        if (result) {
+            if (pre_acknowledged) {
+                assert(post_acknowledged); // group task called `recancel` but was not canceled
+            } else {
+                assert(!post_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
+            }
+        } else |err| switch (err) {
+            // Don't swallow the cancelation: make it visible to the `Group.async` caller.
+            error.Canceled => {
+                assert(!pre_acknowledged); // group task called `recancel` but was not canceled
+                assert(post_acknowledged); // group task returned `error.Canceled` but was never canceled
+                recancel(userdata);
+            },
+        }
+    };
+}
+
+fn groupConcurrent(
+    userdata: ?*anyopaque,
+    type_erased: *Io.Group,
+    context: []const u8,
+    context_alignment: Alignment,
+    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+) Io.ConcurrentError!void {
+    assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
+    assert(context.len <= Fiber.max_context_size); // TODO
+
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const group: Group = .{ .ptr = type_erased };
+    const fiber = Fiber.create(ev) catch |err| switch (err) {
+        error.OutOfMemory => return error.ConcurrencyUnavailable,
+    };
+    log.debug("allocated {*}", .{fiber});
+
+    const closure: *Group.AsyncClosure = .fromFiber(fiber);
+    fiber.* = .{
+        .required_align = {},
+        .context = switch (builtin.cpu.arch) {
+            .aarch64 => .{
+                .sp = @intFromPtr(closure),
+                .fp = 0,
+                .pc = @intFromPtr(&Group.AsyncClosure.entry),
+            },
+            .x86_64 => .{
+                .rsp = @intFromPtr(closure) - @sizeOf(usize),
+                .rbp = 0,
+                .rip = @intFromPtr(&Group.AsyncClosure.entry),
+            },
+            else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+        },
+        .await_count = 0,
+        .link = .{ .group = .{ .prev = null, .next = null } },
+        .status = .{ .queue_next = null },
+        .cancel_status = .unrequested,
+        .cancel_protection = .unblocked,
+    };
+    closure.* = .{
+        .ev = ev,
+        .group = group,
+        .fiber = fiber,
+        .start = start,
+    };
+    @memcpy(closure.contextPointer(), context);
+    group.addFiber(ev, fiber);
+    const thread: *Thread = .current();
+    if (ev.schedule(thread, .{ .head = fiber, .tail = fiber })) thread.submit();
+}
+
+fn groupAwait(
+    userdata: ?*anyopaque,
+    type_erased: *Io.Group,
+    initial_token: *anyopaque,
+) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = initial_token;
+    ev.yield(null, .{ .group_await = .{ .ptr = type_erased } });
+}
+
+fn groupCancel(userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = initial_token;
+    ev.yield(null, .{ .group_cancel = .{ .ptr = type_erased } });
+}
+
+fn recancel(userdata: ?*anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const cancel_protection = &Thread.current().currentFiber().cancel_protection;
+    assert(cancel_protection.acknowledged);
+    cancel_protection.acknowledged = false;
+}
+
+fn swapCancelProtection(userdata: ?*anyopaque, new: Io.CancelProtection) Io.CancelProtection {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const cancel_protection = &Thread.current().currentFiber().cancel_protection;
+    defer cancel_protection.user = new;
+    return cancel_protection.user;
+}
+
+fn checkCancel(userdata: ?*anyopaque) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const fiber = Thread.current().currentFiber();
+    switch (fiber.cancel_protection.check()) {
+        .blocked => {},
+        .unblocked => if (@atomicLoad(Fiber.CancelStatus, &fiber.cancel_status, .monotonic).requested) {
+            fiber.cancel_protection.acknowledge();
+            return error.Canceled;
+        },
+    }
+}
+
+fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) Io.Cancelable!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    var await_count: u31, var result = for (futures, 0..) |future, future_index| {
+        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+        if (@atomicRmw(
+            ?*Fiber,
+            &future_fiber.link.awaiter,
+            .Xchg,
+            cancel_region.fiber,
+            .acq_rel,
+        )) |awaiter| {
+            assert(awaiter == Fiber.finished);
+            break .{ @intCast(future_index), future_index };
+        }
+    } else result: {
+        const await_count: u31 = @intCast(futures.len);
+        cancel_region.await(.select) catch |err| switch (err) {
+            error.Canceled => |e| break :result .{ await_count + 1, e },
+        };
+        ev.yield(null, .{ .await = 1 });
+        cancel_region.await(.nothing) catch |err| switch (err) {
+            error.Canceled => |e| break :result .{ await_count, e },
+        };
+        break :result .{ await_count - 1, futures.len };
+    };
+    for (futures[0 .. result catch futures.len], 0..) |future, future_index| {
+        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+        const awaiter = @atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, null, .monotonic);
+        if (awaiter == Fiber.finished) {
+            @atomicStore(?*Fiber, &future_fiber.link.awaiter, Fiber.finished, .monotonic);
+            result = if (result) |finished_index| @min(future_index, finished_index) else |e| e;
+        } else {
+            assert(awaiter == cancel_region.fiber);
+            await_count -= 1;
+        }
+    }
+    // Equivalent to `ev.yield(null, .{ .await = await_count });`,
+    // but avoiding a context switch in the common case.
+    switch (std.math.order(
+        @atomicRmw(i32, &cancel_region.fiber.await_count, .Sub, await_count, .monotonic),
+        await_count,
+    )) {
+        .lt => ev.yield(null, .{ .await = 0 }),
+        .eq => {},
+        .gt => unreachable,
+    }
+    return result;
+}
+
+fn futexWait(
+    userdata: ?*anyopaque,
+    ptr: *const u32,
+    expected: u32,
+    timeout: Io.Timeout,
+) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (builtin.single_threaded) unreachable; // Deadlock.
+    const timespec: ?linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = timespec: switch (timeout) {
+        .none => .{
+            null,
+            .awake,
+            linux.IORING_TIMEOUT_ABS,
+        },
+        .duration => |duration| {
+            const ns = duration.raw.toNanoseconds();
+            break :timespec .{
+                .{
+                    .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                    .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+                },
+                duration.clock,
+                0,
+            };
+        },
+        .deadline => |deadline| {
+            const ns = deadline.raw.toNanoseconds();
+            break :timespec .{
+                .{
+                    .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                    .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+                },
+                deadline.clock,
+                linux.IORING_TIMEOUT_ABS,
+            };
+        },
+    };
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const thread = try cancel_region.awaitIoUring();
+    thread.enqueue().* = .{
+        .opcode = .FUTEX_WAIT,
+        .flags = if (timespec) |_| linux.IOSQE_IO_LINK else 0,
+        .ioprio = 0,
+        .fd = @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = true }),
+        .off = expected,
+        .addr = @intFromPtr(ptr),
+        .len = 0,
+        .rw_flags = 0,
+        .user_data = @intFromPtr(cancel_region.fiber),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = std.math.maxInt(u32),
+        .resv = 0,
+    };
+    if (timespec) |*timespec_ptr| thread.enqueue().* = .{
+        .opcode = .LINK_TIMEOUT,
+        .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+        .ioprio = 0,
+        .fd = 0,
+        .off = 0,
+        .addr = @intFromPtr(timespec_ptr),
+        .len = 1,
+        .rw_flags = timeout_flags | @as(u32, switch (clock) {
+            .real => linux.IORING_TIMEOUT_REALTIME,
+            else => 0,
+            .boot => linux.IORING_TIMEOUT_BOOTTIME,
+        }),
+        .user_data = @intFromEnum(Completion.UserData.wakeup),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = 0,
+        .resv = 0,
+    };
+    ev.yield(null, .nothing);
+    switch (cancel_region.errno()) {
+        .SUCCESS => {}, // notified by `wake()`
+        .INTR, .CANCELED => {}, // caller's responsibility to retry
+        .AGAIN => {}, // ptr.* != expect
+        .INVAL => {}, // possibly timeout overflow
+        .TIMEDOUT => unreachable,
+        .FAULT => recoverableOsBugDetected(), // ptr was invalid
+        else => recoverableOsBugDetected(),
+    }
+}
+
+fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (builtin.single_threaded) unreachable; // Deadlock.
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
+    };
+    thread.enqueue().* = .{
+        .opcode = .FUTEX_WAIT,
+        .flags = 0,
+        .ioprio = 0,
+        .fd = @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = true }),
+        .off = expected,
+        .addr = @intFromPtr(ptr),
+        .len = 0,
+        .rw_flags = 0,
+        .user_data = @intFromPtr(cancel_region.fiber),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = std.math.maxInt(u32),
+        .resv = 0,
+    };
+    ev.yield(null, .nothing);
+    switch (cancel_region.errno()) {
+        .SUCCESS => {}, // notified by `wake()`
+        .INTR, .CANCELED => {}, // caller's responsibility to retry
+        .AGAIN => {}, // ptr.* != expect
+        .INVAL => {}, // possibly timeout overflow
+        .FAULT => recoverableOsBugDetected(), // ptr was invalid
+        else => recoverableOsBugDetected(),
+    }
+}
+
+fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    if (builtin.single_threaded) unreachable; // Nothing to wake up.
+    const thread: *Thread = .current();
+    thread.enqueue().* = .{
+        .opcode = .FUTEX_WAKE,
+        .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+        .ioprio = 0,
+        .fd = @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = true }),
+        .off = max_waiters,
+        .addr = @intFromPtr(ptr),
+        .len = 0,
+        .rw_flags = 0,
+        .user_data = @intFromEnum(Completion.UserData.futex_wake),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = std.math.maxInt(u32),
+        .resv = 0,
+    };
+    thread.submit();
+}
+
+fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    switch (operation) {
+        .file_read_streaming => |o| return .{
+            .file_read_streaming = ev.fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                else => |e| e,
+            },
+        },
+        .file_write_streaming => |o| return .{
+            .file_write_streaming = ev.fileWriteStreaming(o.file, o.header, o.data, o.splat) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                else => |e| e,
+            },
+        },
+        .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
+    }
+}
+
+fn fileReadStreaming(ev: *Evented, file: File, data: []const []u8) File.Reader.Error!usize {
+    var iovecs_buffer: [max_iovecs_len]iovec = undefined;
+    var i: usize = 0;
+    for (data) |buf| {
+        if (iovecs_buffer.len - i == 0) break;
+        if (buf.len != 0) {
+            iovecs_buffer[i] = .{ .base = buf.ptr, .len = buf.len };
+            i += 1;
+        }
+    }
+    const dest = iovecs_buffer[0..i];
+    assert(dest[0].len > 0);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.preadv(&cancel_region, file.handle, dest, null);
+}
+
+fn fileWriteStreaming(
+    ev: *Evented,
+    file: File,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+) File.Writer.Error!usize {
+    var iovecs: [max_iovecs_len]iovec_const = undefined;
+    var iovlen: iovlen_t = 0;
+    addBuf(&iovecs, &iovlen, header);
+    for (data[0 .. data.len - 1]) |bytes| addBuf(&iovecs, &iovlen, bytes);
+    const pattern = data[data.len - 1];
+    if (iovecs.len - iovlen != 0) switch (splat) {
+        0 => {},
+        1 => addBuf(&iovecs, &iovlen, pattern),
+        else => switch (pattern.len) {
+            0 => {},
+            1 => {
+                var backup_buffer: [splat_buffer_size]u8 = undefined;
+                const splat_buffer = &backup_buffer;
+                const memset_len = @min(splat_buffer.len, splat);
+                const buf = splat_buffer[0..memset_len];
+                @memset(buf, pattern[0]);
+                addBuf(&iovecs, &iovlen, buf);
+                var remaining_splat = splat - buf.len;
+                while (remaining_splat > splat_buffer.len and iovecs.len - iovlen != 0) {
+                    assert(buf.len == splat_buffer.len);
+                    addBuf(&iovecs, &iovlen, splat_buffer);
+                    remaining_splat -= splat_buffer.len;
+                }
+                addBuf(&iovecs, &iovlen, splat_buffer[0..@min(remaining_splat, splat_buffer.len)]);
+            },
+            else => for (0..@min(splat, iovecs.len - iovlen)) |_| {
+                addBuf(&iovecs, &iovlen, pattern);
+            },
+        },
+    };
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.pwritev(&cancel_region, file.handle, iovecs[0..iovlen], null);
+}
+
+fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!i32 {
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        const rc = linux.ioctl(o.file.handle, @bitCast(o.code), @intFromPtr(o.arg));
+        switch (linux.errno(rc)) {
+            .SUCCESS => return @bitCast(@as(u32, @truncate(rc))),
+            .INTR => continue,
+            else => |err| return -@as(i32, @intFromEnum(err)),
+        }
+    }
+}
+
+fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    batchDrainSubmitted(batch, &cancel_region, false) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
+        else => |e| return e,
+    };
+    while (true) {
+        batchDrainReady(batch) catch |err| switch (err) {
+            error.Timeout => unreachable, // no timeout
+        };
+        if (batch.completed.head != .none) return;
+        ev.yield(null, .{ .batch_await = batch });
+    }
+}
+
+fn batchAwaitConcurrent(
+    userdata: ?*anyopaque,
+    batch: *Io.Batch,
+    timeout: Io.Timeout,
+) Io.Batch.AwaitConcurrentError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try batchDrainSubmitted(batch, &cancel_region, true);
+    const timespec: linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = while (true) {
+        batchDrainReady(batch) catch |err| switch (err) {
+            error.Timeout => unreachable, // no timeout
+        };
+        if (batch.completed.head != .none) return;
+        switch (timeout) {
+            .none => ev.yield(null, .{ .batch_await = batch }),
+            .duration => |duration| {
+                const ns = duration.raw.toNanoseconds();
+                break .{
+                    .{
+                        .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                        .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+                    },
+                    duration.clock,
+                    0,
+                };
+            },
+            .deadline => |deadline| {
+                const ns = deadline.raw.toNanoseconds();
+                break .{
+                    .{
+                        .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                        .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+                    },
+                    deadline.clock,
+                    linux.IORING_TIMEOUT_ABS,
+                };
+            },
+        }
+    };
+    {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .TIMEOUT,
+            .flags = 0,
             .ioprio = 0,
-            .fd = cancel_thread.io_uring.fd,
-            .off = @intFromPtr(future_fiber),
-            .addr = 0,
-            .len = @bitCast(-@as(i32, @intFromEnum(std.os.linux.E.INTR))),
+            .fd = 0,
+            .off = 0,
+            .addr = @intFromPtr(&timespec),
+            .len = 1,
+            .rw_flags = timeout_flags | @as(u32, switch (clock) {
+                .real => linux.IORING_TIMEOUT_REALTIME,
+                else => 0,
+                .boot => linux.IORING_TIMEOUT_BOOTTIME,
+            }),
+            .user_data = @intFromPtr(&batch.context) | 0b11,
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+    }
+    while (batch.completed.head == .none) {
+        ev.yield(null, .{ .batch_await = batch });
+        batchDrainReady(batch) catch |err| switch (err) {
+            error.Timeout => |e| return if (batch.completed.head == .none) e,
+        };
+        if (batch.completed.head == .none) continue;
+    }
+    const thread = try cancel_region.awaitIoUring();
+    thread.enqueue().* = .{
+        .opcode = .TIMEOUT_REMOVE,
+        .flags = 0,
+        .ioprio = 0,
+        .fd = 0,
+        .off = 0,
+        .addr = @intFromPtr(&batch.context) | 0b11,
+        .len = 0,
+        .rw_flags = 0,
+        .user_data = @intFromPtr(cancel_region.fiber),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = 0,
+        .resv = 0,
+    };
+    ev.yield(null, .nothing);
+    switch (cancel_region.errno()) {
+        .SUCCESS => return,
+        .BUSY, .NOENT => {},
+        else => |err| unexpectedErrno(err) catch {},
+    }
+    while (true) {
+        batchDrainReady(batch) catch |err| switch (err) {
+            error.Timeout => return,
+        };
+        ev.yield(null, .{ .batch_await = batch });
+    }
+}
+
+/// If `concurrency` is false, `error.ConcurrencyUnavailable` is unreachable.
+fn batchDrainSubmitted(
+    batch: *Io.Batch,
+    cancel_region: *CancelRegion,
+    concurrency: bool,
+) (Io.ConcurrentError || Io.Cancelable)!void {
+    var index = batch.submitted.head;
+    if (index == .none) return;
+    errdefer batch.submitted.head = index;
+    const thread = try cancel_region.awaitIoUring();
+    while (index != .none) {
+        const storage = &batch.storage[index.toIndex()];
+        const next_index = storage.submission.node.next;
+        if (@as(?Io.Operation.Result, operation: switch (storage.submission.operation) {
+            .file_read_streaming => |o| {
+                const buffer = for (o.data) |buffer| {
+                    if (buffer.len != 0) break buffer;
+                } else break :operation .{ .file_read_streaming = 0 };
+                const fd = o.file.handle;
+                storage.* = .{ .pending = .{
+                    .node = .{ .prev = batch.pending.tail, .next = .none },
+                    .tag = .file_read_streaming,
+                    .context = undefined,
+                } };
+                thread.enqueue().* = .{
+                    .opcode = .READ,
+                    .flags = 0,
+                    .ioprio = 0,
+                    .fd = fd,
+                    .off = std.math.maxInt(u64),
+                    .addr = @intFromPtr(buffer.ptr),
+                    .len = @min(buffer.len, 0xfffff000),
+                    .rw_flags = 0,
+                    .user_data = @intFromPtr(&storage.pending.context) | 0b10,
+                    .buf_index = 0,
+                    .personality = 0,
+                    .splice_fd_in = 0,
+                    .addr3 = 0,
+                    .resv = 0,
+                };
+                break :operation null;
+            },
+            .file_write_streaming => |o| {
+                const buffer = buffer: {
+                    if (o.header.len != 0) break :buffer o.header;
+                    for (o.data[0 .. o.data.len - 1]) |buffer| {
+                        if (buffer.len != 0) break :buffer buffer;
+                    }
+                    if (o.splat > 0) break :buffer o.data[o.data.len - 1];
+                    break :operation .{ .file_write_streaming = 0 };
+                };
+                const fd = o.file.handle;
+                storage.* = .{ .pending = .{
+                    .node = .{ .prev = batch.pending.tail, .next = .none },
+                    .tag = .file_write_streaming,
+                    .context = undefined,
+                } };
+                thread.enqueue().* = .{
+                    .opcode = .WRITE,
+                    .flags = 0,
+                    .ioprio = 0,
+                    .fd = fd,
+                    .off = std.math.maxInt(u64),
+                    .addr = @intFromPtr(buffer.ptr),
+                    .len = @min(buffer.len, 0xfffff000),
+                    .rw_flags = 0,
+                    .user_data = @intFromPtr(&storage.pending.context) | 0b10,
+                    .buf_index = 0,
+                    .personality = 0,
+                    .splice_fd_in = 0,
+                    .addr3 = 0,
+                    .resv = 0,
+                };
+                break :operation null;
+            },
+            .device_io_control => |o| if (concurrency)
+                return error.ConcurrencyUnavailable
+            else
+                .{ .device_io_control = try deviceIoControl(&o) },
+        })) |result| {
+            switch (batch.completed.tail) {
+                .none => batch.completed.head = index,
+                else => |tail_index| batch.storage[tail_index.toIndex()].completion.node.next = index,
+            }
+            batch.completed.tail = index;
+            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+        } else {
+            switch (batch.pending.tail) {
+                .none => batch.pending.head = index,
+                else => |tail_index| batch.storage[tail_index.toIndex()].pending.node.next = index,
+            }
+            batch.pending.tail = index;
+            storage.pending.context[0] = @intFromPtr(batch);
+        }
+        index = next_index;
+    }
+    batch.submitted = .{ .head = .none, .tail = .none };
+}
+
+fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void {
+    while (@atomicRmw(?*anyopaque, &batch.context, .Xchg, null, .acquire)) |head| {
+        var next: usize = @intFromPtr(head);
+        var timeout = false;
+        while (cond: switch (@as(u2, @truncate(next))) {
+            0b00 => if (timeout) return error.Timeout else false,
+            0b01 => {
+                assert(!timeout);
+                return error.Timeout;
+            },
+            0b10 => true,
+            0b11 => {
+                assert(!timeout);
+                timeout = true;
+                break :cond true;
+            },
+        }) {
+            var context: *Io.Operation.Storage.Pending.Context = @ptrFromInt(next & ~@as(usize, 0b11));
+            next = context[0];
+            const completion: Completion = .{
+                .result = @bitCast(@as(u32, @intCast(context[1]))),
+                .flags = @intCast(context[2]),
+            };
+            const pending: *Io.Operation.Storage.Pending = @fieldParentPtr("context", context);
+            const storage: *Io.Operation.Storage = @fieldParentPtr("pending", pending);
+            const index: Io.Operation.OptionalIndex = .fromIndex(storage - batch.storage.ptr);
+            assert(completion.flags & linux.IORING_CQE_F_SKIP == 0);
+            switch (pending.node.prev) {
+                .none => batch.pending.head = pending.node.next,
+                else => |prev_index| batch.storage[prev_index.toIndex()].pending.node.next =
+                    pending.node.next,
+            }
+            switch (pending.node.next) {
+                .none => batch.pending.tail = pending.node.prev,
+                else => |prev_index| batch.storage[prev_index.toIndex()].pending.node.prev =
+                    pending.node.prev,
+            }
+            if (@as(?Io.Operation.Result, result: switch (pending.tag) {
+                .file_read_streaming => .{
+                    .file_read_streaming = switch (completion.errno()) {
+                        .SUCCESS => @as(u32, @bitCast(completion.result)),
+                        .INTR => 0,
+                        .CANCELED => break :result null,
+                        .INVAL => |err| errnoBug(err),
+                        .FAULT => |err| errnoBug(err),
+                        .AGAIN => error.WouldBlock,
+                        .BADF => |err| errnoBug(err), // File descriptor used after closed
+                        .IO => error.InputOutput,
+                        .ISDIR => error.IsDir,
+                        .NOBUFS => error.SystemResources,
+                        .NOMEM => error.SystemResources,
+                        .NOTCONN => error.SocketUnconnected,
+                        .CONNRESET => error.ConnectionResetByPeer,
+                        else => |err| unexpectedErrno(err),
+                    },
+                },
+                .file_write_streaming => .{
+                    .file_write_streaming = switch (completion.errno()) {
+                        .SUCCESS => @as(u32, @bitCast(completion.result)),
+                        .INTR => 0,
+                        .CANCELED => break :result null,
+                        .INVAL => |err| errnoBug(err),
+                        .FAULT => |err| errnoBug(err),
+                        .AGAIN => error.WouldBlock,
+                        .BADF => error.NotOpenForWriting, // Can be a race condition.
+                        .DESTADDRREQ => |err| errnoBug(err), // `connect` was never called.
+                        .DQUOT => error.DiskQuota,
+                        .FBIG => error.FileTooBig,
+                        .IO => error.InputOutput,
+                        .NOSPC => error.NoSpaceLeft,
+                        .PERM => error.PermissionDenied,
+                        .PIPE => error.BrokenPipe,
+                        .CONNRESET => |err| errnoBug(err), // Not a socket handle.
+                        .BUSY => error.DeviceBusy,
+                        else => |err| unexpectedErrno(err),
+                    },
+                },
+                .device_io_control => unreachable,
+            })) |result| {
+                switch (batch.completed.tail) {
+                    .none => batch.completed.head = index,
+                    else => |tail_index| batch.storage[tail_index.toIndex()].completion.node.next =
+                        index,
+                }
+                storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+                batch.completed.tail = index;
+            } else {
+                switch (batch.unused.tail) {
+                    .none => batch.unused.head = index,
+                    else => |tail_index| batch.storage[tail_index.toIndex()].unused.next = index,
+                }
+                storage.* = .{ .unused = .{ .prev = batch.unused.tail, .next = .none } };
+                batch.unused.tail = index;
+            }
+        }
+    }
+}
+
+fn batchCancel(userdata: ?*anyopaque, batch: *Io.Batch) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    batchDrainReady(batch) catch |err| switch (err) {
+        error.Timeout => unreachable, // no timeout
+    };
+    var index = batch.pending.head;
+    if (index == .none) return;
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
+    };
+    while (index != .none) {
+        const pending = &batch.storage[index.toIndex()].pending;
+        thread.enqueue().* = .{
+            .opcode = .ASYNC_CANCEL,
+            .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+            .ioprio = 0,
+            .fd = 0,
+            .off = 0,
+            .addr = @intFromPtr(&pending.context) | 0b10,
+            .len = 0,
             .rw_flags = 0,
-            .user_data = @intFromEnum(Completion.UserData.cleanup),
+            .user_data = @intFromEnum(Completion.UserData.wakeup),
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = 0,
             .addr3 = 0,
             .resv = 0,
         };
+        index = pending.node.next;
+    }
+    while (batch.pending.head != .none) batchDrainReady(batch) catch |err| switch (err) {
+        error.Timeout => unreachable, // no timeout
     };
-    await(userdata, any_future, result, result_alignment);
 }
 
-fn cancelRequested(userdata: ?*anyopaque) bool {
-    _ = userdata;
-    return @atomicLoad(?*Thread, &Thread.current().currentFiber().cancel_thread, .acquire) == Thread.canceling;
+fn dirCreateDir(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+) Dir.CreateDirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .MKDIRAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir.handle,
+            .off = 0,
+            .addr = @intFromPtr(sub_path_posix.ptr),
+            .len = permissions.toMode(),
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .ACCES => return error.AccessDenied,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .PERM => return error.PermissionDenied,
+            .DQUOT => return error.DiskQuota,
+            .EXIST => return error.PathAlreadyExists,
+            .FAULT => |err| return errnoBug(err),
+            .LOOP => return error.SymLinkLoop,
+            .MLINK => return error.LinkQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .ROFS => return error.ReadOnlyFileSystem,
+            // dragonfly: when dir_fd is unlinked from filesystem
+            .NOTCONN => return error.FileNotFound,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
 }
 
-fn createFile(
+fn dirCreateDirPath(
     userdata: ?*anyopaque,
-    dir: Io.Dir,
+    dir: Dir,
     sub_path: []const u8,
-    flags: Io.File.CreateFlags,
-) Io.File.OpenError!Io.File {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const thread: *Thread = .current();
-    const iou = &thread.io_uring;
-    const fiber = thread.currentFiber();
-    try fiber.enterCancelRegion(thread);
+    permissions: Dir.Permissions,
+) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var it = Dir.path.componentIterator(sub_path);
+    var status: Dir.CreatePathStatus = .existed;
+    var component = it.last() orelse return error.BadPathName;
+    while (true) {
+        if (dirCreateDir(ev, dir, component.path, permissions)) |_| {
+            status = .created;
+        } else |err| switch (err) {
+            error.PathAlreadyExists => {
+                // stat the file and return an error if it's not a directory
+                // this is important because otherwise a dangling symlink
+                // could cause an infinite loop
+                const fstat = try dirStatFile(ev, dir, component.path, .{});
+                if (fstat.kind != .directory) return error.NotDir;
+            },
+            error.FileNotFound => |e| {
+                component = it.previous() orelse return e;
+                continue;
+            },
+            else => |e| return e,
+        }
+        component = it.next() orelse return status;
+    }
+}
+
+fn dirCreateDirPathOpen(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+    options: Dir.OpenOptions,
+) Dir.CreateDirPathOpenError!Dir {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return dirOpenDir(ev, dir, sub_path, options) catch |err| switch (err) {
+        error.FileNotFound => {
+            _ = try dirCreateDirPath(ev, dir, sub_path, permissions);
+            return dirOpenDir(ev, dir, sub_path, options);
+        },
+        else => |e| return e,
+    };
+}
+
+fn dirOpenDir(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.OpenOptions,
+) Dir.OpenError!Dir {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return .{
+        .handle = ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
+            .ACCMODE = .RDONLY,
+            .DIRECTORY = true,
+            .NOFOLLOW = !options.follow_symlinks,
+            .CLOEXEC = true,
+            .PATH = !options.iterate,
+        }, 0) catch |err| switch (err) {
+            error.IsDir => return errnoBug(.ISDIR),
+            error.WouldBlock => return errnoBug(.AGAIN),
+            error.FileTooBig => return errnoBug(.FBIG),
+            error.NoSpaceLeft => return errnoBug(.NOSPC),
+            error.DeviceBusy => return errnoBug(.BUSY), // O_EXCL not passed
+            error.FileBusy => return errnoBug(.TXTBSY),
+            error.PathAlreadyExists => return errnoBug(.EXIST), // Not creating.
+            error.PipeBusy => return error.Unexpected, // Not opening a pipe.
+            error.AntivirusInterference => unreachable, // Windows-only
+            error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
+            else => |e| return e,
+        },
+    };
+}
+
+fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.stat(&cancel_region, dir.handle);
+}
+
+fn dirStatFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.StatFileOptions,
+) Dir.StatFileError!File.Stat {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.statx(&cancel_region, dir.handle, sub_path_posix, linux.AT.NO_AUTOMOUNT |
+        @as(u32, if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW));
+}
+
+fn dirAccess(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.AccessOptions,
+) Dir.AccessError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const mode: u32 =
+        @as(u32, if (options.read) linux.R_OK else 0) |
+        @as(u32, if (options.write) linux.W_OK else 0) |
+        @as(u32, if (options.execute) linux.X_OK else 0);
+    const flags: u32 = if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW;
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.faccessat(dir.handle, sub_path_posix, mode, flags))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .TXTBSY => return error.FileBusy,
+            .NOTDIR => return error.FileNotFound,
+            .NOENT => return error.FileNotFound,
+            .NAMETOOLONG => return error.NameTooLong,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .IO => return error.InputOutput,
+            .NOMEM => return error.SystemResources,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirCreateFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    flags: File.CreateFlags,
+) File.OpenError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
 
-    const posix = std.posix;
-    const sub_path_c = try posix.toPosixPath(sub_path);
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var os_flags: posix.O = .{
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const fd = try ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
         .ACCMODE = if (flags.read) .RDWR else .WRONLY,
         .CREAT = true,
         .TRUNC = flags.truncate,
         .EXCL = flags.exclusive,
-    };
-    if (@hasField(posix.O, "LARGEFILE")) os_flags.LARGEFILE = true;
-    if (@hasField(posix.O, "CLOEXEC")) os_flags.CLOEXEC = true;
+        .CLOEXEC = true,
+    }, flags.permissions.toMode());
+    errdefer ev.close(fd);
 
-    // Use the O locking flags if the os supports them to acquire the lock
-    // atomically. Note that the NONBLOCK flag is removed after the openat()
-    // call is successful.
-    const has_flock_open_flags = @hasField(posix.O, "EXLOCK");
-    if (has_flock_open_flags) switch (flags.lock) {
+    switch (flags.lock) {
         .none => {},
-        .shared => {
-            os_flags.SHLOCK = true;
-            os_flags.NONBLOCK = flags.lock_nonblocking;
-        },
-        .exclusive => {
-            os_flags.EXLOCK = true;
-            os_flags.NONBLOCK = flags.lock_nonblocking;
-        },
-    };
-    const have_flock = @TypeOf(posix.system.flock) != void;
+        .shared, .exclusive => try ev.flock(
+            &cancel_region,
+            fd,
+            flags.lock,
+            if (flags.lock_nonblocking) .nonblocking else .blocking,
+        ),
+    }
+
+    return .{ .handle = fd, .flags = .{ .nonblocking = false } };
+}
+
+fn dirCreateFileAtomic(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    dest_path: []const u8,
+    options: Dir.CreateFileAtomicOptions,
+) Dir.CreateFileAtomicError!File.Atomic {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    // Linux has O_TMPFILE, but linkat() does not support AT_REPLACE, so it's
+    // useless when we have to make up a bogus path name to do the rename()
+    // anyway.
+    if (!options.replace) tmpfile: {
+        const flags: linux.O = if (@hasField(linux.O, "TMPFILE")) .{
+            .ACCMODE = .RDWR,
+            .TMPFILE = true,
+            .DIRECTORY = true,
+            .CLOEXEC = true,
+        } else if (@hasField(linux.O, "TMPFILE0") and !@hasField(linux.O, "TMPFILE2")) .{
+            .ACCMODE = .RDWR,
+            .TMPFILE0 = true,
+            .TMPFILE1 = true,
+            .DIRECTORY = true,
+            .CLOEXEC = true,
+        } else break :tmpfile;
+
+        const dest_dirname = Dir.path.dirname(dest_path);
+        if (dest_dirname) |dirname| {
+            // This has a nice side effect of preemptively triggering EISDIR or
+            // ENOENT, avoiding the ambiguity below.
+            _ = dirCreateDirPath(ev, dir, dirname, .default_dir) catch |err| switch (err) {
+                // None of these make sense in this context.
+                error.IsDir,
+                error.Streaming,
+                error.DiskQuota,
+                error.PathAlreadyExists,
+                error.LinkQuotaExceeded,
+                error.PipeBusy,
+                error.FileTooBig,
+                error.DeviceBusy,
+                error.FileLocksUnsupported,
+                error.FileBusy,
+                => return error.Unexpected,
 
-    if (have_flock and !has_flock_open_flags and flags.lock != .none) {
-        @panic("TODO");
+                else => |e| return e,
+            };
+        }
+
+        var path_buffer: [PATH_MAX]u8 = undefined;
+        const sub_path_posix = try pathToPosix(dest_dirname orelse ".", &path_buffer);
+
+        var cancel_region: CancelRegion = .init();
+        defer cancel_region.deinit();
+        return .{
+            .file = .{
+                .handle = ev.openat(
+                    &cancel_region,
+                    dir.handle,
+                    sub_path_posix,
+                    flags,
+                    options.permissions.toMode(),
+                ) catch |err| switch (err) {
+                    error.IsDir, error.FileNotFound => {
+                        // Ambiguous error code. It might mean the file system
+                        // does not support O_TMPFILE. Therefore, we must fall
+                        // back to not using O_TMPFILE.
+                        break :tmpfile;
+                    },
+                    error.FileTooBig => return errnoBug(.FBIG),
+                    error.DeviceBusy => return errnoBug(.BUSY), // O_EXCL not passed
+                    error.PathAlreadyExists => return errnoBug(.EXIST), // Not creating.
+                    error.PipeBusy => return error.Unexpected, // Not opening a pipe.
+                    error.AntivirusInterference => unreachable, // Windows-only
+                    error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
+                    else => |e| return e,
+                },
+                .flags = .{ .nonblocking = false },
+            },
+            .file_basename_hex = 0,
+            .dest_sub_path = dest_path,
+            .file_open = true,
+            .file_exists = false,
+            .close_dir_on_deinit = false,
+            .dir = dir,
+        };
     }
 
-    if (has_flock_open_flags and flags.lock_nonblocking) {
-        @panic("TODO");
+    if (Dir.path.dirname(dest_path)) |dirname| {
+        const new_dir = if (options.make_path)
+            dirCreateDirPathOpen(ev, dir, dirname, .default_dir, .{}) catch |err| switch (err) {
+                // None of these make sense in this context.
+                error.IsDir,
+                error.Streaming,
+                error.DiskQuota,
+                error.PathAlreadyExists,
+                error.LinkQuotaExceeded,
+                error.PipeBusy,
+                error.FileTooBig,
+                error.FileLocksUnsupported,
+                error.DeviceBusy,
+                => return error.Unexpected,
+
+                else => |e| return e,
+            }
+        else
+            try dirOpenDir(ev, dir, dirname, .{});
+
+        return ev.atomicFileInit(Dir.path.basename(dest_path), options.permissions, new_dir, true);
     }
 
-    getSqe(iou).* = .{
-        .opcode = .OPENAT,
-        .flags = 0,
-        .ioprio = 0,
-        .fd = dir.handle,
-        .off = 0,
-        .addr = @intFromPtr(&sub_path_c),
-        .len = @intCast(flags.mode),
-        .rw_flags = @bitCast(os_flags),
-        .user_data = @intFromPtr(fiber),
-        .buf_index = 0,
-        .personality = 0,
-        .splice_fd_in = 0,
-        .addr3 = 0,
-        .resv = 0,
-    };
+    return ev.atomicFileInit(dest_path, options.permissions, dir, false);
+}
 
-    el.yield(null, .nothing);
-    fiber.exitCancelRegion(thread);
+fn atomicFileInit(
+    ev: *Evented,
+    dest_basename: []const u8,
+    permissions: File.Permissions,
+    dir: Dir,
+    close_dir_on_deinit: bool,
+) Dir.CreateFileAtomicError!File.Atomic {
+    while (true) {
+        var random_integer: u64 = undefined;
+        random(ev, @ptrCast(&random_integer));
+        const tmp_sub_path = std.fmt.hex(random_integer);
+        const file = dirCreateFile(ev, dir, &tmp_sub_path, .{
+            .permissions = permissions,
+            .exclusive = true,
+        }) catch |err| switch (err) {
+            error.PathAlreadyExists => continue,
+            error.DeviceBusy => continue,
+            error.FileBusy => continue,
 
-    const completion = fiber.resultPointer(Completion);
-    switch (errno(completion.result)) {
-        .SUCCESS => return .{ .handle = completion.result },
-        .INTR => unreachable,
-        .CANCELED => return error.Canceled,
+            error.IsDir => return error.Unexpected, // No path components.
+            error.FileTooBig => return error.Unexpected, // Creating, not opening.
+            error.FileLocksUnsupported => return error.Unexpected, // Not asking for locks.
+            error.PipeBusy => return error.Unexpected, // Not opening a pipe.
 
-        .FAULT => unreachable,
-        .INVAL => return error.BadPathName,
-        .BADF => unreachable,
-        .ACCES => return error.AccessDenied,
-        .FBIG => return error.FileTooBig,
-        .OVERFLOW => return error.FileTooBig,
-        .ISDIR => return error.IsDir,
-        .LOOP => return error.SymLinkLoop,
-        .MFILE => return error.ProcessFdQuotaExceeded,
-        .NAMETOOLONG => return error.NameTooLong,
-        .NFILE => return error.SystemFdQuotaExceeded,
-        .NODEV => return error.NoDevice,
-        .NOENT => return error.FileNotFound,
-        .NOMEM => return error.SystemResources,
-        .NOSPC => return error.NoSpaceLeft,
-        .NOTDIR => return error.NotDir,
-        .PERM => return error.PermissionDenied,
-        .EXIST => return error.PathAlreadyExists,
-        .BUSY => return error.DeviceBusy,
-        .OPNOTSUPP => return error.FileLocksUnsupported,
-        .AGAIN => return error.WouldBlock,
-        .TXTBSY => return error.FileBusy,
-        .NXIO => return error.NoDevice,
-        else => |err| return posix.unexpectedErrno(err),
+            else => |e| return e,
+        };
+        return .{
+            .file = file,
+            .file_basename_hex = random_integer,
+            .dest_sub_path = dest_basename,
+            .file_open = true,
+            .file_exists = true,
+            .close_dir_on_deinit = close_dir_on_deinit,
+            .dir = dir,
+        };
     }
 }
 
-fn fileOpen(
+fn dirOpenFile(
     userdata: ?*anyopaque,
-    dir: Io.Dir,
+    dir: Dir,
     sub_path: []const u8,
-    flags: Io.File.OpenFlags,
-) Io.File.OpenError!Io.File {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const thread: *Thread = .current();
-    const iou = &thread.io_uring;
-    const fiber = thread.currentFiber();
-    try fiber.enterCancelRegion(thread);
+    flags: File.OpenFlags,
+) File.OpenError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
 
-    const posix = std.posix;
-    const sub_path_c = try posix.toPosixPath(sub_path);
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var os_flags: posix.O = .{
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const fd = try ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
         .ACCMODE = switch (flags.mode) {
             .read_only => .RDONLY,
             .write_only => .WRONLY,
             .read_write => .RDWR,
         },
+        .NOCTTY = !flags.allow_ctty,
+        .NOFOLLOW = !flags.follow_symlinks,
+        .CLOEXEC = true,
+        .PATH = flags.path_only,
+    }, 0);
+    errdefer ev.close(fd);
+
+    if (!flags.allow_directory) {
+        const is_dir = is_dir: {
+            const s = ev.stat(&cancel_region, fd) catch |err| switch (err) {
+                // The directory-ness is either unknown or unknowable
+                error.Streaming => break :is_dir false,
+                else => |e| return e,
+            };
+            break :is_dir s.kind == .directory;
+        };
+        if (is_dir) return error.IsDir;
+    }
+
+    switch (flags.lock) {
+        .none => {},
+        .shared, .exclusive => try ev.flock(
+            &cancel_region,
+            fd,
+            flags.lock,
+            if (flags.lock_nonblocking) .nonblocking else .blocking,
+        ),
+    }
+
+    return .{ .handle = fd, .flags = .{ .nonblocking = false } };
+}
+
+fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    for (dirs) |dir| ev.close(dir.handle);
+}
+
+fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var buffer_index: usize = 0;
+    while (buffer.len - buffer_index != 0) {
+        if (dr.end - dr.index == 0) {
+            // Refill the buffer, unless we've already created references to
+            // buffered data.
+            if (buffer_index != 0) break;
+            var cancel_region: CancelRegion = .init();
+            defer cancel_region.deinit();
+            if (dr.state == .reset) {
+                ev.lseek(&cancel_region, dr.dir.handle, 0, linux.SEEK.SET) catch |err| switch (err) {
+                    error.Unseekable => return error.Unexpected,
+                    else => |e| return e,
+                };
+                dr.state = .reading;
+            }
+            const n = while (true) {
+                try cancel_region.await(.nothing);
+                const rc = linux.getdents64(dr.dir.handle, dr.buffer.ptr, dr.buffer.len);
+                switch (linux.errno(rc)) {
+                    .SUCCESS => break rc,
+                    .INTR => continue,
+                    .BADF => |err| return errnoBug(err), // Dir is invalid or was opened without iteration ability.
+                    .FAULT => |err| return errnoBug(err),
+                    .NOTDIR => |err| return errnoBug(err),
+                    // To be consistent across platforms, iteration
+                    // ends if the directory being iterated is deleted
+                    // during iteration. This matches the behavior of
+                    // non-Linux, non-WASI UNIX platforms.
+                    .NOENT => {
+                        dr.state = .finished;
+                        return 0;
+                    },
+                    // This can occur when reading /proc/$PID/net, or
+                    // if the provided buffer is too small. Neither
+                    // scenario is intended to be handled by this API.
+                    .INVAL => return error.Unexpected,
+                    .ACCES => return error.AccessDenied, // Lacking permission to iterate this directory.
+                    else => |err| return unexpectedErrno(err),
+                }
+            };
+            if (n == 0) {
+                dr.state = .finished;
+                return 0;
+            }
+            dr.index = 0;
+            dr.end = n;
+        }
+        // Linux aligns the header by padding after the null byte of the name
+        // to align the next entry. This means we can find the end of the name
+        // by looking at only the 8 bytes before the next record. However since
+        // file names are usually short it's better to keep the machine code
+        // simpler.
+        //
+        // Furthermore, I observed qemu user mode to not align this struct, so
+        // this code makes the conservative choice to not assume alignment.
+        const linux_entry: *align(1) linux.dirent64 = @ptrCast(&dr.buffer[dr.index]);
+        const next_index = dr.index + linux_entry.reclen;
+        dr.index = next_index;
+        const name_ptr: [*]u8 = &linux_entry.name;
+        const padded_name = name_ptr[0 .. linux_entry.reclen - @offsetOf(linux.dirent64, "name")];
+        const name_len = std.mem.findScalar(u8, padded_name, 0).?;
+        const name = name_ptr[0..name_len :0];
+
+        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) continue;
+
+        const entry_kind: File.Kind = switch (linux_entry.type) {
+            linux.DT.BLK => .block_device,
+            linux.DT.CHR => .character_device,
+            linux.DT.DIR => .directory,
+            linux.DT.FIFO => .named_pipe,
+            linux.DT.LNK => .sym_link,
+            linux.DT.REG => .file,
+            linux.DT.SOCK => .unix_domain_socket,
+            else => .unknown,
+        };
+        buffer[buffer_index] = .{
+            .name = name,
+            .kind = entry_kind,
+            .inode = linux_entry.ino,
+        };
+        buffer_index += 1;
+    }
+    return buffer_index;
+}
+
+fn dirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.realPath(&cancel_region, dir.handle, out_buffer);
+}
+
+fn dirRealPathFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    out_buffer: []u8,
+) Dir.RealPathFileError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const fd = ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
+        .CLOEXEC = true,
+        .PATH = true,
+    }, 0) catch |err| switch (err) {
+        error.WouldBlock => return errnoBug(.AGAIN),
+        error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
+        else => |e| return e,
+    };
+    defer ev.close(fd);
+    return ev.realPath(&cancel_region, fd, out_buffer);
+}
+
+fn dirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .UNLINKAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir.handle,
+            .off = 0,
+            .addr = @intFromPtr(sub_path_posix.ptr),
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .PERM => return error.PermissionDenied,
+            .ACCES => return error.AccessDenied,
+            .BUSY => return error.FileBusy,
+            .FAULT => |err| return errnoBug(err),
+            .IO => return error.FileSystem,
+            .ISDIR => return error.IsDir,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOTDIR => return error.NotDir,
+            .NOMEM => return error.SystemResources,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .EXIST => |err| return errnoBug(err),
+            .NOTEMPTY => |err| return errnoBug(err), // Not passing AT.REMOVEDIR
+            .ILSEQ => return error.BadPathName,
+            .INVAL => |err| return errnoBug(err), // invalid flags, or pathname has . as last component
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .UNLINKAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir.handle,
+            .off = 0,
+            .addr = @intFromPtr(sub_path_posix.ptr),
+            .len = 0,
+            .rw_flags = linux.AT.REMOVEDIR,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .BUSY => return error.FileBusy,
+            .FAULT => |err| return errnoBug(err),
+            .IO => return error.FileSystem,
+            .ISDIR => |err| return errnoBug(err),
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOTDIR => return error.NotDir,
+            .NOMEM => return error.SystemResources,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .EXIST => |err| return errnoBug(err),
+            .NOTEMPTY => return error.DirNotEmpty,
+            .ILSEQ => return error.BadPathName,
+            .INVAL => |err| return errnoBug(err), // invalid flags, or pathname has . as last component
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirRename(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+) Dir.RenameError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var old_path_buffer: [PATH_MAX]u8 = undefined;
+    var new_path_buffer: [PATH_MAX]u8 = undefined;
+
+    const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
+    const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.renameat(
+        &cancel_region,
+        old_dir.handle,
+        old_sub_path_posix,
+        new_dir.handle,
+        new_sub_path_posix,
+        .{},
+    );
+}
+
+fn dirRenamePreserve(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+) Dir.RenamePreserveError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var old_path_buffer: [PATH_MAX]u8 = undefined;
+    var new_path_buffer: [PATH_MAX]u8 = undefined;
+
+    const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
+    const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.renameat(
+        &cancel_region,
+        old_dir.handle,
+        old_sub_path_posix,
+        new_dir.handle,
+        new_sub_path_posix,
+        .{ .NOREPLACE = true },
+    );
+}
+
+fn dirSymLink(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    target_path: []const u8,
+    sym_link_path: []const u8,
+    flags: Dir.SymLinkFlags,
+) Dir.SymLinkError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = flags;
+
+    var target_path_buffer: [PATH_MAX]u8 = undefined;
+    var sym_link_path_buffer: [PATH_MAX]u8 = undefined;
+
+    const target_path_posix = try pathToPosix(target_path, &target_path_buffer);
+    const sym_link_path_posix = try pathToPosix(sym_link_path, &sym_link_path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .SYMLINKAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir.handle,
+            .off = @intFromPtr(sym_link_path_posix.ptr),
+            .addr = @intFromPtr(target_path_posix.ptr),
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .DQUOT => return error.DiskQuota,
+            .EXIST => return error.PathAlreadyExists,
+            .IO => return error.FileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOTDIR => return error.NotDir,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirReadLink(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    buffer: []u8,
+) Dir.ReadLinkError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var sub_path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &sub_path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        const rc = linux.readlinkat(dir.handle, sub_path_posix, buffer.ptr, buffer.len);
+        switch (linux.errno(rc)) {
+            .SUCCESS => {
+                const len: usize = @bitCast(rc);
+                return len;
+            },
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => return error.NotLink,
+            .IO => return error.FileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.NotDir,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirSetOwner(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    owner: ?File.Uid,
+    group: ?File.Gid,
+) Dir.SetOwnerError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.fchownat(
+        &cancel_region,
+        dir.handle,
+        "",
+        owner orelse std.math.maxInt(linux.uid_t),
+        group orelse std.math.maxInt(linux.gid_t),
+        linux.AT.EMPTY_PATH,
+    );
+}
+
+fn dirSetFileOwner(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    owner: ?File.Uid,
+    group: ?File.Gid,
+    options: Dir.SetFileOwnerOptions,
+) Dir.SetFileOwnerError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.fchownat(
+        &cancel_region,
+        dir.handle,
+        sub_path_posix,
+        owner orelse std.math.maxInt(linux.uid_t),
+        group orelse std.math.maxInt(linux.gid_t),
+        if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
+    );
+}
+
+fn dirSetPermissions(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    permissions: Dir.Permissions,
+) Dir.SetPermissionsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    ev.fchmodat(
+        &cancel_region,
+        dir.handle,
+        "",
+        permissions.toMode(),
+        linux.AT.EMPTY_PATH,
+    ) catch |err| switch (err) {
+        error.NameTooLong => return errnoBug(.NAMETOOLONG),
+        error.BadPathName => return errnoBug(.ILSEQ),
+        error.ProcessFdQuotaExceeded => return errnoBug(.MFILE),
+        error.SystemFdQuotaExceeded => return errnoBug(.NFILE),
+        error.OperationUnsupported => return errnoBug(.OPNOTSUPP),
+        else => |e| return e,
     };
+}
+
+fn dirSetFilePermissions(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+    options: Dir.SetFilePermissionsOptions,
+) Dir.SetFilePermissionsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.fchmodat(
+        &cancel_region,
+        dir.handle,
+        sub_path_posix,
+        permissions.toMode(),
+        if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
+    );
+}
+
+fn dirSetTimestamps(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.SetTimestampsOptions,
+) Dir.SetTimestampsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.utimensat(
+        &cancel_region,
+        dir.handle,
+        sub_path_posix,
+        if (options.modify_timestamp != .now or options.access_timestamp != .now) &.{
+            setTimestampToPosix(options.access_timestamp),
+            setTimestampToPosix(options.modify_timestamp),
+        } else null,
+        if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
+    );
+}
+
+fn dirHardLink(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+    options: Dir.HardLinkOptions,
+) Dir.HardLinkError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var old_path_buffer: [PATH_MAX]u8 = undefined;
+    var new_path_buffer: [PATH_MAX]u8 = undefined;
+
+    const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
+    const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.linkat(
+        &cancel_region,
+        old_dir.handle,
+        old_sub_path_posix,
+        new_dir.handle,
+        new_sub_path_posix,
+        if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
+    );
+}
+
+fn fileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.stat(&cancel_region, file.handle);
+}
+
+fn fileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        var statx_buf = std.mem.zeroes(linux.Statx);
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .STATX,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = file.handle,
+            .off = @intFromPtr(&statx_buf),
+            .addr = @intFromPtr(""),
+            .len = @bitCast(linux.STATX{ .SIZE = true }),
+            .rw_flags = linux.AT.EMPTY_PATH,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => {
+                if (!statx_buf.mask.SIZE) return error.Unexpected;
+                return statx_buf.size;
+            },
+            .INTR, .CANCELED => continue,
+            .ACCES => |err| return errnoBug(err),
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .LOOP => |err| return errnoBug(err),
+            .NAMETOOLONG => |err| return errnoBug(err),
+            .NOENT => |err| return errnoBug(err),
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
 
-    if (@hasField(posix.O, "CLOEXEC")) os_flags.CLOEXEC = true;
-    if (@hasField(posix.O, "LARGEFILE")) os_flags.LARGEFILE = true;
-    if (@hasField(posix.O, "NOCTTY")) os_flags.NOCTTY = !flags.allow_ctty;
-
-    // Use the O locking flags if the os supports them to acquire the lock
-    // atomically.
-    const has_flock_open_flags = @hasField(posix.O, "EXLOCK");
-    if (has_flock_open_flags) {
-        // Note that the NONBLOCK flag is removed after the openat() call
-        // is successful.
-        switch (flags.lock) {
-            .none => {},
-            .shared => {
-                os_flags.SHLOCK = true;
-                os_flags.NONBLOCK = flags.lock_nonblocking;
+fn fileClose(userdata: ?*anyopaque, files: []const File) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    for (files) |file| ev.close(file.handle);
+}
+
+fn fileWritePositional(
+    userdata: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+    offset: u64,
+) File.WritePositionalError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var iovecs: [max_iovecs_len]iovec_const = undefined;
+    var iovlen: iovlen_t = 0;
+    addBuf(&iovecs, &iovlen, header);
+    for (data[0 .. data.len - 1]) |bytes| addBuf(&iovecs, &iovlen, bytes);
+    const pattern = data[data.len - 1];
+    if (iovecs.len - iovlen != 0) switch (splat) {
+        0 => {},
+        1 => addBuf(&iovecs, &iovlen, pattern),
+        else => switch (pattern.len) {
+            0 => {},
+            1 => {
+                var backup_buffer: [splat_buffer_size]u8 = undefined;
+                const splat_buffer = &backup_buffer;
+                const memset_len = @min(splat_buffer.len, splat);
+                const buf = splat_buffer[0..memset_len];
+                @memset(buf, pattern[0]);
+                addBuf(&iovecs, &iovlen, buf);
+                var remaining_splat = splat - buf.len;
+                while (remaining_splat > splat_buffer.len and iovecs.len - iovlen != 0) {
+                    assert(buf.len == splat_buffer.len);
+                    addBuf(&iovecs, &iovlen, splat_buffer);
+                    remaining_splat -= splat_buffer.len;
+                }
+                addBuf(&iovecs, &iovlen, splat_buffer[0..@min(remaining_splat, splat_buffer.len)]);
             },
-            .exclusive => {
-                os_flags.EXLOCK = true;
-                os_flags.NONBLOCK = flags.lock_nonblocking;
+            else => for (0..@min(splat, iovecs.len - iovlen)) |_| {
+                addBuf(&iovecs, &iovlen, pattern);
             },
+        },
+    };
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.pwritev(&cancel_region, file.handle, iovecs[0..iovlen], offset);
+}
+
+/// This is either usize or u32. Since, either is fine, let's use the same
+/// `addBuf` function for both writing to a file and sending network messages.
+const iovlen_t = @FieldType(linux.msghdr_const, "iovlen");
+
+fn addBuf(v: []iovec_const, i: *iovlen_t, bytes: []const u8) void {
+    // OS checks ptr addr before length so zero length vectors must be omitted.
+    if (bytes.len == 0) return;
+    if (v.len - i.* == 0) return;
+    v[i.*] = .{ .base = bytes.ptr, .len = bytes.len };
+    i.* += 1;
+}
+
+fn fileWriteFileStreaming(
+    userdata: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    file_reader: *File.Reader,
+    limit: Io.Limit,
+) File.Writer.WriteFileError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.Unimplemented;
+}
+
+fn fileWriteFilePositional(
+    userdata: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    file_reader: *File.Reader,
+    limit: Io.Limit,
+    offset: u64,
+) File.WriteFilePositionalError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    _ = offset;
+    return error.Unimplemented;
+}
+
+fn fileReadPositional(
+    userdata: ?*anyopaque,
+    file: File,
+    data: []const []u8,
+    offset: u64,
+) File.ReadPositionalError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var iovecs_buffer: [max_iovecs_len]iovec = undefined;
+    var i: usize = 0;
+    for (data) |buf| {
+        if (iovecs_buffer.len - i == 0) break;
+        if (buf.len != 0) {
+            iovecs_buffer[i] = .{ .base = buf.ptr, .len = buf.len };
+            i += 1;
+        }
+    }
+    if (i == 0) return 0;
+    const dest = iovecs_buffer[0..i];
+    assert(dest[0].len > 0);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.preadv(&cancel_region, file.handle, dest, offset) catch |err| switch (err) {
+        error.SocketUnconnected => errnoBug(.NOTCONN), // not a socket
+        error.ConnectionResetByPeer => errnoBug(.CONNRESET), // not a socket
+        else => |e| e,
+    };
+}
+
+fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.lseek(&cancel_region, file.handle, @bitCast(offset), linux.SEEK.CUR);
+}
+
+fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.lseek(&cancel_region, file.handle, offset, linux.SEEK.SET);
+}
+
+fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .FSYNC,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = file.handle,
+            .off = 0,
+            .addr = 0,
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .BADF => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .ROFS => |err| return errnoBug(err),
+            .IO => return error.InputOutput,
+            .NOSPC => return error.NoSpaceLeft,
+            .DQUOT => return error.DiskQuota,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        var wsz: winsize = undefined;
+        const fd: usize = @bitCast(@as(isize, file.handle));
+        const rc = linux.syscall3(.ioctl, fd, linux.T.IOCGWINSZ, @intFromPtr(&wsz));
+        switch (linux.errno(rc)) {
+            .SUCCESS => return true,
+            .INTR => continue,
+            else => return false,
+        }
+    }
+}
+
+fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (!try fileIsTty(ev, file)) return error.NotTerminalDevice;
+}
+
+fn fileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .FTRUNCATE,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = file.handle,
+            .off = length,
+            .addr = 0,
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .FBIG => return error.FileTooBig,
+            .IO => return error.InputOutput,
+            .PERM => return error.PermissionDenied,
+            .TXTBSY => return error.FileBusy,
+            .BADF => |err| return errnoBug(err), // Handle not open for writing.
+            .INVAL => return error.NonResizable, // This is returned for /dev/null for example.
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fileSetOwner(
+    userdata: ?*anyopaque,
+    file: File,
+    owner: ?File.Uid,
+    group: ?File.Gid,
+) File.SetOwnerError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.fchownat(
+        &cancel_region,
+        file.handle,
+        "",
+        owner orelse std.math.maxInt(linux.uid_t),
+        group orelse std.math.maxInt(linux.gid_t),
+        linux.AT.EMPTY_PATH,
+    );
+}
+
+fn fileSetPermissions(
+    userdata: ?*anyopaque,
+    file: File,
+    permissions: File.Permissions,
+) File.SetPermissionsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    ev.fchmodat(
+        &cancel_region,
+        file.handle,
+        "",
+        permissions.toMode(),
+        linux.AT.EMPTY_PATH,
+    ) catch |err| switch (err) {
+        error.NameTooLong => return errnoBug(.NAMETOOLONG),
+        error.BadPathName => return errnoBug(.ILSEQ),
+        error.ProcessFdQuotaExceeded => return errnoBug(.MFILE),
+        error.SystemFdQuotaExceeded => return errnoBug(.NFILE),
+        error.OperationUnsupported => return errnoBug(.OPNOTSUPP),
+        else => |e| return e,
+    };
+}
+
+fn fileSetTimestamps(
+    userdata: ?*anyopaque,
+    file: File,
+    options: File.SetTimestampsOptions,
+) File.SetTimestampsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try ev.utimensat(
+        &cancel_region,
+        file.handle,
+        "",
+        if (options.modify_timestamp != .now or options.access_timestamp != .now) &.{
+            setTimestampToPosix(options.access_timestamp),
+            setTimestampToPosix(options.modify_timestamp),
+        } else null,
+        linux.AT.EMPTY_PATH,
+    );
+}
+
+fn fileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    ev.flock(&cancel_region, file.handle, lock, .blocking) catch |err| switch (err) {
+        error.WouldBlock => unreachable, // blocking
+        else => |e| return e,
+    };
+}
+
+fn fileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    ev.flock(&cancel_region, file.handle, lock, switch (lock) {
+        .none => .blocking,
+        .shared, .exclusive => .nonblocking,
+    }) catch |err| switch (err) {
+        error.WouldBlock => return false,
+        else => |e| return e,
+    };
+    return true;
+}
+
+fn fileUnlock(userdata: ?*anyopaque, file: File) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    ev.flock(&cancel_region, file.handle, .none, .blocking) catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
+        error.WouldBlock => unreachable, // blocking
+        error.SystemResources => return recoverableOsBugDetected(), // Resource deallocation.
+        error.FileLocksUnsupported => return recoverableOsBugDetected(), // We already got the lock.
+        error.Unexpected => return recoverableOsBugDetected(), // Resource deallocation must succeed.
+    };
+}
+
+fn fileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    ev.flock(&cancel_region, file.handle, .shared, .nonblocking) catch |err| switch (err) {
+        error.WouldBlock => return errnoBug(.AGAIN), // File was not locked in exclusive mode.
+        error.SystemResources => return errnoBug(.NOLCK), // Lock already obtained.
+        error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Lock already obtained.
+        else => |e| return e,
+    };
+}
+
+fn fileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.realPath(&cancel_region, file.handle, out_buffer);
+}
+
+fn fileHardLink(
+    userdata: ?*anyopaque,
+    file: File,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+    options: File.HardLinkOptions,
+) File.HardLinkError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var new_path_buffer: [PATH_MAX]u8 = undefined;
+    const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    return ev.linkat(
+        &cancel_region,
+        file.handle,
+        "",
+        new_dir.handle,
+        new_sub_path_posix,
+        linux.AT.EMPTY_PATH | @as(u32, if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW),
+    );
+}
+
+fn fileMemoryMapCreate(
+    userdata: ?*anyopaque,
+    file: File,
+    options: File.MemoryMap.CreateOptions,
+) File.MemoryMap.CreateError!File.MemoryMap {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const prot: linux.PROT = .{
+        .READ = options.protection.read,
+        .WRITE = options.protection.write,
+        .EXEC = options.protection.execute,
+    };
+    const flags: linux.MAP = .{
+        .TYPE = .SHARED_VALIDATE,
+        .POPULATE = options.populate,
+    };
+
+    const page_align = std.heap.page_size_min;
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const contents = while (true) {
+        try cancel_region.await(.nothing);
+        const casted_offset = std.math.cast(i64, options.offset) orelse return error.Unseekable;
+        const rc = linux.mmap(null, options.len, prot, flags, file.handle, casted_offset);
+        switch (linux.errno(rc)) {
+            .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..options.len],
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .AGAIN => return error.LockedMemoryLimitExceeded,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NOMEM => return error.OutOfMemory,
+            .PERM => return error.PermissionDenied,
+            .OVERFLOW => return error.Unseekable,
+            .BADF => |err| return errnoBug(err), // Always a race condition.
+            .INVAL => |err| return errnoBug(err), // Invalid parameters to mmap()
+            .OPNOTSUPP => |err| return errnoBug(err), // Bad flags with MAP.SHARED_VALIDATE on Linux.
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    return .{
+        .file = file,
+        .offset = options.offset,
+        .memory = contents,
+        .section = {},
+    };
+}
+
+fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const memory = mm.memory;
+    if (memory.len == 0) return;
+    switch (linux.errno(linux.munmap(memory.ptr, memory.len))) {
+        .SUCCESS => {},
+        else => |err| if (builtin.mode == .Debug)
+            std.log.err("failed to unmap {d} bytes at {*}: {t}", .{ memory.len, memory.ptr, err }),
+    }
+    mm.* = undefined;
+}
+
+fn processExecutableOpen(
+    userdata: ?*anyopaque,
+    flags: File.OpenFlags,
+) process.OpenExecutableError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return dirOpenFile(ev, .{ .handle = linux.AT.FDCWD }, "/proc/self/exe", flags);
+}
+
+fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.ExecutablePathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return dirReadLink(ev, .cwd(), "/proc/self/exe", out_buffer) catch |err| switch (err) {
+        error.UnsupportedReparsePointType => unreachable, // Windows-only
+        error.NetworkNotFound => unreachable, // Windows-only
+        error.FileBusy => unreachable, // Windows-only
+        else => |e| return e,
+    };
+}
+
+fn lockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+    ev.stderr_mutex.lockUncancelable(ev_io);
+    errdefer ev.stderr_mutex.unlock(ev_io);
+    return ev.initLockedStderr(terminal_mode);
+}
+
+fn tryLockStderr(
+    userdata: ?*anyopaque,
+    terminal_mode: ?Io.Terminal.Mode,
+) Io.Cancelable!?Io.LockedStderr {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+    if (!ev.stderr_mutex.tryLock()) return null;
+    errdefer ev.stderr_mutex.unlock(ev_io);
+    return try ev.initLockedStderr(terminal_mode);
+}
+
+fn initLockedStderr(ev: *Evented, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
+    if (!ev.stderr_writer_initialized) {
+        const ev_io = ev.io();
+        try ev.scanEnviron();
+        const NO_COLOR = ev.environ.exist.NO_COLOR;
+        const CLICOLOR_FORCE = ev.environ.exist.CLICOLOR_FORCE;
+        ev.stderr_mode = terminal_mode orelse
+            try .detect(ev_io, ev.stderr_writer.file, NO_COLOR, CLICOLOR_FORCE);
+        ev.stderr_writer_initialized = true;
+    }
+    return .{
+        .file_writer = &ev.stderr_writer,
+        .terminal_mode = terminal_mode orelse ev.stderr_mode,
+    };
+}
+
+fn unlockStderr(userdata: ?*anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.stderr_writer.interface.flush() catch |err| switch (err) {
+        error.WriteFailed => switch (ev.stderr_writer.err.?) {
+            error.Canceled => recancel(ev),
+            else => {},
+        },
+    };
+    ev.stderr_writer.interface.end = 0;
+    ev.stderr_writer.interface.buffer = &.{};
+    ev.stderr_mutex.unlock(ev.io());
+}
+
+fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.getcwd(buffer.ptr, buffer.len))) {
+            .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
+            .INTR => continue,
+            .NOENT => return error.CurrentDirUnlinked,
+            .RANGE => return error.NameTooLong,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    if (dir.handle == linux.AT.FDCWD) return;
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.fchdir(dir.handle))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .NOTDIR => return error.NotDir,
+            .IO => return error.FileSystem,
+            .BADF => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
         }
     }
-    const have_flock = @TypeOf(posix.system.flock) != void;
+}
 
-    if (have_flock and !has_flock_open_flags and flags.lock != .none) {
-        @panic("TODO");
+fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) ChdirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const dir_path_posix = try pathToPosix(dir_path, &path_buffer);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.chdir(dir_path_posix))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .IO => return error.FileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.NotDir,
+            .ILSEQ => return error.BadPathName,
+            .FAULT => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
     }
+}
+
+fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    try ev.scanEnviron(); // for PATH
+    const PATH = ev.environ.string.PATH orelse default_PATH;
+
+    var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
+    defer arena_allocator.deinit();
+    const arena = arena_allocator.allocator();
+
+    const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+
+    const env_block = env_block: {
+        const prog_fd: i32 = -1;
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+        break :env_block try ev.environ.process_environ.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+    };
+
+    return execv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
+}
+
+fn processReplacePath(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    options: process.ReplaceOptions,
+) process.ReplaceError {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = dir;
+    _ = options;
+    @panic("TODO processReplacePath");
+}
+
+fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const spawned = try ev.spawn(options);
+    defer ev.close(spawned.err_fd);
+
+    // Wait for the child to report any errors in or before `execvpe`.
+    var child_err: ForkBailError = undefined;
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    ev.readAll(&cancel_region, spawned.err_fd, @ptrCast(&child_err)) catch |read_err| {
+        switch (read_err) {
+            error.Canceled => unreachable, // blocked
+            error.EndOfStream => {
+                // Write end closed by CLOEXEC at the time of the `execvpe` call,
+                // indicating success.
+            },
+            else => {
+                // Problem reading the error from the error reporting pipe. We
+                // don't know if the child is alive or dead. Better to assume it is
+                // alive so the resource does not risk being leaked.
+            },
+        }
+        return .{
+            .id = spawned.pid,
+            .thread_handle = {},
+            .stdin = spawned.stdin,
+            .stdout = spawned.stdout,
+            .stderr = spawned.stderr,
+            .request_resource_usage_statistics = options.request_resource_usage_statistics,
+        };
+    };
+    return child_err;
+}
+
+fn processSpawnPath(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    options: process.SpawnOptions,
+) process.SpawnError!process.Child {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = dir;
+    _ = options;
+    @panic("TODO processSpawnPath");
+}
+
+const Spawned = struct {
+    pid: pid_t,
+    err_fd: fd_t,
+    stdin: ?File,
+    stdout: ?File,
+    stderr: ?File,
+};
+fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned {
+    // The child process does need to access (one end of) these pipes. However,
+    // we must initially set CLOEXEC to avoid a race condition. If another thread
+    // is racing to spawn a different child process, we don't want it to inherit
+    // these FDs in any scenario; that would mean that, for instance, calls to
+    // `poll` from the parent would not report the child's stdout as closing when
+    // expected, since the other child may retain a reference to the write end of
+    // the pipe. So, we create the pipes with CLOEXEC initially. After fork, we
+    // need to do something in the new child to make sure we preserve the reference
+    // we want. We could use `fcntl` to remove CLOEXEC from the FD, but as it
+    // turns out, we `dup2` everything anyway, so there's no need!
+    const pipe_flags: linux.O = .{ .CLOEXEC = true };
+
+    const stdin_pipe = if (options.stdin == .pipe) try pipe2(pipe_flags) else undefined;
+    errdefer if (options.stdin == .pipe) {
+        ev.destroyPipe(stdin_pipe);
+    };
+
+    const stdout_pipe = if (options.stdout == .pipe) try pipe2(pipe_flags) else undefined;
+    errdefer if (options.stdout == .pipe) {
+        ev.destroyPipe(stdout_pipe);
+    };
+
+    const stderr_pipe = if (options.stderr == .pipe) try pipe2(pipe_flags) else undefined;
+    errdefer if (options.stderr == .pipe) {
+        ev.destroyPipe(stderr_pipe);
+    };
+
+    const any_ignore =
+        options.stdin == .ignore or options.stdout == .ignore or options.stderr == .ignore;
+    const dev_null_fd = if (any_ignore) dev_null_fd: {
+        var cancel_region: CancelRegion = .init();
+        defer cancel_region.deinit();
+        break :dev_null_fd try ev.null_fd.open(ev, &cancel_region, "/dev/null", .{
+            .ACCMODE = .RDWR,
+        });
+    } else undefined;
+
+    const prog_pipe: [2]fd_t = if (options.progress_node.index != .none) pipe: {
+        // We use CLOEXEC for the same reason as in `pipe_flags`.
+        const pipe = try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true });
+        _ = linux.fcntl(pipe[0], linux.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2));
+        break :pipe pipe;
+    } else .{ -1, -1 };
+    errdefer ev.destroyPipe(prog_pipe);
+
+    var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
+    defer arena_allocator.deinit();
+    const arena = arena_allocator.allocator();
+
+    // The POSIX standard does not allow malloc() between fork() and execve(),
+    // and this allocator may be a libc allocator.
+    // I have personally observed the child process deadlocking when it tries
+    // to call malloc() due to a heap allocation between fork() and execve(),
+    // in musl v1.1.24.
+    // Additionally, we want to reduce the number of possible ways things
+    // can fail between fork() and execve().
+    // Therefore, we do all the allocation for the execve() before the fork().
+    // This means we must do the null-termination of argv and env vars here.
+    const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+
+    const prog_fileno = 3;
+    comptime assert(@max(linux.STDIN_FILENO, linux.STDOUT_FILENO, linux.STDERR_FILENO) + 1 == prog_fileno);
+
+    const env_block = env_block: {
+        const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+        break :env_block try ev.environ.process_environ.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+    };
+
+    // This pipe communicates to the parent errors in the child between `fork` and `execvpe`.
+    // It is closed by the child (via CLOEXEC) without writing if `execvpe` succeeds.
+    const err_pipe: [2]fd_t = try pipe2(.{ .CLOEXEC = true });
+    errdefer ev.destroyPipe(err_pipe);
+
+    try ev.scanEnviron(); // for PATH
+    const PATH = ev.environ.string.PATH orelse default_PATH;
+
+    const pid_result: pid_t = fork: {
+        const rc = linux.fork();
+        switch (linux.errno(rc)) {
+            .SUCCESS => break :fork @intCast(rc),
+            .AGAIN => return error.SystemResources,
+            .NOMEM => return error.SystemResources,
+            .NOSYS => return error.OperationUnsupported,
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+
+    if (pid_result == 0) {
+        defer comptime unreachable; // We are the child.
+        _ = swapCancelProtection(ev, .blocked);
+        const ep1 = err_pipe[1];
+
+        ev.setUpChildIo(options.stdin, stdin_pipe[0], linux.STDIN_FILENO, dev_null_fd) catch |err|
+            ev.forkBail(ep1, err);
+        ev.setUpChildIo(options.stdout, stdout_pipe[1], linux.STDOUT_FILENO, dev_null_fd) catch |err|
+            ev.forkBail(ep1, err);
+        ev.setUpChildIo(options.stderr, stderr_pipe[1], linux.STDERR_FILENO, dev_null_fd) catch |err|
+            ev.forkBail(ep1, err);
+
+        switch (options.cwd) {
+            .inherit => {},
+            .dir => |cwd| processSetCurrentDir(ev, cwd) catch |err| ev.forkBail(ep1, err),
+            .path => |cwd| processSetCurrentPath(ev, cwd) catch |err| ev.forkBail(ep1, err),
+        }
+
+        // Must happen after fchdir above, the cwd file descriptor might be
+        // equal to prog_fileno and be clobbered by this dup2 call.
+        if (prog_pipe[1] != -1) dup2(prog_pipe[1], prog_fileno) catch |err| ev.forkBail(ep1, err);
+
+        if (options.gid) |gid| {
+            switch (linux.errno(linux.setregid(gid, gid))) {
+                .SUCCESS => {},
+                .AGAIN => ev.forkBail(ep1, error.ResourceLimitReached),
+                .INVAL => ev.forkBail(ep1, error.InvalidUserId),
+                .PERM => ev.forkBail(ep1, error.PermissionDenied),
+                else => ev.forkBail(ep1, error.Unexpected),
+            }
+        }
 
-    if (has_flock_open_flags and flags.lock_nonblocking) {
-        @panic("TODO");
+        if (options.uid) |uid| {
+            switch (linux.errno(linux.setreuid(uid, uid))) {
+                .SUCCESS => {},
+                .AGAIN => ev.forkBail(ep1, error.ResourceLimitReached),
+                .INVAL => ev.forkBail(ep1, error.InvalidUserId),
+                .PERM => ev.forkBail(ep1, error.PermissionDenied),
+                else => ev.forkBail(ep1, error.Unexpected),
+            }
+        }
+
+        if (options.pgid) |pid| {
+            switch (linux.errno(linux.setpgid(0, pid))) {
+                .SUCCESS => {},
+                .ACCES => ev.forkBail(ep1, error.ProcessAlreadyExec),
+                .INVAL => ev.forkBail(ep1, error.InvalidProcessGroupId),
+                .PERM => ev.forkBail(ep1, error.PermissionDenied),
+                else => ev.forkBail(ep1, error.Unexpected),
+            }
+        }
+
+        if (options.start_suspended) {
+            switch (linux.errno(linux.kill(linux.getpid(), .STOP))) {
+                .SUCCESS => {},
+                .PERM => ev.forkBail(ep1, error.PermissionDenied),
+                else => ev.forkBail(ep1, error.Unexpected),
+            }
+        }
+
+        const err = execv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
+        ev.forkBail(ep1, err);
     }
 
-    getSqe(iou).* = .{
-        .opcode = .OPENAT,
-        .flags = 0,
-        .ioprio = 0,
-        .fd = dir.handle,
-        .off = 0,
-        .addr = @intFromPtr(&sub_path_c),
-        .len = 0,
-        .rw_flags = @bitCast(os_flags),
-        .user_data = @intFromPtr(fiber),
-        .buf_index = 0,
-        .personality = 0,
-        .splice_fd_in = 0,
-        .addr3 = 0,
-        .resv = 0,
+    const pid: pid_t = @intCast(pid_result); // We are the parent.
+    errdefer comptime unreachable; // The child is forked; we must not error from now on
+
+    ev.close(err_pipe[1]); // make sure only the child holds the write end open
+
+    if (options.stdin == .pipe) ev.close(stdin_pipe[0]);
+    if (options.stdout == .pipe) ev.close(stdout_pipe[1]);
+    if (options.stderr == .pipe) ev.close(stderr_pipe[1]);
+
+    if (prog_pipe[1] != -1) ev.close(prog_pipe[1]);
+
+    options.progress_node.setIpcFile(ev, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
+
+    return .{
+        .pid = pid,
+        .err_fd = err_pipe[0],
+        .stdin = switch (options.stdin) {
+            .pipe => .{ .handle = stdin_pipe[1], .flags = .{ .nonblocking = false } },
+            else => null,
+        },
+        .stdout = switch (options.stdout) {
+            .pipe => .{ .handle = stdout_pipe[0], .flags = .{ .nonblocking = false } },
+            else => null,
+        },
+        .stderr = switch (options.stderr) {
+            .pipe => .{ .handle = stderr_pipe[0], .flags = .{ .nonblocking = false } },
+            else => null,
+        },
     };
+}
+
+pub const PipeError = error{
+    SystemFdQuotaExceeded,
+    ProcessFdQuotaExceeded,
+} || Io.UnexpectedError;
+pub fn pipe2(flags: linux.O) PipeError![2]fd_t {
+    var fds: [2]fd_t = undefined;
+    switch (linux.errno(linux.pipe2(&fds, flags))) {
+        .SUCCESS => return fds,
+        .INVAL => |err| return errnoBug(err), // Invalid flags
+        .NFILE => return error.SystemFdQuotaExceeded,
+        .MFILE => return error.ProcessFdQuotaExceeded,
+        else => |err| return unexpectedErrno(err),
+    }
+}
+fn destroyPipe(ev: *Evented, pipe: [2]fd_t) void {
+    if (pipe[0] != -1) ev.close(pipe[0]);
+    if (pipe[0] != pipe[1]) ev.close(pipe[1]);
+}
+
+fn setUpChildIo(
+    ev: *Evented,
+    stdio: process.SpawnOptions.StdIo,
+    pipe_fd: fd_t,
+    std_fileno: i32,
+    dev_null_fd: fd_t,
+) !void {
+    switch (stdio) {
+        .pipe => try dup2(pipe_fd, std_fileno),
+        .close => ev.close(std_fileno),
+        .inherit => {},
+        .ignore => try dup2(dev_null_fd, std_fileno),
+        .file => |file| try dup2(file.handle, std_fileno),
+    }
+}
+
+pub const DupError = error{
+    ProcessFdQuotaExceeded,
+    SystemResources,
+} || Io.UnexpectedError || Io.Cancelable;
+pub fn dup2(old_fd: fd_t, new_fd: fd_t) DupError!void {
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.dup2(old_fd, new_fd))) {
+            .SUCCESS => {},
+            .BUSY, .INTR => continue,
+            .INVAL => |err| return errnoBug(err), // invalid parameters
+            .BADF => |err| return errnoBug(err), // use after free
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NOMEM => return error.SystemResources,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
 
-    el.yield(null, .nothing);
-    fiber.exitCancelRegion(thread);
+/// Errors that can occur between fork() and execv()
+const ForkBailError = process.SetCurrentDirError || ChdirError ||
+    process.SpawnError || process.ReplaceError;
+/// Child of fork calls this to report an error to the fork parent. Then the
+/// child exits.
+fn forkBail(ev: *Evented, fd: fd_t, err: ForkBailError) noreturn {
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    ev.writeAll(&cancel_region, fd, @ptrCast(&err)) catch {};
+    const exit = if (builtin.single_threaded) linux.exit else linux.exit_group;
+    exit(1);
+}
 
-    const completion = fiber.resultPointer(Completion);
-    switch (errno(completion.result)) {
-        .SUCCESS => return .{ .handle = completion.result },
-        .INTR => unreachable,
-        .CANCELED => return error.Canceled,
+fn execv(
+    arg0_expand: process.ArgExpansion,
+    file: [*:0]const u8,
+    child_argv: [*:null]?[*:0]const u8,
+    env_block: process.Environ.PosixBlock,
+    PATH: []const u8,
+) process.ReplaceError {
+    const file_slice = std.mem.sliceTo(file, 0);
+    if (std.mem.findScalar(u8, file_slice, '/') != null) return execvPath(file, child_argv, env_block);
 
-        .FAULT => unreachable,
-        .INVAL => return error.BadPathName,
-        .BADF => unreachable,
-        .ACCES => return error.AccessDenied,
-        .FBIG => return error.FileTooBig,
-        .OVERFLOW => return error.FileTooBig,
-        .ISDIR => return error.IsDir,
-        .LOOP => return error.SymLinkLoop,
+    // Use of PATH_MAX here is valid as the path_buf will be passed
+    // directly to the operating system in posixExecvPath.
+    var path_buf: [PATH_MAX]u8 = undefined;
+    var it = std.mem.tokenizeScalar(u8, PATH, ':');
+    var seen_eacces = false;
+    var err: process.ReplaceError = error.FileNotFound;
+
+    // In case of expanding arg0 we must put it back if we return with an error.
+    const prev_arg0 = child_argv[0];
+    defer switch (arg0_expand) {
+        .expand => child_argv[0] = prev_arg0,
+        .no_expand => {},
+    };
+
+    while (it.next()) |search_path| {
+        const path_len = search_path.len + file_slice.len + 1;
+        if (path_buf.len < path_len + 1) return error.NameTooLong;
+        @memcpy(path_buf[0..search_path.len], search_path);
+        path_buf[search_path.len] = '/';
+        @memcpy(path_buf[search_path.len + 1 ..][0..file_slice.len], file_slice);
+        path_buf[path_len] = 0;
+        const full_path = path_buf[0..path_len :0].ptr;
+        switch (arg0_expand) {
+            .expand => child_argv[0] = full_path,
+            .no_expand => {},
+        }
+        err = execvPath(full_path, child_argv, env_block);
+        switch (err) {
+            error.AccessDenied => seen_eacces = true,
+            error.FileNotFound, error.NotDir => {},
+            else => |e| return e,
+        }
+    }
+    if (seen_eacces) return error.AccessDenied;
+    return err;
+}
+/// This function ignores PATH environment variable.
+pub fn execvPath(
+    path: [*:0]const u8,
+    child_argv: [*:null]const ?[*:0]const u8,
+    env_block: process.Environ.PosixBlock,
+) process.ReplaceError {
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    try cancel_region.await(.nothing);
+    switch (linux.errno(linux.execve(path, child_argv, env_block.slice.ptr))) {
+        .FAULT => |err| return errnoBug(err), // Bad pointer parameter.
+        .@"2BIG" => return error.SystemResources,
         .MFILE => return error.ProcessFdQuotaExceeded,
         .NAMETOOLONG => return error.NameTooLong,
         .NFILE => return error.SystemFdQuotaExceeded,
-        .NODEV => return error.NoDevice,
+        .NOMEM => return error.SystemResources,
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .INVAL => return error.InvalidExe,
+        .NOEXEC => return error.InvalidExe,
+        .IO => return error.FileSystem,
+        .LOOP => return error.FileSystem,
+        .ISDIR => return error.IsDir,
         .NOENT => return error.FileNotFound,
-        .NOMEM => return error.SystemResources,
-        .NOSPC => return error.NoSpaceLeft,
         .NOTDIR => return error.NotDir,
-        .PERM => return error.PermissionDenied,
-        .EXIST => return error.PathAlreadyExists,
-        .BUSY => return error.DeviceBusy,
-        .OPNOTSUPP => return error.FileLocksUnsupported,
-        .AGAIN => return error.WouldBlock,
         .TXTBSY => return error.FileBusy,
-        .NXIO => return error.NoDevice,
-        else => |err| return posix.unexpectedErrno(err),
+        .LIBBAD => return error.InvalidExe,
+        else => |err| return unexpectedErrno(err),
     }
 }
 
-fn fileClose(userdata: ?*anyopaque, file: Io.File) void {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const thread: *Thread = .current();
-    const iou = &thread.io_uring;
-    const fiber = thread.currentFiber();
-
-    getSqe(iou).* = .{
-        .opcode = .CLOSE,
-        .flags = 0,
-        .ioprio = 0,
-        .fd = file.handle,
-        .off = 0,
-        .addr = 0,
-        .len = 0,
-        .rw_flags = 0,
-        .user_data = @intFromPtr(fiber),
-        .buf_index = 0,
-        .personality = 0,
-        .splice_fd_in = 0,
-        .addr3 = 0,
-        .resv = 0,
-    };
-
-    el.yield(null, .nothing);
-
-    const completion = fiber.resultPointer(Completion);
-    switch (errno(completion.result)) {
-        .SUCCESS => return,
-        .INTR => unreachable,
-        .CANCELED => return,
-
-        .BADF => unreachable, // Always a race condition.
-        else => return,
+fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitError!process.Child.Term {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    defer ev.childCleanup(child);
+
+    const pid = child.id.?;
+    var info: linux.siginfo_t = undefined;
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .WAITID,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = pid,
+            .off = @intFromPtr(&info),
+            .addr = 0,
+            .len = @intFromEnum(linux.P.PID),
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = linux.W.EXITED |
+                @as(i32, if (child.request_resource_usage_statistics) linux.W.NOWAIT else 0),
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => {
+                if (child.request_resource_usage_statistics) while (true) {
+                    try cancel_region.await(.nothing);
+                    var rusage: linux.rusage = undefined;
+                    switch (linux.errno(linux.waitid(
+                        .PID,
+                        pid,
+                        &info,
+                        linux.W.EXITED | linux.W.NOHANG,
+                        &rusage,
+                    ))) {
+                        .SUCCESS => {
+                            child.resource_usage_statistics.rusage = rusage;
+                            break;
+                        },
+                        .INTR, .CANCELED => continue,
+                        .CHILD => |err| return errnoBug(err), // Double-free.
+                        else => |err| return unexpectedErrno(err),
+                    }
+                };
+                const status: u32 = @bitCast(info.fields.common.second.sigchld.status);
+                const code: linux.CLD = @enumFromInt(info.code);
+                return switch (code) {
+                    .EXITED => .{ .exited = @truncate(status) },
+                    .KILLED, .DUMPED => .{ .signal = @enumFromInt(status) },
+                    .TRAPPED, .STOPPED => .{ .stopped = status },
+                    _, .CONTINUED => .{ .unknown = status },
+                };
+            },
+            .INTR, .CANCELED => continue,
+            .CHILD => |err| return errnoBug(err), // Double-free.
+            else => |err| return unexpectedErrno(err),
+        }
     }
 }
 
-fn pread(userdata: ?*anyopaque, file: Io.File, buffer: []u8, offset: std.posix.off_t) Io.File.PReadError!usize {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const thread: *Thread = .current();
-    const iou = &thread.io_uring;
-    const fiber = thread.currentFiber();
-    try fiber.enterCancelRegion(thread);
-
-    getSqe(iou).* = .{
-        .opcode = .READ,
-        .flags = 0,
-        .ioprio = 0,
-        .fd = file.handle,
-        .off = @bitCast(offset),
-        .addr = @intFromPtr(buffer.ptr),
-        .len = @min(buffer.len, 0x7ffff000),
-        .rw_flags = 0,
-        .user_data = @intFromPtr(fiber),
-        .buf_index = 0,
-        .personality = 0,
-        .splice_fd_in = 0,
-        .addr3 = 0,
-        .resv = 0,
+fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    defer ev.childCleanup(child);
+
+    const pid = child.id.?;
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    while (true) switch (linux.errno(linux.kill(pid, .TERM))) {
+        .SUCCESS => break,
+        .INTR => continue,
+        .PERM => return,
+        .INVAL => |err| return errnoBug(err) catch {},
+        .SRCH => |err| return errnoBug(err) catch {},
+        else => |err| return unexpectedErrno(err) catch {},
     };
 
-    el.yield(null, .nothing);
-    fiber.exitCancelRegion(thread);
-
-    const completion = fiber.resultPointer(Completion);
-    switch (errno(completion.result)) {
-        .SUCCESS => return @as(u32, @bitCast(completion.result)),
-        .INTR => unreachable,
-        .CANCELED => return error.Canceled,
-
-        .INVAL => unreachable,
-        .FAULT => unreachable,
-        .NOENT => return error.ProcessNotFound,
-        .AGAIN => return error.WouldBlock,
-        .BADF => return error.NotOpenForReading, // Can be a race condition.
-        .IO => return error.InputOutput,
-        .ISDIR => return error.IsDir,
-        .NOBUFS => return error.SystemResources,
-        .NOMEM => return error.SystemResources,
-        .NOTCONN => return error.SocketUnconnected,
-        .CONNRESET => return error.ConnectionResetByPeer,
-        .TIMEDOUT => return error.Timeout,
-        .NXIO => return error.Unseekable,
-        .SPIPE => return error.Unseekable,
-        .OVERFLOW => return error.Unseekable,
-        else => |err| return std.posix.unexpectedErrno(err),
+    var info: linux.siginfo_t = undefined;
+    while (true) {
+        const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
+        thread.enqueue().* = .{
+            .opcode = .WAITID,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = pid,
+            .off = @intFromPtr(&info),
+            .addr = 0,
+            .len = @intFromEnum(linux.P.PID),
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = linux.W.EXITED,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .CHILD => |err| return errnoBug(err) catch {}, // Double-free.
+            else => |err| return unexpectedErrno(err) catch {},
+        }
     }
 }
 
-fn pwrite(userdata: ?*anyopaque, file: Io.File, buffer: []const u8, offset: std.posix.off_t) Io.File.PWriteError!usize {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const thread: *Thread = .current();
-    const iou = &thread.io_uring;
-    const fiber = thread.currentFiber();
-    try fiber.enterCancelRegion(thread);
+fn childCleanup(ev: *Evented, child: *process.Child) void {
+    if (child.stdin) |*stdin| {
+        ev.close(stdin.handle);
+        child.stdin = null;
+    }
+    if (child.stdout) |*stdout| {
+        ev.close(stdout.handle);
+        child.stdout = null;
+    }
+    if (child.stderr) |*stderr| {
+        ev.close(stderr.handle);
+        child.stderr = null;
+    }
+    child.id = null;
+}
 
-    getSqe(iou).* = .{
-        .opcode = .WRITE,
-        .flags = 0,
-        .ioprio = 0,
-        .fd = file.handle,
-        .off = @bitCast(offset),
-        .addr = @intFromPtr(buffer.ptr),
-        .len = @min(buffer.len, 0x7ffff000),
-        .rw_flags = 0,
-        .user_data = @intFromPtr(fiber),
-        .buf_index = 0,
-        .personality = 0,
-        .splice_fd_in = 0,
-        .addr3 = 0,
-        .resv = 0,
+fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const cancel_protection = swapCancelProtection(ev, .blocked);
+    defer assert(swapCancelProtection(ev, cancel_protection) == .blocked);
+    ev.scanEnviron() catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
     };
+    return ev.environ.zig_progress_file;
+}
 
-    el.yield(null, .nothing);
-    fiber.exitCancelRegion(thread);
-
-    const completion = fiber.resultPointer(Completion);
-    switch (errno(completion.result)) {
-        .SUCCESS => return @as(u32, @bitCast(completion.result)),
-        .INTR => unreachable,
-        .CANCELED => return error.Canceled,
-
-        .INVAL => return error.InvalidArgument,
-        .FAULT => unreachable,
-        .NOENT => return error.ProcessNotFound,
-        .AGAIN => return error.WouldBlock,
-        .BADF => return error.NotOpenForWriting, // can be a race condition.
-        .DESTADDRREQ => unreachable, // `connect` was never called.
-        .DQUOT => return error.DiskQuota,
-        .FBIG => return error.FileTooBig,
-        .IO => return error.InputOutput,
-        .NOSPC => return error.NoSpaceLeft,
-        .ACCES => return error.AccessDenied,
-        .PERM => return error.PermissionDenied,
-        .PIPE => return error.BrokenPipe,
-        .NXIO => return error.Unseekable,
-        .SPIPE => return error.Unseekable,
-        .OVERFLOW => return error.Unseekable,
-        .BUSY => return error.DeviceBusy,
-        .CONNRESET => return error.ConnectionResetByPeer,
-        .MSGSIZE => return error.MessageOversize,
-        else => |err| return std.posix.unexpectedErrno(err),
-    }
+fn scanEnviron(ev: *Evented) Io.Cancelable!void {
+    const ev_io = ev.io();
+    try ev.environ_mutex.lock(ev_io);
+    defer ev.environ_mutex.unlock(ev_io);
+    ev.environ.scan(ev.allocator());
 }
 
-fn now(userdata: ?*anyopaque, clockid: std.posix.clockid_t) Io.ClockGetTimeError!Io.Timestamp {
-    _ = userdata;
-    const timespec = try std.posix.clock_gettime(clockid);
-    return @enumFromInt(@as(i128, timespec.sec) * std.time.ns_per_s + timespec.nsec);
+fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const clock_id = clockToPosix(clock);
+    var timespec: linux.timespec = undefined;
+    return switch (linux.errno(linux.clock_getres(clock_id, &timespec))) {
+        .SUCCESS => .fromNanoseconds(nanosecondsFromPosix(&timespec)),
+        .INVAL => return error.ClockUnavailable,
+        else => |err| return unexpectedErrno(err),
+    };
 }
 
-fn sleep(userdata: ?*anyopaque, clockid: std.posix.clockid_t, deadline: Io.Deadline) Io.SleepError!void {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const thread: *Thread = .current();
-    const iou = &thread.io_uring;
-    const fiber = thread.currentFiber();
-    try fiber.enterCancelRegion(thread);
+fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Timestamp {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var tp: linux.timespec = undefined;
+    switch (linux.errno(linux.clock_gettime(clockToPosix(clock), &tp))) {
+        .SUCCESS => return timestampFromPosix(&tp),
+        else => return .zero,
+    }
+}
 
-    const deadline_nanoseconds: i96 = switch (deadline) {
-        .duration => |duration| duration.nanoseconds,
-        .timestamp => |timestamp| @intFromEnum(timestamp),
-    };
-    const timespec: std.os.linux.kernel_timespec = .{
-        .sec = @intCast(@divFloor(deadline_nanoseconds, std.time.ns_per_s)),
-        .nsec = @intCast(@mod(deadline_nanoseconds, std.time.ns_per_s)),
+fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    const timespec: linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = timespec: switch (timeout) {
+        .none => .{
+            .{
+                .sec = std.math.maxInt(i64),
+                .nsec = std.time.ns_per_s - 1,
+            },
+            .awake,
+            linux.IORING_TIMEOUT_ABS,
+        },
+        .duration => |duration| {
+            const ns = duration.raw.toNanoseconds();
+            break :timespec .{
+                .{
+                    .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                    .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+                },
+                duration.clock,
+                0,
+            };
+        },
+        .deadline => |deadline| {
+            const ns = deadline.raw.toNanoseconds();
+            break :timespec .{
+                .{
+                    .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                    .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+                },
+                deadline.clock,
+                linux.IORING_TIMEOUT_ABS,
+            };
+        },
     };
-    getSqe(iou).* = .{
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const thread = try cancel_region.awaitIoUring();
+    thread.enqueue().* = .{
         .opcode = .TIMEOUT,
         .flags = 0,
         .ioprio = 0,
@@ -1382,116 +4847,1257 @@ fn sleep(userdata: ?*anyopaque, clockid: std.posix.clockid_t, deadline: Io.Deadl
         .off = 0,
         .addr = @intFromPtr(&timespec),
         .len = 1,
-        .rw_flags = @as(u32, switch (deadline) {
-            .duration => 0,
-            .timestamp => std.os.linux.IORING_TIMEOUT_ABS,
-        }) | @as(u32, switch (clockid) {
-            .REALTIME => std.os.linux.IORING_TIMEOUT_REALTIME,
-            .MONOTONIC => 0,
-            .BOOTTIME => std.os.linux.IORING_TIMEOUT_BOOTTIME,
-            else => return error.UnsupportedClock,
+        .rw_flags = timeout_flags | @as(u32, switch (clock) {
+            .real => linux.IORING_TIMEOUT_REALTIME,
+            else => 0,
+            .boot => linux.IORING_TIMEOUT_BOOTTIME,
         }),
-        .user_data = @intFromPtr(fiber),
+        .user_data = @intFromPtr(cancel_region.fiber),
         .buf_index = 0,
         .personality = 0,
         .splice_fd_in = 0,
         .addr3 = 0,
         .resv = 0,
     };
+    ev.yield(null, .nothing);
+    switch (cancel_region.errno()) {
+        // Handles SUCCESS as well as clock not available and unexpected
+        // errors. The user had a chance to check clock resolution before
+        // getting here, which would have reported 0, making this a legal
+        // amount of time to sleep.
+        else => return,
+        .INTR, .CANCELED => return error.Canceled,
+    }
+}
+
+fn random(userdata: ?*anyopaque, buffer: []u8) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var thread: *Thread = .current();
+    if (!thread.csprng.isInitialized()) {
+        @branchHint(.unlikely);
+        var seed: [Csprng.seed_len]u8 = undefined;
+        {
+            const ev_io = ev.io();
+            ev.csprng_mutex.lockUncancelable(ev_io);
+            defer ev.csprng_mutex.unlock(ev_io);
+            if (!ev.csprng.isInitialized()) {
+                @branchHint(.unlikely);
+                var cancel_region: CancelRegion = .initBlocked();
+                defer cancel_region.deinit();
+                ev.urandomReadAll(&cancel_region, &seed) catch |err| switch (err) {
+                    error.Canceled => unreachable, // blocked
+                    else => fallbackSeed(ev, &seed),
+                };
+                ev.csprng.rng = .init(seed);
+                thread = .current();
+            }
+            ev.csprng.rng.fill(&seed);
+        }
+        if (!thread.csprng.isInitialized()) {
+            @branchHint(.likely);
+            thread.csprng.rng = .init(seed);
+        } else thread.csprng.rng.addEntropy(&seed);
+    }
+    thread.csprng.rng.fill(buffer);
+}
+
+fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (buffer.len == 0) return;
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    ev.urandomReadAll(&cancel_region, buffer) catch |err| switch (err) {
+        error.Canceled => return error.Canceled,
+        else => return error.EntropyUnavailable,
+    };
+}
+
+fn netListenIpUnavailable(
+    userdata: ?*anyopaque,
+    address: net.IpAddress,
+    options: net.IpAddress.ListenOptions,
+) net.IpAddress.ListenError!net.Server {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+fn netAcceptUnavailable(
+    userdata: ?*anyopaque,
+    listen_handle: net.Socket.Handle,
+) net.Server.AcceptError!net.Stream {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = listen_handle;
+    return error.NetworkDown;
+}
+
+fn netBindIp(
+    userdata: ?*anyopaque,
+    address: *const net.IpAddress,
+    options: net.IpAddress.BindOptions,
+) net.IpAddress.BindError!net.Socket {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const family = posixAddressFamily(address);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    const socket_fd = try ev.socket(&cancel_region, family, options);
+    errdefer ev.close(socket_fd);
+    var storage: PosixAddress = undefined;
+    var addr_len = addressToPosix(address, &storage);
+    try ev.bind(&cancel_region, socket_fd, &storage.any, addr_len);
+    try ev.getsockname(&cancel_region, socket_fd, &storage.any, &addr_len);
+    return .{
+        .handle = socket_fd,
+        .address = addressFromPosix(&storage),
+    };
+}
+
+fn netBindIpUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.IpAddress,
+    options: net.IpAddress.BindOptions,
+) net.IpAddress.BindError!net.Socket {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+fn netConnectIpUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.IpAddress,
+    options: net.IpAddress.ConnectOptions,
+) net.IpAddress.ConnectError!net.Stream {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+fn netListenUnixUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.UnixAddress,
+    options: net.UnixAddress.ListenOptions,
+) net.UnixAddress.ListenError!net.Socket.Handle {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.AddressFamilyUnsupported;
+}
+
+fn netConnectUnixUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.UnixAddress,
+) net.UnixAddress.ConnectError!net.Socket.Handle {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    return error.AddressFamilyUnsupported;
+}
+
+fn netSocketCreatePairUnavailable(
+    userdata: ?*anyopaque,
+    options: net.Socket.CreatePairOptions,
+) net.Socket.CreatePairError![2]net.Socket {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+fn netSendUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    messages: []net.OutgoingMessage,
+    flags: net.SendFlags,
+) struct { ?net.Socket.SendError, usize } {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = messages;
+    _ = flags;
+    return .{ error.NetworkDown, 0 };
+}
+
+fn netReceive(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    message_buffer: []net.IncomingMessage,
+    data_buffer: []u8,
+    flags: net.ReceiveFlags,
+    timeout: Io.Timeout,
+) struct { ?net.Socket.ReceiveTimeoutError, usize } {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const ev_io = ev.io();
+
+    var message_i: usize = 0;
+    var data_i: usize = 0;
+
+    const deadline: ?struct {
+        raw: Io.Timestamp,
+        timespec: linux.kernel_timespec,
+        clock: Io.Clock,
+    } = if (timeout.toTimestamp(ev_io)) |deadline| deadline: {
+        const ns = deadline.raw.toNanoseconds();
+        break :deadline .{
+            .raw = deadline.raw,
+            .timespec = .{
+                .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
+                .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
+            },
+            .clock = deadline.clock,
+        };
+    } else null;
+
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        if (message_buffer.len - message_i == 0) return .{ null, message_i };
+        const message = &message_buffer[message_i];
+        const remaining_data_buffer = data_buffer[data_i..];
+        var storage: PosixAddress = undefined;
+        var iov: iovec = .{ .base = remaining_data_buffer.ptr, .len = remaining_data_buffer.len };
+        var msg: linux.msghdr = .{
+            .name = &storage.any,
+            .namelen = @sizeOf(PosixAddress),
+            .iov = (&iov)[0..1],
+            .iovlen = 1,
+            .control = message.control.ptr,
+            .controllen = @intCast(message.control.len),
+            .flags = undefined,
+        };
+
+        const thread = cancel_region.awaitIoUring() catch |err| return .{ err, message_i };
+        thread.enqueue().* = .{
+            .opcode = .RECVMSG,
+            .flags = if (deadline) |_| linux.IOSQE_IO_LINK else 0,
+            .ioprio = 0,
+            .fd = handle,
+            .off = 0,
+            .addr = @intFromPtr(&msg),
+            .len = 0,
+            .rw_flags = linux.MSG.NOSIGNAL |
+                @as(u32, if (flags.oob) linux.MSG.OOB else 0) |
+                @as(u32, if (flags.peek) linux.MSG.PEEK else 0) |
+                @as(u32, if (flags.trunc) linux.MSG.TRUNC else 0),
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        if (deadline) |*deadline_ptr| thread.enqueue().* = .{
+            .opcode = .LINK_TIMEOUT,
+            .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+            .ioprio = 0,
+            .fd = 0,
+            .off = 0,
+            .addr = @intFromPtr(&deadline_ptr.timespec),
+            .len = 1,
+            .rw_flags = linux.IORING_TIMEOUT_ABS | @as(u32, switch (deadline_ptr.clock) {
+                .real => linux.IORING_TIMEOUT_REALTIME,
+                else => 0,
+                .boot => linux.IORING_TIMEOUT_BOOTTIME,
+            }),
+            .user_data = @intFromEnum(Completion.UserData.wakeup),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        const completion = cancel_region.completion();
+        switch (completion.errno()) {
+            .SUCCESS => {
+                const data = remaining_data_buffer[0..@intCast(completion.result)];
+                data_i += data.len;
+                message.* = .{
+                    .from = addressFromPosix(&storage),
+                    .data = data,
+                    .control = if (msg.control) |ptr| @as([*]u8, @ptrCast(ptr))[0..msg.controllen] else message.control,
+                    .flags = .{
+                        .eor = (msg.flags & linux.MSG.EOR) != 0,
+                        .trunc = (msg.flags & linux.MSG.TRUNC) != 0,
+                        .ctrunc = (msg.flags & linux.MSG.CTRUNC) != 0,
+                        .oob = (msg.flags & linux.MSG.OOB) != 0,
+                        .errqueue = if (@hasDecl(linux.MSG, "ERRQUEUE")) (msg.flags & linux.MSG.ERRQUEUE) != 0 else false,
+                    },
+                };
+                message_i += 1;
+                continue;
+            },
+            .AGAIN => unreachable,
+            .INTR, .CANCELED => {
+                if (deadline) |d| {
+                    if (now(ev, d.clock).nanoseconds >= d.raw.nanoseconds) return .{ error.Timeout, message_i };
+                }
+                continue;
+            },
+
+            .BADF => |err| return .{ errnoBug(err), message_i },
+            .NFILE => return .{ error.SystemFdQuotaExceeded, message_i },
+            .MFILE => return .{ error.ProcessFdQuotaExceeded, message_i },
+            .FAULT => |err| return .{ errnoBug(err), message_i },
+            .INVAL => |err| return .{ errnoBug(err), message_i },
+            .NOBUFS => return .{ error.SystemResources, message_i },
+            .NOMEM => return .{ error.SystemResources, message_i },
+            .NOTCONN => return .{ error.SocketUnconnected, message_i },
+            .NOTSOCK => |err| return .{ errnoBug(err), message_i },
+            .MSGSIZE => return .{ error.MessageOversize, message_i },
+            .PIPE => return .{ error.SocketUnconnected, message_i },
+            .OPNOTSUPP => |err| return .{ errnoBug(err), message_i },
+            .CONNRESET => return .{ error.ConnectionResetByPeer, message_i },
+            .NETDOWN => return .{ error.NetworkDown, message_i },
+            else => |err| return .{ unexpectedErrno(err), message_i },
+        }
+    }
+}
+
+fn netReceiveUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    message_buffer: []net.IncomingMessage,
+    data_buffer: []u8,
+    flags: net.ReceiveFlags,
+    timeout: Io.Timeout,
+) struct { ?net.Socket.ReceiveTimeoutError, usize } {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = message_buffer;
+    _ = data_buffer;
+    _ = flags;
+    _ = timeout;
+    return .{ error.NetworkDown, 0 };
+}
+
+fn netReadUnavailable(
+    userdata: ?*anyopaque,
+    fd: net.Socket.Handle,
+    data: [][]u8,
+) net.Stream.Reader.Error!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = fd;
+    _ = data;
+    return error.NetworkDown;
+}
+
+fn netWriteUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+) net.Stream.Writer.Error!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = header;
+    _ = data;
+    _ = splat;
+    return error.NetworkDown;
+}
+
+fn netWriteFileUnavailable(
+    userdata: ?*anyopaque,
+    socket_handle: net.Socket.Handle,
+    header: []const u8,
+    file_reader: *File.Reader,
+    limit: Io.Limit,
+) net.Stream.Writer.WriteFileError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = socket_handle;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.NetworkDown;
+}
+
+fn netClose(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    for (handles) |handle| ev.close(handle);
+}
+
+fn netCloseUnavailable(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handles;
+    unreachable; // How you gonna close something that was impossible to open?
+}
+
+fn netShutdown(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    how: net.ShutdownHow,
+) net.ShutdownError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .SHUTDOWN,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = handle,
+            .off = 0,
+            .addr = 0,
+            .len = switch (how) {
+                .recv => linux.SHUT.RD,
+                .send => linux.SHUT.WR,
+                .both => linux.SHUT.RDWR,
+            },
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .BADF, .NOTSOCK, .INVAL => |err| return errnoBug(err),
+            .NOTCONN => return error.SocketUnconnected,
+            .NOBUFS => return error.SystemResources,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn netShutdownUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    how: net.ShutdownHow,
+) net.ShutdownError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = how;
+    unreachable; // How you gonna shutdown something that was impossible to open?
+}
+
+fn netInterfaceNameResolveUnavailable(
+    userdata: ?*anyopaque,
+    name: *const net.Interface.Name,
+) net.Interface.Name.ResolveError!net.Interface {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = name;
+    return error.InterfaceNotFound;
+}
+
+fn netInterfaceNameUnavailable(
+    userdata: ?*anyopaque,
+    interface: net.Interface,
+) net.Interface.NameError!net.Interface.Name {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = interface;
+    return error.Unexpected;
+}
+
+fn netLookupUnavailable(
+    userdata: ?*anyopaque,
+    host_name: net.HostName,
+    resolved: *Io.Queue(net.HostName.LookupResult),
+    options: net.HostName.LookupOptions,
+) net.HostName.LookupError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = host_name;
+    _ = options;
+    resolved.close(ev.io());
+    return error.NetworkDown;
+}
+
+fn bind(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    socket_fd: fd_t,
+    addr: *const linux.sockaddr,
+    addr_len: linux.socklen_t,
+) !void {
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .BIND,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = socket_fd,
+            .off = addr_len,
+            .addr = @intFromPtr(addr),
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .ADDRINUSE => return error.AddressInUse,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .INVAL => |err| return errnoBug(err), // invalid parameters
+            .NOTSOCK => |err| return errnoBug(err), // invalid `sockfd`
+            .AFNOSUPPORT => return error.AddressFamilyUnsupported,
+            .ADDRNOTAVAIL => return error.AddressUnavailable,
+            .FAULT => |err| return errnoBug(err), // invalid `addr` pointer
+            .NOMEM => return error.SystemResources,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
 
-    el.yield(null, .nothing);
-    fiber.exitCancelRegion(thread);
-
-    const completion = fiber.resultPointer(Completion);
-    switch (errno(completion.result)) {
-        .SUCCESS, .TIME => return,
-        .INTR => unreachable,
-        .CANCELED => return error.Canceled,
-
-        else => |err| return std.posix.unexpectedErrno(err),
-    }
-}
-
-fn mutexLock(userdata: ?*anyopaque, prev_state: Io.Mutex.State, mutex: *Io.Mutex) error{Canceled}!void {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    el.yield(null, .{ .mutex_lock = .{ .prev_state = prev_state, .mutex = mutex } });
-}
-fn mutexUnlock(userdata: ?*anyopaque, prev_state: Io.Mutex.State, mutex: *Io.Mutex) void {
-    var maybe_waiting_fiber: ?*Fiber = @ptrFromInt(@intFromEnum(prev_state));
-    while (if (maybe_waiting_fiber) |waiting_fiber| @cmpxchgWeak(
-        Io.Mutex.State,
-        &mutex.state,
-        @enumFromInt(@intFromPtr(waiting_fiber)),
-        @enumFromInt(@intFromPtr(waiting_fiber.queue_next)),
-        .release,
-        .acquire,
-    ) else @cmpxchgWeak(
-        Io.Mutex.State,
-        &mutex.state,
-        .locked_once,
-        .unlocked,
-        .release,
-        .acquire,
-    ) orelse return) |next_state| maybe_waiting_fiber = @ptrFromInt(@intFromEnum(next_state));
-    maybe_waiting_fiber.?.queue_next = null;
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    el.yield(maybe_waiting_fiber.?, .reschedule);
-}
-
-const ConditionImpl = struct {
-    tail: *Fiber,
-    event: union(enum) {
-        queued,
-        wake: Io.Condition.Wake,
-    },
-};
-
-fn conditionWait(userdata: ?*anyopaque, cond: *Io.Condition, mutex: *Io.Mutex) Io.Cancelable!void {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    el.yield(null, .{ .condition_wait = .{ .cond = cond, .mutex = mutex } });
-    const thread = Thread.current();
-    const fiber = thread.currentFiber();
-    const cond_impl = fiber.resultPointer(ConditionImpl);
-    try mutex.lock(el.io());
-    switch (cond_impl.event) {
-        .queued => {},
-        .wake => |wake| if (fiber.queue_next) |next_fiber| switch (wake) {
-            .one => if (@cmpxchgStrong(
-                ?*Fiber,
-                @as(*?*Fiber, @ptrCast(&cond.state)),
-                null,
-                next_fiber,
-                .release,
-                .acquire,
-            )) |old_fiber| {
-                const old_cond_impl = old_fiber.?.resultPointer(ConditionImpl);
-                assert(old_cond_impl.tail.queue_next == null);
-                old_cond_impl.tail.queue_next = next_fiber;
-                old_cond_impl.tail = cond_impl.tail;
+fn close(ev: *Evented, fd: fd_t) void {
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    while (true) {
+        const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
+        thread.enqueue().* = .{
+            .opcode = .CLOSE,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = fd,
+            .off = 0,
+            .addr = 0,
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .BADF => unreachable, // Always a race condition.
+            else => break,
+        }
+    }
+}
+
+fn fchmodat(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    dir: fd_t,
+    path: [*:0]const u8,
+    mode: linux.mode_t,
+    flags: u32,
+) Dir.SetFilePermissionsError!void {
+    _ = ev;
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.fchmodat2(dir, path, mode, flags))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .BADF => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .ACCES => return error.AccessDenied,
+            .IO => return error.InputOutput,
+            .LOOP => return error.SymLinkLoop,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.FileNotFound,
+            .OPNOTSUPP => return error.OperationUnsupported,
+            .PERM => return error.PermissionDenied,
+            .ROFS => return error.ReadOnlyFileSystem,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fchownat(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    dir: fd_t,
+    path: [*:0]const u8,
+    owner: linux.uid_t,
+    group: linux.gid_t,
+    flags: u32,
+) File.SetOwnerError!void {
+    _ = ev;
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.fchownat(dir, path, owner, group, flags))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .BADF => |err| return errnoBug(err), // likely fd refers to directory opened without `Dir.OpenOptions.iterate`
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .ACCES => return error.AccessDenied,
+            .IO => return error.InputOutput,
+            .LOOP => return error.SymLinkLoop,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.FileNotFound,
+            .PERM => return error.PermissionDenied,
+            .ROFS => return error.ReadOnlyFileSystem,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn flock(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    op: File.Lock,
+    blocking: enum { blocking, nonblocking },
+) (File.LockError || error{WouldBlock})!void {
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.flock(fd, LOCK.NB | @as(i32, switch (op) {
+            .none => LOCK.UN,
+            .shared => LOCK.SH,
+            .exclusive => LOCK.EX,
+        })))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .BADF => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err), // invalid parameters
+            .NOLCK => return error.SystemResources,
+            .AGAIN => {
+                const thread = try cancel_region.awaitIoUring();
+                thread.enqueue().* = .{
+                    .opcode = .NOP,
+                    .flags = 0,
+                    .ioprio = 0,
+                    .fd = 0,
+                    .off = 0,
+                    .addr = 0,
+                    .len = 0,
+                    .rw_flags = 0,
+                    .user_data = @intFromPtr(cancel_region.fiber),
+                    .buf_index = 0,
+                    .personality = 0,
+                    .splice_fd_in = 0,
+                    .addr3 = 0,
+                    .resv = 0,
+                };
+                ev.yield(null, .nothing);
+                switch (cancel_region.errno()) {
+                    .SUCCESS, .INTR, .CANCELED => {},
+                    else => unreachable,
+                }
+                switch (blocking) {
+                    .blocking => continue,
+                    .nonblocking => return error.WouldBlock,
+                }
             },
-            .all => el.schedule(thread, .{ .head = next_fiber, .tail = cond_impl.tail }),
-        },
+            .OPNOTSUPP => return error.FileLocksUnsupported,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn getsockname(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    socket_fd: fd_t,
+    addr: *linux.sockaddr,
+    addr_len: *linux.socklen_t,
+) !void {
+    _ = ev;
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.getsockname(socket_fd, addr, addr_len))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err), // invalid parameters
+            .NOTSOCK => |err| return errnoBug(err), // always a race condition
+            .NOBUFS => return error.SystemResources,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn linkat(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    old_dir: fd_t,
+    old_path: [*:0]const u8,
+    new_dir: fd_t,
+    new_path: [*:0]const u8,
+    flags: u32,
+) File.HardLinkError!void {
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .LINKAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = old_dir,
+            .off = @intFromPtr(new_path),
+            .addr = @intFromPtr(old_path),
+            .len = @bitCast(new_dir),
+            .rw_flags = flags,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .ACCES => return error.AccessDenied,
+            .DQUOT => return error.DiskQuota,
+            .EXIST => return error.PathAlreadyExists,
+            .IO => return error.HardwareFailure,
+            .LOOP => return error.SymLinkLoop,
+            .MLINK => return error.LinkQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .PERM => return error.PermissionDenied,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .XDEV => return error.CrossDevice,
+            .ILSEQ => return error.BadPathName,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn lseek(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    offset: u64,
+    whence: u32,
+) File.SeekError!void {
+    _ = ev;
+    while (true) {
+        try cancel_region.await(.nothing);
+        var result: u64 = undefined;
+        switch (linux.errno(switch (@sizeOf(usize)) {
+            else => comptime unreachable,
+            4 => linux.llseek(fd, offset, &result, whence),
+            8 => linux.lseek(fd, @bitCast(offset), whence),
+        })) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .INVAL => return error.Unseekable,
+            .OVERFLOW => return error.Unseekable,
+            .SPIPE => return error.Unseekable,
+            .NXIO => return error.Unseekable,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn openat(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    dir: fd_t,
+    path: [*:0]const u8,
+    flags: linux.O,
+    mode: linux.mode_t,
+) File.OpenError!fd_t {
+    var mut_flags = flags;
+    if (@hasField(linux.O, "LARGEFILE")) mut_flags.LARGEFILE = true;
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .OPENAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir,
+            .off = 0,
+            .addr = @intFromPtr(path),
+            .len = mode,
+            .rw_flags = @bitCast(mut_flags),
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        const completion = cancel_region.completion();
+        switch (completion.errno()) {
+            .SUCCESS => return completion.result,
+            .INTR, .CANCELED => continue,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => return error.BadPathName,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .ACCES => return error.AccessDenied,
+            .FBIG => return error.FileTooBig,
+            .OVERFLOW => return error.FileTooBig,
+            .ISDIR => return error.IsDir,
+            .LOOP => return error.SymLinkLoop,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NODEV => return error.NoDevice,
+            .NOENT => return error.FileNotFound,
+            .SRCH => return error.FileNotFound, // Linux when opening procfs files.
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .PERM => return error.PermissionDenied,
+            .EXIST => return error.PathAlreadyExists,
+            .BUSY => return error.DeviceBusy,
+            .OPNOTSUPP => return error.FileLocksUnsupported,
+            .AGAIN => return error.WouldBlock,
+            .TXTBSY => return error.FileBusy,
+            .NXIO => return error.NoDevice,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn preadv(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    iov: []const iovec,
+    offset: ?u64,
+) File.Reader.Error!usize {
+    if (iov.len == 0) return 0;
+    const gather = iov.len > 1 or iov[0].len > 0xfffff000;
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = if (gather) .READV else .READ,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = fd,
+            .off = offset orelse std.math.maxInt(u64),
+            .addr = if (gather) @intFromPtr(iov.ptr) else @intFromPtr(iov[0].base),
+            .len = @intCast(if (gather) iov.len else iov[0].len),
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        const completion = cancel_region.completion();
+        switch (completion.errno()) {
+            .SUCCESS => return @as(u32, @bitCast(completion.result)),
+            .INTR, .CANCELED => continue,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .AGAIN => return error.WouldBlock,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed
+            .IO => return error.InputOutput,
+            .ISDIR => return error.IsDir,
+            .NOBUFS => return error.SystemResources,
+            .NOMEM => return error.SystemResources,
+            .NOTCONN => return error.SocketUnconnected,
+            .CONNRESET => return error.ConnectionResetByPeer,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn pwritev(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    iov: []const iovec_const,
+    offset: ?u64,
+) File.Writer.Error!usize {
+    if (iov.len == 0) return 0;
+    const scatter = iov.len > 1 or iov[0].len > 0xfffff000;
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = if (scatter) .WRITEV else .WRITE,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = fd,
+            .off = offset orelse std.math.maxInt(u64),
+            .addr = if (scatter) @intFromPtr(iov.ptr) else @intFromPtr(iov[0].base),
+            .len = @intCast(if (scatter) iov.len else iov[0].len),
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        const completion = cancel_region.completion();
+        switch (completion.errno()) {
+            .SUCCESS => return @as(u32, @bitCast(completion.result)),
+            .INTR, .CANCELED => continue,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .AGAIN => return error.WouldBlock,
+            .BADF => return error.NotOpenForWriting, // Can be a race condition.
+            .DESTADDRREQ => |err| return errnoBug(err), // `connect` was never called.
+            .DQUOT => return error.DiskQuota,
+            .FBIG => return error.FileTooBig,
+            .IO => return error.InputOutput,
+            .NOSPC => return error.NoSpaceLeft,
+            .PERM => return error.PermissionDenied,
+            .PIPE => return error.BrokenPipe,
+            .CONNRESET => |err| return errnoBug(err), // Not a socket handle.
+            .BUSY => return error.DeviceBusy,
+            else => |err| return unexpectedErrno(err),
+        }
     }
-    fiber.queue_next = null;
 }
 
-fn conditionWake(userdata: ?*anyopaque, cond: *Io.Condition, wake: Io.Condition.Wake) void {
-    const el: *EventLoop = @ptrCast(@alignCast(userdata));
-    const waiting_fiber = @atomicRmw(?*Fiber, @as(*?*Fiber, @ptrCast(&cond.state)), .Xchg, null, .acquire) orelse return;
-    waiting_fiber.resultPointer(ConditionImpl).event = .{ .wake = wake };
-    el.yield(waiting_fiber, .reschedule);
+fn readAll(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    buffer: []u8,
+) (File.Reader.Error || error{EndOfStream})!void {
+    var index: usize = 0;
+    while (buffer.len - index != 0) {
+        const len = try ev.preadv(cancel_region, fd, &.{
+            .{ .base = buffer[index..].ptr, .len = buffer.len - index },
+        }, null);
+        if (len == 0) return error.EndOfStream;
+        index += len;
+    }
 }
 
-fn errno(signed: i32) std.os.linux.E {
-    return .init(@bitCast(@as(isize, signed)));
+fn realPath(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    out_buffer: []u8,
+) File.RealPathError!usize {
+    _ = ev;
+    var procfs_buf: [std.fmt.count("/proc/self/fd/{d}\x00", .{std.math.minInt(fd_t)})]u8 = undefined;
+    const proc_path = std.fmt.bufPrintSentinel(&procfs_buf, "/proc/self/fd/{d}", .{fd}, 0) catch
+        unreachable;
+    while (true) {
+        try cancel_region.await(.nothing);
+        const rc = linux.readlink(proc_path, out_buffer.ptr, out_buffer.len);
+        switch (linux.errno(rc)) {
+            .SUCCESS => return rc,
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .FAULT => |err| return errnoBug(err),
+            .IO => return error.FileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.NotDir,
+            .ILSEQ => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
 }
 
-fn getSqe(iou: *IoUring) *std.os.linux.io_uring_sqe {
-    while (true) return iou.get_sqe() catch {
-        _ = iou.submit_and_wait(0) catch |err| switch (err) {
-            error.SignalInterrupt => std.log.warn("submit_and_wait failed with SignalInterrupt", .{}),
-            else => |e| @panic(@errorName(e)),
+fn renameat(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    old_dir: fd_t,
+    old_path: [*:0]const u8,
+    new_dir: fd_t,
+    new_path: [*:0]const u8,
+    flags: linux.RENAME,
+) Dir.RenameError!void {
+    while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .RENAMEAT,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = old_dir,
+            .off = @intFromPtr(new_path),
+            .addr = @intFromPtr(old_path),
+            .len = @bitCast(new_dir),
+            .rw_flags = @bitCast(flags),
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .BUSY => return error.FileBusy,
+            .DQUOT => return error.DiskQuota,
+            .ISDIR => return error.IsDir,
+            .IO => return error.HardwareFailure,
+            .LOOP => return error.SymLinkLoop,
+            .MLINK => return error.LinkQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOTDIR => return error.NotDir,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .EXIST => return error.DirNotEmpty,
+            .NOTEMPTY => return error.DirNotEmpty,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .XDEV => return error.CrossDevice,
+            .ILSEQ => return error.BadPathName,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn setsockopt(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    level: i32,
+    opt_name: u32,
+    option: u32,
+) !void {
+    const o: []const u8 = @ptrCast(&option);
+    while (true) {
+        const off: extern struct {
+            cmd_op: linux.IO_URING_SOCKET_OP,
+            pad: u32,
+        } align(@alignOf(u64)) = .{
+            .cmd_op = .SETSOCKOPT,
+            .pad = 0,
+        };
+        const addr: extern struct { level: i32, opt_name: u32 } align(@alignOf(u64)) = .{
+            .level = level,
+            .opt_name = opt_name,
         };
-        continue;
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .URING_CMD,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = fd,
+            .off = @as(*const u64, @ptrCast(&off)).*,
+            .addr = @as(*const u64, @ptrCast(&addr)).*,
+            .len = 0,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = @intCast(o.len),
+            .addr3 = @intFromPtr(o.ptr),
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return,
+            .INTR, .CANCELED => continue,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .NOTSOCK => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn socket(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    family: linux.sa_family_t,
+    options: net.IpAddress.BindOptions,
+) error{
+    AddressFamilyUnsupported,
+    ProtocolUnsupportedBySystem,
+    ProcessFdQuotaExceeded,
+    SystemFdQuotaExceeded,
+    SystemResources,
+    ProtocolUnsupportedByAddressFamily,
+    SocketModeUnsupported,
+    OptionUnsupported,
+    Unexpected,
+    Canceled,
+}!fd_t {
+    const mode = posixSocketMode(options.mode);
+    const protocol = posixProtocol(options.protocol);
+    const socket_fd = while (true) {
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .SOCKET,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = family,
+            .off = mode | linux.SOCK.CLOEXEC,
+            .addr = 0,
+            .len = protocol,
+            .rw_flags = 0,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        const completion = cancel_region.completion();
+        switch (completion.errno()) {
+            .SUCCESS => break completion.result,
+            .INTR, .CANCELED => continue,
+            .AFNOSUPPORT => return error.AddressFamilyUnsupported,
+            .INVAL => return error.ProtocolUnsupportedBySystem,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NOBUFS => return error.SystemResources,
+            .NOMEM => return error.SystemResources,
+            .PROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
+            .PROTOTYPE => return error.SocketModeUnsupported,
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    errdefer ev.close(socket_fd);
+
+    if (options.ip6_only) {
+        if (linux.IPV6 == void) return error.OptionUnsupported;
+        try ev.setsockopt(cancel_region, socket_fd, linux.IPPROTO.IPV6, linux.IPV6.V6ONLY, 0);
+    }
+
+    return socket_fd;
+}
+
+fn stat(ev: *Evented, cancel_region: *CancelRegion, fd: fd_t) Dir.StatError!Dir.Stat {
+    return ev.statx(cancel_region, fd, "", linux.AT.EMPTY_PATH) catch |err| switch (err) {
+        error.BadPathName, error.NameTooLong => unreachable, // path is empty
+        error.AccessDenied => return errnoBug(.ACCES),
+        error.SymLinkLoop => return errnoBug(.LOOP),
+        error.FileNotFound => return errnoBug(.NOENT),
+        error.NotDir => return errnoBug(.NOTDIR),
+        else => |e| return e,
     };
 }
+
+fn statx(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    dir: fd_t,
+    path: [*:0]const u8,
+    flags: u32,
+) (Dir.StatError || Dir.PathNameError || error{ FileNotFound, NotDir, SymLinkLoop })!Dir.Stat {
+    while (true) {
+        var statx_buf = std.mem.zeroes(linux.Statx);
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .STATX,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir,
+            .off = @intFromPtr(&statx_buf),
+            .addr = @intFromPtr(path),
+            .len = @bitCast(linux_statx_request),
+            .rw_flags = flags,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => return statFromLinux(&statx_buf),
+            .INTR, .CANCELED => continue,
+            .ACCES => return error.AccessDenied,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => |err| return errnoBug(err),
+            .NOENT => return error.FileNotFound,
+            .NOTDIR => return error.NotDir,
+            .NOMEM => return error.SystemResources,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn urandomReadAll(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    buffer: []u8,
+) (File.OpenError || File.Reader.Error || error{EndOfStream})!void {
+    return ev.readAll(cancel_region, try ev.random_fd.open(ev, cancel_region, "/dev/urandom", .{
+        .ACCMODE = .RDONLY,
+        .CLOEXEC = true,
+    }), buffer);
+}
+
+fn utimensat(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    dir: fd_t,
+    path: [*:0]const u8,
+    times: ?*const [2]linux.timespec,
+    flags: u32,
+) File.SetTimestampsError!void {
+    _ = ev;
+    while (true) {
+        try cancel_region.await(.nothing);
+        switch (linux.errno(linux.utimensat(dir, path, times, flags))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .BADF => |err| return errnoBug(err), // always a race condition
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .ROFS => return error.ReadOnlyFileSystem,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn writeAll(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    fd: fd_t,
+    buffer: []const u8,
+) (File.Writer.Error || error{EndOfStream})!void {
+    var index: usize = 0;
+    while (buffer.len - index != 0) {
+        const len = try ev.pwritev(cancel_region, fd, &.{
+            .{ .base = buffer[index..].ptr, .len = buffer.len - index },
+        }, null);
+        if (len == 0) return error.EndOfStream;
+        index += len;
+    }
+}
+
+test {
+    _ = Fiber.CancelProtection;
+}
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1f450d1dacd6d93992d885e92294d34d66202628..dac4ada39d2a3239086f1ef38d2a04a56a653a1e 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -78,7 +78,7 @@ null_file: NullFile = .{},
 random_file: RandomFile = .{},
 pipe_file: PipeFile = .{},
 
-csprng: Csprng = .{},
+csprng: Csprng = .uninitialized,
 
 system_basic_information: SystemBasicInformation = .{},
 
@@ -88,10 +88,12 @@ const SystemBasicInformation = if (!is_windows) struct {} else struct {
 };
 
 pub const Csprng = struct {
-    rng: std.Random.DefaultCsprng = .{
+    rng: std.Random.DefaultCsprng,
+
+    pub const uninitialized: Csprng = .{ .rng = .{
         .state = undefined,
         .offset = std.math.maxInt(usize),
-    },
+    } };
 
     pub const seed_len = std.Random.DefaultCsprng.secret_seed_length;
 
@@ -120,7 +122,7 @@ pub const Argv0 = switch (native_os) {
     },
 };
 
-const Environ = struct {
+pub const Environ = struct {
     /// Unmodified data directly from the OS.
     process_environ: process.Environ,
     /// Protected by `mutex`. Determines whether the other fields have been
@@ -157,6 +159,127 @@ const Environ = struct {
             HOME: ?[:0]const u8 = null,
         },
     };
+
+    pub fn scan(environ: *Environ, allocator: std.mem.Allocator) void {
+        if (environ.initialized) return;
+        environ.initialized = true;
+
+        if (is_windows) {
+            // This value expires with any call that modifies the environment,
+            // which is outside of this Io implementation's control, so references
+            // must be short-lived.
+            const peb = windows.peb();
+            assert(windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
+            defer assert(windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
+            const ptr = peb.ProcessParameters.Environment;
+
+            var i: usize = 0;
+            while (ptr[i] != 0) {
+                // There are some special environment variables that start with =,
+                // so we need a special case to not treat = as a key/value separator
+                // if it's the first character.
+                // https://devblogs.microsoft.com/oldnewthing/20100506-00/?p=14133
+                const key_start = i;
+                if (ptr[i] == '=') i += 1;
+                while (ptr[i] != 0 and ptr[i] != '=') : (i += 1) {}
+                const key_w = ptr[key_start..i];
+
+                const value_start = i + 1;
+                while (ptr[i] != 0) : (i += 1) {} // skip over '=' and value
+                const value_w = ptr[value_start..i];
+                i += 1; // skip over null byte
+
+                if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'N', 'O', '_', 'C', 'O', 'L', 'O', 'R' })) {
+                    environ.exist.NO_COLOR = true;
+                } else if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'C', 'L', 'I', 'C', 'O', 'L', 'O', 'R', '_', 'F', 'O', 'R', 'C', 'E' })) {
+                    environ.exist.CLICOLOR_FORCE = true;
+                } else if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'Z', 'I', 'G', '_', 'P', 'R', 'O', 'G', 'R', 'E', 'S', 'S' })) {
+                    environ.zig_progress_file = file: {
+                        var value_buf: [std.fmt.count("{d}", .{std.math.maxInt(usize)})]u8 = undefined;
+                        const len = std.unicode.calcWtf8Len(value_w);
+                        if (len > value_buf.len) break :file error.UnrecognizedFormat;
+                        assert(std.unicode.wtf16LeToWtf8(&value_buf, value_w) == len);
+                        break :file .{
+                            .handle = @ptrFromInt(std.fmt.parseInt(usize, value_buf[0..len], 10) catch
+                                break :file error.UnrecognizedFormat),
+                            .flags = .{ .nonblocking = true },
+                        };
+                    };
+                }
+                comptime assert(@sizeOf(String) == 0);
+            }
+        } else if (native_os == .wasi and !builtin.link_libc) {
+            var environ_size: usize = undefined;
+            var environ_buf_size: usize = undefined;
+
+            switch (std.os.wasi.environ_sizes_get(&environ_size, &environ_buf_size)) {
+                .SUCCESS => {},
+                else => |err| {
+                    environ.err = posix.unexpectedErrno(err);
+                    return;
+                },
+            }
+            if (environ_size == 0) return;
+
+            const wasi_environ = allocator.alloc([*:0]u8, environ_size) catch |err| {
+                environ.err = err;
+                return;
+            };
+            defer allocator.free(wasi_environ);
+            const wasi_environ_buf = allocator.alloc(u8, environ_buf_size) catch |err| {
+                environ.err = err;
+                return;
+            };
+            defer allocator.free(wasi_environ_buf);
+
+            switch (std.os.wasi.environ_get(wasi_environ.ptr, wasi_environ_buf.ptr)) {
+                .SUCCESS => {},
+                else => |err| {
+                    environ.err = posix.unexpectedErrno(err);
+                    return;
+                },
+            }
+
+            for (wasi_environ) |env| {
+                const pair = std.mem.sliceTo(env, 0);
+                var parts = std.mem.splitScalar(u8, pair, '=');
+                const key = parts.first();
+                if (std.mem.eql(u8, key, "NO_COLOR")) {
+                    environ.exist.NO_COLOR = true;
+                } else if (std.mem.eql(u8, key, "CLICOLOR_FORCE")) {
+                    environ.exist.CLICOLOR_FORCE = true;
+                }
+                comptime assert(@sizeOf(String) == 0);
+            }
+        } else {
+            for (environ.process_environ.block.slice) |opt_entry| {
+                const entry = opt_entry.?;
+                var entry_i: usize = 0;
+                while (entry[entry_i] != 0 and entry[entry_i] != '=') : (entry_i += 1) {}
+                const key = entry[0..entry_i];
+
+                var end_i: usize = entry_i;
+                while (entry[end_i] != 0) : (end_i += 1) {}
+                const value = entry[entry_i + 1 .. end_i :0];
+
+                if (std.mem.eql(u8, key, "NO_COLOR")) {
+                    environ.exist.NO_COLOR = true;
+                } else if (std.mem.eql(u8, key, "CLICOLOR_FORCE")) {
+                    environ.exist.CLICOLOR_FORCE = true;
+                } else if (std.mem.eql(u8, key, "ZIG_PROGRESS")) {
+                    environ.zig_progress_file = file: {
+                        break :file .{
+                            .handle = std.fmt.parseInt(u31, value, 10) catch
+                                break :file error.UnrecognizedFormat,
+                            .flags = .{ .nonblocking = true },
+                        };
+                    };
+                } else inline for (@typeInfo(String).@"struct".fields) |field| {
+                    if (std.mem.eql(u8, key, field.name)) @field(environ.string, field.name) = value;
+                }
+            }
+        }
+    }
 };
 
 pub const NullFile = switch (native_os) {
@@ -1397,13 +1520,13 @@ pub fn waitForApcOrAlert() void {
     _ = windows.ntdll.NtDelayExecution(windows.TRUE, &infinite_timeout);
 }
 
-const max_iovecs_len = 8;
-const splat_buffer_size = 64;
+pub const max_iovecs_len = 8;
+pub const splat_buffer_size = 64;
 /// Happens to be the same number that matches maximum number of handles that
 /// NtWaitForMultipleObjects accepts. We use this value also for poll() on
 /// posix systems.
 const poll_buffer_len = 64;
-const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
+pub const default_PATH = "/usr/local/bin:/bin/:/usr/bin";
 /// There are multiple kernel bugs being worked around with retries.
 const max_windows_kernel_bug_retries = 13;
 
@@ -1588,7 +1711,7 @@ fn worker(t: *Threaded) void {
         .cancel_protection = .unblocked,
         .futex_waiter = undefined,
         .unpark_flag = unpark_flag_init,
-        .csprng = .{},
+        .csprng = .uninitialized,
     };
     Thread.current = &thread;
 
@@ -2563,12 +2686,12 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
 fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
-        batchAwaitWindows(b, false) catch |err| switch (err) {
+        batchDrainSubmittedWindows(b, false) catch |err| switch (err) {
             error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
             else => |e| return e,
         };
         const alertable_syscall = try AlertableSyscall.start();
-        while (b.pending.head != .none and b.completions.head == .none) waitForApcOrAlert();
+        while (b.pending.head != .none and b.completed.head == .none) waitForApcOrAlert();
         alertable_syscall.finish();
         return;
     }
@@ -2576,7 +2699,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
         var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
         var poll_len: u32 = 0;
         {
-            var index = b.submissions.head;
+            var index = b.submitted.head;
             while (index != .none and poll_len < poll_buffer_len) {
                 const submission = &b.storage[index.toIndex()].submission;
                 switch (submission.operation) {
@@ -2605,7 +2728,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
             1 => {},
             else => while (true) {
                 const timeout_ms: i32 = t: {
-                    if (b.completions.head != .none) {
+                    if (b.completed.head != .none) {
                         // It is legal to call batchWait with already completed
                         // operations in the ring. In such case, we need to avoid
                         // blocking in the poll syscall, but we can still take this
@@ -2620,7 +2743,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                 switch (posix.errno(rc)) {
                     .SUCCESS => {
                         if (rc == 0) {
-                            if (b.completions.head != .none) {
+                            if (b.completed.head != .none) {
                                 // Since there are already completions available in the
                                 // queue, this is neither a timeout nor a case for
                                 // retrying.
@@ -2629,7 +2752,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                             continue;
                         }
                         var prev_index: Io.Operation.OptionalIndex = .none;
-                        var index = b.submissions.head;
+                        var index = b.submitted.head;
                         for (poll_buffer[0..poll_len]) |poll_entry| {
                             const storage = &b.storage[index.toIndex()];
                             const submission = &storage.submission;
@@ -2638,17 +2761,17 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                                 const result = try operate(t, submission.operation);
 
                                 switch (prev_index) {
-                                    .none => b.submissions.head = next_index,
+                                    .none => b.submitted.head = next_index,
                                     else => b.storage[prev_index.toIndex()].submission.node.next = next_index,
                                 }
-                                if (next_index == .none) b.submissions.tail = prev_index;
+                                if (next_index == .none) b.submitted.tail = prev_index;
 
-                                switch (b.completions.tail) {
-                                    .none => b.completions.head = index,
+                                switch (b.completed.tail) {
+                                    .none => b.completed.head = index,
                                     else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
                                 }
                                 storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
-                                b.completions.tail = index;
+                                b.completed.tail = index;
                             } else prev_index = index;
                             index = next_index;
                         }
@@ -2662,10 +2785,10 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
         }
     }
 
-    var tail_index = b.completions.tail;
-    defer b.completions.tail = tail_index;
-    var index = b.submissions.head;
-    errdefer b.submissions.head = index;
+    var tail_index = b.completed.tail;
+    defer b.completed.tail = tail_index;
+    var index = b.submitted.head;
+    errdefer b.submitted.head = index;
     while (index != .none) {
         const storage = &b.storage[index.toIndex()];
         const submission = &storage.submission;
@@ -2673,22 +2796,22 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
         const result = try operate(t, submission.operation);
 
         switch (tail_index) {
-            .none => b.completions.head = index,
+            .none => b.completed.head = index,
             else => b.storage[tail_index.toIndex()].completion.node.next = index,
         }
         storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
         tail_index = index;
         index = next_index;
     }
-    b.submissions = .{ .head = .none, .tail = .none };
+    b.submitted = .{ .head = .none, .tail = .none };
 }
 
 fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
         const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(ioBasic(t));
-        try batchAwaitWindows(b, true);
-        while (b.pending.head != .none and b.completions.head == .none) {
+        try batchDrainSubmittedWindows(b, true);
+        while (b.pending.head != .none and b.completed.head == .none) {
             var delay_interval: windows.LARGE_INTEGER = interval: {
                 const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
                 break :interval timeoutToWindowsInterval(.{ .deadline = d }).?;
@@ -2701,7 +2824,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
                     // The thread woke due to the timeout. Although spurious
                     // timeouts are OK, when no deadline is passed we must not
                     // return `error.Timeout`.
-                    if (timeout != .none and b.completions.head == .none) return error.Timeout;
+                    if (timeout != .none and b.completed.head == .none) return error.Timeout;
                 },
                 else => {},
             }
@@ -2743,7 +2866,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         }
     } = .{ .gpa = t.allocator, .b = b, .slice = &poll_buffer, .len = 0 };
     {
-        var index = b.submissions.head;
+        var index = b.submitted.head;
         while (index != .none) {
             const submission = &b.storage[index.toIndex()].submission;
             switch (submission.operation) {
@@ -2757,18 +2880,18 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     switch (poll_storage.len) {
         0 => return,
         1 => if (timeout == .none) {
-            const index = b.submissions.head;
+            const index = b.submitted.head;
             const storage = &b.storage[index.toIndex()];
             const result = try operate(t, storage.submission.operation);
 
-            b.submissions = .{ .head = .none, .tail = .none };
+            b.submitted = .{ .head = .none, .tail = .none };
 
-            switch (b.completions.tail) {
-                .none => b.completions.head = index,
+            switch (b.completed.tail) {
+                .none => b.completed.head = index,
                 else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
             }
             storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
-            b.completions.tail = index;
+            b.completed.tail = index;
             return;
         },
         else => {},
@@ -2777,7 +2900,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     const deadline = timeout.toTimestamp(t_io);
     while (true) {
         const timeout_ms: i32 = t: {
-            if (b.completions.head != .none) {
+            if (b.completed.head != .none) {
                 // It is legal to call batchWait with already completed
                 // operations in the ring. In such case, we need to avoid
                 // blocking in the poll syscall, but we can still take this
@@ -2794,7 +2917,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         switch (posix.errno(rc)) {
             .SUCCESS => {
                 if (rc == 0) {
-                    if (b.completions.head != .none) {
+                    if (b.completed.head != .none) {
                         // Since there are already completions available in the
                         // queue, this is neither a timeout nor a case for
                         // retrying.
@@ -2806,7 +2929,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
                     return error.Timeout;
                 }
                 var prev_index: Io.Operation.OptionalIndex = .none;
-                var index = b.submissions.head;
+                var index = b.submitted.head;
                 for (poll_storage.slice[0..poll_storage.len]) |poll_entry| {
                     const submission = &b.storage[index.toIndex()].submission;
                     const next_index = submission.node.next;
@@ -2814,17 +2937,20 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
                         const result = try operate(t, submission.operation);
 
                         switch (prev_index) {
-                            .none => b.submissions.head = next_index,
+                            .none => b.submitted.head = next_index,
                             else => b.storage[prev_index.toIndex()].submission.node.next = next_index,
                         }
-                        if (next_index == .none) b.submissions.tail = prev_index;
+                        if (next_index == .none) b.submitted.tail = prev_index;
 
-                        switch (b.completions.tail) {
-                            .none => b.completions.head = index,
+                        switch (b.completed.tail) {
+                            .none => b.completed.head = index,
                             else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
                         }
-                        b.completions.tail = index;
-                        b.storage[index.toIndex()] = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+                        b.completed.tail = index;
+                        b.storage[index.toIndex()] = .{ .completion = .{
+                            .node = .{ .next = .none },
+                            .result = result,
+                        } };
                     } else prev_index = index;
                     index = next_index;
                 }
@@ -2841,7 +2967,7 @@ const WindowsBatchPendingOperationContext = extern struct {
     file: windows.HANDLE,
     iosb: windows.IO_STATUS_BLOCK,
 
-    const Erased = [3]usize;
+    const Erased = Io.Operation.Storage.Pending.Context;
 
     comptime {
         assert(@sizeOf(Erased) <= @sizeOf(WindowsBatchPendingOperationContext));
@@ -2858,24 +2984,9 @@ const WindowsBatchPendingOperationContext = extern struct {
 
 fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    {
-        var tail_index = b.unused.tail;
-        defer b.unused.tail = tail_index;
-        var index = b.submissions.head;
-        errdefer b.submissions.head = index;
-        while (index != .none) {
-            const next_index = b.storage[index.toIndex()].submission.node.next;
-            switch (tail_index) {
-                .none => b.unused.head = index,
-                else => b.storage[tail_index.toIndex()].unused.next = index,
-            }
-            b.storage[index.toIndex()] = .{ .unused = .{ .prev = tail_index, .next = .none } };
-            tail_index = index;
-            index = next_index;
-        }
-        b.submissions = .{ .head = .none, .tail = .none };
-    }
     if (is_windows) {
+        if (b.pending.head == .none) return;
+        waitForApcOrAlert();
         var index = b.pending.head;
         while (index != .none) {
             const pending = &b.storage[index.toIndex()].pending;
@@ -2889,10 +3000,13 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
         t.allocator.free(@as([*]posix.pollfd, @ptrCast(@alignCast(context)))[0..b.storage.len]);
         b.context = null;
     }
-    assert(b.pending.head == .none);
 }
 
-fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows.ULONG) callconv(.winapi) void {
+fn batchApc(
+    apc_context: ?*anyopaque,
+    iosb: *windows.IO_STATUS_BLOCK,
+    _: windows.ULONG,
+) callconv(.winapi) void {
     const b: *Io.Batch = @ptrCast(@alignCast(apc_context));
     const context: *WindowsBatchPendingOperationContext = @fieldParentPtr("iosb", iosb);
     const erased_context = context.toErased();
@@ -2918,11 +3032,12 @@ fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows
             b.unused.tail = .fromIndex(index);
         },
         else => {
-            switch (b.completions.tail) {
-                .none => b.completions.head = .fromIndex(index),
-                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = .fromIndex(index),
+            switch (b.completed.tail) {
+                .none => b.completed.head = .fromIndex(index),
+                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next =
+                    .fromIndex(index),
             }
-            b.completions.tail = .fromIndex(index);
+            b.completed.tail = .fromIndex(index);
             const result: Io.Operation.Result = switch (pending.tag) {
                 .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
                 .file_write_streaming => .{ .file_write_streaming = ntWriteFileResult(iosb) },
@@ -2934,9 +3049,9 @@ fn batchApc(apc_context: ?*anyopaque, iosb: *windows.IO_STATUS_BLOCK, _: windows
 }
 
 /// If `concurrency` is false, `error.ConcurrencyUnavailable` is unreachable.
-fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, ConcurrencyUnavailable }!void {
-    var index = b.submissions.head;
-    errdefer b.submissions.head = index;
+fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentError || Io.Cancelable)!void {
+    var index = b.submitted.head;
+    errdefer b.submitted.head = index;
     while (index != .none) {
         const storage = &b.storage[index.toIndex()];
         const submission = storage.submission;
@@ -2952,7 +3067,7 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
         b.pending.tail = index;
         const context: *WindowsBatchPendingOperationContext = .fromErased(&storage.pending.context);
         errdefer {
-            context.iosb.u.Status = .CANCELLED;
+            context.iosb = .{ .u = .{ .Status = .CANCELLED }, .Information = undefined };
             batchApc(b, &context.iosb, 0);
         }
         switch (submission.operation) {
@@ -2960,10 +3075,7 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
                 var data_index: usize = 0;
                 while (o.data.len - data_index != 0 and o.data[data_index].len == 0) data_index += 1;
                 if (o.data.len - data_index == 0) {
-                    context.iosb = .{
-                        .u = .{ .Status = .SUCCESS },
-                        .Information = 0,
-                    };
+                    context.iosb = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
                     batchApc(b, &context.iosb, 0);
                     break :o;
                 }
@@ -3023,10 +3135,7 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
             .file_write_streaming => |o| o: {
                 const buffer = windowsWriteBuffer(o.header, o.data, o.splat);
                 if (buffer.len == 0) {
-                    context.iosb = .{
-                        .u = .{ .Status = .SUCCESS },
-                        .Information = 0,
-                    };
+                    context.iosb = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
                     batchApc(b, &context.iosb, 0);
                     break :o;
                 }
@@ -3140,7 +3249,7 @@ fn batchAwaitWindows(b: *Io.Batch, concurrency: bool) error{ Canceled, Concurren
         }
         index = submission.node.next;
     }
-    b.submissions = .{ .head = .none, .tail = .none };
+    b.submitted = .{ .head = .none, .tail = .none };
 }
 
 /// Since Windows only supports writing one contiguous buffer, returns the
@@ -3155,7 +3264,7 @@ fn windowsWriteBuffer(header: []const u8, data: []const []const u8, splat: usize
         if (splat == 0) return &.{};
         break :b data[data.len - 1];
     };
-    return buffer[0..@min(buffer.len, std.math.maxInt(u32))];
+    return buffer[0..std.math.lossyCast(u32, buffer.len)];
 }
 
 fn submitComplete(ring: []u32, complete_tail: *Io.Batch.RingIndex, op: u32) void {
@@ -4677,8 +4786,8 @@ fn atomicFileInit(
     dir: Dir,
     close_dir_on_deinit: bool,
 ) Dir.CreateFileAtomicError!File.Atomic {
-    var random_integer: u64 = undefined;
     while (true) {
+        var random_integer: u64 = undefined;
         t_io.random(@ptrCast(&random_integer));
         const tmp_sub_path = std.fmt.hex(random_integer);
         const file = dir.createFile(t_io, &tmp_sub_path, .{
@@ -14317,11 +14426,11 @@ pub fn posixProtocol(protocol: ?net.Protocol) u32 {
     return @intFromEnum(protocol orelse return 0);
 }
 
-fn recoverableOsBugDetected() void {
+pub fn recoverableOsBugDetected() void {
     if (is_debug) unreachable;
 }
 
-fn clockToPosix(clock: Io.Clock) posix.clockid_t {
+pub fn clockToPosix(clock: Io.Clock) posix.clockid_t {
     return switch (clock) {
         .real => posix.CLOCK.REALTIME,
         .awake => switch (native_os) {
@@ -14355,7 +14464,7 @@ fn clockToWasi(clock: Io.Clock) std.os.wasi.clockid_t {
     };
 }
 
-const linux_statx_request: std.os.linux.STATX = .{
+pub const linux_statx_request: std.os.linux.STATX = .{
     .TYPE = true,
     .MODE = true,
     .ATIME = true,
@@ -14367,7 +14476,7 @@ const linux_statx_request: std.os.linux.STATX = .{
     .BLOCKS = true,
 };
 
-const linux_statx_check: std.os.linux.STATX = .{
+pub const linux_statx_check: std.os.linux.STATX = .{
     .TYPE = true,
     .MODE = true,
     .ATIME = false,
@@ -14379,7 +14488,7 @@ const linux_statx_check: std.os.linux.STATX = .{
     .BLOCKS = false,
 };
 
-fn statFromLinux(stx: *const std.os.linux.Statx) Io.UnexpectedError!File.Stat {
+pub fn statFromLinux(stx: *const std.os.linux.Statx) Io.UnexpectedError!File.Stat {
     const actual_mask_int: u32 = @bitCast(stx.mask);
     const wanted_mask_int: u32 = @bitCast(linux_statx_check);
     if ((actual_mask_int | wanted_mask_int) != actual_mask_int) return error.Unexpected;
@@ -14470,11 +14579,11 @@ fn statFromWasi(st: *const std.os.wasi.filestat_t) File.Stat {
     };
 }
 
-fn timestampFromPosix(timespec: *const posix.timespec) Io.Timestamp {
+pub fn timestampFromPosix(timespec: *const posix.timespec) Io.Timestamp {
     return .{ .nanoseconds = nanosecondsFromPosix(timespec) };
 }
 
-fn nanosecondsFromPosix(timespec: *const posix.timespec) i96 {
+pub fn nanosecondsFromPosix(timespec: *const posix.timespec) i96 {
     return @intCast(@as(i128, timespec.sec) * std.time.ns_per_s + timespec.nsec);
 }
 
@@ -14492,7 +14601,7 @@ fn timestampToPosix(nanoseconds: i96) posix.timespec {
     };
 }
 
-fn setTimestampToPosix(set_ts: File.SetTimestamp) posix.timespec {
+pub fn setTimestampToPosix(set_ts: File.SetTimestamp) posix.timespec {
     return switch (set_ts) {
         .unchanged => .OMIT,
         .now => .NOW,
@@ -14500,7 +14609,7 @@ fn setTimestampToPosix(set_ts: File.SetTimestamp) posix.timespec {
     };
 }
 
-fn pathToPosix(file_path: []const u8, buffer: *[posix.PATH_MAX]u8) Dir.PathNameError![:0]u8 {
+pub fn pathToPosix(file_path: []const u8, buffer: *[posix.PATH_MAX]u8) Dir.PathNameError![:0]u8 {
     if (std.mem.containsAtLeastScalar2(u8, file_path, 0, 1)) return error.BadPathName;
     // >= rather than > to make room for the null byte
     if (file_path.len >= buffer.len) return error.NameTooLong;
@@ -14996,126 +15105,7 @@ const WindowsEnvironStrings = struct {
 fn scanEnviron(t: *Threaded) void {
     mutexLock(&t.mutex);
     defer mutexUnlock(&t.mutex);
-
-    if (t.environ.initialized) return;
-    t.environ.initialized = true;
-
-    if (is_windows) {
-        // This value expires with any call that modifies the environment,
-        // which is outside of this Io implementation's control, so references
-        // must be short-lived.
-        const peb = windows.peb();
-        assert(windows.ntdll.RtlEnterCriticalSection(peb.FastPebLock) == .SUCCESS);
-        defer assert(windows.ntdll.RtlLeaveCriticalSection(peb.FastPebLock) == .SUCCESS);
-        const ptr = peb.ProcessParameters.Environment;
-
-        var i: usize = 0;
-        while (ptr[i] != 0) {
-
-            // There are some special environment variables that start with =,
-            // so we need a special case to not treat = as a key/value separator
-            // if it's the first character.
-            // https://devblogs.microsoft.com/oldnewthing/20100506-00/?p=14133
-            const key_start = i;
-            if (ptr[i] == '=') i += 1;
-            while (ptr[i] != 0 and ptr[i] != '=') : (i += 1) {}
-            const key_w = ptr[key_start..i];
-
-            const value_start = i + 1;
-            while (ptr[i] != 0) : (i += 1) {} // skip over '=' and value
-            const value_w = ptr[value_start..i];
-            i += 1; // skip over null byte
-
-            if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'N', 'O', '_', 'C', 'O', 'L', 'O', 'R' })) {
-                t.environ.exist.NO_COLOR = true;
-            } else if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'C', 'L', 'I', 'C', 'O', 'L', 'O', 'R', '_', 'F', 'O', 'R', 'C', 'E' })) {
-                t.environ.exist.CLICOLOR_FORCE = true;
-            } else if (windows.eqlIgnoreCaseWtf16(key_w, &.{ 'Z', 'I', 'G', '_', 'P', 'R', 'O', 'G', 'R', 'E', 'S', 'S' })) {
-                t.environ.zig_progress_file = file: {
-                    var value_buf: [std.fmt.count("{d}", .{std.math.maxInt(usize)})]u8 = undefined;
-                    const len = std.unicode.calcWtf8Len(value_w);
-                    if (len > value_buf.len) break :file error.UnrecognizedFormat;
-                    assert(std.unicode.wtf16LeToWtf8(&value_buf, value_w) == len);
-                    break :file .{
-                        .handle = @ptrFromInt(std.fmt.parseInt(usize, value_buf[0..len], 10) catch
-                            break :file error.UnrecognizedFormat),
-                        .flags = .{ .nonblocking = true },
-                    };
-                };
-            }
-            comptime assert(@sizeOf(Environ.String) == 0);
-        }
-    } else if (native_os == .wasi and !builtin.link_libc) {
-        var environ_count: usize = undefined;
-        var environ_buf_size: usize = undefined;
-
-        switch (std.os.wasi.environ_sizes_get(&environ_count, &environ_buf_size)) {
-            .SUCCESS => {},
-            else => |err| {
-                t.environ.err = posix.unexpectedErrno(err);
-                return;
-            },
-        }
-        if (environ_count == 0) return;
-
-        const environ = t.allocator.alloc([*:0]u8, environ_count) catch |err| {
-            t.environ.err = err;
-            return;
-        };
-        defer t.allocator.free(environ);
-        const environ_buf = t.allocator.alloc(u8, environ_buf_size) catch |err| {
-            t.environ.err = err;
-            return;
-        };
-        defer t.allocator.free(environ_buf);
-
-        switch (std.os.wasi.environ_get(environ.ptr, environ_buf.ptr)) {
-            .SUCCESS => {},
-            else => |err| {
-                t.environ.err = posix.unexpectedErrno(err);
-                return;
-            },
-        }
-
-        for (environ) |env| {
-            const pair = std.mem.sliceTo(env, 0);
-            var parts = std.mem.splitScalar(u8, pair, '=');
-            const key = parts.first();
-            if (std.mem.eql(u8, key, "NO_COLOR")) {
-                t.environ.exist.NO_COLOR = true;
-            } else if (std.mem.eql(u8, key, "CLICOLOR_FORCE")) {
-                t.environ.exist.CLICOLOR_FORCE = true;
-            }
-            comptime assert(@sizeOf(Environ.String) == 0);
-        }
-    } else {
-        for (t.environ.process_environ.block.slice) |opt_entry| {
-            const entry = opt_entry.?;
-            var entry_i: usize = 0;
-            while (entry[entry_i] != 0 and entry[entry_i] != '=') : (entry_i += 1) {}
-            const key = entry[0..entry_i];
-
-            var end_i: usize = entry_i;
-            while (entry[end_i] != 0) : (end_i += 1) {}
-            const value = entry[entry_i + 1 .. end_i :0];
-
-            if (std.mem.eql(u8, key, "NO_COLOR")) {
-                t.environ.exist.NO_COLOR = true;
-            } else if (std.mem.eql(u8, key, "CLICOLOR_FORCE")) {
-                t.environ.exist.CLICOLOR_FORCE = true;
-            } else if (std.mem.eql(u8, key, "ZIG_PROGRESS")) {
-                t.environ.zig_progress_file = file: {
-                    break :file .{
-                        .handle = std.fmt.parseInt(u31, value, 10) catch
-                            break :file error.UnrecognizedFormat,
-                        .flags = .{ .nonblocking = true },
-                    };
-                };
-            } else inline for (@typeInfo(Environ.String).@"struct".fields) |field| {
-                if (std.mem.eql(u8, key, field.name)) @field(t.environ.string, field.name) = value;
-            }
-        }
-    }
+    t.environ.scan(t.allocator);
 }
 
 fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError {
@@ -15213,17 +15203,17 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     const any_ignore = (options.stdin == .ignore or options.stdout == .ignore or options.stderr == .ignore);
     const dev_null_fd = if (any_ignore) try getDevNullFd(t) else undefined;
 
-    const prog_pipe: [2]posix.fd_t = if (options.progress_node.index != .none)
+    const prog_pipe: [2]posix.fd_t = if (options.progress_node.index != .none) pipe: {
         // We use CLOEXEC for the same reason as in `pipe_flags`.
-        try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true })
-    else
-        .{ -1, -1 };
+        const pipe = try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true });
+        switch (native_os) {
+            .linux => _ = posix.system.fcntl(pipe[0], posix.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2)),
+            else => {},
+        }
+        break :pipe pipe;
+    } else .{ -1, -1 };
     errdefer destroyPipe(prog_pipe);
 
-    if (native_os == .linux and prog_pipe[0] != -1) {
-        _ = posix.system.fcntl(prog_pipe[0], posix.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2));
-    }
-
     var arena_allocator = std.heap.ArenaAllocator.init(t.allocator);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
@@ -17241,16 +17231,7 @@ fn randomMainThread(t: *Threaded, buffer: []u8) void {
 
             randomSecure(t, &seed) catch |err| switch (err) {
                 error.Canceled => unreachable,
-                error.EntropyUnavailable => {
-                    @memset(&seed, 0);
-                    const aslr_addr = @intFromPtr(t);
-                    std.mem.writeInt(usize, seed[seed.len - @sizeOf(usize) ..][0..@sizeOf(usize)], aslr_addr, .native);
-                    switch (native_os) {
-                        .windows => fallbackSeedWindows(&seed),
-                        .wasi => if (builtin.link_libc) fallbackSeedPosix(&seed) else fallbackSeedWasi(&seed),
-                        else => fallbackSeedPosix(&seed),
-                    }
-                },
+                error.EntropyUnavailable => fallbackSeed(t, &seed),
             };
         }
         t.csprng.rng = .init(seed);
@@ -17259,6 +17240,17 @@ fn randomMainThread(t: *Threaded, buffer: []u8) void {
     t.csprng.rng.fill(buffer);
 }
 
+pub fn fallbackSeed(aslr_addr: ?*anyopaque, seed: *[Csprng.seed_len]u8) void {
+    @memset(seed, 0);
+    std.mem.writeInt(usize, seed[seed.len - @sizeOf(usize) ..][0..@sizeOf(usize)], @intFromPtr(aslr_addr), .native);
+    const fallbackSeedImpl = switch (native_os) {
+        .windows => fallbackSeedWindows,
+        .wasi => if (builtin.link_libc) fallbackSeedPosix else fallbackSeedWasi,
+        else => fallbackSeedPosix,
+    };
+    fallbackSeedImpl(seed);
+}
+
 fn fallbackSeedPosix(seed: *[Csprng.seed_len]u8) void {
     std.mem.writeInt(posix.pid_t, seed[0..@sizeOf(posix.pid_t)], posix.system.getpid(), .native);
     const i_1 = @sizeOf(posix.pid_t);
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index c89585b9ba82c0ae6896a8284b91974bf2ceaeb2..7f168994321c3e88074b20f91b0dfabaf76892eb 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -6717,9 +6717,10 @@ pub const IORING_ACCEPT_MULTISHOT = 1 << 0;
 /// IORING_OP_MSG_RING command types, stored in sqe->addr
 pub const IORING_MSG_RING_COMMAND = enum(u8) {
     /// pass sqe->len as 'res' and off as user_data
-    DATA,
+    DATA = 0,
     /// send a registered fd to another ring
-    SEND_FD,
+    SEND_FD = 1,
+    _,
 };
 
 // io_uring_sqe.msg_ring_flags (rw_flags in the Zig struct)
@@ -6772,6 +6773,8 @@ pub const IORING_CQE_F_SOCK_NONEMPTY = 1 << 2;
 pub const IORING_CQE_F_NOTIF = 1 << 3;
 /// If set, the buffer ID set in the completion will get more completions.
 pub const IORING_CQE_F_BUF_MORE = 1 << 4;
+pub const IORING_CQE_F_SKIP = 1 << 5;
+pub const IORING_CQE_F_32 = 1 << 15;
 
 pub const IORING_CQE_BUFFER_SHIFT = 16;
 
@@ -7068,7 +7071,7 @@ pub const IORING_RESTRICTION = enum(u16) {
     _,
 };
 
-pub const IO_URING_SOCKET_OP = enum(u16) {
+pub const IO_URING_SOCKET_OP = enum(u32) {
     SIOCIN = 0,
     SIOCOUTQ = 1,
     GETSOCKOPT = 2,
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 2e3056b96099412d672fcc8f6fd4b5eca8768096..fca2d0c773c47359e33f9c5d47ebe316fbde327b 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -60,7 +60,7 @@ pub const CurrentPathError = error{
     NameTooLong,
     /// Not possible on Windows. Always returned on WASI.
     CurrentDirUnlinked,
-} || Io.UnexpectedError;
+} || Io.Cancelable || Io.UnexpectedError;
 
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// On other platforms, the result is an opaque sequence of bytes with no
@@ -72,7 +72,7 @@ pub fn currentPath(io: Io, buffer: []u8) CurrentPathError!usize {
 pub const CurrentPathAllocError = Allocator.Error || error{
     /// Not possible on Windows. Always returned on WASI.
     CurrentDirUnlinked,
-} || Io.UnexpectedError;
+} || Io.Cancelable || Io.UnexpectedError;
 
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// On other platforms, the result is an opaque sequence of bytes with no
@@ -355,7 +355,7 @@ pub const SpawnError = error{
     /// On Windows, the volume does not contain a recognized file system. File
     /// system drivers might not be loaded, or the volume may be corrupt.
     UnrecognizedVolume,
-} || Io.Dir.PathNameError || Io.Cancelable || Io.UnexpectedError;
+} || Io.File.OpenError || Io.Dir.PathNameError || Io.Cancelable || Io.UnexpectedError;
 
 pub const SpawnOptions = struct {
     argv: []const []const u8,
diff --git a/lib/std/tar.zig b/lib/std/tar.zig
index 024a425919af7544339f9ee731f7947bd2d86c07..d108a03219ddfc0c29161972b0cb3707470fb3c5 100644
--- a/lib/std/tar.zig
+++ b/lib/std/tar.zig
@@ -1128,10 +1128,10 @@ fn filePermissions(mode: u32, options: PipeOptions) Io.File.Permissions {
 
 test filePermissions {
     if (!Io.File.Permissions.has_executable_bit) return error.SkipZigTest;
-    try testing.expectEqual(.default_file, filePermissions(0o744, .{ .mode_mode = .ignore }));
-    try testing.expectEqual(.executable_file, filePermissions(0o744, .{}));
-    try testing.expectEqual(.default_file, filePermissions(0o644, .{}));
-    try testing.expectEqual(.default_file, filePermissions(0o655, .{}));
+    try testing.expectEqual(Io.File.Permissions.default_file, filePermissions(0o744, .{ .mode_mode = .ignore }));
+    try testing.expectEqual(Io.File.Permissions.executable_file, filePermissions(0o744, .{}));
+    try testing.expectEqual(Io.File.Permissions.default_file, filePermissions(0o644, .{}));
+    try testing.expectEqual(Io.File.Permissions.default_file, filePermissions(0o655, .{}));
 }
 
 test "executable bit" {
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 4f671b71b944886940d74f1dd6639b76b28e1aaf..608bbe4a94f7fa4ffcf752175043e80b238a0d14 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -4891,11 +4891,7 @@ fn performAllTheWork(
 
     work: while (true) {
         for (&comp.work_queues) |*work_queue| if (work_queue.popFront()) |job| {
-            try processOneJob(
-                @intFromEnum(Zcu.PerThread.Id.main),
-                comp,
-                job,
-            );
+            try processOneJob(.main, comp, job);
             continue :work;
         };
         if (comp.zcu) |zcu| {
@@ -5160,11 +5156,7 @@ pub fn queueJobs(comp: *Compilation, jobs: []const Job) !void {
     for (jobs) |job| try comp.queueJob(job);
 }
 
-fn processOneJob(
-    tid: usize,
-    comp: *Compilation,
-    job: Job,
-) JobError!void {
+fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!void {
     switch (job) {
         .codegen_func => |func| {
             const zcu = comp.zcu.?;
@@ -5232,7 +5224,7 @@ fn processOneJob(
             const named_frame = tracy.namedFrame("analyze_func");
             defer named_frame.end();
 
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));
+            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
 
             pt.ensureFuncBodyUpToDate(func) catch |err| switch (err) {
@@ -5245,7 +5237,7 @@ fn processOneJob(
             const named_frame = tracy.namedFrame("analyze_comptime_unit");
             defer named_frame.end();
 
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));
+            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
 
             const maybe_err: Zcu.SemaError!void = switch (unit.unwrap()) {
@@ -5285,7 +5277,7 @@ fn processOneJob(
             const named_frame = tracy.namedFrame("resolve_type_fully");
             defer named_frame.end();
 
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));
+            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
             Type.fromInterned(ty).resolveFully(pt) catch |err| switch (err) {
                 error.OutOfMemory, error.Canceled => |e| return e,
@@ -5296,7 +5288,7 @@ fn processOneJob(
             const named_frame = tracy.namedFrame("analyze_mod");
             defer named_frame.end();
 
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));
+            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
             pt.semaMod(mod) catch |err| switch (err) {
                 error.OutOfMemory, error.Canceled => |e| return e,
@@ -5642,13 +5634,14 @@ fn workerUpdateFile(
     prog_node: std.Progress.Node,
     group: *Io.Group,
 ) void {
-    const tid = Compilation.getTid();
     const io = comp.io;
+    const tid: Zcu.PerThread.Id = .acquire(io);
+    defer tid.release(io);
 
     const child_prog_node = prog_node.start(fs.path.basename(file.path.sub_path), 0);
     defer child_prog_node.end();
 
-    const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));
+    const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
     defer pt.deactivate();
     pt.updateFile(file_index, file) catch |err| {
         pt.reportRetryableFileError(file_index, "unable to load '{s}': {s}", .{ fs.path.basename(file.path.sub_path), @errorName(err) }) catch |oom| switch (oom) {
@@ -5708,9 +5701,10 @@ fn workerUpdateBuiltinFile(comp: *Compilation, file: *Zcu.File) void {
 }
 
 fn workerUpdateEmbedFile(comp: *Compilation, ef_index: Zcu.EmbedFile.Index, ef: *Zcu.EmbedFile) void {
-    const tid = Compilation.getTid();
     const io = comp.io;
-    comp.detectEmbedFileUpdate(@enumFromInt(tid), ef_index, ef) catch |err| switch (err) {
+    const tid: Zcu.PerThread.Id = .acquire(io);
+    defer tid.release(io);
+    comp.detectEmbedFileUpdate(tid, ef_index, ef) catch |err| switch (err) {
         error.OutOfMemory => {
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
@@ -5868,7 +5862,7 @@ pub fn translateC(
     }
 
     var stdout: []u8 = undefined;
-    try @import("main.zig").translateC(gpa, arena, io, argv.items, environ_map, prog_node, &stdout);
+    try @import("main.zig").translateC(gpa, arena, io, argv.items, environ_map, prog_node, comp.thread_limit, &stdout);
 
     if (out_dep_path) |dep_file_path| add_deps: {
         if (comp.verbose_cimport) log.info("processing dep file at {s}", .{dep_file_path});
@@ -8394,17 +8388,3 @@ pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode {
 pub fn compilerRtStrip(comp: Compilation) bool {
     return comp.root_mod.strip;
 }
-
-/// This is a temporary workaround put in place to migrate from `std.Thread.Pool`
-/// to `std.Io.Threaded` for asynchronous/concurrent work. The eventual solution
-/// will likely involve significant changes to the `InternPool` implementation.
-pub fn getTid() usize {
-    if (my_tid == null) my_tid = next_tid.fetchAdd(1, .monotonic);
-    return my_tid.?;
-}
-pub fn setMainThread() void {
-    my_tid = 0;
-}
-/// TID 0 is reserved for the main thread.
-var next_tid: std.atomic.Value(usize) = .init(1);
-threadlocal var my_tid: ?usize = null;
diff --git a/src/InternPool.zig b/src/InternPool.zig
index d713adcd3082851a3ee01a37819d0d62ffccdc1c..595bedd5473653ccc2885b3181d5007dfe0b926e 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -3,6 +3,7 @@
 const InternPool = @This();
 
 const builtin = @import("builtin");
+const build_options = @import("build_options");
 
 const std = @import("std");
 const Io = std.Io;
@@ -86,13 +87,11 @@ dep_entries: std.ArrayList(DepEntry),
 /// garbage collection pass.
 free_dep_entries: std.ArrayList(DepEntry.Index),
 
-/// Whether a multi-threaded intern pool is useful.
-/// Currently `false` until the intern pool is actually accessed
-/// from multiple threads to reduce the cost of this data structure.
-const want_multi_threaded = true;
-
 /// Whether a single-threaded intern pool impl is in use.
-pub const single_threaded = builtin.single_threaded or !want_multi_threaded;
+pub const single_threaded = switch (build_options.io_mode) {
+    .threaded => builtin.single_threaded,
+    .evented => false, // even without threads, evented can be access from multiple tasks at a time
+};
 
 pub const empty: InternPool = .{
     .locals = &.{},
@@ -6915,7 +6914,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, io: Io, available_threads: usize) !
     assert(ip.locals.len == 0 and ip.shards.len == 0);
     assert(available_threads > 0 and available_threads <= std.math.maxInt(u8));
 
-    const used_threads = if (single_threaded) 1 else available_threads;
+    const used_threads = if (single_threaded) 1 else @max(available_threads, 2);
     ip.locals = try gpa.alloc(Local, used_threads);
     @memset(ip.locals, .{
         .shared = .{
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 6a2872eae8fa3c0d3ce1beed7a29c1b080c4d1b2..f2d6dbf497a1f47faef87d208c082c364867bb9e 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4954,8 +4954,10 @@ pub const CodegenTaskPool = struct {
         // We own `air` now, so we are responsbile for freeing it.
         var air = orig_air;
         defer air.deinit(zcu.comp.gpa);
-        const tid = Compilation.getTid();
-        const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
+        const io = zcu.comp.io;
+        const tid: Zcu.PerThread.Id = .acquire(io);
+        defer tid.release(io);
+        const pt: Zcu.PerThread = .activate(zcu, tid);
         defer pt.deactivate();
         return pt.runCodegen(func_index, &air);
     }
@@ -4964,8 +4966,10 @@ pub const CodegenTaskPool = struct {
         func_index: InternPool.Index,
         air: *Air,
     ) CodegenResult {
-        const tid = Compilation.getTid();
-        const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
+        const io = zcu.comp.io;
+        const tid: Zcu.PerThread.Id = .acquire(io);
+        defer tid.release(io);
+        const pt: Zcu.PerThread = .activate(zcu, tid);
         defer pt.deactivate();
         return pt.runCodegen(func_index, air);
     }
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 56b09d9da1110eaf2491bff1ff03e7b5e6b50c53..5472afc5f02682b3f9083b4d710e1c5616c74d57 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -41,13 +41,86 @@ zcu: *Zcu,
 tid: Id,
 
 pub const IdBacking = u7;
-pub const Id = if (InternPool.single_threaded) enum { main } else enum(IdBacking) { main, _ };
+pub const Id = if (InternPool.single_threaded) enum {
+    main,
+
+    pub fn allocate(arena: Allocator, n: usize) Allocator.Error!void {
+        _ = arena;
+        _ = n;
+    }
+    pub fn acquire(io: std.Io) Id {
+        _ = io;
+        return .main;
+    }
+    pub fn release(tid: Id, io: std.Io) void {
+        _ = io;
+        _ = tid;
+    }
+} else enum(IdBacking) {
+    main,
+    _,
+
+    var tid_mutex: std.Io.Mutex = .init;
+    var tid_cond: std.Io.Condition = .init;
+    /// This is a temporary workaround put in place to migrate from `std.Thread.Pool`
+    /// to `std.Io.Threaded` for asynchronous/concurrent work. The eventual solution
+    /// will likely involve significant changes to the `InternPool` implementation.
+    var available_tids: std.ArrayList(Id) = .empty;
+    threadlocal var recursive_depth: usize = 0;
+    threadlocal var recursive_tid: Id = .main;
+
+    pub fn allocate(arena: Allocator, n: usize) Allocator.Error!void {
+        assert(available_tids.items.len == 0);
+        try available_tids.ensureTotalCapacityPrecise(arena, n - 1);
+        for (1..n) |tid| available_tids.appendAssumeCapacity(@enumFromInt(tid));
+    }
+    pub fn acquire(io: std.Io) Id {
+        switch (build_options.io_mode) {
+            .threaded => {
+                recursive_depth += 1;
+                if (recursive_depth > 1) {
+                    assert(recursive_tid != .main);
+                    return recursive_tid;
+                }
+            },
+            .evented => {},
+        }
+        tid_mutex.lockUncancelable(io);
+        defer tid_mutex.unlock(io);
+        while (true) {
+            if (available_tids.pop()) |tid| {
+                switch (build_options.io_mode) {
+                    .threaded => recursive_tid = tid,
+                    .evented => {},
+                }
+                return tid;
+            }
+            tid_cond.waitUncancelable(io, &tid_mutex);
+        }
+    }
+    pub fn release(tid: Id, io: std.Io) void {
+        switch (build_options.io_mode) {
+            .threaded => {
+                assert(recursive_tid == tid);
+                recursive_depth -= 1;
+                if (recursive_depth > 0) return;
+                recursive_tid = .main;
+            },
+            .evented => {},
+        }
+        {
+            tid_mutex.lockUncancelable(io);
+            defer tid_mutex.unlock(io);
+            available_tids.appendAssumeCapacity(tid);
+        }
+        tid_cond.signal(io);
+    }
+};
 
 pub fn activate(zcu: *Zcu, tid: Id) Zcu.PerThread {
     zcu.intern_pool.activate();
     return .{ .zcu = zcu, .tid = tid };
 }
-
 pub fn deactivate(pt: Zcu.PerThread) void {
     pt.zcu.intern_pool.deactivate();
 }
diff --git a/src/crash_report.zig b/src/crash_report.zig
index e56bc7cec53e8a2e057ab52cf1c4055b1539fd59..41d56e8aaf4637130b97ee6cc79c3aa623c4770c 100644
--- a/src/crash_report.zig
+++ b/src/crash_report.zig
@@ -1,34 +1,14 @@
-/// We override the panic implementation to our own one, so we can print our own information before
-/// calling the default panic handler. This declaration must be re-exposed from `@import("root")`.
-pub const panic = if (dev.env == .bootstrap)
-    std.debug.simple_panic
-else
-    std.debug.FullPanic(panicImpl);
-
-/// We let std install its segfault handler, but we override the target-agnostic handler it calls,
-/// so we can print our own information before calling the default segfault logic. This declaration
-/// must be re-exposed from `@import("root")`.
-pub const debug = struct {
-    pub const handleSegfault = handleSegfaultImpl;
-};
-
 /// Printed in panic messages when suggesting a command to run, allowing copy-pasting the command.
 /// Set by `main` as soon as arguments are known. The value here is a default in case we somehow
 /// crash earlier than that.
 pub var zig_argv0: []const u8 = "zig";
 
-fn handleSegfaultImpl(addr: ?usize, name: []const u8, opt_ctx: ?std.debug.CpuContextPtr) noreturn {
-    @branchHint(.cold);
-    dumpCrashContext() catch {};
-    std.debug.defaultHandleSegfault(addr, name, opt_ctx);
-}
-fn panicImpl(msg: []const u8, first_trace_addr: ?usize) noreturn {
-    @branchHint(.cold);
-    dumpCrashContext() catch {};
-    std.debug.defaultPanic(msg, first_trace_addr orelse @returnAddress());
-}
+const enabled = switch (build_options.io_mode) {
+    .threaded => build_options.enable_debug_extensions,
+    .evented => false, // would use threadlocals in a way incompatible with evented
+};
 
-pub const AnalyzeBody = if (build_options.enable_debug_extensions) struct {
+pub const AnalyzeBody = if (enabled) struct {
     parent: ?*AnalyzeBody,
     sema: *Sema,
     block: *Sema.Block,
@@ -63,7 +43,7 @@ pub const AnalyzeBody = if (build_options.enable_debug_extensions) struct {
     pub inline fn setBodyIndex(_: @This(), _: usize) void {}
 };
 
-pub const CodegenFunc = if (build_options.enable_debug_extensions) struct {
+pub const CodegenFunc = if (enabled) struct {
     zcu: *const Zcu,
     func_index: InternPool.Index,
     threadlocal var current: ?CodegenFunc = null;
@@ -82,23 +62,14 @@ pub const CodegenFunc = if (build_options.enable_debug_extensions) struct {
     pub fn stop(_: InternPool.Index) void {}
 };
 
-fn dumpCrashContext() Io.Writer.Error!void {
+pub fn dumpCrashContext(terminal: Io.Terminal) Io.Writer.Error!void {
     const S = struct {
-        /// In the case of recursive panics or segfaults, don't print the context for a second time.
-        threadlocal var already_dumped = false;
         /// TODO: make this unnecessary. It exists because `print_zir` currently needs an allocator,
         /// but that shouldn't be necessary---it's already only used in one place.
-        threadlocal var crash_heap: [64 * 1024]u8 = undefined;
+        var crash_heap: [64 * 1024]u8 = undefined;
     };
-    if (S.already_dumped) return;
-    S.already_dumped = true;
-
-    // TODO: this does mean that a different thread could grab the stderr mutex between the context
-    // and the actual panic printing, which would be quite confusing.
-    const stderr = std.debug.lockStderr(&.{});
-    defer std.debug.unlockStderr();
-    const w = &stderr.file_writer.interface;
 
+    const w = terminal.writer;
     try w.writeAll("Compiler crash context:\n");
 
     if (CodegenFunc.current) |*cg| {
diff --git a/src/introspect.zig b/src/introspect.zig
index 0cba9fdcc4d5d97f03559ab205d3710f54205176..13d00520936973fccc37ede11256842e0826f423 100644
--- a/src/introspect.zig
+++ b/src/introspect.zig
@@ -54,11 +54,7 @@ pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
 /// Like `std.process.currentPathAlloc`, but also resolves the path with `Dir.path.resolve`. This
 /// means the path has no repeated separators, no "." or ".." components, and no trailing separator.
 /// On WASI, "" is returned instead of ".".
-pub fn getResolvedCwd(io: Io, gpa: Allocator) error{
-    OutOfMemory,
-    CurrentDirUnlinked,
-    Unexpected,
-}![]u8 {
+pub fn getResolvedCwd(io: Io, gpa: Allocator) std.process.CurrentPathAllocError![]u8 {
     if (builtin.target.os.tag == .wasi) {
         if (std.debug.runtime_safety) {
             const cwd = try std.process.currentPathAlloc(io, gpa);
diff --git a/src/link.zig b/src/link.zig
index c8e46540bac608301ee75b5c315b5c9b2ac05b72..72c5d27105bc9e40864b6c5b7ed7feb0917205f2 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -1500,12 +1500,12 @@ pub fn doPrelinkTask(comp: *Compilation, task: PrelinkTask) void {
         },
     }
 }
-pub fn doZcuTask(comp: *Compilation, tid: usize, task: ZcuTask) void {
+pub fn doZcuTask(comp: *Compilation, tid: Zcu.PerThread.Id, task: ZcuTask) void {
     const io = comp.io;
     const diags = &comp.link_diags;
     const zcu = comp.zcu.?;
     const ip = &zcu.intern_pool;
-    const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
+    const pt: Zcu.PerThread = .activate(zcu, tid);
     defer pt.deactivate();
 
     var timer = comp.startTimer();
@@ -1610,8 +1610,8 @@ pub fn doZcuTask(comp: *Compilation, tid: usize, task: ZcuTask) void {
         }
     }
 }
-pub fn doIdleTask(comp: *Compilation, tid: usize) error{ OutOfMemory, LinkFailure }!bool {
-    return if (comp.bin_file) |lf| lf.idle(@enumFromInt(tid)) else false;
+pub fn doIdleTask(comp: *Compilation, tid: Zcu.PerThread.Id) error{ OutOfMemory, LinkFailure }!bool {
+    return if (comp.bin_file) |lf| lf.idle(tid) else false;
 }
 /// After the main pipeline is done, but before flush, the compilation may need to link one final
 /// `Nav` into the binary: the `builtin.test_functions` value. Since the link thread isn't running
diff --git a/src/link/Queue.zig b/src/link/Queue.zig
index b716800baebe7eaccf8e3eba0b8779dbb744faad..a49c1915672019d347037fe5e4ff1ba346e38cb5 100644
--- a/src/link/Queue.zig
+++ b/src/link/Queue.zig
@@ -96,12 +96,12 @@ pub fn enqueuePrelink(q: *Queue, comp: *Compilation, tasks: []const PrelinkTask)
 pub fn enqueueZcu(
     q: *Queue,
     comp: *Compilation,
-    tid: usize,
+    tid: Zcu.PerThread.Id,
     task: ZcuTask,
 ) Io.Cancelable!void {
     const io = comp.io;
 
-    assert(tid == 0);
+    assert(tid == .main);
 
     if (q.future != null) {
         if (q.zcu_queue.putOne(io, task)) |_| {
@@ -148,8 +148,9 @@ pub fn finishZcuQueue(q: *Queue, comp: *Compilation) void {
 }
 
 fn runLinkTasks(q: *Queue, comp: *Compilation) void {
-    const tid = Compilation.getTid();
     const io = comp.io;
+    const tid: Zcu.PerThread.Id = .acquire(io);
+    defer tid.release(io);
 
     var have_idle_tasks = true;
 
@@ -198,7 +199,7 @@ fn runLinkTasks(q: *Queue, comp: *Compilation) void {
         }
     }
 }
-fn runIdleTask(comp: *Compilation, tid: usize) bool {
+fn runIdleTask(comp: *Compilation, tid: Zcu.PerThread.Id) bool {
     return link.doIdleTask(comp, tid) catch |err| switch (err) {
         error.OutOfMemory => have_more: {
             comp.link_diags.setAllocFailure();
@@ -217,5 +218,6 @@ const Compilation = @import("../Compilation.zig");
 const InternPool = @import("../InternPool.zig");
 const link = @import("../link.zig");
 const PrelinkTask = link.PrelinkTask;
-const ZcuTask = link.ZcuTask;
 const Queue = @This();
+const Zcu = @import("../Zcu.zig");
+const ZcuTask = link.ZcuTask;
diff --git a/src/main.zig b/src/main.zig
index ed194b476776ffd6f597227dac5498b71eff967e..caa076f41706cd2b268085635eaf7bb8619f287d 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -52,8 +52,11 @@ pub const std_options: std.Options = .{
 };
 pub const std_options_cwd = if (native_os == .wasi) wasi_cwd else null;
 
-pub const panic = crash_report.panic;
-pub const debug = crash_report.debug;
+pub const debug = struct {
+    pub fn printCrashContext(terminal: Io.Terminal) void {
+        crash_report.dumpCrashContext(terminal) catch {};
+    }
+};
 
 var preopens: std.process.Preopens = .empty;
 pub fn wasi_cwd() Io.Dir {
@@ -158,25 +161,55 @@ pub fn log(
     std.log.defaultLog(level, scope, format, args);
 }
 
-var debug_allocator: std.heap.DebugAllocator(.{
-    .stack_trace_frames = build_options.mem_leak_frames,
-}) = .init;
-
 const use_debug_allocator = build_options.debug_gpa or
     (native_os != .wasi and !builtin.link_libc and switch (builtin.mode) {
         .Debug, .ReleaseSafe => true,
         .ReleaseFast, .ReleaseSmall => false,
     });
 
+const RootAllocator = if (use_debug_allocator) std.heap.DebugAllocator(.{
+    .stack_trace_frames = build_options.mem_leak_frames,
+    .thread_safe = switch (build_options.io_mode) {
+        .threaded => true,
+        .evented => false,
+    },
+}) else struct {
+    pub const init: RootAllocator = .{};
+    pub fn allocator(_: RootAllocator) Allocator {
+        if (native_os == .wasi) return std.heap.wasm_allocator;
+        if (builtin.link_libc) return std.heap.c_allocator;
+        return std.heap.smp_allocator;
+    }
+    pub fn deinit(_: RootAllocator) std.heap.Check {
+        return .ok;
+    }
+};
+
 pub fn main(init: std.process.Init.Minimal) anyerror!void {
-    const gpa = gpa: {
-        if (use_debug_allocator) break :gpa debug_allocator.allocator();
-        if (native_os == .wasi) break :gpa std.heap.wasm_allocator;
-        if (builtin.link_libc) break :gpa std.heap.c_allocator;
-        break :gpa std.heap.smp_allocator;
-    };
-    defer if (use_debug_allocator) {
-        _ = debug_allocator.deinit();
+    var root_allocator: RootAllocator = .init;
+    defer _ = root_allocator.deinit();
+    const root_gpa = root_allocator.allocator();
+    var io_impl: IoImpl = undefined;
+    switch (build_options.io_mode) {
+        .threaded => io_impl = .init(root_gpa, .{
+            .stack_size = thread_stack_size,
+
+            .argv0 = .init(init.args),
+            .environ = init.environ,
+        }),
+        .evented => try io_impl.init(root_gpa, .{
+            .argv0 = .init(init.args),
+            .environ = init.environ,
+
+            .backing_allocator_needs_mutex = use_debug_allocator,
+        }),
+    }
+    defer io_impl.deinit();
+    io_impl_ptr = &io_impl;
+    const io = io_impl.io();
+    const gpa = switch (build_options.io_mode) {
+        .threaded => root_gpa,
+        .evented => io_impl.allocator(),
     };
     var arena_instance = std.heap.ArenaAllocator.init(gpa);
     defer arena_instance.deinit();
@@ -193,17 +226,6 @@ pub fn main(init: std.process.Init.Minimal) anyerror!void {
 
     var environ_map = init.environ.createMap(arena) catch |err| fatal("failed to parse environment: {t}", .{err});
 
-    Compilation.setMainThread();
-
-    var threaded: Io.Threaded = .init(gpa, .{
-        .argv0 = .init(init.args),
-        .environ = init.environ,
-    });
-    defer threaded.deinit();
-    threaded_impl_ptr = &threaded;
-    threaded.stack_size = thread_stack_size;
-    const io = threaded.io();
-
     if (tracy.enable_allocation) {
         var gpa_tracy = tracy.tracyAllocator(gpa);
         return mainArgs(gpa_tracy.allocator(), arena, io, args, &environ_map);
@@ -3400,7 +3422,7 @@ fn buildOutputType(
         @max(n_jobs orelse std.Thread.getCpuCount() catch 1, 1),
         std.math.maxInt(Zcu.PerThread.IdBacking),
     );
-    setThreadLimit(thread_limit);
+    try setThreadLimit(arena, thread_limit);
 
     for (create_module.c_source_files.items) |*src| {
         dev.check(.c_compiler);
@@ -4731,13 +4753,13 @@ pub fn translateC(
     argv: []const []const u8,
     environ_map: *const process.Environ.Map,
     prog_node: std.Progress.Node,
+    thread_limit: usize,
     capture: ?*[]u8,
 ) !void {
-    try jitCmd(gpa, arena, io, argv, environ_map, .{
+    try jitCmdInner(gpa, arena, io, argv, environ_map, prog_node, thread_limit, .{
         .cmd_name = "translate-c",
         .root_src_path = "translate-c/main.zig",
         .depend_on_aro = true,
-        .progress_node = prog_node,
         .capture = capture,
     });
 }
@@ -5187,7 +5209,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
         @max(n_jobs orelse std.Thread.getCpuCount() catch 1, 1),
         std.math.maxInt(Zcu.PerThread.IdBacking),
     );
-    setThreadLimit(thread_limit);
+    try setThreadLimit(arena, thread_limit);
 
     // Dummy http client that is not actually used when fetch_command is unsupported.
     // Prevents bootstrap from depending on a bunch of unnecessary stuff.
@@ -5651,7 +5673,7 @@ const JitCmdOptions = struct {
     capture: ?*[]u8 = null,
     /// Send error bundles via std.zig.Server over stdout
     server: bool = false,
-    progress_node: ?std.Progress.Node = null,
+    color: Color = .auto,
 };
 
 fn jitCmd(
@@ -5664,12 +5686,30 @@ fn jitCmd(
 ) !void {
     dev.check(.jit_command);
 
-    const color: Color = .auto;
-    const root_prog_node = if (options.progress_node) |node| node else std.Progress.start(io, .{
-        .disable_printing = (color == .off),
+    const root_prog_node = std.Progress.start(io, .{
+        .disable_printing = (options.color == .off),
     });
     defer root_prog_node.end();
 
+    const thread_limit = @min(
+        @max(std.Thread.getCpuCount() catch 1, 1),
+        std.math.maxInt(Zcu.PerThread.IdBacking),
+    );
+    try setThreadLimit(arena, thread_limit);
+
+    return jitCmdInner(gpa, arena, io, args, environ_map, root_prog_node, thread_limit, options);
+}
+
+fn jitCmdInner(
+    gpa: Allocator,
+    arena: Allocator,
+    io: Io,
+    args: []const []const u8,
+    environ_map: *const process.Environ.Map,
+    root_prog_node: std.Progress.Node,
+    thread_limit: usize,
+    options: JitCmdOptions,
+) !void {
     const target_query: std.Target.Query = .{};
     const resolved_target: Package.Module.ResolvedTarget = .{
         .result = std.zig.resolveTargetQueryOrFatal(io, target_query),
@@ -5702,12 +5742,6 @@ fn jitCmd(
     );
     defer dirs.deinit(io);
 
-    const thread_limit = @min(
-        @max(std.Thread.getCpuCount() catch 1, 1),
-        std.math.maxInt(Zcu.PerThread.IdBacking),
-    );
-    setThreadLimit(thread_limit);
-
     var child_argv: std.ArrayList([]const u8) = .empty;
     try child_argv.ensureUnusedCapacity(arena, args.len + 4);
 
@@ -5795,7 +5829,7 @@ fn jitCmd(
                 process.exit(2);
             }
         } else {
-            updateModule(comp, color, root_prog_node) catch |err| switch (err) {
+            updateModule(comp, options.color, root_prog_node) catch |err| switch (err) {
                 error.CompileErrorsReported => process.exit(2),
                 else => |e| return e,
             };
@@ -7777,15 +7811,25 @@ fn addLibDirectoryWarn2(
     });
 }
 
-var threaded_impl_ptr: *Io.Threaded = undefined;
-fn setThreadLimit(n: usize) void {
-    // We want a maximum of n total threads to keep the InternPool happy, but
-    // the main thread doesn't count towards the limits, so use n-1. Also, the
-    // linker can run concurrently, so we need to set both the async *and* the
-    // concurrency limit.
-    const limit: Io.Limit = .limited(n - 1);
-    threaded_impl_ptr.setAsyncLimit(limit);
-    threaded_impl_ptr.concurrent_limit = limit;
+const IoImpl = switch (build_options.io_mode) {
+    .threaded => Io.Threaded,
+    .evented => Io.Evented,
+};
+var io_impl_ptr: *IoImpl = undefined;
+fn setThreadLimit(arena: std.mem.Allocator, n: usize) Allocator.Error!void {
+    switch (build_options.io_mode) {
+        .threaded => {
+            // We want a maximum of n total threads to keep the InternPool happy, but
+            // the main thread doesn't count towards the limits, so use n-1. Also, the
+            // linker can run concurrently, so we need to set both the async *and* the
+            // concurrency limit.
+            const limit: Io.Limit = .limited(n - 1);
+            io_impl_ptr.setAsyncLimit(limit);
+            io_impl_ptr.concurrent_limit = limit;
+        },
+        .evented => {},
+    }
+    try Zcu.PerThread.Id.allocate(arena, @max(n, 2));
 }
 
 fn randInt(io: Io, comptime T: type) T {
diff --git a/stage1/config.zig.in b/stage1/config.zig.in
index d5c9a7ebbfbd3ff70427e29fb73ab67f0ab75523..087585cd7eee9b1ea4bec29e8af50eb29fa64084 100644
--- a/stage1/config.zig.in
+++ b/stage1/config.zig.in
@@ -13,4 +13,5 @@ pub const value_tracing = false;
 pub const skip_non_native = false;
 pub const debug_gpa = false;
 pub const dev = .core;
+pub const io_mode: enum { threaded, evented } = .threaded;
 pub const value_interpret_mode = .direct;
-- 
2.54.0


From f2cbc1912b9c58c2a20b9f32fb60b7793f5e4820 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Thu, 15 Jan 2026 21:54:07 -0500
Subject: [PATCH 241/499] tracy: replace `namedFrame` with `traceNamed`

It is not valid to use frames here because multiple compilations may run
concurrently, and a frame with a given name must stop before starting
again.
---
 src/Compilation.zig | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 608bbe4a94f7fa4ffcf752175043e80b238a0d14..8e9c9b948cfabc4f5bad7406f1a9144a9f85d0da 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -21,6 +21,7 @@ const introspect = @import("introspect.zig");
 const link = @import("link.zig");
 const tracy = @import("tracy.zig");
 const trace = tracy.trace;
+const traceNamed = tracy.traceNamed;
 const build_options = @import("build_options");
 const LibCInstallation = std.zig.LibCInstallation;
 const glibc = @import("libs/glibc.zig");
@@ -4707,8 +4708,8 @@ fn performAllTheWork(
     }
 
     if (comp.zcu) |zcu| {
-        const astgen_frame = tracy.namedFrame("astgen");
-        defer astgen_frame.end();
+        const tracy_trace = traceNamed(@src(), "astgen");
+        defer tracy_trace.end();
 
         const zir_prog_node = main_progress_node.start("AST Lowering", 0);
         defer zir_prog_node.end();
@@ -5221,8 +5222,8 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             try comp.link_queue.enqueueZcu(comp, tid, .{ .update_line_number = tracked_inst });
         },
         .analyze_func => |func| {
-            const named_frame = tracy.namedFrame("analyze_func");
-            defer named_frame.end();
+            const tracy_trace = traceNamed(@src(), "analyze_func");
+            defer tracy_trace.end();
 
             const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
@@ -5234,8 +5235,8 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             };
         },
         .analyze_comptime_unit => |unit| {
-            const named_frame = tracy.namedFrame("analyze_comptime_unit");
-            defer named_frame.end();
+            const tracy_trace = traceNamed(@src(), "analyze_comptime_unit");
+            defer tracy_trace.end();
 
             const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
@@ -5274,8 +5275,8 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             }
         },
         .resolve_type_fully => |ty| {
-            const named_frame = tracy.namedFrame("resolve_type_fully");
-            defer named_frame.end();
+            const tracy_trace = traceNamed(@src(), "resolve_type_fully");
+            defer tracy_trace.end();
 
             const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
@@ -5285,8 +5286,8 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             };
         },
         .analyze_mod => |mod| {
-            const named_frame = tracy.namedFrame("analyze_mod");
-            defer named_frame.end();
+            const tracy_trace = traceNamed(@src(), "analyze_mod");
+            defer tracy_trace.end();
 
             const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
@@ -5296,8 +5297,8 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             };
         },
         .windows_import_lib => |index| {
-            const named_frame = tracy.namedFrame("windows_import_lib");
-            defer named_frame.end();
+            const tracy_trace = traceNamed(@src(), "windows_import_lib");
+            defer tracy_trace.end();
 
             const link_lib = comp.windows_libs.keys()[index];
             mingw.buildImportLib(comp, link_lib) catch |err| {
-- 
2.54.0


From 7e8ee985e20f34ba6afb815a7cded443aca297d3 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Tue, 13 Jan 2026 19:10:45 -0500
Subject: [PATCH 242/499] tracy: add fiber integration

---
 build.zig              | 14 ++++++++++++--
 lib/std/Io/IoUring.zig | 44 ++++++++++++++++++++++++++++++++++++++++++
 src/main.zig           |  2 +-
 src/tracy.zig          | 12 ++++++++++++
 4 files changed, 69 insertions(+), 3 deletions(-)

diff --git a/build.zig b/build.zig
index 1ec1fa9caf7f8fc2af988ccc0ea733d388f3c0cc..07cef8274c070707ae931deb68abfb5e7ed5a870 100644
--- a/build.zig
+++ b/build.zig
@@ -370,10 +370,20 @@ pub fn build(b: *std.Build) !void {
             &[_][]const u8{ tracy_path, "public", "TracyClient.cpp" },
         );
 
-        const tracy_c_flags: []const []const u8 = &.{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined" };
+        const tracy_c_flags: []const []const u8 = &.{
+            "-DTRACY_ENABLE=1",
+            "-fno-sanitize=undefined",
+            "-DTRACY_FIBERS",
+        };
 
         exe.root_module.addIncludePath(.{ .cwd_relative = tracy_path });
-        exe.root_module.addCSourceFile(.{ .file = .{ .cwd_relative = client_cpp }, .flags = tracy_c_flags });
+        exe.root_module.addCSourceFile(.{
+            .file = .{ .cwd_relative = client_cpp },
+            .flags = tracy_c_flags[0..switch (io_mode) {
+                .threaded => 2,
+                .evented => 3,
+            }],
+        });
         exe.root_module.link_libc = true;
         exe.root_module.link_libcpp = true;
 
diff --git a/lib/std/Io/IoUring.zig b/lib/std/Io/IoUring.zig
index f853aaa08f20a2df3fb8f1b623f68d92300a062d..ccf8408840d2f09e21dbdf585713eeed2c5e34fa 100644
--- a/lib/std/Io/IoUring.zig
+++ b/lib/std/Io/IoUring.zig
@@ -44,6 +44,14 @@ const timestampFromPosix = Io.Threaded.timestampFromPosix;
 const unexpectedErrno = std.posix.unexpectedErrno;
 const winsize = std.posix.winsize;
 
+const tracy = if (@hasDecl(@import("root"), "tracy")) @import("root").tracy else struct {
+    const enable = false;
+    inline fn fiberEnter(fiber: [*:0]const u8) void {
+        _ = fiber;
+    }
+    inline fn fiberLeave() void {}
+};
+
 backing_allocator_needs_mutex: bool,
 backing_allocator_mutex: Io.Mutex,
 /// Does not need to be thread-safe if not used elsewhere.
@@ -90,6 +98,7 @@ const Thread = struct {
     io_uring: IoUring,
     idle_search_index: u32,
     steal_ready_search_index: u32,
+    name_arena: if (tracy.enable) std.heap.ArenaAllocator.State else struct {},
     csprng: Csprng,
 
     threadlocal var self: ?*Thread = null;
@@ -138,6 +147,9 @@ const Fiber = struct {
     },
     cancel_status: CancelStatus,
     cancel_protection: CancelProtection,
+    name: if (tracy.enable) [*:0]const u8 else void,
+
+    var next_name: u64 = 0;
 
     const CancelStatus = packed struct(u32) {
         requested: bool,
@@ -772,6 +784,7 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
         .status = .{ .queue_next = null },
         .cancel_status = .unrequested,
         .cancel_protection = .unblocked,
+        .name = if (tracy.enable) "main task",
     };
     const main_thread = &ev.threads.allocated[0];
     Thread.self = main_thread;
@@ -802,11 +815,13 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
         ),
         .idle_search_index = 1,
         .steal_ready_search_index = 1,
+        .name_arena = .{},
         .csprng = .uninitialized,
     };
     errdefer main_thread.io_uring.deinit();
     log.debug("created main idle {*}", .{&main_thread.idle_context});
     log.debug("created main {*}", .{main_fiber});
+    if (tracy.enable) tracy.fiberEnter(main_fiber.name);
 }
 
 pub fn deinit(ev: *Evented) void {
@@ -958,6 +973,7 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
             },
             .idle_search_index = 0,
             .steal_ready_search_index = 0,
+            .name_arena = .{},
             .csprng = .uninitialized,
         };
         new_thread.thread = std.Thread.spawn(.{
@@ -1160,6 +1176,12 @@ const SwitchMessage = struct {
     fn handle(message: *const SwitchMessage, ev: *Evented) void {
         const thread: *Thread = .current();
         thread.current_context = message.contexts.ready;
+        if (tracy.enable) {
+            if (message.contexts.ready != &thread.idle_context) {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.ready));
+                tracy.fiberEnter(fiber.name);
+            } else tracy.fiberLeave();
+        }
         switch (message.pending_task) {
             .nothing => {},
             .reschedule => if (message.contexts.prev != &thread.idle_context) {
@@ -1543,6 +1565,17 @@ fn concurrent(
         .status = .{ .queue_next = null },
         .cancel_status = .unrequested,
         .cancel_protection = .unblocked,
+        .name = if (tracy.enable) name: {
+            const thread: *Thread = .current();
+            var name_arena = thread.name_arena.promote(std.heap.page_allocator);
+            defer thread.name_arena = name_arena.state;
+            break :name std.fmt.allocPrintSentinel(
+                name_arena.allocator(),
+                "task {d}",
+                .{@atomicRmw(u64, &Fiber.next_name, .Add, 1, .monotonic)},
+                0,
+            ) catch return error.ConcurrencyUnavailable;
+        },
     };
     closure.* = .{
         .ev = ev,
@@ -1920,6 +1953,17 @@ fn groupConcurrent(
         .status = .{ .queue_next = null },
         .cancel_status = .unrequested,
         .cancel_protection = .unblocked,
+        .name = if (tracy.enable) name: {
+            const thread: *Thread = .current();
+            var name_arena = thread.name_arena.promote(std.heap.page_allocator);
+            defer thread.name_arena = name_arena.state;
+            break :name std.fmt.allocPrintSentinel(
+                name_arena.allocator(),
+                "group task {d}",
+                .{@atomicRmw(u64, &Fiber.next_name, .Add, 1, .monotonic)},
+                0,
+            ) catch return error.ConcurrencyUnavailable;
+        },
     };
     closure.* = .{
         .ev = ev,
diff --git a/src/main.zig b/src/main.zig
index caa076f41706cd2b268085635eaf7bb8619f287d..82a1fcf0503c1c88eb074d4334d85ebd00cfa30a 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -21,7 +21,7 @@ const AstGen = std.zig.AstGen;
 const ZonGen = std.zig.ZonGen;
 const Server = std.zig.Server;
 
-const tracy = @import("tracy.zig");
+pub const tracy = @import("tracy.zig");
 const Compilation = @import("Compilation.zig");
 const link = @import("link.zig");
 const Package = @import("Package.zig");
diff --git a/src/tracy.zig b/src/tracy.zig
index 1a106d22d6dc9a9210603ce01401a848e1246f72..4fc2b009344aaa96f4a013a40b8dc9d99ffe10fb 100644
--- a/src/tracy.zig
+++ b/src/tracy.zig
@@ -98,6 +98,16 @@ pub inline fn traceNamed(comptime src: std.builtin.SourceLocation, comptime name
     }
 }
 
+pub inline fn fiberEnter(fiber: [*:0]const u8) void {
+    if (!enable) return;
+    ___tracy_fiber_enter(fiber);
+}
+
+pub inline fn fiberLeave() void {
+    if (!enable) return;
+    ___tracy_fiber_leave();
+}
+
 pub fn tracyAllocator(allocator: std.mem.Allocator) TracyAllocator(null) {
     return TracyAllocator(null).init(allocator);
 }
@@ -318,6 +328,8 @@ extern fn ___tracy_emit_memory_free_callstack_named(ptr: *const anyopaque, depth
 extern fn ___tracy_emit_logString(severity: MessageSeverity, color: i32, callstack_depth: i32, size: usize, txt: [*]const u8) void;
 extern fn ___tracy_emit_logStringL(severity: MessageSeverity, color: i32, callstack_depth: i32, txt: [*:0]const u8) void;
 extern fn ___tracy_emit_frame_mark(name: ?[*:0]const u8) void;
+extern fn ___tracy_fiber_enter(fiber: [*:0]const u8) void;
+extern fn ___tracy_fiber_leave() void;
 
 const ___tracy_source_location_data = extern struct {
     name: ?[*:0]const u8,
-- 
2.54.0


From 6473dc22fc1659df218ade897647c0658e0ebec9 Mon Sep 17 00:00:00 2001
From: Nils Koch <mail@nilskch.dev>
Date: Wed, 17 Dec 2025 17:54:31 +0100
Subject: [PATCH 243/499] std.ArrayList: Fix compile error when `@sizeOf(T) ==
 0`

---
 lib/std/array_list.zig | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index d84bafca0eee96747445ec7a99424cd5c84de20b..f15388d7b5df62c3112b4ab0902ee587425c0442 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -1362,11 +1362,11 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
             return self.getLast();
         }
 
-        const init_capacity: comptime_int = @max(1, std.atomic.cache_line / @sizeOf(T));
-
         /// Called when memory growth is necessary. Returns a capacity larger than
         /// minimum that grows super-linearly.
         pub fn growCapacity(minimum: usize) usize {
+            if (@sizeOf(T) == 0) return math.maxInt(usize);
+            const init_capacity: comptime_int = @max(1, std.atomic.cache_line / @sizeOf(T));
             return minimum +| (minimum / 2 + init_capacity);
         }
     };
@@ -1751,6 +1751,14 @@ test "insert" {
         try testing.expect(list.items[2] == 2);
         try testing.expect(list.items[3] == 3);
     }
+    {
+        var list: ArrayList(struct {}) = .empty;
+        defer list.deinit(a);
+
+        try list.insert(a, 0, .{});
+        try list.append(a, .{});
+        try testing.expect(list.items.len == 2);
+    }
 }
 
 test "insertSlice" {
-- 
2.54.0


From 04c180c8e57fecdf3478de966f32b8a1f65ad202 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 8 Feb 2026 23:55:26 -0800
Subject: [PATCH 244/499] compiler_rt: partial cleanup

introduce `symbol` helper function and partially migrate to using it
---
 lib/compiler_rt.zig             |  69 ++++++++++++++--
 lib/compiler_rt/absvdi2.zig     |   4 +-
 lib/compiler_rt/absvti2.zig     |   4 +-
 lib/compiler_rt/adddf3.zig      |   5 +-
 lib/compiler_rt/addsf3.zig      |   5 +-
 lib/compiler_rt/addvdi3.zig     |   4 +-
 lib/compiler_rt/atomics.zig     | 139 ++++++++++++++++----------------
 lib/compiler_rt/aulldiv.zig     |  10 +--
 lib/compiler_rt/cmpdf2.zig      |  17 ++--
 lib/compiler_rt/cmptf2.zig      |  33 ++++----
 lib/compiler_rt/common.zig      |  26 ++----
 lib/compiler_rt/cos.zig         |  17 ++--
 lib/compiler_rt/count0bits.zig  |  22 ++---
 lib/compiler_rt/divdc3.zig      |   4 +-
 lib/compiler_rt/divdf3.zig      |   7 +-
 lib/compiler_rt/divhf3.zig      |   4 +-
 lib/compiler_rt/divmodei4.zig   |  12 +--
 lib/compiler_rt/divsc3.zig      |   4 +-
 lib/compiler_rt/divsf3.zig      |   7 +-
 lib/compiler_rt/divtc3.zig      |   5 +-
 lib/compiler_rt/divxc3.zig      |   4 +-
 lib/compiler_rt/exp.zig         |  19 +++--
 lib/compiler_rt/extenddftf2.zig |   7 +-
 lib/compiler_rt/extendhfdf2.zig |   3 +-
 lib/compiler_rt/extendhfsf2.zig |   7 +-
 lib/compiler_rt/extendsfxf2.zig |   4 +-
 lib/compiler_rt/extendxftf2.zig |   5 +-
 lib/compiler_rt/fixdfsi.zig     |   5 +-
 lib/compiler_rt/fixdfti.zig     |   6 +-
 lib/compiler_rt/fixsfdi.zig     |   7 +-
 lib/compiler_rt/fixtfdi.zig     |   7 +-
 lib/compiler_rt/fixtfsi.zig     |   7 +-
 lib/compiler_rt/fixtfti.zig     |   8 +-
 lib/compiler_rt/fixunsdfei.zig  |   8 +-
 lib/compiler_rt/fixunsdfti.zig  |   6 +-
 lib/compiler_rt/fixunshfdi.zig  |   4 +-
 lib/compiler_rt/fixunshfei.zig  |   8 +-
 lib/compiler_rt/fixunshfti.zig  |   6 +-
 lib/compiler_rt/fixunssfei.zig  |   8 +-
 lib/compiler_rt/fixunssfti.zig  |   5 +-
 lib/compiler_rt/fixunstfei.zig  |   8 +-
 lib/compiler_rt/fixunsxfdi.zig  |   4 +-
 lib/compiler_rt/fixunsxfei.zig  |   4 +-
 lib/compiler_rt/fixxfdi.zig     |   4 +-
 lib/compiler_rt/fixxfti.zig     |   6 +-
 lib/compiler_rt/floatdihf.zig   |   4 +-
 lib/compiler_rt/floatdisf.zig   |   8 +-
 lib/compiler_rt/floatditf.zig   |   7 +-
 lib/compiler_rt/floatdixf.zig   |   4 +-
 lib/compiler_rt/floateidf.zig   |   8 +-
 lib/compiler_rt/floateixf.zig   |   8 +-
 lib/compiler_rt/floatsixf.zig   |   3 +-
 lib/compiler_rt/floattidf.zig   |   6 +-
 lib/compiler_rt/floattisf.zig   |   6 +-
 lib/compiler_rt/floattitf.zig   |   8 +-
 lib/compiler_rt/floatundidf.zig |   8 +-
 lib/compiler_rt/floatuneitf.zig |   8 +-
 lib/compiler_rt/floatunsihf.zig |   4 +-
 lib/compiler_rt/floatunsisf.zig |   5 +-
 lib/compiler_rt/floatunsitf.zig |   7 +-
 lib/compiler_rt/floatuntidf.zig |   6 +-
 lib/compiler_rt/floatuntihf.zig |   6 +-
 lib/compiler_rt/floatuntitf.zig |   8 +-
 lib/compiler_rt/floor_ceil.zig  |  29 +++----
 lib/compiler_rt/gedf2.zig       |   9 ++-
 lib/compiler_rt/gehf2.zig       |   6 +-
 lib/compiler_rt/gexf2.zig       |   6 +-
 lib/compiler_rt/int.zig         |  35 ++++----
 lib/compiler_rt/log.zig         |  18 ++---
 lib/compiler_rt/log10.zig       |  18 ++---
 lib/compiler_rt/memcmp.zig      |  30 -------
 lib/compiler_rt/muldc3.zig      |   4 +-
 lib/compiler_rt/muldf3.zig      |   5 +-
 lib/compiler_rt/mulsc3.zig      |   4 +-
 lib/compiler_rt/multc3.zig      |   5 +-
 lib/compiler_rt/mulvsi3.zig     |   7 +-
 lib/compiler_rt/negtf2.zig      |   5 +-
 lib/compiler_rt/parity.zig      |  13 ++-
 lib/compiler_rt/popcount.zig    |  10 +--
 lib/compiler_rt/powiXf2.zig     |  15 ++--
 lib/compiler_rt/sin.zig         |  19 +++--
 lib/compiler_rt/strlen.zig      |  10 ---
 lib/compiler_rt/subdf3.zig      |   5 +-
 lib/compiler_rt/subvdi3.zig     |   4 +-
 lib/compiler_rt/subxf3.zig      |   4 +-
 lib/compiler_rt/tan.zig         |  15 ++--
 lib/compiler_rt/trunc.zig       |  19 +++--
 lib/compiler_rt/truncdfhf2.zig  |   5 +-
 lib/compiler_rt/trunctfhf2.zig  |   3 +-
 lib/compiler_rt/trunctfsf2.zig  |   7 +-
 lib/compiler_rt/truncxfdf2.zig  |   4 +-
 lib/compiler_rt/truncxfhf2.zig  |   3 +-
 lib/compiler_rt/truncxfsf2.zig  |   4 +-
 lib/compiler_rt/udivmodei4.zig  |  14 ++--
 lib/compiler_rt/unorddf2.zig    |   5 +-
 95 files changed, 532 insertions(+), 480 deletions(-)
 delete mode 100644 lib/compiler_rt/memcmp.zig
 delete mode 100644 lib/compiler_rt/strlen.zig

diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig
index 87ff89c2d937b395eb562b7c82bbe7afb0916917..343363188f9f5023b54a54f145412212c799a840 100644
--- a/lib/compiler_rt.zig
+++ b/lib/compiler_rt.zig
@@ -1,10 +1,11 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("compiler_rt/common.zig");
+const ofmt_c = builtin.object_format == .c;
+
+const std = @import("std");
 
 /// Avoid dragging in the runtime safety mechanisms into this .o file, unless
 /// we're trying to test compiler-rt.
-pub const panic = if (common.test_safety)
+pub const panic = if (test_safety)
     std.debug.FullPanic(std.debug.defaultPanic)
 else
     std.debug.no_panic;
@@ -19,6 +20,33 @@ pub const std_options_debug_io: std.Io = if (builtin.is_test)
 else
     unreachable;
 
+pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void {
+    @export(func, .{ .name = name, .linkage = linkage, .visibility = visibility });
+}
+
+/// For now, we prefer weak linkage because some of the routines we implement here may also be
+/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
+/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
+pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
+    .internal
+else if (ofmt_c)
+    .strong
+else
+    .weak;
+
+/// Determines the symbol's visibility to other objects.
+/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
+/// export it to the host runtime.
+pub const visibility: std.builtin.SymbolVisibility = if (linkage == .internal or builtin.link_mode == .dynamic)
+    .default
+else
+    .hidden;
+
+pub const test_safety = switch (builtin.zig_backend) {
+    .stage2_aarch64 => false,
+    else => builtin.is_test,
+};
+
 comptime {
     // Integer routines
     _ = @import("compiler_rt/count0bits.zig");
@@ -276,17 +304,44 @@ comptime {
         _ = @import("compiler_rt/memcpy.zig");
         _ = @import("compiler_rt/memset.zig");
         _ = @import("compiler_rt/memmove.zig");
-        _ = @import("compiler_rt/memcmp.zig");
+        symbol(&memcmp, "memcmp");
         _ = @import("compiler_rt/bcmp.zig");
         _ = @import("compiler_rt/ssp.zig");
-
-        _ = @import("compiler_rt/strlen.zig");
+        symbol(&strlen, "strlen");
     }
 
     // Temporarily used for uefi until https://github.com/ziglang/zig/issues/21630 is addressed.
     if (!builtin.link_libc and (builtin.os.tag == .windows or builtin.os.tag == .uefi) and (builtin.abi == .none or builtin.abi == .msvc)) {
-        @export(&_fltused, .{ .name = "_fltused", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_fltused, "_fltused");
     }
 }
 
 var _fltused: c_int = 1;
+
+fn strlen(s: [*:0]const c_char) callconv(.c) usize {
+    return std.mem.len(s);
+}
+
+fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.c) c_int {
+    var i: usize = 0;
+    while (i < n) : (i += 1) {
+        const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
+        if (compared != 0) return compared;
+    }
+    return 0;
+}
+
+test "memcmp" {
+    const arr0 = &[_]u8{ 1, 1, 1 };
+    const arr1 = &[_]u8{ 1, 1, 1 };
+    const arr2 = &[_]u8{ 1, 0, 1 };
+    const arr3 = &[_]u8{ 1, 2, 1 };
+    const arr4 = &[_]u8{ 1, 0xff, 1 };
+
+    try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
+    try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
+    try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
+
+    try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
+    try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
+}
diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig
index add32608e8a389c6a62139410f356b0c24072981..408d70ad167d29c7895e6145e7635da95ec62a82 100644
--- a/lib/compiler_rt/absvdi2.zig
+++ b/lib/compiler_rt/absvdi2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const absv = @import("./absv.zig").absv;
 
 comptime {
-    @export(&__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__absvdi2, "__absvdi2");
 }
 
 pub fn __absvdi2(a: i64) callconv(.c) i64 {
diff --git a/lib/compiler_rt/absvti2.zig b/lib/compiler_rt/absvti2.zig
index 1b2ddaaefac6ad7fa139a331fe569bcf11f27cc9..ab367d2b78ae2f0a813d011ec74dc532d103303f 100644
--- a/lib/compiler_rt/absvti2.zig
+++ b/lib/compiler_rt/absvti2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const absv = @import("./absv.zig").absv;
 
 comptime {
-    @export(&__absvti2, .{ .name = "__absvti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__absvti2, "__absvti2");
 }
 
 pub fn __absvti2(a: i128) callconv(.c) i128 {
diff --git a/lib/compiler_rt/adddf3.zig b/lib/compiler_rt/adddf3.zig
index 98fba79bbd5116617489d61e32c0d02122f1a579..7a49b0d782b7b50b022fee510f8cc885c567acd5 100644
--- a/lib/compiler_rt/adddf3.zig
+++ b/lib/compiler_rt/adddf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const addf3 = @import("./addf3.zig").addf3;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dadd, "__aeabi_dadd");
     } else {
-        @export(&__adddf3, .{ .name = "__adddf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__adddf3, "__adddf3");
     }
 }
 
diff --git a/lib/compiler_rt/addsf3.zig b/lib/compiler_rt/addsf3.zig
index ef1627ae7ae05d9a83716fa53178b9d50971e040..fb65bec624939a224e5938aabcdc77d821f43e3f 100644
--- a/lib/compiler_rt/addsf3.zig
+++ b/lib/compiler_rt/addsf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const addf3 = @import("./addf3.zig").addf3;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_fadd, "__aeabi_fadd");
     } else {
-        @export(&__addsf3, .{ .name = "__addsf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__addsf3, "__addsf3");
     }
 }
 
diff --git a/lib/compiler_rt/addvdi3.zig b/lib/compiler_rt/addvdi3.zig
index e7346b717ff87faada5d780b02d0b42e1e30d7b6..a5cde2494acba14282409395aa47ce9660faa0ff 100644
--- a/lib/compiler_rt/addvdi3.zig
+++ b/lib/compiler_rt/addvdi3.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const testing = @import("std").testing;
 
 comptime {
-    @export(&__addvdi3, .{ .name = "__addvdi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__addvdi3, "__addvdi3");
 }
 
 pub fn __addvdi3(a: i64, b: i64) callconv(.c) i64 {
diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig
index b87b7a6315252a277ed7b6d8f6b001f833885ed9..31c87f4b1ba6ab6f6f668952e61770fcbcd641cd 100644
--- a/lib/compiler_rt/atomics.zig
+++ b/lib/compiler_rt/atomics.zig
@@ -1,10 +1,11 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("./common.zig");
 const cpu = builtin.cpu;
 const arch = cpu.arch;
-const linkage = common.linkage;
-const visibility = common.visibility;
+
+const std = @import("std");
+
+const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 // This parameter is true iff the target architecture supports the bare minimum
 // to implement the atomic load/store intrinsics.
@@ -225,7 +226,7 @@ fn __atomic_store_16(dst: *u128, value: u128, model: i32) callconv(.c) void {
 }
 
 fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T {
-    const WideAtomic = std.meta.Int(.unsigned, smallest_atomic_fetch_exch_size * 8);
+    const WideAtomic = @Int(.unsigned, smallest_atomic_fetch_exch_size * 8);
 
     const addr = @intFromPtr(ptr);
     const wide_addr = addr & ~(@as(T, smallest_atomic_fetch_exch_size) - 1);
@@ -535,81 +536,81 @@ fn __atomic_fetch_umin_16(ptr: *u128, val: u128, model: i32) callconv(.c) u128 {
 
 comptime {
     if (supports_atomic_ops and builtin.object_format != .c) {
-        @export(&__atomic_load, .{ .name = "__atomic_load", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_store, .{ .name = "__atomic_store", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_load, "__atomic_load");
+        symbol(&__atomic_store, "__atomic_store");
+        symbol(&__atomic_exchange, "__atomic_exchange");
+        symbol(&__atomic_compare_exchange, "__atomic_compare_exchange");
 
-        @export(&__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_add_16, .{ .name = "__atomic_fetch_add_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_add_1, "__atomic_fetch_add_1");
+        symbol(&__atomic_fetch_add_2, "__atomic_fetch_add_2");
+        symbol(&__atomic_fetch_add_4, "__atomic_fetch_add_4");
+        symbol(&__atomic_fetch_add_8, "__atomic_fetch_add_8");
+        symbol(&__atomic_fetch_add_16, "__atomic_fetch_add_16");
 
-        @export(&__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_sub_16, .{ .name = "__atomic_fetch_sub_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_sub_1, "__atomic_fetch_sub_1");
+        symbol(&__atomic_fetch_sub_2, "__atomic_fetch_sub_2");
+        symbol(&__atomic_fetch_sub_4, "__atomic_fetch_sub_4");
+        symbol(&__atomic_fetch_sub_8, "__atomic_fetch_sub_8");
+        symbol(&__atomic_fetch_sub_16, "__atomic_fetch_sub_16");
 
-        @export(&__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_and_16, .{ .name = "__atomic_fetch_and_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_and_1, "__atomic_fetch_and_1");
+        symbol(&__atomic_fetch_and_2, "__atomic_fetch_and_2");
+        symbol(&__atomic_fetch_and_4, "__atomic_fetch_and_4");
+        symbol(&__atomic_fetch_and_8, "__atomic_fetch_and_8");
+        symbol(&__atomic_fetch_and_16, "__atomic_fetch_and_16");
 
-        @export(&__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_or_16, .{ .name = "__atomic_fetch_or_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_or_1, "__atomic_fetch_or_1");
+        symbol(&__atomic_fetch_or_2, "__atomic_fetch_or_2");
+        symbol(&__atomic_fetch_or_4, "__atomic_fetch_or_4");
+        symbol(&__atomic_fetch_or_8, "__atomic_fetch_or_8");
+        symbol(&__atomic_fetch_or_16, "__atomic_fetch_or_16");
 
-        @export(&__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_xor_16, .{ .name = "__atomic_fetch_xor_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_xor_1, "__atomic_fetch_xor_1");
+        symbol(&__atomic_fetch_xor_2, "__atomic_fetch_xor_2");
+        symbol(&__atomic_fetch_xor_4, "__atomic_fetch_xor_4");
+        symbol(&__atomic_fetch_xor_8, "__atomic_fetch_xor_8");
+        symbol(&__atomic_fetch_xor_16, "__atomic_fetch_xor_16");
 
-        @export(&__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_nand_16, .{ .name = "__atomic_fetch_nand_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_nand_1, "__atomic_fetch_nand_1");
+        symbol(&__atomic_fetch_nand_2, "__atomic_fetch_nand_2");
+        symbol(&__atomic_fetch_nand_4, "__atomic_fetch_nand_4");
+        symbol(&__atomic_fetch_nand_8, "__atomic_fetch_nand_8");
+        symbol(&__atomic_fetch_nand_16, "__atomic_fetch_nand_16");
 
-        @export(&__atomic_fetch_umax_1, .{ .name = "__atomic_fetch_umax_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_2, .{ .name = "__atomic_fetch_umax_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_4, .{ .name = "__atomic_fetch_umax_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_8, .{ .name = "__atomic_fetch_umax_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_16, .{ .name = "__atomic_fetch_umax_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_umax_1, "__atomic_fetch_umax_1");
+        symbol(&__atomic_fetch_umax_2, "__atomic_fetch_umax_2");
+        symbol(&__atomic_fetch_umax_4, "__atomic_fetch_umax_4");
+        symbol(&__atomic_fetch_umax_8, "__atomic_fetch_umax_8");
+        symbol(&__atomic_fetch_umax_16, "__atomic_fetch_umax_16");
 
-        @export(&__atomic_fetch_umin_1, .{ .name = "__atomic_fetch_umin_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_2, .{ .name = "__atomic_fetch_umin_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_4, .{ .name = "__atomic_fetch_umin_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_8, .{ .name = "__atomic_fetch_umin_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_16, .{ .name = "__atomic_fetch_umin_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_umin_1, "__atomic_fetch_umin_1");
+        symbol(&__atomic_fetch_umin_2, "__atomic_fetch_umin_2");
+        symbol(&__atomic_fetch_umin_4, "__atomic_fetch_umin_4");
+        symbol(&__atomic_fetch_umin_8, "__atomic_fetch_umin_8");
+        symbol(&__atomic_fetch_umin_16, "__atomic_fetch_umin_16");
 
-        @export(&__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_load_16, .{ .name = "__atomic_load_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_load_1, "__atomic_load_1");
+        symbol(&__atomic_load_2, "__atomic_load_2");
+        symbol(&__atomic_load_4, "__atomic_load_4");
+        symbol(&__atomic_load_8, "__atomic_load_8");
+        symbol(&__atomic_load_16, "__atomic_load_16");
 
-        @export(&__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_store_16, .{ .name = "__atomic_store_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_store_1, "__atomic_store_1");
+        symbol(&__atomic_store_2, "__atomic_store_2");
+        symbol(&__atomic_store_4, "__atomic_store_4");
+        symbol(&__atomic_store_8, "__atomic_store_8");
+        symbol(&__atomic_store_16, "__atomic_store_16");
 
-        @export(&__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_exchange_16, .{ .name = "__atomic_exchange_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_exchange_1, "__atomic_exchange_1");
+        symbol(&__atomic_exchange_2, "__atomic_exchange_2");
+        symbol(&__atomic_exchange_4, "__atomic_exchange_4");
+        symbol(&__atomic_exchange_8, "__atomic_exchange_8");
+        symbol(&__atomic_exchange_16, "__atomic_exchange_16");
 
-        @export(&__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_compare_exchange_16, .{ .name = "__atomic_compare_exchange_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_compare_exchange_1, "__atomic_compare_exchange_1");
+        symbol(&__atomic_compare_exchange_2, "__atomic_compare_exchange_2");
+        symbol(&__atomic_compare_exchange_4, "__atomic_compare_exchange_4");
+        symbol(&__atomic_compare_exchange_8, "__atomic_compare_exchange_8");
+        symbol(&__atomic_compare_exchange_16, "__atomic_compare_exchange_16");
     }
 }
diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig
index fbfa18dfd195c295c91514d21d9abce04ba9bea2..fb0d6126a86f46a3af3fca1b979be1245ce36b0f 100644
--- a/lib/compiler_rt/aulldiv.zig
+++ b/lib/compiler_rt/aulldiv.zig
@@ -1,15 +1,13 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
-const os = builtin.os.tag;
-const abi = builtin.abi;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_x86_msvc_abi) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
-        @export(&_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_alldiv, "\x01__alldiv");
+        symbol(&_aulldiv, "\x01__aulldiv");
     }
 }
 
diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig
index ebec596f270d739e689f3f735f94800a96ed95dc..691827ac4b2565a5e01a8c74ff7a0d785e788725 100644
--- a/lib/compiler_rt/cmpdf2.zig
+++ b/lib/compiler_rt/cmpdf2.zig
@@ -2,18 +2,19 @@
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dcmpeq, "__aeabi_dcmpeq");
+        symbol(&__aeabi_dcmplt, "__aeabi_dcmplt");
+        symbol(&__aeabi_dcmple, "__aeabi_dcmple");
     } else {
-        @export(&__eqdf2, .{ .name = "__eqdf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__nedf2, .{ .name = "__nedf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__ledf2, .{ .name = "__ledf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__cmpdf2, .{ .name = "__cmpdf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__ltdf2, .{ .name = "__ltdf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__eqdf2, "__eqdf2");
+        symbol(&__nedf2, "__nedf2");
+        symbol(&__ledf2, "__ledf2");
+        symbol(&__cmpdf2, "__cmpdf2");
+        symbol(&__ltdf2, "__ltdf2");
     }
 }
 
diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig
index 3188ecf90ec5f180fc500f39530a432354135673..846e62935c763e1311d0e635f6af6116d7eeea38 100644
--- a/lib/compiler_rt/cmptf2.zig
+++ b/lib/compiler_rt/cmptf2.zig
@@ -2,27 +2,28 @@
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__netf2, .{ .name = "__nekf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__letf2, .{ .name = "__lekf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__eqtf2, "__eqkf2");
+        symbol(&__netf2, "__nekf2");
+        symbol(&__lttf2, "__ltkf2");
+        symbol(&__letf2, "__lekf2");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_Qp_fne, .{ .name = "_Qp_fne", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_Qp_flt, .{ .name = "_Qp_flt", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_cmp, "_Qp_cmp");
+        symbol(&_Qp_feq, "_Qp_feq");
+        symbol(&_Qp_fne, "_Qp_fne");
+        symbol(&_Qp_flt, "_Qp_flt");
+        symbol(&_Qp_fle, "_Qp_fle");
+        symbol(&_Qp_fgt, "_Qp_fgt");
+        symbol(&_Qp_fge, "_Qp_fge");
     }
-    @export(&__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__netf2, .{ .name = "__netf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__letf2, .{ .name = "__letf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__lttf2, .{ .name = "__lttf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__eqtf2, "__eqtf2");
+    symbol(&__netf2, "__netf2");
+    symbol(&__letf2, "__letf2");
+    symbol(&__cmptf2, "__cmptf2");
+    symbol(&__lttf2, "__lttf2");
 }
 
 /// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index a9b4c2296c5974415af57e3d2dc1aba2941f96cf..0839d78b1b34d4c18f87d9143c0d9599135899f9 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -3,23 +3,11 @@ const builtin = @import("builtin");
 const native_endian = builtin.cpu.arch.endian();
 const ofmt_c = builtin.object_format == .c;
 
-/// For now, we prefer weak linkage because some of the routines we implement here may also be
-/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
-/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
-pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
-    .internal
-else if (ofmt_c)
-    .strong
-else
-    .weak;
+/// Deprecated, everything in common should move to compiler_rt.zig
+pub const linkage = @import("../compiler_rt.zig").linkage;
 
-/// Determines the symbol's visibility to other objects.
-/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
-/// export it to the host runtime.
-pub const visibility: std.builtin.SymbolVisibility = if (linkage == .internal or builtin.link_mode == .dynamic)
-    .default
-else
-    .hidden;
+/// Deprecated, everything in common should move to compiler_rt.zig
+pub const visibility = @import("../compiler_rt.zig").visibility;
 
 pub const PreferredLoadStoreElement = element: {
     if (std.simd.suggestVectorLength(u8)) |vec_size| {
@@ -121,10 +109,8 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) {
 
 pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
 
-pub const test_safety = switch (builtin.zig_backend) {
-    .stage2_aarch64 => false,
-    else => builtin.is_test,
-};
+/// Deprecated, everything in common should move to compiler_rt.zig
+pub const test_safety = @import("../compiler_rt.zig").test_safety;
 
 /// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
 pub fn F16T(comptime OtherType: type) type {
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 3384887385f0faeb4ad3c1b0b5f35e7a189ceb31..406098d56b9a172ca99f725b401cd42a27185047 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -2,22 +2,23 @@ const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+
 const common = @import("common.zig");
-
+const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 comptime {
-    @export(&__cosh, .{ .name = "__cosh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&cosf, .{ .name = "cosf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&cos, .{ .name = "cos", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__cosx, .{ .name = "__cosx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__cosh, "__cosh");
+    symbol(&cosf, "cosf");
+    symbol(&cos, "cos");
+    symbol(&__cosx, "__cosx");
     if (common.want_ppc_abi) {
-        @export(&cosq, .{ .name = "cosf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&cosq, "cosf128");
     }
-    @export(&cosq, .{ .name = "cosq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&cosl, .{ .name = "cosl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&cosq, "cosq");
+    symbol(&cosl, "cosl");
 }
 
 pub fn __cosh(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/count0bits.zig b/lib/compiler_rt/count0bits.zig
index 3696c899447e5328f1b13b369a0f9e41f1924ebe..12084864646b6d9e58c5c6147ce2b582dd7d4f9b 100644
--- a/lib/compiler_rt/count0bits.zig
+++ b/lib/compiler_rt/count0bits.zig
@@ -1,17 +1,17 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const std = @import("std");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__clzsi2, .{ .name = "__clzsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__clzdi2, .{ .name = "__clzdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__clzti2, .{ .name = "__clzti2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ctzsi2, .{ .name = "__ctzsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ctzdi2, .{ .name = "__ctzdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ctzti2, .{ .name = "__ctzti2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ffssi2, .{ .name = "__ffssi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ffsdi2, .{ .name = "__ffsdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ffsti2, .{ .name = "__ffsti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__clzsi2, "__clzsi2");
+    symbol(&__clzdi2, "__clzdi2");
+    symbol(&__clzti2, "__clzti2");
+    symbol(&__ctzsi2, "__ctzsi2");
+    symbol(&__ctzdi2, "__ctzdi2");
+    symbol(&__ctzti2, "__ctzti2");
+    symbol(&__ffssi2, "__ffssi2");
+    symbol(&__ffsdi2, "__ffsdi2");
+    symbol(&__ffsti2, "__ffsti2");
 }
 
 // clz - count leading zeroes
diff --git a/lib/compiler_rt/divdc3.zig b/lib/compiler_rt/divdc3.zig
index ce2797ee39a1b03cd6d602e27c9c431f92978457..e26dd26d61552832bcd1d19c022e8b0455551a40 100644
--- a/lib/compiler_rt/divdc3.zig
+++ b/lib/compiler_rt/divdc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divdc3, "__divdc3");
     }
 }
 
diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig
index a94544165bdfc11531e877a7c919e6085e60fb39..c57b432832da60e2eefe2d3ca6e75f499fa2b301 100644
--- a/lib/compiler_rt/divdf3.zig
+++ b/lib/compiler_rt/divdf3.zig
@@ -3,18 +3,17 @@
 //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divdf3.c
 
 const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 const normalize = common.normalize;
 const wideMultiply = common.wideMultiply;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_ddiv, "__aeabi_ddiv");
     } else {
-        @export(&__divdf3, .{ .name = "__divdf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divdf3, "__divdf3");
     }
 }
 
diff --git a/lib/compiler_rt/divhf3.zig b/lib/compiler_rt/divhf3.zig
index 84bfe378710325a7d5994f92623c35603a11ed2d..fc2710ff2761fce7e8822583b86aefc562f98486 100644
--- a/lib/compiler_rt/divhf3.zig
+++ b/lib/compiler_rt/divhf3.zig
@@ -1,8 +1,8 @@
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const divsf3 = @import("./divsf3.zig");
 
 comptime {
-    @export(&__divhf3, .{ .name = "__divhf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divhf3, "__divhf3");
 }
 
 pub fn __divhf3(a: f16, b: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/divmodei4.zig b/lib/compiler_rt/divmodei4.zig
index ab11452206f5d52d3a709b5c90fb23344a59cf72..d96be7dec5cd71011da2b7744a22e1203335e540 100644
--- a/lib/compiler_rt/divmodei4.zig
+++ b/lib/compiler_rt/divmodei4.zig
@@ -1,15 +1,17 @@
-const std = @import("std");
 const builtin = @import("builtin");
+const endian = builtin.cpu.arch.endian();
+
+const std = @import("std");
+
 const common = @import("common.zig");
 const udivmod = @import("udivmodei4.zig").divmod;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divei4, "__divei4");
+    symbol(&__modei4, "__modei4");
 }
 
-const endian = builtin.cpu.arch.endian();
-
 inline fn limb(x: []u32, i: usize) *u32 {
     return if (endian == .little) &x[i] else &x[x.len - 1 - i];
 }
diff --git a/lib/compiler_rt/divsc3.zig b/lib/compiler_rt/divsc3.zig
index 504d8f7d67ace593a310e15d6594ccdb1aba0ad7..9378bfab8ce80584b3b5b1b6d1fbd70200ef6648 100644
--- a/lib/compiler_rt/divsc3.zig
+++ b/lib/compiler_rt/divsc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divsc3, .{ .name = "__divsc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divsc3, "__divsc3");
     }
 }
 
diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig
index dca1d49ebe0cdd0f8e1c66fd758ba8f91ea10a09..67e24de80dde507f71b290ea9884658b739cd503 100644
--- a/lib/compiler_rt/divsf3.zig
+++ b/lib/compiler_rt/divsf3.zig
@@ -3,17 +3,16 @@
 //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divsf3.c
 
 const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
 
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const normalize = common.normalize;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_fdiv, "__aeabi_fdiv");
     } else {
-        @export(&__divsf3, .{ .name = "__divsf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divsf3, "__divsf3");
     }
 }
 
diff --git a/lib/compiler_rt/divtc3.zig b/lib/compiler_rt/divtc3.zig
index 3bdf2a90338d9c5b65634e160e9a5342b48a7280..d686958621958a2fe81446d5cdab03001629650c 100644
--- a/lib/compiler_rt/divtc3.zig
+++ b/lib/compiler_rt/divtc3.zig
@@ -1,12 +1,13 @@
 const common = @import("./common.zig");
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
         if (common.want_ppc_abi)
-            @export(&__divtc3, .{ .name = "__divkc3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__divtc3, "__divkc3");
+        symbol(&__divtc3, "__divtc3");
     }
 }
 
diff --git a/lib/compiler_rt/divxc3.zig b/lib/compiler_rt/divxc3.zig
index 6e5f7905dd63654f2d9d42fd74230614154ae46a..86c737a83931c6c34f73303eeaba00536d8e1bd4 100644
--- a/lib/compiler_rt/divxc3.zig
+++ b/lib/compiler_rt/divxc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divxc3, "__divxc3");
     }
 }
 
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index f25bf57092cbfbe850ab20e02ff127eb3c1822c2..3f18188fa0905669a373df546dd3924cec4dbb36 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -4,25 +4,28 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/expf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c
 
-const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
+
+const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__exph, .{ .name = "__exph", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&expf, .{ .name = "expf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&exp, .{ .name = "exp", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__expx, .{ .name = "__expx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__exph, "__exph");
+    symbol(&expf, "expf");
+    symbol(&exp, "exp");
+    symbol(&__expx, "__expx");
     if (common.want_ppc_abi) {
-        @export(&expq, .{ .name = "expf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&expq, "expf128");
     }
-    @export(&expq, .{ .name = "expq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&expl, .{ .name = "expl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&expq, "expq");
+    symbol(&expl, "expl");
 }
 
 pub fn __exph(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig
index 9ef552c2c55032bcca12bb99c7f3dbbf3f121e5e..0204de48edbf75097daa2a387b9618990260a3bb 100644
--- a/lib/compiler_rt/extenddftf2.zig
+++ b/lib/compiler_rt/extenddftf2.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const extendf = @import("./extendf.zig").extendf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__extenddftf2, "__extenddfkf2");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_dtoq, "_Qp_dtoq");
     }
-    @export(&__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extenddftf2, "__extenddftf2");
 }
 
 pub fn __extenddftf2(a: f64) callconv(.c) f128 {
diff --git a/lib/compiler_rt/extendhfdf2.zig b/lib/compiler_rt/extendhfdf2.zig
index 3b3b65ec114ceb3e11d743fa664b794c3bc2b773..2191bafe136c94e75527a363626779f55302b334 100644
--- a/lib/compiler_rt/extendhfdf2.zig
+++ b/lib/compiler_rt/extendhfdf2.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const extendf = @import("./extendf.zig").extendf;
 
 comptime {
-    @export(&__extendhfdf2, .{ .name = "__extendhfdf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendhfdf2, "__extendhfdf2");
 }
 
 pub fn __extendhfdf2(a: common.F16T(f64)) callconv(.c) f64 {
diff --git a/lib/compiler_rt/extendhfsf2.zig b/lib/compiler_rt/extendhfsf2.zig
index f4f8be4305c846f3f5d9d748c9b7c2b383aa5768..2c734f0147651e165bafa14111289d22e776085c 100644
--- a/lib/compiler_rt/extendhfsf2.zig
+++ b/lib/compiler_rt/extendhfsf2.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const extendf = @import("./extendf.zig").extendf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.gnu_f16_abi) {
-        @export(&__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gnu_h2f_ieee, "__gnu_h2f_ieee");
     } else if (common.want_aeabi) {
-        @export(&__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_h2f, "__aeabi_h2f");
     }
-    @export(&__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendhfsf2, "__extendhfsf2");
 }
 
 pub fn __extendhfsf2(a: common.F16T(f32)) callconv(.c) f32 {
diff --git a/lib/compiler_rt/extendsfxf2.zig b/lib/compiler_rt/extendsfxf2.zig
index 8665c445f770c60c7c9d2af732c8c46f0a9ddf50..9a6796bd668602b1d653a6581613fcb69edb7853 100644
--- a/lib/compiler_rt/extendsfxf2.zig
+++ b/lib/compiler_rt/extendsfxf2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const extend_f80 = @import("./extendf.zig").extend_f80;
 
 comptime {
-    @export(&__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendsfxf2, "__extendsfxf2");
 }
 
 fn __extendsfxf2(a: f32) callconv(.c) f80 {
diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig
index cec1fa1f7ce9891734177d7baab3776307bd4657..1c39e1e84c7a3beb0a9470a123c05dea456eed77 100644
--- a/lib/compiler_rt/extendxftf2.zig
+++ b/lib/compiler_rt/extendxftf2.zig
@@ -1,8 +1,9 @@
 const std = @import("std");
-const common = @import("./common.zig");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendxftf2, "__extendxftf2");
 }
 
 fn __extendxftf2(a: f80) callconv(.c) f128 {
diff --git a/lib/compiler_rt/fixdfsi.zig b/lib/compiler_rt/fixdfsi.zig
index b1b26867b9c1899c73efe201c43f04ee95da3a58..7707f898302898743dc5c07b0969967c40e2163e 100644
--- a/lib/compiler_rt/fixdfsi.zig
+++ b/lib/compiler_rt/fixdfsi.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_d2iz, "__aeabi_d2iz");
     } else {
-        @export(&__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfsi, "__fixdfsi");
     }
 }
 
diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig
index 499811c5511a30c9724aca2fab257efe4b470465..64c5a080f91a2c9afc2e9bb265a599a207e3312a 100644
--- a/lib/compiler_rt/fixdfti.zig
+++ b/lib/compiler_rt/fixdfti.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfti_windows_x86_64, "__fixdfti");
     } else {
-        @export(&__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfti, "__fixdfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixsfdi.zig b/lib/compiler_rt/fixsfdi.zig
index 894d5a0c1353b6a1890decd86d4ba7d41f2366b8..b2880aefc23714d1ecfa6cf2456d2ab55b737d14 100644
--- a/lib/compiler_rt/fixsfdi.zig
+++ b/lib/compiler_rt/fixsfdi.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_f2lz, "__aeabi_f2lz");
     } else {
         if (common.want_windows_arm_abi) {
-            @export(&__fixsfdi, .{ .name = "__stoi64", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__fixsfdi, "__stoi64");
         }
-        @export(&__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixsfdi, "__fixsfdi");
     }
 }
 
diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig
index 5c41f56595e5bdcddb55fdc63caab5836f0a22f3..bc1c8e56eb4fa3d3a06dd991972c7f22df500917 100644
--- a/lib/compiler_rt/fixtfdi.zig
+++ b/lib/compiler_rt/fixtfdi.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfdi, "__fixkfdi");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_qtox, "_Qp_qtox");
     }
-    @export(&__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixtfdi, "__fixtfdi");
 }
 
 pub fn __fixtfdi(a: f128) callconv(.c) i64 {
diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig
index 0d525cf8c4c442175fa7ebf39af2711823f74243..0919566a804a68d3ebb050fea1c74a2294d1f598 100644
--- a/lib/compiler_rt/fixtfsi.zig
+++ b/lib/compiler_rt/fixtfsi.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfsi, "__fixkfsi");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_qtoi, "_Qp_qtoi");
     }
-    @export(&__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixtfsi, "__fixtfsi");
 }
 
 pub fn __fixtfsi(a: f128) callconv(.c) i32 {
diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig
index fe71a0f08906d929771ff367b97921b6044a05b8..2a1a928256a380e4336aac7e8b5b9dad9390a7ea 100644
--- a/lib/compiler_rt/fixtfti.zig
+++ b/lib/compiler_rt/fixtfti.zig
@@ -1,14 +1,14 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixtfti_windows_x86_64, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfti_windows_x86_64, "__fixtfti");
     } else {
         if (common.want_ppc_abi)
-            @export(&__fixtfti, .{ .name = "__fixkfti", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__fixtfti, "__fixkfti");
+        symbol(&__fixtfti, "__fixtfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfei.zig b/lib/compiler_rt/fixunsdfei.zig
index be5bbf0a8a7a4c51c72609fe76e93b76ff81012f..f564f7f7a32869e7cdad92a2f264941a3eab7511 100644
--- a/lib/compiler_rt/fixunsdfei.zig
+++ b/lib/compiler_rt/fixunsdfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunsdfei, .{ .name = "__fixunsdfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsdfei, "__fixunsdfei");
 }
 
 pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig
index 28b79a0733b0cb8a881b4c5556d7ce32690d1069..a90b3d67fb5e5fc5640447b74464c65b18705d9a 100644
--- a/lib/compiler_rt/fixunsdfti.zig
+++ b/lib/compiler_rt/fixunsdfti.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti");
     } else {
-        @export(&__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsdfti, "__fixunsdfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunshfdi.zig b/lib/compiler_rt/fixunshfdi.zig
index a949ee99045d07e3a007c074bf974fcb95c28fb6..741e482506d2df3ffbb1388a9848f9317f6f1808 100644
--- a/lib/compiler_rt/fixunshfdi.zig
+++ b/lib/compiler_rt/fixunshfdi.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunshfdi, "__fixunshfdi");
 }
 
 fn __fixunshfdi(a: f16) callconv(.c) u64 {
diff --git a/lib/compiler_rt/fixunshfei.zig b/lib/compiler_rt/fixunshfei.zig
index 4cb7ef2ba8da0c8d9862cd3ea0e9425429834fba..a61d94f3958f4cc8f5f01f57f317e5a44f32fc20 100644
--- a/lib/compiler_rt/fixunshfei.zig
+++ b/lib/compiler_rt/fixunshfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunshfei, .{ .name = "__fixunshfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunshfei, "__fixunshfei");
 }
 
 pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig
index c61be597e772b6abebe139712a00c0f251747c6b..454aa9d57569749bf2d304baf6e3bac85bdd867a 100644
--- a/lib/compiler_rt/fixunshfti.zig
+++ b/lib/compiler_rt/fixunshfti.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixunshfti_windows_x86_64, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunshfti_windows_x86_64, "__fixunshfti");
     } else {
-        @export(&__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunshfti, "__fixunshfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfei.zig b/lib/compiler_rt/fixunssfei.zig
index 0fb957ed1f79ed31b5f27f5f1b368fec7b4655a6..2fd123bd1b4693f96b51604a794dc2879660dc87 100644
--- a/lib/compiler_rt/fixunssfei.zig
+++ b/lib/compiler_rt/fixunssfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunssfei, .{ .name = "__fixunssfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunssfei, "__fixunssfei");
 }
 
 pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig
index 693442417c77cab0c74bff9135025ab86bcde86f..73e2d2a3f6b81926d346f9c04da8f880e4acf616 100644
--- a/lib/compiler_rt/fixunssfti.zig
+++ b/lib/compiler_rt/fixunssfti.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunssfti_windows_x86_64, "__fixunssfti");
     } else {
-        @export(&__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunssfti, "__fixunssfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunstfei.zig b/lib/compiler_rt/fixunstfei.zig
index 84ac5010c96e9c3113eec67e9ca6f5291787f9e8..3d8986da90790a1a9cbf9a5fa2939e94c8009cc2 100644
--- a/lib/compiler_rt/fixunstfei.zig
+++ b/lib/compiler_rt/fixunstfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunstfei, .{ .name = "__fixunstfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunstfei, "__fixunstfei");
 }
 
 pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunsxfdi.zig b/lib/compiler_rt/fixunsxfdi.zig
index 4dffd0253ee533db22eba53b5c5e6334cf0bf593..8385961b6b2ea2cd7632776ffa46d41e9e6f8bf3 100644
--- a/lib/compiler_rt/fixunsxfdi.zig
+++ b/lib/compiler_rt/fixunsxfdi.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsxfdi, "__fixunsxfdi");
 }
 
 fn __fixunsxfdi(a: f80) callconv(.c) u64 {
diff --git a/lib/compiler_rt/fixunsxfei.zig b/lib/compiler_rt/fixunsxfei.zig
index dc795e74c691e6cb6c0927ef703163aa5481f5b6..d7902ddff54773d5240a57c8aaf6910ab6f9f02e 100644
--- a/lib/compiler_rt/fixunsxfei.zig
+++ b/lib/compiler_rt/fixunsxfei.zig
@@ -1,10 +1,10 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsxfei, "__fixunsxfei");
 }
 
 pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {
diff --git a/lib/compiler_rt/fixxfdi.zig b/lib/compiler_rt/fixxfdi.zig
index 155fead1bbe18c813a7a641700c23f3e6e41c431..e9e4b7528b07168dafdf4791a6cc13d795d5b78a 100644
--- a/lib/compiler_rt/fixxfdi.zig
+++ b/lib/compiler_rt/fixxfdi.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixxfdi, "__fixxfdi");
 }
 
 fn __fixxfdi(a: f80) callconv(.c) i64 {
diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig
index 292b9688e7fa1b627edf9943915dba087141bdc7..2f43814eacf1dd310a878f0e42e546250ea5f424 100644
--- a/lib/compiler_rt/fixxfti.zig
+++ b/lib/compiler_rt/fixxfti.zig
@@ -1,12 +1,14 @@
 const builtin = @import("builtin");
+
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixxfti_windows_x86_64, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixxfti_windows_x86_64, "__fixxfti");
     } else {
-        @export(&__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixxfti, "__fixxfti");
     }
 }
 
diff --git a/lib/compiler_rt/floatdihf.zig b/lib/compiler_rt/floatdihf.zig
index fd534e5946202527e9b6ce1cef31e970230c384b..c6865dff6b8025e49b8f1a0ffc36674c230247a4 100644
--- a/lib/compiler_rt/floatdihf.zig
+++ b/lib/compiler_rt/floatdihf.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatdihf, "__floatdihf");
 }
 
 fn __floatdihf(a: i64) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatdisf.zig b/lib/compiler_rt/floatdisf.zig
index 1efd9c937ff2b2849db3be096696bff395d55f0a..691ba91f26b9228380481258dca2f0719e67b09d 100644
--- a/lib/compiler_rt/floatdisf.zig
+++ b/lib/compiler_rt/floatdisf.zig
@@ -1,15 +1,15 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_l2f, "__aeabi_l2f");
     } else {
         if (common.want_windows_arm_abi) {
-            @export(&__floatdisf, .{ .name = "__i64tos", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floatdisf, "__i64tos");
         }
-        @export(&__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatdisf, "__floatdisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig
index 864361b7b3d567f959e1e6cde55e20b40a9d487c..03182aab0b96e04619ecc48fff90f80548bb2c29 100644
--- a/lib/compiler_rt/floatditf.zig
+++ b/lib/compiler_rt/floatditf.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatditf, "__floatdikf");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_xtoq, "_Qp_xtoq");
     }
-    @export(&__floatditf, .{ .name = "__floatditf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatditf, "__floatditf");
 }
 
 pub fn __floatditf(a: i64) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatdixf.zig b/lib/compiler_rt/floatdixf.zig
index 8ac6f06fb5929319ad28e387377b120ae3e95e37..6bd06245d584402e7ed93b0d57d71f471bde05d4 100644
--- a/lib/compiler_rt/floatdixf.zig
+++ b/lib/compiler_rt/floatdixf.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatdixf, "__floatdixf");
 }
 
 fn __floatdixf(a: i64) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floateidf.zig b/lib/compiler_rt/floateidf.zig
index 6434743939ec3895302925bca84937d42d6a2287..ac3972c28778600d342d0412741e9a3e41797546 100644
--- a/lib/compiler_rt/floateidf.zig
+++ b/lib/compiler_rt/floateidf.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__floateidf, .{ .name = "__floateidf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateidf, "__floateidf");
 }
 
 pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 {
diff --git a/lib/compiler_rt/floateixf.zig b/lib/compiler_rt/floateixf.zig
index ffb8445fd337ae8d7311233675435f7e7a3af1f7..dafefa4e8f11b978f26b5e4d10cc8b0feeed480b 100644
--- a/lib/compiler_rt/floateixf.zig
+++ b/lib/compiler_rt/floateixf.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floateixf, .{ .name = "__floateixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateixf, "__floateixf");
 }
 
 pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floatsixf.zig b/lib/compiler_rt/floatsixf.zig
index 59bf7ddb99ffd827ab0fe52540ecf7af99a80477..0d5fcb340db962c8fa7231eed32f5076c9486b7a 100644
--- a/lib/compiler_rt/floatsixf.zig
+++ b/lib/compiler_rt/floatsixf.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__floatsixf, .{ .name = "__floatsixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatsixf, "__floatsixf");
 }
 
 fn __floatsixf(a: i32) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig
index 2ac5726b5166ab233125ae44dcf74a4fe11eed5b..db48fe8af37195b59db7ce5f16790a88b4f09f2e 100644
--- a/lib/compiler_rt/floattidf.zig
+++ b/lib/compiler_rt/floattidf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattidf_windows_x86_64, "__floattidf");
     } else {
-        @export(&__floattidf, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattidf, "__floattidf");
     }
 }
 
diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig
index 953192f33115a103b27f48a56875ab7176c2af15..3e5fffcfd8fec0d5972819955b703bffa45f3fb1 100644
--- a/lib/compiler_rt/floattisf.zig
+++ b/lib/compiler_rt/floattisf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattisf_windows_x86_64, "__floattisf");
     } else {
-        @export(&__floattisf, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattisf, "__floattisf");
     }
 }
 
diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig
index 3973aa4ab294fea0b9f905194bebc914a9532cd5..e8e301c42d36f9faa01e6f13d4cb77eb6a19739a 100644
--- a/lib/compiler_rt/floattitf.zig
+++ b/lib/compiler_rt/floattitf.zig
@@ -1,14 +1,14 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floattitf_windows_x86_64, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattitf_windows_x86_64, "__floattitf");
     } else {
         if (common.want_ppc_abi)
-            @export(&__floattitf, .{ .name = "__floattikf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__floattitf, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floattitf, "__floattikf");
+        symbol(&__floattitf, "__floattitf");
     }
 }
 
diff --git a/lib/compiler_rt/floatundidf.zig b/lib/compiler_rt/floatundidf.zig
index 7a9e4afe7af40701c85b9347ddedf36ead437f17..6530f76ee70ed4070392e299274cb84bcf6e90e3 100644
--- a/lib/compiler_rt/floatundidf.zig
+++ b/lib/compiler_rt/floatundidf.zig
@@ -1,15 +1,15 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_ul2d, "__aeabi_ul2d");
     } else {
         if (common.want_windows_arm_abi) {
-            @export(&__floatundidf, .{ .name = "__u64tod", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floatundidf, "__u64tod");
         }
-        @export(&__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatundidf, "__floatundidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuneitf.zig b/lib/compiler_rt/floatuneitf.zig
index d84678ce115f88c3cb21cc5203fb162f6404a653..ddee65dfb18b793bffe08d850384842fcff5747e 100644
--- a/lib/compiler_rt/floatuneitf.zig
+++ b/lib/compiler_rt/floatuneitf.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floatuneitf, .{ .name = "__floatuneitf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatuneitf, "__floatuneitf");
 }
 
 pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatunsihf.zig b/lib/compiler_rt/floatunsihf.zig
index 123b76fcde1b1175e74902f26e2ff820a2d6c662..a2e42ca10f3af950e900f5250fa6a3d23e2b1266 100644
--- a/lib/compiler_rt/floatunsihf.zig
+++ b/lib/compiler_rt/floatunsihf.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatunsihf, "__floatunsihf");
 }
 
 pub fn __floatunsihf(a: u32) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatunsisf.zig b/lib/compiler_rt/floatunsisf.zig
index 4bcceba5c8c967a73312765468a98876a5b128c9..72ac1a59017743f319dd65b8d609d499999715fd 100644
--- a/lib/compiler_rt/floatunsisf.zig
+++ b/lib/compiler_rt/floatunsisf.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_ui2f, "__aeabi_ui2f");
     } else {
-        @export(&__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatunsisf, "__floatunsisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig
index e491987003f054005b841a316f414412dfb9ecb8..6ad2ca5c5638834b27490bc3bbde0ec3a743ad77 100644
--- a/lib/compiler_rt/floatunsitf.zig
+++ b/lib/compiler_rt/floatunsitf.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatunsitf, "__floatunsikf");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_uitoq, "_Qp_uitoq");
     }
-    @export(&__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatunsitf, "__floatunsitf");
 }
 
 pub fn __floatunsitf(a: u32) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig
index 284e50dd367bd6dfed766842fffa0f8fecd43815..d2d34f57545fd787b35e772deacd1cae19ba9af5 100644
--- a/lib/compiler_rt/floatuntidf.zig
+++ b/lib/compiler_rt/floatuntidf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntidf_windows_x86_64, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntidf_windows_x86_64, "__floatuntidf");
     } else {
-        @export(&__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntidf, "__floatuntidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig
index 41da6f1bfb501f9b78ab65277cb4a49da40f6ad6..629e8088eb5abacfba51edd1915045833892cdb4 100644
--- a/lib/compiler_rt/floatuntihf.zig
+++ b/lib/compiler_rt/floatuntihf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntihf_windows_x86_64, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntihf_windows_x86_64, "__floatuntihf");
     } else {
-        @export(&__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntihf, "__floatuntihf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig
index 77dd22ed5978b6b86019d4c50ed7421003f7041a..64063495b8dc0f423ab06d6ce359ca1f772665c6 100644
--- a/lib/compiler_rt/floatuntitf.zig
+++ b/lib/compiler_rt/floatuntitf.zig
@@ -1,14 +1,14 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntitf_windows_x86_64, "__floatuntitf");
     } else {
         if (common.want_ppc_abi)
-            @export(&__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floatuntitf, "__floatuntikf");
+        symbol(&__floatuntitf, "__floatuntitf");
     }
 }
 
diff --git a/lib/compiler_rt/floor_ceil.zig b/lib/compiler_rt/floor_ceil.zig
index e669cb812d7268a12fd1c9db48b52e840f3863c1..c44e9c2e571eee6c009a13ed10c98742a5ec8940 100644
--- a/lib/compiler_rt/floor_ceil.zig
+++ b/lib/compiler_rt/floor_ceil.zig
@@ -15,29 +15,30 @@ const mem = std.mem;
 const expect = std.testing.expect;
 
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     // floor
-    @export(&__floorh, .{ .name = "__floorh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&floorf, .{ .name = "floorf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&floor, .{ .name = "floor", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__floorx, .{ .name = "__floorx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floorh, "__floorh");
+    symbol(&floorf, "floorf");
+    symbol(&floor, "floor");
+    symbol(&__floorx, "__floorx");
     if (common.want_ppc_abi) {
-        @export(&floorq, .{ .name = "floorf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&floorq, "floorf128");
     }
-    @export(&floorq, .{ .name = "floorq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&floorl, .{ .name = "floorl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&floorq, "floorq");
+    symbol(&floorl, "floorl");
 
     // ceil
-    @export(&__ceilh, .{ .name = "__ceilh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&ceilf, .{ .name = "ceilf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&ceil, .{ .name = "ceil", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ceilx, .{ .name = "__ceilx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__ceilh, "__ceilh");
+    symbol(&ceilf, "ceilf");
+    symbol(&ceil, "ceil");
+    symbol(&__ceilx, "__ceilx");
     if (common.want_ppc_abi) {
-        @export(&ceilq, .{ .name = "ceilf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&ceilq, "ceilf128");
     }
-    @export(&ceilq, .{ .name = "ceilq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&ceill, .{ .name = "ceill", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&ceilq, "ceilq");
+    symbol(&ceill, "ceill");
 }
 
 pub fn __floorh(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig
index aeb08b4a8b9eae9979b99ba37db0db4047992a92..bd16de17f82329b39e158265f5616ebbdd12b510 100644
--- a/lib/compiler_rt/gedf2.zig
+++ b/lib/compiler_rt/gedf2.zig
@@ -2,14 +2,15 @@
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dcmpge, "__aeabi_dcmpge");
+        symbol(&__aeabi_dcmpgt, "__aeabi_dcmpgt");
     } else {
-        @export(&__gedf2, .{ .name = "__gedf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gedf2, "__gedf2");
+        symbol(&__gtdf2, "__gtdf2");
     }
 }
 
diff --git a/lib/compiler_rt/gehf2.zig b/lib/compiler_rt/gehf2.zig
index b46d4a1a24d0038abc38ce6e6ca5d5dda8324ef8..e4e15a449d41b5e703498b9a1e66c6c6c1683d0d 100644
--- a/lib/compiler_rt/gehf2.zig
+++ b/lib/compiler_rt/gehf2.zig
@@ -1,11 +1,11 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    @export(&__gehf2, .{ .name = "__gehf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__gthf2, .{ .name = "__gthf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__gehf2, "__gehf2");
+    symbol(&__gthf2, "__gthf2");
 }
 
 /// "These functions return a value greater than or equal to zero if neither
diff --git a/lib/compiler_rt/gexf2.zig b/lib/compiler_rt/gexf2.zig
index 365c298cc6161fd39f5360fedbbc0d70e6fa7c11..c6b3a1befdab554692b4d41411b933eefa227d4a 100644
--- a/lib/compiler_rt/gexf2.zig
+++ b/lib/compiler_rt/gexf2.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    @export(&__gexf2, .{ .name = "__gexf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__gexf2, "__gexf2");
+    symbol(&__gtxf2, "__gtxf2");
 }
 
 fn __gexf2(a: f80, b: f80) callconv(.c) i32 {
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index 3f38bad973d55ac78551fcda15deb1b2341e2c3c..01827cf6404d2e48826e14bb3c514e38519c9522 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -1,34 +1,37 @@
 //! Builtin functions that operate on integer types
 
 const builtin = @import("builtin");
+const arch = builtin.cpu.arch;
+
 const std = @import("std");
 const testing = std.testing;
 const maxInt = std.math.maxInt;
 const minInt = std.math.minInt;
-const arch = builtin.cpu.arch;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const udivmod = @import("udivmod.zig").udivmod;
 const __divti3 = @import("divti3.zig").__divti3;
 
 comptime {
-    @export(&__divmodti4, .{ .name = "__divmodti4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divmodti4, "__divmodti4");
+    symbol(&__udivmoddi4, "__udivmoddi4");
+    symbol(&__divmoddi4, "__divmoddi4");
     if (common.want_aeabi) {
-        @export(&__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_idiv, "__aeabi_idiv");
+        symbol(&__aeabi_uidiv, "__aeabi_uidiv");
     } else {
-        @export(&__divsi3, .{ .name = "__divsi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divsi3, "__divsi3");
+        symbol(&__udivsi3, "__udivsi3");
     }
-    @export(&__divdi3, .{ .name = "__divdi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__udivdi3, .{ .name = "__udivdi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__modsi3, .{ .name = "__modsi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__moddi3, .{ .name = "__moddi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__umodsi3, .{ .name = "__umodsi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__umoddi3, .{ .name = "__umoddi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__divmodsi4, .{ .name = "__divmodsi4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divdi3, "__divdi3");
+    symbol(&__udivdi3, "__udivdi3");
+    symbol(&__modsi3, "__modsi3");
+    symbol(&__moddi3, "__moddi3");
+    symbol(&__umodsi3, "__umodsi3");
+    symbol(&__umoddi3, "__umoddi3");
+    symbol(&__divmodsi4, "__divmodsi4");
+    symbol(&__udivmodsi4, "__udivmodsi4");
 }
 
 pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.c) i128 {
diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig
index 3270b27916169ace21dfa9a3f26f550d8fbd0c82..96dd319f720bf7237e603f82f7d2284866159af7 100644
--- a/lib/compiler_rt/log.zig
+++ b/lib/compiler_rt/log.zig
@@ -5,23 +5,23 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/log.c?h=1b76ff0767d01df72f692806ee5adee13c67ef88
 
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
-const arch = builtin.cpu.arch;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__logh, .{ .name = "__logh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&logf, .{ .name = "logf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log, .{ .name = "log", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__logx, .{ .name = "__logx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__logh, "__logh");
+    symbol(&logf, "logf");
+    symbol(&log, "log");
+    symbol(&__logx, "__logx");
     if (common.want_ppc_abi) {
-        @export(&logq, .{ .name = "logf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&logq, "logf128");
     }
-    @export(&logq, .{ .name = "logq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&logl, .{ .name = "logl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&logq, "logq");
+    symbol(&logl, "logl");
 }
 
 pub fn __logh(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index d501cef461a0d10fb78f441f30ffa4b2f023e5a9..d2741e3b231d8b0e6008f506b9cdef38e4bd392a 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -5,24 +5,24 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c
 
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const maxInt = std.math.maxInt;
-const arch = builtin.cpu.arch;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__log10h, .{ .name = "__log10h", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log10f, .{ .name = "log10f", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log10, .{ .name = "log10", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__log10x, .{ .name = "__log10x", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__log10h, "__log10h");
+    symbol(&log10f, "log10f");
+    symbol(&log10, "log10");
+    symbol(&__log10x, "__log10x");
     if (common.want_ppc_abi) {
-        @export(&log10q, .{ .name = "log10f128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&log10q, "log10f128");
     }
-    @export(&log10q, .{ .name = "log10q", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&log10q, "log10q");
+    symbol(&log10l, "log10l");
 }
 
 pub fn __log10h(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/memcmp.zig b/lib/compiler_rt/memcmp.zig
deleted file mode 100644
index f332d82eac93d91e094c64a9b51181ba1417cb7e..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/memcmp.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-const std = @import("std");
-const common = @import("./common.zig");
-
-comptime {
-    @export(&memcmp, .{ .name = "memcmp", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-pub fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.c) c_int {
-    var i: usize = 0;
-    while (i < n) : (i += 1) {
-        const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
-        if (compared != 0) return compared;
-    }
-    return 0;
-}
-
-test "memcmp" {
-    const arr0 = &[_]u8{ 1, 1, 1 };
-    const arr1 = &[_]u8{ 1, 1, 1 };
-    const arr2 = &[_]u8{ 1, 0, 1 };
-    const arr3 = &[_]u8{ 1, 2, 1 };
-    const arr4 = &[_]u8{ 1, 0xff, 1 };
-
-    try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
-    try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
-    try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
-
-    try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
-    try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
-}
diff --git a/lib/compiler_rt/muldc3.zig b/lib/compiler_rt/muldc3.zig
index 9670c1312887c99a038540ed097bb22daede93f3..d5facaa2b645670b6bf6e0953ec6b73342342329 100644
--- a/lib/compiler_rt/muldc3.zig
+++ b/lib/compiler_rt/muldc3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
 const mulc3 = @import("./mulc3.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__muldc3, "__muldc3");
     }
 }
 
diff --git a/lib/compiler_rt/muldf3.zig b/lib/compiler_rt/muldf3.zig
index cf67df0913ab624cb1f5a840f8da139e9d0d38a1..e9c978430ecd15dceba4896874e3c118374b1f04 100644
--- a/lib/compiler_rt/muldf3.zig
+++ b/lib/compiler_rt/muldf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dmul, "__aeabi_dmul");
     } else {
-        @export(&__muldf3, .{ .name = "__muldf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__muldf3, "__muldf3");
     }
 }
 
diff --git a/lib/compiler_rt/mulsc3.zig b/lib/compiler_rt/mulsc3.zig
index 49c1e31aecd43e18961bf2c3853b8855993a917c..e735e65eade6a77f908abe8b4b25e8fc30af7f9f 100644
--- a/lib/compiler_rt/mulsc3.zig
+++ b/lib/compiler_rt/mulsc3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__mulsc3, "__mulsc3");
     }
 }
 
diff --git a/lib/compiler_rt/multc3.zig b/lib/compiler_rt/multc3.zig
index 1ed373660f81ef101d6b37086b456a11dd546707..13870c6465e4d6e200119ab266ccd63f6769f306 100644
--- a/lib/compiler_rt/multc3.zig
+++ b/lib/compiler_rt/multc3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
         if (common.want_ppc_abi)
-            @export(&__multc3, .{ .name = "__mulkc3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__multc3, "__mulkc3");
+        symbol(&__multc3, "__multc3");
     }
 }
 
diff --git a/lib/compiler_rt/mulvsi3.zig b/lib/compiler_rt/mulvsi3.zig
index e773ea0d9ad756fe0d8a834ed04f4c79834fa171..0935ea497afa52a46f515c83c40c2d8cc5bc02db 100644
--- a/lib/compiler_rt/mulvsi3.zig
+++ b/lib/compiler_rt/mulvsi3.zig
@@ -1,9 +1,10 @@
-const mulv = @import("mulo.zig");
-const common = @import("./common.zig");
 const testing = @import("std").testing;
 
+const mulv = @import("mulo.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
+
 comptime {
-    @export(&__mulvsi3, .{ .name = "__mulvsi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__mulvsi3, "__mulvsi3");
 }
 
 pub fn __mulvsi3(a: i32, b: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/negtf2.zig b/lib/compiler_rt/negtf2.zig
index ecb5cc2c9007256061a7f102029e1d14c75d0494..9d981ce2ffb3159d3377a1a9843a551cac5e8e2b 100644
--- a/lib/compiler_rt/negtf2.zig
+++ b/lib/compiler_rt/negtf2.zig
@@ -1,9 +1,10 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi)
-        @export(&__negtf2, .{ .name = "__negkf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__negtf2, .{ .name = "__negtf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__negtf2, "__negkf2");
+    symbol(&__negtf2, "__negtf2");
 }
 
 fn __negtf2(a: f128) callconv(.c) f128 {
diff --git a/lib/compiler_rt/parity.zig b/lib/compiler_rt/parity.zig
index 71d50f327b178d01545fb9315e01aee2061970cf..e3881699042fafc3fc0da7415e6fb2bb6d1aedde 100644
--- a/lib/compiler_rt/parity.zig
+++ b/lib/compiler_rt/parity.zig
@@ -1,14 +1,11 @@
 //! parity - if number of bits set is even => 0, else => 1
 //! - pariytXi2_generic for big and little endian
-
-const std = @import("std");
-const builtin = @import("builtin");
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__paritysi2, .{ .name = "__paritysi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__paritydi2, .{ .name = "__paritydi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__parityti2, .{ .name = "__parityti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__paritysi2, "__paritysi2");
+    symbol(&__paritydi2, "__paritydi2");
+    symbol(&__parityti2, "__parityti2");
 }
 
 pub fn __paritysi2(a: i32) callconv(.c) i32 {
@@ -24,7 +21,7 @@ pub fn __parityti2(a: i128) callconv(.c) i32 {
 }
 
 inline fn parityXi2(comptime T: type, a: T) i32 {
-    var x: std.meta.Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
+    var x: @Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
     // Bit Twiddling Hacks: Compute parity in parallel
     comptime var shift: u8 = @bitSizeOf(T) / 2;
     inline while (shift > 2) {
diff --git a/lib/compiler_rt/popcount.zig b/lib/compiler_rt/popcount.zig
index 12ecda16cc1c2c41119017ccf32c1405f9a434f8..b1ef500ea117514d08b598e4209770bd4b879b1f 100644
--- a/lib/compiler_rt/popcount.zig
+++ b/lib/compiler_rt/popcount.zig
@@ -6,14 +6,12 @@
 //! TAOCP: Combinational Algorithms, Bitwise Tricks And Techniques,
 //!   subsubsection "Working with the rightmost bits" and "Sideways addition".
 
-const builtin = @import("builtin");
-const std = @import("std");
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__popcountsi2, .{ .name = "__popcountsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__popcountdi2, .{ .name = "__popcountdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__popcountti2, .{ .name = "__popcountti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__popcountsi2, "__popcountsi2");
+    symbol(&__popcountdi2, "__popcountdi2");
+    symbol(&__popcountti2, "__popcountti2");
 }
 
 pub fn __popcountsi2(a: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/powiXf2.zig b/lib/compiler_rt/powiXf2.zig
index b603998d556949d01c0915c51e2c50f72a509a82..91767818bd71cbe91d78a3454aaa31fe8d22ed68 100644
--- a/lib/compiler_rt/powiXf2.zig
+++ b/lib/compiler_rt/powiXf2.zig
@@ -3,18 +3,17 @@
 //! Multiplication order (left-to-right or right-to-left) does not matter for
 //! error propagation and this method is optimized for performance, not accuracy.
 
-const builtin = @import("builtin");
 const common = @import("common.zig");
-const std = @import("std");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__powihf2, .{ .name = "__powihf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powisf2, .{ .name = "__powisf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powidf2, .{ .name = "__powidf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__powihf2, "__powihf2");
+    symbol(&__powisf2, "__powisf2");
+    symbol(&__powidf2, "__powidf2");
     if (common.want_ppc_abi)
-        @export(&__powitf2, .{ .name = "__powikf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powitf2, .{ .name = "__powitf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powixf2, .{ .name = "__powixf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__powitf2, "__powikf2");
+    symbol(&__powitf2, "__powitf2");
+    symbol(&__powixf2, "__powixf2");
 }
 
 inline fn powiXf2(comptime FT: type, a: FT, b: i32) FT {
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index d25c1cd23ae194c3dabed9c497714aca5457e95e..ab1775d7ce8f50c420085e0317675802108d7933 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -5,27 +5,26 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/sin.c
 
 const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+
 const common = @import("common.zig");
-
+const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 comptime {
-    @export(&__sinh, .{ .name = "__sinh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sinf, .{ .name = "sinf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sin, .{ .name = "sin", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__sinx, .{ .name = "__sinx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__sinh, "__sinh");
+    symbol(&sinf, "sinf");
+    symbol(&sin, "sin");
+    symbol(&__sinx, "__sinx");
     if (common.want_ppc_abi) {
-        @export(&sinq, .{ .name = "sinf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&sinq, "sinf128");
     }
-    @export(&sinq, .{ .name = "sinq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sinl, .{ .name = "sinl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sinq, "sinq");
+    symbol(&sinl, "sinl");
 }
 
 pub fn __sinh(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/strlen.zig b/lib/compiler_rt/strlen.zig
deleted file mode 100644
index 01d4e760dc2c78f484937f9cf2b635d4452df0b6..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/strlen.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const std = @import("std");
-const common = @import("common.zig");
-
-comptime {
-    @export(&strlen, .{ .name = "strlen", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn strlen(s: [*:0]const c_char) callconv(.c) usize {
-    return std.mem.len(s);
-}
diff --git a/lib/compiler_rt/subdf3.zig b/lib/compiler_rt/subdf3.zig
index b1d78509028c1a57217e188e23d28e70b04d6227..3e7dcc3dd27ae6fd78c3239fc4c6afe02f7f541a 100644
--- a/lib/compiler_rt/subdf3.zig
+++ b/lib/compiler_rt/subdf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const addf3 = @import("./addf3.zig").addf3;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dsub, "__aeabi_dsub");
     } else {
-        @export(&__subdf3, .{ .name = "__subdf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__subdf3, "__subdf3");
     }
 }
 
diff --git a/lib/compiler_rt/subvdi3.zig b/lib/compiler_rt/subvdi3.zig
index 17c893c91141925285dd5eecbd6297523fbb57a2..62bb1b406835c1a72588cd9c1d08705f6663bbd2 100644
--- a/lib/compiler_rt/subvdi3.zig
+++ b/lib/compiler_rt/subvdi3.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const testing = @import("std").testing;
 
 comptime {
-    @export(&__subvdi3, .{ .name = "__subvdi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subvdi3, "__subvdi3");
 }
 
 pub fn __subvdi3(a: i64, b: i64) callconv(.c) i64 {
diff --git a/lib/compiler_rt/subxf3.zig b/lib/compiler_rt/subxf3.zig
index d119f0bd984fc311b2f67a89760c9f147397af9d..1c2dcd65429596c975937432aae6eaefb89c2f72 100644
--- a/lib/compiler_rt/subxf3.zig
+++ b/lib/compiler_rt/subxf3.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__subxf3, .{ .name = "__subxf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subxf3, "__subxf3");
 }
 
 fn __subxf3(a: f80, b: f80) callconv(.c) f80 {
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index a78d7afb67b491d1d5ebb246689dbc7e4b8d9f73..17b7f1f1e7c19b453a89c5594040d1fb27d6078e 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -17,17 +17,18 @@ const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 const arch = builtin.cpu.arch;
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__tanh, .{ .name = "__tanh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&tanf, .{ .name = "tanf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&tan, .{ .name = "tan", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__tanx, .{ .name = "__tanx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__tanh, "__tanh");
+    symbol(&tanf, "tanf");
+    symbol(&tan, "tan");
+    symbol(&__tanx, "__tanx");
     if (common.want_ppc_abi) {
-        @export(&tanq, .{ .name = "tanf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&tanq, "tanf128");
     }
-    @export(&tanq, .{ .name = "tanq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&tanl, .{ .name = "tanl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&tanq, "tanq");
+    symbol(&tanl, "tanl");
 }
 
 pub fn __tanh(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index 55468c752fa4ff279ab872f5bd15077576fe1186..799fbc9fbbdf4f3953987f401870371d1e4ea436 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -4,24 +4,27 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/truncf.c
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c
 
-const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
+
+const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__trunch, .{ .name = "__trunch", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&truncf, .{ .name = "truncf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&trunc, .{ .name = "trunc", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__truncx, .{ .name = "__truncx", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunch, "__trunch");
+    symbol(&truncf, "truncf");
+    symbol(&trunc, "trunc");
+    symbol(&__truncx, "__truncx");
     if (common.want_ppc_abi) {
-        @export(&truncq, .{ .name = "truncf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&truncq, "truncf128");
     }
-    @export(&truncq, .{ .name = "truncq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&truncl, .{ .name = "truncl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&truncq, "truncq");
+    symbol(&truncl, "truncl");
 }
 
 pub fn __trunch(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
index 4db14f0211849bb30d47f429e24b7a510736aab6..43ad7fb20dd5a4b0afbab9846b44be3c94bce1c3 100644
--- a/lib/compiler_rt/truncdfhf2.zig
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const truncf = @import("./truncf.zig").truncf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_d2h, "__aeabi_d2h");
     }
-    @export(&__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncdfhf2, "__truncdfhf2");
 }
 
 pub fn __truncdfhf2(a: f64) callconv(.c) common.F16T(f64) {
diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig
index f5adc918c2d50fc455e08db16e09de88b25088a3..bd0e7a5dc24806071622438c95f02e8bbc6054a3 100644
--- a/lib/compiler_rt/trunctfhf2.zig
+++ b/lib/compiler_rt/trunctfhf2.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const truncf = @import("./truncf.zig").truncf;
 
 comptime {
-    @export(&__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunctfhf2, "__trunctfhf2");
 }
 
 pub fn __trunctfhf2(a: f128) callconv(.c) common.F16T(f128) {
diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig
index 17e7570c9f0ecaa1b607d06deaf400a8ff83abc2..bab5534bfe08da10814e99e9015b41c02c0fe68e 100644
--- a/lib/compiler_rt/trunctfsf2.zig
+++ b/lib/compiler_rt/trunctfsf2.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const truncf = @import("./truncf.zig").truncf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__trunctfsf2, "__trunckfsf2");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_qtos, "_Qp_qtos");
     }
-    @export(&__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunctfsf2, "__trunctfsf2");
 }
 
 pub fn __trunctfsf2(a: f128) callconv(.c) f32 {
diff --git a/lib/compiler_rt/truncxfdf2.zig b/lib/compiler_rt/truncxfdf2.zig
index 1d7e66c278f3c0ecf55fa3e034ed429ad5bae913..6140d94181fbe10a5e83e880dff805e87b34fae8 100644
--- a/lib/compiler_rt/truncxfdf2.zig
+++ b/lib/compiler_rt/truncxfdf2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
 
 comptime {
-    @export(&__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncxfdf2, "__truncxfdf2");
 }
 
 fn __truncxfdf2(a: f80) callconv(.c) f64 {
diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig
index b2dd9c7468265eb8ac5c0b9d865327e4e2208493..b6abce58d5eb505e0547e5eebd3f111909565631 100644
--- a/lib/compiler_rt/truncxfhf2.zig
+++ b/lib/compiler_rt/truncxfhf2.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
 
 comptime {
-    @export(&__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncxfhf2, "__truncxfhf2");
 }
 
 fn __truncxfhf2(a: f80) callconv(.c) common.F16T(f80) {
diff --git a/lib/compiler_rt/truncxfsf2.zig b/lib/compiler_rt/truncxfsf2.zig
index 9d36f7aa29a407b0e266b74437cfdd0c869eae35..8aaf7e6906a9da938835d2c36e931bfb21d07037 100644
--- a/lib/compiler_rt/truncxfsf2.zig
+++ b/lib/compiler_rt/truncxfsf2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncxfsf2, "__truncxfsf2");
 }
 
 fn __truncxfsf2(a: f80) callconv(.c) f32 {
diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig
index 0923f3f222fcdc070334afc3fdad4a610ecb4f6f..fd8cc6717e68b649d16f8a71ec36f7f576f326fa 100644
--- a/lib/compiler_rt/udivmodei4.zig
+++ b/lib/compiler_rt/udivmodei4.zig
@@ -1,18 +1,20 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const endian = builtin.cpu.arch.endian();
+
+const std = @import("std");
 const shr = std.math.shr;
 const shl = std.math.shl;
 
+const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
+
 const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535
 
 comptime {
-    @export(&__udivei4, .{ .name = "__udivei4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__umodei4, .{ .name = "__umodei4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__udivei4, "__udivei4");
+    symbol(&__umodei4, "__umodei4");
 }
 
-const endian = builtin.cpu.arch.endian();
-
 /// Get the value of a limb.
 inline fn limb(x: []const u32, i: usize) u32 {
     return if (endian == .little) x[i] else x[x.len - 1 - i];
diff --git a/lib/compiler_rt/unorddf2.zig b/lib/compiler_rt/unorddf2.zig
index 5b17343a5168961aa57f61ee3ac3c9279ecd270e..634f14398df9661beaab7cdfe061008d4828bb6a 100644
--- a/lib/compiler_rt/unorddf2.zig
+++ b/lib/compiler_rt/unorddf2.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dcmpun, "__aeabi_dcmpun");
     } else {
-        @export(&__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__unorddf2, "__unorddf2");
     }
 }
 
-- 
2.54.0


From 65c073b1475d38c4b8e004b4dd7624f7e41e3c99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Feb 2026 23:44:35 +0100
Subject: [PATCH 245/499] generate_linux_syscalls: update usage text

---
 tools/generate_linux_syscalls.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/generate_linux_syscalls.zig b/tools/generate_linux_syscalls.zig
index 70d410f806b35999af5950f67cf8faecfb951fa7..403c09d3438f97546120bb40f27eefc8ab58072e 100644
--- a/tools/generate_linux_syscalls.zig
+++ b/tools/generate_linux_syscalls.zig
@@ -250,8 +250,8 @@ pub fn main(init: std.process.Init) !void {
 
 fn usage(w: *std.Io.Writer, arg0: []const u8) std.Io.Writer.Error!void {
     try w.print(
-        \\Usage: {s} /path/to/zig /path/to/linux
-        \\Alternative Usage: zig run /path/to/git/zig/tools/generate_linux_syscalls.zig -- /path/to/zig /path/to/linux
+        \\Usage: {s} /path/to/linux
+        \\Alternative Usage: zig run /path/to/git/zig/tools/generate_linux_syscalls.zig -- /path/to/linux
         \\
         \\Generates the list of Linux syscalls for each supported cpu arch, using the Linux development tree.
         \\Prints to stdout Zig code which you can use to replace the file lib/std/os/linux/syscalls.zig.
-- 
2.54.0


From 81ef502f08e966fb57c4313a9c7e9b6f9f55aa4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Feb 2026 23:54:12 +0100
Subject: [PATCH 246/499] generate_linux_syscalls: add hexagon abi name

---
 tools/generate_linux_syscalls.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/generate_linux_syscalls.zig b/tools/generate_linux_syscalls.zig
index 403c09d3438f97546120bb40f27eefc8ab58072e..707f72988e8c17305a2dce571b7797655020ff1a 100644
--- a/tools/generate_linux_syscalls.zig
+++ b/tools/generate_linux_syscalls.zig
@@ -73,6 +73,7 @@ const Abi = enum {
     nios2,
     or1k,
     riscv,
+    hexagon,
 };
 
 const __X32_SYSCALL_BIT: u32 = 0x40000000;
@@ -161,7 +162,7 @@ const architectures: []const Arch = &.{
     .{ .@"var" = "LoongArch64", .table = .generic, .abi = &.{ .common, .@"64" } },
     .{ .@"var" = "Arc", .table = .generic, .abi = &.{ .common, .@"32", .arc, .time32, .renameat, .stat64, .rlimit } },
     .{ .@"var" = "CSky", .table = .generic, .abi = &.{ .common, .@"32", .csky, .time32, .stat64, .rlimit } },
-    .{ .@"var" = "Hexagon", .table = .generic, .abi = &.{ .common, .@"32", .time32, .stat64, .rlimit, .renameat } },
+    .{ .@"var" = "Hexagon", .table = .generic, .abi = &.{ .common, .@"32", .hexagon, .time32, .stat64, .rlimit, .renameat } },
     .{ .@"var" = "OpenRisc", .table = .generic, .abi = &.{ .common, .@"32", .or1k, .time32, .stat64, .rlimit, .renameat } },
     // .{ .@"var" = "Nios2", .table = .generic, .abi = &.{ .common, .@"32", .nios2, .time32, .stat64, .rlimit, .renameat } },
     // .{ .@"var" = "Parisc", .table = .{ .specific = "arch/parisc/kernel/syscalls/syscall.tbl" }, .abi = &.{ .common, .@"32" } },
-- 
2.54.0


From bc282a6389fce178acba6462cdadd52a1aa1026a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Feb 2026 23:34:48 +0100
Subject: [PATCH 247/499] generate_linux_syscalls: add loongarch32

---
 tools/generate_linux_syscalls.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tools/generate_linux_syscalls.zig b/tools/generate_linux_syscalls.zig
index 707f72988e8c17305a2dce571b7797655020ff1a..de537563127047c338ea71390c717589e9e426f1 100644
--- a/tools/generate_linux_syscalls.zig
+++ b/tools/generate_linux_syscalls.zig
@@ -159,6 +159,7 @@ const architectures: []const Arch = &.{
     .{ .@"var" = "Arm64", .table = .generic, .abi = &.{ .common, .@"64", .renameat, .rlimit, .memfd_secret } },
     .{ .@"var" = "RiscV32", .table = .generic, .abi = &.{ .common, .@"32", .riscv, .memfd_secret } },
     .{ .@"var" = "RiscV64", .table = .generic, .abi = &.{ .common, .@"64", .riscv, .rlimit, .memfd_secret } },
+    .{ .@"var" = "LoongArch32", .table = .generic, .abi = &.{ .common, .@"32" } },
     .{ .@"var" = "LoongArch64", .table = .generic, .abi = &.{ .common, .@"64" } },
     .{ .@"var" = "Arc", .table = .generic, .abi = &.{ .common, .@"32", .arc, .time32, .renameat, .stat64, .rlimit } },
     .{ .@"var" = "CSky", .table = .generic, .abi = &.{ .common, .@"32", .csky, .time32, .stat64, .rlimit } },
-- 
2.54.0


From 80db2e0b8b4168b77e66c83ead3ad028340efb31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Feb 2026 23:45:55 +0100
Subject: [PATCH 248/499] std.os.linux: update syscalls for 6.19

---
 lib/std/os/linux.zig          |   1 +
 lib/std/os/linux/syscalls.zig | 341 +++++++++++++++++++++++++++++++++-
 2 files changed, 341 insertions(+), 1 deletion(-)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index c89585b9ba82c0ae6896a8284b91974bf2ceaeb2..72f39d11899b46775c86026c52dc6b29735ef92b 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -118,6 +118,7 @@ pub const SYS = switch (native_arch) {
     .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
     .csky => syscalls.CSky,
     .hexagon => syscalls.Hexagon,
+    .loongarch32 => syscalls.LoongArch32,
     .loongarch64 => syscalls.LoongArch64,
     .m68k => syscalls.M68k,
     .mips, .mipsel => syscalls.MipsO32,
diff --git a/lib/std/os/linux/syscalls.zig b/lib/std/os/linux/syscalls.zig
index c111f518b6d617d4874f847bc883715b4a7a8344..ee2ebdac26272c7c3e9e07c0d4ae93542269775b 100644
--- a/lib/std/os/linux/syscalls.zig
+++ b/lib/std/os/linux/syscalls.zig
@@ -1,5 +1,5 @@
 // This file is automatically generated by tools/generate_linux_syscalls.zig
-// This list current as of kernel: 6.18.2
+// This list current as of kernel: 6.19.0
 
 pub const X86 = enum(usize) {
     restart_syscall = 0,
@@ -461,6 +461,7 @@ pub const X86 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const X64 = enum(usize) {
@@ -847,6 +848,7 @@ pub const X64 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const X32 = enum(usize) {
@@ -1186,6 +1188,7 @@ pub const X32 = enum(usize) {
     open_tree_attr = 1073742291,
     file_getattr = 1073742292,
     file_setattr = 1073742293,
+    listns = 1073742294,
     rt_sigaction = 1073742336,
     rt_sigreturn = 1073742337,
     ioctl = 1073742338,
@@ -1649,6 +1652,7 @@ pub const Arm = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 
     breakpoint = arm_base + 1,
     cacheflush = arm_base + 2,
@@ -2097,6 +2101,7 @@ pub const Sparc = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const Sparc64 = enum(usize) {
@@ -2501,6 +2506,7 @@ pub const Sparc64 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const M68k = enum(usize) {
@@ -2945,6 +2951,7 @@ pub const M68k = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const MipsO32 = enum(usize) {
@@ -3383,6 +3390,7 @@ pub const MipsO32 = enum(usize) {
     open_tree_attr = 4467,
     file_getattr = 4468,
     file_setattr = 4469,
+    listns = 4470,
 };
 
 pub const MipsN64 = enum(usize) {
@@ -3757,6 +3765,7 @@ pub const MipsN64 = enum(usize) {
     open_tree_attr = 5467,
     file_getattr = 5468,
     file_setattr = 5469,
+    listns = 5470,
 };
 
 pub const MipsN32 = enum(usize) {
@@ -4155,6 +4164,7 @@ pub const MipsN32 = enum(usize) {
     open_tree_attr = 6467,
     file_getattr = 6468,
     file_setattr = 6469,
+    listns = 6470,
 };
 
 pub const PowerPC = enum(usize) {
@@ -4608,6 +4618,7 @@ pub const PowerPC = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const PowerPC64 = enum(usize) {
@@ -5033,6 +5044,7 @@ pub const PowerPC64 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const S390x = enum(usize) {
@@ -5424,6 +5436,7 @@ pub const S390x = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const Xtensa = enum(usize) {
@@ -5819,6 +5832,7 @@ pub const Xtensa = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const Arm64 = enum(usize) {
@@ -6147,6 +6161,7 @@ pub const Arm64 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const RiscV32 = enum(usize) {
@@ -6466,6 +6481,7 @@ pub const RiscV32 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const RiscV64 = enum(usize) {
@@ -6795,6 +6811,324 @@ pub const RiscV64 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
+};
+
+pub const LoongArch32 = enum(usize) {
+    io_setup = 0,
+    io_destroy = 1,
+    io_submit = 2,
+    io_cancel = 3,
+    setxattr = 5,
+    lsetxattr = 6,
+    fsetxattr = 7,
+    getxattr = 8,
+    lgetxattr = 9,
+    fgetxattr = 10,
+    listxattr = 11,
+    llistxattr = 12,
+    flistxattr = 13,
+    removexattr = 14,
+    lremovexattr = 15,
+    fremovexattr = 16,
+    getcwd = 17,
+    lookup_dcookie = 18,
+    eventfd2 = 19,
+    epoll_create1 = 20,
+    epoll_ctl = 21,
+    epoll_pwait = 22,
+    dup = 23,
+    dup3 = 24,
+    fcntl64 = 25,
+    inotify_init1 = 26,
+    inotify_add_watch = 27,
+    inotify_rm_watch = 28,
+    ioctl = 29,
+    ioprio_set = 30,
+    ioprio_get = 31,
+    flock = 32,
+    mknodat = 33,
+    mkdirat = 34,
+    unlinkat = 35,
+    symlinkat = 36,
+    linkat = 37,
+    umount2 = 39,
+    mount = 40,
+    pivot_root = 41,
+    nfsservctl = 42,
+    statfs64 = 43,
+    fstatfs64 = 44,
+    truncate64 = 45,
+    ftruncate64 = 46,
+    fallocate = 47,
+    faccessat = 48,
+    chdir = 49,
+    fchdir = 50,
+    chroot = 51,
+    fchmod = 52,
+    fchmodat = 53,
+    fchownat = 54,
+    fchown = 55,
+    openat = 56,
+    close = 57,
+    vhangup = 58,
+    pipe2 = 59,
+    quotactl = 60,
+    getdents64 = 61,
+    llseek = 62,
+    read = 63,
+    write = 64,
+    readv = 65,
+    writev = 66,
+    pread64 = 67,
+    pwrite64 = 68,
+    preadv = 69,
+    pwritev = 70,
+    sendfile64 = 71,
+    signalfd4 = 74,
+    vmsplice = 75,
+    splice = 76,
+    tee = 77,
+    readlinkat = 78,
+    sync = 81,
+    fsync = 82,
+    fdatasync = 83,
+    sync_file_range = 84,
+    timerfd_create = 85,
+    acct = 89,
+    capget = 90,
+    capset = 91,
+    personality = 92,
+    exit = 93,
+    exit_group = 94,
+    waitid = 95,
+    set_tid_address = 96,
+    unshare = 97,
+    set_robust_list = 99,
+    get_robust_list = 100,
+    getitimer = 102,
+    setitimer = 103,
+    kexec_load = 104,
+    init_module = 105,
+    delete_module = 106,
+    timer_create = 107,
+    timer_getoverrun = 109,
+    timer_delete = 111,
+    syslog = 116,
+    ptrace = 117,
+    sched_setparam = 118,
+    sched_setscheduler = 119,
+    sched_getscheduler = 120,
+    sched_getparam = 121,
+    sched_setaffinity = 122,
+    sched_getaffinity = 123,
+    sched_yield = 124,
+    sched_get_priority_max = 125,
+    sched_get_priority_min = 126,
+    restart_syscall = 128,
+    kill = 129,
+    tkill = 130,
+    tgkill = 131,
+    sigaltstack = 132,
+    rt_sigsuspend = 133,
+    rt_sigaction = 134,
+    rt_sigprocmask = 135,
+    rt_sigpending = 136,
+    rt_sigqueueinfo = 138,
+    rt_sigreturn = 139,
+    setpriority = 140,
+    getpriority = 141,
+    reboot = 142,
+    setregid = 143,
+    setgid = 144,
+    setreuid = 145,
+    setuid = 146,
+    setresuid = 147,
+    getresuid = 148,
+    setresgid = 149,
+    getresgid = 150,
+    setfsuid = 151,
+    setfsgid = 152,
+    times = 153,
+    setpgid = 154,
+    getpgid = 155,
+    getsid = 156,
+    setsid = 157,
+    getgroups = 158,
+    setgroups = 159,
+    uname = 160,
+    sethostname = 161,
+    setdomainname = 162,
+    getrusage = 165,
+    umask = 166,
+    prctl = 167,
+    getcpu = 168,
+    getpid = 172,
+    getppid = 173,
+    getuid = 174,
+    geteuid = 175,
+    getgid = 176,
+    getegid = 177,
+    gettid = 178,
+    sysinfo = 179,
+    mq_open = 180,
+    mq_unlink = 181,
+    mq_notify = 184,
+    mq_getsetattr = 185,
+    msgget = 186,
+    msgctl = 187,
+    msgrcv = 188,
+    msgsnd = 189,
+    semget = 190,
+    semctl = 191,
+    semop = 193,
+    shmget = 194,
+    shmctl = 195,
+    shmat = 196,
+    shmdt = 197,
+    socket = 198,
+    socketpair = 199,
+    bind = 200,
+    listen = 201,
+    accept = 202,
+    connect = 203,
+    getsockname = 204,
+    getpeername = 205,
+    sendto = 206,
+    recvfrom = 207,
+    setsockopt = 208,
+    getsockopt = 209,
+    shutdown = 210,
+    sendmsg = 211,
+    recvmsg = 212,
+    readahead = 213,
+    brk = 214,
+    munmap = 215,
+    mremap = 216,
+    add_key = 217,
+    request_key = 218,
+    keyctl = 219,
+    clone = 220,
+    execve = 221,
+    mmap2 = 222,
+    fadvise64_64 = 223,
+    swapon = 224,
+    swapoff = 225,
+    mprotect = 226,
+    msync = 227,
+    mlock = 228,
+    munlock = 229,
+    mlockall = 230,
+    munlockall = 231,
+    mincore = 232,
+    madvise = 233,
+    remap_file_pages = 234,
+    mbind = 235,
+    get_mempolicy = 236,
+    set_mempolicy = 237,
+    migrate_pages = 238,
+    move_pages = 239,
+    rt_tgsigqueueinfo = 240,
+    perf_event_open = 241,
+    accept4 = 242,
+    prlimit64 = 261,
+    fanotify_init = 262,
+    fanotify_mark = 263,
+    name_to_handle_at = 264,
+    open_by_handle_at = 265,
+    syncfs = 267,
+    setns = 268,
+    sendmmsg = 269,
+    process_vm_readv = 270,
+    process_vm_writev = 271,
+    kcmp = 272,
+    finit_module = 273,
+    sched_setattr = 274,
+    sched_getattr = 275,
+    renameat2 = 276,
+    seccomp = 277,
+    getrandom = 278,
+    memfd_create = 279,
+    bpf = 280,
+    execveat = 281,
+    userfaultfd = 282,
+    membarrier = 283,
+    mlock2 = 284,
+    copy_file_range = 285,
+    preadv2 = 286,
+    pwritev2 = 287,
+    pkey_mprotect = 288,
+    pkey_alloc = 289,
+    pkey_free = 290,
+    statx = 291,
+    rseq = 293,
+    kexec_file_load = 294,
+    clock_gettime64 = 403,
+    clock_settime64 = 404,
+    clock_adjtime64 = 405,
+    clock_getres_time64 = 406,
+    clock_nanosleep_time64 = 407,
+    timer_gettime64 = 408,
+    timer_settime64 = 409,
+    timerfd_gettime64 = 410,
+    timerfd_settime64 = 411,
+    utimensat_time64 = 412,
+    pselect6_time64 = 413,
+    ppoll_time64 = 414,
+    io_pgetevents_time64 = 416,
+    recvmmsg_time64 = 417,
+    mq_timedsend_time64 = 418,
+    mq_timedreceive_time64 = 419,
+    semtimedop_time64 = 420,
+    rt_sigtimedwait_time64 = 421,
+    futex_time64 = 422,
+    sched_rr_get_interval_time64 = 423,
+    pidfd_send_signal = 424,
+    io_uring_setup = 425,
+    io_uring_enter = 426,
+    io_uring_register = 427,
+    open_tree = 428,
+    move_mount = 429,
+    fsopen = 430,
+    fsconfig = 431,
+    fsmount = 432,
+    fspick = 433,
+    pidfd_open = 434,
+    clone3 = 435,
+    close_range = 436,
+    openat2 = 437,
+    pidfd_getfd = 438,
+    faccessat2 = 439,
+    process_madvise = 440,
+    epoll_pwait2 = 441,
+    mount_setattr = 442,
+    quotactl_fd = 443,
+    landlock_create_ruleset = 444,
+    landlock_add_rule = 445,
+    landlock_restrict_self = 446,
+    process_mrelease = 448,
+    futex_waitv = 449,
+    set_mempolicy_home_node = 450,
+    cachestat = 451,
+    fchmodat2 = 452,
+    map_shadow_stack = 453,
+    futex_wake = 454,
+    futex_wait = 455,
+    futex_requeue = 456,
+    statmount = 457,
+    listmount = 458,
+    lsm_get_self_attr = 459,
+    lsm_set_self_attr = 460,
+    lsm_list_modules = 461,
+    mseal = 462,
+    setxattrat = 463,
+    getxattrat = 464,
+    listxattrat = 465,
+    removexattrat = 466,
+    open_tree_attr = 467,
+    file_getattr = 468,
+    file_setattr = 469,
+    listns = 470,
 };
 
 pub const LoongArch64 = enum(usize) {
@@ -7119,6 +7453,7 @@ pub const LoongArch64 = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const Arc = enum(usize) {
@@ -7471,6 +7806,7 @@ pub const Arc = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const CSky = enum(usize) {
@@ -7819,6 +8155,7 @@ pub const CSky = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const Hexagon = enum(usize) {
@@ -8166,6 +8503,7 @@ pub const Hexagon = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
 
 pub const OpenRisc = enum(usize) {
@@ -8514,4 +8852,5 @@ pub const OpenRisc = enum(usize) {
     open_tree_attr = 467,
     file_getattr = 468,
     file_setattr = 469,
+    listns = 470,
 };
-- 
2.54.0


From 7af9882c6d32e5febd1320648131afbb0ced4f55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Feb 2026 23:36:43 +0100
Subject: [PATCH 249/499] libc: update Linux headers to 6.19

---
 .../include/aarch64-linux-any/asm/hwcap.h     |   1 +
 lib/libc/include/aarch64-linux-any/asm/kvm.h  |   2 +-
 .../include/aarch64-linux-any/asm/ptrace.h    |   4 +-
 .../aarch64-linux-any/asm/sigcontext.h        |   4 +-
 .../include/aarch64-linux-any/asm/unistd_64.h |   1 +
 .../any-linux-any/asm-generic/posix_types.h   |   1 +
 .../any-linux-any/asm-generic/unistd.h        |   4 +-
 .../include/any-linux-any/drm/amdgpu_drm.h    | 102 ++-
 .../include/any-linux-any/drm/amdxdna_accel.h | 197 +++++
 lib/libc/include/any-linux-any/drm/drm.h      |  78 +-
 .../include/any-linux-any/drm/drm_fourcc.h    |  23 +-
 lib/libc/include/any-linux-any/drm/drm_mode.h | 192 ++++-
 .../include/any-linux-any/drm/ethosu_accel.h  | 261 ++++++
 .../include/any-linux-any/drm/ivpu_accel.h    |  63 ++
 .../include/any-linux-any/drm/panfrost_drm.h  | 150 +++-
 .../include/any-linux-any/drm/panthor_drm.h   |   3 +
 .../include/any-linux-any/drm/rocket_accel.h  | 142 ++++
 lib/libc/include/any-linux-any/drm/v3d_drm.h  |   2 +
 lib/libc/include/any-linux-any/drm/xe_drm.h   | 304 ++++++-
 lib/libc/include/any-linux-any/linux/acrn.h   |  36 +-
 .../any-linux-any/linux/android/binder.h      |   2 +-
 .../linux/android/binder_netlink.h            |  38 +
 .../any-linux-any/linux/aspeed-video.h        |   7 +
 lib/libc/include/any-linux-any/linux/audit.h  |   2 +
 .../any-linux-any/linux/blktrace_api.h        |  55 +-
 .../include/any-linux-any/linux/blkzoned.h    |  48 +-
 lib/libc/include/any-linux-any/linux/bpf.h    |  59 +-
 lib/libc/include/any-linux-any/linux/btrfs.h  |   9 +
 .../include/any-linux-any/linux/can/netlink.h |  48 +-
 lib/libc/include/any-linux-any/linux/comedi.h |   2 +-
 .../any-linux-any/linux/dev_energymodel.h     |  82 ++
 .../include/any-linux-any/linux/devlink.h     |   6 +
 lib/libc/include/any-linux-any/linux/dpll.h   |   3 +
 .../include/any-linux-any/linux/ethtool.h     |   6 +
 .../linux/ethtool_netlink_generated.h         |  48 ++
 lib/libc/include/any-linux-any/linux/ext4.h   |  53 ++
 lib/libc/include/any-linux-any/linux/fb.h     |   2 +-
 lib/libc/include/any-linux-any/linux/fcntl.h  |  13 +
 lib/libc/include/any-linux-any/linux/fou.h    |   1 +
 lib/libc/include/any-linux-any/linux/fs.h     |   8 +-
 lib/libc/include/any-linux-any/linux/fuse.h   |  22 +-
 lib/libc/include/any-linux-any/linux/gpib.h   | 103 +++
 .../include/any-linux-any/linux/gpib_ioctl.h  | 167 ++++
 .../include/any-linux-any/linux/handshake.h   |   1 +
 lib/libc/include/any-linux-any/linux/hidraw.h |   2 +
 lib/libc/include/any-linux-any/linux/i2c.h    |   2 +-
 lib/libc/include/any-linux-any/linux/i8k.h    |   2 +
 .../include/any-linux-any/linux/if_bridge.h   |   3 +
 .../include/any-linux-any/linux/if_ether.h    |   4 +
 .../include/any-linux-any/linux/if_link.h     |   3 +
 .../include/any-linux-any/linux/if_team.h     |   1 +
 .../include/any-linux-any/linux/iio/types.h   |   5 +
 .../any-linux-any/linux/input-event-codes.h   |  22 +
 lib/libc/include/any-linux-any/linux/input.h  |  22 +-
 .../include/any-linux-any/linux/io_uring.h    |  71 +-
 .../any-linux-any/linux/io_uring/query.h      |  68 ++
 .../include/any-linux-any/linux/iommufd.h     |  10 +
 .../include/any-linux-any/linux/isst_if.h     |  50 +-
 lib/libc/include/any-linux-any/linux/ivtv.h   |   2 +-
 lib/libc/include/any-linux-any/linux/kexec.h  |   4 +
 .../include/any-linux-any/linux/kfd_ioctl.h   |   4 +-
 lib/libc/include/any-linux-any/linux/kvm.h    |  14 +
 .../include/any-linux-any/linux/landlock.h    |  37 +-
 .../include/any-linux-any/linux/liveupdate.h  | 216 +++++
 .../any-linux-any/linux/lockd_netlink.h       |   1 +
 lib/libc/include/any-linux-any/linux/magic.h  |   1 +
 .../any-linux-any/linux/map_benchmark.h       |  35 +
 lib/libc/include/any-linux-any/linux/mdio.h   |  23 +-
 .../any-linux-any/linux/media-bus-format.h    |   9 +-
 .../linux/media/amlogic/c3-isp-config.h       |  84 +-
 .../linux/media/arm/mali-c55-config.h         | 785 ++++++++++++++++++
 .../any-linux-any/linux/media/v4l2-isp.h      | 102 +++
 .../include/any-linux-any/linux/mempolicy.h   |  12 +-
 lib/libc/include/any-linux-any/linux/mount.h  |   2 +-
 lib/libc/include/any-linux-any/linux/mptcp.h  |  24 +-
 .../include/any-linux-any/linux/mptcp_pm.h    |   5 +-
 lib/libc/include/any-linux-any/linux/mshv.h   | 116 ++-
 .../include/any-linux-any/linux/net_shaper.h  |   1 +
 lib/libc/include/any-linux-any/linux/netdev.h |   2 +
 .../any-linux-any/linux/netfilter/nf_tables.h |  16 +-
 .../linux/netfilter_ipv6/ip6t_srh.h           |  40 +-
 lib/libc/include/any-linux-any/linux/nfs.h    |   1 -
 .../any-linux-any/linux/nfsd_netlink.h        |   1 +
 .../any-linux-any/linux/nl80211-vnd-intel.h   |   1 -
 .../include/any-linux-any/linux/nl80211.h     | 260 +++++-
 lib/libc/include/any-linux-any/linux/nsfs.h   |  70 +-
 lib/libc/include/any-linux-any/linux/ovpn.h   |   1 +
 .../include/any-linux-any/linux/pci_regs.h    |  99 +++
 .../include/any-linux-any/linux/perf_event.h  |  25 +-
 lib/libc/include/any-linux-any/linux/pidfd.h  |  11 +-
 lib/libc/include/any-linux-any/linux/pr.h     |  16 +
 lib/libc/include/any-linux-any/linux/prctl.h  |  10 +
 .../include/any-linux-any/linux/psp-sev.h     |  76 +-
 .../include/any-linux-any/linux/psp-sfs.h     |  87 ++
 lib/libc/include/any-linux-any/linux/psp.h    |  85 ++
 .../include/any-linux-any/linux/ptp_clock.h   |   4 +
 .../include/any-linux-any/linux/raid/md_p.h   |   3 +-
 .../any-linux-any/linux/rkisp1-config.h       |  98 +--
 lib/libc/include/any-linux-any/linux/rseq.h   |  21 +-
 lib/libc/include/any-linux-any/linux/stddef.h |   1 -
 lib/libc/include/any-linux-any/linux/tcp.h    |   9 +
 lib/libc/include/any-linux-any/linux/tee.h    | 108 ++-
 lib/libc/include/any-linux-any/linux/tls.h    |   2 +
 .../include/any-linux-any/linux/usb/cdc.h     |  12 +-
 .../any-linux-any/linux/v4l2-controls.h       | 127 +--
 .../any-linux-any/linux/v4l2-dv-timings.h     |   2 +-
 .../include/any-linux-any/linux/version.h     |   4 +-
 lib/libc/include/any-linux-any/linux/vfio.h   |  28 +
 .../include/any-linux-any/linux/videodev2.h   |  24 +-
 .../include/any-linux-any/linux/virtio_ids.h  |   1 +
 .../include/any-linux-any/linux/virtio_net.h  |   3 +-
 .../include/any-linux-any/linux/virtio_pci.h  |   2 +-
 .../include/any-linux-any/linux/virtio_spi.h  | 181 ++++
 lib/libc/include/any-linux-any/linux/vmcore.h |   9 +
 .../include/any-linux-any/linux/wireguard.h   | 193 +----
 lib/libc/include/any-linux-any/misc/fastrpc.h |   2 +-
 .../any-linux-any/misc/uacce/hisi_qm.h        |   1 +
 .../any-linux-any/rdma/ib_user_ioctl_verbs.h  |   1 +
 .../include/any-linux-any/rdma/ib_user_sa.h   |  14 +
 .../include/any-linux-any/rdma/ionic-abi.h    | 115 +++
 .../include/any-linux-any/rdma/irdma-abi.h    |  16 +-
 .../include/any-linux-any/rdma/rdma_user_cm.h |  44 +-
 .../any-linux-any/regulator/regulator.h       |   4 +-
 .../include/any-linux-any/scsi/fc/fc_els.h    |  54 +-
 lib/libc/include/any-linux-any/sound/asound.h |   2 +-
 .../any-linux-any/sound/compress_offload.h    |  35 +-
 .../any-linux-any/sound/compress_params.h     |  41 +-
 .../any-linux-any/sound/intel/avs/tokens.h    |  21 +
 .../any-linux-any/sound/snd_ar_tokens.h       |  20 +-
 .../include/any-linux-any/sound/sof/tokens.h  |   2 +
 .../include/arc-linux-any/asm/unistd_32.h     |   1 +
 .../include/arm-linux-any/asm/unistd-eabi.h   |   1 +
 .../include/arm-linux-any/asm/unistd-oabi.h   |   1 +
 lib/libc/include/csky-linux-any/asm/ptrace.h  |   4 +-
 .../include/csky-linux-any/asm/unistd_32.h    |   1 +
 .../include/hexagon-linux-any/asm/unistd_32.h |   1 +
 .../include/loongarch-linux-any/asm/kvm.h     |   2 +
 .../include/loongarch-linux-any/asm/ptrace.h  |  48 +-
 .../include/loongarch-linux-any/asm/unistd.h  |   8 +-
 .../loongarch-linux-any/asm/unistd_32.h       | 320 +++++++
 .../loongarch-linux-any/asm/unistd_64.h       |   1 +
 .../include/m68k-linux-any/asm/unistd_32.h    |   1 +
 .../include/mips-linux-any/asm/unistd_n32.h   |   1 +
 .../include/mips-linux-any/asm/unistd_n64.h   |   1 +
 .../include/mips-linux-any/asm/unistd_o32.h   |   1 +
 .../include/powerpc-linux-any/asm/opal-prd.h  |   4 +-
 .../powerpc-linux-any/asm/papr-hvpipe.h       |  33 +
 .../include/powerpc-linux-any/asm/ptrace.h    |  12 +-
 .../include/powerpc-linux-any/asm/types.h     |   4 +-
 .../include/powerpc-linux-any/asm/unistd_32.h |   1 +
 .../include/powerpc-linux-any/asm/unistd_64.h |   1 +
 .../include/riscv-linux-any/asm/hwprobe.h     |   7 +
 lib/libc/include/riscv-linux-any/asm/kvm.h    |  26 +-
 lib/libc/include/riscv-linux-any/asm/ptrace.h |   4 +-
 .../include/riscv-linux-any/asm/sigcontext.h  |   4 +-
 .../include/riscv-linux-any/asm/unistd_32.h   |   1 +
 .../include/riscv-linux-any/asm/unistd_64.h   |   1 +
 .../include/riscv-linux-any/asm/vendor/mips.h |   3 +
 .../include/s390x-linux-any/asm/bitsperlong.h |   4 -
 lib/libc/include/s390x-linux-any/asm/ipcbuf.h |   3 -
 lib/libc/include/s390x-linux-any/asm/ipl.h    |   1 +
 .../include/s390x-linux-any/asm/posix_types.h |  13 -
 lib/libc/include/s390x-linux-any/asm/ptrace.h | 124 ---
 .../include/s390x-linux-any/asm/sigcontext.h  |  15 -
 lib/libc/include/s390x-linux-any/asm/stat.h   |  70 --
 lib/libc/include/s390x-linux-any/asm/unistd.h |   4 -
 .../include/s390x-linux-any/asm/unistd_32.h   | 446 ----------
 .../include/s390x-linux-any/asm/unistd_64.h   |   9 +-
 lib/libc/include/sparc-linux-any/asm/ptrace.h |  24 +-
 lib/libc/include/sparc-linux-any/asm/signal.h |   4 +-
 lib/libc/include/sparc-linux-any/asm/traps.h  |   4 +-
 .../include/sparc-linux-any/asm/unistd_32.h   |   1 +
 .../include/sparc-linux-any/asm/unistd_64.h   |   1 +
 lib/libc/include/sparc-linux-any/asm/utrap.h  |   4 +-
 lib/libc/include/x86-linux-any/asm/kvm.h      |  35 +
 .../x86-linux-any/asm/processor-flags.h       |   2 +
 lib/libc/include/x86-linux-any/asm/sgx.h      |  10 +-
 lib/libc/include/x86-linux-any/asm/svm.h      |   4 +
 .../include/x86-linux-any/asm/unistd_32.h     |   1 +
 .../include/x86-linux-any/asm/unistd_64.h     |   2 +
 .../include/x86-linux-any/asm/unistd_x32.h    |   2 +
 lib/libc/include/x86-linux-any/asm/vmx.h      |   7 +-
 .../include/xtensa-linux-any/asm/unistd_32.h  |   1 +
 183 files changed, 5922 insertions(+), 1464 deletions(-)
 create mode 100644 lib/libc/include/any-linux-any/drm/ethosu_accel.h
 create mode 100644 lib/libc/include/any-linux-any/drm/rocket_accel.h
 create mode 100644 lib/libc/include/any-linux-any/linux/android/binder_netlink.h
 create mode 100644 lib/libc/include/any-linux-any/linux/dev_energymodel.h
 create mode 100644 lib/libc/include/any-linux-any/linux/gpib.h
 create mode 100644 lib/libc/include/any-linux-any/linux/gpib_ioctl.h
 create mode 100644 lib/libc/include/any-linux-any/linux/io_uring/query.h
 create mode 100644 lib/libc/include/any-linux-any/linux/liveupdate.h
 create mode 100644 lib/libc/include/any-linux-any/linux/map_benchmark.h
 create mode 100644 lib/libc/include/any-linux-any/linux/media/arm/mali-c55-config.h
 create mode 100644 lib/libc/include/any-linux-any/linux/media/v4l2-isp.h
 create mode 100644 lib/libc/include/any-linux-any/linux/psp-sfs.h
 create mode 100644 lib/libc/include/any-linux-any/linux/psp.h
 create mode 100644 lib/libc/include/any-linux-any/linux/virtio_spi.h
 create mode 100644 lib/libc/include/any-linux-any/rdma/ionic-abi.h
 create mode 100644 lib/libc/include/loongarch-linux-any/asm/unistd_32.h
 create mode 100644 lib/libc/include/powerpc-linux-any/asm/papr-hvpipe.h
 create mode 100644 lib/libc/include/riscv-linux-any/asm/vendor/mips.h
 delete mode 100644 lib/libc/include/s390x-linux-any/asm/unistd_32.h

diff --git a/lib/libc/include/aarch64-linux-any/asm/hwcap.h b/lib/libc/include/aarch64-linux-any/asm/hwcap.h
index 9dc9726add5814facc6a9fe1eb433557ece374be..e484bcc59adffc094c3dbf06b5112871662ee5a0 100644
--- a/lib/libc/include/aarch64-linux-any/asm/hwcap.h
+++ b/lib/libc/include/aarch64-linux-any/asm/hwcap.h
@@ -145,5 +145,6 @@
  */
 #define HWCAP3_MTE_FAR		(1UL << 0)
 #define HWCAP3_MTE_STORE_ONLY		(1UL << 1)
+#define HWCAP3_LSFE		(1UL << 2)
 
 #endif /* __ASM_HWCAP_H */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-linux-any/asm/kvm.h b/lib/libc/include/aarch64-linux-any/asm/kvm.h
index 1950d28cb3f6b9151194b774c5e164fc380e3cb8..8b5e526846d26113ae86a97811cc1b335f8cb86e 100644
--- a/lib/libc/include/aarch64-linux-any/asm/kvm.h
+++ b/lib/libc/include/aarch64-linux-any/asm/kvm.h
@@ -31,7 +31,7 @@
 #define KVM_SPSR_FIQ	4
 #define KVM_NR_SPSR	5
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 #include <linux/psci.h>
 #include <linux/types.h>
 #include <asm/ptrace.h>
diff --git a/lib/libc/include/aarch64-linux-any/asm/ptrace.h b/lib/libc/include/aarch64-linux-any/asm/ptrace.h
index ebe77241748798120544adcc97bd59acb12d867d..b5f9c5843302cf648d16bd3f726da30a6aca0849 100644
--- a/lib/libc/include/aarch64-linux-any/asm/ptrace.h
+++ b/lib/libc/include/aarch64-linux-any/asm/ptrace.h
@@ -80,7 +80,7 @@
 #define PTRACE_PEEKMTETAGS	  33
 #define PTRACE_POKEMTETAGS	  34
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 /*
  * User structures for general purpose, floating point and debug registers.
@@ -332,6 +332,6 @@ struct user_gcs {
 	__u64 gcspr_el0;
 };
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 #endif /* __ASM_PTRACE_H */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-linux-any/asm/sigcontext.h b/lib/libc/include/aarch64-linux-any/asm/sigcontext.h
index b84cf3a202928d6173bf87a01f89afed8aa0e98d..0543ba5e05a00140e5f35f3fdcf269d18eb71f2a 100644
--- a/lib/libc/include/aarch64-linux-any/asm/sigcontext.h
+++ b/lib/libc/include/aarch64-linux-any/asm/sigcontext.h
@@ -17,7 +17,7 @@
 #ifndef __ASM_SIGCONTEXT_H
 #define __ASM_SIGCONTEXT_H
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 #include <linux/types.h>
 
@@ -192,7 +192,7 @@ struct gcs_context {
 	__u64 reserved;
 };
 
-#endif /* !__ASSEMBLY__ */
+#endif /* !__ASSEMBLER__ */
 
 #include <asm/sve_context.h>
 
diff --git a/lib/libc/include/aarch64-linux-any/asm/unistd_64.h b/lib/libc/include/aarch64-linux-any/asm/unistd_64.h
index 892b50dc5255dd430120390d2381a229620dd1fc..6f36afa697aa947891906bc645e8042581e63f07 100644
--- a/lib/libc/include/aarch64-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/aarch64-linux-any/asm/unistd_64.h
@@ -326,6 +326,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/asm-generic/posix_types.h b/lib/libc/include/any-linux-any/asm-generic/posix_types.h
index 99fb554755b615647c0b42f7f3460f13c9a4fbba..8877dce186f7064254ca9218345f3447478349c6 100644
--- a/lib/libc/include/any-linux-any/asm-generic/posix_types.h
+++ b/lib/libc/include/any-linux-any/asm-generic/posix_types.h
@@ -86,6 +86,7 @@ typedef struct {
  */
 typedef __kernel_long_t	__kernel_off_t;
 typedef long long	__kernel_loff_t;
+typedef unsigned long long	__kernel_uoff_t;
 typedef __kernel_long_t	__kernel_old_time_t;
 typedef __kernel_long_t	__kernel_time_t;
 typedef long long __kernel_time64_t;
diff --git a/lib/libc/include/any-linux-any/asm-generic/unistd.h b/lib/libc/include/any-linux-any/asm-generic/unistd.h
index 810329deff0102463c74b493112dbee2fa90c696..50b15f7713f6c24cd6d9393f86ac46fa9831dd33 100644
--- a/lib/libc/include/any-linux-any/asm-generic/unistd.h
+++ b/lib/libc/include/any-linux-any/asm-generic/unistd.h
@@ -857,9 +857,11 @@ __SYSCALL(__NR_open_tree_attr, sys_open_tree_attr)
 __SYSCALL(__NR_file_getattr, sys_file_getattr)
 #define __NR_file_setattr 469
 __SYSCALL(__NR_file_setattr, sys_file_setattr)
+#define __NR_listns 470
+__SYSCALL(__NR_listns, sys_listns)
 
 #undef __NR_syscalls
-#define __NR_syscalls 470
+#define __NR_syscalls 471
 
 /*
  * 32 bit systems traditionally used different
diff --git a/lib/libc/include/any-linux-any/drm/amdgpu_drm.h b/lib/libc/include/any-linux-any/drm/amdgpu_drm.h
index e54dab061a8644250fbfa07cde8a0efc84032c96..a46b28cafad913d50673edc6b364aa933528cd87 100644
--- a/lib/libc/include/any-linux-any/drm/amdgpu_drm.h
+++ b/lib/libc/include/any-linux-any/drm/amdgpu_drm.h
@@ -57,6 +57,7 @@ extern "C" {
 #define DRM_AMDGPU_USERQ		0x16
 #define DRM_AMDGPU_USERQ_SIGNAL		0x17
 #define DRM_AMDGPU_USERQ_WAIT		0x18
+#define DRM_AMDGPU_GEM_LIST_HANDLES	0x19
 
 #define DRM_IOCTL_AMDGPU_GEM_CREATE	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_CREATE, union drm_amdgpu_gem_create)
 #define DRM_IOCTL_AMDGPU_GEM_MMAP	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_MMAP, union drm_amdgpu_gem_mmap)
@@ -77,6 +78,7 @@ extern "C" {
 #define DRM_IOCTL_AMDGPU_USERQ		DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_USERQ, union drm_amdgpu_userq)
 #define DRM_IOCTL_AMDGPU_USERQ_SIGNAL	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_USERQ_SIGNAL, struct drm_amdgpu_userq_signal)
 #define DRM_IOCTL_AMDGPU_USERQ_WAIT	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_USERQ_WAIT, struct drm_amdgpu_userq_wait)
+#define DRM_IOCTL_AMDGPU_GEM_LIST_HANDLES DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_LIST_HANDLES, struct drm_amdgpu_gem_list_handles)
 
 /**
  * DOC: memory domains
@@ -103,6 +105,8 @@ extern "C" {
  *
  * %AMDGPU_GEM_DOMAIN_DOORBELL	Doorbell. It is an MMIO region for
  * signalling user mode queues.
+ *
+ * %AMDGPU_GEM_DOMAIN_MMIO_REMAP	MMIO remap page (special mapping for HDP flushing).
  */
 #define AMDGPU_GEM_DOMAIN_CPU		0x1
 #define AMDGPU_GEM_DOMAIN_GTT		0x2
@@ -111,13 +115,15 @@ extern "C" {
 #define AMDGPU_GEM_DOMAIN_GWS		0x10
 #define AMDGPU_GEM_DOMAIN_OA		0x20
 #define AMDGPU_GEM_DOMAIN_DOORBELL	0x40
+#define AMDGPU_GEM_DOMAIN_MMIO_REMAP	0x80
 #define AMDGPU_GEM_DOMAIN_MASK		(AMDGPU_GEM_DOMAIN_CPU | \
 					 AMDGPU_GEM_DOMAIN_GTT | \
 					 AMDGPU_GEM_DOMAIN_VRAM | \
 					 AMDGPU_GEM_DOMAIN_GDS | \
 					 AMDGPU_GEM_DOMAIN_GWS | \
-					 AMDGPU_GEM_DOMAIN_OA | \
-					 AMDGPU_GEM_DOMAIN_DOORBELL)
+					 AMDGPU_GEM_DOMAIN_OA |	\
+					 AMDGPU_GEM_DOMAIN_DOORBELL | \
+					 AMDGPU_GEM_DOMAIN_MMIO_REMAP)
 
 /* Flag that CPU access will be required for the case of VRAM domain */
 #define AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED	(1 << 0)
@@ -800,6 +806,21 @@ union drm_amdgpu_wait_fences {
 
 #define AMDGPU_GEM_OP_GET_GEM_CREATE_INFO	0
 #define AMDGPU_GEM_OP_SET_PLACEMENT		1
+#define AMDGPU_GEM_OP_GET_MAPPING_INFO		2
+
+struct drm_amdgpu_gem_vm_entry {
+	/* Start of mapping (in bytes) */
+	__u64 addr;
+
+	/* Size of mapping (in bytes) */
+	__u64 size;
+
+	/* Mapping offset */
+	__u64 offset;
+
+	/* flags needed to recreate mapping */
+	__u64 flags;
+};
 
 /* Sets or returns a value associated with a buffer. */
 struct drm_amdgpu_gem_op {
@@ -807,8 +828,44 @@ struct drm_amdgpu_gem_op {
 	__u32	handle;
 	/** AMDGPU_GEM_OP_* */
 	__u32	op;
-	/** Input or return value */
+	/** Input or return value. For MAPPING_INFO op: pointer to array of struct drm_amdgpu_gem_vm_entry */
 	__u64	value;
+	/** For MAPPING_INFO op: number of mappings (in/out) */
+	__u32	num_entries;
+
+	__u32	padding;
+};
+
+#define AMDGPU_GEM_LIST_HANDLES_FLAG_IS_IMPORT	(1 << 0)
+
+struct drm_amdgpu_gem_list_handles {
+	/* User pointer to array of drm_amdgpu_gem_bo_info_entry */
+	__u64   entries;
+
+	/* Size of entries buffer / Number of handles in process (if larger than size of buffer, must retry) */
+	__u32   num_entries;
+
+	__u32 padding;
+};
+
+struct drm_amdgpu_gem_list_handles_entry {
+	/* gem handle of buffer object */
+	__u32 gem_handle;
+
+	/* Currently just one flag: IS_IMPORT */
+	__u32 flags;
+
+	/* Size of bo */
+	__u64 size;
+
+	/* Preferred domains for GEM_CREATE */
+	__u64 preferred_domains;
+
+	/* GEM_CREATE flags for re-creation of buffer */
+	__u64 alloc_flags;
+
+	/* physical start_addr alignment in bytes for some HW requirements */
+	__u64 alignment;
 };
 
 #define AMDGPU_VA_OP_MAP			1
@@ -1031,10 +1088,11 @@ struct drm_amdgpu_cs_chunk_cp_gfx_shadow {
  *  Query h/w info: Flag that this is integrated (a.h.a. fusion) GPU
  *
  */
-#define AMDGPU_IDS_FLAGS_FUSION         0x1
-#define AMDGPU_IDS_FLAGS_PREEMPTION     0x2
-#define AMDGPU_IDS_FLAGS_TMZ            0x4
-#define AMDGPU_IDS_FLAGS_CONFORMANT_TRUNC_COORD 0x8
+#define AMDGPU_IDS_FLAGS_FUSION			0x01
+#define AMDGPU_IDS_FLAGS_PREEMPTION		0x02
+#define AMDGPU_IDS_FLAGS_TMZ			0x04
+#define AMDGPU_IDS_FLAGS_CONFORMANT_TRUNC_COORD	0x08
+#define AMDGPU_IDS_FLAGS_GANG_SUBMIT		0x10
 
 /*
  *  Query h/w info: Flag identifying VF/PF/PT mode
@@ -1497,27 +1555,6 @@ struct drm_amdgpu_info_hw_ip {
 	__u32  userq_num_slots;
 };
 
-/* GFX metadata BO sizes and alignment info (in bytes) */
-struct drm_amdgpu_info_uq_fw_areas_gfx {
-	/* shadow area size */
-	__u32 shadow_size;
-	/* shadow area base virtual mem alignment */
-	__u32 shadow_alignment;
-	/* context save area size */
-	__u32 csa_size;
-	/* context save area base virtual mem alignment */
-	__u32 csa_alignment;
-};
-
-/* IP specific fw related information used in the
- * subquery AMDGPU_INFO_UQ_FW_AREAS
- */
-struct drm_amdgpu_info_uq_fw_areas {
-	union {
-		struct drm_amdgpu_info_uq_fw_areas_gfx gfx;
-	};
-};
-
 struct drm_amdgpu_info_num_handles {
 	/** Max handles as supported by firmware for UVD */
 	__u32  uvd_max_handles;
@@ -1619,15 +1656,6 @@ struct drm_amdgpu_info_uq_metadata {
 #define AMDGPU_FAMILY_GC_11_5_0			150 /* GC 11.5.0 */
 #define AMDGPU_FAMILY_GC_12_0_0			152 /* GC 12.0.0 */
 
-/* FIXME wrong namespace! */
-struct drm_color_ctm_3x4 {
-	/*
-	 * Conversion matrix with 3x4 dimensions in S31.32 sign-magnitude
-	 * (not two's complement!) format.
-	 */
-	__u64 matrix[12];
-};
-
 #if defined(__cplusplus)
 }
 #endif
diff --git a/lib/libc/include/any-linux-any/drm/amdxdna_accel.h b/lib/libc/include/any-linux-any/drm/amdxdna_accel.h
index 9968df0ef879204eb8137e374c9404ba5ffdebd3..745a4e352061317490de097ef9bed9ba3b2ea3c1 100644
--- a/lib/libc/include/any-linux-any/drm/amdxdna_accel.h
+++ b/lib/libc/include/any-linux-any/drm/amdxdna_accel.h
@@ -34,6 +34,7 @@ enum amdxdna_drm_ioctl_id {
 	DRM_AMDXDNA_EXEC_CMD,
 	DRM_AMDXDNA_GET_INFO,
 	DRM_AMDXDNA_SET_STATE,
+	DRM_AMDXDNA_GET_ARRAY = 10,
 };
 
 /**
@@ -153,6 +154,31 @@ enum amdxdna_bo_type {
 	AMDXDNA_BO_CMD,
 };
 
+/**
+ * struct amdxdna_drm_va_entry
+ * @vaddr: Virtual address.
+ * @len: Size of entry.
+ */
+struct amdxdna_drm_va_entry {
+	__u64 vaddr;
+	__u64 len;
+};
+
+/**
+ * struct amdxdna_drm_va_tbl
+ * @dmabuf_fd: The fd of dmabuf.
+ * @num_entries: Number of va entries.
+ * @va_entries: Array of va entries.
+ *
+ * The input can be either a dmabuf fd or a virtual address entry table.
+ * When dmabuf_fd is used, num_entries must be zero.
+ */
+struct amdxdna_drm_va_tbl {
+	__s32 dmabuf_fd;
+	__u32 num_entries;
+	struct amdxdna_drm_va_entry va_entries[];
+};
+
 /**
  * struct amdxdna_drm_create_bo - Create a buffer object.
  * @flags: Buffer flags. MBZ.
@@ -416,6 +442,52 @@ enum amdxdna_drm_get_param {
 	DRM_AMDXDNA_QUERY_HW_CONTEXTS,
 	DRM_AMDXDNA_QUERY_FIRMWARE_VERSION = 8,
 	DRM_AMDXDNA_GET_POWER_MODE,
+	DRM_AMDXDNA_QUERY_TELEMETRY,
+	DRM_AMDXDNA_GET_FORCE_PREEMPT_STATE,
+	DRM_AMDXDNA_QUERY_RESOURCE_INFO,
+	DRM_AMDXDNA_GET_FRAME_BOUNDARY_PREEMPT_STATE,
+};
+
+/**
+ * struct amdxdna_drm_get_resource_info - Get resource information
+ */
+struct amdxdna_drm_get_resource_info {
+	/** @npu_clk_max: max H-Clocks */
+	__u64 npu_clk_max;
+	/** @npu_tops_max: max TOPs */
+	__u64 npu_tops_max;
+	/** @npu_task_max: max number of tasks */
+	__u64 npu_task_max;
+	/** @npu_tops_curr: current TOPs */
+	__u64 npu_tops_curr;
+	/** @npu_task_curr: current number of tasks */
+	__u64 npu_task_curr;
+};
+
+/**
+ * struct amdxdna_drm_attribute_state - State of an attribute
+ */
+struct amdxdna_drm_attribute_state {
+	/** @state: enabled or disabled */
+	__u8 state;
+	/** @pad: MBZ */
+	__u8 pad[7];
+};
+
+/**
+ * struct amdxdna_drm_query_telemetry_header - Telemetry data header
+ */
+struct amdxdna_drm_query_telemetry_header {
+	/** @major: Firmware telemetry interface major version number */
+	__u32 major;
+	/** @minor: Firmware telemetry interface minor version number */
+	__u32 minor;
+	/** @type: Telemetry query type */
+	__u32 type;
+	/** @map_num_elements: Total number of elements in the map table */
+	__u32 map_num_elements;
+	/** @map: Element map */
+	__u32 map[];
 };
 
 /**
@@ -430,10 +502,131 @@ struct amdxdna_drm_get_info {
 	__u64 buffer; /* in/out */
 };
 
+#define AMDXDNA_HWCTX_STATE_IDLE	0
+#define AMDXDNA_HWCTX_STATE_ACTIVE	1
+
+/**
+ * struct amdxdna_drm_hwctx_entry - The hardware context array entry
+ */
+struct amdxdna_drm_hwctx_entry {
+	/** @context_id: Context ID. */
+	__u32 context_id;
+	/** @start_col: Start AIE array column assigned to context. */
+	__u32 start_col;
+	/** @num_col: Number of AIE array columns assigned to context. */
+	__u32 num_col;
+	/** @hwctx_id: The real hardware context id. */
+	__u32 hwctx_id;
+	/** @pid: ID of process which created this context. */
+	__s64 pid;
+	/** @command_submissions: Number of commands submitted. */
+	__u64 command_submissions;
+	/** @command_completions: Number of commands completed. */
+	__u64 command_completions;
+	/** @migrations: Number of times been migrated. */
+	__u64 migrations;
+	/** @preemptions: Number of times been preempted. */
+	__u64 preemptions;
+	/** @errors: Number of errors happened. */
+	__u64 errors;
+	/** @priority: Context priority. */
+	__u64 priority;
+	/** @heap_usage: Usage of device heap buffer. */
+	__u64 heap_usage;
+	/** @suspensions: Number of times been suspended. */
+	__u64 suspensions;
+	/**
+	 * @state: Context state.
+	 * %AMDXDNA_HWCTX_STATE_IDLE
+	 * %AMDXDNA_HWCTX_STATE_ACTIVE
+	 */
+	__u32 state;
+	/** @pasid: PASID been bound. */
+	__u32 pasid;
+	/** @gops: Giga operations per second. */
+	__u32 gops;
+	/** @fps: Frames per second. */
+	__u32 fps;
+	/** @dma_bandwidth: DMA bandwidth. */
+	__u32 dma_bandwidth;
+	/** @latency: Frame response latency. */
+	__u32 latency;
+	/** @frame_exec_time: Frame execution time. */
+	__u32 frame_exec_time;
+	/** @txn_op_idx: Index of last control code executed. */
+	__u32 txn_op_idx;
+	/** @ctx_pc: Program counter. */
+	__u32 ctx_pc;
+	/** @fatal_error_type: Fatal error type if context crashes. */
+	__u32 fatal_error_type;
+	/** @fatal_error_exception_type: Firmware exception type. */
+	__u32 fatal_error_exception_type;
+	/** @fatal_error_exception_pc: Firmware exception program counter. */
+	__u32 fatal_error_exception_pc;
+	/** @fatal_error_app_module: Exception module name. */
+	__u32 fatal_error_app_module;
+	/** @pad: Structure pad. */
+	__u32 pad;
+};
+
+/**
+ * struct amdxdna_async_error - XDNA async error structure
+ */
+struct amdxdna_async_error {
+	/** @err_code: Error code. */
+	__u64 err_code;
+	/** @ts_us: Timestamp. */
+	__u64 ts_us;
+	/** @ex_err_code: Extra error code */
+	__u64 ex_err_code;
+};
+
+#define DRM_AMDXDNA_HW_CONTEXT_ALL	0
+#define DRM_AMDXDNA_HW_LAST_ASYNC_ERR	2
+
+/**
+ * struct amdxdna_drm_get_array - Get information array.
+ */
+struct amdxdna_drm_get_array {
+	/**
+	 * @param:
+	 *
+	 * Supported params:
+	 *
+	 * %DRM_AMDXDNA_HW_CONTEXT_ALL:
+	 * Returns all created hardware contexts.
+	 */
+	__u32 param;
+	/**
+	 * @element_size:
+	 *
+	 * Specifies maximum element size and returns the actual element size.
+	 */
+	__u32 element_size;
+	/**
+	 * @num_element:
+	 *
+	 * Specifies maximum number of elements and returns the actual number
+	 * of elements.
+	 */
+	__u32 num_element; /* in/out */
+	/** @pad: MBZ */
+	__u32 pad;
+	/**
+	 * @buffer:
+	 *
+	 * Specifies the match conditions and returns the matched information
+	 * array.
+	 */
+	__u64 buffer;
+};
+
 enum amdxdna_drm_set_param {
 	DRM_AMDXDNA_SET_POWER_MODE,
 	DRM_AMDXDNA_WRITE_AIE_MEM,
 	DRM_AMDXDNA_WRITE_AIE_REG,
+	DRM_AMDXDNA_SET_FORCE_PREEMPT,
+	DRM_AMDXDNA_SET_FRAME_BOUNDARY_PREEMPT,
 };
 
 /**
@@ -494,6 +687,10 @@ struct amdxdna_drm_set_power_mode {
 	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDXDNA_SET_STATE, \
 		 struct amdxdna_drm_set_state)
 
+#define DRM_IOCTL_AMDXDNA_GET_ARRAY \
+	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDXDNA_GET_ARRAY, \
+		 struct amdxdna_drm_get_array)
+
 #if defined(__cplusplus)
 } /* extern c end */
 #endif
diff --git a/lib/libc/include/any-linux-any/drm/drm.h b/lib/libc/include/any-linux-any/drm/drm.h
index b6ca2dc3678e7ff8611c2f34c9ec181ce7190c9c..bd8bd0b2a4874aa80686d954e0dc78407afde7ac 100644
--- a/lib/libc/include/any-linux-any/drm/drm.h
+++ b/lib/libc/include/any-linux-any/drm/drm.h
@@ -591,34 +591,65 @@ struct drm_set_version {
 	int drm_dd_minor;
 };
 
-/* DRM_IOCTL_GEM_CLOSE ioctl argument type */
+/**
+ * struct drm_gem_close - Argument for &DRM_IOCTL_GEM_CLOSE ioctl.
+ * @handle: Handle of the object to be closed.
+ * @pad: Padding.
+ *
+ * Releases the handle to an mm object.
+ */
 struct drm_gem_close {
-	/** Handle of the object to be closed. */
 	__u32 handle;
 	__u32 pad;
 };
 
-/* DRM_IOCTL_GEM_FLINK ioctl argument type */
+/**
+ * struct drm_gem_flink - Argument for &DRM_IOCTL_GEM_FLINK ioctl.
+ * @handle: Handle for the object being named.
+ * @name: Returned global name.
+ *
+ * Create a global name for an object, returning the name.
+ *
+ * Note that the name does not hold a reference; when the object
+ * is freed, the name goes away.
+ */
 struct drm_gem_flink {
-	/** Handle for the object being named */
 	__u32 handle;
-
-	/** Returned global name */
 	__u32 name;
 };
 
-/* DRM_IOCTL_GEM_OPEN ioctl argument type */
+/**
+ * struct drm_gem_open - Argument for &DRM_IOCTL_GEM_OPEN ioctl.
+ * @name: Name of object being opened.
+ * @handle: Returned handle for the object.
+ * @size: Returned size of the object
+ *
+ * Open an object using the global name, returning a handle and the size.
+ *
+ * This handle (of course) holds a reference to the object, so the object
+ * will not go away until the handle is deleted.
+ */
 struct drm_gem_open {
-	/** Name of object being opened */
 	__u32 name;
-
-	/** Returned handle for the object */
 	__u32 handle;
-
-	/** Returned size of the object */
 	__u64 size;
 };
 
+/**
+ * struct drm_gem_change_handle - Argument for &DRM_IOCTL_GEM_CHANGE_HANDLE ioctl.
+ * @handle: The handle of a gem object.
+ * @new_handle: An available gem handle.
+ *
+ * This ioctl changes the handle of a GEM object to the specified one.
+ * The new handle must be unused. On success the old handle is closed
+ * and all further IOCTL should refer to the new handle only.
+ * Calls to DRM_IOCTL_PRIME_FD_TO_HANDLE will return the new handle.
+ */
+struct drm_gem_change_handle {
+	__u32 handle;
+	__u32 new_handle;
+};
+
 /**
  * DRM_CAP_DUMB_BUFFER
  *
@@ -869,6 +900,21 @@ struct drm_get_cap {
  */
 #define DRM_CLIENT_CAP_CURSOR_PLANE_HOTSPOT	6
 
+/**
+ * DRM_CLIENT_CAP_PLANE_COLOR_PIPELINE
+ *
+ * If set to 1 the DRM core will allow setting the COLOR_PIPELINE
+ * property on a &drm_plane, as well as drm_colorop properties.
+ *
+ * Setting of these plane properties will be rejected when this client
+ * cap is set:
+ * - COLOR_ENCODING
+ * - COLOR_RANGE
+ *
+ * The client must enable &DRM_CLIENT_CAP_ATOMIC first.
+ */
+#define DRM_CLIENT_CAP_PLANE_COLOR_PIPELINE	7
+
 /* DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */
 struct drm_set_client_cap {
 	__u64 capability;
@@ -1303,6 +1349,14 @@ extern "C" {
  */
 #define DRM_IOCTL_SET_CLIENT_NAME	DRM_IOWR(0xD1, struct drm_set_client_name)
 
+/**
+ * DRM_IOCTL_GEM_CHANGE_HANDLE - Move an object to a different handle
+ *
+ * Some applications (notably CRIU) need objects to have specific gem handles.
+ * This ioctl changes the object at one gem handle to use a new gem handle.
+ */
+#define DRM_IOCTL_GEM_CHANGE_HANDLE    DRM_IOWR(0xD2, struct drm_gem_change_handle)
+
 /*
  * Device specific ioctls should only be in their respective headers
  * The device specific ioctl range is from 0x40 to 0x9f.
diff --git a/lib/libc/include/any-linux-any/drm/drm_fourcc.h b/lib/libc/include/any-linux-any/drm/drm_fourcc.h
index 560229d1f0ced874492163a7801f04ac17390bf1..f13e98f66201f2a32a6f60713cf885d48c914023 100644
--- a/lib/libc/include/any-linux-any/drm/drm_fourcc.h
+++ b/lib/libc/include/any-linux-any/drm/drm_fourcc.h
@@ -979,14 +979,20 @@ extern "C" {
  *               2 = Gob Height 8, Turing+ Page Kind mapping
  *               3 = Reserved for future use.
  *
- * 22:22 s     Sector layout.  On Tegra GPUs prior to Xavier, there is a further
- *             bit remapping step that occurs at an even lower level than the
- *             page kind and block linear swizzles.  This causes the layout of
- *             surfaces mapped in those SOC's GPUs to be incompatible with the
- *             equivalent mapping on other GPUs in the same system.
+ * 22:22 s     Sector layout.  There is a further bit remapping step that occurs
+ * 26:27       at an even lower level than the page kind and block linear
+ *             swizzles.  This causes the bit arrangement of surfaces in memory
+ *             to differ subtly, and prevents direct sharing of surfaces between
+ *             GPUs with different layouts.
  *
- *               0 = Tegra K1 - Tegra Parker/TX2 Layout.
- *               1 = Desktop GPU and Tegra Xavier+ Layout
+ *               0 = Tegra K1 - Tegra Parker/TX2 Layout
+ *               1 = Pre-GB20x, GB20x 32+ bpp, GB10, Tegra Xavier-Orin Layout
+ *               2 = GB20x(Blackwell 2)+ 8 bpp surface layout
+ *               3 = GB20x(Blackwell 2)+ 16 bpp surface layout
+ *               4 = Reserved for future use.
+ *               5 = Reserved for future use.
+ *               6 = Reserved for future use.
+ *               7 = Reserved for future use.
  *
  * 25:23 c     Lossless Framebuffer Compression type.
  *
@@ -1001,7 +1007,7 @@ extern "C" {
  *               6 = Reserved for future use
  *               7 = Reserved for future use
  *
- * 55:25 -     Reserved for future use.  Must be zero.
+ * 55:28 -     Reserved for future use.  Must be zero.
  */
 #define DRM_FORMAT_MOD_NVIDIA_BLOCK_LINEAR_2D(c, s, g, k, h) \
 	fourcc_mod_code(NVIDIA, (0x10 | \
@@ -1009,6 +1015,7 @@ extern "C" {
 				 (((k) & 0xff) << 12) | \
 				 (((g) & 0x3) << 20) | \
 				 (((s) & 0x1) << 22) | \
+				 (((s) & 0x6) << 25) | \
 				 (((c) & 0x7) << 23)))
 
 /* To grandfather in prior block linear format modifiers to the above layout,
diff --git a/lib/libc/include/any-linux-any/drm/drm_mode.h b/lib/libc/include/any-linux-any/drm/drm_mode.h
index 852c53245da0fee43cf5aa548ac594fdf254fed8..b9d7342bd5a3d8930cbfded47618a9c0539dccb4 100644
--- a/lib/libc/include/any-linux-any/drm/drm_mode.h
+++ b/lib/libc/include/any-linux-any/drm/drm_mode.h
@@ -629,6 +629,7 @@ struct drm_mode_connector_set_property {
 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb
 #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
 #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
+#define DRM_MODE_OBJECT_COLOROP 0xfafafafa
 #define DRM_MODE_OBJECT_ANY 0
 
 struct drm_mode_obj_get_properties {
@@ -846,6 +847,20 @@ struct drm_color_ctm {
 	__u64 matrix[9];
 };
 
+struct drm_color_ctm_3x4 {
+	/*
+	 * Conversion matrix with 3x4 dimensions in S31.32 sign-magnitude
+	 * (not two's complement!) format.
+	 *
+	 * out   matrix          in
+	 * |R|   |0  1  2  3 |   | R |
+	 * |G| = |4  5  6  7 | x | G |
+	 * |B|   |8  9  10 11|   | B |
+	 *                       |1.0|
+	 */
+	__u64 matrix[12];
+};
+
 struct drm_color_lut {
 	/*
 	 * Values are mapped linearly to 0.0 - 1.0 range, with 0x0 == 0.0 and
@@ -857,6 +872,125 @@ struct drm_color_lut {
 	__u16 reserved;
 };
 
+/*
+ * struct drm_color_lut32
+ *
+ * 32-bit per channel color LUT entry, similar to drm_color_lut.
+ */
+struct drm_color_lut32 {
+	__u32 red;
+	__u32 green;
+	__u32 blue;
+	__u32 reserved;
+};
+
+/**
+ * enum drm_colorop_type - Type of color operation
+ *
+ * drm_colorops can be of many different types. Each type behaves differently
+ * and defines a different set of properties. This enum defines all types and
+ * gives a high-level description.
+ */
+enum drm_colorop_type {
+	/**
+	 * @DRM_COLOROP_1D_CURVE:
+	 *
+	 * enum string "1D Curve"
+	 *
+	 * A 1D curve that is being applied to all color channels. The
+	 * curve is specified via the CURVE_1D_TYPE colorop property.
+	 */
+	DRM_COLOROP_1D_CURVE,
+
+	/**
+	 * @DRM_COLOROP_1D_LUT:
+	 *
+	 * enum string "1D LUT"
+	 *
+	 * A simple 1D LUT of uniformly spaced &drm_color_lut32 entries,
+	 * packed into a blob via the DATA property. The driver's
+	 * expected LUT size is advertised via the SIZE property.
+	 *
+	 * The DATA blob is an array of struct drm_color_lut32 with size
+	 * of "size".
+	 */
+	DRM_COLOROP_1D_LUT,
+
+	/**
+	 * @DRM_COLOROP_CTM_3X4:
+	 *
+	 * enum string "3x4 Matrix"
+	 *
+	 * A 3x4 matrix. Its values are specified via the
+	 * &drm_color_ctm_3x4 struct provided via the DATA property.
+	 *
+	 * The DATA blob is a float[12]:
+	 * out   matrix          in
+	 * | R |   | 0  1  2  3  |   | R |
+	 * | G | = | 4  5  6  7  | x | G |
+	 * | B |   | 8  9  10 12 |   | B |
+	 */
+	DRM_COLOROP_CTM_3X4,
+
+	/**
+	 * @DRM_COLOROP_MULTIPLIER:
+	 *
+	 * enum string "Multiplier"
+	 *
+	 * A simple multiplier, applied to all color values. The
+	 * multiplier is specified as a S31.32 via the MULTIPLIER
+	 * property.
+	 */
+	DRM_COLOROP_MULTIPLIER,
+
+	/**
+	 * @DRM_COLOROP_3D_LUT:
+	 *
+	 * enum string "3D LUT"
+	 *
+	 * A 3D LUT of &drm_color_lut32 entries,
+	 * packed into a blob via the DATA property. The driver's expected
+	 * LUT size is advertised via the SIZE property, i.e., a 3D LUT with
+	 * 17x17x17 entries will have SIZE set to 17.
+	 *
+	 * The DATA blob is a 3D array of struct drm_color_lut32 with dimension
+	 * length of "size".
+	 * The LUT elements are traversed like so:
+	 *
+	 *   for B in range 0..n
+	 *     for G in range 0..n
+	 *       for R in range 0..n
+	 *        index = R + n * (G + n * B)
+	 *         color = lut3d[index]
+	 */
+	DRM_COLOROP_3D_LUT,
+};
+
+/**
+ * enum drm_colorop_lut3d_interpolation_type - type of 3DLUT interpolation
+ */
+enum drm_colorop_lut3d_interpolation_type {
+	/**
+	 * @DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL:
+	 *
+	 * Tetrahedral 3DLUT interpolation
+	 */
+	DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL,
+};
+
+/**
+ * enum drm_colorop_lut1d_interpolation_type - type of interpolation for 1D LUTs
+ */
+enum drm_colorop_lut1d_interpolation_type {
+	/**
+	 * @DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR:
+	 *
+	 * Linear interpolation. Values between points of the LUT will be
+	 * linearly interpolated.
+	 */
+	DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR,
+};
+
 /**
  * struct drm_plane_size_hint - Plane size hints
  * @width: The width of the plane in pixel
@@ -962,6 +1096,14 @@ struct hdr_output_metadata {
  * Request that the kernel sends back a vblank event (see
  * struct drm_event_vblank) with the &DRM_EVENT_FLIP_COMPLETE type when the
  * page-flip is done.
+ *
+ * When used with atomic uAPI, one event will be delivered per CRTC included in
+ * the atomic commit. A CRTC is included in an atomic commit if one of its
+ * properties is set, or if a property is set on a connector or plane linked
+ * via the CRTC_ID property to the CRTC. At least one CRTC must be included,
+ * and all pulled in CRTCs must be either previously or newly powered on (in
+ * other words, a powered off CRTC which stays off cannot be included in the
+ * atomic commit).
  */
 #define DRM_MODE_PAGE_FLIP_EVENT 0x01
 /**
@@ -1058,7 +1200,7 @@ struct drm_mode_crtc_page_flip_target {
  * struct drm_mode_create_dumb - Create a KMS dumb buffer for scanout.
  * @height: buffer height in pixels
  * @width: buffer width in pixels
- * @bpp: bits per pixel
+ * @bpp: color mode
  * @flags: must be zero
  * @handle: buffer object handle
  * @pitch: number of bytes between two consecutive lines
@@ -1066,6 +1208,54 @@ struct drm_mode_crtc_page_flip_target {
  *
  * User-space fills @height, @width, @bpp and @flags. If the IOCTL succeeds,
  * the kernel fills @handle, @pitch and @size.
+ *
+ * The value of @bpp is a color-mode number describing a specific format
+ * or a variant thereof. The value often corresponds to the number of bits
+ * per pixel for most modes, although there are exceptions. Each color mode
+ * maps to a DRM format plus a number of modes with similar pixel layout.
+ * Framebuffer layout is always linear.
+ *
+ * Support for all modes and formats is optional. Even if dumb-buffer
+ * creation with a certain color mode succeeds, it is not guaranteed that
+ * the DRM driver supports any of the related formats. Most drivers support
+ * a color mode of 32 with a format of DRM_FORMAT_XRGB8888 on their primary
+ * plane.
+ *
+ * +------------+------------------------+------------------------+
+ * | Color mode | Framebuffer format     | Compatible formats     |
+ * +============+========================+========================+
+ * |     32     |  * DRM_FORMAT_XRGB8888 |  * DRM_FORMAT_BGRX8888 |
+ * |            |                        |  * DRM_FORMAT_RGBX8888 |
+ * |            |                        |  * DRM_FORMAT_XBGR8888 |
+ * +------------+------------------------+------------------------+
+ * |     24     |  * DRM_FORMAT_RGB888   |  * DRM_FORMAT_BGR888   |
+ * +------------+------------------------+------------------------+
+ * |     16     |  * DRM_FORMAT_RGB565   |  * DRM_FORMAT_BGR565   |
+ * +------------+------------------------+------------------------+
+ * |     15     |  * DRM_FORMAT_XRGB1555 |  * DRM_FORMAT_BGRX1555 |
+ * |            |                        |  * DRM_FORMAT_RGBX1555 |
+ * |            |                        |  * DRM_FORMAT_XBGR1555 |
+ * +------------+------------------------+------------------------+
+ * |      8     |  * DRM_FORMAT_C8       |  * DRM_FORMAT_D8       |
+ * |            |                        |  * DRM_FORMAT_R8       |
+ * +------------+------------------------+------------------------+
+ * |      4     |  * DRM_FORMAT_C4       |  * DRM_FORMAT_D4       |
+ * |            |                        |  * DRM_FORMAT_R4       |
+ * +------------+------------------------+------------------------+
+ * |      2     |  * DRM_FORMAT_C2       |  * DRM_FORMAT_D2       |
+ * |            |                        |  * DRM_FORMAT_R2       |
+ * +------------+------------------------+------------------------+
+ * |      1     |  * DRM_FORMAT_C1       |  * DRM_FORMAT_D1       |
+ * |            |                        |  * DRM_FORMAT_R1       |
+ * +------------+------------------------+------------------------+
+ *
+ * Color modes of 10, 12, 15, 30 and 64 are only supported for use by
+ * legacy user space. Please don't use them in new code. Other modes
+ * are not support.
+ *
+ * Do not attempt to allocate anything but linear framebuffer memory
+ * with single-plane RGB data. Allocation of other framebuffer
+ * layouts requires dedicated ioctls in the respective DRM driver.
  */
 struct drm_mode_create_dumb {
 	__u32 height;
diff --git a/lib/libc/include/any-linux-any/drm/ethosu_accel.h b/lib/libc/include/any-linux-any/drm/ethosu_accel.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a905bbd686a9a106e445a617555f59c2d535946
--- /dev/null
+++ b/lib/libc/include/any-linux-any/drm/ethosu_accel.h
@@ -0,0 +1,261 @@
+/* SPDX-License-Identifier: MIT */
+/* Copyright (C) 2025 Arm, Ltd. */
+#ifndef _ETHOSU_DRM_H_
+#define _ETHOSU_DRM_H_
+
+#include "drm.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * DOC: IOCTL IDs
+ *
+ * enum drm_ethosu_ioctl_id - IOCTL IDs
+ *
+ * Place new ioctls at the end, don't re-order, don't replace or remove entries.
+ *
+ * These IDs are not meant to be used directly. Use the DRM_IOCTL_ETHOSU_xxx
+ * definitions instead.
+ */
+enum drm_ethosu_ioctl_id {
+	/** @DRM_ETHOSU_DEV_QUERY: Query device information. */
+	DRM_ETHOSU_DEV_QUERY = 0,
+
+	/** @DRM_ETHOSU_BO_CREATE: Create a buffer object. */
+	DRM_ETHOSU_BO_CREATE,
+
+	/** @DRM_ETHOSU_BO_WAIT: Wait on a buffer object's fence. */
+	DRM_ETHOSU_BO_WAIT,
+
+	/**
+	 * @DRM_ETHOSU_BO_MMAP_OFFSET: Get the file offset to pass to
+	 * mmap to map a GEM object.
+	 */
+	DRM_ETHOSU_BO_MMAP_OFFSET,
+
+	/**
+	 * @DRM_ETHOSU_CMDSTREAM_BO_CREATE: Create a command stream buffer
+	 * object.
+	 */
+	DRM_ETHOSU_CMDSTREAM_BO_CREATE,
+
+	/** @DRM_ETHOSU_SUBMIT: Submit a job and BOs to run. */
+	DRM_ETHOSU_SUBMIT,
+};
+
+/**
+ * DOC: IOCTL arguments
+ */
+
+/**
+ * enum drm_ethosu_dev_query_type - Query type
+ *
+ * Place new types at the end, don't re-order, don't remove or replace.
+ */
+enum drm_ethosu_dev_query_type {
+	/** @DRM_ETHOSU_DEV_QUERY_NPU_INFO: Query NPU information. */
+	DRM_ETHOSU_DEV_QUERY_NPU_INFO = 0,
+};
+
+/**
+ * struct drm_ethosu_gpu_info - NPU information
+ *
+ * Structure grouping all queryable information relating to the NPU.
+ */
+struct drm_ethosu_npu_info {
+	/** @id : NPU ID. */
+	__u32 id;
+#define DRM_ETHOSU_ARCH_MAJOR(x)			((x) >> 28)
+#define DRM_ETHOSU_ARCH_MINOR(x)			(((x) >> 20) & 0xff)
+#define DRM_ETHOSU_ARCH_PATCH(x)			(((x) >> 16) & 0xf)
+#define DRM_ETHOSU_PRODUCT_MAJOR(x)		(((x) >> 12) & 0xf)
+#define DRM_ETHOSU_VERSION_MAJOR(x)		(((x) >> 8) & 0xf)
+#define DRM_ETHOSU_VERSION_MINOR(x)		(((x) >> 4) & 0xff)
+#define DRM_ETHOSU_VERSION_STATUS(x)		((x) & 0xf)
+
+	/** @gpu_rev: GPU revision. */
+	__u32 config;
+
+	__u32 sram_size;
+};
+
+/**
+ * struct drm_ethosu_dev_query - Arguments passed to DRM_ETHOSU_IOCTL_DEV_QUERY
+ */
+struct drm_ethosu_dev_query {
+	/** @type: the query type (see drm_ethosu_dev_query_type). */
+	__u32 type;
+
+	/**
+	 * @size: size of the type being queried.
+	 *
+	 * If pointer is NULL, size is updated by the driver to provide the
+	 * output structure size. If pointer is not NULL, the driver will
+	 * only copy min(size, actual_structure_size) bytes to the pointer,
+	 * and update the size accordingly. This allows us to extend query
+	 * types without breaking userspace.
+	 */
+	__u32 size;
+
+	/**
+	 * @pointer: user pointer to a query type struct.
+	 *
+	 * Pointer can be NULL, in which case, nothing is copied, but the
+	 * actual structure size is returned. If not NULL, it must point to
+	 * a location that's large enough to hold size bytes.
+	 */
+	__u64 pointer;
+};
+
+/**
+ * enum drm_ethosu_bo_flags - Buffer object flags, passed at creation time.
+ */
+enum drm_ethosu_bo_flags {
+	/**
+	 * @DRM_ETHOSU_BO_NO_MMAP: The buffer object will never be CPU-mapped
+	 * in userspace.
+	 */
+	DRM_ETHOSU_BO_NO_MMAP = (1 << 0),
+};
+
+/**
+ * struct drm_ethosu_bo_create - Arguments passed to DRM_IOCTL_ETHOSU_BO_CREATE.
+ */
+struct drm_ethosu_bo_create {
+	/**
+	 * @size: Requested size for the object
+	 *
+	 * The (page-aligned) allocated size for the object will be returned.
+	 */
+	__u64 size;
+
+	/**
+	 * @flags: Flags. Must be a combination of drm_ethosu_bo_flags flags.
+	 */
+	__u32 flags;
+
+	/**
+	 * @handle: Returned handle for the object.
+	 *
+	 * Object handles are nonzero.
+	 */
+	__u32 handle;
+};
+
+/**
+ * struct drm_ethosu_bo_mmap_offset - Arguments passed to DRM_IOCTL_ETHOSU_BO_MMAP_OFFSET.
+ */
+struct drm_ethosu_bo_mmap_offset {
+	/** @handle: Handle of the object we want an mmap offset for. */
+	__u32 handle;
+
+	/** @pad: MBZ. */
+	__u32 pad;
+
+	/** @offset: The fake offset to use for subsequent mmap calls. */
+	__u64 offset;
+};
+
+/**
+ * struct drm_ethosu_wait_bo - ioctl argument for waiting for
+ * completion of the last DRM_ETHOSU_SUBMIT on a BO.
+ *
+ * This is useful for cases where multiple processes might be
+ * rendering to a BO and you want to wait for all rendering to be
+ * completed.
+ */
+struct drm_ethosu_bo_wait {
+	__u32 handle;
+	__u32 pad;
+	__s64 timeout_ns;	/* absolute */
+};
+
+struct drm_ethosu_cmdstream_bo_create {
+	/* Size of the data argument. */
+	__u32 size;
+
+	/* Flags, currently must be 0. */
+	__u32 flags;
+
+	/* Pointer to the data. */
+	__u64 data;
+
+	/** Returned GEM handle for the BO. */
+	__u32 handle;
+
+	/* Pad, must be 0. */
+	__u32 pad;
+};
+
+/**
+ * struct drm_ethosu_job - A job to be run on the NPU
+ *
+ * The kernel will schedule the execution of this job taking into account its
+ * dependencies with other jobs. All tasks in the same job will be executed
+ * sequentially on the same core, to benefit from memory residency in SRAM.
+ */
+struct drm_ethosu_job {
+	/** Input: BO handle for cmdstream. */
+	__u32 cmd_bo;
+
+	/** Input: Amount of SRAM to use. */
+	__u32 sram_size;
+
+#define ETHOSU_MAX_REGIONS	8
+	/** Input: Array of BO handles for each region. */
+	__u32 region_bo_handles[ETHOSU_MAX_REGIONS];
+};
+
+/**
+ * struct drm_ethosu_submit - ioctl argument for submitting commands to the NPU.
+ *
+ * The kernel will schedule the execution of these jobs in dependency order.
+ */
+struct drm_ethosu_submit {
+	/** Input: Pointer to an array of struct drm_ethosu_job. */
+	__u64 jobs;
+
+	/** Input: Number of jobs passed in. */
+	__u32 job_count;
+
+	/** Reserved, must be zero. */
+	__u32 pad;
+};
+
+/**
+ * DRM_IOCTL_ETHOSU() - Build a ethosu IOCTL number
+ * @__access: Access type. Must be R, W or RW.
+ * @__id: One of the DRM_ETHOSU_xxx id.
+ * @__type: Suffix of the type being passed to the IOCTL.
+ *
+ * Don't use this macro directly, use the DRM_IOCTL_ETHOSU_xxx
+ * values instead.
+ *
+ * Return: An IOCTL number to be passed to ioctl() from userspace.
+ */
+#define DRM_IOCTL_ETHOSU(__access, __id, __type) \
+	DRM_IO ## __access(DRM_COMMAND_BASE + DRM_ETHOSU_ ## __id, \
+			   struct drm_ethosu_ ## __type)
+
+enum {
+	DRM_IOCTL_ETHOSU_DEV_QUERY =
+		DRM_IOCTL_ETHOSU(WR, DEV_QUERY, dev_query),
+	DRM_IOCTL_ETHOSU_BO_CREATE =
+		DRM_IOCTL_ETHOSU(WR, BO_CREATE, bo_create),
+	DRM_IOCTL_ETHOSU_BO_WAIT =
+		DRM_IOCTL_ETHOSU(WR, BO_WAIT, bo_wait),
+	DRM_IOCTL_ETHOSU_BO_MMAP_OFFSET =
+		DRM_IOCTL_ETHOSU(WR, BO_MMAP_OFFSET, bo_mmap_offset),
+	DRM_IOCTL_ETHOSU_CMDSTREAM_BO_CREATE =
+		DRM_IOCTL_ETHOSU(WR, CMDSTREAM_BO_CREATE, cmdstream_bo_create),
+	DRM_IOCTL_ETHOSU_SUBMIT =
+		DRM_IOCTL_ETHOSU(WR, SUBMIT, submit),
+};
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* _ETHOSU_DRM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/drm/ivpu_accel.h b/lib/libc/include/any-linux-any/drm/ivpu_accel.h
index df8215c5fc73fd7134ca325f4fa7fedbc3679aea..2993c1415d28520b63bbab01e24046c40fe9d58d 100644
--- a/lib/libc/include/any-linux-any/drm/ivpu_accel.h
+++ b/lib/libc/include/any-linux-any/drm/ivpu_accel.h
@@ -25,6 +25,7 @@ extern "C" {
 #define DRM_IVPU_CMDQ_CREATE              0x0b
 #define DRM_IVPU_CMDQ_DESTROY             0x0c
 #define DRM_IVPU_CMDQ_SUBMIT              0x0d
+#define DRM_IVPU_BO_CREATE_FROM_USERPTR	  0x0e
 
 #define DRM_IOCTL_IVPU_GET_PARAM                                               \
 	DRM_IOWR(DRM_COMMAND_BASE + DRM_IVPU_GET_PARAM, struct drm_ivpu_param)
@@ -69,6 +70,10 @@ extern "C" {
 #define DRM_IOCTL_IVPU_CMDQ_SUBMIT                                             \
 	DRM_IOW(DRM_COMMAND_BASE + DRM_IVPU_CMDQ_SUBMIT, struct drm_ivpu_cmdq_submit)
 
+#define DRM_IOCTL_IVPU_BO_CREATE_FROM_USERPTR                        \
+	DRM_IOWR(DRM_COMMAND_BASE + DRM_IVPU_BO_CREATE_FROM_USERPTR, \
+		 struct drm_ivpu_bo_create_from_userptr)
+
 /**
  * DOC: contexts
  *
@@ -90,6 +95,7 @@ extern "C" {
 #define DRM_IVPU_PARAM_TILE_CONFIG	    11
 #define DRM_IVPU_PARAM_SKU		    12
 #define DRM_IVPU_PARAM_CAPABILITIES	    13
+#define DRM_IVPU_PARAM_PREEMPT_BUFFER_SIZE  14
 
 #define DRM_IVPU_PLATFORM_TYPE_SILICON	    0
 
@@ -126,6 +132,13 @@ extern "C" {
  * command queue destroy and submit job on specific command queue.
  */
 #define DRM_IVPU_CAP_MANAGE_CMDQ       3
+/**
+ * DRM_IVPU_CAP_BO_CREATE_FROM_USERPTR
+ *
+ * Driver supports creating buffer objects from user space memory pointers.
+ * This allows creating GEM buffers from existing user memory regions.
+ */
+#define DRM_IVPU_CAP_BO_CREATE_FROM_USERPTR	4
 
 /**
  * struct drm_ivpu_param - Get/Set VPU parameters
@@ -176,6 +189,9 @@ struct drm_ivpu_param {
 	 *
 	 * %DRM_IVPU_PARAM_CAPABILITIES:
 	 * Supported capabilities (read-only)
+	 *
+	 * %DRM_IVPU_PARAM_PREEMPT_BUFFER_SIZE:
+	 * Size of the preemption buffer (read-only)
 	 */
 	__u32 param;
 
@@ -190,6 +206,7 @@ struct drm_ivpu_param {
 #define DRM_IVPU_BO_HIGH_MEM   DRM_IVPU_BO_SHAVE_MEM
 #define DRM_IVPU_BO_MAPPABLE   0x00000002
 #define DRM_IVPU_BO_DMA_MEM    0x00000004
+#define DRM_IVPU_BO_READ_ONLY  0x00000008
 
 #define DRM_IVPU_BO_CACHED     0x00000000
 #define DRM_IVPU_BO_UNCACHED   0x00010000
@@ -200,6 +217,7 @@ struct drm_ivpu_param {
 	(DRM_IVPU_BO_HIGH_MEM | \
 	 DRM_IVPU_BO_MAPPABLE | \
 	 DRM_IVPU_BO_DMA_MEM | \
+	 DRM_IVPU_BO_READ_ONLY | \
 	 DRM_IVPU_BO_CACHE_MASK)
 
 /**
@@ -251,6 +269,44 @@ struct drm_ivpu_bo_create {
 	__u64 vpu_addr;
 };
 
+/**
+ * struct drm_ivpu_bo_create_from_userptr - Create dma-buf from user pointer
+ *
+ * Create a GEM buffer object from a user pointer to a memory region.
+ */
+struct drm_ivpu_bo_create_from_userptr {
+	/** @user_ptr: User pointer to memory region (must be page aligned) */
+	__u64 user_ptr;
+
+	/** @size: Size of the memory region in bytes (must be page aligned) */
+	__u64 size;
+
+	/**
+	 * @flags:
+	 *
+	 * Supported flags:
+	 *
+	 * %DRM_IVPU_BO_HIGH_MEM:
+	 *
+	 * Allocate VPU address from >4GB range.
+	 *
+	 * %DRM_IVPU_BO_DMA_MEM:
+	 *
+	 * Allocate from DMA memory range accessible by hardware DMA.
+	 *
+	 * %DRM_IVPU_BO_READ_ONLY:
+	 *
+	 * Allocate as a read-only buffer object.
+	 */
+	__u32 flags;
+
+	/** @handle: Returned GEM object handle */
+	__u32 handle;
+
+	/** @vpu_addr: Returned VPU virtual address */
+	__u64 vpu_addr;
+};
+
 /**
  * struct drm_ivpu_bo_info - Query buffer object info
  */
@@ -371,6 +427,13 @@ struct drm_ivpu_cmdq_submit {
 	 * to be executed. The offset has to be 8-byte aligned.
 	 */
 	__u32 commands_offset;
+	/**
+	 * @preempt_buffer_index:
+	 *
+	 * Index of the preemption buffer in the buffers_ptr array.
+	 */
+	__u32 preempt_buffer_index;
+	__u32 reserved;
 };
 
 /* drm_ivpu_bo_wait job status codes */
diff --git a/lib/libc/include/any-linux-any/drm/panfrost_drm.h b/lib/libc/include/any-linux-any/drm/panfrost_drm.h
index 22557772e67295c1b228d88cbfb611ed4dd0efe6..639c91e2b78344a6103dcc71db3b2ef3e5c0384f 100644
--- a/lib/libc/include/any-linux-any/drm/panfrost_drm.h
+++ b/lib/libc/include/any-linux-any/drm/panfrost_drm.h
@@ -22,6 +22,8 @@ extern "C" {
 #define DRM_PANFROST_PERFCNT_DUMP		0x07
 #define DRM_PANFROST_MADVISE			0x08
 #define DRM_PANFROST_SET_LABEL_BO		0x09
+#define DRM_PANFROST_JM_CTX_CREATE		0x0a
+#define DRM_PANFROST_JM_CTX_DESTROY		0x0b
 
 #define DRM_IOCTL_PANFROST_SUBMIT		DRM_IOW(DRM_COMMAND_BASE + DRM_PANFROST_SUBMIT, struct drm_panfrost_submit)
 #define DRM_IOCTL_PANFROST_WAIT_BO		DRM_IOW(DRM_COMMAND_BASE + DRM_PANFROST_WAIT_BO, struct drm_panfrost_wait_bo)
@@ -31,6 +33,8 @@ extern "C" {
 #define DRM_IOCTL_PANFROST_GET_BO_OFFSET	DRM_IOWR(DRM_COMMAND_BASE + DRM_PANFROST_GET_BO_OFFSET, struct drm_panfrost_get_bo_offset)
 #define DRM_IOCTL_PANFROST_MADVISE		DRM_IOWR(DRM_COMMAND_BASE + DRM_PANFROST_MADVISE, struct drm_panfrost_madvise)
 #define DRM_IOCTL_PANFROST_SET_LABEL_BO		DRM_IOWR(DRM_COMMAND_BASE + DRM_PANFROST_SET_LABEL_BO, struct drm_panfrost_set_label_bo)
+#define DRM_IOCTL_PANFROST_JM_CTX_CREATE	DRM_IOWR(DRM_COMMAND_BASE + DRM_PANFROST_JM_CTX_CREATE, struct drm_panfrost_jm_ctx_create)
+#define DRM_IOCTL_PANFROST_JM_CTX_DESTROY	DRM_IOWR(DRM_COMMAND_BASE + DRM_PANFROST_JM_CTX_DESTROY, struct drm_panfrost_jm_ctx_destroy)
 
 /*
  * Unstable ioctl(s): only exposed when the unsafe unstable_ioctls module
@@ -50,27 +54,47 @@ extern "C" {
  * This asks the kernel to have the GPU execute a render command list.
  */
 struct drm_panfrost_submit {
-
-	/** Address to GPU mapping of job descriptor */
+	/**
+	 * @jc: Address to GPU mapping of job descriptor
+	 */
 	__u64 jc;
-
-	/** An optional array of sync objects to wait on before starting this job. */
+	/**
+	 * @in_syncs: An optional array of sync objects to wait on
+	 * before starting this job.
+	 */
 	__u64 in_syncs;
-
-	/** Number of sync objects to wait on before starting this job. */
+	/**
+	 * @in_sync_count: Number of sync objects to wait on before
+	 * starting this job.
+	 */
 	__u32 in_sync_count;
-
-	/** An optional sync object to place the completion fence in. */
+	/**
+	 * @out_sync: An optional sync object to place the completion fence in.
+	 */
 	__u32 out_sync;
-
-	/** Pointer to a u32 array of the BOs that are referenced by the job. */
+	/**
+	 * @bo_handles: Pointer to a u32 array of the BOs that are
+	 * referenced by the job.
+	 */
 	__u64 bo_handles;
-
-	/** Number of BO handles passed in (size is that times 4). */
+	/**
+	 * @bo_handle_count: Number of BO handles passed in (size is
+	 * that times 4).
+	 */
 	__u32 bo_handle_count;
-
-	/** A combination of PANFROST_JD_REQ_* */
+	/**
+	 * @requirements: A combination of PANFROST_JD_REQ_*
+	 */
 	__u32 requirements;
+	/**
+	 * @jm_ctx_handle: JM context handle. Zero if you want to use the
+	 * default context.
+	 */
+	__u32 jm_ctx_handle;
+	/**
+	 * @pad: Padding field. Must be zero.
+	 */
+	__u32 pad;
 };
 
 /**
@@ -82,9 +106,18 @@ struct drm_panfrost_submit {
  * completed.
  */
 struct drm_panfrost_wait_bo {
+	/**
+	 * @handle: Handle for the object to wait for.
+	 */
 	__u32 handle;
+	/**
+	 * @pad: Padding, must be zero-filled.
+	 */
 	__u32 pad;
-	__s64 timeout_ns;	/* absolute */
+	/**
+	 * @timeout_ns: absolute number of nanoseconds to wait.
+	 */
+	__s64 timeout_ns;
 };
 
 /* Valid flags to pass to drm_panfrost_create_bo */
@@ -97,16 +130,26 @@ struct drm_panfrost_wait_bo {
  * The flags argument is a bit mask of PANFROST_BO_* flags.
  */
 struct drm_panfrost_create_bo {
+	/**
+	 * @size: size of shmem/BO area to create (bytes)
+	 */
 	__u32 size;
+	/**
+	 * @flags: see PANFROST_BO_* flags
+	 */
 	__u32 flags;
-	/** Returned GEM handle for the BO. */
+	/**
+	 * @handle: Returned GEM handle for the BO.
+	 */
 	__u32 handle;
-	/* Pad, must be zero-filled. */
+	/**
+	 * @pad: Padding, must be zero-filled.
+	 */
 	__u32 pad;
 	/**
-	 * Returned offset for the BO in the GPU address space.  This offset
-	 * is private to the DRM fd and is valid for the lifetime of the GEM
-	 * handle.
+	 * @offset: Returned offset for the BO in the GPU address space.
+	 * This offset is private to the DRM fd and is valid for the
+	 * lifetime of the GEM handle.
 	 *
 	 * This offset value will always be nonzero, since various HW
 	 * units treat 0 specially.
@@ -126,10 +169,17 @@ struct drm_panfrost_create_bo {
  * used in a future extension.
  */
 struct drm_panfrost_mmap_bo {
-	/** Handle for the object being mapped. */
+	/**
+	 * @handle: Handle for the object being mapped.
+	 */
 	__u32 handle;
+	/**
+	 * @flags: currently not used (should be zero)
+	 */
 	__u32 flags;
-	/** offset into the drm node to use for subsequent mmap call. */
+	/**
+	 * @offset: offset into the drm node to use for subsequent mmap call.
+	 */
 	__u64 offset;
 };
 
@@ -177,6 +227,7 @@ enum drm_panfrost_param {
 	DRM_PANFROST_PARAM_AFBC_FEATURES,
 	DRM_PANFROST_PARAM_SYSTEM_TIMESTAMP,
 	DRM_PANFROST_PARAM_SYSTEM_TIMESTAMP_FREQUENCY,
+	DRM_PANFROST_PARAM_ALLOWED_JM_CTX_PRIORITIES,
 };
 
 struct drm_panfrost_get_param {
@@ -185,7 +236,7 @@ struct drm_panfrost_get_param {
 	__u64 value;
 };
 
-/**
+/*
  * Returns the offset for the BO in the GPU address space for this DRM fd.
  * This is the same value returned by drm_panfrost_create_bo, if that was called
  * from this DRM fd.
@@ -233,12 +284,14 @@ struct drm_panfrost_madvise {
  * struct drm_panfrost_set_label_bo - ioctl argument for labelling Panfrost BOs.
  */
 struct drm_panfrost_set_label_bo {
-	/** @handle: Handle of the buffer object to label. */
+	/**
+	 * @handle: Handle of the buffer object to label.
+	 */
 	__u32 handle;
-
-	/**  @pad: MBZ. */
+	/**
+	 * @pad: Must be zero.
+	 */
 	__u32 pad;
-
 	/**
 	 * @label: User pointer to a NUL-terminated string
 	 *
@@ -299,6 +352,49 @@ struct panfrost_dump_registers {
 	__u32 value;
 };
 
+enum drm_panfrost_jm_ctx_priority {
+	/**
+	 * @PANFROST_JM_CTX_PRIORITY_LOW: Low priority context.
+	 */
+	PANFROST_JM_CTX_PRIORITY_LOW = 0,
+
+	/**
+	 * @PANFROST_JM_CTX_PRIORITY_MEDIUM: Medium priority context.
+	 */
+	PANFROST_JM_CTX_PRIORITY_MEDIUM,
+
+	/**
+	 * @PANFROST_JM_CTX_PRIORITY_HIGH: High priority context.
+	 *
+	 * Requires CAP_SYS_NICE or DRM_MASTER.
+	 */
+	PANFROST_JM_CTX_PRIORITY_HIGH,
+};
+
+struct drm_panfrost_jm_ctx_create {
+	/**
+	 * @handle: Handle of the created JM context
+	 */
+	__u32 handle;
+	/**
+	 * @priority: Context priority (see enum drm_panfrost_jm_ctx_priority).
+	 */
+	__u32 priority;
+};
+
+struct drm_panfrost_jm_ctx_destroy {
+	/**
+	 * @handle: Handle of the JM context to destroy.
+	 *
+	 * Must be a valid context handle returned by DRM_IOCTL_PANTHOR_JM_CTX_CREATE.
+	 */
+	__u32 handle;
+	/**
+	 * @pad: Padding field, must be zero.
+	 */
+	__u32 pad;
+};
+
 #if defined(__cplusplus)
 }
 #endif
diff --git a/lib/libc/include/any-linux-any/drm/panthor_drm.h b/lib/libc/include/any-linux-any/drm/panthor_drm.h
index 9274998d24a4a28d78abd08b732e8be8d041edab..35bb24e19e64c048462293ff72f8688f9bb4bd8f 100644
--- a/lib/libc/include/any-linux-any/drm/panthor_drm.h
+++ b/lib/libc/include/any-linux-any/drm/panthor_drm.h
@@ -327,6 +327,9 @@ struct drm_panthor_gpu_info {
 
 	/** @pad: MBZ. */
 	__u32 pad;
+
+	/** @gpu_features: Bitmask describing supported GPU-wide features */
+	__u64 gpu_features;
 };
 
 /**
diff --git a/lib/libc/include/any-linux-any/drm/rocket_accel.h b/lib/libc/include/any-linux-any/drm/rocket_accel.h
new file mode 100644
index 0000000000000000000000000000000000000000..782120422bf0921c4a5a1a7377c15927bd258170
--- /dev/null
+++ b/lib/libc/include/any-linux-any/drm/rocket_accel.h
@@ -0,0 +1,142 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2024 Tomeu Vizoso
+ */
+#ifndef __DRM_UAPI_ROCKET_ACCEL_H__
+#define __DRM_UAPI_ROCKET_ACCEL_H__
+
+#include "drm.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define DRM_ROCKET_CREATE_BO			0x00
+#define DRM_ROCKET_SUBMIT			0x01
+#define DRM_ROCKET_PREP_BO			0x02
+#define DRM_ROCKET_FINI_BO			0x03
+
+#define DRM_IOCTL_ROCKET_CREATE_BO		DRM_IOWR(DRM_COMMAND_BASE + DRM_ROCKET_CREATE_BO, struct drm_rocket_create_bo)
+#define DRM_IOCTL_ROCKET_SUBMIT			DRM_IOW(DRM_COMMAND_BASE + DRM_ROCKET_SUBMIT, struct drm_rocket_submit)
+#define DRM_IOCTL_ROCKET_PREP_BO		DRM_IOW(DRM_COMMAND_BASE + DRM_ROCKET_PREP_BO, struct drm_rocket_prep_bo)
+#define DRM_IOCTL_ROCKET_FINI_BO		DRM_IOW(DRM_COMMAND_BASE + DRM_ROCKET_FINI_BO, struct drm_rocket_fini_bo)
+
+/**
+ * struct drm_rocket_create_bo - ioctl argument for creating Rocket BOs.
+ *
+ */
+struct drm_rocket_create_bo {
+	/** Input: Size of the requested BO. */
+	__u32 size;
+
+	/** Output: GEM handle for the BO. */
+	__u32 handle;
+
+	/**
+	 * Output: DMA address for the BO in the NPU address space.  This address
+	 * is private to the DRM fd and is valid for the lifetime of the GEM
+	 * handle.
+	 */
+	__u64 dma_address;
+
+	/** Output: Offset into the drm node to use for subsequent mmap call. */
+	__u64 offset;
+};
+
+/**
+ * struct drm_rocket_prep_bo - ioctl argument for starting CPU ownership of the BO.
+ *
+ * Takes care of waiting for any NPU jobs that might still use the NPU and performs cache
+ * synchronization.
+ */
+struct drm_rocket_prep_bo {
+	/** Input: GEM handle of the buffer object. */
+	__u32 handle;
+
+	/** Reserved, must be zero. */
+	__u32 reserved;
+
+	/** Input: Amount of time to wait for NPU jobs. */
+	__s64 timeout_ns;
+};
+
+/**
+ * struct drm_rocket_fini_bo - ioctl argument for finishing CPU ownership of the BO.
+ *
+ * Synchronize caches for NPU access.
+ */
+struct drm_rocket_fini_bo {
+	/** Input: GEM handle of the buffer object. */
+	__u32 handle;
+
+	/** Reserved, must be zero. */
+	__u32 reserved;
+};
+
+/**
+ * struct drm_rocket_task - A task to be run on the NPU
+ *
+ * A task is the smallest unit of work that can be run on the NPU.
+ */
+struct drm_rocket_task {
+	/** Input: DMA address to NPU mapping of register command buffer */
+	__u32 regcmd;
+
+	/** Input: Number of commands in the register command buffer */
+	__u32 regcmd_count;
+};
+
+/**
+ * struct drm_rocket_job - A job to be run on the NPU
+ *
+ * The kernel will schedule the execution of this job taking into account its
+ * dependencies with other jobs. All tasks in the same job will be executed
+ * sequentially on the same core, to benefit from memory residency in SRAM.
+ */
+struct drm_rocket_job {
+	/** Input: Pointer to an array of struct drm_rocket_task. */
+	__u64 tasks;
+
+	/** Input: Pointer to a u32 array of the BOs that are read by the job. */
+	__u64 in_bo_handles;
+
+	/** Input: Pointer to a u32 array of the BOs that are written to by the job. */
+	__u64 out_bo_handles;
+
+	/** Input: Number of tasks passed in. */
+	__u32 task_count;
+
+	/** Input: Size in bytes of the structs in the @tasks field. */
+	__u32 task_struct_size;
+
+	/** Input: Number of input BO handles passed in (size is that times 4). */
+	__u32 in_bo_handle_count;
+
+	/** Input: Number of output BO handles passed in (size is that times 4). */
+	__u32 out_bo_handle_count;
+};
+
+/**
+ * struct drm_rocket_submit - ioctl argument for submitting commands to the NPU.
+ *
+ * The kernel will schedule the execution of these jobs in dependency order.
+ */
+struct drm_rocket_submit {
+	/** Input: Pointer to an array of struct drm_rocket_job. */
+	__u64 jobs;
+
+	/** Input: Number of jobs passed in. */
+	__u32 job_count;
+
+	/** Input: Size in bytes of the structs in the @jobs field. */
+	__u32 job_struct_size;
+
+	/** Reserved, must be zero. */
+	__u64 reserved;
+};
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* __DRM_UAPI_ROCKET_ACCEL_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/drm/v3d_drm.h b/lib/libc/include/any-linux-any/drm/v3d_drm.h
index 2ab8bee601e6d7d161d2122da9adcdf47d0cbb4b..b2b694d4c09e11735cd0d8b349ae16e3d0a6c47d 100644
--- a/lib/libc/include/any-linux-any/drm/v3d_drm.h
+++ b/lib/libc/include/any-linux-any/drm/v3d_drm.h
@@ -294,6 +294,8 @@ enum drm_v3d_param {
 	DRM_V3D_PARAM_SUPPORTS_CPU_QUEUE,
 	DRM_V3D_PARAM_MAX_PERF_COUNTERS,
 	DRM_V3D_PARAM_SUPPORTS_SUPER_PAGES,
+	DRM_V3D_PARAM_GLOBAL_RESET_COUNTER,
+	DRM_V3D_PARAM_CONTEXT_RESET_COUNTER,
 };
 
 struct drm_v3d_get_param {
diff --git a/lib/libc/include/any-linux-any/drm/xe_drm.h b/lib/libc/include/any-linux-any/drm/xe_drm.h
index fbe9b00ea68c7ca8ec4d99514a98a6ca5330ca1f..68f290c3938de068565be03e3f5ce57df8e1253f 100644
--- a/lib/libc/include/any-linux-any/drm/xe_drm.h
+++ b/lib/libc/include/any-linux-any/drm/xe_drm.h
@@ -81,6 +81,8 @@ extern "C" {
  *  - &DRM_IOCTL_XE_EXEC
  *  - &DRM_IOCTL_XE_WAIT_USER_FENCE
  *  - &DRM_IOCTL_XE_OBSERVATION
+ *  - &DRM_IOCTL_XE_MADVISE
+ *  - &DRM_IOCTL_XE_VM_QUERY_MEM_RANGE_ATTRS
  */
 
 /*
@@ -102,6 +104,8 @@ extern "C" {
 #define DRM_XE_EXEC			0x09
 #define DRM_XE_WAIT_USER_FENCE		0x0a
 #define DRM_XE_OBSERVATION		0x0b
+#define DRM_XE_MADVISE			0x0c
+#define DRM_XE_VM_QUERY_MEM_RANGE_ATTRS	0x0d
 
 /* Must be kept compact -- no holes */
 
@@ -117,6 +121,8 @@ extern "C" {
 #define DRM_IOCTL_XE_EXEC			DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)
 #define DRM_IOCTL_XE_WAIT_USER_FENCE		DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)
 #define DRM_IOCTL_XE_OBSERVATION		DRM_IOW(DRM_COMMAND_BASE + DRM_XE_OBSERVATION, struct drm_xe_observation_param)
+#define DRM_IOCTL_XE_MADVISE			DRM_IOW(DRM_COMMAND_BASE + DRM_XE_MADVISE, struct drm_xe_madvise)
+#define DRM_IOCTL_XE_VM_QUERY_MEM_RANGE_ATTRS	DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_VM_QUERY_MEM_RANGE_ATTRS, struct drm_xe_vm_query_mem_range_attr)
 
 /**
  * DOC: Xe IOCTL Extensions
@@ -760,8 +766,16 @@ struct drm_xe_device_query {
  * gem creation
  *
  * The @flags can be:
- *  - %DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING
- *  - %DRM_XE_GEM_CREATE_FLAG_SCANOUT
+ *  - %DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING - Modify the GEM object
+ *    allocation strategy by deferring physical memory allocation
+ *    until the object is either bound to a virtual memory region via
+ *    VM_BIND or accessed by the CPU. As a result, no backing memory is
+ *    reserved at the time of GEM object creation.
+ *  - %DRM_XE_GEM_CREATE_FLAG_SCANOUT - Indicates that the GEM object is
+ *    intended for scanout via the display engine. When set, kernel ensures
+ *    that the allocation is placed in a memory region compatible with the
+ *    display engine requirements. This may impose restrictions on tiling,
+ *    alignment, and memory placement to guarantee proper display functionality.
  *  - %DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM - When using VRAM as a
  *    possible placement, ensure that the corresponding VRAM allocation
  *    will always use the CPU accessible part of VRAM. This is important
@@ -1003,6 +1017,24 @@ struct drm_xe_vm_destroy {
  *    valid on VMs with DRM_XE_VM_CREATE_FLAG_FAULT_MODE set. The CPU address
  *    mirror flag are only valid for DRM_XE_VM_BIND_OP_MAP operations, the BO
  *    handle MBZ, and the BO offset MBZ.
+ *  - %DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET - Can be used in combination with
+ *    %DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR to reset madvises when the underlying
+ *    CPU address space range is unmapped (typically with munmap(2) or brk(2)).
+ *    The madvise values set with &DRM_IOCTL_XE_MADVISE are reset to the values
+ *    that were present immediately after the &DRM_IOCTL_XE_VM_BIND.
+ *    The reset GPU virtual address range is the intersection of the range bound
+ *    using &DRM_IOCTL_XE_VM_BIND and the virtual CPU address space range
+ *    unmapped.
+ *    This functionality is present to mimic the behaviour of CPU address space
+ *    madvises set using madvise(2), which are typically reset on unmap.
+ *    Note: free(3) may or may not call munmap(2) and/or brk(2), and may thus
+ *    not invoke autoreset. Neither will stack variables going out of scope.
+ *    Therefore it's recommended to always explicitly reset the madvises when
+ *    freeing the memory backing a region used in a &DRM_IOCTL_XE_MADVISE call.
+ *
+ * The @prefetch_mem_region_instance for %DRM_XE_VM_BIND_OP_PREFETCH can also be:
+ *  - %DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC, which ensures prefetching occurs in
+ *    the memory region advised by madvise.
  */
 struct drm_xe_vm_bind_op {
 	/** @extensions: Pointer to the first extension struct, if any */
@@ -1105,9 +1137,11 @@ struct drm_xe_vm_bind_op {
 #define DRM_XE_VM_BIND_FLAG_DUMPABLE	(1 << 3)
 #define DRM_XE_VM_BIND_FLAG_CHECK_PXP	(1 << 4)
 #define DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR	(1 << 5)
+#define DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET	(1 << 6)
 	/** @flags: Bind flags */
 	__u32 flags;
 
+#define DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC	-1
 	/**
 	 * @prefetch_mem_region_instance: Memory region to prefetch VMA to.
 	 * It is a region instance, not a mask.
@@ -1429,6 +1463,7 @@ struct drm_xe_exec {
 	/** @exec_queue_id: Exec queue ID for the batch buffer */
 	__u32 exec_queue_id;
 
+#define DRM_XE_MAX_SYNCS 1024
 	/** @num_syncs: Amount of struct drm_xe_sync in array. */
 	__u32 num_syncs;
 
@@ -1974,6 +2009,271 @@ struct drm_xe_query_eu_stall {
 	__u64 sampling_rates[];
 };
 
+/**
+ * struct drm_xe_madvise - Input of &DRM_IOCTL_XE_MADVISE
+ *
+ * This structure is used to set memory attributes for a virtual address range
+ * in a VM. The type of attribute is specified by @type, and the corresponding
+ * union member is used to provide additional parameters for @type.
+ *
+ * Supported attribute types:
+ *  - DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC: Set preferred memory location.
+ *  - DRM_XE_MEM_RANGE_ATTR_ATOMIC: Set atomic access policy.
+ *  - DRM_XE_MEM_RANGE_ATTR_PAT: Set page attribute table index.
+ *
+ * Example:
+ *
+ * .. code-block:: C
+ *
+ *    struct drm_xe_madvise madvise = {
+ *         .vm_id = vm_id,
+ *         .start = 0x100000,
+ *         .range = 0x2000,
+ *         .type = DRM_XE_MEM_RANGE_ATTR_ATOMIC,
+ *         .atomic_val = DRM_XE_ATOMIC_DEVICE,
+ *    };
+ *
+ *    ioctl(fd, DRM_IOCTL_XE_MADVISE, &madvise);
+ *
+ */
+struct drm_xe_madvise {
+	/** @extensions: Pointer to the first extension struct, if any */
+	__u64 extensions;
+
+	/** @start: start of the virtual address range */
+	__u64 start;
+
+	/** @range: size of the virtual address range */
+	__u64 range;
+
+	/** @vm_id: vm_id of the virtual range */
+	__u32 vm_id;
+
+#define DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC	0
+#define DRM_XE_MEM_RANGE_ATTR_ATOMIC		1
+#define DRM_XE_MEM_RANGE_ATTR_PAT		2
+	/** @type: type of attribute */
+	__u32 type;
+
+	union {
+		/**
+		 * @preferred_mem_loc: preferred memory location
+		 *
+		 * Used when @type == DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC
+		 *
+		 * Supported values for @preferred_mem_loc.devmem_fd:
+		 *  - DRM_XE_PREFERRED_LOC_DEFAULT_DEVICE: set vram of fault tile as preferred loc
+		 *  - DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM: set smem as preferred loc
+		 *
+		 * Supported values for @preferred_mem_loc.migration_policy:
+		 *  - DRM_XE_MIGRATE_ALL_PAGES
+		 *  - DRM_XE_MIGRATE_ONLY_SYSTEM_PAGES
+		 */
+		struct {
+#define DRM_XE_PREFERRED_LOC_DEFAULT_DEVICE	0
+#define DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM	-1
+			/** @preferred_mem_loc.devmem_fd: fd for preferred loc */
+			__u32 devmem_fd;
+
+#define DRM_XE_MIGRATE_ALL_PAGES		0
+#define DRM_XE_MIGRATE_ONLY_SYSTEM_PAGES	1
+			/** @preferred_mem_loc.migration_policy: Page migration policy */
+			__u16 migration_policy;
+
+			/** @preferred_mem_loc.pad : MBZ */
+			__u16 pad;
+
+			/** @preferred_mem_loc.reserved : Reserved */
+			__u64 reserved;
+		} preferred_mem_loc;
+
+		/**
+		 * @atomic: Atomic access policy
+		 *
+		 * Used when @type == DRM_XE_MEM_RANGE_ATTR_ATOMIC.
+		 *
+		 * Supported values for @atomic.val:
+		 *  - DRM_XE_ATOMIC_UNDEFINED: Undefined or default behaviour.
+		 *    Support both GPU and CPU atomic operations for system allocator.
+		 *    Support GPU atomic operations for normal(bo) allocator.
+		 *  - DRM_XE_ATOMIC_DEVICE: Support GPU atomic operations.
+		 *  - DRM_XE_ATOMIC_GLOBAL: Support both GPU and CPU atomic operations.
+		 *  - DRM_XE_ATOMIC_CPU: Support CPU atomic only, no GPU atomics supported.
+		 */
+		struct {
+#define DRM_XE_ATOMIC_UNDEFINED	0
+#define DRM_XE_ATOMIC_DEVICE	1
+#define DRM_XE_ATOMIC_GLOBAL	2
+#define DRM_XE_ATOMIC_CPU	3
+			/** @atomic.val: value of atomic operation */
+			__u32 val;
+
+			/** @atomic.pad: MBZ */
+			__u32 pad;
+
+			/** @atomic.reserved: Reserved */
+			__u64 reserved;
+		} atomic;
+
+		/**
+		 * @pat_index: Page attribute table index
+		 *
+		 * Used when @type == DRM_XE_MEM_RANGE_ATTR_PAT.
+		 */
+		struct {
+			/** @pat_index.val: PAT index value */
+			__u32 val;
+
+			/** @pat_index.pad: MBZ */
+			__u32 pad;
+
+			/** @pat_index.reserved: Reserved */
+			__u64 reserved;
+		} pat_index;
+	};
+
+	/** @reserved: Reserved */
+	__u64 reserved[2];
+};
+
+/**
+ * struct drm_xe_mem_range_attr - Output of &DRM_IOCTL_XE_VM_QUERY_MEM_RANGES_ATTRS
+ *
+ * This structure is provided by userspace and filled by KMD in response to the
+ * DRM_IOCTL_XE_VM_QUERY_MEM_RANGES_ATTRS ioctl. It describes memory attributes of
+ * a memory ranges within a user specified address range in a VM.
+ *
+ * The structure includes information such as atomic access policy,
+ * page attribute table (PAT) index, and preferred memory location.
+ * Userspace allocates an array of these structures and passes a pointer to the
+ * ioctl to retrieve attributes for each memory ranges
+ *
+ * @extensions: Pointer to the first extension struct, if any
+ * @start: Start address of the memory range
+ * @end: End address of the virtual memory range
+ *
+ */
+struct drm_xe_mem_range_attr {
+	 /** @extensions: Pointer to the first extension struct, if any */
+	__u64 extensions;
+
+	/** @start: start of the memory range */
+	__u64 start;
+
+	/** @end: end of the memory range */
+	__u64 end;
+
+	/** @preferred_mem_loc: preferred memory location */
+	struct {
+		/** @preferred_mem_loc.devmem_fd: fd for preferred loc */
+		__u32 devmem_fd;
+
+		/** @preferred_mem_loc.migration_policy: Page migration policy */
+		__u32 migration_policy;
+	} preferred_mem_loc;
+
+	/** @atomic: Atomic access policy */
+	struct {
+		/** @atomic.val: atomic attribute */
+		__u32 val;
+
+		/** @atomic.reserved: Reserved */
+		__u32 reserved;
+	} atomic;
+
+	 /** @pat_index: Page attribute table index */
+	struct {
+		/** @pat_index.val: PAT index */
+		__u32 val;
+
+		/** @pat_index.reserved: Reserved */
+		__u32 reserved;
+	} pat_index;
+
+	/** @reserved: Reserved */
+	__u64 reserved[2];
+};
+
+/**
+ * struct drm_xe_vm_query_mem_range_attr - Input of &DRM_IOCTL_XE_VM_QUERY_MEM_ATTRIBUTES
+ *
+ * This structure is used to query memory attributes of memory regions
+ * within a user specified address range in a VM. It provides detailed
+ * information about each memory range, including atomic access policy,
+ * page attribute table (PAT) index, and preferred memory location.
+ *
+ * Userspace first calls the ioctl with @num_mem_ranges = 0,
+ * @sizeof_mem_ranges_attr = 0 and @vector_of_vma_mem_attr = NULL to retrieve
+ * the number of memory regions and size of each memory range attribute.
+ * Then, it allocates a buffer of that size and calls the ioctl again to fill
+ * the buffer with memory range attributes.
+ *
+ * If second call fails with -ENOSPC, it means memory ranges changed between
+ * first call and now, retry IOCTL again with @num_mem_ranges = 0,
+ * @sizeof_mem_ranges_attr = 0 and @vector_of_vma_mem_attr = NULL followed by
+ * Second ioctl call.
+ *
+ * Example:
+ *
+ * .. code-block:: C
+ *
+ *    struct drm_xe_vm_query_mem_range_attr query = {
+ *         .vm_id = vm_id,
+ *         .start = 0x100000,
+ *         .range = 0x2000,
+ *     };
+ *
+ *    // First ioctl call to get num of mem regions and sizeof each attribute
+ *    ioctl(fd, DRM_IOCTL_XE_VM_QUERY_MEM_RANGE_ATTRS, &query);
+ *
+ *    // Allocate buffer for the memory region attributes
+ *    void *ptr = malloc(query.num_mem_ranges * query.sizeof_mem_range_attr);
+ *    void *ptr_start = ptr;
+ *
+ *    query.vector_of_mem_attr = (uintptr_t)ptr;
+ *
+ *    // Second ioctl call to actually fill the memory attributes
+ *    ioctl(fd, DRM_IOCTL_XE_VM_QUERY_MEM_RANGE_ATTRS, &query);
+ *
+ *    // Iterate over the returned memory region attributes
+ *    for (unsigned int i = 0; i < query.num_mem_ranges; ++i) {
+ *       struct drm_xe_mem_range_attr *attr = (struct drm_xe_mem_range_attr *)ptr;
+ *
+ *       // Do something with attr
+ *
+ *       // Move pointer by one entry
+ *       ptr += query.sizeof_mem_range_attr;
+ *     }
+ *
+ *    free(ptr_start);
+ */
+struct drm_xe_vm_query_mem_range_attr {
+	/** @extensions: Pointer to the first extension struct, if any */
+	__u64 extensions;
+
+	/** @vm_id: vm_id of the virtual range */
+	__u32 vm_id;
+
+	/** @num_mem_ranges: number of mem_ranges in range */
+	__u32 num_mem_ranges;
+
+	/** @start: start of the virtual address range */
+	__u64 start;
+
+	/** @range: size of the virtual address range */
+	__u64 range;
+
+	/** @sizeof_mem_range_attr: size of struct drm_xe_mem_range_attr */
+	__u64 sizeof_mem_range_attr;
+
+	/** @vector_of_mem_attr: userptr to array of struct drm_xe_mem_range_attr */
+	__u64 vector_of_mem_attr;
+
+	/** @reserved: Reserved */
+	__u64 reserved[2];
+
+};
+
 #if defined(__cplusplus)
 }
 #endif
diff --git a/lib/libc/include/any-linux-any/linux/acrn.h b/lib/libc/include/any-linux-any/linux/acrn.h
index 02239d21b2e8e060d9c4f1a179fb26d77f607e1c..b2270d3d8fa6243e15f53e6b7e766e9a31f4ab87 100644
--- a/lib/libc/include/any-linux-any/linux/acrn.h
+++ b/lib/libc/include/any-linux-any/linux/acrn.h
@@ -418,26 +418,32 @@ struct acrn_pcidev {
 };
 
 /**
- * struct acrn_mmiodev - Info for assigning or de-assigning a MMIO device
- * @name:			Name of the MMIO device.
- * @res[].user_vm_pa:		Physical address of User VM of the MMIO region
- *				for the MMIO device.
- * @res[].service_vm_pa:	Physical address of Service VM of the MMIO
- *				region for the MMIO device.
- * @res[].size:			Size of the MMIO region for the MMIO device.
- * @res[].mem_type:		Memory type of the MMIO region for the MMIO
- *				device.
+ * struct acrn_mmio_dev_res - MMIO device resource description
+ * @user_vm_pa:		Physical address of User VM of the MMIO region
+ *			for the MMIO device.
+ * @service_vm_pa:	Physical address of Service VM of the MMIO
+ *			region for the MMIO device.
+ * @size:		Size of the MMIO region for the MMIO device.
+ * @mem_type:		Memory type of the MMIO region for the MMIO
+ *			device.
+ */
+struct acrn_mmio_dev_res {
+	__u64	user_vm_pa;
+	__u64	service_vm_pa;
+	__u64	size;
+	__u64	mem_type;
+};
+
+/**
+ * struct acrn_mmiodev - Info for assigning or de-assigning an MMIO device
+ * @name:	Name of the MMIO device.
+ * @res:	Array of MMIO device descriptions
  *
  * This structure will be passed to hypervisor directly.
  */
 struct acrn_mmiodev {
 	__u8	name[8];
-	struct {
-		__u64	user_vm_pa;
-		__u64	service_vm_pa;
-		__u64	size;
-		__u64	mem_type;
-	} res[ACRN_MMIODEV_RES_NUM];
+	struct acrn_mmio_dev_res res[ACRN_MMIODEV_RES_NUM];
 };
 
 /**
diff --git a/lib/libc/include/any-linux-any/linux/android/binder.h b/lib/libc/include/any-linux-any/linux/android/binder.h
index 78c2f377ad399d23c38b0202ef1d51bdbf4af95d..c4e9ae0798eb6d56a9dd01f13d4c939e05dc24ae 100644
--- a/lib/libc/include/any-linux-any/linux/android/binder.h
+++ b/lib/libc/include/any-linux-any/linux/android/binder.h
@@ -38,7 +38,7 @@ enum {
 	BINDER_TYPE_PTR		= B_PACK_CHARS('p', 't', '*', B_TYPE_LARGE),
 };
 
-enum {
+enum flat_binder_object_flags {
 	FLAT_BINDER_FLAG_PRIORITY_MASK = 0xff,
 	FLAT_BINDER_FLAG_ACCEPTS_FDS = 0x100,
 
diff --git a/lib/libc/include/any-linux-any/linux/android/binder_netlink.h b/lib/libc/include/any-linux-any/linux/android/binder_netlink.h
new file mode 100644
index 0000000000000000000000000000000000000000..41f2dc8f87b16330719805e8cb17618852ed645f
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/android/binder_netlink.h
@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/binder.yaml */
+/* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
+
+#ifndef _LINUX_ANDROID_BINDER_NETLINK_H
+#define _LINUX_ANDROID_BINDER_NETLINK_H
+
+#define BINDER_FAMILY_NAME	"binder"
+#define BINDER_FAMILY_VERSION	1
+
+enum {
+	BINDER_A_REPORT_ERROR = 1,
+	BINDER_A_REPORT_CONTEXT,
+	BINDER_A_REPORT_FROM_PID,
+	BINDER_A_REPORT_FROM_TID,
+	BINDER_A_REPORT_TO_PID,
+	BINDER_A_REPORT_TO_TID,
+	BINDER_A_REPORT_IS_REPLY,
+	BINDER_A_REPORT_FLAGS,
+	BINDER_A_REPORT_CODE,
+	BINDER_A_REPORT_DATA_SIZE,
+
+	__BINDER_A_REPORT_MAX,
+	BINDER_A_REPORT_MAX = (__BINDER_A_REPORT_MAX - 1)
+};
+
+enum {
+	BINDER_CMD_REPORT = 1,
+
+	__BINDER_CMD_MAX,
+	BINDER_CMD_MAX = (__BINDER_CMD_MAX - 1)
+};
+
+#define BINDER_MCGRP_REPORT	"report"
+
+#endif /* _LINUX_ANDROID_BINDER_NETLINK_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/aspeed-video.h b/lib/libc/include/any-linux-any/linux/aspeed-video.h
index 0dbdd4a822d7bd45c1611e0bf973319c10f8ab9a..82e400673161649c9408736c2574d63cb7128d95 100644
--- a/lib/libc/include/any-linux-any/linux/aspeed-video.h
+++ b/lib/libc/include/any-linux-any/linux/aspeed-video.h
@@ -8,6 +8,13 @@
 
 #include <linux/v4l2-controls.h>
 
+/* aspeed video's input types */
+enum aspeed_video_input {
+	VIDEO_INPUT_VGA = 0,
+	VIDEO_INPUT_GFX,
+	VIDEO_INPUT_MAX
+};
+
 #define V4L2_CID_ASPEED_HQ_MODE			(V4L2_CID_USER_ASPEED_BASE  + 1)
 #define V4L2_CID_ASPEED_HQ_JPEG_QUALITY		(V4L2_CID_USER_ASPEED_BASE  + 2)
 
diff --git a/lib/libc/include/any-linux-any/linux/audit.h b/lib/libc/include/any-linux-any/linux/audit.h
index 11ebd0e60bde22aced3dfa018f2105f209e530dd..fd93ab126e39a896dd7216fb7e70e401ab2aa81b 100644
--- a/lib/libc/include/any-linux-any/linux/audit.h
+++ b/lib/libc/include/any-linux-any/linux/audit.h
@@ -148,6 +148,8 @@
 #define AUDIT_IPE_POLICY_LOAD	1422	/* IPE policy load */
 #define AUDIT_LANDLOCK_ACCESS	1423	/* Landlock denial */
 #define AUDIT_LANDLOCK_DOMAIN	1424	/* Landlock domain status */
+#define AUDIT_MAC_TASK_CONTEXTS	1425	/* Multiple LSM task contexts */
+#define AUDIT_MAC_OBJ_CONTEXTS	1426	/* Multiple LSM objext contexts */
 
 #define AUDIT_FIRST_KERN_ANOM_MSG   1700
 #define AUDIT_LAST_KERN_ANOM_MSG    1799
diff --git a/lib/libc/include/any-linux-any/linux/blktrace_api.h b/lib/libc/include/any-linux-any/linux/blktrace_api.h
index b3799fb2cf8e64c17940b589fe312c0c95853afa..b8c1cf49c6c52e63401fbe455576851ab85791d3 100644
--- a/lib/libc/include/any-linux-any/linux/blktrace_api.h
+++ b/lib/libc/include/any-linux-any/linux/blktrace_api.h
@@ -26,11 +26,22 @@ enum blktrace_cat {
 	BLK_TC_DRV_DATA	= 1 << 14,	/* binary per-driver data */
 	BLK_TC_FUA	= 1 << 15,	/* fua requests */
 
-	BLK_TC_END	= 1 << 15,	/* we've run out of bits! */
+	BLK_TC_END_V1	= 1 << 15,	/* we've run out of bits! */
+
+	BLK_TC_ZONE_APPEND	= 1ull << 16,  	/* zone append */
+	BLK_TC_ZONE_RESET	= 1ull << 17,	/* zone reset */
+	BLK_TC_ZONE_RESET_ALL	= 1ull << 18,	/* zone reset all */
+	BLK_TC_ZONE_FINISH	= 1ull << 19,	/* zone finish */
+	BLK_TC_ZONE_OPEN	= 1ull << 20,	/* zone open */
+	BLK_TC_ZONE_CLOSE	= 1ull << 21,	/* zone close */
+
+	BLK_TC_WRITE_ZEROES	= 1ull << 22,	/* write-zeroes */
+
+	BLK_TC_END_V2		= 1ull << 22,
 };
 
 #define BLK_TC_SHIFT		(16)
-#define BLK_TC_ACT(act)		((act) << BLK_TC_SHIFT)
+#define BLK_TC_ACT(act)		((u64)(act) << BLK_TC_SHIFT)
 
 /*
  * Basic trace actions
@@ -53,6 +64,8 @@ enum blktrace_act {
 	__BLK_TA_REMAP,			/* bio was remapped */
 	__BLK_TA_ABORT,			/* request aborted */
 	__BLK_TA_DRV_DATA,		/* driver-specific binary data */
+	__BLK_TA_ZONE_PLUG,		/* zone write plug was plugged */
+	__BLK_TA_ZONE_UNPLUG,		/* zone write plug was unplugged */
 	__BLK_TA_CGROUP = 1 << 8,	/* from a cgroup*/
 };
 
@@ -88,12 +101,19 @@ enum blktrace_notify {
 #define BLK_TA_ABORT		(__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE))
 #define BLK_TA_DRV_DATA	(__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA))
 
+#define BLK_TA_ZONE_APPEND	(__BLK_TA_COMPLETE |\
+				 BLK_TC_ACT(BLK_TC_ZONE_APPEND))
+#define BLK_TA_ZONE_PLUG	(__BLK_TA_ZONE_PLUG | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_ZONE_UNPLUG	(__BLK_TA_ZONE_UNPLUG |\
+				 BLK_TC_ACT(BLK_TC_QUEUE))
+
 #define BLK_TN_PROCESS		(__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY))
 #define BLK_TN_TIMESTAMP	(__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY))
 #define BLK_TN_MESSAGE		(__BLK_TN_MESSAGE | BLK_TC_ACT(BLK_TC_NOTIFY))
 
 #define BLK_IO_TRACE_MAGIC	0x65617400
 #define BLK_IO_TRACE_VERSION	0x07
+#define BLK_IO_TRACE2_VERSION	0x08
 
 /*
  * The trace itself
@@ -113,6 +133,21 @@ struct blk_io_trace {
 	/* cgroup id will be stored here if exists */
 };
 
+struct blk_io_trace2 {
+	__u32 magic;		/* MAGIC << 8 | BLK_IO_TRACE2_VERSION */
+	__u32 sequence;		/* event number */
+	__u64 time;		/* in nanoseconds */
+	__u64 sector;		/* disk offset */
+	__u32 bytes;		/* transfer length */
+	__u32 pid;		/* who did it */
+	__u64 action;		/* what happened */
+	__u32 device;		/* device number */
+	__u32 cpu;		/* on what cpu did it happen */
+	__u16 error;		/* completion error */
+	__u16 pdu_len;		/* length of data after this trace */
+	__u8 pad[12];
+	/* cgroup id will be stored here if it exists */
+};
 /*
  * The remap event
  */
@@ -129,6 +164,7 @@ enum {
 };
 
 #define BLKTRACE_BDEV_SIZE	32
+#define BLKTRACE_BDEV_SIZE2	64
 
 /*
  * User setup structure passed with BLKTRACESETUP
@@ -143,4 +179,19 @@ struct blk_user_trace_setup {
 	__u32 pid;
 };
 
+/*
+ * User setup structure passed with BLKTRACESETUP2
+ */
+struct blk_user_trace_setup2 {
+	char name[BLKTRACE_BDEV_SIZE2];		/* output */
+	__u64 act_mask;				/* input */
+	__u32 buf_size;				/* input */
+	__u32 buf_nr;				/* input */
+	__u64 start_lba;
+	__u64 end_lba;
+	__u32 pid;
+	__u32 flags;		/* currently unused */
+	__u64 reserved[11];
+};
+
 #endif /* BLKTRACE_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/blkzoned.h b/lib/libc/include/any-linux-any/linux/blkzoned.h
index 3fd4d0ce2d1a2e43082c28d6da8135404519698b..07d4f4b49ff34f10f5aec3831a80474e31c9b9d0 100644
--- a/lib/libc/include/any-linux-any/linux/blkzoned.h
+++ b/lib/libc/include/any-linux-any/linux/blkzoned.h
@@ -48,6 +48,8 @@ enum blk_zone_type {
  *                      FINISH ZONE command.
  * @BLK_ZONE_COND_READONLY: The zone is read-only.
  * @BLK_ZONE_COND_OFFLINE: The zone is offline (sectors cannot be read/written).
+ * @BLK_ZONE_COND_ACTIVE: The zone is either implicitly open, explicitly open,
+ *			  or closed.
  *
  * The Zone Condition state machine in the ZBC/ZAC standards maps the above
  * deinitions as:
@@ -61,6 +63,13 @@ enum blk_zone_type {
  *
  * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should
  * be considered invalid.
+ *
+ * The condition BLK_ZONE_COND_ACTIVE is used only with cached zone reports.
+ * It is used to report any of the BLK_ZONE_COND_IMP_OPEN,
+ * BLK_ZONE_COND_EXP_OPEN and BLK_ZONE_COND_CLOSED conditions. Conversely, a
+ * regular zone report will never report a zone condition using
+ * BLK_ZONE_COND_ACTIVE and instead use the conditions BLK_ZONE_COND_IMP_OPEN,
+ * BLK_ZONE_COND_EXP_OPEN or BLK_ZONE_COND_CLOSED as reported by the device.
  */
 enum blk_zone_cond {
 	BLK_ZONE_COND_NOT_WP	= 0x0,
@@ -71,15 +80,29 @@ enum blk_zone_cond {
 	BLK_ZONE_COND_READONLY	= 0xD,
 	BLK_ZONE_COND_FULL	= 0xE,
 	BLK_ZONE_COND_OFFLINE	= 0xF,
+
+	BLK_ZONE_COND_ACTIVE	= 0xFF, /* added in Linux 6.19 */
+#define BLK_ZONE_COND_ACTIVE	BLK_ZONE_COND_ACTIVE
 };
 
 /**
  * enum blk_zone_report_flags - Feature flags of reported zone descriptors.
  *
- * @BLK_ZONE_REP_CAPACITY: Zone descriptor has capacity field.
+ * @BLK_ZONE_REP_CAPACITY: Output only. Indicates that zone descriptors in a
+ *			   zone report have a valid capacity field.
+ * @BLK_ZONE_REP_CACHED: Input only. Indicates that the zone report should be
+ *			 generated using cached zone information. In this case,
+ *			 the implicit open, explicit open and closed zone
+ *			 conditions are all reported with the
+ *			 BLK_ZONE_COND_ACTIVE condition.
  */
 enum blk_zone_report_flags {
-	BLK_ZONE_REP_CAPACITY	= (1 << 0),
+	/* Output flags */
+	BLK_ZONE_REP_CAPACITY	= (1U << 0),
+
+	/* Input flags */
+	BLK_ZONE_REP_CACHED	= (1U << 31), /* added in Linux 6.19 */
+#define BLK_ZONE_REP_CACHED	BLK_ZONE_REP_CACHED
 };
 
 /**
@@ -122,6 +145,10 @@ struct blk_zone {
  * @sector: starting sector of report
  * @nr_zones: IN maximum / OUT actual
  * @flags: one or more flags as defined by enum blk_zone_report_flags.
+ * @flags: one or more flags as defined by enum blk_zone_report_flags.
+ *	   With BLKREPORTZONE, this field is ignored as an input and is valid
+ *	   only as an output. Using BLKREPORTZONEV2, this field is used as both
+ *	   input and output.
  * @zones: Space to hold @nr_zones @zones entries on reply.
  *
  * The array of at most @nr_zones must follow this structure in memory.
@@ -148,9 +175,19 @@ struct blk_zone_range {
 /**
  * Zoned block device ioctl's:
  *
- * @BLKREPORTZONE: Get zone information. Takes a zone report as argument.
- *                 The zone report will start from the zone containing the
- *                 sector specified in the report request structure.
+ * @BLKREPORTZONE: Get zone information from a zoned device. Takes a zone report
+ *		   as argument. The zone report will start from the zone
+ *		   containing the sector specified in struct blk_zone_report.
+ *		   The flags field of struct blk_zone_report is used as an
+ *		   output only and ignored as an input.
+ *		   DEPRECATED, use BLKREPORTZONEV2 instead.
+ * @BLKREPORTZONEV2: Same as @BLKREPORTZONE but uses the flags field of
+ *		     struct blk_zone_report as an input, allowing to get a zone
+ *		     report using cached zone information if the flag
+ *		     BLK_ZONE_REP_CACHED is set. In such case, the zone report
+ *		     may include zones with the condition @BLK_ZONE_COND_ACTIVE
+ *		     (c.f. the description of this condition above for more
+ *		     details).
  * @BLKRESETZONE: Reset the write pointer of the zones in the specified
  *                sector range. The sector range must be zone aligned.
  * @BLKGETZONESZ: Get the device zone size in number of 512 B sectors.
@@ -169,5 +206,6 @@ struct blk_zone_range {
 #define BLKOPENZONE	_IOW(0x12, 134, struct blk_zone_range)
 #define BLKCLOSEZONE	_IOW(0x12, 135, struct blk_zone_range)
 #define BLKFINISHZONE	_IOW(0x12, 136, struct blk_zone_range)
+#define BLKREPORTZONEV2	_IOWR(0x12, 142, struct blk_zone_report)
 
 #endif /* _BLKZONED_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/bpf.h b/lib/libc/include/any-linux-any/linux/bpf.h
index a221b888155d952a5619345aa33d78c18759f4ae..eb4445bb243f8f93256601d8b08bac06b3943bcd 100644
--- a/lib/libc/include/any-linux-any/linux/bpf.h
+++ b/lib/libc/include/any-linux-any/linux/bpf.h
@@ -1026,6 +1026,7 @@ enum bpf_map_type {
 	BPF_MAP_TYPE_USER_RINGBUF,
 	BPF_MAP_TYPE_CGRP_STORAGE,
 	BPF_MAP_TYPE_ARENA,
+	BPF_MAP_TYPE_INSN_ARRAY,
 	__MAX_BPF_MAP_TYPE
 };
 
@@ -1430,6 +1431,9 @@ enum {
 
 /* Do not translate kernel bpf_arena pointers to user pointers */
 	BPF_F_NO_USER_CONV	= (1U << 18),
+
+/* Enable BPF ringbuf overwrite mode */
+	BPF_F_RB_OVERWRITE	= (1U << 19),
 };
 
 /* Flags for BPF_PROG_QUERY. */
@@ -1522,6 +1526,12 @@ union bpf_attr {
 		 * If provided, map_flags should have BPF_F_TOKEN_FD flag set.
 		 */
 		__s32	map_token_fd;
+
+		/* Hash of the program that has exclusive access to the map.
+		 */
+		__aligned_u64 excl_prog_hash;
+		/* Size of the passed excl_prog_hash. */
+		__u32 excl_prog_hash_size;
 	};
 
 	struct { /* anonymous struct used by BPF_MAP_*_ELEM and BPF_MAP_FREEZE commands */
@@ -1605,6 +1615,16 @@ union bpf_attr {
 		 * continuous.
 		 */
 		__u32		fd_array_cnt;
+		/* Pointer to a buffer containing the signature of the BPF
+		 * program.
+		 */
+		__aligned_u64   signature;
+		/* Size of the signature buffer in bytes. */
+		__u32 		signature_size;
+		/* ID of the kernel keyring to be used for signature
+		 * verification.
+		 */
+		__s32		keyring_id;
 	};
 
 	struct { /* anonymous struct used by BPF_OBJ_* commands */
@@ -4875,7 +4895,7 @@ union bpf_attr {
  *
  *		**-ENOENT** if the bpf_local_storage cannot be found.
  *
- * long bpf_d_path(struct path *path, char *buf, u32 sz)
+ * long bpf_d_path(const struct path *path, char *buf, u32 sz)
  *	Description
  *		Return full path for given **struct path** object, which
  *		needs to be the kernel BTF *path* object. The path is
@@ -5602,7 +5622,7 @@ union bpf_attr {
  *	Return
  *		*sk* if casting is valid, or **NULL** otherwise.
  *
- * long bpf_dynptr_from_mem(void *data, u32 size, u64 flags, struct bpf_dynptr *ptr)
+ * long bpf_dynptr_from_mem(void *data, u64 size, u64 flags, struct bpf_dynptr *ptr)
  *	Description
  *		Get a dynptr to local memory *data*.
  *
@@ -5645,7 +5665,7 @@ union bpf_attr {
  *	Return
  *		Nothing. Always succeeds.
  *
- * long bpf_dynptr_read(void *dst, u32 len, const struct bpf_dynptr *src, u32 offset, u64 flags)
+ * long bpf_dynptr_read(void *dst, u64 len, const struct bpf_dynptr *src, u64 offset, u64 flags)
  *	Description
  *		Read *len* bytes from *src* into *dst*, starting from *offset*
  *		into *src*.
@@ -5655,7 +5675,7 @@ union bpf_attr {
  *		of *src*'s data, -EINVAL if *src* is an invalid dynptr or if
  *		*flags* is not 0.
  *
- * long bpf_dynptr_write(const struct bpf_dynptr *dst, u32 offset, void *src, u32 len, u64 flags)
+ * long bpf_dynptr_write(const struct bpf_dynptr *dst, u64 offset, void *src, u64 len, u64 flags)
  *	Description
  *		Write *len* bytes from *src* into *dst*, starting from *offset*
  *		into *dst*.
@@ -5676,7 +5696,7 @@ union bpf_attr {
  *		is a read-only dynptr or if *flags* is not correct. For skb-type dynptrs,
  *		other errors correspond to errors returned by **bpf_skb_store_bytes**\ ().
  *
- * void *bpf_dynptr_data(const struct bpf_dynptr *ptr, u32 offset, u32 len)
+ * void *bpf_dynptr_data(const struct bpf_dynptr *ptr, u64 offset, u64 len)
  *	Description
  *		Get a pointer to the underlying dynptr data.
  *
@@ -6215,6 +6235,7 @@ enum {
 	BPF_RB_RING_SIZE = 1,
 	BPF_RB_CONS_POS = 2,
 	BPF_RB_PROD_POS = 3,
+	BPF_RB_OVERWRITE_POS = 4,
 };
 
 /* BPF ring buffer constants */
@@ -6666,6 +6687,8 @@ struct bpf_map_info {
 	__u32 btf_value_type_id;
 	__u32 btf_vmlinux_id;
 	__u64 map_extra;
+	__aligned_u64 hash;
+	__u32 hash_size;
 } __attribute__((aligned(8)));
 
 struct bpf_btf_info {
@@ -7182,6 +7205,8 @@ enum {
 	TCP_BPF_SYN_MAC         = 1007, /* Copy the MAC, IP[46], and TCP header */
 	TCP_BPF_SOCK_OPS_CB_FLAGS = 1008, /* Get or Set TCP sock ops flags */
 	SK_BPF_CB_FLAGS		= 1009, /* Get or set sock ops flags in socket */
+	SK_BPF_BYPASS_PROT_MEM	= 1010, /* Get or Set sk->sk_bypass_prot_mem */
+
 };
 
 enum {
@@ -7418,6 +7443,10 @@ struct bpf_timer {
 	__u64 __opaque[2];
 } __attribute__((aligned(8)));
 
+struct bpf_task_work {
+	__u64 __opaque;
+} __attribute__((aligned(8)));
+
 struct bpf_wq {
 	__u64 __opaque[2];
 } __attribute__((aligned(8)));
@@ -7623,4 +7652,24 @@ enum bpf_kfunc_flags {
 	BPF_F_PAD_ZEROS = (1ULL << 0),
 };
 
+/*
+ * Values of a BPF_MAP_TYPE_INSN_ARRAY entry must be of this type.
+ *
+ * Before the map is used the orig_off field should point to an
+ * instruction inside the program being loaded. The other fields
+ * must be set to 0.
+ *
+ * After the program is loaded, the xlated_off will be adjusted
+ * by the verifier to point to the index of the original instruction
+ * in the xlated program. If the instruction is deleted, it will
+ * be set to (u32)-1. The jitted_off will be set to the corresponding
+ * offset in the jitted image of the program.
+ */
+struct bpf_insn_array_value {
+	__u32 orig_off;
+	__u32 xlated_off;
+	__u32 jitted_off;
+	__u32 :32;
+};
+
 #endif /* __LINUX_BPF_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/btrfs.h b/lib/libc/include/any-linux-any/linux/btrfs.h
index b1d1e7726501df99d38a8eba5aeaced65ff859f7..aba1c89a0ba4d5b443b5a5c9329a2e063f7a501a 100644
--- a/lib/libc/include/any-linux-any/linux/btrfs.h
+++ b/lib/libc/include/any-linux-any/linux/btrfs.h
@@ -1097,6 +1097,12 @@ enum btrfs_err_code {
 	BTRFS_ERROR_DEV_RAID1C4_MIN_NOT_MET,
 };
 
+/* Flags for IOC_SHUTDOWN, must match XFS_FSOP_GOING_FLAGS_* flags. */
+#define BTRFS_SHUTDOWN_FLAGS_DEFAULT			0x0
+#define BTRFS_SHUTDOWN_FLAGS_LOGFLUSH			0x1
+#define BTRFS_SHUTDOWN_FLAGS_NOLOGFLUSH			0x2
+#define BTRFS_SHUTDOWN_FLAGS_LAST			0x3
+
 #define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \
 				   struct btrfs_ioctl_vol_args)
 #define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, \
@@ -1218,6 +1224,9 @@ enum btrfs_err_code {
 #define BTRFS_IOC_SUBVOL_SYNC_WAIT _IOW(BTRFS_IOCTL_MAGIC, 65, \
 					struct btrfs_ioctl_subvol_wait)
 
+/* Shutdown ioctl should follow XFS's interfaces, thus not using btrfs magic. */
+#define BTRFS_IOC_SHUTDOWN	_IOR('X', 125, __u32)
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/libc/include/any-linux-any/linux/can/netlink.h b/lib/libc/include/any-linux-any/linux/can/netlink.h
index 2890f7e44416a841a5d5b5a0dbecbce9d144d695..18fab11591090bcbe3290c049aa618ae6ee6bc28 100644
--- a/lib/libc/include/any-linux-any/linux/can/netlink.h
+++ b/lib/libc/include/any-linux-any/linux/can/netlink.h
@@ -5,6 +5,7 @@
  * Definitions for the CAN netlink interface
  *
  * Copyright (c) 2009 Wolfgang Grandegger <wg@grandegger.com>
+ * Copyright (c) 2021-2025 Vincent Mailhol <mailhol@kernel.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the version 2 of the GNU General Public License
@@ -101,8 +102,13 @@ struct can_ctrlmode {
 #define CAN_CTRLMODE_PRESUME_ACK	0x40	/* Ignore missing CAN ACKs */
 #define CAN_CTRLMODE_FD_NON_ISO		0x80	/* CAN FD in non-ISO mode */
 #define CAN_CTRLMODE_CC_LEN8_DLC	0x100	/* Classic CAN DLC option */
-#define CAN_CTRLMODE_TDC_AUTO		0x200	/* CAN transiver automatically calculates TDCV */
-#define CAN_CTRLMODE_TDC_MANUAL		0x400	/* TDCV is manually set up by user */
+#define CAN_CTRLMODE_TDC_AUTO		0x200	/* FD transceiver automatically calculates TDCV */
+#define CAN_CTRLMODE_TDC_MANUAL		0x400	/* FD TDCV is manually set up by user */
+#define CAN_CTRLMODE_RESTRICTED		0x800	/* Restricted operation mode */
+#define CAN_CTRLMODE_XL			0x1000	/* CAN XL mode */
+#define CAN_CTRLMODE_XL_TDC_AUTO	0x2000	/* XL transceiver automatically calculates TDCV */
+#define CAN_CTRLMODE_XL_TDC_MANUAL	0x4000	/* XL TDCV is manually set up by user */
+#define CAN_CTRLMODE_XL_TMS		0x8000	/* Transceiver Mode Switching */
 
 /*
  * CAN device statistics
@@ -129,15 +135,20 @@ enum {
 	IFLA_CAN_RESTART_MS,
 	IFLA_CAN_RESTART,
 	IFLA_CAN_BERR_COUNTER,
-	IFLA_CAN_DATA_BITTIMING,
-	IFLA_CAN_DATA_BITTIMING_CONST,
+	IFLA_CAN_DATA_BITTIMING, /* FD */
+	IFLA_CAN_DATA_BITTIMING_CONST, /* FD */
 	IFLA_CAN_TERMINATION,
 	IFLA_CAN_TERMINATION_CONST,
 	IFLA_CAN_BITRATE_CONST,
-	IFLA_CAN_DATA_BITRATE_CONST,
+	IFLA_CAN_DATA_BITRATE_CONST, /* FD */
 	IFLA_CAN_BITRATE_MAX,
-	IFLA_CAN_TDC,
+	IFLA_CAN_TDC, /* FD */
 	IFLA_CAN_CTRLMODE_EXT,
+	IFLA_CAN_XL_DATA_BITTIMING,
+	IFLA_CAN_XL_DATA_BITTIMING_CONST,
+	IFLA_CAN_XL_DATA_BITRATE_CONST,
+	IFLA_CAN_XL_TDC,
+	IFLA_CAN_XL_PWM,
 
 	/* add new constants above here */
 	__IFLA_CAN_MAX,
@@ -145,7 +156,7 @@ enum {
 };
 
 /*
- * CAN FD Transmitter Delay Compensation (TDC)
+ * CAN FD/XL Transmitter Delay Compensation (TDC)
  *
  * Please refer to struct can_tdc_const and can_tdc in
  * include/linux/can/bittiming.h for further details.
@@ -179,6 +190,29 @@ enum {
 	IFLA_CAN_CTRLMODE_MAX = __IFLA_CAN_CTRLMODE - 1
 };
 
+/*
+ * CAN FD/XL Pulse-Width Modulation (PWM)
+ *
+ * Please refer to struct can_pwm_const and can_pwm in
+ * include/linux/can/bittiming.h for further details.
+ */
+enum {
+	IFLA_CAN_PWM_UNSPEC,
+	IFLA_CAN_PWM_PWMS_MIN,	/* u32 */
+	IFLA_CAN_PWM_PWMS_MAX,	/* u32 */
+	IFLA_CAN_PWM_PWML_MIN,	/* u32 */
+	IFLA_CAN_PWM_PWML_MAX,	/* u32 */
+	IFLA_CAN_PWM_PWMO_MIN,	/* u32 */
+	IFLA_CAN_PWM_PWMO_MAX,	/* u32 */
+	IFLA_CAN_PWM_PWMS,	/* u32 */
+	IFLA_CAN_PWM_PWML,	/* u32 */
+	IFLA_CAN_PWM_PWMO,	/* u32 */
+
+	/* add new constants above here */
+	__IFLA_CAN_PWM,
+	IFLA_CAN_PWM_MAX = __IFLA_CAN_PWM - 1
+};
+
 /* u16 termination range: 1..65535 Ohms */
 #define CAN_TERMINATION_DISABLED 0
 
diff --git a/lib/libc/include/any-linux-any/linux/comedi.h b/lib/libc/include/any-linux-any/linux/comedi.h
index 0ef8eadde4a294b597bdf05b1a20b7f630f8884a..c30157b456e7ad3b15da7a68f34ed7ccbbd06d64 100644
--- a/lib/libc/include/any-linux-any/linux/comedi.h
+++ b/lib/libc/include/any-linux-any/linux/comedi.h
@@ -640,7 +640,7 @@ struct comedi_chaninfo {
 
 /**
  * struct comedi_rangeinfo - used to retrieve the range table for a channel
- * @range_type:		Encodes subdevice index (bits 27:24), channel index
+ * @range_type:		Encodes subdevice index (bits 31:24), channel index
  *			(bits 23:16) and range table length (bits 15:0).
  * @range_ptr:		Pointer to array of @struct comedi_krange to be filled
  *			in with the range table for the channel or subdevice.
diff --git a/lib/libc/include/any-linux-any/linux/dev_energymodel.h b/lib/libc/include/any-linux-any/linux/dev_energymodel.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e1c8f55bbbe48bd2772efc30a8178eacda642dc
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/dev_energymodel.h
@@ -0,0 +1,82 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/dev-energymodel.yaml */
+/* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
+
+#ifndef _LINUX_DEV_ENERGYMODEL_H
+#define _LINUX_DEV_ENERGYMODEL_H
+
+#define DEV_ENERGYMODEL_FAMILY_NAME	"dev-energymodel"
+#define DEV_ENERGYMODEL_FAMILY_VERSION	1
+
+/**
+ * enum dev_energymodel_perf_state_flags
+ * @DEV_ENERGYMODEL_PERF_STATE_FLAGS_PERF_STATE_INEFFICIENT: The performance
+ *   state is inefficient. There is in this perf-domain, another performance
+ *   state with a higher frequency but a lower or equal power cost.
+ */
+enum dev_energymodel_perf_state_flags {
+	DEV_ENERGYMODEL_PERF_STATE_FLAGS_PERF_STATE_INEFFICIENT = 1,
+};
+
+/**
+ * enum dev_energymodel_perf_domain_flags
+ * @DEV_ENERGYMODEL_PERF_DOMAIN_FLAGS_PERF_DOMAIN_MICROWATTS: The power values
+ *   are in micro-Watts or some other scale.
+ * @DEV_ENERGYMODEL_PERF_DOMAIN_FLAGS_PERF_DOMAIN_SKIP_INEFFICIENCIES: Skip
+ *   inefficient states when estimating energy consumption.
+ * @DEV_ENERGYMODEL_PERF_DOMAIN_FLAGS_PERF_DOMAIN_ARTIFICIAL: The power values
+ *   are artificial and might be created by platform missing real power
+ *   information.
+ */
+enum dev_energymodel_perf_domain_flags {
+	DEV_ENERGYMODEL_PERF_DOMAIN_FLAGS_PERF_DOMAIN_MICROWATTS = 1,
+	DEV_ENERGYMODEL_PERF_DOMAIN_FLAGS_PERF_DOMAIN_SKIP_INEFFICIENCIES = 2,
+	DEV_ENERGYMODEL_PERF_DOMAIN_FLAGS_PERF_DOMAIN_ARTIFICIAL = 4,
+};
+
+enum {
+	DEV_ENERGYMODEL_A_PERF_DOMAIN_PAD = 1,
+	DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID,
+	DEV_ENERGYMODEL_A_PERF_DOMAIN_FLAGS,
+	DEV_ENERGYMODEL_A_PERF_DOMAIN_CPUS,
+
+	__DEV_ENERGYMODEL_A_PERF_DOMAIN_MAX,
+	DEV_ENERGYMODEL_A_PERF_DOMAIN_MAX = (__DEV_ENERGYMODEL_A_PERF_DOMAIN_MAX - 1)
+};
+
+enum {
+	DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID = 1,
+	DEV_ENERGYMODEL_A_PERF_TABLE_PERF_STATE,
+
+	__DEV_ENERGYMODEL_A_PERF_TABLE_MAX,
+	DEV_ENERGYMODEL_A_PERF_TABLE_MAX = (__DEV_ENERGYMODEL_A_PERF_TABLE_MAX - 1)
+};
+
+enum {
+	DEV_ENERGYMODEL_A_PERF_STATE_PAD = 1,
+	DEV_ENERGYMODEL_A_PERF_STATE_PERFORMANCE,
+	DEV_ENERGYMODEL_A_PERF_STATE_FREQUENCY,
+	DEV_ENERGYMODEL_A_PERF_STATE_POWER,
+	DEV_ENERGYMODEL_A_PERF_STATE_COST,
+	DEV_ENERGYMODEL_A_PERF_STATE_FLAGS,
+
+	__DEV_ENERGYMODEL_A_PERF_STATE_MAX,
+	DEV_ENERGYMODEL_A_PERF_STATE_MAX = (__DEV_ENERGYMODEL_A_PERF_STATE_MAX - 1)
+};
+
+enum {
+	DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS = 1,
+	DEV_ENERGYMODEL_CMD_GET_PERF_TABLE,
+	DEV_ENERGYMODEL_CMD_PERF_DOMAIN_CREATED,
+	DEV_ENERGYMODEL_CMD_PERF_DOMAIN_UPDATED,
+	DEV_ENERGYMODEL_CMD_PERF_DOMAIN_DELETED,
+
+	__DEV_ENERGYMODEL_CMD_MAX,
+	DEV_ENERGYMODEL_CMD_MAX = (__DEV_ENERGYMODEL_CMD_MAX - 1)
+};
+
+#define DEV_ENERGYMODEL_MCGRP_EVENT	"event"
+
+#endif /* _LINUX_DEV_ENERGYMODEL_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/devlink.h b/lib/libc/include/any-linux-any/linux/devlink.h
index 5c3318cc97449a23e63d946eb5795f34e63aead8..621e00d943e7ee9fc136586c2a80af2bdaed77f1 100644
--- a/lib/libc/include/any-linux-any/linux/devlink.h
+++ b/lib/libc/include/any-linux-any/linux/devlink.h
@@ -181,6 +181,7 @@ enum devlink_sb_threshold_type {
 enum devlink_eswitch_mode {
 	DEVLINK_ESWITCH_MODE_LEGACY,
 	DEVLINK_ESWITCH_MODE_SWITCHDEV,
+	DEVLINK_ESWITCH_MODE_SWITCHDEV_INACTIVE,
 };
 
 enum devlink_eswitch_inline_mode {
@@ -636,6 +637,11 @@ enum devlink_attr {
 
 	DEVLINK_ATTR_RATE_TC_BWS,		/* nested */
 
+	DEVLINK_ATTR_HEALTH_REPORTER_BURST_PERIOD,	/* u64 */
+
+	DEVLINK_ATTR_PARAM_VALUE_DEFAULT,	/* dynamic */
+	DEVLINK_ATTR_PARAM_RESET_DEFAULT,	/* flag */
+
 	/* Add new attributes above here, update the spec in
 	 * Documentation/netlink/specs/devlink.yaml and re-generate
 	 * net/devlink/netlink_gen.c.
diff --git a/lib/libc/include/any-linux-any/linux/dpll.h b/lib/libc/include/any-linux-any/linux/dpll.h
index 4e69e1087a9fdd81d84bf9d23340961432cca64b..2e62513f271dee5b174660869bc416a9b41842c5 100644
--- a/lib/libc/include/any-linux-any/linux/dpll.h
+++ b/lib/libc/include/any-linux-any/linux/dpll.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/dpll.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_DPLL_H
 #define _LINUX_DPLL_H
@@ -216,6 +217,7 @@ enum dpll_a {
 	DPLL_A_LOCK_STATUS_ERROR,
 	DPLL_A_CLOCK_QUALITY_LEVEL,
 	DPLL_A_PHASE_OFFSET_MONITOR,
+	DPLL_A_PHASE_OFFSET_AVG_FACTOR,
 
 	__DPLL_A_MAX,
 	DPLL_A_MAX = (__DPLL_A_MAX - 1)
@@ -250,6 +252,7 @@ enum dpll_a_pin {
 	DPLL_A_PIN_ESYNC_FREQUENCY_SUPPORTED,
 	DPLL_A_PIN_ESYNC_PULSE,
 	DPLL_A_PIN_REFERENCE_SYNC,
+	DPLL_A_PIN_PHASE_ADJUST_GRAN,
 
 	__DPLL_A_PIN_MAX,
 	DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1)
diff --git a/lib/libc/include/any-linux-any/linux/ethtool.h b/lib/libc/include/any-linux-any/linux/ethtool.h
index aacdee5fc3e9d3e716fb0a10e3c636121191e8cd..2186d2f2d2190d0240b0a8f56508595ae17df15d 100644
--- a/lib/libc/include/any-linux-any/linux/ethtool.h
+++ b/lib/libc/include/any-linux-any/linux/ethtool.h
@@ -2075,6 +2075,10 @@ enum ethtool_link_mode_bit_indices {
 	ETHTOOL_LINK_MODE_800000baseDR4_2_Full_BIT	 = 118,
 	ETHTOOL_LINK_MODE_800000baseSR4_Full_BIT	 = 119,
 	ETHTOOL_LINK_MODE_800000baseVR4_Full_BIT	 = 120,
+	ETHTOOL_LINK_MODE_1600000baseCR8_Full_BIT	 = 121,
+	ETHTOOL_LINK_MODE_1600000baseKR8_Full_BIT	 = 122,
+	ETHTOOL_LINK_MODE_1600000baseDR8_Full_BIT	 = 123,
+	ETHTOOL_LINK_MODE_1600000baseDR8_2_Full_BIT	 = 124,
 
 	/* must be last entry */
 	__ETHTOOL_LINK_MODE_MASK_NBITS
@@ -2188,6 +2192,7 @@ enum ethtool_link_mode_bit_indices {
 #define SPEED_200000		200000
 #define SPEED_400000		400000
 #define SPEED_800000		800000
+#define SPEED_1600000		1600000
 
 #define SPEED_UNKNOWN		-1
 
@@ -2378,6 +2383,7 @@ enum {
 #define	RXH_L4_B_0_1	(1 << 6) /* src port in case of TCP/UDP/SCTP */
 #define	RXH_L4_B_2_3	(1 << 7) /* dst port in case of TCP/UDP/SCTP */
 #define	RXH_GTP_TEID	(1 << 8) /* teid in case of GTP */
+#define	RXH_IP6_FL	(1 << 9) /* IPv6 flow label */
 #define	RXH_DISCARD	(1 << 31)
 
 #define	RX_CLS_FLOW_DISC	0xffffffffffffffffULL
diff --git a/lib/libc/include/any-linux-any/linux/ethtool_netlink_generated.h b/lib/libc/include/any-linux-any/linux/ethtool_netlink_generated.h
index 35042d7278070dc436cdb181508cff3ce434757a..2ab973732a9c37896dd3bf3602870aee7569cc6c 100644
--- a/lib/libc/include/any-linux-any/linux/ethtool_netlink_generated.h
+++ b/lib/libc/include/any-linux-any/linux/ethtool_netlink_generated.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/ethtool.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_ETHTOOL_NETLINK_GENERATED_H
 #define _LINUX_ETHTOOL_NETLINK_GENERATED_H
@@ -561,12 +562,24 @@ enum {
 	ETHTOOL_A_TUNNEL_INFO_MAX = (__ETHTOOL_A_TUNNEL_INFO_CNT - 1)
 };
 
+enum {
+	ETHTOOL_A_FEC_HIST_PAD = 1,
+	ETHTOOL_A_FEC_HIST_BIN_LOW,
+	ETHTOOL_A_FEC_HIST_BIN_HIGH,
+	ETHTOOL_A_FEC_HIST_BIN_VAL,
+	ETHTOOL_A_FEC_HIST_BIN_VAL_PER_LANE,
+
+	__ETHTOOL_A_FEC_HIST_CNT,
+	ETHTOOL_A_FEC_HIST_MAX = (__ETHTOOL_A_FEC_HIST_CNT - 1)
+};
+
 enum {
 	ETHTOOL_A_FEC_STAT_UNSPEC,
 	ETHTOOL_A_FEC_STAT_PAD,
 	ETHTOOL_A_FEC_STAT_CORRECTED,
 	ETHTOOL_A_FEC_STAT_UNCORR,
 	ETHTOOL_A_FEC_STAT_CORR_BITS,
+	ETHTOOL_A_FEC_STAT_HIST,
 
 	__ETHTOOL_A_FEC_STAT_CNT,
 	ETHTOOL_A_FEC_STAT_MAX = (__ETHTOOL_A_FEC_STAT_CNT - 1)
@@ -791,6 +804,39 @@ enum {
 	ETHTOOL_A_PSE_NTF_MAX = (__ETHTOOL_A_PSE_NTF_CNT - 1)
 };
 
+enum {
+	ETHTOOL_A_MSE_CAPABILITIES_MAX_AVERAGE_MSE = 1,
+	ETHTOOL_A_MSE_CAPABILITIES_MAX_PEAK_MSE,
+	ETHTOOL_A_MSE_CAPABILITIES_REFRESH_RATE_PS,
+	ETHTOOL_A_MSE_CAPABILITIES_NUM_SYMBOLS,
+
+	__ETHTOOL_A_MSE_CAPABILITIES_CNT,
+	ETHTOOL_A_MSE_CAPABILITIES_MAX = (__ETHTOOL_A_MSE_CAPABILITIES_CNT - 1)
+};
+
+enum {
+	ETHTOOL_A_MSE_SNAPSHOT_AVERAGE_MSE = 1,
+	ETHTOOL_A_MSE_SNAPSHOT_PEAK_MSE,
+	ETHTOOL_A_MSE_SNAPSHOT_WORST_PEAK_MSE,
+
+	__ETHTOOL_A_MSE_SNAPSHOT_CNT,
+	ETHTOOL_A_MSE_SNAPSHOT_MAX = (__ETHTOOL_A_MSE_SNAPSHOT_CNT - 1)
+};
+
+enum {
+	ETHTOOL_A_MSE_HEADER = 1,
+	ETHTOOL_A_MSE_CAPABILITIES,
+	ETHTOOL_A_MSE_CHANNEL_A,
+	ETHTOOL_A_MSE_CHANNEL_B,
+	ETHTOOL_A_MSE_CHANNEL_C,
+	ETHTOOL_A_MSE_CHANNEL_D,
+	ETHTOOL_A_MSE_WORST_CHANNEL,
+	ETHTOOL_A_MSE_LINK,
+
+	__ETHTOOL_A_MSE_CNT,
+	ETHTOOL_A_MSE_MAX = (__ETHTOOL_A_MSE_CNT - 1)
+};
+
 enum {
 	ETHTOOL_MSG_USER_NONE = 0,
 	ETHTOOL_MSG_STRSET_GET = 1,
@@ -843,6 +889,7 @@ enum {
 	ETHTOOL_MSG_RSS_SET,
 	ETHTOOL_MSG_RSS_CREATE_ACT,
 	ETHTOOL_MSG_RSS_DELETE_ACT,
+	ETHTOOL_MSG_MSE_GET,
 
 	__ETHTOOL_MSG_USER_CNT,
 	ETHTOOL_MSG_USER_MAX = (__ETHTOOL_MSG_USER_CNT - 1)
@@ -903,6 +950,7 @@ enum {
 	ETHTOOL_MSG_RSS_CREATE_ACT_REPLY,
 	ETHTOOL_MSG_RSS_CREATE_NTF,
 	ETHTOOL_MSG_RSS_DELETE_NTF,
+	ETHTOOL_MSG_MSE_GET_REPLY,
 
 	__ETHTOOL_MSG_KERNEL_CNT,
 	ETHTOOL_MSG_KERNEL_MAX = (__ETHTOOL_MSG_KERNEL_CNT - 1)
diff --git a/lib/libc/include/any-linux-any/linux/ext4.h b/lib/libc/include/any-linux-any/linux/ext4.h
index edbf8f035cfb1ac8c072b17700c0ceb4594cd998..e864103cde86df6bbcc54271716daf8c44d89a64 100644
--- a/lib/libc/include/any-linux-any/linux/ext4.h
+++ b/lib/libc/include/any-linux-any/linux/ext4.h
@@ -33,6 +33,8 @@
 #define EXT4_IOC_CHECKPOINT		_IOW('f', 43, __u32)
 #define EXT4_IOC_GETFSUUID		_IOR('f', 44, struct fsuuid)
 #define EXT4_IOC_SETFSUUID		_IOW('f', 44, struct fsuuid)
+#define EXT4_IOC_GET_TUNE_SB_PARAM	_IOR('f', 45, struct ext4_tune_sb_params)
+#define EXT4_IOC_SET_TUNE_SB_PARAM	_IOW('f', 46, struct ext4_tune_sb_params)
 
 #define EXT4_IOC_SHUTDOWN _IOR('X', 125, __u32)
 
@@ -108,6 +110,57 @@ struct ext4_new_group_input {
 	__u16 unused;
 };
 
+struct ext4_tune_sb_params {
+	__u32 set_flags;
+	__u32 checkinterval;
+	__u16 errors_behavior;
+	__u16 mnt_count;
+	__u16 max_mnt_count;
+	__u16 raid_stride;
+	__u64 last_check_time;
+	__u64 reserved_blocks;
+	__u64 blocks_count;
+	__u32 default_mnt_opts;
+	__u32 reserved_uid;
+	__u32 reserved_gid;
+	__u32 raid_stripe_width;
+	__u16 encoding;
+	__u16 encoding_flags;
+	__u8  def_hash_alg;
+	__u8  pad_1;
+	__u16 pad_2;
+	__u32 feature_compat;
+	__u32 feature_incompat;
+	__u32 feature_ro_compat;
+	__u32 set_feature_compat_mask;
+	__u32 set_feature_incompat_mask;
+	__u32 set_feature_ro_compat_mask;
+	__u32 clear_feature_compat_mask;
+	__u32 clear_feature_incompat_mask;
+	__u32 clear_feature_ro_compat_mask;
+	__u8  mount_opts[64];
+	__u8  pad[68];
+};
+
+#define EXT4_TUNE_FL_ERRORS_BEHAVIOR	0x00000001
+#define EXT4_TUNE_FL_MNT_COUNT		0x00000002
+#define EXT4_TUNE_FL_MAX_MNT_COUNT	0x00000004
+#define EXT4_TUNE_FL_CHECKINTRVAL	0x00000008
+#define EXT4_TUNE_FL_LAST_CHECK_TIME	0x00000010
+#define EXT4_TUNE_FL_RESERVED_BLOCKS	0x00000020
+#define EXT4_TUNE_FL_RESERVED_UID	0x00000040
+#define EXT4_TUNE_FL_RESERVED_GID	0x00000080
+#define EXT4_TUNE_FL_DEFAULT_MNT_OPTS	0x00000100
+#define EXT4_TUNE_FL_DEF_HASH_ALG	0x00000200
+#define EXT4_TUNE_FL_RAID_STRIDE	0x00000400
+#define EXT4_TUNE_FL_RAID_STRIPE_WIDTH	0x00000800
+#define EXT4_TUNE_FL_MOUNT_OPTS		0x00001000
+#define EXT4_TUNE_FL_FEATURES		0x00002000
+#define EXT4_TUNE_FL_EDIT_FEATURES	0x00004000
+#define EXT4_TUNE_FL_FORCE_FSCK		0x00008000
+#define EXT4_TUNE_FL_ENCODING		0x00010000
+#define EXT4_TUNE_FL_ENCODING_FLAGS	0x00020000
+
 /*
  * Returned by EXT4_IOC_GET_ES_CACHE as an additional possible flag.
  * It indicates that the entry in extent status cache is for a hole.
diff --git a/lib/libc/include/any-linux-any/linux/fb.h b/lib/libc/include/any-linux-any/linux/fb.h
index 33d91b152486e8fea5a11296cfdc8901454d0ec8..6650e72ef020db4a5296ade81fc21bd06372a142 100644
--- a/lib/libc/include/any-linux-any/linux/fb.h
+++ b/lib/libc/include/any-linux-any/linux/fb.h
@@ -317,7 +317,7 @@ enum {
 #define FB_VBLANK_HAVE_VCOUNT	0x020	/* the vcount field is valid */
 #define FB_VBLANK_HAVE_HCOUNT	0x040	/* the hcount field is valid */
 #define FB_VBLANK_VSYNCING	0x080	/* currently in a vsync */
-#define FB_VBLANK_HAVE_VSYNC	0x100	/* verical syncs can be detected */
+#define FB_VBLANK_HAVE_VSYNC	0x100	/* vertical syncs can be detected */
 
 struct fb_vblank {
 	__u32 flags;			/* FB_VBLANK flags */
diff --git a/lib/libc/include/any-linux-any/linux/fcntl.h b/lib/libc/include/any-linux-any/linux/fcntl.h
index 782578d670ea6af35f9621e14b087ada7995f7ac..6adc03f8fa700c8ac8d0b9cbe0330aa6cb482111 100644
--- a/lib/libc/include/any-linux-any/linux/fcntl.h
+++ b/lib/libc/include/any-linux-any/linux/fcntl.h
@@ -4,6 +4,7 @@
 
 #include <asm/fcntl.h>
 #include <linux/openat2.h>
+#include <linux/types.h>
 
 #define F_SETLEASE	(F_LINUX_SPECIFIC_BASE + 0)
 #define F_GETLEASE	(F_LINUX_SPECIFIC_BASE + 1)
@@ -79,6 +80,17 @@
  */
 #define RWF_WRITE_LIFE_NOT_SET	RWH_WRITE_LIFE_NOT_SET
 
+/* Set/Get delegations */
+#define F_GETDELEG		(F_LINUX_SPECIFIC_BASE + 15)
+#define F_SETDELEG		(F_LINUX_SPECIFIC_BASE + 16)
+
+/* Argument structure for F_GETDELEG and F_SETDELEG */
+struct delegation {
+	__u32	d_flags;	/* Must be 0 */
+	__u16	d_type;		/* F_RDLCK, F_WRLCK, F_UNLCK */
+	__u16	__pad;		/* Must be 0 */
+};
+
 /*
  * Types of directory notifications that may be requested.
  */
@@ -111,6 +123,7 @@
 #define PIDFD_SELF_THREAD_GROUP		-10001 /* Current thread group leader. */
 
 #define FD_PIDFS_ROOT			-10002 /* Root of the pidfs filesystem */
+#define FD_NSFS_ROOT			-10003 /* Root of the nsfs filesystem */
 #define FD_INVALID			-10009 /* Invalid file descriptor: -10000 - EBADF = -10009 */
 
 /* Generic flags for the *at(2) family of syscalls. */
diff --git a/lib/libc/include/any-linux-any/linux/fou.h b/lib/libc/include/any-linux-any/linux/fou.h
index fb70cbe09f320a862b37668175c1101fcebac07c..5074c599f7e85da2e7f9aac567b8157cad77b54c 100644
--- a/lib/libc/include/any-linux-any/linux/fou.h
+++ b/lib/libc/include/any-linux-any/linux/fou.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/fou.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_FOU_H
 #define _LINUX_FOU_H
diff --git a/lib/libc/include/any-linux-any/linux/fs.h b/lib/libc/include/any-linux-any/linux/fs.h
index ffd4070c60c720102efa625f443f5c8937649a4d..29221c3f26d46af69125a834b44a2b2165972b50 100644
--- a/lib/libc/include/any-linux-any/linux/fs.h
+++ b/lib/libc/include/any-linux-any/linux/fs.h
@@ -294,8 +294,9 @@ struct file_attr {
 #define BLKROTATIONAL _IO(0x12,126)
 #define BLKZEROOUT _IO(0x12,127)
 #define BLKGETDISKSEQ _IOR(0x12,128,__u64)
-/* 130-136 are used by zoned block device ioctls (uapi/linux/blkzoned.h) */
+/* 130-136 and 142 are used by zoned block device ioctls (uapi/linux/blkzoned.h) */
 /* 137-141 are used by blk-crypto ioctls (uapi/linux/blk-crypto.h) */
+#define BLKTRACESETUP2 _IOWR(0x12, 142, struct blk_user_trace_setup2)
 
 #define BMAP_IOCTL 1		/* obsolete - kept for compatibility */
 #define FIBMAP	   _IO(0x00,1)	/* bmap access */
@@ -426,10 +427,13 @@ typedef int __bitwise __kernel_rwf_t;
 /* buffered IO that drops the cache after reading or writing data */
 #define RWF_DONTCACHE	((__kernel_rwf_t)0x00000080)
 
+/* prevent pipe and socket writes from raising SIGPIPE */
+#define RWF_NOSIGNAL	((__kernel_rwf_t)0x00000100)
+
 /* mask of flags supported by the kernel */
 #define RWF_SUPPORTED	(RWF_HIPRI | RWF_DSYNC | RWF_SYNC | RWF_NOWAIT |\
 			 RWF_APPEND | RWF_NOAPPEND | RWF_ATOMIC |\
-			 RWF_DONTCACHE)
+			 RWF_DONTCACHE | RWF_NOSIGNAL)
 
 #define PROCFS_IOCTL_MAGIC 'f'
 
diff --git a/lib/libc/include/any-linux-any/linux/fuse.h b/lib/libc/include/any-linux-any/linux/fuse.h
index 63375b267a55f34230fd2e218e23f91b8d0108d6..547ce86ac12844f0cfebc3c789f2f0e4778af279 100644
--- a/lib/libc/include/any-linux-any/linux/fuse.h
+++ b/lib/libc/include/any-linux-any/linux/fuse.h
@@ -235,6 +235,11 @@
  *
  *  7.44
  *  - add FUSE_NOTIFY_INC_EPOCH
+ *
+ *  7.45
+ *  - add FUSE_COPY_FILE_RANGE_64
+ *  - add struct fuse_copy_file_range_out
+ *  - add FUSE_NOTIFY_PRUNE
  */
 
 #ifndef _LINUX_FUSE_H
@@ -266,7 +271,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 44
+#define FUSE_KERNEL_MINOR_VERSION 45
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -653,6 +658,7 @@ enum fuse_opcode {
 	FUSE_SYNCFS		= 50,
 	FUSE_TMPFILE		= 51,
 	FUSE_STATX		= 52,
+	FUSE_COPY_FILE_RANGE_64	= 53,
 
 	/* CUSE specific operations */
 	CUSE_INIT		= 4096,
@@ -671,7 +677,7 @@ enum fuse_notify_code {
 	FUSE_NOTIFY_DELETE = 6,
 	FUSE_NOTIFY_RESEND = 7,
 	FUSE_NOTIFY_INC_EPOCH = 8,
-	FUSE_NOTIFY_CODE_MAX,
+	FUSE_NOTIFY_PRUNE = 9,
 };
 
 /* The read buffer is required to be at least 8k, but may be much larger */
@@ -1110,6 +1116,12 @@ struct fuse_notify_retrieve_in {
 	uint64_t	dummy4;
 };
 
+struct fuse_notify_prune_out {
+	uint32_t	count;
+	uint32_t	padding;
+	uint64_t	spare;
+};
+
 struct fuse_backing_map {
 	int32_t		fd;
 	uint32_t	flags;
@@ -1122,6 +1134,7 @@ struct fuse_backing_map {
 #define FUSE_DEV_IOC_BACKING_OPEN	_IOW(FUSE_DEV_IOC_MAGIC, 1, \
 					     struct fuse_backing_map)
 #define FUSE_DEV_IOC_BACKING_CLOSE	_IOW(FUSE_DEV_IOC_MAGIC, 2, uint32_t)
+#define FUSE_DEV_IOC_SYNC_INIT		_IO(FUSE_DEV_IOC_MAGIC, 3)
 
 struct fuse_lseek_in {
 	uint64_t	fh;
@@ -1144,6 +1157,11 @@ struct fuse_copy_file_range_in {
 	uint64_t	flags;
 };
 
+/* For FUSE_COPY_FILE_RANGE_64 */
+struct fuse_copy_file_range_out {
+	uint64_t	bytes_copied;
+};
+
 #define FUSE_SETUPMAPPING_FLAG_WRITE (1ull << 0)
 #define FUSE_SETUPMAPPING_FLAG_READ (1ull << 1)
 struct fuse_setupmapping_in {
diff --git a/lib/libc/include/any-linux-any/linux/gpib.h b/lib/libc/include/any-linux-any/linux/gpib.h
new file mode 100644
index 0000000000000000000000000000000000000000..510e8361d5562c8f020d026324f4dccc9ca70877
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/gpib.h
@@ -0,0 +1,103 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+/***************************************************************************
+ *    copyright		   : (C) 2002 by Frank Mori Hess
+ ***************************************************************************/
+
+#ifndef _GPIB_H
+#define _GPIB_H
+
+#define GPIB_MAX_NUM_BOARDS 16
+#define GPIB_MAX_NUM_DESCRIPTORS 0x1000
+
+enum ibsta_bit_numbers {
+	DCAS_NUM = 0,
+	DTAS_NUM = 1,
+	LACS_NUM = 2,
+	TACS_NUM = 3,
+	ATN_NUM = 4,
+	CIC_NUM = 5,
+	REM_NUM = 6,
+	LOK_NUM = 7,
+	CMPL_NUM = 8,
+	EVENT_NUM = 9,
+	SPOLL_NUM = 10,
+	RQS_NUM = 11,
+	SRQI_NUM = 12,
+	END_NUM = 13,
+	TIMO_NUM = 14,
+	ERR_NUM = 15
+};
+
+/* IBSTA status bits (returned by all functions) */
+enum ibsta_bits {
+	DCAS = (1 << DCAS_NUM),	/* device clear state */
+	DTAS = (1 << DTAS_NUM),	/* device trigger state */
+	LACS = (1 <<  LACS_NUM),	/* GPIB interface is addressed as Listener */
+	TACS = (1 <<  TACS_NUM),	/* GPIB interface is addressed as Talker */
+	ATN = (1 <<  ATN_NUM),	/* Attention is asserted */
+	CIC = (1 <<  CIC_NUM),	/* GPIB interface is Controller-in-Charge */
+	REM = (1 << REM_NUM),	/* remote state */
+	LOK = (1 << LOK_NUM),	/* lockout state */
+	CMPL = (1 <<  CMPL_NUM),	/* I/O is complete  */
+	EVENT = (1 << EVENT_NUM),	/* DCAS, DTAS, or IFC has occurred */
+	SPOLL = (1 << SPOLL_NUM),	/* board serial polled by busmaster */
+	RQS = (1 <<  RQS_NUM),	/* Device requesting service  */
+	SRQI = (1 << SRQI_NUM),	/* SRQ is asserted */
+	END = (1 << END_NUM),	/* EOI or EOS encountered */
+	TIMO = (1 << TIMO_NUM),	/* Time limit on I/O or wait function exceeded */
+	ERR = (1 << ERR_NUM),	/* Function call terminated on error */
+
+	device_status_mask = ERR | TIMO | END | CMPL | RQS,
+	board_status_mask = ERR | TIMO | END | CMPL | SPOLL |
+		EVENT | LOK | REM | CIC | ATN | TACS | LACS | DTAS | DCAS | SRQI,
+};
+
+/* End-of-string (EOS) modes for use with ibeos */
+
+enum eos_flags {
+	EOS_MASK = 0x1c00,
+	REOS = 0x0400,		/* Terminate reads on EOS	*/
+	XEOS = 0x800,	/* assert EOI when EOS char is sent */
+	BIN = 0x1000		/* Do 8-bit compare on EOS	*/
+};
+
+/* GPIB Bus Control Lines bit vector */
+enum bus_control_line {
+	VALID_DAV = 0x01,
+	VALID_NDAC = 0x02,
+	VALID_NRFD = 0x04,
+	VALID_IFC = 0x08,
+	VALID_REN = 0x10,
+	VALID_SRQ = 0x20,
+	VALID_ATN = 0x40,
+	VALID_EOI = 0x80,
+	VALID_ALL = 0xff,
+	BUS_DAV = 0x0100,		/* DAV	line status bit */
+	BUS_NDAC = 0x0200,		/* NDAC line status bit */
+	BUS_NRFD = 0x0400,		/* NRFD line status bit */
+	BUS_IFC = 0x0800,		/* IFC	line status bit */
+	BUS_REN = 0x1000,		/* REN	line status bit */
+	BUS_SRQ = 0x2000,		/* SRQ	line status bit */
+	BUS_ATN = 0x4000,		/* ATN	line status bit */
+	BUS_EOI = 0x8000		/* EOI	line status bit */
+};
+
+enum ppe_bits {
+	PPC_DISABLE = 0x10,
+	PPC_SENSE = 0x8,	/* parallel poll sense bit	*/
+	PPC_DIO_MASK = 0x7
+};
+
+enum {
+	request_service_bit = 0x40,
+};
+
+enum gpib_events {
+	EVENT_NONE = 0,
+	EVENT_DEV_TRG = 1,
+	EVENT_DEV_CLR = 2,
+	EVENT_IFC = 3
+};
+
+#endif	/* _GPIB_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/gpib_ioctl.h b/lib/libc/include/any-linux-any/linux/gpib_ioctl.h
new file mode 100644
index 0000000000000000000000000000000000000000..45f0e801aae62f8cf86ee4d7c84adf80b7618e25
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/gpib_ioctl.h
@@ -0,0 +1,167 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+/***************************************************************************
+ *    copyright            : (C) 2002 by Frank Mori Hess
+ ***************************************************************************/
+
+#ifndef _GPIB_IOCTL_H
+#define _GPIB_IOCTL_H
+
+#include <asm/ioctl.h>
+#include <linux/types.h>
+
+#define GPIB_CODE 160
+
+struct gpib_board_type_ioctl {
+	char name[100];
+};
+
+/* argument for read/write/command ioctls */
+struct gpib_read_write_ioctl {
+	__u64 buffer_ptr;
+	__u32 requested_transfer_count;
+	__u32 completed_transfer_count;
+	__s32 end; /* end flag return for reads, end io suppression request for cmd*/
+	__s32 handle;
+};
+
+struct gpib_open_dev_ioctl {
+	__u32 handle;
+	__u32 pad;
+	__s32 sad;
+	__u32 is_board;
+};
+
+struct gpib_close_dev_ioctl {
+	__u32 handle;
+};
+
+struct gpib_serial_poll_ioctl {
+	__u32 pad;
+	__s32 sad;
+	__u8 status_byte;
+	__u8 padding[3];   /* align to 32 bit boundary */
+};
+
+struct gpib_eos_ioctl {
+	__s32 eos;
+	__s32 eos_flags;
+};
+
+struct gpib_wait_ioctl {
+	__s32 handle;
+	__s32 wait_mask;
+	__s32 clear_mask;
+	__s32 set_mask;
+	__s32 ibsta;
+	__s32 pad;
+	__s32 sad;
+	__u32 usec_timeout;
+};
+
+struct gpib_online_ioctl {
+	__u64 init_data_ptr;
+	__s32 init_data_length;
+	__s32 online;
+};
+
+struct gpib_spoll_bytes_ioctl {
+	__u32 num_bytes;
+	__u32 pad;
+	__s32 sad;
+};
+
+struct gpib_board_info_ioctl {
+	__u32 pad;
+	__s32 sad;
+	__s32 parallel_poll_configuration;
+	__s32 autopolling;
+	__s32 is_system_controller;
+	__u32 t1_delay;
+	unsigned ist : 1;
+	unsigned no_7_bit_eos : 1;
+	unsigned padding :30; /* align to 32 bit boundary */
+};
+
+struct gpib_select_pci_ioctl {
+	__s32 pci_bus;
+	__s32 pci_slot;
+};
+
+struct gpib_ppoll_config_ioctl {
+	__u8 config;
+	unsigned set_ist : 1;
+	unsigned clear_ist : 1;
+	unsigned padding :22; /* align to 32 bit boundary */
+};
+
+struct gpib_pad_ioctl {
+	__u32 handle;
+	__u32 pad;
+};
+
+struct gpib_sad_ioctl {
+	__u32 handle;
+	__s32 sad;
+};
+
+/* select a piece of hardware to attach by its sysfs device path */
+struct gpib_select_device_path_ioctl {
+	char device_path[0x1000];
+};
+
+/* update status byte and request service */
+struct gpib_request_service2 {
+	__u8 status_byte;
+	__u8 padding[3]; /* align to 32 bit boundary */
+	__s32 new_reason_for_service;
+};
+
+/* Standard functions. */
+enum gpib_ioctl {
+	IBRD = _IOWR(GPIB_CODE, 100, struct gpib_read_write_ioctl),
+	IBWRT = _IOWR(GPIB_CODE, 101, struct gpib_read_write_ioctl),
+	IBCMD = _IOWR(GPIB_CODE, 102, struct gpib_read_write_ioctl),
+	IBOPENDEV = _IOWR(GPIB_CODE, 3, struct gpib_open_dev_ioctl),
+	IBCLOSEDEV = _IOW(GPIB_CODE, 4, struct gpib_close_dev_ioctl),
+	IBWAIT = _IOWR(GPIB_CODE, 5, struct gpib_wait_ioctl),
+	IBRPP = _IOWR(GPIB_CODE, 6, __u8),
+
+	IBSIC = _IOW(GPIB_CODE, 9, __u32),
+	IBSRE = _IOW(GPIB_CODE, 10, __s32),
+	IBGTS = _IO(GPIB_CODE, 11),
+	IBCAC = _IOW(GPIB_CODE, 12, __s32),
+	IBLINES = _IOR(GPIB_CODE, 14, __s16),
+	IBPAD = _IOW(GPIB_CODE, 15, struct gpib_pad_ioctl),
+	IBSAD = _IOW(GPIB_CODE, 16, struct gpib_sad_ioctl),
+	IBTMO = _IOW(GPIB_CODE, 17, __u32),
+	IBRSP = _IOWR(GPIB_CODE, 18, struct gpib_serial_poll_ioctl),
+	IBEOS = _IOW(GPIB_CODE, 19, struct gpib_eos_ioctl),
+	IBRSV = _IOW(GPIB_CODE, 20, __u8),
+	CFCBASE = _IOW(GPIB_CODE, 21, __u64),
+	CFCIRQ = _IOW(GPIB_CODE, 22, __u32),
+	CFCDMA = _IOW(GPIB_CODE, 23, __u32),
+	CFCBOARDTYPE = _IOW(GPIB_CODE, 24, struct gpib_board_type_ioctl),
+
+	IBMUTEX = _IOW(GPIB_CODE, 26, __s32),
+	IBSPOLL_BYTES = _IOWR(GPIB_CODE, 27, struct gpib_spoll_bytes_ioctl),
+	IBPPC = _IOW(GPIB_CODE, 28, struct gpib_ppoll_config_ioctl),
+	IBBOARD_INFO = _IOR(GPIB_CODE, 29, struct gpib_board_info_ioctl),
+
+	IBQUERY_BOARD_RSV = _IOR(GPIB_CODE, 31, __s32),
+	IBSELECT_PCI = _IOWR(GPIB_CODE, 32, struct gpib_select_pci_ioctl),
+	IBEVENT = _IOR(GPIB_CODE, 33, __s16),
+	IBRSC = _IOW(GPIB_CODE, 34, __s32),
+	IB_T1_DELAY = _IOW(GPIB_CODE, 35, __u32),
+	IBLOC = _IO(GPIB_CODE, 36),
+
+	IBAUTOSPOLL = _IOW(GPIB_CODE, 38, __s16),
+	IBONL = _IOW(GPIB_CODE, 39, struct gpib_online_ioctl),
+	IBPP2_SET = _IOW(GPIB_CODE, 40, __s16),
+	IBPP2_GET = _IOR(GPIB_CODE, 41, __s16),
+	IBSELECT_DEVICE_PATH = _IOW(GPIB_CODE, 43, struct gpib_select_device_path_ioctl),
+	/* 44 was IBSELECT_SERIAL_NUMBER */
+	IBRSV2 = _IOW(GPIB_CODE, 45, struct gpib_request_service2)
+};
+
+#endif	/* _GPIB_IOCTL_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/handshake.h b/lib/libc/include/any-linux-any/linux/handshake.h
index 7874215475ce54288f95928cbcbad2322df87f20..83c4f050ad7f402763cbeb0b8e1acd0456563dff 100644
--- a/lib/libc/include/any-linux-any/linux/handshake.h
+++ b/lib/libc/include/any-linux-any/linux/handshake.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/handshake.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_HANDSHAKE_H
 #define _LINUX_HANDSHAKE_H
diff --git a/lib/libc/include/any-linux-any/linux/hidraw.h b/lib/libc/include/any-linux-any/linux/hidraw.h
index 7b1d5d2f6ad41377532fa5a2a3b58f0ab993d812..059fa946ea5cf483170e7c5be79500d00b6d0560 100644
--- a/lib/libc/include/any-linux-any/linux/hidraw.h
+++ b/lib/libc/include/any-linux-any/linux/hidraw.h
@@ -48,6 +48,8 @@ struct hidraw_devinfo {
 #define HIDIOCGOUTPUT(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x0C, len)
 #define HIDIOCREVOKE	      _IOW('H', 0x0D, int) /* Revoke device access */
 
+#define HIDIOCTL_LAST		_IOC_NR(HIDIOCREVOKE)
+
 #define HIDRAW_FIRST_MINOR 0
 #define HIDRAW_MAX_DEVICES 64
 /* number of reports to buffer */
diff --git a/lib/libc/include/any-linux-any/linux/i2c.h b/lib/libc/include/any-linux-any/linux/i2c.h
index 11b43063b1bbe569d2850a61803ceba39d671d88..a4da4b4da796a4c31c63f3bcef7c193e7887ff14 100644
--- a/lib/libc/include/any-linux-any/linux/i2c.h
+++ b/lib/libc/include/any-linux-any/linux/i2c.h
@@ -36,7 +36,7 @@
  *
  *   Only if I2C_FUNC_NOSTART is set:
  *   %I2C_M_NOSTART: skip repeated start sequence
-
+ *
  *   Only if I2C_FUNC_PROTOCOL_MANGLING is set:
  *   %I2C_M_NO_RD_ACK: in a read message, master ACK/NACK bit is skipped
  *   %I2C_M_IGNORE_NAK: treat NACK from client as ACK
diff --git a/lib/libc/include/any-linux-any/linux/i8k.h b/lib/libc/include/any-linux-any/linux/i8k.h
index 82cf7e69f0d9ebf9650d7e083eaec2fbe2d6e653..9d08d4bce0169df81dcc450d5466bb67768a794a 100644
--- a/lib/libc/include/any-linux-any/linux/i8k.h
+++ b/lib/libc/include/any-linux-any/linux/i8k.h
@@ -36,6 +36,8 @@
 #define I8K_FAN_LOW		1
 #define I8K_FAN_HIGH		2
 #define I8K_FAN_TURBO		3
+/* Many machines treat this mode as some sort of automatic mode */
+#define I8K_FAN_AUTO		3
 #define I8K_FAN_MAX		I8K_FAN_TURBO
 
 #define I8K_VOL_UP		1
diff --git a/lib/libc/include/any-linux-any/linux/if_bridge.h b/lib/libc/include/any-linux-any/linux/if_bridge.h
index 415dc8f953a3e675f551c7f9ceb19b8e0292b236..8593f5ca74680feaf08710add042a77ddf901ece 100644
--- a/lib/libc/include/any-linux-any/linux/if_bridge.h
+++ b/lib/libc/include/any-linux-any/linux/if_bridge.h
@@ -823,6 +823,8 @@ struct br_mcast_stats {
 /* bridge boolean options
  * BR_BOOLOPT_NO_LL_LEARN - disable learning from link-local packets
  * BR_BOOLOPT_MCAST_VLAN_SNOOPING - control vlan multicast snooping
+ * BR_BOOLOPT_FDB_LOCAL_VLAN_0 - local FDB entries installed by the bridge
+ *                               driver itself should only be added on VLAN 0
  *
  * IMPORTANT: if adding a new option do not forget to handle
  *            it in br_boolopt_toggle/get and bridge sysfs
@@ -832,6 +834,7 @@ enum br_boolopt_id {
 	BR_BOOLOPT_MCAST_VLAN_SNOOPING,
 	BR_BOOLOPT_MST_ENABLE,
 	BR_BOOLOPT_MDB_OFFLOAD_FAIL_NOTIFICATION,
+	BR_BOOLOPT_FDB_LOCAL_VLAN_0,
 	BR_BOOLOPT_MAX
 };
 
diff --git a/lib/libc/include/any-linux-any/linux/if_ether.h b/lib/libc/include/any-linux-any/linux/if_ether.h
index 7af9ced28bbac2a83967453d84bc3b3c650fe1fe..c81e8662b76b4618dba44e09e319c7fd88ce0aff 100644
--- a/lib/libc/include/any-linux-any/linux/if_ether.h
+++ b/lib/libc/include/any-linux-any/linux/if_ether.h
@@ -92,6 +92,9 @@
 #define ETH_P_ETHERCAT	0x88A4		/* EtherCAT			*/
 #define ETH_P_8021AD	0x88A8          /* 802.1ad Service VLAN		*/
 #define ETH_P_802_EX1	0x88B5		/* 802.1 Local Experimental 1.  */
+#define ETH_P_MXLGSW	0x88C3		/* Infineon Technologies Corporate Research ST
+					 * Used by MaxLinear GSW DSA
+					 */
 #define ETH_P_PREAUTH	0x88C7		/* 802.11 Preauthentication */
 #define ETH_P_TIPC	0x88CA		/* TIPC 			*/
 #define ETH_P_LLDP	0x88CC		/* Link Layer Discovery Protocol */
@@ -114,6 +117,7 @@
 #define ETH_P_QINQ1	0x9100		/* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_QINQ2	0x9200		/* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_QINQ3	0x9300		/* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_YT921X	0x9988		/* Motorcomm YT921x DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_EDSA	0xDADA		/* Ethertype DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_DSA_8021Q	0xDADB		/* Fake VLAN Header for DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_DSA_A5PSW	0xE001		/* A5PSW Tag Value [ NOT AN OFFICIALLY REGISTERED ID ] */
diff --git a/lib/libc/include/any-linux-any/linux/if_link.h b/lib/libc/include/any-linux-any/linux/if_link.h
index 7cf6e78a146063bbc37b2f91d3be7359d804d8a5..9a6f4c08d38eb1dc18d98d7f89101cca880d349e 100644
--- a/lib/libc/include/any-linux-any/linux/if_link.h
+++ b/lib/libc/include/any-linux-any/linux/if_link.h
@@ -379,6 +379,8 @@ enum {
 	IFLA_DPLL_PIN,
 	IFLA_MAX_PACING_OFFLOAD_HORIZON,
 	IFLA_NETNS_IMMUTABLE,
+	IFLA_HEADROOM,
+	IFLA_TAILROOM,
 	__IFLA_MAX
 };
 
@@ -1562,6 +1564,7 @@ enum {
 	IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE,
 	IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE,
 	IFLA_BOND_SLAVE_PRIO,
+	IFLA_BOND_SLAVE_ACTOR_PORT_PRIO,
 	__IFLA_BOND_SLAVE_MAX,
 };
 
diff --git a/lib/libc/include/any-linux-any/linux/if_team.h b/lib/libc/include/any-linux-any/linux/if_team.h
index 1fd7f45940b4d1beae0e8ddd2b82387d44865a97..a1024a4529eb3672a9bd8040e0e6372b107d275a 100644
--- a/lib/libc/include/any-linux-any/linux/if_team.h
+++ b/lib/libc/include/any-linux-any/linux/if_team.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/team.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_IF_TEAM_H
 #define _LINUX_IF_TEAM_H
diff --git a/lib/libc/include/any-linux-any/linux/iio/types.h b/lib/libc/include/any-linux-any/linux/iio/types.h
index 425d95fd135bb9387774755b5b5ac97201d75ac3..be99610f279b27575e5285721b9b3834230d569d 100644
--- a/lib/libc/include/any-linux-any/linux/iio/types.h
+++ b/lib/libc/include/any-linux-any/linux/iio/types.h
@@ -52,6 +52,7 @@ enum iio_chan_type {
 	IIO_COLORTEMP,
 	IIO_CHROMATICITY,
 	IIO_ATTENTION,
+	IIO_ALTCURRENT,
 };
 
 enum iio_modifier {
@@ -108,6 +109,10 @@ enum iio_modifier {
 	IIO_MOD_ROLL,
 	IIO_MOD_LIGHT_UVA,
 	IIO_MOD_LIGHT_UVB,
+	IIO_MOD_RMS,
+	IIO_MOD_ACTIVE,
+	IIO_MOD_REACTIVE,
+	IIO_MOD_APPARENT,
 };
 
 enum iio_event_type {
diff --git a/lib/libc/include/any-linux-any/linux/input-event-codes.h b/lib/libc/include/any-linux-any/linux/input-event-codes.h
index 33e936a04285385da649e2dde89e4f5f0f13df7d..3ee0d097c9a70d2ac2f3c76dcda95e47c5ad2c1f 100644
--- a/lib/libc/include/any-linux-any/linux/input-event-codes.h
+++ b/lib/libc/include/any-linux-any/linux/input-event-codes.h
@@ -27,6 +27,7 @@
 #define INPUT_PROP_TOPBUTTONPAD		0x04	/* softbuttons at top of pad */
 #define INPUT_PROP_POINTING_STICK	0x05	/* is a pointing stick */
 #define INPUT_PROP_ACCELEROMETER	0x06	/* has accelerometer */
+#define INPUT_PROP_PRESSUREPAD		0x07	/* pressure triggers clicks */
 
 #define INPUT_PROP_MAX			0x1f
 #define INPUT_PROP_CNT			(INPUT_PROP_MAX + 1)
@@ -630,6 +631,18 @@
 #define KEY_BRIGHTNESS_MIN		0x250	/* Set Brightness to Minimum */
 #define KEY_BRIGHTNESS_MAX		0x251	/* Set Brightness to Maximum */
 
+/*
+ * Keycodes for hotkeys toggling the electronic privacy screen found on some
+ * laptops on/off. Note when the embedded-controller turns on/off the eprivacy
+ * screen itself then the state should be reported through drm connecter props:
+ * https://www.kernel.org/doc/html/latest/gpu/drm-kms.html#standard-connector-properties
+ * Except when implementing the drm connecter properties API is not possible
+ * because e.g. the firmware does not allow querying the presence and/or status
+ * of the eprivacy screen at boot.
+ */
+#define KEY_EPRIVACY_SCREEN_ON		0x252
+#define KEY_EPRIVACY_SCREEN_OFF		0x253
+
 #define KEY_KBDINPUTASSIST_PREV		0x260
 #define KEY_KBDINPUTASSIST_NEXT		0x261
 #define KEY_KBDINPUTASSIST_PREVGROUP		0x262
@@ -878,6 +891,7 @@
 
 #define ABS_VOLUME		0x20
 #define ABS_PROFILE		0x21
+#define ABS_SND_PROFILE		0x22
 
 #define ABS_MISC		0x28
 
@@ -987,4 +1001,12 @@
 #define SND_MAX			0x07
 #define SND_CNT			(SND_MAX+1)
 
+/*
+ * ABS_SND_PROFILE values
+ */
+
+#define SND_PROFILE_SILENT	0x00
+#define SND_PROFILE_VIBRATE	0x01
+#define SND_PROFILE_RING	0x02
+
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/input.h b/lib/libc/include/any-linux-any/linux/input.h
index faa5b9d7212c00387fd31a1cdd95f9728b0bc9ae..71006dc6d71894083c297f880e0f4365ff3fcce5 100644
--- a/lib/libc/include/any-linux-any/linux/input.h
+++ b/lib/libc/include/any-linux-any/linux/input.h
@@ -427,6 +427,24 @@ struct ff_rumble_effect {
 	__u16 weak_magnitude;
 };
 
+/**
+ * struct ff_haptic_effect
+ * @hid_usage: hid_usage according to Haptics page (WAVEFORM_CLICK, etc.)
+ * @vendor_id: the waveform vendor ID if hid_usage is in the vendor-defined range
+ * @vendor_waveform_page: the vendor waveform page if hid_usage is in the vendor-defined range
+ * @intensity: strength of the effect as percentage
+ * @repeat_count: number of times to retrigger effect
+ * @retrigger_period: time before effect is retriggered (in ms)
+ */
+struct ff_haptic_effect {
+	__u16 hid_usage;
+	__u16 vendor_id;
+	__u8  vendor_waveform_page;
+	__u16 intensity;
+	__u16 repeat_count;
+	__u16 retrigger_period;
+};
+
 /**
  * struct ff_effect - defines force feedback effect
  * @type: type of the effect (FF_CONSTANT, FF_PERIODIC, FF_RAMP, FF_SPRING,
@@ -463,6 +481,7 @@ struct ff_effect {
 		struct ff_periodic_effect periodic;
 		struct ff_condition_effect condition[2]; /* One for each axis */
 		struct ff_rumble_effect rumble;
+		struct ff_haptic_effect haptic;
 	} u;
 };
 
@@ -470,6 +489,7 @@ struct ff_effect {
  * Force feedback effect types
  */
 
+#define FF_HAPTIC		0x4f
 #define FF_RUMBLE	0x50
 #define FF_PERIODIC	0x51
 #define FF_CONSTANT	0x52
@@ -479,7 +499,7 @@ struct ff_effect {
 #define FF_INERTIA	0x56
 #define FF_RAMP		0x57
 
-#define FF_EFFECT_MIN	FF_RUMBLE
+#define FF_EFFECT_MIN	FF_HAPTIC
 #define FF_EFFECT_MAX	FF_RAMP
 
 /*
diff --git a/lib/libc/include/any-linux-any/linux/io_uring.h b/lib/libc/include/any-linux-any/linux/io_uring.h
index 92cc87565f7b4d04ba369a80f15b1a0d4022bf1c..cfd70529ed9e9192c2ee3d643da89d8486211e86 100644
--- a/lib/libc/include/any-linux-any/linux/io_uring.h
+++ b/lib/libc/include/any-linux-any/linux/io_uring.h
@@ -225,6 +225,18 @@ enum io_uring_sqe_flags_bit {
 /* Use hybrid poll in iopoll process */
 #define IORING_SETUP_HYBRID_IOPOLL	(1U << 17)
 
+/*
+ * Allow both 16b and 32b CQEs. If a 32b CQE is posted, it will have
+ * IORING_CQE_F_32 set in cqe->flags.
+ */
+#define IORING_SETUP_CQE_MIXED		(1U << 18)
+
+/*
+ * Allow both 64b and 128b SQEs. If a 128b SQE is posted, it will have
+ * a 128b opcode.
+ */
+#define IORING_SETUP_SQE_MIXED		(1U << 19)
+
 enum io_uring_op {
 	IORING_OP_NOP,
 	IORING_OP_READV,
@@ -289,6 +301,8 @@ enum io_uring_op {
 	IORING_OP_READV_FIXED,
 	IORING_OP_WRITEV_FIXED,
 	IORING_OP_PIPE,
+	IORING_OP_NOP128,
+	IORING_OP_URING_CMD128,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
@@ -298,9 +312,13 @@ enum io_uring_op {
  * sqe->uring_cmd_flags		top 8bits aren't available for userspace
  * IORING_URING_CMD_FIXED	use registered buffer; pass this flag
  *				along with setting sqe->buf_index.
+ * IORING_URING_CMD_MULTISHOT	must be used with buffer select, like other
+ *				multishot commands. Not compatible with
+ *				IORING_URING_CMD_FIXED, for now.
  */
 #define IORING_URING_CMD_FIXED	(1U << 0)
-#define IORING_URING_CMD_MASK	IORING_URING_CMD_FIXED
+#define IORING_URING_CMD_MULTISHOT	(1U << 1)
+#define IORING_URING_CMD_MASK	(IORING_URING_CMD_FIXED | IORING_URING_CMD_MULTISHOT)
 
 
 /*
@@ -394,7 +412,7 @@ enum io_uring_op {
  *				will be	contiguous from the starting buffer ID.
  *
  * IORING_SEND_VECTORIZED	If set, SEND[_ZC] will take a pointer to a io_vec
- * 				to allow vectorized send operations.
+ *				to allow vectorized send operations.
  */
 #define IORING_RECVSEND_POLL_FIRST	(1U << 0)
 #define IORING_RECV_MULTISHOT		(1U << 1)
@@ -454,6 +472,7 @@ enum io_uring_msg_ring_flags {
 #define IORING_NOP_FIXED_FILE		(1U << 2)
 #define IORING_NOP_FIXED_BUFFER		(1U << 3)
 #define IORING_NOP_TW			(1U << 4)
+#define IORING_NOP_CQE32		(1U << 5)
 
 /*
  * IO completion data structure (Completion Queue Entry)
@@ -487,12 +506,22 @@ struct io_uring_cqe {
  *			other provided buffer type, all completions with a
  *			buffer passed back is automatically returned to the
  *			application.
+ * IORING_CQE_F_SKIP	If set, then the application/liburing must ignore this
+ *			CQE. It's only purpose is to fill a gap in the ring,
+ *			if a large CQE is attempted posted when the ring has
+ *			just a single small CQE worth of space left before
+ *			wrapping.
+ * IORING_CQE_F_32	If set, this is a 32b/big-cqe posting. Use with rings
+ *			setup in a mixed CQE mode, where both 16b and 32b
+ *			CQEs may be posted to the CQ ring.
  */
 #define IORING_CQE_F_BUFFER		(1U << 0)
 #define IORING_CQE_F_MORE		(1U << 1)
 #define IORING_CQE_F_SOCK_NONEMPTY	(1U << 2)
 #define IORING_CQE_F_NOTIF		(1U << 3)
 #define IORING_CQE_F_BUF_MORE		(1U << 4)
+#define IORING_CQE_F_SKIP		(1U << 5)
+#define IORING_CQE_F_32			(1U << 15)
 
 #define IORING_CQE_BUFFER_SHIFT		16
 
@@ -665,6 +694,12 @@ enum io_uring_register_op {
 
 	IORING_REGISTER_MEM_REGION		= 34,
 
+	/* query various aspects of io_uring, see linux/io_uring/query.h */
+	IORING_REGISTER_QUERY			= 35,
+
+	/* auxiliary zcrx configuration, see enum zcrx_ctrl_op */
+	IORING_REGISTER_ZCRX_CTRL		= 36,
+
 	/* this goes last */
 	IORING_REGISTER_LAST,
 
@@ -974,6 +1009,7 @@ enum io_uring_socket_op {
 	SOCKET_URING_OP_GETSOCKOPT,
 	SOCKET_URING_OP_SETSOCKOPT,
 	SOCKET_URING_OP_TX_TIMESTAMP,
+	SOCKET_URING_OP_GETSOCKNAME,
 };
 
 /*
@@ -1028,6 +1064,10 @@ struct io_uring_zcrx_area_reg {
 	__u64	__resv2[2];
 };
 
+enum zcrx_reg_flags {
+	ZCRX_REG_IMPORT	= 1,
+};
+
 /*
  * Argument for IORING_REGISTER_ZCRX_IFQ
  */
@@ -1046,6 +1086,33 @@ struct io_uring_zcrx_ifq_reg {
 	__u64	__resv[3];
 };
 
+enum zcrx_ctrl_op {
+	ZCRX_CTRL_FLUSH_RQ,
+	ZCRX_CTRL_EXPORT,
+
+	__ZCRX_CTRL_LAST,
+};
+
+struct zcrx_ctrl_flush_rq {
+	__u64		__resv[6];
+};
+
+struct zcrx_ctrl_export {
+	__u32		zcrx_fd;
+	__u32 		__resv1[11];
+};
+
+struct zcrx_ctrl {
+	__u32	zcrx_id;
+	__u32	op; /* see enum zcrx_ctrl_op */
+	__u64	__resv[2];
+
+	union {
+		struct zcrx_ctrl_export		zc_export;
+		struct zcrx_ctrl_flush_rq	zc_flush;
+	};
+};
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/libc/include/any-linux-any/linux/io_uring/query.h b/lib/libc/include/any-linux-any/linux/io_uring/query.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f9c60a5bf2f3bd5b6e17d66539117be8b7c04f0
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/io_uring/query.h
@@ -0,0 +1,68 @@
+/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR MIT */
+/*
+ * Header file for the io_uring query interface.
+ */
+#ifndef LINUX_IO_URING_QUERY_H
+#define LINUX_IO_URING_QUERY_H
+
+#include <linux/types.h>
+
+struct io_uring_query_hdr {
+	__u64 next_entry;
+	__u64 query_data;
+	__u32 query_op;
+	__u32 size;
+	__s32 result;
+	__u32 __resv[3];
+};
+
+enum {
+	IO_URING_QUERY_OPCODES			= 0,
+	IO_URING_QUERY_ZCRX			= 1,
+	IO_URING_QUERY_SCQ			= 2,
+
+	__IO_URING_QUERY_MAX,
+};
+
+/* Doesn't require a ring */
+struct io_uring_query_opcode {
+	/* The number of supported IORING_OP_* opcodes */
+	__u32	nr_request_opcodes;
+	/* The number of supported IORING_[UN]REGISTER_* opcodes */
+	__u32	nr_register_opcodes;
+	/* Bitmask of all supported IORING_FEAT_* flags */
+	__u64	feature_flags;
+	/* Bitmask of all supported IORING_SETUP_* flags */
+	__u64	ring_setup_flags;
+	/* Bitmask of all supported IORING_ENTER_** flags */
+	__u64	enter_flags;
+	/* Bitmask of all supported IOSQE_* flags */
+	__u64	sqe_flags;
+	/* The number of available query opcodes */
+	__u32	nr_query_opcodes;
+	__u32	__pad;
+};
+
+struct io_uring_query_zcrx {
+	/* Bitmask of supported ZCRX_REG_* flags, */
+	__u64 register_flags;
+	/* Bitmask of all supported IORING_ZCRX_AREA_* flags */
+	__u64 area_flags;
+	/* The number of supported ZCRX_CTRL_* opcodes */
+	__u32 nr_ctrl_opcodes;
+	__u32 __resv1;
+	/* The refill ring header size */
+	__u32 rq_hdr_size;
+	/* The alignment for the header */
+	__u32 rq_hdr_alignment;
+	__u64 __resv2;
+};
+
+struct io_uring_query_scq {
+	/* The SQ/CQ rings header size */
+	__u64 hdr_size;
+	/* The alignment for the header */
+	__u64 hdr_alignment;
+};
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/iommufd.h b/lib/libc/include/any-linux-any/linux/iommufd.h
index 847b6135e960e1c94e003e362f48645ad2c8db72..8f4e6e49fbb498081802699239d33f96238fe3b8 100644
--- a/lib/libc/include/any-linux-any/linux/iommufd.h
+++ b/lib/libc/include/any-linux-any/linux/iommufd.h
@@ -450,6 +450,16 @@ struct iommu_hwpt_vtd_s1 {
  * nested domain will translate the same as the nesting parent. The S1 will
  * install a Context Descriptor Table pointing at userspace memory translated
  * by the nesting parent.
+ *
+ * It's suggested to allocate a vDEVICE object carrying vSID and then re-attach
+ * the nested domain, as soon as the vSID is available in the VMM level:
+ *
+ * - when Cfg=translate, a vDEVICE must be allocated prior to attaching to the
+ *   allocated nested domain, as CD/ATS invalidations and vevents need a vSID.
+ * - when Cfg=bypass/abort, a vDEVICE is not enforced during the nested domain
+ *   attachment, to support a GBPA case where VM sets CR0.SMMUEN=0. However, if
+ *   VM sets CR0.SMMUEN=1 while missing a vDEVICE object, kernel would fail to
+ *   report events to the VM. E.g. F_TRANSLATION when guest STE.Cfg=abort.
  */
 struct iommu_hwpt_arm_smmuv3 {
 	__aligned_le64 ste[2];
diff --git a/lib/libc/include/any-linux-any/linux/isst_if.h b/lib/libc/include/any-linux-any/linux/isst_if.h
index 073e491b7774fd35b045292a167aef6dfd772022..882a6eedded2e06f0413298c64b1f8f0151a3d4c 100644
--- a/lib/libc/include/any-linux-any/linux/isst_if.h
+++ b/lib/libc/include/any-linux-any/linux/isst_if.h
@@ -52,7 +52,7 @@ struct isst_if_cpu_map {
 /**
  * struct isst_if_cpu_maps - structure for CPU map IOCTL
  * @cmd_count:	Number of CPU mapping command in cpu_map[]
- * @cpu_map[]:	Holds one or more CPU map data structure
+ * @cpu_map:	Holds one or more CPU map data structure
  *
  * This structure used with ioctl ISST_IF_GET_PHY_ID to send
  * one or more CPU mapping commands. Here IOCTL return value indicates
@@ -82,8 +82,8 @@ struct isst_if_io_reg {
 
 /**
  * struct isst_if_io_regs - structure for IO register commands
- * @cmd_count:	Number of io reg commands in io_reg[]
- * @io_reg[]:	Holds one or more io_reg command structure
+ * @req_count:	Number of io reg commands in io_reg[]
+ * @io_reg:	Holds one or more io_reg command structure
  *
  * This structure used with ioctl ISST_IF_IO_CMD to send
  * one or more read/write commands to PUNIT. Here IOCTL return value
@@ -120,7 +120,7 @@ struct isst_if_mbox_cmd {
 /**
  * struct isst_if_mbox_cmds - structure for mailbox commands
  * @cmd_count:	Number of mailbox commands in mbox_cmd[]
- * @mbox_cmd[]:	Holds one or more mbox commands
+ * @mbox_cmd:	Holds one or more mbox commands
  *
  * This structure used with ioctl ISST_IF_MBOX_COMMAND to send
  * one or more mailbox commands to PUNIT. Here IOCTL return value
@@ -152,7 +152,7 @@ struct isst_if_msr_cmd {
 /**
  * struct isst_if_msr_cmds - structure for msr commands
  * @cmd_count:	Number of mailbox commands in msr_cmd[]
- * @msr_cmd[]:	Holds one or more msr commands
+ * @msr_cmd:	Holds one or more msr commands
  *
  * This structure used with ioctl ISST_IF_MSR_COMMAND to send
  * one or more MSR commands. IOCTL return value indicates number of
@@ -167,8 +167,9 @@ struct isst_if_msr_cmds {
  * struct isst_core_power - Structure to get/set core_power feature
  * @get_set:	0: Get, 1: Set
  * @socket_id:	Socket/package id
- * @power_domain: Power Domain id
+ * @power_domain_id: Power Domain id
  * @enable:	Feature enable status
+ * @supported:	Power domain supports SST_CP interface
  * @priority_type: Priority type for the feature (ordered/proportional)
  *
  * Structure to get/set core_power feature state using IOCTL
@@ -187,11 +188,11 @@ struct isst_core_power {
  * struct isst_clos_param - Structure to get/set clos praram
  * @get_set:	0: Get, 1: Set
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
- * clos:	Clos ID for the parameters
- * min_freq_mhz: Minimum frequency in MHz
- * max_freq_mhz: Maximum frequency in MHz
- * prop_prio:	Proportional priority from 0-15
+ * @power_domain_id:	Power Domain id
+ * @clos:	Clos ID for the parameters
+ * @min_freq_mhz: Minimum frequency in MHz
+ * @max_freq_mhz: Maximum frequency in MHz
+ * @prop_prio:	Proportional priority from 0-15
  *
  * Structure to get/set per clos property using IOCTL
  * ISST_IF_CLOS_PARAM.
@@ -209,7 +210,7 @@ struct isst_clos_param {
 /**
  * struct isst_if_clos_assoc - Structure to assign clos to a CPU
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @logical_cpu: CPU number
  * @clos:	Clos ID to assign to the logical CPU
  *
@@ -228,6 +229,7 @@ struct isst_if_clos_assoc {
  * @get_set:	Request is for get or set
  * @punit_cpu_map: Set to 1 if the CPU number is punit numbering not
  *		   Linux CPU number
+ * @assoc_info: CLOS data for this CPU
  *
  * Structure used to get/set associate CPUs to clos using IOCTL
  * ISST_IF_CLOS_ASSOC.
@@ -257,7 +259,7 @@ struct isst_tpmi_instance_count {
 /**
  * struct isst_perf_level_info - Structure to get information on SST-PP levels
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @logical_cpu: CPU number
  * @clos:	Clos ID to assign to the logical CPU
  * @max_level: Maximum performance level supported by the platform
@@ -267,8 +269,8 @@ struct isst_tpmi_instance_count {
  * @feature_state: SST-BF and SST-TF (enabled/disabled) status at current level
  * @locked: SST-PP performance level change is locked/unlocked
  * @enabled: SST-PP feature is enabled or not
- * @sst-tf_support: SST-TF support status at this level
- * @sst-bf_support: SST-BF support status at this level
+ * @sst_tf_support: SST-TF support status at this level
+ * @sst_bf_support: SST-BF support status at this level
  *
  * Structure to get SST-PP details using IOCTL ISST_IF_PERF_LEVELS.
  */
@@ -289,7 +291,7 @@ struct isst_perf_level_info {
 /**
  * struct isst_perf_level_control - Structure to set SST-PP level
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @level:	level to set
  *
  * Structure used change SST-PP level using IOCTL ISST_IF_PERF_SET_LEVEL.
@@ -303,7 +305,7 @@ struct isst_perf_level_control {
 /**
  * struct isst_perf_feature_control - Structure to activate SST-BF/SST-TF
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @feature:	bit 0 = SST-BF state, bit 1 = SST-TF state
  *
  * Structure used to enable SST-BF/SST-TF using IOCTL ISST_IF_PERF_SET_FEATURE.
@@ -320,7 +322,7 @@ struct isst_perf_feature_control {
 /**
  * struct isst_perf_level_data_info - Structure to get SST-PP level details
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @level:	SST-PP level for which caller wants to get information
  * @tdp_ratio: TDP Ratio
  * @base_freq_mhz: Base frequency in MHz
@@ -341,8 +343,8 @@ struct isst_perf_feature_control {
  * @pm_fabric_freq_mhz: Fabric (Uncore) minimum frequency
  * @max_buckets: Maximum trl buckets
  * @max_trl_levels: Maximum trl levels
- * @bucket_core_counts[TRL_MAX_BUCKETS]: Number of cores per bucket
- * @trl_freq_mhz[TRL_MAX_LEVELS][TRL_MAX_BUCKETS]: maximum frequency
+ * @bucket_core_counts: Number of cores per bucket
+ * @trl_freq_mhz: maximum frequency
  * for a bucket and trl level
  *
  * Structure used to get information on frequencies and TDP for a SST-PP
@@ -402,7 +404,7 @@ struct isst_perf_level_fabric_info {
 /**
  * struct isst_perf_level_cpu_mask - Structure to get SST-PP level CPU mask
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @level:	SST-PP level for which caller wants to get information
  * @punit_cpu_map: Set to 1 if the CPU number is punit numbering not
  *		   Linux CPU number. If 0 CPU buffer is copied to user space
@@ -430,7 +432,7 @@ struct isst_perf_level_cpu_mask {
 /**
  * struct isst_base_freq_info - Structure to get SST-BF frequencies
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @level:	SST-PP level for which caller wants to get information
  * @high_base_freq_mhz: High priority CPU base frequency
  * @low_base_freq_mhz: Low priority CPU base frequency
@@ -453,9 +455,11 @@ struct isst_base_freq_info {
 /**
  * struct isst_turbo_freq_info - Structure to get SST-TF frequencies
  * @socket_id:	Socket/package id
- * @power_domain:	Power Domain id
+ * @power_domain_id:	Power Domain id
  * @level:	SST-PP level for which caller wants to get information
  * @max_clip_freqs: Maximum number of low priority core clipping frequencies
+ * @max_buckets: Maximum trl buckets
+ * @max_trl_levels: Maximum trl levels
  * @lp_clip_freq_mhz: Clip frequencies per trl level
  * @bucket_core_counts: Maximum number of cores for a bucket
  * @trl_freq_mhz: Frequencies per trl level for each bucket
diff --git a/lib/libc/include/any-linux-any/linux/ivtv.h b/lib/libc/include/any-linux-any/linux/ivtv.h
index ae6bab82b8c6a2eab61df890680753767d1434ee..aaeff03f96b213cc7d5901f6f14e715690ed5742 100644
--- a/lib/libc/include/any-linux-any/linux/ivtv.h
+++ b/lib/libc/include/any-linux-any/linux/ivtv.h
@@ -2,7 +2,7 @@
 /*
     Public ivtv API header
     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
-    Copyright (C) 2004-2007  Hans Verkuil <hverkuil@xs4all.nl>
+    Copyright (C) 2004-2007  Hans Verkuil <hverkuil@kernel.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/lib/libc/include/any-linux-any/linux/kexec.h b/lib/libc/include/any-linux-any/linux/kexec.h
index 49ff741624c2b760bf5049082205793c31173a73..e965aab40d33799a22e76ce08acb3dd7843d21f8 100644
--- a/lib/libc/include/any-linux-any/linux/kexec.h
+++ b/lib/libc/include/any-linux-any/linux/kexec.h
@@ -22,12 +22,16 @@
  * KEXEC_FILE_ON_CRASH : Load/unload operation belongs to kdump image.
  * KEXEC_FILE_NO_INITRAMFS : No initramfs is being loaded. Ignore the initrd
  *                           fd field.
+ * KEXEC_FILE_FORCE_DTB : Force carrying over the current boot's DTB to the new
+ *                        kernel on x86. This is already the default behavior on
+ *                        some other architectures, like ARM64 and PowerPC.
  */
 #define KEXEC_FILE_UNLOAD	0x00000001
 #define KEXEC_FILE_ON_CRASH	0x00000002
 #define KEXEC_FILE_NO_INITRAMFS	0x00000004
 #define KEXEC_FILE_DEBUG	0x00000008
 #define KEXEC_FILE_NO_CMA	0x00000010
+#define KEXEC_FILE_FORCE_DTB	0x00000020
 
 /* These values match the ELF architecture values.
  * Unless there is a good reason that should continue to be the case.
diff --git a/lib/libc/include/any-linux-any/linux/kfd_ioctl.h b/lib/libc/include/any-linux-any/linux/kfd_ioctl.h
index bad6286285a5eb6cf3a1d10cded9208aca2ecc1c..b120355bbb7c0d5494905af8dabcb56a13aada86 100644
--- a/lib/libc/include/any-linux-any/linux/kfd_ioctl.h
+++ b/lib/libc/include/any-linux-any/linux/kfd_ioctl.h
@@ -67,8 +67,8 @@ struct kfd_ioctl_get_version_args {
 
 struct kfd_ioctl_create_queue_args {
 	__u64 ring_base_address;	/* to KFD */
-	__u64 write_pointer_address;	/* from KFD */
-	__u64 read_pointer_address;	/* from KFD */
+	__u64 write_pointer_address;	/* to KFD */
+	__u64 read_pointer_address;	/* to KFD */
 	__u64 doorbell_offset;	/* from KFD */
 
 	__u32 ring_size;		/* to KFD */
diff --git a/lib/libc/include/any-linux-any/linux/kvm.h b/lib/libc/include/any-linux-any/linux/kvm.h
index 3e4d668e1e9c2a4fb451070c7eec3967a309401e..190c95cec9789d7d7402d82eeea1c01b77608b7c 100644
--- a/lib/libc/include/any-linux-any/linux/kvm.h
+++ b/lib/libc/include/any-linux-any/linux/kvm.h
@@ -179,6 +179,7 @@ struct kvm_xen_exit {
 #define KVM_EXIT_LOONGARCH_IOCSR  38
 #define KVM_EXIT_MEMORY_FAULT     39
 #define KVM_EXIT_TDX              40
+#define KVM_EXIT_ARM_SEA          41
 
 /* For KVM_EXIT_INTERNAL_ERROR */
 /* Emulate instruction failed. */
@@ -465,6 +466,14 @@ struct kvm_run {
 				} setup_event_notify;
 			};
 		} tdx;
+		/* KVM_EXIT_ARM_SEA */
+		struct {
+#define KVM_EXIT_ARM_SEA_FLAG_GPA_VALID	(1ULL << 0)
+			__u64 flags;
+			__u64 esr;
+			__u64 gva;
+			__u64 gpa;
+		} arm_sea;
 		/* Fix the size of the union. */
 		char padding[256];
 	};
@@ -954,6 +963,9 @@ struct kvm_enable_cap {
 #define KVM_CAP_ARM_EL2_E2H0 241
 #define KVM_CAP_RISCV_MP_STATE_RESET 242
 #define KVM_CAP_ARM_CACHEABLE_PFNMAP_SUPPORTED 243
+#define KVM_CAP_GUEST_MEMFD_FLAGS 244
+#define KVM_CAP_ARM_SEA_TO_USER 245
+#define KVM_CAP_S390_USER_OPEREXEC 246
 
 struct kvm_irq_routing_irqchip {
 	__u32 irqchip;
@@ -1590,6 +1602,8 @@ struct kvm_memory_attributes {
 #define KVM_MEMORY_ATTRIBUTE_PRIVATE           (1ULL << 3)
 
 #define KVM_CREATE_GUEST_MEMFD	_IOWR(KVMIO,  0xd4, struct kvm_create_guest_memfd)
+#define GUEST_MEMFD_FLAG_MMAP		(1ULL << 0)
+#define GUEST_MEMFD_FLAG_INIT_SHARED	(1ULL << 1)
 
 struct kvm_create_guest_memfd {
 	__u64 size;
diff --git a/lib/libc/include/any-linux-any/linux/landlock.h b/lib/libc/include/any-linux-any/linux/landlock.h
index e4fcb8006bcae44ed6bba966bce8e6c606beff4a..37f269bdbbf9d7df0de738f26f3bb1bef976d439 100644
--- a/lib/libc/include/any-linux-any/linux/landlock.h
+++ b/lib/libc/include/any-linux-any/linux/landlock.h
@@ -216,6 +216,23 @@ struct landlock_net_port_attr {
  *   :manpage:`ftruncate(2)`, :manpage:`creat(2)`, or :manpage:`open(2)` with
  *   ``O_TRUNC``.  This access right is available since the third version of the
  *   Landlock ABI.
+ * - %LANDLOCK_ACCESS_FS_IOCTL_DEV: Invoke :manpage:`ioctl(2)` commands on an opened
+ *   character or block device.
+ *
+ *   This access right applies to all `ioctl(2)` commands implemented by device
+ *   drivers.  However, the following common IOCTL commands continue to be
+ *   invokable independent of the %LANDLOCK_ACCESS_FS_IOCTL_DEV right:
+ *
+ *   * IOCTL commands targeting file descriptors (``FIOCLEX``, ``FIONCLEX``),
+ *   * IOCTL commands targeting file descriptions (``FIONBIO``, ``FIOASYNC``),
+ *   * IOCTL commands targeting file systems (``FIFREEZE``, ``FITHAW``,
+ *     ``FIGETBSZ``, ``FS_IOC_GETFSUUID``, ``FS_IOC_GETFSSYSFSPATH``)
+ *   * Some IOCTL commands which do not make sense when used with devices, but
+ *     whose implementations are safe and return the right error codes
+ *     (``FS_IOC_FIEMAP``, ``FICLONE``, ``FICLONERANGE``, ``FIDEDUPERANGE``)
+ *
+ *   This access right is available since the fifth version of the Landlock
+ *   ABI.
  *
  * Whether an opened file can be truncated with :manpage:`ftruncate(2)` or used
  * with `ioctl(2)` is determined during :manpage:`open(2)`, in the same way as
@@ -275,26 +292,6 @@ struct landlock_net_port_attr {
  *   If multiple requirements are not met, the ``EACCES`` error code takes
  *   precedence over ``EXDEV``.
  *
- * The following access right applies both to files and directories:
- *
- * - %LANDLOCK_ACCESS_FS_IOCTL_DEV: Invoke :manpage:`ioctl(2)` commands on an opened
- *   character or block device.
- *
- *   This access right applies to all `ioctl(2)` commands implemented by device
- *   drivers.  However, the following common IOCTL commands continue to be
- *   invokable independent of the %LANDLOCK_ACCESS_FS_IOCTL_DEV right:
- *
- *   * IOCTL commands targeting file descriptors (``FIOCLEX``, ``FIONCLEX``),
- *   * IOCTL commands targeting file descriptions (``FIONBIO``, ``FIOASYNC``),
- *   * IOCTL commands targeting file systems (``FIFREEZE``, ``FITHAW``,
- *     ``FIGETBSZ``, ``FS_IOC_GETFSUUID``, ``FS_IOC_GETFSSYSFSPATH``)
- *   * Some IOCTL commands which do not make sense when used with devices, but
- *     whose implementations are safe and return the right error codes
- *     (``FS_IOC_FIEMAP``, ``FICLONE``, ``FICLONERANGE``, ``FIDEDUPERANGE``)
- *
- *   This access right is available since the fifth version of the Landlock
- *   ABI.
- *
  * .. warning::
  *
  *   It is currently not possible to restrict some file-related actions
diff --git a/lib/libc/include/any-linux-any/linux/liveupdate.h b/lib/libc/include/any-linux-any/linux/liveupdate.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f3aeca415a1c08e3a09bc3398f527257dacd4f6
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/liveupdate.h
@@ -0,0 +1,216 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+/*
+ * Userspace interface for /dev/liveupdate
+ * Live Update Orchestrator
+ *
+ * Copyright (c) 2025, Google LLC.
+ * Pasha Tatashin <pasha.tatashin@soleen.com>
+ */
+
+#ifndef _LIVEUPDATE_H
+#define _LIVEUPDATE_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/**
+ * DOC: General ioctl format
+ *
+ * The ioctl interface follows a general format to allow for extensibility. Each
+ * ioctl is passed in a structure pointer as the argument providing the size of
+ * the structure in the first u32. The kernel checks that any structure space
+ * beyond what it understands is 0. This allows userspace to use the backward
+ * compatible portion while consistently using the newer, larger, structures.
+ *
+ * ioctls use a standard meaning for common errnos:
+ *
+ *  - ENOTTY: The IOCTL number itself is not supported at all
+ *  - E2BIG: The IOCTL number is supported, but the provided structure has
+ *    non-zero in a part the kernel does not understand.
+ *  - EOPNOTSUPP: The IOCTL number is supported, and the structure is
+ *    understood, however a known field has a value the kernel does not
+ *    understand or support.
+ *  - EINVAL: Everything about the IOCTL was understood, but a field is not
+ *    correct.
+ *  - ENOENT: A provided token does not exist.
+ *  - ENOMEM: Out of memory.
+ *  - EOVERFLOW: Mathematics overflowed.
+ *
+ * As well as additional errnos, within specific ioctls.
+ */
+
+/* The ioctl type, documented in ioctl-number.rst */
+#define LIVEUPDATE_IOCTL_TYPE		0xBA
+
+/* The maximum length of session name including null termination */
+#define LIVEUPDATE_SESSION_NAME_LENGTH 64
+
+/* The /dev/liveupdate ioctl commands */
+enum {
+	LIVEUPDATE_CMD_BASE = 0x00,
+	LIVEUPDATE_CMD_CREATE_SESSION = LIVEUPDATE_CMD_BASE,
+	LIVEUPDATE_CMD_RETRIEVE_SESSION = 0x01,
+};
+
+/* ioctl commands for session file descriptors */
+enum {
+	LIVEUPDATE_CMD_SESSION_BASE = 0x40,
+	LIVEUPDATE_CMD_SESSION_PRESERVE_FD = LIVEUPDATE_CMD_SESSION_BASE,
+	LIVEUPDATE_CMD_SESSION_RETRIEVE_FD = 0x41,
+	LIVEUPDATE_CMD_SESSION_FINISH = 0x42,
+};
+
+/**
+ * struct liveupdate_ioctl_create_session - ioctl(LIVEUPDATE_IOCTL_CREATE_SESSION)
+ * @size:	Input; sizeof(struct liveupdate_ioctl_create_session)
+ * @fd:		Output; The new file descriptor for the created session.
+ * @name:	Input; A null-terminated string for the session name, max
+ *		length %LIVEUPDATE_SESSION_NAME_LENGTH including termination
+ *		character.
+ *
+ * Creates a new live update session for managing preserved resources.
+ * This ioctl can only be called on the main /dev/liveupdate device.
+ *
+ * Return: 0 on success, negative error code on failure.
+ */
+struct liveupdate_ioctl_create_session {
+	__u32		size;
+	__s32		fd;
+	__u8		name[LIVEUPDATE_SESSION_NAME_LENGTH];
+};
+
+#define LIVEUPDATE_IOCTL_CREATE_SESSION					\
+	_IO(LIVEUPDATE_IOCTL_TYPE, LIVEUPDATE_CMD_CREATE_SESSION)
+
+/**
+ * struct liveupdate_ioctl_retrieve_session - ioctl(LIVEUPDATE_IOCTL_RETRIEVE_SESSION)
+ * @size:    Input; sizeof(struct liveupdate_ioctl_retrieve_session)
+ * @fd:      Output; The new file descriptor for the retrieved session.
+ * @name:    Input; A null-terminated string identifying the session to retrieve.
+ *           The name must exactly match the name used when the session was
+ *           created in the previous kernel.
+ *
+ * Retrieves a handle (a new file descriptor) for a preserved session by its
+ * name. This is the primary mechanism for a userspace agent to regain control
+ * of its preserved resources after a live update.
+ *
+ * The userspace application provides the null-terminated `name` of a session
+ * it created before the live update. If a preserved session with a matching
+ * name is found, the kernel instantiates it and returns a new file descriptor
+ * in the `fd` field. This new session FD can then be used for all file-specific
+ * operations, such as restoring individual file descriptors with
+ * LIVEUPDATE_SESSION_RETRIEVE_FD.
+ *
+ * It is the responsibility of the userspace application to know the names of
+ * the sessions it needs to retrieve. If no session with the given name is
+ * found, the ioctl will fail with -ENOENT.
+ *
+ * This ioctl can only be called on the main /dev/liveupdate device when the
+ * system is in the LIVEUPDATE_STATE_UPDATED state.
+ */
+struct liveupdate_ioctl_retrieve_session {
+	__u32		size;
+	__s32		fd;
+	__u8		name[LIVEUPDATE_SESSION_NAME_LENGTH];
+};
+
+#define LIVEUPDATE_IOCTL_RETRIEVE_SESSION \
+	_IO(LIVEUPDATE_IOCTL_TYPE, LIVEUPDATE_CMD_RETRIEVE_SESSION)
+
+/* Session specific IOCTLs */
+
+/**
+ * struct liveupdate_session_preserve_fd - ioctl(LIVEUPDATE_SESSION_PRESERVE_FD)
+ * @size:  Input; sizeof(struct liveupdate_session_preserve_fd)
+ * @fd:    Input; The user-space file descriptor to be preserved.
+ * @token: Input; An opaque, unique token for preserved resource.
+ *
+ * Holds parameters for preserving a file descriptor.
+ *
+ * User sets the @fd field identifying the file descriptor to preserve
+ * (e.g., memfd, kvm, iommufd, VFIO). The kernel validates if this FD type
+ * and its dependencies are supported for preservation. If validation passes,
+ * the kernel marks the FD internally and *initiates the process* of preparing
+ * its state for saving. The actual snapshotting of the state typically occurs
+ * during the subsequent %LIVEUPDATE_IOCTL_PREPARE execution phase, though
+ * some finalization might occur during freeze.
+ * On successful validation and initiation, the kernel uses the @token
+ * field with an opaque identifier representing the resource being preserved.
+ * This token confirms the FD is targeted for preservation and is required for
+ * the subsequent %LIVEUPDATE_SESSION_RETRIEVE_FD call after the live update.
+ *
+ * Return: 0 on success (validation passed, preservation initiated), negative
+ * error code on failure (e.g., unsupported FD type, dependency issue,
+ * validation failed).
+ */
+struct liveupdate_session_preserve_fd {
+	__u32		size;
+	__s32		fd;
+	__aligned_u64	token;
+};
+
+#define LIVEUPDATE_SESSION_PRESERVE_FD					\
+	_IO(LIVEUPDATE_IOCTL_TYPE, LIVEUPDATE_CMD_SESSION_PRESERVE_FD)
+
+/**
+ * struct liveupdate_session_retrieve_fd - ioctl(LIVEUPDATE_SESSION_RETRIEVE_FD)
+ * @size:  Input; sizeof(struct liveupdate_session_retrieve_fd)
+ * @fd:    Output; The new file descriptor representing the fully restored
+ *         kernel resource.
+ * @token: Input; An opaque, token that was used to preserve the resource.
+ *
+ * Retrieve a previously preserved file descriptor.
+ *
+ * User sets the @token field to the value obtained from a successful
+ * %LIVEUPDATE_IOCTL_FD_PRESERVE call before the live update. On success,
+ * the kernel restores the state (saved during the PREPARE/FREEZE phases)
+ * associated with the token and populates the @fd field with a new file
+ * descriptor referencing the restored resource in the current (new) kernel.
+ * This operation must be performed *before* signaling completion via
+ * %LIVEUPDATE_IOCTL_FINISH.
+ *
+ * Return: 0 on success, negative error code on failure (e.g., invalid token).
+ */
+struct liveupdate_session_retrieve_fd {
+	__u32		size;
+	__s32		fd;
+	__aligned_u64	token;
+};
+
+#define LIVEUPDATE_SESSION_RETRIEVE_FD					\
+	_IO(LIVEUPDATE_IOCTL_TYPE, LIVEUPDATE_CMD_SESSION_RETRIEVE_FD)
+
+/**
+ * struct liveupdate_session_finish - ioctl(LIVEUPDATE_SESSION_FINISH)
+ * @size:     Input; sizeof(struct liveupdate_session_finish)
+ * @reserved: Input; Must be zero. Reserved for future use.
+ *
+ * Signals the completion of the restoration process for a retrieved session.
+ * This is the final operation that should be performed on a session file
+ * descriptor after a live update.
+ *
+ * This ioctl must be called once all required file descriptors for the session
+ * have been successfully retrieved (using %LIVEUPDATE_SESSION_RETRIEVE_FD) and
+ * are fully restored from the userspace and kernel perspective.
+ *
+ * Upon success, the kernel releases its ownership of the preserved resources
+ * associated with this session. This allows internal resources to be freed,
+ * typically by decrementing reference counts on the underlying preserved
+ * objects.
+ *
+ * If this operation fails, the resources remain preserved in memory. Userspace
+ * may attempt to call finish again. The resources will otherwise be reset
+ * during the next live update cycle.
+ *
+ * Return: 0 on success, negative error code on failure.
+ */
+struct liveupdate_session_finish {
+	__u32		size;
+	__u32		reserved;
+};
+
+#define LIVEUPDATE_SESSION_FINISH					\
+	_IO(LIVEUPDATE_IOCTL_TYPE, LIVEUPDATE_CMD_SESSION_FINISH)
+
+#endif /* _LIVEUPDATE_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/lockd_netlink.h b/lib/libc/include/any-linux-any/linux/lockd_netlink.h
index 60f7378be6ec33697800cdcb74502c2fd121ed22..4c8674ec542452e3352c9a4feae25daf530ff90b 100644
--- a/lib/libc/include/any-linux-any/linux/lockd_netlink.h
+++ b/lib/libc/include/any-linux-any/linux/lockd_netlink.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/lockd.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_LOCKD_NETLINK_H
 #define _LINUX_LOCKD_NETLINK_H
diff --git a/lib/libc/include/any-linux-any/linux/magic.h b/lib/libc/include/any-linux-any/linux/magic.h
index 99fb2381fb0a2ea92ee3428e7d84cd3d3491a8df..1cdc39612827022028cbf3e8fe391503851ecfc3 100644
--- a/lib/libc/include/any-linux-any/linux/magic.h
+++ b/lib/libc/include/any-linux-any/linux/magic.h
@@ -103,5 +103,6 @@
 #define DEVMEM_MAGIC		0x454d444d	/* "DMEM" */
 #define SECRETMEM_MAGIC		0x5345434d	/* "SECM" */
 #define PID_FS_MAGIC		0x50494446	/* "PIDF" */
+#define GUEST_MEMFD_MAGIC	0x474d454d	/* "GMEM" */
 
 #endif /* __LINUX_MAGIC_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/map_benchmark.h b/lib/libc/include/any-linux-any/linux/map_benchmark.h
new file mode 100644
index 0000000000000000000000000000000000000000..1689166dc56bf2b26d7d98e108fd2bf53b7eccb3
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/map_benchmark.h
@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */
+/*
+ * Copyright (C) 2022-2025 HiSilicon Limited.
+ */
+
+#ifndef _DMA_BENCHMARK_H
+#define _DMA_BENCHMARK_H
+
+#include <linux/types.h>
+
+#define DMA_MAP_BENCHMARK       _IOWR('d', 1, struct map_benchmark)
+#define DMA_MAP_MAX_THREADS     1024
+#define DMA_MAP_MAX_SECONDS     300
+#define DMA_MAP_MAX_TRANS_DELAY (10 * NSEC_PER_MSEC)
+
+#define DMA_MAP_BIDIRECTIONAL   0
+#define DMA_MAP_TO_DEVICE       1
+#define DMA_MAP_FROM_DEVICE     2
+
+struct map_benchmark {
+	__u64 avg_map_100ns; /* average map latency in 100ns */
+	__u64 map_stddev; /* standard deviation of map latency */
+	__u64 avg_unmap_100ns; /* as above */
+	__u64 unmap_stddev;
+	__u32 threads; /* how many threads will do map/unmap in parallel */
+	__u32 seconds; /* how long the test will last */
+	__s32 node; /* which numa node this benchmark will run on */
+	__u32 dma_bits; /* DMA addressing capability */
+	__u32 dma_dir; /* DMA data direction */
+	__u32 dma_trans_ns; /* time for DMA transmission in ns */
+	__u32 granule;  /* how many PAGE_SIZE will do map/unmap once a time */
+	__u8 expansion[76]; /* For future use */
+};
+
+#endif /* _DMA_BENCHMARK_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/mdio.h b/lib/libc/include/any-linux-any/linux/mdio.h
index 8a50aa70235076061376dd9cc25e9e1d5cfc9f4b..a87d5ff3041cd083c5bff0fbe6c8c13245803391 100644
--- a/lib/libc/include/any-linux-any/linux/mdio.h
+++ b/lib/libc/include/any-linux-any/linux/mdio.h
@@ -116,10 +116,24 @@
 #define MDIO_CTRL1_SPEED10G		(MDIO_CTRL1_SPEEDSELEXT | 0x00)
 /* 10PASS-TS/2BASE-TL */
 #define MDIO_CTRL1_SPEED10P2B		(MDIO_CTRL1_SPEEDSELEXT | 0x04)
+/* Note: the MDIO_CTRL1_SPEED_XXX values for everything past 10PASS-TS/2BASE-TL
+ * do not match between the PCS and PMA values. Any additions past this point
+ * should be PMA or PCS specific. The following 2 defines are workarounds for
+ * values added before this was caught. They should be considered deprecated.
+ */
+#define MDIO_CTRL1_SPEED2_5G		MDIO_PMA_CTRL1_SPEED2_5G
+#define MDIO_CTRL1_SPEED5G		MDIO_PMA_CTRL1_SPEED5G
+/* 100 Gb/s */
+#define MDIO_PCS_CTRL1_SPEED100G	(MDIO_CTRL1_SPEEDSELEXT | 0x10)
+/* 25 Gb/s */
+#define MDIO_PCS_CTRL1_SPEED25G		(MDIO_CTRL1_SPEEDSELEXT | 0x14)
+/* 50 Gb/s */
+#define MDIO_PCS_CTRL1_SPEED50G		(MDIO_CTRL1_SPEEDSELEXT | 0x18)
 /* 2.5 Gb/s */
-#define MDIO_CTRL1_SPEED2_5G		(MDIO_CTRL1_SPEEDSELEXT | 0x18)
+#define MDIO_PMA_CTRL1_SPEED2_5G	(MDIO_CTRL1_SPEEDSELEXT | 0x18)
 /* 5 Gb/s */
-#define MDIO_CTRL1_SPEED5G		(MDIO_CTRL1_SPEEDSELEXT | 0x1c)
+#define MDIO_PMA_CTRL1_SPEED5G		(MDIO_CTRL1_SPEEDSELEXT | 0x1c)
+
 
 /* Status register 1. */
 #define MDIO_STAT1_LPOWERABLE		0x0002	/* Low-power ability */
@@ -133,6 +147,11 @@
 #define MDIO_AN_STAT1_PAGE		0x0040	/* Page received */
 #define MDIO_AN_STAT1_XNP		0x0080	/* Extended next page status */
 
+/* Device Identifier 2 */
+#define MDIO_DEVID2_OUI			0xfc00	/* OUI Portion of PHY ID */
+#define MDIO_DEVID2_MODEL_NUM		0x03f0	/* Manufacturer's Model Number */
+#define MDIO_DEVID2_REV_NUM		0x000f	/* Revision Number */
+
 /* Speed register. */
 #define MDIO_SPEED_10G			0x0001	/* 10G capable */
 #define MDIO_PMA_SPEED_2B		0x0002	/* 2BASE-TL capable */
diff --git a/lib/libc/include/any-linux-any/linux/media-bus-format.h b/lib/libc/include/any-linux-any/linux/media-bus-format.h
index 0c437c27f4e9a9636c87f1c0c0bbca2e07155766..a31aaf1776b53e831e034b31adfc1295c969b053 100644
--- a/lib/libc/include/any-linux-any/linux/media-bus-format.h
+++ b/lib/libc/include/any-linux-any/linux/media-bus-format.h
@@ -34,7 +34,7 @@
 
 #define MEDIA_BUS_FMT_FIXED			0x0001
 
-/* RGB - next is	0x1028 */
+/* RGB - next is	0x1029 */
 #define MEDIA_BUS_FMT_RGB444_1X12		0x1016
 #define MEDIA_BUS_FMT_RGB444_2X8_PADHI_BE	0x1001
 #define MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE	0x1002
@@ -74,6 +74,7 @@
 #define MEDIA_BUS_FMT_RGB888_1X36_CPADLO	0x1021
 #define MEDIA_BUS_FMT_RGB121212_1X36		0x1019
 #define MEDIA_BUS_FMT_RGB161616_1X48		0x101a
+#define MEDIA_BUS_FMT_RGB202020_1X60		0x1028
 
 /* YUV (including grey) - next is	0x202f */
 #define MEDIA_BUS_FMT_Y8_1X8			0x2001
@@ -123,7 +124,7 @@
 #define MEDIA_BUS_FMT_YUV16_1X48		0x202a
 #define MEDIA_BUS_FMT_UYYVYY16_0_5X48		0x202b
 
-/* Bayer - next is	0x3021 */
+/* Bayer - next is	0x3025 */
 #define MEDIA_BUS_FMT_SBGGR8_1X8		0x3001
 #define MEDIA_BUS_FMT_SGBRG8_1X8		0x3013
 #define MEDIA_BUS_FMT_SGRBG8_1X8		0x3002
@@ -156,6 +157,10 @@
 #define MEDIA_BUS_FMT_SGBRG16_1X16		0x301e
 #define MEDIA_BUS_FMT_SGRBG16_1X16		0x301f
 #define MEDIA_BUS_FMT_SRGGB16_1X16		0x3020
+#define MEDIA_BUS_FMT_SBGGR20_1X20		0x3021
+#define MEDIA_BUS_FMT_SGBRG20_1X20		0x3022
+#define MEDIA_BUS_FMT_SGRBG20_1X20		0x3023
+#define MEDIA_BUS_FMT_SRGGB20_1X20		0x3024
 
 /* JPEG compressed formats - next is	0x4002 */
 #define MEDIA_BUS_FMT_JPEG_1X8			0x4001
diff --git a/lib/libc/include/any-linux-any/linux/media/amlogic/c3-isp-config.h b/lib/libc/include/any-linux-any/linux/media/amlogic/c3-isp-config.h
index 1c1d8b46b2ac9292bed5849d5bc2a9f9ea648232..22df6912f97d1f4034daa02952567ea5354a01a6 100644
--- a/lib/libc/include/any-linux-any/linux/media/amlogic/c3-isp-config.h
+++ b/lib/libc/include/any-linux-any/linux/media/amlogic/c3-isp-config.h
@@ -8,6 +8,8 @@
 
 #include <linux/types.h>
 
+#include <linux/media/v4l2-isp.h>
+
 /*
  * Frames are split into zones of almost equal width and height - a zone is a
  * rectangular tile of a frame. The metering blocks within the ISP collect
@@ -141,7 +143,7 @@ struct c3_isp_stats_info {
  * @C3_ISP_PARAMS_BUFFER_V0: First version of C3 ISP parameters block
  */
 enum c3_isp_params_buffer_version {
-	C3_ISP_PARAMS_BUFFER_V0,
+	C3_ISP_PARAMS_BUFFER_V0 = V4L2_ISP_PARAMS_VERSION_V0,
 };
 
 /**
@@ -176,62 +178,23 @@ enum c3_isp_params_block_type {
 	C3_ISP_PARAMS_BLOCK_SENTINEL
 };
 
-#define C3_ISP_PARAMS_BLOCK_FL_DISABLE (1U << 0)
-#define C3_ISP_PARAMS_BLOCK_FL_ENABLE (1U << 1)
+/* For backward compatibility */
+#define C3_ISP_PARAMS_BLOCK_FL_DISABLE	V4L2_ISP_PARAMS_FL_BLOCK_DISABLE
+#define C3_ISP_PARAMS_BLOCK_FL_ENABLE	V4L2_ISP_PARAMS_FL_BLOCK_ENABLE
 
 /**
- * struct c3_isp_params_block_header - C3 ISP parameter block header
+ * c3_isp_params_block_header - C3 ISP parameter block header
  *
  * This structure represents the common part of all the ISP configuration
- * blocks. Each parameters block shall embed an instance of this structure type
- * as its first member, followed by the block-specific configuration data. The
- * driver inspects this common header to discern the block type and its size and
- * properly handle the block content by casting it to the correct block-specific
- * type.
+ * blocks and is identical to :c:type:`v4l2_isp_params_block_header`.
  *
- * The @type field is one of the values enumerated by
+ * The type field is one of the values enumerated by
  * :c:type:`c3_isp_params_block_type` and specifies how the data should be
- * interpreted by the driver. The @size field specifies the size of the
- * parameters block and is used by the driver for validation purposes. The
- * @flags field is a bitmask of per-block flags C3_ISP_PARAMS_FL*.
+ * interpreted by the driver.
  *
- * When userspace wants to disable an ISP block the
- * C3_ISP_PARAMS_BLOCK_FL_DISABLED bit should be set in the @flags field. In
- * this case userspace may optionally omit the remainder of the configuration
- * block, which will be ignored by the driver.
- *
- * When a new configuration of an ISP block needs to be applied userspace
- * shall fully populate the ISP block and omit setting the
- * C3_ISP_PARAMS_BLOCK_FL_DISABLED bit in the @flags field.
- *
- * Userspace is responsible for correctly populating the parameters block header
- * fields (@type, @flags and @size) and the block-specific parameters.
- *
- * For example:
- *
- * .. code-block:: c
- *
- *	void populate_pst_gamma(struct c3_isp_params_block_header *block) {
- *		struct c3_isp_params_pst_gamma *gamma =
- *			(struct c3_isp_params_pst_gamma *)block;
- *
- *		gamma->header.type = C3_ISP_PARAMS_BLOCK_PST_GAMMA;
- *		gamma->header.flags = C3_ISP_PARAMS_BLOCK_FL_ENABLE;
- *		gamma->header.size = sizeof(*gamma);
- *
- *		for (unsigned int i = 0; i < 129; i++)
- *			gamma->pst_gamma_lut[i] = i;
- *	}
- *
- * @type: The parameters block type from :c:type:`c3_isp_params_block_type`
- * @flags: A bitmask of block flags
- * @size: Size (in bytes) of the parameters block, including this header
+ * The flags field is a bitmask of per-block flags C3_ISP_PARAMS_FL_*.
  */
-struct c3_isp_params_block_header {
-	__u16 type;
-	__u16 flags;
-	__u32 size;
-};
+#define c3_isp_params_block_header v4l2_isp_params_block_header
 
 /**
  * struct c3_isp_params_awb_gains - Gains for auto-white balance
@@ -498,26 +461,10 @@ struct c3_isp_params_blc {
 /**
  * struct c3_isp_params_cfg - C3 ISP configuration parameters
  *
- * This struct contains the configuration parameters of the C3 ISP
- * algorithms, serialized by userspace into an opaque data buffer. Each
- * configuration parameter block is represented by a block-specific structure
- * which contains a :c:type:`c3_isp_param_block_header` entry as first
- * member. Userspace populates the @data buffer with configuration parameters
- * for the blocks that it intends to configure. As a consequence, the data
- * buffer effective size changes according to the number of ISP blocks that
- * userspace intends to configure.
+ * This is the driver-specific implementation of
+ * :c:type:`v4l2_isp_params_buffer`.
  *
- * The parameters buffer is versioned by the @version field to allow modifying
- * and extending its definition. Userspace should populate the @version field to
- * inform the driver about the version it intends to use. The driver will parse
- * and handle the @data buffer according to the data layout specific to the
- * indicated revision and return an error if the desired revision is not
- * supported.
- *
- * For each ISP block that userspace wants to configure, a block-specific
- * structure is appended to the @data buffer, one after the other without gaps
- * in between nor overlaps. Userspace shall populate the @total_size field with
- * the effective size, in bytes, of the @data buffer.
+ * Currently only C3_ISP_PARAM_BUFFER_V0 is supported.
  *
  * The expected memory layout of the parameters buffer is::
  *
@@ -561,4 +508,5 @@ struct c3_isp_params_cfg {
 	__u8 data[C3_ISP_PARAMS_MAX_SIZE];
 };
 
+
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/media/arm/mali-c55-config.h b/lib/libc/include/any-linux-any/linux/media/arm/mali-c55-config.h
new file mode 100644
index 0000000000000000000000000000000000000000..7dde3f61bdddb9bd0a3cd75cc19c860eb1352289
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/media/arm/mali-c55-config.h
@@ -0,0 +1,785 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * ARM Mali-C55 ISP Driver - Userspace API
+ *
+ * Copyright (C) 2023 Ideas on Board Oy
+ */
+
+#ifndef __UAPI_MALI_C55_CONFIG_H
+#define __UAPI_MALI_C55_CONFIG_H
+
+#include <linux/types.h>
+#include <linux/v4l2-controls.h>
+#include <linux/media/v4l2-isp.h>
+
+#define V4L2_CID_MALI_C55_CAPABILITIES	(V4L2_CID_USER_MALI_C55_BASE + 0x0)
+#define MALI_C55_GPS_PONG		(1U << 0)
+#define MALI_C55_GPS_WDR		(1U << 1)
+#define MALI_C55_GPS_COMPRESSION	(1U << 2)
+#define MALI_C55_GPS_TEMPER		(1U << 3)
+#define MALI_C55_GPS_SINTER_LITE	(1U << 4)
+#define MALI_C55_GPS_SINTER		(1U << 5)
+#define MALI_C55_GPS_IRIDIX_LTM		(1U << 6)
+#define MALI_C55_GPS_IRIDIX_GTM		(1U << 7)
+#define MALI_C55_GPS_CNR		(1U << 8)
+#define MALI_C55_GPS_FRSCALER		(1U << 9)
+#define MALI_C55_GPS_DS_PIPE		(1U << 10)
+
+/*
+ * Frames are split into zones of almost equal width and height - a zone is a
+ * rectangular tile of a frame. The metering blocks within the ISP collect
+ * aggregated statistics per zone. A maximum of 15x15 zones can be configured,
+ * and so the statistics buffer within the hardware is sized to accommodate
+ * that.
+ *
+ * The utilised number of zones is runtime configurable.
+ */
+#define MALI_C55_MAX_ZONES	(15 * 15)
+
+/**
+ * struct mali_c55_ae_1024bin_hist - Auto Exposure 1024-bin histogram statistics
+ *
+ * @bins:	1024 element array of 16-bit pixel counts.
+ *
+ * The 1024-bin histogram module collects image-global but zone-weighted
+ * intensity distributions of pixels in fixed-width bins. The modules can be
+ * configured into different "plane modes" which affect the contents of the
+ * collected statistics. In plane mode 0, pixel intensities are taken regardless
+ * of colour plane into a single 1024-bin histogram with a bin width of 4. In
+ * plane mode 1, four 256-bin histograms with a bin width of 16 are collected -
+ * one for each CFA colour plane. In plane modes 4, 5, 6 and 7 two 512-bin
+ * histograms with a bin width of 8 are collected - in each mode one of the
+ * colour planes is collected into the first histogram and all the others are
+ * combined into the second. The histograms are stored consecutively in the bins
+ * array.
+ *
+ * The 16-bit pixel counts are stored as a 4-bit exponent in the most
+ * significant bits followed by a 12-bit mantissa. Conversion to a usable
+ * format can be done according to the following pseudo-code::
+ *
+ *	if (e == 0) {
+ *		bin = m * 2;
+ *	} else {
+ *		bin = (m + 4096) * 2^e
+ *	}
+ *
+ * where
+ *	e is the exponent value in range 0..15
+ *	m is the mantissa value in range 0..4095
+ *
+ * The pixels used in calculating the statistics can be masked using three
+ * methods:
+ *
+ * 1. Pixels can be skipped in X and Y directions independently.
+ * 2. Minimum/Maximum intensities can be configured
+ * 3. Zones can be differentially weighted, including 0 weighted to mask them
+ *
+ * The data for this histogram can be collected from different tap points in the
+ * ISP depending on configuration - after the white balance or digital gain
+ * blocks, or immediately after the input crossbar.
+ */
+struct mali_c55_ae_1024bin_hist {
+	__u16 bins[1024];
+} __attribute__((packed));
+
+/**
+ * struct mali_c55_ae_5bin_hist - Auto Exposure 5-bin histogram statistics
+ *
+ * @hist0:	16-bit normalised pixel count for the 0th intensity bin
+ * @hist1:	16-bit normalised pixel count for the 1st intensity bin
+ * @hist3:	16-bit normalised pixel count for the 3rd intensity bin
+ * @hist4:	16-bit normalised pixel count for the 4th intensity bin
+ *
+ * The ISP generates a 5-bin histogram of normalised pixel counts within bins of
+ * pixel intensity for each of 225 possible zones within a frame. The centre bin
+ * of the histogram for each zone is not available from the hardware and must be
+ * calculated by subtracting the values of hist0, hist1, hist3 and hist4 from
+ * 0xffff as in the following equation:
+ *
+ *	hist2 = 0xffff - (hist0 + hist1 + hist3 + hist4)
+ */
+struct mali_c55_ae_5bin_hist {
+	__u16 hist0;
+	__u16 hist1;
+	__u16 hist3;
+	__u16 hist4;
+} __attribute__((packed));
+
+/**
+ * struct mali_c55_awb_average_ratios - Auto White Balance colour ratios
+ *
+ * @avg_rg_gr:	Average R/G or G/R ratio in Q4.8 format.
+ * @avg_bg_br:	Average B/G or B/R ratio in Q4.8 format.
+ * @num_pixels:	The number of pixels used in the AWB calculation
+ *
+ * The ISP calculates and collects average colour ratios for each zone in an
+ * image and stores them in Q4.8 format (the lowest 8 bits are fractional, with
+ * bits [11:8] representing the integer). The exact ratios collected (either
+ * R/G, B/G or G/R, B/R) are configurable through the parameters buffer. The
+ * value of the 4 high bits is undefined.
+ */
+struct mali_c55_awb_average_ratios {
+	__u16 avg_rg_gr;
+	__u16 avg_bg_br;
+	__u32 num_pixels;
+} __attribute__((packed));
+
+/**
+ * struct mali_c55_af_statistics - Auto Focus edge and intensity statistics
+ *
+ * @intensity_stats:	Packed mantissa and exponent value for pixel intensity
+ * @edge_stats:		Packed mantissa and exponent values for edge intensity
+ *
+ * The ISP collects the squared sum of pixel intensities for each zone within a
+ * configurable Region of Interest on the frame. Additionally, the same data are
+ * collected after being passed through a bandpass filter which removes high and
+ * low frequency components - these are referred to as the edge statistics.
+ *
+ * The intensity and edge statistics for a zone can be used to calculate the
+ * contrast information for a zone
+ *
+ *	C = E2 / I2
+ *
+ * Where I2 is the intensity statistic for a zone and E2 is the edge statistic
+ * for that zone. Optimum focus is reached when C is at its maximum.
+ *
+ * The intensity and edge statistics are stored packed into a non-standard 16
+ * bit floating point format, where the 7 most significant bits represent the
+ * exponent and the 9 least significant bits the mantissa. This format can be
+ * unpacked with the following pseudocode::
+ *
+ *	if (e == 0) {
+ *		x = m;
+ *	} else {
+ *		x = 2^e-1 * (m + 2^9)
+ *	}
+ *
+ * where
+ *	e is the exponent value in range 0..127
+ *	m is the mantissa value in range 0..511
+ */
+struct mali_c55_af_statistics {
+	__u16 intensity_stats;
+	__u16 edge_stats;
+} __attribute__((packed));
+
+/**
+ * struct mali_c55_stats_buffer - 3A statistics for the mali-c55 ISP
+ *
+ * @ae_1024bin_hist:		1024-bin frame-global pixel intensity histogram
+ * @iridix_1024bin_hist:	Post-Iridix block 1024-bin histogram
+ * @ae_5bin_hists:		5-bin pixel intensity histograms for AEC
+ * @reserved1:			Undefined buffer space
+ * @awb_ratios:			Color balance ratios for Auto White Balance
+ * @reserved2:			Undefined buffer space
+ * @af_statistics:		Pixel intensity statistics for Auto Focus
+ * @reserved3:			Undefined buffer space
+ *
+ * This struct describes the metering statistics space in the Mali-C55 ISP's
+ * hardware in its entirety. The space between each defined area is marked as
+ * "unknown" and may not be 0, but should not be used. The @ae_5bin_hists,
+ * @awb_ratios and @af_statistics members are arrays of statistics per-zone.
+ * The zones are arranged in the array in raster order starting from the top
+ * left corner of the image.
+ */
+
+struct mali_c55_stats_buffer {
+	struct mali_c55_ae_1024bin_hist ae_1024bin_hist;
+	struct mali_c55_ae_1024bin_hist iridix_1024bin_hist;
+	struct mali_c55_ae_5bin_hist ae_5bin_hists[MALI_C55_MAX_ZONES];
+	__u32 reserved1[14];
+	struct mali_c55_awb_average_ratios awb_ratios[MALI_C55_MAX_ZONES];
+	__u32 reserved2[14];
+	struct mali_c55_af_statistics af_statistics[MALI_C55_MAX_ZONES];
+	__u32 reserved3[15];
+} __attribute__((packed));
+
+/**
+ * enum mali_c55_param_block_type - Enumeration of Mali-C55 parameter blocks
+ *
+ * This enumeration defines the types of Mali-C55 parameters block. Each block
+ * configures a specific processing block of the Mali-C55 ISP. The block
+ * type allows the driver to correctly interpret the parameters block data.
+ *
+ * It is the responsibility of userspace to correctly set the type of each
+ * parameters block.
+ *
+ * @MALI_C55_PARAM_BLOCK_SENSOR_OFFS: Sensor pre-shading black level offset
+ * @MALI_C55_PARAM_BLOCK_AEXP_HIST: Auto-exposure 1024-bin histogram
+ *				    configuration
+ * @MALI_C55_PARAM_BLOCK_AEXP_IHIST: Post-Iridix auto-exposure 1024-bin
+ *				     histogram configuration
+ * @MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS: Auto-exposure 1024-bin histogram
+ *					    weighting
+ * @MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS: Post-Iridix auto-exposure 1024-bin
+ *					     histogram weighting
+ * @MALI_C55_PARAM_BLOCK_DIGITAL_GAIN: Digital gain
+ * @MALI_C55_PARAM_BLOCK_AWB_GAINS: Auto-white balance gains
+ * @MALI_C55_PARAM_BLOCK_AWB_CONFIG: Auto-white balance statistics config
+ * @MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP: Auto-white balance gains for AEXP-0 tap
+ * @MALI_C55_PARAM_MESH_SHADING_CONFIG : Mesh shading tables configuration
+ * @MALI_C55_PARAM_MESH_SHADING_SELECTION: Mesh shading table selection
+ */
+enum mali_c55_param_block_type {
+	MALI_C55_PARAM_BLOCK_SENSOR_OFFS,
+	MALI_C55_PARAM_BLOCK_AEXP_HIST,
+	MALI_C55_PARAM_BLOCK_AEXP_IHIST,
+	MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS,
+	MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS,
+	MALI_C55_PARAM_BLOCK_DIGITAL_GAIN,
+	MALI_C55_PARAM_BLOCK_AWB_GAINS,
+	MALI_C55_PARAM_BLOCK_AWB_CONFIG,
+	MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP,
+	MALI_C55_PARAM_MESH_SHADING_CONFIG,
+	MALI_C55_PARAM_MESH_SHADING_SELECTION,
+};
+
+/**
+ * struct mali_c55_params_sensor_off_preshading - offset subtraction for each
+ *						  color channel
+ *
+ * Provides removal of the sensor black level from the sensor data. Separate
+ * offsets are provided for each of the four Bayer component color channels
+ * which are defaulted to R, Gr, Gb, B.
+ *
+ * header.type should be set to MALI_C55_PARAM_BLOCK_SENSOR_OFFS from
+ * :c:type:`mali_c55_param_block_type` for this block.
+ *
+ * @header: The Mali-C55 parameters block header
+ * @chan00: Offset for color channel 00 (default: R)
+ * @chan01: Offset for color channel 01 (default: Gr)
+ * @chan10: Offset for color channel 10 (default: Gb)
+ * @chan11: Offset for color channel 11 (default: B)
+ */
+struct mali_c55_params_sensor_off_preshading {
+	struct v4l2_isp_params_block_header header;
+	__u32 chan00;
+	__u32 chan01;
+	__u32 chan10;
+	__u32 chan11;
+};
+
+/**
+ * enum mali_c55_aexp_hist_tap_points - Tap points for the AEXP histogram
+ * @MALI_C55_AEXP_HIST_TAP_WB: After static white balance
+ * @MALI_C55_AEXP_HIST_TAP_FS: After WDR Frame Stitch
+ * @MALI_C55_AEXP_HIST_TAP_TPG: After the test pattern generator
+ */
+enum mali_c55_aexp_hist_tap_points {
+	MALI_C55_AEXP_HIST_TAP_WB = 0,
+	MALI_C55_AEXP_HIST_TAP_FS,
+	MALI_C55_AEXP_HIST_TAP_TPG,
+};
+
+/**
+ * enum mali_c55_aexp_skip_x - Horizontal pixel skipping
+ * @MALI_C55_AEXP_SKIP_X_EVERY_2ND: Collect every 2nd pixel horizontally
+ * @MALI_C55_AEXP_SKIP_X_EVERY_3RD: Collect every 3rd pixel horizontally
+ * @MALI_C55_AEXP_SKIP_X_EVERY_4TH: Collect every 4th pixel horizontally
+ * @MALI_C55_AEXP_SKIP_X_EVERY_5TH: Collect every 5th pixel horizontally
+ * @MALI_C55_AEXP_SKIP_X_EVERY_8TH: Collect every 8th pixel horizontally
+ * @MALI_C55_AEXP_SKIP_X_EVERY_9TH: Collect every 9th pixel horizontally
+ */
+enum mali_c55_aexp_skip_x {
+	MALI_C55_AEXP_SKIP_X_EVERY_2ND,
+	MALI_C55_AEXP_SKIP_X_EVERY_3RD,
+	MALI_C55_AEXP_SKIP_X_EVERY_4TH,
+	MALI_C55_AEXP_SKIP_X_EVERY_5TH,
+	MALI_C55_AEXP_SKIP_X_EVERY_8TH,
+	MALI_C55_AEXP_SKIP_X_EVERY_9TH
+};
+
+/**
+ * enum mali_c55_aexp_skip_y - Vertical pixel skipping
+ * @MALI_C55_AEXP_SKIP_Y_ALL: Collect every single pixel vertically
+ * @MALI_C55_AEXP_SKIP_Y_EVERY_2ND: Collect every 2nd pixel vertically
+ * @MALI_C55_AEXP_SKIP_Y_EVERY_3RD: Collect every 3rd pixel vertically
+ * @MALI_C55_AEXP_SKIP_Y_EVERY_4TH: Collect every 4th pixel vertically
+ * @MALI_C55_AEXP_SKIP_Y_EVERY_5TH: Collect every 5th pixel vertically
+ * @MALI_C55_AEXP_SKIP_Y_EVERY_8TH: Collect every 8th pixel vertically
+ * @MALI_C55_AEXP_SKIP_Y_EVERY_9TH: Collect every 9th pixel vertically
+ */
+enum mali_c55_aexp_skip_y {
+	MALI_C55_AEXP_SKIP_Y_ALL,
+	MALI_C55_AEXP_SKIP_Y_EVERY_2ND,
+	MALI_C55_AEXP_SKIP_Y_EVERY_3RD,
+	MALI_C55_AEXP_SKIP_Y_EVERY_4TH,
+	MALI_C55_AEXP_SKIP_Y_EVERY_5TH,
+	MALI_C55_AEXP_SKIP_Y_EVERY_8TH,
+	MALI_C55_AEXP_SKIP_Y_EVERY_9TH
+};
+
+/**
+ * enum mali_c55_aexp_row_column_offset - Start from the first or second row or
+ *					  column
+ * @MALI_C55_AEXP_FIRST_ROW_OR_COL:	Start from the first row / column
+ * @MALI_C55_AEXP_SECOND_ROW_OR_COL:	Start from the second row / column
+ */
+enum mali_c55_aexp_row_column_offset {
+	MALI_C55_AEXP_FIRST_ROW_OR_COL = 1,
+	MALI_C55_AEXP_SECOND_ROW_OR_COL = 2,
+};
+
+/**
+ * enum mali_c55_aexp_hist_plane_mode - Mode for the AEXP Histograms
+ * @MALI_C55_AEXP_HIST_COMBINED: All color planes in one 1024-bin histogram
+ * @MALI_C55_AEXP_HIST_SEPARATE: Each color plane in one 256-bin histogram with a bin width of 16
+ * @MALI_C55_AEXP_HIST_FOCUS_00: Top left plane in the first bank, rest in second bank
+ * @MALI_C55_AEXP_HIST_FOCUS_01: Top right plane in the first bank, rest in second bank
+ * @MALI_C55_AEXP_HIST_FOCUS_10: Bottom left plane in the first bank, rest in second bank
+ * @MALI_C55_AEXP_HIST_FOCUS_11: Bottom right plane in the first bank, rest in second bank
+ *
+ * In the "focus" modes statistics are collected into two 512-bin histograms
+ * with a bin width of 8. One colour plane is in the first histogram with the
+ * remainder combined into the second. The four options represent which of the
+ * four positions in a bayer pattern are the focused plane.
+ */
+enum mali_c55_aexp_hist_plane_mode {
+	MALI_C55_AEXP_HIST_COMBINED = 0,
+	MALI_C55_AEXP_HIST_SEPARATE = 1,
+	MALI_C55_AEXP_HIST_FOCUS_00 = 4,
+	MALI_C55_AEXP_HIST_FOCUS_01 = 5,
+	MALI_C55_AEXP_HIST_FOCUS_10 = 6,
+	MALI_C55_AEXP_HIST_FOCUS_11 = 7,
+};
+
+/**
+ * struct mali_c55_params_aexp_hist - configuration for AEXP metering hists
+ *
+ * This struct allows users to configure the 1024-bin AEXP histograms. Broadly
+ * speaking the parameters allow you to mask particular regions of the image and
+ * to select different kinds of histogram.
+ *
+ * The skip_x, offset_x, skip_y and offset_y fields allow users to ignore or
+ * mask pixels in the frame by their position relative to the top left pixel.
+ * First, the skip_y, offset_x and offset_y fields define which of the pixels
+ * within each 2x2 region will be counted in the statistics.
+ *
+ * If skip_y == 0 then two pixels from each covered region will be counted. If
+ * both offset_x and offset_y are zero, then the two left-most pixels in each
+ * 2x2 pixel region will be counted. Setting offset_x = 1 will discount the top
+ * left pixel and count the top right pixel. Setting offset_y = 1 will discount
+ * the bottom left pixel and count the bottom right pixel.
+ *
+ * If skip_y != 0 then only a single pixel from each region covered by the
+ * pattern will be counted. In this case offset_x controls whether the pixel
+ * that's counted is in the left (if offset_x == 0) or right (if offset_x == 1)
+ * column and offset_y controls whether the pixel that's counted is in the top
+ * (if offset_y == 0) or bottom (if offset_y == 1) row.
+ *
+ * The skip_x and skip_y fields control how the 2x2 pixel region is repeated
+ * across the image data. The first instance of the region is always in the top
+ * left of the image data. The skip_x field controls how many pixels are ignored
+ * in the x direction before the pixel masking region is repeated. The skip_y
+ * field controls how many pixels are ignored in the y direction before the
+ * pixel masking region is repeated.
+ *
+ * These fields can be used to reduce the number of pixels counted for the
+ * statistics, but it's important to be careful to configure them correctly.
+ * Some combinations of values will result in colour components from the input
+ * data being ignored entirely, for example in the following configuration:
+ *
+ * skip_x = 0
+ * offset_x = 0
+ * skip_y = 0
+ * offset_y = 0
+ *
+ * Only the R and Gb components of RGGB data that was input would be collected.
+ * Similarly in the following configuration:
+ *
+ * skip_x = 0
+ * offset_x = 0
+ * skip_y = 1
+ * offset_y = 1
+ *
+ * Only the Gb component of RGGB data that was input would be collected. To
+ * correct things such that all 4 colour components were included it would be
+ * necessary to set the skip_x and skip_y fields in a way that resulted in all
+ * four colour components being collected:
+ *
+ * skip_x = 1
+ * offset_x = 0
+ * skip_y = 1
+ * offset_y = 1
+ *
+ * header.type should be set to one of either MALI_C55_PARAM_BLOCK_AEXP_HIST or
+ * MALI_C55_PARAM_BLOCK_AEXP_IHIST from :c:type:`mali_c55_param_block_type`.
+ *
+ * @header:		The Mali-C55 parameters block header
+ * @skip_x:		Horizontal decimation. See enum mali_c55_aexp_skip_x
+ * @offset_x:		Skip the first column, or not. See enum mali_c55_aexp_row_column_offset
+ * @skip_y:		Vertical decimation. See enum mali_c55_aexp_skip_y
+ * @offset_y:		Skip the first row, or not. See enum mali_c55_aexp_row_column_offset
+ * @scale_bottom:	Scale pixels in bottom half of intensity range: 0=1x ,1=2x, 2=4x, 4=8x, 4=16x
+ * @scale_top:		scale pixels in top half of intensity range: 0=1x ,1=2x, 2=4x, 4=8x, 4=16x
+ * @plane_mode:		Plane separation mode. See enum mali_c55_aexp_hist_plane_mode
+ * @tap_point:		Tap point for histogram from enum mali_c55_aexp_hist_tap_points.
+ *			This parameter is unused for the post-Iridix Histogram
+ */
+struct mali_c55_params_aexp_hist {
+	struct v4l2_isp_params_block_header header;
+	__u8 skip_x;
+	__u8 offset_x;
+	__u8 skip_y;
+	__u8 offset_y;
+	__u8 scale_bottom;
+	__u8 scale_top;
+	__u8 plane_mode;
+	__u8 tap_point;
+};
+
+/**
+ * struct mali_c55_params_aexp_weights - Array of weights for AEXP metering
+ *
+ * This struct allows users to configure the weighting for both of the 1024-bin
+ * AEXP histograms. The pixel data collected for each zone is multiplied by the
+ * corresponding weight from this array, which may be zero if the intention is
+ * to mask off the zone entirely.
+ *
+ * header.type should be set to one of either MALI_C55_PARAM_BLOCK_AEXP_HIST_WEIGHTS
+ * or MALI_C55_PARAM_BLOCK_AEXP_IHIST_WEIGHTS from :c:type:`mali_c55_param_block_type`.
+ *
+ * @header:		The Mali-C55 parameters block header
+ * @nodes_used_horiz:	Number of active zones horizontally [0..15]
+ * @nodes_used_vert:	Number of active zones vertically [0..15]
+ * @zone_weights:	Zone weighting. Index is row*col where 0,0 is the top
+ *			left zone continuing in raster order. Each zone can be
+ *			weighted in the range [0..15]. The number of rows and
+ *			columns is defined by @nodes_used_vert and
+ *			@nodes_used_horiz
+ */
+struct mali_c55_params_aexp_weights {
+	struct v4l2_isp_params_block_header header;
+	__u8 nodes_used_horiz;
+	__u8 nodes_used_vert;
+	__u8 zone_weights[MALI_C55_MAX_ZONES];
+};
+
+/**
+ * struct mali_c55_params_digital_gain - Digital gain value
+ *
+ * This struct carries a digital gain value to set in the ISP.
+ *
+ * header.type should be set to MALI_C55_PARAM_BLOCK_DIGITAL_GAIN from
+ * :c:type:`mali_c55_param_block_type` for this block.
+ *
+ * @header:	The Mali-C55 parameters block header
+ * @gain:	The digital gain value to apply, in Q5.8 format.
+ */
+struct mali_c55_params_digital_gain {
+	struct v4l2_isp_params_block_header header;
+	__u16 gain;
+};
+
+/**
+ * enum mali_c55_awb_stats_mode - Statistics mode for AWB
+ * @MALI_C55_AWB_MODE_GRBR: Statistics collected as Green/Red and Blue/Red ratios
+ * @MALI_C55_AWB_MODE_RGBG: Statistics collected as Red/Green and Blue/Green ratios
+ */
+enum mali_c55_awb_stats_mode {
+	MALI_C55_AWB_MODE_GRBR = 0,
+	MALI_C55_AWB_MODE_RGBG,
+};
+
+/**
+ * struct mali_c55_params_awb_gains - Gain settings for auto white balance
+ *
+ * This struct allows users to configure the gains for auto-white balance. There
+ * are four gain settings corresponding to each colour channel in the bayer
+ * domain. Although named generically, the association between the gain applied
+ * and the colour channel is done automatically within the ISP depending on the
+ * input format, and so the following mapping always holds true::
+ *
+ *	gain00 = R
+ *	gain01 = Gr
+ *	gain10 = Gb
+ *	gain11 = B
+ *
+ * All of the gains are stored in Q4.8 format.
+ *
+ * header.type should be set to one of either MALI_C55_PARAM_BLOCK_AWB_GAINS or
+ * MALI_C55_PARAM_BLOCK_AWB_GAINS_AEXP from :c:type:`mali_c55_param_block_type`.
+ *
+ * @header:	The Mali-C55 parameters block header
+ * @gain00:	Multiplier for colour channel 00
+ * @gain01:	Multiplier for colour channel 01
+ * @gain10:	Multiplier for colour channel 10
+ * @gain11:	Multiplier for colour channel 11
+ */
+struct mali_c55_params_awb_gains {
+	struct v4l2_isp_params_block_header header;
+	__u16 gain00;
+	__u16 gain01;
+	__u16 gain10;
+	__u16 gain11;
+};
+
+/**
+ * enum mali_c55_params_awb_tap_points - Tap points for the AWB statistics
+ * @MALI_C55_AWB_STATS_TAP_PF: Immediately after the Purple Fringe block
+ * @MALI_C55_AWB_STATS_TAP_CNR: Immediately after the CNR block
+ */
+enum mali_c55_params_awb_tap_points {
+	MALI_C55_AWB_STATS_TAP_PF = 0,
+	MALI_C55_AWB_STATS_TAP_CNR,
+};
+
+/**
+ * struct mali_c55_params_awb_config - Stats settings for auto-white balance
+ *
+ * This struct allows the configuration of the statistics generated for auto
+ * white balance. Pixel intensity limits can be set to exclude overly bright or
+ * dark regions of an image from the statistics entirely. Colour ratio minima
+ * and maxima can be set to discount pixels who's ratios fall outside the
+ * defined boundaries; there are two sets of registers to do this - the
+ * "min/max" ratios which bound a region and the "high/low" ratios which further
+ * trim the upper and lower ratios. For example with the boundaries configured
+ * as follows, only pixels whos colour ratios falls into the region marked "A"
+ * would be counted::
+ *
+ *	                                                          cr_high
+ *	    2.0 |                                                   |
+ *	        |               cb_max --> _________________________v_____
+ *	    1.8 |                         |                         \    |
+ *	        |                         |                          \   |
+ *	    1.6 |                         |                           \  |
+ *	        |                         |                            \ |
+ *	 c  1.4 |               cb_low -->|\              A             \|<--  cb_high
+ *	 b      |                         | \                            |
+ *	    1.2 |                         |  \                           |
+ *	 r      |                         |   \                          |
+ *	 a  1.0 |              cb_min --> |____\_________________________|
+ *	 t      |                         ^    ^                         ^
+ *	 i  0.8 |                         |    |                         |
+ *	 o      |                      cr_min  |                       cr_max
+ *	 s  0.6 |                              |
+ *	        |                             cr_low
+ *	    0.4 |
+ *	        |
+ *	    0.2 |
+ *	        |
+ *	    0.0 |_______________________________________________________________
+ *	        0.0   0.2   0.4   0.6   0.8   1.0   1.2   1.4   1.6   1.8   2.0
+ *	                                   cr ratios
+ *
+ * header.type should be set to MALI_C55_PARAM_BLOCK_AWB_CONFIG from
+ * :c:type:`mali_c55_param_block_type` for this block.
+ *
+ * @header:		The Mali-C55 parameters block header
+ * @tap_point:		The tap point from enum mali_c55_params_awb_tap_points
+ * @stats_mode:		AWB statistics collection mode, see :c:type:`mali_c55_awb_stats_mode`
+ * @white_level:	Upper pixel intensity (I.E. raw pixel values) limit
+ * @black_level:	Lower pixel intensity (I.E. raw pixel values) limit
+ * @cr_max:		Maximum R/G ratio (Q4.8 format)
+ * @cr_min:		Minimum R/G ratio (Q4.8 format)
+ * @cb_max:		Maximum B/G ratio (Q4.8 format)
+ * @cb_min:		Minimum B/G ratio (Q4.8 format)
+ * @nodes_used_horiz:	Number of active zones horizontally [0..15]
+ * @nodes_used_vert:	Number of active zones vertically [0..15]
+ * @cr_high:		R/G ratio trim high (Q4.8 format)
+ * @cr_low:		R/G ratio trim low (Q4.8 format)
+ * @cb_high:		B/G ratio trim high (Q4.8 format)
+ * @cb_low:		B/G ratio trim low (Q4.8 format)
+ */
+struct mali_c55_params_awb_config {
+	struct v4l2_isp_params_block_header header;
+	__u8 tap_point;
+	__u8 stats_mode;
+	__u16 white_level;
+	__u16 black_level;
+	__u16 cr_max;
+	__u16 cr_min;
+	__u16 cb_max;
+	__u16 cb_min;
+	__u8 nodes_used_horiz;
+	__u8 nodes_used_vert;
+	__u16 cr_high;
+	__u16 cr_low;
+	__u16 cb_high;
+	__u16 cb_low;
+};
+
+#define MALI_C55_NUM_MESH_SHADING_ELEMENTS 3072
+
+/**
+ * struct mali_c55_params_mesh_shading_config - Mesh shading configuration
+ *
+ * The mesh shading correction module allows programming a separate table of
+ * either 16x16 or 32x32 node coefficients for 3 different light sources. The
+ * final correction coefficients applied are computed by blending the
+ * coefficients from two tables together.
+ *
+ * A page of 1024 32-bit integers is associated to each colour channel, with
+ * pages stored consecutively in memory. Each 32-bit integer packs 3 8-bit
+ * correction coefficients for a single node, one for each of the three light
+ * sources. The 8 most significant bits are unused. The following table
+ * describes the layout::
+ *
+ *	+----------- Page (Colour Plane) 0 -------------+
+ *	| @mesh[i]  | Mesh Point | Bits  | Light Source |
+ *	+-----------+------------+-------+--------------+
+ *	|         0 |        0,0 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *	|         1 |        0,1 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *	|       ... |        ... | ...   | ...          |
+ *	+-----------+------------+-------+--------------+
+ *	|      1023 |      31,31 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+----------- Page (Colour Plane) 1 -------------+
+ *	| @mesh[i]  | Mesh Point | Bits  | Light Source |
+ *	+-----------+------------+-------+--------------+
+ *	|      1024 |        0,0 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *	|      1025 |        0,1 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *	|       ... |        ... | ...   | ...          |
+ *	+-----------+------------+-------+--------------+
+ *	|      2047 |      31,31 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+----------- Page (Colour Plane) 2 -------------+
+ *	| @mesh[i]  | Mesh Point | Bits  | Light Source |
+ *	+-----------+------------+-------+--------------+
+ *	|      2048 |        0,0 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *	|      2049 |        0,1 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *	|       ... |        ... | ...   | ...          |
+ *	+-----------+------------+-------+--------------+
+ *	|      3071 |      31,31 | 16,23 | LS2          |
+ *	|           |            | 08-15 | LS1          |
+ *	|           |            | 00-07 | LS0          |
+ *	+-----------+------------+-------+--------------+
+ *
+ * The @mesh_scale member determines the precision and minimum and maximum gain.
+ * For example if @mesh_scale is 0 and therefore selects 0 - 2x gain, a value of
+ * 0 in a coefficient means 0.0 gain, a value of 128 means 1.0 gain and 255
+ * means 2.0 gain.
+ *
+ * header.type should be set to MALI_C55_PARAM_MESH_SHADING_CONFIG from
+ * :c:type:`mali_c55_param_block_type` for this block.
+ *
+ * @header:		The Mali-C55 parameters block header
+ * @mesh_show:		Output the mesh data rather than image data
+ * @mesh_scale:		Set the precision and maximum gain range of mesh shading
+ *				- 0 = 0-2x gain
+ *				- 1 = 0-4x gain
+ *				- 2 = 0-8x gain
+ *				- 3 = 0-16x gain
+ *				- 4 = 1-2x gain
+ *				- 5 = 1-3x gain
+ *				- 6 = 1-5x gain
+ *				- 7 = 1-9x gain
+ * @mesh_page_r:	Mesh page select for red colour plane [0..2]
+ * @mesh_page_g:	Mesh page select for green colour plane [0..2]
+ * @mesh_page_b:	Mesh page select for blue colour plane [0..2]
+ * @mesh_width:		Number of horizontal nodes minus 1 [15,31]
+ * @mesh_height:	Number of vertical nodes minus 1 [15,31]
+ * @mesh:		Mesh shading correction tables
+ */
+struct mali_c55_params_mesh_shading_config {
+	struct v4l2_isp_params_block_header header;
+	__u8 mesh_show;
+	__u8 mesh_scale;
+	__u8 mesh_page_r;
+	__u8 mesh_page_g;
+	__u8 mesh_page_b;
+	__u8 mesh_width;
+	__u8 mesh_height;
+	__u32 mesh[MALI_C55_NUM_MESH_SHADING_ELEMENTS];
+};
+
+/** enum mali_c55_params_mesh_alpha_bank - Mesh shading table bank selection
+ * @MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS1 - Select Light Sources 0 and 1
+ * @MALI_C55_MESH_ALPHA_BANK_LS1_AND_LS2 - Select Light Sources 1 and 2
+ * @MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS2 - Select Light Sources 0 and 2
+ */
+enum mali_c55_params_mesh_alpha_bank {
+	MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS1 = 0,
+	MALI_C55_MESH_ALPHA_BANK_LS1_AND_LS2 = 1,
+	MALI_C55_MESH_ALPHA_BANK_LS0_AND_LS2 = 4
+};
+
+/**
+ * struct mali_c55_params_mesh_shading_selection - Mesh table selection
+ *
+ * The module computes the final correction coefficients by blending the ones
+ * from two light source tables, which are selected (independently for each
+ * colour channel) by the @mesh_alpha_bank_r/g/b fields.
+ *
+ * The final blended coefficients for each node are calculated using the
+ * following equation:
+ *
+ *     Final coefficient = (a * LS\ :sub:`b`\ + (256 - a) * LS\ :sub:`a`\) / 256
+ *
+ * Where a is the @mesh_alpha_r/g/b value, and LS\ :sub:`a`\ and LS\ :sub:`b`\
+ * are the node cofficients for the two tables selected by the
+ * @mesh_alpha_bank_r/g/b value.
+ *
+ * The scale of the applied correction may also be controlled by tuning the
+ * @mesh_strength member. This is a modifier to the final coefficients which can
+ * be used to globally reduce the gains applied.
+ *
+ * header.type should be set to MALI_C55_PARAM_MESH_SHADING_SELECTION from
+ * :c:type:`mali_c55_param_block_type` for this block.
+ *
+ * @header:		The Mali-C55 parameters block header
+ * @mesh_alpha_bank_r:	Red mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
+ * @mesh_alpha_bank_g:	Green mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
+ * @mesh_alpha_bank_b:	Blue mesh table select (c:type:`enum mali_c55_params_mesh_alpha_bank`)
+ * @mesh_alpha_r:	Blend coefficient for R [0..255]
+ * @mesh_alpha_g:	Blend coefficient for G [0..255]
+ * @mesh_alpha_b:	Blend coefficient for B [0..255]
+ * @mesh_strength:	Mesh strength in Q4.12 format [0..4096]
+ */
+struct mali_c55_params_mesh_shading_selection {
+	struct v4l2_isp_params_block_header header;
+	__u8 mesh_alpha_bank_r;
+	__u8 mesh_alpha_bank_g;
+	__u8 mesh_alpha_bank_b;
+	__u8 mesh_alpha_r;
+	__u8 mesh_alpha_g;
+	__u8 mesh_alpha_b;
+	__u16 mesh_strength;
+};
+
+/**
+ * define MALI_C55_PARAMS_MAX_SIZE - Maximum size of all Mali C55 Parameters
+ *
+ * Though the parameters for the Mali-C55 are passed as optional blocks, the
+ * driver still needs to know the absolute maximum size so that it can allocate
+ * a buffer sized appropriately to accommodate userspace attempting to set all
+ * possible parameters in a single frame.
+ *
+ * Some structs are in this list multiple times. Where that's the case, it just
+ * reflects the fact that the same struct can be used with multiple different
+ * header types from :c:type:`mali_c55_param_block_type`.
+ */
+#define MALI_C55_PARAMS_MAX_SIZE				\
+	(sizeof(struct mali_c55_params_sensor_off_preshading) +	\
+	sizeof(struct mali_c55_params_aexp_hist) +		\
+	sizeof(struct mali_c55_params_aexp_weights) +		\
+	sizeof(struct mali_c55_params_aexp_hist) +		\
+	sizeof(struct mali_c55_params_aexp_weights) +		\
+	sizeof(struct mali_c55_params_digital_gain) +		\
+	sizeof(struct mali_c55_params_awb_gains) +		\
+	sizeof(struct mali_c55_params_awb_config) +		\
+	sizeof(struct mali_c55_params_awb_gains) +		\
+	sizeof(struct mali_c55_params_mesh_shading_config) +	\
+	sizeof(struct mali_c55_params_mesh_shading_selection))
+
+#endif /* __UAPI_MALI_C55_CONFIG_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/media/v4l2-isp.h b/lib/libc/include/any-linux-any/linux/media/v4l2-isp.h
new file mode 100644
index 0000000000000000000000000000000000000000..20e61e299ceea201f2af68ec25431277118612b3
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/media/v4l2-isp.h
@@ -0,0 +1,102 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Video4Linux2 generic ISP parameters and statistics support
+ *
+ * Copyright (C) 2025 Ideas On Board Oy
+ * Author: Jacopo Mondi <jacopo.mondi@ideasonboard.com>
+ */
+
+#ifndef _V4L2_ISP_H_
+#define _V4L2_ISP_H_
+
+#include <linux/stddef.h>
+#include <linux/types.h>
+
+/**
+ * enum v4l2_isp_params_version - V4L2 ISP parameters versioning
+ *
+ * @V4L2_ISP_PARAMS_VERSION_V0: First version of the V4L2 ISP parameters format
+ *				(for compatibility)
+ * @V4L2_ISP_PARAMS_VERSION_V1: First version of the V4L2 ISP parameters format
+ *
+ * V0 and V1 are identical in order to support drivers compatible with the V4L2
+ * ISP parameters format already upstreamed which use either 0 or 1 as their
+ * versioning identifier. Both V0 and V1 refers to the first version of the
+ * V4L2 ISP parameters format.
+ *
+ * Future revisions of the V4L2 ISP parameters format should start from the
+ * value of 2.
+ */
+enum v4l2_isp_params_version {
+	V4L2_ISP_PARAMS_VERSION_V0 = 0,
+	V4L2_ISP_PARAMS_VERSION_V1
+};
+
+#define V4L2_ISP_PARAMS_FL_BLOCK_DISABLE	(1U << 0)
+#define V4L2_ISP_PARAMS_FL_BLOCK_ENABLE		(1U << 1)
+
+/*
+ * Reserve the first 8 bits for V4L2_ISP_PARAMS_FL_* flag.
+ *
+ * Driver-specific flags should be defined as:
+ * #define DRIVER_SPECIFIC_FLAG0     ((1U << V4L2_ISP_PARAMS_FL_DRIVER_FLAGS(0))
+ * #define DRIVER_SPECIFIC_FLAG1     ((1U << V4L2_ISP_PARAMS_FL_DRIVER_FLAGS(1))
+ */
+#define V4L2_ISP_PARAMS_FL_DRIVER_FLAGS(n)       ((n) + 8)
+
+/**
+ * struct v4l2_isp_params_block_header - V4L2 extensible parameters block header
+ * @type: The parameters block type (driver-specific)
+ * @flags: A bitmask of block flags (driver-specific)
+ * @size: Size (in bytes) of the parameters block, including this header
+ *
+ * This structure represents the common part of all the ISP configuration
+ * blocks. Each parameters block shall embed an instance of this structure type
+ * as its first member, followed by the block-specific configuration data.
+ *
+ * The @type field is an ISP driver-specific value that identifies the block
+ * type. The @size field specifies the size of the parameters block.
+ *
+ * The @flags field is a bitmask of per-block flags V4L2_PARAMS_ISP_FL_* and
+ * driver-specific flags specified by the driver header.
+ */
+struct v4l2_isp_params_block_header {
+	__u16 type;
+	__u16 flags;
+	__u32 size;
+} __attribute__((aligned(8)));
+
+/**
+ * struct v4l2_isp_params_buffer - V4L2 extensible parameters configuration
+ * @version: The parameters buffer version (driver-specific)
+ * @data_size: The configuration data effective size, excluding this header
+ * @data: The configuration data
+ *
+ * This structure contains the configuration parameters of the ISP algorithms,
+ * serialized by userspace into a data buffer. Each configuration parameter
+ * block is represented by a block-specific structure which contains a
+ * :c:type:`v4l2_isp_params_block_header` entry as first member. Userspace
+ * populates the @data buffer with configuration parameters for the blocks that
+ * it intends to configure. As a consequence, the data buffer effective size
+ * changes according to the number of ISP blocks that userspace intends to
+ * configure and is set by userspace in the @data_size field.
+ *
+ * The parameters buffer is versioned by the @version field to allow modifying
+ * and extending its definition. Userspace shall populate the @version field to
+ * inform the driver about the version it intends to use. The driver will parse
+ * and handle the @data buffer according to the data layout specific to the
+ * indicated version and return an error if the desired version is not
+ * supported.
+ *
+ * For each ISP block that userspace wants to configure, a block-specific
+ * structure is appended to the @data buffer, one after the other without gaps
+ * in between. Userspace shall populate the @data_size field with the effective
+ * size, in bytes, of the @data buffer.
+ */
+struct v4l2_isp_params_buffer {
+	__u32 version;
+	__u32 data_size;
+	__u8 data[] __counted_by(data_size);
+};
+
+#endif /* _V4L2_ISP_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/mempolicy.h b/lib/libc/include/any-linux-any/linux/mempolicy.h
index 2df80acf65439bc015f3d3a1a43473462399fabb..9943941832dd875a1b9f1dc07657ef75c665689d 100644
--- a/lib/libc/include/any-linux-any/linux/mempolicy.h
+++ b/lib/libc/include/any-linux-any/linux/mempolicy.h
@@ -66,10 +66,16 @@ enum {
 #define MPOL_F_MORON	(1 << 4) /* Migrate On protnone Reference On Node */
 
 /*
- * These bit locations are exposed in the vm.zone_reclaim_mode sysctl
- * ABI.  New bits are OK, but existing bits can never change.
+ * Enabling zone reclaim means the page allocator will attempt to fulfill
+ * the allocation request on the current node by triggering reclaim and
+ * trying to shrink the current node.
+ * Fallback allocations on the next candidates in the zonelist are considered
+ * when reclaim fails to free up enough memory in the current node/zone.
+ *
+ * These bit locations are exposed in the vm.zone_reclaim_mode sysctl.
+ * New bits are OK, but existing bits should not be changed.
  */
-#define RECLAIM_ZONE	(1<<0)	/* Run shrink_inactive_list on the zone */
+#define RECLAIM_ZONE	(1<<0)	/* Enable zone reclaim */
 #define RECLAIM_WRITE	(1<<1)	/* Writeout pages during reclaim */
 #define RECLAIM_UNMAP	(1<<2)	/* Unmap pages during reclaim */
 
diff --git a/lib/libc/include/any-linux-any/linux/mount.h b/lib/libc/include/any-linux-any/linux/mount.h
index 5062431943951bf3ea9a36032b3c4d13f0b2b4c1..9fd5d88023bfdfd2b2eb4bca2621d914948836f4 100644
--- a/lib/libc/include/any-linux-any/linux/mount.h
+++ b/lib/libc/include/any-linux-any/linux/mount.h
@@ -197,7 +197,7 @@ struct statmount {
  */
 struct mnt_id_req {
 	__u32 size;
-	__u32 spare;
+	__u32 mnt_ns_fd;
 	__u64 mnt_id;
 	__u64 param;
 	__u64 mnt_ns_id;
diff --git a/lib/libc/include/any-linux-any/linux/mptcp.h b/lib/libc/include/any-linux-any/linux/mptcp.h
index 7abe4077f71e59204c1f6b936f38f90ac7a4c8a2..766139324f9f62d7022f81059b2c684b60b774b2 100644
--- a/lib/libc/include/any-linux-any/linux/mptcp.h
+++ b/lib/libc/include/any-linux-any/linux/mptcp.h
@@ -30,20 +30,28 @@
 #define MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED	_BITUL(1)
 
 #define MPTCP_PM_EV_FLAG_DENY_JOIN_ID0		_BITUL(0)
+#define MPTCP_PM_EV_FLAG_SERVER_SIDE		_BITUL(1)
 
-#define MPTCP_PM_ADDR_FLAG_SIGNAL                      (1 << 0)
-#define MPTCP_PM_ADDR_FLAG_SUBFLOW                     (1 << 1)
-#define MPTCP_PM_ADDR_FLAG_BACKUP                      (1 << 2)
-#define MPTCP_PM_ADDR_FLAG_FULLMESH                    (1 << 3)
-#define MPTCP_PM_ADDR_FLAG_IMPLICIT                    (1 << 4)
+#define MPTCP_PM_ADDR_FLAG_SIGNAL		_BITUL(0)
+#define MPTCP_PM_ADDR_FLAG_SUBFLOW		_BITUL(1)
+#define MPTCP_PM_ADDR_FLAG_BACKUP		_BITUL(2)
+#define MPTCP_PM_ADDR_FLAG_FULLMESH		_BITUL(3)
+#define MPTCP_PM_ADDR_FLAG_IMPLICIT		_BITUL(4)
+#define MPTCP_PM_ADDR_FLAG_LAMINAR		_BITUL(5)
+#define MPTCP_PM_ADDR_FLAGS_MASK		GENMASK(5, 0)
 
 struct mptcp_info {
 	__u8	mptcpi_subflows;
+	#define mptcpi_extra_subflows mptcpi_subflows
 	__u8	mptcpi_add_addr_signal;
 	__u8	mptcpi_add_addr_accepted;
 	__u8	mptcpi_subflows_max;
+	#define mptcpi_limit_extra_subflows mptcpi_subflows_max
 	__u8	mptcpi_add_addr_signal_max;
+	#define mptcpi_endp_signal_max mptcpi_add_addr_signal_max
 	__u8	mptcpi_add_addr_accepted_max;
+	#define mptcpi_limit_add_addr_accepted mptcpi_add_addr_accepted_max
+	/* 16-bit hole that can no longer be filled */
 	__u32	mptcpi_flags;
 	__u32	mptcpi_token;
 	__u64	mptcpi_write_seq;
@@ -51,14 +59,18 @@ struct mptcp_info {
 	__u64	mptcpi_rcv_nxt;
 	__u8	mptcpi_local_addr_used;
 	__u8	mptcpi_local_addr_max;
+	#define mptcpi_endp_subflow_max mptcpi_local_addr_max
 	__u8	mptcpi_csum_enabled;
+	/* 8-bit hole that can no longer be filled */
 	__u32	mptcpi_retransmits;
 	__u64	mptcpi_bytes_retrans;
 	__u64	mptcpi_bytes_sent;
 	__u64	mptcpi_bytes_received;
 	__u64	mptcpi_bytes_acked;
 	__u8	mptcpi_subflows_total;
-	__u8	reserved[3];
+	__u8	mptcpi_endp_laminar_max;
+	__u8	mptcpi_endp_fullmesh_max;
+	__u8	reserved;
 	__u32	mptcpi_last_data_sent;
 	__u32	mptcpi_last_data_recv;
 	__u32	mptcpi_last_ack_recv;
diff --git a/lib/libc/include/any-linux-any/linux/mptcp_pm.h b/lib/libc/include/any-linux-any/linux/mptcp_pm.h
index 9dd09b314f736953672892a918f4e5786f560c91..eb12cf124c26e4c7b464aa1b971b6562ff64a744 100644
--- a/lib/libc/include/any-linux-any/linux/mptcp_pm.h
+++ b/lib/libc/include/any-linux-any/linux/mptcp_pm.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/mptcp_pm.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_MPTCP_PM_H
 #define _LINUX_MPTCP_PM_H
@@ -16,10 +17,10 @@
  *   good time to allocate memory and send ADD_ADDR if needed. Depending on the
  *   traffic-patterns it can take a long time until the MPTCP_EVENT_ESTABLISHED
  *   is sent. Attributes: token, family, saddr4 | saddr6, daddr4 | daddr6,
- *   sport, dport, server-side, [flags].
+ *   sport, dport, [server-side], [flags].
  * @MPTCP_EVENT_ESTABLISHED: A MPTCP connection is established (can start new
  *   subflows). Attributes: token, family, saddr4 | saddr6, daddr4 | daddr6,
- *   sport, dport, server-side, [flags].
+ *   sport, dport, [server-side], [flags].
  * @MPTCP_EVENT_CLOSED: A MPTCP connection has stopped. Attribute: token.
  * @MPTCP_EVENT_ANNOUNCED: A new address has been announced by the peer.
  *   Attributes: token, rem_id, family, daddr4 | daddr6 [, dport].
diff --git a/lib/libc/include/any-linux-any/linux/mshv.h b/lib/libc/include/any-linux-any/linux/mshv.h
index 1fccce47aec36d24ff1ab698fc4dd8703f1aa48a..7e542a818e0ab8159c6892a4ee002d71c5d0da43 100644
--- a/lib/libc/include/any-linux-any/linux/mshv.h
+++ b/lib/libc/include/any-linux-any/linux/mshv.h
@@ -26,6 +26,7 @@ enum {
 	MSHV_PT_BIT_LAPIC,
 	MSHV_PT_BIT_X2APIC,
 	MSHV_PT_BIT_GPA_SUPER_PAGES,
+	MSHV_PT_BIT_CPU_AND_XSAVE_FEATURES,
 	MSHV_PT_BIT_COUNT,
 };
 
@@ -41,6 +42,8 @@ enum {
  * @pt_flags: Bitmask of 1 << MSHV_PT_BIT_*
  * @pt_isolation: MSHV_PT_ISOLATION_*
  *
+ * This is the initial/v1 version for backward compatibility.
+ *
  * Returns a file descriptor to act as a handle to a guest partition.
  * At this point the partition is not yet initialized in the hypervisor.
  * Some operations must be done with the partition in this state, e.g. setting
@@ -52,6 +55,37 @@ struct mshv_create_partition {
 	__u64 pt_isolation;
 };
 
+#define MSHV_NUM_CPU_FEATURES_BANKS 2
+
+/**
+ * struct mshv_create_partition_v2
+ *
+ * This is extended version of the above initial MSHV_CREATE_PARTITION
+ * ioctl and allows for following additional parameters:
+ *
+ * @pt_num_cpu_fbanks: Must be set to MSHV_NUM_CPU_FEATURES_BANKS.
+ * @pt_cpu_fbanks: Disabled processor feature banks array.
+ * @pt_disabled_xsave: Disabled xsave feature bits.
+ *
+ * pt_cpu_fbanks and pt_disabled_xsave are passed through as-is to the create
+ * partition hypercall.
+ *
+ * Returns : same as above original mshv_create_partition
+ */
+struct mshv_create_partition_v2 {
+	__u64 pt_flags;
+	__u64 pt_isolation;
+	__u16 pt_num_cpu_fbanks;
+	__u8  pt_rsvd[6];		/* MBZ */
+	__u64 pt_cpu_fbanks[MSHV_NUM_CPU_FEATURES_BANKS];
+	__u64 pt_rsvd1[2];		/* MBZ */
+#if defined(__x86_64__)
+	__u64 pt_disabled_xsave;
+#else
+	__u64 pt_rsvd2;			/* MBZ */
+#endif
+} __attribute__((packed));
+
 /* /dev/mshv */
 #define MSHV_CREATE_PARTITION	_IOW(MSHV_IOCTL, 0x00, struct mshv_create_partition)
 
@@ -89,7 +123,7 @@ enum {
  * @rsvd: MBZ
  *
  * Map or unmap a region of userspace memory to Guest Physical Addresses (GPA).
- * Mappings can't overlap in GPA space or userspace.
+ * Mappings can't overlap in GPA space.
  * To unmap, these fields must match an existing mapping.
  */
 struct mshv_user_mem_region {
@@ -288,4 +322,84 @@ struct mshv_get_set_vp_state {
  * #define MSHV_ROOT_HVCALL			_IOWR(MSHV_IOCTL, 0x07, struct mshv_root_hvcall)
  */
 
+/* Structure definitions, macros and IOCTLs for mshv_vtl */
+
+#define MSHV_CAP_CORE_API_STABLE        0x0
+#define MSHV_CAP_REGISTER_PAGE          0x1
+#define MSHV_CAP_VTL_RETURN_ACTION      0x2
+#define MSHV_CAP_DR6_SHARED             0x3
+#define MSHV_MAX_RUN_MSG_SIZE                256
+
+struct mshv_vp_registers {
+	__u32 count;	/* supports only 1 register at a time */
+	__u32 reserved; /* Reserved for alignment or future use */
+	__u64 regs_ptr;	/* pointer to struct hv_register_assoc */
+};
+
+struct mshv_vtl_set_eventfd {
+	__s32 fd;
+	__u32 flag;
+};
+
+struct mshv_vtl_signal_event {
+	__u32 connection_id;
+	__u32 flag;
+};
+
+struct mshv_vtl_sint_post_msg {
+	__u64 message_type;
+	__u32 connection_id;
+	__u32 payload_size; /* Must not exceed HV_MESSAGE_PAYLOAD_BYTE_COUNT */
+	__u64 payload_ptr; /* pointer to message payload (bytes) */
+};
+
+struct mshv_vtl_ram_disposition {
+	__u64 start_pfn;
+	__u64 last_pfn;
+};
+
+struct mshv_vtl_set_poll_file {
+	__u32 cpu;
+	__u32 fd;
+};
+
+struct mshv_vtl_hvcall_setup {
+	__u64 bitmap_array_size; /* stores number of bytes */
+	__u64 allow_bitmap_ptr;
+};
+
+struct mshv_vtl_hvcall {
+	__u64 control;      /* Hypercall control code */
+	__u64 input_size;   /* Size of the input data */
+	__u64 input_ptr;    /* Pointer to the input struct */
+	__u64 status;       /* Status of the hypercall (output) */
+	__u64 output_size;  /* Size of the output data */
+	__u64 output_ptr;   /* Pointer to the output struct */
+};
+
+struct mshv_sint_mask {
+	__u8 mask;
+	__u8 reserved[7];
+};
+
+/* /dev/mshv device IOCTL */
+#define MSHV_CHECK_EXTENSION    _IOW(MSHV_IOCTL, 0x00, __u32)
+
+/* vtl device */
+#define MSHV_CREATE_VTL			_IOR(MSHV_IOCTL, 0x1D, char)
+#define MSHV_ADD_VTL0_MEMORY	_IOW(MSHV_IOCTL, 0x21, struct mshv_vtl_ram_disposition)
+#define MSHV_SET_POLL_FILE		_IOW(MSHV_IOCTL, 0x25, struct mshv_vtl_set_poll_file)
+#define MSHV_RETURN_TO_LOWER_VTL	_IO(MSHV_IOCTL, 0x27)
+#define MSHV_GET_VP_REGISTERS		_IOWR(MSHV_IOCTL, 0x05, struct mshv_vp_registers)
+#define MSHV_SET_VP_REGISTERS		_IOW(MSHV_IOCTL, 0x06, struct mshv_vp_registers)
+
+/* VMBus device IOCTLs */
+#define MSHV_SINT_SIGNAL_EVENT    _IOW(MSHV_IOCTL, 0x22, struct mshv_vtl_signal_event)
+#define MSHV_SINT_POST_MESSAGE    _IOW(MSHV_IOCTL, 0x23, struct mshv_vtl_sint_post_msg)
+#define MSHV_SINT_SET_EVENTFD     _IOW(MSHV_IOCTL, 0x24, struct mshv_vtl_set_eventfd)
+#define MSHV_SINT_PAUSE_MESSAGE_STREAM     _IOW(MSHV_IOCTL, 0x25, struct mshv_sint_mask)
+
+/* hv_hvcall device */
+#define MSHV_HVCALL_SETUP        _IOW(MSHV_IOCTL, 0x1E, struct mshv_vtl_hvcall_setup)
+#define MSHV_HVCALL              _IOWR(MSHV_IOCTL, 0x1F, struct mshv_vtl_hvcall)
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/net_shaper.h b/lib/libc/include/any-linux-any/linux/net_shaper.h
index b9c409a55b156923953a4b760b19449c71cdeb8d..03b1aa4f08750897f40f15ab7761ed15152e06d5 100644
--- a/lib/libc/include/any-linux-any/linux/net_shaper.h
+++ b/lib/libc/include/any-linux-any/linux/net_shaper.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/net_shaper.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_NET_SHAPER_H
 #define _LINUX_NET_SHAPER_H
diff --git a/lib/libc/include/any-linux-any/linux/netdev.h b/lib/libc/include/any-linux-any/linux/netdev.h
index 4de80b07930e3a97a97407057b5c3e8714333057..d48296f17fb3882dacc8a8eaa16f8d29b3efa8c3 100644
--- a/lib/libc/include/any-linux-any/linux/netdev.h
+++ b/lib/libc/include/any-linux-any/linux/netdev.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/netdev.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_NETDEV_H
 #define _LINUX_NETDEV_H
@@ -80,6 +81,7 @@ enum netdev_qstats_scope {
 enum netdev_napi_threaded {
 	NETDEV_NAPI_THREADED_DISABLED,
 	NETDEV_NAPI_THREADED_ENABLED,
+	NETDEV_NAPI_THREADED_BUSY_POLL,
 };
 
 enum {
diff --git a/lib/libc/include/any-linux-any/linux/netfilter/nf_tables.h b/lib/libc/include/any-linux-any/linux/netfilter/nf_tables.h
index 9795d421a26743c8c6af77ca5babbb23d3f86e6f..4f481f87ecaf7ee34363e0d4d50de2ad2194718f 100644
--- a/lib/libc/include/any-linux-any/linux/netfilter/nf_tables.h
+++ b/lib/libc/include/any-linux-any/linux/netfilter/nf_tables.h
@@ -881,7 +881,7 @@ enum nft_exthdr_flags {
  * enum nft_exthdr_op - nf_tables match options
  *
  * @NFT_EXTHDR_OP_IPV6: match against ipv6 extension headers
- * @NFT_EXTHDR_OP_TCP: match against tcp options
+ * @NFT_EXTHDR_OP_TCPOPT: match against tcp options
  * @NFT_EXTHDR_OP_IPV4: match against ipv4 options
  * @NFT_EXTHDR_OP_SCTP: match against sctp chunks
  * @NFT_EXTHDR_OP_DCCP: match against dccp otions
@@ -959,6 +959,7 @@ enum nft_exthdr_attributes {
  * @NFT_META_SDIF: slave device interface index
  * @NFT_META_SDIFNAME: slave device interface name
  * @NFT_META_BRI_BROUTE: packet br_netfilter_broute bit
+ * @NFT_META_BRI_IIFHWADDR: packet input bridge interface ethernet address
  */
 enum nft_meta_keys {
 	NFT_META_LEN,
@@ -999,6 +1000,7 @@ enum nft_meta_keys {
 	NFT_META_SDIFNAME,
 	NFT_META_BRI_BROUTE,
 	__NFT_META_IIFTYPE,
+	NFT_META_BRI_IIFHWADDR,
 };
 
 /**
@@ -1198,7 +1200,7 @@ enum nft_ct_attributes {
 #define NFTA_CT_MAX		(__NFTA_CT_MAX - 1)
 
 /**
- * enum nft_flow_attributes - ct offload expression attributes
+ * enum nft_offload_attributes - ct offload expression attributes
  * @NFTA_FLOW_TABLE_NAME: flow table name (NLA_STRING)
  */
 enum nft_offload_attributes {
@@ -1408,7 +1410,7 @@ enum nft_reject_types {
 };
 
 /**
- * enum nft_reject_code - Generic reject codes for IPv4/IPv6
+ * enum nft_reject_inet_code - Generic reject codes for IPv4/IPv6
  *
  * @NFT_REJECT_ICMPX_NO_ROUTE: no route to host / network unreachable
  * @NFT_REJECT_ICMPX_PORT_UNREACH: port unreachable
@@ -1478,9 +1480,9 @@ enum nft_nat_attributes {
 /**
  * enum nft_tproxy_attributes - nf_tables tproxy expression netlink attributes
  *
- * NFTA_TPROXY_FAMILY: Target address family (NLA_U32: nft_registers)
- * NFTA_TPROXY_REG_ADDR: Target address register (NLA_U32: nft_registers)
- * NFTA_TPROXY_REG_PORT: Target port register (NLA_U32: nft_registers)
+ * @NFTA_TPROXY_FAMILY: Target address family (NLA_U32: nft_registers)
+ * @NFTA_TPROXY_REG_ADDR: Target address register (NLA_U32: nft_registers)
+ * @NFTA_TPROXY_REG_PORT: Target port register (NLA_U32: nft_registers)
  */
 enum nft_tproxy_attributes {
 	NFTA_TPROXY_UNSPEC,
@@ -1781,7 +1783,7 @@ enum nft_synproxy_attributes {
 #define NFTA_SYNPROXY_MAX (__NFTA_SYNPROXY_MAX - 1)
 
 /**
- * enum nft_device_attributes - nf_tables device netlink attributes
+ * enum nft_devices_attributes - nf_tables device netlink attributes
  *
  * @NFTA_DEVICE_NAME: name of this device (NLA_STRING)
  * @NFTA_DEVICE_PREFIX: device name prefix, a simple wildcard (NLA_STRING)
diff --git a/lib/libc/include/any-linux-any/linux/netfilter_ipv6/ip6t_srh.h b/lib/libc/include/any-linux-any/linux/netfilter_ipv6/ip6t_srh.h
index b470290111826bae2d0ca54818c33d15d9b7eb81..8930a1afe9757c8310093c87129b5f1143684c84 100644
--- a/lib/libc/include/any-linux-any/linux/netfilter_ipv6/ip6t_srh.h
+++ b/lib/libc/include/any-linux-any/linux/netfilter_ipv6/ip6t_srh.h
@@ -41,13 +41,13 @@
 
 /**
  *      struct ip6t_srh - SRH match options
- *      @ next_hdr: Next header field of SRH
- *      @ hdr_len: Extension header length field of SRH
- *      @ segs_left: Segments left field of SRH
- *      @ last_entry: Last entry field of SRH
- *      @ tag: Tag field of SRH
- *      @ mt_flags: match options
- *      @ mt_invflags: Invert the sense of match options
+ *      @next_hdr: Next header field of SRH
+ *      @hdr_len: Extension header length field of SRH
+ *      @segs_left: Segments left field of SRH
+ *      @last_entry: Last entry field of SRH
+ *      @tag: Tag field of SRH
+ *      @mt_flags: match options
+ *      @mt_invflags: Invert the sense of match options
  */
 
 struct ip6t_srh {
@@ -62,19 +62,19 @@ struct ip6t_srh {
 
 /**
  *      struct ip6t_srh1 - SRH match options (revision 1)
- *      @ next_hdr: Next header field of SRH
- *      @ hdr_len: Extension header length field of SRH
- *      @ segs_left: Segments left field of SRH
- *      @ last_entry: Last entry field of SRH
- *      @ tag: Tag field of SRH
- *      @ psid_addr: Address of previous SID in SRH SID list
- *      @ nsid_addr: Address of NEXT SID in SRH SID list
- *      @ lsid_addr: Address of LAST SID in SRH SID list
- *      @ psid_msk: Mask of previous SID in SRH SID list
- *      @ nsid_msk: Mask of next SID in SRH SID list
- *      @ lsid_msk: MAsk of last SID in SRH SID list
- *      @ mt_flags: match options
- *      @ mt_invflags: Invert the sense of match options
+ *      @next_hdr: Next header field of SRH
+ *      @hdr_len: Extension header length field of SRH
+ *      @segs_left: Segments left field of SRH
+ *      @last_entry: Last entry field of SRH
+ *      @tag: Tag field of SRH
+ *      @psid_addr: Address of previous SID in SRH SID list
+ *      @nsid_addr: Address of NEXT SID in SRH SID list
+ *      @lsid_addr: Address of LAST SID in SRH SID list
+ *      @psid_msk: Mask of previous SID in SRH SID list
+ *      @nsid_msk: Mask of next SID in SRH SID list
+ *      @lsid_msk: MAsk of last SID in SRH SID list
+ *      @mt_flags: match options
+ *      @mt_invflags: Invert the sense of match options
  */
 
 struct ip6t_srh1 {
diff --git a/lib/libc/include/any-linux-any/linux/nfs.h b/lib/libc/include/any-linux-any/linux/nfs.h
index 45ddcfc8b7bbf541b13e2822a261d207152ddd24..4970e6cdf206f1783551a971bd64cc50cfa4ff08 100644
--- a/lib/libc/include/any-linux-any/linux/nfs.h
+++ b/lib/libc/include/any-linux-any/linux/nfs.h
@@ -49,7 +49,6 @@
 	NFSERR_NOENT = 2,		/* v2 v3 v4 */
 	NFSERR_IO = 5,			/* v2 v3 v4 */
 	NFSERR_NXIO = 6,		/* v2 v3 v4 */
-	NFSERR_EAGAIN = 11,		/* v2 v3 */
 	NFSERR_ACCES = 13,		/* v2 v3 v4 */
 	NFSERR_EXIST = 17,		/* v2 v3 v4 */
 	NFSERR_XDEV = 18,		/*    v3 v4 */
diff --git a/lib/libc/include/any-linux-any/linux/nfsd_netlink.h b/lib/libc/include/any-linux-any/linux/nfsd_netlink.h
index e924948f6b4c78bc8379d37e6316ca43bc4a1ceb..99e7881f3e74524928708211abb0dfae032ea834 100644
--- a/lib/libc/include/any-linux-any/linux/nfsd_netlink.h
+++ b/lib/libc/include/any-linux-any/linux/nfsd_netlink.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/nfsd.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_NFSD_NETLINK_H
 #define _LINUX_NFSD_NETLINK_H
diff --git a/lib/libc/include/any-linux-any/linux/nl80211-vnd-intel.h b/lib/libc/include/any-linux-any/linux/nl80211-vnd-intel.h
index 6f87408a3cfae5cb682189f29ace64b077706a9e..e89d02ea90fef7f8378974f2d74ec332c3d90926 100644
--- a/lib/libc/include/any-linux-any/linux/nl80211-vnd-intel.h
+++ b/lib/libc/include/any-linux-any/linux/nl80211-vnd-intel.h
@@ -84,7 +84,6 @@ enum iwl_vendor_auth_akm_mode {
  *
  * @NUM_IWL_MVM_VENDOR_ATTR: number of vendor attributes
  * @MAX_IWL_MVM_VENDOR_ATTR: highest vendor attribute number
-
  */
 enum iwl_mvm_vendor_attr {
 	__IWL_MVM_VENDOR_ATTR_INVALID				= 0x00,
diff --git a/lib/libc/include/any-linux-any/linux/nl80211.h b/lib/libc/include/any-linux-any/linux/nl80211.h
index 747551a6f25ccec97c79b99700810d0c4ee95cd0..60f9999ac16dad6fcf6187de38be094306bc4d77 100644
--- a/lib/libc/include/any-linux-any/linux/nl80211.h
+++ b/lib/libc/include/any-linux-any/linux/nl80211.h
@@ -1085,8 +1085,9 @@
  *	%NL80211_ATTR_NAN_MASTER_PREF attribute and optional
  *	%NL80211_ATTR_BANDS attributes.  If %NL80211_ATTR_BANDS is
  *	omitted or set to 0, it means don't-care and the device will
- *	decide what to use.  After this command NAN functions can be
- *	added.
+ *	decide what to use. Additional cluster configuration may be
+ *	optionally provided with %NL80211_ATTR_NAN_CONFIG.
+ *	After this command NAN functions can be added.
  * @NL80211_CMD_STOP_NAN: Stop the NAN operation, identified by
  *	its %NL80211_ATTR_WDEV interface.
  * @NL80211_CMD_ADD_NAN_FUNCTION: Add a NAN function. The function is defined
@@ -1115,6 +1116,10 @@
  *	current configuration is not changed.  If it is present but
  *	set to zero, the configuration is changed to don't-care
  *	(i.e. the device can decide what to do).
+ *	Additional parameters may be provided with
+ *	%NL80211_ATTR_NAN_CONFIG. User space should provide all previously
+ *	configured nested attributes under %NL80211_ATTR_NAN_CONFIG, even if
+ *	only a subset was changed.
  * @NL80211_CMD_NAN_MATCH: Notification sent when a match is reported.
  *	This will contain a %NL80211_ATTR_NAN_MATCH nested attribute and
  *	%NL80211_ATTR_COOKIE.
@@ -1344,6 +1349,18 @@
  *	control EPCS configuration. Used to notify userland on the current state
  *	of EPCS.
  *
+ * @NL80211_CMD_NAN_NEXT_DW_NOTIFICATION: This command is used to notify
+ *	user space about the next NAN Discovery Window (DW). User space may use
+ *	it to prepare frames to be sent in the next DW.
+ *	%NL80211_ATTR_WIPHY_FREQ is used to indicate the frequency of the next
+ *	DW. SDF transmission should be requested with %NL80211_CMD_FRAME and
+ *	the device/driver shall take care of the actual transmission timing.
+ *	This notification is only sent to the NAN interface owning socket
+ *	(see %NL80211_ATTR_SOCKET_OWNER flag).
+ * @NL80211_CMD_NAN_CLUSTER_JOINED: This command is used to notify
+ *	user space that the NAN new cluster has been joined. The cluster ID is
+ *	indicated by %NL80211_ATTR_MAC.
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -1604,6 +1621,9 @@ enum nl80211_commands {
 	NL80211_CMD_ASSOC_MLO_RECONF,
 	NL80211_CMD_EPCS_CFG,
 
+	NL80211_CMD_NAN_NEXT_DW_NOTIFICATION,
+	NL80211_CMD_NAN_CLUSTER_JOINED,
+
 	/* add new commands above here */
 
 	/* used to define NL80211_CMD_MAX below */
@@ -1943,8 +1963,9 @@ enum nl80211_commands {
  *	The driver must also specify support for this with the extended
  *	features NL80211_EXT_FEATURE_BEACON_RATE_LEGACY,
  *	NL80211_EXT_FEATURE_BEACON_RATE_HT,
- *	NL80211_EXT_FEATURE_BEACON_RATE_VHT and
- *	NL80211_EXT_FEATURE_BEACON_RATE_HE.
+ *	NL80211_EXT_FEATURE_BEACON_RATE_VHT,
+ *	NL80211_EXT_FEATURE_BEACON_RATE_HE and
+ *	NL80211_EXT_FEATURE_BEACON_RATE_EHT.
  *
  * @NL80211_ATTR_FRAME_MATCH: A binary attribute which typically must contain
  *	at least one byte, currently used with @NL80211_CMD_REGISTER_FRAME.
@@ -2283,7 +2304,8 @@ enum nl80211_commands {
  * @NL80211_ATTR_PEER_AID: Association ID for the peer TDLS station (u16).
  *	This is similar to @NL80211_ATTR_STA_AID but with a difference of being
  *	allowed to be used with the first @NL80211_CMD_SET_STATION command to
- *	update a TDLS peer STA entry.
+ *	update a TDLS peer STA entry. For S1G interfaces, this is limited to
+ *	1600 for the current mac80211 implementation.
  *
  * @NL80211_ATTR_COALESCE_RULE: Coalesce rule information.
  *
@@ -2858,8 +2880,9 @@ enum nl80211_commands {
  *	index. If the userspace includes more RNR elements than number of
  *	MBSSID elements then these will be added in every EMA beacon.
  *
- * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is
- *	disabled.
+ * @NL80211_ATTR_MLO_LINK_DISABLED: Unused. It was used to indicate that a link
+ *	is disabled during association. However, the AP will send the
+ *	information by including a TTLM in the association response.
  *
  * @NL80211_ATTR_BSS_DUMP_INCLUDE_USE_DATA: Include BSS usage data, i.e.
  *	include BSSes that can only be used in restricted scenarios and/or
@@ -2928,6 +2951,29 @@ enum nl80211_commands {
  *	required alongside this attribute. Refer to
  *	@enum nl80211_s1g_short_beacon_attrs for the attribute definitions.
  *
+ * @NL80211_ATTR_BSS_PARAM: nested attribute used with %NL80211_CMD_GET_WIPHY
+ *	which indicates which BSS parameters can be modified. The attribute can
+ *	also be used as flag attribute by user-space in %NL80211_CMD_SET_BSS to
+ *	indicate that it wants strict checking on the BSS parameters to be
+ *	modified.
+ *
+ * @NL80211_ATTR_NAN_CONFIG: Nested attribute for
+ *	extended NAN cluster configuration. This is used with
+ *	%NL80211_CMD_START_NAN and %NL80211_CMD_CHANGE_NAN_CONFIG.
+ *	See &enum nl80211_nan_conf_attributes for details.
+ *	This attribute is optional.
+ * @NL80211_ATTR_NAN_NEW_CLUSTER: Flag attribute indicating that a new
+ *	NAN cluster has been created. This is used with
+ *	%NL80211_CMD_NAN_CLUSTER_JOINED
+ * @NL80211_ATTR_NAN_CAPABILITIES: Nested attribute for NAN capabilities.
+ *	This is used with %NL80211_CMD_GET_WIPHY to indicate the NAN
+ *	capabilities supported by the driver. See &enum nl80211_nan_capabilities
+ *	for details.
+ *
+ * @NL80211_ATTR_S1G_PRIMARY_2MHZ: flag attribute indicating that the S1G
+ *	primary channel is 2 MHz wide, and the control channel designates
+ *	the 1 MHz primary subchannel within that 2 MHz primary.
+ *
  * @NUM_NL80211_ATTR: total number of nl80211_attrs available
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
@@ -3489,6 +3535,12 @@ enum nl80211_attrs {
 
 	NL80211_ATTR_S1G_LONG_BEACON_PERIOD,
 	NL80211_ATTR_S1G_SHORT_BEACON,
+	NL80211_ATTR_BSS_PARAM,
+	NL80211_ATTR_NAN_CONFIG,
+	NL80211_ATTR_NAN_NEW_CLUSTER,
+	NL80211_ATTR_NAN_CAPABILITIES,
+
+	NL80211_ATTR_S1G_PRIMARY_2MHZ,
 
 	/* add attributes here, update the policy in nl80211.c */
 
@@ -3735,6 +3787,22 @@ enum nl80211_eht_gi {
 	NL80211_RATE_INFO_EHT_GI_3_2,
 };
 
+/**
+ * enum nl80211_eht_ltf - EHT long training field
+ * @NL80211_RATE_INFO_EHT_1XLTF: 3.2 usec
+ * @NL80211_RATE_INFO_EHT_2XLTF: 6.4 usec
+ * @NL80211_RATE_INFO_EHT_4XLTF: 12.8 usec
+ * @NL80211_RATE_INFO_EHT_6XLTF: 19.2 usec
+ * @NL80211_RATE_INFO_EHT_8XLTF: 25.6 usec
+ */
+enum nl80211_eht_ltf {
+	NL80211_RATE_INFO_EHT_1XLTF,
+	NL80211_RATE_INFO_EHT_2XLTF,
+	NL80211_RATE_INFO_EHT_4XLTF,
+	NL80211_RATE_INFO_EHT_6XLTF,
+	NL80211_RATE_INFO_EHT_8XLTF,
+};
+
 /**
  * enum nl80211_eht_ru_alloc - EHT RU allocation values
  * @NL80211_RATE_INFO_EHT_RU_ALLOC_26: 26-tone RU allocation
@@ -4371,6 +4439,12 @@ enum nl80211_wmm_rule {
  *	very low power (VLP) AP, despite being NO_IR.
  * @NL80211_FREQUENCY_ATTR_ALLOW_20MHZ_ACTIVITY: This channel can be active in
  *	20 MHz bandwidth, despite being NO_IR.
+ * @NL80211_FREQUENCY_ATTR_NO_4MHZ: 4 MHz operation is not allowed on this
+ *	channel in current regulatory domain.
+ * @NL80211_FREQUENCY_ATTR_NO_8MHZ: 8 MHz operation is not allowed on this
+ *	channel in current regulatory domain.
+ * @NL80211_FREQUENCY_ATTR_NO_16MHZ: 16 MHz operation is not allowed on this
+ *	channel in current regulatory domain.
  * @NL80211_FREQUENCY_ATTR_MAX: highest frequency attribute number
  *	currently defined
  * @__NL80211_FREQUENCY_ATTR_AFTER_LAST: internal use
@@ -4416,6 +4490,9 @@ enum nl80211_frequency_attr {
 	NL80211_FREQUENCY_ATTR_CAN_MONITOR,
 	NL80211_FREQUENCY_ATTR_ALLOW_6GHZ_VLP_AP,
 	NL80211_FREQUENCY_ATTR_ALLOW_20MHZ_ACTIVITY,
+	NL80211_FREQUENCY_ATTR_NO_4MHZ,
+	NL80211_FREQUENCY_ATTR_NO_8MHZ,
+	NL80211_FREQUENCY_ATTR_NO_16MHZ,
 
 	/* keep last */
 	__NL80211_FREQUENCY_ATTR_AFTER_LAST,
@@ -5481,6 +5558,10 @@ enum nl80211_key_attributes {
  *	see &struct nl80211_txrate_he
  * @NL80211_TXRATE_HE_GI: configure HE GI, 0.8us, 1.6us and 3.2us.
  * @NL80211_TXRATE_HE_LTF: configure HE LTF, 1XLTF, 2XLTF and 4XLTF.
+ * @NL80211_TXRATE_EHT: EHT rates allowed for TX rate selection,
+ *	see &struct nl80211_txrate_eht
+ * @NL80211_TXRATE_EHT_GI: configure EHT GI, (u8, see &enum nl80211_eht_gi)
+ * @NL80211_TXRATE_EHT_LTF: configure EHT LTF, (u8, see &enum nl80211_eht_ltf)
  * @__NL80211_TXRATE_AFTER_LAST: internal
  * @NL80211_TXRATE_MAX: highest TX rate attribute
  */
@@ -5493,6 +5574,9 @@ enum nl80211_tx_rate_attributes {
 	NL80211_TXRATE_HE,
 	NL80211_TXRATE_HE_GI,
 	NL80211_TXRATE_HE_LTF,
+	NL80211_TXRATE_EHT,
+	NL80211_TXRATE_EHT_GI,
+	NL80211_TXRATE_EHT_LTF,
 
 	/* keep last */
 	__NL80211_TXRATE_AFTER_LAST,
@@ -5525,6 +5609,15 @@ enum nl80211_txrate_gi {
 	NL80211_TXRATE_FORCE_LGI,
 };
 
+#define NL80211_EHT_NSS_MAX             16
+/**
+ * struct nl80211_txrate_eht - EHT MCS/NSS txrate bitmap
+ * @mcs: MCS bitmap table for each NSS (array index 0 for 1 stream, etc.)
+ */
+struct nl80211_txrate_eht {
+	__u16 mcs[NL80211_EHT_NSS_MAX];
+};
+
 /**
  * enum nl80211_band - Frequency band
  * @NL80211_BAND_2GHZ: 2.4 GHz ISM band
@@ -6649,6 +6742,9 @@ enum nl80211_feature_flags {
  *	(signaling and payload protected) A-MSDUs and this shall be advertised
  *	in the RSNXE.
  *
+ * @NL80211_EXT_FEATURE_BEACON_RATE_EHT: Driver supports beacon rate
+ *	configuration (AP/mesh) with EHT rates.
+ *
  * @NUM_NL80211_EXT_FEATURES: number of extended features.
  * @MAX_NL80211_EXT_FEATURES: highest extended feature index.
  */
@@ -6724,6 +6820,7 @@ enum nl80211_ext_feature_index {
 	NL80211_EXT_FEATURE_OWE_OFFLOAD_AP,
 	NL80211_EXT_FEATURE_DFS_CONCURRENT,
 	NL80211_EXT_FEATURE_SPP_AMSDU_SUPPORT,
+	NL80211_EXT_FEATURE_BEACON_RATE_EHT,
 
 	/* add new features before the definition below */
 	NUM_NL80211_EXT_FEATURES,
@@ -7278,6 +7375,105 @@ enum nl80211_nan_match_attributes {
 	NL80211_NAN_MATCH_ATTR_MAX = NUM_NL80211_NAN_MATCH_ATTR - 1
 };
 
+/**
+ * enum nl80211_nan_band_conf_attributes - NAN band configuration attributes
+ * @__NL80211_NAN_BAND_CONF_INVALID: Invalid.
+ * @NL80211_NAN_BAND_CONF_BAND: Band for which the configuration is
+ *	being set. The value is according to &enum nl80211_band (u8).
+ * @NL80211_NAN_BAND_CONF_FREQ: Discovery frequency. This attribute shall not
+ *	be present on 2.4 GHZ band. On 5 GHz band its presence is optional.
+ *	The allowed values are 5220 (channel 44) or 5745 (channel 149).
+ *	If not present, channel 149 is used if allowed, otherwise channel 44
+ *	will be selected. The value is in MHz (u16).
+ * @NL80211_NAN_BAND_CONF_RSSI_CLOSE: RSSI close threshold used for NAN state
+ *	transition algorithm as described in chapters 3.3.6 and 3.3.7 "NAN
+ *	Device Role and State Transition" of Wi-Fi Aware (TM) Specification
+ *	v4.0. If not specified, default device value is used. The value should
+ *	be greater than -60 dBm (s8).
+ * @NL80211_NAN_BAND_CONF_RSSI_MIDDLE: RSSI middle threshold used for NAN state
+ *	transition algorithm as described in chapters 3.3.6 and 3.3.7 "NAN
+ *	Device Role and State Transition" of Wi-Fi Aware (TM) Specification
+ *	v4.0. If not present, default device value is used. The value should be
+ *	greater than -75 dBm and less than %NL80211_NAN_BAND_CONF_RSSI_CLOSE
+ *	(s8).
+ * @NL80211_NAN_BAND_CONF_WAKE_DW: Committed DW information (values 0-5).
+ *	Value 0 means that the device will not wake up during the
+ *	discovery window. Values 1-5 mean that the device will wake up
+ *	during each 2^(n - 1) discovery window, where n is the value of
+ *	this attribute. Setting this attribute to 0 is not allowed on
+ *	2.4 GHz band (u8). This is an optional parameter (default is 1).
+ * @NL80211_NAN_BAND_CONF_DISABLE_SCAN: Optional flag attribute to disable
+ *	scanning (for cluster merge) on the band. If set, the device will not
+ *	scan on this band anymore. Disabling scanning on 2.4 GHz band is not
+ *	allowed.
+ * @NUM_NL80211_NAN_BAND_CONF_ATTR: Internal.
+ * @NL80211_NAN_BAND_CONF_ATTR_MAX: Highest NAN band configuration attribute.
+ *
+ * These attributes are used to configure NAN band-specific parameters. Note,
+ * that both RSSI attributes should be configured (or both left unset).
+ */
+enum nl80211_nan_band_conf_attributes {
+	__NL80211_NAN_BAND_CONF_INVALID,
+	NL80211_NAN_BAND_CONF_BAND,
+	NL80211_NAN_BAND_CONF_FREQ,
+	NL80211_NAN_BAND_CONF_RSSI_CLOSE,
+	NL80211_NAN_BAND_CONF_RSSI_MIDDLE,
+	NL80211_NAN_BAND_CONF_WAKE_DW,
+	NL80211_NAN_BAND_CONF_DISABLE_SCAN,
+
+	/* keep last */
+	NUM_NL80211_NAN_BAND_CONF_ATTR,
+	NL80211_NAN_BAND_CONF_ATTR_MAX = NUM_NL80211_NAN_BAND_CONF_ATTR - 1,
+};
+
+/**
+ * enum nl80211_nan_conf_attributes - NAN configuration attributes
+ * @__NL80211_NAN_CONF_INVALID: Invalid attribute, used for validation.
+ * @NL80211_NAN_CONF_CLUSTER_ID: ID for the NAN cluster. This is a MAC
+ *	address that can take values from 50-6F-9A-01-00-00 to
+ *	50-6F-9A-01-FF-FF. This attribute is optional. If not present,
+ *	a random Cluster ID will be chosen.
+ * @NL80211_NAN_CONF_EXTRA_ATTRS: Additional NAN attributes to be
+ *	published in the beacons. This is an optional byte array.
+ * @NL80211_NAN_CONF_VENDOR_ELEMS: Vendor-specific elements that will
+ *	be published in the beacons. This is an optional byte array.
+ * @NL80211_NAN_CONF_BAND_CONFIGS: This is a nested array attribute,
+ *	containing multiple entries for each supported band. Each band
+ *	configuration consists of &enum nl80211_nan_band_conf_attributes.
+ * @NL80211_NAN_CONF_SCAN_PERIOD: Scan period in seconds. If not configured,
+ *	device default is used. Zero value will disable scanning.
+ *	This is u16 (optional).
+ * @NL80211_NAN_CONF_SCAN_DWELL_TIME: Scan dwell time in TUs per channel.
+ *	Only non-zero values are valid. If not configured the device default
+ *	value is used. This is u16 (optional)
+ * @NL80211_NAN_CONF_DISCOVERY_BEACON_INTERVAL: Discovery beacon interval
+ *	in TUs. Valid range is 50-200 TUs. If not configured the device default
+ *	value is used. This is u8 (optional)
+ * @NL80211_NAN_CONF_NOTIFY_DW: If set, the driver will notify userspace about
+ *	the upcoming discovery window with
+ *	%NL80211_CMD_NAN_NEXT_DW_NOTIFICATION.
+ *	This is a flag attribute.
+ * @NUM_NL80211_NAN_CONF_ATTR: Internal.
+ * @NL80211_NAN_CONF_ATTR_MAX: Highest NAN configuration attribute.
+ *
+ * These attributes are used to configure NAN-specific parameters.
+ */
+enum nl80211_nan_conf_attributes {
+	__NL80211_NAN_CONF_INVALID,
+	NL80211_NAN_CONF_CLUSTER_ID,
+	NL80211_NAN_CONF_EXTRA_ATTRS,
+	NL80211_NAN_CONF_VENDOR_ELEMS,
+	NL80211_NAN_CONF_BAND_CONFIGS,
+	NL80211_NAN_CONF_SCAN_PERIOD,
+	NL80211_NAN_CONF_SCAN_DWELL_TIME,
+	NL80211_NAN_CONF_DISCOVERY_BEACON_INTERVAL,
+	NL80211_NAN_CONF_NOTIFY_DW,
+
+	/* keep last */
+	NUM_NL80211_NAN_CONF_ATTR,
+	NL80211_NAN_CONF_ATTR_MAX = NUM_NL80211_NAN_CONF_ATTR - 1,
+};
+
 /**
  * enum nl80211_external_auth_action - Action to perform with external
  *     authentication request. Used by NL80211_ATTR_EXTERNAL_AUTH_ACTION.
@@ -8187,4 +8383,54 @@ enum nl80211_s1g_short_beacon_attrs {
 		__NL80211_S1G_SHORT_BEACON_ATTR_LAST - 1
 };
 
+/**
+ * enum nl80211_nan_capabilities - NAN (Neighbor Aware Networking)
+ *	capabilities.
+ *
+ * @__NL80211_NAN_CAPABILITIES_INVALID: Invalid.
+ * @NL80211_NAN_CAPA_CONFIGURABLE_SYNC: Flag attribute indicating that
+ *	the device supports configurable synchronization. If set, the device
+ *	should be able to handle %NL80211_ATTR_NAN_CONFIG
+ *	attribute in the %NL80211_CMD_START_NAN (and change) command.
+ * @NL80211_NAN_CAPA_USERSPACE_DE: Flag attribute indicating that
+ *	NAN Discovery Engine (DE) is not offloaded and the driver assumes
+ *	user space DE implementation. When set, %NL80211_CMD_ADD_NAN_FUNCTION,
+ *	%NL80211_CMD_DEL_NAN_FUNCTION and %NL80211_CMD_NAN_MATCH commands
+ *	should not be used. In addition, the device/driver should support
+ *	sending discovery window (DW) notifications using
+ *	%NL80211_CMD_NAN_NEXT_DW_NOTIFICATION and handling transmission and
+ *	reception of NAN SDF frames on NAN device interface during DW windows.
+ *	(%NL80211_CMD_FRAME is used to transmit SDFs)
+ * @NL80211_NAN_CAPA_OP_MODE: u8 attribute indicating the supported operation
+ *	modes as defined in Wi-Fi Aware (TM) specification Table 81 (Operation
+ *	Mode field format).
+ * @NL80211_NAN_CAPA_NUM_ANTENNAS: u8 attribute indicating the number of
+ *	TX and RX antennas supported by the device. Lower nibble indicates
+ *	the number of TX antennas and upper nibble indicates the number of RX
+ *	antennas. Value 0 indicates the information is not available.
+ *	See table 79 of Wi-Fi Aware (TM) specification (Number of
+ *	Antennas field).
+ * @NL80211_NAN_CAPA_MAX_CHANNEL_SWITCH_TIME: u16 attribute indicating the
+ *	maximum time in microseconds that the device requires to switch
+ *	channels.
+ * @NL80211_NAN_CAPA_CAPABILITIES: u8 attribute containing the
+ *	capabilities of the device as defined in Wi-Fi Aware (TM)
+ *	specification Table 79 (Capabilities field).
+ * @__NL80211_NAN_CAPABILITIES_LAST: Internal
+ * @NL80211_NAN_CAPABILITIES_MAX: Highest NAN capability attribute.
+ */
+enum nl80211_nan_capabilities {
+	__NL80211_NAN_CAPABILITIES_INVALID,
+
+	NL80211_NAN_CAPA_CONFIGURABLE_SYNC,
+	NL80211_NAN_CAPA_USERSPACE_DE,
+	NL80211_NAN_CAPA_OP_MODE,
+	NL80211_NAN_CAPA_NUM_ANTENNAS,
+	NL80211_NAN_CAPA_MAX_CHANNEL_SWITCH_TIME,
+	NL80211_NAN_CAPA_CAPABILITIES,
+	/* keep last */
+	__NL80211_NAN_CAPABILITIES_LAST,
+	NL80211_NAN_CAPABILITIES_MAX = __NL80211_NAN_CAPABILITIES_LAST - 1,
+};
+
 #endif /* __LINUX_NL80211_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/nsfs.h b/lib/libc/include/any-linux-any/linux/nsfs.h
index 4c2a921d3210b0f9b41c8bc8f4f700e2de8a7895..71f8fa87fd1df7113b943778efaa7980ae561573 100644
--- a/lib/libc/include/any-linux-any/linux/nsfs.h
+++ b/lib/libc/include/any-linux-any/linux/nsfs.h
@@ -16,8 +16,6 @@
 #define NS_GET_NSTYPE		_IO(NSIO, 0x3)
 /* Get owner UID (in the caller's user namespace) for a user namespace */
 #define NS_GET_OWNER_UID	_IO(NSIO, 0x4)
-/* Get the id for a mount namespace */
-#define NS_GET_MNTNS_ID		_IOR(NSIO, 0x5, __u64)
 /* Translate pid from target pid namespace into the caller's pid namespace. */
 #define NS_GET_PID_FROM_PIDNS	_IOR(NSIO, 0x6, int)
 /* Return thread-group leader id of pid in the callers pid namespace. */
@@ -42,6 +40,10 @@ struct mnt_ns_info {
 /* Get previous namespace. */
 #define NS_MNT_GET_PREV		_IOR(NSIO, 12, struct mnt_ns_info)
 
+/* Retrieve namespace identifiers. */
+#define NS_GET_MNTNS_ID		_IOR(NSIO, 5,  __u64)
+#define NS_GET_ID		_IOR(NSIO, 13, __u64)
+
 enum init_ns_ino {
 	IPC_NS_INIT_INO		= 0xEFFFFFFFU,
 	UTS_NS_INIT_INO		= 0xEFFFFFFEU,
@@ -53,4 +55,68 @@ enum init_ns_ino {
 	MNT_NS_INIT_INO		= 0xEFFFFFF8U,
 };
 
+struct nsfs_file_handle {
+	__u64 ns_id;
+	__u32 ns_type;
+	__u32 ns_inum;
+};
+
+#define NSFS_FILE_HANDLE_SIZE_VER0 16 /* sizeof first published struct */
+#define NSFS_FILE_HANDLE_SIZE_LATEST sizeof(struct nsfs_file_handle) /* sizeof latest published struct */
+
+enum init_ns_id {
+	IPC_NS_INIT_ID		= 1ULL,
+	UTS_NS_INIT_ID		= 2ULL,
+	USER_NS_INIT_ID		= 3ULL,
+	PID_NS_INIT_ID		= 4ULL,
+	CGROUP_NS_INIT_ID	= 5ULL,
+	TIME_NS_INIT_ID		= 6ULL,
+	NET_NS_INIT_ID		= 7ULL,
+	MNT_NS_INIT_ID		= 8ULL,
+};
+
+enum ns_type {
+	TIME_NS    = (1ULL << 7),  /* CLONE_NEWTIME */
+	MNT_NS     = (1ULL << 17), /* CLONE_NEWNS */
+	CGROUP_NS  = (1ULL << 25), /* CLONE_NEWCGROUP */
+	UTS_NS     = (1ULL << 26), /* CLONE_NEWUTS */
+	IPC_NS     = (1ULL << 27), /* CLONE_NEWIPC */
+	USER_NS    = (1ULL << 28), /* CLONE_NEWUSER */
+	PID_NS     = (1ULL << 29), /* CLONE_NEWPID */
+	NET_NS     = (1ULL << 30), /* CLONE_NEWNET */
+};
+
+/**
+ * struct ns_id_req - namespace ID request structure
+ * @size: size of this structure
+ * @spare: reserved for future use
+ * @filter: filter mask
+ * @ns_id: last namespace id
+ * @user_ns_id: owning user namespace ID
+ *
+ * Structure for passing namespace ID and miscellaneous parameters to
+ * statns(2) and listns(2).
+ *
+ * For statns(2) @param represents the request mask.
+ * For listns(2) @param represents the last listed mount id (or zero).
+ */
+struct ns_id_req {
+	__u32 size;
+	__u32 spare;
+	__u64 ns_id;
+	struct /* listns */ {
+		__u32 ns_type;
+		__u32 spare2;
+		__u64 user_ns_id;
+	};
+};
+
+/*
+ * Special @user_ns_id value that can be passed to listns()
+ */
+#define LISTNS_CURRENT_USER 0xffffffffffffffff /* Caller's userns */
+
+/* List of all ns_id_req versions. */
+#define NS_ID_REQ_SIZE_VER0 32 /* sizeof first published struct */
+
 #endif /* __LINUX_NSFS_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/ovpn.h b/lib/libc/include/any-linux-any/linux/ovpn.h
index 261b4d7cd8ee07b9d15b0e5fa4a685041e7496ae..5c3959fcb6d7db810868d5c892a750f7536c151d 100644
--- a/lib/libc/include/any-linux-any/linux/ovpn.h
+++ b/lib/libc/include/any-linux-any/linux/ovpn.h
@@ -2,6 +2,7 @@
 /* Do not edit directly, auto-generated from: */
 /*	Documentation/netlink/specs/ovpn.yaml */
 /* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
 #ifndef _LINUX_OVPN_H
 #define _LINUX_OVPN_H
diff --git a/lib/libc/include/any-linux-any/linux/pci_regs.h b/lib/libc/include/any-linux-any/linux/pci_regs.h
index cd11a2a882d3cb3bf746b31dcb8f334236d85bfb..b5e6035e5e02ef98fe8b50c3a7192289d79a2455 100644
--- a/lib/libc/include/any-linux-any/linux/pci_regs.h
+++ b/lib/libc/include/any-linux-any/linux/pci_regs.h
@@ -207,6 +207,9 @@
 
 /* Capability lists */
 
+#define PCI_CAP_ID_MASK		0x00ff	/* Capability ID mask */
+#define PCI_CAP_LIST_NEXT_MASK	0xff00	/* Next Capability Pointer mask */
+
 #define PCI_CAP_LIST_ID		0	/* Capability ID */
 #define  PCI_CAP_ID_PM		0x01	/* Power Management */
 #define  PCI_CAP_ID_AGP		0x02	/* Accelerated Graphics Port */
@@ -500,6 +503,7 @@
 #define  PCI_EXP_DEVCAP_PWR_VAL	0x03fc0000 /* Slot Power Limit Value */
 #define  PCI_EXP_DEVCAP_PWR_SCL	0x0c000000 /* Slot Power Limit Scale */
 #define  PCI_EXP_DEVCAP_FLR     0x10000000 /* Function Level Reset */
+#define  PCI_EXP_DEVCAP_TEE     0x40000000 /* TEE I/O (TDISP) Support */
 #define PCI_EXP_DEVCTL		0x08	/* Device Control */
 #define  PCI_EXP_DEVCTL_CERE	0x0001	/* Correctable Error Reporting En. */
 #define  PCI_EXP_DEVCTL_NFERE	0x0002	/* Non-Fatal Error Reporting Enable */
@@ -751,6 +755,8 @@
 #define PCI_EXT_CAP_ID_NPEM	0x29	/* Native PCIe Enclosure Management */
 #define PCI_EXT_CAP_ID_PL_32GT  0x2A    /* Physical Layer 32.0 GT/s */
 #define PCI_EXT_CAP_ID_DOE	0x2E	/* Data Object Exchange */
+#define PCI_EXT_CAP_ID_DEV3	0x2F	/* Device 3 Capability/Control/Status */
+#define PCI_EXT_CAP_ID_IDE	0x30    /* Integrity and Data Encryption */
 #define PCI_EXT_CAP_ID_PL_64GT	0x31	/* Physical Layer 64.0 GT/s */
 #define PCI_EXT_CAP_ID_MAX	PCI_EXT_CAP_ID_PL_64GT
 
@@ -776,6 +782,12 @@
 #define  PCI_ERR_UNC_MCBTLP	0x00800000	/* MC blocked TLP */
 #define  PCI_ERR_UNC_ATOMEG	0x01000000	/* Atomic egress blocked */
 #define  PCI_ERR_UNC_TLPPRE	0x02000000	/* TLP prefix blocked */
+#define  PCI_ERR_UNC_POISON_BLK	0x04000000	/* Poisoned TLP Egress Blocked */
+#define  PCI_ERR_UNC_DMWR_BLK	0x08000000	/* DMWr Request Egress Blocked */
+#define  PCI_ERR_UNC_IDE_CHECK	0x10000000	/* IDE Check Failed */
+#define  PCI_ERR_UNC_MISR_IDE	0x20000000	/* Misrouted IDE TLP */
+#define  PCI_ERR_UNC_PCRC_CHECK	0x40000000	/* PCRC Check Failed */
+#define  PCI_ERR_UNC_XLAT_BLK	0x80000000	/* TLP Translation Egress Blocked */
 #define PCI_ERR_UNCOR_MASK	0x08	/* Uncorrectable Error Mask */
 	/* Same bits as above */
 #define PCI_ERR_UNCOR_SEVER	0x0c	/* Uncorrectable Error Severity */
@@ -798,6 +810,7 @@
 #define  PCI_ERR_CAP_ECRC_CHKC		0x00000080 /* ECRC Check Capable */
 #define  PCI_ERR_CAP_ECRC_CHKE		0x00000100 /* ECRC Check Enable */
 #define  PCI_ERR_CAP_PREFIX_LOG_PRESENT	0x00000800 /* TLP Prefix Log Present */
+#define  PCI_ERR_CAP_COMP_TIME_LOG	0x00001000 /* Completion Timeout Prefix/Header Log Capable */
 #define  PCI_ERR_CAP_TLP_LOG_FLIT	0x00040000 /* TLP was logged in Flit Mode */
 #define  PCI_ERR_CAP_TLP_LOG_SIZE	0x00f80000 /* Logged TLP Size (only in Flit mode) */
 #define PCI_ERR_HEADER_LOG	0x1c	/* Header Log Register (16 bytes) */
@@ -1234,9 +1247,95 @@
 /* Deprecated old name, replaced with PCI_DOE_DATA_OBJECT_DISC_RSP_3_TYPE */
 #define PCI_DOE_DATA_OBJECT_DISC_RSP_3_PROTOCOL		PCI_DOE_DATA_OBJECT_DISC_RSP_3_TYPE
 
+/* Device 3 Extended Capability */
+#define PCI_DEV3_CAP		0x04	/* Device 3 Capabilities Register */
+#define PCI_DEV3_CTL		0x08	/* Device 3 Control Register */
+#define PCI_DEV3_STA		0x0c	/* Device 3 Status Register */
+#define  PCI_DEV3_STA_SEGMENT	0x8	/* Segment Captured (end-to-end flit-mode detected) */
+
 /* Compute Express Link (CXL r3.1, sec 8.1.5) */
 #define PCI_DVSEC_CXL_PORT				3
 #define PCI_DVSEC_CXL_PORT_CTL				0x0c
 #define PCI_DVSEC_CXL_PORT_CTL_UNMASK_SBR		0x00000001
 
+/* Integrity and Data Encryption Extended Capability */
+#define PCI_IDE_CAP			0x04
+#define  PCI_IDE_CAP_LINK		0x1  /* Link IDE Stream Supported */
+#define  PCI_IDE_CAP_SELECTIVE		0x2  /* Selective IDE Streams Supported */
+#define  PCI_IDE_CAP_FLOWTHROUGH	0x4  /* Flow-Through IDE Stream Supported */
+#define  PCI_IDE_CAP_PARTIAL_HEADER_ENC 0x8  /* Partial Header Encryption Supported */
+#define  PCI_IDE_CAP_AGGREGATION	0x10 /* Aggregation Supported */
+#define  PCI_IDE_CAP_PCRC		0x20 /* PCRC Supported */
+#define  PCI_IDE_CAP_IDE_KM		0x40 /* IDE_KM Protocol Supported */
+#define  PCI_IDE_CAP_SEL_CFG		0x80 /* Selective IDE for Config Request Support */
+#define  PCI_IDE_CAP_ALG		__GENMASK(12, 8) /* Supported Algorithms */
+#define   PCI_IDE_CAP_ALG_AES_GCM_256	0    /* AES-GCM 256 key size, 96b MAC */
+#define  PCI_IDE_CAP_LINK_TC_NUM	__GENMASK(15, 13) /* Link IDE TCs */
+#define  PCI_IDE_CAP_SEL_NUM		__GENMASK(23, 16) /* Supported Selective IDE Streams */
+#define  PCI_IDE_CAP_TEE_LIMITED	0x1000000 /* TEE-Limited Stream Supported */
+#define PCI_IDE_CTL			0x08
+#define  PCI_IDE_CTL_FLOWTHROUGH_IDE	0x4  /* Flow-Through IDE Stream Enabled */
+
+#define PCI_IDE_LINK_STREAM_0		0xc  /* First Link Stream Register Block */
+#define  PCI_IDE_LINK_BLOCK_SIZE	8
+/* Link IDE Stream block, up to PCI_IDE_CAP_LINK_TC_NUM */
+#define PCI_IDE_LINK_CTL_0		0x00		  /* First Link Control Register Offset in block */
+#define  PCI_IDE_LINK_CTL_EN		0x1		  /* Link IDE Stream Enable */
+#define  PCI_IDE_LINK_CTL_TX_AGGR_NPR	__GENMASK(3, 2)	  /* Tx Aggregation Mode NPR */
+#define  PCI_IDE_LINK_CTL_TX_AGGR_PR	__GENMASK(5, 4)	  /* Tx Aggregation Mode PR */
+#define  PCI_IDE_LINK_CTL_TX_AGGR_CPL	__GENMASK(7, 6)	  /* Tx Aggregation Mode CPL */
+#define  PCI_IDE_LINK_CTL_PCRC_EN	0x100		  /* PCRC Enable */
+#define  PCI_IDE_LINK_CTL_PART_ENC	__GENMASK(13, 10) /* Partial Header Encryption Mode */
+#define  PCI_IDE_LINK_CTL_ALG		__GENMASK(18, 14) /* Selection from PCI_IDE_CAP_ALG */
+#define  PCI_IDE_LINK_CTL_TC		__GENMASK(21, 19) /* Traffic Class */
+#define  PCI_IDE_LINK_CTL_ID		__GENMASK(31, 24) /* Stream ID */
+#define PCI_IDE_LINK_STS_0		0x4               /* First Link Status Register Offset in block */
+#define  PCI_IDE_LINK_STS_STATE		__GENMASK(3, 0)   /* Link IDE Stream State */
+#define  PCI_IDE_LINK_STS_IDE_FAIL	0x80000000	  /* IDE fail message received */
+
+/* Selective IDE Stream block, up to PCI_IDE_CAP_SELECTIVE_STREAMS_NUM */
+/* Selective IDE Stream Capability Register */
+#define  PCI_IDE_SEL_CAP		0x00
+#define   PCI_IDE_SEL_CAP_ASSOC_NUM	__GENMASK(3, 0)
+/* Selective IDE Stream Control Register */
+#define  PCI_IDE_SEL_CTL		0x04
+#define   PCI_IDE_SEL_CTL_EN		0x1		  /* Selective IDE Stream Enable */
+#define   PCI_IDE_SEL_CTL_TX_AGGR_NPR	__GENMASK(3, 2)	  /* Tx Aggregation Mode NPR */
+#define   PCI_IDE_SEL_CTL_TX_AGGR_PR	__GENMASK(5, 4)   /* Tx Aggregation Mode PR */
+#define   PCI_IDE_SEL_CTL_TX_AGGR_CPL	__GENMASK(7, 6)	  /* Tx Aggregation Mode CPL */
+#define   PCI_IDE_SEL_CTL_PCRC_EN	0x100		  /* PCRC Enable */
+#define   PCI_IDE_SEL_CTL_CFG_EN	0x200		  /* Selective IDE for Configuration Requests */
+#define   PCI_IDE_SEL_CTL_PART_ENC	__GENMASK(13, 10) /* Partial Header Encryption Mode */
+#define   PCI_IDE_SEL_CTL_ALG		__GENMASK(18, 14) /* Selection from PCI_IDE_CAP_ALG */
+#define   PCI_IDE_SEL_CTL_TC		__GENMASK(21, 19) /* Traffic Class */
+#define   PCI_IDE_SEL_CTL_DEFAULT	0x400000	  /* Default Stream */
+#define   PCI_IDE_SEL_CTL_TEE_LIMITED	0x800000	  /* TEE-Limited Stream */
+#define   PCI_IDE_SEL_CTL_ID		__GENMASK(31, 24) /* Stream ID */
+#define   PCI_IDE_SEL_CTL_ID_MAX	255
+/* Selective IDE Stream Status Register */
+#define  PCI_IDE_SEL_STS		 0x08
+#define   PCI_IDE_SEL_STS_STATE		 __GENMASK(3, 0) /* Selective IDE Stream State */
+#define   PCI_IDE_SEL_STS_STATE_INSECURE 0
+#define   PCI_IDE_SEL_STS_STATE_SECURE	 2
+#define   PCI_IDE_SEL_STS_IDE_FAIL	 0x80000000	 /* IDE fail message received */
+/* IDE RID Association Register 1 */
+#define  PCI_IDE_SEL_RID_1		 0x0c
+#define   PCI_IDE_SEL_RID_1_LIMIT	 __GENMASK(23, 8)
+/* IDE RID Association Register 2 */
+#define  PCI_IDE_SEL_RID_2		0x10
+#define   PCI_IDE_SEL_RID_2_VALID	0x1
+#define   PCI_IDE_SEL_RID_2_BASE	__GENMASK(23, 8)
+#define   PCI_IDE_SEL_RID_2_SEG		__GENMASK(31, 24)
+/* Selective IDE Address Association Register Block, up to PCI_IDE_SEL_CAP_ASSOC_NUM */
+#define PCI_IDE_SEL_ADDR_BLOCK_SIZE	12
+#define  PCI_IDE_SEL_ADDR_1(x)		(20 + (x) * PCI_IDE_SEL_ADDR_BLOCK_SIZE)
+#define   PCI_IDE_SEL_ADDR_1_VALID	0x1
+#define   PCI_IDE_SEL_ADDR_1_BASE_LOW	__GENMASK(19, 8)
+#define   PCI_IDE_SEL_ADDR_1_LIMIT_LOW	__GENMASK(31, 20)
+/* IDE Address Association Register 2 is "Memory Limit Upper" */
+#define  PCI_IDE_SEL_ADDR_2(x)		(24 + (x) * PCI_IDE_SEL_ADDR_BLOCK_SIZE)
+/* IDE Address Association Register 3 is "Memory Base Upper" */
+#define  PCI_IDE_SEL_ADDR_3(x)		(28 + (x) * PCI_IDE_SEL_ADDR_BLOCK_SIZE)
+#define PCI_IDE_SEL_BLOCK_SIZE(nr_assoc)  (20 + PCI_IDE_SEL_ADDR_BLOCK_SIZE * (nr_assoc))
+
 #endif /* LINUX_PCI_REGS_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/perf_event.h b/lib/libc/include/any-linux-any/linux/perf_event.h
index c148f90cae1e4fc86c1b0c0700ea7fa5c1db3ef7..8459dd89d78997c5f99db2e426dbfa052fa61c13 100644
--- a/lib/libc/include/any-linux-any/linux/perf_event.h
+++ b/lib/libc/include/any-linux-any/linux/perf_event.h
@@ -2,7 +2,7 @@
 /*
  * Performance events:
  *
- *    Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
+ *    Copyright (C) 2008-2009, Linutronix GmbH, Thomas Gleixner <tglx@kernel.org>
  *    Copyright (C) 2008-2011, Red Hat, Inc., Ingo Molnar
  *    Copyright (C) 2008-2011, Red Hat, Inc., Peter Zijlstra
  *
@@ -382,6 +382,7 @@ enum perf_event_read_format {
 #define PERF_ATTR_SIZE_VER6			120	/* Add: aux_sample_size */
 #define PERF_ATTR_SIZE_VER7			128	/* Add: sig_data */
 #define PERF_ATTR_SIZE_VER8			136	/* Add: config3 */
+#define PERF_ATTR_SIZE_VER9			144	/* add: config4 */
 
 /*
  * 'struct perf_event_attr' contains various attributes that define
@@ -463,7 +464,9 @@ struct perf_event_attr {
 				inherit_thread :  1, /* children only inherit if cloned with CLONE_THREAD */
 				remove_on_exec :  1, /* event is removed from task on exec */
 				sigtrap        :  1, /* send synchronous SIGTRAP on event */
-				__reserved_1   : 26;
+				defer_callchain:  1, /* request PERF_RECORD_CALLCHAIN_DEFERRED records */
+				defer_output   :  1, /* output PERF_RECORD_CALLCHAIN_DEFERRED records */
+				__reserved_1   : 24;
 
 	union {
 		__u32		wakeup_events;	  /* wake up every n events */
@@ -543,6 +546,7 @@ struct perf_event_attr {
 	__u64	sig_data;
 
 	__u64	config3; /* extension of config2 */
+	__u64	config4; /* extension of config3 */
 };
 
 /*
@@ -1239,6 +1243,22 @@ enum perf_event_type {
 	 */
 	PERF_RECORD_AUX_OUTPUT_HW_ID		= 21,
 
+	/*
+	 * This user callchain capture was deferred until shortly before
+	 * returning to user space.  Previous samples would have kernel
+	 * callchains only and they need to be stitched with this to make full
+	 * callchains.
+	 *
+	 * struct {
+	 *	struct perf_event_header	header;
+	 *	u64				cookie;
+	 *	u64				nr;
+	 *	u64				ips[nr];
+	 *	struct sample_id		sample_id;
+	 * };
+	 */
+	PERF_RECORD_CALLCHAIN_DEFERRED		= 22,
+
 	PERF_RECORD_MAX,			/* non-ABI */
 };
 
@@ -1269,6 +1289,7 @@ enum perf_callchain_context {
 	PERF_CONTEXT_HV				= (__u64)-32,
 	PERF_CONTEXT_KERNEL			= (__u64)-128,
 	PERF_CONTEXT_USER			= (__u64)-512,
+	PERF_CONTEXT_USER_DEFERRED		= (__u64)-640,
 
 	PERF_CONTEXT_GUEST			= (__u64)-2048,
 	PERF_CONTEXT_GUEST_KERNEL		= (__u64)-2176,
diff --git a/lib/libc/include/any-linux-any/linux/pidfd.h b/lib/libc/include/any-linux-any/linux/pidfd.h
index fb5f32a6967c2bfe97d02b3ae22c562e2f505c09..b6b447e819543c8829d8dfc37aa6b63674dc4703 100644
--- a/lib/libc/include/any-linux-any/linux/pidfd.h
+++ b/lib/libc/include/any-linux-any/linux/pidfd.h
@@ -22,8 +22,12 @@
 #define PIDFD_INFO_CGROUPID		(1UL << 2) /* Always returned if available, even if not requested */
 #define PIDFD_INFO_EXIT			(1UL << 3) /* Only returned if requested. */
 #define PIDFD_INFO_COREDUMP		(1UL << 4) /* Only returned if requested. */
+#define PIDFD_INFO_SUPPORTED_MASK	(1UL << 5) /* Want/got supported mask flags */
+#define PIDFD_INFO_COREDUMP_SIGNAL	(1UL << 6) /* Always returned if PIDFD_INFO_COREDUMP is requested. */
 
 #define PIDFD_INFO_SIZE_VER0		64 /* sizeof first published struct */
+#define PIDFD_INFO_SIZE_VER1		72 /* sizeof second published struct */
+#define PIDFD_INFO_SIZE_VER2		80 /* sizeof third published struct */
 
 /*
  * Values for @coredump_mask in pidfd_info.
@@ -87,8 +91,11 @@ struct pidfd_info {
 	__u32 fsuid;
 	__u32 fsgid;
 	__s32 exit_code;
-	__u32 coredump_mask;
-	__u32 __spare1;
+	struct /* coredump info */ {
+		__u32 coredump_mask;
+		__u32 coredump_signal;
+	};
+	__u64 supported_mask;	/* Mask flags that this kernel supports */
 };
 
 #define PIDFS_IOCTL_MAGIC 0xFF
diff --git a/lib/libc/include/any-linux-any/linux/pr.h b/lib/libc/include/any-linux-any/linux/pr.h
index c52481a33eaf0a6220bd37d369a3bc714b26b02c..f44b2dda5495f859842eebc4fa2692bad395875c 100644
--- a/lib/libc/include/any-linux-any/linux/pr.h
+++ b/lib/libc/include/any-linux-any/linux/pr.h
@@ -56,6 +56,18 @@ struct pr_clear {
 	__u32	__pad;
 };
 
+struct pr_read_keys {
+	__u32	generation;
+	__u32	num_keys;
+	__u64	keys_ptr;
+};
+
+struct pr_read_reservation {
+	__u64	key;
+	__u32	generation;
+	__u32	type;
+};
+
 #define PR_FL_IGNORE_KEY	(1 << 0)	/* ignore existing key */
 
 #define IOC_PR_REGISTER		_IOW('p', 200, struct pr_registration)
@@ -64,5 +76,9 @@ struct pr_clear {
 #define IOC_PR_PREEMPT		_IOW('p', 203, struct pr_preempt)
 #define IOC_PR_PREEMPT_ABORT	_IOW('p', 204, struct pr_preempt)
 #define IOC_PR_CLEAR		_IOW('p', 205, struct pr_clear)
+#define IOC_PR_READ_KEYS	_IOWR('p', 206, struct pr_read_keys)
+#define IOC_PR_READ_RESERVATION	_IOR('p', 207, struct pr_read_reservation)
+
+#define PR_KEYS_MAX		(1u << 16)
 
 #endif /* _PR_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/prctl.h b/lib/libc/include/any-linux-any/linux/prctl.h
index c5ffc68b8cfaa96467b938806106a9dd07f99051..00b7b5fe56c4458965d00762a7e4b0b1418e98cb 100644
--- a/lib/libc/include/any-linux-any/linux/prctl.h
+++ b/lib/libc/include/any-linux-any/linux/prctl.h
@@ -177,7 +177,17 @@ struct prctl_mm_map {
 
 #define PR_GET_TID_ADDRESS	40
 
+/*
+ * Flags for PR_SET_THP_DISABLE are only applicable when disabling. Bit 0
+ * is reserved, so PR_GET_THP_DISABLE can return "1 | flags", to effectively
+ * return "1" when no flags were specified for PR_SET_THP_DISABLE.
+ */
 #define PR_SET_THP_DISABLE	41
+/*
+ * Don't disable THPs when explicitly advised (e.g., MADV_HUGEPAGE /
+ * VM_HUGEPAGE, MADV_COLLAPSE).
+ */
+# define PR_THP_DISABLE_EXCEPT_ADVISED	(1 << 1)
 #define PR_GET_THP_DISABLE	42
 
 /*
diff --git a/lib/libc/include/any-linux-any/linux/psp-sev.h b/lib/libc/include/any-linux-any/linux/psp-sev.h
index ce45a7f9bf030978fe819b107392fc5108bb84ac..ba30f4cd48a256788db8016bbb51b88a607f9d98 100644
--- a/lib/libc/include/any-linux-any/linux/psp-sev.h
+++ b/lib/libc/include/any-linux-any/linux/psp-sev.h
@@ -47,32 +47,32 @@ typedef enum {
 	 * with possible values from the specification.
 	 */
 	SEV_RET_NO_FW_CALL = -1,
-	SEV_RET_SUCCESS = 0,
-	SEV_RET_INVALID_PLATFORM_STATE,
-	SEV_RET_INVALID_GUEST_STATE,
-	SEV_RET_INAVLID_CONFIG,
+	SEV_RET_SUCCESS                    = 0,
+	SEV_RET_INVALID_PLATFORM_STATE     = 0x0001,
+	SEV_RET_INVALID_GUEST_STATE        = 0x0002,
+	SEV_RET_INAVLID_CONFIG             = 0x0003,
 	SEV_RET_INVALID_CONFIG = SEV_RET_INAVLID_CONFIG,
-	SEV_RET_INVALID_LEN,
-	SEV_RET_ALREADY_OWNED,
-	SEV_RET_INVALID_CERTIFICATE,
-	SEV_RET_POLICY_FAILURE,
-	SEV_RET_INACTIVE,
-	SEV_RET_INVALID_ADDRESS,
-	SEV_RET_BAD_SIGNATURE,
-	SEV_RET_BAD_MEASUREMENT,
-	SEV_RET_ASID_OWNED,
-	SEV_RET_INVALID_ASID,
-	SEV_RET_WBINVD_REQUIRED,
-	SEV_RET_DFFLUSH_REQUIRED,
-	SEV_RET_INVALID_GUEST,
-	SEV_RET_INVALID_COMMAND,
-	SEV_RET_ACTIVE,
-	SEV_RET_HWSEV_RET_PLATFORM,
-	SEV_RET_HWSEV_RET_UNSAFE,
-	SEV_RET_UNSUPPORTED,
-	SEV_RET_INVALID_PARAM,
-	SEV_RET_RESOURCE_LIMIT,
-	SEV_RET_SECURE_DATA_INVALID,
+	SEV_RET_INVALID_LEN                = 0x0004,
+	SEV_RET_ALREADY_OWNED              = 0x0005,
+	SEV_RET_INVALID_CERTIFICATE        = 0x0006,
+	SEV_RET_POLICY_FAILURE             = 0x0007,
+	SEV_RET_INACTIVE                   = 0x0008,
+	SEV_RET_INVALID_ADDRESS            = 0x0009,
+	SEV_RET_BAD_SIGNATURE              = 0x000A,
+	SEV_RET_BAD_MEASUREMENT            = 0x000B,
+	SEV_RET_ASID_OWNED                 = 0x000C,
+	SEV_RET_INVALID_ASID               = 0x000D,
+	SEV_RET_WBINVD_REQUIRED            = 0x000E,
+	SEV_RET_DFFLUSH_REQUIRED           = 0x000F,
+	SEV_RET_INVALID_GUEST              = 0x0010,
+	SEV_RET_INVALID_COMMAND            = 0x0011,
+	SEV_RET_ACTIVE                     = 0x0012,
+	SEV_RET_HWSEV_RET_PLATFORM         = 0x0013,
+	SEV_RET_HWSEV_RET_UNSAFE           = 0x0014,
+	SEV_RET_UNSUPPORTED                = 0x0015,
+	SEV_RET_INVALID_PARAM              = 0x0016,
+	SEV_RET_RESOURCE_LIMIT             = 0x0017,
+	SEV_RET_SECURE_DATA_INVALID        = 0x0018,
 	SEV_RET_INVALID_PAGE_SIZE          = 0x0019,
 	SEV_RET_INVALID_PAGE_STATE         = 0x001A,
 	SEV_RET_INVALID_MDATA_ENTRY        = 0x001B,
@@ -87,6 +87,22 @@ typedef enum {
 	SEV_RET_RESTORE_REQUIRED           = 0x0025,
 	SEV_RET_RMP_INITIALIZATION_FAILED  = 0x0026,
 	SEV_RET_INVALID_KEY                = 0x0027,
+	SEV_RET_SHUTDOWN_INCOMPLETE        = 0x0028,
+	SEV_RET_INCORRECT_BUFFER_LENGTH	   = 0x0030,
+	SEV_RET_EXPAND_BUFFER_LENGTH_REQUEST = 0x0031,
+	SEV_RET_SPDM_REQUEST               = 0x0032,
+	SEV_RET_SPDM_ERROR                 = 0x0033,
+	SEV_RET_SEV_STATUS_ERR_IN_DEV_CONN = 0x0035,
+	SEV_RET_SEV_STATUS_INVALID_DEV_CTX = 0x0036,
+	SEV_RET_SEV_STATUS_INVALID_TDI_CTX = 0x0037,
+	SEV_RET_SEV_STATUS_INVALID_TDI     = 0x0038,
+	SEV_RET_SEV_STATUS_RECLAIM_REQUIRED = 0x0039,
+	SEV_RET_IN_USE                     = 0x003A,
+	SEV_RET_SEV_STATUS_INVALID_DEV_STATE = 0x003B,
+	SEV_RET_SEV_STATUS_INVALID_TDI_STATE = 0x003C,
+	SEV_RET_SEV_STATUS_DEV_CERT_CHANGED = 0x003D,
+	SEV_RET_SEV_STATUS_RESYNC_REQ      = 0x003E,
+	SEV_RET_SEV_STATUS_RESPONSE_TOO_LARGE = 0x003F,
 	SEV_RET_MAX,
 } sev_ret_code;
 
@@ -185,6 +201,10 @@ struct sev_user_data_get_id2 {
  * @mask_chip_id: whether chip id is present in attestation reports or not
  * @mask_chip_key: whether attestation reports are signed or not
  * @vlek_en: VLEK (Version Loaded Endorsement Key) hashstick is loaded
+ * @feature_info: whether SNP_FEATURE_INFO command is available
+ * @rapl_dis: whether RAPL is disabled
+ * @ciphertext_hiding_cap: whether platform has ciphertext hiding capability
+ * @ciphertext_hiding_en: whether ciphertext hiding is enabled
  * @rsvd1: reserved
  * @guest_count: the number of guest currently managed by the firmware
  * @current_tcb_version: current TCB version
@@ -200,7 +220,11 @@ struct sev_user_data_snp_status {
 	__u32 mask_chip_id:1;		/* Out */
 	__u32 mask_chip_key:1;		/* Out */
 	__u32 vlek_en:1;		/* Out */
-	__u32 rsvd1:29;
+	__u32 feature_info:1;		/* Out */
+	__u32 rapl_dis:1;		/* Out */
+	__u32 ciphertext_hiding_cap:1;	/* Out */
+	__u32 ciphertext_hiding_en:1;	/* Out */
+	__u32 rsvd1:25;
 	__u32 guest_count;		/* Out */
 	__u64 current_tcb_version;	/* Out */
 	__u64 reported_tcb_version;	/* Out */
diff --git a/lib/libc/include/any-linux-any/linux/psp-sfs.h b/lib/libc/include/any-linux-any/linux/psp-sfs.h
new file mode 100644
index 0000000000000000000000000000000000000000..effaa14b678bc620c34481cef830a3353ca4bee5
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/psp-sfs.h
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */
+/*
+ * Userspace interface for AMD Seamless Firmware Servicing (SFS)
+ *
+ * Copyright (C) 2025 Advanced Micro Devices, Inc.
+ *
+ * Author: Ashish Kalra <ashish.kalra@amd.com>
+ */
+
+#ifndef __PSP_SFS_USER_H__
+#define __PSP_SFS_USER_H__
+
+#include <linux/types.h>
+
+/**
+ * SFS: AMD Seamless Firmware Support (SFS) interface
+ */
+
+#define PAYLOAD_NAME_SIZE	64
+#define TEE_EXT_CMD_BUFFER_SIZE	4096
+
+/**
+ * struct sfs_user_get_fw_versions - get current level of base firmware (output).
+ * @blob:                  current level of base firmware for ASP and patch levels (input/output).
+ * @sfs_status:            32-bit SFS status value (output).
+ * @sfs_extended_status:   32-bit SFS extended status value (output).
+ */
+struct sfs_user_get_fw_versions {
+	__u8	blob[TEE_EXT_CMD_BUFFER_SIZE];
+	__u32	sfs_status;
+	__u32	sfs_extended_status;
+} __attribute__((packed));
+
+/**
+ * struct sfs_user_update_package - update SFS package (input).
+ * @payload_name:          name of SFS package to load, verify and execute (input).
+ * @sfs_status:            32-bit SFS status value (output).
+ * @sfs_extended_status:   32-bit SFS extended status value (output).
+ */
+struct sfs_user_update_package {
+	char	payload_name[PAYLOAD_NAME_SIZE];
+	__u32	sfs_status;
+	__u32	sfs_extended_status;
+} __attribute__((packed));
+
+/**
+ * Seamless Firmware Support (SFS) IOC
+ *
+ * possible return codes for all SFS IOCTLs:
+ *  0:          success
+ *  -EINVAL:    invalid input
+ *  -E2BIG:     excess data passed
+ *  -EFAULT:    failed to copy to/from userspace
+ *  -EBUSY:     mailbox in recovery or in use
+ *  -ENODEV:    driver not bound with PSP device
+ *  -EACCES:    request isn't authorized
+ *  -EINVAL:    invalid parameter
+ *  -ETIMEDOUT: request timed out
+ *  -EAGAIN:    invalid request for state machine
+ *  -ENOENT:    not implemented
+ *  -ENFILE:    overflow
+ *  -EPERM:     invalid signature
+ *  -EIO:       PSP I/O error
+ */
+#define SFS_IOC_TYPE	'S'
+
+/**
+ * SFSIOCFWVERS - returns blob containing FW versions
+ *                ASP provides the current level of Base Firmware for the ASP
+ *                and the other microprocessors as well as current patch
+ *                level(s).
+ */
+#define SFSIOCFWVERS	_IOWR(SFS_IOC_TYPE, 0x1, struct sfs_user_get_fw_versions)
+
+/**
+ * SFSIOCUPDATEPKG - updates package/payload
+ *                   ASP loads, verifies and executes the SFS package.
+ *                   By default, the SFS package/payload is loaded from
+ *                   /lib/firmware/amd, but alternative firmware loading
+ *                   path can be specified using kernel parameter
+ *                   firmware_class.path or the firmware loading path
+ *                   can be customized using sysfs file:
+ *                   /sys/module/firmware_class/parameters/path.
+ */
+#define SFSIOCUPDATEPKG	_IOWR(SFS_IOC_TYPE, 0x2, struct sfs_user_update_package)
+
+#endif /* __PSP_SFS_USER_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/psp.h b/lib/libc/include/any-linux-any/linux/psp.h
new file mode 100644
index 0000000000000000000000000000000000000000..edfee0216117dde01d002cd7dac61eb0d1756ed4
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/psp.h
@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/psp.yaml */
+/* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
+
+#ifndef _LINUX_PSP_H
+#define _LINUX_PSP_H
+
+#define PSP_FAMILY_NAME		"psp"
+#define PSP_FAMILY_VERSION	1
+
+enum psp_version {
+	PSP_VERSION_HDR0_AES_GCM_128,
+	PSP_VERSION_HDR0_AES_GCM_256,
+	PSP_VERSION_HDR0_AES_GMAC_128,
+	PSP_VERSION_HDR0_AES_GMAC_256,
+};
+
+enum {
+	PSP_A_DEV_ID = 1,
+	PSP_A_DEV_IFINDEX,
+	PSP_A_DEV_PSP_VERSIONS_CAP,
+	PSP_A_DEV_PSP_VERSIONS_ENA,
+
+	__PSP_A_DEV_MAX,
+	PSP_A_DEV_MAX = (__PSP_A_DEV_MAX - 1)
+};
+
+enum {
+	PSP_A_ASSOC_DEV_ID = 1,
+	PSP_A_ASSOC_VERSION,
+	PSP_A_ASSOC_RX_KEY,
+	PSP_A_ASSOC_TX_KEY,
+	PSP_A_ASSOC_SOCK_FD,
+
+	__PSP_A_ASSOC_MAX,
+	PSP_A_ASSOC_MAX = (__PSP_A_ASSOC_MAX - 1)
+};
+
+enum {
+	PSP_A_KEYS_KEY = 1,
+	PSP_A_KEYS_SPI,
+
+	__PSP_A_KEYS_MAX,
+	PSP_A_KEYS_MAX = (__PSP_A_KEYS_MAX - 1)
+};
+
+enum {
+	PSP_A_STATS_DEV_ID = 1,
+	PSP_A_STATS_KEY_ROTATIONS,
+	PSP_A_STATS_STALE_EVENTS,
+	PSP_A_STATS_RX_PACKETS,
+	PSP_A_STATS_RX_BYTES,
+	PSP_A_STATS_RX_AUTH_FAIL,
+	PSP_A_STATS_RX_ERROR,
+	PSP_A_STATS_RX_BAD,
+	PSP_A_STATS_TX_PACKETS,
+	PSP_A_STATS_TX_BYTES,
+	PSP_A_STATS_TX_ERROR,
+
+	__PSP_A_STATS_MAX,
+	PSP_A_STATS_MAX = (__PSP_A_STATS_MAX - 1)
+};
+
+enum {
+	PSP_CMD_DEV_GET = 1,
+	PSP_CMD_DEV_ADD_NTF,
+	PSP_CMD_DEV_DEL_NTF,
+	PSP_CMD_DEV_SET,
+	PSP_CMD_DEV_CHANGE_NTF,
+	PSP_CMD_KEY_ROTATE,
+	PSP_CMD_KEY_ROTATE_NTF,
+	PSP_CMD_RX_ASSOC,
+	PSP_CMD_TX_ASSOC,
+	PSP_CMD_GET_STATS,
+
+	__PSP_CMD_MAX,
+	PSP_CMD_MAX = (__PSP_CMD_MAX - 1)
+};
+
+#define PSP_MCGRP_MGMT	"mgmt"
+#define PSP_MCGRP_USE	"use"
+
+#endif /* _LINUX_PSP_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/ptp_clock.h b/lib/libc/include/any-linux-any/linux/ptp_clock.h
index f1325f8d62aa058fd3d6c4e87c2379cb0aa44250..c30e0bbca9af61c6456514ab1922d5a8a6d16f00 100644
--- a/lib/libc/include/any-linux-any/linux/ptp_clock.h
+++ b/lib/libc/include/any-linux-any/linux/ptp_clock.h
@@ -248,6 +248,10 @@ struct ptp_pin_desc {
 	_IOWR(PTP_CLK_MAGIC, 18, struct ptp_sys_offset_extended)
 #define PTP_MASK_CLEAR_ALL  _IO(PTP_CLK_MAGIC, 19)
 #define PTP_MASK_EN_SINGLE  _IOW(PTP_CLK_MAGIC, 20, unsigned int)
+#define PTP_SYS_OFFSET_PRECISE_CYCLES \
+	_IOWR(PTP_CLK_MAGIC, 21, struct ptp_sys_offset_precise)
+#define PTP_SYS_OFFSET_EXTENDED_CYCLES \
+	_IOWR(PTP_CLK_MAGIC, 22, struct ptp_sys_offset_extended)
 
 struct ptp_extts_event {
 	struct ptp_clock_time t; /* Time event occurred. */
diff --git a/lib/libc/include/any-linux-any/linux/raid/md_p.h b/lib/libc/include/any-linux-any/linux/raid/md_p.h
index b07f8e01158e065407de960c87b74c4871906f21..10e3a335c92764d773ecfa62a07931c00287ee9a 100644
--- a/lib/libc/include/any-linux-any/linux/raid/md_p.h
+++ b/lib/libc/include/any-linux-any/linux/raid/md_p.h
@@ -291,7 +291,8 @@ struct mdp_superblock_1 {
 	__le64	resync_offset;	/* data before this offset (from data_offset) known to be in sync */
 	__le32	sb_csum;	/* checksum up to devs[max_dev] */
 	__le32	max_dev;	/* size of devs[] array to consider */
-	__u8	pad3[64-32];	/* set to 0 when writing */
+	__le32  logical_block_size;	/* same as q->limits->logical_block_size */
+	__u8	pad3[64-36];	/* set to 0 when writing */
 
 	/* device state information. Indexed by dev_number.
 	 * 2 bytes per device
diff --git a/lib/libc/include/any-linux-any/linux/rkisp1-config.h b/lib/libc/include/any-linux-any/linux/rkisp1-config.h
index 2eb9ca60c7ccaace64636e0a5138cb7860ae6b0c..de50a52521360e2ddbfe4e8a0e514aa1376af48d 100644
--- a/lib/libc/include/any-linux-any/linux/rkisp1-config.h
+++ b/lib/libc/include/any-linux-any/linux/rkisp1-config.h
@@ -9,6 +9,8 @@
 
 #include <linux/types.h>
 
+#include <linux/media/v4l2-isp.h>
+
 /* Defect Pixel Cluster Detection */
 #define RKISP1_CIF_ISP_MODULE_DPCC		(1U << 0)
 /* Black Level Subtraction */
@@ -1158,79 +1160,26 @@ enum rkisp1_ext_params_block_type {
 	RKISP1_EXT_PARAMS_BLOCK_TYPE_WDR,
 };
 
-#define RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE	(1U << 0)
-#define RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE	(1U << 1)
+/* For backward compatibility */
+#define RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE	V4L2_ISP_PARAMS_FL_BLOCK_DISABLE
+#define RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE	V4L2_ISP_PARAMS_FL_BLOCK_ENABLE
 
 /* A bitmask of parameters blocks supported on the current hardware. */
 #define RKISP1_CID_SUPPORTED_PARAMS_BLOCKS	(V4L2_CID_USER_RKISP1_BASE + 0x01)
 
 /**
- * struct rkisp1_ext_params_block_header - RkISP1 extensible parameters block
- *					   header
+ * rkisp1_ext_params_block_header - RkISP1 extensible parameters block header
  *
  * This structure represents the common part of all the ISP configuration
- * blocks. Each parameters block shall embed an instance of this structure type
- * as its first member, followed by the block-specific configuration data. The
- * driver inspects this common header to discern the block type and its size and
- * properly handle the block content by casting it to the correct block-specific
- * type.
+ * blocks and is identical to :c:type:`v4l2_isp_params_block_header`.
  *
- * The @type field is one of the values enumerated by
+ * The type field is one of the values enumerated by
  * :c:type:`rkisp1_ext_params_block_type` and specifies how the data should be
- * interpreted by the driver. The @size field specifies the size of the
- * parameters block and is used by the driver for validation purposes.
+ * interpreted by the driver.
  *
- * The @flags field is a bitmask of per-block flags RKISP1_EXT_PARAMS_FL_*.
- *
- * When userspace wants to configure and enable an ISP block it shall fully
- * populate the block configuration and set the
- * RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE bit in the @flags field.
- *
- * When userspace simply wants to disable an ISP block the
- * RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE bit should be set in @flags field. The
- * driver ignores the rest of the block configuration structure in this case.
- *
- * If a new configuration of an ISP block has to be applied userspace shall
- * fully populate the ISP block configuration and omit setting the
- * RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE and RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE bits
- * in the @flags field.
- *
- * Setting both the RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE and
- * RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE bits in the @flags field is not allowed
- * and not accepted by the driver.
- *
- * Userspace is responsible for correctly populating the parameters block header
- * fields (@type, @flags and @size) and the block-specific parameters.
- *
- * For example:
- *
- * .. code-block:: c
- *
- *	void populate_bls(struct rkisp1_ext_params_block_header *block) {
- *		struct rkisp1_ext_params_bls_config *bls =
- *			(struct rkisp1_ext_params_bls_config *)block;
- *
- *		bls->header.type = RKISP1_EXT_PARAMS_BLOCK_ID_BLS;
- *		bls->header.flags = RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE;
- *		bls->header.size = sizeof(*bls);
- *
- *		bls->config.enable_auto = 0;
- *		bls->config.fixed_val.r = blackLevelRed_;
- *		bls->config.fixed_val.gr = blackLevelGreenR_;
- *		bls->config.fixed_val.gb = blackLevelGreenB_;
- *		bls->config.fixed_val.b = blackLevelBlue_;
- *	}
- *
- * @type: The parameters block type, see
- *	  :c:type:`rkisp1_ext_params_block_type`
- * @flags: A bitmask of block flags
- * @size: Size (in bytes) of the parameters block, including this header
+ * The flags field is a bitmask of per-block flags RKISP1_EXT_PARAMS_FL_*.
  */
-struct rkisp1_ext_params_block_header {
-	__u16 type;
-	__u16 flags;
-	__u32 size;
-};
+#define rkisp1_ext_params_block_header v4l2_isp_params_block_header
 
 /**
  * struct rkisp1_ext_params_bls_config - RkISP1 extensible params BLS config
@@ -1588,27 +1537,14 @@ struct rkisp1_ext_params_wdr_config {
  * @RKISP1_EXT_PARAM_BUFFER_V1: First version of RkISP1 extensible parameters
  */
 enum rksip1_ext_param_buffer_version {
-	RKISP1_EXT_PARAM_BUFFER_V1 = 1,
+	RKISP1_EXT_PARAM_BUFFER_V1 = V4L2_ISP_PARAMS_VERSION_V1,
 };
 
 /**
  * struct rkisp1_ext_params_cfg - RkISP1 extensible parameters configuration
  *
- * This struct contains the configuration parameters of the RkISP1 ISP
- * algorithms, serialized by userspace into a data buffer. Each configuration
- * parameter block is represented by a block-specific structure which contains a
- * :c:type:`rkisp1_ext_params_block_header` entry as first member. Userspace
- * populates the @data buffer with configuration parameters for the blocks that
- * it intends to configure. As a consequence, the data buffer effective size
- * changes according to the number of ISP blocks that userspace intends to
- * configure and is set by userspace in the @data_size field.
- *
- * The parameters buffer is versioned by the @version field to allow modifying
- * and extending its definition. Userspace shall populate the @version field to
- * inform the driver about the version it intends to use. The driver will parse
- * and handle the @data buffer according to the data layout specific to the
- * indicated version and return an error if the desired version is not
- * supported.
+ * This is the driver-specific implementation of
+ * :c:type:`v4l2_isp_params_buffer`.
  *
  * Currently the single RKISP1_EXT_PARAM_BUFFER_V1 version is supported.
  * When a new format version will be added, a mechanism for userspace to query
@@ -1624,11 +1560,6 @@ enum rksip1_ext_param_buffer_version {
  * the maximum value represents the blocks supported by the kernel driver,
  * independently of the device instance.
  *
- * For each ISP block that userspace wants to configure, a block-specific
- * structure is appended to the @data buffer, one after the other without gaps
- * in between nor overlaps. Userspace shall populate the @data_size field with
- * the effective size, in bytes, of the @data buffer.
- *
  * The expected memory layout of the parameters buffer is::
  *
  *	+-------------------- struct rkisp1_ext_params_cfg -------------------+
@@ -1678,4 +1609,5 @@ struct rkisp1_ext_params_cfg {
 	__u8 data[RKISP1_EXT_PARAMS_MAX_SIZE];
 };
 
+
 #endif /* _RKISP1_CONFIG_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/rseq.h b/lib/libc/include/any-linux-any/linux/rseq.h
index 753d9fb68929489f1713f8b0299a08ec170d009c..098884d5e4301d4e583c845274d3c6df5d0dbbba 100644
--- a/lib/libc/include/any-linux-any/linux/rseq.h
+++ b/lib/libc/include/any-linux-any/linux/rseq.h
@@ -114,20 +114,13 @@ struct rseq {
 	/*
 	 * Restartable sequences flags field.
 	 *
-	 * This field should only be updated by the thread which
-	 * registered this data structure. Read by the kernel.
-	 * Mainly used for single-stepping through rseq critical sections
-	 * with debuggers.
-	 *
-	 * - RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT
-	 *     Inhibit instruction sequence block restart on preemption
-	 *     for this thread.
-	 * - RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL
-	 *     Inhibit instruction sequence block restart on signal
-	 *     delivery for this thread.
-	 * - RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE
-	 *     Inhibit instruction sequence block restart on migration for
-	 *     this thread.
+	 * This field was initially intended to allow event masking for
+	 * single-stepping through rseq critical sections with debuggers.
+	 * The kernel does not support this anymore and the relevant bits
+	 * are checked for being always false:
+	 *	- RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT
+	 *	- RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL
+	 *	- RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE
 	 */
 	__u32 flags;
 
diff --git a/lib/libc/include/any-linux-any/linux/stddef.h b/lib/libc/include/any-linux-any/linux/stddef.h
index 3617ec45ae58dad8aafdd01f9f223079c57de66c..3c5b007adb7a39ab03ca8948e52b93d41700b8de 100644
--- a/lib/libc/include/any-linux-any/linux/stddef.h
+++ b/lib/libc/include/any-linux-any/linux/stddef.h
@@ -3,7 +3,6 @@
 #define _LINUX_STDDEF_H
 
 
-
 #ifndef __always_inline
 #define __always_inline __inline__
 #endif
diff --git a/lib/libc/include/any-linux-any/linux/tcp.h b/lib/libc/include/any-linux-any/linux/tcp.h
index 91e31b3251eb7e86dab73a2009be1ea443554c81..d31f30cee2b8a45aaac26b04224b6b6df8798658 100644
--- a/lib/libc/include/any-linux-any/linux/tcp.h
+++ b/lib/libc/include/any-linux-any/linux/tcp.h
@@ -316,6 +316,15 @@ struct tcp_info {
 					 * in milliseconds, including any
 					 * unfinished recovery.
 					 */
+	__u32	tcpi_received_ce;    /* # of CE marks received */
+	__u32	tcpi_delivered_e1_bytes;  /* Accurate ECN byte counters */
+	__u32	tcpi_delivered_e0_bytes;
+	__u32	tcpi_delivered_ce_bytes;
+	__u32	tcpi_received_e1_bytes;
+	__u32	tcpi_received_e0_bytes;
+	__u32	tcpi_received_ce_bytes;
+	__u16	tcpi_accecn_fail_mode;
+	__u16	tcpi_accecn_opt_seen;
 };
 
 /* netlink attributes types for SCM_TIMESTAMPING_OPT_STATS */
diff --git a/lib/libc/include/any-linux-any/linux/tee.h b/lib/libc/include/any-linux-any/linux/tee.h
index 43e7f3b2504caebfbe85cdae48a0012f12387689..4f8d7d97a77a2749fb910e0620e0bca74a92d805 100644
--- a/lib/libc/include/any-linux-any/linux/tee.h
+++ b/lib/libc/include/any-linux-any/linux/tee.h
@@ -42,14 +42,16 @@
 #define TEE_IOC_MAGIC	0xa4
 #define TEE_IOC_BASE	0
 
-#define TEE_MAX_ARG_SIZE	1024
+#define TEE_MAX_ARG_SIZE	4096
 
 #define TEE_GEN_CAP_GP		(1 << 0)/* GlobalPlatform compliant TEE */
 #define TEE_GEN_CAP_PRIVILEGED	(1 << 1)/* Privileged device (for supplicant) */
 #define TEE_GEN_CAP_REG_MEM	(1 << 2)/* Supports registering shared memory */
 #define TEE_GEN_CAP_MEMREF_NULL	(1 << 3)/* NULL MemRef support */
+#define TEE_GEN_CAP_OBJREF	(1 << 4)/* Supports generic object reference */
 
-#define TEE_MEMREF_NULL		(__u64)(-1) /* NULL MemRef Buffer */
+#define TEE_MEMREF_NULL		((__u64)(-1)) /* NULL MemRef Buffer */
+#define TEE_OBJREF_NULL		((__u64)(-1)) /* NULL ObjRef Object */
 
 /*
  * TEE Implementation ID
@@ -57,6 +59,7 @@
 #define TEE_IMPL_ID_OPTEE	1
 #define TEE_IMPL_ID_AMDTEE	2
 #define TEE_IMPL_ID_TSTEE	3
+#define TEE_IMPL_ID_QTEE	4
 
 /*
  * OP-TEE specific capabilities
@@ -151,6 +154,20 @@ struct tee_ioctl_buf_data {
 #define TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT	6
 #define TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT	7	/* input and output */
 
+/*
+ * These defines userspace buffer parameters.
+ */
+#define TEE_IOCTL_PARAM_ATTR_TYPE_UBUF_INPUT	8
+#define TEE_IOCTL_PARAM_ATTR_TYPE_UBUF_OUTPUT	9
+#define TEE_IOCTL_PARAM_ATTR_TYPE_UBUF_INOUT	10	/* input and output */
+
+/*
+ * These defines object reference parameters.
+ */
+#define TEE_IOCTL_PARAM_ATTR_TYPE_OBJREF_INPUT	11
+#define TEE_IOCTL_PARAM_ATTR_TYPE_OBJREF_OUTPUT	12
+#define TEE_IOCTL_PARAM_ATTR_TYPE_OBJREF_INOUT	13
+
 /*
  * Mask for the type part of the attribute, leaves room for more types
  */
@@ -186,14 +203,18 @@ struct tee_ioctl_buf_data {
 /**
  * struct tee_ioctl_param - parameter
  * @attr: attributes
- * @a: if a memref, offset into the shared memory object, else a value parameter
- * @b: if a memref, size of the buffer, else a value parameter
+ * @a: if a memref, offset into the shared memory object,
+ *     else if a ubuf, address of the user buffer,
+ *     else if an objref, object identifier, else a value parameter
+ * @b: if a memref or ubuf, size of the buffer,
+ *     else if objref, flags for the object, else a value parameter
  * @c: if a memref, shared memory identifier, else a value parameter
  *
- * @attr & TEE_PARAM_ATTR_TYPE_MASK indicates if memref or value is used in
- * the union. TEE_PARAM_ATTR_TYPE_VALUE_* indicates value and
- * TEE_PARAM_ATTR_TYPE_MEMREF_* indicates memref. TEE_PARAM_ATTR_TYPE_NONE
- * indicates that none of the members are used.
+ * @attr & TEE_PARAM_ATTR_TYPE_MASK indicates if memref, ubuf, or value is
+ * used in the union. TEE_PARAM_ATTR_TYPE_VALUE_* indicates value,
+ * TEE_PARAM_ATTR_TYPE_MEMREF_* indicates memref, TEE_PARAM_ATTR_TYPE_UBUF_*
+ * indicates ubuf, and TEE_PARAM_ATTR_TYPE_OBJREF_* indicates objref.
+ * TEE_PARAM_ATTR_TYPE_NONE indicates that none of the members are used.
  *
  * Shared memory is allocated with TEE_IOC_SHM_ALLOC which returns an
  * identifier representing the shared memory object. A memref can reference
@@ -228,8 +249,9 @@ struct tee_ioctl_param {
  * @cancel_id:	[in] Cancellation id, a unique value to identify this request
  * @session:	[out] Session id
  * @ret:	[out] return value
- * @ret_origin	[out] origin of the return value
- * @num_params	[in] number of parameters following this struct
+ * @ret_origin:	[out] origin of the return value
+ * @num_params:	[in] number of &struct tee_ioctl_param entries in @params
+ * @params:	array of ioctl parameters
  */
 struct tee_ioctl_open_session_arg {
 	__u8 uuid[TEE_IOCTL_UUID_LEN];
@@ -255,14 +277,14 @@ struct tee_ioctl_open_session_arg {
 				     struct tee_ioctl_buf_data)
 
 /**
- * struct tee_ioctl_invoke_func_arg - Invokes a function in a Trusted
- * Application
+ * struct tee_ioctl_invoke_arg - Invokes a function in a Trusted Application
  * @func:	[in] Trusted Application function, specific to the TA
  * @session:	[in] Session id
  * @cancel_id:	[in] Cancellation id, a unique value to identify this request
  * @ret:	[out] return value
- * @ret_origin	[out] origin of the return value
- * @num_params	[in] number of parameters following this struct
+ * @ret_origin:	[out] origin of the return value
+ * @num_params:	[in] number of parameters following this struct
+ * @params:	array of ioctl parameters
  */
 struct tee_ioctl_invoke_arg {
 	__u32 func;
@@ -317,7 +339,8 @@ struct tee_ioctl_close_session_arg {
 /**
  * struct tee_iocl_supp_recv_arg - Receive a request for a supplicant function
  * @func:	[in] supplicant function
- * @num_params	[in/out] number of parameters following this struct
+ * @num_params:	[in/out] number of &struct tee_ioctl_param entries in @params
+ * @params:	array of ioctl parameters
  *
  * @num_params is the number of params that tee-supplicant has room to
  * receive when input, @num_params is the number of actual params
@@ -342,7 +365,8 @@ struct tee_iocl_supp_recv_arg {
 /**
  * struct tee_iocl_supp_send_arg - Send a response to a received request
  * @ret:	[out] return value
- * @num_params	[in] number of parameters following this struct
+ * @num_params:	[in] number of &struct tee_ioctl_param entries in @params
+ * @params:	array of ioctl parameters
  */
 struct tee_iocl_supp_send_arg {
 	__u32 ret;
@@ -378,6 +402,37 @@ struct tee_ioctl_shm_register_data {
 	__s32 id;
 };
 
+/**
+ * struct tee_ioctl_shm_register_fd_data - Shared memory registering argument
+ * @fd:		[in] File descriptor identifying dmabuf reference
+ * @size:	[out] Size of referenced memory
+ * @flags:	[in] Flags to/from allocation.
+ * @id:		[out] Identifier of the shared memory
+ *
+ * The flags field should currently be zero as input. Updated by the call
+ * with actual flags as defined by TEE_IOCTL_SHM_* above.
+ * This structure is used as argument for TEE_IOC_SHM_REGISTER_FD below.
+ */
+struct tee_ioctl_shm_register_fd_data {
+	__s64 fd;
+	__u64 size;
+	__u32 flags;
+	__s32 id;
+};
+
+/**
+ * TEE_IOC_SHM_REGISTER_FD - register a shared memory from a file descriptor
+ *
+ * Returns a file descriptor on success or < 0 on failure
+ *
+ * The returned file descriptor refers to the shared memory object in the
+ * kernel. The supplied file deccriptor can be closed if it's not needed
+ * for other purposes. The shared memory is freed when the descriptor is
+ * closed.
+ */
+#define TEE_IOC_SHM_REGISTER_FD	_IOWR(TEE_IOC_MAGIC, TEE_IOC_BASE + 8, \
+				     struct tee_ioctl_shm_register_fd_data)
+
 /**
  * TEE_IOC_SHM_REGISTER - Register shared memory argument
  *
@@ -401,4 +456,25 @@ struct tee_ioctl_shm_register_data {
  * munmap(): unmaps previously shared memory
  */
 
+/**
+ * struct tee_ioctl_object_invoke_arg - Invokes an object in a
+ *   Trusted Application
+ * @id:		[in] Object id
+ * @op:		[in] Object operation, specific to the object
+ * @ret:	[out] return value
+ * @num_params:	[in] number of parameters following this struct
+ * @params:	array of ioctl parameters
+ */
+struct tee_ioctl_object_invoke_arg {
+	__u64 id;
+	__u32 op;
+	__u32 ret;
+	__u32 num_params;
+	/* num_params tells the actual number of element in params */
+	struct tee_ioctl_param params[];
+};
+
+#define TEE_IOC_OBJECT_INVOKE	_IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 10, \
+				     struct tee_ioctl_buf_data)
+
 #endif /*__TEE_H*/
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/tls.h b/lib/libc/include/any-linux-any/linux/tls.h
index 34431c8acd82aed8736b33fc9d55355df8265683..09141020115c5c64d6419059ae214867eb82bbb2 100644
--- a/lib/libc/include/any-linux-any/linux/tls.h
+++ b/lib/libc/include/any-linux-any/linux/tls.h
@@ -41,6 +41,7 @@
 #define TLS_RX			2	/* Set receive parameters */
 #define TLS_TX_ZEROCOPY_RO	3	/* TX zerocopy (only sendfile now) */
 #define TLS_RX_EXPECT_NO_PAD	4	/* Attempt opportunistic zero-copy */
+#define TLS_TX_MAX_PAYLOAD_LEN	5	/* Maximum plaintext size */
 
 /* Supported versions */
 #define TLS_VERSION_MINOR(ver)	((ver) & 0xFF)
@@ -194,6 +195,7 @@ enum {
 	TLS_INFO_RXCONF,
 	TLS_INFO_ZC_RO_TX,
 	TLS_INFO_RX_NO_PAD,
+	TLS_INFO_TX_MAX_PAYLOAD_LEN,
 	__TLS_INFO_MAX,
 };
 #define TLS_INFO_MAX (__TLS_INFO_MAX - 1)
diff --git a/lib/libc/include/any-linux-any/linux/usb/cdc.h b/lib/libc/include/any-linux-any/linux/usb/cdc.h
index 9d896d4fd525b9db99cd09d4ea35870adc12d92d..ef5a82e37d09bc31989236889cefd0e5ed09229b 100644
--- a/lib/libc/include/any-linux-any/linux/usb/cdc.h
+++ b/lib/libc/include/any-linux-any/linux/usb/cdc.h
@@ -104,8 +104,10 @@ struct usb_cdc_union_desc {
 	__u8	bDescriptorSubType;
 
 	__u8	bMasterInterface0;
-	__u8	bSlaveInterface0;
-	/* ... and there could be other slave interfaces */
+	union {
+		__u8	bSlaveInterface0;
+		__DECLARE_FLEX_ARRAY(__u8, bSlaveInterfaces);
+	};
 } __attribute__ ((packed));
 
 /* "Country Selection Functional Descriptor" from CDC spec 5.2.3.9 */
@@ -115,8 +117,10 @@ struct usb_cdc_country_functional_desc {
 	__u8	bDescriptorSubType;
 
 	__u8	iCountryCodeRelDate;
-	__le16	wCountyCode0;
-	/* ... and there can be a lot of country codes */
+	union {
+		__le16	wCountryCode0;
+		__DECLARE_FLEX_ARRAY(__le16, wCountryCodes);
+	};
 } __attribute__ ((packed));
 
 /* "Network Channel Terminal Functional Descriptor" from CDC spec 5.2.3.11 */
diff --git a/lib/libc/include/any-linux-any/linux/v4l2-controls.h b/lib/libc/include/any-linux-any/linux/v4l2-controls.h
index 03405ef3a6e25e2de3a752dd92f2234b7544b577..4faebbcf3a64a53fcdeb84c6175f21341acba82c 100644
--- a/lib/libc/include/any-linux-any/linux/v4l2-controls.h
+++ b/lib/libc/include/any-linux-any/linux/v4l2-controls.h
@@ -226,6 +226,12 @@ enum v4l2_colorfx {
  */
 #define V4L2_CID_USER_RKISP1_BASE		(V4L2_CID_USER_BASE + 0x1220)
 
+/*
+ * The base for the Arm Mali-C55 ISP driver controls.
+ * We reserve 16 controls for this driver
+ */
+#define V4L2_CID_USER_MALI_C55_BASE		(V4L2_CID_USER_BASE + 0x1230)
+
 /* MPEG-class control IDs */
 /* The MPEG controls are applicable to all codec controls
  * and the 'MPEG' part of the define is historical */
@@ -1189,7 +1195,7 @@ enum v4l2_flash_strobe_source {
 #define V4L2_CID_JPEG_CLASS_BASE		(V4L2_CTRL_CLASS_JPEG | 0x900)
 #define V4L2_CID_JPEG_CLASS			(V4L2_CTRL_CLASS_JPEG | 1)
 
-#define	V4L2_CID_JPEG_CHROMA_SUBSAMPLING	(V4L2_CID_JPEG_CLASS_BASE + 1)
+#define V4L2_CID_JPEG_CHROMA_SUBSAMPLING	(V4L2_CID_JPEG_CLASS_BASE + 1)
 enum v4l2_jpeg_chroma_subsampling {
 	V4L2_JPEG_CHROMA_SUBSAMPLING_444	= 0,
 	V4L2_JPEG_CHROMA_SUBSAMPLING_422	= 1,
@@ -1198,15 +1204,15 @@ enum v4l2_jpeg_chroma_subsampling {
 	V4L2_JPEG_CHROMA_SUBSAMPLING_410	= 4,
 	V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY	= 5,
 };
-#define	V4L2_CID_JPEG_RESTART_INTERVAL		(V4L2_CID_JPEG_CLASS_BASE + 2)
-#define	V4L2_CID_JPEG_COMPRESSION_QUALITY	(V4L2_CID_JPEG_CLASS_BASE + 3)
+#define V4L2_CID_JPEG_RESTART_INTERVAL		(V4L2_CID_JPEG_CLASS_BASE + 2)
+#define V4L2_CID_JPEG_COMPRESSION_QUALITY	(V4L2_CID_JPEG_CLASS_BASE + 3)
 
-#define	V4L2_CID_JPEG_ACTIVE_MARKER		(V4L2_CID_JPEG_CLASS_BASE + 4)
-#define	V4L2_JPEG_ACTIVE_MARKER_APP0		(1 << 0)
-#define	V4L2_JPEG_ACTIVE_MARKER_APP1		(1 << 1)
-#define	V4L2_JPEG_ACTIVE_MARKER_COM		(1 << 16)
-#define	V4L2_JPEG_ACTIVE_MARKER_DQT		(1 << 17)
-#define	V4L2_JPEG_ACTIVE_MARKER_DHT		(1 << 18)
+#define V4L2_CID_JPEG_ACTIVE_MARKER		(V4L2_CID_JPEG_CLASS_BASE + 4)
+#define V4L2_JPEG_ACTIVE_MARKER_APP0		(1 << 0)
+#define V4L2_JPEG_ACTIVE_MARKER_APP1		(1 << 1)
+#define V4L2_JPEG_ACTIVE_MARKER_COM		(1 << 16)
+#define V4L2_JPEG_ACTIVE_MARKER_DQT		(1 << 17)
+#define V4L2_JPEG_ACTIVE_MARKER_DHT		(1 << 18)
 
 
 /* Image source controls */
@@ -1239,10 +1245,10 @@ enum v4l2_jpeg_chroma_subsampling {
 #define V4L2_CID_DV_CLASS_BASE			(V4L2_CTRL_CLASS_DV | 0x900)
 #define V4L2_CID_DV_CLASS			(V4L2_CTRL_CLASS_DV | 1)
 
-#define	V4L2_CID_DV_TX_HOTPLUG			(V4L2_CID_DV_CLASS_BASE + 1)
-#define	V4L2_CID_DV_TX_RXSENSE			(V4L2_CID_DV_CLASS_BASE + 2)
-#define	V4L2_CID_DV_TX_EDID_PRESENT		(V4L2_CID_DV_CLASS_BASE + 3)
-#define	V4L2_CID_DV_TX_MODE			(V4L2_CID_DV_CLASS_BASE + 4)
+#define V4L2_CID_DV_TX_HOTPLUG			(V4L2_CID_DV_CLASS_BASE + 1)
+#define V4L2_CID_DV_TX_RXSENSE			(V4L2_CID_DV_CLASS_BASE + 2)
+#define V4L2_CID_DV_TX_EDID_PRESENT		(V4L2_CID_DV_CLASS_BASE + 3)
+#define V4L2_CID_DV_TX_MODE			(V4L2_CID_DV_CLASS_BASE + 4)
 enum v4l2_dv_tx_mode {
 	V4L2_DV_TX_MODE_DVI_D	= 0,
 	V4L2_DV_TX_MODE_HDMI	= 1,
@@ -1263,7 +1269,7 @@ enum v4l2_dv_it_content_type {
 	V4L2_DV_IT_CONTENT_TYPE_NO_ITC	  = 4,
 };
 
-#define	V4L2_CID_DV_RX_POWER_PRESENT		(V4L2_CID_DV_CLASS_BASE + 100)
+#define V4L2_CID_DV_RX_POWER_PRESENT		(V4L2_CID_DV_CLASS_BASE + 100)
 #define V4L2_CID_DV_RX_RGB_RANGE		(V4L2_CID_DV_CLASS_BASE + 101)
 #define V4L2_CID_DV_RX_IT_CONTENT_TYPE		(V4L2_CID_DV_CLASS_BASE + 102)
 
@@ -1533,15 +1539,6 @@ struct v4l2_ctrl_h264_pred_weights {
 	struct v4l2_h264_weight_factors weight_factors[2];
 };
 
-#define V4L2_H264_SLICE_TYPE_P				0
-#define V4L2_H264_SLICE_TYPE_B				1
-#define V4L2_H264_SLICE_TYPE_I				2
-#define V4L2_H264_SLICE_TYPE_SP				3
-#define V4L2_H264_SLICE_TYPE_SI				4
-
-#define V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED	0x01
-#define V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH		0x02
-
 #define V4L2_H264_TOP_FIELD_REF				0x1
 #define V4L2_H264_BOTTOM_FIELD_REF			0x2
 #define V4L2_H264_FRAME_REF				0x3
@@ -1562,8 +1559,17 @@ struct v4l2_h264_reference {
  * Maximum DPB size, as specified by section 'A.3.1 Level limits
  * common to the Baseline, Main, and Extended profiles'.
  */
-#define V4L2_H264_NUM_DPB_ENTRIES 16
-#define V4L2_H264_REF_LIST_LEN (2 * V4L2_H264_NUM_DPB_ENTRIES)
+#define V4L2_H264_NUM_DPB_ENTRIES		16
+#define V4L2_H264_REF_LIST_LEN			(2 * V4L2_H264_NUM_DPB_ENTRIES)
+
+#define V4L2_H264_SLICE_TYPE_P				0
+#define V4L2_H264_SLICE_TYPE_B				1
+#define V4L2_H264_SLICE_TYPE_I				2
+#define V4L2_H264_SLICE_TYPE_SP				3
+#define V4L2_H264_SLICE_TYPE_SI				4
+
+#define V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED		0x01
+#define V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH			0x02
 
 #define V4L2_CID_STATELESS_H264_SLICE_PARAMS	(V4L2_CID_CODEC_STATELESS_BASE + 6)
 /**
@@ -1703,7 +1709,6 @@ struct v4l2_ctrl_h264_decode_params {
 	__u32 flags;
 };
 
-
 /* Stateless FWHT control, used by the vicodec driver */
 
 /* Current FWHT version */
@@ -2545,44 +2550,10 @@ struct v4l2_ctrl_hevc_scaling_matrix {
 	__u8	scaling_list_dc_coef_32x32[2];
 };
 
-#define V4L2_CID_COLORIMETRY_CLASS_BASE	(V4L2_CTRL_CLASS_COLORIMETRY | 0x900)
-#define V4L2_CID_COLORIMETRY_CLASS	(V4L2_CTRL_CLASS_COLORIMETRY | 1)
-
-#define V4L2_CID_COLORIMETRY_HDR10_CLL_INFO	(V4L2_CID_COLORIMETRY_CLASS_BASE + 0)
-
-struct v4l2_ctrl_hdr10_cll_info {
-	__u16 max_content_light_level;
-	__u16 max_pic_average_light_level;
-};
-
-#define V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY	(V4L2_CID_COLORIMETRY_CLASS_BASE + 1)
-
-#define V4L2_HDR10_MASTERING_PRIMARIES_X_LOW	5
-#define V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH	37000
-#define V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW	5
-#define V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH	42000
-#define V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW	5
-#define V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH	37000
-#define V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW	5
-#define V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH	42000
-#define V4L2_HDR10_MASTERING_MAX_LUMA_LOW	50000
-#define V4L2_HDR10_MASTERING_MAX_LUMA_HIGH	100000000
-#define V4L2_HDR10_MASTERING_MIN_LUMA_LOW	1
-#define V4L2_HDR10_MASTERING_MIN_LUMA_HIGH	50000
-
-struct v4l2_ctrl_hdr10_mastering_display {
-	__u16 display_primaries_x[3];
-	__u16 display_primaries_y[3];
-	__u16 white_point_x;
-	__u16 white_point_y;
-	__u32 max_display_mastering_luminance;
-	__u32 min_display_mastering_luminance;
-};
-
 /* Stateless VP9 controls */
 
 #define V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED	0x1
-#define	V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE	0x2
+#define V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE	0x2
 
 /**
  * struct v4l2_vp9_loop_filter - VP9 loop filter parameters
@@ -3509,4 +3480,38 @@ struct v4l2_ctrl_av1_film_grain {
 #define V4L2_CID_MPEG_CX2341X_BASE      V4L2_CID_CODEC_CX2341X_BASE
 #define V4L2_CID_MPEG_MFC51_BASE        V4L2_CID_CODEC_MFC51_BASE
 
+#define V4L2_CID_COLORIMETRY_CLASS_BASE	(V4L2_CTRL_CLASS_COLORIMETRY | 0x900)
+#define V4L2_CID_COLORIMETRY_CLASS	(V4L2_CTRL_CLASS_COLORIMETRY | 1)
+
+#define V4L2_CID_COLORIMETRY_HDR10_CLL_INFO	(V4L2_CID_COLORIMETRY_CLASS_BASE + 0)
+
+struct v4l2_ctrl_hdr10_cll_info {
+	__u16 max_content_light_level;
+	__u16 max_pic_average_light_level;
+};
+
+#define V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY	(V4L2_CID_COLORIMETRY_CLASS_BASE + 1)
+
+#define V4L2_HDR10_MASTERING_PRIMARIES_X_LOW	5
+#define V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH	37000
+#define V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW	5
+#define V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH	42000
+#define V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW	5
+#define V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH	37000
+#define V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW	5
+#define V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH	42000
+#define V4L2_HDR10_MASTERING_MAX_LUMA_LOW	50000
+#define V4L2_HDR10_MASTERING_MAX_LUMA_HIGH	100000000
+#define V4L2_HDR10_MASTERING_MIN_LUMA_LOW	1
+#define V4L2_HDR10_MASTERING_MIN_LUMA_HIGH	50000
+
+struct v4l2_ctrl_hdr10_mastering_display {
+	__u16 display_primaries_x[3];
+	__u16 display_primaries_y[3];
+	__u16 white_point_x;
+	__u16 white_point_y;
+	__u32 max_display_mastering_luminance;
+	__u32 min_display_mastering_luminance;
+};
+
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/v4l2-dv-timings.h b/lib/libc/include/any-linux-any/linux/v4l2-dv-timings.h
index f14587888df3e21cd9959d665184ddf5ed81edcb..3791c25e5a2f4c17128c13e55891b0152038085f 100644
--- a/lib/libc/include/any-linux-any/linux/v4l2-dv-timings.h
+++ b/lib/libc/include/any-linux-any/linux/v4l2-dv-timings.h
@@ -2,7 +2,7 @@
 /*
  * V4L2 DV timings header.
  *
- * Copyright (C) 2012-2016  Hans Verkuil <hansverk@cisco.com>
+ * Copyright (C) 2012-2016  Hans Verkuil <hverkuil@kernel.org>
  */
 
 #ifndef _V4L2_DV_TIMINGS_H
diff --git a/lib/libc/include/any-linux-any/linux/version.h b/lib/libc/include/any-linux-any/linux/version.h
index c5e8c73f0611e9f0bd8f2cdf5a53e87b25625b98..4d81f6650cb2ee073cc4065a09ad2e658a9159e9 100644
--- a/lib/libc/include/any-linux-any/linux/version.h
+++ b/lib/libc/include/any-linux-any/linux/version.h
@@ -1,5 +1,5 @@
-#define LINUX_VERSION_CODE 397568
+#define LINUX_VERSION_CODE 398080
 #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + ((c) > 255 ? 255 : (c)))
 #define LINUX_VERSION_MAJOR 6
-#define LINUX_VERSION_PATCHLEVEL 17
+#define LINUX_VERSION_PATCHLEVEL 19
 #define LINUX_VERSION_SUBLEVEL 0
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/vfio.h b/lib/libc/include/any-linux-any/linux/vfio.h
index 817cd3bba6fb8dc85740e20c873fa364ec8e5af1..2fe756d15c747167af67a3f2bedd588e1b904a89 100644
--- a/lib/libc/include/any-linux-any/linux/vfio.h
+++ b/lib/libc/include/any-linux-any/linux/vfio.h
@@ -14,6 +14,7 @@
 
 #include <linux/types.h>
 #include <linux/ioctl.h>
+#include <linux/stddef.h>
 
 #define VFIO_API_VERSION	0
 
@@ -1478,6 +1479,33 @@ struct vfio_device_feature_bus_master {
 };
 #define VFIO_DEVICE_FEATURE_BUS_MASTER 10
 
+/**
+ * Upon VFIO_DEVICE_FEATURE_GET create a dma_buf fd for the
+ * regions selected.
+ *
+ * open_flags are the typical flags passed to open(2), eg O_RDWR, O_CLOEXEC,
+ * etc. offset/length specify a slice of the region to create the dmabuf from.
+ * nr_ranges is the total number of (P2P DMA) ranges that comprise the dmabuf.
+ *
+ * flags should be 0.
+ *
+ * Return: The fd number on success, -1 and errno is set on failure.
+ */
+#define VFIO_DEVICE_FEATURE_DMA_BUF 11
+
+struct vfio_region_dma_range {
+	__u64 offset;
+	__u64 length;
+};
+
+struct vfio_device_feature_dma_buf {
+	__u32	region_index;
+	__u32	open_flags;
+	__u32   flags;
+	__u32   nr_ranges;
+	struct vfio_region_dma_range dma_ranges[] __counted_by(nr_ranges);
+};
+
 /* -------- API for Type1 VFIO IOMMU -------- */
 
 /**
diff --git a/lib/libc/include/any-linux-any/linux/videodev2.h b/lib/libc/include/any-linux-any/linux/videodev2.h
index afc6ef2e225960bb06656a1115d1ad1bc2d756a1..a9bb91a56ce8a16501bd80bd524892a671c8656e 100644
--- a/lib/libc/include/any-linux-any/linux/videodev2.h
+++ b/lib/libc/include/any-linux-any/linux/videodev2.h
@@ -51,7 +51,7 @@
  *
  *	Author: Bill Dirks <bill@thedirks.org>
  *		Justin Schoeman
- *              Hans Verkuil <hverkuil@xs4all.nl>
+ *              Hans Verkuil <hverkuil@kernel.org>
  *		et al.
  */
 #ifndef __LINUX_VIDEODEV2_H
@@ -857,6 +857,10 @@ struct v4l2_pix_format {
 #define V4L2_META_FMT_RPI_FE_CFG	v4l2_fourcc('R', 'P', 'F', 'C') /* PiSP FE configuration */
 #define V4L2_META_FMT_RPI_FE_STATS	v4l2_fourcc('R', 'P', 'F', 'S') /* PiSP FE stats */
 
+/* Vendor specific - used for Arm Mali-C55 ISP */
+#define V4L2_META_FMT_MALI_C55_PARAMS	v4l2_fourcc('C', '5', '5', 'P') /* ARM Mali-C55 Parameters */
+#define V4L2_META_FMT_MALI_C55_STATS	v4l2_fourcc('C', '5', '5', 'S') /* ARM Mali-C55 3A Statistics */
+
 
 /* priv field value to indicates that subsequent fields are valid. */
 #define V4L2_PIX_FMT_PRIV_MAGIC		0xfeedcafe
@@ -1542,8 +1546,8 @@ struct v4l2_bt_timings {
 } __attribute__ ((packed));
 
 /* Interlaced or progressive format */
-#define	V4L2_DV_PROGRESSIVE	0
-#define	V4L2_DV_INTERLACED	1
+#define V4L2_DV_PROGRESSIVE	0
+#define V4L2_DV_INTERLACED	1
 
 /* Polarities. If bit is not set, it is assumed to be negative polarity */
 #define V4L2_DV_VSYNC_POS_POL	0x00000001
@@ -2715,15 +2719,15 @@ struct v4l2_remove_buffers {
  * Only implemented if CONFIG_VIDEO_ADV_DEBUG is defined.
  * You must be root to use these ioctls. Never use these in applications!
  */
-#define	VIDIOC_DBG_S_REGISTER	 _IOW('V', 79, struct v4l2_dbg_register)
-#define	VIDIOC_DBG_G_REGISTER	_IOWR('V', 80, struct v4l2_dbg_register)
+#define VIDIOC_DBG_S_REGISTER	 _IOW('V', 79, struct v4l2_dbg_register)
+#define VIDIOC_DBG_G_REGISTER	_IOWR('V', 80, struct v4l2_dbg_register)
 
 #define VIDIOC_S_HW_FREQ_SEEK	 _IOW('V', 82, struct v4l2_hw_freq_seek)
-#define	VIDIOC_S_DV_TIMINGS	_IOWR('V', 87, struct v4l2_dv_timings)
-#define	VIDIOC_G_DV_TIMINGS	_IOWR('V', 88, struct v4l2_dv_timings)
-#define	VIDIOC_DQEVENT		 _IOR('V', 89, struct v4l2_event)
-#define	VIDIOC_SUBSCRIBE_EVENT	 _IOW('V', 90, struct v4l2_event_subscription)
-#define	VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
+#define VIDIOC_S_DV_TIMINGS	_IOWR('V', 87, struct v4l2_dv_timings)
+#define VIDIOC_G_DV_TIMINGS	_IOWR('V', 88, struct v4l2_dv_timings)
+#define VIDIOC_DQEVENT		 _IOR('V', 89, struct v4l2_event)
+#define VIDIOC_SUBSCRIBE_EVENT	 _IOW('V', 90, struct v4l2_event_subscription)
+#define VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
 #define VIDIOC_CREATE_BUFS	_IOWR('V', 92, struct v4l2_create_buffers)
 #define VIDIOC_PREPARE_BUF	_IOWR('V', 93, struct v4l2_buffer)
 #define VIDIOC_G_SELECTION	_IOWR('V', 94, struct v4l2_selection)
diff --git a/lib/libc/include/any-linux-any/linux/virtio_ids.h b/lib/libc/include/any-linux-any/linux/virtio_ids.h
index c3e777be20d4635dc8ee61d1d188ec606b75fc57..56a254e95532979e9e2e939170841f7edf1e4df3 100644
--- a/lib/libc/include/any-linux-any/linux/virtio_ids.h
+++ b/lib/libc/include/any-linux-any/linux/virtio_ids.h
@@ -68,6 +68,7 @@
 #define VIRTIO_ID_AUDIO_POLICY		39 /* virtio audio policy */
 #define VIRTIO_ID_BT			40 /* virtio bluetooth */
 #define VIRTIO_ID_GPIO			41 /* virtio gpio */
+#define VIRTIO_ID_SPI			45 /* virtio spi */
 
 /*
  * Virtio Transitional IDs
diff --git a/lib/libc/include/any-linux-any/linux/virtio_net.h b/lib/libc/include/any-linux-any/linux/virtio_net.h
index d20bf32f8bedca43c23fbf0de9a7c55cdd6e0efe..b9a134a3b8e33777aaab72b8547860007be4a828 100644
--- a/lib/libc/include/any-linux-any/linux/virtio_net.h
+++ b/lib/libc/include/any-linux-any/linux/virtio_net.h
@@ -193,7 +193,8 @@ struct virtio_net_hdr_v1 {
 
 struct virtio_net_hdr_v1_hash {
 	struct virtio_net_hdr_v1 hdr;
-	__le32 hash_value;
+	__le16 hash_value_lo;
+	__le16 hash_value_hi;
 #define VIRTIO_NET_HASH_REPORT_NONE            0
 #define VIRTIO_NET_HASH_REPORT_IPv4            1
 #define VIRTIO_NET_HASH_REPORT_TCPv4           2
diff --git a/lib/libc/include/any-linux-any/linux/virtio_pci.h b/lib/libc/include/any-linux-any/linux/virtio_pci.h
index c94b33dd58c639ab9aaa28acfacff568cc17a584..0ea45985e25121a353f12115494cec9bb3162e26 100644
--- a/lib/libc/include/any-linux-any/linux/virtio_pci.h
+++ b/lib/libc/include/any-linux-any/linux/virtio_pci.h
@@ -40,7 +40,7 @@
 #define _LINUX_VIRTIO_PCI_H
 
 #include <linux/types.h>
-#include <linux/kernel.h>
+#include <linux/const.h>
 
 #ifndef VIRTIO_PCI_NO_LEGACY
 
diff --git a/lib/libc/include/any-linux-any/linux/virtio_spi.h b/lib/libc/include/any-linux-any/linux/virtio_spi.h
new file mode 100644
index 0000000000000000000000000000000000000000..878c47d147472c92a5590588699a6ed3aef06d1f
--- /dev/null
+++ b/lib/libc/include/any-linux-any/linux/virtio_spi.h
@@ -0,0 +1,181 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (C) 2023 OpenSynergy GmbH
+ * Copyright (C) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+#ifndef _LINUX_VIRTIO_VIRTIO_SPI_H
+#define _LINUX_VIRTIO_VIRTIO_SPI_H
+
+#include <linux/types.h>
+#include <linux/virtio_config.h>
+#include <linux/virtio_ids.h>
+#include <linux/virtio_types.h>
+
+/* Sample data on trailing clock edge */
+#define VIRTIO_SPI_CPHA			_BITUL(0)
+/* Clock is high when IDLE */
+#define VIRTIO_SPI_CPOL			_BITUL(1)
+/* Chip Select is active high */
+#define VIRTIO_SPI_CS_HIGH			_BITUL(2)
+/* Transmit LSB first */
+#define VIRTIO_SPI_MODE_LSB_FIRST		_BITUL(3)
+/* Loopback mode */
+#define VIRTIO_SPI_MODE_LOOP			_BITUL(4)
+
+/**
+ * struct virtio_spi_config - All config fields are read-only for the
+ * Virtio SPI driver
+ * @cs_max_number: maximum number of chipselect the host SPI controller
+ *   supports.
+ * @cs_change_supported: indicates if the host SPI controller supports to toggle
+ *   chipselect after each transfer in one message:
+ *   0: unsupported, chipselect will be kept in active state throughout the
+ *      message transaction;
+ *   1: supported.
+ *   Note: Message here contains a sequence of SPI transfers.
+ * @tx_nbits_supported: indicates the supported number of bit for writing:
+ *   bit 0: DUAL (2-bit transfer), 1 for supported
+ *   bit 1: QUAD (4-bit transfer), 1 for supported
+ *   bit 2: OCTAL (8-bit transfer), 1 for supported
+ *   other bits are reserved as 0, 1-bit transfer is always supported.
+ * @rx_nbits_supported: indicates the supported number of bit for reading:
+ *   bit 0: DUAL (2-bit transfer), 1 for supported
+ *   bit 1: QUAD (4-bit transfer), 1 for supported
+ *   bit 2: OCTAL (8-bit transfer), 1 for supported
+ *   other bits are reserved as 0, 1-bit transfer is always supported.
+ * @bits_per_word_mask: mask indicating which values of bits_per_word are
+ *   supported. If not set, no limitation for bits_per_word.
+ * @mode_func_supported: indicates the following features are supported or not:
+ *   bit 0-1: CPHA feature
+ *     0b00: invalid, should support as least one CPHA setting
+ *     0b01: supports CPHA=0 only
+ *     0b10: supports CPHA=1 only
+ *     0b11: supports CPHA=0 and CPHA=1.
+ *   bit 2-3: CPOL feature
+ *     0b00: invalid, should support as least one CPOL setting
+ *     0b01: supports CPOL=0 only
+ *     0b10: supports CPOL=1 only
+ *     0b11: supports CPOL=0 and CPOL=1.
+ *   bit 4: chipselect active high feature, 0 for unsupported and 1 for
+ *     supported, chipselect active low is supported by default.
+ *   bit 5: LSB first feature, 0 for unsupported and 1 for supported,
+ *     MSB first is supported by default.
+ *   bit 6: loopback mode feature, 0 for unsupported and 1 for supported,
+ *     normal mode is supported by default.
+ * @max_freq_hz: the maximum clock rate supported in Hz unit, 0 means no
+ *   limitation for transfer speed.
+ * @max_word_delay_ns: the maximum word delay supported, in nanoseconds.
+ *   A value of 0 indicates that word delay is unsupported.
+ *   Each transfer may consist of a sequence of words.
+ * @max_cs_setup_ns: the maximum delay supported after chipselect is asserted,
+ *   in ns unit, 0 means delay is not supported to introduce after chipselect is
+ *   asserted.
+ * @max_cs_hold_ns: the maximum delay supported before chipselect is deasserted,
+ *   in ns unit, 0 means delay is not supported to introduce before chipselect
+ *   is deasserted.
+ * @max_cs_incative_ns: maximum delay supported after chipselect is deasserted,
+ *   in ns unit, 0 means delay is not supported to introduce after chipselect is
+ *   deasserted.
+ */
+struct virtio_spi_config {
+	__u8 cs_max_number;
+	__u8 cs_change_supported;
+#define VIRTIO_SPI_RX_TX_SUPPORT_DUAL		_BITUL(0)
+#define VIRTIO_SPI_RX_TX_SUPPORT_QUAD		_BITUL(1)
+#define VIRTIO_SPI_RX_TX_SUPPORT_OCTAL		_BITUL(2)
+	__u8 tx_nbits_supported;
+	__u8 rx_nbits_supported;
+	__le32 bits_per_word_mask;
+#define VIRTIO_SPI_MF_SUPPORT_CPHA_0		_BITUL(0)
+#define VIRTIO_SPI_MF_SUPPORT_CPHA_1		_BITUL(1)
+#define VIRTIO_SPI_MF_SUPPORT_CPOL_0		_BITUL(2)
+#define VIRTIO_SPI_MF_SUPPORT_CPOL_1		_BITUL(3)
+#define VIRTIO_SPI_MF_SUPPORT_CS_HIGH		_BITUL(4)
+#define VIRTIO_SPI_MF_SUPPORT_LSB_FIRST		_BITUL(5)
+#define VIRTIO_SPI_MF_SUPPORT_LOOPBACK		_BITUL(6)
+	__le32 mode_func_supported;
+	__le32 max_freq_hz;
+	__le32 max_word_delay_ns;
+	__le32 max_cs_setup_ns;
+	__le32 max_cs_hold_ns;
+	__le32 max_cs_inactive_ns;
+};
+
+/**
+ * struct spi_transfer_head - virtio SPI transfer descriptor
+ * @chip_select_id: chipselect index the SPI transfer used.
+ * @bits_per_word: the number of bits in each SPI transfer word.
+ * @cs_change: whether to deselect device after finishing this transfer
+ *     before starting the next transfer, 0 means cs keep asserted and
+ *     1 means cs deasserted then asserted again.
+ * @tx_nbits: bus width for write transfer.
+ *     0,1: bus width is 1, also known as SINGLE
+ *     2  : bus width is 2, also known as DUAL
+ *     4  : bus width is 4, also known as QUAD
+ *     8  : bus width is 8, also known as OCTAL
+ *     other values are invalid.
+ * @rx_nbits: bus width for read transfer.
+ *     0,1: bus width is 1, also known as SINGLE
+ *     2  : bus width is 2, also known as DUAL
+ *     4  : bus width is 4, also known as QUAD
+ *     8  : bus width is 8, also known as OCTAL
+ *     other values are invalid.
+ * @reserved: for future use.
+ * @mode: SPI transfer mode.
+ *     bit 0: CPHA, determines the timing (i.e. phase) of the data
+ *         bits relative to the clock pulses.For CPHA=0, the
+ *         "out" side changes the data on the trailing edge of the
+ *         preceding clock cycle, while the "in" side captures the data
+ *         on (or shortly after) the leading edge of the clock cycle.
+ *         For CPHA=1, the "out" side changes the data on the leading
+ *         edge of the current clock cycle, while the "in" side
+ *         captures the data on (or shortly after) the trailing edge of
+ *         the clock cycle.
+ *     bit 1: CPOL, determines the polarity of the clock. CPOL=0 is a
+ *         clock which idles at 0, and each cycle consists of a pulse
+ *         of 1. CPOL=1 is a clock which idles at 1, and each cycle
+ *         consists of a pulse of 0.
+ *     bit 2: CS_HIGH, if 1, chip select active high, else active low.
+ *     bit 3: LSB_FIRST, determines per-word bits-on-wire, if 0, MSB
+ *         first, else LSB first.
+ *     bit 4: LOOP, loopback mode.
+ * @freq: the transfer speed in Hz.
+ * @word_delay_ns: delay to be inserted between consecutive words of a
+ *     transfer, in ns unit.
+ * @cs_setup_ns: delay to be introduced after CS is asserted, in ns
+ *     unit.
+ * @cs_delay_hold_ns: delay to be introduced before CS is deasserted
+ *     for each transfer, in ns unit.
+ * @cs_change_delay_inactive_ns: delay to be introduced after CS is
+ *     deasserted and before next asserted, in ns unit.
+ */
+struct spi_transfer_head {
+	__u8 chip_select_id;
+	__u8 bits_per_word;
+	__u8 cs_change;
+	__u8 tx_nbits;
+	__u8 rx_nbits;
+	__u8 reserved[3];
+	__le32 mode;
+	__le32 freq;
+	__le32 word_delay_ns;
+	__le32 cs_setup_ns;
+	__le32 cs_delay_hold_ns;
+	__le32 cs_change_delay_inactive_ns;
+};
+
+/**
+ * struct spi_transfer_result - virtio SPI transfer result
+ * @result: Transfer result code.
+ *          VIRTIO_SPI_TRANS_OK: Transfer successful.
+ *          VIRTIO_SPI_PARAM_ERR: Parameter error.
+ *          VIRTIO_SPI_TRANS_ERR: Transfer error.
+ */
+struct spi_transfer_result {
+#define VIRTIO_SPI_TRANS_OK	0
+#define VIRTIO_SPI_PARAM_ERR	1
+#define VIRTIO_SPI_TRANS_ERR	2
+	__u8 result;
+};
+
+#endif /* #ifndef _LINUX_VIRTIO_VIRTIO_SPI_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/vmcore.h b/lib/libc/include/any-linux-any/linux/vmcore.h
index c054379fafadfc075f4ebf596915734a87b8a038..8806b3211b15adb2b303c033a54d873bd74bc14e 100644
--- a/lib/libc/include/any-linux-any/linux/vmcore.h
+++ b/lib/libc/include/any-linux-any/linux/vmcore.h
@@ -15,4 +15,13 @@ struct vmcoredd_header {
 	__u8 dump_name[VMCOREDD_MAX_NAME_BYTES]; /* Device dump's name */
 };
 
+enum hwerr_error_type {
+	HWERR_RECOV_CPU,
+	HWERR_RECOV_MEMORY,
+	HWERR_RECOV_PCI,
+	HWERR_RECOV_CXL,
+	HWERR_RECOV_OTHERS,
+	HWERR_RECOV_MAX,
+};
+
 #endif /* _VMCORE_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/linux/wireguard.h b/lib/libc/include/any-linux-any/linux/wireguard.h
index 1a7c3ec481931428772947b73aac232dafd86f27..679808267fc87603a12ee8d03361965175a7e918 100644
--- a/lib/libc/include/any-linux-any/linux/wireguard.h
+++ b/lib/libc/include/any-linux-any/linux/wireguard.h
@@ -1,156 +1,31 @@
-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR MIT */
-/*
- * Copyright (C) 2015-2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
- *
- * Documentation
- * =============
- *
- * The below enums and macros are for interfacing with WireGuard, using generic
- * netlink, with family WG_GENL_NAME and version WG_GENL_VERSION. It defines two
- * methods: get and set. Note that while they share many common attributes,
- * these two functions actually accept a slightly different set of inputs and
- * outputs.
- *
- * WG_CMD_GET_DEVICE
- * -----------------
- *
- * May only be called via NLM_F_REQUEST | NLM_F_DUMP. The command should contain
- * one but not both of:
- *
- *    WGDEVICE_A_IFINDEX: NLA_U32
- *    WGDEVICE_A_IFNAME: NLA_NUL_STRING, maxlen IFNAMSIZ - 1
- *
- * The kernel will then return several messages (NLM_F_MULTI) containing the
- * following tree of nested items:
- *
- *    WGDEVICE_A_IFINDEX: NLA_U32
- *    WGDEVICE_A_IFNAME: NLA_NUL_STRING, maxlen IFNAMSIZ - 1
- *    WGDEVICE_A_PRIVATE_KEY: NLA_EXACT_LEN, len WG_KEY_LEN
- *    WGDEVICE_A_PUBLIC_KEY: NLA_EXACT_LEN, len WG_KEY_LEN
- *    WGDEVICE_A_LISTEN_PORT: NLA_U16
- *    WGDEVICE_A_FWMARK: NLA_U32
- *    WGDEVICE_A_PEERS: NLA_NESTED
- *        0: NLA_NESTED
- *            WGPEER_A_PUBLIC_KEY: NLA_EXACT_LEN, len WG_KEY_LEN
- *            WGPEER_A_PRESHARED_KEY: NLA_EXACT_LEN, len WG_KEY_LEN
- *            WGPEER_A_ENDPOINT: NLA_MIN_LEN(struct sockaddr), struct sockaddr_in or struct sockaddr_in6
- *            WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL: NLA_U16
- *            WGPEER_A_LAST_HANDSHAKE_TIME: NLA_EXACT_LEN, struct __kernel_timespec
- *            WGPEER_A_RX_BYTES: NLA_U64
- *            WGPEER_A_TX_BYTES: NLA_U64
- *            WGPEER_A_ALLOWEDIPS: NLA_NESTED
- *                0: NLA_NESTED
- *                    WGALLOWEDIP_A_FAMILY: NLA_U16
- *                    WGALLOWEDIP_A_IPADDR: NLA_MIN_LEN(struct in_addr), struct in_addr or struct in6_addr
- *                    WGALLOWEDIP_A_CIDR_MASK: NLA_U8
- *                0: NLA_NESTED
- *                    ...
- *                0: NLA_NESTED
- *                    ...
- *                ...
- *            WGPEER_A_PROTOCOL_VERSION: NLA_U32
- *        0: NLA_NESTED
- *            ...
- *        ...
- *
- * It is possible that all of the allowed IPs of a single peer will not
- * fit within a single netlink message. In that case, the same peer will
- * be written in the following message, except it will only contain
- * WGPEER_A_PUBLIC_KEY and WGPEER_A_ALLOWEDIPS. This may occur several
- * times in a row for the same peer. It is then up to the receiver to
- * coalesce adjacent peers. Likewise, it is possible that all peers will
- * not fit within a single message. So, subsequent peers will be sent
- * in following messages, except those will only contain WGDEVICE_A_IFNAME
- * and WGDEVICE_A_PEERS. It is then up to the receiver to coalesce these
- * messages to form the complete list of peers.
- *
- * Since this is an NLA_F_DUMP command, the final message will always be
- * NLMSG_DONE, even if an error occurs. However, this NLMSG_DONE message
- * contains an integer error code. It is either zero or a negative error
- * code corresponding to the errno.
- *
- * WG_CMD_SET_DEVICE
- * -----------------
- *
- * May only be called via NLM_F_REQUEST. The command should contain the
- * following tree of nested items, containing one but not both of
- * WGDEVICE_A_IFINDEX and WGDEVICE_A_IFNAME:
- *
- *    WGDEVICE_A_IFINDEX: NLA_U32
- *    WGDEVICE_A_IFNAME: NLA_NUL_STRING, maxlen IFNAMSIZ - 1
- *    WGDEVICE_A_FLAGS: NLA_U32, 0 or WGDEVICE_F_REPLACE_PEERS if all current
- *                      peers should be removed prior to adding the list below.
- *    WGDEVICE_A_PRIVATE_KEY: len WG_KEY_LEN, all zeros to remove
- *    WGDEVICE_A_LISTEN_PORT: NLA_U16, 0 to choose randomly
- *    WGDEVICE_A_FWMARK: NLA_U32, 0 to disable
- *    WGDEVICE_A_PEERS: NLA_NESTED
- *        0: NLA_NESTED
- *            WGPEER_A_PUBLIC_KEY: len WG_KEY_LEN
- *            WGPEER_A_FLAGS: NLA_U32, 0 and/or WGPEER_F_REMOVE_ME if the
- *                            specified peer should not exist at the end of the
- *                            operation, rather than added/updated and/or
- *                            WGPEER_F_REPLACE_ALLOWEDIPS if all current allowed
- *                            IPs of this peer should be removed prior to adding
- *                            the list below and/or WGPEER_F_UPDATE_ONLY if the
- *                            peer should only be set if it already exists.
- *            WGPEER_A_PRESHARED_KEY: len WG_KEY_LEN, all zeros to remove
- *            WGPEER_A_ENDPOINT: struct sockaddr_in or struct sockaddr_in6
- *            WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL: NLA_U16, 0 to disable
- *            WGPEER_A_ALLOWEDIPS: NLA_NESTED
- *                0: NLA_NESTED
- *                    WGALLOWEDIP_A_FAMILY: NLA_U16
- *                    WGALLOWEDIP_A_IPADDR: struct in_addr or struct in6_addr
- *                    WGALLOWEDIP_A_CIDR_MASK: NLA_U8
- *                    WGALLOWEDIP_A_FLAGS: NLA_U32, WGALLOWEDIP_F_REMOVE_ME if
- *                                         the specified IP should be removed;
- *                                         otherwise, this IP will be added if
- *                                         it is not already present.
- *                0: NLA_NESTED
- *                    ...
- *                0: NLA_NESTED
- *                    ...
- *                ...
- *            WGPEER_A_PROTOCOL_VERSION: NLA_U32, should not be set or used at
- *                                       all by most users of this API, as the
- *                                       most recent protocol will be used when
- *                                       this is unset. Otherwise, must be set
- *                                       to 1.
- *        0: NLA_NESTED
- *            ...
- *        ...
- *
- * It is possible that the amount of configuration data exceeds that of
- * the maximum message length accepted by the kernel. In that case, several
- * messages should be sent one after another, with each successive one
- * filling in information not contained in the prior. Note that if
- * WGDEVICE_F_REPLACE_PEERS is specified in the first message, it probably
- * should not be specified in fragments that come after, so that the list
- * of peers is only cleared the first time but appended after. Likewise for
- * peers, if WGPEER_F_REPLACE_ALLOWEDIPS is specified in the first message
- * of a peer, it likely should not be specified in subsequent fragments.
- *
- * If an error occurs, NLMSG_ERROR will reply containing an errno.
- */
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/* Do not edit directly, auto-generated from: */
+/*	Documentation/netlink/specs/wireguard.yaml */
+/* YNL-GEN uapi header */
+/* To regenerate run: tools/net/ynl/ynl-regen.sh */
 
-#ifndef _WG_UAPI_WIREGUARD_H
-#define _WG_UAPI_WIREGUARD_H
+#ifndef _LINUX_WIREGUARD_H
+#define _LINUX_WIREGUARD_H
 
-#define WG_GENL_NAME "wireguard"
-#define WG_GENL_VERSION 1
+#define WG_GENL_NAME	"wireguard"
+#define WG_GENL_VERSION	1
 
-#define WG_KEY_LEN 32
-
-enum wg_cmd {
-	WG_CMD_GET_DEVICE,
-	WG_CMD_SET_DEVICE,
-	__WG_CMD_MAX
-};
-#define WG_CMD_MAX (__WG_CMD_MAX - 1)
+#define WG_KEY_LEN	32
 
 enum wgdevice_flag {
-	WGDEVICE_F_REPLACE_PEERS = 1U << 0,
-	__WGDEVICE_F_ALL = WGDEVICE_F_REPLACE_PEERS
+	WGDEVICE_F_REPLACE_PEERS = 1,
 };
+
+enum wgpeer_flag {
+	WGPEER_F_REMOVE_ME = 1,
+	WGPEER_F_REPLACE_ALLOWEDIPS = 2,
+	WGPEER_F_UPDATE_ONLY = 4,
+};
+
+enum wgallowedip_flag {
+	WGALLOWEDIP_F_REMOVE_ME = 1,
+};
+
 enum wgdevice_attribute {
 	WGDEVICE_A_UNSPEC,
 	WGDEVICE_A_IFINDEX,
@@ -161,17 +36,11 @@ enum wgdevice_attribute {
 	WGDEVICE_A_LISTEN_PORT,
 	WGDEVICE_A_FWMARK,
 	WGDEVICE_A_PEERS,
+
 	__WGDEVICE_A_LAST
 };
 #define WGDEVICE_A_MAX (__WGDEVICE_A_LAST - 1)
 
-enum wgpeer_flag {
-	WGPEER_F_REMOVE_ME = 1U << 0,
-	WGPEER_F_REPLACE_ALLOWEDIPS = 1U << 1,
-	WGPEER_F_UPDATE_ONLY = 1U << 2,
-	__WGPEER_F_ALL = WGPEER_F_REMOVE_ME | WGPEER_F_REPLACE_ALLOWEDIPS |
-			 WGPEER_F_UPDATE_ONLY
-};
 enum wgpeer_attribute {
 	WGPEER_A_UNSPEC,
 	WGPEER_A_PUBLIC_KEY,
@@ -184,22 +53,28 @@ enum wgpeer_attribute {
 	WGPEER_A_TX_BYTES,
 	WGPEER_A_ALLOWEDIPS,
 	WGPEER_A_PROTOCOL_VERSION,
+
 	__WGPEER_A_LAST
 };
 #define WGPEER_A_MAX (__WGPEER_A_LAST - 1)
 
-enum wgallowedip_flag {
-	WGALLOWEDIP_F_REMOVE_ME = 1U << 0,
-	__WGALLOWEDIP_F_ALL = WGALLOWEDIP_F_REMOVE_ME
-};
 enum wgallowedip_attribute {
 	WGALLOWEDIP_A_UNSPEC,
 	WGALLOWEDIP_A_FAMILY,
 	WGALLOWEDIP_A_IPADDR,
 	WGALLOWEDIP_A_CIDR_MASK,
 	WGALLOWEDIP_A_FLAGS,
+
 	__WGALLOWEDIP_A_LAST
 };
 #define WGALLOWEDIP_A_MAX (__WGALLOWEDIP_A_LAST - 1)
 
-#endif /* _WG_UAPI_WIREGUARD_H */
\ No newline at end of file
+enum wg_cmd {
+	WG_CMD_GET_DEVICE,
+	WG_CMD_SET_DEVICE,
+
+	__WG_CMD_MAX
+};
+#define WG_CMD_MAX (__WG_CMD_MAX - 1)
+
+#endif /* _LINUX_WIREGUARD_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/misc/fastrpc.h b/lib/libc/include/any-linux-any/misc/fastrpc.h
index f2a35db7cc2268c67aa94841114e1a3b6fe2cb11..6f59b5d1265f95c95c34679c1d09e5322b1f2e5d 100644
--- a/lib/libc/include/any-linux-any/misc/fastrpc.h
+++ b/lib/libc/include/any-linux-any/misc/fastrpc.h
@@ -134,7 +134,7 @@ struct fastrpc_mem_unmap {
 };
 
 struct fastrpc_ioctl_capability {
-	__u32 domain;
+	__u32 unused; /* deprecated, ignored by the kernel */
 	__u32 attribute_id;
 	__u32 capability;   /* dsp capability */
 	__u32 reserved[4];
diff --git a/lib/libc/include/any-linux-any/misc/uacce/hisi_qm.h b/lib/libc/include/any-linux-any/misc/uacce/hisi_qm.h
index 3f89cd15286826d37dca7e7e0e86178bc7a80938..1b774e03ac4741982115eabad62a16945e57c066 100644
--- a/lib/libc/include/any-linux-any/misc/uacce/hisi_qm.h
+++ b/lib/libc/include/any-linux-any/misc/uacce/hisi_qm.h
@@ -31,6 +31,7 @@ struct hisi_qp_info {
 #define HISI_QM_API_VER_BASE "hisi_qm_v1"
 #define HISI_QM_API_VER2_BASE "hisi_qm_v2"
 #define HISI_QM_API_VER3_BASE "hisi_qm_v3"
+#define HISI_QM_API_VER5_BASE "hisi_qm_v5"
 
 /* UACCE_CMD_QM_SET_QP_CTX: Set qp algorithm type */
 #define UACCE_CMD_QM_SET_QP_CTX	_IOWR('H', 10, struct hisi_qp_ctx)
diff --git a/lib/libc/include/any-linux-any/rdma/ib_user_ioctl_verbs.h b/lib/libc/include/any-linux-any/rdma/ib_user_ioctl_verbs.h
index 0eb7bf77a1b30cfb7285262f8d752f267b0aa1f8..087df334051c1fd445ef1db9e4fc0f454d1f0158 100644
--- a/lib/libc/include/any-linux-any/rdma/ib_user_ioctl_verbs.h
+++ b/lib/libc/include/any-linux-any/rdma/ib_user_ioctl_verbs.h
@@ -255,6 +255,7 @@ enum rdma_driver_id {
 	RDMA_DRIVER_SIW,
 	RDMA_DRIVER_ERDMA,
 	RDMA_DRIVER_MANA,
+	RDMA_DRIVER_IONIC,
 };
 
 enum ib_uverbs_gid_type {
diff --git a/lib/libc/include/any-linux-any/rdma/ib_user_sa.h b/lib/libc/include/any-linux-any/rdma/ib_user_sa.h
index 1017cb10f725e34c0a9c772619fc1548b31b612a..a2038c59f85aa621d82cb18f1070f5fe565cff4d 100644
--- a/lib/libc/include/any-linux-any/rdma/ib_user_sa.h
+++ b/lib/libc/include/any-linux-any/rdma/ib_user_sa.h
@@ -74,4 +74,18 @@ struct ib_user_path_rec {
 	__u8	preference;
 };
 
+struct ib_user_service_rec {
+	__be64	id;
+	__u8	gid[16];
+	__be16	pkey;
+	__u8	reserved[2];
+	__be32	lease;
+	__u8	key[16];
+	__u8	name[64];
+	__u8	data_8[16];
+	__be16	data_16[8];
+	__be32	data_32[4];
+	__be64	data_64[2];
+};
+
 #endif /* IB_USER_SA_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/rdma/ionic-abi.h b/lib/libc/include/any-linux-any/rdma/ionic-abi.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e95282d894ca66c676222670cec7c3f93e8bd80
--- /dev/null
+++ b/lib/libc/include/any-linux-any/rdma/ionic-abi.h
@@ -0,0 +1,115 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/* Copyright (C) 2018-2025, Advanced Micro Devices, Inc */
+
+#ifndef IONIC_ABI_H
+#define IONIC_ABI_H
+
+#include <linux/types.h>
+
+#define IONIC_ABI_VERSION	1
+
+#define IONIC_EXPDB_64		1
+#define IONIC_EXPDB_128		2
+#define IONIC_EXPDB_256		4
+#define IONIC_EXPDB_512		8
+
+#define IONIC_EXPDB_SQ		1
+#define IONIC_EXPDB_RQ		2
+
+#define IONIC_CMB_ENABLE	1
+#define IONIC_CMB_REQUIRE	2
+#define IONIC_CMB_EXPDB		4
+#define IONIC_CMB_WC		8
+#define IONIC_CMB_UC		16
+
+struct ionic_ctx_req {
+	__u32 rsvd[2];
+};
+
+struct ionic_ctx_resp {
+	__u32 rsvd;
+	__u32 page_shift;
+
+	__aligned_u64 dbell_offset;
+
+	__u16 version;
+	__u8 qp_opcodes;
+	__u8 admin_opcodes;
+
+	__u8 sq_qtype;
+	__u8 rq_qtype;
+	__u8 cq_qtype;
+	__u8 admin_qtype;
+
+	__u8 max_stride;
+	__u8 max_spec;
+	__u8 udma_count;
+	__u8 expdb_mask;
+	__u8 expdb_qtypes;
+
+	__u8 rsvd2[3];
+};
+
+struct ionic_qdesc {
+	__aligned_u64 addr;
+	__u32 size;
+	__u16 mask;
+	__u8 depth_log2;
+	__u8 stride_log2;
+};
+
+struct ionic_ah_resp {
+	__u32 ahid;
+	__u32 pad;
+};
+
+struct ionic_cq_req {
+	struct ionic_qdesc cq[2];
+	__u8 udma_mask;
+	__u8 rsvd[7];
+};
+
+struct ionic_cq_resp {
+	__u32 cqid[2];
+	__u8 udma_mask;
+	__u8 rsvd[7];
+};
+
+struct ionic_qp_req {
+	struct ionic_qdesc sq;
+	struct ionic_qdesc rq;
+	__u8 sq_spec;
+	__u8 rq_spec;
+	__u8 sq_cmb;
+	__u8 rq_cmb;
+	__u8 udma_mask;
+	__u8 rsvd[3];
+};
+
+struct ionic_qp_resp {
+	__u32 qpid;
+	__u8 sq_cmb;
+	__u8 rq_cmb;
+	__u8 udma_idx;
+	__u8 rsvd[1];
+	__aligned_u64 sq_cmb_offset;
+	__aligned_u64 rq_cmb_offset;
+};
+
+struct ionic_srq_req {
+	struct ionic_qdesc rq;
+	__u8 rq_spec;
+	__u8 rq_cmb;
+	__u8 udma_mask;
+	__u8 rsvd[5];
+};
+
+struct ionic_srq_resp {
+	__u32 qpid;
+	__u8 rq_cmb;
+	__u8 udma_idx;
+	__u8 rsvd[2];
+	__aligned_u64 rq_cmb_offset;
+};
+
+#endif /* IONIC_ABI_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/rdma/irdma-abi.h b/lib/libc/include/any-linux-any/rdma/irdma-abi.h
index f4d8f0703e87d7637e95c386110fad8e204d046b..4fed730222dbce773260c2aa23b99f5cda2afa6f 100644
--- a/lib/libc/include/any-linux-any/rdma/irdma-abi.h
+++ b/lib/libc/include/any-linux-any/rdma/irdma-abi.h
@@ -20,11 +20,14 @@ enum irdma_memreg_type {
 	IRDMA_MEMREG_TYPE_MEM  = 0,
 	IRDMA_MEMREG_TYPE_QP   = 1,
 	IRDMA_MEMREG_TYPE_CQ   = 2,
+	IRDMA_MEMREG_TYPE_SRQ  = 3,
 };
 
 enum {
 	IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0,
 	IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1,
+	IRDMA_ALLOC_UCTX_MAX_HW_SRQ_QUANTA = 1 << 2,
+	IRDMA_SUPPORT_WQE_FORMAT_V2 = 1 << 3,
 };
 
 struct irdma_alloc_ucontext_req {
@@ -54,7 +57,8 @@ struct irdma_alloc_ucontext_resp {
 	__u8 rsvd2;
 	__aligned_u64 comp_mask;
 	__u16 min_hw_wq_size;
-	__u8 rsvd3[6];
+	__u8 revd3[2];
+	__u32 max_hw_srq_quanta;
 };
 
 struct irdma_alloc_pd_resp {
@@ -71,6 +75,16 @@ struct irdma_create_cq_req {
 	__aligned_u64 user_shadow_area;
 };
 
+struct irdma_create_srq_req {
+	__aligned_u64 user_srq_buf;
+	__aligned_u64 user_shadow_area;
+};
+
+struct irdma_create_srq_resp {
+	__u32 srq_id;
+	__u32 srq_size;
+};
+
 struct irdma_create_qp_req {
 	__aligned_u64 user_wqe_bufs;
 	__aligned_u64 user_compl_ctx;
diff --git a/lib/libc/include/any-linux-any/rdma/rdma_user_cm.h b/lib/libc/include/any-linux-any/rdma/rdma_user_cm.h
index 3fbf696a34c4dfd07388dec0b4cc8bb637e39be6..2d3b7c4f2ec4a3f6e11ad5a902adc605709a2d8c 100644
--- a/lib/libc/include/any-linux-any/rdma/rdma_user_cm.h
+++ b/lib/libc/include/any-linux-any/rdma/rdma_user_cm.h
@@ -67,7 +67,9 @@ enum {
 	RDMA_USER_CM_CMD_QUERY,
 	RDMA_USER_CM_CMD_BIND,
 	RDMA_USER_CM_CMD_RESOLVE_ADDR,
-	RDMA_USER_CM_CMD_JOIN_MCAST
+	RDMA_USER_CM_CMD_JOIN_MCAST,
+	RDMA_USER_CM_CMD_RESOLVE_IB_SERVICE,
+	RDMA_USER_CM_CMD_WRITE_CM_EVENT,
 };
 
 /* See IBTA Annex A11, servies ID bytes 4 & 5 */
@@ -147,7 +149,8 @@ struct rdma_ucm_resolve_route {
 enum {
 	RDMA_USER_CM_QUERY_ADDR,
 	RDMA_USER_CM_QUERY_PATH,
-	RDMA_USER_CM_QUERY_GID
+	RDMA_USER_CM_QUERY_GID,
+	RDMA_USER_CM_QUERY_IB_SERVICE
 };
 
 struct rdma_ucm_query {
@@ -187,6 +190,12 @@ struct rdma_ucm_query_path_resp {
 	struct ib_path_rec_data path_data[];
 };
 
+struct rdma_ucm_query_ib_service_resp {
+	__u32 num_service_recs;
+	__u32 reserved;
+	struct ib_user_service_rec recs[];
+};
+
 struct rdma_ucm_conn_param {
 	__u32 qp_num;
 	__u32 qkey;
@@ -297,6 +306,7 @@ struct rdma_ucm_event_resp {
 	union {
 		struct rdma_ucm_conn_param conn;
 		struct rdma_ucm_ud_param   ud;
+		__u32 arg32[2];
 	} param;
 	__u32 reserved;
 	struct rdma_ucm_ece ece;
@@ -338,4 +348,34 @@ struct rdma_ucm_migrate_resp {
 	__u32 events_reported;
 };
 
+enum {
+	RDMA_USER_CM_IB_SERVICE_FLAG_ID = 1 << 0,
+	RDMA_USER_CM_IB_SERVICE_FLAG_NAME = 1 << 1,
+};
+
+#define RDMA_USER_CM_IB_SERVICE_NAME_SIZE 64
+struct rdma_ucm_ib_service {
+	__aligned_u64 service_id;
+	__u8  service_name[RDMA_USER_CM_IB_SERVICE_NAME_SIZE];
+	__u32 flags;
+	__u32 reserved;
+};
+
+struct rdma_ucm_resolve_ib_service {
+	__u32 id;
+	__u32 reserved;
+	struct rdma_ucm_ib_service ibs;
+};
+
+struct rdma_ucm_write_cm_event {
+	__u32 id;
+	__u32 reserved;
+	__u32 event;
+	__u32 status;
+	union {
+		struct rdma_ucm_conn_param conn;
+		struct rdma_ucm_ud_param ud;
+		__u64 arg;
+	} param;
+};
 #endif /* RDMA_USER_CM_H */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/regulator/regulator.h b/lib/libc/include/any-linux-any/regulator/regulator.h
index e92204bd59a07a186edfcb50e0f31de94c4d9469..12c357e626125b6fe85900027ea01a92afa54271 100644
--- a/lib/libc/include/any-linux-any/regulator/regulator.h
+++ b/lib/libc/include/any-linux-any/regulator/regulator.h
@@ -8,7 +8,7 @@
 #ifndef _REGULATOR_H
 #define _REGULATOR_H
 
-#include <stdint.h>
+#include <linux/types.h>
 
 /*
  * Regulator notifier events.
@@ -58,7 +58,7 @@
 
 struct reg_genl_event {
 	char reg_name[32];
-	uint64_t event;
+	__u64 event;
 };
 
 /* attributes of reg_genl_family */
diff --git a/lib/libc/include/any-linux-any/scsi/fc/fc_els.h b/lib/libc/include/any-linux-any/scsi/fc/fc_els.h
index e84bc63e7f9dff98b7c95beb11c5d580d5642298..5220bc05d555ca0a732033006cb7645aa564f41b 100644
--- a/lib/libc/include/any-linux-any/scsi/fc/fc_els.h
+++ b/lib/libc/include/any-linux-any/scsi/fc/fc_els.h
@@ -11,6 +11,8 @@
 #include <linux/types.h>
 #include <asm/byteorder.h>
 
+#include <stddef.h>		/* for offsetof */
+
 /*
  * Fibre Channel Switch - Enhanced Link Services definitions.
  * From T11 FC-LS Rev 1.2 June 7, 2005.
@@ -1109,12 +1111,15 @@ struct fc_els_fpin {
 
 /* Diagnostic Function Descriptor - FPIN Registration */
 struct fc_df_desc_fpin_reg {
-	__be32		desc_tag;	/* FPIN Registration (0x00030001) */
-	__be32		desc_len;	/* Length of Descriptor (in bytes).
-					 * Size of descriptor excluding
-					 * desc_tag and desc_len fields.
-					 */
-	__be32		count;		/* Number of desc_tags elements */
+	/* New members MUST be added within the __struct_group() macro below. */
+	__struct_group(fc_df_desc_fpin_reg_hdr, __hdr, /* no attrs */,
+		__be32		desc_tag; /* FPIN Registration (0x00030001) */
+		__be32		desc_len; /* Length of Descriptor (in bytes).
+					   * Size of descriptor excluding
+					   * desc_tag and desc_len fields.
+					   */
+		__be32		count;	  /* Number of desc_tags elements */
+	);
 	__be32		desc_tags[];	/* Array of Descriptor Tags.
 					 * Each tag indicates a function
 					 * supported by the N_Port (request)
@@ -1124,33 +1129,44 @@ struct fc_df_desc_fpin_reg {
 					 * See ELS_FN_DTAG_xxx for tag values.
 					 */
 };
+_Static_assert(offsetof(struct fc_df_desc_fpin_reg, desc_tags) == sizeof(struct fc_df_desc_fpin_reg_hdr),
+	      "struct member likely outside of __struct_group()");
 
 /*
  * ELS_RDF - Register Diagnostic Functions
  */
 struct fc_els_rdf {
-	__u8		fpin_cmd;	/* command (0x19) */
-	__u8		fpin_zero[3];	/* specified as zero - part of cmd */
-	__be32		desc_len;	/* Length of Descriptor List (in bytes).
-					 * Size of ELS excluding fpin_cmd,
-					 * fpin_zero and desc_len fields.
-					 */
+	/* New members MUST be added within the __struct_group() macro below. */
+	__struct_group(fc_els_rdf_hdr, __hdr, /* no attrs */,
+		__u8		fpin_cmd;	/* command (0x19) */
+		__u8		fpin_zero[3];	/* specified as zero - part of cmd */
+		__be32		desc_len;	/* Length of Descriptor List (in bytes).
+						 * Size of ELS excluding fpin_cmd,
+						 * fpin_zero and desc_len fields.
+						 */
+	);
 	struct fc_tlv_desc	desc[];	/* Descriptor list */
 };
+_Static_assert(offsetof(struct fc_els_rdf, desc) == sizeof(struct fc_els_rdf_hdr),
+	       "struct member likely outside of __struct_group()");
 
 /*
  * ELS RDF LS_ACC Response.
  */
 struct fc_els_rdf_resp {
-	struct fc_els_ls_acc	acc_hdr;
-	__be32			desc_list_len;	/* Length of response (in
-						 * bytes). Excludes acc_hdr
-						 * and desc_list_len fields.
-						 */
-	struct fc_els_lsri_desc	lsri;
+	/* New members MUST be added within the __struct_group() macro below. */
+	__struct_group(fc_els_rdf_resp_hdr, __hdr, /* no attrs */,
+		struct fc_els_ls_acc	acc_hdr;
+		__be32			desc_list_len;	/* Length of response (in
+							 * bytes). Excludes acc_hdr
+							 * and desc_list_len fields.
+							 */
+		struct fc_els_lsri_desc	lsri;
+	);
 	struct fc_tlv_desc	desc[];	/* Supported Descriptor list */
 };
-
+_Static_assert(offsetof(struct fc_els_rdf_resp, desc) == sizeof(struct fc_els_rdf_resp_hdr),
+	       "struct member likely outside of __struct_group()");
 
 /*
  * Diagnostic Capability Descriptors for EDC ELS
diff --git a/lib/libc/include/any-linux-any/sound/asound.h b/lib/libc/include/any-linux-any/sound/asound.h
index 1054dc2a693eb541aa5d6ee7e021dfea6a93659e..d4f3232039d501cf98404a0700d2481b9c499f02 100644
--- a/lib/libc/include/any-linux-any/sound/asound.h
+++ b/lib/libc/include/any-linux-any/sound/asound.h
@@ -58,7 +58,7 @@ struct snd_cea_861_aud_if {
 	unsigned char db2_sf_ss; /* sample frequency and size */
 	unsigned char db3; /* not used, all zeros */
 	unsigned char db4_ca; /* channel allocation code */
-	unsigned char db5_dminh_lsv; /* downmix inhibit & level-shit values */
+	unsigned char db5_dminh_lsv; /* downmix inhibit & level-shift values */
 };
 
 /****************************************************************************
diff --git a/lib/libc/include/any-linux-any/sound/compress_offload.h b/lib/libc/include/any-linux-any/sound/compress_offload.h
index 9832ba3bab74fe138628c3a252986aba0d60bda1..31110f75f3ba72fb12378b7ef1185024ffd823ea 100644
--- a/lib/libc/include/any-linux-any/sound/compress_offload.h
+++ b/lib/libc/include/any-linux-any/sound/compress_offload.h
@@ -13,8 +13,7 @@
 #include <sound/asound.h>
 #include <sound/compress_params.h>
 
-
-#define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 3, 0)
+#define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 4, 1)
 /**
  * struct snd_compressed_buffer - compressed buffer
  * @fragment_size: size of buffer fragment in bytes
@@ -56,6 +55,25 @@ struct snd_compr_tstamp {
 	__u32 sampling_rate;
 } __attribute__((packed, aligned(4)));
 
+/**
+ * struct snd_compr_tstamp64 - timestamp descriptor with fields in 64 bit
+ * @byte_offset: Byte offset in ring buffer to DSP
+ * @copied_total: Total number of bytes copied from/to ring buffer to/by DSP
+ * @pcm_frames: Frames decoded or encoded by DSP. This field will evolve by
+ *	large steps and should only be used to monitor encoding/decoding
+ *	progress. It shall not be used for timing estimates.
+ * @pcm_io_frames: Frames rendered or received by DSP into a mixer or an audio
+ * output/input. This field should be used for A/V sync or time estimates.
+ * @sampling_rate: sampling rate of audio
+ */
+struct snd_compr_tstamp64 {
+	__u32 byte_offset;
+	__u64 copied_total;
+	__u64 pcm_frames;
+	__u64 pcm_io_frames;
+	__u32 sampling_rate;
+} __attribute__((packed, aligned(4)));
+
 /**
  * struct snd_compr_avail - avail descriptor
  * @avail: Number of bytes available in ring buffer for writing/reading
@@ -66,6 +84,16 @@ struct snd_compr_avail {
 	struct snd_compr_tstamp tstamp;
 } __attribute__((packed, aligned(4)));
 
+/**
+ * struct snd_compr_avail64 - avail descriptor with tstamp in 64 bit format
+ * @avail: Number of bytes available in ring buffer for writing/reading
+ * @tstamp: timestamp information
+ */
+struct snd_compr_avail64 {
+	__u64 avail;
+	struct snd_compr_tstamp64 tstamp;
+} __attribute__((packed, aligned(4)));
+
 enum snd_compr_direction {
 	SND_COMPRESS_PLAYBACK = 0,
 	SND_COMPRESS_CAPTURE,
@@ -189,6 +217,7 @@ struct snd_compr_task_status {
  * Note: only codec params can be changed runtime and stream params cant be
  * SNDRV_COMPRESS_GET_PARAMS: Query codec params
  * SNDRV_COMPRESS_TSTAMP: get the current timestamp value
+ * SNDRV_COMPRESS_TSTAMP64: get the current timestamp value in 64 bit format
  * SNDRV_COMPRESS_AVAIL: get the current buffer avail value.
  * This also queries the tstamp properties
  * SNDRV_COMPRESS_PAUSE: Pause the running stream
@@ -211,6 +240,8 @@ struct snd_compr_task_status {
 						 struct snd_compr_metadata)
 #define SNDRV_COMPRESS_TSTAMP		_IOR('C', 0x20, struct snd_compr_tstamp)
 #define SNDRV_COMPRESS_AVAIL		_IOR('C', 0x21, struct snd_compr_avail)
+#define SNDRV_COMPRESS_TSTAMP64		_IOR('C', 0x22, struct snd_compr_tstamp64)
+#define SNDRV_COMPRESS_AVAIL64		_IOR('C', 0x23, struct snd_compr_avail64)
 #define SNDRV_COMPRESS_PAUSE		_IO('C', 0x30)
 #define SNDRV_COMPRESS_RESUME		_IO('C', 0x31)
 #define SNDRV_COMPRESS_START		_IO('C', 0x32)
diff --git a/lib/libc/include/any-linux-any/sound/compress_params.h b/lib/libc/include/any-linux-any/sound/compress_params.h
index 6953bbd802c9524931b4e88ee73c269cfcd54b53..a7254afdce04004b624415843b5698c120ab84a5 100644
--- a/lib/libc/include/any-linux-any/sound/compress_params.h
+++ b/lib/libc/include/any-linux-any/sound/compress_params.h
@@ -43,7 +43,8 @@
 #define SND_AUDIOCODEC_BESPOKE               ((__u32) 0x0000000E)
 #define SND_AUDIOCODEC_ALAC                  ((__u32) 0x0000000F)
 #define SND_AUDIOCODEC_APE                   ((__u32) 0x00000010)
-#define SND_AUDIOCODEC_MAX                   SND_AUDIOCODEC_APE
+#define SND_AUDIOCODEC_OPUS_RAW              ((__u32) 0x00000011)
+#define SND_AUDIOCODEC_MAX                   SND_AUDIOCODEC_OPUS_RAW
 
 /*
  * Profile and modes are listed with bit masks. This allows for a
@@ -324,6 +325,43 @@ struct snd_dec_ape {
 	__u32 seek_table_present;
 } __attribute__((packed, aligned(4)));
 
+/**
+ * struct snd_dec_opus - Opus decoder parameters (raw opus packets)
+ * @version: Usually should be '1' but can be split into major (4 upper bits)
+ * and minor (4 lower bits) sub-fields.
+ * @num_channels: Number of output channels.
+ * @pre_skip: Number of samples to discard at 48 kHz.
+ * @sample_rate: Sample rate of original input.
+ * @output_gain: Gain to apply when decoding (in Q7.8 format).
+ * @mapping_family: Order and meaning of output channels. Only values 0 and 1
+ * are expected; values 2..255 are not recommended for playback.
+ *
+ * @chan_map: Optional channel mapping table. Describes mapping of opus streams
+ *            to decoded channels. Fields:
+ * @chan_map.stream_count: Number of streams encoded in each Ogg packet.
+ * @chan_map.coupled_count: Number of streams whose decoders are used
+ *                          for two channels.
+ * @chan_map.channel_map: Which decoded channel to be used for each one.
+ *                        Supports only mapping families 0 and 1,
+ *                        max number of channels is 8.
+ *
+ * These options were extracted from RFC7845 Section 5.
+ */
+
+struct snd_dec_opus {
+	__u8 version;
+	__u8 num_channels;
+	__u16 pre_skip;
+	__u32 sample_rate;
+	__u16 output_gain;
+	__u8 mapping_family;
+	struct snd_dec_opus_ch_map {
+		__u8 stream_count;
+		__u8 coupled_count;
+		__u8 channel_map[8];
+	} chan_map;
+} __attribute__((packed, aligned(4)));
+
 union snd_codec_options {
 	struct snd_enc_wma wma;
 	struct snd_enc_vorbis vorbis;
@@ -334,6 +372,7 @@ union snd_codec_options {
 	struct snd_dec_wma wma_d;
 	struct snd_dec_alac alac_d;
 	struct snd_dec_ape ape_d;
+	struct snd_dec_opus opus_d;
 	struct {
 		__u32 out_sample_rate;
 	} src_d;
diff --git a/lib/libc/include/any-linux-any/sound/intel/avs/tokens.h b/lib/libc/include/any-linux-any/sound/intel/avs/tokens.h
index c565277b8fe8ad2379017c0e1fb0f199757f4443..9095eb70dd9a85f4da6b6900e787f35fcdb8f544 100644
--- a/lib/libc/include/any-linux-any/sound/intel/avs/tokens.h
+++ b/lib/libc/include/any-linux-any/sound/intel/avs/tokens.h
@@ -21,6 +21,7 @@ enum avs_tplg_token {
 	AVS_TKN_MANIFEST_NUM_BINDINGS_U32		= 8,
 	AVS_TKN_MANIFEST_NUM_CONDPATH_TMPLS_U32		= 9,
 	AVS_TKN_MANIFEST_NUM_INIT_CONFIGS_U32		= 10,
+	AVS_TKN_MANIFEST_NUM_NHLT_CONFIGS_U32		= 11,
 
 	/* struct avs_tplg_library */
 	AVS_TKN_LIBRARY_ID_U32				= 101,
@@ -124,6 +125,7 @@ enum avs_tplg_token {
 	AVS_TKN_MOD_KCONTROL_ID_U32			= 1707,
 	AVS_TKN_MOD_INIT_CONFIG_NUM_IDS_U32		= 1708,
 	AVS_TKN_MOD_INIT_CONFIG_ID_U32			= 1709,
+	AVS_TKN_MOD_NHLT_CONFIG_ID_U32			= 1710,
 
 	/* struct avs_tplg_path_template */
 	AVS_TKN_PATH_TMPL_ID_U32			= 1801,
@@ -133,6 +135,21 @@ enum avs_tplg_token {
 	AVS_TKN_PATH_FE_FMT_ID_U32			= 1902,
 	AVS_TKN_PATH_BE_FMT_ID_U32			= 1903,
 
+	/* struct avs_tplg_path_template (conditional) */
+	AVS_TKN_CONDPATH_TMPL_ID_U32			= 1801,
+	AVS_TKN_CONDPATH_TMPL_SOURCE_TPLG_NAME_STRING	= 2002,
+	AVS_TKN_CONDPATH_TMPL_SOURCE_PATH_TMPL_ID_U32	= 2003,
+	AVS_TKN_CONDPATH_TMPL_SINK_TPLG_NAME_STRING	= 2004,
+	AVS_TKN_CONDPATH_TMPL_SINK_PATH_TMPL_ID_U32	= 2005,
+	AVS_TKN_CONDPATH_TMPL_COND_TYPE_U32		= 2006,
+	AVS_TKN_CONDPATH_TMPL_OVERRIDABLE_BOOL		= 2007,
+	AVS_TKN_CONDPATH_TMPL_PRIORITY_U8		= 2008,
+
+	/* struct avs_tplg_path (conditional) */
+	AVS_TKN_CONDPATH_ID_U32				= 1901,
+	AVS_TKN_CONDPATH_SOURCE_PATH_ID_U32		= 2102,
+	AVS_TKN_CONDPATH_SINK_PATH_ID_U32		= 2103,
+
 	/* struct avs_tplg_pin_format */
 	AVS_TKN_PIN_FMT_INDEX_U32			= 2201,
 	AVS_TKN_PIN_FMT_IOBS_U32			= 2202,
@@ -145,6 +162,10 @@ enum avs_tplg_token {
 	AVS_TKN_INIT_CONFIG_ID_U32			= 2401,
 	AVS_TKN_INIT_CONFIG_PARAM_U8			= 2402,
 	AVS_TKN_INIT_CONFIG_LENGTH_U32			= 2403,
+
+	/* struct avs_tplg_nhlt_config */
+	AVS_TKN_NHLT_CONFIG_ID_U32			= 2501,
+	AVS_TKN_NHLT_CONFIG_SIZE_U32			= 2502,
 };
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/sound/snd_ar_tokens.h b/lib/libc/include/any-linux-any/sound/snd_ar_tokens.h
index 8075cd134251f1b30de2a9b4897cf4e4733cca44..41085ea05fad9e2fe7183d43634ece9b8c78ee07 100644
--- a/lib/libc/include/any-linux-any/sound/snd_ar_tokens.h
+++ b/lib/libc/include/any-linux-any/sound/snd_ar_tokens.h
@@ -3,6 +3,8 @@
 #ifndef __SND_AR_TOKENS_H__
 #define __SND_AR_TOKENS_H__
 
+#include <linux/types.h>
+
 #define APM_SUB_GRAPH_PERF_MODE_LOW_POWER	0x1
 #define APM_SUB_GRAPH_PERF_MODE_LOW_LATENCY	0x2
 
@@ -118,6 +120,12 @@ enum ar_event_types {
  *						LPAIF_WSA = 2,
  *						LPAIF_VA = 3,
  *						LPAIF_AXI = 4
+ * Possible values for MI2S
+ *						I2S_INTF_TYPE_PRIMARY = 0,
+ *						I2S_INTF_TYPE_SECONDARY = 1,
+ *						I2S_INTF_TYPE_TERTIARY = 2,
+ *						I2S_INTF_TYPE_QUATERNARY = 3,
+ *						I2S_INTF_TYPE_QUINARY = 4,
  *
  * %AR_TKN_U32_MODULE_FMT_INTERLEAVE:		PCM Interleaving
  *						PCM_INTERLEAVED = 1,
@@ -184,8 +192,8 @@ enum ar_event_types {
 #define AR_TKN_U32_MODULE_INSTANCE_ID		201
 #define AR_TKN_U32_MODULE_MAX_IP_PORTS		202
 #define AR_TKN_U32_MODULE_MAX_OP_PORTS		203
-#define AR_TKN_U32_MODULE_IN_PORTS		204
-#define AR_TKN_U32_MODULE_OUT_PORTS		205
+#define AR_TKN_U32_MODULE_IN_PORTS		204 /* deprecated */
+#define AR_TKN_U32_MODULE_OUT_PORTS		205 /* deprecated */
 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID	206
 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID	207
 #define AR_TKN_U32_MODULE_SRC_INSTANCE_ID	208
@@ -232,4 +240,12 @@ enum ar_event_types {
 #define AR_TKN_U32_MODULE_LOG_TAP_POINT_ID	260
 #define AR_TKN_U32_MODULE_LOG_MODE		261
 
+#define SND_SOC_AR_TPLG_MODULE_CFG_TYPE 0x01001006
+struct audioreach_module_priv_data {
+	__le32 size;	/* size in bytes of the array, including all elements */
+	__le32 type;	/* SND_SOC_AR_TPLG_MODULE_CFG_TYPE */
+	__le32 priv[2];	/* Private data for future expansion */
+	__le32 data[0];	/* config data */
+};
+
 #endif /* __SND_AR_TOKENS_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-linux-any/sound/sof/tokens.h b/lib/libc/include/any-linux-any/sound/sof/tokens.h
index 9bdad9ff27d4ca9e54b34de0f7dc48d77fd821ea..a52c019fc5fed2d9fff81804eb824f1dd239da93 100644
--- a/lib/libc/include/any-linux-any/sound/sof/tokens.h
+++ b/lib/libc/include/any-linux-any/sound/sof/tokens.h
@@ -106,6 +106,8 @@
  */
 #define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME	417
 
+#define SOF_TKN_COMP_SCHED_DOMAIN		418
+
 /* SSP */
 #define SOF_TKN_INTEL_SSP_CLKS_CONTROL		500
 #define SOF_TKN_INTEL_SSP_MCLK_ID		501
diff --git a/lib/libc/include/arc-linux-any/asm/unistd_32.h b/lib/libc/include/arc-linux-any/asm/unistd_32.h
index f4c5c5d809d3698d13746c552dc3c844b068d453..cb602f509a8c54a1f3a86e74c7478fe9316c9806 100644
--- a/lib/libc/include/arc-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/arc-linux-any/asm/unistd_32.h
@@ -350,6 +350,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/arm-linux-any/asm/unistd-eabi.h b/lib/libc/include/arm-linux-any/asm/unistd-eabi.h
index c46cb74ed458cab2b316d4d140bcc5545ddfa7a1..24d037cfb0d34f92bee81947d8a0f192506db852 100644
--- a/lib/libc/include/arm-linux-any/asm/unistd-eabi.h
+++ b/lib/libc/include/arm-linux-any/asm/unistd-eabi.h
@@ -423,5 +423,6 @@
 #define __NR_open_tree_attr (__NR_SYSCALL_BASE + 467)
 #define __NR_file_getattr (__NR_SYSCALL_BASE + 468)
 #define __NR_file_setattr (__NR_SYSCALL_BASE + 469)
+#define __NR_listns (__NR_SYSCALL_BASE + 470)
 
 #endif /* _ASM_UNISTD_EABI_H */
\ No newline at end of file
diff --git a/lib/libc/include/arm-linux-any/asm/unistd-oabi.h b/lib/libc/include/arm-linux-any/asm/unistd-oabi.h
index 4226cbc2a92d4fb407dd8e1519b8232829c41a50..ca50acaf2a8b4235ddc1fb7af8a8e854a49dd1d0 100644
--- a/lib/libc/include/arm-linux-any/asm/unistd-oabi.h
+++ b/lib/libc/include/arm-linux-any/asm/unistd-oabi.h
@@ -435,5 +435,6 @@
 #define __NR_open_tree_attr (__NR_SYSCALL_BASE + 467)
 #define __NR_file_getattr (__NR_SYSCALL_BASE + 468)
 #define __NR_file_setattr (__NR_SYSCALL_BASE + 469)
+#define __NR_listns (__NR_SYSCALL_BASE + 470)
 
 #endif /* _ASM_UNISTD_OABI_H */
\ No newline at end of file
diff --git a/lib/libc/include/csky-linux-any/asm/ptrace.h b/lib/libc/include/csky-linux-any/asm/ptrace.h
index cc88df60dec416225f22c8287b2a5ad6cbdcd63c..20ca6c24be1052cddb9f04d6f3a8ada78922f7bf 100644
--- a/lib/libc/include/csky-linux-any/asm/ptrace.h
+++ b/lib/libc/include/csky-linux-any/asm/ptrace.h
@@ -3,7 +3,7 @@
 #ifndef _CSKY_PTRACE_H
 #define _CSKY_PTRACE_H
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 struct pt_regs {
 	unsigned long	tls;
@@ -47,5 +47,5 @@ struct user_fp {
 	unsigned long	reserved;
 };
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 #endif /* _CSKY_PTRACE_H */
\ No newline at end of file
diff --git a/lib/libc/include/csky-linux-any/asm/unistd_32.h b/lib/libc/include/csky-linux-any/asm/unistd_32.h
index 98121e63cbe4a264a8b983f7a8369b68d8111b6f..a3aafb989a3e3120a9f8173d940c78add55d884e 100644
--- a/lib/libc/include/csky-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/csky-linux-any/asm/unistd_32.h
@@ -346,6 +346,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/hexagon-linux-any/asm/unistd_32.h b/lib/libc/include/hexagon-linux-any/asm/unistd_32.h
index 41f43021fdaa9592a882b29ee82571e054b4f9fa..9dfd77f5183a0c83bbea99053578c4a8e6365a9a 100644
--- a/lib/libc/include/hexagon-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/hexagon-linux-any/asm/unistd_32.h
@@ -345,6 +345,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/loongarch-linux-any/asm/kvm.h b/lib/libc/include/loongarch-linux-any/asm/kvm.h
index 4d43a769f7f81d015d97ef14ff616dc470ab1c4c..04367ef1bfa9f9a39da8aa6f3579609cd1c085ef 100644
--- a/lib/libc/include/loongarch-linux-any/asm/kvm.h
+++ b/lib/libc/include/loongarch-linux-any/asm/kvm.h
@@ -103,6 +103,8 @@ struct kvm_fpu {
 #define  KVM_LOONGARCH_VM_FEAT_PMU		5
 #define  KVM_LOONGARCH_VM_FEAT_PV_IPI		6
 #define  KVM_LOONGARCH_VM_FEAT_PV_STEALTIME	7
+#define  KVM_LOONGARCH_VM_FEAT_PTW		8
+#define  KVM_LOONGARCH_VM_FEAT_MSGINT		9
 
 /* Device Control API on vcpu fd */
 #define KVM_LOONGARCH_VCPU_CPUCFG	0
diff --git a/lib/libc/include/loongarch-linux-any/asm/ptrace.h b/lib/libc/include/loongarch-linux-any/asm/ptrace.h
index 800edc83d53c1604ef79c6b80852b600663c627a..9001186616ee1a269d0ac00e367d817c33261f25 100644
--- a/lib/libc/include/loongarch-linux-any/asm/ptrace.h
+++ b/lib/libc/include/loongarch-linux-any/asm/ptrace.h
@@ -10,8 +10,6 @@
 
 #include <linux/types.h>
 
-#include <stdint.h>
-
 /*
  * For PTRACE_{POKE,PEEK}USR. 0 - 31 are GPRs,
  * 32 is syscall's original ARG0, 33 is PC, 34 is BADVADDR.
@@ -39,44 +37,54 @@ struct user_pt_regs {
 } __attribute__((aligned(8)));
 
 struct user_fp_state {
-	uint64_t fpr[32];
-	uint64_t fcc;
-	uint32_t fcsr;
+	__u64 fpr[32];
+	__u64 fcc;
+	__u32 fcsr;
 };
 
 struct user_lsx_state {
 	/* 32 registers, 128 bits width per register. */
-	uint64_t vregs[32*2];
+	__u64 vregs[32*2];
 };
 
 struct user_lasx_state {
 	/* 32 registers, 256 bits width per register. */
-	uint64_t vregs[32*4];
+	__u64 vregs[32*4];
 };
 
 struct user_lbt_state {
-	uint64_t scr[4];
-	uint32_t eflags;
-	uint32_t ftop;
+	__u64 scr[4];
+	__u32 eflags;
+	__u32 ftop;
 };
 
 struct user_watch_state {
-	uint64_t dbg_info;
+	__u64 dbg_info;
 	struct {
-		uint64_t    addr;
-		uint64_t    mask;
-		uint32_t    ctrl;
-		uint32_t    pad;
+#if __BITS_PER_LONG == 32
+		__u32    addr;
+		__u32    mask;
+#else
+		__u64    addr;
+		__u64    mask;
+#endif
+		__u32    ctrl;
+		__u32    pad;
 	} dbg_regs[8];
 };
 
 struct user_watch_state_v2 {
-	uint64_t dbg_info;
+	__u64 dbg_info;
 	struct {
-		uint64_t    addr;
-		uint64_t    mask;
-		uint32_t    ctrl;
-		uint32_t    pad;
+#if __BITS_PER_LONG == 32
+		__u32    addr;
+		__u32    mask;
+#else
+		__u64    addr;
+		__u64    mask;
+#endif
+		__u32    ctrl;
+		__u32    pad;
 	} dbg_regs[14];
 };
 
diff --git a/lib/libc/include/loongarch-linux-any/asm/unistd.h b/lib/libc/include/loongarch-linux-any/asm/unistd.h
index 07af3ba94fc7fc7debd0b6a39a6bae261bbe51df..37211d5079a32a0c55fad247bd1abfe768dd4e20 100644
--- a/lib/libc/include/loongarch-linux-any/asm/unistd.h
+++ b/lib/libc/include/loongarch-linux-any/asm/unistd.h
@@ -1,3 +1,9 @@
 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 
-#include <asm/unistd_64.h>
\ No newline at end of file
+#include <asm/bitsperlong.h>
+
+#if __BITS_PER_LONG == 32
+#include <asm/unistd_32.h>
+#else
+#include <asm/unistd_64.h>
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/loongarch-linux-any/asm/unistd_32.h b/lib/libc/include/loongarch-linux-any/asm/unistd_32.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce7914afda4fdfa307d3468fbba689e919da8aa6
--- /dev/null
+++ b/lib/libc/include/loongarch-linux-any/asm/unistd_32.h
@@ -0,0 +1,320 @@
+#ifndef _ASM_UNISTD_32_H
+#define _ASM_UNISTD_32_H
+
+#define __NR_io_setup 0
+#define __NR_io_destroy 1
+#define __NR_io_submit 2
+#define __NR_io_cancel 3
+#define __NR_setxattr 5
+#define __NR_lsetxattr 6
+#define __NR_fsetxattr 7
+#define __NR_getxattr 8
+#define __NR_lgetxattr 9
+#define __NR_fgetxattr 10
+#define __NR_listxattr 11
+#define __NR_llistxattr 12
+#define __NR_flistxattr 13
+#define __NR_removexattr 14
+#define __NR_lremovexattr 15
+#define __NR_fremovexattr 16
+#define __NR_getcwd 17
+#define __NR_lookup_dcookie 18
+#define __NR_eventfd2 19
+#define __NR_epoll_create1 20
+#define __NR_epoll_ctl 21
+#define __NR_epoll_pwait 22
+#define __NR_dup 23
+#define __NR_dup3 24
+#define __NR_fcntl64 25
+#define __NR_inotify_init1 26
+#define __NR_inotify_add_watch 27
+#define __NR_inotify_rm_watch 28
+#define __NR_ioctl 29
+#define __NR_ioprio_set 30
+#define __NR_ioprio_get 31
+#define __NR_flock 32
+#define __NR_mknodat 33
+#define __NR_mkdirat 34
+#define __NR_unlinkat 35
+#define __NR_symlinkat 36
+#define __NR_linkat 37
+#define __NR_umount2 39
+#define __NR_mount 40
+#define __NR_pivot_root 41
+#define __NR_nfsservctl 42
+#define __NR_statfs64 43
+#define __NR_fstatfs64 44
+#define __NR_truncate64 45
+#define __NR_ftruncate64 46
+#define __NR_fallocate 47
+#define __NR_faccessat 48
+#define __NR_chdir 49
+#define __NR_fchdir 50
+#define __NR_chroot 51
+#define __NR_fchmod 52
+#define __NR_fchmodat 53
+#define __NR_fchownat 54
+#define __NR_fchown 55
+#define __NR_openat 56
+#define __NR_close 57
+#define __NR_vhangup 58
+#define __NR_pipe2 59
+#define __NR_quotactl 60
+#define __NR_getdents64 61
+#define __NR_llseek 62
+#define __NR_read 63
+#define __NR_write 64
+#define __NR_readv 65
+#define __NR_writev 66
+#define __NR_pread64 67
+#define __NR_pwrite64 68
+#define __NR_preadv 69
+#define __NR_pwritev 70
+#define __NR_sendfile64 71
+#define __NR_signalfd4 74
+#define __NR_vmsplice 75
+#define __NR_splice 76
+#define __NR_tee 77
+#define __NR_readlinkat 78
+#define __NR_sync 81
+#define __NR_fsync 82
+#define __NR_fdatasync 83
+#define __NR_sync_file_range 84
+#define __NR_timerfd_create 85
+#define __NR_acct 89
+#define __NR_capget 90
+#define __NR_capset 91
+#define __NR_personality 92
+#define __NR_exit 93
+#define __NR_exit_group 94
+#define __NR_waitid 95
+#define __NR_set_tid_address 96
+#define __NR_unshare 97
+#define __NR_set_robust_list 99
+#define __NR_get_robust_list 100
+#define __NR_getitimer 102
+#define __NR_setitimer 103
+#define __NR_kexec_load 104
+#define __NR_init_module 105
+#define __NR_delete_module 106
+#define __NR_timer_create 107
+#define __NR_timer_getoverrun 109
+#define __NR_timer_delete 111
+#define __NR_syslog 116
+#define __NR_ptrace 117
+#define __NR_sched_setparam 118
+#define __NR_sched_setscheduler 119
+#define __NR_sched_getscheduler 120
+#define __NR_sched_getparam 121
+#define __NR_sched_setaffinity 122
+#define __NR_sched_getaffinity 123
+#define __NR_sched_yield 124
+#define __NR_sched_get_priority_max 125
+#define __NR_sched_get_priority_min 126
+#define __NR_restart_syscall 128
+#define __NR_kill 129
+#define __NR_tkill 130
+#define __NR_tgkill 131
+#define __NR_sigaltstack 132
+#define __NR_rt_sigsuspend 133
+#define __NR_rt_sigaction 134
+#define __NR_rt_sigprocmask 135
+#define __NR_rt_sigpending 136
+#define __NR_rt_sigqueueinfo 138
+#define __NR_rt_sigreturn 139
+#define __NR_setpriority 140
+#define __NR_getpriority 141
+#define __NR_reboot 142
+#define __NR_setregid 143
+#define __NR_setgid 144
+#define __NR_setreuid 145
+#define __NR_setuid 146
+#define __NR_setresuid 147
+#define __NR_getresuid 148
+#define __NR_setresgid 149
+#define __NR_getresgid 150
+#define __NR_setfsuid 151
+#define __NR_setfsgid 152
+#define __NR_times 153
+#define __NR_setpgid 154
+#define __NR_getpgid 155
+#define __NR_getsid 156
+#define __NR_setsid 157
+#define __NR_getgroups 158
+#define __NR_setgroups 159
+#define __NR_uname 160
+#define __NR_sethostname 161
+#define __NR_setdomainname 162
+#define __NR_getrusage 165
+#define __NR_umask 166
+#define __NR_prctl 167
+#define __NR_getcpu 168
+#define __NR_getpid 172
+#define __NR_getppid 173
+#define __NR_getuid 174
+#define __NR_geteuid 175
+#define __NR_getgid 176
+#define __NR_getegid 177
+#define __NR_gettid 178
+#define __NR_sysinfo 179
+#define __NR_mq_open 180
+#define __NR_mq_unlink 181
+#define __NR_mq_notify 184
+#define __NR_mq_getsetattr 185
+#define __NR_msgget 186
+#define __NR_msgctl 187
+#define __NR_msgrcv 188
+#define __NR_msgsnd 189
+#define __NR_semget 190
+#define __NR_semctl 191
+#define __NR_semop 193
+#define __NR_shmget 194
+#define __NR_shmctl 195
+#define __NR_shmat 196
+#define __NR_shmdt 197
+#define __NR_socket 198
+#define __NR_socketpair 199
+#define __NR_bind 200
+#define __NR_listen 201
+#define __NR_accept 202
+#define __NR_connect 203
+#define __NR_getsockname 204
+#define __NR_getpeername 205
+#define __NR_sendto 206
+#define __NR_recvfrom 207
+#define __NR_setsockopt 208
+#define __NR_getsockopt 209
+#define __NR_shutdown 210
+#define __NR_sendmsg 211
+#define __NR_recvmsg 212
+#define __NR_readahead 213
+#define __NR_brk 214
+#define __NR_munmap 215
+#define __NR_mremap 216
+#define __NR_add_key 217
+#define __NR_request_key 218
+#define __NR_keyctl 219
+#define __NR_clone 220
+#define __NR_execve 221
+#define __NR_mmap2 222
+#define __NR_fadvise64_64 223
+#define __NR_swapon 224
+#define __NR_swapoff 225
+#define __NR_mprotect 226
+#define __NR_msync 227
+#define __NR_mlock 228
+#define __NR_munlock 229
+#define __NR_mlockall 230
+#define __NR_munlockall 231
+#define __NR_mincore 232
+#define __NR_madvise 233
+#define __NR_remap_file_pages 234
+#define __NR_mbind 235
+#define __NR_get_mempolicy 236
+#define __NR_set_mempolicy 237
+#define __NR_migrate_pages 238
+#define __NR_move_pages 239
+#define __NR_rt_tgsigqueueinfo 240
+#define __NR_perf_event_open 241
+#define __NR_accept4 242
+#define __NR_prlimit64 261
+#define __NR_fanotify_init 262
+#define __NR_fanotify_mark 263
+#define __NR_name_to_handle_at 264
+#define __NR_open_by_handle_at 265
+#define __NR_syncfs 267
+#define __NR_setns 268
+#define __NR_sendmmsg 269
+#define __NR_process_vm_readv 270
+#define __NR_process_vm_writev 271
+#define __NR_kcmp 272
+#define __NR_finit_module 273
+#define __NR_sched_setattr 274
+#define __NR_sched_getattr 275
+#define __NR_renameat2 276
+#define __NR_seccomp 277
+#define __NR_getrandom 278
+#define __NR_memfd_create 279
+#define __NR_bpf 280
+#define __NR_execveat 281
+#define __NR_userfaultfd 282
+#define __NR_membarrier 283
+#define __NR_mlock2 284
+#define __NR_copy_file_range 285
+#define __NR_preadv2 286
+#define __NR_pwritev2 287
+#define __NR_pkey_mprotect 288
+#define __NR_pkey_alloc 289
+#define __NR_pkey_free 290
+#define __NR_statx 291
+#define __NR_rseq 293
+#define __NR_kexec_file_load 294
+#define __NR_clock_gettime64 403
+#define __NR_clock_settime64 404
+#define __NR_clock_adjtime64 405
+#define __NR_clock_getres_time64 406
+#define __NR_clock_nanosleep_time64 407
+#define __NR_timer_gettime64 408
+#define __NR_timer_settime64 409
+#define __NR_timerfd_gettime64 410
+#define __NR_timerfd_settime64 411
+#define __NR_utimensat_time64 412
+#define __NR_pselect6_time64 413
+#define __NR_ppoll_time64 414
+#define __NR_io_pgetevents_time64 416
+#define __NR_recvmmsg_time64 417
+#define __NR_mq_timedsend_time64 418
+#define __NR_mq_timedreceive_time64 419
+#define __NR_semtimedop_time64 420
+#define __NR_rt_sigtimedwait_time64 421
+#define __NR_futex_time64 422
+#define __NR_sched_rr_get_interval_time64 423
+#define __NR_pidfd_send_signal 424
+#define __NR_io_uring_setup 425
+#define __NR_io_uring_enter 426
+#define __NR_io_uring_register 427
+#define __NR_open_tree 428
+#define __NR_move_mount 429
+#define __NR_fsopen 430
+#define __NR_fsconfig 431
+#define __NR_fsmount 432
+#define __NR_fspick 433
+#define __NR_pidfd_open 434
+#define __NR_clone3 435
+#define __NR_close_range 436
+#define __NR_openat2 437
+#define __NR_pidfd_getfd 438
+#define __NR_faccessat2 439
+#define __NR_process_madvise 440
+#define __NR_epoll_pwait2 441
+#define __NR_mount_setattr 442
+#define __NR_quotactl_fd 443
+#define __NR_landlock_create_ruleset 444
+#define __NR_landlock_add_rule 445
+#define __NR_landlock_restrict_self 446
+#define __NR_process_mrelease 448
+#define __NR_futex_waitv 449
+#define __NR_set_mempolicy_home_node 450
+#define __NR_cachestat 451
+#define __NR_fchmodat2 452
+#define __NR_map_shadow_stack 453
+#define __NR_futex_wake 454
+#define __NR_futex_wait 455
+#define __NR_futex_requeue 456
+#define __NR_statmount 457
+#define __NR_listmount 458
+#define __NR_lsm_get_self_attr 459
+#define __NR_lsm_set_self_attr 460
+#define __NR_lsm_list_modules 461
+#define __NR_mseal 462
+#define __NR_setxattrat 463
+#define __NR_getxattrat 464
+#define __NR_listxattrat 465
+#define __NR_removexattrat 466
+#define __NR_open_tree_attr 467
+#define __NR_file_getattr 468
+#define __NR_file_setattr 469
+#define __NR_listns 470
+
+
+#endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/loongarch-linux-any/asm/unistd_64.h b/lib/libc/include/loongarch-linux-any/asm/unistd_64.h
index eafb593448bebd7de1869bf4c60d6d31fdffc891..2cc5f652540e28449093a483e7447c83c410d8a9 100644
--- a/lib/libc/include/loongarch-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/loongarch-linux-any/asm/unistd_64.h
@@ -322,6 +322,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/m68k-linux-any/asm/unistd_32.h b/lib/libc/include/m68k-linux-any/asm/unistd_32.h
index 99dff7d1f8780c5b8851e072c73e6fdd6556dd85..00aaaca38120188b22667aea6269cff1431ff855 100644
--- a/lib/libc/include/m68k-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/m68k-linux-any/asm/unistd_32.h
@@ -442,6 +442,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/mips-linux-any/asm/unistd_n32.h b/lib/libc/include/mips-linux-any/asm/unistd_n32.h
index 5709abd8e7a3b03a3d313a8a12cd65085d2cabc9..14fafc75ff3794801ff39d9caf21e954d7548c55 100644
--- a/lib/libc/include/mips-linux-any/asm/unistd_n32.h
+++ b/lib/libc/include/mips-linux-any/asm/unistd_n32.h
@@ -398,5 +398,6 @@
 #define __NR_open_tree_attr (__NR_Linux + 467)
 #define __NR_file_getattr (__NR_Linux + 468)
 #define __NR_file_setattr (__NR_Linux + 469)
+#define __NR_listns (__NR_Linux + 470)
 
 #endif /* _ASM_UNISTD_N32_H */
\ No newline at end of file
diff --git a/lib/libc/include/mips-linux-any/asm/unistd_n64.h b/lib/libc/include/mips-linux-any/asm/unistd_n64.h
index 1aa5e2f65fd1af3ecab786f20b1dfb094eb4ade8..4b63dbf52b8f40e9fe7d3fec1c4fde9dd7f128f1 100644
--- a/lib/libc/include/mips-linux-any/asm/unistd_n64.h
+++ b/lib/libc/include/mips-linux-any/asm/unistd_n64.h
@@ -374,5 +374,6 @@
 #define __NR_open_tree_attr (__NR_Linux + 467)
 #define __NR_file_getattr (__NR_Linux + 468)
 #define __NR_file_setattr (__NR_Linux + 469)
+#define __NR_listns (__NR_Linux + 470)
 
 #endif /* _ASM_UNISTD_N64_H */
\ No newline at end of file
diff --git a/lib/libc/include/mips-linux-any/asm/unistd_o32.h b/lib/libc/include/mips-linux-any/asm/unistd_o32.h
index 635c7ee3c8fbeefe89f205acae3dd75cbc4777ee..3cf8772199b14ebae238e7b5b703c1927ea7e270 100644
--- a/lib/libc/include/mips-linux-any/asm/unistd_o32.h
+++ b/lib/libc/include/mips-linux-any/asm/unistd_o32.h
@@ -444,5 +444,6 @@
 #define __NR_open_tree_attr (__NR_Linux + 467)
 #define __NR_file_getattr (__NR_Linux + 468)
 #define __NR_file_setattr (__NR_Linux + 469)
+#define __NR_listns (__NR_Linux + 470)
 
 #endif /* _ASM_UNISTD_O32_H */
\ No newline at end of file
diff --git a/lib/libc/include/powerpc-linux-any/asm/opal-prd.h b/lib/libc/include/powerpc-linux-any/asm/opal-prd.h
index 087b068aeab9733463189a79d82465927ae07b79..6c9a482525dad46884ab2e22b7c2d0d8056056f2 100644
--- a/lib/libc/include/powerpc-linux-any/asm/opal-prd.h
+++ b/lib/libc/include/powerpc-linux-any/asm/opal-prd.h
@@ -40,7 +40,7 @@
 #define OPAL_PRD_SCOM_READ		_IOR('o', 0x02, struct opal_prd_scom)
 #define OPAL_PRD_SCOM_WRITE		_IOW('o', 0x03, struct opal_prd_scom)
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 struct opal_prd_info {
 	__u64	version;
@@ -54,6 +54,6 @@ struct opal_prd_scom {
 	__s64	rc;
 };
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 #endif /* _ASM_POWERPC_OPAL_PRD_H */
\ No newline at end of file
diff --git a/lib/libc/include/powerpc-linux-any/asm/papr-hvpipe.h b/lib/libc/include/powerpc-linux-any/asm/papr-hvpipe.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc54cf544903cd06cb058d4ae8fcb3a49c4306cb
--- /dev/null
+++ b/lib/libc/include/powerpc-linux-any/asm/papr-hvpipe.h
@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _PAPR_HVPIPE_H_
+#define _PAPR_HVPIPE_H_
+
+#include <linux/types.h>
+#include <asm/ioctl.h>
+#include <asm/papr-miscdev.h>
+
+/*
+ * This header is included in payload between OS and the user
+ * space.
+ * flags: OS notifies the user space whether the hvpipe is
+ *        closed or the buffer has the payload.
+ */
+struct papr_hvpipe_hdr {
+	__u8 version;
+	__u8 reserved[3];
+	__u32 flags;
+	__u8 reserved2[40];
+};
+
+/*
+ * ioctl for /dev/papr-hvpipe
+ */
+#define PAPR_HVPIPE_IOC_CREATE_HANDLE	_IOW(PAPR_MISCDEV_IOC_ID, 9, __u32)
+
+/*
+ * hvpipe_hdr flags used for read()
+ */
+#define HVPIPE_MSG_AVAILABLE	0x01 /* Payload is available */
+#define HVPIPE_LOST_CONNECTION	0x02 /* Pipe connection is closed/unavailable */
+
+#endif /* _PAPR_HVPIPE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/powerpc-linux-any/asm/ptrace.h b/lib/libc/include/powerpc-linux-any/asm/ptrace.h
index 62f6b23535c38931bbfc86272eab6100c28a4355..b3d128a2a2f933dfb3bcc3f6b3dd82a0cd0a33ee 100644
--- a/lib/libc/include/powerpc-linux-any/asm/ptrace.h
+++ b/lib/libc/include/powerpc-linux-any/asm/ptrace.h
@@ -27,7 +27,7 @@
 
 #include <linux/types.h>
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 struct pt_regs
 {
@@ -53,7 +53,7 @@ struct pt_regs
 	unsigned long result;		/* Result of a system call */
 };
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 
 /*
@@ -196,7 +196,7 @@ struct pt_regs
 #define PPC_PTRACE_SETHWDEBUG	0x88
 #define PPC_PTRACE_DELHWDEBUG	0x87
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 struct ppc_debug_info {
 	__u32 version;			/* Only version 1 exists to date */
@@ -208,7 +208,7 @@ struct ppc_debug_info {
 	__u64 features;
 };
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 /*
  * features will have bits indication whether there is support for:
@@ -220,7 +220,7 @@ struct ppc_debug_info {
 #define PPC_DEBUG_FEATURE_DATA_BP_DAWR		0x0000000000000010
 #define PPC_DEBUG_FEATURE_DATA_BP_ARCH_31	0x0000000000000020
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 struct ppc_hw_breakpoint {
 	__u32 version;		/* currently, version must be 1 */
@@ -232,7 +232,7 @@ struct ppc_hw_breakpoint {
 	__u64 condition_value;	/* contents of the DVC register */
 };
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 /*
  * Trigger Type
diff --git a/lib/libc/include/powerpc-linux-any/asm/types.h b/lib/libc/include/powerpc-linux-any/asm/types.h
index f2a0da7f59a5a53196e118472df1b830c6177c9f..b44ffb37f1708b181698f2e0b62816cc3c7015d2 100644
--- a/lib/libc/include/powerpc-linux-any/asm/types.h
+++ b/lib/libc/include/powerpc-linux-any/asm/types.h
@@ -28,14 +28,14 @@
 # include <asm-generic/int-ll64.h>
 #endif
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 
 typedef struct {
 	__u32 u[4];
 } __attribute__((aligned(16))) __vector128;
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 
 #endif /* _ASM_POWERPC_TYPES_H */
\ No newline at end of file
diff --git a/lib/libc/include/powerpc-linux-any/asm/unistd_32.h b/lib/libc/include/powerpc-linux-any/asm/unistd_32.h
index d794875830988a57e031b7eb1344826dc2a5879d..b633275f5438cd8aa5f82ebf80a0e8791be09517 100644
--- a/lib/libc/include/powerpc-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/powerpc-linux-any/asm/unistd_32.h
@@ -451,6 +451,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/powerpc-linux-any/asm/unistd_64.h b/lib/libc/include/powerpc-linux-any/asm/unistd_64.h
index ff4437c87e62676f018f3da88c4f95d6fbb6cce5..70aae1ef57f3bc07741b9b3a186a948ef7f545fb 100644
--- a/lib/libc/include/powerpc-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/powerpc-linux-any/asm/unistd_64.h
@@ -423,6 +423,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/riscv-linux-any/asm/hwprobe.h b/lib/libc/include/riscv-linux-any/asm/hwprobe.h
index 8d1f367100978642ac94905865f5e024c836f350..a7d9065a569c62c93432ef43e72e219de55da3d3 100644
--- a/lib/libc/include/riscv-linux-any/asm/hwprobe.h
+++ b/lib/libc/include/riscv-linux-any/asm/hwprobe.h
@@ -82,6 +82,11 @@ struct riscv_hwprobe {
 #define		RISCV_HWPROBE_EXT_ZAAMO		(1ULL << 56)
 #define		RISCV_HWPROBE_EXT_ZALRSC	(1ULL << 57)
 #define		RISCV_HWPROBE_EXT_ZABHA		(1ULL << 58)
+#define		RISCV_HWPROBE_EXT_ZALASR	(1ULL << 59)
+#define		RISCV_HWPROBE_EXT_ZICBOP	(1ULL << 60)
+#define		RISCV_HWPROBE_EXT_ZILSD		(1ULL << 61)
+#define		RISCV_HWPROBE_EXT_ZCLSD		(1ULL << 62)
+
 #define RISCV_HWPROBE_KEY_CPUPERF_0	5
 #define		RISCV_HWPROBE_MISALIGNED_UNKNOWN	(0 << 0)
 #define		RISCV_HWPROBE_MISALIGNED_EMULATED	(1 << 0)
@@ -106,6 +111,8 @@ struct riscv_hwprobe {
 #define RISCV_HWPROBE_KEY_VENDOR_EXT_THEAD_0	11
 #define RISCV_HWPROBE_KEY_ZICBOM_BLOCK_SIZE	12
 #define RISCV_HWPROBE_KEY_VENDOR_EXT_SIFIVE_0	13
+#define RISCV_HWPROBE_KEY_VENDOR_EXT_MIPS_0	14
+#define RISCV_HWPROBE_KEY_ZICBOP_BLOCK_SIZE	15
 /* Increase RISCV_HWPROBE_MAX_KEY when adding items. */
 
 /* Flags */
diff --git a/lib/libc/include/riscv-linux-any/asm/kvm.h b/lib/libc/include/riscv-linux-any/asm/kvm.h
index f74aa1ef8ae503ce1d22eef7a9d2bb306f774f91..cddcfc73f04f33ace629c8de9fb4ed0203393596 100644
--- a/lib/libc/include/riscv-linux-any/asm/kvm.h
+++ b/lib/libc/include/riscv-linux-any/asm/kvm.h
@@ -9,7 +9,7 @@
 #ifndef __LINUX_KVM_RISCV_H
 #define __LINUX_KVM_RISCV_H
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 #include <linux/types.h>
 #include <asm/bitsperlong.h>
@@ -23,6 +23,8 @@
 #define KVM_INTERRUPT_SET	-1U
 #define KVM_INTERRUPT_UNSET	-2U
 
+#define KVM_EXIT_FAIL_ENTRY_NO_VSFILE	(1ULL << 0)
+
 /* for KVM_GET_REGS and KVM_SET_REGS */
 struct kvm_regs {
 };
@@ -56,6 +58,7 @@ struct kvm_riscv_config {
 	unsigned long mimpid;
 	unsigned long zicboz_block_size;
 	unsigned long satp_mode;
+	unsigned long zicbop_block_size;
 };
 
 /* CORE registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */
@@ -185,6 +188,10 @@ enum KVM_RISCV_ISA_EXT_ID {
 	KVM_RISCV_ISA_EXT_ZICCRSE,
 	KVM_RISCV_ISA_EXT_ZAAMO,
 	KVM_RISCV_ISA_EXT_ZALRSC,
+	KVM_RISCV_ISA_EXT_ZICBOP,
+	KVM_RISCV_ISA_EXT_ZFBFMIN,
+	KVM_RISCV_ISA_EXT_ZVFBFMIN,
+	KVM_RISCV_ISA_EXT_ZVFBFWMA,
 	KVM_RISCV_ISA_EXT_MAX,
 };
 
@@ -205,6 +212,8 @@ enum KVM_RISCV_SBI_EXT_ID {
 	KVM_RISCV_SBI_EXT_DBCN,
 	KVM_RISCV_SBI_EXT_STA,
 	KVM_RISCV_SBI_EXT_SUSP,
+	KVM_RISCV_SBI_EXT_FWFT,
+	KVM_RISCV_SBI_EXT_MPXY,
 	KVM_RISCV_SBI_EXT_MAX,
 };
 
@@ -214,6 +223,18 @@ struct kvm_riscv_sbi_sta {
 	unsigned long shmem_hi;
 };
 
+struct kvm_riscv_sbi_fwft_feature {
+	unsigned long enable;
+	unsigned long flags;
+	unsigned long value;
+};
+
+/* SBI FWFT extension registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */
+struct kvm_riscv_sbi_fwft {
+	struct kvm_riscv_sbi_fwft_feature misaligned_deleg;
+	struct kvm_riscv_sbi_fwft_feature pointer_masking;
+};
+
 /* Possible states for kvm_riscv_timer */
 #define KVM_RISCV_TIMER_STATE_OFF	0
 #define KVM_RISCV_TIMER_STATE_ON	1
@@ -297,6 +318,9 @@ struct kvm_riscv_sbi_sta {
 #define KVM_REG_RISCV_SBI_STA		(0x0 << KVM_REG_RISCV_SUBTYPE_SHIFT)
 #define KVM_REG_RISCV_SBI_STA_REG(name)		\
 		(offsetof(struct kvm_riscv_sbi_sta, name) / sizeof(unsigned long))
+#define KVM_REG_RISCV_SBI_FWFT		(0x1 << KVM_REG_RISCV_SUBTYPE_SHIFT)
+#define KVM_REG_RISCV_SBI_FWFT_REG(name)	\
+		(offsetof(struct kvm_riscv_sbi_fwft, name) / sizeof(unsigned long))
 
 /* Device Control API: RISC-V AIA */
 #define KVM_DEV_RISCV_APLIC_ALIGN		0x1000
diff --git a/lib/libc/include/riscv-linux-any/asm/ptrace.h b/lib/libc/include/riscv-linux-any/asm/ptrace.h
index 607bb0a8d4502f650ef5142daa6aee99523e6b11..ab55fac5e947b2846b684e90c6d51d1dec553751 100644
--- a/lib/libc/include/riscv-linux-any/asm/ptrace.h
+++ b/lib/libc/include/riscv-linux-any/asm/ptrace.h
@@ -6,7 +6,7 @@
 #ifndef _ASM_RISCV_PTRACE_H
 #define _ASM_RISCV_PTRACE_H
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 #include <linux/types.h>
 
@@ -127,6 +127,6 @@ struct __riscv_v_regset_state {
  */
 #define RISCV_MAX_VLENB (8192)
 
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 #endif /* _ASM_RISCV_PTRACE_H */
\ No newline at end of file
diff --git a/lib/libc/include/riscv-linux-any/asm/sigcontext.h b/lib/libc/include/riscv-linux-any/asm/sigcontext.h
index 2fec9bd5a497bdc3afc6741ddc0e55d10d422522..f134d762a0bc4a3ab603629be2282efc985de577 100644
--- a/lib/libc/include/riscv-linux-any/asm/sigcontext.h
+++ b/lib/libc/include/riscv-linux-any/asm/sigcontext.h
@@ -15,7 +15,7 @@
 /* The size of END signal context header. */
 #define END_HDR_SIZE	0x0
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 struct __sc_riscv_v_state {
 	struct __riscv_v_ext_state v_state;
@@ -35,6 +35,6 @@ struct sigcontext {
 	};
 };
 
-#endif /*!__ASSEMBLY__*/
+#endif /*!__ASSEMBLER__*/
 
 #endif /* _ASM_RISCV_SIGCONTEXT_H */
\ No newline at end of file
diff --git a/lib/libc/include/riscv-linux-any/asm/unistd_32.h b/lib/libc/include/riscv-linux-any/asm/unistd_32.h
index 6681c21a63a8778bbdeb9ea44ae3be611ba87fe5..2bca65239bb37a5dc75f5c443f6db1a363c8c48c 100644
--- a/lib/libc/include/riscv-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/riscv-linux-any/asm/unistd_32.h
@@ -317,6 +317,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/riscv-linux-any/asm/unistd_64.h b/lib/libc/include/riscv-linux-any/asm/unistd_64.h
index 28884c9851e7b6233c3e2bd12c756e83b79255cd..6919b204cc3ab549fd448e5bad427fe818cd4fe7 100644
--- a/lib/libc/include/riscv-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/riscv-linux-any/asm/unistd_64.h
@@ -327,6 +327,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/riscv-linux-any/asm/vendor/mips.h b/lib/libc/include/riscv-linux-any/asm/vendor/mips.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ada02ab13de5b1d2f7d88af83b4267c7f015c9f
--- /dev/null
+++ b/lib/libc/include/riscv-linux-any/asm/vendor/mips.h
@@ -0,0 +1,3 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+
+#define RISCV_HWPROBE_VENDOR_EXT_XMIPSEXECTL	BIT(0)
\ No newline at end of file
diff --git a/lib/libc/include/s390x-linux-any/asm/bitsperlong.h b/lib/libc/include/s390x-linux-any/asm/bitsperlong.h
index a296696bb7077ab1ee35592aae3db62de7d7882b..711368a3ce3c3fb44e96a6ca7ca823182197742e 100644
--- a/lib/libc/include/s390x-linux-any/asm/bitsperlong.h
+++ b/lib/libc/include/s390x-linux-any/asm/bitsperlong.h
@@ -2,11 +2,7 @@
 #ifndef __ASM_S390_BITSPERLONG_H
 #define __ASM_S390_BITSPERLONG_H
 
-#ifndef __s390x__
-#define __BITS_PER_LONG 32
-#else
 #define __BITS_PER_LONG 64
-#endif
 
 #include <asm-generic/bitsperlong.h>
 
diff --git a/lib/libc/include/s390x-linux-any/asm/ipcbuf.h b/lib/libc/include/s390x-linux-any/asm/ipcbuf.h
index 967477874d0542ecf3e918aea603fae9a64456a9..38ddb143df1b2c8f93062d188d5dd86c793cfb58 100644
--- a/lib/libc/include/s390x-linux-any/asm/ipcbuf.h
+++ b/lib/libc/include/s390x-linux-any/asm/ipcbuf.h
@@ -24,9 +24,6 @@ struct ipc64_perm
 	__kernel_mode_t		mode;
 	unsigned short		__pad1;
 	unsigned short		seq;
-#ifndef __s390x__
-	unsigned short		__pad2;
-#endif /* ! __s390x__ */
 	unsigned long		__unused1;
 	unsigned long		__unused2;
 };
diff --git a/lib/libc/include/s390x-linux-any/asm/ipl.h b/lib/libc/include/s390x-linux-any/asm/ipl.h
index 9d9197ba24bec86ee388ccff492acb3f16ff1c36..1af0869dc590540f9c5093491a839bdb25cee850 100644
--- a/lib/libc/include/s390x-linux-any/asm/ipl.h
+++ b/lib/libc/include/s390x-linux-any/asm/ipl.h
@@ -15,6 +15,7 @@ struct ipl_pl_hdr {
 #define IPL_PL_FLAG_IPLPS	0x80
 #define IPL_PL_FLAG_SIPL	0x40
 #define IPL_PL_FLAG_IPLSR	0x20
+#define IPL_PL_FLAG_SBP		0x10
 
 /* IPL Parameter Block header */
 struct ipl_pb_hdr {
diff --git a/lib/libc/include/s390x-linux-any/asm/posix_types.h b/lib/libc/include/s390x-linux-any/asm/posix_types.h
index df0e737305842fa06f8e5e1e7821420b84129f4a..2ce540b400f714727a83f72fec94aefc3c081250 100644
--- a/lib/libc/include/s390x-linux-any/asm/posix_types.h
+++ b/lib/libc/include/s390x-linux-any/asm/posix_types.h
@@ -21,17 +21,6 @@ typedef unsigned short	__kernel_old_dev_t;
 #define __kernel_old_dev_t __kernel_old_dev_t
 
 
-#ifndef __s390x__
-
-typedef unsigned long   __kernel_ino_t;
-typedef unsigned short  __kernel_mode_t;
-typedef unsigned short  __kernel_ipc_pid_t;
-typedef unsigned short  __kernel_uid_t;
-typedef unsigned short  __kernel_gid_t;
-typedef int             __kernel_ptrdiff_t;
-
-#else /* __s390x__ */
-
 typedef unsigned int    __kernel_ino_t;
 typedef unsigned int    __kernel_mode_t;
 typedef int             __kernel_ipc_pid_t;
@@ -40,8 +29,6 @@ typedef unsigned int    __kernel_gid_t;
 typedef long            __kernel_ptrdiff_t;
 typedef unsigned long   __kernel_sigset_t;      /* at least 32 bits */
 
-#endif /* __s390x__ */
-
 #define __kernel_ino_t  __kernel_ino_t
 #define __kernel_mode_t __kernel_mode_t
 #define __kernel_ipc_pid_t __kernel_ipc_pid_t
diff --git a/lib/libc/include/s390x-linux-any/asm/ptrace.h b/lib/libc/include/s390x-linux-any/asm/ptrace.h
index 07f4b9ca3713c65702165fafe9c79193141d12ef..bfe8e69a6787b88e947f1b37d708e9d7e48d0f48 100644
--- a/lib/libc/include/s390x-linux-any/asm/ptrace.h
+++ b/lib/libc/include/s390x-linux-any/asm/ptrace.h
@@ -14,94 +14,6 @@
  * Offsets in the user_regs_struct. They are used for the ptrace
  * system call and in entry.S
  */
-#ifndef __s390x__
-
-#define PT_PSWMASK  0x00
-#define PT_PSWADDR  0x04
-#define PT_GPR0     0x08
-#define PT_GPR1     0x0C
-#define PT_GPR2     0x10
-#define PT_GPR3     0x14
-#define PT_GPR4     0x18
-#define PT_GPR5     0x1C
-#define PT_GPR6     0x20
-#define PT_GPR7     0x24
-#define PT_GPR8     0x28
-#define PT_GPR9     0x2C
-#define PT_GPR10    0x30
-#define PT_GPR11    0x34
-#define PT_GPR12    0x38
-#define PT_GPR13    0x3C
-#define PT_GPR14    0x40
-#define PT_GPR15    0x44
-#define PT_ACR0     0x48
-#define PT_ACR1     0x4C
-#define PT_ACR2     0x50
-#define PT_ACR3     0x54
-#define PT_ACR4	    0x58
-#define PT_ACR5	    0x5C
-#define PT_ACR6	    0x60
-#define PT_ACR7	    0x64
-#define PT_ACR8	    0x68
-#define PT_ACR9	    0x6C
-#define PT_ACR10    0x70
-#define PT_ACR11    0x74
-#define PT_ACR12    0x78
-#define PT_ACR13    0x7C
-#define PT_ACR14    0x80
-#define PT_ACR15    0x84
-#define PT_ORIGGPR2 0x88
-#define PT_FPC	    0x90
-/*
- * A nasty fact of life that the ptrace api
- * only supports passing of longs.
- */
-#define PT_FPR0_HI  0x98
-#define PT_FPR0_LO  0x9C
-#define PT_FPR1_HI  0xA0
-#define PT_FPR1_LO  0xA4
-#define PT_FPR2_HI  0xA8
-#define PT_FPR2_LO  0xAC
-#define PT_FPR3_HI  0xB0
-#define PT_FPR3_LO  0xB4
-#define PT_FPR4_HI  0xB8
-#define PT_FPR4_LO  0xBC
-#define PT_FPR5_HI  0xC0
-#define PT_FPR5_LO  0xC4
-#define PT_FPR6_HI  0xC8
-#define PT_FPR6_LO  0xCC
-#define PT_FPR7_HI  0xD0
-#define PT_FPR7_LO  0xD4
-#define PT_FPR8_HI  0xD8
-#define PT_FPR8_LO  0XDC
-#define PT_FPR9_HI  0xE0
-#define PT_FPR9_LO  0xE4
-#define PT_FPR10_HI 0xE8
-#define PT_FPR10_LO 0xEC
-#define PT_FPR11_HI 0xF0
-#define PT_FPR11_LO 0xF4
-#define PT_FPR12_HI 0xF8
-#define PT_FPR12_LO 0xFC
-#define PT_FPR13_HI 0x100
-#define PT_FPR13_LO 0x104
-#define PT_FPR14_HI 0x108
-#define PT_FPR14_LO 0x10C
-#define PT_FPR15_HI 0x110
-#define PT_FPR15_LO 0x114
-#define PT_CR_9	    0x118
-#define PT_CR_10    0x11C
-#define PT_CR_11    0x120
-#define PT_IEEE_IP  0x13C
-#define PT_LASTOFF  PT_IEEE_IP
-#define PT_ENDREGS  0x140-1
-
-#define GPR_SIZE	4
-#define CR_SIZE		4
-
-#define STACK_FRAME_OVERHEAD	96	/* size of minimum stack frame */
-
-#else /* __s390x__ */
-
 #define PT_PSWMASK  0x00
 #define PT_PSWADDR  0x08
 #define PT_GPR0     0x10
@@ -166,38 +78,6 @@
 
 #define STACK_FRAME_OVERHEAD	160	 /* size of minimum stack frame */
 
-#endif /* __s390x__ */
-
-#ifndef __s390x__
-
-#define PSW_MASK_PER		_AC(0x40000000, UL)
-#define PSW_MASK_DAT		_AC(0x04000000, UL)
-#define PSW_MASK_IO		_AC(0x02000000, UL)
-#define PSW_MASK_EXT		_AC(0x01000000, UL)
-#define PSW_MASK_KEY		_AC(0x00F00000, UL)
-#define PSW_MASK_BASE		_AC(0x00080000, UL)	/* always one */
-#define PSW_MASK_MCHECK		_AC(0x00040000, UL)
-#define PSW_MASK_WAIT		_AC(0x00020000, UL)
-#define PSW_MASK_PSTATE		_AC(0x00010000, UL)
-#define PSW_MASK_ASC		_AC(0x0000C000, UL)
-#define PSW_MASK_CC		_AC(0x00003000, UL)
-#define PSW_MASK_PM		_AC(0x00000F00, UL)
-#define PSW_MASK_RI		_AC(0x00000000, UL)
-#define PSW_MASK_EA		_AC(0x00000000, UL)
-#define PSW_MASK_BA		_AC(0x00000000, UL)
-
-#define PSW_MASK_USER		_AC(0x0000FF00, UL)
-
-#define PSW_ADDR_AMODE		_AC(0x80000000, UL)
-#define PSW_ADDR_INSN		_AC(0x7FFFFFFF, UL)
-
-#define PSW_ASC_PRIMARY		_AC(0x00000000, UL)
-#define PSW_ASC_ACCREG		_AC(0x00004000, UL)
-#define PSW_ASC_SECONDARY	_AC(0x00008000, UL)
-#define PSW_ASC_HOME		_AC(0x0000C000, UL)
-
-#else /* __s390x__ */
-
 #define PSW_MASK_PER		_AC(0x4000000000000000, UL)
 #define PSW_MASK_DAT		_AC(0x0400000000000000, UL)
 #define PSW_MASK_IO		_AC(0x0200000000000000, UL)
@@ -224,8 +104,6 @@
 #define PSW_ASC_SECONDARY	_AC(0x0000800000000000, UL)
 #define PSW_ASC_HOME		_AC(0x0000C00000000000, UL)
 
-#endif /* __s390x__ */
-
 #define NUM_GPRS	16
 #define NUM_FPRS	16
 #define NUM_CRS		16
@@ -308,9 +186,7 @@ typedef struct {
 #define PER_EM_MASK 0xE8000000UL
 
 typedef struct {
-#ifdef __s390x__
 	unsigned		       : 32;
-#endif /* __s390x__ */
 	unsigned em_branching	       : 1;
 	unsigned em_instruction_fetch  : 1;
 	/*
diff --git a/lib/libc/include/s390x-linux-any/asm/sigcontext.h b/lib/libc/include/s390x-linux-any/asm/sigcontext.h
index f6e4f24fbe84acfa22f6c522091d3bebe63302dc..c1580e10e6d2b576d1c70995104381f0726fd314 100644
--- a/lib/libc/include/s390x-linux-any/asm/sigcontext.h
+++ b/lib/libc/include/s390x-linux-any/asm/sigcontext.h
@@ -17,24 +17,12 @@
 #define __NUM_VXRS_LOW		16
 #define __NUM_VXRS_HIGH		16
 
-#ifndef __s390x__
-
-/* Has to be at least _NSIG_WORDS from asm/signal.h */
-#define _SIGCONTEXT_NSIG	64
-#define _SIGCONTEXT_NSIG_BPW	32
-/* Size of stack frame allocated when calling signal handler. */
-#define __SIGNAL_FRAMESIZE	96
-
-#else /* __s390x__ */
-
 /* Has to be at least _NSIG_WORDS from asm/signal.h */
 #define _SIGCONTEXT_NSIG	64
 #define _SIGCONTEXT_NSIG_BPW	64 
 /* Size of stack frame allocated when calling signal handler. */
 #define __SIGNAL_FRAMESIZE	160
 
-#endif /* __s390x__ */
-
 #define _SIGCONTEXT_NSIG_WORDS	(_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
 #define _SIGMASK_COPY_SIZE	(sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
 
@@ -66,9 +54,6 @@ typedef struct
 
 typedef struct
 {
-#ifndef __s390x__
-	unsigned long gprs_high[__NUM_GPRS];
-#endif
 	unsigned long long vxrs_low[__NUM_VXRS_LOW];
 	__vector128 vxrs_high[__NUM_VXRS_HIGH];
 	unsigned char __reserved[128];
diff --git a/lib/libc/include/s390x-linux-any/asm/stat.h b/lib/libc/include/s390x-linux-any/asm/stat.h
index d80b769eb867cf5d8178cf8fb7b792fc59d69952..bc9be64b304cb1b9e8302822dbf2a7519a9dd27e 100644
--- a/lib/libc/include/s390x-linux-any/asm/stat.h
+++ b/lib/libc/include/s390x-linux-any/asm/stat.h
@@ -8,74 +8,6 @@
 #ifndef _S390_STAT_H
 #define _S390_STAT_H
 
-#ifndef __s390x__
-struct __old_kernel_stat {
-        unsigned short st_dev;
-        unsigned short st_ino;
-        unsigned short st_mode;
-        unsigned short st_nlink;
-        unsigned short st_uid;
-        unsigned short st_gid;
-        unsigned short st_rdev;
-        unsigned long  st_size;
-        unsigned long  st_atime;
-        unsigned long  st_mtime;
-        unsigned long  st_ctime;
-};
-
-struct stat {
-        unsigned short st_dev;
-        unsigned short __pad1;
-        unsigned long  st_ino;
-        unsigned short st_mode;
-        unsigned short st_nlink;
-        unsigned short st_uid;
-        unsigned short st_gid;
-        unsigned short st_rdev;
-        unsigned short __pad2;
-        unsigned long  st_size;
-        unsigned long  st_blksize;
-        unsigned long  st_blocks;
-        unsigned long  st_atime;
-        unsigned long  st_atime_nsec;
-        unsigned long  st_mtime;
-        unsigned long  st_mtime_nsec;
-        unsigned long  st_ctime;
-        unsigned long  st_ctime_nsec;
-        unsigned long  __unused4;
-        unsigned long  __unused5;
-};
-
-/* This matches struct stat64 in glibc2.1, hence the absolutely
- * insane amounts of padding around dev_t's.
- */
-struct stat64 {
-        unsigned long long	st_dev;
-        unsigned int    __pad1;
-#define STAT64_HAS_BROKEN_ST_INO        1
-        unsigned long   __st_ino;
-        unsigned int    st_mode;
-        unsigned int    st_nlink;
-        unsigned long   st_uid;
-        unsigned long   st_gid;
-        unsigned long long	st_rdev;
-        unsigned int    __pad3;
-        long long	st_size;
-        unsigned long   st_blksize;
-        unsigned char   __pad4[4];
-        unsigned long   __pad5;     /* future possible st_blocks high bits */
-        unsigned long   st_blocks;  /* Number 512-byte blocks allocated. */
-        unsigned long   st_atime;
-        unsigned long   st_atime_nsec;
-        unsigned long   st_mtime;
-        unsigned long   st_mtime_nsec;
-        unsigned long   st_ctime;
-        unsigned long   st_ctime_nsec;  /* will be high 32 bits of ctime someday */
-        unsigned long long	st_ino;
-};
-
-#else /* __s390x__ */
-
 struct stat {
         unsigned long  st_dev;
         unsigned long  st_ino;
@@ -97,8 +29,6 @@ struct stat {
         unsigned long  __unused[3];
 };
 
-#endif /* __s390x__ */
-
 #define STAT_HAVE_NSEC 1
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/s390x-linux-any/asm/unistd.h b/lib/libc/include/s390x-linux-any/asm/unistd.h
index ff8aef3f465d1c88daf7c96fc1060fab9a71972f..e8427e563278b472a99a4c603d56c47a393cc1f9 100644
--- a/lib/libc/include/s390x-linux-any/asm/unistd.h
+++ b/lib/libc/include/s390x-linux-any/asm/unistd.h
@@ -8,10 +8,6 @@
 #ifndef _ASM_S390_UNISTD_H_
 #define _ASM_S390_UNISTD_H_
 
-#ifdef __s390x__
 #include <asm/unistd_64.h>
-#else
-#include <asm/unistd_32.h>
-#endif
 
 #endif /* _ASM_S390_UNISTD_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/s390x-linux-any/asm/unistd_32.h b/lib/libc/include/s390x-linux-any/asm/unistd_32.h
deleted file mode 100644
index c7af1845622ece28a70512781b4d14d7a4157328..0000000000000000000000000000000000000000
--- a/lib/libc/include/s390x-linux-any/asm/unistd_32.h
+++ /dev/null
@@ -1,446 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-#ifndef _ASM_S390_UNISTD_32_H
-#define _ASM_S390_UNISTD_32_H
-
-#define __NR_exit 1
-#define __NR_fork 2
-#define __NR_read 3
-#define __NR_write 4
-#define __NR_open 5
-#define __NR_close 6
-#define __NR_restart_syscall 7
-#define __NR_creat 8
-#define __NR_link 9
-#define __NR_unlink 10
-#define __NR_execve 11
-#define __NR_chdir 12
-#define __NR_time 13
-#define __NR_mknod 14
-#define __NR_chmod 15
-#define __NR_lchown 16
-#define __NR_lseek 19
-#define __NR_getpid 20
-#define __NR_mount 21
-#define __NR_umount 22
-#define __NR_setuid 23
-#define __NR_getuid 24
-#define __NR_stime 25
-#define __NR_ptrace 26
-#define __NR_alarm 27
-#define __NR_pause 29
-#define __NR_utime 30
-#define __NR_access 33
-#define __NR_nice 34
-#define __NR_sync 36
-#define __NR_kill 37
-#define __NR_rename 38
-#define __NR_mkdir 39
-#define __NR_rmdir 40
-#define __NR_dup 41
-#define __NR_pipe 42
-#define __NR_times 43
-#define __NR_brk 45
-#define __NR_setgid 46
-#define __NR_getgid 47
-#define __NR_signal 48
-#define __NR_geteuid 49
-#define __NR_getegid 50
-#define __NR_acct 51
-#define __NR_umount2 52
-#define __NR_ioctl 54
-#define __NR_fcntl 55
-#define __NR_setpgid 57
-#define __NR_umask 60
-#define __NR_chroot 61
-#define __NR_ustat 62
-#define __NR_dup2 63
-#define __NR_getppid 64
-#define __NR_getpgrp 65
-#define __NR_setsid 66
-#define __NR_sigaction 67
-#define __NR_setreuid 70
-#define __NR_setregid 71
-#define __NR_sigsuspend 72
-#define __NR_sigpending 73
-#define __NR_sethostname 74
-#define __NR_setrlimit 75
-#define __NR_getrlimit 76
-#define __NR_getrusage 77
-#define __NR_gettimeofday 78
-#define __NR_settimeofday 79
-#define __NR_getgroups 80
-#define __NR_setgroups 81
-#define __NR_symlink 83
-#define __NR_readlink 85
-#define __NR_uselib 86
-#define __NR_swapon 87
-#define __NR_reboot 88
-#define __NR_readdir 89
-#define __NR_mmap 90
-#define __NR_munmap 91
-#define __NR_truncate 92
-#define __NR_ftruncate 93
-#define __NR_fchmod 94
-#define __NR_fchown 95
-#define __NR_getpriority 96
-#define __NR_setpriority 97
-#define __NR_statfs 99
-#define __NR_fstatfs 100
-#define __NR_ioperm 101
-#define __NR_socketcall 102
-#define __NR_syslog 103
-#define __NR_setitimer 104
-#define __NR_getitimer 105
-#define __NR_stat 106
-#define __NR_lstat 107
-#define __NR_fstat 108
-#define __NR_lookup_dcookie 110
-#define __NR_vhangup 111
-#define __NR_idle 112
-#define __NR_wait4 114
-#define __NR_swapoff 115
-#define __NR_sysinfo 116
-#define __NR_ipc 117
-#define __NR_fsync 118
-#define __NR_sigreturn 119
-#define __NR_clone 120
-#define __NR_setdomainname 121
-#define __NR_uname 122
-#define __NR_adjtimex 124
-#define __NR_mprotect 125
-#define __NR_sigprocmask 126
-#define __NR_create_module 127
-#define __NR_init_module 128
-#define __NR_delete_module 129
-#define __NR_get_kernel_syms 130
-#define __NR_quotactl 131
-#define __NR_getpgid 132
-#define __NR_fchdir 133
-#define __NR_bdflush 134
-#define __NR_sysfs 135
-#define __NR_personality 136
-#define __NR_afs_syscall 137
-#define __NR_setfsuid 138
-#define __NR_setfsgid 139
-#define __NR__llseek 140
-#define __NR_getdents 141
-#define __NR__newselect 142
-#define __NR_flock 143
-#define __NR_msync 144
-#define __NR_readv 145
-#define __NR_writev 146
-#define __NR_getsid 147
-#define __NR_fdatasync 148
-#define __NR__sysctl 149
-#define __NR_mlock 150
-#define __NR_munlock 151
-#define __NR_mlockall 152
-#define __NR_munlockall 153
-#define __NR_sched_setparam 154
-#define __NR_sched_getparam 155
-#define __NR_sched_setscheduler 156
-#define __NR_sched_getscheduler 157
-#define __NR_sched_yield 158
-#define __NR_sched_get_priority_max 159
-#define __NR_sched_get_priority_min 160
-#define __NR_sched_rr_get_interval 161
-#define __NR_nanosleep 162
-#define __NR_mremap 163
-#define __NR_setresuid 164
-#define __NR_getresuid 165
-#define __NR_query_module 167
-#define __NR_poll 168
-#define __NR_nfsservctl 169
-#define __NR_setresgid 170
-#define __NR_getresgid 171
-#define __NR_prctl 172
-#define __NR_rt_sigreturn 173
-#define __NR_rt_sigaction 174
-#define __NR_rt_sigprocmask 175
-#define __NR_rt_sigpending 176
-#define __NR_rt_sigtimedwait 177
-#define __NR_rt_sigqueueinfo 178
-#define __NR_rt_sigsuspend 179
-#define __NR_pread64 180
-#define __NR_pwrite64 181
-#define __NR_chown 182
-#define __NR_getcwd 183
-#define __NR_capget 184
-#define __NR_capset 185
-#define __NR_sigaltstack 186
-#define __NR_sendfile 187
-#define __NR_getpmsg 188
-#define __NR_putpmsg 189
-#define __NR_vfork 190
-#define __NR_ugetrlimit 191
-#define __NR_mmap2 192
-#define __NR_truncate64 193
-#define __NR_ftruncate64 194
-#define __NR_stat64 195
-#define __NR_lstat64 196
-#define __NR_fstat64 197
-#define __NR_lchown32 198
-#define __NR_getuid32 199
-#define __NR_getgid32 200
-#define __NR_geteuid32 201
-#define __NR_getegid32 202
-#define __NR_setreuid32 203
-#define __NR_setregid32 204
-#define __NR_getgroups32 205
-#define __NR_setgroups32 206
-#define __NR_fchown32 207
-#define __NR_setresuid32 208
-#define __NR_getresuid32 209
-#define __NR_setresgid32 210
-#define __NR_getresgid32 211
-#define __NR_chown32 212
-#define __NR_setuid32 213
-#define __NR_setgid32 214
-#define __NR_setfsuid32 215
-#define __NR_setfsgid32 216
-#define __NR_pivot_root 217
-#define __NR_mincore 218
-#define __NR_madvise 219
-#define __NR_getdents64 220
-#define __NR_fcntl64 221
-#define __NR_readahead 222
-#define __NR_sendfile64 223
-#define __NR_setxattr 224
-#define __NR_lsetxattr 225
-#define __NR_fsetxattr 226
-#define __NR_getxattr 227
-#define __NR_lgetxattr 228
-#define __NR_fgetxattr 229
-#define __NR_listxattr 230
-#define __NR_llistxattr 231
-#define __NR_flistxattr 232
-#define __NR_removexattr 233
-#define __NR_lremovexattr 234
-#define __NR_fremovexattr 235
-#define __NR_gettid 236
-#define __NR_tkill 237
-#define __NR_futex 238
-#define __NR_sched_setaffinity 239
-#define __NR_sched_getaffinity 240
-#define __NR_tgkill 241
-#define __NR_io_setup 243
-#define __NR_io_destroy 244
-#define __NR_io_getevents 245
-#define __NR_io_submit 246
-#define __NR_io_cancel 247
-#define __NR_exit_group 248
-#define __NR_epoll_create 249
-#define __NR_epoll_ctl 250
-#define __NR_epoll_wait 251
-#define __NR_set_tid_address 252
-#define __NR_fadvise64 253
-#define __NR_timer_create 254
-#define __NR_timer_settime 255
-#define __NR_timer_gettime 256
-#define __NR_timer_getoverrun 257
-#define __NR_timer_delete 258
-#define __NR_clock_settime 259
-#define __NR_clock_gettime 260
-#define __NR_clock_getres 261
-#define __NR_clock_nanosleep 262
-#define __NR_fadvise64_64 264
-#define __NR_statfs64 265
-#define __NR_fstatfs64 266
-#define __NR_remap_file_pages 267
-#define __NR_mbind 268
-#define __NR_get_mempolicy 269
-#define __NR_set_mempolicy 270
-#define __NR_mq_open 271
-#define __NR_mq_unlink 272
-#define __NR_mq_timedsend 273
-#define __NR_mq_timedreceive 274
-#define __NR_mq_notify 275
-#define __NR_mq_getsetattr 276
-#define __NR_kexec_load 277
-#define __NR_add_key 278
-#define __NR_request_key 279
-#define __NR_keyctl 280
-#define __NR_waitid 281
-#define __NR_ioprio_set 282
-#define __NR_ioprio_get 283
-#define __NR_inotify_init 284
-#define __NR_inotify_add_watch 285
-#define __NR_inotify_rm_watch 286
-#define __NR_migrate_pages 287
-#define __NR_openat 288
-#define __NR_mkdirat 289
-#define __NR_mknodat 290
-#define __NR_fchownat 291
-#define __NR_futimesat 292
-#define __NR_fstatat64 293
-#define __NR_unlinkat 294
-#define __NR_renameat 295
-#define __NR_linkat 296
-#define __NR_symlinkat 297
-#define __NR_readlinkat 298
-#define __NR_fchmodat 299
-#define __NR_faccessat 300
-#define __NR_pselect6 301
-#define __NR_ppoll 302
-#define __NR_unshare 303
-#define __NR_set_robust_list 304
-#define __NR_get_robust_list 305
-#define __NR_splice 306
-#define __NR_sync_file_range 307
-#define __NR_tee 308
-#define __NR_vmsplice 309
-#define __NR_move_pages 310
-#define __NR_getcpu 311
-#define __NR_epoll_pwait 312
-#define __NR_utimes 313
-#define __NR_fallocate 314
-#define __NR_utimensat 315
-#define __NR_signalfd 316
-#define __NR_timerfd 317
-#define __NR_eventfd 318
-#define __NR_timerfd_create 319
-#define __NR_timerfd_settime 320
-#define __NR_timerfd_gettime 321
-#define __NR_signalfd4 322
-#define __NR_eventfd2 323
-#define __NR_inotify_init1 324
-#define __NR_pipe2 325
-#define __NR_dup3 326
-#define __NR_epoll_create1 327
-#define __NR_preadv 328
-#define __NR_pwritev 329
-#define __NR_rt_tgsigqueueinfo 330
-#define __NR_perf_event_open 331
-#define __NR_fanotify_init 332
-#define __NR_fanotify_mark 333
-#define __NR_prlimit64 334
-#define __NR_name_to_handle_at 335
-#define __NR_open_by_handle_at 336
-#define __NR_clock_adjtime 337
-#define __NR_syncfs 338
-#define __NR_setns 339
-#define __NR_process_vm_readv 340
-#define __NR_process_vm_writev 341
-#define __NR_s390_runtime_instr 342
-#define __NR_kcmp 343
-#define __NR_finit_module 344
-#define __NR_sched_setattr 345
-#define __NR_sched_getattr 346
-#define __NR_renameat2 347
-#define __NR_seccomp 348
-#define __NR_getrandom 349
-#define __NR_memfd_create 350
-#define __NR_bpf 351
-#define __NR_s390_pci_mmio_write 352
-#define __NR_s390_pci_mmio_read 353
-#define __NR_execveat 354
-#define __NR_userfaultfd 355
-#define __NR_membarrier 356
-#define __NR_recvmmsg 357
-#define __NR_sendmmsg 358
-#define __NR_socket 359
-#define __NR_socketpair 360
-#define __NR_bind 361
-#define __NR_connect 362
-#define __NR_listen 363
-#define __NR_accept4 364
-#define __NR_getsockopt 365
-#define __NR_setsockopt 366
-#define __NR_getsockname 367
-#define __NR_getpeername 368
-#define __NR_sendto 369
-#define __NR_sendmsg 370
-#define __NR_recvfrom 371
-#define __NR_recvmsg 372
-#define __NR_shutdown 373
-#define __NR_mlock2 374
-#define __NR_copy_file_range 375
-#define __NR_preadv2 376
-#define __NR_pwritev2 377
-#define __NR_s390_guarded_storage 378
-#define __NR_statx 379
-#define __NR_s390_sthyi 380
-#define __NR_kexec_file_load 381
-#define __NR_io_pgetevents 382
-#define __NR_rseq 383
-#define __NR_pkey_mprotect 384
-#define __NR_pkey_alloc 385
-#define __NR_pkey_free 386
-#define __NR_semget 393
-#define __NR_semctl 394
-#define __NR_shmget 395
-#define __NR_shmctl 396
-#define __NR_shmat 397
-#define __NR_shmdt 398
-#define __NR_msgget 399
-#define __NR_msgsnd 400
-#define __NR_msgrcv 401
-#define __NR_msgctl 402
-#define __NR_clock_gettime64 403
-#define __NR_clock_settime64 404
-#define __NR_clock_adjtime64 405
-#define __NR_clock_getres_time64 406
-#define __NR_clock_nanosleep_time64 407
-#define __NR_timer_gettime64 408
-#define __NR_timer_settime64 409
-#define __NR_timerfd_gettime64 410
-#define __NR_timerfd_settime64 411
-#define __NR_utimensat_time64 412
-#define __NR_pselect6_time64 413
-#define __NR_ppoll_time64 414
-#define __NR_io_pgetevents_time64 416
-#define __NR_recvmmsg_time64 417
-#define __NR_mq_timedsend_time64 418
-#define __NR_mq_timedreceive_time64 419
-#define __NR_semtimedop_time64 420
-#define __NR_rt_sigtimedwait_time64 421
-#define __NR_futex_time64 422
-#define __NR_sched_rr_get_interval_time64 423
-#define __NR_pidfd_send_signal 424
-#define __NR_io_uring_setup 425
-#define __NR_io_uring_enter 426
-#define __NR_io_uring_register 427
-#define __NR_open_tree 428
-#define __NR_move_mount 429
-#define __NR_fsopen 430
-#define __NR_fsconfig 431
-#define __NR_fsmount 432
-#define __NR_fspick 433
-#define __NR_pidfd_open 434
-#define __NR_clone3 435
-#define __NR_close_range 436
-#define __NR_openat2 437
-#define __NR_pidfd_getfd 438
-#define __NR_faccessat2 439
-#define __NR_process_madvise 440
-#define __NR_epoll_pwait2 441
-#define __NR_mount_setattr 442
-#define __NR_quotactl_fd 443
-#define __NR_landlock_create_ruleset 444
-#define __NR_landlock_add_rule 445
-#define __NR_landlock_restrict_self 446
-#define __NR_memfd_secret 447
-#define __NR_process_mrelease 448
-#define __NR_futex_waitv 449
-#define __NR_set_mempolicy_home_node 450
-#define __NR_cachestat 451
-#define __NR_fchmodat2 452
-#define __NR_map_shadow_stack 453
-#define __NR_futex_wake 454
-#define __NR_futex_wait 455
-#define __NR_futex_requeue 456
-#define __NR_statmount 457
-#define __NR_listmount 458
-#define __NR_lsm_get_self_attr 459
-#define __NR_lsm_set_self_attr 460
-#define __NR_lsm_list_modules 461
-#define __NR_mseal 462
-#define __NR_setxattrat 463
-#define __NR_getxattrat 464
-#define __NR_listxattrat 465
-#define __NR_removexattrat 466
-#define __NR_open_tree_attr 467
-#define __NR_file_getattr 468
-#define __NR_file_setattr 469
-
-#endif /* _ASM_S390_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/s390x-linux-any/asm/unistd_64.h b/lib/libc/include/s390x-linux-any/asm/unistd_64.h
index e529dad8b0134dd5236925e82de827d172354a18..bbb2740f95424be5708c7a90d3b08b3ca05ea77e 100644
--- a/lib/libc/include/s390x-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/s390x-linux-any/asm/unistd_64.h
@@ -1,6 +1,5 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-#ifndef _ASM_S390_UNISTD_64_H
-#define _ASM_S390_UNISTD_64_H
+#ifndef _ASM_UNISTD_64_H
+#define _ASM_UNISTD_64_H
 
 #define __NR_exit 1
 #define __NR_fork 2
@@ -390,5 +389,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
-#endif /* _ASM_S390_UNISTD_64_H */
\ No newline at end of file
+
+#endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/sparc-linux-any/asm/ptrace.h b/lib/libc/include/sparc-linux-any/asm/ptrace.h
index 7035096cd50eaa378dbde7544778dc4521b3553c..c596b810f44c3ac0e8c73fd526afad107e652949 100644
--- a/lib/libc/include/sparc-linux-any/asm/ptrace.h
+++ b/lib/libc/include/sparc-linux-any/asm/ptrace.h
@@ -15,7 +15,7 @@
  */
 #define PT_REGS_MAGIC 0x57ac6c00
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 #include <linux/types.h>
 
@@ -88,7 +88,7 @@ struct sparc_trapf {
 	unsigned long _unused;
 	struct pt_regs *regs;
 };
-#endif /* (!__ASSEMBLY__) */
+#endif /* (!__ASSEMBLER__) */
 #else
 /* 32 bit sparc */
 
@@ -97,7 +97,7 @@ struct sparc_trapf {
 /* This struct defines the way the registers are stored on the
  * stack during a system call and basically all traps.
  */
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 #include <linux/types.h>
 
@@ -125,11 +125,11 @@ struct sparc_stackf {
 	unsigned long xargs[6];
 	unsigned long xxargs[1];
 };
-#endif /* (!__ASSEMBLY__) */
+#endif /* (!__ASSEMBLER__) */
 
 #endif /* (defined(__sparc__) && defined(__arch64__))*/
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 #define TRACEREG_SZ	sizeof(struct pt_regs)
 #define STACKFRAME_SZ	sizeof(struct sparc_stackf)
@@ -137,7 +137,7 @@ struct sparc_stackf {
 #define TRACEREG32_SZ	sizeof(struct pt_regs32)
 #define STACKFRAME32_SZ	sizeof(struct sparc_stackf32)
 
-#endif /* (!__ASSEMBLY__) */
+#endif /* (!__ASSEMBLER__) */
 
 #define UREG_G0        0
 #define UREG_G1        1
@@ -161,30 +161,30 @@ struct sparc_stackf {
 #if defined(__sparc__) && defined(__arch64__)
 /* 64 bit sparc */
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 
-#else /* __ASSEMBLY__ */
+#else /* __ASSEMBLER__ */
 /* For assembly code. */
 #define TRACEREG_SZ		0xa0
 #define STACKFRAME_SZ		0xc0
 
 #define TRACEREG32_SZ		0x50
 #define STACKFRAME32_SZ		0x60
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 #else /* (defined(__sparc__) && defined(__arch64__)) */
 
 /* 32 bit sparc */
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 
-#else /* (!__ASSEMBLY__) */
+#else /* (!__ASSEMBLER__) */
 /* For assembly code. */
 #define TRACEREG_SZ       0x50
 #define STACKFRAME_SZ     0x60
-#endif /* (!__ASSEMBLY__) */
+#endif /* (!__ASSEMBLER__) */
 
 #endif /* (defined(__sparc__) && defined(__arch64__)) */
 
diff --git a/lib/libc/include/sparc-linux-any/asm/signal.h b/lib/libc/include/sparc-linux-any/asm/signal.h
index cf7a24e53182b192ca7101071e8f905a969ff6b5..68db2d506d6d6f83724eb5065f13a44d61b8d84d 100644
--- a/lib/libc/include/sparc-linux-any/asm/signal.h
+++ b/lib/libc/include/sparc-linux-any/asm/signal.h
@@ -105,7 +105,7 @@
 #define __old_sigaction32	sigaction32
 #endif
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 
 typedef unsigned long __old_sigset_t;            /* at least 32 bits */
 
@@ -174,6 +174,6 @@ typedef struct sigaltstack {
 } stack_t;
 
 
-#endif /* !(__ASSEMBLY__) */
+#endif /* !(__ASSEMBLER__) */
 
 #endif /* __SPARC_SIGNAL_H */
\ No newline at end of file
diff --git a/lib/libc/include/sparc-linux-any/asm/traps.h b/lib/libc/include/sparc-linux-any/asm/traps.h
index f8ea8f6cfb14af5de03c457622c12edcb85e26ff..15dc6894fa62737cc4771a92cb1acb5b0a793d69 100644
--- a/lib/libc/include/sparc-linux-any/asm/traps.h
+++ b/lib/libc/include/sparc-linux-any/asm/traps.h
@@ -10,8 +10,8 @@
 
 #define NUM_SPARC_TRAPS  255
 
-#ifndef __ASSEMBLY__
-#endif /* !(__ASSEMBLY__) */
+#ifndef __ASSEMBLER__
+#endif /* !(__ASSEMBLER__) */
 
 /* For patching the trap table at boot time, we need to know how to
  * form various common Sparc instructions.  Thus these macros...
diff --git a/lib/libc/include/sparc-linux-any/asm/unistd_32.h b/lib/libc/include/sparc-linux-any/asm/unistd_32.h
index c800914ee31dd4068011f36b4730008dbcef5f03..7a72b432c92c983192273206cdc08fd3d8e797f3 100644
--- a/lib/libc/include/sparc-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/sparc-linux-any/asm/unistd_32.h
@@ -439,6 +439,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/sparc-linux-any/asm/unistd_64.h b/lib/libc/include/sparc-linux-any/asm/unistd_64.h
index cd8586e657ab37139503076630f19bd9fcc3dc56..7509b1c69dfcfb2b341f313fba9a7668ee44a0d2 100644
--- a/lib/libc/include/sparc-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/sparc-linux-any/asm/unistd_64.h
@@ -402,6 +402,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/sparc-linux-any/asm/utrap.h b/lib/libc/include/sparc-linux-any/asm/utrap.h
index 4bc0f926b31ea629b30a2564dd4ec0e314dcdfef..1b1bedbe2179bd5783559391b4d323d643b0c518 100644
--- a/lib/libc/include/sparc-linux-any/asm/utrap.h
+++ b/lib/libc/include/sparc-linux-any/asm/utrap.h
@@ -44,9 +44,9 @@
 
 #define	UTH_NOCHANGE				(-1)
 
-#ifndef __ASSEMBLY__
+#ifndef __ASSEMBLER__
 typedef int utrap_entry_t;
 typedef void *utrap_handler_t;
-#endif /* __ASSEMBLY__ */
+#endif /* __ASSEMBLER__ */
 
 #endif /* !(__ASM_SPARC64_PROCESSOR_H) */
\ No newline at end of file
diff --git a/lib/libc/include/x86-linux-any/asm/kvm.h b/lib/libc/include/x86-linux-any/asm/kvm.h
index caf6af2ea14181419652d5b0fcbc9f514db5f3a3..39dc18a9d22ab5c4e230a491ced38f0f8d6a2868 100644
--- a/lib/libc/include/x86-linux-any/asm/kvm.h
+++ b/lib/libc/include/x86-linux-any/asm/kvm.h
@@ -35,6 +35,11 @@
 #define MC_VECTOR 18
 #define XM_VECTOR 19
 #define VE_VECTOR 20
+#define CP_VECTOR 21
+
+#define HV_VECTOR 28
+#define VC_VECTOR 29
+#define SX_VECTOR 30
 
 /* Select x86 specific features in <linux/kvm.h> */
 #define __KVM_HAVE_PIT
@@ -409,6 +414,35 @@ struct kvm_xcrs {
 	__u64 padding[16];
 };
 
+#define KVM_X86_REG_TYPE_MSR		2
+#define KVM_X86_REG_TYPE_KVM		3
+
+#define KVM_X86_KVM_REG_SIZE(reg)						\
+({										\
+	reg == KVM_REG_GUEST_SSP ? KVM_REG_SIZE_U64 : 0;			\
+})
+
+#define KVM_X86_REG_TYPE_SIZE(type, reg)					\
+({										\
+	__u64 type_size = (__u64)type << 32;					\
+										\
+	type_size |= type == KVM_X86_REG_TYPE_MSR ? KVM_REG_SIZE_U64 :		\
+		     type == KVM_X86_REG_TYPE_KVM ? KVM_X86_KVM_REG_SIZE(reg) :	\
+		     0;								\
+	type_size;								\
+})
+
+#define KVM_X86_REG_ID(type, index)				\
+	(KVM_REG_X86 | KVM_X86_REG_TYPE_SIZE(type, index) | index)
+
+#define KVM_X86_REG_MSR(index)					\
+	KVM_X86_REG_ID(KVM_X86_REG_TYPE_MSR, index)
+#define KVM_X86_REG_KVM(index)					\
+	KVM_X86_REG_ID(KVM_X86_REG_TYPE_KVM, index)
+
+/* KVM-defined registers starting from 0 */
+#define KVM_REG_GUEST_SSP	0
+
 #define KVM_SYNC_X86_REGS      (1UL << 0)
 #define KVM_SYNC_X86_SREGS     (1UL << 1)
 #define KVM_SYNC_X86_EVENTS    (1UL << 2)
@@ -466,6 +500,7 @@ struct kvm_sync_regs {
 /* vendor-specific groups and attributes for system fd */
 #define KVM_X86_GRP_SEV			1
 #  define KVM_X86_SEV_VMSA_FEATURES	0
+#  define KVM_X86_SNP_POLICY_BITS	1
 
 struct kvm_vmx_nested_state_data {
 	__u8 vmcs12[KVM_STATE_NESTED_VMX_VMCS_SIZE];
diff --git a/lib/libc/include/x86-linux-any/asm/processor-flags.h b/lib/libc/include/x86-linux-any/asm/processor-flags.h
index ea4a94f6374c32f676b5491b66fe7b983065b25c..a84acbaf3d5a4389d63d3cee3d8b75bdff5a08aa 100644
--- a/lib/libc/include/x86-linux-any/asm/processor-flags.h
+++ b/lib/libc/include/x86-linux-any/asm/processor-flags.h
@@ -136,6 +136,8 @@
 #define X86_CR4_PKE		_BITUL(X86_CR4_PKE_BIT)
 #define X86_CR4_CET_BIT		23 /* enable Control-flow Enforcement Technology */
 #define X86_CR4_CET		_BITUL(X86_CR4_CET_BIT)
+#define X86_CR4_LASS_BIT	27 /* enable Linear Address Space Separation support */
+#define X86_CR4_LASS		_BITUL(X86_CR4_LASS_BIT)
 #define X86_CR4_LAM_SUP_BIT	28 /* LAM for supervisor pointers */
 #define X86_CR4_LAM_SUP		_BITUL(X86_CR4_LAM_SUP_BIT)
 
diff --git a/lib/libc/include/x86-linux-any/asm/sgx.h b/lib/libc/include/x86-linux-any/asm/sgx.h
index e5339772ed61fb76c7b20ea92c399100f641a482..96f549676e8f4181e7b0a79b8266bed2fa6932c2 100644
--- a/lib/libc/include/x86-linux-any/asm/sgx.h
+++ b/lib/libc/include/x86-linux-any/asm/sgx.h
@@ -10,7 +10,7 @@
 
 /**
  * enum sgx_page_flags - page control flags
- * %SGX_PAGE_MEASURE:	Measure the page contents with a sequence of
+ * @SGX_PAGE_MEASURE:	Measure the page contents with a sequence of
  *			ENCLS[EEXTEND] operations.
  */
 enum sgx_page_flags {
@@ -143,6 +143,12 @@ struct sgx_enclave_run;
 /**
  * typedef sgx_enclave_user_handler_t - Exit handler function accepted by
  *					__vdso_sgx_enter_enclave()
+ * @rdi:	RDI at the time of EEXIT, undefined on AEX
+ * @rsi:	RSI at the time of EEXIT, undefined on AEX
+ * @rdx:	RDX at the time of EEXIT, undefined on AEX
+ * @rsp:	RSP (untrusted) at the time of EEXIT or AEX
+ * @r8:		R8 at the time of EEXIT, undefined on AEX
+ * @r9:		R9 at the time of EEXIT, undefined on AEX
  * @run:	The run instance given by the caller
  *
  * The register parameters contain the snapshot of their values at enclave
@@ -166,7 +172,7 @@ typedef int (*sgx_enclave_user_handler_t)(long rdi, long rsi, long rdx,
  * @exception_addr:		The address that triggered the exception
  * @user_handler:		User provided callback run on exception
  * @user_data:			Data passed to the user handler
- * @reserved			Reserved for future extensions
+ * @reserved:			Reserved for future extensions
  *
  * If @user_handler is provided, the handler will be invoked on all return paths
  * of the normal flow.  The user handler may transfer control, e.g. via a
diff --git a/lib/libc/include/x86-linux-any/asm/svm.h b/lib/libc/include/x86-linux-any/asm/svm.h
index 38b353cb688fa041946e0685a68ee17e798ea251..eedc7f29f43c32ad0f373d21e512e9b81438c6a9 100644
--- a/lib/libc/include/x86-linux-any/asm/svm.h
+++ b/lib/libc/include/x86-linux-any/asm/svm.h
@@ -118,6 +118,10 @@
 #define SVM_VMGEXIT_AP_CREATE			1
 #define SVM_VMGEXIT_AP_DESTROY			2
 #define SVM_VMGEXIT_SNP_RUN_VMPL		0x80000018
+#define SVM_VMGEXIT_SAVIC			0x8000001a
+#define SVM_VMGEXIT_SAVIC_REGISTER_GPA		0
+#define SVM_VMGEXIT_SAVIC_UNREGISTER_GPA	1
+#define SVM_VMGEXIT_SAVIC_SELF_GPA		~0ULL
 #define SVM_VMGEXIT_HV_FEATURES			0x8000fffd
 #define SVM_VMGEXIT_TERM_REQUEST		0x8000fffe
 #define SVM_VMGEXIT_TERM_REASON(reason_set, reason_code)	\
diff --git a/lib/libc/include/x86-linux-any/asm/unistd_32.h b/lib/libc/include/x86-linux-any/asm/unistd_32.h
index 92b6fe12b9a1a4f7ba86460ab013d93cdf34e49e..7657717b820a9f3e90728afd2f947f87fcde171d 100644
--- a/lib/libc/include/x86-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/x86-linux-any/asm/unistd_32.h
@@ -460,6 +460,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86-linux-any/asm/unistd_64.h b/lib/libc/include/x86-linux-any/asm/unistd_64.h
index aa4a20ca85c0ba5d4b093494571f602a04b86676..a2878fea0dcb42feb56a0f76ae8f49f7e5149f79 100644
--- a/lib/libc/include/x86-linux-any/asm/unistd_64.h
+++ b/lib/libc/include/x86-linux-any/asm/unistd_64.h
@@ -337,6 +337,7 @@
 #define __NR_io_pgetevents 333
 #define __NR_rseq 334
 #define __NR_uretprobe 335
+#define __NR_uprobe 336
 #define __NR_pidfd_send_signal 424
 #define __NR_io_uring_setup 425
 #define __NR_io_uring_enter 426
@@ -383,6 +384,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_64_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86-linux-any/asm/unistd_x32.h b/lib/libc/include/x86-linux-any/asm/unistd_x32.h
index 56845ed56c0d8d418173f97172ee0e20ad5e1f1a..70e4dab3024d965d4afb27685c6ef5d23062be2b 100644
--- a/lib/libc/include/x86-linux-any/asm/unistd_x32.h
+++ b/lib/libc/include/x86-linux-any/asm/unistd_x32.h
@@ -290,6 +290,7 @@
 #define __NR_io_pgetevents (__X32_SYSCALL_BIT + 333)
 #define __NR_rseq (__X32_SYSCALL_BIT + 334)
 #define __NR_uretprobe (__X32_SYSCALL_BIT + 335)
+#define __NR_uprobe (__X32_SYSCALL_BIT + 336)
 #define __NR_pidfd_send_signal (__X32_SYSCALL_BIT + 424)
 #define __NR_io_uring_setup (__X32_SYSCALL_BIT + 425)
 #define __NR_io_uring_enter (__X32_SYSCALL_BIT + 426)
@@ -336,6 +337,7 @@
 #define __NR_open_tree_attr (__X32_SYSCALL_BIT + 467)
 #define __NR_file_getattr (__X32_SYSCALL_BIT + 468)
 #define __NR_file_setattr (__X32_SYSCALL_BIT + 469)
+#define __NR_listns (__X32_SYSCALL_BIT + 470)
 #define __NR_rt_sigaction (__X32_SYSCALL_BIT + 512)
 #define __NR_rt_sigreturn (__X32_SYSCALL_BIT + 513)
 #define __NR_ioctl (__X32_SYSCALL_BIT + 514)
diff --git a/lib/libc/include/x86-linux-any/asm/vmx.h b/lib/libc/include/x86-linux-any/asm/vmx.h
index 252e469b73fe7d5be01887ca6e34d569bd5a8feb..e1e6afa2b32a12602a0e1767a0e428024626879d 100644
--- a/lib/libc/include/x86-linux-any/asm/vmx.h
+++ b/lib/libc/include/x86-linux-any/asm/vmx.h
@@ -93,7 +93,10 @@
 #define EXIT_REASON_TPAUSE              68
 #define EXIT_REASON_BUS_LOCK            74
 #define EXIT_REASON_NOTIFY              75
+#define EXIT_REASON_SEAMCALL            76
 #define EXIT_REASON_TDCALL              77
+#define EXIT_REASON_MSR_READ_IMM        84
+#define EXIT_REASON_MSR_WRITE_IMM       85
 
 #define VMX_EXIT_REASONS \
 	{ EXIT_REASON_EXCEPTION_NMI,         "EXCEPTION_NMI" }, \
@@ -158,7 +161,9 @@
 	{ EXIT_REASON_TPAUSE,                "TPAUSE" }, \
 	{ EXIT_REASON_BUS_LOCK,              "BUS_LOCK" }, \
 	{ EXIT_REASON_NOTIFY,                "NOTIFY" }, \
-	{ EXIT_REASON_TDCALL,                "TDCALL" }
+	{ EXIT_REASON_TDCALL,                "TDCALL" }, \
+	{ EXIT_REASON_MSR_READ_IMM,          "MSR_READ_IMM" }, \
+	{ EXIT_REASON_MSR_WRITE_IMM,         "MSR_WRITE_IMM" }
 
 #define VMX_EXIT_REASON_FLAGS \
 	{ VMX_EXIT_REASONS_FAILED_VMENTRY,	"FAILED_VMENTRY" }
diff --git a/lib/libc/include/xtensa-linux-any/asm/unistd_32.h b/lib/libc/include/xtensa-linux-any/asm/unistd_32.h
index edf6b3e6559a51b53f9ed52ad3a654d9c825a336..d1af9e226510e0df9ed9027ddcfffdca6ede6b8f 100644
--- a/lib/libc/include/xtensa-linux-any/asm/unistd_32.h
+++ b/lib/libc/include/xtensa-linux-any/asm/unistd_32.h
@@ -416,6 +416,7 @@
 #define __NR_open_tree_attr 467
 #define __NR_file_getattr 468
 #define __NR_file_setattr 469
+#define __NR_listns 470
 
 
 #endif /* _ASM_UNISTD_32_H */
\ No newline at end of file
-- 
2.54.0


From fcf0fc225a7e9023d62138e6cbc6d5ffd91453e0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Feb 2026 23:46:43 +0100
Subject: [PATCH 250/499] std.Target: update max Linux version to 6.19

---
 lib/std/Target.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Target.zig b/lib/std/Target.zig
index d1ce30f343eb32427c60cda55071d1157b608b9a..1b0c617598d346dba09599feb5b47649a916b71a 100644
--- a/lib/std/Target.zig
+++ b/lib/std/Target.zig
@@ -443,7 +443,7 @@ pub const Os = struct {
 
                                 break :blk default_min;
                             },
-                            .max = .{ .major = 6, .minor = 17, .patch = 0 },
+                            .max = .{ .major = 6, .minor = 19, .patch = 0 },
                         },
                         .glibc = blk: {
                             // For 32-bit targets that traditionally used 32-bit time, we require
-- 
2.54.0


From 74608293afa6d825c6482d2253eed28a89705351 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 9 Feb 2026 18:47:03 -0800
Subject: [PATCH 251/499] compiler_rt: common -> compiler_rt

use the "symbol" helper function in all exports

move all declarations from common.zig to compiler_rt.zig

flatten the tree structure somewhat (move contents of tiny files into
parent files)

No functional changes.
---
 lib/compiler_rt.zig                         | 425 ++++++++++++++++++--
 lib/compiler_rt/aarch64_outline_atomics.zig | 203 +++++-----
 lib/compiler_rt/absvsi2.zig                 |   5 +-
 lib/compiler_rt/adddf3.zig                  |   4 +-
 lib/compiler_rt/addf3.zig                   |   4 +-
 lib/compiler_rt/addhf3.zig                  |   5 +-
 lib/compiler_rt/addsf3.zig                  |   4 +-
 lib/compiler_rt/addtf3.zig                  |  13 +-
 lib/compiler_rt/addvsi3.zig                 |   5 +-
 lib/compiler_rt/addxf3.zig                  |   5 +-
 lib/compiler_rt/arm.zig                     |  57 +--
 lib/compiler_rt/atomics.zig                 |   2 +-
 lib/compiler_rt/aulldiv.zig                 |   4 +-
 lib/compiler_rt/aullrem.zig                 |   9 +-
 lib/compiler_rt/bcmp.zig                    |  30 --
 lib/compiler_rt/bitreverse.zig              |   9 +-
 lib/compiler_rt/bswap.zig                   |   9 +-
 lib/compiler_rt/clear_cache.zig             |   5 +-
 lib/compiler_rt/cmp.zig                     |  15 +-
 lib/compiler_rt/cmpdf2.zig                  |   4 +-
 lib/compiler_rt/cmphf2.zig                  |  48 ---
 lib/compiler_rt/cmpsf2.zig                  |  66 ---
 lib/compiler_rt/cmptf2.zig                  |   6 +-
 lib/compiler_rt/cmpxf2.zig                  |  13 +-
 lib/compiler_rt/common.zig                  | 296 --------------
 lib/compiler_rt/comparef.zig                | 144 +++++++
 lib/compiler_rt/comparesf2_test.zig         |  10 +-
 lib/compiler_rt/cos.zig                     |   8 +-
 lib/compiler_rt/divdf3.zig                  |   8 +-
 lib/compiler_rt/divhc3.zig                  |   5 +-
 lib/compiler_rt/divmodei4.zig               |   6 +-
 lib/compiler_rt/divsf3.zig                  |   6 +-
 lib/compiler_rt/divtc3.zig                  |   4 +-
 lib/compiler_rt/divtf3.zig                  |  17 +-
 lib/compiler_rt/divti3.zig                  |  39 --
 lib/compiler_rt/divti3_test.zig             |   2 +-
 lib/compiler_rt/divxf3.zig                  |   9 +-
 lib/compiler_rt/emutls.zig                  |   5 +-
 lib/compiler_rt/exp.zig                     |  14 +-
 lib/compiler_rt/exp2.zig                    |  25 +-
 lib/compiler_rt/extenddftf2.zig             |   6 +-
 lib/compiler_rt/extenddfxf2.zig             |   5 +-
 lib/compiler_rt/extendf_test.zig            |   6 +-
 lib/compiler_rt/extendhfdf2.zig             |   4 +-
 lib/compiler_rt/extendhfsf2.zig             |  10 +-
 lib/compiler_rt/extendhftf2.zig             |   7 +-
 lib/compiler_rt/extendhfxf2.zig             |   7 +-
 lib/compiler_rt/extendsfdf2.zig             |   9 +-
 lib/compiler_rt/extendsftf2.zig             |  13 +-
 lib/compiler_rt/fabs.zig                    |  19 +-
 lib/compiler_rt/fixdfdi.zig                 |  13 +-
 lib/compiler_rt/fixdfei.zig                 |   5 +-
 lib/compiler_rt/fixdfsi.zig                 |   4 +-
 lib/compiler_rt/fixdfti.zig                 |   4 +-
 lib/compiler_rt/fixhfdi.zig                 |  10 -
 lib/compiler_rt/fixhfei.zig                 |   5 +-
 lib/compiler_rt/fixhfsi.zig                 |  10 -
 lib/compiler_rt/fixhfti.zig                 |  21 -
 lib/compiler_rt/fixsfdi.zig                 |   6 +-
 lib/compiler_rt/fixsfei.zig                 |   5 +-
 lib/compiler_rt/fixsfsi.zig                 |   9 +-
 lib/compiler_rt/fixsfti.zig                 |   9 +-
 lib/compiler_rt/fixtfdi.zig                 |   6 +-
 lib/compiler_rt/fixtfei.zig                 |   5 +-
 lib/compiler_rt/fixtfsi.zig                 |   6 +-
 lib/compiler_rt/fixtfti.zig                 |   6 +-
 lib/compiler_rt/fixunsdfdi.zig              |  13 +-
 lib/compiler_rt/fixunsdfsi.zig              |   9 +-
 lib/compiler_rt/fixunsdfti.zig              |   4 +-
 lib/compiler_rt/fixunshfsi.zig              |   5 +-
 lib/compiler_rt/fixunshfti.zig              |   4 +-
 lib/compiler_rt/fixunssfdi.zig              |  13 +-
 lib/compiler_rt/fixunssfsi.zig              |   9 +-
 lib/compiler_rt/fixunssfti.zig              |   4 +-
 lib/compiler_rt/fixunstfdi.zig              |  13 +-
 lib/compiler_rt/fixunstfsi.zig              |  13 +-
 lib/compiler_rt/fixunstfti.zig              |  13 +-
 lib/compiler_rt/fixunsxfsi.zig              |   5 +-
 lib/compiler_rt/fixunsxfti.zig              |   9 +-
 lib/compiler_rt/fixxfei.zig                 |   5 +-
 lib/compiler_rt/fixxfsi.zig                 |   5 +-
 lib/compiler_rt/fixxfti.zig                 |  23 --
 lib/compiler_rt/floatdidf.zig               |  13 +-
 lib/compiler_rt/floatdisf.zig               |   6 +-
 lib/compiler_rt/floatditf.zig               |   6 +-
 lib/compiler_rt/floateihf.zig               |   5 +-
 lib/compiler_rt/floateisf.zig               |   5 +-
 lib/compiler_rt/floateitf.zig               |   5 +-
 lib/compiler_rt/floatsidf.zig               |   9 +-
 lib/compiler_rt/floatsihf.zig               |   5 +-
 lib/compiler_rt/floatsisf.zig               |   9 +-
 lib/compiler_rt/floatsitf.zig               |  13 +-
 lib/compiler_rt/floatsixf.zig               |   2 +-
 lib/compiler_rt/floattidf.zig               |   4 +-
 lib/compiler_rt/floattihf.zig               |   9 +-
 lib/compiler_rt/floattisf.zig               |   4 +-
 lib/compiler_rt/floattitf.zig               |   6 +-
 lib/compiler_rt/floattixf.zig               |   9 +-
 lib/compiler_rt/floatundidf.zig             |   6 +-
 lib/compiler_rt/floatundihf.zig             |   5 +-
 lib/compiler_rt/floatundisf.zig             |  13 +-
 lib/compiler_rt/floatunditf.zig             |  13 +-
 lib/compiler_rt/floatundixf.zig             |   5 +-
 lib/compiler_rt/floatuneidf.zig             |   5 +-
 lib/compiler_rt/floatuneihf.zig             |   5 +-
 lib/compiler_rt/floatuneisf.zig             |   5 +-
 lib/compiler_rt/floatuneixf.zig             |   5 +-
 lib/compiler_rt/floatunsidf.zig             |   9 +-
 lib/compiler_rt/floatunsisf.zig             |   4 +-
 lib/compiler_rt/floatunsitf.zig             |   6 +-
 lib/compiler_rt/floatunsixf.zig             |   5 +-
 lib/compiler_rt/floatuntidf.zig             |   4 +-
 lib/compiler_rt/floatuntihf.zig             |   4 +-
 lib/compiler_rt/floatuntisf.zig             |   9 +-
 lib/compiler_rt/floatuntitf.zig             |   6 +-
 lib/compiler_rt/floatuntixf.zig             |   9 +-
 lib/compiler_rt/floor_ceil.zig              |  12 +-
 lib/compiler_rt/fma.zig                     |  19 +-
 lib/compiler_rt/fmax.zig                    |  19 +-
 lib/compiler_rt/fmin.zig                    |  19 +-
 lib/compiler_rt/fmod.zig                    |  21 +-
 lib/compiler_rt/gedf2.zig                   |   4 +-
 lib/compiler_rt/gesf2.zig                   |  13 +-
 lib/compiler_rt/getf2.zig                   |  15 +-
 lib/compiler_rt/hexagon.zig                 |  52 +--
 lib/compiler_rt/int.zig                     |   8 +-
 lib/compiler_rt/int_from_float.zig          |  51 ++-
 lib/compiler_rt/log.zig                     |  12 +-
 lib/compiler_rt/log10.zig                   |  12 +-
 lib/compiler_rt/log2.zig                    |  27 +-
 lib/compiler_rt/memcpy.zig                  |   8 +-
 lib/compiler_rt/memmove.zig                 |  20 +-
 lib/compiler_rt/memset.zig                  |  33 --
 lib/compiler_rt/modti3.zig                  |  42 --
 lib/compiler_rt/modti3_test.zig             |   2 +-
 lib/compiler_rt/mulXi3.zig                  |  21 +-
 lib/compiler_rt/muldf3.zig                  |   4 +-
 lib/compiler_rt/mulf3.zig                   |   8 +-
 lib/compiler_rt/mulhc3.zig                  |   5 +-
 lib/compiler_rt/mulhf3.zig                  |   5 +-
 lib/compiler_rt/mulo.zig                    |   9 +-
 lib/compiler_rt/mulsf3.zig                  |   9 +-
 lib/compiler_rt/multc3.zig                  |   4 +-
 lib/compiler_rt/multf3.zig                  |  13 +-
 lib/compiler_rt/mulxc3.zig                  |   5 +-
 lib/compiler_rt/mulxf3.zig                  |   5 +-
 lib/compiler_rt/negXi2.zig                  |  39 --
 lib/compiler_rt/negdf2.zig                  |  17 -
 lib/compiler_rt/negdi2_test.zig             |   8 +-
 lib/compiler_rt/neghf2.zig                  |   9 -
 lib/compiler_rt/negsf2.zig                  |  17 -
 lib/compiler_rt/negsi2_test.zig             |   5 +-
 lib/compiler_rt/negtf2.zig                  |  12 -
 lib/compiler_rt/negti2_test.zig             |   8 +-
 lib/compiler_rt/negv.zig                    |   9 +-
 lib/compiler_rt/negxf2.zig                  |   9 -
 lib/compiler_rt/os_version_check.zig        |   7 +-
 lib/compiler_rt/powiXf2.zig                 |   4 +-
 lib/compiler_rt/round.zig                   |  25 +-
 lib/compiler_rt/shift.zig                   |  35 +-
 lib/compiler_rt/sin.zig                     |   8 +-
 lib/compiler_rt/sincos.zig                  |  25 +-
 lib/compiler_rt/sqrt.zig                    |  29 +-
 lib/compiler_rt/ssp.zig                     |  23 +-
 lib/compiler_rt/stack_probe.zig             |  21 +-
 lib/compiler_rt/subdf3.zig                  |   4 +-
 lib/compiler_rt/subhf3.zig                  |   5 +-
 lib/compiler_rt/subsf3.zig                  |   9 +-
 lib/compiler_rt/subtf3.zig                  |  13 +-
 lib/compiler_rt/subvsi3.zig                 |   5 +-
 lib/compiler_rt/tan.zig                     |   8 +-
 lib/compiler_rt/trunc.zig                   |  15 +-
 lib/compiler_rt/truncdfhf2.zig              |   6 +-
 lib/compiler_rt/truncdfsf2.zig              |   9 +-
 lib/compiler_rt/truncsfhf2.zig              |  17 +-
 lib/compiler_rt/trunctfdf2.zig              |  13 +-
 lib/compiler_rt/trunctfhf2.zig              |   4 +-
 lib/compiler_rt/trunctfsf2.zig              |   6 +-
 lib/compiler_rt/trunctfxf2.zig              |   5 +-
 lib/compiler_rt/truncxfhf2.zig              |   4 +-
 lib/compiler_rt/udivmod.zig                 | 108 ++++-
 lib/compiler_rt/udivmodei4.zig              |   6 +-
 lib/compiler_rt/udivmodti4.zig              |  26 --
 lib/compiler_rt/udivmodti4_test.zig         |   2 +-
 lib/compiler_rt/udivti3.zig                 |  22 -
 lib/compiler_rt/umodti3.zig                 |  26 --
 lib/compiler_rt/unorddf2.zig                |   4 +-
 lib/compiler_rt/unordhf2.zig                |  10 -
 lib/compiler_rt/unordsf2.zig                |  18 -
 lib/compiler_rt/unordtf2.zig                |  16 -
 lib/compiler_rt/unordxf2.zig                |  10 -
 191 files changed, 1604 insertions(+), 1687 deletions(-)
 delete mode 100644 lib/compiler_rt/bcmp.zig
 delete mode 100644 lib/compiler_rt/cmphf2.zig
 delete mode 100644 lib/compiler_rt/cmpsf2.zig
 delete mode 100644 lib/compiler_rt/common.zig
 delete mode 100644 lib/compiler_rt/divti3.zig
 delete mode 100644 lib/compiler_rt/fixhfdi.zig
 delete mode 100644 lib/compiler_rt/fixhfsi.zig
 delete mode 100644 lib/compiler_rt/fixhfti.zig
 delete mode 100644 lib/compiler_rt/fixxfti.zig
 delete mode 100644 lib/compiler_rt/memset.zig
 delete mode 100644 lib/compiler_rt/modti3.zig
 delete mode 100644 lib/compiler_rt/negXi2.zig
 delete mode 100644 lib/compiler_rt/negdf2.zig
 delete mode 100644 lib/compiler_rt/neghf2.zig
 delete mode 100644 lib/compiler_rt/negsf2.zig
 delete mode 100644 lib/compiler_rt/negtf2.zig
 delete mode 100644 lib/compiler_rt/negxf2.zig
 delete mode 100644 lib/compiler_rt/udivmodti4.zig
 delete mode 100644 lib/compiler_rt/udivti3.zig
 delete mode 100644 lib/compiler_rt/umodti3.zig
 delete mode 100644 lib/compiler_rt/unordhf2.zig
 delete mode 100644 lib/compiler_rt/unordsf2.zig
 delete mode 100644 lib/compiler_rt/unordtf2.zig
 delete mode 100644 lib/compiler_rt/unordxf2.zig

diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig
index 343363188f9f5023b54a54f145412212c799a840..5c9c7a59af3738ac49d7912b1a1c8de6c7802c59 100644
--- a/lib/compiler_rt.zig
+++ b/lib/compiler_rt.zig
@@ -1,5 +1,6 @@
 const builtin = @import("builtin");
 const ofmt_c = builtin.object_format == .c;
+const native_endian = builtin.cpu.arch.endian();
 
 const std = @import("std");
 
@@ -57,13 +58,12 @@ comptime {
     _ = @import("compiler_rt/cmp.zig");
 
     _ = @import("compiler_rt/shift.zig");
-    _ = @import("compiler_rt/negXi2.zig");
+    symbol(&__negsi2, "__negsi2");
+    symbol(&__negdi2, "__negdi2");
+    symbol(&__negti2, "__negti2");
     _ = @import("compiler_rt/int.zig");
     _ = @import("compiler_rt/mulXi3.zig");
-    _ = @import("compiler_rt/divti3.zig");
-    _ = @import("compiler_rt/udivti3.zig");
-    _ = @import("compiler_rt/modti3.zig");
-    _ = @import("compiler_rt/umodti3.zig");
+    _ = @import("compiler_rt/udivmod.zig");
 
     _ = @import("compiler_rt/absv.zig");
     _ = @import("compiler_rt/absvsi2.zig");
@@ -108,9 +108,6 @@ comptime {
     _ = @import("compiler_rt/trunctfxf2.zig");
 
     _ = @import("compiler_rt/int_from_float.zig");
-    _ = @import("compiler_rt/fixhfsi.zig");
-    _ = @import("compiler_rt/fixhfdi.zig");
-    _ = @import("compiler_rt/fixhfti.zig");
     _ = @import("compiler_rt/fixhfei.zig");
     _ = @import("compiler_rt/fixsfsi.zig");
     _ = @import("compiler_rt/fixsfdi.zig");
@@ -126,8 +123,8 @@ comptime {
     _ = @import("compiler_rt/fixtfei.zig");
     _ = @import("compiler_rt/fixxfsi.zig");
     _ = @import("compiler_rt/fixxfdi.zig");
-    _ = @import("compiler_rt/fixxfti.zig");
     _ = @import("compiler_rt/fixxfei.zig");
+
     _ = @import("compiler_rt/fixunshfsi.zig");
     _ = @import("compiler_rt/fixunshfdi.zig");
     _ = @import("compiler_rt/fixunshfti.zig");
@@ -193,16 +190,10 @@ comptime {
 
     // comparison
     _ = @import("compiler_rt/comparef.zig");
-    _ = @import("compiler_rt/cmphf2.zig");
-    _ = @import("compiler_rt/cmpsf2.zig");
     _ = @import("compiler_rt/cmpdf2.zig");
     _ = @import("compiler_rt/cmptf2.zig");
     _ = @import("compiler_rt/cmpxf2.zig");
-    _ = @import("compiler_rt/unordhf2.zig");
-    _ = @import("compiler_rt/unordsf2.zig");
     _ = @import("compiler_rt/unorddf2.zig");
-    _ = @import("compiler_rt/unordxf2.zig");
-    _ = @import("compiler_rt/unordtf2.zig");
     _ = @import("compiler_rt/gehf2.zig");
     _ = @import("compiler_rt/gesf2.zig");
     _ = @import("compiler_rt/gedf2.zig");
@@ -236,11 +227,17 @@ comptime {
     _ = @import("compiler_rt/divxf3.zig");
     _ = @import("compiler_rt/divtf3.zig");
 
-    _ = @import("compiler_rt/neghf2.zig");
-    _ = @import("compiler_rt/negsf2.zig");
-    _ = @import("compiler_rt/negdf2.zig");
-    _ = @import("compiler_rt/negtf2.zig");
-    _ = @import("compiler_rt/negxf2.zig");
+    symbol(&__neghf2, "__neghf2");
+    if (want_aeabi) {
+        symbol(&__aeabi_fneg, "__aeabi_fneg");
+        symbol(&__aeabi_dneg, "__aeabi_dneg");
+    } else {
+        symbol(&__negsf2, "__negsf2");
+        symbol(&__negdf2, "__negdf2");
+    }
+    if (want_ppc_abi) symbol(&__negtf2, "__negkf2");
+    symbol(&__negtf2, "__negtf2");
+    symbol(&__negxf2, "__negxf2");
 
     // other
     _ = @import("compiler_rt/powiXf2.zig");
@@ -281,7 +278,6 @@ comptime {
     // BigInt. Alphabetically sorted.
     _ = @import("compiler_rt/divmodei4.zig");
     _ = @import("compiler_rt/udivmodei4.zig");
-    _ = @import("compiler_rt/udivmodti4.zig");
 
     // extra
     _ = @import("compiler_rt/os_version_check.zig");
@@ -302,10 +298,13 @@ comptime {
         }
 
         _ = @import("compiler_rt/memcpy.zig");
-        _ = @import("compiler_rt/memset.zig");
+        if (!ofmt_c) {
+            symbol(&memset, "memset");
+            symbol(&__memset, "__memset");
+        }
         _ = @import("compiler_rt/memmove.zig");
         symbol(&memcmp, "memcmp");
-        _ = @import("compiler_rt/bcmp.zig");
+        symbol(&bcmp, "bcmp");
         _ = @import("compiler_rt/ssp.zig");
         symbol(&strlen, "strlen");
     }
@@ -345,3 +344,383 @@ test "memcmp" {
     try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
     try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
 }
+
+pub const PreferredLoadStoreElement = element: {
+    if (std.simd.suggestVectorLength(u8)) |vec_size| {
+        const Vec = @Vector(vec_size, u8);
+
+        if (@sizeOf(Vec) == vec_size and std.math.isPowerOfTwo(vec_size)) {
+            break :element Vec;
+        }
+    }
+    break :element usize;
+};
+
+pub const want_aeabi = switch (builtin.abi) {
+    .eabi,
+    .eabihf,
+    .musleabi,
+    .musleabihf,
+    .gnueabi,
+    .gnueabihf,
+    .android,
+    .androideabi,
+    => switch (builtin.cpu.arch) {
+        .arm, .armeb, .thumb, .thumbeb => true,
+        else => false,
+    },
+    else => false,
+};
+
+/// These functions are required on Windows on ARM. They are provided by MSVC libc, but in libc-less
+/// builds or when linking MinGW libc they are our responsibility.
+/// Temporarily used for thumb-uefi until https://github.com/ziglang/zig/issues/21630 is addressed.
+pub const want_windows_arm_abi = e: {
+    if (!builtin.cpu.arch.isArm()) break :e false;
+    switch (builtin.os.tag) {
+        .windows, .uefi => {},
+        else => break :e false,
+    }
+    // The ABI is needed, but it's only our reponsibility if libc won't provide it.
+    break :e builtin.abi.isGnu() or !builtin.link_libc;
+};
+
+/// These functions are required by on Windows on x86 on some ABIs. They are provided by MSVC libc,
+/// but in libc-less builds they are our responsibility.
+pub const want_windows_x86_msvc_abi = e: {
+    if (builtin.cpu.arch != .x86) break :e false;
+    if (builtin.os.tag != .windows) break :e false;
+    switch (builtin.abi) {
+        .none, .msvc, .itanium => {},
+        else => break :e false,
+    }
+    // The ABI is needed, but it's only our responsibility if libc won't provide it.
+    break :e !builtin.link_libc;
+};
+
+pub const want_ppc_abi = builtin.cpu.arch.isPowerPC();
+
+pub const want_float_exceptions = !builtin.cpu.arch.isWasm();
+
+// Libcalls that involve u128 on Windows x86-64 are expected by LLVM to use the
+// calling convention of @Vector(2, u64), rather than what's standard.
+pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c;
+
+/// This governs whether to use these symbol names for f16/f32 conversions
+/// rather than the standard names:
+/// * __gnu_f2h_ieee
+/// * __gnu_h2f_ieee
+/// Known correct configurations:
+///   x86_64-freestanding-none => true
+///   x86_64-linux-none => true
+///   x86_64-linux-gnu => true
+///   x86_64-linux-musl => true
+///   x86_64-linux-eabi => true
+///   arm-linux-musleabihf => true
+///   arm-linux-gnueabihf => true
+///   arm-linux-eabihf => false
+///   wasm32-wasi-musl => false
+///   wasm32-freestanding-none => false
+///   x86_64-windows-gnu => true
+///   x86_64-windows-msvc => true
+///   any-macos-any => false
+pub const gnu_f16_abi = switch (builtin.cpu.arch) {
+    .wasm32,
+    .wasm64,
+    .riscv64,
+    .riscv64be,
+    .riscv32,
+    .riscv32be,
+    => false,
+
+    .x86, .x86_64 => true,
+
+    .arm, .armeb, .thumb, .thumbeb => switch (builtin.abi) {
+        .eabi, .eabihf => false,
+        else => true,
+    },
+
+    else => !builtin.os.tag.isDarwin(),
+};
+
+pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
+
+/// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
+pub fn F16T(comptime OtherType: type) type {
+    return switch (builtin.cpu.arch) {
+        .amdgcn,
+        .arm,
+        .armeb,
+        .thumb,
+        .thumbeb,
+        .aarch64,
+        .aarch64_be,
+        .hexagon,
+        .loongarch32,
+        .loongarch64,
+        .nvptx,
+        .nvptx64,
+        .riscv32,
+        .riscv32be,
+        .riscv64,
+        .riscv64be,
+        .s390x,
+        .spirv32,
+        .spirv64,
+        => f16,
+        .x86, .x86_64 => if (builtin.target.os.tag.isDarwin()) switch (OtherType) {
+            // Starting with LLVM 16, Darwin uses different abi for f16
+            // depending on the type of the other return/argument..???
+            f32, f64 => u16,
+            f80, f128 => f16,
+            else => unreachable,
+        } else f16,
+        else => u16,
+    };
+}
+
+pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
+    switch (Z) {
+        u16 => {
+            // 16x16 --> 32 bit multiply
+            const product = @as(u32, a) * @as(u32, b);
+            hi.* = @intCast(product >> 16);
+            lo.* = @truncate(product);
+        },
+        u32 => {
+            // 32x32 --> 64 bit multiply
+            const product = @as(u64, a) * @as(u64, b);
+            hi.* = @truncate(product >> 32);
+            lo.* = @truncate(product);
+        },
+        u64 => {
+            const S = struct {
+                fn loWord(x: u64) u64 {
+                    return @as(u32, @truncate(x));
+                }
+                fn hiWord(x: u64) u64 {
+                    return @as(u32, @truncate(x >> 32));
+                }
+            };
+            // 64x64 -> 128 wide multiply for platforms that don't have such an operation;
+            // many 64-bit platforms have this operation, but they tend to have hardware
+            // floating-point, so we don't bother with a special case for them here.
+            // Each of the component 32x32 -> 64 products
+            const plolo: u64 = S.loWord(a) * S.loWord(b);
+            const plohi: u64 = S.loWord(a) * S.hiWord(b);
+            const philo: u64 = S.hiWord(a) * S.loWord(b);
+            const phihi: u64 = S.hiWord(a) * S.hiWord(b);
+            // Sum terms that contribute to lo in a way that allows us to get the carry
+            const r0: u64 = S.loWord(plolo);
+            const r1: u64 = S.hiWord(plolo) +% S.loWord(plohi) +% S.loWord(philo);
+            lo.* = r0 +% (r1 << 32);
+            // Sum terms contributing to hi with the carry from lo
+            hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi;
+        },
+        u128 => {
+            const Word_LoMask: u64 = 0x00000000ffffffff;
+            const Word_HiMask: u64 = 0xffffffff00000000;
+            const Word_FullMask: u64 = 0xffffffffffffffff;
+            const S = struct {
+                fn Word_1(x: u128) u64 {
+                    return @as(u32, @truncate(x >> 96));
+                }
+                fn Word_2(x: u128) u64 {
+                    return @as(u32, @truncate(x >> 64));
+                }
+                fn Word_3(x: u128) u64 {
+                    return @as(u32, @truncate(x >> 32));
+                }
+                fn Word_4(x: u128) u64 {
+                    return @as(u32, @truncate(x));
+                }
+            };
+            // 128x128 -> 256 wide multiply for platforms that don't have such an operation;
+            // many 64-bit platforms have this operation, but they tend to have hardware
+            // floating-point, so we don't bother with a special case for them here.
+
+            const product11: u64 = S.Word_1(a) * S.Word_1(b);
+            const product12: u64 = S.Word_1(a) * S.Word_2(b);
+            const product13: u64 = S.Word_1(a) * S.Word_3(b);
+            const product14: u64 = S.Word_1(a) * S.Word_4(b);
+            const product21: u64 = S.Word_2(a) * S.Word_1(b);
+            const product22: u64 = S.Word_2(a) * S.Word_2(b);
+            const product23: u64 = S.Word_2(a) * S.Word_3(b);
+            const product24: u64 = S.Word_2(a) * S.Word_4(b);
+            const product31: u64 = S.Word_3(a) * S.Word_1(b);
+            const product32: u64 = S.Word_3(a) * S.Word_2(b);
+            const product33: u64 = S.Word_3(a) * S.Word_3(b);
+            const product34: u64 = S.Word_3(a) * S.Word_4(b);
+            const product41: u64 = S.Word_4(a) * S.Word_1(b);
+            const product42: u64 = S.Word_4(a) * S.Word_2(b);
+            const product43: u64 = S.Word_4(a) * S.Word_3(b);
+            const product44: u64 = S.Word_4(a) * S.Word_4(b);
+
+            const sum0: u128 = @as(u128, product44);
+            const sum1: u128 = @as(u128, product34) +%
+                @as(u128, product43);
+            const sum2: u128 = @as(u128, product24) +%
+                @as(u128, product33) +%
+                @as(u128, product42);
+            const sum3: u128 = @as(u128, product14) +%
+                @as(u128, product23) +%
+                @as(u128, product32) +%
+                @as(u128, product41);
+            const sum4: u128 = @as(u128, product13) +%
+                @as(u128, product22) +%
+                @as(u128, product31);
+            const sum5: u128 = @as(u128, product12) +%
+                @as(u128, product21);
+            const sum6: u128 = @as(u128, product11);
+
+            const r0: u128 = (sum0 & Word_FullMask) +%
+                ((sum1 & Word_LoMask) << 32);
+            const r1: u128 = (sum0 >> 64) +%
+                ((sum1 >> 32) & Word_FullMask) +%
+                (sum2 & Word_FullMask) +%
+                ((sum3 << 32) & Word_HiMask);
+
+            lo.* = r0 +% (r1 << 64);
+            hi.* = (r1 >> 64) +%
+                (sum1 >> 96) +%
+                (sum2 >> 64) +%
+                (sum3 >> 32) +%
+                sum4 +%
+                (sum5 << 32) +%
+                (sum6 << 64);
+        },
+        else => @compileError("unsupported"),
+    }
+}
+
+pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).float.bits)) i32 {
+    const Z = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
+
+    const shift = @clz(significand.*) - @clz(integerBit);
+    significand.* <<= @as(std.math.Log2Int(Z), @intCast(shift));
+    return @as(i32, 1) - shift;
+}
+
+pub inline fn fneg(a: anytype) @TypeOf(a) {
+    const F = @TypeOf(a);
+    const bits = @typeInfo(F).float.bits;
+    const U = @Int(.unsigned, bits);
+    const sign_bit_mask = @as(U, 1) << (bits - 1);
+    const negated = @as(U, @bitCast(a)) ^ sign_bit_mask;
+    return @bitCast(negated);
+}
+
+fn __negxf2(a: f80) callconv(.c) f80 {
+    return fneg(a);
+}
+
+fn __neghf2(a: f16) callconv(.c) f16 {
+    return fneg(a);
+}
+
+fn __negdf2(a: f64) callconv(.c) f64 {
+    return fneg(a);
+}
+
+fn __aeabi_dneg(a: f64) callconv(.{ .arm_aapcs = .{} }) f64 {
+    return fneg(a);
+}
+
+fn __negtf2(a: f128) callconv(.c) f128 {
+    return fneg(a);
+}
+
+fn __negsf2(a: f32) callconv(.c) f32 {
+    return fneg(a);
+}
+
+fn __aeabi_fneg(a: f32) callconv(.{ .arm_aapcs = .{} }) f32 {
+    return fneg(a);
+}
+
+/// Allows to access underlying bits as two equally sized lower and higher
+/// signed or unsigned integers.
+pub fn HalveInt(comptime T: type, comptime signed_half: bool) type {
+    return extern union {
+        pub const bits = @divExact(@typeInfo(T).int.bits, 2);
+        pub const HalfTU = std.meta.Int(.unsigned, bits);
+        pub const HalfTS = std.meta.Int(.signed, bits);
+        pub const HalfT = if (signed_half) HalfTS else HalfTU;
+
+        all: T,
+        s: if (native_endian == .little)
+            extern struct { low: HalfT, high: HalfT }
+        else
+            extern struct { high: HalfT, low: HalfT },
+    };
+}
+
+pub fn __negsi2(a: i32) callconv(.c) i32 {
+    return negXi2(i32, a);
+}
+
+pub fn __negdi2(a: i64) callconv(.c) i64 {
+    return negXi2(i64, a);
+}
+
+pub fn __negti2(a: i128) callconv(.c) i128 {
+    return negXi2(i128, a);
+}
+
+inline fn negXi2(comptime T: type, a: T) T {
+    return -a;
+}
+
+pub fn memset(dest: ?[*]u8, c: u8, len: usize) callconv(.c) ?[*]u8 {
+    @setRuntimeSafety(false);
+
+    if (len != 0) {
+        var d = dest.?;
+        var n = len;
+        while (true) {
+            d[0] = c;
+            n -= 1;
+            if (n == 0) break;
+            d += 1;
+        }
+    }
+
+    return dest;
+}
+
+pub fn __memset(dest: ?[*]u8, c: u8, n: usize, dest_n: usize) callconv(.c) ?[*]u8 {
+    if (dest_n < n)
+        @panic("buffer overflow");
+    return memset(dest, c, n);
+}
+
+pub fn bcmp(vl: [*]allowzero const u8, vr: [*]allowzero const u8, n: usize) callconv(.c) c_int {
+    @setRuntimeSafety(false);
+
+    var index: usize = 0;
+    while (index != n) : (index += 1) {
+        if (vl[index] != vr[index]) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+test "bcmp" {
+    const base_arr = &[_]u8{ 1, 1, 1 };
+    const arr1 = &[_]u8{ 1, 1, 1 };
+    const arr2 = &[_]u8{ 1, 0, 1 };
+    const arr3 = &[_]u8{ 1, 2, 1 };
+
+    try std.testing.expect(bcmp(base_arr[0..], arr1[0..], base_arr.len) == 0);
+    try std.testing.expect(bcmp(base_arr[0..], arr2[0..], base_arr.len) != 0);
+    try std.testing.expect(bcmp(base_arr[0..], arr3[0..], base_arr.len) != 0);
+}
+
+test {
+    _ = @import("compiler_rt/negsi2_test.zig");
+    _ = @import("compiler_rt/negdi2_test.zig");
+    _ = @import("compiler_rt/negti2_test.zig");
+}
diff --git a/lib/compiler_rt/aarch64_outline_atomics.zig b/lib/compiler_rt/aarch64_outline_atomics.zig
index 817800eb21cbe0d97b4d65eba146fe77adad0e50..c03306cd1a1cd07e0a450f66c67b985f41a1e0d3 100644
--- a/lib/compiler_rt/aarch64_outline_atomics.zig
+++ b/lib/compiler_rt/aarch64_outline_atomics.zig
@@ -1,7 +1,8 @@
 //! This file is generated by tools/gen_outline_atomics.zig.
 const builtin = @import("builtin");
 const std = @import("std");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const always_has_lse = builtin.cpu.has(.aarch64, .lse);
 
 /// This default is overridden at runtime after inspecting CPU properties.
@@ -2024,104 +2025,104 @@ fn __aarch64_cas16_acq_rel() align(16) callconv(.naked) void {
 }
 
 comptime {
-    @export(&__aarch64_cas1_relax, .{ .name = "__aarch64_cas1_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp1_relax, .{ .name = "__aarch64_swp1_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd1_relax, .{ .name = "__aarch64_ldadd1_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr1_relax, .{ .name = "__aarch64_ldclr1_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor1_relax, .{ .name = "__aarch64_ldeor1_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset1_relax, .{ .name = "__aarch64_ldset1_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas1_acq, .{ .name = "__aarch64_cas1_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp1_acq, .{ .name = "__aarch64_swp1_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd1_acq, .{ .name = "__aarch64_ldadd1_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr1_acq, .{ .name = "__aarch64_ldclr1_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor1_acq, .{ .name = "__aarch64_ldeor1_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset1_acq, .{ .name = "__aarch64_ldset1_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas1_rel, .{ .name = "__aarch64_cas1_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp1_rel, .{ .name = "__aarch64_swp1_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd1_rel, .{ .name = "__aarch64_ldadd1_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr1_rel, .{ .name = "__aarch64_ldclr1_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor1_rel, .{ .name = "__aarch64_ldeor1_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset1_rel, .{ .name = "__aarch64_ldset1_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas1_acq_rel, .{ .name = "__aarch64_cas1_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp1_acq_rel, .{ .name = "__aarch64_swp1_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd1_acq_rel, .{ .name = "__aarch64_ldadd1_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr1_acq_rel, .{ .name = "__aarch64_ldclr1_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor1_acq_rel, .{ .name = "__aarch64_ldeor1_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset1_acq_rel, .{ .name = "__aarch64_ldset1_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas2_relax, .{ .name = "__aarch64_cas2_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp2_relax, .{ .name = "__aarch64_swp2_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd2_relax, .{ .name = "__aarch64_ldadd2_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr2_relax, .{ .name = "__aarch64_ldclr2_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor2_relax, .{ .name = "__aarch64_ldeor2_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset2_relax, .{ .name = "__aarch64_ldset2_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas2_acq, .{ .name = "__aarch64_cas2_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp2_acq, .{ .name = "__aarch64_swp2_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd2_acq, .{ .name = "__aarch64_ldadd2_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr2_acq, .{ .name = "__aarch64_ldclr2_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor2_acq, .{ .name = "__aarch64_ldeor2_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset2_acq, .{ .name = "__aarch64_ldset2_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas2_rel, .{ .name = "__aarch64_cas2_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp2_rel, .{ .name = "__aarch64_swp2_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd2_rel, .{ .name = "__aarch64_ldadd2_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr2_rel, .{ .name = "__aarch64_ldclr2_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor2_rel, .{ .name = "__aarch64_ldeor2_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset2_rel, .{ .name = "__aarch64_ldset2_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas2_acq_rel, .{ .name = "__aarch64_cas2_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp2_acq_rel, .{ .name = "__aarch64_swp2_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd2_acq_rel, .{ .name = "__aarch64_ldadd2_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr2_acq_rel, .{ .name = "__aarch64_ldclr2_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor2_acq_rel, .{ .name = "__aarch64_ldeor2_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset2_acq_rel, .{ .name = "__aarch64_ldset2_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas4_relax, .{ .name = "__aarch64_cas4_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp4_relax, .{ .name = "__aarch64_swp4_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd4_relax, .{ .name = "__aarch64_ldadd4_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr4_relax, .{ .name = "__aarch64_ldclr4_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor4_relax, .{ .name = "__aarch64_ldeor4_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset4_relax, .{ .name = "__aarch64_ldset4_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas4_acq, .{ .name = "__aarch64_cas4_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp4_acq, .{ .name = "__aarch64_swp4_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd4_acq, .{ .name = "__aarch64_ldadd4_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr4_acq, .{ .name = "__aarch64_ldclr4_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor4_acq, .{ .name = "__aarch64_ldeor4_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset4_acq, .{ .name = "__aarch64_ldset4_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas4_rel, .{ .name = "__aarch64_cas4_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp4_rel, .{ .name = "__aarch64_swp4_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd4_rel, .{ .name = "__aarch64_ldadd4_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr4_rel, .{ .name = "__aarch64_ldclr4_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor4_rel, .{ .name = "__aarch64_ldeor4_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset4_rel, .{ .name = "__aarch64_ldset4_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas4_acq_rel, .{ .name = "__aarch64_cas4_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp4_acq_rel, .{ .name = "__aarch64_swp4_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd4_acq_rel, .{ .name = "__aarch64_ldadd4_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr4_acq_rel, .{ .name = "__aarch64_ldclr4_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor4_acq_rel, .{ .name = "__aarch64_ldeor4_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset4_acq_rel, .{ .name = "__aarch64_ldset4_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas8_relax, .{ .name = "__aarch64_cas8_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp8_relax, .{ .name = "__aarch64_swp8_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd8_relax, .{ .name = "__aarch64_ldadd8_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr8_relax, .{ .name = "__aarch64_ldclr8_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor8_relax, .{ .name = "__aarch64_ldeor8_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset8_relax, .{ .name = "__aarch64_ldset8_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas8_acq, .{ .name = "__aarch64_cas8_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp8_acq, .{ .name = "__aarch64_swp8_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd8_acq, .{ .name = "__aarch64_ldadd8_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr8_acq, .{ .name = "__aarch64_ldclr8_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor8_acq, .{ .name = "__aarch64_ldeor8_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset8_acq, .{ .name = "__aarch64_ldset8_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas8_rel, .{ .name = "__aarch64_cas8_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp8_rel, .{ .name = "__aarch64_swp8_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd8_rel, .{ .name = "__aarch64_ldadd8_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr8_rel, .{ .name = "__aarch64_ldclr8_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor8_rel, .{ .name = "__aarch64_ldeor8_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset8_rel, .{ .name = "__aarch64_ldset8_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas8_acq_rel, .{ .name = "__aarch64_cas8_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_swp8_acq_rel, .{ .name = "__aarch64_swp8_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldadd8_acq_rel, .{ .name = "__aarch64_ldadd8_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldclr8_acq_rel, .{ .name = "__aarch64_ldclr8_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldeor8_acq_rel, .{ .name = "__aarch64_ldeor8_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_ldset8_acq_rel, .{ .name = "__aarch64_ldset8_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas16_relax, .{ .name = "__aarch64_cas16_relax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas16_acq, .{ .name = "__aarch64_cas16_acq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas16_rel, .{ .name = "__aarch64_cas16_rel", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__aarch64_cas16_acq_rel, .{ .name = "__aarch64_cas16_acq_rel", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__aarch64_cas1_relax, "__aarch64_cas1_relax");
+    symbol(&__aarch64_swp1_relax, "__aarch64_swp1_relax");
+    symbol(&__aarch64_ldadd1_relax, "__aarch64_ldadd1_relax");
+    symbol(&__aarch64_ldclr1_relax, "__aarch64_ldclr1_relax");
+    symbol(&__aarch64_ldeor1_relax, "__aarch64_ldeor1_relax");
+    symbol(&__aarch64_ldset1_relax, "__aarch64_ldset1_relax");
+    symbol(&__aarch64_cas1_acq, "__aarch64_cas1_acq");
+    symbol(&__aarch64_swp1_acq, "__aarch64_swp1_acq");
+    symbol(&__aarch64_ldadd1_acq, "__aarch64_ldadd1_acq");
+    symbol(&__aarch64_ldclr1_acq, "__aarch64_ldclr1_acq");
+    symbol(&__aarch64_ldeor1_acq, "__aarch64_ldeor1_acq");
+    symbol(&__aarch64_ldset1_acq, "__aarch64_ldset1_acq");
+    symbol(&__aarch64_cas1_rel, "__aarch64_cas1_rel");
+    symbol(&__aarch64_swp1_rel, "__aarch64_swp1_rel");
+    symbol(&__aarch64_ldadd1_rel, "__aarch64_ldadd1_rel");
+    symbol(&__aarch64_ldclr1_rel, "__aarch64_ldclr1_rel");
+    symbol(&__aarch64_ldeor1_rel, "__aarch64_ldeor1_rel");
+    symbol(&__aarch64_ldset1_rel, "__aarch64_ldset1_rel");
+    symbol(&__aarch64_cas1_acq_rel, "__aarch64_cas1_acq_rel");
+    symbol(&__aarch64_swp1_acq_rel, "__aarch64_swp1_acq_rel");
+    symbol(&__aarch64_ldadd1_acq_rel, "__aarch64_ldadd1_acq_rel");
+    symbol(&__aarch64_ldclr1_acq_rel, "__aarch64_ldclr1_acq_rel");
+    symbol(&__aarch64_ldeor1_acq_rel, "__aarch64_ldeor1_acq_rel");
+    symbol(&__aarch64_ldset1_acq_rel, "__aarch64_ldset1_acq_rel");
+    symbol(&__aarch64_cas2_relax, "__aarch64_cas2_relax");
+    symbol(&__aarch64_swp2_relax, "__aarch64_swp2_relax");
+    symbol(&__aarch64_ldadd2_relax, "__aarch64_ldadd2_relax");
+    symbol(&__aarch64_ldclr2_relax, "__aarch64_ldclr2_relax");
+    symbol(&__aarch64_ldeor2_relax, "__aarch64_ldeor2_relax");
+    symbol(&__aarch64_ldset2_relax, "__aarch64_ldset2_relax");
+    symbol(&__aarch64_cas2_acq, "__aarch64_cas2_acq");
+    symbol(&__aarch64_swp2_acq, "__aarch64_swp2_acq");
+    symbol(&__aarch64_ldadd2_acq, "__aarch64_ldadd2_acq");
+    symbol(&__aarch64_ldclr2_acq, "__aarch64_ldclr2_acq");
+    symbol(&__aarch64_ldeor2_acq, "__aarch64_ldeor2_acq");
+    symbol(&__aarch64_ldset2_acq, "__aarch64_ldset2_acq");
+    symbol(&__aarch64_cas2_rel, "__aarch64_cas2_rel");
+    symbol(&__aarch64_swp2_rel, "__aarch64_swp2_rel");
+    symbol(&__aarch64_ldadd2_rel, "__aarch64_ldadd2_rel");
+    symbol(&__aarch64_ldclr2_rel, "__aarch64_ldclr2_rel");
+    symbol(&__aarch64_ldeor2_rel, "__aarch64_ldeor2_rel");
+    symbol(&__aarch64_ldset2_rel, "__aarch64_ldset2_rel");
+    symbol(&__aarch64_cas2_acq_rel, "__aarch64_cas2_acq_rel");
+    symbol(&__aarch64_swp2_acq_rel, "__aarch64_swp2_acq_rel");
+    symbol(&__aarch64_ldadd2_acq_rel, "__aarch64_ldadd2_acq_rel");
+    symbol(&__aarch64_ldclr2_acq_rel, "__aarch64_ldclr2_acq_rel");
+    symbol(&__aarch64_ldeor2_acq_rel, "__aarch64_ldeor2_acq_rel");
+    symbol(&__aarch64_ldset2_acq_rel, "__aarch64_ldset2_acq_rel");
+    symbol(&__aarch64_cas4_relax, "__aarch64_cas4_relax");
+    symbol(&__aarch64_swp4_relax, "__aarch64_swp4_relax");
+    symbol(&__aarch64_ldadd4_relax, "__aarch64_ldadd4_relax");
+    symbol(&__aarch64_ldclr4_relax, "__aarch64_ldclr4_relax");
+    symbol(&__aarch64_ldeor4_relax, "__aarch64_ldeor4_relax");
+    symbol(&__aarch64_ldset4_relax, "__aarch64_ldset4_relax");
+    symbol(&__aarch64_cas4_acq, "__aarch64_cas4_acq");
+    symbol(&__aarch64_swp4_acq, "__aarch64_swp4_acq");
+    symbol(&__aarch64_ldadd4_acq, "__aarch64_ldadd4_acq");
+    symbol(&__aarch64_ldclr4_acq, "__aarch64_ldclr4_acq");
+    symbol(&__aarch64_ldeor4_acq, "__aarch64_ldeor4_acq");
+    symbol(&__aarch64_ldset4_acq, "__aarch64_ldset4_acq");
+    symbol(&__aarch64_cas4_rel, "__aarch64_cas4_rel");
+    symbol(&__aarch64_swp4_rel, "__aarch64_swp4_rel");
+    symbol(&__aarch64_ldadd4_rel, "__aarch64_ldadd4_rel");
+    symbol(&__aarch64_ldclr4_rel, "__aarch64_ldclr4_rel");
+    symbol(&__aarch64_ldeor4_rel, "__aarch64_ldeor4_rel");
+    symbol(&__aarch64_ldset4_rel, "__aarch64_ldset4_rel");
+    symbol(&__aarch64_cas4_acq_rel, "__aarch64_cas4_acq_rel");
+    symbol(&__aarch64_swp4_acq_rel, "__aarch64_swp4_acq_rel");
+    symbol(&__aarch64_ldadd4_acq_rel, "__aarch64_ldadd4_acq_rel");
+    symbol(&__aarch64_ldclr4_acq_rel, "__aarch64_ldclr4_acq_rel");
+    symbol(&__aarch64_ldeor4_acq_rel, "__aarch64_ldeor4_acq_rel");
+    symbol(&__aarch64_ldset4_acq_rel, "__aarch64_ldset4_acq_rel");
+    symbol(&__aarch64_cas8_relax, "__aarch64_cas8_relax");
+    symbol(&__aarch64_swp8_relax, "__aarch64_swp8_relax");
+    symbol(&__aarch64_ldadd8_relax, "__aarch64_ldadd8_relax");
+    symbol(&__aarch64_ldclr8_relax, "__aarch64_ldclr8_relax");
+    symbol(&__aarch64_ldeor8_relax, "__aarch64_ldeor8_relax");
+    symbol(&__aarch64_ldset8_relax, "__aarch64_ldset8_relax");
+    symbol(&__aarch64_cas8_acq, "__aarch64_cas8_acq");
+    symbol(&__aarch64_swp8_acq, "__aarch64_swp8_acq");
+    symbol(&__aarch64_ldadd8_acq, "__aarch64_ldadd8_acq");
+    symbol(&__aarch64_ldclr8_acq, "__aarch64_ldclr8_acq");
+    symbol(&__aarch64_ldeor8_acq, "__aarch64_ldeor8_acq");
+    symbol(&__aarch64_ldset8_acq, "__aarch64_ldset8_acq");
+    symbol(&__aarch64_cas8_rel, "__aarch64_cas8_rel");
+    symbol(&__aarch64_swp8_rel, "__aarch64_swp8_rel");
+    symbol(&__aarch64_ldadd8_rel, "__aarch64_ldadd8_rel");
+    symbol(&__aarch64_ldclr8_rel, "__aarch64_ldclr8_rel");
+    symbol(&__aarch64_ldeor8_rel, "__aarch64_ldeor8_rel");
+    symbol(&__aarch64_ldset8_rel, "__aarch64_ldset8_rel");
+    symbol(&__aarch64_cas8_acq_rel, "__aarch64_cas8_acq_rel");
+    symbol(&__aarch64_swp8_acq_rel, "__aarch64_swp8_acq_rel");
+    symbol(&__aarch64_ldadd8_acq_rel, "__aarch64_ldadd8_acq_rel");
+    symbol(&__aarch64_ldclr8_acq_rel, "__aarch64_ldclr8_acq_rel");
+    symbol(&__aarch64_ldeor8_acq_rel, "__aarch64_ldeor8_acq_rel");
+    symbol(&__aarch64_ldset8_acq_rel, "__aarch64_ldset8_acq_rel");
+    symbol(&__aarch64_cas16_relax, "__aarch64_cas16_relax");
+    symbol(&__aarch64_cas16_acq, "__aarch64_cas16_acq");
+    symbol(&__aarch64_cas16_rel, "__aarch64_cas16_rel");
+    symbol(&__aarch64_cas16_acq_rel, "__aarch64_cas16_acq_rel");
 }
diff --git a/lib/compiler_rt/absvsi2.zig b/lib/compiler_rt/absvsi2.zig
index fb527cd997f6a16a001683effd5bb789d0080625..538d7f7f0155f98cf997b711514145ae77da5c2a 100644
--- a/lib/compiler_rt/absvsi2.zig
+++ b/lib/compiler_rt/absvsi2.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const absv = @import("./absv.zig").absv;
 
 comptime {
-    @export(&__absvsi2, .{ .name = "__absvsi2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__absvsi2, "__absvsi2");
 }
 
 pub fn __absvsi2(a: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/adddf3.zig b/lib/compiler_rt/adddf3.zig
index 7a49b0d782b7b50b022fee510f8cc885c567acd5..7b6f252da2c7f697b23b8e9e9fd13d34cc99bc80 100644
--- a/lib/compiler_rt/adddf3.zig
+++ b/lib/compiler_rt/adddf3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const addf3 = @import("./addf3.zig").addf3;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_dadd, "__aeabi_dadd");
     } else {
         symbol(&__adddf3, "__adddf3");
diff --git a/lib/compiler_rt/addf3.zig b/lib/compiler_rt/addf3.zig
index 60ae0165a8dab665be30baa96e05bc81d67112aa..91152735f445bbaa8abf459b17f9d597a1a030af 100644
--- a/lib/compiler_rt/addf3.zig
+++ b/lib/compiler_rt/addf3.zig
@@ -1,7 +1,7 @@
 const std = @import("std");
 const math = std.math;
-const common = @import("./common.zig");
-const normalize = common.normalize;
+const compiler_rt = @import("../compiler_rt.zig");
+const normalize = compiler_rt.normalize;
 
 /// Ported from:
 ///
diff --git a/lib/compiler_rt/addhf3.zig b/lib/compiler_rt/addhf3.zig
index 842c88f5d4268c9b3b2030096ba52bb296106dcd..bd13f48cac5f1ebeda2f019b1252d6a6967aa964 100644
--- a/lib/compiler_rt/addhf3.zig
+++ b/lib/compiler_rt/addhf3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const addf3 = @import("./addf3.zig").addf3;
 
 comptime {
-    @export(&__addhf3, .{ .name = "__addhf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__addhf3, "__addhf3");
 }
 
 fn __addhf3(a: f16, b: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/addsf3.zig b/lib/compiler_rt/addsf3.zig
index fb65bec624939a224e5938aabcdc77d821f43e3f..4878fb704d1769469fb0a9155c930f0e24e0cabc 100644
--- a/lib/compiler_rt/addsf3.zig
+++ b/lib/compiler_rt/addsf3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const addf3 = @import("./addf3.zig").addf3;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_fadd, "__aeabi_fadd");
     } else {
         symbol(&__addsf3, "__addsf3");
diff --git a/lib/compiler_rt/addtf3.zig b/lib/compiler_rt/addtf3.zig
index d4011f923805cce7f58da56beeadf5c7700b9001..50e699415a6db4d1376a03f7385543c17930e11c 100644
--- a/lib/compiler_rt/addtf3.zig
+++ b/lib/compiler_rt/addtf3.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const addf3 = @import("./addf3.zig").addf3;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__addtf3, .{ .name = "__addkf3", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_add, .{ .name = "_Qp_add", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__addtf3, "__addkf3");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_add, "_Qp_add");
     }
-    @export(&__addtf3, .{ .name = "__addtf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__addtf3, "__addtf3");
 }
 
 pub fn __addtf3(a: f128, b: f128) callconv(.c) f128 {
diff --git a/lib/compiler_rt/addvsi3.zig b/lib/compiler_rt/addvsi3.zig
index 468047eda1c5bf9440291928d5648ea216be9816..c35b22e8dfd73703480c89f4a5d305fa5b8ec9fd 100644
--- a/lib/compiler_rt/addvsi3.zig
+++ b/lib/compiler_rt/addvsi3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const testing = @import("std").testing;
 
 comptime {
-    @export(&__addvsi3, .{ .name = "__addvsi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__addvsi3, "__addvsi3");
 }
 
 pub fn __addvsi3(a: i32, b: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/addxf3.zig b/lib/compiler_rt/addxf3.zig
index e1509f04f5f69f703f243e7a7fc043e2b5dda4c8..f57708c98553874b47b62591b339e49b22ecedbd 100644
--- a/lib/compiler_rt/addxf3.zig
+++ b/lib/compiler_rt/addxf3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const addf3 = @import("./addf3.zig").addf3;
 
 comptime {
-    @export(&__addxf3, .{ .name = "__addxf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__addxf3, "__addxf3");
 }
 
 pub fn __addxf3(a: f80, b: f80) callconv(.c) f80 {
diff --git a/lib/compiler_rt/arm.zig b/lib/compiler_rt/arm.zig
index aa31e855dc13e8b2901bb67602a72e67d71625a6..eecb0e5d037bf5cbbb385caad94864a155a502d4 100644
--- a/lib/compiler_rt/arm.zig
+++ b/lib/compiler_rt/arm.zig
@@ -4,49 +4,50 @@ const std = @import("std");
 const builtin = @import("builtin");
 const target = builtin.target;
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
     if (!builtin.is_test) {
         if (arch.isArm()) {
-            @export(&__aeabi_unwind_cpp_pr0, .{ .name = "__aeabi_unwind_cpp_pr0", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_unwind_cpp_pr1, .{ .name = "__aeabi_unwind_cpp_pr1", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_unwind_cpp_pr2, .{ .name = "__aeabi_unwind_cpp_pr2", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_unwind_cpp_pr0, "__aeabi_unwind_cpp_pr0");
+            symbol(&__aeabi_unwind_cpp_pr1, "__aeabi_unwind_cpp_pr1");
+            symbol(&__aeabi_unwind_cpp_pr2, "__aeabi_unwind_cpp_pr2");
 
-            if (common.want_windows_arm_abi) {
-                @export(&__aeabi_ldivmod, .{ .name = "__rt_sdiv64", .linkage = common.linkage, .visibility = common.visibility });
-                @export(&__aeabi_uldivmod, .{ .name = "__rt_udiv64", .linkage = common.linkage, .visibility = common.visibility });
-                @export(&__aeabi_idivmod, .{ .name = "__rt_sdiv", .linkage = common.linkage, .visibility = common.visibility });
-                @export(&__aeabi_uidivmod, .{ .name = "__rt_udiv", .linkage = common.linkage, .visibility = common.visibility });
+            if (compiler_rt.want_windows_arm_abi) {
+                symbol(&__aeabi_ldivmod, "__rt_sdiv64");
+                symbol(&__aeabi_uldivmod, "__rt_udiv64");
+                symbol(&__aeabi_idivmod, "__rt_sdiv");
+                symbol(&__aeabi_uidivmod, "__rt_udiv");
             }
-            @export(&__aeabi_ldivmod, .{ .name = "__aeabi_ldivmod", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_uldivmod, .{ .name = "__aeabi_uldivmod", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_idivmod, .{ .name = "__aeabi_idivmod", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_uidivmod, .{ .name = "__aeabi_uidivmod", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_ldivmod, "__aeabi_ldivmod");
+            symbol(&__aeabi_uldivmod, "__aeabi_uldivmod");
+            symbol(&__aeabi_idivmod, "__aeabi_idivmod");
+            symbol(&__aeabi_uidivmod, "__aeabi_uidivmod");
 
-            @export(&__aeabi_memcpy, .{ .name = "__aeabi_memcpy", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memcpy4, .{ .name = "__aeabi_memcpy4", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memcpy8, .{ .name = "__aeabi_memcpy8", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_memcpy, "__aeabi_memcpy");
+            symbol(&__aeabi_memcpy4, "__aeabi_memcpy4");
+            symbol(&__aeabi_memcpy8, "__aeabi_memcpy8");
 
-            @export(&__aeabi_memmove, .{ .name = "__aeabi_memmove", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memmove4, .{ .name = "__aeabi_memmove4", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memmove8, .{ .name = "__aeabi_memmove8", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_memmove, "__aeabi_memmove");
+            symbol(&__aeabi_memmove4, "__aeabi_memmove4");
+            symbol(&__aeabi_memmove8, "__aeabi_memmove8");
 
-            @export(&__aeabi_memset, .{ .name = "__aeabi_memset", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memset4, .{ .name = "__aeabi_memset4", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memset8, .{ .name = "__aeabi_memset8", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_memset, "__aeabi_memset");
+            symbol(&__aeabi_memset4, "__aeabi_memset4");
+            symbol(&__aeabi_memset8, "__aeabi_memset8");
 
-            @export(&__aeabi_memclr, .{ .name = "__aeabi_memclr", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memclr4, .{ .name = "__aeabi_memclr4", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_memclr8, .{ .name = "__aeabi_memclr8", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_memclr, "__aeabi_memclr");
+            symbol(&__aeabi_memclr4, "__aeabi_memclr4");
+            symbol(&__aeabi_memclr8, "__aeabi_memclr8");
 
             if (builtin.os.tag == .linux or builtin.os.tag == .freebsd) {
-                @export(&__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = common.linkage, .visibility = common.visibility });
+                symbol(&__aeabi_read_tp, "__aeabi_read_tp");
             }
 
             // floating-point helper functions (single+double-precision reverse subtraction, y – x), see subdf3.zig
-            @export(&__aeabi_frsub, .{ .name = "__aeabi_frsub", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__aeabi_drsub, .{ .name = "__aeabi_drsub", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__aeabi_frsub, "__aeabi_frsub");
+            symbol(&__aeabi_drsub, "__aeabi_drsub");
         }
     }
 }
diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig
index 31c87f4b1ba6ab6f6f668952e61770fcbcd641cd..d6eaf4d67178feb800c7490a8fc282871de26e96 100644
--- a/lib/compiler_rt/atomics.zig
+++ b/lib/compiler_rt/atomics.zig
@@ -4,7 +4,7 @@ const arch = cpu.arch;
 
 const std = @import("std");
 
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 // This parameter is true iff the target architecture supports the bare minimum
diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig
index fb0d6126a86f46a3af3fca1b979be1245ce36b0f..4ed92f39eefde1b941634b5b72eac8d1e41ba0d2 100644
--- a/lib/compiler_rt/aulldiv.zig
+++ b/lib/compiler_rt/aulldiv.zig
@@ -1,10 +1,10 @@
 const builtin = @import("builtin");
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_x86_msvc_abi) {
+    if (compiler_rt.want_windows_x86_msvc_abi) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
         symbol(&_alldiv, "\x01__alldiv");
         symbol(&_aulldiv, "\x01__aulldiv");
diff --git a/lib/compiler_rt/aullrem.zig b/lib/compiler_rt/aullrem.zig
index ea12c16a0620c16d27711831bfb753d791403e5d..efb8f15b733f4962fa37d2fb58b7ca8a13f539e6 100644
--- a/lib/compiler_rt/aullrem.zig
+++ b/lib/compiler_rt/aullrem.zig
@@ -3,13 +3,14 @@ const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 const os = builtin.os.tag;
 const abi = builtin.abi;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    if (common.want_windows_x86_msvc_abi) {
+    if (compiler_rt.want_windows_x86_msvc_abi) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
-        @export(&_allrem, .{ .name = "\x01__allrem", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_aullrem, .{ .name = "\x01__aullrem", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_allrem, "\x01__allrem");
+        symbol(&_aullrem, "\x01__aullrem");
     }
 }
 
diff --git a/lib/compiler_rt/bcmp.zig b/lib/compiler_rt/bcmp.zig
deleted file mode 100644
index eb1fca21f0118640c5490f82ca7c0fb26a8c10cd..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/bcmp.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-const std = @import("std");
-const common = @import("./common.zig");
-
-comptime {
-    @export(&bcmp, .{ .name = "bcmp", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-pub fn bcmp(vl: [*]allowzero const u8, vr: [*]allowzero const u8, n: usize) callconv(.c) c_int {
-    @setRuntimeSafety(false);
-
-    var index: usize = 0;
-    while (index != n) : (index += 1) {
-        if (vl[index] != vr[index]) {
-            return 1;
-        }
-    }
-
-    return 0;
-}
-
-test "bcmp" {
-    const base_arr = &[_]u8{ 1, 1, 1 };
-    const arr1 = &[_]u8{ 1, 1, 1 };
-    const arr2 = &[_]u8{ 1, 0, 1 };
-    const arr3 = &[_]u8{ 1, 2, 1 };
-
-    try std.testing.expect(bcmp(base_arr[0..], arr1[0..], base_arr.len) == 0);
-    try std.testing.expect(bcmp(base_arr[0..], arr2[0..], base_arr.len) != 0);
-    try std.testing.expect(bcmp(base_arr[0..], arr3[0..], base_arr.len) != 0);
-}
diff --git a/lib/compiler_rt/bitreverse.zig b/lib/compiler_rt/bitreverse.zig
index 6dbeac77d9e196c8363a4fd8faf5888131c9d858..dda620152d6dfb3d1f877beb1adcfcf5117d2c31 100644
--- a/lib/compiler_rt/bitreverse.zig
+++ b/lib/compiler_rt/bitreverse.zig
@@ -1,11 +1,12 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__bitreversesi2, .{ .name = "__bitreversesi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__bitreversedi2, .{ .name = "__bitreversedi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__bitreverseti2, .{ .name = "__bitreverseti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__bitreversesi2, "__bitreversesi2");
+    symbol(&__bitreversedi2, "__bitreversedi2");
+    symbol(&__bitreverseti2, "__bitreverseti2");
 }
 
 inline fn bitreverseXi2(comptime T: type, a: T) T {
diff --git a/lib/compiler_rt/bswap.zig b/lib/compiler_rt/bswap.zig
index e6f634c66fb787de4d0671ca622d696c2e930e7f..94c3294eaf8e2da54dabf03dbd1c33aa7dec3244 100644
--- a/lib/compiler_rt/bswap.zig
+++ b/lib/compiler_rt/bswap.zig
@@ -1,11 +1,12 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__bswapsi2, .{ .name = "__bswapsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__bswapdi2, .{ .name = "__bswapdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__bswapti2, .{ .name = "__bswapti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__bswapsi2, "__bswapsi2");
+    symbol(&__bswapdi2, "__bswapdi2");
+    symbol(&__bswapti2, "__bswapti2");
 }
 
 // bswap - byteswap
diff --git a/lib/compiler_rt/clear_cache.zig b/lib/compiler_rt/clear_cache.zig
index 0e3b5d371f93e8b8374ff83537ee8aed10357fa5..2a8226c1300332caa9ef89259fa61f80f80fea55 100644
--- a/lib/compiler_rt/clear_cache.zig
+++ b/lib/compiler_rt/clear_cache.zig
@@ -2,7 +2,8 @@ const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 const os = builtin.os.tag;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 // Ported from llvm-project d32170dbd5b0d54436537b6b75beaf44324e0c28
 
@@ -188,7 +189,7 @@ fn clear_cache(start: usize, end: usize) callconv(.c) void {
 }
 
 fn exportIt() void {
-    @export(&clear_cache, .{ .name = "__clear_cache", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&clear_cache, "__clear_cache");
 }
 
 // MIPS-only
diff --git a/lib/compiler_rt/cmp.zig b/lib/compiler_rt/cmp.zig
index cac23a7508f1546d8fe372582bd03e526062868a..9b123f5007172e8ae64990eab09e4751b0f72a66 100644
--- a/lib/compiler_rt/cmp.zig
+++ b/lib/compiler_rt/cmp.zig
@@ -1,14 +1,15 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__cmpsi2, .{ .name = "__cmpsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__cmpdi2, .{ .name = "__cmpdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__cmpti2, .{ .name = "__cmpti2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ucmpsi2, .{ .name = "__ucmpsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ucmpdi2, .{ .name = "__ucmpdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ucmpti2, .{ .name = "__ucmpti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__cmpsi2, "__cmpsi2");
+    symbol(&__cmpdi2, "__cmpdi2");
+    symbol(&__cmpti2, "__cmpti2");
+    symbol(&__ucmpsi2, "__ucmpsi2");
+    symbol(&__ucmpdi2, "__ucmpdi2");
+    symbol(&__ucmpti2, "__ucmpti2");
 }
 
 // cmp - signed compare
diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig
index 691827ac4b2565a5e01a8c74ff7a0d785e788725..7a9295bcdb764fc9860a591ef16adadf844c3d96 100644
--- a/lib/compiler_rt/cmpdf2.zig
+++ b/lib/compiler_rt/cmpdf2.zig
@@ -1,11 +1,11 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const comparef = @import("./comparef.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_dcmpeq, "__aeabi_dcmpeq");
         symbol(&__aeabi_dcmplt, "__aeabi_dcmplt");
         symbol(&__aeabi_dcmple, "__aeabi_dcmple");
diff --git a/lib/compiler_rt/cmphf2.zig b/lib/compiler_rt/cmphf2.zig
deleted file mode 100644
index ea70e71e161fe6131e48632d5a455862455257f7..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/cmphf2.zig
+++ /dev/null
@@ -1,48 +0,0 @@
-///! The quoted behavior definitions are from
-///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
-const comparef = @import("./comparef.zig");
-
-comptime {
-    @export(&__eqhf2, .{ .name = "__eqhf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__nehf2, .{ .name = "__nehf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__lehf2, .{ .name = "__lehf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__cmphf2, .{ .name = "__cmphf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__lthf2, .{ .name = "__lthf2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
-/// if a is greater than b, they return 1; and if a and b are equal they return 0.
-/// If either argument is NaN they return 1..."
-///
-/// Note that this matches the definition of `__lehf2`, `__eqhf2`, `__nehf2`, `__cmphf2`,
-/// and `__lthf2`.
-fn __cmphf2(a: f16, b: f16) callconv(.c) i32 {
-    return @intFromEnum(comparef.cmpf2(f16, comparef.LE, a, b));
-}
-
-/// "These functions return a value less than or equal to zero if neither argument is NaN,
-/// and a is less than or equal to b."
-pub fn __lehf2(a: f16, b: f16) callconv(.c) i32 {
-    return __cmphf2(a, b);
-}
-
-/// "These functions return zero if neither argument is NaN, and a and b are equal."
-/// Note that due to some kind of historical accident, __eqhf2 and __nehf2 are defined
-/// to have the same return value.
-pub fn __eqhf2(a: f16, b: f16) callconv(.c) i32 {
-    return __cmphf2(a, b);
-}
-
-/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
-/// Note that due to some kind of historical accident, __eqhf2 and __nehf2 are defined
-/// to have the same return value.
-pub fn __nehf2(a: f16, b: f16) callconv(.c) i32 {
-    return __cmphf2(a, b);
-}
-
-/// "These functions return a value less than zero if neither argument is NaN, and a
-/// is strictly less than b."
-pub fn __lthf2(a: f16, b: f16) callconv(.c) i32 {
-    return __cmphf2(a, b);
-}
diff --git a/lib/compiler_rt/cmpsf2.zig b/lib/compiler_rt/cmpsf2.zig
deleted file mode 100644
index 4b200198e662fcdab160b1f5ab79b1914b6c4d65..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/cmpsf2.zig
+++ /dev/null
@@ -1,66 +0,0 @@
-///! The quoted behavior definitions are from
-///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
-const comparef = @import("./comparef.zig");
-
-comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__eqsf2, .{ .name = "__eqsf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__nesf2, .{ .name = "__nesf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__lesf2, .{ .name = "__lesf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__cmpsf2, .{ .name = "__cmpsf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__ltsf2, .{ .name = "__ltsf2", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
-/// if a is greater than b, they return 1; and if a and b are equal they return 0.
-/// If either argument is NaN they return 1..."
-///
-/// Note that this matches the definition of `__lesf2`, `__eqsf2`, `__nesf2`, `__cmpsf2`,
-/// and `__ltsf2`.
-fn __cmpsf2(a: f32, b: f32) callconv(.c) i32 {
-    return @intFromEnum(comparef.cmpf2(f32, comparef.LE, a, b));
-}
-
-/// "These functions return a value less than or equal to zero if neither argument is NaN,
-/// and a is less than or equal to b."
-pub fn __lesf2(a: f32, b: f32) callconv(.c) i32 {
-    return __cmpsf2(a, b);
-}
-
-/// "These functions return zero if neither argument is NaN, and a and b are equal."
-/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
-/// to have the same return value.
-pub fn __eqsf2(a: f32, b: f32) callconv(.c) i32 {
-    return __cmpsf2(a, b);
-}
-
-/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
-/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
-/// to have the same return value.
-pub fn __nesf2(a: f32, b: f32) callconv(.c) i32 {
-    return __cmpsf2(a, b);
-}
-
-/// "These functions return a value less than zero if neither argument is NaN, and a
-/// is strictly less than b."
-pub fn __ltsf2(a: f32, b: f32) callconv(.c) i32 {
-    return __cmpsf2(a, b);
-}
-
-fn __aeabi_fcmpeq(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
-    return @intFromBool(comparef.cmpf2(f32, comparef.LE, a, b) == .Equal);
-}
-
-fn __aeabi_fcmplt(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
-    return @intFromBool(comparef.cmpf2(f32, comparef.LE, a, b) == .Less);
-}
-
-fn __aeabi_fcmple(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
-    return @intFromBool(comparef.cmpf2(f32, comparef.LE, a, b) != .Greater);
-}
diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig
index 846e62935c763e1311d0e635f6af6116d7eeea38..bdffc97f8694d2e98939f525ffb8027d066d85f3 100644
--- a/lib/compiler_rt/cmptf2.zig
+++ b/lib/compiler_rt/cmptf2.zig
@@ -1,16 +1,16 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const comparef = @import("./comparef.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__eqtf2, "__eqkf2");
         symbol(&__netf2, "__nekf2");
         symbol(&__lttf2, "__ltkf2");
         symbol(&__letf2, "__lekf2");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_cmp, "_Qp_cmp");
         symbol(&_Qp_feq, "_Qp_feq");
         symbol(&_Qp_fne, "_Qp_fne");
diff --git a/lib/compiler_rt/cmpxf2.zig b/lib/compiler_rt/cmpxf2.zig
index f70de9c0b617eacdb8a9d1a751280c980b07f79c..c6e2e375a1f6c5d80331d8bd325f937248202168 100644
--- a/lib/compiler_rt/cmpxf2.zig
+++ b/lib/compiler_rt/cmpxf2.zig
@@ -1,14 +1,15 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    @export(&__eqxf2, .{ .name = "__eqxf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__nexf2, .{ .name = "__nexf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__lexf2, .{ .name = "__lexf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__cmpxf2, .{ .name = "__cmpxf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ltxf2, .{ .name = "__ltxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__eqxf2, "__eqxf2");
+    symbol(&__nexf2, "__nexf2");
+    symbol(&__lexf2, "__lexf2");
+    symbol(&__cmpxf2, "__cmpxf2");
+    symbol(&__ltxf2, "__ltxf2");
 }
 
 /// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
deleted file mode 100644
index 0839d78b1b34d4c18f87d9143c0d9599135899f9..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/common.zig
+++ /dev/null
@@ -1,296 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const native_endian = builtin.cpu.arch.endian();
-const ofmt_c = builtin.object_format == .c;
-
-/// Deprecated, everything in common should move to compiler_rt.zig
-pub const linkage = @import("../compiler_rt.zig").linkage;
-
-/// Deprecated, everything in common should move to compiler_rt.zig
-pub const visibility = @import("../compiler_rt.zig").visibility;
-
-pub const PreferredLoadStoreElement = element: {
-    if (std.simd.suggestVectorLength(u8)) |vec_size| {
-        const Vec = @Vector(vec_size, u8);
-
-        if (@sizeOf(Vec) == vec_size and std.math.isPowerOfTwo(vec_size)) {
-            break :element Vec;
-        }
-    }
-    break :element usize;
-};
-
-pub const want_aeabi = switch (builtin.abi) {
-    .eabi,
-    .eabihf,
-    .musleabi,
-    .musleabihf,
-    .gnueabi,
-    .gnueabihf,
-    .android,
-    .androideabi,
-    => switch (builtin.cpu.arch) {
-        .arm, .armeb, .thumb, .thumbeb => true,
-        else => false,
-    },
-    else => false,
-};
-
-/// These functions are required on Windows on ARM. They are provided by MSVC libc, but in libc-less
-/// builds or when linking MinGW libc they are our responsibility.
-/// Temporarily used for thumb-uefi until https://github.com/ziglang/zig/issues/21630 is addressed.
-pub const want_windows_arm_abi = e: {
-    if (!builtin.cpu.arch.isArm()) break :e false;
-    switch (builtin.os.tag) {
-        .windows, .uefi => {},
-        else => break :e false,
-    }
-    // The ABI is needed, but it's only our reponsibility if libc won't provide it.
-    break :e builtin.abi.isGnu() or !builtin.link_libc;
-};
-
-/// These functions are required by on Windows on x86 on some ABIs. They are provided by MSVC libc,
-/// but in libc-less builds they are our responsibility.
-pub const want_windows_x86_msvc_abi = e: {
-    if (builtin.cpu.arch != .x86) break :e false;
-    if (builtin.os.tag != .windows) break :e false;
-    switch (builtin.abi) {
-        .none, .msvc, .itanium => {},
-        else => break :e false,
-    }
-    // The ABI is needed, but it's only our responsibility if libc won't provide it.
-    break :e !builtin.link_libc;
-};
-
-pub const want_ppc_abi = builtin.cpu.arch.isPowerPC();
-
-pub const want_float_exceptions = !builtin.cpu.arch.isWasm();
-
-// Libcalls that involve u128 on Windows x86-64 are expected by LLVM to use the
-// calling convention of @Vector(2, u64), rather than what's standard.
-pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c;
-
-/// This governs whether to use these symbol names for f16/f32 conversions
-/// rather than the standard names:
-/// * __gnu_f2h_ieee
-/// * __gnu_h2f_ieee
-/// Known correct configurations:
-///   x86_64-freestanding-none => true
-///   x86_64-linux-none => true
-///   x86_64-linux-gnu => true
-///   x86_64-linux-musl => true
-///   x86_64-linux-eabi => true
-///   arm-linux-musleabihf => true
-///   arm-linux-gnueabihf => true
-///   arm-linux-eabihf => false
-///   wasm32-wasi-musl => false
-///   wasm32-freestanding-none => false
-///   x86_64-windows-gnu => true
-///   x86_64-windows-msvc => true
-///   any-macos-any => false
-pub const gnu_f16_abi = switch (builtin.cpu.arch) {
-    .wasm32,
-    .wasm64,
-    .riscv64,
-    .riscv64be,
-    .riscv32,
-    .riscv32be,
-    => false,
-
-    .x86, .x86_64 => true,
-
-    .arm, .armeb, .thumb, .thumbeb => switch (builtin.abi) {
-        .eabi, .eabihf => false,
-        else => true,
-    },
-
-    else => !builtin.os.tag.isDarwin(),
-};
-
-pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
-
-/// Deprecated, everything in common should move to compiler_rt.zig
-pub const test_safety = @import("../compiler_rt.zig").test_safety;
-
-/// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
-pub fn F16T(comptime OtherType: type) type {
-    return switch (builtin.cpu.arch) {
-        .amdgcn,
-        .arm,
-        .armeb,
-        .thumb,
-        .thumbeb,
-        .aarch64,
-        .aarch64_be,
-        .hexagon,
-        .loongarch32,
-        .loongarch64,
-        .nvptx,
-        .nvptx64,
-        .riscv32,
-        .riscv32be,
-        .riscv64,
-        .riscv64be,
-        .s390x,
-        .spirv32,
-        .spirv64,
-        => f16,
-        .x86, .x86_64 => if (builtin.target.os.tag.isDarwin()) switch (OtherType) {
-            // Starting with LLVM 16, Darwin uses different abi for f16
-            // depending on the type of the other return/argument..???
-            f32, f64 => u16,
-            f80, f128 => f16,
-            else => unreachable,
-        } else f16,
-        else => u16,
-    };
-}
-
-pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
-    switch (Z) {
-        u16 => {
-            // 16x16 --> 32 bit multiply
-            const product = @as(u32, a) * @as(u32, b);
-            hi.* = @intCast(product >> 16);
-            lo.* = @truncate(product);
-        },
-        u32 => {
-            // 32x32 --> 64 bit multiply
-            const product = @as(u64, a) * @as(u64, b);
-            hi.* = @truncate(product >> 32);
-            lo.* = @truncate(product);
-        },
-        u64 => {
-            const S = struct {
-                fn loWord(x: u64) u64 {
-                    return @as(u32, @truncate(x));
-                }
-                fn hiWord(x: u64) u64 {
-                    return @as(u32, @truncate(x >> 32));
-                }
-            };
-            // 64x64 -> 128 wide multiply for platforms that don't have such an operation;
-            // many 64-bit platforms have this operation, but they tend to have hardware
-            // floating-point, so we don't bother with a special case for them here.
-            // Each of the component 32x32 -> 64 products
-            const plolo: u64 = S.loWord(a) * S.loWord(b);
-            const plohi: u64 = S.loWord(a) * S.hiWord(b);
-            const philo: u64 = S.hiWord(a) * S.loWord(b);
-            const phihi: u64 = S.hiWord(a) * S.hiWord(b);
-            // Sum terms that contribute to lo in a way that allows us to get the carry
-            const r0: u64 = S.loWord(plolo);
-            const r1: u64 = S.hiWord(plolo) +% S.loWord(plohi) +% S.loWord(philo);
-            lo.* = r0 +% (r1 << 32);
-            // Sum terms contributing to hi with the carry from lo
-            hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi;
-        },
-        u128 => {
-            const Word_LoMask: u64 = 0x00000000ffffffff;
-            const Word_HiMask: u64 = 0xffffffff00000000;
-            const Word_FullMask: u64 = 0xffffffffffffffff;
-            const S = struct {
-                fn Word_1(x: u128) u64 {
-                    return @as(u32, @truncate(x >> 96));
-                }
-                fn Word_2(x: u128) u64 {
-                    return @as(u32, @truncate(x >> 64));
-                }
-                fn Word_3(x: u128) u64 {
-                    return @as(u32, @truncate(x >> 32));
-                }
-                fn Word_4(x: u128) u64 {
-                    return @as(u32, @truncate(x));
-                }
-            };
-            // 128x128 -> 256 wide multiply for platforms that don't have such an operation;
-            // many 64-bit platforms have this operation, but they tend to have hardware
-            // floating-point, so we don't bother with a special case for them here.
-
-            const product11: u64 = S.Word_1(a) * S.Word_1(b);
-            const product12: u64 = S.Word_1(a) * S.Word_2(b);
-            const product13: u64 = S.Word_1(a) * S.Word_3(b);
-            const product14: u64 = S.Word_1(a) * S.Word_4(b);
-            const product21: u64 = S.Word_2(a) * S.Word_1(b);
-            const product22: u64 = S.Word_2(a) * S.Word_2(b);
-            const product23: u64 = S.Word_2(a) * S.Word_3(b);
-            const product24: u64 = S.Word_2(a) * S.Word_4(b);
-            const product31: u64 = S.Word_3(a) * S.Word_1(b);
-            const product32: u64 = S.Word_3(a) * S.Word_2(b);
-            const product33: u64 = S.Word_3(a) * S.Word_3(b);
-            const product34: u64 = S.Word_3(a) * S.Word_4(b);
-            const product41: u64 = S.Word_4(a) * S.Word_1(b);
-            const product42: u64 = S.Word_4(a) * S.Word_2(b);
-            const product43: u64 = S.Word_4(a) * S.Word_3(b);
-            const product44: u64 = S.Word_4(a) * S.Word_4(b);
-
-            const sum0: u128 = @as(u128, product44);
-            const sum1: u128 = @as(u128, product34) +%
-                @as(u128, product43);
-            const sum2: u128 = @as(u128, product24) +%
-                @as(u128, product33) +%
-                @as(u128, product42);
-            const sum3: u128 = @as(u128, product14) +%
-                @as(u128, product23) +%
-                @as(u128, product32) +%
-                @as(u128, product41);
-            const sum4: u128 = @as(u128, product13) +%
-                @as(u128, product22) +%
-                @as(u128, product31);
-            const sum5: u128 = @as(u128, product12) +%
-                @as(u128, product21);
-            const sum6: u128 = @as(u128, product11);
-
-            const r0: u128 = (sum0 & Word_FullMask) +%
-                ((sum1 & Word_LoMask) << 32);
-            const r1: u128 = (sum0 >> 64) +%
-                ((sum1 >> 32) & Word_FullMask) +%
-                (sum2 & Word_FullMask) +%
-                ((sum3 << 32) & Word_HiMask);
-
-            lo.* = r0 +% (r1 << 64);
-            hi.* = (r1 >> 64) +%
-                (sum1 >> 96) +%
-                (sum2 >> 64) +%
-                (sum3 >> 32) +%
-                sum4 +%
-                (sum5 << 32) +%
-                (sum6 << 64);
-        },
-        else => @compileError("unsupported"),
-    }
-}
-
-pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).float.bits)) i32 {
-    const Z = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
-    const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
-
-    const shift = @clz(significand.*) - @clz(integerBit);
-    significand.* <<= @as(std.math.Log2Int(Z), @intCast(shift));
-    return @as(i32, 1) - shift;
-}
-
-pub inline fn fneg(a: anytype) @TypeOf(a) {
-    const F = @TypeOf(a);
-    const bits = @typeInfo(F).float.bits;
-    const U = @Int(.unsigned, bits);
-    const sign_bit_mask = @as(U, 1) << (bits - 1);
-    const negated = @as(U, @bitCast(a)) ^ sign_bit_mask;
-    return @bitCast(negated);
-}
-
-/// Allows to access underlying bits as two equally sized lower and higher
-/// signed or unsigned integers.
-pub fn HalveInt(comptime T: type, comptime signed_half: bool) type {
-    return extern union {
-        pub const bits = @divExact(@typeInfo(T).int.bits, 2);
-        pub const HalfTU = std.meta.Int(.unsigned, bits);
-        pub const HalfTS = std.meta.Int(.signed, bits);
-        pub const HalfT = if (signed_half) HalfTS else HalfTU;
-
-        all: T,
-        s: if (native_endian == .little)
-            extern struct { low: HalfT, high: HalfT }
-        else
-            extern struct { high: HalfT, low: HalfT },
-    };
-}
diff --git a/lib/compiler_rt/comparef.zig b/lib/compiler_rt/comparef.zig
index 76f04f430a4c177265d9679c3e089f41b221753f..3e9747758966f1c11d0e0a2a72eee0782e928a83 100644
--- a/lib/compiler_rt/comparef.zig
+++ b/lib/compiler_rt/comparef.zig
@@ -1,5 +1,149 @@
 const std = @import("std");
 
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+
+comptime {
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_fcmpun, "__aeabi_fcmpun");
+    } else {
+        symbol(&__unordsf2, "__unordsf2");
+    }
+
+    symbol(&__unordxf2, "__unordxf2");
+
+    symbol(&__eqhf2, "__eqhf2");
+    symbol(&__nehf2, "__nehf2");
+    symbol(&__lehf2, "__lehf2");
+    symbol(&__cmphf2, "__cmphf2");
+    symbol(&__lthf2, "__lthf2");
+
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_fcmpeq, "__aeabi_fcmpeq");
+        symbol(&__aeabi_fcmplt, "__aeabi_fcmplt");
+        symbol(&__aeabi_fcmple, "__aeabi_fcmple");
+    } else {
+        symbol(&__eqsf2, "__eqsf2");
+        symbol(&__nesf2, "__nesf2");
+        symbol(&__lesf2, "__lesf2");
+        symbol(&__cmpsf2, "__cmpsf2");
+        symbol(&__ltsf2, "__ltsf2");
+    }
+
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__unordtf2, "__unordkf2");
+    } else if (compiler_rt.want_sparc_abi) {
+        // These exports are handled in cmptf2.zig because unordered comparisons
+        // are based on calling _Qp_cmp.
+    }
+    symbol(&__unordtf2, "__unordtf2");
+    symbol(&__unordhf2, "__unordhf2");
+}
+
+pub fn __unordhf2(a: f16, b: f16) callconv(.c) i32 {
+    return unordcmp(f16, a, b);
+}
+
+pub fn __unordtf2(a: f128, b: f128) callconv(.c) i32 {
+    return unordcmp(f128, a, b);
+}
+
+/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
+/// if a is greater than b, they return 1; and if a and b are equal they return 0.
+/// If either argument is NaN they return 1..."
+///
+/// Note that this matches the definition of `__lesf2`, `__eqsf2`, `__nesf2`, `__cmpsf2`,
+/// and `__ltsf2`.
+fn __cmpsf2(a: f32, b: f32) callconv(.c) i32 {
+    return @intFromEnum(cmpf2(f32, LE, a, b));
+}
+
+/// "These functions return a value less than or equal to zero if neither argument is NaN,
+/// and a is less than or equal to b."
+pub fn __lesf2(a: f32, b: f32) callconv(.c) i32 {
+    return __cmpsf2(a, b);
+}
+
+/// "These functions return zero if neither argument is NaN, and a and b are equal."
+/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
+/// to have the same return value.
+pub fn __eqsf2(a: f32, b: f32) callconv(.c) i32 {
+    return __cmpsf2(a, b);
+}
+
+/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
+/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
+/// to have the same return value.
+pub fn __nesf2(a: f32, b: f32) callconv(.c) i32 {
+    return __cmpsf2(a, b);
+}
+
+/// "These functions return a value less than zero if neither argument is NaN, and a
+/// is strictly less than b."
+pub fn __ltsf2(a: f32, b: f32) callconv(.c) i32 {
+    return __cmpsf2(a, b);
+}
+
+fn __aeabi_fcmpeq(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
+    return @intFromBool(cmpf2(f32, LE, a, b) == .Equal);
+}
+
+fn __aeabi_fcmplt(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
+    return @intFromBool(cmpf2(f32, LE, a, b) == .Less);
+}
+
+fn __aeabi_fcmple(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
+    return @intFromBool(cmpf2(f32, LE, a, b) != .Greater);
+}
+
+/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
+/// if a is greater than b, they return 1; and if a and b are equal they return 0.
+/// If either argument is NaN they return 1..."
+///
+/// Note that this matches the definition of `__lehf2`, `__eqhf2`, `__nehf2`, `__cmphf2`,
+/// and `__lthf2`.
+fn __cmphf2(a: f16, b: f16) callconv(.c) i32 {
+    return @intFromEnum(cmpf2(f16, LE, a, b));
+}
+
+/// "These functions return a value less than or equal to zero if neither argument is NaN,
+/// and a is less than or equal to b."
+fn __lehf2(a: f16, b: f16) callconv(.c) i32 {
+    return __cmphf2(a, b);
+}
+
+/// "These functions return zero if neither argument is NaN, and a and b are equal."
+/// Note that due to some kind of historical accident, __eqhf2 and __nehf2 are defined
+/// to have the same return value.
+fn __eqhf2(a: f16, b: f16) callconv(.c) i32 {
+    return __cmphf2(a, b);
+}
+
+/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
+/// Note that due to some kind of historical accident, __eqhf2 and __nehf2 are defined
+/// to have the same return value.
+fn __nehf2(a: f16, b: f16) callconv(.c) i32 {
+    return __cmphf2(a, b);
+}
+
+/// "These functions return a value less than zero if neither argument is NaN, and a
+/// is strictly less than b."
+fn __lthf2(a: f16, b: f16) callconv(.c) i32 {
+    return __cmphf2(a, b);
+}
+
+fn __unordxf2(a: f80, b: f80) callconv(.c) i32 {
+    return unordcmp(f80, a, b);
+}
+
+pub fn __unordsf2(a: f32, b: f32) callconv(.c) i32 {
+    return unordcmp(f32, a, b);
+}
+
+fn __aeabi_fcmpun(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
+    return unordcmp(f32, a, b);
+}
+
 pub const LE = enum(i32) {
     Less = -1,
     Equal = 0,
diff --git a/lib/compiler_rt/comparesf2_test.zig b/lib/compiler_rt/comparesf2_test.zig
index 65e78da99e1f4c48bcd2522772c4af45c4b14366..d42e1ca6db124de615f2eb3a74eadfeb119992eb 100644
--- a/lib/compiler_rt/comparesf2_test.zig
+++ b/lib/compiler_rt/comparesf2_test.zig
@@ -5,15 +5,15 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-const __eqsf2 = @import("./cmpsf2.zig").__eqsf2;
-const __lesf2 = @import("./cmpsf2.zig").__lesf2;
-const __ltsf2 = @import("./cmpsf2.zig").__ltsf2;
-const __nesf2 = @import("./cmpsf2.zig").__nesf2;
+const __eqsf2 = @import("./comparef.zig").__eqsf2;
+const __lesf2 = @import("./comparef.zig").__lesf2;
+const __ltsf2 = @import("./comparef.zig").__ltsf2;
+const __nesf2 = @import("./comparef.zig").__nesf2;
 
 const __gesf2 = @import("./gesf2.zig").__gesf2;
 const __gtsf2 = @import("./gesf2.zig").__gtsf2;
 
-const __unordsf2 = @import("./unordsf2.zig").__unordsf2;
+const __unordsf2 = @import("./comparef.zig").__unordsf2;
 
 const TestVector = struct {
     a: f32,
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 406098d56b9a172ca99f725b401cd42a27185047..3534e7837cc2c144c167c38698115e907e6469b7 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -3,7 +3,7 @@ const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
@@ -14,7 +14,7 @@ comptime {
     symbol(&cosf, "cosf");
     symbol(&cos, "cos");
     symbol(&__cosx, "__cosx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&cosq, "cosf128");
     }
     symbol(&cosq, "cosq");
@@ -40,7 +40,7 @@ pub fn cosf(x: f32) callconv(.c) f32 {
     if (ix <= 0x3f490fda) { // |x| ~<= pi/4
         if (ix < 0x39800000) { // |x| < 2**-12
             // raise inexact if x != 0
-            if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
+            if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
             return 1.0;
         }
         return trig.__cosdf(x);
@@ -91,7 +91,7 @@ pub fn cos(x: f64) callconv(.c) f64 {
     if (ix <= 0x3fe921fb) {
         if (ix < 0x3e46a09e) { // |x| < 2**-27 * sqrt(2)
             // raise inexact if x!=0
-            if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
+            if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
             return 1.0;
         }
         return trig.__cos(x, 0);
diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig
index c57b432832da60e2eefe2d3ca6e75f499fa2b301..b8a9c1914e2cecbaa04bf3f3386a2cb028356a14 100644
--- a/lib/compiler_rt/divdf3.zig
+++ b/lib/compiler_rt/divdf3.zig
@@ -3,14 +3,14 @@
 //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divdf3.c
 
 const std = @import("std");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
-const normalize = common.normalize;
-const wideMultiply = common.wideMultiply;
+const normalize = compiler_rt.normalize;
+const wideMultiply = compiler_rt.wideMultiply;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_ddiv, "__aeabi_ddiv");
     } else {
         symbol(&__divdf3, "__divdf3");
diff --git a/lib/compiler_rt/divhc3.zig b/lib/compiler_rt/divhc3.zig
index 8243c545b164e55cfcc43417fe78c14371821537..c9668f4ca8ae84840ab3ee65446b682b6223832b 100644
--- a/lib/compiler_rt/divhc3.zig
+++ b/lib/compiler_rt/divhc3.zig
@@ -1,10 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divhc3, .{ .name = "__divhc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divhc3, "__divhc3");
     }
 }
 
diff --git a/lib/compiler_rt/divmodei4.zig b/lib/compiler_rt/divmodei4.zig
index d96be7dec5cd71011da2b7744a22e1203335e540..4fa168a675c86879640ceda8bc604ecd81918a8f 100644
--- a/lib/compiler_rt/divmodei4.zig
+++ b/lib/compiler_rt/divmodei4.zig
@@ -3,7 +3,7 @@ const endian = builtin.cpu.arch.endian();
 
 const std = @import("std");
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const udivmod = @import("udivmodei4.zig").divmod;
 const symbol = @import("../compiler_rt.zig").symbol;
 
@@ -36,7 +36,7 @@ fn divmod(q: ?[]u32, r: ?[]u32, u: []u32, v: []u32) !void {
 }
 
 pub fn __divei4(q_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
     const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size]));
     const u: []u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
@@ -45,7 +45,7 @@ pub fn __divei4(q_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) vo
 }
 
 pub fn __modei4(r_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
     const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size]));
     const u: []u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig
index 67e24de80dde507f71b290ea9884658b739cd503..5406dc8ccf72161b2b70200467cad051ba311b16 100644
--- a/lib/compiler_rt/divsf3.zig
+++ b/lib/compiler_rt/divsf3.zig
@@ -4,12 +4,12 @@
 
 const std = @import("std");
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
-const normalize = common.normalize;
+const normalize = compiler_rt.normalize;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_fdiv, "__aeabi_fdiv");
     } else {
         symbol(&__divsf3, "__divsf3");
diff --git a/lib/compiler_rt/divtc3.zig b/lib/compiler_rt/divtc3.zig
index d686958621958a2fe81446d5cdab03001629650c..b0e0f35f5447488f4d15ba76ede68bab2425f96b 100644
--- a/lib/compiler_rt/divtc3.zig
+++ b/lib/compiler_rt/divtc3.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        if (common.want_ppc_abi)
+        if (compiler_rt.want_ppc_abi)
             symbol(&__divtc3, "__divkc3");
         symbol(&__divtc3, "__divtc3");
     }
diff --git a/lib/compiler_rt/divtf3.zig b/lib/compiler_rt/divtf3.zig
index 6606d0de3808cfc36917c3dc55348106d851eaa1..db495ee0a44d8f2325c15ea8351a44cbf3f7f0be 100644
--- a/lib/compiler_rt/divtf3.zig
+++ b/lib/compiler_rt/divtf3.zig
@@ -1,17 +1,18 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-const common = @import("common.zig");
-const normalize = common.normalize;
-const wideMultiply = common.wideMultiply;
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+const normalize = compiler_rt.normalize;
+const wideMultiply = compiler_rt.wideMultiply;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__divtf3, .{ .name = "__divkf3", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_div, .{ .name = "_Qp_div", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__divtf3, "__divkf3");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_div, "_Qp_div");
     }
-    @export(&__divtf3, .{ .name = "__divtf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divtf3, "__divtf3");
 }
 
 pub fn __divtf3(a: f128, b: f128) callconv(.c) f128 {
diff --git a/lib/compiler_rt/divti3.zig b/lib/compiler_rt/divti3.zig
deleted file mode 100644
index 9eb8dda18741793935b231748f1994b0d19809b0..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/divti3.zig
+++ /dev/null
@@ -1,39 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const udivmod = @import("udivmod.zig").udivmod;
-const arch = builtin.cpu.arch;
-const common = @import("common.zig");
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__divti3, .{ .name = "__divti3", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __divti3(a: i128, b: i128) callconv(.c) i128 {
-    return div(a, b);
-}
-
-const v128 = @Vector(2, u64);
-
-fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.c) v128 {
-    return @bitCast(div(@bitCast(a), @bitCast(b)));
-}
-
-inline fn div(a: i128, b: i128) i128 {
-    const s_a = a >> (128 - 1);
-    const s_b = b >> (128 - 1);
-
-    const an = (a ^ s_a) -% s_a;
-    const bn = (b ^ s_b) -% s_b;
-
-    const r = udivmod(u128, @bitCast(an), @bitCast(bn), null);
-    const s = s_a ^ s_b;
-    return (@as(i128, @bitCast(r)) ^ s) -% s;
-}
-
-test {
-    _ = @import("divti3_test.zig");
-}
diff --git a/lib/compiler_rt/divti3_test.zig b/lib/compiler_rt/divti3_test.zig
index bcf45da3f23c59d3ab62af4783bbb75b6d947661..34431d12af4c9e559b619654be2e9b70107f93a1 100644
--- a/lib/compiler_rt/divti3_test.zig
+++ b/lib/compiler_rt/divti3_test.zig
@@ -1,4 +1,4 @@
-const __divti3 = @import("divti3.zig").__divti3;
+const __divti3 = @import("udivmod.zig").__divti3;
 const testing = @import("std").testing;
 
 fn test__divti3(a: i128, b: i128, expected: i128) !void {
diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig
index 069510a2b6872f33db80117c6c9ba873d6b0927d..46210a500f09ee68f2bd2c259925fa1fa415a8ee 100644
--- a/lib/compiler_rt/divxf3.zig
+++ b/lib/compiler_rt/divxf3.zig
@@ -2,12 +2,13 @@ const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 
-const common = @import("common.zig");
-const normalize = common.normalize;
-const wideMultiply = common.wideMultiply;
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+const normalize = compiler_rt.normalize;
+const wideMultiply = compiler_rt.wideMultiply;
 
 comptime {
-    @export(&__divxf3, .{ .name = "__divxf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divxf3, "__divxf3");
 }
 
 pub fn __divxf3(a: f80, b: f80) callconv(.c) f80 {
diff --git a/lib/compiler_rt/emutls.zig b/lib/compiler_rt/emutls.zig
index d702597cd24ec3189b5296d5610aefcc57c10fce..ee80d75d9f9d6c6cd9beb8c581f2b10f09b6fb19 100644
--- a/lib/compiler_rt/emutls.zig
+++ b/lib/compiler_rt/emutls.zig
@@ -5,7 +5,8 @@
 
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 const abort = std.process.abort;
 const assert = std.debug.assert;
@@ -17,7 +18,7 @@ const gcc_word = usize;
 
 comptime {
     if (builtin.link_libc and (builtin.abi.isAndroid() or builtin.abi.isOpenHarmony() or builtin.os.tag == .openbsd)) {
-        @export(&__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__emutls_get_address, "__emutls_get_address");
     }
 }
 
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index 3f18188fa0905669a373df546dd3924cec4dbb36..c5a980ac72f46b5bd945e1accee32e869e546212 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -13,7 +13,7 @@ const mem = std.mem;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
@@ -21,7 +21,7 @@ comptime {
     symbol(&expf, "expf");
     symbol(&exp, "exp");
     symbol(&__expx, "__expx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&expq, "expf128");
     }
     symbol(&expq, "expq");
@@ -61,7 +61,7 @@ pub fn expf(x_: f32) callconv(.c) f32 {
             return x * 0x1.0p127;
         }
         if (sign != 0) {
-            if (common.want_float_exceptions) mem.doNotOptimizeAway(-0x1.0p-149 / x); // overflow
+            if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(-0x1.0p-149 / x); // overflow
             // x <= -103.972084
             if (hx >= 0x42CFF1B5) {
                 return 0;
@@ -93,7 +93,7 @@ pub fn expf(x_: f32) callconv(.c) f32 {
         hi = x;
         lo = 0;
     } else {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(0x1.0p127 + x); // inexact
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(0x1.0p127 + x); // inexact
         return 1 + x;
     }
 
@@ -137,11 +137,11 @@ pub fn exp(x_: f64) callconv(.c) f64 {
         }
         if (x > 709.782712893383973096) {
             // overflow if x != inf
-            return if (common.want_float_exceptions) x * 0x1p1023 else std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) x * 0x1p1023 else std.math.inf(f64);
         }
         if (x < -708.39641853226410622) {
             // underflow if x != -inf
-            if (common.want_float_exceptions) mem.doNotOptimizeAway(-0x0.0000000000001p-1022 / x);
+            if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(-0x0.0000000000001p-1022 / x);
             if (x < -745.13321910194110842) {
                 return 0;
             }
@@ -174,7 +174,7 @@ pub fn exp(x_: f64) callconv(.c) f64 {
         lo = 0;
     } else {
         // inexact if x != 0
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(0x1.0p1023 + x);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(0x1.0p1023 + x);
         return 1 + x;
     }
 
diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig
index f59e98620ebd283cf45c171a663a863c1c124041..4e41db2f2d37813a83ae8b38e46f3c805e601e95 100644
--- a/lib/compiler_rt/exp2.zig
+++ b/lib/compiler_rt/exp2.zig
@@ -11,18 +11,19 @@ const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__exp2h, .{ .name = "__exp2h", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&exp2f, .{ .name = "exp2f", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&exp2, .{ .name = "exp2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__exp2x, .{ .name = "__exp2x", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&exp2q, .{ .name = "exp2f128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__exp2h, "__exp2h");
+    symbol(&exp2f, "exp2f");
+    symbol(&exp2, "exp2");
+    symbol(&__exp2x, "__exp2x");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&exp2q, "exp2f128");
     }
-    @export(&exp2q, .{ .name = "exp2q", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&exp2l, .{ .name = "exp2l", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&exp2q, "exp2q");
+    symbol(&exp2l, "exp2l");
 }
 
 pub fn __exp2h(x: f16) callconv(.c) f16 {
@@ -54,7 +55,7 @@ pub fn exp2f(x: f32) callconv(.c) f32 {
         // x < -126
         if (u >= 0x80000000) {
             if (u >= 0xC3160000 or u & 0x000FFFF != 0) {
-                if (common.want_float_exceptions) mem.doNotOptimizeAway(-0x1.0p-149 / x);
+                if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(-0x1.0p-149 / x);
             }
             // x <= -150
             if (u >= 0xC3160000) {
@@ -108,7 +109,7 @@ pub fn exp2(x: f64) callconv(.c) f64 {
     if (ix >= 0x408FF000) {
         // x >= 1024 or nan
         if (ix >= 0x40900000 and ux >> 63 == 0) {
-            return if (common.want_float_exceptions) x * 0x1p1023 else std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) x * 0x1p1023 else std.math.inf(f64);
         }
         // -inf or -nan
         if (ix >= 0x7FF00000) {
@@ -118,7 +119,7 @@ pub fn exp2(x: f64) callconv(.c) f64 {
         if (ux >> 63 != 0) {
             // underflow
             if (x <= -1075 or x - 0x1.0p52 + 0x1.0p52 != x) {
-                if (common.want_float_exceptions) mem.doNotOptimizeAway(@as(f32, @floatCast(-0x1.0p-149 / x)));
+                if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(@as(f32, @floatCast(-0x1.0p-149 / x)));
             }
             if (x <= -1075) {
                 return 0;
diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig
index 0204de48edbf75097daa2a387b9618990260a3bb..4ccd402b24dfdc519f1c4a9e2958c1ac6a32da9a 100644
--- a/lib/compiler_rt/extenddftf2.zig
+++ b/lib/compiler_rt/extenddftf2.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const extendf = @import("./extendf.zig").extendf;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__extenddftf2, "__extenddfkf2");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_dtoq, "_Qp_dtoq");
     }
     symbol(&__extenddftf2, "__extenddftf2");
diff --git a/lib/compiler_rt/extenddfxf2.zig b/lib/compiler_rt/extenddfxf2.zig
index 1d7bc998d76d2f65c738fa6cc22dcd7f2faf09c4..d18195aea357d8fdd8fc26a0d34db798bc06f187 100644
--- a/lib/compiler_rt/extenddfxf2.zig
+++ b/lib/compiler_rt/extenddfxf2.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const extend_f80 = @import("./extendf.zig").extend_f80;
 
 comptime {
-    @export(&__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extenddfxf2, "__extenddfxf2");
 }
 
 pub fn __extenddfxf2(a: f64) callconv(.c) f80 {
diff --git a/lib/compiler_rt/extendf_test.zig b/lib/compiler_rt/extendf_test.zig
index 20273507d16d1a992a983674ccf37ff917a90106..f572495b6634f8096fa5dd41dd9d2fd1b362a0a1 100644
--- a/lib/compiler_rt/extendf_test.zig
+++ b/lib/compiler_rt/extendf_test.zig
@@ -1,12 +1,14 @@
+const builtin = @import("builtin");
+
 const std = @import("std");
 const math = std.math;
-const builtin = @import("builtin");
+
 const __extendhfsf2 = @import("extendhfsf2.zig").__extendhfsf2;
 const __extendhftf2 = @import("extendhftf2.zig").__extendhftf2;
 const __extendsftf2 = @import("extendsftf2.zig").__extendsftf2;
 const __extenddftf2 = @import("extenddftf2.zig").__extenddftf2;
 const __extenddfxf2 = @import("extenddfxf2.zig").__extenddfxf2;
-const F16T = @import("./common.zig").F16T;
+const F16T = @import("../compiler_rt.zig").F16T;
 
 fn test__extenddfxf2(a: f64, expected: u80) !void {
     const x = __extenddfxf2(a);
diff --git a/lib/compiler_rt/extendhfdf2.zig b/lib/compiler_rt/extendhfdf2.zig
index 2191bafe136c94e75527a363626779f55302b334..8cadc7139eebbad29f39b5245a14971c5c187a0d 100644
--- a/lib/compiler_rt/extendhfdf2.zig
+++ b/lib/compiler_rt/extendhfdf2.zig
@@ -1,4 +1,4 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const extendf = @import("./extendf.zig").extendf;
 
@@ -6,6 +6,6 @@ comptime {
     symbol(&__extendhfdf2, "__extendhfdf2");
 }
 
-pub fn __extendhfdf2(a: common.F16T(f64)) callconv(.c) f64 {
+pub fn __extendhfdf2(a: compiler_rt.F16T(f64)) callconv(.c) f64 {
     return extendf(f64, f16, @as(u16, @bitCast(a)));
 }
diff --git a/lib/compiler_rt/extendhfsf2.zig b/lib/compiler_rt/extendhfsf2.zig
index 2c734f0147651e165bafa14111289d22e776085c..b638192c47502e6e698e86fcce8be3fbc0f7d2f9 100644
--- a/lib/compiler_rt/extendhfsf2.zig
+++ b/lib/compiler_rt/extendhfsf2.zig
@@ -1,21 +1,21 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const extendf = @import("./extendf.zig").extendf;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.gnu_f16_abi) {
+    if (compiler_rt.gnu_f16_abi) {
         symbol(&__gnu_h2f_ieee, "__gnu_h2f_ieee");
-    } else if (common.want_aeabi) {
+    } else if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_h2f, "__aeabi_h2f");
     }
     symbol(&__extendhfsf2, "__extendhfsf2");
 }
 
-pub fn __extendhfsf2(a: common.F16T(f32)) callconv(.c) f32 {
+pub fn __extendhfsf2(a: compiler_rt.F16T(f32)) callconv(.c) f32 {
     return extendf(f32, f16, @as(u16, @bitCast(a)));
 }
 
-fn __gnu_h2f_ieee(a: common.F16T(f32)) callconv(.c) f32 {
+fn __gnu_h2f_ieee(a: compiler_rt.F16T(f32)) callconv(.c) f32 {
     return extendf(f32, f16, @as(u16, @bitCast(a)));
 }
 
diff --git a/lib/compiler_rt/extendhftf2.zig b/lib/compiler_rt/extendhftf2.zig
index a94b849a5a2c3416e326bfe9d3e5bd041a468174..29e7866b663389aae7048a474e585916fec7cac1 100644
--- a/lib/compiler_rt/extendhftf2.zig
+++ b/lib/compiler_rt/extendhftf2.zig
@@ -1,10 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const extendf = @import("./extendf.zig").extendf;
 
 comptime {
-    @export(&__extendhftf2, .{ .name = "__extendhftf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendhftf2, "__extendhftf2");
 }
 
-pub fn __extendhftf2(a: common.F16T(f128)) callconv(.c) f128 {
+pub fn __extendhftf2(a: compiler_rt.F16T(f128)) callconv(.c) f128 {
     return extendf(f128, f16, @as(u16, @bitCast(a)));
 }
diff --git a/lib/compiler_rt/extendhfxf2.zig b/lib/compiler_rt/extendhfxf2.zig
index 5e205b1f888808ed29d7c8e189c8213ed70817b8..e76daf4f55045262daa10cb4547688ed012a6bc0 100644
--- a/lib/compiler_rt/extendhfxf2.zig
+++ b/lib/compiler_rt/extendhfxf2.zig
@@ -1,10 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const extend_f80 = @import("./extendf.zig").extend_f80;
 
 comptime {
-    @export(&__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendhfxf2, "__extendhfxf2");
 }
 
-fn __extendhfxf2(a: common.F16T(f80)) callconv(.c) f80 {
+fn __extendhfxf2(a: compiler_rt.F16T(f80)) callconv(.c) f80 {
     return extend_f80(f16, @as(u16, @bitCast(a)));
 }
diff --git a/lib/compiler_rt/extendsfdf2.zig b/lib/compiler_rt/extendsfdf2.zig
index 9cc0a436633d5b3910bc2e8b4c790393395cbd10..4f34b05242a5f57155c9bb83c3e978c6ec3ace42 100644
--- a/lib/compiler_rt/extendsfdf2.zig
+++ b/lib/compiler_rt/extendsfdf2.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const extendf = @import("./extendf.zig").extendf;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_f2d, "__aeabi_f2d");
     } else {
-        @export(&__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__extendsfdf2, "__extendsfdf2");
     }
 }
 
diff --git a/lib/compiler_rt/extendsftf2.zig b/lib/compiler_rt/extendsftf2.zig
index 3690a0733c87db737d1ae6c7508a9c5decf0a0a9..e260eec7fe93dbcc7d6f4d219186ccc9d99acc9c 100644
--- a/lib/compiler_rt/extendsftf2.zig
+++ b/lib/compiler_rt/extendsftf2.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const extendf = @import("./extendf.zig").extendf;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__extendsftf2, .{ .name = "__extendsfkf2", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_stoq, .{ .name = "_Qp_stoq", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__extendsftf2, "__extendsfkf2");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_stoq, "_Qp_stoq");
     }
-    @export(&__extendsftf2, .{ .name = "__extendsftf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendsftf2, "__extendsftf2");
 }
 
 pub fn __extendsftf2(a: f32) callconv(.c) f128 {
diff --git a/lib/compiler_rt/fabs.zig b/lib/compiler_rt/fabs.zig
index 9a10f4ce617a62e3e0e0c8a3f78f55053855d6de..8fcf36262a40ed89c2e3ae0be958eaadabfb2c91 100644
--- a/lib/compiler_rt/fabs.zig
+++ b/lib/compiler_rt/fabs.zig
@@ -1,18 +1,19 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__fabsh, .{ .name = "__fabsh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fabsf, .{ .name = "fabsf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fabs, .{ .name = "fabs", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__fabsx, .{ .name = "__fabsx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&fabsq, .{ .name = "fabsf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fabsh, "__fabsh");
+    symbol(&fabsf, "fabsf");
+    symbol(&fabs, "fabs");
+    symbol(&__fabsx, "__fabsx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&fabsq, "fabsf128");
     }
-    @export(&fabsq, .{ .name = "fabsq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fabsl, .{ .name = "fabsl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&fabsq, "fabsq");
+    symbol(&fabsl, "fabsl");
 }
 
 pub fn __fabsh(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/fixdfdi.zig b/lib/compiler_rt/fixdfdi.zig
index 97f3be044e2be76206a67d30083b0f54584c66af..5a66cc124f0f4ec092f1c49715ae6c547a396b66 100644
--- a/lib/compiler_rt/fixdfdi.zig
+++ b/lib/compiler_rt/fixdfdi.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_d2lz, "__aeabi_d2lz");
     } else {
-        if (common.want_windows_arm_abi) {
-            @export(&__fixdfdi, .{ .name = "__dtoi64", .linkage = common.linkage, .visibility = common.visibility });
+        if (compiler_rt.want_windows_arm_abi) {
+            symbol(&__fixdfdi, "__dtoi64");
         }
-        @export(&__fixdfdi, .{ .name = "__fixdfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfdi, "__fixdfdi");
     }
 }
 
diff --git a/lib/compiler_rt/fixdfei.zig b/lib/compiler_rt/fixdfei.zig
index 3565cb45ba2bf2d692cd66273af486c70268611a..170b4a160337fe5fc426fe2e715ab46426d76d7e 100644
--- a/lib/compiler_rt/fixdfei.zig
+++ b/lib/compiler_rt/fixdfei.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixdfei, .{ .name = "__fixdfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixdfei, "__fixdfei");
 }
 
 pub fn __fixdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {
diff --git a/lib/compiler_rt/fixdfsi.zig b/lib/compiler_rt/fixdfsi.zig
index 7707f898302898743dc5c07b0969967c40e2163e..1d42337ea54573e4c7423147323046b029f9af52 100644
--- a/lib/compiler_rt/fixdfsi.zig
+++ b/lib/compiler_rt/fixdfsi.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_d2iz, "__aeabi_d2iz");
     } else {
         symbol(&__fixdfsi, "__fixdfsi");
diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig
index 64c5a080f91a2c9afc2e9bb265a599a207e3312a..4717fd7b59f1b17854dfc742b73bfd506c1522fd 100644
--- a/lib/compiler_rt/fixdfti.zig
+++ b/lib/compiler_rt/fixdfti.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__fixdfti_windows_x86_64, "__fixdfti");
     } else {
         symbol(&__fixdfti, "__fixdfti");
diff --git a/lib/compiler_rt/fixhfdi.zig b/lib/compiler_rt/fixhfdi.zig
deleted file mode 100644
index 3bcb848972d90eb84012ba83b47e19d4bee78585..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/fixhfdi.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const common = @import("./common.zig");
-const intFromFloat = @import("./int_from_float.zig").intFromFloat;
-
-comptime {
-    @export(&__fixhfdi, .{ .name = "__fixhfdi", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn __fixhfdi(a: f16) callconv(.c) i64 {
-    return intFromFloat(i64, a);
-}
diff --git a/lib/compiler_rt/fixhfei.zig b/lib/compiler_rt/fixhfei.zig
index 1eef56073fc6331fc74c3c19cd69e95290e4070c..5b759c3fc683d909ce7808242a59129c310bbb56 100644
--- a/lib/compiler_rt/fixhfei.zig
+++ b/lib/compiler_rt/fixhfei.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixhfei, .{ .name = "__fixhfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixhfei, "__fixhfei");
 }
 
 pub fn __fixhfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {
diff --git a/lib/compiler_rt/fixhfsi.zig b/lib/compiler_rt/fixhfsi.zig
deleted file mode 100644
index 658f13bb71903e92f400bd7a01e2c8b91c3ee703..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/fixhfsi.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const common = @import("./common.zig");
-const intFromFloat = @import("./int_from_float.zig").intFromFloat;
-
-comptime {
-    @export(&__fixhfsi, .{ .name = "__fixhfsi", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn __fixhfsi(a: f16) callconv(.c) i32 {
-    return intFromFloat(i32, a);
-}
diff --git a/lib/compiler_rt/fixhfti.zig b/lib/compiler_rt/fixhfti.zig
deleted file mode 100644
index 1c51ebc056482625c0301cd75d6a552e9702a594..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/fixhfti.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const builtin = @import("builtin");
-const common = @import("./common.zig");
-const intFromFloat = @import("./int_from_float.zig").intFromFloat;
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__fixhfti_windows_x86_64, .{ .name = "__fixhfti", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__fixhfti, .{ .name = "__fixhfti", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __fixhfti(a: f16) callconv(.c) i128 {
-    return intFromFloat(i128, a);
-}
-
-const v2u64 = @Vector(2, u64);
-
-fn __fixhfti_windows_x86_64(a: f16) callconv(.c) v2u64 {
-    return @bitCast(intFromFloat(i128, a));
-}
diff --git a/lib/compiler_rt/fixsfdi.zig b/lib/compiler_rt/fixsfdi.zig
index b2880aefc23714d1ecfa6cf2456d2ab55b737d14..0a3731877e8bf7c7591391c8d76a6a5f953e74f1 100644
--- a/lib/compiler_rt/fixsfdi.zig
+++ b/lib/compiler_rt/fixsfdi.zig
@@ -1,13 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_f2lz, "__aeabi_f2lz");
     } else {
-        if (common.want_windows_arm_abi) {
+        if (compiler_rt.want_windows_arm_abi) {
             symbol(&__fixsfdi, "__stoi64");
         }
         symbol(&__fixsfdi, "__fixsfdi");
diff --git a/lib/compiler_rt/fixsfei.zig b/lib/compiler_rt/fixsfei.zig
index efbccfa29956506c7111750aa8f2a972f19bf8a3..43243254059d78d0ba678bcf1ae9ab37b50c3f47 100644
--- a/lib/compiler_rt/fixsfei.zig
+++ b/lib/compiler_rt/fixsfei.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixsfei, .{ .name = "__fixsfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixsfei, "__fixsfei");
 }
 
 pub fn __fixsfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {
diff --git a/lib/compiler_rt/fixsfsi.zig b/lib/compiler_rt/fixsfsi.zig
index abb856436985d3cd99d51fcfe02f830dca4ad84b..9c07c5824a25aac5f83ae2e2f58ce4df66f53b38 100644
--- a/lib/compiler_rt/fixsfsi.zig
+++ b/lib/compiler_rt/fixsfsi.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_f2iz, "__aeabi_f2iz");
     } else {
-        @export(&__fixsfsi, .{ .name = "__fixsfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixsfsi, "__fixsfsi");
     }
 }
 
diff --git a/lib/compiler_rt/fixsfti.zig b/lib/compiler_rt/fixsfti.zig
index 82b1db70dc9409cab195e2dc0a19117047033bf8..0980012a453eba643ea0af0206d8256bab481990 100644
--- a/lib/compiler_rt/fixsfti.zig
+++ b/lib/compiler_rt/fixsfti.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__fixsfti_windows_x86_64, .{ .name = "__fixsfti", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__fixsfti_windows_x86_64, "__fixsfti");
     } else {
-        @export(&__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixsfti, "__fixsfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig
index bc1c8e56eb4fa3d3a06dd991972c7f22df500917..f3cb7bc1cf152227699881577c1f8acd6787e7d8 100644
--- a/lib/compiler_rt/fixtfdi.zig
+++ b/lib/compiler_rt/fixtfdi.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__fixtfdi, "__fixkfdi");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_qtox, "_Qp_qtox");
     }
     symbol(&__fixtfdi, "__fixtfdi");
diff --git a/lib/compiler_rt/fixtfei.zig b/lib/compiler_rt/fixtfei.zig
index 980db4c614f89bdef90ad03ea892861724e334ea..6443a0cb3be226c25affb17567fa8c860868aaa1 100644
--- a/lib/compiler_rt/fixtfei.zig
+++ b/lib/compiler_rt/fixtfei.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixtfei, .{ .name = "__fixtfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixtfei, "__fixtfei");
 }
 
 pub fn __fixtfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {
diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig
index 0919566a804a68d3ebb050fea1c74a2294d1f598..10cddec0da2a55d7ec91bdbf5a0b2090a17687b4 100644
--- a/lib/compiler_rt/fixtfsi.zig
+++ b/lib/compiler_rt/fixtfsi.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__fixtfsi, "__fixkfsi");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_qtoi, "_Qp_qtoi");
     }
     symbol(&__fixtfsi, "__fixtfsi");
diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig
index 2a1a928256a380e4336aac7e8b5b9dad9390a7ea..cb642d61664a2780003a78cc0293f80657b516a5 100644
--- a/lib/compiler_rt/fixtfti.zig
+++ b/lib/compiler_rt/fixtfti.zig
@@ -1,12 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__fixtfti_windows_x86_64, "__fixtfti");
     } else {
-        if (common.want_ppc_abi)
+        if (compiler_rt.want_ppc_abi)
             symbol(&__fixtfti, "__fixkfti");
         symbol(&__fixtfti, "__fixtfti");
     }
diff --git a/lib/compiler_rt/fixunsdfdi.zig b/lib/compiler_rt/fixunsdfdi.zig
index 211963bf3e6f3db00d5db224a7483a044ee44b54..340bb8f6b11276fd9fff401b7f6a655e63d0a218 100644
--- a/lib/compiler_rt/fixunsdfdi.zig
+++ b/lib/compiler_rt/fixunsdfdi.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_d2ulz, "__aeabi_d2ulz");
     } else {
-        if (common.want_windows_arm_abi) {
-            @export(&__fixunsdfdi, .{ .name = "__dtou64", .linkage = common.linkage, .visibility = common.visibility });
+        if (compiler_rt.want_windows_arm_abi) {
+            symbol(&__fixunsdfdi, "__dtou64");
         }
-        @export(&__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsdfdi, "__fixunsdfdi");
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfsi.zig b/lib/compiler_rt/fixunsdfsi.zig
index a8e9197361a79ec78d5d051308155dea204fd60f..e8b976d03d690d0de88d07e3fe4b97c0490e5901 100644
--- a/lib/compiler_rt/fixunsdfsi.zig
+++ b/lib/compiler_rt/fixunsdfsi.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_d2uiz, "__aeabi_d2uiz");
     } else {
-        @export(&__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsdfsi, "__fixunsdfsi");
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig
index a90b3d67fb5e5fc5640447b74464c65b18705d9a..95d15ac3138eab9596b375c50814521c4aac5416 100644
--- a/lib/compiler_rt/fixunsdfti.zig
+++ b/lib/compiler_rt/fixunsdfti.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti");
     } else {
         symbol(&__fixunsdfti, "__fixunsdfti");
diff --git a/lib/compiler_rt/fixunshfsi.zig b/lib/compiler_rt/fixunshfsi.zig
index fca40d1b0a33f07b577ac1bb40388e55b03dd5dd..438767c7a89a57c22385a1b666a6f59875d1f7ba 100644
--- a/lib/compiler_rt/fixunshfsi.zig
+++ b/lib/compiler_rt/fixunshfsi.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixunshfsi, .{ .name = "__fixunshfsi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunshfsi, "__fixunshfsi");
 }
 
 fn __fixunshfsi(a: f16) callconv(.c) u32 {
diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig
index 454aa9d57569749bf2d304baf6e3bac85bdd867a..a090027196937f25b649dcd6d8e3d589e7cd4083 100644
--- a/lib/compiler_rt/fixunshfti.zig
+++ b/lib/compiler_rt/fixunshfti.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__fixunshfti_windows_x86_64, "__fixunshfti");
     } else {
         symbol(&__fixunshfti, "__fixunshfti");
diff --git a/lib/compiler_rt/fixunssfdi.zig b/lib/compiler_rt/fixunssfdi.zig
index f12ec1cd5a9d93ca82e4f02e91c7550f90e44fe4..ffc238a53fb9f12a64446371a3d3191331d6994c 100644
--- a/lib/compiler_rt/fixunssfdi.zig
+++ b/lib/compiler_rt/fixunssfdi.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_f2ulz, "__aeabi_f2ulz");
     } else {
-        if (common.want_windows_arm_abi) {
-            @export(&__fixunssfdi, .{ .name = "__stou64", .linkage = common.linkage, .visibility = common.visibility });
+        if (compiler_rt.want_windows_arm_abi) {
+            symbol(&__fixunssfdi, "__stou64");
         }
-        @export(&__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunssfdi, "__fixunssfdi");
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfsi.zig b/lib/compiler_rt/fixunssfsi.zig
index 4def4b867fea5cb931fa4af64b040a5d6446f31d..f9c09b3f3d881774c21117e3c32b3a0b0b0a9f82 100644
--- a/lib/compiler_rt/fixunssfsi.zig
+++ b/lib/compiler_rt/fixunssfsi.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_f2uiz, "__aeabi_f2uiz");
     } else {
-        @export(&__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunssfsi, "__fixunssfsi");
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig
index 73e2d2a3f6b81926d346f9c04da8f880e4acf616..da46f43d5bc111b53ee317a70a0456d3ea554853 100644
--- a/lib/compiler_rt/fixunssfti.zig
+++ b/lib/compiler_rt/fixunssfti.zig
@@ -1,10 +1,10 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__fixunssfti_windows_x86_64, "__fixunssfti");
     } else {
         symbol(&__fixunssfti, "__fixunssfti");
diff --git a/lib/compiler_rt/fixunstfdi.zig b/lib/compiler_rt/fixunstfdi.zig
index f1e1822a311831e70993b892e3ecf8e417f5628f..809fe6eb80e0286619dccdb50854c286ee4ec520 100644
--- a/lib/compiler_rt/fixunstfdi.zig
+++ b/lib/compiler_rt/fixunstfdi.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__fixunstfdi, .{ .name = "__fixunskfdi", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtoux, .{ .name = "_Qp_qtoux", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__fixunstfdi, "__fixunskfdi");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_qtoux, "_Qp_qtoux");
     }
-    @export(&__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunstfdi, "__fixunstfdi");
 }
 
 pub fn __fixunstfdi(a: f128) callconv(.c) u64 {
diff --git a/lib/compiler_rt/fixunstfsi.zig b/lib/compiler_rt/fixunstfsi.zig
index d3a9bfbed85fa07355dd69fceed197ae5ebfb0d9..e8ec0aea932237035fc36e9db5cd310f5477d5e1 100644
--- a/lib/compiler_rt/fixunstfsi.zig
+++ b/lib/compiler_rt/fixunstfsi.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__fixunstfsi, .{ .name = "__fixunskfsi", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtoui, .{ .name = "_Qp_qtoui", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__fixunstfsi, "__fixunskfsi");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_qtoui, "_Qp_qtoui");
     }
-    @export(&__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunstfsi, "__fixunstfsi");
 }
 
 pub fn __fixunstfsi(a: f128) callconv(.c) u32 {
diff --git a/lib/compiler_rt/fixunstfti.zig b/lib/compiler_rt/fixunstfti.zig
index 92fcd569dc6d939305bbc0daf3c3fa6c52978853..81c2a160957c20492c3781353a4042807d7ed0af 100644
--- a/lib/compiler_rt/fixunstfti.zig
+++ b/lib/compiler_rt/fixunstfti.zig
@@ -1,14 +1,15 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__fixunstfti_windows_x86_64, .{ .name = "__fixunstfti", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__fixunstfti_windows_x86_64, "__fixunstfti");
     } else {
-        if (common.want_ppc_abi)
-            @export(&__fixunstfti, .{ .name = "__fixunskfti", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__fixunstfti, .{ .name = "__fixunstfti", .linkage = common.linkage, .visibility = common.visibility });
+        if (compiler_rt.want_ppc_abi)
+            symbol(&__fixunstfti, "__fixunskfti");
+        symbol(&__fixunstfti, "__fixunstfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunsxfsi.zig b/lib/compiler_rt/fixunsxfsi.zig
index 8f900076c728c85d317746acd237c3003f184543..7309fbf5a6cf72a7eb862773fbb121437243c2ee 100644
--- a/lib/compiler_rt/fixunsxfsi.zig
+++ b/lib/compiler_rt/fixunsxfsi.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsxfsi, "__fixunsxfsi");
 }
 
 fn __fixunsxfsi(a: f80) callconv(.c) u32 {
diff --git a/lib/compiler_rt/fixunsxfti.zig b/lib/compiler_rt/fixunsxfti.zig
index 39dde2ca1222f8f776f308fbfa1e4802f90c66ef..24296dd416c85377442b95e1dcdea92ed27a96e7 100644
--- a/lib/compiler_rt/fixunsxfti.zig
+++ b/lib/compiler_rt/fixunsxfti.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__fixunsxfti_windows_x86_64, .{ .name = "__fixunsxfti", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__fixunsxfti_windows_x86_64, "__fixunsxfti");
     } else {
-        @export(&__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsxfti, "__fixunsxfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixxfei.zig b/lib/compiler_rt/fixxfei.zig
index 75edfad035cbb30fea542e043343de9570a32f67..82cd67648df13ac446de3a74ef796ba55ad45065 100644
--- a/lib/compiler_rt/fixxfei.zig
+++ b/lib/compiler_rt/fixxfei.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixxfei, .{ .name = "__fixxfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixxfei, "__fixxfei");
 }
 
 pub fn __fixxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {
diff --git a/lib/compiler_rt/fixxfsi.zig b/lib/compiler_rt/fixxfsi.zig
index 8a645bdae1fbe57c78398827589e4b070d563611..363492168c760bcd12432e7c757ec4b8f60a2cc1 100644
--- a/lib/compiler_rt/fixxfsi.zig
+++ b/lib/compiler_rt/fixxfsi.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixxfsi, .{ .name = "__fixxfsi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixxfsi, "__fixxfsi");
 }
 
 fn __fixxfsi(a: f80) callconv(.c) i32 {
diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig
deleted file mode 100644
index 2f43814eacf1dd310a878f0e42e546250ea5f424..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/fixxfti.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-const builtin = @import("builtin");
-
-const common = @import("./common.zig");
-const intFromFloat = @import("./int_from_float.zig").intFromFloat;
-const symbol = @import("../compiler_rt.zig").symbol;
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        symbol(&__fixxfti_windows_x86_64, "__fixxfti");
-    } else {
-        symbol(&__fixxfti, "__fixxfti");
-    }
-}
-
-pub fn __fixxfti(a: f80) callconv(.c) i128 {
-    return intFromFloat(i128, a);
-}
-
-const v2u64 = @Vector(2, u64);
-
-fn __fixxfti_windows_x86_64(a: f80) callconv(.c) v2u64 {
-    return @bitCast(intFromFloat(i128, a));
-}
diff --git a/lib/compiler_rt/floatdidf.zig b/lib/compiler_rt/floatdidf.zig
index f614521478da14f27429c1a413d247d1c035c7e5..f8d5153d5b43896b3dd26a32e84f613151b84653 100644
--- a/lib/compiler_rt/floatdidf.zig
+++ b/lib/compiler_rt/floatdidf.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_l2d, "__aeabi_l2d");
     } else {
-        if (common.want_windows_arm_abi) {
-            @export(&__floatdidf, .{ .name = "__i64tod", .linkage = common.linkage, .visibility = common.visibility });
+        if (compiler_rt.want_windows_arm_abi) {
+            symbol(&__floatdidf, "__i64tod");
         }
-        @export(&__floatdidf, .{ .name = "__floatdidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatdidf, "__floatdidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatdisf.zig b/lib/compiler_rt/floatdisf.zig
index 691ba91f26b9228380481258dca2f0719e67b09d..3da1faba367a6a17b81f97c93db6ff2041765b84 100644
--- a/lib/compiler_rt/floatdisf.zig
+++ b/lib/compiler_rt/floatdisf.zig
@@ -1,12 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_l2f, "__aeabi_l2f");
     } else {
-        if (common.want_windows_arm_abi) {
+        if (compiler_rt.want_windows_arm_abi) {
             symbol(&__floatdisf, "__i64tos");
         }
         symbol(&__floatdisf, "__floatdisf");
diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig
index 03182aab0b96e04619ecc48fff90f80548bb2c29..544c059f1b103e44b44c1e2a30dcb574114ad08c 100644
--- a/lib/compiler_rt/floatditf.zig
+++ b/lib/compiler_rt/floatditf.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__floatditf, "__floatdikf");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_xtoq, "_Qp_xtoq");
     }
     symbol(&__floatditf, "__floatditf");
diff --git a/lib/compiler_rt/floateihf.zig b/lib/compiler_rt/floateihf.zig
index 013e6d2d79cb1e444e68c10b8a8e24aa42d8d182..c1ec290fb1084a05b6353ffde4968bce3c3cd3d8 100644
--- a/lib/compiler_rt/floateihf.zig
+++ b/lib/compiler_rt/floateihf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floateihf, .{ .name = "__floateihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateihf, "__floateihf");
 }
 
 pub fn __floateihf(a: [*]const u8, bits: usize) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floateisf.zig b/lib/compiler_rt/floateisf.zig
index eb24b6aa43123cd73d5ea61e89777fa1f66ef507..dd5933b7dff321ee90d0b13ee6d9a5e0d85a9f20 100644
--- a/lib/compiler_rt/floateisf.zig
+++ b/lib/compiler_rt/floateisf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floateisf, .{ .name = "__floateisf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateisf, "__floateisf");
 }
 
 pub fn __floateisf(a: [*]const u8, bits: usize) callconv(.c) f32 {
diff --git a/lib/compiler_rt/floateitf.zig b/lib/compiler_rt/floateitf.zig
index e5b50ab7a6b34c44d6d0fe7029037e21114fad70..0df893bd18881c9ec382e718a7664bf4d0f7a8e4 100644
--- a/lib/compiler_rt/floateitf.zig
+++ b/lib/compiler_rt/floateitf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floateitf, .{ .name = "__floateitf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateitf, "__floateitf");
 }
 
 pub fn __floateitf(a: [*]const u8, bits: usize) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatsidf.zig b/lib/compiler_rt/floatsidf.zig
index 435c8db9a465184dc532cba1947a2dd7a4b8bb12..dc5a261a08f1e86155d7af20b62b43b02c99bbe5 100644
--- a/lib/compiler_rt/floatsidf.zig
+++ b/lib/compiler_rt/floatsidf.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_i2d, "__aeabi_i2d");
     } else {
-        @export(&__floatsidf, .{ .name = "__floatsidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatsidf, "__floatsidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatsihf.zig b/lib/compiler_rt/floatsihf.zig
index 5f2db12585d900e8cd9e36e3b760c2cabcad927b..e1d588cfb0da1ed1007496f3d32db0fcdd8612ef 100644
--- a/lib/compiler_rt/floatsihf.zig
+++ b/lib/compiler_rt/floatsihf.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatsihf, .{ .name = "__floatsihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatsihf, "__floatsihf");
 }
 
 fn __floatsihf(a: i32) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatsisf.zig b/lib/compiler_rt/floatsisf.zig
index 9c36387c668c1d4bd7aa3dc371368dab2f47c53a..0dac860ebfded913a3eacb1666cb34e246f87dde 100644
--- a/lib/compiler_rt/floatsisf.zig
+++ b/lib/compiler_rt/floatsisf.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_i2f, "__aeabi_i2f");
     } else {
-        @export(&__floatsisf, .{ .name = "__floatsisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatsisf, "__floatsisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatsitf.zig b/lib/compiler_rt/floatsitf.zig
index 750633052dcee4880f17f52684c0b4ee0d36a4dd..b004d539899865e6908cb454e56e81cc31c0d3bf 100644
--- a/lib/compiler_rt/floatsitf.zig
+++ b/lib/compiler_rt/floatsitf.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__floatsitf, .{ .name = "__floatsikf", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_itoq, .{ .name = "_Qp_itoq", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__floatsitf, "__floatsikf");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_itoq, "_Qp_itoq");
     }
-    @export(&__floatsitf, .{ .name = "__floatsitf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatsitf, "__floatsitf");
 }
 
 pub fn __floatsitf(a: i32) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatsixf.zig b/lib/compiler_rt/floatsixf.zig
index 0d5fcb340db962c8fa7231eed32f5076c9486b7a..bd28eaf1fa68f9580f63b918bfeea6cc78295699 100644
--- a/lib/compiler_rt/floatsixf.zig
+++ b/lib/compiler_rt/floatsixf.zig
@@ -1,4 +1,4 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig
index db48fe8af37195b59db7ce5f16790a88b4f09f2e..5fd6b4c0f68782935fb6b90713228dabfab7d928 100644
--- a/lib/compiler_rt/floattidf.zig
+++ b/lib/compiler_rt/floattidf.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__floattidf_windows_x86_64, "__floattidf");
     } else {
         symbol(&__floattidf, "__floattidf");
diff --git a/lib/compiler_rt/floattihf.zig b/lib/compiler_rt/floattihf.zig
index 9ad705870e9eafbd49f2eb9c88d0d83bc7c5315a..643849f48e25ca2735ab813dd152f3b93015fcbf 100644
--- a/lib/compiler_rt/floattihf.zig
+++ b/lib/compiler_rt/floattihf.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__floattihf_windows_x86_64, .{ .name = "__floattihf", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__floattihf_windows_x86_64, "__floattihf");
     } else {
-        @export(&__floattihf, .{ .name = "__floattihf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattihf, "__floattihf");
     }
 }
 
diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig
index 3e5fffcfd8fec0d5972819955b703bffa45f3fb1..8926105d2df059bccfdf34bebfcff4277c988504 100644
--- a/lib/compiler_rt/floattisf.zig
+++ b/lib/compiler_rt/floattisf.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__floattisf_windows_x86_64, "__floattisf");
     } else {
         symbol(&__floattisf, "__floattisf");
diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig
index e8e301c42d36f9faa01e6f13d4cb77eb6a19739a..f8e6ca80e61d65f4c765b94aade334ccd13d1ed1 100644
--- a/lib/compiler_rt/floattitf.zig
+++ b/lib/compiler_rt/floattitf.zig
@@ -1,12 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__floattitf_windows_x86_64, "__floattitf");
     } else {
-        if (common.want_ppc_abi)
+        if (compiler_rt.want_ppc_abi)
             symbol(&__floattitf, "__floattikf");
         symbol(&__floattitf, "__floattitf");
     }
diff --git a/lib/compiler_rt/floattixf.zig b/lib/compiler_rt/floattixf.zig
index ac1df5ba32b359bbe414d6ec134744299d2e7786..b69b8f9845fa858e5a05133aa4b69a5c11342ca3 100644
--- a/lib/compiler_rt/floattixf.zig
+++ b/lib/compiler_rt/floattixf.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__floattixf_windows_x86_64, .{ .name = "__floattixf", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__floattixf_windows_x86_64, "__floattixf");
     } else {
-        @export(&__floattixf, .{ .name = "__floattixf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattixf, "__floattixf");
     }
 }
 
diff --git a/lib/compiler_rt/floatundidf.zig b/lib/compiler_rt/floatundidf.zig
index 6530f76ee70ed4070392e299274cb84bcf6e90e3..852675370503bab154245fd685ff2c2a5449aea0 100644
--- a/lib/compiler_rt/floatundidf.zig
+++ b/lib/compiler_rt/floatundidf.zig
@@ -1,12 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_ul2d, "__aeabi_ul2d");
     } else {
-        if (common.want_windows_arm_abi) {
+        if (compiler_rt.want_windows_arm_abi) {
             symbol(&__floatundidf, "__u64tod");
         }
         symbol(&__floatundidf, "__floatundidf");
diff --git a/lib/compiler_rt/floatundihf.zig b/lib/compiler_rt/floatundihf.zig
index e7a3f865f829ff28e7efaa805790d17a52f7d884..064d565d2dc4ec4f118dee8400375de802400f2b 100644
--- a/lib/compiler_rt/floatundihf.zig
+++ b/lib/compiler_rt/floatundihf.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatundihf, .{ .name = "__floatundihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatundihf, "__floatundihf");
 }
 
 fn __floatundihf(a: u64) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatundisf.zig b/lib/compiler_rt/floatundisf.zig
index 89e7fa1f4bf65848bcc6abbdb422e4dc77a737dc..827a419fd5315624866af773ea71a9098b2bcb3e 100644
--- a/lib/compiler_rt/floatundisf.zig
+++ b/lib/compiler_rt/floatundisf.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_ul2f, "__aeabi_ul2f");
     } else {
-        if (common.want_windows_arm_abi) {
-            @export(&__floatundisf, .{ .name = "__u64tos", .linkage = common.linkage, .visibility = common.visibility });
+        if (compiler_rt.want_windows_arm_abi) {
+            symbol(&__floatundisf, "__u64tos");
         }
-        @export(&__floatundisf, .{ .name = "__floatundisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatundisf, "__floatundisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatunditf.zig b/lib/compiler_rt/floatunditf.zig
index d313ff3d12a55290777a6af85ea4881e945eacf1..257a5779bb9bd71d80b44b79f7d4cc12a6afdace 100644
--- a/lib/compiler_rt/floatunditf.zig
+++ b/lib/compiler_rt/floatunditf.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__floatunditf, .{ .name = "__floatundikf", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_uxtoq, .{ .name = "_Qp_uxtoq", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__floatunditf, "__floatundikf");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_uxtoq, "_Qp_uxtoq");
     }
-    @export(&__floatunditf, .{ .name = "__floatunditf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatunditf, "__floatunditf");
 }
 
 pub fn __floatunditf(a: u64) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatundixf.zig b/lib/compiler_rt/floatundixf.zig
index b9691e91448866757cca2b6278768b6a6e8e3bd5..ce36d47a4ef225c67e4e45f3695cdb14649cee4c 100644
--- a/lib/compiler_rt/floatundixf.zig
+++ b/lib/compiler_rt/floatundixf.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatundixf, .{ .name = "__floatundixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatundixf, "__floatundixf");
 }
 
 fn __floatundixf(a: u64) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floatuneidf.zig b/lib/compiler_rt/floatuneidf.zig
index bb8a6579cec5d9f48125d6c7cfe9bc8b1c7c51c7..6e391b7cf1c4baeacb55c731ca24c66750c6d346 100644
--- a/lib/compiler_rt/floatuneidf.zig
+++ b/lib/compiler_rt/floatuneidf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floatuneidf, .{ .name = "__floatuneidf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatuneidf, "__floatuneidf");
 }
 
 pub fn __floatuneidf(a: [*]const u8, bits: usize) callconv(.c) f64 {
diff --git a/lib/compiler_rt/floatuneihf.zig b/lib/compiler_rt/floatuneihf.zig
index 17b1e1d29059b1ad28302e94ad33b9335275c59b..0df0cf155be8e7d39afb5012940fa85ec3211603 100644
--- a/lib/compiler_rt/floatuneihf.zig
+++ b/lib/compiler_rt/floatuneihf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floatuneihf, .{ .name = "__floatuneihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatuneihf, "__floatuneihf");
 }
 
 pub fn __floatuneihf(a: [*]const u8, bits: usize) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatuneisf.zig b/lib/compiler_rt/floatuneisf.zig
index bb43b6ee652c37bd7a2fbd6712edb636d70bde37..e2dadd9ffddc6efe13ffd53bb9f2cdeeffc3530d 100644
--- a/lib/compiler_rt/floatuneisf.zig
+++ b/lib/compiler_rt/floatuneisf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floatuneisf, .{ .name = "__floatuneisf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatuneisf, "__floatuneisf");
 }
 
 pub fn __floatuneisf(a: [*]const u8, bits: usize) callconv(.c) f32 {
diff --git a/lib/compiler_rt/floatuneixf.zig b/lib/compiler_rt/floatuneixf.zig
index ad0b8f24de1db0f665ece481853fb5ba76f1e53a..75dd565daffe16ffb4e95230266fca2f5d288603 100644
--- a/lib/compiler_rt/floatuneixf.zig
+++ b/lib/compiler_rt/floatuneixf.zig
@@ -1,10 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floatuneixf, .{ .name = "__floatuneixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatuneixf, "__floatuneixf");
 }
 
 pub fn __floatuneixf(a: [*]const u8, bits: usize) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floatunsidf.zig b/lib/compiler_rt/floatunsidf.zig
index fc50a5ad37db3cda3be420f0479f3aab09461c2a..94949c7bff4eafff900a0b22e53998a930c3d7ea 100644
--- a/lib/compiler_rt/floatunsidf.zig
+++ b/lib/compiler_rt/floatunsidf.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_ui2d, "__aeabi_ui2d");
     } else {
-        @export(&__floatunsidf, .{ .name = "__floatunsidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatunsidf, "__floatunsidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatunsisf.zig b/lib/compiler_rt/floatunsisf.zig
index 72ac1a59017743f319dd65b8d609d499999715fd..04da1aa5c03cf76815cccf2273731501d1c8edc0 100644
--- a/lib/compiler_rt/floatunsisf.zig
+++ b/lib/compiler_rt/floatunsisf.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_ui2f, "__aeabi_ui2f");
     } else {
         symbol(&__floatunsisf, "__floatunsisf");
diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig
index 6ad2ca5c5638834b27490bc3bbde0ec3a743ad77..6a5607c147ede2b8cdd10771caf3a97624bab7f2 100644
--- a/lib/compiler_rt/floatunsitf.zig
+++ b/lib/compiler_rt/floatunsitf.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__floatunsitf, "__floatunsikf");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_uitoq, "_Qp_uitoq");
     }
     symbol(&__floatunsitf, "__floatunsitf");
diff --git a/lib/compiler_rt/floatunsixf.zig b/lib/compiler_rt/floatunsixf.zig
index 875d3476fa99d0a2d96faa89ccb6f7e99c27232f..906f0270f5c53d28970a0c250b24abcadfa72946 100644
--- a/lib/compiler_rt/floatunsixf.zig
+++ b/lib/compiler_rt/floatunsixf.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatunsixf, .{ .name = "__floatunsixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatunsixf, "__floatunsixf");
 }
 
 fn __floatunsixf(a: u32) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig
index d2d34f57545fd787b35e772deacd1cae19ba9af5..7e08a66b97c4f18a85ec386e4fc8eda16bb972ab 100644
--- a/lib/compiler_rt/floatuntidf.zig
+++ b/lib/compiler_rt/floatuntidf.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__floatuntidf_windows_x86_64, "__floatuntidf");
     } else {
         symbol(&__floatuntidf, "__floatuntidf");
diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig
index 629e8088eb5abacfba51edd1915045833892cdb4..5c50f39eaad5be332c32eb5618e8ff8011f660b1 100644
--- a/lib/compiler_rt/floatuntihf.zig
+++ b/lib/compiler_rt/floatuntihf.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__floatuntihf_windows_x86_64, "__floatuntihf");
     } else {
         symbol(&__floatuntihf, "__floatuntihf");
diff --git a/lib/compiler_rt/floatuntisf.zig b/lib/compiler_rt/floatuntisf.zig
index f79d2e5feda54382074c9ca12cc32696aa1f6228..5a15f7c19d9f6906bb1a485d7101976f2297ac40 100644
--- a/lib/compiler_rt/floatuntisf.zig
+++ b/lib/compiler_rt/floatuntisf.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntisf_windows_x86_64, .{ .name = "__floatuntisf", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__floatuntisf_windows_x86_64, "__floatuntisf");
     } else {
-        @export(&__floatuntisf, .{ .name = "__floatuntisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntisf, "__floatuntisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig
index 64063495b8dc0f423ab06d6ce359ca1f772665c6..6df02c5bef9a6d43c54a82e207446d049a0b84e8 100644
--- a/lib/compiler_rt/floatuntitf.zig
+++ b/lib/compiler_rt/floatuntitf.zig
@@ -1,12 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
+    if (compiler_rt.want_windows_v2u64_abi) {
         symbol(&__floatuntitf_windows_x86_64, "__floatuntitf");
     } else {
-        if (common.want_ppc_abi)
+        if (compiler_rt.want_ppc_abi)
             symbol(&__floatuntitf, "__floatuntikf");
         symbol(&__floatuntitf, "__floatuntitf");
     }
diff --git a/lib/compiler_rt/floatuntixf.zig b/lib/compiler_rt/floatuntixf.zig
index 12a561b5732a2d8284ed81325c8e5304781fe1dd..27e668109fdc4eaf3315dea7e129aa70393782c7 100644
--- a/lib/compiler_rt/floatuntixf.zig
+++ b/lib/compiler_rt/floatuntixf.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntixf_windows_x86_64, .{ .name = "__floatuntixf", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__floatuntixf_windows_x86_64, "__floatuntixf");
     } else {
-        @export(&__floatuntixf, .{ .name = "__floatuntixf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntixf, "__floatuntixf");
     }
 }
 
diff --git a/lib/compiler_rt/floor_ceil.zig b/lib/compiler_rt/floor_ceil.zig
index c44e9c2e571eee6c009a13ed10c98742a5ec8940..f81d2e0011286a1ea45a3ef147fc704eadac4b4e 100644
--- a/lib/compiler_rt/floor_ceil.zig
+++ b/lib/compiler_rt/floor_ceil.zig
@@ -14,7 +14,7 @@ const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
@@ -23,7 +23,7 @@ comptime {
     symbol(&floorf, "floorf");
     symbol(&floor, "floor");
     symbol(&__floorx, "__floorx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&floorq, "floorf128");
     }
     symbol(&floorq, "floorq");
@@ -34,7 +34,7 @@ comptime {
     symbol(&ceilf, "ceilf");
     symbol(&ceil, "ceil");
     symbol(&__ceilx, "__ceilx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&ceilq, "ceilf128");
     }
     symbol(&ceilq, "ceilq");
@@ -106,11 +106,11 @@ inline fn impl(comptime T: type, comptime op: enum { floor, ceil }, x: T) T {
             if (e >= 0) {
                 const m = (@as(U, 1) << @intCast(mantissa - e)) - 1;
                 if (u & m == 0) return x;
-                if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1.0p120);
+                if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1.0p120);
                 if (u >> bits - 1 == @intFromBool(op == .floor)) u += m;
                 return @bitCast(u & ~m);
             } else {
-                if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1.0p120);
+                if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1.0p120);
                 return switch (op) {
                     .floor => if (u >> bits - 1 == 0) 0.0 else if (u << 1 != 0) -1.0 else x,
                     .ceil => if (u >> bits - 1 != 0) -0.0 else if (u << 1 != 0) 1.0 else x,
@@ -128,7 +128,7 @@ inline fn impl(comptime T: type, comptime op: enum { floor, ceil }, x: T) T {
                 x - C + C - x;
 
             if (e <= bias - 1) {
-                if (common.want_float_exceptions) mem.doNotOptimizeAway(y);
+                if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(y);
                 return switch (op) {
                     .floor => if (positive) 0.0 else -1.0,
                     .ceil => if (positive) 1.0 else -0.0,
diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig
index cce9215f881d1d0aad575e1afa17c9e50a08fe6d..10926e9bde05d36d8cdf16661542df9821621e0c 100644
--- a/lib/compiler_rt/fma.zig
+++ b/lib/compiler_rt/fma.zig
@@ -8,18 +8,19 @@
 const std = @import("std");
 const math = std.math;
 const expect = std.testing.expect;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__fmah, .{ .name = "__fmah", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmaf, .{ .name = "fmaf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fma, .{ .name = "fma", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__fmax, .{ .name = "__fmax", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&fmaq, .{ .name = "fmaf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fmah, "__fmah");
+    symbol(&fmaf, "fmaf");
+    symbol(&fma, "fma");
+    symbol(&__fmax, "__fmax");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&fmaq, "fmaf128");
     }
-    @export(&fmaq, .{ .name = "fmaq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmal, .{ .name = "fmal", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&fmaq, "fmaq");
+    symbol(&fmal, "fmal");
 }
 
 pub fn __fmah(x: f16, y: f16, z: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/fmax.zig b/lib/compiler_rt/fmax.zig
index 19a7c3f6f7899021efddc3d458d39a52403c056e..606888d2d4f63a88a6a7de945239ddaca43f483d 100644
--- a/lib/compiler_rt/fmax.zig
+++ b/lib/compiler_rt/fmax.zig
@@ -2,18 +2,19 @@ const std = @import("std");
 const builtin = @import("builtin");
 const math = std.math;
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__fmaxh, .{ .name = "__fmaxh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmaxf, .{ .name = "fmaxf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmax, .{ .name = "fmax", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__fmaxx, .{ .name = "__fmaxx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&fmaxq, .{ .name = "fmaxf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fmaxh, "__fmaxh");
+    symbol(&fmaxf, "fmaxf");
+    symbol(&fmax, "fmax");
+    symbol(&__fmaxx, "__fmaxx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&fmaxq, "fmaxf128");
     }
-    @export(&fmaxq, .{ .name = "fmaxq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmaxl, .{ .name = "fmaxl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&fmaxq, "fmaxq");
+    symbol(&fmaxl, "fmaxl");
 }
 
 pub fn __fmaxh(x: f16, y: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/fmin.zig b/lib/compiler_rt/fmin.zig
index aa54ba6e0b081a0bdcedceaf79c674abb1591d3c..bea1779476c89f2e4d174f5d5f381f4ac802dde6 100644
--- a/lib/compiler_rt/fmin.zig
+++ b/lib/compiler_rt/fmin.zig
@@ -2,18 +2,19 @@ const std = @import("std");
 const builtin = @import("builtin");
 const math = std.math;
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__fminh, .{ .name = "__fminh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fminf, .{ .name = "fminf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmin, .{ .name = "fmin", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__fminx, .{ .name = "__fminx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&fminq, .{ .name = "fminf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fminh, "__fminh");
+    symbol(&fminf, "fminf");
+    symbol(&fmin, "fmin");
+    symbol(&__fminx, "__fminx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&fminq, "fminf128");
     }
-    @export(&fminq, .{ .name = "fminq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fminl, .{ .name = "fminl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&fminq, "fminq");
+    symbol(&fminl, "fminl");
 }
 
 pub fn __fminh(x: f16, y: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig
index ae5abaae65f68021638dec7948fc729d302bc589..c2108abf3394d67d575ec124e23d61f19c5a5482 100644
--- a/lib/compiler_rt/fmod.zig
+++ b/lib/compiler_rt/fmod.zig
@@ -3,19 +3,20 @@ const std = @import("std");
 const math = std.math;
 const assert = std.debug.assert;
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
-const normalize = common.normalize;
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+const normalize = compiler_rt.normalize;
 
 comptime {
-    @export(&__fmodh, .{ .name = "__fmodh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmodf, .{ .name = "fmodf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmod, .{ .name = "fmod", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__fmodx, .{ .name = "__fmodx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&fmodq, .{ .name = "fmodf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fmodh, "__fmodh");
+    symbol(&fmodf, "fmodf");
+    symbol(&fmod, "fmod");
+    symbol(&__fmodx, "__fmodx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&fmodq, "fmodf128");
     }
-    @export(&fmodq, .{ .name = "fmodq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&fmodl, .{ .name = "fmodl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&fmodq, "fmodq");
+    symbol(&fmodl, "fmodl");
 }
 
 pub fn __fmodh(x: f16, y: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig
index bd16de17f82329b39e158265f5616ebbdd12b510..a37fb27bd362d4f5a3155657624430e19461356c 100644
--- a/lib/compiler_rt/gedf2.zig
+++ b/lib/compiler_rt/gedf2.zig
@@ -1,11 +1,11 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const comparef = @import("./comparef.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_dcmpge, "__aeabi_dcmpge");
         symbol(&__aeabi_dcmpgt, "__aeabi_dcmpgt");
     } else {
diff --git a/lib/compiler_rt/gesf2.zig b/lib/compiler_rt/gesf2.zig
index d4b6a23c662db77423c5bf35c664ef0462fb4552..49454c469411e4fe41aee3d5edbb71630b6ca7f0 100644
--- a/lib/compiler_rt/gesf2.zig
+++ b/lib/compiler_rt/gesf2.zig
@@ -1,15 +1,16 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_fcmpge, "__aeabi_fcmpge");
+        symbol(&__aeabi_fcmpgt, "__aeabi_fcmpgt");
     } else {
-        @export(&__gesf2, .{ .name = "__gesf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__gtsf2, .{ .name = "__gtsf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gesf2, "__gesf2");
+        symbol(&__gtsf2, "__gtsf2");
     }
 }
 
diff --git a/lib/compiler_rt/getf2.zig b/lib/compiler_rt/getf2.zig
index a6014b365e56a2a68bb3bb9fb22bcfbad3f29ed2..4476ab636c27a1a2c3ef6a4e598d4f8e7b63ee8a 100644
--- a/lib/compiler_rt/getf2.zig
+++ b/lib/compiler_rt/getf2.zig
@@ -1,18 +1,19 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__getf2, .{ .name = "__gekf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__gttf2, .{ .name = "__gtkf2", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__getf2, "__gekf2");
+        symbol(&__gttf2, "__gtkf2");
+    } else if (compiler_rt.want_sparc_abi) {
         // These exports are handled in cmptf2.zig because gt and ge on sparc
         // are based on calling _Qp_cmp.
     }
-    @export(&__getf2, .{ .name = "__getf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__gttf2, .{ .name = "__gttf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__getf2, "__getf2");
+    symbol(&__gttf2, "__gttf2");
 }
 
 /// "These functions return a value greater than or equal to zero if neither
diff --git a/lib/compiler_rt/hexagon.zig b/lib/compiler_rt/hexagon.zig
index de7fd96491247917759074434a0cad49a7739169..2a4b8b75f7d0e961a853225bab3bbd135bf4665a 100644
--- a/lib/compiler_rt/hexagon.zig
+++ b/lib/compiler_rt/hexagon.zig
@@ -1,5 +1,7 @@
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 fn __hexagon_divsi3() callconv(.naked) noreturn {
     asm volatile (
@@ -1759,29 +1761,29 @@ fn __hexagon_sqrtdf2() align(32) callconv(.naked) noreturn {
 
 comptime {
     if (builtin.cpu.arch == .hexagon) {
-        @export(&__hexagon_adddf3, .{ .name = "__hexagon_adddf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_adddf3, .{ .name = "__hexagon_fast_adddf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_subdf3, .{ .name = "__hexagon_subdf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_subdf3, .{ .name = "__hexagon_fast_subdf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_divdf3, .{ .name = "__hexagon_divdf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_divdf3, .{ .name = "__hexagon_fast_divdf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_muldf3, .{ .name = "__hexagon_muldf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_muldf3, .{ .name = "__hexagon_fast_muldf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_sqrtdf2, .{ .name = "__hexagon_sqrtdf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_sqrtdf2, .{ .name = "__hexagon_fast2_sqrtdf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_sqrtdf2, .{ .name = "__hexagon_sqrt", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_divsf3, .{ .name = "__hexagon_divsf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_divsf3, .{ .name = "__hexagon_fast_divsf3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_divsi3, .{ .name = "__hexagon_divsi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_umodsi3, .{ .name = "__hexagon_umodsi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_sqrtf, .{ .name = "__hexagon_sqrtf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_sqrtf, .{ .name = "__hexagon_fast2_sqrtf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_moddi3, .{ .name = "__hexagon_moddi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_divdi3, .{ .name = "__hexagon_divdi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_udivdi3, .{ .name = "__hexagon_udivdi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_umoddi3, .{ .name = "__hexagon_umoddi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_modsi3, .{ .name = "__hexagon_modsi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes, .{ .name = "__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__hexagon_udivsi3, .{ .name = "__hexagon_udivsi3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__hexagon_adddf3, "__hexagon_adddf3");
+        symbol(&__hexagon_adddf3, "__hexagon_fast_adddf3");
+        symbol(&__hexagon_subdf3, "__hexagon_subdf3");
+        symbol(&__hexagon_subdf3, "__hexagon_fast_subdf3");
+        symbol(&__hexagon_divdf3, "__hexagon_divdf3");
+        symbol(&__hexagon_divdf3, "__hexagon_fast_divdf3");
+        symbol(&__hexagon_muldf3, "__hexagon_muldf3");
+        symbol(&__hexagon_muldf3, "__hexagon_fast_muldf3");
+        symbol(&__hexagon_sqrtdf2, "__hexagon_sqrtdf2");
+        symbol(&__hexagon_sqrtdf2, "__hexagon_fast2_sqrtdf2");
+        symbol(&__hexagon_sqrtdf2, "__hexagon_sqrt");
+        symbol(&__hexagon_divsf3, "__hexagon_divsf3");
+        symbol(&__hexagon_divsf3, "__hexagon_fast_divsf3");
+        symbol(&__hexagon_divsi3, "__hexagon_divsi3");
+        symbol(&__hexagon_umodsi3, "__hexagon_umodsi3");
+        symbol(&__hexagon_sqrtf, "__hexagon_sqrtf");
+        symbol(&__hexagon_sqrtf, "__hexagon_fast2_sqrtf");
+        symbol(&__hexagon_moddi3, "__hexagon_moddi3");
+        symbol(&__hexagon_divdi3, "__hexagon_divdi3");
+        symbol(&__hexagon_udivdi3, "__hexagon_udivdi3");
+        symbol(&__hexagon_umoddi3, "__hexagon_umoddi3");
+        symbol(&__hexagon_modsi3, "__hexagon_modsi3");
+        symbol(&__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes, "__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes");
+        symbol(&__hexagon_udivsi3, "__hexagon_udivsi3");
     }
 }
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index 01827cf6404d2e48826e14bb3c514e38519c9522..48c900207bce8946adf6bb9cafe9407b214946d4 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -8,16 +8,16 @@ const testing = std.testing;
 const maxInt = std.math.maxInt;
 const minInt = std.math.minInt;
 
-const common = @import("common.zig");
-const symbol = @import("../compiler_rt.zig").symbol;
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const udivmod = @import("udivmod.zig").udivmod;
-const __divti3 = @import("divti3.zig").__divti3;
+const __divti3 = @import("udivmod.zig").__divti3;
 
 comptime {
     symbol(&__divmodti4, "__divmodti4");
     symbol(&__udivmoddi4, "__udivmoddi4");
     symbol(&__divmoddi4, "__divmoddi4");
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_idiv, "__aeabi_idiv");
         symbol(&__aeabi_uidiv, "__aeabi_uidiv");
     } else {
diff --git a/lib/compiler_rt/int_from_float.zig b/lib/compiler_rt/int_from_float.zig
index 1f1cdb215f2fea1120d2583c8fa0a176abaf5dfb..146456fd110812e036413fc4638412d73cd0ac87 100644
--- a/lib/compiler_rt/int_from_float.zig
+++ b/lib/compiler_rt/int_from_float.zig
@@ -1,13 +1,58 @@
 const std = @import("std");
-const Int = std.meta.Int;
 const math = std.math;
-const Log2Int = math.Log2Int;
+const Log2Int = std.math.Log2Int;
+
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+
+comptime {
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__fixxfti_windows_x86_64, "__fixxfti");
+    } else {
+        symbol(&__fixxfti, "__fixxfti");
+    }
+
+    symbol(&__fixhfsi, "__fixhfsi");
+    symbol(&__fixhfdi, "__fixhfdi");
+
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__fixhfti_windows_x86_64, "__fixhfti");
+    } else {
+        symbol(&__fixhfti, "__fixhfti");
+    }
+}
+
+const v2u64 = @Vector(2, u64);
+
+pub fn __fixhfti(a: f16) callconv(.c) i128 {
+    return intFromFloat(i128, a);
+}
+
+fn __fixhfti_windows_x86_64(a: f16) callconv(.c) v2u64 {
+    return @bitCast(intFromFloat(i128, a));
+}
+
+fn __fixhfdi(a: f16) callconv(.c) i64 {
+    return intFromFloat(i64, a);
+}
+
+fn __fixhfsi(a: f16) callconv(.c) i32 {
+    return intFromFloat(i32, a);
+}
+
+pub fn __fixxfti(a: f80) callconv(.c) i128 {
+    return intFromFloat(i128, a);
+}
+
+fn __fixxfti_windows_x86_64(a: f80) callconv(.c) v2u64 {
+    return @bitCast(intFromFloat(i128, a));
+}
 
 pub inline fn intFromFloat(comptime I: type, a: anytype) I {
     const F = @TypeOf(a);
     const float_bits = @typeInfo(F).float.bits;
     const int_bits = @typeInfo(I).int.bits;
-    const rep_t = Int(.unsigned, float_bits);
+    const rep_t = @Int(.unsigned, float_bits);
     const sig_bits = math.floatMantissaBits(F);
     const exp_bits = math.floatExponentBits(F);
     const fractional_bits = math.floatFractionalBits(F);
diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig
index 96dd319f720bf7237e603f82f7d2284866159af7..0cd2a00ddb18746d85edb5409aa162f1dcf44a7e 100644
--- a/lib/compiler_rt/log.zig
+++ b/lib/compiler_rt/log.zig
@@ -9,7 +9,7 @@ const math = std.math;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
@@ -17,7 +17,7 @@ comptime {
     symbol(&logf, "logf");
     symbol(&log, "log");
     symbol(&__logx, "__logx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&logq, "logf128");
     }
     symbol(&logq, "logq");
@@ -45,11 +45,11 @@ pub fn logf(x_: f32) callconv(.c) f32 {
     if (ix < 0x00800000 or ix >> 31 != 0) {
         // log(+-0) = -inf
         if (ix << 1 == 0) {
-            return if (common.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
         }
         // log(-#) = nan
         if (ix >> 31 != 0) {
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
         }
 
         // subnormal, scale x
@@ -398,13 +398,13 @@ pub fn log(x: f64) callconv(.c) f64 {
         @branchHint(.unlikely);
 
         if (ix << 1 == 0)
-            return if (common.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
 
         if (ix == @as(i64, @bitCast(std.math.inf(f64))))
             return x;
 
         if (top & 0x8000 != 0 or top & 0x7ff0 == 0x7ff0)
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
 
         ix = @as(i64, @bitCast(x * 0x1p52)) - (52 << 52);
     }
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index d2741e3b231d8b0e6008f506b9cdef38e4bd392a..ec4edac61860c7285879d13f0c1df4685774f370 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -10,7 +10,7 @@ const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const maxInt = std.math.maxInt;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
@@ -18,7 +18,7 @@ comptime {
     symbol(&log10f, "log10f");
     symbol(&log10, "log10");
     symbol(&__log10x, "__log10x");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&log10q, "log10f128");
     }
     symbol(&log10q, "log10q");
@@ -49,11 +49,11 @@ pub fn log10f(x_: f32) callconv(.c) f32 {
     if (ix < 0x00800000 or ix >> 31 != 0) {
         // log(+-0) = -inf
         if (ix << 1 == 0) {
-            return if (common.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
         }
         // log(-#) = nan
         if (ix >> 31 != 0) {
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
         }
 
         k -= 25;
@@ -111,11 +111,11 @@ pub fn log10(x_: f64) callconv(.c) f64 {
     if (hx < 0x00100000 or hx >> 31 != 0) {
         // log(+-0) = -inf
         if (ix << 1 == 0) {
-            return if (common.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
         }
         // log(-#) = nan
         if (hx >> 31 != 0) {
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
         }
 
         // subnormal, scale x
diff --git a/lib/compiler_rt/log2.zig b/lib/compiler_rt/log2.zig
index 48ff6135d8f4559a83eb5719545ee573409396e3..ad17df7f653dbff49570203f79307049926dae74 100644
--- a/lib/compiler_rt/log2.zig
+++ b/lib/compiler_rt/log2.zig
@@ -11,18 +11,19 @@ const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const maxInt = std.math.maxInt;
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__log2h, .{ .name = "__log2h", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log2f, .{ .name = "log2f", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log2, .{ .name = "log2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__log2x, .{ .name = "__log2x", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&log2q, .{ .name = "log2f128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__log2h, "__log2h");
+    symbol(&log2f, "log2f");
+    symbol(&log2, "log2");
+    symbol(&__log2x, "__log2x");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&log2q, "log2f128");
     }
-    @export(&log2q, .{ .name = "log2q", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log2l, .{ .name = "log2l", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&log2q, "log2q");
+    symbol(&log2l, "log2l");
 }
 
 pub fn __log2h(a: f16) callconv(.c) f16 {
@@ -47,11 +48,11 @@ pub fn log2f(x_: f32) callconv(.c) f32 {
     if (ix < 0x00800000 or ix >> 31 != 0) {
         // log(+-0) = -inf
         if (ix << 1 == 0) {
-            return if (common.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
         }
         // log(-#) = nan
         if (ix >> 31 != 0) {
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
         }
 
         k -= 25;
@@ -105,11 +106,11 @@ pub fn log2(x_: f64) callconv(.c) f64 {
     if (hx < 0x00100000 or hx >> 31 != 0) {
         // log(+-0) = -inf
         if (ix << 1 == 0) {
-            return if (common.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
+            return if (compiler_rt.want_float_exceptions) -1 / (x * x) else -std.math.inf(f64);
         }
         // log(-#) = nan
         if (hx >> 31 != 0) {
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
         }
 
         // subnormal, scale x
diff --git a/lib/compiler_rt/memcpy.zig b/lib/compiler_rt/memcpy.zig
index 4dcd184d29e04a63a5323335ffd5c972bac18a07..bb3c91eea83601771be7a61f1f4a8cd3d20e2249 100644
--- a/lib/compiler_rt/memcpy.zig
+++ b/lib/compiler_rt/memcpy.zig
@@ -1,14 +1,14 @@
 const std = @import("std");
 const assert = std.debug.assert;
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const builtin = @import("builtin");
 
 comptime {
     if (builtin.object_format != .c) {
         const export_options: std.builtin.ExportOptions = .{
             .name = "memcpy",
-            .linkage = common.linkage,
-            .visibility = common.visibility,
+            .linkage = compiler_rt.linkage,
+            .visibility = compiler_rt.visibility,
         };
 
         if (builtin.mode == .ReleaseSmall or builtin.zig_backend == .stage2_aarch64)
@@ -18,7 +18,7 @@ comptime {
     }
 }
 
-const Element = common.PreferredLoadStoreElement;
+const Element = compiler_rt.PreferredLoadStoreElement;
 
 comptime {
     assert(std.math.isPowerOfTwo(@sizeOf(Element)));
diff --git a/lib/compiler_rt/memmove.zig b/lib/compiler_rt/memmove.zig
index c57ba9c3cc2c89adc3699f2e5a98c527ed9165bd..ad501e758aba4bcd1b2247900369cbeffbd8275a 100644
--- a/lib/compiler_rt/memmove.zig
+++ b/lib/compiler_rt/memmove.zig
@@ -1,17 +1,17 @@
 const std = @import("std");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const builtin = @import("builtin");
 const assert = std.debug.assert;
 const memcpy = @import("memcpy.zig");
 
-const Element = common.PreferredLoadStoreElement;
+const Element = compiler_rt.PreferredLoadStoreElement;
 
 comptime {
     if (builtin.object_format != .c) {
         const export_options: std.builtin.ExportOptions = .{
             .name = "memmove",
-            .linkage = common.linkage,
-            .visibility = common.visibility,
+            .linkage = compiler_rt.linkage,
+            .visibility = compiler_rt.visibility,
         };
 
         if (builtin.mode == .ReleaseSmall or builtin.zig_backend == .stage2_aarch64)
@@ -39,7 +39,7 @@ fn memmoveSmall(opt_dest: ?[*]u8, opt_src: ?[*]const u8, len: usize) callconv(.c
 }
 
 fn memmoveFast(dest: ?[*]u8, src: ?[*]u8, len: usize) callconv(.c) ?[*]u8 {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const small_limit = @max(2 * @sizeOf(Element), @sizeOf(Element));
 
     if (copySmallLength(small_limit, dest.?, src.?, len)) return dest;
@@ -79,7 +79,7 @@ inline fn copyLessThan16(
     src: [*]const u8,
     len: usize,
 ) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     if (len < 4) {
         if (len == 0) return;
         const b = len / 2;
@@ -100,7 +100,7 @@ inline fn copy16ToSmallLimit(
     src: [*]const u8,
     len: usize,
 ) bool {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     inline for (2..(std.math.log2(small_limit) + 1) / 2 + 1) |p| {
         const limit = 1 << (2 * p);
         if (len < limit) {
@@ -119,7 +119,7 @@ inline fn copyRange4(
     src: [*]const u8,
     len: usize,
 ) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     comptime assert(std.math.isPowerOfTwo(copy_len));
     assert(len >= copy_len);
     assert(len < 4 * copy_len);
@@ -147,7 +147,7 @@ inline fn copyForwards(
     src: [*]const u8,
     len: usize,
 ) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     assert(len >= 2 * @sizeOf(Element));
 
     const head = src[0..@sizeOf(Element)].*;
@@ -181,7 +181,7 @@ inline fn copyBlocks(
     src: anytype,
     max_bytes: usize,
 ) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
 
     const T = @typeInfo(@TypeOf(dest)).pointer.child;
     comptime assert(T == @typeInfo(@TypeOf(src)).pointer.child);
diff --git a/lib/compiler_rt/memset.zig b/lib/compiler_rt/memset.zig
deleted file mode 100644
index 6b51037b57d3644ade239d8f0c7d731cc74c3512..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/memset.zig
+++ /dev/null
@@ -1,33 +0,0 @@
-const std = @import("std");
-const common = @import("./common.zig");
-const builtin = @import("builtin");
-
-comptime {
-    if (builtin.object_format != .c) {
-        @export(&memset, .{ .name = "memset", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__memset, .{ .name = "__memset", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn memset(dest: ?[*]u8, c: u8, len: usize) callconv(.c) ?[*]u8 {
-    @setRuntimeSafety(false);
-
-    if (len != 0) {
-        var d = dest.?;
-        var n = len;
-        while (true) {
-            d[0] = c;
-            n -= 1;
-            if (n == 0) break;
-            d += 1;
-        }
-    }
-
-    return dest;
-}
-
-pub fn __memset(dest: ?[*]u8, c: u8, n: usize, dest_n: usize) callconv(.c) ?[*]u8 {
-    if (dest_n < n)
-        @panic("buffer overflow");
-    return memset(dest, c, n);
-}
diff --git a/lib/compiler_rt/modti3.zig b/lib/compiler_rt/modti3.zig
deleted file mode 100644
index 74e431a06166be0d1a4048400e8ebe3095345e98..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/modti3.zig
+++ /dev/null
@@ -1,42 +0,0 @@
-//! Ported from:
-//!
-//! https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/lib/builtins/modti3.c
-
-const std = @import("std");
-const builtin = @import("builtin");
-const udivmod = @import("udivmod.zig").udivmod;
-const common = @import("common.zig");
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__modti3, .{ .name = "__modti3", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __modti3(a: i128, b: i128) callconv(.c) i128 {
-    return mod(a, b);
-}
-
-const v2u64 = @Vector(2, u64);
-
-fn __modti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
-    return @bitCast(mod(@as(i128, @bitCast(a)), @as(i128, @bitCast(b))));
-}
-
-inline fn mod(a: i128, b: i128) i128 {
-    const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0
-    const s_b = b >> (128 - 1); // s = b < 0 ? -1 : 0
-
-    const an = (a ^ s_a) -% s_a; // negate if s == -1
-    const bn = (b ^ s_b) -% s_b; // negate if s == -1
-
-    var r: u128 = undefined;
-    _ = udivmod(u128, @as(u128, @bitCast(an)), @as(u128, @bitCast(bn)), &r);
-    return (@as(i128, @bitCast(r)) ^ s_a) -% s_a; // negate if s == -1
-}
-
-test {
-    _ = @import("modti3_test.zig");
-}
diff --git a/lib/compiler_rt/modti3_test.zig b/lib/compiler_rt/modti3_test.zig
index 800547b48bcc8826f71a8a7168b5c4596e90c9d5..6959e09dccce78b6e84eb4f0a932e0085514f272 100644
--- a/lib/compiler_rt/modti3_test.zig
+++ b/lib/compiler_rt/modti3_test.zig
@@ -1,4 +1,4 @@
-const __modti3 = @import("modti3.zig").__modti3;
+const __modti3 = @import("udivmod.zig").__modti3;
 const testing = @import("std").testing;
 
 fn test__modti3(a: i128, b: i128, expected: i128) !void {
diff --git a/lib/compiler_rt/mulXi3.zig b/lib/compiler_rt/mulXi3.zig
index 198d51c8883875c28134e48eb60e667699e05c49..41df7283ea7c1e801c8a631e91724fc9e87f1a48 100644
--- a/lib/compiler_rt/mulXi3.zig
+++ b/lib/compiler_rt/mulXi3.zig
@@ -1,20 +1,21 @@
 const builtin = @import("builtin");
 const std = @import("std");
 const testing = std.testing;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const native_endian = builtin.cpu.arch.endian();
 
 comptime {
-    @export(&__mulsi3, .{ .name = "__mulsi3", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_aeabi) {
-        @export(&__aeabi_lmul, .{ .name = "__aeabi_lmul", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__mulsi3, "__mulsi3");
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_lmul, "__aeabi_lmul");
     } else {
-        @export(&__muldi3, .{ .name = "__muldi3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__muldi3, "__muldi3");
     }
-    if (common.want_windows_v2u64_abi) {
-        @export(&__multi3_windows_x86_64, .{ .name = "__multi3", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__multi3_windows_x86_64, "__multi3");
     } else {
-        @export(&__multi3, .{ .name = "__multi3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__multi3, "__multi3");
     }
 }
 
@@ -41,7 +42,7 @@ fn __aeabi_lmul(a: i64, b: i64) callconv(.{ .arm_aapcs = .{} }) i64 {
 }
 
 inline fn mulX(comptime T: type, a: T, b: T) T {
-    const word_t = common.HalveInt(T, false);
+    const word_t = compiler_rt.HalveInt(T, false);
     const x = word_t{ .all = a };
     const y = word_t{ .all = b };
     var r = switch (T) {
@@ -64,7 +65,7 @@ fn DoubleInt(comptime T: type) type {
 
 fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
     const DT = DoubleInt(T);
-    const word_t = common.HalveInt(DT, false);
+    const word_t = compiler_rt.HalveInt(DT, false);
     const bits_in_word_2 = @sizeOf(T) * 8 / 2;
     const lower_mask = (~@as(T, 0)) >> bits_in_word_2;
 
diff --git a/lib/compiler_rt/muldf3.zig b/lib/compiler_rt/muldf3.zig
index e9c978430ecd15dceba4896874e3c118374b1f04..b8809e76da8d11e04c181d9dea86911aaac1cb29 100644
--- a/lib/compiler_rt/muldf3.zig
+++ b/lib/compiler_rt/muldf3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_dmul, "__aeabi_dmul");
     } else {
         symbol(&__muldf3, "__muldf3");
diff --git a/lib/compiler_rt/mulf3.zig b/lib/compiler_rt/mulf3.zig
index 34d39fb9b705dbf570a1841be8a6695906448d09..d85b0bf8d57185f5c3a86b6bf1ffde0efa567750 100644
--- a/lib/compiler_rt/mulf3.zig
+++ b/lib/compiler_rt/mulf3.zig
@@ -1,12 +1,12 @@
 const std = @import("std");
 const math = std.math;
 const builtin = @import("builtin");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 
 /// Ported from:
 /// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/lib/builtins/fp_mul_impl.inc
 pub inline fn mulf3(comptime T: type, a: T, b: T) T {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const typeWidth = @typeInfo(T).float.bits;
     const significandBits = math.floatMantissaBits(T);
     const fractionalBits = math.floatFractionalBits(T);
@@ -97,7 +97,7 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
     var productHi: ZSignificand = undefined;
     var productLo: ZSignificand = undefined;
     const left_align_shift = ZSignificandBits - fractionalBits - 1;
-    common.wideMultiply(ZSignificand, aSignificand, bSignificand << left_align_shift, &productHi, &productLo);
+    compiler_rt.wideMultiply(ZSignificand, aSignificand, bSignificand << left_align_shift, &productHi, &productLo);
 
     var productExponent: i32 = @as(i32, @intCast(aExponent + bExponent)) - exponentBias + scale;
 
@@ -163,7 +163,7 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
 ///
 /// This is analogous to an shr version of `@shlWithOverflow`
 fn wideShrWithTruncation(comptime Z: type, hi: *Z, lo: *Z, count: u32) bool {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const typeWidth = @typeInfo(Z).int.bits;
     var inexact = false;
     if (count < typeWidth) {
diff --git a/lib/compiler_rt/mulhc3.zig b/lib/compiler_rt/mulhc3.zig
index 09bca03a050c1281dedc68c1c94028d0f5e79dea..4e0d3f875389ddf2f02bb7ddb3f75106e6d48513 100644
--- a/lib/compiler_rt/mulhc3.zig
+++ b/lib/compiler_rt/mulhc3.zig
@@ -1,9 +1,10 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__mulhc3, .{ .name = "__mulhc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__mulhc3, "__mulhc3");
     }
 }
 
diff --git a/lib/compiler_rt/mulhf3.zig b/lib/compiler_rt/mulhf3.zig
index 22f7a95627f9c82dbe3f9b818e062c7188cd8a44..46ce7a6b999005704db84280e3e83c7be05985b6 100644
--- a/lib/compiler_rt/mulhf3.zig
+++ b/lib/compiler_rt/mulhf3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
-    @export(&__mulhf3, .{ .name = "__mulhf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__mulhf3, "__mulhf3");
 }
 
 pub fn __mulhf3(a: f16, b: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/mulo.zig b/lib/compiler_rt/mulo.zig
index b85623eb7e5107984a9b52b1a47d0f40200f1218..979a5452a53e3497f48af7bf4abe8af9eb7ed884 100644
--- a/lib/compiler_rt/mulo.zig
+++ b/lib/compiler_rt/mulo.zig
@@ -1,12 +1,13 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const math = std.math;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__mulosi4, .{ .name = "__mulosi4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__mulodi4, .{ .name = "__mulodi4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__muloti4, .{ .name = "__muloti4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__mulosi4, "__mulosi4");
+    symbol(&__mulodi4, "__mulodi4");
+    symbol(&__muloti4, "__muloti4");
 }
 
 // mulo - multiplication overflow
diff --git a/lib/compiler_rt/mulsf3.zig b/lib/compiler_rt/mulsf3.zig
index a603652262bcfd7612abe196ac80d6a04dc1be35..81f9eafae213d8cba10579b86f109bdfd361ba41 100644
--- a/lib/compiler_rt/mulsf3.zig
+++ b/lib/compiler_rt/mulsf3.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_fmul, "__aeabi_fmul");
     } else {
-        @export(&__mulsf3, .{ .name = "__mulsf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__mulsf3, "__mulsf3");
     }
 }
 
diff --git a/lib/compiler_rt/multc3.zig b/lib/compiler_rt/multc3.zig
index 13870c6465e4d6e200119ab266ccd63f6769f306..4914735b10f63ec38d3487738e461769db6f8669 100644
--- a/lib/compiler_rt/multc3.zig
+++ b/lib/compiler_rt/multc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        if (common.want_ppc_abi)
+        if (compiler_rt.want_ppc_abi)
             symbol(&__multc3, "__mulkc3");
         symbol(&__multc3, "__multc3");
     }
diff --git a/lib/compiler_rt/multf3.zig b/lib/compiler_rt/multf3.zig
index 6ef9cc2c2580ece0ab9f86495091c21e03a9275c..3befe34da0f4b3634ada353d8918d9542239a16e 100644
--- a/lib/compiler_rt/multf3.zig
+++ b/lib/compiler_rt/multf3.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__multf3, .{ .name = "__mulkf3", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_mul, .{ .name = "_Qp_mul", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__multf3, "__mulkf3");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_mul, "_Qp_mul");
     }
-    @export(&__multf3, .{ .name = "__multf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__multf3, "__multf3");
 }
 
 pub fn __multf3(a: f128, b: f128) callconv(.c) f128 {
diff --git a/lib/compiler_rt/mulxc3.zig b/lib/compiler_rt/mulxc3.zig
index cbf9c640830519ad6058986202fa886a7ee5f15d..ac0e189f63ba4d4ce2f0a753c4f7409e0b551d23 100644
--- a/lib/compiler_rt/mulxc3.zig
+++ b/lib/compiler_rt/mulxc3.zig
@@ -1,9 +1,10 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__mulxc3, .{ .name = "__mulxc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__mulxc3, "__mulxc3");
     }
 }
 
diff --git a/lib/compiler_rt/mulxf3.zig b/lib/compiler_rt/mulxf3.zig
index 1d9f465ebd053a498493f964f6406911384b72c7..dcf783a4a6bc434275416e9da0079f65b3354277 100644
--- a/lib/compiler_rt/mulxf3.zig
+++ b/lib/compiler_rt/mulxf3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
-    @export(&__mulxf3, .{ .name = "__mulxf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__mulxf3, "__mulxf3");
 }
 
 pub fn __mulxf3(a: f80, b: f80) callconv(.c) f80 {
diff --git a/lib/compiler_rt/negXi2.zig b/lib/compiler_rt/negXi2.zig
deleted file mode 100644
index 7a57e988c6e5520a91595e89f4f160271638b35f..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/negXi2.zig
+++ /dev/null
@@ -1,39 +0,0 @@
-//! neg - negate (the number)
-//! - negXi2 for unoptimized little and big endian
-//! sfffffff = 2^31-1
-//! two's complement inverting bits and add 1 would result in -INT_MIN == 0
-//! => -INT_MIN = -2^31 forbidden
-//! * size optimized builds
-//! * machines that dont support carry operations
-
-const std = @import("std");
-const builtin = @import("builtin");
-const common = @import("common.zig");
-
-comptime {
-    @export(&__negsi2, .{ .name = "__negsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__negdi2, .{ .name = "__negdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__negti2, .{ .name = "__negti2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-pub fn __negsi2(a: i32) callconv(.c) i32 {
-    return negXi2(i32, a);
-}
-
-pub fn __negdi2(a: i64) callconv(.c) i64 {
-    return negXi2(i64, a);
-}
-
-pub fn __negti2(a: i128) callconv(.c) i128 {
-    return negXi2(i128, a);
-}
-
-inline fn negXi2(comptime T: type, a: T) T {
-    return -a;
-}
-
-test {
-    _ = @import("negsi2_test.zig");
-    _ = @import("negdi2_test.zig");
-    _ = @import("negti2_test.zig");
-}
diff --git a/lib/compiler_rt/negdf2.zig b/lib/compiler_rt/negdf2.zig
deleted file mode 100644
index b0ac26e6c0c5b8f6e946c38c81ccbd15c38da129..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/negdf2.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const common = @import("./common.zig");
-
-comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_dneg, .{ .name = "__aeabi_dneg", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__negdf2, .{ .name = "__negdf2", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-fn __negdf2(a: f64) callconv(.c) f64 {
-    return common.fneg(a);
-}
-
-fn __aeabi_dneg(a: f64) callconv(.{ .arm_aapcs = .{} }) f64 {
-    return common.fneg(a);
-}
diff --git a/lib/compiler_rt/negdi2_test.zig b/lib/compiler_rt/negdi2_test.zig
index a4bb0217ada987622d4269b682f369ae83864c2e..2a3a96619351235e443d8aa7b67ae1aa4b55bc1b 100644
--- a/lib/compiler_rt/negdi2_test.zig
+++ b/lib/compiler_rt/negdi2_test.zig
@@ -1,8 +1,10 @@
-const neg = @import("negXi2.zig");
-const testing = @import("std").testing;
+const std = @import("std");
+const testing = std.testing;
+
+const compiler_rt = @import("../compiler_rt.zig");
 
 fn test__negdi2(a: i64, expected: i64) !void {
-    const result = neg.__negdi2(a);
+    const result = compiler_rt.__negdi2(a);
     try testing.expectEqual(expected, result);
 }
 
diff --git a/lib/compiler_rt/neghf2.zig b/lib/compiler_rt/neghf2.zig
deleted file mode 100644
index 59c7e155b72f714d28d7fa24b0b8860ca853e3ac..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/neghf2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const common = @import("./common.zig");
-
-comptime {
-    @export(&__neghf2, .{ .name = "__neghf2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn __neghf2(a: f16) callconv(.c) f16 {
-    return common.fneg(a);
-}
diff --git a/lib/compiler_rt/negsf2.zig b/lib/compiler_rt/negsf2.zig
deleted file mode 100644
index 065dc3acd10607b31f7ae4f210c6d873761cf1bf..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/negsf2.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const common = @import("./common.zig");
-
-comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_fneg, .{ .name = "__aeabi_fneg", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__negsf2, .{ .name = "__negsf2", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-fn __negsf2(a: f32) callconv(.c) f32 {
-    return common.fneg(a);
-}
-
-fn __aeabi_fneg(a: f32) callconv(.{ .arm_aapcs = .{} }) f32 {
-    return common.fneg(a);
-}
diff --git a/lib/compiler_rt/negsi2_test.zig b/lib/compiler_rt/negsi2_test.zig
index 2584de2136e9f2ebb9691afe5323e071edeaf9f8..0eecd6a728dea30442bfc71e8af98f75d01b7a80 100644
--- a/lib/compiler_rt/negsi2_test.zig
+++ b/lib/compiler_rt/negsi2_test.zig
@@ -1,11 +1,12 @@
 const std = @import("std");
-const neg = @import("negXi2.zig");
 const testing = std.testing;
 
+const compiler_rt = @import("../compiler_rt.zig");
+
 const print = std.debug.print;
 
 fn test__negsi2(a: i32, expected: i32) !void {
-    const result = neg.__negsi2(a);
+    const result = compiler_rt.__negsi2(a);
     try testing.expectEqual(expected, result);
 }
 
diff --git a/lib/compiler_rt/negtf2.zig b/lib/compiler_rt/negtf2.zig
deleted file mode 100644
index 9d981ce2ffb3159d3377a1a9843a551cac5e8e2b..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/negtf2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const common = @import("./common.zig");
-const symbol = @import("../compiler_rt.zig").symbol;
-
-comptime {
-    if (common.want_ppc_abi)
-        symbol(&__negtf2, "__negkf2");
-    symbol(&__negtf2, "__negtf2");
-}
-
-fn __negtf2(a: f128) callconv(.c) f128 {
-    return common.fneg(a);
-}
diff --git a/lib/compiler_rt/negti2_test.zig b/lib/compiler_rt/negti2_test.zig
index d58f9c8f270f236b6184d75ed1278c75e72f6fe7..ea9e917312e0e4fc3251454f2dcff620ba0d8a0e 100644
--- a/lib/compiler_rt/negti2_test.zig
+++ b/lib/compiler_rt/negti2_test.zig
@@ -1,8 +1,10 @@
-const neg = @import("negXi2.zig");
-const testing = @import("std").testing;
+const std = @import("std");
+const testing = std.testing;
+
+const compiler_rt = @import("../compiler_rt.zig");
 
 fn test__negti2(a: i128, expected: i128) !void {
-    const result = neg.__negti2(a);
+    const result = compiler_rt.__negti2(a);
     try testing.expectEqual(expected, result);
 }
 
diff --git a/lib/compiler_rt/negv.zig b/lib/compiler_rt/negv.zig
index 98934b78f424552476ddab4bf819db24bc48b33b..7c67a51c34ab72f9c3f0038024e45ca79413d955 100644
--- a/lib/compiler_rt/negv.zig
+++ b/lib/compiler_rt/negv.zig
@@ -3,12 +3,13 @@
 //! - negvXi4_generic for unoptimized version
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__negvsi2, .{ .name = "__negvsi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__negvdi2, .{ .name = "__negvdi2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__negvti2, .{ .name = "__negvti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__negvsi2, "__negvsi2");
+    symbol(&__negvdi2, "__negvdi2");
+    symbol(&__negvti2, "__negvti2");
 }
 
 pub fn __negvsi2(a: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/negxf2.zig b/lib/compiler_rt/negxf2.zig
deleted file mode 100644
index ea16c8fef215c883559c16d06bf9766c02106fcb..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/negxf2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const common = @import("./common.zig");
-
-comptime {
-    @export(&__negxf2, .{ .name = "__negxf2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn __negxf2(a: f80) callconv(.c) f80 {
-    return common.fneg(a);
-}
diff --git a/lib/compiler_rt/os_version_check.zig b/lib/compiler_rt/os_version_check.zig
index a2dc7f221e769f6fd90d739c59acd3ae7d8ea7df..e575fef9ce553fee90cc9f7cc900689c5804cb20 100644
--- a/lib/compiler_rt/os_version_check.zig
+++ b/lib/compiler_rt/os_version_check.zig
@@ -1,15 +1,16 @@
 const std = @import("std");
 const testing = std.testing;
 const builtin = @import("builtin");
-const common = @import("common.zig");
-const panic = @import("common.zig").panic;
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+const panic = @import("../compiler_rt.zig").panic;
 
 const have_availability_version_check = builtin.os.tag.isDarwin() and
     builtin.os.version_range.semver.min.order(.{ .major = 10, .minor = 15, .patch = 0 }).compare(.gte);
 
 comptime {
     if (have_availability_version_check) {
-        @export(&__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__isPlatformVersionAtLeast, "__isPlatformVersionAtLeast");
     }
 }
 
diff --git a/lib/compiler_rt/powiXf2.zig b/lib/compiler_rt/powiXf2.zig
index 91767818bd71cbe91d78a3454aaa31fe8d22ed68..b2a1e3e6989ba85538243483d14fd92ad0e3158d 100644
--- a/lib/compiler_rt/powiXf2.zig
+++ b/lib/compiler_rt/powiXf2.zig
@@ -3,14 +3,14 @@
 //! Multiplication order (left-to-right or right-to-left) does not matter for
 //! error propagation and this method is optimized for performance, not accuracy.
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     symbol(&__powihf2, "__powihf2");
     symbol(&__powisf2, "__powisf2");
     symbol(&__powidf2, "__powidf2");
-    if (common.want_ppc_abi)
+    if (compiler_rt.want_ppc_abi)
         symbol(&__powitf2, "__powikf2");
     symbol(&__powitf2, "__powitf2");
     symbol(&__powixf2, "__powixf2");
diff --git a/lib/compiler_rt/round.zig b/lib/compiler_rt/round.zig
index b643bfd89fab0a9e277dfd0cecafc54d706595e1..8087fd6e1529fdc42012074257e12e5017de8dae 100644
--- a/lib/compiler_rt/round.zig
+++ b/lib/compiler_rt/round.zig
@@ -10,18 +10,19 @@ const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__roundh, .{ .name = "__roundh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&roundf, .{ .name = "roundf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&round, .{ .name = "round", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__roundx, .{ .name = "__roundx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&roundq, .{ .name = "roundf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__roundh, "__roundh");
+    symbol(&roundf, "roundf");
+    symbol(&round, "round");
+    symbol(&__roundx, "__roundx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&roundq, "roundf128");
     }
-    @export(&roundq, .{ .name = "roundq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&roundl, .{ .name = "roundl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&roundq, "roundq");
+    symbol(&roundl, "roundl");
 }
 
 pub fn __roundh(x: f16) callconv(.c) f16 {
@@ -44,7 +45,7 @@ pub fn roundf(x_: f32) callconv(.c) f32 {
         x = -x;
     }
     if (e < 0x7F - 1) {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(x + f32_toint);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + f32_toint);
         return 0 * @as(f32, @bitCast(u));
     }
 
@@ -79,7 +80,7 @@ pub fn round(x_: f64) callconv(.c) f64 {
         x = -x;
     }
     if (e < 0x3ff - 1) {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(x + f64_toint);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + f64_toint);
         return 0 * @as(f64, @bitCast(u));
     }
 
@@ -119,7 +120,7 @@ pub fn roundq(x_: f128) callconv(.c) f128 {
         x = -x;
     }
     if (e < 0x3FFF - 1) {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(x + f128_toint);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + f128_toint);
         return 0 * @as(f128, @bitCast(u));
     }
 
diff --git a/lib/compiler_rt/shift.zig b/lib/compiler_rt/shift.zig
index 9c75bd3475fb2e4dddd31cee61f44cf46514ac15..425ca2c69cba7c5698ee40dd3c7bdece5a9dbd78 100644
--- a/lib/compiler_rt/shift.zig
+++ b/lib/compiler_rt/shift.zig
@@ -1,33 +1,34 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const Log2Int = std.math.Log2Int;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
     // symbol compatibility with libgcc
-    @export(&__ashlsi3, .{ .name = "__ashlsi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ashrsi3, .{ .name = "__ashrsi3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__lshrsi3, .{ .name = "__lshrsi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__ashlsi3, "__ashlsi3");
+    symbol(&__ashrsi3, "__ashrsi3");
+    symbol(&__lshrsi3, "__lshrsi3");
 
-    @export(&__ashlti3, .{ .name = "__ashlti3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__ashrti3, .{ .name = "__ashrti3", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__lshrti3, .{ .name = "__lshrti3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__ashlti3, "__ashlti3");
+    symbol(&__ashrti3, "__ashrti3");
+    symbol(&__lshrti3, "__lshrti3");
 
-    if (common.want_aeabi) {
-        @export(&__aeabi_llsl, .{ .name = "__aeabi_llsl", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_lasr, .{ .name = "__aeabi_lasr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_llsr, .{ .name = "__aeabi_llsr", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_llsl, "__aeabi_llsl");
+        symbol(&__aeabi_lasr, "__aeabi_lasr");
+        symbol(&__aeabi_llsr, "__aeabi_llsr");
     } else {
-        @export(&__ashldi3, .{ .name = "__ashldi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__ashrdi3, .{ .name = "__ashrdi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__lshrdi3, .{ .name = "__lshrdi3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__ashldi3, "__ashldi3");
+        symbol(&__ashrdi3, "__ashrdi3");
+        symbol(&__lshrdi3, "__lshrdi3");
     }
 }
 
 // Arithmetic shift left: shift in 0 from right to left
 // Precondition: 0 <= b < bits_in_dword
 inline fn ashlXi3(comptime T: type, a: T, b: i32) T {
-    const word_t = common.HalveInt(T, false);
+    const word_t = compiler_rt.HalveInt(T, false);
 
     const input = word_t{ .all = a };
     var output: word_t = undefined;
@@ -49,7 +50,7 @@ inline fn ashlXi3(comptime T: type, a: T, b: i32) T {
 // Arithmetic shift right: shift in 1 from left to right
 // Precondition: 0 <= b < T.bit_count
 inline fn ashrXi3(comptime T: type, a: T, b: i32) T {
-    const word_t = common.HalveInt(T, true);
+    const word_t = compiler_rt.HalveInt(T, true);
 
     const input = word_t{ .all = a };
     var output: word_t = undefined;
@@ -72,7 +73,7 @@ inline fn ashrXi3(comptime T: type, a: T, b: i32) T {
 // Logical shift right: shift in 0 from left to right
 // Precondition: 0 <= b < T.bit_count
 inline fn lshrXi3(comptime T: type, a: T, b: i32) T {
-    const word_t = common.HalveInt(T, false);
+    const word_t = compiler_rt.HalveInt(T, false);
 
     const input = word_t{ .all = a };
     var output: word_t = undefined;
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index ab1775d7ce8f50c420085e0317675802108d7933..ef3709bc1882156614a2b69b64e2643195534d84 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -9,7 +9,7 @@ const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
@@ -20,7 +20,7 @@ comptime {
     symbol(&sinf, "sinf");
     symbol(&sin, "sin");
     symbol(&__sinx, "__sinx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&sinq, "sinf128");
     }
     symbol(&sinq, "sinq");
@@ -46,7 +46,7 @@ pub fn sinf(x: f32) callconv(.c) f32 {
     if (ix <= 0x3f490fda) { // |x| ~<= pi/4
         if (ix < 0x39800000) { // |x| < 2**-12
             // raise inexact if x!=0 and underflow if subnormal
-            if (common.want_float_exceptions) {
+            if (compiler_rt.want_float_exceptions) {
                 if (ix < 0x00800000) {
                     mem.doNotOptimizeAway(x / 0x1p120);
                 } else {
@@ -101,7 +101,7 @@ pub fn sin(x: f64) callconv(.c) f64 {
     if (ix <= 0x3fe921fb) {
         if (ix < 0x3e500000) { // |x| < 2**-26
             // raise inexact if x != 0 and underflow if subnormal
-            if (common.want_float_exceptions) {
+            if (compiler_rt.want_float_exceptions) {
                 if (ix < 0x00100000) {
                     mem.doNotOptimizeAway(x / 0x1p120);
                 } else {
diff --git a/lib/compiler_rt/sincos.zig b/lib/compiler_rt/sincos.zig
index 46fec8ff64c37ee972b998793f29742260709286..6aeb1105e59f7f8433eb631fab27b5c20d3fccd4 100644
--- a/lib/compiler_rt/sincos.zig
+++ b/lib/compiler_rt/sincos.zig
@@ -6,18 +6,19 @@ const mem = std.mem;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__sincosh, .{ .name = "__sincosh", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sincosf, .{ .name = "sincosf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sincos, .{ .name = "sincos", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__sincosx, .{ .name = "__sincosx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&sincosq, .{ .name = "sincosf128", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__sincosh, "__sincosh");
+    symbol(&sincosf, "sincosf");
+    symbol(&sincos, "sincos");
+    symbol(&__sincosx, "__sincosx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&sincosq, "sincosf128");
     }
-    @export(&sincosq, .{ .name = "sincosq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sincosl, .{ .name = "sincosl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sincosq, "sincosq");
+    symbol(&sincosl, "sincosl");
 }
 
 pub fn __sincosh(x: f16, r_sin: *f16, r_cos: *f16) callconv(.c) void {
@@ -44,7 +45,7 @@ pub fn sincosf(x: f32, r_sin: *f32, r_cos: *f32) callconv(.c) void {
         // |x| < 2**-12
         if (ix < 0x39800000) {
             // raise inexact if x!=0 and underflow if subnormal
-            if (common.want_float_exceptions) {
+            if (compiler_rt.want_float_exceptions) {
                 if (ix < 0x00100000) {
                     mem.doNotOptimizeAway(x / 0x1p120);
                 } else {
@@ -138,7 +139,7 @@ pub fn sincos(x: f64, r_sin: *f64, r_cos: *f64) callconv(.c) void {
         // if |x| < 2**-27 * sqrt(2)
         if (ix < 0x3e46a09e) {
             // raise inexact if x != 0 and underflow if subnormal
-            if (common.want_float_exceptions) {
+            if (compiler_rt.want_float_exceptions) {
                 if (ix < 0x00100000) {
                     mem.doNotOptimizeAway(x / 0x1p120);
                 } else {
@@ -242,7 +243,7 @@ inline fn sincos_generic(comptime F: type, x: F, r_sin: *F, r_cos: *F) void {
         if (se < 0x3fff - math.floatFractionalBits(F) - 1) {
             // raise underflow if subnormal
             if (se == 0) {
-                if (common.want_float_exceptions) mem.doNotOptimizeAway(x * 0x1p-120);
+                if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x * 0x1p-120);
             }
             r_sin.* = x;
             // raise inexact if x!=0
diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig
index 870b1ee560ae680fd731107577d0d21f3b948f38..e765414fb0f418ea9f6d1d71e03c4fa73ff36ca9 100644
--- a/lib/compiler_rt/sqrt.zig
+++ b/lib/compiler_rt/sqrt.zig
@@ -9,20 +9,21 @@ const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 const math = std.math;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
-    @export(&__sqrth, .{ .name = "__sqrth", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sqrtf, .{ .name = "sqrtf", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sqrt, .{ .name = "sqrt", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__sqrtx, .{ .name = "__sqrtx", .linkage = common.linkage, .visibility = common.visibility });
-    if (common.want_ppc_abi) {
-        @export(&sqrtq, .{ .name = "sqrtf128", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_sqrt, .{ .name = "_Qp_sqrt", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__sqrth, "__sqrth");
+    symbol(&sqrtf, "sqrtf");
+    symbol(&sqrt, "sqrt");
+    symbol(&__sqrtx, "__sqrtx");
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&sqrtq, "sqrtf128");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_sqrt, "_Qp_sqrt");
     }
-    @export(&sqrtq, .{ .name = "sqrtq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sqrtl, .{ .name = "sqrtl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sqrtq, "sqrtq");
+    symbol(&sqrtl, "sqrtl");
 }
 
 pub fn __sqrth(x: f16) callconv(.c) f16 {
@@ -103,7 +104,7 @@ pub fn sqrtf(x: f32) callconv(.c) f32 {
             return x;
 
         if (ix > @as(u32, @bitCast(std.math.inf(f32))))
-            return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f32);
+            return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f32);
 
         ix = @as(u32, @bitCast(@as(i32, @bitCast(x * 0x1p23)) - (23 << 23)));
     }
@@ -154,7 +155,7 @@ pub fn sqrt(x: f64) callconv(.c) f64 {
         // x < 0x1p-1022 or inf or nan.
         if (ix & 0x7FFF_FFFF_FFFF_FFFF == 0) return x;
         if (ix == 0x7FF0_0000_0000_0000) return x;
-        if (ix > 0x7FF0_0000_0000_0000) return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
+        if (ix > 0x7FF0_0000_0000_0000) return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f64);
         // x is subnormal, normalize it.
         ix = @bitCast(x * 0x1p52);
         top = (ix >> 52) -% 52;
@@ -291,7 +292,7 @@ pub fn __sqrtx(x: f80) callconv(.c) f80 {
         // x < 0x1p-16382 or inf or nan.
         if (ix & 0x7FFF_FFFF_FFFF_FFFF_FFFF == 0) return x;
         if (ix == 0x7FFF_8000_0000_0000_0000) return x;
-        if (ix > 0x7FFF_8000_0000_0000_0000) return if (common.want_float_exceptions) (x - x) / 0.0 else math.nan(f80);
+        if (ix > 0x7FFF_8000_0000_0000_0000) return if (compiler_rt.want_float_exceptions) (x - x) / 0.0 else math.nan(f80);
         // x is subnormal, normalize it.
         ix = @bitCast(x * 0x1p63);
         top = (ix >> 64) -% 63;
diff --git a/lib/compiler_rt/ssp.zig b/lib/compiler_rt/ssp.zig
index 0a138735baeac2746e4179747f9e4635f3c899dd..403652ea1bd3ccbb7982fa861886faf6d6673dfa 100644
--- a/lib/compiler_rt/ssp.zig
+++ b/lib/compiler_rt/ssp.zig
@@ -13,7 +13,8 @@
 //! - __vsprintf_chk
 
 const std = @import("std");
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const builtin = @import("builtin");
 
 extern fn memset(dest: ?[*]u8, c: u8, n: usize) callconv(.c) ?[*]u8;
@@ -21,16 +22,16 @@ extern fn memcpy(noalias dest: ?[*]u8, noalias src: ?[*]const u8, n: usize) call
 extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.c) ?[*]u8;
 
 comptime {
-    @export(&__stack_chk_fail, .{ .name = if (builtin.os.tag == .openbsd) "__stack_smash_handler" else "__stack_chk_fail", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__chk_fail, .{ .name = "__chk_fail", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__stack_chk_guard, .{ .name = "__stack_chk_guard", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__strcpy_chk, .{ .name = "__strcpy_chk", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__strncpy_chk, .{ .name = "__strncpy_chk", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__strcat_chk, .{ .name = "__strcat_chk", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__strncat_chk, .{ .name = "__strncat_chk", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__memcpy_chk, .{ .name = "__memcpy_chk", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__memmove_chk, .{ .name = "__memmove_chk", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__memset_chk, .{ .name = "__memset_chk", .linkage = common.linkage, .visibility = common.visibility });
+    @export(&__stack_chk_fail, .{ .name = if (builtin.os.tag == .openbsd) "__stack_smash_handler" else "__stack_chk_fail", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+    symbol(&__chk_fail, "__chk_fail");
+    symbol(&__stack_chk_guard, "__stack_chk_guard");
+    symbol(&__strcpy_chk, "__strcpy_chk");
+    symbol(&__strncpy_chk, "__strncpy_chk");
+    symbol(&__strcat_chk, "__strcat_chk");
+    symbol(&__strncat_chk, "__strncat_chk");
+    symbol(&__memcpy_chk, "__memcpy_chk");
+    symbol(&__memmove_chk, "__memmove_chk");
+    symbol(&__memset_chk, "__memset_chk");
 }
 
 fn __stack_chk_fail() callconv(.c) noreturn {
diff --git a/lib/compiler_rt/stack_probe.zig b/lib/compiler_rt/stack_probe.zig
index 83e08be0153754724f8e3b08609fcf3b33dbb1c5..5d63c9a42244fae40c1125cba55b16461162fa10 100644
--- a/lib/compiler_rt/stack_probe.zig
+++ b/lib/compiler_rt/stack_probe.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const os_tag = builtin.os.tag;
 const arch = builtin.cpu.arch;
 const abi = builtin.abi;
@@ -9,16 +10,16 @@ comptime {
     if (builtin.os.tag == .windows) {
         // Default stack-probe functions emitted by LLVM
         if (builtin.target.isMinGW()) {
-            @export(&_chkstk, .{ .name = "_alloca", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__chkstk, .{ .name = "__chkstk", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&___chkstk, .{ .name = "__alloca", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&___chkstk, .{ .name = "___chkstk", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__chkstk_ms, .{ .name = "__chkstk_ms", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&___chkstk_ms, .{ .name = "___chkstk_ms", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&_chkstk, "_alloca");
+            symbol(&__chkstk, "__chkstk");
+            symbol(&___chkstk, "__alloca");
+            symbol(&___chkstk, "___chkstk");
+            symbol(&__chkstk_ms, "__chkstk_ms");
+            symbol(&___chkstk_ms, "___chkstk_ms");
         } else if (!builtin.link_libc) {
             // This symbols are otherwise exported by MSVCRT.lib
-            @export(&_chkstk, .{ .name = "_chkstk", .linkage = common.linkage, .visibility = common.visibility });
-            @export(&__chkstk, .{ .name = "__chkstk", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&_chkstk, "_chkstk");
+            symbol(&__chkstk, "__chkstk");
         }
     }
 
@@ -26,7 +27,7 @@ comptime {
         .x86,
         .x86_64,
         => {
-            @export(&zig_probe_stack, .{ .name = "__zig_probe_stack", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&zig_probe_stack, "__zig_probe_stack");
         },
         else => {},
     }
diff --git a/lib/compiler_rt/subdf3.zig b/lib/compiler_rt/subdf3.zig
index 3e7dcc3dd27ae6fd78c3239fc4c6afe02f7f541a..4d00a7f03ae71c4f9bf2ffecbcd1123216dff6b6 100644
--- a/lib/compiler_rt/subdf3.zig
+++ b/lib/compiler_rt/subdf3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const addf3 = @import("./addf3.zig").addf3;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_dsub, "__aeabi_dsub");
     } else {
         symbol(&__subdf3, "__subdf3");
diff --git a/lib/compiler_rt/subhf3.zig b/lib/compiler_rt/subhf3.zig
index e019005ae478c34125c77f4b698f5c6737c8e26c..258401d2957a6d3aafcd0aa02c6de63ca0211952 100644
--- a/lib/compiler_rt/subhf3.zig
+++ b/lib/compiler_rt/subhf3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const addf3 = @import("./addf3.zig").addf3;
 
 comptime {
-    @export(&__subhf3, .{ .name = "__subhf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subhf3, "__subhf3");
 }
 
 fn __subhf3(a: f16, b: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/subsf3.zig b/lib/compiler_rt/subsf3.zig
index 9a1cb559b23af9393a9916d36f67e2987ad74af5..94d47220166aff38656455d3f50fa2b061df3f61 100644
--- a/lib/compiler_rt/subsf3.zig
+++ b/lib/compiler_rt/subsf3.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const addf3 = @import("./addf3.zig").addf3;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_fsub, "__aeabi_fsub");
     } else {
-        @export(&__subsf3, .{ .name = "__subsf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__subsf3, "__subsf3");
     }
 }
 
diff --git a/lib/compiler_rt/subtf3.zig b/lib/compiler_rt/subtf3.zig
index b187eaf579b3894df819e902051c9fe33058d897..617e0e701617030ca231bd3daea6d28a8331d6ac 100644
--- a/lib/compiler_rt/subtf3.zig
+++ b/lib/compiler_rt/subtf3.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const addf3 = @import("./addf3.zig").addf3;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__subtf3, .{ .name = "__subkf3", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_sub, .{ .name = "_Qp_sub", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__subtf3, "__subkf3");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_sub, "_Qp_sub");
     }
-    @export(&__subtf3, .{ .name = "__subtf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subtf3, "__subtf3");
 }
 
 pub fn __subtf3(a: f128, b: f128) callconv(.c) f128 {
diff --git a/lib/compiler_rt/subvsi3.zig b/lib/compiler_rt/subvsi3.zig
index 68f551071c8ff1e123aecf6075fd85f7c649ab40..0744585770237d034f35947a927155efe23eaef9 100644
--- a/lib/compiler_rt/subvsi3.zig
+++ b/lib/compiler_rt/subvsi3.zig
@@ -1,8 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const testing = @import("std").testing;
 
 comptime {
-    @export(&__subvsi3, .{ .name = "__subvsi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subvsi3, "__subvsi3");
 }
 
 pub fn __subvsi3(a: i32, b: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index 17b7f1f1e7c19b453a89c5594040d1fb27d6078e..822ffd4dec0fc21a4fac305ddd995e65ebf8fbc0 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -16,7 +16,7 @@ const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 const arch = builtin.cpu.arch;
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
@@ -24,7 +24,7 @@ comptime {
     symbol(&tanf, "tanf");
     symbol(&tan, "tan");
     symbol(&__tanx, "__tanx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&tanq, "tanf128");
     }
     symbol(&tanq, "tanq");
@@ -50,7 +50,7 @@ pub fn tanf(x: f32) callconv(.c) f32 {
     if (ix <= 0x3f490fda) { // |x| ~<= pi/4
         if (ix < 0x39800000) { // |x| < 2**-12
             // raise inexact if x!=0 and underflow if subnormal
-            if (common.want_float_exceptions) {
+            if (compiler_rt.want_float_exceptions) {
                 if (ix < 0x00800000) {
                     mem.doNotOptimizeAway(x / 0x1p120);
                 } else {
@@ -94,7 +94,7 @@ pub fn tan(x: f64) callconv(.c) f64 {
     if (ix <= 0x3fe921fb) {
         if (ix < 0x3e400000) { // |x| < 2**-27
             // raise inexact if x!=0 and underflow if subnormal
-            if (common.want_float_exceptions) {
+            if (compiler_rt.want_float_exceptions) {
                 if (ix < 0x00100000) {
                     mem.doNotOptimizeAway(x / 0x1p120);
                 } else {
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index 799fbc9fbbdf4f3953987f401870371d1e4ea436..b7846307034b667b5ae631d470689da9a3eb9b98 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -4,23 +4,20 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/truncf.c
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c
 
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
-
 const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 
-const common = @import("common.zig");
-const symbol = @import("../compiler_rt.zig").symbol;
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 
 comptime {
     symbol(&__trunch, "__trunch");
     symbol(&truncf, "truncf");
     symbol(&trunc, "trunc");
     symbol(&__truncx, "__truncx");
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&truncq, "truncf128");
     }
     symbol(&truncq, "truncq");
@@ -48,7 +45,7 @@ pub fn truncf(x: f32) callconv(.c) f32 {
     if (u & m == 0) {
         return x;
     } else {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
         return @bitCast(u & ~m);
     }
 }
@@ -69,7 +66,7 @@ pub fn trunc(x: f64) callconv(.c) f64 {
     if (u & m == 0) {
         return x;
     } else {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
         return @bitCast(u & ~m);
     }
 }
@@ -95,7 +92,7 @@ pub fn truncq(x: f128) callconv(.c) f128 {
     if (u & m == 0) {
         return x;
     } else {
-        if (common.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
+        if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
         return @bitCast(u & ~m);
     }
 }
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
index 43ad7fb20dd5a4b0afbab9846b44be3c94bce1c3..e01e1877633eee7077c64ef42e6cde56a0a17aee 100644
--- a/lib/compiler_rt/truncdfhf2.zig
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -1,15 +1,15 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const truncf = @import("./truncf.zig").truncf;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_d2h, "__aeabi_d2h");
     }
     symbol(&__truncdfhf2, "__truncdfhf2");
 }
 
-pub fn __truncdfhf2(a: f64) callconv(.c) common.F16T(f64) {
+pub fn __truncdfhf2(a: f64) callconv(.c) compiler_rt.F16T(f64) {
     return @bitCast(truncf(f16, f64, a));
 }
 
diff --git a/lib/compiler_rt/truncdfsf2.zig b/lib/compiler_rt/truncdfsf2.zig
index 8d6ed5c3206f963401abb558adcdc9e56aae9e22..f1bada18449130344f213ad0f8272794d38f23bf 100644
--- a/lib/compiler_rt/truncdfsf2.zig
+++ b/lib/compiler_rt/truncdfsf2.zig
@@ -1,11 +1,12 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const truncf = @import("./truncf.zig").truncf;
 
 comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_d2f, "__aeabi_d2f");
     } else {
-        @export(&__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__truncdfsf2, "__truncdfsf2");
     }
 }
 
diff --git a/lib/compiler_rt/truncsfhf2.zig b/lib/compiler_rt/truncsfhf2.zig
index acd5631da8f71e013e2eb55e5bf87ab3a02299cd..e0b2b1e4bf2f15400c568f1c1656c8cb70bc03c8 100644
--- a/lib/compiler_rt/truncsfhf2.zig
+++ b/lib/compiler_rt/truncsfhf2.zig
@@ -1,20 +1,21 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const truncf = @import("./truncf.zig").truncf;
 
 comptime {
-    if (common.gnu_f16_abi) {
-        @export(&__gnu_f2h_ieee, .{ .name = "__gnu_f2h_ieee", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_aeabi) {
-        @export(&__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.gnu_f16_abi) {
+        symbol(&__gnu_f2h_ieee, "__gnu_f2h_ieee");
+    } else if (compiler_rt.want_aeabi) {
+        symbol(&__aeabi_f2h, "__aeabi_f2h");
     }
-    @export(&__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncsfhf2, "__truncsfhf2");
 }
 
-pub fn __truncsfhf2(a: f32) callconv(.c) common.F16T(f32) {
+pub fn __truncsfhf2(a: f32) callconv(.c) compiler_rt.F16T(f32) {
     return @bitCast(truncf(f16, f32, a));
 }
 
-fn __gnu_f2h_ieee(a: f32) callconv(.c) common.F16T(f32) {
+fn __gnu_f2h_ieee(a: f32) callconv(.c) compiler_rt.F16T(f32) {
     return @bitCast(truncf(f16, f32, a));
 }
 
diff --git a/lib/compiler_rt/trunctfdf2.zig b/lib/compiler_rt/trunctfdf2.zig
index 4f569dae675c8e1fa9e394f167388bd79c53d3ff..5396e8715141245c8fe402e7de3f2b0238b6f532 100644
--- a/lib/compiler_rt/trunctfdf2.zig
+++ b/lib/compiler_rt/trunctfdf2.zig
@@ -1,13 +1,14 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const truncf = @import("./truncf.zig").truncf;
 
 comptime {
-    if (common.want_ppc_abi) {
-        @export(&__trunctfdf2, .{ .name = "__trunckfdf2", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtod, .{ .name = "_Qp_qtod", .linkage = common.linkage, .visibility = common.visibility });
+    if (compiler_rt.want_ppc_abi) {
+        symbol(&__trunctfdf2, "__trunckfdf2");
+    } else if (compiler_rt.want_sparc_abi) {
+        symbol(&_Qp_qtod, "_Qp_qtod");
     }
-    @export(&__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunctfdf2, "__trunctfdf2");
 }
 
 pub fn __trunctfdf2(a: f128) callconv(.c) f64 {
diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig
index bd0e7a5dc24806071622438c95f02e8bbc6054a3..46c6e34ec957c36713cbf1c79d5f3fc0c1f34043 100644
--- a/lib/compiler_rt/trunctfhf2.zig
+++ b/lib/compiler_rt/trunctfhf2.zig
@@ -1,4 +1,4 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const truncf = @import("./truncf.zig").truncf;
 
@@ -6,6 +6,6 @@ comptime {
     symbol(&__trunctfhf2, "__trunctfhf2");
 }
 
-pub fn __trunctfhf2(a: f128) callconv(.c) common.F16T(f128) {
+pub fn __trunctfhf2(a: f128) callconv(.c) compiler_rt.F16T(f128) {
     return @bitCast(truncf(f16, f128, a));
 }
diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig
index bab5534bfe08da10814e99e9015b41c02c0fe68e..94dbff6ef9cbe6326893550686379f6dc20bb8a6 100644
--- a/lib/compiler_rt/trunctfsf2.zig
+++ b/lib/compiler_rt/trunctfsf2.zig
@@ -1,11 +1,11 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const truncf = @import("./truncf.zig").truncf;
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_ppc_abi) {
+    if (compiler_rt.want_ppc_abi) {
         symbol(&__trunctfsf2, "__trunckfsf2");
-    } else if (common.want_sparc_abi) {
+    } else if (compiler_rt.want_sparc_abi) {
         symbol(&_Qp_qtos, "_Qp_qtos");
     }
     symbol(&__trunctfsf2, "__trunctfsf2");
diff --git a/lib/compiler_rt/trunctfxf2.zig b/lib/compiler_rt/trunctfxf2.zig
index df0db2393a6277e451df262fedc0a5b4bf48fb1c..dfb9ef80402cda0360a111e436ba1f7c460bbc1f 100644
--- a/lib/compiler_rt/trunctfxf2.zig
+++ b/lib/compiler_rt/trunctfxf2.zig
@@ -1,9 +1,10 @@
 const math = @import("std").math;
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
 
 comptime {
-    @export(&__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunctfxf2, "__trunctfxf2");
 }
 
 pub fn __trunctfxf2(a: f128) callconv(.c) f80 {
diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig
index b6abce58d5eb505e0547e5eebd3f111909565631..4c3e951bfe9b67ff88818e6a89f210851ddfcfb0 100644
--- a/lib/compiler_rt/truncxfhf2.zig
+++ b/lib/compiler_rt/truncxfhf2.zig
@@ -1,4 +1,4 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
 
@@ -6,6 +6,6 @@ comptime {
     symbol(&__truncxfhf2, "__truncxfhf2");
 }
 
-fn __truncxfhf2(a: f80) callconv(.c) common.F16T(f80) {
+fn __truncxfhf2(a: f80) callconv(.c) compiler_rt.F16T(f80) {
     return @bitCast(trunc_f80(f16, a));
 }
diff --git a/lib/compiler_rt/udivmod.zig b/lib/compiler_rt/udivmod.zig
index bf6aaadeae9451edaa7e1ffa0dfc8a74f4aa0877..44165c0a62b9283aed00b3f1bdae93ada8b43b1c 100644
--- a/lib/compiler_rt/udivmod.zig
+++ b/lib/compiler_rt/udivmod.zig
@@ -1,8 +1,98 @@
-const std = @import("std");
 const builtin = @import("builtin");
+
+const std = @import("std");
 const Log2Int = std.math.Log2Int;
-const common = @import("common.zig");
-const HalveInt = common.HalveInt;
+
+const compiler_rt = @import("../compiler_rt.zig");
+const symbol = compiler_rt.symbol;
+const HalveInt = compiler_rt.HalveInt;
+
+comptime {
+    if (compiler_rt.want_windows_v2u64_abi) {
+        symbol(&__umodti3_windows_x86_64, "__umodti3");
+        symbol(&__modti3_windows_x86_64, "__modti3");
+        symbol(&__udivti3_windows_x86_64, "__udivti3");
+        symbol(&__divti3_windows_x86_64, "__divti3");
+        symbol(&__udivmodti4_windows_x86_64, "__udivmodti4");
+    } else {
+        symbol(&__umodti3, "__umodti3");
+        symbol(&__modti3, "__modti3");
+        symbol(&__udivti3, "__udivti3");
+        symbol(&__divti3, "__divti3");
+        symbol(&__udivmodti4, "__udivmodti4");
+    }
+}
+
+const v128 = @Vector(2, u64);
+const v2u64 = @Vector(2, u64);
+
+pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.c) u128 {
+    return udivmod(u128, a, b, maybe_rem);
+}
+
+fn __udivmodti4_windows_x86_64(a: v2u64, b: v2u64, maybe_rem: ?*u128) callconv(.c) v2u64 {
+    return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), maybe_rem));
+}
+
+pub fn __divti3(a: i128, b: i128) callconv(.c) i128 {
+    return div(a, b);
+}
+
+fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.c) v128 {
+    return @bitCast(div(@bitCast(a), @bitCast(b)));
+}
+
+inline fn div(a: i128, b: i128) i128 {
+    const s_a = a >> (128 - 1);
+    const s_b = b >> (128 - 1);
+
+    const an = (a ^ s_a) -% s_a;
+    const bn = (b ^ s_b) -% s_b;
+
+    const r = udivmod(u128, @bitCast(an), @bitCast(bn), null);
+    const s = s_a ^ s_b;
+    return (@as(i128, @bitCast(r)) ^ s) -% s;
+}
+
+pub fn __udivti3(a: u128, b: u128) callconv(.c) u128 {
+    return udivmod(u128, a, b, null);
+}
+
+fn __udivti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
+    return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), null));
+}
+
+pub fn __modti3(a: i128, b: i128) callconv(.c) i128 {
+    return mod(a, b);
+}
+
+fn __modti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
+    return @bitCast(mod(@as(i128, @bitCast(a)), @as(i128, @bitCast(b))));
+}
+
+inline fn mod(a: i128, b: i128) i128 {
+    const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0
+    const s_b = b >> (128 - 1); // s = b < 0 ? -1 : 0
+
+    const an = (a ^ s_a) -% s_a; // negate if s == -1
+    const bn = (b ^ s_b) -% s_b; // negate if s == -1
+
+    var r: u128 = undefined;
+    _ = udivmod(u128, @as(u128, @bitCast(an)), @as(u128, @bitCast(bn)), &r);
+    return (@as(i128, @bitCast(r)) ^ s_a) -% s_a; // negate if s == -1
+}
+
+pub fn __umodti3(a: u128, b: u128) callconv(.c) u128 {
+    var r: u128 = undefined;
+    _ = udivmod(u128, a, b, &r);
+    return r;
+}
+
+fn __umodti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
+    var r: u128 = undefined;
+    _ = udivmod(u128, @bitCast(a), @bitCast(b), &r);
+    return @bitCast(r);
+}
 
 const lo = switch (builtin.cpu.arch.endian()) {
     .big => 1,
@@ -14,7 +104,7 @@ const hi = 1 - lo;
 // Returns U / v_ and sets r = U % v_.
 fn divwide_generic(comptime T: type, _u1: T, _u0: T, v_: T, r: *T) T {
     const HalfT = HalveInt(T, false).HalfT;
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     var v = v_;
 
     const b = @as(T, 1) << (@bitSizeOf(T) / 2);
@@ -70,7 +160,7 @@ fn divwide_generic(comptime T: type, _u1: T, _u0: T, v_: T, r: *T) T {
 }
 
 fn divwide(comptime T: type, _u1: T, _u0: T, v: T, r: *T) T {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     if (T == u64 and builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag != .windows) {
         var rem: T = undefined;
         const quo = asm (
@@ -90,7 +180,7 @@ fn divwide(comptime T: type, _u1: T, _u0: T, v: T, r: *T) T {
 
 // Returns a_ / b_ and sets maybe_rem = a_ % b.
 pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const HalfT = HalveInt(T, false).HalfT;
     const SignedT = std.meta.Int(.signed, @bitSizeOf(T));
 
@@ -147,3 +237,9 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
     }
     return @bitCast(q);
 }
+
+test {
+    _ = @import("modti3_test.zig");
+    _ = @import("divti3_test.zig");
+    _ = @import("udivmodti4_test.zig");
+}
diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig
index fd8cc6717e68b649d16f8a71ec36f7f576f326fa..f037639c72b334d04fa9d195af6f0e3ae6ee71d5 100644
--- a/lib/compiler_rt/udivmodei4.zig
+++ b/lib/compiler_rt/udivmodei4.zig
@@ -5,7 +5,7 @@ const std = @import("std");
 const shr = std.math.shr;
 const shl = std.math.shl;
 
-const common = @import("common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535
@@ -115,7 +115,7 @@ pub fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
 }
 
 pub fn __udivei4(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) callconv(.c) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
     const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size]));
     const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
@@ -124,7 +124,7 @@ pub fn __udivei4(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) ca
 }
 
 pub fn __umodei4(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) callconv(.c) void {
-    @setRuntimeSafety(common.test_safety);
+    @setRuntimeSafety(compiler_rt.test_safety);
     const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
     const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size]));
     const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
diff --git a/lib/compiler_rt/udivmodti4.zig b/lib/compiler_rt/udivmodti4.zig
deleted file mode 100644
index a1b89bb9625b5c221fb454c37511f6cb1fc981aa..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/udivmodti4.zig
+++ /dev/null
@@ -1,26 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const udivmod = @import("udivmod.zig").udivmod;
-const common = @import("common.zig");
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__udivmodti4_windows_x86_64, .{ .name = "__udivmodti4", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__udivmodti4, .{ .name = "__udivmodti4", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.c) u128 {
-    return udivmod(u128, a, b, maybe_rem);
-}
-
-const v2u64 = @Vector(2, u64);
-
-fn __udivmodti4_windows_x86_64(a: v2u64, b: v2u64, maybe_rem: ?*u128) callconv(.c) v2u64 {
-    return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), maybe_rem));
-}
-
-test {
-    _ = @import("udivmodti4_test.zig");
-}
diff --git a/lib/compiler_rt/udivmodti4_test.zig b/lib/compiler_rt/udivmodti4_test.zig
index 5e172c29f88649bc4826d3c6e5e013c4897f50f4..fc457990e69642a87678cf1772fc8c920e8e6206 100644
--- a/lib/compiler_rt/udivmodti4_test.zig
+++ b/lib/compiler_rt/udivmodti4_test.zig
@@ -1,6 +1,6 @@
 // Disable formatting to avoid unnecessary source repository bloat.
 // zig fmt: off
-const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;
+const __udivmodti4 = @import("udivmod.zig").__udivmodti4;
 const testing = @import("std").testing;
 
 fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) !void {
diff --git a/lib/compiler_rt/udivti3.zig b/lib/compiler_rt/udivti3.zig
deleted file mode 100644
index a579d81e47dff972a53973e8276df9b28fede533..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/udivti3.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const udivmod = @import("udivmod.zig").udivmod;
-const common = @import("common.zig");
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__udivti3_windows_x86_64, .{ .name = "__udivti3", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__udivti3, .{ .name = "__udivti3", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __udivti3(a: u128, b: u128) callconv(.c) u128 {
-    return udivmod(u128, a, b, null);
-}
-
-const v2u64 = @Vector(2, u64);
-
-fn __udivti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
-    return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), null));
-}
diff --git a/lib/compiler_rt/umodti3.zig b/lib/compiler_rt/umodti3.zig
deleted file mode 100644
index 63cfcc2c25367aac11c205181494c2b84ee7a8af..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/umodti3.zig
+++ /dev/null
@@ -1,26 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const udivmod = @import("udivmod.zig").udivmod;
-const common = @import("common.zig");
-
-comptime {
-    if (common.want_windows_v2u64_abi) {
-        @export(&__umodti3_windows_x86_64, .{ .name = "__umodti3", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__umodti3, .{ .name = "__umodti3", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __umodti3(a: u128, b: u128) callconv(.c) u128 {
-    var r: u128 = undefined;
-    _ = udivmod(u128, a, b, &r);
-    return r;
-}
-
-const v2u64 = @Vector(2, u64);
-
-fn __umodti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
-    var r: u128 = undefined;
-    _ = udivmod(u128, @bitCast(a), @bitCast(b), &r);
-    return @bitCast(r);
-}
diff --git a/lib/compiler_rt/unorddf2.zig b/lib/compiler_rt/unorddf2.zig
index 634f14398df9661beaab7cdfe061008d4828bb6a..90da7451992ab5f8b003e5e2f85f93947f932197 100644
--- a/lib/compiler_rt/unorddf2.zig
+++ b/lib/compiler_rt/unorddf2.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const compiler_rt = @import("../compiler_rt.zig");
 const comparef = @import("./comparef.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    if (common.want_aeabi) {
+    if (compiler_rt.want_aeabi) {
         symbol(&__aeabi_dcmpun, "__aeabi_dcmpun");
     } else {
         symbol(&__unorddf2, "__unorddf2");
diff --git a/lib/compiler_rt/unordhf2.zig b/lib/compiler_rt/unordhf2.zig
deleted file mode 100644
index 4fcffd1a1d1cca24f075b363f62370b938000b70..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/unordhf2.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const common = @import("./common.zig");
-const comparef = @import("./comparef.zig");
-
-comptime {
-    @export(&__unordhf2, .{ .name = "__unordhf2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-pub fn __unordhf2(a: f16, b: f16) callconv(.c) i32 {
-    return comparef.unordcmp(f16, a, b);
-}
diff --git a/lib/compiler_rt/unordsf2.zig b/lib/compiler_rt/unordsf2.zig
deleted file mode 100644
index 56bfb94028d8e6623b4ca7cd141f7d81b9809f85..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/unordsf2.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const common = @import("./common.zig");
-const comparef = @import("./comparef.zig");
-
-comptime {
-    if (common.want_aeabi) {
-        @export(&__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = common.linkage, .visibility = common.visibility });
-    } else {
-        @export(&__unordsf2, .{ .name = "__unordsf2", .linkage = common.linkage, .visibility = common.visibility });
-    }
-}
-
-pub fn __unordsf2(a: f32, b: f32) callconv(.c) i32 {
-    return comparef.unordcmp(f32, a, b);
-}
-
-fn __aeabi_fcmpun(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 {
-    return comparef.unordcmp(f32, a, b);
-}
diff --git a/lib/compiler_rt/unordtf2.zig b/lib/compiler_rt/unordtf2.zig
deleted file mode 100644
index 22e90acaaed05f16447edb08287d5122f73749af..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/unordtf2.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const common = @import("./common.zig");
-const comparef = @import("./comparef.zig");
-
-comptime {
-    if (common.want_ppc_abi) {
-        @export(&__unordtf2, .{ .name = "__unordkf2", .linkage = common.linkage, .visibility = common.visibility });
-    } else if (common.want_sparc_abi) {
-        // These exports are handled in cmptf2.zig because unordered comparisons
-        // are based on calling _Qp_cmp.
-    }
-    @export(&__unordtf2, .{ .name = "__unordtf2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn __unordtf2(a: f128, b: f128) callconv(.c) i32 {
-    return comparef.unordcmp(f128, a, b);
-}
diff --git a/lib/compiler_rt/unordxf2.zig b/lib/compiler_rt/unordxf2.zig
deleted file mode 100644
index 2ebf5f413cc6ccfa26fd4df0a00e5064262b0edc..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/unordxf2.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const common = @import("./common.zig");
-const comparef = @import("./comparef.zig");
-
-comptime {
-    @export(&__unordxf2, .{ .name = "__unordxf2", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-pub fn __unordxf2(a: f80, b: f80) callconv(.c) i32 {
-    return comparef.unordcmp(f80, a, b);
-}
-- 
2.54.0


From 2372c68ae82db4b5e8730eb62e5cfb23f9381e59 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 9 Feb 2026 20:11:05 -0800
Subject: [PATCH 252/499] cmake: remove compiler rt source listings

---
 CMakeLists.txt | 175 -------------------------------------------------
 1 file changed, 175 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 38dbd6ca6afae4f08df1cac61913794890e393de..8317566b4455d453b8f3d542de0293181912d6fd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -205,181 +205,6 @@ set(ZIG_CPP_SOURCES
 set(ZIG_STAGE2_SOURCES
     "${ZIG_CONFIG_ZIG_OUT}"
     lib/compiler_rt.zig
-    lib/compiler_rt/absv.zig
-    lib/compiler_rt/absvdi2.zig
-    lib/compiler_rt/absvsi2.zig
-    lib/compiler_rt/absvti2.zig
-    lib/compiler_rt/adddf3.zig
-    lib/compiler_rt/addf3.zig
-    lib/compiler_rt/addsf3.zig
-    lib/compiler_rt/addtf3.zig
-    lib/compiler_rt/addvsi3.zig
-    lib/compiler_rt/addvdi3.zig
-    lib/compiler_rt/addxf3.zig
-    lib/compiler_rt/arm.zig
-    lib/compiler_rt/atomics.zig
-    lib/compiler_rt/aulldiv.zig
-    lib/compiler_rt/aullrem.zig
-    lib/compiler_rt/bswap.zig
-    lib/compiler_rt/clear_cache.zig
-    lib/compiler_rt/cmp.zig
-    lib/compiler_rt/cmpdf2.zig
-    lib/compiler_rt/cmpsf2.zig
-    lib/compiler_rt/cmptf2.zig
-    lib/compiler_rt/cmpxf2.zig
-    lib/compiler_rt/common.zig
-    lib/compiler_rt/comparef.zig
-    lib/compiler_rt/cos.zig
-    lib/compiler_rt/count0bits.zig
-    lib/compiler_rt/divdf3.zig
-    lib/compiler_rt/divsf3.zig
-    lib/compiler_rt/divtf3.zig
-    lib/compiler_rt/divti3.zig
-    lib/compiler_rt/divxf3.zig
-    lib/compiler_rt/emutls.zig
-    lib/compiler_rt/exp.zig
-    lib/compiler_rt/exp2.zig
-    lib/compiler_rt/extenddftf2.zig
-    lib/compiler_rt/extenddfxf2.zig
-    lib/compiler_rt/extendf.zig
-    lib/compiler_rt/extendhfsf2.zig
-    lib/compiler_rt/extendhftf2.zig
-    lib/compiler_rt/extendhfxf2.zig
-    lib/compiler_rt/extendsfdf2.zig
-    lib/compiler_rt/extendsftf2.zig
-    lib/compiler_rt/extendsfxf2.zig
-    lib/compiler_rt/extendxftf2.zig
-    lib/compiler_rt/fabs.zig
-    lib/compiler_rt/fixdfdi.zig
-    lib/compiler_rt/fixdfsi.zig
-    lib/compiler_rt/fixdfti.zig
-    lib/compiler_rt/fixhfdi.zig
-    lib/compiler_rt/fixhfsi.zig
-    lib/compiler_rt/fixhfti.zig
-    lib/compiler_rt/fixsfdi.zig
-    lib/compiler_rt/fixsfsi.zig
-    lib/compiler_rt/fixsfti.zig
-    lib/compiler_rt/fixtfdi.zig
-    lib/compiler_rt/fixtfsi.zig
-    lib/compiler_rt/fixtfti.zig
-    lib/compiler_rt/fixunsdfdi.zig
-    lib/compiler_rt/fixunsdfsi.zig
-    lib/compiler_rt/fixunsdfti.zig
-    lib/compiler_rt/fixunshfdi.zig
-    lib/compiler_rt/fixunshfsi.zig
-    lib/compiler_rt/fixunshfti.zig
-    lib/compiler_rt/fixunssfdi.zig
-    lib/compiler_rt/fixunssfsi.zig
-    lib/compiler_rt/fixunssfti.zig
-    lib/compiler_rt/fixunstfdi.zig
-    lib/compiler_rt/fixunstfsi.zig
-    lib/compiler_rt/fixunstfti.zig
-    lib/compiler_rt/fixunsxfdi.zig
-    lib/compiler_rt/fixunsxfsi.zig
-    lib/compiler_rt/fixunsxfti.zig
-    lib/compiler_rt/fixxfdi.zig
-    lib/compiler_rt/fixxfsi.zig
-    lib/compiler_rt/fixxfti.zig
-    lib/compiler_rt/float_from_int.zig
-    lib/compiler_rt/floatdidf.zig
-    lib/compiler_rt/floatdihf.zig
-    lib/compiler_rt/floatdisf.zig
-    lib/compiler_rt/floatditf.zig
-    lib/compiler_rt/floatdixf.zig
-    lib/compiler_rt/floatsidf.zig
-    lib/compiler_rt/floatsihf.zig
-    lib/compiler_rt/floatsisf.zig
-    lib/compiler_rt/floatsitf.zig
-    lib/compiler_rt/floatsixf.zig
-    lib/compiler_rt/floattidf.zig
-    lib/compiler_rt/floattihf.zig
-    lib/compiler_rt/floattisf.zig
-    lib/compiler_rt/floattitf.zig
-    lib/compiler_rt/floattixf.zig
-    lib/compiler_rt/floatundidf.zig
-    lib/compiler_rt/floatundihf.zig
-    lib/compiler_rt/floatundisf.zig
-    lib/compiler_rt/floatunditf.zig
-    lib/compiler_rt/floatundixf.zig
-    lib/compiler_rt/floatunsidf.zig
-    lib/compiler_rt/floatunsihf.zig
-    lib/compiler_rt/floatunsisf.zig
-    lib/compiler_rt/floatunsitf.zig
-    lib/compiler_rt/floatunsixf.zig
-    lib/compiler_rt/floatuntidf.zig
-    lib/compiler_rt/floatuntihf.zig
-    lib/compiler_rt/floatuntisf.zig
-    lib/compiler_rt/floatuntitf.zig
-    lib/compiler_rt/floatuntixf.zig
-    lib/compiler_rt/floor_ceil.zig
-    lib/compiler_rt/fma.zig
-    lib/compiler_rt/fmax.zig
-    lib/compiler_rt/fmin.zig
-    lib/compiler_rt/fmod.zig
-    lib/compiler_rt/gedf2.zig
-    lib/compiler_rt/gesf2.zig
-    lib/compiler_rt/getf2.zig
-    lib/compiler_rt/gexf2.zig
-    lib/compiler_rt/int.zig
-    lib/compiler_rt/int_from_float.zig
-    lib/compiler_rt/log.zig
-    lib/compiler_rt/log10.zig
-    lib/compiler_rt/log2.zig
-    lib/compiler_rt/modti3.zig
-    lib/compiler_rt/mulXi3.zig
-    lib/compiler_rt/muldf3.zig
-    lib/compiler_rt/mulf3.zig
-    lib/compiler_rt/mulo.zig
-    lib/compiler_rt/mulsf3.zig
-    lib/compiler_rt/multf3.zig
-    lib/compiler_rt/mulvsi3.zig
-    lib/compiler_rt/mulxf3.zig
-    lib/compiler_rt/negXi2.zig
-    lib/compiler_rt/negdf2.zig
-    lib/compiler_rt/negsf2.zig
-    lib/compiler_rt/negtf2.zig
-    lib/compiler_rt/negv.zig
-    lib/compiler_rt/negxf2.zig
-    lib/compiler_rt/os_version_check.zig
-    lib/compiler_rt/parity.zig
-    lib/compiler_rt/popcount.zig
-    lib/compiler_rt/rem_pio2.zig
-    lib/compiler_rt/rem_pio2_large.zig
-    lib/compiler_rt/rem_pio2f.zig
-    lib/compiler_rt/round.zig
-    lib/compiler_rt/shift.zig
-    lib/compiler_rt/sin.zig
-    lib/compiler_rt/sincos.zig
-    lib/compiler_rt/sqrt.zig
-    lib/compiler_rt/stack_probe.zig
-    lib/compiler_rt/subdf3.zig
-    lib/compiler_rt/subsf3.zig
-    lib/compiler_rt/subtf3.zig
-    lib/compiler_rt/subvdi3.zig
-    lib/compiler_rt/subvsi3.zig
-    lib/compiler_rt/subxf3.zig
-    lib/compiler_rt/tan.zig
-    lib/compiler_rt/trig.zig
-    lib/compiler_rt/trunc.zig
-    lib/compiler_rt/truncdfhf2.zig
-    lib/compiler_rt/truncdfsf2.zig
-    lib/compiler_rt/truncf.zig
-    lib/compiler_rt/truncsfhf2.zig
-    lib/compiler_rt/trunctfdf2.zig
-    lib/compiler_rt/trunctfhf2.zig
-    lib/compiler_rt/trunctfsf2.zig
-    lib/compiler_rt/trunctfxf2.zig
-    lib/compiler_rt/truncxfdf2.zig
-    lib/compiler_rt/truncxfhf2.zig
-    lib/compiler_rt/truncxfsf2.zig
-    lib/compiler_rt/udivmod.zig
-    lib/compiler_rt/udivmodei4.zig
-    lib/compiler_rt/udivmodti4.zig
-    lib/compiler_rt/udivti3.zig
-    lib/compiler_rt/umodti3.zig
-    lib/compiler_rt/unorddf2.zig
-    lib/compiler_rt/unordsf2.zig
-    lib/compiler_rt/unordtf2.zig
     lib/std/BitStack.zig
     lib/std/Build.zig
     lib/std/Build/Cache.zig
-- 
2.54.0


From e314dadb015a913a2cdc12298986e9181305d8db Mon Sep 17 00:00:00 2001
From: Khitiara <robotbrainify@gmail.com>
Date: Mon, 2 Feb 2026 12:39:32 -0500
Subject: [PATCH 253/499] Allow overriding std.Io at a namespace level.

This should only be used when the fundamental types break down, e.g. on freestanding or when adding support for a non-posix OS, where std.Io.File.Handle is set to void.
---
 lib/std/std.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/std.zig b/lib/std/std.zig
index d563cdfae7aac1003fb7d91472cd6653f78a5cee..7a796b25d086272407c2e729b2ceae2d7e7c236b 100644
--- a/lib/std/std.zig
+++ b/lib/std/std.zig
@@ -20,7 +20,7 @@ pub const EnumMap = enums.EnumMap;
 pub const EnumSet = enums.EnumSet;
 pub const HashMap = hash_map.HashMap;
 pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
-pub const Io = @import("Io.zig");
+pub const Io = if (@hasDecl(root, "std_options_Io")) root.std_options_Io else @import("Io.zig");
 pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;
 pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;
 pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;
-- 
2.54.0


From 7369008d8ca94fe48d9408d03851a4a17f7e1b73 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Tue, 10 Feb 2026 11:05:35 -0500
Subject: [PATCH 254/499] Io.IoUring: implement some thread pool options and
 other cleanup

---
 lib/std/Io/IoUring.zig  | 1137 +++++++++++++++++++++++----------------
 lib/std/Io/Threaded.zig |    7 +-
 2 files changed, 666 insertions(+), 478 deletions(-)

diff --git a/lib/std/Io/IoUring.zig b/lib/std/Io/IoUring.zig
index ccf8408840d2f09e21dbdf585713eeed2c5e34fa..e4b5bc0fe534596425112db5c6aae5f9c33eb624 100644
--- a/lib/std/Io/IoUring.zig
+++ b/lib/std/Io/IoUring.zig
@@ -59,7 +59,9 @@ backing_allocator: Allocator,
 main_fiber_buffer: [
     std.mem.alignForward(usize, @sizeOf(Fiber), @alignOf(Completion)) + @sizeOf(Completion)
 ]u8 align(@max(@alignOf(Fiber), @alignOf(Completion))),
+log2_ring_entries: u4,
 threads: Thread.List,
+sync_limit: ?Io.Semaphore,
 
 stderr_mutex: Io.Mutex,
 stderr_writer: File.Writer = .{
@@ -84,10 +86,9 @@ csprng: Csprng,
 /// Empirically saw glibc complain about 256KB.
 const idle_stack_size = 512 * 1024;
 
-const max_idle_search = 4;
-const max_steal_ready_search = 4;
-
-const io_uring_entries = 64;
+const max_idle_search = 1;
+const max_steal_ready_search = 2;
+const max_steal_free_search = 4;
 
 const Thread = struct {
     required_align: void align(4),
@@ -95,9 +96,11 @@ const Thread = struct {
     idle_context: Context,
     current_context: *Context,
     ready_queue: ?*Fiber,
+    free_queue: ?*Fiber,
     io_uring: IoUring,
     idle_search_index: u32,
     steal_ready_search_index: u32,
+    steal_free_search_index: u32,
     name_arena: if (tracy.enable) std.heap.ArenaAllocator.State else struct {},
     csprng: Csprng,
 
@@ -107,6 +110,15 @@ const Thread = struct {
         return self.?;
     }
 
+    fn deinit(thread: *Thread, gpa: Allocator) void {
+        var next_fiber = thread.free_queue;
+        while (next_fiber) |free_fiber| {
+            next_fiber = free_fiber.status.free_next;
+            gpa.free(free_fiber.allocatedSlice());
+        }
+        thread.io_uring.deinit();
+    }
+
     fn currentFiber(thread: *Thread) *Fiber {
         assert(thread.current_context != &thread.idle_context);
         return @fieldParentPtr("context", thread.current_context);
@@ -144,6 +156,7 @@ const Fiber = struct {
     status: union(enum) {
         queue_next: ?*Fiber,
         awaiting_group: Group,
+        free_next: ?*Fiber,
     },
     cancel_status: CancelStatus,
     cancel_protection: CancelProtection,
@@ -235,7 +248,7 @@ const Fiber = struct {
         }
     };
 
-    const finished: ?*Fiber = @ptrFromInt(@alignOf(Thread));
+    const finished: ?*Fiber = @ptrFromInt(@alignOf(Fiber));
 
     const max_result_align: Alignment = .@"16";
     const max_result_size = max_result_align.forward(512);
@@ -259,13 +272,49 @@ const Fiber = struct {
     }
 
     fn create(ev: *Evented) error{OutOfMemory}!*Fiber {
+        const thread: *Thread = .current();
+        if (@atomicRmw(?*Fiber, &thread.free_queue, .Xchg, finished, .acquire)) |free_fiber| {
+            assert(free_fiber != finished);
+            @atomicStore(?*Fiber, &thread.free_queue, free_fiber.status.free_next, .release);
+            return free_fiber;
+        }
+        const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
+        for (0..@min(max_steal_free_search, active_threads)) |_| {
+            defer thread.steal_free_search_index += 1;
+            if (thread.steal_free_search_index == active_threads) thread.steal_free_search_index = 0;
+            const steal_free_search_thread =
+                &ev.threads.allocated[0..active_threads][thread.steal_free_search_index];
+            if (steal_free_search_thread == thread) continue;
+            const free_fiber =
+                @atomicLoad(?*Fiber, &steal_free_search_thread.free_queue, .monotonic) orelse continue;
+            if (free_fiber == finished) continue;
+            if (@cmpxchgWeak(
+                ?*Fiber,
+                &steal_free_search_thread.free_queue,
+                free_fiber,
+                null,
+                .acquire,
+                .monotonic,
+            )) |_| continue;
+            @atomicStore(?*Fiber, &thread.free_queue, free_fiber.status.free_next, .release);
+            return free_fiber;
+        }
+        @atomicStore(?*Fiber, &thread.free_queue, null, .monotonic);
         return @ptrCast(try ev.allocator().alignedAlloc(u8, .of(Fiber), allocation_size));
     }
 
-    fn destroy(fiber: *Fiber, gpa: std.mem.Allocator) void {
-        log.debug("destroying {*}", .{fiber});
+    fn destroy(fiber: *Fiber) void {
+        const thread: *Thread = .current();
         assert(fiber.status.queue_next == null);
-        gpa.free(fiber.allocatedSlice());
+        fiber.status = .{ .free_next = @atomicLoad(?*Fiber, &thread.free_queue, .acquire) };
+        while (true) fiber.status.free_next = @cmpxchgWeak(
+            ?*Fiber,
+            &thread.free_queue,
+            fiber.status.free_next,
+            fiber,
+            .acq_rel,
+            .acquire,
+        ) orelse break;
     }
 
     fn allocatedSlice(f: *Fiber) []align(@alignOf(Fiber)) u8 {
@@ -416,6 +465,62 @@ const CancelRegion = struct {
     fn errno(cancel_region: *const CancelRegion) linux.E {
         return cancel_region.completion().errno();
     }
+
+    const Sync = struct {
+        cancel_region: CancelRegion,
+        fn init(ev: *Evented) Io.Cancelable!Sync {
+            if (ev.sync_limit) |*sync_limit| try sync_limit.wait(ev.io());
+            return .{ .cancel_region = .init() };
+        }
+        fn initBlocked(ev: *Evented) Sync {
+            if (ev.sync_limit) |*sync_limit| sync_limit.waitUncancelable(ev.io());
+            return .{ .cancel_region = .initBlocked() };
+        }
+        fn deinit(sync: *Sync, ev: *Evented) void {
+            sync.cancel_region.deinit();
+            if (ev.sync_limit) |*sync_limit| sync_limit.post(ev.io());
+        }
+
+        const Maybe = union(enum) {
+            cancel_region: CancelRegion,
+            sync: Sync,
+
+            fn deinit(maybe: *Maybe, ev: *Evented) void {
+                switch (maybe.*) {
+                    .cancel_region => |*cancel_region| cancel_region.deinit(),
+                    .sync => |*sync| sync.deinit(ev),
+                }
+            }
+
+            fn enterSync(maybe: *Maybe, ev: *Evented) Io.Cancelable!*Sync {
+                switch (maybe.*) {
+                    .cancel_region => |cancel_region| {
+                        if (ev.sync_limit) |*sync_limit| try sync_limit.wait(ev.io());
+                        maybe.* = .{ .sync = .{ .cancel_region = cancel_region } };
+                    },
+                    .sync => {},
+                }
+                return &maybe.sync;
+            }
+
+            fn leaveSync(maybe: *Maybe, ev: *Evented) void {
+                switch (maybe.*) {
+                    .cancel_region => {},
+                    .sync => |sync| {
+                        if (ev.sync_limit) |*sync_limit| sync_limit.post(ev.io());
+                        maybe.* = .{ .cancel_region = sync.cancel_region };
+                    },
+                }
+            }
+
+            fn cancelRegion(maybe: *Maybe) *CancelRegion {
+                return switch (maybe.*) {
+                    .cancel_region => |*cancel_region| cancel_region,
+                    .sync => |*sync| &sync.cancel_region,
+                };
+            }
+        };
+    };
 };
 
 const CachedFd = struct {
@@ -685,7 +790,7 @@ fn fileMemoryMapSetLength(
     new_len: usize,
 ) File.MemoryMap.SetLengthError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
+
     const page_size = std.heap.pageSize();
     const alignment: Alignment = .fromByteUnits(page_size);
     const page_align = std.heap.page_size_min;
@@ -695,12 +800,12 @@ fn fileMemoryMapSetLength(
         mm.memory.len = new_len;
         return;
     }
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
     const flags: linux.MREMAP = .{ .MAYMOVE = true };
     const addr_hint: ?[*]const u8 = null;
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     const new_memory = while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         const rc = linux.mremap(old_memory.ptr, old_memory.len, new_len, flags, addr_hint);
         switch (linux.errno(rc)) {
             .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len],
@@ -730,17 +835,28 @@ fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePosi
 pub const InitOptions = struct {
     backing_allocator_needs_mutex: bool = true,
 
+    /// Maximum thread pool size (excluding the main thread).
+    /// Defaults to one less than the number of logical CPU cores.
+    thread_limit: ?usize = null,
+    /// Maximum number of threads that may perform synchronous syscalls.
+    sync_limit: Io.Limit = .unlimited,
+
+    log2_ring_entries: u4 = 3,
+
     /// Affects the following operations:
     /// * `processExecutablePath` on OpenBSD and Haiku.
     argv0: Argv0 = .empty,
     /// Affects the following operations:
     /// * `fileIsTty`
     /// * `processSpawn`, `processSpawnPath`, `processReplace`, `processReplacePath`
-    environ: process.Environ,
+    environ: process.Environ = .empty,
 };
 
 pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !void {
-    const threads_size = @max(std.Thread.getCpuCount() catch 1, 1) * @sizeOf(Thread);
+    const threads_size = @sizeOf(Thread) * if (options.thread_limit) |thread_limit|
+        1 + thread_limit
+    else
+        @max(std.Thread.getCpuCount() catch 1, 1);
     const idle_stack_end_offset =
         std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.page_size_max);
     const allocated_slice = try backing_allocator.alignedAlloc(u8, .of(Thread), idle_stack_end_offset);
@@ -750,11 +866,13 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
         .backing_allocator_mutex = .init,
         .backing_allocator = backing_allocator,
         .main_fiber_buffer = undefined,
+        .log2_ring_entries = options.log2_ring_entries,
         .threads = .{
             .allocated = @ptrCast(allocated_slice[0..threads_size]),
             .reserved = 1,
             .active = 1,
         },
+        .sync_limit = if (options.sync_limit.toInt()) |sync_limit| .{ .permits = sync_limit } else null,
 
         .stderr_mutex = .init,
         .stderr_writer = .{
@@ -809,18 +927,18 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
         },
         .current_context = &main_fiber.context,
         .ready_queue = null,
+        .free_queue = null,
         .io_uring = try .init(
-            io_uring_entries,
+            @as(u16, 1) << ev.log2_ring_entries,
             linux.IORING_SETUP_COOP_TASKRUN | linux.IORING_SETUP_SINGLE_ISSUER,
         ),
         .idle_search_index = 1,
         .steal_ready_search_index = 1,
+        .steal_free_search_index = 1,
         .name_arena = .{},
         .csprng = .uninitialized,
     };
     errdefer main_thread.io_uring.deinit();
-    log.debug("created main idle {*}", .{&main_thread.idle_context});
-    log.debug("created main {*}", .{main_fiber});
     if (tracy.enable) tracy.fiberEnter(main_fiber.name);
 }
 
@@ -831,7 +949,7 @@ pub fn deinit(ev: *Evented) void {
         assert(ready_fiber == null or ready_fiber == Fiber.finished); // pending async
     }
     ev.yield(null, .exit);
-    ev.threads.allocated[0].io_uring.deinit();
+    ev.threads.allocated[0].deinit(ev.allocator());
     ev.null_fd.close();
     ev.random_fd.close();
     const allocated_ptr: [*]align(@alignOf(Thread)) u8 = @ptrCast(@alignCast(ev.threads.allocated.ptr));
@@ -848,6 +966,7 @@ pub fn deinit(ev: *Evented) void {
 
 fn findReadyFiber(ev: *Evented, thread: *Thread) ?*Fiber {
     if (@atomicRmw(?*Fiber, &thread.ready_queue, .Xchg, Fiber.finished, .acquire)) |ready_fiber| {
+        assert(ready_fiber != Fiber.finished);
         @atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.status.queue_next, .release);
         ready_fiber.status.queue_next = null;
         return ready_fiber;
@@ -860,7 +979,7 @@ fn findReadyFiber(ev: *Evented, thread: *Thread) ?*Fiber {
             &ev.threads.allocated[0..active_threads][thread.steal_ready_search_index];
         if (steal_ready_search_thread == thread) continue;
         const ready_fiber =
-            @atomicLoad(?*Fiber, &steal_ready_search_thread.ready_queue, .acquire) orelse continue;
+            @atomicLoad(?*Fiber, &steal_ready_search_thread.ready_queue, .monotonic) orelse continue;
         if (ready_fiber == Fiber.finished) continue;
         if (@cmpxchgWeak(
             ?*Fiber,
@@ -892,19 +1011,10 @@ fn yield(ev: *Evented, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.P
         },
         .pending_task = pending_task,
     };
-    log.debug("switching from {*} to {*}", .{ message.contexts.prev, message.contexts.ready });
     contextSwitch(&message).handle(ev);
 }
 
 fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
-    {
-        var fiber = ready_queue.head;
-        while (true) {
-            log.debug("scheduling {*}", .{fiber});
-            fiber = fiber.status.queue_next orelse break;
-        }
-        assert(fiber == ready_queue.tail);
-    }
     // shared fields of previous `Thread` must be initialized before later ones are marked as active
     const new_thread_index = @atomicLoad(u32, &ev.threads.active, .acquire);
     for (0..@min(max_idle_search, new_thread_index)) |_| {
@@ -963,7 +1073,8 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
             .idle_context = undefined,
             .current_context = &new_thread.idle_context,
             .ready_queue = ready_queue.head,
-            .io_uring = IoUring.init_params(io_uring_entries, &params) catch |err| {
+            .free_queue = null,
+            .io_uring = IoUring.init_params(@as(u16, 1) << ev.log2_ring_entries, &params) catch |err| {
                 @atomicStore(u32, &ev.threads.reserved, new_thread_index, .release);
                 // no more access to `thread` after giving up reservation
                 log.warn("unable to create worker thread due to io_uring init failure: {s}", .{
@@ -973,6 +1084,7 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
             },
             .idle_search_index = 0,
             .steal_ready_search_index = 0,
+            .steal_free_search_index = 0,
             .name_arena = .{},
             .csprng = .uninitialized,
         };
@@ -991,14 +1103,14 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
         return false;
     }
     // nobody wanted it, so just queue it on ourselves
-    while (@cmpxchgWeak(
+    while (true) ready_queue.tail.status.queue_next = @cmpxchgWeak(
         ?*Fiber,
         &thread.ready_queue,
         ready_queue.tail.status.queue_next,
         ready_queue.head,
         .acq_rel,
         .acquire,
-    )) |old_head| ready_queue.tail.status.queue_next = old_head;
+    ) orelse break;
     return false;
 }
 
@@ -1015,8 +1127,7 @@ fn mainIdle(
 fn threadEntry(ev: *Evented, index: u32) void {
     const thread: *Thread = &ev.threads.allocated[index];
     Thread.self = thread;
-    defer thread.io_uring.deinit();
-    log.debug("created thread idle {*}", .{&thread.idle_context});
+    defer thread.deinit(ev.allocator());
     switch (linux.errno(linux.io_uring_register(thread.io_uring.fd, .REGISTER_ENABLE_RINGS, null, 0))) {
         .SUCCESS => ev.idle(thread),
         else => |err| @panic(@tagName(err)),
@@ -1054,103 +1165,107 @@ fn idle(ev: *Evented, thread: *Thread) void {
             error.SignalInterrupt => {},
             else => |e| @panic(@errorName(e)),
         };
-        var cqes_buffer: [io_uring_entries]linux.io_uring_cqe = undefined;
         var maybe_ready_queue: ?Fiber.Queue = null;
-        for (cqes_buffer[0 .. thread.io_uring.copy_cqes(&cqes_buffer, 0) catch |err| switch (err) {
-            error.SignalInterrupt => 0,
-            else => |e| @panic(@errorName(e)),
-        }]) |cqe| if (cqe.flags & linux.IORING_CQE_F_SKIP == 0) switch (@as(
-            Completion.UserData,
-            @enumFromInt(cqe.user_data),
-        )) {
-            .unused => unreachable, // bad submission queued?
-            .wakeup => {},
-            .futex_wake => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
-                .SUCCESS => recoverableOsBugDetected(), // success is skipped
-                .INVAL => {}, // invalid futex_wait() on ptr done elsewhere
-                .INTR, .CANCELED => recoverableOsBugDetected(), // `Completion.UserData.futex_wake` is not cancelable
-                .FAULT => {}, // pointer became invalid while doing the wake
-                else => recoverableOsBugDetected(), // deadlock due to operating system bug
-            },
-            .cleanup => @panic("failed to notify other threads that we are exiting"),
-            .exit => {
-                assert(maybe_ready_fiber == null and maybe_ready_queue == null); // pending async
-                return;
-            },
-            _ => if (@as(?*Fiber, ready_fiber: switch (@as(u2, @truncate(cqe.user_data))) {
-                0b00 => {
-                    const ready_fiber: *Fiber = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
-                    ready_fiber.resultPointer(Completion).* = .{
-                        .result = cqe.res,
-                        .flags = cqe.flags,
-                    };
-                    break :ready_fiber ready_fiber;
+        while (true) {
+            var cqes_buffer: [1 << 8]linux.io_uring_cqe = undefined;
+            const cqes = cqes_buffer[0 .. thread.io_uring.copy_cqes(&cqes_buffer, 0) catch |err| switch (err) {
+                error.SignalInterrupt => 0,
+                else => |e| @panic(@errorName(e)),
+            }];
+            if (cqes.len == 0) break;
+            for (cqes) |cqe| if (cqe.flags & linux.IORING_CQE_F_SKIP == 0) switch (@as(
+                Completion.UserData,
+                @enumFromInt(cqe.user_data),
+            )) {
+                .unused => unreachable, // bad submission queued?
+                .wakeup => {},
+                .futex_wake => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
+                    .SUCCESS => recoverableOsBugDetected(), // success is skipped
+                    .INVAL => {}, // invalid futex_wait() on ptr done elsewhere
+                    .INTR, .CANCELED => recoverableOsBugDetected(), // `Completion.UserData.futex_wake` is not cancelable
+                    .FAULT => {}, // pointer became invalid while doing the wake
+                    else => recoverableOsBugDetected(), // deadlock due to operating system bug
                 },
-                0b01 => {
-                    thread.enqueue().* = .{
-                        .opcode = .ASYNC_CANCEL,
-                        .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
-                        .ioprio = 0,
-                        .fd = 0,
-                        .off = 0,
-                        .addr = cqe.user_data & ~@as(usize, 0b11),
-                        .len = 0,
-                        .rw_flags = 0,
-                        .user_data = @intFromEnum(Completion.UserData.wakeup),
-                        .buf_index = 0,
-                        .personality = 0,
-                        .splice_fd_in = 0,
-                        .addr3 = 0,
-                        .resv = 0,
-                    };
-                    break :ready_fiber null;
+                .cleanup => @panic("failed to notify other threads that we are exiting"),
+                .exit => {
+                    assert(maybe_ready_fiber == null and maybe_ready_queue == null); // pending async
+                    return;
                 },
-                0b10 => {
-                    const context: *Io.Operation.Storage.Pending.Context =
-                        @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
-                    const batch: *Io.Batch = @ptrFromInt(context[0]);
-                    var next: usize = 0b00;
-                    context[0..3].* = .{ next, @as(u32, @bitCast(cqe.res)), cqe.flags };
-                    while (true) {
-                        next = @cmpxchgWeak(
-                            usize,
-                            @as(*usize, @ptrCast(&batch.context)),
-                            next,
-                            cqe.user_data,
-                            .release,
-                            .acquire,
-                        ) orelse break;
-                        context[0] = next;
-                    }
-                    break :ready_fiber switch (@as(u2, @truncate(next))) {
-                        0b00, 0b01 => @ptrFromInt(next & ~@as(usize, 0b11)),
-                        0b10, 0b11 => null,
-                    };
-                },
-                0b11 => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
-                    .SUCCESS => unreachable, // no event count specified
-                    .TIME => {
-                        const context: *usize = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
-                        const fiber = @atomicRmw(usize, context, .Add, 0b01, .acquire);
-                        break :ready_fiber switch (@as(u2, @truncate(fiber))) {
-                            else => unreachable, // timeout completed multiple times
-                            0b00 => @ptrFromInt(fiber & ~@as(usize, 0b11)),
-                            0b10 => null,
+                _ => if (@as(?*Fiber, ready_fiber: switch (@as(u2, @truncate(cqe.user_data))) {
+                    0b00 => {
+                        const ready_fiber: *Fiber = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
+                        ready_fiber.resultPointer(Completion).* = .{
+                            .result = cqe.res,
+                            .flags = cqe.flags,
+                        };
+                        break :ready_fiber ready_fiber;
+                    },
+                    0b01 => {
+                        thread.enqueue().* = .{
+                            .opcode = .ASYNC_CANCEL,
+                            .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+                            .ioprio = 0,
+                            .fd = 0,
+                            .off = 0,
+                            .addr = cqe.user_data & ~@as(usize, 0b11),
+                            .len = 0,
+                            .rw_flags = 0,
+                            .user_data = @intFromEnum(Completion.UserData.wakeup),
+                            .buf_index = 0,
+                            .personality = 0,
+                            .splice_fd_in = 0,
+                            .addr3 = 0,
+                            .resv = 0,
                         };
+                        break :ready_fiber null;
+                    },
+                    0b10 => {
+                        const context: *Io.Operation.Storage.Pending.Context =
+                            @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
+                        const batch: *Io.Batch = @ptrFromInt(context[0]);
+                        var next: usize = 0b00;
+                        context[0..3].* = .{ next, @as(u32, @bitCast(cqe.res)), cqe.flags };
+                        while (true) {
+                            next = @cmpxchgWeak(
+                                usize,
+                                @as(*usize, @ptrCast(&batch.context)),
+                                next,
+                                cqe.user_data,
+                                .release,
+                                .acquire,
+                            ) orelse break;
+                            context[0] = next;
+                        }
+                        break :ready_fiber switch (@as(u2, @truncate(next))) {
+                            0b00, 0b01 => @ptrFromInt(next & ~@as(usize, 0b11)),
+                            0b10, 0b11 => null,
+                        };
+                    },
+                    0b11 => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
+                        .SUCCESS => unreachable, // no event count specified
+                        .TIME => {
+                            const context: *usize = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
+                            const fiber = @atomicRmw(usize, context, .Add, 0b01, .acquire);
+                            break :ready_fiber switch (@as(u2, @truncate(fiber))) {
+                                else => unreachable, // timeout completed multiple times
+                                0b00 => @ptrFromInt(fiber & ~@as(usize, 0b11)),
+                                0b10 => null,
+                            };
+                        },
+                        .CANCELED => null, // user data may have been invalidated
+                        else => |err| unexpectedErrno(err) catch null,
                     },
-                    .CANCELED => null, // user data may have been invalidated
-                    else => |err| unexpectedErrno(err) catch null,
+                })) |ready_fiber| {
+                    assert(ready_fiber.status.queue_next == null);
+                    if (maybe_ready_fiber == null) {
+                        maybe_ready_fiber = ready_fiber;
+                    } else if (maybe_ready_queue) |*ready_queue| {
+                        ready_queue.tail.status.queue_next = ready_fiber;
+                        ready_queue.tail = ready_fiber;
+                    } else maybe_ready_queue = .{ .head = ready_fiber, .tail = ready_fiber };
                 },
-            })) |ready_fiber| {
-                assert(ready_fiber.status.queue_next == null);
-                if (maybe_ready_fiber == null) {
-                    maybe_ready_fiber = ready_fiber;
-                } else if (maybe_ready_queue) |*ready_queue| {
-                    ready_queue.tail.status.queue_next = ready_fiber;
-                    ready_queue.tail = ready_fiber;
-                } else maybe_ready_queue = .{ .head = ready_fiber, .tail = ready_fiber };
-            },
-        };
+            };
+        }
         if (maybe_ready_queue) |ready_queue| _ = ev.schedule(thread, ready_queue);
     }
 }
@@ -1220,8 +1335,7 @@ const SwitchMessage = struct {
             },
             .destroy => {
                 const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
-                fiber.destroy(ev.backing_allocator);
-                ev.backing_allocator_mutex.unlock(ev.io());
+                fiber.destroy();
             },
             .exit => for (
                 ev.threads.allocated[0..@atomicLoad(u32, &ev.threads.active, .acquire)],
@@ -1295,7 +1409,6 @@ inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage {
               .x15 = true,
               .x16 = true,
               .x17 = true,
-              .x18 = true,
               .x19 = true,
               .x20 = true,
               .x21 = true,
@@ -1497,7 +1610,6 @@ const AsyncClosure = struct {
     ) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
         message.handle(closure.ev);
         const fiber = closure.fiber;
-        log.debug("{*} performing async", .{fiber});
         closure.start(closure.contextPointer(), fiber.resultBytes(closure.result_align));
         closure.ev.yield(
             if (@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel)) |awaiter|
@@ -1542,7 +1654,6 @@ fn concurrent(
     const fiber = Fiber.create(ev) catch |err| switch (err) {
         error.OutOfMemory => return error.ConcurrencyUnavailable,
     };
-    log.debug("allocated {*}", .{fiber});
 
     const closure: *AsyncClosure = .fromFiber(fiber);
     fiber.* = .{
@@ -1608,7 +1719,7 @@ fn await(
         assert(awaiter == fiber); // spurious wakeup
     }
     @memcpy(result, future_fiber.resultBytes(result_alignment));
-    future_fiber.destroy(ev.allocator());
+    future_fiber.destroy();
 }
 
 fn cancel(
@@ -1866,7 +1977,6 @@ const Group = struct {
         ) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn {
             message.handle(closure.ev);
             assert(closure.fiber.status.queue_next == null);
-            log.debug("{*} performing group async", .{closure.fiber});
             const result = closure.start(closure.contextPointer());
             const ev = closure.ev;
             const group = closure.group;
@@ -1877,9 +1987,7 @@ const Group = struct {
             } else |err| switch (err) {
                 error.Canceled => assert(cancel_acknowledged), // group task returned `error.Canceled` but was never canceled
             }
-            const awaiter = group.removeFiber(ev, fiber);
-            ev.backing_allocator_mutex.lockUncancelable(ev.io());
-            ev.yield(awaiter, .destroy);
+            ev.yield(group.removeFiber(ev, fiber), .destroy);
             unreachable; // switched to dead fiber
         }
     };
@@ -1930,7 +2038,6 @@ fn groupConcurrent(
     const fiber = Fiber.create(ev) catch |err| switch (err) {
         error.OutOfMemory => return error.ConcurrencyUnavailable,
     };
-    log.debug("allocated {*}", .{fiber});
 
     const closure: *Group.AsyncClosure = .fromFiber(fiber);
     fiber.* = .{
@@ -2080,7 +2187,6 @@ fn futexWait(
     timeout: Io.Timeout,
 ) Io.Cancelable!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    if (builtin.single_threaded) unreachable; // Deadlock.
     const timespec: ?linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = timespec: switch (timeout) {
         .none => .{
             null,
@@ -2163,7 +2269,6 @@ fn futexWait(
 
 fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    if (builtin.single_threaded) unreachable; // Deadlock.
     var cancel_region: CancelRegion = .initBlocked();
     defer cancel_region.deinit();
     const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
@@ -2199,7 +2304,6 @@ fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32)
 fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     _ = ev;
-    if (builtin.single_threaded) unreachable; // Nothing to wake up.
     const thread: *Thread = .current();
     thread.enqueue().* = .{
         .opcode = .FUTEX_WAKE,
@@ -2222,24 +2326,43 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
 
 fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    switch (operation) {
-        .file_read_streaming => |o| return .{
-            .file_read_streaming = ev.fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    return switch (operation) {
+        .file_read_streaming => |o| .{
+            .file_read_streaming = ev.fileReadStreaming(
+                &maybe_sync.cancel_region,
+                o.file,
+                o.data,
+            ) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 else => |e| e,
             },
         },
-        .file_write_streaming => |o| return .{
-            .file_write_streaming = ev.fileWriteStreaming(o.file, o.header, o.data, o.splat) catch |err| switch (err) {
+        .file_write_streaming => |o| .{
+            .file_write_streaming = ev.fileWriteStreaming(
+                &maybe_sync.cancel_region,
+                o.file,
+                o.header,
+                o.data,
+                o.splat,
+            ) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 else => |e| e,
             },
         },
-        .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
-    }
+        .device_io_control => |o| .{
+            .device_io_control = try ev.deviceIoControl(try maybe_sync.enterSync(ev), o),
+        },
+    };
 }
 
-fn fileReadStreaming(ev: *Evented, file: File, data: []const []u8) File.Reader.Error!usize {
+fn fileReadStreaming(
+    ev: *Evented,
+    cancel_region: *CancelRegion,
+    file: File,
+    data: []const []u8,
+) File.ReadStreamingError!usize {
     var iovecs_buffer: [max_iovecs_len]iovec = undefined;
     var i: usize = 0;
     for (data) |buf| {
@@ -2252,13 +2375,13 @@ fn fileReadStreaming(ev: *Evented, file: File, data: []const []u8) File.Reader.E
     const dest = iovecs_buffer[0..i];
     assert(dest[0].len > 0);
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    return ev.preadv(&cancel_region, file.handle, dest, null);
+    const n = try ev.preadv(cancel_region, file.handle, dest, null);
+    return if (n == 0) error.EndOfStream else n;
 }
 
 fn fileWriteStreaming(
     ev: *Evented,
+    cancel_region: *CancelRegion,
     file: File,
     header: []const u8,
     data: []const []const u8,
@@ -2294,17 +2417,17 @@ fn fileWriteStreaming(
             },
         },
     };
-
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    return ev.pwritev(&cancel_region, file.handle, iovecs[0..iovlen], null);
+    return ev.pwritev(cancel_region, file.handle, iovecs[0..iovlen], null);
 }
 
-fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!i32 {
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+fn deviceIoControl(
+    ev: *Evented,
+    sync: *CancelRegion.Sync,
+    o: Io.Operation.DeviceIoControl,
+) Io.Cancelable!i32 {
+    _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         const rc = linux.ioctl(o.file.handle, @bitCast(o.code), @intFromPtr(o.arg));
         switch (linux.errno(rc)) {
             .SUCCESS => return @bitCast(@as(u32, @truncate(rc))),
@@ -2316,12 +2439,13 @@ fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!i32 {
 
 fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    batchDrainSubmitted(batch, &cancel_region, false) catch |err| switch (err) {
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    ev.batchDrainSubmitted(&maybe_sync, batch, false) catch |err| switch (err) {
         error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
         else => |e| return e,
     };
+    maybe_sync.leaveSync(ev);
     while (true) {
         batchDrainReady(batch) catch |err| switch (err) {
             error.Timeout => unreachable, // no timeout
@@ -2337,9 +2461,10 @@ fn batchAwaitConcurrent(
     timeout: Io.Timeout,
 ) Io.Batch.AwaitConcurrentError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    try batchDrainSubmitted(batch, &cancel_region, true);
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    try ev.batchDrainSubmitted(&maybe_sync, batch, true);
+    maybe_sync.leaveSync(ev);
     const timespec: linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = while (true) {
         batchDrainReady(batch) catch |err| switch (err) {
             error.Timeout => unreachable, // no timeout
@@ -2372,7 +2497,7 @@ fn batchAwaitConcurrent(
         }
     };
     {
-        const thread = try cancel_region.awaitIoUring();
+        const thread = try maybe_sync.cancel_region.awaitIoUring();
         thread.enqueue().* = .{
             .opcode = .TIMEOUT,
             .flags = 0,
@@ -2401,7 +2526,7 @@ fn batchAwaitConcurrent(
         };
         if (batch.completed.head == .none) continue;
     }
-    const thread = try cancel_region.awaitIoUring();
+    const thread = try maybe_sync.cancel_region.awaitIoUring();
     thread.enqueue().* = .{
         .opcode = .TIMEOUT_REMOVE,
         .flags = 0,
@@ -2411,7 +2536,7 @@ fn batchAwaitConcurrent(
         .addr = @intFromPtr(&batch.context) | 0b11,
         .len = 0,
         .rw_flags = 0,
-        .user_data = @intFromPtr(cancel_region.fiber),
+        .user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
         .buf_index = 0,
         .personality = 0,
         .splice_fd_in = 0,
@@ -2419,7 +2544,7 @@ fn batchAwaitConcurrent(
         .resv = 0,
     };
     ev.yield(null, .nothing);
-    switch (cancel_region.errno()) {
+    switch (maybe_sync.cancel_region.errno()) {
         .SUCCESS => return,
         .BUSY, .NOENT => {},
         else => |err| unexpectedErrno(err) catch {},
@@ -2434,22 +2559,23 @@ fn batchAwaitConcurrent(
 
 /// If `concurrency` is false, `error.ConcurrencyUnavailable` is unreachable.
 fn batchDrainSubmitted(
+    ev: *Evented,
+    maybe_sync: *CancelRegion.Sync.Maybe,
     batch: *Io.Batch,
-    cancel_region: *CancelRegion,
     concurrency: bool,
 ) (Io.ConcurrentError || Io.Cancelable)!void {
     var index = batch.submitted.head;
     if (index == .none) return;
     errdefer batch.submitted.head = index;
-    const thread = try cancel_region.awaitIoUring();
+    const thread = try maybe_sync.cancelRegion().awaitIoUring();
     while (index != .none) {
         const storage = &batch.storage[index.toIndex()];
         const next_index = storage.submission.node.next;
-        if (@as(?Io.Operation.Result, operation: switch (storage.submission.operation) {
+        if (@as(?Io.Operation.Result, result: switch (storage.submission.operation) {
             .file_read_streaming => |o| {
                 const buffer = for (o.data) |buffer| {
                     if (buffer.len != 0) break buffer;
-                } else break :operation .{ .file_read_streaming = 0 };
+                } else break :result .{ .file_read_streaming = 0 };
                 const fd = o.file.handle;
                 storage.* = .{ .pending = .{
                     .node = .{ .prev = batch.pending.tail, .next = .none },
@@ -2472,7 +2598,7 @@ fn batchDrainSubmitted(
                     .addr3 = 0,
                     .resv = 0,
                 };
-                break :operation null;
+                break :result null;
             },
             .file_write_streaming => |o| {
                 const buffer = buffer: {
@@ -2481,7 +2607,7 @@ fn batchDrainSubmitted(
                         if (buffer.len != 0) break :buffer buffer;
                     }
                     if (o.splat > 0) break :buffer o.data[o.data.len - 1];
-                    break :operation .{ .file_write_streaming = 0 };
+                    break :result .{ .file_write_streaming = 0 };
                 };
                 const fd = o.file.handle;
                 storage.* = .{ .pending = .{
@@ -2505,12 +2631,12 @@ fn batchDrainSubmitted(
                     .addr3 = 0,
                     .resv = 0,
                 };
-                break :operation null;
+                break :result null;
             },
             .device_io_control => |o| if (concurrency)
                 return error.ConcurrencyUnavailable
             else
-                .{ .device_io_control = try deviceIoControl(&o) },
+                .{ .device_io_control = try ev.deviceIoControl(try maybe_sync.enterSync(ev), o) },
         })) |result| {
             switch (batch.completed.tail) {
                 .none => batch.completed.head = index,
@@ -2838,7 +2964,6 @@ fn dirAccess(
     options: Dir.AccessOptions,
 ) Dir.AccessError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
 
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
@@ -2849,10 +2974,10 @@ fn dirAccess(
         @as(u32, if (options.execute) linux.X_OK else 0);
     const flags: u32 = if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW;
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.faccessat(dir.handle, sub_path_posix, mode, flags))) {
             .SUCCESS => return,
             .INTR => continue,
@@ -2885,21 +3010,21 @@ fn dirCreateFile(
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    const fd = try ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    const fd = try ev.openat(&maybe_sync.cancel_region, dir.handle, sub_path_posix, .{
         .ACCMODE = if (flags.read) .RDWR else .WRONLY,
         .CREAT = true,
         .TRUNC = flags.truncate,
         .EXCL = flags.exclusive,
         .CLOEXEC = true,
     }, flags.permissions.toMode());
-    errdefer ev.close(fd);
+    errdefer ev.close(maybe_sync.cancelRegion(), fd);
 
     switch (flags.lock) {
         .none => {},
         .shared, .exclusive => try ev.flock(
-            &cancel_region,
+            try maybe_sync.enterSync(ev),
             fd,
             flags.lock,
             if (flags.lock_nonblocking) .nonblocking else .blocking,
@@ -3069,9 +3194,9 @@ fn dirOpenFile(
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    const fd = try ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    const fd = try ev.openat(&maybe_sync.cancel_region, dir.handle, sub_path_posix, .{
         .ACCMODE = switch (flags.mode) {
             .read_only => .RDONLY,
             .write_only => .WRONLY,
@@ -3082,11 +3207,11 @@ fn dirOpenFile(
         .CLOEXEC = true,
         .PATH = flags.path_only,
     }, 0);
-    errdefer ev.close(fd);
+    errdefer ev.close(maybe_sync.cancelRegion(), fd);
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
-            const s = ev.stat(&cancel_region, fd) catch |err| switch (err) {
+            const s = ev.stat(&maybe_sync.cancel_region, fd) catch |err| switch (err) {
                 // The directory-ness is either unknown or unknowable
                 error.Streaming => break :is_dir false,
                 else => |e| return e,
@@ -3099,7 +3224,7 @@ fn dirOpenFile(
     switch (flags.lock) {
         .none => {},
         .shared, .exclusive => try ev.flock(
-            &cancel_region,
+            try maybe_sync.enterSync(ev),
             fd,
             flags.lock,
             if (flags.lock_nonblocking) .nonblocking else .blocking,
@@ -3111,7 +3236,9 @@ fn dirOpenFile(
 
 fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    for (dirs) |dir| ev.close(dir.handle);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    for (dirs) |dir| ev.close(&cancel_region, dir.handle);
 }
 
 fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
@@ -3122,17 +3249,17 @@ fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Read
             // Refill the buffer, unless we've already created references to
             // buffered data.
             if (buffer_index != 0) break;
-            var cancel_region: CancelRegion = .init();
-            defer cancel_region.deinit();
+            var sync: CancelRegion.Sync = try .init(ev);
+            defer sync.deinit(ev);
             if (dr.state == .reset) {
-                ev.lseek(&cancel_region, dr.dir.handle, 0, linux.SEEK.SET) catch |err| switch (err) {
+                ev.lseek(&sync, dr.dir.handle, 0, linux.SEEK.SET) catch |err| switch (err) {
                     error.Unseekable => return error.Unexpected,
                     else => |e| return e,
                 };
                 dr.state = .reading;
             }
             const n = while (true) {
-                try cancel_region.await(.nothing);
+                try sync.cancel_region.await(.nothing);
                 const rc = linux.getdents64(dr.dir.handle, dr.buffer.ptr, dr.buffer.len);
                 switch (linux.errno(rc)) {
                     .SUCCESS => break rc,
@@ -3203,9 +3330,9 @@ fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Read
 
 fn dirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    return ev.realPath(&cancel_region, dir.handle, out_buffer);
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    return ev.realPath(&sync, dir.handle, out_buffer);
 }
 
 fn dirRealPathFile(
@@ -3219,9 +3346,9 @@ fn dirRealPathFile(
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    const fd = ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    const fd = ev.openat(&maybe_sync.cancel_region, dir.handle, sub_path_posix, .{
         .CLOEXEC = true,
         .PATH = true,
     }, 0) catch |err| switch (err) {
@@ -3229,8 +3356,8 @@ fn dirRealPathFile(
         error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
         else => |e| return e,
     };
-    defer ev.close(fd);
-    return ev.realPath(&cancel_region, fd, out_buffer);
+    defer ev.close(maybe_sync.cancelRegion(), fd);
+    return ev.realPath(try maybe_sync.enterSync(ev), fd, out_buffer);
 }
 
 fn dirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
@@ -3458,15 +3585,14 @@ fn dirReadLink(
     buffer: []u8,
 ) Dir.ReadLinkError!usize {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
 
     var sub_path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &sub_path_buffer);
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         const rc = linux.readlinkat(dir.handle, sub_path_posix, buffer.ptr, buffer.len);
         switch (linux.errno(rc)) {
             .SUCCESS => {
@@ -3496,10 +3622,10 @@ fn dirSetOwner(
     group: ?File.Gid,
 ) Dir.SetOwnerError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     try ev.fchownat(
-        &cancel_region,
+        &sync,
         dir.handle,
         "",
         owner orelse std.math.maxInt(linux.uid_t),
@@ -3519,10 +3645,10 @@ fn dirSetFileOwner(
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     try ev.fchownat(
-        &cancel_region,
+        &sync,
         dir.handle,
         sub_path_posix,
         owner orelse std.math.maxInt(linux.uid_t),
@@ -3537,10 +3663,10 @@ fn dirSetPermissions(
     permissions: Dir.Permissions,
 ) Dir.SetPermissionsError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     ev.fchmodat(
-        &cancel_region,
+        &sync,
         dir.handle,
         "",
         permissions.toMode(),
@@ -3565,10 +3691,10 @@ fn dirSetFilePermissions(
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     try ev.fchmodat(
-        &cancel_region,
+        &sync,
         dir.handle,
         sub_path_posix,
         permissions.toMode(),
@@ -3585,8 +3711,8 @@ fn dirSetTimestamps(
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     var path_buffer: [PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var cancel_region: CancelRegion.Sync = try .init(ev);
+    defer cancel_region.deinit(ev);
     try ev.utimensat(
         &cancel_region,
         dir.handle,
@@ -3680,7 +3806,9 @@ fn fileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
 
 fn fileClose(userdata: ?*anyopaque, files: []const File) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    for (files) |file| ev.close(file.handle);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    for (files) |file| ev.close(&cancel_region, file.handle);
 }
 
 fn fileWritePositional(
@@ -3807,16 +3935,16 @@ fn fileReadPositional(
 
 fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    try ev.lseek(&cancel_region, file.handle, @bitCast(offset), linux.SEEK.CUR);
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    try ev.lseek(&sync, file.handle, @bitCast(offset), linux.SEEK.CUR);
 }
 
 fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    try ev.lseek(&cancel_region, file.handle, offset, linux.SEEK.SET);
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    try ev.lseek(&sync, file.handle, offset, linux.SEEK.SET);
 }
 
 fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
@@ -3858,14 +3986,12 @@ fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
 
 fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         var wsz: winsize = undefined;
-        const fd: usize = @bitCast(@as(isize, file.handle));
-        const rc = linux.syscall3(.ioctl, fd, linux.T.IOCGWINSZ, @intFromPtr(&wsz));
+        const rc = linux.ioctl(file.handle, linux.T.IOCGWINSZ, @intFromPtr(&wsz));
         switch (linux.errno(rc)) {
             .SUCCESS => return true,
             .INTR => continue,
@@ -3923,10 +4049,10 @@ fn fileSetOwner(
     group: ?File.Gid,
 ) File.SetOwnerError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     try ev.fchownat(
-        &cancel_region,
+        &sync,
         file.handle,
         "",
         owner orelse std.math.maxInt(linux.uid_t),
@@ -3941,10 +4067,10 @@ fn fileSetPermissions(
     permissions: File.Permissions,
 ) File.SetPermissionsError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     ev.fchmodat(
-        &cancel_region,
+        &sync,
         file.handle,
         "",
         permissions.toMode(),
@@ -3965,10 +4091,10 @@ fn fileSetTimestamps(
     options: File.SetTimestampsOptions,
 ) File.SetTimestampsError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     try ev.utimensat(
-        &cancel_region,
+        &sync,
         file.handle,
         "",
         if (options.modify_timestamp != .now or options.access_timestamp != .now) &.{
@@ -3981,9 +4107,9 @@ fn fileSetTimestamps(
 
 fn fileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    ev.flock(&cancel_region, file.handle, lock, .blocking) catch |err| switch (err) {
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    ev.flock(&sync, file.handle, lock, .blocking) catch |err| switch (err) {
         error.WouldBlock => unreachable, // blocking
         else => |e| return e,
     };
@@ -3991,9 +4117,9 @@ fn fileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!v
 
 fn fileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    ev.flock(&cancel_region, file.handle, lock, switch (lock) {
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    ev.flock(&sync, file.handle, lock, switch (lock) {
         .none => .blocking,
         .shared, .exclusive => .nonblocking,
     }) catch |err| switch (err) {
@@ -4005,9 +4131,9 @@ fn fileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockErro
 
 fn fileUnlock(userdata: ?*anyopaque, file: File) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .initBlocked();
-    defer cancel_region.deinit();
-    ev.flock(&cancel_region, file.handle, .none, .blocking) catch |err| switch (err) {
+    var sync: CancelRegion.Sync = .initBlocked(ev);
+    defer sync.deinit(ev);
+    ev.flock(&sync, file.handle, .none, .blocking) catch |err| switch (err) {
         error.Canceled => unreachable, // blocked
         error.WouldBlock => unreachable, // blocking
         error.SystemResources => return recoverableOsBugDetected(), // Resource deallocation.
@@ -4018,9 +4144,9 @@ fn fileUnlock(userdata: ?*anyopaque, file: File) void {
 
 fn fileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    ev.flock(&cancel_region, file.handle, .shared, .nonblocking) catch |err| switch (err) {
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    ev.flock(&sync, file.handle, .shared, .nonblocking) catch |err| switch (err) {
         error.WouldBlock => return errnoBug(.AGAIN), // File was not locked in exclusive mode.
         error.SystemResources => return errnoBug(.NOLCK), // Lock already obtained.
         error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Lock already obtained.
@@ -4030,9 +4156,9 @@ fn fileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!
 
 fn fileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    return ev.realPath(&cancel_region, file.handle, out_buffer);
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    return ev.realPath(&sync, file.handle, out_buffer);
 }
 
 fn fileHardLink(
@@ -4065,7 +4191,7 @@ fn fileMemoryMapCreate(
     options: File.MemoryMap.CreateOptions,
 ) File.MemoryMap.CreateError!File.MemoryMap {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
+
     const prot: linux.PROT = .{
         .READ = options.protection.read,
         .WRITE = options.protection.write,
@@ -4078,10 +4204,10 @@ fn fileMemoryMapCreate(
 
     const page_align = std.heap.page_size_min;
 
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     const contents = while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         const casted_offset = std.math.cast(i64, options.offset) orelse return error.Unseekable;
         const rc = linux.mmap(null, options.len, prot, flags, file.handle, casted_offset);
         switch (linux.errno(rc)) {
@@ -4189,11 +4315,10 @@ fn unlockStderr(userdata: ?*anyopaque) void {
 
 fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.getcwd(buffer.ptr, buffer.len))) {
             .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
             .INTR => continue,
@@ -4208,48 +4333,19 @@ fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathEr
 
 fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
     if (dir.handle == linux.AT.FDCWD) return;
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    while (true) {
-        try cancel_region.await(.nothing);
-        switch (linux.errno(linux.fchdir(dir.handle))) {
-            .SUCCESS => return,
-            .INTR => continue,
-            .ACCES => return error.AccessDenied,
-            .NOTDIR => return error.NotDir,
-            .IO => return error.FileSystem,
-            .BADF => |err| return errnoBug(err),
-            else => |err| return unexpectedErrno(err),
-        }
-    }
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    return ev.fchdir(&sync, dir.handle);
 }
 
 fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) ChdirError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
     var path_buffer: [PATH_MAX]u8 = undefined;
     const dir_path_posix = try pathToPosix(dir_path, &path_buffer);
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    while (true) {
-        try cancel_region.await(.nothing);
-        switch (linux.errno(linux.chdir(dir_path_posix))) {
-            .SUCCESS => return,
-            .INTR => continue,
-            .ACCES => return error.AccessDenied,
-            .IO => return error.FileSystem,
-            .LOOP => return error.SymLinkLoop,
-            .NAMETOOLONG => return error.NameTooLong,
-            .NOENT => return error.FileNotFound,
-            .NOMEM => return error.SystemResources,
-            .NOTDIR => return error.NotDir,
-            .ILSEQ => return error.BadPathName,
-            .FAULT => |err| return errnoBug(err),
-            else => |err| return unexpectedErrno(err),
-        }
-    }
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    return ev.chdir(&sync, dir_path_posix);
 }
 
 fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError {
@@ -4275,7 +4371,9 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
         });
     };
 
-    return execv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    return ev.execv(&sync, options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
 }
 
 fn processReplacePath(
@@ -4293,12 +4391,12 @@ fn processReplacePath(
 fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     const spawned = try ev.spawn(options);
-    defer ev.close(spawned.err_fd);
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    defer ev.close(&cancel_region, spawned.err_fd);
 
     // Wait for the child to report any errors in or before `execvpe`.
     var child_err: ForkBailError = undefined;
-    var cancel_region: CancelRegion = .initBlocked();
-    defer cancel_region.deinit();
     ev.readAll(&cancel_region, spawned.err_fd, @ptrCast(&child_err)) catch |read_err| {
         switch (read_err) {
             error.Canceled => unreachable, // blocked
@@ -4336,6 +4434,8 @@ fn processSpawnPath(
     @panic("TODO processSpawnPath");
 }
 
+const prog_fileno = 3;
+
 const Spawned = struct {
     pid: pid_t,
     err_fd: fd_t,
@@ -4344,6 +4444,9 @@ const Spawned = struct {
     stderr: ?File,
 };
 fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned {
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+
     // The child process does need to access (one end of) these pipes. However,
     // we must initially set CLOEXEC to avoid a race condition. If another thread
     // is racing to spawn a different child process, we don't want it to inherit
@@ -4358,28 +4461,24 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
 
     const stdin_pipe = if (options.stdin == .pipe) try pipe2(pipe_flags) else undefined;
     errdefer if (options.stdin == .pipe) {
-        ev.destroyPipe(stdin_pipe);
+        ev.destroyPipe(&cancel_region, stdin_pipe);
     };
 
     const stdout_pipe = if (options.stdout == .pipe) try pipe2(pipe_flags) else undefined;
     errdefer if (options.stdout == .pipe) {
-        ev.destroyPipe(stdout_pipe);
+        ev.destroyPipe(&cancel_region, stdout_pipe);
     };
 
     const stderr_pipe = if (options.stderr == .pipe) try pipe2(pipe_flags) else undefined;
     errdefer if (options.stderr == .pipe) {
-        ev.destroyPipe(stderr_pipe);
+        ev.destroyPipe(&cancel_region, stderr_pipe);
     };
 
     const any_ignore =
         options.stdin == .ignore or options.stdout == .ignore or options.stderr == .ignore;
-    const dev_null_fd = if (any_ignore) dev_null_fd: {
-        var cancel_region: CancelRegion = .init();
-        defer cancel_region.deinit();
-        break :dev_null_fd try ev.null_fd.open(ev, &cancel_region, "/dev/null", .{
-            .ACCMODE = .RDWR,
-        });
-    } else undefined;
+    const dev_null_fd = if (any_ignore) try ev.null_fd.open(ev, &cancel_region, "/dev/null", .{
+        .ACCMODE = .RDWR,
+    }) else undefined;
 
     const prog_pipe: [2]fd_t = if (options.progress_node.index != .none) pipe: {
         // We use CLOEXEC for the same reason as in `pipe_flags`.
@@ -4387,7 +4486,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
         _ = linux.fcntl(pipe[0], linux.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2));
         break :pipe pipe;
     } else .{ -1, -1 };
-    errdefer ev.destroyPipe(prog_pipe);
+    errdefer ev.destroyPipe(&cancel_region, prog_pipe);
 
     var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
     defer arena_allocator.deinit();
@@ -4405,7 +4504,6 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
     for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
 
-    const prog_fileno = 3;
     comptime assert(@max(linux.STDIN_FILENO, linux.STDOUT_FILENO, linux.STDERR_FILENO) + 1 == prog_fileno);
 
     const env_block = env_block: {
@@ -4421,7 +4519,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     // This pipe communicates to the parent errors in the child between `fork` and `execvpe`.
     // It is closed by the child (via CLOEXEC) without writing if `execvpe` succeeds.
     const err_pipe: [2]fd_t = try pipe2(.{ .CLOEXEC = true });
-    errdefer ev.destroyPipe(err_pipe);
+    errdefer ev.destroyPipe(&cancel_region, err_pipe);
 
     try ev.scanEnviron(); // for PATH
     const PATH = ev.environ.string.PATH orelse default_PATH;
@@ -4439,78 +4537,33 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
 
     if (pid_result == 0) {
         defer comptime unreachable; // We are the child.
-        _ = swapCancelProtection(ev, .blocked);
-        const ep1 = err_pipe[1];
-
-        ev.setUpChildIo(options.stdin, stdin_pipe[0], linux.STDIN_FILENO, dev_null_fd) catch |err|
-            ev.forkBail(ep1, err);
-        ev.setUpChildIo(options.stdout, stdout_pipe[1], linux.STDOUT_FILENO, dev_null_fd) catch |err|
-            ev.forkBail(ep1, err);
-        ev.setUpChildIo(options.stderr, stderr_pipe[1], linux.STDERR_FILENO, dev_null_fd) catch |err|
-            ev.forkBail(ep1, err);
-
-        switch (options.cwd) {
-            .inherit => {},
-            .dir => |cwd| processSetCurrentDir(ev, cwd) catch |err| ev.forkBail(ep1, err),
-            .path => |cwd| processSetCurrentPath(ev, cwd) catch |err| ev.forkBail(ep1, err),
-        }
-
-        // Must happen after fchdir above, the cwd file descriptor might be
-        // equal to prog_fileno and be clobbered by this dup2 call.
-        if (prog_pipe[1] != -1) dup2(prog_pipe[1], prog_fileno) catch |err| ev.forkBail(ep1, err);
-
-        if (options.gid) |gid| {
-            switch (linux.errno(linux.setregid(gid, gid))) {
-                .SUCCESS => {},
-                .AGAIN => ev.forkBail(ep1, error.ResourceLimitReached),
-                .INVAL => ev.forkBail(ep1, error.InvalidUserId),
-                .PERM => ev.forkBail(ep1, error.PermissionDenied),
-                else => ev.forkBail(ep1, error.Unexpected),
-            }
-        }
-
-        if (options.uid) |uid| {
-            switch (linux.errno(linux.setreuid(uid, uid))) {
-                .SUCCESS => {},
-                .AGAIN => ev.forkBail(ep1, error.ResourceLimitReached),
-                .INVAL => ev.forkBail(ep1, error.InvalidUserId),
-                .PERM => ev.forkBail(ep1, error.PermissionDenied),
-                else => ev.forkBail(ep1, error.Unexpected),
-            }
-        }
-
-        if (options.pgid) |pid| {
-            switch (linux.errno(linux.setpgid(0, pid))) {
-                .SUCCESS => {},
-                .ACCES => ev.forkBail(ep1, error.ProcessAlreadyExec),
-                .INVAL => ev.forkBail(ep1, error.InvalidProcessGroupId),
-                .PERM => ev.forkBail(ep1, error.PermissionDenied),
-                else => ev.forkBail(ep1, error.Unexpected),
-            }
-        }
-
-        if (options.start_suspended) {
-            switch (linux.errno(linux.kill(linux.getpid(), .STOP))) {
-                .SUCCESS => {},
-                .PERM => ev.forkBail(ep1, error.PermissionDenied),
-                else => ev.forkBail(ep1, error.Unexpected),
-            }
-        }
-
-        const err = execv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
-        ev.forkBail(ep1, err);
+        var sync: CancelRegion.Sync = .{ .cancel_region = .initBlocked() };
+        const err = ev.setUpChild(&sync, .{
+            .stdin_pipe = stdin_pipe[0],
+            .stdout_pipe = stdout_pipe[1],
+            .stderr_pipe = stderr_pipe[1],
+            .dev_null_fd = dev_null_fd,
+            .prog_pipe = prog_pipe[1],
+            .argv_buf = argv_buf,
+            .env_block = env_block,
+            .PATH = PATH,
+            .spawn = options,
+        });
+        ev.writeAll(&sync.cancel_region, err_pipe[1], @ptrCast(&err)) catch {};
+        const exit = if (builtin.single_threaded) linux.exit else linux.exit_group;
+        exit(1);
     }
 
     const pid: pid_t = @intCast(pid_result); // We are the parent.
     errdefer comptime unreachable; // The child is forked; we must not error from now on
 
-    ev.close(err_pipe[1]); // make sure only the child holds the write end open
+    ev.close(&cancel_region, err_pipe[1]); // make sure only the child holds the write end open
 
-    if (options.stdin == .pipe) ev.close(stdin_pipe[0]);
-    if (options.stdout == .pipe) ev.close(stdout_pipe[1]);
-    if (options.stderr == .pipe) ev.close(stderr_pipe[1]);
+    if (options.stdin == .pipe) ev.close(&cancel_region, stdin_pipe[0]);
+    if (options.stdout == .pipe) ev.close(&cancel_region, stdout_pipe[1]);
+    if (options.stderr == .pipe) ev.close(&cancel_region, stderr_pipe[1]);
 
-    if (prog_pipe[1] != -1) ev.close(prog_pipe[1]);
+    if (prog_pipe[1] != -1) ev.close(&cancel_region, prog_pipe[1]);
 
     options.progress_node.setIpcFile(ev, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
 
@@ -4546,24 +4599,127 @@ pub fn pipe2(flags: linux.O) PipeError![2]fd_t {
         else => |err| return unexpectedErrno(err),
     }
 }
-fn destroyPipe(ev: *Evented, pipe: [2]fd_t) void {
-    if (pipe[0] != -1) ev.close(pipe[0]);
-    if (pipe[0] != pipe[1]) ev.close(pipe[1]);
+fn destroyPipe(ev: *Evented, cancel_region: *CancelRegion, pipe: [2]fd_t) void {
+    if (pipe[0] != -1) ev.close(cancel_region, pipe[0]);
+    if (pipe[0] != pipe[1]) ev.close(cancel_region, pipe[1]);
+}
+
+/// Errors that can occur between fork() and execv()
+const ForkBailError = process.SetCurrentDirError || ChdirError ||
+    process.SpawnError || process.ReplaceError;
+fn setUpChild(
+    ev: *Evented,
+    sync: *CancelRegion.Sync,
+    options: struct {
+        stdin_pipe: fd_t,
+        stdout_pipe: fd_t,
+        stderr_pipe: fd_t,
+        dev_null_fd: fd_t,
+        prog_pipe: fd_t,
+        argv_buf: [:null]?[*:0]const u8,
+        env_block: process.Environ.Block,
+        PATH: []const u8,
+        spawn: process.SpawnOptions,
+    },
+) ForkBailError {
+    try ev.setUpChildIo(
+        sync,
+        options.spawn.stdin,
+        options.stdin_pipe,
+        linux.STDIN_FILENO,
+        options.dev_null_fd,
+    );
+    try ev.setUpChildIo(
+        sync,
+        options.spawn.stdout,
+        options.stdout_pipe,
+        linux.STDOUT_FILENO,
+        options.dev_null_fd,
+    );
+    try ev.setUpChildIo(
+        sync,
+        options.spawn.stderr,
+        options.stderr_pipe,
+        linux.STDERR_FILENO,
+        options.dev_null_fd,
+    );
+
+    switch (options.spawn.cwd) {
+        .inherit => {},
+        .dir => |cwd_dir| try ev.fchdir(sync, cwd_dir.handle),
+        .path => |cwd_path| {
+            var cwd_path_buffer: [PATH_MAX]u8 = undefined;
+            const cwd_path_posix = try pathToPosix(cwd_path, &cwd_path_buffer);
+            try ev.chdir(sync, cwd_path_posix);
+        },
+    }
+
+    // Must happen after fchdir above, the cwd file descriptor might be
+    // equal to prog_fileno and be clobbered by this dup2 call.
+    if (options.prog_pipe != -1) try ev.dup2(sync, options.prog_pipe, prog_fileno);
+
+    if (options.spawn.gid) |gid| {
+        switch (linux.errno(linux.setregid(gid, gid))) {
+            .SUCCESS => {},
+            .AGAIN => return error.ResourceLimitReached,
+            .INVAL => return error.InvalidUserId,
+            .PERM => return error.PermissionDenied,
+            else => return error.Unexpected,
+        }
+    }
+
+    if (options.spawn.uid) |uid| {
+        switch (linux.errno(linux.setreuid(uid, uid))) {
+            .SUCCESS => {},
+            .AGAIN => return error.ResourceLimitReached,
+            .INVAL => return error.InvalidUserId,
+            .PERM => return error.PermissionDenied,
+            else => return error.Unexpected,
+        }
+    }
+
+    if (options.spawn.pgid) |pid| {
+        switch (linux.errno(linux.setpgid(0, pid))) {
+            .SUCCESS => {},
+            .ACCES => return error.ProcessAlreadyExec,
+            .INVAL => return error.InvalidProcessGroupId,
+            .PERM => return error.PermissionDenied,
+            else => return error.Unexpected,
+        }
+    }
+
+    if (options.spawn.start_suspended) {
+        switch (linux.errno(linux.kill(linux.getpid(), .STOP))) {
+            .SUCCESS => {},
+            .PERM => return error.PermissionDenied,
+            else => return error.Unexpected,
+        }
+    }
+
+    return ev.execv(
+        sync,
+        options.spawn.expand_arg0,
+        options.argv_buf.ptr[0].?,
+        options.argv_buf.ptr,
+        options.env_block,
+        options.PATH,
+    );
 }
 
 fn setUpChildIo(
     ev: *Evented,
+    sync: *CancelRegion.Sync,
     stdio: process.SpawnOptions.StdIo,
     pipe_fd: fd_t,
     std_fileno: i32,
     dev_null_fd: fd_t,
 ) !void {
     switch (stdio) {
-        .pipe => try dup2(pipe_fd, std_fileno),
-        .close => ev.close(std_fileno),
+        .pipe => try ev.dup2(sync, pipe_fd, std_fileno),
+        .close => ev.close(&sync.cancel_region, std_fileno),
         .inherit => {},
-        .ignore => try dup2(dev_null_fd, std_fileno),
-        .file => |file| try dup2(file.handle, std_fileno),
+        .ignore => try ev.dup2(sync, dev_null_fd, std_fileno),
+        .file => |file| try ev.dup2(sync, file.handle, std_fileno),
     }
 }
 
@@ -4571,11 +4727,10 @@ pub const DupError = error{
     ProcessFdQuotaExceeded,
     SystemResources,
 } || Io.UnexpectedError || Io.Cancelable;
-pub fn dup2(old_fd: fd_t, new_fd: fd_t) DupError!void {
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
+pub fn dup2(ev: *Evented, sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t) DupError!void {
+    _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.dup2(old_fd, new_fd))) {
             .SUCCESS => {},
             .BUSY, .INTR => continue,
@@ -4588,20 +4743,9 @@ pub fn dup2(old_fd: fd_t, new_fd: fd_t) DupError!void {
     }
 }
 
-/// Errors that can occur between fork() and execv()
-const ForkBailError = process.SetCurrentDirError || ChdirError ||
-    process.SpawnError || process.ReplaceError;
-/// Child of fork calls this to report an error to the fork parent. Then the
-/// child exits.
-fn forkBail(ev: *Evented, fd: fd_t, err: ForkBailError) noreturn {
-    var cancel_region: CancelRegion = .initBlocked();
-    defer cancel_region.deinit();
-    ev.writeAll(&cancel_region, fd, @ptrCast(&err)) catch {};
-    const exit = if (builtin.single_threaded) linux.exit else linux.exit_group;
-    exit(1);
-}
-
 fn execv(
+    ev: *Evented,
+    sync: *CancelRegion.Sync,
     arg0_expand: process.ArgExpansion,
     file: [*:0]const u8,
     child_argv: [*:null]?[*:0]const u8,
@@ -4609,7 +4753,7 @@ fn execv(
     PATH: []const u8,
 ) process.ReplaceError {
     const file_slice = std.mem.sliceTo(file, 0);
-    if (std.mem.findScalar(u8, file_slice, '/') != null) return execvPath(file, child_argv, env_block);
+    if (std.mem.findScalar(u8, file_slice, '/') != null) return ev.execvPath(sync, file, child_argv, env_block);
 
     // Use of PATH_MAX here is valid as the path_buf will be passed
     // directly to the operating system in posixExecvPath.
@@ -4637,7 +4781,7 @@ fn execv(
             .expand => child_argv[0] = full_path,
             .no_expand => {},
         }
-        err = execvPath(full_path, child_argv, env_block);
+        err = ev.execvPath(sync, full_path, child_argv, env_block);
         switch (err) {
             error.AccessDenied => seen_eacces = true,
             error.FileNotFound, error.NotDir => {},
@@ -4649,13 +4793,14 @@ fn execv(
 }
 /// This function ignores PATH environment variable.
 pub fn execvPath(
+    ev: *Evented,
+    sync: *CancelRegion.Sync,
     path: [*:0]const u8,
     child_argv: [*:null]const ?[*:0]const u8,
     env_block: process.Environ.PosixBlock,
 ) process.ReplaceError {
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    try cancel_region.await(.nothing);
+    _ = ev;
+    try sync.cancel_region.await(.nothing);
     switch (linux.errno(linux.execve(path, child_argv, env_block.slice.ptr))) {
         .FAULT => |err| return errnoBug(err), // Bad pointer parameter.
         .@"2BIG" => return error.SystemResources,
@@ -4680,14 +4825,15 @@ pub fn execvPath(
 
 fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitError!process.Child.Term {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    defer ev.childCleanup(child);
+
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    defer ev.childCleanup(maybe_sync.cancelRegion(), child);
 
     const pid = child.id.?;
     var info: linux.siginfo_t = undefined;
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
     while (true) {
-        const thread = try cancel_region.awaitIoUring();
+        const thread = try maybe_sync.cancel_region.awaitIoUring();
         thread.enqueue().* = .{
             .opcode = .WAITID,
             .flags = 0,
@@ -4697,7 +4843,7 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
             .addr = 0,
             .len = @intFromEnum(linux.P.PID),
             .rw_flags = 0,
-            .user_data = @intFromPtr(cancel_region.fiber),
+            .user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = linux.W.EXITED |
@@ -4706,27 +4852,30 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
             .resv = 0,
         };
         ev.yield(null, .nothing);
-        switch (cancel_region.errno()) {
+        switch (maybe_sync.cancel_region.errno()) {
             .SUCCESS => {
-                if (child.request_resource_usage_statistics) while (true) {
-                    try cancel_region.await(.nothing);
-                    var rusage: linux.rusage = undefined;
-                    switch (linux.errno(linux.waitid(
-                        .PID,
-                        pid,
-                        &info,
-                        linux.W.EXITED | linux.W.NOHANG,
-                        &rusage,
-                    ))) {
-                        .SUCCESS => {
-                            child.resource_usage_statistics.rusage = rusage;
-                            break;
-                        },
-                        .INTR, .CANCELED => continue,
-                        .CHILD => |err| return errnoBug(err), // Double-free.
-                        else => |err| return unexpectedErrno(err),
+                if (child.request_resource_usage_statistics) {
+                    const sync = try maybe_sync.enterSync(ev);
+                    while (true) {
+                        try sync.cancel_region.await(.nothing);
+                        var rusage: linux.rusage = undefined;
+                        switch (linux.errno(linux.waitid(
+                            .PID,
+                            pid,
+                            &info,
+                            linux.W.EXITED | linux.W.NOHANG,
+                            &rusage,
+                        ))) {
+                            .SUCCESS => {
+                                child.resource_usage_statistics.rusage = rusage;
+                                break;
+                            },
+                            .INTR, .CANCELED => continue,
+                            .CHILD => |err| return errnoBug(err), // Double-free.
+                            else => |err| return unexpectedErrno(err),
+                        }
                     }
-                };
+                }
                 const status: u32 = @bitCast(info.fields.common.second.sigchld.status);
                 const code: linux.CLD = @enumFromInt(info.code);
                 return switch (code) {
@@ -4745,11 +4894,12 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
 
 fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    defer ev.childCleanup(child);
+
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .sync = .initBlocked(ev) };
+    defer maybe_sync.deinit(ev);
+    defer ev.childCleanup(maybe_sync.cancelRegion(), child);
 
     const pid = child.id.?;
-    var cancel_region: CancelRegion = .initBlocked();
-    defer cancel_region.deinit();
     while (true) switch (linux.errno(linux.kill(pid, .TERM))) {
         .SUCCESS => break,
         .INTR => continue,
@@ -4758,10 +4908,11 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
         .SRCH => |err| return errnoBug(err) catch {},
         else => |err| return unexpectedErrno(err) catch {},
     };
+    maybe_sync.leaveSync(ev);
 
     var info: linux.siginfo_t = undefined;
     while (true) {
-        const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
+        const thread = maybe_sync.cancel_region.awaitIoUring() catch |err| switch (err) {
             error.Canceled => unreachable, // blocked
         };
         thread.enqueue().* = .{
@@ -4773,7 +4924,7 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
             .addr = 0,
             .len = @intFromEnum(linux.P.PID),
             .rw_flags = 0,
-            .user_data = @intFromPtr(cancel_region.fiber),
+            .user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = linux.W.EXITED,
@@ -4781,7 +4932,7 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
             .resv = 0,
         };
         ev.yield(null, .nothing);
-        switch (cancel_region.errno()) {
+        switch (maybe_sync.cancel_region.errno()) {
             .SUCCESS => return,
             .INTR, .CANCELED => continue,
             .CHILD => |err| return errnoBug(err) catch {}, // Double-free.
@@ -4790,17 +4941,17 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
     }
 }
 
-fn childCleanup(ev: *Evented, child: *process.Child) void {
+fn childCleanup(ev: *Evented, cancel_region: *CancelRegion, child: *process.Child) void {
     if (child.stdin) |*stdin| {
-        ev.close(stdin.handle);
+        ev.close(cancel_region, stdin.handle);
         child.stdin = null;
     }
     if (child.stdout) |*stdout| {
-        ev.close(stdout.handle);
+        ev.close(cancel_region, stdout.handle);
         child.stdout = null;
     }
     if (child.stderr) |*stderr| {
-        ev.close(stderr.handle);
+        ev.close(cancel_region, stderr.handle);
         child.stderr = null;
     }
     child.id = null;
@@ -4985,14 +5136,14 @@ fn netBindIp(
 ) net.IpAddress.BindError!net.Socket {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     const family = posixAddressFamily(address);
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    const socket_fd = try ev.socket(&cancel_region, family, options);
-    errdefer ev.close(socket_fd);
+    var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
+    defer maybe_sync.deinit(ev);
+    const socket_fd = try ev.socket(&maybe_sync.cancel_region, family, options);
+    errdefer ev.close(maybe_sync.cancelRegion(), socket_fd);
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
-    try ev.bind(&cancel_region, socket_fd, &storage.any, addr_len);
-    try ev.getsockname(&cancel_region, socket_fd, &storage.any, &addr_len);
+    try ev.bind(&maybe_sync.cancel_region, socket_fd, &storage.any, addr_len);
+    try ev.getsockname(try maybe_sync.enterSync(ev), socket_fd, &storage.any, &addr_len);
     return .{
         .handle = socket_fd,
         .address = addressFromPosix(&storage),
@@ -5268,7 +5419,9 @@ fn netWriteFileUnavailable(
 
 fn netClose(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    for (handles) |handle| ev.close(handle);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    for (handles) |handle| ev.close(&cancel_region, handle);
 }
 
 fn netCloseUnavailable(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
@@ -5407,9 +5560,28 @@ fn bind(
     }
 }
 
-fn close(ev: *Evented, fd: fd_t) void {
-    var cancel_region: CancelRegion = .initBlocked();
-    defer cancel_region.deinit();
+fn chdir(ev: *Evented, sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError!void {
+    _ = ev;
+    while (true) {
+        try sync.cancel_region.await(.nothing);
+        switch (linux.errno(linux.chdir(path))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .IO => return error.FileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.NotDir,
+            .ILSEQ => return error.BadPathName,
+            .FAULT => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn close(ev: *Evented, cancel_region: *CancelRegion, fd: fd_t) void {
     while (true) {
         const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
             error.Canceled => unreachable, // blocked
@@ -5440,9 +5612,26 @@ fn close(ev: *Evented, fd: fd_t) void {
     }
 }
 
+fn fchdir(ev: *Evented, sync: *CancelRegion.Sync, dir: fd_t) process.SetCurrentDirError!void {
+    _ = ev;
+    if (dir == linux.AT.FDCWD) return;
+    while (true) {
+        try sync.cancel_region.await(.nothing);
+        switch (linux.errno(linux.fchdir(dir))) {
+            .SUCCESS => return,
+            .INTR => continue,
+            .ACCES => return error.AccessDenied,
+            .NOTDIR => return error.NotDir,
+            .IO => return error.FileSystem,
+            .BADF => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
 fn fchmodat(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     dir: fd_t,
     path: [*:0]const u8,
     mode: linux.mode_t,
@@ -5450,7 +5639,7 @@ fn fchmodat(
 ) Dir.SetFilePermissionsError!void {
     _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.fchmodat2(dir, path, mode, flags))) {
             .SUCCESS => return,
             .INTR => continue,
@@ -5473,7 +5662,7 @@ fn fchmodat(
 
 fn fchownat(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     dir: fd_t,
     path: [*:0]const u8,
     owner: linux.uid_t,
@@ -5482,7 +5671,7 @@ fn fchownat(
 ) File.SetOwnerError!void {
     _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.fchownat(dir, path, owner, group, flags))) {
             .SUCCESS => return,
             .INTR => continue,
@@ -5504,13 +5693,13 @@ fn fchownat(
 
 fn flock(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     fd: fd_t,
     op: File.Lock,
     blocking: enum { blocking, nonblocking },
 ) (File.LockError || error{WouldBlock})!void {
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.flock(fd, LOCK.NB | @as(i32, switch (op) {
             .none => LOCK.UN,
             .shared => LOCK.SH,
@@ -5522,7 +5711,7 @@ fn flock(
             .INVAL => |err| return errnoBug(err), // invalid parameters
             .NOLCK => return error.SystemResources,
             .AGAIN => {
-                const thread = try cancel_region.awaitIoUring();
+                const thread = try sync.cancel_region.awaitIoUring();
                 thread.enqueue().* = .{
                     .opcode = .NOP,
                     .flags = 0,
@@ -5532,7 +5721,7 @@ fn flock(
                     .addr = 0,
                     .len = 0,
                     .rw_flags = 0,
-                    .user_data = @intFromPtr(cancel_region.fiber),
+                    .user_data = @intFromPtr(sync.cancel_region.fiber),
                     .buf_index = 0,
                     .personality = 0,
                     .splice_fd_in = 0,
@@ -5540,7 +5729,7 @@ fn flock(
                     .resv = 0,
                 };
                 ev.yield(null, .nothing);
-                switch (cancel_region.errno()) {
+                switch (sync.cancel_region.errno()) {
                     .SUCCESS, .INTR, .CANCELED => {},
                     else => unreachable,
                 }
@@ -5557,14 +5746,14 @@ fn flock(
 
 fn getsockname(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     socket_fd: fd_t,
     addr: *linux.sockaddr,
     addr_len: *linux.socklen_t,
 ) !void {
     _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.getsockname(socket_fd, addr, addr_len))) {
             .SUCCESS => return,
             .INTR => continue,
@@ -5633,14 +5822,14 @@ fn linkat(
 
 fn lseek(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     fd: fd_t,
     offset: u64,
     whence: u32,
 ) File.SeekError!void {
     _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         var result: u64 = undefined;
         switch (linux.errno(switch (@sizeOf(usize)) {
             else => comptime unreachable,
@@ -5837,7 +6026,7 @@ fn readAll(
 
 fn realPath(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     fd: fd_t,
     out_buffer: []u8,
 ) File.RealPathError!usize {
@@ -5846,7 +6035,7 @@ fn realPath(
     const proc_path = std.fmt.bufPrintSentinel(&procfs_buf, "/proc/self/fd/{d}", .{fd}, 0) catch
         unreachable;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         const rc = linux.readlink(proc_path, out_buffer.ptr, out_buffer.len);
         switch (linux.errno(rc)) {
             .SUCCESS => return rc,
@@ -6025,7 +6214,7 @@ fn socket(
             else => |err| return unexpectedErrno(err),
         }
     };
-    errdefer ev.close(socket_fd);
+    errdefer ev.close(cancel_region, socket_fd);
 
     if (options.ip6_only) {
         if (linux.IPV6 == void) return error.OptionUnsupported;
@@ -6103,7 +6292,7 @@ fn urandomReadAll(
 
 fn utimensat(
     ev: *Evented,
-    cancel_region: *CancelRegion,
+    sync: *CancelRegion.Sync,
     dir: fd_t,
     path: [*:0]const u8,
     times: ?*const [2]linux.timespec,
@@ -6111,7 +6300,7 @@ fn utimensat(
 ) File.SetTimestampsError!void {
     _ = ev;
     while (true) {
-        try cancel_region.await(.nothing);
+        try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.utimensat(dir, path, times, flags))) {
             .SUCCESS => return,
             .INTR => continue,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index dac4ada39d2a3239086f1ef38d2a04a56a653a1e..e378797544b6fc4d81a4b3f5fa40b29146c5259f 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1543,7 +1543,7 @@ pub const InitOptions = struct {
     /// this limit, calls to `Io.async` when all threads are busy run the task
     /// immediately.
     ///
-    /// Defaults to a number equal to logical CPU cores.
+    /// Defaults to one less than the number of logical CPU cores.
     ///
     /// Protected by `Threaded.mutex` once the I/O instance is already in use. See
     /// `setAsyncLimit`.
@@ -1552,8 +1552,7 @@ pub const InitOptions = struct {
     /// tasks. Until this limit, calls to `Io.concurrent` will increase the thread
     /// pool size.
     ///
-    /// concurrent tasks. After this number, calls to `Io.concurrent` return
-    /// `error.ConcurrencyUnavailable`.
+    /// After this number, calls to `Io.concurrent` return `error.ConcurrencyUnavailable`.
     concurrent_limit: Io.Limit = .unlimited,
     /// Affects the following operations:
     /// * `processExecutablePath` on OpenBSD and Haiku.
@@ -1562,7 +1561,7 @@ pub const InitOptions = struct {
     /// * `fileIsTty`
     /// * `processExecutablePath` on OpenBSD and Haiku (observes "PATH").
     /// * `processSpawn`, `processSpawnPath`, `processReplace`, `processReplacePath`
-    environ: process.Environ,
+    environ: process.Environ = .empty,
     /// If set to `true`, `File.MemoryMap` APIs will always take the fallback path.
     disable_memory_mapping: bool = false,
 };
-- 
2.54.0


From 68403267117bf5cf73e0f747887f2834336ae4a2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 9 Feb 2026 17:17:38 -0800
Subject: [PATCH 255/499] compiler: override debug_io in release + evented mode

to avoid a dependency on std.Io.Threaded in such case
---
 lib/std/debug/ElfFile.zig |  6 +++++-
 src/main.zig              | 19 ++++++++++++++-----
 2 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/lib/std/debug/ElfFile.zig b/lib/std/debug/ElfFile.zig
index 892510601591bc305a0331dea4a95e0992f65765..6d8ed0bdce85ee7b0fdaca22a2247fc767a8ef8e 100644
--- a/lib/std/debug/ElfFile.zig
+++ b/lib/std/debug/ElfFile.zig
@@ -86,7 +86,11 @@ pub const DebugInfoSearchPaths = struct {
             },
             .exe_dir = std.fs.path.dirname(exe_path) orelse ".",
         };
-        @compileError("std.Options.elf_debug_info_search_paths must be provided");
+        return .{
+            .debuginfod_client = null,
+            .global_debug = &.{"/usr/lib/debug"},
+            .exe_dir = std.fs.path.dirname(exe_path) orelse ".",
+        };
     }
 };
 
diff --git a/src/main.zig b/src/main.zig
index 82a1fcf0503c1c88eb074d4334d85ebd00cfa30a..c49bb0f03393702eca6ab03af27cf6f97fd03603 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -51,6 +51,17 @@ pub const std_options: std.Options = .{
     },
 };
 pub const std_options_cwd = if (native_os == .wasi) wasi_cwd else null;
+pub const std_options_debug_threaded_io: ?*Io.Threaded = switch (build_options.io_mode) {
+    .threaded => &io_impl,
+    .evented => switch (builtin.mode) {
+        .Debug => Io.Threaded.global_single_threaded,
+        .ReleaseFast, .ReleaseSmall, .ReleaseSafe => null,
+    },
+};
+pub const std_options_debug_io: Io = switch (build_options.io_mode) {
+    .threaded => io_impl.ioBasic(),
+    .evented => io_impl.io(),
+};
 
 pub const debug = struct {
     pub fn printCrashContext(terminal: Io.Terminal) void {
@@ -189,7 +200,6 @@ pub fn main(init: std.process.Init.Minimal) anyerror!void {
     var root_allocator: RootAllocator = .init;
     defer _ = root_allocator.deinit();
     const root_gpa = root_allocator.allocator();
-    var io_impl: IoImpl = undefined;
     switch (build_options.io_mode) {
         .threaded => io_impl = .init(root_gpa, .{
             .stack_size = thread_stack_size,
@@ -205,7 +215,6 @@ pub fn main(init: std.process.Init.Minimal) anyerror!void {
         }),
     }
     defer io_impl.deinit();
-    io_impl_ptr = &io_impl;
     const io = io_impl.io();
     const gpa = switch (build_options.io_mode) {
         .threaded => root_gpa,
@@ -7815,7 +7824,7 @@ const IoImpl = switch (build_options.io_mode) {
     .threaded => Io.Threaded,
     .evented => Io.Evented,
 };
-var io_impl_ptr: *IoImpl = undefined;
+var io_impl: IoImpl = undefined;
 fn setThreadLimit(arena: std.mem.Allocator, n: usize) Allocator.Error!void {
     switch (build_options.io_mode) {
         .threaded => {
@@ -7824,8 +7833,8 @@ fn setThreadLimit(arena: std.mem.Allocator, n: usize) Allocator.Error!void {
             // linker can run concurrently, so we need to set both the async *and* the
             // concurrency limit.
             const limit: Io.Limit = .limited(n - 1);
-            io_impl_ptr.setAsyncLimit(limit);
-            io_impl_ptr.concurrent_limit = limit;
+            io_impl.setAsyncLimit(limit);
+            io_impl.concurrent_limit = limit;
         },
         .evented => {},
     }
-- 
2.54.0


From 96bd268c8c07b8aae0372317bfea60ef2fb3f257 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 10 Feb 2026 13:06:18 -0800
Subject: [PATCH 256/499] zig libc: simplify implementation

- use symbol export helper
- move all declarations from common.zig into c.zig
- correct documentation
- delete dead code
---
 lib/c.zig                |  63 +++++++++++++--------
 lib/c/common.zig         |  29 ----------
 lib/c/ctype.zig          |  92 +++++++++++++++---------------
 lib/c/inttypes.zig       |  10 ++--
 lib/c/math.zig           |  74 ++++++++++++------------
 lib/c/stdlib.zig         |  54 +++++++++---------
 lib/c/stdlib/drand48.zig |  24 ++++----
 lib/c/stdlib/rand.zig    |  10 ++--
 lib/c/string.zig         |  84 +++++++++++++--------------
 lib/c/strings.zig        |  30 +++++-----
 lib/c/sys.zig            |   7 ---
 lib/c/sys/capability.zig |  15 +++--
 lib/c/sys/file.zig       |  11 ++--
 lib/c/sys/mman.zig       |  41 +++++++-------
 lib/c/sys/reboot.zig     |  11 ++--
 lib/c/sys/utsname.zig    |  13 +++--
 lib/c/unistd.zig         | 119 ++++++++++++++++++++-------------------
 lib/c/wchar.zig          |  66 +++++++++++-----------
 18 files changed, 382 insertions(+), 371 deletions(-)
 delete mode 100644 lib/c/common.zig
 delete mode 100644 lib/c/sys.zig

diff --git a/lib/c.zig b/lib/c.zig
index 681a6f73a58d136e9f8f29679cf4c7de91b38286..c25293b84dc9424e8373cd325ccb12ba875eb618 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -1,7 +1,9 @@
-//! This is Zig's multi-target implementation of libc.
+//! Multi-target implementation of libc, providing ABI compatibility with
+//! bundled libcs.
 //!
-//! When `builtin.link_libc` is true, we need to export all the functions and
-//! provide a libc API compatible with the target (e.g. musl, wasi-libc, ...).
+//! mingw-w64 libc is not fully statically linked, so some symbols don't need
+//! to be exported. However, a future enhancement could be eliminating Zig's
+//! dependency on msvcrt dll even when linking libc and targeting Windows.
 
 const builtin = @import("builtin");
 const std = @import("std");
@@ -13,8 +15,36 @@ pub const panic = if (builtin.is_test)
 else
     std.debug.no_panic;
 
-// NOTE: `libzigc` aims to be a standalone libc and provide ABI compatibility with its bundled libc's.
-// Some of them like `mingw` are not fully statically linked so some symbols don't need to be exported.
+/// It is incorrect to make this conditional on `builtin.is_test`, because it is possible that
+/// libzigc is being linked into a different test compilation, as opposed to being tested itself.
+pub const linkage: std.builtin.GlobalLinkage = .strong;
+
+/// Determines the symbol's visibility to other objects.
+/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
+/// export it to the host runtime.
+pub const visibility: std.builtin.SymbolVisibility = .hidden;
+
+pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void {
+    @export(func, .{ .name = name, .linkage = linkage, .visibility = visibility });
+}
+
+/// Given a low-level syscall return value, sets errno and returns `-1`, or on
+/// success returns the result.
+pub fn errno(syscall_return_value: usize) c_int {
+    return switch (builtin.os.tag) {
+        .linux => {
+            const signed: isize = @bitCast(syscall_return_value);
+            const casted: c_int = @intCast(signed);
+            if (casted < 0) {
+                @branchHint(.unlikely);
+                std.c._errno().* = -casted;
+                return -1;
+            }
+            return casted;
+        },
+        else => comptime unreachable,
+    };
+}
 
 comptime {
     _ = @import("c/inttypes.zig");
@@ -25,22 +55,11 @@ comptime {
     _ = @import("c/strings.zig");
     _ = @import("c/wchar.zig");
 
-    _ = @import("c/sys.zig");
+    _ = @import("c/sys/mman.zig");
+    _ = @import("c/sys/file.zig");
+    _ = @import("c/sys/reboot.zig");
+    _ = @import("c/sys/capability.zig");
+    _ = @import("c/sys/utsname.zig");
+
     _ = @import("c/unistd.zig");
-
-    if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        // Files specific to musl and wasi-libc.
-    }
-
-    if (builtin.target.isMuslLibC()) {
-        // Files specific to musl.
-    }
-
-    if (builtin.target.isWasiLibC()) {
-        // Files specific to wasi-libc.
-    }
-
-    if (builtin.target.isMinGW()) {
-        // Files specific to MinGW-w64.
-    }
 }
diff --git a/lib/c/common.zig b/lib/c/common.zig
deleted file mode 100644
index 5cd94cf0ceedf73986b5b0217d4e285fac45f735..0000000000000000000000000000000000000000
--- a/lib/c/common.zig
+++ /dev/null
@@ -1,29 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-
-/// It is incorrect to make this conditional on `builtin.is_test`, because it is possible that
-/// libzigc is being linked into a different test compilation, as opposed to being tested itself.
-pub const linkage: std.builtin.GlobalLinkage = .strong;
-
-/// Determines the symbol's visibility to other objects.
-/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
-/// export it to the host runtime.
-pub const visibility: std.builtin.SymbolVisibility = .hidden;
-
-/// Given a low-level syscall return value, sets errno and returns `-1`, or on
-/// success returns the result.
-pub fn errno(syscall_return_value: usize) c_int {
-    return switch (builtin.os.tag) {
-        .linux => {
-            const signed: isize = @bitCast(syscall_return_value);
-            const casted: c_int = @intCast(signed);
-            if (casted < 0) {
-                @branchHint(.unlikely);
-                std.c._errno().* = -casted;
-                return -1;
-            }
-            return casted;
-        },
-        else => comptime unreachable,
-    };
-}
diff --git a/lib/c/ctype.zig b/lib/c/ctype.zig
index 5fd5669faebbe746fd6dabce501e2a5661004364..9316ee102f9ec971acbb70662cbaf2c7db24a626 100644
--- a/lib/c/ctype.zig
+++ b/lib/c/ctype.zig
@@ -1,57 +1,57 @@
-const std = @import("std");
-const common = @import("common.zig");
 const builtin = @import("builtin");
+const std = @import("std");
+const symbol = @import("../c.zig").symbol;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         // Functions specific to musl and wasi-libc.
-        @export(&isalnum, .{ .name = "isalnum", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isalpha, .{ .name = "isalpha", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isblank, .{ .name = "isblank", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&iscntrl, .{ .name = "iscntrl", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isdigit, .{ .name = "isdigit", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isgraph, .{ .name = "isgraph", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&islower, .{ .name = "islower", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isprint, .{ .name = "isprint", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&ispunct, .{ .name = "ispunct", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isspace, .{ .name = "isspace", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isupper, .{ .name = "isupper", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isxdigit, .{ .name = "isxdigit", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&tolower, .{ .name = "tolower", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&toupper, .{ .name = "toupper", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&isalnum, "isalnum");
+        symbol(&isalpha, "isalpha");
+        symbol(&isblank, "isblank");
+        symbol(&iscntrl, "iscntrl");
+        symbol(&isdigit, "isdigit");
+        symbol(&isgraph, "isgraph");
+        symbol(&islower, "islower");
+        symbol(&isprint, "isprint");
+        symbol(&ispunct, "ispunct");
+        symbol(&isspace, "isspace");
+        symbol(&isupper, "isupper");
+        symbol(&isxdigit, "isxdigit");
+        symbol(&tolower, "tolower");
+        symbol(&toupper, "toupper");
 
-        @export(&__isalnum_l, .{ .name = "__isalnum_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isalpha_l, .{ .name = "__isalpha_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isblank_l, .{ .name = "__isblank_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__iscntrl_l, .{ .name = "__iscntrl_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isdigit_l, .{ .name = "__isdigit_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isgraph_l, .{ .name = "__isgraph_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__islower_l, .{ .name = "__islower_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isprint_l, .{ .name = "__isprint_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__ispunct_l, .{ .name = "__ispunct_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isspace_l, .{ .name = "__isspace_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isupper_l, .{ .name = "__isupper_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isxdigit_l, .{ .name = "__isxdigit_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__tolower_l, .{ .name = "__tolower_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__toupper_l, .{ .name = "__toupper_l", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__isalnum_l, "__isalnum_l");
+        symbol(&__isalpha_l, "__isalpha_l");
+        symbol(&__isblank_l, "__isblank_l");
+        symbol(&__iscntrl_l, "__iscntrl_l");
+        symbol(&__isdigit_l, "__isdigit_l");
+        symbol(&__isgraph_l, "__isgraph_l");
+        symbol(&__islower_l, "__islower_l");
+        symbol(&__isprint_l, "__isprint_l");
+        symbol(&__ispunct_l, "__ispunct_l");
+        symbol(&__isspace_l, "__isspace_l");
+        symbol(&__isupper_l, "__isupper_l");
+        symbol(&__isxdigit_l, "__isxdigit_l");
+        symbol(&__tolower_l, "__tolower_l");
+        symbol(&__toupper_l, "__toupper_l");
 
-        @export(&__isalnum_l, .{ .name = "isalnum_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isalpha_l, .{ .name = "isalpha_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isblank_l, .{ .name = "isblank_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__iscntrl_l, .{ .name = "iscntrl_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isdigit_l, .{ .name = "isdigit_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isgraph_l, .{ .name = "isgraph_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__islower_l, .{ .name = "islower_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isprint_l, .{ .name = "isprint_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__ispunct_l, .{ .name = "ispunct_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isspace_l, .{ .name = "isspace_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isupper_l, .{ .name = "isupper_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__isxdigit_l, .{ .name = "isxdigit_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__tolower_l, .{ .name = "tolower_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__toupper_l, .{ .name = "toupper_l", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__isalnum_l, "isalnum_l");
+        symbol(&__isalpha_l, "isalpha_l");
+        symbol(&__isblank_l, "isblank_l");
+        symbol(&__iscntrl_l, "iscntrl_l");
+        symbol(&__isdigit_l, "isdigit_l");
+        symbol(&__isgraph_l, "isgraph_l");
+        symbol(&__islower_l, "islower_l");
+        symbol(&__isprint_l, "isprint_l");
+        symbol(&__ispunct_l, "ispunct_l");
+        symbol(&__isspace_l, "isspace_l");
+        symbol(&__isupper_l, "isupper_l");
+        symbol(&__isxdigit_l, "isxdigit_l");
+        symbol(&__tolower_l, "tolower_l");
+        symbol(&__toupper_l, "toupper_l");
 
-        @export(&isascii, .{ .name = "isascii", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&toascii, .{ .name = "toascii", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&isascii, "isascii");
+        symbol(&toascii, "toascii");
     }
 }
 
diff --git a/lib/c/inttypes.zig b/lib/c/inttypes.zig
index 39b2c9ba885008e8307c2d01f5b84eff3fc1f91a..7bdcae873eb657d5a6acf1dd7b099d907576df40 100644
--- a/lib/c/inttypes.zig
+++ b/lib/c/inttypes.zig
@@ -1,14 +1,16 @@
-const std = @import("std");
-const common = @import("common.zig");
 const builtin = @import("builtin");
+
+const std = @import("std");
 const intmax_t = std.c.intmax_t;
 const imaxdiv_t = std.c.imaxdiv_t;
 
+const symbol = @import("../c.zig").symbol;
+
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         // Functions specific to musl and wasi-libc.
-        @export(&imaxabs, .{ .name = "imaxabs", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&imaxdiv, .{ .name = "imaxdiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&imaxabs, "imaxabs");
+        symbol(&imaxdiv, "imaxdiv");
     }
 }
 
diff --git a/lib/c/math.zig b/lib/c/math.zig
index e9d92002c4fc391eb352fe024e567338fc74e145..27524e986016176a6c1898024e366b4118897105 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -1,57 +1,59 @@
+const builtin = @import("builtin");
+
 const std = @import("std");
 const math = std.math;
-const common = @import("common.zig");
-const builtin = @import("builtin");
+
+const symbol = @import("../c.zig").symbol;
 
 comptime {
     if (builtin.target.isMinGW()) {
-        @export(&isnan, .{ .name = "isnan", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isnan, .{ .name = "__isnan", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isnanf, .{ .name = "isnanf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isnanf, .{ .name = "__isnanf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isnanl, .{ .name = "isnanl", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&isnanl, .{ .name = "__isnanl", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&isnan, "isnan");
+        symbol(&isnan, "__isnan");
+        symbol(&isnanf, "isnanf");
+        symbol(&isnanf, "__isnanf");
+        symbol(&isnanl, "isnanl");
+        symbol(&isnanl, "__isnanl");
 
-        @export(&math.nan(f64), .{ .name = "__QNAN", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.snan(f64), .{ .name = "__SNAN", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.inf(f64), .{ .name = "__INF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.floatTrueMin(f64), .{ .name = "__DENORM", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&math.nan(f64), "__QNAN");
+        symbol(&math.snan(f64), "__SNAN");
+        symbol(&math.inf(f64), "__INF");
+        symbol(&math.floatTrueMin(f64), "__DENORM");
 
-        @export(&math.nan(f32), .{ .name = "__QNANF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.snan(f32), .{ .name = "__SNANF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.inf(f32), .{ .name = "__INFF", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.floatTrueMin(f32), .{ .name = "__DENORMF", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&math.nan(f32), "__QNANF");
+        symbol(&math.snan(f32), "__SNANF");
+        symbol(&math.inf(f32), "__INFF");
+        symbol(&math.floatTrueMin(f32), "__DENORMF");
 
-        @export(&math.nan(c_longdouble), .{ .name = "__QNANL", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.snan(c_longdouble), .{ .name = "__SNANL", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.inf(c_longdouble), .{ .name = "__INFL", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&math.floatTrueMin(c_longdouble), .{ .name = "__DENORML", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&math.nan(c_longdouble), "__QNANL");
+        symbol(&math.snan(c_longdouble), "__SNANL");
+        symbol(&math.inf(c_longdouble), "__INFL");
+        symbol(&math.floatTrueMin(c_longdouble), "__DENORML");
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        @export(&hypotf, .{ .name = "hypotf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&hypotl, .{ .name = "hypotl", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&nan, .{ .name = "nan", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&nanf, .{ .name = "nanf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&nanl, .{ .name = "nanl", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&hypotf, "hypotf");
+        symbol(&hypotl, "hypotl");
+        symbol(&nan, "nan");
+        symbol(&nanf, "nanf");
+        symbol(&nanl, "nanl");
     }
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        @export(&acos, .{ .name = "acos", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&atanf, .{ .name = "atanf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&atan, .{ .name = "atan", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&cbrt, .{ .name = "cbrt", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&cbrtf, .{ .name = "cbrtf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&hypot, .{ .name = "hypot", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&pow, .{ .name = "pow", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&acos, "acos");
+        symbol(&atanf, "atanf");
+        symbol(&atan, "atan");
+        symbol(&atanl, "atanl");
+        symbol(&cbrt, "cbrt");
+        symbol(&cbrtf, "cbrtf");
+        symbol(&hypot, "hypot");
+        symbol(&pow, "pow");
     }
 
     if (builtin.target.isMuslLibC()) {
-        @export(&copysignf, .{ .name = "copysignf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&copysign, .{ .name = "copysign", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&copysignf, "copysignf");
+        symbol(&copysign, "copysign");
     }
-    @export(&copysignl, .{ .name = "copysignl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&copysignl, "copysignl");
 }
 
 fn acos(x: f64) callconv(.c) f64 {
diff --git a/lib/c/stdlib.zig b/lib/c/stdlib.zig
index 51ead9bee729edc25469b4b00c23d92301b58a22..ccc8c08a143959353951939df3efb6593e02e999 100644
--- a/lib/c/stdlib.zig
+++ b/lib/c/stdlib.zig
@@ -1,47 +1,49 @@
-const std = @import("std");
-const common = @import("common.zig");
 const builtin = @import("builtin");
+
+const std = @import("std");
 const assert = std.debug.assert;
 const div_t = std.c.div_t;
 const ldiv_t = std.c.ldiv_t;
 const lldiv_t = std.c.lldiv_t;
 
+const symbol = @import("../c.zig").symbol;
+
 comptime {
     _ = @import("stdlib/rand.zig");
     _ = @import("stdlib/drand48.zig");
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         // Functions specific to musl and wasi-libc.
-        @export(&abs, .{ .name = "abs", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&labs, .{ .name = "labs", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&llabs, .{ .name = "llabs", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&abs, "abs");
+        symbol(&labs, "labs");
+        symbol(&llabs, "llabs");
 
-        @export(&div, .{ .name = "div", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&ldiv, .{ .name = "ldiv", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&lldiv, .{ .name = "lldiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&div, "div");
+        symbol(&ldiv, "ldiv");
+        symbol(&lldiv, "lldiv");
 
-        @export(&atoi, .{ .name = "atoi", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&atol, .{ .name = "atol", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&atoll, .{ .name = "atoll", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&atoi, "atoi");
+        symbol(&atol, "atol");
+        symbol(&atoll, "atoll");
 
-        @export(&strtol, .{ .name = "strtol", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoll, .{ .name = "strtoll", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoul, .{ .name = "strtoul", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoull, .{ .name = "strtoull", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoimax, .{ .name = "strtoimax", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoumax, .{ .name = "strtoumax", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strtol, "strtol");
+        symbol(&strtoll, "strtoll");
+        symbol(&strtoul, "strtoul");
+        symbol(&strtoull, "strtoull");
+        symbol(&strtoimax, "strtoimax");
+        symbol(&strtoumax, "strtoumax");
 
-        @export(&strtol, .{ .name = "__strtol_internal", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoll, .{ .name = "__strtoll_internal", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoul, .{ .name = "__strtoul_internal", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoull, .{ .name = "__strtoull_internal", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoimax, .{ .name = "__strtoimax_internal", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtoumax, .{ .name = "__strtoumax_internal", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strtol, "__strtol_internal");
+        symbol(&strtoll, "__strtoll_internal");
+        symbol(&strtoul, "__strtoul_internal");
+        symbol(&strtoull, "__strtoull_internal");
+        symbol(&strtoimax, "__strtoimax_internal");
+        symbol(&strtoumax, "__strtoumax_internal");
 
-        @export(&qsort_r, .{ .name = "qsort_r", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&qsort, .{ .name = "qsort", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&qsort_r, "qsort_r");
+        symbol(&qsort, "qsort");
 
-        @export(&bsearch, .{ .name = "bsearch", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&bsearch, "bsearch");
     }
 }
 
diff --git a/lib/c/stdlib/drand48.zig b/lib/c/stdlib/drand48.zig
index b3104c7df42862bebc361cf222efdd245a6fcd85..266cc7af4a64fa1afe6ea50fe5367c9633fc9e55 100644
--- a/lib/c/stdlib/drand48.zig
+++ b/lib/c/stdlib/drand48.zig
@@ -1,21 +1,23 @@
 //! drand48 functions are based off a 48-bit lcg prng: https://pubs.opengroup.org/onlinepubs/9799919799/functions/drand48.html
 
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
+
+const std = @import("std");
 const Lcg = std.Random.lcg.Wrapping(u48);
 
+const symbol = @import("../../c.zig").symbol;
+
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        @export(&erand48, .{ .name = "erand48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&jrand48, .{ .name = "jrand48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&nrand48, .{ .name = "nrand48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&drand48, .{ .name = "drand48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&lrand48, .{ .name = "lrand48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&mrand48, .{ .name = "mrand48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&lcong48, .{ .name = "lcong48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&seed48, .{ .name = "seed48", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&srand48, .{ .name = "srand48", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&erand48, "erand48");
+        symbol(&jrand48, "jrand48");
+        symbol(&nrand48, "nrand48");
+        symbol(&drand48, "drand48");
+        symbol(&lrand48, "lrand48");
+        symbol(&mrand48, "mrand48");
+        symbol(&lcong48, "lcong48");
+        symbol(&seed48, "seed48");
+        symbol(&srand48, "srand48");
     }
 }
 
diff --git a/lib/c/stdlib/rand.zig b/lib/c/stdlib/rand.zig
index 9ca7a51967a40fa8d180ae4aff8eaf763cdd3bb2..a160a9d376c440584247c0aa72140e3d7a92eb95 100644
--- a/lib/c/stdlib/rand.zig
+++ b/lib/c/stdlib/rand.zig
@@ -1,12 +1,12 @@
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
+const std = @import("std");
+const symbol = @import("../../c.zig").symbol;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        @export(&rand, .{ .name = "rand", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&srand, .{ .name = "srand", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&rand_r, .{ .name = "rand_r", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&rand, "rand");
+        symbol(&srand, "srand");
+        symbol(&rand_r, "rand_r");
     }
 }
 
diff --git a/lib/c/string.zig b/lib/c/string.zig
index e0161934718765177cb37a28cf8f90aa60fc7ea6..722ef0ba77d948251bb0121d9d31f23989c6c7f6 100644
--- a/lib/c/string.zig
+++ b/lib/c/string.zig
@@ -1,6 +1,6 @@
 const builtin = @import("builtin");
 const std = @import("std");
-const common = @import("common.zig");
+const symbol = @import("../c.zig").symbol;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -8,58 +8,58 @@ comptime {
         // memmove implemented in compiler_rt
         // memset implemented in compiler_rt
         // memcmp implemented in compiler_rt
-        @export(&memchr, .{ .name = "memchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strcpy, .{ .name = "strcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strncpy, .{ .name = "strncpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strcat, .{ .name = "strcat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strncat, .{ .name = "strncat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strcmp, .{ .name = "strcmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strncmp, .{ .name = "strncmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strcoll, .{ .name = "strcoll", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strxfrm, .{ .name = "strxfrm", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strchr, .{ .name = "strchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strrchr, .{ .name = "strrchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strcspn, .{ .name = "strcspn", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strspn, .{ .name = "strspn", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strpbrk, .{ .name = "strpbrk", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strstr, .{ .name = "strstr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtok, .{ .name = "strtok", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&memchr, "memchr");
+        symbol(&strcpy, "strcpy");
+        symbol(&strncpy, "strncpy");
+        symbol(&strcat, "strcat");
+        symbol(&strncat, "strncat");
+        symbol(&strcmp, "strcmp");
+        symbol(&strncmp, "strncmp");
+        symbol(&strcoll, "strcoll");
+        symbol(&strxfrm, "strxfrm");
+        symbol(&strchr, "strchr");
+        symbol(&strrchr, "strrchr");
+        symbol(&strcspn, "strcspn");
+        symbol(&strspn, "strspn");
+        symbol(&strpbrk, "strpbrk");
+        symbol(&strstr, "strstr");
+        symbol(&strtok, "strtok");
         // strlen is in compiler_rt
 
-        @export(&strtok_r, .{ .name = "strtok_r", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&stpcpy, .{ .name = "stpcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&stpncpy, .{ .name = "stpncpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strnlen, .{ .name = "strnlen", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&memmem, .{ .name = "memmem", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strtok_r, "strtok_r");
+        symbol(&stpcpy, "stpcpy");
+        symbol(&stpncpy, "stpncpy");
+        symbol(&strnlen, "strnlen");
+        symbol(&memmem, "memmem");
 
-        @export(&memccpy, .{ .name = "memccpy", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&memccpy, "memccpy");
 
-        @export(&strsep, .{ .name = "strsep", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strlcat, .{ .name = "strlcat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strlcpy, .{ .name = "strlcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&explicit_bzero, .{ .name = "explicit_bzero", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strsep, "strsep");
+        symbol(&strlcat, "strlcat");
+        symbol(&strlcpy, "strlcpy");
+        symbol(&explicit_bzero, "explicit_bzero");
 
-        @export(&strchrnul, .{ .name = "strchrnul", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strcasestr, .{ .name = "strcasestr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&memrchr, .{ .name = "memrchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&mempcpy, .{ .name = "mempcpy", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strchrnul, "strchrnul");
+        symbol(&strcasestr, "strcasestr");
+        symbol(&memrchr, "memrchr");
+        symbol(&mempcpy, "mempcpy");
 
-        @export(&__strcoll_l, .{ .name = "__strcoll_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__strxfrm_l, .{ .name = "__strxfrm_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__strcoll_l, .{ .name = "strcoll_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__strxfrm_l, .{ .name = "strxfrm_l", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__strcoll_l, "__strcoll_l");
+        symbol(&__strxfrm_l, "__strxfrm_l");
+        symbol(&__strcoll_l, "strcoll_l");
+        symbol(&__strxfrm_l, "strxfrm_l");
 
         // These symbols are not in the public ABI of musl/wasi. However they depend on these exports internally.
-        @export(&stpcpy, .{ .name = "__stpcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&stpncpy, .{ .name = "__stpncpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strchrnul, .{ .name = "__strchrnul", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&memrchr, .{ .name = "__memrchr", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&stpcpy, "__stpcpy");
+        symbol(&stpncpy, "__stpncpy");
+        symbol(&strchrnul, "__strchrnul");
+        symbol(&memrchr, "__memrchr");
     }
 
     if (builtin.target.isMinGW()) {
-        @export(&strnlen, .{ .name = "strnlen", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&mempcpy, .{ .name = "mempcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strtok_r, .{ .name = "strtok_r", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strnlen, "strnlen");
+        symbol(&mempcpy, "mempcpy");
+        symbol(&strtok_r, "strtok_r");
     }
 }
 
diff --git a/lib/c/strings.zig b/lib/c/strings.zig
index 9bebe1566fbc92e5ae3f0cd1fc033efe7826da33..8a052795ae40768d47ececbf527865650e5ab046 100644
--- a/lib/c/strings.zig
+++ b/lib/c/strings.zig
@@ -1,27 +1,27 @@
-const std = @import("std");
-const common = @import("common.zig");
 const builtin = @import("builtin");
+const std = @import("std");
+const symbol = @import("../c.zig").symbol;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         // bcmp is implemented in compiler_rt
-        @export(&bcopy, .{ .name = "bcopy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&bzero, .{ .name = "bzero", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&index, .{ .name = "index", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&rindex, .{ .name = "rindex", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&bcopy, "bcopy");
+        symbol(&bzero, "bzero");
+        symbol(&index, "index");
+        symbol(&rindex, "rindex");
 
-        @export(&ffs, .{ .name = "ffs", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&ffsl, .{ .name = "ffsl", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&ffsll, .{ .name = "ffsll", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&ffs, "ffs");
+        symbol(&ffsl, "ffsl");
+        symbol(&ffsll, "ffsll");
 
-        @export(&strcasecmp, .{ .name = "strcasecmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&strncasecmp, .{ .name = "strncasecmp", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&strcasecmp, "strcasecmp");
+        symbol(&strncasecmp, "strncasecmp");
 
-        @export(&__strcasecmp_l, .{ .name = "__strcasecmp_l", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__strncasecmp_l, .{ .name = "__strncasecmp_l", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__strcasecmp_l, "__strcasecmp_l");
+        symbol(&__strncasecmp_l, "__strncasecmp_l");
 
-        @export(&__strcasecmp_l, .{ .name = "strcasecmp_l", .linkage = .weak, .visibility = common.visibility });
-        @export(&__strncasecmp_l, .{ .name = "strncasecmp_l", .linkage = .weak, .visibility = common.visibility });
+        symbol(&__strcasecmp_l, "strcasecmp_l");
+        symbol(&__strncasecmp_l, "strncasecmp_l");
     }
 }
 
diff --git a/lib/c/sys.zig b/lib/c/sys.zig
deleted file mode 100644
index 71e068616b28b78f8b2f341a313310430106e4cf..0000000000000000000000000000000000000000
--- a/lib/c/sys.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-comptime {
-    _ = @import("sys/mman.zig");
-    _ = @import("sys/file.zig");
-    _ = @import("sys/reboot.zig");
-    _ = @import("sys/capability.zig");
-    _ = @import("sys/utsname.zig");
-}
diff --git a/lib/c/sys/capability.zig b/lib/c/sys/capability.zig
index 19718a45e3f925129859d25d738a60b84d4ccd98..dd8faad75d676722bd032ab6c04c88ce41cce4c3 100644
--- a/lib/c/sys/capability.zig
+++ b/lib/c/sys/capability.zig
@@ -1,18 +1,21 @@
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
 
+const std = @import("std");
+
+const symbol = @import("../../c.zig").symbol;
+const errno = @import("../../c.zig").errno;
+
 comptime {
     if (builtin.target.isMuslLibC()) {
-        @export(&capsetLinux, .{ .name = "capset", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&capgetLinux, .{ .name = "capget", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&capsetLinux, "capset");
+        symbol(&capgetLinux, "capget");
     }
 }
 
 fn capsetLinux(hdrp: *anyopaque, datap: *anyopaque) callconv(.c) c_int {
-    return common.errno(std.os.linux.capset(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap))));
+    return errno(std.os.linux.capset(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap))));
 }
 
 fn capgetLinux(hdrp: *anyopaque, datap: *anyopaque) callconv(.c) c_int {
-    return common.errno(std.os.linux.capget(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap))));
+    return errno(std.os.linux.capget(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap))));
 }
diff --git a/lib/c/sys/file.zig b/lib/c/sys/file.zig
index 643d3fcd037f9459cdb679e301c8cd9da3f5f28a..fcc77114254a5fb3641dbe1476cd539e96e5755f 100644
--- a/lib/c/sys/file.zig
+++ b/lib/c/sys/file.zig
@@ -1,13 +1,16 @@
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
 
+const std = @import("std");
+
+const symbol = @import("../../c.zig").symbol;
+const errno = @import("../../c.zig").errno;
+
 comptime {
     if (builtin.target.isMuslLibC()) {
-        @export(&flockLinux, .{ .name = "flock", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&flockLinux, "flock");
     }
 }
 
 fn flockLinux(fd: c_int, operation: c_int) callconv(.c) c_int {
-    return common.errno(std.os.linux.flock(fd, operation));
+    return errno(std.os.linux.flock(fd, operation));
 }
diff --git a/lib/c/sys/mman.zig b/lib/c/sys/mman.zig
index 92de9ad07660f48af93e334b50b0d63c63b27ff3..3783cc419713607c5fdd0c6f57030cfbeaa11cf7 100644
--- a/lib/c/sys/mman.zig
+++ b/lib/c/sys/mman.zig
@@ -1,56 +1,59 @@
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
 
+const std = @import("std");
+
+const symbol = @import("../../c.zig").symbol;
+const errno = @import("../../c.zig").errno;
+
 comptime {
     if (builtin.target.isMuslLibC()) {
-        @export(&madviseLinux, .{ .name = "madvise", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&madviseLinux, .{ .name = "__madvise", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&madviseLinux, "madvise");
+        symbol(&madviseLinux, "__madvise");
 
-        @export(&mincoreLinux, .{ .name = "mincore", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&mincoreLinux, "mincore");
 
-        @export(&mlockLinux, .{ .name = "mlock", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&mlockallLinux, .{ .name = "mlockall", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&mlockLinux, "mlock");
+        symbol(&mlockallLinux, "mlockall");
 
-        @export(&mprotectLinux, .{ .name = "mprotect", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&mprotectLinux, .{ .name = "__mprotect", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&mprotectLinux, "mprotect");
+        symbol(&mprotectLinux, "__mprotect");
 
-        @export(&munlockLinux, .{ .name = "munlock", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&munlockallLinux, .{ .name = "munlockall", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&munlockLinux, "munlock");
+        symbol(&munlockallLinux, "munlockall");
 
-        @export(&posix_madviseLinux, .{ .name = "posix_madvise", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&posix_madviseLinux, "posix_madvise");
     }
 }
 
 fn madviseLinux(addr: *anyopaque, len: usize, advice: c_int) callconv(.c) c_int {
-    return common.errno(std.os.linux.madvise(@ptrCast(addr), len, @bitCast(advice)));
+    return errno(std.os.linux.madvise(@ptrCast(addr), len, @bitCast(advice)));
 }
 
 fn mincoreLinux(addr: *anyopaque, len: usize, vec: [*]u8) callconv(.c) c_int {
-    return common.errno(std.os.linux.mincore(@ptrCast(addr), len, vec));
+    return errno(std.os.linux.mincore(@ptrCast(addr), len, vec));
 }
 
 fn mlockLinux(addr: *const anyopaque, len: usize) callconv(.c) c_int {
-    return common.errno(std.os.linux.mlock(@ptrCast(addr), len));
+    return errno(std.os.linux.mlock(@ptrCast(addr), len));
 }
 
 fn mlockallLinux(flags: c_int) callconv(.c) c_int {
-    return common.errno(std.os.linux.mlockall(@bitCast(flags)));
+    return errno(std.os.linux.mlockall(@bitCast(flags)));
 }
 
 fn mprotectLinux(addr: *anyopaque, len: usize, prot: c_int) callconv(.c) c_int {
     const page_size = std.heap.pageSize();
     const start = std.mem.alignBackward(usize, @intFromPtr(addr), page_size);
     const aligned_len = std.mem.alignForward(usize, len, page_size);
-    return common.errno(std.os.linux.mprotect(@ptrFromInt(start), aligned_len, @bitCast(prot)));
+    return errno(std.os.linux.mprotect(@ptrFromInt(start), aligned_len, @bitCast(prot)));
 }
 
 fn munlockLinux(addr: *const anyopaque, len: usize) callconv(.c) c_int {
-    return common.errno(std.os.linux.munlock(@ptrCast(addr), len));
+    return errno(std.os.linux.munlock(@ptrCast(addr), len));
 }
 
 fn munlockallLinux() callconv(.c) c_int {
-    return common.errno(std.os.linux.munlockall());
+    return errno(std.os.linux.munlockall());
 }
 
 fn posix_madviseLinux(addr: *anyopaque, len: usize, advice: c_int) callconv(.c) c_int {
diff --git a/lib/c/sys/reboot.zig b/lib/c/sys/reboot.zig
index 8b7b0503bd14ff7868cd17b9b22cc211bf529833..8ec4210477e4dc22119a49c52c53a4763dd4e05d 100644
--- a/lib/c/sys/reboot.zig
+++ b/lib/c/sys/reboot.zig
@@ -1,13 +1,16 @@
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
 
+const std = @import("std");
+
+const symbol = @import("../../c.zig").symbol;
+const errno = @import("../../c.zig").errno;
+
 comptime {
     if (builtin.target.isMuslLibC()) {
-        @export(&rebootLinux, .{ .name = "reboot", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&rebootLinux, "reboot");
     }
 }
 
 fn rebootLinux(cmd: c_int) callconv(.c) c_int {
-    return common.errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @enumFromInt(cmd), null));
+    return errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @enumFromInt(cmd), null));
 }
diff --git a/lib/c/sys/utsname.zig b/lib/c/sys/utsname.zig
index 6082c1b6cecf6c15c8454cf362fef9e49cc1e3e8..5ae02adbc40b00329be390a7e15eb872fac30be7 100644
--- a/lib/c/sys/utsname.zig
+++ b/lib/c/sys/utsname.zig
@@ -1,19 +1,22 @@
-const std = @import("std");
-const common = @import("../common.zig");
 const builtin = @import("builtin");
 
+const std = @import("std");
+
+const symbol = @import("../../c.zig").symbol;
+const errno = @import("../../c.zig").errno;
+
 comptime {
     if (builtin.target.isMuslLibC()) {
-        @export(&unameLinux, .{ .name = "uname", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&unameLinux, "uname");
     }
 
     if (builtin.target.isWasiLibC()) {
-        @export(&unameWasi, .{ .name = "uname", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&unameWasi, "uname");
     }
 }
 
 fn unameLinux(uts: *std.os.linux.utsname) callconv(.c) c_int {
-    return common.errno(std.os.linux.uname(uts));
+    return errno(std.os.linux.uname(uts));
 }
 
 fn unameWasi(uts: *std.c.utsname) callconv(.c) c_int {
diff --git a/lib/c/unistd.zig b/lib/c/unistd.zig
index 98290f0e04a0621d43ff521ecebde45beafdf965..ef0f8895c76ca819e832982d61325efe7950bbf3 100644
--- a/lib/c/unistd.zig
+++ b/lib/c/unistd.zig
@@ -1,50 +1,53 @@
-const std = @import("std");
-const common = @import("common.zig");
 const builtin = @import("builtin");
+
+const std = @import("std");
 const linux = std.os.linux;
 
+const symbol = @import("../c.zig").symbol;
+const errno = @import("../c.zig").errno;
+
 comptime {
     if (builtin.target.isMuslLibC()) {
-        @export(&_exit, .{ .name = "_exit", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_exit, "_exit");
 
-        @export(&accessLinux, .{ .name = "access", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&acctLinux, .{ .name = "acct", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&chdirLinux, .{ .name = "chdir", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&chownLinux, .{ .name = "chown", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&fchownatLinux, .{ .name = "fchownat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&lchownLinux, .{ .name = "lchown", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&chrootLinux, .{ .name = "chroot", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&ctermidLinux, .{ .name = "ctermid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&dupLinux, .{ .name = "dup", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&accessLinux, "access");
+        symbol(&acctLinux, "acct");
+        symbol(&chdirLinux, "chdir");
+        symbol(&chownLinux, "chown");
+        symbol(&fchownatLinux, "fchownat");
+        symbol(&lchownLinux, "lchown");
+        symbol(&chrootLinux, "chroot");
+        symbol(&ctermidLinux, "ctermid");
+        symbol(&dupLinux, "dup");
 
-        @export(&getegidLinux, .{ .name = "getegid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&geteuidLinux, .{ .name = "geteuid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getgidLinux, .{ .name = "getgid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getgroupsLinux, .{ .name = "getgroups", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getpgidLinux, .{ .name = "getpgid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getpgrpLinux, .{ .name = "getpgrp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&setpgidLinux, .{ .name = "setpgid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&setpgrpLinux, .{ .name = "setpgrp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getsidLinux, .{ .name = "getsid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getpidLinux, .{ .name = "getpid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getppidLinux, .{ .name = "getppid", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&getuidLinux, .{ .name = "getuid", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&getegidLinux, "getegid");
+        symbol(&geteuidLinux, "geteuid");
+        symbol(&getgidLinux, "getgid");
+        symbol(&getgroupsLinux, "getgroups");
+        symbol(&getpgidLinux, "getpgid");
+        symbol(&getpgrpLinux, "getpgrp");
+        symbol(&setpgidLinux, "setpgid");
+        symbol(&setpgrpLinux, "setpgrp");
+        symbol(&getsidLinux, "getsid");
+        symbol(&getpidLinux, "getpid");
+        symbol(&getppidLinux, "getppid");
+        symbol(&getuidLinux, "getuid");
 
-        @export(&rmdirLinux, .{ .name = "rmdir", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&linkLinux, .{ .name = "link", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&linkatLinux, .{ .name = "linkat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&pipeLinux, .{ .name = "pipe", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&renameatLinux, .{ .name = "renameat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&symlinkLinux, .{ .name = "symlink", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&symlinkatLinux, .{ .name = "symlinkat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&syncLinux, .{ .name = "sync", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&unlinkLinux, .{ .name = "unlink", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&unlinkatLinux, .{ .name = "unlinkat", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&rmdirLinux, "rmdir");
+        symbol(&linkLinux, "link");
+        symbol(&linkatLinux, "linkat");
+        symbol(&pipeLinux, "pipe");
+        symbol(&renameatLinux, "renameat");
+        symbol(&symlinkLinux, "symlink");
+        symbol(&symlinkatLinux, "symlinkat");
+        symbol(&syncLinux, "sync");
+        symbol(&unlinkLinux, "unlink");
+        symbol(&unlinkatLinux, "unlinkat");
 
-        @export(&execveLinux, .{ .name = "execve", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&execveLinux, "execve");
     }
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        @export(&swab, .{ .name = "swab", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&swab, "swab");
     }
 }
 
@@ -53,31 +56,31 @@ fn _exit(exit_code: c_int) callconv(.c) noreturn {
 }
 
 fn accessLinux(path: [*:0]const c_char, amode: c_int) callconv(.c) c_int {
-    return common.errno(linux.access(@ptrCast(path), @bitCast(amode)));
+    return errno(linux.access(@ptrCast(path), @bitCast(amode)));
 }
 
 fn acctLinux(path: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.acct(@ptrCast(path)));
+    return errno(linux.acct(@ptrCast(path)));
 }
 
 fn chdirLinux(path: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.chdir(@ptrCast(path)));
+    return errno(linux.chdir(@ptrCast(path)));
 }
 
 fn chownLinux(path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t) callconv(.c) c_int {
-    return common.errno(linux.chown(@ptrCast(path), uid, gid));
+    return errno(linux.chown(@ptrCast(path), uid, gid));
 }
 
 fn fchownatLinux(fd: c_int, path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t, flags: c_int) callconv(.c) c_int {
-    return common.errno(linux.fchownat(fd, @ptrCast(path), uid, gid, @bitCast(flags)));
+    return errno(linux.fchownat(fd, @ptrCast(path), uid, gid, @bitCast(flags)));
 }
 
 fn lchownLinux(path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t) callconv(.c) c_int {
-    return common.errno(linux.lchown(@ptrCast(path), uid, gid));
+    return errno(linux.lchown(@ptrCast(path), uid, gid));
 }
 
 fn chrootLinux(path: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.chroot(@ptrCast(path)));
+    return errno(linux.chroot(@ptrCast(path)));
 }
 
 fn ctermidLinux(maybe_path: ?[*]c_char) callconv(.c) [*:0]c_char {
@@ -90,7 +93,7 @@ fn ctermidLinux(maybe_path: ?[*]c_char) callconv(.c) [*:0]c_char {
 }
 
 fn dupLinux(fd: c_int) callconv(.c) c_int {
-    return common.errno(linux.dup(fd));
+    return errno(linux.dup(fd));
 }
 
 fn getegidLinux() callconv(.c) linux.gid_t {
@@ -106,11 +109,11 @@ fn getgidLinux() callconv(.c) linux.gid_t {
 }
 
 fn getgroupsLinux(size: c_int, list: ?[*]linux.gid_t) callconv(.c) c_int {
-    return common.errno(linux.getgroups(@intCast(size), list));
+    return errno(linux.getgroups(@intCast(size), list));
 }
 
 fn getpgidLinux(pid: linux.pid_t) callconv(.c) linux.pid_t {
-    return common.errno(linux.getpgid(pid));
+    return errno(linux.getpgid(pid));
 }
 
 fn getpgrpLinux() callconv(.c) linux.pid_t {
@@ -118,7 +121,7 @@ fn getpgrpLinux() callconv(.c) linux.pid_t {
 }
 
 fn setpgidLinux(pid: linux.pid_t, pgid: linux.pid_t) callconv(.c) c_int {
-    return common.errno(linux.setpgid(pid, pgid));
+    return errno(linux.setpgid(pid, pgid));
 }
 
 fn setpgrpLinux() callconv(.c) linux.pid_t {
@@ -134,7 +137,7 @@ fn getppidLinux() callconv(.c) linux.pid_t {
 }
 
 fn getsidLinux(pid: linux.pid_t) callconv(.c) linux.pid_t {
-    return common.errno(linux.getsid(pid));
+    return errno(linux.getsid(pid));
 }
 
 fn getuidLinux() callconv(.c) linux.uid_t {
@@ -142,31 +145,31 @@ fn getuidLinux() callconv(.c) linux.uid_t {
 }
 
 fn linkLinux(old: [*:0]const c_char, new: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.link(@ptrCast(old), @ptrCast(new)));
+    return errno(linux.link(@ptrCast(old), @ptrCast(new)));
 }
 
 fn linkatLinux(old_fd: c_int, old: [*:0]const c_char, new_fd: c_int, new: [*:0]const c_char, flags: c_int) callconv(.c) c_int {
-    return common.errno(linux.linkat(old_fd, @ptrCast(old), new_fd, @ptrCast(new), @bitCast(flags)));
+    return errno(linux.linkat(old_fd, @ptrCast(old), new_fd, @ptrCast(new), @bitCast(flags)));
 }
 
 fn pipeLinux(fd: *[2]c_int) callconv(.c) c_int {
-    return common.errno(linux.pipe(@ptrCast(fd)));
+    return errno(linux.pipe(@ptrCast(fd)));
 }
 
 fn renameatLinux(old_fd: c_int, old: [*:0]const c_char, new_fd: c_int, new: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.renameat(old_fd, @ptrCast(old), new_fd, @ptrCast(new)));
+    return errno(linux.renameat(old_fd, @ptrCast(old), new_fd, @ptrCast(new)));
 }
 
 fn rmdirLinux(path: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.rmdir(@ptrCast(path)));
+    return errno(linux.rmdir(@ptrCast(path)));
 }
 
 fn symlinkLinux(existing: [*:0]const c_char, new: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.symlink(@ptrCast(existing), @ptrCast(new)));
+    return errno(linux.symlink(@ptrCast(existing), @ptrCast(new)));
 }
 
 fn symlinkatLinux(existing: [*:0]const c_char, fd: c_int, new: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.symlinkat(@ptrCast(existing), fd, @ptrCast(new)));
+    return errno(linux.symlinkat(@ptrCast(existing), fd, @ptrCast(new)));
 }
 
 fn syncLinux() callconv(.c) void {
@@ -174,15 +177,15 @@ fn syncLinux() callconv(.c) void {
 }
 
 fn unlinkLinux(path: [*:0]const c_char) callconv(.c) c_int {
-    return common.errno(linux.unlink(@ptrCast(path)));
+    return errno(linux.unlink(@ptrCast(path)));
 }
 
 fn unlinkatLinux(fd: c_int, path: [*:0]const c_char, flags: c_int) callconv(.c) c_int {
-    return common.errno(linux.unlinkat(fd, @ptrCast(path), @bitCast(flags)));
+    return errno(linux.unlinkat(fd, @ptrCast(path), @bitCast(flags)));
 }
 
 fn execveLinux(path: [*:0]const c_char, argv: [*:null]const ?[*:0]c_char, envp: [*:null]const ?[*:0]c_char) callconv(.c) c_int {
-    return common.errno(linux.execve(@ptrCast(path), @ptrCast(argv), @ptrCast(envp)));
+    return errno(linux.execve(@ptrCast(path), @ptrCast(argv), @ptrCast(envp)));
 }
 
 fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isize) callconv(.c) void {
diff --git a/lib/c/wchar.zig b/lib/c/wchar.zig
index b31c450cfcc835e1d22ba95c663cdd3171b21b72..b85687e8a7487685d306da0057d98f8962735176 100644
--- a/lib/c/wchar.zig
+++ b/lib/c/wchar.zig
@@ -1,44 +1,46 @@
-const std = @import("std");
-const common = @import("common.zig");
 const builtin = @import("builtin");
+
+const std = @import("std");
 const wint_t = std.c.wint_t;
 const wchar_t = std.c.wchar_t;
 
+const symbol = @import("../c.zig").symbol;
+
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        @export(&wmemchr, .{ .name = "wmemchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemcmp, .{ .name = "wmemcmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemcpy, .{ .name = "wmemcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemmove, .{ .name = "wmemmove", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemset, .{ .name = "wmemset", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcslen, .{ .name = "wcslen", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsnlen, .{ .name = "wcsnlen", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcscmp, .{ .name = "wcscmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsncmp, .{ .name = "wcsncmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcpcpy, .{ .name = "wcpcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcpncpy, .{ .name = "wcpncpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcscpy, .{ .name = "wcscpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsncpy, .{ .name = "wcsncpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcscat, .{ .name = "wcscat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsncat, .{ .name = "wcsncat", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcschr, .{ .name = "wcschr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsrchr, .{ .name = "wcsrchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsspn, .{ .name = "wcsspn", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcscspn, .{ .name = "wcscspn", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcspbrk, .{ .name = "wcspbrk", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcstok, .{ .name = "wcstok", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsstr, .{ .name = "wcsstr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcswcs, .{ .name = "wcswcs", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&wmemchr, "wmemchr");
+        symbol(&wmemcmp, "wmemcmp");
+        symbol(&wmemcpy, "wmemcpy");
+        symbol(&wmemmove, "wmemmove");
+        symbol(&wmemset, "wmemset");
+        symbol(&wcslen, "wcslen");
+        symbol(&wcsnlen, "wcsnlen");
+        symbol(&wcscmp, "wcscmp");
+        symbol(&wcsncmp, "wcsncmp");
+        symbol(&wcpcpy, "wcpcpy");
+        symbol(&wcpncpy, "wcpncpy");
+        symbol(&wcscpy, "wcscpy");
+        symbol(&wcsncpy, "wcsncpy");
+        symbol(&wcscat, "wcscat");
+        symbol(&wcsncat, "wcsncat");
+        symbol(&wcschr, "wcschr");
+        symbol(&wcsrchr, "wcsrchr");
+        symbol(&wcsspn, "wcsspn");
+        symbol(&wcscspn, "wcscspn");
+        symbol(&wcspbrk, "wcspbrk");
+        symbol(&wcstok, "wcstok");
+        symbol(&wcsstr, "wcsstr");
+        symbol(&wcswcs, "wcswcs");
     }
 
     if (builtin.target.isMinGW()) {
-        @export(&wmemchr, .{ .name = "wmemchr", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemcmp, .{ .name = "wmemcmp", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemcpy, .{ .name = "wmemcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmempcpy, .{ .name = "wmempcpy", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemmove, .{ .name = "wmemmove", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wmemset, .{ .name = "wmemset", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&wcsnlen, .{ .name = "wcsnlen", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&wmemchr, "wmemchr");
+        symbol(&wmemcmp, "wmemcmp");
+        symbol(&wmemcpy, "wmemcpy");
+        symbol(&wmempcpy, "wmempcpy");
+        symbol(&wmemmove, "wmemmove");
+        symbol(&wmemset, "wmemset");
+        symbol(&wcsnlen, "wcsnlen");
     }
 }
 
-- 
2.54.0


From 87fa61bdd12f0b2625013ca6eabb5fe5479a18f4 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Wed, 11 Feb 2026 10:51:26 +0100
Subject: [PATCH 257/499] fix(codegen/llvm): teach llvm to not `dllexport`
 hidden exports

---
 src/codegen/llvm.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index b2a7d230ce7b695f715c2421e9ef2c5f1588f998..0cba671469398ba1d6f439f82755e57354fa744f 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1735,7 +1735,7 @@ pub const Object = struct {
         }
 
         global_index.setUnnamedAddr(.default, &o.builder);
-        if (comp.config.dll_export_fns)
+        if (comp.config.dll_export_fns and first_export.opts.visibility != .hidden)
             global_index.setDllStorageClass(.dllexport, &o.builder);
         global_index.setLinkage(switch (first_export.opts.linkage) {
             .internal => unreachable,
@@ -1794,7 +1794,7 @@ pub const Object = struct {
 
             const alias_global_index = alias_index.ptrConst(&o.builder).global;
             alias_global_index.setUnnamedAddr(.default, &o.builder);
-            if (comp.config.dll_export_fns)
+            if (comp.config.dll_export_fns and first_export.opts.visibility != .hidden)
                 alias_global_index.setDllStorageClass(.dllexport, &o.builder);
             alias_global_index.setLinkage(switch (first_export.opts.linkage) {
                 .internal => unreachable,
-- 
2.54.0


From a6f64096a1487fa6787907d7f130dadff5decb5b Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Wed, 11 Feb 2026 15:44:42 +0100
Subject: [PATCH 258/499] chore(test/standalone): test linking libc in a shared
 library

---
 test/standalone/shared_library/build.zig | 60 ++++++++++++++----------
 1 file changed, 34 insertions(+), 26 deletions(-)

diff --git a/test/standalone/shared_library/build.zig b/test/standalone/shared_library/build.zig
index 5b105e18cc669fa6a863c8ae0aa17c47f927d7d3..00c8e9cf34bd2951c814141103beef8d52b34f3c 100644
--- a/test/standalone/shared_library/build.zig
+++ b/test/standalone/shared_library/build.zig
@@ -6,32 +6,40 @@ pub fn build(b: *std.Build) void {
 
     const optimize: std.builtin.OptimizeMode = .Debug;
     const target = b.graph.host;
-    const lib = b.addLibrary(.{
-        .linkage = .dynamic,
-        .name = "mathtest",
-        .version = .{ .major = 1, .minor = 0, .patch = 0 },
-        .root_module = b.createModule(.{
-            .root_source_file = b.path("mathtest.zig"),
-            .target = target,
-            .optimize = optimize,
-        }),
-    });
 
-    const exe = b.addExecutable(.{
-        .name = "test",
-        .root_module = b.createModule(.{
-            .root_source_file = null,
-            .target = target,
-            .optimize = optimize,
-            .link_libc = true,
-        }),
-    });
-    exe.root_module.addCSourceFile(.{
-        .file = b.path("test.c"),
-        .flags = &[_][]const u8{"-std=c99"},
-    });
-    exe.root_module.linkLibrary(lib);
+    const exe_names: []const []const u8 = &.{ "test", "test-dync" };
+    const lib_names: []const []const u8 = &.{ "mathtest", "mathtest-dync" };
+    const lib_link_libc: []const bool = &.{ false, true };
 
-    const run_cmd = b.addRunArtifact(exe);
-    test_step.dependOn(&run_cmd.step);
+    for (exe_names, lib_names, lib_link_libc) |exe_name, lib_name, dyn_libc| {
+        const lib = b.addLibrary(.{
+            .linkage = .dynamic,
+            .name = lib_name,
+            .version = .{ .major = 1, .minor = 0, .patch = 0 },
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("mathtest.zig"),
+                .target = target,
+                .optimize = optimize,
+                .link_libc = dyn_libc,
+            }),
+        });
+
+        const exe = b.addExecutable(.{
+            .name = exe_name,
+            .root_module = b.createModule(.{
+                .root_source_file = null,
+                .target = target,
+                .optimize = optimize,
+                .link_libc = true,
+            }),
+        });
+        exe.root_module.addCSourceFile(.{
+            .file = b.path("test.c"),
+            .flags = &[_][]const u8{"-std=c99"},
+        });
+        exe.root_module.linkLibrary(lib);
+
+        const run_cmd = b.addRunArtifact(exe);
+        test_step.dependOn(&run_cmd.step);
+    }
 }
-- 
2.54.0


From d4217e21191d66fd62fed980a2429a6eddd7ca7a Mon Sep 17 00:00:00 2001
From: Pivok <pivoc@protonmail.com>
Date: Wed, 11 Feb 2026 19:39:40 +0100
Subject: [PATCH 259/499] zig libc: exp10, exp10f, pow10, pow10f (#31163)

See #30978.

Commands i run:
```
$ stage3/bin/zig build -p stage4 -Denable-llvm -Dno-lib

$ stage4/bin/zig build test-libc -Dlibc-test-path=../../libc-test -Dtest-filter=exp10 -fqemu -fwasmtime --summary line
Build Summary: 725/737 steps succeeded (12 skipped)
```

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31163
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: Pivok <pivoc@protonmail.com>
Co-committed-by: Pivok <pivoc@protonmail.com>
---
 lib/c/math.zig                  | 20 ++++++++++++++++++++
 lib/libc/musl/src/math/exp10.c  | 24 ------------------------
 lib/libc/musl/src/math/exp10f.c | 22 ----------------------
 src/libs/musl.zig               |  2 --
 src/libs/wasi_libc.zig          |  2 --
 5 files changed, 20 insertions(+), 50 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/exp10.c
 delete mode 100644 lib/libc/musl/src/math/exp10f.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 27524e986016176a6c1898024e366b4118897105..85b871c695ef5c4233ba9c6375d41f6347605687 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -45,8 +45,12 @@ comptime {
         symbol(&atanl, "atanl");
         symbol(&cbrt, "cbrt");
         symbol(&cbrtf, "cbrtf");
+        symbol(&exp10, "exp10");
+        symbol(&exp10f, "exp10f");
         symbol(&hypot, "hypot");
         symbol(&pow, "pow");
+        symbol(&pow10, "pow10");
+        symbol(&pow10f, "pow10f");
     }
 
     if (builtin.target.isMuslLibC()) {
@@ -123,6 +127,14 @@ fn cbrtf(x: f32) callconv(.c) f32 {
     return math.cbrt(x);
 }
 
+fn exp10(x: f64) callconv(.c) f64 {
+    return math.pow(f64, 10.0, x);
+}
+
+fn exp10f(x: f32) callconv(.c) f32 {
+    return math.pow(f32, 10.0, x);
+}
+
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
     return math.hypot(x, y);
 }
@@ -138,3 +150,11 @@ fn hypotl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
 fn pow(x: f64, y: f64) callconv(.c) f64 {
     return math.pow(f64, x, y);
 }
+
+fn pow10(x: f64) callconv(.c) f64 {
+    return exp10(x);
+}
+
+fn pow10f(x: f32) callconv(.c) f32 {
+    return exp10f(x);
+}
diff --git a/lib/libc/musl/src/math/exp10.c b/lib/libc/musl/src/math/exp10.c
deleted file mode 100644
index 26899ebac90e1a094d422efcd01806e5cc31e53f..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/exp10.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#define _GNU_SOURCE
-#include <math.h>
-#include <stdint.h>
-
-double exp10(double x)
-{
-	static const double p10[] = {
-		1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10,
-		1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1,
-		1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-		1e10, 1e11, 1e12, 1e13, 1e14, 1e15
-	};
-	double n, y = modf(x, &n);
-	union {double f; uint64_t i;} u = {n};
-	/* fabs(n) < 16 without raising invalid on nan */
-	if ((u.i>>52 & 0x7ff) < 0x3ff+4) {
-		if (!y) return p10[(int)n+15];
-		y = exp2(3.32192809488736234787031942948939 * y);
-		return y * p10[(int)n+15];
-	}
-	return pow(10.0, x);
-}
-
-weak_alias(exp10, pow10);
diff --git a/lib/libc/musl/src/math/exp10f.c b/lib/libc/musl/src/math/exp10f.c
deleted file mode 100644
index d009f0a84fdd9f15010ee83de729b86e50f69caf..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/exp10f.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#define _GNU_SOURCE
-#include <math.h>
-#include <stdint.h>
-
-float exp10f(float x)
-{
-	static const float p10[] = {
-		1e-7f, 1e-6f, 1e-5f, 1e-4f, 1e-3f, 1e-2f, 1e-1f,
-		1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7
-	};
-	float n, y = modff(x, &n);
-	union {float f; uint32_t i;} u = {n};
-	/* fabsf(n) < 8 without raising invalid on nan */
-	if ((u.i>>23 & 0xff) < 0x7f+3) {
-		if (!y) return p10[(int)n+7];
-		y = exp2f(3.32192809488736234787031942948939f * y);
-		return y * p10[(int)n+7];
-	}
-	return exp2(3.32192809488736234787031942948939 * x);
-}
-
-weak_alias(exp10f, pow10f);
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index d0c87ada315066e3ee8997466fa8506bd41f57c4..ff359a1e93599e400ccddce477a0d6ede9c4d289 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -848,8 +848,6 @@ const src_files = [_][]const u8{
     "musl/src/math/erf.c",
     "musl/src/math/erff.c",
     "musl/src/math/erfl.c",
-    "musl/src/math/exp10.c",
-    "musl/src/math/exp10f.c",
     "musl/src/math/exp10l.c",
     "musl/src/math/exp2f_data.c",
     "musl/src/math/exp2l.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 1ca5ba3e70018d296e3c47c4bd0bc64ec2490615..49090795eca86f7e9d290a8c7e04bab75795197e 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -710,8 +710,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/math/erf.c",
     "musl/src/math/erff.c",
     "musl/src/math/erfl.c",
-    "musl/src/math/exp10.c",
-    "musl/src/math/exp10f.c",
     "musl/src/math/exp10l.c",
     "musl/src/math/exp2f_data.c",
     "musl/src/math/exp2l.c",
-- 
2.54.0


From ba293eb820e5c2f62ac7a8ef623d8bffde3dc4f1 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 10:44:04 -0800
Subject: [PATCH 260/499] Revert "compiler: override debug_io in release +
 evented mode"

This reverts commit 68403267117bf5cf73e0f747887f2834336ae4a2.

The commit bungled deinitialization in main.
---
 lib/std/debug/ElfFile.zig |  6 +-----
 src/main.zig              | 19 +++++--------------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/lib/std/debug/ElfFile.zig b/lib/std/debug/ElfFile.zig
index 6d8ed0bdce85ee7b0fdaca22a2247fc767a8ef8e..892510601591bc305a0331dea4a95e0992f65765 100644
--- a/lib/std/debug/ElfFile.zig
+++ b/lib/std/debug/ElfFile.zig
@@ -86,11 +86,7 @@ pub const DebugInfoSearchPaths = struct {
             },
             .exe_dir = std.fs.path.dirname(exe_path) orelse ".",
         };
-        return .{
-            .debuginfod_client = null,
-            .global_debug = &.{"/usr/lib/debug"},
-            .exe_dir = std.fs.path.dirname(exe_path) orelse ".",
-        };
+        @compileError("std.Options.elf_debug_info_search_paths must be provided");
     }
 };
 
diff --git a/src/main.zig b/src/main.zig
index c49bb0f03393702eca6ab03af27cf6f97fd03603..82a1fcf0503c1c88eb074d4334d85ebd00cfa30a 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -51,17 +51,6 @@ pub const std_options: std.Options = .{
     },
 };
 pub const std_options_cwd = if (native_os == .wasi) wasi_cwd else null;
-pub const std_options_debug_threaded_io: ?*Io.Threaded = switch (build_options.io_mode) {
-    .threaded => &io_impl,
-    .evented => switch (builtin.mode) {
-        .Debug => Io.Threaded.global_single_threaded,
-        .ReleaseFast, .ReleaseSmall, .ReleaseSafe => null,
-    },
-};
-pub const std_options_debug_io: Io = switch (build_options.io_mode) {
-    .threaded => io_impl.ioBasic(),
-    .evented => io_impl.io(),
-};
 
 pub const debug = struct {
     pub fn printCrashContext(terminal: Io.Terminal) void {
@@ -200,6 +189,7 @@ pub fn main(init: std.process.Init.Minimal) anyerror!void {
     var root_allocator: RootAllocator = .init;
     defer _ = root_allocator.deinit();
     const root_gpa = root_allocator.allocator();
+    var io_impl: IoImpl = undefined;
     switch (build_options.io_mode) {
         .threaded => io_impl = .init(root_gpa, .{
             .stack_size = thread_stack_size,
@@ -215,6 +205,7 @@ pub fn main(init: std.process.Init.Minimal) anyerror!void {
         }),
     }
     defer io_impl.deinit();
+    io_impl_ptr = &io_impl;
     const io = io_impl.io();
     const gpa = switch (build_options.io_mode) {
         .threaded => root_gpa,
@@ -7824,7 +7815,7 @@ const IoImpl = switch (build_options.io_mode) {
     .threaded => Io.Threaded,
     .evented => Io.Evented,
 };
-var io_impl: IoImpl = undefined;
+var io_impl_ptr: *IoImpl = undefined;
 fn setThreadLimit(arena: std.mem.Allocator, n: usize) Allocator.Error!void {
     switch (build_options.io_mode) {
         .threaded => {
@@ -7833,8 +7824,8 @@ fn setThreadLimit(arena: std.mem.Allocator, n: usize) Allocator.Error!void {
             // linker can run concurrently, so we need to set both the async *and* the
             // concurrency limit.
             const limit: Io.Limit = .limited(n - 1);
-            io_impl.setAsyncLimit(limit);
-            io_impl.concurrent_limit = limit;
+            io_impl_ptr.setAsyncLimit(limit);
+            io_impl_ptr.concurrent_limit = limit;
         },
         .evented => {},
     }
-- 
2.54.0


From ea30f86113cb1ef2ea53f8d35598061ebb153c8e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 00:08:15 -0800
Subject: [PATCH 261/499] bump maxrss for compiler_rt, libc, and c-abi tests

---
 build.zig | 26 +++-----------------------
 1 file changed, 3 insertions(+), 23 deletions(-)

diff --git a/build.zig b/build.zig
index 07cef8274c070707ae931deb68abfb5e7ed5a870..bd1fd2d046ad4470ace4946605f1f17e4960693a 100644
--- a/build.zig
+++ b/build.zig
@@ -509,7 +509,7 @@ pub fn build(b: *std.Build) !void {
         .skip_llvm = skip_llvm,
         .skip_libc = true,
         .no_builtin = true,
-        .max_rss = 900_000_000,
+        .max_rss = 2_000_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
@@ -535,7 +535,7 @@ pub fn build(b: *std.Build) !void {
         .skip_llvm = skip_llvm,
         .skip_libc = true,
         .no_builtin = true,
-        .max_rss = 900_000_000,
+        .max_rss = 4_000_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
@@ -618,27 +618,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_release = skip_release,
-        .max_rss = switch (b.graph.host.result.os.tag) {
-            .freebsd => switch (b.graph.host.result.cpu.arch) {
-                .x86_64 => 727_221_862,
-                else => 800_000_000,
-            },
-            .linux => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 1_318_185_369,
-                .loongarch64 => 1_422_904_524,
-                .powerpc64le => 560_870_604,
-                .riscv64 => 449_924_710,
-                .s390x => 1_946_743_603,
-                .x86_64 => 2_389_779_251,
-                else => 2_200_000_000,
-            },
-            .macos => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 1_813_612_134,
-                else => 1_900_000_000,
-            },
-            .windows => 400_000_000,
-            else => 2_200_000_000,
-        },
+        .max_rss = 3_000_000_000,
     }));
     test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows));
     test_step.dependOn(tests.addStackTraceTests(b, test_filters, skip_non_native));
-- 
2.54.0


From b600b6e5e08bc443ef9742b36d51c95715c8150a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 10 Feb 2026 23:31:37 -0800
Subject: [PATCH 262/499] std.posix: remove close function

---
 lib/c/unistd.zig                              |  30 ++++++
 lib/libc/musl/src/unistd/close.c              |  19 ----
 lib/libc/musl/src/unistd/posix_close.c        |   6 --
 .../sources/__wasilibc_fd_renumber.c          |  38 -------
 lib/std/Build/Watch.zig                       |   4 +-
 lib/std/Io/IoUring.zig                        |   2 +-
 lib/std/Io/Kqueue.zig                         |  15 +--
 lib/std/Io/Threaded.zig                       | 102 +++++++++++-------
 lib/std/os/linux.zig                          |   2 +-
 lib/std/os/linux/IoUring.zig                  |   4 +-
 lib/std/os/linux/IoUring/test.zig             |  42 ++++----
 lib/std/os/linux/test.zig                     |  36 +++++++
 lib/std/posix.zig                             |  78 --------------
 lib/std/posix/test.zig                        |  18 ----
 src/libs/musl.zig                             |   2 -
 src/libs/wasi_libc.zig                        |   1 -
 16 files changed, 165 insertions(+), 234 deletions(-)
 delete mode 100644 lib/libc/musl/src/unistd/close.c
 delete mode 100644 lib/libc/musl/src/unistd/posix_close.c

diff --git a/lib/c/unistd.zig b/lib/c/unistd.zig
index ef0f8895c76ca819e832982d61325efe7950bbf3..676f943f36b24e393713fad3f13e042cfe29f087 100644
--- a/lib/c/unistd.zig
+++ b/lib/c/unistd.zig
@@ -14,6 +14,8 @@ comptime {
         symbol(&acctLinux, "acct");
         symbol(&chdirLinux, "chdir");
         symbol(&chownLinux, "chown");
+        symbol(&close, "close");
+        symbol(&posix_close, "posix_close");
         symbol(&fchownatLinux, "fchownat");
         symbol(&lchownLinux, "lchown");
         symbol(&chrootLinux, "chroot");
@@ -49,6 +51,9 @@ comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&swab, "swab");
     }
+    if (builtin.target.isWasiLibC()) {
+        symbol(&closeWasi, "close");
+    }
 }
 
 fn _exit(exit_code: c_int) callconv(.c) noreturn {
@@ -226,3 +231,28 @@ test swab {
     swab("abcd", &a, 3);
     try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
 }
+
+fn close(fd: std.c.fd_t) callconv(.c) c_int {
+    const signed: isize = @bitCast(linux.close(fd));
+    if (signed < 0) {
+        @branchHint(.unlikely);
+        if (-signed == @intFromEnum(linux.E.INTR)) return 0;
+        std.c._errno().* = @intCast(-signed);
+        return -1;
+    }
+    return 0;
+}
+
+fn posix_close(fd: std.c.fd_t, _: c_int) callconv(.c) c_int {
+    return close(fd);
+}
+
+fn closeWasi(fd: std.c.fd_t) callconv(.c) c_int {
+    switch (std.os.wasi.fd_close(fd)) {
+        .SUCCESS => return 0,
+        else => |e| {
+            std.c._errno().* = @intFromEnum(e);
+            return -1;
+        },
+    }
+}
diff --git a/lib/libc/musl/src/unistd/close.c b/lib/libc/musl/src/unistd/close.c
deleted file mode 100644
index a2105f5060e235733a739bf6155ca25192210ef4..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/close.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <unistd.h>
-#include <errno.h>
-#include "aio_impl.h"
-#include "syscall.h"
-
-static int dummy(int fd)
-{
-	return fd;
-}
-
-weak_alias(dummy, __aio_close);
-
-int close(int fd)
-{
-	fd = __aio_close(fd);
-	int r = __syscall_cp(SYS_close, fd);
-	if (r == -EINTR) r = 0;
-	return __syscall_ret(r);
-}
diff --git a/lib/libc/musl/src/unistd/posix_close.c b/lib/libc/musl/src/unistd/posix_close.c
deleted file mode 100644
index 90f51a82e32d69921e6ddce5cb5c473d59bfc935..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/unistd/posix_close.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <unistd.h>
-
-int posix_close(int fd, int flags)
-{
-	return close(fd);
-}
diff --git a/lib/libc/wasi/libc-bottom-half/sources/__wasilibc_fd_renumber.c b/lib/libc/wasi/libc-bottom-half/sources/__wasilibc_fd_renumber.c
index 7690d1359eac29f70378747f41aba7ebc7f9be6f..bf2b3a2e935120c263dba0d3cf6ab21b2e19a654 100644
--- a/lib/libc/wasi/libc-bottom-half/sources/__wasilibc_fd_renumber.c
+++ b/lib/libc/wasi/libc-bottom-half/sources/__wasilibc_fd_renumber.c
@@ -70,41 +70,3 @@ void drop_udp_socket(udp_socket_t socket) {
     udp_udp_socket_drop_own(socket.socket);
 }
 #endif // __wasilibc_use_wasip2
-
-int close(int fd) {
-    // Scan the preopen fds before making any changes.
-    __wasilibc_populate_preopens();
-
-#ifdef __wasilibc_use_wasip2
-    descriptor_table_entry_t entry;
-    if (descriptor_table_remove(fd, &entry)) {
-
-        switch (entry.tag)
-        {
-        case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
-            drop_tcp_socket(entry.tcp_socket);
-            break;
-        case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
-            drop_udp_socket(entry.udp_socket);
-            break;
-        default: /* unreachable */ abort();
-        }
-        
-        return 0;
-    }
-#endif // __wasilibc_use_wasip2
-    
-    __wasi_errno_t error = __wasi_fd_close(fd);
-    if (error != 0) {
-        errno = error;
-        return -1;
-    }
-
-    return 0;
-}
-
-weak void __wasilibc_populate_preopens(void) {
-    // This version does nothing. It may be overridden by a version which does
-    // something if `__wasilibc_find_abspath` or `__wasilibc_find_relpath` are
-    // used.
-}
diff --git a/lib/std/Build/Watch.zig b/lib/std/Build/Watch.zig
index c559210b9268d9c0cc44c52f765b81af39b87652..fe0a532395d4a9e9068e3adb42776735a1d30b1c 100644
--- a/lib/std/Build/Watch.zig
+++ b/lib/std/Build/Watch.zig
@@ -693,7 +693,7 @@ const Os = switch (builtin.os.tag) {
                                     fatal("failed to open directory {f}: {t}", .{ path, err });
                                 };
                             // Empirically the dir has to stay open or else no events are triggered.
-                            errdefer if (!skip_open_dir) posix.close(dir_fd);
+                            errdefer if (!skip_open_dir) std.Io.Threaded.closeFd(dir_fd);
                             const changes = [1]posix.Kevent{.{
                                 .ident = @bitCast(@as(isize, dir_fd)),
                                 .filter = std.c.EVFILT.VNODE,
@@ -793,7 +793,7 @@ const Os = switch (builtin.os.tag) {
                     };
                     const filtered_changes = if (i == handles.len - 1) changes[0..1] else &changes;
                     _ = try Io.Kqueue.kevent(w.os.kq_fd, filtered_changes, &.{}, null);
-                    if (path.sub_path.len != 0) posix.close(dir_fd);
+                    if (path.sub_path.len != 0) std.Io.Threaded.closeFd(dir_fd);
 
                     w.dir_table.swapRemoveAt(i);
                     handles.swapRemove(i);
diff --git a/lib/std/Io/IoUring.zig b/lib/std/Io/IoUring.zig
index e4b5bc0fe534596425112db5c6aae5f9c33eb624..542f5e5fb2453a7e442d9c712a7d4d74b8fdb0bc 100644
--- a/lib/std/Io/IoUring.zig
+++ b/lib/std/Io/IoUring.zig
@@ -549,7 +549,7 @@ const CachedFd = struct {
             .initializing => unreachable,
             _ => |fd| {
                 assert(@intFromEnum(fd) >= 0);
-                std.posix.close(@intFromEnum(fd));
+                _ = std.os.linux.close(@intFromEnum(fd));
                 cached_fd.* = .init;
             },
         }
diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig
index 822c34f789f16bc135a1ca6dab48fe1c7d5a384a..3c9a0cbe1ca569e9d71184617d5fdb822d1f7a25 100644
--- a/lib/std/Io/Kqueue.zig
+++ b/lib/std/Io/Kqueue.zig
@@ -11,6 +11,7 @@ const Allocator = std.mem.Allocator;
 const Alignment = std.mem.Alignment;
 const IpAddress = std.Io.net.IpAddress;
 const errnoBug = std.Io.Threaded.errnoBug;
+const closeFd = std.Io.Threaded.closeFd;
 const posix = std.posix;
 
 /// Must be a thread-safe allocator.
@@ -64,7 +65,7 @@ const Thread = struct {
     };
 
     fn deinit(thread: *Thread, gpa: Allocator) void {
-        posix.close(thread.kq_fd);
+        closeFd(thread.kq_fd);
         assert(thread.wait_queues.count() == 0);
         thread.wait_queues.deinit(gpa);
         thread.* = undefined;
@@ -212,7 +213,7 @@ pub fn init(k: *Kqueue, gpa: Allocator, options: InitOptions) !void {
         .steal_ready_search_index = 1,
         .wait_queues = .empty,
     };
-    errdefer std.posix.close(main_thread.kq_fd);
+    errdefer closeFd(main_thread.kq_fd);
     std.log.debug("created main idle {*}", .{&main_thread.idle_context});
     std.log.debug("created main {*}", .{main_fiber});
 }
@@ -371,7 +372,7 @@ fn schedule(k: *Kqueue, thread: *Thread, ready_queue: Fiber.Queue) void {
             .stack_size = idle_stack_size,
             .allocator = k.gpa,
         }, threadEntry, .{ k, new_thread_index }) catch |err| {
-            posix.close(new_thread.kq_fd);
+            closeFd(new_thread.kq_fd);
             @atomicStore(u32, &k.threads.reserved, new_thread_index, .release);
             // no more access to `thread` after giving up reservation
             std.log.warn("unable to create worker thread due spawn failure: {s}", .{@errorName(err)});
@@ -1234,7 +1235,7 @@ fn netBindIp(
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     const family = Io.Threaded.posixAddressFamily(address);
     const socket_fd = try openSocketPosix(k, family, options);
-    errdefer std.posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
     var storage: Io.Threaded.PosixAddress = undefined;
     var addr_len = Io.Threaded.addressToPosix(address, &storage);
     try posixBind(k, socket_fd, &storage.any, addr_len);
@@ -1252,7 +1253,7 @@ fn netConnectIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: n
         .mode = options.mode,
         .protocol = options.protocol,
     });
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
     var storage: Io.Threaded.PosixAddress = undefined;
     var addr_len = Io.Threaded.addressToPosix(address, &storage);
     try posixConnect(k, socket_fd, &storage.any, addr_len);
@@ -1565,7 +1566,7 @@ fn openSocketPosix(
         switch (posix.errno(socket_rc)) {
             .SUCCESS => {
                 const fd: posix.fd_t = @intCast(socket_rc);
-                errdefer posix.close(fd);
+                errdefer closeFd(fd);
                 if (Io.Threaded.socket_flags_unsupported) {
                     while (true) {
                         try k.checkCancel();
@@ -1614,7 +1615,7 @@ fn openSocketPosix(
             else => |err| return posix.unexpectedErrno(err),
         }
     };
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
 
     if (options.ip6_only) {
         if (posix.IPV6 == void) return error.OptionUnsupported;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index e378797544b6fc4d81a4b3f5fa40b29146c5259f..60ee5df9451529265acfb25ca95e0db1b0862d4e 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -303,7 +303,7 @@ pub const NullFile = switch (native_os) {
 
         fn deinit(this: *@This()) void {
             if (this.fd >= 0) {
-                posix.close(this.fd);
+                closeFd(this.fd);
                 this.fd = -1;
             }
         }
@@ -4337,7 +4337,7 @@ fn dirCreateFilePosix(
             }
         }
     };
-    errdefer posix.close(fd);
+    errdefer closeFd(fd);
 
     if (have_flock and !have_flock_open_flags and flags.lock != .none) {
         const lock_nonblocking: i32 = if (flags.lock_nonblocking) posix.LOCK.NB else 0;
@@ -4917,7 +4917,7 @@ fn dirOpenFilePosix(
             }
         }
     };
-    errdefer posix.close(fd);
+    errdefer closeFd(fd);
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
@@ -5241,7 +5241,7 @@ fn dirOpenFileWasi(
             },
         }
     }
-    errdefer posix.close(fd);
+    errdefer closeFd(fd);
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
@@ -5457,7 +5457,13 @@ pub fn dirOpenDirWindows(
 fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    for (dirs) |dir| posix.close(dir.handle);
+    for (dirs) |dir| {
+        if (is_windows) {
+            windows.CloseHandle(dir.handle);
+        } else {
+            closeFd(dir.handle);
+        }
+    }
 }
 
 const dirRead = switch (native_os) {
@@ -6777,7 +6783,7 @@ fn dirRealPathFilePosix(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, o
             },
         }
     };
-    defer posix.close(fd);
+    defer closeFd(fd);
     return realPathPosix(fd, out_buffer);
 }
 
@@ -8367,7 +8373,7 @@ fn fchmodatFallback(
             }
         }
     };
-    defer posix.close(path_fd);
+    defer closeFd(path_fd);
 
     const path_mode = mode: {
         const sys = if (statx_use_c) std.c else std.os.linux;
@@ -9592,7 +9598,13 @@ fn dirHardLink(
 fn fileClose(userdata: ?*anyopaque, files: []const File) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    for (files) |file| posix.close(file.handle);
+    for (files) |file| {
+        if (is_windows) {
+            windows.CloseHandle(file.handle);
+        } else {
+            closeFd(file.handle);
+        }
+    }
 }
 
 fn fileReadStreaming(userdata: ?*anyopaque, file: File, data: []const []u8) File.ReadStreamingError!usize {
@@ -11783,7 +11795,7 @@ fn netListenIpPosix(
         .mode = options.mode,
         .protocol = options.protocol,
     });
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
 
     if (options.reuse_address) {
         try setSocketOption(socket_fd, posix.SOL.SOCKET, posix.SO.REUSEADDR, 1);
@@ -11946,7 +11958,7 @@ fn netListenUnixPosix(
         error.OptionUnsupported => return error.Unexpected,
         else => |e| return e,
     };
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
 
     var storage: UnixAddress = undefined;
     const addr_len = addressUnixToPosix(address, &storage);
@@ -12362,7 +12374,7 @@ fn netConnectIpPosix(
         .mode = options.mode,
         .protocol = options.protocol,
     });
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
     try posixConnect(socket_fd, &storage.any, addr_len);
@@ -12462,7 +12474,7 @@ fn netConnectUnixPosix(
         error.OptionUnsupported => return error.Unexpected,
         else => |e| return e,
     };
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
     var storage: UnixAddress = undefined;
     const addr_len = addressUnixToPosix(address, &storage);
     try posixConnectUnix(socket_fd, &storage.any, addr_len);
@@ -12536,7 +12548,7 @@ fn netBindIpPosix(
     _ = t;
     const family = posixAddressFamily(address);
     const socket_fd = try openSocketPosix(family, options);
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
     try posixBind(socket_fd, &storage.any, addr_len);
@@ -12642,7 +12654,7 @@ fn openSocketPosix(
             .SUCCESS => {
                 syscall.finish();
                 const fd: posix.fd_t = @intCast(rc);
-                errdefer posix.close(fd);
+                errdefer closeFd(fd);
                 if (socket_flags_unsupported) try setCloexec(fd);
                 break fd;
             },
@@ -12661,7 +12673,7 @@ fn openSocketPosix(
             else => |err| return syscall.unexpectedErrno(err),
         }
     };
-    errdefer posix.close(socket_fd);
+    errdefer closeFd(socket_fd);
 
     if (options.ip6_only) {
         if (posix.IPV6 == void) return error.OptionUnsupported;
@@ -12707,8 +12719,8 @@ fn netSocketCreatePair(
         .SUCCESS => {
             syscall.finish();
             errdefer {
-                posix.close(sockets[0]);
-                posix.close(sockets[1]);
+                closeFd(sockets[0]);
+                closeFd(sockets[1]);
             }
             if (socket_flags_unsupported) {
                 try setCloexec(sockets[0]);
@@ -12809,7 +12821,7 @@ fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Serve
             .SUCCESS => {
                 syscall.finish();
                 const fd: posix.fd_t = @intCast(rc);
-                errdefer posix.close(fd);
+                errdefer closeFd(fd);
                 if (!have_accept4) try setCloexec(fd);
                 break fd;
             },
@@ -13679,7 +13691,7 @@ fn netClose(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
     _ = t;
     switch (native_os) {
         .windows => for (handles) |handle| closeSocketWindows(handle),
-        else => for (handles) |handle| posix.close(handle),
+        else => for (handles) |handle| closeFd(handle),
     }
 }
 
@@ -13787,7 +13799,7 @@ fn netInterfaceNameResolve(
             error.OptionUnsupported => return error.Unexpected,
             else => |e| return e,
         };
-        defer posix.close(sock_fd);
+        defer closeFd(sock_fd);
 
         var ifr: posix.ifreq = .{
             .ifrn = .{ .name = @bitCast(name.bytes) },
@@ -15329,13 +15341,13 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     const pid: posix.pid_t = @intCast(pid_result); // We are the parent.
     errdefer comptime unreachable; // The child is forked; we must not error from now on
 
-    posix.close(err_pipe[1]); // make sure only the child holds the write end open
+    closeFd(err_pipe[1]); // make sure only the child holds the write end open
 
-    if (options.stdin == .pipe) posix.close(stdin_pipe[0]);
-    if (options.stdout == .pipe) posix.close(stdout_pipe[1]);
-    if (options.stderr == .pipe) posix.close(stderr_pipe[1]);
+    if (options.stdin == .pipe) closeFd(stdin_pipe[0]);
+    if (options.stdout == .pipe) closeFd(stdout_pipe[1]);
+    if (options.stderr == .pipe) closeFd(stderr_pipe[1]);
 
-    if (prog_pipe[1] != -1) posix.close(prog_pipe[1]);
+    if (prog_pipe[1] != -1) closeFd(prog_pipe[1]);
     options.progress_node.setIpcFile(t, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
 
     return .{
@@ -15373,7 +15385,7 @@ fn getDevNullFd(t: *Threaded) !posix.fd_t {
                 mutexLock(&t.mutex); // Another thread might have won the race.
                 defer mutexUnlock(&t.mutex);
                 if (t.null_file.fd != -1) {
-                    posix.close(fresh_fd);
+                    closeFd(fresh_fd);
                     return t.null_file.fd;
                 } else {
                     t.null_file.fd = fresh_fd;
@@ -15399,7 +15411,7 @@ fn getDevNullFd(t: *Threaded) !posix.fd_t {
 fn processSpawnPosix(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const spawned = try spawnPosix(t, options);
-    defer posix.close(spawned.err_fd);
+    defer closeFd(spawned.err_fd);
 
     // Wait for the child to report any errors in or before `execvpe`.
     if (readIntFd(spawned.err_fd)) |child_err_int| {
@@ -15666,15 +15678,15 @@ fn childKillPosix(child: *process.Child) !void {
 
 fn childCleanupPosix(child: *process.Child) void {
     if (child.stdin) |*stdin| {
-        posix.close(stdin.handle);
+        closeFd(stdin.handle);
         child.stdin = null;
     }
     if (child.stdout) |*stdout| {
-        posix.close(stdout.handle);
+        closeFd(stdout.handle);
         child.stdout = null;
     }
     if (child.stderr) |*stderr| {
-        posix.close(stderr.handle);
+        closeFd(stderr.handle);
         child.stderr = null;
     }
     child.id = null;
@@ -15743,14 +15755,14 @@ fn readIntFd(fd: posix.fd_t) !ErrInt {
 const ErrInt = std.meta.Int(.unsigned, @sizeOf(anyerror) * 8);
 
 fn destroyPipe(pipe: [2]posix.fd_t) void {
-    if (pipe[0] != -1) posix.close(pipe[0]);
-    if (pipe[0] != pipe[1]) posix.close(pipe[1]);
+    if (pipe[0] != -1) closeFd(pipe[0]);
+    if (pipe[0] != pipe[1]) closeFd(pipe[1]);
 }
 
 fn setUpChildIo(stdio: process.SpawnOptions.StdIo, pipe_fd: i32, std_fileno: i32, dev_null_fd: i32) !void {
     switch (stdio) {
         .pipe => try dup2(pipe_fd, std_fileno),
-        .close => posix.close(std_fileno),
+        .close => closeFd(std_fileno),
         .inherit => {},
         .ignore => try dup2(dev_null_fd, std_fileno),
         .file => @panic("TODO implement setUpChildIo when file is used"),
@@ -17439,7 +17451,7 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
             }
         }
     };
-    errdefer posix.close(fd);
+    errdefer closeFd(fd);
 
     switch (native_os) {
         .linux => {
@@ -17454,7 +17466,7 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                         mutexLock(&t.mutex); // Another thread might have won the race.
                         defer mutexUnlock(&t.mutex);
                         if (t.random_file.fd >= 0) {
-                            posix.close(fd);
+                            closeFd(fd);
                             return t.random_file.fd;
                         } else if (!posix.S.ISCHR(statx.mode)) {
                             t.random_file.fd = -2;
@@ -17482,7 +17494,7 @@ fn getRandomFd(t: *Threaded) Io.RandomSecureError!posix.fd_t {
                         mutexLock(&t.mutex); // Another thread might have won the race.
                         defer mutexUnlock(&t.mutex);
                         if (t.random_file.fd >= 0) {
-                            posix.close(fd);
+                            closeFd(fd);
                             return t.random_file.fd;
                         } else if (!posix.S.ISCHR(stat.mode)) {
                             t.random_file.fd = -2;
@@ -18170,8 +18182,8 @@ pub fn pipe2(flags: posix.O) PipeError![2]posix.fd_t {
         else => |err| return posix.unexpectedErrno(err),
     }
     errdefer {
-        posix.close(fds[0]);
-        posix.close(fds[1]);
+        closeFd(fds[0]);
+        closeFd(fds[1]);
     }
 
     // https://github.com/ziglang/zig/issues/18882
@@ -19164,3 +19176,17 @@ fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows
         }
     }
 }
+
+pub fn closeFd(fd: posix.fd_t) void {
+    if (native_os == .wasi and !builtin.link_libc) {
+        switch (std.os.wasi.fd_close(fd)) {
+            .SUCCESS, .INTR => {},
+            .BADF => recoverableOsBugDetected(), // use after free
+            else => recoverableOsBugDetected(), // unexpected failure
+        }
+    } else switch (posix.errno(posix.system.close(fd))) {
+        .SUCCESS, .INTR => {}, // INTR still a success, see https://github.com/ziglang/zig/issues/2425
+        .BADF => recoverableOsBugDetected(), // use after free
+        else => recoverableOsBugDetected(), // unexpected failure
+    }
+}
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index a0e066b54654f7b164aa697aa582f1b30f29148e..32dd627e09ebdb29e7871b13f4d0ac3a1fe94fb2 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1571,7 +1571,7 @@ pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
     return syscall2(.clone, flags, child_stack_ptr);
 }
 
-pub fn close(fd: i32) usize {
+pub fn close(fd: fd_t) usize {
     return syscall1(.close, @as(usize, @bitCast(@as(isize, fd))));
 }
 
diff --git a/lib/std/os/linux/IoUring.zig b/lib/std/os/linux/IoUring.zig
index 5afb5d248c918608205877a8be653f18452924ec..77fda7389dbc08924833c3e96ea1985be3cb3283 100644
--- a/lib/std/os/linux/IoUring.zig
+++ b/lib/std/os/linux/IoUring.zig
@@ -67,7 +67,7 @@ pub fn init_params(entries: u16, p: *linux.io_uring_params) !IoUring {
     }
     const fd = @as(linux.fd_t, @intCast(res));
     assert(fd >= 0);
-    errdefer posix.close(fd);
+    errdefer _ = linux.close(fd);
 
     // Kernel versions 5.4 and up use only one mmap() for the submission and completion queues.
     // This is not an optional feature for us... if the kernel does it, we have to do it.
@@ -125,7 +125,7 @@ pub fn deinit(self: *IoUring) void {
     // The mmaps depend on the fd, so the order of these calls is important:
     self.cq.deinit();
     self.sq.deinit();
-    posix.close(self.fd);
+    _ = linux.close(self.fd);
     self.fd = -1;
 }
 
diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig
index 240a60c2e7a59b555bd2954e2c6b07e1239db4e9..c75253a80fc4c1df1d2cd94e51ffdd102cedfe3e 100644
--- a/lib/std/os/linux/IoUring/test.zig
+++ b/lib/std/os/linux/IoUring/test.zig
@@ -440,7 +440,7 @@ test "openat" {
     try testing.expect(cqe_openat.res > 0);
     try testing.expectEqual(@as(u32, 0), cqe_openat.flags);
 
-    posix.close(cqe_openat.res);
+    _ = linux.close(cqe_openat.res);
 }
 
 test "close" {
@@ -530,7 +530,7 @@ test "sendmsg/recvmsg" {
     };
 
     const server = try socket(address_server.family, posix.SOCK.DGRAM, 0);
-    defer posix.close(server);
+    defer _ = linux.close(server);
     try posix.setsockopt(server, posix.SOL.SOCKET, posix.SO.REUSEPORT, &mem.toBytes(@as(c_int, 1)));
     try posix.setsockopt(server, posix.SOL.SOCKET, posix.SO.REUSEADDR, &mem.toBytes(@as(c_int, 1)));
     try bind(server, addrAny(&address_server), @sizeOf(linux.sockaddr.in));
@@ -540,7 +540,7 @@ test "sendmsg/recvmsg" {
     try getsockname(server, addrAny(&address_server), &slen);
 
     const client = try socket(address_server.family, posix.SOCK.DGRAM, 0);
-    defer posix.close(client);
+    defer _ = linux.close(client);
 
     const buffer_send = [_]u8{42} ** 128;
     const iovecs_send = [_]iovec_const{
@@ -1034,7 +1034,7 @@ test "shutdown" {
     // Socket bound, expect shutdown to work
     {
         const server = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-        defer posix.close(server);
+        defer _ = linux.close(server);
         try posix.setsockopt(server, posix.SOL.SOCKET, posix.SO.REUSEADDR, &mem.toBytes(@as(c_int, 1)));
         try bind(server, addrAny(&address), @sizeOf(linux.sockaddr.in));
         try listen(server, 1);
@@ -1067,7 +1067,7 @@ test "shutdown" {
     // Socket not bound, expect to fail with ENOTCONN
     {
         const server = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-        defer posix.close(server);
+        defer _ = linux.close(server);
 
         const shutdown_sqe = ring.shutdown(0x445445445, server, linux.SHUT.RD) catch |err| switch (err) {
             else => |errno| std.debug.panic("unhandled errno: {}", .{errno}),
@@ -1741,7 +1741,7 @@ test "accept multishot" {
         .addr = @bitCast([4]u8{ 127, 0, 0, 1 }),
     };
     const listener_socket = try createListenerSocket(&address);
-    defer posix.close(listener_socket);
+    defer _ = linux.close(listener_socket);
 
     // submit multishot accept operation
     var addr: posix.sockaddr = undefined;
@@ -1754,7 +1754,7 @@ test "accept multishot" {
     while (nr > 0) : (nr -= 1) {
         // connect client
         const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-        errdefer posix.close(client);
+        errdefer _ = linux.close(client);
         try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
 
         // test accept completion
@@ -1764,7 +1764,7 @@ test "accept multishot" {
         try testing.expect(cqe.user_data == userdata);
         try testing.expect(cqe.flags & linux.IORING_CQE_F_MORE > 0); // more flag is set
 
-        posix.close(client);
+        _ = linux.close(client);
     }
 }
 
@@ -1848,7 +1848,7 @@ test "accept_direct" {
     try ring.register_files(registered_fds[0..]);
 
     const listener_socket = try createListenerSocket(&address);
-    defer posix.close(listener_socket);
+    defer _ = linux.close(listener_socket);
 
     const accept_userdata: u64 = 0xaaaaaaaa;
     const read_userdata: u64 = 0xbbbbbbbb;
@@ -1866,7 +1866,7 @@ test "accept_direct" {
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
             try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
-            defer posix.close(client);
+            defer _ = linux.close(client);
 
             // accept completion
             const cqe_accept = try ring.copy_cqe();
@@ -1900,7 +1900,7 @@ test "accept_direct" {
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
             try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
-            defer posix.close(client);
+            defer _ = linux.close(client);
             // completion with error
             const cqe_accept = try ring.copy_cqe();
             try testing.expect(cqe_accept.user_data == accept_userdata);
@@ -1936,7 +1936,7 @@ test "accept_multishot_direct" {
     try ring.register_files(registered_fds[0..]);
 
     const listener_socket = try createListenerSocket(&address);
-    defer posix.close(listener_socket);
+    defer _ = linux.close(listener_socket);
 
     const accept_userdata: u64 = 0xaaaaaaaa;
 
@@ -1950,7 +1950,7 @@ test "accept_multishot_direct" {
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
             try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
-            defer posix.close(client);
+            defer _ = linux.close(client);
 
             // accept completion
             const cqe_accept = try ring.copy_cqe();
@@ -1965,7 +1965,7 @@ test "accept_multishot_direct" {
             // connect
             const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
             try connect(client, addrAny(&address), @sizeOf(linux.sockaddr.in));
-            defer posix.close(client);
+            defer _ = linux.close(client);
             // completion with error
             const cqe_accept = try ring.copy_cqe();
             try testing.expect(cqe_accept.user_data == accept_userdata);
@@ -1998,7 +1998,7 @@ test "socket" {
     const fd: linux.fd_t = @intCast(cqe.res);
     try testing.expect(fd > 2);
 
-    posix.close(fd);
+    _ = linux.close(fd);
 }
 
 test "socket_direct/socket_direct_alloc/close_direct" {
@@ -2042,7 +2042,7 @@ test "socket_direct/socket_direct_alloc/close_direct" {
         .addr = @bitCast([4]u8{ 127, 0, 0, 1 }),
     };
     const listener_socket = try createListenerSocket(&address);
-    defer posix.close(listener_socket);
+    defer _ = linux.close(listener_socket);
     const accept_userdata: u64 = 0xaaaaaaaa;
     const connect_userdata: u64 = 0xbbbbbbbb;
     const close_userdata: u64 = 0xcccccccc;
@@ -2599,8 +2599,8 @@ pub const SocketTestHarness = struct {
     client: posix.socket_t,
 
     pub fn close(self: SocketTestHarness) void {
-        posix.close(self.client);
-        posix.close(self.listener);
+        _ = linux.close(self.client);
+        _ = linux.close(self.listener);
     }
 };
 
@@ -2611,7 +2611,7 @@ pub fn createSocketTestHarness(ring: *IoUring) !SocketTestHarness {
         .addr = @bitCast([4]u8{ 127, 0, 0, 1 }),
     };
     const listener_socket = try createListenerSocket(&address);
-    errdefer posix.close(listener_socket);
+    errdefer _ = linux.close(listener_socket);
 
     // Submit 1 accept
     var accept_addr: posix.sockaddr = undefined;
@@ -2620,7 +2620,7 @@ pub fn createSocketTestHarness(ring: *IoUring) !SocketTestHarness {
 
     // Create a TCP client socket
     const client = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-    errdefer posix.close(client);
+    errdefer _ = linux.close(client);
     _ = try ring.connect(0xcccccccc, client, addrAny(&address), @sizeOf(linux.sockaddr.in));
 
     try testing.expectEqual(@as(u32, 2), try ring.submit());
@@ -2660,7 +2660,7 @@ pub fn createSocketTestHarness(ring: *IoUring) !SocketTestHarness {
 fn createListenerSocket(address: *linux.sockaddr.in) !posix.socket_t {
     const kernel_backlog = 1;
     const listener_socket = try socket(address.family, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
-    errdefer posix.close(listener_socket);
+    errdefer _ = linux.close(listener_socket);
 
     try posix.setsockopt(listener_socket, posix.SOL.SOCKET, posix.SO.REUSEADDR, &mem.toBytes(@as(c_int, 1)));
     try bind(listener_socket, addrAny(address), @sizeOf(linux.sockaddr.in));
diff --git a/lib/std/os/linux/test.zig b/lib/std/os/linux/test.zig
index 974ce0a25c7993f1dff45471e40fe9f2d1b5d287..63e0d2f96a22b8373881d9b559e6851d36c26652 100644
--- a/lib/std/os/linux/test.zig
+++ b/lib/std/os/linux/test.zig
@@ -407,6 +407,42 @@ test "futex2_requeue" {
     try expectEqual(0, rc);
 }
 
+test "timerfd" {
+    const tfd: linux.fd_t = rc: {
+        const rc = linux.timerfd_create(.MONOTONIC, .{ .CLOEXEC = true });
+        switch (linux.errno(rc)) {
+            .SUCCESS => break :rc @intCast(rc),
+            else => @panic("test failed"),
+        }
+    };
+    defer _ = linux.close(tfd);
+
+    // Fire event 10_000_000ns = 10ms after the posix.timerfd_settime call.
+    var sit: linux.itimerspec = .{ .it_interval = .{ .sec = 0, .nsec = 0 }, .it_value = .{ .sec = 0, .nsec = 10 * (1000 * 1000) } };
+    const flags: linux.TFD.TIMER = .{};
+    switch (linux.errno(linux.timerfd_settime(tfd, @bitCast(flags), &sit, null))) {
+        .SUCCESS => {},
+        else => @panic("test failed"),
+    }
+
+    var fds: [1]std.posix.pollfd = .{.{ .fd = tfd, .events = linux.POLL.IN, .revents = 0 }};
+    try expectEqual(@as(usize, 1), try std.posix.poll(&fds, -1)); // -1 => infinite waiting
+
+    const git = rc: {
+        var curr_value: linux.itimerspec = undefined;
+        const rc = linux.timerfd_gettime(tfd, &curr_value);
+        switch (linux.errno(rc)) {
+            .SUCCESS => break :rc curr_value,
+            else => @panic("test failed"),
+        }
+    };
+    const expect_disarmed_timer: linux.itimerspec = .{
+        .it_interval = .{ .sec = 0, .nsec = 0 },
+        .it_value = .{ .sec = 0, .nsec = 0 },
+    };
+    try expectEqual(expect_disarmed_timer, git);
+}
+
 test {
     _ = linux.IoUring;
 }
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index 1742325026ed269ef38c78ddb61d80ec750e8390..1e92b39c6f3dada511381bb5c70893c50ed65ad4 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -278,30 +278,6 @@ pub const socket_t = if (native_os == .windows) windows.ws2_32.SOCKET else fd_t;
 /// the system function call whose errno value is intended to be observed.
 pub const errno = system.errno;
 
-/// Closes the file descriptor.
-///
-/// Asserts the file descriptor is open.
-///
-/// This function is not capable of returning any indication of failure. An
-/// application which wants to ensure writes have succeeded before closing must
-/// call `fsync` before `close`.
-///
-/// The Zig standard library does not support POSIX thread cancellation.
-pub fn close(fd: fd_t) void {
-    if (native_os == .windows) {
-        return windows.CloseHandle(fd);
-    }
-    if (native_os == .wasi and !builtin.link_libc) {
-        _ = std.os.wasi.fd_close(fd);
-        return;
-    }
-    switch (errno(system.close(fd))) {
-        .BADF => unreachable, // Always a race condition.
-        .INTR => return, // This is still a success. See https://github.com/ziglang/zig/issues/2425
-        else => return,
-    }
-}
-
 pub const RebootError = error{
     PermissionDenied,
 } || UnexpectedError;
@@ -1541,60 +1517,6 @@ pub fn perf_event_open(
     }
 }
 
-pub const TimerFdCreateError = error{
-    PermissionDenied,
-    ProcessFdQuotaExceeded,
-    SystemFdQuotaExceeded,
-    NoDevice,
-    SystemResources,
-} || UnexpectedError;
-
-pub const TimerFdGetError = error{InvalidHandle} || UnexpectedError;
-pub const TimerFdSetError = TimerFdGetError || error{Canceled};
-
-pub fn timerfd_create(clock_id: system.timerfd_clockid_t, flags: system.TFD) TimerFdCreateError!fd_t {
-    const rc = system.timerfd_create(clock_id, @bitCast(flags));
-    return switch (errno(rc)) {
-        .SUCCESS => @intCast(rc),
-        .INVAL => unreachable,
-        .MFILE => return error.ProcessFdQuotaExceeded,
-        .NFILE => return error.SystemFdQuotaExceeded,
-        .NODEV => return error.NoDevice,
-        .NOMEM => return error.SystemResources,
-        .PERM => return error.PermissionDenied,
-        else => |err| return unexpectedErrno(err),
-    };
-}
-
-pub fn timerfd_settime(
-    fd: i32,
-    flags: system.TFD.TIMER,
-    new_value: *const system.itimerspec,
-    old_value: ?*system.itimerspec,
-) TimerFdSetError!void {
-    const rc = system.timerfd_settime(fd, @bitCast(flags), new_value, old_value);
-    return switch (errno(rc)) {
-        .SUCCESS => {},
-        .BADF => error.InvalidHandle,
-        .FAULT => unreachable,
-        .INVAL => unreachable,
-        .CANCELED => error.Canceled,
-        else => |err| return unexpectedErrno(err),
-    };
-}
-
-pub fn timerfd_gettime(fd: i32) TimerFdGetError!system.itimerspec {
-    var curr_value: system.itimerspec = undefined;
-    const rc = system.timerfd_gettime(fd, &curr_value);
-    return switch (errno(rc)) {
-        .SUCCESS => return curr_value,
-        .BADF => error.InvalidHandle,
-        .FAULT => unreachable,
-        .INVAL => unreachable,
-        else => |err| return unexpectedErrno(err),
-    };
-}
-
 pub const PtraceError = error{
     DeadLock,
     DeviceBusy,
diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig
index e2a52473f3862ea1332a82abd0d0ab98d428b153..96d4515dcc14236b99d3f3de4bc6468a5d8ff396 100644
--- a/lib/std/posix/test.zig
+++ b/lib/std/posix/test.zig
@@ -522,21 +522,3 @@ test "rename smoke test" {
         try expectError(error.FileNotFound, Io.Dir.cwd().openDir(io, file_path, .{}));
     }
 }
-
-test "timerfd" {
-    if (native_os != .linux) return error.SkipZigTest;
-
-    const tfd = try posix.timerfd_create(.MONOTONIC, .{ .CLOEXEC = true });
-    defer posix.close(tfd);
-
-    // Fire event 10_000_000ns = 10ms after the posix.timerfd_settime call.
-    var sit: linux.itimerspec = .{ .it_interval = .{ .sec = 0, .nsec = 0 }, .it_value = .{ .sec = 0, .nsec = 10 * (1000 * 1000) } };
-    try posix.timerfd_settime(tfd, .{}, &sit, null);
-
-    var fds: [1]posix.pollfd = .{.{ .fd = tfd, .events = linux.POLL.IN, .revents = 0 }};
-    try expectEqual(@as(usize, 1), try posix.poll(&fds, -1)); // -1 => infinite waiting
-
-    const git = try posix.timerfd_gettime(tfd);
-    const expect_disarmed_timer: linux.itimerspec = .{ .it_interval = .{ .sec = 0, .nsec = 0 }, .it_value = .{ .sec = 0, .nsec = 0 } };
-    try expectEqual(expect_disarmed_timer, git);
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index ff359a1e93599e400ccddce477a0d6ede9c4d289..8cdc4a966f2bdad68f5623543d651255df9fcd98 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -1830,7 +1830,6 @@ const src_files = [_][]const u8{
     "musl/src/time/wcsftime.c",
     "musl/src/time/__year_to_secs.c",
     "musl/src/unistd/alarm.c",
-    "musl/src/unistd/close.c",
     "musl/src/unistd/dup2.c",
     "musl/src/unistd/dup3.c",
     "musl/src/unistd/faccessat.c",
@@ -1849,7 +1848,6 @@ const src_files = [_][]const u8{
     "musl/src/unistd/nice.c",
     "musl/src/unistd/pause.c",
     "musl/src/unistd/pipe2.c",
-    "musl/src/unistd/posix_close.c",
     "musl/src/unistd/pread.c",
     "musl/src/unistd/preadv.c",
     "musl/src/unistd/pwrite.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 49090795eca86f7e9d290a8c7e04bab75795197e..ca6231bf53344375ac78b809dcfe749b5a482b7c 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -999,7 +999,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/time/strptime.c",
     "musl/src/time/timespec_get.c",
     "musl/src/time/__year_to_secs.c",
-    "musl/src/unistd/posix_close.c",
 
     "wasi/libc-top-half/musl/src/conf/fpathconf.c",
     "wasi/libc-top-half/musl/src/conf/sysconf.c",
-- 
2.54.0


From 13f31bb3c319813cbc3ed461ad9a97ec1c379f11 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Wed, 11 Feb 2026 15:29:51 -0800
Subject: [PATCH 263/499] std/c: glibc has supported arc4random_buf since 2.36

---
 lib/std/c.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index 809ce29a472e61529c8c079ac24d8c71d5745ca2..169e6d73b5fbd52e3ccbbb0b0650b4780c3ecb04 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -10357,7 +10357,10 @@ pub extern "c" fn sendfile64(out_fd: fd_t, in_fd: fd_t, offset: ?*i64, count: us
 pub extern "c" fn setrlimit64(resource: rlimit_resource, rlim: *const rlimit) c_int;
 
 pub const arc4random_buf = switch (native_os) {
-    .linux => if (builtin.abi.isAndroid()) private.arc4random_buf else {},
+    .linux => if (builtin.abi.isAndroid() or
+        (builtin.abi.isGnu() and versionCheck(.{ .major = 2, .minor = 36, .patch = 0 })))
+        private.arc4random_buf
+    else {},
     .dragonfly, .netbsd, .freebsd, .illumos, .openbsd, .serenity, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => private.arc4random_buf,
     else => {},
 };
-- 
2.54.0


From 251f54d1d7d0f871f551c54d77f1a8238a041983 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Thu, 12 Feb 2026 12:59:22 -0500
Subject: [PATCH 264/499] crash_report: finish reverting panic changes

---
 src/crash_report.zig | 57 +++++++++++++++++++++++++++-----------------
 src/main.zig         |  9 +++----
 2 files changed, 40 insertions(+), 26 deletions(-)

diff --git a/src/crash_report.zig b/src/crash_report.zig
index 41d56e8aaf4637130b97ee6cc79c3aa623c4770c..1723ad24a0b255cc580fa62f5b5e0906709f880e 100644
--- a/src/crash_report.zig
+++ b/src/crash_report.zig
@@ -1,14 +1,31 @@
+/// We override the panic implementation to our own one, so we can print our own information before
+/// calling the default panic handler. This declaration must be re-exposed from `@import("root")`.
+pub const panic = std.debug.FullPanic(panicImpl);
+
+/// We let std install its segfault handler, but we override the target-agnostic handler it calls,
+/// so we can print our own information before calling the default segfault logic. This declaration
+/// must be re-exposed from `@import("root")`.
+pub const debug = struct {
+    pub const handleSegfault = handleSegfaultImpl;
+};
+
 /// Printed in panic messages when suggesting a command to run, allowing copy-pasting the command.
 /// Set by `main` as soon as arguments are known. The value here is a default in case we somehow
 /// crash earlier than that.
 pub var zig_argv0: []const u8 = "zig";
 
-const enabled = switch (build_options.io_mode) {
-    .threaded => build_options.enable_debug_extensions,
-    .evented => false, // would use threadlocals in a way incompatible with evented
-};
+fn handleSegfaultImpl(addr: ?usize, name: []const u8, opt_ctx: ?std.debug.CpuContextPtr) noreturn {
+    @branchHint(.cold);
+    dumpCrashContext() catch {};
+    std.debug.defaultHandleSegfault(addr, name, opt_ctx);
+}
+fn panicImpl(msg: []const u8, first_trace_addr: ?usize) noreturn {
+    @branchHint(.cold);
+    dumpCrashContext() catch {};
+    std.debug.defaultPanic(msg, first_trace_addr orelse @returnAddress());
+}
 
-pub const AnalyzeBody = if (enabled) struct {
+pub const AnalyzeBody = struct {
     parent: ?*AnalyzeBody,
     sema: *Sema,
     block: *Sema.Block,
@@ -35,15 +52,9 @@ pub const AnalyzeBody = if (enabled) struct {
         std.debug.assert(current.? == ab); // `Sema.analyzeBodyInner` did not match push/pop calls
         current = ab.parent;
     }
-} else struct {
-    const current: ?noreturn = null;
-    // Dummy implementation, with functions marked `inline` to avoid interfering with tail calls.
-    pub inline fn push(_: AnalyzeBody, _: *Sema, _: *Sema.Block, _: []const Zir.Inst.Index) void {}
-    pub inline fn pop(_: AnalyzeBody) void {}
-    pub inline fn setBodyIndex(_: @This(), _: usize) void {}
 };
 
-pub const CodegenFunc = if (enabled) struct {
+pub const CodegenFunc = struct {
     zcu: *const Zcu,
     func_index: InternPool.Index,
     threadlocal var current: ?CodegenFunc = null;
@@ -55,21 +66,25 @@ pub const CodegenFunc = if (enabled) struct {
         std.debug.assert(current.?.func_index == func_index);
         current = null;
     }
-} else struct {
-    const current: ?noreturn = null;
-    // Dummy implementation
-    pub fn start(_: *const Zcu, _: InternPool.Index) void {}
-    pub fn stop(_: InternPool.Index) void {}
 };
 
-pub fn dumpCrashContext(terminal: Io.Terminal) Io.Writer.Error!void {
+fn dumpCrashContext() Io.Writer.Error!void {
     const S = struct {
+        /// In the case of recursive panics or segfaults, don't print the context for a second time.
+        threadlocal var already_dumped = false;
         /// TODO: make this unnecessary. It exists because `print_zir` currently needs an allocator,
         /// but that shouldn't be necessary---it's already only used in one place.
-        var crash_heap: [64 * 1024]u8 = undefined;
+        threadlocal var crash_heap: [64 * 1024]u8 = undefined;
     };
+    if (S.already_dumped) return;
+    S.already_dumped = true;
+
+    // TODO: this does mean that a different thread could grab the stderr mutex between the context
+    // and the actual panic printing, which would be quite confusing.
+    const stderr = std.debug.lockStderr(&.{});
+    defer std.debug.unlockStderr();
+    const w = &stderr.file_writer.interface;
 
-    const w = terminal.writer;
     try w.writeAll("Compiler crash context:\n");
 
     if (CodegenFunc.current) |*cg| {
@@ -155,5 +170,3 @@ const Zcu = @import("Zcu.zig");
 const InternPool = @import("InternPool.zig");
 const dev = @import("dev.zig");
 const print_zir = @import("print_zir.zig");
-
-const build_options = @import("build_options");
diff --git a/src/main.zig b/src/main.zig
index 82a1fcf0503c1c88eb074d4334d85ebd00cfa30a..89a24559ed7a89ea3732f22277a6595c8f1e4606 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -52,11 +52,12 @@ pub const std_options: std.Options = .{
 };
 pub const std_options_cwd = if (native_os == .wasi) wasi_cwd else null;
 
-pub const debug = struct {
-    pub fn printCrashContext(terminal: Io.Terminal) void {
-        crash_report.dumpCrashContext(terminal) catch {};
-    }
+const crash_report_enabled = switch (build_options.io_mode) {
+    .threaded => build_options.enable_debug_extensions,
+    .evented => false, // would use threadlocals in a way incompatible with evented
 };
+pub const panic = if (crash_report_enabled) crash_report.panic else std.debug.FullPanic(std.debug.defaultPanic);
+pub const debug = if (crash_report_enabled) crash_report.debug else struct {};
 
 var preopens: std.process.Preopens = .empty;
 pub fn wasi_cwd() Io.Dir {
-- 
2.54.0


From 0a61eca22c5628b0a56d875246fc4ef007a3bad9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 13:53:26 -0800
Subject: [PATCH 265/499] bump max_rss for module tests

---
 build.zig | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/build.zig b/build.zig
index bd1fd2d046ad4470ace4946605f1f17e4960693a..5eba8f82db9fe1567cf81dae1495499b8e627bf3 100644
--- a/build.zig
+++ b/build.zig
@@ -560,22 +560,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = switch (b.graph.host.result.os.tag) {
-            .freebsd => switch (b.graph.host.result.cpu.arch) {
-                .x86_64 => 3_756_422_348,
-                else => 3_800_000_000,
-            },
-            .linux => 6_800_000_000,
-            .macos => switch (b.graph.host.result.cpu.arch) {
-                .aarch64 => 8_273_795_481,
-                else => 8_300_000_000,
-            },
-            .windows => switch (b.graph.host.result.cpu.arch) {
-                .x86_64 => 3_750_236_160,
-                else => 3_800_000_000,
-            },
-            else => 8_300_000_000,
-        },
+        .max_rss = 8_500_000_000,
     }));
 
     const unit_tests_step = b.step("test-unit", "Run the compiler source unit tests");
-- 
2.54.0


From 5c59a4623898cdb15b569f59fba49d48a7b9600f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 19:41:37 -0800
Subject: [PATCH 266/499] std.heap.PageAllocator: fix not respecting alignments

in remap and resize, alignments larger than page size were incorrectly ignored.
---
 lib/std/heap/PageAllocator.zig | 41 ++++++++++++++++------------------
 lib/std/heap/SmpAllocator.zig  |  4 ++--
 2 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/lib/std/heap/PageAllocator.zig b/lib/std/heap/PageAllocator.zig
index 4ca3ec944fc5f47ebb61dba0360afdf21c0b76ce..bed9be54493cd11a01458b3a53eceacdb4cfaa3d 100644
--- a/lib/std/heap/PageAllocator.zig
+++ b/lib/std/heap/PageAllocator.zig
@@ -1,19 +1,17 @@
-const std = @import("../std.zig");
 const builtin = @import("builtin");
+const native_os = builtin.os.tag;
+
+const std = @import("../std.zig");
 const Allocator = std.mem.Allocator;
+const Alignment = std.mem.Alignment;
 const mem = std.mem;
 const maxInt = std.math.maxInt;
 const assert = std.debug.assert;
-const native_os = builtin.os.tag;
 const windows = std.os.windows;
-const ntdll = windows.ntdll;
+const ntdll = std.os.windows.ntdll;
 const posix = std.posix;
 const page_size_min = std.heap.page_size_min;
 
-const SUCCESS = @import("../os/windows/ntstatus.zig").NTSTATUS.SUCCESS;
-const MEM_RESERVE_PLACEHOLDER = windows.MEM_RESERVE_PLACEHOLDER;
-const MEM_PRESERVE_PLACEHOLDER = windows.MEM_PRESERVE_PLACEHOLDER;
-
 pub const vtable: Allocator.VTable = .{
     .alloc = alloc,
     .resize = resize,
@@ -21,7 +19,7 @@ pub const vtable: Allocator.VTable = .{
     .free = free,
 };
 
-pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
+pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
     const page_size = std.heap.pageSize();
     if (n >= maxInt(usize) - page_size) return null;
     const alignment_bytes = alignment.toByteUnits();
@@ -33,11 +31,11 @@ pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
         const current_process = windows.GetCurrentProcess();
         var status = ntdll.NtAllocateVirtualMemory(current_process, @ptrCast(&base_addr), 0, &size, .{ .COMMIT = true, .RESERVE = true }, .{ .READWRITE = true });
 
-        if (status == SUCCESS and mem.isAligned(@intFromPtr(base_addr), alignment_bytes)) {
+        if (status == .SUCCESS and mem.isAligned(@intFromPtr(base_addr), alignment_bytes)) {
             return @ptrCast(base_addr);
         }
 
-        if (status == SUCCESS) {
+        if (status == .SUCCESS) {
             var region_size: windows.SIZE_T = 0;
             _ = ntdll.NtFreeVirtualMemory(current_process, @ptrCast(&base_addr), &region_size, .{ .RELEASE = true });
         }
@@ -50,7 +48,7 @@ pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
 
         status = ntdll.NtAllocateVirtualMemory(current_process, @ptrCast(&base_addr), 0, &size, .{ .RESERVE = true, .RESERVE_PLACEHOLDER = true }, .{ .NOACCESS = true });
 
-        if (status != SUCCESS) return null;
+        if (status != .SUCCESS) return null;
 
         const placeholder_addr = @intFromPtr(base_addr);
         const aligned_addr = mem.alignForward(usize, placeholder_addr, alignment_bytes);
@@ -75,7 +73,7 @@ pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
 
         status = ntdll.NtAllocateVirtualMemory(current_process, @ptrCast(&base_addr), 0, &size, .{ .COMMIT = true }, .{ .READWRITE = true });
 
-        if (status == SUCCESS) {
+        if (status == .SUCCESS) {
             return @ptrCast(base_addr);
         }
 
@@ -116,31 +114,29 @@ pub fn map(n: usize, alignment: mem.Alignment) ?[*]u8 {
     return result_ptr;
 }
 
-fn alloc(context: *anyopaque, n: usize, alignment: mem.Alignment, ra: usize) ?[*]u8 {
+fn alloc(context: *anyopaque, n: usize, alignment: Alignment, ra: usize) ?[*]u8 {
     _ = context;
     _ = ra;
     assert(n > 0);
     return map(n, alignment);
 }
 
-fn resize(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len: usize, return_address: usize) bool {
+fn resize(context: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, return_address: usize) bool {
     _ = context;
-    _ = alignment;
     _ = return_address;
-    return realloc(memory, new_len, false) != null;
+    return realloc(memory, alignment, new_len, false) != null;
 }
 
-fn remap(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len: usize, return_address: usize) ?[*]u8 {
+fn remap(context: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, return_address: usize) ?[*]u8 {
     _ = context;
-    _ = alignment;
     _ = return_address;
-    return realloc(memory, new_len, true);
+    return realloc(memory, alignment, new_len, true);
 }
 
-fn free(context: *anyopaque, memory: []u8, alignment: mem.Alignment, return_address: usize) void {
+fn free(context: *anyopaque, memory: []u8, alignment: Alignment, return_address: usize) void {
     _ = context;
-    _ = alignment;
     _ = return_address;
+    _ = alignment;
     return unmap(@alignCast(memory));
 }
 
@@ -155,9 +151,10 @@ pub fn unmap(memory: []align(page_size_min) u8) void {
     }
 }
 
-pub fn realloc(uncasted_memory: []u8, new_len: usize, may_move: bool) ?[*]u8 {
+pub fn realloc(uncasted_memory: []u8, alignment: Alignment, new_len: usize, may_move: bool) ?[*]u8 {
     const memory: []align(page_size_min) u8 = @alignCast(uncasted_memory);
     const page_size = std.heap.pageSize();
+    if (alignment.toByteUnits() > page_size) return null;
     const new_size_aligned = mem.alignForward(usize, new_len, page_size);
 
     if (native_os == .windows) {
diff --git a/lib/std/heap/SmpAllocator.zig b/lib/std/heap/SmpAllocator.zig
index e51e4975b68dce33c3c9d2e78691f8b9bec32159..50380d29b534e5c7d41a32c0c9d74af4efad3f08 100644
--- a/lib/std/heap/SmpAllocator.zig
+++ b/lib/std/heap/SmpAllocator.zig
@@ -179,7 +179,7 @@ fn resize(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len:
     const new_class = sizeClassIndex(new_len, alignment);
     if (class >= size_class_count) {
         if (new_class < size_class_count) return false;
-        return PageAllocator.realloc(memory, new_len, false) != null;
+        return PageAllocator.realloc(memory, alignment, new_len, false) != null;
     }
     return new_class == class;
 }
@@ -191,7 +191,7 @@ fn remap(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len: u
     const new_class = sizeClassIndex(new_len, alignment);
     if (class >= size_class_count) {
         if (new_class < size_class_count) return null;
-        return PageAllocator.realloc(memory, new_len, true);
+        return PageAllocator.realloc(memory, alignment, new_len, true);
     }
     return if (new_class == class) memory.ptr else null;
 }
-- 
2.54.0


From 6744160211b2ab480e4c479e46440c76f00c1810 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 10 Feb 2026 17:37:33 -0800
Subject: [PATCH 267/499] zig libc: implement malloc

---
 lib/c.zig                                     |   13 +-
 lib/c/malloc.zig                              |  182 ++
 lib/libc/musl/src/malloc/calloc.c             |   45 -
 lib/libc/musl/src/malloc/free.c               |    6 -
 lib/libc/musl/src/malloc/libc_calloc.c        |    4 -
 lib/libc/musl/src/malloc/lite_malloc.c        |  118 --
 .../musl/src/malloc/mallocng/aligned_alloc.c  |   60 -
 lib/libc/musl/src/malloc/mallocng/donate.c    |   39 -
 lib/libc/musl/src/malloc/mallocng/free.c      |  151 --
 lib/libc/musl/src/malloc/mallocng/glue.h      |   95 -
 lib/libc/musl/src/malloc/mallocng/malloc.c    |  387 -----
 .../src/malloc/mallocng/malloc_usable_size.c  |   13 -
 lib/libc/musl/src/malloc/mallocng/meta.h      |  288 ---
 lib/libc/musl/src/malloc/mallocng/realloc.c   |   51 -
 lib/libc/musl/src/malloc/memalign.c           |    7 -
 .../musl/src/malloc/oldmalloc/aligned_alloc.c |   53 -
 lib/libc/musl/src/malloc/oldmalloc/malloc.c   |  556 ------
 .../musl/src/malloc/oldmalloc/malloc_impl.h   |   39 -
 .../src/malloc/oldmalloc/malloc_usable_size.c |    9 -
 lib/libc/musl/src/malloc/posix_memalign.c     |   11 -
 lib/libc/musl/src/malloc/realloc.c            |    6 -
 lib/libc/musl/src/malloc/reallocarray.c       |   13 -
 lib/libc/musl/src/malloc/replaced.c           |    4 -
 lib/libc/wasi/emmalloc/emmalloc.c             | 1540 -----------------
 lib/std/heap/SmpAllocator.zig                 |   13 +-
 src/libs/musl.zig                             |   21 +-
 src/libs/wasi_libc.zig                        |   20 -
 27 files changed, 198 insertions(+), 3546 deletions(-)
 create mode 100644 lib/c/malloc.zig
 delete mode 100644 lib/libc/musl/src/malloc/calloc.c
 delete mode 100644 lib/libc/musl/src/malloc/free.c
 delete mode 100644 lib/libc/musl/src/malloc/libc_calloc.c
 delete mode 100644 lib/libc/musl/src/malloc/lite_malloc.c
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/aligned_alloc.c
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/donate.c
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/free.c
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/glue.h
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/malloc.c
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/malloc_usable_size.c
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/meta.h
 delete mode 100644 lib/libc/musl/src/malloc/mallocng/realloc.c
 delete mode 100644 lib/libc/musl/src/malloc/memalign.c
 delete mode 100644 lib/libc/musl/src/malloc/oldmalloc/aligned_alloc.c
 delete mode 100644 lib/libc/musl/src/malloc/oldmalloc/malloc.c
 delete mode 100644 lib/libc/musl/src/malloc/oldmalloc/malloc_impl.h
 delete mode 100644 lib/libc/musl/src/malloc/oldmalloc/malloc_usable_size.c
 delete mode 100644 lib/libc/musl/src/malloc/posix_memalign.c
 delete mode 100644 lib/libc/musl/src/malloc/realloc.c
 delete mode 100644 lib/libc/musl/src/malloc/reallocarray.c
 delete mode 100644 lib/libc/musl/src/malloc/replaced.c
 delete mode 100644 lib/libc/wasi/emmalloc/emmalloc.c

diff --git a/lib/c.zig b/lib/c.zig
index c25293b84dc9424e8373cd325ccb12ba875eb618..8b181dc1184b6504085de5adaf2ce04f639ec25c 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -47,19 +47,22 @@ pub fn errno(syscall_return_value: usize) c_int {
 }
 
 comptime {
-    _ = @import("c/inttypes.zig");
     _ = @import("c/ctype.zig");
-    _ = @import("c/stdlib.zig");
+    _ = @import("c/inttypes.zig");
+    if (!builtin.target.isMinGW()) {
+        _ = @import("c/malloc.zig");
+    }
     _ = @import("c/math.zig");
+    _ = @import("c/stdlib.zig");
     _ = @import("c/string.zig");
     _ = @import("c/strings.zig");
-    _ = @import("c/wchar.zig");
 
-    _ = @import("c/sys/mman.zig");
+    _ = @import("c/sys/capability.zig");
     _ = @import("c/sys/file.zig");
+    _ = @import("c/sys/mman.zig");
     _ = @import("c/sys/reboot.zig");
-    _ = @import("c/sys/capability.zig");
     _ = @import("c/sys/utsname.zig");
 
     _ = @import("c/unistd.zig");
+    _ = @import("c/wchar.zig");
 }
diff --git a/lib/c/malloc.zig b/lib/c/malloc.zig
new file mode 100644
index 0000000000000000000000000000000000000000..72e7621b61057fdb1c31737c0af3c0b0262d53c0
--- /dev/null
+++ b/lib/c/malloc.zig
@@ -0,0 +1,182 @@
+//! Based on wrapping a stateless Zig Allocator implementation, apropriate for:
+//! - ReleaseFast and ReleaseSmall optimization modes, with multi-threading
+//!   enabled.
+//! - WebAssembly in single-threaded mode.
+//!
+//! Because the libc APIs don't have client alignment and size tracking, in
+//! order to take advantage of Zig allocator implementations, additional
+//! metadata must be stored in the allocations.
+//!
+//! This implementation stores the metadata just before the pointer returned
+//! from `malloc`, just like many libc malloc implementations do, including
+//! musl. This has the downside of causing fragmentation for allocations with
+//! higher alignment, however most of that memory can be recovered by
+//! preemptively putting the gap onto the freelist.
+const builtin = @import("builtin");
+
+const std = @import("std");
+const assert = std.debug.assert;
+const Alignment = std.mem.Alignment;
+const alignment_bytes = @max(@alignOf(std.c.max_align_t), @sizeOf(Header));
+const alignment: Alignment = .fromByteUnits(alignment_bytes);
+
+const symbol = @import("../c.zig").symbol;
+
+comptime {
+    symbol(&malloc, "malloc");
+    symbol(&aligned_alloc, "aligned_alloc");
+    symbol(&posix_memalign, "posix_memalign");
+    symbol(&calloc, "calloc");
+    symbol(&realloc, "realloc");
+    symbol(&reallocarray, "reallocarray");
+    symbol(&free, "free");
+    symbol(&malloc_usable_size, "malloc_usable_size");
+
+    symbol(&valloc, "valloc");
+    symbol(&memalign, "memalign");
+}
+
+const no_context: *anyopaque = undefined;
+const no_ra: usize = undefined;
+const vtable = switch (builtin.cpu.arch) {
+    .wasm32, .wasm64 => std.heap.WasmAllocator.vtable,
+    else => std.heap.SmpAllocator.vtable,
+};
+
+/// Needed because libc memory allocators don't provide old alignment and size
+/// which are required by Zig memory allocators.
+const Header = packed struct(u64) {
+    alignment: Alignment,
+    /// Does not include the extra alignment bytes added.
+    size: Size,
+    padding: Padding = 0,
+
+    comptime {
+        assert(@sizeOf(Header) <= alignment_bytes);
+    }
+
+    const Size = @Int(.unsigned, @min(64 - @bitSizeOf(Alignment), @bitSizeOf(usize)));
+    const Padding = @Int(.unsigned, 64 - @bitSizeOf(Alignment) - @bitSizeOf(Size));
+
+    fn fromBase(base: [*]align(alignment_bytes) u8) *Header {
+        return @ptrCast(base - @sizeOf(Header));
+    }
+};
+
+fn malloc(n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    const size = std.math.cast(Header.Size, n) orelse return null;
+    const ptr: [*]align(alignment_bytes) u8 = @alignCast(
+        vtable.alloc(no_context, n + alignment_bytes, alignment, no_ra) orelse return null,
+    );
+    const base = ptr + alignment_bytes;
+    const header: *Header = .fromBase(base);
+    header.* = .{
+        .alignment = alignment,
+        .size = size,
+    };
+    return base;
+}
+
+fn aligned_alloc(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    const size = std.math.cast(Header.Size, n) orelse return null;
+    const max_align = alignment.max(.fromByteUnits(alloc_alignment));
+    const max_align_bytes = max_align.toByteUnits();
+    const ptr: [*]align(alignment_bytes) u8 = @alignCast(
+        vtable.alloc(no_context, n + max_align_bytes, max_align, no_ra) orelse return null,
+    );
+    const base: [*]align(alignment_bytes) u8 = @alignCast(ptr + max_align_bytes);
+    const header: *Header = .fromBase(base);
+    header.* = .{
+        .alignment = max_align,
+        .size = size,
+    };
+    return base;
+}
+
+fn calloc(elems: usize, len: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    const n = std.math.mul(usize, elems, len) catch return null;
+    const base = malloc(n) orelse return null;
+    @memset(base[0..n], 0);
+    return base;
+}
+
+fn realloc(opt_old_base: ?[*]align(alignment_bytes) u8, n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    if (n == 0) {
+        free(opt_old_base);
+        return null;
+    }
+    const old_base = opt_old_base orelse return malloc(n);
+    const new_size = std.math.cast(Header.Size, n) orelse return null;
+    const old_header: *Header = .fromBase(old_base);
+    assert(old_header.padding == 0);
+    const old_size = old_header.size;
+    const old_alignment = old_header.alignment;
+    const old_alignment_bytes = old_alignment.toByteUnits();
+    const old_ptr = old_base - old_alignment_bytes;
+    const old_slice = old_ptr[0 .. old_size + old_alignment_bytes];
+    const new_base: [*]align(alignment_bytes) u8 = if (vtable.remap(
+        no_context,
+        old_slice,
+        old_alignment,
+        n + old_alignment_bytes,
+        no_ra,
+    )) |new_ptr| @alignCast(new_ptr + old_alignment_bytes) else b: {
+        const new_ptr: [*]align(alignment_bytes) u8 = @alignCast(
+            vtable.alloc(no_context, n + old_alignment_bytes, old_alignment, no_ra) orelse return null,
+        );
+        const new_base: [*]align(alignment_bytes) u8 = @alignCast(new_ptr + old_alignment_bytes);
+        const copy_len = @min(new_size, old_size);
+        @memcpy(new_base[0..copy_len], old_base[0..copy_len]);
+        vtable.free(no_context, old_slice, old_alignment, no_ra);
+        break :b new_base;
+    };
+    const new_header: *Header = .fromBase(new_base);
+    new_header.* = .{
+        .alignment = old_alignment,
+        .size = new_size,
+    };
+    return new_base;
+}
+
+fn reallocarray(opt_base: ?[*]align(alignment_bytes) u8, elems: usize, len: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    const n = std.math.mul(usize, elems, len) catch return null;
+    return realloc(opt_base, n);
+}
+
+fn free(opt_old_base: ?[*]align(alignment_bytes) u8) callconv(.c) void {
+    const old_base = opt_old_base orelse return;
+    const old_header: *Header = .fromBase(old_base);
+    assert(old_header.padding == 0);
+    const old_size = old_header.size;
+    const old_alignment = old_header.alignment;
+    const old_alignment_bytes = old_alignment.toByteUnits();
+    const old_ptr = old_base - old_alignment_bytes;
+    const old_slice = old_ptr[0 .. old_size + old_alignment_bytes];
+    vtable.free(no_context, old_slice, old_alignment, no_ra);
+}
+
+fn malloc_usable_size(opt_old_base: ?[*]align(alignment_bytes) u8) callconv(.c) usize {
+    const old_base = opt_old_base orelse return 0;
+    const old_header: *Header = .fromBase(old_base);
+    assert(old_header.padding == 0);
+    const old_size = old_header.size;
+    return old_size;
+}
+
+fn valloc(n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    return aligned_alloc(std.heap.pageSize(), n);
+}
+
+fn memalign(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    return aligned_alloc(alloc_alignment, n);
+}
+
+fn posix_memalign(result: *?[*]align(alignment_bytes) u8, alloc_alignment: usize, n: usize) callconv(.c) c_int {
+    if (alloc_alignment < @sizeOf(*anyopaque)) return @intFromEnum(std.c.E.INVAL);
+    if (n == 0) {
+        result.* = null;
+    } else {
+        result.* = aligned_alloc(alloc_alignment, n) orelse return @intFromEnum(std.c.E.NOMEM);
+    }
+    return 0;
+}
diff --git a/lib/libc/musl/src/malloc/calloc.c b/lib/libc/musl/src/malloc/calloc.c
deleted file mode 100644
index bf6bddca3fd81aca3b246391e34ea9afbc95ed3e..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/calloc.c
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <errno.h>
-#include "dynlink.h"
-
-static size_t mal0_clear(char *p, size_t n)
-{
-	const size_t pagesz = 4096; /* arbitrary */
-	if (n < pagesz) return n;
-#ifdef __GNUC__
-	typedef uint64_t __attribute__((__may_alias__)) T;
-#else
-	typedef unsigned char T;
-#endif
-	char *pp = p + n;
-	size_t i = (uintptr_t)pp & (pagesz - 1);
-	for (;;) {
-		pp = memset(pp - i, 0, i);
-		if (pp - p < pagesz) return pp - p;
-		for (i = pagesz; i; i -= 2*sizeof(T), pp -= 2*sizeof(T))
-		        if (((T *)pp)[-1] | ((T *)pp)[-2])
-				break;
-	}
-}
-
-static int allzerop(void *p)
-{
-	return 0;
-}
-weak_alias(allzerop, __malloc_allzerop);
-
-void *calloc(size_t m, size_t n)
-{
-	if (n && m > (size_t)-1/n) {
-		errno = ENOMEM;
-		return 0;
-	}
-	n *= m;
-	void *p = malloc(n);
-	if (!p || (!__malloc_replaced && __malloc_allzerop(p)))
-		return p;
-	n = mal0_clear(p, n);
-	return memset(p, 0, n);
-}
diff --git a/lib/libc/musl/src/malloc/free.c b/lib/libc/musl/src/malloc/free.c
deleted file mode 100644
index 3944f7b28f3c3265cb092cf984c69e89f62f435a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/free.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdlib.h>
-
-void free(void *p)
-{
-	__libc_free(p);
-}
diff --git a/lib/libc/musl/src/malloc/libc_calloc.c b/lib/libc/musl/src/malloc/libc_calloc.c
deleted file mode 100644
index d25eabea47f563d8d1dc5b93d55bc976cb64e1cf..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/libc_calloc.c
+++ /dev/null
@@ -1,4 +0,0 @@
-#define calloc __libc_calloc
-#define malloc __libc_malloc
-
-#include "calloc.c"
diff --git a/lib/libc/musl/src/malloc/lite_malloc.c b/lib/libc/musl/src/malloc/lite_malloc.c
deleted file mode 100644
index 43a988fbb8adcc3c6469c21b9a4ad13018f2758b..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/lite_malloc.c
+++ /dev/null
@@ -1,118 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <limits.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include "libc.h"
-#include "lock.h"
-#include "syscall.h"
-#include "fork_impl.h"
-
-#define ALIGN 16
-
-/* This function returns true if the interval [old,new]
- * intersects the 'len'-sized interval below &libc.auxv
- * (interpreted as the main-thread stack) or below &b
- * (the current stack). It is used to defend against
- * buggy brk implementations that can cross the stack. */
-
-static int traverses_stack_p(uintptr_t old, uintptr_t new)
-{
-	const uintptr_t len = 8<<20;
-	uintptr_t a, b;
-
-	b = (uintptr_t)libc.auxv;
-	a = b > len ? b-len : 0;
-	if (new>a && old<b) return 1;
-
-	b = (uintptr_t)&b;
-	a = b > len ? b-len : 0;
-	if (new>a && old<b) return 1;
-
-	return 0;
-}
-
-static volatile int lock[1];
-volatile int *const __bump_lockptr = lock;
-
-static void *__simple_malloc(size_t n)
-{
-	static uintptr_t brk, cur, end;
-	static unsigned mmap_step;
-	size_t align=1;
-	void *p;
-
-	if (n > SIZE_MAX/2) {
-		errno = ENOMEM;
-		return 0;
-	}
-
-	if (!n) n++;
-	while (align<n && align<ALIGN)
-		align += align;
-
-	LOCK(lock);
-
-	cur += -cur & align-1;
-
-	if (n > end-cur) {
-		size_t req = n - (end-cur) + PAGE_SIZE-1 & -PAGE_SIZE;
-
-		if (!cur) {
-			brk = __syscall(SYS_brk, 0);
-			brk += -brk & PAGE_SIZE-1;
-			cur = end = brk;
-		}
-
-		if (brk == end && req < SIZE_MAX-brk
-		    && !traverses_stack_p(brk, brk+req)
-		    && __syscall(SYS_brk, brk+req)==brk+req) {
-			brk = end += req;
-		} else {
-			int new_area = 0;
-			req = n + PAGE_SIZE-1 & -PAGE_SIZE;
-			/* Only make a new area rather than individual mmap
-			 * if wasted space would be over 1/8 of the map. */
-			if (req-n > req/8) {
-				/* Geometric area size growth up to 64 pages,
-				 * bounding waste by 1/8 of the area. */
-				size_t min = PAGE_SIZE<<(mmap_step/2);
-				if (min-n > end-cur) {
-					if (req < min) {
-						req = min;
-						if (mmap_step < 12)
-							mmap_step++;
-					}
-					new_area = 1;
-				}
-			}
-			void *mem = __mmap(0, req, PROT_READ|PROT_WRITE,
-				MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
-			if (mem == MAP_FAILED || !new_area) {
-				UNLOCK(lock);
-				return mem==MAP_FAILED ? 0 : mem;
-			}
-			cur = (uintptr_t)mem;
-			end = cur + req;
-		}
-	}
-
-	p = (void *)cur;
-	cur += n;
-	UNLOCK(lock);
-	return p;
-}
-
-weak_alias(__simple_malloc, __libc_malloc_impl);
-
-void *__libc_malloc(size_t n)
-{
-	return __libc_malloc_impl(n);
-}
-
-static void *default_malloc(size_t n)
-{
-	return __libc_malloc_impl(n);
-}
-
-weak_alias(default_malloc, malloc);
diff --git a/lib/libc/musl/src/malloc/mallocng/aligned_alloc.c b/lib/libc/musl/src/malloc/mallocng/aligned_alloc.c
deleted file mode 100644
index e0862a83ae00444734417d97dea6b4a679e557df..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/aligned_alloc.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdlib.h>
-#include <errno.h>
-#include "meta.h"
-
-void *aligned_alloc(size_t align, size_t len)
-{
-	if ((align & -align) != align) {
-		errno = EINVAL;
-		return 0;
-	}
-
-	if (len > SIZE_MAX - align || align >= (1ULL<<31)*UNIT) {
-		errno = ENOMEM;
-		return 0;
-	}
-
-	if (DISABLE_ALIGNED_ALLOC) {
-		errno = ENOMEM;
-		return 0;
-	}
-
-	if (align <= UNIT) align = UNIT;
-
-	unsigned char *p = malloc(len + align - UNIT);
-	if (!p)
-		return 0;
-
-	struct meta *g = get_meta(p);
-	int idx = get_slot_index(p);
-	size_t stride = get_stride(g);
-	unsigned char *start = g->mem->storage + stride*idx;
-	unsigned char *end = g->mem->storage + stride*(idx+1) - IB;
-	size_t adj = -(uintptr_t)p & (align-1);
-
-	if (!adj) {
-		set_size(p, end, len);
-		return p;
-	}
-	p += adj;
-	uint32_t offset = (size_t)(p-g->mem->storage)/UNIT;
-	if (offset <= 0xffff) {
-		*(uint16_t *)(p-2) = offset;
-		p[-4] = 0;
-	} else {
-		// use a 32-bit offset if 16-bit doesn't fit. for this,
-		// 16-bit field must be zero, [-4] byte nonzero.
-		*(uint16_t *)(p-2) = 0;
-		*(uint32_t *)(p-8) = offset;
-		p[-4] = 1;
-	}
-	p[-3] = idx;
-	set_size(p, end, len);
-	// store offset to aligned enframing. this facilitates cycling
-	// offset and also iteration of heap for debugging/measurement.
-	// for extreme overalignment it won't fit but these are classless
-	// allocations anyway.
-	*(uint16_t *)(start - 2) = (size_t)(p-start)/UNIT;
-	start[-3] = 7<<5;
-	return p;
-}
diff --git a/lib/libc/musl/src/malloc/mallocng/donate.c b/lib/libc/musl/src/malloc/mallocng/donate.c
deleted file mode 100644
index 41d850f357e332f2ec24c198385d39258df4b921..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/donate.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <limits.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <errno.h>
-
-#include "meta.h"
-
-static void donate(unsigned char *base, size_t len)
-{
-	uintptr_t a = (uintptr_t)base;
-	uintptr_t b = a + len;
-	a += -a & (UNIT-1);
-	b -= b & (UNIT-1);
-	memset(base, 0, len);
-	for (int sc=47; sc>0 && b>a; sc-=4) {
-		if (b-a < (size_classes[sc]+1)*UNIT) continue;
-		struct meta *m = alloc_meta();
-		m->avail_mask = 0;
-		m->freed_mask = 1;
-		m->mem = (void *)a;
-		m->mem->meta = m;
-		m->last_idx = 0;
-		m->freeable = 0;
-		m->sizeclass = sc;
-		m->maplen = 0;
-		*((unsigned char *)m->mem+UNIT-4) = 0;
-		*((unsigned char *)m->mem+UNIT-3) = 255;
-		m->mem->storage[size_classes[sc]*UNIT-4] = 0;
-		queue(&ctx.active[sc], m);
-		a += (size_classes[sc]+1)*UNIT;
-	}
-}
-
-void __malloc_donate(char *start, char *end)
-{
-	donate((void *)start, end-start);
-}
diff --git a/lib/libc/musl/src/malloc/mallocng/free.c b/lib/libc/musl/src/malloc/mallocng/free.c
deleted file mode 100644
index 43f32aade86b62b99baac87435ee5fb5ef43080c..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/free.c
+++ /dev/null
@@ -1,151 +0,0 @@
-#define _BSD_SOURCE
-#include <stdlib.h>
-#include <sys/mman.h>
-
-#include "meta.h"
-
-struct mapinfo {
-	void *base;
-	size_t len;
-};
-
-static struct mapinfo nontrivial_free(struct meta *, int);
-
-static struct mapinfo free_group(struct meta *g)
-{
-	struct mapinfo mi = { 0 };
-	int sc = g->sizeclass;
-	if (sc < 48) {
-		ctx.usage_by_class[sc] -= g->last_idx+1;
-	}
-	if (g->maplen) {
-		step_seq();
-		record_seq(sc);
-		mi.base = g->mem;
-		mi.len = g->maplen*4096UL;
-	} else {
-		void *p = g->mem;
-		struct meta *m = get_meta(p);
-		int idx = get_slot_index(p);
-		g->mem->meta = 0;
-		// not checking size/reserved here; it's intentionally invalid
-		mi = nontrivial_free(m, idx);
-	}
-	free_meta(g);
-	return mi;
-}
-
-static int okay_to_free(struct meta *g)
-{
-	int sc = g->sizeclass;
-
-	if (!g->freeable) return 0;
-
-	// always free individual mmaps not suitable for reuse
-	if (sc >= 48 || get_stride(g) < UNIT*size_classes[sc])
-		return 1;
-
-	// always free groups allocated inside another group's slot
-	// since recreating them should not be expensive and they
-	// might be blocking freeing of a much larger group.
-	if (!g->maplen) return 1;
-
-	// if there is another non-full group, free this one to
-	// consolidate future allocations, reduce fragmentation.
-	if (g->next != g) return 1;
-
-	// free any group in a size class that's not bouncing
-	if (!is_bouncing(sc)) return 1;
-
-	size_t cnt = g->last_idx+1;
-	size_t usage = ctx.usage_by_class[sc];
-
-	// if usage is high enough that a larger count should be
-	// used, free the low-count group so a new one will be made.
-	if (9*cnt <= usage && cnt < 20)
-		return 1;
-
-	// otherwise, keep the last group in a bouncing class.
-	return 0;
-}
-
-static struct mapinfo nontrivial_free(struct meta *g, int i)
-{
-	uint32_t self = 1u<<i;
-	int sc = g->sizeclass;
-	uint32_t mask = g->freed_mask | g->avail_mask;
-
-	if (mask+self == (2u<<g->last_idx)-1 && okay_to_free(g)) {
-		// any multi-slot group is necessarily on an active list
-		// here, but single-slot groups might or might not be.
-		if (g->next) {
-			assert(sc < 48);
-			int activate_new = (ctx.active[sc]==g);
-			dequeue(&ctx.active[sc], g);
-			if (activate_new && ctx.active[sc])
-				activate_group(ctx.active[sc]);
-		}
-		return free_group(g);
-	} else if (!mask) {
-		assert(sc < 48);
-		// might still be active if there were no allocations
-		// after last available slot was taken.
-		if (ctx.active[sc] != g) {
-			queue(&ctx.active[sc], g);
-		}
-	}
-	a_or(&g->freed_mask, self);
-	return (struct mapinfo){ 0 };
-}
-
-void free(void *p)
-{
-	if (!p) return;
-
-	struct meta *g = get_meta(p);
-	int idx = get_slot_index(p);
-	size_t stride = get_stride(g);
-	unsigned char *start = g->mem->storage + stride*idx;
-	unsigned char *end = start + stride - IB;
-	get_nominal_size(p, end);
-	uint32_t self = 1u<<idx, all = (2u<<g->last_idx)-1;
-	((unsigned char *)p)[-3] = 255;
-	// invalidate offset to group header, and cycle offset of
-	// used region within slot if current offset is zero.
-	*(uint16_t *)((char *)p-2) = 0;
-
-	// release any whole pages contained in the slot to be freed
-	// unless it's a single-slot group that will be unmapped.
-	if (((uintptr_t)(start-1) ^ (uintptr_t)end) >= 2*PGSZ && g->last_idx) {
-		unsigned char *base = start + (-(uintptr_t)start & (PGSZ-1));
-		size_t len = (end-base) & -PGSZ;
-		if (len && USE_MADV_FREE) {
-			int e = errno;
-			madvise(base, len, MADV_FREE);
-			errno = e;
-		}
-	}
-
-	// atomic free without locking if this is neither first or last slot
-	for (;;) {
-		uint32_t freed = g->freed_mask;
-		uint32_t avail = g->avail_mask;
-		uint32_t mask = freed | avail;
-		assert(!(mask&self));
-		if (!freed || mask+self==all) break;
-		if (!MT)
-			g->freed_mask = freed+self;
-		else if (a_cas(&g->freed_mask, freed, freed+self)!=freed)
-			continue;
-		return;
-	}
-
-	wrlock();
-	struct mapinfo mi = nontrivial_free(g, idx);
-	unlock();
-	if (mi.len) {
-		int e = errno;
-		munmap(mi.base, mi.len);
-		errno = e;
-	}
-}
diff --git a/lib/libc/musl/src/malloc/mallocng/glue.h b/lib/libc/musl/src/malloc/mallocng/glue.h
deleted file mode 100644
index 77f4c812b20a77bea56596d0b0bb82626cc34853..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/glue.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#ifndef MALLOC_GLUE_H
-#define MALLOC_GLUE_H
-
-#include <stdint.h>
-#include <sys/mman.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <elf.h>
-#include <string.h>
-#include "atomic.h"
-#include "syscall.h"
-#include "libc.h"
-#include "lock.h"
-#include "dynlink.h"
-
-// use macros to appropriately namespace these.
-#define size_classes __malloc_size_classes
-#define ctx __malloc_context
-#define alloc_meta __malloc_alloc_meta
-#define is_allzero __malloc_allzerop
-#define dump_heap __dump_heap
-
-#define malloc __libc_malloc_impl
-#define realloc __libc_realloc
-#define free __libc_free
-
-#define USE_MADV_FREE 0
-
-#if USE_REAL_ASSERT
-#include <assert.h>
-#else
-#undef assert
-#define assert(x) do { if (!(x)) a_crash(); } while(0)
-#endif
-
-#define brk(p) ((uintptr_t)__syscall(SYS_brk, p))
-
-#define mmap __mmap
-#define madvise __madvise
-#define mremap __mremap
-
-#define DISABLE_ALIGNED_ALLOC (__malloc_replaced && !__aligned_alloc_replaced)
-
-static inline uint64_t get_random_secret()
-{
-	uint64_t secret = (uintptr_t)&secret * 1103515245;
-	for (size_t i=0; libc.auxv[i]; i+=2)
-		if (libc.auxv[i]==AT_RANDOM)
-			memcpy(&secret, (char *)libc.auxv[i+1]+8, sizeof secret);
-	return secret;
-}
-
-#ifndef PAGESIZE
-#define PAGESIZE PAGE_SIZE
-#endif
-
-#define MT (libc.need_locks)
-
-#define RDLOCK_IS_EXCLUSIVE 1
-
-__attribute__((__visibility__("hidden")))
-extern int __malloc_lock[1];
-
-#define LOCK_OBJ_DEF \
-int __malloc_lock[1]; \
-void __malloc_atfork(int who) { malloc_atfork(who); }
-
-static inline void rdlock()
-{
-	if (MT) LOCK(__malloc_lock);
-}
-static inline void wrlock()
-{
-	if (MT) LOCK(__malloc_lock);
-}
-static inline void unlock()
-{
-	UNLOCK(__malloc_lock);
-}
-static inline void upgradelock()
-{
-}
-static inline void resetlock()
-{
-	__malloc_lock[0] = 0;
-}
-
-static inline void malloc_atfork(int who)
-{
-	if (who<0) rdlock();
-	else if (who>0) resetlock();
-	else unlock();
-}
-
-#endif
diff --git a/lib/libc/musl/src/malloc/mallocng/malloc.c b/lib/libc/musl/src/malloc/mallocng/malloc.c
deleted file mode 100644
index d695ab8ec98216d3420e41b820f951c9474adca4..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/malloc.c
+++ /dev/null
@@ -1,387 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <limits.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <errno.h>
-
-#include "meta.h"
-
-LOCK_OBJ_DEF;
-
-const uint16_t size_classes[] = {
-	1, 2, 3, 4, 5, 6, 7, 8,
-	9, 10, 12, 15,
-	18, 20, 25, 31,
-	36, 42, 50, 63,
-	72, 84, 102, 127,
-	146, 170, 204, 255,
-	292, 340, 409, 511,
-	584, 682, 818, 1023,
-	1169, 1364, 1637, 2047,
-	2340, 2730, 3276, 4095,
-	4680, 5460, 6552, 8191,
-};
-
-static const uint8_t small_cnt_tab[][3] = {
-	{ 30, 30, 30 },
-	{ 31, 15, 15 },
-	{ 20, 10, 10 },
-	{ 31, 15, 7 },
-	{ 25, 12, 6 },
-	{ 21, 10, 5 },
-	{ 18, 8, 4 },
-	{ 31, 15, 7 },
-	{ 28, 14, 6 },
-};
-
-static const uint8_t med_cnt_tab[4] = { 28, 24, 20, 32 };
-
-struct malloc_context ctx = { 0 };
-
-struct meta *alloc_meta(void)
-{
-	struct meta *m;
-	unsigned char *p;
-	if (!ctx.init_done) {
-#ifndef PAGESIZE
-		ctx.pagesize = get_page_size();
-#endif
-		ctx.secret = get_random_secret();
-		ctx.init_done = 1;
-	}
-	size_t pagesize = PGSZ;
-	if (pagesize < 4096) pagesize = 4096;
-	if ((m = dequeue_head(&ctx.free_meta_head))) return m;
-	if (!ctx.avail_meta_count) {
-		int need_unprotect = 1;
-		if (!ctx.avail_meta_area_count && ctx.brk!=-1) {
-			uintptr_t new = ctx.brk + pagesize;
-			int need_guard = 0;
-			if (!ctx.brk) {
-				need_guard = 1;
-				ctx.brk = brk(0);
-				// some ancient kernels returned _ebss
-				// instead of next page as initial brk.
-				ctx.brk += -ctx.brk & (pagesize-1);
-				new = ctx.brk + 2*pagesize;
-			}
-			if (brk(new) != new) {
-				ctx.brk = -1;
-			} else {
-				if (need_guard) mmap((void *)ctx.brk, pagesize,
-					PROT_NONE, MAP_ANON|MAP_PRIVATE|MAP_FIXED, -1, 0);
-				ctx.brk = new;
-				ctx.avail_meta_areas = (void *)(new - pagesize);
-				ctx.avail_meta_area_count = pagesize>>12;
-				need_unprotect = 0;
-			}
-		}
-		if (!ctx.avail_meta_area_count) {
-			size_t n = 2UL << ctx.meta_alloc_shift;
-			p = mmap(0, n*pagesize, PROT_NONE,
-				MAP_PRIVATE|MAP_ANON, -1, 0);
-			if (p==MAP_FAILED) return 0;
-			ctx.avail_meta_areas = p + pagesize;
-			ctx.avail_meta_area_count = (n-1)*(pagesize>>12);
-			ctx.meta_alloc_shift++;
-		}
-		p = ctx.avail_meta_areas;
-		if ((uintptr_t)p & (pagesize-1)) need_unprotect = 0;
-		if (need_unprotect)
-			if (mprotect(p, pagesize, PROT_READ|PROT_WRITE)
-			    && errno != ENOSYS)
-				return 0;
-		ctx.avail_meta_area_count--;
-		ctx.avail_meta_areas = p + 4096;
-		if (ctx.meta_area_tail) {
-			ctx.meta_area_tail->next = (void *)p;
-		} else {
-			ctx.meta_area_head = (void *)p;
-		}
-		ctx.meta_area_tail = (void *)p;
-		ctx.meta_area_tail->check = ctx.secret;
-		ctx.avail_meta_count = ctx.meta_area_tail->nslots
-			= (4096-sizeof(struct meta_area))/sizeof *m;
-		ctx.avail_meta = ctx.meta_area_tail->slots;
-	}
-	ctx.avail_meta_count--;
-	m = ctx.avail_meta++;
-	m->prev = m->next = 0;
-	return m;
-}
-
-static uint32_t try_avail(struct meta **pm)
-{
-	struct meta *m = *pm;
-	uint32_t first;
-	if (!m) return 0;
-	uint32_t mask = m->avail_mask;
-	if (!mask) {
-		if (!m) return 0;
-		if (!m->freed_mask) {
-			dequeue(pm, m);
-			m = *pm;
-			if (!m) return 0;
-		} else {
-			m = m->next;
-			*pm = m;
-		}
-
-		mask = m->freed_mask;
-
-		// skip fully-free group unless it's the only one
-		// or it's a permanently non-freeable group
-		if (mask == (2u<<m->last_idx)-1 && m->freeable) {
-			m = m->next;
-			*pm = m;
-			mask = m->freed_mask;
-		}
-
-		// activate more slots in a not-fully-active group
-		// if needed, but only as a last resort. prefer using
-		// any other group with free slots. this avoids
-		// touching & dirtying as-yet-unused pages.
-		if (!(mask & ((2u<<m->mem->active_idx)-1))) {
-			if (m->next != m) {
-				m = m->next;
-				*pm = m;
-			} else {
-				int cnt = m->mem->active_idx + 2;
-				int size = size_classes[m->sizeclass]*UNIT;
-				int span = UNIT + size*cnt;
-				// activate up to next 4k boundary
-				while ((span^(span+size-1)) < 4096) {
-					cnt++;
-					span += size;
-				}
-				if (cnt > m->last_idx+1)
-					cnt = m->last_idx+1;
-				m->mem->active_idx = cnt-1;
-			}
-		}
-		mask = activate_group(m);
-		assert(mask);
-		decay_bounces(m->sizeclass);
-	}
-	first = mask&-mask;
-	m->avail_mask = mask-first;
-	return first;
-}
-
-static int alloc_slot(int, size_t);
-
-static struct meta *alloc_group(int sc, size_t req)
-{
-	size_t size = UNIT*size_classes[sc];
-	int i = 0, cnt;
-	unsigned char *p;
-	struct meta *m = alloc_meta();
-	if (!m) return 0;
-	size_t usage = ctx.usage_by_class[sc];
-	size_t pagesize = PGSZ;
-	int active_idx;
-	if (sc < 9) {
-		while (i<2 && 4*small_cnt_tab[sc][i] > usage)
-			i++;
-		cnt = small_cnt_tab[sc][i];
-	} else {
-		// lookup max number of slots fitting in power-of-two size
-		// from a table, along with number of factors of two we
-		// can divide out without a remainder or reaching 1.
-		cnt = med_cnt_tab[sc&3];
-
-		// reduce cnt to avoid excessive eagar allocation.
-		while (!(cnt&1) && 4*cnt > usage)
-			cnt >>= 1;
-
-		// data structures don't support groups whose slot offsets
-		// in units don't fit in 16 bits.
-		while (size*cnt >= 65536*UNIT)
-			cnt >>= 1;
-	}
-
-	// If we selected a count of 1 above but it's not sufficient to use
-	// mmap, increase to 2. Then it might be; if not it will nest.
-	if (cnt==1 && size*cnt+UNIT <= pagesize/2) cnt = 2;
-
-	// All choices of size*cnt are "just below" a power of two, so anything
-	// larger than half the page size should be allocated as whole pages.
-	if (size*cnt+UNIT > pagesize/2) {
-		// check/update bounce counter to start/increase retention
-		// of freed maps, and inhibit use of low-count, odd-size
-		// small mappings and single-slot groups if activated.
-		int nosmall = is_bouncing(sc);
-		account_bounce(sc);
-		step_seq();
-
-		// since the following count reduction opportunities have
-		// an absolute memory usage cost, don't overdo them. count
-		// coarse usage as part of usage.
-		if (!(sc&1) && sc<32) usage += ctx.usage_by_class[sc+1];
-
-		// try to drop to a lower count if the one found above
-		// increases usage by more than 25%. these reduced counts
-		// roughly fill an integral number of pages, just not a
-		// power of two, limiting amount of unusable space.
-		if (4*cnt > usage && !nosmall) {
-			if (0);
-			else if ((sc&3)==1 && size*cnt>8*pagesize) cnt = 2;
-			else if ((sc&3)==2 && size*cnt>4*pagesize) cnt = 3;
-			else if ((sc&3)==0 && size*cnt>8*pagesize) cnt = 3;
-			else if ((sc&3)==0 && size*cnt>2*pagesize) cnt = 5;
-		}
-		size_t needed = size*cnt + UNIT;
-		needed += -needed & (pagesize-1);
-
-		// produce an individually-mmapped allocation if usage is low,
-		// bounce counter hasn't triggered, and either it saves memory
-		// or it avoids eagar slot allocation without wasting too much.
-		if (!nosmall && cnt<=7) {
-			req += IB + UNIT;
-			req += -req & (pagesize-1);
-			if (req<size+UNIT || (req>=4*pagesize && 2*cnt>usage)) {
-				cnt = 1;
-				needed = req;
-			}
-		}
-
-		p = mmap(0, needed, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
-		if (p==MAP_FAILED) {
-			free_meta(m);
-			return 0;
-		}
-		m->maplen = needed>>12;
-		ctx.mmap_counter++;
-		active_idx = (4096-UNIT)/size-1;
-		if (active_idx > cnt-1) active_idx = cnt-1;
-		if (active_idx < 0) active_idx = 0;
-	} else {
-		int j = size_to_class(UNIT+cnt*size-IB);
-		int idx = alloc_slot(j, UNIT+cnt*size-IB);
-		if (idx < 0) {
-			free_meta(m);
-			return 0;
-		}
-		struct meta *g = ctx.active[j];
-		p = enframe(g, idx, UNIT*size_classes[j]-IB, ctx.mmap_counter);
-		m->maplen = 0;
-		p[-3] = (p[-3]&31) | (6<<5);
-		for (int i=0; i<=cnt; i++)
-			p[UNIT+i*size-4] = 0;
-		active_idx = cnt-1;
-	}
-	ctx.usage_by_class[sc] += cnt;
-	m->avail_mask = (2u<<active_idx)-1;
-	m->freed_mask = (2u<<(cnt-1))-1 - m->avail_mask;
-	m->mem = (void *)p;
-	m->mem->meta = m;
-	m->mem->active_idx = active_idx;
-	m->last_idx = cnt-1;
-	m->freeable = 1;
-	m->sizeclass = sc;
-	return m;
-}
-
-static int alloc_slot(int sc, size_t req)
-{
-	uint32_t first = try_avail(&ctx.active[sc]);
-	if (first) return a_ctz_32(first);
-
-	struct meta *g = alloc_group(sc, req);
-	if (!g) return -1;
-
-	g->avail_mask--;
-	queue(&ctx.active[sc], g);
-	return 0;
-}
-
-void *malloc(size_t n)
-{
-	if (size_overflows(n)) return 0;
-	struct meta *g;
-	uint32_t mask, first;
-	int sc;
-	int idx;
-	int ctr;
-
-	if (n >= MMAP_THRESHOLD) {
-		size_t needed = n + IB + UNIT;
-		void *p = mmap(0, needed, PROT_READ|PROT_WRITE,
-			MAP_PRIVATE|MAP_ANON, -1, 0);
-		if (p==MAP_FAILED) return 0;
-		wrlock();
-		step_seq();
-		g = alloc_meta();
-		if (!g) {
-			unlock();
-			munmap(p, needed);
-			return 0;
-		}
-		g->mem = p;
-		g->mem->meta = g;
-		g->last_idx = 0;
-		g->freeable = 1;
-		g->sizeclass = 63;
-		g->maplen = (needed+4095)/4096;
-		g->avail_mask = g->freed_mask = 0;
-		// use a global counter to cycle offset in
-		// individually-mmapped allocations.
-		ctx.mmap_counter++;
-		idx = 0;
-		goto success;
-	}
-
-	sc = size_to_class(n);
-
-	rdlock();
-	g = ctx.active[sc];
-
-	// use coarse size classes initially when there are not yet
-	// any groups of desired size. this allows counts of 2 or 3
-	// to be allocated at first rather than having to start with
-	// 7 or 5, the min counts for even size classes.
-	if (!g && sc>=4 && sc<32 && sc!=6 && !(sc&1) && !ctx.usage_by_class[sc]) {
-		size_t usage = ctx.usage_by_class[sc|1];
-		// if a new group may be allocated, count it toward
-		// usage in deciding if we can use coarse class.
-		if (!ctx.active[sc|1] || (!ctx.active[sc|1]->avail_mask
-		    && !ctx.active[sc|1]->freed_mask))
-			usage += 3;
-		if (usage <= 12)
-			sc |= 1;
-		g = ctx.active[sc];
-	}
-
-	for (;;) {
-		mask = g ? g->avail_mask : 0;
-		first = mask&-mask;
-		if (!first) break;
-		if (RDLOCK_IS_EXCLUSIVE || !MT)
-			g->avail_mask = mask-first;
-		else if (a_cas(&g->avail_mask, mask, mask-first)!=mask)
-			continue;
-		idx = a_ctz_32(first);
-		goto success;
-	}
-	upgradelock();
-
-	idx = alloc_slot(sc, n);
-	if (idx < 0) {
-		unlock();
-		return 0;
-	}
-	g = ctx.active[sc];
-
-success:
-	ctr = ctx.mmap_counter;
-	unlock();
-	return enframe(g, idx, n, ctr);
-}
-
-int is_allzero(void *p)
-{
-	struct meta *g = get_meta(p);
-	return g->sizeclass >= 48 ||
-		get_stride(g) < UNIT*size_classes[g->sizeclass];
-}
diff --git a/lib/libc/musl/src/malloc/mallocng/malloc_usable_size.c b/lib/libc/musl/src/malloc/mallocng/malloc_usable_size.c
deleted file mode 100644
index ce6a960c6f5835d5fd7f16818a139e5d9991edb4..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/malloc_usable_size.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdlib.h>
-#include "meta.h"
-
-size_t malloc_usable_size(void *p)
-{
-	if (!p) return 0;
-	struct meta *g = get_meta(p);
-	int idx = get_slot_index(p);
-	size_t stride = get_stride(g);
-	unsigned char *start = g->mem->storage + stride*idx;
-	unsigned char *end = start + stride - IB;
-	return get_nominal_size(p, end);
-}
diff --git a/lib/libc/musl/src/malloc/mallocng/meta.h b/lib/libc/musl/src/malloc/mallocng/meta.h
deleted file mode 100644
index 61ec53f9a589941c5edb29da0f6fa9342faf42ab..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/meta.h
+++ /dev/null
@@ -1,288 +0,0 @@
-#ifndef MALLOC_META_H
-#define MALLOC_META_H
-
-#include <stdint.h>
-#include <errno.h>
-#include <limits.h>
-#include "glue.h"
-
-__attribute__((__visibility__("hidden")))
-extern const uint16_t size_classes[];
-
-#define MMAP_THRESHOLD 131052
-
-#define UNIT 16
-#define IB 4
-
-struct group {
-	struct meta *meta;
-	unsigned char active_idx:5;
-	char pad[UNIT - sizeof(struct meta *) - 1];
-	unsigned char storage[];
-};
-
-struct meta {
-	struct meta *prev, *next;
-	struct group *mem;
-	volatile int avail_mask, freed_mask;
-	uintptr_t last_idx:5;
-	uintptr_t freeable:1;
-	uintptr_t sizeclass:6;
-	uintptr_t maplen:8*sizeof(uintptr_t)-12;
-};
-
-struct meta_area {
-	uint64_t check;
-	struct meta_area *next;
-	int nslots;
-	struct meta slots[];
-};
-
-struct malloc_context {
-	uint64_t secret;
-#ifndef PAGESIZE
-	size_t pagesize;
-#endif
-	int init_done;
-	unsigned mmap_counter;
-	struct meta *free_meta_head;
-	struct meta *avail_meta;
-	size_t avail_meta_count, avail_meta_area_count, meta_alloc_shift;
-	struct meta_area *meta_area_head, *meta_area_tail;
-	unsigned char *avail_meta_areas;
-	struct meta *active[48];
-	size_t usage_by_class[48];
-	uint8_t unmap_seq[32], bounces[32];
-	uint8_t seq;
-	uintptr_t brk;
-};
-
-__attribute__((__visibility__("hidden")))
-extern struct malloc_context ctx;
-
-#ifdef PAGESIZE
-#define PGSZ PAGESIZE
-#else
-#define PGSZ ctx.pagesize
-#endif
-
-__attribute__((__visibility__("hidden")))
-struct meta *alloc_meta(void);
-
-__attribute__((__visibility__("hidden")))
-int is_allzero(void *);
-
-static inline void queue(struct meta **phead, struct meta *m)
-{
-	assert(!m->next);
-	assert(!m->prev);
-	if (*phead) {
-		struct meta *head = *phead;
-		m->next = head;
-		m->prev = head->prev;
-		m->next->prev = m->prev->next = m;
-	} else {
-		m->prev = m->next = m;
-		*phead = m;
-	}
-}
-
-static inline void dequeue(struct meta **phead, struct meta *m)
-{
-	if (m->next != m) {
-		m->prev->next = m->next;
-		m->next->prev = m->prev;
-		if (*phead == m) *phead = m->next;
-	} else {
-		*phead = 0;
-	}
-	m->prev = m->next = 0;
-}
-
-static inline struct meta *dequeue_head(struct meta **phead)
-{
-	struct meta *m = *phead;
-	if (m) dequeue(phead, m);
-	return m;
-}
-
-static inline void free_meta(struct meta *m)
-{
-	*m = (struct meta){0};
-	queue(&ctx.free_meta_head, m);
-}
-
-static inline uint32_t activate_group(struct meta *m)
-{
-	assert(!m->avail_mask);
-	uint32_t mask, act = (2u<<m->mem->active_idx)-1;
-	do mask = m->freed_mask;
-	while (a_cas(&m->freed_mask, mask, mask&~act)!=mask);
-	return m->avail_mask = mask & act;
-}
-
-static inline int get_slot_index(const unsigned char *p)
-{
-	return p[-3] & 31;
-}
-
-static inline struct meta *get_meta(const unsigned char *p)
-{
-	assert(!((uintptr_t)p & 15));
-	int offset = *(const uint16_t *)(p - 2);
-	int index = get_slot_index(p);
-	if (p[-4]) {
-		assert(!offset);
-		offset = *(uint32_t *)(p - 8);
-		assert(offset > 0xffff);
-	}
-	const struct group *base = (const void *)(p - UNIT*offset - UNIT);
-	const struct meta *meta = base->meta;
-	assert(meta->mem == base);
-	assert(index <= meta->last_idx);
-	assert(!(meta->avail_mask & (1u<<index)));
-	assert(!(meta->freed_mask & (1u<<index)));
-	const struct meta_area *area = (void *)((uintptr_t)meta & -4096);
-	assert(area->check == ctx.secret);
-	if (meta->sizeclass < 48) {
-		assert(offset >= size_classes[meta->sizeclass]*index);
-		assert(offset < size_classes[meta->sizeclass]*(index+1));
-	} else {
-		assert(meta->sizeclass == 63);
-	}
-	if (meta->maplen) {
-		assert(offset <= meta->maplen*4096UL/UNIT - 1);
-	}
-	return (struct meta *)meta;
-}
-
-static inline size_t get_nominal_size(const unsigned char *p, const unsigned char *end)
-{
-	size_t reserved = p[-3] >> 5;
-	if (reserved >= 5) {
-		assert(reserved == 5);
-		reserved = *(const uint32_t *)(end-4);
-		assert(reserved >= 5);
-		assert(!end[-5]);
-	}
-	assert(reserved <= end-p);
-	assert(!*(end-reserved));
-	// also check the slot's overflow byte
-	assert(!*end);
-	return end-reserved-p;
-}
-
-static inline size_t get_stride(const struct meta *g)
-{
-	if (!g->last_idx && g->maplen) {
-		return g->maplen*4096UL - UNIT;
-	} else {
-		return UNIT*size_classes[g->sizeclass];
-	}
-}
-
-static inline void set_size(unsigned char *p, unsigned char *end, size_t n)
-{
-	int reserved = end-p-n;
-	if (reserved) end[-reserved] = 0;
-	if (reserved >= 5) {
-		*(uint32_t *)(end-4) = reserved;
-		end[-5] = 0;
-		reserved = 5;
-	}
-	p[-3] = (p[-3]&31) + (reserved<<5);
-}
-
-static inline void *enframe(struct meta *g, int idx, size_t n, int ctr)
-{
-	size_t stride = get_stride(g);
-	size_t slack = (stride-IB-n)/UNIT;
-	unsigned char *p = g->mem->storage + stride*idx;
-	unsigned char *end = p+stride-IB;
-	// cycle offset within slot to increase interval to address
-	// reuse, facilitate trapping double-free.
-	int off = (p[-3] ? *(uint16_t *)(p-2) + 1 : ctr) & 255;
-	assert(!p[-4]);
-	if (off > slack) {
-		size_t m = slack;
-		m |= m>>1; m |= m>>2; m |= m>>4;
-		off &= m;
-		if (off > slack) off -= slack+1;
-		assert(off <= slack);
-	}
-	if (off) {
-		// store offset in unused header at offset zero
-		// if enframing at non-zero offset.
-		*(uint16_t *)(p-2) = off;
-		p[-3] = 7<<5;
-		p += UNIT*off;
-		// for nonzero offset there is no permanent check
-		// byte, so make one.
-		p[-4] = 0;
-	}
-	*(uint16_t *)(p-2) = (size_t)(p-g->mem->storage)/UNIT;
-	p[-3] = idx;
-	set_size(p, end, n);
-	return p;
-}
-
-static inline int size_to_class(size_t n)
-{
-	n = (n+IB-1)>>4;
-	if (n<10) return n;
-	n++;
-	int i = (28-a_clz_32(n))*4 + 8;
-	if (n>size_classes[i+1]) i+=2;
-	if (n>size_classes[i]) i++;
-	return i;
-}
-
-static inline int size_overflows(size_t n)
-{
-	if (n >= SIZE_MAX/2 - 4096) {
-		errno = ENOMEM;
-		return 1;
-	}
-	return 0;
-}
-
-static inline void step_seq(void)
-{
-	if (ctx.seq==255) {
-		for (int i=0; i<32; i++) ctx.unmap_seq[i] = 0;
-		ctx.seq = 1;
-	} else {
-		ctx.seq++;
-	}
-}
-
-static inline void record_seq(int sc)
-{
-	if (sc-7U < 32) ctx.unmap_seq[sc-7] = ctx.seq;
-}
-
-static inline void account_bounce(int sc)
-{
-	if (sc-7U < 32) {
-		int seq = ctx.unmap_seq[sc-7];
-		if (seq && ctx.seq-seq < 10) {
-			if (ctx.bounces[sc-7]+1 < 100)
-				ctx.bounces[sc-7]++;
-			else
-				ctx.bounces[sc-7] = 150;
-		}
-	}
-}
-
-static inline void decay_bounces(int sc)
-{
-	if (sc-7U < 32 && ctx.bounces[sc-7])
-		ctx.bounces[sc-7]--;
-}
-
-static inline int is_bouncing(int sc)
-{
-	return (sc-7U < 32 && ctx.bounces[sc-7] >= 100);
-}
-
-#endif
diff --git a/lib/libc/musl/src/malloc/mallocng/realloc.c b/lib/libc/musl/src/malloc/mallocng/realloc.c
deleted file mode 100644
index 18769f42d83ae71dabea1e7caf117fe4115af139..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/mallocng/realloc.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#define _GNU_SOURCE
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <string.h>
-#include "meta.h"
-
-void *realloc(void *p, size_t n)
-{
-	if (!p) return malloc(n);
-	if (size_overflows(n)) return 0;
-
-	struct meta *g = get_meta(p);
-	int idx = get_slot_index(p);
-	size_t stride = get_stride(g);
-	unsigned char *start = g->mem->storage + stride*idx;
-	unsigned char *end = start + stride - IB;
-	size_t old_size = get_nominal_size(p, end);
-	size_t avail_size = end-(unsigned char *)p;
-	void *new;
-
-	// only resize in-place if size class matches
-	if (n <= avail_size && n<MMAP_THRESHOLD
-	    && size_to_class(n)+1 >= g->sizeclass) {
-		set_size(p, end, n);
-		return p;
-	}
-
-	// use mremap if old and new size are both mmap-worthy
-	if (g->sizeclass>=48 && n>=MMAP_THRESHOLD) {
-		assert(g->sizeclass==63);
-		size_t base = (unsigned char *)p-start;
-		size_t needed = (n + base + UNIT + IB + 4095) & -4096;
-		new = g->maplen*4096UL == needed ? g->mem :
-			mremap(g->mem, g->maplen*4096UL, needed, MREMAP_MAYMOVE);
-		if (new!=MAP_FAILED) {
-			g->mem = new;
-			g->maplen = needed/4096;
-			p = g->mem->storage + base;
-			end = g->mem->storage + (needed - UNIT) - IB;
-			*end = 0;
-			set_size(p, end, n);
-			return p;
-		}
-	}
-
-	new = malloc(n);
-	if (!new) return 0;
-	memcpy(new, p, n < old_size ? n : old_size);
-	free(p);
-	return new;
-}
diff --git a/lib/libc/musl/src/malloc/memalign.c b/lib/libc/musl/src/malloc/memalign.c
deleted file mode 100644
index 32cd87d812f7f4228d1f85932f7a7dbb75777de7..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/memalign.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#define _BSD_SOURCE
-#include <stdlib.h>
-
-void *memalign(size_t align, size_t len)
-{
-	return aligned_alloc(align, len);
-}
diff --git a/lib/libc/musl/src/malloc/oldmalloc/aligned_alloc.c b/lib/libc/musl/src/malloc/oldmalloc/aligned_alloc.c
deleted file mode 100644
index 4adca3b4f6b7704b3cb034c4a087eaf4e08c2749..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/oldmalloc/aligned_alloc.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <errno.h>
-#include "malloc_impl.h"
-
-void *aligned_alloc(size_t align, size_t len)
-{
-	unsigned char *mem, *new;
-
-	if ((align & -align) != align) {
-		errno = EINVAL;
-		return 0;
-	}
-
-	if (len > SIZE_MAX - align ||
-	    (__malloc_replaced && !__aligned_alloc_replaced)) {
-		errno = ENOMEM;
-		return 0;
-	}
-
-	if (align <= SIZE_ALIGN)
-		return malloc(len);
-
-	if (!(mem = malloc(len + align-1)))
-		return 0;
-
-	new = (void *)((uintptr_t)mem + align-1 & -align);
-	if (new == mem) return mem;
-
-	struct chunk *c = MEM_TO_CHUNK(mem);
-	struct chunk *n = MEM_TO_CHUNK(new);
-
-	if (IS_MMAPPED(c)) {
-		/* Apply difference between aligned and original
-		 * address to the "extra" field of mmapped chunk. */
-		n->psize = c->psize + (new-mem);
-		n->csize = c->csize - (new-mem);
-		return new;
-	}
-
-	struct chunk *t = NEXT_CHUNK(c);
-
-	/* Split the allocated chunk into two chunks. The aligned part
-	 * that will be used has the size in its footer reduced by the
-	 * difference between the aligned and original addresses, and
-	 * the resulting size copied to its header. A new header and
-	 * footer are written for the split-off part to be freed. */
-	n->psize = c->csize = C_INUSE | (new-mem);
-	n->csize = t->psize -= new-mem;
-
-	__bin_chunk(c);
-	return new;
-}
diff --git a/lib/libc/musl/src/malloc/oldmalloc/malloc.c b/lib/libc/musl/src/malloc/oldmalloc/malloc.c
deleted file mode 100644
index 25d00d44dea770a7f78ac61a15aeda9308057b2a..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/oldmalloc/malloc.c
+++ /dev/null
@@ -1,556 +0,0 @@
-#define _GNU_SOURCE
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <stdint.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include "libc.h"
-#include "atomic.h"
-#include "pthread_impl.h"
-#include "malloc_impl.h"
-#include "fork_impl.h"
-
-#define malloc __libc_malloc_impl
-#define realloc __libc_realloc
-#define free __libc_free
-
-#if defined(__GNUC__) && defined(__PIC__)
-#define inline inline __attribute__((always_inline))
-#endif
-
-static struct {
-	volatile uint64_t binmap;
-	struct bin bins[64];
-	volatile int split_merge_lock[2];
-} mal;
-
-/* Synchronization tools */
-
-static inline void lock(volatile int *lk)
-{
-	int need_locks = libc.need_locks;
-	if (need_locks) {
-		while(a_swap(lk, 1)) __wait(lk, lk+1, 1, 1);
-		if (need_locks < 0) libc.need_locks = 0;
-	}
-}
-
-static inline void unlock(volatile int *lk)
-{
-	if (lk[0]) {
-		a_store(lk, 0);
-		if (lk[1]) __wake(lk, 1, 1);
-	}
-}
-
-static inline void lock_bin(int i)
-{
-	lock(mal.bins[i].lock);
-	if (!mal.bins[i].head)
-		mal.bins[i].head = mal.bins[i].tail = BIN_TO_CHUNK(i);
-}
-
-static inline void unlock_bin(int i)
-{
-	unlock(mal.bins[i].lock);
-}
-
-static int first_set(uint64_t x)
-{
-#if 1
-	return a_ctz_64(x);
-#else
-	static const char debruijn64[64] = {
-		0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
-		62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
-		63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
-		51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
-	};
-	static const char debruijn32[32] = {
-		0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
-		31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
-	};
-	if (sizeof(long) < 8) {
-		uint32_t y = x;
-		if (!y) {
-			y = x>>32;
-			return 32 + debruijn32[(y&-y)*0x076be629 >> 27];
-		}
-		return debruijn32[(y&-y)*0x076be629 >> 27];
-	}
-	return debruijn64[(x&-x)*0x022fdd63cc95386dull >> 58];
-#endif
-}
-
-static const unsigned char bin_tab[60] = {
-	            32,33,34,35,36,36,37,37,38,38,39,39,
-	40,40,40,40,41,41,41,41,42,42,42,42,43,43,43,43,
-	44,44,44,44,44,44,44,44,45,45,45,45,45,45,45,45,
-	46,46,46,46,46,46,46,46,47,47,47,47,47,47,47,47,
-};
-
-static int bin_index(size_t x)
-{
-	x = x / SIZE_ALIGN - 1;
-	if (x <= 32) return x;
-	if (x < 512) return bin_tab[x/8-4];
-	if (x > 0x1c00) return 63;
-	return bin_tab[x/128-4] + 16;
-}
-
-static int bin_index_up(size_t x)
-{
-	x = x / SIZE_ALIGN - 1;
-	if (x <= 32) return x;
-	x--;
-	if (x < 512) return bin_tab[x/8-4] + 1;
-	return bin_tab[x/128-4] + 17;
-}
-
-#if 0
-void __dump_heap(int x)
-{
-	struct chunk *c;
-	int i;
-	for (c = (void *)mal.heap; CHUNK_SIZE(c); c = NEXT_CHUNK(c))
-		fprintf(stderr, "base %p size %zu (%d) flags %d/%d\n",
-			c, CHUNK_SIZE(c), bin_index(CHUNK_SIZE(c)),
-			c->csize & 15,
-			NEXT_CHUNK(c)->psize & 15);
-	for (i=0; i<64; i++) {
-		if (mal.bins[i].head != BIN_TO_CHUNK(i) && mal.bins[i].head) {
-			fprintf(stderr, "bin %d: %p\n", i, mal.bins[i].head);
-			if (!(mal.binmap & 1ULL<<i))
-				fprintf(stderr, "missing from binmap!\n");
-		} else if (mal.binmap & 1ULL<<i)
-			fprintf(stderr, "binmap wrongly contains %d!\n", i);
-	}
-}
-#endif
-
-/* This function returns true if the interval [old,new]
- * intersects the 'len'-sized interval below &libc.auxv
- * (interpreted as the main-thread stack) or below &b
- * (the current stack). It is used to defend against
- * buggy brk implementations that can cross the stack. */
-
-static int traverses_stack_p(uintptr_t old, uintptr_t new)
-{
-	const uintptr_t len = 8<<20;
-	uintptr_t a, b;
-
-	b = (uintptr_t)libc.auxv;
-	a = b > len ? b-len : 0;
-	if (new>a && old<b) return 1;
-
-	b = (uintptr_t)&b;
-	a = b > len ? b-len : 0;
-	if (new>a && old<b) return 1;
-
-	return 0;
-}
-
-/* Expand the heap in-place if brk can be used, or otherwise via mmap,
- * using an exponential lower bound on growth by mmap to make
- * fragmentation asymptotically irrelevant. The size argument is both
- * an input and an output, since the caller needs to know the size
- * allocated, which will be larger than requested due to page alignment
- * and mmap minimum size rules. The caller is responsible for locking
- * to prevent concurrent calls. */
-
-static void *__expand_heap(size_t *pn)
-{
-	static uintptr_t brk;
-	static unsigned mmap_step;
-	size_t n = *pn;
-
-	if (n > SIZE_MAX/2 - PAGE_SIZE) {
-		errno = ENOMEM;
-		return 0;
-	}
-	n += -n & PAGE_SIZE-1;
-
-	if (!brk) {
-		brk = __syscall(SYS_brk, 0);
-		brk += -brk & PAGE_SIZE-1;
-	}
-
-	if (n < SIZE_MAX-brk && !traverses_stack_p(brk, brk+n)
-	    && __syscall(SYS_brk, brk+n)==brk+n) {
-		*pn = n;
-		brk += n;
-		return (void *)(brk-n);
-	}
-
-	size_t min = (size_t)PAGE_SIZE << mmap_step/2;
-	if (n < min) n = min;
-	void *area = __mmap(0, n, PROT_READ|PROT_WRITE,
-		MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
-	if (area == MAP_FAILED) return 0;
-	*pn = n;
-	mmap_step++;
-	return area;
-}
-
-static struct chunk *expand_heap(size_t n)
-{
-	static void *end;
-	void *p;
-	struct chunk *w;
-
-	/* The argument n already accounts for the caller's chunk
-	 * overhead needs, but if the heap can't be extended in-place,
-	 * we need room for an extra zero-sized sentinel chunk. */
-	n += SIZE_ALIGN;
-
-	p = __expand_heap(&n);
-	if (!p) return 0;
-
-	/* If not just expanding existing space, we need to make a
-	 * new sentinel chunk below the allocated space. */
-	if (p != end) {
-		/* Valid/safe because of the prologue increment. */
-		n -= SIZE_ALIGN;
-		p = (char *)p + SIZE_ALIGN;
-		w = MEM_TO_CHUNK(p);
-		w->psize = 0 | C_INUSE;
-	}
-
-	/* Record new heap end and fill in footer. */
-	end = (char *)p + n;
-	w = MEM_TO_CHUNK(end);
-	w->psize = n | C_INUSE;
-	w->csize = 0 | C_INUSE;
-
-	/* Fill in header, which may be new or may be replacing a
-	 * zero-size sentinel header at the old end-of-heap. */
-	w = MEM_TO_CHUNK(p);
-	w->csize = n | C_INUSE;
-
-	return w;
-}
-
-static int adjust_size(size_t *n)
-{
-	/* Result of pointer difference must fit in ptrdiff_t. */
-	if (*n-1 > PTRDIFF_MAX - SIZE_ALIGN - PAGE_SIZE) {
-		if (*n) {
-			errno = ENOMEM;
-			return -1;
-		} else {
-			*n = SIZE_ALIGN;
-			return 0;
-		}
-	}
-	*n = (*n + OVERHEAD + SIZE_ALIGN - 1) & SIZE_MASK;
-	return 0;
-}
-
-static void unbin(struct chunk *c, int i)
-{
-	if (c->prev == c->next)
-		a_and_64(&mal.binmap, ~(1ULL<<i));
-	c->prev->next = c->next;
-	c->next->prev = c->prev;
-	c->csize |= C_INUSE;
-	NEXT_CHUNK(c)->psize |= C_INUSE;
-}
-
-static void bin_chunk(struct chunk *self, int i)
-{
-	self->next = BIN_TO_CHUNK(i);
-	self->prev = mal.bins[i].tail;
-	self->next->prev = self;
-	self->prev->next = self;
-	if (self->prev == BIN_TO_CHUNK(i))
-		a_or_64(&mal.binmap, 1ULL<<i);
-}
-
-static void trim(struct chunk *self, size_t n)
-{
-	size_t n1 = CHUNK_SIZE(self);
-	struct chunk *next, *split;
-
-	if (n >= n1 - DONTCARE) return;
-
-	next = NEXT_CHUNK(self);
-	split = (void *)((char *)self + n);
-
-	split->psize = n | C_INUSE;
-	split->csize = n1-n;
-	next->psize = n1-n;
-	self->csize = n | C_INUSE;
-
-	int i = bin_index(n1-n);
-	lock_bin(i);
-
-	bin_chunk(split, i);
-
-	unlock_bin(i);
-}
-
-void *malloc(size_t n)
-{
-	struct chunk *c;
-	int i, j;
-	uint64_t mask;
-
-	if (adjust_size(&n) < 0) return 0;
-
-	if (n > MMAP_THRESHOLD) {
-		size_t len = n + OVERHEAD + PAGE_SIZE - 1 & -PAGE_SIZE;
-		char *base = __mmap(0, len, PROT_READ|PROT_WRITE,
-			MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
-		if (base == (void *)-1) return 0;
-		c = (void *)(base + SIZE_ALIGN - OVERHEAD);
-		c->csize = len - (SIZE_ALIGN - OVERHEAD);
-		c->psize = SIZE_ALIGN - OVERHEAD;
-		return CHUNK_TO_MEM(c);
-	}
-
-	i = bin_index_up(n);
-	if (i<63 && (mal.binmap & (1ULL<<i))) {
-		lock_bin(i);
-		c = mal.bins[i].head;
-		if (c != BIN_TO_CHUNK(i) && CHUNK_SIZE(c)-n <= DONTCARE) {
-			unbin(c, i);
-			unlock_bin(i);
-			return CHUNK_TO_MEM(c);
-		}
-		unlock_bin(i);
-	}
-	lock(mal.split_merge_lock);
-	for (mask = mal.binmap & -(1ULL<<i); mask; mask -= (mask&-mask)) {
-		j = first_set(mask);
-		lock_bin(j);
-		c = mal.bins[j].head;
-		if (c != BIN_TO_CHUNK(j)) {
-			unbin(c, j);
-			unlock_bin(j);
-			break;
-		}
-		unlock_bin(j);
-	}
-	if (!mask) {
-		c = expand_heap(n);
-		if (!c) {
-			unlock(mal.split_merge_lock);
-			return 0;
-		}
-	}
-	trim(c, n);
-	unlock(mal.split_merge_lock);
-	return CHUNK_TO_MEM(c);
-}
-
-int __malloc_allzerop(void *p)
-{
-	return IS_MMAPPED(MEM_TO_CHUNK(p));
-}
-
-void *realloc(void *p, size_t n)
-{
-	struct chunk *self, *next;
-	size_t n0, n1;
-	void *new;
-
-	if (!p) return malloc(n);
-
-	if (adjust_size(&n) < 0) return 0;
-
-	self = MEM_TO_CHUNK(p);
-	n1 = n0 = CHUNK_SIZE(self);
-
-	if (n<=n0 && n0-n<=DONTCARE) return p;
-
-	if (IS_MMAPPED(self)) {
-		size_t extra = self->psize;
-		char *base = (char *)self - extra;
-		size_t oldlen = n0 + extra;
-		size_t newlen = n + extra;
-		/* Crash on realloc of freed chunk */
-		if (extra & 1) a_crash();
-		if (newlen < PAGE_SIZE && (new = malloc(n-OVERHEAD))) {
-			n0 = n;
-			goto copy_free_ret;
-		}
-		newlen = (newlen + PAGE_SIZE-1) & -PAGE_SIZE;
-		if (oldlen == newlen) return p;
-		base = __mremap(base, oldlen, newlen, MREMAP_MAYMOVE);
-		if (base == (void *)-1)
-			goto copy_realloc;
-		self = (void *)(base + extra);
-		self->csize = newlen - extra;
-		return CHUNK_TO_MEM(self);
-	}
-
-	next = NEXT_CHUNK(self);
-
-	/* Crash on corrupted footer (likely from buffer overflow) */
-	if (next->psize != self->csize) a_crash();
-
-	if (n < n0) {
-		int i = bin_index_up(n);
-		int j = bin_index(n0);
-		if (i<j && (mal.binmap & (1ULL << i)))
-			goto copy_realloc;
-		struct chunk *split = (void *)((char *)self + n);
-		self->csize = split->psize = n | C_INUSE;
-		split->csize = next->psize = n0-n | C_INUSE;
-		__bin_chunk(split);
-		return CHUNK_TO_MEM(self);
-	}
-
-	lock(mal.split_merge_lock);
-
-	size_t nsize = next->csize & C_INUSE ? 0 : CHUNK_SIZE(next);
-	if (n0+nsize >= n) {
-		int i = bin_index(nsize);
-		lock_bin(i);
-		if (!(next->csize & C_INUSE)) {
-			unbin(next, i);
-			unlock_bin(i);
-			next = NEXT_CHUNK(next);
-			self->csize = next->psize = n0+nsize | C_INUSE;
-			trim(self, n);
-			unlock(mal.split_merge_lock);
-			return CHUNK_TO_MEM(self);
-		}
-		unlock_bin(i);
-	}
-	unlock(mal.split_merge_lock);
-
-copy_realloc:
-	/* As a last resort, allocate a new chunk and copy to it. */
-	new = malloc(n-OVERHEAD);
-	if (!new) return 0;
-copy_free_ret:
-	memcpy(new, p, (n<n0 ? n : n0) - OVERHEAD);
-	free(CHUNK_TO_MEM(self));
-	return new;
-}
-
-void __bin_chunk(struct chunk *self)
-{
-	struct chunk *next = NEXT_CHUNK(self);
-
-	/* Crash on corrupted footer (likely from buffer overflow) */
-	if (next->psize != self->csize) a_crash();
-
-	lock(mal.split_merge_lock);
-
-	size_t osize = CHUNK_SIZE(self), size = osize;
-
-	/* Since we hold split_merge_lock, only transition from free to
-	 * in-use can race; in-use to free is impossible */
-	size_t psize = self->psize & C_INUSE ? 0 : CHUNK_PSIZE(self);
-	size_t nsize = next->csize & C_INUSE ? 0 : CHUNK_SIZE(next);
-
-	if (psize) {
-		int i = bin_index(psize);
-		lock_bin(i);
-		if (!(self->psize & C_INUSE)) {
-			struct chunk *prev = PREV_CHUNK(self);
-			unbin(prev, i);
-			self = prev;
-			size += psize;
-		}
-		unlock_bin(i);
-	}
-	if (nsize) {
-		int i = bin_index(nsize);
-		lock_bin(i);
-		if (!(next->csize & C_INUSE)) {
-			unbin(next, i);
-			next = NEXT_CHUNK(next);
-			size += nsize;
-		}
-		unlock_bin(i);
-	}
-
-	int i = bin_index(size);
-	lock_bin(i);
-
-	self->csize = size;
-	next->psize = size;
-	bin_chunk(self, i);
-	unlock(mal.split_merge_lock);
-
-	/* Replace middle of large chunks with fresh zero pages */
-	if (size > RECLAIM && (size^(size-osize)) > size-osize) {
-		uintptr_t a = (uintptr_t)self + SIZE_ALIGN+PAGE_SIZE-1 & -PAGE_SIZE;
-		uintptr_t b = (uintptr_t)next - SIZE_ALIGN & -PAGE_SIZE;
-		int e = errno;
-#if 1
-		__madvise((void *)a, b-a, MADV_DONTNEED);
-#else
-		__mmap((void *)a, b-a, PROT_READ|PROT_WRITE,
-			MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
-#endif
-		errno = e;
-	}
-
-	unlock_bin(i);
-}
-
-static void unmap_chunk(struct chunk *self)
-{
-	size_t extra = self->psize;
-	char *base = (char *)self - extra;
-	size_t len = CHUNK_SIZE(self) + extra;
-	/* Crash on double free */
-	if (extra & 1) a_crash();
-	int e = errno;
-	__munmap(base, len);
-	errno = e;
-}
-
-void free(void *p)
-{
-	if (!p) return;
-
-	struct chunk *self = MEM_TO_CHUNK(p);
-
-	if (IS_MMAPPED(self))
-		unmap_chunk(self);
-	else
-		__bin_chunk(self);
-}
-
-void __malloc_donate(char *start, char *end)
-{
-	size_t align_start_up = (SIZE_ALIGN-1) & (-(uintptr_t)start - OVERHEAD);
-	size_t align_end_down = (SIZE_ALIGN-1) & (uintptr_t)end;
-
-	/* Getting past this condition ensures that the padding for alignment
-	 * and header overhead will not overflow and will leave a nonzero
-	 * multiple of SIZE_ALIGN bytes between start and end. */
-	if (end - start <= OVERHEAD + align_start_up + align_end_down)
-		return;
-	start += align_start_up + OVERHEAD;
-	end   -= align_end_down;
-
-	struct chunk *c = MEM_TO_CHUNK(start), *n = MEM_TO_CHUNK(end);
-	c->psize = n->csize = C_INUSE;
-	c->csize = n->psize = C_INUSE | (end-start);
-	__bin_chunk(c);
-}
-
-void __malloc_atfork(int who)
-{
-	if (who<0) {
-		lock(mal.split_merge_lock);
-		for (int i=0; i<64; i++)
-			lock(mal.bins[i].lock);
-	} else if (!who) {
-		for (int i=0; i<64; i++)
-			unlock(mal.bins[i].lock);
-		unlock(mal.split_merge_lock);
-	} else {
-		for (int i=0; i<64; i++)
-			mal.bins[i].lock[0] = mal.bins[i].lock[1] = 0;
-		mal.split_merge_lock[1] = 0;
-		mal.split_merge_lock[0] = 0;
-	}
-}
diff --git a/lib/libc/musl/src/malloc/oldmalloc/malloc_impl.h b/lib/libc/musl/src/malloc/oldmalloc/malloc_impl.h
deleted file mode 100644
index e1cf4774c1e40d44d338200e95f8028b8083ce53..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/oldmalloc/malloc_impl.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef MALLOC_IMPL_H
-#define MALLOC_IMPL_H
-
-#include <sys/mman.h>
-#include "dynlink.h"
-
-struct chunk {
-	size_t psize, csize;
-	struct chunk *next, *prev;
-};
-
-struct bin {
-	volatile int lock[2];
-	struct chunk *head;
-	struct chunk *tail;
-};
-
-#define SIZE_ALIGN (4*sizeof(size_t))
-#define SIZE_MASK (-SIZE_ALIGN)
-#define OVERHEAD (2*sizeof(size_t))
-#define MMAP_THRESHOLD (0x1c00*SIZE_ALIGN)
-#define DONTCARE 16
-#define RECLAIM 163840
-
-#define CHUNK_SIZE(c) ((c)->csize & -2)
-#define CHUNK_PSIZE(c) ((c)->psize & -2)
-#define PREV_CHUNK(c) ((struct chunk *)((char *)(c) - CHUNK_PSIZE(c)))
-#define NEXT_CHUNK(c) ((struct chunk *)((char *)(c) + CHUNK_SIZE(c)))
-#define MEM_TO_CHUNK(p) (struct chunk *)((char *)(p) - OVERHEAD)
-#define CHUNK_TO_MEM(c) (void *)((char *)(c) + OVERHEAD)
-#define BIN_TO_CHUNK(i) (MEM_TO_CHUNK(&mal.bins[i].head))
-
-#define C_INUSE  ((size_t)1)
-
-#define IS_MMAPPED(c) !((c)->csize & (C_INUSE))
-
-hidden void __bin_chunk(struct chunk *);
-
-#endif
diff --git a/lib/libc/musl/src/malloc/oldmalloc/malloc_usable_size.c b/lib/libc/musl/src/malloc/oldmalloc/malloc_usable_size.c
deleted file mode 100644
index 672b518ad0ef15d9b3ad19a0538c6490aa88ca63..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/oldmalloc/malloc_usable_size.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <malloc.h>
-#include "malloc_impl.h"
- 
-hidden void *(*const __realloc_dep)(void *, size_t) = realloc;
-
-size_t malloc_usable_size(void *p)
-{
-	return p ? CHUNK_SIZE(MEM_TO_CHUNK(p)) - OVERHEAD : 0;
-}
diff --git a/lib/libc/musl/src/malloc/posix_memalign.c b/lib/libc/musl/src/malloc/posix_memalign.c
deleted file mode 100644
index ad4d8f473015e378ad1025363cd68507ec539f18..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/posix_memalign.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdlib.h>
-#include <errno.h>
-
-int posix_memalign(void **res, size_t align, size_t len)
-{
-	if (align < sizeof(void *)) return EINVAL;
-	void *mem = aligned_alloc(align, len);
-	if (!mem) return errno;
-	*res = mem;
-	return 0;
-}
diff --git a/lib/libc/musl/src/malloc/realloc.c b/lib/libc/musl/src/malloc/realloc.c
deleted file mode 100644
index fb0e8b7c47869c5ad259f430132867d3744a4441..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/realloc.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdlib.h>
-
-void *realloc(void *p, size_t n)
-{
-	return __libc_realloc(p, n);
-}
diff --git a/lib/libc/musl/src/malloc/reallocarray.c b/lib/libc/musl/src/malloc/reallocarray.c
deleted file mode 100644
index 4a6ebe460469b69a6e860f6f1ad643c40c35fbeb..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/reallocarray.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#define _BSD_SOURCE
-#include <errno.h>
-#include <stdlib.h>
-
-void *reallocarray(void *ptr, size_t m, size_t n)
-{
-	if (n && m > -1 / n) {
-		errno = ENOMEM;
-		return 0;
-	}
-
-	return realloc(ptr, m * n);
-}
diff --git a/lib/libc/musl/src/malloc/replaced.c b/lib/libc/musl/src/malloc/replaced.c
deleted file mode 100644
index 07fce61ec08d67f39fce99e659719042ad17f356..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/malloc/replaced.c
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "dynlink.h"
-
-int __malloc_replaced;
-int __aligned_alloc_replaced;
diff --git a/lib/libc/wasi/emmalloc/emmalloc.c b/lib/libc/wasi/emmalloc/emmalloc.c
deleted file mode 100644
index e97ef44dc058772c640a2be5889513dce73ef592..0000000000000000000000000000000000000000
--- a/lib/libc/wasi/emmalloc/emmalloc.c
+++ /dev/null
@@ -1,1540 +0,0 @@
-/*
- * Copyright 2018 The Emscripten Authors.  All rights reserved.
- * Emscripten is available under two separate licenses, the MIT license and the
- * University of Illinois/NCSA Open Source License.  Both these licenses can be
- * found in the LICENSE file.
- *
- * Simple minimalistic but efficient sbrk()-based malloc/free that works in
- * singlethreaded and multithreaded builds.
- *
- * Assumptions:
- *
- *  - sbrk() is used to claim new memory (sbrk handles geometric/linear
- *  - overallocation growth)
- *  - sbrk() can be used by other code outside emmalloc.
- *  - sbrk() is very fast in most cases (internal wasm call).
- *  - sbrk() returns pointers with an alignment of alignof(max_align_t)
- *
- * Invariants:
- *
- *  - Per-allocation header overhead is 8 bytes, smallest allocated payload
- *    amount is 8 bytes, and a multiple of 4 bytes.
- *  - Acquired memory blocks are subdivided into disjoint regions that lie
- *    next to each other.
- *  - A region is either in used or free.
- *    Used regions may be adjacent, and a used and unused region
- *    may be adjacent, but not two unused ones - they would be
- *    merged.
- *  - Memory allocation takes constant time, unless the alloc needs to sbrk()
- *    or memory is very close to being exhausted.
- *
- * Debugging:
- *
- *  - If not NDEBUG, runtime assert()s are in use.
- *  - If EMMALLOC_MEMVALIDATE is defined, a large amount of extra checks are done.
- *  - If EMMALLOC_VERBOSE is defined, a lot of operations are logged
- *    out, in addition to EMMALLOC_MEMVALIDATE.
- *  - Debugging and logging directly uses console.log via uses EM_ASM, not
- *    printf etc., to minimize any risk of debugging or logging depending on
- *    malloc.
- */
-
-#include <stdalign.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <memory.h>
-#include <assert.h>
-#include <malloc.h>
-#include <limits.h>
-#include <stdlib.h>
-
-#ifdef __EMSCRIPTEN_TRACING__
-#include <emscripten/trace.h>
-#endif
-
-// Defind by the linker to have the address of the start of the heap.
-extern unsigned char __heap_base;
-extern unsigned char __heap_end;
-
-// Behavior of right shifting a signed integer is compiler implementation defined.
-static_assert((((int32_t)0x80000000U) >> 31) == -1, "This malloc implementation requires that right-shifting a signed integer produces a sign-extending (arithmetic) shift!");
-
-// Configuration: specifies the minimum alignment that malloc()ed memory outputs. Allocation requests with smaller alignment
-// than this will yield an allocation with this much alignment.
-#define MALLOC_ALIGNMENT alignof(max_align_t)
-static_assert(alignof(max_align_t) == 16, "max_align_t must be correct");
-
-#define EMMALLOC_EXPORT __attribute__((weak))
-
-#define MIN(x, y) ((x) < (y) ? (x) : (y))
-#define MAX(x, y) ((x) > (y) ? (x) : (y))
-
-#define NUM_FREE_BUCKETS 64
-#define BUCKET_BITMASK_T uint64_t
-
-// Dynamic memory is subdivided into regions, in the format
-
-// <size:uint32_t> ..... <size:uint32_t> | <size:uint32_t> ..... <size:uint32_t> | <size:uint32_t> ..... <size:uint32_t> | .....
-
-// That is, at the bottom and top end of each memory region, the size of that region is stored. That allows traversing the
-// memory regions backwards and forwards. Because each allocation must be at least a multiple of 4 bytes, the lowest two bits of
-// each size field is unused. Free regions are distinguished by used regions by having the FREE_REGION_FLAG bit present
-// in the size field. I.e. for free regions, the size field is odd, and for used regions, the size field reads even.
-#define FREE_REGION_FLAG 0x1u
-
-// Attempts to malloc() more than this many bytes would cause an overflow when calculating the size of a region,
-// therefore allocations larger than this are short-circuited immediately on entry.
-#define MAX_ALLOC_SIZE 0xFFFFFFC7u
-
-// A free region has the following structure:
-// <size:size_t> <prevptr> <nextptr> ... <size:size_t>
-
-typedef struct Region
-{
-  size_t size;
-  // Use a circular doubly linked list to represent free region data.
-  struct Region *prev, *next;
-  // ... N bytes of free data
-  size_t _at_the_end_of_this_struct_size; // do not dereference, this is present for convenient struct sizeof() computation only
-} Region;
-
-// Each memory block starts with a RootRegion at the beginning.
-// The RootRegion specifies the size of the region block, and forms a linked
-// list of all RootRegions in the program, starting with `listOfAllRegions`
-// below.
-typedef struct RootRegion
-{
-  uint32_t size;
-  struct RootRegion *next;
-  uint8_t* endPtr;
-} RootRegion;
-
-#if defined(__EMSCRIPTEN_PTHREADS__)
-// In multithreaded builds, use a simple global spinlock strategy to acquire/release access to the memory allocator.
-static volatile uint8_t multithreadingLock = 0;
-#define MALLOC_ACQUIRE() while(__sync_lock_test_and_set(&multithreadingLock, 1)) { while(multithreadingLock) { /*nop*/ } }
-#define MALLOC_RELEASE() __sync_lock_release(&multithreadingLock)
-// Test code to ensure we have tight malloc acquire/release guards in place.
-#define ASSERT_MALLOC_IS_ACQUIRED() assert(multithreadingLock == 1)
-#else
-// In singlethreaded builds, no need for locking.
-#define MALLOC_ACQUIRE() ((void)0)
-#define MALLOC_RELEASE() ((void)0)
-#define ASSERT_MALLOC_IS_ACQUIRED() ((void)0)
-#endif
-
-#define IS_POWER_OF_2(val) (((val) & ((val)-1)) == 0)
-#define ALIGN_UP(ptr, alignment) ((uint8_t*)((((uintptr_t)(ptr)) + ((alignment)-1)) & ~((alignment)-1)))
-#define HAS_ALIGNMENT(ptr, alignment) ((((uintptr_t)(ptr)) & ((alignment)-1)) == 0)
-
-static_assert(IS_POWER_OF_2(MALLOC_ALIGNMENT), "MALLOC_ALIGNMENT must be a power of two value!");
-static_assert(MALLOC_ALIGNMENT >= 4, "Smallest possible MALLOC_ALIGNMENT if 4!");
-
-// A region that contains as payload a single forward linked list of pointers to
-// root regions of each disjoint region blocks.
-static RootRegion *listOfAllRegions = NULL;
-
-// For each of the buckets, maintain a linked list head node. The head node for each
-// free region is a sentinel node that does not actually represent any free space, but
-// the sentinel is used to avoid awkward testing against (if node == freeRegionHeadNode)
-// when adding and removing elements from the linked list, i.e. we are guaranteed that
-// the sentinel node is always fixed and there, and the actual free region list elements
-// start at freeRegionBuckets[i].next each.
-static Region freeRegionBuckets[NUM_FREE_BUCKETS] = {
-	{ .prev = &freeRegionBuckets[0], .next = &freeRegionBuckets[0] },
-	{ .prev = &freeRegionBuckets[1], .next = &freeRegionBuckets[1] },
-	{ .prev = &freeRegionBuckets[2], .next = &freeRegionBuckets[2] },
-	{ .prev = &freeRegionBuckets[3], .next = &freeRegionBuckets[3] },
-	{ .prev = &freeRegionBuckets[4], .next = &freeRegionBuckets[4] },
-	{ .prev = &freeRegionBuckets[5], .next = &freeRegionBuckets[5] },
-	{ .prev = &freeRegionBuckets[6], .next = &freeRegionBuckets[6] },
-	{ .prev = &freeRegionBuckets[7], .next = &freeRegionBuckets[7] },
-	{ .prev = &freeRegionBuckets[8], .next = &freeRegionBuckets[8] },
-	{ .prev = &freeRegionBuckets[9], .next = &freeRegionBuckets[9] },
-	{ .prev = &freeRegionBuckets[10], .next = &freeRegionBuckets[10] },
-	{ .prev = &freeRegionBuckets[11], .next = &freeRegionBuckets[11] },
-	{ .prev = &freeRegionBuckets[12], .next = &freeRegionBuckets[12] },
-	{ .prev = &freeRegionBuckets[13], .next = &freeRegionBuckets[13] },
-	{ .prev = &freeRegionBuckets[14], .next = &freeRegionBuckets[14] },
-	{ .prev = &freeRegionBuckets[15], .next = &freeRegionBuckets[15] },
-	{ .prev = &freeRegionBuckets[16], .next = &freeRegionBuckets[16] },
-	{ .prev = &freeRegionBuckets[17], .next = &freeRegionBuckets[17] },
-	{ .prev = &freeRegionBuckets[18], .next = &freeRegionBuckets[18] },
-	{ .prev = &freeRegionBuckets[19], .next = &freeRegionBuckets[19] },
-	{ .prev = &freeRegionBuckets[20], .next = &freeRegionBuckets[20] },
-	{ .prev = &freeRegionBuckets[21], .next = &freeRegionBuckets[21] },
-	{ .prev = &freeRegionBuckets[22], .next = &freeRegionBuckets[22] },
-	{ .prev = &freeRegionBuckets[23], .next = &freeRegionBuckets[23] },
-	{ .prev = &freeRegionBuckets[24], .next = &freeRegionBuckets[24] },
-	{ .prev = &freeRegionBuckets[25], .next = &freeRegionBuckets[25] },
-	{ .prev = &freeRegionBuckets[26], .next = &freeRegionBuckets[26] },
-	{ .prev = &freeRegionBuckets[27], .next = &freeRegionBuckets[27] },
-	{ .prev = &freeRegionBuckets[28], .next = &freeRegionBuckets[28] },
-	{ .prev = &freeRegionBuckets[29], .next = &freeRegionBuckets[29] },
-	{ .prev = &freeRegionBuckets[30], .next = &freeRegionBuckets[30] },
-	{ .prev = &freeRegionBuckets[31], .next = &freeRegionBuckets[31] },
-	{ .prev = &freeRegionBuckets[32], .next = &freeRegionBuckets[32] },
-	{ .prev = &freeRegionBuckets[33], .next = &freeRegionBuckets[33] },
-	{ .prev = &freeRegionBuckets[34], .next = &freeRegionBuckets[34] },
-	{ .prev = &freeRegionBuckets[35], .next = &freeRegionBuckets[35] },
-	{ .prev = &freeRegionBuckets[36], .next = &freeRegionBuckets[36] },
-	{ .prev = &freeRegionBuckets[37], .next = &freeRegionBuckets[37] },
-	{ .prev = &freeRegionBuckets[38], .next = &freeRegionBuckets[38] },
-	{ .prev = &freeRegionBuckets[39], .next = &freeRegionBuckets[39] },
-	{ .prev = &freeRegionBuckets[40], .next = &freeRegionBuckets[40] },
-	{ .prev = &freeRegionBuckets[41], .next = &freeRegionBuckets[41] },
-	{ .prev = &freeRegionBuckets[42], .next = &freeRegionBuckets[42] },
-	{ .prev = &freeRegionBuckets[43], .next = &freeRegionBuckets[43] },
-	{ .prev = &freeRegionBuckets[44], .next = &freeRegionBuckets[44] },
-	{ .prev = &freeRegionBuckets[45], .next = &freeRegionBuckets[45] },
-	{ .prev = &freeRegionBuckets[46], .next = &freeRegionBuckets[46] },
-	{ .prev = &freeRegionBuckets[47], .next = &freeRegionBuckets[47] },
-	{ .prev = &freeRegionBuckets[48], .next = &freeRegionBuckets[48] },
-	{ .prev = &freeRegionBuckets[49], .next = &freeRegionBuckets[49] },
-	{ .prev = &freeRegionBuckets[50], .next = &freeRegionBuckets[50] },
-	{ .prev = &freeRegionBuckets[51], .next = &freeRegionBuckets[51] },
-	{ .prev = &freeRegionBuckets[52], .next = &freeRegionBuckets[52] },
-	{ .prev = &freeRegionBuckets[53], .next = &freeRegionBuckets[53] },
-	{ .prev = &freeRegionBuckets[54], .next = &freeRegionBuckets[54] },
-	{ .prev = &freeRegionBuckets[55], .next = &freeRegionBuckets[55] },
-	{ .prev = &freeRegionBuckets[56], .next = &freeRegionBuckets[56] },
-	{ .prev = &freeRegionBuckets[57], .next = &freeRegionBuckets[57] },
-	{ .prev = &freeRegionBuckets[58], .next = &freeRegionBuckets[58] },
-	{ .prev = &freeRegionBuckets[59], .next = &freeRegionBuckets[59] },
-	{ .prev = &freeRegionBuckets[60], .next = &freeRegionBuckets[60] },
-	{ .prev = &freeRegionBuckets[61], .next = &freeRegionBuckets[61] },
-	{ .prev = &freeRegionBuckets[62], .next = &freeRegionBuckets[62] },
-	{ .prev = &freeRegionBuckets[63], .next = &freeRegionBuckets[63] },
-};
-
-// A bitmask that tracks the population status for each of the 64 distinct memory regions:
-// a zero at bit position i means that the free list bucket i is empty. This bitmask is
-// used to avoid redundant scanning of the 64 different free region buckets: instead by
-// looking at the bitmask we can find in constant time an index to a free region bucket
-// that contains free memory of desired size.
-static BUCKET_BITMASK_T freeRegionBucketsUsed = 0;
-
-// Amount of bytes taken up by allocation header data
-#define REGION_HEADER_SIZE (2*sizeof(size_t))
-
-// Smallest allocation size that is possible is 2*pointer size, since payload of each region must at least contain space
-// to store the free region linked list prev and next pointers. An allocation size smaller than this will be rounded up
-// to this size.
-#define SMALLEST_ALLOCATION_SIZE (2*sizeof(void*))
-
-/* Subdivide regions of free space into distinct circular doubly linked lists, where each linked list
-represents a range of free space blocks. The following function compute_free_list_bucket() converts
-an allocation size to the bucket index that should be looked at. The buckets are grouped as follows:
-
-  Bucket 0: [8, 15], range size=8
-  Bucket 1: [16, 23], range size=8
-  Bucket 2: [24, 31], range size=8
-  Bucket 3: [32, 39], range size=8
-  Bucket 4: [40, 47], range size=8
-  Bucket 5: [48, 55], range size=8
-  Bucket 6: [56, 63], range size=8
-  Bucket 7: [64, 71], range size=8
-  Bucket 8: [72, 79], range size=8
-  Bucket 9: [80, 87], range size=8
-  Bucket 10: [88, 95], range size=8
-  Bucket 11: [96, 103], range size=8
-  Bucket 12: [104, 111], range size=8
-  Bucket 13: [112, 119], range size=8
-  Bucket 14: [120, 159], range size=40
-  Bucket 15: [160, 191], range size=32
-  Bucket 16: [192, 223], range size=32
-  Bucket 17: [224, 255], range size=32
-  Bucket 18: [256, 319], range size=64
-  Bucket 19: [320, 383], range size=64
-  Bucket 20: [384, 447], range size=64
-  Bucket 21: [448, 511], range size=64
-  Bucket 22: [512, 639], range size=128
-  Bucket 23: [640, 767], range size=128
-  Bucket 24: [768, 895], range size=128
-  Bucket 25: [896, 1023], range size=128
-  Bucket 26: [1024, 1279], range size=256
-  Bucket 27: [1280, 1535], range size=256
-  Bucket 28: [1536, 1791], range size=256
-  Bucket 29: [1792, 2047], range size=256
-  Bucket 30: [2048, 2559], range size=512
-  Bucket 31: [2560, 3071], range size=512
-  Bucket 32: [3072, 3583], range size=512
-  Bucket 33: [3584, 6143], range size=2560
-  Bucket 34: [6144, 8191], range size=2048
-  Bucket 35: [8192, 12287], range size=4096
-  Bucket 36: [12288, 16383], range size=4096
-  Bucket 37: [16384, 24575], range size=8192
-  Bucket 38: [24576, 32767], range size=8192
-  Bucket 39: [32768, 49151], range size=16384
-  Bucket 40: [49152, 65535], range size=16384
-  Bucket 41: [65536, 98303], range size=32768
-  Bucket 42: [98304, 131071], range size=32768
-  Bucket 43: [131072, 196607], range size=65536
-  Bucket 44: [196608, 262143], range size=65536
-  Bucket 45: [262144, 393215], range size=131072
-  Bucket 46: [393216, 524287], range size=131072
-  Bucket 47: [524288, 786431], range size=262144
-  Bucket 48: [786432, 1048575], range size=262144
-  Bucket 49: [1048576, 1572863], range size=524288
-  Bucket 50: [1572864, 2097151], range size=524288
-  Bucket 51: [2097152, 3145727], range size=1048576
-  Bucket 52: [3145728, 4194303], range size=1048576
-  Bucket 53: [4194304, 6291455], range size=2097152
-  Bucket 54: [6291456, 8388607], range size=2097152
-  Bucket 55: [8388608, 12582911], range size=4194304
-  Bucket 56: [12582912, 16777215], range size=4194304
-  Bucket 57: [16777216, 25165823], range size=8388608
-  Bucket 58: [25165824, 33554431], range size=8388608
-  Bucket 59: [33554432, 50331647], range size=16777216
-  Bucket 60: [50331648, 67108863], range size=16777216
-  Bucket 61: [67108864, 100663295], range size=33554432
-  Bucket 62: [100663296, 134217727], range size=33554432
-  Bucket 63: 134217728 bytes and larger. */
-static_assert(NUM_FREE_BUCKETS == 64, "Following function is tailored specifically for NUM_FREE_BUCKETS == 64 case");
-static int compute_free_list_bucket(size_t allocSize)
-{
-  if (allocSize < 128) return (allocSize >> 3) - 1;
-  int clz = __builtin_clz(allocSize);
-  int bucketIndex = (clz > 19) ? 110 - (clz<<2) + ((allocSize >> (29-clz)) ^ 4) : MIN(71 - (clz<<1) + ((allocSize >> (30-clz)) ^ 2), NUM_FREE_BUCKETS-1);
-  assert(bucketIndex >= 0);
-  assert(bucketIndex < NUM_FREE_BUCKETS);
-  return bucketIndex;
-}
-
-#define DECODE_CEILING_SIZE(size) ((size_t)((size) & ~FREE_REGION_FLAG))
-
-static Region *prev_region(Region *region)
-{
-  size_t prevRegionSize = ((size_t*)region)[-1];
-  prevRegionSize = DECODE_CEILING_SIZE(prevRegionSize);
-  return (Region*)((uint8_t*)region - prevRegionSize);
-}
-
-static Region *next_region(Region *region)
-{
-  return (Region*)((uint8_t*)region + region->size);
-}
-
-static size_t region_ceiling_size(Region *region)
-{
-  return ((size_t*)((uint8_t*)region + region->size))[-1];
-}
-
-static bool region_is_free(Region *r)
-{
-  return region_ceiling_size(r) & FREE_REGION_FLAG;
-}
-
-static bool region_is_in_use(Region *r)
-{
-  return r->size == region_ceiling_size(r);
-}
-
-static size_t size_of_region_from_ceiling(Region *r)
-{
-  size_t size = region_ceiling_size(r);
-  return DECODE_CEILING_SIZE(size);
-}
-
-static bool debug_region_is_consistent(Region *r)
-{
-  assert(r);
-  size_t sizeAtBottom = r->size;
-  size_t sizeAtCeiling = size_of_region_from_ceiling(r);
-  return sizeAtBottom == sizeAtCeiling;
-}
-
-static uint8_t *region_payload_start_ptr(Region *region)
-{
-  return (uint8_t*)region + sizeof(size_t);
-}
-
-static uint8_t *region_payload_end_ptr(Region *region)
-{
-  return (uint8_t*)region + region->size - sizeof(size_t);
-}
-
-static void create_used_region(void *ptr, size_t size)
-{
-  assert(ptr);
-  assert(HAS_ALIGNMENT(ptr, sizeof(size_t)));
-  assert(HAS_ALIGNMENT(size, sizeof(size_t)));
-  assert(size >= sizeof(Region));
-  *(size_t*)ptr = size;
-  ((size_t*)ptr)[(size/sizeof(size_t))-1] = size;
-}
-
-static void create_free_region(void *ptr, size_t size)
-{
-  assert(ptr);
-  assert(HAS_ALIGNMENT(ptr, sizeof(size_t)));
-  assert(HAS_ALIGNMENT(size, sizeof(size_t)));
-  assert(size >= sizeof(Region));
-  Region *freeRegion = (Region*)ptr;
-  freeRegion->size = size;
-  ((size_t*)ptr)[(size/sizeof(size_t))-1] = size | FREE_REGION_FLAG;
-}
-
-static void prepend_to_free_list(Region *region, Region *prependTo)
-{
-  assert(region);
-  assert(prependTo);
-  // N.b. the region we are prepending to is always the sentinel node,
-  // which represents a dummy node that is technically not a free node, so
-  // region_is_free(prependTo) does not hold.
-  assert(region_is_free((Region*)region));
-  region->next = prependTo;
-  region->prev = prependTo->prev;
-  assert(region->prev);
-  prependTo->prev = region;
-  region->prev->next = region;
-}
-
-static void unlink_from_free_list(Region *region)
-{
-  assert(region);
-  assert(region_is_free((Region*)region));
-  assert(region->prev);
-  assert(region->next);
-  region->prev->next = region->next;
-  region->next->prev = region->prev;
-}
-
-static void link_to_free_list(Region *freeRegion)
-{
-  assert(freeRegion);
-  assert(freeRegion->size >= sizeof(Region));
-  int bucketIndex = compute_free_list_bucket(freeRegion->size-REGION_HEADER_SIZE);
-  Region *freeListHead = freeRegionBuckets + bucketIndex;
-  freeRegion->prev = freeListHead;
-  freeRegion->next = freeListHead->next;
-  assert(freeRegion->next);
-  freeListHead->next = freeRegion;
-  freeRegion->next->prev = freeRegion;
-  freeRegionBucketsUsed |= ((BUCKET_BITMASK_T)1) << bucketIndex;
-}
-
-#if 0
-static void dump_memory_regions()
-{
-  ASSERT_MALLOC_IS_ACQUIRED();
-  RootRegion *root = listOfAllRegions;
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('All memory regions:'));
-  while(root)
-  {
-    Region *r = (Region*)root;
-    assert(debug_region_is_consistent(r));
-    uint8_t *lastRegionEnd = root->endPtr;
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('Region block 0x'+($0>>>0).toString(16)+' - 0x'+($1>>>0).toString(16)+ ' ('+($2>>>0)+' bytes):'),
-      r, lastRegionEnd, lastRegionEnd-(uint8_t*)r);
-    while((uint8_t*)r < lastRegionEnd)
-    {
-      MAIN_THREAD_ASYNC_EM_ASM(console.log('Region 0x'+($0>>>0).toString(16)+', size: '+($1>>>0)+' ('+($2?"used":"--FREE--")+')'),
-        r, r->size, region_ceiling_size(r) == r->size);
-
-      assert(debug_region_is_consistent(r));
-      size_t sizeFromCeiling = size_of_region_from_ceiling(r);
-      if (sizeFromCeiling != r->size)
-        MAIN_THREAD_ASYNC_EM_ASM(console.log('Corrupt region! Size marker at the end of the region does not match: '+($0>>>0)), sizeFromCeiling);
-      if (r->size == 0)
-        break;
-      r = next_region(r);
-    }
-    root = root->next;
-    MAIN_THREAD_ASYNC_EM_ASM(console.log(""));
-  }
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('Free regions:'));
-  for(int i = 0; i < NUM_FREE_BUCKETS; ++i)
-  {
-    Region *prev = &freeRegionBuckets[i];
-    Region *fr = freeRegionBuckets[i].next;
-    while(fr != &freeRegionBuckets[i])
-    {
-      MAIN_THREAD_ASYNC_EM_ASM(console.log('In bucket '+$0+', free region 0x'+($1>>>0).toString(16)+', size: ' + ($2>>>0) + ' (size at ceiling: '+($3>>>0)+'), prev: 0x' + ($4>>>0).toString(16) + ', next: 0x' + ($5>>>0).toString(16)),
-        i, fr, fr->size, size_of_region_from_ceiling(fr), fr->prev, fr->next);
-      assert(debug_region_is_consistent(fr));
-      assert(region_is_free(fr));
-      assert(fr->prev == prev);
-      prev = fr;
-      assert(fr->next != fr);
-      assert(fr->prev != fr);
-      fr = fr->next;
-    }
-  }
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('Free bucket index map: ' + ($0>>>0).toString(2) + ' ' + ($1>>>0).toString(2)), (uint32_t)(freeRegionBucketsUsed >> 32), (uint32_t)freeRegionBucketsUsed);
-  MAIN_THREAD_ASYNC_EM_ASM(console.log(""));
-}
-
-void emmalloc_dump_memory_regions()
-{
-  MALLOC_ACQUIRE();
-  dump_memory_regions();
-  MALLOC_RELEASE();
-}
-
-static int validate_memory_regions()
-{
-  ASSERT_MALLOC_IS_ACQUIRED();
-  RootRegion *root = listOfAllRegions;
-  while(root)
-  {
-    Region *r = (Region*)root;
-    if (!debug_region_is_consistent(r))
-    {
-      MAIN_THREAD_ASYNC_EM_ASM(console.error('Used region 0x'+($0>>>0).toString(16)+', size: '+($1>>>0)+' ('+($2?"used":"--FREE--")+') is corrupt (size markers in the beginning and at the end of the region do not match!)'),
-        r, r->size, region_ceiling_size(r) == r->size);
-      return 1;
-    }
-    uint8_t *lastRegionEnd = root->endPtr;
-    while((uint8_t*)r < lastRegionEnd)
-    {
-      if (!debug_region_is_consistent(r))
-      {
-        MAIN_THREAD_ASYNC_EM_ASM(console.error('Used region 0x'+($0>>>0).toString(16)+', size: '+($1>>>0)+' ('+($2?"used":"--FREE--")+') is corrupt (size markers in the beginning and at the end of the region do not match!)'),
-          r, r->size, region_ceiling_size(r) == r->size);
-        return 1;
-      }
-      if (r->size == 0)
-        break;
-      r = next_region(r);
-    }
-    root = root->next;
-  }
-  for(int i = 0; i < NUM_FREE_BUCKETS; ++i)
-  {
-    Region *prev = &freeRegionBuckets[i];
-    Region *fr = freeRegionBuckets[i].next;
-    while(fr != &freeRegionBuckets[i])
-    {
-      if (!debug_region_is_consistent(fr) || !region_is_free(fr) || fr->prev != prev || fr->next == fr || fr->prev == fr)
-      {
-        MAIN_THREAD_ASYNC_EM_ASM(console.log('In bucket '+$0+', free region 0x'+($1>>>0).toString(16)+', size: ' + ($2>>>0) + ' (size at ceiling: '+($3>>>0)+'), prev: 0x' + ($4>>>0).toString(16) + ', next: 0x' + ($5>>>0).toString(16) + ' is corrupt!'),
-          i, fr, fr->size, size_of_region_from_ceiling(fr), fr->prev, fr->next);
-        return 1;
-      }
-      prev = fr;
-      fr = fr->next;
-    }
-  }
-  return 0;
-}
-
-int emmalloc_validate_memory_regions()
-{
-  MALLOC_ACQUIRE();
-  int memoryError = validate_memory_regions();
-  MALLOC_RELEASE();
-  return memoryError;
-}
-#endif
-
-static bool claim_more_memory(size_t numBytes)
-{
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('claim_more_memory(numBytes='+($0>>>0)+ ')'), numBytes);
-#endif
-
-#ifdef EMMALLOC_MEMVALIDATE
-  validate_memory_regions();
-#endif
-
-  uint8_t *startPtr;
-  uint8_t *endPtr;
-  do {
-    // If this is the first time we're called, see if we can use
-    // the initial heap memory set up by wasm-ld.
-    if (!listOfAllRegions) {
-      unsigned char *heap_base = &__heap_base;
-      unsigned char *heap_end = &__heap_end;
-      if (heap_end < heap_base) {
-	__builtin_trap();
-      }
-      if (numBytes <= (size_t)(heap_end - heap_base)) {
-        startPtr = heap_base;
-        endPtr = heap_end;
-	break;
-      }
-    }
-
-    // Round numBytes up to the nearest page size.
-    numBytes = (numBytes + (PAGE_SIZE-1)) & -PAGE_SIZE;
-
-    // Claim memory via sbrk
-    startPtr = (uint8_t*)sbrk(numBytes);
-    if ((intptr_t)startPtr == -1)
-    {
-#ifdef EMMALLOC_VERBOSE
-      MAIN_THREAD_ASYNC_EM_ASM(console.error('claim_more_memory: sbrk failed!'));
-#endif
-      return false;
-    }
-#ifdef EMMALLOC_VERBOSE
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('claim_more_memory: claimed 0x' + ($0>>>0).toString(16) + ' - 0x' + ($1>>>0).toString(16) + ' (' + ($2>>>0) + ' bytes) via sbrk()'), startPtr, startPtr + numBytes, numBytes);
-#endif
-    assert(HAS_ALIGNMENT(startPtr, alignof(size_t)));
-    endPtr = startPtr + numBytes;
-  } while (0);
-
-  // Create a sentinel region at the end of the new heap block
-  Region *endSentinelRegion = (Region*)(endPtr - sizeof(Region));
-  create_used_region(endSentinelRegion, sizeof(Region));
-
-  // If we are the sole user of sbrk(), it will feed us continuous/consecutive memory addresses - take advantage
-  // of that if so: instead of creating two disjoint memory regions blocks, expand the previous one to a larger size.
-  uint8_t *previousSbrkEndAddress = listOfAllRegions ? listOfAllRegions->endPtr : 0;
-  if (startPtr == previousSbrkEndAddress)
-  {
-    Region *prevEndSentinel = prev_region((Region*)startPtr);
-    assert(debug_region_is_consistent(prevEndSentinel));
-    assert(region_is_in_use(prevEndSentinel));
-    Region *prevRegion = prev_region(prevEndSentinel);
-    assert(debug_region_is_consistent(prevRegion));
-
-    listOfAllRegions->endPtr = endPtr;
-
-    // Two scenarios, either the last region of the previous block was in use, in which case we need to create
-    // a new free region in the newly allocated space; or it was free, in which case we can extend that region
-    // to cover a larger size.
-    if (region_is_free(prevRegion))
-    {
-      size_t newFreeRegionSize = (uint8_t*)endSentinelRegion - (uint8_t*)prevRegion;
-      unlink_from_free_list(prevRegion);
-      create_free_region(prevRegion, newFreeRegionSize);
-      link_to_free_list(prevRegion);
-      return true;
-    }
-    // else: last region of the previous block was in use. Since we are joining two consecutive sbrk() blocks,
-    // we can swallow the end sentinel of the previous block away.
-    startPtr -= sizeof(Region);
-  }
-  else
-  {
-    // Create a root region at the start of the heap block
-    create_used_region(startPtr, sizeof(Region));
-
-    // Dynamic heap start region:
-    RootRegion *newRegionBlock = (RootRegion*)startPtr;
-    newRegionBlock->next = listOfAllRegions; // Pointer to next region block head
-    newRegionBlock->endPtr = endPtr; // Pointer to the end address of this region block
-    listOfAllRegions = newRegionBlock;
-    startPtr += sizeof(Region);
-  }
-
-  // Create a new memory region for the new claimed free space.
-  create_free_region(startPtr, (uint8_t*)endSentinelRegion - startPtr);
-  link_to_free_list((Region*)startPtr);
-  return true;
-}
-
-#if 0
-// Initialize emmalloc during static initialization.
-// See system/lib/README.md for static constructor ordering.
-__attribute__((constructor(47)))
-static void initialize_emmalloc_heap()
-{
-  // Initialize circular doubly linked lists representing free space
-  // Never useful to unroll this for loop, just takes up code size.
-#pragma clang loop unroll(disable)
-  for(int i = 0; i < NUM_FREE_BUCKETS; ++i)
-    freeRegionBuckets[i].prev = freeRegionBuckets[i].next = &freeRegionBuckets[i];
-
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('initialize_emmalloc_heap()'));
-#endif
-
-  // Start with a tiny dynamic region.
-  claim_more_memory(3*sizeof(Region));
-}
-
-void emmalloc_blank_slate_from_orbit()
-{
-  MALLOC_ACQUIRE();
-  listOfAllRegions = NULL;
-  freeRegionBucketsUsed = 0;
-  initialize_emmalloc_heap();
-  MALLOC_RELEASE();
-}
-#endif
-
-static void *attempt_allocate(Region *freeRegion, size_t alignment, size_t size)
-{
-  ASSERT_MALLOC_IS_ACQUIRED();
-  assert(freeRegion);
-  // Look at the next potential free region to allocate into.
-  // First, we should check if the free region has enough of payload bytes contained
-  // in it to accommodate the new allocation. This check needs to take account the
-  // requested allocation alignment, so the payload memory area needs to be rounded
-  // upwards to the desired alignment.
-  uint8_t *payloadStartPtr = region_payload_start_ptr(freeRegion);
-  uint8_t *payloadStartPtrAligned = ALIGN_UP(payloadStartPtr, alignment);
-  uint8_t *payloadEndPtr = region_payload_end_ptr(freeRegion);
-
-  // Do we have enough free space, taking into account alignment?
-  if (payloadStartPtrAligned + size > payloadEndPtr)
-    return NULL;
-
-  // We have enough free space, so the memory allocation will be made into this region. Remove this free region
-  // from the list of free regions: whatever slop remains will be later added back to the free region pool.
-  unlink_from_free_list(freeRegion);
-
-  // Before we proceed further, fix up the boundary of this region and the region that precedes this one,
-  // so that the boundary between the two regions happens at a right spot for the payload to be aligned.
-  if (payloadStartPtr != payloadStartPtrAligned)
-  {
-    Region *prevRegion = prev_region((Region*)freeRegion);
-    // We never have two free regions adjacent to each other, so the region before this free
-    // region should be in use.
-    assert(region_is_in_use(prevRegion));
-    size_t regionBoundaryBumpAmount = payloadStartPtrAligned - payloadStartPtr;
-    size_t newThisRegionSize = freeRegion->size - regionBoundaryBumpAmount;
-    create_used_region(prevRegion, prevRegion->size + regionBoundaryBumpAmount);
-    freeRegion = (Region *)((uint8_t*)freeRegion + regionBoundaryBumpAmount);
-    freeRegion->size = newThisRegionSize;
-  }
-  // Next, we need to decide whether this region is so large that it should be split into two regions,
-  // one representing the newly used memory area, and at the high end a remaining leftover free area.
-  // This splitting to two is done always if there is enough space for the high end to fit a region.
-  // Carve 'size' bytes of payload off this region. So,
-  // [sz prev next sz]
-  // becomes
-  // [sz payload sz] [sz prev next sz]
-  if (sizeof(Region) + REGION_HEADER_SIZE + size <= freeRegion->size)
-  {
-    // There is enough space to keep a free region at the end of the carved out block
-    // -> construct the new block
-    Region *newFreeRegion = (Region *)((uint8_t*)freeRegion + REGION_HEADER_SIZE + size);
-    create_free_region(newFreeRegion, freeRegion->size - size - REGION_HEADER_SIZE);
-    link_to_free_list(newFreeRegion);
-
-    // Recreate the resized Region under its new size.
-    create_used_region(freeRegion, size + REGION_HEADER_SIZE);
-  }
-  else
-  {
-    // There is not enough space to split the free memory region into used+free parts, so consume the whole
-    // region as used memory, not leaving a free memory region behind.
-    // Initialize the free region as used by resetting the ceiling size to the same value as the size at bottom.
-    ((size_t*)((uint8_t*)freeRegion + freeRegion->size))[-1] = freeRegion->size;
-  }
-
-#ifdef __EMSCRIPTEN_TRACING__
-  emscripten_trace_record_allocation(freeRegion, freeRegion->size);
-#endif
-
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('attempt_allocate - succeeded allocating memory, region ptr=0x' + ($0>>>0).toString(16) + ', align=' + $1 + ', payload size=' + ($2>>>0) + ' bytes)'), freeRegion, alignment, size);
-#endif
-
-  return (uint8_t*)freeRegion + sizeof(size_t);
-}
-
-static size_t validate_alloc_alignment(size_t alignment)
-{
-  // Cannot perform allocations that are less than 4 byte aligned, because the Region
-  // control structures need to be aligned. Also round up to minimum outputted alignment.
-  alignment = MAX(alignment, MALLOC_ALIGNMENT);
-  // Arbitrary upper limit on alignment - very likely a programming bug if alignment is higher than this.
-  assert(alignment <= 1024*1024);
-  return alignment;
-}
-
-static size_t validate_alloc_size(size_t size)
-{
-  assert(size + REGION_HEADER_SIZE > size);
-
-  // Allocation sizes must be a multiple of pointer sizes, and at least 2*sizeof(pointer).
-  size_t validatedSize = size > SMALLEST_ALLOCATION_SIZE ? (size_t)ALIGN_UP(size, sizeof(Region*)) : SMALLEST_ALLOCATION_SIZE;
-  assert(validatedSize >= size); // 32-bit wraparound should not occur, too large sizes should be stopped before
-
-  return validatedSize;
-}
-
-static void *allocate_memory(size_t alignment, size_t size)
-{
-  ASSERT_MALLOC_IS_ACQUIRED();
-
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('allocate_memory(align=' + $0 + ', size=' + ($1>>>0) + ' bytes)'), alignment, size);
-#endif
-
-#ifdef EMMALLOC_MEMVALIDATE
-  validate_memory_regions();
-#endif
-
-  if (!IS_POWER_OF_2(alignment))
-  {
-#ifdef EMMALLOC_VERBOSE
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('Allocation failed: alignment not power of 2!'));
-#endif
-    return 0;
-  }
-
-  if (size > MAX_ALLOC_SIZE)
-  {
-#ifdef EMMALLOC_VERBOSE
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('Allocation failed: attempted allocation size is too large: ' + ($0 >>> 0) + 'bytes! (negative integer wraparound?)'), size);
-#endif
-    return 0;
-  }
-
-  alignment = validate_alloc_alignment(alignment);
-  size = validate_alloc_size(size);
-
-  // Attempt to allocate memory starting from smallest bucket that can contain the required amount of memory.
-  // Under normal alignment conditions this should always be the first or second bucket we look at, but if
-  // performing an allocation with complex alignment, we may need to look at multiple buckets.
-  int bucketIndex = compute_free_list_bucket(size);
-  BUCKET_BITMASK_T bucketMask = freeRegionBucketsUsed >> bucketIndex;
-
-  // Loop through each bucket that has free regions in it, based on bits set in freeRegionBucketsUsed bitmap.
-  while(bucketMask)
-  {
-    BUCKET_BITMASK_T indexAdd = __builtin_ctzll(bucketMask);
-    bucketIndex += indexAdd;
-    bucketMask >>= indexAdd;
-    assert(bucketIndex >= 0);
-    assert(bucketIndex <= NUM_FREE_BUCKETS-1);
-    assert(freeRegionBucketsUsed & (((BUCKET_BITMASK_T)1) << bucketIndex));
-
-    Region *freeRegion = freeRegionBuckets[bucketIndex].next;
-    assert(freeRegion);
-    if (freeRegion != &freeRegionBuckets[bucketIndex])
-    {
-      void *ptr = attempt_allocate(freeRegion, alignment, size);
-      if (ptr)
-        return ptr;
-
-      // We were not able to allocate from the first region found in this bucket, so penalize
-      // the region by cycling it to the end of the doubly circular linked list. (constant time)
-      // This provides a randomized guarantee that when performing allocations of size k to a
-      // bucket of [k-something, k+something] range, we will not always attempt to satisfy the
-      // allocation from the same available region at the front of the list, but we try each
-      // region in turn.
-      unlink_from_free_list(freeRegion);
-      prepend_to_free_list(freeRegion, &freeRegionBuckets[bucketIndex]);
-      // But do not stick around to attempt to look at other regions in this bucket - move
-      // to search the next populated bucket index if this did not fit. This gives a practical
-      // "allocation in constant time" guarantee, since the next higher bucket will only have
-      // regions that are all of strictly larger size than the requested allocation. Only if
-      // there is a difficult alignment requirement we may fail to perform the allocation from
-      // a region in the next bucket, and if so, we keep trying higher buckets until one of them
-      // works.
-      ++bucketIndex;
-      bucketMask >>= 1;
-    }
-    else
-    {
-      // This bucket was not populated after all with any regions,
-      // but we just had a stale bit set to mark a populated bucket.
-      // Reset the bit to update latest status so that we do not
-      // redundantly look at this bucket again.
-      freeRegionBucketsUsed &= ~(((BUCKET_BITMASK_T)1) << bucketIndex);
-      bucketMask ^= 1;
-    }
-    // Instead of recomputing bucketMask from scratch at the end of each loop, it is updated as we go,
-    // to avoid undefined behavior with (x >> 32)/(x >> 64) when bucketIndex reaches 32/64, (the shift would comes out as a no-op instead of 0).
-
-    assert((bucketIndex == NUM_FREE_BUCKETS && bucketMask == 0) || (bucketMask == freeRegionBucketsUsed >> bucketIndex));
-  }
-
-  // None of the buckets were able to accommodate an allocation. If this happens we are almost out of memory.
-  // The largest bucket might contain some suitable regions, but we only looked at one region in that bucket, so
-  // as a last resort, loop through more free regions in the bucket that represents the largest allocations available.
-  // But only if the bucket representing largest allocations available is not any of the first thirty buckets,
-  // these represent allocatable areas less than <1024 bytes - which could be a lot of scrap.
-  // In such case, prefer to sbrk() in more memory right away.
-  int largestBucketIndex = NUM_FREE_BUCKETS - 1 - __builtin_clzll(freeRegionBucketsUsed);
-  // freeRegion will be null if there is absolutely no memory left. (all buckets are 100% used)
-  Region *freeRegion = freeRegionBucketsUsed ? freeRegionBuckets[largestBucketIndex].next : 0;
-  if (freeRegionBucketsUsed >> 30)
-  {
-    // Look only at a constant number of regions in this bucket max, to avoid bad worst case behavior.
-    // If this many regions cannot find free space, we give up and prefer to sbrk() more instead.
-    const int maxRegionsToTryBeforeGivingUp = 99;
-    int numTriesLeft = maxRegionsToTryBeforeGivingUp;
-    while(freeRegion != &freeRegionBuckets[largestBucketIndex] && numTriesLeft-- > 0)
-    {
-      void *ptr = attempt_allocate(freeRegion, alignment, size);
-      if (ptr)
-        return ptr;
-      freeRegion = freeRegion->next;
-    }
-  }
-
-  // We were unable to find a free memory region. Must sbrk() in more memory!
-  size_t numBytesToClaim = size+sizeof(Region)*3;
-  assert(numBytesToClaim > size); // 32-bit wraparound should not happen here, allocation size has been validated above!
-  bool success = claim_more_memory(numBytesToClaim);
-  if (success)
-    return allocate_memory(alignment, size); // Recurse back to itself to try again
-
-  // also sbrk() failed, we are really really constrained :( As a last resort, go back to looking at the
-  // bucket we already looked at above, continuing where the above search left off - perhaps there are
-  // regions we overlooked the first time that might be able to satisfy the allocation.
-  if (freeRegion)
-  {
-    while(freeRegion != &freeRegionBuckets[largestBucketIndex])
-    {
-      void *ptr = attempt_allocate(freeRegion, alignment, size);
-      if (ptr)
-        return ptr;
-      freeRegion = freeRegion->next;
-    }
-  }
-
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('Could not find a free memory block!'));
-#endif
-
-  return 0;
-}
-
-static
-void *emmalloc_memalign(size_t alignment, size_t size)
-{
-  MALLOC_ACQUIRE();
-  void *ptr = allocate_memory(alignment, size);
-  MALLOC_RELEASE();
-  return ptr;
-}
-
-#if 0
-void * EMMALLOC_EXPORT memalign(size_t alignment, size_t size)
-{
-  return emmalloc_memalign(alignment, size);
-}
-#endif
-
-void * EMMALLOC_EXPORT aligned_alloc(size_t alignment, size_t size)
-{
-  if ((alignment % sizeof(void *) != 0) || (size % alignment) != 0)
-    return 0;
-  return emmalloc_memalign(alignment, size);
-}
-
-static
-void *emmalloc_malloc(size_t size)
-{
-  return emmalloc_memalign(MALLOC_ALIGNMENT, size);
-}
-
-void * EMMALLOC_EXPORT malloc(size_t size)
-{
-  return emmalloc_malloc(size);
-}
-
-static
-size_t emmalloc_usable_size(void *ptr)
-{
-  if (!ptr)
-    return 0;
-
-  uint8_t *regionStartPtr = (uint8_t*)ptr - sizeof(size_t);
-  Region *region = (Region*)(regionStartPtr);
-  assert(HAS_ALIGNMENT(region, sizeof(size_t)));
-
-  MALLOC_ACQUIRE();
-
-  size_t size = region->size;
-  assert(size >= sizeof(Region));
-  assert(region_is_in_use(region));
-
-  MALLOC_RELEASE();
-
-  return size - REGION_HEADER_SIZE;
-}
-
-size_t EMMALLOC_EXPORT malloc_usable_size(void *ptr)
-{
-  return emmalloc_usable_size(ptr);
-}
-
-static
-void emmalloc_free(void *ptr)
-{
-#ifdef EMMALLOC_MEMVALIDATE
-  emmalloc_validate_memory_regions();
-#endif
-
-  if (!ptr)
-    return;
-
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('free(ptr=0x'+($0>>>0).toString(16)+')'), ptr);
-#endif
-
-  uint8_t *regionStartPtr = (uint8_t*)ptr - sizeof(size_t);
-  Region *region = (Region*)(regionStartPtr);
-  assert(HAS_ALIGNMENT(region, sizeof(size_t)));
-
-  MALLOC_ACQUIRE();
-
-  size_t size = region->size;
-#ifdef EMMALLOC_VERBOSE
-  if (size < sizeof(Region) || !region_is_in_use(region))
-  {
-    if (debug_region_is_consistent(region))
-      // LLVM wasm backend bug: cannot use MAIN_THREAD_ASYNC_EM_ASM() here, that generates internal compiler error
-      // Reproducible by running e.g. other.test_alloc_3GB
-      EM_ASM(console.error('Double free at region ptr 0x' + ($0>>>0).toString(16) + ', region->size: 0x' + ($1>>>0).toString(16) + ', region->sizeAtCeiling: 0x' + ($2>>>0).toString(16) + ')'), region, size, region_ceiling_size(region));
-    else
-      MAIN_THREAD_ASYNC_EM_ASM(console.error('Corrupt region at region ptr 0x' + ($0>>>0).toString(16) + ' region->size: 0x' + ($1>>>0).toString(16) + ', region->sizeAtCeiling: 0x' + ($2>>>0).toString(16) + ')'), region, size, region_ceiling_size(region));
-  }
-#endif
-  assert(size >= sizeof(Region));
-  assert(region_is_in_use(region));
-
-#ifdef __EMSCRIPTEN_TRACING__
-  emscripten_trace_record_free(region);
-#endif
-
-  // Check merging with left side
-  size_t prevRegionSizeField = ((size_t*)region)[-1];
-  size_t prevRegionSize = prevRegionSizeField & ~FREE_REGION_FLAG;
-  if (prevRegionSizeField != prevRegionSize) // Previous region is free?
-  {
-    Region *prevRegion = (Region*)((uint8_t*)region - prevRegionSize);
-    assert(debug_region_is_consistent(prevRegion));
-    unlink_from_free_list(prevRegion);
-    regionStartPtr = (uint8_t*)prevRegion;
-    size += prevRegionSize;
-  }
-
-  // Check merging with right side
-  Region *nextRegion = next_region(region);
-  assert(debug_region_is_consistent(nextRegion));
-  size_t sizeAtEnd = *(size_t*)region_payload_end_ptr(nextRegion);
-  if (nextRegion->size != sizeAtEnd)
-  {
-    unlink_from_free_list(nextRegion);
-    size += nextRegion->size;
-  }
-
-  create_free_region(regionStartPtr, size);
-  link_to_free_list((Region*)regionStartPtr);
-
-  MALLOC_RELEASE();
-
-#ifdef EMMALLOC_MEMVALIDATE
-  emmalloc_validate_memory_regions();
-#endif
-}
-
-void EMMALLOC_EXPORT free(void *ptr)
-{
-  emmalloc_free(ptr);
-}
-
-// Can be called to attempt to increase or decrease the size of the given region
-// to a new size (in-place). Returns 1 if resize succeeds, and 0 on failure.
-static int attempt_region_resize(Region *region, size_t size)
-{
-  ASSERT_MALLOC_IS_ACQUIRED();
-  assert(size > 0);
-  assert(HAS_ALIGNMENT(size, sizeof(size_t)));
-
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('attempt_region_resize(region=0x' + ($0>>>0).toString(16) + ', size=' + ($1>>>0) + ' bytes)'), region, size);
-#endif
-
-  // First attempt to resize this region, if the next region that follows this one
-  // is a free region.
-  Region *nextRegion = next_region(region);
-  uint8_t *nextRegionEndPtr = (uint8_t*)nextRegion + nextRegion->size;
-  size_t sizeAtCeiling = ((size_t*)nextRegionEndPtr)[-1];
-  if (nextRegion->size != sizeAtCeiling) // Next region is free?
-  {
-    assert(region_is_free(nextRegion));
-    uint8_t *newNextRegionStartPtr = (uint8_t*)region + size;
-    assert(HAS_ALIGNMENT(newNextRegionStartPtr, sizeof(size_t)));
-    // Next region does not shrink to too small size?
-    if (newNextRegionStartPtr + sizeof(Region) <= nextRegionEndPtr)
-    {
-      unlink_from_free_list(nextRegion);
-      create_free_region(newNextRegionStartPtr, nextRegionEndPtr - newNextRegionStartPtr);
-      link_to_free_list((Region*)newNextRegionStartPtr);
-      create_used_region(region, newNextRegionStartPtr - (uint8_t*)region);
-      return 1;
-    }
-    // If we remove the next region altogether, allocation is satisfied?
-    if (newNextRegionStartPtr <= nextRegionEndPtr)
-    {
-      unlink_from_free_list(nextRegion);
-      create_used_region(region, region->size + nextRegion->size);
-      return 1;
-    }
-  }
-  else
-  {
-    // Next region is an used region - we cannot change its starting address. However if we are shrinking the
-    // size of this region, we can create a new free region between this and the next used region.
-    if (size + sizeof(Region) <= region->size)
-    {
-      size_t freeRegionSize = region->size - size;
-      create_used_region(region, size);
-      Region *freeRegion = (Region *)((uint8_t*)region + size);
-      create_free_region(freeRegion, freeRegionSize);
-      link_to_free_list(freeRegion);
-      return 1;
-    }
-    else if (size <= region->size)
-    {
-      // Caller was asking to shrink the size, but due to not being able to fit a full Region in the shrunk
-      // area, we cannot actually do anything. This occurs if the shrink amount is really small. In such case,
-      // just call it success without doing any work.
-      return 1;
-    }
-  }
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('attempt_region_resize failed.'));
-#endif
-  return 0;
-}
-
-static int acquire_and_attempt_region_resize(Region *region, size_t size)
-{
-  MALLOC_ACQUIRE();
-  int success = attempt_region_resize(region, size);
-  MALLOC_RELEASE();
-  return success;
-}
-
-static
-void *emmalloc_aligned_realloc(void *ptr, size_t alignment, size_t size)
-{
-#ifdef EMMALLOC_VERBOSE
-  MAIN_THREAD_ASYNC_EM_ASM(console.log('aligned_realloc(ptr=0x' + ($0>>>0).toString(16) + ', alignment=' + $1 + ', size=' + ($2>>>0)), ptr, alignment, size);
-#endif
-
-  if (!ptr)
-    return emmalloc_memalign(alignment, size);
-
-  if (size == 0)
-  {
-    free(ptr);
-    return 0;
-  }
-
-  if (size > MAX_ALLOC_SIZE)
-  {
-#ifdef EMMALLOC_VERBOSE
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('Allocation failed: attempted allocation size is too large: ' + ($0 >>> 0) + 'bytes! (negative integer wraparound?)'), size);
-#endif
-    return 0;
-  }
-
-  assert(IS_POWER_OF_2(alignment));
-  // aligned_realloc() cannot be used to ask to change the alignment of a pointer.
-  assert(HAS_ALIGNMENT(ptr, alignment));
-  size = validate_alloc_size(size);
-
-  // Calculate the region start address of the original allocation
-  Region *region = (Region*)((uint8_t*)ptr - sizeof(size_t));
-
-  // First attempt to resize the given region to avoid having to copy memory around
-  if (acquire_and_attempt_region_resize(region, size + REGION_HEADER_SIZE))
-  {
-#ifdef __EMSCRIPTEN_TRACING__
-    emscripten_trace_record_reallocation(ptr, ptr, size);
-#endif
-    return ptr;
-  }
-
-  // If resize failed, we must allocate a new region, copy the data over, and then
-  // free the old region.
-  void *newptr = emmalloc_memalign(alignment, size);
-  if (newptr)
-  {
-    memcpy(newptr, ptr, MIN(size, region->size - REGION_HEADER_SIZE));
-    free(ptr);
-  }
-  // N.B. If there is not enough memory, the old memory block should not be freed and
-  // null pointer is returned.
-  return newptr;
-}
-
-#if 0
-void * EMMALLOC_EXPORT aligned_realloc(void *ptr, size_t alignment, size_t size)
-{
-  return emmalloc_aligned_realloc(ptr, alignment, size);
-}
-#endif
-
-#if 0
-// realloc_try() is like realloc(), but only attempts to try to resize the existing memory
-// area. If resizing the existing memory area fails, then realloc_try() will return 0
-// (the original memory block is not freed or modified). If resizing succeeds, previous
-// memory contents will be valid up to min(old length, new length) bytes.
-void *emmalloc_realloc_try(void *ptr, size_t size)
-{
-  if (!ptr)
-    return 0;
-
-  if (size == 0)
-  {
-    free(ptr);
-    return 0;
-  }
-
-  if (size > MAX_ALLOC_SIZE)
-  {
-#ifdef EMMALLOC_VERBOSE
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('Allocation failed: attempted allocation size is too large: ' + ($0 >>> 0) + 'bytes! (negative integer wraparound?)'), size);
-#endif
-    return 0;
-  }
-
-  size = validate_alloc_size(size);
-
-  // Calculate the region start address of the original allocation
-  Region *region = (Region*)((uint8_t*)ptr - sizeof(size_t));
-
-  // Attempt to resize the given region to avoid having to copy memory around
-  int success = acquire_and_attempt_region_resize(region, size + REGION_HEADER_SIZE);
-#ifdef __EMSCRIPTEN_TRACING__
-  if (success)
-    emscripten_trace_record_reallocation(ptr, ptr, size);
-#endif
-  return success ? ptr : 0;
-}
-
-// emmalloc_aligned_realloc_uninitialized() is like aligned_realloc(), but old memory contents
-// will be undefined after reallocation. (old memory is not preserved in any case)
-void *emmalloc_aligned_realloc_uninitialized(void *ptr, size_t alignment, size_t size)
-{
-  if (!ptr)
-    return emmalloc_memalign(alignment, size);
-
-  if (size == 0)
-  {
-    free(ptr);
-    return 0;
-  }
-
-  if (size > MAX_ALLOC_SIZE)
-  {
-#ifdef EMMALLOC_VERBOSE
-    MAIN_THREAD_ASYNC_EM_ASM(console.log('Allocation failed: attempted allocation size is too large: ' + ($0 >>> 0) + 'bytes! (negative integer wraparound?)'), size);
-#endif
-    return 0;
-  }
-
-  size = validate_alloc_size(size);
-
-  // Calculate the region start address of the original allocation
-  Region *region = (Region*)((uint8_t*)ptr - sizeof(size_t));
-
-  // First attempt to resize the given region to avoid having to copy memory around
-  if (acquire_and_attempt_region_resize(region, size + REGION_HEADER_SIZE))
-  {
-#ifdef __EMSCRIPTEN_TRACING__
-    emscripten_trace_record_reallocation(ptr, ptr, size);
-#endif
-    return ptr;
-  }
-
-  // If resize failed, drop the old region and allocate a new region. Memory is not
-  // copied over
-  free(ptr);
-  return emmalloc_memalign(alignment, size);
-}
-#endif
-
-static
-void *emmalloc_realloc(void *ptr, size_t size)
-{
-  return emmalloc_aligned_realloc(ptr, MALLOC_ALIGNMENT, size);
-}
-
-void * EMMALLOC_EXPORT realloc(void *ptr, size_t size)
-{
-  return emmalloc_realloc(ptr, size);
-}
-
-#if 0
-// realloc_uninitialized() is like realloc(), but old memory contents
-// will be undefined after reallocation. (old memory is not preserved in any case)
-void *emmalloc_realloc_uninitialized(void *ptr, size_t size)
-{
-  return emmalloc_aligned_realloc_uninitialized(ptr, MALLOC_ALIGNMENT, size);
-}
-#endif
-
-static
-int emmalloc_posix_memalign(void **memptr, size_t alignment, size_t size)
-{
-  assert(memptr);
-  if (alignment % sizeof(void *) != 0)
-    return 22/* EINVAL*/;
-  *memptr = emmalloc_memalign(alignment, size);
-  return *memptr ?  0 : 12/*ENOMEM*/;
-}
-
-int EMMALLOC_EXPORT posix_memalign(void **memptr, size_t alignment, size_t size)
-{
-  return emmalloc_posix_memalign(memptr, alignment, size);
-}
-
-static
-void *emmalloc_calloc(size_t num, size_t size)
-{
-  size_t bytes = num*size;
-  void *ptr = emmalloc_memalign(MALLOC_ALIGNMENT, bytes);
-  if (ptr)
-    memset(ptr, 0, bytes);
-  return ptr;
-}
-
-void * EMMALLOC_EXPORT calloc(size_t num, size_t size)
-{
-  return emmalloc_calloc(num, size);
-}
-
-#if 0
-static int count_linked_list_size(Region *list)
-{
-  int size = 1;
-  for(Region *i = list->next; i != list; list = list->next)
-    ++size;
-  return size;
-}
-
-static size_t count_linked_list_space(Region *list)
-{
-  size_t space = 0;
-  for(Region *i = list->next; i != list; list = list->next)
-    space += region_payload_end_ptr(i) - region_payload_start_ptr(i);
-  return space;
-}
-
-struct mallinfo emmalloc_mallinfo()
-{
-  MALLOC_ACQUIRE();
-
-  struct mallinfo info;
-  // Non-mmapped space allocated (bytes): For emmalloc,
-  // let's define this as the difference between heap size and dynamic top end.
-  info.arena = emscripten_get_heap_size() - (size_t)sbrk(0);
-  // Number of "ordinary" blocks. Let's define this as the number of highest
-  // size blocks. (subtract one from each, since there is a sentinel node in each list)
-  info.ordblks = count_linked_list_size(&freeRegionBuckets[NUM_FREE_BUCKETS-1])-1;
-  // Number of free "fastbin" blocks. For emmalloc, define this as the number
-  // of blocks that are not in the largest pristine block.
-  info.smblks = 0;
-  // The total number of bytes in free "fastbin" blocks.
-  info.fsmblks = 0;
-  for(int i = 0; i < NUM_FREE_BUCKETS-1; ++i)
-  {
-    info.smblks += count_linked_list_size(&freeRegionBuckets[i])-1;
-    info.fsmblks += count_linked_list_space(&freeRegionBuckets[i]);
-  }
-
-  info.hblks = 0; // Number of mmapped regions: always 0. (no mmap support)
-  info.hblkhd = 0; // Amount of bytes in mmapped regions: always 0. (no mmap support)
-
-  // Walk through all the heap blocks to report the following data:
-  // The "highwater mark" for allocated space—that is, the maximum amount of
-  // space that was ever allocated. Emmalloc does not want to pay code to
-  // track this, so this is only reported from current allocation data, and
-  // may not be accurate.
-  info.usmblks = 0;
-  info.uordblks = 0; // The total number of bytes used by in-use allocations.
-  info.fordblks = 0; // The total number of bytes in free blocks.
-  // The total amount of releasable free space at the top of the heap.
-  // This is the maximum number of bytes that could ideally be released by malloc_trim(3).
-  Region *lastActualRegion = prev_region((Region*)(listOfAllRegions->endPtr - sizeof(Region)));
-  info.keepcost = region_is_free(lastActualRegion) ? lastActualRegion->size : 0;
-
-  RootRegion *root = listOfAllRegions;
-  while(root)
-  {
-    Region *r = (Region*)root;
-    assert(debug_region_is_consistent(r));
-    uint8_t *lastRegionEnd = root->endPtr;
-    while((uint8_t*)r < lastRegionEnd)
-    {
-      assert(debug_region_is_consistent(r));
-
-      if (region_is_free(r))
-      {
-        // Count only the payload of the free block towards free memory.
-        info.fordblks += region_payload_end_ptr(r) - region_payload_start_ptr(r);
-        // But the header data of the free block goes towards used memory.
-        info.uordblks += REGION_HEADER_SIZE;
-      }
-      else
-      {
-        info.uordblks += r->size;
-      }
-      // Update approximate watermark data
-      info.usmblks = MAX(info.usmblks, (intptr_t)r + r->size);
-
-      if (r->size == 0)
-        break;
-      r = next_region(r);
-    }
-    root = root->next;
-  }
-
-  MALLOC_RELEASE();
-  return info;
-}
-
-struct mallinfo EMMALLOC_EXPORT mallinfo()
-{
-  return emmalloc_mallinfo();
-}
-
-// Note! This function is not fully multithreadin safe: while this function is running, other threads should not be
-// allowed to call sbrk()!
-static int trim_dynamic_heap_reservation(size_t pad)
-{
-  ASSERT_MALLOC_IS_ACQUIRED();
-
-  if (!listOfAllRegions)
-    return 0; // emmalloc is not controlling any dynamic memory at all - cannot release memory.
-  uint8_t *previousSbrkEndAddress = listOfAllRegions->endPtr;
-  assert(sbrk(0) == previousSbrkEndAddress);
-  size_t lastMemoryRegionSize = ((size_t*)previousSbrkEndAddress)[-1];
-  assert(lastMemoryRegionSize == 16); // // The last memory region should be a sentinel node of exactly 16 bytes in size.
-  Region *endSentinelRegion = (Region*)(previousSbrkEndAddress - sizeof(Region));
-  Region *lastActualRegion = prev_region(endSentinelRegion);
-
-  // Round padding up to multiple of 4 bytes to keep sbrk() and memory region alignment intact.
-  // Also have at least 8 bytes of payload so that we can form a full free region.
-  size_t newRegionSize = (size_t)ALIGN_UP(pad, 4);
-  if (pad > 0)
-    newRegionSize += sizeof(Region) - (newRegionSize - pad);
-
-  if (!region_is_free(lastActualRegion) || lastActualRegion->size <= newRegionSize)
-    return 0; // Last actual region is in use, or caller desired to leave more free memory intact than there is.
-
-  // This many bytes will be shrunk away.
-  size_t shrinkAmount = lastActualRegion->size - newRegionSize;
-  assert(HAS_ALIGNMENT(shrinkAmount, 4));
-
-  unlink_from_free_list(lastActualRegion);
-  // If pad == 0, we should delete the last free region altogether. If pad > 0,
-  // shrink the last free region to the desired size.
-  if (newRegionSize > 0)
-  {
-    create_free_region(lastActualRegion, newRegionSize);
-    link_to_free_list(lastActualRegion);
-  }
-
-  // Recreate the sentinel region at the end of the last free region
-  endSentinelRegion = (Region*)((uint8_t*)lastActualRegion + newRegionSize);
-  create_used_region(endSentinelRegion, sizeof(Region));
-
-  // And update the size field of the whole region block.
-  listOfAllRegions->endPtr = (uint8_t*)endSentinelRegion + sizeof(Region);
-
-  // Finally call sbrk() to shrink the memory area.
-  void *oldSbrk = sbrk(-(intptr_t)shrinkAmount);
-  assert((intptr_t)oldSbrk != -1); // Shrinking with sbrk() should never fail.
-  assert(oldSbrk == previousSbrkEndAddress); // Another thread should not have raced to increase sbrk() on us!
-
-  // All successful, and we actually trimmed memory!
-  return 1;
-}
-
-int emmalloc_trim(size_t pad)
-{
-  MALLOC_ACQUIRE();
-  int success = trim_dynamic_heap_reservation(pad);
-  MALLOC_RELEASE();
-  return success;
-}
-
-int EMMALLOC_EXPORT malloc_trim(size_t pad)
-{
-  return emmalloc_trim(pad);
-}
-
-size_t emmalloc_dynamic_heap_size()
-{
-  size_t dynamicHeapSize = 0;
-
-  MALLOC_ACQUIRE();
-  RootRegion *root = listOfAllRegions;
-  while(root)
-  {
-    dynamicHeapSize += root->endPtr - (uint8_t*)root;
-    root = root->next;
-  }
-  MALLOC_RELEASE();
-  return dynamicHeapSize;
-}
-
-size_t emmalloc_free_dynamic_memory()
-{
-  size_t freeDynamicMemory = 0;
-
-  int bucketIndex = 0;
-
-  MALLOC_ACQUIRE();
-  BUCKET_BITMASK_T bucketMask = freeRegionBucketsUsed;
-
-  // Loop through each bucket that has free regions in it, based on bits set in freeRegionBucketsUsed bitmap.
-  while(bucketMask)
-  {
-    BUCKET_BITMASK_T indexAdd = __builtin_ctzll(bucketMask);
-    bucketIndex += indexAdd;
-    bucketMask >>= indexAdd;
-    for(Region *freeRegion = freeRegionBuckets[bucketIndex].next;
-      freeRegion != &freeRegionBuckets[bucketIndex];
-      freeRegion = freeRegion->next)
-    {
-      freeDynamicMemory += freeRegion->size - REGION_HEADER_SIZE;
-    }
-    ++bucketIndex;
-    bucketMask >>= 1;
-  }
-  MALLOC_RELEASE();
-  return freeDynamicMemory;
-}
-
-size_t emmalloc_compute_free_dynamic_memory_fragmentation_map(size_t freeMemorySizeMap[32])
-{
-  memset((void*)freeMemorySizeMap, 0, sizeof(freeMemorySizeMap[0])*32);
-
-  size_t numFreeMemoryRegions = 0;
-  int bucketIndex = 0;
-  MALLOC_ACQUIRE();
-  BUCKET_BITMASK_T bucketMask = freeRegionBucketsUsed;
-
-  // Loop through each bucket that has free regions in it, based on bits set in freeRegionBucketsUsed bitmap.
-  while(bucketMask)
-  {
-    BUCKET_BITMASK_T indexAdd = __builtin_ctzll(bucketMask);
-    bucketIndex += indexAdd;
-    bucketMask >>= indexAdd;
-    for(Region *freeRegion = freeRegionBuckets[bucketIndex].next;
-      freeRegion != &freeRegionBuckets[bucketIndex];
-      freeRegion = freeRegion->next)
-    {
-      ++numFreeMemoryRegions;
-      size_t freeDynamicMemory = freeRegion->size - REGION_HEADER_SIZE;
-      if (freeDynamicMemory > 0)
-        ++freeMemorySizeMap[31-__builtin_clz(freeDynamicMemory)];
-      else
-        ++freeMemorySizeMap[0];
-    }
-    ++bucketIndex;
-    bucketMask >>= 1;
-  }
-  MALLOC_RELEASE();
-  return numFreeMemoryRegions;
-}
-
-size_t emmalloc_unclaimed_heap_memory(void) {
-  return emscripten_get_heap_max() - (size_t)sbrk(0);
-}
-#endif
-
-// Define these to satisfy musl references.
-void *__libc_malloc(size_t) __attribute__((alias("malloc")));
-void __libc_free(void *) __attribute__((alias("free")));
-void *__libc_calloc(size_t nmemb, size_t size) __attribute__((alias("calloc")));
diff --git a/lib/std/heap/SmpAllocator.zig b/lib/std/heap/SmpAllocator.zig
index 50380d29b534e5c7d41a32c0c9d74af4efad3f08..5982026cbca00834fe7d7be5e099a9a964c17ecc 100644
--- a/lib/std/heap/SmpAllocator.zig
+++ b/lib/std/heap/SmpAllocator.zig
@@ -26,6 +26,7 @@
 //! By limiting the thread-local metadata array to the same number as the CPU
 //! count, ensures that as threads are created and destroyed, they cycle
 //! through the full set of freelists.
+const SmpAllocator = @This();
 
 const builtin = @import("builtin");
 
@@ -34,7 +35,7 @@ const assert = std.debug.assert;
 const mem = std.mem;
 const math = std.math;
 const Allocator = std.mem.Allocator;
-const SmpAllocator = @This();
+const Alignment = std.mem.Alignment;
 const PageAllocator = std.heap.PageAllocator;
 
 cpu_count: u32,
@@ -114,7 +115,7 @@ comptime {
     assert(!builtin.single_threaded); // you're holding it wrong
 }
 
-fn alloc(context: *anyopaque, len: usize, alignment: mem.Alignment, ra: usize) ?[*]u8 {
+fn alloc(context: *anyopaque, len: usize, alignment: Alignment, ra: usize) ?[*]u8 {
     _ = context;
     _ = ra;
     const class = sizeClassIndex(len, alignment);
@@ -172,7 +173,7 @@ fn alloc(context: *anyopaque, len: usize, alignment: mem.Alignment, ra: usize) ?
     }
 }
 
-fn resize(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len: usize, ra: usize) bool {
+fn resize(context: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ra: usize) bool {
     _ = context;
     _ = ra;
     const class = sizeClassIndex(memory.len, alignment);
@@ -184,7 +185,7 @@ fn resize(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len:
     return new_class == class;
 }
 
-fn remap(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len: usize, ra: usize) ?[*]u8 {
+fn remap(context: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ra: usize) ?[*]u8 {
     _ = context;
     _ = ra;
     const class = sizeClassIndex(memory.len, alignment);
@@ -196,7 +197,7 @@ fn remap(context: *anyopaque, memory: []u8, alignment: mem.Alignment, new_len: u
     return if (new_class == class) memory.ptr else null;
 }
 
-fn free(context: *anyopaque, memory: []u8, alignment: mem.Alignment, ra: usize) void {
+fn free(context: *anyopaque, memory: []u8, alignment: Alignment, ra: usize) void {
     _ = context;
     _ = ra;
     const class = sizeClassIndex(memory.len, alignment);
@@ -214,7 +215,7 @@ fn free(context: *anyopaque, memory: []u8, alignment: mem.Alignment, ra: usize)
     t.frees[class] = @intFromPtr(node);
 }
 
-fn sizeClassIndex(len: usize, alignment: mem.Alignment) usize {
+fn sizeClassIndex(len: usize, alignment: Alignment) usize {
     return @max(@bitSizeOf(usize) - @clz(len - 1), @intFromEnum(alignment), min_class) - min_class;
 }
 
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 8cdc4a966f2bdad68f5623543d651255df9fcd98..54fa1aed853c53dd213666ad5184eee881814868 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -352,8 +352,7 @@ const Ext = enum {
 fn addSrcFile(arena: Allocator, source_table: *std.StringArrayHashMap(Ext), file_path: []const u8) !void {
     const ext: Ext = ext: {
         if (mem.endsWith(u8, file_path, ".c")) {
-            if (mem.startsWith(u8, file_path, "musl/src/malloc/") or
-                mem.startsWith(u8, file_path, "musl/src/string/") or
+            if (mem.startsWith(u8, file_path, "musl/src/string/") or
                 mem.startsWith(u8, file_path, "musl/src/internal/"))
             {
                 break :ext .o3;
@@ -786,24 +785,6 @@ const src_files = [_][]const u8{
     "musl/src/locale/uselocale.c",
     "musl/src/locale/wcscoll.c",
     "musl/src/locale/wcsxfrm.c",
-    "musl/src/malloc/calloc.c",
-    "musl/src/malloc/free.c",
-    "musl/src/malloc/libc_calloc.c",
-    "musl/src/malloc/lite_malloc.c",
-    "musl/src/malloc/mallocng/aligned_alloc.c",
-    "musl/src/malloc/mallocng/donate.c",
-    "musl/src/malloc/mallocng/free.c",
-    "musl/src/malloc/mallocng/malloc.c",
-    "musl/src/malloc/mallocng/malloc_usable_size.c",
-    "musl/src/malloc/mallocng/realloc.c",
-    "musl/src/malloc/memalign.c",
-    "musl/src/malloc/oldmalloc/aligned_alloc.c",
-    "musl/src/malloc/oldmalloc/malloc.c",
-    "musl/src/malloc/oldmalloc/malloc_usable_size.c",
-    "musl/src/malloc/posix_memalign.c",
-    "musl/src/malloc/reallocarray.c",
-    "musl/src/malloc/realloc.c",
-    "musl/src/malloc/replaced.c",
     "musl/src/math/aarch64/fma.c",
     "musl/src/math/aarch64/fmaf.c",
     "musl/src/math/aarch64/llrint.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index ca6231bf53344375ac78b809dcfe749b5a482b7c..2809f5c9f31ecb17c031bf1c55ef4406c988d7fc 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -77,22 +77,6 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
         .libc_a => {
             var libc_sources = std.array_list.Managed(Compilation.CSourceFile).init(arena);
 
-            {
-                // Compile emmalloc.
-                var args = std.array_list.Managed([]const u8).init(arena);
-                try addCCArgs(comp, arena, &args, .{ .want_O3 = true, .no_strict_aliasing = true });
-
-                for (emmalloc_src_files) |file_path| {
-                    try libc_sources.append(.{
-                        .src_path = try comp.dirs.zig_lib.join(arena, &.{
-                            "libc", try sanitize(arena, file_path),
-                        }),
-                        .extra_flags = args.items,
-                        .owner = undefined,
-                    });
-                }
-            }
-
             {
                 // Compile libc-bottom-half.
                 var args = std.array_list.Managed([]const u8).init(arena);
@@ -472,10 +456,6 @@ fn addLibcTopHalfIncludes(
     });
 }
 
-const emmalloc_src_files = [_][]const u8{
-    "wasi/emmalloc/emmalloc.c",
-};
-
 const libc_bottom_half_src_files = [_][]const u8{
     "wasi/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c",
     "wasi/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c",
-- 
2.54.0


From 6ccabbd4e558dd0d56c471408c4cf29e0992dc1c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 10 Feb 2026 19:28:43 -0800
Subject: [PATCH 268/499] std: brk allocator for single-threaded mode

---
 lib/c/malloc.zig                              |   6 +-
 lib/std/heap.zig                              |  29 +--
 .../{WasmAllocator.zig => BrkAllocator.zig}   |  96 ++++++----
 lib/std/heap/sbrk_allocator.zig               | 180 ------------------
 lib/std/os/linux.zig                          |   4 +
 5 files changed, 82 insertions(+), 233 deletions(-)
 rename lib/std/heap/{WasmAllocator.zig => BrkAllocator.zig} (79%)
 delete mode 100644 lib/std/heap/sbrk_allocator.zig

diff --git a/lib/c/malloc.zig b/lib/c/malloc.zig
index 72e7621b61057fdb1c31737c0af3c0b0262d53c0..4b8ba77b5ecef1d569c54f362285f0a647b2b596 100644
--- a/lib/c/malloc.zig
+++ b/lib/c/malloc.zig
@@ -1,7 +1,7 @@
-//! Based on wrapping a stateless Zig Allocator implementation, apropriate for:
+//! Based on wrapping a stateless Zig Allocator implementation, appropriate for:
 //! - ReleaseFast and ReleaseSmall optimization modes, with multi-threading
 //!   enabled.
-//! - WebAssembly in single-threaded mode.
+//! - WebAssembly or Linux in single-threaded release modes.
 //!
 //! Because the libc APIs don't have client alignment and size tracking, in
 //! order to take advantage of Zig allocator implementations, additional
@@ -40,7 +40,7 @@ const no_context: *anyopaque = undefined;
 const no_ra: usize = undefined;
 const vtable = switch (builtin.cpu.arch) {
     .wasm32, .wasm64 => std.heap.WasmAllocator.vtable,
-    else => std.heap.SmpAllocator.vtable,
+    else => if (builtin.single_threaded) std.heap.BrkAllocator.vtable else std.heap.SmpAllocator.vtable,
 };
 
 /// Needed because libc memory allocators don't provide old alignment and size
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index ba7ef0aabf4c77ef905aa14836ab0e91102b0ba1..562d0846efde69bf0d58b926896b6fc8100b3db2 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -13,9 +13,9 @@ pub const ArenaAllocator = @import("heap/arena_allocator.zig").ArenaAllocator;
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
-pub const SbrkAllocator = @import("heap/sbrk_allocator.zig").SbrkAllocator;
 pub const ThreadSafeAllocator = @import("heap/ThreadSafeAllocator.zig");
-pub const WasmAllocator = @import("heap/WasmAllocator.zig");
+pub const WasmAllocator = if (builtin.single_threaded) BrkAllocator else @compileError("unimplemented");
+pub const BrkAllocator = @import("heap/BrkAllocator.zig");
 
 pub const DebugAllocatorConfig = @import("heap/debug_allocator.zig").Config;
 pub const DebugAllocator = @import("heap/debug_allocator.zig").DebugAllocator;
@@ -356,9 +356,6 @@ pub const page_allocator: Allocator = if (@hasDecl(root, "os") and
 else if (builtin.target.cpu.arch.isWasm()) .{
     .ptr = undefined,
     .vtable = &WasmAllocator.vtable,
-} else if (builtin.target.os.tag == .plan9) .{
-    .ptr = undefined,
-    .vtable = &SbrkAllocator(std.os.plan9.sbrk).vtable,
 } else .{
     .ptr = undefined,
     .vtable = &PageAllocator.vtable,
@@ -369,16 +366,18 @@ pub const smp_allocator: Allocator = .{
     .vtable = &SmpAllocator.vtable,
 };
 
-/// This allocator is fast, small, and specific to WebAssembly. In the future,
-/// this will be the implementation automatically selected by
-/// `GeneralPurposeAllocator` when compiling in `ReleaseSmall` mode for wasm32
-/// and wasm64 architectures.
-/// Until then, it is available here to play with.
+/// This allocator is fast, small, and specific to WebAssembly.
 pub const wasm_allocator: Allocator = .{
     .ptr = undefined,
     .vtable = &WasmAllocator.vtable,
 };
 
+/// Supports single-threaded WebAssembly and Linux.
+pub const brk_allocator: Allocator = .{
+    .ptr = undefined,
+    .vtable = &BrkAllocator.vtable,
+};
+
 /// Returns a `StackFallbackAllocator` allocating using either a
 /// `FixedBufferAllocator` on an array of size `size` and falling back to
 /// `fallback_allocator` if that fails.
@@ -1014,9 +1013,11 @@ test {
     _ = GeneralPurposeAllocator;
     _ = FixedBufferAllocator;
     _ = ThreadSafeAllocator;
-    _ = SbrkAllocator;
-    if (builtin.target.cpu.arch.isWasm()) {
-        _ = WasmAllocator;
+    if (builtin.single_threaded) {
+        if (builtin.cpu.arch.isWasm() or (builtin.os.tag == .linux and !builtin.link_libc)) {
+            _ = brk_allocator;
+        }
+    } else {
+        _ = smp_allocator;
     }
-    if (!builtin.single_threaded) _ = smp_allocator;
 }
diff --git a/lib/std/heap/WasmAllocator.zig b/lib/std/heap/BrkAllocator.zig
similarity index 79%
rename from lib/std/heap/WasmAllocator.zig
rename to lib/std/heap/BrkAllocator.zig
index 2045d7c30373742e15afe2bb800a97f86be0d847..91b7230c9d30423d53afb3b6946d9c940990716e 100644
--- a/lib/std/heap/WasmAllocator.zig
+++ b/lib/std/heap/BrkAllocator.zig
@@ -1,20 +1,30 @@
-const std = @import("../std.zig");
+//! Supports single-threaded targets that have a sbrk-like primitive which includes
+//! Linux and WebAssembly.
+//!
+//! On Linux, assumes exclusive access to the brk syscall.
+const BrkAllocator = @This();
 const builtin = @import("builtin");
+
+const std = @import("../std.zig");
 const Allocator = std.mem.Allocator;
-const mem = std.mem;
+const Alignment = std.mem.Alignment;
 const assert = std.debug.assert;
-const wasm = std.wasm;
 const math = std.math;
+const page_size_max = std.heap.page_size_max;
 
 comptime {
-    if (!builtin.target.cpu.arch.isWasm()) {
-        @compileError("only available for wasm32 arch");
-    }
-    if (!builtin.single_threaded) {
-        @compileError("TODO implement support for multi-threaded wasm");
-    }
+    if (!builtin.single_threaded) @compileError("unsupported");
 }
 
+next_addrs: [size_class_count]usize = @splat(0),
+/// For each size class, points to the freed pointer.
+frees: [size_class_count]usize = @splat(0),
+/// For each big size class, points to the freed pointer.
+big_frees: [big_size_class_count]usize = @splat(0),
+prev_brk: usize = 0,
+
+var global: BrkAllocator = .{};
+
 pub const vtable: Allocator.VTable = .{
     .alloc = alloc,
     .resize = resize,
@@ -27,9 +37,13 @@ pub const Error = Allocator.Error;
 const max_usize = math.maxInt(usize);
 const ushift = math.Log2Int(usize);
 const bigpage_size = 64 * 1024;
-const pages_per_bigpage = bigpage_size / wasm.page_size;
+const pages_per_bigpage = bigpage_size / page_size_max;
 const bigpage_count = max_usize / bigpage_size;
 
+comptime {
+    assert(bigpage_size >= page_size_max);
+}
+
 /// Because of storing free list pointers, the minimum size class is 3.
 const min_class = math.log2(math.ceilPowerOfTwoAssert(usize, 1 + @sizeOf(usize)));
 const size_class_count = math.log2(bigpage_size) - min_class;
@@ -39,13 +53,7 @@ const size_class_count = math.log2(bigpage_size) - min_class;
 /// etc.
 const big_size_class_count = math.log2(bigpage_count);
 
-var next_addrs: [size_class_count]usize = @splat(0);
-/// For each size class, points to the freed pointer.
-var frees: [size_class_count]usize = @splat(0);
-/// For each big size class, points to the freed pointer.
-var big_frees: [big_size_class_count]usize = @splat(0);
-
-fn alloc(ctx: *anyopaque, len: usize, alignment: mem.Alignment, return_address: usize) ?[*]u8 {
+fn alloc(ctx: *anyopaque, len: usize, alignment: Alignment, return_address: usize) ?[*]u8 {
     _ = ctx;
     _ = return_address;
     // Make room for the freelist next pointer.
@@ -54,24 +62,24 @@ fn alloc(ctx: *anyopaque, len: usize, alignment: mem.Alignment, return_address:
     const class = math.log2(slot_size) - min_class;
     if (class < size_class_count) {
         const addr = a: {
-            const top_free_ptr = frees[class];
+            const top_free_ptr = global.frees[class];
             if (top_free_ptr != 0) {
                 const node: *usize = @ptrFromInt(top_free_ptr + (slot_size - @sizeOf(usize)));
-                frees[class] = node.*;
+                global.frees[class] = node.*;
                 break :a top_free_ptr;
             }
 
-            const next_addr = next_addrs[class];
-            if (next_addr % wasm.page_size == 0) {
+            const next_addr = global.next_addrs[class];
+            if (next_addr % page_size_max == 0) {
                 const addr = allocBigPages(1);
                 if (addr == 0) return null;
                 //std.debug.print("allocated fresh slot_size={d} class={d} addr=0x{x}\n", .{
                 //    slot_size, class, addr,
                 //});
-                next_addrs[class] = addr + slot_size;
+                global.next_addrs[class] = addr + slot_size;
                 break :a addr;
             } else {
-                next_addrs[class] = next_addr + slot_size;
+                global.next_addrs[class] = next_addr + slot_size;
                 break :a next_addr;
             }
         };
@@ -84,7 +92,7 @@ fn alloc(ctx: *anyopaque, len: usize, alignment: mem.Alignment, return_address:
 fn resize(
     ctx: *anyopaque,
     buf: []u8,
-    alignment: mem.Alignment,
+    alignment: Alignment,
     new_len: usize,
     return_address: usize,
 ) bool {
@@ -112,7 +120,7 @@ fn resize(
 fn remap(
     context: *anyopaque,
     memory: []u8,
-    alignment: mem.Alignment,
+    alignment: Alignment,
     new_len: usize,
     return_address: usize,
 ) ?[*]u8 {
@@ -122,7 +130,7 @@ fn remap(
 fn free(
     ctx: *anyopaque,
     buf: []u8,
-    alignment: mem.Alignment,
+    alignment: Alignment,
     return_address: usize,
 ) void {
     _ = ctx;
@@ -134,16 +142,16 @@ fn free(
     const addr = @intFromPtr(buf.ptr);
     if (class < size_class_count) {
         const node: *usize = @ptrFromInt(addr + (slot_size - @sizeOf(usize)));
-        node.* = frees[class];
-        frees[class] = addr;
+        node.* = global.frees[class];
+        global.frees[class] = addr;
     } else {
         const bigpages_needed = bigPagesNeeded(actual_len);
         const pow2_pages = math.ceilPowerOfTwoAssert(usize, bigpages_needed);
         const big_slot_size_bytes = pow2_pages * bigpage_size;
         const node: *usize = @ptrFromInt(addr + (big_slot_size_bytes - @sizeOf(usize)));
         const big_class = math.log2(pow2_pages);
-        node.* = big_frees[big_class];
-        big_frees[big_class] = addr;
+        node.* = global.big_frees[big_class];
+        global.big_frees[big_class] = addr;
     }
 }
 
@@ -156,16 +164,30 @@ fn allocBigPages(n: usize) usize {
     const slot_size_bytes = pow2_pages * bigpage_size;
     const class = math.log2(pow2_pages);
 
-    const top_free_ptr = big_frees[class];
+    const top_free_ptr = global.big_frees[class];
     if (top_free_ptr != 0) {
         const node: *usize = @ptrFromInt(top_free_ptr + (slot_size_bytes - @sizeOf(usize)));
-        big_frees[class] = node.*;
+        global.big_frees[class] = node.*;
         return top_free_ptr;
     }
 
-    const page_index = @wasmMemoryGrow(0, pow2_pages * pages_per_bigpage);
-    if (page_index == -1) return 0;
-    return @as(usize, @intCast(page_index)) * wasm.page_size;
+    if (builtin.cpu.arch.isWasm()) {
+        const page_index = @wasmMemoryGrow(0, pow2_pages * pages_per_bigpage);
+        if (page_index == -1) return 0;
+        return @as(usize, @intCast(page_index)) * page_size_max;
+    } else if (builtin.os.tag == .linux) {
+        const start_brk = s: {
+            const start_brk = global.prev_brk;
+            break :s if (start_brk == 0) std.os.linux.brk(0) else start_brk;
+        };
+        const end_brk = start_brk + pow2_pages * pages_per_bigpage * page_size_max;
+        const new_prev_brk = std.os.linux.brk(end_brk);
+        global.prev_brk = new_prev_brk;
+        if (new_prev_brk != end_brk) return 0;
+        return start_brk;
+    } else {
+        @compileError("no sbrk-like OS primitive available");
+    }
 }
 
 const test_ally: Allocator = .{
@@ -257,12 +279,14 @@ test "shrink" {
 }
 
 test "large object - grow" {
+    if (builtin.os.tag == .linux) return error.SkipZigTest;
+
     var slice1 = try test_ally.alloc(u8, bigpage_size * 2 - 20);
     defer test_ally.free(slice1);
 
     const old = slice1;
     slice1 = try test_ally.realloc(slice1, bigpage_size * 2 - 10);
-    try std.testing.expect(slice1.ptr == old.ptr);
+    try std.testing.expectEqual(slice1.ptr, old.ptr);
 
     slice1 = try test_ally.realloc(slice1, bigpage_size * 2);
     slice1 = try test_ally.realloc(slice1, bigpage_size * 2 + 1);
diff --git a/lib/std/heap/sbrk_allocator.zig b/lib/std/heap/sbrk_allocator.zig
deleted file mode 100644
index c4006d332239c38bc9fbeb7f770f81fd5f77bb22..0000000000000000000000000000000000000000
--- a/lib/std/heap/sbrk_allocator.zig
+++ /dev/null
@@ -1,180 +0,0 @@
-const builtin = @import("builtin");
-
-const std = @import("../std.zig");
-const Io = std.Io;
-const math = std.math;
-const Allocator = std.mem.Allocator;
-const mem = std.mem;
-const heap = std.heap;
-const assert = std.debug.assert;
-
-pub fn SbrkAllocator(comptime sbrk: *const fn (n: usize) usize) type {
-    return struct {
-        pub const vtable: Allocator.VTable = .{
-            .alloc = alloc,
-            .resize = resize,
-            .remap = remap,
-            .free = free,
-        };
-
-        pub const Error = Allocator.Error;
-
-        const max_usize = math.maxInt(usize);
-        const ushift = math.Log2Int(usize);
-        const bigpage_size = 64 * 1024;
-        const pages_per_bigpage = bigpage_size / heap.pageSize();
-        const bigpage_count = max_usize / bigpage_size;
-
-        /// Because of storing free list pointers, the minimum size class is 3.
-        const min_class = math.log2(math.ceilPowerOfTwoAssert(usize, 1 + @sizeOf(usize)));
-        const size_class_count = math.log2(bigpage_size) - min_class;
-        /// 0 - 1 bigpage
-        /// 1 - 2 bigpages
-        /// 2 - 4 bigpages
-        /// etc.
-        const big_size_class_count = math.log2(bigpage_count);
-
-        var next_addrs = [1]usize{0} ** size_class_count;
-        /// For each size class, points to the freed pointer.
-        var frees = [1]usize{0} ** size_class_count;
-        /// For each big size class, points to the freed pointer.
-        var big_frees = [1]usize{0} ** big_size_class_count;
-
-        // TODO don't do the naive locking strategy
-        var mutex: Io.Mutex = .{};
-        fn alloc(ctx: *anyopaque, len: usize, alignment: mem.Alignment, return_address: usize) ?[*]u8 {
-            _ = ctx;
-            _ = return_address;
-            Io.Threaded.mutexLock(&mutex);
-            defer Io.Threaded.mutexUnlock(&mutex);
-            // Make room for the freelist next pointer.
-            const actual_len = @max(len +| @sizeOf(usize), alignment.toByteUnits());
-            const slot_size = math.ceilPowerOfTwo(usize, actual_len) catch return null;
-            const class = math.log2(slot_size) - min_class;
-            if (class < size_class_count) {
-                const addr = a: {
-                    const top_free_ptr = frees[class];
-                    if (top_free_ptr != 0) {
-                        const node = @as(*usize, @ptrFromInt(top_free_ptr + (slot_size - @sizeOf(usize))));
-                        frees[class] = node.*;
-                        break :a top_free_ptr;
-                    }
-
-                    const next_addr = next_addrs[class];
-                    if (next_addr % heap.pageSize() == 0) {
-                        const addr = allocBigPages(1);
-                        if (addr == 0) return null;
-                        //std.debug.print("allocated fresh slot_size={d} class={d} addr=0x{x}\n", .{
-                        //    slot_size, class, addr,
-                        //});
-                        next_addrs[class] = addr + slot_size;
-                        break :a addr;
-                    } else {
-                        next_addrs[class] = next_addr + slot_size;
-                        break :a next_addr;
-                    }
-                };
-                return @as([*]u8, @ptrFromInt(addr));
-            }
-            const bigpages_needed = bigPagesNeeded(actual_len);
-            const addr = allocBigPages(bigpages_needed);
-            return @as([*]u8, @ptrFromInt(addr));
-        }
-
-        fn resize(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: mem.Alignment,
-            new_len: usize,
-            return_address: usize,
-        ) bool {
-            _ = ctx;
-            _ = return_address;
-            Io.Threaded.mutexLock(&mutex);
-            defer Io.Threaded.mutexUnlock(&mutex);
-            // We don't want to move anything from one size class to another, but we
-            // can recover bytes in between powers of two.
-            const buf_align = alignment.toByteUnits();
-            const old_actual_len = @max(buf.len + @sizeOf(usize), buf_align);
-            const new_actual_len = @max(new_len +| @sizeOf(usize), buf_align);
-            const old_small_slot_size = math.ceilPowerOfTwoAssert(usize, old_actual_len);
-            const old_small_class = math.log2(old_small_slot_size) - min_class;
-            if (old_small_class < size_class_count) {
-                const new_small_slot_size = math.ceilPowerOfTwo(usize, new_actual_len) catch return false;
-                return old_small_slot_size == new_small_slot_size;
-            } else {
-                const old_bigpages_needed = bigPagesNeeded(old_actual_len);
-                const old_big_slot_pages = math.ceilPowerOfTwoAssert(usize, old_bigpages_needed);
-                const new_bigpages_needed = bigPagesNeeded(new_actual_len);
-                const new_big_slot_pages = math.ceilPowerOfTwo(usize, new_bigpages_needed) catch return false;
-                return old_big_slot_pages == new_big_slot_pages;
-            }
-        }
-
-        fn remap(
-            context: *anyopaque,
-            memory: []u8,
-            alignment: mem.Alignment,
-            new_len: usize,
-            return_address: usize,
-        ) ?[*]u8 {
-            return if (resize(context, memory, alignment, new_len, return_address)) memory.ptr else null;
-        }
-
-        fn free(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: mem.Alignment,
-            return_address: usize,
-        ) void {
-            _ = ctx;
-            _ = return_address;
-            Io.Threaded.mutexLock(&mutex);
-            defer Io.Threaded.mutexUnlock(&mutex);
-            const buf_align = alignment.toByteUnits();
-            const actual_len = @max(buf.len + @sizeOf(usize), buf_align);
-            const slot_size = math.ceilPowerOfTwoAssert(usize, actual_len);
-            const class = math.log2(slot_size) - min_class;
-            const addr = @intFromPtr(buf.ptr);
-            if (class < size_class_count) {
-                const node = @as(*usize, @ptrFromInt(addr + (slot_size - @sizeOf(usize))));
-                node.* = frees[class];
-                frees[class] = addr;
-            } else {
-                const bigpages_needed = bigPagesNeeded(actual_len);
-                const pow2_pages = math.ceilPowerOfTwoAssert(usize, bigpages_needed);
-                const big_slot_size_bytes = pow2_pages * bigpage_size;
-                const node = @as(*usize, @ptrFromInt(addr + (big_slot_size_bytes - @sizeOf(usize))));
-                const big_class = math.log2(pow2_pages);
-                node.* = big_frees[big_class];
-                big_frees[big_class] = addr;
-            }
-        }
-
-        inline fn bigPagesNeeded(byte_count: usize) usize {
-            return (byte_count + (bigpage_size + (@sizeOf(usize) - 1))) / bigpage_size;
-        }
-
-        fn allocBigPages(n: usize) usize {
-            const pow2_pages = math.ceilPowerOfTwoAssert(usize, n);
-            const slot_size_bytes = pow2_pages * bigpage_size;
-            const class = math.log2(pow2_pages);
-
-            const top_free_ptr = big_frees[class];
-            if (top_free_ptr != 0) {
-                const node = @as(*usize, @ptrFromInt(top_free_ptr + (slot_size_bytes - @sizeOf(usize))));
-                big_frees[class] = node.*;
-                return top_free_ptr;
-            }
-            return sbrk(pow2_pages * pages_per_bigpage * heap.pageSize());
-        }
-    };
-}
-
-test SbrkAllocator {
-    _ = SbrkAllocator(struct {
-        fn sbrk(_: usize) usize {
-            return 0;
-        }
-    }.sbrk);
-}
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 32dd627e09ebdb29e7871b13f4d0ac3a1fe94fb2..8cce6c1dae8d06646450d865a8d6b932f6254710 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -594,6 +594,10 @@ pub fn errno(r: usize) E {
     return @enumFromInt(int);
 }
 
+pub fn brk(addr: usize) usize {
+    return syscall1(.brk, addr);
+}
+
 pub fn dup(old: i32) usize {
     return syscall1(.dup, @as(usize, @bitCast(@as(isize, old))));
 }
-- 
2.54.0


From e2fccd8dd5c09ed805c000a6c26c7d1eb1e7d6c1 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 10 Feb 2026 19:52:01 -0800
Subject: [PATCH 269/499] musl: remove macro redefinitions of malloc

---
 lib/libc/musl/src/aio/aio.c               | 5 -----
 lib/libc/musl/src/exit/atexit.c           | 5 -----
 lib/libc/musl/src/include/stdlib.h        | 6 ------
 lib/libc/musl/src/ldso/dlerror.c          | 5 -----
 lib/libc/musl/src/locale/dcngettext.c     | 5 -----
 lib/libc/musl/src/locale/duplocale.c      | 5 -----
 lib/libc/musl/src/locale/freelocale.c     | 5 -----
 lib/libc/musl/src/locale/locale_map.c     | 5 -----
 lib/libc/musl/src/locale/newlocale.c      | 5 -----
 lib/libc/musl/src/process/fdop.h          | 5 -----
 lib/libc/musl/src/thread/pthread_atfork.c | 5 -----
 lib/libc/musl/src/thread/sem_open.c       | 5 -----
 lib/libc/musl/src/time/__tz.c             | 5 -----
 13 files changed, 66 deletions(-)

diff --git a/lib/libc/musl/src/aio/aio.c b/lib/libc/musl/src/aio/aio.c
index d7e063bf93ca82fb5a6708a4bad7f8e1ead9e752..5c586260c33e79e71834deb71e38f046e1882ced 100644
--- a/lib/libc/musl/src/aio/aio.c
+++ b/lib/libc/musl/src/aio/aio.c
@@ -11,11 +11,6 @@
 #include "pthread_impl.h"
 #include "aio_impl.h"
 
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc __libc_realloc
-#define free __libc_free
-
 /* The following is a threads-based implementation of AIO with minimal
  * dependence on implementation details. Most synchronization is
  * performed with pthread primitives, but atomics and futex operations
diff --git a/lib/libc/musl/src/exit/atexit.c b/lib/libc/musl/src/exit/atexit.c
index 854e9fddbe559218805261c7623dbaa7304569d1..2804a1d7ad31971be2bda9447f76b271f51da30b 100644
--- a/lib/libc/musl/src/exit/atexit.c
+++ b/lib/libc/musl/src/exit/atexit.c
@@ -4,11 +4,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc undef
-#define free undef
-
 /* Ensure that at least 32 atexit handlers can be registered without malloc */
 #define COUNT 32
 
diff --git a/lib/libc/musl/src/include/stdlib.h b/lib/libc/musl/src/include/stdlib.h
index 812b04de2fd6b6efb1576a72eea4fa16007fc2ad..1599691fbeec4d037674c309a03dccec1e12db36 100644
--- a/lib/libc/musl/src/include/stdlib.h
+++ b/lib/libc/musl/src/include/stdlib.h
@@ -10,10 +10,4 @@ hidden int __ptsname_r(int, char *, size_t);
 hidden char *__randname(char *);
 hidden void __qsort_r (void *, size_t, size_t, int (*)(const void *, const void *, void *), void *);
 
-hidden void *__libc_malloc(size_t);
-hidden void *__libc_malloc_impl(size_t);
-hidden void *__libc_calloc(size_t, size_t);
-hidden void *__libc_realloc(void *, size_t);
-hidden void __libc_free(void *);
-
 #endif
diff --git a/lib/libc/musl/src/ldso/dlerror.c b/lib/libc/musl/src/ldso/dlerror.c
index dae0f3a9b24a93d01882fdafd4ed91cb29416375..141df3ab134988e03a570a70828e37400c2ec87c 100644
--- a/lib/libc/musl/src/ldso/dlerror.c
+++ b/lib/libc/musl/src/ldso/dlerror.c
@@ -5,11 +5,6 @@
 #include "dynlink.h"
 #include "atomic.h"
 
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc __libc_realloc
-#define free __libc_free
-
 char *dlerror()
 {
 	pthread_t self = __pthread_self();
diff --git a/lib/libc/musl/src/locale/dcngettext.c b/lib/libc/musl/src/locale/dcngettext.c
index 0b53286db753648d68ddef5b2905091bf39c4b9f..67e551058cb03aa77d34828ed7ca0ef47a043a57 100644
--- a/lib/libc/musl/src/locale/dcngettext.c
+++ b/lib/libc/musl/src/locale/dcngettext.c
@@ -12,11 +12,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc undef
-#define free undef
-
 struct binding {
 	struct binding *next;
 	int dirlen;
diff --git a/lib/libc/musl/src/locale/duplocale.c b/lib/libc/musl/src/locale/duplocale.c
index 5ce33ae6ded0acc40a93706bf39db10c3775f2b3..030b64cb0e706cdf29c7104526e86b6ee08d7adb 100644
--- a/lib/libc/musl/src/locale/duplocale.c
+++ b/lib/libc/musl/src/locale/duplocale.c
@@ -3,11 +3,6 @@
 #include "locale_impl.h"
 #include "libc.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 locale_t __duplocale(locale_t old)
 {
 	locale_t new = malloc(sizeof *new);
diff --git a/lib/libc/musl/src/locale/freelocale.c b/lib/libc/musl/src/locale/freelocale.c
index 385d12069d5733d8a291ceb6c870d842befed953..802b8bfe1c72458d8def7c505df0c022d026b1f0 100644
--- a/lib/libc/musl/src/locale/freelocale.c
+++ b/lib/libc/musl/src/locale/freelocale.c
@@ -1,11 +1,6 @@
 #include <stdlib.h>
 #include "locale_impl.h"
 
-#define malloc undef
-#define calloc undef
-#define realloc undef
-#define free __libc_free
-
 void freelocale(locale_t l)
 {
 	if (__loc_is_allocated(l)) free(l);
diff --git a/lib/libc/musl/src/locale/locale_map.c b/lib/libc/musl/src/locale/locale_map.c
index da61f7fc032c5d010cd6409589aeb2e0ca61c84f..a8c9e7f24427920941ae0fe2dc3d24bf0af0f443 100644
--- a/lib/libc/musl/src/locale/locale_map.c
+++ b/lib/libc/musl/src/locale/locale_map.c
@@ -7,11 +7,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 const char *__lctrans_impl(const char *msg, const struct __locale_map *lm)
 {
 	const char *trans = 0;
diff --git a/lib/libc/musl/src/locale/newlocale.c b/lib/libc/musl/src/locale/newlocale.c
index 9ac3cd386f99df95ba6e8f5a32a91b9c402db10d..12ae87d679e987293756808d5b05bb0846f86861 100644
--- a/lib/libc/musl/src/locale/newlocale.c
+++ b/lib/libc/musl/src/locale/newlocale.c
@@ -4,11 +4,6 @@
 #include "locale_impl.h"
 #include "lock.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 static int default_locale_init_done;
 static struct __locale_struct default_locale, default_ctype_locale;
 
diff --git a/lib/libc/musl/src/process/fdop.h b/lib/libc/musl/src/process/fdop.h
index 7cf733b21dc14ce2708fac19fa46dea87fcdfa9b..5adf1443874854c6a7a33c4b641ff18c152a0f38 100644
--- a/lib/libc/musl/src/process/fdop.h
+++ b/lib/libc/musl/src/process/fdop.h
@@ -10,8 +10,3 @@ struct fdop {
 	mode_t mode;
 	char path[];
 };
-
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc undef
-#define free __libc_free
diff --git a/lib/libc/musl/src/thread/pthread_atfork.c b/lib/libc/musl/src/thread/pthread_atfork.c
index 26d325438cec6ae63cc814766de557cc7a6a89c3..6d348ac8b73f8f3bc02dba246c303ee459cebe51 100644
--- a/lib/libc/musl/src/thread/pthread_atfork.c
+++ b/lib/libc/musl/src/thread/pthread_atfork.c
@@ -3,11 +3,6 @@
 #include "libc.h"
 #include "lock.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 static struct atfork_funcs {
 	void (*prepare)(void);
 	void (*parent)(void);
diff --git a/lib/libc/musl/src/thread/sem_open.c b/lib/libc/musl/src/thread/sem_open.c
index 0ad29de96cc1667f3a6d629f5da4104b56ede9d6..c3d2f6d3c0b2f97d64c3e72dd68c00062655c527 100644
--- a/lib/libc/musl/src/thread/sem_open.c
+++ b/lib/libc/musl/src/thread/sem_open.c
@@ -14,11 +14,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc undef
-#define free undef
-
 static struct {
 	ino_t ino;
 	sem_t *sem;
diff --git a/lib/libc/musl/src/time/__tz.c b/lib/libc/musl/src/time/__tz.c
index c34b3eb755a54b38efa8f8e4b39e0bfb1e23b406..ff51bd9802244cbac936e449f284455994151c24 100644
--- a/lib/libc/musl/src/time/__tz.c
+++ b/lib/libc/musl/src/time/__tz.c
@@ -9,11 +9,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 long  __timezone = 0;
 int   __daylight = 0;
 char *__tzname[2] = { 0, 0 };
-- 
2.54.0


From f5d5dbd1668b9fc7347b017563e2e951f3156c1e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 23:48:49 -0800
Subject: [PATCH 270/499] wasi libc: remove malloc defines

---
 lib/libc/wasi/libc-top-half/musl/src/exit/atexit.c       | 5 -----
 lib/libc/wasi/libc-top-half/musl/src/include/stdlib.h    | 6 ------
 lib/libc/wasi/libc-top-half/musl/src/locale/locale_map.c | 5 -----
 lib/libc/wasi/libc-top-half/musl/src/locale/newlocale.c  | 5 -----
 lib/libc/wasi/libc-top-half/musl/src/time/__tz.c         | 5 -----
 5 files changed, 26 deletions(-)

diff --git a/lib/libc/wasi/libc-top-half/musl/src/exit/atexit.c b/lib/libc/wasi/libc-top-half/musl/src/exit/atexit.c
index 155292d0ea5fed4390c0e6c86dce40032d6df470..30f897b7eae8478a67cebc7c0b804ffcc78ced73 100644
--- a/lib/libc/wasi/libc-top-half/musl/src/exit/atexit.c
+++ b/lib/libc/wasi/libc-top-half/musl/src/exit/atexit.c
@@ -4,11 +4,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc __libc_calloc
-#define realloc undef
-#define free undef
-
 /* Ensure that at least 32 atexit handlers can be registered without malloc */
 #define COUNT 32
 
diff --git a/lib/libc/wasi/libc-top-half/musl/src/include/stdlib.h b/lib/libc/wasi/libc-top-half/musl/src/include/stdlib.h
index 812b04de2fd6b6efb1576a72eea4fa16007fc2ad..1599691fbeec4d037674c309a03dccec1e12db36 100644
--- a/lib/libc/wasi/libc-top-half/musl/src/include/stdlib.h
+++ b/lib/libc/wasi/libc-top-half/musl/src/include/stdlib.h
@@ -10,10 +10,4 @@ hidden int __ptsname_r(int, char *, size_t);
 hidden char *__randname(char *);
 hidden void __qsort_r (void *, size_t, size_t, int (*)(const void *, const void *, void *), void *);
 
-hidden void *__libc_malloc(size_t);
-hidden void *__libc_malloc_impl(size_t);
-hidden void *__libc_calloc(size_t, size_t);
-hidden void *__libc_realloc(void *, size_t);
-hidden void __libc_free(void *);
-
 #endif
diff --git a/lib/libc/wasi/libc-top-half/musl/src/locale/locale_map.c b/lib/libc/wasi/libc-top-half/musl/src/locale/locale_map.c
index ebfb158f4a32fc6c25d04f609c04e4cab647a287..b7463fa54f177655215057db0ed348dd17f44464 100644
--- a/lib/libc/wasi/libc-top-half/musl/src/locale/locale_map.c
+++ b/lib/libc/wasi/libc-top-half/musl/src/locale/locale_map.c
@@ -9,11 +9,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 const char *__lctrans_impl(const char *msg, const struct __locale_map *lm)
 {
 	const char *trans = 0;
diff --git a/lib/libc/wasi/libc-top-half/musl/src/locale/newlocale.c b/lib/libc/wasi/libc-top-half/musl/src/locale/newlocale.c
index 11c778557a484f16142467ecf07f5d24cc049972..154682de971f6b65acd420b6639b692f1b7a33eb 100644
--- a/lib/libc/wasi/libc-top-half/musl/src/locale/newlocale.c
+++ b/lib/libc/wasi/libc-top-half/musl/src/locale/newlocale.c
@@ -6,11 +6,6 @@
 #include "locale_impl.h"
 #include "lock.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 static int default_locale_init_done;
 static struct __locale_struct default_locale, default_ctype_locale;
 
diff --git a/lib/libc/wasi/libc-top-half/musl/src/time/__tz.c b/lib/libc/wasi/libc-top-half/musl/src/time/__tz.c
index 7efb9a975716fff8f3b63dc0f4ca2f7965aadfd9..ee05eb58f8444241bdaad5b7ae47fb3a83c9fa3f 100644
--- a/lib/libc/wasi/libc-top-half/musl/src/time/__tz.c
+++ b/lib/libc/wasi/libc-top-half/musl/src/time/__tz.c
@@ -11,11 +11,6 @@
 #include "lock.h"
 #include "fork_impl.h"
 
-#define malloc __libc_malloc
-#define calloc undef
-#define realloc undef
-#define free undef
-
 #ifdef __wasilibc_unmodified_upstream // timezone data
 long  __timezone = 0;
 int   __daylight = 0;
-- 
2.54.0


From 21829a5b4ab0f21864e6e84fe585da365bab50c2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 23:48:04 -0800
Subject: [PATCH 271/499] zig libc: export all symbols weak

Normally, libc goes into a static archive, making all symbols
overrideable. However, Zig supports including the libc functions as part
of the Zig Compilation Unit, so to support this use case we make all
symbols weak.
---
 lib/c.zig | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/c.zig b/lib/c.zig
index 8b181dc1184b6504085de5adaf2ce04f639ec25c..b9f2a27eb7065ca5023f9d45c3e9e20fe30dbe99 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -15,17 +15,17 @@ pub const panic = if (builtin.is_test)
 else
     std.debug.no_panic;
 
-/// It is incorrect to make this conditional on `builtin.is_test`, because it is possible that
-/// libzigc is being linked into a different test compilation, as opposed to being tested itself.
-pub const linkage: std.builtin.GlobalLinkage = .strong;
-
 /// Determines the symbol's visibility to other objects.
 /// For WebAssembly this allows the symbol to be resolved to other modules, but will not
 /// export it to the host runtime.
 pub const visibility: std.builtin.SymbolVisibility = .hidden;
 
 pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void {
-    @export(func, .{ .name = name, .linkage = linkage, .visibility = visibility });
+    // Normally, libc goes into a static archive, making all symbols
+    // overridable. However, Zig supports including the libc functions as part
+    // of the Zig Compilation Unit, so to support this use case we make all
+    // symbols weak.
+    @export(func, .{ .name = name, .linkage = .weak, .visibility = visibility });
 }
 
 /// Given a low-level syscall return value, sets errno and returns `-1`, or on
-- 
2.54.0


From 0de7668c013c5d3e095f0e436dba1b22a6a01f14 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 23:49:09 -0800
Subject: [PATCH 272/499] test harness: refmt for readability

---
 test/src/Libc.zig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/src/Libc.zig b/test/src/Libc.zig
index 423d7856d1e581d13155830df176dead3f95bcf9..c6cea0d57133e3f55c24d115fdc76585e066a102 100644
--- a/test/src/Libc.zig
+++ b/test/src/Libc.zig
@@ -60,7 +60,9 @@ pub fn addTarget(libc: *const Libc, target: std.Build.ResolvedTarget) void {
             .link_libc = true,
         });
 
-        var libtest_c_source_files: []const []const u8 = &.{ "print.c", "rand.c", "mtest.c", "setrlim.c", "memfill.c", "vmfill.c", "fdfill.c", "utf8.c" };
+        var libtest_c_source_files: []const []const u8 = &.{
+            "print.c", "rand.c", "mtest.c", "setrlim.c", "memfill.c", "vmfill.c", "fdfill.c", "utf8.c",
+        };
         libtest_mod.addCSourceFiles(.{
             .root = common,
             .files = libtest_c_source_files[0..if (target.result.isMuslLibC()) 8 else 3],
-- 
2.54.0


From ec02571a30e2975039cef5cb92467082ea5de5c0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 11 Feb 2026 23:49:21 -0800
Subject: [PATCH 273/499] zig libc malloc: set errno when returning null

---
 lib/c/malloc.zig | 32 +++++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/lib/c/malloc.zig b/lib/c/malloc.zig
index 4b8ba77b5ecef1d569c54f362285f0a647b2b596..5ddae3776754882ad722b63543ae1285a55ee268 100644
--- a/lib/c/malloc.zig
+++ b/lib/c/malloc.zig
@@ -64,9 +64,9 @@ const Header = packed struct(u64) {
 };
 
 fn malloc(n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
-    const size = std.math.cast(Header.Size, n) orelse return null;
+    const size = std.math.cast(Header.Size, n) orelse return nomem();
     const ptr: [*]align(alignment_bytes) u8 = @alignCast(
-        vtable.alloc(no_context, n + alignment_bytes, alignment, no_ra) orelse return null,
+        vtable.alloc(no_context, n + alignment_bytes, alignment, no_ra) orelse return nomem(),
     );
     const base = ptr + alignment_bytes;
     const header: *Header = .fromBase(base);
@@ -78,6 +78,11 @@ fn malloc(n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
 }
 
 fn aligned_alloc(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
+    return aligned_alloc_inner(alloc_alignment, n) orelse return nomem();
+}
+
+/// Avoids setting errno so it can be called by `posix_memalign`.
+fn aligned_alloc_inner(alloc_alignment: usize, n: usize) ?[*]align(alignment_bytes) u8 {
     const size = std.math.cast(Header.Size, n) orelse return null;
     const max_align = alignment.max(.fromByteUnits(alloc_alignment));
     const max_align_bytes = max_align.toByteUnits();
@@ -94,7 +99,7 @@ fn aligned_alloc(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignm
 }
 
 fn calloc(elems: usize, len: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
-    const n = std.math.mul(usize, elems, len) catch return null;
+    const n = std.math.mul(usize, elems, len) catch return nomem();
     const base = malloc(n) orelse return null;
     @memset(base[0..n], 0);
     return base;
@@ -106,7 +111,7 @@ fn realloc(opt_old_base: ?[*]align(alignment_bytes) u8, n: usize) callconv(.c) ?
         return null;
     }
     const old_base = opt_old_base orelse return malloc(n);
-    const new_size = std.math.cast(Header.Size, n) orelse return null;
+    const new_size = std.math.cast(Header.Size, n) orelse return nomem();
     const old_header: *Header = .fromBase(old_base);
     assert(old_header.padding == 0);
     const old_size = old_header.size;
@@ -122,7 +127,8 @@ fn realloc(opt_old_base: ?[*]align(alignment_bytes) u8, n: usize) callconv(.c) ?
         no_ra,
     )) |new_ptr| @alignCast(new_ptr + old_alignment_bytes) else b: {
         const new_ptr: [*]align(alignment_bytes) u8 = @alignCast(
-            vtable.alloc(no_context, n + old_alignment_bytes, old_alignment, no_ra) orelse return null,
+            vtable.alloc(no_context, n + old_alignment_bytes, old_alignment, no_ra) orelse
+                return nomem(),
         );
         const new_base: [*]align(alignment_bytes) u8 = @alignCast(new_ptr + old_alignment_bytes);
         const copy_len = @min(new_size, old_size);
@@ -139,7 +145,7 @@ fn realloc(opt_old_base: ?[*]align(alignment_bytes) u8, n: usize) callconv(.c) ?
 }
 
 fn reallocarray(opt_base: ?[*]align(alignment_bytes) u8, elems: usize, len: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
-    const n = std.math.mul(usize, elems, len) catch return null;
+    const n = std.math.mul(usize, elems, len) catch return nomem();
     return realloc(opt_base, n);
 }
 
@@ -173,10 +179,14 @@ fn memalign(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignment_b
 
 fn posix_memalign(result: *?[*]align(alignment_bytes) u8, alloc_alignment: usize, n: usize) callconv(.c) c_int {
     if (alloc_alignment < @sizeOf(*anyopaque)) return @intFromEnum(std.c.E.INVAL);
-    if (n == 0) {
-        result.* = null;
-    } else {
-        result.* = aligned_alloc(alloc_alignment, n) orelse return @intFromEnum(std.c.E.NOMEM);
-    }
+    result.* = aligned_alloc_inner(alloc_alignment, n) orelse return @intFromEnum(std.c.E.NOMEM);
     return 0;
 }
+
+/// Libc memory allocation functions must set errno in addition to returning
+/// `null`.
+fn nomem() ?[*]align(alignment_bytes) u8 {
+    @branchHint(.cold);
+    std.c._errno().* = @intFromEnum(std.c.E.NOMEM);
+    return null;
+}
-- 
2.54.0


From 6d52678a6cfee1bc05d995bef8d963a5921ed8ea Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 12 Feb 2026 13:13:48 -0800
Subject: [PATCH 274/499] zig libc malloc: skip export when unit testing

These functions can only be exported when external libc components are
available due to the errno location dependency. Note that even when zig
libc is complete, on Windows, errno location will always be external (in
ucrtbase.dll).
---
 build.zig        |  2 +-
 lib/c.zig        | 35 +++++++++++++++++++++++++----------
 lib/c/malloc.zig | 23 +++++++++++++----------
 3 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/build.zig b/build.zig
index 5eba8f82db9fe1567cf81dae1495499b8e627bf3..ed3c764a24e566b12321711da6178db3616b958e 100644
--- a/build.zig
+++ b/build.zig
@@ -518,7 +518,7 @@ pub fn build(b: *std.Build) !void {
         .test_extra_targets = test_extra_targets,
         .root_src = "lib/c.zig",
         .name = "zigc",
-        .desc = "Run the zigc tests",
+        .desc = "Run the zig libc implementation unit tests",
         .optimize_modes = optimization_modes,
         .include_paths = &.{},
         .skip_single_threaded = true,
diff --git a/lib/c.zig b/lib/c.zig
index b9f2a27eb7065ca5023f9d45c3e9e20fe30dbe99..2e21581588be05490b621a9525de0019e7c3fa42 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -15,17 +15,32 @@ pub const panic = if (builtin.is_test)
 else
     std.debug.no_panic;
 
-/// Determines the symbol's visibility to other objects.
-/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
-/// export it to the host runtime.
-pub const visibility: std.builtin.SymbolVisibility = .hidden;
-
+/// It is possible that this libc is being linked into a different test
+/// compilation, as opposed to being tested itself. In such case,
+/// `builtin.link_libc` will be `true` along with `builtin.is_test`.
+///
+/// When we don't have a complete libc, `builtin.link_libc` will be `false` and
+/// we will be missing externally provided symbols, such as `_errno` from
+/// ucrtbase.dll. In such case, we must avoid analyzing otherwise exported
+/// functions because it would cause undefined symbol usage.
+///
+/// Unfortunately such logic cannot be automatically done in this function body
+/// since `func` will always be analyzed by the time we get here, so `comptime`
+/// blocks will need to each check for `builtin.link_libc` and skip exports
+/// when the exported functions have libc dependencies not provided by this
+/// compilation unit.
 pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void {
-    // Normally, libc goes into a static archive, making all symbols
-    // overridable. However, Zig supports including the libc functions as part
-    // of the Zig Compilation Unit, so to support this use case we make all
-    // symbols weak.
-    @export(func, .{ .name = name, .linkage = .weak, .visibility = visibility });
+    @export(func, .{
+        .name = name,
+        // Normally, libc goes into a static archive, making all symbols
+        // overridable. However, Zig supports including the libc functions as part
+        // of the Zig Compilation Unit, so to support this use case we make all
+        // symbols weak.
+        .linkage = .weak,
+        // For WebAssembly, hidden visibility allows the symbol to be resolved to
+        // other modules, but will not export it to the host runtime.
+        .visibility = .hidden,
+    });
 }
 
 /// Given a low-level syscall return value, sets errno and returns `-1`, or on
diff --git a/lib/c/malloc.zig b/lib/c/malloc.zig
index 5ddae3776754882ad722b63543ae1285a55ee268..4ef795c278716763b40507431c5513979f0bf2d3 100644
--- a/lib/c/malloc.zig
+++ b/lib/c/malloc.zig
@@ -23,17 +23,20 @@ const alignment: Alignment = .fromByteUnits(alignment_bytes);
 const symbol = @import("../c.zig").symbol;
 
 comptime {
-    symbol(&malloc, "malloc");
-    symbol(&aligned_alloc, "aligned_alloc");
-    symbol(&posix_memalign, "posix_memalign");
-    symbol(&calloc, "calloc");
-    symbol(&realloc, "realloc");
-    symbol(&reallocarray, "reallocarray");
-    symbol(&free, "free");
-    symbol(&malloc_usable_size, "malloc_usable_size");
+    // Dependency on external errno location.
+    if (builtin.link_libc) {
+        symbol(&malloc, "malloc");
+        symbol(&aligned_alloc, "aligned_alloc");
+        symbol(&posix_memalign, "posix_memalign");
+        symbol(&calloc, "calloc");
+        symbol(&realloc, "realloc");
+        symbol(&reallocarray, "reallocarray");
+        symbol(&free, "free");
+        symbol(&malloc_usable_size, "malloc_usable_size");
 
-    symbol(&valloc, "valloc");
-    symbol(&memalign, "memalign");
+        symbol(&valloc, "valloc");
+        symbol(&memalign, "memalign");
+    }
 }
 
 const no_context: *anyopaque = undefined;
-- 
2.54.0


From 6296924214fe8f0c08c7fcf30ecce5974133d1b4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 12 Feb 2026 15:00:22 -0800
Subject: [PATCH 275/499] build: bump behavior max_rss

---
 build.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.zig b/build.zig
index ed3c764a24e566b12321711da6178db3616b958e..b2227b0cb81fb8e74f83b2c3107751c7756e3640 100644
--- a/build.zig
+++ b/build.zig
@@ -483,7 +483,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = 3_300_000_000,
+        .max_rss = 3_500_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
-- 
2.54.0


From 0957761d5c26ef23c04333120974323109a38f93 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 12 Feb 2026 14:58:49 -0800
Subject: [PATCH 276/499] std.heap.BrkAllocator: fix incorrect assumptions

---
 lib/std/heap/BrkAllocator.zig | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/lib/std/heap/BrkAllocator.zig b/lib/std/heap/BrkAllocator.zig
index 91b7230c9d30423d53afb3b6946d9c940990716e..1f0c88635f945be4ec5708901e4b7b3ccb21bfb3 100644
--- a/lib/std/heap/BrkAllocator.zig
+++ b/lib/std/heap/BrkAllocator.zig
@@ -10,7 +10,6 @@ const Allocator = std.mem.Allocator;
 const Alignment = std.mem.Alignment;
 const assert = std.debug.assert;
 const math = std.math;
-const page_size_max = std.heap.page_size_max;
 
 comptime {
     if (!builtin.single_threaded) @compileError("unsupported");
@@ -36,14 +35,9 @@ pub const Error = Allocator.Error;
 
 const max_usize = math.maxInt(usize);
 const ushift = math.Log2Int(usize);
-const bigpage_size = 64 * 1024;
-const pages_per_bigpage = bigpage_size / page_size_max;
+const bigpage_size: comptime_int = @max(64 * 1024, std.heap.page_size_max);
 const bigpage_count = max_usize / bigpage_size;
 
-comptime {
-    assert(bigpage_size >= page_size_max);
-}
-
 /// Because of storing free list pointers, the minimum size class is 3.
 const min_class = math.log2(math.ceilPowerOfTwoAssert(usize, 1 + @sizeOf(usize)));
 const size_class_count = math.log2(bigpage_size) - min_class;
@@ -70,7 +64,7 @@ fn alloc(ctx: *anyopaque, len: usize, alignment: Alignment, return_address: usiz
             }
 
             const next_addr = global.next_addrs[class];
-            if (next_addr % page_size_max == 0) {
+            if (next_addr % bigpage_size == 0) {
                 const addr = allocBigPages(1);
                 if (addr == 0) return null;
                 //std.debug.print("allocated fresh slot_size={d} class={d} addr=0x{x}\n", .{
@@ -172,15 +166,19 @@ fn allocBigPages(n: usize) usize {
     }
 
     if (builtin.cpu.arch.isWasm()) {
+        comptime assert(std.heap.page_size_max == std.heap.page_size_min);
+        const page_size = std.heap.page_size_max;
+        const pages_per_bigpage = bigpage_size / page_size;
         const page_index = @wasmMemoryGrow(0, pow2_pages * pages_per_bigpage);
         if (page_index == -1) return 0;
-        return @as(usize, @intCast(page_index)) * page_size_max;
+        return @as(usize, @intCast(page_index)) * page_size;
     } else if (builtin.os.tag == .linux) {
-        const start_brk = s: {
-            const start_brk = global.prev_brk;
-            break :s if (start_brk == 0) std.os.linux.brk(0) else start_brk;
-        };
-        const end_brk = start_brk + pow2_pages * pages_per_bigpage * page_size_max;
+        const prev_brk = global.prev_brk;
+        const start_brk = if (prev_brk == 0)
+            std.mem.alignForward(usize, std.os.linux.brk(0), bigpage_size)
+        else
+            prev_brk;
+        const end_brk = start_brk + pow2_pages * bigpage_size;
         const new_prev_brk = std.os.linux.brk(end_brk);
         global.prev_brk = new_prev_brk;
         if (new_prev_brk != end_brk) return 0;
-- 
2.54.0


From 37109fa4ef5beea9c4ec1ea78e4fcc02df34be3c Mon Sep 17 00:00:00 2001
From: Karel Marek <karel.marek@kernun.cz>
Date: Thu, 12 Feb 2026 10:16:42 +0100
Subject: [PATCH 277/499] Fix IpAddress.setPort

---
 lib/std/Io/net.zig | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io/net.zig b/lib/std/Io/net.zig
index 72daee6f94625f9ce88fb2e71b7802a0b3bfbbd4..51a8d6647bd80bd28d37ffc43e725e38cfdc89d4 100644
--- a/lib/std/Io/net.zig
+++ b/lib/std/Io/net.zig
@@ -153,8 +153,9 @@ pub const IpAddress = union(enum) {
 
     /// `port` is native-endian.
     pub fn setPort(a: *IpAddress, port: u16) void {
-        switch (a) {
-            inline .ip4, .ip6 => |*x| x.port = port,
+        switch (a.*) {
+            .ip4 => a.ip4.port = port,
+            .ip6 => a.ip6.port = port,
         }
     }
 
@@ -1430,6 +1431,11 @@ test "parsing IPv6 addresses" {
     try testIp6Parse("ff02::");
     try testIp6Parse("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
 }
+test "IpAddress.setPort works" {
+    var addr: IpAddress = .{ .ip4 = undefined };
+    addr.setPort(0);
+    try std.testing.expectEqual(0, addr.getPort());
+}
 
 fn testIp6Parse(input: []const u8) !void {
     return testIp6ParseTransform(input, input);
-- 
2.54.0


From 5132d78e8385cbadc888275761258a1fca27b6f0 Mon Sep 17 00:00:00 2001
From: Neel <ntamtam614@gmail.com>
Date: Wed, 11 Feb 2026 21:49:48 -0600
Subject: [PATCH 278/499] libc: implement insque and remque in Zig

Implements insque() and remque() doubly-linked list functions
in lib/c/search.zig and removes musl C implementation.
Contributes to #30978
---
 lib/c.zig                         |  1 +
 lib/c/search.zig                  | 67 +++++++++++++++++++++++++++++++
 lib/libc/musl/src/search/insque.c | 32 ---------------
 src/libs/musl.zig                 |  1 -
 src/libs/wasi_libc.zig            |  1 -
 5 files changed, 68 insertions(+), 34 deletions(-)
 create mode 100644 lib/c/search.zig
 delete mode 100644 lib/libc/musl/src/search/insque.c

diff --git a/lib/c.zig b/lib/c.zig
index 2e21581588be05490b621a9525de0019e7c3fa42..63597e3022b14efdf2c01d62a05a0563d0e8572a 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -68,6 +68,7 @@ comptime {
         _ = @import("c/malloc.zig");
     }
     _ = @import("c/math.zig");
+    _ = @import("c/search.zig");
     _ = @import("c/stdlib.zig");
     _ = @import("c/string.zig");
     _ = @import("c/strings.zig");
diff --git a/lib/c/search.zig b/lib/c/search.zig
new file mode 100644
index 0000000000000000000000000000000000000000..271aec873e9d2554f303dd2ba896c80b6f108cb9
--- /dev/null
+++ b/lib/c/search.zig
@@ -0,0 +1,67 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const symbol = @import("../c.zig").symbol;
+
+comptime {
+    if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        symbol(&insque, "insque");
+        symbol(&remque, "remque");
+    }
+}
+
+const Node = extern struct {
+    next: ?*Node,
+    prev: ?*Node,
+};
+
+fn insque(element: *anyopaque, pred: ?*anyopaque) callconv(.c) void {
+    const e: *Node = @ptrCast(@alignCast(element));
+
+    if (pred) |p_ptr| {
+        const p: *Node = @ptrCast(@alignCast(p_ptr));
+        e.next = p.next;
+        e.prev = p;
+        p.next = e;
+
+        if (e.next) |next| {
+            next.prev = e;
+        }
+    } else {
+        e.next = null;
+        e.prev = null;
+    }
+}
+
+fn remque(element: *anyopaque) callconv(.c) void {
+    const e: *Node = @ptrCast(@alignCast(element));
+
+    if (e.next) |next| next.prev = e.prev;
+    if (e.prev) |prev| prev.next = e.next;
+}
+
+test "insque and remque" {
+    var first = Node{ .next = null, .prev = null };
+    var second = Node{ .next = null, .prev = null };
+    var third = Node{ .next = null, .prev = null };
+
+    insque(&first, null);
+    try std.testing.expectEqual(@as(?*Node, null), first.next);
+    try std.testing.expectEqual(@as(?*Node, null), first.prev);
+
+    insque(&second, &first);
+    try std.testing.expectEqual(@as(?*Node, &second), first.next);
+    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
+
+    insque(&third, &first);
+    try std.testing.expectEqual(@as(?*Node, &third), first.next);
+    try std.testing.expectEqual(@as(?*Node, &second), third.next);
+    try std.testing.expectEqual(@as(?*Node, &first), third.prev);
+    try std.testing.expectEqual(@as(?*Node, &third), second.prev);
+
+    remque(&third);
+    try std.testing.expectEqual(@as(?*Node, &second), first.next);
+    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
+
+    remque(&second);
+    try std.testing.expectEqual(@as(?*Node, null), first.next);
+}
diff --git a/lib/libc/musl/src/search/insque.c b/lib/libc/musl/src/search/insque.c
deleted file mode 100644
index b7475d84f31eb442550e5a4197d473ff36bda755..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/search/insque.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <search.h>
-
-struct node {
-	struct node *next;
-	struct node *prev;
-};
-
-void insque(void *element, void *pred)
-{
-	struct node *e = element;
-	struct node *p = pred;
-
-	if (!p) {
-		e->next = e->prev = 0;
-		return;
-	}
-	e->next = p->next;
-	e->prev = p;
-	p->next = e;
-	if (e->next)
-		e->next->prev = e;
-}
-
-void remque(void *element)
-{
-	struct node *e = element;
-
-	if (e->next)
-		e->next->prev = e->prev;
-	if (e->prev)
-		e->prev->next = e->next;
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 54fa1aed853c53dd213666ad5184eee881814868..b201c1b7ff32e0ad63d15729618959f3fa543140 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -1296,7 +1296,6 @@ const src_files = [_][]const u8{
     "musl/src/sched/sched_setscheduler.c",
     "musl/src/sched/sched_yield.c",
     "musl/src/search/hsearch.c",
-    "musl/src/search/insque.c",
     "musl/src/search/lsearch.c",
     "musl/src/search/tdelete.c",
     "musl/src/search/tdestroy.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 2809f5c9f31ecb17c031bf1c55ef4406c988d7fc..869c4d52dae7ccdd3388889714a91f83c5b0c159 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -848,7 +848,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/regex/fnmatch.c",
     "musl/src/regex/regerror.c",
     "musl/src/search/hsearch.c",
-    "musl/src/search/insque.c",
     "musl/src/search/lsearch.c",
     "musl/src/search/tdelete.c",
     "musl/src/search/tdestroy.c",
-- 
2.54.0


From f36d0573cd0f80b271b9f07a7215fa237d14ae9a Mon Sep 17 00:00:00 2001
From: kineye <27766253+JanikkinaJ@users.noreply.github.com.>
Date: Sat, 7 Feb 2026 16:09:29 +0100
Subject: [PATCH 279/499] zig libc: add rint

---
 lib/c/math.zig                      | 57 +++++++++++++++++++++++++++++
 lib/libc/musl/src/math/rint.c       | 28 --------------
 lib/libc/musl/src/math/s390x/rint.c | 15 --------
 src/libs/musl.zig                   |  4 --
 4 files changed, 57 insertions(+), 47 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/rint.c
 delete mode 100644 lib/libc/musl/src/math/s390x/rint.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 85b871c695ef5c4233ba9c6375d41f6347605687..2c02597bb2271bd9a83cf6f4cf35b8cd8afdf9fc 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -56,6 +56,7 @@ comptime {
     if (builtin.target.isMuslLibC()) {
         symbol(&copysignf, "copysignf");
         symbol(&copysign, "copysign");
+        symbol(&rint, "rint");
     }
     symbol(&copysignl, "copysignl");
 }
@@ -158,3 +159,59 @@ fn pow10(x: f64) callconv(.c) f64 {
 fn pow10f(x: f32) callconv(.c) f32 {
     return exp10f(x);
 }
+
+fn rint(x: f64) callconv(.c) f64 {
+    const toint: f64 = 1.0 / @as(f64, std.math.floatEps(f64));
+    const a: u64 = @bitCast(x);
+    const e = a >> 52 & 0x7ff;
+    const s = a >> 63;
+    var y: f64 = undefined;
+
+    if (e >= 0x3ff + 52) {
+        return x;
+    }
+    if (s == 1) {
+        y = x - toint + toint;
+    } else {
+        y = x + toint - toint;
+    }
+    if (y == 0) {
+        return if (s == 1) -0.0 else 0;
+    }
+    return y;
+}
+
+test "rint" {
+    // Positive numbers round correctly
+    try std.testing.expectEqual(@as(f64, 42.0), rint(42.2));
+    try std.testing.expectEqual(@as(f64, 42.0), rint(41.8));
+
+    // Negative numbers round correctly
+    try std.testing.expectEqual(@as(f64, -6.0), rint(-5.9));
+    try std.testing.expectEqual(@as(f64, -6.0), rint(-6.1));
+
+    // No rounding needed test
+    try std.testing.expectEqual(@as(f64, 5.0), rint(5.0));
+    try std.testing.expectEqual(@as(f64, -10.0), rint(-10.0));
+    try std.testing.expectEqual(@as(f64, 0.0), rint(0.0));
+
+    // Very large numbers return unchanged
+    const large: f64 = 9007199254740992.0; // 2^53
+    try std.testing.expectEqual(large, rint(large));
+    try std.testing.expectEqual(-large, rint(-large));
+
+    // Small positive numbers round to zero
+    const pos_result = rint(0.3);
+    try std.testing.expectEqual(@as(f64, 0.0), pos_result);
+    try std.testing.expect(@as(u64, @bitCast(pos_result)) == 0);
+
+    // Small negative numbers round to negative zero
+    const neg_result = rint(-0.3);
+    try std.testing.expectEqual(@as(f64, 0.0), neg_result);
+    const bits: u64 = @bitCast(neg_result);
+    try std.testing.expect((bits >> 63) == 1);
+
+    // Exact half rounds to nearest even (banker's rounding)
+    try std.testing.expectEqual(@as(f64, 2.0), rint(2.5));
+    try std.testing.expectEqual(@as(f64, 4.0), rint(3.5));
+}
diff --git a/lib/libc/musl/src/math/rint.c b/lib/libc/musl/src/math/rint.c
deleted file mode 100644
index fbba390e7d723774d41ba2a9da74957c20643d63..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/rint.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <float.h>
-#include <math.h>
-#include <stdint.h>
-
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
-#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
-#define EPS LDBL_EPSILON
-#endif
-static const double_t toint = 1/EPS;
-
-double rint(double x)
-{
-	union {double f; uint64_t i;} u = {x};
-	int e = u.i>>52 & 0x7ff;
-	int s = u.i>>63;
-	double_t y;
-
-	if (e >= 0x3ff+52)
-		return x;
-	if (s)
-		y = x - toint + toint;
-	else
-		y = x + toint - toint;
-	if (y == 0)
-		return s ? -0.0 : 0;
-	return y;
-}
diff --git a/lib/libc/musl/src/math/s390x/rint.c b/lib/libc/musl/src/math/s390x/rint.c
deleted file mode 100644
index b02f09eb0645ab577fe14471d76bc27f205823ba..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/s390x/rint.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <math.h>
-
-#if defined(__HTM__) || __ARCH__ >= 9
-
-double rint(double x)
-{
-	__asm__ ("fidbr %0, 0, %1" : "=f"(x) : "f"(x));
-	return x;
-}
-
-#else
-
-#include "../rint.c"
-
-#endif
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index b201c1b7ff32e0ad63d15729618959f3fa543140..3f2739ec714d9d879bf73b340f55ac2b4d62e055 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -797,7 +797,6 @@ const src_files = [_][]const u8{
     "musl/src/math/aarch64/lroundf.c",
     "musl/src/math/aarch64/nearbyint.c",
     "musl/src/math/aarch64/nearbyintf.c",
-    "musl/src/math/aarch64/rint.c",
     "musl/src/math/aarch64/rintf.c",
     "musl/src/math/acosf.c",
     "musl/src/math/acosh.c",
@@ -887,7 +886,6 @@ const src_files = [_][]const u8{
     "musl/src/math/i386/remquof.s",
     "musl/src/math/i386/remquol.s",
     "musl/src/math/i386/remquo.s",
-    "musl/src/math/i386/rint.c",
     "musl/src/math/i386/rintf.c",
     "musl/src/math/i386/rintl.c",
     "musl/src/math/i386/scalblnf.s",
@@ -981,7 +979,6 @@ const src_files = [_][]const u8{
     "musl/src/math/remquo.c",
     "musl/src/math/remquof.c",
     "musl/src/math/remquol.c",
-    "musl/src/math/rint.c",
     "musl/src/math/rintf.c",
     "musl/src/math/rintl.c",
     "musl/src/math/riscv32/fma.c",
@@ -993,7 +990,6 @@ const src_files = [_][]const u8{
     "musl/src/math/s390x/nearbyint.c",
     "musl/src/math/s390x/nearbyintf.c",
     "musl/src/math/s390x/nearbyintl.c",
-    "musl/src/math/s390x/rint.c",
     "musl/src/math/s390x/rintf.c",
     "musl/src/math/s390x/rintl.c",
     "musl/src/math/scalb.c",
-- 
2.54.0


From 35c5611f0707a46f6314a7b4e4597ff56bfead18 Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Wed, 11 Feb 2026 00:41:04 +0100
Subject: [PATCH 280/499] std.Deque: add `*Ptr` variants of getter functions

This makes it practical to store large items or items that are meant to
be mutable directly inside of the deque.
It is the responsibility of the user to stop using the returned pointers
after calling a function that could invalidate them.
---
 lib/std/deque.zig | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/lib/std/deque.zig b/lib/std/deque.zig
index 267b8a0afe4a7c40cb0250c0afbeb0b55bb61bc1..6874ebe394117a38d838818eff0b8f520aae36d0 100644
--- a/lib/std/deque.zig
+++ b/lib/std/deque.zig
@@ -180,12 +180,24 @@ pub fn Deque(comptime T: type) type {
             return deque.buffer[deque.head];
         }
 
+        /// Return pointer to the first item in the deque or null if empty.
+        pub fn frontPtr(deque: *const Self) ?*T {
+            if (deque.len == 0) return null;
+            return &deque.buffer[deque.head];
+        }
+
         /// Return the last item in the deque or null if empty.
         pub fn back(deque: *const Self) ?T {
             if (deque.len == 0) return null;
             return deque.buffer[deque.bufferIndex(deque.len - 1)];
         }
 
+        /// Return the last item in the deque or null if empty.
+        pub fn backPtr(deque: *const Self) ?*T {
+            if (deque.len == 0) return null;
+            return &deque.buffer[deque.bufferIndex(deque.len - 1)];
+        }
+
         /// Return the item at the given index in the deque.
         ///
         /// The first item in the queue is at index 0.
@@ -196,6 +208,16 @@ pub fn Deque(comptime T: type) type {
             return deque.buffer[deque.bufferIndex(index)];
         }
 
+        /// Return pointer to the item at the given index in the deque.
+        ///
+        /// The first item in the queue is at index 0.
+        ///
+        /// Asserts that the index is in-bounds.
+        pub fn atPtr(deque: *const Self, index: usize) *T {
+            assert(index < deque.len);
+            return &deque.buffer[deque.bufferIndex(index)];
+        }
+
         /// Remove and return the first item in the deque or null if empty.
         pub fn popFront(deque: *Self) ?T {
             if (deque.len == 0) return null;
-- 
2.54.0


From 527e97b25201a1a252bcff6d79198513babda2db Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Wed, 11 Feb 2026 00:57:19 +0100
Subject: [PATCH 281/499] std.Deque: add `*Slice` variants of push functions

This mirrors the `*Slice` variants e.g. `std.ArrayList` already provides.
---
 lib/std/deque.zig | 143 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 143 insertions(+)

diff --git a/lib/std/deque.zig b/lib/std/deque.zig
index 6874ebe394117a38d838818eff0b8f520aae36d0..236d476135416e73057793f0327b2beb633c61f7 100644
--- a/lib/std/deque.zig
+++ b/lib/std/deque.zig
@@ -174,6 +174,91 @@ pub fn Deque(comptime T: type) type {
             deque.len += 1;
         }
 
+        /// Add `items` to the front of the deque.
+        /// This is equivalent to iterating `items` in reverse and calling
+        /// `pushFront` on every single entry.
+        ///
+        /// Invalidates element pointers if additional memory is needed.
+        pub fn pushFrontSlice(deque: *Self, gpa: Allocator, items: []const T) error{OutOfMemory}!void {
+            try deque.ensureUnusedCapacity(gpa, items.len);
+            return deque.pushFrontSliceAssumeCapacity(items);
+        }
+
+        /// Add `items` to the front of the deque.
+        /// This is equivalent to iterating `items` in reverse and calling
+        /// `pushFront` on every single entry.
+        ///
+        /// Never invalidates element pointers.
+        ///
+        /// If the deque lacks unused capacity for the additional items, returns
+        /// `error.OutOfMemory`.
+        pub fn pushFrontSliceBounded(deque: *Self, items: []const T) error{OutOfMemory}!void {
+            if (deque.buffer.len - deque.len < items.len) return error.OutOfMemory;
+            return deque.pushFrontSliceAssumeCapacity(items);
+        }
+
+        /// Add `items` to the front of the deque.
+        /// This is equivalent to iterating `items` in reverse and calling
+        /// `pushFront` on every single entry.
+        ///
+        /// Never invalidates element pointers.
+        ///
+        /// Asserts that the deque can hold the additional items.
+        pub fn pushFrontSliceAssumeCapacity(deque: *Self, items: []const T) void {
+            assert(deque.buffer.len - deque.len >= items.len);
+            if (deque.head < items.len) {
+                @memcpy(deque.buffer[0..deque.head], items[items.len - deque.head ..]);
+                deque.head = deque.buffer.len - items.len + deque.head;
+                @memcpy(deque.buffer[deque.head..], items.ptr);
+            } else {
+                deque.head -= items.len;
+                @memcpy(deque.buffer[deque.head..][0..items.len], items);
+            }
+            deque.len += items.len;
+        }
+
+        /// Add `items` to the back of the deque.
+        /// This is equivalent to iterating `items` in order and calling
+        /// `pushBack` on every single entry.
+        ///
+        /// Invalidates element pointers if additional memory is needed.
+        pub fn pushBackSlice(deque: *Self, gpa: Allocator, items: []const T) error{OutOfMemory}!void {
+            try deque.ensureUnusedCapacity(gpa, items.len);
+            return deque.pushBackSliceAssumeCapacity(items);
+        }
+
+        /// Add `items` to the back of the deque.
+        /// This is equivalent to iterating `items` in order and calling
+        /// `pushBack` on every single entry.
+        ///
+        /// Never invalidates element pointers.
+        ///
+        /// If the deque lacks unused capacity for the additional items, returns
+        /// `error.OutOfMemory`.
+        pub fn pushBackSliceBounded(deque: *Self, items: []const T) error{OutOfMemory}!void {
+            if (deque.buffer.len - deque.len < items.len) return error.OutOfMemory;
+            return deque.pushBackSliceAssumeCapacity(items);
+        }
+
+        /// Add `items` to the back of the deque.
+        /// This is equivalent to iterating `items` in order and calling
+        /// `pushBack` on every single entry.
+        ///
+        /// Never invalidates element pointers.
+        ///
+        /// Asserts that the deque can hold the additional items.
+        pub fn pushBackSliceAssumeCapacity(deque: *Self, items: []const T) void {
+            assert(deque.buffer.len - deque.len >= items.len);
+            const trailing_buffer = deque.buffer[deque.bufferIndex(deque.len)..];
+            if (trailing_buffer.len < items.len) {
+                @memcpy(trailing_buffer, items[0..trailing_buffer.len]);
+                @memcpy(deque.buffer.ptr, items[trailing_buffer.len..]);
+            } else {
+                @memcpy(trailing_buffer[0..items.len], items);
+            }
+            deque.len += items.len;
+        }
+
         /// Return the first item in the deque or null if empty.
         pub fn front(deque: *const Self) ?T {
             if (deque.len == 0) return null;
@@ -350,6 +435,40 @@ test "slow growth" {
     try testing.expectEqual(null, q.popBack());
 }
 
+test "slice" {
+    const testing = std.testing;
+    const gpa = testing.allocator;
+
+    var q: Deque(i32) = .empty;
+    defer q.deinit(gpa);
+
+    try q.pushBackSlice(gpa, &.{ 3, 4, 5 });
+    try q.pushBackSlice(gpa, &.{ 6, 7 });
+    try q.pushFrontSlice(gpa, &.{2});
+    try q.pushBackSlice(gpa, &.{});
+    try q.pushFrontSlice(gpa, &.{ 0, 1 });
+    try q.pushFrontSlice(gpa, &.{});
+
+    try testing.expectEqual(0, q.popFront());
+    try testing.expectEqual(1, q.popFront());
+    try testing.expectEqual(7, q.popBack());
+    try testing.expectEqual(6, q.popBack());
+
+    try q.pushFrontSlice(gpa, &.{ 0, 1 });
+    try q.pushBackSlice(gpa, &.{ 6, 7 });
+
+    try testing.expectEqual(0, q.popFront());
+    try testing.expectEqual(1, q.popFront());
+    try testing.expectEqual(2, q.popFront());
+    try testing.expectEqual(7, q.popBack());
+    try testing.expectEqual(6, q.popBack());
+    try testing.expectEqual(3, q.popFront());
+    try testing.expectEqual(4, q.popFront());
+    try testing.expectEqual(5, q.popBack());
+    try testing.expectEqual(null, q.popFront());
+    try testing.expectEqual(null, q.popBack());
+}
+
 test "fuzz against ArrayList oracle" {
     try std.testing.fuzz({}, fuzzAgainstArrayList, .{});
 }
@@ -384,6 +503,8 @@ fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
     const Action = enum {
         push_back,
         push_front,
+        push_back_slice,
+        push_front_slice,
         pop_back,
         pop_front,
         grow,
@@ -406,6 +527,28 @@ fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
                     q.pushFrontBounded(item),
                 );
             },
+            .push_back_slice => {
+                var buffer: [std.math.maxInt(u3)]u32 = undefined;
+                const items = buffer[0..random.int(u3)];
+                for (items) |*item| {
+                    item.* = random.int(u8);
+                }
+                try testing.expectEqual(
+                    l.appendSliceBounded(items),
+                    q.pushBackSliceBounded(items),
+                );
+            },
+            .push_front_slice => {
+                var buffer: [std.math.maxInt(u3)]u32 = undefined;
+                const items = buffer[0..random.int(u3)];
+                for (items) |*item| {
+                    item.* = random.int(u8);
+                }
+                try testing.expectEqual(
+                    l.insertSliceBounded(0, items),
+                    q.pushFrontSliceBounded(items),
+                );
+            },
             .pop_back => {
                 try testing.expectEqual(l.pop(), q.popBack());
             },
-- 
2.54.0


From 623723507f7f307ac888ce483b422bde7da9984b Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Wed, 11 Feb 2026 08:29:30 +0100
Subject: [PATCH 282/499] std.Deque: add `peek` and `*Ptr` functions to
 `Iterator`

The iterator should be as powerful as manual access via `as` and `asPtr`
to justify its existence.
---
 lib/std/deque.zig | 57 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 51 insertions(+), 6 deletions(-)

diff --git a/lib/std/deque.zig b/lib/std/deque.zig
index 236d476135416e73057793f0327b2beb633c61f7..6a2cbdaeb4f81ff4e7d6d7f45b6ab63ab6776c70 100644
--- a/lib/std/deque.zig
+++ b/lib/std/deque.zig
@@ -323,13 +323,24 @@ pub fn Deque(comptime T: type) type {
             deque: *const Self,
             index: usize,
 
+            pub fn peek(it: Iterator) ?T {
+                if (it.index >= it.deque.len) return null;
+                return it.deque.at(it.index);
+            }
             pub fn next(it: *Iterator) ?T {
-                if (it.index < it.deque.len) {
-                    defer it.index += 1;
-                    return it.deque.at(it.index);
-                } else {
-                    return null;
-                }
+                const item = it.peek() orelse return null;
+                it.index += 1;
+                return item;
+            }
+
+            pub fn peekPtr(it: Iterator) ?*T {
+                if (it.index >= it.deque.len) return null;
+                return it.deque.atPtr(it.index);
+            }
+            pub fn nextPtr(it: *Iterator) ?*T {
+                const item_ptr = it.peekPtr() orelse return null;
+                it.index += 1;
+                return item_ptr;
             }
         };
 
@@ -469,6 +480,40 @@ test "slice" {
     try testing.expectEqual(null, q.popBack());
 }
 
+test "iterator" {
+    const testing = std.testing;
+    const gpa = testing.allocator;
+
+    var q: Deque(i32) = .empty;
+    defer q.deinit(gpa);
+
+    const items: []const i32 = &.{ 0, 1, 2, 3, 4, 5 };
+    try q.pushFrontSlice(gpa, items);
+
+    {
+        var it = q.iterator();
+        for (items) |item| {
+            try testing.expectEqual(item, it.peek());
+            try testing.expectEqual(item, it.next());
+        }
+        try testing.expectEqual(null, it.peek());
+        try testing.expectEqual(null, it.next());
+    }
+    {
+        var it = q.iterator();
+        for (items) |item| {
+            if (it.peekPtr()) |ptr| {
+                try testing.expectEqual(item, ptr.*);
+            } else return error.TextExpectedNonNull;
+            if (it.nextPtr()) |ptr| {
+                try testing.expectEqual(item, ptr.*);
+            } else return error.TextExpectedNonNull;
+        }
+        try testing.expectEqual(null, it.peekPtr());
+        try testing.expectEqual(null, it.nextPtr());
+    }
+}
+
 test "fuzz against ArrayList oracle" {
     try std.testing.fuzz({}, fuzzAgainstArrayList, .{});
 }
-- 
2.54.0


From 13e42b16cd91a92f18e9666e0ad8617b396c215a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 12 Feb 2026 21:45:52 -0800
Subject: [PATCH 283/499] std.deque: fix typo in unit test

---
 lib/std/deque.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/deque.zig b/lib/std/deque.zig
index 6a2cbdaeb4f81ff4e7d6d7f45b6ab63ab6776c70..2d4cfc8600ef07c20660c3a1eb0f680089f58854 100644
--- a/lib/std/deque.zig
+++ b/lib/std/deque.zig
@@ -504,10 +504,10 @@ test "iterator" {
         for (items) |item| {
             if (it.peekPtr()) |ptr| {
                 try testing.expectEqual(item, ptr.*);
-            } else return error.TextExpectedNonNull;
+            } else return error.TestExpectedNonNull;
             if (it.nextPtr()) |ptr| {
                 try testing.expectEqual(item, ptr.*);
-            } else return error.TextExpectedNonNull;
+            } else return error.TestExpectedNonNull;
         }
         try testing.expectEqual(null, it.peekPtr());
         try testing.expectEqual(null, it.nextPtr());
-- 
2.54.0


From 0bed4fb384f2e4d0f33307f63e9d3a1f023438e4 Mon Sep 17 00:00:00 2001
From: IntegratedQuantum <jahe788@gmail.com>
Date: Fri, 13 Feb 2026 16:54:10 +0100
Subject: [PATCH 284/499] crypto: Allow arbitrary types for secureZeroes

also removed some related ptrCasts
---
 lib/std/crypto.zig               | 2 +-
 lib/std/crypto/ghash_polyval.zig | 2 +-
 lib/std/crypto/poly1305.zig      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/crypto.zig b/lib/std/crypto.zig
index 7833a31237bff443a652bc9c4ca639c81e90e98f..d020d61e14c9c3d27712ed05bacf03d16ca1c5b6 100644
--- a/lib/std/crypto.zig
+++ b/lib/std/crypto.zig
@@ -412,7 +412,7 @@ test "issue #4532: no index out of bounds" {
 /// Sets a slice to zeroes.
 /// Prevents the store from being optimized out.
 pub fn secureZero(comptime T: type, s: []volatile T) void {
-    @memset(s, 0);
+    @memset(s, std.mem.zeroes(T));
 }
 
 test secureZero {
diff --git a/lib/std/crypto/ghash_polyval.zig b/lib/std/crypto/ghash_polyval.zig
index 45b2beb91b253ae0ee7fb6a8151bf82c0df47817..8e33eb80750c0b6c43e3f0106ff45636ef22670e 100644
--- a/lib/std/crypto/ghash_polyval.zig
+++ b/lib/std/crypto/ghash_polyval.zig
@@ -402,7 +402,7 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
             st.pad();
             mem.writeInt(u128, out[0..16], st.acc, endian);
 
-            std.crypto.secureZero(u8, @as([*]u8, @ptrCast(st))[0..@sizeOf(Self)]);
+            std.crypto.secureZero(Self, st[0..1]);
         }
 
         /// Compute the GHASH of a message.
diff --git a/lib/std/crypto/poly1305.zig b/lib/std/crypto/poly1305.zig
index 5bf5a57428897f54595c785eeb4b1bd6acdbb30d..3d6e4d89c33b785dfbeda0fc2fd03a12cf88be2b 100644
--- a/lib/std/crypto/poly1305.zig
+++ b/lib/std/crypto/poly1305.zig
@@ -184,7 +184,7 @@ pub const Poly1305 = struct {
         mem.writeInt(u64, out[0..8], st.h[0], .little);
         mem.writeInt(u64, out[8..16], st.h[1], .little);
 
-        std.crypto.secureZero(u8, @as([*]u8, @ptrCast(st))[0..@sizeOf(Poly1305)]);
+        std.crypto.secureZero(Poly1305, st[0..1]);
     }
 
     pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void {
-- 
2.54.0


From 2fa1a784914c536e45fdfaba9e357d0ef4f4f133 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Mon, 9 Feb 2026 14:19:27 -0500
Subject: [PATCH 285/499] Io.Dispatch: introduce grand central dispatch io impl

---
 lib/std/Build/Watch/FsEvents.zig      |   44 +-
 lib/std/Io.zig                        |  112 +-
 lib/std/Io/Dispatch.zig               | 5038 +++++++++++++++++++++++++
 lib/std/Io/Kqueue.zig                 |  218 +-
 lib/std/Io/Reader.zig                 |    2 +-
 lib/std/Io/Threaded.zig               |  247 +-
 lib/std/Io/{IoUring.zig => Uring.zig} |  875 ++---
 lib/std/Io/fiber.zig                  |  201 +
 lib/std/c.zig                         |   13 +-
 lib/std/c/darwin.zig                  |   28 +-
 lib/std/c/darwin/dispatch.zig         |  308 ++
 lib/std/debug.zig                     |    8 +-
 lib/std/process/Environ.zig           |   12 +
 src/crash_report.zig                  |    2 +
 14 files changed, 6163 insertions(+), 945 deletions(-)
 create mode 100644 lib/std/Io/Dispatch.zig
 rename lib/std/Io/{IoUring.zig => Uring.zig} (93%)
 create mode 100644 lib/std/Io/fiber.zig
 create mode 100644 lib/std/c/darwin/dispatch.zig

diff --git a/lib/std/Build/Watch/FsEvents.zig b/lib/std/Build/Watch/FsEvents.zig
index c9d2ed219c7e926b3cefd80b61d5ca5bf8945e02..dd22a5881df3cc888d9cc44a9e9f546f42ce3169 100644
--- a/lib/std/Build/Watch/FsEvents.zig
+++ b/lib/std/Build/Watch/FsEvents.zig
@@ -34,11 +34,11 @@ watch_paths: std.StringArrayHashMapUnmanaged([]const *std.Build.Step),
 
 /// The semaphore we use to block the thread calling `wait` until the callback determines a relevant
 /// event has occurred. This is retained across `wait` calls for simplicity and efficiency.
-waiting_semaphore: dispatch_semaphore_t,
+waiting_semaphore: dispatch.semaphore_t,
 /// This dispatch queue is created by us and executes serially. It exists exclusively to trigger the
 /// callbacks of the FSEventStream we create. This is not in use outside of `wait`, but is retained
 /// across `wait` calls for simplicity and efficiency.
-dispatch_queue: dispatch_queue_t,
+dispatch_queue: dispatch.queue_t,
 /// In theory, this field avoids race conditions. In practice, it is essentially unused at the time
 /// of writing. See the comment at the start of `wait` for details.
 since_event: FSEventStreamEventId,
@@ -57,7 +57,7 @@ const ResolvedSymbols = struct {
         latency: CFTimeInterval,
         flags: FSEventStreamCreateFlags,
     ) callconv(.c) FSEventStreamRef,
-    FSEventStreamSetDispatchQueue: *const fn (stream: FSEventStreamRef, queue: dispatch_queue_t) callconv(.c) void,
+    FSEventStreamSetDispatchQueue: *const fn (stream: FSEventStreamRef, queue: dispatch.queue_t) callconv(.c) void,
     FSEventStreamStart: *const fn (stream: FSEventStreamRef) callconv(.c) bool,
     FSEventStreamStop: *const fn (stream: FSEventStreamRef) callconv(.c) void,
     FSEventStreamInvalidate: *const fn (stream: FSEventStreamRef) callconv(.c) void,
@@ -80,7 +80,7 @@ const ResolvedSymbols = struct {
     kCFAllocatorUseContext: *const CFAllocatorRef,
 };
 
-pub fn init(cwd_path: []const u8) error{ OpenFrameworkFailed, MissingCoreServicesSymbol }!FsEvents {
+pub fn init(cwd_path: []const u8) error{ OpenFrameworkFailed, MissingCoreServicesSymbol, SystemResources }!FsEvents {
     var core_services = std.DynLib.open("/System/Library/Frameworks/CoreServices.framework/CoreServices") catch
         return error.OpenFrameworkFailed;
     errdefer core_services.close();
@@ -96,8 +96,8 @@ pub fn init(cwd_path: []const u8) error{ OpenFrameworkFailed, MissingCoreService
         .paths_arena = .{},
         .watch_roots = &.{},
         .watch_paths = .empty,
-        .waiting_semaphore = dispatch_semaphore_create(0),
-        .dispatch_queue = dispatch_queue_create("zig-watch", .SERIAL),
+        .waiting_semaphore = dispatch.semaphore_create(0) orelse return error.SystemResources,
+        .dispatch_queue = dispatch.queue_create("zig-watch", .SERIAL()) orelse return error.SystemResources,
         // Not `.since_now`, because this means we can init `FsEvents` *before* we do work in order
         // to notice any changes which happened during said work.
         .since_event = resolved_symbols.FSEventsGetCurrentEventId(),
@@ -106,8 +106,8 @@ pub fn init(cwd_path: []const u8) error{ OpenFrameworkFailed, MissingCoreService
 }
 
 pub fn deinit(fse: *FsEvents, gpa: Allocator, io: Io) void {
-    dispatch_release(fse.waiting_semaphore);
-    dispatch_release(fse.dispatch_queue);
+    fse.waiting_semaphore.as_object().release();
+    fse.dispatch_queue.as_object().release();
     fse.core_services.close(io);
 
     gpa.free(fse.watch_roots);
@@ -275,9 +275,9 @@ pub fn wait(fse: *FsEvents, gpa: Allocator, timeout_ns: ?u64) error{ OutOfMemory
     defer rs.FSEventStreamInvalidate(event_stream);
     if (!rs.FSEventStreamStart(event_stream)) return error.StartFailed;
     defer rs.FSEventStreamStop(event_stream);
-    const result = dispatch_semaphore_wait(fse.waiting_semaphore, timeout: {
-        const ns = timeout_ns orelse break :timeout .forever;
-        break :timeout dispatch_time(.now, @intCast(ns));
+    const result = fse.waiting_semaphore.wait(timeout: {
+        const ns = timeout_ns orelse break :timeout .FOREVER;
+        break :timeout .time(.NOW, @intCast(ns));
     });
     return switch (result) {
         0 => .dirty,
@@ -382,7 +382,7 @@ fn eventCallback(
     }
     if (any_dirty) {
         fse.since_event = rs.FSEventStreamGetLatestEventId(stream);
-        _ = dispatch_semaphore_signal(fse.waiting_semaphore);
+        _ = fse.waiting_semaphore.signal();
     }
 }
 fn dirStartsWith(path: []const u8, prefix: []const u8) bool {
@@ -392,25 +392,6 @@ fn dirStartsWith(path: []const u8, prefix: []const u8) bool {
     return true; // `path` is `/foo/bar/...`, `prefix` is `/foo/bar`
 }
 
-const dispatch_time_t = enum(u64) {
-    now = 0,
-    forever = std.math.maxInt(u64),
-    _,
-};
-extern fn dispatch_time(base: dispatch_time_t, delta_ns: i64) dispatch_time_t;
-
-const dispatch_semaphore_t = *opaque {};
-extern fn dispatch_semaphore_create(value: isize) dispatch_semaphore_t;
-extern fn dispatch_semaphore_wait(dsema: dispatch_semaphore_t, timeout: dispatch_time_t) isize;
-extern fn dispatch_semaphore_signal(dsema: dispatch_semaphore_t) isize;
-
-const dispatch_queue_t = *opaque {};
-const dispatch_queue_attr_t = ?*opaque {
-    const SERIAL: dispatch_queue_attr_t = null;
-};
-extern fn dispatch_queue_create(label: [*:0]const u8, attr: dispatch_queue_attr_t) dispatch_queue_t;
-extern fn dispatch_release(object: *anyopaque) void;
-
 const CFAllocatorRef = ?*const opaque {};
 const CFArrayRef = *const opaque {};
 const CFStringRef = *const opaque {};
@@ -489,6 +470,7 @@ const FSEventStreamEventFlags = packed struct(u32) {
     _: u24 = 0,
 };
 
+const dispatch = std.c.dispatch;
 const std = @import("std");
 const Io = std.Io;
 const assert = std.debug.assert;
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index b22345ed94a96eb31dff8a2b29d8a2cb21247759..daced32fa855d618e6a8750abb5ac61329b291c4 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -26,19 +26,17 @@ userdata: ?*anyopaque,
 vtable: *const VTable,
 
 pub const Threaded = @import("Io/Threaded.zig");
-pub const Evented = switch (builtin.os.tag) {
-    .linux => switch (builtin.cpu.arch) {
-        .x86_64, .aarch64 => IoUring,
-        else => void, // context-switching code not implemented yet
-    },
-    .dragonfly, .freebsd, .netbsd, .openbsd, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => switch (builtin.cpu.arch) {
-        .x86_64, .aarch64 => Kqueue,
-        else => void, // context-switching code not implemented yet
-    },
+
+pub const fiber = @import("Io/fiber.zig");
+pub const Evented = if (fiber.supported) switch (builtin.os.tag) {
+    .linux => Uring,
+    .dragonfly, .freebsd, .netbsd, .openbsd => Kqueue,
+    .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => Dispatch,
     else => void,
-};
+} else void; // context-switching code not implemented yet
+pub const Dispatch = @import("Io/Dispatch.zig");
 pub const Kqueue = @import("Io/Kqueue.zig");
-pub const IoUring = @import("Io/IoUring.zig");
+pub const Uring = @import("Io/Uring.zig");
 
 pub const Reader = @import("Io/Reader.zig");
 pub const Writer = @import("Io/Writer.zig");
@@ -51,6 +49,8 @@ pub const RwLock = @import("Io/RwLock.zig");
 pub const Semaphore = @import("Io/Semaphore.zig");
 
 pub const VTable = struct {
+    crashHandler: *const fn (?*anyopaque) void,
+
     /// If it returns `null` it means `result` has been already populated and
     /// `await` will be a no-op.
     ///
@@ -378,9 +378,9 @@ pub const Operation = union(enum) {
         pub const Pending = struct {
             node: List.DoubleNode,
             tag: Tag,
-            context: Context align(@max(@alignOf(usize), 4)),
+            userdata: Userdata align(@max(@alignOf(usize), 4)),
 
-            pub const Context = [3]usize;
+            pub const Userdata = [7]usize;
         };
 
         pub const Completion = struct {
@@ -431,7 +431,7 @@ pub const Batch = struct {
     submitted: Operation.List,
     pending: Operation.List,
     completed: Operation.List,
-    context: ?*anyopaque align(@max(@alignOf(?*anyopaque), 4)),
+    userdata: ?*anyopaque align(@max(@alignOf(?*anyopaque), 4)),
 
     /// After calling this, it is safe to unconditionally defer a call to
     /// `cancel`. `storage` is a pre-allocated buffer of undefined memory that
@@ -453,40 +453,40 @@ pub const Batch = struct {
             .submitted = .empty,
             .pending = .empty,
             .completed = .empty,
-            .context = null,
+            .userdata = null,
         };
     }
 
     /// Adds an operation to be performed at the next await call.
     /// Returns the index that will be returned by `next` after the operation completes.
     /// Asserts that no more than `storage.len` operations are active at a time.
-    pub fn add(b: *Batch, operation: Operation) u32 {
-        const index = b.unused.next;
-        b.addAt(index.toIndex(), operation);
+    pub fn add(batch: *Batch, operation: Operation) u32 {
+        const index = batch.unused.next;
+        batch.addAt(index.toIndex(), operation);
         return index;
     }
 
     /// Adds an operation to be performed at the next await call.
     /// After the operation completes, `next` will return `index`.
     /// Asserts that the operation at `index` is not active.
-    pub fn addAt(b: *Batch, index: u32, operation: Operation) void {
-        const storage = &b.storage[index];
+    pub fn addAt(batch: *Batch, index: u32, operation: Operation) void {
+        const storage = &batch.storage[index];
         const unused = storage.unused;
         switch (unused.prev) {
-            .none => b.unused.head = unused.next,
-            else => |prev_index| b.storage[prev_index.toIndex()].unused.next = unused.next,
+            .none => batch.unused.head = unused.next,
+            else => |prev_index| batch.storage[prev_index.toIndex()].unused.next = unused.next,
         }
         switch (unused.next) {
-            .none => b.unused.tail = unused.prev,
-            else => |next_index| b.storage[next_index.toIndex()].unused.prev = unused.prev,
+            .none => batch.unused.tail = unused.prev,
+            else => |next_index| batch.storage[next_index.toIndex()].unused.prev = unused.prev,
         }
 
-        switch (b.submitted.tail) {
-            .none => b.submitted.head = .fromIndex(index),
-            else => |tail_index| b.storage[tail_index.toIndex()].submission.node.next = .fromIndex(index),
+        switch (batch.submitted.tail) {
+            .none => batch.submitted.head = .fromIndex(index),
+            else => |tail_index| batch.storage[tail_index.toIndex()].submission.node.next = .fromIndex(index),
         }
         storage.* = .{ .submission = .{ .node = .{ .next = .none }, .operation = operation } };
-        b.submitted.tail = .fromIndex(index);
+        batch.submitted.tail = .fromIndex(index);
     }
 
     pub const Completion = struct {
@@ -502,22 +502,22 @@ pub const Batch = struct {
     ///
     /// Each completion returned from this function dequeues from the `Batch`.
     /// It is not required to dequeue all completions before awaiting again.
-    pub fn next(b: *Batch) ?Completion {
-        const index = b.completed.head;
+    pub fn next(batch: *Batch) ?Completion {
+        const index = batch.completed.head;
         if (index == .none) return null;
-        const storage = &b.storage[index.toIndex()];
+        const storage = &batch.storage[index.toIndex()];
         const completion = storage.completion;
         const next_index = completion.node.next;
-        b.completed.head = next_index;
-        if (next_index == .none) b.completed.tail = .none;
+        batch.completed.head = next_index;
+        if (next_index == .none) batch.completed.tail = .none;
 
-        const tail_index = b.unused.tail;
+        const tail_index = batch.unused.tail;
         switch (tail_index) {
-            .none => b.unused.head = index,
-            else => b.storage[tail_index.toIndex()].unused.next = index,
+            .none => batch.unused.head = index,
+            else => batch.storage[tail_index.toIndex()].unused.next = index,
         }
         storage.* = .{ .unused = .{ .prev = tail_index, .next = .none } };
-        b.unused.tail = index;
+        batch.unused.tail = index;
         return .{ .index = index.toIndex(), .result = completion.result };
     }
 
@@ -529,8 +529,8 @@ pub const Batch = struct {
     /// concurrency into the batched operations, but unlike `awaitConcurrent`,
     /// does not require it, and therefore cannot fail with
     /// `error.ConcurrencyUnavailable`.
-    pub fn awaitAsync(b: *Batch, io: Io) Cancelable!void {
-        return io.vtable.batchAwaitAsync(io.userdata, b);
+    pub fn awaitAsync(batch: *Batch, io: Io) Cancelable!void {
+        return io.vtable.batchAwaitAsync(io.userdata, batch);
     }
 
     pub const AwaitConcurrentError = ConcurrentError || Cancelable || Timeout.Error;
@@ -542,8 +542,8 @@ pub const Batch = struct {
     /// Unlike `awaitAsync`, this function requires the implementation to
     /// perform the operations concurrently and therefore can fail with
     /// `error.ConcurrencyUnavailable`.
-    pub fn awaitConcurrent(b: *Batch, io: Io, timeout: Timeout) AwaitConcurrentError!void {
-        return io.vtable.batchAwaitConcurrent(io.userdata, b, timeout);
+    pub fn awaitConcurrent(batch: *Batch, io: Io, timeout: Timeout) AwaitConcurrentError!void {
+        return io.vtable.batchAwaitConcurrent(io.userdata, batch, timeout);
     }
 
     /// Requests all pending operations to be interrupted, then waits for all
@@ -552,28 +552,28 @@ pub const Batch = struct {
     /// canceled operations will be absent from the iteration. Some operations
     /// may have successfully completed regardless of the cancel request and
     /// will appear in the iteration.
-    pub fn cancel(b: *Batch, io: Io) void {
+    pub fn cancel(batch: *Batch, io: Io) void {
         { // abort pending submissions
-            var tail_index = b.unused.tail;
-            defer b.unused.tail = tail_index;
-            var index = b.submitted.head;
-            errdefer b.submissions.head = index;
+            var tail_index = batch.unused.tail;
+            defer batch.unused.tail = tail_index;
+            var index = batch.submitted.head;
+            errdefer batch.submissions.head = index;
             while (index != .none) {
-                const next_index = b.storage[index.toIndex()].submission.node.next;
+                const next_index = batch.storage[index.toIndex()].submission.node.next;
                 switch (tail_index) {
-                    .none => b.unused.head = index,
-                    else => b.storage[tail_index.toIndex()].unused.next = index,
+                    .none => batch.unused.head = index,
+                    else => batch.storage[tail_index.toIndex()].unused.next = index,
                 }
-                b.storage[index.toIndex()] = .{ .unused = .{ .prev = tail_index, .next = .none } };
+                batch.storage[index.toIndex()] = .{ .unused = .{ .prev = tail_index, .next = .none } };
                 tail_index = index;
                 index = next_index;
             }
-            b.submitted = .{ .head = .none, .tail = .none };
+            batch.submitted = .{ .head = .none, .tail = .none };
         }
-        io.vtable.batchCancel(io.userdata, b);
-        assert(b.submitted.head == .none and b.submitted.tail == .none);
-        assert(b.pending.head == .none and b.pending.tail == .none);
-        assert(b.context == null); // that was the last chance to deallocate resources
+        io.vtable.batchCancel(io.userdata, batch);
+        assert(batch.submitted.head == .none and batch.submitted.tail == .none);
+        assert(batch.pending.head == .none and batch.pending.tail == .none);
+        assert(batch.userdata == null); // that was the last chance to deallocate resources
     }
 };
 
@@ -643,7 +643,7 @@ pub const Limit = enum(usize) {
     }
 
     pub fn nonzero(l: Limit) bool {
-        return @intFromEnum(l) > 0;
+        return l != .nothing;
     }
 
     /// Return a new limit reduced by `amount` or return `null` indicating
diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..49df71ef9499ba46640761ada9b261f4af069dc0
--- /dev/null
+++ b/lib/std/Io/Dispatch.zig
@@ -0,0 +1,5038 @@
+const Alignment = std.mem.Alignment;
+const Allocator = std.mem.Allocator;
+const Argv0 = Io.Threaded.Argv0;
+const assert = std.debug.assert;
+const builtin = @import("builtin");
+const c = std.c;
+const ChdirError = Io.Threaded.ChdirError;
+const clockToPosix = Io.Threaded.clockToPosix;
+const closeFd = Io.Threaded.closeFd;
+const Csprng = Io.Threaded.Csprng;
+const default_PATH = Io.Threaded.default_PATH;
+const Dir = Io.Dir;
+const Environ = Io.Threaded.Environ;
+const errnoBug = Io.Threaded.errnoBug;
+const Evented = @This();
+const fallbackSeed = Io.Threaded.fallbackSeed;
+const File = Io.File;
+const Io = std.Io;
+const iovec = std.posix.iovec;
+const iovec_const = std.posix.iovec_const;
+const log = std.log.scoped(.dispatch);
+const max_iovecs_len = Io.Threaded.max_iovecs_len;
+const nanosecondsFromPosix = Io.Threaded.nanosecondsFromPosix;
+const net = Io.net;
+const pathToPosix = Io.Threaded.pathToPosix;
+const process = std.process;
+const recoverableOsBugDetected = Io.Threaded.recoverableOsBugDetected;
+const setTimestampToPosix = Io.Threaded.setTimestampToPosix;
+const splat_buffer_size = Io.Threaded.splat_buffer_size;
+const statFromPosix = Io.Threaded.statFromPosix;
+const statusToTerm = Io.Threaded.statusToTerm;
+const std = @import("std");
+const timestampFromPosix = Io.Threaded.timestampFromPosix;
+const unexpectedErrno = std.posix.unexpectedErrno;
+const UseSendfile = Io.Threaded.UseSendfile;
+const UseFcopyfile = Io.Threaded.UseFcopyfile;
+
+/// Empirically saw >4KB being used by the llvm aarch64 backend.
+const main_loop_stack_size = 8 * 1024;
+
+queue: c.dispatch.queue_t,
+backing_allocator_needs_mutex: bool,
+backing_allocator_mutex: Mutex,
+/// Does not need to be thread-safe if not used elsewhere.
+backing_allocator: Allocator,
+main_fiber: Fiber,
+main_loop_stack: [*]align(builtin.target.stackAlignment()) u8,
+exit_semaphore: c.dispatch.semaphore_t,
+
+use_sendfile: UseSendfile,
+use_fcopyfile: UseFcopyfile,
+leeway: u64,
+
+futexes: [1 << 8]Futex,
+
+init_stderr_writer: c.dispatch.once_t,
+stderr_mutex: Mutex,
+stderr_writer: File.Writer,
+stderr_mode: Io.Terminal.Mode,
+
+scan_environ: c.dispatch.once_t,
+environ: Environ,
+
+open_dev_null: c.dispatch.once_t,
+dev_null_file: File.OpenError!File,
+
+csprng_mutex: Mutex,
+csprng: Csprng,
+
+const Thread = struct {
+    main_context: Io.fiber.Context,
+    current_context: ?*Io.fiber.Context,
+    seed_csprng: c.dispatch.once_t,
+    csprng: Csprng,
+
+    threadlocal var self: Thread = .{
+        .main_context = undefined,
+        .current_context = null,
+        .seed_csprng = .init,
+        .csprng = undefined,
+    };
+
+    noinline fn current() *Thread {
+        return &self;
+    }
+
+    fn currentFiber(thread: *Thread) *Fiber {
+        assert(thread.current_context != &thread.main_context);
+        return @fieldParentPtr("context", thread.current_context.?);
+    }
+
+    const List = struct {
+        allocated: []Thread,
+        reserved: u32,
+        active: u32,
+    };
+};
+
+const Fiber = struct {
+    required_align: void align(4),
+    evented: *Evented,
+    context: Io.fiber.Context,
+    await_count: i32,
+    link: union {
+        awaiter: ?*Fiber,
+        group: struct { prev: ?*Fiber, next: ?*Fiber },
+    },
+    status: union(enum) {
+        queue_next: ?*Fiber,
+        awaiting_group: Group,
+    },
+    cancel_status: CancelStatus,
+    cancel_protection: CancelProtection,
+
+    var next_name: u64 = 0;
+
+    const CancelStatus = packed struct(usize) {
+        requested: bool,
+        awaiting: Awaiting,
+
+        const unrequested: CancelStatus = .{ .requested = false, .awaiting = .nothing };
+
+        const Awaiting = enum(@Int(.unsigned, @bitSizeOf(usize) - shift)) {
+            nothing = 0,
+            group = 1,
+            select = 2,
+            _,
+
+            const shift = 1;
+
+            fn subWrap(lhs: Awaiting, rhs: Awaiting) Awaiting {
+                return @enumFromInt(@intFromEnum(lhs) -% @intFromEnum(rhs));
+            }
+
+            fn fromCancelable(cancelable: *Cancelable) Awaiting {
+                return @enumFromInt(@shrExact(@intFromPtr(cancelable), shift));
+            }
+
+            fn toCancelable(awaiting: Awaiting) *Cancelable {
+                return @ptrFromInt(@shlExact(@as(usize, @intFromEnum(awaiting)), shift));
+            }
+        };
+
+        fn changeAwaiting(
+            cancel_status: *CancelStatus,
+            old_awaiting: Awaiting,
+            new_awaiting: Awaiting,
+        ) bool {
+            const old_cancel_status = @atomicRmw(CancelStatus, cancel_status, .Add, .{
+                .requested = false,
+                .awaiting = new_awaiting.subWrap(old_awaiting),
+            }, .release);
+            assert(old_cancel_status.awaiting == old_awaiting);
+            return old_cancel_status.requested;
+        }
+    };
+
+    const CancelProtection = packed struct {
+        user: Io.CancelProtection,
+        acknowledged: bool,
+
+        const unblocked: CancelProtection = .{ .user = .unblocked, .acknowledged = false };
+
+        fn check(cancel_protection: CancelProtection) Io.CancelProtection {
+            return @enumFromInt(@intFromBool(cancel_protection != unblocked));
+        }
+
+        fn acknowledge(cancel_protection: *CancelProtection) void {
+            assert(!cancel_protection.acknowledged);
+            cancel_protection.acknowledged = true;
+        }
+
+        fn recancel(cancel_protection: *CancelProtection) void {
+            assert(cancel_protection.acknowledged);
+            cancel_protection.acknowledged = false;
+        }
+
+        test check {
+            try std.testing.expectEqual(Io.CancelProtection.unblocked, check(.unblocked));
+            try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
+                .user = .unblocked,
+                .acknowledged = true,
+            }));
+            try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
+                .user = .blocked,
+                .acknowledged = false,
+            }));
+            try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
+                .user = .blocked,
+                .acknowledged = true,
+            }));
+        }
+    };
+
+    const finished: ?*Fiber = @ptrFromInt(@alignOf(Fiber));
+
+    const max_result_align: Alignment = .@"16";
+    const max_result_size = max_result_align.forward(512);
+    /// This includes any stack realignments that need to happen, and also the
+    /// initial frame return address slot and argument frame, depending on target.
+    const min_stack_size = 60 * 1024 * 1024;
+    const max_context_align: Alignment = .@"16";
+    const max_context_size = max_context_align.forward(1024);
+    const max_closure_size: usize = @sizeOf(AsyncClosure);
+    const max_closure_align: Alignment = .of(AsyncClosure);
+    const allocation_size = std.mem.alignForward(
+        usize,
+        max_closure_align.max(max_context_align).forward(
+            max_result_align.forward(@sizeOf(Fiber)) + max_result_size + min_stack_size,
+        ) + max_closure_size + max_context_size,
+        std.heap.page_size_max,
+    );
+
+    fn create(ev: *Evented) error{OutOfMemory}!*Fiber {
+        return @ptrCast(try ev.allocator().alignedAlloc(u8, .of(Fiber), allocation_size));
+    }
+
+    fn destroy(fiber: *Fiber, ev: *Evented) void {
+        assert(fiber.status.queue_next == null);
+        ev.allocator().free(fiber.allocatedSlice());
+    }
+
+    fn allocatedSlice(f: *Fiber) []align(@alignOf(Fiber)) u8 {
+        return @as([*]align(@alignOf(Fiber)) u8, @ptrCast(f))[0..allocation_size];
+    }
+
+    fn allocatedEnd(f: *Fiber) [*]u8 {
+        const allocated_slice = f.allocatedSlice();
+        return allocated_slice[allocated_slice.len..].ptr;
+    }
+
+    fn resultPointer(f: *Fiber, comptime Result: type) *Result {
+        return @ptrCast(@alignCast(f.resultBytes(.of(Result))));
+    }
+
+    fn resultBytes(f: *Fiber, alignment: Alignment) [*]u8 {
+        return @ptrFromInt(alignment.forward(@intFromPtr(f) + @sizeOf(Fiber)));
+    }
+
+    const Queue = struct { head: *Fiber, tail: *Fiber };
+
+    /// Like a `*Fiber`, but 2 bits smaller than a pointer (because the LSBs are always 0 due to
+    /// alignment) so that those two bits can be used in a `packed struct`.
+    const PackedPtr = enum(@Int(.unsigned, @bitSizeOf(usize) - 2)) {
+        null = 0,
+        all_ones = std.math.maxInt(@Int(.unsigned, @bitSizeOf(usize) - 2)),
+        _,
+
+        const Split = packed struct(usize) { low: u2, high: PackedPtr };
+        fn pack(ptr: ?*Fiber) PackedPtr {
+            const split: Split = @bitCast(@intFromPtr(ptr));
+            assert(split.low == 0);
+            return split.high;
+        }
+        fn unpack(ptr: PackedPtr) ?*Fiber {
+            const split: Split = .{ .low = 0, .high = ptr };
+            return @ptrFromInt(@as(usize, @bitCast(split)));
+        }
+    };
+
+    fn requestCancel(fiber: *Fiber, ev: *Evented) void {
+        const cancel_status = @atomicRmw(
+            Fiber.CancelStatus,
+            &fiber.cancel_status,
+            .Or,
+            .{ .requested = true, .awaiting = .nothing },
+            .acquire,
+        );
+        assert(!cancel_status.requested);
+        switch (cancel_status.awaiting) {
+            .nothing => {},
+            .group => {
+                // The awaiter received a cancelation request while awaiting a group,
+                // so propagate the cancelation to the group.
+                if (fiber.status.awaiting_group.cancel(ev, null)) {
+                    fiber.status = .{ .queue_next = null };
+                    ev.queue.async(fiber, &Fiber.@"resume");
+                }
+            },
+            .select => if (@atomicRmw(i32, &fiber.await_count, .Add, 1, .monotonic) == -1) {
+                ev.queue.async(fiber, &Fiber.@"resume");
+            },
+            _ => |awaiting| awaiting.toCancelable().canceled(),
+        }
+    }
+
+    fn @"resume"(context: ?*anyopaque) callconv(.c) void {
+        const fiber: *Fiber = @ptrCast(@alignCast(context));
+        const thread: *Thread = .current();
+        const message: SwitchMessage = .{
+            .contexts = .{
+                .old = &thread.main_context,
+                .new = &fiber.context,
+            },
+            .pending_task = .nothing,
+        };
+        contextSwitch(&message).handle(fiber.evented);
+    }
+};
+
+pub fn allocator(ev: *Evented) std.mem.Allocator {
+    return if (ev.backing_allocator_needs_mutex) .{
+        .ptr = ev,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    } else ev.backing_allocator;
+}
+
+fn alloc(userdata: *anyopaque, len: usize, alignment: std.mem.Alignment, ret_addr: usize) ?[*]u8 {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.backing_allocator_mutex.lockUncancelable(ev);
+    defer ev.backing_allocator_mutex.unlock();
+    return ev.backing_allocator.rawAlloc(len, alignment, ret_addr);
+}
+
+fn resize(
+    userdata: *anyopaque,
+    memory: []u8,
+    alignment: std.mem.Alignment,
+    new_len: usize,
+    ret_addr: usize,
+) bool {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.backing_allocator_mutex.lockUncancelable(ev);
+    defer ev.backing_allocator_mutex.unlock();
+    return ev.backing_allocator.rawResize(memory, alignment, new_len, ret_addr);
+}
+
+fn remap(
+    userdata: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    ret_addr: usize,
+) ?[*]u8 {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.backing_allocator_mutex.lockUncancelable(ev);
+    defer ev.backing_allocator_mutex.unlock();
+    return ev.backing_allocator.rawRemap(memory, alignment, new_len, ret_addr);
+}
+
+fn free(userdata: *anyopaque, memory: []u8, alignment: std.mem.Alignment, ret_addr: usize) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.backing_allocator_mutex.lockUncancelable(ev);
+    defer ev.backing_allocator_mutex.unlock();
+    return ev.backing_allocator.rawFree(memory, alignment, ret_addr);
+}
+
+pub fn io(ev: *Evented) Io {
+    return .{
+        .userdata = ev,
+        .vtable = &.{
+            .crashHandler = crashHandler,
+
+            .async = async,
+            .concurrent = concurrent,
+            .await = await,
+            .cancel = cancel,
+
+            .groupAsync = groupAsync,
+            .groupConcurrent = groupConcurrent,
+            .groupAwait = groupAwait,
+            .groupCancel = groupCancel,
+
+            .recancel = recancel,
+            .swapCancelProtection = swapCancelProtection,
+            .checkCancel = checkCancel,
+
+            .select = select,
+
+            .futexWait = futexWait,
+            .futexWaitUncancelable = futexWaitUncancelable,
+            .futexWake = futexWake,
+
+            .operate = operate,
+            .batchAwaitAsync = batchAwaitAsync,
+            .batchAwaitConcurrent = batchAwaitConcurrent,
+            .batchCancel = batchCancel,
+
+            .dirCreateDir = dirCreateDir,
+            .dirCreateDirPath = dirCreateDirPath,
+            .dirCreateDirPathOpen = dirCreateDirPathOpen,
+            .dirOpenDir = dirOpenDir,
+            .dirStat = dirStat,
+            .dirStatFile = dirStatFile,
+            .dirAccess = dirAccess,
+            .dirCreateFile = dirCreateFile,
+            .dirCreateFileAtomic = dirCreateFileAtomic,
+            .dirOpenFile = dirOpenFile,
+            .dirClose = dirClose,
+            .dirRead = dirRead,
+            .dirRealPath = dirRealPath,
+            .dirRealPathFile = dirRealPathFile,
+            .dirDeleteFile = dirDeleteFile,
+            .dirDeleteDir = dirDeleteDir,
+            .dirRename = dirRename,
+            .dirRenamePreserve = dirRenamePreserve,
+            .dirSymLink = dirSymLink,
+            .dirReadLink = dirReadLink,
+            .dirSetOwner = dirSetOwner,
+            .dirSetFileOwner = dirSetFileOwner,
+            .dirSetPermissions = dirSetPermissions,
+            .dirSetFilePermissions = dirSetFilePermissions,
+            .dirSetTimestamps = dirSetTimestamps,
+            .dirHardLink = dirHardLink,
+
+            .fileStat = fileStat,
+            .fileLength = fileLength,
+            .fileClose = fileClose,
+            .fileWritePositional = fileWritePositional,
+            .fileWriteFileStreaming = fileWriteFileStreaming,
+            .fileWriteFilePositional = fileWriteFilePositional,
+            .fileReadPositional = fileReadPositional,
+            .fileSeekBy = fileSeekBy,
+            .fileSeekTo = fileSeekTo,
+            .fileSync = fileSync,
+            .fileIsTty = fileIsTty,
+            .fileEnableAnsiEscapeCodes = fileEnableAnsiEscapeCodes,
+            .fileSupportsAnsiEscapeCodes = fileIsTty,
+            .fileSetLength = fileSetLength,
+            .fileSetOwner = fileSetOwner,
+            .fileSetPermissions = fileSetPermissions,
+            .fileSetTimestamps = fileSetTimestamps,
+            .fileLock = fileLock,
+            .fileTryLock = fileTryLock,
+            .fileUnlock = fileUnlock,
+            .fileDowngradeLock = fileDowngradeLock,
+            .fileRealPath = fileRealPath,
+            .fileHardLink = fileHardLink,
+
+            .fileMemoryMapCreate = fileMemoryMapCreate,
+            .fileMemoryMapDestroy = fileMemoryMapDestroy,
+            .fileMemoryMapSetLength = fileMemoryMapSetLength,
+            .fileMemoryMapRead = fileMemoryMapRead,
+            .fileMemoryMapWrite = fileMemoryMapWrite,
+
+            .processExecutableOpen = processExecutableOpen,
+            .processExecutablePath = processExecutablePath,
+            .lockStderr = lockStderr,
+            .tryLockStderr = tryLockStderr,
+            .unlockStderr = unlockStderr,
+            .processCurrentPath = processCurrentPath,
+            .processSetCurrentDir = processSetCurrentDir,
+            .processReplace = processReplace,
+            .processReplacePath = processReplacePath,
+            .processSpawn = processSpawn,
+            .processSpawnPath = processSpawnPath,
+            .childWait = childWait,
+            .childKill = childKill,
+
+            .progressParentFile = progressParentFile,
+
+            .now = now,
+            .clockResolution = clockResolution,
+            .sleep = sleep,
+
+            .random = random,
+            .randomSecure = randomSecure,
+
+            .netListenIp = netListenIpUnavailable,
+            .netAccept = netAcceptUnavailable,
+            .netBindIp = netBindIpUnavailable,
+            .netConnectIp = netConnectIpUnavailable,
+            .netListenUnix = netListenUnixUnavailable,
+            .netConnectUnix = netConnectUnixUnavailable,
+            .netSocketCreatePair = netSocketCreatePairUnavailable,
+            .netSend = netSendUnavailable,
+            .netReceive = netReceiveUnavailable,
+            .netRead = netReadUnavailable,
+            .netWrite = netWriteUnavailable,
+            .netWriteFile = netWriteFileUnavailable,
+            .netClose = netClose,
+            .netShutdown = netShutdownUnavailable,
+            .netInterfaceNameResolve = netInterfaceNameResolveUnavailable,
+            .netInterfaceName = netInterfaceNameUnavailable,
+            .netLookup = netLookupUnavailable,
+        },
+    };
+}
+
+pub const InitOptions = struct {
+    backing_allocator_needs_mutex: bool = true,
+    queue: ?c.dispatch.queue_t = null,
+    /// Upper limit on the allowable delay in processing timeouts in order to improve power
+    /// consumption and system performance.
+    leeway: Io.Duration = .fromMilliseconds(10),
+
+    /// Affects the following operations:
+    /// * `processExecutablePath` on OpenBSD and Haiku.
+    argv0: Argv0 = .empty,
+    /// Affects the following operations:
+    /// * `fileIsTty`
+    /// * `processSpawn`, `processSpawnPath`, `processReplace`, `processReplacePath`
+    environ: process.Environ = .empty,
+};
+
+pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !void {
+    const queue = if (options.queue) |queue| queue: {
+        queue.as_object().retain();
+        break :queue queue;
+    } else c.dispatch.queue_create("org.ziglang.std.Io.Dispatch", .CONCURRENT()) orelse
+        return error.SystemResources;
+    errdefer queue.as_object().release();
+    const main_loop_stack = try backing_allocator.alignedAlloc(
+        u8,
+        .fromByteUnits(builtin.target.stackAlignment()),
+        main_loop_stack_size,
+    );
+    errdefer backing_allocator.free(main_loop_stack);
+    const exit_semaphore = c.dispatch.semaphore_create(0) orelse return error.SystemResources;
+    errdefer exit_semaphore.as_object().release();
+    ev.* = .{
+        .queue = queue,
+        .backing_allocator_needs_mutex = options.backing_allocator_needs_mutex,
+        .backing_allocator_mutex = undefined,
+        .backing_allocator = backing_allocator,
+        .main_fiber = .{
+            .required_align = {},
+            .evented = ev,
+            .context = undefined,
+            .await_count = 0,
+            .link = .{ .awaiter = null },
+            .status = .{ .queue_next = null },
+            .cancel_status = .unrequested,
+            .cancel_protection = .unblocked,
+        },
+        .main_loop_stack = main_loop_stack.ptr,
+        .exit_semaphore = exit_semaphore,
+
+        .use_fcopyfile = .default,
+        .use_sendfile = .default,
+        .leeway = std.math.lossyCast(u64, options.leeway.toNanoseconds()),
+
+        .futexes = undefined,
+
+        .init_stderr_writer = .init,
+        .stderr_mutex = undefined,
+        .stderr_writer = .{
+            .io = ev.io(),
+            .interface = Io.File.Writer.initInterface(&.{}),
+            .file = .stderr(),
+            .mode = .streaming,
+        },
+        .stderr_mode = .no_color,
+
+        .scan_environ = if (options.environ.block.isEmpty()) .done else .init,
+        .environ = .{ .process_environ = options.environ },
+
+        .open_dev_null = .init,
+        .dev_null_file = error.FileNotFound,
+
+        .csprng_mutex = undefined,
+        .csprng = .uninitialized,
+    };
+    try ev.backing_allocator_mutex.init(queue);
+    errdefer ev.backing_allocator_mutex.deinit();
+    var initialized_futexes: usize = 0;
+    errdefer for (ev.futexes[0..initialized_futexes]) |*futex| futex.deinit();
+    for (&ev.futexes) |*futex| {
+        try futex.init(queue);
+        initialized_futexes += 1;
+    }
+    try ev.stderr_mutex.init(queue);
+    errdefer ev.stderr_mutex.deinit();
+    try ev.csprng_mutex.init(queue);
+    errdefer ev.csprng_mutex.deinit();
+    const thread: *Thread = .current();
+    thread.main_context = switch (builtin.cpu.arch) {
+        .aarch64 => .{
+            .sp = @intFromPtr(main_loop_stack[main_loop_stack_size..].ptr),
+            .fp = @intFromPtr(ev),
+            .pc = @intFromPtr(&mainLoopEntry),
+        },
+        .x86_64 => .{
+            .rsp = @intFromPtr(main_loop_stack[main_loop_stack_size..].ptr) - 8,
+            .rbp = @intFromPtr(ev),
+            .rip = @intFromPtr(&mainLoopEntry),
+        },
+        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+    };
+    thread.current_context = &ev.main_fiber.context;
+}
+
+pub fn deinit(ev: *Evented) void {
+    assert(Thread.current().currentFiber() == &ev.main_fiber);
+    ev.yield(.exit);
+    ev.csprng_mutex.deinit();
+    if (ev.dev_null_file) |file| fileClose(ev, &.{file}) else |_| {}
+    ev.stderr_mutex.deinit();
+    for (&ev.futexes) |*futex| futex.deinit();
+    ev.exit_semaphore.as_object().release();
+    ev.backing_allocator.free(ev.main_loop_stack[0..main_loop_stack_size]);
+    ev.queue.as_object().release();
+}
+
+fn yield(ev: *Evented, pending_task: SwitchMessage.PendingTask) void {
+    const thread: *Thread = .current();
+    const message: SwitchMessage = .{
+        .contexts = .{
+            .old = thread.current_context.?,
+            .new = &thread.main_context,
+        },
+        .pending_task = pending_task,
+    };
+    contextSwitch(&message).handle(ev);
+}
+
+fn mainLoopEntry() callconv(.naked) void {
+    switch (builtin.cpu.arch) {
+        .aarch64 => asm volatile (
+            \\ mov x0, fp
+            \\ mov fp, #0
+            \\ b %[mainLoop]
+            :
+            : [mainLoop] "X" (&mainLoop),
+        ),
+        .x86_64 => asm volatile (
+            \\ movq %%rbp, %%rdi
+            \\ xor %%ebp, %%ebp
+            \\ jmp %[mainLoop:P]
+            :
+            : [mainLoop] "X" (&mainLoop),
+        ),
+        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+    }
+}
+
+fn mainLoop(ev: *Evented, message: *const SwitchMessage) callconv(.c) noreturn {
+    message.handle(ev);
+    assert(ev.exit_semaphore.wait(.FOREVER) == 0);
+    Fiber.@"resume"(&ev.main_fiber);
+    unreachable; // switched to dead fiber
+}
+
+const SwitchMessage = struct {
+    contexts: Io.fiber.Switch,
+    pending_task: PendingTask,
+
+    const PendingTask = union(enum) {
+        nothing,
+        await: u31,
+        activate: c.dispatch.object_t,
+        @"resume": c.dispatch.object_t,
+        group_await: Group,
+        group_cancel: Group,
+        mutex_wait: *Mutex.Waiter,
+        futex_wait: *Futex.Waiter,
+        futex_wake: *Futex.Waker,
+        sleep: c.dispatch.time_t,
+        destroy,
+        exit,
+    };
+
+    fn handle(message: *const SwitchMessage, ev: *Evented) void {
+        const thread: *Thread = .current();
+        thread.current_context = message.contexts.new;
+        switch (message.pending_task) {
+            .nothing => {},
+            .await => |count| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                if (@atomicRmw(i32, &fiber.await_count, .Sub, count, .monotonic) > 0)
+                    ev.queue.async(fiber, &Fiber.@"resume");
+            },
+            .activate => |object| object.activate(),
+            .@"resume" => |object| object.@"resume"(),
+            .group_await => |group| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                if (group.await(ev, fiber)) ev.queue.async(fiber, &Fiber.@"resume");
+            },
+            .group_cancel => |group| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                if (group.cancel(ev, fiber)) ev.queue.async(fiber, &Fiber.@"resume");
+            },
+            .mutex_wait => |waiter| {
+                waiter.sleeper =
+                    .init(ev.queue, @alignCast(@fieldParentPtr("context", message.contexts.old)));
+                switch (waiter.sleeper.fiber.cancel_protection.check()) {
+                    .unblocked => {},
+                    .blocked => waiter.cancelable = .blocked,
+                }
+                waiter.mutex.queue.async(waiter, &Mutex.Waiter.add);
+            },
+            .futex_wait => |waiter| {
+                waiter.sleeper =
+                    .init(ev.queue, @alignCast(@fieldParentPtr("context", message.contexts.old)));
+                switch (waiter.sleeper.fiber.cancel_protection.check()) {
+                    .unblocked => {},
+                    .blocked => waiter.cancelable = .blocked,
+                }
+                waiter.futex.queue.async(waiter, &Futex.Waiter.add);
+            },
+            .futex_wake => |waker| {
+                waker.sleeper =
+                    .init(ev.queue, @alignCast(@fieldParentPtr("context", message.contexts.old)));
+                waker.futex.queue.async(waker, &Futex.Waker.remove);
+            },
+            .sleep => |when| {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                when.after(ev.queue, fiber, &Fiber.@"resume");
+            },
+            .destroy => {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                fiber.destroy(ev);
+            },
+            .exit => _ = ev.exit_semaphore.signal(),
+        }
+    }
+};
+
+inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage {
+    return @fieldParentPtr("contexts", Io.fiber.contextSwitch(&message.contexts));
+}
+
+const Cancelable = struct {
+    required_align: void align(2) = {},
+    queue: c.dispatch.queue_t,
+    cancel: c.dispatch.function_t,
+
+    const is_blocked: c.dispatch.function_t =
+        @ptrFromInt(@typeInfo(c.dispatch.function_t).pointer.alignment * 1);
+    const is_requested: c.dispatch.function_t =
+        @ptrFromInt(@typeInfo(c.dispatch.function_t).pointer.alignment * 2);
+
+    const blocked: Cancelable = .{ .queue = undefined, .cancel = is_blocked };
+
+    const AwaitError = error{CancelRequested};
+
+    fn await(cancelable: *Cancelable, fiber: *Fiber) AwaitError!void {
+        const function = cancelable.cancel;
+        assert(function != is_requested);
+        if (function == is_blocked) {
+            @branchHint(.unlikely);
+            return;
+        }
+        if (@cmpxchgStrong(
+            Fiber.CancelStatus,
+            &fiber.cancel_status,
+            .{ .requested = false, .awaiting = .nothing },
+            .{ .requested = false, .awaiting = .fromCancelable(cancelable) },
+            .release,
+            .monotonic,
+        )) |cancel_status| {
+            assert(cancel_status.requested and cancel_status.awaiting == .nothing);
+            cancelable.cancel = is_requested;
+            return error.CancelRequested;
+        }
+    }
+
+    fn canceled(cancelable: *Cancelable) void {
+        assert(cancelable.cancel != is_blocked);
+        assert(cancelable.cancel != is_requested);
+        cancelable.queue.async(cancelable, cancelable.cancel);
+    }
+
+    fn check(cancelable: *Cancelable, fiber: *Fiber) Io.Cancelable!void {
+        if (cancelable.cancel == is_requested) {
+            @branchHint(.unlikely);
+            fiber.cancel_protection.acknowledge();
+            return error.Canceled;
+        }
+    }
+};
+
+const Sleeper = struct {
+    queue: c.dispatch.queue_t,
+    fiber: *Fiber,
+
+    fn init(queue: c.dispatch.queue_t, fiber: *Fiber) Sleeper {
+        queue.as_object().retain();
+        return .{ .queue = queue, .fiber = fiber };
+    }
+
+    fn wake(context: ?*anyopaque) callconv(.c) void {
+        const sleeper: *Sleeper = @ptrCast(@alignCast(context));
+        const queue = sleeper.queue;
+        sleeper.queue = undefined;
+        queue.async(sleeper.fiber, &Fiber.@"resume");
+        queue.as_object().release();
+    }
+};
+
+const Mutex = struct {
+    /// including the locker
+    num_waiters: usize,
+    queue: c.dispatch.queue_t,
+    waiters: std.DoublyLinkedList,
+
+    const Waiter = struct {
+        sleeper: Sleeper = undefined,
+        cancelable: Cancelable,
+        mutex: *Mutex,
+        node: std.DoublyLinkedList.Node = .{},
+
+        fn add(context: ?*anyopaque) callconv(.c) void {
+            const waiter: *Waiter = @ptrCast(@alignCast(context));
+            waiter.tryAdd() catch |err| switch (err) {
+                error.CancelRequested => {
+                    waiter.wake();
+                    assert(@atomicRmw(usize, &waiter.mutex.num_waiters, .Sub, 1, .monotonic) >= 1);
+                },
+            };
+        }
+
+        fn tryAdd(waiter: *Waiter) Cancelable.AwaitError!void {
+            switch (@atomicLoad(usize, &waiter.mutex.num_waiters, .acquire)) {
+                0 => unreachable,
+                1 => return waiter.wake(), // already locked exclusively
+                else => try waiter.cancelable.await(waiter.sleeper.fiber),
+            }
+            waiter.mutex.waiters.append(&waiter.node);
+        }
+
+        fn canceled(context: ?*anyopaque) callconv(.c) void {
+            const cancelable: *Cancelable = @ptrCast(@alignCast(context));
+            cancelable.cancel = Cancelable.is_requested;
+            const waiter: *Waiter = @fieldParentPtr("cancelable", cancelable);
+            assert(@atomicRmw(
+                Fiber.CancelStatus,
+                &waiter.sleeper.fiber.cancel_status,
+                .Xchg,
+                .{ .requested = true, .awaiting = .nothing },
+                .monotonic,
+            ) == Fiber.CancelStatus{ .requested = true, .awaiting = .fromCancelable(cancelable) });
+            const mutex = waiter.mutex;
+            mutex.waiters.remove(&waiter.node);
+            waiter.wake();
+            assert(@atomicRmw(usize, &mutex.num_waiters, .Sub, 1, .monotonic) >= 1);
+        }
+
+        fn remove(context: ?*anyopaque) callconv(.c) void {
+            const mutex: *Mutex = @ptrCast(@alignCast(context));
+            var stop_node: ?*std.DoublyLinkedList.Node = null;
+            while (mutex.waiters.first != stop_node) {
+                @branchHint(.likely);
+                const waiter: *Waiter = @fieldParentPtr("node", mutex.waiters.popFirst().?);
+                if (waiter.cancelable.cancel != Cancelable.is_blocked) {
+                    @branchHint(.likely);
+                    const cancel_status = @atomicRmw(
+                        Fiber.CancelStatus,
+                        &waiter.sleeper.fiber.cancel_status,
+                        .And,
+                        .{ .requested = true, .awaiting = .nothing },
+                        .monotonic,
+                    );
+                    assert(cancel_status.awaiting.toCancelable() == &waiter.cancelable);
+                    if (cancel_status.requested) {
+                        @branchHint(.unlikely);
+                        // carefully place the hot potato out of the way
+                        mutex.waiters.append(&waiter.node);
+                        if (stop_node == null) stop_node = &waiter.node;
+                        continue;
+                    }
+                }
+                waiter.wake();
+                return;
+            }
+            // everyone is about to die, nobody will wake up ;-(
+        }
+
+        fn wake(waiter: *Waiter) void {
+            Sleeper.wake(&waiter.sleeper);
+        }
+    };
+
+    fn init(mutex: *Mutex, queue: c.dispatch.queue_t) error{SystemResources}!void {
+        mutex.* = .{
+            .num_waiters = 0,
+            .queue = c.dispatch.queue_create_with_target(
+                "org.ziglang.std.Io.Dispatch.Mutex",
+                .SERIAL(),
+                queue,
+            ) orelse return error.SystemResources,
+            .waiters = .{},
+        };
+    }
+
+    fn deinit(mutex: *Mutex) void {
+        assert(mutex.num_waiters == 0 and mutex.waiters.first == null and mutex.waiters.last == null);
+        mutex.queue.as_object().release();
+        mutex.* = undefined;
+    }
+
+    fn tryLock(mutex: *Mutex) bool {
+        if (@cmpxchgWeak(usize, &mutex.num_waiters, 0, 1, .acquire, .monotonic) == null) {
+            @branchHint(.likely);
+            return true;
+        }
+        return false;
+    }
+
+    fn lock(mutex: *Mutex, ev: *Evented) Io.Cancelable!void {
+        switch (@atomicRmw(usize, &mutex.num_waiters, .Add, 1, .acquire)) {
+            0 => {},
+            else => {
+                @branchHint(.unlikely);
+                var waiter: Waiter = .{
+                    .cancelable = .{ .queue = mutex.queue, .cancel = &Mutex.Waiter.canceled },
+                    .mutex = mutex,
+                };
+                ev.yield(.{ .mutex_wait = &waiter });
+                try waiter.cancelable.check(waiter.sleeper.fiber);
+            },
+        }
+    }
+
+    fn lockUncancelable(mutex: *Mutex, ev: *Evented) void {
+        switch (@atomicRmw(usize, &mutex.num_waiters, .Add, 1, .acquire)) {
+            0 => {},
+            else => {
+                @branchHint(.unlikely);
+                var waiter: Waiter = .{ .cancelable = .blocked, .mutex = mutex };
+                ev.yield(.{ .mutex_wait = &waiter });
+                waiter.cancelable.check(waiter.sleeper.fiber) catch |err| switch (err) {
+                    error.Canceled => unreachable, // blocked
+                };
+            },
+        }
+    }
+
+    fn unlock(mutex: *Mutex) void {
+        switch (@atomicRmw(usize, &mutex.num_waiters, .Sub, 1, .release)) {
+            0 => unreachable,
+            1 => {},
+            else => {
+                @branchHint(.unlikely);
+                mutex.queue.async(mutex, &Waiter.remove);
+            },
+        }
+    }
+};
+
+fn crashHandler(userdata: ?*anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const thread = &Thread.self;
+    if (thread.current_context == null) std.process.abort();
+    if (thread.current_context == &thread.main_context) std.process.abort();
+    const fiber = thread.currentFiber();
+    @atomicStore(
+        Fiber.CancelStatus,
+        &fiber.cancel_status,
+        .{ .requested = true, .awaiting = .nothing },
+        .monotonic,
+    );
+    fiber.cancel_protection = .{ .user = .blocked, .acknowledged = true };
+}
+
+const AsyncClosure = struct {
+    ev: *Evented,
+    fiber: *Fiber,
+    start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+    result_align: Alignment,
+
+    fn fromFiber(fiber: *Fiber) *AsyncClosure {
+        return @ptrFromInt(Fiber.max_context_align.max(.of(AsyncClosure)).backward(
+            @intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
+        ) - @sizeOf(AsyncClosure));
+    }
+
+    fn contextPointer(closure: *AsyncClosure) [*]align(Fiber.max_context_align.toByteUnits()) u8 {
+        return @alignCast(@as([*]u8, @ptrCast(closure)) + @sizeOf(AsyncClosure));
+    }
+
+    fn entry() callconv(.naked) void {
+        switch (builtin.cpu.arch) {
+            .aarch64 => asm volatile (
+                \\ mov x0, sp
+                \\ b %[call]
+                :
+                : [call] "X" (&call),
+            ),
+            .x86_64 => asm volatile (
+                \\ leaq 8(%%rsp), %%rdi
+                \\ jmp %[call:P]
+                :
+                : [call] "X" (&call),
+            ),
+            else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+        }
+    }
+
+    fn call(
+        closure: *AsyncClosure,
+        message: *const SwitchMessage,
+    ) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
+        message.handle(closure.ev);
+        const fiber = closure.fiber;
+        closure.start(closure.contextPointer(), fiber.resultBytes(closure.result_align));
+        if (@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel)) |awaiter|
+            if (@atomicRmw(i32, &awaiter.await_count, .Add, 1, .monotonic) == -1)
+                closure.ev.queue.async(awaiter, &Fiber.@"resume");
+        closure.ev.yield(.nothing);
+        unreachable; // switched to dead fiber
+    }
+};
+
+fn async(
+    userdata: ?*anyopaque,
+    result: []u8,
+    result_alignment: Alignment,
+    context: []const u8,
+    context_alignment: Alignment,
+    start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+) ?*std.Io.AnyFuture {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return concurrent(ev, result.len, result_alignment, context, context_alignment, start) catch {
+        start(context.ptr, result.ptr);
+        return null;
+    };
+}
+
+fn concurrent(
+    userdata: ?*anyopaque,
+    result_len: usize,
+    result_alignment: Alignment,
+    context: []const u8,
+    context_alignment: Alignment,
+    start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+) Io.ConcurrentError!*std.Io.AnyFuture {
+    assert(result_alignment.compare(.lte, Fiber.max_result_align)); // TODO
+    assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
+    assert(result_len <= Fiber.max_result_size); // TODO
+    assert(context.len <= Fiber.max_context_size); // TODO
+
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const fiber = Fiber.create(ev) catch |err| switch (err) {
+        error.OutOfMemory => return error.ConcurrencyUnavailable,
+    };
+
+    const closure: *AsyncClosure = .fromFiber(fiber);
+    fiber.* = .{
+        .required_align = {},
+        .evented = ev,
+        .context = switch (builtin.cpu.arch) {
+            .aarch64 => .{
+                .sp = @intFromPtr(closure),
+                .fp = 0,
+                .pc = @intFromPtr(&AsyncClosure.entry),
+            },
+            .x86_64 => .{
+                .rsp = @intFromPtr(closure) - 8,
+                .rbp = 0,
+                .rip = @intFromPtr(&AsyncClosure.entry),
+            },
+            else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+        },
+        .await_count = 0,
+        .link = .{ .awaiter = null },
+        .status = .{ .queue_next = null },
+        .cancel_status = .unrequested,
+        .cancel_protection = .unblocked,
+    };
+    closure.* = .{
+        .ev = ev,
+        .fiber = fiber,
+        .start = start,
+        .result_align = result_alignment,
+    };
+    @memcpy(closure.contextPointer(), context);
+
+    ev.queue.async(fiber, &Fiber.@"resume");
+    return @ptrCast(fiber);
+}
+
+fn await(
+    userdata: ?*anyopaque,
+    future: *std.Io.AnyFuture,
+    result: []u8,
+    result_alignment: Alignment,
+) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const fiber = Thread.current().currentFiber();
+    const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+    if (@atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, fiber, .acq_rel)) |awaiter| {
+        assert(awaiter == Fiber.finished);
+    } else while (true) {
+        ev.yield(.{ .await = 1 });
+        const awaiter = @atomicLoad(?*Fiber, &future_fiber.link.awaiter, .acquire);
+        if (awaiter == Fiber.finished) break;
+        assert(awaiter == fiber); // spurious wakeup
+    }
+    @memcpy(result, future_fiber.resultBytes(result_alignment));
+    future_fiber.destroy(ev);
+}
+
+fn cancel(
+    userdata: ?*anyopaque,
+    future: *std.Io.AnyFuture,
+    result: []u8,
+    result_alignment: Alignment,
+) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+    future_fiber.requestCancel(ev);
+    await(ev, future, result, result_alignment);
+}
+
+const Group = struct {
+    ptr: *Io.Group,
+
+    const List = packed struct(usize) {
+        cancel_requested: bool,
+        awaiter_delayed: bool,
+        fibers: Fiber.PackedPtr,
+    };
+    fn listPtr(group: Group) *List {
+        return @ptrCast(&group.ptr.token);
+    }
+
+    const Mutex = packed struct(u32) {
+        locked: bool,
+        contended: bool,
+        shared2: u30,
+    };
+    fn mutexPtr(group: Group) *Group.Mutex {
+        return switch (comptime builtin.cpu.arch.endian()) {
+            .little => @ptrCast(&group.ptr.state),
+            .big => @ptrCast(@alignCast(
+                @as([*]u8, @ptrCast(&group.ptr.state)) + @sizeOf(usize) - @sizeOf(u32),
+            )),
+        };
+    }
+
+    const Awaiter = packed struct(usize) {
+        locked: bool,
+        contended: bool,
+        awaiter: Fiber.PackedPtr,
+    };
+    fn awaiterPtr(group: Group) *Awaiter {
+        return @ptrCast(&group.ptr.state);
+    }
+
+    fn lock(group: Group, ev: *Evented) void {
+        const mutex = group.mutexPtr();
+        {
+            const old_state = @atomicRmw(
+                Group.Mutex,
+                mutex,
+                .Or,
+                .{ .locked = true, .contended = false, .shared2 = 0 },
+                .acquire,
+            );
+            if (!old_state.locked) {
+                @branchHint(.likely);
+                return;
+            }
+            if (old_state.contended) {
+                futexWaitUncancelable(ev, @ptrCast(mutex), @bitCast(old_state));
+            }
+        }
+        while (true) {
+            var old_state = @atomicRmw(
+                Group.Mutex,
+                mutex,
+                .Or,
+                .{ .locked = true, .contended = true, .shared2 = 0 },
+                .acquire,
+            );
+            if (!old_state.locked) {
+                @branchHint(.likely);
+                return;
+            }
+            old_state.contended = true;
+            futexWaitUncancelable(ev, @ptrCast(mutex), @bitCast(old_state));
+        }
+    }
+
+    fn unlock(group: Group, ev: *Evented) void {
+        const mutex = group.mutexPtr();
+        const old_state = @atomicRmw(
+            Group.Mutex,
+            mutex,
+            .And,
+            .{ .locked = false, .contended = false, .shared2 = std.math.maxInt(u30) },
+            .release,
+        );
+        assert(old_state.locked);
+        if (old_state.contended) futexWake(ev, @ptrCast(mutex), 1);
+    }
+
+    fn addFiber(group: Group, ev: *Evented, fiber: *Fiber) void {
+        group.lock(ev);
+        defer group.unlock(ev);
+        const list_ptr = group.listPtr();
+        const list = @atomicLoad(List, list_ptr, .monotonic);
+        if (list.cancel_requested) fiber.cancel_status = .{ .requested = true, .awaiting = .nothing };
+        const old_head = list.fibers.unpack();
+        if (old_head) |head| head.link.group.prev = fiber;
+        fiber.link.group.next = old_head;
+        @atomicStore(List, list_ptr, .{
+            .cancel_requested = list.cancel_requested,
+            .awaiter_delayed = list.awaiter_delayed,
+            .fibers = .pack(fiber),
+        }, .monotonic);
+    }
+
+    fn removeFiber(group: Group, ev: *Evented, fiber: *Fiber) ?*Fiber {
+        group.lock(ev);
+        defer group.unlock(ev);
+        const list_ptr = group.listPtr();
+        const list = @atomicLoad(List, list_ptr, .monotonic);
+        if (fiber.link.group.next) |next| next.link.group.prev = fiber.link.group.prev;
+        if (fiber.link.group.prev) |prev| {
+            prev.link.group.next = fiber.link.group.next;
+        } else if (fiber.link.group.next) |new_head| {
+            @atomicStore(List, list_ptr, .{
+                .cancel_requested = list.cancel_requested,
+                .awaiter_delayed = list.awaiter_delayed,
+                .fibers = .pack(new_head),
+            }, .monotonic);
+        } else if (@atomicLoad(Awaiter, group.awaiterPtr(), .monotonic).awaiter.unpack()) |awaiter| {
+            if (!awaiter.cancel_status.changeAwaiting(.group, .nothing) or list.cancel_requested) {
+                @atomicStore(List, list_ptr, .{
+                    .cancel_requested = false,
+                    .awaiter_delayed = false,
+                    .fibers = .null,
+                }, .release);
+                assert(awaiter.status.awaiting_group.ptr == group.ptr);
+                awaiter.status = .{ .queue_next = null };
+                return awaiter;
+            }
+            // Race with `Fiber.requestCancel`
+            @atomicStore(List, list_ptr, .{
+                .cancel_requested = false,
+                .awaiter_delayed = true,
+                .fibers = .null,
+            }, .monotonic);
+        } else @atomicStore(List, list_ptr, .{
+            .cancel_requested = false,
+            .awaiter_delayed = false,
+            .fibers = .null,
+        }, .release);
+        return null;
+    }
+
+    fn await(group: Group, ev: *Evented, awaiter: *Fiber) bool {
+        group.lock(ev);
+        defer group.unlock(ev);
+        if (@atomicLoad(List, group.listPtr(), .monotonic).fibers.unpack()) |_| {
+            if (group.registerAwaiter(awaiter) and awaiter.cancel_protection.check() == .unblocked) {
+                // The awaiter already had an unacknowledged cancelation request before
+                // attempting to await a group, so propagate the cancelation to the group.
+                assert(!group.cancelLocked(ev, null));
+            }
+            return false;
+        }
+        return true;
+    }
+
+    fn cancel(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool {
+        group.lock(ev);
+        defer group.unlock(ev);
+        return group.cancelLocked(ev, maybe_awaiter);
+    }
+
+    /// Assumes the mutex is held.
+    fn cancelLocked(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool {
+        const list_ptr = group.listPtr();
+        const list = @atomicRmw(
+            List,
+            list_ptr,
+            .Add,
+            .{ .cancel_requested = true, .awaiter_delayed = false, .fibers = .null },
+            .monotonic,
+        );
+        assert(!list.cancel_requested);
+        if (list.fibers.unpack()) |head| {
+            var maybe_fiber: ?*Fiber = head;
+            while (maybe_fiber) |fiber| {
+                fiber.requestCancel(ev);
+                maybe_fiber = fiber.link.group.next;
+            }
+            if (maybe_awaiter) |awaiter| _ = group.registerAwaiter(awaiter);
+            return false;
+        }
+        @atomicStore(
+            List,
+            list_ptr,
+            .{ .cancel_requested = false, .awaiter_delayed = false, .fibers = .null },
+            .release,
+        );
+        return if (maybe_awaiter) |_| true else list.awaiter_delayed;
+    }
+
+    /// Assumes the mutex is held.
+    fn registerAwaiter(group: Group, awaiter: *Fiber) bool {
+        assert(awaiter.status.queue_next == null);
+        awaiter.status = .{ .awaiting_group = group };
+        assert(@atomicRmw(
+            Awaiter,
+            group.awaiterPtr(),
+            .Add,
+            .{ .locked = false, .contended = false, .awaiter = .pack(awaiter) },
+            .monotonic,
+        ).awaiter == .null);
+        return awaiter.cancel_status.changeAwaiting(.nothing, .group);
+    }
+
+    const AsyncClosure = struct {
+        ev: *Evented,
+        group: Group,
+        fiber: *Fiber,
+        start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+
+        fn fromFiber(fiber: *Fiber) *Group.AsyncClosure {
+            return @ptrFromInt(Fiber.max_context_align.max(.of(Group.AsyncClosure)).backward(
+                @intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
+            ) - @sizeOf(Group.AsyncClosure));
+        }
+
+        fn contextPointer(
+            closure: *Group.AsyncClosure,
+        ) [*]align(Fiber.max_context_align.toByteUnits()) u8 {
+            return @alignCast(@as([*]u8, @ptrCast(closure)) + @sizeOf(Group.AsyncClosure));
+        }
+
+        fn entry() callconv(.naked) void {
+            switch (builtin.cpu.arch) {
+                .aarch64 => asm volatile (
+                    \\ mov x0, sp
+                    \\ b %[call]
+                    :
+                    : [call] "X" (&call),
+                ),
+                .x86_64 => asm volatile (
+                    \\ leaq 8(%%rsp), %%rdi
+                    \\ jmp %[call:P]
+                    :
+                    : [call] "X" (&call),
+                ),
+                else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+            }
+        }
+
+        fn call(
+            closure: *Group.AsyncClosure,
+            message: *const SwitchMessage,
+        ) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn {
+            message.handle(closure.ev);
+            assert(closure.fiber.status.queue_next == null);
+            const result = closure.start(closure.contextPointer());
+            const ev = closure.ev;
+            const group = closure.group;
+            const fiber = closure.fiber;
+            const cancel_acknowledged = fiber.cancel_protection.acknowledged;
+            if (result) {
+                assert(!cancel_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
+            } else |err| switch (err) {
+                error.Canceled => assert(cancel_acknowledged), // group task returned `error.Canceled` but was never canceled
+            }
+            if (group.removeFiber(ev, fiber)) |awaiter| ev.queue.async(awaiter, &Fiber.@"resume");
+            ev.yield(.destroy);
+            unreachable; // switched to dead fiber
+        }
+    };
+};
+
+fn groupAsync(
+    userdata: ?*anyopaque,
+    type_erased: *Io.Group,
+    context: []const u8,
+    context_alignment: Alignment,
+    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return groupConcurrent(ev, type_erased, context, context_alignment, start) catch {
+        const fiber = Thread.current().currentFiber();
+        const pre_acknowledged = fiber.cancel_protection.acknowledged;
+        const result = start(context.ptr);
+        const post_acknowledged = fiber.cancel_protection.acknowledged;
+        if (result) {
+            if (pre_acknowledged) {
+                assert(post_acknowledged); // group task called `recancel` but was not canceled
+            } else {
+                assert(!post_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
+            }
+        } else |err| switch (err) {
+            // Don't swallow the cancelation: make it visible to the `Group.async` caller.
+            error.Canceled => {
+                assert(!pre_acknowledged); // group task called `recancel` but was not canceled
+                assert(post_acknowledged); // group task returned `error.Canceled` but was never canceled
+                fiber.cancel_protection.recancel();
+            },
+        }
+    };
+}
+
+fn groupConcurrent(
+    userdata: ?*anyopaque,
+    type_erased: *Io.Group,
+    context: []const u8,
+    context_alignment: Alignment,
+    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+) Io.ConcurrentError!void {
+    assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
+    assert(context.len <= Fiber.max_context_size); // TODO
+
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const group: Group = .{ .ptr = type_erased };
+    const fiber = Fiber.create(ev) catch |err| switch (err) {
+        error.OutOfMemory => return error.ConcurrencyUnavailable,
+    };
+
+    const closure: *Group.AsyncClosure = .fromFiber(fiber);
+    fiber.* = .{
+        .required_align = {},
+        .evented = ev,
+        .context = switch (builtin.cpu.arch) {
+            .aarch64 => .{
+                .sp = @intFromPtr(closure),
+                .fp = 0,
+                .pc = @intFromPtr(&Group.AsyncClosure.entry),
+            },
+            .x86_64 => .{
+                .rsp = @intFromPtr(closure) - 8,
+                .rbp = 0,
+                .rip = @intFromPtr(&Group.AsyncClosure.entry),
+            },
+            else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+        },
+        .await_count = 0,
+        .link = .{ .group = .{ .prev = null, .next = null } },
+        .status = .{ .queue_next = null },
+        .cancel_status = .unrequested,
+        .cancel_protection = .unblocked,
+    };
+    closure.* = .{
+        .ev = ev,
+        .group = group,
+        .fiber = fiber,
+        .start = start,
+    };
+    @memcpy(closure.contextPointer(), context);
+    group.addFiber(ev, fiber);
+    ev.queue.async(fiber, &Fiber.@"resume");
+}
+
+fn groupAwait(
+    userdata: ?*anyopaque,
+    type_erased: *Io.Group,
+    initial_token: *anyopaque,
+) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = initial_token;
+    ev.yield(.{ .group_await = .{ .ptr = type_erased } });
+}
+
+fn groupCancel(userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = initial_token;
+    ev.yield(.{ .group_cancel = .{ .ptr = type_erased } });
+}
+
+fn recancel(userdata: ?*anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    Thread.current().currentFiber().cancel_protection.recancel();
+}
+
+fn swapCancelProtection(userdata: ?*anyopaque, new: Io.CancelProtection) Io.CancelProtection {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const cancel_protection = &Thread.current().currentFiber().cancel_protection;
+    defer cancel_protection.user = new;
+    return cancel_protection.user;
+}
+
+fn checkCancel(userdata: ?*anyopaque) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const fiber = Thread.current().currentFiber();
+    switch (fiber.cancel_protection.check()) {
+        .unblocked => {
+            const cancel_status = @atomicLoad(Fiber.CancelStatus, &fiber.cancel_status, .monotonic);
+            assert(cancel_status.awaiting == .nothing);
+            if (cancel_status.requested) {
+                @branchHint(.unlikely);
+                fiber.cancel_protection.acknowledge();
+                return error.Canceled;
+            }
+        },
+        .blocked => {},
+    }
+}
+
+const Futex = struct {
+    num_waiters: usize,
+    queue: c.dispatch.queue_t,
+    waiters: std.DoublyLinkedList,
+
+    const Waiter = struct {
+        sleeper: Sleeper = undefined,
+        cancelable: Cancelable,
+        futex: *Futex,
+        node: std.DoublyLinkedList.Node = .{},
+        ptr: *const u32,
+        expected: u32,
+        timeout: c.dispatch.time_t = .FOREVER,
+        leeway: u64,
+        timer: ?c.dispatch.source_t = null,
+
+        const already_signaled: c.dispatch.source_t = @ptrFromInt(1);
+
+        fn add(context: ?*anyopaque) callconv(.c) void {
+            const waiter: *Waiter = @ptrCast(@alignCast(context));
+            const futex = waiter.futex;
+            _ = @atomicRmw(usize, &futex.num_waiters, .Add, 1, .acquire);
+            waiter.tryAdd() catch |err| switch (err) {
+                error.CancelRequested => {
+                    wake(waiter);
+                    assert(@atomicRmw(usize, &futex.num_waiters, .Sub, 1, .monotonic) >= 1);
+                },
+            };
+        }
+
+        fn tryAdd(waiter: *Waiter) Cancelable.AwaitError!void {
+            if (@atomicLoad(u32, waiter.ptr, .monotonic) != waiter.expected)
+                return error.CancelRequested;
+            try waiter.cancelable.await(waiter.sleeper.fiber);
+            const futex = waiter.futex;
+            switch (waiter.timeout) {
+                .FOREVER => {},
+                else => |timeout| {
+                    const timer = c.dispatch.source_create(.TIMER, 0, .none, futex.queue) orelse {
+                        log.warn("unable to create timer for futex timeout", .{});
+                        return error.CancelRequested;
+                    };
+                    timer.as_object().set_context(waiter);
+                    timer.set_event_handler(&timedOut);
+                    timer.set_cancel_handler(&wake);
+                    timer.set_timer(timeout, c.dispatch.TIME_FOREVER, waiter.leeway);
+                    timer.as_object().activate();
+                    waiter.timer = timer;
+                },
+            }
+            futex.waiters.append(&waiter.node);
+        }
+
+        fn canceled(context: ?*anyopaque) callconv(.c) void {
+            const cancelable: *Cancelable = @ptrCast(@alignCast(context));
+            cancelable.cancel = Cancelable.is_requested;
+            const waiter: *Waiter = @fieldParentPtr("cancelable", cancelable);
+            assert(@atomicRmw(
+                Fiber.CancelStatus,
+                &waiter.sleeper.fiber.cancel_status,
+                .Xchg,
+                .{ .requested = true, .awaiting = .nothing },
+                .monotonic,
+            ) == Fiber.CancelStatus{ .requested = true, .awaiting = .fromCancelable(cancelable) });
+            const futex = waiter.futex;
+            waiter.removeUncancelable();
+            assert(@atomicRmw(usize, &futex.num_waiters, .Sub, 1, .monotonic) >= 1);
+        }
+
+        fn timedOut(context: ?*anyopaque) callconv(.c) void {
+            const waiter: *Waiter = @ptrCast(@alignCast(context));
+            const futex = waiter.futex;
+            waiter.remove() catch |err| switch (err) {
+                error.CancelRequested => return,
+            };
+            assert(@atomicRmw(usize, &futex.num_waiters, .Sub, 1, .monotonic) >= 1);
+        }
+
+        fn remove(waiter: *Waiter) Cancelable.AwaitError!void {
+            if (waiter.cancelable.cancel != Cancelable.is_blocked) {
+                @branchHint(.likely);
+                const cancel_status = @atomicRmw(
+                    Fiber.CancelStatus,
+                    &waiter.sleeper.fiber.cancel_status,
+                    .And,
+                    .{ .requested = true, .awaiting = .nothing },
+                    .monotonic,
+                );
+                assert(cancel_status.awaiting.toCancelable() == &waiter.cancelable);
+                if (cancel_status.requested) return error.CancelRequested;
+            }
+            waiter.removeUncancelable();
+        }
+
+        fn removeUncancelable(waiter: *Waiter) void {
+            waiter.futex.waiters.remove(&waiter.node);
+            if (waiter.timer) |timer| timer.cancel() else wake(waiter);
+        }
+
+        fn wake(context: ?*anyopaque) callconv(.c) void {
+            const waiter: *Waiter = @ptrCast(@alignCast(context));
+            if (waiter.timer) |timer| timer.as_object().release();
+            Sleeper.wake(&waiter.sleeper);
+        }
+    };
+
+    const Waker = struct {
+        sleeper: Sleeper = undefined,
+        futex: *Futex,
+        ptr: *const u32,
+        max_waiters: u32,
+
+        fn remove(context: ?*anyopaque) callconv(.c) void {
+            const waker: *Waker = @ptrCast(@alignCast(context));
+            const futex = waker.futex;
+            const ptr = waker.ptr;
+            const max_waiters = waker.max_waiters;
+
+            var num_removed: usize = 0;
+            var next_node = futex.waiters.first;
+            while (num_removed < max_waiters) {
+                const waiter: *Waiter = @fieldParentPtr("node", next_node orelse break);
+                next_node = waiter.node.next;
+                if (waiter.ptr != ptr) {
+                    @branchHint(.unlikely);
+                    continue;
+                }
+                waiter.remove() catch |err| switch (err) {
+                    error.CancelRequested => continue,
+                };
+                num_removed += 1;
+            }
+            assert(@atomicRmw(usize, &futex.num_waiters, .Sub, num_removed, .monotonic) >= num_removed);
+
+            var sleeper = waker.sleeper;
+            waker.* = undefined;
+            Sleeper.wake(&sleeper);
+        }
+    };
+
+    fn init(futex: *Futex, queue: c.dispatch.queue_t) error{SystemResources}!void {
+        futex.* = .{
+            .num_waiters = 0,
+            .queue = c.dispatch.queue_create_with_target(
+                "org.ziglang.std.Io.Dispatch.Futex",
+                .SERIAL(),
+                queue,
+            ) orelse return error.SystemResources,
+            .waiters = .{},
+        };
+    }
+
+    fn deinit(futex: *Futex) void {
+        assert(futex.num_waiters == 0 and futex.waiters.first == null and futex.waiters.last == null);
+        futex.queue.as_object().release();
+        futex.* = undefined;
+    }
+};
+
+fn futexForAddress(ev: *Evented, address: usize) *Futex {
+    // Here we use Fibonacci hashing: the golden ratio can be used to evenly redistribute input
+    // values across a range, giving a poor, but extremely quick to compute, hash.
+
+    // This literal is the rounded value of '2^64 / phi' (where 'phi' is the golden ratio). The
+    // shift then converts it to '2^b / phi', where 'b' is the pointer bit width.
+    const fibonacci_multiplier = 0x9E3779B97F4A7C15 >> (64 - @bitSizeOf(usize));
+    const hashed = address *% fibonacci_multiplier;
+    comptime assert(std.math.isPowerOfTwo(ev.futexes.len));
+    // The high bits of `hashed` have better entropy than the low bits.
+    return &ev.futexes[hashed >> @clz(ev.futexes.len - 1)];
+}
+
+fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) Io.Cancelable!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const fiber = Thread.current().currentFiber();
+    var await_count: u31, var result = for (futures, 0..) |future, future_index| {
+        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+        if (@atomicRmw(
+            ?*Fiber,
+            &future_fiber.link.awaiter,
+            .Xchg,
+            fiber,
+            .acq_rel,
+        )) |awaiter| {
+            assert(awaiter == Fiber.finished);
+            break .{ @intCast(future_index), future_index };
+        }
+    } else result: {
+        const await_count: u31 = @intCast(futures.len);
+        ev.yield(.{ .await = 1 });
+        break :result .{ await_count - 1, futures.len };
+    };
+    for (futures[0..result], 0..) |future, future_index| {
+        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
+        const awaiter = @atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, null, .monotonic);
+        if (awaiter == Fiber.finished) {
+            @atomicStore(?*Fiber, &future_fiber.link.awaiter, Fiber.finished, .monotonic);
+            result = @min(future_index, result);
+        } else {
+            assert(awaiter == fiber);
+            await_count -= 1;
+        }
+    }
+    // Equivalent to `ev.yield(null, .{ .await = await_count });`,
+    // but avoiding a context switch in the common case.
+    switch (std.math.order(
+        @atomicRmw(i32, &fiber.await_count, .Sub, await_count, .monotonic),
+        await_count,
+    )) {
+        .lt => ev.yield(.{ .await = 0 }),
+        .eq => {},
+        .gt => unreachable,
+    }
+    return result;
+}
+
+fn futexWait(
+    userdata: ?*anyopaque,
+    ptr: *const u32,
+    expected: u32,
+    timeout: Io.Timeout,
+) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const futex = ev.futexForAddress(@intFromPtr(ptr));
+    var waiter: Futex.Waiter = .{
+        .cancelable = .{ .queue = futex.queue, .cancel = &Futex.Waiter.canceled },
+        .futex = futex,
+        .ptr = ptr,
+        .expected = expected,
+        .timeout = ev.timeFromTimeout(timeout),
+        .leeway = ev.leeway,
+    };
+    ev.yield(.{ .futex_wait = &waiter });
+    try waiter.cancelable.check(waiter.sleeper.fiber);
+}
+
+fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const futex = ev.futexForAddress(@intFromPtr(ptr));
+    var waiter: Futex.Waiter = .{
+        .cancelable = .blocked,
+        .futex = futex,
+        .ptr = ptr,
+        .expected = expected,
+        .leeway = ev.leeway,
+    };
+    ev.yield(.{ .futex_wait = &waiter });
+    waiter.cancelable.check(waiter.sleeper.fiber) catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
+    };
+}
+
+fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (max_waiters == 0) return;
+    const futex = ev.futexForAddress(@intFromPtr(ptr));
+    switch (@atomicRmw(usize, &futex.num_waiters, .Add, 0, .release)) {
+        0 => return,
+        else => {
+            @branchHint(.unlikely);
+            var waker: Futex.Waker = .{ .futex = futex, .ptr = ptr, .max_waiters = max_waiters };
+            ev.yield(.{ .futex_wake = &waker });
+        },
+    }
+}
+
+fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    switch (operation) {
+        .file_read_streaming => |o| return .{
+            .file_read_streaming = ev.fileReadStreaming(o.file, o.data) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                else => |e| e,
+            },
+        },
+        .file_write_streaming => |o| return .{
+            .file_write_streaming = ev.fileWriteStreaming(
+                o.file,
+                o.header,
+                o.data,
+                o.splat,
+            ) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                else => |e| e,
+            },
+        },
+        .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
+    }
+}
+
+fn fileReadStreaming(ev: *Evented, file: File, data: []const []u8) File.ReadStreamingError!usize {
+    if (file.flags.nonblocking) nonblocking: {
+        return fileReadStreamingLimit(file.handle, data, .unlimited) catch |err| switch (err) {
+            error.WouldBlock => break :nonblocking,
+            else => |e| return e,
+        };
+    }
+    const source = c.dispatch.source_create(
+        .READ,
+        @bitCast(@as(isize, file.handle)),
+        .none,
+        ev.queue,
+    ) orelse return error.SystemResources;
+    source.as_object().set_context(Thread.current().currentFiber());
+    source.set_event_handler(&Fiber.@"resume");
+    ev.yield(.{ .activate = source.as_object() });
+    const limit = source.get_data();
+    source.as_object().release();
+    while (true) return fileReadStreamingLimit(
+        file.handle,
+        data,
+        .limited(limit),
+    ) catch |err| switch (err) {
+        error.WouldBlock => {
+            ev.yield(.nothing);
+            continue;
+        },
+        else => |e| return e,
+    };
+}
+fn fileReadStreamingLimit(
+    handle: File.Handle,
+    data: []const []u8,
+    limit: Io.Limit,
+) File.ReadStreamingError!usize {
+    var iovecs: [max_iovecs_len]iovec = undefined;
+    var iovlen: iovlen_t = 0;
+    // .nothing can mean that the write side has been closed,
+    // in which case the buffer still needs to be drained
+    var remaining = if (limit == .nothing) .unlimited else limit;
+    for (data) |buf| addBuf(false, &iovecs, &iovlen, &remaining, buf);
+    if (iovlen == 0) return 0;
+    while (true) {
+        const rc = c.readv(handle, &iovecs, iovlen);
+        switch (c.errno(rc)) {
+            .SUCCESS => return if (rc == 0) error.EndOfStream else @intCast(rc),
+            .INTR => continue,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .AGAIN => return error.WouldBlock,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed
+            .IO => return error.InputOutput,
+            .ISDIR => return error.IsDir,
+            .NOBUFS => return error.SystemResources,
+            .NOMEM => return error.SystemResources,
+            .NOTCONN => return error.SocketUnconnected,
+            .CONNRESET => return error.ConnectionResetByPeer,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fileWriteStreaming(
+    ev: *Evented,
+    file: File,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+) File.Writer.Error!usize {
+    if (file.flags.nonblocking) nonblocking: {
+        return fileWriteStreamingLimit(
+            file.handle,
+            header,
+            data,
+            splat,
+            .unlimited,
+        ) catch |err| switch (err) {
+            error.WouldBlock => break :nonblocking,
+            else => |e| return e,
+        };
+    }
+    const source = c.dispatch.source_create(
+        .WRITE,
+        @bitCast(@as(isize, file.handle)),
+        .none,
+        ev.queue,
+    ) orelse return error.SystemResources;
+    source.as_object().set_context(Thread.current().currentFiber());
+    source.set_event_handler(&Fiber.@"resume");
+    ev.yield(.{ .activate = source.as_object() });
+    const limit = source.get_data();
+    source.as_object().release();
+    while (true) return fileWriteStreamingLimit(
+        file.handle,
+        header,
+        data,
+        splat,
+        .limited(limit),
+    ) catch |err| switch (err) {
+        error.WouldBlock => {
+            ev.yield(.nothing);
+            continue;
+        },
+        else => |e| return e,
+    };
+}
+fn fileWriteStreamingLimit(
+    handle: File.Handle,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+    limit: Io.Limit,
+) File.Writer.Error!usize {
+    if (limit == .nothing) return 0;
+    var iovecs: [max_iovecs_len]iovec_const = undefined;
+    var iovlen: iovlen_t = 0;
+    var remaining = limit;
+    addBuf(true, &iovecs, &iovlen, &remaining, header);
+    for (data[0 .. data.len - 1]) |bytes| addBuf(true, &iovecs, &iovlen, &remaining, bytes);
+    const pattern = data[data.len - 1];
+    var backup_buffer: [splat_buffer_size]u8 = undefined;
+    if (iovecs.len - iovlen != 0 and remaining != .nothing) switch (splat) {
+        0 => {},
+        1 => addBuf(true, &iovecs, &iovlen, &remaining, pattern),
+        else => switch (pattern.len) {
+            0 => {},
+            1 => {
+                const splat_buffer = &backup_buffer;
+                const memset_len = @min(splat_buffer.len, splat);
+                const buf = splat_buffer[0..memset_len];
+                @memset(buf, pattern[0]);
+                addBuf(true, &iovecs, &iovlen, &remaining, buf);
+                var remaining_splat = splat - buf.len;
+                while (remaining_splat > splat_buffer.len and iovecs.len - iovlen != 0 and remaining != .nothing) {
+                    assert(buf.len == splat_buffer.len);
+                    addBuf(true, &iovecs, &iovlen, &remaining, splat_buffer);
+                    remaining_splat -= splat_buffer.len;
+                }
+                addBuf(true, &iovecs, &iovlen, &remaining, splat_buffer[0..@min(remaining_splat, splat_buffer.len)]);
+            },
+            else => for (0..@min(splat, iovecs.len - iovlen)) |_| {
+                if (remaining == .nothing) break;
+                addBuf(true, &iovecs, &iovlen, &remaining, pattern);
+            },
+        },
+    };
+    if (iovlen == 0) return 0;
+    while (true) {
+        const rc = c.writev(handle, &iovecs, iovlen);
+        switch (c.errno(rc)) {
+            .SUCCESS => return @intCast(rc),
+            .INTR => continue,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .AGAIN => return error.WouldBlock,
+            .BADF => return error.NotOpenForWriting, // Can be a race condition.
+            .DESTADDRREQ => |err| return errnoBug(err), // `connect` was never called.
+            .DQUOT => return error.DiskQuota,
+            .FBIG => return error.FileTooBig,
+            .IO => return error.InputOutput,
+            .NOSPC => return error.NoSpaceLeft,
+            .PERM => return error.PermissionDenied,
+            .PIPE => return error.BrokenPipe,
+            .CONNRESET => |err| return errnoBug(err), // Not a socket handle.
+            .BUSY => return error.DeviceBusy,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!i32 {
+    while (true) {
+        const rc = c.ioctl(o.file.handle, @bitCast(o.code), @intFromPtr(o.arg));
+        switch (c.errno(rc)) {
+            .SUCCESS => return rc,
+            .INTR => {},
+            else => |err| return -@as(i32, @intFromEnum(err)),
+        }
+    }
+}
+
+const BatchWaiter = struct {
+    sleeper: Sleeper,
+    queue: c.dispatch.queue_t,
+    timer: ?c.dispatch.source_t = null,
+
+    const already_signaled: c.dispatch.source_t = @ptrFromInt(1);
+
+    fn signal(context: ?*anyopaque) callconv(.c) void {
+        const waiter: *BatchWaiter = @ptrCast(@alignCast(context));
+        if (waiter.timer) |timer| {
+            if (timer != already_signaled) timer.cancel();
+        } else {
+            waiter.timer = already_signaled;
+            waiter.queue.async(waiter, &@"suspend");
+        }
+    }
+
+    fn @"suspend"(context: ?*anyopaque) callconv(.c) void {
+        const waiter: *BatchWaiter = @ptrCast(@alignCast(context));
+        if (waiter.timer) |timer| if (timer != already_signaled) timer.as_object().release();
+        waiter.queue.as_object().@"suspend"();
+        waiter.wake();
+    }
+
+    fn wake(waiter: *BatchWaiter) void {
+        var sleeper = waiter.sleeper;
+        waiter.* = undefined;
+        Sleeper.wake(&sleeper);
+    }
+};
+
+fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const queue = ev.batchDrainSubmitted(batch, false) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
+        error.Canceled => |e| return e,
+    } orelse return;
+    if (batch.pending.head == .none) return;
+    var waiter: BatchWaiter = .{
+        .sleeper = .init(ev.queue, Thread.current().currentFiber()),
+        .queue = queue,
+    };
+    if (batch.completed.head != .none) BatchWaiter.signal(&waiter);
+    queue.as_object().set_context(&waiter);
+    ev.yield(.{ .@"resume" = queue.as_object() });
+}
+
+fn batchAwaitConcurrent(
+    userdata: ?*anyopaque,
+    batch: *Io.Batch,
+    timeout: Io.Timeout,
+) Io.Batch.AwaitConcurrentError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const queue = try ev.batchDrainSubmitted(batch, true) orelse return;
+    if (batch.pending.head == .none) return;
+    var waiter: BatchWaiter = .{
+        .sleeper = .init(ev.queue, Thread.current().currentFiber()),
+        .queue = queue,
+    };
+    if (batch.completed.head == .none) switch (timeout) {
+        .none => {},
+        else => {
+            const timer = c.dispatch.source_create(.TIMER, 0, .none, queue) orelse
+                return error.ConcurrencyUnavailable;
+            assert(timer != BatchWaiter.already_signaled);
+            timer.as_object().set_context(&waiter);
+            timer.set_event_handler(&BatchWaiter.signal);
+            timer.set_cancel_handler(&BatchWaiter.@"suspend");
+            timer.set_timer(ev.timeFromTimeout(timeout), c.dispatch.TIME_FOREVER, ev.leeway);
+            timer.as_object().activate();
+            waiter.timer = timer;
+        },
+    } else BatchWaiter.signal(&waiter);
+    queue.as_object().set_context(&waiter);
+    ev.yield(.{ .@"resume" = queue.as_object() });
+}
+
+fn batchCancel(userdata: ?*anyopaque, batch: *Io.Batch) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var index = batch.pending.head;
+    while (index != .none) {
+        const storage = &batch.storage[index.toIndex()];
+        const pending = &storage.pending;
+        const operation_userdata: *BatchOperationUserdata = .fromErased(&pending.userdata);
+        assert(operation_userdata.batch == batch);
+        operation_userdata.source.cancel();
+    }
+    const queue: c.dispatch.queue_t = @ptrCast(batch.userdata orelse return);
+    if (batch.pending.head != .none) {
+        var waiter: BatchWaiter = .{
+            .sleeper = .init(ev.queue, Thread.current().currentFiber()),
+            .queue = queue,
+            .timer = BatchWaiter.already_signaled,
+        };
+        if (batch.pending.head == .none) queue.async(&waiter, &BatchWaiter.signal);
+        queue.as_object().set_context(&waiter);
+        ev.yield(.{ .@"resume" = queue.as_object() });
+    }
+    batch.userdata = null;
+}
+
+const BatchOperationUserdata = extern struct {
+    batch: *Io.Batch,
+    source: c.dispatch.source_t,
+    operation: extern union {
+        file_read_streaming: extern struct {
+            data_ptr: [*]const []u8,
+            data_len: usize,
+        },
+        file_write_streaming: extern struct {
+            header_ptr: [*]const u8,
+            header_len: usize,
+            data_ptr: [*]const []const u8,
+            data_len: usize,
+            splat: usize,
+
+            fn header(operation: *const @This()) []const u8 {
+                return operation.header_ptr[0..operation.header_len];
+            }
+
+            fn data(operation: *const @This()) []const []const u8 {
+                return operation.data_ptr[0..operation.data_len];
+            }
+        },
+    },
+
+    const Erased = Io.Operation.Storage.Pending.Userdata;
+
+    comptime {
+        assert(@sizeOf(BatchOperationUserdata) <= @sizeOf(Erased));
+    }
+
+    fn toErased(userdata: *BatchOperationUserdata) *Erased {
+        return @ptrCast(userdata);
+    }
+
+    fn fromErased(erased: *Erased) *BatchOperationUserdata {
+        return @ptrCast(erased);
+    }
+};
+
+/// If `concurrency` is false, `error.ConcurrencyUnavailable` is unreachable.
+fn batchDrainSubmitted(
+    ev: *Evented,
+    batch: *Io.Batch,
+    concurrency: bool,
+) (Io.ConcurrentError || Io.Cancelable)!?c.dispatch.queue_t {
+    var index = batch.submitted.head;
+    if (index == .none) return @ptrCast(batch.userdata);
+    errdefer batch.submitted.head = index;
+    const maybe_queue: ?c.dispatch.queue_t = if (batch.userdata) |batch_userdata|
+        @ptrCast(batch_userdata)
+    else maybe_queue: {
+        const queue = c.dispatch.queue_create_with_target(
+            "org.ziglang.std.Io.Dispatch.Batch",
+            .SERIAL(),
+            ev.queue,
+        ) orelse if (concurrency) return error.ConcurrencyUnavailable else break :maybe_queue null;
+        queue.as_object().@"suspend"();
+        batch.userdata = queue;
+        break :maybe_queue queue;
+    };
+    while (index != .none) {
+        const storage = &batch.storage[index.toIndex()];
+        const next_index = storage.submission.node.next;
+        if (@as(?Io.Operation.Result, result: {
+            if (maybe_queue) |queue| switch (storage.submission.operation) {
+                .file_read_streaming => |operation| {
+                    const data = for (operation.data, 0..) |buffer, data_index| {
+                        if (buffer.len > 0) break operation.data[data_index..];
+                    } else break :result .{ .file_read_streaming = 0 };
+                    const source = c.dispatch.source_create(
+                        .READ,
+                        @bitCast(@as(isize, operation.file.handle)),
+                        .none,
+                        queue,
+                    ) orelse break :result .{ .file_read_streaming = error.SystemResources };
+                    storage.* = .{ .pending = .{
+                        .node = .{ .prev = batch.pending.tail, .next = .none },
+                        .tag = .file_read_streaming,
+                        .userdata = undefined,
+                    } };
+                    const operation_userdata: *BatchOperationUserdata =
+                        .fromErased(&storage.pending.userdata);
+                    operation_userdata.* = .{
+                        .batch = batch,
+                        .source = source,
+                        .operation = .{ .file_read_streaming = .{
+                            .data_ptr = data.ptr,
+                            .data_len = data.len,
+                        } },
+                    };
+                    source.as_object().set_context(storage);
+                    source.set_event_handler(&batchSourceEvent);
+                    source.set_cancel_handler(&batchSourceCancel);
+                    source.as_object().activate();
+                    break :result null;
+                },
+                .file_write_streaming => |operation| {
+                    const data = for (operation.data, 0..) |buffer, data_index| {
+                        if (buffer.len > 0) break operation.data[data_index..];
+                    } else if (operation.header.len > 0)
+                        operation.data[0..1]
+                    else
+                        break :result .{ .file_write_streaming = 0 };
+                    const source = c.dispatch.source_create(
+                        .WRITE,
+                        @bitCast(@as(isize, operation.file.handle)),
+                        .none,
+                        queue,
+                    ) orelse break :result .{ .file_write_streaming = error.SystemResources };
+                    storage.* = .{ .pending = .{
+                        .node = .{ .prev = batch.pending.tail, .next = .none },
+                        .tag = .file_write_streaming,
+                        .userdata = undefined,
+                    } };
+                    const operation_userdata: *BatchOperationUserdata =
+                        .fromErased(&storage.pending.userdata);
+                    operation_userdata.* = .{
+                        .batch = batch,
+                        .source = source,
+                        .operation = .{ .file_write_streaming = .{
+                            .header_ptr = operation.header.ptr,
+                            .header_len = operation.header.len,
+                            .data_ptr = data.ptr,
+                            .data_len = data.len,
+                            .splat = operation.splat,
+                        } },
+                    };
+                    source.as_object().set_context(storage);
+                    source.set_event_handler(&batchSourceEvent);
+                    source.set_cancel_handler(&batchSourceCancel);
+                    source.as_object().activate();
+                    break :result null;
+                },
+                .device_io_control => {},
+            };
+            if (concurrency) return error.ConcurrencyUnavailable;
+            break :result try operate(ev, storage.submission.operation);
+        })) |result| {
+            switch (batch.completed.tail) {
+                .none => batch.completed.head = index,
+                else => |tail_index| batch.storage[tail_index.toIndex()].completion.node.next = index,
+            }
+            batch.completed.tail = index;
+            storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+        } else {
+            switch (batch.pending.tail) {
+                .none => batch.pending.head = index,
+                else => |tail_index| batch.storage[tail_index.toIndex()].pending.node.next = index,
+            }
+            batch.pending.tail = index;
+        }
+        index = next_index;
+    }
+    batch.submitted = .{ .head = .none, .tail = .none };
+    return maybe_queue;
+}
+
+fn batchSourceEvent(context: ?*anyopaque) callconv(.c) void {
+    const storage: *Io.Operation.Storage = @ptrCast(@alignCast(context));
+    const pending = &storage.pending;
+    const operation_userdata: *BatchOperationUserdata = .fromErased(&pending.userdata);
+    const batch = operation_userdata.batch;
+    const source = operation_userdata.source;
+    const index: Io.Operation.OptionalIndex = .fromIndex(storage - batch.storage.ptr);
+    const result: Io.Operation.Result = result: switch (pending.tag) {
+        .file_read_streaming => {
+            const operation = &operation_userdata.operation.file_read_streaming;
+            break :result .{ .file_read_streaming = fileReadStreamingLimit(
+                @intCast(source.get_handle()),
+                operation.data_ptr[0..operation.data_len],
+                .limited(source.get_data()),
+            ) catch |err| switch (err) {
+                error.Canceled => return Thread.current().currentFiber().cancel_protection.recancel(),
+                error.WouldBlock => return,
+                else => |e| e,
+            } };
+        },
+        .file_write_streaming => {
+            const operation = &operation_userdata.operation.file_write_streaming;
+            break :result .{ .file_write_streaming = fileWriteStreamingLimit(
+                @intCast(source.get_handle()),
+                operation.header_ptr[0..operation.header_len],
+                operation.data_ptr[0..operation.data_len],
+                operation.splat,
+                .limited(source.get_data()),
+            ) catch |err| switch (err) {
+                error.Canceled => return Thread.current().currentFiber().cancel_protection.recancel(),
+                error.WouldBlock => return,
+                else => |e| e,
+            } };
+        },
+        .device_io_control => unreachable,
+    };
+
+    switch (pending.node.prev) {
+        .none => batch.pending.head = pending.node.next,
+        else => |prev_index| batch.storage[prev_index.toIndex()].pending.node.next = pending.node.next,
+    }
+    switch (pending.node.next) {
+        .none => batch.pending.tail = pending.node.prev,
+        else => |next_index| batch.storage[next_index.toIndex()].pending.node.prev = pending.node.prev,
+    }
+
+    switch (batch.completed.tail) {
+        .none => batch.completed.head = index,
+        else => |tail_index| batch.storage[tail_index.toIndex()].completion.node.next = index,
+    }
+    storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+    batch.completed.tail = index;
+
+    source.as_object().release();
+    const queue: c.dispatch.queue_t = @ptrCast(batch.userdata);
+    const waiter: *BatchWaiter = @ptrCast(@alignCast(queue.as_object().get_context()));
+    BatchWaiter.signal(waiter);
+}
+
+fn batchSourceCancel(context: ?*anyopaque) callconv(.c) void {
+    const storage: *Io.Operation.Storage = @ptrCast(@alignCast(context));
+    const pending = &storage.pending;
+    const operation_userdata: *BatchOperationUserdata = .fromErased(&pending.userdata);
+    const batch = operation_userdata.batch;
+    const source = operation_userdata.source;
+    const index: Io.Operation.OptionalIndex = .fromIndex(storage - batch.storage.ptr);
+
+    switch (pending.node.prev) {
+        .none => batch.pending.head = pending.node.next,
+        else => |prev_index| batch.storage[prev_index.toIndex()].pending.node.next = pending.node.next,
+    }
+    switch (pending.node.next) {
+        .none => batch.pending.tail = pending.node.prev,
+        else => |next_index| batch.storage[next_index.toIndex()].pending.node.prev = pending.node.prev,
+    }
+
+    const tail_index = batch.unused.tail;
+    switch (tail_index) {
+        .none => batch.unused.head = index,
+        else => batch.storage[tail_index.toIndex()].unused.next = index,
+    }
+    storage.* = .{ .unused = .{ .prev = tail_index, .next = .none } };
+    batch.unused.tail = index;
+
+    source.as_object().release();
+    if (batch.pending.head != .none) return;
+    const queue: c.dispatch.queue_t = @ptrCast(batch.userdata);
+    const waiter: *BatchWaiter = @ptrCast(@alignCast(queue.as_object().get_context()));
+    queue.as_object().release();
+    waiter.wake();
+}
+
+fn dirCreateDir(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+) Dir.CreateDirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    while (true) {
+        switch (c.errno(c.mkdirat(dir.handle, sub_path_posix, permissions.toMode()))) {
+            .SUCCESS => return,
+            .INTR => {},
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .DQUOT => return error.DiskQuota,
+            .EXIST => return error.PathAlreadyExists,
+            .LOOP => return error.SymLinkLoop,
+            .MLINK => return error.LinkQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .ROFS => return error.ReadOnlyFileSystem,
+            .ILSEQ => return error.BadPathName,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .FAULT => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirCreateDirPath(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var it = Dir.path.componentIterator(sub_path);
+    var status: Dir.CreatePathStatus = .existed;
+    var component = it.last() orelse return error.BadPathName;
+    while (true) {
+        if (dirCreateDir(ev, dir, component.path, permissions)) |_| {
+            status = .created;
+        } else |err| switch (err) {
+            error.PathAlreadyExists => {
+                // It is important to return an error if it's not a directory
+                // because otherwise a dangling symlink could cause an infinite
+                // loop.
+                const fstat = try dirStatFile(ev, dir, component.path, .{});
+                if (fstat.kind != .directory) return error.NotDir;
+            },
+            error.FileNotFound => |e| {
+                component = it.previous() orelse return e;
+                continue;
+            },
+            else => |e| return e,
+        }
+        component = it.next() orelse return status;
+    }
+}
+
+fn dirCreateDirPathOpen(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+    options: Dir.OpenOptions,
+) Dir.CreateDirPathOpenError!Dir {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return dirOpenDir(ev, dir, sub_path, options) catch |err| switch (err) {
+        error.FileNotFound => {
+            _ = try dirCreateDirPath(ev, dir, sub_path, permissions);
+            return dirOpenDir(ev, dir, sub_path, options);
+        },
+        else => |e| return e,
+    };
+}
+
+fn dirOpenDir(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.OpenOptions,
+) Dir.OpenError!Dir {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const flags: c.O = .{
+        .ACCMODE = .RDONLY,
+        .NOFOLLOW = !options.follow_symlinks,
+        .DIRECTORY = true,
+        .CLOEXEC = true,
+    };
+
+    while (true) {
+        const rc = c.openat(dir.handle, sub_path_posix, flags);
+        switch (c.errno(rc)) {
+            .SUCCESS => return .{ .handle = @intCast(rc) },
+            .INTR => {},
+            .INVAL => return error.BadPathName,
+            .ACCES => return error.AccessDenied,
+            .LOOP => return error.SymLinkLoop,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NODEV => return error.NoDevice,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.NotDir,
+            .PERM => return error.PermissionDenied,
+            .NXIO => return error.NoDevice,
+            .ILSEQ => return error.BadPathName,
+            .FAULT => |err| return errnoBug(err),
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .BUSY => |err| return errnoBug(err), // O_EXCL not passed
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return fileStat(ev, .{
+        .handle = dir.handle,
+        .flags = .{ .nonblocking = false },
+    });
+}
+
+fn dirStatFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.StatFileOptions,
+) Dir.StatFileError!File.Stat {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const flags: u32 = if (options.follow_symlinks) 0 else c.AT.SYMLINK_NOFOLLOW;
+
+    while (true) {
+        var stat = std.mem.zeroes(c.Stat);
+        switch (c.errno(c.fstatat(dir.handle, sub_path_posix, &stat, flags))) {
+            .SUCCESS => return statFromPosix(&stat),
+            .INTR => {},
+            .INVAL => |err| return errnoBug(err),
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .NOMEM => return error.SystemResources,
+            .ACCES => return error.AccessDenied,
+            .PERM => return error.PermissionDenied,
+            .FAULT => |err| return errnoBug(err),
+            .NAMETOOLONG => return error.NameTooLong,
+            .LOOP => return error.SymLinkLoop,
+            .NOENT => return error.FileNotFound,
+            .NOTDIR => return error.FileNotFound,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirAccess(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.AccessOptions,
+) Dir.AccessError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const flags: u32 = if (options.follow_symlinks) 0 else c.AT.SYMLINK_NOFOLLOW;
+
+    const mode: u32 =
+        @as(u32, if (options.read) c.R_OK else 0) |
+        @as(u32, if (options.write) c.W_OK else 0) |
+        @as(u32, if (options.execute) c.X_OK else 0);
+
+    while (true) switch (c.errno(c.faccessat(dir.handle, sub_path_posix, mode, flags))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        .LOOP => return error.SymLinkLoop,
+        .TXTBSY => return error.FileBusy,
+        .NOTDIR => return error.FileNotFound,
+        .NOENT => return error.FileNotFound,
+        .NAMETOOLONG => return error.NameTooLong,
+        .INVAL => |err| return errnoBug(err),
+        .FAULT => |err| return errnoBug(err),
+        .IO => return error.InputOutput,
+        .NOMEM => return error.SystemResources,
+        .ILSEQ => return error.BadPathName,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirCreateFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    flags: File.CreateFlags,
+) File.OpenError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const os_flags: c.O = .{
+        .ACCMODE = if (flags.read) .RDWR else .WRONLY,
+        .NONBLOCK = flags.lock == .none or flags.lock_nonblocking,
+        .SHLOCK = flags.lock == .shared,
+        .EXLOCK = flags.lock == .exclusive,
+        .CREAT = true,
+        .TRUNC = flags.truncate,
+        .EXCL = flags.exclusive,
+        .CLOEXEC = true,
+    };
+
+    const fd: c.fd_t = while (true) {
+        const rc = c.openat(dir.handle, sub_path_posix, os_flags, flags.permissions.toMode());
+        switch (c.errno(rc)) {
+            .SUCCESS => break @intCast(rc),
+            .INTR => {},
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => return error.BadPathName,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .ACCES => return error.AccessDenied,
+            .FBIG => return error.FileTooBig,
+            .OVERFLOW => return error.FileTooBig,
+            .ISDIR => return error.IsDir,
+            .LOOP => return error.SymLinkLoop,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NODEV => return error.NoDevice,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .PERM => return error.PermissionDenied,
+            .EXIST => return error.PathAlreadyExists,
+            .BUSY => return error.DeviceBusy,
+            .OPNOTSUPP => return error.FileLocksUnsupported,
+            .AGAIN => return error.WouldBlock,
+            .TXTBSY => return error.FileBusy,
+            .NXIO => return error.NoDevice,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    errdefer closeFd(fd);
+
+    return .{
+        .handle = fd,
+        .flags = .{ .nonblocking = os_flags.NONBLOCK },
+    };
+}
+
+fn dirCreateFileAtomic(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    dest_path: []const u8,
+    options: Dir.CreateFileAtomicOptions,
+) Dir.CreateFileAtomicError!File.Atomic {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (Dir.path.dirname(dest_path)) |dirname| {
+        const new_dir = if (options.make_path)
+            dirCreateDirPathOpen(ev, dir, dirname, .default_dir, .{}) catch |err| switch (err) {
+                // None of these make sense in this context.
+                error.IsDir,
+                error.Streaming,
+                error.DiskQuota,
+                error.PathAlreadyExists,
+                error.LinkQuotaExceeded,
+                error.PipeBusy,
+                error.FileTooBig,
+                error.FileLocksUnsupported,
+                error.DeviceBusy,
+                => return error.Unexpected,
+
+                else => |e| return e,
+            }
+        else
+            try dirOpenDir(ev, dir, dirname, .{});
+        return ev.atomicFileInit(Dir.path.basename(dest_path), options.permissions, new_dir, true);
+    }
+    return ev.atomicFileInit(dest_path, options.permissions, dir, false);
+}
+
+fn atomicFileInit(
+    ev: *Evented,
+    dest_basename: []const u8,
+    permissions: File.Permissions,
+    dir: Dir,
+    close_dir_on_deinit: bool,
+) Dir.CreateFileAtomicError!File.Atomic {
+    while (true) {
+        var random_integer: u64 = undefined;
+        random(ev, @ptrCast(&random_integer));
+        const tmp_sub_path = std.fmt.hex(random_integer);
+        const file = dirCreateFile(ev, dir, &tmp_sub_path, .{
+            .permissions = permissions,
+            .exclusive = true,
+        }) catch |err| switch (err) {
+            error.PathAlreadyExists => continue,
+            error.DeviceBusy => continue,
+            error.FileBusy => continue,
+
+            error.IsDir => return error.Unexpected, // No path components.
+            error.FileTooBig => return error.Unexpected, // Creating, not opening.
+            error.FileLocksUnsupported => return error.Unexpected, // Not asking for locks.
+            error.PipeBusy => return error.Unexpected, // Not opening a pipe.
+
+            else => |e| return e,
+        };
+        return .{
+            .file = file,
+            .file_basename_hex = random_integer,
+            .dest_sub_path = dest_basename,
+            .file_open = true,
+            .file_exists = true,
+            .close_dir_on_deinit = close_dir_on_deinit,
+            .dir = dir,
+        };
+    }
+}
+
+fn dirOpenFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    flags: File.OpenFlags,
+) File.OpenError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const os_flags: c.O = .{
+        .ACCMODE = switch (flags.mode) {
+            .read_only => .RDONLY,
+            .write_only => .WRONLY,
+            .read_write => .RDWR,
+        },
+        .NONBLOCK = flags.lock == .none or flags.lock_nonblocking,
+        .SHLOCK = flags.lock == .shared,
+        .EXLOCK = flags.lock == .exclusive,
+        .NOFOLLOW = !flags.follow_symlinks,
+        .NOCTTY = !flags.allow_ctty,
+        .CLOEXEC = true,
+    };
+
+    const fd: c.fd_t = while (true) {
+        const rc = c.openat(dir.handle, sub_path_posix, os_flags);
+        switch (c.errno(rc)) {
+            .SUCCESS => break @intCast(rc),
+            .INTR => {},
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => return error.BadPathName,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .ACCES => return error.AccessDenied,
+            .FBIG => return error.FileTooBig,
+            .OVERFLOW => return error.FileTooBig,
+            .ISDIR => return error.IsDir,
+            .LOOP => return error.SymLinkLoop,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NODEV => return error.NoDevice,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .PERM => return error.PermissionDenied,
+            .EXIST => return error.PathAlreadyExists,
+            .BUSY => return error.DeviceBusy,
+            .OPNOTSUPP => return error.FileLocksUnsupported,
+            .AGAIN => return error.WouldBlock,
+            .TXTBSY => return error.FileBusy,
+            .NXIO => return error.NoDevice,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    errdefer closeFd(fd);
+
+    if (!flags.allow_directory) {
+        const is_dir = is_dir: {
+            const stat = fileStat(ev, .{
+                .handle = fd,
+                .flags = .{ .nonblocking = false },
+            }) catch |err| switch (err) {
+                // The directory-ness is either unknown or unknowable
+                error.Streaming => break :is_dir false,
+                else => |e| return e,
+            };
+            break :is_dir stat.kind == .directory;
+        };
+        if (is_dir) return error.IsDir;
+    }
+
+    return .{
+        .handle = fd,
+        .flags = .{ .nonblocking = os_flags.NONBLOCK },
+    };
+}
+
+fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    for (dirs) |dir| closeFd(dir.handle);
+}
+
+fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const Header = extern struct {
+        seek: i64,
+    };
+    const header: *Header = @ptrCast(dr.buffer.ptr);
+    const header_end: usize = @sizeOf(Header);
+    if (dr.index < header_end) {
+        // Initialize header.
+        dr.index = header_end;
+        dr.end = header_end;
+        header.* = .{ .seek = 0 };
+    }
+    var buffer_index: usize = 0;
+    while (buffer.len - buffer_index != 0) {
+        if (dr.end - dr.index == 0) {
+            // Refill the buffer, unless we've already created references to
+            // buffered data.
+            if (buffer_index != 0) break;
+            if (dr.state == .reset) {
+                ev.lseek(dr.dir.handle, 0, c.SEEK.SET) catch |err| switch (err) {
+                    error.Unseekable => return error.Unexpected,
+                    else => |e| return e,
+                };
+                dr.state = .reading;
+            }
+            const dents_buffer = dr.buffer[header_end..];
+            const n: usize = while (true) {
+                const rc = c.getdirentries(dr.dir.handle, dents_buffer.ptr, dents_buffer.len, &header.seek);
+                switch (c.errno(rc)) {
+                    .SUCCESS => break @intCast(rc),
+                    .INTR => {},
+                    .BADF => |err| return errnoBug(err), // Dir is invalid or was opened without iteration ability.
+                    .FAULT => |err| return errnoBug(err),
+                    .NOTDIR => |err| return errnoBug(err),
+                    .INVAL => |err| return errnoBug(err),
+                    else => |err| return unexpectedErrno(err),
+                }
+            };
+            if (n == 0) {
+                dr.state = .finished;
+                return 0;
+            }
+            dr.index = header_end;
+            dr.end = header_end + n;
+        }
+        const darwin_entry = @as(*align(1) c.dirent, @ptrCast(&dr.buffer[dr.index]));
+        const next_index = dr.index + darwin_entry.reclen;
+        dr.index = next_index;
+
+        const name = @as([*]u8, @ptrCast(&darwin_entry.name))[0..darwin_entry.namlen];
+        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..") or (darwin_entry.ino == 0))
+            continue;
+
+        const entry_kind: File.Kind = switch (darwin_entry.type) {
+            c.DT.BLK => .block_device,
+            c.DT.CHR => .character_device,
+            c.DT.DIR => .directory,
+            c.DT.FIFO => .named_pipe,
+            c.DT.LNK => .sym_link,
+            c.DT.REG => .file,
+            c.DT.SOCK => .unix_domain_socket,
+            c.DT.WHT => .whiteout,
+            else => .unknown,
+        };
+        buffer[buffer_index] = .{
+            .name = name,
+            .kind = entry_kind,
+            .inode = darwin_entry.ino,
+        };
+        buffer_index += 1;
+    }
+    return buffer_index;
+}
+
+fn dirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return ev.realPath(dir.handle, out_buffer);
+}
+
+fn realPath(ev: *Evented, fd: c.fd_t, out_buffer: []u8) File.RealPathError!usize {
+    _ = ev;
+    var buffer: [c.PATH_MAX]u8 = undefined;
+    @memset(&buffer, 0);
+    while (true) {
+        switch (c.errno(c.fcntl(fd, c.F.GETPATH, &buffer))) {
+            .SUCCESS => break,
+            .INTR => {},
+            .ACCES => return error.AccessDenied,
+            .BADF => return error.FileNotFound,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NameTooLong,
+            .RANGE => return error.NameTooLong,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+    const n = std.mem.indexOfScalar(u8, &buffer, 0) orelse buffer.len;
+    if (n > out_buffer.len) return error.NameTooLong;
+    @memcpy(out_buffer[0..n], buffer[0..n]);
+    return n;
+}
+
+fn dirRealPathFile(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    out_buffer: []u8,
+) Dir.RealPathFileError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    if (dir.handle == c.AT.FDCWD) {
+        if (out_buffer.len < c.PATH_MAX) return error.NameTooLong;
+        while (true) {
+            if (c.realpath(sub_path_posix, out_buffer.ptr)) |redundant_pointer| {
+                assert(redundant_pointer == out_buffer.ptr);
+                return std.mem.indexOfScalar(u8, out_buffer, 0) orelse out_buffer.len;
+            }
+            const err: c.E = @enumFromInt(c._errno().*);
+            switch (err) {
+                .INTR => {},
+                .INVAL => return errnoBug(err),
+                .BADF => return errnoBug(err),
+                .FAULT => return errnoBug(err),
+                .ACCES => return error.AccessDenied,
+                .NOENT => return error.FileNotFound,
+                .OPNOTSUPP => return error.OperationUnsupported,
+                .NOTDIR => return error.NotDir,
+                .NAMETOOLONG => return error.NameTooLong,
+                .LOOP => return error.SymLinkLoop,
+                .IO => return error.InputOutput,
+                else => return unexpectedErrno(err),
+            }
+        }
+    }
+
+    const os_flags: c.O = .{
+        .NONBLOCK = true,
+        .CLOEXEC = true,
+    };
+
+    const fd: c.fd_t = while (true) {
+        const rc = c.openat(dir.handle, sub_path_posix, os_flags);
+        switch (c.errno(rc)) {
+            .SUCCESS => break @intCast(rc),
+            .INTR => {},
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => return error.BadPathName,
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .ACCES => return error.AccessDenied,
+            .FBIG => return error.FileTooBig,
+            .OVERFLOW => return error.FileTooBig,
+            .ISDIR => return error.IsDir,
+            .LOOP => return error.SymLinkLoop,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NODEV => return error.NoDevice,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NoSpaceLeft,
+            .NOTDIR => return error.NotDir,
+            .PERM => return error.PermissionDenied,
+            .EXIST => return error.PathAlreadyExists,
+            .BUSY => return error.DeviceBusy,
+            .NXIO => return error.NoDevice,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    defer closeFd(fd);
+    return ev.realPath(fd, out_buffer);
+}
+
+fn dirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    while (true) switch (c.errno(c.unlinkat(dir.handle, sub_path_posix, 0))) {
+        .SUCCESS => return,
+        .INTR => {},
+        // Some systems return permission errors when trying to delete a
+        // directory, so we need to handle that case specifically and
+        // translate the error.
+        .PERM => {
+            // Don't follow symlinks to match unlinkat (which acts on symlinks rather than follows them).
+            var st = std.mem.zeroes(c.Stat);
+            while (true) switch (c.errno(c.fstatat(
+                dir.handle,
+                sub_path_posix,
+                &st,
+                c.AT.SYMLINK_NOFOLLOW,
+            ))) {
+                .SUCCESS => break,
+                .INTR => {},
+                else => return error.PermissionDenied,
+            };
+            if (st.mode & c.S.IFMT == c.S.IFDIR) return error.IsDir else return error.PermissionDenied;
+        },
+        .ACCES => return error.AccessDenied,
+        .BUSY => return error.FileBusy,
+        .FAULT => |err| return errnoBug(err),
+        .IO => return error.FileSystem,
+        .ISDIR => return error.IsDir,
+        .LOOP => return error.SymLinkLoop,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.NotDir,
+        .NOMEM => return error.SystemResources,
+        .ROFS => return error.ReadOnlyFileSystem,
+        .EXIST => |err| return errnoBug(err),
+        .NOTEMPTY => |err| return errnoBug(err), // Not passing AT.REMOVEDIR
+        .ILSEQ => return error.BadPathName,
+        .INVAL => |err| return errnoBug(err), // invalid flags, or pathname has . as last component
+        .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    while (true) switch (c.errno(c.unlinkat(dir.handle, sub_path_posix, c.AT.REMOVEDIR))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .BUSY => return error.FileBusy,
+        .FAULT => |err| return errnoBug(err),
+        .IO => return error.FileSystem,
+        .ISDIR => |err| return errnoBug(err),
+        .LOOP => return error.SymLinkLoop,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.NotDir,
+        .NOMEM => return error.SystemResources,
+        .ROFS => return error.ReadOnlyFileSystem,
+        .EXIST => |err| return errnoBug(err),
+        .NOTEMPTY => return error.DirNotEmpty,
+        .ILSEQ => return error.BadPathName,
+        .INVAL => |err| return errnoBug(err), // invalid flags, or pathname has . as last component
+        .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirRename(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+) Dir.RenameError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var old_path_buffer: [c.PATH_MAX]u8 = undefined;
+    var new_path_buffer: [c.PATH_MAX]u8 = undefined;
+
+    const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
+    const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
+
+    while (true) switch (c.errno(c.renameat(old_dir.handle, old_sub_path_posix, new_dir.handle, new_sub_path_posix))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .BUSY => return error.FileBusy,
+        .DQUOT => return error.DiskQuota,
+        .ISDIR => return error.IsDir,
+        .IO => return error.HardwareFailure,
+        .LOOP => return error.SymLinkLoop,
+        .MLINK => return error.LinkQuotaExceeded,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.NotDir,
+        .NOMEM => return error.SystemResources,
+        .NOSPC => return error.NoSpaceLeft,
+        .EXIST => return error.DirNotEmpty,
+        .NOTEMPTY => return error.DirNotEmpty,
+        .ROFS => return error.ReadOnlyFileSystem,
+        .XDEV => return error.CrossDevice,
+        .ILSEQ => return error.BadPathName,
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirRenamePreserve(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+) Dir.RenamePreserveError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    // Make a hard link then delete the original.
+    try dirHardLink(ev, old_dir, old_sub_path, new_dir, new_sub_path, .{ .follow_symlinks = false });
+    const prev = swapCancelProtection(ev, .blocked);
+    defer _ = swapCancelProtection(ev, prev);
+    dirDeleteFile(ev, old_dir, old_sub_path) catch {};
+}
+
+fn dirSymLink(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    target_path: []const u8,
+    sym_link_path: []const u8,
+    flags: Dir.SymLinkFlags,
+) Dir.SymLinkError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = flags;
+
+    var target_path_buffer: [c.PATH_MAX]u8 = undefined;
+    var sym_link_path_buffer: [c.PATH_MAX]u8 = undefined;
+
+    const target_path_posix = try pathToPosix(target_path, &target_path_buffer);
+    const sym_link_path_posix = try pathToPosix(sym_link_path, &sym_link_path_buffer);
+
+    while (true) switch (c.errno(c.symlinkat(target_path_posix, dir.handle, sym_link_path_posix))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .DQUOT => return error.DiskQuota,
+        .EXIST => return error.PathAlreadyExists,
+        .IO => return error.FileSystem,
+        .LOOP => return error.SymLinkLoop,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.NotDir,
+        .NOMEM => return error.SystemResources,
+        .NOSPC => return error.NoSpaceLeft,
+        .ROFS => return error.ReadOnlyFileSystem,
+        .ILSEQ => return error.BadPathName,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirReadLink(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    buffer: []u8,
+) Dir.ReadLinkError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var sub_path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &sub_path_buffer);
+    while (true) {
+        const rc = c.readlinkat(dir.handle, sub_path_posix, buffer.ptr, buffer.len);
+        switch (c.errno(rc)) {
+            .SUCCESS => return @intCast(rc),
+            .INTR => {},
+            .ACCES => return error.AccessDenied,
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => return error.NotLink,
+            .IO => return error.FileSystem,
+            .LOOP => return error.SymLinkLoop,
+            .NAMETOOLONG => return error.NameTooLong,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => return error.NotDir,
+            .ILSEQ => return error.BadPathName,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn dirSetOwner(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    owner: ?File.Uid,
+    group: ?File.Gid,
+) Dir.SetOwnerError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    return fchown(dir.handle, owner, group);
+}
+
+fn fchown(fd: c.fd_t, owner: ?File.Uid, group: ?File.Gid) File.SetOwnerError!void {
+    const uid = owner orelse std.math.maxInt(c.uid_t);
+    const gid = group orelse std.math.maxInt(c.gid_t);
+    while (true) switch (c.errno(c.fchown(fd, uid, gid))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err), // likely fd refers to directory opened without `Dir.OpenOptions.iterate`
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .IO => return error.InputOutput,
+        .LOOP => return error.SymLinkLoop,
+        .NOENT => return error.FileNotFound,
+        .NOMEM => return error.SystemResources,
+        .NOTDIR => return error.FileNotFound,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirSetFileOwner(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    owner: ?File.Uid,
+    group: ?File.Gid,
+    options: Dir.SetFileOwnerOptions,
+) Dir.SetFileOwnerError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+    _ = ev;
+    while (true) switch (c.errno(c.fchownat(
+        dir.handle,
+        sub_path_posix,
+        owner orelse std.math.maxInt(c.uid_t),
+        group orelse std.math.maxInt(c.gid_t),
+        if (options.follow_symlinks) 0 else c.AT.SYMLINK_NOFOLLOW,
+    ))) {
+        .SUCCESS => return,
+        .INTR => continue,
+        .BADF => |err| return errnoBug(err), // likely fd refers to directory opened without `Dir.OpenOptions.iterate`
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .IO => return error.InputOutput,
+        .LOOP => return error.SymLinkLoop,
+        .NOENT => return error.FileNotFound,
+        .NOMEM => return error.SystemResources,
+        .NOTDIR => return error.FileNotFound,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirSetPermissions(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    permissions: Dir.Permissions,
+) Dir.SetPermissionsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return ev.fchmod(dir.handle, permissions.toMode());
+}
+
+fn dirSetFilePermissions(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    permissions: Dir.Permissions,
+    options: Dir.SetFilePermissionsOptions,
+) Dir.SetFilePermissionsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    const mode = permissions.toMode();
+    const flags: u32 = if (options.follow_symlinks) 0 else c.AT.SYMLINK_NOFOLLOW;
+
+    while (true) switch (c.errno(c.fchmodat(dir.handle, sub_path_posix, mode, flags))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err),
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .IO => return error.InputOutput,
+        .LOOP => return error.SymLinkLoop,
+        .MFILE => return error.ProcessFdQuotaExceeded,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NFILE => return error.SystemFdQuotaExceeded,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.FileNotFound,
+        .NOMEM => return error.SystemResources,
+        .OPNOTSUPP => return error.OperationUnsupported,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirSetTimestamps(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    sub_path: []const u8,
+    options: Dir.SetTimestampsOptions,
+) Dir.SetTimestampsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var times_buffer: [2]c.timespec = undefined;
+    const times = if (options.modify_timestamp == .now and options.access_timestamp == .now) null else p: {
+        times_buffer = .{
+            setTimestampToPosix(options.access_timestamp),
+            setTimestampToPosix(options.modify_timestamp),
+        };
+        break :p &times_buffer;
+    };
+
+    const flags: u32 = if (options.follow_symlinks) 0 else c.AT.SYMLINK_NOFOLLOW;
+
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+
+    while (true) switch (c.errno(c.utimensat(dir.handle, sub_path_posix, times, flags))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err), // always a race condition
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn dirHardLink(
+    userdata: ?*anyopaque,
+    old_dir: Dir,
+    old_sub_path: []const u8,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+    options: Dir.HardLinkOptions,
+) Dir.HardLinkError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var old_path_buffer: [c.PATH_MAX]u8 = undefined;
+    var new_path_buffer: [c.PATH_MAX]u8 = undefined;
+
+    const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
+    const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
+
+    const flags: u32 = if (options.follow_symlinks) c.AT.SYMLINK_FOLLOW else 0;
+    return linkat(old_dir.handle, old_sub_path_posix, new_dir.handle, new_sub_path_posix, flags);
+}
+
+fn fileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    while (true) {
+        var stat = std.mem.zeroes(c.Stat);
+        switch (c.errno(c.fstat(file.handle, &stat))) {
+            .SUCCESS => return statFromPosix(&stat),
+            .INTR => {},
+            .INVAL => |err| return errnoBug(err),
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .NOMEM => return error.SystemResources,
+            .ACCES => return error.AccessDenied,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const stat = try fileStat(ev, file);
+    return stat.size;
+}
+
+fn fileClose(userdata: ?*anyopaque, files: []const File) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    for (files) |file| closeFd(file.handle);
+}
+
+fn fileWritePositional(
+    userdata: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+    offset: u64,
+) File.WritePositionalError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var iovecs: [max_iovecs_len]iovec_const = undefined;
+    var iovlen: iovlen_t = 0;
+    var remaining: Io.Limit = .unlimited;
+    addBuf(true, &iovecs, &iovlen, &remaining, header);
+    for (data[0 .. data.len - 1]) |bytes| addBuf(true, &iovecs, &iovlen, &remaining, bytes);
+    const pattern = data[data.len - 1];
+    var backup_buffer: [splat_buffer_size]u8 = undefined;
+    if (iovecs.len - iovlen != 0 and remaining != .nothing) switch (splat) {
+        0 => {},
+        1 => addBuf(true, &iovecs, &iovlen, &remaining, pattern),
+        else => switch (pattern.len) {
+            0 => {},
+            1 => {
+                const splat_buffer = &backup_buffer;
+                const memset_len = @min(splat_buffer.len, splat);
+                const buf = splat_buffer[0..memset_len];
+                @memset(buf, pattern[0]);
+                addBuf(true, &iovecs, &iovlen, &remaining, buf);
+                var remaining_splat = splat - buf.len;
+                while (remaining_splat > splat_buffer.len and iovecs.len - iovlen != 0 and remaining != .nothing) {
+                    assert(buf.len == splat_buffer.len);
+                    addBuf(true, &iovecs, &iovlen, &remaining, splat_buffer);
+                    remaining_splat -= splat_buffer.len;
+                }
+                addBuf(true, &iovecs, &iovlen, &remaining, splat_buffer[0..@min(remaining_splat, splat_buffer.len)]);
+            },
+            else => for (0..@min(splat, iovecs.len - iovlen)) |_| {
+                if (remaining == .nothing) break;
+                addBuf(true, &iovecs, &iovlen, &remaining, pattern);
+            },
+        },
+    };
+    if (iovlen == 0) return 0;
+    while (true) {
+        const rc = c.pwritev(file.handle, &iovecs, iovlen, @bitCast(offset));
+        switch (c.errno(rc)) {
+            .SUCCESS => return @intCast(rc),
+            .INTR => {},
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .DESTADDRREQ => |err| return errnoBug(err), // `connect` was never called.
+            .CONNRESET => |err| return errnoBug(err), // Not a socket handle.
+            .BADF => return error.NotOpenForWriting,
+            .AGAIN => return error.WouldBlock,
+            .DQUOT => return error.DiskQuota,
+            .FBIG => return error.FileTooBig,
+            .IO => return error.InputOutput,
+            .NOSPC => return error.NoSpaceLeft,
+            .PERM => return error.PermissionDenied,
+            .PIPE => return error.BrokenPipe,
+            .BUSY => return error.DeviceBusy,
+            .TXTBSY => return error.FileBusy,
+            .NXIO => return error.Unseekable,
+            .SPIPE => return error.Unseekable,
+            .OVERFLOW => return error.Unseekable,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fileWriteFileStreaming(
+    userdata: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    file_reader: *File.Reader,
+    limit: Io.Limit,
+) File.Writer.WriteFileError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const reader_buffered = file_reader.interface.buffered();
+    if (reader_buffered.len >= @intFromEnum(limit)) {
+        const n = try fileWriteStreaming(ev, file, header, &.{limit.slice(reader_buffered)}, 1);
+        file_reader.interface.toss(n -| header.len);
+        return n;
+    }
+    const file_limit = @intFromEnum(limit) - reader_buffered.len;
+    const out_fd = file.handle;
+    const in_fd = file_reader.file.handle;
+
+    if (file_reader.size) |size| {
+        if (size - file_reader.pos == 0) {
+            if (reader_buffered.len != 0) {
+                const n = try fileWriteStreaming(ev, file, header, &.{limit.slice(reader_buffered)}, 1);
+                file_reader.interface.toss(n -| header.len);
+                return n;
+            } else {
+                return error.EndOfStream;
+            }
+        }
+    }
+
+    if (@atomicLoad(UseSendfile, &ev.use_sendfile, .monotonic) == .disabled) return error.Unimplemented;
+    const offset = std.math.cast(c.off_t, file_reader.pos) orelse return error.Unimplemented;
+    var hdtr_data: c.sf_hdtr = undefined;
+    var headers: [2]iovec_const = undefined;
+    var headers_i: u8 = 0;
+    if (header.len != 0) {
+        headers[headers_i] = .{ .base = header.ptr, .len = header.len };
+        headers_i += 1;
+    }
+    if (reader_buffered.len != 0) {
+        headers[headers_i] = .{ .base = reader_buffered.ptr, .len = reader_buffered.len };
+        headers_i += 1;
+    }
+    const hdtr: ?*c.sf_hdtr = if (headers_i == 0) null else b: {
+        hdtr_data = .{
+            .headers = &headers,
+            .hdr_cnt = headers_i,
+            .trailers = null,
+            .trl_cnt = 0,
+        };
+        break :b &hdtr_data;
+    };
+    const max_count = std.math.maxInt(i32); // Avoid EINVAL.
+    var len: c.off_t = @min(file_limit, max_count);
+    const flags = 0;
+    while (true) switch (c.errno(c.sendfile(in_fd, out_fd, offset, &len, hdtr, flags))) {
+        .SUCCESS => break,
+        .OPNOTSUPP, .NOTSOCK, .NOSYS => {
+            // Give calling code chance to observe before trying
+            // something else.
+            @atomicStore(UseSendfile, &ev.use_sendfile, .disabled, .monotonic);
+            return 0;
+        },
+        .INTR => if (len > 0) break,
+        .AGAIN => {
+            if (len == 0) return error.WouldBlock;
+            break;
+        },
+        else => |e| {
+            assert(error.Unexpected == switch (e) {
+                .NOTCONN => return error.BrokenPipe,
+                .IO => return error.InputOutput,
+                .PIPE => return error.BrokenPipe,
+                .BADF => |err| errnoBug(err),
+                .FAULT => |err| errnoBug(err),
+                .INVAL => |err| errnoBug(err),
+                else => |err| unexpectedErrno(err),
+            });
+            // Give calling code chance to observe the error before trying
+            // something else.
+            @atomicStore(UseSendfile, &ev.use_sendfile, .disabled, .monotonic);
+            return 0;
+        },
+    };
+    if (len == 0) {
+        file_reader.size = file_reader.pos;
+        return error.EndOfStream;
+    }
+    const u_len: usize = @bitCast(len);
+    file_reader.interface.toss(u_len -| header.len);
+    return u_len;
+}
+
+fn fileWriteFilePositional(
+    userdata: ?*anyopaque,
+    file: File,
+    header: []const u8,
+    file_reader: *File.Reader,
+    limit: Io.Limit,
+    offset: u64,
+) File.WriteFilePositionalError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const reader_buffered = file_reader.interface.buffered();
+    if (reader_buffered.len >= @intFromEnum(limit)) {
+        const n = try fileWritePositional(
+            ev,
+            file,
+            header,
+            &.{limit.slice(reader_buffered)},
+            1,
+            offset,
+        );
+        file_reader.interface.toss(n -| header.len);
+        return n;
+    }
+    const out_fd = file.handle;
+    const in_fd = file_reader.file.handle;
+
+    if (file_reader.size) |size| {
+        if (size - file_reader.pos == 0) {
+            if (reader_buffered.len != 0) {
+                const n = try fileWritePositional(
+                    ev,
+                    file,
+                    header,
+                    &.{limit.slice(reader_buffered)},
+                    1,
+                    offset,
+                );
+                file_reader.interface.toss(n -| header.len);
+                return n;
+            } else {
+                return error.EndOfStream;
+            }
+        }
+    }
+
+    if (@atomicLoad(UseFcopyfile, &ev.use_fcopyfile, .monotonic) == .disabled)
+        return error.Unimplemented;
+    if (file_reader.pos != 0) return error.Unimplemented;
+    if (offset != 0) return error.Unimplemented;
+    if (limit != .unlimited) return error.Unimplemented;
+    const size = file_reader.getSize() catch return error.Unimplemented;
+    if (header.len != 0 or reader_buffered.len != 0) {
+        const n = try fileWritePositional(
+            ev,
+            file,
+            header,
+            &.{limit.slice(reader_buffered)},
+            1,
+            offset,
+        );
+        file_reader.interface.toss(n -| header.len);
+        return n;
+    }
+    while (true) {
+        const rc = c.fcopyfile(in_fd, out_fd, null, .{ .DATA = true });
+        switch (c.errno(rc)) {
+            .SUCCESS => break,
+            .INTR => {},
+            .OPNOTSUPP => {
+                // Give calling code chance to observe before trying
+                // something else.
+                @atomicStore(UseFcopyfile, &ev.use_fcopyfile, .disabled, .monotonic);
+                return 0;
+            },
+            else => |e| {
+                assert(error.Unexpected == switch (e) {
+                    .NOMEM => return error.SystemResources,
+                    .INVAL => |err| errnoBug(err),
+                    else => |err| unexpectedErrno(err),
+                });
+                return 0;
+            },
+        }
+    }
+    file_reader.pos = size;
+    return size;
+}
+
+fn fileReadPositional(
+    userdata: ?*anyopaque,
+    file: File,
+    data: []const []u8,
+    offset: u64,
+) File.ReadPositionalError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var iovecs: [max_iovecs_len]iovec = undefined;
+    var iovlen: iovlen_t = 0;
+    var remaining: Io.Limit = .unlimited;
+    for (data) |buf| addBuf(false, &iovecs, &iovlen, &remaining, buf);
+    if (iovlen == 0) return 0;
+    while (true) {
+        const rc = c.preadv(file.handle, &iovecs, iovlen, @bitCast(offset));
+        switch (c.errno(rc)) {
+            .SUCCESS => return @intCast(rc),
+            .INTR => {},
+            .NXIO => return error.Unseekable,
+            .SPIPE => return error.Unseekable,
+            .OVERFLOW => return error.Unseekable,
+            .NOBUFS => return error.SystemResources,
+            .NOMEM => return error.SystemResources,
+            .AGAIN => return error.WouldBlock,
+            .IO => return error.InputOutput,
+            .ISDIR => return error.IsDir,
+            .NOTCONN => |err| return errnoBug(err), // not a socket
+            .CONNRESET => |err| return errnoBug(err), // not a socket
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .BADF => return error.NotOpenForReading,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
+fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return ev.lseek(file.handle, @bitCast(offset), c.SEEK.CUR);
+}
+
+fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return ev.lseek(file.handle, offset, c.SEEK.SET);
+}
+
+fn lseek(ev: *Evented, fd: c.fd_t, offset: u64, whence: i32) File.SeekError!void {
+    _ = ev;
+    while (true) switch (c.errno(c.lseek(fd, @bitCast(offset), whence))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+        .INVAL => return error.Unseekable,
+        .OVERFLOW => return error.Unseekable,
+        .SPIPE => return error.Unseekable,
+        .NXIO => return error.Unseekable,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    while (true) switch (c.errno(c.fsync(file.handle))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ROFS => |err| return errnoBug(err),
+        .IO => return error.InputOutput,
+        .NOSPC => return error.NoSpaceLeft,
+        .DQUOT => return error.DiskQuota,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    while (true) {
+        const rc = c.isatty(file.handle);
+        switch (c.errno(rc - 1)) {
+            .SUCCESS => return true,
+            .INTR => {},
+            else => return false,
+        }
+    }
+}
+
+fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (!try fileIsTty(ev, file)) return error.NotTerminalDevice;
+}
+
+fn fileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    const signed_len: i64 = @bitCast(length);
+    if (signed_len < 0) return error.FileTooBig; // Avoid ambiguous EINVAL errors.
+
+    while (true) switch (c.errno(c.ftruncate(file.handle, signed_len))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .FBIG => return error.FileTooBig,
+        .IO => return error.InputOutput,
+        .PERM => return error.PermissionDenied,
+        .TXTBSY => return error.FileBusy,
+        .BADF => |err| return errnoBug(err), // Handle not open for writing.
+        .INVAL => return error.NonResizable, // This is returned for /dev/null for example.
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileSetOwner(
+    userdata: ?*anyopaque,
+    file: File,
+    owner: ?File.Uid,
+    group: ?File.Gid,
+) File.SetOwnerError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    return fchown(file.handle, owner, group);
+}
+
+fn fileSetPermissions(
+    userdata: ?*anyopaque,
+    file: File,
+    permissions: File.Permissions,
+) File.SetPermissionsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    return ev.fchmod(file.handle, permissions.toMode());
+}
+
+fn fchmod(ev: *Evented, fd: c.fd_t, mode: c.mode_t) File.SetPermissionsError!void {
+    _ = ev;
+    while (true) switch (c.errno(c.fchmod(fd, mode))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err),
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .IO => return error.InputOutput,
+        .LOOP => return error.SymLinkLoop,
+        .NOENT => return error.FileNotFound,
+        .NOMEM => return error.SystemResources,
+        .NOTDIR => return error.FileNotFound,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileSetTimestamps(
+    userdata: ?*anyopaque,
+    file: File,
+    options: File.SetTimestampsOptions,
+) File.SetTimestampsError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    var times_buffer: [2]c.timespec = undefined;
+    const times = if (options.modify_timestamp == .now and options.access_timestamp == .now) null else p: {
+        times_buffer = .{
+            setTimestampToPosix(options.access_timestamp),
+            setTimestampToPosix(options.modify_timestamp),
+        };
+        break :p &times_buffer;
+    };
+
+    while (true) switch (c.errno(c.futimens(file.handle, times))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err), // always a race condition
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const operation: i32 = switch (lock) {
+        .none => c.LOCK.UN,
+        .shared => c.LOCK.SH,
+        .exclusive => c.LOCK.EX,
+    };
+    while (true) switch (c.errno(c.flock(file.handle, operation))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .BADF => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err), // invalid parameters
+        .NOLCK => return error.SystemResources,
+        .AGAIN => |err| return errnoBug(err),
+        .OPNOTSUPP => return error.FileLocksUnsupported,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const operation: i32 = switch (lock) {
+        .none => c.LOCK.UN,
+        .shared => c.LOCK.SH | c.LOCK.NB,
+        .exclusive => c.LOCK.EX | c.LOCK.NB,
+    };
+    while (true) switch (c.errno(c.flock(file.handle, operation))) {
+        .SUCCESS => return true,
+        .INTR => {},
+        .AGAIN => return false,
+        .BADF => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err), // invalid parameters
+        .NOLCK => return error.SystemResources,
+        .OPNOTSUPP => return error.FileLocksUnsupported,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileUnlock(userdata: ?*anyopaque, file: File) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    while (true) switch (c.errno(c.flock(file.handle, c.LOCK.UN))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .AGAIN => return recoverableOsBugDetected(), // unlocking can't block
+        .BADF => return recoverableOsBugDetected(), // File descriptor used after closed.
+        .INVAL => return recoverableOsBugDetected(), // invalid parameters
+        .NOLCK => return recoverableOsBugDetected(), // Resource deallocation.
+        .OPNOTSUPP => return recoverableOsBugDetected(), // We already got the lock.
+        else => return recoverableOsBugDetected(), // Resource deallocation must succeed.
+    };
+}
+
+fn fileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const operation = c.LOCK.SH | c.LOCK.NB;
+    while (true) switch (c.errno(c.flock(file.handle, operation))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .AGAIN => |err| return errnoBug(err), // File was not locked in exclusive mode.
+        .BADF => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err), // invalid parameters
+        .NOLCK => |err| return errnoBug(err), // Lock already obtained.
+        .OPNOTSUPP => |err| return errnoBug(err), // Lock already obtained.
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var buffer: [c.PATH_MAX]u8 = undefined;
+    @memset(&buffer, 0);
+    while (true) {
+        switch (c.errno(c.fcntl(file.handle, c.F.GETPATH, &buffer))) {
+            .SUCCESS => break,
+            .INTR => {},
+            .ACCES => return error.AccessDenied,
+            .BADF => return error.FileNotFound,
+            .NOENT => return error.FileNotFound,
+            .NOMEM => return error.SystemResources,
+            .NOSPC => return error.NameTooLong,
+            .RANGE => return error.NameTooLong,
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+    const n = std.mem.indexOfScalar(u8, &buffer, 0) orelse buffer.len;
+    if (n > out_buffer.len) return error.NameTooLong;
+    @memcpy(out_buffer[0..n], buffer[0..n]);
+    return n;
+}
+
+fn fileHardLink(
+    userdata: ?*anyopaque,
+    file: File,
+    new_dir: Dir,
+    new_sub_path: []const u8,
+    options: File.HardLinkOptions,
+) File.HardLinkError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = file;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+fn linkat(
+    old_dir: c.fd_t,
+    old_path: [*:0]const u8,
+    new_dir: c.fd_t,
+    new_path: [*:0]const u8,
+    flags: u32,
+) File.HardLinkError!void {
+    while (true) switch (c.errno(c.linkat(old_dir, old_path, new_dir, new_path, flags))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .ACCES => return error.AccessDenied,
+        .DQUOT => return error.DiskQuota,
+        .EXIST => return error.PathAlreadyExists,
+        .IO => return error.HardwareFailure,
+        .LOOP => return error.SymLinkLoop,
+        .MLINK => return error.LinkQuotaExceeded,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOMEM => return error.SystemResources,
+        .NOSPC => return error.NoSpaceLeft,
+        .NOTDIR => return error.NotDir,
+        .PERM => return error.PermissionDenied,
+        .ROFS => return error.ReadOnlyFileSystem,
+        .XDEV => return error.CrossDevice,
+        .ILSEQ => return error.BadPathName,
+        .FAULT => |err| return errnoBug(err),
+        .INVAL => |err| return errnoBug(err),
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn fileMemoryMapCreate(
+    userdata: ?*anyopaque,
+    file: File,
+    options: File.MemoryMap.CreateOptions,
+) File.MemoryMap.CreateError!File.MemoryMap {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    const prot: c.PROT = .{
+        .READ = options.protection.read,
+        .WRITE = options.protection.write,
+        .EXEC = options.protection.execute,
+    };
+    const flags: c.MAP = .{
+        .TYPE = .SHARED,
+    };
+
+    const page_align = std.heap.page_size_min;
+
+    const contents = while (true) {
+        const casted_offset = std.math.cast(i64, options.offset) orelse return error.Unseekable;
+        const rc = c.mmap(null, options.len, prot, flags, file.handle, casted_offset);
+        const err: c.E = if (rc != c.MAP_FAILED) .SUCCESS else @enumFromInt(c._errno().*);
+        switch (err) {
+            .SUCCESS => break @as([*]align(page_align) u8, @ptrCast(@alignCast(rc)))[0..options.len],
+            .INTR => {},
+            .ACCES => return error.AccessDenied,
+            .AGAIN => return error.LockedMemoryLimitExceeded,
+            .MFILE => return error.ProcessFdQuotaExceeded,
+            .NFILE => return error.SystemFdQuotaExceeded,
+            .NOMEM => return error.OutOfMemory,
+            .PERM => return error.PermissionDenied,
+            .OVERFLOW => return error.Unseekable,
+            .BADF => return errnoBug(err), // Always a race condition.
+            .INVAL => return errnoBug(err), // Invalid parameters to mmap()
+            else => return unexpectedErrno(err),
+        }
+    };
+    return .{
+        .file = file,
+        .offset = options.offset,
+        .memory = contents,
+        .section = {},
+    };
+}
+
+fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const memory = mm.memory;
+    if (memory.len == 0) return;
+    switch (c.errno(c.munmap(memory.ptr, memory.len))) {
+        .SUCCESS => {},
+        else => |err| if (builtin.mode == .Debug)
+            std.log.err("failed to unmap {d} bytes at {*}: {t}", .{ memory.len, memory.ptr, err }),
+    }
+    mm.* = undefined;
+}
+
+fn fileMemoryMapSetLength(
+    userdata: ?*anyopaque,
+    mm: *File.MemoryMap,
+    new_len: usize,
+) File.MemoryMap.SetLengthError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+
+    const page_size = std.heap.pageSize();
+    const alignment: Alignment = .fromByteUnits(page_size);
+    const old_memory = mm.memory;
+
+    if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
+        mm.memory.len = new_len;
+        return;
+    }
+    return error.OperationUnsupported;
+}
+
+fn fileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = mm;
+}
+
+fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = mm;
+}
+
+fn processExecutableOpen(
+    userdata: ?*anyopaque,
+    flags: File.OpenFlags,
+) process.OpenExecutableError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    // _NSGetExecutablePath() returns a path that might be a symlink to
+    // the executable. Here it does not matter since we open it.
+    var symlink_path_buf: [c.PATH_MAX + 1]u8 = undefined;
+    var n: u32 = symlink_path_buf.len;
+    const rc = c._NSGetExecutablePath(&symlink_path_buf, &n);
+    if (rc != 0) return error.NameTooLong;
+    const symlink_path = std.mem.sliceTo(&symlink_path_buf, 0);
+    return dirOpenFile(ev, .cwd(), symlink_path, flags);
+}
+
+fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.ExecutablePathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    // _NSGetExecutablePath() returns a path that might be a symlink to
+    // the executable.
+    var symlink_path_buf: [c.PATH_MAX + 1]u8 = undefined;
+    var n: u32 = symlink_path_buf.len;
+    const rc = c._NSGetExecutablePath(&symlink_path_buf, &n);
+    if (rc != 0) return error.NameTooLong;
+    const symlink_path = std.mem.sliceTo(&symlink_path_buf, 0);
+    assert(Dir.path.isAbsolute(symlink_path));
+    return dirRealPathFile(ev, .cwd(), symlink_path, out_buffer) catch |err| switch (err) {
+        error.NetworkNotFound => unreachable, // Windows-only
+        error.FileBusy => unreachable, // Windows-only
+        else => |e| return e,
+    };
+}
+
+fn lockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    try ev.stderr_mutex.lock(ev);
+    errdefer ev.stderr_mutex.unlock();
+    return ev.initLockedStderr(terminal_mode);
+}
+
+fn tryLockStderr(
+    userdata: ?*anyopaque,
+    terminal_mode: ?Io.Terminal.Mode,
+) Io.Cancelable!?Io.LockedStderr {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (!ev.stderr_mutex.tryLock()) return null;
+    errdefer ev.stderr_mutex.unlock();
+    return try ev.initLockedStderr(terminal_mode);
+}
+
+fn initLockedStderr(ev: *Evented, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
+    ev.init_stderr_writer.once(ev, &initStderrWriter);
+    return .{
+        .file_writer = &ev.stderr_writer,
+        .terminal_mode = terminal_mode orelse ev.stderr_mode,
+    };
+}
+
+fn initStderrWriter(context: ?*anyopaque) callconv(.c) void {
+    const ev: *Evented = @ptrCast(@alignCast(context));
+    const cancel_protection = swapCancelProtection(ev, .blocked);
+    defer assert(swapCancelProtection(ev, cancel_protection) == .blocked);
+    ev.scan_environ.once(ev, &scanEnviron);
+    const NO_COLOR = ev.environ.exist.NO_COLOR;
+    const CLICOLOR_FORCE = ev.environ.exist.CLICOLOR_FORCE;
+    ev.stderr_mode = Io.Terminal.Mode.detect(
+        ev.io(),
+        ev.stderr_writer.file,
+        NO_COLOR,
+        CLICOLOR_FORCE,
+    ) catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
+    };
+}
+
+fn unlockStderr(userdata: ?*anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (ev.stderr_writer.err == null) ev.stderr_writer.interface.flush() catch {};
+    if (ev.stderr_writer.err) |err| {
+        switch (err) {
+            error.Canceled => Thread.current().currentFiber().cancel_protection.recancel(),
+            else => {},
+        }
+        ev.stderr_writer.err = null;
+    }
+    ev.stderr_writer.interface.end = 0;
+    ev.stderr_writer.interface.buffer.len = 0;
+    ev.stderr_mutex.unlock();
+}
+
+fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const err: c.E = if (c.getcwd(buffer.ptr, buffer.len)) |_| .SUCCESS else @enumFromInt(c._errno().*);
+    switch (err) {
+        .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
+        .NOENT => return error.CurrentDirUnlinked,
+        .RANGE => return error.NameTooLong,
+        .FAULT => |e| return errnoBug(e),
+        .INVAL => |e| return errnoBug(e),
+        else => return unexpectedErrno(err),
+    }
+}
+
+fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    if (dir.handle == c.AT.FDCWD) return;
+    while (true) switch (c.errno(c.fchdir(dir.handle))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .ACCES => return error.AccessDenied,
+        .NOTDIR => return error.NotDir,
+        .IO => return error.FileSystem,
+        .BADF => |err| return errnoBug(err),
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) ChdirError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    var path_buffer: [c.PATH_MAX]u8 = undefined;
+    const dir_path_posix = try pathToPosix(dir_path, &path_buffer);
+    while (true) switch (c.errno(c.chdir(dir_path_posix))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .ACCES => return error.AccessDenied,
+        .IO => return error.FileSystem,
+        .LOOP => return error.SymLinkLoop,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOMEM => return error.SystemResources,
+        .NOTDIR => return error.NotDir,
+        .ILSEQ => return error.BadPathName,
+        .FAULT => |err| return errnoBug(err),
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    if (!process.can_replace) return error.OperationUnsupported;
+
+    ev.scan_environ.once(ev, &scanEnviron); // for PATH
+    const PATH = ev.environ.string.PATH orelse default_PATH;
+
+    var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
+    defer arena_allocator.deinit();
+    const arena = arena_allocator.allocator();
+
+    const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+
+    const env_block = env_block: {
+        const prog_fd: i32 = -1;
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+        break :env_block try ev.environ.process_environ.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+    };
+
+    return ev.execv(options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
+}
+
+fn processReplacePath(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    options: process.ReplaceOptions,
+) process.ReplaceError {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = dir;
+    _ = options;
+    @panic("TODO processReplacePath");
+}
+
+fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    const spawned = try ev.spawn(options);
+    defer fileClose(ev, &.{spawned.err_pipe});
+
+    // Wait for the child to report any errors in or before `execvpe`.
+    var child_err: ForkBailError = undefined;
+    ev.readAll(spawned.err_pipe, @ptrCast(&child_err)) catch |read_err| {
+        switch (read_err) {
+            error.Canceled => unreachable, // blocked
+            error.EndOfStream => {
+                // Write end closed by CLOEXEC at the time of the `execvpe` call,
+                // indicating success.
+            },
+            else => {
+                // Problem reading the error from the error reporting pipe. We
+                // don't know if the child is alive or dead. Better to assume it is
+                // alive so the resource does not risk being leaked.
+            },
+        }
+        return .{
+            .id = spawned.pid,
+            .thread_handle = {},
+            .stdin = spawned.stdin,
+            .stdout = spawned.stdout,
+            .stderr = spawned.stderr,
+            .request_resource_usage_statistics = options.request_resource_usage_statistics,
+        };
+    };
+    return child_err;
+}
+
+fn processSpawnPath(
+    userdata: ?*anyopaque,
+    dir: Dir,
+    options: process.SpawnOptions,
+) process.SpawnError!process.Child {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = dir;
+    _ = options;
+    @panic("TODO processSpawnPath");
+}
+
+const prog_fileno = @max(c.STDIN_FILENO, c.STDOUT_FILENO, c.STDERR_FILENO) + 1;
+
+const Spawned = struct {
+    pid: c.pid_t,
+    err_pipe: File,
+    stdin: ?File,
+    stdout: ?File,
+    stderr: ?File,
+};
+fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned {
+    // The child process does need to access (one end of) these pipes. However,
+    // we must initially set CLOEXEC to avoid a race condition. If another thread
+    // is racing to spawn a different child process, we don't want it to inherit
+    // these FDs in any scenario; that would mean that, for instance, calls to
+    // `poll` from the parent would not report the child's stdout as closing when
+    // expected, since the other child may retain a reference to the write end of
+    // the pipe. So, we create the pipes with CLOEXEC initially. After fork, we
+    // need to do something in the new child to make sure we preserve the reference
+    // we want. We could use `fcntl` to remove CLOEXEC from the FD, but as it
+    // turns out, we `dup2` everything anyway, so there's no need!
+    const pipe_flags: c.O = .{ .CLOEXEC = true };
+
+    const stdin_pipe = if (options.stdin == .pipe) try pipe2(pipe_flags) else undefined;
+    errdefer if (options.stdin == .pipe) {
+        destroyPipe(stdin_pipe);
+    };
+
+    const stdout_pipe = if (options.stdout == .pipe) try pipe2(pipe_flags) else undefined;
+    errdefer if (options.stdout == .pipe) {
+        destroyPipe(stdout_pipe);
+    };
+
+    const stderr_pipe = if (options.stderr == .pipe) try pipe2(pipe_flags) else undefined;
+    errdefer if (options.stderr == .pipe) {
+        destroyPipe(stderr_pipe);
+    };
+
+    const any_ignore =
+        options.stdin == .ignore or options.stdout == .ignore or options.stderr == .ignore;
+    const dev_null_file = if (any_ignore) dev_null_file: {
+        ev.open_dev_null.once(ev, &openDevNullFile);
+        break :dev_null_file try ev.dev_null_file;
+    } else undefined;
+
+    const prog_pipe: [2]c.fd_t = if (options.progress_node.index != .none)
+        // We use CLOEXEC for the same reason as in `pipe_flags`.
+        try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true })
+    else
+        .{ -1, -1 };
+    errdefer destroyPipe(prog_pipe);
+
+    var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
+    defer arena_allocator.deinit();
+    const arena = arena_allocator.allocator();
+
+    // The POSIX standard does not allow malloc() between fork() and execve(),
+    // and this allocator may be a libc allocator.
+    // I have personally observed the child process deadlocking when it tries
+    // to call malloc() due to a heap allocation between fork() and execve(),
+    // in musl v1.1.24.
+    // Additionally, we want to reduce the number of possible ways things
+    // can fail between fork() and execve().
+    // Therefore, we do all the allocation for the execve() before the fork().
+    // This means we must do the null-termination of argv and env vars here.
+    const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+
+    const env_block = env_block: {
+        const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;
+        if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+        break :env_block try ev.environ.process_environ.createPosixBlock(arena, .{
+            .zig_progress_fd = prog_fd,
+        });
+    };
+
+    // This pipe communicates to the parent errors in the child between `fork` and `execvpe`.
+    // It is closed by the child (via CLOEXEC) without writing if `execvpe` succeeds.
+    const err_pipe: [2]File = err_pipe: {
+        const err_pipe = try pipe2(.{ .CLOEXEC = true });
+        break :err_pipe .{
+            .{ .handle = err_pipe[0], .flags = .{ .nonblocking = false } },
+            .{ .handle = err_pipe[1], .flags = .{ .nonblocking = false } },
+        };
+    };
+    errdefer fileClose(ev, &err_pipe);
+
+    ev.scan_environ.once(ev, &scanEnviron); // for PATH
+    const PATH = ev.environ.string.PATH orelse default_PATH;
+
+    const pid_result: c.pid_t = fork: {
+        const rc = c.fork();
+        switch (c.errno(rc)) {
+            .SUCCESS => break :fork @intCast(rc),
+            .AGAIN => return error.SystemResources,
+            .NOMEM => return error.SystemResources,
+            .NOSYS => return error.OperationUnsupported,
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+
+    if (pid_result == 0) {
+        defer comptime unreachable; // We are the child.
+        const err = ev.setUpChild(.{
+            .stdin_pipe = stdin_pipe[0],
+            .stdout_pipe = stdout_pipe[1],
+            .stderr_pipe = stderr_pipe[1],
+            .dev_null_fd = dev_null_file.handle,
+            .prog_pipe = prog_pipe[1],
+            .argv_buf = argv_buf,
+            .env_block = env_block,
+            .PATH = PATH,
+            .spawn = options,
+        });
+        ev.writeAll(err_pipe[1], @ptrCast(&err)) catch {};
+        c.exit(1);
+    }
+
+    const pid: c.pid_t = @intCast(pid_result); // We are the parent.
+    errdefer comptime unreachable; // The child is forked; we must not error from now on
+
+    fileClose(ev, err_pipe[1..2]); // make sure only the child holds the write end open
+
+    if (options.stdin == .pipe) closeFd(stdin_pipe[0]);
+    if (options.stdout == .pipe) closeFd(stdout_pipe[1]);
+    if (options.stderr == .pipe) closeFd(stderr_pipe[1]);
+
+    if (prog_pipe[1] != -1) closeFd(prog_pipe[1]);
+
+    options.progress_node.setIpcFile(ev, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
+
+    return .{
+        .pid = pid,
+        .err_pipe = err_pipe[0],
+        .stdin = switch (options.stdin) {
+            .pipe => .{ .handle = stdin_pipe[1], .flags = .{ .nonblocking = false } },
+            else => null,
+        },
+        .stdout = switch (options.stdout) {
+            .pipe => .{ .handle = stdout_pipe[0], .flags = .{ .nonblocking = false } },
+            else => null,
+        },
+        .stderr = switch (options.stderr) {
+            .pipe => .{ .handle = stderr_pipe[0], .flags = .{ .nonblocking = false } },
+            else => null,
+        },
+    };
+}
+
+fn openDevNullFile(context: ?*anyopaque) callconv(.c) void {
+    const ev: *Evented = @ptrCast(@alignCast(context));
+    ev.dev_null_file = dirOpenFile(ev, .cwd(), "/dev/null", .{ .mode = .read_write });
+}
+
+/// Errors that can occur between fork() and execv()
+const ForkBailError = process.SetCurrentDirError || ChdirError ||
+    process.SpawnError || process.ReplaceError;
+fn setUpChild(ev: *Evented, options: struct {
+    stdin_pipe: c.fd_t,
+    stdout_pipe: c.fd_t,
+    stderr_pipe: c.fd_t,
+    dev_null_fd: c.fd_t,
+    prog_pipe: c.fd_t,
+    argv_buf: [:null]?[*:0]const u8,
+    env_block: process.Environ.Block,
+    PATH: []const u8,
+    spawn: process.SpawnOptions,
+}) ForkBailError {
+    try ev.setUpChildIo(
+        options.spawn.stdin,
+        options.stdin_pipe,
+        c.STDIN_FILENO,
+        options.dev_null_fd,
+    );
+    try ev.setUpChildIo(
+        options.spawn.stdout,
+        options.stdout_pipe,
+        c.STDOUT_FILENO,
+        options.dev_null_fd,
+    );
+    try ev.setUpChildIo(
+        options.spawn.stderr,
+        options.stderr_pipe,
+        c.STDERR_FILENO,
+        options.dev_null_fd,
+    );
+
+    switch (options.spawn.cwd) {
+        .inherit => {},
+        .dir => |cwd_dir| try processSetCurrentDir(ev, cwd_dir),
+        .path => |cwd_path| try processSetCurrentPath(ev, cwd_path),
+    }
+
+    // Must happen after fchdir above, the cwd file descriptor might be
+    // equal to prog_fileno and be clobbered by this dup2 call.
+    if (options.prog_pipe != -1) try ev.dup2(options.prog_pipe, prog_fileno);
+
+    if (options.spawn.gid) |gid| while (true) switch (c.errno(c.setregid(gid, gid))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .AGAIN => return error.ResourceLimitReached,
+        .INVAL => return error.InvalidUserId,
+        .PERM => return error.PermissionDenied,
+        else => return error.Unexpected,
+    };
+
+    if (options.spawn.uid) |uid| while (true) switch (c.errno(c.setreuid(uid, uid))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .AGAIN => return error.ResourceLimitReached,
+        .INVAL => return error.InvalidUserId,
+        .PERM => return error.PermissionDenied,
+        else => return error.Unexpected,
+    };
+
+    if (options.spawn.pgid) |pid| while (true) switch (c.errno(c.setpgid(0, pid))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .ACCES => return error.ProcessAlreadyExec,
+        .INVAL => return error.InvalidProcessGroupId,
+        .PERM => return error.PermissionDenied,
+        else => return error.Unexpected,
+    };
+
+    if (options.spawn.start_suspended) while (true) switch (c.errno(c.kill(0, .STOP))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .PERM => return error.PermissionDenied,
+        else => return error.Unexpected,
+    };
+
+    return ev.execv(
+        options.spawn.expand_arg0,
+        options.argv_buf.ptr[0].?,
+        options.argv_buf.ptr,
+        options.env_block,
+        options.PATH,
+    );
+}
+
+fn setUpChildIo(
+    ev: *Evented,
+    stdio: process.SpawnOptions.StdIo,
+    pipe_fd: c.fd_t,
+    std_fileno: i32,
+    dev_null_fd: c.fd_t,
+) !void {
+    switch (stdio) {
+        .pipe => try ev.dup2(pipe_fd, std_fileno),
+        .close => closeFd(std_fileno),
+        .inherit => {},
+        .ignore => try ev.dup2(dev_null_fd, std_fileno),
+        .file => |file| {
+            if (file.flags.nonblocking) @panic("TODO implement setUpChildIo when nonblocking file is used");
+            try ev.dup2(file.handle, std_fileno);
+        },
+    }
+}
+
+const PipeError = error{
+    SystemFdQuotaExceeded,
+    ProcessFdQuotaExceeded,
+} || Io.UnexpectedError;
+
+fn pipe2(flags: c.O) PipeError![2]c.fd_t {
+    var fds: [2]c.fd_t = undefined;
+
+    while (true) switch (c.errno(c.pipe(&fds))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .NFILE => return error.SystemFdQuotaExceeded,
+        .MFILE => return error.ProcessFdQuotaExceeded,
+        else => |err| return unexpectedErrno(err),
+    };
+    errdefer {
+        closeFd(fds[0]);
+        closeFd(fds[1]);
+    }
+
+    // https://github.com/ziglang/zig/issues/18882
+    if (@as(u32, @bitCast(flags)) == 0) return fds;
+
+    // CLOEXEC is special, it's a file descriptor flag and must be set using
+    // F.SETFD.
+    if (flags.CLOEXEC) for (fds) |fd| while (true) switch (c.errno(c.fcntl(fd, c.F.SETFD, @as(u32, c.FD_CLOEXEC)))) {
+        .SUCCESS => break,
+        .INTR => {},
+        else => |err| return unexpectedErrno(err),
+    };
+
+    const new_flags: u32 = f: {
+        var new_flags = flags;
+        new_flags.CLOEXEC = false;
+        break :f @bitCast(new_flags);
+    };
+
+    // Set every other flag affecting the file status using F.SETFL.
+    if (new_flags != 0) for (fds) |fd| while (true) switch (c.errno(c.fcntl(fd, c.F.SETFL, new_flags))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .INVAL => |err| return errnoBug(err),
+        else => |err| return unexpectedErrno(err),
+    };
+
+    return fds;
+}
+
+fn destroyPipe(pipe: [2]c.fd_t) void {
+    if (pipe[0] != -1) closeFd(pipe[0]);
+    if (pipe[0] != pipe[1]) closeFd(pipe[1]);
+}
+
+const DupError = error{
+    ProcessFdQuotaExceeded,
+    SystemResources,
+} || Io.UnexpectedError || Io.Cancelable;
+fn dup2(ev: *Evented, old_fd: c.fd_t, new_fd: c.fd_t) DupError!void {
+    _ = ev;
+    while (true) switch (c.errno(c.dup2(old_fd, new_fd))) {
+        .SUCCESS => return,
+        .BUSY, .INTR => {},
+        .INVAL => |err| return errnoBug(err), // invalid parameters
+        .BADF => |err| return errnoBug(err), // use after free
+        .MFILE => return error.ProcessFdQuotaExceeded,
+        .NOMEM => return error.SystemResources,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn execv(
+    ev: *Evented,
+    arg0_expand: process.ArgExpansion,
+    file: [*:0]const u8,
+    child_argv: [*:null]?[*:0]const u8,
+    env_block: process.Environ.PosixBlock,
+    PATH: []const u8,
+) process.ReplaceError {
+    const file_slice = std.mem.sliceTo(file, 0);
+    if (std.mem.findScalar(u8, file_slice, '/') != null) return ev.execvPath(file, child_argv, env_block);
+
+    // Use of PATH_MAX here is valid as the path_buf will be passed
+    // directly to the operating system in posixExecvPath.
+    var path_buf: [c.PATH_MAX]u8 = undefined;
+    var it = std.mem.tokenizeScalar(u8, PATH, ':');
+    var seen_eacces = false;
+    var err: process.ReplaceError = error.FileNotFound;
+
+    // In case of expanding arg0 we must put it back if we return with an error.
+    const prev_arg0 = child_argv[0];
+    defer switch (arg0_expand) {
+        .expand => child_argv[0] = prev_arg0,
+        .no_expand => {},
+    };
+
+    while (it.next()) |search_path| {
+        const path_len = search_path.len + file_slice.len + 1;
+        if (path_buf.len < path_len + 1) return error.NameTooLong;
+        @memcpy(path_buf[0..search_path.len], search_path);
+        path_buf[search_path.len] = '/';
+        @memcpy(path_buf[search_path.len + 1 ..][0..file_slice.len], file_slice);
+        path_buf[path_len] = 0;
+        const full_path = path_buf[0..path_len :0].ptr;
+        switch (arg0_expand) {
+            .expand => child_argv[0] = full_path,
+            .no_expand => {},
+        }
+        err = ev.execvPath(full_path, child_argv, env_block);
+        switch (err) {
+            error.AccessDenied => seen_eacces = true,
+            error.FileNotFound, error.NotDir => {},
+            else => |e| return e,
+        }
+    }
+    if (seen_eacces) return error.AccessDenied;
+    return err;
+}
+/// This function ignores PATH environment variable.
+fn execvPath(
+    ev: *Evented,
+    path: [*:0]const u8,
+    child_argv: [*:null]const ?[*:0]const u8,
+    env_block: process.Environ.PosixBlock,
+) process.ReplaceError {
+    _ = ev;
+    switch (c.errno(c.execve(path, child_argv, env_block.slice.ptr))) {
+        .FAULT => |err| return errnoBug(err), // Bad pointer parameter.
+        .@"2BIG" => return error.SystemResources,
+        .MFILE => return error.ProcessFdQuotaExceeded,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NFILE => return error.SystemFdQuotaExceeded,
+        .NOMEM => return error.SystemResources,
+        .ACCES => return error.AccessDenied,
+        .PERM => return error.PermissionDenied,
+        .INVAL => return error.InvalidExe,
+        .NOEXEC => return error.InvalidExe,
+        .IO => return error.FileSystem,
+        .LOOP => return error.FileSystem,
+        .ISDIR => return error.IsDir,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.NotDir,
+        .TXTBSY => return error.FileBusy,
+        .BADEXEC => return error.InvalidExe,
+        .BADARCH => return error.InvalidExe,
+        else => |err| return unexpectedErrno(err),
+    }
+}
+
+fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitError!process.Child.Term {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    defer ev.childCleanup(child);
+    const pid = child.id.?;
+    const source = c.dispatch.source_create(
+        .PROC,
+        @bitCast(@as(isize, pid)),
+        .{ .PROC = .{ .EXIT = true } },
+        ev.queue,
+    ) orelse return error.Unexpected;
+    source.as_object().set_context(Thread.current().currentFiber());
+    source.set_event_handler(&Fiber.@"resume");
+    ev.yield(.{ .activate = source.as_object() });
+    source.as_object().release();
+    var status: c_int = undefined;
+    var ru: c.rusage = undefined;
+    const ru_ptr = if (child.request_resource_usage_statistics) &ru else null;
+    while (true) switch (c.errno(c.wait4(pid, &status, 0, ru_ptr))) {
+        .SUCCESS => {
+            if (ru_ptr) |p| child.resource_usage_statistics.rusage = p.*;
+            return statusToTerm(@bitCast(status));
+        },
+        .INTR => {},
+        .CHILD => |err| return errnoBug(err), // Double-free.
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    defer ev.childCleanup(child);
+    const pid = child.id.?;
+    while (true) switch (c.errno(c.kill(pid, .TERM))) {
+        .SUCCESS => break,
+        .INTR => {},
+        .PERM => return,
+        .INVAL => |err| errnoBug(err) catch return,
+        .SRCH => |err| errnoBug(err) catch return,
+        else => |err| unexpectedErrno(err) catch return,
+    };
+    var status: c_int = undefined;
+    while (true) switch (c.errno(c.wait4(pid, &status, 0, null))) {
+        .SUCCESS => return,
+        .INTR => {},
+        .CHILD => |err| errnoBug(err) catch return, // Double-free.
+        else => |err| unexpectedErrno(err) catch return,
+    };
+}
+
+fn childCleanup(ev: *Evented, child: *process.Child) void {
+    if (child.stdin) |stdin| {
+        fileClose(ev, &.{stdin});
+        child.stdin = null;
+    }
+    if (child.stdout) |stdout| {
+        fileClose(ev, &.{stdout});
+        child.stdout = null;
+    }
+    if (child.stderr) |stderr| {
+        fileClose(ev, &.{stderr});
+        child.stderr = null;
+    }
+    child.id = null;
+}
+
+fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.scan_environ.once(ev, &scanEnviron);
+    return ev.environ.zig_progress_file;
+}
+
+fn scanEnviron(context: ?*anyopaque) callconv(.c) void {
+    const ev: *Evented = @ptrCast(@alignCast(context));
+    ev.environ.scan(ev.allocator());
+}
+
+fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Timestamp {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const clock_id: c.clockid_t = clockToPosix(clock);
+    var timespec: c.timespec = undefined;
+    switch (c.errno(c.clock_gettime(clock_id, &timespec))) {
+        .SUCCESS => return timestampFromPosix(&timespec),
+        else => return .zero,
+    }
+}
+
+fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const clock_id: c.clockid_t = clockToPosix(clock);
+    var timespec: c.timespec = undefined;
+    return switch (c.errno(c.clock_getres(clock_id, &timespec))) {
+        .SUCCESS => .fromNanoseconds(nanosecondsFromPosix(&timespec)),
+        .INVAL => return error.ClockUnavailable,
+        else => |err| return unexpectedErrno(err),
+    };
+}
+
+fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    ev.yield(.{ .sleep = ev.timeFromTimeout(timeout) });
+}
+
+fn timeFromTimeout(ev: *Evented, timeout: Io.Timeout) c.dispatch.time_t {
+    return timeout: switch (timeout) {
+        .none => .FOREVER,
+        .duration => |duration| .time(switch (duration.clock) {
+            .real => .WALL_NOW,
+            else => .NOW,
+        }, std.math.lossyCast(i64, duration.raw.toNanoseconds())),
+        .deadline => |deadline| switch (deadline.clock) {
+            .real => .walltime(&.{
+                .sec = @intCast(@divFloor(deadline.raw.toNanoseconds(), std.time.ns_per_s)),
+                .nsec = @intCast(@mod(deadline.raw.toNanoseconds(), std.time.ns_per_s)),
+            }, 0),
+            else => continue :timeout .{ .duration = deadline.durationFromNow(ev.io()) },
+        },
+    };
+}
+
+const Random = struct {
+    evented: *Evented,
+    thread: *Thread,
+    buffer: []u8,
+
+    fn seed(context: ?*anyopaque) callconv(.c) void {
+        const rand: *Random = @ptrCast(@alignCast(context));
+        const ev = rand.evented;
+        ev.csprng_mutex.lockUncancelable(ev);
+        defer ev.csprng_mutex.unlock();
+        var buffer: [Csprng.seed_len]u8 = undefined;
+        if (!ev.csprng.isInitialized()) {
+            @branchHint(.unlikely);
+            const cancel_protection = swapCancelProtection(ev, .blocked);
+            defer assert(swapCancelProtection(ev, cancel_protection) == .blocked);
+            randomSecure(ev, &buffer) catch |err| switch (err) {
+                error.Canceled => unreachable, // blocked
+                error.EntropyUnavailable => fallbackSeed(ev, &buffer),
+            };
+            ev.csprng.rng = .init(buffer);
+        }
+        ev.csprng.rng.fill(&buffer);
+        rand.thread.csprng.rng = .init(buffer);
+        rand.thread.csprng.rng.fill(rand.buffer);
+        rand.buffer.len = 0;
+    }
+};
+
+fn random(userdata: ?*anyopaque, buffer: []u8) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    if (buffer.len == 0) return;
+    const thread: *Thread = .current();
+    var rand: Random = .{ .evented = ev, .thread = thread, .buffer = buffer };
+    thread.seed_csprng.once(&rand, &Random.seed);
+    if (rand.buffer.len > 0) thread.csprng.rng.fill(buffer);
+}
+
+fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    if (buffer.len > 0) c.arc4random_buf(buffer.ptr, buffer.len);
+}
+
+fn netListenIpUnavailable(
+    userdata: ?*anyopaque,
+    address: net.IpAddress,
+    options: net.IpAddress.ListenOptions,
+) net.IpAddress.ListenError!net.Server {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+fn netAcceptUnavailable(
+    userdata: ?*anyopaque,
+    listen_handle: net.Socket.Handle,
+) net.Server.AcceptError!net.Stream {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = listen_handle;
+    return error.NetworkDown;
+}
+
+fn netBindIpUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.IpAddress,
+    options: net.IpAddress.BindOptions,
+) net.IpAddress.BindError!net.Socket {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+fn netConnectIpUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.IpAddress,
+    options: net.IpAddress.ConnectOptions,
+) net.IpAddress.ConnectError!net.Stream {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+fn netListenUnixUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.UnixAddress,
+    options: net.UnixAddress.ListenOptions,
+) net.UnixAddress.ListenError!net.Socket.Handle {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    _ = options;
+    return error.AddressFamilyUnsupported;
+}
+
+fn netConnectUnixUnavailable(
+    userdata: ?*anyopaque,
+    address: *const net.UnixAddress,
+) net.UnixAddress.ConnectError!net.Socket.Handle {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = address;
+    return error.AddressFamilyUnsupported;
+}
+
+fn netSocketCreatePairUnavailable(
+    userdata: ?*anyopaque,
+    options: net.Socket.CreatePairOptions,
+) net.Socket.CreatePairError![2]net.Socket {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+fn netSendUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    messages: []net.OutgoingMessage,
+    flags: net.SendFlags,
+) struct { ?net.Socket.SendError, usize } {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = messages;
+    _ = flags;
+    return .{ error.NetworkDown, 0 };
+}
+
+fn netReceiveUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    message_buffer: []net.IncomingMessage,
+    data_buffer: []u8,
+    flags: net.ReceiveFlags,
+    timeout: Io.Timeout,
+) struct { ?net.Socket.ReceiveTimeoutError, usize } {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = message_buffer;
+    _ = data_buffer;
+    _ = flags;
+    _ = timeout;
+    return .{ error.NetworkDown, 0 };
+}
+
+fn netReadUnavailable(
+    userdata: ?*anyopaque,
+    fd: net.Socket.Handle,
+    data: [][]u8,
+) net.Stream.Reader.Error!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = fd;
+    _ = data;
+    return error.NetworkDown;
+}
+
+fn netWriteUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    header: []const u8,
+    data: []const []const u8,
+    splat: usize,
+) net.Stream.Writer.Error!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = header;
+    _ = data;
+    _ = splat;
+    return error.NetworkDown;
+}
+
+fn netWriteFileUnavailable(
+    userdata: ?*anyopaque,
+    socket_handle: net.Socket.Handle,
+    header: []const u8,
+    file_reader: *File.Reader,
+    limit: Io.Limit,
+) net.Stream.Writer.WriteFileError!usize {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = socket_handle;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.NetworkDown;
+}
+
+fn netClose(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    for (handles) |handle| closeFd(handle);
+}
+
+fn netShutdownUnavailable(
+    userdata: ?*anyopaque,
+    handle: net.Socket.Handle,
+    how: net.ShutdownHow,
+) net.ShutdownError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = handle;
+    _ = how;
+    unreachable; // How you gonna shutdown something that was impossible to open?
+}
+
+fn netInterfaceNameResolveUnavailable(
+    userdata: ?*anyopaque,
+    name: *const net.Interface.Name,
+) net.Interface.Name.ResolveError!net.Interface {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = name;
+    return error.InterfaceNotFound;
+}
+
+fn netInterfaceNameUnavailable(
+    userdata: ?*anyopaque,
+    interface: net.Interface,
+) net.Interface.NameError!net.Interface.Name {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = interface;
+    return error.Unexpected;
+}
+
+fn netLookupUnavailable(
+    userdata: ?*anyopaque,
+    host_name: net.HostName,
+    resolved: *Io.Queue(net.HostName.LookupResult),
+    options: net.HostName.LookupOptions,
+) net.HostName.LookupError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = host_name;
+    _ = options;
+    resolved.close(ev.io());
+    return error.NetworkDown;
+}
+
+fn readAll(ev: *Evented, file: File, buffer: []u8) File.ReadStreamingError!void {
+    var index: usize = 0;
+    while (buffer.len - index != 0) {
+        const len = try ev.fileReadStreaming(file, &.{buffer[index..]});
+        if (len == 0) return error.EndOfStream;
+        index += len;
+    }
+}
+
+fn writeAll(ev: *Evented, file: File, buffer: []const u8) (File.Writer.Error || error{EndOfStream})!void {
+    var index: usize = 0;
+    while (buffer.len - index != 0) {
+        const len = try ev.fileWriteStreaming(file, &.{}, &.{buffer[index..]}, 1);
+        if (len == 0) return error.EndOfStream;
+        index += len;
+    }
+}
+
+/// This is either usize or u32. Since, either is fine, let's use the same
+/// `addBuf` function for both writing to a file and sending network messages.
+const iovlen_t = @FieldType(c.msghdr_const, "iovlen");
+
+fn addConstBuf(v: []iovec_const, i: *iovlen_t, remaining: ?*usize, bytes: []const u8) void {
+    if (v.len - i.* == 0) return;
+    const len = @min(remaining.*, bytes.len);
+    if (len == 0) return;
+    v[i.*] = .{ .base = bytes.ptr, .len = len };
+    i.* += 1;
+    remaining.* -= len;
+}
+fn addBuf(
+    comptime is_const: bool,
+    vec: []if (is_const) iovec_const else iovec,
+    vec_len: *iovlen_t,
+    remaining: *Io.Limit,
+    bytes: if (is_const) []const u8 else []u8,
+) void {
+    if (vec.len - vec_len.* == 0) return;
+    const len = remaining.minInt(bytes.len);
+    if (len == 0) return;
+    vec[vec_len.*] = .{ .base = bytes.ptr, .len = len };
+    vec_len.* += 1;
+    remaining.* = remaining.subtract(len).?;
+}
+
+test {
+    _ = Fiber.CancelProtection;
+}
diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig
index 3c9a0cbe1ca569e9d71184617d5fdb822d1f7a25..863bb0c22a8bfa6045da678910e8dea170792c0b 100644
--- a/lib/std/Io/Kqueue.zig
+++ b/lib/std/Io/Kqueue.zig
@@ -31,8 +31,8 @@ const changes_buffer_len = 64;
 
 const Thread = struct {
     thread: std.Thread,
-    idle_context: Context,
-    current_context: *Context,
+    idle_context: Io.fiber.Context,
+    current_context: *Io.fiber.Context,
     ready_queue: ?*Fiber,
     kq_fd: posix.fd_t,
     idle_search_index: u32,
@@ -74,7 +74,7 @@ const Thread = struct {
 
 const Fiber = struct {
     required_align: void align(4),
-    context: Context,
+    context: Io.fiber.Context,
     awaiter: ?*Fiber,
     queue_next: ?*Fiber,
     cancel_thread: ?*Thread,
@@ -291,12 +291,12 @@ fn yield(k: *Kqueue, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.Pen
         &thread.idle_context;
     const message: SwitchMessage = .{
         .contexts = .{
-            .prev = thread.current_context,
-            .ready = ready_context,
+            .old = thread.current_context,
+            .new = ready_context,
         },
         .pending_task = pending_task,
     };
-    std.log.debug("switching from {*} to {*}", .{ message.contexts.prev, message.contexts.ready });
+    std.log.debug("switching from {*} to {*}", .{ message.contexts.old, message.contexts.new });
     contextSwitch(&message).handle(k);
 }
 
@@ -393,7 +393,7 @@ fn schedule(k: *Kqueue, thread: *Thread, ready_queue: Fiber.Queue) void {
     )) |old_head| ready_queue.tail.queue_next = old_head;
 }
 
-fn mainIdle(k: *Kqueue, message: *const SwitchMessage) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Context)))) noreturn {
+fn mainIdle(k: *Kqueue, message: *const SwitchMessage) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Io.fiber.Context)))) noreturn {
     message.handle(k);
     k.idle(&k.threads.allocated[0]);
     k.yield(@ptrCast(&k.main_fiber_buffer), .nothing);
@@ -483,10 +483,7 @@ fn idle(k: *Kqueue, thread: *Thread) void {
 }
 
 const SwitchMessage = struct {
-    contexts: extern struct {
-        prev: *Context,
-        ready: *Context,
-    },
+    contexts: Io.fiber.Switch,
     pending_task: PendingTask,
 
     const PendingTask = union(enum) {
@@ -500,11 +497,11 @@ const SwitchMessage = struct {
 
     fn handle(message: *const SwitchMessage, k: *Kqueue) void {
         const thread: *Thread = .current();
-        thread.current_context = message.contexts.ready;
+        thread.current_context = message.contexts.new;
         switch (message.pending_task) {
             .nothing => {},
-            .reschedule => if (message.contexts.prev != &thread.idle_context) {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+            .reschedule => if (message.contexts.old != &thread.idle_context) {
+                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 assert(prev_fiber.queue_next == null);
                 k.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
             },
@@ -512,13 +509,13 @@ const SwitchMessage = struct {
                 k.recycle(fiber);
             },
             .register_awaiter => |awaiter| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 assert(prev_fiber.queue_next == null);
                 if (@atomicRmw(?*Fiber, awaiter, .Xchg, prev_fiber, .acq_rel) == Fiber.finished)
                     k.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
             },
             .register_select => |futures| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 assert(prev_fiber.queue_next == null);
                 for (futures) |any_future| {
                     const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
@@ -550,195 +547,8 @@ const SwitchMessage = struct {
     }
 };
 
-const Context = switch (builtin.cpu.arch) {
-    .aarch64 => extern struct {
-        sp: u64,
-        fp: u64,
-        pc: u64,
-    },
-    .x86_64 => extern struct {
-        rsp: u64,
-        rbp: u64,
-        rip: u64,
-    },
-    else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
-};
-
 inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage {
-    return @fieldParentPtr("contexts", switch (builtin.cpu.arch) {
-        .aarch64 => asm volatile (
-            \\ ldp x0, x2, [x1]
-            \\ ldr x3, [x2, #16]
-            \\ mov x4, sp
-            \\ stp x4, fp, [x0]
-            \\ adr x5, 0f
-            \\ ldp x4, fp, [x2]
-            \\ str x5, [x0, #16]
-            \\ mov sp, x4
-            \\ br x3
-            \\0:
-            : [received_message] "={x1}" (-> *const @FieldType(SwitchMessage, "contexts")),
-            : [message_to_send] "{x1}" (&message.contexts),
-            : .{
-              .x0 = true,
-              .x1 = true,
-              .x2 = true,
-              .x3 = true,
-              .x4 = true,
-              .x5 = true,
-              .x6 = true,
-              .x7 = true,
-              .x8 = true,
-              .x9 = true,
-              .x10 = true,
-              .x11 = true,
-              .x12 = true,
-              .x13 = true,
-              .x14 = true,
-              .x15 = true,
-              .x16 = true,
-              .x17 = true,
-              .x19 = true,
-              .x20 = true,
-              .x21 = true,
-              .x22 = true,
-              .x23 = true,
-              .x24 = true,
-              .x25 = true,
-              .x26 = true,
-              .x27 = true,
-              .x28 = true,
-              .x30 = true,
-              .z0 = true,
-              .z1 = true,
-              .z2 = true,
-              .z3 = true,
-              .z4 = true,
-              .z5 = true,
-              .z6 = true,
-              .z7 = true,
-              .z8 = true,
-              .z9 = true,
-              .z10 = true,
-              .z11 = true,
-              .z12 = true,
-              .z13 = true,
-              .z14 = true,
-              .z15 = true,
-              .z16 = true,
-              .z17 = true,
-              .z18 = true,
-              .z19 = true,
-              .z20 = true,
-              .z21 = true,
-              .z22 = true,
-              .z23 = true,
-              .z24 = true,
-              .z25 = true,
-              .z26 = true,
-              .z27 = true,
-              .z28 = true,
-              .z29 = true,
-              .z30 = true,
-              .z31 = true,
-              .p0 = true,
-              .p1 = true,
-              .p2 = true,
-              .p3 = true,
-              .p4 = true,
-              .p5 = true,
-              .p6 = true,
-              .p7 = true,
-              .p8 = true,
-              .p9 = true,
-              .p10 = true,
-              .p11 = true,
-              .p12 = true,
-              .p13 = true,
-              .p14 = true,
-              .p15 = true,
-              .fpcr = true,
-              .fpsr = true,
-              .ffr = true,
-              .memory = true,
-            }),
-        .x86_64 => asm volatile (
-            \\ movq 0(%%rsi), %%rax
-            \\ movq 8(%%rsi), %%rcx
-            \\ leaq 0f(%%rip), %%rdx
-            \\ movq %%rsp, 0(%%rax)
-            \\ movq %%rbp, 8(%%rax)
-            \\ movq %%rdx, 16(%%rax)
-            \\ movq 0(%%rcx), %%rsp
-            \\ movq 8(%%rcx), %%rbp
-            \\ jmpq *16(%%rcx)
-            \\0:
-            : [received_message] "={rsi}" (-> *const @FieldType(SwitchMessage, "contexts")),
-            : [message_to_send] "{rsi}" (&message.contexts),
-            : .{
-              .rax = true,
-              .rcx = true,
-              .rdx = true,
-              .rbx = true,
-              .rsi = true,
-              .rdi = true,
-              .r8 = true,
-              .r9 = true,
-              .r10 = true,
-              .r11 = true,
-              .r12 = true,
-              .r13 = true,
-              .r14 = true,
-              .r15 = true,
-              .mm0 = true,
-              .mm1 = true,
-              .mm2 = true,
-              .mm3 = true,
-              .mm4 = true,
-              .mm5 = true,
-              .mm6 = true,
-              .mm7 = true,
-              .zmm0 = true,
-              .zmm1 = true,
-              .zmm2 = true,
-              .zmm3 = true,
-              .zmm4 = true,
-              .zmm5 = true,
-              .zmm6 = true,
-              .zmm7 = true,
-              .zmm8 = true,
-              .zmm9 = true,
-              .zmm10 = true,
-              .zmm11 = true,
-              .zmm12 = true,
-              .zmm13 = true,
-              .zmm14 = true,
-              .zmm15 = true,
-              .zmm16 = true,
-              .zmm17 = true,
-              .zmm18 = true,
-              .zmm19 = true,
-              .zmm20 = true,
-              .zmm21 = true,
-              .zmm22 = true,
-              .zmm23 = true,
-              .zmm24 = true,
-              .zmm25 = true,
-              .zmm26 = true,
-              .zmm27 = true,
-              .zmm28 = true,
-              .zmm29 = true,
-              .zmm30 = true,
-              .zmm31 = true,
-              .fpsr = true,
-              .fpcr = true,
-              .mxcsr = true,
-              .rflags = true,
-              .dirflag = true,
-              .memory = true,
-            }),
-        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
-    });
+    return @fieldParentPtr("contexts", Io.fiber.contextSwitch(&message.contexts));
 }
 
 fn mainIdleEntry() callconv(.naked) void {
diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig
index 9ff025a637c87e15f852d09234fd8d6570ad2ee4..26ab1cea35049becb3b88ffcdcd0aeff7265c504 100644
--- a/lib/std/Io/Reader.zig
+++ b/lib/std/Io/Reader.zig
@@ -375,7 +375,7 @@ pub fn appendRemainingAligned(
     defer list.* = a.toArrayListAligned(alignment);
 
     var remaining = limit;
-    while (remaining.nonzero()) {
+    while (remaining != .nothing) {
         const n = stream(r, &a.writer, remaining) catch |err| switch (err) {
             error.EndOfStream => return,
             error.WriteFailed => return error.OutOfMemory,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 60ee5df9451529265acfb25ca95e0db1b0862d4e..5d5758bb7afee72aa6c7515325c6080c160b0708 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -72,6 +72,9 @@ stderr_mutex_locker: std.Thread.Id = Thread.invalid_id,
 stderr_mutex_lock_count: usize = 0,
 
 argv0: Argv0,
+/// Protected by `mutex`. Determines whether `environ` has been
+/// memoized based on `process_environ`.
+environ_initialized: bool,
 environ: Environ,
 
 null_file: NullFile = .{},
@@ -125,9 +128,6 @@ pub const Argv0 = switch (native_os) {
 pub const Environ = struct {
     /// Unmodified data directly from the OS.
     process_environ: process.Environ,
-    /// Protected by `mutex`. Determines whether the other fields have been
-    /// memoized based on `process_environ`.
-    initialized: bool = false,
     /// Protected by `mutex`. Memoized based on `process_environ`. Tracks whether the
     /// environment variables are present, ignoring their value.
     exist: Exist = .{},
@@ -161,9 +161,6 @@ pub const Environ = struct {
     };
 
     pub fn scan(environ: *Environ, allocator: std.mem.Allocator) void {
-        if (environ.initialized) return;
-        environ.initialized = true;
-
         if (is_windows) {
             // This value expires with any call that modifies the environment,
             // which is outside of this Io implementation's control, so references
@@ -1589,6 +1586,7 @@ pub fn init(
         .old_sig_pipe = undefined,
         .have_signal_handler = init_single_threaded.have_signal_handler,
         .argv0 = options.argv0,
+        .environ_initialized = options.environ.block.isEmpty(),
         .environ = .{ .process_environ = options.environ },
         .worker_threads = init_single_threaded.worker_threads,
         .disable_memory_mapping = options.disable_memory_mapping,
@@ -1606,6 +1604,7 @@ pub fn init(
         .old_sig_pipe = undefined,
         .have_signal_handler = false,
         .argv0 = options.argv0,
+        .environ_initialized = options.environ.block.isEmpty(),
         .environ = .{ .process_environ = options.environ },
         .worker_threads = .init(null),
         .disable_memory_mapping = options.disable_memory_mapping,
@@ -1643,9 +1642,8 @@ pub const init_single_threaded: Threaded = .{
     .old_sig_pipe = undefined,
     .have_signal_handler = false,
     .argv0 = .empty,
-    .environ = .{ .process_environ = .{
-        .block = if (process.Environ.Block == process.Environ.GlobalBlock) .global else .empty,
-    } },
+    .environ_initialized = true,
+    .environ = .empty,
     .worker_threads = .init(null),
     .disable_memory_mapping = false,
 };
@@ -1768,6 +1766,8 @@ pub fn io(t: *Threaded) Io {
     return .{
         .userdata = t,
         .vtable = &.{
+            .crashHandler = crashHandler,
+
             .async = async,
             .concurrent = concurrent,
             .await = await,
@@ -1932,6 +1932,8 @@ pub fn ioBasic(t: *Threaded) Io {
     return .{
         .userdata = t,
         .vtable = &.{
+            .crashHandler = crashHandler,
+
             .async = async,
             .concurrent = concurrent,
             .await = await,
@@ -2157,6 +2159,14 @@ const use_libc_getrandom = std.c.versionCheck(if (builtin.abi.isAndroid()) .{
 
 const use_dev_urandom = @TypeOf(posix.system.getrandom) == void and native_os == .linux;
 
+fn crashHandler(userdata: ?*anyopaque) void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+    const thread = Thread.current orelse return;
+    thread.status.store(.{ .cancelation = .canceled, .awaitable = .null }, .monotonic);
+    thread.cancel_protection = .blocked;
+}
+
 fn async(
     userdata: ?*anyopaque,
     result: []u8,
@@ -2838,19 +2848,19 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     var poll_storage: struct {
         gpa: std.mem.Allocator,
-        b: *Io.Batch,
+        batch: *Io.Batch,
         slice: []posix.pollfd,
         len: u32,
 
         fn add(storage: *@This(), file: Io.File, events: @FieldType(posix.pollfd, "events")) Io.ConcurrentError!void {
             const len = storage.len;
             if (len == poll_buffer_len) {
-                const slice: []posix.pollfd = if (storage.b.context) |context|
-                    @as([*]posix.pollfd, @ptrCast(@alignCast(context)))[0..storage.b.storage.len]
+                const slice: []posix.pollfd = if (storage.batch.userdata) |batch_userdata|
+                    @as([*]posix.pollfd, @ptrCast(@alignCast(batch_userdata)))[0..storage.batch.storage.len]
                 else allocation: {
-                    const allocation = storage.gpa.alloc(posix.pollfd, storage.b.storage.len) catch
+                    const allocation = storage.gpa.alloc(posix.pollfd, storage.batch.storage.len) catch
                         return error.ConcurrencyUnavailable;
-                    storage.b.context = allocation.ptr;
+                    storage.batch.userdata = allocation.ptr;
                     break :allocation allocation;
                 };
                 @memcpy(slice[0..poll_buffer_len], storage.slice);
@@ -2863,7 +2873,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
             };
             storage.len = len + 1;
         }
-    } = .{ .gpa = t.allocator, .b = b, .slice = &poll_buffer, .len = 0 };
+    } = .{ .gpa = t.allocator, .batch = b, .slice = &poll_buffer, .len = 0 };
     {
         var index = b.submitted.head;
         while (index != .none) {
@@ -2962,21 +2972,21 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     }
 }
 
-const WindowsBatchPendingOperationContext = extern struct {
+const WindowsBatchOperationUserdata = extern struct {
     file: windows.HANDLE,
     iosb: windows.IO_STATUS_BLOCK,
 
-    const Erased = Io.Operation.Storage.Pending.Context;
+    const Erased = Io.Operation.Storage.Pending.Userdata;
 
     comptime {
-        assert(@sizeOf(Erased) <= @sizeOf(WindowsBatchPendingOperationContext));
+        assert(@sizeOf(WindowsBatchOperationUserdata) <= @sizeOf(Erased));
     }
 
-    fn toErased(context: *WindowsBatchPendingOperationContext) *Erased {
-        return @ptrCast(context);
+    fn toErased(userdata: *WindowsBatchOperationUserdata) *Erased {
+        return @ptrCast(userdata);
     }
 
-    fn fromErased(erased: *Erased) *WindowsBatchPendingOperationContext {
+    fn fromErased(erased: *Erased) *WindowsBatchOperationUserdata {
         return @ptrCast(erased);
     }
 };
@@ -2989,15 +2999,16 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
         var index = b.pending.head;
         while (index != .none) {
             const pending = &b.storage[index.toIndex()].pending;
-            const context: *WindowsBatchPendingOperationContext = .fromErased(&pending.context);
+            const operation_userdata: *WindowsBatchOperationUserdata = .fromErased(&pending.userdata);
             var cancel_iosb: windows.IO_STATUS_BLOCK = undefined;
-            _ = windows.ntdll.NtCancelIoFileEx(context.file, &context.iosb, &cancel_iosb);
+            _ = windows.ntdll.NtCancelIoFileEx(operation_userdata.file, &operation_userdata.iosb, &cancel_iosb);
             index = pending.node.next;
         }
         while (b.pending.head != .none) waitForApcOrAlert();
-    } else if (b.context) |context| {
-        t.allocator.free(@as([*]posix.pollfd, @ptrCast(@alignCast(context)))[0..b.storage.len]);
-        b.context = null;
+    } else if (b.userdata) |batch_userdata| {
+        const poll_storage: [*]posix.pollfd = @ptrCast(@alignCast(batch_userdata));
+        t.allocator.free(poll_storage[0..b.storage.len]);
+        b.userdata = null;
     }
 }
 
@@ -3007,9 +3018,9 @@ fn batchApc(
     _: windows.ULONG,
 ) callconv(.winapi) void {
     const b: *Io.Batch = @ptrCast(@alignCast(apc_context));
-    const context: *WindowsBatchPendingOperationContext = @fieldParentPtr("iosb", iosb);
-    const erased_context = context.toErased();
-    const pending: *Io.Operation.Storage.Pending = @fieldParentPtr("context", erased_context);
+    const operation_userdata: *WindowsBatchOperationUserdata = @fieldParentPtr("iosb", iosb);
+    const erased_userdata = operation_userdata.toErased();
+    const pending: *Io.Operation.Storage.Pending = @fieldParentPtr("userdata", erased_userdata);
     switch (pending.node.prev) {
         .none => b.pending.head = pending.node.next,
         else => |prev_index| b.storage[prev_index.toIndex()].pending.node.next = pending.node.next,
@@ -3019,24 +3030,23 @@ fn batchApc(
         else => |next_index| b.storage[next_index.toIndex()].pending.node.prev = pending.node.prev,
     }
     const storage: *Io.Operation.Storage = @fieldParentPtr("pending", pending);
-    const index = storage - b.storage.ptr;
+    const index: Io.Operation.OptionalIndex = .fromIndex(storage - b.storage.ptr);
     switch (iosb.u.Status) {
         .CANCELLED => {
             const tail_index = b.unused.tail;
             switch (tail_index) {
-                .none => b.unused.head = .fromIndex(index),
-                else => b.storage[tail_index.toIndex()].unused.next = .fromIndex(index),
+                .none => b.unused.head = index,
+                else => b.storage[tail_index.toIndex()].unused.next = index,
             }
             storage.* = .{ .unused = .{ .prev = tail_index, .next = .none } };
-            b.unused.tail = .fromIndex(index);
+            b.unused.tail = index;
         },
         else => {
             switch (b.completed.tail) {
-                .none => b.completed.head = .fromIndex(index),
-                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next =
-                    .fromIndex(index),
+                .none => b.completed.head = index,
+                else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
             }
-            b.completed.tail = .fromIndex(index);
+            b.completed.tail = index;
             const result: Io.Operation.Result = switch (pending.tag) {
                 .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
                 .file_write_streaming => .{ .file_write_streaming = ntWriteFileResult(iosb) },
@@ -3057,38 +3067,38 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
         storage.* = .{ .pending = .{
             .node = .{ .prev = b.pending.tail, .next = .none },
             .tag = submission.operation,
-            .context = undefined,
+            .userdata = undefined,
         } };
         switch (b.pending.tail) {
             .none => b.pending.head = index,
             else => |tail_index| b.storage[tail_index.toIndex()].pending.node.next = index,
         }
         b.pending.tail = index;
-        const context: *WindowsBatchPendingOperationContext = .fromErased(&storage.pending.context);
+        const operation_userdata: *WindowsBatchOperationUserdata = .fromErased(&storage.pending.userdata);
         errdefer {
-            context.iosb = .{ .u = .{ .Status = .CANCELLED }, .Information = undefined };
-            batchApc(b, &context.iosb, 0);
+            operation_userdata.iosb = .{ .u = .{ .Status = .CANCELLED }, .Information = undefined };
+            batchApc(b, &operation_userdata.iosb, 0);
         }
         switch (submission.operation) {
             .file_read_streaming => |o| o: {
                 var data_index: usize = 0;
                 while (o.data.len - data_index != 0 and o.data[data_index].len == 0) data_index += 1;
                 if (o.data.len - data_index == 0) {
-                    context.iosb = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
-                    batchApc(b, &context.iosb, 0);
+                    operation_userdata.iosb = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
+                    batchApc(b, &operation_userdata.iosb, 0);
                     break :o;
                 }
                 const buffer = o.data[data_index];
                 const short_buffer_len = std.math.lossyCast(u32, buffer.len);
 
                 if (o.file.flags.nonblocking) {
-                    context.file = o.file.handle;
+                    operation_userdata.file = o.file.handle;
                     switch (windows.ntdll.NtReadFile(
                         o.file.handle,
                         null, // event
                         &batchApc,
                         b,
-                        &context.iosb,
+                        &operation_userdata.iosb,
                         buffer.ptr,
                         short_buffer_len,
                         null, // byte offset
@@ -3097,8 +3107,8 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         .PENDING, .SUCCESS => {},
                         .CANCELLED => unreachable,
                         else => |status| {
-                            context.iosb.u.Status = status;
-                            batchApc(b, &context.iosb, 0);
+                            operation_userdata.iosb.u.Status = status;
+                            batchApc(b, &operation_userdata.iosb, 0);
                         },
                     }
                 } else {
@@ -3110,7 +3120,7 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         null, // event
                         null, // APC routine
                         null, // APC context
-                        &context.iosb,
+                        &operation_userdata.iosb,
                         buffer.ptr,
                         short_buffer_len,
                         null, // byte offset
@@ -3123,9 +3133,8 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         },
                         else => |status| {
                             syscall.finish();
-
-                            context.iosb.u.Status = status;
-                            batchApc(b, &context.iosb, 0);
+                            operation_userdata.iosb.u.Status = status;
+                            batchApc(b, &operation_userdata.iosb, 0);
                             break;
                         },
                     };
@@ -3134,18 +3143,18 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
             .file_write_streaming => |o| o: {
                 const buffer = windowsWriteBuffer(o.header, o.data, o.splat);
                 if (buffer.len == 0) {
-                    context.iosb = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
-                    batchApc(b, &context.iosb, 0);
+                    operation_userdata.iosb = .{ .u = .{ .Status = .SUCCESS }, .Information = 0 };
+                    batchApc(b, &operation_userdata.iosb, 0);
                     break :o;
                 }
                 if (o.file.flags.nonblocking) {
-                    context.file = o.file.handle;
+                    operation_userdata.file = o.file.handle;
                     switch (windows.ntdll.NtWriteFile(
                         o.file.handle,
                         null, // event
                         &batchApc,
                         b,
-                        &context.iosb,
+                        &operation_userdata.iosb,
                         buffer.ptr,
                         @intCast(buffer.len),
                         null, // byte offset
@@ -3154,8 +3163,8 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         .PENDING, .SUCCESS => {},
                         .CANCELLED => unreachable,
                         else => |status| {
-                            context.iosb.u.Status = status;
-                            batchApc(b, &context.iosb, 0);
+                            operation_userdata.iosb.u.Status = status;
+                            batchApc(b, &operation_userdata.iosb, 0);
                         },
                     }
                 } else {
@@ -3167,7 +3176,7 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         null, // event
                         null, // APC routine
                         null, // APC context
-                        &context.iosb,
+                        &operation_userdata.iosb,
                         buffer.ptr,
                         @intCast(buffer.len),
                         null, // byte offset
@@ -3180,9 +3189,8 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         },
                         else => |status| {
                             syscall.finish();
-
-                            context.iosb.u.Status = status;
-                            batchApc(b, &context.iosb, 0);
+                            operation_userdata.iosb.u.Status = status;
+                            batchApc(b, &operation_userdata.iosb, 0);
                             break;
                         },
                     };
@@ -3194,13 +3202,13 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                     else => &windows.ntdll.NtDeviceIoControlFile,
                 };
                 if (o.file.flags.nonblocking) {
-                    context.file = o.file.handle;
+                    operation_userdata.file = o.file.handle;
                     switch (NtControlFile(
                         o.file.handle,
                         null, // event
                         &batchApc,
                         b,
-                        &context.iosb,
+                        &operation_userdata.iosb,
                         o.code,
                         if (o.in.len > 0) o.in.ptr else null,
                         @intCast(o.in.len),
@@ -3210,8 +3218,8 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         .PENDING, .SUCCESS => {},
                         .CANCELLED => unreachable,
                         else => |status| {
-                            context.iosb.u.Status = status;
-                            batchApc(b, &context.iosb, 0);
+                            operation_userdata.iosb.u.Status = status;
+                            batchApc(b, &operation_userdata.iosb, 0);
                         },
                     }
                 } else {
@@ -3223,7 +3231,7 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         null, // event
                         null, // APC routine
                         null, // APC context
-                        &context.iosb,
+                        &operation_userdata.iosb,
                         o.code,
                         if (o.in.len > 0) o.in.ptr else null,
                         @intCast(o.in.len),
@@ -3237,9 +3245,8 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                         },
                         else => |status| {
                             syscall.finish();
-
-                            context.iosb.u.Status = status;
-                            batchApc(b, &context.iosb, 0);
+                            operation_userdata.iosb.u.Status = status;
+                            batchApc(b, &operation_userdata.iosb, 0);
                             break;
                         },
                     };
@@ -3816,7 +3823,13 @@ fn filePathKind(t: *Threaded, dir: Dir, sub_path: []const u8) !File.Kind {
         const syscall: Syscall = try .start();
         while (true) {
             var statx = std.mem.zeroes(linux.Statx);
-            switch (linux.errno(linux.statx(dir.handle, sub_path_posix, 0, .{ .TYPE = true }, &statx))) {
+            switch (linux.errno(linux.statx(
+                dir.handle,
+                sub_path_posix,
+                linux.AT.NO_AUTOMOUNT | linux.AT.SYMLINK_NOFOLLOW,
+                .{ .TYPE = true },
+                &statx,
+            ))) {
                 .SUCCESS => {
                     syscall.finish();
                     if (!statx.mask.TYPE) return error.Unexpected;
@@ -3832,7 +3845,7 @@ fn filePathKind(t: *Threaded, dir: Dir, sub_path: []const u8) !File.Kind {
         }
     }
 
-    const stat = try dirStatFile(t, dir, sub_path, .{});
+    const stat = try dirStatFile(t, dir, sub_path, .{ .follow_symlinks = false });
     return stat.kind;
 }
 
@@ -13573,13 +13586,13 @@ fn netWriteWindows(
     addWsaBuf(&iovecs, &len, header);
     for (data[0 .. data.len - 1]) |bytes| addWsaBuf(&iovecs, &len, bytes);
     const pattern = data[data.len - 1];
+    var backup_buffer: [64]u8 = undefined;
     if (iovecs.len - len != 0) switch (splat) {
         0 => {},
         1 => addWsaBuf(&iovecs, &len, pattern),
         else => switch (pattern.len) {
             0 => {},
             1 => {
-                var backup_buffer: [64]u8 = undefined;
                 const splat_buffer = &backup_buffer;
                 const memset_len = @min(splat_buffer.len, splat);
                 const buf = splat_buffer[0..memset_len];
@@ -14519,7 +14532,7 @@ pub fn statFromLinux(stx: *const std.os.linux.Statx) Io.UnexpectedError!File.Sta
     };
 }
 
-fn statxKind(stx_mode: u16) File.Kind {
+pub fn statxKind(stx_mode: u16) File.Kind {
     return switch (stx_mode & std.os.linux.S.IFMT) {
         std.os.linux.S.IFDIR => .directory,
         std.os.linux.S.IFCHR => .character_device,
@@ -14532,7 +14545,7 @@ fn statxKind(stx_mode: u16) File.Kind {
     };
 }
 
-fn statFromPosix(st: *const posix.Stat) File.Stat {
+pub fn statFromPosix(st: *const posix.Stat) File.Stat {
     const atime = st.atime();
     const mtime = st.mtime();
     const ctime = st.ctime();
@@ -15116,7 +15129,9 @@ const WindowsEnvironStrings = struct {
 fn scanEnviron(t: *Threaded) void {
     mutexLock(&t.mutex);
     defer mutexUnlock(&t.mutex);
+    if (t.environ_initialized) return;
     t.environ.scan(t.allocator);
+    t.environ_initialized = true;
 }
 
 fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError {
@@ -15256,7 +15271,7 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
 
     // This pipe communicates to the parent errors in the child between `fork` and `execvpe`.
     // It is closed by the child (via CLOEXEC) without writing if `execvpe` succeeds.
-    const err_pipe: [2]posix.fd_t = try pipe2(.{ .CLOEXEC = true });
+    const err_pipe = try pipe2(.{ .CLOEXEC = true });
     errdefer destroyPipe(err_pipe);
 
     t.scanEnviron(); // for PATH
@@ -15327,7 +15342,7 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
         }
 
         if (options.start_suspended) {
-            switch (posix.errno(posix.system.kill(posix.system.getpid(), .STOP))) {
+            switch (posix.errno(posix.system.kill(0, .STOP))) {
                 .SUCCESS => {},
                 .PERM => forkBail(ep1, error.PermissionDenied),
                 else => forkBail(ep1, error.Unexpected),
@@ -15539,15 +15554,15 @@ fn childCleanupWindows(child: *process.Child) void {
     windows.CloseHandle(child.thread_handle);
     child.thread_handle = undefined;
 
-    if (child.stdin) |*stdin| {
+    if (child.stdin) |stdin| {
         windows.CloseHandle(stdin.handle);
         child.stdin = null;
     }
-    if (child.stdout) |*stdout| {
+    if (child.stdout) |stdout| {
         windows.CloseHandle(stdout.handle);
         child.stdout = null;
     }
-    if (child.stderr) |*stderr| {
+    if (child.stderr) |stderr| {
         windows.CloseHandle(stderr.handle);
         child.stderr = null;
     }
@@ -15621,7 +15636,7 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T
     };
 }
 
-fn statusToTerm(status: u32) process.Child.Term {
+pub fn statusToTerm(status: u32) process.Child.Term {
     return if (posix.W.IFEXITED(status))
         .{ .exited = posix.W.EXITSTATUS(status) }
     else if (posix.W.IFSIGNALED(status))
@@ -15677,15 +15692,15 @@ fn childKillPosix(child: *process.Child) !void {
 }
 
 fn childCleanupPosix(child: *process.Child) void {
-    if (child.stdin) |*stdin| {
+    if (child.stdin) |stdin| {
         closeFd(stdin.handle);
         child.stdin = null;
     }
-    if (child.stdout) |*stdout| {
+    if (child.stdout) |stdout| {
         closeFd(stdout.handle);
         child.stdout = null;
     }
-    if (child.stderr) |*stderr| {
+    if (child.stderr) |stderr| {
         closeFd(stderr.handle);
         child.stderr = null;
     }
@@ -15818,21 +15833,57 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
         .dwFlags = windows.STARTF_USESTDHANDLES,
         .hStdInput = switch (options.stdin) {
             .inherit => peb.ProcessParameters.hStdInput,
-            .file => |file| file.handle,
+            .file => |file| try OpenFile(&.{}, .{
+                .access_mask = .{
+                    .STANDARD = .{ .SYNCHRONIZE = true },
+                    .GENERIC = .{ .READ = true },
+                },
+                .dir = file.handle,
+                .sa = &.{
+                    .nLength = @sizeOf(windows.SECURITY_ATTRIBUTES),
+                    .lpSecurityDescriptor = null,
+                    .bInheritHandle = windows.TRUE,
+                },
+                .creation = .OPEN,
+            }),
             .ignore => nul_handle,
             .pipe => stdin_pipe[1],
             .close => null,
         },
         .hStdOutput = switch (options.stdout) {
             .inherit => peb.ProcessParameters.hStdOutput,
-            .file => |file| file.handle,
+            .file => |file| try OpenFile(&.{}, .{
+                .access_mask = .{
+                    .STANDARD = .{ .SYNCHRONIZE = true },
+                    .GENERIC = .{ .WRITE = true },
+                },
+                .dir = file.handle,
+                .sa = &.{
+                    .nLength = @sizeOf(windows.SECURITY_ATTRIBUTES),
+                    .lpSecurityDescriptor = null,
+                    .bInheritHandle = windows.TRUE,
+                },
+                .creation = .OPEN,
+            }),
             .ignore => nul_handle,
             .pipe => stdout_pipe[1],
             .close => null,
         },
         .hStdError = switch (options.stderr) {
             .inherit => peb.ProcessParameters.hStdError,
-            .file => |file| file.handle,
+            .file => |file| try OpenFile(&.{}, .{
+                .access_mask = .{
+                    .STANDARD = .{ .SYNCHRONIZE = true },
+                    .GENERIC = .{ .WRITE = true },
+                },
+                .dir = file.handle,
+                .sa = &.{
+                    .nLength = @sizeOf(windows.SECURITY_ATTRIBUTES),
+                    .lpSecurityDescriptor = null,
+                    .bInheritHandle = windows.TRUE,
+                },
+                .creation = .OPEN,
+            }),
             .ignore => nul_handle,
             .pipe => stderr_pipe[1],
             .close => null,
@@ -16030,6 +16081,10 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
         .id = piProcInfo.hProcess,
         .thread_handle = piProcInfo.hThread,
         .stdin = stdin: switch (options.stdin) {
+            .file => {
+                windows.CloseHandle(siStartInfo.hStdInput.?);
+                break :stdin null;
+            },
             .pipe => {
                 windows.CloseHandle(stdin_pipe[1]);
                 break :stdin .{ .handle = stdin_pipe[0], .flags = .{ .nonblocking = false } };
@@ -16037,6 +16092,10 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
             else => null,
         },
         .stdout = stdout: switch (options.stdout) {
+            .file => {
+                windows.CloseHandle(siStartInfo.hStdOutput.?);
+                break :stdout null;
+            },
             .pipe => {
                 windows.CloseHandle(stdout_pipe[1]);
                 break :stdout .{ .handle = stdout_pipe[0], .flags = .{ .nonblocking = true } };
@@ -16044,6 +16103,10 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
             else => null,
         },
         .stderr = stderr: switch (options.stderr) {
+            .file => {
+                windows.CloseHandle(siStartInfo.hStdError.?);
+                break :stderr null;
+            },
             .pipe => {
                 windows.CloseHandle(stderr_pipe[1]);
                 break :stderr .{ .handle = stderr_pipe[0], .flags = .{ .nonblocking = true } };
@@ -16054,6 +16117,8 @@ fn processSpawnWindows(userdata: ?*anyopaque, options: process.SpawnOptions) pro
     };
 }
 
+fn inheritFile() windows.HANDLE {}
+
 fn getCngDevice(t: *Threaded) Io.RandomSecureError!windows.HANDLE {
     {
         mutexLock(&t.mutex);
@@ -17758,11 +17823,7 @@ const parking_futex = struct {
                 waiter.node.next = waking_head;
                 waking_head = &waiter.node;
                 num_removed += 1;
-                // Signal to `waiter` that they're about to be unparked, in case we're racing with their
-                // timeout. See corresponding logic in `wake`.
-                waiter.address = 0;
             }
-
             _ = bucket.num_waiters.fetchSub(num_removed, .monotonic);
         }
 
@@ -19056,7 +19117,7 @@ const OpenError = error{
 const OpenFileOptions = struct {
     access_mask: windows.ACCESS_MASK,
     dir: ?windows.HANDLE = null,
-    sa: ?*windows.SECURITY_ATTRIBUTES = null,
+    sa: ?*const windows.SECURITY_ATTRIBUTES = null,
     share_access: windows.FILE.SHARE = .VALID_FLAGS,
     creation: windows.FILE.CREATE_DISPOSITION,
     filter: Filter = .non_directory_only,
@@ -19076,10 +19137,10 @@ const OpenFileOptions = struct {
 
 /// TODO: inline this logic everywhere and delete this function
 fn OpenFile(sub_path_w: []const u16, options: OpenFileOptions) OpenError!windows.HANDLE {
-    if (std.mem.eql(u16, sub_path_w, &[_]u16{'.'}) and options.filter == .non_directory_only) {
+    if (std.mem.eql(u16, sub_path_w, &.{'.'}) and options.filter == .non_directory_only) {
         return error.IsDir;
     }
-    if (std.mem.eql(u16, sub_path_w, &[_]u16{ '.', '.' }) and options.filter == .non_directory_only) {
+    if (std.mem.eql(u16, sub_path_w, &.{ '.', '.' }) and options.filter == .non_directory_only) {
         return error.IsDir;
     }
 
diff --git a/lib/std/Io/IoUring.zig b/lib/std/Io/Uring.zig
similarity index 93%
rename from lib/std/Io/IoUring.zig
rename to lib/std/Io/Uring.zig
index 542f5e5fb2453a7e442d9c712a7d4d74b8fdb0bc..e668fe0426e1b1dff083e225fb21a0db312d293f 100644
--- a/lib/std/Io/IoUring.zig
+++ b/lib/std/Io/Uring.zig
@@ -39,6 +39,7 @@ const recoverableOsBugDetected = Io.Threaded.recoverableOsBugDetected;
 const setTimestampToPosix = Io.Threaded.setTimestampToPosix;
 const splat_buffer_size = Io.Threaded.splat_buffer_size;
 const statFromLinux = Io.Threaded.statFromLinux;
+const statxKind = Io.Threaded.statxKind;
 const std = @import("../std.zig");
 const timestampFromPosix = Io.Threaded.timestampFromPosix;
 const unexpectedErrno = std.posix.unexpectedErrno;
@@ -52,6 +53,14 @@ const tracy = if (@hasDecl(@import("root"), "tracy")) @import("root").tracy else
     inline fn fiberLeave() void {}
 };
 
+/// Empirically saw >128KB being used by the self-hosted backend to panic.
+/// Empirically saw glibc complain about 256KB.
+const idle_stack_size = 512 * 1024;
+
+const max_idle_search = 1;
+const max_steal_ready_search = 2;
+const max_steal_free_search = 4;
+
 backing_allocator_needs_mutex: bool,
 backing_allocator_mutex: Io.Mutex,
 /// Does not need to be thread-safe if not used elsewhere.
@@ -63,6 +72,7 @@ log2_ring_entries: u4,
 threads: Thread.List,
 sync_limit: ?Io.Semaphore,
 
+stderr_writer_initialized: bool = false,
 stderr_mutex: Io.Mutex,
 stderr_writer: File.Writer = .{
     .io = undefined,
@@ -71,9 +81,9 @@ stderr_writer: File.Writer = .{
     .mode = .streaming,
 },
 stderr_mode: Io.Terminal.Mode = .no_color,
-stderr_writer_initialized: bool = false,
 
 environ_mutex: Io.Mutex,
+environ_initialized: bool,
 environ: Environ,
 
 null_fd: CachedFd,
@@ -82,19 +92,11 @@ random_fd: CachedFd,
 csprng_mutex: Io.Mutex,
 csprng: Csprng,
 
-/// Empirically saw >128KB being used by the self-hosted backend to panic.
-/// Empirically saw glibc complain about 256KB.
-const idle_stack_size = 512 * 1024;
-
-const max_idle_search = 1;
-const max_steal_ready_search = 2;
-const max_steal_free_search = 4;
-
 const Thread = struct {
     required_align: void align(4),
     thread: std.Thread,
-    idle_context: Context,
-    current_context: *Context,
+    idle_context: Io.fiber.Context,
+    current_context: *Io.fiber.Context,
     ready_queue: ?*Fiber,
     free_queue: ?*Fiber,
     io_uring: IoUring,
@@ -147,7 +149,7 @@ const Thread = struct {
 
 const Fiber = struct {
     required_align: void align(4),
-    context: Context,
+    context: Io.fiber.Context,
     await_count: i32,
     link: union {
         awaiter: ?*Fiber,
@@ -191,7 +193,7 @@ const Fiber = struct {
 
             fn toIoUringFd(awaiting: Awaiting) fd_t {
                 switch (awaiting) {
-                    .nothing, .group => unreachable,
+                    .nothing, .group, .select => unreachable,
                     _ => return @intFromEnum(awaiting),
                 }
             }
@@ -361,7 +363,7 @@ const Fiber = struct {
             &fiber.cancel_status,
             .Or,
             .{ .requested = true, .awaiting = @enumFromInt(0) },
-            .acq_rel,
+            .acquire,
         );
         assert(!cancel_status.requested);
         switch (cancel_status.awaiting) {
@@ -377,9 +379,10 @@ const Fiber = struct {
             .select => if (@atomicRmw(i32, &fiber.await_count, .Add, 1, .monotonic) == -1) {
                 _ = ev.schedule(.current(), .{ .head = fiber, .tail = fiber });
             },
-            _ => |cancel_io_uring_fd| {
+            _ => |awaiting| {
+                const awaiting_io_uring_fd = awaiting.toIoUringFd();
                 const thread: *Thread = .current();
-                thread.enqueue().* = if (thread.io_uring.fd == @intFromEnum(cancel_io_uring_fd)) .{
+                thread.enqueue().* = if (thread.io_uring.fd == awaiting_io_uring_fd) .{
                     .opcode = .ASYNC_CANCEL,
                     .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
                     .ioprio = 0,
@@ -388,7 +391,7 @@ const Fiber = struct {
                     .addr = @intFromPtr(fiber),
                     .len = 0,
                     .rw_flags = 0,
-                    .user_data = @intFromEnum(Completion.UserData.wakeup),
+                    .user_data = @intFromEnum(Completion.Userdata.wakeup),
                     .buf_index = 0,
                     .personality = 0,
                     .splice_fd_in = 0,
@@ -398,12 +401,12 @@ const Fiber = struct {
                     .opcode = .MSG_RING,
                     .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
                     .ioprio = 0,
-                    .fd = @intFromEnum(cancel_io_uring_fd),
+                    .fd = awaiting_io_uring_fd,
                     .off = @intFromPtr(fiber) | 0b01,
                     .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA),
                     .len = 0,
                     .rw_flags = 0,
-                    .user_data = @intFromEnum(Completion.UserData.cleanup),
+                    .user_data = @intFromEnum(Completion.Userdata.cleanup),
                     .buf_index = 0,
                     .personality = 0,
                     .splice_fd_in = 0,
@@ -435,19 +438,26 @@ const CancelRegion = struct {
         };
     }
     fn deinit(cancel_region: *CancelRegion) void {
-        if (cancel_region.status.requested) _ = cancel_region.fiber.cancel_status.changeAwaiting(
-            cancel_region.status.awaiting,
-            .nothing,
-        );
+        if (cancel_region.status.requested) {
+            @branchHint(.likely);
+            _ = cancel_region.fiber.cancel_status.changeAwaiting(
+                cancel_region.status.awaiting,
+                .nothing,
+            );
+        }
         cancel_region.* = undefined;
     }
     fn await(cancel_region: *CancelRegion, awaiting: Fiber.CancelStatus.Awaiting) Io.Cancelable!void {
-        if (!cancel_region.status.requested) return;
+        if (!cancel_region.status.requested) {
+            @branchHint(.unlikely);
+            return;
+        }
         const status: Fiber.CancelStatus = .{ .requested = true, .awaiting = awaiting };
         if (cancel_region.fiber.cancel_status.changeAwaiting(
             cancel_region.status.awaiting,
             status.awaiting,
         )) {
+            @branchHint(.unlikely);
             cancel_region.fiber.cancel_protection.acknowledge();
             cancel_region.status = .unrequested;
             return error.Canceled;
@@ -549,7 +559,7 @@ const CachedFd = struct {
             .initializing => unreachable,
             _ => |fd| {
                 assert(@intFromEnum(fd) >= 0);
-                _ = std.os.linux.close(@intFromEnum(fd));
+                _ = linux.close(@intFromEnum(fd));
                 cached_fd.* = .init;
             },
         }
@@ -658,6 +668,8 @@ pub fn io(ev: *Evented) Io {
     return .{
         .userdata = ev,
         .vtable = &.{
+            .crashHandler = crashHandler,
+
             .async = async,
             .concurrent = concurrent,
             .await = await,
@@ -784,54 +796,6 @@ pub fn io(ev: *Evented) Io {
     };
 }
 
-fn fileMemoryMapSetLength(
-    userdata: ?*anyopaque,
-    mm: *File.MemoryMap,
-    new_len: usize,
-) File.MemoryMap.SetLengthError!void {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-
-    const page_size = std.heap.pageSize();
-    const alignment: Alignment = .fromByteUnits(page_size);
-    const page_align = std.heap.page_size_min;
-    const old_memory = mm.memory;
-
-    if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
-        mm.memory.len = new_len;
-        return;
-    }
-    const flags: linux.MREMAP = .{ .MAYMOVE = true };
-    const addr_hint: ?[*]const u8 = null;
-    var sync: CancelRegion.Sync = try .init(ev);
-    defer sync.deinit(ev);
-    const new_memory = while (true) {
-        try sync.cancel_region.await(.nothing);
-        const rc = linux.mremap(old_memory.ptr, old_memory.len, new_len, flags, addr_hint);
-        switch (linux.errno(rc)) {
-            .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len],
-            .INTR => continue,
-            .AGAIN => return error.LockedMemoryLimitExceeded,
-            .NOMEM => return error.OutOfMemory,
-            .INVAL => |err| return errnoBug(err),
-            .FAULT => |err| return errnoBug(err),
-            else => |err| return unexpectedErrno(err),
-        }
-    };
-    mm.memory = new_memory;
-}
-
-fn fileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = mm;
-}
-
-fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = mm;
-}
-
 pub const InitOptions = struct {
     backing_allocator_needs_mutex: bool = true,
 
@@ -858,7 +822,7 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
     else
         @max(std.Thread.getCpuCount() catch 1, 1);
     const idle_stack_end_offset =
-        std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.page_size_max);
+        std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.pageSize());
     const allocated_slice = try backing_allocator.alignedAlloc(u8, .of(Thread), idle_stack_end_offset);
     errdefer backing_allocator.free(allocated_slice);
     ev.* = .{
@@ -874,6 +838,7 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
         },
         .sync_limit = if (options.sync_limit.toInt()) |sync_limit| .{ .permits = sync_limit } else null,
 
+        .stderr_writer_initialized = false,
         .stderr_mutex = .init,
         .stderr_writer = .{
             .io = ev.io(),
@@ -882,9 +847,9 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
             .mode = .streaming,
         },
         .stderr_mode = .no_color,
-        .stderr_writer_initialized = false,
 
         .environ_mutex = .init,
+        .environ_initialized = options.environ.block.isEmpty(),
         .environ = .{ .process_environ = options.environ },
 
         .null_fd = .init,
@@ -906,21 +871,18 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
     };
     const main_thread = &ev.threads.allocated[0];
     Thread.self = main_thread;
-    const idle_stack_end: [*]align(16) usize =
-        @ptrCast(@alignCast(allocated_slice[idle_stack_end_offset..].ptr));
-    (idle_stack_end - 1)[0..1].* = .{@intFromPtr(ev)};
     main_thread.* = .{
         .required_align = {},
         .thread = undefined,
         .idle_context = switch (builtin.cpu.arch) {
             .aarch64 => .{
-                .sp = @intFromPtr(idle_stack_end),
-                .fp = 0,
+                .sp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
+                .fp = @intFromPtr(ev),
                 .pc = @intFromPtr(&mainIdleEntry),
             },
             .x86_64 => .{
-                .rsp = @intFromPtr(idle_stack_end - 1),
-                .rbp = 0,
+                .rsp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
+                .rbp = @intFromPtr(ev),
                 .rip = @intFromPtr(&mainIdleEntry),
             },
             else => @compileError("unimplemented architecture"),
@@ -943,13 +905,14 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
 }
 
 pub fn deinit(ev: *Evented) void {
+    const main_fiber: *Fiber = @ptrCast(&ev.main_fiber_buffer);
+    assert(Thread.current().currentFiber() == main_fiber);
     const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
     for (ev.threads.allocated[0..active_threads]) |*thread| {
         const ready_fiber = @atomicLoad(?*Fiber, &thread.ready_queue, .monotonic);
         assert(ready_fiber == null or ready_fiber == Fiber.finished); // pending async
     }
     ev.yield(null, .exit);
-    ev.threads.allocated[0].deinit(ev.allocator());
     ev.null_fd.close();
     ev.random_fd.close();
     const allocated_ptr: [*]align(@alignOf(Thread)) u8 = @ptrCast(@alignCast(ev.threads.allocated.ptr));
@@ -959,6 +922,7 @@ pub fn deinit(ev: *Evented) void {
         std.heap.page_size_max,
     );
     for (ev.threads.allocated[1..active_threads]) |*thread| thread.thread.join();
+    for (ev.threads.allocated[0..active_threads]) |*thread| thread.deinit(ev.backing_allocator);
     assert(active_threads == ev.threads.active); // spawned threads while there was no pending async?
     ev.backing_allocator.free(allocated_ptr[0..idle_stack_end_offset]);
     ev.* = undefined;
@@ -1006,8 +970,8 @@ fn yield(ev: *Evented, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.P
         &thread.idle_context;
     const message: SwitchMessage = .{
         .contexts = .{
-            .prev = thread.current_context,
-            .ready = ready_context,
+            .old = thread.current_context,
+            .new = ready_context,
         },
         .pending_task = pending_task,
     };
@@ -1035,11 +999,11 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
             .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
             .ioprio = 0,
             .fd = idle_search_thread.io_uring.fd,
-            .off = @intFromEnum(Completion.UserData.wakeup),
+            .off = @intFromEnum(Completion.Userdata.wakeup),
             .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA),
             .len = 0,
             .rw_flags = 0,
-            .user_data = @intFromEnum(Completion.UserData.wakeup),
+            .user_data = @intFromEnum(Completion.Userdata.wakeup),
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = 0,
@@ -1114,20 +1078,9 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
     return false;
 }
 
-fn mainIdle(
-    ev: *Evented,
-    message: *const SwitchMessage,
-) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Context)))) noreturn {
-    message.handle(ev);
-    ev.idle(&ev.threads.allocated[0]);
-    ev.yield(@ptrCast(&ev.main_fiber_buffer), .nothing);
-    unreachable; // switched to dead fiber
-}
-
 fn threadEntry(ev: *Evented, index: u32) void {
     const thread: *Thread = &ev.threads.allocated[index];
     Thread.self = thread;
-    defer thread.deinit(ev.allocator());
     switch (linux.errno(linux.io_uring_register(thread.io_uring.fd, .REGISTER_ENABLE_RINGS, null, 0))) {
         .SUCCESS => ev.idle(thread),
         else => |err| @panic(@tagName(err)),
@@ -1138,10 +1091,11 @@ const Completion = struct {
     result: i32,
     flags: u32,
 
-    const UserData = enum(usize) {
+    const Userdata = enum(usize) {
         unused,
         wakeup,
         futex_wake,
+        close,
         cleanup,
         exit,
         /// If bit 0 is 1, a pointer to the `context` field of `Io.Batch.Storage.Pending`.
@@ -1154,6 +1108,36 @@ const Completion = struct {
     }
 };
 
+fn mainIdleEntry() callconv(.naked) void {
+    switch (builtin.cpu.arch) {
+        .aarch64 => asm volatile (
+            \\ mov x0, fp
+            \\ mov fp, #0
+            \\ b %[mainIdle]
+            :
+            : [mainIdle] "X" (&mainIdle),
+        ),
+        .x86_64 => asm volatile (
+            \\ movq %%rbp, %%rdi
+            \\ xor %%ebp, %%ebp
+            \\ jmp %[mainIdle:P]
+            :
+            : [mainIdle] "X" (&mainIdle),
+        ),
+        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+    }
+}
+
+fn mainIdle(
+    ev: *Evented,
+    message: *const SwitchMessage,
+) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Io.fiber.Context)))) noreturn {
+    message.handle(ev);
+    ev.idle(&ev.threads.allocated[0]);
+    ev.yield(@ptrCast(&ev.main_fiber_buffer), .nothing);
+    unreachable; // switched to dead fiber
+}
+
 fn idle(ev: *Evented, thread: *Thread) void {
     var maybe_ready_fiber: ?*Fiber = null;
     while (true) {
@@ -1174,7 +1158,7 @@ fn idle(ev: *Evented, thread: *Thread) void {
             }];
             if (cqes.len == 0) break;
             for (cqes) |cqe| if (cqe.flags & linux.IORING_CQE_F_SKIP == 0) switch (@as(
-                Completion.UserData,
+                Completion.Userdata,
                 @enumFromInt(cqe.user_data),
             )) {
                 .unused => unreachable, // bad submission queued?
@@ -1182,10 +1166,15 @@ fn idle(ev: *Evented, thread: *Thread) void {
                 .futex_wake => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
                     .SUCCESS => recoverableOsBugDetected(), // success is skipped
                     .INVAL => {}, // invalid futex_wait() on ptr done elsewhere
-                    .INTR, .CANCELED => recoverableOsBugDetected(), // `Completion.UserData.futex_wake` is not cancelable
+                    .INTR, .CANCELED => recoverableOsBugDetected(), // `Completion.Userdata.futex_wake` is not cancelable
                     .FAULT => {}, // pointer became invalid while doing the wake
                     else => recoverableOsBugDetected(), // deadlock due to operating system bug
                 },
+                .close => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
+                    .BADF => recoverableOsBugDetected(), // Always a race condition.
+                    .INTR => {}, // This is still a success. See https://github.com/ziglang/zig/issues/2425
+                    else => {},
+                },
                 .cleanup => @panic("failed to notify other threads that we are exiting"),
                 .exit => {
                     assert(maybe_ready_fiber == null and maybe_ready_queue == null); // pending async
@@ -1210,7 +1199,7 @@ fn idle(ev: *Evented, thread: *Thread) void {
                             .addr = cqe.user_data & ~@as(usize, 0b11),
                             .len = 0,
                             .rw_flags = 0,
-                            .user_data = @intFromEnum(Completion.UserData.wakeup),
+                            .user_data = @intFromEnum(Completion.Userdata.wakeup),
                             .buf_index = 0,
                             .personality = 0,
                             .splice_fd_in = 0,
@@ -1220,21 +1209,21 @@ fn idle(ev: *Evented, thread: *Thread) void {
                         break :ready_fiber null;
                     },
                     0b10 => {
-                        const context: *Io.Operation.Storage.Pending.Context =
+                        const batch_userdata: *Io.Operation.Storage.Pending.Userdata =
                             @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
-                        const batch: *Io.Batch = @ptrFromInt(context[0]);
+                        const batch: *Io.Batch = @ptrFromInt(batch_userdata[0]);
                         var next: usize = 0b00;
-                        context[0..3].* = .{ next, @as(u32, @bitCast(cqe.res)), cqe.flags };
+                        batch_userdata[0..3].* = .{ next, @as(u32, @bitCast(cqe.res)), cqe.flags };
                         while (true) {
                             next = @cmpxchgWeak(
                                 usize,
-                                @as(*usize, @ptrCast(&batch.context)),
+                                @as(*usize, @ptrCast(&batch.userdata)),
                                 next,
                                 cqe.user_data,
                                 .release,
                                 .acquire,
                             ) orelse break;
-                            context[0] = next;
+                            batch_userdata[0] = next;
                         }
                         break :ready_fiber switch (@as(u2, @truncate(next))) {
                             0b00, 0b01 => @ptrFromInt(next & ~@as(usize, 0b11)),
@@ -1271,10 +1260,7 @@ fn idle(ev: *Evented, thread: *Thread) void {
 }
 
 const SwitchMessage = struct {
-    contexts: extern struct {
-        prev: *Context,
-        ready: *Context,
-    },
+    contexts: Io.fiber.Switch,
     pending_task: PendingTask,
 
     const PendingTask = union(enum) {
@@ -1290,40 +1276,40 @@ const SwitchMessage = struct {
 
     fn handle(message: *const SwitchMessage, ev: *Evented) void {
         const thread: *Thread = .current();
-        thread.current_context = message.contexts.ready;
+        thread.current_context = message.contexts.new;
         if (tracy.enable) {
-            if (message.contexts.ready != &thread.idle_context) {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.ready));
+            if (message.contexts.new != &thread.idle_context) {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.new));
                 tracy.fiberEnter(fiber.name);
             } else tracy.fiberLeave();
         }
         switch (message.pending_task) {
             .nothing => {},
-            .reschedule => if (message.contexts.prev != &thread.idle_context) {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+            .reschedule => if (message.contexts.old != &thread.idle_context) {
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 assert(fiber.status.queue_next == null);
                 _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
             .await => |count| {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 if (@atomicRmw(i32, &fiber.await_count, .Sub, count, .monotonic) > 0)
                     _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
             .group_await => |group| {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 if (group.await(ev, fiber))
                     _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
             .group_cancel => |group| {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 if (group.cancel(ev, fiber))
                     _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
             .batch_await => |batch| {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 if (@cmpxchgStrong(
                     ?*anyopaque,
-                    &batch.context,
+                    &batch.userdata,
                     null,
                     fiber,
                     .release,
@@ -1334,7 +1320,7 @@ const SwitchMessage = struct {
                 }
             },
             .destroy => {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.prev));
+                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 fiber.destroy();
             },
             .exit => for (
@@ -1345,11 +1331,11 @@ const SwitchMessage = struct {
                     .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
                     .ioprio = 0,
                     .fd = each_thread.io_uring.fd,
-                    .off = @intFromEnum(Completion.UserData.exit),
+                    .off = @intFromEnum(Completion.Userdata.exit),
                     .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA),
                     .len = 0,
                     .rw_flags = 0,
-                    .user_data = @intFromEnum(Completion.UserData.cleanup),
+                    .user_data = @intFromEnum(Completion.Userdata.cleanup),
                     .buf_index = 0,
                     .personality = 0,
                     .splice_fd_in = 0,
@@ -1361,213 +1347,23 @@ const SwitchMessage = struct {
     }
 };
 
-const Context = switch (builtin.cpu.arch) {
-    .aarch64 => extern struct {
-        sp: u64,
-        fp: u64,
-        pc: u64,
-    },
-    .x86_64 => extern struct {
-        rsp: u64,
-        rbp: u64,
-        rip: u64,
-    },
-    else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
-};
-
 inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage {
-    return @fieldParentPtr("contexts", switch (builtin.cpu.arch) {
-        .aarch64 => asm volatile (
-            \\ ldp x0, x2, [x1]
-            \\ ldr x3, [x2, #16]
-            \\ mov x4, sp
-            \\ stp x4, fp, [x0]
-            \\ adr x5, 0f
-            \\ ldp x4, fp, [x2]
-            \\ str x5, [x0, #16]
-            \\ mov sp, x4
-            \\ br x3
-            \\0:
-            : [received_message] "={x1}" (-> *const @FieldType(SwitchMessage, "contexts")),
-            : [message_to_send] "{x1}" (&message.contexts),
-            : .{
-              .x0 = true,
-              .x1 = true,
-              .x2 = true,
-              .x3 = true,
-              .x4 = true,
-              .x5 = true,
-              .x6 = true,
-              .x7 = true,
-              .x8 = true,
-              .x9 = true,
-              .x10 = true,
-              .x11 = true,
-              .x12 = true,
-              .x13 = true,
-              .x14 = true,
-              .x15 = true,
-              .x16 = true,
-              .x17 = true,
-              .x19 = true,
-              .x20 = true,
-              .x21 = true,
-              .x22 = true,
-              .x23 = true,
-              .x24 = true,
-              .x25 = true,
-              .x26 = true,
-              .x27 = true,
-              .x28 = true,
-              .x30 = true,
-              .z0 = true,
-              .z1 = true,
-              .z2 = true,
-              .z3 = true,
-              .z4 = true,
-              .z5 = true,
-              .z6 = true,
-              .z7 = true,
-              .z8 = true,
-              .z9 = true,
-              .z10 = true,
-              .z11 = true,
-              .z12 = true,
-              .z13 = true,
-              .z14 = true,
-              .z15 = true,
-              .z16 = true,
-              .z17 = true,
-              .z18 = true,
-              .z19 = true,
-              .z20 = true,
-              .z21 = true,
-              .z22 = true,
-              .z23 = true,
-              .z24 = true,
-              .z25 = true,
-              .z26 = true,
-              .z27 = true,
-              .z28 = true,
-              .z29 = true,
-              .z30 = true,
-              .z31 = true,
-              .p0 = true,
-              .p1 = true,
-              .p2 = true,
-              .p3 = true,
-              .p4 = true,
-              .p5 = true,
-              .p6 = true,
-              .p7 = true,
-              .p8 = true,
-              .p9 = true,
-              .p10 = true,
-              .p11 = true,
-              .p12 = true,
-              .p13 = true,
-              .p14 = true,
-              .p15 = true,
-              .fpcr = true,
-              .fpsr = true,
-              .ffr = true,
-              .memory = true,
-            }),
-        .x86_64 => asm volatile (
-            \\ movq 0(%%rsi), %%rax
-            \\ movq 8(%%rsi), %%rcx
-            \\ leaq 0f(%%rip), %%rdx
-            \\ movq %%rsp, 0(%%rax)
-            \\ movq %%rbp, 8(%%rax)
-            \\ movq %%rdx, 16(%%rax)
-            \\ movq 0(%%rcx), %%rsp
-            \\ movq 8(%%rcx), %%rbp
-            \\ jmpq *16(%%rcx)
-            \\0:
-            : [received_message] "={rsi}" (-> *const @FieldType(SwitchMessage, "contexts")),
-            : [message_to_send] "{rsi}" (&message.contexts),
-            : .{
-              .rax = true,
-              .rcx = true,
-              .rdx = true,
-              .rbx = true,
-              .rsi = true,
-              .rdi = true,
-              .r8 = true,
-              .r9 = true,
-              .r10 = true,
-              .r11 = true,
-              .r12 = true,
-              .r13 = true,
-              .r14 = true,
-              .r15 = true,
-              .mm0 = true,
-              .mm1 = true,
-              .mm2 = true,
-              .mm3 = true,
-              .mm4 = true,
-              .mm5 = true,
-              .mm6 = true,
-              .mm7 = true,
-              .zmm0 = true,
-              .zmm1 = true,
-              .zmm2 = true,
-              .zmm3 = true,
-              .zmm4 = true,
-              .zmm5 = true,
-              .zmm6 = true,
-              .zmm7 = true,
-              .zmm8 = true,
-              .zmm9 = true,
-              .zmm10 = true,
-              .zmm11 = true,
-              .zmm12 = true,
-              .zmm13 = true,
-              .zmm14 = true,
-              .zmm15 = true,
-              .zmm16 = true,
-              .zmm17 = true,
-              .zmm18 = true,
-              .zmm19 = true,
-              .zmm20 = true,
-              .zmm21 = true,
-              .zmm22 = true,
-              .zmm23 = true,
-              .zmm24 = true,
-              .zmm25 = true,
-              .zmm26 = true,
-              .zmm27 = true,
-              .zmm28 = true,
-              .zmm29 = true,
-              .zmm30 = true,
-              .zmm31 = true,
-              .fpsr = true,
-              .fpcr = true,
-              .mxcsr = true,
-              .rflags = true,
-              .dirflag = true,
-              .memory = true,
-            }),
-        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
-    });
+    return @fieldParentPtr("contexts", Io.fiber.contextSwitch(&message.contexts));
 }
 
-fn mainIdleEntry() callconv(.naked) void {
-    switch (builtin.cpu.arch) {
-        .aarch64 => asm volatile (
-            \\ ldr x0, [sp, #-8]
-            \\ b %[mainIdle]
-            :
-            : [mainIdle] "X" (&mainIdle),
-        ),
-        .x86_64 => asm volatile (
-            \\ movq (%%rsp), %%rdi
-            \\ jmp %[mainIdle:P]
-            :
-            : [mainIdle] "X" (&mainIdle),
-        ),
-        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
-    }
+fn crashHandler(userdata: ?*anyopaque) void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    const thread = Thread.self orelse std.process.abort();
+    if (thread.current_context == &thread.idle_context) std.process.abort();
+    const fiber = thread.currentFiber();
+    @atomicStore(
+        Fiber.CancelStatus,
+        &fiber.cancel_status,
+        .{ .requested = true, .awaiting = .nothing },
+        .monotonic,
+    );
+    fiber.cancel_protection = .{ .user = .blocked, .acknowledged = true };
 }
 
 const AsyncClosure = struct {
@@ -1665,7 +1461,7 @@ fn concurrent(
                 .pc = @intFromPtr(&AsyncClosure.entry),
             },
             .x86_64 => .{
-                .rsp = @intFromPtr(closure) - @sizeOf(usize),
+                .rsp = @intFromPtr(closure) - 8,
                 .rbp = 0,
                 .rip = @intFromPtr(&AsyncClosure.entry),
             },
@@ -2017,7 +1813,7 @@ fn groupAsync(
             error.Canceled => {
                 assert(!pre_acknowledged); // group task called `recancel` but was not canceled
                 assert(post_acknowledged); // group task returned `error.Canceled` but was never canceled
-                recancel(userdata);
+                fiber.cancel_protection.recancel();
             },
         }
     };
@@ -2049,7 +1845,7 @@ fn groupConcurrent(
                 .pc = @intFromPtr(&Group.AsyncClosure.entry),
             },
             .x86_64 => .{
-                .rsp = @intFromPtr(closure) - @sizeOf(usize),
+                .rsp = @intFromPtr(closure) - 8,
                 .rbp = 0,
                 .rip = @intFromPtr(&Group.AsyncClosure.entry),
             },
@@ -2103,9 +1899,7 @@ fn groupCancel(userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *an
 fn recancel(userdata: ?*anyopaque) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     _ = ev;
-    const cancel_protection = &Thread.current().currentFiber().cancel_protection;
-    assert(cancel_protection.acknowledged);
-    cancel_protection.acknowledged = false;
+    Thread.current().currentFiber().cancel_protection.recancel();
 }
 
 fn swapCancelProtection(userdata: ?*anyopaque, new: Io.CancelProtection) Io.CancelProtection {
@@ -2121,11 +1915,16 @@ fn checkCancel(userdata: ?*anyopaque) Io.Cancelable!void {
     _ = ev;
     const fiber = Thread.current().currentFiber();
     switch (fiber.cancel_protection.check()) {
+        .unblocked => {
+            const cancel_status = @atomicLoad(Fiber.CancelStatus, &fiber.cancel_status, .monotonic);
+            assert(cancel_status.awaiting == .nothing);
+            if (cancel_status.requested) {
+                @branchHint(.unlikely);
+                fiber.cancel_protection.acknowledge();
+                return error.Canceled;
+            }
+        },
         .blocked => {},
-        .unblocked => if (@atomicLoad(Fiber.CancelStatus, &fiber.cancel_status, .monotonic).requested) {
-            fiber.cancel_protection.acknowledge();
-            return error.Canceled;
-        },
     }
 }
 
@@ -2248,7 +2047,7 @@ fn futexWait(
             else => 0,
             .boot => linux.IORING_TIMEOUT_BOOTTIME,
         }),
-        .user_data = @intFromEnum(Completion.UserData.wakeup),
+        .user_data = @intFromEnum(Completion.Userdata.wakeup),
         .buf_index = 0,
         .personality = 0,
         .splice_fd_in = 0,
@@ -2314,7 +2113,7 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
         .addr = @intFromPtr(ptr),
         .len = 0,
         .rw_flags = 0,
-        .user_data = @intFromEnum(Completion.UserData.futex_wake),
+        .user_data = @intFromEnum(Completion.Userdata.futex_wake),
         .buf_index = 0,
         .personality = 0,
         .splice_fd_in = 0,
@@ -2367,7 +2166,7 @@ fn fileReadStreaming(
     var i: usize = 0;
     for (data) |buf| {
         if (iovecs_buffer.len - i == 0) break;
-        if (buf.len != 0) {
+        if (buf.len > 0) {
             iovecs_buffer[i] = .{ .base = buf.ptr, .len = buf.len };
             i += 1;
         }
@@ -2392,13 +2191,13 @@ fn fileWriteStreaming(
     addBuf(&iovecs, &iovlen, header);
     for (data[0 .. data.len - 1]) |bytes| addBuf(&iovecs, &iovlen, bytes);
     const pattern = data[data.len - 1];
+    var backup_buffer: [splat_buffer_size]u8 = undefined;
     if (iovecs.len - iovlen != 0) switch (splat) {
         0 => {},
         1 => addBuf(&iovecs, &iovlen, pattern),
         else => switch (pattern.len) {
             0 => {},
             1 => {
-                var backup_buffer: [splat_buffer_size]u8 = undefined;
                 const splat_buffer = &backup_buffer;
                 const memset_len = @min(splat_buffer.len, splat);
                 const buf = splat_buffer[0..memset_len];
@@ -2443,14 +2242,14 @@ fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void {
     defer maybe_sync.deinit(ev);
     ev.batchDrainSubmitted(&maybe_sync, batch, false) catch |err| switch (err) {
         error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
-        else => |e| return e,
+        error.Canceled => |e| return e,
     };
     maybe_sync.leaveSync(ev);
     while (true) {
         batchDrainReady(batch) catch |err| switch (err) {
             error.Timeout => unreachable, // no timeout
         };
-        if (batch.completed.head != .none) return;
+        if (batch.completed.head != .none or batch.pending.head == .none) return;
         ev.yield(null, .{ .batch_await = batch });
     }
 }
@@ -2469,7 +2268,7 @@ fn batchAwaitConcurrent(
         batchDrainReady(batch) catch |err| switch (err) {
             error.Timeout => unreachable, // no timeout
         };
-        if (batch.completed.head != .none) return;
+        if (batch.completed.head != .none or batch.pending.head == .none) return;
         switch (timeout) {
             .none => ev.yield(null, .{ .batch_await = batch }),
             .duration => |duration| {
@@ -2511,7 +2310,7 @@ fn batchAwaitConcurrent(
                 else => 0,
                 .boot => linux.IORING_TIMEOUT_BOOTTIME,
             }),
-            .user_data = @intFromPtr(&batch.context) | 0b11,
+            .user_data = @intFromPtr(&batch.userdata) | 0b11,
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = 0,
@@ -2519,12 +2318,12 @@ fn batchAwaitConcurrent(
             .resv = 0,
         };
     }
-    while (batch.completed.head == .none) {
+    while (batch.completed.head == .none and batch.pending.head != .none) {
         ev.yield(null, .{ .batch_await = batch });
         batchDrainReady(batch) catch |err| switch (err) {
-            error.Timeout => |e| return if (batch.completed.head == .none) e,
+            error.Timeout => |e| return if (batch.completed.head == .none and
+                batch.pending.head != .none) e,
         };
-        if (batch.completed.head == .none) continue;
     }
     const thread = try maybe_sync.cancel_region.awaitIoUring();
     thread.enqueue().* = .{
@@ -2533,7 +2332,7 @@ fn batchAwaitConcurrent(
         .ioprio = 0,
         .fd = 0,
         .off = 0,
-        .addr = @intFromPtr(&batch.context) | 0b11,
+        .addr = @intFromPtr(&batch.userdata) | 0b11,
         .len = 0,
         .rw_flags = 0,
         .user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
@@ -2566,21 +2365,21 @@ fn batchDrainSubmitted(
 ) (Io.ConcurrentError || Io.Cancelable)!void {
     var index = batch.submitted.head;
     if (index == .none) return;
-    errdefer batch.submitted.head = index;
     const thread = try maybe_sync.cancelRegion().awaitIoUring();
+    errdefer batch.submitted.head = index;
     while (index != .none) {
         const storage = &batch.storage[index.toIndex()];
         const next_index = storage.submission.node.next;
         if (@as(?Io.Operation.Result, result: switch (storage.submission.operation) {
             .file_read_streaming => |o| {
                 const buffer = for (o.data) |buffer| {
-                    if (buffer.len != 0) break buffer;
+                    if (buffer.len > 0) break buffer;
                 } else break :result .{ .file_read_streaming = 0 };
                 const fd = o.file.handle;
                 storage.* = .{ .pending = .{
                     .node = .{ .prev = batch.pending.tail, .next = .none },
                     .tag = .file_read_streaming,
-                    .context = undefined,
+                    .userdata = undefined,
                 } };
                 thread.enqueue().* = .{
                     .opcode = .READ,
@@ -2591,7 +2390,7 @@ fn batchDrainSubmitted(
                     .addr = @intFromPtr(buffer.ptr),
                     .len = @min(buffer.len, 0xfffff000),
                     .rw_flags = 0,
-                    .user_data = @intFromPtr(&storage.pending.context) | 0b10,
+                    .user_data = @intFromPtr(&storage.pending.userdata) | 0b10,
                     .buf_index = 0,
                     .personality = 0,
                     .splice_fd_in = 0,
@@ -2604,7 +2403,7 @@ fn batchDrainSubmitted(
                 const buffer = buffer: {
                     if (o.header.len != 0) break :buffer o.header;
                     for (o.data[0 .. o.data.len - 1]) |buffer| {
-                        if (buffer.len != 0) break :buffer buffer;
+                        if (buffer.len > 0) break :buffer buffer;
                     }
                     if (o.splat > 0) break :buffer o.data[o.data.len - 1];
                     break :result .{ .file_write_streaming = 0 };
@@ -2613,7 +2412,7 @@ fn batchDrainSubmitted(
                 storage.* = .{ .pending = .{
                     .node = .{ .prev = batch.pending.tail, .next = .none },
                     .tag = .file_write_streaming,
-                    .context = undefined,
+                    .userdata = undefined,
                 } };
                 thread.enqueue().* = .{
                     .opcode = .WRITE,
@@ -2624,7 +2423,7 @@ fn batchDrainSubmitted(
                     .addr = @intFromPtr(buffer.ptr),
                     .len = @min(buffer.len, 0xfffff000),
                     .rw_flags = 0,
-                    .user_data = @intFromPtr(&storage.pending.context) | 0b10,
+                    .user_data = @intFromPtr(&storage.pending.userdata) | 0b10,
                     .buf_index = 0,
                     .personality = 0,
                     .splice_fd_in = 0,
@@ -2650,7 +2449,7 @@ fn batchDrainSubmitted(
                 else => |tail_index| batch.storage[tail_index.toIndex()].pending.node.next = index,
             }
             batch.pending.tail = index;
-            storage.pending.context[0] = @intFromPtr(batch);
+            storage.pending.userdata[0] = @intFromPtr(batch);
         }
         index = next_index;
     }
@@ -2658,7 +2457,7 @@ fn batchDrainSubmitted(
 }
 
 fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void {
-    while (@atomicRmw(?*anyopaque, &batch.context, .Xchg, null, .acquire)) |head| {
+    while (@atomicRmw(?*anyopaque, &batch.userdata, .Xchg, null, .acquire)) |head| {
         var next: usize = @intFromPtr(head);
         var timeout = false;
         while (cond: switch (@as(u2, @truncate(next))) {
@@ -2674,13 +2473,15 @@ fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void {
                 break :cond true;
             },
         }) {
-            var context: *Io.Operation.Storage.Pending.Context = @ptrFromInt(next & ~@as(usize, 0b11));
-            next = context[0];
+            var operation_userdata: *Io.Operation.Storage.Pending.Userdata =
+                @ptrFromInt(next & ~@as(usize, 0b11));
+            next = operation_userdata[0];
             const completion: Completion = .{
-                .result = @bitCast(@as(u32, @intCast(context[1]))),
-                .flags = @intCast(context[2]),
+                .result = @bitCast(@as(u32, @intCast(operation_userdata[1]))),
+                .flags = @intCast(operation_userdata[2]),
             };
-            const pending: *Io.Operation.Storage.Pending = @fieldParentPtr("context", context);
+            const pending: *Io.Operation.Storage.Pending =
+                @fieldParentPtr("userdata", operation_userdata);
             const storage: *Io.Operation.Storage = @fieldParentPtr("pending", pending);
             const index: Io.Operation.OptionalIndex = .fromIndex(storage - batch.storage.ptr);
             assert(completion.flags & linux.IORING_CQE_F_SKIP == 0);
@@ -2776,10 +2577,10 @@ fn batchCancel(userdata: ?*anyopaque, batch: *Io.Batch) void {
             .ioprio = 0,
             .fd = 0,
             .off = 0,
-            .addr = @intFromPtr(&pending.context) | 0b10,
+            .addr = @intFromPtr(&pending.userdata) | 0b10,
             .len = 0,
             .rw_flags = 0,
-            .user_data = @intFromEnum(Completion.UserData.wakeup),
+            .user_data = @intFromEnum(Completion.Userdata.wakeup),
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = 0,
@@ -2842,8 +2643,6 @@ fn dirCreateDir(
             .NOSPC => return error.NoSpaceLeft,
             .NOTDIR => return error.NotDir,
             .ROFS => return error.ReadOnlyFileSystem,
-            // dragonfly: when dir_fd is unlinked from filesystem
-            .NOTCONN => return error.FileNotFound,
             .ILSEQ => return error.BadPathName,
             else => |err| return unexpectedErrno(err),
         }
@@ -2869,8 +2668,8 @@ fn dirCreateDirPath(
                 // stat the file and return an error if it's not a directory
                 // this is important because otherwise a dangling symlink
                 // could cause an infinite loop
-                const fstat = try dirStatFile(ev, dir, component.path, .{});
-                if (fstat.kind != .directory) return error.NotDir;
+                const kind = try ev.filePathKind(dir, component.path);
+                if (kind != .directory) return error.NotDir;
             },
             error.FileNotFound => |e| {
                 component = it.previous() orelse return e;
@@ -2882,6 +2681,51 @@ fn dirCreateDirPath(
     }
 }
 
+fn filePathKind(ev: *Evented, dir: Dir, sub_path: []const u8) !File.Kind {
+    var path_buffer: [PATH_MAX]u8 = undefined;
+    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
+    var cancel_region: CancelRegion = .init();
+    defer cancel_region.deinit();
+    while (true) {
+        var statx_buf = std.mem.zeroes(linux.Statx);
+        const thread = try cancel_region.awaitIoUring();
+        thread.enqueue().* = .{
+            .opcode = .STATX,
+            .flags = 0,
+            .ioprio = 0,
+            .fd = dir.handle,
+            .off = @intFromPtr(&statx_buf),
+            .addr = @intFromPtr(sub_path_posix.ptr),
+            .len = @bitCast(linux.STATX{ .TYPE = true }),
+            .rw_flags = linux.AT.NO_AUTOMOUNT | linux.AT.SYMLINK_NOFOLLOW,
+            .user_data = @intFromPtr(cancel_region.fiber),
+            .buf_index = 0,
+            .personality = 0,
+            .splice_fd_in = 0,
+            .addr3 = 0,
+            .resv = 0,
+        };
+        ev.yield(null, .nothing);
+        switch (cancel_region.errno()) {
+            .SUCCESS => {
+                if (!statx_buf.mask.TYPE) return error.Unexpected;
+                return statxKind(statx_buf.mode);
+            },
+            .INTR, .CANCELED => continue,
+            .ACCES => |err| return errnoBug(err),
+            .BADF => |err| return errnoBug(err), // File descriptor used after closed.
+            .FAULT => |err| return errnoBug(err),
+            .INVAL => |err| return errnoBug(err),
+            .LOOP => |err| return errnoBug(err),
+            .NAMETOOLONG => |err| return errnoBug(err),
+            .NOENT => |err| return errnoBug(err),
+            .NOMEM => return error.SystemResources,
+            .NOTDIR => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    }
+}
+
 fn dirCreateDirPathOpen(
     userdata: ?*anyopaque,
     dir: Dir,
@@ -3019,7 +2863,7 @@ fn dirCreateFile(
         .EXCL = flags.exclusive,
         .CLOEXEC = true,
     }, flags.permissions.toMode());
-    errdefer ev.close(maybe_sync.cancelRegion(), fd);
+    errdefer ev.close(fd);
 
     switch (flags.lock) {
         .none => {},
@@ -3207,7 +3051,7 @@ fn dirOpenFile(
         .CLOEXEC = true,
         .PATH = flags.path_only,
     }, 0);
-    errdefer ev.close(maybe_sync.cancelRegion(), fd);
+    errdefer ev.close(fd);
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
@@ -3236,9 +3080,7 @@ fn dirOpenFile(
 
 fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    for (dirs) |dir| ev.close(&cancel_region, dir.handle);
+    for (dirs) |dir| ev.close(dir.handle);
 }
 
 fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
@@ -3356,7 +3198,7 @@ fn dirRealPathFile(
         error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
         else => |e| return e,
     };
-    defer ev.close(maybe_sync.cancelRegion(), fd);
+    defer ev.close(fd);
     return ev.realPath(try maybe_sync.enterSync(ev), fd, out_buffer);
 }
 
@@ -3595,10 +3437,7 @@ fn dirReadLink(
         try sync.cancel_region.await(.nothing);
         const rc = linux.readlinkat(dir.handle, sub_path_posix, buffer.ptr, buffer.len);
         switch (linux.errno(rc)) {
-            .SUCCESS => {
-                const len: usize = @bitCast(rc);
-                return len;
-            },
+            .SUCCESS => return @bitCast(rc),
             .INTR => continue,
             .ACCES => return error.AccessDenied,
             .FAULT => |err| return errnoBug(err),
@@ -3808,7 +3647,7 @@ fn fileClose(userdata: ?*anyopaque, files: []const File) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     var cancel_region: CancelRegion = .init();
     defer cancel_region.deinit();
-    for (files) |file| ev.close(&cancel_region, file.handle);
+    for (files) |file| ev.close(file.handle);
 }
 
 fn fileWritePositional(
@@ -3826,13 +3665,13 @@ fn fileWritePositional(
     addBuf(&iovecs, &iovlen, header);
     for (data[0 .. data.len - 1]) |bytes| addBuf(&iovecs, &iovlen, bytes);
     const pattern = data[data.len - 1];
+    var backup_buffer: [splat_buffer_size]u8 = undefined;
     if (iovecs.len - iovlen != 0) switch (splat) {
         0 => {},
         1 => addBuf(&iovecs, &iovlen, pattern),
         else => switch (pattern.len) {
             0 => {},
             1 => {
-                var backup_buffer: [splat_buffer_size]u8 = undefined;
                 const splat_buffer = &backup_buffer;
                 const memset_len = @min(splat_buffer.len, splat);
                 const buf = splat_buffer[0..memset_len];
@@ -3915,7 +3754,7 @@ fn fileReadPositional(
     var i: usize = 0;
     for (data) |buf| {
         if (iovecs_buffer.len - i == 0) break;
-        if (buf.len != 0) {
+        if (buf.len > 0) {
             iovecs_buffer[i] = .{ .base = buf.ptr, .len = buf.len };
             i += 1;
         }
@@ -3927,9 +3766,9 @@ fn fileReadPositional(
     var cancel_region: CancelRegion = .init();
     defer cancel_region.deinit();
     return ev.preadv(&cancel_region, file.handle, dest, offset) catch |err| switch (err) {
-        error.SocketUnconnected => errnoBug(.NOTCONN), // not a socket
-        error.ConnectionResetByPeer => errnoBug(.CONNRESET), // not a socket
-        else => |e| e,
+        error.SocketUnconnected => return errnoBug(.NOTCONN), // not a socket
+        error.ConnectionResetByPeer => return errnoBug(.CONNRESET), // not a socket
+        else => |e| return e,
     };
 }
 
@@ -4247,6 +4086,54 @@ fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
     mm.* = undefined;
 }
 
+fn fileMemoryMapSetLength(
+    userdata: ?*anyopaque,
+    mm: *File.MemoryMap,
+    new_len: usize,
+) File.MemoryMap.SetLengthError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+
+    const page_size = std.heap.pageSize();
+    const alignment: Alignment = .fromByteUnits(page_size);
+    const page_align = std.heap.page_size_min;
+    const old_memory = mm.memory;
+
+    if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
+        mm.memory.len = new_len;
+        return;
+    }
+    const flags: linux.MREMAP = .{ .MAYMOVE = true };
+    const addr_hint: ?[*]const u8 = null;
+    var sync: CancelRegion.Sync = try .init(ev);
+    defer sync.deinit(ev);
+    const new_memory = while (true) {
+        try sync.cancel_region.await(.nothing);
+        const rc = linux.mremap(old_memory.ptr, old_memory.len, new_len, flags, addr_hint);
+        switch (linux.errno(rc)) {
+            .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len],
+            .INTR => continue,
+            .AGAIN => return error.LockedMemoryLimitExceeded,
+            .NOMEM => return error.OutOfMemory,
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            else => |err| return unexpectedErrno(err),
+        }
+    };
+    mm.memory = new_memory;
+}
+
+fn fileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = mm;
+}
+
+fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
+    const ev: *Evented = @ptrCast(@alignCast(userdata));
+    _ = ev;
+    _ = mm;
+}
+
 fn processExecutableOpen(
     userdata: ?*anyopaque,
     flags: File.OpenFlags,
@@ -4287,11 +4174,21 @@ fn tryLockStderr(
 fn initLockedStderr(ev: *Evented, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
     if (!ev.stderr_writer_initialized) {
         const ev_io = ev.io();
-        try ev.scanEnviron();
+        const cancel_protection = swapCancelProtection(ev, .blocked);
+        defer assert(swapCancelProtection(ev, cancel_protection) == .blocked);
+        ev.scanEnviron() catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
         const NO_COLOR = ev.environ.exist.NO_COLOR;
         const CLICOLOR_FORCE = ev.environ.exist.CLICOLOR_FORCE;
-        ev.stderr_mode = terminal_mode orelse
-            try .detect(ev_io, ev.stderr_writer.file, NO_COLOR, CLICOLOR_FORCE);
+        ev.stderr_mode = Io.Terminal.Mode.detect(
+            ev_io,
+            ev.stderr_writer.file,
+            NO_COLOR,
+            CLICOLOR_FORCE,
+        ) catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
         ev.stderr_writer_initialized = true;
     }
     return .{
@@ -4302,12 +4199,14 @@ fn initLockedStderr(ev: *Evented, terminal_mode: ?Io.Terminal.Mode) Io.Cancelabl
 
 fn unlockStderr(userdata: ?*anyopaque) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    ev.stderr_writer.interface.flush() catch |err| switch (err) {
-        error.WriteFailed => switch (ev.stderr_writer.err.?) {
-            error.Canceled => recancel(ev),
+    if (ev.stderr_writer.err == null) ev.stderr_writer.interface.flush() catch {};
+    if (ev.stderr_writer.err) |err| {
+        switch (err) {
+            error.Canceled => Thread.current().currentFiber().cancel_protection.recancel(),
             else => {},
-        },
-    };
+        }
+        ev.stderr_writer.err = null;
+    }
     ev.stderr_writer.interface.end = 0;
     ev.stderr_writer.interface.buffer = &.{};
     ev.stderr_mutex.unlock(ev.io());
@@ -4393,7 +4292,7 @@ fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.Sp
     const spawned = try ev.spawn(options);
     var cancel_region: CancelRegion = .initBlocked();
     defer cancel_region.deinit();
-    defer ev.close(&cancel_region, spawned.err_fd);
+    defer ev.close(spawned.err_fd);
 
     // Wait for the child to report any errors in or before `execvpe`.
     var child_err: ForkBailError = undefined;
@@ -4434,7 +4333,7 @@ fn processSpawnPath(
     @panic("TODO processSpawnPath");
 }
 
-const prog_fileno = 3;
+const prog_fileno = @max(linux.STDIN_FILENO, linux.STDOUT_FILENO, linux.STDERR_FILENO);
 
 const Spawned = struct {
     pid: pid_t,
@@ -4461,17 +4360,17 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
 
     const stdin_pipe = if (options.stdin == .pipe) try pipe2(pipe_flags) else undefined;
     errdefer if (options.stdin == .pipe) {
-        ev.destroyPipe(&cancel_region, stdin_pipe);
+        ev.destroyPipe(stdin_pipe);
     };
 
     const stdout_pipe = if (options.stdout == .pipe) try pipe2(pipe_flags) else undefined;
     errdefer if (options.stdout == .pipe) {
-        ev.destroyPipe(&cancel_region, stdout_pipe);
+        ev.destroyPipe(stdout_pipe);
     };
 
     const stderr_pipe = if (options.stderr == .pipe) try pipe2(pipe_flags) else undefined;
     errdefer if (options.stderr == .pipe) {
-        ev.destroyPipe(&cancel_region, stderr_pipe);
+        ev.destroyPipe(stderr_pipe);
     };
 
     const any_ignore =
@@ -4486,7 +4385,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
         _ = linux.fcntl(pipe[0], linux.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2));
         break :pipe pipe;
     } else .{ -1, -1 };
-    errdefer ev.destroyPipe(&cancel_region, prog_pipe);
+    errdefer ev.destroyPipe(prog_pipe);
 
     var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
     defer arena_allocator.deinit();
@@ -4504,8 +4403,6 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
     for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
 
-    comptime assert(@max(linux.STDIN_FILENO, linux.STDOUT_FILENO, linux.STDERR_FILENO) + 1 == prog_fileno);
-
     const env_block = env_block: {
         const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;
         if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
@@ -4519,7 +4416,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     // This pipe communicates to the parent errors in the child between `fork` and `execvpe`.
     // It is closed by the child (via CLOEXEC) without writing if `execvpe` succeeds.
     const err_pipe: [2]fd_t = try pipe2(.{ .CLOEXEC = true });
-    errdefer ev.destroyPipe(&cancel_region, err_pipe);
+    errdefer ev.destroyPipe(err_pipe);
 
     try ev.scanEnviron(); // for PATH
     const PATH = ev.environ.string.PATH orelse default_PATH;
@@ -4557,13 +4454,13 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     const pid: pid_t = @intCast(pid_result); // We are the parent.
     errdefer comptime unreachable; // The child is forked; we must not error from now on
 
-    ev.close(&cancel_region, err_pipe[1]); // make sure only the child holds the write end open
+    ev.close(err_pipe[1]); // make sure only the child holds the write end open
 
-    if (options.stdin == .pipe) ev.close(&cancel_region, stdin_pipe[0]);
-    if (options.stdout == .pipe) ev.close(&cancel_region, stdout_pipe[1]);
-    if (options.stderr == .pipe) ev.close(&cancel_region, stderr_pipe[1]);
+    if (options.stdin == .pipe) ev.close(stdin_pipe[0]);
+    if (options.stdout == .pipe) ev.close(stdout_pipe[1]);
+    if (options.stderr == .pipe) ev.close(stderr_pipe[1]);
 
-    if (prog_pipe[1] != -1) ev.close(&cancel_region, prog_pipe[1]);
+    if (prog_pipe[1] != -1) ev.close(prog_pipe[1]);
 
     options.progress_node.setIpcFile(ev, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
 
@@ -4599,29 +4496,25 @@ pub fn pipe2(flags: linux.O) PipeError![2]fd_t {
         else => |err| return unexpectedErrno(err),
     }
 }
-fn destroyPipe(ev: *Evented, cancel_region: *CancelRegion, pipe: [2]fd_t) void {
-    if (pipe[0] != -1) ev.close(cancel_region, pipe[0]);
-    if (pipe[0] != pipe[1]) ev.close(cancel_region, pipe[1]);
+fn destroyPipe(ev: *Evented, pipe: [2]fd_t) void {
+    if (pipe[0] != -1) ev.close(pipe[0]);
+    if (pipe[0] != pipe[1]) ev.close(pipe[1]);
 }
 
 /// Errors that can occur between fork() and execv()
 const ForkBailError = process.SetCurrentDirError || ChdirError ||
     process.SpawnError || process.ReplaceError;
-fn setUpChild(
-    ev: *Evented,
-    sync: *CancelRegion.Sync,
-    options: struct {
-        stdin_pipe: fd_t,
-        stdout_pipe: fd_t,
-        stderr_pipe: fd_t,
-        dev_null_fd: fd_t,
-        prog_pipe: fd_t,
-        argv_buf: [:null]?[*:0]const u8,
-        env_block: process.Environ.Block,
-        PATH: []const u8,
-        spawn: process.SpawnOptions,
-    },
-) ForkBailError {
+fn setUpChild(ev: *Evented, sync: *CancelRegion.Sync, options: struct {
+    stdin_pipe: fd_t,
+    stdout_pipe: fd_t,
+    stderr_pipe: fd_t,
+    dev_null_fd: fd_t,
+    prog_pipe: fd_t,
+    argv_buf: [:null]?[*:0]const u8,
+    env_block: process.Environ.Block,
+    PATH: []const u8,
+    spawn: process.SpawnOptions,
+}) ForkBailError {
     try ev.setUpChildIo(
         sync,
         options.spawn.stdin,
@@ -4689,7 +4582,7 @@ fn setUpChild(
     }
 
     if (options.spawn.start_suspended) {
-        switch (linux.errno(linux.kill(linux.getpid(), .STOP))) {
+        switch (linux.errno(linux.kill(0, .STOP))) {
             .SUCCESS => {},
             .PERM => return error.PermissionDenied,
             else => return error.Unexpected,
@@ -4716,10 +4609,13 @@ fn setUpChildIo(
 ) !void {
     switch (stdio) {
         .pipe => try ev.dup2(sync, pipe_fd, std_fileno),
-        .close => ev.close(&sync.cancel_region, std_fileno),
+        .close => _ = linux.close(std_fileno),
         .inherit => {},
         .ignore => try ev.dup2(sync, dev_null_fd, std_fileno),
-        .file => |file| try ev.dup2(sync, file.handle, std_fileno),
+        .file => |file| {
+            if (file.flags.nonblocking) @panic("TODO implement setUpChildIo when nonblocking file is used");
+            try ev.dup2(sync, file.handle, std_fileno);
+        },
     }
 }
 
@@ -4828,7 +4724,7 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
 
     var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
     defer maybe_sync.deinit(ev);
-    defer ev.childCleanup(maybe_sync.cancelRegion(), child);
+    defer ev.childCleanup(child);
 
     const pid = child.id.?;
     var info: linux.siginfo_t = undefined;
@@ -4897,7 +4793,7 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
 
     var maybe_sync: CancelRegion.Sync.Maybe = .{ .sync = .initBlocked(ev) };
     defer maybe_sync.deinit(ev);
-    defer ev.childCleanup(maybe_sync.cancelRegion(), child);
+    defer ev.childCleanup(child);
 
     const pid = child.id.?;
     while (true) switch (linux.errno(linux.kill(pid, .TERM))) {
@@ -4941,17 +4837,17 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
     }
 }
 
-fn childCleanup(ev: *Evented, cancel_region: *CancelRegion, child: *process.Child) void {
+fn childCleanup(ev: *Evented, child: *process.Child) void {
     if (child.stdin) |*stdin| {
-        ev.close(cancel_region, stdin.handle);
+        ev.close(stdin.handle);
         child.stdin = null;
     }
     if (child.stdout) |*stdout| {
-        ev.close(cancel_region, stdout.handle);
+        ev.close(stdout.handle);
         child.stdout = null;
     }
     if (child.stderr) |*stderr| {
-        ev.close(cancel_region, stderr.handle);
+        ev.close(stderr.handle);
         child.stderr = null;
     }
     child.id = null;
@@ -4971,7 +4867,9 @@ fn scanEnviron(ev: *Evented) Io.Cancelable!void {
     const ev_io = ev.io();
     try ev.environ_mutex.lock(ev_io);
     defer ev.environ_mutex.unlock(ev_io);
+    if (ev.environ_initialized) return;
     ev.environ.scan(ev.allocator());
+    ev.environ_initialized = true;
 }
 
 fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
@@ -5139,7 +5037,7 @@ fn netBindIp(
     var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
     defer maybe_sync.deinit(ev);
     const socket_fd = try ev.socket(&maybe_sync.cancel_region, family, options);
-    errdefer ev.close(maybe_sync.cancelRegion(), socket_fd);
+    errdefer ev.close(socket_fd);
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
     try ev.bind(&maybe_sync.cancel_region, socket_fd, &storage.any, addr_len);
@@ -5150,18 +5048,6 @@ fn netBindIp(
     };
 }
 
-fn netBindIpUnavailable(
-    userdata: ?*anyopaque,
-    address: *const net.IpAddress,
-    options: net.IpAddress.BindOptions,
-) net.IpAddress.BindError!net.Socket {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = address;
-    _ = options;
-    return error.NetworkDown;
-}
-
 fn netConnectIpUnavailable(
     userdata: ?*anyopaque,
     address: *const net.IpAddress,
@@ -5300,7 +5186,7 @@ fn netReceive(
                 else => 0,
                 .boot => linux.IORING_TIMEOUT_BOOTTIME,
             }),
-            .user_data = @intFromEnum(Completion.UserData.wakeup),
+            .user_data = @intFromEnum(Completion.Userdata.wakeup),
             .buf_index = 0,
             .personality = 0,
             .splice_fd_in = 0,
@@ -5355,24 +5241,6 @@ fn netReceive(
     }
 }
 
-fn netReceiveUnavailable(
-    userdata: ?*anyopaque,
-    handle: net.Socket.Handle,
-    message_buffer: []net.IncomingMessage,
-    data_buffer: []u8,
-    flags: net.ReceiveFlags,
-    timeout: Io.Timeout,
-) struct { ?net.Socket.ReceiveTimeoutError, usize } {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = handle;
-    _ = message_buffer;
-    _ = data_buffer;
-    _ = flags;
-    _ = timeout;
-    return .{ error.NetworkDown, 0 };
-}
-
 fn netReadUnavailable(
     userdata: ?*anyopaque,
     fd: net.Socket.Handle,
@@ -5419,16 +5287,7 @@ fn netWriteFileUnavailable(
 
 fn netClose(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    for (handles) |handle| ev.close(&cancel_region, handle);
-}
-
-fn netCloseUnavailable(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = handles;
-    unreachable; // How you gonna close something that was impossible to open?
+    for (handles) |handle| ev.close(handle);
 }
 
 fn netShutdown(
@@ -5473,18 +5332,6 @@ fn netShutdown(
     }
 }
 
-fn netShutdownUnavailable(
-    userdata: ?*anyopaque,
-    handle: net.Socket.Handle,
-    how: net.ShutdownHow,
-) net.ShutdownError!void {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = handle;
-    _ = how;
-    unreachable; // How you gonna shutdown something that was impossible to open?
-}
-
 fn netInterfaceNameResolveUnavailable(
     userdata: ?*anyopaque,
     name: *const net.Interface.Name,
@@ -5581,35 +5428,25 @@ fn chdir(ev: *Evented, sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError
     }
 }
 
-fn close(ev: *Evented, cancel_region: *CancelRegion, fd: fd_t) void {
-    while (true) {
-        const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
-            error.Canceled => unreachable, // blocked
-        };
-        thread.enqueue().* = .{
-            .opcode = .CLOSE,
-            .flags = 0,
-            .ioprio = 0,
-            .fd = fd,
-            .off = 0,
-            .addr = 0,
-            .len = 0,
-            .rw_flags = 0,
-            .user_data = @intFromPtr(cancel_region.fiber),
-            .buf_index = 0,
-            .personality = 0,
-            .splice_fd_in = 0,
-            .addr3 = 0,
-            .resv = 0,
-        };
-        ev.yield(null, .nothing);
-        switch (cancel_region.errno()) {
-            .SUCCESS => return,
-            .INTR, .CANCELED => continue,
-            .BADF => unreachable, // Always a race condition.
-            else => break,
-        }
-    }
+fn close(ev: *Evented, fd: fd_t) void {
+    _ = ev;
+    const thread: *Thread = .current();
+    thread.enqueue().* = .{
+        .opcode = .CLOSE,
+        .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
+        .ioprio = 0,
+        .fd = fd,
+        .off = 0,
+        .addr = 0,
+        .len = 0,
+        .rw_flags = 0,
+        .user_data = @intFromEnum(Completion.Userdata.close),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = 0,
+        .resv = 0,
+    };
 }
 
 fn fchdir(ev: *Evented, sync: *CancelRegion.Sync, dir: fd_t) process.SetCurrentDirError!void {
@@ -6214,7 +6051,7 @@ fn socket(
             else => |err| return unexpectedErrno(err),
         }
     };
-    errdefer ev.close(cancel_region, socket_fd);
+    errdefer ev.close(socket_fd);
 
     if (options.ip6_only) {
         if (linux.IPV6 == void) return error.OptionUnsupported;
diff --git a/lib/std/Io/fiber.zig b/lib/std/Io/fiber.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bc33a3a97eeb8390110864488e9f4e776c1a11ae
--- /dev/null
+++ b/lib/std/Io/fiber.zig
@@ -0,0 +1,201 @@
+pub const supported = switch (builtin.cpu.arch) {
+    .aarch64, .x86_64 => true,
+    else => false,
+};
+
+/// Stores the cpu state of an inactive fiber.
+pub const Context = switch (builtin.cpu.arch) {
+    .aarch64 => extern struct {
+        sp: u64,
+        fp: u64,
+        pc: u64,
+    },
+    .x86_64 => extern struct {
+        rsp: u64,
+        rbp: u64,
+        rip: u64,
+    },
+    else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+};
+
+pub const Switch = extern struct { old: *Context, new: *Context };
+
+/// Fills `s.old` with the current cpu state, and restores the cpu state stored in `s.new`.
+pub inline fn contextSwitch(s: *const Switch) *const Switch {
+    return switch (builtin.cpu.arch) {
+        .aarch64 => asm volatile (
+            \\ ldp x0, x2, [x1]
+            \\ ldr x3, [x2, #16]
+            \\ mov x4, sp
+            \\ stp x4, fp, [x0]
+            \\ adr x5, 0f
+            \\ ldp x4, fp, [x2]
+            \\ str x5, [x0, #16]
+            \\ mov sp, x4
+            \\ br x3
+            \\0:
+            : [received_message] "={x1}" (-> *const Switch),
+            : [message_to_send] "{x1}" (s),
+            : .{
+              .x0 = true,
+              .x1 = true,
+              .x2 = true,
+              .x3 = true,
+              .x4 = true,
+              .x5 = true,
+              .x6 = true,
+              .x7 = true,
+              .x8 = true,
+              .x9 = true,
+              .x10 = true,
+              .x11 = true,
+              .x12 = true,
+              .x13 = true,
+              .x14 = true,
+              .x15 = true,
+              .x16 = true,
+              .x17 = true,
+              .x19 = true,
+              .x20 = true,
+              .x21 = true,
+              .x22 = true,
+              .x23 = true,
+              .x24 = true,
+              .x25 = true,
+              .x26 = true,
+              .x27 = true,
+              .x28 = true,
+              .x30 = true,
+              .z0 = true,
+              .z1 = true,
+              .z2 = true,
+              .z3 = true,
+              .z4 = true,
+              .z5 = true,
+              .z6 = true,
+              .z7 = true,
+              .z8 = true,
+              .z9 = true,
+              .z10 = true,
+              .z11 = true,
+              .z12 = true,
+              .z13 = true,
+              .z14 = true,
+              .z15 = true,
+              .z16 = true,
+              .z17 = true,
+              .z18 = true,
+              .z19 = true,
+              .z20 = true,
+              .z21 = true,
+              .z22 = true,
+              .z23 = true,
+              .z24 = true,
+              .z25 = true,
+              .z26 = true,
+              .z27 = true,
+              .z28 = true,
+              .z29 = true,
+              .z30 = true,
+              .z31 = true,
+              .p0 = true,
+              .p1 = true,
+              .p2 = true,
+              .p3 = true,
+              .p4 = true,
+              .p5 = true,
+              .p6 = true,
+              .p7 = true,
+              .p8 = true,
+              .p9 = true,
+              .p10 = true,
+              .p11 = true,
+              .p12 = true,
+              .p13 = true,
+              .p14 = true,
+              .p15 = true,
+              .fpcr = true,
+              .fpsr = true,
+              .ffr = true,
+              .memory = true,
+            }),
+        .x86_64 => asm volatile (
+            \\ movq 0(%%rsi), %%rax
+            \\ movq 8(%%rsi), %%rcx
+            \\ leaq 0f(%%rip), %%rdx
+            \\ movq %%rsp, 0(%%rax)
+            \\ movq %%rbp, 8(%%rax)
+            \\ movq %%rdx, 16(%%rax)
+            \\ movq 0(%%rcx), %%rsp
+            \\ movq 8(%%rcx), %%rbp
+            \\ jmpq *16(%%rcx)
+            \\0:
+            : [received_message] "={rsi}" (-> *const Switch),
+            : [message_to_send] "{rsi}" (s),
+            : .{
+              .rax = true,
+              .rcx = true,
+              .rdx = true,
+              .rbx = true,
+              .rsi = true,
+              .rdi = true,
+              .r8 = true,
+              .r9 = true,
+              .r10 = true,
+              .r11 = true,
+              .r12 = true,
+              .r13 = true,
+              .r14 = true,
+              .r15 = true,
+              .mm0 = true,
+              .mm1 = true,
+              .mm2 = true,
+              .mm3 = true,
+              .mm4 = true,
+              .mm5 = true,
+              .mm6 = true,
+              .mm7 = true,
+              .zmm0 = true,
+              .zmm1 = true,
+              .zmm2 = true,
+              .zmm3 = true,
+              .zmm4 = true,
+              .zmm5 = true,
+              .zmm6 = true,
+              .zmm7 = true,
+              .zmm8 = true,
+              .zmm9 = true,
+              .zmm10 = true,
+              .zmm11 = true,
+              .zmm12 = true,
+              .zmm13 = true,
+              .zmm14 = true,
+              .zmm15 = true,
+              .zmm16 = true,
+              .zmm17 = true,
+              .zmm18 = true,
+              .zmm19 = true,
+              .zmm20 = true,
+              .zmm21 = true,
+              .zmm22 = true,
+              .zmm23 = true,
+              .zmm24 = true,
+              .zmm25 = true,
+              .zmm26 = true,
+              .zmm27 = true,
+              .zmm28 = true,
+              .zmm29 = true,
+              .zmm30 = true,
+              .zmm31 = true,
+              .fpsr = true,
+              .fpcr = true,
+              .mxcsr = true,
+              .rflags = true,
+              .dirflag = true,
+              .memory = true,
+            }),
+        else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
+    };
+}
+
+const builtin = @import("builtin");
diff --git a/lib/std/c.zig b/lib/std/c.zig
index 169e6d73b5fbd52e3ccbbb0b0650b4780c3ecb04..67d0540676b16cb4d3c545b04cff120ff0fd46a0 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -10724,6 +10724,7 @@ pub extern "c" fn chmod(path: [*:0]const u8, mode: mode_t) c_int;
 pub extern "c" fn fchmod(fd: fd_t, mode: mode_t) c_int;
 pub extern "c" fn fchmodat(fd: fd_t, path: [*:0]const u8, mode: mode_t, flags: c_uint) c_int;
 pub extern "c" fn fchown(fd: fd_t, owner: uid_t, group: gid_t) c_int;
+pub extern "c" fn fchownat(fd: fd_t, path: [*:0]const u8, owner: uid_t, group: gid_t, flags: c_uint) c_int;
 pub extern "c" fn umask(mode: mode_t) mode_t;
 
 pub extern "c" fn rmdir(path: [*:0]const u8) c_int;
@@ -10864,6 +10865,7 @@ pub const pthread_setname_np = switch (native_os) {
 
 pub extern "c" fn pthread_getname_np(thread: pthread_t, name: [*:0]u8, len: usize) c_int;
 pub extern "c" fn pthread_kill(pthread_t, signal: SIG) c_int;
+pub extern "c" fn pthread_exit(ptr: ?*anyopaque) noreturn;
 
 pub const pthread_threadid_np = switch (native_os) {
     .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => private.pthread_threadid_np,
@@ -11296,16 +11298,7 @@ pub const clock_get_time = darwin.clock_get_time;
 pub const clock_serv_t = darwin.clock_serv_t;
 pub const clock_res_t = darwin.clock_res_t;
 pub const @"close$NOCANCEL" = darwin.@"close$NOCANCEL";
-pub const dispatch_function_t = darwin.dispatch_function_t;
-pub const dispatch_once_f = darwin.dispatch_once_f;
-pub const dispatch_once_t = darwin.dispatch_once_t;
-pub const dispatch_release = darwin.dispatch_release;
-pub const dispatch_semaphore_create = darwin.dispatch_semaphore_create;
-pub const dispatch_semaphore_signal = darwin.dispatch_semaphore_signal;
-pub const dispatch_semaphore_t = darwin.dispatch_semaphore_t;
-pub const dispatch_semaphore_wait = darwin.dispatch_semaphore_wait;
-pub const dispatch_time = darwin.dispatch_time;
-pub const dispatch_time_t = darwin.dispatch_time_t;
+pub const dispatch = darwin.dispatch;
 pub const fcopyfile = darwin.fcopyfile;
 pub const host_t = darwin.host_t;
 pub const integer_t = darwin.integer_t;
diff --git a/lib/std/c/darwin.zig b/lib/std/c/darwin.zig
index 706dc89bf2d99ed2eefa5f21b3767dce7ada1f69..f18b61187c92fb2ddfb2ed4d4e922aaa957632fc 100644
--- a/lib/std/c/darwin.zig
+++ b/lib/std/c/darwin.zig
@@ -18,6 +18,9 @@ comptime {
     assert(builtin.os.tag.isDarwin()); // Prevent access of std.c symbols on wrong OS.
 }
 
+// Grand Central Dispatch is exposed by libSystem.
+pub const dispatch = @import("darwin/dispatch.zig");
+
 pub const mach_port_t = c_uint;
 
 pub const EXC = enum(exception_type_t) {
@@ -896,31 +899,6 @@ pub const qos_class_t = enum(c_uint) {
     _,
 };
 
-// Grand Central Dispatch is exposed by libSystem.
-pub extern "c" fn dispatch_release(object: *anyopaque) void;
-
-pub const dispatch_semaphore_t = *opaque {};
-pub extern "c" fn dispatch_semaphore_create(value: isize) ?dispatch_semaphore_t;
-pub extern "c" fn dispatch_semaphore_wait(dsema: dispatch_semaphore_t, timeout: dispatch_time_t) isize;
-pub extern "c" fn dispatch_semaphore_signal(dsema: dispatch_semaphore_t) isize;
-
-pub const DISPATCH_TIME_NOW = @compileError("use dispatch_time_t.NOW");
-pub const DISPATCH_TIME_FOREVER = @compileError("use dispatch_time_t.FOREVER");
-pub const dispatch_time_t = enum(u64) {
-    NOW = 0,
-    FOREVER = ~0,
-    _,
-};
-pub extern "c" fn dispatch_time(when: dispatch_time_t, delta: i64) dispatch_time_t;
-
-pub const dispatch_once_t = usize;
-pub const dispatch_function_t = fn (?*anyopaque) callconv(.c) void;
-pub extern fn dispatch_once_f(
-    predicate: *dispatch_once_t,
-    context: ?*anyopaque,
-    function: dispatch_function_t,
-) void;
-
 /// Undocumented futex-like API available on darwin 16+
 /// (macOS 10.12+, iOS 10.0+, tvOS 10.0+, watchOS 3.0+, catalyst 13.0+).
 ///
diff --git a/lib/std/c/darwin/dispatch.zig b/lib/std/c/darwin/dispatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2bd44b9f01cd5e636088c4725f68e2a9b3fdfe06
--- /dev/null
+++ b/lib/std/c/darwin/dispatch.zig
@@ -0,0 +1,308 @@
+// dispatch/base.h
+pub const function_t = *const fn (?*anyopaque) callconv(.c) void;
+
+// dispatch/object.h
+pub const object_t = *_os_object_s;
+pub const retain = dispatch_retain;
+pub const release = dispatch_release;
+pub const get_context = dispatch_get_context;
+pub const set_context = dispatch_set_context;
+pub const set_finalizer_f = dispatch_set_finalizer_f;
+pub const activate = dispatch_activate;
+pub const @"suspend" = dispatch_suspend;
+pub const @"resume" = dispatch_resume;
+
+const _os_object_s = opaque {
+    pub const retain = dispatch_retain;
+    pub const release = dispatch_release;
+    pub const get_context = dispatch_get_context;
+    pub const set_context = dispatch_set_context;
+    pub const set_finalizer = dispatch_set_finalizer_f;
+    pub const activate = dispatch_activate;
+    pub const @"suspend" = dispatch_suspend;
+    pub const @"resume" = dispatch_resume;
+    pub const set_target_queue = dispatch_set_target_queue;
+};
+extern "c" fn dispatch_retain(object: object_t) void;
+extern "c" fn dispatch_release(object: object_t) void;
+extern "c" fn dispatch_get_context(object: object_t) ?*anyopaque;
+extern "c" fn dispatch_set_context(object: object_t, context: ?*anyopaque) void;
+extern "c" fn dispatch_set_finalizer_f(object: object_t, finalizer: ?function_t) void;
+extern "c" fn dispatch_activate(object: object_t) void;
+extern "c" fn dispatch_suspend(object: object_t) void;
+extern "c" fn dispatch_resume(object: object_t) void;
+
+// dispatch/once.h
+pub const once_t = enum(isize) {
+    init = 0,
+    done = -1,
+    _,
+
+    pub inline fn once(predicate: *once_t, context: ?*anyopaque, function: function_t) void {
+        if (@atomicLoad(once_t, predicate, .unordered) != .done) {
+            @branchHint(.unlikely);
+            once_f(predicate, context, function);
+        } else asm volatile ("" ::: .{ .memory = true });
+        switch (builtin.mode) {
+            .Debug, .ReleaseSafe => {},
+            .ReleaseFast, .ReleaseSmall => if (@atomicLoad(once_t, predicate, .unordered) != .done)
+                unreachable,
+        }
+    }
+};
+pub const once_f = dispatch_once_f;
+
+extern "c" fn dispatch_once_f(predicate: *once_t, context: ?*anyopaque, function: function_t) void;
+
+// dispatch/queue.h
+pub const queue_t = *queue_s;
+pub const queue_global_t = queue_t;
+pub const queue_serial_executor_t = queue_t;
+pub const queue_serial_t = queue_t;
+pub const queue_main_t = queue_serial_t;
+pub const queue_concurrent_t = queue_t;
+pub const async_f = dispatch_async_f;
+pub const sync_f = dispatch_sync_f;
+pub const async_and_wait_f = dispatch_async_and_wait_f;
+pub const apply_f = dispatch_apply_f;
+pub const get_current_queue = dispatch_get_current_queue;
+pub inline fn get_main_queue() queue_main_t {
+    return &_dispatch_main_q;
+}
+pub const queue_priority_t = enum(c_long) {
+    HIGH = 2,
+    DEFAULT = 0,
+    LOW = -1,
+    BACKGROUND = std.math.minInt(i16),
+    _,
+};
+pub const get_global_queue = dispatch_get_global_queue;
+pub const queue_attr_t = ?*queue_attr_s;
+pub inline fn QUEUE_SERIAL() queue_attr_t {
+    return null;
+}
+pub inline fn QUEUE_INACTIVE() queue_attr_t {
+    return queue_attr_make_initially_inactive(QUEUE_SERIAL());
+}
+pub inline fn QUEUE_CONCURRENT() queue_attr_t {
+    return &_dispatch_queue_attr_concurrent;
+}
+pub inline fn QUEUE_CONCURRENT_INACTIVE() queue_attr_t {
+    return queue_attr_make_initially_inactive(QUEUE_CONCURRENT());
+}
+pub const queue_attr_make_initially_inactive = dispatch_queue_attr_make_initially_inactive;
+pub const TARGET_QUEUE_DEFAULT: ?queue_t = null;
+pub const queue_create_with_target = dispatch_queue_create_with_target;
+pub const queue_create = dispatch_queue_create;
+pub const CURRENT_QUEUE_LABEL: ?[*:0]const u8 = null;
+pub const queue_get_label = dispatch_queue_get_label;
+pub const main = dispatch_main;
+pub const after_f = dispatch_after_f;
+
+const queue_s = opaque {
+    pub inline fn as_object(queue: queue_t) object_t {
+        return @ptrCast(queue);
+    }
+    pub const async = async_f;
+    pub const sync = sync_f;
+    pub const async_and_wait = async_and_wait_f;
+    pub const apply = apply_f;
+    pub const get_current = get_current_queue;
+    pub const get_main = get_main_queue;
+    pub const get_global = get_global_queue;
+    pub const create_with_target = queue_create_with_target;
+    pub const create = queue_create;
+    pub const get_label = queue_get_label;
+};
+extern "c" fn dispatch_async_f(queue: queue_t, context: ?*anyopaque, work: function_t) void;
+extern "c" fn dispatch_sync_f(queue: queue_t, context: ?*anyopaque, work: function_t) void;
+extern "c" fn dispatch_async_and_wait_f(queue: queue_t, context: ?*anyopaque, work: function_t) void;
+extern "c" fn dispatch_apply_f(iterations: usize, queue: ?queue_t, context: ?*anyopaque, work: *const fn (context: ?*anyopaque, iteration: usize) callconv(.c) void) void;
+extern "c" fn dispatch_get_current_queue() queue_t;
+extern "c" var _dispatch_main_q: queue_s;
+extern "c" fn dispatch_get_global_queue(identifier: isize, flags: usize) queue_global_t;
+const queue_attr_s = opaque {
+    pub inline fn as_object(queue_attr: queue_attr_t) object_t {
+        return @ptrCast(queue_attr);
+    }
+    pub const SERIAL = QUEUE_SERIAL;
+    pub const INACTIVE = QUEUE_INACTIVE;
+    pub const CONCURRENT = QUEUE_CONCURRENT;
+    pub const CONCURRENT_INACTIVE = QUEUE_CONCURRENT_INACTIVE;
+};
+extern "c" var _dispatch_queue_attr_concurrent: queue_attr_s;
+extern "c" fn dispatch_queue_attr_make_initially_inactive(attr: queue_attr_t) queue_attr_t;
+extern "c" fn dispatch_queue_create_with_target(label: ?[*:0]const u8, attr: queue_attr_t, target: ?queue_t) ?queue_t;
+extern "c" fn dispatch_queue_create(label: ?[*:0]const u8, attr: queue_attr_t) ?queue_t;
+extern "c" fn dispatch_queue_get_label(queue: ?queue_t) [*:0]const u8;
+extern "c" fn dispatch_set_target_queue(object: object_t, queue: ?queue_t) void;
+extern "c" fn dispatch_main() noreturn;
+extern "c" fn dispatch_after_f(when: time_t, queue: queue_t, context: ?*anyopaque, work: function_t) void;
+
+// dispatch/semaphore.h
+pub const semaphore_t = *semaphore_s;
+pub const semaphore_create = dispatch_semaphore_create;
+pub const semaphore_wait = dispatch_semaphore_wait;
+pub const semaphore_signal = dispatch_semaphore_signal;
+
+const semaphore_s = opaque {
+    pub inline fn as_object(semaphore: semaphore_t) object_t {
+        return @ptrCast(semaphore);
+    }
+    pub const create = semaphore_create;
+    pub const wait = semaphore_wait;
+    pub const signal = semaphore_signal;
+};
+extern "c" fn dispatch_semaphore_create(value: isize) ?semaphore_t;
+extern "c" fn dispatch_semaphore_wait(dsema: semaphore_t, timeout: time_t) isize;
+extern "c" fn dispatch_semaphore_signal(dsema: semaphore_t) isize;
+
+// dispatch/source.h
+pub const source_t = *source_s;
+pub const source_type_t = *const source_type_s;
+pub const SOURCE_TYPE_DATA_ADD = &_dispatch_source_type_data_add;
+pub const SOURCE_TYPE_DATA_OR = &_dispatch_source_type_data_or;
+pub const SOURCE_TYPE_DATA_REPLACE = &_dispatch_source_type_data_replace;
+pub const SOURCE_TYPE_MACH_SEND = &_dispatch_source_type_mach_send;
+pub const SOURCE_TYPE_MACH_RECV = &_dispatch_source_type_mach_recv;
+pub const SOURCE_TYPE_MEMORYPRESSURE = &_dispatch_source_type_memorypressure;
+pub const SOURCE_TYPE_PROC = &_dispatch_source_type_proc;
+pub const SOURCE_TYPE_READ = &_dispatch_source_type_read;
+pub const SOURCE_TYPE_SIGNAL = &_dispatch_source_type_signal;
+pub const SOURCE_TYPE_TIMER = &_dispatch_source_type_timer;
+pub const SOURCE_TYPE_VNODE = &_dispatch_source_type_vnode;
+pub const SOURCE_TYPE_WRITE = &_dispatch_source_type_write;
+pub const source_mach_send_flags_t = packed struct(usize) {
+    DEAD: bool = false,
+    unused1: @Int(.unsigned, @bitSizeOf(usize) - 1) = 0,
+};
+pub const source_mach_recv_flags_t = packed struct(usize) {
+    unused0: @Int(.unsigned, @bitSizeOf(usize) - 0) = 0,
+};
+pub const source_memorypressure_flags_t = packed struct(usize) {
+    NORMAL: bool = false,
+    WARN: bool = false,
+    CRITICAL: bool = false,
+    unused3: @Int(.unsigned, @bitSizeOf(usize) - 3) = 0,
+};
+pub const source_proc_flags_t = packed struct(usize) {
+    unused0: u27 = 0,
+    SIGNAL: bool = false,
+    unused28: u1 = 0,
+    EXEC: bool = false,
+    FORK: bool = false,
+    EXIT: bool = false,
+    unused32: @Int(.unsigned, @bitSizeOf(usize) - 32) = 0,
+};
+pub const source_vnode_flags_t = packed struct(usize) {
+    DELETE: bool = false,
+    WRITE: bool = false,
+    EXTEND: bool = false,
+    ATTRIB: bool = false,
+    LINK: bool = false,
+    RENAME: bool = false,
+    REVOKE: bool = false,
+    unused7: u1 = 0,
+    FUNLOCK: bool = false,
+    unused9: @Int(.unsigned, @bitSizeOf(usize) - 9) = 0,
+};
+pub const source_timer_flags_t = packed struct(usize) {
+    STRICT: bool = false,
+    unused1: @Int(.unsigned, @bitSizeOf(usize) - 1) = 0,
+};
+pub const source_flags_t = packed union {
+    raw: usize,
+    MACH_SEND: source_mach_send_flags_t,
+    MACH_RECV: source_mach_recv_flags_t,
+    MEMORYPRESSURE: source_memorypressure_flags_t,
+    PROC: source_proc_flags_t,
+    VNODE: source_vnode_flags_t,
+    pub const none: source_flags_t = .{ .raw = 0 };
+};
+pub const source_create = dispatch_source_create;
+pub const source_set_event_handler_f = dispatch_source_set_event_handler_f;
+pub const source_set_cancel_handler_f = dispatch_source_set_cancel_handler_f;
+pub const source_cancel = dispatch_source_cancel;
+pub const source_testcancel = dispatch_source_testcancel;
+pub const source_get_handle = dispatch_source_get_handle;
+pub const source_get_mask = dispatch_source_get_mask;
+pub const source_get_data = dispatch_source_get_data;
+pub const source_merge_data = dispatch_source_merge_data;
+pub const source_set_timer = dispatch_source_set_timer;
+pub const source_set_registration_handler_f = dispatch_source_set_registration_handler_f;
+
+const source_s = opaque {
+    pub inline fn as_object(source: source_t) object_t {
+        return @ptrCast(source);
+    }
+    pub const set_event_handler = source_set_event_handler_f;
+    pub const set_cancel_handler = source_set_cancel_handler_f;
+    pub const cancel = source_cancel;
+    pub const testcancel = source_testcancel;
+    pub const get_handle = source_get_handle;
+    pub const get_mask = source_get_mask;
+    pub const get_data = source_get_data;
+    pub const merge_data = source_merge_data;
+    pub const set_timer = source_set_timer;
+    pub const set_registration_handler = source_set_registration_handler_f;
+};
+const source_type_s = opaque {
+    pub const DATA_ADD = SOURCE_TYPE_DATA_ADD;
+    pub const DATA_OR = SOURCE_TYPE_DATA_OR;
+    pub const DATA_REPLACE = SOURCE_TYPE_DATA_REPLACE;
+    pub const MACH_SEND = SOURCE_TYPE_MACH_SEND;
+    pub const MACH_RECV = SOURCE_TYPE_MACH_RECV;
+    pub const MEMORYPRESSURE = SOURCE_TYPE_MEMORYPRESSURE;
+    pub const PROC = SOURCE_TYPE_PROC;
+    pub const READ = SOURCE_TYPE_READ;
+    pub const SIGNAL = SOURCE_TYPE_SIGNAL;
+    pub const TIMER = SOURCE_TYPE_TIMER;
+    pub const VNODE = SOURCE_TYPE_VNODE;
+    pub const WRITE = SOURCE_TYPE_WRITE;
+};
+extern "c" const _dispatch_source_type_data_add: source_type_s;
+extern "c" const _dispatch_source_type_data_or: source_type_s;
+extern "c" const _dispatch_source_type_data_replace: source_type_s;
+extern "c" const _dispatch_source_type_mach_send: source_type_s;
+extern "c" const _dispatch_source_type_mach_recv: source_type_s;
+extern "c" const _dispatch_source_type_memorypressure: source_type_s;
+extern "c" const _dispatch_source_type_proc: source_type_s;
+extern "c" const _dispatch_source_type_read: source_type_s;
+extern "c" const _dispatch_source_type_signal: source_type_s;
+extern "c" const _dispatch_source_type_timer: source_type_s;
+extern "c" const _dispatch_source_type_vnode: source_type_s;
+extern "c" const _dispatch_source_type_write: source_type_s;
+extern "c" fn dispatch_source_create(type: source_type_t, handle: usize, mask: source_flags_t, queue: ?queue_t) ?source_t;
+extern "c" fn dispatch_source_set_event_handler_f(source: source_t, handler: ?function_t) void;
+extern "c" fn dispatch_source_set_cancel_handler_f(source: source_t, handler: ?function_t) void;
+extern "c" fn dispatch_source_cancel(source: source_t) void;
+extern "c" fn dispatch_source_testcancel(source: source_t) isize;
+extern "c" fn dispatch_source_get_handle(source: source_t) usize;
+extern "c" fn dispatch_source_get_mask(source: source_t) source_flags_t;
+extern "c" fn dispatch_source_get_data(source: source_t) usize;
+extern "c" fn dispatch_source_merge_data(source: source_t, value: usize) void;
+extern "c" fn dispatch_source_set_timer(source: source_t, start: time_t, interval: u64, leeway: u64) void;
+extern "c" fn dispatch_source_set_registration_handler_f(source: source_t, handler: ?function_t) void;
+
+// dispatch/time.h
+pub const time_t = enum(u64) {
+    WALL_NOW = WALLTIME_NOW,
+    NOW = TIME_NOW,
+    FOREVER = TIME_FOREVER,
+    _,
+
+    pub const time = dispatch_time;
+    pub const walltime = dispatch_walltime;
+    pub const after = dispatch_after_f;
+};
+pub const WALLTIME_NOW = ~@as(u64, 1);
+pub const TIME_NOW: u64 = 0;
+pub const TIME_FOREVER = ~@as(u64, 0);
+pub const time = dispatch_time;
+pub const walltime = dispatch_walltime;
+
+extern "c" fn dispatch_time(when: time_t, delta: i64) time_t;
+extern "c" fn dispatch_walltime(when: ?*const std.c.timespec, delta: i64) time_t;
+
+const builtin = @import("builtin");
+const std = @import("std");
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index a2b5467c1f4aec44657b58f8c33eab8adac47de0..3f40e3cd1e4dee13ccf475f43247382cbf6eeed7 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -533,9 +533,7 @@ pub fn defaultPanic(msg: []const u8, first_trace_addr: ?usize) noreturn {
         else => {},
     }
 
-    // Don't try to cancel during a panic. No need to re-enable cancelation,
-    // because the panic handler doesn't return.
-    _ = std.Options.debug_io.swapCancelProtection(.blocked);
+    std.Options.debug_io.vtable.crashHandler(std.Options.debug_io.userdata);
 
     if (enable_segfault_handler) {
         // If a segfault happens while panicking, we want it to actually segfault, not trigger
@@ -1535,9 +1533,7 @@ fn handleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContextPtr) noret
 }
 
 pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContextPtr) noreturn {
-    // Don't try to cancel during a segfault. No need to re-enable cancelation,
-    // because the segfault handler doesn't return.
-    _ = std.Options.debug_io.swapCancelProtection(.blocked);
+    std.Options.debug_io.vtable.crashHandler(std.Options.debug_io.userdata);
 
     // There is very similar logic to the following in `defaultPanic`.
     switch (panic_stage) {
diff --git a/lib/std/process/Environ.zig b/lib/std/process/Environ.zig
index 45e2385c99a6d56317714b40f2b1161f1613caea..d9ef7aec2ddf7205056b7c3ede163d7c309ae03c 100644
--- a/lib/std/process/Environ.zig
+++ b/lib/std/process/Environ.zig
@@ -39,6 +39,10 @@ pub const GlobalBlock = struct {
     pub const global: GlobalBlock = .{ .use_global = true };
 
     pub fn deinit(_: GlobalBlock, _: Allocator) void {}
+
+    pub fn isEmpty(block: GlobalBlock) bool {
+        return !block.use_global;
+    }
 };
 
 pub const PosixBlock = struct {
@@ -51,6 +55,10 @@ pub const PosixBlock = struct {
         gpa.free(block.slice);
     }
 
+    pub fn isEmpty(block: PosixBlock) bool {
+        return block.slice.len == 0;
+    }
+
     pub const View = struct {
         slice: []const [*:0]const u8,
 
@@ -72,6 +80,10 @@ pub const WindowsBlock = struct {
         gpa.free(block.slice);
     }
 
+    pub fn isEmpty(block: WindowsBlock) bool {
+        return block.slice[0] == 0;
+    }
+
     pub const View = struct {
         ptr: [*:0]const u16,
 
diff --git a/src/crash_report.zig b/src/crash_report.zig
index 1723ad24a0b255cc580fa62f5b5e0906709f880e..f58a7cef7a95ba7e2e8709b798dd35367f9e206b 100644
--- a/src/crash_report.zig
+++ b/src/crash_report.zig
@@ -79,6 +79,8 @@ fn dumpCrashContext() Io.Writer.Error!void {
     if (S.already_dumped) return;
     S.already_dumped = true;
 
+    std.Options.debug_io.vtable.crashHandler(std.Options.debug_io.userdata);
+
     // TODO: this does mean that a different thread could grab the stderr mutex between the context
     // and the actual panic printing, which would be quite confusing.
     const stderr = std.debug.lockStderr(&.{});
-- 
2.54.0


From 0eb1e0c30a4f143dfcb15b4c6a01ec9c566dc39f Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Fri, 13 Feb 2026 12:28:03 -0500
Subject: [PATCH 286/499] crash_report: finish reverting panic changes better

I missed that the types were `pub`.
---
 src/crash_report.zig | 28 +++++++++++++++++++++++-----
 src/main.zig         |  8 ++------
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/src/crash_report.zig b/src/crash_report.zig
index f58a7cef7a95ba7e2e8709b798dd35367f9e206b..b177af3bb6033ffc4e10e15a8aaf7c7e74c0bf03 100644
--- a/src/crash_report.zig
+++ b/src/crash_report.zig
@@ -1,13 +1,18 @@
+pub const enabled = switch (build_options.io_mode) {
+    .threaded => build_options.enable_debug_extensions,
+    .evented => false, // would use threadlocals in a way incompatible with evented
+};
+
 /// We override the panic implementation to our own one, so we can print our own information before
 /// calling the default panic handler. This declaration must be re-exposed from `@import("root")`.
-pub const panic = std.debug.FullPanic(panicImpl);
+pub const panic = std.debug.FullPanic(if (enabled) panicImpl else std.debug.defaultPanic);
 
 /// We let std install its segfault handler, but we override the target-agnostic handler it calls,
 /// so we can print our own information before calling the default segfault logic. This declaration
 /// must be re-exposed from `@import("root")`.
-pub const debug = struct {
+pub const debug = if (enabled) struct {
     pub const handleSegfault = handleSegfaultImpl;
-};
+} else struct {};
 
 /// Printed in panic messages when suggesting a command to run, allowing copy-pasting the command.
 /// Set by `main` as soon as arguments are known. The value here is a default in case we somehow
@@ -25,7 +30,7 @@ fn panicImpl(msg: []const u8, first_trace_addr: ?usize) noreturn {
     std.debug.defaultPanic(msg, first_trace_addr orelse @returnAddress());
 }
 
-pub const AnalyzeBody = struct {
+pub const AnalyzeBody = if (enabled) struct {
     parent: ?*AnalyzeBody,
     sema: *Sema,
     block: *Sema.Block,
@@ -52,9 +57,15 @@ pub const AnalyzeBody = struct {
         std.debug.assert(current.? == ab); // `Sema.analyzeBodyInner` did not match push/pop calls
         current = ab.parent;
     }
+} else struct {
+    const current: ?noreturn = null;
+    // Dummy implementation, with functions marked `inline` to avoid interfering with tail calls.
+    pub inline fn push(_: AnalyzeBody, _: *Sema, _: *Sema.Block, _: []const Zir.Inst.Index) void {}
+    pub inline fn pop(_: AnalyzeBody) void {}
+    pub inline fn setBodyIndex(_: @This(), _: usize) void {}
 };
 
-pub const CodegenFunc = struct {
+pub const CodegenFunc = if (enabled) struct {
     zcu: *const Zcu,
     func_index: InternPool.Index,
     threadlocal var current: ?CodegenFunc = null;
@@ -66,6 +77,11 @@ pub const CodegenFunc = struct {
         std.debug.assert(current.?.func_index == func_index);
         current = null;
     }
+} else struct {
+    const current: ?noreturn = null;
+    // Dummy implementation
+    pub fn start(_: *const Zcu, _: InternPool.Index) void {}
+    pub fn stop(_: InternPool.Index) void {}
 };
 
 fn dumpCrashContext() Io.Writer.Error!void {
@@ -172,3 +188,5 @@ const Zcu = @import("Zcu.zig");
 const InternPool = @import("InternPool.zig");
 const dev = @import("dev.zig");
 const print_zir = @import("print_zir.zig");
+
+const build_options = @import("build_options");
diff --git a/src/main.zig b/src/main.zig
index 89a24559ed7a89ea3732f22277a6595c8f1e4606..1b9fe7b299406c76724d3690fa4c0ae20d74b1ba 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -52,12 +52,8 @@ pub const std_options: std.Options = .{
 };
 pub const std_options_cwd = if (native_os == .wasi) wasi_cwd else null;
 
-const crash_report_enabled = switch (build_options.io_mode) {
-    .threaded => build_options.enable_debug_extensions,
-    .evented => false, // would use threadlocals in a way incompatible with evented
-};
-pub const panic = if (crash_report_enabled) crash_report.panic else std.debug.FullPanic(std.debug.defaultPanic);
-pub const debug = if (crash_report_enabled) crash_report.debug else struct {};
+pub const panic = crash_report.panic;
+pub const debug = crash_report.debug;
 
 var preopens: std.process.Preopens = .empty;
 pub fn wasi_cwd() Io.Dir {
-- 
2.54.0


From 4ea99049230b5be00ca5a09d3a3fd78ecba30594 Mon Sep 17 00:00:00 2001
From: rpkak <rpkak@noreply.codeberg.org>
Date: Fri, 13 Feb 2026 09:01:30 +0100
Subject: [PATCH 287/499] remove some unused libc files

---
 lib/libc/mingw/misc/setjmp.S          | 119 --------------------------
 lib/libc/musl/src/locale/strcoll.c    |  15 ----
 lib/libc/musl/src/locale/strxfrm.c    |  18 ----
 lib/libc/musl/src/math/aarch64/rint.c |   7 --
 lib/libc/musl/src/math/i386/rint.c    |   7 --
 lib/libc/musl/src/math/roundl.c       |  37 --------
 6 files changed, 203 deletions(-)
 delete mode 100644 lib/libc/mingw/misc/setjmp.S
 delete mode 100644 lib/libc/musl/src/locale/strcoll.c
 delete mode 100644 lib/libc/musl/src/locale/strxfrm.c
 delete mode 100644 lib/libc/musl/src/math/aarch64/rint.c
 delete mode 100644 lib/libc/musl/src/math/i386/rint.c
 delete mode 100644 lib/libc/musl/src/math/roundl.c

diff --git a/lib/libc/mingw/misc/setjmp.S b/lib/libc/mingw/misc/setjmp.S
deleted file mode 100644
index 2baaae49c8bfda597153ac992147f25048366673..0000000000000000000000000000000000000000
--- a/lib/libc/mingw/misc/setjmp.S
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-
-#include <_mingw_mac.h>
-
-#ifndef __arm64ec__
-        .globl  __MINGW_USYMBOL(__intrinsic_setjmp)
-        .def    __MINGW_USYMBOL(__intrinsic_setjmp); .scl 2; .type 32; .endef
-
-#if defined(_WIN64)
-        .globl  __MINGW_USYMBOL(__intrinsic_setjmpex)
-        .def    __MINGW_USYMBOL(__intrinsic_setjmpex); .scl 2; .type 32; .endef
-#endif
-
-#if defined(__i386__)
-        .globl  __MINGW_USYMBOL(_setjmp3)
-        .def    __MINGW_USYMBOL(_setjmp3); .scl 2; .type 32; .endef
-__MINGW_USYMBOL(_setjmp3):
-__MINGW_USYMBOL(__intrinsic_setjmp):
-        movl    4(%esp),%ecx         /* jmp_buf */
-        movl    %ebp,0(%ecx)         /* jmp_buf.Ebp */
-        movl    %ebx,4(%ecx)         /* jmp_buf.Ebx */
-        movl    %edi,8(%ecx)         /* jmp_buf.Edi */
-        movl    %esi,12(%ecx)        /* jmp_buf.Esi */
-        movl    %esp,16(%ecx)        /* jmp_buf.Esp */
-        movl    0(%esp),%eax
-        movl    %eax,20(%ecx)        /* jmp_buf.Eip */
-        xorl    %eax, %eax
-        retl
-
-#elif defined(__x86_64__)
-        .globl  __MINGW_USYMBOL(setjmp)
-        .def    __MINGW_USYMBOL(setjmp); .scl 2; .type 32; .endef
-__MINGW_USYMBOL(setjmp):
-__MINGW_USYMBOL(__intrinsic_setjmp):
-        xorq    %rdx,%rdx
-__MINGW_USYMBOL(__intrinsic_setjmpex):
-        movq    %rdx,(%rcx)          /* jmp_buf->Frame */
-        movq    %rbx,0x8(%rcx)       /* jmp_buf->Rbx */
-        leaq    0x8(%rsp),%rax
-        movq    %rax,0x10(%rcx)      /* jmp_buf->Rsp */
-        movq    %rbp,0x18(%rcx)      /* jmp_buf->Rbp */
-        movq    %rsi,0x20(%rcx)      /* jmp_buf->Rsi */
-        movq    %rdi,0x28(%rcx)      /* jmp_buf->Rdi */
-        movq    %r12,0x30(%rcx)      /* jmp_buf->R12 */
-        movq    %r13,0x38(%rcx)      /* jmp_buf->R13 */
-        movq    %r14,0x40(%rcx)      /* jmp_buf->R14 */
-        movq    %r15,0x48(%rcx)      /* jmp_buf->R15 */
-        movq    (%rsp),%rax
-        movq    %rax,0x50(%rcx)      /* jmp_buf->Rip */
-        stmxcsr 0x58(%rcx)           /* jmp_buf->MxCsr */
-        fnstcw  0x5c(%rcx)           /* jmp_buf->FpCsr */
-        movdqa  %xmm6,0x60(%rcx)     /* jmp_buf->Xmm6 */
-        movdqa  %xmm7,0x70(%rcx)     /* jmp_buf->Xmm7 */
-        movdqa  %xmm8,0x80(%rcx)     /* jmp_buf->Xmm8 */
-        movdqa  %xmm9,0x90(%rcx)     /* jmp_buf->Xmm9 */
-        movdqa  %xmm10,0xa0(%rcx)    /* jmp_buf->Xmm10 */
-        movdqa  %xmm11,0xb0(%rcx)    /* jmp_buf->Xmm11 */
-        movdqa  %xmm12,0xc0(%rcx)    /* jmp_buf->Xmm12 */
-        movdqa  %xmm13,0xd0(%rcx)    /* jmp_buf->Xmm13 */
-        movdqa  %xmm14,0xe0(%rcx)    /* jmp_buf->Xmm14 */
-        movdqa  %xmm15,0xf0(%rcx)    /* jmp_buf->Xmm15 */
-        xorq    %rax,%rax
-        retq
-
-#elif defined(__arm__)
-__MINGW_USYMBOL(__intrinsic_setjmp):
-        mov     r1,  #0
-        str     r1,  [r0]            /* jmp_buf->Frame */
-        str     r4,  [r0, #0x4]      /* jmp_buf->R4 */
-        str     r5,  [r0, #0x8]      /* jmp_buf->R5 */
-        str     r6,  [r0, #0xc]      /* jmp_buf->R6 */
-        str     r7,  [r0, #0x10]     /* jmp_buf->R7 */
-        str     r8,  [r0, #0x14]     /* jmp_buf->R8 */
-        str     r9,  [r0, #0x18]     /* jmp_buf->R9 */
-        str     r10, [r0, #0x1c]     /* jmp_buf->R10 */
-        str     r11, [r0, #0x20]     /* jmp_buf->R11 */
-        str     sp,  [r0, #0x24]     /* jmp_buf->Sp */
-        str     lr,  [r0, #0x28]     /* jmp_buf->Pc */
-        vmrs    r2,  fpscr
-        str     r2,  [r0, #0x2c]     /* jmp_buf->Fpscr */
-        vstr    d8,  [r0, #0x30]     /* jmp_buf->D[0] */
-        vstr    d9,  [r0, #0x38]     /* jmp_buf->D[1] */
-        vstr    d10, [r0, #0x40]     /* jmp_buf->D[2] */
-        vstr    d11, [r0, #0x48]     /* jmp_buf->D[3] */
-        vstr    d12, [r0, #0x50]     /* jmp_buf->D[4] */
-        vstr    d13, [r0, #0x58]     /* jmp_buf->D[5] */
-        vstr    d14, [r0, #0x60]     /* jmp_buf->D[6] */
-        vstr    d15, [r0, #0x68]     /* jmp_buf->D[7] */
-        mov     r0,  #0
-        bx      lr
-#elif defined(__aarch64__)
-__MINGW_USYMBOL(__intrinsic_setjmp):
-        mov     x1,  #0
-__MINGW_USYMBOL(__intrinsic_setjmpex):
-        str     x1,  [x0]             /* jmp_buf->Frame */
-        stp     x19, x20, [x0, #0x10] /* jmp_buf->X19, X20 */
-        stp     x21, x22, [x0, #0x20] /* jmp_buf->X21, X22 */
-        stp     x23, x24, [x0, #0x30] /* jmp_buf->X23, X24 */
-        stp     x25, x26, [x0, #0x40] /* jmp_buf->X25, X26 */
-        stp     x27, x28, [x0, #0x50] /* jmp_buf->X27, X28 */
-        stp     x29, x30, [x0, #0x60] /* jmp_buf->Fp,  Lr  */
-        mov     x2,  sp
-        str     x2,       [x0, #0x70] /* jmp_buf->Sp */
-        mrs     x2,  fpcr
-        str     w2,       [x0, #0x78] /* jmp_buf->Fpcr */
-        mrs     x2,  fpsr
-        str     w2,       [x0, #0x7c] /* jmp_buf->Fpsr */
-        stp     d8,  d9,  [x0, #0x80] /* jmp_buf->D[0-1] */
-        stp     d10, d11, [x0, #0x90] /* jmp_buf->D[2-3] */
-        stp     d12, d13, [x0, #0xa0] /* jmp_buf->D[4-5] */
-        stp     d14, d15, [x0, #0xb0] /* jmp_buf->D[6-7] */
-        mov     x0,  #0
-        ret
-#endif
-#endif /* __arm64ec__ */
diff --git a/lib/libc/musl/src/locale/strcoll.c b/lib/libc/musl/src/locale/strcoll.c
deleted file mode 100644
index dd3cbc480e34520fd62628d43ede7f11c0d92611..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/locale/strcoll.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <string.h>
-#include <locale.h>
-#include "locale_impl.h"
-
-int __strcoll_l(const char *l, const char *r, locale_t loc)
-{
-	return strcmp(l, r);
-}
-
-int strcoll(const char *l, const char *r)
-{
-	return __strcoll_l(l, r, CURRENT_LOCALE);
-}
-
-weak_alias(__strcoll_l, strcoll_l);
diff --git a/lib/libc/musl/src/locale/strxfrm.c b/lib/libc/musl/src/locale/strxfrm.c
deleted file mode 100644
index c66c62039d9593ac8b9d0ca732ce8c98e9107555..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/locale/strxfrm.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <string.h>
-#include <locale.h>
-#include "locale_impl.h"
-
-/* collate only by code points */
-size_t __strxfrm_l(char *restrict dest, const char *restrict src, size_t n, locale_t loc)
-{
-	size_t l = strlen(src);
-	if (n > l) strcpy(dest, src);
-	return l;
-}
-
-size_t strxfrm(char *restrict dest, const char *restrict src, size_t n)
-{
-	return __strxfrm_l(dest, src, n, CURRENT_LOCALE);
-}
-
-weak_alias(__strxfrm_l, strxfrm_l);
diff --git a/lib/libc/musl/src/math/aarch64/rint.c b/lib/libc/musl/src/math/aarch64/rint.c
deleted file mode 100644
index 45b194b5e4959c95a60b68202dbdbabf60a7d420..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/aarch64/rint.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <math.h>
-
-double rint(double x)
-{
-	__asm__ ("frintx %d0, %d1" : "=w"(x) : "w"(x));
-	return x;
-}
diff --git a/lib/libc/musl/src/math/i386/rint.c b/lib/libc/musl/src/math/i386/rint.c
deleted file mode 100644
index a5276a60d8f4c0baa6e72836ea43f24b03fb4666..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/rint.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <math.h>
-
-double rint(double x)
-{
-	__asm__ ("frndint" : "+t"(x));
-	return x;
-}
diff --git a/lib/libc/musl/src/math/roundl.c b/lib/libc/musl/src/math/roundl.c
deleted file mode 100644
index f4ff6820a982276321f6bfe8198e0975c7016017..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/roundl.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "libm.h"
-
-#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double roundl(long double x)
-{
-	return round(x);
-}
-#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-
-static const long double toint = 1/LDBL_EPSILON;
-
-long double roundl(long double x)
-{
-	union ldshape u = {x};
-	int e = u.i.se & 0x7fff;
-	long double y;
-
-	if (e >= 0x3fff+LDBL_MANT_DIG-1)
-		return x;
-	if (u.i.se >> 15)
-		x = -x;
-	if (e < 0x3fff-1) {
-		FORCE_EVAL(x + toint);
-		return 0*u.f;
-	}
-	y = x + toint - toint - x;
-	if (y > 0.5)
-		y = y + x - 1;
-	else if (y <= -0.5)
-		y = y + x + 1;
-	else
-		y = y + x;
-	if (u.i.se >> 15)
-		y = -y;
-	return y;
-}
-#endif
-- 
2.54.0


From 3dc2a1f9ac572e1205cc2202e12f4d948ca67fd5 Mon Sep 17 00:00:00 2001
From: "kj4tmp@gmail.com" <kj4tmp@gmail.com>
Date: Sun, 25 Jan 2026 00:00:41 -0800
Subject: [PATCH 288/499] zig libc: acosf

---
 lib/c/math.zig                      |  5 ++
 lib/libc/musl/src/math/acosf.c      | 71 -----------------------------
 lib/libc/musl/src/math/i386/acosf.s | 16 -------
 src/libs/musl.zig                   |  2 -
 src/libs/wasi_libc.zig              |  1 -
 test/libc.zig                       |  2 +-
 6 files changed, 6 insertions(+), 91 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/acosf.c
 delete mode 100644 lib/libc/musl/src/math/i386/acosf.s

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 2c02597bb2271bd9a83cf6f4cf35b8cd8afdf9fc..cce37f9000858b41b08d14a9012f5e607a2b2367 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -51,6 +51,7 @@ comptime {
         symbol(&pow, "pow");
         symbol(&pow10, "pow10");
         symbol(&pow10f, "pow10f");
+        symbol(&acosf, "acosf");
     }
 
     if (builtin.target.isMuslLibC()) {
@@ -84,6 +85,10 @@ fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
     };
 }
 
+fn acosf(x: f32) callconv(.c) f32 {
+    return std.math.acos(x);
+}
+
 fn isnan(x: f64) callconv(.c) c_int {
     return if (math.isNan(x)) 1 else 0;
 }
diff --git a/lib/libc/musl/src/math/acosf.c b/lib/libc/musl/src/math/acosf.c
deleted file mode 100644
index 8ee1a71d0cc2965e08e170be1dc4529d0165f3b4..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/acosf.c
+++ /dev/null
@@ -1,71 +0,0 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/e_acosf.c */
-/*
- * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
- */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-#include "libm.h"
-
-static const float
-pio2_hi = 1.5707962513e+00, /* 0x3fc90fda */
-pio2_lo = 7.5497894159e-08, /* 0x33a22168 */
-pS0 =  1.6666586697e-01,
-pS1 = -4.2743422091e-02,
-pS2 = -8.6563630030e-03,
-qS1 = -7.0662963390e-01;
-
-static float R(float z)
-{
-	float_t p, q;
-	p = z*(pS0+z*(pS1+z*pS2));
-	q = 1.0f+z*qS1;
-	return p/q;
-}
-
-float acosf(float x)
-{
-	float z,w,s,c,df;
-	uint32_t hx,ix;
-
-	GET_FLOAT_WORD(hx, x);
-	ix = hx & 0x7fffffff;
-	/* |x| >= 1 or nan */
-	if (ix >= 0x3f800000) {
-		if (ix == 0x3f800000) {
-			if (hx >> 31)
-				return 2*pio2_hi + 0x1p-120f;
-			return 0;
-		}
-		return 0/(x-x);
-	}
-	/* |x| < 0.5 */
-	if (ix < 0x3f000000) {
-		if (ix <= 0x32800000) /* |x| < 2**-26 */
-			return pio2_hi + 0x1p-120f;
-		return pio2_hi - (x - (pio2_lo-x*R(x*x)));
-	}
-	/* x < -0.5 */
-	if (hx >> 31) {
-		z = (1+x)*0.5f;
-		s = sqrtf(z);
-		w = R(z)*s-pio2_lo;
-		return 2*(pio2_hi - (s+w));
-	}
-	/* x > 0.5 */
-	z = (1-x)*0.5f;
-	s = sqrtf(z);
-	GET_FLOAT_WORD(hx,s);
-	SET_FLOAT_WORD(df,hx&0xfffff000);
-	c = (z-df*df)/(s+df);
-	w = R(z)*s+c;
-	return 2*(df+w);
-}
diff --git a/lib/libc/musl/src/math/i386/acosf.s b/lib/libc/musl/src/math/i386/acosf.s
deleted file mode 100644
index d2cdfdbfefd6f15a0c94540e42d57fa9b9f27077..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/i386/acosf.s
+++ /dev/null
@@ -1,16 +0,0 @@
-.global acosf
-.type acosf,@function
-acosf:
-	flds 4(%esp)
-	fld %st(0)
-	fld1
-	fsub %st(0),%st(1)
-	fadd %st(2)
-	fmulp
-	fsqrt
-	fabs         # fix sign of zero (matters in downward rounding mode)
-	fxch %st(1)
-	fpatan
-	fstps 4(%esp)
-	flds 4(%esp)
-	ret
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index 3f2739ec714d9d879bf73b340f55ac2b4d62e055..d8f5fe28121d5b1e93507bae4edee26c2456ea57 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -798,7 +798,6 @@ const src_files = [_][]const u8{
     "musl/src/math/aarch64/nearbyint.c",
     "musl/src/math/aarch64/nearbyintf.c",
     "musl/src/math/aarch64/rintf.c",
-    "musl/src/math/acosf.c",
     "musl/src/math/acosh.c",
     "musl/src/math/acoshf.c",
     "musl/src/math/acoshl.c",
@@ -852,7 +851,6 @@ const src_files = [_][]const u8{
     "musl/src/math/frexp.c",
     "musl/src/math/frexpf.c",
     "musl/src/math/frexpl.c",
-    "musl/src/math/i386/acosf.s",
     "musl/src/math/i386/acosl.s",
     "musl/src/math/i386/asinf.s",
     "musl/src/math/i386/asinl.s",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 869c4d52dae7ccdd3388889714a91f83c5b0c159..0bdcb724c50c1db7a6253f042d20e0fb4c2e09c9 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -664,7 +664,6 @@ const libc_top_half_src_files = [_][]const u8{
     "musl/src/locale/strtod_l.c",
     "musl/src/locale/wcscoll.c",
     "musl/src/locale/wcsxfrm.c",
-    "musl/src/math/acosf.c",
     "musl/src/math/acosh.c",
     "musl/src/math/acoshf.c",
     "musl/src/math/acoshl.c",
diff --git a/test/libc.zig b/test/libc.zig
index 57581ca32e9e51710a300588a12d61a3a44caba2..f2c34af560947dae39d56ea5f184c8ceeadb5903 100644
--- a/test/libc.zig
+++ b/test/libc.zig
@@ -139,7 +139,7 @@ pub fn addCases(cases: *tests.LibcContext) void {
     cases.addLibcTestCase("regression/wcsstr-false-negative.c", true, .{});
 
     cases.addLibcTestCase("math/acos.c", true, .{});
-    // cases.addLibcTestCase("math/acosf.c", true, .{});
+    cases.addLibcTestCase("math/acosf.c", true, .{});
     // cases.addLibcTestCase("math/acosh.c", true, .{});
     cases.addLibcTestCase("math/acoshf.c", true, .{});
     // cases.addLibcTestCase("math/acoshl.c", true, .{});
-- 
2.54.0


From 004872baec3fc71236ee6503a6e0885a4bae7dd0 Mon Sep 17 00:00:00 2001
From: "kj4tmp@gmail.com" <kj4tmp@gmail.com>
Date: Wed, 28 Jan 2026 22:42:45 -0800
Subject: [PATCH 289/499] zig libc: acosf: fix fp exceptions

some fp exceptions are prohibited by zig test-libc (libc-test).
Promoting to f64 prevents vectorization of some floating point
divisions. The vectorization has unused lanes which contain zero. On
division the lanes containing zero are divided and trigger the INVALID
fp flags.
---
 lib/std/math/acos.zig | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig
index dae3f70c82dfa1839e6112ba7135e32e9c65ef1f..b163551d0aae2c90730855a4efbfbf4d93571969 100644
--- a/lib/std/math/acos.zig
+++ b/lib/std/math/acos.zig
@@ -81,9 +81,13 @@ fn rationalApproxBinary32(z: f32) f32 {
     const pS2: f32 = -8.6563630030e-03;
     const qS1: f32 = -7.0662963390e-01;
 
-    const p = z * (pS0 + z * (pS1 + z * pS2));
-    const q = 1.0 + z * qS1;
-    return p / q;
+    // f64 is used instead of f32 to avoid
+    // a vectorization on x86_64. The vectorization
+    // causes extra floating point execeptions
+    // that are prohibited by libc-test.
+    const p: f64 = @as(f64, @floatCast(z)) * (pS0 + z * (pS1 + z * pS2));
+    const q: f64 = 1.0 + z * qS1;
+    return @floatCast(p / q);
 }
 
 fn acosBinary32(x: f32) f32 {
-- 
2.54.0


From fd74c5742d3c8343868516c03a6a0695280744d1 Mon Sep 17 00:00:00 2001
From: hubidubi <hubidubi@noreply.codeberg.org>
Date: Fri, 13 Feb 2026 20:39:38 +0100
Subject: [PATCH 290/499] std.Io.Threaded: fix FreeBSD Futex max_waiters
 (#30094)

On FreeBSD, the maximum waiters should be Cs INT_MAX instead of the maximum of a u32. Waiting for the Io.Event in the broadcast test triggers this bug.

Resolves #30715

Co-authored-by: Simon Galli <hubi@hubidubi.net>
Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30094
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: hubidubi <hubidubi@noreply.codeberg.org>
Co-committed-by: hubidubi <hubidubi@noreply.codeberg.org>
---
 lib/std/Io/Threaded.zig |  2 +-
 lib/std/Io/test.zig     | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 60ee5df9451529265acfb25ca95e0db1b0862d4e..88ec774771371d35b47e98f8cf314853ff224611 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1104,7 +1104,7 @@ const Thread = struct {
                 const rc = std.c._umtx_op(
                     @intFromPtr(ptr),
                     @intFromEnum(std.c.UMTX_OP.WAKE_PRIVATE),
-                    @as(c_ulong, max_waiters),
+                    @as(c_ulong, @min(max_waiters, std.math.maxInt(c_int))),
                     0, // there is no timeout struct
                     0, // there is no timeout struct pointer
                 );
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 70af7a25ee2c909492ff53fb56ecfdfb337e5ac7..7b652a495e899891743cb880a567eb7da9e74a5c 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -818,10 +818,11 @@ test "Event broadcast" {
         event: Io.Event = .unset,
         counter: std.atomic.Value(usize) = std.atomic.Value(usize).init(num_threads),
 
-        fn wait(self: *@This()) void {
+        fn wait(self: *@This()) !void {
             if (self.counter.fetchSub(1, .acq_rel) == 1) {
                 self.event.set(io);
             }
+            try self.event.wait(io);
         }
     };
 
@@ -829,9 +830,9 @@ test "Event broadcast" {
         start_barrier: Barrier = .{},
         finish_barrier: Barrier = .{},
 
-        fn run(self: *@This()) void {
-            self.start_barrier.wait();
-            self.finish_barrier.wait();
+        fn run(self: *@This()) !void {
+            try self.start_barrier.wait();
+            try self.finish_barrier.wait();
         }
     };
 
@@ -841,5 +842,5 @@ test "Event broadcast" {
     for (&threads) |*t| t.* = try std.Thread.spawn(.{}, Context.run, .{&ctx});
     defer for (threads) |t| t.join();
 
-    ctx.run();
+    try ctx.run();
 }
-- 
2.54.0


From 07b08b96389a1dd60bc150a5ed72586ee57b2303 Mon Sep 17 00:00:00 2001
From: Chris Boesch <chrboesch@noreply.codeberg.org>
Date: Fri, 13 Feb 2026 20:49:14 +0100
Subject: [PATCH 291/499] compiler_rt: Implemented missing handling of denormal
 numbers when dividing f128 (#30198)

Replaces the "flush denormals to zero" placeholder in divtf3.zig with IEEE 754 denormal support including rounding.

fixes #30179

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30198
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: Chris Boesch <chrboesch@noreply.codeberg.org>
Co-committed-by: Chris Boesch <chrboesch@noreply.codeberg.org>
---
 lib/compiler_rt/divtf3.zig      | 25 ++++++++++++++++++++++---
 lib/compiler_rt/divtf3_test.zig |  5 +++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/lib/compiler_rt/divtf3.zig b/lib/compiler_rt/divtf3.zig
index db495ee0a44d8f2325c15ea8351a44cbf3f7f0be..d5d76c3c8cbed966e6eb03fb3e555d2b2e948160 100644
--- a/lib/compiler_rt/divtf3.zig
+++ b/lib/compiler_rt/divtf3.zig
@@ -222,10 +222,29 @@ inline fn div(a: f128, b: f128) f128 {
                 // The rounded result is normal; return it.
                 return @bitCast(absResult | quotientSign);
             }
+            // Result is denormal with exponent 0
+            return @bitCast(absResult | quotientSign);
+        } else {
+            // For denormals with writtenExponent < 0,
+            // the implicit bit must be shifted into the mantissa (IEEE 754)
+            const shiftAmount = @as(u7, @intCast(1 - writtenExponent));
+
+            // Check for underflow
+            if (shiftAmount > significandBits) {
+                return @bitCast(quotientSign);
+            }
+
+            // Round the quotient before pushing
+            const shouldRound = (residual << 1) > bSignificand;
+            const roundedQuotient = quotient +% @as(u113, @intFromBool(shouldRound));
+
+            // Move to the denormal range and apply the mask
+            const denormQuotient = roundedQuotient >> shiftAmount;
+            const absResult = denormQuotient & significandMask;
+
+            //  Add sign to denormal mantissa and return
+            return @bitCast(absResult | quotientSign);
         }
-        // Flush denormals to zero.  In the future, it would be nice to add
-        // code to round them correctly.
-        return @bitCast(quotientSign);
     } else {
         const round = @intFromBool((residual << 1) >= bSignificand);
         // Clear the implicit bit
diff --git a/lib/compiler_rt/divtf3_test.zig b/lib/compiler_rt/divtf3_test.zig
index f8f2b0d188ba01591ee5ec358061a175ad05a5e1..4573d2ed85a6d7581a230ccfe5264de463a57ea6 100644
--- a/lib/compiler_rt/divtf3_test.zig
+++ b/lib/compiler_rt/divtf3_test.zig
@@ -46,4 +46,9 @@ test "divtf3" {
     try test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078);
     try test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0);
     try test__divtf3(1.0, 0x1.ffffffffffffffffffffffffffffp-1, 0x3FFF000000000000, 1);
+
+    try test__divtf3(std.math.floatMin(f128), 2.0, 0x0000800000000000, 0x0000000000000000);
+    try test__divtf3(std.math.floatMin(f128), 4.0, 0x0000400000000000, 0x0000000000000000);
+    try test__divtf3(1.0, 0x1.0000000000000000000000000001p16382, 0x0000ffffffffffff, 0xfffffffffffffffe);
+    try test__divtf3(1.2, std.math.floatMax(f128), 0x00004ccccccccccc, 0xcccccccccccccccd);
 }
-- 
2.54.0


From 8901d38b7d3eab22af87bba9962f5a749fb31661 Mon Sep 17 00:00:00 2001
From: lzm-build <3575188313@qq.com>
Date: Fri, 13 Feb 2026 15:38:49 +0800
Subject: [PATCH 292/499] std.math.atan: Add `@Vector(?,f32)` and
 `@Vector(?,f64)` support

---
 lib/std/math/atan.zig | 219 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 211 insertions(+), 8 deletions(-)

diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig
index 8b783bf3474b7cf260c9ca4930e35200dd6704bd..e88de71dd0c4204532d58d5e42b0d73acc20871b 100644
--- a/lib/std/math/atan.zig
+++ b/lib/std/math/atan.zig
@@ -4,6 +4,12 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/atanf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/atan.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/atanl.c
+//
+// Ported from ARM-software, which is licensed under the MIT license:
+// https://github.com/ARM-software/optimized-routines/blob/master/LICENSE
+//
+// https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/atanf.c
+// https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/atan.c
 
 const std = @import("../std.zig");
 const math = std.math;
@@ -17,14 +23,22 @@ const testing = std.testing;
 ///  - atan(+-inf) = +-pi/2
 pub fn atan(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
-    return switch (T) {
-        f16 => atanBinary16(x),
-        f32 => atanBinary32(x),
-        f64 => atanBinary64(x),
-        f80 => atanExtended80(x),
-        f128 => atanBinary128(x),
-        else => @compileError("atan not implemented for " ++ @typeName(T)),
-    };
+    switch (T) {
+        f16 => return atanBinary16(x),
+        f32 => return atanBinary32(x),
+        f64 => return atanBinary64(x),
+        f80 => return atanExtended80(x),
+        f128 => return atanBinary128(x),
+        else => {
+            const info = @typeInfo(T);
+            if (info == .vector) {
+                const vec_type = info.vector.child;
+                if (vec_type == f32) return atanBinary32Vec(x);
+                if (vec_type == f64) return atanBinary64Vec(x);
+            }
+            @compileError("atan not implemented for " ++ @typeName(T));
+        },
+    }
 }
 
 fn atanBinary16(x: f16) f16 {
@@ -579,3 +593,192 @@ test "atanBinary128" {
     try testing.expectApproxEqAbs(atanBinary128(0x1.299d54ac7d6afc5154643b601519p1), 0x1.2a24e22d861debfd6f974500567fp0, math.floatEpsAt(f128, 0x1.2a24e22d861debfd6f974500567fp0));
     try testing.expectApproxEqAbs(atanBinary128(-0x1.0264fb9f3d50e4f0f966f0686064p1), -0x1.1c617825f97512b7f38656ab12cdp0, math.floatEpsAt(f128, -0x1.1c617825f97512b7f38656ab12cdp0));
 }
+
+fn atanBinary32Vec(x: anytype) @TypeOf(x) {
+    const type_info = @typeInfo(@TypeOf(x));
+    comptime std.debug.assert(type_info.vector.child == f32);
+    const vec_len = type_info.vector.len;
+    const sign_mask: @Vector(vec_len, u32) = @splat(0x80000000);
+    const neg_one: @Vector(vec_len, f32) = @splat(-1.0);
+    const pi_over_2: @Vector(vec_len, u32) = @splat(0x3fc90fdb);
+    const zero: @Vector(vec_len, u32) = @splat(0);
+    const c0: @Vector(vec_len, f32) = @splat(-0x1.5554dcp-2);
+    const c1: @Vector(vec_len, f32) = @splat(0x1.9978ecp-3);
+    const c2: @Vector(vec_len, f32) = @splat(-0x1.230a94p-3);
+    const c3: @Vector(vec_len, f32) = @splat(0x1.b4debp-4);
+    const c4: @Vector(vec_len, f32) = @splat(-0x1.3550dap-4);
+    const c5: @Vector(vec_len, f32) = @splat(0x1.61eebp-5);
+    const c6: @Vector(vec_len, f32) = @splat(-0x1.0c17d4p-6);
+    const c7: @Vector(vec_len, f32) = @splat(0x1.7ea694p-9);
+
+    const ix: @Vector(vec_len, u32) = @bitCast(x);
+    const sign = ix & sign_mask;
+    const pred = @abs(x) > @abs(neg_one);
+    const z = @select(f32, pred, neg_one / x, x);
+    const shift: @Vector(vec_len, f32) = @bitCast(@select(u32, pred, pi_over_2 ^ sign, zero));
+    const z2 = z * z;
+    const z3 = z * z2;
+    const z4 = z2 * z2;
+    const z8 = z4 * z4;
+    const p0_1 = @mulAdd(@Vector(vec_len, f32), z2, c1, c0);
+    const p2_3 = @mulAdd(@Vector(vec_len, f32), z2, c3, c2);
+    const p4_5 = @mulAdd(@Vector(vec_len, f32), z2, c5, c4);
+    const p6_7 = @mulAdd(@Vector(vec_len, f32), z2, c7, c6);
+    const p0_3 = @mulAdd(@Vector(vec_len, f32), z4, p2_3, p0_1);
+    const p4_7 = @mulAdd(@Vector(vec_len, f32), z4, p6_7, p4_5);
+    const p0_7 = @mulAdd(@Vector(vec_len, f32), z8, p4_7, p0_3);
+    return @mulAdd(@Vector(vec_len, f32), z3, p0_7, shift + z);
+}
+
+fn atanBinary64Vec(x: anytype) @TypeOf(x) {
+    const type_info = @typeInfo(@TypeOf(x));
+    comptime std.debug.assert(type_info.vector.child == f64);
+    const vec_len = type_info.vector.len;
+    const sign_mask: @Vector(vec_len, u64) = @splat(0x8000000000000000);
+    const neg_one: @Vector(vec_len, f64) = @splat(-1.0);
+    const pi_over_2: @Vector(vec_len, u64) = @splat(0x3ff921fb54442d18);
+    const zero: @Vector(vec_len, u64) = @splat(0);
+    const c0: @Vector(vec_len, f64) = @splat(-0x1.555555555552ap-2);
+    const c1: @Vector(vec_len, f64) = @splat(0x1.9999999995aebp-3);
+    const c2: @Vector(vec_len, f64) = @splat(-0x1.24924923923f6p-3);
+    const c3: @Vector(vec_len, f64) = @splat(0x1.c71c7184288a2p-4);
+    const c4: @Vector(vec_len, f64) = @splat(-0x1.745d11fb3d32bp-4);
+    const c5: @Vector(vec_len, f64) = @splat(0x1.3b136a18051b9p-4);
+    const c6: @Vector(vec_len, f64) = @splat(-0x1.110e6d985f496p-4);
+    const c7: @Vector(vec_len, f64) = @splat(0x1.e1bcf7f08801dp-5);
+    const c8: @Vector(vec_len, f64) = @splat(-0x1.ae644e28058c3p-5);
+    const c9: @Vector(vec_len, f64) = @splat(0x1.82eeb1fed85c6p-5);
+    const c10: @Vector(vec_len, f64) = @splat(-0x1.59d7f901566cbp-5);
+    const c11: @Vector(vec_len, f64) = @splat(0x1.2c982855ab069p-5);
+    const c12: @Vector(vec_len, f64) = @splat(-0x1.eb49592998177p-6);
+    const c13: @Vector(vec_len, f64) = @splat(0x1.69d8b396e3d38p-6);
+    const c14: @Vector(vec_len, f64) = @splat(-0x1.ca980345c4204p-7);
+    const c15: @Vector(vec_len, f64) = @splat(0x1.dc050eafde0b3p-8);
+    const c16: @Vector(vec_len, f64) = @splat(-0x1.7ea70755b8eccp-9);
+    const c17: @Vector(vec_len, f64) = @splat(0x1.ba3da3de903e8p-11);
+    const c18: @Vector(vec_len, f64) = @splat(-0x1.44a4b059b6f67p-13);
+    const c19: @Vector(vec_len, f64) = @splat(0x1.c4a45029e5a91p-17);
+
+    const ix: @Vector(vec_len, u64) = @bitCast(x);
+    const sign = ix & sign_mask;
+    const pred = @abs(x) > @abs(neg_one);
+    const shift: @Vector(vec_len, f64) = @bitCast(@select(u64, pred, pi_over_2 ^ sign, zero));
+    const z = @select(f64, pred, neg_one / x, x);
+    const z2 = z * z;
+    const z3 = z * z2;
+    const z4 = z2 * z2;
+    const z8 = z4 * z4;
+    const z16 = z8 * z8;
+    const p0_1 = @mulAdd(@Vector(vec_len, f64), z2, c1, c0);
+    const p2_3 = @mulAdd(@Vector(vec_len, f64), z2, c3, c2);
+    const p0_3 = @mulAdd(@Vector(vec_len, f64), z4, p2_3, p0_1);
+    const p4_5 = @mulAdd(@Vector(vec_len, f64), z2, c5, c4);
+    const p6_7 = @mulAdd(@Vector(vec_len, f64), z2, c7, c6);
+    const p4_7 = @mulAdd(@Vector(vec_len, f64), z4, p6_7, p4_5);
+    const p0_7 = @mulAdd(@Vector(vec_len, f64), z8, p4_7, p0_3);
+    const p8_9 = @mulAdd(@Vector(vec_len, f64), z2, c9, c8);
+    const p10_11 = @mulAdd(@Vector(vec_len, f64), z2, c11, c10);
+    const p8_11 = @mulAdd(@Vector(vec_len, f64), z4, p10_11, p8_9);
+    const p12_13 = @mulAdd(@Vector(vec_len, f64), z2, c13, c12);
+    const p14_15 = @mulAdd(@Vector(vec_len, f64), z2, c15, c14);
+    const p12_15 = @mulAdd(@Vector(vec_len, f64), z4, p14_15, p12_13);
+    const p16_17 = @mulAdd(@Vector(vec_len, f64), z2, c17, c16);
+    const p18_19 = @mulAdd(@Vector(vec_len, f64), z2, c19, c18);
+    const p16_19 = @mulAdd(@Vector(vec_len, f64), z4, p18_19, p16_17);
+    const p8_15 = @mulAdd(@Vector(vec_len, f64), z8, p12_15, p8_11);
+    const p8_19 = @mulAdd(@Vector(vec_len, f64), z16, p16_19, p8_15);
+    const p0_19 = @mulAdd(@Vector(vec_len, f64), p8_19, z16, p0_7);
+    return @mulAdd(@Vector(vec_len, f64), z3, p0_19, shift + z);
+}
+
+test "atanBinary32Vec.special" {
+    const input: @Vector(7, f32) = .{
+        0x0p+0,
+        -0x0p+0,
+        0x1p+0,
+        -0x1p+0,
+        math.inf(f32),
+        -math.inf(f32),
+        math.nan(f32),
+    };
+    const output = atanBinary32Vec(input);
+    try testing.expectEqual(output[0], 0x0p+0);
+    try testing.expectEqual(output[1], -0x0p+0);
+    try testing.expectApproxEqAbs(output[2], 0x1.921fb6p-1, math.floatEpsAt(f32, 0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(output[3], -0x1.921fb6p-1, math.floatEpsAt(f32, -0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(output[4], 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(output[5], -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expect(math.isNan(output[6]));
+}
+
+test "atanBinary32Vec" {
+    const input: @Vector(10, f32) = .{
+        -0x1.8629dp-2,
+        -0x1.59d42ep1,
+        -0x1.d2dbe2p0,
+        -0x1.5f314ep-1,
+        0x1.5869bp1,
+        -0x1.b13a06p-2,
+        0x1.3cb0f2p1,
+        -0x1.0ed746p-2,
+        0x1.299d54p1,
+        -0x1.0264fcp1,
+    };
+    const output = atanBinary32Vec(input);
+    try testing.expectApproxEqAbs(output[0], -0x1.74c62p-2, math.floatEpsAt(f32, -0x1.74c62p-2));
+    try testing.expectApproxEqAbs(output[1], -0x1.375fd8p0, math.floatEpsAt(f32, -0x1.375fd8p0));
+    try testing.expectApproxEqAbs(output[2], -0x1.11b8aep0, math.floatEpsAt(f32, -0x1.11b8aep0));
+    try testing.expectApproxEqAbs(output[3], -0x1.33d28cp-1, math.floatEpsAt(f32, -0x1.33d28cp-1));
+    try testing.expectApproxEqAbs(output[4], 0x1.37082ep0, math.floatEpsAt(f32, 0x1.37082ep0));
+    try testing.expectApproxEqAbs(output[5], -0x1.99d7cap-2, math.floatEpsAt(f32, -0x1.99d7cap-2));
+    try testing.expectApproxEqAbs(output[6], 0x1.2fcb12p0, math.floatEpsAt(f32, 0x1.2fcb12p0));
+    try testing.expectApproxEqAbs(output[7], -0x1.08c71ap-2, math.floatEpsAt(f32, -0x1.08c71ap-2));
+    try testing.expectApproxEqAbs(output[8], 0x1.2a24e2p0, math.floatEpsAt(f32, 0x1.2a24e2p0));
+    try testing.expectApproxEqAbs(output[9], -0x1.1c6178p0, math.floatEpsAt(f32, -0x1.1c6178p0));
+}
+
+test "atanBinary64Vec.special" {
+    const input: @Vector(7, f64) = .{
+        0x0p+0,
+        -0x0p+0,
+        0x1p+0,
+        -0x1p+0,
+        math.inf(f64),
+        -math.inf(f64),
+        math.nan(f64),
+    };
+    const output = atanBinary64Vec(input);
+    try testing.expectEqual(output[0], 0x0p+0);
+    try testing.expectEqual(output[1], -0x0p+0);
+    try testing.expectApproxEqAbs(output[2], 0x1.921fb54442d18p-1, math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(output[3], -0x1.921fb54442d18p-1, math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(output[4], 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(output[5], -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expect(math.isNan(output[6]));
+}
+
+test "atanBinary64Vec" {
+    const input: @Vector(10, f64) = .{
+        -0x1.8629d0244cdccp-2,
+        -0x1.59d42d4659937p1,
+        -0x1.d2dbe23d04f06p0,
+        -0x1.5f314e72398e8p-1,
+        0x1.5869af37b7d08p1,
+        -0x1.b13a05a662618p-2,
+        0x1.3cb0f12f39d8ap1,
+        -0x1.0ed746b39cbb7p-2,
+        0x1.299d54ac7d6bp1,
+        -0x1.0264fb9f3d50ep1,
+    };
+    const output = atanBinary64Vec(input);
+    try testing.expectApproxEqAbs(output[0], -0x1.74c61f4377016p-2, math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
+    try testing.expectApproxEqAbs(output[1], -0x1.375fd7987cc2p0, math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
+    try testing.expectApproxEqAbs(output[2], -0x1.11b8adeba5616p0, math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
+    try testing.expectApproxEqAbs(output[3], -0x1.33d28ca762539p-1, math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
+    try testing.expectApproxEqAbs(output[4], 0x1.37082ce2dd03p0, math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
+    try testing.expectApproxEqAbs(output[5], -0x1.99d7cac66dd44p-2, math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
+    try testing.expectApproxEqAbs(output[6], 0x1.2fcb120468e8ep0, math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
+    try testing.expectApproxEqAbs(output[7], -0x1.08c71aa0e509p-2, math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
+    try testing.expectApproxEqAbs(output[8], 0x1.2a24e22d861dfp0, math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
+    try testing.expectApproxEqAbs(output[9], -0x1.1c617825f9751p0, math.floatEpsAt(f64, -0x1.1c617825f9751p0));
+}
-- 
2.54.0


From 12e6ac2e8fb034f823390e5d7f1680411c903e7c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 13 Feb 2026 12:25:53 -0800
Subject: [PATCH 293/499] std.math.atan: simplify type logic

---
 lib/std/math/atan.zig | 46 +++++++++++++++++++------------------------
 1 file changed, 20 insertions(+), 26 deletions(-)

diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig
index e88de71dd0c4204532d58d5e42b0d73acc20871b..26d8e5f83bc0a56e538a26fafce5188f4c189f7b 100644
--- a/lib/std/math/atan.zig
+++ b/lib/std/math/atan.zig
@@ -23,21 +23,21 @@ const testing = std.testing;
 ///  - atan(+-inf) = +-pi/2
 pub fn atan(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
-    switch (T) {
-        f16 => return atanBinary16(x),
-        f32 => return atanBinary32(x),
-        f64 => return atanBinary64(x),
-        f80 => return atanExtended80(x),
-        f128 => return atanBinary128(x),
-        else => {
-            const info = @typeInfo(T);
-            if (info == .vector) {
-                const vec_type = info.vector.child;
-                if (vec_type == f32) return atanBinary32Vec(x);
-                if (vec_type == f64) return atanBinary64Vec(x);
-            }
-            @compileError("atan not implemented for " ++ @typeName(T));
+    switch (@typeInfo(T)) {
+        .float => |info| switch (info.bits) {
+            16 => return atanBinary16(x),
+            32 => return atanBinary32(x),
+            64 => return atanBinary64(x),
+            80 => return atanExtended80(x),
+            128 => return atanBinary128(x),
+            else => comptime unreachable,
         },
+        .vector => |info| switch (info.child) {
+            f32 => return atanBinary32Vec(info.len, x),
+            f64 => return atanBinary64Vec(info.len, x),
+            else => @compileError("unimplemented"),
+        },
+        else => comptime unreachable,
     }
 }
 
@@ -594,10 +594,7 @@ test "atanBinary128" {
     try testing.expectApproxEqAbs(atanBinary128(-0x1.0264fb9f3d50e4f0f966f0686064p1), -0x1.1c617825f97512b7f38656ab12cdp0, math.floatEpsAt(f128, -0x1.1c617825f97512b7f38656ab12cdp0));
 }
 
-fn atanBinary32Vec(x: anytype) @TypeOf(x) {
-    const type_info = @typeInfo(@TypeOf(x));
-    comptime std.debug.assert(type_info.vector.child == f32);
-    const vec_len = type_info.vector.len;
+fn atanBinary32Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f32)) @TypeOf(x) {
     const sign_mask: @Vector(vec_len, u32) = @splat(0x80000000);
     const neg_one: @Vector(vec_len, f32) = @splat(-1.0);
     const pi_over_2: @Vector(vec_len, u32) = @splat(0x3fc90fdb);
@@ -630,10 +627,7 @@ fn atanBinary32Vec(x: anytype) @TypeOf(x) {
     return @mulAdd(@Vector(vec_len, f32), z3, p0_7, shift + z);
 }
 
-fn atanBinary64Vec(x: anytype) @TypeOf(x) {
-    const type_info = @typeInfo(@TypeOf(x));
-    comptime std.debug.assert(type_info.vector.child == f64);
-    const vec_len = type_info.vector.len;
+fn atanBinary64Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f64)) @TypeOf(x) {
     const sign_mask: @Vector(vec_len, u64) = @splat(0x8000000000000000);
     const neg_one: @Vector(vec_len, f64) = @splat(-1.0);
     const pi_over_2: @Vector(vec_len, u64) = @splat(0x3ff921fb54442d18);
@@ -701,7 +695,7 @@ test "atanBinary32Vec.special" {
         -math.inf(f32),
         math.nan(f32),
     };
-    const output = atanBinary32Vec(input);
+    const output = atanBinary32Vec(7, input);
     try testing.expectEqual(output[0], 0x0p+0);
     try testing.expectEqual(output[1], -0x0p+0);
     try testing.expectApproxEqAbs(output[2], 0x1.921fb6p-1, math.floatEpsAt(f32, 0x1.921fb6p-1));
@@ -724,7 +718,7 @@ test "atanBinary32Vec" {
         0x1.299d54p1,
         -0x1.0264fcp1,
     };
-    const output = atanBinary32Vec(input);
+    const output = atanBinary32Vec(10, input);
     try testing.expectApproxEqAbs(output[0], -0x1.74c62p-2, math.floatEpsAt(f32, -0x1.74c62p-2));
     try testing.expectApproxEqAbs(output[1], -0x1.375fd8p0, math.floatEpsAt(f32, -0x1.375fd8p0));
     try testing.expectApproxEqAbs(output[2], -0x1.11b8aep0, math.floatEpsAt(f32, -0x1.11b8aep0));
@@ -747,7 +741,7 @@ test "atanBinary64Vec.special" {
         -math.inf(f64),
         math.nan(f64),
     };
-    const output = atanBinary64Vec(input);
+    const output = atanBinary64Vec(7, input);
     try testing.expectEqual(output[0], 0x0p+0);
     try testing.expectEqual(output[1], -0x0p+0);
     try testing.expectApproxEqAbs(output[2], 0x1.921fb54442d18p-1, math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
@@ -770,7 +764,7 @@ test "atanBinary64Vec" {
         0x1.299d54ac7d6bp1,
         -0x1.0264fb9f3d50ep1,
     };
-    const output = atanBinary64Vec(input);
+    const output = atanBinary64Vec(10, input);
     try testing.expectApproxEqAbs(output[0], -0x1.74c61f4377016p-2, math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
     try testing.expectApproxEqAbs(output[1], -0x1.375fd7987cc2p0, math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
     try testing.expectApproxEqAbs(output[2], -0x1.11b8adeba5616p0, math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
-- 
2.54.0


From 3c9024be08f34d2bb38693df38e5b4b334c74f90 Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Sun, 2 Nov 2025 17:18:53 -0500
Subject: [PATCH 294/499] update fuzzing for build system changes

---
 lib/std/Build/Fuzz.zig      | 8 ++++++++
 lib/std/Build/WebServer.zig | 5 ++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index 980735bd02869b7a10739bad50f039244e1913f7..44bcf97a7a945f718da6ea264f235c95fdea5262 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -135,6 +135,14 @@ pub fn start(fuzz: *Fuzz) void {
             fatal("unable to spawn coverage task: {t}", .{err});
     }
 
+    for (fuzz.run_steps) |run| {
+        if (run.fuzz_tests.items.len > 1) {
+            // Multiple fuzzWorkerRuns currently cause race-conditions
+            // since they use the same Run step. See #30969
+            fatal("--fuzz not yet implemented for multiple tests", .{});
+        }
+    }
+
     for (fuzz.run_steps) |run| {
         for (run.fuzz_tests.items) |unit_test_index| {
             assert(run.rebuilt_executable != null);
diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index 08bc584522683423c04ee33fe6b03f96f68b64e8..97759169033432889ab27dda2d27dcc84d1882f7 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -608,7 +608,10 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     defer body_buffer.deinit(gpa);
 
     while (true) {
-        const header = try stdout.takeStruct(Header, .little);
+        const header = stdout.takeStruct(Header, .little) catch |e| switch (e) {
+            error.ReadFailed => return error.ReadFailed,
+            error.EndOfStream => break,
+        };
         body_buffer.clearRetainingCapacity();
         try stdout.appendExact(gpa, &body_buffer, header.bytes_len);
         const body = body_buffer.items;
-- 
2.54.0


From af1e196db3bca66c29979c685b1c9c896c275211 Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Sun, 2 Nov 2025 09:57:15 -0500
Subject: [PATCH 295/499] align end of elf archives

The end of the archive needs to also be aligned to a two-byte boundary,
not just the start of records. This was causing lld to reject archives.

Notably, this was happening with compiler_rt when rebuilding in fuzz
mode, which is why this commit is included in this patchset.
---
 lib/std/Build/Step/CheckObject.zig |  6 +++++-
 src/link/Elf/relocatable.zig       | 10 ++++++----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/lib/std/Build/Step/CheckObject.zig b/lib/std/Build/Step/CheckObject.zig
index ac8fafaa3fc965e808466c4573a7a6746c683097..ad44138f3128db3391b2822ffc91263068009d93 100644
--- a/lib/std/Build/Step/CheckObject.zig
+++ b/lib/std/Build/Step/CheckObject.zig
@@ -1702,6 +1702,10 @@ const ElfDumper = struct {
             return error.InvalidArchiveMagicNumber;
         }
 
+        if (!mem.isAligned(bytes.len, 2)) {
+            return error.InvalidArchivePadding;
+        }
+
         var ctx = ArchiveContext{
             .gpa = gpa,
             .data = bytes,
@@ -1715,8 +1719,8 @@ const ElfDumper = struct {
         }
 
         while (true) {
-            if (reader.seek >= ctx.data.len) break;
             if (!mem.isAligned(reader.seek, 2)) reader.seek += 1;
+            if (reader.seek >= ctx.data.len) break;
 
             const hdr = try reader.takeStruct(elf.ar_hdr, .little);
 
diff --git a/src/link/Elf/relocatable.zig b/src/link/Elf/relocatable.zig
index 74ea71ce9d063b73880582335a45178a418f1366..864f7bf4185e88847f7072337d5abf84f0e1df42 100644
--- a/src/link/Elf/relocatable.zig
+++ b/src/link/Elf/relocatable.zig
@@ -95,10 +95,11 @@ pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation) !void {
     const total_size: usize = blk: {
         var pos: usize = elf.ARMAG.len;
         pos += @sizeOf(elf.ar_hdr) + ar_symtab.size(.p64);
+        pos = mem.alignForward(usize, pos, 2);
 
         if (ar_strtab.size() > 0) {
-            pos = mem.alignForward(usize, pos, 2);
             pos += @sizeOf(elf.ar_hdr) + ar_strtab.size();
+            pos = mem.alignForward(usize, pos, 2);
         }
 
         for (files.items) |index| {
@@ -108,9 +109,9 @@ pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation) !void {
                 .object => |x| &x.output_ar_state,
                 else => unreachable,
             };
-            pos = mem.alignForward(usize, pos, 2);
             state.file_off = pos;
             pos += @sizeOf(elf.ar_hdr) + (math.cast(usize, state.size) orelse return error.Overflow);
+            pos = mem.alignForward(usize, pos, 2);
         }
 
         break :blk pos;
@@ -131,17 +132,18 @@ pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation) !void {
 
     // Write symtab
     try ar_symtab.write(.p64, elf_file, &writer);
+    if (!mem.isAligned(writer.end, 2)) try writer.writeByte(0);
 
     // Write strtab
     if (ar_strtab.size() > 0) {
-        if (!mem.isAligned(writer.end, 2)) try writer.writeByte(0);
         try ar_strtab.write(&writer);
+        if (!mem.isAligned(writer.end, 2)) try writer.writeByte(0);
     }
 
     // Write object files
     for (files.items) |index| {
-        if (!mem.isAligned(writer.end, 2)) try writer.writeByte(0);
         try elf_file.file(index).?.writeAr(elf_file, &writer);
+        if (!mem.isAligned(writer.end, 2)) try writer.writeByte(0);
     }
 
     assert(writer.buffered().len == total_size);
-- 
2.54.0


From 1a9d75ebe0037bd908ed263bb7f4228f9a8681ef Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Mon, 3 Nov 2025 18:37:47 -0500
Subject: [PATCH 296/499] fix fuzzing speed with prior runs

---
 lib/build-web/fuzz.zig | 4 +++-
 lib/std/Build/Fuzz.zig | 4 ++++
 lib/std/Build/abi.zig  | 1 +
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/build-web/fuzz.zig b/lib/build-web/fuzz.zig
index 5fe0de2f7a0517cb658670941d7887933a6a14e0..21eb3f868a6319b220b6a9a1fb0ee24a85d27a93 100644
--- a/lib/build-web/fuzz.zig
+++ b/lib/build-web/fuzz.zig
@@ -1,5 +1,6 @@
 // Server timestamp.
 var start_fuzzing_timestamp: i64 = undefined;
+var start_fuzzing_n_runs: u64 = undefined;
 
 const js = struct {
     extern "fuzz" fn requestSources() void;
@@ -36,6 +37,7 @@ pub fn sourceIndexMessage(msg_bytes: []u8) error{OutOfMemory}!void {
     const source_locations: []const Coverage.SourceLocation = @alignCast(std.mem.bytesAsSlice(Coverage.SourceLocation, msg_bytes[source_locations_start..source_locations_end]));
 
     start_fuzzing_timestamp = header.start_timestamp;
+    start_fuzzing_n_runs = header.start_n_runs;
     try updateCoverageSources(directories, files, source_locations, string_bytes);
     js.ready();
 }
@@ -271,7 +273,7 @@ fn updateStats() error{OutOfMemory}!void {
 
     const avg_speed: f64 = speed: {
         const ns_elapsed: f64 = @floatFromInt(nsSince(start_fuzzing_timestamp));
-        const n_runs: f64 = @floatFromInt(hdr.n_runs);
+        const n_runs: f64 = @floatFromInt(hdr.n_runs -% start_fuzzing_n_runs);
         break :speed n_runs / (ns_elapsed / std.time.ns_per_s);
     };
 
diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index 44bcf97a7a945f718da6ea264f235c95fdea5262..b2477f50884b34100e772960ca4a2c387ddd0008 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -64,6 +64,7 @@ const CoverageMap = struct {
     /// Elements are indexes into `source_locations` pointing to the unit tests that are being fuzz tested.
     entry_points: std.ArrayList(u32),
     start_timestamp: i64,
+    start_n_runs: u64,
 
     fn deinit(cm: *CoverageMap, gpa: Allocator) void {
         std.posix.munmap(cm.mapped_memory);
@@ -299,6 +300,7 @@ pub fn sendUpdate(
                 .source_locations_len = @intCast(coverage_map.source_locations.len),
                 .string_bytes_len = @intCast(coverage_map.coverage.string_bytes.items.len),
                 .start_timestamp = coverage_map.start_timestamp,
+                .start_n_runs = coverage_map.start_n_runs,
             };
             var iovecs: [5][]const u8 = .{
                 @ptrCast(&header),
@@ -390,6 +392,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
         .source_locations = undefined, // populated below
         .entry_points = .{},
         .start_timestamp = ws.now(),
+        .start_n_runs = undefined, // populated below
     };
     errdefer gop.value_ptr.coverage.deinit(gpa);
 
@@ -467,6 +470,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
 
     for (sorted_pcs.items(.index), sorted_pcs.items(.sl)) |i, sl| source_locations[i] = sl;
     gop.value_ptr.source_locations = source_locations;
+    gop.value_ptr.start_n_runs = header.n_runs;
 
     ws.notifyUpdate();
 }
diff --git a/lib/std/Build/abi.zig b/lib/std/Build/abi.zig
index b7c1e7379d37928ac12113cf1633f6e3be89f208..68060ae16ba47910476db7c6f85f6cc81c84ea48 100644
--- a/lib/std/Build/abi.zig
+++ b/lib/std/Build/abi.zig
@@ -219,6 +219,7 @@ pub const fuzz = struct {
         string_bytes_len: u32,
         /// When, according to the server, fuzzing started.
         start_timestamp: i64 align(4),
+        start_n_runs: u64 align(4),
     };
 
     /// WebSocket server->client.
-- 
2.54.0


From e40557b1f75863d9a66af301e83c8c48f0df81d5 Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Sun, 23 Nov 2025 13:54:13 -0500
Subject: [PATCH 297/499] allow specifying mode in --debug-rt

The motivation is that libfuzzer is slow in Debug mode and bugs usually
manifest late into fuzzing, which makes testing it in ReleaseSafe
useful.
---
 lib/compiler/build_runner.zig  |  6 +++++-
 lib/std/Build.zig              |  2 +-
 lib/std/Build/Step/Compile.zig |  3 ++-
 src/Compilation.zig            | 11 ++++++-----
 src/main.zig                   |  9 ++++++---
 5 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index faf81194a993db9e0ff90e7a34269a57a216f653..927c285098dbfa3970074429e6b3eb02d1c336b3 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -310,7 +310,11 @@ pub fn main(init: process.Init.Minimal) !void {
             } else if (mem.eql(u8, arg, "--debug-pkg-config")) {
                 builder.debug_pkg_config = true;
             } else if (mem.eql(u8, arg, "--debug-rt")) {
-                graph.debug_compiler_runtime_libs = true;
+                graph.debug_compiler_runtime_libs = .Debug;
+            } else if (mem.cutPrefix(u8, arg, "--debug-rt=")) |rest| {
+                graph.debug_compiler_runtime_libs =
+                    std.meta.stringToEnum(std.builtin.OptimizeMode, rest) orelse
+                    fatal("unrecognized optimization mode: '{s}'", .{rest});
             } else if (mem.eql(u8, arg, "--debug-compile-errors")) {
                 builder.debug_compile_errors = true;
             } else if (mem.eql(u8, arg, "--debug-incremental")) {
diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index 257b7abef37c05e379079a7fea536ba8b3d4f452..4dbbb083e37afef9599b86dbed3770dec1700675 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -115,7 +115,7 @@ pub const Graph = struct {
     arena: Allocator,
     system_library_options: std.StringArrayHashMapUnmanaged(SystemLibraryMode) = .empty,
     system_package_mode: bool = false,
-    debug_compiler_runtime_libs: bool = false,
+    debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null,
     cache: Cache,
     zig_exe: [:0]const u8,
     environ_map: process.Environ.Map,
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index d9bbe844f6aece8512496cf622a85523e425b5d5..c09f9eaf2e8c6d22e2f744571732d79426e5d10b 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -1462,7 +1462,8 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
     try zig_args.append("--global-cache-dir");
     try zig_args.append(b.graph.global_cache_root.path orelse ".");
 
-    if (b.graph.debug_compiler_runtime_libs) try zig_args.append("--debug-rt");
+    if (b.graph.debug_compiler_runtime_libs) |mode|
+        try zig_args.append(b.fmt("--debug-rt={t}", .{mode}));
 
     try zig_args.append("--name");
     try zig_args.append(compile.name);
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 8e9c9b948cfabc4f5bad7406f1a9144a9f85d0da..6a4fab500b3fc0b1a6efb1752b131d4eb592b3e1 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -186,7 +186,7 @@ verbose_link: bool,
 link_depfile: ?[]const u8,
 disable_c_depfile: bool,
 stack_report: bool,
-debug_compiler_runtime_libs: bool,
+debug_compiler_runtime_libs: ?std.builtin.OptimizeMode,
 debug_compile_errors: bool,
 /// Do not check this field directly. Instead, use the `debugIncremental` wrapper function.
 debug_incremental: bool,
@@ -1749,7 +1749,7 @@ pub const CreateOptions = struct {
     link_depfile: ?[]const u8 = null,
     verbose_cimport: bool = false,
     verbose_llvm_cpu_features: bool = false,
-    debug_compiler_runtime_libs: bool = false,
+    debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null,
     debug_compile_errors: bool = false,
     debug_incremental: bool = false,
     /// Normally when you create a `Compilation`, Zig will automatically build
@@ -2201,7 +2201,8 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
         cache.hash.addBytes(options.root_name);
         cache.hash.add(options.config.wasi_exec_model);
         cache.hash.add(options.config.san_cov_trace_pc_guard);
-        cache.hash.add(options.debug_compiler_runtime_libs);
+        cache.hash.add(options.debug_compiler_runtime_libs != null);
+        if (options.debug_compiler_runtime_libs) |mode| cache.hash.add(mode);
         // The actual emit paths don't matter. They're only user-specified if we aren't using the
         // cache! However, it does matter whether the files are emitted at all.
         cache.hash.add(options.emit_bin != .no);
@@ -8373,8 +8374,8 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
 /// This decides the optimization mode for all zig-provided libraries, including
 /// compiler-rt, libcxx, libc, libunwind, etc.
 pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode {
-    if (comp.debug_compiler_runtime_libs) {
-        return .Debug;
+    if (comp.debug_compiler_runtime_libs) |mode| {
+        return mode;
     }
     const target = &comp.root_mod.resolved_target.result;
     switch (comp.root_mod.optimize_mode) {
diff --git a/src/main.zig b/src/main.zig
index 1b9fe7b299406c76724d3690fa4c0ae20d74b1ba..2adefdfea3163adac94cb616f2cebeae8225c269 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -708,7 +708,8 @@ const usage_build_generic =
     \\  --debug-log [scope]          Enable printing debug/info log messages for scope
     \\  --debug-compile-errors       Crash with helpful diagnostics at the first compile error
     \\  --debug-link-snapshot        Enable dumping of the linker's state in JSON format
-    \\  --debug-rt                   Debug compiler runtime libraries
+    \\  --debug-rt[=mode]            Build compiler runtime libraries with [mode] optimization
+    \\                               (Debug if [=mode] is omitted)
     \\  --debug-incremental          Enable incremental compilation debug features
     \\
 ;
@@ -928,7 +929,7 @@ fn buildOutputType(
     var minor_subsystem_version: ?u16 = null;
     var mingw_unicode_entry_point: bool = false;
     var enable_link_snapshots: bool = false;
-    var debug_compiler_runtime_libs = false;
+    var debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null;
     var install_name: ?[]const u8 = null;
     var hash_style: link.File.Lld.Elf.HashStyle = .both;
     var entitlements: ?[]const u8 = null;
@@ -1382,7 +1383,9 @@ fn buildOutputType(
                             enable_link_snapshots = true;
                         }
                     } else if (mem.eql(u8, arg, "--debug-rt")) {
-                        debug_compiler_runtime_libs = true;
+                        debug_compiler_runtime_libs = .Debug;
+                    } else if (mem.cutPrefix(u8, arg, "--debug-rt=")) |rest| {
+                        debug_compiler_runtime_libs = parseOptimizeMode(rest);
                     } else if (mem.eql(u8, arg, "--debug-incremental")) {
                         if (build_options.enable_debug_extensions) {
                             debug_incremental = true;
-- 
2.54.0


From 5b9bb0a4045aaae387b049f4b28f350aef0dbed2 Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Fri, 13 Feb 2026 17:50:30 -0500
Subject: [PATCH 298/499] add -Dfuzz-only

Runs only one configuration suitable for fuzzing.
---
 build.zig      | 16 ++++++++++++----
 test/tests.zig | 23 +++++++++++++++++------
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/build.zig b/build.zig
index b2227b0cb81fb8e74f83b2c3107751c7756e3640..5b723ad5b266f281a39bf1d51d295997a78c4be0 100644
--- a/build.zig
+++ b/build.zig
@@ -85,6 +85,7 @@ pub fn build(b: *std.Build) !void {
     docs_step.dependOn(std_docs_step);
 
     const no_matrix = b.option(bool, "no-matrix", "Limit test matrix to exactly one target configuration") orelse false;
+    const fuzz_only = b.option(bool, "fuzz-only", "Limit test matrix to one target suitable for fuzzing") orelse false;
     const skip_debug = b.option(bool, "skip-debug", "Main test suite skips debug builds") orelse false;
     const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse no_matrix;
     const skip_release_small = b.option(bool, "skip-release-small", "Main test suite skips release-small builds") orelse skip_release;
@@ -417,6 +418,13 @@ pub fn build(b: *std.Build) !void {
     }
     const optimization_modes = chosen_opt_modes_buf[0..chosen_mode_index];
 
+    const test_only: ?tests.ModuleTestOptions.TestOnly = if (no_matrix)
+        .default
+    else if (fuzz_only)
+        .{ .fuzz = optimize }
+    else
+        null;
+
     const fmt_include_paths = &.{ "lib", "src", "test", "tools", "build.zig", "build.zig.zon" };
     const fmt_exclude_paths = &.{ "test/cases", "test/behavior/zon" };
     const do_fmt = b.addFmt(.{
@@ -472,7 +480,7 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
-        .test_default_only = no_matrix,
+        .test_only = test_only,
         .skip_spirv = skip_spirv,
         .skip_wasm = skip_wasm,
         .skip_freebsd = skip_freebsd,
@@ -497,7 +505,7 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
-        .test_default_only = no_matrix,
+        .test_only = test_only,
         .skip_spirv = skip_spirv,
         .skip_wasm = skip_wasm,
         .skip_freebsd = skip_freebsd,
@@ -523,7 +531,7 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
-        .test_default_only = no_matrix,
+        .test_only = test_only,
         .skip_spirv = skip_spirv,
         .skip_wasm = skip_wasm,
         .skip_freebsd = skip_freebsd,
@@ -549,7 +557,7 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
-        .test_default_only = no_matrix,
+        .test_only = test_only,
         .skip_spirv = skip_spirv,
         .skip_wasm = skip_wasm,
         .skip_freebsd = skip_freebsd,
diff --git a/test/tests.zig b/test/tests.zig
index 81fc9ae7d074971c31f80d11042e66ed5dc55a95..0eaf0b1eaf745195811ae62662731a60a6ef9b00 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -2310,7 +2310,7 @@ pub fn addCliTests(b: *std.Build) *Step {
     return step;
 }
 
-const ModuleTestOptions = struct {
+pub const ModuleTestOptions = struct {
     test_filters: []const []const u8,
     test_target_filters: []const []const u8,
     test_extra_targets: bool,
@@ -2319,7 +2319,7 @@ const ModuleTestOptions = struct {
     desc: []const u8,
     optimize_modes: []const OptimizeMode,
     include_paths: []const []const u8,
-    test_default_only: bool,
+    test_only: ?TestOnly,
     skip_single_threaded: bool,
     skip_non_native: bool,
     skip_spirv: bool,
@@ -2335,20 +2335,31 @@ const ModuleTestOptions = struct {
     max_rss: usize = 0,
     no_builtin: bool = false,
     build_options: ?*Step.Options = null,
+
+    pub const TestOnly = union(enum) {
+        default: void,
+        fuzz: OptimizeMode,
+    };
 };
 
 pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
     const step = b.step(b.fmt("test-{s}", .{options.name}), options.desc);
 
-    if (options.test_default_only) {
-        const test_target = &test_targets[0];
+    if (options.test_only) |test_only| {
+        const test_target: TestTarget = switch (test_only) {
+            .default => test_targets[0],
+            .fuzz => |optimize| .{
+                .optimize_mode = optimize,
+                .use_llvm = true,
+            },
+        };
         const resolved_target = b.resolveTargetQuery(test_target.target);
         const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM");
         addOneModuleTest(b, step, test_target, &resolved_target, triple_txt, options);
         return step;
     }
 
-    for_targets: for (&test_targets) |*test_target| {
+    for_targets: for (test_targets) |test_target| {
         if (test_target.skip_modules.len > 0) {
             for (test_target.skip_modules) |skip_mod| {
                 if (std.mem.eql(u8, options.name, skip_mod)) continue :for_targets;
@@ -2425,7 +2436,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
 fn addOneModuleTest(
     b: *std.Build,
     step: *Step,
-    test_target: *const TestTarget,
+    test_target: TestTarget,
     resolved_target: *const std.Build.ResolvedTarget,
     triple_txt: []const u8,
     options: ModuleTestOptions,
-- 
2.54.0


From 5d583061625c1c413e11a3d14e796602ce752687 Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Fri, 13 Feb 2026 17:48:57 -0500
Subject: [PATCH 299/499] rework fuzz testing to be smith based

-- On the standard library side:

The `input: []const u8` parameter of functions passed to `testing.fuzz`
has changed to `smith: *testing.Smith`. `Smith` is used to generate
values from libfuzzer or input bytes generated by libfuzzer.

`Smith` contains the following base methods:
* `value` as a generic method for generating any type
* `eos` for generating end-of-stream markers. Provides the additional
  guarantee `true` will eventually by provided.
* `bytes` for filling a byte array.
* `slice` for filling part of a buffer and providing the length.

`Smith.Weight` is used for giving value ranges a higher probability of
being selected. By default, every value has a weight of zero (i.e. they
will not be selected). Weights can only apply to values that fit within
a u64. The above functions have corresponding ones that accept weights.
Additionally, the following functions are provided:
* `baselineWeights` which provides a set of weights containing every
  possible value of a type.
* `eosSimpleWeighted` for unique weights for `true` and `false`
* `valueRangeAtMost` and `valueRangeLessThan` for weighing only a range
  of values.

-- On the libfuzzer and abi side:

--- Uids

These are u32s which are used to classify requested values. This solves
the problem of a mutation causing a new value to be requested and
shifting all future values; for example:

1. An initial input contains the values 1, 2, 3 which are interpreted
as a, b, and c respectively by the test.

2. The 1 is mutated to a 4 which causes the test to request an extra
value interpreted as d. The input is now 4, 2, 3, 5 (new value) which
the test corresponds to a, d, b, c; however, b and c no longer
correspond to their original values.

Uids contain a hash component and type component. The hash component
is currently determined in `Smith` by taking a hash of the calling
`@returnAddress()` or via an argument in the corresponding `WithHash`
functions. The type component is used extensively in libfuzzer with its
hashmaps.

--- Mutations

At the start of a cycle (a run), a random number of values to mutate is
selected with less being exponentially more likely. The indexes of the
values are selected from a selected uid with a logarithmic bias to uids
with more values.

Mutations may change a single values, several consecutive values in a
uid, or several consecutive values in the uid-independent order they
were requested. They may generate random values, mutate from previous
ones, or copy from other values in the same uid from the same input or
spliced from another.

For integers, mutations from previous ones currently only generates
random values. For bytes, mutations from previous mix new random data
and previous bytes with a set number of mutations.

--- Passive Minimization

A different approach has been taken for minimizing inputs: instead of
trying a fixed set of mutations when a fresh input is found, the input
is instead simply added to the corpus and removed when it is no longer
valuable.

The quality of an input is measured based off how many unique pcs it
hit and how many values it needed from the fuzzer. It is tracked which
inputs hold the best qualities for each pc for hitting the minimum and
maximum unique pcs while needing the least values.

Once all an input's qualities have been superseded for the pcs it hit,
it is removed from the corpus.

-- Comparison to byte-based smith

A byte-based smith would be much more inefficient and complex than this
solution. It would be unable to solve the shifting problem that Uids
do. It is unable to provide values from the fuzzer past end-of-stream.
Even with feedback, it would be unable to act on dynamic weights which
have proven essential with the updated tests (e.g. to constrain values
to a range).

-- Test updates

All the standard library tests have been updated to use the new smith
interface. For `Deque`, an ad hoc allocator was written to improve
performance and remove reliance on heap allocation. `TokenSmith` has
been added to aid in testing Ast and help inform decisions on the smith
interface.
---
 lib/compiler/test_runner.zig        |   16 +-
 lib/fuzzer.zig                      | 2608 +++++++++++++++------------
 lib/init/src/main.zig               |   34 +-
 lib/std/Build/abi.zig               |  134 +-
 lib/std/compress/flate/Compress.zig |  626 ++++---
 lib/std/debug.zig                   |    1 +
 lib/std/deque.zig                   |  154 +-
 lib/std/json/scanner_test.zig       |   17 -
 lib/std/testing.zig                 |    8 +-
 lib/std/testing/Smith.zig           |  895 +++++++++
 lib/std/zig.zig                     |    2 +
 lib/std/zig/Ast.zig                 |   15 +-
 lib/std/zig/TokenSmith.zig          |  277 +++
 lib/std/zig/parser_test.zig         |   13 +-
 lib/std/zig/tokenizer.zig           |   34 +-
 src/codegen/llvm.zig                |    2 +-
 test/standalone/libfuzzer/main.zig  |    6 +-
 17 files changed, 3325 insertions(+), 1517 deletions(-)
 create mode 100644 lib/std/testing/Smith.zig
 create mode 100644 lib/std/zig/TokenSmith.zig

diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig
index c868bee6aa6262bdefd97b9a5af0befcbc8751e0..9c100176d502b82277d1c99a6688473276746240 100644
--- a/lib/compiler/test_runner.zig
+++ b/lib/compiler/test_runner.zig
@@ -379,7 +379,7 @@ var fuzz_amount_or_instance: u64 = undefined;
 
 pub fn fuzz(
     context: anytype,
-    comptime testOne: fn (context: @TypeOf(context), []const u8) anyerror!void,
+    comptime testOne: fn (context: @TypeOf(context), *std.testing.Smith) anyerror!void,
     options: testing.FuzzInputOptions,
 ) anyerror!void {
     // Prevent this function from confusing the fuzzer by omitting its own code
@@ -406,12 +406,12 @@ pub fn fuzz(
     const global = struct {
         var ctx: @TypeOf(context) = undefined;
 
-        fn test_one(input: fuzz_abi.Slice) callconv(.c) void {
+        fn test_one() callconv(.c) void {
             @disableInstrumentation();
             testing.allocator_instance = .{};
             defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
             log_err_count = 0;
-            testOne(ctx, input.toSlice()) catch |err| switch (err) {
+            testOne(ctx, @constCast(&testing.Smith{ .in = null })) catch |err| switch (err) {
                 error.SkipZigTest => return,
                 else => {
                     const stderr = std.debug.lockStderr(&.{}).terminal();
@@ -435,13 +435,11 @@ pub fn fuzz(
         const prev_allocator_state = testing.allocator_instance;
         testing.allocator_instance = .{};
         defer testing.allocator_instance = prev_allocator_state;
-
         global.ctx = context;
-        fuzz_abi.fuzzer_init_test(&global.test_one, .fromSlice(builtin.test_functions[fuzz_test_index].name));
 
+        fuzz_abi.fuzzer_set_test(&global.test_one, .fromSlice(builtin.test_functions[fuzz_test_index].name));
         for (options.corpus) |elem|
             fuzz_abi.fuzzer_new_input(.fromSlice(elem));
-
         fuzz_abi.fuzzer_main(fuzz_mode, fuzz_amount_or_instance);
         return;
     }
@@ -449,10 +447,12 @@ pub fn fuzz(
     // When the unit test executable is not built in fuzz mode, only run the
     // provided corpus.
     for (options.corpus) |input| {
-        try testOne(context, input);
+        var smith: testing.Smith = .{ .in = input };
+        try testOne(context, &smith);
     }
 
     // In case there is no provided corpus, also use an empty
     // string as a smoke test.
-    try testOne(context, "");
+    var smith: testing.Smith = .{ .in = "" };
+    try testOne(context, &smith);
 }
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index 9e0c5c6ad649e7cdd454ed6725aec751a490ba77..b3a6eb5196c1fbad6c2af380d815737892ef5866 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -1,15 +1,13 @@
 const builtin = @import("builtin");
-const native_endian = builtin.cpu.arch.endian();
 
 const std = @import("std");
 const Io = std.Io;
-const fatal = std.process.fatal;
 const mem = std.mem;
 const math = std.math;
-const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const panic = std.debug.panic;
 const abi = std.Build.abi.fuzz;
+const Uid = abi.Uid;
 
 pub const std_options = std.Options{
     .logFn = logOverride,
@@ -23,8 +21,7 @@ fn logOverride(
     comptime format: []const u8,
     args: anytype,
 ) void {
-    const f = log_f orelse
-        panic("attempt to use log before initialization, message:\n" ++ format, args);
+    const f = log_f orelse panic("log before initialization, message:\n" ++ format, args);
     f.lock(io, .exclusive) catch |e| panic("failed to lock logging file: {t}", .{e});
     defer f.unlock(io);
 
@@ -48,10 +45,9 @@ const gpa = switch (builtin.mode) {
     .ReleaseFast, .ReleaseSmall, .ReleaseSafe => std.heap.smp_allocator,
 };
 
-/// Part of `exec`, however seperate to allow it to be set before `exec` is.
+// Seperate from `exec` to allow initialization before `exec` is.
 var log_f: ?Io.File = null;
-var exec: Executable = .preinit;
-var inst: Instrumentation = .preinit;
+var exec: Executable = undefined;
 var fuzzer: Fuzzer = undefined;
 var current_test_name: ?[]const u8 = null;
 
@@ -60,36 +56,28 @@ fn bitsetUsizes(elems: usize) usize {
 }
 
 const Executable = struct {
-    /// Tracks the hit count for each pc as updated by the process's instrumentation.
+    /// Tracks the hit count for each pc as updated by the test's instrumentation.
     pc_counters: []u8,
 
     cache_f: Io.Dir,
     /// Shared copy of all pcs that have been hit stored in a memory-mapped file that can viewed
     /// while the fuzzer is running.
-    shared_seen_pcs: MemoryMappedList,
+    shared_seen_pcs: []align(std.heap.page_size_min) volatile u8,
     /// Hash of pcs used to uniquely identify the shared coverage file
     pc_digest: u64,
 
-    /// A minimal state for this struct which instrumentation can function on.
-    /// Used before this structure is initialized to avoid illegal behavior
-    /// from instrumentation functions being called and using undefined values.
-    pub const preinit: Executable = .{
-        .pc_counters = undefined, // instrumentation works off the __sancov_cntrs section
-        .cache_f = undefined,
-        .shared_seen_pcs = undefined,
-        .pc_digest = undefined,
-    };
-
-    fn getCoverageFile(cache_dir: Io.Dir, pcs: []const usize, pc_digest: u64) MemoryMappedList {
-        const pc_bitset_usizes = bitsetUsizes(pcs.len);
-        const coverage_file_name = std.fmt.hex(pc_digest);
-        comptime assert(abi.SeenPcsHeader.trailing[0] == .pc_bits_usize);
-        comptime assert(abi.SeenPcsHeader.trailing[1] == .pc_addr);
+    fn getCoverageMap(
+        cache_dir: Io.Dir,
+        pcs: []const usize,
+        pc_digest: u64,
+    ) []align(std.heap.page_size_min) volatile u8 {
+        const file_name = std.fmt.hex(pc_digest);
 
         var v = cache_dir.createDirPathOpen(io, "v", .{}) catch |e|
             panic("failed to create directory 'v': {t}", .{e});
         defer v.close(io);
-        const coverage_file, const populate = if (v.createFile(io, &coverage_file_name, .{
+
+        const coverage_file, const populate = if (v.createFile(io, &file_name, .{
             .read = true,
             // If we create the file, we want to block other processes while we populate it
             .lock = .exclusive,
@@ -97,71 +85,76 @@ const Executable = struct {
         })) |f|
             .{ f, true }
         else |e| switch (e) {
-            error.PathAlreadyExists => .{ v.openFile(io, &coverage_file_name, .{
+            error.PathAlreadyExists => .{ v.openFile(io, &file_name, .{
                 .mode = .read_write,
                 .lock = .shared,
             }) catch |e2| panic(
                 "failed to open existing coverage file '{s}': {t}",
-                .{ &coverage_file_name, e2 },
+                .{ &file_name, e2 },
             ), false },
-            else => panic("failed to create coverage file '{s}': {t}", .{ &coverage_file_name, e }),
+            else => panic("failed to create coverage file '{s}': {t}", .{ &file_name, e }),
         };
 
+        comptime assert(abi.SeenPcsHeader.trailing[0] == .pc_bits_usize);
+        comptime assert(abi.SeenPcsHeader.trailing[1] == .pc_addr);
+        const pc_bitset_usizes = bitsetUsizes(pcs.len);
         const coverage_file_len = @sizeOf(abi.SeenPcsHeader) +
             pc_bitset_usizes * @sizeOf(usize) +
             pcs.len * @sizeOf(usize);
 
         if (populate) {
-            defer coverage_file.lock(io, .shared) catch |e| panic(
-                "failed to demote lock for coverage file '{s}': {t}",
-                .{ &coverage_file_name, e },
-            );
-            var map = MemoryMappedList.create(coverage_file, 0, coverage_file_len) catch |e| panic(
-                "failed to init memory map for coverage file '{s}': {t}",
-                .{ &coverage_file_name, e },
-            );
-            map.appendSliceAssumeCapacity(@ptrCast(&abi.SeenPcsHeader{
-                .n_runs = 0,
-                .unique_runs = 0,
-                .pcs_len = pcs.len,
-            }));
-            map.appendNTimesAssumeCapacity(0, pc_bitset_usizes * @sizeOf(usize));
-            // Relocations have been applied to `pcs` so it contains runtime addresses (with slide
-            // applied). We need to translate these to the virtual addresses as on disk.
-            for (pcs) |pc| {
-                const pc_vaddr = fuzzer_unslide_address(pc);
-                map.appendSliceAssumeCapacity(@ptrCast(&pc_vaddr));
-            }
-            return map;
+            coverage_file.setLength(io, coverage_file_len) catch |e|
+                panic("failed to resize new coverage file '{s}': {t}", .{ &file_name, e });
         } else {
             const size = coverage_file.length(io) catch |e|
-                panic("failed to stat coverage file '{s}': {t}", .{ &coverage_file_name, e });
+                panic("failed to stat coverage file '{s}': {t}", .{ &file_name, e });
             if (size != coverage_file_len) panic(
                 "incompatible existing coverage file '{s}' (differing lengths: {} != {})",
-                .{ &coverage_file_name, size, coverage_file_len },
+                .{ &file_name, size, coverage_file_len },
             );
+        }
 
-            const map = MemoryMappedList.init(
-                coverage_file,
-                coverage_file_len,
-                coverage_file_len,
-            ) catch |e| panic(
-                "failed to init memory map for coverage file '{s}': {t}",
-                .{ &coverage_file_name, e },
-            );
+        var io_map = coverage_file.createMemoryMap(io, .{ .len = coverage_file_len }) catch |e|
+            panic("failed to memmap coverage file '{s}': {t}", .{ &file_name, e });
+        const map = io_map.memory;
+
+        const header: *abi.SeenPcsHeader = @ptrCast(map[0..@sizeOf(abi.SeenPcsHeader)]);
+        const trailing = map[@sizeOf(abi.SeenPcsHeader)..];
+        const trailing_bitset_end = pc_bitset_usizes * @sizeOf(usize);
+        const trailing_bitset: []usize = @ptrCast(@alignCast(trailing[0..trailing_bitset_end]));
+        const trailing_addresses: []usize = @ptrCast(@alignCast(trailing[trailing_bitset_end..]));
 
-            const seen_pcs_header: *const abi.SeenPcsHeader = @ptrCast(@volatileCast(map.items));
-            if (seen_pcs_header.pcs_len != pcs.len) panic(
+        if (populate) {
+            header.* = .{
+                .n_runs = 0,
+                .unique_runs = 0,
+                .pcs_len = pcs.len,
+            };
+            @memset(trailing_bitset, 0);
+            for (trailing_addresses, pcs) |*cov_pc, slided_pc| {
+                cov_pc.* = fuzzer_unslide_address(slided_pc);
+            }
+            io_map.write(io) catch |e|
+                panic("failed to write memory map of '{s}': {t}", .{ &file_name, e });
+
+            coverage_file.lock(io, .shared) catch |e| panic(
+                "failed to demote lock for coverage file '{s}': {t}",
+                .{ &file_name, e },
+            );
+        } else { // Check expected contents
+            if (header.pcs_len != pcs.len) panic(
                 "incompatible existing coverage file '{s}' (differing pcs length: {} != {})",
-                .{ &coverage_file_name, seen_pcs_header.pcs_len, pcs.len },
+                .{ &file_name, header.pcs_len, pcs.len },
             );
-            if (mem.indexOfDiff(usize, seen_pcs_header.pcAddrs(), pcs)) |i| panic(
-                "incompatible existing coverage file '{s}' (differing pc at index {d}: {x} != {x})",
-                .{ &coverage_file_name, i, seen_pcs_header.pcAddrs()[i], pcs[i] },
-            );
-
-            return map;
+            for (0.., header.pcAddrs(), pcs) |i, cov_pc, slided_pc| {
+                const pc = fuzzer_unslide_address(slided_pc);
+                if (cov_pc != pc) panic(
+                    "incompatible existing coverage file '{s}' (differing pc at index {d}: {x} != {x})",
+                    .{ &file_name, i, cov_pc, pc },
+                );
+            }
         }
+        return map;
     }
 
     pub fn init(cache_dir_path: []const u8) Executable {
@@ -230,7 +223,7 @@ const Executable = struct {
             }
             break :digest h.final();
         };
-        self.shared_seen_pcs = getCoverageFile(cache_dir, pcs, self.pc_digest);
+        self.shared_seen_pcs = getCoverageMap(cache_dir, pcs, self.pc_digest);
 
         return self;
     }
@@ -244,14 +237,14 @@ const Executable = struct {
         index: usize = 0,
         pc_counters: []u8,
 
-        pub fn next(self: *PcBitsetIterator) usize {
-            const rest = self.pc_counters[self.index..];
+        pub fn next(i: *PcBitsetIterator) usize {
+            const rest = i.pc_counters[i.index..];
             if (rest.len >= @bitSizeOf(usize)) {
-                defer self.index += @bitSizeOf(usize);
+                defer i.index += @bitSizeOf(usize);
                 const V = @Vector(@bitSizeOf(usize), u8);
                 return @as(usize, @bitCast(@as(V, @splat(0)) != rest[0..@bitSizeOf(usize)].*));
             } else if (rest.len != 0) {
-                defer self.index += rest.len;
+                defer i.index += rest.len;
                 var res: usize = 0;
                 for (0.., rest) |bit_index, byte| {
                     res |= @shlExact(@as(usize, @intFromBool(byte != 0)), @intCast(bit_index));
@@ -260,155 +253,414 @@ const Executable = struct {
             } else unreachable;
         }
     };
-};
 
-/// Data gathered from instrumentation functions.
-/// Seperate from Executable since its state is resetable and changes.
-/// Seperate from Fuzzer since it may be needed before fuzzing starts.
-const Instrumentation = struct {
-    /// Bitset of seen pcs across all runs excluding fresh pcs.
-    /// This is seperate then shared_seen_pcs because multiple fuzzing processes are likely using
-    /// it which causes contention and unrelated pcs to our campaign being set.
-    seen_pcs: []usize,
-
-    /// Stores a fresh input's new pcs
-    fresh_pcs: []usize,
-
-    /// Pcs which __sanitizer_cov_trace_switch and __sanitizer_cov_trace_const_cmpx
-    /// have been called from and have had their already been added to const_x_vals
-    const_pcs: std.AutoArrayHashMapUnmanaged(usize, void) = .empty,
-    /// Values that have been constant operands in comparisons and switch cases.
-    /// There may be duplicates in this array if they came from different addresses, which is
-    /// fine as they are likely more important and hence more likely to be selected.
-    const_vals2: std.ArrayList(u16) = .empty,
-    const_vals4: std.ArrayList(u32) = .empty,
-    const_vals8: std.ArrayList(u64) = .empty,
-    const_vals16: std.ArrayList(u128) = .empty,
-
-    /// A minimal state for this struct which instrumentation can function on.
-    /// Used before this structure is initialized to avoid illegal behavior
-    /// from instrumentation functions being called and using undefined values.
-    pub const preinit: Instrumentation = .{
-        .seen_pcs = undefined, // currently only updated by `Fuzzer`
-        .fresh_pcs = undefined,
-    };
-
-    pub fn depreinit(self: *Instrumentation) void {
-        self.const_vals2.deinit(gpa);
-        self.const_vals4.deinit(gpa);
-        self.const_vals8.deinit(gpa);
-        self.const_vals16.deinit(gpa);
-        self.* = undefined;
-    }
-
-    pub fn init() Instrumentation {
-        const pc_bitset_usizes = bitsetUsizes(exec.pc_counters.len);
-        const alloc_usizes = pc_bitset_usizes * 2;
-        const buf = gpa.alloc(u8, alloc_usizes * @sizeOf(usize)) catch @panic("OOM");
-        var fba_ctx: std.heap.FixedBufferAllocator = .init(buf);
-        const fba = fba_ctx.allocator();
-
-        var self: Instrumentation = .{
-            .seen_pcs = fba.alloc(usize, pc_bitset_usizes) catch unreachable,
-            .fresh_pcs = fba.alloc(usize, pc_bitset_usizes) catch unreachable,
-        };
-        self.reset();
-        return self;
-    }
-
-    pub fn reset(self: *Instrumentation) void {
-        @memset(self.seen_pcs, 0);
-        @memset(self.fresh_pcs, 0);
-        self.const_pcs.clearRetainingCapacity();
-        self.const_vals2.clearRetainingCapacity();
-        self.const_vals4.clearRetainingCapacity();
-        self.const_vals8.clearRetainingCapacity();
-        self.const_vals16.clearRetainingCapacity();
-    }
-
-    /// If false is returned, then the pc is marked as seen
-    pub fn constPcSeen(self: *Instrumentation, pc: usize) bool {
-        return (self.const_pcs.getOrPut(gpa, pc) catch @panic("OOM")).found_existing;
-    }
-
-    pub fn isFresh(self: *Instrumentation) bool {
-        var hit_pcs = exec.pcBitsetIterator();
-        for (self.seen_pcs) |seen_pcs| {
-            if (hit_pcs.next() & ~seen_pcs != 0) return true;
-        }
-
-        return false;
-    }
-
-    /// Updates `fresh_pcs`
-    pub fn setFresh(self: *Instrumentation) void {
-        var hit_pcs = exec.pcBitsetIterator();
-        for (self.seen_pcs, self.fresh_pcs) |seen_pcs, *fresh_pcs| {
-            fresh_pcs.* = hit_pcs.next() & ~seen_pcs;
-        }
-    }
-
-    /// Returns if `exec.pc_counters` is a superset of `fresh_pcs`.
-    pub fn atleastFresh(self: *Instrumentation) bool {
-        var hit_pcs = exec.pcBitsetIterator();
-        for (self.fresh_pcs) |fresh_pcs| {
-            if (fresh_pcs & hit_pcs.next() != fresh_pcs) return false;
-        }
-        return true;
-    }
-
-    /// Updates based off `fresh_pcs`
-    fn updateSeen(self: *Instrumentation) void {
-        comptime assert(abi.SeenPcsHeader.trailing[0] == .pc_bits_usize);
-        const shared_seen_pcs: [*]volatile usize = @ptrCast(
-            exec.shared_seen_pcs.items[@sizeOf(abi.SeenPcsHeader)..].ptr,
+    pub fn seenPcsHeader(e: Executable) *align(std.heap.page_size_min) volatile abi.SeenPcsHeader {
+        return mem.bytesAsValue(
+            abi.SeenPcsHeader,
+            e.shared_seen_pcs[0..@sizeOf(abi.SeenPcsHeader)],
         );
-
-        for (self.seen_pcs, shared_seen_pcs, self.fresh_pcs) |*seen, *shared_seen, fresh| {
-            seen.* |= fresh;
-            if (fresh != 0)
-                _ = @atomicRmw(usize, shared_seen, .Or, fresh, .monotonic);
-        }
     }
 };
 
 const Fuzzer = struct {
-    arena_ctx: std.heap.ArenaAllocator = .init(gpa),
-    rng: std.Random.DefaultPrng = .init(0),
+    // The default PRNG is not used here since going through `Random` can be very expensive
+    // since LLVM often fails to devirtualize and inline `fill`. Additionally, optimization
+    // is simpler since integers are not serialized then deserialized in the random stream.
+    //
+    // This acounts for a 30% performance improvement with LLVM 21.
+    xoshiro: std.Random.Xoshiro256,
     test_one: abi.TestOne,
-    /// The next input that will be given to the testOne function. When the
-    /// current process crashes, this memory-mapped file is used to recover the
-    /// input.
-    input: MemoryMappedList,
-
-    /// Minimized past inputs leading to new pc hits.
-    /// These are randomly mutated in round-robin fashion
-    /// Element zero is always an empty input. It is gauraunteed no other elements are empty.
-    corpus: std.ArrayList([]const u8),
-    corpus_pos: usize,
-    /// List of past mutations that have led to new inputs. This way, the mutations that are the
-    /// most effective are the most likely to be selected again. Starts with one of each mutation.
-    mutations: std.ArrayList(Mutation) = .empty,
 
+    seen_pcs: []usize,
+    bests: struct {
+        len: u32,
+        quality_buf: []Input.Best,
+        input_buf: []Input.Best.Map,
+    },
+    seen_uids: std.ArrayHashMapUnmanaged(Uid, struct {
+        slices: union {
+            ints: std.ArrayList([]u64),
+            bytes: std.ArrayList(Input.Data.Bytes),
+        },
+    }, Uid.hashmap_ctx, false),
+
+    /// Past inputs leading to new pc or uid hits.
+    /// These are randomly mutated in round-robin fashion.
+    corpus: std.MultiArrayList(Input),
+    corpus_pos: Input.Index,
+
+    bytes_input: std.testing.Smith,
+    input_builder: Input.Builder,
+    /// Number of data calls the current run has made.
+    req_values: u32,
+    /// Number of bytes provided to the current run.
+    req_bytes: u32,
+    /// Index into the uid slices the current run is at.
+    /// `uid_data_i[i]` corresponds to `corpus[corpus_pos].data.uid_slices.values()[i]`.
+    uid_data_i: std.ArrayList(u32),
+    mut_data: struct {
+        /// Untyped indexes of `corpus[corpus_pos].data` that should be mutated.
+        ///
+        /// If an index appears multiple times, the first should be prioritized.
+        i: [4]u32,
+        /// For mutations which are a sequential mutation, the state is stored here.
+        seq: [4]struct {
+            kind: packed struct {
+                class: enum(u1) { replace, insert },
+                copy: bool,
+                /// If set then `.copy = true` and `.class = .replace`
+                ordered_mutate: bool,
+                /// If set then all other bits are undefined
+                none: bool,
+            },
+            len: u32,
+            copy: SeqCopy,
+        },
+    },
+
+    /// As values are provided to the Smith, they are appended to this. If the test
+    /// crashes, this can be recovered and used to obtain the crashing values.
+    mmap_input: MemoryMappedInput,
     /// Filesystem directory containing found inputs for future runs
     corpus_dir: Io.Dir,
-    corpus_dir_idx: usize = 0,
+    /// The values in `corpus` past this point directly correspond to what is found
+    /// in `corpus_dir`.
+    start_corpus_dir: u32,
+
+    const SeqCopy = union {
+        order_i: u32,
+        ints: []u64,
+        bytes: Input.Data.Bytes,
+    };
+
+    const Input = struct {
+        /// Untyped indexes into this are formed as follows: If the index is less than `ints.len`
+        /// it indexes into `ints`, otherwise it indexes into `bytes` subtracted by `ints.len`.
+        /// `math.maxInt(u32)` is reserved and impossible normally.
+        data: Data,
+        /// Corresponds with `data.uid_slices`.
+        /// Values are the indexes of `seen_uids` with the same uid.
+        seen_uid_i: []u32,
+        /// Used to select a random uid to mutate from.
+        ///
+        /// The number of times a uid is present in this array is logarithmic
+        /// to its data length in order to avoid long inputs from only being
+        /// selected while still having some bias towards longer ones.
+        weighted_uid_slice_i: []u32,
+
+        ref: struct {
+            /// Values are indexes of `Fuzzer.bests`.
+            best_i_buf: []u32,
+            best_i_len: u32,
+        },
+
+        pub const Data = struct {
+            uid_slices: Data.UidSlices,
+            ints: []u64,
+            bytes: Bytes,
+            /// Contains untyped indexes in the order they were requested.
+            order: []u32,
+
+            pub const Bytes = struct {
+                entries: []Entry,
+                table: []u8,
+
+                pub const Entry = struct {
+                    off: u32,
+                    len: u32,
+                };
+
+                pub fn deinit(b: Bytes) void {
+                    gpa.free(b.entries);
+                    gpa.free(b.table);
+                }
+            };
+
+            pub const UidSlices = std.ArrayHashMapUnmanaged(Uid, struct {
+                base: u32,
+                len: u32,
+            }, Uid.hashmap_ctx, false);
+        };
+
+        pub fn deinit(i: *Input) void {
+            i.data.uid_slices.deinit(gpa);
+            gpa.free(i.data.ints);
+            i.data.bytes.deinit();
+            gpa.free(i.data.order);
+            gpa.free(i.seen_uid_i);
+            gpa.free(i.weighted_uid_slice_i);
+            gpa.free(i.ref.best_i_buf);
+            i.* = undefined;
+        }
+
+        pub const none: Input = .{
+            .data = .{
+                .uid_slices = .empty,
+                .ints = &.{},
+                .bytes = .{
+                    .entries = &.{},
+                    .table = undefined,
+                },
+                .order = &.{},
+            },
+            .seen_uid_i = &.{},
+            .weighted_uid_slice_i = &.{},
+
+            // Empty input is not referenced by `Fuzzer`
+            .ref = undefined,
+        };
+
+        pub const Index = enum(u32) {
+            pub const reserved_start: Index = .bytes_dry;
+            /// Only touches `Fuzzer.smith`.
+            bytes_dry = math.maxInt(u32) - 1,
+            /// Only touches `Fuzzer.smith` and `Fuzzer.input_builder`.
+            bytes_fresh = math.maxInt(u32),
+            _,
+        };
+
+        pub const Best = struct {
+            pc: u32,
+            min: Quality,
+            max: Quality,
+
+            /// Order of significance:
+            /// * n_pcs
+            /// * req.values
+            /// * req.bytes
+            pub const Quality = struct {
+                n_pcs: u32,
+                req: packed struct(u64) {
+                    bytes: u32,
+                    values: u32,
+
+                    pub fn int(r: @This()) u64 {
+                        return @bitCast(r);
+                    }
+                },
+
+                pub fn betterLess(a: Quality, b: Quality) bool {
+                    return (a.n_pcs < b.n_pcs) | ((a.n_pcs == b.n_pcs) & (a.req.int() < b.req.int()));
+                }
+
+                pub fn betterMore(a: Quality, b: Quality) bool {
+                    return (a.n_pcs > b.n_pcs) | ((a.n_pcs == b.n_pcs) & (a.req.int() < b.req.int()));
+                }
+            };
+
+            pub const Map = struct {
+                min: Input.Index,
+                max: Input.Index,
+            };
+        };
+
+        pub const Builder = struct {
+            uid_slices: std.ArrayHashMapUnmanaged(Uid, union {
+                ints: std.MultiArrayList(struct {
+                    value: u64,
+                    order_i: u32,
+                }),
+                bytes: std.MultiArrayList(struct {
+                    value: Data.Bytes.Entry,
+                    order_i: u32,
+                }),
+            }, Uid.hashmap_ctx, false),
+            bytes_table: std.ArrayList(u8),
+            // These will not overflow due to the 32-bit constraint on `MemoryMappedInput`
+            total_ints: u32,
+            total_bytes: u32,
+            weighted_len: u32,
+            /// Used to ensure that the 32-bit constraint in
+            /// `MemoryMappedInput` applies to this run.
+            smithed_len: u32,
+
+            pub const init: Builder = .{
+                .uid_slices = .empty,
+                .bytes_table = .empty,
+                .total_ints = 0,
+                .total_bytes = 0,
+                .weighted_len = 0,
+                .smithed_len = 4,
+            };
+
+            pub fn addInt(b: *Builder, uid: Uid, int: u64) void {
+                const u = &b.uid_slices;
+                const gop = u.getOrPutValue(gpa, uid, .{ .ints = .empty }) catch @panic("OOM");
+                gop.value_ptr.ints.append(gpa, .{
+                    .value = int,
+                    .order_i = b.total_ints + b.total_bytes,
+                }) catch @panic("OOM");
+                b.total_ints += 1;
+                b.weighted_len += @intFromBool(math.isPowerOfTwo(gop.value_ptr.ints.len));
+            }
+
+            pub fn addBytes(b: *Builder, uid: Uid, bytes: []const u8) void {
+                const u = &b.uid_slices;
+                const gop = u.getOrPutValue(gpa, uid, .{ .bytes = .empty }) catch @panic("OOM");
+                gop.value_ptr.bytes.append(gpa, .{
+                    .value = .{
+                        .off = @intCast(b.bytes_table.items.len),
+                        .len = @intCast(bytes.len),
+                    },
+                    .order_i = b.total_ints + b.total_bytes,
+                }) catch @panic("OOM");
+                b.bytes_table.appendSlice(gpa, bytes) catch @panic("OOM");
+                b.total_bytes += 1;
+                b.weighted_len += @intFromBool(math.isPowerOfTwo(gop.value_ptr.bytes.len));
+            }
+
+            pub fn checkSmithedLen(b: *Builder, n: usize) void {
+                const n32 = @min(n, math.maxInt(u32)); // second will overflow
+                b.smithed_len, const ov = @addWithOverflow(b.smithed_len, n32);
+                if (ov == 1) @panic("too much smith data requested (non-deterministic)");
+            }
+
+            /// Additionally resets the state of this structure.
+            ///
+            /// The callee must populate
+            /// * `.seen_uid_i`
+            /// * `.ref`
+            pub fn build(b: *Builder) Input {
+                const uid_slices = b.uid_slices.entries.slice();
+                var input: Input = .{
+                    .data = .{
+                        .uid_slices = Data.UidSlices.init(gpa, uid_slices.items(.key), &.{}) catch
+                            @panic("OOM"),
+                        .ints = gpa.alloc(u64, b.total_ints) catch @panic("OOM"),
+                        .bytes = .{
+                            .entries = gpa.alloc(Data.Bytes.Entry, b.total_bytes) catch @panic("OOM"),
+                            .table = b.bytes_table.toOwnedSlice(gpa) catch @panic("OOM"),
+                        },
+                        .order = gpa.alloc(u32, b.total_ints + b.total_bytes) catch @panic("OOM"),
+                    },
+                    .seen_uid_i = gpa.alloc(u32, uid_slices.len) catch @panic("OOM"),
+                    .weighted_uid_slice_i = gpa.alloc(u32, b.weighted_len) catch @panic("OOM"),
+                    .ref = undefined,
+                };
+                var ints_pos: u32 = 0;
+                var bytes_pos: u32 = 0;
+                var weighted_pos: u32 = 0;
+
+                assert(mem.eql(Uid, uid_slices.items(.key), input.data.uid_slices.keys()));
+                for (
+                    0..,
+                    uid_slices.items(.key),
+                    uid_slices.items(.value),
+                    input.data.uid_slices.values(),
+                ) |uid_i, uid, *uid_data, *slice| {
+                    const weighted_len = 1 + math.log2_int(u32, len: switch (uid.kind) {
+                        .int => {
+                            const ints = uid_data.ints.slice();
+                            @memcpy(input.data.ints[ints_pos..][0..ints.len], ints.items(.value));
+                            for (ints.items(.order_i), ints_pos..) |order_i, data_i| {
+                                input.data.order[order_i] = @intCast(data_i);
+                            }
+                            uid_data.ints.deinit(gpa);
+                            slice.* = .{ .base = ints_pos, .len = @intCast(ints.len) };
+                            ints_pos += @intCast(ints.len);
+                            break :len @intCast(ints.len);
+                        },
+                        .bytes => {
+                            const bytes = uid_data.bytes.slice();
+                            @memcpy(
+                                input.data.bytes.entries[bytes_pos..][0..bytes.len],
+                                bytes.items(.value),
+                            );
+                            for (
+                                bytes.items(.order_i),
+                                b.total_ints + bytes_pos..,
+                            ) |order_i, data_i| {
+                                input.data.order[order_i] = @intCast(data_i);
+                            }
+                            uid_data.bytes.deinit(gpa);
+                            slice.* = .{ .base = bytes_pos, .len = @intCast(bytes.len) };
+                            bytes_pos += @intCast(bytes.len);
+                            break :len @intCast(bytes.len);
+                        },
+                    });
+                    const weighted = input.weighted_uid_slice_i[weighted_pos..][0..weighted_len];
+                    @memset(weighted, @intCast(uid_i));
+                    weighted_pos += weighted_len;
+                }
+
+                assert(ints_pos == b.total_ints);
+                assert(bytes_pos == b.total_bytes);
+                assert(weighted_pos == b.weighted_len);
+
+                b.uid_slices.clearRetainingCapacity();
+                b.total_ints = 0;
+                b.total_bytes = 0;
+                b.weighted_len = 0;
+                b.smithed_len = 4;
+                return input;
+            }
+        };
+    };
+
+    pub fn init() Fuzzer {
+        if (exec.pc_counters.len > math.maxInt(u32)) @panic("too many pcs");
+        const f: Fuzzer = .{
+            .xoshiro = .init(0),
+            .test_one = undefined,
+
+            .seen_pcs = gpa.alloc(usize, bitsetUsizes(exec.pc_counters.len)) catch @panic("OOM"),
+            .bests = .{
+                .len = 0,
+                .quality_buf = gpa.alloc(Input.Best, exec.pc_counters.len) catch @panic("OOM"),
+                .input_buf = gpa.alloc(Input.Best.Map, exec.pc_counters.len) catch @panic("OOM"),
+            },
+            .seen_uids = .empty,
 
-    pub fn init(test_one: abi.TestOne, unit_test_name: []const u8) Fuzzer {
-        var self: Fuzzer = .{
-            .test_one = test_one,
-            .input = undefined,
             .corpus = .empty,
-            .corpus_pos = 0,
-            .mutations = .empty,
+            .corpus_pos = undefined,
+
+            .bytes_input = undefined,
+            .input_builder = .init,
+            .req_values = undefined,
+            .req_bytes = undefined,
+            .uid_data_i = .empty,
+            .mut_data = undefined,
+
+            .mmap_input = undefined,
             .corpus_dir = undefined,
+            .start_corpus_dir = undefined,
         };
-        const arena = self.arena_ctx.allocator();
+        @memset(f.seen_pcs, 0);
+        return f;
+    }
 
-        self.corpus_dir = exec.cache_f.createDirPathOpen(io, unit_test_name, .{}) catch |e|
+    /// May only be called after `f.setTest` has been called
+    pub fn reset(f: *Fuzzer) void {
+        f.test_one = undefined;
+
+        @memset(f.seen_pcs, 0);
+        f.bests.len = 0;
+        @memset(f.bests.quality_buf, undefined);
+        @memset(f.bests.input_buf, undefined);
+        for (f.seen_uids.keys(), f.seen_uids.values()) |uid, *u| {
+            switch (uid.kind) {
+                .int => u.slices.ints.deinit(gpa),
+                .bytes => u.slices.bytes.deinit(gpa),
+            }
+        }
+        f.seen_uids.clearRetainingCapacity();
+
+        f.corpus.clearRetainingCapacity();
+        f.corpus_pos = undefined;
+
+        f.uid_data_i.clearRetainingCapacity();
+
+        f.mmap_input.deinit();
+        f.corpus_dir.close(io);
+        f.start_corpus_dir = undefined;
+    }
+
+    pub fn setTest(f: *Fuzzer, test_one: abi.TestOne, unit_test_name: []const u8) void {
+        f.test_one = test_one;
+        f.corpus_dir = exec.cache_f.createDirPathOpen(io, unit_test_name, .{}) catch |e|
             panic("failed to open directory '{s}': {t}", .{ unit_test_name, e });
-        self.input = in: {
-            const f = self.corpus_dir.createFile(io, "in", .{
+        f.mmap_input = map: {
+            const input = f.corpus_dir.createFile(io, "in", .{
                 .read = true,
                 .truncate = false,
                 // In case any other fuzz tests are running under the same test name,
@@ -419,181 +671,979 @@ const Fuzzer = struct {
                 error.WouldBlock => @panic("input file 'in' is in use by another fuzzing process"),
                 else => panic("failed to create input file 'in': {t}", .{e}),
             };
-            const size = f.length(io) catch |e| panic("failed to stat input file 'in': {t}", .{e});
-            const map = (if (size < std.heap.page_size_max)
-                MemoryMappedList.create(f, 8, std.heap.page_size_max)
-            else
-                MemoryMappedList.init(f, size, size)) catch |e|
-                panic("failed to memory map input file 'in': {t}", .{e});
 
-            // Perform a dry-run of the stored input if there was one in case it might reproduce a
-            // crash.
-            const old_in_len = mem.littleToNative(usize, mem.bytesAsValue(usize, map.items[0..8]).*);
-            if (size >= 8 and old_in_len != 0 and map.items.len - 8 < old_in_len) {
-                test_one(.fromSlice(@volatileCast(map.items[8..][0..old_in_len])));
+            var size = input.length(io) catch |e| panic("failed to stat input file 'in': {t}", .{e});
+            if (size < std.heap.page_size_max) {
+                size = std.heap.page_size_max;
+                input.setLength(io, size) catch |e| panic("failed to resize input file 'in': {t}", .{e});
             }
 
-            break :in map;
+            break :map MemoryMappedInput.init(input, size) catch |e|
+                panic("failed to memmap input file 'in': {t}", .{e});
         };
-        inst.reset();
 
-        self.mutations.appendSlice(gpa, std.meta.tags(Mutation)) catch @panic("OOM");
-        // Ensure there is never an empty corpus. Additionally, an empty input usually leads to
-        // new inputs.
-        self.addInput(&.{});
+        // Perform a dry-run of the stored input in case it might reproduce a crash.
+        const len = mem.readInt(u32, f.mmap_input.mmap.memory[0..4], .little);
+        if (len < f.mmap_input.mmap.memory[4..].len) {
+            f.mmap_input.len = len;
+            f.runBytes(f.mmap_input.inputSlice(), .bytes_dry);
+            f.mmap_input.clearRetainingCapacity();
+        }
+    }
 
+    pub fn loadCorpus(f: *Fuzzer) void {
+        f.corpus_pos = @enumFromInt(f.corpus.len);
+        f.corpus.append(gpa, .none) catch @panic("OOM"); // Also ensures the corpus is not empty
+        f.start_corpus_dir = @intCast(f.corpus.len);
         while (true) {
-            var name_buf: [@sizeOf(usize) * 2]u8 = undefined;
-            const bytes = self.corpus_dir.readFileAlloc(
-                io,
-                std.fmt.bufPrint(&name_buf, "{x}", .{self.corpus_dir_idx}) catch unreachable,
-                arena,
-                .unlimited,
-            ) catch |e| switch (e) {
+            var name_buf: [8]u8 = undefined;
+            const name = f.corpusFileName(&name_buf, @enumFromInt(f.corpus.len));
+            const bytes = f.corpus_dir.readFileAlloc(io, name, gpa, .unlimited) catch |e| switch (e) {
                 error.FileNotFound => break,
-                else => panic("failed to read corpus file '{x}': {t}", .{ self.corpus_dir_idx, e }),
+                else => panic("failed to read corpus file '{s}': {t}", .{ name, e }),
             };
-            // No corpus file of length zero will ever be created
-            if (bytes.len == 0)
-                panic("corrupt corpus file '{x}' (len of zero)", .{self.corpus_dir_idx});
-            self.addInput(bytes);
-            self.corpus_dir_idx += 1;
+            defer gpa.free(bytes);
+            f.newInput(bytes, false);
         }
+        f.corpus_pos = @enumFromInt(0);
+    }
 
-        return self;
+    fn corpusFileName(f: *Fuzzer, buf: *[8]u8, i: Input.Index) []u8 {
+        const dir_i = @intFromEnum(i) - f.start_corpus_dir;
+        return std.fmt.bufPrint(buf, "{x}", .{dir_i}) catch unreachable;
     }
 
-    pub fn deinit(self: *Fuzzer) void {
-        self.input.deinit();
-        self.corpus.deinit(gpa);
-        self.mutations.deinit(gpa);
-        self.corpus_dir.close(io);
-        self.arena_ctx.deinit();
-        self.* = undefined;
+    fn rngInt(f: *Fuzzer, T: type) T {
+        comptime assert(@bitSizeOf(T) <= 64);
+        const Unsigned = @Int(.unsigned, @bitSizeOf(T));
+        return @bitCast(@as(Unsigned, @truncate(f.xoshiro.next())));
     }
 
-    pub fn addInput(self: *Fuzzer, bytes: []const u8) void {
-        self.corpus.append(gpa, bytes) catch @panic("OOM");
-        self.input.clearRetainingCapacity();
-        self.input.ensureTotalCapacity(8 + bytes.len) catch |e|
-            panic("could not resize shared input file: {t}", .{e});
-        self.input.items.len = 8;
-        self.input.appendSliceAssumeCapacity(bytes);
-        self.run();
-        inst.setFresh();
-        inst.updateSeen();
+    fn rngLessThan(f: *Fuzzer, T: type, limit: T) T {
+        return std.Random.limitRangeBiased(T, f.rngInt(T), limit);
     }
 
-    /// Assumes `fresh_pcs` correspond to the input
-    fn minimizeInput(self: *Fuzzer) void {
-        // The minimization technique is kept relatively simple, we sequentially try to remove each
-        // byte and check that the new pcs and memory loads are still hit.
-        var i = self.input.items.len;
-        while (i != 8) {
-            i -= 1;
-            const old = self.input.orderedRemove(i);
-
-            @memset(exec.pc_counters, 0);
-            self.run();
-
-            if (!inst.atleastFresh()) {
-                self.input.insertAssumeCapacity(i, old);
-            } else {
-                // This removal may have led to new pcs or memory loads being hit, so we need to
-                // update them to avoid duplicates.
-                inst.setFresh();
-            }
+    /// Used for generating small values rather than making many calls into the prng.
+    const SmallEntronopy = struct {
+        bits: u64,
+
+        pub fn take(e: *SmallEntronopy, T: type) T {
+            defer e.bits >>= @bitSizeOf(T);
+            return @truncate(e.bits);
+        }
+    };
+
+    fn isFresh(f: *Fuzzer) bool {
+        // Store as a bool instead of returning immediately to aid optimizations
+        // by reducing branching since a fresh input is the unlikely case.
+        var fresh: bool = false;
+
+        var n_pcs: u32 = 0;
+        var hit_pcs = exec.pcBitsetIterator();
+        for (f.seen_pcs) |seen| {
+            const hits = hit_pcs.next();
+            fresh |= hits & ~seen != 0;
+            n_pcs += @popCount(hits);
         }
+
+        const quality: Input.Best.Quality = .{
+            .n_pcs = n_pcs,
+            .req = .{
+                .values = f.req_values,
+                .bytes = f.req_bytes,
+            },
+        };
+        for (f.bests.quality_buf[0..f.bests.len]) |best| {
+            if (exec.pc_counters[best.pc] == 0) continue;
+            fresh |= quality.betterLess(best.min) | quality.betterMore(best.max);
+        }
+
+        return fresh;
     }
 
-    fn run(self: *Fuzzer) void {
-        // `pc_counters` is not cleared since only new hits are relevant.
+    fn runBytes(f: *Fuzzer, bytes: []const u8, mode: Input.Index) void {
+        assert(mode == .bytes_dry or mode == .bytes_fresh);
 
-        mem.bytesAsValue(usize, self.input.items[0..8]).* =
-            mem.nativeToLittle(usize, self.input.items.len - 8);
-        self.test_one(.fromSlice(@volatileCast(self.input.items[8..])));
+        f.bytes_input = .{ .in = bytes };
+        f.corpus_pos = mode;
+        f.run(0); // 0 since `f.uid_data` is unused
+    }
 
-        const header = mem.bytesAsValue(
-            abi.SeenPcsHeader,
-            exec.shared_seen_pcs.items[0..@sizeOf(abi.SeenPcsHeader)],
+    fn updateSeenPcs(f: *Fuzzer) void {
+        comptime assert(abi.SeenPcsHeader.trailing[0] == .pc_bits_usize);
+        const shared_seen_pcs: [*]volatile usize = @ptrCast(
+            exec.shared_seen_pcs[@sizeOf(abi.SeenPcsHeader)..].ptr,
         );
-        _ = @atomicRmw(usize, &header.n_runs, .Add, 1, .monotonic);
-    }
-
-    pub fn cycle(self: *Fuzzer) void {
-        const input = self.corpus.items[self.corpus_pos];
-        self.corpus_pos += 1;
-        if (self.corpus_pos == self.corpus.items.len)
-            self.corpus_pos = 0;
-
-        const rng = self.rng.random();
-        const m = while (true) {
-            const m = self.mutations.items[rng.uintLessThanBiased(usize, self.mutations.items.len)];
-            if (!m.mutate(
-                rng,
-                input,
-                &self.input,
-                self.corpus.items,
-                inst.const_vals2.items,
-                inst.const_vals4.items,
-                inst.const_vals8.items,
-                inst.const_vals16.items,
-            )) continue;
-            break m;
+
+        var hit_pcs = exec.pcBitsetIterator();
+        for (f.seen_pcs, shared_seen_pcs) |*seen, *shared_seen| {
+            const new = hit_pcs.next() & ~seen.*;
+            if (new != 0) {
+                seen.* |= new;
+                _ = @atomicRmw(usize, shared_seen, .Or, new, .monotonic);
+            }
+        }
+    }
+
+    fn removeBest(f: *Fuzzer, i: Input.Index, best_i: u32, modify_fs_corpus: bool) void {
+        const ref = &f.corpus.items(.ref)[@intFromEnum(i)];
+        const list_i = mem.indexOfScalar(u32, ref.best_i_buf[0..ref.best_i_len], best_i).?;
+        ref.best_i_len -= 1;
+        ref.best_i_buf[list_i] = ref.best_i_buf[ref.best_i_len];
+
+        if (ref.best_i_len == 0 and @intFromEnum(i) >= f.start_corpus_dir and modify_fs_corpus) {
+            // The input is no longer valuable, so remove it.
+            var removed_input = f.corpus.get(@intFromEnum(i));
+            for (
+                removed_input.data.uid_slices.keys(),
+                removed_input.data.uid_slices.values(),
+                removed_input.seen_uid_i,
+            ) |uid, slice, seen_uid_i| {
+                switch (uid.kind) {
+                    .int => {
+                        const seen_ints = &f.seen_uids.values()[seen_uid_i].slices.ints;
+                        const removed_ints = removed_input.data.ints[slice.base..][0..slice.len];
+                        _ = seen_ints.swapRemove(for (0.., seen_ints.items) |idx, ints| {
+                            if (removed_ints.ptr == ints.ptr) {
+                                assert(removed_ints.len == ints.len);
+                                break idx;
+                            }
+                        } else unreachable);
+                    },
+                    .bytes => {
+                        const seen_bytes = &f.seen_uids.values()[seen_uid_i].slices.bytes;
+                        const removed_bytes: Input.Data.Bytes = .{
+                            .entries = removed_input.data.bytes.entries[slice.base..][0..slice.len],
+                            .table = removed_input.data.bytes.table,
+                        };
+                        _ = seen_bytes.swapRemove(for (0.., seen_bytes.items) |idx, bytes| {
+                            if (removed_bytes.entries.ptr == bytes.entries.ptr) {
+                                assert(removed_bytes.entries.len == bytes.entries.len);
+                                assert(removed_bytes.table.ptr == bytes.table.ptr);
+                                assert(removed_bytes.table.len == bytes.table.len);
+                                break idx;
+                            }
+                        } else unreachable);
+                    },
+                }
+            }
+            removed_input.deinit();
+            f.corpus.swapRemove(@intFromEnum(i));
+
+            var removed_name_buf: [8]u8 = undefined;
+            const removed_name = f.corpusFileName(&removed_name_buf, i);
+
+            if (@intFromEnum(i) == f.corpus.len) {
+                f.corpus_dir.deleteFile(io, removed_name) catch |e| panic(
+                    "failed to remove corpus file '{s}': {t}",
+                    .{ removed_name, e },
+                );
+                return; // No item moved so no refs to update
+            }
+
+            var swapped_name_buf: [8]u8 = undefined;
+            const swapped_name = f.corpusFileName(&swapped_name_buf, @enumFromInt(f.corpus.len));
+
+            f.corpus_dir.rename(swapped_name, f.corpus_dir, removed_name, io) catch |e| panic(
+                "failed to rename corpus file '{s}' to '{s}': {t}",
+                .{ swapped_name, removed_name, e },
+            );
+
+            // Update refrences. `ref` can be reused since it was a swap remove
+            for (ref.best_i_buf[0..ref.best_i_len]) |update_pc_i| {
+                const best = &f.bests.input_buf[update_pc_i];
+                assert(@intFromEnum(best.min) == f.corpus.len or
+                    @intFromEnum(best.max) == f.corpus.len);
+
+                if (@intFromEnum(best.min) == f.corpus.len) best.min = i;
+                if (@intFromEnum(best.max) == f.corpus.len) best.max = i;
+            }
+        }
+    }
+
+    pub fn newInput(f: *Fuzzer, bytes: []const u8, modify_fs_corpus: bool) void {
+        f.runBytes(bytes, .bytes_fresh);
+        f.req_values = f.input_builder.total_ints + f.input_builder.total_bytes;
+        f.req_bytes = @intCast(f.input_builder.bytes_table.items.len);
+        var input = f.input_builder.build();
+
+        f.uid_data_i.ensureTotalCapacity(gpa, input.data.uid_slices.entries.len) catch @panic("OOM");
+        for (
+            input.seen_uid_i,
+            input.data.uid_slices.keys(),
+            input.data.uid_slices.values(),
+        ) |*i, uid, slice| {
+            const gop = f.seen_uids.getOrPutValue(gpa, uid, switch (uid.kind) {
+                .int => .{ .slices = .{ .ints = .empty } },
+                .bytes => .{ .slices = .{ .bytes = .empty } },
+            }) catch @panic("OOM");
+            switch (uid.kind) {
+                .int => f.seen_uids.values()[gop.index].slices.ints.append(
+                    gpa,
+                    input.data.ints[slice.base..][0..slice.len],
+                ) catch @panic("OOM"),
+                .bytes => f.seen_uids.values()[gop.index].slices.bytes.append(gpa, .{
+                    .entries = input.data.bytes.entries[slice.base..][0..slice.len],
+                    .table = input.data.bytes.table,
+                }) catch @panic("OOM"),
+            }
+            i.* = @intCast(gop.index);
+        }
+
+        const quality: Input.Best.Quality = .{
+            .n_pcs = n_pcs: {
+                @setRuntimeSafety(builtin.mode == .Debug); // Necessary for vectorization
+                var n: u32 = 0;
+                for (exec.pc_counters) |c| {
+                    n += @intFromBool(c != 0);
+                }
+                break :n_pcs n;
+            },
+            .req = .{
+                .values = f.req_values,
+                .bytes = f.req_bytes,
+            },
         };
 
-        self.run();
+        var best_i_list: std.ArrayList(u32) = .empty;
+        for (0.., f.bests.quality_buf[0..f.bests.len]) |best_i, best| {
+            if (exec.pc_counters[best.pc] == 0) continue;
+
+            const better_min = quality.betterLess(best.min);
+            const better_max = quality.betterMore(best.max);
+            if (!better_min and !better_max) {
+                @branchHint(.likely);
+                continue;
+            }
+            best_i_list.append(gpa, @intCast(best_i)) catch @panic("OOM");
+
+            const map = &f.bests.input_buf[best_i];
+            if (map.min != map.max) {
+                if (better_min) {
+                    f.removeBest(map.min, @intCast(best_i), modify_fs_corpus);
+                }
+                if (better_max) {
+                    f.removeBest(map.max, @intCast(best_i), modify_fs_corpus);
+                }
+            } else {
+                if (better_min and better_max) {
+                    f.removeBest(map.min, @intCast(best_i), modify_fs_corpus);
+                }
+            }
+        }
+
+        // Must come after the above since some inputs may be removed
+        const input_i: Input.Index = @enumFromInt(f.corpus.len);
+        if (input_i == Input.Index.reserved_start) {
+            @panic("corpus size limit exceeded");
+        }
 
-        if (inst.isFresh()) {
+        for (best_i_list.items) |i| {
+            const best_qual = &f.bests.quality_buf[i];
+            const best_map = &f.bests.input_buf[i];
+
+            if (quality.betterLess(best_qual.min)) {
+                best_qual.min = quality;
+                best_map.min = input_i;
+            }
+            if (quality.betterMore(best_qual.max)) {
+                best_qual.max = quality;
+                best_map.max = input_i;
+            }
+        }
+
+        for (0.., exec.pc_counters) |i, hits| {
+            if (hits == 0) {
+                @branchHint(.likely);
+                continue;
+            }
+
+            if ((f.seen_pcs[i / @bitSizeOf(usize)] >> @intCast(i % @bitSizeOf(usize))) & 1 == 0) {
+                @branchHint(.unlikely);
+                best_i_list.append(gpa, f.bests.len) catch @panic("OOM");
+                f.bests.quality_buf[f.bests.len] = .{
+                    .pc = @intCast(i),
+                    .min = quality,
+                    .max = quality,
+                };
+                f.bests.input_buf[f.bests.len] = .{ .min = input_i, .max = input_i };
+                f.bests.len += 1;
+            }
+        }
+
+        if (best_i_list.items.len == 0 and
+            modify_fs_corpus // Found by freshness; otherwise, it does not need to be better
+        ) {
+            @branchHint(.cold); // Nondeterministic test
+            std.log.warn("nondeterministic rerun", .{});
+            return;
+        }
+
+        input.ref.best_i_buf = best_i_list.toOwnedSlice(gpa) catch @panic("OOM");
+        input.ref.best_i_len = @intCast(input.ref.best_i_buf.len);
+        f.corpus.append(gpa, input) catch @panic("OOM");
+        f.corpus_pos = input_i;
+
+        // Must come after the above since `seen_pcs` is used
+        f.updateSeenPcs();
+
+        if (!modify_fs_corpus) return;
+
+        // Write new input to cache
+        var name_buf: [8]u8 = undefined;
+        const name = f.corpusFileName(&name_buf, input_i);
+        f.corpus_dir.writeFile(io, .{ .sub_path = name, .data = bytes }) catch |e|
+            panic("failed to write corpus file '{s}': {t}", .{ name, e });
+    }
+
+    fn run(f: *Fuzzer, input_uids: usize) void {
+        @memset(exec.pc_counters, 0);
+        f.uid_data_i.items.len = input_uids;
+        @memset(f.uid_data_i.items, 0);
+        f.req_values = 0;
+        f.req_bytes = 0;
+
+        f.test_one();
+        _ = @atomicRmw(usize, &exec.seenPcsHeader().n_runs, .Add, 1, .monotonic);
+    }
+
+    /// Returns a number of mutations to perform from 1-4
+    /// with smaller values exponentially more likely.
+    pub fn mutCount(rng: u16) u8 {
+        // The below provides the following distribution
+        // @clz(@clz(    range       mapped   percentage         ratio
+        //          0 ->     0         -> 4  1 = 93.750%  (15 / 16   )
+        //          1 ->     1 - 255   -> 3  2 =  5.859%  (15 / 256  )
+        //          2 ->   256 - 4095  -> 2  3 =   .391%  (<1 / 256  )
+        //          3 ->  4096 - 16383 -> 1  4 =   .002%  ( 1 / 65536)
+        //          4 -> 16384 - 32767 -> 1
+        //          5 -> 32768 - 65535 -> 1
+        return @as(u8, 4) - @min(@clz(@clz(rng)), 3);
+    }
+
+    pub fn cycle(f: *Fuzzer) void {
+        assert(f.mmap_input.len == 0);
+        const corpus = f.corpus.slice();
+        const corpus_i = @intFromEnum(f.corpus_pos);
+
+        var small_entronopy: SmallEntronopy = .{ .bits = f.rngInt(u64) };
+        var n_mutate = mutCount(small_entronopy.take(u16));
+        const data = &corpus.items(.data)[corpus_i];
+        const weighted_uid_slice_i = corpus.items(.weighted_uid_slice_i)[corpus_i];
+        n_mutate *= @intFromBool(weighted_uid_slice_i.len != 0); // No static mutations on empty
+
+        f.mut_data = .{
+            .i = @splat(math.maxInt(u32)),
+            .seq = @splat(.{
+                .kind = .{
+                    .class = undefined,
+                    .copy = undefined,
+                    .ordered_mutate = undefined,
+                    .none = true,
+                },
+                .len = undefined,
+                .copy = undefined,
+            }),
+        };
+
+        const uid_slices = data.uid_slices.entries.slice();
+        for (
+            f.mut_data.i[0..n_mutate],
+            f.mut_data.seq[0..n_mutate],
+        ) |*i, *s| if ((data.order.len < 2) | (small_entronopy.take(u3) != 0)) {
+            // Mutation on uid
+            const uid_slice_wi = f.rngLessThan(u32, @intCast(weighted_uid_slice_i.len));
+            const uid_slice_i = weighted_uid_slice_i[uid_slice_wi];
+
+            const is_bytes = uid_slices.items(.key)[uid_slice_i].kind == .bytes;
+            const data_slice = uid_slices.items(.value)[uid_slice_i];
+            i.* = @as(u32, @intCast(data.ints.len)) * @intFromBool(is_bytes) +
+                data_slice.base + f.rngLessThan(u32, data_slice.len);
+        } else {
+            // Sequence mutation on order
+            const order_len: u32 = @intCast(data.order.len);
+            const order_i = f.rngLessThan(u32, order_len - 1);
+            s.* = .{
+                .kind = .{
+                    .class = .replace,
+                    .copy = true,
+                    .ordered_mutate = true,
+                    .none = false,
+                },
+                .len = @min(@clz(f.rngInt(u16)) + 1, order_len - order_i),
+                .copy = .{ .order_i = order_i },
+            };
+            i.* = data.order[order_i];
+        };
+
+        f.run(data.uid_slices.entries.len);
+        if (f.isFresh()) {
             @branchHint(.unlikely);
 
-            const header = mem.bytesAsValue(
-                abi.SeenPcsHeader,
-                exec.shared_seen_pcs.items[0..@sizeOf(abi.SeenPcsHeader)],
-            );
-            _ = @atomicRmw(usize, &header.unique_runs, .Add, 1, .monotonic);
+            _ = @atomicRmw(usize, &exec.seenPcsHeader().unique_runs, .Add, 1, .monotonic);
+            f.newInput(f.mmap_input.inputSlice(), true);
+        }
+        f.mmap_input.clearRetainingCapacity();
 
-            inst.setFresh();
-            self.minimizeInput();
-            inst.updateSeen();
+        assert(@intFromEnum(f.corpus_pos) < f.corpus.len);
+        f.corpus_pos = @enumFromInt((@intFromEnum(f.corpus_pos) + 1) % f.corpus.len);
+    }
 
-            // An empty-input has always been tried, so if an empty input is fresh then the
-            // test has to be non-deterministic. This has to be checked as duplicate empty
-            // entries are not allowed.
-            if (self.input.items.len - 8 == 0) {
-                std.log.warn("non-deterministic test (empty input produces different hits)", .{});
-                _ = @atomicRmw(usize, &header.unique_runs, .Sub, 1, .monotonic);
-                return;
+    fn weightsContain(int: u64, weights: []const abi.Weight) bool {
+        var contains: bool = false;
+        for (weights) |w| {
+            contains |= w.min <= int and int <= w.max;
+        }
+        return contains;
+    }
+
+    fn weightsContainBytes(bytes: []const u8, weights: []const abi.Weight) bool {
+        if (weights[0].min == 0 and weights[0].max == 0xff) {
+            // Fast path: all bytes are valid
+            return true;
+        }
+
+        var contains: bool = true;
+        for (bytes) |b| {
+            contains &= weightsContain(b, weights);
+        }
+        return contains;
+    }
+
+    fn sumWeightsInclusive(weights: []const abi.Weight) u64 {
+        var sum: u64 = math.maxInt(u64);
+        for (weights) |w| {
+            sum +%= (w.max - w.min +% 1) *% w.weight;
+        }
+        return sum;
+    }
+
+    fn weightedValue(f: *Fuzzer, weights: []const abi.Weight, incl_sum: u64) u64 {
+        var incl_n: u64 = f.rngInt(u64);
+        const limit = incl_sum +% 1;
+        if (limit != 0) incl_n = std.Random.limitRangeBiased(u64, incl_n, limit);
+
+        for (weights) |w| {
+            // (w.max - w.min + 1) * w.weight - 1
+            const incl_vals = (w.max - w.min) * w.weight + (w.weight - 1);
+            if (incl_n > incl_vals) {
+                incl_n -= incl_vals + 1;
+            } else {
+                const val = w.min + incl_n / w.weight;
+                assert(val <= w.max);
+                return val;
+            }
+        } else unreachable;
+    }
+
+    const Untyped = union {
+        int: u64,
+        bytes: []u8,
+    };
+
+    fn nextUntyped(f: *Fuzzer, uid: Uid, weights: []const abi.Weight) union(enum) {
+        copy: Untyped,
+        mutate: Untyped,
+        fresh: void,
+    } {
+        const corpus = f.corpus.slice();
+        const corpus_i = @intFromEnum(f.corpus_pos);
+        const data = &corpus.items(.data)[corpus_i];
+        var small_entronopy: SmallEntronopy = .{ .bits = f.rngInt(u64) };
+
+        const uid_i = data.uid_slices.getIndex(uid) orelse {
+            @branchHint(.unlikely);
+            return .fresh;
+        };
+        const data_slice = data.uid_slices.values()[uid_i];
+        var slice_i = f.uid_data_i.items[uid_i];
+        var data_i = data_slice.base + slice_i;
+
+        new_data: while (true) {
+            assert(slice_i == f.uid_data_i.items[uid_i] and data_i == data_slice.base + slice_i);
+            if (slice_i == data_slice.len) break :new_data;
+            assert(slice_i < data_slice.len);
+
+            f.uid_data_i.items[uid_i] += 1;
+            const mut_i = std.simd.firstIndexOfValue(
+                @as(@Vector(4, u32), f.mut_data.i),
+                data_i + @as(u32, @intCast(data.ints.len)) * @intFromEnum(uid.kind),
+            ) orelse {
+                @branchHint(.likely);
+                switch (uid.kind) {
+                    .int => {
+                        const int = data.ints[data_i];
+                        if (weightsContain(int, weights)) {
+                            @branchHint(.likely);
+                            return .{ .copy = .{ .int = int } };
+                        }
+                    },
+                    .bytes => {
+                        const entry = data.bytes.entries[data_i];
+                        const bytes = data.bytes.table[entry.off..][0..entry.len];
+                        if (weightsContainBytes(bytes, weights)) {
+                            @branchHint(.likely);
+                            return .{ .copy = .{ .bytes = bytes } };
+                        }
+                    },
+                }
+                break :new_data;
+            };
+
+            const seq = &f.mut_data.seq[mut_i];
+            new_seq: {
+                if (!seq.kind.none) break :new_seq;
+
+                var opts: packed struct(u6) {
+                    // Matches layout as `mut_data.seq.kind`
+                    insert: bool,
+                    copy: bool,
+
+                    seq: u2,
+                    delete: bool,
+                    splice: bool,
+                } = @bitCast(small_entronopy.take(u6));
+                if (opts.seq != 0) break :new_data;
+
+                const max_consume = data_slice.len - slice_i; // inclusive
+                if (opts.delete) {
+                    f.uid_data_i.items[uid_i] += f.rngLessThan(u32, max_consume);
+                    slice_i = f.uid_data_i.items[uid_i];
+                    data_i = data_slice.base + slice_i;
+                    continue;
+                }
+                opts.insert |= max_consume == 0;
+                seq.kind = .{
+                    .class = if (opts.insert) .replace else .insert,
+                    .copy = opts.copy,
+                    .ordered_mutate = false,
+                    .none = false,
+                };
+
+                if (!seq.kind.copy) {
+                    seq.len = switch (seq.kind.class) {
+                        .replace => f.rngLessThan(u32, max_consume) + 1,
+                        .insert => @clz(f.rngInt(u16)) + 1,
+                    };
+                    seq.copy = undefined;
+                } else {
+                    const src: SeqCopy, const src_len: u32 = if (!opts.splice) .{
+                        switch (uid.kind) {
+                            .int => .{ .ints = data.ints[data_slice.base..][0..data_slice.len] },
+                            .bytes => .{ .bytes = .{
+                                .entries = data.bytes.entries[data_slice.base..][0..data_slice.len],
+                                .table = data.bytes.table,
+                            } },
+                        },
+                        data_slice.len,
+                    } else src: {
+                        const seen_uid_i = corpus.items(.seen_uid_i)[corpus_i][uid_i];
+                        const untyped_slices = f.seen_uids.values()[seen_uid_i].slices;
+                        switch (uid.kind) {
+                            .int => {
+                                const slices = untyped_slices.ints.items;
+                                const i = f.rngLessThan(u32, @intCast(slices.len));
+                                break :src .{
+                                    .{ .ints = slices[i] },
+                                    @intCast(slices[i].len),
+                                };
+                            },
+                            .bytes => {
+                                const slices = untyped_slices.bytes.items;
+                                const i = f.rngLessThan(u32, @intCast(slices.len));
+                                break :src .{
+                                    .{ .bytes = slices[i] },
+                                    @intCast(slices[i].entries.len),
+                                };
+                            },
+                        }
+                    };
+
+                    const off = f.rngLessThan(u32, src_len);
+                    seq.len = f.rngLessThan(u32, src_len - off) + 1;
+                    if (seq.kind.class == .replace) seq.len = @min(seq.len, max_consume);
+                    seq.copy = switch (uid.kind) {
+                        .int => .{ .ints = src.ints[off..][0..seq.len] },
+                        .bytes => .{ .bytes = .{
+                            .entries = src.bytes.entries[off..][0..seq.len],
+                            .table = src.bytes.table,
+                        } },
+                    };
+                }
+            }
+
+            assert(!seq.kind.none);
+            f.uid_data_i.items[uid_i] -= @intFromBool(seq.kind.class == .insert);
+            seq.len -= 1;
+            seq.kind.none |= seq.len == 0;
+            f.mut_data.i[mut_i] += @intFromBool(seq.kind.class == .replace and seq.len != 0);
+
+            if (!seq.kind.copy) {
+                assert(!seq.kind.ordered_mutate);
+                break :new_data;
+            }
+            if (seq.kind.ordered_mutate) {
+                assert(seq.kind.class == .replace);
+                seq.copy.order_i += @intFromBool(seq.len != 0);
+                f.mut_data.i[mut_i] = data.order[seq.copy.order_i];
+                break :new_data;
+            }
+            switch (uid.kind) {
+                .int => {
+                    const int = seq.copy.ints[0];
+                    seq.copy.ints = seq.copy.ints[1..];
+                    if (weightsContain(int, weights)) {
+                        @branchHint(.likely);
+                        return .{ .copy = .{ .int = int } };
+                    }
+                },
+                .bytes => {
+                    const entry = seq.copy.bytes.entries[0];
+                    const bytes = seq.copy.bytes.table[entry.off..][0..entry.len];
+                    seq.copy.bytes.entries = seq.copy.bytes.entries[1..];
+                    if (weightsContainBytes(bytes, weights)) {
+                        @branchHint(.likely);
+                        return .{ .copy = .{ .bytes = bytes } };
+                    }
+                },
+            }
+            break;
+        }
+
+        const opts: packed struct(u10) {
+            copy: u2,
+            fresh: u2,
+            splice: bool,
+            local_far: bool,
+            local_off: i4,
+        } = @bitCast(small_entronopy.take(u10));
+
+        if (opts.copy != 0) {
+            if (opts.fresh == 0 or slice_i == data_slice.len) return .fresh;
+            return .{ .mutate = switch (uid.kind) {
+                .int => .{ .int = data.ints[data_i] },
+                .bytes => .{ .bytes = b: {
+                    const entry = data.bytes.entries[data_i];
+                    break :b data.bytes.table[entry.off..][0..entry.len];
+                } },
+            } };
+        }
+
+        if (!opts.splice) {
+            const src_data_i = data_slice.base + if (!opts.local_far) i: {
+                const off = opts.local_off;
+                break :i if (off >= 0) @min(
+                    f.uid_data_i.items[uid_i] +| @as(u4, @intCast(off)),
+                    data_slice.len - 1,
+                ) else f.uid_data_i.items[uid_i] -| @abs(off);
+            } else f.rngLessThan(u32, data_slice.len);
+            switch (uid.kind) {
+                .int => {
+                    const int = data.ints[src_data_i];
+                    if (weightsContain(int, weights)) {
+                        @branchHint(.likely);
+                        return .{ .copy = .{ .int = int } };
+                    }
+                },
+                .bytes => {
+                    const entry = data.bytes.entries[src_data_i];
+                    const bytes = data.bytes.table[entry.off..][0..entry.len];
+                    if (weightsContainBytes(bytes, weights)) {
+                        @branchHint(.likely);
+                        return .{ .copy = .{ .bytes = bytes } };
+                    }
+                },
+            }
+        } else {
+            const seen_uid_i = corpus.items(.seen_uid_i)[corpus_i][uid_i];
+            const untyped_slices = f.seen_uids.values()[seen_uid_i].slices;
+            switch (uid.kind) {
+                .int => {
+                    const slices = untyped_slices.ints.items;
+                    const from = slices[f.rngLessThan(u32, @intCast(slices.len))];
+                    const int = from[f.rngLessThan(u32, @intCast(from.len))];
+                    if (weightsContain(int, weights)) {
+                        @branchHint(.likely);
+                        return .{ .copy = .{ .int = int } };
+                    }
+                },
+                .bytes => {
+                    const slices = untyped_slices.bytes.items;
+                    const from = slices[f.rngLessThan(u32, @intCast(slices.len))];
+                    const entry_i = f.rngLessThan(u32, @intCast(from.entries.len));
+                    const entry = from.entries[entry_i];
+                    const bytes = from.table[entry.off..][0..entry.len];
+                    if (weightsContainBytes(bytes, weights)) {
+                        @branchHint(.likely);
+                        return .{ .copy = .{ .bytes = bytes } };
+                    }
+                },
+            }
+        }
+        return .fresh;
+    }
+
+    pub fn nextInt(f: *Fuzzer, uid: Uid, weights: []const abi.Weight) u64 {
+        f.req_values += 1;
+        if (@intFromEnum(f.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) {
+            @branchHint(.unlikely);
+            const int = f.bytes_input.valueWeightedWithHash(u64, weights, undefined);
+            if (f.corpus_pos == .bytes_fresh) {
+                f.input_builder.checkSmithedLen(8);
+                f.input_builder.addInt(uid, int);
             }
+            return int;
+        }
+        const int = f.nextIntInner(uid, weights);
+        f.mmap_input.appendLittleInt(u64, int);
+        return int;
+    }
+
+    fn nextIntInner(f: *Fuzzer, uid: Uid, weights: []const abi.Weight) u64 {
+        return switch (f.nextUntyped(uid, weights)) {
+            .copy => |u| u.int,
+            .mutate, .fresh => f.weightedValue(weights, sumWeightsInclusive(weights)),
+        };
+    }
+
+    pub fn nextEos(f: *Fuzzer, uid: Uid, weights: []const abi.Weight) bool {
+        f.req_values += 1;
+        if (@intFromEnum(f.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) {
+            @branchHint(.unlikely);
+            const eos = f.bytes_input.eosWeightedWithHash(weights, undefined);
+            if (f.corpus_pos == .bytes_fresh) {
+                f.input_builder.checkSmithedLen(1);
+                f.input_builder.addInt(uid, @intFromBool(eos));
+            }
+            return eos;
+        }
+        // `nextIntInner` is already gauraunteed to eventually return `1`
+        const eos = @as(u1, @intCast(f.nextIntInner(uid, weights))) != 0;
+        f.mmap_input.appendLittleInt(u8, @intFromBool(eos));
+        return eos;
+    }
 
-            const arena = self.arena_ctx.allocator();
-            const bytes = arena.dupe(u8, @volatileCast(self.input.items[8..])) catch @panic("OOM");
+    fn mutateBytes(f: *Fuzzer, in: []u8, out: []u8, weights: []const abi.Weight) void {
+        assert(in.len != 0);
+        const weights_incl_sum = sumWeightsInclusive(weights);
 
-            self.corpus.append(gpa, bytes) catch @panic("OOM");
-            self.mutations.appendNTimes(gpa, m, 6) catch @panic("OOM");
+        var small_entronopy: SmallEntronopy = .{ .bits = f.rngInt(u64) };
+        var muts = mutCount(small_entronopy.take(u16));
+        var rem_out = out;
+        var rem_copy = in;
+        while (rem_out.len != 0 and muts != 0) {
+            muts -= 1;
+            const opts: packed struct(u4) {
+                kind: enum(u2) {
+                    random,
+                    stream_copy,
+                    stream_discard,
+                    absolute_copy,
+                },
+                small: u2,
 
-            // Write new corpus to cache
-            var name_buf: [@sizeOf(usize) * 2]u8 = undefined;
-            self.corpus_dir.writeFile(io, .{
-                .sub_path = std.fmt.bufPrint(&name_buf, "{x}", .{self.corpus_dir_idx}) catch unreachable,
-                .data = bytes,
-            }) catch |e| panic("failed to write corpus file '{x}': {t}", .{ self.corpus_dir_idx, e });
-            self.corpus_dir_idx += 1;
+                pub fn limitSmall(o: @This(), n: usize) u32 {
+                    return @min(
+                        @as(u32, @intCast(n)),
+                        @as(u32, if (o.small != 0) 8 else math.maxInt(u32)),
+                    );
+                }
+            } = @bitCast(small_entronopy.take(u4));
+            s: switch (opts.kind) {
+                .random => {
+                    const n = f.rngLessThan(u32, opts.limitSmall(rem_out.len)) + 1;
+                    for (rem_out[0..n]) |*o| {
+                        o.* = @intCast(f.weightedValue(weights, weights_incl_sum));
+                    }
+                    rem_out = rem_out[n..];
+                },
+                .stream_copy => {
+                    if (rem_copy.len == 0) continue :s .random;
+                    const n = @min(
+                        f.rngLessThan(u32, opts.limitSmall(rem_copy.len)) + 1,
+                        rem_out.len,
+                    );
+                    @memcpy(rem_out[0..n], rem_copy[0..n]);
+                    rem_out = rem_out[n..];
+                    rem_copy = rem_copy[n..];
+                },
+                .stream_discard => {
+                    if (rem_copy.len == 0) continue :s .random;
+                    const n = f.rngLessThan(u32, opts.limitSmall(rem_copy.len)) + 1;
+                    rem_copy = rem_copy[n..];
+                },
+                .absolute_copy => {
+                    const in_len: u32 = @intCast(in.len);
+                    const off = f.rngLessThan(u32, in_len);
+                    const len = @min(
+                        f.rngLessThan(u32, in_len - off) + 1,
+                        opts.limitSmall(rem_out.len),
+                    );
+                    @memcpy(rem_out[0..len], in[off..][0..len]);
+                    rem_out = rem_out[len..];
+                },
+            }
         }
+
+        const copy = @min(rem_out.len, rem_copy.len);
+        @memcpy(rem_out[0..copy], rem_copy[0..copy]);
+        for (rem_out[copy..]) |*o| {
+            o.* = @intCast(f.weightedValue(weights, weights_incl_sum));
+        }
+    }
+
+    fn nextBytesInner(f: *Fuzzer, uid: Uid, out: []u8, weights: []const abi.Weight) void {
+        so: switch (f.nextUntyped(uid, weights)) {
+            .copy => |u| {
+                if (u.bytes.len >= out.len) {
+                    @branchHint(.likely);
+                    @memcpy(out, u.bytes[0..out.len]);
+                    return;
+                }
+
+                @memcpy(out[0..u.bytes.len], u.bytes);
+                const weights_incl_sum = sumWeightsInclusive(weights);
+                for (out[u.bytes.len..]) |*o| {
+                    o.* = @intCast(f.weightedValue(weights, weights_incl_sum));
+                }
+            },
+            .mutate => |u| {
+                if (u.bytes.len == 0) continue :so .fresh;
+                f.mutateBytes(u.bytes, out, weights);
+            },
+            .fresh => {
+                const weights_incl_sum = sumWeightsInclusive(weights);
+                for (out) |*o| {
+                    o.* = @intCast(f.weightedValue(weights, weights_incl_sum));
+                }
+            },
+        }
+    }
+
+    pub fn nextBytes(f: *Fuzzer, uid: Uid, out: []u8, weights: []const abi.Weight) void {
+        f.req_values += 1;
+        f.req_bytes +%= @truncate(out.len); // This function should panic since the 32-bit
+        // data limit is exceeded, so wrapping is fine.
+        if (@intFromEnum(f.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) {
+            @branchHint(.unlikely);
+            f.bytes_input.bytesWeightedWithHash(out, weights, undefined);
+            if (f.corpus_pos == .bytes_fresh) {
+                f.input_builder.checkSmithedLen(out.len);
+                f.input_builder.addBytes(uid, out);
+            }
+            return;
+        }
+
+        f.nextBytesInner(uid, out, weights);
+        f.mmap_input.appendSlice(out);
+    }
+
+    fn nextSliceInner(
+        f: *Fuzzer,
+        uid: Uid,
+        buf: []u8,
+        len_weights: []const abi.Weight,
+        byte_weights: []const abi.Weight,
+    ) u32 {
+        so: switch (f.nextUntyped(uid, byte_weights)) {
+            .copy => |u| {
+                var len: u32 = @intCast(u.bytes.len);
+                if (!weightsContain(len, len_weights)) {
+                    @branchHint(.unlikely);
+                    len = @intCast(f.weightedValue(len_weights, sumWeightsInclusive(len_weights)));
+                }
+
+                if (u.bytes.len >= len) {
+                    @branchHint(.likely);
+                    @memcpy(buf[0..len], u.bytes[0..len]);
+                    return len;
+                }
+
+                @memcpy(buf[0..u.bytes.len], u.bytes);
+                const weights_incl_sum = sumWeightsInclusive(byte_weights);
+                for (buf[u.bytes.len..len]) |*o| {
+                    o.* = @intCast(f.weightedValue(byte_weights, weights_incl_sum));
+                }
+                return len;
+            },
+            .mutate => |u| {
+                if (u.bytes.len == 0) continue :so .fresh;
+                const len: u32 = len: {
+                    const offseted: packed struct {
+                        is: u3,
+                        sub: bool,
+                        by: u3,
+                    } = @bitCast(f.rngInt(u7));
+                    if (offseted.is != 0) {
+                        const len = if (offseted.sub)
+                            @as(u32, @intCast(u.bytes.len)) -| offseted.by
+                        else
+                            @min(u.bytes.len + offseted.by, @as(u32, @intCast(buf.len)));
+                        if (weightsContain(len, len_weights)) {
+                            break :len len;
+                        }
+                    }
+                    break :len @intCast(f.weightedValue(
+                        len_weights,
+                        sumWeightsInclusive(len_weights),
+                    ));
+                };
+                f.mutateBytes(u.bytes, buf[0..len], byte_weights);
+                return len;
+            },
+            .fresh => {
+                const len: u32 = @intCast(f.weightedValue(
+                    len_weights,
+                    sumWeightsInclusive(len_weights),
+                ));
+                const weights_incl_sum = sumWeightsInclusive(byte_weights);
+                for (buf[0..len]) |*o| {
+                    o.* = @intCast(f.weightedValue(byte_weights, weights_incl_sum));
+                }
+                return len;
+            },
+        }
+    }
+
+    pub fn nextSlice(
+        f: *Fuzzer,
+        uid: Uid,
+        buf: []u8,
+        len_weights: []const abi.Weight,
+        byte_weights: []const abi.Weight,
+    ) u32 {
+        f.req_values += 1;
+        if (@intFromEnum(f.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) {
+            @branchHint(.unlikely);
+            const n = f.bytes_input.sliceWeightedWithHash(
+                buf,
+                len_weights,
+                byte_weights,
+                undefined,
+            );
+            if (f.corpus_pos == .bytes_fresh) {
+                f.input_builder.checkSmithedLen(@as(usize, 4) + n);
+                f.input_builder.addBytes(uid, buf[0..n]);
+            }
+            return n;
+        }
+
+        const n = f.nextSliceInner(uid, buf, len_weights, byte_weights);
+        f.mmap_input.appendLittleInt(u32, n);
+        f.mmap_input.appendSlice(buf[0..n]);
+        f.req_bytes += n;
+        return n;
     }
 };
 
-/// Instrumentation must not be triggered before this function is called
 export fn fuzzer_init(cache_dir_path: abi.Slice) void {
-    inst.depreinit();
     exec = .init(cache_dir_path.toSlice());
-    inst = .init();
+    fuzzer = .init();
 }
 
-/// Invalid until `fuzzer_init` is called.
 export fn fuzzer_coverage() abi.Coverage {
     const coverage_id = exec.pc_digest;
-    const header: *const abi.SeenPcsHeader = @ptrCast(@volatileCast(exec.shared_seen_pcs.items.ptr));
+    const header = @volatileCast(exec.seenPcsHeader());
 
     var seen_count: usize = 0;
     for (header.seenBits()) |chunk| {
@@ -608,32 +1658,56 @@ export fn fuzzer_coverage() abi.Coverage {
     };
 }
 
-/// fuzzer_init must be called beforehand
-export fn fuzzer_init_test(test_one: abi.TestOne, unit_test_name: abi.Slice) void {
+export fn fuzzer_set_test(test_one: abi.TestOne, unit_test_name: abi.Slice) void {
     current_test_name = unit_test_name.toSlice();
-    fuzzer = .init(test_one, unit_test_name.toSlice());
+    fuzzer.setTest(test_one, unit_test_name.toSlice());
 }
 
-/// fuzzer_init_test must be called beforehand
-/// The callee owns the memory of bytes and must not free it until the fuzzer is finished.
 export fn fuzzer_new_input(bytes: abi.Slice) void {
-    // An entry of length zero is always added and duplicates of it are not allowed.
-    if (bytes.len != 0)
-        fuzzer.addInput(bytes.toSlice());
+    if (bytes.len == 0) return; // An entry of length zero is always present
+    fuzzer.newInput(bytes.toSlice(), false);
 }
 
-/// fuzzer_init_test must be called first
 export fn fuzzer_main(limit_kind: abi.LimitKind, amount: u64) void {
+    fuzzer.loadCorpus();
     switch (limit_kind) {
         .forever => while (true) fuzzer.cycle(),
         .iterations => for (0..amount) |_| fuzzer.cycle(),
     }
+    fuzzer.reset();
+}
+
+export fn fuzzer_int(uid: Uid, weights: abi.Weights) u64 {
+    assert(uid.kind == .int);
+    return fuzzer.nextInt(uid, weights.toSlice());
+}
+
+export fn fuzzer_eos(uid: Uid, weights: abi.Weights) bool {
+    assert(uid.kind == .int);
+    return fuzzer.nextEos(uid, weights.toSlice());
+}
+
+export fn fuzzer_bytes(uid: Uid, out: abi.MutSlice, weights: abi.Weights) void {
+    assert(uid.kind == .bytes);
+    return fuzzer.nextBytes(uid, out.toSlice(), weights.toSlice());
+}
+
+export fn fuzzer_slice(
+    uid: Uid,
+    buf: abi.MutSlice,
+    len_weights: abi.Weights,
+    byte_weights: abi.Weights,
+) u32 {
+    assert(uid.kind == .bytes);
+    return fuzzer.nextSlice(uid, buf.toSlice(), len_weights.toSlice(), byte_weights.toSlice());
 }
 
 export fn fuzzer_unslide_address(addr: usize) usize {
     const si = std.debug.getSelfDebugInfo() catch @compileError("unsupported");
     const slide = si.getModuleSlide(io, addr) catch |err| {
-        std.debug.panic("failed to find virtual address slide: {t}", .{err});
+        // The LLVM backend seems to insert placeholder values of `1` in __sancov_pcs1
+        if (addr == 1) return 1;
+        panic("failed to find virtual address slide for address 0x{x}: {t}", .{ addr, err });
     };
     return addr - slide;
 }
@@ -642,74 +1716,6 @@ export fn fuzzer_unslide_address(addr: usize) usize {
 /// Currently not used by the fuzzer.
 export threadlocal var __sancov_lowest_stack: usize = 0;
 
-/// Inline since the return address of the callee is required
-inline fn genericConstCmp(T: anytype, val: T, comptime const_vals_field: []const u8) void {
-    if (!inst.constPcSeen(@returnAddress())) {
-        @branchHint(.unlikely);
-        @field(inst, const_vals_field).append(gpa, val) catch @panic("OOM");
-    }
-}
-
-export fn __sanitizer_cov_trace_const_cmp1(const_arg: u8, arg: u8) void {
-    _ = const_arg;
-    _ = arg;
-}
-
-export fn __sanitizer_cov_trace_const_cmp2(const_arg: u16, arg: u16) void {
-    _ = arg;
-    genericConstCmp(u16, const_arg, "const_vals2");
-}
-
-export fn __sanitizer_cov_trace_const_cmp4(const_arg: u32, arg: u32) void {
-    _ = arg;
-    genericConstCmp(u32, const_arg, "const_vals4");
-}
-
-export fn __sanitizer_cov_trace_const_cmp8(const_arg: u64, arg: u64) void {
-    _ = arg;
-    genericConstCmp(u64, const_arg, "const_vals8");
-}
-
-export fn __sanitizer_cov_trace_switch(val: u64, cases: [*]const u64) void {
-    _ = val;
-    if (!inst.constPcSeen(@returnAddress())) {
-        @branchHint(.unlikely);
-        const case_bits = cases[1];
-        const cases_slice = cases[2..][0..cases[0]];
-        switch (case_bits) {
-            // 8-bit cases are ignored because they are likely to be randomly generated
-            0...8 => {},
-            9...16 => for (cases_slice) |c|
-                inst.const_vals2.append(gpa, @truncate(c)) catch @panic("OOM"),
-            17...32 => for (cases_slice) |c|
-                inst.const_vals4.append(gpa, @truncate(c)) catch @panic("OOM"),
-            33...64 => for (cases_slice) |c|
-                inst.const_vals8.append(gpa, @truncate(c)) catch @panic("OOM"),
-            else => {}, // Should be impossible
-        }
-    }
-}
-
-export fn __sanitizer_cov_trace_cmp1(arg1: u8, arg2: u8) void {
-    _ = arg1;
-    _ = arg2;
-}
-
-export fn __sanitizer_cov_trace_cmp2(arg1: u16, arg2: u16) void {
-    _ = arg1;
-    _ = arg2;
-}
-
-export fn __sanitizer_cov_trace_cmp4(arg1: u32, arg2: u32) void {
-    _ = arg1;
-    _ = arg2;
-}
-
-export fn __sanitizer_cov_trace_cmp8(arg1: u64, arg2: u64) void {
-    _ = arg1;
-    _ = arg2;
-}
-
 export fn __sanitizer_cov_trace_pc_indir(callee: usize) void {
     // Not valuable because we already have pc tracing via 8bit counters.
     _ = callee;
@@ -729,723 +1735,117 @@ export fn __sanitizer_cov_pcs_init(start: usize, end: usize) void {
     _ = end;
 }
 
-/// Copy all of source into dest at position 0.
-/// If the slices overlap, dest.ptr must be <= src.ptr.
-fn volatileCopyForwards(comptime T: type, dest: []volatile T, source: []const volatile T) void {
-    for (dest, source) |*d, s| d.* = s;
-}
-
-/// Copy all of source into dest at position 0.
-/// If the slices overlap, dest.ptr must be >= src.ptr.
-fn volatileCopyBackwards(comptime T: type, dest: []volatile T, source: []const volatile T) void {
-    var i = source.len;
-    while (i > 0) {
-        i -= 1;
-        dest[i] = source[i];
-    }
-}
-
-const Mutation = enum {
-    /// Applies .insert_*_span, .push_*_span
-    /// For wtf-8, this limits code units, not code points
-    const max_insert_len = 12;
-    /// Applies to .insert_large_*_span and .push_large_*_span
-    /// 4096 is used as it is a common sector size
-    const max_large_insert_len = 4096;
-    /// Applies to .delete_span and .pop_span
-    const max_delete_len = 16;
-    /// Applies to .set_*span, .move_span, .set_existing_span
-    const max_set_len = 12;
-    const max_replicate_len = 64;
-    const AddValue = i6;
-    const SmallValue = i10;
-
-    delete_byte,
-    delete_span,
-    /// Removes the last byte from the input
-    pop_byte,
-    pop_span,
-    /// Inserts a group of bytes which is already in the input and removes the original copy.
-    move_span,
-    /// Replaces a group of bytes in the input with another group of bytes in the input
-    set_existing_span,
-    insert_existing_span,
-    push_existing_span,
-    set_rng_byte,
-    set_rng_span,
-    insert_rng_byte,
-    insert_rng_span,
-    /// Adds a byte to the end of the input
-    push_rng_byte,
-    push_rng_span,
-    set_zero_byte,
-    set_zero_span,
-    insert_zero_byte,
-    insert_zero_span,
-    push_zero_byte,
-    push_zero_span,
-    /// Inserts a lot of zeros to the end of the input
-    /// This is intended to work with fuzz tests that require data in (large) blocks
-    push_large_zero_span,
-    /// Inserts a group of ascii printable character
-    insert_print_span,
-    /// Inserts a group of character from a...z, A...Z, 0...9, _, and ' '
-    insert_common_span,
-    /// Inserts a group of ascii digits possibly preceded by a `-`
-    insert_integer,
-    /// Code units are evenly distributed between one to four
-    insert_wtf8_char,
-    insert_wtf8_span,
-    /// Inserts a group of bytes from another input
-    insert_splice_span,
-    // utf16 is not yet included since insertion of random bytes should adaquetly check
-    // BMP character, surrogate handling, and occasionally chacters outside of the BMP.
-    set_print_span,
-    set_common_span,
-    set_splice_span,
-    /// Similar to set_splice_span, but the bytes are copied to the same index instead of a random
-    replicate_splice_span,
-    push_print_span,
-    push_common_span,
-    push_integer,
-    push_wtf8_char,
-    push_wtf8_span,
-    push_splice_span,
-    /// Clears a random amount of high bits of a byte
-    truncate_8,
-    truncate_16le,
-    truncate_16be,
-    truncate_32le,
-    truncate_32be,
-    truncate_64le,
-    truncate_64be,
-    /// Flips a random bit
-    xor_1,
-    /// Swaps up to three bits of a byte biased to less bits
-    xor_few_8,
-    /// Swaps up to six bits of a 16-bit value biased to less bits
-    xor_few_16,
-    /// Swaps up to nine bits of a 32-bit value biased to less bits
-    xor_few_32,
-    /// Swaps up to twelve bits of 64-bit value biased to less bits
-    xor_few_64,
-    /// Adds to a byte a value of type AddValue
-    add_8,
-    add_16le,
-    add_16be,
-    add_32le,
-    add_32be,
-    add_64le,
-    add_64be,
-    /// Sets a 16-bit little-endian value to a value of type SmallValue
-    set_small_16le,
-    set_small_16be,
-    set_small_32le,
-    set_small_32be,
-    set_small_64le,
-    set_small_64be,
-    insert_small_16le,
-    insert_small_16be,
-    insert_small_32le,
-    insert_small_32be,
-    insert_small_64le,
-    insert_small_64be,
-    push_small_16le,
-    push_small_16be,
-    push_small_32le,
-    push_small_32be,
-    push_small_64le,
-    push_small_64be,
-    set_const_16,
-    set_const_32,
-    set_const_64,
-    set_const_128,
-    insert_const_16,
-    insert_const_32,
-    insert_const_64,
-    insert_const_128,
-    push_const_16,
-    push_const_32,
-    push_const_64,
-    push_const_128,
-    /// Sets a byte with up to three bits set biased to less bits
-    set_few_8,
-    /// Sets a 16-bit value with up to six bits set biased to less bits
-    set_few_16,
-    /// Sets a 32-bit value with up to nine bits set biased to less bits
-    set_few_32,
-    /// Sets a 64-bit value with up to twelve bits set biased to less bits
-    set_few_64,
-    insert_few_8,
-    insert_few_16,
-    insert_few_32,
-    insert_few_64,
-    push_few_8,
-    push_few_16,
-    push_few_32,
-    push_few_64,
-    /// Randomizes a random contigous group of bits in a byte
-    packed_set_rng_8,
-    packed_set_rng_16le,
-    packed_set_rng_16be,
-    packed_set_rng_32le,
-    packed_set_rng_32be,
-    packed_set_rng_64le,
-    packed_set_rng_64be,
-
-    fn fewValue(rng: std.Random, T: type, comptime bits: u16) T {
-        var result: T = 0;
-        var remaining_bits = rng.intRangeAtMostBiased(u16, 1, bits);
-        while (remaining_bits > 0) {
-            result |= @shlExact(@as(T, 1), rng.int(math.Log2Int(T)));
-            remaining_bits -= 1;
-        }
-        return result;
-    }
-
-    /// Returns if the mutation was applicable to the input
-    pub fn mutate(
-        mutation: Mutation,
-        rng: std.Random,
-        in: []const u8,
-        out: *MemoryMappedList,
-        corpus: []const []const u8,
-        const_vals2: []const u16,
-        const_vals4: []const u32,
-        const_vals8: []const u64,
-        const_vals16: []const u128,
-    ) bool {
-        out.clearRetainingCapacity();
-        const new_capacity = 8 + in.len + @max(
-            16, // builtin 128 value
-            Mutation.max_insert_len,
-            Mutation.max_large_insert_len,
-        );
-        out.ensureTotalCapacity(new_capacity) catch |e|
-            panic("could not resize shared input file: {t}", .{e});
-        out.items.len = 8; // Length field
-
-        const applied = switch (mutation) {
-            inline else => |m| m.comptimeMutate(
-                rng,
-                in,
-                out,
-                corpus,
-                const_vals2,
-                const_vals4,
-                const_vals8,
-                const_vals16,
-            ),
-        };
-        if (!applied)
-            assert(out.items.len == 8)
-        else
-            assert(out.items.len <= new_capacity);
-        return applied;
-    }
-
-    /// Assumes out has already been cleared
-    fn comptimeMutate(
-        comptime mutation: Mutation,
-        rng: std.Random,
-        in: []const u8,
-        out: *MemoryMappedList,
-        corpus: []const []const u8,
-        const_vals2: []const u16,
-        const_vals4: []const u32,
-        const_vals8: []const u64,
-        const_vals16: []const u128,
-    ) bool {
-        const Class = enum { new, remove, rmw, move_span, replicate_splice_span };
-        const class: Class, const class_ctx = switch (mutation) {
-            // zig fmt: off
-            .move_span => .{ .move_span, null },
-            .replicate_splice_span => .{ .replicate_splice_span, null },
-
-            .delete_byte => .{ .remove, .{ .delete, 1 } },
-            .delete_span => .{ .remove, .{ .delete, max_delete_len } },
-
-            .pop_byte => .{ .remove, .{ .pop, 1 } },
-            .pop_span => .{ .remove, .{ .pop, max_delete_len } },
-
-            .set_rng_byte         => .{ .new, .{ .set   ,  1, .rng     , .one              } },
-            .set_zero_byte        => .{ .new, .{ .set   ,  1, .zero    , .one              } },
-            .set_rng_span         => .{ .new, .{ .set   ,  1, .rng     , .many             } },
-            .set_zero_span        => .{ .new, .{ .set   ,  1, .zero    , .many             } },
-            .set_common_span      => .{ .new, .{ .set   ,  1, .common  , .many             } },
-            .set_print_span       => .{ .new, .{ .set   ,  1, .print   , .many             } },
-            .set_existing_span    => .{ .new, .{ .set   ,  2, .existing, .many             } },
-            .set_splice_span      => .{ .new, .{ .set   ,  1, .splice  , .many             } },
-            .set_const_16         => .{ .new, .{ .set   ,  2, .@"const", const_vals2       } },
-            .set_const_32         => .{ .new, .{ .set   ,  4, .@"const", const_vals4       } },
-            .set_const_64         => .{ .new, .{ .set   ,  8, .@"const", const_vals8       } },
-            .set_const_128        => .{ .new, .{ .set   , 16, .@"const", const_vals16      } },
-            .set_small_16le       => .{ .new, .{ .set   ,  2, .small   , .{ i16, .little } } },
-            .set_small_32le       => .{ .new, .{ .set   ,  4, .small   , .{ i32, .little } } },
-            .set_small_64le       => .{ .new, .{ .set   ,  8, .small   , .{ i64, .little } } },
-            .set_small_16be       => .{ .new, .{ .set   ,  2, .small   , .{ i16, .big    } } },
-            .set_small_32be       => .{ .new, .{ .set   ,  4, .small   , .{ i32, .big    } } },
-            .set_small_64be       => .{ .new, .{ .set   ,  8, .small   , .{ i64, .big    } } },
-            .set_few_8            => .{ .new, .{ .set   ,  1, .few     , .{ u8 , 3  }      } },
-            .set_few_16           => .{ .new, .{ .set   ,  2, .few     , .{ u16, 6  }      } },
-            .set_few_32           => .{ .new, .{ .set   ,  4, .few     , .{ u32, 9  }      } },
-            .set_few_64           => .{ .new, .{ .set   ,  8, .few     , .{ u64, 12 }      } },
-
-            .insert_rng_byte      => .{ .new, .{ .insert,  0, .rng     , .one              } },
-            .insert_zero_byte     => .{ .new, .{ .insert,  0, .zero    , .one              } },
-            .insert_rng_span      => .{ .new, .{ .insert,  0, .rng     , .many             } },
-            .insert_zero_span     => .{ .new, .{ .insert,  0, .zero    , .many             } },
-            .insert_print_span    => .{ .new, .{ .insert,  0, .print   , .many             } },
-            .insert_common_span   => .{ .new, .{ .insert,  0, .common  , .many             } },
-            .insert_integer       => .{ .new, .{ .insert,  0, .integer , .many             } },
-            .insert_wtf8_char     => .{ .new, .{ .insert,  0, .wtf8    , .one              } },
-            .insert_wtf8_span     => .{ .new, .{ .insert,  0, .wtf8    , .many             } },
-            .insert_existing_span => .{ .new, .{ .insert,  1, .existing, .many             } },
-            .insert_splice_span   => .{ .new, .{ .insert,  0, .splice  , .many             } },
-            .insert_const_16      => .{ .new, .{ .insert,  0, .@"const", const_vals2       } },
-            .insert_const_32      => .{ .new, .{ .insert,  0, .@"const", const_vals4       } },
-            .insert_const_64      => .{ .new, .{ .insert,  0, .@"const", const_vals8       } },
-            .insert_const_128     => .{ .new, .{ .insert,  0, .@"const", const_vals16      } },
-            .insert_small_16le    => .{ .new, .{ .insert,  0, .small   , .{ i16, .little } } },
-            .insert_small_32le    => .{ .new, .{ .insert,  0, .small   , .{ i32, .little } } },
-            .insert_small_64le    => .{ .new, .{ .insert,  0, .small   , .{ i64, .little } } },
-            .insert_small_16be    => .{ .new, .{ .insert,  0, .small   , .{ i16, .big    } } },
-            .insert_small_32be    => .{ .new, .{ .insert,  0, .small   , .{ i32, .big    } } },
-            .insert_small_64be    => .{ .new, .{ .insert,  0, .small   , .{ i64, .big    } } },
-            .insert_few_8         => .{ .new, .{ .insert,  0, .few     , .{ u8 , 3  }      } },
-            .insert_few_16        => .{ .new, .{ .insert,  0, .few     , .{ u16, 6  }      } },
-            .insert_few_32        => .{ .new, .{ .insert,  0, .few     , .{ u32, 9  }      } },
-            .insert_few_64        => .{ .new, .{ .insert,  0, .few     , .{ u64, 12 }      } },
-
-            .push_rng_byte        => .{ .new, .{ .push  ,  0, .rng     , .one              } },
-            .push_zero_byte       => .{ .new, .{ .push  ,  0, .zero    , .one              } },
-            .push_rng_span        => .{ .new, .{ .push  ,  0, .rng     , .many             } },
-            .push_zero_span       => .{ .new, .{ .push  ,  0, .zero    , .many             } },
-            .push_print_span      => .{ .new, .{ .push  ,  0, .print   , .many             } },
-            .push_common_span     => .{ .new, .{ .push  ,  0, .common  , .many             } },
-            .push_integer         => .{ .new, .{ .push  ,  0, .integer , .many             } },
-            .push_large_zero_span => .{ .new, .{ .push  ,  0, .zero    , .large            } },
-            .push_wtf8_char       => .{ .new, .{ .push  ,  0, .wtf8    , .one              } },
-            .push_wtf8_span       => .{ .new, .{ .push  ,  0, .wtf8    , .many             } },
-            .push_existing_span   => .{ .new, .{ .push  ,  1, .existing, .many             } },
-            .push_splice_span     => .{ .new, .{ .push  ,  0, .splice  , .many             } },
-            .push_const_16        => .{ .new, .{ .push  ,  0, .@"const", const_vals2       } },
-            .push_const_32        => .{ .new, .{ .push  ,  0, .@"const", const_vals4       } },
-            .push_const_64        => .{ .new, .{ .push  ,  0, .@"const", const_vals8       } },
-            .push_const_128       => .{ .new, .{ .push  ,  0, .@"const", const_vals16      } },
-            .push_small_16le      => .{ .new, .{ .push  ,  0, .small   , .{ i16, .little } } },
-            .push_small_32le      => .{ .new, .{ .push  ,  0, .small   , .{ i32, .little } } },
-            .push_small_64le      => .{ .new, .{ .push  ,  0, .small   , .{ i64, .little } } },
-            .push_small_16be      => .{ .new, .{ .push  ,  0, .small   , .{ i16, .big    } } },
-            .push_small_32be      => .{ .new, .{ .push  ,  0, .small   , .{ i32, .big    } } },
-            .push_small_64be      => .{ .new, .{ .push  ,  0, .small   , .{ i64, .big    } } },
-            .push_few_8           => .{ .new, .{ .push  ,  0, .few     , .{ u8 , 3  }      } },
-            .push_few_16          => .{ .new, .{ .push  ,  0, .few     , .{ u16, 6  }      } },
-            .push_few_32          => .{ .new, .{ .push  ,  0, .few     , .{ u32, 9  }      } },
-            .push_few_64          => .{ .new, .{ .push  ,  0, .few     , .{ u64, 12 }      } },
-
-            .xor_1               => .{ .rmw, .{ .xor       , u8 , native_endian, 1  } },
-            .xor_few_8           => .{ .rmw, .{ .xor       , u8 , native_endian, 3  } },
-            .xor_few_16          => .{ .rmw, .{ .xor       , u16, native_endian, 6  } },
-            .xor_few_32          => .{ .rmw, .{ .xor       , u32, native_endian, 9  } },
-            .xor_few_64          => .{ .rmw, .{ .xor       , u64, native_endian, 12 } },
-
-            .truncate_8          => .{ .rmw, .{ .truncate  , u8 , native_endian, {} } },
-            .truncate_16le       => .{ .rmw, .{ .truncate  , u16, .little      , {} } },
-            .truncate_32le       => .{ .rmw, .{ .truncate  , u32, .little      , {} } },
-            .truncate_64le       => .{ .rmw, .{ .truncate  , u64, .little      , {} } },
-            .truncate_16be       => .{ .rmw, .{ .truncate  , u16, .big         , {} } },
-            .truncate_32be       => .{ .rmw, .{ .truncate  , u32, .big         , {} } },
-            .truncate_64be       => .{ .rmw, .{ .truncate  , u64, .big         , {} } },
-
-            .add_8               => .{ .rmw, .{ .add       , i8 , native_endian, {} } },
-            .add_16le            => .{ .rmw, .{ .add       , i16, .little      , {} } },
-            .add_32le            => .{ .rmw, .{ .add       , i32, .little      , {} } },
-            .add_64le            => .{ .rmw, .{ .add       , i64, .little      , {} } },
-            .add_16be            => .{ .rmw, .{ .add       , i16, .big         , {} } },
-            .add_32be            => .{ .rmw, .{ .add       , i32, .big         , {} } },
-            .add_64be            => .{ .rmw, .{ .add       , i64, .big         , {} } },
-
-            .packed_set_rng_8    => .{ .rmw, .{ .packed_rng, u8 , native_endian, {} } },
-            .packed_set_rng_16le => .{ .rmw, .{ .packed_rng, u16, .little      , {} } },
-            .packed_set_rng_32le => .{ .rmw, .{ .packed_rng, u32, .little      , {} } },
-            .packed_set_rng_64le => .{ .rmw, .{ .packed_rng, u64, .little      , {} } },
-            .packed_set_rng_16be => .{ .rmw, .{ .packed_rng, u16, .big         , {} } },
-            .packed_set_rng_32be => .{ .rmw, .{ .packed_rng, u32, .big         , {} } },
-            .packed_set_rng_64be => .{ .rmw, .{ .packed_rng, u64, .big         , {} } },
-            // zig fmt: on
-        };
-
-        switch (class) {
-            .new => {
-                const op: enum {
-                    set,
-                    insert,
-                    push,
-
-                    pub fn maxLen(comptime op: @This(), in_len: usize) usize {
-                        return switch (op) {
-                            .set => @min(in_len, max_set_len),
-                            .insert, .push => max_insert_len,
-                        };
-                    }
-                }, const min_in_len, const data: enum {
-                    rng,
-                    zero,
-                    common,
-                    print,
-                    integer,
-                    wtf8,
-                    existing,
-                    splice,
-                    @"const",
-                    small,
-                    few,
-                }, const data_ctx = class_ctx;
-                const Size = enum { one, many, large };
-                if (in.len < min_in_len) return false;
-                if (data == .@"const" and data_ctx.len == 0) return false;
-
-                const splice_i = if (data == .splice) blk: {
-                    // Element zero always holds an empty input, so we do not select it
-                    if (corpus.len == 1) return false;
-                    break :blk rng.intRangeLessThanBiased(usize, 1, corpus.len);
-                } else undefined;
-
-                // Only needs to be followed for set
-                const len = switch (data) {
-                    else => switch (@as(Size, data_ctx)) {
-                        .one => 1,
-                        .many => rng.intRangeAtMostBiased(usize, 1, op.maxLen(in.len)),
-                        .large => rng.intRangeAtMostBiased(usize, 1, max_large_insert_len),
-                    },
-                    .wtf8 => undefined, // varies by size of each code unit
-                    .splice => rng.intRangeAtMostBiased(usize, 1, @min(
-                        corpus[splice_i].len,
-                        op.maxLen(in.len),
-                    )),
-                    .existing => rng.intRangeAtMostBiased(usize, 1, @min(
-                        in.len,
-                        op.maxLen(in.len),
-                    )),
-                    .@"const" => @sizeOf(@typeInfo(@TypeOf(data_ctx)).pointer.child),
-                    .small, .few => @sizeOf(data_ctx[0]),
-                };
-
-                const i = switch (op) {
-                    .set => rng.uintAtMostBiased(usize, in.len - len),
-                    .insert => rng.uintAtMostBiased(usize, in.len),
-                    .push => in.len,
-                };
-
-                out.appendSliceAssumeCapacity(in[0..i]);
-                switch (data) {
-                    .rng => {
-                        var bytes: [@max(max_insert_len, max_set_len)]u8 = undefined;
-                        rng.bytes(bytes[0..len]);
-                        out.appendSliceAssumeCapacity(bytes[0..len]);
-                    },
-                    .zero => out.appendNTimesAssumeCapacity(0, len),
-                    .common => for (out.addManyAsSliceAssumeCapacity(len)) |*c| {
-                        c.* = switch (rng.int(u6)) {
-                            0 => ' ',
-                            1...10 => |x| '0' + (@as(u8, x) - 1),
-                            11...36 => |x| 'A' + (@as(u8, x) - 11),
-                            37 => '_',
-                            38...63 => |x| 'a' + (@as(u8, x) - 38),
-                        };
-                    },
-                    .print => for (out.addManyAsSliceAssumeCapacity(len)) |*c| {
-                        c.* = rng.intRangeAtMostBiased(u8, 0x20, 0x7E);
-                    },
-                    .integer => {
-                        const negative = len != 0 and rng.boolean();
-                        if (negative) {
-                            out.appendAssumeCapacity('-');
-                        }
-
-                        for (out.addManyAsSliceAssumeCapacity(len - @intFromBool(negative))) |*c| {
-                            c.* = rng.intRangeAtMostBiased(u8, '0', '9');
-                        }
-                    },
-                    .wtf8 => {
-                        comptime assert(op != .set);
-                        var codepoints: usize = if (data_ctx == .one)
-                            1
-                        else
-                            rng.intRangeAtMostBiased(usize, 1, Mutation.max_insert_len / 4);
-
-                        while (true) {
-                            const units1 = rng.int(u2);
-                            const value = switch (units1) {
-                                0 => rng.int(u7),
-                                1 => rng.intRangeAtMostBiased(u11, 0x000080, 0x0007FF),
-                                2 => rng.intRangeAtMostBiased(u16, 0x000800, 0x00FFFF),
-                                3 => rng.intRangeAtMostBiased(u21, 0x010000, 0x10FFFF),
-                            };
-                            const units = @as(u3, units1) + 1;
-
-                            var buf: [4]u8 = undefined;
-                            assert(std.unicode.wtf8Encode(value, &buf) catch unreachable == units);
-                            out.appendSliceAssumeCapacity(buf[0..units]);
-
-                            codepoints -= 1;
-                            if (codepoints == 0) break;
-                        }
-                    },
-                    .existing => {
-                        const j = rng.uintAtMostBiased(usize, in.len - len);
-                        out.appendSliceAssumeCapacity(in[j..][0..len]);
-                    },
-                    .splice => {
-                        const j = rng.uintAtMostBiased(usize, corpus[splice_i].len - len);
-                        out.appendSliceAssumeCapacity(corpus[splice_i][j..][0..len]);
-                    },
-                    .@"const" => out.appendSliceAssumeCapacity(@ptrCast(
-                        &data_ctx[rng.uintLessThanBiased(usize, data_ctx.len)],
-                    )),
-                    .small => out.appendSliceAssumeCapacity(@ptrCast(
-                        &mem.nativeTo(data_ctx[0], rng.int(SmallValue), data_ctx[1]),
-                    )),
-                    .few => out.appendSliceAssumeCapacity(@ptrCast(
-                        &fewValue(rng, data_ctx[0], data_ctx[1]),
-                    )),
-                }
-                switch (op) {
-                    .set => out.appendSliceAssumeCapacity(in[i + len ..]),
-                    .insert => out.appendSliceAssumeCapacity(in[i..]),
-                    .push => {},
-                }
-            },
-            .remove => {
-                if (in.len == 0) return false;
-                const Op = enum { delete, pop };
-                const op: Op, const max_len = class_ctx;
-                // LessThan is used so we don't delete the entire span (which is unproductive since
-                // an empty input has always been tried)
-                const len = if (max_len == 1) 1 else rng.uintLessThanBiased(
-                    usize,
-                    @min(max_len + 1, in.len),
-                );
-                switch (op) {
-                    .delete => {
-                        const i = rng.uintAtMostBiased(usize, in.len - len);
-                        out.appendSliceAssumeCapacity(in[0..i]);
-                        out.appendSliceAssumeCapacity(in[i + len ..]);
-                    },
-                    .pop => out.appendSliceAssumeCapacity(in[0 .. in.len - len]),
-                }
-            },
-            .rmw => {
-                const Op = enum { xor, truncate, add, packed_rng };
-                const op: Op, const T, const endian, const xor_bits = class_ctx;
-                if (in.len < @sizeOf(T)) return false;
-                const Log2T = math.Log2Int(T);
-
-                const idx = rng.uintAtMostBiased(usize, in.len - @sizeOf(T));
-                const old = mem.readInt(T, in[idx..][0..@sizeOf(T)], endian);
-                const new = switch (op) {
-                    .xor => old ^ fewValue(rng, T, xor_bits),
-                    .truncate => old & (@as(T, math.maxInt(T)) >> rng.int(Log2T)),
-                    .add => old +% addend: {
-                        const val = rng.int(Mutation.AddValue);
-                        break :addend if (val == 0) 1 else val;
-                    },
-                    .packed_rng => blk: {
-                        const bits = rng.int(math.Log2Int(T)) +| 1;
-                        break :blk old ^ (rng.int(T) >> bits << rng.uintAtMostBiased(Log2T, bits));
-                    },
-                };
-                out.appendSliceAssumeCapacity(in);
-                mem.bytesAsValue(T, out.items[8..][idx..][0..@sizeOf(T)]).* =
-                    mem.nativeTo(T, new, endian);
-            },
-            .move_span => {
-                if (in.len < 2) return false;
-                // One less since moving whole output will never change anything
-                const len = rng.intRangeAtMostBiased(usize, 1, @min(
-                    in.len - 1,
-                    Mutation.max_set_len,
-                ));
-
-                const src = rng.uintAtMostBiased(usize, in.len - len);
-                // This indexes into the final input
-                const dst = blk: {
-                    const res = rng.uintAtMostBiased(usize, in.len - len - 1);
-                    break :blk res + @intFromBool(res >= src);
-                };
-
-                if (src < dst) {
-                    out.appendSliceAssumeCapacity(in[0..src]);
-                    out.appendSliceAssumeCapacity(in[src + len .. dst + len]);
-                    out.appendSliceAssumeCapacity(in[src..][0..len]);
-                    out.appendSliceAssumeCapacity(in[dst + len ..]);
-                } else {
-                    out.appendSliceAssumeCapacity(in[0..dst]);
-                    out.appendSliceAssumeCapacity(in[src..][0..len]);
-                    out.appendSliceAssumeCapacity(in[dst..src]);
-                    out.appendSliceAssumeCapacity(in[src + len ..]);
-                }
-            },
-            .replicate_splice_span => {
-                if (in.len == 0) return false;
-                if (corpus.len == 1) return false;
-                const from = corpus[rng.intRangeLessThanBiased(usize, 1, corpus.len)];
-                const len = rng.uintLessThanBiased(usize, @min(in.len, from.len, max_replicate_len));
-                const i = rng.uintAtMostBiased(usize, @min(in.len, from.len) - len);
-                out.appendSliceAssumeCapacity(in[0..i]);
-                out.appendSliceAssumeCapacity(from[i..][0..len]);
-                out.appendSliceAssumeCapacity(in[i + len ..]);
-            },
-        }
-        return true;
-    }
-};
-
-/// Like `std.ArrayList(u8)` but backed by memory mapping.
-pub const MemoryMappedList = struct {
-    /// Contents of the list.
+/// Reusable and recoverable input.
+///
+/// Has a 32-bit limit on the input length. This has the nice side effect that `u32`
+/// can be used in most placed in `fuzzer` with the last four values reserved.
+const MemoryMappedInput = struct {
+    len: u32,
+    /// Directly accessing `memory` is unsafe, use either `inputSlice` or `writeSlice`.
     ///
-    /// Pointers to elements in this slice are invalidated by various functions
-    /// of this ArrayList in accordance with the respective documentation. In
-    /// all cases, "invalidated" means that the memory has been passed to this
-    /// allocator's resize or free function.
-    items: []align(std.heap.page_size_min) volatile u8,
-    /// How many bytes this list can hold without allocating additional memory.
-    capacity: usize,
-    /// The file is kept open so that it can be resized.
-    file: Io.File,
+    /// `memory` starts with the length of the input as a little-endian 32-bit integer.
+    mmap: Io.File.MemoryMap,
 
-    pub fn init(file: Io.File, length: usize, capacity: usize) !MemoryMappedList {
-        const ptr = try std.posix.mmap(
-            null,
-            capacity,
-            .{ .READ = true, .WRITE = true },
-            .{ .TYPE = .SHARED },
-            file.handle,
-            0,
-        );
+    /// `file` becomes owned by the returned `MemoryMappedInput`
+    pub fn init(file: Io.File, size: usize) !MemoryMappedInput {
+        assert(size >= 4);
         return .{
-            .file = file,
-            .items = ptr[0..length],
-            .capacity = capacity,
+            .len = 0,
+            .mmap = try file.createMemoryMap(io, .{ .len = size }),
         };
     }
 
-    pub fn create(file: Io.File, length: usize, capacity: usize) !MemoryMappedList {
-        try file.setLength(io, capacity);
-        return init(file, length, capacity);
-    }
-
-    pub fn deinit(l: *MemoryMappedList) void {
-        l.file.close(io);
-        std.posix.munmap(@volatileCast(l.items.ptr[0..l.capacity]));
+    pub fn deinit(l: *MemoryMappedInput) void {
+        const f = l.mmap.file;
+        l.mmap.write(io) catch |e| panic("failed to write memory map of 'in': {t}", .{e});
+        l.mmap.destroy(io);
+        f.close(io);
         l.* = undefined;
     }
 
     /// Modify the array so that it can hold at least `additional_count` **more** items.
+    ///
     /// Invalidates element pointers if additional memory is needed.
-    pub fn ensureUnusedCapacity(l: *MemoryMappedList, additional_count: usize) !void {
-        return l.ensureTotalCapacity(l.items.len + additional_count);
+    pub fn ensureUnusedCapacity(l: *MemoryMappedInput, additional_count: usize) void {
+        return l.ensureTotalCapacity(4 + l.len + additional_count);
     }
 
-    /// If the current capacity is less than `new_capacity`, this function will
-    /// modify the array so that it can hold at least `new_capacity` items.
+    /// If the current capacity is less than `min_capacity`, this function will
+    /// modify the array so that it can hold at least `min_capacity` items.
+    ///
     /// Invalidates element pointers if additional memory is needed.
-    pub fn ensureTotalCapacity(l: *MemoryMappedList, new_capacity: usize) !void {
-        if (l.capacity >= new_capacity) return;
+    pub fn ensureTotalCapacity(l: *MemoryMappedInput, min_capacity: usize) void {
+        if (l.mmap.memory.len < min_capacity) {
+            @branchHint(.unlikely);
 
-        const better_capacity = growCapacity(l.capacity, new_capacity);
-        return l.ensureTotalCapacityPrecise(better_capacity);
+            const max_capacity = 1 << 32; // The size of the length header is not added
+            // in order to keep the capacity page aligned and to allow those values to
+            // reserved for other places.
+            if (min_capacity > max_capacity) @panic("too much smith data requested");
+
+            const new_capacity = @min(growCapacity(min_capacity), max_capacity);
+            l.mmap.file.setLength(io, new_capacity) catch |e|
+                panic("failed to resize 'in': {t}", .{e});
+            l.mmap.setLength(io, new_capacity) catch |se| switch (se) {
+                error.OperationUnsupported => {
+                    const f = l.mmap.file;
+                    l.mmap.destroy(io);
+                    l.mmap = f.createMemoryMap(io, .{ .len = new_capacity }) catch |e|
+                        panic("failed to memory map 'in': {t}", .{e});
+                },
+                else => panic("failed to resize memory map of 'in': {t}", .{se}),
+            };
+        }
+    }
+
+    // Only writing has side effects, so volatile is not needed
+    pub fn inputSlice(l: *MemoryMappedInput) []const u8 {
+        return l.mmap.memory[4..][0..l.len];
     }
 
-    pub fn ensureTotalCapacityPrecise(l: *MemoryMappedList, new_capacity: usize) !void {
-        if (l.capacity >= new_capacity) return;
+    // Writing has side effectsd, so volatile is necessary
+    pub fn writeSlice(l: *MemoryMappedInput) []volatile u8 {
+        return l.mmap.memory;
+    }
 
-        std.posix.munmap(@volatileCast(l.items.ptr[0..l.capacity]));
-        try l.file.setLength(io, new_capacity);
-        l.* = try init(l.file, l.items.len, new_capacity);
+    fn writeLen(l: *MemoryMappedInput) void {
+        l.writeSlice()[0..4].* = @bitCast(mem.nativeToLittle(u32, l.len));
     }
 
     /// Invalidates all element pointers.
-    pub fn clearRetainingCapacity(l: *MemoryMappedList) void {
-        l.items.len = 0;
+    pub fn clearRetainingCapacity(l: *MemoryMappedInput) void {
+        l.len = 0;
+        l.writeLen();
     }
 
     /// Append the slice of items to the list.
-    /// Asserts that the list can hold the additional items.
-    pub fn appendSliceAssumeCapacity(l: *MemoryMappedList, items: []const u8) void {
-        const old_len = l.items.len;
-        const new_len = old_len + items.len;
-        assert(new_len <= l.capacity);
-        l.items.len = new_len;
-        @memcpy(l.items[old_len..][0..items.len], items);
+    ///
+    /// Invalidates item pointers if more space is required.
+    pub fn appendSlice(l: *MemoryMappedInput, items: []const u8) void {
+        l.ensureUnusedCapacity(items.len);
+        @memcpy(l.writeSlice()[4 + l.len ..][0..items.len], items);
+        l.len += @as(u32, @intCast(items.len));
+        l.writeLen();
     }
 
-    /// Extends the list by 1 element.
-    /// Never invalidates element pointers.
-    /// Asserts that the list can hold one additional item.
-    pub fn appendAssumeCapacity(l: *MemoryMappedList, item: u8) void {
-        const new_item_ptr = l.addOneAssumeCapacity();
-        new_item_ptr.* = item;
-    }
-
-    /// Increase length by 1, returning pointer to the new item.
-    /// The returned pointer becomes invalid when the list is resized.
-    /// Never invalidates element pointers.
-    /// Asserts that the list can hold one additional item.
-    pub fn addOneAssumeCapacity(l: *MemoryMappedList) *volatile u8 {
-        assert(l.items.len < l.capacity);
-        l.items.len += 1;
-        return &l.items[l.items.len - 1];
-    }
-
-    /// Append a value to the list `n` times.
-    /// Never invalidates element pointers.
-    /// The function is inline so that a comptime-known `value` parameter will
-    /// have better memset codegen in case it has a repeated byte pattern.
-    /// Asserts that the list can hold the additional items.
-    pub inline fn appendNTimesAssumeCapacity(l: *MemoryMappedList, value: u8, n: usize) void {
-        const new_len = l.items.len + n;
-        assert(new_len <= l.capacity);
-        @memset(l.items.ptr[l.items.len..new_len], value);
-        l.items.len = new_len;
-    }
-
-    /// Resize the array, adding `n` new elements, which have `undefined` values.
-    /// The return value is a slice pointing to the newly allocated elements.
-    /// Never invalidates element pointers.
-    /// The returned pointer becomes invalid when the list is resized.
-    /// Asserts that the list can hold the additional items.
-    pub fn addManyAsSliceAssumeCapacity(l: *MemoryMappedList, n: usize) []volatile u8 {
-        assert(l.items.len + n <= l.capacity);
-        const prev_len = l.items.len;
-        l.items.len += n;
-        return l.items[prev_len..][0..n];
+    /// Append the little-endian integer to the list.
+    ///
+    /// Invalidates item pointers if more space is required.
+    pub fn appendLittleInt(l: *MemoryMappedInput, T: type, x: T) void {
+        l.ensureUnusedCapacity(@sizeOf(T));
+        //std.log.debug("{} {} {}", .{ l.writeSlice().len, l.len, @sizeOf(T) });
+        l.writeSlice()[4 + l.len ..][0..@sizeOf(T)].* = @bitCast(mem.nativeToLittle(T, x));
+        l.len += @sizeOf(T);
+        l.writeLen();
     }
 
     /// Called when memory growth is necessary. Returns a capacity larger than
     /// minimum that grows super-linearly.
-    fn growCapacity(current: usize, minimum: usize) usize {
-        var new = current;
-        while (true) {
-            new = mem.alignForward(usize, new + new / 2, std.heap.page_size_max);
-            if (new >= minimum) return new;
-        }
-    }
-
-    pub fn insertAssumeCapacity(l: *MemoryMappedList, i: usize, item: u8) void {
-        assert(l.items.len + 1 <= l.capacity);
-        l.items.len += 1;
-        volatileCopyBackwards(u8, l.items[i + 1 ..], l.items[i .. l.items.len - 1]);
-        l.items[i] = item;
-    }
-
-    pub fn orderedRemove(l: *MemoryMappedList, i: usize) u8 {
-        assert(l.items.len + 1 <= l.capacity);
-        const old = l.items[i];
-        volatileCopyForwards(u8, l.items[i .. l.items.len - 1], l.items[i + 1 ..]);
-        l.items.len -= 1;
-        return old;
+    fn growCapacity(minimum: usize) usize {
+        return mem.alignForward(
+            usize,
+            minimum +| (minimum / 2 + std.heap.page_size_max),
+            std.heap.page_size_max,
+        );
     }
 };
diff --git a/lib/init/src/main.zig b/lib/init/src/main.zig
index 2c6df25be543819dfd345b0c8b5e69588ed51afe..0ce4b9110ef7058efecee2eb48940bcd54fc6768 100644
--- a/lib/init/src/main.zig
+++ b/lib/init/src/main.zig
@@ -40,12 +40,32 @@ test "simple test" {
 }
 
 test "fuzz example" {
-    const Context = struct {
-        fn testOne(context: @This(), input: []const u8) anyerror!void {
-            _ = context;
-            // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
-            try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input));
-        }
+    try std.testing.fuzz({}, testOne, .{});
+}
+
+fn testOne(context: void, smith: *std.testing.Smith) !void {
+    _ = context;
+    // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
+
+    const gpa = std.testing.allocator;
+    var list: std.ArrayList(u8) = .empty;
+    defer list.deinit(gpa);
+    while (!smith.eos()) switch (smith.value(enum { add_data, dup_data })) {
+        .add_data => {
+            const slice = try list.addManyAsSlice(gpa, smith.value(u4));
+            smith.bytes(slice);
+        },
+        .dup_data => {
+            if (list.items.len == 0) continue;
+            if (list.items.len > std.math.maxInt(u32)) return error.SkipZigTest;
+            const len = smith.valueRangeAtMost(u32, 1, @min(32, list.items.len));
+            const off = smith.valueRangeAtMost(u32, 0, @intCast(list.items.len - len));
+            try list.appendSlice(gpa, list.items[off..][0..len]);
+            try std.testing.expectEqualSlices(
+                u8,
+                list.items[off..][0..len],
+                list.items[list.items.len - len ..],
+            );
+        },
     };
-    try std.testing.fuzz(Context{}, Context.testOne, .{});
 }
diff --git a/lib/std/Build/abi.zig b/lib/std/Build/abi.zig
index 68060ae16ba47910476db7c6f85f6cc81c84ea48..a7decb09da66b4b80bad33ac377e8d523ce0b844 100644
--- a/lib/std/Build/abi.zig
+++ b/lib/std/Build/abi.zig
@@ -6,6 +6,7 @@
 //! All of these components interface to some degree via an ABI:
 //! * The build runner communicates with the web interface over a WebSocket connection
 //! * The build runner communicates with `libfuzzer` over a shared memory-mapped file
+const std = @import("std");
 
 // Check that no WebSocket message type has implicit padding bits. This ensures we never send any
 // undefined bits over the wire, and also helps validate that the layout doesn't differ between, for
@@ -13,7 +14,6 @@
 comptime {
     const check = struct {
         fn check(comptime T: type) void {
-            const std = @import("std");
             std.debug.assert(@typeInfo(T) == .@"struct");
             std.debug.assert(@typeInfo(T).@"struct".layout == .@"extern");
             std.debug.assert(std.meta.hasUniqueRepresentation(T));
@@ -139,14 +139,48 @@ pub const Rebuild = extern struct {
 
 /// ABI bits specifically relating to the fuzzer interface.
 pub const fuzz = struct {
-    pub const TestOne = *const fn (Slice) callconv(.c) void;
+    pub const TestOne = *const fn () callconv(.c) void;
+
+    /// A unique value to identify the related requests across runs
+    pub const Uid = packed struct(u32) {
+        kind: enum(u1) { int, bytes },
+        hash: u31,
+
+        pub const hashmap_ctx = struct {
+            pub fn hash(_: @This(), u: Uid) u32 {
+                // We can ignore `kind` since `hash` should be unique regardless
+                return u.hash;
+            }
+
+            pub fn eql(_: @This(), a: Uid, b: Uid, _: usize) bool {
+                return a == b;
+            }
+        };
+    };
+
     pub extern fn fuzzer_init(cache_dir_path: Slice) void;
+    /// `fuzzer_init` must be called first.
     pub extern fn fuzzer_coverage() Coverage;
-    pub extern fn fuzzer_init_test(test_one: TestOne, unit_test_name: Slice) void;
+    /// `fuzzer_init` must be called first.
+    pub extern fn fuzzer_set_test(test_one: TestOne, unit_test_name: Slice) void;
+    /// `fuzzer_set_test` must be called first.
+    /// The callee owns the memory of bytes and must not free it until `fuzzer_main` returns
     pub extern fn fuzzer_new_input(bytes: Slice) void;
+    /// `fuzzer_set_test` must be called first.
+    /// Resets the fuzzer's state to that of `fuzzer_init`.
     pub extern fn fuzzer_main(limit_kind: LimitKind, amount: u64) void;
     pub extern fn fuzzer_unslide_address(addr: usize) usize;
 
+    pub extern fn fuzzer_int(uid: Uid, weights: Weights) u64;
+    pub extern fn fuzzer_eos(uid: Uid, weights: Weights) bool;
+    pub extern fn fuzzer_bytes(uid: Uid, out: MutSlice, weights: Weights) void;
+    pub extern fn fuzzer_slice(
+        uid: Uid,
+        buf: MutSlice,
+        len_weights: Weights,
+        byte_weights: Weights,
+    ) u32;
+
     pub const Slice = extern struct {
         ptr: [*]const u8,
         len: usize,
@@ -160,6 +194,100 @@ pub const fuzz = struct {
         }
     };
 
+    pub const MutSlice = extern struct {
+        ptr: [*]u8,
+        len: usize,
+
+        pub fn toSlice(s: MutSlice) []u8 {
+            return s.ptr[0..s.len];
+        }
+
+        pub fn fromSlice(s: []u8) MutSlice {
+            return .{ .ptr = s.ptr, .len = s.len };
+        }
+    };
+
+    pub const Weights = extern struct {
+        ptr: [*]const Weight,
+        len: usize,
+
+        pub fn toSlice(s: Weights) []const Weight {
+            return s.ptr[0..s.len];
+        }
+
+        pub fn fromSlice(s: []const Weight) Weights {
+            return .{ .ptr = s.ptr, .len = s.len };
+        }
+    };
+
+    /// Increases the probability of values being selected by the fuzzer.
+    ///
+    /// `weight` applies to each value in the range (i.e. not evenly across
+    /// the range) and must be nonzero.
+    ///
+    /// In a set of weights, the total weight must not exceed 2^64 and be
+    /// nonzero.
+    pub const Weight = extern struct {
+        /// Inclusive
+        min: u64,
+        /// Inclusive
+        max: u64,
+        weight: u64,
+
+        fn intFromValue(x: anytype) u64 {
+            const T = @TypeOf(x);
+            return switch (@typeInfo(T)) {
+                .comptime_int => x,
+                .bool => @intFromBool(x),
+                .@"enum" => @intFromEnum(x),
+                else => @as(std.meta.Int(.unsigned, @bitSizeOf(T)), @bitCast(x)),
+
+                .int => |i| x: {
+                    comptime {
+                        if (i.signedness == .signed) {
+                            @compileError("type does not have a continous range: " ++ @typeName(T));
+                        }
+                        // Reject types that don't have a fixed bitsize (esp. usize)
+                        // since they are not gauraunteed to fit in a u64 across targets.
+                        if (std.mem.indexOfScalar(type, &.{
+                            usize, c_char, c_ushort, c_uint, c_ulong, c_ulonglong,
+                        }, T) != null) {
+                            @compileError("type does not have a fixed bitsize: " ++ @typeName(T));
+                        }
+                    }
+                    break :x x;
+                },
+
+                .comptime_float,
+                .float,
+                => @compileError("type does not have a continous range: " ++ @typeName(T)),
+                .pointer => @compileError("type does not have a fixed bitsize: " ++ @typeName(T)),
+            };
+        }
+
+        pub fn value(T: type, x: T, weight: u64) Weight {
+            return .{ .min = intFromValue(x), .max = intFromValue(x), .weight = weight };
+        }
+
+        pub fn rangeAtMost(T: type, at_least: T, at_most: T, weight: u64) Weight {
+            std.debug.assert(intFromValue(at_least) <= intFromValue(at_most));
+            return .{
+                .min = intFromValue(at_least),
+                .max = intFromValue(at_most),
+                .weight = weight,
+            };
+        }
+
+        pub fn rangeLessThan(T: type, at_least: T, less_than: T, weight: u64) Weight {
+            std.debug.assert(intFromValue(at_least) < intFromValue(less_than));
+            return .{
+                .min = intFromValue(at_least),
+                .max = intFromValue(less_than) - 1,
+                .weight = weight,
+            };
+        }
+    };
+
     pub const LimitKind = enum(u8) { forever, iterations };
 
     /// libfuzzer uses this and its usize is the one that counts. To match the ABI,
diff --git a/lib/std/compress/flate/Compress.zig b/lib/std/compress/flate/Compress.zig
index 0a85dd9d0a3c2ce53d7735bd8e4dd1aaec52b2b2..9f470706068b66244c0a406d5e8355450179dd1d 100644
--- a/lib/std/compress/flate/Compress.zig
+++ b/lib/std/compress/flate/Compress.zig
@@ -279,7 +279,7 @@ pub fn init(
     assert(buffer.len >= flate.max_window_len);
 
     // note that disallowing some of these simplifies matching logic
-    assert(opts.chain != 0); // use `Huffman`, disallowing this simplies matching
+    assert(opts.chain != 0); // use `Huffman`; disallowing this simplies matching
     assert(opts.good >= 3 and opts.nice >= 3); // a match will (usually) not be found
     assert(opts.good <= 258 and opts.nice <= 258); // a longer match will not be found
     assert(opts.lazy <= opts.nice); // a longer match will (usually) not be found
@@ -558,45 +558,35 @@ test betterMatchLen {
     try std.testing.fuzz({}, testFuzzedMatchLen, .{});
 }
 
-fn testFuzzedMatchLen(_: void, input: []const u8) !void {
+fn testFuzzedMatchLen(_: void, smith: *std.testing.Smith) !void {
     @disableInstrumentation();
-    var r: Io.Reader = .fixed(input);
     var buf: [1024]u8 = undefined;
     var w: Writer = .fixed(&buf);
-    var old = r.takeLeb128(u9) catch 0;
-    var bytes_off = @max(1, r.takeLeb128(u10) catch 258);
-    const prev_back = @max(1, r.takeLeb128(u10) catch 258);
 
-    while (r.takeByte()) |byte| {
-        const op: packed struct(u8) {
-            kind: enum(u2) { splat, copy, insert_imm, insert },
-            imm: u6,
-
-            pub fn immOrByte(op_s: @This(), r_s: *Io.Reader) usize {
-                return if (op_s.imm == 0) op_s.imm else @as(usize, r_s.takeByte() catch 0) + 64;
-            }
-        } = @bitCast(byte);
-        (switch (op.kind) {
-            .splat => w.splatByteAll(r.takeByte() catch 0, op.immOrByte(&r)),
+    while (w.unusedCapacityLen() != 0 and !smith.eosWeightedSimple(7, 1)) {
+        switch (smith.value(enum(u2) { splat, copy, insert })) {
+            .splat => w.splatByteAll(
+                smith.value(u8),
+                smith.valueRangeAtMost(u9, 1, @min(511, w.unusedCapacityLen())),
+            ) catch unreachable,
             .copy => write: {
-                const start = w.buffered().len -| op.immOrByte(&r);
-                const len = @min(w.buffered().len - start, r.takeByte() catch 3);
-                break :write w.writeAll(w.buffered()[start..][0..len]);
+                if (w.buffered().len == 0) continue;
+                const start = smith.valueRangeAtMost(u10, 0, @intCast(w.buffered().len - 1));
+                const max_len = @min(w.unusedCapacityLen(), w.buffered().len - start);
+                const len = smith.valueRangeAtMost(u10, 1, @intCast(max_len));
+                break :write w.writeAll(w.buffered()[start..][0..len]) catch unreachable;
             },
-            .insert_imm => w.writeByte(op.imm),
-            .insert => w.writeAll(r.take(
-                @min(r.bufferedLen(), @as(usize, op.imm) + 1),
-            ) catch unreachable),
-        }) catch break;
-    } else |_| {}
+            .insert => w.advance(smith.slice(w.unusedCapacitySlice())),
+        }
+    }
+    w.splatByteAll(0, (1 + token.min_length) -| w.buffered().len) catch unreachable;
 
-    w.splatByteAll(0, (1 + 3) -| w.buffered().len) catch unreachable;
-    bytes_off = @min(bytes_off, @as(u10, @intCast(w.buffered().len - 3)));
-    const prev_off = bytes_off -| prev_back;
-    assert(prev_off < bytes_off);
+    const max_start = w.buffered().len - token.min_length;
+    const bytes_off = smith.valueRangeAtMost(u10, 1, @intCast(max_start));
+    const prev_off = smith.valueRangeAtMost(u10, 0, bytes_off - 1);
     const prev = w.buffered()[prev_off..];
     const bytes = w.buffered()[bytes_off..];
-    old = @min(old, bytes.len - 1, token.max_length - 1);
+    const old = smith.valueRangeLessThan(u10, 0, @min(bytes.len, token.max_length));
 
     const diff_index = mem.findDiff(u8, prev, bytes).?; // unwrap since lengths are not same
     const expected_len = @min(diff_index, 258);
@@ -1036,7 +1026,7 @@ const huffman = struct {
         max_bits: u4,
         incomplete_allowed: bool,
     ) struct { u32, u16 } {
-        assert(out_codes.len - 1 >= @intFromBool(incomplete_allowed));
+        assert(out_codes.len - 1 >= @intFromBool(!incomplete_allowed));
         // freqs and out_codes are in the loop to assert they are all the same length
         for (freqs, out_codes, out_bits) |_, _, n| assert(n == 0);
         assert(out_codes.len <= @as(u16, 1) << max_bits);
@@ -1255,40 +1245,35 @@ const huffman = struct {
         try std.testing.fuzz({}, checkFuzzedBuildFreqs, .{});
     }
 
-    fn checkFuzzedBuildFreqs(_: void, freqs: []const u8) !void {
+    fn checkFuzzedBuildFreqs(_: void, smith: *std.testing.Smith) !void {
         @disableInstrumentation();
-        var r: Io.Reader = .fixed(freqs);
         var freqs_limit: u16 = 65535;
         var freqs_buf: [max_leafs]u16 = undefined;
         var nfreqs: u15 = 0;
 
-        const params: packed struct(u8) {
-            max_bits: u4,
-            _: u3,
-            incomplete_allowed: bool,
-        } = @bitCast(r.takeByte() catch 255);
-        while (nfreqs != freqs_buf.len) {
-            const leb = r.takeLeb128(u16);
-            const f = if (leb) |f| @min(f, freqs_limit) else |e| switch (e) {
-                error.ReadFailed => unreachable,
-                error.EndOfStream => 0,
-                error.Overflow => freqs_limit,
-            };
+        const incomplete_allowed = smith.value(bool);
+        while (nfreqs < @as(u8, @intFromBool(!incomplete_allowed)) + 1 or
+            nfreqs != freqs_buf.len and freqs_limit != 0 and
+                smith.eosWeightedSimple(15, 1))
+        {
+            const f = smith.valueWeighted(u16, &.{
+                .rangeAtMost(u16, 0, @min(31, freqs_limit), @max(freqs_limit, 1)),
+                .rangeAtMost(u16, 0, freqs_limit, 1),
+            });
             freqs_buf[nfreqs] = f;
-            nfreqs += 1;
             freqs_limit -= f;
-            if (leb == error.EndOfStream and nfreqs - 1 > @intFromBool(params.incomplete_allowed))
-                break;
+            nfreqs += 1;
         }
 
         var codes_buf: [max_leafs]u16 = undefined;
         var bits_buf: [max_leafs]u4 = @splat(0);
+        const max_bits = smith.valueRangeAtMost(u4, math.log2_int_ceil(u15, nfreqs), 15);
         const total_bits, const last_nonzero = build(
             freqs_buf[0..nfreqs],
             codes_buf[0..nfreqs],
             bits_buf[0..nfreqs],
-            @max(math.log2_int_ceil(u15, nfreqs), params.max_bits),
-            params.incomplete_allowed,
+            max_bits,
+            incomplete_allowed,
         );
 
         var has_bitlen_one: bool = false;
@@ -1303,21 +1288,21 @@ const huffman = struct {
         }
 
         errdefer std.log.err(
-            \\ params: {}
+            \\ incomplete_allowed: {}
+            \\ max_bits: {}
             \\ freqs: {any}
             \\ bits: {any}
             \\ # freqs: {}
-            \\ max bits: {} 
             \\ weighted sum: {}
             \\ has_bitlen_one: {}
             \\ expected/actual total bits: {}/{}
             \\ expected/actual last nonzero: {?}/{}
         ++ "\n", .{
-            params,
+            incomplete_allowed,
+            max_bits,
             freqs_buf[0..nfreqs],
             bits_buf[0..nfreqs],
             nfreqs,
-            @max(math.log2_int_ceil(u15, nfreqs), params.max_bits),
             weighted_sum,
             has_bitlen_one,
             expected_total_bits,
@@ -1331,7 +1316,7 @@ const huffman = struct {
         if (weighted_sum > 1 << 15)
             return error.OversubscribedHuffmanTree;
         if (weighted_sum < 1 << 15 and
-            !(params.incomplete_allowed and has_bitlen_one and weighted_sum == 1 << 14))
+            !(incomplete_allowed and has_bitlen_one and weighted_sum == 1 << 14))
             return error.IncompleteHuffmanTree;
     }
 };
@@ -1353,6 +1338,7 @@ fn testingFreqBufs() !*[2][65536]u8 {
     }
     return fbufs;
 }
+const FreqBufIndex = enum(u1) { gradient, random };
 
 fn testingCheckDecompressedMatches(
     flate_bytes: []const u8,
@@ -1426,34 +1412,31 @@ test Compress {
     try std.testing.fuzz(fbufs, testFuzzedCompressInput, .{});
 }
 
-fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, input: []const u8) !void {
-    var in: Io.Reader = .fixed(input);
-    var opts: packed struct(u51) {
-        container: PackedContainer,
-        buf_size: u16,
-        good: u8,
-        nice: u8,
-        lazy: u8,
-        /// Not a `u16` to limit it for performance
-        chain: u9,
-    } = @bitCast(in.takeLeb128(u51) catch 0);
-    var expected_hash: flate.Container.Hasher = .init(opts.container.val());
+fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith) !void {
+    @disableInstrumentation();
+    const container = smith.value(flate.Container);
+    const good = smith.valueRangeAtMost(u16, 3, 258);
+    const nice = smith.valueRangeAtMost(u16, 3, 258);
+    const lazy = smith.valueRangeAtMost(u16, 3, nice);
+    const chain = smith.valueWeighted(u16, &.{
+        .rangeAtMost(u16, if (good <= lazy) 4 else 1, 255, 65536),
+        // The following weights are greatly reduced since they increasing take more time to run
+        .rangeAtMost(u16, 256, 4095, 256),
+        .rangeAtMost(u16, 4096, 32767 + 256, 1),
+    });
+    var expected_hash: flate.Container.Hasher = .init(container);
     var expected_size: u32 = 0;
 
     var flate_buf: [128 * 1024]u8 = undefined;
     var flate_w: Writer = .fixed(&flate_buf);
     var deflate_buf: [flate.max_window_len * 2]u8 = undefined;
-    var deflate_w = try Compress.init(
-        &flate_w,
-        deflate_buf[0 .. flate.max_window_len + @as(usize, opts.buf_size)],
-        opts.container.val(),
-        .{
-            .good = @as(u16, opts.good) + 3,
-            .nice = @as(u16, opts.nice) + 3,
-            .lazy = @as(u16, @min(opts.lazy, opts.nice)) + 3,
-            .chain = @max(1, opts.chain, @as(u8, 4) * @intFromBool(opts.good <= opts.lazy)),
-        },
-    );
+    const bufsize = smith.valueRangeAtMost(u32, flate.max_window_len, @intCast(deflate_buf.len));
+    var deflate_w = try Compress.init(&flate_w, deflate_buf[0..bufsize], container, .{
+        .good = good,
+        .nice = nice,
+        .lazy = lazy,
+        .chain = chain,
+    });
 
     // It is ensured that more bytes are not written then this to ensure this run
     // does not take too long and that `flate_buf` does not run out of space.
@@ -1465,79 +1448,57 @@ fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, input: []const u8) !void
     // extra 32 bytes is reserved on top of that for container headers and footers.
     const max_size = flate_buf.len - (flate_buf_blocks * 64 + 32);
 
-    while (true) {
-        const data: packed struct(u36) {
-            is_rebase: bool,
-            is_bytes: bool,
-            params: packed union {
-                copy: packed struct(u34) {
-                    len_lo: u5,
-                    dist: u15,
-                    len_hi: u4,
-                    _: u10,
-                },
-                bytes: packed struct(u34) {
-                    kind: enum(u1) { gradient, random },
-                    off_hi: u4,
-                    len_lo: u10,
-                    off_mi: u4,
-                    len_hi: u5,
-                    off_lo: u8,
-                    _: u2,
-                },
-                rebase: packed struct(u34) {
-                    preserve: u17,
-                    capacity: u17,
-                },
-            },
-        } = @bitCast(in.takeLeb128(u36) catch |e| switch (e) {
-            error.ReadFailed => unreachable,
-            error.Overflow => 0,
-            error.EndOfStream => break,
-        });
+    while (!smith.eosWeightedSimple(7, 1)) {
+        const max_bytes = max_size -| expected_size;
+        if (max_bytes == 0) break;
 
         const buffered = deflate_w.writer.buffered();
         // Required for repeating patterns and since writing from `buffered` is illegal
         var copy_buf: [512]u8 = undefined;
 
-        if (data.is_rebase) {
-            const usable_capacity = deflate_w.writer.buffer.len - rebase_reserved_capacity;
-            const preserve = @min(data.params.rebase.preserve, usable_capacity);
-            const capacity = @min(data.params.rebase.capacity, usable_capacity -
-                @max(rebase_min_preserve, preserve));
-            try deflate_w.writer.rebase(preserve, capacity);
-            continue;
-        }
+        const bytes = bytes: switch (smith.valueRangeAtMost(
+            u2,
+            @intFromBool(buffered.len == 0),
+            2,
+        )) {
+            0 => { // Copy
+                const start = smith.valueRangeLessThan(u32, 0, @intCast(buffered.len));
+                // Reuse the implementation's history; otherwise, our own would need maintained.
+                const from = buffered[start..];
+                const len = smith.valueRangeAtMost(u16, 1, @min(copy_buf.len, max_bytes));
 
-        const max_bytes = max_size -| expected_size;
-        const bytes = if (!data.is_bytes and buffered.len != 0) bytes: {
-            const dist = @min(buffered.len, @as(u32, data.params.copy.dist) + 1);
-            const len = @min(
-                @max(@shlExact(@as(u9, data.params.copy.len_hi), 5) | data.params.copy.len_lo, 1),
-                max_bytes,
-            );
-            // Reuse the implementation's history. Otherwise our own would need maintained.
-            const bytes_start = buffered[buffered.len - dist ..];
-            const history_bytes = bytes_start[0..@min(bytes_start.len, len)];
-
-            @memcpy(copy_buf[0..history_bytes.len], history_bytes);
-            const new_history = len - history_bytes.len;
-            if (history_bytes.len != len) for ( // check needed for `- dist`
-                copy_buf[history_bytes.len..][0..new_history],
-                copy_buf[history_bytes.len - dist ..][0..new_history],
-            ) |*next, prev| {
-                next.* = prev;
-            };
-            break :bytes copy_buf[0..len];
-        } else bytes: {
-            const off = @shlExact(@as(u16, data.params.bytes.off_hi), 12) |
-                @shlExact(@as(u16, data.params.bytes.off_mi), 8) |
-                data.params.bytes.off_lo;
-            const len = @shlExact(@as(u16, data.params.bytes.len_hi), 10) |
-                data.params.bytes.len_lo;
-            const fbuf = &fbufs[@intFromEnum(data.params.bytes.kind)];
-            break :bytes fbuf[off..][0..@min(len, fbuf.len - off, max_bytes)];
+                const history_bytes = from[0..@min(from.len, len)];
+                @memcpy(copy_buf[0..history_bytes.len], history_bytes);
+                const repeat_len = len - history_bytes.len;
+                for (
+                    copy_buf[history_bytes.len..][0..repeat_len],
+                    copy_buf[0..repeat_len],
+                ) |*next, prev| {
+                    next.* = prev;
+                }
+                break :bytes copy_buf[0..len];
+            },
+            1 => { // Bytes
+                const fbuf = &fbufs[
+                    smith.valueWeighted(u1, &.{
+                        .value(FreqBufIndex, .gradient, 3),
+                        .value(FreqBufIndex, .random, 1),
+                    })
+                ];
+                const len = smith.valueRangeAtMost(u32, 1, @min(fbuf.len, max_bytes));
+                const off = smith.valueRangeAtMost(u32, 0, @intCast(fbuf.len - len));
+                break :bytes fbuf[off..][0..len];
+            },
+            2 => { // Rebase
+                const rebaseable = bufsize - rebase_reserved_capacity;
+                const capacity = smith.valueRangeAtMost(u32, 1, rebaseable - rebase_min_preserve);
+                const preserve = smith.valueRangeAtMost(u32, 0, rebaseable - capacity);
+                try deflate_w.writer.rebase(preserve, capacity);
+                continue;
+            },
+            else => unreachable,
         };
+
         assert(bytes.len <= max_bytes);
         try deflate_w.writer.writeAll(bytes);
         expected_hash.update(bytes);
@@ -1780,7 +1741,8 @@ fn countVec(data: []const []const u8) usize {
     return bytes;
 }
 
-fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, input: []const u8) !void {
+fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, smith: *std.testing.Smith) !void {
+    @disableInstrumentation();
     const HashedStoreWriter = struct {
         writer: Writer,
         state: enum {
@@ -1819,8 +1781,8 @@ fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, input: []const u8) !void {
 
         /// Note that this implementation is somewhat dependent on the implementation of
         /// `Raw` by expecting headers / footers to be continous in data elements. It
-        /// also expects the header to be the same as `flate.Container.header` and not
-        /// for multiple streams to be concatenated.
+        /// also expects the header to be the same as `flate.Container.header` and for
+        /// multiple streams to not be concatenated.
         fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize {
             errdefer w.* = .failing;
             var h: *@This() = @fieldParentPtr("writer", w);
@@ -1909,102 +1871,110 @@ fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, input: []const u8) !void {
         }
 
         fn flush(w: *Writer) Writer.Error!void {
-            defer w.* = .failing; // Clears buffer even if state hasn't reached `end`
+            defer w.* = .failing; // Empties buffer even if state hasn't reached `end`
             _ = try @This().drain(w, &.{""}, 0);
         }
     };
 
-    var in: Io.Reader = .fixed(input);
-    const opts: packed struct(u19) {
-        container: PackedContainer,
-        buf_len: u17,
-    } = @bitCast(in.takeLeb128(u19) catch 0);
-    var output: HashedStoreWriter = .init(&.{}, opts.container.val());
-    var r_buf: [2 * 65536]u8 = undefined;
-    var r: Raw = try .init(
-        &output.writer,
-        r_buf[0 .. opts.buf_len +% flate.max_window_len],
-        opts.container.val(),
-    );
-
-    var data_base: u18 = 0;
-    var expected_hash: flate.Container.Hasher = .init(opts.container.val());
+    const container = smith.value(flate.Container);
+    var output: HashedStoreWriter = .init(&.{}, container);
+    var expected_hash: flate.Container.Hasher = .init(container);
     var expected_size: u32 = 0;
+    // 10 maximum blocks is the choosen limit since it is two more
+    // than the maximum the implementation can output in one drain.
+    const max_size = 10 * @as(u32, Raw.max_block_size);
+
+    var raw_buf: [2 * @as(usize, Raw.max_block_size)]u8 = undefined;
+    const raw_buf_len = smith.valueWeighted(u32, &.{
+        .value(u32, 0, @intCast(raw_buf.len)), // unbuffered
+        .rangeAtMost(u32, 0, @intCast(raw_buf.len), 1),
+    });
+    var raw: Raw = try .init(&output.writer, raw_buf[0..raw_buf_len], container);
+
+    const data_buf_len: u32 = @intCast(data_buf.len);
     var vecs: [32][]const u8 = undefined;
     var vecs_n: usize = 0;
 
-    while (in.seek != in.end) {
-        const VecInfo = packed struct(u58) {
-            output: bool,
-            /// If set, `data_len` and `splat` are reinterpreted as `capacity`
-            /// and `preserve_len` respectively and `output` is treated as set.
-            rebase: bool,
-            block_aligning_len: bool,
-            block_aligning_splat: bool,
-            data_len: u18,
-            splat: u18,
-            data_off: u18,
+    while (true) {
+        const Op = packed struct {
+            drain: bool = false,
+            add_vec: bool = false,
+            rebase: bool = false,
+
+            pub const drain_only: @This() = .{ .drain = true };
+            pub const add_vec_only: @This() = .{ .add_vec = true };
+            pub const add_vec_and_drain: @This() = .{ .add_vec = true, .drain = true };
+            pub const drain_and_rebase: @This() = .{ .drain = true, .rebase = true };
         };
-        var vec_info: VecInfo = @bitCast(in.takeLeb128(u58) catch |e| switch (e) {
-            error.ReadFailed => unreachable,
-            error.Overflow, error.EndOfStream => 0,
-        });
 
-        {
-            const buffered = r.writer.buffered().len + countVec(vecs[0..vecs_n]);
-            const to_align = mem.alignForwardAnyAlign(usize, buffered, Raw.max_block_size) - buffered;
-            assert((buffered + to_align) % Raw.max_block_size == 0);
+        const is_eos = expected_size == max_size or smith.eosWeightedSimple(7, 1);
+        var op: Op = if (!is_eos) smith.valueWeighted(Op, &.{
+            .value(Op, .add_vec_only, 6),
+            .value(Op, .add_vec_and_drain, 1),
+            .value(Op, .drain_and_rebase, 1),
+        }) else .drain_only;
 
-            if (vec_info.block_aligning_len) {
-                vec_info.data_len = @intCast(to_align);
-            } else if (vec_info.block_aligning_splat and vec_info.data_len != 0 and
-                to_align % vec_info.data_len == 0)
-            {
-                vec_info.splat = @divExact(@as(u18, @intCast(to_align)), vec_info.data_len) -% 1;
-            }
-        }
+        if (op.add_vec) {
+            const max_write = max_size - expected_size;
+            const buffered: u32 = @intCast(raw.writer.buffered().len + countVec(vecs[0..vecs_n]));
+            const to_align = Raw.max_block_size - buffered % Raw.max_block_size;
+            assert(to_align != 0); // otherwise, not helpful.
 
-        var splat = if (vec_info.output and !vec_info.rebase) vec_info.splat +% 1 else 1;
-        add_vec: {
-            if (vec_info.rebase) break :add_vec;
-            if (expected_size +| math.mulWide(u18, vec_info.data_len, splat) >
-                10 * (1 << 16))
-            {
-                // Skip this vector to avoid this test taking too long.
-                // 10 maximum sized blocks is choosen as the limit since it is two more
-                // than the maximum the implementation can output in one drain.
-                splat = 1;
-                break :add_vec;
-            }
+            const max_data = @min(data_buf_len, max_write);
+            const len = smith.valueWeighted(u32, &.{
+                .rangeAtMost(u32, 0, max_data, 1),
+                .rangeAtMost(u32, 0, @min(Raw.max_block_size, max_data), 4),
+                .value(u32, @min(to_align, max_data), max_data), // @min 2nd arg is an edge-case
+            });
+            const off = smith.valueRangeAtMost(u32, 0, data_buf_len - len);
 
-            vecs[vecs_n] = data_buf[@min(
-                data_base +% vec_info.data_off,
-                data_buf.len - vec_info.data_len,
-            )..][0..vec_info.data_len];
-
-            data_base +%= vec_info.data_len +% 3; // extra 3 to help catch aliasing bugs
-
-            for (0..splat) |_| expected_hash.update(vecs[vecs_n]);
-            expected_size += @as(u32, @intCast(vecs[vecs_n].len)) * splat;
+            expected_size += len;
+            vecs[vecs_n] = data_buf[off..][0..len];
             vecs_n += 1;
+            op.drain |= vecs_n == vecs.len;
         }
 
-        const want_drain = vecs_n == vecs.len or vec_info.output or vec_info.rebase or
-            in.seek == in.end;
-        if (want_drain and vecs_n != 0) {
-            try r.writer.writeSplatAll(vecs[0..vecs_n], splat);
+        op.drain |= is_eos;
+        op.drain &= vecs_n != 0;
+        if (op.drain) {
+            const pattern_len: u32 = @intCast(vecs[vecs_n - 1].len);
+            const pattern_len_z = @max(pattern_len, 1);
+
+            const max_write = max_size - (expected_size - pattern_len);
+            const buffered: u32 = @intCast(raw.writer.buffered().len + countVec(vecs[0 .. vecs_n - 1]));
+            const to_align = Raw.max_block_size - buffered % Raw.max_block_size;
+            assert(to_align != 0); // otherwise, not helpful.
+
+            const max_splat = max_write / pattern_len_z;
+            const weights: [3]std.testing.Smith.Weight = .{
+                .rangeAtMost(u32, 0, max_splat, 1),
+                .rangeAtMost(u32, 0, @min(
+                    Raw.max_block_size + pattern_len_z,
+                    max_write,
+                ) / pattern_len_z, 4),
+                .value(u32, to_align / pattern_len_z, max_splat * 4),
+            };
+            const align_weight = to_align % pattern_len_z == 0 and to_align <= max_write;
+            const n_weights = @as(u8, 2) + @intFromBool(align_weight);
+            const splat = smith.valueWeighted(u32, weights[0..n_weights]);
+
+            expected_size = expected_size - pattern_len + pattern_len * splat; // splat may be zero
+            for (vecs[0 .. vecs_n - 1]) |v| expected_hash.update(v);
+            for (0..splat) |_| expected_hash.update(vecs[vecs_n - 1]);
+            try raw.writer.writeSplatAll(vecs[0..vecs_n], splat);
             vecs_n = 0;
-        } else assert(splat == 1);
+        }
 
-        if (vec_info.rebase) {
-            try r.writer.rebase(vec_info.data_len, @min(
-                r.writer.buffer.len -| vec_info.data_len,
-                vec_info.splat,
-            ));
+        if (op.rebase) {
+            const capacity = smith.valueRangeAtMost(u32, 0, raw_buf_len);
+            const preserve = smith.valueRangeAtMost(u32, 0, raw_buf_len - capacity);
+            try raw.writer.rebase(preserve, capacity);
         }
+
+        if (is_eos) break;
     }
 
-    try r.writer.flush();
+    try raw.writer.flush();
     try output.writer.flush();
 
     try std.testing.expectEqual(.end, output.state);
@@ -2432,120 +2402,146 @@ test Huffman {
     try std.testing.fuzz(fbufs, testFuzzedHuffmanInput, .{});
 }
 
+fn fuzzedHuffmanDrainSpaceLimit(max_drain: usize, written: usize, eos: bool) usize {
+    var block_lim = math.divCeil(usize, max_drain, Huffman.max_tokens) catch unreachable;
+    block_lim = @max(block_lim, @intFromBool(eos));
+    const footer_overhead = @as(u8, 8) * @intFromBool(eos);
+    // 6 for a raw block header (the block header may span two bytes)
+    return written + 6 * block_lim + max_drain + footer_overhead;
+}
+
 /// This function is derived from `testFuzzedRawInput` with a few changes for fuzzing `Huffman`.
-fn testFuzzedHuffmanInput(fbufs: *const [2][65536]u8, input: []const u8) !void {
-    var in: Io.Reader = .fixed(input);
-    const opts: packed struct(u19) {
-        container: PackedContainer,
-        buf_len: u17,
-    } = @bitCast(in.takeLeb128(u19) catch 0);
+fn testFuzzedHuffmanInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith) !void {
+    @disableInstrumentation();
+    const container = smith.value(flate.Container);
     var flate_buf: [2 * 65536]u8 = undefined;
     var flate_w: Writer = .fixed(&flate_buf);
-    var h_buf: [2 * 65536]u8 = undefined;
-    var h: Huffman = try .init(
-        &flate_w,
-        h_buf[0 .. opts.buf_len +% flate.max_window_len],
-        opts.container.val(),
-    );
-
-    var expected_hash: flate.Container.Hasher = .init(opts.container.val());
+    var expected_hash: flate.Container.Hasher = .init(container);
     var expected_size: u32 = 0;
+    const max_size = 4 * @as(u32, Huffman.max_tokens);
+
+    var h_buf: [2 * @as(usize, Huffman.max_tokens)]u8 = undefined;
+    const h_buf_len = smith.valueWeighted(u32, &.{
+        .value(u32, 0, @intCast(h_buf.len)), // unbuffered
+        .rangeAtMost(u32, 0, @intCast(h_buf.len), 1),
+    });
+    var h: Huffman = try .init(&flate_w, h_buf[0..h_buf_len], container);
+
     var vecs: [32][]const u8 = undefined;
     var vecs_n: usize = 0;
 
-    while (in.seek != in.end) {
-        const VecInfo = packed struct(u55) {
-            output: bool,
-            /// If set, `data_len` and `splat` are reinterpreted as `capacity`
-            /// and `preserve_len` respectively and `output` is treated as set.
-            rebase: bool,
-            block_aligning_len: bool,
-            block_aligning_splat: bool,
-            data_off_hi: u8,
-            random_data: u1,
-            data_len: u16,
-            splat: u18,
-            /// This is less useful as each value is part of the same gradient 'step'
-            data_off_lo: u8,
+    while (true) {
+        const Op = packed struct {
+            drain: bool = false,
+            add_vec: bool = false,
+            rebase: bool = false,
+
+            pub const drain_only: @This() = .{ .drain = true };
+            pub const add_vec_only: @This() = .{ .add_vec = true };
+            pub const add_vec_and_drain: @This() = .{ .add_vec = true, .drain = true };
+            pub const drain_and_rebase: @This() = .{ .drain = true, .rebase = true };
         };
-        var vec_info: VecInfo = @bitCast(in.takeLeb128(u55) catch |e| switch (e) {
-            error.ReadFailed => unreachable,
-            error.Overflow, error.EndOfStream => 0,
-        });
 
-        {
-            const buffered = h.writer.buffered().len + countVec(vecs[0..vecs_n]);
-            const to_align = mem.alignForwardAnyAlign(usize, buffered, Huffman.max_tokens) - buffered;
-            assert((buffered + to_align) % Huffman.max_tokens == 0);
+        const is_eos = expected_size == max_size or smith.eosWeightedSimple(7, 1);
+        var op: Op = if (!is_eos) smith.valueWeighted(Op, &.{
+            .value(Op, .add_vec_only, 6),
+            .value(Op, .add_vec_and_drain, 1),
+            .value(Op, .drain_and_rebase, 1),
+        }) else .drain_only;
 
-            if (vec_info.block_aligning_len) {
-                vec_info.data_len = @intCast(to_align);
-            } else if (vec_info.block_aligning_splat and vec_info.data_len != 0 and
-                to_align % vec_info.data_len == 0)
-            {
-                vec_info.splat = @divExact(@as(u18, @intCast(to_align)), vec_info.data_len) -% 1;
-            }
-        }
+        if (op.add_vec) {
+            const max_write = max_size - expected_size;
+            const buffered: u32 = @intCast(h.writer.buffered().len + countVec(vecs[0..vecs_n]));
+            const to_align = Huffman.max_tokens - buffered % Huffman.max_tokens;
+            assert(to_align != 0); // otherwise, not helpful.
 
-        var splat = if (vec_info.output and !vec_info.rebase) vec_info.splat +% 1 else 1;
-        add_vec: {
-            if (vec_info.rebase) break :add_vec;
-            if (expected_size +| math.mulWide(u18, vec_info.data_len, splat) > 4 * (1 << 16)) {
-                // Skip this vector to avoid this test taking too long.
-                splat = 1;
-                break :add_vec;
-            }
+            const data_buf = &fbufs[
+                smith.valueWeighted(u1, &.{
+                    .value(FreqBufIndex, .gradient, 3),
+                    .value(FreqBufIndex, .random, 1),
+                })
+            ];
+            const data_buf_len: u32 = @intCast(data_buf.len);
 
-            const data_buf = &fbufs[vec_info.random_data];
-            vecs[vecs_n] = data_buf[@min(
-                (@as(u16, vec_info.data_off_hi) << 8) | vec_info.data_off_lo,
-                data_buf.len - vec_info.data_len,
-            )..][0..vec_info.data_len];
+            const max_data = @min(data_buf_len, max_write);
+            const len = smith.valueWeighted(u32, &.{
+                .rangeAtMost(u32, 0, max_data, 1),
+                .rangeAtMost(u32, 0, @min(Huffman.max_tokens, max_data), 4),
+                .value(u32, @min(to_align, max_data), max_data), // @min 2nd arg is an edge-case
+            });
+            const off = smith.valueRangeAtMost(u32, 0, data_buf_len - len);
 
-            for (0..splat) |_| expected_hash.update(vecs[vecs_n]);
-            expected_size += @as(u32, @intCast(vecs[vecs_n].len)) * splat;
+            expected_size += len;
+            vecs[vecs_n] = data_buf[off..][0..len];
             vecs_n += 1;
+            op.drain |= vecs_n == vecs.len;
         }
 
-        const want_drain = vecs_n == vecs.len or vec_info.output or vec_info.rebase or
-            in.seek == in.end;
-        if (want_drain and vecs_n != 0) {
-            var n = h.writer.buffered().len + Writer.countSplat(vecs[0..vecs_n], splat);
-            const oos = h.writer.writeSplatAll(vecs[0..vecs_n], splat) == error.WriteFailed;
-            n -= h.writer.buffered().len;
-            const block_lim = math.divCeil(usize, n, Huffman.max_tokens) catch unreachable;
-            const lim = flate_w.end + 6 * block_lim + n; // 6 since block header may span two bytes
-            if (flate_w.end > lim) return error.OverheadTooLarge;
-            if (oos) return;
+        op.drain |= is_eos;
+        op.drain &= vecs_n != 0;
+        if (op.drain) {
+            const pattern_len: u32 = @intCast(vecs[vecs_n - 1].len);
+            const pattern_len_z = @max(pattern_len, 1);
+
+            const max_write = max_size - (expected_size - pattern_len);
+            const buffered: u32 = @intCast(h.writer.buffered().len + countVec(vecs[0 .. vecs_n - 1]));
+            const to_align = Huffman.max_tokens - buffered % Huffman.max_tokens;
+            assert(to_align != 0); // otherwise, not helpful.
+
+            const max_splat = max_write / pattern_len_z;
+            const weights: [3]std.testing.Smith.Weight = .{
+                .rangeAtMost(u32, 0, max_splat, 1),
+                .rangeAtMost(u32, 0, @min(
+                    Huffman.max_tokens + pattern_len_z,
+                    max_write,
+                ) / pattern_len_z, 4),
+                .value(u32, to_align / pattern_len_z, max_splat * 4),
+            };
+            const align_weight = to_align % pattern_len_z == 0 and to_align <= max_write;
+            const n_weights = @as(u8, 2) + @intFromBool(align_weight);
+            const splat = smith.valueWeighted(u32, weights[0..n_weights]);
+
+            expected_size = expected_size - pattern_len + pattern_len * splat; // splat may be zero
+            for (vecs[0 .. vecs_n - 1]) |v| expected_hash.update(v);
+            for (0..splat) |_| expected_hash.update(vecs[vecs_n - 1]);
+
+            const max_space = fuzzedHuffmanDrainSpaceLimit(
+                buffered + pattern_len * splat,
+                flate_w.buffered().len,
+                false,
+            );
+            h.writer.writeSplatAll(vecs[0..vecs_n], splat) catch
+                return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {};
+            if (flate_w.buffered().len > max_space) return error.OverheadTooLarge;
 
             vecs_n = 0;
-        } else assert(splat == 1);
+        }
+
+        if (op.rebase) {
+            const capacity = smith.valueRangeAtMost(u32, 0, h_buf_len);
+            const preserve = smith.valueRangeAtMost(u32, 0, h_buf_len - capacity);
 
-        if (vec_info.rebase) {
-            const old_end = flate_w.end;
-            var n = h.writer.buffered().len;
-            const oos = h.writer.rebase(vec_info.data_len, @min(
-                h.writer.buffer.len -| vec_info.data_len,
-                vec_info.splat,
-            )) == error.WriteFailed;
-            n -= h.writer.buffered().len;
-            const block_lim = math.divCeil(usize, n, Huffman.max_tokens) catch unreachable;
-            const lim = old_end + 6 * block_lim + n; // 6 since block header may span two bytes
-            if (flate_w.end > lim) return error.OverheadTooLarge;
-            if (oos) return;
+            const max_space = fuzzedHuffmanDrainSpaceLimit(
+                h.writer.buffered().len,
+                flate_w.buffered().len,
+                false,
+            );
+            h.writer.rebase(preserve, capacity) catch
+                return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {};
+            if (flate_w.buffered().len > max_space) return error.OverheadTooLarge;
         }
-    }
 
-    {
-        const old_end = flate_w.end;
-        const n = h.writer.buffered().len;
-        const oos = h.writer.flush() == error.WriteFailed;
-        assert(h.writer.buffered().len == 0);
-        const block_lim = @max(1, math.divCeil(usize, n, Huffman.max_tokens) catch unreachable);
-        const lim = old_end + 6 * block_lim + n + opts.container.val().footerSize();
-        if (flate_w.end > lim) return error.OverheadTooLarge;
-        if (oos) return;
+        if (is_eos) break;
     }
 
+    const max_space = fuzzedHuffmanDrainSpaceLimit(
+        h.writer.buffered().len,
+        flate_w.buffered().len,
+        true,
+    );
+    h.writer.flush() catch
+        return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {};
+    if (flate_w.buffered().len > max_space) return error.OverheadTooLarge;
+
     try testingCheckDecompressedMatches(flate_w.buffered(), expected_size, expected_hash);
 }
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 3f40e3cd1e4dee13ccf475f43247382cbf6eeed7..702eb5857be77a20e26828af9f42304b56014d36 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -417,6 +417,7 @@ pub const CpuContextPtr = if (cpu_context.Native == noreturn) noreturn else *con
 /// ReleaseFast and ReleaseSmall mode. Outside of a test block, this assert
 /// function is the correct function to use.
 pub fn assert(ok: bool) void {
+    @disableInstrumentation();
     if (!ok) unreachable; // assertion failure
 }
 
diff --git a/lib/std/deque.zig b/lib/std/deque.zig
index 2d4cfc8600ef07c20660c3a1eb0f680089f58854..d15aa5e55690e0de4320f4ad991e149c1a0a2c50 100644
--- a/lib/std/deque.zig
+++ b/lib/std/deque.zig
@@ -518,55 +518,139 @@ test "fuzz against ArrayList oracle" {
     try std.testing.fuzz({}, fuzzAgainstArrayList, .{});
 }
 
-test "dumb fuzz against ArrayList oracle" {
-    const testing = std.testing;
-    const gpa = testing.allocator;
+const FuzzAllocator = struct {
+    smith: *std.testing.Smith,
+    bufs: [2][256 * 4]u8 align(4),
+    used_bitmap: u2,
+    used_len: [2]usize,
+
+    pub fn init(smith: *std.testing.Smith) FuzzAllocator {
+        return .{
+            .smith = smith,
+            .bufs = undefined,
+            .used_len = undefined,
+            .used_bitmap = 0,
+        };
+    }
+
+    pub fn allocator(f: *FuzzAllocator) std.mem.Allocator {
+        return .{
+            .ptr = f,
+            .vtable = &.{
+                .alloc = alloc,
+                .resize = resize,
+                .remap = remap,
+                .free = free,
+            },
+        };
+    }
+
+    pub fn allocCount(f: *FuzzAllocator) u2 {
+        return @popCount(f.used_bitmap);
+    }
+
+    fn alloc(ctx: *anyopaque, len: usize, a: std.mem.Alignment, _: usize) ?[*]u8 {
+        const f: *FuzzAllocator = @ptrCast(@alignCast(ctx));
+        assert(a == .@"4");
+        assert(len % 4 == 0);
+
+        const slot: u1 = @intCast(@ctz(~f.used_bitmap));
+        const buf: []u8 = &f.bufs[slot];
+        if (len > buf.len) return null;
+        f.used_bitmap |= @as(u2, 1) << slot;
+        f.used_len[slot] = len;
+        return buf.ptr;
+    }
 
-    const input = try gpa.alloc(u8, 1024);
-    defer gpa.free(input);
+    fn memSlot(f: *FuzzAllocator, mem: []u8) u1 {
+        const slot: u1 = if (&mem[0] == &f.bufs[0][0])
+            0
+        else if (&mem[0] == &f.bufs[1][0])
+            1
+        else
+            unreachable;
+        assert((f.used_bitmap >> slot) & 1 == 1);
+        assert(mem.len == f.used_len[slot]);
+        return slot;
+    }
 
-    var prng = std.Random.DefaultPrng.init(testing.random_seed);
-    prng.random().bytes(input);
+    fn resize(ctx: *anyopaque, mem: []u8, a: std.mem.Alignment, new_len: usize, _: usize) bool {
+        const f: *FuzzAllocator = @ptrCast(@alignCast(ctx));
+        assert(a == .@"4");
+        assert(f.allocCount() == 1);
 
-    try fuzzAgainstArrayList({}, input);
-}
+        const slot = f.memSlot(mem);
+        if (new_len > f.bufs[slot].len or f.smith.value(bool)) return false;
+        f.used_len[slot] = new_len;
+        return true;
+    }
 
-fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
+    fn remap(ctx: *anyopaque, mem: []u8, a: std.mem.Alignment, new_len: usize, _: usize) ?[*]u8 {
+        const f: *FuzzAllocator = @ptrCast(@alignCast(ctx));
+        assert(a == .@"4");
+        assert(f.allocCount() == 1);
+
+        const slot = f.memSlot(mem);
+        if (new_len > f.bufs[slot].len or f.smith.value(bool)) return null;
+
+        if (f.smith.value(bool)) {
+            f.used_len[slot] = new_len;
+            // remap in place
+            return mem.ptr;
+        } else {
+            // moving remap
+            const new_slot = ~slot;
+            f.used_bitmap = ~f.used_bitmap;
+            f.used_len[new_slot] = new_len;
+
+            const new_buf = &f.bufs[new_slot];
+            @memcpy(new_buf[0..mem.len], mem);
+            return new_buf.ptr;
+        }
+    }
+
+    fn free(ctx: *anyopaque, mem: []u8, a: std.mem.Alignment, _: usize) void {
+        const f: *FuzzAllocator = @ptrCast(@alignCast(ctx));
+        assert(a == .@"4");
+        f.used_bitmap ^= @as(u2, 1) << f.memSlot(mem);
+    }
+};
+
+fn fuzzAgainstArrayList(_: void, smith: *std.testing.Smith) anyerror!void {
     const testing = std.testing;
-    const gpa = testing.allocator;
+
+    var q_gpa_inst: FuzzAllocator = .init(smith);
+    var l_gpa_buf: [q_gpa_inst.bufs[0].len]u8 align(4) = undefined;
+    var l_gpa_inst: std.heap.FixedBufferAllocator = .init(&l_gpa_buf);
+    const q_gpa = q_gpa_inst.allocator();
+    const l_gpa = l_gpa_inst.allocator();
 
     var q: Deque(u32) = .empty;
-    defer q.deinit(gpa);
     var l: std.ArrayList(u32) = .empty;
-    defer l.deinit(gpa);
 
-    if (input.len < 2) return;
-
-    var prng = std.Random.DefaultPrng.init(input[0]);
-    const random = prng.random();
-
-    const Action = enum {
+    const Action = enum(u8) {
+        grow,
         push_back,
         push_front,
         push_back_slice,
         push_front_slice,
         pop_back,
         pop_front,
-        grow,
-        /// Sentinel to avoid hardcoding the cast below
-        max,
     };
-    for (input[1..]) |byte| {
-        switch (@as(Action, @enumFromInt(byte % (@intFromEnum(Action.max))))) {
+
+    while (!smith.eosWeightedSimple(15, 1)) {
+        const baseline = testing.Smith.baselineWeights(Action);
+        const grow_weight: testing.Smith.Weight = .value(Action, .grow, 3);
+        switch (smith.valueWeighted(Action, baseline ++ .{grow_weight})) {
             .push_back => {
-                const item = random.int(u8);
+                const item = smith.value(u32);
                 try testing.expectEqual(
                     l.appendBounded(item),
                     q.pushBackBounded(item),
                 );
             },
             .push_front => {
-                const item = random.int(u8);
+                const item = smith.value(u32);
                 try testing.expectEqual(
                     l.insertBounded(0, item),
                     q.pushFrontBounded(item),
@@ -574,9 +658,9 @@ fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
             },
             .push_back_slice => {
                 var buffer: [std.math.maxInt(u3)]u32 = undefined;
-                const items = buffer[0..random.int(u3)];
+                const items = buffer[0..smith.value(u3)];
                 for (items) |*item| {
-                    item.* = random.int(u8);
+                    item.* = smith.value(u32);
                 }
                 try testing.expectEqual(
                     l.appendSliceBounded(items),
@@ -585,9 +669,9 @@ fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
             },
             .push_front_slice => {
                 var buffer: [std.math.maxInt(u3)]u32 = undefined;
-                const items = buffer[0..random.int(u3)];
+                const items = buffer[0..smith.value(u3)];
                 for (items) |*item| {
-                    item.* = random.int(u8);
+                    item.* = smith.value(u32);
                 }
                 try testing.expectEqual(
                     l.insertSliceBounded(0, items),
@@ -607,11 +691,10 @@ fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
             // ensureTotalCapacityPrecise(), which is the most complex part
             // of the Deque implementation.
             .grow => {
-                const growth = random.int(u3);
-                try l.ensureTotalCapacityPrecise(gpa, l.items.len + growth);
-                try q.ensureTotalCapacityPrecise(gpa, q.len + growth);
+                const growth = smith.value(u3);
+                try l.ensureTotalCapacityPrecise(l_gpa, l.items.len + growth);
+                try q.ensureTotalCapacityPrecise(q_gpa, q.len + growth);
             },
-            .max => unreachable,
         }
         try testing.expectEqual(l.getLastOrNull(), q.back());
         try testing.expectEqual(
@@ -627,5 +710,8 @@ fn fuzzAgainstArrayList(_: void, input: []const u8) anyerror!void {
             }
             try testing.expectEqual(null, it.next());
         }
+        try testing.expectEqual(@intFromBool(q.buffer.len != 0), q_gpa_inst.allocCount());
     }
+    q.deinit(q_gpa);
+    try testing.expectEqual(0, q_gpa_inst.allocCount());
 }
diff --git a/lib/std/json/scanner_test.zig b/lib/std/json/scanner_test.zig
index 5b4bfa532ae7660d16b0c2ce379fab53581bdc7a..3be71b2cb925bf19117d2cbd288455e7808379c3 100644
--- a/lib/std/json/scanner_test.zig
+++ b/lib/std/json/scanner_test.zig
@@ -490,20 +490,3 @@ test isNumberFormattedLikeAnInteger {
     try std.testing.expect(!isNumberFormattedLikeAnInteger("1e10"));
     try std.testing.expect(!isNumberFormattedLikeAnInteger("1E10"));
 }
-
-test "fuzz" {
-    try std.testing.fuzz({}, fuzzTestOne, .{});
-}
-
-fn fuzzTestOne(_: void, input: []const u8) !void {
-    var buf: [16384]u8 = undefined;
-    var fba: std.heap.FixedBufferAllocator = .init(&buf);
-
-    var scanner = Scanner.initCompleteInput(fba.allocator(), input);
-    // Property: There are at most input.len tokens
-    var tokens: usize = 0;
-    while ((scanner.next() catch return) != .end_of_document) {
-        tokens += 1;
-        if (tokens > input.len) return error.Overflow;
-    }
-}
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 317256fcee6f6b1f56aa1a631fce3c536356a4ac..09919f8b69220c51607e875dee868ea6a048d1a5 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -1203,6 +1203,8 @@ pub fn refAllDecls(comptime T: type) void {
     }
 }
 
+pub const Smith = @import("testing/Smith.zig");
+
 pub const FuzzInputOptions = struct {
     corpus: []const []const u8 = &.{},
 };
@@ -1210,7 +1212,7 @@ pub const FuzzInputOptions = struct {
 /// Inline to avoid coverage instrumentation.
 pub inline fn fuzz(
     context: anytype,
-    comptime testOne: fn (context: @TypeOf(context), input: []const u8) anyerror!void,
+    comptime testOne: fn (context: @TypeOf(context), smith: *Smith) anyerror!void,
     options: FuzzInputOptions,
 ) anyerror!void {
     return @import("root").fuzz(context, testOne, options);
@@ -1317,3 +1319,7 @@ pub const ReaderIndirect = struct {
         };
     }
 };
+
+test {
+    _ = &Smith;
+}
diff --git a/lib/std/testing/Smith.zig b/lib/std/testing/Smith.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9b1574282b3ad53d7b35bbcdf61cd8261432b2f0
--- /dev/null
+++ b/lib/std/testing/Smith.zig
@@ -0,0 +1,895 @@
+//! Used in conjuncation with `std.testing.fuzz` to generate values
+
+const builtin = @import("builtin");
+const std = @import("../std.zig");
+const assert = std.debug.assert;
+const fuzz_abi = std.Build.abi.fuzz;
+const Smith = @This();
+
+/// Null if the fuzzer is being used, in which case this struct will not be mutated.
+///
+/// Intended to be initialized directly.
+in: ?[]const u8,
+
+pub const Weight = fuzz_abi.Weight;
+
+fn intUid(hash: u32) fuzz_abi.Uid {
+    @disableInstrumentation();
+    return @bitCast(hash << 1);
+}
+
+fn bytesUid(hash: u32) fuzz_abi.Uid {
+    @disableInstrumentation();
+    return @bitCast(hash | 1);
+}
+
+fn Backing(T: type) type {
+    return @Int(.unsigned, @bitSizeOf(T));
+}
+
+fn toExcessK(T: type, x: T) Backing(T) {
+    return @bitCast(x -% std.math.minInt(T));
+}
+
+fn fromExcessK(T: type, x: Backing(T)) T {
+    return @as(T, @bitCast(x)) +% std.math.minInt(T);
+}
+
+fn enumFieldLessThan(_: void, a: std.builtin.Type.EnumField, b: std.builtin.Type.EnumField) bool {
+    return a.value < b.value;
+}
+
+/// Returns an array of weights containing each possible value of `T`.
+//
+// `inline` to propogate the `comptime`ness of the result
+pub inline fn baselineWeights(T: type) []const Weight {
+    return comptime switch (@typeInfo(T)) {
+        .bool, .int, .float => i: {
+            // Reject types that don't have a fixed bitsize (esp. usize)
+            // since they are not gauraunteed to fit in a u64 across targets.
+            if (std.mem.indexOfScalar(type, &.{
+                isize,      usize,
+                c_char,     c_longdouble,
+                c_short,    c_ushort,
+                c_int,      c_uint,
+                c_long,     c_ulong,
+                c_longlong, c_ulonglong,
+            }, T) != null) {
+                @compileError("type does not have a fixed bitsize: " ++ @typeName(T));
+            }
+            break :i &.{.rangeAtMost(Backing(T), 0, (1 << @bitSizeOf(T)) - 1, 1)};
+        },
+        .@"struct" => |s| if (s.backing_integer) |B|
+            baselineWeights(B)
+        else
+            @compileError("non-packed structs cannot be weighted"),
+        .@"union" => |u| if (u.layout == .@"packed")
+            baselineWeights(Backing(T))
+        else
+            @compileError("non-packed unions cannot be weighted"),
+        .@"enum" => |e| if (!e.is_exhaustive)
+            baselineWeights(e.tag_type)
+        else if (e.fields.len == 0)
+            // Cannot be included in below branch due to `log2_int_ceil`
+            @compileError("exhaustive zero-field enums cannot be weighted")
+        else e: {
+            @setEvalBranchQuota(@intCast(4 * e.fields.len *
+                std.math.log2_int_ceil(usize, e.fields.len)));
+
+            var sorted_fields = e.fields[0..e.fields.len].*;
+            std.mem.sortUnstable(std.builtin.Type.EnumField, &sorted_fields, {}, enumFieldLessThan);
+
+            var weights: []const Weight = &.{};
+            var seq_first: u64 = sorted_fields[0].value;
+            for (sorted_fields[0 .. sorted_fields.len - 1], sorted_fields[1..]) |prev, field| {
+                if (field.value != prev.value + 1) {
+                    weights = weights ++ .{Weight.rangeAtMost(u64, seq_first, prev.value, 1)};
+                    seq_first = field.value;
+                }
+            }
+            weights = weights ++ .{Weight.rangeAtMost(
+                u64,
+                seq_first,
+                sorted_fields[sorted_fields.len - 1].value,
+                1,
+            )};
+
+            break :e weights;
+        },
+        else => @compileError("unexpected type: " ++ @typeName(T)),
+    };
+}
+
+test baselineWeights {
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(bool, false, true, 1)},
+        baselineWeights(bool),
+    );
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(u4, 0, 15, 1)},
+        baselineWeights(u4),
+    );
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(u4, 0, 15, 1)},
+        baselineWeights(i4),
+    );
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(u16, 0, 0xffff, 1)},
+        baselineWeights(f16),
+    );
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(u4, 0, 15, 1)},
+        baselineWeights(packed struct(u4) { _: u4 }),
+    );
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(u4, 0, 15, 1)},
+        baselineWeights(packed union { _: u4 }),
+    );
+    try std.testing.expectEqualSlices(
+        Weight,
+        &.{.rangeAtMost(u4, 0, 15, 1)},
+        baselineWeights(enum(u4) { _ }),
+    );
+    try std.testing.expectEqualSlices(Weight, &.{
+        .rangeAtMost(u4, 0, 1, 1),
+        .value(u4, 3, 1),
+        .value(u4, 5, 1),
+        .rangeAtMost(u4, 8, 10, 1),
+    }, baselineWeights(enum(u4) {
+        a = 1,
+        b = 5,
+        c = 8,
+        d = 3,
+        e = 0,
+        f = 9,
+        g = 10,
+    }));
+}
+
+fn valueFromInt(T: anytype, int: Backing(T)) T {
+    @disableInstrumentation();
+    return switch (@typeInfo(T)) {
+        .@"enum" => @enumFromInt(int),
+        else => @bitCast(int),
+    };
+}
+
+fn checkWeights(weights: []const Weight, max_incl: u64) void {
+    @disableInstrumentation();
+    const w0 = weights[0]; // Sum of weights is zero
+    assert(w0.weight != 0);
+    assert(w0.max <= max_incl);
+
+    var incl_sum: u64 = (w0.max - w0.min) * w0.weight + (w0.weight - 1); // Sum of weights greater than 2^64
+    for (weights[1..]) |w| {
+        assert(w.weight != 0);
+        assert(w.max <= max_incl);
+        // This addition will not overflow except with an illegal combination of weights since
+        // the exclusive sum must be at least one so a span of all values is impossible.
+        incl_sum += (w.max - w.min + 1) * w.weight; // Sum of weights greater than 2^64
+    }
+}
+
+// `inline` to propogate callee's unique return address
+inline fn firstHash() u32 {
+    return @truncate(std.hash.int(@returnAddress()));
+}
+
+// `noinline` to capture a unique return address
+pub noinline fn value(s: *Smith, T: type) T {
+    @disableInstrumentation();
+    return s.valueWithHash(T, firstHash());
+}
+
+// `noinline` to capture a unique return address
+pub noinline fn valueWeighted(s: *Smith, T: type, weights: []const Weight) T {
+    @disableInstrumentation();
+    return s.valueWeightedWithHash(T, weights, firstHash());
+}
+
+// `noinline` to capture a unique return address
+pub noinline fn valueRangeAtMost(s: *Smith, T: type, at_least: T, at_most: T) T {
+    @disableInstrumentation();
+    return s.valueRangeAtMostWithHash(T, at_least, at_most, firstHash());
+}
+
+// `noinline` to capture a unique return address
+pub noinline fn valueRangeLessThan(s: *Smith, T: type, at_least: T, less_than: T) T {
+    @disableInstrumentation();
+    return s.valueRangeLessThanWithHash(T, at_least, less_than, firstHash());
+}
+
+/// This is similar to `value(bool)` however it is gauraunteed to eventually
+/// return `true` and provides the fuzzer with an extra hint about the data.
+//
+// `noinline` to capture a unique return address
+pub noinline fn eos(s: *Smith) bool {
+    @disableInstrumentation();
+    return s.eosWithHash(firstHash());
+}
+
+/// This is similar to `value(bool)` however it is gauraunteed to eventually
+/// return `true` and provides the fuzzer with an extra hint about the data.
+///
+/// It is asserted that the weight of `true` is non-zero.
+//
+// `noinline` to capture a unique return address
+pub noinline fn eosWeighted(s: *Smith, weights: []const Weight) bool {
+    @disableInstrumentation();
+    return s.eosWeightedWithHash(weights, firstHash());
+}
+
+/// This is similar to `value(bool)` however it is gauraunteed to eventually
+/// return `true` and provides the fuzzer with an extra hint about the data.
+///
+/// It is asserted that the weight of `true` is non-zero.
+//
+// `noinline` to capture a unique return address
+pub noinline fn eosWeightedSimple(s: *Smith, false_weight: u64, true_weight: u64) bool {
+    @disableInstrumentation();
+    return s.eosWeightedSimpleWithHash(false_weight, true_weight, firstHash());
+}
+
+// `noinline` to capture a unique return address
+pub noinline fn bytes(s: *Smith, out: []u8) void {
+    @disableInstrumentation();
+    return s.bytesWithHash(out, firstHash());
+}
+
+// `noinline` to capture a unique return address
+pub noinline fn bytesWeighted(s: *Smith, out: []u8, weights: []const Weight) void {
+    @disableInstrumentation();
+    return s.bytesWeightedWithHash(out, weights, firstHash());
+}
+
+/// Returns the length of the filled slice
+///
+/// It is asserted that `buf.len` fits within a u32
+// `noinline` to capture a unique return address
+pub noinline fn slice(s: *Smith, buf: []u8) u32 {
+    @disableInstrumentation();
+    return s.sliceWithHash(buf, firstHash());
+}
+
+/// Returns the length of the filled slice
+///
+/// It is asserted that `buf.len` fits within a u32
+//
+// `noinline` to capture a unique return address
+pub noinline fn sliceWeightedBytes(s: *Smith, buf: []u8, byte_weights: []const Weight) u32 {
+    @disableInstrumentation();
+    return s.sliceWeightedBytesWithHash(buf, byte_weights, firstHash());
+}
+
+/// Returns the length of the filled slice
+///
+/// It is asserted that `buf.len` fits within a u32
+//
+// `noinline` to capture a unique return address
+pub noinline fn sliceWeighted(
+    s: *Smith,
+    buf: []u8,
+    len_weights: []const Weight,
+    byte_weights: []const Weight,
+) u32 {
+    @disableInstrumentation();
+    return s.sliceWeightedWithHash(buf, len_weights, byte_weights, firstHash());
+}
+
+fn weightsContain(int: u64, weights: []const Weight) bool {
+    @disableInstrumentation();
+    var contains: bool = false;
+    for (weights) |w| {
+        contains |= w.min <= int and int <= w.max;
+    }
+    return contains;
+}
+
+/// Asserts `T` can be a member of a packed type
+//
+// `inline` to propogate the `comptime`ness of the result
+inline fn allBitPatternsValid(T: type) bool {
+    return comptime switch (@typeInfo(T)) {
+        .void, .bool, .int, .float => true,
+        inline .@"struct", .@"union" => |c| c.layout == .@"packed" and for (c.fields) |f| {
+            if (!allBitPatternsValid(f.type)) break false;
+        } else true,
+        .@"enum" => |e| !e.is_exhaustive,
+        else => unreachable,
+    };
+}
+
+test allBitPatternsValid {
+    try std.testing.expect(allBitPatternsValid(packed struct {
+        a: void,
+        b: u8,
+        c: f16,
+        d: packed union {
+            a: u16,
+            b: i16,
+            c: f16,
+        },
+        e: enum(u4) { _ },
+    }));
+    try std.testing.expect(!allBitPatternsValid(packed union {
+        a: i4,
+        b: enum(u4) { a },
+    }));
+}
+
+fn UnionTagWithoutUninitializable(T: type) type {
+    const u = @typeInfo(T).@"union";
+    const Tag = u.tag_type orelse @compileError("union must have tag");
+    const e = @typeInfo(Tag).@"enum";
+    var field_names: [e.fields.len][]const u8 = undefined;
+    var field_values: [e.fields.len]e.tag_type = undefined;
+    var n_fields = 0;
+    for (u.fields) |f| {
+        switch (f.type) {
+            noreturn => continue,
+            else => {},
+        }
+        field_names[n_fields] = f.name;
+        field_values[n_fields] = @intFromEnum(@field(Tag, f.name));
+        n_fields += 1;
+    }
+    return @Enum(e.tag_type, .exhaustive, field_names[0..n_fields], field_values[0..n_fields]);
+}
+
+pub fn valueWithHash(s: *Smith, T: type, hash: u32) T {
+    @disableInstrumentation();
+    return switch (@typeInfo(T)) {
+        .void => {},
+        .bool, .int, .float => full: {
+            var int: Backing(T) = 0;
+            comptime var biti = 0;
+            var rhash = hash; // 'running' hash
+            inline while (biti < @bitSizeOf(T)) {
+                const n = @min(@bitSizeOf(T) - biti, 64);
+                const P = @Int(.unsigned, n);
+                int |= @as(
+                    @TypeOf(int),
+                    s.valueWeightedWithHash(P, baselineWeights(P), rhash),
+                ) << biti;
+                biti += n;
+                rhash = std.hash.int(rhash);
+            }
+            break :full @bitCast(int);
+        },
+        .@"enum" => |e| if (e.is_exhaustive) v: {
+            if (@bitSizeOf(e.tag_type) <= 64) {
+                break :v s.valueWeightedWithHash(T, baselineWeights(T), hash);
+            }
+            break :v std.enums.fromInt(T, s.valueWithHash(e.tag_type, hash)) orelse
+                @enumFromInt(e.fields[0].value);
+        } else @enumFromInt(s.valueWithHash(e.tag_type, hash)),
+        .optional => |o| if (s.valueWithHash(bool, hash))
+            null
+        else
+            s.valueWithHash(o.child, std.hash.int(hash)),
+        inline .array, .vector => |a| arr: {
+            var arr: [a.len]a.child = undefined; // `T` cannot be used due to the vector case
+            if (a.child != u8) {
+                for (&arr) |*v| {
+                    v.* = s.valueWithHash(a.child, hash);
+                }
+            } else {
+                s.bytesWithHash(&arr, hash);
+            }
+            break :arr arr;
+        },
+        .@"struct" => |st| if (!allBitPatternsValid(T)) v: {
+            var v: T = undefined;
+            var rhash = hash;
+            inline for (st.fields) |f| {
+                // rhash is incremented in the call so our rhash state is not reused (e.g. with
+                // two nested structs. note that xor cannot work for this case as the bit would
+                // be flipped back here)
+                @field(v, f.name) = s.valueWithHash(f.type, rhash +% 1);
+                rhash = std.hash.int(rhash);
+            }
+            break :v v;
+        } else @bitCast(s.valueWithHash(st.backing_integer.?, hash)),
+        .@"union" => if (!allBitPatternsValid(T))
+            switch (s.valueWithHash(
+                UnionTagWithoutUninitializable(T),
+                // hash is incremented in the call so our hash state is not reused for below
+                std.hash.int(hash +% 1),
+            )) {
+                inline else => |t| @unionInit(
+                    T,
+                    @tagName(t),
+                    s.valueWithHash(@FieldType(T, @tagName(t)), hash),
+                ),
+            }
+        else
+            @bitCast(s.valueWithHash(Backing(T), hash)),
+        else => @compileError("unexpected type '" ++ @typeName(T) ++ "'"),
+    };
+}
+
+pub fn valueWeightedWithHash(s: *Smith, T: type, weights: []const Weight, hash: u32) T {
+    @disableInstrumentation();
+    checkWeights(weights, (1 << @bitSizeOf(T)) - 1);
+    return valueFromInt(T, @intCast(s.valueWeightedWithHashInner(weights, hash)));
+}
+
+fn valueWeightedWithHashInner(s: *Smith, weights: []const Weight, hash: u32) u64 {
+    @disableInstrumentation();
+    return if (s.in) |*in| int: {
+        if (in.len < 8) {
+            @branchHint(.unlikely);
+            in.* = &.{};
+            break :int weights[0].min;
+        }
+        const int = std.mem.readInt(u64, in.*[0..8], .little);
+        in.* = in.*[8..];
+        break :int if (weightsContain(int, weights)) int else weights[0].min;
+    } else if (builtin.fuzz) int: {
+        @branchHint(.likely);
+        break :int fuzz_abi.fuzzer_int(intUid(hash), .fromSlice(weights));
+    } else unreachable;
+}
+
+pub fn valueRangeAtMostWithHash(s: *Smith, T: type, at_least: T, at_most: T, hash: u32) T {
+    @disableInstrumentation();
+    if (@typeInfo(T) == .int and @typeInfo(T).int.signedness == .signed) {
+        return fromExcessK(T, s.valueRangeAtMostWithHash(
+            Backing(T),
+            toExcessK(T, at_least),
+            toExcessK(T, at_most),
+            hash,
+        ));
+    }
+    return s.valueWeightedWithHash(T, &.{.rangeAtMost(T, at_least, at_most, 1)}, hash);
+}
+
+pub fn valueRangeLessThanWithHash(s: *Smith, T: type, at_least: T, less_than: T, hash: u32) T {
+    @disableInstrumentation();
+    if (@typeInfo(T) == .int and @typeInfo(T).int.signedness == .signed) {
+        return fromExcessK(T, s.valueRangeLessThanWithHash(
+            Backing(T),
+            toExcessK(T, at_least),
+            toExcessK(T, less_than),
+            hash,
+        ));
+    }
+    return s.valueWeightedWithHash(T, &.{.rangeLessThan(T, at_least, less_than, 1)}, hash);
+}
+
+/// This is similar to `value(bool)` however it is gauraunteed to eventually
+/// return `true` and provides the fuzzer with an extra hint about the data.
+pub fn eosWithHash(s: *Smith, hash: u32) bool {
+    @disableInstrumentation();
+    return s.eosWeightedWithHash(baselineWeights(bool), hash);
+}
+
+/// This is similar to `value(bool)` however it is gauraunteed to eventually
+/// return `true` and provides the fuzzer with an extra hint about the data.
+///
+/// It is asserted that the weight of `true` is non-zero.
+pub fn eosWeightedWithHash(s: *Smith, weights: []const Weight, hash: u32) bool {
+    @disableInstrumentation();
+    checkWeights(weights, 1);
+    for (weights) |w| (if (w.max == 1) break) else unreachable; // `true` must have non-zero weight
+
+    if (s.in) |*in| {
+        if (in.len == 0) {
+            @branchHint(.unlikely);
+            return true;
+        }
+        const eos_val = in.*[0] != 0;
+        in.* = in.*[1..];
+        return eos_val or b: {
+            var only_true: bool = true;
+            for (weights) |w| {
+                only_true &= @as(u1, @intCast(w.min)) == 1;
+            }
+            break :b only_true;
+        };
+    } else if (builtin.fuzz) {
+        @branchHint(.likely);
+        return fuzz_abi.fuzzer_eos(intUid(hash), .fromSlice(weights));
+    } else unreachable;
+}
+
+/// This is similar to `value(bool)` however it is gauraunteed to eventually
+/// return `true` and provides the fuzzer with an extra hint about the data.
+///
+/// It is asserted that the weight of `false` is non-zero.
+/// It is asserted that the weight of `true` is non-zero.
+//
+// `noinline` to capture a unique return address
+pub fn eosWeightedSimpleWithHash(s: *Smith, false_weight: u64, true_weight: u64, hash: u32) bool {
+    @disableInstrumentation();
+    return s.eosWeightedWithHash(&.{
+        .value(bool, false, false_weight),
+        .value(bool, true, true_weight),
+    }, hash);
+}
+
+pub fn bytesWithHash(s: *Smith, out: []u8, hash: u32) void {
+    @disableInstrumentation();
+    return s.bytesWeightedWithHash(out, baselineWeights(u8), hash);
+}
+
+pub fn bytesWeightedWithHash(s: *Smith, out: []u8, weights: []const Weight, hash: u32) void {
+    @disableInstrumentation();
+    checkWeights(weights, 255);
+
+    if (s.in) |*in| {
+        var present_weights: [256]bool = @splat(false);
+        for (weights) |w| {
+            @memset(present_weights[@intCast(w.min)..@intCast(w.max + 1)], true);
+        }
+        const default: u8 = @intCast(weights[0].min);
+
+        const copy_len = @min(out.len, in.len);
+        for (in.*[0..copy_len], out[0..copy_len]) |i, *o| {
+            o.* = if (present_weights[i]) i else default;
+        }
+        in.* = in.*[copy_len..];
+        @memset(out[copy_len..], default);
+    } else if (builtin.fuzz) {
+        @branchHint(.likely);
+        fuzz_abi.fuzzer_bytes(bytesUid(hash), .fromSlice(out), .fromSlice(weights));
+    } else unreachable;
+}
+
+/// Returns the length of the filled slice
+///
+/// It is asserted that `buf.len` fits within a u32
+pub fn sliceWithHash(s: *Smith, buf: []u8, hash: u32) u32 {
+    @disableInstrumentation();
+    return s.sliceWeightedBytesWithHash(buf, baselineWeights(u8), hash);
+}
+
+/// Returns the length of the filled slice
+///
+/// It is asserted that `buf.len` fits within a u32
+pub fn sliceWeightedBytesWithHash(
+    s: *Smith,
+    buf: []u8,
+    byte_weights: []const Weight,
+    hash: u32,
+) u32 {
+    @disableInstrumentation();
+    return s.sliceWeightedWithHash(
+        buf,
+        &.{.rangeAtMost(u32, 0, @intCast(buf.len), 1)},
+        byte_weights,
+        hash,
+    );
+}
+
+/// Returns the length of the filled slice
+///
+/// It is asserted that `buf.len` fits within a u32
+pub fn sliceWeightedWithHash(
+    s: *Smith,
+    buf: []u8,
+    len_weights: []const Weight,
+    byte_weights: []const Weight,
+    hash: u32,
+) u32 {
+    @disableInstrumentation();
+    checkWeights(byte_weights, 255);
+    checkWeights(len_weights, @as(u32, @intCast(buf.len)));
+
+    if (s.in) |*in| {
+        const in_len = len: {
+            if (in.len < 4) {
+                @branchHint(.unlikely);
+                in.* = &.{};
+                break :len 0;
+            }
+            const len = std.mem.readInt(u32, in.*[0..4], .little);
+            in.* = in.*[4..];
+            break :len @min(len, in.len);
+        };
+        const out_len: u32 = if (weightsContain(in_len, len_weights))
+            in_len
+        else
+            @intCast(len_weights[0].min);
+
+        var present_weights: [256]bool = @splat(false);
+        for (byte_weights) |w| {
+            @memset(present_weights[@intCast(w.min)..@intCast(w.max + 1)], true);
+        }
+        const default: u8 = @intCast(byte_weights[0].min);
+
+        const copy_len = @min(out_len, in_len);
+        for (in.*[0..copy_len], buf[0..copy_len]) |i, *o| {
+            o.* = if (present_weights[i]) i else default;
+        }
+        in.* = in.*[in_len..];
+        @memset(buf[copy_len..], default);
+        return out_len;
+    } else if (builtin.fuzz) {
+        @branchHint(.likely);
+        return fuzz_abi.fuzzer_slice(
+            bytesUid(hash),
+            .fromSlice(buf),
+            .fromSlice(len_weights),
+            .fromSlice(byte_weights),
+        );
+    } else unreachable;
+}
+
+fn constructInput(comptime values: []const union(enum) {
+    eos: bool,
+    int: u64,
+    bytes: []const u8,
+    slice: []const u8,
+}) []const u8 {
+    const result = comptime result: {
+        var result: [
+            len: {
+                var len = 0;
+                for (values) |v| len += switch (v) {
+                    .eos => 1,
+                    .int => 8,
+                    .bytes => |b| b.len,
+                    .slice => |s| 4 + s.len,
+                };
+                break :len len;
+            }
+        ]u8 = undefined;
+        var w: std.Io.Writer = .fixed(&result);
+
+        for (values) |v| switch (v) {
+            .eos => |e| w.writeByte(@intFromBool(e)) catch unreachable,
+            .int => |i| w.writeInt(u64, i, .little) catch unreachable,
+            .bytes => |b| w.writeAll(b) catch unreachable,
+            .slice => |s| {
+                w.writeInt(u32, @intCast(s.len), .little) catch unreachable;
+                w.writeAll(s) catch unreachable;
+            },
+        };
+
+        break :result result;
+    };
+    return &result;
+}
+
+test value {
+    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+
+    const S = struct {
+        v: void = {},
+        b: bool = true,
+        ih: u16 = 123,
+        iq: u64 = 55555,
+        io: u128 = (1 << 80) | (1 << 23),
+        fd: f64 = std.math.pi,
+        ft: f80 = std.math.e,
+        eh: enum(u16) { a, _ } = @enumFromInt(999),
+        eo: enum(u128) { a, b, _ } = .b,
+        aw: [3]u32 = .{ 1 << 30, 1 << 20, 1 << 10 },
+        vw: @Vector(3, u32) = .{ 1 << 10, 1 << 20, 1 << 30 },
+        ab: [3]u8 = .{ 55, 33, 88 },
+        vb: @Vector(3, u8) = .{ 22, 44, 99 },
+        s: struct { q: u64 } = .{ .q = 1 },
+        sz: struct {} = .{},
+        sp: packed struct(u8) { a: u5, b: u3 } = .{ .a = 31, .b = 3 },
+        si: packed struct(u8) { a: u5, b: enum(u3) { a, b } } = .{ .a = 15, .b = .b },
+        u: union(enum(u2)) {
+            a: u64,
+            b: u64,
+            c: noreturn,
+        } = .{ .b = 777777 },
+        up: packed union {
+            a: u16,
+            b: f16,
+        } = .{ .b = std.math.phi },
+
+        invalid: struct {
+            ib: u8 = 0,
+            eb: enum(u8) { a, b } = .a,
+            eo: enum(u128) { a, b } = .a,
+            u: union(enum(u1)) { a: noreturn, b: void } = .{ .b = {} },
+        } = .{},
+    };
+    const s: S = .{};
+    const ft_bits: u80 = @bitCast(s.ft);
+    const eo_bits = @intFromEnum(s.eo);
+
+    var smith: Smith = .{
+        .in = constructInput(&.{
+            // v
+            .{ .int = @intFromBool(s.b) }, // b
+            .{ .int = s.ih }, // ih
+            .{ .int = s.iq }, // iq
+            .{ .int = @truncate(s.io) }, .{ .int = @intCast(s.io >> 64) }, // io
+            .{ .int = @bitCast(s.fd) }, // fd
+            .{ .int = @truncate(ft_bits) }, .{ .int = @intCast(ft_bits >> 64) }, // ft
+            .{ .int = @intFromEnum(s.eh) }, // eh
+            .{ .int = @truncate(eo_bits) }, .{ .int = @intCast(eo_bits >> 64) }, // eo
+            .{ .int = s.aw[0] }, .{ .int = s.aw[1] }, .{ .int = s.aw[2] }, // aw
+            .{ .int = s.vw[0] }, .{ .int = s.vw[1] }, .{ .int = s.vw[2] }, // vw
+            .{ .bytes = &s.ab }, // ab
+            .{ .bytes = &@as([3]u8, s.vb) }, // vb
+            .{ .int = s.s.q }, // s.q
+            //sz
+            .{ .int = @as(u8, @bitCast(s.sp)) }, // sp
+            .{ .int = s.si.a }, .{ .int = @intFromEnum(s.si.b) }, // si
+            .{ .int = @intFromEnum(s.u) }, .{ .int = s.u.b }, // u
+            .{ .int = @as(u16, @bitCast(s.up)) }, // up
+            // invalid values
+            .{ .int = 555 }, // invalid.ib
+            .{ .int = 123 }, // invalid.eb
+            .{ .int = 0 }, .{ .int = 1 }, // invalid.eo
+            .{ .int = 0 }, // invalid.u
+        }),
+    };
+
+    try std.testing.expectEqual(s, smith.value(S));
+}
+
+test valueWeighted {
+    var smith: Smith = .{
+        .in = constructInput(&.{
+            .{ .int = 200 },
+            .{ .int = 200 },
+            .{ .int = 300 },
+            .{ .int = 400 },
+        }),
+    };
+
+    try std.testing.expectEqual(200, smith.valueWeighted(u8, &.{.rangeAtMost(u8, 50, 200, 1)}));
+    try std.testing.expectEqual(50, smith.valueWeighted(u8, &.{.rangeLessThan(u8, 50, 200, 1)}));
+    const E = enum(u64) { a = 100, b = 200, c = 300 };
+    try std.testing.expectEqual(E.c, smith.valueWeighted(E, baselineWeights(E)));
+    try std.testing.expectEqual(E.a, smith.valueWeighted(E, baselineWeights(E)));
+    try std.testing.expectEqual(12345, smith.valueWeighted(u64, &.{.value(u64, 12345, 1)}));
+}
+
+test valueRangeAtMost {
+    var smith: Smith = .{
+        .in = constructInput(&.{
+            .{ .int = 100 },
+            .{ .int = 100 },
+            .{ .int = 200 },
+            .{ .int = 100 },
+            .{ .int = 200 },
+            .{ .int = 0 },
+        }),
+    };
+    try std.testing.expectEqual(100, smith.valueRangeAtMost(u8, 0, 250));
+    try std.testing.expectEqual(100, smith.valueRangeAtMost(u8, 100, 100));
+    try std.testing.expectEqual(0, smith.valueRangeAtMost(u8, 0, 100));
+    try std.testing.expectEqual(100 - 128, smith.valueRangeAtMost(i8, -100, 100));
+    try std.testing.expectEqual(200 - 128, smith.valueRangeAtMost(i8, -100, 100));
+    try std.testing.expectEqual(-100, smith.valueRangeAtMost(i8, -100, 100));
+}
+
+test valueRangeLessThan {
+    var smith: Smith = .{
+        .in = constructInput(&.{
+            .{ .int = 100 },
+            .{ .int = 100 },
+            .{ .int = 100 },
+            .{ .int = 100 + 128 },
+        }),
+    };
+    try std.testing.expectEqual(100, smith.valueRangeLessThan(u8, 0, 250));
+    try std.testing.expectEqual(0, smith.valueRangeLessThan(u8, 0, 100));
+    try std.testing.expectEqual(100 - 128, smith.valueRangeLessThan(i8, -100, 100));
+    try std.testing.expectEqual(-100, smith.valueRangeLessThan(i8, -100, 100));
+}
+
+test eos {
+    var smith: Smith = .{
+        .in = constructInput(&.{
+            .{ .eos = false },
+            .{ .eos = true },
+        }),
+    };
+    try std.testing.expect(!smith.eos());
+    try std.testing.expect(smith.eos());
+    try std.testing.expect(smith.eos());
+}
+
+test eosWeighted {
+    var smith: Smith = .{ .in = constructInput(&.{.{ .eos = false }}) };
+    try std.testing.expect(smith.eosWeighted(&.{.value(bool, true, std.math.maxInt(u64))}));
+}
+
+test bytes {
+    var smith: Smith = .{ .in = constructInput(&.{
+        .{ .bytes = "testing!" },
+        .{ .bytes = "ab" },
+    }) };
+    var buf: [8]u8 = undefined;
+
+    smith.bytes(&buf);
+    try std.testing.expectEqualSlices(u8, "testing!", &buf);
+    smith.bytes(buf[0..0]);
+    smith.bytes(buf[0..3]);
+    try std.testing.expectEqualSlices(u8, "ab\x00", buf[0..3]);
+}
+
+test bytesWeighted {
+    var smith: Smith = .{ .in = constructInput(&.{
+        .{ .bytes = "testing!" },
+        .{ .bytes = "ab" },
+    }) };
+    const weights: []const Weight = &.{.rangeAtMost(u8, 'a', 'z', 1)};
+    var buf: [8]u8 = undefined;
+
+    smith.bytesWeighted(&buf, weights);
+    try std.testing.expectEqualSlices(u8, "testinga", &buf);
+    smith.bytesWeighted(buf[0..0], weights);
+    smith.bytesWeighted(buf[0..3], weights);
+    try std.testing.expectEqualSlices(u8, "aba", buf[0..3]);
+}
+
+test slice {
+    var smith: Smith = .{
+        .in = constructInput(&.{
+            .{ .slice = "testing!" },
+            .{ .slice = "" },
+            .{ .slice = "ab" },
+            .{ .bytes = std.mem.asBytes(&std.mem.nativeToLittle(u32, 4)) }, // length past end
+        }),
+    };
+    var buf: [8]u8 = undefined;
+
+    try std.testing.expectEqualSlices(u8, "testing!", buf[0..smith.slice(&buf)]);
+    try std.testing.expectEqualSlices(u8, "", buf[0..smith.slice(&buf)]);
+    try std.testing.expectEqualSlices(u8, "ab", buf[0..smith.slice(&buf)]);
+    try std.testing.expectEqualSlices(u8, "", buf[0..smith.slice(&buf)]);
+}
+
+test sliceWeightedBytes {
+    const weights: []const Weight = &.{.rangeAtMost(u8, 'a', 'z', 1)};
+    var smith: Smith = .{ .in = constructInput(&.{
+        .{ .slice = "testing!" },
+    }) };
+    var buf: [8]u8 = undefined;
+
+    try std.testing.expectEqualSlices(
+        u8,
+        "testinga",
+        buf[0..smith.sliceWeightedBytes(&buf, weights)],
+    );
+    try std.testing.expectEqualSlices(u8, "", buf[0..smith.sliceWeightedBytes(&buf, weights)]);
+}
+
+test sliceWeighted {
+    const len_weights: []const Weight = &.{.rangeAtMost(u8, 3, 6, 1)};
+    const weights: []const Weight = &.{.rangeAtMost(u8, 'a', 'z', 1)};
+    var smith: Smith = .{ .in = constructInput(&.{
+        .{ .slice = "testing!" },
+        .{ .slice = "ing!" },
+        .{ .slice = "ab" },
+    }) };
+    var buf: [8]u8 = undefined;
+
+    try std.testing.expectEqualSlices(
+        u8,
+        "tes",
+        buf[0..smith.sliceWeighted(&buf, len_weights, weights)],
+    );
+    try std.testing.expectEqualSlices(
+        u8,
+        "inga",
+        buf[0..smith.sliceWeighted(&buf, len_weights, weights)],
+    );
+    try std.testing.expectEqualSlices(
+        u8,
+        "aba",
+        buf[0..smith.sliceWeighted(&buf, len_weights, weights)],
+    );
+    try std.testing.expectEqualSlices(
+        u8,
+        "aaa",
+        buf[0..smith.sliceWeighted(&buf, len_weights, weights)],
+    );
+}
diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index 16c15e51097200758df482cc5b6487619011234d..ba799c650e74229e4f3812fe67742bc0550b8925 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -14,6 +14,7 @@ pub const Server = @import("zig/Server.zig");
 pub const Client = @import("zig/Client.zig");
 pub const Token = tokenizer.Token;
 pub const Tokenizer = tokenizer.Tokenizer;
+pub const TokenSmith = @import("zig/TokenSmith.zig");
 pub const string_literal = @import("zig/string_literal.zig");
 pub const number_literal = @import("zig/number_literal.zig");
 pub const primitives = @import("zig/primitives.zig");
@@ -991,6 +992,7 @@ test {
     _ = LibCDirs;
     _ = LibCInstallation;
     _ = Server;
+    _ = TokenSmith;
     _ = WindowsSdk;
     _ = number_literal;
     _ = primitives;
diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig
index 7331f6188e925224c36fd9718f482eb64377f5c0..3c039b5fe5a54be45e0ca9c4bcee2ba9699a7f57 100644
--- a/lib/std/zig/Ast.zig
+++ b/lib/std/zig/Ast.zig
@@ -160,10 +160,21 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
         if (token.tag == .eof) break;
     }
 
+    var tokens_slice = tokens.toOwnedSlice();
+    errdefer tokens_slice.deinit(gpa);
+    return parseTokens(gpa, source, tokens_slice, mode);
+}
+
+pub fn parseTokens(
+    gpa: Allocator,
+    source: [:0]const u8,
+    tokens: Ast.TokenList.Slice,
+    mode: Mode,
+) Allocator.Error!Ast {
     var parser: Parse = .{
         .source = source,
         .gpa = gpa,
-        .tokens = tokens.slice(),
+        .tokens = tokens,
         .errors = .{},
         .nodes = .{},
         .extra_data = .{},
@@ -194,7 +205,7 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
     return Ast{
         .source = source,
         .mode = mode,
-        .tokens = tokens.toOwnedSlice(),
+        .tokens = tokens,
         .nodes = parser.nodes.toOwnedSlice(),
         .extra_data = extra_data,
         .errors = errors,
diff --git a/lib/std/zig/TokenSmith.zig b/lib/std/zig/TokenSmith.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a582c402e9abaa9c64066982c203766aba1b138c
--- /dev/null
+++ b/lib/std/zig/TokenSmith.zig
@@ -0,0 +1,277 @@
+//! Generates a list of tokens and a valid corresponding source.
+//! Smithed intertoken content is a non-goal of this.
+
+const std = @import("../std.zig");
+const Smith = std.testing.Smith;
+const Token = std.zig.Token;
+const TokenList = std.zig.Ast.TokenList;
+const TokenSmith = @This();
+
+source_buf: [4096]u8,
+source_len: u32,
+tag_buf: [512]Token.Tag,
+start_buf: [512]std.zig.Ast.ByteOffset,
+tags_len: u16,
+
+fn symbolLenWeights(t: *TokenSmith, min: u32, reserve: u32) [2]Smith.Weight {
+    @disableInstrumentation();
+    const space = @as(u32, t.source_buf.len - 1) - t.source_len - reserve;
+    std.debug.assert(space >= 15);
+    return .{
+        .rangeAtMost(u32, min, space, 1),
+        .rangeAtMost(u32, min, 15, space),
+    };
+}
+
+pub fn gen(smith: *Smith) TokenSmith {
+    @disableInstrumentation();
+    var t: TokenSmith = .{
+        .source_buf = undefined,
+        .source_len = 0,
+        .tag_buf = undefined,
+        .start_buf = undefined,
+        .tags_len = 0,
+    };
+
+    const max_lexeme_len = comptime max: {
+        var max: usize = 0;
+        for (std.meta.tags(Token.Tag)) |tag| {
+            max = @max(max, if (tag.lexeme()) |s| s.len else 0);
+        }
+        break :max max;
+    } + 1; // + space
+    const symbol_reserved = 15 + 4; // 4 = doc comment: "///\n"
+    const max_output_bytes = @max(symbol_reserved, max_lexeme_len);
+
+    while (t.tags_len + 2 < t.tag_buf.len - 1 and
+        t.source_len + max_output_bytes < t.source_buf.len - 1 and
+        !smith.eosWeightedSimple(7, 1))
+    {
+        const tag = smith.value(Token.Tag);
+        if (tag == .eof) continue;
+        t.tag_buf[t.tags_len] = tag;
+        t.start_buf[t.tags_len] = t.source_len;
+        t.tags_len += 1;
+
+        if (tag.lexeme()) |lexeme| {
+            @memcpy(t.source_buf[t.source_len..][0..lexeme.len], lexeme);
+            t.source_len += @intCast(lexeme.len);
+
+            if (tag == .invalid_periodasterisks) {
+                t.tag_buf[t.tags_len] = .asterisk;
+                t.start_buf[t.tags_len] = t.source_len - 1;
+                t.tags_len += 1;
+            }
+
+            t.source_buf[t.source_len] = '\n';
+            t.source_len += 1;
+        } else sw: switch (tag) {
+            .invalid => {
+                // While their are multiple ways invalid may be hit,
+                // it is unlikely the source will be inspected.
+                t.source_buf[t.source_len] = 0;
+                t.source_len += 1;
+            },
+            .identifier => {
+                const start = smith.valueWeighted(u8, &.{
+                    .rangeAtMost(u8, 'a', 'z', 1),
+                    .rangeAtMost(u8, '@', 'Z', 1), // @, A...Z
+                    .value(u8, '_', 1),
+                });
+                t.source_buf[t.source_len] = start;
+                t.source_len += 1;
+                if (start == '@') continue :sw .string_literal;
+
+                const len_weights = t.symbolLenWeights(0, 1);
+                const len = smith.sliceWeighted(
+                    t.source_buf[t.source_len..],
+                    &len_weights,
+                    &.{
+                        .rangeAtMost(u8, 'a', 'z', 1),
+                        .rangeAtMost(u8, 'A', 'Z', 1),
+                        .rangeAtMost(u8, '0', '9', 1),
+                        .value(u8, '_', 1),
+                    },
+                );
+                if (Token.getKeyword(t.source_buf[t.source_len - 1 ..][0 .. len + 1]) != null) {
+                    t.source_buf[t.source_len - 1] = '_';
+                }
+                t.source_len += len;
+
+                t.source_buf[t.source_len] = '\n';
+                t.source_len += 1;
+            },
+            .char_literal, .string_literal => |kind| {
+                const end: u8 = switch (kind) {
+                    .char_literal => '\'',
+                    .string_literal => '"',
+                    else => unreachable,
+                };
+
+                t.source_buf[t.source_len] = end;
+                t.source_len += 1;
+
+                const len_weights = t.symbolLenWeights(0, 2);
+                const len = smith.sliceWeighted(
+                    t.source_buf[t.source_len..],
+                    &len_weights,
+                    &.{
+                        .rangeAtMost(u8, 0x20, 0x7e, 1),
+                        .value(u8, '\\', 15),
+                    },
+                );
+                var start_escape = false;
+                for (t.source_buf[t.source_len..][0..len]) |*c| {
+                    if (!start_escape and c.* == end) c.* = ' ';
+                    start_escape = !start_escape and c.* == '\\';
+                }
+                if (start_escape) t.source_buf[t.source_len..][len - 1] = ' ';
+                t.source_len += len;
+
+                t.source_buf[t.source_len] = end;
+                t.source_buf[t.source_len + 1] = '\n';
+                t.source_len += 2;
+            },
+            .multiline_string_literal_line => {
+                t.source_buf[t.source_len..][0..2].* = @splat('\\');
+                t.source_len += 2;
+
+                const len_weights = t.symbolLenWeights(0, 1);
+                t.source_len += smith.sliceWeighted(
+                    t.source_buf[t.source_len..],
+                    &len_weights,
+                    &.{.rangeAtMost(u8, 0x20, 0x7e, 1)},
+                );
+
+                t.source_buf[t.source_len] = '\n';
+                t.source_len += 1;
+            },
+            .number_literal => {
+                t.source_buf[t.source_len] = smith.valueRangeAtMost(u8, '0', '9');
+                t.source_len += 1;
+
+                const len_weights = t.symbolLenWeights(0, 1);
+                const len = smith.sliceWeighted(
+                    t.source_buf[t.source_len..],
+                    &len_weights,
+                    &.{
+                        .rangeAtMost(u8, '0', '9', 8),
+                        .rangeAtMost(u8, 'a', 'z', 1),
+                        .rangeAtMost(u8, 'A', 'Z', 1),
+                        .value(u8, '+', 1),
+                        .rangeAtMost(u8, '-', '.', 1), // -, .
+                    },
+                );
+
+                var no_period = false;
+                var not_exponent = true;
+                for (t.source_buf[t.source_len..][0..len], 0..) |*c, i| {
+                    const invalid_period = no_period and c.* == '.' or i + 1 == len;
+                    const is_exponent = c.* == '-' or c.* == '+';
+                    const invalid_exponent = not_exponent and is_exponent;
+                    const valid_exponent = !not_exponent and is_exponent;
+                    if (invalid_period or invalid_exponent) c.* = '0';
+                    no_period |= c.* == '.' or valid_exponent;
+                    not_exponent = switch (c.*) {
+                        'e', 'E', 'p', 'P' => false,
+                        else => true,
+                    };
+                }
+
+                t.source_len += len;
+                t.source_buf[t.source_len] = '\n';
+                t.source_len += 1;
+            },
+            .builtin => {
+                t.source_buf[t.source_len] = '@';
+                t.source_len += 1;
+
+                const len_weights = t.symbolLenWeights(1, 1);
+                const len = smith.sliceWeighted(
+                    t.source_buf[t.source_len..],
+                    &len_weights,
+                    &.{
+                        .rangeAtMost(u8, 'a', 'z', 1),
+                        .rangeAtMost(u8, 'A', 'Z', 1),
+                        .rangeAtMost(u8, '0', '9', 1),
+                        .value(u8, '_', 1),
+                    },
+                );
+                if (t.source_buf[t.source_len] >= '0' and t.source_buf[t.source_len] <= '9') {
+                    t.source_buf[t.source_len] = '_';
+                }
+                t.source_len += len;
+
+                t.source_buf[t.source_len] = '\n';
+                t.source_len += 1;
+            },
+            .doc_comment, .container_doc_comment => |kind| {
+                t.source_buf[t.source_len..][0..2].* = "//".*;
+                t.source_buf[t.source_len..][2] = switch (kind) {
+                    .doc_comment => '/',
+                    .container_doc_comment => '!',
+                    else => unreachable,
+                };
+                t.source_len += 3;
+
+                const len_weights = t.symbolLenWeights(0, 1);
+                const len = smith.sliceWeighted(
+                    t.source_buf[t.source_len..],
+                    &len_weights,
+                    &.{
+                        .rangeAtMost(u8, 0x20, 0x7e, 1),
+                        .rangeAtMost(u8, 0x80, 0xff, 1),
+                    },
+                );
+                if (kind == .doc_comment and len != 0 and t.source_buf[t.source_len] == '/') {
+                    t.source_buf[t.source_len] = ' ';
+                }
+                t.source_len += len;
+
+                t.source_buf[t.source_len] = '\n';
+                t.source_len += 1;
+            },
+            else => unreachable,
+        }
+    }
+
+    t.tag_buf[t.tags_len] = .eof;
+    t.start_buf[t.tags_len] = t.source_len;
+    t.tags_len += 1;
+    t.source_buf[t.source_len] = 0;
+    return t;
+}
+
+pub fn source(t: *TokenSmith) [:0]u8 {
+    return t.source_buf[0..t.source_len :0];
+}
+
+/// The Slice is not backed by a MultiArrayList, so calling deinit or toMultiArrayList is illegal.
+pub fn list(t: *TokenSmith) TokenList.Slice {
+    var slice: TokenList.Slice = .{
+        .ptrs = undefined,
+        .len = t.tags_len,
+        .capacity = t.tags_len,
+    };
+    comptime std.debug.assert(slice.ptrs.len == 2);
+    slice.ptrs[@intFromEnum(TokenList.Field.tag)] = @ptrCast(&t.tag_buf);
+    slice.ptrs[@intFromEnum(TokenList.Field.start)] = @ptrCast(&t.start_buf);
+    return slice;
+}
+
+test TokenSmith {
+    try std.testing.fuzz({}, checkSource, .{});
+}
+
+fn checkSource(_: void, smith: *Smith) !void {
+    var t: TokenSmith = .gen(smith);
+    try std.testing.expectEqual(Token.Tag.eof, t.tag_buf[t.tags_len - 1]);
+
+    var tokenizer: std.zig.Tokenizer = .init(t.source());
+    for (t.tag_buf[0..t.tags_len], t.start_buf[0..t.tags_len]) |tag, start| {
+        const tok = tokenizer.next();
+        try std.testing.expectEqual(tok.tag, tag);
+        try std.testing.expectEqual(tok.loc.start, start);
+        if (tag == .invalid) break;
+    }
+}
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 46aa82f10fb5b7fe42f13b6c7b3c31a4cbf5dd79..84799e8470791e0130d9558cceddc8f6b15232ac 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -6420,14 +6420,9 @@ test "fuzz ast parse" {
     try std.testing.fuzz({}, fuzzTestOneParse, .{});
 }
 
-fn fuzzTestOneParse(_: void, input: []const u8) !void {
-    // The first byte holds if zig / zon
-    if (input.len == 0) return;
-    const mode: std.zig.Ast.Mode = if (input[0] & 1 == 0) .zig else .zon;
-    const bytes = input[1..];
-
+fn fuzzTestOneParse(_: void, smith: *std.testing.Smith) !void {
+    const mode = smith.value(std.zig.Ast.Mode);
+    var tokens: std.zig.TokenSmith = .gen(smith);
     var fba: std.heap.FixedBufferAllocator = .init(&fixed_buffer_mem);
-    const allocator = fba.allocator();
-    const source = allocator.dupeZ(u8, bytes) catch return;
-    _ = std.zig.Ast.parse(allocator, source, mode) catch return;
+    _ = std.zig.Ast.parseTokens(fba.allocator(), tokens.source(), tokens.list(), mode) catch return;
 }
diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 2736b8be54b8df426af8ea5d14f19b3b40868089..c296b6f5330273b3b2c4ed62e67a4451aa72734a 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -713,6 +713,9 @@ pub const Tokenizer = struct {
                 self.index += 1;
                 switch (self.buffer[self.index]) {
                     0, '\n' => result.tag = .invalid,
+                    0x01...0x09, 0x0b...0x1f, 0x7f => {
+                        continue :state .invalid;
+                    },
                     else => continue :state .string_literal,
                 }
             },
@@ -1721,15 +1724,22 @@ fn testTokenize(source: [:0]const u8, expected_token_tags: []const Token.Tag) !v
     try std.testing.expectEqual(source.len, last_token.loc.end);
 }
 
-fn testPropertiesUpheld(_: void, source: []const u8) !void {
-    var source0_buf: [512]u8 = undefined;
-    if (source.len + 1 > source0_buf.len)
-        return;
-    @memcpy(source0_buf[0..source.len], source);
-    source0_buf[source.len] = 0;
-    const source0 = source0_buf[0..source.len :0];
+fn testPropertiesUpheld(_: void, smith: *std.testing.Smith) !void {
+    @disableInstrumentation();
+    var source_buf: [512]u8 = undefined;
+    const len = smith.sliceWeightedBytes(source_buf[0 .. source_buf.len - 1], &.{
+        .rangeAtMost(u8, 0x00, 0xff, 1),
+        .rangeAtMost(u8, 0x20, 0x7e, 4),
+        .rangeAtMost(u8, 0x00, 0x1f, 1),
+        .value(u8, 0, 6),
+        .value(u8, ' ', 6),
+        .rangeAtMost(u8, '\t', '\n', 6), // \t, \n
+        .value(u8, '\r', 3),
+    });
+    source_buf[len] = 0;
+    const source = source_buf[0..len :0];
 
-    var tokenizer = Tokenizer.init(source0);
+    var tokenizer = Tokenizer.init(source);
     var tokenization_failed = false;
     while (true) {
         const token = tokenizer.next();
@@ -1742,12 +1752,12 @@ fn testPropertiesUpheld(_: void, source: []const u8) !void {
                 tokenization_failed = true;
 
                 // Property: invalid token always ends at newline or eof
-                try std.testing.expect(source0[token.loc.end] == '\n' or source0[token.loc.end] == 0);
+                try std.testing.expect(source[token.loc.end] == '\n' or source[token.loc.end] == 0);
             },
             .eof => {
                 // Property: EOF token is always 0-length at end of source.
-                try std.testing.expectEqual(source0.len, token.loc.start);
-                try std.testing.expectEqual(source0.len, token.loc.end);
+                try std.testing.expectEqual(source.len, token.loc.start);
+                try std.testing.expectEqual(source.len, token.loc.end);
                 break;
             },
             else => continue,
@@ -1755,7 +1765,7 @@ fn testPropertiesUpheld(_: void, source: []const u8) !void {
     }
 
     if (tokenization_failed) return;
-    for (source0) |cur| {
+    for (source) |cur| {
         // Property: No null byte allowed except at end.
         if (cur == 0) {
             return error.TestUnexpectedResult;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 0cba671469398ba1d6f439f82755e57354fa744f..4ef72e8ab7fed1786845aa5b8e08d1ddfe6091fa 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1116,7 +1116,7 @@ pub const Object = struct {
                 // needs to for better fuzzing logic.
                 .IndirectCalls = false,
                 .TraceBB = false,
-                .TraceCmp = options.fuzz,
+                .TraceCmp = false,
                 .TraceDiv = false,
                 .TraceGep = false,
                 .Use8bitCounters = false,
diff --git a/test/standalone/libfuzzer/main.zig b/test/standalone/libfuzzer/main.zig
index 836f25285b45d89f58b2c924ee0621cc65243e6e..b92ff9372d150bf503c06c07ebd603a762d3e5cd 100644
--- a/test/standalone/libfuzzer/main.zig
+++ b/test/standalone/libfuzzer/main.zig
@@ -2,9 +2,7 @@ const std = @import("std");
 const abi = std.Build.abi.fuzz;
 const native_endian = @import("builtin").cpu.arch.endian();
 
-fn testOne(in: abi.Slice) callconv(.c) void {
-    std.debug.assertReadable(in.toSlice());
-}
+fn testOne() callconv(.c) void {}
 
 pub fn main(init: std.process.Init) !void {
     const gpa = init.gpa;
@@ -19,7 +17,7 @@ pub fn main(init: std.process.Init) !void {
     defer cache_dir.close(io);
 
     abi.fuzzer_init(.fromSlice(cache_dir_path));
-    abi.fuzzer_init_test(testOne, .fromSlice("test"));
+    abi.fuzzer_set_test(testOne, .fromSlice("test"));
     abi.fuzzer_new_input(.fromSlice(""));
     abi.fuzzer_new_input(.fromSlice("hello"));
 
-- 
2.54.0


From ef13a373bcce33fd74dcdf3aaa86f21a601d35ec Mon Sep 17 00:00:00 2001
From: lzm-build <3575188313@qq.com>
Date: Sat, 14 Feb 2026 13:33:55 +0800
Subject: [PATCH 300/499] fix assertion argument order in acos/asin/atan

---
 lib/std/math/acos.zig | 130 ++++++++++++------------
 lib/std/math/asin.zig | 140 +++++++++++++-------------
 lib/std/math/atan.zig | 224 +++++++++++++++++++++---------------------
 3 files changed, 247 insertions(+), 247 deletions(-)

diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig
index b163551d0aae2c90730855a4efbfbf4d93571969..4277683d57469b33d55670403c5d1028fa7c66a6 100644
--- a/lib/std/math/acos.zig
+++ b/lib/std/math/acos.zig
@@ -323,9 +323,9 @@ fn acosBinary128(x: f128) f128 {
 }
 
 test "acosBinary16.special" {
-    try testing.expectApproxEqAbs(acosBinary16(0x0p+0), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
-    try testing.expectApproxEqAbs(acosBinary16(-0x1p+0), 0x1.92p1, math.floatEpsAt(f16, 0x1.92p1));
-    try testing.expectEqual(acosBinary16(0x1p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.92p0, acosBinary16(0x0p+0), math.floatEpsAt(f16, 0x1.92p0));
+    try testing.expectApproxEqAbs(0x1.92p1, acosBinary16(-0x1p+0), math.floatEpsAt(f16, 0x1.92p1));
+    try testing.expectEqual(0x0p+0, acosBinary16(0x1p+0));
     try testing.expect(math.isNan(acosBinary16(0x1.004p0)));
     try testing.expect(math.isNan(acosBinary16(-0x1.004p0)));
     try testing.expect(math.isNan(acosBinary16(math.inf(f16))));
@@ -334,22 +334,22 @@ test "acosBinary16.special" {
 }
 
 test "acosBinary16" {
-    try testing.expectApproxEqAbs(acosBinary16(0x1.db4p-5), 0x1.834p0, math.floatEpsAt(f16, 0x1.834p0));
-    try testing.expectApproxEqAbs(acosBinary16(-0x1.068p-2), 0x1.d48p0, math.floatEpsAt(f16, 0x1.d48p0));
-    try testing.expectApproxEqAbs(acosBinary16(-0x1.2c4p-3), 0x1.b7cp0, math.floatEpsAt(f16, 0x1.b7cp0));
-    try testing.expectApproxEqAbs(acosBinary16(0x1.65p-3), 0x1.654p0, math.floatEpsAt(f16, 0x1.654p0));
-    try testing.expectApproxEqAbs(acosBinary16(0x1.dfcp-1), 0x1.6d8p-2, math.floatEpsAt(f16, 0x1.6d8p-2));
-    try testing.expectApproxEqAbs(acosBinary16(-0x1.764p-1), 0x1.32p1, math.floatEpsAt(f16, 0x1.32p1));
-    try testing.expectApproxEqAbs(acosBinary16(0x1.b18p-3), 0x1.5b8p0, math.floatEpsAt(f16, 0x1.5b8p0));
-    try testing.expectApproxEqAbs(acosBinary16(0x1.5acp-3), 0x1.668p0, math.floatEpsAt(f16, 0x1.668p0));
-    try testing.expectApproxEqAbs(acosBinary16(-0x1.18cp-1), 0x1.134p1, math.floatEpsAt(f16, 0x1.134p1));
-    try testing.expectApproxEqAbs(acosBinary16(-0x1.03p-1), 0x1.0dp1, math.floatEpsAt(f16, 0x1.0dp1));
+    try testing.expectApproxEqAbs(0x1.834p0, acosBinary16(0x1.db4p-5), math.floatEpsAt(f16, 0x1.834p0));
+    try testing.expectApproxEqAbs(0x1.d48p0, acosBinary16(-0x1.068p-2), math.floatEpsAt(f16, 0x1.d48p0));
+    try testing.expectApproxEqAbs(0x1.b7cp0, acosBinary16(-0x1.2c4p-3), math.floatEpsAt(f16, 0x1.b7cp0));
+    try testing.expectApproxEqAbs(0x1.654p0, acosBinary16(0x1.65p-3), math.floatEpsAt(f16, 0x1.654p0));
+    try testing.expectApproxEqAbs(0x1.6d8p-2, acosBinary16(0x1.dfcp-1), math.floatEpsAt(f16, 0x1.6d8p-2));
+    try testing.expectApproxEqAbs(0x1.32p1, acosBinary16(-0x1.764p-1), math.floatEpsAt(f16, 0x1.32p1));
+    try testing.expectApproxEqAbs(0x1.5b8p0, acosBinary16(0x1.b18p-3), math.floatEpsAt(f16, 0x1.5b8p0));
+    try testing.expectApproxEqAbs(0x1.668p0, acosBinary16(0x1.5acp-3), math.floatEpsAt(f16, 0x1.668p0));
+    try testing.expectApproxEqAbs(0x1.134p1, acosBinary16(-0x1.18cp-1), math.floatEpsAt(f16, 0x1.134p1));
+    try testing.expectApproxEqAbs(0x1.0dp1, acosBinary16(-0x1.03p-1), math.floatEpsAt(f16, 0x1.0dp1));
 }
 
 test "acosBinary32.special" {
-    try testing.expectApproxEqAbs(acosBinary32(0x0p+0), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
-    try testing.expectApproxEqAbs(acosBinary32(-0x1p+0), 0x1.921fb6p+1, math.floatEpsAt(f32, 0x1.921fb6p+1));
-    try testing.expectEqual(acosBinary32(0x1p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb6p+0, acosBinary32(0x0p+0), math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(0x1.921fb6p+1, acosBinary32(-0x1p+0), math.floatEpsAt(f32, 0x1.921fb6p+1));
+    try testing.expectEqual(0x0p+0, acosBinary32(0x1p+0));
     try testing.expect(math.isNan(acosBinary32(0x1.000002p+0)));
     try testing.expect(math.isNan(acosBinary32(-0x1.000002p+0)));
     try testing.expect(math.isNan(acosBinary32(math.inf(f32))));
@@ -358,22 +358,22 @@ test "acosBinary32.special" {
 }
 
 test "acosBinary32" {
-    try testing.expectApproxEqAbs(acosBinary32(-0x1.13284cp-2), 0x1.d7c4e6p+0, math.floatEpsAt(f32, 0x1.d7c4e6p+0));
-    try testing.expectApproxEqAbs(acosBinary32(0x1.6ca8ep-1), 0x1.8e6756p-1, math.floatEpsAt(f32, 0x1.8e6756p-1));
-    try testing.expectApproxEqAbs(acosBinary32(0x1.c2ca6p-1), 0x1.f9d74cp-2, math.floatEpsAt(f32, 0x1.f9d74cp-2));
-    try testing.expectApproxEqAbs(acosBinary32(-0x1.55f12p-1), 0x1.26abdcp+1, math.floatEpsAt(f32, 0x1.26abdcp+1));
-    try testing.expectApproxEqAbs(acosBinary32(-0x1.15679ep-2), 0x1.d85a44p+0, math.floatEpsAt(f32, 0x1.d85a44p+0));
-    try testing.expectApproxEqAbs(acosBinary32(-0x1.41e132p-5), 0x1.9c2f68p+0, math.floatEpsAt(f32, 0x1.9c2f68p+0));
-    try testing.expectApproxEqAbs(acosBinary32(0x1.281b0ep-1), 0x1.e881bp-1, math.floatEpsAt(f32, 0x1.e881bp-1));
-    try testing.expectApproxEqAbs(acosBinary32(0x1.b5ce34p-1), 0x1.1713f6p-1, math.floatEpsAt(f32, 0x1.1713f6p-1));
-    try testing.expectApproxEqAbs(acosBinary32(-0x1.583482p-3), 0x1.bd5accp+0, math.floatEpsAt(f32, 0x1.bd5accp+0));
-    try testing.expectApproxEqAbs(acosBinary32(-0x1.ea8224p-1), 0x1.6ce7d8p+1, math.floatEpsAt(f32, 0x1.6ce7d8p+1));
+    try testing.expectApproxEqAbs(0x1.d7c4e6p+0, acosBinary32(-0x1.13284cp-2), math.floatEpsAt(f32, 0x1.d7c4e6p+0));
+    try testing.expectApproxEqAbs(0x1.8e6756p-1, acosBinary32(0x1.6ca8ep-1), math.floatEpsAt(f32, 0x1.8e6756p-1));
+    try testing.expectApproxEqAbs(0x1.f9d74cp-2, acosBinary32(0x1.c2ca6p-1), math.floatEpsAt(f32, 0x1.f9d74cp-2));
+    try testing.expectApproxEqAbs(0x1.26abdcp+1, acosBinary32(-0x1.55f12p-1), math.floatEpsAt(f32, 0x1.26abdcp+1));
+    try testing.expectApproxEqAbs(0x1.d85a44p+0, acosBinary32(-0x1.15679ep-2), math.floatEpsAt(f32, 0x1.d85a44p+0));
+    try testing.expectApproxEqAbs(0x1.9c2f68p+0, acosBinary32(-0x1.41e132p-5), math.floatEpsAt(f32, 0x1.9c2f68p+0));
+    try testing.expectApproxEqAbs(0x1.e881bp-1, acosBinary32(0x1.281b0ep-1), math.floatEpsAt(f32, 0x1.e881bp-1));
+    try testing.expectApproxEqAbs(0x1.1713f6p-1, acosBinary32(0x1.b5ce34p-1), math.floatEpsAt(f32, 0x1.1713f6p-1));
+    try testing.expectApproxEqAbs(0x1.bd5accp+0, acosBinary32(-0x1.583482p-3), math.floatEpsAt(f32, 0x1.bd5accp+0));
+    try testing.expectApproxEqAbs(0x1.6ce7d8p+1, acosBinary32(-0x1.ea8224p-1), math.floatEpsAt(f32, 0x1.6ce7d8p+1));
 }
 
 test "acosBinary64.special" {
-    try testing.expectApproxEqAbs(acosBinary64(0x0p+0), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
-    try testing.expectApproxEqAbs(acosBinary64(-0x1p+0), 0x1.921fb54442d18p+1, math.floatEpsAt(f64, 0x1.921fb54442d18p+1));
-    try testing.expectEqual(acosBinary64(0x1p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+0, acosBinary64(0x0p+0), math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+1, acosBinary64(-0x1p+0), math.floatEpsAt(f64, 0x1.921fb54442d18p+1));
+    try testing.expectEqual(0x0p+0, acosBinary64(0x1p+0));
     try testing.expect(math.isNan(acosBinary64(0x1.0000000000001p+0)));
     try testing.expect(math.isNan(acosBinary64(-0x1.0000000000001p+0)));
     try testing.expect(math.isNan(acosBinary64(math.inf(f64))));
@@ -382,22 +382,22 @@ test "acosBinary64.special" {
 }
 
 test "acosBinary64" {
-    try testing.expectApproxEqAbs(acosBinary64(-0x1.13284b2b5006dp-2), 0x1.d7c4e61020905p+0, math.floatEpsAt(f64, 0x1.d7c4e61020905p+0));
-    try testing.expectApproxEqAbs(acosBinary64(0x1.6ca8dfb825911p-1), 0x1.8e6756e27c366p-1, math.floatEpsAt(f64, 0x1.8e6756e27c366p-1));
-    try testing.expectApproxEqAbs(acosBinary64(0x1.c2ca609de7505p-1), 0x1.f9d748eaf956p-2, math.floatEpsAt(f64, 0x1.f9d748eaf956p-2));
-    try testing.expectApproxEqAbs(acosBinary64(-0x1.55f11fba96889p-1), 0x1.26abdc68d07aap+1, math.floatEpsAt(f64, 0x1.26abdc68d07aap+1));
-    try testing.expectApproxEqAbs(acosBinary64(-0x1.15679e27084ddp-2), 0x1.d85a44ea44fe4p+0, math.floatEpsAt(f64, 0x1.d85a44ea44fe4p+0));
-    try testing.expectApproxEqAbs(acosBinary64(-0x1.41e131b093c41p-5), 0x1.9c2f688eee8abp+0, math.floatEpsAt(f64, 0x1.9c2f688eee8abp+0));
-    try testing.expectApproxEqAbs(acosBinary64(0x1.281b0d18455f5p-1), 0x1.e881b1d4eb2a1p-1, math.floatEpsAt(f64, 0x1.e881b1d4eb2a1p-1));
-    try testing.expectApproxEqAbs(acosBinary64(0x1.b5ce34a51b239p-1), 0x1.1713f567a87efp-1, math.floatEpsAt(f64, 0x1.1713f567a87efp-1));
-    try testing.expectApproxEqAbs(acosBinary64(-0x1.583481079de4dp-3), 0x1.bd5acbe8fcc59p+0, math.floatEpsAt(f64, 0x1.bd5acbe8fcc59p+0));
-    try testing.expectApproxEqAbs(acosBinary64(-0x1.ea8223103b871p-1), 0x1.6ce7d66f628e5p+1, math.floatEpsAt(f64, 0x1.6ce7d66f628e5p+1));
+    try testing.expectApproxEqAbs(0x1.d7c4e61020905p+0, acosBinary64(-0x1.13284b2b5006dp-2), math.floatEpsAt(f64, 0x1.d7c4e61020905p+0));
+    try testing.expectApproxEqAbs(0x1.8e6756e27c366p-1, acosBinary64(0x1.6ca8dfb825911p-1), math.floatEpsAt(f64, 0x1.8e6756e27c366p-1));
+    try testing.expectApproxEqAbs(0x1.f9d748eaf956p-2, acosBinary64(0x1.c2ca609de7505p-1), math.floatEpsAt(f64, 0x1.f9d748eaf956p-2));
+    try testing.expectApproxEqAbs(0x1.26abdc68d07aap+1, acosBinary64(-0x1.55f11fba96889p-1), math.floatEpsAt(f64, 0x1.26abdc68d07aap+1));
+    try testing.expectApproxEqAbs(0x1.d85a44ea44fe4p+0, acosBinary64(-0x1.15679e27084ddp-2), math.floatEpsAt(f64, 0x1.d85a44ea44fe4p+0));
+    try testing.expectApproxEqAbs(0x1.9c2f688eee8abp+0, acosBinary64(-0x1.41e131b093c41p-5), math.floatEpsAt(f64, 0x1.9c2f688eee8abp+0));
+    try testing.expectApproxEqAbs(0x1.e881b1d4eb2a1p-1, acosBinary64(0x1.281b0d18455f5p-1), math.floatEpsAt(f64, 0x1.e881b1d4eb2a1p-1));
+    try testing.expectApproxEqAbs(0x1.1713f567a87efp-1, acosBinary64(0x1.b5ce34a51b239p-1), math.floatEpsAt(f64, 0x1.1713f567a87efp-1));
+    try testing.expectApproxEqAbs(0x1.bd5acbe8fcc59p+0, acosBinary64(-0x1.583481079de4dp-3), math.floatEpsAt(f64, 0x1.bd5acbe8fcc59p+0));
+    try testing.expectApproxEqAbs(0x1.6ce7d66f628e5p+1, acosBinary64(-0x1.ea8223103b871p-1), math.floatEpsAt(f64, 0x1.6ce7d66f628e5p+1));
 }
 
 test "acosExtended80.special" {
-    try testing.expectApproxEqAbs(acosExtended80(0x0p+0), 0x1.921fb54442d1846ap+0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap+0));
-    try testing.expectApproxEqAbs(acosExtended80(-0x1p+0), 0x1.921fb54442d1846ap+1, math.floatEpsAt(f80, 0x1.921fb54442d1846ap+1));
-    try testing.expectEqual(acosExtended80(0x1p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb54442d1846ap+0, acosExtended80(0x0p+0), math.floatEpsAt(f80, 0x1.921fb54442d1846ap+0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d1846ap+1, acosExtended80(-0x1p+0), math.floatEpsAt(f80, 0x1.921fb54442d1846ap+1));
+    try testing.expectEqual(0x0p+0, acosExtended80(0x1p+0));
     try testing.expect(math.isNan(acosExtended80(0x1.0000000000000002p+0)));
     try testing.expect(math.isNan(acosExtended80(-0x1.0000000000000002p+0)));
     try testing.expect(math.isNan(acosExtended80(math.inf(f80))));
@@ -406,22 +406,22 @@ test "acosExtended80.special" {
 }
 
 test "acosExtended80" {
-    try testing.expectApproxEqAbs(acosExtended80(0x1.72068a321edc8804p-1), 0x1.86b349040d28f794p-1, math.floatEpsAt(f80, 0x1.86b349040d28f794p-1));
-    try testing.expectApproxEqAbs(acosExtended80(-0x1.06d0a467d22977ecp-2), 0x1.d4923ade73ec379cp0, math.floatEpsAt(f80, 0x1.d4923ade73ec379cp0));
-    try testing.expectApproxEqAbs(acosExtended80(0x1.77d21385faa9798ap-3), 0x1.62e0e8898c6d04f2p0, math.floatEpsAt(f80, 0x1.62e0e8898c6d04f2p0));
-    try testing.expectApproxEqAbs(acosExtended80(-0x1.73ee3e8bc2a44dbep-1), 0x1.3123cbcd5dc4bd58p1, math.floatEpsAt(f80, 0x1.3123cbcd5dc4bd58p1));
-    try testing.expectApproxEqAbs(acosExtended80(0x1.0a2dd1f6ffcf668ap-1), 0x1.062a6d562df2d316p0, math.floatEpsAt(f80, 0x1.062a6d562df2d316p0));
-    try testing.expectApproxEqAbs(acosExtended80(0x1.8e835c490a3aff9ep-3), 0x1.5ffd68b520aa55fap0, math.floatEpsAt(f80, 0x1.5ffd68b520aa55fap0));
-    try testing.expectApproxEqAbs(acosExtended80(0x1.add20cdc1565064cp-3), 0x1.5bfe6cabda700684p0, math.floatEpsAt(f80, 0x1.5bfe6cabda700684p0));
-    try testing.expectApproxEqAbs(acosExtended80(0x1.21986d43727fca72p-8), 0x1.90fe1c993b571924p0, math.floatEpsAt(f80, 0x1.90fe1c993b571924p0));
-    try testing.expectApproxEqAbs(acosExtended80(0x1.d61e0b3fae6a0564p-2), 0x1.18044ccc626e7f9ep0, math.floatEpsAt(f80, 0x1.18044ccc626e7f9ep0));
-    try testing.expectApproxEqAbs(acosExtended80(-0x1.171e7c4a41883ccap-4), 0x1.a39513b6c16532b4p0, math.floatEpsAt(f80, 0x1.a39513b6c16532b4p0));
+    try testing.expectApproxEqAbs(0x1.86b349040d28f794p-1, acosExtended80(0x1.72068a321edc8804p-1), math.floatEpsAt(f80, 0x1.86b349040d28f794p-1));
+    try testing.expectApproxEqAbs(0x1.d4923ade73ec379cp0, acosExtended80(-0x1.06d0a467d22977ecp-2), math.floatEpsAt(f80, 0x1.d4923ade73ec379cp0));
+    try testing.expectApproxEqAbs(0x1.62e0e8898c6d04f2p0, acosExtended80(0x1.77d21385faa9798ap-3), math.floatEpsAt(f80, 0x1.62e0e8898c6d04f2p0));
+    try testing.expectApproxEqAbs(0x1.3123cbcd5dc4bd58p1, acosExtended80(-0x1.73ee3e8bc2a44dbep-1), math.floatEpsAt(f80, 0x1.3123cbcd5dc4bd58p1));
+    try testing.expectApproxEqAbs(0x1.062a6d562df2d316p0, acosExtended80(0x1.0a2dd1f6ffcf668ap-1), math.floatEpsAt(f80, 0x1.062a6d562df2d316p0));
+    try testing.expectApproxEqAbs(0x1.5ffd68b520aa55fap0, acosExtended80(0x1.8e835c490a3aff9ep-3), math.floatEpsAt(f80, 0x1.5ffd68b520aa55fap0));
+    try testing.expectApproxEqAbs(0x1.5bfe6cabda700684p0, acosExtended80(0x1.add20cdc1565064cp-3), math.floatEpsAt(f80, 0x1.5bfe6cabda700684p0));
+    try testing.expectApproxEqAbs(0x1.90fe1c993b571924p0, acosExtended80(0x1.21986d43727fca72p-8), math.floatEpsAt(f80, 0x1.90fe1c993b571924p0));
+    try testing.expectApproxEqAbs(0x1.18044ccc626e7f9ep0, acosExtended80(0x1.d61e0b3fae6a0564p-2), math.floatEpsAt(f80, 0x1.18044ccc626e7f9ep0));
+    try testing.expectApproxEqAbs(0x1.a39513b6c16532b4p0, acosExtended80(-0x1.171e7c4a41883ccap-4), math.floatEpsAt(f80, 0x1.a39513b6c16532b4p0));
 }
 
 test "acosBinary128.special" {
-    try testing.expectApproxEqAbs(acosBinary128(0x0p+0), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
-    try testing.expectApproxEqAbs(acosBinary128(-0x1p+0), 0x1.921fb54442d18469898cc51701b8p1, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p1));
-    try testing.expectEqual(acosBinary128(0x1p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18469898cc51701b8p0, acosBinary128(0x0p+0), math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18469898cc51701b8p1, acosBinary128(-0x1p+0), math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p1));
+    try testing.expectEqual(0x0p+0, acosBinary128(0x1p+0));
     try testing.expect(math.isNan(acosBinary128(0x1.0000000000000000000000000001p0)));
     try testing.expect(math.isNan(acosBinary128(-0x1.0000000000000000000000000001p0)));
     try testing.expect(math.isNan(acosBinary128(math.inf(f128))));
@@ -430,14 +430,14 @@ test "acosBinary128.special" {
 }
 
 test "acosBinary128" {
-    try testing.expectApproxEqAbs(acosBinary128(-0x1.511bdb99a3c4373bedf834ef4f68p-1), 0x1.250e9a58f049eeafa99db4360c88p1, math.floatEpsAt(f128, 0x1.250e9a58f049eeafa99db4360c88p1));
-    try testing.expectApproxEqAbs(acosBinary128(-0x1.5879cc3ad6dfd2a52e9891c69808p-1), 0x1.2786664b1c676c99437b68590004p1, math.floatEpsAt(f128, 0x1.2786664b1c676c99437b68590004p1));
-    try testing.expectApproxEqAbs(acosBinary128(0x1.3f988ba64a7eb97a751c5f0b3077p-1), 0x1.cb190cd361c7c03a09c470b4caebp-1, math.floatEpsAt(f128, 0x1.cb190cd361c7c03a09c470b4caebp-1));
-    try testing.expectApproxEqAbs(acosBinary128(-0x1.3f2d96c7768e4c4fa02315727959p-1), 0x1.1f373be697880111758f582b1a96p1, math.floatEpsAt(f128, 0x1.1f373be697880111758f582b1a96p1));
-    try testing.expectApproxEqAbs(acosBinary128(0x1.fad303c2e28c1f4d8f9fd0e5686fp-2), 0x1.0d92fd2a0a6ca3e4853c1de9ea6ap0, math.floatEpsAt(f128, 0x1.0d92fd2a0a6ca3e4853c1de9ea6ap0));
-    try testing.expectApproxEqAbs(acosBinary128(0x1.ddde322bd1a2ee50c5ba30c9c617p-2), 0x1.15d4b306e16fbf9ea4f29e82b154p0, math.floatEpsAt(f128, 0x1.15d4b306e16fbf9ea4f29e82b154p0));
-    try testing.expectApproxEqAbs(acosBinary128(-0x1.b02f6adefcbeb1d48666b827ff17p-1), 0x1.49b0a0355a5539052388e8a6dc11p1, math.floatEpsAt(f128, 0x1.49b0a0355a5539052388e8a6dc11p1));
-    try testing.expectApproxEqAbs(acosBinary128(0x1.c8581cce7cd3f6efab0fc60d9b7dp-2), 0x1.1be0b757f4cef022f5d2422b9c78p0, math.floatEpsAt(f128, 0x1.1be0b757f4cef022f5d2422b9c78p0));
-    try testing.expectApproxEqAbs(acosBinary128(-0x1.bf887b8c4e33cbef59993056f3dep-1), 0x1.513270e671db2d840f20b0186c2cp1, math.floatEpsAt(f128, 0x1.513270e671db2d840f20b0186c2cp1));
-    try testing.expectApproxEqAbs(acosBinary128(0x1.0c0f600ab6f9c84c6102942044cep-3), 0x1.70851a509f0e8bfbe780aa8f29f9p0, math.floatEpsAt(f128, 0x1.70851a509f0e8bfbe780aa8f29f9p0));
+    try testing.expectApproxEqAbs(0x1.250e9a58f049eeafa99db4360c88p1, acosBinary128(-0x1.511bdb99a3c4373bedf834ef4f68p-1), math.floatEpsAt(f128, 0x1.250e9a58f049eeafa99db4360c88p1));
+    try testing.expectApproxEqAbs(0x1.2786664b1c676c99437b68590004p1, acosBinary128(-0x1.5879cc3ad6dfd2a52e9891c69808p-1), math.floatEpsAt(f128, 0x1.2786664b1c676c99437b68590004p1));
+    try testing.expectApproxEqAbs(0x1.cb190cd361c7c03a09c470b4caebp-1, acosBinary128(0x1.3f988ba64a7eb97a751c5f0b3077p-1), math.floatEpsAt(f128, 0x1.cb190cd361c7c03a09c470b4caebp-1));
+    try testing.expectApproxEqAbs(0x1.1f373be697880111758f582b1a96p1, acosBinary128(-0x1.3f2d96c7768e4c4fa02315727959p-1), math.floatEpsAt(f128, 0x1.1f373be697880111758f582b1a96p1));
+    try testing.expectApproxEqAbs(0x1.0d92fd2a0a6ca3e4853c1de9ea6ap0, acosBinary128(0x1.fad303c2e28c1f4d8f9fd0e5686fp-2), math.floatEpsAt(f128, 0x1.0d92fd2a0a6ca3e4853c1de9ea6ap0));
+    try testing.expectApproxEqAbs(0x1.15d4b306e16fbf9ea4f29e82b154p0, acosBinary128(0x1.ddde322bd1a2ee50c5ba30c9c617p-2), math.floatEpsAt(f128, 0x1.15d4b306e16fbf9ea4f29e82b154p0));
+    try testing.expectApproxEqAbs(0x1.49b0a0355a5539052388e8a6dc11p1, acosBinary128(-0x1.b02f6adefcbeb1d48666b827ff17p-1), math.floatEpsAt(f128, 0x1.49b0a0355a5539052388e8a6dc11p1));
+    try testing.expectApproxEqAbs(0x1.1be0b757f4cef022f5d2422b9c78p0, acosBinary128(0x1.c8581cce7cd3f6efab0fc60d9b7dp-2), math.floatEpsAt(f128, 0x1.1be0b757f4cef022f5d2422b9c78p0));
+    try testing.expectApproxEqAbs(0x1.513270e671db2d840f20b0186c2cp1, acosBinary128(-0x1.bf887b8c4e33cbef59993056f3dep-1), math.floatEpsAt(f128, 0x1.513270e671db2d840f20b0186c2cp1));
+    try testing.expectApproxEqAbs(0x1.70851a509f0e8bfbe780aa8f29f9p0, acosBinary128(0x1.0c0f600ab6f9c84c6102942044cep-3), math.floatEpsAt(f128, 0x1.70851a509f0e8bfbe780aa8f29f9p0));
 }
diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig
index 113fb584bbc3fac8c8d0636f692ebfe2b4553623..af8f3521b334d88586f048ec09810269d23ce04b 100644
--- a/lib/std/math/asin.zig
+++ b/lib/std/math/asin.zig
@@ -312,10 +312,10 @@ fn asinBinary128(x: f128) f128 {
 }
 
 test "asinBinary16.special" {
-    try testing.expectApproxEqAbs(asinBinary16(0x1p+0), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
-    try testing.expectApproxEqAbs(asinBinary16(-0x1p+0), -0x1.92p0, math.floatEpsAt(f16, -0x1.92p0));
-    try testing.expectEqual(asinBinary16(0x0p+0), 0x0p+0);
-    try testing.expectEqual(asinBinary16(-0x0p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.92p0, asinBinary16(0x1p+0), math.floatEpsAt(f16, 0x1.92p0));
+    try testing.expectApproxEqAbs(-0x1.92p0, asinBinary16(-0x1p+0), math.floatEpsAt(f16, -0x1.92p0));
+    try testing.expectEqual(0x0p+0, asinBinary16(0x0p+0));
+    try testing.expectEqual(0x0p+0, asinBinary16(-0x0p+0));
     try testing.expect(math.isNan(asinBinary16(0x1.004p0)));
     try testing.expect(math.isNan(asinBinary16(-0x1.004p0)));
     try testing.expect(math.isNan(asinBinary16(math.inf(f16))));
@@ -324,23 +324,23 @@ test "asinBinary16.special" {
 }
 
 test "asinBinary16" {
-    try testing.expectApproxEqAbs(asinBinary16(-0x1.e4cp-6), -0x1.e4cp-6, math.floatEpsAt(f16, -0x1.e4cp-6));
-    try testing.expectApproxEqAbs(asinBinary16(0x1.d68p-1), 0x1.2a8p0, math.floatEpsAt(f16, 0x1.2a8p0));
-    try testing.expectApproxEqAbs(asinBinary16(-0x1.a4cp-1), -0x1.eep-1, math.floatEpsAt(f16, -0x1.eep-1));
-    try testing.expectApproxEqAbs(asinBinary16(-0x1.0a4p-2), -0x1.0d4p-2, math.floatEpsAt(f16, -0x1.0d4p-2));
-    try testing.expectApproxEqAbs(asinBinary16(0x1.28cp-1), 0x1.3c8p-1, math.floatEpsAt(f16, 0x1.3c8p-1));
-    try testing.expectApproxEqAbs(asinBinary16(0x1.284p-3), 0x1.298p-3, math.floatEpsAt(f16, 0x1.298p-3));
-    try testing.expectApproxEqAbs(asinBinary16(-0x1.574p-1), -0x1.784p-1, math.floatEpsAt(f16, -0x1.784p-1));
-    try testing.expectApproxEqAbs(asinBinary16(-0x1.4ccp-1), -0x1.6a4p-1, math.floatEpsAt(f16, -0x1.6a4p-1));
-    try testing.expectApproxEqAbs(asinBinary16(0x1.a18p-1), 0x1.e84p-1, math.floatEpsAt(f16, 0x1.e84p-1));
-    try testing.expectApproxEqAbs(asinBinary16(0x1.7a8p-2), 0x1.83cp-2, math.floatEpsAt(f16, 0x1.83cp-2));
+    try testing.expectApproxEqAbs(-0x1.e4cp-6, asinBinary16(-0x1.e4cp-6), math.floatEpsAt(f16, -0x1.e4cp-6));
+    try testing.expectApproxEqAbs(0x1.2a8p0, asinBinary16(0x1.d68p-1), math.floatEpsAt(f16, 0x1.2a8p0));
+    try testing.expectApproxEqAbs(-0x1.eep-1, asinBinary16(-0x1.a4cp-1), math.floatEpsAt(f16, -0x1.eep-1));
+    try testing.expectApproxEqAbs(-0x1.0d4p-2, asinBinary16(-0x1.0a4p-2), math.floatEpsAt(f16, -0x1.0d4p-2));
+    try testing.expectApproxEqAbs(0x1.3c8p-1, asinBinary16(0x1.28cp-1), math.floatEpsAt(f16, 0x1.3c8p-1));
+    try testing.expectApproxEqAbs(0x1.298p-3, asinBinary16(0x1.284p-3), math.floatEpsAt(f16, 0x1.298p-3));
+    try testing.expectApproxEqAbs(-0x1.784p-1, asinBinary16(-0x1.574p-1), math.floatEpsAt(f16, -0x1.784p-1));
+    try testing.expectApproxEqAbs(-0x1.6a4p-1, asinBinary16(-0x1.4ccp-1), math.floatEpsAt(f16, -0x1.6a4p-1));
+    try testing.expectApproxEqAbs(0x1.e84p-1, asinBinary16(0x1.a18p-1), math.floatEpsAt(f16, 0x1.e84p-1));
+    try testing.expectApproxEqAbs(0x1.83cp-2, asinBinary16(0x1.7a8p-2), math.floatEpsAt(f16, 0x1.83cp-2));
 }
 
 test "asinBinary32.special" {
-    try testing.expectApproxEqAbs(asinBinary32(0x1p+0), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
-    try testing.expectApproxEqAbs(asinBinary32(-0x1p+0), -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
-    try testing.expectEqual(asinBinary32(0x0p+0), 0x0p+0);
-    try testing.expectEqual(asinBinary32(-0x0p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb6p+0, asinBinary32(0x1p+0), math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb6p+0, asinBinary32(-0x1p+0), math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expectEqual(0x0p+0, asinBinary32(0x0p+0));
+    try testing.expectEqual(0x0p+0, asinBinary32(-0x0p+0));
     try testing.expect(math.isNan(asinBinary32(0x1.000002p+0)));
     try testing.expect(math.isNan(asinBinary32(-0x1.000002p+0)));
     try testing.expect(math.isNan(asinBinary32(math.inf(f32))));
@@ -349,23 +349,23 @@ test "asinBinary32.special" {
 }
 
 test "asinBinary32" {
-    try testing.expectApproxEqAbs(asinBinary32(-0x1.4c2906p-4), -0x1.4c868p-4, math.floatEpsAt(f32, -0x1.4c868p-4));
-    try testing.expectApproxEqAbs(asinBinary32(0x1.05fcfap-1), 0x1.130648p-1, math.floatEpsAt(f32, 0x1.130648p-1));
-    try testing.expectApproxEqAbs(asinBinary32(0x1.fab976p-2), 0x1.090abcp-1, math.floatEpsAt(f32, 0x1.090abcp-1));
-    try testing.expectApproxEqAbs(asinBinary32(0x1.8b4b8cp-1), 0x1.c39fa2p-1, math.floatEpsAt(f32, 0x1.c39fa2p-1));
-    try testing.expectApproxEqAbs(asinBinary32(0x1.7117c2p-1), 0x1.9c332p-1, math.floatEpsAt(f32, 0x1.9c332p-1));
-    try testing.expectApproxEqAbs(asinBinary32(0x1.e5e112p-5), 0x1.e62a1cp-5, math.floatEpsAt(f32, 0x1.e62a1cp-5));
-    try testing.expectApproxEqAbs(asinBinary32(-0x1.07673p-2), -0x1.0a65dep-2, math.floatEpsAt(f32, -0x1.0a65dep-2));
-    try testing.expectApproxEqAbs(asinBinary32(-0x1.2108dep-2), -0x1.25046p-2, math.floatEpsAt(f32, -0x1.25046p-2));
-    try testing.expectApproxEqAbs(asinBinary32(-0x1.4e6e6cp-1), -0x1.6c6f0cp-1, math.floatEpsAt(f32, -0x1.6c6f0cp-1));
-    try testing.expectApproxEqAbs(asinBinary32(0x1.22a16ap-1), 0x1.350f7ap-1, math.floatEpsAt(f32, 0x1.350f7ap-1));
+    try testing.expectApproxEqAbs(-0x1.4c868p-4, asinBinary32(-0x1.4c2906p-4), math.floatEpsAt(f32, -0x1.4c868p-4));
+    try testing.expectApproxEqAbs(0x1.130648p-1, asinBinary32(0x1.05fcfap-1), math.floatEpsAt(f32, 0x1.130648p-1));
+    try testing.expectApproxEqAbs(0x1.090abcp-1, asinBinary32(0x1.fab976p-2), math.floatEpsAt(f32, 0x1.090abcp-1));
+    try testing.expectApproxEqAbs(0x1.c39fa2p-1, asinBinary32(0x1.8b4b8cp-1), math.floatEpsAt(f32, 0x1.c39fa2p-1));
+    try testing.expectApproxEqAbs(0x1.9c332p-1, asinBinary32(0x1.7117c2p-1), math.floatEpsAt(f32, 0x1.9c332p-1));
+    try testing.expectApproxEqAbs(0x1.e62a1cp-5, asinBinary32(0x1.e5e112p-5), math.floatEpsAt(f32, 0x1.e62a1cp-5));
+    try testing.expectApproxEqAbs(-0x1.0a65dep-2, asinBinary32(-0x1.07673p-2), math.floatEpsAt(f32, -0x1.0a65dep-2));
+    try testing.expectApproxEqAbs(-0x1.25046p-2, asinBinary32(-0x1.2108dep-2), math.floatEpsAt(f32, -0x1.25046p-2));
+    try testing.expectApproxEqAbs(-0x1.6c6f0cp-1, asinBinary32(-0x1.4e6e6cp-1), math.floatEpsAt(f32, -0x1.6c6f0cp-1));
+    try testing.expectApproxEqAbs(0x1.350f7ap-1, asinBinary32(0x1.22a16ap-1), math.floatEpsAt(f32, 0x1.350f7ap-1));
 }
 
 test "asinBinary64.special" {
-    try testing.expectApproxEqAbs(asinBinary64(0x1p+0), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1p+0), -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
-    try testing.expectEqual(asinBinary64(0x0p+0), 0x0p+0);
-    try testing.expectEqual(asinBinary64(-0x0p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+0, asinBinary64(0x1p+0), math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18p+0, asinBinary64(-0x1p+0), math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expectEqual(0x0p+0, asinBinary64(0x0p+0));
+    try testing.expectEqual(0x0p+0, asinBinary64(-0x0p+0));
     try testing.expect(math.isNan(asinBinary64(0x1.000002p+0)));
     try testing.expect(math.isNan(asinBinary64(-0x1.000002p+0)));
     try testing.expect(math.isNan(asinBinary64(math.inf(f64))));
@@ -374,23 +374,23 @@ test "asinBinary64.special" {
 }
 
 test "asinBinary64" {
-    try testing.expectApproxEqAbs(asinBinary64(0x1.e674fba3e40d5p-2), 0x1.fae86c5941692p-2, math.floatEpsAt(f64, 0x1.fae86c5941692p-2));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.30fd0566fd979p-1), -0x1.46b6ad730c93ap-1, math.floatEpsAt(f64, -0x1.46b6ad730c93ap-1));
-    try testing.expectApproxEqAbs(asinBinary64(0x1.6444a25abfeaap-2), 0x1.6be0be8074eep-2, math.floatEpsAt(f64, 0x1.6be0be8074eep-2));
-    try testing.expectApproxEqAbs(asinBinary64(0x1.40a53228d1a13p-1), 0x1.5a7e98f53f717p-1, math.floatEpsAt(f64, 0x1.5a7e98f53f717p-1));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.ccc6d64845cfdp-1), -0x1.1ea2602d14e8p0, math.floatEpsAt(f64, -0x1.1ea2602d14e8p0));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.94bd91b7fc74bp-1), -0x1.d2c2634193158p-1, math.floatEpsAt(f64, -0x1.d2c2634193158p-1));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.8d741b5797fccp-2), -0x1.982d5f1895d2p-2, math.floatEpsAt(f64, -0x1.982d5f1895d2p-2));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.3e8e7e15881c5p-3), -0x1.3fdaf7dfdc864p-3, math.floatEpsAt(f64, -0x1.3fdaf7dfdc864p-3));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.88222d8ab8ca9p-2), -0x1.9269540735b7bp-2, math.floatEpsAt(f64, -0x1.9269540735b7bp-2));
-    try testing.expectApproxEqAbs(asinBinary64(-0x1.41c0e9babcbd2p-2), -0x1.474c4c6625527p-2, math.floatEpsAt(f64, -0x1.474c4c6625527p-2));
+    try testing.expectApproxEqAbs(0x1.fae86c5941692p-2, asinBinary64(0x1.e674fba3e40d5p-2), math.floatEpsAt(f64, 0x1.fae86c5941692p-2));
+    try testing.expectApproxEqAbs(-0x1.46b6ad730c93ap-1, asinBinary64(-0x1.30fd0566fd979p-1), math.floatEpsAt(f64, -0x1.46b6ad730c93ap-1));
+    try testing.expectApproxEqAbs(0x1.6be0be8074eep-2, asinBinary64(0x1.6444a25abfeaap-2), math.floatEpsAt(f64, 0x1.6be0be8074eep-2));
+    try testing.expectApproxEqAbs(0x1.5a7e98f53f717p-1, asinBinary64(0x1.40a53228d1a13p-1), math.floatEpsAt(f64, 0x1.5a7e98f53f717p-1));
+    try testing.expectApproxEqAbs(-0x1.1ea2602d14e8p0, asinBinary64(-0x1.ccc6d64845cfdp-1), math.floatEpsAt(f64, -0x1.1ea2602d14e8p0));
+    try testing.expectApproxEqAbs(-0x1.d2c2634193158p-1, asinBinary64(-0x1.94bd91b7fc74bp-1), math.floatEpsAt(f64, -0x1.d2c2634193158p-1));
+    try testing.expectApproxEqAbs(-0x1.982d5f1895d2p-2, asinBinary64(-0x1.8d741b5797fccp-2), math.floatEpsAt(f64, -0x1.982d5f1895d2p-2));
+    try testing.expectApproxEqAbs(-0x1.3fdaf7dfdc864p-3, asinBinary64(-0x1.3e8e7e15881c5p-3), math.floatEpsAt(f64, -0x1.3fdaf7dfdc864p-3));
+    try testing.expectApproxEqAbs(-0x1.9269540735b7bp-2, asinBinary64(-0x1.88222d8ab8ca9p-2), math.floatEpsAt(f64, -0x1.9269540735b7bp-2));
+    try testing.expectApproxEqAbs(-0x1.474c4c6625527p-2, asinBinary64(-0x1.41c0e9babcbd2p-2), math.floatEpsAt(f64, -0x1.474c4c6625527p-2));
 }
 
 test "asinExtended80.special" {
-    try testing.expectApproxEqAbs(asinExtended80(0x1p+0), 0x1.921fb54442d1846ap+0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap+0));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1p+0), -0x1.921fb54442d1846ap+0, math.floatEpsAt(f80, -0x1.921fb54442d1846ap+0));
-    try testing.expectEqual(asinExtended80(0x0p+0), 0x0p+0);
-    try testing.expectEqual(asinExtended80(-0x0p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb54442d1846ap+0, asinExtended80(0x1p+0), math.floatEpsAt(f80, 0x1.921fb54442d1846ap+0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d1846ap+0, asinExtended80(-0x1p+0), math.floatEpsAt(f80, -0x1.921fb54442d1846ap+0));
+    try testing.expectEqual(0x0p+0, asinExtended80(0x0p+0));
+    try testing.expectEqual(0x0p+0, asinExtended80(-0x0p+0));
     try testing.expect(math.isNan(asinExtended80(0x1.0000000000000002p+0)));
     try testing.expect(math.isNan(asinExtended80(-0x1.0000000000000002p+0)));
     try testing.expect(math.isNan(asinExtended80(math.inf(f80))));
@@ -399,23 +399,23 @@ test "asinExtended80.special" {
 }
 
 test "asinExtended80" {
-    try testing.expectApproxEqAbs(asinExtended80(0x1.63cf98bc52ce0da8p-9), 0x1.63cfb560149daa9p-9, math.floatEpsAt(f80, 0x1.63cfb560149daa9p-9));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.0473756f7ae930dp-1), -0x1.113cbacd8cd1b96cp-1, math.floatEpsAt(f80, -0x1.113cbacd8cd1b96cp-1));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.2310057e005cc288p-2), -0x1.2721b231d197b064p-2, math.floatEpsAt(f80, -0x1.2721b231d197b064p-2));
-    try testing.expectApproxEqAbs(asinExtended80(0x1.f13b03bd685d96eap-1), 0x1.547c408c5d2b05aap0, math.floatEpsAt(f80, 0x1.547c408c5d2b05aap0));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.d5c507e3ef84041cp-1), -0x1.296b76bfadbb5cecp0, math.floatEpsAt(f80, -0x1.296b76bfadbb5cecp0));
-    try testing.expectApproxEqAbs(asinExtended80(0x1.8222cbc9147153d8p-1), 0x1.b572da8729a84f2ap-1, math.floatEpsAt(f80, 0x1.b572da8729a84f2ap-1));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.42c9e6b4a088a246p-11), -0x1.42c9e80ac0524dap-11, math.floatEpsAt(f80, -0x1.42c9e80ac0524dap-11));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.8f78d49deadb521cp-3), -0x1.920ca86aef6c3028p-3, math.floatEpsAt(f80, -0x1.920ca86aef6c3028p-3));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.ab98792783515774p-2), -0x1.b91cb4f7204d92fp-2, math.floatEpsAt(f80, -0x1.b91cb4f7204d92fp-2));
-    try testing.expectApproxEqAbs(asinExtended80(-0x1.104fe30cef6800aap-1), -0x1.1f20815fdc4c5304p-1, math.floatEpsAt(f80, -0x1.1f20815fdc4c5304p-1));
+    try testing.expectApproxEqAbs(0x1.63cfb560149daa9p-9, asinExtended80(0x1.63cf98bc52ce0da8p-9), math.floatEpsAt(f80, 0x1.63cfb560149daa9p-9));
+    try testing.expectApproxEqAbs(-0x1.113cbacd8cd1b96cp-1, asinExtended80(-0x1.0473756f7ae930dp-1), math.floatEpsAt(f80, -0x1.113cbacd8cd1b96cp-1));
+    try testing.expectApproxEqAbs(-0x1.2721b231d197b064p-2, asinExtended80(-0x1.2310057e005cc288p-2), math.floatEpsAt(f80, -0x1.2721b231d197b064p-2));
+    try testing.expectApproxEqAbs(0x1.547c408c5d2b05aap0, asinExtended80(0x1.f13b03bd685d96eap-1), math.floatEpsAt(f80, 0x1.547c408c5d2b05aap0));
+    try testing.expectApproxEqAbs(-0x1.296b76bfadbb5cecp0, asinExtended80(-0x1.d5c507e3ef84041cp-1), math.floatEpsAt(f80, -0x1.296b76bfadbb5cecp0));
+    try testing.expectApproxEqAbs(0x1.b572da8729a84f2ap-1, asinExtended80(0x1.8222cbc9147153d8p-1), math.floatEpsAt(f80, 0x1.b572da8729a84f2ap-1));
+    try testing.expectApproxEqAbs(-0x1.42c9e80ac0524dap-11, asinExtended80(-0x1.42c9e6b4a088a246p-11), math.floatEpsAt(f80, -0x1.42c9e80ac0524dap-11));
+    try testing.expectApproxEqAbs(-0x1.920ca86aef6c3028p-3, asinExtended80(-0x1.8f78d49deadb521cp-3), math.floatEpsAt(f80, -0x1.920ca86aef6c3028p-3));
+    try testing.expectApproxEqAbs(-0x1.b91cb4f7204d92fp-2, asinExtended80(-0x1.ab98792783515774p-2), math.floatEpsAt(f80, -0x1.b91cb4f7204d92fp-2));
+    try testing.expectApproxEqAbs(-0x1.1f20815fdc4c5304p-1, asinExtended80(-0x1.104fe30cef6800aap-1), math.floatEpsAt(f80, -0x1.1f20815fdc4c5304p-1));
 }
 
 test "asinBinary128.special" {
-    try testing.expectApproxEqAbs(asinBinary128(0x1p+0), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1p+0), -0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
-    try testing.expectEqual(asinBinary128(0x0p+0), 0x0p+0);
-    try testing.expectEqual(asinBinary128(-0x0p+0), 0x0p+0);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18469898cc51701b8p0, asinBinary128(0x1p+0), math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18469898cc51701b8p0, asinBinary128(-0x1p+0), math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectEqual(0x0p+0, asinBinary128(0x0p+0));
+    try testing.expectEqual(0x0p+0, asinBinary128(-0x0p+0));
     try testing.expect(math.isNan(asinBinary128(0x1.0000000000000000000000000001p0)));
     try testing.expect(math.isNan(asinBinary128(-0x1.0000000000000000000000000001p0)));
     try testing.expect(math.isNan(asinBinary128(math.inf(f128))));
@@ -424,14 +424,14 @@ test "asinBinary128.special" {
 }
 
 test "asinBinary128" {
-    try testing.expectApproxEqAbs(asinBinary128(0x1.85868ce287ca0196b01c25fec5ffp-3), 0x1.87e9c740d7837f8e8fa667988fbep-3, math.floatEpsAt(f128, 0x1.87e9c740d7837f8e8fa667988fbep-3));
-    try testing.expectApproxEqAbs(asinBinary128(0x1.8718d6d30b4daed08d04ef59f478p-1), 0x1.bd11a474e864213b48e0f005f1f4p-1, math.floatEpsAt(f128, 0x1.bd11a474e864213b48e0f005f1f4p-1));
-    try testing.expectApproxEqAbs(asinBinary128(0x1.11a67640cd7f0ba5d5e362f3abfap-1), 0x1.20b56f8b42649fe72d1f8d68a378p-1, math.floatEpsAt(f128, 0x1.20b56f8b42649fe72d1f8d68a378p-1));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1.bd13bf14a9dce22188e52650daa7p-1), -0x1.0dc3a7ddb9736e5ad699bf338566p0, math.floatEpsAt(f128, -0x1.0dc3a7ddb9736e5ad699bf338566p0));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1.dee0bc217fc462af57c484eefa71p-2), -0x1.f250716038f70fa50a5826c03802p-2, math.floatEpsAt(f128, -0x1.f250716038f70fa50a5826c03802p-2));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1.ea7df9139371c10b9d6fd2bbccd3p-1), -0x1.47a8b4cdd327f90056722feddbabp0, math.floatEpsAt(f128, -0x1.47a8b4cdd327f90056722feddbabp0));
-    try testing.expectApproxEqAbs(asinBinary128(0x1.04aaea6de3b5a616460702f26dfcp-2), 0x1.079178d52be662dec67e2cd7f6e9p-2, math.floatEpsAt(f128, 0x1.079178d52be662dec67e2cd7f6e9p-2));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1.c7ea85e6b61be666435a7d99444cp-1), -0x1.192df5a8d71702cf1e27014887b2p0, math.floatEpsAt(f128, -0x1.192df5a8d71702cf1e27014887b2p0));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1.6e210214e40edf6c8479998189d1p-1), -0x1.97f1092fd94ac0fdfddae2e1222bp-1, math.floatEpsAt(f128, -0x1.97f1092fd94ac0fdfddae2e1222bp-1));
-    try testing.expectApproxEqAbs(asinBinary128(-0x1.95061bf93ed6986a45d20f0e1064p-3), -0x1.97b62bc5ae6512093828828325e1p-3, math.floatEpsAt(f128, -0x1.97b62bc5ae6512093828828325e1p-3));
+    try testing.expectApproxEqAbs(0x1.87e9c740d7837f8e8fa667988fbep-3, asinBinary128(0x1.85868ce287ca0196b01c25fec5ffp-3), math.floatEpsAt(f128, 0x1.87e9c740d7837f8e8fa667988fbep-3));
+    try testing.expectApproxEqAbs(0x1.bd11a474e864213b48e0f005f1f4p-1, asinBinary128(0x1.8718d6d30b4daed08d04ef59f478p-1), math.floatEpsAt(f128, 0x1.bd11a474e864213b48e0f005f1f4p-1));
+    try testing.expectApproxEqAbs(0x1.20b56f8b42649fe72d1f8d68a378p-1, asinBinary128(0x1.11a67640cd7f0ba5d5e362f3abfap-1), math.floatEpsAt(f128, 0x1.20b56f8b42649fe72d1f8d68a378p-1));
+    try testing.expectApproxEqAbs(-0x1.0dc3a7ddb9736e5ad699bf338566p0, asinBinary128(-0x1.bd13bf14a9dce22188e52650daa7p-1), math.floatEpsAt(f128, -0x1.0dc3a7ddb9736e5ad699bf338566p0));
+    try testing.expectApproxEqAbs(-0x1.f250716038f70fa50a5826c03802p-2, asinBinary128(-0x1.dee0bc217fc462af57c484eefa71p-2), math.floatEpsAt(f128, -0x1.f250716038f70fa50a5826c03802p-2));
+    try testing.expectApproxEqAbs(-0x1.47a8b4cdd327f90056722feddbabp0, asinBinary128(-0x1.ea7df9139371c10b9d6fd2bbccd3p-1), math.floatEpsAt(f128, -0x1.47a8b4cdd327f90056722feddbabp0));
+    try testing.expectApproxEqAbs(0x1.079178d52be662dec67e2cd7f6e9p-2, asinBinary128(0x1.04aaea6de3b5a616460702f26dfcp-2), math.floatEpsAt(f128, 0x1.079178d52be662dec67e2cd7f6e9p-2));
+    try testing.expectApproxEqAbs(-0x1.192df5a8d71702cf1e27014887b2p0, asinBinary128(-0x1.c7ea85e6b61be666435a7d99444cp-1), math.floatEpsAt(f128, -0x1.192df5a8d71702cf1e27014887b2p0));
+    try testing.expectApproxEqAbs(-0x1.97f1092fd94ac0fdfddae2e1222bp-1, asinBinary128(-0x1.6e210214e40edf6c8479998189d1p-1), math.floatEpsAt(f128, -0x1.97f1092fd94ac0fdfddae2e1222bp-1));
+    try testing.expectApproxEqAbs(-0x1.97b62bc5ae6512093828828325e1p-3, asinBinary128(-0x1.95061bf93ed6986a45d20f0e1064p-3), math.floatEpsAt(f128, -0x1.97b62bc5ae6512093828828325e1p-3));
 }
diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig
index 26d8e5f83bc0a56e538a26fafce5188f4c189f7b..ccb46e7afed44e33ca1c88da1aed7830f05e51d0 100644
--- a/lib/std/math/atan.zig
+++ b/lib/std/math/atan.zig
@@ -480,118 +480,118 @@ fn atanBinary128(x: f128) f128 {
 }
 
 test "atanBinary16.special" {
-    try testing.expectEqual(atanBinary16(0x0p+0), 0x0p+0);
-    try testing.expectEqual(atanBinary16(-0x0p+0), -0x0p+0);
-    try testing.expectApproxEqAbs(atanBinary16(0x1p+0), 0x1.92p-1, math.floatEpsAt(f16, 0x1.92p-1));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1p+0), -0x1.92p-1, math.floatEpsAt(f16, -0x1.92p-1));
-    try testing.expectApproxEqAbs(atanBinary16(math.inf(f16)), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
-    try testing.expectApproxEqAbs(atanBinary16(-math.inf(f16)), -0x1.92p0, math.floatEpsAt(f16, -0x1.92p0));
+    try testing.expectEqual(0x0p+0, atanBinary16(0x0p+0));
+    try testing.expectEqual(-0x0p+0, atanBinary16(-0x0p+0));
+    try testing.expectApproxEqAbs(0x1.92p-1, atanBinary16(0x1p+0), math.floatEpsAt(f16, 0x1.92p-1));
+    try testing.expectApproxEqAbs(-0x1.92p-1, atanBinary16(-0x1p+0), math.floatEpsAt(f16, -0x1.92p-1));
+    try testing.expectApproxEqAbs(0x1.92p0, atanBinary16(math.inf(f16)), math.floatEpsAt(f16, 0x1.92p0));
+    try testing.expectApproxEqAbs(-0x1.92p0, atanBinary16(-math.inf(f16)), math.floatEpsAt(f16, -0x1.92p0));
     try testing.expect(math.isNan(atanBinary16(math.nan(f16))));
 }
 
 test "atanBinary16" {
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.864p-2), -0x1.74cp-2, math.floatEpsAt(f16, -0x1.74cp-2));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.59cp1), -0x1.374p0, math.floatEpsAt(f16, -0x1.374p0));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.d2cp0), -0x1.11cp0, math.floatEpsAt(f16, -0x1.11cp0));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.5f4p-1), -0x1.33cp-1, math.floatEpsAt(f16, -0x1.33cp-1));
-    try testing.expectApproxEqAbs(atanBinary16(0x1.588p1), 0x1.37p0, math.floatEpsAt(f16, 0x1.37p0));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.b14p-2), -0x1.99cp-2, math.floatEpsAt(f16, -0x1.99cp-2));
-    try testing.expectApproxEqAbs(atanBinary16(0x1.3ccp1), 0x1.2fcp0, math.floatEpsAt(f16, 0x1.2fcp0));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.0ecp-2), -0x1.08cp-2, math.floatEpsAt(f16, -0x1.08cp-2));
-    try testing.expectApproxEqAbs(atanBinary16(0x1.298p1), 0x1.2ap0, math.floatEpsAt(f16, 0x1.2ap0));
-    try testing.expectApproxEqAbs(atanBinary16(-0x1.028p1), -0x1.1c8p0, math.floatEpsAt(f16, -0x1.1c8p0));
+    try testing.expectApproxEqAbs(-0x1.74cp-2, atanBinary16(-0x1.864p-2), math.floatEpsAt(f16, -0x1.74cp-2));
+    try testing.expectApproxEqAbs(-0x1.374p0, atanBinary16(-0x1.59cp1), math.floatEpsAt(f16, -0x1.374p0));
+    try testing.expectApproxEqAbs(-0x1.11cp0, atanBinary16(-0x1.d2cp0), math.floatEpsAt(f16, -0x1.11cp0));
+    try testing.expectApproxEqAbs(-0x1.33cp-1, atanBinary16(-0x1.5f4p-1), math.floatEpsAt(f16, -0x1.33cp-1));
+    try testing.expectApproxEqAbs(0x1.37p0, atanBinary16(0x1.588p1), math.floatEpsAt(f16, 0x1.37p0));
+    try testing.expectApproxEqAbs(-0x1.99cp-2, atanBinary16(-0x1.b14p-2), math.floatEpsAt(f16, -0x1.99cp-2));
+    try testing.expectApproxEqAbs(0x1.2fcp0, atanBinary16(0x1.3ccp1), math.floatEpsAt(f16, 0x1.2fcp0));
+    try testing.expectApproxEqAbs(-0x1.08cp-2, atanBinary16(-0x1.0ecp-2), math.floatEpsAt(f16, -0x1.08cp-2));
+    try testing.expectApproxEqAbs(0x1.2ap0, atanBinary16(0x1.298p1), math.floatEpsAt(f16, 0x1.2ap0));
+    try testing.expectApproxEqAbs(-0x1.1c8p0, atanBinary16(-0x1.028p1), math.floatEpsAt(f16, -0x1.1c8p0));
 }
 
 test "atanBinary32.special" {
-    try testing.expectEqual(atanBinary32(0x0p+0), 0x0p+0);
-    try testing.expectEqual(atanBinary32(-0x0p+0), -0x0p+0);
-    try testing.expectApproxEqAbs(atanBinary32(0x1p+0), 0x1.921fb6p-1, math.floatEpsAt(f32, 0x1.921fb6p-1));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1p+0), -0x1.921fb6p-1, math.floatEpsAt(f32, -0x1.921fb6p-1));
-    try testing.expectApproxEqAbs(atanBinary32(math.inf(f32)), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
-    try testing.expectApproxEqAbs(atanBinary32(-math.inf(f32)), -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expectEqual(0x0p+0, atanBinary32(0x0p+0));
+    try testing.expectEqual(-0x0p+0, atanBinary32(-0x0p+0));
+    try testing.expectApproxEqAbs(0x1.921fb6p-1, atanBinary32(0x1p+0), math.floatEpsAt(f32, 0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(-0x1.921fb6p-1, atanBinary32(-0x1p+0), math.floatEpsAt(f32, -0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(0x1.921fb6p+0, atanBinary32(math.inf(f32)), math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb6p+0, atanBinary32(-math.inf(f32)), math.floatEpsAt(f32, -0x1.921fb6p+0));
     try testing.expect(math.isNan(atanBinary32(math.nan(f32))));
 }
 
 test "atanBinary32" {
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.8629dp-2), -0x1.74c62p-2, math.floatEpsAt(f32, -0x1.74c62p-2));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.59d42ep1), -0x1.375fd8p0, math.floatEpsAt(f32, -0x1.375fd8p0));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.d2dbe2p0), -0x1.11b8aep0, math.floatEpsAt(f32, -0x1.11b8aep0));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.5f314ep-1), -0x1.33d28cp-1, math.floatEpsAt(f32, -0x1.33d28cp-1));
-    try testing.expectApproxEqAbs(atanBinary32(0x1.5869bp1), 0x1.37082ep0, math.floatEpsAt(f32, 0x1.37082ep0));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.b13a06p-2), -0x1.99d7cap-2, math.floatEpsAt(f32, -0x1.99d7cap-2));
-    try testing.expectApproxEqAbs(atanBinary32(0x1.3cb0f2p1), 0x1.2fcb12p0, math.floatEpsAt(f32, 0x1.2fcb12p0));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.0ed746p-2), -0x1.08c71ap-2, math.floatEpsAt(f32, -0x1.08c71ap-2));
-    try testing.expectApproxEqAbs(atanBinary32(0x1.299d54p1), 0x1.2a24e2p0, math.floatEpsAt(f32, 0x1.2a24e2p0));
-    try testing.expectApproxEqAbs(atanBinary32(-0x1.0264fcp1), -0x1.1c6178p0, math.floatEpsAt(f32, -0x1.1c6178p0));
+    try testing.expectApproxEqAbs(-0x1.74c62p-2, atanBinary32(-0x1.8629dp-2), math.floatEpsAt(f32, -0x1.74c62p-2));
+    try testing.expectApproxEqAbs(-0x1.375fd8p0, atanBinary32(-0x1.59d42ep1), math.floatEpsAt(f32, -0x1.375fd8p0));
+    try testing.expectApproxEqAbs(-0x1.11b8aep0, atanBinary32(-0x1.d2dbe2p0), math.floatEpsAt(f32, -0x1.11b8aep0));
+    try testing.expectApproxEqAbs(-0x1.33d28cp-1, atanBinary32(-0x1.5f314ep-1), math.floatEpsAt(f32, -0x1.33d28cp-1));
+    try testing.expectApproxEqAbs(0x1.37082ep0, atanBinary32(0x1.5869bp1), math.floatEpsAt(f32, 0x1.37082ep0));
+    try testing.expectApproxEqAbs(-0x1.99d7cap-2, atanBinary32(-0x1.b13a06p-2), math.floatEpsAt(f32, -0x1.99d7cap-2));
+    try testing.expectApproxEqAbs(0x1.2fcb12p0, atanBinary32(0x1.3cb0f2p1), math.floatEpsAt(f32, 0x1.2fcb12p0));
+    try testing.expectApproxEqAbs(-0x1.08c71ap-2, atanBinary32(-0x1.0ed746p-2), math.floatEpsAt(f32, -0x1.08c71ap-2));
+    try testing.expectApproxEqAbs(0x1.2a24e2p0, atanBinary32(0x1.299d54p1), math.floatEpsAt(f32, 0x1.2a24e2p0));
+    try testing.expectApproxEqAbs(-0x1.1c6178p0, atanBinary32(-0x1.0264fcp1), math.floatEpsAt(f32, -0x1.1c6178p0));
 }
 
 test "atanBinary64.special" {
-    try testing.expectEqual(atanBinary64(0x0p+0), 0x0p+0);
-    try testing.expectEqual(atanBinary64(-0x0p+0), -0x0p+0);
-    try testing.expectApproxEqAbs(atanBinary64(0x1p+0), 0x1.921fb54442d18p-1, math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1p+0), -0x1.921fb54442d18p-1, math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
-    try testing.expectApproxEqAbs(atanBinary64(math.inf(f64)), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
-    try testing.expectApproxEqAbs(atanBinary64(-math.inf(f64)), -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expectEqual(0x0p+0, atanBinary64(0x0p+0));
+    try testing.expectEqual(-0x0p+0, atanBinary64(-0x0p+0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p-1, atanBinary64(0x1p+0), math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18p-1, atanBinary64(-0x1p+0), math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+0, atanBinary64(math.inf(f64)), math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18p+0, atanBinary64(-math.inf(f64)), math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
     try testing.expect(math.isNan(atanBinary64(math.nan(f64))));
 }
 
 test "atanBinary64" {
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.8629d0244cdccp-2), -0x1.74c61f4377016p-2, math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.59d42d4659937p1), -0x1.375fd7987cc2p0, math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.d2dbe23d04f06p0), -0x1.11b8adeba5616p0, math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.5f314e72398e8p-1), -0x1.33d28ca762539p-1, math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
-    try testing.expectApproxEqAbs(atanBinary64(0x1.5869af37b7d08p1), 0x1.37082ce2dd03p0, math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.b13a05a662618p-2), -0x1.99d7cac66dd44p-2, math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
-    try testing.expectApproxEqAbs(atanBinary64(0x1.3cb0f12f39d8ap1), 0x1.2fcb120468e8ep0, math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.0ed746b39cbb7p-2), -0x1.08c71aa0e509p-2, math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
-    try testing.expectApproxEqAbs(atanBinary64(0x1.299d54ac7d6bp1), 0x1.2a24e22d861dfp0, math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
-    try testing.expectApproxEqAbs(atanBinary64(-0x1.0264fb9f3d50ep1), -0x1.1c617825f9751p0, math.floatEpsAt(f64, -0x1.1c617825f9751p0));
+    try testing.expectApproxEqAbs(-0x1.74c61f4377016p-2, atanBinary64(-0x1.8629d0244cdccp-2), math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
+    try testing.expectApproxEqAbs(-0x1.375fd7987cc2p0, atanBinary64(-0x1.59d42d4659937p1), math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
+    try testing.expectApproxEqAbs(-0x1.11b8adeba5616p0, atanBinary64(-0x1.d2dbe23d04f06p0), math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
+    try testing.expectApproxEqAbs(-0x1.33d28ca762539p-1, atanBinary64(-0x1.5f314e72398e8p-1), math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
+    try testing.expectApproxEqAbs(0x1.37082ce2dd03p0, atanBinary64(0x1.5869af37b7d08p1), math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
+    try testing.expectApproxEqAbs(-0x1.99d7cac66dd44p-2, atanBinary64(-0x1.b13a05a662618p-2), math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
+    try testing.expectApproxEqAbs(0x1.2fcb120468e8ep0, atanBinary64(0x1.3cb0f12f39d8ap1), math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
+    try testing.expectApproxEqAbs(-0x1.08c71aa0e509p-2, atanBinary64(-0x1.0ed746b39cbb7p-2), math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
+    try testing.expectApproxEqAbs(0x1.2a24e22d861dfp0, atanBinary64(0x1.299d54ac7d6bp1), math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
+    try testing.expectApproxEqAbs(-0x1.1c617825f9751p0, atanBinary64(-0x1.0264fb9f3d50ep1), math.floatEpsAt(f64, -0x1.1c617825f9751p0));
 }
 
 test "atanExtended80.special" {
-    try testing.expectEqual(atanExtended80(0x0p+0), 0x0p+0);
-    try testing.expectEqual(atanExtended80(-0x0p+0), -0x0p+0);
-    try testing.expectApproxEqAbs(atanExtended80(0x1p+0), 0x1.921fb54442d1846ap-1, math.floatEpsAt(f80, 0x1.921fb54442d1846ap-1));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1p+0), -0x1.921fb54442d1846ap-1, math.floatEpsAt(f80, -0x1.921fb54442d1846ap-1));
-    try testing.expectApproxEqAbs(atanExtended80(math.inf(f80)), 0x1.921fb54442d1846ap0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap0));
-    try testing.expectApproxEqAbs(atanExtended80(-math.inf(f80)), -0x1.921fb54442d1846ap0, math.floatEpsAt(f80, -0x1.921fb54442d1846ap0));
+    try testing.expectEqual(0x0p+0, atanExtended80(0x0p+0));
+    try testing.expectEqual(-0x0p+0, atanExtended80(-0x0p+0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d1846ap-1, atanExtended80(0x1p+0), math.floatEpsAt(f80, 0x1.921fb54442d1846ap-1));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d1846ap-1, atanExtended80(-0x1p+0), math.floatEpsAt(f80, -0x1.921fb54442d1846ap-1));
+    try testing.expectApproxEqAbs(0x1.921fb54442d1846ap0, atanExtended80(math.inf(f80)), math.floatEpsAt(f80, 0x1.921fb54442d1846ap0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d1846ap0, atanExtended80(-math.inf(f80)), math.floatEpsAt(f80, -0x1.921fb54442d1846ap0));
     try testing.expect(math.isNan(atanExtended80(math.nan(f80))));
 }
 
 test "atanExtended80" {
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.8629d0244cdcbed8p-2), -0x1.74c61f437701661p-2, math.floatEpsAt(f80, -0x1.74c61f437701661p-2));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.59d42d4659936d9ep1), -0x1.375fd7987cc1fd02p0, math.floatEpsAt(f80, -0x1.375fd7987cc1fd02p0));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.d2dbe23d04f067b4p0), -0x1.11b8adeba5615e04p0, math.floatEpsAt(f80, -0x1.11b8adeba5615e04p0));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.5f314e72398e7dbcp-1), -0x1.33d28ca76253964cp-1, math.floatEpsAt(f80, -0x1.33d28ca76253964cp-1));
-    try testing.expectApproxEqAbs(atanExtended80(0x1.5869af37b7d078cap1), 0x1.37082ce2dd03010cp0, math.floatEpsAt(f80, 0x1.37082ce2dd03010cp0));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.b13a05a66261821ap-2), -0x1.99d7cac66dd4438p-2, math.floatEpsAt(f80, -0x1.99d7cac66dd4438p-2));
-    try testing.expectApproxEqAbs(atanExtended80(0x1.3cb0f12f39d899cp1), 0x1.2fcb120468e8d9ecp0, math.floatEpsAt(f80, 0x1.2fcb120468e8d9ecp0));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.0ed746b39cbb7614p-2), -0x1.08c71aa0e5090998p-2, math.floatEpsAt(f80, -0x1.08c71aa0e5090998p-2));
-    try testing.expectApproxEqAbs(atanExtended80(0x1.299d54ac7d6afc52p1), 0x1.2a24e22d861debfep0, math.floatEpsAt(f80, 0x1.2a24e22d861debfep0));
-    try testing.expectApproxEqAbs(atanExtended80(-0x1.0264fb9f3d50e4fp1), -0x1.1c617825f97512b8p0, math.floatEpsAt(f80, -0x1.1c617825f97512b8p0));
+    try testing.expectApproxEqAbs(-0x1.74c61f437701661p-2, atanExtended80(-0x1.8629d0244cdcbed8p-2), math.floatEpsAt(f80, -0x1.74c61f437701661p-2));
+    try testing.expectApproxEqAbs(-0x1.375fd7987cc1fd02p0, atanExtended80(-0x1.59d42d4659936d9ep1), math.floatEpsAt(f80, -0x1.375fd7987cc1fd02p0));
+    try testing.expectApproxEqAbs(-0x1.11b8adeba5615e04p0, atanExtended80(-0x1.d2dbe23d04f067b4p0), math.floatEpsAt(f80, -0x1.11b8adeba5615e04p0));
+    try testing.expectApproxEqAbs(-0x1.33d28ca76253964cp-1, atanExtended80(-0x1.5f314e72398e7dbcp-1), math.floatEpsAt(f80, -0x1.33d28ca76253964cp-1));
+    try testing.expectApproxEqAbs(0x1.37082ce2dd03010cp0, atanExtended80(0x1.5869af37b7d078cap1), math.floatEpsAt(f80, 0x1.37082ce2dd03010cp0));
+    try testing.expectApproxEqAbs(-0x1.99d7cac66dd4438p-2, atanExtended80(-0x1.b13a05a66261821ap-2), math.floatEpsAt(f80, -0x1.99d7cac66dd4438p-2));
+    try testing.expectApproxEqAbs(0x1.2fcb120468e8d9ecp0, atanExtended80(0x1.3cb0f12f39d899cp1), math.floatEpsAt(f80, 0x1.2fcb120468e8d9ecp0));
+    try testing.expectApproxEqAbs(-0x1.08c71aa0e5090998p-2, atanExtended80(-0x1.0ed746b39cbb7614p-2), math.floatEpsAt(f80, -0x1.08c71aa0e5090998p-2));
+    try testing.expectApproxEqAbs(0x1.2a24e22d861debfep0, atanExtended80(0x1.299d54ac7d6afc52p1), math.floatEpsAt(f80, 0x1.2a24e22d861debfep0));
+    try testing.expectApproxEqAbs(-0x1.1c617825f97512b8p0, atanExtended80(-0x1.0264fb9f3d50e4fp1), math.floatEpsAt(f80, -0x1.1c617825f97512b8p0));
 }
 
 test "atanBinary128.special" {
-    try testing.expectEqual(atanBinary128(0x0p+0), 0x0p+0);
-    try testing.expectEqual(atanBinary128(-0x0p+0), -0x0p+0);
-    try testing.expectApproxEqAbs(atanBinary128(0x1p+0), 0x1.921fb54442d18469898cc51701b8p-1, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p-1));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1p+0), -0x1.921fb54442d18469898cc51701b8p-1, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p-1));
-    try testing.expectApproxEqAbs(atanBinary128(math.inf(f128)), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
-    try testing.expectApproxEqAbs(atanBinary128(-math.inf(f128)), -0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectEqual(0x0p+0, atanBinary128(0x0p+0));
+    try testing.expectEqual(-0x0p+0, atanBinary128(-0x0p+0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18469898cc51701b8p-1, atanBinary128(0x1p+0), math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p-1));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18469898cc51701b8p-1, atanBinary128(-0x1p+0), math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p-1));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18469898cc51701b8p0, atanBinary128(math.inf(f128)), math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18469898cc51701b8p0, atanBinary128(-math.inf(f128)), math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
     try testing.expect(math.isNan(atanBinary128(math.nan(f128))));
 }
 
 test "atanBinary128" {
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.8629d0244cdcbed71792ccdec26dp-2), -0x1.74c61f437701660ff76989d23707p-2, math.floatEpsAt(f128, -0x1.74c61f437701660ff76989d23707p-2));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.59d42d4659936d9e22b5dea4faefp1), -0x1.375fd7987cc1fd0119cf0cc5b708p0, math.floatEpsAt(f128, -0x1.375fd7987cc1fd0119cf0cc5b708p0));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.d2dbe23d04f067b42da3f8efdf57p0), -0x1.11b8adeba5615e0370722b511231p0, math.floatEpsAt(f128, -0x1.11b8adeba5615e0370722b511231p0));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.5f314e72398e7dbbe70fb072983ep-1), -0x1.33d28ca76253964cb5d3581cdd88p-1, math.floatEpsAt(f128, -0x1.33d28ca76253964cb5d3581cdd88p-1));
-    try testing.expectApproxEqAbs(atanBinary128(0x1.5869af37b7d078caa3456c44aecep1), 0x1.37082ce2dd03010bbea814dc5882p0, math.floatEpsAt(f128, 0x1.37082ce2dd03010bbea814dc5882p0));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.b13a05a66261821a364ad8c6c999p-2), -0x1.99d7cac66dd4438077284b491a91p-2, math.floatEpsAt(f128, -0x1.99d7cac66dd4438077284b491a91p-2));
-    try testing.expectApproxEqAbs(atanBinary128(0x1.3cb0f12f39d899c0d963ac413297p1), 0x1.2fcb120468e8d9ebdb74702314c8p0, math.floatEpsAt(f128, 0x1.2fcb120468e8d9ebdb74702314c8p0));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.0ed746b39cbb7614d8735e8315a8p-2), -0x1.08c71aa0e5090998206fbbe2090fp-2, math.floatEpsAt(f128, -0x1.08c71aa0e5090998206fbbe2090fp-2));
-    try testing.expectApproxEqAbs(atanBinary128(0x1.299d54ac7d6afc5154643b601519p1), 0x1.2a24e22d861debfd6f974500567fp0, math.floatEpsAt(f128, 0x1.2a24e22d861debfd6f974500567fp0));
-    try testing.expectApproxEqAbs(atanBinary128(-0x1.0264fb9f3d50e4f0f966f0686064p1), -0x1.1c617825f97512b7f38656ab12cdp0, math.floatEpsAt(f128, -0x1.1c617825f97512b7f38656ab12cdp0));
+    try testing.expectApproxEqAbs(-0x1.74c61f437701660ff76989d23707p-2, atanBinary128(-0x1.8629d0244cdcbed71792ccdec26dp-2), math.floatEpsAt(f128, -0x1.74c61f437701660ff76989d23707p-2));
+    try testing.expectApproxEqAbs(-0x1.375fd7987cc1fd0119cf0cc5b708p0, atanBinary128(-0x1.59d42d4659936d9e22b5dea4faefp1), math.floatEpsAt(f128, -0x1.375fd7987cc1fd0119cf0cc5b708p0));
+    try testing.expectApproxEqAbs(-0x1.11b8adeba5615e0370722b511231p0, atanBinary128(-0x1.d2dbe23d04f067b42da3f8efdf57p0), math.floatEpsAt(f128, -0x1.11b8adeba5615e0370722b511231p0));
+    try testing.expectApproxEqAbs(-0x1.33d28ca76253964cb5d3581cdd88p-1, atanBinary128(-0x1.5f314e72398e7dbbe70fb072983ep-1), math.floatEpsAt(f128, -0x1.33d28ca76253964cb5d3581cdd88p-1));
+    try testing.expectApproxEqAbs(0x1.37082ce2dd03010bbea814dc5882p0, atanBinary128(0x1.5869af37b7d078caa3456c44aecep1), math.floatEpsAt(f128, 0x1.37082ce2dd03010bbea814dc5882p0));
+    try testing.expectApproxEqAbs(-0x1.99d7cac66dd4438077284b491a91p-2, atanBinary128(-0x1.b13a05a66261821a364ad8c6c999p-2), math.floatEpsAt(f128, -0x1.99d7cac66dd4438077284b491a91p-2));
+    try testing.expectApproxEqAbs(0x1.2fcb120468e8d9ebdb74702314c8p0, atanBinary128(0x1.3cb0f12f39d899c0d963ac413297p1), math.floatEpsAt(f128, 0x1.2fcb120468e8d9ebdb74702314c8p0));
+    try testing.expectApproxEqAbs(-0x1.08c71aa0e5090998206fbbe2090fp-2, atanBinary128(-0x1.0ed746b39cbb7614d8735e8315a8p-2), math.floatEpsAt(f128, -0x1.08c71aa0e5090998206fbbe2090fp-2));
+    try testing.expectApproxEqAbs(0x1.2a24e22d861debfd6f974500567fp0, atanBinary128(0x1.299d54ac7d6afc5154643b601519p1), math.floatEpsAt(f128, 0x1.2a24e22d861debfd6f974500567fp0));
+    try testing.expectApproxEqAbs(-0x1.1c617825f97512b7f38656ab12cdp0, atanBinary128(-0x1.0264fb9f3d50e4f0f966f0686064p1), math.floatEpsAt(f128, -0x1.1c617825f97512b7f38656ab12cdp0));
 }
 
 fn atanBinary32Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f32)) @TypeOf(x) {
@@ -696,12 +696,12 @@ test "atanBinary32Vec.special" {
         math.nan(f32),
     };
     const output = atanBinary32Vec(7, input);
-    try testing.expectEqual(output[0], 0x0p+0);
-    try testing.expectEqual(output[1], -0x0p+0);
-    try testing.expectApproxEqAbs(output[2], 0x1.921fb6p-1, math.floatEpsAt(f32, 0x1.921fb6p-1));
-    try testing.expectApproxEqAbs(output[3], -0x1.921fb6p-1, math.floatEpsAt(f32, -0x1.921fb6p-1));
-    try testing.expectApproxEqAbs(output[4], 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
-    try testing.expectApproxEqAbs(output[5], -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expectEqual(0x0p+0, output[0]);
+    try testing.expectEqual(-0x0p+0, output[1]);
+    try testing.expectApproxEqAbs(0x1.921fb6p-1, output[2], math.floatEpsAt(f32, 0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(-0x1.921fb6p-1, output[3], math.floatEpsAt(f32, -0x1.921fb6p-1));
+    try testing.expectApproxEqAbs(0x1.921fb6p+0, output[4], math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb6p+0, output[5], math.floatEpsAt(f32, -0x1.921fb6p+0));
     try testing.expect(math.isNan(output[6]));
 }
 
@@ -719,16 +719,16 @@ test "atanBinary32Vec" {
         -0x1.0264fcp1,
     };
     const output = atanBinary32Vec(10, input);
-    try testing.expectApproxEqAbs(output[0], -0x1.74c62p-2, math.floatEpsAt(f32, -0x1.74c62p-2));
-    try testing.expectApproxEqAbs(output[1], -0x1.375fd8p0, math.floatEpsAt(f32, -0x1.375fd8p0));
-    try testing.expectApproxEqAbs(output[2], -0x1.11b8aep0, math.floatEpsAt(f32, -0x1.11b8aep0));
-    try testing.expectApproxEqAbs(output[3], -0x1.33d28cp-1, math.floatEpsAt(f32, -0x1.33d28cp-1));
-    try testing.expectApproxEqAbs(output[4], 0x1.37082ep0, math.floatEpsAt(f32, 0x1.37082ep0));
-    try testing.expectApproxEqAbs(output[5], -0x1.99d7cap-2, math.floatEpsAt(f32, -0x1.99d7cap-2));
-    try testing.expectApproxEqAbs(output[6], 0x1.2fcb12p0, math.floatEpsAt(f32, 0x1.2fcb12p0));
-    try testing.expectApproxEqAbs(output[7], -0x1.08c71ap-2, math.floatEpsAt(f32, -0x1.08c71ap-2));
-    try testing.expectApproxEqAbs(output[8], 0x1.2a24e2p0, math.floatEpsAt(f32, 0x1.2a24e2p0));
-    try testing.expectApproxEqAbs(output[9], -0x1.1c6178p0, math.floatEpsAt(f32, -0x1.1c6178p0));
+    try testing.expectApproxEqAbs(-0x1.74c62p-2, output[0], math.floatEpsAt(f32, -0x1.74c62p-2));
+    try testing.expectApproxEqAbs(-0x1.375fd8p0, output[1], math.floatEpsAt(f32, -0x1.375fd8p0));
+    try testing.expectApproxEqAbs(-0x1.11b8aep0, output[2], math.floatEpsAt(f32, -0x1.11b8aep0));
+    try testing.expectApproxEqAbs(-0x1.33d28cp-1, output[3], math.floatEpsAt(f32, -0x1.33d28cp-1));
+    try testing.expectApproxEqAbs(0x1.37082ep0, output[4], math.floatEpsAt(f32, 0x1.37082ep0));
+    try testing.expectApproxEqAbs(-0x1.99d7cap-2, output[5], math.floatEpsAt(f32, -0x1.99d7cap-2));
+    try testing.expectApproxEqAbs(0x1.2fcb12p0, output[6], math.floatEpsAt(f32, 0x1.2fcb12p0));
+    try testing.expectApproxEqAbs(-0x1.08c71ap-2, output[7], math.floatEpsAt(f32, -0x1.08c71ap-2));
+    try testing.expectApproxEqAbs(0x1.2a24e2p0, output[8], math.floatEpsAt(f32, 0x1.2a24e2p0));
+    try testing.expectApproxEqAbs(-0x1.1c6178p0, output[9], math.floatEpsAt(f32, -0x1.1c6178p0));
 }
 
 test "atanBinary64Vec.special" {
@@ -742,12 +742,12 @@ test "atanBinary64Vec.special" {
         math.nan(f64),
     };
     const output = atanBinary64Vec(7, input);
-    try testing.expectEqual(output[0], 0x0p+0);
-    try testing.expectEqual(output[1], -0x0p+0);
-    try testing.expectApproxEqAbs(output[2], 0x1.921fb54442d18p-1, math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
-    try testing.expectApproxEqAbs(output[3], -0x1.921fb54442d18p-1, math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
-    try testing.expectApproxEqAbs(output[4], 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
-    try testing.expectApproxEqAbs(output[5], -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expectEqual(0x0p+0, output[0]);
+    try testing.expectEqual(-0x0p+0, output[1]);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p-1, output[2], math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18p-1, output[3], math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+0, output[4], math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18p+0, output[5], math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
     try testing.expect(math.isNan(output[6]));
 }
 
@@ -765,14 +765,14 @@ test "atanBinary64Vec" {
         -0x1.0264fb9f3d50ep1,
     };
     const output = atanBinary64Vec(10, input);
-    try testing.expectApproxEqAbs(output[0], -0x1.74c61f4377016p-2, math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
-    try testing.expectApproxEqAbs(output[1], -0x1.375fd7987cc2p0, math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
-    try testing.expectApproxEqAbs(output[2], -0x1.11b8adeba5616p0, math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
-    try testing.expectApproxEqAbs(output[3], -0x1.33d28ca762539p-1, math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
-    try testing.expectApproxEqAbs(output[4], 0x1.37082ce2dd03p0, math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
-    try testing.expectApproxEqAbs(output[5], -0x1.99d7cac66dd44p-2, math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
-    try testing.expectApproxEqAbs(output[6], 0x1.2fcb120468e8ep0, math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
-    try testing.expectApproxEqAbs(output[7], -0x1.08c71aa0e509p-2, math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
-    try testing.expectApproxEqAbs(output[8], 0x1.2a24e22d861dfp0, math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
-    try testing.expectApproxEqAbs(output[9], -0x1.1c617825f9751p0, math.floatEpsAt(f64, -0x1.1c617825f9751p0));
+    try testing.expectApproxEqAbs(-0x1.74c61f4377016p-2, output[0], math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
+    try testing.expectApproxEqAbs(-0x1.375fd7987cc2p0, output[1], math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
+    try testing.expectApproxEqAbs(-0x1.11b8adeba5616p0, output[2], math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
+    try testing.expectApproxEqAbs(-0x1.33d28ca762539p-1, output[3], math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
+    try testing.expectApproxEqAbs(0x1.37082ce2dd03p0, output[4], math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
+    try testing.expectApproxEqAbs(-0x1.99d7cac66dd44p-2, output[5], math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
+    try testing.expectApproxEqAbs(0x1.2fcb120468e8ep0, output[6], math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
+    try testing.expectApproxEqAbs(-0x1.08c71aa0e509p-2, output[7], math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
+    try testing.expectApproxEqAbs(0x1.2a24e22d861dfp0, output[8], math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
+    try testing.expectApproxEqAbs(-0x1.1c617825f9751p0, output[9], math.floatEpsAt(f64, -0x1.1c617825f9751p0));
 }
-- 
2.54.0


From 017228de89ef2ea4ed229c4eea62317826a909b6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 13 Feb 2026 14:32:27 -0800
Subject: [PATCH 301/499] libc malloc: introduce a canary

Instead of padding, use static entropy to detect corrupted header.

* 64-bit, safe modes: 10 canary bits
* 64-bit, unsafe modes: 0 canary bits
* 32-bit: 27 canary bits

A further enhancement, not done here, would be to upgrade from canary to
parity.
---
 lib/c/malloc.zig | 60 +++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 29 deletions(-)

diff --git a/lib/c/malloc.zig b/lib/c/malloc.zig
index 4ef795c278716763b40507431c5513979f0bf2d3..083825e438a87d1eb894f028943f81f17d06e963 100644
--- a/lib/c/malloc.zig
+++ b/lib/c/malloc.zig
@@ -52,17 +52,37 @@ const Header = packed struct(u64) {
     alignment: Alignment,
     /// Does not include the extra alignment bytes added.
     size: Size,
-    padding: Padding = 0,
+    canary: Canary = magic,
 
     comptime {
         assert(@sizeOf(Header) <= alignment_bytes);
     }
 
-    const Size = @Int(.unsigned, @min(64 - @bitSizeOf(Alignment), @bitSizeOf(usize)));
-    const Padding = @Int(.unsigned, 64 - @bitSizeOf(Alignment) - @bitSizeOf(Size));
+    const safety = switch (builtin.mode) {
+        .Debug, .ReleaseSafe => true,
+        .ReleaseFast, .ReleaseSmall => false,
+    };
+    const max_addr_bits = switch (safety) {
+        true => 48, // Ensures space for Canary bits.
+        false => 64,
+    };
+    const Size = @Int(.unsigned, @min(max_addr_bits, 64 - @bitSizeOf(Alignment), @bitSizeOf(usize)));
+    const Canary = @Int(.unsigned, 64 - @bitSizeOf(Alignment) - @bitSizeOf(Size));
+    const magic: Canary = switch (safety) {
+        true => @truncate(@as(u64, 0x76fa65bebb3d7a39)), // statically chosen entropy
+        false => 0,
+    };
 
-    fn fromBase(base: [*]align(alignment_bytes) u8) *Header {
-        return @ptrCast(base - @sizeOf(Header));
+    fn get(base: [*]align(alignment_bytes) u8) Header {
+        const header: *Header = @ptrCast(base - @sizeOf(Header));
+        assert(header.canary == magic);
+        return header.*;
+    }
+
+    fn set(base: [*]align(alignment_bytes) u8, a: Alignment, size: Size) [*]align(alignment_bytes) u8 {
+        const header: *Header = @ptrCast(base - @sizeOf(Header));
+        header.* = .{ .alignment = a, .size = size };
+        return base;
     }
 };
 
@@ -72,12 +92,7 @@ fn malloc(n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
         vtable.alloc(no_context, n + alignment_bytes, alignment, no_ra) orelse return nomem(),
     );
     const base = ptr + alignment_bytes;
-    const header: *Header = .fromBase(base);
-    header.* = .{
-        .alignment = alignment,
-        .size = size,
-    };
-    return base;
+    return Header.set(base, alignment, size);
 }
 
 fn aligned_alloc(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
@@ -93,12 +108,7 @@ fn aligned_alloc_inner(alloc_alignment: usize, n: usize) ?[*]align(alignment_byt
         vtable.alloc(no_context, n + max_align_bytes, max_align, no_ra) orelse return null,
     );
     const base: [*]align(alignment_bytes) u8 = @alignCast(ptr + max_align_bytes);
-    const header: *Header = .fromBase(base);
-    header.* = .{
-        .alignment = max_align,
-        .size = size,
-    };
-    return base;
+    return Header.set(base, max_align, size);
 }
 
 fn calloc(elems: usize, len: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
@@ -115,8 +125,7 @@ fn realloc(opt_old_base: ?[*]align(alignment_bytes) u8, n: usize) callconv(.c) ?
     }
     const old_base = opt_old_base orelse return malloc(n);
     const new_size = std.math.cast(Header.Size, n) orelse return nomem();
-    const old_header: *Header = .fromBase(old_base);
-    assert(old_header.padding == 0);
+    const old_header: Header = .get(old_base);
     const old_size = old_header.size;
     const old_alignment = old_header.alignment;
     const old_alignment_bytes = old_alignment.toByteUnits();
@@ -139,12 +148,7 @@ fn realloc(opt_old_base: ?[*]align(alignment_bytes) u8, n: usize) callconv(.c) ?
         vtable.free(no_context, old_slice, old_alignment, no_ra);
         break :b new_base;
     };
-    const new_header: *Header = .fromBase(new_base);
-    new_header.* = .{
-        .alignment = old_alignment,
-        .size = new_size,
-    };
-    return new_base;
+    return Header.set(new_base, old_alignment, new_size);
 }
 
 fn reallocarray(opt_base: ?[*]align(alignment_bytes) u8, elems: usize, len: usize) callconv(.c) ?[*]align(alignment_bytes) u8 {
@@ -154,8 +158,7 @@ fn reallocarray(opt_base: ?[*]align(alignment_bytes) u8, elems: usize, len: usiz
 
 fn free(opt_old_base: ?[*]align(alignment_bytes) u8) callconv(.c) void {
     const old_base = opt_old_base orelse return;
-    const old_header: *Header = .fromBase(old_base);
-    assert(old_header.padding == 0);
+    const old_header: Header = .get(old_base);
     const old_size = old_header.size;
     const old_alignment = old_header.alignment;
     const old_alignment_bytes = old_alignment.toByteUnits();
@@ -166,8 +169,7 @@ fn free(opt_old_base: ?[*]align(alignment_bytes) u8) callconv(.c) void {
 
 fn malloc_usable_size(opt_old_base: ?[*]align(alignment_bytes) u8) callconv(.c) usize {
     const old_base = opt_old_base orelse return 0;
-    const old_header: *Header = .fromBase(old_base);
-    assert(old_header.padding == 0);
+    const old_header: Header = .get(old_base);
     const old_size = old_header.size;
     return old_size;
 }
-- 
2.54.0


From f996d28666e7d562b6a18e9f80fe31a3463456d0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 13 Feb 2026 17:05:21 -0800
Subject: [PATCH 302/499] fetch: use tmp dir inside zig-pkg/

Using the tmp dir of the local .zig-cache/ could result in
error.CrossDevice if the user chose a non-default local cache path.

closes #31148
---
 src/Package/Fetch.zig | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index f51532b10596a21be4ac665d34f0600b4c78b097..7226a497218685ee60275dbbbd28fc9f9f529d32 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -684,15 +684,13 @@ fn runResource(
 
     const arena = f.arena.allocator();
     const eb = &f.error_bundle;
-    const s = fs.path.sep_str;
-    const local_cache_root = job_queue.local_cache;
     const rand_int = r: {
         var x: u64 = undefined;
         io.random(@ptrCast(&x));
         break :r x;
     };
-    const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(rand_int);
-    const tmp_directory_path = try local_cache_root.join(arena, tmp_dir_sub_path);
+    const tmp_dir_sub_path = ".tmp-" ++ std.fmt.hex(rand_int);
+    const tmp_directory_path = try job_queue.root_pkg_path.join(arena, tmp_dir_sub_path);
 
     const package_sub_path = blk: {
         var tmp_directory: Cache.Directory = .{
-- 
2.54.0


From 51509fe63bd94c2067bdc31962775ed3742b657f Mon Sep 17 00:00:00 2001
From: lzm-build <3575188313@qq.com>
Date: Sat, 14 Feb 2026 16:57:05 +0800
Subject: [PATCH 303/499] std.math.acos/asin: Add @Vector(?,f32) and
 @Vector(?,f64) support

---
 lib/std/math/acos.zig | 200 ++++++++++++++++++++++++++++++++++++++++--
 lib/std/math/asin.zig | 196 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 380 insertions(+), 16 deletions(-)

diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig
index 4277683d57469b33d55670403c5d1028fa7c66a6..f96c3fffb5a72c0e33b04152d059afe029e7a75c 100644
--- a/lib/std/math/acos.zig
+++ b/lib/std/math/acos.zig
@@ -4,6 +4,12 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/acosf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/acos.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/acosl.c
+//
+// Ported from ARM-software, which is licensed under the MIT license:
+// https://github.com/ARM-software/optimized-routines/blob/master/LICENSE
+//
+// https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/acosf.c
+// https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/acos.c
 
 const std = @import("../std.zig");
 const math = std.math;
@@ -17,14 +23,22 @@ const native_endian = builtin.cpu.arch.endian();
 ///  - acos(x)   = nan if x < -1 or x > 1
 pub fn acos(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
-    return switch (T) {
-        f16 => acosBinary16(x),
-        f32 => acosBinary32(x),
-        f64 => acosBinary64(x),
-        f80 => acosExtended80(x),
-        f128 => acosBinary128(x),
-        else => @compileError("acos not implemented for " ++ @typeName(T)),
-    };
+    switch (@typeInfo(T)) {
+        .float => |info| switch (info.bits) {
+            16 => return acosBinary16(x),
+            32 => return acosBinary32(x),
+            64 => return acosBinary64(x),
+            80 => return acosExtended80(x),
+            128 => return acosBinary128(x),
+            else => comptime unreachable,
+        },
+        .vector => |info| switch (info.child) {
+            f32 => return acosBinary32Vec(info.len, x),
+            f64 => return acosBinary64Vec(info.len, x),
+            else => @compileError("unimplemented"),
+        },
+        else => comptime unreachable,
+    }
 }
 
 fn approxBinary16(z: f32) f32 {
@@ -441,3 +455,173 @@ test "acosBinary128" {
     try testing.expectApproxEqAbs(0x1.513270e671db2d840f20b0186c2cp1, acosBinary128(-0x1.bf887b8c4e33cbef59993056f3dep-1), math.floatEpsAt(f128, 0x1.513270e671db2d840f20b0186c2cp1));
     try testing.expectApproxEqAbs(0x1.70851a509f0e8bfbe780aa8f29f9p0, acosBinary128(0x1.0c0f600ab6f9c84c6102942044cep-3), math.floatEpsAt(f128, 0x1.70851a509f0e8bfbe780aa8f29f9p0));
 }
+
+fn acosBinary32Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f32)) @TypeOf(x) {
+    const pi: @Vector(vec_len, f32) = @splat(math.pi);
+    const pi_over_2: @Vector(vec_len, f32) = @splat(math.pi / 2.0);
+    const zero: @Vector(vec_len, f32) = @splat(0.0);
+    const half: @Vector(vec_len, f32) = @splat(0.5);
+    const neg_one: @Vector(vec_len, f32) = @splat(-1.0);
+    const two: @Vector(vec_len, f32) = @splat(2.0);
+    const c0: @Vector(vec_len, f32) = @splat(0x1.55555ep-3);
+    const c1: @Vector(vec_len, f32) = @splat(0x1.33261ap-4);
+    const c2: @Vector(vec_len, f32) = @splat(0x1.70d7dcp-5);
+    const c3: @Vector(vec_len, f32) = @splat(0x1.b059dp-6);
+    const c4: @Vector(vec_len, f32) = @splat(0x1.3af7d8p-5);
+
+    const ax = @abs(x);
+    const ax_lt_half = ax < half;
+    const is_neg = x < zero;
+    const z2 = @select(f32, ax_lt_half, x * x, @mulAdd(@Vector(vec_len, f32), -half, ax, half));
+    const z = @select(f32, ax_lt_half, ax, @sqrt(z2));
+    const z3 = z2 * z;
+    const p3_4 = @mulAdd(@Vector(vec_len, f32), z2, c4, c3);
+    const p2_4 = @mulAdd(@Vector(vec_len, f32), z2, p3_4, c2);
+    const p1_4 = @mulAdd(@Vector(vec_len, f32), z2, p2_4, c1);
+    const p0_4 = @mulAdd(@Vector(vec_len, f32), z2, p1_4, c0);
+    const p = @mulAdd(@Vector(vec_len, f32), z3, p0_4, z);
+    const mul = @select(f32, ax_lt_half, neg_one, two);
+    const add = @select(f32, ax_lt_half, pi_over_2, @select(f32, is_neg, pi, zero));
+    return @mulAdd(@Vector(vec_len, f32), mul, @select(f32, is_neg, -p, p), add);
+}
+
+fn acosBinary64Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f64)) @TypeOf(x) {
+    const pi: @Vector(vec_len, f64) = @splat(math.pi);
+    const pi_over_2: @Vector(vec_len, f64) = @splat(math.pi / 2.0);
+    const zero: @Vector(vec_len, f64) = @splat(0.0);
+    const half: @Vector(vec_len, f64) = @splat(0.5);
+    const neg_one: @Vector(vec_len, f64) = @splat(-1.0);
+    const two: @Vector(vec_len, f64) = @splat(2.0);
+    const c0: @Vector(vec_len, f64) = @splat(0x1.555555555554ep-3);
+    const c1: @Vector(vec_len, f64) = @splat(0x1.3333333337233p-4);
+    const c2: @Vector(vec_len, f64) = @splat(0x1.6db6db67f6d9fp-5);
+    const c3: @Vector(vec_len, f64) = @splat(0x1.f1c71fbd29fbbp-6);
+    const c4: @Vector(vec_len, f64) = @splat(0x1.6e8b264d467d6p-6);
+    const c5: @Vector(vec_len, f64) = @splat(0x1.1c5997c357e9dp-6);
+    const c6: @Vector(vec_len, f64) = @splat(0x1.c86a22cd9389dp-7);
+    const c7: @Vector(vec_len, f64) = @splat(0x1.856073c22ebbep-7);
+    const c8: @Vector(vec_len, f64) = @splat(0x1.fd1151acb6bedp-8);
+    const c9: @Vector(vec_len, f64) = @splat(0x1.087182f799c1dp-6);
+    const c10: @Vector(vec_len, f64) = @splat(-0x1.6602748120927p-7);
+    const c11: @Vector(vec_len, f64) = @splat(0x1.cfa0dd1f9478p-6);
+
+    const ax = @abs(x);
+    const ax_lt_half = ax < half;
+    const is_neg = x < zero;
+    const z2 = @select(f64, ax_lt_half, x * x, @mulAdd(@Vector(vec_len, f64), -half, ax, half));
+    const z = @select(f64, ax_lt_half, ax, @sqrt(z2));
+    const z3 = z2 * z;
+    const z4 = z2 * z2;
+    const z8 = z4 * z4;
+    const p0_1 = @mulAdd(@Vector(vec_len, f64), z2, c1, c0);
+    const p2_3 = @mulAdd(@Vector(vec_len, f64), z2, c3, c2);
+    const p0_3 = @mulAdd(@Vector(vec_len, f64), z4, p2_3, p0_1);
+    const p4_5 = @mulAdd(@Vector(vec_len, f64), z2, c5, c4);
+    const p6_7 = @mulAdd(@Vector(vec_len, f64), z2, c7, c6);
+    const p4_7 = @mulAdd(@Vector(vec_len, f64), z4, p6_7, p4_5);
+    const p8_9 = @mulAdd(@Vector(vec_len, f64), z2, c9, c8);
+    const p10_11 = @mulAdd(@Vector(vec_len, f64), z2, c11, c10);
+    const p8_11 = @mulAdd(@Vector(vec_len, f64), z4, p10_11, p8_9);
+    const p4_11 = @mulAdd(@Vector(vec_len, f64), z8, p8_11, p4_7);
+    const p0_11 = @mulAdd(@Vector(vec_len, f64), z8, p4_11, p0_3);
+    const p = @mulAdd(@Vector(vec_len, f64), z3, p0_11, z);
+    const mul = @select(f64, ax_lt_half, neg_one, two);
+    const add = @select(f64, ax_lt_half, pi_over_2, @select(f64, is_neg, pi, zero));
+    return @mulAdd(@Vector(vec_len, f64), mul, @select(f64, is_neg, -p, p), add);
+}
+
+test "acosBinary32Vec.special" {
+    const input: @Vector(8, f32) = .{
+        0x0p+0,
+        -0x1p+0,
+        0x1p+0,
+        0x1.000002p+0,
+        -0x1.000002p+0,
+        math.inf(f32),
+        -math.inf(f32),
+        math.nan(f32),
+    };
+    const output = acosBinary32Vec(8, input);
+    try testing.expectApproxEqAbs(0x1.921fb6p+0, output[0], math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(0x1.921fb6p+1, output[1], math.floatEpsAt(f32, 0x1.921fb6p+1));
+    try testing.expectEqual(0x0p+0, output[2]);
+    try testing.expect(math.isNan(output[3]));
+    try testing.expect(math.isNan(output[4]));
+    try testing.expect(math.isNan(output[5]));
+    try testing.expect(math.isNan(output[6]));
+    try testing.expect(math.isNan(output[7]));
+}
+
+test "acosBinary32Vec" {
+    const input: @Vector(10, f32) = .{
+        -0x1.13284cp-2,
+        0x1.6ca8ep-1,
+        0x1.c2ca6p-1,
+        -0x1.55f12p-1,
+        -0x1.15679ep-2,
+        -0x1.41e132p-5,
+        0x1.281b0ep-1,
+        0x1.b5ce34p-1,
+        -0x1.583482p-3,
+        -0x1.ea8224p-1,
+    };
+    const output = acosBinary32Vec(10, input);
+    try testing.expectApproxEqAbs(0x1.d7c4e6p+0, output[0], math.floatEpsAt(f32, 0x1.d7c4e6p+0));
+    try testing.expectApproxEqAbs(0x1.8e6756p-1, output[1], math.floatEpsAt(f32, 0x1.8e6756p-1));
+    try testing.expectApproxEqAbs(0x1.f9d74cp-2, output[2], math.floatEpsAt(f32, 0x1.f9d74cp-2));
+    try testing.expectApproxEqAbs(0x1.26abdcp+1, output[3], math.floatEpsAt(f32, 0x1.26abdcp+1));
+    try testing.expectApproxEqAbs(0x1.d85a44p+0, output[4], math.floatEpsAt(f32, 0x1.d85a44p+0));
+    try testing.expectApproxEqAbs(0x1.9c2f68p+0, output[5], math.floatEpsAt(f32, 0x1.9c2f68p+0));
+    try testing.expectApproxEqAbs(0x1.e881bp-1, output[6], math.floatEpsAt(f32, 0x1.e881bp-1));
+    try testing.expectApproxEqAbs(0x1.1713f6p-1, output[7], math.floatEpsAt(f32, 0x1.1713f6p-1));
+    try testing.expectApproxEqAbs(0x1.bd5accp+0, output[8], math.floatEpsAt(f32, 0x1.bd5accp+0));
+    try testing.expectApproxEqAbs(0x1.6ce7d8p+1, output[9], math.floatEpsAt(f32, 0x1.6ce7d8p+1));
+}
+
+test "acosBinary64Vec.special" {
+    const input: @Vector(8, f64) = .{
+        0x0p+0,
+        -0x1p+0,
+        0x1p+0,
+        0x1.0000000000001p+0,
+        -0x1.0000000000001p+0,
+        math.inf(f64),
+        -math.inf(f64),
+        math.nan(f64),
+    };
+    const output = acosBinary64Vec(8, input);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+0, output[0], math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+1, output[1], math.floatEpsAt(f64, 0x1.921fb54442d18p+1));
+    try testing.expectEqual(0x0p+0, output[2]);
+    try testing.expect(math.isNan(output[3]));
+    try testing.expect(math.isNan(output[4]));
+    try testing.expect(math.isNan(output[5]));
+    try testing.expect(math.isNan(output[6]));
+    try testing.expect(math.isNan(output[7]));
+}
+
+test "acosBinary64Vec" {
+    const input: @Vector(10, f64) = .{
+        -0x1.13284b2b5006dp-2,
+        0x1.6ca8dfb825911p-1,
+        0x1.c2ca609de7505p-1,
+        -0x1.55f11fba96889p-1,
+        -0x1.15679e27084ddp-2,
+        -0x1.41e131b093c41p-5,
+        0x1.281b0d18455f5p-1,
+        0x1.b5ce34a51b239p-1,
+        -0x1.583481079de4dp-3,
+        -0x1.ea8223103b871p-1,
+    };
+    const output = acosBinary64Vec(10, input);
+    try testing.expectApproxEqAbs(0x1.d7c4e61020905p+0, output[0], math.floatEpsAt(f64, 0x1.d7c4e61020905p+0));
+    try testing.expectApproxEqAbs(0x1.8e6756e27c366p-1, output[1], math.floatEpsAt(f64, 0x1.8e6756e27c366p-1));
+    try testing.expectApproxEqAbs(0x1.f9d748eaf956p-2, output[2], math.floatEpsAt(f64, 0x1.f9d748eaf956p-2));
+    try testing.expectApproxEqAbs(0x1.26abdc68d07aap+1, output[3], math.floatEpsAt(f64, 0x1.26abdc68d07aap+1));
+    try testing.expectApproxEqAbs(0x1.d85a44ea44fe4p+0, output[4], math.floatEpsAt(f64, 0x1.d85a44ea44fe4p+0));
+    try testing.expectApproxEqAbs(0x1.9c2f688eee8abp+0, output[5], math.floatEpsAt(f64, 0x1.9c2f688eee8abp+0));
+    try testing.expectApproxEqAbs(0x1.e881b1d4eb2a1p-1, output[6], math.floatEpsAt(f64, 0x1.e881b1d4eb2a1p-1));
+    try testing.expectApproxEqAbs(0x1.1713f567a87efp-1, output[7], math.floatEpsAt(f64, 0x1.1713f567a87efp-1));
+    try testing.expectApproxEqAbs(0x1.bd5acbe8fcc59p+0, output[8], math.floatEpsAt(f64, 0x1.bd5acbe8fcc59p+0));
+    try testing.expectApproxEqAbs(0x1.6ce7d66f628e5p+1, output[9], math.floatEpsAt(f64, 0x1.6ce7d66f628e5p+1));
+}
diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig
index af8f3521b334d88586f048ec09810269d23ce04b..7c5eb68d014d27ea72ef991fb8f84ed64c474c2e 100644
--- a/lib/std/math/asin.zig
+++ b/lib/std/math/asin.zig
@@ -4,6 +4,12 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/asinf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/asin.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/asinl.c
+//
+// Ported from ARM-software, which is licensed under the MIT license:
+// https://github.com/ARM-software/optimized-routines/blob/master/LICENSE
+//
+// https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/asinf.c
+// https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/asin.c
 
 const std = @import("../std.zig");
 const math = std.math;
@@ -19,14 +25,22 @@ const native_endian = builtin.cpu.arch.endian();
 ///  - asin(x)   = nan if x < -1 or x > 1
 pub fn asin(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
-    return switch (T) {
-        f16 => asinBinary16(x),
-        f32 => asinBinary32(x),
-        f64 => asinBinary64(x),
-        f80 => asinExtended80(x),
-        f128 => asinBinary128(x),
-        else => @compileError("asin not implemented for " ++ @typeName(T)),
-    };
+    switch (@typeInfo(T)) {
+        .float => |info| switch (info.bits) {
+            16 => return asinBinary16(x),
+            32 => return asinBinary32(x),
+            64 => return asinBinary64(x),
+            80 => return asinExtended80(x),
+            128 => return asinBinary128(x),
+            else => comptime unreachable,
+        },
+        .vector => |info| switch (info.child) {
+            f32 => return asinBinary32Vec(info.len, x),
+            f64 => return asinBinary64Vec(info.len, x),
+            else => @compileError("unimplemented"),
+        },
+        else => comptime unreachable,
+    }
 }
 
 fn approxBinary16(z: f32) f32 {
@@ -435,3 +449,169 @@ test "asinBinary128" {
     try testing.expectApproxEqAbs(-0x1.97f1092fd94ac0fdfddae2e1222bp-1, asinBinary128(-0x1.6e210214e40edf6c8479998189d1p-1), math.floatEpsAt(f128, -0x1.97f1092fd94ac0fdfddae2e1222bp-1));
     try testing.expectApproxEqAbs(-0x1.97b62bc5ae6512093828828325e1p-3, asinBinary128(-0x1.95061bf93ed6986a45d20f0e1064p-3), math.floatEpsAt(f128, -0x1.97b62bc5ae6512093828828325e1p-3));
 }
+
+fn asinBinary32Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f32)) @TypeOf(x) {
+    const pi_over_2: @Vector(vec_len, f32) = @splat(math.pi / 2.0);
+    const zero: @Vector(vec_len, f32) = @splat(0.0);
+    const half: @Vector(vec_len, f32) = @splat(0.5);
+    const neg_two: @Vector(vec_len, f32) = @splat(-2.0);
+    const c0: @Vector(vec_len, f32) = @splat(0x1.55555ep-3);
+    const c1: @Vector(vec_len, f32) = @splat(0x1.33261ap-4);
+    const c2: @Vector(vec_len, f32) = @splat(0x1.70d7dcp-5);
+    const c3: @Vector(vec_len, f32) = @splat(0x1.b059dp-6);
+    const c4: @Vector(vec_len, f32) = @splat(0x1.3af7d8p-5);
+
+    const ax = @abs(x);
+    const ax_lt_half = ax < half;
+    const z2 = @select(f32, ax_lt_half, x * x, @mulAdd(@Vector(vec_len, f32), -half, ax, half));
+    const z = @select(f32, ax_lt_half, ax, @sqrt(z2));
+    const z3 = z2 * z;
+    const p3_4 = @mulAdd(@Vector(vec_len, f32), z2, c4, c3);
+    const p2_4 = @mulAdd(@Vector(vec_len, f32), z2, p3_4, c2);
+    const p1_4 = @mulAdd(@Vector(vec_len, f32), z2, p2_4, c1);
+    const p0_4 = @mulAdd(@Vector(vec_len, f32), z2, p1_4, c0);
+    const p = @mulAdd(@Vector(vec_len, f32), z3, p0_4, z);
+    const y = @select(f32, ax_lt_half, p, @mulAdd(@Vector(vec_len, f32), p, neg_two, pi_over_2));
+    return @select(f32, x < zero, -y, y);
+}
+
+fn asinBinary64Vec(comptime vec_len: comptime_int, x: @Vector(vec_len, f64)) @TypeOf(x) {
+    const pi_over_2: @Vector(vec_len, f64) = @splat(math.pi / 2.0);
+    const zero: @Vector(vec_len, f64) = @splat(0.0);
+    const half: @Vector(vec_len, f64) = @splat(0.5);
+    const neg_two: @Vector(vec_len, f64) = @splat(-2.0);
+    const c0: @Vector(vec_len, f64) = @splat(0x1.555555555554ep-3);
+    const c1: @Vector(vec_len, f64) = @splat(0x1.3333333337233p-4);
+    const c2: @Vector(vec_len, f64) = @splat(0x1.6db6db67f6d9fp-5);
+    const c3: @Vector(vec_len, f64) = @splat(0x1.f1c71fbd29fbbp-6);
+    const c4: @Vector(vec_len, f64) = @splat(0x1.6e8b264d467d6p-6);
+    const c5: @Vector(vec_len, f64) = @splat(0x1.1c5997c357e9dp-6);
+    const c6: @Vector(vec_len, f64) = @splat(0x1.c86a22cd9389dp-7);
+    const c7: @Vector(vec_len, f64) = @splat(0x1.856073c22ebbep-7);
+    const c8: @Vector(vec_len, f64) = @splat(0x1.fd1151acb6bedp-8);
+    const c9: @Vector(vec_len, f64) = @splat(0x1.087182f799c1dp-6);
+    const c10: @Vector(vec_len, f64) = @splat(-0x1.6602748120927p-7);
+    const c11: @Vector(vec_len, f64) = @splat(0x1.cfa0dd1f9478p-6);
+
+    const ax = @abs(x);
+    const ax_lt_half = ax < half;
+    const z2 = @select(f64, ax_lt_half, x * x, @mulAdd(@Vector(vec_len, f64), -half, ax, half));
+    const z = @select(f64, ax_lt_half, ax, @sqrt(z2));
+    const z3 = z2 * z;
+    const z4 = z2 * z2;
+    const z8 = z4 * z4;
+    const p0_1 = @mulAdd(@Vector(vec_len, f64), z2, c1, c0);
+    const p2_3 = @mulAdd(@Vector(vec_len, f64), z2, c3, c2);
+    const p0_3 = @mulAdd(@Vector(vec_len, f64), z4, p2_3, p0_1);
+    const p4_5 = @mulAdd(@Vector(vec_len, f64), z2, c5, c4);
+    const p6_7 = @mulAdd(@Vector(vec_len, f64), z2, c7, c6);
+    const p4_7 = @mulAdd(@Vector(vec_len, f64), z4, p6_7, p4_5);
+    const p8_9 = @mulAdd(@Vector(vec_len, f64), z2, c9, c8);
+    const p10_11 = @mulAdd(@Vector(vec_len, f64), z2, c11, c10);
+    const p8_11 = @mulAdd(@Vector(vec_len, f64), z4, p10_11, p8_9);
+    const p4_11 = @mulAdd(@Vector(vec_len, f64), z8, p8_11, p4_7);
+    const p0_11 = @mulAdd(@Vector(vec_len, f64), z8, p4_11, p0_3);
+    const p = @mulAdd(@Vector(vec_len, f64), z3, p0_11, z);
+    const y = @select(f64, ax_lt_half, p, @mulAdd(@Vector(vec_len, f64), p, neg_two, pi_over_2));
+    return @select(f64, x < zero, -y, y);
+}
+
+test "asinBinary32Vec.special" {
+    const input: @Vector(9, f32) = .{
+        0x1p+0,
+        -0x1p+0,
+        0x0p+0,
+        -0x0p+0,
+        0x1.000002p+0,
+        -0x1.000002p+0,
+        math.inf(f32),
+        -math.inf(f32),
+        math.nan(f32),
+    };
+    const output = asinBinary32Vec(9, input);
+    try testing.expectApproxEqAbs(0x1.921fb6p+0, output[0], math.floatEpsAt(f32, 0x1.921fb6p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb6p+0, output[1], math.floatEpsAt(f32, -0x1.921fb6p+0));
+    try testing.expectEqual(0x0p+0, output[2]);
+    try testing.expectEqual(0x0p+0, output[3]);
+    try testing.expect(math.isNan(output[4]));
+    try testing.expect(math.isNan(output[5]));
+    try testing.expect(math.isNan(output[6]));
+    try testing.expect(math.isNan(output[7]));
+    try testing.expect(math.isNan(output[8]));
+}
+
+test "asinBinary32Vec" {
+    const input: @Vector(10, f32) = .{
+        -0x1.4c2906p-4,
+        0x1.05fcfap-1,
+        0x1.fab976p-2,
+        0x1.8b4b8cp-1,
+        0x1.7117c2p-1,
+        0x1.e5e112p-5,
+        -0x1.07673p-2,
+        -0x1.2108dep-2,
+        -0x1.4e6e6cp-1,
+        0x1.22a16ap-1,
+    };
+    const output = asinBinary32Vec(10, input);
+    try testing.expectApproxEqAbs(-0x1.4c868p-4, output[0], math.floatEpsAt(f32, -0x1.4c868p-4));
+    try testing.expectApproxEqAbs(0x1.130648p-1, output[1], math.floatEpsAt(f32, 0x1.130648p-1));
+    try testing.expectApproxEqAbs(0x1.090abcp-1, output[2], math.floatEpsAt(f32, 0x1.090abcp-1));
+    try testing.expectApproxEqAbs(0x1.c39fa2p-1, output[3], math.floatEpsAt(f32, 0x1.c39fa2p-1));
+    try testing.expectApproxEqAbs(0x1.9c332p-1, output[4], math.floatEpsAt(f32, 0x1.9c332p-1));
+    try testing.expectApproxEqAbs(0x1.e62a1cp-5, output[5], math.floatEpsAt(f32, 0x1.e62a1cp-5));
+    try testing.expectApproxEqAbs(-0x1.0a65dep-2, output[6], math.floatEpsAt(f32, -0x1.0a65dep-2));
+    try testing.expectApproxEqAbs(-0x1.25046p-2, output[7], math.floatEpsAt(f32, -0x1.25046p-2));
+    try testing.expectApproxEqAbs(-0x1.6c6f0cp-1, output[8], math.floatEpsAt(f32, -0x1.6c6f0cp-1));
+    try testing.expectApproxEqAbs(0x1.350f7ap-1, output[9], math.floatEpsAt(f32, 0x1.350f7ap-1));
+}
+
+test "asinBinary64Vec.special" {
+    const input: @Vector(9, f64) = .{
+        0x1p+0,
+        -0x1p+0,
+        0x0p+0,
+        -0x0p+0,
+        0x1.000002p+0,
+        -0x1.000002p+0,
+        math.inf(f64),
+        -math.inf(f64),
+        math.nan(f64),
+    };
+    const output = asinBinary64Vec(9, input);
+    try testing.expectApproxEqAbs(0x1.921fb54442d18p+0, output[0], math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
+    try testing.expectApproxEqAbs(-0x1.921fb54442d18p+0, output[1], math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
+    try testing.expectEqual(0x0p+0, output[2]);
+    try testing.expectEqual(0x0p+0, output[3]);
+    try testing.expect(math.isNan(output[4]));
+    try testing.expect(math.isNan(output[5]));
+    try testing.expect(math.isNan(output[6]));
+    try testing.expect(math.isNan(output[7]));
+    try testing.expect(math.isNan(output[8]));
+}
+
+test "asinBinary64Vec" {
+    const input: @Vector(10, f64) = .{
+        0x1.e674fba3e40d5p-2,
+        -0x1.30fd0566fd979p-1,
+        0x1.6444a25abfeaap-2,
+        0x1.40a53228d1a13p-1,
+        -0x1.ccc6d64845cfdp-1,
+        -0x1.94bd91b7fc74bp-1,
+        -0x1.8d741b5797fccp-2,
+        -0x1.3e8e7e15881c5p-3,
+        -0x1.88222d8ab8ca9p-2,
+        -0x1.41c0e9babcbd2p-2,
+    };
+    const output = asinBinary64Vec(10, input);
+    try testing.expectApproxEqAbs(0x1.fae86c5941692p-2, output[0], math.floatEpsAt(f64, 0x1.fae86c5941692p-2));
+    try testing.expectApproxEqAbs(-0x1.46b6ad730c93ap-1, output[1], math.floatEpsAt(f64, -0x1.46b6ad730c93ap-1));
+    try testing.expectApproxEqAbs(0x1.6be0be8074eep-2, output[2], math.floatEpsAt(f64, 0x1.6be0be8074eep-2));
+    try testing.expectApproxEqAbs(0x1.5a7e98f53f717p-1, output[3], math.floatEpsAt(f64, 0x1.5a7e98f53f717p-1));
+    try testing.expectApproxEqAbs(-0x1.1ea2602d14e8p0, output[4], math.floatEpsAt(f64, -0x1.1ea2602d14e8p0));
+    try testing.expectApproxEqAbs(-0x1.d2c2634193158p-1, output[5], math.floatEpsAt(f64, -0x1.d2c2634193158p-1));
+    try testing.expectApproxEqAbs(-0x1.982d5f1895d2p-2, output[6], math.floatEpsAt(f64, -0x1.982d5f1895d2p-2));
+    try testing.expectApproxEqAbs(-0x1.3fdaf7dfdc864p-3, output[7], math.floatEpsAt(f64, -0x1.3fdaf7dfdc864p-3));
+    try testing.expectApproxEqAbs(-0x1.9269540735b7bp-2, output[8], math.floatEpsAt(f64, -0x1.9269540735b7bp-2));
+    try testing.expectApproxEqAbs(-0x1.474c4c6625527p-2, output[9], math.floatEpsAt(f64, -0x1.474c4c6625527p-2));
+}
-- 
2.54.0


From b7f93695f90e92b4437346bd993bbdb4d86f7b07 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sat, 14 Feb 2026 04:49:03 -0500
Subject: [PATCH 304/499] Io.Dispatch.Mutex: fix deadlock conditions

---
 lib/std/Io/Dispatch.zig       | 275 ++++++++++++++++++----------------
 lib/std/c/darwin/dispatch.zig |   6 +-
 2 files changed, 150 insertions(+), 131 deletions(-)

diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 49df71ef9499ba46640761ada9b261f4af069dc0..81b9d207f385adb9216bc5a0d850b92f6ec9b6c6 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -280,7 +280,7 @@ const Fiber = struct {
             .select => if (@atomicRmw(i32, &fiber.await_count, .Add, 1, .monotonic) == -1) {
                 ev.queue.async(fiber, &Fiber.@"resume");
             },
-            _ => |awaiting| awaiting.toCancelable().canceled(),
+            _ => |awaiting| awaiting.toCancelable().async(),
         }
     }
 
@@ -484,7 +484,7 @@ pub fn io(ev: *Evented) Io {
 
 pub const InitOptions = struct {
     backing_allocator_needs_mutex: bool = true,
-    queue: ?c.dispatch.queue_t = null,
+    target_queue: ?c.dispatch.queue_t = .TARGET_DEFAULT,
     /// Upper limit on the allowable delay in processing timeouts in order to improve power
     /// consumption and system performance.
     leeway: Io.Duration = .fromMilliseconds(10),
@@ -499,11 +499,11 @@ pub const InitOptions = struct {
 };
 
 pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !void {
-    const queue = if (options.queue) |queue| queue: {
-        queue.as_object().retain();
-        break :queue queue;
-    } else c.dispatch.queue_create("org.ziglang.std.Io.Dispatch", .CONCURRENT()) orelse
-        return error.SystemResources;
+    const queue = c.dispatch.queue_create_with_target(
+        "org.ziglang.std.Io.Dispatch",
+        .CONCURRENT(),
+        options.target_queue,
+    ) orelse return error.SystemResources;
     errdefer queue.as_object().release();
     const main_loop_stack = try backing_allocator.alignedAlloc(
         u8,
@@ -727,9 +727,9 @@ const Cancelable = struct {
 
     const blocked: Cancelable = .{ .queue = undefined, .cancel = is_blocked };
 
-    const AwaitError = error{CancelRequested};
+    const RequestedError = error{CancelRequested};
 
-    fn await(cancelable: *Cancelable, fiber: *Fiber) AwaitError!void {
+    fn enter(cancelable: *Cancelable, fiber: *Fiber) RequestedError!void {
         const function = cancelable.cancel;
         assert(function != is_requested);
         if (function == is_blocked) {
@@ -750,13 +750,42 @@ const Cancelable = struct {
         }
     }
 
-    fn canceled(cancelable: *Cancelable) void {
-        assert(cancelable.cancel != is_blocked);
-        assert(cancelable.cancel != is_requested);
-        cancelable.queue.async(cancelable, cancelable.cancel);
+    fn leave(cancelable: *Cancelable, fiber: *Fiber) RequestedError!void {
+        const function = cancelable.cancel;
+        assert(function != is_requested);
+        if (function == is_blocked) {
+            @branchHint(.unlikely);
+            return;
+        }
+        const cancel_status = @atomicRmw(Fiber.CancelStatus, &fiber.cancel_status, .And, .{
+            .requested = true,
+            .awaiting = .nothing,
+        }, .monotonic);
+        assert(cancel_status.awaiting.toCancelable() == cancelable);
+        if (cancel_status.requested) return error.CancelRequested;
     }
 
-    fn check(cancelable: *Cancelable, fiber: *Fiber) Io.Cancelable!void {
+    fn async(cancelable: *Cancelable) void {
+        const function = cancelable.cancel;
+        assert(function != is_blocked and function != is_requested);
+        cancelable.queue.async(cancelable, function);
+    }
+
+    fn requested(cancelable: *Cancelable, fiber: *Fiber) void {
+        const function = cancelable.cancel;
+        assert(function != is_blocked and function != is_requested);
+        assert(@atomicLoad(Fiber.CancelStatus, &fiber.cancel_status, .monotonic) == Fiber.CancelStatus{
+            .requested = true,
+            .awaiting = .fromCancelable(cancelable),
+        });
+        cancelable.cancel = is_requested;
+        @atomicStore(Fiber.CancelStatus, &fiber.cancel_status, .{
+            .requested = true,
+            .awaiting = .nothing,
+        }, .monotonic);
+    }
+
+    fn acknowledge(cancelable: *Cancelable, fiber: *Fiber) Io.Cancelable!void {
         if (cancelable.cancel == is_requested) {
             @branchHint(.unlikely);
             fiber.cancel_protection.acknowledge();
@@ -784,81 +813,97 @@ const Sleeper = struct {
 };
 
 const Mutex = struct {
-    /// including the locker
-    num_waiters: usize,
+    state: State,
     queue: c.dispatch.queue_t,
     waiters: std.DoublyLinkedList,
 
+    const State = packed struct(usize) {
+        locked: bool,
+        num_waiters: NumWaiters,
+
+        const NumWaiters = @Int(.unsigned, @bitSizeOf(usize) - 1);
+    };
+
     const Waiter = struct {
         sleeper: Sleeper = undefined,
         cancelable: Cancelable,
         mutex: *Mutex,
-        node: std.DoublyLinkedList.Node = .{},
+        node: std.DoublyLinkedList.Node = undefined,
 
         fn add(context: ?*anyopaque) callconv(.c) void {
             const waiter: *Waiter = @ptrCast(@alignCast(context));
-            waiter.tryAdd() catch |err| switch (err) {
+            waiter.cancelable.enter(waiter.sleeper.fiber) catch |err| switch (err) {
+                error.CancelRequested => return waiter.wake(),
+            };
+            var state = @atomicRmw(State, &waiter.mutex.state, .Add, .{
+                .locked = false,
+                .num_waiters = 1,
+            }, .monotonic);
+            state.num_waiters += 1;
+            while (!state.locked) {
+                @branchHint(.unlikely);
+                state = @cmpxchgWeak(State, &waiter.mutex.state, state, .{
+                    .locked = true,
+                    .num_waiters = state.num_waiters - 1,
+                }, .acquire, .monotonic) orelse break;
+            } else return waiter.mutex.waiters.append(&waiter.node);
+            waiter.cancelable.leave(waiter.sleeper.fiber) catch |err| switch (err) {
                 error.CancelRequested => {
-                    waiter.wake();
-                    assert(@atomicRmw(usize, &waiter.mutex.num_waiters, .Sub, 1, .monotonic) >= 1);
+                    waiter.node.next = &waiter.node;
+                    return;
                 },
             };
-        }
-
-        fn tryAdd(waiter: *Waiter) Cancelable.AwaitError!void {
-            switch (@atomicLoad(usize, &waiter.mutex.num_waiters, .acquire)) {
-                0 => unreachable,
-                1 => return waiter.wake(), // already locked exclusively
-                else => try waiter.cancelable.await(waiter.sleeper.fiber),
-            }
-            waiter.mutex.waiters.append(&waiter.node);
+            waiter.wake();
         }
 
         fn canceled(context: ?*anyopaque) callconv(.c) void {
             const cancelable: *Cancelable = @ptrCast(@alignCast(context));
-            cancelable.cancel = Cancelable.is_requested;
             const waiter: *Waiter = @fieldParentPtr("cancelable", cancelable);
-            assert(@atomicRmw(
-                Fiber.CancelStatus,
-                &waiter.sleeper.fiber.cancel_status,
-                .Xchg,
-                .{ .requested = true, .awaiting = .nothing },
-                .monotonic,
-            ) == Fiber.CancelStatus{ .requested = true, .awaiting = .fromCancelable(cancelable) });
+            cancelable.requested(waiter.sleeper.fiber);
             const mutex = waiter.mutex;
-            mutex.waiters.remove(&waiter.node);
+            if (waiter.node.next != &waiter.node) {
+                @branchHint(.likely);
+                mutex.waiters.remove(&waiter.node);
+                assert(@atomicRmw(State, &mutex.state, .Sub, .{
+                    .locked = false,
+                    .num_waiters = 1,
+                }, .monotonic).num_waiters >= 1);
+            }
+            waiter.node = undefined;
             waiter.wake();
-            assert(@atomicRmw(usize, &mutex.num_waiters, .Sub, 1, .monotonic) >= 1);
         }
 
         fn remove(context: ?*anyopaque) callconv(.c) void {
             const mutex: *Mutex = @ptrCast(@alignCast(context));
-            var stop_node: ?*std.DoublyLinkedList.Node = null;
-            while (mutex.waiters.first != stop_node) {
+            var state = @atomicLoad(State, &mutex.state, .monotonic);
+            while (!state.locked and state.num_waiters > 0) {
                 @branchHint(.likely);
-                const waiter: *Waiter = @fieldParentPtr("node", mutex.waiters.popFirst().?);
-                if (waiter.cancelable.cancel != Cancelable.is_blocked) {
-                    @branchHint(.likely);
-                    const cancel_status = @atomicRmw(
-                        Fiber.CancelStatus,
-                        &waiter.sleeper.fiber.cancel_status,
-                        .And,
-                        .{ .requested = true, .awaiting = .nothing },
-                        .monotonic,
-                    );
-                    assert(cancel_status.awaiting.toCancelable() == &waiter.cancelable);
-                    if (cancel_status.requested) {
-                        @branchHint(.unlikely);
-                        // carefully place the hot potato out of the way
-                        mutex.waiters.append(&waiter.node);
-                        if (stop_node == null) stop_node = &waiter.node;
+                state = @cmpxchgWeak(State, &mutex.state, state, .{
+                    .locked = true,
+                    .num_waiters = state.num_waiters - 1,
+                }, .acquire, .monotonic) orelse break;
+            } else return;
+            var num_removed: State.NumWaiters = 0;
+            while (mutex.waiters.popFirst()) |node| {
+                @branchHint(.likely);
+                const waiter: *Waiter = @fieldParentPtr("node", node);
+                node.* = undefined;
+                waiter.cancelable.leave(waiter.sleeper.fiber) catch |err| switch (err) {
+                    error.CancelRequested => {
+                        num_removed += 1;
+                        node.next = node;
                         continue;
-                    }
-                }
-                waiter.wake();
-                return;
+                    },
+                };
+                break;
+            }
+            if (num_removed > 0) {
+                @branchHint(.unlikely);
+                assert(@atomicRmw(State, &mutex.state, .Sub, .{
+                    .locked = false,
+                    .num_waiters = num_removed,
+                }, .monotonic).num_waiters >= num_removed);
             }
-            // everyone is about to die, nobody will wake up ;-(
         }
 
         fn wake(waiter: *Waiter) void {
@@ -868,7 +913,7 @@ const Mutex = struct {
 
     fn init(mutex: *Mutex, queue: c.dispatch.queue_t) error{SystemResources}!void {
         mutex.* = .{
-            .num_waiters = 0,
+            .state = .{ .locked = false, .num_waiters = 0 },
             .queue = c.dispatch.queue_create_with_target(
                 "org.ziglang.std.Io.Dispatch.Mutex",
                 .SERIAL(),
@@ -879,56 +924,48 @@ const Mutex = struct {
     }
 
     fn deinit(mutex: *Mutex) void {
-        assert(mutex.num_waiters == 0 and mutex.waiters.first == null and mutex.waiters.last == null);
+        assert(mutex.state == State{ .locked = false, .num_waiters = 0 });
+        assert(mutex.waiters.first == null and mutex.waiters.last == null);
         mutex.queue.as_object().release();
         mutex.* = undefined;
     }
 
     fn tryLock(mutex: *Mutex) bool {
-        if (@cmpxchgWeak(usize, &mutex.num_waiters, 0, 1, .acquire, .monotonic) == null) {
-            @branchHint(.likely);
-            return true;
+        const state =
+            @atomicRmw(State, &mutex.state, .Or, .{ .locked = true, .num_waiters = 0 }, .acquire);
+        if (state.locked) {
+            @branchHint(.unlikely);
         }
-        return false;
+        return !state.locked;
     }
 
     fn lock(mutex: *Mutex, ev: *Evented) Io.Cancelable!void {
-        switch (@atomicRmw(usize, &mutex.num_waiters, .Add, 1, .acquire)) {
-            0 => {},
-            else => {
-                @branchHint(.unlikely);
-                var waiter: Waiter = .{
-                    .cancelable = .{ .queue = mutex.queue, .cancel = &Mutex.Waiter.canceled },
-                    .mutex = mutex,
-                };
-                ev.yield(.{ .mutex_wait = &waiter });
-                try waiter.cancelable.check(waiter.sleeper.fiber);
-            },
-        }
+        if (mutex.tryLock()) return;
+        var waiter: Waiter = .{
+            .cancelable = .{ .queue = mutex.queue, .cancel = &Mutex.Waiter.canceled },
+            .mutex = mutex,
+        };
+        ev.yield(.{ .mutex_wait = &waiter });
+        try waiter.cancelable.acknowledge(waiter.sleeper.fiber);
     }
 
     fn lockUncancelable(mutex: *Mutex, ev: *Evented) void {
-        switch (@atomicRmw(usize, &mutex.num_waiters, .Add, 1, .acquire)) {
-            0 => {},
-            else => {
-                @branchHint(.unlikely);
-                var waiter: Waiter = .{ .cancelable = .blocked, .mutex = mutex };
-                ev.yield(.{ .mutex_wait = &waiter });
-                waiter.cancelable.check(waiter.sleeper.fiber) catch |err| switch (err) {
-                    error.Canceled => unreachable, // blocked
-                };
-            },
-        }
+        if (mutex.tryLock()) return;
+        var waiter: Waiter = .{ .cancelable = .blocked, .mutex = mutex };
+        ev.yield(.{ .mutex_wait = &waiter });
+        waiter.cancelable.acknowledge(waiter.sleeper.fiber) catch |err| switch (err) {
+            error.Canceled => unreachable, // blocked
+        };
     }
 
     fn unlock(mutex: *Mutex) void {
-        switch (@atomicRmw(usize, &mutex.num_waiters, .Sub, 1, .release)) {
-            0 => unreachable,
-            1 => {},
-            else => {
-                @branchHint(.unlikely);
-                mutex.queue.async(mutex, &Waiter.remove);
-            },
+        const state = @atomicRmw(State, &mutex.state, .And, .{
+            .locked = false,
+            .num_waiters = std.math.maxInt(State.NumWaiters),
+        }, .release);
+        if (state.num_waiters > 0) {
+            @branchHint(.unlikely);
+            mutex.queue.async(mutex, &Waiter.remove);
         }
     }
 };
@@ -1517,10 +1554,10 @@ const Futex = struct {
             };
         }
 
-        fn tryAdd(waiter: *Waiter) Cancelable.AwaitError!void {
+        fn tryAdd(waiter: *Waiter) Cancelable.RequestedError!void {
             if (@atomicLoad(u32, waiter.ptr, .monotonic) != waiter.expected)
                 return error.CancelRequested;
-            try waiter.cancelable.await(waiter.sleeper.fiber);
+            try waiter.cancelable.enter(waiter.sleeper.fiber);
             const futex = waiter.futex;
             switch (waiter.timeout) {
                 .FOREVER => {},
@@ -1542,46 +1579,28 @@ const Futex = struct {
 
         fn canceled(context: ?*anyopaque) callconv(.c) void {
             const cancelable: *Cancelable = @ptrCast(@alignCast(context));
-            cancelable.cancel = Cancelable.is_requested;
             const waiter: *Waiter = @fieldParentPtr("cancelable", cancelable);
-            assert(@atomicRmw(
-                Fiber.CancelStatus,
-                &waiter.sleeper.fiber.cancel_status,
-                .Xchg,
-                .{ .requested = true, .awaiting = .nothing },
-                .monotonic,
-            ) == Fiber.CancelStatus{ .requested = true, .awaiting = .fromCancelable(cancelable) });
+            cancelable.requested(waiter.sleeper.fiber);
             const futex = waiter.futex;
-            waiter.removeUncancelable();
+            waiter.remove();
             assert(@atomicRmw(usize, &futex.num_waiters, .Sub, 1, .monotonic) >= 1);
         }
 
         fn timedOut(context: ?*anyopaque) callconv(.c) void {
             const waiter: *Waiter = @ptrCast(@alignCast(context));
             const futex = waiter.futex;
-            waiter.remove() catch |err| switch (err) {
+            waiter.tryRemove() catch |err| switch (err) {
                 error.CancelRequested => return,
             };
             assert(@atomicRmw(usize, &futex.num_waiters, .Sub, 1, .monotonic) >= 1);
         }
 
-        fn remove(waiter: *Waiter) Cancelable.AwaitError!void {
-            if (waiter.cancelable.cancel != Cancelable.is_blocked) {
-                @branchHint(.likely);
-                const cancel_status = @atomicRmw(
-                    Fiber.CancelStatus,
-                    &waiter.sleeper.fiber.cancel_status,
-                    .And,
-                    .{ .requested = true, .awaiting = .nothing },
-                    .monotonic,
-                );
-                assert(cancel_status.awaiting.toCancelable() == &waiter.cancelable);
-                if (cancel_status.requested) return error.CancelRequested;
-            }
-            waiter.removeUncancelable();
+        fn tryRemove(waiter: *Waiter) Cancelable.RequestedError!void {
+            try waiter.cancelable.leave(waiter.sleeper.fiber);
+            waiter.remove();
         }
 
-        fn removeUncancelable(waiter: *Waiter) void {
+        fn remove(waiter: *Waiter) void {
             waiter.futex.waiters.remove(&waiter.node);
             if (waiter.timer) |timer| timer.cancel() else wake(waiter);
         }
@@ -1614,7 +1633,7 @@ const Futex = struct {
                     @branchHint(.unlikely);
                     continue;
                 }
-                waiter.remove() catch |err| switch (err) {
+                waiter.tryRemove() catch |err| switch (err) {
                     error.CancelRequested => continue,
                 };
                 num_removed += 1;
@@ -1720,7 +1739,7 @@ fn futexWait(
         .leeway = ev.leeway,
     };
     ev.yield(.{ .futex_wait = &waiter });
-    try waiter.cancelable.check(waiter.sleeper.fiber);
+    try waiter.cancelable.acknowledge(waiter.sleeper.fiber);
 }
 
 fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
@@ -1734,7 +1753,7 @@ fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32)
         .leeway = ev.leeway,
     };
     ev.yield(.{ .futex_wait = &waiter });
-    waiter.cancelable.check(waiter.sleeper.fiber) catch |err| switch (err) {
+    waiter.cancelable.acknowledge(waiter.sleeper.fiber) catch |err| switch (err) {
         error.Canceled => unreachable, // blocked
     };
 }
diff --git a/lib/std/c/darwin/dispatch.zig b/lib/std/c/darwin/dispatch.zig
index 2bd44b9f01cd5e636088c4725f68e2a9b3fdfe06..68b0b48782b02295064a6362b9ed0e249a92659e 100644
--- a/lib/std/c/darwin/dispatch.zig
+++ b/lib/std/c/darwin/dispatch.zig
@@ -39,14 +39,13 @@ pub const once_t = enum(isize) {
     _,
 
     pub inline fn once(predicate: *once_t, context: ?*anyopaque, function: function_t) void {
-        if (@atomicLoad(once_t, predicate, .unordered) != .done) {
+        if (predicate.* != .done) {
             @branchHint(.unlikely);
             once_f(predicate, context, function);
         } else asm volatile ("" ::: .{ .memory = true });
         switch (builtin.mode) {
             .Debug, .ReleaseSafe => {},
-            .ReleaseFast, .ReleaseSmall => if (@atomicLoad(once_t, predicate, .unordered) != .done)
-                unreachable,
+            .ReleaseFast, .ReleaseSmall => if (predicate.* != .done) unreachable,
         }
     }
 };
@@ -110,6 +109,7 @@ const queue_s = opaque {
     pub const get_current = get_current_queue;
     pub const get_main = get_main_queue;
     pub const get_global = get_global_queue;
+    pub const TARGET_DEFAULT = TARGET_QUEUE_DEFAULT;
     pub const create_with_target = queue_create_with_target;
     pub const create = queue_create;
     pub const get_label = queue_get_label;
-- 
2.54.0


From 771047ae930f73de14c30ec972d5c9a71c48b271 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sat, 14 Feb 2026 05:42:15 -0500
Subject: [PATCH 305/499] Io.Dispatch.sleep: add cancelation support

---
 lib/std/Io/Dispatch.zig | 79 ++++++++++++++++++++++++++++++++++++++---
 1 file changed, 75 insertions(+), 4 deletions(-)

diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 81b9d207f385adb9216bc5a0d850b92f6ec9b6c6..959cb86421fd02af83f316353ec79c2388161174 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -650,7 +650,8 @@ const SwitchMessage = struct {
         mutex_wait: *Mutex.Waiter,
         futex_wait: *Futex.Waiter,
         futex_wake: *Futex.Waker,
-        sleep: c.dispatch.time_t,
+        sleep_wait: *SleepWaiter,
+        after: c.dispatch.time_t,
         destroy,
         exit,
     };
@@ -698,7 +699,17 @@ const SwitchMessage = struct {
                     .init(ev.queue, @alignCast(@fieldParentPtr("context", message.contexts.old)));
                 waker.futex.queue.async(waker, &Futex.Waker.remove);
             },
-            .sleep => |when| {
+            .sleep_wait => |waiter| {
+                waiter.sleeper =
+                    .init(ev.queue, @alignCast(@fieldParentPtr("context", message.contexts.old)));
+                const queue = waiter.cancelable.queue;
+                switch (waiter.sleeper.fiber.cancel_protection.check()) {
+                    .unblocked => {},
+                    .blocked => waiter.cancelable = .blocked,
+                }
+                queue.async(waiter, &SleepWaiter.start);
+            },
+            .after => |when| {
                 const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
                 when.after(ev.queue, fiber, &Fiber.@"resume");
             },
@@ -1563,7 +1574,7 @@ const Futex = struct {
                 .FOREVER => {},
                 else => |timeout| {
                     const timer = c.dispatch.source_create(.TIMER, 0, .none, futex.queue) orelse {
-                        log.warn("unable to create timer for futex timeout", .{});
+                        log.warn("failed to create timer for futex timeout", .{});
                         return error.CancelRequested;
                     };
                     timer.as_object().set_context(waiter);
@@ -4738,9 +4749,69 @@ fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionEr
     };
 }
 
+const SleepWaiter = struct {
+    sleeper: Sleeper = undefined,
+    cancelable: Cancelable,
+    timer: c.dispatch.source_t,
+    started: bool = false,
+
+    fn start(context: ?*anyopaque) callconv(.c) void {
+        const waiter: *SleepWaiter = @ptrCast(@alignCast(context));
+        waiter.cancelable.enter(waiter.sleeper.fiber) catch |err| switch (err) {
+            error.CancelRequested => waiter.timer.cancel(),
+        };
+        waiter.timer.as_object().activate();
+    }
+
+    fn timedOut(context: ?*anyopaque) callconv(.c) void {
+        const waiter: *SleepWaiter = @ptrCast(@alignCast(context));
+        waiter.cancelable.leave(waiter.sleeper.fiber) catch |err| switch (err) {
+            error.CancelRequested => return,
+        };
+        waiter.timer.cancel();
+    }
+
+    fn canceled(context: ?*anyopaque) callconv(.c) void {
+        const cancelable: *Cancelable = @ptrCast(@alignCast(context));
+        const waiter: *SleepWaiter = @fieldParentPtr("cancelable", cancelable);
+        cancelable.requested(waiter.sleeper.fiber);
+        waiter.timer.cancel();
+    }
+
+    fn wake(context: ?*anyopaque) callconv(.c) void {
+        const waiter: *SleepWaiter = @ptrCast(@alignCast(context));
+        var sleeper = waiter.sleeper;
+        waiter.* = undefined;
+        Sleeper.wake(&sleeper);
+    }
+};
+
 fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    ev.yield(.{ .sleep = ev.timeFromTimeout(timeout) });
+    const queue = c.dispatch.queue_create_with_target(
+        "org.ziglang.std.Io.Dispatch.sleep",
+        .SERIAL(),
+        ev.queue,
+    ) orelse {
+        log.warn("failed to create serial queue for sleep", .{});
+        return ev.yield(.{ .after = ev.timeFromTimeout(timeout) });
+    };
+    defer queue.as_object().release();
+    const timer = c.dispatch.source_create(.TIMER, 0, .none, queue) orelse {
+        log.warn("failed to create timer for sleep", .{});
+        return ev.yield(.{ .after = ev.timeFromTimeout(timeout) });
+    };
+    var waiter: SleepWaiter = .{
+        .cancelable = .{ .queue = queue, .cancel = &Futex.Waiter.canceled },
+        .timer = timer,
+    };
+    timer.as_object().set_context(&waiter);
+    timer.set_event_handler(&SleepWaiter.timedOut);
+    timer.set_cancel_handler(&SleepWaiter.wake);
+    timer.set_timer(ev.timeFromTimeout(timeout), c.dispatch.TIME_FOREVER, ev.leeway);
+    ev.yield(.{ .sleep_wait = &waiter });
+    timer.as_object().release();
+    try waiter.cancelable.acknowledge(waiter.sleeper.fiber);
 }
 
 fn timeFromTimeout(ev: *Evented, timeout: Io.Timeout) c.dispatch.time_t {
-- 
2.54.0


From d9fc7fa04db797d7b27dab2d9d6f56f63848da76 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 14 Feb 2026 18:31:48 -0800
Subject: [PATCH 306/499] std.Io: remove select function

This function works with a slice of futures and returns the index of a
completed one. This doesn't work very well in practice because it's
either too high level or too low level.

At the lower level we have Io.Batch for doing this kind of thing at the
Operation API layer.

At the higher level we have Io.Select which is a convenience wrapper
around an Io.Group and an Io.Queue.
---
 lib/std/Io.zig          | 38 ----------------------
 lib/std/Io/Dispatch.zig | 50 -----------------------------
 lib/std/Io/Kqueue.zig   | 22 -------------
 lib/std/Io/Threaded.zig | 70 -----------------------------------------
 lib/std/Io/Uring.zig    | 61 ++---------------------------------
 lib/std/Io/test.zig     | 34 --------------------
 6 files changed, 2 insertions(+), 273 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index daced32fa855d618e6a8750abb5ac61329b291c4..eb0d28dff3a15c3adfba556a2fc149da010969cb 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -144,10 +144,6 @@ pub const VTable = struct {
     swapCancelProtection: *const fn (?*anyopaque, new: CancelProtection) CancelProtection,
     checkCancel: *const fn (?*anyopaque) Cancelable!void,
 
-    /// Blocks until one of the futures from the list has a result ready, such
-    /// that awaiting it will not block. Returns that index.
-    select: *const fn (?*anyopaque, futures: []const *AnyFuture) Cancelable!usize,
-
     futexWait: *const fn (?*anyopaque, ptr: *const u32, expected: u32, Timeout) Cancelable!void,
     futexWaitUncancelable: *const fn (?*anyopaque, ptr: *const u32, expected: u32) void,
     futexWake: *const fn (?*anyopaque, ptr: *const u32, max_waiters: u32) void,
@@ -2120,40 +2116,6 @@ pub fn sleep(io: Io, duration: Duration, clock: Clock) Cancelable!void {
     } });
 }
 
-/// Given a struct with each field a `*Future`, returns a union with the same
-/// fields, each field type the future's result.
-pub fn SelectUnion(S: type) type {
-    const struct_fields = @typeInfo(S).@"struct".fields;
-    var names: [struct_fields.len][]const u8 = undefined;
-    var types: [struct_fields.len]type = undefined;
-    for (struct_fields, &names, &types) |struct_field, *union_field_name, *UnionFieldType| {
-        const FieldFuture = @typeInfo(struct_field.type).pointer.child;
-        union_field_name.* = struct_field.name;
-        UnionFieldType.* = @FieldType(FieldFuture, "result");
-    }
-    return @Union(.auto, std.meta.FieldEnum(S), &names, &types, &@splat(.{}));
-}
-
-/// `s` is a struct with every field a `*Future(T)`, where `T` can be any type,
-/// and can be different for each field.
-pub fn select(io: Io, s: anytype) Cancelable!SelectUnion(@TypeOf(s)) {
-    const U = SelectUnion(@TypeOf(s));
-    const S = @TypeOf(s);
-    const fields = @typeInfo(S).@"struct".fields;
-    var futures: [fields.len]*AnyFuture = undefined;
-    inline for (fields, &futures) |field, *any_future| {
-        const future = @field(s, field.name);
-        any_future.* = future.any_future orelse return @unionInit(U, field.name, future.result);
-    }
-    switch (try io.vtable.select(io.userdata, &futures)) {
-        inline 0...(fields.len - 1) => |selected_index| {
-            const field_name = fields[selected_index].name;
-            return @unionInit(U, field_name, @field(s, field_name).await(io));
-        },
-        else => unreachable,
-    }
-}
-
 pub const LockedStderr = struct {
     file_writer: *File.Writer,
     terminal_mode: Terminal.Mode,
diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 959cb86421fd02af83f316353ec79c2388161174..6a6257a25a052a30ea427da44f89540f8e8a04f6 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -123,7 +123,6 @@ const Fiber = struct {
         const Awaiting = enum(@Int(.unsigned, @bitSizeOf(usize) - shift)) {
             nothing = 0,
             group = 1,
-            select = 2,
             _,
 
             const shift = 1;
@@ -277,9 +276,6 @@ const Fiber = struct {
                     ev.queue.async(fiber, &Fiber.@"resume");
                 }
             },
-            .select => if (@atomicRmw(i32, &fiber.await_count, .Add, 1, .monotonic) == -1) {
-                ev.queue.async(fiber, &Fiber.@"resume");
-            },
             _ => |awaiting| awaiting.toCancelable().async(),
         }
     }
@@ -370,8 +366,6 @@ pub fn io(ev: *Evented) Io {
             .swapCancelProtection = swapCancelProtection,
             .checkCancel = checkCancel,
 
-            .select = select,
-
             .futexWait = futexWait,
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
@@ -1689,50 +1683,6 @@ fn futexForAddress(ev: *Evented, address: usize) *Futex {
     return &ev.futexes[hashed >> @clz(ev.futexes.len - 1)];
 }
 
-fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) Io.Cancelable!usize {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    const fiber = Thread.current().currentFiber();
-    var await_count: u31, var result = for (futures, 0..) |future, future_index| {
-        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
-        if (@atomicRmw(
-            ?*Fiber,
-            &future_fiber.link.awaiter,
-            .Xchg,
-            fiber,
-            .acq_rel,
-        )) |awaiter| {
-            assert(awaiter == Fiber.finished);
-            break .{ @intCast(future_index), future_index };
-        }
-    } else result: {
-        const await_count: u31 = @intCast(futures.len);
-        ev.yield(.{ .await = 1 });
-        break :result .{ await_count - 1, futures.len };
-    };
-    for (futures[0..result], 0..) |future, future_index| {
-        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
-        const awaiter = @atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, null, .monotonic);
-        if (awaiter == Fiber.finished) {
-            @atomicStore(?*Fiber, &future_fiber.link.awaiter, Fiber.finished, .monotonic);
-            result = @min(future_index, result);
-        } else {
-            assert(awaiter == fiber);
-            await_count -= 1;
-        }
-    }
-    // Equivalent to `ev.yield(null, .{ .await = await_count });`,
-    // but avoiding a context switch in the common case.
-    switch (std.math.order(
-        @atomicRmw(i32, &fiber.await_count, .Sub, await_count, .monotonic),
-        await_count,
-    )) {
-        .lt => ev.yield(.{ .await = 0 }),
-        .eq => {},
-        .gt => unreachable,
-    }
-    return result;
-}
-
 fn futexWait(
     userdata: ?*anyopaque,
     ptr: *const u32,
diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig
index 863bb0c22a8bfa6045da678910e8dea170792c0b..e70a3b1274c25333564c8a9655d0d974c64b2007 100644
--- a/lib/std/Io/Kqueue.zig
+++ b/lib/std/Io/Kqueue.zig
@@ -491,7 +491,6 @@ const SwitchMessage = struct {
         reschedule,
         recycle: *Fiber,
         register_awaiter: *?*Fiber,
-        register_select: []const *Io.AnyFuture,
         exit,
     };
 
@@ -514,19 +513,6 @@ const SwitchMessage = struct {
                 if (@atomicRmw(?*Fiber, awaiter, .Xchg, prev_fiber, .acq_rel) == Fiber.finished)
                     k.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
             },
-            .register_select => |futures| {
-                const prev_fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
-                assert(prev_fiber.queue_next == null);
-                for (futures) |any_future| {
-                    const future_fiber: *Fiber = @ptrCast(@alignCast(any_future));
-                    if (@atomicRmw(?*Fiber, &future_fiber.awaiter, .Xchg, prev_fiber, .acq_rel) == Fiber.finished) {
-                        const closure: *AsyncClosure = .fromFiber(future_fiber);
-                        if (!@atomicRmw(bool, &closure.already_awaited, .Xchg, true, .seq_cst)) {
-                            k.schedule(thread, .{ .head = prev_fiber, .tail = prev_fiber });
-                        }
-                    }
-                }
-            },
             .exit => for (k.threads.allocated[0..@atomicLoad(u32, &k.threads.active, .acquire)]) |*each_thread| {
                 const changes = [_]posix.Kevent{
                     .{
@@ -628,7 +614,6 @@ pub fn io(k: *Kqueue) Io {
             .concurrent = concurrent,
             .await = await,
             .cancel = cancel,
-            .select = select,
 
             .groupAsync = groupAsync,
             .groupConcurrent = groupConcurrent,
@@ -824,13 +809,6 @@ fn groupCancel(userdata: ?*anyopaque, group: *Io.Group, token: *anyopaque) void
     @panic("TODO");
 }
 
-fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) Io.Cancelable!usize {
-    const k: *Kqueue = @ptrCast(@alignCast(userdata));
-    _ = k;
-    _ = futures;
-    @panic("TODO");
-}
-
 fn dirCreateDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirError!void {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 7902ee693bb7ea0dafe18dbf0a32256cba5f73ef..485c35da578115c4f63a497124b09e1ebed9d643 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1772,7 +1772,6 @@ pub fn io(t: *Threaded) Io {
             .concurrent = concurrent,
             .await = await,
             .cancel = cancel,
-            .select = select,
 
             .groupAsync = groupAsync,
             .groupConcurrent = groupConcurrent,
@@ -1938,7 +1937,6 @@ pub fn ioBasic(t: *Threaded) Io {
             .concurrent = concurrent,
             .await = await,
             .cancel = cancel,
-            .select = select,
 
             .groupAsync = groupAsync,
             .groupConcurrent = groupConcurrent,
@@ -11727,74 +11725,6 @@ fn sleepNanosleep(t: *Threaded, timeout: Io.Timeout) Io.Cancelable!void {
     }
 }
 
-fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) Io.Cancelable!usize {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-
-    var num_completed: std.atomic.Value(u32) = .init(0);
-
-    for (futures, 0..) |any_future, i| {
-        const future: *Future = @ptrCast(@alignCast(any_future));
-        future.awaiter = &num_completed;
-        const old_status = future.status.fetchOr(
-            .{ .tag = .pending_awaited, .thread = .null },
-            .release, // release `future.awaiter`
-        );
-        switch (old_status.tag) {
-            .pending => {},
-            .pending_awaited => unreachable, // `await` raced with `select`
-            .pending_canceled => unreachable, // `cancel` raced with `select`
-            .done => {
-                future.status.store(old_status, .monotonic);
-                _ = finishSelect(&num_completed, futures[0..i]);
-                return i;
-            },
-        }
-    }
-
-    errdefer _ = finishSelect(&num_completed, futures);
-
-    while (true) {
-        const n = num_completed.load(.acquire);
-        if (n > 0) break;
-        assert(n < futures.len);
-        try Thread.futexWait(&num_completed.raw, n, null);
-    }
-    return finishSelect(&num_completed, futures).?;
-}
-fn finishSelect(
-    num_completed: *std.atomic.Value(u32),
-    futures: []const *Io.AnyFuture,
-) ?usize {
-    var completed_index: ?usize = null;
-    var expect_completed: u32 = 0;
-    for (futures, 0..) |any_future, i| {
-        const future: *Future = @ptrCast(@alignCast(any_future));
-        // This operation will convert `.pending_awaited` to `.pending`, or leave `.done` untouched.
-        switch (future.status.fetchAnd(
-            .{ .tag = @enumFromInt(0b10), .thread = .all_ones },
-            .monotonic,
-        ).tag) {
-            .pending_awaited => {},
-            .pending => unreachable,
-            .pending_canceled => unreachable,
-            .done => {
-                expect_completed += 1;
-                completed_index = i;
-            },
-        }
-    }
-    // If any future has just finished, wait for it to signal `num_completed` to avoid dangling
-    // references to stack memory.
-    while (true) {
-        const n = num_completed.load(.acquire);
-        if (n == expect_completed) break;
-        assert(n < expect_completed);
-        Thread.futexWaitUncancelable(&num_completed.raw, n, null);
-    }
-    return completed_index;
-}
-
 fn netListenIpPosix(
     userdata: ?*anyopaque,
     address: IpAddress,
diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index e668fe0426e1b1dff083e225fb21a0db312d293f..d204c23d01fed35af4f39d2128af23ee432e6f6b 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -175,7 +175,6 @@ const Fiber = struct {
         const Awaiting = enum(u31) {
             nothing = std.math.maxInt(u31),
             group = std.math.maxInt(u31) - 1,
-            select = std.math.maxInt(u31) - 2,
             /// An io_uring fd.
             _,
 
@@ -186,14 +185,14 @@ const Fiber = struct {
             fn fromIoUringFd(fd: fd_t) Awaiting {
                 const awaiting: Awaiting = @enumFromInt(fd);
                 switch (awaiting) {
-                    .nothing, .group, .select => unreachable,
+                    .nothing, .group => unreachable,
                     _ => return awaiting,
                 }
             }
 
             fn toIoUringFd(awaiting: Awaiting) fd_t {
                 switch (awaiting) {
-                    .nothing, .group, .select => unreachable,
+                    .nothing, .group => unreachable,
                     _ => return @intFromEnum(awaiting),
                 }
             }
@@ -376,9 +375,6 @@ const Fiber = struct {
                     _ = ev.schedule(.current(), .{ .head = fiber, .tail = fiber });
                 }
             },
-            .select => if (@atomicRmw(i32, &fiber.await_count, .Add, 1, .monotonic) == -1) {
-                _ = ev.schedule(.current(), .{ .head = fiber, .tail = fiber });
-            },
             _ => |awaiting| {
                 const awaiting_io_uring_fd = awaiting.toIoUringFd();
                 const thread: *Thread = .current();
@@ -684,8 +680,6 @@ pub fn io(ev: *Evented) Io {
             .swapCancelProtection = swapCancelProtection,
             .checkCancel = checkCancel,
 
-            .select = select,
-
             .futexWait = futexWait,
             .futexWaitUncancelable = futexWaitUncancelable,
             .futexWake = futexWake,
@@ -1928,57 +1922,6 @@ fn checkCancel(userdata: ?*anyopaque) Io.Cancelable!void {
     }
 }
 
-fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) Io.Cancelable!usize {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
-    var await_count: u31, var result = for (futures, 0..) |future, future_index| {
-        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
-        if (@atomicRmw(
-            ?*Fiber,
-            &future_fiber.link.awaiter,
-            .Xchg,
-            cancel_region.fiber,
-            .acq_rel,
-        )) |awaiter| {
-            assert(awaiter == Fiber.finished);
-            break .{ @intCast(future_index), future_index };
-        }
-    } else result: {
-        const await_count: u31 = @intCast(futures.len);
-        cancel_region.await(.select) catch |err| switch (err) {
-            error.Canceled => |e| break :result .{ await_count + 1, e },
-        };
-        ev.yield(null, .{ .await = 1 });
-        cancel_region.await(.nothing) catch |err| switch (err) {
-            error.Canceled => |e| break :result .{ await_count, e },
-        };
-        break :result .{ await_count - 1, futures.len };
-    };
-    for (futures[0 .. result catch futures.len], 0..) |future, future_index| {
-        const future_fiber: *Fiber = @ptrCast(@alignCast(future));
-        const awaiter = @atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, null, .monotonic);
-        if (awaiter == Fiber.finished) {
-            @atomicStore(?*Fiber, &future_fiber.link.awaiter, Fiber.finished, .monotonic);
-            result = if (result) |finished_index| @min(future_index, finished_index) else |e| e;
-        } else {
-            assert(awaiter == cancel_region.fiber);
-            await_count -= 1;
-        }
-    }
-    // Equivalent to `ev.yield(null, .{ .await = await_count });`,
-    // but avoiding a context switch in the common case.
-    switch (std.math.order(
-        @atomicRmw(i32, &cancel_region.fiber.await_count, .Sub, await_count, .monotonic),
-        await_count,
-    )) {
-        .lt => ev.yield(null, .{ .await = 0 }),
-        .eq => {},
-        .gt => unreachable,
-    }
-    return result;
-}
-
 fn futexWait(
     userdata: ?*anyopaque,
     ptr: *const u32,
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 7b652a495e899891743cb880a567eb7da9e74a5c..d13cc802ceb236c399abe3f762c6040c727ef769 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -282,40 +282,6 @@ test "Group.concurrent" {
     try testing.expectEqualSlices(usize, &.{ 45, 245 }, &results);
 }
 
-test "select" {
-    const io = testing.io;
-
-    var queue: Io.Queue(u8) = .init(&.{});
-
-    var get_a = io.concurrent(Io.Queue(u8).getOne, .{ &queue, io }) catch |err| switch (err) {
-        error.ConcurrencyUnavailable => {
-            try testing.expect(builtin.single_threaded);
-            return;
-        },
-    };
-    defer _ = get_a.cancel(io) catch {};
-
-    var get_b = try io.concurrent(Io.Queue(u8).getOne, .{ &queue, io });
-    defer _ = get_b.cancel(io) catch {};
-
-    var timeout = io.async(Io.sleep, .{ io, .fromMilliseconds(1), .awake });
-    defer timeout.cancel(io) catch {};
-
-    switch (try io.select(.{
-        .get_a = &get_a,
-        .get_b = &get_b,
-        .timeout = &timeout,
-    })) {
-        .get_a => return error.TestFailure,
-        .get_b => return error.TestFailure,
-        .timeout => {
-            queue.close(io);
-            try testing.expectError(error.Closed, get_a.await(io));
-            try testing.expectError(error.Closed, get_b.await(io));
-        },
-    }
-}
-
 fn testQueue(comptime len: usize) !void {
     const io = testing.io;
     var buf: [len]usize = undefined;
-- 
2.54.0


From 5763f7dbcc65288d7d13236f82eec9a23d97bee7 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sun, 15 Feb 2026 05:51:42 -0500
Subject: [PATCH 307/499] std.Io.Evented: clean up supporting code for `select`

---
 lib/std/Io/Dispatch.zig      |  86 ++++-----
 lib/std/Io/Uring.zig         | 327 ++++++++++++++++++-----------------
 lib/std/os/linux/IoUring.zig |   4 +
 3 files changed, 207 insertions(+), 210 deletions(-)

diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 6a6257a25a052a30ea427da44f89540f8e8a04f6..328fb59162fd8bbdaa28401a3513e1a1c3172cdc 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -100,15 +100,11 @@ const Fiber = struct {
     required_align: void align(4),
     evented: *Evented,
     context: Io.fiber.Context,
-    await_count: i32,
     link: union {
         awaiter: ?*Fiber,
         group: struct { prev: ?*Fiber, next: ?*Fiber },
     },
-    status: union(enum) {
-        queue_next: ?*Fiber,
-        awaiting_group: Group,
-    },
+    awaiting_group: Group,
     cancel_status: CancelStatus,
     cancel_protection: CancelProtection,
 
@@ -215,7 +211,6 @@ const Fiber = struct {
     }
 
     fn destroy(fiber: *Fiber, ev: *Evented) void {
-        assert(fiber.status.queue_next == null);
         ev.allocator().free(fiber.allocatedSlice());
     }
 
@@ -271,8 +266,8 @@ const Fiber = struct {
             .group => {
                 // The awaiter received a cancelation request while awaiting a group,
                 // so propagate the cancelation to the group.
-                if (fiber.status.awaiting_group.cancel(ev, null)) {
-                    fiber.status = .{ .queue_next = null };
+                if (fiber.awaiting_group.cancel(ev, null)) {
+                    fiber.awaiting_group = undefined;
                     ev.queue.async(fiber, &Fiber.@"resume");
                 }
             },
@@ -516,9 +511,8 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
             .required_align = {},
             .evented = ev,
             .context = undefined,
-            .await_count = 0,
             .link = .{ .awaiter = null },
-            .status = .{ .queue_next = null },
+            .awaiting_group = undefined,
             .cancel_status = .unrequested,
             .cancel_protection = .unblocked,
         },
@@ -636,7 +630,7 @@ const SwitchMessage = struct {
 
     const PendingTask = union(enum) {
         nothing,
-        await: u31,
+        await: *Fiber,
         activate: c.dispatch.object_t,
         @"resume": c.dispatch.object_t,
         group_await: Group,
@@ -655,10 +649,10 @@ const SwitchMessage = struct {
         thread.current_context = message.contexts.new;
         switch (message.pending_task) {
             .nothing => {},
-            .await => |count| {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
-                if (@atomicRmw(i32, &fiber.await_count, .Sub, count, .monotonic) > 0)
-                    ev.queue.async(fiber, &Fiber.@"resume");
+            .await => |awaiting| {
+                const awaiter: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                if (@atomicRmw(?*Fiber, &awaiting.link.awaiter, .Xchg, awaiter, .acq_rel) ==
+                    Fiber.finished) ev.queue.async(awaiter, &Fiber.@"resume");
             },
             .activate => |object| object.activate(),
             .@"resume" => |object| object.@"resume"(),
@@ -992,7 +986,7 @@ fn crashHandler(userdata: ?*anyopaque) void {
 }
 
 const AsyncClosure = struct {
-    ev: *Evented,
+    evented: *Evented,
     fiber: *Fiber,
     start: *const fn (context: *const anyopaque, result: *anyopaque) void,
     result_align: Alignment,
@@ -1029,13 +1023,13 @@ const AsyncClosure = struct {
         closure: *AsyncClosure,
         message: *const SwitchMessage,
     ) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
-        message.handle(closure.ev);
+        const ev = closure.evented;
         const fiber = closure.fiber;
+        message.handle(ev);
         closure.start(closure.contextPointer(), fiber.resultBytes(closure.result_align));
         if (@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel)) |awaiter|
-            if (@atomicRmw(i32, &awaiter.await_count, .Add, 1, .monotonic) == -1)
-                closure.ev.queue.async(awaiter, &Fiber.@"resume");
-        closure.ev.yield(.nothing);
+            ev.queue.async(awaiter, &Fiber.@"resume");
+        ev.yield(.nothing);
         unreachable; // switched to dead fiber
     }
 };
@@ -1090,14 +1084,13 @@ fn concurrent(
             },
             else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
         },
-        .await_count = 0,
         .link = .{ .awaiter = null },
-        .status = .{ .queue_next = null },
+        .awaiting_group = undefined,
         .cancel_status = .unrequested,
         .cancel_protection = .unblocked,
     };
     closure.* = .{
-        .ev = ev,
+        .evented = ev,
         .fiber = fiber,
         .start = start,
         .result_align = result_alignment,
@@ -1115,18 +1108,11 @@ fn await(
     result_alignment: Alignment,
 ) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    const fiber = Thread.current().currentFiber();
-    const future_fiber: *Fiber = @ptrCast(@alignCast(future));
-    if (@atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, fiber, .acq_rel)) |awaiter| {
-        assert(awaiter == Fiber.finished);
-    } else while (true) {
-        ev.yield(.{ .await = 1 });
-        const awaiter = @atomicLoad(?*Fiber, &future_fiber.link.awaiter, .acquire);
-        if (awaiter == Fiber.finished) break;
-        assert(awaiter == fiber); // spurious wakeup
-    }
-    @memcpy(result, future_fiber.resultBytes(result_alignment));
-    future_fiber.destroy(ev);
+    const awaiting: *Fiber = @ptrCast(@alignCast(future));
+    if (@atomicLoad(?*Fiber, &awaiting.link.awaiter, .acquire) != Fiber.finished)
+        ev.yield(.{ .await = awaiting });
+    @memcpy(result, awaiting.resultBytes(result_alignment));
+    awaiting.destroy(ev);
 }
 
 fn cancel(
@@ -1261,8 +1247,8 @@ const Group = struct {
                     .awaiter_delayed = false,
                     .fibers = .null,
                 }, .release);
-                assert(awaiter.status.awaiting_group.ptr == group.ptr);
-                awaiter.status = .{ .queue_next = null };
+                assert(awaiter.awaiting_group.ptr == group.ptr);
+                awaiter.awaiting_group = undefined;
                 return awaiter;
             }
             // Race with `Fiber.requestCancel`
@@ -1330,8 +1316,7 @@ const Group = struct {
 
     /// Assumes the mutex is held.
     fn registerAwaiter(group: Group, awaiter: *Fiber) bool {
-        assert(awaiter.status.queue_next == null);
-        awaiter.status = .{ .awaiting_group = group };
+        awaiter.awaiting_group = group;
         assert(@atomicRmw(
             Awaiter,
             group.awaiterPtr(),
@@ -1343,7 +1328,7 @@ const Group = struct {
     }
 
     const AsyncClosure = struct {
-        ev: *Evented,
+        evented: *Evented,
         group: Group,
         fiber: *Fiber,
         start: *const fn (context: *const anyopaque) Io.Cancelable!void,
@@ -1382,19 +1367,15 @@ const Group = struct {
             closure: *Group.AsyncClosure,
             message: *const SwitchMessage,
         ) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn {
-            message.handle(closure.ev);
-            assert(closure.fiber.status.queue_next == null);
-            const result = closure.start(closure.contextPointer());
-            const ev = closure.ev;
-            const group = closure.group;
+            const ev = closure.evented;
             const fiber = closure.fiber;
-            const cancel_acknowledged = fiber.cancel_protection.acknowledged;
-            if (result) {
-                assert(!cancel_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
+            message.handle(ev);
+            if (closure.start(closure.contextPointer())) {
+                assert(!fiber.cancel_protection.acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
             } else |err| switch (err) {
-                error.Canceled => assert(cancel_acknowledged), // group task returned `error.Canceled` but was never canceled
+                error.Canceled => assert(fiber.cancel_protection.acknowledged), // group task returned `error.Canceled` but was never canceled
             }
-            if (group.removeFiber(ev, fiber)) |awaiter| ev.queue.async(awaiter, &Fiber.@"resume");
+            if (closure.group.removeFiber(ev, fiber)) |awaiter| ev.queue.async(awaiter, &Fiber.@"resume");
             ev.yield(.destroy);
             unreachable; // switched to dead fiber
         }
@@ -1464,14 +1445,13 @@ fn groupConcurrent(
             },
             else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
         },
-        .await_count = 0,
         .link = .{ .group = .{ .prev = null, .next = null } },
-        .status = .{ .queue_next = null },
+        .awaiting_group = undefined,
         .cancel_status = .unrequested,
         .cancel_protection = .unblocked,
     };
     closure.* = .{
-        .ev = ev,
+        .evented = ev,
         .group = group,
         .fiber = fiber,
         .start = start,
diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index d204c23d01fed35af4f39d2128af23ee432e6f6b..a2c4f6e5ec9a15343fb428792da27c883d48c3df 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -150,7 +150,6 @@ const Thread = struct {
 const Fiber = struct {
     required_align: void align(4),
     context: Io.fiber.Context,
-    await_count: i32,
     link: union {
         awaiter: ?*Fiber,
         group: struct { prev: ?*Fiber, next: ?*Fiber },
@@ -856,7 +855,6 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
     main_fiber.* = .{
         .required_align = {},
         .context = undefined,
-        .await_count = 0,
         .link = .{ .awaiter = null },
         .status = .{ .queue_next = null },
         .cancel_status = .unrequested,
@@ -1260,7 +1258,7 @@ const SwitchMessage = struct {
     const PendingTask = union(enum) {
         nothing,
         reschedule,
-        await: u31,
+        await: *Fiber,
         group_await: Group,
         group_cancel: Group,
         batch_await: *Io.Batch,
@@ -1284,10 +1282,11 @@ const SwitchMessage = struct {
                 assert(fiber.status.queue_next == null);
                 _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
             },
-            .await => |count| {
-                const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
-                if (@atomicRmw(i32, &fiber.await_count, .Sub, count, .monotonic) > 0)
-                    _ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
+            .await => |awaiting| {
+                const awaiter: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
+                assert(awaiter.status.queue_next == null);
+                if (@atomicRmw(?*Fiber, &awaiting.link.awaiter, .Xchg, awaiter, .acq_rel) ==
+                    Fiber.finished) _ = ev.schedule(thread, .{ .head = awaiter, .tail = awaiter });
             },
             .group_await => |group| {
                 const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
@@ -1361,7 +1360,7 @@ fn crashHandler(userdata: ?*anyopaque) void {
 }
 
 const AsyncClosure = struct {
-    ev: *Evented,
+    evented: *Evented,
     fiber: *Fiber,
     start: *const fn (context: *const anyopaque, result: *anyopaque) void,
     result_align: Alignment,
@@ -1398,16 +1397,11 @@ const AsyncClosure = struct {
         closure: *AsyncClosure,
         message: *const SwitchMessage,
     ) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
-        message.handle(closure.ev);
+        const ev = closure.evented;
         const fiber = closure.fiber;
+        message.handle(ev);
         closure.start(closure.contextPointer(), fiber.resultBytes(closure.result_align));
-        closure.ev.yield(
-            if (@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel)) |awaiter|
-                if (@atomicRmw(i32, &awaiter.await_count, .Add, 1, .monotonic) == -1) awaiter else null
-            else
-                null,
-            .nothing,
-        );
+        ev.yield(@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel), .nothing);
         unreachable; // switched to dead fiber
     }
 };
@@ -1461,7 +1455,6 @@ fn concurrent(
             },
             else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
         },
-        .await_count = 0,
         .link = .{ .awaiter = null },
         .status = .{ .queue_next = null },
         .cancel_status = .unrequested,
@@ -1479,7 +1472,7 @@ fn concurrent(
         },
     };
     closure.* = .{
-        .ev = ev,
+        .evented = ev,
         .fiber = fiber,
         .start = start,
         .result_align = result_alignment,
@@ -1498,18 +1491,11 @@ fn await(
     result_alignment: Alignment,
 ) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
-    const fiber = Thread.current().currentFiber();
-    const future_fiber: *Fiber = @ptrCast(@alignCast(future));
-    if (@atomicRmw(?*Fiber, &future_fiber.link.awaiter, .Xchg, fiber, .acq_rel)) |awaiter| {
-        assert(awaiter == Fiber.finished);
-    } else while (true) {
-        ev.yield(null, .{ .await = 1 });
-        const awaiter = @atomicLoad(?*Fiber, &future_fiber.link.awaiter, .acquire);
-        if (awaiter == Fiber.finished) break;
-        assert(awaiter == fiber); // spurious wakeup
-    }
-    @memcpy(result, future_fiber.resultBytes(result_alignment));
-    future_fiber.destroy();
+    const awaiting: *Fiber = @ptrCast(@alignCast(future));
+    if (@atomicLoad(?*Fiber, &awaiting.link.awaiter, .acquire) != Fiber.finished)
+        ev.yield(null, .{ .await = awaiting });
+    @memcpy(result, awaiting.resultBytes(result_alignment));
+    awaiting.destroy();
 }
 
 fn cancel(
@@ -1726,7 +1712,7 @@ const Group = struct {
     }
 
     const AsyncClosure = struct {
-        ev: *Evented,
+        evented: *Evented,
         group: Group,
         fiber: *Fiber,
         start: *const fn (context: *const anyopaque) Io.Cancelable!void,
@@ -1765,19 +1751,16 @@ const Group = struct {
             closure: *Group.AsyncClosure,
             message: *const SwitchMessage,
         ) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn {
-            message.handle(closure.ev);
-            assert(closure.fiber.status.queue_next == null);
-            const result = closure.start(closure.contextPointer());
-            const ev = closure.ev;
-            const group = closure.group;
+            const ev = closure.evented;
             const fiber = closure.fiber;
-            const cancel_acknowledged = fiber.cancel_protection.acknowledged;
-            if (result) {
-                assert(!cancel_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
+            message.handle(ev);
+            assert(fiber.status.queue_next == null);
+            if (closure.start(closure.contextPointer())) {
+                assert(!fiber.cancel_protection.acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
             } else |err| switch (err) {
-                error.Canceled => assert(cancel_acknowledged), // group task returned `error.Canceled` but was never canceled
+                error.Canceled => assert(fiber.cancel_protection.acknowledged), // group task returned `error.Canceled` but was never canceled
             }
-            ev.yield(group.removeFiber(ev, fiber), .destroy);
+            ev.yield(closure.group.removeFiber(ev, fiber), .destroy);
             unreachable; // switched to dead fiber
         }
     };
@@ -1845,7 +1828,6 @@ fn groupConcurrent(
             },
             else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
         },
-        .await_count = 0,
         .link = .{ .group = .{ .prev = null, .next = null } },
         .status = .{ .queue_next = null },
         .cancel_status = .unrequested,
@@ -1863,7 +1845,7 @@ fn groupConcurrent(
         },
     };
     closure.* = .{
-        .ev = ev,
+        .evented = ev,
         .group = group,
         .fiber = fiber,
         .start = start,
@@ -2173,7 +2155,7 @@ fn deviceIoControl(
         const rc = linux.ioctl(o.file.handle, @bitCast(o.code), @intFromPtr(o.arg));
         switch (linux.errno(rc)) {
             .SUCCESS => return @bitCast(@as(u32, @truncate(rc))),
-            .INTR => continue,
+            .INTR => {},
             else => |err| return -@as(i32, @intFromEnum(err)),
         }
     }
@@ -2571,7 +2553,7 @@ fn dirCreateDir(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => return error.AccessDenied,
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .PERM => return error.PermissionDenied,
@@ -2654,7 +2636,7 @@ fn filePathKind(ev: *Evented, dir: Dir, sub_path: []const u8) !File.Kind {
                 if (!statx_buf.mask.TYPE) return error.Unexpected;
                 return statxKind(statx_buf.mode);
             },
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => |err| return errnoBug(err),
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .FAULT => |err| return errnoBug(err),
@@ -2767,7 +2749,7 @@ fn dirAccess(
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.faccessat(dir.handle, sub_path_posix, mode, flags))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .ACCES => return error.AccessDenied,
             .PERM => return error.PermissionDenied,
             .ROFS => return error.ReadOnlyFileSystem,
@@ -2806,7 +2788,7 @@ fn dirCreateFile(
         .EXCL = flags.exclusive,
         .CLOEXEC = true,
     }, flags.permissions.toMode());
-    errdefer ev.close(fd);
+    errdefer ev.closeAsync(fd);
 
     switch (flags.lock) {
         .none => {},
@@ -2994,7 +2976,7 @@ fn dirOpenFile(
         .CLOEXEC = true,
         .PATH = flags.path_only,
     }, 0);
-    errdefer ev.close(fd);
+    errdefer ev.closeAsync(fd);
 
     if (!flags.allow_directory) {
         const is_dir = is_dir: {
@@ -3048,7 +3030,7 @@ fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Read
                 const rc = linux.getdents64(dr.dir.handle, dr.buffer.ptr, dr.buffer.len);
                 switch (linux.errno(rc)) {
                     .SUCCESS => break rc,
-                    .INTR => continue,
+                    .INTR => {},
                     .BADF => |err| return errnoBug(err), // Dir is invalid or was opened without iteration ability.
                     .FAULT => |err| return errnoBug(err),
                     .NOTDIR => |err| return errnoBug(err),
@@ -3141,7 +3123,7 @@ fn dirRealPathFile(
         error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
         else => |e| return e,
     };
-    defer ev.close(fd);
+    defer ev.closeAsync(fd);
     return ev.realPath(try maybe_sync.enterSync(ev), fd, out_buffer);
 }
 
@@ -3174,7 +3156,7 @@ fn dirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.Dele
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .PERM => return error.PermissionDenied,
             .ACCES => return error.AccessDenied,
             .BUSY => return error.FileBusy,
@@ -3226,7 +3208,7 @@ fn dirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.Delet
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => return error.AccessDenied,
             .PERM => return error.PermissionDenied,
             .BUSY => return error.FileBusy,
@@ -3342,7 +3324,7 @@ fn dirSymLink(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .FAULT => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err),
             .ACCES => return error.AccessDenied,
@@ -3381,7 +3363,7 @@ fn dirReadLink(
         const rc = linux.readlinkat(dir.handle, sub_path_posix, buffer.ptr, buffer.len);
         switch (linux.errno(rc)) {
             .SUCCESS => return @bitCast(rc),
-            .INTR => continue,
+            .INTR => {},
             .ACCES => return error.AccessDenied,
             .FAULT => |err| return errnoBug(err),
             .INVAL => return error.NotLink,
@@ -3571,7 +3553,7 @@ fn fileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
                 if (!statx_buf.mask.SIZE) return error.Unexpected;
                 return statx_buf.size;
             },
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => |err| return errnoBug(err),
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .FAULT => |err| return errnoBug(err),
@@ -3754,7 +3736,7 @@ fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .BADF => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err),
             .ROFS => |err| return errnoBug(err),
@@ -3776,7 +3758,7 @@ fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
         const rc = linux.ioctl(file.handle, linux.T.IOCGWINSZ, @intFromPtr(&wsz));
         switch (linux.errno(rc)) {
             .SUCCESS => return true,
-            .INTR => continue,
+            .INTR => {},
             else => return false,
         }
     }
@@ -3812,7 +3794,7 @@ fn fileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthE
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .FBIG => return error.FileTooBig,
             .IO => return error.InputOutput,
             .PERM => return error.PermissionDenied,
@@ -3994,7 +3976,7 @@ fn fileMemoryMapCreate(
         const rc = linux.mmap(null, options.len, prot, flags, file.handle, casted_offset);
         switch (linux.errno(rc)) {
             .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..options.len],
-            .INTR => continue,
+            .INTR => {},
             .ACCES => return error.AccessDenied,
             .AGAIN => return error.LockedMemoryLimitExceeded,
             .MFILE => return error.ProcessFdQuotaExceeded,
@@ -4054,7 +4036,7 @@ fn fileMemoryMapSetLength(
         const rc = linux.mremap(old_memory.ptr, old_memory.len, new_len, flags, addr_hint);
         switch (linux.errno(rc)) {
             .SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len],
-            .INTR => continue,
+            .INTR => {},
             .AGAIN => return error.LockedMemoryLimitExceeded,
             .NOMEM => return error.OutOfMemory,
             .INVAL => |err| return errnoBug(err),
@@ -4163,7 +4145,7 @@ fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathEr
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.getcwd(buffer.ptr, buffer.len))) {
             .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
-            .INTR => continue,
+            .INTR => {},
             .NOENT => return error.CurrentDirUnlinked,
             .RANGE => return error.NameTooLong,
             .FAULT => |err| return errnoBug(err),
@@ -4178,7 +4160,7 @@ fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirEr
     if (dir.handle == linux.AT.FDCWD) return;
     var sync: CancelRegion.Sync = try .init(ev);
     defer sync.deinit(ev);
-    return ev.fchdir(&sync, dir.handle);
+    return fchdir(&sync, dir.handle);
 }
 
 fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) ChdirError!void {
@@ -4215,7 +4197,7 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
 
     var sync: CancelRegion.Sync = try .init(ev);
     defer sync.deinit(ev);
-    return ev.execv(&sync, options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
+    return execv(&sync, options.expand_arg0, argv_buf.ptr[0].?, argv_buf.ptr, env_block, PATH);
 }
 
 fn processReplacePath(
@@ -4235,7 +4217,7 @@ fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.Sp
     const spawned = try ev.spawn(options);
     var cancel_region: CancelRegion = .initBlocked();
     defer cancel_region.deinit();
-    defer ev.close(spawned.err_fd);
+    defer ev.closeAsync(spawned.err_fd);
 
     // Wait for the child to report any errors in or before `execvpe`.
     var child_err: ForkBailError = undefined;
@@ -4377,8 +4359,9 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
 
     if (pid_result == 0) {
         defer comptime unreachable; // We are the child.
+        // Note that the parent uring is no longer accessible, so we must no longer reference `ev`.
         var sync: CancelRegion.Sync = .{ .cancel_region = .initBlocked() };
-        const err = ev.setUpChild(&sync, .{
+        const err = setUpChild(&sync, .{
             .stdin_pipe = stdin_pipe[0],
             .stdout_pipe = stdout_pipe[1],
             .stderr_pipe = stderr_pipe[1],
@@ -4389,7 +4372,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
             .PATH = PATH,
             .spawn = options,
         });
-        ev.writeAll(&sync.cancel_region, err_pipe[1], @ptrCast(&err)) catch {};
+        writeAllSync(&sync, err_pipe[1], @ptrCast(&err)) catch {};
         const exit = if (builtin.single_threaded) linux.exit else linux.exit_group;
         exit(1);
     }
@@ -4397,13 +4380,13 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     const pid: pid_t = @intCast(pid_result); // We are the parent.
     errdefer comptime unreachable; // The child is forked; we must not error from now on
 
-    ev.close(err_pipe[1]); // make sure only the child holds the write end open
+    ev.closeAsync(err_pipe[1]); // make sure only the child holds the write end open
 
-    if (options.stdin == .pipe) ev.close(stdin_pipe[0]);
-    if (options.stdout == .pipe) ev.close(stdout_pipe[1]);
-    if (options.stderr == .pipe) ev.close(stderr_pipe[1]);
+    if (options.stdin == .pipe) ev.closeAsync(stdin_pipe[0]);
+    if (options.stdout == .pipe) ev.closeAsync(stdout_pipe[1]);
+    if (options.stderr == .pipe) ev.closeAsync(stderr_pipe[1]);
 
-    if (prog_pipe[1] != -1) ev.close(prog_pipe[1]);
+    if (prog_pipe[1] != -1) ev.closeAsync(prog_pipe[1]);
 
     options.progress_node.setIpcFile(ev, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
 
@@ -4440,14 +4423,14 @@ pub fn pipe2(flags: linux.O) PipeError![2]fd_t {
     }
 }
 fn destroyPipe(ev: *Evented, pipe: [2]fd_t) void {
-    if (pipe[0] != -1) ev.close(pipe[0]);
-    if (pipe[0] != pipe[1]) ev.close(pipe[1]);
+    if (pipe[0] != -1) ev.closeAsync(pipe[0]);
+    if (pipe[0] != pipe[1]) ev.closeAsync(pipe[1]);
 }
 
 /// Errors that can occur between fork() and execv()
 const ForkBailError = process.SetCurrentDirError || ChdirError ||
     process.SpawnError || process.ReplaceError;
-fn setUpChild(ev: *Evented, sync: *CancelRegion.Sync, options: struct {
+fn setUpChild(sync: *CancelRegion.Sync, options: struct {
     stdin_pipe: fd_t,
     stdout_pipe: fd_t,
     stderr_pipe: fd_t,
@@ -4458,21 +4441,21 @@ fn setUpChild(ev: *Evented, sync: *CancelRegion.Sync, options: struct {
     PATH: []const u8,
     spawn: process.SpawnOptions,
 }) ForkBailError {
-    try ev.setUpChildIo(
+    try setUpChildIo(
         sync,
         options.spawn.stdin,
         options.stdin_pipe,
         linux.STDIN_FILENO,
         options.dev_null_fd,
     );
-    try ev.setUpChildIo(
+    try setUpChildIo(
         sync,
         options.spawn.stdout,
         options.stdout_pipe,
         linux.STDOUT_FILENO,
         options.dev_null_fd,
     );
-    try ev.setUpChildIo(
+    try setUpChildIo(
         sync,
         options.spawn.stderr,
         options.stderr_pipe,
@@ -4482,17 +4465,17 @@ fn setUpChild(ev: *Evented, sync: *CancelRegion.Sync, options: struct {
 
     switch (options.spawn.cwd) {
         .inherit => {},
-        .dir => |cwd_dir| try ev.fchdir(sync, cwd_dir.handle),
+        .dir => |cwd_dir| try fchdir(sync, cwd_dir.handle),
         .path => |cwd_path| {
             var cwd_path_buffer: [PATH_MAX]u8 = undefined;
             const cwd_path_posix = try pathToPosix(cwd_path, &cwd_path_buffer);
-            try ev.chdir(sync, cwd_path_posix);
+            try chdir(sync, cwd_path_posix);
         },
     }
 
     // Must happen after fchdir above, the cwd file descriptor might be
     // equal to prog_fileno and be clobbered by this dup2 call.
-    if (options.prog_pipe != -1) try ev.dup2(sync, options.prog_pipe, prog_fileno);
+    if (options.prog_pipe != -1) try dup2(sync, options.prog_pipe, prog_fileno);
 
     if (options.spawn.gid) |gid| {
         switch (linux.errno(linux.setregid(gid, gid))) {
@@ -4532,7 +4515,7 @@ fn setUpChild(ev: *Evented, sync: *CancelRegion.Sync, options: struct {
         }
     }
 
-    return ev.execv(
+    return execv(
         sync,
         options.spawn.expand_arg0,
         options.argv_buf.ptr[0].?,
@@ -4543,7 +4526,6 @@ fn setUpChild(ev: *Evented, sync: *CancelRegion.Sync, options: struct {
 }
 
 fn setUpChildIo(
-    ev: *Evented,
     sync: *CancelRegion.Sync,
     stdio: process.SpawnOptions.StdIo,
     pipe_fd: fd_t,
@@ -4551,13 +4533,13 @@ fn setUpChildIo(
     dev_null_fd: fd_t,
 ) !void {
     switch (stdio) {
-        .pipe => try ev.dup2(sync, pipe_fd, std_fileno),
+        .pipe => try dup2(sync, pipe_fd, std_fileno),
         .close => _ = linux.close(std_fileno),
         .inherit => {},
-        .ignore => try ev.dup2(sync, dev_null_fd, std_fileno),
+        .ignore => try dup2(sync, dev_null_fd, std_fileno),
         .file => |file| {
             if (file.flags.nonblocking) @panic("TODO implement setUpChildIo when nonblocking file is used");
-            try ev.dup2(sync, file.handle, std_fileno);
+            try dup2(sync, file.handle, std_fileno);
         },
     }
 }
@@ -4566,13 +4548,12 @@ pub const DupError = error{
     ProcessFdQuotaExceeded,
     SystemResources,
 } || Io.UnexpectedError || Io.Cancelable;
-pub fn dup2(ev: *Evented, sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t) DupError!void {
-    _ = ev;
+pub fn dup2(sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t) DupError!void {
     while (true) {
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.dup2(old_fd, new_fd))) {
             .SUCCESS => {},
-            .BUSY, .INTR => continue,
+            .BUSY, .INTR => {},
             .INVAL => |err| return errnoBug(err), // invalid parameters
             .BADF => |err| return errnoBug(err), // use after free
             .MFILE => return error.ProcessFdQuotaExceeded,
@@ -4583,7 +4564,6 @@ pub fn dup2(ev: *Evented, sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t)
 }
 
 fn execv(
-    ev: *Evented,
     sync: *CancelRegion.Sync,
     arg0_expand: process.ArgExpansion,
     file: [*:0]const u8,
@@ -4592,7 +4572,8 @@ fn execv(
     PATH: []const u8,
 ) process.ReplaceError {
     const file_slice = std.mem.sliceTo(file, 0);
-    if (std.mem.findScalar(u8, file_slice, '/') != null) return ev.execvPath(sync, file, child_argv, env_block);
+    if (std.mem.findScalar(u8, file_slice, '/') != null)
+        return execvPath(sync, file, child_argv, env_block);
 
     // Use of PATH_MAX here is valid as the path_buf will be passed
     // directly to the operating system in posixExecvPath.
@@ -4620,7 +4601,7 @@ fn execv(
             .expand => child_argv[0] = full_path,
             .no_expand => {},
         }
-        err = ev.execvPath(sync, full_path, child_argv, env_block);
+        err = execvPath(sync, full_path, child_argv, env_block);
         switch (err) {
             error.AccessDenied => seen_eacces = true,
             error.FileNotFound, error.NotDir => {},
@@ -4632,13 +4613,11 @@ fn execv(
 }
 /// This function ignores PATH environment variable.
 pub fn execvPath(
-    ev: *Evented,
     sync: *CancelRegion.Sync,
     path: [*:0]const u8,
     child_argv: [*:null]const ?[*:0]const u8,
     env_block: process.Environ.PosixBlock,
 ) process.ReplaceError {
-    _ = ev;
     try sync.cancel_region.await(.nothing);
     switch (linux.errno(linux.execve(path, child_argv, env_block.slice.ptr))) {
         .FAULT => |err| return errnoBug(err), // Bad pointer parameter.
@@ -4709,7 +4688,7 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
                                 child.resource_usage_statistics.rusage = rusage;
                                 break;
                             },
-                            .INTR, .CANCELED => continue,
+                            .INTR, .CANCELED => {},
                             .CHILD => |err| return errnoBug(err), // Double-free.
                             else => |err| return unexpectedErrno(err),
                         }
@@ -4724,7 +4703,7 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
                     _, .CONTINUED => .{ .unknown = status },
                 };
             },
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .CHILD => |err| return errnoBug(err), // Double-free.
             else => |err| return unexpectedErrno(err),
         }
@@ -4741,7 +4720,7 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
     const pid = child.id.?;
     while (true) switch (linux.errno(linux.kill(pid, .TERM))) {
         .SUCCESS => break,
-        .INTR => continue,
+        .INTR => {},
         .PERM => return,
         .INVAL => |err| return errnoBug(err) catch {},
         .SRCH => |err| return errnoBug(err) catch {},
@@ -4773,7 +4752,7 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
         ev.yield(null, .nothing);
         switch (maybe_sync.cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .CHILD => |err| return errnoBug(err) catch {}, // Double-free.
             else => |err| return unexpectedErrno(err) catch {},
         }
@@ -4782,15 +4761,15 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
 
 fn childCleanup(ev: *Evented, child: *process.Child) void {
     if (child.stdin) |*stdin| {
-        ev.close(stdin.handle);
+        ev.closeAsync(stdin.handle);
         child.stdin = null;
     }
     if (child.stdout) |*stdout| {
-        ev.close(stdout.handle);
+        ev.closeAsync(stdout.handle);
         child.stdout = null;
     }
     if (child.stderr) |*stderr| {
-        ev.close(stderr.handle);
+        ev.closeAsync(stderr.handle);
         child.stderr = null;
     }
     child.id = null;
@@ -4896,14 +4875,10 @@ fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
         .resv = 0,
     };
     ev.yield(null, .nothing);
-    switch (cancel_region.errno()) {
-        // Handles SUCCESS as well as clock not available and unexpected
-        // errors. The user had a chance to check clock resolution before
-        // getting here, which would have reported 0, making this a legal
-        // amount of time to sleep.
-        else => return,
-        .INTR, .CANCELED => return error.Canceled,
-    }
+    // Handles SUCCESS as well as clock not available and unexpected
+    // errors. The user had a chance to check clock resolution before
+    // getting here, which would have reported 0, making this a legal
+    // amount of time to sleep.
 }
 
 fn random(userdata: ?*anyopaque, buffer: []u8) void {
@@ -4980,7 +4955,7 @@ fn netBindIp(
     var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
     defer maybe_sync.deinit(ev);
     const socket_fd = try ev.socket(&maybe_sync.cancel_region, family, options);
-    errdefer ev.close(socket_fd);
+    errdefer ev.closeAsync(socket_fd);
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
     try ev.bind(&maybe_sync.cancel_region, socket_fd, &storage.any, addr_len);
@@ -5147,23 +5122,19 @@ fn netReceive(
                     .data = data,
                     .control = if (msg.control) |ptr| @as([*]u8, @ptrCast(ptr))[0..msg.controllen] else message.control,
                     .flags = .{
-                        .eor = (msg.flags & linux.MSG.EOR) != 0,
-                        .trunc = (msg.flags & linux.MSG.TRUNC) != 0,
-                        .ctrunc = (msg.flags & linux.MSG.CTRUNC) != 0,
-                        .oob = (msg.flags & linux.MSG.OOB) != 0,
-                        .errqueue = if (@hasDecl(linux.MSG, "ERRQUEUE")) (msg.flags & linux.MSG.ERRQUEUE) != 0 else false,
+                        .eor = msg.flags & linux.MSG.EOR != 0,
+                        .trunc = msg.flags & linux.MSG.TRUNC != 0,
+                        .ctrunc = msg.flags & linux.MSG.CTRUNC != 0,
+                        .oob = msg.flags & linux.MSG.OOB != 0,
+                        .errqueue = msg.flags & linux.MSG.ERRQUEUE != 0,
                     },
                 };
                 message_i += 1;
                 continue;
             },
             .AGAIN => unreachable,
-            .INTR, .CANCELED => {
-                if (deadline) |d| {
-                    if (now(ev, d.clock).nanoseconds >= d.raw.nanoseconds) return .{ error.Timeout, message_i };
-                }
-                continue;
-            },
+            .INTR, .CANCELED => if (deadline) |d| if (now(ev, d.clock).nanoseconds >= d.raw.nanoseconds)
+                return .{ error.Timeout, message_i },
 
             .BADF => |err| return .{ errnoBug(err), message_i },
             .NFILE => return .{ error.SystemFdQuotaExceeded, message_i },
@@ -5266,7 +5237,7 @@ fn netShutdown(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .BADF, .NOTSOCK, .INVAL => |err| return errnoBug(err),
             .NOTCONN => return error.SocketUnconnected,
             .NOBUFS => return error.SystemResources,
@@ -5336,7 +5307,7 @@ fn bind(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ADDRINUSE => return error.AddressInUse,
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .INVAL => |err| return errnoBug(err), // invalid parameters
@@ -5350,13 +5321,12 @@ fn bind(
     }
 }
 
-fn chdir(ev: *Evented, sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError!void {
-    _ = ev;
+fn chdir(sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError!void {
     while (true) {
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.chdir(path))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .ACCES => return error.AccessDenied,
             .IO => return error.FileSystem,
             .LOOP => return error.SymLinkLoop,
@@ -5372,6 +5342,36 @@ fn chdir(ev: *Evented, sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError
 }
 
 fn close(ev: *Evented, fd: fd_t) void {
+    var cancel_region: CancelRegion = .initBlocked();
+    defer cancel_region.deinit();
+    const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
+        error.Canceled => unreachable, // blocked
+    };
+    thread.enqueue().* = .{
+        .opcode = .CLOSE,
+        .flags = 0,
+        .ioprio = 0,
+        .fd = fd,
+        .off = 0,
+        .addr = 0,
+        .len = 0,
+        .rw_flags = 0,
+        .user_data = @intFromPtr(cancel_region.fiber),
+        .buf_index = 0,
+        .personality = 0,
+        .splice_fd_in = 0,
+        .addr3 = 0,
+        .resv = 0,
+    };
+    ev.yield(null, .nothing);
+    switch (cancel_region.errno()) {
+        .BADF => recoverableOsBugDetected(), // Always a race condition.
+        .INTR => {}, // This is still a success. See https://github.com/ziglang/zig/issues/2425
+        else => {},
+    }
+}
+
+fn closeAsync(ev: *Evented, fd: fd_t) void {
     _ = ev;
     const thread: *Thread = .current();
     thread.enqueue().* = .{
@@ -5392,14 +5392,13 @@ fn close(ev: *Evented, fd: fd_t) void {
     };
 }
 
-fn fchdir(ev: *Evented, sync: *CancelRegion.Sync, dir: fd_t) process.SetCurrentDirError!void {
-    _ = ev;
+fn fchdir(sync: *CancelRegion.Sync, dir: fd_t) process.SetCurrentDirError!void {
     if (dir == linux.AT.FDCWD) return;
     while (true) {
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.fchdir(dir))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .ACCES => return error.AccessDenied,
             .NOTDIR => return error.NotDir,
             .IO => return error.FileSystem,
@@ -5422,7 +5421,7 @@ fn fchmodat(
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.fchmodat2(dir, path, mode, flags))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .BADF => |err| return errnoBug(err),
             .FAULT => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err),
@@ -5454,7 +5453,7 @@ fn fchownat(
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.fchownat(dir, path, owner, group, flags))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .BADF => |err| return errnoBug(err), // likely fd refers to directory opened without `Dir.OpenOptions.iterate`
             .FAULT => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err),
@@ -5486,7 +5485,7 @@ fn flock(
             .exclusive => LOCK.EX,
         })))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .BADF => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err), // invalid parameters
             .NOLCK => return error.SystemResources,
@@ -5536,7 +5535,7 @@ fn getsockname(
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.getsockname(socket_fd, addr, addr_len))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .FAULT => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err), // invalid parameters
@@ -5577,7 +5576,7 @@ fn linkat(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => return error.AccessDenied,
             .DQUOT => return error.DiskQuota,
             .EXIST => return error.PathAlreadyExists,
@@ -5617,7 +5616,7 @@ fn lseek(
             8 => linux.lseek(fd, @bitCast(offset), whence),
         })) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .INVAL => return error.Unseekable,
             .OVERFLOW => return error.Unseekable,
@@ -5660,7 +5659,7 @@ fn openat(
         const completion = cancel_region.completion();
         switch (completion.errno()) {
             .SUCCESS => return completion.result,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .FAULT => |err| return errnoBug(err),
             .INVAL => return error.BadPathName,
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
@@ -5722,7 +5721,7 @@ fn preadv(
         const completion = cancel_region.completion();
         switch (completion.errno()) {
             .SUCCESS => return @as(u32, @bitCast(completion.result)),
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .INVAL => |err| return errnoBug(err),
             .FAULT => |err| return errnoBug(err),
             .AGAIN => return error.WouldBlock,
@@ -5769,7 +5768,7 @@ fn pwritev(
         const completion = cancel_region.completion();
         switch (completion.errno()) {
             .SUCCESS => return @as(u32, @bitCast(completion.result)),
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .INVAL => |err| return errnoBug(err),
             .FAULT => |err| return errnoBug(err),
             .AGAIN => return error.WouldBlock,
@@ -5819,7 +5818,7 @@ fn realPath(
         const rc = linux.readlink(proc_path, out_buffer.ptr, out_buffer.len);
         switch (linux.errno(rc)) {
             .SUCCESS => return rc,
-            .INTR => continue,
+            .INTR => {},
             .ACCES => return error.AccessDenied,
             .FAULT => |err| return errnoBug(err),
             .IO => return error.FileSystem,
@@ -5864,7 +5863,7 @@ fn renameat(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => return error.AccessDenied,
             .PERM => return error.PermissionDenied,
             .BUSY => return error.FileBusy,
@@ -5931,7 +5930,7 @@ fn setsockopt(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .NOTSOCK => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err),
@@ -5982,7 +5981,7 @@ fn socket(
         const completion = cancel_region.completion();
         switch (completion.errno()) {
             .SUCCESS => break completion.result,
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .AFNOSUPPORT => return error.AddressFamilyUnsupported,
             .INVAL => return error.ProtocolUnsupportedBySystem,
             .MFILE => return error.ProcessFdQuotaExceeded,
@@ -5994,7 +5993,7 @@ fn socket(
             else => |err| return unexpectedErrno(err),
         }
     };
-    errdefer ev.close(socket_fd);
+    errdefer ev.closeAsync(socket_fd);
 
     if (options.ip6_only) {
         if (linux.IPV6 == void) return error.OptionUnsupported;
@@ -6044,7 +6043,7 @@ fn statx(
         ev.yield(null, .nothing);
         switch (cancel_region.errno()) {
             .SUCCESS => return statFromLinux(&statx_buf),
-            .INTR, .CANCELED => continue,
+            .INTR, .CANCELED => {},
             .ACCES => return error.AccessDenied,
             .BADF => |err| return errnoBug(err), // File descriptor used after closed.
             .FAULT => |err| return errnoBug(err),
@@ -6083,7 +6082,7 @@ fn utimensat(
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.utimensat(dir, path, times, flags))) {
             .SUCCESS => return,
-            .INTR => continue,
+            .INTR => {},
             .BADF => |err| return errnoBug(err), // always a race condition
             .FAULT => |err| return errnoBug(err),
             .INVAL => |err| return errnoBug(err),
@@ -6095,19 +6094,33 @@ fn utimensat(
     }
 }
 
-fn writeAll(
-    ev: *Evented,
-    cancel_region: *CancelRegion,
-    fd: fd_t,
-    buffer: []const u8,
-) (File.Writer.Error || error{EndOfStream})!void {
+fn writeAllSync(sync: *CancelRegion.Sync, fd: fd_t, buffer: []const u8) File.Writer.Error!void {
     var index: usize = 0;
-    while (buffer.len - index != 0) {
-        const len = try ev.pwritev(cancel_region, fd, &.{
-            .{ .base = buffer[index..].ptr, .len = buffer.len - index },
-        }, null);
-        if (len == 0) return error.EndOfStream;
-        index += len;
+    while (buffer.len - index != 0) index += try writeSync(sync, fd, buffer[index..]);
+}
+
+fn writeSync(sync: *CancelRegion.Sync, fd: fd_t, buffer: []const u8) File.Writer.Error!usize {
+    while (true) {
+        try sync.cancel_region.await(.nothing);
+        const rc = linux.write(fd, buffer.ptr, buffer.len);
+        switch (linux.errno(rc)) {
+            .SUCCESS => return @intCast(rc),
+            .INTR => {},
+            .INVAL => |err| return errnoBug(err),
+            .FAULT => |err| return errnoBug(err),
+            .AGAIN => return error.WouldBlock,
+            .BADF => return error.NotOpenForWriting, // Can be a race condition.
+            .DESTADDRREQ => |err| return errnoBug(err), // `connect` was never called.
+            .DQUOT => return error.DiskQuota,
+            .FBIG => return error.FileTooBig,
+            .IO => return error.InputOutput,
+            .NOSPC => return error.NoSpaceLeft,
+            .PERM => return error.PermissionDenied,
+            .PIPE => return error.BrokenPipe,
+            .CONNRESET => |err| return errnoBug(err), // Not a socket handle.
+            .BUSY => return error.DeviceBusy,
+            else => |err| return unexpectedErrno(err),
+        }
     }
 }
 
diff --git a/lib/std/os/linux/IoUring.zig b/lib/std/os/linux/IoUring.zig
index 77fda7389dbc08924833c3e96ea1985be3cb3283..b8e83c51895faac65d561d4fda1d80c29be4a59a 100644
--- a/lib/std/os/linux/IoUring.zig
+++ b/lib/std/os/linux/IoUring.zig
@@ -201,6 +201,10 @@ pub fn enter(self: *IoUring, to_submit: u32, min_complete: u32, flags: u32) !u32
         // The kernel believes our `self.fd` does not refer to an io_uring instance,
         // or the opcode is valid but not supported by this kernel (more likely):
         .OPNOTSUPP => return error.OpcodeNotSupported,
+        // The thread submitting the work is invalid. This may occur if IORING_ENTER_GETEVENTS
+        // and IORING_SETUP_DEFER_TASKRUN is set, but the submitting thread is not the thread
+        // that initially created or enabled the io_uring associated with fd.
+        .EXIST => return error.InvalidThread,
         // The operation was interrupted by a delivery of a signal before it could complete.
         // This can happen while waiting for events with IORING_ENTER_GETEVENTS:
         .INTR => return error.SignalInterrupt,
-- 
2.54.0


From 8c83acd3d4e753c0fe52462068c2758ac3762095 Mon Sep 17 00:00:00 2001
From: Iku Iwasa <iku.iwasa@gmail.com>
Date: Sun, 15 Feb 2026 10:41:28 +0900
Subject: [PATCH 308/499] Add missing EV flags for NetBSD

- Add FLAG1, ERROR and EOF.
---
 lib/std/c.zig | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index 67d0540676b16cb4d3c545b04cff120ff0fd46a0..f4bdf3969c08e90969862b18a1c5ca6fcc970229 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -9812,13 +9812,16 @@ pub const EV = switch (native_os) {
         pub const ONESHOT = 0x0010;
         /// clear event state after reporting
         pub const CLEAR = 0x0020;
-        /// force immediate event output
-        /// ... with or without ERROR
-        /// ... use KEVENT_FLAG_ERROR_EVENTS
-        ///     on syscalls supporting flags
+        /// force EV_ERROR on success, data=0
         pub const RECEIPT = 0x0040;
         /// disable event after reporting
         pub const DISPATCH = 0x0080;
+        /// filter-specific flag
+        pub const FLAG1 = 0x2000;
+        /// error, data contains errno
+        pub const ERROR = 0x4000;
+        /// EOF detected
+        pub const EOF = 0x8000;
     },
     .freebsd => struct {
         /// add event to kq (implies enable)
-- 
2.54.0


From 17dd2f0a853eebb99d7165a3ec90719fc7b023a2 Mon Sep 17 00:00:00 2001
From: rpkak <rpkak@noreply.codeberg.org>
Date: Sun, 15 Feb 2026 18:05:12 +0100
Subject: [PATCH 309/499] spirv: implement AIR tag struct_field_ptr

---
 src/codegen/spirv/CodeGen.zig | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index f7212b6e1b1f449368872d27aa3688f12b891aa9..2222bb9a050341495a7ca97f6b5a4b9dd5b189ec 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -2761,6 +2761,8 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) Error!void {
             .struct_field_val => try cg.airStructFieldVal(inst),
             .field_parent_ptr => try cg.airFieldParentPtr(inst),
 
+            .struct_field_ptr => try cg.airStructFieldPtr(inst),
+
             .struct_field_ptr_index_0 => try cg.airStructFieldPtrIndex(inst, 0),
             .struct_field_ptr_index_1 => try cg.airStructFieldPtrIndex(inst, 1),
             .struct_field_ptr_index_2 => try cg.airStructFieldPtrIndex(inst, 2),
@@ -4806,6 +4808,15 @@ fn structFieldPtr(
     }
 }
 
+fn airStructFieldPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
+    const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
+    const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
+    const struct_ptr = try cg.resolve(struct_field.struct_operand);
+    const struct_ptr_ty = cg.typeOf(struct_field.struct_operand);
+    const result_ptr_ty = cg.typeOfIndex(inst);
+    return try cg.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, struct_field.field_index);
+}
+
 fn airStructFieldPtrIndex(cg: *CodeGen, inst: Air.Inst.Index, field_index: u32) !?Id {
     const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const struct_ptr = try cg.resolve(ty_op.operand);
-- 
2.54.0


From 1838134200c769b97b90f2b6daf7b50d861c7834 Mon Sep 17 00:00:00 2001
From: vitalii <vitalii.voloshyn@gmail.com>
Date: Sat, 14 Feb 2026 22:37:33 +0200
Subject: [PATCH 310/499] fix segfault when /etc/hosts missing last newline

---
 lib/std/Io/Threaded.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 485c35da578115c4f63a497124b09e1ebed9d643..a7e9668309eab37ccf91f34fc4bcdb57744b0b42 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -14866,7 +14866,7 @@ fn lookupHostsReader(
             error.ReadFailed => return error.ReadFailed,
             error.EndOfStream => break,
         };
-        reader.toss(1);
+        reader.toss(@min(1, reader.bufferedLen()));
         var split_it = std.mem.splitScalar(u8, line, '#');
         const no_comment_line = split_it.first();
 
-- 
2.54.0


From 27eec9bd62d126f2288ccf7b6f78dc38291cd2ed Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 15 Feb 2026 20:26:12 -0800
Subject: [PATCH 311/499] Revert "Allow overriding std.Io at a namespace
 level."

This reverts commit e314dadb015a913a2cdc12298986e9181305d8db.

This idea requires more consideration before committing to it.
At the very least let's not regress autodocs.

Closes #31230
---
 lib/std/std.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/std.zig b/lib/std/std.zig
index 7a796b25d086272407c2e729b2ceae2d7e7c236b..d563cdfae7aac1003fb7d91472cd6653f78a5cee 100644
--- a/lib/std/std.zig
+++ b/lib/std/std.zig
@@ -20,7 +20,7 @@ pub const EnumMap = enums.EnumMap;
 pub const EnumSet = enums.EnumSet;
 pub const HashMap = hash_map.HashMap;
 pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
-pub const Io = if (@hasDecl(root, "std_options_Io")) root.std_options_Io else @import("Io.zig");
+pub const Io = @import("Io.zig");
 pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;
 pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;
 pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;
-- 
2.54.0


From 0e45a449914e0170179301f721bb2025cac363aa Mon Sep 17 00:00:00 2001
From: "Marcel W. Wysocki" <maci.stgn@gmail.com>
Date: Mon, 16 Feb 2026 14:31:49 +0800
Subject: [PATCH 312/499] cc: disable implicit runtimes with -nostdlib,
 matching clang

---
 src/main.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.zig b/src/main.zig
index 1b9fe7b299406c76724d3690fa4c0ae20d74b1ba..ace428b0a51463c690a1e69b45eea290da7887a1 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -2078,6 +2078,8 @@ fn buildOutputType(
                     .nostdlib => {
                         create_module.opts.ensure_libc_on_non_freestanding = false;
                         create_module.opts.ensure_libcpp_on_non_freestanding = false;
+                        want_compiler_rt = false;
+                        want_ubsan_rt = false;
                     },
                     .nostdlib_cpp => create_module.opts.ensure_libcpp_on_non_freestanding = false,
                     .shared => {
-- 
2.54.0


From 0fd8dc8ea6872a545ba7f58e0f934cfa86adb2a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 17 Feb 2026 14:37:48 +0100
Subject: [PATCH 313/499] ci: update to qemu 10.2.1

---
 ci/x86_64-linux-debug-llvm.sh | 2 +-
 ci/x86_64-linux-debug.sh      | 2 +-
 ci/x86_64-linux-release.sh    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index 26d3911c135b0bdbf91ae0004788349e1cdc998b..815adfbe8e635bc2110a11f779e60b7d0a44fc72 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.0/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index d644d5e6439c586a02f97fc29122d223d8bffa18..01e7fdfff7dbf3e636a20953faf9d17a9a5197d7 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.0/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 94e6e93bbdc0f9fd5146c300624efb3f16a222c0..65f28ac59846a86d4b8177ffaa2131540eec003a 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.0/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
-- 
2.54.0


From 0e3c6514a4d1f89498bf411b58131d129218807f Mon Sep 17 00:00:00 2001
From: "Marcel W. Wysocki" <maci.stgn@gmail.com>
Date: Mon, 16 Feb 2026 00:45:28 +0800
Subject: [PATCH 314/499] link: recognize thin archives in ld script detection

Needed for linking the Linux kernel.
---
 lib/std/elf.zig | 2 ++
 src/link.zig    | 5 ++++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/std/elf.zig b/lib/std/elf.zig
index ec5e0be951d13f4fc6042efb83d637dbd22d79a4..962e0ceb9e22f655c9542c94928c98691d63a4fb 100644
--- a/lib/std/elf.zig
+++ b/lib/std/elf.zig
@@ -3062,6 +3062,8 @@ fn genSpecialMemberName(comptime name: []const u8) *const [16]u8 {
 // member indicates, for each member file.
 /// String that begins an archive file.
 pub const ARMAG = "!<arch>\n";
+/// String that begins a thin archive file.
+pub const ARMAG_THIN = "!<thin>\n";
 /// String in ar_fmag at the end of each header.
 pub const ARFMAG = "`\n";
 /// 32-bit symtab identifier
diff --git a/src/link.zig b/src/link.zig
index 72c5d27105bc9e40864b6c5b7ed7feb0917205f2..4999c8a31affc3964f8cf129f6bb50c8c5a87675 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -2226,7 +2226,10 @@ fn resolvePathInputLib(
         const n = file.readPositionalAll(io, ld_script_bytes.items, 0) catch |err|
             fatal("failed to read '{f}': {t}", .{ std.fmt.alt(test_path, .formatEscapeChar), err });
         const buf = ld_script_bytes.items[0..n];
-        if (mem.startsWith(u8, buf, std.elf.MAGIC) or mem.startsWith(u8, buf, std.elf.ARMAG)) {
+        if (mem.startsWith(u8, buf, std.elf.MAGIC) or
+            mem.startsWith(u8, buf, std.elf.ARMAG) or
+            mem.startsWith(u8, buf, std.elf.ARMAG_THIN))
+        {
             // Appears to be an ELF or archive file.
             return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query);
         }
-- 
2.54.0


From d297f7b8f2f598967a8b91a45df1b1932dd3c81d Mon Sep 17 00:00:00 2001
From: Saurabh Mishra <saurabh.m@proton.me>
Date: Wed, 18 Feb 2026 11:20:32 -0800
Subject: [PATCH 315/499] make priority dequeue an unmanaged container and
 ensure tests pass

---
 lib/std/priority_dequeue.zig | 410 ++++++++++++++++++++---------------
 1 file changed, 236 insertions(+), 174 deletions(-)

diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index e2a01696e595948639496dd97ac4307be54b88b9..33cf0eadbb44b3b3099c48a60575b5c298dca187 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -21,33 +21,31 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
 
         items: []T,
         len: usize,
-        allocator: Allocator,
         context: Context,
 
         /// Initialize and return a new priority dequeue.
-        pub fn init(allocator: Allocator, context: Context) Self {
+        pub fn init(context: Context) Self {
             return Self{
                 .items = &[_]T{},
                 .len = 0,
-                .allocator = allocator,
                 .context = context,
             };
         }
 
         /// Free memory used by the dequeue.
-        pub fn deinit(self: Self) void {
-            self.allocator.free(self.items);
+        pub fn deinit(self: Self, allocator: Allocator) void {
+            allocator.free(self.items);
         }
 
         /// Insert a new element, maintaining priority.
-        pub fn add(self: *Self, elem: T) !void {
-            try self.ensureUnusedCapacity(1);
+        pub fn add(self: *Self, allocator: Allocator, elem: T) !void {
+            try self.ensureUnusedCapacity(allocator, 1);
             addUnchecked(self, elem);
         }
 
         /// Add each element in `items` to the dequeue.
-        pub fn addSlice(self: *Self, items: []const T) !void {
-            try self.ensureUnusedCapacity(items.len);
+        pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void {
+            try self.ensureUnusedCapacity(allocator, items.len);
             for (items) |e| {
                 self.addUnchecked(e);
             }
@@ -333,14 +331,12 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             return self.items.len;
         }
 
-        /// Dequeue takes ownership of the passed in slice. The slice must have been
-        /// allocated with `allocator`.
-        /// De-initialize with `deinit`.
-        pub fn fromOwnedSlice(allocator: Allocator, items: []T, context: Context) Self {
+        /// Dequeue takes ownership of the passed in slice. The slice must be de-initialize
+        /// with `deinit`.
+        pub fn fromOwnedSlice(items: []T, context: Context) Self {
             var queue = Self{
                 .items = items,
                 .len = items.len,
-                .allocator = allocator,
                 .context = context,
             };
 
@@ -356,29 +352,29 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
         }
 
         /// Ensure that the dequeue can fit at least `new_capacity` items.
-        pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
+        pub fn ensureTotalCapacity(self: *Self, allocator: Allocator, new_capacity: usize) !void {
             var better_capacity = self.capacity();
             if (better_capacity >= new_capacity) return;
             while (true) {
                 better_capacity += better_capacity / 2 + 8;
                 if (better_capacity >= new_capacity) break;
             }
-            self.items = try self.allocator.realloc(self.items, better_capacity);
+            self.items = try allocator.realloc(self.items, better_capacity);
         }
 
         /// Ensure that the dequeue can fit at least `additional_count` **more** items.
-        pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void {
-            return self.ensureTotalCapacity(self.len + additional_count);
+        pub fn ensureUnusedCapacity(self: *Self, allocator: Allocator, additional_count: usize) !void {
+            return self.ensureTotalCapacity(allocator, self.len + additional_count);
         }
 
         /// Reduce allocated capacity to `new_len`.
-        pub fn shrinkAndFree(self: *Self, new_len: usize) void {
+        pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_len: usize) void {
             assert(new_len <= self.items.len);
 
             // Cannot shrink to smaller than the current queue size without invalidating the heap property
             assert(new_len >= self.len);
 
-            self.items = self.allocator.realloc(self.items[0..], new_len) catch |e| switch (e) {
+            self.items = allocator.realloc(self.items[0..], new_len) catch |e| switch (e) {
                 error.OutOfMemory => { // no problem, capacity is still correct then.
                     self.items.len = new_len;
                     return;
@@ -468,15 +464,16 @@ fn lessThanComparison(context: void, a: u32, b: u32) Order {
 const PDQ = PriorityDequeue(u32, void, lessThanComparison);
 
 test "add and remove min" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
 
-    try queue.add(54);
-    try queue.add(12);
-    try queue.add(7);
-    try queue.add(23);
-    try queue.add(25);
-    try queue.add(13);
+    try queue.add(gpa, 54);
+    try queue.add(gpa, 12);
+    try queue.add(gpa, 7);
+    try queue.add(gpa, 23);
+    try queue.add(gpa, 25);
+    try queue.add(gpa, 13);
 
     try expectEqual(@as(u32, 7), queue.removeMin());
     try expectEqual(@as(u32, 12), queue.removeMin());
@@ -487,6 +484,8 @@ test "add and remove min" {
 }
 
 test "add and remove min structs" {
+    const gpa = std.testing.allocator;
+
     const S = struct {
         size: u32,
     };
@@ -495,15 +494,15 @@ test "add and remove min structs" {
             _ = context;
             return std.math.order(a.size, b.size);
         }
-    }.order).init(testing.allocator, {});
-    defer queue.deinit();
+    }.order).init({});
+    defer queue.deinit(gpa);
 
-    try queue.add(.{ .size = 54 });
-    try queue.add(.{ .size = 12 });
-    try queue.add(.{ .size = 7 });
-    try queue.add(.{ .size = 23 });
-    try queue.add(.{ .size = 25 });
-    try queue.add(.{ .size = 13 });
+    try queue.add(gpa, .{ .size = 54 });
+    try queue.add(gpa, .{ .size = 12 });
+    try queue.add(gpa, .{ .size = 7 });
+    try queue.add(gpa, .{ .size = 23 });
+    try queue.add(gpa, .{ .size = 25 });
+    try queue.add(gpa, .{ .size = 13 });
 
     try expectEqual(@as(u32, 7), queue.removeMin().size);
     try expectEqual(@as(u32, 12), queue.removeMin().size);
@@ -514,15 +513,17 @@ test "add and remove min structs" {
 }
 
 test "add and remove max" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(54);
-    try queue.add(12);
-    try queue.add(7);
-    try queue.add(23);
-    try queue.add(25);
-    try queue.add(13);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 54);
+    try queue.add(gpa, 12);
+    try queue.add(gpa, 7);
+    try queue.add(gpa, 23);
+    try queue.add(gpa, 25);
+    try queue.add(gpa, 13);
 
     try expectEqual(@as(u32, 54), queue.removeMax());
     try expectEqual(@as(u32, 25), queue.removeMax());
@@ -533,15 +534,17 @@ test "add and remove max" {
 }
 
 test "add and remove same min" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
-    try queue.add(1);
-    try queue.add(1);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 1);
 
     try expectEqual(@as(u32, 1), queue.removeMin());
     try expectEqual(@as(u32, 1), queue.removeMin());
@@ -552,15 +555,17 @@ test "add and remove same min" {
 }
 
 test "add and remove same max" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
-    try queue.add(1);
-    try queue.add(1);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 1);
 
     try expectEqual(@as(u32, 2), queue.removeMax());
     try expectEqual(@as(u32, 2), queue.removeMax());
@@ -571,20 +576,24 @@ test "add and remove same max" {
 }
 
 test "removeOrNull empty" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
 
     try expect(queue.removeMinOrNull() == null);
     try expect(queue.removeMaxOrNull() == null);
 }
 
 test "edge case 3 elements" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(9);
-    try queue.add(3);
-    try queue.add(2);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 9);
+    try queue.add(gpa, 3);
+    try queue.add(gpa, 2);
 
     try expectEqual(@as(u32, 2), queue.removeMin());
     try expectEqual(@as(u32, 3), queue.removeMin());
@@ -592,12 +601,14 @@ test "edge case 3 elements" {
 }
 
 test "edge case 3 elements max" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(9);
-    try queue.add(3);
-    try queue.add(2);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 9);
+    try queue.add(gpa, 3);
+    try queue.add(gpa, 2);
 
     try expectEqual(@as(u32, 9), queue.removeMax());
     try expectEqual(@as(u32, 3), queue.removeMax());
@@ -605,39 +616,46 @@ test "edge case 3 elements max" {
 }
 
 test "peekMin" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
 
     try expect(queue.peekMin() == null);
 
-    try queue.add(9);
-    try queue.add(3);
-    try queue.add(2);
+    try queue.add(gpa, 9);
+    try queue.add(gpa, 3);
+    try queue.add(gpa, 2);
 
     try expect(queue.peekMin().? == 2);
     try expect(queue.peekMin().? == 2);
 }
 
 test "peekMax" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
 
     try expect(queue.peekMin() == null);
 
-    try queue.add(9);
-    try queue.add(3);
-    try queue.add(2);
+    try queue.add(gpa, 9);
+    try queue.add(gpa, 3);
+    try queue.add(gpa, 2);
 
     try expect(queue.peekMax().? == 9);
     try expect(queue.peekMax().? == 9);
 }
 
 test "sift up with odd indices, removeMin" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     for (items) |e| {
-        try queue.add(e);
+        try queue.add(gpa, e);
     }
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
@@ -647,11 +665,14 @@ test "sift up with odd indices, removeMin" {
 }
 
 test "sift up with odd indices, removeMax" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     for (items) |e| {
-        try queue.add(e);
+        try queue.add(gpa, e);
     }
 
     const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
@@ -661,10 +682,13 @@ test "sift up with odd indices, removeMax" {
 }
 
 test "addSlice min" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    try queue.addSlice(items[0..]);
+    try queue.addSlice(gpa, items[0..]);
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
@@ -673,10 +697,13 @@ test "addSlice min" {
 }
 
 test "addSlice max" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    try queue.addSlice(items[0..]);
+    try queue.addSlice(gpa, items[0..]);
 
     const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
     for (sorted_items) |e| {
@@ -685,19 +712,26 @@ test "addSlice max" {
 }
 
 test "fromOwnedSlice trivial case 0" {
+    const gpa = std.testing.allocator;
+
     const items = [0]u32{};
-    const queue_items = try testing.allocator.dupe(u32, &items);
-    var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
-    defer queue.deinit();
+    const queue_items = try gpa.dupe(u32, &items);
+
+    var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
+    defer queue.deinit(gpa);
+
     try expectEqual(@as(usize, 0), queue.len);
     try expect(queue.removeMinOrNull() == null);
 }
 
 test "fromOwnedSlice trivial case 1" {
+    const gpa = std.testing.allocator;
+
     const items = [1]u32{1};
-    const queue_items = try testing.allocator.dupe(u32, &items);
-    var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
-    defer queue.deinit();
+    const queue_items = try gpa.dupe(u32, &items);
+
+    var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
+    defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 1), queue.len);
     try expectEqual(items[0], queue.removeMin());
@@ -705,10 +739,13 @@ test "fromOwnedSlice trivial case 1" {
 }
 
 test "fromOwnedSlice" {
+    const gpa = std.testing.allocator;
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    const queue_items = try testing.allocator.dupe(u32, items[0..]);
-    var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
-    defer queue.deinit();
+    const queue_items = try gpa.dupe(u32, items[0..]);
+
+    var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
+    defer queue.deinit(gpa);
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
@@ -717,12 +754,14 @@ test "fromOwnedSlice" {
 }
 
 test "update min queue" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(55);
-    try queue.add(44);
-    try queue.add(11);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 55);
+    try queue.add(gpa, 44);
+    try queue.add(gpa, 11);
     try queue.update(55, 5);
     try queue.update(44, 4);
     try queue.update(11, 1);
@@ -732,13 +771,15 @@ test "update min queue" {
 }
 
 test "update same min queue" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 2);
     try queue.update(1, 5);
     try queue.update(2, 4);
     try expectEqual(@as(u32, 1), queue.removeMin());
@@ -748,12 +789,14 @@ test "update same min queue" {
 }
 
 test "update max queue" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(55);
-    try queue.add(44);
-    try queue.add(11);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 55);
+    try queue.add(gpa, 44);
+    try queue.add(gpa, 11);
     try queue.update(55, 5);
     try queue.update(44, 1);
     try queue.update(11, 4);
@@ -764,13 +807,15 @@ test "update max queue" {
 }
 
 test "update same max queue" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 2);
     try queue.update(1, 5);
     try queue.update(2, 4);
     try expectEqual(@as(u32, 5), queue.removeMax());
@@ -780,25 +825,29 @@ test "update same max queue" {
 }
 
 test "update after remove" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(1);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 1);
     try expectEqual(@as(u32, 1), queue.removeMin());
     try expectError(error.ElementNotFound, queue.update(1, 1));
 }
 
 test "iterator" {
-    var queue = PDQ.init(testing.allocator, {});
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
     var map = std.AutoHashMap(u32, void).init(testing.allocator);
     defer {
-        queue.deinit();
+        queue.deinit(gpa);
         map.deinit();
     }
 
     const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
     for (items) |e| {
-        _ = try queue.add(e);
+        _ = try queue.add(gpa, e);
         _ = try map.put(e, {});
     }
 
@@ -811,12 +860,14 @@ test "iterator" {
 }
 
 test "remove at index" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.add(3);
-    try queue.add(2);
-    try queue.add(1);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.add(gpa, 3);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 1);
 
     var it = queue.iterator();
     var elem = it.next();
@@ -834,8 +885,10 @@ test "remove at index" {
 }
 
 test "iterator while empty" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
+
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
 
     var it = queue.iterator();
 
@@ -843,19 +896,21 @@ test "iterator while empty" {
 }
 
 test "shrinkAndFree" {
-    var queue = PDQ.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = std.testing.allocator;
 
-    try queue.ensureTotalCapacity(4);
+    var queue = PDQ.init({});
+    defer queue.deinit(gpa);
+
+    try queue.ensureTotalCapacity(gpa, 4);
     try expect(queue.capacity() >= 4);
 
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(3);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 3);
     try expect(queue.capacity() >= 4);
     try expectEqual(@as(usize, 3), queue.len);
 
-    queue.shrinkAndFree(3);
+    queue.shrinkAndFree(gpa, 3);
     try expectEqual(@as(usize, 3), queue.capacity());
     try expectEqual(@as(usize, 3), queue.len);
 
@@ -879,11 +934,12 @@ test "fuzz testing min" {
 }
 
 fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void {
-    const allocator = testing.allocator;
-    const items = try generateRandomSlice(allocator, rng, queue_size);
+    const gpa = std.testing.allocator;
 
-    var queue = PDQ.fromOwnedSlice(allocator, items, {});
-    defer queue.deinit();
+    const items = try generateRandomSlice(gpa, rng, queue_size);
+
+    var queue = PDQ.fromOwnedSlice(items, {});
+    defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
     while (queue.removeMinOrNull()) |next| {
@@ -908,11 +964,12 @@ test "fuzz testing max" {
 }
 
 fn fuzzTestMax(rng: std.Random, queue_size: usize) !void {
-    const allocator = testing.allocator;
-    const items = try generateRandomSlice(allocator, rng, queue_size);
+    const gpa = std.testing.allocator;
 
-    var queue = PDQ.fromOwnedSlice(testing.allocator, items, {});
-    defer queue.deinit();
+    const items = try generateRandomSlice(gpa, rng, queue_size);
+
+    var queue = PDQ.fromOwnedSlice(items, {});
+    defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
     while (queue.removeMaxOrNull()) |next| {
@@ -937,11 +994,12 @@ test "fuzz testing min and max" {
 }
 
 fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
-    const allocator = testing.allocator;
-    const items = try generateRandomSlice(allocator, rng, queue_size);
+    const gpa = std.testing.allocator;
 
-    var queue = PDQ.fromOwnedSlice(allocator, items, {});
-    defer queue.deinit();
+    const items = try generateRandomSlice(gpa, rng, queue_size);
+
+    var queue = PDQ.fromOwnedSlice(items, {});
+    defer queue.deinit(gpa);
 
     var last_min: ?u32 = null;
     var last_max: ?u32 = null;
@@ -983,18 +1041,20 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order {
 const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison);
 
 test "add and remove" {
+    const gpa = std.testing.allocator;
+
     const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
 
-    var queue = CPDQ.init(testing.allocator, context[0..]);
-    defer queue.deinit();
+    var queue = CPDQ.init(context[0..]);
+    defer queue.deinit(gpa);
 
-    try queue.add(0);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(3);
-    try queue.add(4);
-    try queue.add(5);
-    try queue.add(6);
+    try queue.add(gpa, 0);
+    try queue.add(gpa, 1);
+    try queue.add(gpa, 2);
+    try queue.add(gpa, 3);
+    try queue.add(gpa, 4);
+    try queue.add(gpa, 5);
+    try queue.add(gpa, 6);
     try expectEqual(@as(usize, 6), queue.removeMin());
     try expectEqual(@as(usize, 5), queue.removeMax());
     try expectEqual(@as(usize, 3), queue.removeMin());
@@ -1007,20 +1067,22 @@ test "add and remove" {
 var all_cmps_unique = true;
 
 test "don't compare a value to a copy of itself" {
+    const gpa = std.testing.allocator;
+
     var depq = PriorityDequeue(u32, void, struct {
         fn uniqueLessThan(_: void, a: u32, b: u32) Order {
             all_cmps_unique = all_cmps_unique and (a != b);
             return std.math.order(a, b);
         }
-    }.uniqueLessThan).init(testing.allocator, {});
-    defer depq.deinit();
+    }.uniqueLessThan).init({});
+    defer depq.deinit(gpa);
 
-    try depq.add(1);
-    try depq.add(2);
-    try depq.add(3);
-    try depq.add(4);
-    try depq.add(5);
-    try depq.add(6);
+    try depq.add(gpa, 1);
+    try depq.add(gpa, 2);
+    try depq.add(gpa, 3);
+    try depq.add(gpa, 4);
+    try depq.add(gpa, 5);
+    try depq.add(gpa, 6);
 
     _ = depq.removeIndex(2);
     try expectEqual(all_cmps_unique, true);
-- 
2.54.0


From 535722b37419f821650a3765e20880a3186ceff3 Mon Sep 17 00:00:00 2001
From: Saurabh Mishra <saurabh.m@proton.me>
Date: Wed, 18 Feb 2026 11:43:57 -0800
Subject: [PATCH 316/499] rename `add` to `push` and `remove` to `pop` in
 methods and tests

---
 lib/std/priority_dequeue.zig | 390 +++++++++++++++++------------------
 1 file changed, 195 insertions(+), 195 deletions(-)

diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index 33cf0eadbb44b3b3099c48a60575b5c298dca187..a69f2bcb9aa53daabca77a8cda515d96ccfda8b8 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -38,20 +38,20 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
         }
 
         /// Insert a new element, maintaining priority.
-        pub fn add(self: *Self, allocator: Allocator, elem: T) !void {
+        pub fn push(self: *Self, allocator: Allocator, elem: T) !void {
             try self.ensureUnusedCapacity(allocator, 1);
-            addUnchecked(self, elem);
+            pushUnchecked(self, elem);
         }
 
         /// Add each element in `items` to the dequeue.
-        pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void {
+        pub fn pushSlice(self: *Self, allocator: Allocator, items: []const T) !void {
             try self.ensureUnusedCapacity(allocator, items.len);
             for (items) |e| {
-                self.addUnchecked(e);
+                self.pushUnchecked(e);
             }
         }
 
-        fn addUnchecked(self: *Self, elem: T) void {
+        fn pushUnchecked(self: *Self, elem: T) void {
             self.items[self.len] = elem;
 
             if (self.len > 0) {
@@ -151,32 +151,32 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
 
         /// Pop the smallest element from the dequeue. Returns
         /// `null` if empty.
-        pub fn removeMinOrNull(self: *Self) ?T {
-            return if (self.len > 0) self.removeMin() else null;
+        pub fn popMinOrNull(self: *Self) ?T {
+            return if (self.len > 0) self.popMin() else null;
         }
 
         /// Remove and return the smallest element from the
         /// dequeue.
-        pub fn removeMin(self: *Self) T {
-            return self.removeIndex(0);
+        pub fn popMin(self: *Self) T {
+            return self.popIndex(0);
         }
 
         /// Pop the largest element from the dequeue. Returns
         /// `null` if empty.
-        pub fn removeMaxOrNull(self: *Self) ?T {
-            return if (self.len > 0) self.removeMax() else null;
+        pub fn popMaxOrNull(self: *Self) ?T {
+            return if (self.len > 0) self.popMax() else null;
         }
 
         /// Remove and return the largest element from the
         /// dequeue.
-        pub fn removeMax(self: *Self) T {
-            return self.removeIndex(self.maxIndex().?);
+        pub fn popMax(self: *Self) T {
+            return self.popIndex(self.maxIndex().?);
         }
 
         /// Remove and return element at index. Indices are in the
         /// same order as iterator, which is not necessarily priority
         /// order.
-        pub fn removeIndex(self: *Self, index: usize) T {
+        pub fn popIndex(self: *Self, index: usize) T {
             assert(self.len > index);
             const item = self.items[index];
             const last = self.items[self.len - 1];
@@ -391,8 +391,8 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
                 }
                 return error.ElementNotFound;
             };
-            _ = self.removeIndex(old_index);
-            self.addUnchecked(new_elem);
+            _ = self.popIndex(old_index);
+            self.pushUnchecked(new_elem);
         }
 
         pub const Iterator = struct {
@@ -463,27 +463,27 @@ fn lessThanComparison(context: void, a: u32, b: u32) Order {
 
 const PDQ = PriorityDequeue(u32, void, lessThanComparison);
 
-test "add and remove min" {
+test "push and pop min" {
     const gpa = std.testing.allocator;
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 54);
-    try queue.add(gpa, 12);
-    try queue.add(gpa, 7);
-    try queue.add(gpa, 23);
-    try queue.add(gpa, 25);
-    try queue.add(gpa, 13);
+    try queue.push(gpa, 54);
+    try queue.push(gpa, 12);
+    try queue.push(gpa, 7);
+    try queue.push(gpa, 23);
+    try queue.push(gpa, 25);
+    try queue.push(gpa, 13);
 
-    try expectEqual(@as(u32, 7), queue.removeMin());
-    try expectEqual(@as(u32, 12), queue.removeMin());
-    try expectEqual(@as(u32, 13), queue.removeMin());
-    try expectEqual(@as(u32, 23), queue.removeMin());
-    try expectEqual(@as(u32, 25), queue.removeMin());
-    try expectEqual(@as(u32, 54), queue.removeMin());
+    try expectEqual(@as(u32, 7), queue.popMin());
+    try expectEqual(@as(u32, 12), queue.popMin());
+    try expectEqual(@as(u32, 13), queue.popMin());
+    try expectEqual(@as(u32, 23), queue.popMin());
+    try expectEqual(@as(u32, 25), queue.popMin());
+    try expectEqual(@as(u32, 54), queue.popMin());
 }
 
-test "add and remove min structs" {
+test "push and pop min structs" {
     const gpa = std.testing.allocator;
 
     const S = struct {
@@ -497,92 +497,92 @@ test "add and remove min structs" {
     }.order).init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, .{ .size = 54 });
-    try queue.add(gpa, .{ .size = 12 });
-    try queue.add(gpa, .{ .size = 7 });
-    try queue.add(gpa, .{ .size = 23 });
-    try queue.add(gpa, .{ .size = 25 });
-    try queue.add(gpa, .{ .size = 13 });
-
-    try expectEqual(@as(u32, 7), queue.removeMin().size);
-    try expectEqual(@as(u32, 12), queue.removeMin().size);
-    try expectEqual(@as(u32, 13), queue.removeMin().size);
-    try expectEqual(@as(u32, 23), queue.removeMin().size);
-    try expectEqual(@as(u32, 25), queue.removeMin().size);
-    try expectEqual(@as(u32, 54), queue.removeMin().size);
+    try queue.push(gpa, .{ .size = 54 });
+    try queue.push(gpa, .{ .size = 12 });
+    try queue.push(gpa, .{ .size = 7 });
+    try queue.push(gpa, .{ .size = 23 });
+    try queue.push(gpa, .{ .size = 25 });
+    try queue.push(gpa, .{ .size = 13 });
+
+    try expectEqual(@as(u32, 7), queue.popMin().size);
+    try expectEqual(@as(u32, 12), queue.popMin().size);
+    try expectEqual(@as(u32, 13), queue.popMin().size);
+    try expectEqual(@as(u32, 23), queue.popMin().size);
+    try expectEqual(@as(u32, 25), queue.popMin().size);
+    try expectEqual(@as(u32, 54), queue.popMin().size);
 }
 
-test "add and remove max" {
+test "push and pop max" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 54);
-    try queue.add(gpa, 12);
-    try queue.add(gpa, 7);
-    try queue.add(gpa, 23);
-    try queue.add(gpa, 25);
-    try queue.add(gpa, 13);
-
-    try expectEqual(@as(u32, 54), queue.removeMax());
-    try expectEqual(@as(u32, 25), queue.removeMax());
-    try expectEqual(@as(u32, 23), queue.removeMax());
-    try expectEqual(@as(u32, 13), queue.removeMax());
-    try expectEqual(@as(u32, 12), queue.removeMax());
-    try expectEqual(@as(u32, 7), queue.removeMax());
+    try queue.push(gpa, 54);
+    try queue.push(gpa, 12);
+    try queue.push(gpa, 7);
+    try queue.push(gpa, 23);
+    try queue.push(gpa, 25);
+    try queue.push(gpa, 13);
+
+    try expectEqual(@as(u32, 54), queue.popMax());
+    try expectEqual(@as(u32, 25), queue.popMax());
+    try expectEqual(@as(u32, 23), queue.popMax());
+    try expectEqual(@as(u32, 13), queue.popMax());
+    try expectEqual(@as(u32, 12), queue.popMax());
+    try expectEqual(@as(u32, 7), queue.popMax());
 }
 
-test "add and remove same min" {
+test "push and pop same min" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 1);
-
-    try expectEqual(@as(u32, 1), queue.removeMin());
-    try expectEqual(@as(u32, 1), queue.removeMin());
-    try expectEqual(@as(u32, 1), queue.removeMin());
-    try expectEqual(@as(u32, 1), queue.removeMin());
-    try expectEqual(@as(u32, 2), queue.removeMin());
-    try expectEqual(@as(u32, 2), queue.removeMin());
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+
+    try expectEqual(@as(u32, 1), queue.popMin());
+    try expectEqual(@as(u32, 1), queue.popMin());
+    try expectEqual(@as(u32, 1), queue.popMin());
+    try expectEqual(@as(u32, 1), queue.popMin());
+    try expectEqual(@as(u32, 2), queue.popMin());
+    try expectEqual(@as(u32, 2), queue.popMin());
 }
 
-test "add and remove same max" {
+test "push and pop same max" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 1);
-
-    try expectEqual(@as(u32, 2), queue.removeMax());
-    try expectEqual(@as(u32, 2), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+
+    try expectEqual(@as(u32, 2), queue.popMax());
+    try expectEqual(@as(u32, 2), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
 }
 
-test "removeOrNull empty" {
+test "popOrNull empty" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try expect(queue.removeMinOrNull() == null);
-    try expect(queue.removeMaxOrNull() == null);
+    try expect(queue.popMinOrNull() == null);
+    try expect(queue.popMaxOrNull() == null);
 }
 
 test "edge case 3 elements" {
@@ -591,13 +591,13 @@ test "edge case 3 elements" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 9);
-    try queue.add(gpa, 3);
-    try queue.add(gpa, 2);
+    try queue.push(gpa, 9);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
 
-    try expectEqual(@as(u32, 2), queue.removeMin());
-    try expectEqual(@as(u32, 3), queue.removeMin());
-    try expectEqual(@as(u32, 9), queue.removeMin());
+    try expectEqual(@as(u32, 2), queue.popMin());
+    try expectEqual(@as(u32, 3), queue.popMin());
+    try expectEqual(@as(u32, 9), queue.popMin());
 }
 
 test "edge case 3 elements max" {
@@ -606,13 +606,13 @@ test "edge case 3 elements max" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 9);
-    try queue.add(gpa, 3);
-    try queue.add(gpa, 2);
+    try queue.push(gpa, 9);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
 
-    try expectEqual(@as(u32, 9), queue.removeMax());
-    try expectEqual(@as(u32, 3), queue.removeMax());
-    try expectEqual(@as(u32, 2), queue.removeMax());
+    try expectEqual(@as(u32, 9), queue.popMax());
+    try expectEqual(@as(u32, 3), queue.popMax());
+    try expectEqual(@as(u32, 2), queue.popMax());
 }
 
 test "peekMin" {
@@ -623,9 +623,9 @@ test "peekMin" {
 
     try expect(queue.peekMin() == null);
 
-    try queue.add(gpa, 9);
-    try queue.add(gpa, 3);
-    try queue.add(gpa, 2);
+    try queue.push(gpa, 9);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
 
     try expect(queue.peekMin().? == 2);
     try expect(queue.peekMin().? == 2);
@@ -639,15 +639,15 @@ test "peekMax" {
 
     try expect(queue.peekMin() == null);
 
-    try queue.add(gpa, 9);
-    try queue.add(gpa, 3);
-    try queue.add(gpa, 2);
+    try queue.push(gpa, 9);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
 
     try expect(queue.peekMax().? == 9);
     try expect(queue.peekMax().? == 9);
 }
 
-test "sift up with odd indices, removeMin" {
+test "sift up with odd indices, popMin" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
@@ -655,16 +655,16 @@ test "sift up with odd indices, removeMin" {
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     for (items) |e| {
-        try queue.add(gpa, e);
+        try queue.push(gpa, e);
     }
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.removeMin());
+        try expectEqual(e, queue.popMin());
     }
 }
 
-test "sift up with odd indices, removeMax" {
+test "sift up with odd indices, popMax" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
@@ -672,42 +672,42 @@ test "sift up with odd indices, removeMax" {
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     for (items) |e| {
-        try queue.add(gpa, e);
+        try queue.push(gpa, e);
     }
 
     const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.removeMax());
+        try expectEqual(e, queue.popMax());
     }
 }
 
-test "addSlice min" {
+test "pushSlice min" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    try queue.addSlice(gpa, items[0..]);
+    try queue.pushSlice(gpa, items[0..]);
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.removeMin());
+        try expectEqual(e, queue.popMin());
     }
 }
 
-test "addSlice max" {
+test "pushSlice max" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    try queue.addSlice(gpa, items[0..]);
+    try queue.pushSlice(gpa, items[0..]);
 
     const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.removeMax());
+        try expectEqual(e, queue.popMax());
     }
 }
 
@@ -721,7 +721,7 @@ test "fromOwnedSlice trivial case 0" {
     defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 0), queue.len);
-    try expect(queue.removeMinOrNull() == null);
+    try expect(queue.popMinOrNull() == null);
 }
 
 test "fromOwnedSlice trivial case 1" {
@@ -734,8 +734,8 @@ test "fromOwnedSlice trivial case 1" {
     defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 1), queue.len);
-    try expectEqual(items[0], queue.removeMin());
-    try expect(queue.removeMinOrNull() == null);
+    try expectEqual(items[0], queue.popMin());
+    try expect(queue.popMinOrNull() == null);
 }
 
 test "fromOwnedSlice" {
@@ -749,7 +749,7 @@ test "fromOwnedSlice" {
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.removeMin());
+        try expectEqual(e, queue.popMin());
     }
 }
 
@@ -759,15 +759,15 @@ test "update min queue" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 55);
-    try queue.add(gpa, 44);
-    try queue.add(gpa, 11);
+    try queue.push(gpa, 55);
+    try queue.push(gpa, 44);
+    try queue.push(gpa, 11);
     try queue.update(55, 5);
     try queue.update(44, 4);
     try queue.update(11, 1);
-    try expectEqual(@as(u32, 1), queue.removeMin());
-    try expectEqual(@as(u32, 4), queue.removeMin());
-    try expectEqual(@as(u32, 5), queue.removeMin());
+    try expectEqual(@as(u32, 1), queue.popMin());
+    try expectEqual(@as(u32, 4), queue.popMin());
+    try expectEqual(@as(u32, 5), queue.popMin());
 }
 
 test "update same min queue" {
@@ -776,16 +776,16 @@ test "update same min queue" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 2);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
     try queue.update(1, 5);
     try queue.update(2, 4);
-    try expectEqual(@as(u32, 1), queue.removeMin());
-    try expectEqual(@as(u32, 2), queue.removeMin());
-    try expectEqual(@as(u32, 4), queue.removeMin());
-    try expectEqual(@as(u32, 5), queue.removeMin());
+    try expectEqual(@as(u32, 1), queue.popMin());
+    try expectEqual(@as(u32, 2), queue.popMin());
+    try expectEqual(@as(u32, 4), queue.popMin());
+    try expectEqual(@as(u32, 5), queue.popMin());
 }
 
 test "update max queue" {
@@ -794,16 +794,16 @@ test "update max queue" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 55);
-    try queue.add(gpa, 44);
-    try queue.add(gpa, 11);
+    try queue.push(gpa, 55);
+    try queue.push(gpa, 44);
+    try queue.push(gpa, 11);
     try queue.update(55, 5);
     try queue.update(44, 1);
     try queue.update(11, 4);
 
-    try expectEqual(@as(u32, 5), queue.removeMax());
-    try expectEqual(@as(u32, 4), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
+    try expectEqual(@as(u32, 5), queue.popMax());
+    try expectEqual(@as(u32, 4), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
 }
 
 test "update same max queue" {
@@ -812,26 +812,26 @@ test "update same max queue" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 2);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
     try queue.update(1, 5);
     try queue.update(2, 4);
-    try expectEqual(@as(u32, 5), queue.removeMax());
-    try expectEqual(@as(u32, 4), queue.removeMax());
-    try expectEqual(@as(u32, 2), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
+    try expectEqual(@as(u32, 5), queue.popMax());
+    try expectEqual(@as(u32, 4), queue.popMax());
+    try expectEqual(@as(u32, 2), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
 }
 
-test "update after remove" {
+test "update after pop" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 1);
-    try expectEqual(@as(u32, 1), queue.removeMin());
+    try queue.push(gpa, 1);
+    try expectEqual(@as(u32, 1), queue.popMin());
     try expectError(error.ElementNotFound, queue.update(1, 1));
 }
 
@@ -847,7 +847,7 @@ test "iterator" {
 
     const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
     for (items) |e| {
-        _ = try queue.add(gpa, e);
+        _ = try queue.push(gpa, e);
         _ = try map.put(e, {});
     }
 
@@ -859,15 +859,15 @@ test "iterator" {
     try expectEqual(@as(usize, 0), map.count());
 }
 
-test "remove at index" {
+test "pop at index" {
     const gpa = std.testing.allocator;
 
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 3);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 1);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 1);
 
     var it = queue.iterator();
     var elem = it.next();
@@ -878,10 +878,10 @@ test "remove at index" {
         idx += 1;
     } else unreachable;
 
-    try expectEqual(queue.removeIndex(two_idx), 2);
-    try expectEqual(queue.removeMin(), 1);
-    try expectEqual(queue.removeMin(), 3);
-    try expectEqual(queue.removeMinOrNull(), null);
+    try expectEqual(queue.popIndex(two_idx), 2);
+    try expectEqual(queue.popMin(), 1);
+    try expectEqual(queue.popMin(), 3);
+    try expectEqual(queue.popMinOrNull(), null);
 }
 
 test "iterator while empty" {
@@ -904,9 +904,9 @@ test "shrinkAndFree" {
     try queue.ensureTotalCapacity(gpa, 4);
     try expect(queue.capacity() >= 4);
 
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 3);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 3);
     try expect(queue.capacity() >= 4);
     try expectEqual(@as(usize, 3), queue.len);
 
@@ -914,10 +914,10 @@ test "shrinkAndFree" {
     try expectEqual(@as(usize, 3), queue.capacity());
     try expectEqual(@as(usize, 3), queue.len);
 
-    try expectEqual(@as(u32, 3), queue.removeMax());
-    try expectEqual(@as(u32, 2), queue.removeMax());
-    try expectEqual(@as(u32, 1), queue.removeMax());
-    try expect(queue.removeMaxOrNull() == null);
+    try expectEqual(@as(u32, 3), queue.popMax());
+    try expectEqual(@as(u32, 2), queue.popMax());
+    try expectEqual(@as(u32, 1), queue.popMax());
+    try expect(queue.popMaxOrNull() == null);
 }
 
 test "fuzz testing min" {
@@ -942,7 +942,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void {
     defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
-    while (queue.removeMinOrNull()) |next| {
+    while (queue.popMinOrNull()) |next| {
         if (last_removed) |last| {
             try expect(last <= next);
         }
@@ -972,7 +972,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void {
     defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
-    while (queue.removeMaxOrNull()) |next| {
+    while (queue.popMaxOrNull()) |next| {
         if (last_removed) |last| {
             try expect(last >= next);
         }
@@ -1006,13 +1006,13 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
     var i: usize = 0;
     while (i < queue_size) : (i += 1) {
         if (i % 2 == 0) {
-            const next = queue.removeMin();
+            const next = queue.popMin();
             if (last_min) |last| {
                 try expect(last <= next);
             }
             last_min = next;
         } else {
-            const next = queue.removeMax();
+            const next = queue.popMax();
             if (last_max) |last| {
                 try expect(last >= next);
             }
@@ -1040,7 +1040,7 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order {
 
 const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison);
 
-test "add and remove" {
+test "push and pop" {
     const gpa = std.testing.allocator;
 
     const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
@@ -1048,20 +1048,20 @@ test "add and remove" {
     var queue = CPDQ.init(context[0..]);
     defer queue.deinit(gpa);
 
-    try queue.add(gpa, 0);
-    try queue.add(gpa, 1);
-    try queue.add(gpa, 2);
-    try queue.add(gpa, 3);
-    try queue.add(gpa, 4);
-    try queue.add(gpa, 5);
-    try queue.add(gpa, 6);
-    try expectEqual(@as(usize, 6), queue.removeMin());
-    try expectEqual(@as(usize, 5), queue.removeMax());
-    try expectEqual(@as(usize, 3), queue.removeMin());
-    try expectEqual(@as(usize, 0), queue.removeMax());
-    try expectEqual(@as(usize, 4), queue.removeMin());
-    try expectEqual(@as(usize, 2), queue.removeMax());
-    try expectEqual(@as(usize, 1), queue.removeMin());
+    try queue.push(gpa, 0);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 4);
+    try queue.push(gpa, 5);
+    try queue.push(gpa, 6);
+    try expectEqual(@as(usize, 6), queue.popMin());
+    try expectEqual(@as(usize, 5), queue.popMax());
+    try expectEqual(@as(usize, 3), queue.popMin());
+    try expectEqual(@as(usize, 0), queue.popMax());
+    try expectEqual(@as(usize, 4), queue.popMin());
+    try expectEqual(@as(usize, 2), queue.popMax());
+    try expectEqual(@as(usize, 1), queue.popMin());
 }
 
 var all_cmps_unique = true;
@@ -1077,13 +1077,13 @@ test "don't compare a value to a copy of itself" {
     }.uniqueLessThan).init({});
     defer depq.deinit(gpa);
 
-    try depq.add(gpa, 1);
-    try depq.add(gpa, 2);
-    try depq.add(gpa, 3);
-    try depq.add(gpa, 4);
-    try depq.add(gpa, 5);
-    try depq.add(gpa, 6);
+    try depq.push(gpa, 1);
+    try depq.push(gpa, 2);
+    try depq.push(gpa, 3);
+    try depq.push(gpa, 4);
+    try depq.push(gpa, 5);
+    try depq.push(gpa, 6);
 
-    _ = depq.removeIndex(2);
+    _ = depq.popIndex(2);
     try expectEqual(all_cmps_unique, true);
 }
-- 
2.54.0


From 23252c27beda48df95beb7bcf53b900e93fc7441 Mon Sep 17 00:00:00 2001
From: Saurabh Mishra <saurabh.m@proton.me>
Date: Wed, 18 Feb 2026 11:58:13 -0800
Subject: [PATCH 317/499] merge `popMinOrNull` into `popMin` and `popMaxOrNull`
 into `popMax`, and update tests

---
 lib/std/priority_dequeue.zig | 58 ++++++++++++++----------------------
 1 file changed, 22 insertions(+), 36 deletions(-)

diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index a69f2bcb9aa53daabca77a8cda515d96ccfda8b8..53cb65d98e273618310341336f6fc8d8b1397ac8 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -149,28 +149,14 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             return self.bestItemAtIndices(1, 2, .gt).index;
         }
 
-        /// Pop the smallest element from the dequeue. Returns
-        /// `null` if empty.
-        pub fn popMinOrNull(self: *Self) ?T {
-            return if (self.len > 0) self.popMin() else null;
+        /// Remove and return the smallest element from the dequeue, or `null` if empty
+        pub fn popMin(self: *Self) ?T {
+            return if (self.len > 0) self.popIndex(0) else null;
         }
 
-        /// Remove and return the smallest element from the
-        /// dequeue.
-        pub fn popMin(self: *Self) T {
-            return self.popIndex(0);
-        }
-
-        /// Pop the largest element from the dequeue. Returns
-        /// `null` if empty.
-        pub fn popMaxOrNull(self: *Self) ?T {
-            return if (self.len > 0) self.popMax() else null;
-        }
-
-        /// Remove and return the largest element from the
-        /// dequeue.
-        pub fn popMax(self: *Self) T {
-            return self.popIndex(self.maxIndex().?);
+        /// Remove and return the largest element from the dequeue, or `null` if empty
+        pub fn popMax(self: *Self) ?T {
+            return if (self.len > 0) self.popIndex(self.maxIndex().?) else null;
         }
 
         /// Remove and return element at index. Indices are in the
@@ -504,12 +490,12 @@ test "push and pop min structs" {
     try queue.push(gpa, .{ .size = 25 });
     try queue.push(gpa, .{ .size = 13 });
 
-    try expectEqual(@as(u32, 7), queue.popMin().size);
-    try expectEqual(@as(u32, 12), queue.popMin().size);
-    try expectEqual(@as(u32, 13), queue.popMin().size);
-    try expectEqual(@as(u32, 23), queue.popMin().size);
-    try expectEqual(@as(u32, 25), queue.popMin().size);
-    try expectEqual(@as(u32, 54), queue.popMin().size);
+    try expectEqual(@as(u32, 7), queue.popMin().?.size);
+    try expectEqual(@as(u32, 12), queue.popMin().?.size);
+    try expectEqual(@as(u32, 13), queue.popMin().?.size);
+    try expectEqual(@as(u32, 23), queue.popMin().?.size);
+    try expectEqual(@as(u32, 25), queue.popMin().?.size);
+    try expectEqual(@as(u32, 54), queue.popMin().?.size);
 }
 
 test "push and pop max" {
@@ -581,8 +567,8 @@ test "popOrNull empty" {
     var queue = PDQ.init({});
     defer queue.deinit(gpa);
 
-    try expect(queue.popMinOrNull() == null);
-    try expect(queue.popMaxOrNull() == null);
+    try expect(queue.popMin() == null);
+    try expect(queue.popMax() == null);
 }
 
 test "edge case 3 elements" {
@@ -721,7 +707,7 @@ test "fromOwnedSlice trivial case 0" {
     defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 0), queue.len);
-    try expect(queue.popMinOrNull() == null);
+    try expect(queue.popMin() == null);
 }
 
 test "fromOwnedSlice trivial case 1" {
@@ -735,7 +721,7 @@ test "fromOwnedSlice trivial case 1" {
 
     try expectEqual(@as(usize, 1), queue.len);
     try expectEqual(items[0], queue.popMin());
-    try expect(queue.popMinOrNull() == null);
+    try expect(queue.popMin() == null);
 }
 
 test "fromOwnedSlice" {
@@ -881,7 +867,7 @@ test "pop at index" {
     try expectEqual(queue.popIndex(two_idx), 2);
     try expectEqual(queue.popMin(), 1);
     try expectEqual(queue.popMin(), 3);
-    try expectEqual(queue.popMinOrNull(), null);
+    try expectEqual(queue.popMin(), null);
 }
 
 test "iterator while empty" {
@@ -917,7 +903,7 @@ test "shrinkAndFree" {
     try expectEqual(@as(u32, 3), queue.popMax());
     try expectEqual(@as(u32, 2), queue.popMax());
     try expectEqual(@as(u32, 1), queue.popMax());
-    try expect(queue.popMaxOrNull() == null);
+    try expect(queue.popMax() == null);
 }
 
 test "fuzz testing min" {
@@ -942,7 +928,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void {
     defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
-    while (queue.popMinOrNull()) |next| {
+    while (queue.popMin()) |next| {
         if (last_removed) |last| {
             try expect(last <= next);
         }
@@ -972,7 +958,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void {
     defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
-    while (queue.popMaxOrNull()) |next| {
+    while (queue.popMax()) |next| {
         if (last_removed) |last| {
             try expect(last >= next);
         }
@@ -1006,13 +992,13 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
     var i: usize = 0;
     while (i < queue_size) : (i += 1) {
         if (i % 2 == 0) {
-            const next = queue.popMin();
+            const next = queue.popMin().?;
             if (last_min) |last| {
                 try expect(last <= next);
             }
             last_min = next;
         } else {
-            const next = queue.popMax();
+            const next = queue.popMax().?;
             if (last_max) |last| {
                 try expect(last >= next);
             }
-- 
2.54.0


From 293710c1cd3160787e882113014c022ce665d16d Mon Sep 17 00:00:00 2001
From: Saurabh Mishra <saurabh.m@proton.me>
Date: Wed, 18 Feb 2026 12:38:26 -0800
Subject: [PATCH 318/499] use `.empty` for default field values intead of
 `init()` and introduce `initContext()`

---
 lib/std/priority_dequeue.zig | 64 ++++++++++++++++++++----------------
 1 file changed, 36 insertions(+), 28 deletions(-)

diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index 53cb65d98e273618310341336f6fc8d8b1397ac8..414c9428387fff401c4d58e0e5b6827081a7b2bb 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -23,10 +23,17 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
         len: usize,
         context: Context,
 
-        /// Initialize and return a new priority dequeue.
-        pub fn init(context: Context) Self {
+        /// A priority dequeue containing no elements.
+        pub const empty: Self = .{
+            .items = &.{},
+            .len = 0,
+            .context = undefined,
+        };
+
+        /// Initialize and return a new priority dequeue with context.
+        pub fn initContext(context: Context) Self {
             return Self{
-                .items = &[_]T{},
+                .items = &.{},
                 .len = 0,
                 .context = context,
             };
@@ -451,7 +458,8 @@ const PDQ = PriorityDequeue(u32, void, lessThanComparison);
 
 test "push and pop min" {
     const gpa = std.testing.allocator;
-    var queue = PDQ.init({});
+
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 54);
@@ -480,7 +488,7 @@ test "push and pop min structs" {
             _ = context;
             return std.math.order(a.size, b.size);
         }
-    }.order).init({});
+    }.order).initContext({});
     defer queue.deinit(gpa);
 
     try queue.push(gpa, .{ .size = 54 });
@@ -501,7 +509,7 @@ test "push and pop min structs" {
 test "push and pop max" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 54);
@@ -522,7 +530,7 @@ test "push and pop max" {
 test "push and pop same min" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -543,7 +551,7 @@ test "push and pop same min" {
 test "push and pop same max" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -564,7 +572,7 @@ test "push and pop same max" {
 test "popOrNull empty" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try expect(queue.popMin() == null);
@@ -574,7 +582,7 @@ test "popOrNull empty" {
 test "edge case 3 elements" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 9);
@@ -589,7 +597,7 @@ test "edge case 3 elements" {
 test "edge case 3 elements max" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 9);
@@ -604,7 +612,7 @@ test "edge case 3 elements max" {
 test "peekMin" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try expect(queue.peekMin() == null);
@@ -620,7 +628,7 @@ test "peekMin" {
 test "peekMax" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try expect(queue.peekMin() == null);
@@ -636,7 +644,7 @@ test "peekMax" {
 test "sift up with odd indices, popMin" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -653,7 +661,7 @@ test "sift up with odd indices, popMin" {
 test "sift up with odd indices, popMax" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -670,7 +678,7 @@ test "sift up with odd indices, popMax" {
 test "pushSlice min" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -685,7 +693,7 @@ test "pushSlice min" {
 test "pushSlice max" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -742,7 +750,7 @@ test "fromOwnedSlice" {
 test "update min queue" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 55);
@@ -759,7 +767,7 @@ test "update min queue" {
 test "update same min queue" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -777,7 +785,7 @@ test "update same min queue" {
 test "update max queue" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 55);
@@ -795,7 +803,7 @@ test "update max queue" {
 test "update same max queue" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -813,7 +821,7 @@ test "update same max queue" {
 test "update after pop" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -824,7 +832,7 @@ test "update after pop" {
 test "iterator" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     var map = std.AutoHashMap(u32, void).init(testing.allocator);
     defer {
         queue.deinit(gpa);
@@ -848,7 +856,7 @@ test "iterator" {
 test "pop at index" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 3);
@@ -873,7 +881,7 @@ test "pop at index" {
 test "iterator while empty" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     var it = queue.iterator();
@@ -884,7 +892,7 @@ test "iterator while empty" {
 test "shrinkAndFree" {
     const gpa = std.testing.allocator;
 
-    var queue = PDQ.init({});
+    var queue: PDQ = .empty;
     defer queue.deinit(gpa);
 
     try queue.ensureTotalCapacity(gpa, 4);
@@ -1031,7 +1039,7 @@ test "push and pop" {
 
     const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
 
-    var queue = CPDQ.init(context[0..]);
+    var queue: CPDQ = .initContext(context[0..]);
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 0);
@@ -1060,7 +1068,7 @@ test "don't compare a value to a copy of itself" {
             all_cmps_unique = all_cmps_unique and (a != b);
             return std.math.order(a, b);
         }
-    }.uniqueLessThan).init({});
+    }.uniqueLessThan).initContext({});
     defer depq.deinit(gpa);
 
     try depq.push(gpa, 1);
-- 
2.54.0


From 5140455264347f8bf869edae71faa8848e92dabd Mon Sep 17 00:00:00 2001
From: Saurabh Mishra <saurabh.m@proton.me>
Date: Wed, 18 Feb 2026 13:24:03 -0800
Subject: [PATCH 319/499] min heap is formed with less than comparison

---
 lib/std/priority_dequeue.zig | 115 ++++++++++++++++++-----------------
 1 file changed, 59 insertions(+), 56 deletions(-)

diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index 414c9428387fff401c4d58e0e5b6827081a7b2bb..04182206c53a4a2953d4a063be838ae761287eb8 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -449,17 +449,20 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
     };
 }
 
+/// If a min heap is constructed from slice `{5, 8, 2, 9, 7, 1, 4, 4}` using this
+/// method, then the elements will be in order: {1, 2, 4, 4, 5, 7, 8, 9}
 fn lessThanComparison(context: void, a: u32, b: u32) Order {
     _ = context;
     return std.math.order(a, b);
 }
 
-const PDQ = PriorityDequeue(u32, void, lessThanComparison);
+/// Elements with lower priority will be removed first
+const MinHeap = PriorityDequeue(u32, void, lessThanComparison);
 
-test "push and pop min" {
+test "push and pop min in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 54);
@@ -506,10 +509,10 @@ test "push and pop min structs" {
     try expectEqual(@as(u32, 54), queue.popMin().?.size);
 }
 
-test "push and pop max" {
+test "push and pop max in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 54);
@@ -527,10 +530,10 @@ test "push and pop max" {
     try expectEqual(@as(u32, 7), queue.popMax());
 }
 
-test "push and pop same min" {
+test "push and pop same min in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -548,10 +551,10 @@ test "push and pop same min" {
     try expectEqual(@as(u32, 2), queue.popMin());
 }
 
-test "push and pop same max" {
+test "push and pop same max in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -569,20 +572,20 @@ test "push and pop same max" {
     try expectEqual(@as(u32, 1), queue.popMax());
 }
 
-test "popOrNull empty" {
+test "pop empty in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try expect(queue.popMin() == null);
     try expect(queue.popMax() == null);
 }
 
-test "edge case 3 elements" {
+test "edge case 3 elements popMin in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 9);
@@ -594,10 +597,10 @@ test "edge case 3 elements" {
     try expectEqual(@as(u32, 9), queue.popMin());
 }
 
-test "edge case 3 elements max" {
+test "edge case 3 elements popmax in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 9);
@@ -609,10 +612,10 @@ test "edge case 3 elements max" {
     try expectEqual(@as(u32, 2), queue.popMax());
 }
 
-test "peekMin" {
+test "peekMin in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try expect(queue.peekMin() == null);
@@ -625,10 +628,10 @@ test "peekMin" {
     try expect(queue.peekMin().? == 2);
 }
 
-test "peekMax" {
+test "peekMax in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try expect(queue.peekMin() == null);
@@ -641,10 +644,10 @@ test "peekMax" {
     try expect(queue.peekMax().? == 9);
 }
 
-test "sift up with odd indices, popMin" {
+test "sift up with odd indices and popMin in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -658,10 +661,10 @@ test "sift up with odd indices, popMin" {
     }
 }
 
-test "sift up with odd indices, popMax" {
+test "sift up with odd indices and popMax in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -675,10 +678,10 @@ test "sift up with odd indices, popMax" {
     }
 }
 
-test "pushSlice min" {
+test "pushSlice in min heap and popMin" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -690,10 +693,10 @@ test "pushSlice min" {
     }
 }
 
-test "pushSlice max" {
+test "pushSlice in min heap and popMax" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
@@ -705,26 +708,26 @@ test "pushSlice max" {
     }
 }
 
-test "fromOwnedSlice trivial case 0" {
+test "fromOwnedSlice trivial case 0 min heap" {
     const gpa = std.testing.allocator;
 
     const items = [0]u32{};
     const queue_items = try gpa.dupe(u32, &items);
 
-    var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
+    var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {});
     defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 0), queue.len);
     try expect(queue.popMin() == null);
 }
 
-test "fromOwnedSlice trivial case 1" {
+test "fromOwnedSlice trivial case 1 min heap" {
     const gpa = std.testing.allocator;
 
     const items = [1]u32{1};
     const queue_items = try gpa.dupe(u32, &items);
 
-    var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
+    var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {});
     defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 1), queue.len);
@@ -732,13 +735,13 @@ test "fromOwnedSlice trivial case 1" {
     try expect(queue.popMin() == null);
 }
 
-test "fromOwnedSlice" {
+test "fromOwnedSlice min heap" {
     const gpa = std.testing.allocator;
 
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     const queue_items = try gpa.dupe(u32, items[0..]);
 
-    var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
+    var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {});
     defer queue.deinit(gpa);
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
@@ -747,10 +750,10 @@ test "fromOwnedSlice" {
     }
 }
 
-test "update min queue" {
+test "update and popMin in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 55);
@@ -764,10 +767,10 @@ test "update min queue" {
     try expectEqual(@as(u32, 5), queue.popMin());
 }
 
-test "update same min queue" {
+test "update same element and popMin in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -782,10 +785,10 @@ test "update same min queue" {
     try expectEqual(@as(u32, 5), queue.popMin());
 }
 
-test "update max queue" {
+test "update and popMax in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 55);
@@ -800,10 +803,10 @@ test "update max queue" {
     try expectEqual(@as(u32, 1), queue.popMax());
 }
 
-test "update same max queue" {
+test "update same element and popMax in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -818,10 +821,10 @@ test "update same max queue" {
     try expectEqual(@as(u32, 1), queue.popMax());
 }
 
-test "update after pop" {
+test "update after pop in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 1);
@@ -829,10 +832,10 @@ test "update after pop" {
     try expectError(error.ElementNotFound, queue.update(1, 1));
 }
 
-test "iterator" {
+test "min heap iterator" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     var map = std.AutoHashMap(u32, void).init(testing.allocator);
     defer {
         queue.deinit(gpa);
@@ -853,10 +856,10 @@ test "iterator" {
     try expectEqual(@as(usize, 0), map.count());
 }
 
-test "pop at index" {
+test "pop at index in min heap" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 3);
@@ -878,10 +881,10 @@ test "pop at index" {
     try expectEqual(queue.popMin(), null);
 }
 
-test "iterator while empty" {
+test "min heap iterator while empty" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     var it = queue.iterator();
@@ -889,10 +892,10 @@ test "iterator while empty" {
     try expectEqual(it.next(), null);
 }
 
-test "shrinkAndFree" {
+test "min heap shrinkAndFree" {
     const gpa = std.testing.allocator;
 
-    var queue: PDQ = .empty;
+    var queue: MinHeap = .empty;
     defer queue.deinit(gpa);
 
     try queue.ensureTotalCapacity(gpa, 4);
@@ -932,7 +935,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void {
 
     const items = try generateRandomSlice(gpa, rng, queue_size);
 
-    var queue = PDQ.fromOwnedSlice(items, {});
+    var queue: MinHeap = .fromOwnedSlice(items, {});
     defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
@@ -962,7 +965,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void {
 
     const items = try generateRandomSlice(gpa, rng, queue_size);
 
-    var queue = PDQ.fromOwnedSlice(items, {});
+    var queue: MinHeap = .fromOwnedSlice(items, {});
     defer queue.deinit(gpa);
 
     var last_removed: ?u32 = null;
@@ -992,7 +995,7 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
 
     const items = try generateRandomSlice(gpa, rng, queue_size);
 
-    var queue = PDQ.fromOwnedSlice(items, {});
+    var queue: MinHeap = .fromOwnedSlice(items, {});
     defer queue.deinit(gpa);
 
     var last_min: ?u32 = null;
@@ -1032,14 +1035,14 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order {
     return std.math.order(context[a], context[b]);
 }
 
-const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison);
+const MinHeapWithContext = PriorityDequeue(usize, []const u32, contextLessThanComparison);
 
 test "push and pop" {
     const gpa = std.testing.allocator;
 
     const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
 
-    var queue: CPDQ = .initContext(context[0..]);
+    var queue: MinHeapWithContext = .initContext(context[0..]);
     defer queue.deinit(gpa);
 
     try queue.push(gpa, 0);
-- 
2.54.0


From 1e26d885d31d34a00949f28250d6c482e9b38f57 Mon Sep 17 00:00:00 2001
From: Yusuf Bham <git@fiftysix.dev>
Date: Wed, 18 Feb 2026 20:04:18 -0500
Subject: [PATCH 320/499] uefi(guid): don't use std.mem.asBytes in format

Using std.mem.asBytes causes a panic when format
is called as slices can no longer have hex options
when formatting, so instead just print the ints.
---
 lib/std/os/uefi.zig | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/std/os/uefi.zig b/lib/std/os/uefi.zig
index d8f08911b3eb595a8b29ae8546a5f8dd757e3eb3..f8abb8d98974d62d060ad490fb98392cc90df570 100644
--- a/lib/std/os/uefi.zig
+++ b/lib/std/os/uefi.zig
@@ -112,12 +112,12 @@ pub const Guid = extern struct {
         const time_high_and_version = @byteSwap(self.time_high_and_version);
 
         return writer.print("{x:0>8}-{x:0>4}-{x:0>4}-{x:0>2}{x:0>2}-{x}", .{
-            std.mem.asBytes(&time_low),
-            std.mem.asBytes(&time_mid),
-            std.mem.asBytes(&time_high_and_version),
-            std.mem.asBytes(&self.clock_seq_high_and_reserved),
-            std.mem.asBytes(&self.clock_seq_low),
-            std.mem.asBytes(&self.node),
+            time_low,
+            time_mid,
+            time_high_and_version,
+            self.clock_seq_high_and_reserved,
+            self.clock_seq_low,
+            self.node,
         });
     }
 
-- 
2.54.0


From 7dddcd043f23fe05f3333ec10a5592f385a46e49 Mon Sep 17 00:00:00 2001
From: Lukas Lalinsky <lukas@lalinsky.com>
Date: Thu, 19 Feb 2026 21:24:36 +0100
Subject: [PATCH 321/499] Add `lr` and `sp` clobbers for arm/thumb

---
 lib/std/builtin/assembly.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/std/builtin/assembly.zig b/lib/std/builtin/assembly.zig
index 7fa02362a1bf5ae6964ee15d4d03d5bd7fdddcd1..0dd13c5bff9a6928d6958f5e108c527b7dbb343f 100644
--- a/lib/std/builtin/assembly.zig
+++ b/lib/std/builtin/assembly.zig
@@ -555,6 +555,8 @@ pub const Clobbers = switch (@import("builtin").cpu.arch) {
         r13: bool = false,
         r14: bool = false,
 
+        lr: bool = false,
+        sp: bool = false,
         fpscr: bool = false,
         vpr: bool = false,
 
-- 
2.54.0


From e95132476dfd26b28b55f7656f03dd1ec338b509 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 20 Feb 2026 01:27:54 +0100
Subject: [PATCH 322/499] std.os.linux: fix the mmap2 unit for various
 architectures

closes https://codeberg.org/ziglang/zig/issues/31033
---
 lib/std/os/linux.zig | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 8cce6c1dae8d06646450d865a8d6b932f6254710..cbe085a3af73ded631610881042cf0ed43844767 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1118,6 +1118,14 @@ pub fn pivot_root(new_root: [*:0]const u8, put_old: [*:0]const u8) usize {
     return syscall2(.pivot_root, @intFromPtr(new_root), @intFromPtr(put_old));
 }
 
+fn mmap2Unit() u64 {
+    return switch (native_arch) {
+        .arc, .arceb, .m68k => std.heap.pageSize(),
+        .or1k => 8 << 10,
+        else => 4 << 10,
+    };
+}
+
 pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, offset: i64) usize {
     if (@hasField(SYS, "mmap2")) {
         return syscall6(
@@ -1127,7 +1135,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off
             @as(u32, @bitCast(prot)),
             @as(u32, @bitCast(flags)),
             @bitCast(@as(isize, fd)),
-            @truncate(@as(u64, @bitCast(offset)) / std.heap.pageSize()),
+            @truncate(@as(u64, @bitCast(offset)) / mmap2Unit()),
         );
     } else {
         // The s390x mmap() syscall existed before Linux supported syscalls with 5+ parameters, so
-- 
2.54.0


From 8259d8d63145260bff4faf1d4d48b28d4061dc5a Mon Sep 17 00:00:00 2001
From: David Rubin <david@vortan.dev>
Date: Tue, 17 Feb 2026 13:58:26 -0800
Subject: [PATCH 323/499] minimal

---
 lib/std/Io/Uring.zig |  34 ++++++++++++
 lib/std/Io/fiber.zig | 124 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 157 insertions(+), 1 deletion(-)

diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index a2c4f6e5ec9a15343fb428792da27c883d48c3df..12c715c205b4920a6dc6adb5a72a040dab1d11fc 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -872,6 +872,11 @@ pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !v
                 .fp = @intFromPtr(ev),
                 .pc = @intFromPtr(&mainIdleEntry),
             },
+            .riscv64 => .{
+                .sp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
+                .fp = @intFromPtr(ev),
+                .pc = @intFromPtr(&mainIdleEntry),
+            },
             .x86_64 => .{
                 .rsp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
                 .rbp = @intFromPtr(ev),
@@ -1109,6 +1114,13 @@ fn mainIdleEntry() callconv(.naked) void {
             :
             : [mainIdle] "X" (&mainIdle),
         ),
+        .riscv64 => asm volatile (
+            \\ mv a0, fp
+            \\ mv fp, zero
+            \\ tail %[mainIdle]@plt
+            :
+            : [mainIdle] "X" (&mainIdle),
+        ),
         .x86_64 => asm volatile (
             \\ movq %%rbp, %%rdi
             \\ xor %%ebp, %%ebp
@@ -1383,6 +1395,12 @@ const AsyncClosure = struct {
                 :
                 : [call] "X" (&call),
             ),
+            .riscv64 => asm volatile (
+                \\ mv a0, sp
+                \\ tail %[call]@plt
+                :
+                : [call] "X" (&call),
+            ),
             .x86_64 => asm volatile (
                 \\ leaq 8(%%rsp), %%rdi
                 \\ jmp %[call:P]
@@ -1448,6 +1466,11 @@ fn concurrent(
                 .fp = 0,
                 .pc = @intFromPtr(&AsyncClosure.entry),
             },
+            .riscv64 => .{
+                .sp = @intFromPtr(closure),
+                .fp = 0,
+                .pc = @intFromPtr(&AsyncClosure.entry),
+            },
             .x86_64 => .{
                 .rsp = @intFromPtr(closure) - 8,
                 .rbp = 0,
@@ -1737,6 +1760,12 @@ const Group = struct {
                     :
                     : [call] "X" (&call),
                 ),
+                .riscv64 => asm volatile (
+                    \\ mv a0, sp
+                    \\ tail %[call]@plt
+                    :
+                    : [call] "X" (&call),
+                ),
                 .x86_64 => asm volatile (
                     \\ leaq 8(%%rsp), %%rdi
                     \\ jmp %[call:P]
@@ -1821,6 +1850,11 @@ fn groupConcurrent(
                 .fp = 0,
                 .pc = @intFromPtr(&Group.AsyncClosure.entry),
             },
+            .riscv64 => .{
+                .sp = @intFromPtr(closure),
+                .fp = 0,
+                .pc = @intFromPtr(&Group.AsyncClosure.entry),
+            },
             .x86_64 => .{
                 .rsp = @intFromPtr(closure) - 8,
                 .rbp = 0,
diff --git a/lib/std/Io/fiber.zig b/lib/std/Io/fiber.zig
index bc33a3a97eeb8390110864488e9f4e776c1a11ae..1f2e4fbf4c9f76d36a26d36249778199213750f2 100644
--- a/lib/std/Io/fiber.zig
+++ b/lib/std/Io/fiber.zig
@@ -1,5 +1,5 @@
 pub const supported = switch (builtin.cpu.arch) {
-    .aarch64, .x86_64 => true,
+    .aarch64, .riscv64, .x86_64 => true,
     else => false,
 };
 
@@ -10,6 +10,11 @@ pub const Context = switch (builtin.cpu.arch) {
         fp: u64,
         pc: u64,
     },
+    .riscv64 => extern struct {
+        sp: u64,
+        fp: u64,
+        pc: u64,
+    },
     .x86_64 => extern struct {
         rsp: u64,
         rbp: u64,
@@ -119,6 +124,123 @@ pub inline fn contextSwitch(s: *const Switch) *const Switch {
               .ffr = true,
               .memory = true,
             }),
+        .riscv64 => asm volatile (
+            \\ ld a0, 0(a1)
+            \\ ld a2, 8(a1)
+            \\ lla a3, 0f
+            \\ sd sp, 0(a0)
+            \\ sd fp, 8(a0)
+            \\ sd a3, 16(a0)
+            \\ ld sp, 0(a2)
+            \\ ld fp, 8(a2)
+            \\ ld a3, 16(a2)
+            \\ jr a3
+            \\0:
+            : [received_message] "={a1}" (-> *const Switch),
+            : [message_to_send] "{a1}" (s),
+            : .{
+              .x1 = true,
+              .x3 = true,
+              .x4 = true,
+              .x5 = true,
+              .x6 = true,
+              .x7 = true,
+              .x9 = true,
+              .x10 = true,
+              .x11 = true,
+              .x12 = true,
+              .x13 = true,
+              .x14 = true,
+              .x15 = true,
+              .x16 = true,
+              .x17 = true,
+              .x18 = true,
+              .x19 = true,
+              .x20 = true,
+              .x21 = true,
+              .x22 = true,
+              .x23 = true,
+              .x24 = true,
+              .x25 = true,
+              .x26 = true,
+              .x27 = true,
+              .x28 = true,
+              .x29 = true,
+              .x30 = true,
+              .x31 = true,
+              .f0 = true,
+              .f1 = true,
+              .f2 = true,
+              .f3 = true,
+              .f4 = true,
+              .f5 = true,
+              .f6 = true,
+              .f7 = true,
+              .f8 = true,
+              .f9 = true,
+              .f10 = true,
+              .f11 = true,
+              .f12 = true,
+              .f13 = true,
+              .f14 = true,
+              .f15 = true,
+              .f16 = true,
+              .f17 = true,
+              .f18 = true,
+              .f19 = true,
+              .f20 = true,
+              .f21 = true,
+              .f22 = true,
+              .f23 = true,
+              .f24 = true,
+              .f25 = true,
+              .f26 = true,
+              .f27 = true,
+              .f28 = true,
+              .f29 = true,
+              .f30 = true,
+              .f31 = true,
+              .v0 = true,
+              .v1 = true,
+              .v2 = true,
+              .v3 = true,
+              .v4 = true,
+              .v5 = true,
+              .v6 = true,
+              .v7 = true,
+              .v8 = true,
+              .v9 = true,
+              .v10 = true,
+              .v11 = true,
+              .v12 = true,
+              .v13 = true,
+              .v14 = true,
+              .v15 = true,
+              .v16 = true,
+              .v17 = true,
+              .v18 = true,
+              .v19 = true,
+              .v20 = true,
+              .v21 = true,
+              .v22 = true,
+              .v23 = true,
+              .v24 = true,
+              .v25 = true,
+              .v26 = true,
+              .v27 = true,
+              .v28 = true,
+              .v29 = true,
+              .v30 = true,
+              .v31 = true,
+              .vtype = true,
+              .vl = true,
+              .vxsat = true,
+              .vxrm = true,
+              .vcsr = true,
+              .fflags = true,
+              .frm = true,
+              .memory = true,
+            }),
         .x86_64 => asm volatile (
             \\ movq 0(%%rsi), %%rax
             \\ movq 8(%%rsi), %%rcx
-- 
2.54.0


From 14d06330e0b85dbf9dbd2023d58d2af75a150bcc Mon Sep 17 00:00:00 2001
From: John Benediktsson <mrjbq7@gmail.com>
Date: Thu, 19 Feb 2026 11:40:26 -0800
Subject: [PATCH 324/499] std.c: fix SO_LINGER on darwin and define
 SO_LINGER_SEC

---
 lib/std/c.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index f4bdf3969c08e90969862b18a1c5ca6fcc970229..653e10576d5e8cc7860e5b7e15f251041a4902d2 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -6679,7 +6679,7 @@ pub const SO = switch (native_os) {
         pub const DONTROUTE = 0x0010;
         pub const BROADCAST = 0x0020;
         pub const USELOOPBACK = 0x0040;
-        pub const LINGER = 0x1080;
+        pub const LINGER = 0x0080;
         pub const OOBINLINE = 0x0100;
         pub const REUSEPORT = 0x0200;
         pub const ACCEPTFILTER = 0x1000;
@@ -6698,6 +6698,7 @@ pub const SO = switch (native_os) {
         pub const NOADDRERR = 0x1023;
         pub const NWRITE = 0x1024;
         pub const REUSESHAREUID = 0x1025;
+        pub const LINGER_SEC = 0x1080;
     },
     .freebsd => struct {
         pub const DEBUG = 0x00000001;
-- 
2.54.0


From 54eb03cbf61a5c5fdee29c0f45cca824e13d6af8 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 20 Feb 2026 16:42:37 -0800
Subject: [PATCH 325/499] std.Io.Select: remove "outstanding" field

it is not fundamentally part of this abstraction
---
 lib/std/Io.zig                    | 8 --------
 lib/std/crypto/kangarootwelve.zig | 5 ++++-
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index ff58bb400e49697a6557ce45ce451bad72a76973..6d8fbc45365ed90ed70e65141390dfc8b9b58240 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1178,7 +1178,6 @@ pub fn Select(comptime U: type) type {
         io: Io,
         group: Group,
         queue: Queue(U),
-        outstanding: usize,
 
         const S = @This();
 
@@ -1191,7 +1190,6 @@ pub fn Select(comptime U: type) type {
                 .io = io,
                 .queue = .init(buffer),
                 .group = .init,
-                .outstanding = 0,
             };
         }
 
@@ -1235,7 +1233,6 @@ pub fn Select(comptime U: type) type {
                 }
             };
             const context: Context = .{ .select = s, .args = args };
-            _ = @atomicRmw(usize, &s.outstanding, .Add, 1, .monotonic);
             s.io.vtable.groupAsync(s.io.userdata, &s.group, @ptrCast(&context), .of(Context), Context.start);
         }
 
@@ -1276,16 +1273,12 @@ pub fn Select(comptime U: type) type {
             };
             const context: Context = .{ .select = s, .args = args };
             try s.io.vtable.groupConcurrent(s.io.userdata, &s.group, @ptrCast(&context), .of(Context), Context.start);
-            _ = @atomicRmw(usize, &s.outstanding, .Add, 1, .monotonic);
         }
 
         /// Blocks until another task of the select finishes.
         ///
-        /// Asserts there is at least one more `outstanding` task.
-        ///
         /// Not threadsafe.
         pub fn await(s: *S) Cancelable!U {
-            s.outstanding -= 1;
             return s.queue.getOne(s.io) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 error.Closed => unreachable,
@@ -1301,7 +1294,6 @@ pub fn Select(comptime U: type) type {
         ///
         /// Idempotent. Not threadsafe.
         pub fn cancel(s: *S) void {
-            s.outstanding = 0;
             s.group.cancel(s.io);
         }
     };
diff --git a/lib/std/crypto/kangarootwelve.zig b/lib/std/crypto/kangarootwelve.zig
index 65d053ec5dc8b139c48f082b079284140d28b269..c072857359872bc24b120e300da58d0778243e25 100644
--- a/lib/std/crypto/kangarootwelve.zig
+++ b/lib/std/crypto/kangarootwelve.zig
@@ -883,6 +883,7 @@ fn ktMultiThreaded(
         defer allocator.free(pending_cv_buf);
         var pending_cv_lens: [256]usize = .{0} ** 256;
 
+        var select_outstanding: usize = 0;
         var select: Select = .init(io, select_buf);
         defer select.cancel();
         var batches_spawned: usize = 0;
@@ -894,6 +895,7 @@ fn ktMultiThreaded(
                 const batch_leaves = @min(leaves_per_batch, full_leaves - batch_start_leaf);
                 const start_offset = chunk_size + batch_start_leaf * chunk_size;
 
+                select_outstanding += 1;
                 select.async(.batch, SelectLeafContext(Variant).process, .{SelectLeafContext(Variant){
                     .view = view,
                     .batch_idx = batches_spawned,
@@ -903,6 +905,7 @@ fn ktMultiThreaded(
                 batches_spawned += 1;
             }
 
+            select_outstanding -= 1;
             const result = try select.await();
             const batch = result.batch;
             const slot = batch.batch_idx % max_concurrent;
@@ -927,7 +930,7 @@ fn ktMultiThreaded(
             }
         }
 
-        assert(select.outstanding == 0);
+        assert(select_outstanding == 0);
     }
 
     if (has_partial_leaf) {
-- 
2.54.0


From f9053f38e5ca29c23d2328ed06293727cd1fe8d4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 20 Feb 2026 16:57:48 -0800
Subject: [PATCH 326/499] std.Io.Select: add documentation

---
 lib/std/Io.zig | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 6d8fbc45365ed90ed70e65141390dfc8b9b58240..6eea9789b4f985751583caa0460347bdb46b4970 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1173,10 +1173,19 @@ pub fn checkCancel(io: Io) Cancelable!void {
     return io.vtable.checkCancel(io.userdata);
 }
 
+/// Executes tasks together, providing a mechanism to wait until one or more
+/// tasks complete. Similar to `Batch` but operates at the higher level task
+/// abstraction layer rather than lower level `Operation` abstraction layer.
+///
+/// The provided tagged union will be used as the return type of the await
+/// function. When calling async or concurrent, one specifies which union field
+/// the called function's result will be placed into upon completion.
 pub fn Select(comptime U: type) type {
     return struct {
         io: Io,
         group: Group,
+        /// The queue is never closed because there may be live resources
+        /// inserted into it which would otherwise leak.
         queue: Queue(U),
 
         const S = @This();
-- 
2.54.0


From 311bba4af0985241601fed4cf6aba2495fd2912f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 20 Feb 2026 17:28:33 -0800
Subject: [PATCH 327/499] std.Io.Select: add awaitMany function and unit test

and fix documentation. these functions are in fact threadsafe.
---
 lib/std/Io.zig      | 57 ++++++++++++++++++++++++++++-----------------
 lib/std/Io/test.zig | 38 ++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+), 22 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 6eea9789b4f985751583caa0460347bdb46b4970..cbf1a248470373f6c901c744342b2b5662fee10b 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1286,7 +1286,7 @@ pub fn Select(comptime U: type) type {
 
         /// Blocks until another task of the select finishes.
         ///
-        /// Not threadsafe.
+        /// Threadsafe.
         pub fn await(s: *S) Cancelable!U {
             return s.queue.getOne(s.io) catch |err| switch (err) {
                 error.Canceled => |e| return e,
@@ -1294,6 +1294,19 @@ pub fn Select(comptime U: type) type {
             };
         }
 
+        /// Blocks until at least `min` number of results have been copied
+        /// into `buffer`.
+        ///
+        /// Asserts that `buffer.len >= min`.
+        ///
+        /// Threadsafe.
+        pub fn awaitMany(s: *S, buffer: []U, min: usize) Cancelable!usize {
+            return s.queue.get(s.io, buffer, min) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                error.Closed => unreachable,
+            };
+        }
+
         /// Equivalent to `await` but requests cancelation on all remaining
         /// tasks owned by the select.
         ///
@@ -1301,7 +1314,7 @@ pub fn Select(comptime U: type) type {
         ///
         /// It is illegal to call `await` after this.
         ///
-        /// Idempotent. Not threadsafe.
+        /// Idempotent. Threadsafe.
         pub fn cancel(s: *S) void {
             s.group.cancel(s.io);
         }
@@ -1732,7 +1745,7 @@ pub const TypeErasedQueue = struct {
         return if (slice.len > 0) slice else null;
     }
 
-    fn putLocked(q: *TypeErasedQueue, io: Io, elements: []const u8, target: usize, uncancelable: bool) (QueueClosedError || Cancelable)!usize {
+    fn putLocked(q: *TypeErasedQueue, io: Io, elements: []const u8, min: usize, uncancelable: bool) (QueueClosedError || Cancelable)!usize {
         // A closed queue cannot be added to, even if there is space in the buffer.
         if (q.closed) return error.Closed;
 
@@ -1768,12 +1781,12 @@ pub const TypeErasedQueue = struct {
             if (n == elements.len) return elements.len;
         }
 
-        // Don't block if we hit the target.
-        if (n >= target) return n;
+        // Don't block if we hit the min.
+        if (n >= min) return n;
 
         var pending: Put = .{
             .remaining = elements[n..],
-            .needed = target - n,
+            .needed = min - n,
             .condition = .init,
             .node = .{},
         };
@@ -1832,7 +1845,7 @@ pub const TypeErasedQueue = struct {
         return if (slice.len > 0) slice else null;
     }
 
-    fn getLocked(q: *TypeErasedQueue, io: Io, buffer: []u8, target: usize, uncancelable: bool) (QueueClosedError || Cancelable)!usize {
+    fn getLocked(q: *TypeErasedQueue, io: Io, buffer: []u8, min: usize, uncancelable: bool) (QueueClosedError || Cancelable)!usize {
         // The ring buffer gets first priority, then data should come from any
         // queued putters, then finally the ring buffer should be filled with
         // data from putters so they can be resumed.
@@ -1878,15 +1891,15 @@ pub const TypeErasedQueue = struct {
         // No need to call `fillRingBufferFromPutters` from this point onwards,
         // because we emptied the ring buffer *and* the putter queue!
 
-        // Don't block if we hit the target or if the queue is closed. Return how
+        // Don't block if we hit the min or if the queue is closed. Return how
         // many elements we could get immediately, unless the queue was closed and
         // empty, in which case report `error.Closed`.
         if (n == 0 and q.closed) return error.Closed;
-        if (n >= target or q.closed) return n;
+        if (n >= min or q.closed) return n;
 
         var pending: Get = .{
             .remaining = buffer[n..],
-            .needed = target - n,
+            .needed = min - n,
             .condition = .init,
             .node = .{},
         };
@@ -1962,7 +1975,7 @@ pub fn Queue(Elem: type) type {
         /// there is insufficient capacity. Returns when any one of the
         /// following conditions is satisfied:
         ///
-        /// * At least `target` elements have been added to the queue
+        /// * At least `min` elements have been added to the queue
         /// * The queue is closed
         /// * The current task is canceled
         ///
@@ -1971,16 +1984,16 @@ pub fn Queue(Elem: type) type {
         ///
         /// If the queue is closed or the task is canceled, but some items were
         /// already added before the closure or cancelation, then `put` may
-        /// return a number lower than `target`, in which case future calls are
+        /// return a number lower than `min`, in which case future calls are
         /// guaranteed to return `error.Canceled` or `error.Closed`.
         ///
-        /// A return value of 0 is only possible if `target` is 0, in which case
+        /// A return value of 0 is only possible if `min` is 0, in which case
         /// the call is guaranteed to queue as many of `elements` as is possible
         /// *without* blocking.
         ///
-        /// Asserts that `elements.len >= target`.
-        pub fn put(q: *@This(), io: Io, elements: []const Elem, target: usize) (QueueClosedError || Cancelable)!usize {
-            return @divExact(try q.type_erased.put(io, @ptrCast(elements), target * @sizeOf(Elem)), @sizeOf(Elem));
+        /// Asserts that `elements.len >= min`.
+        pub fn put(q: *@This(), io: Io, elements: []const Elem, min: usize) (QueueClosedError || Cancelable)!usize {
+            return @divExact(try q.type_erased.put(io, @ptrCast(elements), min * @sizeOf(Elem)), @sizeOf(Elem));
         }
 
         /// Same as `put` but blocks until all elements have been added to the queue.
@@ -2019,7 +2032,7 @@ pub fn Queue(Elem: type) type {
         /// if there are insufficient elements currently in the queue. Returns when
         /// any one of the following conditions is satisfied:
         ///
-        /// * At least `target` elements have been received from the queue
+        /// * At least `min` elements have been received from the queue
         /// * The queue is closed and contains no buffered elements
         /// * The current task is canceled
         ///
@@ -2028,16 +2041,16 @@ pub fn Queue(Elem: type) type {
         ///
         /// If the queue is closed or the task is canceled, but some items were
         /// already received before the closure or cancelation, then `get` may
-        /// return a number lower than `target`, in which case future calls are
+        /// return a number lower than `min`, in which case future calls are
         /// guaranteed to return `error.Canceled` or `error.Closed`.
         ///
-        /// A return value of 0 is only possible if `target` is 0, in which case
+        /// A return value of 0 is only possible if `min` is 0, in which case
         /// the call is guaranteed to fill as much of `buffer` as is possible
         /// *without* blocking.
         ///
-        /// Asserts that `buffer.len >= target`.
-        pub fn get(q: *@This(), io: Io, buffer: []Elem, target: usize) (QueueClosedError || Cancelable)!usize {
-            return @divExact(try q.type_erased.get(io, @ptrCast(buffer), target * @sizeOf(Elem)), @sizeOf(Elem));
+        /// Asserts that `buffer.len >= min`.
+        pub fn get(q: *@This(), io: Io, buffer: []Elem, min: usize) (QueueClosedError || Cancelable)!usize {
+            return @divExact(try q.type_erased.get(io, @ptrCast(buffer), min * @sizeOf(Elem)), @sizeOf(Elem));
         }
 
         /// Same as `get`, except does not introduce a cancelation point.
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index d13cc802ceb236c399abe3f762c6040c727ef769..4fc041c749503074914b0f4b65aea48e8359e3fd 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -810,3 +810,41 @@ test "Event broadcast" {
 
     try ctx.run();
 }
+
+test "Select" {
+    const S = struct {
+        fn foo() bool {
+            return true;
+        }
+
+        fn bar(io: Io) Io.Cancelable!void {
+            try io.sleep(.fromSeconds(300), .awake);
+        }
+    };
+
+    const io = testing.io;
+
+    const U = union(enum) {
+        foo: bool,
+        bar: Io.Cancelable!void,
+    };
+    var buffer: [4]U = undefined;
+    var select: Io.Select(U) = .init(io, &buffer);
+    defer select.cancel();
+
+    select.async(.foo, S.foo, .{});
+    select.concurrent(.bar, S.bar, .{io}) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => return error.SkipZigTest,
+    };
+
+    switch (try select.await()) {
+        .foo => {},
+        .bar => return error.TestFailed, // should be sleeping
+    }
+    select.async(.foo, S.foo, .{});
+    select.async(.foo, S.foo, .{});
+
+    var finished_buffer: [3]U = undefined;
+    const finished = finished_buffer[0..try select.awaitMany(&finished_buffer, 2)];
+    try testing.expectEqualSlices(U, &.{ .{ .foo = true }, .{ .foo = true } }, finished);
+}
-- 
2.54.0


From c8dd05030519fc52dd457531f6b2654e1ad129b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 18 Feb 2026 04:54:04 +0100
Subject: [PATCH 328/499] std.heap.PageAllocator: hint mmaps in the same
 direction as stack growth

The old logic was fine for targets where the stack grows up (so, literally just
hppa), but problematic on targets where it grows down, because we could hint
that we wanted an allocation to happen in an area of the address space that the
kernel expects to be able to expand the stack into. The kernel is happy to
satisfy such a hint despite the obvious problems this leads to later down the
road.

Co-authored-by: rpkak <rpkak@noreply.codeberg.org>
---
 lib/std/heap.zig               |  3 --
 lib/std/heap/PageAllocator.zig | 72 +++++++++++++++++++++++++++-------
 2 files changed, 58 insertions(+), 17 deletions(-)

diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index 562d0846efde69bf0d58b926896b6fc8100b3db2..bf28555e104879e029bb89016426d1eb60338470 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -41,9 +41,6 @@ pub const MemoryPoolExtra = memory_pool.Extra;
 /// Deprecated; use `memory_pool.Options`.
 pub const MemoryPoolOptions = memory_pool.Options;
 
-/// TODO Utilize this on Windows.
-pub var next_mmap_addr_hint: ?[*]align(page_size_min) u8 = null;
-
 /// comptime-known minimum page size of the target.
 ///
 /// All pointers from `mmap` or `NtAllocateVirtualMemory` are aligned to at least
diff --git a/lib/std/heap/PageAllocator.zig b/lib/std/heap/PageAllocator.zig
index bed9be54493cd11a01458b3a53eceacdb4cfaa3d..66abe7d4daae846810055019a264d0015e988071 100644
--- a/lib/std/heap/PageAllocator.zig
+++ b/lib/std/heap/PageAllocator.zig
@@ -19,6 +19,28 @@ pub const vtable: Allocator.VTable = .{
     .free = free,
 };
 
+/// Hhinting is disabled on operating systems that make an effort to not reuse
+/// mappings. For example, OpenBSD aggressively randomizes addresses of mappings
+/// that don't provide a hint (for security reasons, but it serves our needs
+/// too).
+const enable_hints = switch (builtin.target.os.tag) {
+    .openbsd => false,
+    else => true,
+};
+
+/// On operating systems that don't immediately map in the whole stack, we need
+/// to be careful to not hint into the pages after the stack guard gap, which
+/// the stack will expand into. The easiest way to avoid that is to hint in the
+/// same direction as stack growth.
+const stack_direction = builtin.target.stackGrowth();
+
+/// When hinting upwards, this points to the next page that we hope to allocate
+/// at; when hinting downwards, this points to the beginning of the last
+/// successful allocation.
+///
+/// TODO: Utilize this on Windows.
+var addr_hint: ?[*]align(page_size_min) u8 = null;
+
 pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
     const page_size = std.heap.pageSize();
     if (n >= maxInt(usize) - page_size) return null;
@@ -41,7 +63,7 @@ pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
         }
 
         const overalloc_len = n + alignment_bytes - page_size;
-        const aligned_len = mem.alignForward(usize, n, page_size);
+        const page_aligned_len = mem.alignForward(usize, n, page_size);
 
         base_addr = null;
         size = overalloc_len;
@@ -60,7 +82,7 @@ pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
             _ = ntdll.NtFreeVirtualMemory(current_process, @ptrCast(&prefix_base), &prefix_size_param, .{ .RELEASE = true, .PRESERVE_PLACEHOLDER = true });
         }
 
-        const suffix_start = aligned_addr + aligned_len;
+        const suffix_start = aligned_addr + page_aligned_len;
         const suffix_size = (placeholder_addr + overalloc_len) - suffix_start;
         if (suffix_size > 0) {
             var suffix_base = @as(?*anyopaque, @ptrFromInt(suffix_start));
@@ -69,7 +91,7 @@ pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
         }
 
         base_addr = @ptrFromInt(aligned_addr);
-        size = aligned_len;
+        size = page_aligned_len;
 
         status = ntdll.NtAllocateVirtualMemory(current_process, @ptrCast(&base_addr), 0, &size, .{ .COMMIT = true }, .{ .READWRITE = true });
 
@@ -78,20 +100,34 @@ pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
         }
 
         base_addr = @as(?*anyopaque, @ptrFromInt(aligned_addr));
-        size = aligned_len;
+        size = page_aligned_len;
         _ = ntdll.NtFreeVirtualMemory(current_process, @ptrCast(&base_addr), &size, .{ .RELEASE = true });
 
         return null;
     }
 
-    const aligned_len = mem.alignForward(usize, n, page_size);
+    const page_aligned_len = mem.alignForward(usize, n, page_size);
     const max_drop_len = alignment_bytes -| page_size;
-    const overalloc_len = aligned_len + max_drop_len;
-    const maybe_unaligned_hint = @atomicLoad(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, .unordered);
+    const overalloc_len = page_aligned_len + max_drop_len;
 
-    // Aligning hint does not use mem.alignPointer, because it is slow.
-    // Aligning hint does not use mem.alignForward, because it asserts that there will be no overflow.
-    const hint: ?[*]align(page_size_min) u8 = @ptrFromInt(((@intFromPtr(maybe_unaligned_hint)) +% (alignment_bytes - 1)) & ~(alignment_bytes - 1));
+    const maybe_unaligned_hint, const hint = blk: {
+        if (!enable_hints) break :blk .{ null, null };
+
+        const maybe_unaligned_hint = @atomicLoad(@TypeOf(addr_hint), &addr_hint, .unordered);
+
+        // For the very first mmap, let the kernel pick a good starting address;
+        // we'll begin doing our hinting from there.
+        if (maybe_unaligned_hint == null) break :blk .{ null, null };
+
+        // Aligning hint does not use mem.alignPointer, because it is slow.
+        // Aligning hint does not use mem.alignForward, because it asserts that there will be no overflow.
+        const hint: ?[*]align(page_size_min) u8 = @ptrFromInt(switch (stack_direction) {
+            .down => ((@intFromPtr(maybe_unaligned_hint) -% page_aligned_len) & ~(alignment_bytes - 1)) -% max_drop_len,
+            .up => (@intFromPtr(maybe_unaligned_hint) +% (alignment_bytes - 1)) & ~(alignment_bytes - 1),
+        });
+
+        break :blk .{ maybe_unaligned_hint, hint };
+    };
 
     const slice = posix.mmap(
         hint,
@@ -101,16 +137,24 @@ pub fn map(n: usize, alignment: Alignment) ?[*]u8 {
         -1,
         0,
     ) catch return null;
-    const result_ptr = mem.alignPointer(slice.ptr, alignment_bytes) orelse return null;
+    const result_ptr = mem.alignPointer(slice.ptr, alignment_bytes).?;
+
     // Unmap the extra bytes that were only requested in order to guarantee
     // that the range of memory we were provided had a proper alignment in it
     // somewhere. The extra bytes could be at the beginning, or end, or both.
     const drop_len = result_ptr - slice.ptr;
     if (drop_len != 0) posix.munmap(slice[0..drop_len]);
     const remaining_len = overalloc_len - drop_len;
-    if (remaining_len > aligned_len) posix.munmap(@alignCast(result_ptr[aligned_len..remaining_len]));
-    const new_hint: [*]align(page_size_min) u8 = @alignCast(result_ptr + aligned_len);
-    _ = @cmpxchgStrong(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, maybe_unaligned_hint, new_hint, .monotonic, .monotonic);
+    if (remaining_len > page_aligned_len) posix.munmap(@alignCast(result_ptr[page_aligned_len..remaining_len]));
+
+    if (enable_hints) {
+        const new_hint: [*]align(page_size_min) u8 = @alignCast(result_ptr + switch (stack_direction) {
+            .up => page_aligned_len,
+            .down => 0,
+        });
+        _ = @cmpxchgStrong(@TypeOf(addr_hint), &addr_hint, maybe_unaligned_hint, new_hint, .monotonic, .monotonic);
+    }
+
     return result_ptr;
 }
 
-- 
2.54.0


From a9d18c4a0c2be3d5e7dcedbedc32a9998b1e5515 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 18 Feb 2026 14:51:59 +0100
Subject: [PATCH 329/499] std.heap.PageAllocator: avoid mremaps which may
 reserve potential stack space

Linux's approach to mapping the main thread's stack is quite odd: it essentially
tries to select an mmap address (assuming unhinted mmap calls) which do not
cover the region of virtual address space into which the stack *would* grow
(based on the stack rlimit), but it doesn't actually *prevent* those pages from
being mapped. It also doesn't try particularly hard: it's been observed that the
first (unhinted) mmap call in a simple application is usually put at an address
which is within a gigabyte or two of the stack, which is close enough to make
issues somewhat likely. In particular, if we get an address which is close-ish
to the stack, and then `mremap` it without the MAY_MOVE flag, we are *very*
likely to map pages in this "theoretical stack region". This is particularly a
problem on loongarch64, where the initial mmap address is empirically only
around 200 megabytes from the stack (whereas on most other 64-bit targets it's
closer to a gigabyte).

To work around this, we just need to avoid mremap in some cases. Unfortunately,
this system call isn't used too heavily by musl or glibc, so design issues like
this can and do exist without being caught. So, when `PageAllocator.resize` is
called, let's not try to `mremap` to grow the pages. We can still call `mremap`
in the `PageAllocator.remap` path, because in that case we can set the
`MAY_MOVE` flag, which empirically appears to make the Linux kernel avoid the
problematic "theoretical stack region".
---
 lib/std/heap/PageAllocator.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/heap/PageAllocator.zig b/lib/std/heap/PageAllocator.zig
index 66abe7d4daae846810055019a264d0015e988071..db736036b3f416d34a934b7185ac4a953affa303 100644
--- a/lib/std/heap/PageAllocator.zig
+++ b/lib/std/heap/PageAllocator.zig
@@ -225,7 +225,10 @@ pub fn realloc(uncasted_memory: []u8, alignment: Alignment, new_len: usize, may_
     if (new_size_aligned == page_aligned_len)
         return memory.ptr;
 
-    if (posix.MREMAP != void) {
+    // When the stack grows down, only use `mremap` if the allocation may move.
+    // Otherwise, we might grow the allocation and intrude on virtual address
+    // space which we want to keep available to the stack.
+    if (posix.MREMAP != void and (stack_direction == .up or may_move)) {
         // TODO: if the next_mmap_addr_hint is within the remapped range, update it
         const new_memory = posix.mremap(memory.ptr, page_aligned_len, new_size_aligned, .{ .MAYMOVE = may_move }, null) catch return null;
         return new_memory.ptr;
-- 
2.54.0


From b5bcbf2a62aa513022fdb12df75699308f87b7bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 20 Feb 2026 22:14:35 +0100
Subject: [PATCH 330/499] std.heap.DebugAllocator: make BucketHeader.fromPage()
 use wrapping arithmetic

If we've allocated the very last page in the address space then these operations
will overflow and underflow respectively - which is fine.
---
 lib/std/heap/debug_allocator.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/heap/debug_allocator.zig b/lib/std/heap/debug_allocator.zig
index d150bb09279c48da6f2c48ba6cee97a54bb07c9e..d6f2bf179653582d1d0d02faa1236e38e7fa5ab0 100644
--- a/lib/std/heap/debug_allocator.zig
+++ b/lib/std/heap/debug_allocator.zig
@@ -266,7 +266,7 @@ pub fn DebugAllocator(comptime config: Config) type {
             canary: usize = config.canary,
 
             fn fromPage(page_addr: usize, slot_count: usize) *BucketHeader {
-                const unaligned = page_addr + page_size - bucketSize(slot_count);
+                const unaligned = page_addr +% page_size -% bucketSize(slot_count);
                 return @ptrFromInt(unaligned & ~(@as(usize, @alignOf(BucketHeader)) - 1));
             }
 
-- 
2.54.0


From bd80ad46479fc39e0d629b7a1ff48a96760bb7f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 18 Feb 2026 16:46:42 +0100
Subject: [PATCH 331/499] Revert "ci: disable loongarch64-linux"

This reverts commit f061c0dc2851e5fab34dca1991ebe64cfd156bd5.
---
 .forgejo/workflows/ci.yaml | 41 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 8ae897599a521ee72f7cbfe3ecde10e7110ff15a..48813b9001d0463d39b7ce8e2566ae5dad555b87 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -59,27 +59,26 @@ jobs:
         run: sh ci/aarch64-macos-release.sh
         timeout-minutes: 120
 
-  # https://codeberg.org/ziglang/zig/issues/30800
-  #loongarch64-linux-debug:
-  #  runs-on: [self-hosted, loongarch64-linux]
-  #  steps:
-  #    - name: Checkout
-  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-  #      with:
-  #        fetch-depth: 0
-  #    - name: Build and Test
-  #      run: sh ci/loongarch64-linux-debug.sh
-  #      timeout-minutes: 240
-  #loongarch64-linux-release:
-  #  runs-on: [self-hosted, loongarch64-linux]
-  #  steps:
-  #    - name: Checkout
-  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-  #      with:
-  #        fetch-depth: 0
-  #    - name: Build and Test
-  #      run: sh ci/loongarch64-linux-release.sh
-  #      timeout-minutes: 180
+  loongarch64-linux-debug:
+    runs-on: [self-hosted, loongarch64-linux]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/loongarch64-linux-debug.sh
+        timeout-minutes: 240
+  loongarch64-linux-release:
+    runs-on: [self-hosted, loongarch64-linux]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/loongarch64-linux-release.sh
+        timeout-minutes: 180
 
   powerpc64le-linux-debug:
     runs-on: [self-hosted, powerpc64le-linux]
-- 
2.54.0


From d7f90722f75c887eb9f2a3f0603ce2d2f7ed7d84 Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Sat, 21 Feb 2026 16:52:34 -0500
Subject: [PATCH 332/499] x86_64: fix parsing of sib operands

---
 src/codegen/x86_64/CodeGen.zig | 84 ++++++++++++++++++++++++----------
 1 file changed, 59 insertions(+), 25 deletions(-)

diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 7da423f4299b1d791ed32d39eca8b28ab2874d7f..5032a5128998c96891cfe39f56cd5a040562bb2c 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -177397,7 +177397,10 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             label_gop.value_ptr.target = @intCast(self.mir_instructions.len);
         } else continue;
         if (mnem_str[0] == '.') {
-            if (prefix != .none) return self.fail("prefixed directive: '{s} {s}'", .{ @tagName(prefix), mnem_str });
+            if (prefix != .none) return self.fail("prefixed directive: '{s} {s}'", .{
+                @tagName(prefix),
+                mnem_str,
+            });
             prefix = .directive;
         }
 
@@ -177426,7 +177429,8 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
         else if (std.mem.endsWith(u8, mnem_str, "l"))
             .dword
         else if (std.mem.endsWith(u8, mnem_str, "q") and
-            (std.mem.indexOfScalar(u8, "vp", mnem_str[0]) == null or !std.mem.endsWith(u8, mnem_str, "dq")))
+            (std.mem.indexOfScalar(u8, "vp", mnem_str[0]) == null or
+                !std.mem.endsWith(u8, mnem_str, "dq")))
             .qword
         else if (std.mem.endsWith(u8, mnem_str, "t"))
             .tbyte
@@ -177463,23 +177467,40 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             mnem_size = .init(fixed_mnem_size);
         }
 
+        const ops_str = mnem_it.rest();
+        var ops_index: usize = 0;
         var ops: [4]Operand = @splat(.none);
         var ops_len: usize = 0;
-
-        var last_op = false;
-        var op_it = std.mem.splitScalar(u8, mnem_it.rest(), ',');
         next_op: for (&ops, 0..) |*op, op_index| {
-            const op_str = while (!last_op) {
-                const full_str = op_it.next() orelse break :next_op;
-                const code_str = if (std.mem.indexOfScalar(u8, full_str, '#') orelse
-                    std.mem.indexOf(u8, full_str, "//")) |comment|
-                code: {
-                    last_op = true;
-                    break :code full_str[0..comment];
-                } else full_str;
-                const trim_str = std.mem.trim(u8, code_str, " \t*");
-                if (trim_str.len > 0) break trim_str;
-            } else break;
+            const op_str = while (true) {
+                const op_start = ops_index;
+                if (ops_str.len - op_start == 0) break :next_op;
+                const full_op_str = while (true) {
+                    const op_end = std.mem.findAnyPos(u8, ops_str, ops_index, ",(") orelse {
+                        ops_index = ops_str.len;
+                        break ops_str[op_start..];
+                    };
+                    switch (ops_str[op_end]) {
+                        else => unreachable,
+                        ',' => {
+                            ops_index = op_end + 1;
+                            break ops_str[op_start..op_end];
+                        },
+                        '(' => ops_index = (std.mem.findScalarPos(u8, ops_str, op_end + 1, ')') orelse {
+                            ops_index = ops_str.len;
+                            break ops_str[op_start..];
+                        }) + 1,
+                    }
+                };
+                const untrimmed_op_str = if (std.mem.indexOfScalar(u8, full_op_str, '#') orelse
+                    std.mem.indexOf(u8, full_op_str, "//")) |comment|
+                untrimmed_op_str: {
+                    ops_index = ops_str.len;
+                    break :untrimmed_op_str full_op_str[0..comment];
+                } else full_op_str;
+                const trimmed_op_str = std.mem.trim(u8, untrimmed_op_str, " \t*");
+                if (trimmed_op_str.len > 0) break trimmed_op_str;
+            };
             if (std.mem.startsWith(u8, op_str, "%%")) {
                 const colon = std.mem.indexOfScalarPos(u8, op_str, "%%".len + 2, ':');
                 const reg = parseRegName(op_str["%%".len .. colon orelse op_str.len]) orelse
@@ -177496,7 +177517,8 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                         } },
                     } };
                 } else {
-                    if (mnem_size.use(op_index)) |size| if (reg.size().bitSize(self.target) != size.bitSize(self.target))
+                    if (mnem_size.use(op_index)) |size| if (reg.size().bitSize(self.target) !=
+                        size.bitSize(self.target))
                         return self.fail("invalid register size: '{s}'", .{op_str});
                     op.* = .{ .reg = reg };
                 }
@@ -177510,15 +177532,20 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                     arg_map.get(op_str["%[".len .. colon orelse op_str.len - "]".len]) orelse
                         return self.fail("no matching constraint: '{s}'", .{op_str})
                 ]) {
-                    .immediate => |imm| if (std.mem.eql(u8, modifier, "") or std.mem.eql(u8, modifier, "c"))
+                    .immediate => |imm| if (std.mem.eql(u8, modifier, "") or
+                        std.mem.eql(u8, modifier, "c"))
                         .{ .imm = .u(imm) }
                     else
                         return self.fail("invalid modifier: '{s}'", .{modifier}),
                     .register => |reg| if (std.mem.eql(u8, modifier, ""))
-                        .{ .reg = if (mnem_size.use(op_index)) |size| reg.toSize(size, self.target) else reg }
+                        .{ .reg = if (mnem_size.use(op_index)) |size|
+                            reg.toSize(size, self.target)
+                        else
+                            reg }
                     else
                         return self.fail("invalid modifier: '{s}'", .{modifier}),
-                    .memory => |addr| if (std.mem.eql(u8, modifier, "") or std.mem.eql(u8, modifier, "P"))
+                    .memory => |addr| if (std.mem.eql(u8, modifier, "") or
+                        std.mem.eql(u8, modifier, "P"))
                         .{ .mem = .{
                             .base = .{ .reg = .ds },
                             .mod = .{ .rm = .{
@@ -177564,7 +177591,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                     else
                         return self.fail("invalid modifier: '{s}'", .{modifier}),
                     .lea_extern_func => |extern_func| if (std.mem.eql(u8, modifier, "P"))
-                        .{ .reg = try self.copyToTmpRegister(.usize, .{ .lea_extern_func = extern_func }) }
+                        .{ .reg = try self.copyToTmpRegister(.usize, .{
+                            .lea_extern_func = extern_func,
+                        }) }
                     else
                         return self.fail("invalid modifier: '{s}'", .{modifier}),
                     else => return self.fail("invalid constraint: '{s}'", .{op_str}),
@@ -177579,7 +177608,8 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
             } else if (std.mem.endsWith(u8, op_str, ")")) {
                 const open = std.mem.indexOfScalar(u8, op_str, '(') orelse
                     return self.fail("invalid operand: '{s}'", .{op_str});
-                var sib_it = std.mem.splitScalar(u8, op_str[open + "(".len .. op_str.len - ")".len], ',');
+                var sib_it =
+                    std.mem.splitScalar(u8, op_str[open + "(".len .. op_str.len - ")".len], ',');
                 const base_str = sib_it.next() orelse
                     return self.fail("invalid memory operand: '{s}'", .{op_str});
                 if (base_str.len > 0 and !std.mem.startsWith(u8, base_str, "%%"))
@@ -177626,7 +177656,8 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                     else
                         .none,
                     .mod = .{ .rm = .{
-                        .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}),
+                        .size = mnem_size.use(op_index) orelse
+                            return self.fail("unknown size: '{s}'", .{op_str}),
                         .index = if (index_str.len > 0)
                             parseRegName(index_str["%%".len..]) orelse
                                 return self.fail("invalid index register: '{s}'", .{op_str})
@@ -177675,7 +177706,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                 op.* = .{ .inst = label_gop.value_ptr.target };
             } else return self.fail("invalid operand: '{s}'", .{op_str});
             ops_len += 1;
-        } else if (op_it.next()) |op_str| return self.fail("extra operand: '{s}'", .{op_str});
+        } else if (ops_str.len - ops_index > 0) return self.fail("extra operand: '{s}'", .{
+            ops_str[ops_index..],
+        });
 
         // convert from att syntax to intel syntax
         std.mem.reverse(Operand, ops[0..ops_len]);
@@ -177695,7 +177728,8 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                     else => unreachable,
                 }),
             }) catch unreachable;
-            if (std.meta.stringToEnum(encoder.Instruction.Mnemonic, intel_mnem_str)) |intel_mnem_tag| mnem_tag = intel_mnem_tag;
+            if (std.meta.stringToEnum(encoder.Instruction.Mnemonic, intel_mnem_str)) |intel_mnem_tag|
+                mnem_tag = intel_mnem_tag;
         }
         const mnem_name = @tagName(mnem_tag);
         const mnem_fixed_tag: Mir.Inst.FixedTag = if (prefix == .directive)
-- 
2.54.0


From 29e52aa0407a9b422006967f1bcc651240f9cfcf Mon Sep 17 00:00:00 2001
From: inge4pres <fgualazzi@gmail.com>
Date: Sat, 21 Feb 2026 16:23:57 +0100
Subject: [PATCH 333/499] lib: add cgroup BPF helpers

Add bpf_cgrp_storage_get and bpf_cgrp_storage_delete from
libbpf helpers.

Signed-off-by: inge4pres <fgualazzi@gmail.com>
---
 lib/std/os/linux/bpf/helpers.zig | 2 ++
 lib/std/os/linux/bpf/kern.zig    | 1 +
 2 files changed, 3 insertions(+)

diff --git a/lib/std/os/linux/bpf/helpers.zig b/lib/std/os/linux/bpf/helpers.zig
index d64d7236f01f8e68dfdc3139d4ae4e931ee6b00d..8ec8dac84da192ff35102a18cd1ec7fdfff9d738 100644
--- a/lib/std/os/linux/bpf/helpers.zig
+++ b/lib/std/os/linux/bpf/helpers.zig
@@ -223,3 +223,5 @@ pub const tcp_raw_check_syncookie_ipv4: *align(1) const fn (?*kern.IpHdr, ?*TcpH
 pub const tcp_raw_check_syncookie_ipv6: *align(1) const fn (?*kern.Ipv6Hdr, ?*TcpHdr) c_long = @ptrFromInt(207);
 pub const ktime_get_tai_ns: *align(1) const fn () u64 = @ptrFromInt(208);
 pub const user_ringbuf_drain: *align(1) const fn (?*anyopaque, ?*anyopaque, ?*anyopaque, u64) c_long = @ptrFromInt(209);
+pub const cgrp_storage_get: *align(1) const fn (?*anyopaque, ?*kern.Cgroup, ?*anyopaque, u64) ?*anyopaque = @ptrFromInt(210);
+pub const cgrp_storage_delete: *align(1) const fn (?*anyopaque, ?*kern.Cgroup) c_long = @ptrFromInt(211);
diff --git a/lib/std/os/linux/bpf/kern.zig b/lib/std/os/linux/bpf/kern.zig
index 62c52e00eeb5d9ad2f3125b839610f70193266ae..7fcf17b1b4b619b4c1990629861702400f598bea 100644
--- a/lib/std/os/linux/bpf/kern.zig
+++ b/lib/std/os/linux/bpf/kern.zig
@@ -16,6 +16,7 @@ pub const BpfSock = opaque {};
 pub const BpfSockAddr = opaque {};
 pub const BpfSockOps = opaque {};
 pub const BpfTimer = opaque {};
+pub const Cgroup = opaque {};
 pub const FibLookup = opaque {};
 pub const File = opaque {};
 pub const Inode = opaque {};
-- 
2.54.0


From de6c0d500fb27d01e284c047efeb4e02fb8c63e2 Mon Sep 17 00:00:00 2001
From: Yusuf Bham <git@fiftysix.dev>
Date: Wed, 18 Feb 2026 20:04:18 -0500
Subject: [PATCH 334/499] uefi(guid): don't use @byteSwap in fmt, adjust fmt
 test

@byteSwap shouldn't be called since we're formatting
ints again, and UEFI only officially supports LE.
---
 lib/std/os/uefi.zig | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/lib/std/os/uefi.zig b/lib/std/os/uefi.zig
index f8abb8d98974d62d060ad490fb98392cc90df570..cc2dac949e31d6c5a0bda855079f234f0ae7e181 100644
--- a/lib/std/os/uefi.zig
+++ b/lib/std/os/uefi.zig
@@ -107,14 +107,10 @@ pub const Guid = extern struct {
 
     /// Format GUID into hexadecimal lowercase xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format
     pub fn format(self: Guid, writer: *std.Io.Writer) std.Io.Writer.Error!void {
-        const time_low = @byteSwap(self.time_low);
-        const time_mid = @byteSwap(self.time_mid);
-        const time_high_and_version = @byteSwap(self.time_high_and_version);
-
         return writer.print("{x:0>8}-{x:0>4}-{x:0>4}-{x:0>2}{x:0>2}-{x}", .{
-            time_low,
-            time_mid,
-            time_high_and_version,
+            self.time_low,
+            self.time_mid,
+            self.time_high_and_version,
             self.clock_seq_high_and_reserved,
             self.clock_seq_low,
             self.node,
@@ -225,10 +221,10 @@ test "GUID formatting" {
     const bytes = [_]u8{ 137, 60, 203, 50, 128, 128, 124, 66, 186, 19, 80, 73, 135, 59, 194, 135 };
     const guid: Guid = @bitCast(bytes);
 
-    const str = try std.fmt.allocPrint(std.testing.allocator, "{}", .{guid});
+    const str = try std.fmt.allocPrint(std.testing.allocator, "{f}", .{guid});
     defer std.testing.allocator.free(str);
 
-    try std.testing.expect(std.mem.eql(u8, str, "32cb3c89-8080-427c-ba13-5049873bc287"));
+    try std.testing.expectEqualStrings(str, "32cb3c89-8080-427c-ba13-5049873bc287");
 }
 
 test {
-- 
2.54.0


From 27ef6e9a9b21ff7ca4e349af4384a3a23a1e3cde Mon Sep 17 00:00:00 2001
From: George Huebner <george@feyor.sh>
Date: Sat, 21 Feb 2026 19:19:53 -0600
Subject: [PATCH 335/499] bpf: add missing helpers

---
 lib/std/os/linux/bpf.zig | 70 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/lib/std/os/linux/bpf.zig b/lib/std/os/linux/bpf.zig
index 85f7d677e8f335871f0b751c5b5634bcf4205533..b2e39ec8427e8a4a69dbda87dc992a5a208446fb 100644
--- a/lib/std/os/linux/bpf.zig
+++ b/lib/std/os/linux/bpf.zig
@@ -388,6 +388,76 @@ pub const Helper = enum(i32) {
     skc_to_tcp_request_sock,
     skc_to_udp6_sock,
     get_task_stack,
+    load_hdr_opt,
+    store_hdr_opt,
+    reserve_hdr_opt,
+    inode_storage_get,
+    inode_storage_delete,
+    d_path,
+    copy_from_user,
+    snprintf_btf,
+    seq_printf_btf,
+    skb_cgroup_classid,
+    redirect_neigh,
+    per_cpu_ptr,
+    this_cpu_ptr,
+    redirect_peer,
+    task_storage_get,
+    task_storage_delete,
+    get_current_task_btf,
+    bprm_opts_set,
+    ktime_get_coarse_ns,
+    ima_inode_hash,
+    sock_from_file,
+    check_mtu,
+    for_each_map_elem,
+    snprintf,
+    sys_bpf,
+    btf_find_by_name_kind,
+    sys_close,
+    timer_init,
+    timer_set_callback,
+    timer_start,
+    timer_cancel,
+    get_func_ip,
+    get_attach_cookie,
+    task_pt_regs,
+    get_branch_snapshot,
+    trace_vprintk,
+    skc_to_unix_sock,
+    kallsyms_lookup_name,
+    find_vma,
+    loop,
+    strncmp,
+    get_func_arg,
+    get_func_ret,
+    get_func_arg_cnt,
+    get_retval,
+    set_retval,
+    xdp_get_buff_len,
+    xdp_load_bytes,
+    xdp_store_bytes,
+    copy_from_user_task,
+    skb_set_tstamp,
+    ima_file_hash,
+    kptr_xchg,
+    map_lookup_percpu_elem,
+    skc_to_mptcp_sock,
+    dynptr_from_mem,
+    ringbuf_reserve_dynptr,
+    ringbuf_submit_dynptr,
+    ringbuf_discard_dynptr,
+    dynptr_read,
+    dynptr_write,
+    dynptr_data,
+    tcp_raw_gen_syncookie_ipv4,
+    tcp_raw_gen_syncookie_ipv6,
+    tcp_raw_check_syncookie_ipv4,
+    tcp_raw_check_syncookie_ipv6,
+    ktime_get_tai_ns,
+    user_ringbuf_drain,
+    cgrp_storage_get,
+    cgrp_storage_delete,
     _,
 };
 
-- 
2.54.0


From e8ca9229c8aa6bd2d8abb1f91a8662eed2e68fd5 Mon Sep 17 00:00:00 2001
From: Frank Denis <github@pureftpd.org>
Date: Mon, 23 Feb 2026 23:04:26 +0100
Subject: [PATCH 336/499] Expose the elligator map for Curve25519

This is the same as for Edwards25519 without the y coordinate,
since it returns Montgomery coordinates, but it can be confusing
to call the Edwards25519 function while working on the
Curve25519 representation.

New protocols such as CPACE requires the map over Curve25519.
---
 lib/std/crypto/25519/curve25519.zig | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/lib/std/crypto/25519/curve25519.zig b/lib/std/crypto/25519/curve25519.zig
index 0cc0dec3d18704968c0768de6052684f2e92efac..5e84873d3a0561b4dc200a26d85ee4ae329d079c 100644
--- a/lib/std/crypto/25519/curve25519.zig
+++ b/lib/std/crypto/25519/curve25519.zig
@@ -101,6 +101,11 @@ pub const Curve25519 = struct {
         return try ladder(p, s, 256);
     }
 
+    /// Elligator2 map for Curve25519.
+    pub fn elligator2(r: Fe) Curve25519 {
+        return .{ .x = crypto.ecc.Edwards25519.elligator2(r).x };
+    }
+
     /// Compute the Curve25519 equivalent to an Edwards25519 point.
     ///
     /// Note that the function doesn't check that the input point is
@@ -145,6 +150,23 @@ test "non-affine edwards25519 to curve25519 projection" {
     try std.testing.expectEqualSlices(u8, &xp.toBytes(), &expected);
 }
 
+test "elligator2" {
+    const Fe = Curve25519.Fe;
+
+    // RFC 9380 Appendix J.4.2 test vector (curve25519_XMD:SHA-512_ELL2_NU_)
+    // u = 0x608d892b641f0328523802a6603427c26e55e6f27e71a91a478148d45b5093cd
+    // Q.x = 0x51125222da5e763d97f3c10fcc92ea6860b9ccbbd2eb1285728f566721c1e65b
+    const u = Fe.fromBytes(.{
+        0xcd, 0x93, 0x50, 0x5b, 0xd4, 0x48, 0x81, 0x47, 0x1a, 0xa9, 0x71, 0x7e, 0xf2, 0xe6, 0x55, 0x6e,
+        0xc2, 0x27, 0x34, 0x60, 0xa6, 0x02, 0x38, 0x52, 0x28, 0x03, 0x1f, 0x64, 0x2b, 0x89, 0x8d, 0x60,
+    });
+    const p = Curve25519.elligator2(u);
+    try std.testing.expectEqual([32]u8{
+        0x5b, 0xe6, 0xc1, 0x21, 0x67, 0x56, 0x8f, 0x72, 0x85, 0x12, 0xeb, 0xd2, 0xbb, 0xcc, 0xb9, 0x60,
+        0x68, 0xea, 0x92, 0xcc, 0x0f, 0xc1, 0xf3, 0x97, 0x3d, 0x76, 0x5e, 0xda, 0x22, 0x52, 0x12, 0x51,
+    }, p.toBytes());
+}
+
 test "small order check" {
     var s: [32]u8 = [_]u8{1} ++ [_]u8{0} ** 31;
     const small_order_ss: [7][32]u8 = .{
-- 
2.54.0


From 360bc28c9646ef6bcd6136f8a088930201e02012 Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Mon, 23 Feb 2026 17:07:47 +0100
Subject: [PATCH 337/499] fix cmpxchg behavior test

This has to be a `@cmpxchgStrong` instead of a `@cmpxchgWeak` otherwise
this test will fail spuriously on LL/SC architectures like PowerPC.
---
 test/behavior/atomics.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig
index 15d4b99ba49a5bd7aa5bcc6f54f5cc56df83294c..b7991fcaa470ea8d8f105f400589e9fc2e702554 100644
--- a/test/behavior/atomics.zig
+++ b/test/behavior/atomics.zig
@@ -143,7 +143,7 @@ test "cmpxchg on a global variable" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
-    _ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .acquire, .monotonic);
+    _ = @cmpxchgStrong(u32, &a_global_variable, 1234, 42, .acquire, .monotonic);
     try expect(a_global_variable == 42);
 }
 
-- 
2.54.0


From 784e89fd4b081900baaa9052273bccefc91d01ed Mon Sep 17 00:00:00 2001
From: Toufiq Shishir <toufiqshishir@outlook.com>
Date: Tue, 24 Feb 2026 01:26:27 +0600
Subject: [PATCH 338/499] fix: remove null argument from std.debug.lockStderr
 call inside std.json.Value.dump

---
 lib/std/json/dynamic.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/json/dynamic.zig b/lib/std/json/dynamic.zig
index e38ea9cb17e19d3d251813dbb9b0970f353b9cb5..bebdf7e5881d7fc804bf060029ad05ed0ad1cf5a 100644
--- a/lib/std/json/dynamic.zig
+++ b/lib/std/json/dynamic.zig
@@ -47,7 +47,7 @@ pub const Value = union(enum) {
     }
 
     pub fn dump(v: Value) void {
-        const stderr = std.debug.lockStderr(&.{}, null);
+        const stderr = std.debug.lockStderr(&.{});
         defer std.debug.unlockStderr();
         json.Stringify.value(v, .{}, &stderr.file_writer.interface) catch return;
     }
-- 
2.54.0


From 2f8e66080580c1ef3814cc4e2f27ae418d8d6e0c Mon Sep 17 00:00:00 2001
From: hemisputnik <hemisputnik@proton.me>
Date: Wed, 25 Feb 2026 10:48:24 +0200
Subject: [PATCH 339/499] std.math.log10: handle comptime_int inputs correctly

also add a few tests for comptime types

fixes #31333
---
 lib/std/math/log10.zig | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/lib/std/math/log10.zig b/lib/std/math/log10.zig
index e55ac46849242b9514638528ad2514c4b9e36ca8..4c1bb412a0dac7500b11226f327ceca0d7578168 100644
--- a/lib/std/math/log10.zig
+++ b/lib/std/math/log10.zig
@@ -17,7 +17,12 @@ pub fn log10(x: anytype) @TypeOf(x) {
         },
         .float => return @log10(x),
         .comptime_int => {
-            return @as(comptime_int, @floor(@log10(@as(f64, x))));
+            const Int = @Int(
+                if (x < 0) .signed else .unsigned,
+                // We let log10_int check if x is 0, for a nicer error message.
+                @max(16, if (x == 0) 0 else 1 + std.math.log2(x)),
+            );
+            return @as(comptime_int, log10_int(@as(Int, x)));
         },
         .int => |IntType| switch (IntType.signedness) {
             .signed => @compileError("log10 not implemented for signed integers"),
@@ -156,3 +161,10 @@ test log10_int {
         try testing.expectEqual(max_exponent, log10_int(@as(T, std.math.maxInt(T))));
     }
 }
+
+test "log10 with comptime types" {
+    try testing.expectEqual(0, log10(2));
+    try testing.expectEqual(2.0, log10(100.0));
+    try testing.expectEqual(2, log10(123));
+    try testing.expectEqual(3.0, log10(1000.0));
+}
-- 
2.54.0


From a3a9dc111da7a8455f9a476782f291f349d0ed8d Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Sun, 15 Feb 2026 17:05:00 +0100
Subject: [PATCH 340/499] std.heap.ArenaAllocator: make it threadsafe

Modifies the `Allocator` implementation provided by `ArenaAllocator` to be
threadsafe using only atomics and no synchronization primitives locked
behind an `Io` implementation.

At its core this is a lock-free singly linked list which uses CAS loops to
exchange the head node. A nice property of `ArenaAllocator` is that the
only functions that can ever remove nodes from its linked list are `reset`
and `deinit`, both of which are not part of the `Allocator` interface and
thus aren't threadsafe, so node-related ABA problems are impossible.

There *are* some trade-offs: end index tracking is now per node instead of
per allocator instance. It's not possible to publish a head node and its
end index at the same time if the latter isn't part of the former.

Another compromise had to be made in regards to resizing existing nodes.
Annoyingly, `rawResize` of an arbitrary thread-safe child allocator can
of course never be guaranteed to be an atomic operation, so only one
`alloc` call can ever resize at the same time, other threads have to
consider any resizes they attempt during that time failed. This causes
slightly less optimal behavior than what could be achieved with a mutex.
The LSB of `Node.size` is used to signal that a node is being resized.
This means that all nodes have to have an even size.

Calls to `alloc` have to allocate new nodes optimistically as they can
only know whether any CAS on a head node will succeed after attempting it,
and to attempt the CAS they of course already need to know the address of
the freshly allocated node they are trying to make the new head.
The simplest solution to this would be to just free the new node again if
a CAS fails, however this can be expensive and would mean that in practice
arenas could only really be used with a GPA as their child allocator. To
work around this, this implementation keeps its own free list of nodes
which didn't make their CAS to be reused by a later `alloc` invocation.
To keep things simple and avoid ABA problems the free list is only ever
be accessed beyond its head by 'stealing' the head node (and thus the
entire list) with an atomic swap. This makes iteration and removal trivial
since there's only ever one thread doing it at a time which also owns all
nodes it's holding. When the thread is done it can just push its list onto
the free list again.

This implementation offers comparable performance to the previous one when
only being accessed by a single thread and a slight speedup compared to
the previous implementation wrapped into a `ThreadSafeAllocator` up to ~7
threads performing operations on it concurrently.
(measured on a base model MacBook Pro M1)
---
 CMakeLists.txt                   |   2 +-
 lib/compiler/build_runner.zig    |  12 +-
 lib/std/debug.zig                |   6 +-
 lib/std/heap.zig                 |   2 +-
 lib/std/heap/ArenaAllocator.zig  | 642 +++++++++++++++++++++++++++++++
 lib/std/heap/arena_allocator.zig | 306 ---------------
 lib/std/process.zig              |   2 +-
 7 files changed, 650 insertions(+), 322 deletions(-)
 create mode 100644 lib/std/heap/ArenaAllocator.zig
 delete mode 100644 lib/std/heap/arena_allocator.zig

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8317566b4455d453b8f3d542de0293181912d6fd..4ace4744486c7515a6b4ef5a37fedf6af09c0020 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -263,7 +263,7 @@ set(ZIG_STAGE2_SOURCES
     lib/std/hash/wyhash.zig
     lib/std/hash_map.zig
     lib/std/heap.zig
-    lib/std/heap/arena_allocator.zig
+    lib/std/heap/ArenaAllocator.zig
     lib/std/json.zig
     lib/std/leb128.zig
     lib/std/log.zig
diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index faf81194a993db9e0ff90e7a34269a57a216f653..2ae4a8ad0cd10f416c9de367991a27adf12670d6 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -38,13 +38,9 @@ pub fn main(init: process.Init.Minimal) !void {
     const io = threaded.io();
 
     // ...but we'll back our arena by `std.heap.page_allocator` for efficiency.
-    var single_threaded_arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
-    defer single_threaded_arena.deinit();
-    var thread_safe_arena: std.heap.ThreadSafeAllocator = .{
-        .child_allocator = single_threaded_arena.allocator(),
-        .io = io,
-    };
-    const arena = thread_safe_arena.allocator();
+    var arena_instance: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
 
     const args = try init.args.toSlice(arena);
 
@@ -86,7 +82,7 @@ pub fn main(init: process.Init.Minimal) !void {
             .io = io,
             .gpa = gpa,
             .manifest_dir = try local_cache_directory.handle.createDirPathOpen(io, "h", .{}),
-            .cwd = try process.currentPathAlloc(io, single_threaded_arena.allocator()),
+            .cwd = try process.currentPathAlloc(io, arena),
         },
         .zig_exe = zig_exe,
         .environ_map = try init.environ.createMap(arena),
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 3f40e3cd1e4dee13ccf475f43247382cbf6eeed7..40f9903c15334a7ab307456f0c83d782e3221fa1 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -1346,12 +1346,8 @@ pub fn getDebugInfoAllocator() Allocator {
     // Otherwise, use a global arena backed by the page allocator
     const S = struct {
         var arena: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
-        var ts_arena: std.heap.ThreadSafeAllocator = .{
-            .child_allocator = arena.allocator(),
-            .io = std.Options.debug_io,
-        };
     };
-    return S.ts_arena.allocator();
+    return S.arena.allocator();
 }
 
 /// Whether or not the current target can print useful debug information when a segfault occurs.
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index bf28555e104879e029bb89016426d1eb60338470..18fec1197fcf89b66eeecbba887edc38165a0b4b 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -9,7 +9,7 @@ const Allocator = std.mem.Allocator;
 const windows = std.os.windows;
 const Alignment = std.mem.Alignment;
 
-pub const ArenaAllocator = @import("heap/arena_allocator.zig").ArenaAllocator;
+pub const ArenaAllocator = @import("heap/ArenaAllocator.zig");
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
diff --git a/lib/std/heap/ArenaAllocator.zig b/lib/std/heap/ArenaAllocator.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c772f367d078a8b115c2ec88a3993b7dc58fe220
--- /dev/null
+++ b/lib/std/heap/ArenaAllocator.zig
@@ -0,0 +1,642 @@
+//! This allocator takes an existing allocator, wraps it, and provides an interface where
+//! you can allocate and then free it all together. Calls to free an individual item only
+//! free the item if it was the most recent allocation, otherwise calls to free do
+//! nothing.
+//!
+//! The `Allocator` implementation provided is threadsafe, given that `child_allocator`
+//! is threadsafe as well.
+const ArenaAllocator = @This();
+
+child_allocator: Allocator,
+state: State,
+
+/// Inner state of ArenaAllocator. Can be stored rather than the entire ArenaAllocator
+/// as a memory-saving optimization.
+///
+/// Default initialization of this struct is deprecated; use `init` instead.
+pub const State = struct {
+    used_list: ?*Node = null,
+    free_list: ?*Node = null,
+
+    pub const init: State = .{
+        .used_list = null,
+        .free_list = null,
+    };
+
+    pub fn promote(state: State, child_allocator: Allocator) ArenaAllocator {
+        return .{
+            .child_allocator = child_allocator,
+            .state = state,
+        };
+    }
+};
+
+pub fn allocator(arena: *ArenaAllocator) Allocator {
+    return .{
+        .ptr = arena,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    };
+}
+
+pub fn init(child_allocator: Allocator) ArenaAllocator {
+    return State.init.promote(child_allocator);
+}
+
+/// Not threadsafe.
+pub fn deinit(arena: ArenaAllocator) void {
+    // NOTE: When changing this, make sure `reset()` is adjusted accordingly!
+
+    for ([_]?*Node{ arena.state.used_list, arena.state.free_list }) |first_node| {
+        var it = first_node;
+        while (it) |node| {
+            // this has to occur before the free because the free frees node
+            it = node.next;
+            arena.child_allocator.rawFree(node.allocatedSliceUnsafe(), .of(Node), @returnAddress());
+        }
+    }
+}
+
+/// Queries the current memory use of this arena.
+/// This will **not** include the storage required for internal keeping.
+///
+/// Not threadsafe.
+pub fn queryCapacity(arena: ArenaAllocator) usize {
+    var capacity: usize = 0;
+    for ([_]?*Node{ arena.state.used_list, arena.state.free_list }) |first_node| {
+        capacity += countListCapacity(first_node);
+    }
+    return capacity;
+}
+fn countListCapacity(first_node: ?*Node) usize {
+    var capacity: usize = 0;
+    var it = first_node;
+    while (it) |node| : (it = node.next) {
+        // Compute the actually allocated size excluding the
+        // linked list node.
+        capacity += node.size - @sizeOf(Node);
+    }
+    return capacity;
+}
+
+pub const ResetMode = union(enum) {
+    /// Releases all allocated memory in the arena.
+    free_all,
+    /// This will pre-heat the arena for future allocations by allocating a
+    /// large enough buffer for all previously done allocations.
+    /// Preheating will speed up the allocation process by invoking the backing allocator
+    /// less often than before. If `reset()` is used in a loop, this means that after the
+    /// biggest operation, no memory allocations are performed anymore.
+    retain_capacity,
+    /// This is the same as `retain_capacity`, but the memory will be shrunk to
+    /// this value if it exceeds the limit.
+    retain_with_limit: usize,
+};
+/// Resets the arena allocator and frees all allocated memory.
+///
+/// `mode` defines how the currently allocated memory is handled.
+/// See the variant documentation for `ResetMode` for the effects of each mode.
+///
+/// The function will return whether the reset operation was successful or not.
+/// If the reallocation  failed `false` is returned. The arena will still be fully
+/// functional in that case, all memory is released. Future allocations just might
+/// be slower.
+///
+/// Not threadsafe.
+///
+/// NOTE: If `mode` is `free_all`, the function will always return `true`.
+pub fn reset(arena: *ArenaAllocator, mode: ResetMode) bool {
+    // Some words on the implementation:
+    // The reset function can be implemented with two basic approaches:
+    // - Counting how much bytes were allocated since the last reset, and storing that
+    //   information in State. This will make reset fast and alloc only a teeny tiny bit
+    //   slower.
+    // - Counting how much bytes were allocated by iterating the chunk linked list. This
+    //   will make reset slower, but alloc() keeps the same speed when reset() as if reset()
+    //   would not exist.
+    //
+    // The second variant was chosen for implementation, as with more and more calls to reset(),
+    // the function will get faster and faster. At one point, the complexity of the function
+    // will drop to amortized O(1), as we're only ever having a single chunk that will not be
+    // reallocated, and we're not even touching the backing allocator anymore.
+    //
+    // Thus, only the first hand full of calls to reset() will actually need to iterate the linked
+    // list, all future calls are just taking the first node, and only resetting the `end_index`
+    // value.
+
+    const limit: ?usize = switch (mode) {
+        .retain_capacity => null,
+        .retain_with_limit => |limit| limit,
+        .free_all => 0,
+    };
+    if (limit == 0) {
+        // just reset when we don't have anything to reallocate
+        arena.deinit();
+        arena.state = .init;
+        return true;
+    }
+
+    const used_capacity = countListCapacity(arena.state.used_list);
+    const free_capacity = countListCapacity(arena.state.free_list);
+
+    const new_used_capacity = if (limit) |lim| @min(lim, used_capacity) else used_capacity;
+    const new_free_capacity = if (limit) |lim| @min(lim - new_used_capacity, free_capacity) else free_capacity;
+
+    var ok = true;
+
+    for (
+        [_]*?*Node{ &arena.state.used_list, &arena.state.free_list },
+        [_]usize{ new_used_capacity, new_free_capacity },
+    ) |first_node_ptr, new_capacity| {
+        // Free all nodes except for the last one
+        var it = first_node_ptr.*;
+        const node: *Node = while (it) |node| {
+            // this has to occur before the free because the free frees node
+            it = node.next;
+            if (it == null) break node;
+            arena.child_allocator.rawFree(node.allocatedSliceUnsafe(), .of(Node), @returnAddress());
+        } else {
+            continue;
+        };
+        const allocated_slice = node.allocatedSliceUnsafe();
+
+        if (new_capacity == 0) {
+            arena.child_allocator.rawFree(allocated_slice, .of(Node), @returnAddress());
+            first_node_ptr.* = null;
+            continue;
+        }
+
+        node.end_index = 0;
+        first_node_ptr.* = node;
+
+        const adjusted_capacity: usize = mem.alignForward(usize, new_capacity, 2);
+
+        if (allocated_slice.len - @sizeOf(Node) == adjusted_capacity) {
+            // perfect, no need to invoke the child_allocator
+            continue;
+        }
+
+        if (arena.child_allocator.rawResize(allocated_slice, .of(Node), adjusted_capacity, @returnAddress())) {
+            // successful resize
+            node.size = adjusted_capacity;
+        } else {
+            // manual realloc
+            const new_ptr = arena.child_allocator.rawAlloc(adjusted_capacity, .of(Node), @returnAddress()) orelse {
+                // we failed to preheat the arena properly, signal this to the user.
+                ok = false;
+                continue;
+            };
+            arena.child_allocator.rawFree(allocated_slice, .of(Node), @returnAddress());
+            const new_first_node: *Node = @ptrCast(@alignCast(new_ptr));
+            new_first_node.* = .{
+                .size = adjusted_capacity,
+                .end_index = 0,
+                .next = null,
+            };
+            first_node_ptr.* = new_first_node;
+        }
+    }
+
+    return ok;
+}
+
+/// Concurrent accesses to node pointers generally have to have acquire/release
+/// semantics to guarantee that newly allocated notes are in a valid state when
+/// being inserted into a list. Exceptions are possible, e.g. a CAS loop that
+/// never accesses the node returned on failure can use monotonic semantics on
+/// failure, but must still use release semantics on success to protect the node
+/// it's trying to push.
+const Node = struct {
+    /// Only meant to be accessed indirectly via the methods supplied by this type,
+    /// except if the node is owned by the thread accessing it.
+    /// Must always be an even number to accomodate `resize_bit`.
+    size: usize,
+    /// Concurrent accesses to `end_index` can be monotonic since it is only ever
+    /// incremented in `alloc` and `resize` after being compared to `size`.
+    /// Since `size` can only grow and never shrink, memory access depending on
+    /// `end_index` can never be OOB.
+    end_index: usize,
+    /// This field should only be accessed if the node is owned by the thread
+    /// accessing it.
+    next: ?*Node,
+
+    const resize_bit: usize = 1;
+
+    fn loadEndIndex(node: *Node) usize {
+        return @atomicLoad(usize, &node.end_index, .monotonic);
+    }
+
+    /// Returns `null` on success and previous value on failure.
+    fn trySetEndIndex(node: *Node, from: usize, to: usize) ?usize {
+        assert(from != to); // check this before attempting to set `end_index`!
+        return @cmpxchgWeak(usize, &node.end_index, from, to, .monotonic, .monotonic);
+    }
+
+    fn loadBuf(node: *Node) []u8 {
+        // monotonic is fine since `size` can only ever grow, so the buffer returned
+        // by this function is always valid memory.
+        const size = @atomicLoad(usize, &node.size, .monotonic);
+        return @as([*]u8, @ptrCast(node))[0 .. size & ~resize_bit][@sizeOf(Node)..];
+    }
+
+    /// Returns allocated slice or `null` if node is already (being) resized.
+    fn beginResize(node: *Node) ?[]u8 {
+        const size = @atomicRmw(usize, &node.size, .Or, resize_bit, .acquire); // syncs with release in `endResize`
+        if (size & resize_bit != 0) return null;
+        return @as([*]u8, @ptrCast(node))[0..size];
+    }
+
+    fn endResize(node: *Node, size: usize) void {
+        assert(size & resize_bit == 0);
+        return @atomicStore(usize, &node.size, size, .release); // syncs with acquire in `beginResize`
+    }
+
+    /// Not threadsafe.
+    fn allocatedSliceUnsafe(node: *Node) []u8 {
+        return @as([*]u8, @ptrCast(node))[0 .. node.size & ~resize_bit];
+    }
+};
+
+fn loadFirstNode(arena: *ArenaAllocator) ?*Node {
+    return @atomicLoad(?*Node, &arena.state.used_list, .acquire); // syncs with release in successful `tryPushNode`
+}
+
+const PushResult = union(enum) {
+    success,
+    failure: ?*Node,
+};
+fn tryPushNode(arena: *ArenaAllocator, node: *Node) PushResult {
+    assert(node != node.next);
+    if (@cmpxchgStrong( // strong because retrying means discarding a fitting node -> expensive
+        ?*Node,
+        &arena.state.used_list,
+        node.next,
+        node,
+        .release, // syncs with acquire in failure path or `loadFirstNode`
+        .acquire, // syncs with release in success path
+    )) |old_node| {
+        return .{ .failure = old_node };
+    } else {
+        return .success;
+    }
+}
+
+fn stealFreeList(arena: *ArenaAllocator) ?*Node {
+    // syncs with acq_rel in other `stealFreeList` calls or release in `pushFreeList`
+    return @atomicRmw(?*Node, &arena.state.free_list, .Xchg, null, .acq_rel);
+}
+
+fn pushFreeList(arena: *ArenaAllocator, first: *Node, last: *Node) void {
+    assert(first != last.next);
+    while (@cmpxchgWeak(
+        ?*Node,
+        &arena.state.free_list,
+        last.next,
+        first,
+        .release, // syncs with acquire part of acq_rel in `stealFreeList`
+        .monotonic, // we never access any fields of `old_free_list`, we only care about the pointer
+    )) |old_free_list| {
+        last.next = old_free_list;
+    }
+}
+
+fn alignedIndex(buf_ptr: [*]u8, end_index: usize, alignment: Alignment) usize {
+    return end_index +
+        mem.alignPointerOffset(buf_ptr + end_index, alignment.toByteUnits()).?;
+}
+
+fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u8 {
+    const arena: *ArenaAllocator = @ptrCast(@alignCast(ctx));
+    _ = ret_addr;
+
+    assert(n > 0);
+
+    var cur_first_node = arena.loadFirstNode();
+
+    var cur_new_node: ?*Node = null;
+    defer if (cur_new_node) |node| {
+        node.next = null; // optimize for empty free list
+        arena.pushFreeList(node, node);
+    };
+
+    retry: while (true) {
+        const first_node: ?*Node, const prev_size: usize = first_node: {
+            const node = cur_first_node orelse break :first_node .{ null, 0 };
+            var end_index = node.loadEndIndex();
+            while (true) {
+                const buf = node.loadBuf();
+                const aligned_index = alignedIndex(buf.ptr, end_index, alignment);
+
+                if (aligned_index + n > buf.len) {
+                    break :first_node .{ node, buf.len };
+                }
+
+                end_index = node.trySetEndIndex(end_index, aligned_index + n) orelse {
+                    return buf[aligned_index..][0..n].ptr;
+                };
+            }
+        };
+
+        resize: {
+            // Before attempting to get our hands on a new node, we try to resize
+            // the one we're currently holding. This is an exclusive operation;
+            // if another thread is already in this section we can never resize.
+
+            const node = first_node orelse break :resize;
+            const allocated_slice = node.beginResize() orelse break :resize;
+            var size = allocated_slice.len;
+            defer node.endResize(size);
+
+            const buf = allocated_slice[@sizeOf(Node)..];
+            const end_index = node.loadEndIndex();
+            const aligned_index = alignedIndex(buf.ptr, end_index, alignment);
+            const new_size = mem.alignForward(usize, @sizeOf(Node) + aligned_index + n, 2);
+
+            if (new_size <= allocated_slice.len) {
+                // a `resize` or `free` call managed to sneak in and we need to
+                // guarantee that `size` is only ever increased; retry!
+                continue :retry;
+            }
+
+            if (arena.child_allocator.rawResize(allocated_slice, .of(Node), new_size, @returnAddress())) {
+                size = new_size;
+
+                if (@cmpxchgStrong( // strong because a spurious failure could result in suboptimal usage of this node
+                    usize,
+                    &node.end_index,
+                    end_index,
+                    aligned_index + n,
+                    .monotonic,
+                    .monotonic,
+                ) == null) {
+                    const new_buf = allocated_slice.ptr[0..new_size][@sizeOf(Node)..];
+                    return new_buf[aligned_index..][0..n].ptr;
+                }
+            }
+        }
+
+        // We need a new node! First, we search `free_list` for one that's big
+        // enough, if we don't find one there we fall back to allocating a new
+        // node with `child_allocator` (if we haven't already done that!).
+
+        from_free_list: {
+            // We 'steal' the entire free list to operate on it without other
+            // threads getting up into our business.
+            // This is a rather pragmatic approach, but since the free list isn't
+            // used very frequently it's fine performance-wise, even under load.
+            // Also this avoids the ABA problem; stealing the list with an atomic
+            // swap doesn't introduce any potentially stale `next` pointers.
+
+            const free_list = arena.stealFreeList();
+            var first_free: ?*Node = free_list;
+            var last_free: ?*Node = free_list;
+            defer {
+                // Push remaining stolen free list back onto `arena.state.free_list`.
+                if (first_free) |first| {
+                    const last = last_free.?;
+                    assert(last.next == null); // optimize for no new nodes added during steal
+                    arena.pushFreeList(first, last);
+                }
+            }
+
+            var best_fit_prev: ?*Node = null;
+            var best_fit: ?*Node = null;
+            var best_fit_diff: usize = std.math.maxInt(usize);
+
+            var it_prev: ?*Node = null;
+            var it = free_list;
+            const candidate: ?*Node, const prev: ?*Node = find: while (it) |node| : ({
+                it_prev = it;
+                it = node.next;
+            }) {
+                last_free = node;
+                assert(node.size & Node.resize_bit == 0);
+                const buf = node.allocatedSliceUnsafe()[@sizeOf(Node)..];
+                const aligned_index = alignedIndex(buf.ptr, 0, alignment);
+                if (buf.len < aligned_index + n) {
+                    const diff = aligned_index + n - buf.len;
+                    if (diff <= best_fit_diff) {
+                        best_fit_prev = it_prev;
+                        best_fit = node;
+                        best_fit_diff = diff;
+                    }
+                    continue :find;
+                }
+                break :find .{ node, it_prev };
+            } else {
+                // Ideally we want to use all nodes in `free_list` eventually,
+                // so even if none fit we'll try to resize the one that was the
+                // closest to being large enough.
+                if (best_fit) |node| {
+                    const allocated_slice = node.allocatedSliceUnsafe();
+                    const buf = allocated_slice[@sizeOf(Node)..];
+                    const aligned_index = alignedIndex(buf.ptr, 0, alignment);
+                    const new_size = mem.alignForward(usize, @sizeOf(Node) + aligned_index + n, 2);
+
+                    if (arena.child_allocator.rawResize(allocated_slice, .of(Node), new_size, @returnAddress())) {
+                        node.size = new_size;
+                        break :find .{ node, best_fit_prev };
+                    }
+                }
+                break :from_free_list;
+            };
+
+            it = last_free;
+            while (it) |node| : (it = node.next) {
+                last_free = node;
+            }
+
+            const node = candidate orelse break :from_free_list;
+
+            const old_next = node.next;
+
+            const buf = node.allocatedSliceUnsafe()[@sizeOf(Node)..];
+            const aligned_index = alignedIndex(buf.ptr, 0, alignment);
+
+            node.end_index = aligned_index + n;
+            node.next = first_node;
+
+            switch (arena.tryPushNode(node)) {
+                .success => {
+                    // finish removing node from free list
+                    if (prev) |p| p.next = old_next;
+                    if (node == first_free) first_free = old_next;
+                    if (node == last_free) last_free = prev;
+                    return buf[aligned_index..][0..n].ptr;
+                },
+                .failure => |old_first_node| {
+                    cur_first_node = old_first_node;
+                    // restore free list to as we found it
+                    node.next = old_next;
+                    continue :retry;
+                },
+            }
+        }
+
+        const new_node: *Node = new_node: {
+            if (cur_new_node) |new_node| {
+                break :new_node new_node;
+            } else {
+                @branchHint(.cold);
+            }
+
+            const size: usize = size: {
+                const min_size = @sizeOf(Node) + alignment.toByteUnits() + n;
+                const big_enough_size = prev_size + min_size + 16;
+                break :size mem.alignForward(usize, big_enough_size + big_enough_size / 2, 2);
+            };
+            assert(size & Node.resize_bit == 0);
+            const ptr = arena.child_allocator.rawAlloc(size, .of(Node), @returnAddress()) orelse
+                return null;
+            const new_node: *Node = @ptrCast(@alignCast(ptr));
+            new_node.* = .{
+                .size = size,
+                .end_index = undefined, // set below
+                .next = undefined, // set below
+            };
+            cur_new_node = new_node;
+            break :new_node new_node;
+        };
+
+        const buf = new_node.allocatedSliceUnsafe()[@sizeOf(Node)..];
+        const aligned_index = alignedIndex(buf.ptr, 0, alignment);
+        assert(new_node.size >= @sizeOf(Node) + aligned_index + n);
+
+        new_node.end_index = aligned_index + n;
+        new_node.next = first_node;
+
+        switch (arena.tryPushNode(new_node)) {
+            .success => {
+                cur_new_node = null;
+                return buf[aligned_index..][0..n].ptr;
+            },
+            .failure => |old_first_node| {
+                cur_first_node = old_first_node;
+            },
+        }
+    }
+}
+
+fn resize(ctx: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize, ret_addr: usize) bool {
+    const arena: *ArenaAllocator = @ptrCast(@alignCast(ctx));
+    _ = alignment;
+    _ = ret_addr;
+
+    assert(buf.len > 0);
+    assert(new_len > 0);
+    if (buf.len == new_len) return true;
+
+    const node = arena.loadFirstNode().?;
+    const cur_buf_ptr = @as([*]u8, @ptrCast(node)) + @sizeOf(Node);
+
+    var cur_end_index = node.loadEndIndex();
+    while (true) {
+        if (cur_buf_ptr + cur_end_index != buf.ptr + buf.len) {
+            // It's not the most recent allocation, so it cannot be expanded,
+            // but it's fine if they want to make it smaller.
+            return new_len <= buf.len;
+        }
+
+        const new_end_index: usize = new_end_index: {
+            if (buf.len >= new_len) {
+                break :new_end_index cur_end_index - (buf.len - new_len);
+            }
+            const cur_buf_len: usize = node.loadBuf().len;
+            // Saturating arithmetic because `end_index` and `size` are not
+            // guaranteed to be in sync.
+            if (cur_buf_len -| cur_end_index >= new_len - buf.len) {
+                break :new_end_index cur_end_index + (new_len - buf.len);
+            }
+            return false;
+        };
+
+        cur_end_index = node.trySetEndIndex(cur_end_index, new_end_index) orelse {
+            return true;
+        };
+    }
+}
+
+fn remap(
+    context: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    return_address: usize,
+) ?[*]u8 {
+    return if (resize(context, memory, alignment, new_len, return_address)) memory.ptr else null;
+}
+
+fn free(ctx: *anyopaque, buf: []u8, alignment: Alignment, ret_addr: usize) void {
+    const arena: *ArenaAllocator = @ptrCast(@alignCast(ctx));
+    _ = alignment;
+    _ = ret_addr;
+
+    assert(buf.len > 0);
+
+    const node = arena.loadFirstNode().?;
+    const cur_buf_ptr: [*]u8 = @as([*]u8, @ptrCast(node)) + @sizeOf(Node);
+
+    var cur_end_index = node.loadEndIndex();
+    while (true) {
+        if (cur_buf_ptr + cur_end_index != buf.ptr + buf.len) {
+            // Not the most recent allocation; we cannot free it.
+            return;
+        }
+        const new_end_index = cur_end_index - buf.len;
+        cur_end_index = node.trySetEndIndex(cur_end_index, new_end_index) orelse {
+            return;
+        };
+    }
+}
+
+const std = @import("std");
+const assert = std.debug.assert;
+const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const Alignment = std.mem.Alignment;
+
+test "reset with preheating" {
+    var arena_allocator = ArenaAllocator.init(std.testing.allocator);
+    defer arena_allocator.deinit();
+    // provides some variance in the allocated data
+    var rng_src = std.Random.DefaultPrng.init(std.testing.random_seed);
+    const random = rng_src.random();
+    var rounds: usize = 25;
+    while (rounds > 0) {
+        rounds -= 1;
+        _ = arena_allocator.reset(.retain_capacity);
+        var alloced_bytes: usize = 0;
+        const total_size: usize = random.intRangeAtMost(usize, 256, 16384);
+        while (alloced_bytes < total_size) {
+            const size = random.intRangeAtMost(usize, 16, 256);
+            const alignment: Alignment = .@"32";
+            const slice = try arena_allocator.allocator().alignedAlloc(u8, alignment, size);
+            try std.testing.expect(alignment.check(@intFromPtr(slice.ptr)));
+            try std.testing.expectEqual(size, slice.len);
+            alloced_bytes += slice.len;
+        }
+    }
+}
+
+test "reset while retaining a buffer" {
+    var arena_allocator = ArenaAllocator.init(std.testing.allocator);
+    defer arena_allocator.deinit();
+    const a = arena_allocator.allocator();
+
+    // Create two internal buffers
+    _ = try a.alloc(u8, 1);
+    _ = try a.alloc(u8, 1000);
+
+    try std.testing.expect(arena_allocator.state.used_list != null);
+
+    // Check that we have at least two buffers
+    try std.testing.expect(arena_allocator.state.used_list.?.next != null);
+
+    // This retains the first allocated buffer
+    try std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = 1 }));
+    try std.testing.expect(arena_allocator.state.used_list.?.next == null);
+}
diff --git a/lib/std/heap/arena_allocator.zig b/lib/std/heap/arena_allocator.zig
deleted file mode 100644
index 130eae66f83987f316686fce45478f1422a9d861..0000000000000000000000000000000000000000
--- a/lib/std/heap/arena_allocator.zig
+++ /dev/null
@@ -1,306 +0,0 @@
-const std = @import("../std.zig");
-const assert = std.debug.assert;
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const Alignment = std.mem.Alignment;
-
-/// This allocator takes an existing allocator, wraps it, and provides an interface where
-/// you can allocate and then free it all together. Calls to free an individual item only
-/// free the item if it was the most recent allocation, otherwise calls to free do
-/// nothing.
-pub const ArenaAllocator = struct {
-    child_allocator: Allocator,
-    state: State,
-
-    /// Inner state of ArenaAllocator. Can be stored rather than the entire ArenaAllocator
-    /// as a memory-saving optimization.
-    pub const State = struct {
-        buffer_list: std.SinglyLinkedList = .{},
-        end_index: usize = 0,
-
-        pub fn promote(self: State, child_allocator: Allocator) ArenaAllocator {
-            return .{
-                .child_allocator = child_allocator,
-                .state = self,
-            };
-        }
-    };
-
-    pub fn allocator(self: *ArenaAllocator) Allocator {
-        return .{
-            .ptr = self,
-            .vtable = &.{
-                .alloc = alloc,
-                .resize = resize,
-                .remap = remap,
-                .free = free,
-            },
-        };
-    }
-
-    const BufNode = struct {
-        data: usize,
-        node: std.SinglyLinkedList.Node = .{},
-    };
-    const BufNode_alignment: Alignment = .of(BufNode);
-
-    pub fn init(child_allocator: Allocator) ArenaAllocator {
-        return (State{}).promote(child_allocator);
-    }
-
-    pub fn deinit(self: ArenaAllocator) void {
-        // NOTE: When changing this, make sure `reset()` is adjusted accordingly!
-
-        var it = self.state.buffer_list.first;
-        while (it) |node| {
-            // this has to occur before the free because the free frees node
-            const next_it = node.next;
-            const buf_node: *BufNode = @fieldParentPtr("node", node);
-            const alloc_buf = @as([*]u8, @ptrCast(buf_node))[0..buf_node.data];
-            self.child_allocator.rawFree(alloc_buf, BufNode_alignment, @returnAddress());
-            it = next_it;
-        }
-    }
-
-    pub const ResetMode = union(enum) {
-        /// Releases all allocated memory in the arena.
-        free_all,
-        /// This will pre-heat the arena for future allocations by allocating a
-        /// large enough buffer for all previously done allocations.
-        /// Preheating will speed up the allocation process by invoking the backing allocator
-        /// less often than before. If `reset()` is used in a loop, this means that after the
-        /// biggest operation, no memory allocations are performed anymore.
-        retain_capacity,
-        /// This is the same as `retain_capacity`, but the memory will be shrunk to
-        /// this value if it exceeds the limit.
-        retain_with_limit: usize,
-    };
-    /// Queries the current memory use of this arena.
-    /// This will **not** include the storage required for internal keeping.
-    pub fn queryCapacity(self: ArenaAllocator) usize {
-        var size: usize = 0;
-        var it = self.state.buffer_list.first;
-        while (it) |node| : (it = node.next) {
-            // Compute the actually allocated size excluding the
-            // linked list node.
-            const buf_node: *BufNode = @fieldParentPtr("node", node);
-            size += buf_node.data - @sizeOf(BufNode);
-        }
-        return size;
-    }
-    /// Resets the arena allocator and frees all allocated memory.
-    ///
-    /// `mode` defines how the currently allocated memory is handled.
-    /// See the variant documentation for `ResetMode` for the effects of each mode.
-    ///
-    /// The function will return whether the reset operation was successful or not.
-    /// If the reallocation  failed `false` is returned. The arena will still be fully
-    /// functional in that case, all memory is released. Future allocations just might
-    /// be slower.
-    ///
-    /// NOTE: If `mode` is `free_all`, the function will always return `true`.
-    pub fn reset(self: *ArenaAllocator, mode: ResetMode) bool {
-        // Some words on the implementation:
-        // The reset function can be implemented with two basic approaches:
-        // - Counting how much bytes were allocated since the last reset, and storing that
-        //   information in State. This will make reset fast and alloc only a teeny tiny bit
-        //   slower.
-        // - Counting how much bytes were allocated by iterating the chunk linked list. This
-        //   will make reset slower, but alloc() keeps the same speed when reset() as if reset()
-        //   would not exist.
-        //
-        // The second variant was chosen for implementation, as with more and more calls to reset(),
-        // the function will get faster and faster. At one point, the complexity of the function
-        // will drop to amortized O(1), as we're only ever having a single chunk that will not be
-        // reallocated, and we're not even touching the backing allocator anymore.
-        //
-        // Thus, only the first hand full of calls to reset() will actually need to iterate the linked
-        // list, all future calls are just taking the first node, and only resetting the `end_index`
-        // value.
-        const requested_capacity = switch (mode) {
-            .retain_capacity => self.queryCapacity(),
-            .retain_with_limit => |limit| @min(limit, self.queryCapacity()),
-            .free_all => 0,
-        };
-        if (requested_capacity == 0) {
-            // just reset when we don't have anything to reallocate
-            self.deinit();
-            self.state = State{};
-            return true;
-        }
-        const total_size = requested_capacity + @sizeOf(BufNode);
-        // Free all nodes except for the last one
-        var it = self.state.buffer_list.first;
-        const maybe_first_node = while (it) |node| {
-            // this has to occur before the free because the free frees node
-            const next_it = node.next;
-            if (next_it == null)
-                break node;
-            const buf_node: *BufNode = @fieldParentPtr("node", node);
-            const alloc_buf = @as([*]u8, @ptrCast(buf_node))[0..buf_node.data];
-            self.child_allocator.rawFree(alloc_buf, BufNode_alignment, @returnAddress());
-            it = next_it;
-        } else null;
-        std.debug.assert(maybe_first_node == null or maybe_first_node.?.next == null);
-        // reset the state before we try resizing the buffers, so we definitely have reset the arena to 0.
-        self.state.end_index = 0;
-        if (maybe_first_node) |first_node| {
-            self.state.buffer_list.first = first_node;
-            // perfect, no need to invoke the child_allocator
-            const first_buf_node: *BufNode = @fieldParentPtr("node", first_node);
-            if (first_buf_node.data == total_size)
-                return true;
-            const first_alloc_buf = @as([*]u8, @ptrCast(first_buf_node))[0..first_buf_node.data];
-            if (self.child_allocator.rawResize(first_alloc_buf, BufNode_alignment, total_size, @returnAddress())) {
-                // successful resize
-                first_buf_node.data = total_size;
-            } else {
-                // manual realloc
-                const new_ptr = self.child_allocator.rawAlloc(total_size, BufNode_alignment, @returnAddress()) orelse {
-                    // we failed to preheat the arena properly, signal this to the user.
-                    return false;
-                };
-                self.child_allocator.rawFree(first_alloc_buf, BufNode_alignment, @returnAddress());
-                const buf_node: *BufNode = @ptrCast(@alignCast(new_ptr));
-                buf_node.* = .{ .data = total_size };
-                self.state.buffer_list.first = &buf_node.node;
-            }
-        }
-        return true;
-    }
-
-    fn createNode(self: *ArenaAllocator, prev_len: usize, minimum_size: usize) ?*BufNode {
-        const actual_min_size = minimum_size + (@sizeOf(BufNode) + 16);
-        const big_enough_len = prev_len + actual_min_size;
-        const len = big_enough_len + big_enough_len / 2;
-        const ptr = self.child_allocator.rawAlloc(len, BufNode_alignment, @returnAddress()) orelse
-            return null;
-        const buf_node: *BufNode = @ptrCast(@alignCast(ptr));
-        buf_node.* = .{ .data = len };
-        self.state.buffer_list.prepend(&buf_node.node);
-        self.state.end_index = 0;
-        return buf_node;
-    }
-
-    fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ra: usize) ?[*]u8 {
-        const self: *ArenaAllocator = @ptrCast(@alignCast(ctx));
-        _ = ra;
-
-        const ptr_align = alignment.toByteUnits();
-        var cur_node: *BufNode = if (self.state.buffer_list.first) |first_node|
-            @fieldParentPtr("node", first_node)
-        else
-            (self.createNode(0, n + ptr_align) orelse return null);
-        while (true) {
-            const cur_alloc_buf = @as([*]u8, @ptrCast(cur_node))[0..cur_node.data];
-            const cur_buf = cur_alloc_buf[@sizeOf(BufNode)..];
-            const addr = @intFromPtr(cur_buf.ptr) + self.state.end_index;
-            const adjusted_addr = mem.alignForward(usize, addr, ptr_align);
-            const adjusted_index = self.state.end_index + (adjusted_addr - addr);
-            const new_end_index = adjusted_index + n;
-
-            if (new_end_index <= cur_buf.len) {
-                const result = cur_buf[adjusted_index..new_end_index];
-                self.state.end_index = new_end_index;
-                return result.ptr;
-            }
-
-            const bigger_buf_size = @sizeOf(BufNode) + new_end_index;
-            if (self.child_allocator.rawResize(cur_alloc_buf, BufNode_alignment, bigger_buf_size, @returnAddress())) {
-                cur_node.data = bigger_buf_size;
-            } else {
-                // Allocate a new node if that's not possible
-                cur_node = self.createNode(cur_buf.len, n + ptr_align) orelse return null;
-            }
-        }
-    }
-
-    fn resize(ctx: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize, ret_addr: usize) bool {
-        const self: *ArenaAllocator = @ptrCast(@alignCast(ctx));
-        _ = alignment;
-        _ = ret_addr;
-
-        const cur_node = self.state.buffer_list.first orelse return false;
-        const cur_buf_node: *BufNode = @fieldParentPtr("node", cur_node);
-        const cur_buf = @as([*]u8, @ptrCast(cur_buf_node))[@sizeOf(BufNode)..cur_buf_node.data];
-        if (@intFromPtr(cur_buf.ptr) + self.state.end_index != @intFromPtr(buf.ptr) + buf.len) {
-            // It's not the most recent allocation, so it cannot be expanded,
-            // but it's fine if they want to make it smaller.
-            return new_len <= buf.len;
-        }
-
-        if (buf.len >= new_len) {
-            self.state.end_index -= buf.len - new_len;
-            return true;
-        } else if (cur_buf.len - self.state.end_index >= new_len - buf.len) {
-            self.state.end_index += new_len - buf.len;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    fn remap(
-        context: *anyopaque,
-        memory: []u8,
-        alignment: Alignment,
-        new_len: usize,
-        return_address: usize,
-    ) ?[*]u8 {
-        return if (resize(context, memory, alignment, new_len, return_address)) memory.ptr else null;
-    }
-
-    fn free(ctx: *anyopaque, buf: []u8, alignment: Alignment, ret_addr: usize) void {
-        _ = alignment;
-        _ = ret_addr;
-
-        const self: *ArenaAllocator = @ptrCast(@alignCast(ctx));
-
-        const cur_node = self.state.buffer_list.first orelse return;
-        const cur_buf_node: *BufNode = @fieldParentPtr("node", cur_node);
-        const cur_buf = @as([*]u8, @ptrCast(cur_buf_node))[@sizeOf(BufNode)..cur_buf_node.data];
-
-        if (@intFromPtr(cur_buf.ptr) + self.state.end_index == @intFromPtr(buf.ptr) + buf.len) {
-            self.state.end_index -= buf.len;
-        }
-    }
-};
-
-test "reset with preheating" {
-    var arena_allocator = ArenaAllocator.init(std.testing.allocator);
-    defer arena_allocator.deinit();
-    // provides some variance in the allocated data
-    var rng_src = std.Random.DefaultPrng.init(std.testing.random_seed);
-    const random = rng_src.random();
-    var rounds: usize = 25;
-    while (rounds > 0) {
-        rounds -= 1;
-        _ = arena_allocator.reset(.retain_capacity);
-        var alloced_bytes: usize = 0;
-        const total_size: usize = random.intRangeAtMost(usize, 256, 16384);
-        while (alloced_bytes < total_size) {
-            const size = random.intRangeAtMost(usize, 16, 256);
-            const alignment: Alignment = .@"32";
-            const slice = try arena_allocator.allocator().alignedAlloc(u8, alignment, size);
-            try std.testing.expect(alignment.check(@intFromPtr(slice.ptr)));
-            try std.testing.expectEqual(size, slice.len);
-            alloced_bytes += slice.len;
-        }
-    }
-}
-
-test "reset while retaining a buffer" {
-    var arena_allocator = ArenaAllocator.init(std.testing.allocator);
-    defer arena_allocator.deinit();
-    const a = arena_allocator.allocator();
-
-    // Create two internal buffers
-    _ = try a.alloc(u8, 1);
-    _ = try a.alloc(u8, 1000);
-
-    // Check that we have at least two buffers
-    try std.testing.expect(arena_allocator.state.buffer_list.first.?.next != null);
-
-    // This retains the first allocated buffer
-    try std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = 1 }));
-}
diff --git a/lib/std/process.zig b/lib/std/process.zig
index fca2d0c773c47359e33f9c5d47ebe316fbde327b..1be0cd628d224db76ea26d19d15336549e6ae3ba 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -31,7 +31,7 @@ pub const Init = struct {
     /// `Init` is a superset of `Minimal`; the latter is included here.
     minimal: Minimal,
     /// Permanent storage for the entire process, cleaned automatically on
-    /// exit. Not threadsafe.
+    /// exit. Threadsafe.
     arena: *std.heap.ArenaAllocator,
     /// A default-selected general purpose allocator for temporary heap
     /// allocations. Debug mode will set up leak checking if possible.
-- 
2.54.0


From 333055ced72ae73c1ec74a66aa9436291d8b7d1d Mon Sep 17 00:00:00 2001
From: Ivan Agafonov <armadil@yandex.ru>
Date: Wed, 11 Feb 2026 02:49:11 +0500
Subject: [PATCH 341/499] langref: specific expectEqual* functions instead of
 expect

---
 doc/langref/error_union_parsing_u64.zig       |  2 +-
 .../result_location_interfering_with_swap.zig |  6 +--
 doc/langref/test_TypeOf_builtin.zig           |  6 +--
 doc/langref/test_allocator.zig                |  4 +-
 doc/langref/test_allowzero.zig                |  4 +-
 doc/langref/test_anonymous_struct.zig         |  9 ++--
 doc/langref/test_anonymous_union.zig          |  6 +--
 doc/langref/test_arrays.zig                   | 18 +++----
 doc/langref/test_basic_slices.zig             | 22 ++++----
 doc/langref/test_bitOffsetOf_offsetOf.zig     | 14 ++---
 doc/langref/test_call_builtin.zig             |  4 +-
 .../test_coerce_error_subset_to_superset.zig  |  2 +-
 doc/langref/test_coerce_large_to_small.zig    |  4 +-
 ...st_coerce_optional_wrapped_error_union.zig |  6 +--
 doc/langref/test_coerce_optionals.zig         |  6 +--
 ...test_coerce_slices_arrays_and_pointers.zig | 28 +++++-----
 doc/langref/test_coerce_to_error_union.zig    |  4 +-
 doc/langref/test_coerce_tuples_arrays.zig     |  2 +-
 doc/langref/test_coerce_unions_enums.zig      | 12 ++---
 doc/langref/test_comptime_evaluation.zig      |  8 +--
 doc/langref/test_comptime_max_with_bool.zig   |  2 +-
 .../test_comptime_pointer_conversion.zig      |  6 +--
 doc/langref/test_comptime_pointers.zig        |  4 +-
 doc/langref/test_comptime_variables.zig       |  6 +--
 ...t_container-level_comptime_expressions.zig |  2 +-
 .../test_container_level_variables.zig        |  6 +--
 doc/langref/test_defer.zig                    |  6 +--
 doc/langref/test_empty_block.zig              |  8 +--
 doc/langref/test_enum_literals.zig            |  3 +-
 doc/langref/test_enums.zig                    | 34 ++++++------
 doc/langref/test_error_union.zig              |  6 +--
 .../test_fibonacci_comptime_overflow.zig      |  4 +-
 doc/langref/test_fibonacci_recursion.zig      |  6 +--
 doc/langref/test_field_builtin.zig            | 12 ++---
 doc/langref/test_fn_reflection.zig            |  4 +-
 doc/langref/test_fn_type_inference.zig        | 10 ++--
 doc/langref/test_for.zig                      | 24 ++++-----
 doc/langref/test_for_nested_break.zig         |  6 +--
 doc/langref/test_functions.zig                |  6 +--
 doc/langref/test_global_assembly.zig          |  4 +-
 doc/langref/test_if.zig                       | 13 ++---
 doc/langref/test_if_optionals.zig             | 15 +++---
 .../test_incorrect_pointer_alignment.zig      |  2 +-
 doc/langref/test_inline_else.zig              |  6 +--
 doc/langref/test_inline_for.zig               |  4 +-
 doc/langref/test_inline_switch_union_tag.zig  |  4 +-
 doc/langref/test_inline_while.zig             |  4 +-
 .../test_integer_pointer_conversion.zig       |  6 +--
 doc/langref/test_integer_widening.zig         |  8 +--
 doc/langref/test_labeled_break.zig            |  6 +--
 doc/langref/test_misaligned_pointer.zig       |  4 +-
 doc/langref/test_multidimensional_arrays.zig  |  7 ++-
 ...st_namespaced_container_level_variable.zig |  6 +--
 doc/langref/test_noreturn_from_exit.zig       |  4 +-
 doc/langref/test_null_terminated_array.zig    | 14 ++---
 doc/langref/test_null_terminated_slice.zig    |  6 +--
 doc/langref/test_null_terminated_slicing.zig  |  6 +--
 doc/langref/test_optional_pointer.zig         |  6 +--
 doc/langref/test_optional_type.zig            |  4 +-
 .../test_overaligned_packed_struct.zig        |  4 +-
 doc/langref/test_packed_struct_equality.zig   |  4 +-
 .../test_packed_struct_field_address.zig      |  6 +--
 doc/langref/test_packed_structs.zig           | 20 +++----
 .../test_pass_by_reference_or_value.zig       |  4 +-
 doc/langref/test_peer_type_resolution.zig     | 52 +++++++++----------
 doc/langref/test_pointer_arithmetic.zig       | 18 +++----
 doc/langref/test_pointer_casting.zig          | 10 ++--
 .../test_pointer_coerce_const_optional.zig    |  4 +-
 ...test_pointer_to_non-byte_aligned_field.zig |  4 +-
 doc/langref/test_reduce_builtin.zig           |  8 +--
 doc/langref/test_round_builtin.zig            | 10 ++--
 doc/langref/test_sentinel_mismatch.zig        |  2 +-
 doc/langref/test_shuffle_builtin.zig          |  6 +--
 doc/langref/test_simple_union.zig             |  6 +--
 doc/langref/test_single_item_pointer.zig      | 20 +++----
 doc/langref/test_slice_bounds.zig             |  8 +--
 doc/langref/test_slices.zig                   | 18 +++----
 doc/langref/test_splat_builtin.zig            |  6 +--
 doc/langref/test_src_builtin.zig              |  5 +-
 doc/langref/test_static_local_variable.zig    |  6 +--
 doc/langref/test_struct_result.zig            |  6 +--
 doc/langref/test_structs.zig                  | 22 ++++----
 doc/langref/test_switch.zig                   |  4 +-
 .../test_switch_modify_tagged_union.zig       |  4 +-
 doc/langref/test_switch_tagged_union.zig      |  6 +--
 doc/langref/test_tagName.zig                  |  4 +-
 doc/langref/test_tagged_union.zig             |  8 +--
 .../test_tagged_union_with_tag_values.zig     |  6 +--
 doc/langref/test_this_builtin.zig             |  4 +-
 doc/langref/test_truncate_builtin.zig         |  4 +-
 doc/langref/test_tuples.zig                   |  9 ++--
 doc/langref/test_variable_alignment.zig       |  8 +--
 doc/langref/test_variable_func_alignment.zig  | 22 ++++----
 doc/langref/test_variadic_function.zig        |  2 +-
 doc/langref/test_volatile.zig                 |  4 +-
 doc/langref/test_wasmMemoryGrow_builtin.zig   |  6 +--
 doc/langref/test_while.zig                    |  4 +-
 doc/langref/test_while_break.zig              |  4 +-
 doc/langref/test_while_continue.zig           |  4 +-
 .../test_while_continue_expression.zig        |  3 +-
 doc/langref/test_while_error_capture.zig      |  4 +-
 doc/langref/test_while_null_capture.zig       |  8 +--
 doc/langref/test_wraparound_semantics.zig     |  6 +--
 doc/langref/testing_detect_leak.zig           |  2 +-
 doc/langref/testing_introduction.zig          |  6 ++-
 105 files changed, 422 insertions(+), 410 deletions(-)

diff --git a/doc/langref/error_union_parsing_u64.zig b/doc/langref/error_union_parsing_u64.zig
index 9e55e247f2699c543e067ba2629672bef6504abb..b710d159ac4959eabc5e739e0e504ae9e2d9a9f8 100644
--- a/doc/langref/error_union_parsing_u64.zig
+++ b/doc/langref/error_union_parsing_u64.zig
@@ -35,7 +35,7 @@ fn charToDigit(c: u8) u8 {
 
 test "parse u64" {
     const result = try parseU64("1234", 10);
-    try std.testing.expect(result == 1234);
+    try std.testing.expectEqual(1234, result);
 }
 
 // test
diff --git a/doc/langref/result_location_interfering_with_swap.zig b/doc/langref/result_location_interfering_with_swap.zig
index 6182d4818a024d1c65ae32b0e3f645a0ce39d574..7442d2fa33e143efdaa20ba863dfca682c3dbb79 100644
--- a/doc/langref/result_location_interfering_with_swap.zig
+++ b/doc/langref/result_location_interfering_with_swap.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 test "attempt to swap array elements with array initializer" {
     var arr: [2]u32 = .{ 1, 2 };
     arr = .{ arr[1], arr[0] };
@@ -6,8 +6,8 @@ test "attempt to swap array elements with array initializer" {
     //   arr[0] = arr[1];
     //   arr[1] = arr[0];
     // So this fails!
-    try expect(arr[0] == 2); // succeeds
-    try expect(arr[1] == 1); // fails
+    try expectEqual(2, arr[0]); // succeeds
+    try expectEqual(1, arr[1]); // fails
 }
 
 // test_error=
diff --git a/doc/langref/test_TypeOf_builtin.zig b/doc/langref/test_TypeOf_builtin.zig
index 2c833363fd56f2f1cb49dbef0a8b2292ba266e3f..6ce5f098440d0a9cda7e24101ae48ce1c18cb059 100644
--- a/doc/langref/test_TypeOf_builtin.zig
+++ b/doc/langref/test_TypeOf_builtin.zig
@@ -1,11 +1,11 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "no runtime side effects" {
     var data: i32 = 0;
     const T = @TypeOf(foo(i32, &data));
-    try comptime expect(T == i32);
-    try expect(data == 0);
+    try comptime expectEqual(i32, T);
+    try expectEqual(0, data);
 }
 
 fn foo(comptime T: type, ptr: *T) T {
diff --git a/doc/langref/test_allocator.zig b/doc/langref/test_allocator.zig
index ff0e18a507d0e134da1054a5dce634e089d2f679..35e1bd701f63407716d70c86be7ab655d1eceb65 100644
--- a/doc/langref/test_allocator.zig
+++ b/doc/langref/test_allocator.zig
@@ -1,13 +1,13 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const expect = std.testing.expect;
+const expectEqualStrings = std.testing.expectEqualStrings;
 
 test "using an allocator" {
     var buffer: [100]u8 = undefined;
     var fba = std.heap.FixedBufferAllocator.init(&buffer);
     const allocator = fba.allocator();
     const result = try concat(allocator, "foo", "bar");
-    try expect(std.mem.eql(u8, "foobar", result));
+    try expectEqualStrings("foobar", result);
 }
 
 fn concat(allocator: Allocator, a: []const u8, b: []const u8) ![]u8 {
diff --git a/doc/langref/test_allowzero.zig b/doc/langref/test_allowzero.zig
index 0798322bb04cd1612e07e3b25cbfea2418a6ce23..a5002f7d8c3526720dc5951a9051a01353d9d67c 100644
--- a/doc/langref/test_allowzero.zig
+++ b/doc/langref/test_allowzero.zig
@@ -1,11 +1,11 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "allowzero" {
     var zero: usize = 0; // var to make to runtime-known
     _ = &zero; // suppress 'var is never mutated' error
     const ptr: *allowzero i32 = @ptrFromInt(zero);
-    try expect(@intFromPtr(ptr) == 0);
+    try expectEqual(0, @intFromPtr(ptr));
 }
 
 // test
diff --git a/doc/langref/test_anonymous_struct.zig b/doc/langref/test_anonymous_struct.zig
index 82d4f62203b6f275ecce920356a8014755bf8574..037ca1dd4888d717daa3db651852c2e48d24f0bd 100644
--- a/doc/langref/test_anonymous_struct.zig
+++ b/doc/langref/test_anonymous_struct.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "fully anonymous struct" {
     try check(.{
@@ -11,11 +12,11 @@ test "fully anonymous struct" {
 }
 
 fn check(args: anytype) !void {
-    try expect(args.int == 1234);
-    try expect(args.float == 12.34);
+    try expectEqual(1234, args.int);
+    try expectEqual(12.34, args.float);
     try expect(args.b);
-    try expect(args.s[0] == 'h');
-    try expect(args.s[1] == 'i');
+    try expectEqual('h', args.s[0]);
+    try expectEqual('i', args.s[1]);
 }
 
 // test
diff --git a/doc/langref/test_anonymous_union.zig b/doc/langref/test_anonymous_union.zig
index bb8311d5eb2da42155edcef0d75725bce9dfe1ee..f0ce2980fa579e3787b84ec99d0a84b3d408c070 100644
--- a/doc/langref/test_anonymous_union.zig
+++ b/doc/langref/test_anonymous_union.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Number = union {
     int: i32,
@@ -9,8 +9,8 @@ const Number = union {
 test "anonymous union literal syntax" {
     const i: Number = .{ .int = 42 };
     const f = makeNumber();
-    try expect(i.int == 42);
-    try expect(f.float == 12.34);
+    try expectEqual(42, i.int);
+    try expectEqual(12.34, f.float);
 }
 
 fn makeNumber() Number {
diff --git a/doc/langref/test_arrays.zig b/doc/langref/test_arrays.zig
index 0c479dbce1e257e711357c2ea1a647f97e9ca2d3..fa8d2ed3d3bdacb933f642bc465056ad684893b8 100644
--- a/doc/langref/test_arrays.zig
+++ b/doc/langref/test_arrays.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 const assert = @import("std").debug.assert;
 const mem = @import("std").mem;
 
@@ -29,7 +29,7 @@ test "iterate over an array" {
     for (message) |byte| {
         sum += byte;
     }
-    try expect(sum == 'h' + 'e' + 'l' * 2 + 'o');
+    try expectEqual('h' + 'e' + 'l' * 2 + 'o', sum);
 }
 
 // modifiable array
@@ -39,8 +39,8 @@ test "modify an array" {
     for (&some_integers, 0..) |*item, i| {
         item.* = @intCast(i);
     }
-    try expect(some_integers[10] == 10);
-    try expect(some_integers[99] == 99);
+    try expectEqual(10, some_integers[10]);
+    try expectEqual(99, some_integers[99]);
 }
 
 // array concatenation works if the values are known
@@ -91,8 +91,8 @@ const Point = struct {
 };
 
 test "compile-time array initialization" {
-    try expect(fancy_array[4].x == 4);
-    try expect(fancy_array[4].y == 8);
+    try expectEqual(4, fancy_array[4].x);
+    try expectEqual(8, fancy_array[4].y);
 }
 
 // call a function to initialize an array
@@ -104,9 +104,9 @@ fn makePoint(x: i32) Point {
     };
 }
 test "array initialization with function calls" {
-    try expect(more_points[4].x == 3);
-    try expect(more_points[4].y == 6);
-    try expect(more_points.len == 10);
+    try expectEqual(3, more_points[4].x);
+    try expectEqual(6, more_points[4].y);
+    try expectEqual(10, more_points.len);
 }
 
 // test
diff --git a/doc/langref/test_basic_slices.zig b/doc/langref/test_basic_slices.zig
index 3d3c7c6d7c2631541fd72ffb143ba99668ca3a2f..28013148352eba7c5b9e6c0849e778c1ebc0b5ed 100644
--- a/doc/langref/test_basic_slices.zig
+++ b/doc/langref/test_basic_slices.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 const expectEqualSlices = @import("std").testing.expectEqualSlices;
 
 test "basic slices" {
@@ -12,14 +12,14 @@ test "basic slices" {
 
     try expectEqualSlices(i32, slice, alt_slice);
 
-    try expect(@TypeOf(slice) == []i32);
-    try expect(&slice[0] == &array[0]);
-    try expect(slice.len == array.len);
+    try expectEqual([]i32, @TypeOf(slice));
+    try expectEqual(&array[0], &slice[0]);
+    try expectEqual(array.len, slice.len);
 
     // If you slice with comptime-known start and end positions, the result is
     // a pointer to an array, rather than a slice.
     const array_ptr = array[0..array.len];
-    try expect(@TypeOf(array_ptr) == *[array.len]i32);
+    try expectEqual(*[array.len]i32, @TypeOf(array_ptr));
 
     // You can perform a slice-by-length by slicing twice. This allows the compiler
     // to perform some optimisations like recognising a comptime-known length when
@@ -28,13 +28,13 @@ test "basic slices" {
     _ = &runtime_start;
     const length = 2;
     const array_ptr_len = array[runtime_start..][0..length];
-    try expect(@TypeOf(array_ptr_len) == *[length]i32);
+    try expectEqual(*[length]i32, @TypeOf(array_ptr_len));
 
     // Using the address-of operator on a slice gives a single-item pointer.
-    try expect(@TypeOf(&slice[0]) == *i32);
+    try expectEqual(*i32, @TypeOf(&slice[0]));
     // Using the `ptr` field gives a many-item pointer.
-    try expect(@TypeOf(slice.ptr) == [*]i32);
-    try expect(@intFromPtr(slice.ptr) == @intFromPtr(&slice[0]));
+    try expectEqual([*]i32, @TypeOf(slice.ptr));
+    try expectEqual(@intFromPtr(slice.ptr), @intFromPtr(&slice[0]));
 
     // Slices have array bounds checking. If you try to access something out
     // of bounds, you'll get a safety check failure:
@@ -47,8 +47,8 @@ test "basic slices" {
     const empty1 = &[0]u8{};
     // If the type is known you can use this short hand:
     const empty2: []u8 = &.{};
-    try expect(empty1.len == 0);
-    try expect(empty2.len == 0);
+    try expectEqual(0, empty1.len);
+    try expectEqual(0, empty2.len);
 
     // A zero-length initialization can always be used to create an empty slice, even if the slice is mutable.
     // This is because the pointed-to data is zero bits long, so its immutability is irrelevant.
diff --git a/doc/langref/test_bitOffsetOf_offsetOf.zig b/doc/langref/test_bitOffsetOf_offsetOf.zig
index ed4faebf5f334199ce9e4427206688371b82b464..e2eb49f8a39e881af648f3892e0b67d7d38c6197 100644
--- a/doc/langref/test_bitOffsetOf_offsetOf.zig
+++ b/doc/langref/test_bitOffsetOf_offsetOf.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const BitField = packed struct {
     a: u3,
@@ -9,13 +9,13 @@ const BitField = packed struct {
 
 test "offsets of non-byte-aligned fields" {
     comptime {
-        try expect(@bitOffsetOf(BitField, "a") == 0);
-        try expect(@bitOffsetOf(BitField, "b") == 3);
-        try expect(@bitOffsetOf(BitField, "c") == 6);
+        try expectEqual(0, @bitOffsetOf(BitField, "a"));
+        try expectEqual(3, @bitOffsetOf(BitField, "b"));
+        try expectEqual(6, @bitOffsetOf(BitField, "c"));
 
-        try expect(@offsetOf(BitField, "a") == 0);
-        try expect(@offsetOf(BitField, "b") == 0);
-        try expect(@offsetOf(BitField, "c") == 0);
+        try expectEqual(0, @offsetOf(BitField, "a"));
+        try expectEqual(0, @offsetOf(BitField, "b"));
+        try expectEqual(0, @offsetOf(BitField, "c"));
     }
 }
 
diff --git a/doc/langref/test_call_builtin.zig b/doc/langref/test_call_builtin.zig
index 8caecf73c4843ab64f381326aac564d243f91f49..cc465f2e459b08d9107c709f319bbd098d8f9fad 100644
--- a/doc/langref/test_call_builtin.zig
+++ b/doc/langref/test_call_builtin.zig
@@ -1,7 +1,7 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "noinline function call" {
-    try expect(@call(.auto, add, .{ 3, 9 }) == 12);
+    try expectEqual(12, @call(.auto, add, .{ 3, 9 }));
 }
 
 fn add(a: i32, b: i32) i32 {
diff --git a/doc/langref/test_coerce_error_subset_to_superset.zig b/doc/langref/test_coerce_error_subset_to_superset.zig
index d46c761e4ec45fbab69e7b03ec35a720b4ed93a6..58279a13234a4bea9566b29841237a762c35ebd8 100644
--- a/doc/langref/test_coerce_error_subset_to_superset.zig
+++ b/doc/langref/test_coerce_error_subset_to_superset.zig
@@ -12,7 +12,7 @@ const AllocationError = error{
 
 test "coerce subset to superset" {
     const err = foo(AllocationError.OutOfMemory);
-    try std.testing.expect(err == FileOpenError.OutOfMemory);
+    try std.testing.expectEqual(FileOpenError.OutOfMemory, err);
 }
 
 fn foo(err: AllocationError) FileOpenError {
diff --git a/doc/langref/test_coerce_large_to_small.zig b/doc/langref/test_coerce_large_to_small.zig
index 62111af97992ce5a72ae237808d9bae9cd3c433b..2c7b390e665f5d555a9c3c5493af8015ff85c1aa 100644
--- a/doc/langref/test_coerce_large_to_small.zig
+++ b/doc/langref/test_coerce_large_to_small.zig
@@ -1,10 +1,10 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "coercing large integer type to smaller one when value is comptime-known to fit" {
     const x: u64 = 255;
     const y: u8 = x;
-    try expect(y == 255);
+    try expectEqual(255, y);
 }
 
 // test
diff --git a/doc/langref/test_coerce_optional_wrapped_error_union.zig b/doc/langref/test_coerce_optional_wrapped_error_union.zig
index c41dd0b1d0f69a878ed8e24e9a4fdbb6d17b61eb..bddd2e1acdb7a5270316b6bf919c024071599889 100644
--- a/doc/langref/test_coerce_optional_wrapped_error_union.zig
+++ b/doc/langref/test_coerce_optional_wrapped_error_union.zig
@@ -1,12 +1,12 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "coerce to optionals wrapped in error union" {
     const x: anyerror!?i32 = 1234;
     const y: anyerror!?i32 = null;
 
-    try expect((try x).? == 1234);
-    try expect((try y) == null);
+    try expectEqual(1234, (try x).?);
+    try expectEqual(null, (try y));
 }
 
 // test
diff --git a/doc/langref/test_coerce_optionals.zig b/doc/langref/test_coerce_optionals.zig
index 415bb2344b13346a7ae14b3b30b12e4ec1d14554..2698f35cf0505827f0e35b943811ebe9fd7489f6 100644
--- a/doc/langref/test_coerce_optionals.zig
+++ b/doc/langref/test_coerce_optionals.zig
@@ -1,12 +1,12 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "coerce to optionals" {
     const x: ?i32 = 1234;
     const y: ?i32 = null;
 
-    try expect(x.? == 1234);
-    try expect(y == null);
+    try expectEqual(1234, x.?);
+    try expectEqual(null, y);
 }
 
 // test
diff --git a/doc/langref/test_coerce_slices_arrays_and_pointers.zig b/doc/langref/test_coerce_slices_arrays_and_pointers.zig
index 67b2687163f58bf78c07e0873d2d41e56d1e1502..f79fb8f767ed0800e03275503f729075e46fe401 100644
--- a/doc/langref/test_coerce_slices_arrays_and_pointers.zig
+++ b/doc/langref/test_coerce_slices_arrays_and_pointers.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
+const expectEqualSlices = std.testing.expectEqualSlices;
 
 // You can assign constant pointers to arrays to a slice with
 // const modifier on the element type. Useful in particular for
@@ -7,48 +9,48 @@ const expect = std.testing.expect;
 test "*const [N]T to []const T" {
     const x1: []const u8 = "hello";
     const x2: []const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    try expect(std.mem.eql(u8, x1, x2));
+    try expectEqualStrings(x1, x2);
 
     const y: []const f32 = &[2]f32{ 1.2, 3.4 };
-    try expect(y[0] == 1.2);
+    try expectEqual(1.2, y[0]);
 }
 
 // Likewise, it works when the destination type is an error union.
 test "*const [N]T to E![]const T" {
     const x1: anyerror![]const u8 = "hello";
     const x2: anyerror![]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    try expect(std.mem.eql(u8, try x1, try x2));
+    try expectEqualStrings(try x1, try x2);
 
     const y: anyerror![]const f32 = &[2]f32{ 1.2, 3.4 };
-    try expect((try y)[0] == 1.2);
+    try expectEqual(1.2, (try y)[0]);
 }
 
 // Likewise, it works when the destination type is an optional.
 test "*const [N]T to ?[]const T" {
     const x1: ?[]const u8 = "hello";
     const x2: ?[]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    try expect(std.mem.eql(u8, x1.?, x2.?));
+    try expectEqualStrings(x1.?, x2.?);
 
     const y: ?[]const f32 = &[2]f32{ 1.2, 3.4 };
-    try expect(y.?[0] == 1.2);
+    try expectEqual(1.2, y.?[0]);
 }
 
 // In this cast, the array length becomes the slice length.
 test "*[N]T to []T" {
     var buf: [5]u8 = "hello".*;
     const x: []u8 = &buf;
-    try expect(std.mem.eql(u8, x, "hello"));
+    try expectEqualStrings("hello", x);
 
     const buf2 = [2]f32{ 1.2, 3.4 };
     const x2: []const f32 = &buf2;
-    try expect(std.mem.eql(f32, x2, &[2]f32{ 1.2, 3.4 }));
+    try expectEqualSlices(f32, &[2]f32{ 1.2, 3.4 }, x2);
 }
 
 // Single-item pointers to arrays can be coerced to many-item pointers.
 test "*[N]T to [*]T" {
     var buf: [5]u8 = "hello".*;
     const x: [*]u8 = &buf;
-    try expect(x[4] == 'o');
+    try expectEqual('o', x[4]);
     // x[5] would be an uncaught out of bounds pointer dereference!
 }
 
@@ -56,7 +58,7 @@ test "*[N]T to [*]T" {
 test "*[N]T to ?[*]T" {
     var buf: [5]u8 = "hello".*;
     const x: ?[*]u8 = &buf;
-    try expect(x.?[4] == 'o');
+    try expectEqual('o', x.?[4]);
 }
 
 // Single-item pointers can be cast to len-1 single-item arrays.
@@ -64,14 +66,14 @@ test "*T to *[1]T" {
     var x: i32 = 1234;
     const y: *[1]i32 = &x;
     const z: [*]i32 = y;
-    try expect(z[0] == 1234);
+    try expectEqual(1234, z[0]);
 }
 
 // Sentinel-terminated slices can be coerced into sentinel-terminated pointers
 test "[:x]T to [*:x]T" {
     const buf: [:0]const u8 = "hello";
     const buf2: [*:0]const u8 = buf;
-    try expect(buf2[4] == 'o');
+    try expectEqual('o', buf2[4]);
 }
 
 // test
diff --git a/doc/langref/test_coerce_to_error_union.zig b/doc/langref/test_coerce_to_error_union.zig
index 2789a921981ab8d86e4972b79fe32553efa7f358..4c42e24afbd9284171f9bbe720c3152c23d2031e 100644
--- a/doc/langref/test_coerce_to_error_union.zig
+++ b/doc/langref/test_coerce_to_error_union.zig
@@ -1,11 +1,11 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "coercion to error unions" {
     const x: anyerror!i32 = 1234;
     const y: anyerror!i32 = error.Failure;
 
-    try expect((try x) == 1234);
+    try expectEqual(1234, (try x));
     try std.testing.expectError(error.Failure, y);
 }
 
diff --git a/doc/langref/test_coerce_tuples_arrays.zig b/doc/langref/test_coerce_tuples_arrays.zig
index 6d0e63e15c1c2d29660dd4138ff10794bc9e2763..0005d33e8bdd168919e271fb1dd2d4bdffa84050 100644
--- a/doc/langref/test_coerce_tuples_arrays.zig
+++ b/doc/langref/test_coerce_tuples_arrays.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Tuple = struct { u8, u8 };
 test "coercion from homogeneous tuple to array" {
diff --git a/doc/langref/test_coerce_unions_enums.zig b/doc/langref/test_coerce_unions_enums.zig
index 0a782b4c54e31aeb678ee3673d98560b4442b89c..94655c2e9dcce8d4dc5d74d6d78afc6bcb8e6b7a 100644
--- a/doc/langref/test_coerce_unions_enums.zig
+++ b/doc/langref/test_coerce_unions_enums.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const E = enum {
     one,
@@ -28,22 +28,22 @@ const U2 = union(enum) {
 test "coercion between unions and enums" {
     const u = U{ .two = 12.34 };
     const e: E = u; // coerce union to enum
-    try expect(e == E.two);
+    try expectEqual(E.two, e);
 
     const three = E.three;
     const u_2: U = three; // coerce enum to union
-    try expect(u_2 == E.three);
+    try expectEqual(E.three, u_2);
 
     const u_3: U = .three; // coerce enum literal to union
-    try expect(u_3 == E.three);
+    try expectEqual(E.three, u_3);
 
     const u_4: U2 = .a; // coerce enum literal to union with inferred enum tag type.
-    try expect(u_4.tag() == 1);
+    try expectEqual(1, u_4.tag());
 
     // The following example is invalid.
     // error: coercion from enum '@EnumLiteral()' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
     //var u_5: U2 = .b;
-    //try expect(u_5.tag() == 2);
+    //try expectEqual(2, u_5.tag());
 }
 
 // test
diff --git a/doc/langref/test_comptime_evaluation.zig b/doc/langref/test_comptime_evaluation.zig
index 832814e5957b7423e8eddabe57572e0d99cac50b..521aa14eddfd9fdfd654a75c3bbcf827e3853e4c 100644
--- a/doc/langref/test_comptime_evaluation.zig
+++ b/doc/langref/test_comptime_evaluation.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 const CmdFn = struct {
     name: []const u8,
@@ -32,9 +32,9 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
 }
 
 test "perform fn" {
-    try expect(performFn('t', 1) == 6);
-    try expect(performFn('o', 0) == 1);
-    try expect(performFn('w', 99) == 99);
+    try expectEqual(6, performFn('t', 1));
+    try expectEqual(1, performFn('o', 0));
+    try expectEqual(99, performFn('w', 99));
 }
 
 // test
diff --git a/doc/langref/test_comptime_max_with_bool.zig b/doc/langref/test_comptime_max_with_bool.zig
index 4d05cbbff0aeabf3dd76564a06a0e8431e663e6f..2bcd16cb39f42e6b20e95791d75f5dc4598e4c61 100644
--- a/doc/langref/test_comptime_max_with_bool.zig
+++ b/doc/langref/test_comptime_max_with_bool.zig
@@ -8,7 +8,7 @@ fn max(comptime T: type, a: T, b: T) T {
     }
 }
 test "try to compare bools" {
-    try @import("std").testing.expect(max(bool, false, true) == true);
+    try @import("std").testing.expectEqual(true, max(bool, false, true));
 }
 
 // test
diff --git a/doc/langref/test_comptime_pointer_conversion.zig b/doc/langref/test_comptime_pointer_conversion.zig
index 6151e992c04135cdf6171a073f3f2b6cad7b4db4..0c8e5a44eb3a34e81053fc99e6afd3f11601ee66 100644
--- a/doc/langref/test_comptime_pointer_conversion.zig
+++ b/doc/langref/test_comptime_pointer_conversion.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "comptime @ptrFromInt" {
     comptime {
@@ -6,8 +6,8 @@ test "comptime @ptrFromInt" {
         // ptr is never dereferenced.
         const ptr: *i32 = @ptrFromInt(0xdeadbee0);
         const addr = @intFromPtr(ptr);
-        try expect(@TypeOf(addr) == usize);
-        try expect(addr == 0xdeadbee0);
+        try expectEqual(usize, @TypeOf(addr));
+        try expectEqual(0xdeadbee0, addr);
     }
 }
 
diff --git a/doc/langref/test_comptime_pointers.zig b/doc/langref/test_comptime_pointers.zig
index 784ddfd9f5a25c515f41e000f2115ba4906c0c64..9c3b219c07fe89ea2297f94f4e597f0488a07389 100644
--- a/doc/langref/test_comptime_pointers.zig
+++ b/doc/langref/test_comptime_pointers.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "comptime pointers" {
     comptime {
@@ -6,7 +6,7 @@ test "comptime pointers" {
         const ptr = &x;
         ptr.* += 1;
         x += 1;
-        try expect(ptr.* == 3);
+        try expectEqual(3, ptr.*);
     }
 }
 
diff --git a/doc/langref/test_comptime_variables.zig b/doc/langref/test_comptime_variables.zig
index 49d92ea025647383d07a71bbfe35c895fd1f733d..b551590d1791151ea512d73f9e3b99d27ea542d9 100644
--- a/doc/langref/test_comptime_variables.zig
+++ b/doc/langref/test_comptime_variables.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "comptime vars" {
     var x: i32 = 1;
@@ -8,8 +8,8 @@ test "comptime vars" {
     x += 1;
     y += 1;
 
-    try expect(x == 2);
-    try expect(y == 2);
+    try expectEqual(2, x);
+    try expectEqual(2, y);
 
     if (y != 2) {
         // This compile error never triggers because y is a comptime variable,
diff --git a/doc/langref/test_container-level_comptime_expressions.zig b/doc/langref/test_container-level_comptime_expressions.zig
index 8f324a355397695ddda4bef21f86cd4765473b61..78d5cb4cbbcf8e8daba22ef493d2dc231d0e4d23 100644
--- a/doc/langref/test_container-level_comptime_expressions.zig
+++ b/doc/langref/test_container-level_comptime_expressions.zig
@@ -31,7 +31,7 @@ fn sum(numbers: []const i32) i32 {
 }
 
 test "variable values" {
-    try @import("std").testing.expect(sum_of_first_25_primes == 1060);
+    try @import("std").testing.expectEqual(1060, sum_of_first_25_primes);
 }
 
 // test
diff --git a/doc/langref/test_container_level_variables.zig b/doc/langref/test_container_level_variables.zig
index ade379ec79e053e94a0a69d69bdda8c8e5e3d24e..372fda1863f95659c313149052b65d2b7dfc0a6c 100644
--- a/doc/langref/test_container_level_variables.zig
+++ b/doc/langref/test_container_level_variables.zig
@@ -2,8 +2,8 @@ var y: i32 = add(10, x);
 const x: i32 = add(12, 34);
 
 test "container level variables" {
-    try expect(x == 46);
-    try expect(y == 56);
+    try expectEqual(46, x);
+    try expectEqual(56, y);
 }
 
 fn add(a: i32, b: i32) i32 {
@@ -11,6 +11,6 @@ fn add(a: i32, b: i32) i32 {
 }
 
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 // test
diff --git a/doc/langref/test_defer.zig b/doc/langref/test_defer.zig
index 80aebc9d662c7eafa2766c557ab026b468d45ce9..8c674f3aaf49853132f8eda2817e31bda67928e5 100644
--- a/doc/langref/test_defer.zig
+++ b/doc/langref/test_defer.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 const print = std.debug.print;
 
 fn deferExample() !usize {
@@ -9,14 +9,14 @@ fn deferExample() !usize {
         defer a = 2;
         a = 1;
     }
-    try expect(a == 2);
+    try expectEqual(2, a);
 
     a = 5;
     return a;
 }
 
 test "defer basics" {
-    try expect((try deferExample()) == 5);
+    try expectEqual(5, (try deferExample()));
 }
 
 // test
diff --git a/doc/langref/test_empty_block.zig b/doc/langref/test_empty_block.zig
index cab1b0376791ac273f90aa6ee8f8a7319ed33757..c12f9baefb88aea410d0d1eeff174524b1d41642 100644
--- a/doc/langref/test_empty_block.zig
+++ b/doc/langref/test_empty_block.zig
@@ -1,12 +1,12 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test {
     const a = {};
     const b = void{};
-    try expect(@TypeOf(a) == void);
-    try expect(@TypeOf(b) == void);
-    try expect(a == b);
+    try expectEqual(void, @TypeOf(a));
+    try expectEqual(void, @TypeOf(b));
+    try expectEqual(a, b);
 }
 
 // test
diff --git a/doc/langref/test_enum_literals.zig b/doc/langref/test_enum_literals.zig
index 6acf858c30f86ce096efe47ce9b5dc803cadba3e..e28c1d0d498ca58e1c287d473e4090e1f70ed3e9 100644
--- a/doc/langref/test_enum_literals.zig
+++ b/doc/langref/test_enum_literals.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Color = enum {
     auto,
@@ -10,7 +11,7 @@ const Color = enum {
 test "enum literals" {
     const color1: Color = .auto;
     const color2 = Color.auto;
-    try expect(color1 == color2);
+    try expectEqual(color1, color2);
 }
 
 test "switch using enum literals" {
diff --git a/doc/langref/test_enums.zig b/doc/langref/test_enums.zig
index 4e0b3896f20e775acb2ac3c22db2eadf687697fa..55a4f87d3bd6d24b96845c8e8622e90a98ba9c41 100644
--- a/doc/langref/test_enums.zig
+++ b/doc/langref/test_enums.zig
@@ -1,4 +1,6 @@
 const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
+const expectEqualStrings = @import("std").testing.expectEqualStrings;
 const mem = @import("std").mem;
 
 // Declare an enum.
@@ -20,9 +22,9 @@ const Value = enum(u2) {
 // Now you can cast between u2 and Value.
 // The ordinal value starts from 0, counting up by 1 from the previous member.
 test "enum ordinal value" {
-    try expect(@intFromEnum(Value.zero) == 0);
-    try expect(@intFromEnum(Value.one) == 1);
-    try expect(@intFromEnum(Value.two) == 2);
+    try expectEqual(0, @intFromEnum(Value.zero));
+    try expectEqual(1, @intFromEnum(Value.one));
+    try expectEqual(2, @intFromEnum(Value.two));
 }
 
 // You can override the ordinal value for an enum.
@@ -32,9 +34,9 @@ const Value2 = enum(u32) {
     million = 1000000,
 };
 test "set enum ordinal value" {
-    try expect(@intFromEnum(Value2.hundred) == 100);
-    try expect(@intFromEnum(Value2.thousand) == 1000);
-    try expect(@intFromEnum(Value2.million) == 1000000);
+    try expectEqual(100, @intFromEnum(Value2.hundred));
+    try expectEqual(1000, @intFromEnum(Value2.thousand));
+    try expectEqual(1000000, @intFromEnum(Value2.million));
 }
 
 // You can also override only some values.
@@ -46,11 +48,11 @@ const Value3 = enum(u4) {
     e,
 };
 test "enum implicit ordinal values and overridden values" {
-    try expect(@intFromEnum(Value3.a) == 0);
-    try expect(@intFromEnum(Value3.b) == 8);
-    try expect(@intFromEnum(Value3.c) == 9);
-    try expect(@intFromEnum(Value3.d) == 4);
-    try expect(@intFromEnum(Value3.e) == 5);
+    try expectEqual(0, @intFromEnum(Value3.a));
+    try expectEqual(8, @intFromEnum(Value3.b));
+    try expectEqual(9, @intFromEnum(Value3.c));
+    try expectEqual(4, @intFromEnum(Value3.d));
+    try expectEqual(5, @intFromEnum(Value3.e));
 }
 
 // Enums can have methods, the same as structs and unions.
@@ -84,7 +86,7 @@ test "enum switch" {
         Foo.number => "this is a number",
         Foo.none => "this is a none",
     };
-    try expect(mem.eql(u8, what_is_it, "this is a number"));
+    try expectEqualStrings(what_is_it, "this is a number");
 }
 
 // @typeInfo can be used to access the integer tag type of an enum.
@@ -95,18 +97,18 @@ const Small = enum {
     four,
 };
 test "std.meta.Tag" {
-    try expect(@typeInfo(Small).@"enum".tag_type == u2);
+    try expectEqual(u2, @typeInfo(Small).@"enum".tag_type);
 }
 
 // @typeInfo tells us the field count and the fields names:
 test "@typeInfo" {
-    try expect(@typeInfo(Small).@"enum".fields.len == 4);
-    try expect(mem.eql(u8, @typeInfo(Small).@"enum".fields[1].name, "two"));
+    try expectEqual(4, @typeInfo(Small).@"enum".fields.len);
+    try expectEqualStrings(@typeInfo(Small).@"enum".fields[1].name, "two");
 }
 
 // @tagName gives a [:0]const u8 representation of an enum value:
 test "@tagName" {
-    try expect(mem.eql(u8, @tagName(Small.three), "three"));
+    try expectEqualStrings(@tagName(Small.three), "three");
 }
 
 // test
diff --git a/doc/langref/test_error_union.zig b/doc/langref/test_error_union.zig
index 0cc01ec4a48494223526dc73bcc11701ed2685e0..41ff85339b8642023882bba043b37c260b349f69 100644
--- a/doc/langref/test_error_union.zig
+++ b/doc/langref/test_error_union.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "error union" {
     var foo: anyerror!i32 = undefined;
@@ -10,10 +10,10 @@ test "error union" {
     foo = error.SomeError;
 
     // Use compile-time reflection to access the payload type of an error union:
-    try comptime expect(@typeInfo(@TypeOf(foo)).error_union.payload == i32);
+    try comptime expectEqual(i32, @typeInfo(@TypeOf(foo)).error_union.payload);
 
     // Use compile-time reflection to access the error set type of an error union:
-    try comptime expect(@typeInfo(@TypeOf(foo)).error_union.error_set == anyerror);
+    try comptime expectEqual(anyerror, @typeInfo(@TypeOf(foo)).error_union.error_set);
 }
 
 // test
diff --git a/doc/langref/test_fibonacci_comptime_overflow.zig b/doc/langref/test_fibonacci_comptime_overflow.zig
index f06b37feed4637be2edd6ed3cc24b75176458715..1621e5884f5e7bd3323a336ac8caa5f73daded18 100644
--- a/doc/langref/test_fibonacci_comptime_overflow.zig
+++ b/doc/langref/test_fibonacci_comptime_overflow.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 fn fibonacci(index: u32) u32 {
     //if (index < 2) return index;
@@ -6,7 +6,7 @@ fn fibonacci(index: u32) u32 {
 }
 
 test "fibonacci" {
-    try comptime expect(fibonacci(7) == 13);
+    try comptime expectEqual(13, fibonacci(7));
 }
 
 // test_error=overflow of integer type
diff --git a/doc/langref/test_fibonacci_recursion.zig b/doc/langref/test_fibonacci_recursion.zig
index ba0b809fccec07378c1d5ac843bca6b3264eca7f..3a366fbbd21fc017c842ea3b0938cb954564e69d 100644
--- a/doc/langref/test_fibonacci_recursion.zig
+++ b/doc/langref/test_fibonacci_recursion.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 fn fibonacci(index: u32) u32 {
     if (index < 2) return index;
@@ -7,10 +7,10 @@ fn fibonacci(index: u32) u32 {
 
 test "fibonacci" {
     // test fibonacci at run-time
-    try expect(fibonacci(7) == 13);
+    try expectEqual(13, fibonacci(7));
 
     // test fibonacci at compile-time
-    try comptime expect(fibonacci(7) == 13);
+    try comptime expectEqual(13, fibonacci(7));
 }
 
 // test
diff --git a/doc/langref/test_field_builtin.zig b/doc/langref/test_field_builtin.zig
index 52ce702c7281f535eda0e3a385ddd6cbbaaaad1f..feca7c9298e799cb774542a0c95022465354325b 100644
--- a/doc/langref/test_field_builtin.zig
+++ b/doc/langref/test_field_builtin.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const expectEqual = std.testing.expectEqual;
 
 const Point = struct {
     x: u32,
@@ -8,23 +9,20 @@ const Point = struct {
 };
 
 test "field access by string" {
-    const expect = std.testing.expect;
     var p = Point{ .x = 0, .y = 0 };
 
     @field(p, "x") = 4;
     @field(p, "y") = @field(p, "x") + 1;
 
-    try expect(@field(p, "x") == 4);
-    try expect(@field(p, "y") == 5);
+    try expectEqual(4, @field(p, "x"));
+    try expectEqual(5, @field(p, "y"));
 }
 
 test "decl access by string" {
-    const expect = std.testing.expect;
-
-    try expect(@field(Point, "z") == 1);
+    try expectEqual(1, @field(Point, "z"));
 
     @field(Point, "z") = 2;
-    try expect(@field(Point, "z") == 2);
+    try expectEqual(2, @field(Point, "z"));
 }
 
 // test
diff --git a/doc/langref/test_fn_reflection.zig b/doc/langref/test_fn_reflection.zig
index cc4dd50b334081cd7204d7dc0efa72f3f0f41fe5..7c462bbfc50ae4bc0a4a6aa6827a34f25de1917f 100644
--- a/doc/langref/test_fn_reflection.zig
+++ b/doc/langref/test_fn_reflection.zig
@@ -3,8 +3,8 @@ const math = std.math;
 const testing = std.testing;
 
 test "fn reflection" {
-    try testing.expect(@typeInfo(@TypeOf(testing.expect)).@"fn".params[0].type.? == bool);
-    try testing.expect(@typeInfo(@TypeOf(testing.tmpDir)).@"fn".return_type.? == testing.TmpDir);
+    try testing.expectEqual(bool, @typeInfo(@TypeOf(testing.expect)).@"fn".params[0].type.?);
+    try testing.expectEqual(testing.TmpDir, @typeInfo(@TypeOf(testing.tmpDir)).@"fn".return_type.?);
 
     try testing.expect(@typeInfo(@TypeOf(math.Log2Int)).@"fn".is_generic);
 }
diff --git a/doc/langref/test_fn_type_inference.zig b/doc/langref/test_fn_type_inference.zig
index 494fdea4826e4b47c02cd479b4d4b089714fe47d..227a402ec49cc7c26a201c8a5277f553da2a2498 100644
--- a/doc/langref/test_fn_type_inference.zig
+++ b/doc/langref/test_fn_type_inference.zig
@@ -1,15 +1,15 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 fn addFortyTwo(x: anytype) @TypeOf(x) {
     return x + 42;
 }
 
 test "fn type inference" {
-    try expect(addFortyTwo(1) == 43);
-    try expect(@TypeOf(addFortyTwo(1)) == comptime_int);
+    try expectEqual(43, addFortyTwo(1));
+    try expectEqual(comptime_int, @TypeOf(addFortyTwo(1)));
     const y: i64 = 2;
-    try expect(addFortyTwo(y) == 44);
-    try expect(@TypeOf(addFortyTwo(y)) == i64);
+    try expectEqual(44, addFortyTwo(y));
+    try expectEqual(i64, @TypeOf(addFortyTwo(y)));
 }
 
 // test
diff --git a/doc/langref/test_for.zig b/doc/langref/test_for.zig
index 62751f9fbc3a5851a03bde447b2c0687c88493c3..d2d40db58fda67705cb38ec234e595ded20d86a5 100644
--- a/doc/langref/test_for.zig
+++ b/doc/langref/test_for.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "for basics" {
     const items = [_]i32{ 4, 5, 3, 4, 0 };
@@ -12,22 +12,22 @@ test "for basics" {
         }
         sum += value;
     }
-    try expect(sum == 16);
+    try expectEqual(16, sum);
 
     // To iterate over a portion of a slice, reslice.
     for (items[0..1]) |value| {
         sum += value;
     }
-    try expect(sum == 20);
+    try expectEqual(20, sum);
 
     // To access the index of iteration, specify a second condition as well
     // as a second capture value.
     var sum2: i32 = 0;
     for (items, 0..) |_, i| {
-        try expect(@TypeOf(i) == usize);
+        try expectEqual(usize, @TypeOf(i));
         sum2 += @as(i32, @intCast(i));
     }
-    try expect(sum2 == 10);
+    try expectEqual(10, sum2);
 
     // To iterate over consecutive integers, use the range syntax.
     // Unbounded range is always a compile error.
@@ -35,7 +35,7 @@ test "for basics" {
     for (0..5) |i| {
         sum3 += i;
     }
-    try expect(sum3 == 10);
+    try expectEqual(10, sum3);
 }
 
 test "multi object for" {
@@ -50,7 +50,7 @@ test "multi object for" {
         count += i + j;
     }
 
-    try expect(count == 21);
+    try expectEqual(21, count);
 }
 
 test "for reference" {
@@ -62,9 +62,9 @@ test "for reference" {
         value.* += 1;
     }
 
-    try expect(items[0] == 4);
-    try expect(items[1] == 5);
-    try expect(items[2] == 3);
+    try expectEqual(4, items[0]);
+    try expectEqual(5, items[1]);
+    try expectEqual(3, items[2]);
 }
 
 test "for else" {
@@ -79,10 +79,10 @@ test "for else" {
             sum += value.?;
         }
     } else blk: {
-        try expect(sum == 12);
+        try expectEqual(12, sum);
         break :blk sum;
     };
-    try expect(result == 12);
+    try expectEqual(12, result);
 }
 
 // test
diff --git a/doc/langref/test_for_nested_break.zig b/doc/langref/test_for_nested_break.zig
index 301facbcfe1134785e6e28293bbdbf3694137f23..38fed8900abbe5e43b2e65693b0048ce3a8e5da3 100644
--- a/doc/langref/test_for_nested_break.zig
+++ b/doc/langref/test_for_nested_break.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "nested break" {
     var count: usize = 0;
@@ -9,7 +9,7 @@ test "nested break" {
             break :outer;
         }
     }
-    try expect(count == 1);
+    try expectEqual(1, count);
 }
 
 test "nested continue" {
@@ -21,7 +21,7 @@ test "nested continue" {
         }
     }
 
-    try expect(count == 8);
+    try expectEqual(8, count);
 }
 
 // test
diff --git a/doc/langref/test_functions.zig b/doc/langref/test_functions.zig
index 7b70961ab30b717bca68c097b5718947a787bb31..e86183ad501b7794434795b686764f4166979564 100644
--- a/doc/langref/test_functions.zig
+++ b/doc/langref/test_functions.zig
@@ -1,7 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const native_arch = builtin.cpu.arch;
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 // Functions are declared like this
 fn add(a: i8, b: i8) i8 {
@@ -57,8 +57,8 @@ fn doOp(fnCall: Call2Op, op1: i8, op2: i8) i8 {
 }
 
 test "function" {
-    try expect(doOp(add, 5, 6) == 11);
-    try expect(doOp(sub2, 5, 6) == -1);
+    try expectEqual(11, doOp(add, 5, 6));
+    try expectEqual(-1, doOp(sub2, 5, 6));
 }
 
 // test
diff --git a/doc/langref/test_global_assembly.zig b/doc/langref/test_global_assembly.zig
index a5d5f3ca5f13ecc72866a8f1637a036b4df6f9a8..b7cc6d466b7485e1902d2493131a01c2efca2eb4 100644
--- a/doc/langref/test_global_assembly.zig
+++ b/doc/langref/test_global_assembly.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 comptime {
     asm (
@@ -14,7 +14,7 @@ comptime {
 extern fn my_func(a: i32, b: i32) i32;
 
 test "global assembly" {
-    try expect(my_func(12, 34) == 46);
+    try expectEqual(46, my_func(12, 34));
 }
 
 // test
diff --git a/doc/langref/test_if.zig b/doc/langref/test_if.zig
index 4ea6e66377d88de39889e74a6bd37d40f820fdca..61dfcaa04d0ef9d60b7c56a4033980a9329240db 100644
--- a/doc/langref/test_if.zig
+++ b/doc/langref/test_if.zig
@@ -4,13 +4,14 @@
 // * anyerror!T
 
 const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "if expression" {
     // If expressions are used instead of a ternary expression.
     const a: u32 = 5;
     const b: u32 = 4;
     const result = if (a != b) 47 else 3089;
-    try expect(result == 47);
+    try expectEqual(result, 47);
 }
 
 test "if boolean" {
@@ -32,7 +33,7 @@ test "if error union" {
 
     const a: anyerror!u32 = 0;
     if (a) |value| {
-        try expect(value == 0);
+        try expectEqual(value, 0);
     } else |err| {
         _ = err;
         unreachable;
@@ -43,17 +44,17 @@ test "if error union" {
         _ = value;
         unreachable;
     } else |err| {
-        try expect(err == error.BadValue);
+        try expectEqual(err, error.BadValue);
     }
 
     // The else and |err| capture is strictly required.
     if (a) |value| {
-        try expect(value == 0);
+        try expectEqual(value, 0);
     } else |_| {}
 
     // To check only the error value, use an empty block expression.
     if (b) |_| {} else |err| {
-        try expect(err == error.BadValue);
+        try expectEqual(err, error.BadValue);
     }
 
     // Access the value by reference using a pointer capture.
@@ -65,7 +66,7 @@ test "if error union" {
     }
 
     if (c) |value| {
-        try expect(value == 9);
+        try expectEqual(value, 9);
     } else |_| {
         unreachable;
     }
diff --git a/doc/langref/test_if_optionals.zig b/doc/langref/test_if_optionals.zig
index e19d181c787aa1dce5061e8c419c52e2a9848848..fef9ae3b62fba0090cf93ca20c5d106ebb5b548b 100644
--- a/doc/langref/test_if_optionals.zig
+++ b/doc/langref/test_if_optionals.zig
@@ -1,11 +1,12 @@
 const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "if optional" {
     // If expressions test for null.
 
     const a: ?u32 = 0;
     if (a) |value| {
-        try expect(value == 0);
+        try expectEqual(0, value);
     } else {
         unreachable;
     }
@@ -19,7 +20,7 @@ test "if optional" {
 
     // The else is not required.
     if (a) |value| {
-        try expect(value == 0);
+        try expectEqual(0, value);
     }
 
     // To test against null only, use the binary equality operator.
@@ -34,7 +35,7 @@ test "if optional" {
     }
 
     if (c) |value| {
-        try expect(value == 2);
+        try expectEqual(2, value);
     } else {
         unreachable;
     }
@@ -46,7 +47,7 @@ test "if error union with optional" {
 
     const a: anyerror!?u32 = 0;
     if (a) |optional_value| {
-        try expect(optional_value.? == 0);
+        try expectEqual(0, optional_value.?);
     } else |err| {
         _ = err;
         unreachable;
@@ -54,7 +55,7 @@ test "if error union with optional" {
 
     const b: anyerror!?u32 = null;
     if (b) |optional_value| {
-        try expect(optional_value == null);
+        try expectEqual(null, optional_value);
     } else |_| {
         unreachable;
     }
@@ -64,7 +65,7 @@ test "if error union with optional" {
         _ = optional_value;
         unreachable;
     } else |err| {
-        try expect(err == error.BadValue);
+        try expectEqual(error.BadValue, err);
     }
 
     // Access the value by reference by using a pointer capture each time.
@@ -78,7 +79,7 @@ test "if error union with optional" {
     }
 
     if (d) |optional_value| {
-        try expect(optional_value.? == 9);
+        try expectEqual(9, optional_value.?);
     } else |_| {
         unreachable;
     }
diff --git a/doc/langref/test_incorrect_pointer_alignment.zig b/doc/langref/test_incorrect_pointer_alignment.zig
index d404b330fb4f9d249a090b63363b7770fc3fb210..daa583e6ba887875750de8c1aa8967dc123d704d 100644
--- a/doc/langref/test_incorrect_pointer_alignment.zig
+++ b/doc/langref/test_incorrect_pointer_alignment.zig
@@ -3,7 +3,7 @@ const std = @import("std");
 test "pointer alignment safety" {
     var array align(4) = [_]u32{ 0x11111111, 0x11111111 };
     const bytes = std.mem.sliceAsBytes(array[0..]);
-    try std.testing.expect(foo(bytes) == 0x11111111);
+    try std.testing.expectEqual(0x11111111, foo(bytes));
 }
 fn foo(bytes: []u8) u32 {
     const slice4 = bytes[1..5];
diff --git a/doc/langref/test_inline_else.zig b/doc/langref/test_inline_else.zig
index e535115935dec336d3c1ee1a11c1ac3147551956..8972bd8c6b25f3f4bb3d9f99dfe23acda391df06 100644
--- a/doc/langref/test_inline_else.zig
+++ b/doc/langref/test_inline_else.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const SliceTypeA = extern struct {
     len: usize,
@@ -42,8 +42,8 @@ fn withSwitch(any: AnySlice) usize {
 
 test "inline for and inline else similarity" {
     const any = AnySlice{ .c = "hello" };
-    try expect(withFor(any) == 5);
-    try expect(withSwitch(any) == 5);
+    try expectEqual(5, withFor(any));
+    try expectEqual(5, withSwitch(any));
 }
 
 // test
diff --git a/doc/langref/test_inline_for.zig b/doc/langref/test_inline_for.zig
index fbf75de2eac912a42ae7ede07da46e615d9e1c72..4bc35b8043cb7e74dd5bcb12839741cb9342f4a0 100644
--- a/doc/langref/test_inline_for.zig
+++ b/doc/langref/test_inline_for.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "inline for loop" {
     const nums = [_]i32{ 2, 4, 6 };
@@ -12,7 +12,7 @@ test "inline for loop" {
         };
         sum += typeNameLength(T);
     }
-    try expect(sum == 9);
+    try expectEqual(9, sum);
 }
 
 fn typeNameLength(comptime T: type) usize {
diff --git a/doc/langref/test_inline_switch_union_tag.zig b/doc/langref/test_inline_switch_union_tag.zig
index dcefd4b0a1902d8fb12e52b47b9ea3b68745ab84..4fe0147c81d673e94846a002319f850debf06e19 100644
--- a/doc/langref/test_inline_switch_union_tag.zig
+++ b/doc/langref/test_inline_switch_union_tag.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const U = union(enum) {
     a: u32,
@@ -21,7 +21,7 @@ fn getNum(u: U) u32 {
 
 test "test" {
     const u = U{ .b = 42 };
-    try expect(getNum(u) == 42);
+    try expectEqual(42, getNum(u));
 }
 
 // test
diff --git a/doc/langref/test_inline_while.zig b/doc/langref/test_inline_while.zig
index 3422b647e90813cb6279ba0a2df9006253cb14fb..5cc716652946a1423c6720305cf6cc922f95953b 100644
--- a/doc/langref/test_inline_while.zig
+++ b/doc/langref/test_inline_while.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "inline while loop" {
     comptime var i = 0;
@@ -12,7 +12,7 @@ test "inline while loop" {
         };
         sum += typeNameLength(T);
     }
-    try expect(sum == 9);
+    try expectEqual(9, sum);
 }
 
 fn typeNameLength(comptime T: type) usize {
diff --git a/doc/langref/test_integer_pointer_conversion.zig b/doc/langref/test_integer_pointer_conversion.zig
index 98653cc7e250f2853b63d8ad57ba145989b1eeb7..f2c67f871927fbed1dd2022fa1e4eaecf7b718ad 100644
--- a/doc/langref/test_integer_pointer_conversion.zig
+++ b/doc/langref/test_integer_pointer_conversion.zig
@@ -1,10 +1,10 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "@intFromPtr and @ptrFromInt" {
     const ptr: *i32 = @ptrFromInt(0xdeadbee0);
     const addr = @intFromPtr(ptr);
-    try expect(@TypeOf(addr) == usize);
-    try expect(addr == 0xdeadbee0);
+    try expectEqual(usize, @TypeOf(addr));
+    try expectEqual(0xdeadbee0, addr);
 }
 
 // test
diff --git a/doc/langref/test_integer_widening.zig b/doc/langref/test_integer_widening.zig
index 8b5b5fdb88f390f444034f0e4736bb0f36c13d33..08627d999f59a0feb1e3c2b30fa95be8db157ff8 100644
--- a/doc/langref/test_integer_widening.zig
+++ b/doc/langref/test_integer_widening.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 const mem = std.mem;
 
 test "integer widening" {
@@ -10,13 +10,13 @@ test "integer widening" {
     const d: u64 = c;
     const e: u64 = d;
     const f: u128 = e;
-    try expect(f == a);
+    try expectEqual(f, a);
 }
 
 test "implicit unsigned integer to signed integer" {
     const a: u8 = 250;
     const b: i16 = a;
-    try expect(b == 250);
+    try expectEqual(250, b);
 }
 
 test "float widening" {
@@ -24,7 +24,7 @@ test "float widening" {
     const b: f32 = a;
     const c: f64 = b;
     const d: f128 = c;
-    try expect(d == a);
+    try expectEqual(d, a);
 }
 
 // test
diff --git a/doc/langref/test_labeled_break.zig b/doc/langref/test_labeled_break.zig
index 0310b997e3a7dda483d7688531c4bf94b039b649..52a902d358c4267d749f69458270f9c331a6eb3f 100644
--- a/doc/langref/test_labeled_break.zig
+++ b/doc/langref/test_labeled_break.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "labeled break from labeled block expression" {
     var y: i32 = 123;
@@ -8,8 +8,8 @@ test "labeled break from labeled block expression" {
         y += 1;
         break :blk y;
     };
-    try expect(x == 124);
-    try expect(y == 124);
+    try expectEqual(124, x);
+    try expectEqual(124, y);
 }
 
 // test
diff --git a/doc/langref/test_misaligned_pointer.zig b/doc/langref/test_misaligned_pointer.zig
index 11795ce090558454698cb8a01b8883c7313cdf74..b635d87c5925b8c53c101719720bd9e1f3305b5b 100644
--- a/doc/langref/test_misaligned_pointer.zig
+++ b/doc/langref/test_misaligned_pointer.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const BitField = packed struct {
     a: u3,
@@ -14,7 +14,7 @@ var bit_field = BitField{
 };
 
 test "pointer to non-byte-aligned field" {
-    try expect(bar(&bit_field.b) == 2);
+    try expectEqual(2, bar(&bit_field.b));
 }
 
 fn bar(x: *const u3) u3 {
diff --git a/doc/langref/test_multidimensional_arrays.zig b/doc/langref/test_multidimensional_arrays.zig
index c88e8cb16a5275b5b201efb48d803b0d98ed2335..6c7fefcaea28c9c1d3c1d51ab72d04e333546ec8 100644
--- a/doc/langref/test_multidimensional_arrays.zig
+++ b/doc/langref/test_multidimensional_arrays.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 const mat4x5 = [4][5]f32{
@@ -13,20 +12,20 @@ test "multidimensional arrays" {
     try expectEqual(mat4x5[1], [_]f32{ 0.0, 1.0, 0.0, 1.0, 0.0 });
 
     // Access the 2D array by indexing the outer array, and then the inner array.
-    try expect(mat4x5[3][4] == 9.9);
+    try expectEqual(9.9, mat4x5[3][4]);
 
     // Here we iterate with for loops.
     for (mat4x5, 0..) |row, row_index| {
         for (row, 0..) |cell, column_index| {
             if (row_index == column_index) {
-                try expect(cell == 1.0);
+                try expectEqual(1.0, cell);
             }
         }
     }
 
     // Initialize a multidimensional array to zeros.
     const all_zero: [4][5]f32 = .{.{0} ** 5} ** 4;
-    try expect(all_zero[0][0] == 0);
+    try expectEqual(0, all_zero[0][0]);
 }
 
 // test
diff --git a/doc/langref/test_namespaced_container_level_variable.zig b/doc/langref/test_namespaced_container_level_variable.zig
index 22f56d7d1353cf5e3e7f7e29c154baeefd558d3d..f35aa90d8ec7fcc5f3b5ae35995772bb0b713e09 100644
--- a/doc/langref/test_namespaced_container_level_variable.zig
+++ b/doc/langref/test_namespaced_container_level_variable.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "namespaced container level variable" {
-    try expect(foo() == 1235);
-    try expect(foo() == 1236);
+    try expectEqual(1235, foo());
+    try expectEqual(1236, foo());
 }
 
 const S = struct {
diff --git a/doc/langref/test_noreturn_from_exit.zig b/doc/langref/test_noreturn_from_exit.zig
index 4c5277d2e6eeb9858bbd3d34ffa3ae7f903e7f66..22ea8b4f491f5f01342af8ddb8a8324684a24384 100644
--- a/doc/langref/test_noreturn_from_exit.zig
+++ b/doc/langref/test_noreturn_from_exit.zig
@@ -1,14 +1,14 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const native_arch = builtin.cpu.arch;
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const WINAPI: std.builtin.CallingConvention = if (native_arch == .x86) .{ .x86_stdcall = .{} } else .c;
 extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(WINAPI) noreturn;
 
 test "foo" {
     const value = bar() catch ExitProcess(1);
-    try expect(value == 1234);
+    try expectEqual(1234, value);
 }
 
 fn bar() anyerror!u32 {
diff --git a/doc/langref/test_null_terminated_array.zig b/doc/langref/test_null_terminated_array.zig
index c89ed59bbd05f83567973a82ffaecba3103ae8ef..53ba0d0c6547ca0793e372d0e9808c9572567eec 100644
--- a/doc/langref/test_null_terminated_array.zig
+++ b/doc/langref/test_null_terminated_array.zig
@@ -1,21 +1,21 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "0-terminated sentinel array" {
     const array = [_:0]u8{ 1, 2, 3, 4 };
 
-    try expect(@TypeOf(array) == [4:0]u8);
-    try expect(array.len == 4);
-    try expect(array[4] == 0);
+    try expectEqual([4:0]u8, @TypeOf(array));
+    try expectEqual(4, array.len);
+    try expectEqual(0, array[4]);
 }
 
 test "extra 0s in 0-terminated sentinel array" {
     // The sentinel value may appear earlier, but does not influence the compile-time 'len'.
     const array = [_:0]u8{ 1, 0, 0, 4 };
 
-    try expect(@TypeOf(array) == [4:0]u8);
-    try expect(array.len == 4);
-    try expect(array[4] == 0);
+    try expectEqual([4:0]u8, @TypeOf(array));
+    try expectEqual(4, array.len);
+    try expectEqual(0, array[4]);
 }
 
 // test
diff --git a/doc/langref/test_null_terminated_slice.zig b/doc/langref/test_null_terminated_slice.zig
index 9f14f9bc1d6f3c466a5785cb6331ca4ad507a438..44fad5671d0ff1cba0e61a19861c3f2fa2df5bc9 100644
--- a/doc/langref/test_null_terminated_slice.zig
+++ b/doc/langref/test_null_terminated_slice.zig
@@ -1,11 +1,11 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "0-terminated slice" {
     const slice: [:0]const u8 = "hello";
 
-    try expect(slice.len == 5);
-    try expect(slice[5] == 0);
+    try expectEqual(5, slice.len);
+    try expectEqual(0, slice[5]);
 }
 
 // test
diff --git a/doc/langref/test_null_terminated_slicing.zig b/doc/langref/test_null_terminated_slicing.zig
index e5a248bed388750efd18a3e80c8a078d1e22a0dc..b1d5263976732223516bdf62a37805b4b28b4e58 100644
--- a/doc/langref/test_null_terminated_slicing.zig
+++ b/doc/langref/test_null_terminated_slicing.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "0-terminated slicing" {
     var array = [_]u8{ 3, 2, 1, 0, 3, 2, 1, 0 };
@@ -7,8 +7,8 @@ test "0-terminated slicing" {
     _ = &runtime_length;
     const slice = array[0..runtime_length :0];
 
-    try expect(@TypeOf(slice) == [:0]u8);
-    try expect(slice.len == 3);
+    try expectEqual([:0]u8, @TypeOf(slice));
+    try expectEqual(3, slice.len);
 }
 
 // test
diff --git a/doc/langref/test_optional_pointer.zig b/doc/langref/test_optional_pointer.zig
index acad240fd22de35492a4cb3a6b1152045cc444df..dc3d3bbfda76d3fa67db485a17eafc89b23592d6 100644
--- a/doc/langref/test_optional_pointer.zig
+++ b/doc/langref/test_optional_pointer.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "optional pointers" {
     // Pointers cannot be null. If you want a null pointer, use the optional
@@ -8,11 +8,11 @@ test "optional pointers" {
     var x: i32 = 1;
     ptr = &x;
 
-    try expect(ptr.?.* == 1);
+    try expectEqual(1, ptr.?.*);
 
     // Optional pointers are the same size as normal pointers, because pointer
     // value 0 is used as the null value.
-    try expect(@sizeOf(?*i32) == @sizeOf(*i32));
+    try expectEqual(@sizeOf(?*i32), @sizeOf(*i32));
 }
 
 // test
diff --git a/doc/langref/test_optional_type.zig b/doc/langref/test_optional_type.zig
index 594198b49e302fea30de82d4fd3929e8ec56efa1..97a87c21f2064ba65b29f3542bb3b98f3fbbff56 100644
--- a/doc/langref/test_optional_type.zig
+++ b/doc/langref/test_optional_type.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "optional type" {
     // Declare an optional and coerce from null:
@@ -8,7 +8,7 @@ test "optional type" {
     foo = 1234;
 
     // Use compile-time reflection to access the child type of the optional:
-    try comptime expect(@typeInfo(@TypeOf(foo)).optional.child == i32);
+    try comptime expectEqual(i32, @typeInfo(@TypeOf(foo)).optional.child);
 }
 
 // test
diff --git a/doc/langref/test_overaligned_packed_struct.zig b/doc/langref/test_overaligned_packed_struct.zig
index 8bf52b32970beb3b5bafd705b0601f629ca6c496..7c67800192bf953c0d4a2bd8e6ab0b5701e4928f 100644
--- a/doc/langref/test_overaligned_packed_struct.zig
+++ b/doc/langref/test_overaligned_packed_struct.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const S = packed struct {
     a: u32,
@@ -9,7 +9,7 @@ test "overaligned pointer to packed struct" {
     var foo: S align(4) = .{ .a = 1, .b = 2 };
     const ptr: *align(4) S = &foo;
     const ptr_to_b = &ptr.b;
-    try expect(ptr_to_b.* == 2);
+    try expectEqual(2, ptr_to_b.*);
 }
 
 // test
diff --git a/doc/langref/test_packed_struct_equality.zig b/doc/langref/test_packed_struct_equality.zig
index d1c755af195fda809467c423b1adaf05aeb43460..1449d05652c6e64b77564b6c7c299a6a842221d8 100644
--- a/doc/langref/test_packed_struct_equality.zig
+++ b/doc/langref/test_packed_struct_equality.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "packed struct equality" {
     const S = packed struct {
@@ -8,7 +8,7 @@ test "packed struct equality" {
     };
     const x: S = .{ .a = 1, .b = 2 };
     const y: S = .{ .b = 2, .a = 1 };
-    try expect(x == y);
+    try expectEqual(x, y);
 }
 
 // test
diff --git a/doc/langref/test_packed_struct_field_address.zig b/doc/langref/test_packed_struct_field_address.zig
index 979c0377f6ac942e2d0fde548da2f03ec4ec1212..756d36c3a952b51a6e9ce0f1344477c8e72c1aca 100644
--- a/doc/langref/test_packed_struct_field_address.zig
+++ b/doc/langref/test_packed_struct_field_address.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const BitField = packed struct {
     a: u3,
@@ -14,8 +14,8 @@ var bit_field = BitField{
 };
 
 test "pointers of sub-byte-aligned fields share addresses" {
-    try expect(@intFromPtr(&bit_field.a) == @intFromPtr(&bit_field.b));
-    try expect(@intFromPtr(&bit_field.a) == @intFromPtr(&bit_field.c));
+    try expectEqual(@intFromPtr(&bit_field.a), @intFromPtr(&bit_field.b));
+    try expectEqual(@intFromPtr(&bit_field.a), @intFromPtr(&bit_field.c));
 }
 
 // test
diff --git a/doc/langref/test_packed_structs.zig b/doc/langref/test_packed_structs.zig
index da1f259d5e780da221c214b01b9a31ad63578bce..7e46f852a0a5cfda15a4432d5d3f8ebd710f315f 100644
--- a/doc/langref/test_packed_structs.zig
+++ b/doc/langref/test_packed_structs.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 const native_endian = @import("builtin").target.cpu.arch.endian();
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Full = packed struct {
     number: u16,
@@ -17,23 +17,23 @@ test "@bitCast between packed structs" {
 }
 
 fn doTheTest() !void {
-    try expect(@sizeOf(Full) == 2);
-    try expect(@sizeOf(Divided) == 2);
+    try expectEqual(2, @sizeOf(Full));
+    try expectEqual(2, @sizeOf(Divided));
     const full = Full{ .number = 0x1234 };
     const divided: Divided = @bitCast(full);
-    try expect(divided.half1 == 0x34);
-    try expect(divided.quarter3 == 0x2);
-    try expect(divided.quarter4 == 0x1);
+    try expectEqual(0x34, divided.half1);
+    try expectEqual(0x2, divided.quarter3);
+    try expectEqual(0x1, divided.quarter4);
 
     const ordered: [2]u8 = @bitCast(full);
     switch (native_endian) {
         .big => {
-            try expect(ordered[0] == 0x12);
-            try expect(ordered[1] == 0x34);
+            try expectEqual(0x12, ordered[0]);
+            try expectEqual(0x34, ordered[1]);
         },
         .little => {
-            try expect(ordered[0] == 0x34);
-            try expect(ordered[1] == 0x12);
+            try expectEqual(0x34, ordered[0]);
+            try expectEqual(0x12, ordered[1]);
         },
     }
 }
diff --git a/doc/langref/test_pass_by_reference_or_value.zig b/doc/langref/test_pass_by_reference_or_value.zig
index 0bde07747ea99955ec22e6b50bc51d0b11518375..e35ccf8ce4d35600ff37e3091c194ce1f92c296d 100644
--- a/doc/langref/test_pass_by_reference_or_value.zig
+++ b/doc/langref/test_pass_by_reference_or_value.zig
@@ -11,10 +11,10 @@ fn foo(point: Point) i32 {
     return point.x + point.y;
 }
 
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "pass struct to function" {
-    try expect(foo(Point{ .x = 1, .y = 2 }) == 3);
+    try expectEqual(3, foo(Point{ .x = 1, .y = 2 }));
 }
 
 // test
diff --git a/doc/langref/test_peer_type_resolution.zig b/doc/langref/test_peer_type_resolution.zig
index ad0b9f35cbe7d6b27a2a8ec28e04bf38151f87ba..9bbac881e3e24576335a448e2661a5dfbb887c5b 100644
--- a/doc/langref/test_peer_type_resolution.zig
+++ b/doc/langref/test_peer_type_resolution.zig
@@ -1,20 +1,20 @@
 const std = @import("std");
-const expect = std.testing.expect;
-const mem = std.mem;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
 
 test "peer resolve int widening" {
     const a: i8 = 12;
     const b: i16 = 34;
     const c = a + b;
-    try expect(c == 46);
-    try expect(@TypeOf(c) == i16);
+    try expectEqual(46, c);
+    try expectEqual(i16, @TypeOf(c));
 }
 
 test "peer resolve arrays of different size to const slice" {
-    try expect(mem.eql(u8, boolToStr(true), "true"));
-    try expect(mem.eql(u8, boolToStr(false), "false"));
-    try comptime expect(mem.eql(u8, boolToStr(true), "true"));
-    try comptime expect(mem.eql(u8, boolToStr(false), "false"));
+    try expectEqualStrings("true", boolToStr(true));
+    try expectEqualStrings("false", boolToStr(false));
+    try comptime expectEqualStrings("true", boolToStr(true));
+    try comptime expectEqualStrings("false", boolToStr(false));
 }
 fn boolToStr(b: bool) []const u8 {
     return if (b) "true" else "false";
@@ -27,16 +27,16 @@ test "peer resolve array and const slice" {
 fn testPeerResolveArrayConstSlice(b: bool) !void {
     const value1 = if (b) "aoeu" else @as([]const u8, "zz");
     const value2 = if (b) @as([]const u8, "zz") else "aoeu";
-    try expect(mem.eql(u8, value1, "aoeu"));
-    try expect(mem.eql(u8, value2, "zz"));
+    try expectEqualStrings("aoeu", value1);
+    try expectEqualStrings("zz", value2);
 }
 
 test "peer type resolution: ?T and T" {
-    try expect(peerTypeTAndOptionalT(true, false).? == 0);
-    try expect(peerTypeTAndOptionalT(false, false).? == 3);
+    try expectEqual(0, peerTypeTAndOptionalT(true, false).?);
+    try expectEqual(3, peerTypeTAndOptionalT(false, false).?);
     comptime {
-        try expect(peerTypeTAndOptionalT(true, false).? == 0);
-        try expect(peerTypeTAndOptionalT(false, false).? == 3);
+        try expectEqual(0, peerTypeTAndOptionalT(true, false).?);
+        try expectEqual(3, peerTypeTAndOptionalT(false, false).?);
     }
 }
 fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
@@ -48,11 +48,11 @@ fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
 }
 
 test "peer type resolution: *[0]u8 and []const u8" {
-    try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
-    try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
+    try expectEqual(0, peerTypeEmptyArrayAndSlice(true, "hi").len);
+    try expectEqual(1, peerTypeEmptyArrayAndSlice(false, "hi").len);
     comptime {
-        try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
-        try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
+        try expectEqual(0, peerTypeEmptyArrayAndSlice(true, "hi").len);
+        try expectEqual(1, peerTypeEmptyArrayAndSlice(false, "hi").len);
     }
 }
 fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
@@ -66,14 +66,14 @@ test "peer type resolution: *[0]u8, []const u8, and anyerror![]u8" {
     {
         var data = "hi".*;
         const slice = data[0..];
-        try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
-        try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
+        try expectEqual(0, (try peerTypeEmptyArrayAndSliceAndError(true, slice)).len);
+        try expectEqual(1, (try peerTypeEmptyArrayAndSliceAndError(false, slice)).len);
     }
     comptime {
         var data = "hi".*;
         const slice = data[0..];
-        try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
-        try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
+        try expectEqual(0, (try peerTypeEmptyArrayAndSliceAndError(true, slice)).len);
+        try expectEqual(1, (try peerTypeEmptyArrayAndSliceAndError(false, slice)).len);
     }
 }
 fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
@@ -87,8 +87,8 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
 test "peer type resolution: *const T and ?*T" {
     const a: *const usize = @ptrFromInt(0x123456780);
     const b: ?*usize = @ptrFromInt(0x123456780);
-    try expect(a == b);
-    try expect(b == a);
+    try expectEqual(a, b);
+    try expectEqual(b, a);
 }
 
 test "peer type resolution: error union switch" {
@@ -104,7 +104,7 @@ test "peer type resolution: error union switch" {
         error.B => 1,
         error.C => null,
     };
-    try expect(@TypeOf(b) == ?u32);
+    try expectEqual(?u32, @TypeOf(b));
 
     // The non-error and error cases are only peers if the error case is just a switch expression;
     // the pattern `x catch |err| blk: { switch (err) {...} }` does not consider the unwrapped `x`
@@ -114,7 +114,7 @@ test "peer type resolution: error union switch" {
         error.B => 1,
         error.C => null,
     };
-    try expect(@TypeOf(c) == ?u32);
+    try expectEqual(?u32, @TypeOf(c));
 }
 
 // test
diff --git a/doc/langref/test_pointer_arithmetic.zig b/doc/langref/test_pointer_arithmetic.zig
index 21574285024e648894f7ee19b80759ab9c0d2427..457db08ba26e77f0b6d28dbc1fb92a7a237dac5f 100644
--- a/doc/langref/test_pointer_arithmetic.zig
+++ b/doc/langref/test_pointer_arithmetic.zig
@@ -1,19 +1,19 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "pointer arithmetic with many-item pointer" {
     const array = [_]i32{ 1, 2, 3, 4 };
     var ptr: [*]const i32 = &array;
 
-    try expect(ptr[0] == 1);
+    try expectEqual(1, ptr[0]);
     ptr += 1;
-    try expect(ptr[0] == 2);
+    try expectEqual(2, ptr[0]);
 
     // slicing a many-item pointer without an end is equivalent to
     // pointer arithmetic: `ptr[start..] == ptr + start`
-    try expect(ptr[1..] == ptr + 1);
+    try expectEqual(ptr[1..], ptr + 1);
 
     // subtraction between any two pointers except slices based on element size is supported
-    try expect(&ptr[1] - &ptr[0] == 1);
+    try expectEqual(1, &ptr[1] - &ptr[0]);
 }
 
 test "pointer arithmetic with slices" {
@@ -22,14 +22,14 @@ test "pointer arithmetic with slices" {
     _ = &length; // suppress 'var is never mutated' error
     var slice = array[length..array.len];
 
-    try expect(slice[0] == 1);
-    try expect(slice.len == 4);
+    try expectEqual(1, slice[0]);
+    try expectEqual(4, slice.len);
 
     slice.ptr += 1;
     // now the slice is in an bad state since len has not been updated
 
-    try expect(slice[0] == 2);
-    try expect(slice.len == 4);
+    try expectEqual(2, slice[0]);
+    try expectEqual(4, slice.len);
 }
 
 // test
diff --git a/doc/langref/test_pointer_casting.zig b/doc/langref/test_pointer_casting.zig
index 359d1dc8389c3646b15d92393ed8f45fd198d14a..0a3fde2efe6675c1d142f97ccc67ffdce56bee22 100644
--- a/doc/langref/test_pointer_casting.zig
+++ b/doc/langref/test_pointer_casting.zig
@@ -1,23 +1,23 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "pointer casting" {
     const bytes align(@alignOf(u32)) = [_]u8{ 0x12, 0x12, 0x12, 0x12 };
     const u32_ptr: *const u32 = @ptrCast(&bytes);
-    try expect(u32_ptr.* == 0x12121212);
+    try expectEqual(0x12121212, u32_ptr.*);
 
     // Even this example is contrived - there are better ways to do the above than
     // pointer casting. For example, using a slice narrowing cast:
     const u32_value = std.mem.bytesAsSlice(u32, bytes[0..])[0];
-    try expect(u32_value == 0x12121212);
+    try expectEqual(0x12121212, u32_value);
 
     // And even another way, the most straightforward way to do it:
-    try expect(@as(u32, @bitCast(bytes)) == 0x12121212);
+    try expectEqual(0x12121212, @as(u32, @bitCast(bytes)));
 }
 
 test "pointer child type" {
     // pointer types have a `child` field which tells you the type they point to.
-    try expect(@typeInfo(*u32).pointer.child == u32);
+    try expectEqual(u32, @typeInfo(*u32).pointer.child);
 }
 
 // test
diff --git a/doc/langref/test_pointer_coerce_const_optional.zig b/doc/langref/test_pointer_coerce_const_optional.zig
index f955820593f153abf4f437cb621c37f1263bd7f7..fccb4806b4601d3907485a53924b2d68be758a38 100644
--- a/doc/langref/test_pointer_coerce_const_optional.zig
+++ b/doc/langref/test_pointer_coerce_const_optional.zig
@@ -1,11 +1,11 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqualStrings = std.testing.expectEqualStrings;
 const mem = std.mem;
 
 test "cast *[1][*:0]const u8 to []const ?[*:0]const u8" {
     const window_name = [1][*:0]const u8{"window name"};
     const x: []const ?[*:0]const u8 = &window_name;
-    try expect(mem.eql(u8, mem.span(x[0].?), "window name"));
+    try expectEqualStrings("window name", mem.span(x[0].?));
 }
 
 // test
diff --git a/doc/langref/test_pointer_to_non-byte_aligned_field.zig b/doc/langref/test_pointer_to_non-byte_aligned_field.zig
index 336337caeee9e621808e27280cf1c38d7b71f132..fcf45e74f462a8ba126abdd6b25420576aa097e8 100644
--- a/doc/langref/test_pointer_to_non-byte_aligned_field.zig
+++ b/doc/langref/test_pointer_to_non-byte_aligned_field.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const BitField = packed struct {
     a: u3,
@@ -15,7 +15,7 @@ var foo = BitField{
 
 test "pointer to non-byte-aligned field" {
     const ptr = &foo.b;
-    try expect(ptr.* == 2);
+    try expectEqual(2, ptr.*);
 }
 
 // test
diff --git a/doc/langref/test_reduce_builtin.zig b/doc/langref/test_reduce_builtin.zig
index 82b78b838028b53e7a18ae73159d1b9061b0535e..b411b05eeab622d37ff12d3145310f29794edee9 100644
--- a/doc/langref/test_reduce_builtin.zig
+++ b/doc/langref/test_reduce_builtin.zig
@@ -1,15 +1,15 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "vector @reduce" {
     const V = @Vector(4, i32);
     const value = V{ 1, -1, 1, -1 };
     const result = value > @as(V, @splat(0));
     // result is { true, false, true, false };
-    try comptime expect(@TypeOf(result) == @Vector(4, bool));
+    try comptime expectEqual(@Vector(4, bool), @TypeOf(result));
     const is_all_true = @reduce(.And, result);
-    try comptime expect(@TypeOf(is_all_true) == bool);
-    try expect(is_all_true == false);
+    try comptime expectEqual(bool, @TypeOf(is_all_true));
+    try expectEqual(false, is_all_true);
 }
 
 // test
diff --git a/doc/langref/test_round_builtin.zig b/doc/langref/test_round_builtin.zig
index a317ca79f03d9a87ecdb98a6501e60fbcbdcb3dc..e28b7d5dab798d90a7761c4ce7d5907a462ff2cf 100644
--- a/doc/langref/test_round_builtin.zig
+++ b/doc/langref/test_round_builtin.zig
@@ -1,10 +1,10 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "@round" {
-    try expect(@round(1.4) == 1);
-    try expect(@round(1.5) == 2);
-    try expect(@round(-1.4) == -1);
-    try expect(@round(-2.5) == -3);
+    try expectEqual(1, @round(1.4));
+    try expectEqual(2, @round(1.5));
+    try expectEqual(-1, @round(-1.4));
+    try expectEqual(-3, @round(-2.5));
 }
 
 // test
diff --git a/doc/langref/test_sentinel_mismatch.zig b/doc/langref/test_sentinel_mismatch.zig
index afa1fd295d6c2b38d0ee200aa0399d6838e82a89..df60680351358c1f0c2370cfc97fc86fbb560376 100644
--- a/doc/langref/test_sentinel_mismatch.zig
+++ b/doc/langref/test_sentinel_mismatch.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "sentinel mismatch" {
     var array = [_]u8{ 3, 2, 1, 0 };
diff --git a/doc/langref/test_shuffle_builtin.zig b/doc/langref/test_shuffle_builtin.zig
index c73d1bbfabe9938a5ddec8e80df5a7e5107d59bb..1b319d2f47e5e957a3d0f0bf109500d850a1bb43 100644
--- a/doc/langref/test_shuffle_builtin.zig
+++ b/doc/langref/test_shuffle_builtin.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqualStrings = std.testing.expectEqualStrings;
 
 test "vector @shuffle" {
     const a = @Vector(7, u8){ 'o', 'l', 'h', 'e', 'r', 'z', 'w' };
@@ -9,12 +9,12 @@ test "vector @shuffle" {
     // Notice that we can re-order, duplicate, or omit elements of the input vector
     const mask1 = @Vector(5, i32){ 2, 3, 1, 1, 0 };
     const res1: @Vector(5, u8) = @shuffle(u8, a, undefined, mask1);
-    try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello"));
+    try expectEqualStrings("hello", &@as([5]u8, res1));
 
     // Combining two vectors
     const mask2 = @Vector(6, i32){ -1, 0, 4, 1, -2, -3 };
     const res2: @Vector(6, u8) = @shuffle(u8, a, b, mask2);
-    try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!"));
+    try expectEqualStrings("world!", &@as([6]u8, res2));
 }
 
 // test
diff --git a/doc/langref/test_simple_union.zig b/doc/langref/test_simple_union.zig
index 899666de072bef27a0cb490f2d461e091a84d6cf..f257575adb4f58b4f3721a093a3d42f4da85eec0 100644
--- a/doc/langref/test_simple_union.zig
+++ b/doc/langref/test_simple_union.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Payload = union {
     int: i64,
@@ -8,9 +8,9 @@ const Payload = union {
 };
 test "simple union" {
     var payload = Payload{ .int = 1234 };
-    try expect(payload.int == 1234);
+    try expectEqual(1234, payload.int);
     payload = Payload{ .float = 12.34 };
-    try expect(payload.float == 12.34);
+    try expectEqual(12.34, payload.float);
 }
 
 // test
diff --git a/doc/langref/test_single_item_pointer.zig b/doc/langref/test_single_item_pointer.zig
index 79252b1fa0079ab05ce54e80c197e7a725500cb8..0171147d8241ced1c425139d9a4dcd6ae1c1d2bc 100644
--- a/doc/langref/test_single_item_pointer.zig
+++ b/doc/langref/test_single_item_pointer.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "address of syntax" {
     // Get the address of a variable:
@@ -6,17 +6,17 @@ test "address of syntax" {
     const x_ptr = &x;
 
     // Dereference a pointer:
-    try expect(x_ptr.* == 1234);
+    try expectEqual(1234, x_ptr.*);
 
     // When you get the address of a const variable, you get a const single-item pointer.
-    try expect(@TypeOf(x_ptr) == *const i32);
+    try expectEqual(*const i32, @TypeOf(x_ptr));
 
     // If you want to mutate the value, you'd need an address of a mutable variable:
     var y: i32 = 5678;
     const y_ptr = &y;
-    try expect(@TypeOf(y_ptr) == *i32);
+    try expectEqual(*i32, @TypeOf(y_ptr));
     y_ptr.* += 1;
-    try expect(y_ptr.* == 5679);
+    try expectEqual(5679, y_ptr.*);
 }
 
 test "pointer array access" {
@@ -25,11 +25,11 @@ test "pointer array access" {
     // does not support pointer arithmetic.
     var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     const ptr = &array[2];
-    try expect(@TypeOf(ptr) == *u8);
+    try expectEqual(*u8, @TypeOf(ptr));
 
-    try expect(array[2] == 3);
+    try expectEqual(3, array[2]);
     ptr.* += 1;
-    try expect(array[2] == 4);
+    try expectEqual(4, array[2]);
 }
 
 test "slice syntax" {
@@ -39,11 +39,11 @@ test "slice syntax" {
 
     // Convert to array pointer using slice syntax:
     const x_array_ptr = x_ptr[0..1];
-    try expect(@TypeOf(x_array_ptr) == *[1]i32);
+    try expectEqual(*[1]i32, @TypeOf(x_array_ptr));
 
     // Coerce to many-item pointer:
     const x_many_ptr: [*]i32 = x_array_ptr;
-    try expect(x_many_ptr[0] == 1234);
+    try expectEqual(1234, x_many_ptr[0]);
 }
 
 // test
diff --git a/doc/langref/test_slice_bounds.zig b/doc/langref/test_slice_bounds.zig
index 23022a2757e4a8eae7608d0fbe60a6cf93ac6abf..8de31a7d322e6b0e1171899796b422c22bd115f6 100644
--- a/doc/langref/test_slice_bounds.zig
+++ b/doc/langref/test_slice_bounds.zig
@@ -1,15 +1,15 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "pointer slicing" {
     var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     var start: usize = 2; // var to make it runtime-known
     _ = &start; // suppress 'var is never mutated' error
     const slice = array[start..4];
-    try expect(slice.len == 2);
+    try expectEqual(2, slice.len);
 
-    try expect(array[3] == 4);
+    try expectEqual(4, array[3]);
     slice[1] += 1;
-    try expect(array[3] == 5);
+    try expectEqual(5, array[3]);
 }
 
 // test
diff --git a/doc/langref/test_slices.zig b/doc/langref/test_slices.zig
index e1a51e4651ae57e72bfa492618ff7b5098aaa2ca..a5ac8cb9267065de3c73c5edf0326afeda6e890a 100644
--- a/doc/langref/test_slices.zig
+++ b/doc/langref/test_slices.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
-const expect = std.testing.expect;
-const mem = std.mem;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
 const fmt = std.fmt;
 
 test "using slices for strings" {
@@ -23,13 +23,13 @@ test "using slices for strings" {
     // Generally, you can use UTF-8 and not worry about whether something is a
     // string. If you don't need to deal with individual characters, no need
     // to decode.
-    try expect(mem.eql(u8, hello_world, "hello 世界"));
+    try expectEqualStrings("hello 世界", hello_world);
 }
 
 test "slice pointer" {
     var array: [10]u8 = undefined;
     const ptr = &array;
-    try expect(@TypeOf(ptr) == *[10]u8);
+    try expectEqual(*[10]u8, @TypeOf(ptr));
 
     // A pointer to an array can be sliced just like an array:
     var start: usize = 0;
@@ -37,16 +37,16 @@ test "slice pointer" {
     _ = .{ &start, &end };
     const slice = ptr[start..end];
     // The slice is mutable because we sliced a mutable pointer.
-    try expect(@TypeOf(slice) == []u8);
+    try expectEqual([]u8, @TypeOf(slice));
     slice[2] = 3;
-    try expect(array[2] == 3);
+    try expectEqual(3, array[2]);
 
     // Again, slicing with comptime-known indexes will produce another pointer
     // to an array:
     const ptr2 = slice[2..3];
-    try expect(ptr2.len == 1);
-    try expect(ptr2[0] == 3);
-    try expect(@TypeOf(ptr2) == *[1]u8);
+    try expectEqual(1, ptr2.len);
+    try expectEqual(3, ptr2[0]);
+    try expectEqual(*[1]u8, @TypeOf(ptr2));
 }
 
 // test
diff --git a/doc/langref/test_splat_builtin.zig b/doc/langref/test_splat_builtin.zig
index d11556b1a3f2d4392f311332903aeca14a20a356..d00240620e7dbc738e2ae3468f2059f1f9c8e9a9 100644
--- a/doc/langref/test_splat_builtin.zig
+++ b/doc/langref/test_splat_builtin.zig
@@ -1,16 +1,16 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqualSlices = std.testing.expectEqualSlices;
 
 test "vector @splat" {
     const scalar: u32 = 5;
     const result: @Vector(4, u32) = @splat(scalar);
-    try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
+    try expectEqualSlices(u32, &[_]u32{ 5, 5, 5, 5 }, &@as([4]u32, result));
 }
 
 test "array @splat" {
     const scalar: u32 = 5;
     const result: [4]u32 = @splat(scalar);
-    try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
+    try expectEqualSlices(u32, &[_]u32{ 5, 5, 5, 5 }, &@as([4]u32, result));
 }
 
 // test
diff --git a/doc/langref/test_src_builtin.zig b/doc/langref/test_src_builtin.zig
index 10199be68ef4ecf64292a9bddd92da281a2ee2fd..7286f8f5a8ca7bb9ce3ac93474b24f83db65935b 100644
--- a/doc/langref/test_src_builtin.zig
+++ b/doc/langref/test_src_builtin.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "@src" {
     try doTheTest();
@@ -8,8 +9,8 @@ test "@src" {
 fn doTheTest() !void {
     const src = @src();
 
-    try expect(src.line == 9);
-    try expect(src.column == 17);
+    try expectEqual(10, src.line);
+    try expectEqual(17, src.column);
     try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
     try expect(std.mem.endsWith(u8, src.file, "test_src_builtin.zig"));
 }
diff --git a/doc/langref/test_static_local_variable.zig b/doc/langref/test_static_local_variable.zig
index 4531a96a370e40bd8d2ba9a8064e32e9bc527fd8..58b4505be49cda320397633ed5a0de0b29934f17 100644
--- a/doc/langref/test_static_local_variable.zig
+++ b/doc/langref/test_static_local_variable.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "static local variable" {
-    try expect(foo() == 1235);
-    try expect(foo() == 1236);
+    try expectEqual(1235, foo());
+    try expectEqual(1236, foo());
 }
 
 fn foo() i32 {
diff --git a/doc/langref/test_struct_result.zig b/doc/langref/test_struct_result.zig
index cb8ecf067369a381235102eab2733d9dea7ac4b1..62b32ecf108a2fc46dd0222f7cf4be850a300093 100644
--- a/doc/langref/test_struct_result.zig
+++ b/doc/langref/test_struct_result.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Point = struct { x: i32, y: i32 };
 
@@ -8,8 +8,8 @@ test "anonymous struct literal" {
         .x = 13,
         .y = 67,
     };
-    try expect(pt.x == 13);
-    try expect(pt.y == 67);
+    try expectEqual(13, pt.x);
+    try expectEqual(67, pt.y);
 }
 
 // test
diff --git a/doc/langref/test_structs.zig b/doc/langref/test_structs.zig
index b62fd3578d936ff481a7be03de5c30629ed4f6c8..414dd8be48b4c3b2683e55a7c299f993f2802db6 100644
--- a/doc/langref/test_structs.zig
+++ b/doc/langref/test_structs.zig
@@ -34,12 +34,12 @@ const Vec3 = struct {
 test "dot product" {
     const v1 = Vec3.init(1.0, 0.0, 0.0);
     const v2 = Vec3.init(0.0, 1.0, 0.0);
-    try expect(v1.dot(v2) == 0.0);
+    try expectEqual(0.0, v1.dot(v2));
 
     // Other than being available to call with dot syntax, struct methods are
     // not special. You can reference them as any other declaration inside
     // the struct:
-    try expect(Vec3.dot(v1, v2) == 0.0);
+    try expectEqual(0.0, Vec3.dot(v1, v2));
 }
 
 // Structs can have declarations.
@@ -48,8 +48,8 @@ const Empty = struct {
     pub const PI = 3.14;
 };
 test "struct namespaced variable" {
-    try expect(Empty.PI == 3.14);
-    try expect(@sizeOf(Empty) == 0);
+    try expectEqual(3.14, Empty.PI);
+    try expectEqual(0, @sizeOf(Empty));
 
     // Empty structs can be instantiated the same as usual.
     const does_nothing: Empty = .{};
@@ -69,7 +69,7 @@ test "field parent pointer" {
         .y = 0.5678,
     };
     setYBasedOnX(&point.x, 0.9);
-    try expect(point.y == 0.9);
+    try expectEqual(0.9, point.y);
 }
 
 // Structs can be returned from functions.
@@ -89,19 +89,19 @@ fn LinkedList(comptime T: type) type {
 
 test "linked list" {
     // Functions called at compile-time are memoized.
-    try expect(LinkedList(i32) == LinkedList(i32));
+    try expectEqual(LinkedList(i32), LinkedList(i32));
 
     const list = LinkedList(i32){
         .first = null,
         .last = null,
         .len = 0,
     };
-    try expect(list.len == 0);
+    try expectEqual(0, list.len);
 
     // Since types are first class values you can instantiate the type
     // by assigning it to a variable:
     const ListOfInts = LinkedList(i32);
-    try expect(ListOfInts == LinkedList(i32));
+    try expectEqual(LinkedList(i32), ListOfInts);
 
     var node = ListOfInts.Node{
         .prev = null,
@@ -117,10 +117,10 @@ test "linked list" {
     // When using a pointer to a struct, fields can be accessed directly,
     // without explicitly dereferencing the pointer.
     // So you can do
-    try expect(list2.first.?.data == 1234);
-    // instead of try expect(list2.first.?.*.data == 1234);
+    try expectEqual(1234, list2.first.?.data);
+    // instead of try expectEqual(1234, list2.first.?.*.data);
 }
 
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 // test
diff --git a/doc/langref/test_switch.zig b/doc/langref/test_switch.zig
index 33fabbdfcda3029afb7540f8384aaaabceb6992e..d6e67c1587afe419e70fc54bc2e6aa6f55d61f28 100644
--- a/doc/langref/test_switch.zig
+++ b/doc/langref/test_switch.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "switch simple" {
     const a: u64 = 10;
@@ -40,7 +40,7 @@ test "switch simple" {
         else => 9,
     };
 
-    try expect(b == 1);
+    try expectEqual(1, b);
 }
 
 // Switch expressions can be used outside a function:
diff --git a/doc/langref/test_switch_modify_tagged_union.zig b/doc/langref/test_switch_modify_tagged_union.zig
index 96433900f0b33667df8180dc5371ff6fd45a3dd2..ba5cc5193e09971dd7b21860872eb31f8786260d 100644
--- a/doc/langref/test_switch_modify_tagged_union.zig
+++ b/doc/langref/test_switch_modify_tagged_union.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const ComplexTypeTag = enum {
     ok,
@@ -18,7 +18,7 @@ test "modify tagged union in switch" {
         ComplexTypeTag.not_ok => unreachable,
     }
 
-    try expect(c.ok == 43);
+    try expectEqual(43, c.ok);
 }
 
 // test
diff --git a/doc/langref/test_switch_tagged_union.zig b/doc/langref/test_switch_tagged_union.zig
index 2644817b473244b9012a215ef4d08799fd37a193..568092dad9236faa09301d16c36410d0780eb34f 100644
--- a/doc/langref/test_switch_tagged_union.zig
+++ b/doc/langref/test_switch_tagged_union.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "switch on tagged union" {
     const Point = struct {
@@ -31,8 +31,8 @@ test "switch on tagged union" {
         Item.d => 8,
     };
 
-    try expect(b == 6);
-    try expect(a.c.x == 2);
+    try expectEqual(6, b);
+    try expectEqual(2, a.c.x);
 }
 
 // test
diff --git a/doc/langref/test_tagName.zig b/doc/langref/test_tagName.zig
index 8b0aa1cb289d41f170923bc21977e26a65612515..1190089433accaff50e065066956aa042b604b6c 100644
--- a/doc/langref/test_tagName.zig
+++ b/doc/langref/test_tagName.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqualSlices = std.testing.expectEqualSlices;
 
 const Small2 = union(enum) {
     a: i32,
@@ -7,7 +7,7 @@ const Small2 = union(enum) {
     c: u8,
 };
 test "@tagName" {
-    try expect(std.mem.eql(u8, @tagName(Small2.a), "a"));
+    try expectEqualSlices(u8, "a", @tagName(Small2.a));
 }
 
 // test
diff --git a/doc/langref/test_tagged_union.zig b/doc/langref/test_tagged_union.zig
index d118d7e6bdaa703644378a9f80d2fed56a13b773..9efc18cc28205131435bcad9c2792e0b727585d1 100644
--- a/doc/langref/test_tagged_union.zig
+++ b/doc/langref/test_tagged_union.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const ComplexTypeTag = enum {
     ok,
@@ -12,10 +12,10 @@ const ComplexType = union(ComplexTypeTag) {
 
 test "switch on tagged union" {
     const c = ComplexType{ .ok = 42 };
-    try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
+    try expectEqual(ComplexTypeTag.ok, @as(ComplexTypeTag, c));
 
     switch (c) {
-        .ok => |value| try expect(value == 42),
+        .ok => |value| try expectEqual(42, value),
         .not_ok => unreachable,
     }
 
@@ -29,7 +29,7 @@ test "switch on tagged union" {
 }
 
 test "get tag type" {
-    try expect(std.meta.Tag(ComplexType) == ComplexTypeTag);
+    try expectEqual(ComplexTypeTag, std.meta.Tag(ComplexType));
 }
 
 // test
diff --git a/doc/langref/test_tagged_union_with_tag_values.zig b/doc/langref/test_tagged_union_with_tag_values.zig
index c079b5eac303409085fa904ab10e627f225c2e0e..229a31d6780b213a76cd9d895a6ed838de777f0d 100644
--- a/doc/langref/test_tagged_union_with_tag_values.zig
+++ b/doc/langref/test_tagged_union_with_tag_values.zig
@@ -1,5 +1,5 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 const Tagged = union(enum(u32)) {
     int: i64 = 123,
@@ -8,10 +8,10 @@ const Tagged = union(enum(u32)) {
 
 test "tag values" {
     const int: Tagged = .{ .int = -40 };
-    try expect(@intFromEnum(int) == 123);
+    try expectEqual(123, @intFromEnum(int));
 
     const boolean: Tagged = .{ .boolean = false };
-    try expect(@intFromEnum(boolean) == 67);
+    try expectEqual(67, @intFromEnum(boolean));
 }
 
 // test
diff --git a/doc/langref/test_this_builtin.zig b/doc/langref/test_this_builtin.zig
index 5cad4e25537287d82be21c89bab6b97281ff147a..54cad56fdf73ec6d84545778d63b4103bc704e35 100644
--- a/doc/langref/test_this_builtin.zig
+++ b/doc/langref/test_this_builtin.zig
@@ -1,10 +1,10 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "@This()" {
     var items = [_]i32{ 1, 2, 3, 4 };
     const list = List(i32){ .items = items[0..] };
-    try expect(list.length() == 4);
+    try expectEqual(4, list.length());
 }
 
 fn List(comptime T: type) type {
diff --git a/doc/langref/test_truncate_builtin.zig b/doc/langref/test_truncate_builtin.zig
index a893db82060cded7f0664352f36c5891f78c0dc2..73484fc41e923b8601cb3afdcf8d77cb4e7f84ec 100644
--- a/doc/langref/test_truncate_builtin.zig
+++ b/doc/langref/test_truncate_builtin.zig
@@ -1,10 +1,10 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "integer truncation" {
     const a: u16 = 0xabcd;
     const b: u8 = @truncate(a);
-    try expect(b == 0xcd);
+    try expectEqual(0xcd, b);
 }
 
 // test
diff --git a/doc/langref/test_tuples.zig b/doc/langref/test_tuples.zig
index 54e05e77e70deedbf9e44c673521be5b75ad0d9d..2d075b324fbb415834cc58e863d49b8dd20e065f 100644
--- a/doc/langref/test_tuples.zig
+++ b/doc/langref/test_tuples.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "tuple" {
     const values = .{
@@ -8,14 +9,14 @@ test "tuple" {
         true,
         "hi",
     } ++ .{false} ** 2;
-    try expect(values[0] == 1234);
-    try expect(values[4] == false);
+    try expectEqual(1234, values[0]);
+    try expectEqual(false, values[4]);
     inline for (values, 0..) |v, i| {
         if (i != 2) continue;
         try expect(v);
     }
-    try expect(values.len == 6);
-    try expect(values.@"3"[0] == 'h');
+    try expectEqual(6, values.len);
+    try expectEqual('h', values.@"3"[0]);
 }
 
 // test
diff --git a/doc/langref/test_variable_alignment.zig b/doc/langref/test_variable_alignment.zig
index ea0024f98861b4b08a21f03b40df28160b8971d0..01768e29eb0e81d5924644fbbbbd6739047fb690 100644
--- a/doc/langref/test_variable_alignment.zig
+++ b/doc/langref/test_variable_alignment.zig
@@ -1,14 +1,14 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "variable alignment" {
     var x: i32 = 1234;
     const align_of_i32 = @alignOf(@TypeOf(x));
-    try expect(@TypeOf(&x) == *i32);
-    try expect(*i32 == *align(align_of_i32) i32);
+    try expectEqual(*i32, @TypeOf(&x));
+    try expectEqual(*align(align_of_i32) i32, *i32);
     if (builtin.target.cpu.arch == .x86_64) {
-        try expect(@typeInfo(*i32).pointer.alignment == 4);
+        try expectEqual(4, @typeInfo(*i32).pointer.alignment);
     }
 }
 
diff --git a/doc/langref/test_variable_func_alignment.zig b/doc/langref/test_variable_func_alignment.zig
index e0aa949cee6c31ca35e02ba38ea39edbb0de622c..bd97756c45b18b24e643491176c3c8ea5ce195be 100644
--- a/doc/langref/test_variable_func_alignment.zig
+++ b/doc/langref/test_variable_func_alignment.zig
@@ -1,14 +1,14 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 var foo: u8 align(4) = 100;
 
 test "global variable alignment" {
-    try expect(@typeInfo(@TypeOf(&foo)).pointer.alignment == 4);
-    try expect(@TypeOf(&foo) == *align(4) u8);
+    try expectEqual(4, @typeInfo(@TypeOf(&foo)).pointer.alignment);
+    try expectEqual(*align(4) u8, @TypeOf(&foo));
     const as_pointer_to_array: *align(4) [1]u8 = &foo;
     const as_slice: []align(4) u8 = as_pointer_to_array;
     const as_unaligned_slice: []u8 = as_slice;
-    try expect(as_unaligned_slice[0] == 100);
+    try expectEqual(100, as_unaligned_slice[0]);
 }
 
 fn derp() align(@sizeOf(usize) * 2) i32 {
@@ -18,17 +18,17 @@ fn noop1() align(1) void {}
 fn noop4() align(4) void {}
 
 test "function alignment" {
-    try expect(derp() == 1234);
-    try expect(@TypeOf(derp) == fn () i32);
-    try expect(@TypeOf(&derp) == *align(@sizeOf(usize) * 2) const fn () i32);
+    try expectEqual(1234, derp());
+    try expectEqual(fn () i32, @TypeOf(derp));
+    try expectEqual(*align(@sizeOf(usize) * 2) const fn () i32, @TypeOf(&derp));
 
     noop1();
-    try expect(@TypeOf(noop1) == fn () void);
-    try expect(@TypeOf(&noop1) == *align(1) const fn () void);
+    try expectEqual(fn () void, @TypeOf(noop1));
+    try expectEqual(*align(1) const fn () void, @TypeOf(&noop1));
 
     noop4();
-    try expect(@TypeOf(noop4) == fn () void);
-    try expect(@TypeOf(&noop4) == *align(4) const fn () void);
+    try expectEqual(fn () void, @TypeOf(noop4));
+    try expectEqual(*align(4) const fn () void, @TypeOf(&noop4));
 }
 
 // test
diff --git a/doc/langref/test_variadic_function.zig b/doc/langref/test_variadic_function.zig
index e5d9777f6411db50af3f0dfac7fd702999ed6b1c..f1c389b551d32241221e61859496bf8b22eea498 100644
--- a/doc/langref/test_variadic_function.zig
+++ b/doc/langref/test_variadic_function.zig
@@ -4,7 +4,7 @@ const testing = std.testing;
 pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
 
 test "variadic function" {
-    try testing.expect(printf("Hello, world!\n") == 14);
+    try testing.expectEqual(14, printf("Hello, world!\n"));
     try testing.expect(@typeInfo(@TypeOf(printf)).@"fn".is_var_args);
 }
 
diff --git a/doc/langref/test_volatile.zig b/doc/langref/test_volatile.zig
index 2c33faddf53399a68aec13bcd7354c459b8c266a..b493dd0b94ff1794607049a7014e3cf285f9e46c 100644
--- a/doc/langref/test_volatile.zig
+++ b/doc/langref/test_volatile.zig
@@ -1,8 +1,8 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "volatile" {
     const mmio_ptr: *volatile u8 = @ptrFromInt(0x12345678);
-    try expect(@TypeOf(mmio_ptr) == *volatile u8);
+    try expectEqual(*volatile u8, @TypeOf(mmio_ptr));
 }
 
 // test
diff --git a/doc/langref/test_wasmMemoryGrow_builtin.zig b/doc/langref/test_wasmMemoryGrow_builtin.zig
index 7f2dc3e1490a3fa2e980df0b3c79f6baa159af00..e18d5d1b75a2613168edb37fe6b2ae72c5def571 100644
--- a/doc/langref/test_wasmMemoryGrow_builtin.zig
+++ b/doc/langref/test_wasmMemoryGrow_builtin.zig
@@ -1,13 +1,13 @@
 const std = @import("std");
 const native_arch = @import("builtin").target.cpu.arch;
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 
 test "@wasmMemoryGrow" {
     if (native_arch != .wasm32) return error.SkipZigTest;
 
     const prev = @wasmMemorySize(0);
-    try expect(prev == @wasmMemoryGrow(0, 1));
-    try expect(prev + 1 == @wasmMemorySize(0));
+    try expectEqual(@wasmMemoryGrow(0, 1), prev);
+    try expectEqual(@wasmMemorySize(0), prev + 1);
 }
 
 // test
diff --git a/doc/langref/test_while.zig b/doc/langref/test_while.zig
index 45b27bc7164e99bae32082e598809bfbb04c8dfa..a9771410e2a88448ac6d9f1c1200b73b0ccb12bb 100644
--- a/doc/langref/test_while.zig
+++ b/doc/langref/test_while.zig
@@ -1,11 +1,11 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "while basic" {
     var i: usize = 0;
     while (i < 10) {
         i += 1;
     }
-    try expect(i == 10);
+    try expectEqual(10, i);
 }
 
 // test
diff --git a/doc/langref/test_while_break.zig b/doc/langref/test_while_break.zig
index d30d481548c7eb313127f02f751b602fd74e179f..c433337d9f1f8f8a1b4d0ac0757ba4cc80e5132c 100644
--- a/doc/langref/test_while_break.zig
+++ b/doc/langref/test_while_break.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "while break" {
     var i: usize = 0;
@@ -7,7 +7,7 @@ test "while break" {
             break;
         i += 1;
     }
-    try expect(i == 10);
+    try expectEqual(10, i);
 }
 
 // test
diff --git a/doc/langref/test_while_continue.zig b/doc/langref/test_while_continue.zig
index afe794223a7e4f0377099d2f60837009de1f2434..22f5ba1a7538ba17603280168dce436d3689b02b 100644
--- a/doc/langref/test_while_continue.zig
+++ b/doc/langref/test_while_continue.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "while continue" {
     var i: usize = 0;
@@ -8,7 +8,7 @@ test "while continue" {
             continue;
         break;
     }
-    try expect(i == 10);
+    try expectEqual(10, i);
 }
 
 // test
diff --git a/doc/langref/test_while_continue_expression.zig b/doc/langref/test_while_continue_expression.zig
index 3831f91c05847d90a17bda8d01370165dcdc9e8d..2ebc7c834597985cca5b4740274041251dfe92a6 100644
--- a/doc/langref/test_while_continue_expression.zig
+++ b/doc/langref/test_while_continue_expression.zig
@@ -1,9 +1,10 @@
+const expectEqual = @import("std").testing.expectEqual;
 const expect = @import("std").testing.expect;
 
 test "while loop continue expression" {
     var i: usize = 0;
     while (i < 10) : (i += 1) {}
-    try expect(i == 10);
+    try expectEqual(10, i);
 }
 
 test "while loop continue expression, more complicated" {
diff --git a/doc/langref/test_while_error_capture.zig b/doc/langref/test_while_error_capture.zig
index b687d1a5e7899ac4713a42f224e8802c174fb1e9..739db0229e97d51372cb82eab6860b2fee59daab 100644
--- a/doc/langref/test_while_error_capture.zig
+++ b/doc/langref/test_while_error_capture.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "while error union capture" {
     var sum1: u32 = 0;
@@ -6,7 +6,7 @@ test "while error union capture" {
     while (eventuallyErrorSequence()) |value| {
         sum1 += value;
     } else |err| {
-        try expect(err == error.ReachedZero);
+        try expectEqual(error.ReachedZero, err);
     }
 }
 
diff --git a/doc/langref/test_while_null_capture.zig b/doc/langref/test_while_null_capture.zig
index dd412ffccd2e6a503bca809158ceb62dfc37c204..13fc7e062d5e321e47f83784bdb455a80953f9c3 100644
--- a/doc/langref/test_while_null_capture.zig
+++ b/doc/langref/test_while_null_capture.zig
@@ -1,4 +1,4 @@
-const expect = @import("std").testing.expect;
+const expectEqual = @import("std").testing.expectEqual;
 
 test "while null capture" {
     var sum1: u32 = 0;
@@ -6,7 +6,7 @@ test "while null capture" {
     while (eventuallyNullSequence()) |value| {
         sum1 += value;
     }
-    try expect(sum1 == 3);
+    try expectEqual(3, sum1);
 
     // null capture with an else block
     var sum2: u32 = 0;
@@ -14,7 +14,7 @@ test "while null capture" {
     while (eventuallyNullSequence()) |value| {
         sum2 += value;
     } else {
-        try expect(sum2 == 3);
+        try expectEqual(3, sum2);
     }
 
     // null capture with a continue expression
@@ -24,7 +24,7 @@ test "while null capture" {
     while (eventuallyNullSequence()) |value| : (i += 1) {
         sum3 += value;
     }
-    try expect(i == 3);
+    try expectEqual(3, i);
 }
 
 var numbers_left: u32 = undefined;
diff --git a/doc/langref/test_wraparound_semantics.zig b/doc/langref/test_wraparound_semantics.zig
index 491b0907f678b617ad55ad65d703dc1835f5bd14..18c3ce44a68d763a3bef2a424dc2fb3370b00451 100644
--- a/doc/langref/test_wraparound_semantics.zig
+++ b/doc/langref/test_wraparound_semantics.zig
@@ -1,14 +1,14 @@
 const std = @import("std");
-const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 const minInt = std.math.minInt;
 const maxInt = std.math.maxInt;
 
 test "wraparound addition and subtraction" {
     const x: i32 = maxInt(i32);
     const min_val = x +% 1;
-    try expect(min_val == minInt(i32));
+    try expectEqual(minInt(i32), min_val);
     const max_val = min_val -% 1;
-    try expect(max_val == maxInt(i32));
+    try expectEqual(maxInt(i32), max_val);
 }
 
 // test
diff --git a/doc/langref/testing_detect_leak.zig b/doc/langref/testing_detect_leak.zig
index fd72fc9bba942f7f15b18bc3914a57ca7c54d7d2..d15e7b6b1c7692370ce3eb04ac385d4ab967aa97 100644
--- a/doc/langref/testing_detect_leak.zig
+++ b/doc/langref/testing_detect_leak.zig
@@ -6,7 +6,7 @@ test "detect leak" {
     // missing `defer list.deinit(gpa);`
     try list.append(gpa, '☔');
 
-    try std.testing.expect(list.items.len == 1);
+    try std.testing.expectEqual(1, list.items.len);
 }
 
 // test_error=1 tests leaked memory
diff --git a/doc/langref/testing_introduction.zig b/doc/langref/testing_introduction.zig
index 6a46c8d6887f06c003dadae16383f07cd476d6cc..22bd70a5add3c9ee7a427633b42c85917d7b8d9a 100644
--- a/doc/langref/testing_introduction.zig
+++ b/doc/langref/testing_introduction.zig
@@ -7,12 +7,16 @@ test "expect addOne adds one to 41" {
     // It will return an error if its argument is false to indicate a failure.
     // `try` is used to return an error to the test runner to notify it that the test failed.
     try std.testing.expect(addOne(41) == 42);
+
+    // However, in most cases it is more convenient to use a more specific function like `expectEqual`.
+    // This gives you much clearer and more helpful error messages when a test fails.
+    try std.testing.expectEqual(42, addOne(41));
 }
 
 test addOne {
     // A test name can also be written using an identifier.
     // This is a doctest, and serves as documentation for `addOne`.
-    try std.testing.expect(addOne(41) == 42);
+    try std.testing.expectEqual(42, addOne(41));
 }
 
 /// The function `addOne` adds one to the number given as its argument.
-- 
2.54.0


From bb304796f466b4fd15a4adac7ffbb81ace95d2a4 Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Wed, 18 Feb 2026 18:17:15 -0500
Subject: [PATCH 342/499] optimize flate decompression

Matches now use memcpy and memset when possible.

Block loops have been rewritten to be more optimizer friendly.

Reworks Symbol and HuffmanDecoder
* Symbol now only includes the value and number of code bits.
  decodeSymbol returns only the value.
* HuffmanDecoder now takes the regular bits instead of the reversed.
* Code table construction now uses buckets instead of sorting.
* For linked codes, the value field of Symbol is now used as the next
  index. The actual value is the element index.
* InvalidCode is now detected only once with a special linked index.

Performance is 39.7% faster than before and 1.1% faster than gzip using
a sample created from compressing a tar of the src directory.
---
 lib/std/compress/flate/Decompress.zig | 355 ++++++++++++--------------
 1 file changed, 168 insertions(+), 187 deletions(-)

diff --git a/lib/std/compress/flate/Decompress.zig b/lib/std/compress/flate/Decompress.zig
index d9b6a82a63f06a65c506bed69301afef8b34ea2e..ee095e01f419d32754f6fd0855aa93d09fd1a6cd 100644
--- a/lib/std/compress/flate/Decompress.zig
+++ b/lib/std/compress/flate/Decompress.zig
@@ -229,11 +229,11 @@ fn dynamicCodeLength(self: *Decompress, code: u16, lens: []u4, pos: usize) !usiz
     }
 }
 
-fn decodeSymbol(self: *Decompress, decoder: anytype) !Symbol {
+fn decodeSymbol(self: *Decompress, decoder: anytype) !u16 {
     // Maximum code len is 15 bits.
-    const sym = try decoder.find(@bitReverse(try self.peekIntBitsShort(u15)));
+    const sym = try decoder.find(try self.peekIntBitsShort(u15));
     try self.tossBitsShort(sym.code_bits);
-    return sym;
+    return sym.value;
 }
 
 fn streamDirect(r: *Reader, w: *Writer, limit: std.Io.Limit) Reader.StreamError!usize {
@@ -348,10 +348,10 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader
                     var dec_lens: [286 + 30]u4 = @splat(0);
                     var pos: usize = 0;
                     while (pos < hlit + hdist) {
-                        const peeked = @bitReverse(try d.peekIntBitsShort(u7));
+                        const peeked = try d.peekIntBitsShort(u7);
                         const sym = try cl_dec.find(peeked);
                         try d.tossBitsShort(sym.code_bits);
-                        pos += try d.dynamicCodeLength(sym.symbol, &dec_lens, pos);
+                        pos += try d.dynamicCodeLength(sym.value, &dec_lens, pos);
                     }
                     if (pos > hlit + hdist) {
                         return error.InvalidDynamicBlockHeader;
@@ -383,35 +383,34 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader
             w.advance(n);
             return @intFromEnum(limit) - remaining + n;
         },
-        .fixed_block => {
-            while (remaining > 0) {
-                const code = try d.readFixedCode();
-                switch (code) {
-                    0...255 => {
-                        if (remaining != 0) {
-                            @branchHint(.likely);
-                            try w.writeBytePreserve(flate.history_len, @intCast(code));
-                            remaining -= 1;
-                        } else {
-                            d.state = .{ .fixed_block_literal = @intCast(code) };
-                            return @intFromEnum(limit) - remaining;
-                        }
-                    },
-                    256 => {
-                        d.state = if (d.final_block) .protocol_footer else .block_header;
-                        return @intFromEnum(limit) - remaining;
-                    },
-                    257...285 => {
-                        // Handles fixed block non literal (length) code.
-                        // Length code is followed by 5 bits of distance code.
-                        const length = try d.decodeLength(@intCast(code - 257));
-                        continue :sw .{ .fixed_block_match = length };
-                    },
-                    else => return error.InvalidCode,
+        .fixed_block => while (true) {
+            // Consume bytes
+            const sym = try d.readFixedCode();
+
+            if (sym >= 256) {
+                @branchHint(.unlikely);
+
+                if (sym == 256) {
+                    @branchHint(.unlikely);
+                    // End
+                    d.state = if (d.final_block) .protocol_footer else .block_header;
+                    continue :sw d.state;
                 }
+
+                // Match
+                const length = try d.decodeLength(@intCast(sym - 257));
+                continue :sw .{ .fixed_block_match = length };
+            }
+
+            const byte: u8 = @intCast(sym);
+            if (remaining != 0) {
+                @branchHint(.likely);
+                remaining -= 1;
+                try w.writeBytePreserve(flate.history_len, byte);
+            } else {
+                d.state = .{ .fixed_block_literal = byte };
+                return @intFromEnum(limit) - remaining;
             }
-            d.state = .fixed_block;
-            return @intFromEnum(limit) - remaining;
         },
         .fixed_block_literal => |symbol| {
             assert(remaining != 0);
@@ -431,32 +430,35 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader
                 return @intFromEnum(limit) - remaining;
             }
         },
-        .dynamic_block => {
-            // In larger archives most blocks are usually dynamic, so
-            // decompression performance depends on this logic.
-            var sym = try d.decodeSymbol(&d.lit_dec);
-            sym: switch (sym.kind) {
-                .literal => {
-                    if (remaining != 0) {
-                        @branchHint(.likely);
-                        remaining -= 1;
-                        try w.writeBytePreserve(flate.history_len, sym.symbol);
-                        sym = try d.decodeSymbol(&d.lit_dec);
-                        continue :sym sym.kind;
-                    } else {
-                        d.state = .{ .dynamic_block_literal = sym.symbol };
-                        return @intFromEnum(limit) - remaining;
-                    }
-                },
-                .match => {
-                    // Decode match backreference <length, distance>
-                    const length = try d.decodeLength(@intCast(sym.symbol));
-                    continue :sw .{ .dynamic_block_match = length };
-                },
-                .end_of_block => {
+        // In larger archives most blocks are usually dynamic, so
+        // decompression performance depends on this logic.
+        .dynamic_block => while (true) {
+            // Consume bytes
+            const sym = try d.decodeSymbol(&d.lit_dec);
+
+            if (sym >= 256) {
+                @branchHint(.unlikely);
+
+                if (sym == 256) {
+                    @branchHint(.unlikely);
+                    // End
                     d.state = if (d.final_block) .protocol_footer else .block_header;
                     continue :sw d.state;
-                },
+                }
+
+                // Match
+                const length = try d.decodeLength(@intCast(sym - 257));
+                continue :sw .{ .dynamic_block_match = length };
+            }
+
+            const byte: u8 = @intCast(sym);
+            if (remaining != 0) {
+                @branchHint(.likely);
+                remaining -= 1;
+                try w.writeBytePreserve(flate.history_len, byte);
+            } else {
+                d.state = .{ .dynamic_block_literal = byte };
+                return @intFromEnum(limit) - remaining;
             }
         },
         .dynamic_block_literal => |symbol| {
@@ -470,7 +472,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader
                 @branchHint(.likely);
                 remaining -= length;
                 const dsm = try d.decodeSymbol(&d.dst_dec);
-                const distance = try d.decodeDistance(@intCast(dsm.symbol));
+                const distance = try d.decodeDistance(@intCast(dsm));
                 try writeMatch(w, length, distance);
                 continue :sw .dynamic_block;
             } else {
@@ -501,17 +503,25 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader
 /// back from current write position, and `length` of bytes.
 fn writeMatch(w: *Writer, length: u16, distance: u16) !void {
     if (w.end < distance) return error.InvalidMatch;
-    if (length < token.min_length) return error.InvalidMatch;
-    if (length > token.max_length) return error.InvalidMatch;
-    if (distance < token.min_distance) return error.InvalidMatch;
-    if (distance > token.max_distance) return error.InvalidMatch;
+    assert(length >= token.min_length);
+    assert(length <= token.max_length);
+    assert(distance >= token.min_distance);
+    assert(distance <= token.max_distance);
 
     // This is not a @memmove; it intentionally repeats patterns caused by
     // iterating one byte at a time.
     const dest = try w.writableSlicePreserve(flate.history_len, length);
     const end = dest.ptr - w.buffer.ptr;
     const src = w.buffer[end - distance ..][0..length];
-    for (dest, src) |*d, s| d.* = s;
+    if (distance >= length) {
+        @memcpy(dest, src);
+    } else if (distance == 1) {
+        // Repeating copy of single byte
+        @memset(dest, src[0]);
+    } else {
+        // Repeating copy of multiple bytes
+        for (dest, src) |*d, s| d.* = s;
+    }
 }
 
 fn peekBits(d: *Decompress, n: u4) !u16 {
@@ -603,31 +613,9 @@ fn readFixedCode(d: *Decompress) !u16 {
     };
 }
 
-pub const Symbol = packed struct {
-    pub const Kind = enum(u2) {
-        literal,
-        end_of_block,
-        match,
-    };
-
-    symbol: u8 = 0, // symbol from alphabet
+pub const Symbol = packed struct(u16) {
+    value: u12 = 0,
     code_bits: u4 = 0, // number of bits in code 0-15
-    kind: Kind = .literal,
-
-    code: u16 = 0, // huffman code of the symbol
-    next: u16 = 0, // pointer to the next symbol in linked list
-    // it is safe to use 0 as null pointer, when sorted 0 has shortest code and fits into lookup
-
-    // Sorting less than function.
-    pub fn asc(_: void, a: Symbol, b: Symbol) bool {
-        if (a.code_bits == b.code_bits) {
-            if (a.kind == b.kind) {
-                return a.symbol < b.symbol;
-            }
-            return @intFromEnum(a.kind) < @intFromEnum(b.kind);
-        }
-        return a.code_bits < b.code_bits;
-    }
 };
 
 pub const LiteralDecoder = HuffmanDecoder(286, 15, 9);
@@ -646,69 +634,85 @@ pub const CodegenDecoder = HuffmanDecoder(19, 7, 7);
 /// Small lookup table is optimization for faster search.
 /// It is variation of the algorithm explained in [zlib](https://github.com/madler/zlib/blob/643e17b7498d12ab8d15565662880579692f769d/doc/algorithm.txt#L92)
 /// with difference that we here use statically allocated arrays.
-///
 fn HuffmanDecoder(
     comptime alphabet_size: u16,
     comptime max_code_bits: u4,
     comptime lookup_bits: u4,
 ) type {
     const lookup_shift = max_code_bits - lookup_bits;
+    const lookup_mask = (1 << lookup_bits) - 1;
 
     return struct {
-        // all symbols in alaphabet, sorted by code_len, symbol
-        symbols: [alphabet_size]Symbol = undefined,
         // lookup table code -> symbol
+        // for values with code_bits == 0, symbol is the index of the first node in linked
+        // if the index of the first node is 0xfff, it is an invalid code
         lookup: [1 << lookup_bits]Symbol = undefined,
+        linked: if (lookup_bits == max_code_bits) void else [alphabet_size]struct {
+            // sym.value is the next index in linked where the current index ends the chain
+            // the actual symbol is this nodes's index
+            sym: Symbol,
+            code: u16,
+        } = undefined,
 
         const Self = @This();
 
+        fn reverseIdx(idx: usize) u16 {
+            return @bitReverse(@as(@Int(.unsigned, lookup_bits), @intCast(idx)));
+        }
+
         /// Generates symbols and lookup tables from list of code lens for each symbol.
         pub fn generate(self: *Self, lens: []const u4) !void {
             try checkCompleteness(lens);
 
-            // init alphabet with code_bits
-            for (self.symbols, 0..) |_, i| {
-                const cb: u4 = if (i < lens.len) lens[i] else 0;
-                self.symbols[i] = if (i < 256)
-                    .{ .kind = .literal, .symbol = @intCast(i), .code_bits = cb }
-                else if (i == 256)
-                    .{ .kind = .end_of_block, .symbol = 0xff, .code_bits = cb }
-                else
-                    .{ .kind = .match, .symbol = @intCast(i - 257), .code_bits = cb };
+            var buckets: [1 + @as(usize, max_code_bits)][alphabet_size]Symbol = undefined;
+            var bucket_len: [buckets.len]u16 = @splat(0);
+            for (0.., lens) |symbol, bits| {
+                buckets[bits][bucket_len[bits]] = .{
+                    .value = @intCast(symbol),
+                    .code_bits = bits,
+                };
+                bucket_len[bits] += 1;
             }
-            std.sort.heap(Symbol, &self.symbols, {}, Symbol.asc);
 
-            // reset lookup table
-            for (0..self.lookup.len) |i| {
-                self.lookup[i] = .{};
-            }
-
-            // assign code to symbols
-            // reference: https://youtu.be/9_YEGLe33NA?list=PLU4IQLU9e_OrY8oASHx0u3IXAL9TOdidm&t=2639
             var code: u16 = 0;
             var idx: u16 = 0;
-            for (&self.symbols, 0..) |*sym, pos| {
-                if (sym.code_bits == 0) continue; // skip unused
-                sym.code = code;
+            for (1..lookup_bits + 1) |bits| {
+                const inc = @as(u16, 1) << @intCast(max_code_bits - bits);
+                for (buckets[bits][0..bucket_len[bits]]) |lookup_sym| {
+                    const next_code = code + inc;
+                    const next_idx = next_code >> lookup_shift;
+                    for (idx..next_idx) |i| {
+                        self.lookup[reverseIdx(i)] = lookup_sym;
+                    }
+                    code = next_code;
+                    idx = next_idx;
+                }
+            }
+            for (lookup_bits + 1..buckets.len) |bits| {
+                const inc = @as(u16, 1) << @intCast(max_code_bits - bits);
+                for (buckets[bits][0..bucket_len[bits]]) |linked_sym| {
+                    const next_code = code + inc;
+                    const next_idx = next_code >> lookup_shift;
 
-                const next_code = code + (@as(u16, 1) << (max_code_bits - sym.code_bits));
-                const next_idx = next_code >> lookup_shift;
+                    const ri = reverseIdx(idx);
+                    const next: Symbol = .{
+                        .value = self.lookup[ri].value,
+                        .code_bits = linked_sym.code_bits,
+                    };
+                    self.linked[linked_sym.value] = .{
+                        .sym = next,
+                        .code = @bitReverse(@as(@Int(.unsigned, max_code_bits), @intCast(code))),
+                    };
+                    self.lookup[ri] = .{ .value = linked_sym.value, .code_bits = 0 };
 
-                if (next_idx > self.lookup.len or idx >= self.lookup.len) break;
-                if (sym.code_bits <= lookup_bits) {
-                    // fill small lookup table
-                    for (idx..next_idx) |j|
-                        self.lookup[j] = sym.*;
-                } else {
-                    // insert into linked table starting at root
-                    const root = &self.lookup[idx];
-                    const root_next = root.next;
-                    root.next = @intCast(pos);
-                    sym.next = root_next;
+                    code = next_code;
+                    idx = next_idx;
                 }
+            }
 
-                idx = next_idx;
-                code = next_code;
+            // Invalid codes
+            for (idx..self.lookup.len) |i| {
+                self.lookup[reverseIdx(i)] = .{ .value = 0xfff, .code_bits = 0 };
             }
         }
 
@@ -748,23 +752,25 @@ fn HuffmanDecoder(
         /// Finds symbol for lookup table code.
         pub fn find(self: *Self, code: u16) !Symbol {
             // try to find in lookup table
-            const idx = code >> lookup_shift;
+            const idx = code & lookup_mask;
             const sym = self.lookup[idx];
             if (sym.code_bits != 0) return sym;
             // if not use linked list of symbols with same prefix
-            return self.findLinked(code, sym.next);
+            return self.findLinked(code, sym.value);
         }
 
         fn findLinked(self: *Self, code: u16, start: u16) !Symbol {
+            if (start == 0xfff) return error.InvalidCode;
+            if (lookup_bits == max_code_bits) unreachable;
             var pos = start;
-            while (pos > 0) {
-                const sym = self.symbols[pos];
-                const shift = max_code_bits - sym.code_bits;
+            while (true) {
+                const node = self.linked[pos];
+                const shift = -%node.sym.code_bits;
                 // compare code_bits number of upper bits
-                if ((code ^ sym.code) >> shift == 0) return sym;
-                pos = sym.next;
+                if ((code ^ node.code) << shift == 0)
+                    return .{ .value = @intCast(pos), .code_bits = node.sym.code_bits };
+                pos = node.sym.value;
             }
-            return error.InvalidCode;
         }
     };
 }
@@ -775,74 +781,49 @@ test "init/find" {
     var h: CodegenDecoder = .{};
     try h.generate(&code_lens);
 
-    const expected = [_]struct {
-        sym: Symbol,
-        code: u16,
-    }{
-        .{
-            .code = 0b00_00000,
-            .sym = .{ .symbol = 3, .code_bits = 2 },
-        },
-        .{
-            .code = 0b01_00000,
-            .sym = .{ .symbol = 18, .code_bits = 2 },
-        },
-        .{
-            .code = 0b100_0000,
-            .sym = .{ .symbol = 1, .code_bits = 3 },
-        },
-        .{
-            .code = 0b101_0000,
-            .sym = .{ .symbol = 4, .code_bits = 3 },
-        },
-        .{
-            .code = 0b110_0000,
-            .sym = .{ .symbol = 17, .code_bits = 3 },
-        },
-        .{
-            .code = 0b1110_000,
-            .sym = .{ .symbol = 0, .code_bits = 4 },
-        },
-        .{
-            .code = 0b1111_000,
-            .sym = .{ .symbol = 16, .code_bits = 4 },
-        },
-    };
-
-    // unused symbols
-    for (0..12) |i| {
-        try testing.expectEqual(0, h.symbols[i].code_bits);
-    }
-    // used, from index 12
-    for (expected, 12..) |e, i| {
-        try testing.expectEqual(e.sym.symbol, h.symbols[i].symbol);
-        try testing.expectEqual(e.sym.code_bits, h.symbols[i].code_bits);
-        const sym_from_code = try h.find(e.code);
-        try testing.expectEqual(e.sym.symbol, sym_from_code.symbol);
-    }
-
     // All possible codes for each symbol.
     // Lookup table has 126 elements, to cover all possible 7 bit codes.
     for (0b0000_000..0b0100_000) |c| // 0..32 (32)
-        try testing.expectEqual(3, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 3, .code_bits = 2 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 
     for (0b0100_000..0b1000_000) |c| // 32..64 (32)
-        try testing.expectEqual(18, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 18, .code_bits = 2 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 
     for (0b1000_000..0b1010_000) |c| // 64..80 (16)
-        try testing.expectEqual(1, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 1, .code_bits = 3 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 
     for (0b1010_000..0b1100_000) |c| // 80..96 (16)
-        try testing.expectEqual(4, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 4, .code_bits = 3 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 
     for (0b1100_000..0b1110_000) |c| // 96..112 (16)
-        try testing.expectEqual(17, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 17, .code_bits = 3 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 
     for (0b1110_000..0b1111_000) |c| // 112..120 (8)
-        try testing.expectEqual(0, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 0, .code_bits = 4 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 
     for (0b1111_000..0b1_0000_000) |c| // 120...128 (8)
-        try testing.expectEqual(16, (try h.find(@intCast(c))).symbol);
+        try testing.expectEqual(
+            Symbol{ .value = 16, .code_bits = 4 },
+            try h.find(@bitReverse(@as(u7, @intCast(c)))),
+        );
 }
 
 test "encode/decode literals" {
@@ -867,8 +848,8 @@ test "encode/decode literals" {
         if (bits == 0) continue;
         for (0..1 << (max_bits - bits)) |extra| {
             const full = (@as(u16, code) << (max_bits - bits)) | @as(u16, @intCast(extra));
-            const symbol = try decoder.find(full);
-            try testing.expectEqual(i, symbol.symbol);
+            const symbol = try decoder.find(@bitReverse(@as(u5, @intCast(full))));
+            try testing.expectEqual(i, symbol.value);
             try testing.expectEqual(bits, symbol.code_bits);
         }
     }
-- 
2.54.0


From 56253d9e31c0576f024d95929a8fe26428b35176 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Motiejus=20Jak=C5=A1tys?= <motiejus@jakstys.lt>
Date: Sun, 15 Feb 2026 20:41:19 +0000
Subject: [PATCH 343/499] x86_64 codegen: fix RoundMode vroundss immediate
 value

Quoting Vol. 2B 4-590 of [Intel SSA manual][1]:

> Bit 3 of the immediate byte controls processor behavior for a
precision exception <...>

The Direction struct is incorrectly sized to 4 bits, which pushes the
precision exception bit to the reserved bits, which helpfully crashes
under valgrind (but works on real hardware, since CPU ignores it):

``
const std = @import("std");

noinline fn ceil(x: f32) f32 {
    return @ceil(x);
}

test "ceil" {
    try std.testing.expectEqual(@as(f32, 2.0), ceil(1.5));
}
```

With Zig 0.15.1:

```
$ zig test -fno-llvm -mcpu x86_64_v3  -fvalgrind  ceil_test.zig  --test-cmd valgrind --test-cmd --quiet --test-cmd-bin
Illegal instruction at address 0x102d14d
/home/motiejus/code/ceil_test.zig:4:5: 0x102d14d in ceil (ceil_test.zig)
    return @ceil(x);
    ^
/home/motiejus/code/ceil_test.zig:8:52: 0x102d097 in test.ceil (ceil_test.zig)
    try std.testing.expectEqual(@as(f32, 2.0), ceil(1.5));
                                                   ^
/nix/store/n81qdpd96d86ngfv5bqymy26b8kqm654-zig-0.15.1/lib/compiler/test_runner.zig:218:25: 0x1167e80 in mainTerminal (test_runner.zig)
        if (test_fn.func()) |_| {
                        ^
/nix/store/n81qdpd96d86ngfv5bqymy26b8kqm654-zig-0.15.1/lib/compiler/test_runner.zig:66:28: 0x11610a1 in main (test_runner.zig)
        return mainTerminal();
                           ^
/nix/store/n81qdpd96d86ngfv5bqymy26b8kqm654-zig-0.15.1/lib/std/start.zig:618:22: 0x115ae3d in posixCallMainAndExit (std.zig)
            root.main();
                     ^
/nix/store/n81qdpd96d86ngfv5bqymy26b8kqm654-zig-0.15.1/lib/std/start.zig:232:5: 0x115a6d1 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
???:?:?: 0x0 in ??? (???)
error: the following test command crashed:
valgrind --quiet /home/motiejus/.cache/zig/o/7cc564b5410fc3facdb6e8768643074e/test
```

Zig 0.15.1 with this patch:

```
zig/zig3 test -fno-llvm -mcpu x86_64_v3  -fvalgrind  ceil_test.zig  --test-cmd valgrind --test-cmd --quiet --test-cmd-bin
All 1 tests passed.
```

Looking through `CodeGen.zig` it _seems_ like the same RoundMode struct
is used for vroundss/vroundps/vcvtps2ph, so update the comment while
we're at it. But I am only 90% sure it's true.

[1]: https://cdrdv2.intel.com/v1/dl/getContent/671200
---
 src/codegen/x86_64/bits.zig | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/codegen/x86_64/bits.zig b/src/codegen/x86_64/bits.zig
index 05048109335e0256d91c5f350d7fa900ce08e402..452518e14e90c40c14aebc4f0718f89bc31dc338 100644
--- a/src/codegen/x86_64/bits.zig
+++ b/src/codegen/x86_64/bits.zig
@@ -178,15 +178,15 @@ pub const Condition = enum(u5) {
     }
 };
 
-/// The immediate operand of vcvtps2ph.
-pub const RoundMode = packed struct(u5) {
+/// The immediate operand of vroundss/vroundps/vcvtps2ph/round??.
+pub const RoundMode = packed struct(u4) {
     direction: Direction = .mxcsr,
     precision: enum(u1) {
         normal = 0b0,
         inexact = 0b1,
     } = .normal,
 
-    pub const Direction = enum(u4) {
+    pub const Direction = enum(u3) {
         /// Round to nearest (even)
         nearest = 0b0_00,
         /// Round down (toward -∞)
-- 
2.54.0


From 2fa2300ba46f35a9073475bd24a8aa9180e0b228 Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Thu, 26 Feb 2026 11:51:23 +0100
Subject: [PATCH 344/499] std.heap.ArenaAllocator: Get rid of cmpxchg loop in
 hot path

This is achieved by bumping `end_index` by a large enough amount so that
a suitably aligned region of memory can always be provided. The potential
wasted space this creates is then recovered by a single cmpxchg. This is
always successful for single-threaded arenas which means that this version
still behaves exactly the same as the old single-threaded implementation
when only being accessed by one thread at a time. It can however fail when
another thread bumps `end_index` in the meantime. The observerd failure
rates under extreme load are:

2 Threads: 4-5%
3 Threads: 13-15%
4 Threads: 15-17%
5 Threads: 17-18%
6 Threads: 19-20%
7 Threads: 18-21%

This version offers ~25% faster performance under extreme load from 7 threads,
with diminishing speedups for less threads. The performance for 1 and 2
threads is nearly identical.
---
 lib/std/heap/ArenaAllocator.zig | 142 +++++++++++++++++---------------
 1 file changed, 77 insertions(+), 65 deletions(-)

diff --git a/lib/std/heap/ArenaAllocator.zig b/lib/std/heap/ArenaAllocator.zig
index c772f367d078a8b115c2ec88a3993b7dc58fe220..5901e6474fd88750a9592ab35934053b81b3fa4b 100644
--- a/lib/std/heap/ArenaAllocator.zig
+++ b/lib/std/heap/ArenaAllocator.zig
@@ -213,12 +213,12 @@ pub fn reset(arena: *ArenaAllocator, mode: ResetMode) bool {
 const Node = struct {
     /// Only meant to be accessed indirectly via the methods supplied by this type,
     /// except if the node is owned by the thread accessing it.
-    /// Must always be an even number to accomodate `resize_bit`.
-    size: usize,
-    /// Concurrent accesses to `end_index` can be monotonic since it is only ever
-    /// incremented in `alloc` and `resize` after being compared to `size`.
+    /// Must always be an even number to accomodate `resize` bit.
+    size: Size,
+    /// Concurrent accesses to `end_index` can be monotonic as long as its value
+    /// is compared to a version of `size` before using it to access memory.
     /// Since `size` can only grow and never shrink, memory access depending on
-    /// `end_index` can never be OOB.
+    /// any `end_index` <= any `size` can never be OOB.
     end_index: usize,
     /// This field should only be accessed if the node is owned by the thread
     /// accessing it.
@@ -226,16 +226,6 @@ const Node = struct {
 
     const resize_bit: usize = 1;
 
-    fn loadEndIndex(node: *Node) usize {
-        return @atomicLoad(usize, &node.end_index, .monotonic);
-    }
-
-    /// Returns `null` on success and previous value on failure.
-    fn trySetEndIndex(node: *Node, from: usize, to: usize) ?usize {
-        assert(from != to); // check this before attempting to set `end_index`!
-        return @cmpxchgWeak(usize, &node.end_index, from, to, .monotonic, .monotonic);
-    }
-
     fn loadBuf(node: *Node) []u8 {
         // monotonic is fine since `size` can only ever grow, so the buffer returned
         // by this function is always valid memory.
@@ -326,19 +316,22 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
     retry: while (true) {
         const first_node: ?*Node, const prev_size: usize = first_node: {
             const node = cur_first_node orelse break :first_node .{ null, 0 };
-            var end_index = node.loadEndIndex();
-            while (true) {
-                const buf = node.loadBuf();
-                const aligned_index = alignedIndex(buf.ptr, end_index, alignment);
+            const buf = node.loadBuf();
 
-                if (aligned_index + n > buf.len) {
-                    break :first_node .{ node, buf.len };
-                }
+            // To avoid using a CAS loop in the hot path we atomically increase
+            // `end_index` by a large enough amount to be able to always provide
+            // the required alignment within the reserved memory. To recover the
+            // space this potentially wastes we try to subtract the 'overshoot'
+            // with a single cmpxchg afterwards, which may fail.
 
-                end_index = node.trySetEndIndex(end_index, aligned_index + n) orelse {
-                    return buf[aligned_index..][0..n].ptr;
-                };
-            }
+            const alignable = n + alignment.toByteUnits() - 1;
+            const end_index = @atomicRmw(usize, &node.end_index, .Add, alignable, .monotonic);
+            const aligned_index = alignedIndex(buf.ptr, end_index, alignment);
+            assert(end_index + alignable >= aligned_index + n);
+            _ = @cmpxchgStrong(usize, &node.end_index, end_index + alignable, aligned_index + n, .monotonic, .monotonic);
+
+            if (aligned_index + n > buf.len) break :first_node .{ node, buf.len };
+            return buf[aligned_index..][0..n].ptr;
         };
 
         resize: {
@@ -352,7 +345,7 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
             defer node.endResize(size);
 
             const buf = allocated_slice[@sizeOf(Node)..];
-            const end_index = node.loadEndIndex();
+            const end_index = @atomicLoad(usize, &node.end_index, .monotonic);
             const aligned_index = alignedIndex(buf.ptr, end_index, alignment);
             const new_size = mem.alignForward(usize, @sizeOf(Node) + aligned_index + n, 2);
 
@@ -403,55 +396,59 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
                 }
             }
 
-            var best_fit_prev: ?*Node = null;
-            var best_fit: ?*Node = null;
-            var best_fit_diff: usize = std.math.maxInt(usize);
+            const candidate: ?*Node, const prev: ?*Node = candidate: {
+                var best_fit_prev: ?*Node = null;
+                var best_fit: ?*Node = null;
+                var best_fit_diff: usize = std.math.maxInt(usize);
+
+                var it_prev: ?*Node = null;
+                var it = free_list;
+                while (it) |node| : ({
+                    it_prev = it;
+                    it = node.next;
+                }) {
+                    last_free = node;
+                    assert(node.size & Node.resize_bit == 0);
+                    const buf = node.allocatedSliceUnsafe()[@sizeOf(Node)..];
+                    const aligned_index = alignedIndex(buf.ptr, 0, alignment);
+
+                    if (aligned_index + n <= buf.len) {
+                        break :candidate .{ node, it_prev };
+                    }
 
-            var it_prev: ?*Node = null;
-            var it = free_list;
-            const candidate: ?*Node, const prev: ?*Node = find: while (it) |node| : ({
-                it_prev = it;
-                it = node.next;
-            }) {
-                last_free = node;
-                assert(node.size & Node.resize_bit == 0);
-                const buf = node.allocatedSliceUnsafe()[@sizeOf(Node)..];
-                const aligned_index = alignedIndex(buf.ptr, 0, alignment);
-                if (buf.len < aligned_index + n) {
                     const diff = aligned_index + n - buf.len;
                     if (diff <= best_fit_diff) {
                         best_fit_prev = it_prev;
                         best_fit = node;
                         best_fit_diff = diff;
                     }
-                    continue :find;
-                }
-                break :find .{ node, it_prev };
-            } else {
-                // Ideally we want to use all nodes in `free_list` eventually,
-                // so even if none fit we'll try to resize the one that was the
-                // closest to being large enough.
-                if (best_fit) |node| {
-                    const allocated_slice = node.allocatedSliceUnsafe();
-                    const buf = allocated_slice[@sizeOf(Node)..];
-                    const aligned_index = alignedIndex(buf.ptr, 0, alignment);
-                    const new_size = mem.alignForward(usize, @sizeOf(Node) + aligned_index + n, 2);
+                } else {
+                    // Ideally we want to use all nodes in `free_list` eventually,
+                    // so even if none fit we'll try to resize the one that was the
+                    // closest to being large enough.
+                    if (best_fit) |node| {
+                        const allocated_slice = node.allocatedSliceUnsafe();
+                        const buf = allocated_slice[@sizeOf(Node)..];
+                        const aligned_index = alignedIndex(buf.ptr, 0, alignment);
+                        const new_size = mem.alignForward(usize, @sizeOf(Node) + aligned_index + n, 2);
 
-                    if (arena.child_allocator.rawResize(allocated_slice, .of(Node), new_size, @returnAddress())) {
-                        node.size = new_size;
-                        break :find .{ node, best_fit_prev };
+                        if (arena.child_allocator.rawResize(allocated_slice, .of(Node), new_size, @returnAddress())) {
+                            node.size = new_size;
+                            break :candidate .{ node, best_fit_prev };
+                        }
                     }
+                    break :from_free_list;
                 }
-                break :from_free_list;
             };
 
-            it = last_free;
-            while (it) |node| : (it = node.next) {
-                last_free = node;
+            {
+                var it = last_free;
+                while (it) |node| : (it = node.next) {
+                    last_free = node;
+                }
             }
 
             const node = candidate orelse break :from_free_list;
-
             const old_next = node.next;
 
             const buf = node.allocatedSliceUnsafe()[@sizeOf(Node)..];
@@ -533,7 +530,7 @@ fn resize(ctx: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize, ret_
     const node = arena.loadFirstNode().?;
     const cur_buf_ptr = @as([*]u8, @ptrCast(node)) + @sizeOf(Node);
 
-    var cur_end_index = node.loadEndIndex();
+    var cur_end_index = @atomicLoad(usize, &node.end_index, .monotonic);
     while (true) {
         if (cur_buf_ptr + cur_end_index != buf.ptr + buf.len) {
             // It's not the most recent allocation, so it cannot be expanded,
@@ -554,7 +551,14 @@ fn resize(ctx: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize, ret_
             return false;
         };
 
-        cur_end_index = node.trySetEndIndex(cur_end_index, new_end_index) orelse {
+        cur_end_index = @cmpxchgWeak(
+            usize,
+            &node.end_index,
+            cur_end_index,
+            new_end_index,
+            .monotonic,
+            .monotonic,
+        ) orelse {
             return true;
         };
     }
@@ -580,14 +584,22 @@ fn free(ctx: *anyopaque, buf: []u8, alignment: Alignment, ret_addr: usize) void
     const node = arena.loadFirstNode().?;
     const cur_buf_ptr: [*]u8 = @as([*]u8, @ptrCast(node)) + @sizeOf(Node);
 
-    var cur_end_index = node.loadEndIndex();
+    var cur_end_index = @atomicLoad(usize, &node.end_index, .monotonic);
     while (true) {
         if (cur_buf_ptr + cur_end_index != buf.ptr + buf.len) {
             // Not the most recent allocation; we cannot free it.
             return;
         }
         const new_end_index = cur_end_index - buf.len;
-        cur_end_index = node.trySetEndIndex(cur_end_index, new_end_index) orelse {
+
+        cur_end_index = @cmpxchgWeak(
+            usize,
+            &node.end_index,
+            cur_end_index,
+            new_end_index,
+            .monotonic,
+            .monotonic,
+        ) orelse {
             return;
         };
     }
-- 
2.54.0


From de4112395714b43890aa1e9d1e7dd952e8947288 Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Thu, 26 Feb 2026 15:31:03 +0100
Subject: [PATCH 345/499] std.heap.ArenaAllocator: fix `reset` creating
 undersized nodes

Previously resetting with `retain_capacity < @sizeOf(Node)` would create
an invalid node. This is now fixed, plus `Node.size` now has its own `Size`
type that provides additional safety via assertions to prevent bugs like
this in the future.
---
 lib/std/heap/ArenaAllocator.zig | 68 +++++++++++++++++++++------------
 1 file changed, 44 insertions(+), 24 deletions(-)

diff --git a/lib/std/heap/ArenaAllocator.zig b/lib/std/heap/ArenaAllocator.zig
index 5901e6474fd88750a9592ab35934053b81b3fa4b..a9fea912841df99be85feae311cde1340b9d3088 100644
--- a/lib/std/heap/ArenaAllocator.zig
+++ b/lib/std/heap/ArenaAllocator.zig
@@ -78,7 +78,7 @@ fn countListCapacity(first_node: ?*Node) usize {
     while (it) |node| : (it = node.next) {
         // Compute the actually allocated size excluding the
         // linked list node.
-        capacity += node.size - @sizeOf(Node);
+        capacity += node.size.toInt() - @sizeOf(Node);
     }
     return capacity;
 }
@@ -164,7 +164,10 @@ pub fn reset(arena: *ArenaAllocator, mode: ResetMode) bool {
         };
         const allocated_slice = node.allocatedSliceUnsafe();
 
-        if (new_capacity == 0) {
+        // Align backwards to always stay below limit.
+        const new_size = mem.alignBackward(usize, @sizeOf(Node) + new_capacity, 2);
+
+        if (new_size == @sizeOf(Node)) {
             arena.child_allocator.rawFree(allocated_slice, .of(Node), @returnAddress());
             first_node_ptr.* = null;
             continue;
@@ -173,19 +176,17 @@ pub fn reset(arena: *ArenaAllocator, mode: ResetMode) bool {
         node.end_index = 0;
         first_node_ptr.* = node;
 
-        const adjusted_capacity: usize = mem.alignForward(usize, new_capacity, 2);
-
-        if (allocated_slice.len - @sizeOf(Node) == adjusted_capacity) {
+        if (allocated_slice.len == new_size) {
             // perfect, no need to invoke the child_allocator
             continue;
         }
 
-        if (arena.child_allocator.rawResize(allocated_slice, .of(Node), adjusted_capacity, @returnAddress())) {
+        if (arena.child_allocator.rawResize(allocated_slice, .of(Node), new_size, @returnAddress())) {
             // successful resize
-            node.size = adjusted_capacity;
+            node.size = .fromInt(new_size);
         } else {
             // manual realloc
-            const new_ptr = arena.child_allocator.rawAlloc(adjusted_capacity, .of(Node), @returnAddress()) orelse {
+            const new_ptr = arena.child_allocator.rawAlloc(new_size, .of(Node), @returnAddress()) orelse {
                 // we failed to preheat the arena properly, signal this to the user.
                 ok = false;
                 continue;
@@ -193,7 +194,7 @@ pub fn reset(arena: *ArenaAllocator, mode: ResetMode) bool {
             arena.child_allocator.rawFree(allocated_slice, .of(Node), @returnAddress());
             const new_first_node: *Node = @ptrCast(@alignCast(new_ptr));
             new_first_node.* = .{
-                .size = adjusted_capacity,
+                .size = .fromInt(new_size),
                 .end_index = 0,
                 .next = null,
             };
@@ -224,30 +225,49 @@ const Node = struct {
     /// accessing it.
     next: ?*Node,
 
-    const resize_bit: usize = 1;
+    const Size = packed struct(usize) {
+        resizing: bool,
+        _: @Int(.unsigned, @bitSizeOf(usize) - 1) = 0,
+
+        fn fromInt(int: usize) Size {
+            assert(int >= @sizeOf(Node));
+            const size: Size = @bitCast(int);
+            assert(!size.resizing);
+            return size;
+        }
+
+        fn toInt(size: Size) usize {
+            var int = size;
+            int.resizing = false;
+            return @bitCast(int);
+        }
+
+        comptime {
+            assert(Size{ .resizing = true } == @as(Size, @bitCast(@as(usize, 1))));
+        }
+    };
 
     fn loadBuf(node: *Node) []u8 {
         // monotonic is fine since `size` can only ever grow, so the buffer returned
         // by this function is always valid memory.
-        const size = @atomicLoad(usize, &node.size, .monotonic);
-        return @as([*]u8, @ptrCast(node))[0 .. size & ~resize_bit][@sizeOf(Node)..];
+        const size = @atomicLoad(Size, &node.size, .monotonic);
+        return @as([*]u8, @ptrCast(node))[0..size.toInt()][@sizeOf(Node)..];
     }
 
     /// Returns allocated slice or `null` if node is already (being) resized.
     fn beginResize(node: *Node) ?[]u8 {
-        const size = @atomicRmw(usize, &node.size, .Or, resize_bit, .acquire); // syncs with release in `endResize`
-        if (size & resize_bit != 0) return null;
-        return @as([*]u8, @ptrCast(node))[0..size];
+        const size = @atomicRmw(Size, &node.size, .Or, .{ .resizing = true }, .acquire); // syncs with release in `endResize`
+        if (size.resizing) return null;
+        return @as([*]u8, @ptrCast(node))[0..size.toInt()];
     }
 
     fn endResize(node: *Node, size: usize) void {
-        assert(size & resize_bit == 0);
-        return @atomicStore(usize, &node.size, size, .release); // syncs with acquire in `beginResize`
+        return @atomicStore(Size, &node.size, .fromInt(size), .release); // syncs with acquire in `beginResize`
     }
 
     /// Not threadsafe.
     fn allocatedSliceUnsafe(node: *Node) []u8 {
-        return @as([*]u8, @ptrCast(node))[0 .. node.size & ~resize_bit];
+        return @as([*]u8, @ptrCast(node))[0..node.size.toInt()];
     }
 };
 
@@ -408,7 +428,7 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
                     it = node.next;
                 }) {
                     last_free = node;
-                    assert(node.size & Node.resize_bit == 0);
+                    assert(!node.size.resizing);
                     const buf = node.allocatedSliceUnsafe()[@sizeOf(Node)..];
                     const aligned_index = alignedIndex(buf.ptr, 0, alignment);
 
@@ -433,7 +453,7 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
                         const new_size = mem.alignForward(usize, @sizeOf(Node) + aligned_index + n, 2);
 
                         if (arena.child_allocator.rawResize(allocated_slice, .of(Node), new_size, @returnAddress())) {
-                            node.size = new_size;
+                            node.size = .fromInt(new_size);
                             break :candidate .{ node, best_fit_prev };
                         }
                     }
@@ -486,12 +506,11 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
                 const big_enough_size = prev_size + min_size + 16;
                 break :size mem.alignForward(usize, big_enough_size + big_enough_size / 2, 2);
             };
-            assert(size & Node.resize_bit == 0);
             const ptr = arena.child_allocator.rawAlloc(size, .of(Node), @returnAddress()) orelse
                 return null;
             const new_node: *Node = @ptrCast(@alignCast(ptr));
             new_node.* = .{
-                .size = size,
+                .size = .fromInt(size),
                 .end_index = undefined, // set below
                 .next = undefined, // set below
             };
@@ -501,7 +520,7 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
 
         const buf = new_node.allocatedSliceUnsafe()[@sizeOf(Node)..];
         const aligned_index = alignedIndex(buf.ptr, 0, alignment);
-        assert(new_node.size >= @sizeOf(Node) + aligned_index + n);
+        assert(new_node.size.toInt() >= @sizeOf(Node) + aligned_index + n);
 
         new_node.end_index = aligned_index + n;
         new_node.next = first_node;
@@ -649,6 +668,7 @@ test "reset while retaining a buffer" {
     try std.testing.expect(arena_allocator.state.used_list.?.next != null);
 
     // This retains the first allocated buffer
-    try std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = 1 }));
+    try std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = 2 }));
     try std.testing.expect(arena_allocator.state.used_list.?.next == null);
+    try std.testing.expectEqual(2, arena_allocator.queryCapacity());
 }
-- 
2.54.0


From 2d867223be4139ac55b1be1f5c19eee8a393c62a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 26 Feb 2026 10:11:15 +0100
Subject: [PATCH 346/499] build: use -ffunction-sections -fdata-sections for
 the Zig compiler on ARM

See 7daf0b6f4660245ac518c663f8971aad7e540da8; builds for ARM can run into the
same problems due to limited branch range.
---
 CMakeLists.txt | 2 +-
 build.zig      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4ace4744486c7515a6b4ef5a37fedf6af09c0020..06cc1cd8ddba43e22ee6dd1a39eab58d67851132 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -609,7 +609,7 @@ else()
   set(ZIG1_COMPILE_FLAGS "-std=c99 -Os")
   set(ZIG2_COMPILE_FLAGS "-std=c99 -O0 -fno-sanitize=undefined -fno-stack-protector")
   # Must match the condition in build.zig.
-  if(ZIG_HOST_TARGET_ARCH MATCHES "^powerpc(64)?(le)?$")
+  if(ZIG_HOST_TARGET_ARCH MATCHES "^(arm|thumb)(eb)?$" OR ZIG_HOST_TARGET_ARCH MATCHES "^powerpc(64)?(le)?$")
     set(ZIG1_COMPILE_FLAGS "${ZIG1_COMPILE_FLAGS} -ffunction-sections -fdata-sections")
     set(ZIG2_COMPILE_FLAGS "${ZIG2_COMPILE_FLAGS} -ffunction-sections -fdata-sections")
   endif()
diff --git a/build.zig b/build.zig
index 5b723ad5b266f281a39bf1d51d295997a78c4be0..152ae161d802995dbffdbd112b7b8018a161f51e 100644
--- a/build.zig
+++ b/build.zig
@@ -773,7 +773,7 @@ fn addCompilerStep(b: *std.Build, options: AddCompilerModOptions) *std.Build.Ste
     exe.stack_size = stack_size;
 
     // Must match the condition in CMakeLists.txt.
-    const function_data_sections = options.target.result.cpu.arch.isPowerPC();
+    const function_data_sections = options.target.result.cpu.arch.isArm() or options.target.result.cpu.arch.isPowerPC();
 
     exe.link_function_sections = function_data_sections;
     exe.link_data_sections = function_data_sections;
-- 
2.54.0


From 0b6b65b387cdb145440a33922ab6c3fd10e6071f Mon Sep 17 00:00:00 2001
From: estevesnp <nuno.pinto@live.com>
Date: Wed, 25 Feb 2026 16:14:44 +0000
Subject: [PATCH 347/499] fix: Allow async and concurrent from Io.Select to
 accept non-void error unions

---
 lib/std/Io.zig      |  4 ++--
 lib/std/Io/test.zig | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index cbf1a248470373f6c901c744342b2b5662fee10b..cd846e5dae479ab6cab6c2e5ba60b89fe61444ee 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1238,7 +1238,7 @@ pub fn Select(comptime U: type) type {
                         error.Closed => unreachable,
                     };
                     if (@typeInfo(@TypeOf(raw_result)) == .error_union)
-                        raw_result catch |err| if (err == error.Canceled) return error.Canceled;
+                        _ = raw_result catch |err| if (err == error.Canceled) return error.Canceled;
                 }
             };
             const context: Context = .{ .select = s, .args = args };
@@ -1277,7 +1277,7 @@ pub fn Select(comptime U: type) type {
                         error.Closed => unreachable,
                     };
                     if (@typeInfo(@TypeOf(raw_result)) == .error_union)
-                        raw_result catch |err| if (err == error.Canceled) return error.Canceled;
+                        _ = raw_result catch |err| if (err == error.Canceled) return error.Canceled;
                 }
             };
             const context: Context = .{ .select = s, .args = args };
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 4fc041c749503074914b0f4b65aea48e8359e3fd..5da87cca28de4f898c8e123c1ddb3151e46cc016 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -820,6 +820,10 @@ test "Select" {
         fn bar(io: Io) Io.Cancelable!void {
             try io.sleep(.fromSeconds(300), .awake);
         }
+
+        fn baz() error{Ignored}!u8 {
+            return 42;
+        }
     };
 
     const io = testing.io;
@@ -827,6 +831,7 @@ test "Select" {
     const U = union(enum) {
         foo: bool,
         bar: Io.Cancelable!void,
+        baz: error{Ignored}!u8,
     };
     var buffer: [4]U = undefined;
     var select: Io.Select(U) = .init(io, &buffer);
@@ -840,6 +845,7 @@ test "Select" {
     switch (try select.await()) {
         .foo => {},
         .bar => return error.TestFailed, // should be sleeping
+        .baz => return error.TestFailed, // not called yet
     }
     select.async(.foo, S.foo, .{});
     select.async(.foo, S.foo, .{});
@@ -847,4 +853,14 @@ test "Select" {
     var finished_buffer: [3]U = undefined;
     const finished = finished_buffer[0..try select.awaitMany(&finished_buffer, 2)];
     try testing.expectEqualSlices(U, &.{ .{ .foo = true }, .{ .foo = true } }, finished);
+
+    select.async(.baz, S.baz, .{});
+
+    const result = switch (try select.await()) {
+        .baz => |n| try n,
+        .foo => return error.TestFailed, // not called
+        .bar => return error.TestFailed, // should be sleeping
+    };
+
+    try testing.expectEqual(42, result);
 }
-- 
2.54.0


From 4e2cec265d37afd5ad320d0430060308de65326f Mon Sep 17 00:00:00 2001
From: Saurabh Mishra <saurabh.m@proton.me>
Date: Thu, 26 Feb 2026 21:09:52 +0100
Subject: [PATCH 348/499] Make `std.PriorityQueue` an unmanaged container
 (#31299)

## Summary of changes

+ Make adjustments to the `allocator` field and ensure the below tests pass:

  ```sh
  zig test lib/std/std.zig --zig-lib-dir lib
  zig build test-std -Dno-matrix --summary all
  ```

+ Rename `add` to `push` and `remove` to `pop` in methods and tests

+ Incorporate the functionality of `pop` in `popOrNull`, then rename the `popOrNull` to `pop` and update tests

+ Use `.empty` to set default field values and rename the `init` method to `initContext`

+ Improve variable types in tests: min heap uses the less than context function and max heap uses greater than context function

+ Remove the `dump` method as its not being used anywhere

+ Document methods `clearRetainingCapacity`, `clearAndFree`, `update`, and `ensureTotalCapacityPrecise`

Closes https://codeberg.org/ziglang/zig/issues/31298

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31299
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: Saurabh Mishra <saurabh.m@proton.me>
Co-committed-by: Saurabh Mishra <saurabh.m@proton.me>
---
 lib/std/priority_queue.zig | 505 ++++++++++++++++++++-----------------
 1 file changed, 273 insertions(+), 232 deletions(-)

diff --git a/lib/std/priority_queue.zig b/lib/std/priority_queue.zig
index 3eae43f3c6fa83a4558606c560ce11d5d792d4a5..cb70d6c123c1a9e76401efb7d97a4bedce30c2b2 100644
--- a/lib/std/priority_queue.zig
+++ b/lib/std/priority_queue.zig
@@ -20,31 +20,36 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
 
         items: []T,
         cap: usize,
-        allocator: Allocator,
         context: Context,
 
-        /// Initialize and return a priority queue.
-        pub fn init(allocator: Allocator, context: Context) Self {
+        /// A priority queue containing no elements.
+        pub const empty: Self = .{
+            .items = &.{},
+            .cap = 0,
+            .context = undefined,
+        };
+
+        /// Initialize and return a priority queue with context.
+        pub fn initContext(context: Context) Self {
             return Self{
-                .items = &[_]T{},
+                .items = &.{},
                 .cap = 0,
-                .allocator = allocator,
                 .context = context,
             };
         }
 
         /// Free memory used by the queue.
-        pub fn deinit(self: Self) void {
-            self.allocator.free(self.allocatedSlice());
+        pub fn deinit(self: *Self, allocator: Allocator) void {
+            allocator.free(self.allocatedSlice());
         }
 
         /// Insert a new element, maintaining priority.
-        pub fn add(self: *Self, elem: T) !void {
-            try self.ensureUnusedCapacity(1);
-            addUnchecked(self, elem);
+        pub fn push(self: *Self, allocator: Allocator, elem: T) !void {
+            try self.ensureUnusedCapacity(allocator, 1);
+            pushUnchecked(self, elem);
         }
 
-        fn addUnchecked(self: *Self, elem: T) void {
+        fn pushUnchecked(self: *Self, elem: T) void {
             self.items.len += 1;
             self.items[self.items.len - 1] = elem;
             siftUp(self, self.items.len - 1);
@@ -64,10 +69,10 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
         }
 
         /// Add each element in `items` to the queue.
-        pub fn addSlice(self: *Self, items: []const T) !void {
-            try self.ensureUnusedCapacity(items.len);
+        pub fn pushSlice(self: *Self, allocator: Allocator, items: []const T) !void {
+            try self.ensureUnusedCapacity(allocator, items.len);
             for (items) |e| {
-                self.addUnchecked(e);
+                self.pushUnchecked(e);
             }
         }
 
@@ -77,22 +82,16 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
             return if (self.items.len > 0) self.items[0] else null;
         }
 
-        /// Pop the highest priority element from the queue. Returns
-        /// `null` if empty.
-        pub fn removeOrNull(self: *Self) ?T {
-            return if (self.items.len > 0) self.remove() else null;
-        }
-
-        /// Remove and return the highest priority element from the
-        /// queue.
-        pub fn remove(self: *Self) T {
-            return self.removeIndex(0);
+        /// Remove and return the highest priority element from the queue.
+        /// Returns `null` if empty.
+        pub fn pop(self: *Self) ?T {
+            return if (self.items.len > 0) self.popIndex(0) else null;
         }
 
         /// Remove and return element at index. Indices are in the
         /// same order as iterator, which is not necessarily priority
         /// order.
-        pub fn removeIndex(self: *Self, index: usize) T {
+        pub fn popIndex(self: *Self, index: usize) T {
             assert(self.items.len > index);
             const last = self.items[self.items.len - 1];
             const item = self.items[index];
@@ -158,11 +157,10 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
         /// PriorityQueue takes ownership of the passed in slice. The slice must have been
         /// allocated with `allocator`.
         /// Deinitialize with `deinit`.
-        pub fn fromOwnedSlice(allocator: Allocator, items: []T, context: Context) Self {
+        pub fn fromOwnedSlice(items: []T, context: Context) Self {
             var self = Self{
                 .items = items,
                 .cap = items.len,
-                .allocator = allocator,
                 .context = context,
             };
 
@@ -175,39 +173,42 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
         }
 
         /// Ensure that the queue can fit at least `new_capacity` items.
-        pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
+        pub fn ensureTotalCapacity(self: *Self, allocator: Allocator, new_capacity: usize) !void {
             var better_capacity = self.cap;
             if (better_capacity >= new_capacity) return;
             while (true) {
                 better_capacity += better_capacity / 2 + 8;
                 if (better_capacity >= new_capacity) break;
             }
-            try self.ensureTotalCapacityPrecise(better_capacity);
+            try self.ensureTotalCapacityPrecise(allocator, better_capacity);
         }
 
-        pub fn ensureTotalCapacityPrecise(self: *Self, new_capacity: usize) !void {
+        /// If the current capacity is less than `new_capacity`, this function will
+        /// modify the array so that it can hold exactly `new_capacity` items.
+        /// Invalidates element pointers if additional memory is needed.
+        pub fn ensureTotalCapacityPrecise(self: *Self, allocator: Allocator, new_capacity: usize) !void {
             if (self.capacity() >= new_capacity) return;
 
             const old_memory = self.allocatedSlice();
-            const new_memory = try self.allocator.realloc(old_memory, new_capacity);
+            const new_memory = try allocator.realloc(old_memory, new_capacity);
             self.items.ptr = new_memory.ptr;
             self.cap = new_memory.len;
         }
 
         /// Ensure that the queue can fit at least `additional_count` **more** item.
-        pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void {
-            return self.ensureTotalCapacity(self.items.len + additional_count);
+        pub fn ensureUnusedCapacity(self: *Self, allocator: Allocator, additional_count: usize) !void {
+            return self.ensureTotalCapacity(allocator, self.items.len + additional_count);
         }
 
         /// Reduce allocated capacity to `new_capacity`.
-        pub fn shrinkAndFree(self: *Self, new_capacity: usize) void {
+        pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_capacity: usize) void {
             assert(new_capacity <= self.cap);
 
             // Cannot shrink to smaller than the current queue size without invalidating the heap property
             assert(new_capacity >= self.items.len);
 
             const old_memory = self.allocatedSlice();
-            const new_memory = self.allocator.realloc(old_memory, new_capacity) catch |e| switch (e) {
+            const new_memory = allocator.realloc(old_memory, new_capacity) catch |e| switch (e) {
                 error.OutOfMemory => { // no problem, capacity is still correct then.
                     return;
                 },
@@ -217,16 +218,20 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
             self.cap = new_memory.len;
         }
 
+        /// Remove all elements from the items slice.
         pub fn clearRetainingCapacity(self: *Self) void {
             self.items.len = 0;
         }
 
-        pub fn clearAndFree(self: *Self) void {
-            self.allocator.free(self.allocatedSlice());
+        /// Invalidates all element pointers.
+        pub fn clearAndFree(self: *Self, allocator: Allocator) void {
+            allocator.free(self.allocatedSlice());
             self.items.len = 0;
             self.cap = 0;
         }
 
+        /// Replace an element in the queue with a new element, maintaining priority.
+        /// If the element being updated doesn't exist, return `error.ElementNotFound`.
         pub fn update(self: *Self, elem: T, new_elem: T) !void {
             const update_index = blk: {
                 var idx: usize = 0;
@@ -270,22 +275,6 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
                 .count = 0,
             };
         }
-
-        fn dump(self: *Self) void {
-            const print = std.debug.print;
-            print("{{ ", .{});
-            print("items: ", .{});
-            for (self.items) |e| {
-                print("{}, ", .{e});
-            }
-            print("array: ", .{});
-            for (self.items) |e| {
-                print("{}, ", .{e});
-            }
-            print("len: {} ", .{self.items.len});
-            print("capacity: {}", .{self.cap});
-            print(" }}\n", .{});
-        }
     };
 }
 
@@ -298,181 +287,213 @@ fn greaterThan(context: void, a: u32, b: u32) Order {
     return lessThan(context, a, b).invert();
 }
 
-const PQlt = PriorityQueue(u32, void, lessThan);
-const PQgt = PriorityQueue(u32, void, greaterThan);
+const MinHeap = PriorityQueue(u32, void, lessThan);
+const MaxHeap = PriorityQueue(u32, void, greaterThan);
 
 test "add and remove min heap" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(54);
-    try queue.add(12);
-    try queue.add(7);
-    try queue.add(23);
-    try queue.add(25);
-    try queue.add(13);
-    try expectEqual(@as(u32, 7), queue.remove());
-    try expectEqual(@as(u32, 12), queue.remove());
-    try expectEqual(@as(u32, 13), queue.remove());
-    try expectEqual(@as(u32, 23), queue.remove());
-    try expectEqual(@as(u32, 25), queue.remove());
-    try expectEqual(@as(u32, 54), queue.remove());
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 54);
+    try queue.push(gpa, 12);
+    try queue.push(gpa, 7);
+    try queue.push(gpa, 23);
+    try queue.push(gpa, 25);
+    try queue.push(gpa, 13);
+    try expectEqual(@as(u32, 7), queue.pop());
+    try expectEqual(@as(u32, 12), queue.pop());
+    try expectEqual(@as(u32, 13), queue.pop());
+    try expectEqual(@as(u32, 23), queue.pop());
+    try expectEqual(@as(u32, 25), queue.pop());
+    try expectEqual(@as(u32, 54), queue.pop());
 }
 
 test "add and remove same min heap" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
-    try queue.add(1);
-    try queue.add(1);
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 2), queue.remove());
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 2), queue.pop());
 }
 
 test "removeOrNull on empty" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try expect(queue.removeOrNull() == null);
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try expect(queue.pop() == null);
 }
 
 test "edge case 3 elements" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(9);
-    try queue.add(3);
-    try queue.add(2);
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 3), queue.remove());
-    try expectEqual(@as(u32, 9), queue.remove());
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 9);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 3), queue.pop());
+    try expectEqual(@as(u32, 9), queue.pop());
 }
 
 test "peek" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
+
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
 
     try expect(queue.peek() == null);
-    try queue.add(9);
-    try queue.add(3);
-    try queue.add(2);
+    try queue.push(gpa, 9);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 2);
     try expectEqual(@as(u32, 2), queue.peek().?);
     try expectEqual(@as(u32, 2), queue.peek().?);
 }
 
 test "sift up with odd indices" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
+
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     for (items) |e| {
-        try queue.add(e);
+        try queue.push(gpa, e);
     }
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.remove());
+        try expectEqual(e, queue.pop());
     }
 }
 
 test "addSlice" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
+
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    try queue.addSlice(items[0..]);
+    try queue.pushSlice(gpa, items[0..]);
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.remove());
+        try expectEqual(e, queue.pop());
     }
 }
 
 test "fromOwnedSlice trivial case 0" {
+    const gpa = testing.allocator;
+
     const items = [0]u32{};
-    const queue_items = try testing.allocator.dupe(u32, &items);
-    var queue = PQlt.fromOwnedSlice(testing.allocator, queue_items[0..], {});
-    defer queue.deinit();
+    const queue_items = try gpa.dupe(u32, &items);
+
+    var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {});
+    defer queue.deinit(gpa);
+
     try expectEqual(@as(usize, 0), queue.count());
-    try expect(queue.removeOrNull() == null);
+    try expect(queue.pop() == null);
 }
 
 test "fromOwnedSlice trivial case 1" {
+    const gpa = testing.allocator;
+
     const items = [1]u32{1};
-    const queue_items = try testing.allocator.dupe(u32, &items);
-    var queue = PQlt.fromOwnedSlice(testing.allocator, queue_items[0..], {});
-    defer queue.deinit();
+    const queue_items = try gpa.dupe(u32, &items);
+
+    var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {});
+    defer queue.deinit(gpa);
 
     try expectEqual(@as(usize, 1), queue.count());
-    try expectEqual(items[0], queue.remove());
-    try expect(queue.removeOrNull() == null);
+    try expectEqual(items[0], queue.pop());
+    try expect(queue.pop() == null);
 }
 
 test "fromOwnedSlice" {
+    const gpa = testing.allocator;
+
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    const heap_items = try testing.allocator.dupe(u32, items[0..]);
-    var queue = PQlt.fromOwnedSlice(testing.allocator, heap_items[0..], {});
-    defer queue.deinit();
+    const heap_items = try gpa.dupe(u32, items[0..]);
+
+    var queue: MinHeap = .fromOwnedSlice(heap_items[0..], {});
+    defer queue.deinit(gpa);
 
     const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.remove());
+        try expectEqual(e, queue.pop());
     }
 }
 
 test "add and remove max heap" {
-    var queue = PQgt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(54);
-    try queue.add(12);
-    try queue.add(7);
-    try queue.add(23);
-    try queue.add(25);
-    try queue.add(13);
-    try expectEqual(@as(u32, 54), queue.remove());
-    try expectEqual(@as(u32, 25), queue.remove());
-    try expectEqual(@as(u32, 23), queue.remove());
-    try expectEqual(@as(u32, 13), queue.remove());
-    try expectEqual(@as(u32, 12), queue.remove());
-    try expectEqual(@as(u32, 7), queue.remove());
+    var queue: MaxHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 54);
+    try queue.push(gpa, 12);
+    try queue.push(gpa, 7);
+    try queue.push(gpa, 23);
+    try queue.push(gpa, 25);
+    try queue.push(gpa, 13);
+    try expectEqual(@as(u32, 54), queue.pop());
+    try expectEqual(@as(u32, 25), queue.pop());
+    try expectEqual(@as(u32, 23), queue.pop());
+    try expectEqual(@as(u32, 13), queue.pop());
+    try expectEqual(@as(u32, 12), queue.pop());
+    try expectEqual(@as(u32, 7), queue.pop());
 }
 
 test "add and remove same max heap" {
-    var queue = PQgt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
-    try queue.add(1);
-    try queue.add(1);
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
+    var queue: MaxHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
 }
 
 test "iterator" {
-    var queue = PQlt.init(testing.allocator, {});
+    const gpa = testing.allocator;
+
+    var queue: MinHeap = .empty;
     var map = std.AutoHashMap(u32, void).init(testing.allocator);
     defer {
-        queue.deinit();
+        queue.deinit(gpa);
         map.deinit();
     }
 
     const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
     for (items) |e| {
-        _ = try queue.add(e);
+        _ = try queue.push(gpa, e);
         try map.put(e, {});
     }
 
@@ -485,12 +506,14 @@ test "iterator" {
 }
 
 test "remove at index" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
+
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
 
     const items = [_]u32{ 2, 1, 8, 9, 3, 4, 5 };
     for (items) |e| {
-        _ = try queue.add(e);
+        _ = try queue.push(gpa, e);
     }
 
     var it = queue.iterator();
@@ -501,18 +524,20 @@ test "remove at index" {
         idx += 1;
     } else unreachable;
     const sorted_items = [_]u32{ 1, 3, 4, 5, 8, 9 };
-    try expectEqual(queue.removeIndex(two_idx), 2);
+    try expectEqual(queue.popIndex(two_idx), 2);
 
     var i: usize = 0;
-    while (queue.removeOrNull()) |n| : (i += 1) {
+    while (queue.pop()) |n| : (i += 1) {
         try expectEqual(n, sorted_items[i]);
     }
-    try expectEqual(queue.removeOrNull(), null);
+    try expectEqual(queue.pop(), null);
 }
 
 test "iterator while empty" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
+
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
 
     var it = queue.iterator();
 
@@ -520,110 +545,124 @@ test "iterator while empty" {
 }
 
 test "shrinkAndFree" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.ensureTotalCapacity(4);
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.ensureTotalCapacity(gpa, 4);
     try expect(queue.capacity() >= 4);
 
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(3);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 3);
     try expect(queue.capacity() >= 4);
     try expectEqual(@as(usize, 3), queue.count());
 
-    queue.shrinkAndFree(3);
+    queue.shrinkAndFree(gpa, 3);
     try expectEqual(@as(usize, 3), queue.capacity());
     try expectEqual(@as(usize, 3), queue.count());
 
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 3), queue.remove());
-    try expect(queue.removeOrNull() == null);
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 3), queue.pop());
+    try expect(queue.pop() == null);
 }
 
 test "update min heap" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(55);
-    try queue.add(44);
-    try queue.add(11);
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 55);
+    try queue.push(gpa, 44);
+    try queue.push(gpa, 11);
     try queue.update(55, 5);
     try queue.update(44, 4);
     try queue.update(11, 1);
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 4), queue.remove());
-    try expectEqual(@as(u32, 5), queue.remove());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 4), queue.pop());
+    try expectEqual(@as(u32, 5), queue.pop());
 }
 
 test "update same min heap" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
     try queue.update(1, 5);
     try queue.update(2, 4);
-    try expectEqual(@as(u32, 1), queue.remove());
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 4), queue.remove());
-    try expectEqual(@as(u32, 5), queue.remove());
+    try expectEqual(@as(u32, 1), queue.pop());
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 4), queue.pop());
+    try expectEqual(@as(u32, 5), queue.pop());
 }
 
 test "update max heap" {
-    var queue = PQgt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(55);
-    try queue.add(44);
-    try queue.add(11);
+    var queue: MaxHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 55);
+    try queue.push(gpa, 44);
+    try queue.push(gpa, 11);
     try queue.update(55, 5);
     try queue.update(44, 1);
     try queue.update(11, 4);
-    try expectEqual(@as(u32, 5), queue.remove());
-    try expectEqual(@as(u32, 4), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
+    try expectEqual(@as(u32, 5), queue.pop());
+    try expectEqual(@as(u32, 4), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
 }
 
 test "update same max heap" {
-    var queue = PQgt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(1);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(2);
+    var queue: MaxHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 2);
     try queue.update(1, 5);
     try queue.update(2, 4);
-    try expectEqual(@as(u32, 5), queue.remove());
-    try expectEqual(@as(u32, 4), queue.remove());
-    try expectEqual(@as(u32, 2), queue.remove());
-    try expectEqual(@as(u32, 1), queue.remove());
+    try expectEqual(@as(u32, 5), queue.pop());
+    try expectEqual(@as(u32, 4), queue.pop());
+    try expectEqual(@as(u32, 2), queue.pop());
+    try expectEqual(@as(u32, 1), queue.pop());
 }
 
 test "update after remove" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.add(1);
-    try expectEqual(@as(u32, 1), queue.remove());
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
+
+    try queue.push(gpa, 1);
+    try expectEqual(@as(u32, 1), queue.pop());
     try expectError(error.ElementNotFound, queue.update(1, 1));
 }
 
 test "siftUp in remove" {
-    var queue = PQlt.init(testing.allocator, {});
-    defer queue.deinit();
+    const gpa = testing.allocator;
 
-    try queue.addSlice(&.{ 0, 1, 100, 2, 3, 101, 102, 4, 5, 6, 7, 103, 104, 105, 106, 8 });
+    var queue: MinHeap = .empty;
+    defer queue.deinit(gpa);
 
-    _ = queue.removeIndex(std.mem.findScalar(u32, queue.items[0..queue.count()], 102).?);
+    try queue.pushSlice(gpa, &.{ 0, 1, 100, 2, 3, 101, 102, 4, 5, 6, 7, 103, 104, 105, 106, 8 });
+
+    _ = queue.popIndex(std.mem.findScalar(u32, queue.items[0..queue.count()], 102).?);
 
     const sorted_items = [_]u32{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 100, 101, 103, 104, 105, 106 };
     for (sorted_items) |e| {
-        try expectEqual(e, queue.remove());
+        try expectEqual(e, queue.pop());
     }
 }
 
@@ -631,26 +670,28 @@ fn contextLessThan(context: []const u32, a: usize, b: usize) Order {
     return std.math.order(context[a], context[b]);
 }
 
-const CPQlt = PriorityQueue(usize, []const u32, contextLessThan);
+const MinHeapWithContext = PriorityQueue(usize, []const u32, contextLessThan);
 
 test "add and remove min heap with context comparator" {
+    const gpa = testing.allocator;
+
     const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
 
-    var queue = CPQlt.init(testing.allocator, context[0..]);
-    defer queue.deinit();
+    var queue: MinHeapWithContext = .initContext(context[0..]);
+    defer queue.deinit(gpa);
 
-    try queue.add(0);
-    try queue.add(1);
-    try queue.add(2);
-    try queue.add(3);
-    try queue.add(4);
-    try queue.add(5);
-    try queue.add(6);
-    try expectEqual(@as(usize, 6), queue.remove());
-    try expectEqual(@as(usize, 4), queue.remove());
-    try expectEqual(@as(usize, 3), queue.remove());
-    try expectEqual(@as(usize, 1), queue.remove());
-    try expectEqual(@as(usize, 2), queue.remove());
-    try expectEqual(@as(usize, 0), queue.remove());
-    try expectEqual(@as(usize, 5), queue.remove());
+    try queue.push(gpa, 0);
+    try queue.push(gpa, 1);
+    try queue.push(gpa, 2);
+    try queue.push(gpa, 3);
+    try queue.push(gpa, 4);
+    try queue.push(gpa, 5);
+    try queue.push(gpa, 6);
+    try expectEqual(@as(usize, 6), queue.pop());
+    try expectEqual(@as(usize, 4), queue.pop());
+    try expectEqual(@as(usize, 3), queue.pop());
+    try expectEqual(@as(usize, 1), queue.pop());
+    try expectEqual(@as(usize, 2), queue.pop());
+    try expectEqual(@as(usize, 0), queue.pop());
+    try expectEqual(@as(usize, 5), queue.pop());
 }
-- 
2.54.0


From bbc77df3eb91b9c9dc6b334cd344670f64c4a457 Mon Sep 17 00:00:00 2001
From: Justus Klausecker <justus@klausecker.de>
Date: Thu, 26 Feb 2026 21:12:22 +0100
Subject: [PATCH 349/499] std.heap: delete `ThreadSafeAllocator`

We can keep ourselves safe from those threads perfectly well without you, thanks!
---
 lib/std/heap.zig                     |  2 -
 lib/std/heap/ThreadSafeAllocator.zig | 62 ----------------------------
 2 files changed, 64 deletions(-)
 delete mode 100644 lib/std/heap/ThreadSafeAllocator.zig

diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index 18fec1197fcf89b66eeecbba887edc38165a0b4b..cc8693f650c2d703542788971c132efed020d230 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -13,7 +13,6 @@ pub const ArenaAllocator = @import("heap/ArenaAllocator.zig");
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
-pub const ThreadSafeAllocator = @import("heap/ThreadSafeAllocator.zig");
 pub const WasmAllocator = if (builtin.single_threaded) BrkAllocator else @compileError("unimplemented");
 pub const BrkAllocator = @import("heap/BrkAllocator.zig");
 
@@ -1009,7 +1008,6 @@ test {
     _ = ArenaAllocator;
     _ = GeneralPurposeAllocator;
     _ = FixedBufferAllocator;
-    _ = ThreadSafeAllocator;
     if (builtin.single_threaded) {
         if (builtin.cpu.arch.isWasm() or (builtin.os.tag == .linux and !builtin.link_libc)) {
             _ = brk_allocator;
diff --git a/lib/std/heap/ThreadSafeAllocator.zig b/lib/std/heap/ThreadSafeAllocator.zig
deleted file mode 100644
index 6999213937a95fa1792b964c0237e46e5b8c0ba7..0000000000000000000000000000000000000000
--- a/lib/std/heap/ThreadSafeAllocator.zig
+++ /dev/null
@@ -1,62 +0,0 @@
-//! Deprecated. Thread safety should be built into each Allocator instance
-//! directly rather than trying to do this "composable allocators" thing.
-const ThreadSafeAllocator = @This();
-
-const std = @import("../std.zig");
-const Io = std.Io;
-const Allocator = std.mem.Allocator;
-
-child_allocator: Allocator,
-io: Io,
-mutex: Io.Mutex = .init,
-
-pub fn allocator(self: *ThreadSafeAllocator) Allocator {
-    return .{
-        .ptr = self,
-        .vtable = &.{
-            .alloc = alloc,
-            .resize = resize,
-            .remap = remap,
-            .free = free,
-        },
-    };
-}
-
-fn alloc(ctx: *anyopaque, n: usize, alignment: std.mem.Alignment, ra: usize) ?[*]u8 {
-    const self: *ThreadSafeAllocator = @ptrCast(@alignCast(ctx));
-    const io = self.io;
-    self.mutex.lockUncancelable(io);
-    defer self.mutex.unlock(io);
-
-    return self.child_allocator.rawAlloc(n, alignment, ra);
-}
-
-fn resize(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ret_addr: usize) bool {
-    const self: *ThreadSafeAllocator = @ptrCast(@alignCast(ctx));
-    const io = self.io;
-
-    self.mutex.lockUncancelable(io);
-    defer self.mutex.unlock(io);
-
-    return self.child_allocator.rawResize(buf, alignment, new_len, ret_addr);
-}
-
-fn remap(context: *anyopaque, memory: []u8, alignment: std.mem.Alignment, new_len: usize, return_address: usize) ?[*]u8 {
-    const self: *ThreadSafeAllocator = @ptrCast(@alignCast(context));
-    const io = self.io;
-
-    self.mutex.lockUncancelable(io);
-    defer self.mutex.unlock(io);
-
-    return self.child_allocator.rawRemap(memory, alignment, new_len, return_address);
-}
-
-fn free(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, ret_addr: usize) void {
-    const self: *ThreadSafeAllocator = @ptrCast(@alignCast(ctx));
-    const io = self.io;
-
-    self.mutex.lockUncancelable(io);
-    defer self.mutex.unlock(io);
-
-    return self.child_allocator.rawFree(buf, alignment, ret_addr);
-}
-- 
2.54.0


From b781615e09c53a322e3ed8d88eb3fac10259eb56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 27 Feb 2026 08:49:13 +0100
Subject: [PATCH 350/499] test: disable an error trace test on optimized
 aarch64-freebsd

---
 test/error_traces.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/error_traces.zig b/test/error_traces.zig
index 5a4d1d86de6870b13272b7dbe235655775773e7a..1e6f338eee5e2b9f5d63ed7dd385cc2c5ab24e17 100644
--- a/test/error_traces.zig
+++ b/test/error_traces.zig
@@ -435,6 +435,7 @@ pub fn addCases(cases: *@import("tests.zig").ErrorTracesContext) void {
             .{ .x86_64, .netbsd },
             .{ .x86_64, .linux },
             .{ .x86, .linux },
+            .{ .aarch64, .freebsd },
             .{ .aarch64, .linux },
             .{ .loongarch64, .linux },
             .{ .powerpc64le, .linux },
-- 
2.54.0


From d130f76babf7d11b17c079b51f92fb7024fd3286 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 27 Feb 2026 07:14:11 +0100
Subject: [PATCH 351/499] ci: add aarch64-freebsd scripts

---
 ci/aarch64-freebsd-debug.sh   | 63 ++++++++++++++++++++++++++++++++
 ci/aarch64-freebsd-release.sh | 69 +++++++++++++++++++++++++++++++++++
 2 files changed, 132 insertions(+)
 create mode 100755 ci/aarch64-freebsd-debug.sh
 create mode 100755 ci/aarch64-freebsd-release.sh

diff --git a/ci/aarch64-freebsd-debug.sh b/ci/aarch64-freebsd-debug.sh
new file mode 100755
index 0000000000000000000000000000000000000000..c296a50fd15388ae07286336b32bd0b9157849ec
--- /dev/null
+++ b/ci/aarch64-freebsd-debug.sh
@@ -0,0 +1,63 @@
+#!/bin/sh
+
+# Requires cmake ninja-build
+
+set -x
+set -e
+
+TARGET="aarch64-freebsd-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
+PREFIX="$HOME/deps/$CACHE_BASENAME"
+ZIG="$PREFIX/bin/zig"
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+mkdir build-debug
+cd build-debug
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Debug \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja \
+  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
+  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
+# https://github.com/ziglang/zig/issues/22213
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+stage3-debug/bin/zig build test docs \
+  --maxrss ${ZSF_MAX_RSS:-0} \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  -Dskip-test-incremental \
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib" \
+  --test-timeout 2m
+
+stage3-debug/bin/zig build \
+  --prefix stage4-debug \
+  -Denable-llvm \
+  -Dno-lib \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3-debug/bin/zig version)"
+
+stage4-debug/bin/zig test ../test/behavior.zig
diff --git a/ci/aarch64-freebsd-release.sh b/ci/aarch64-freebsd-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..1686327fb0b7da983d1f98fbd5d4188f01768d62
--- /dev/null
+++ b/ci/aarch64-freebsd-release.sh
@@ -0,0 +1,69 @@
+#!/bin/sh
+
+# Requires cmake ninja-build
+
+set -x
+set -e
+
+TARGET="aarch64-freebsd-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
+PREFIX="$HOME/deps/$CACHE_BASENAME"
+ZIG="$PREFIX/bin/zig"
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+mkdir build-release
+cd build-release
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-release" \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja \
+  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
+  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
+# https://github.com/ziglang/zig/issues/22213
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+stage3-release/bin/zig build test docs \
+  --maxrss ${ZSF_MAX_RSS:-0} \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  -Dskip-test-incremental \
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib" \
+  --test-timeout 2m
+
+# Ensure that stage3 and stage4 are byte-for-byte identical.
+stage3-release/bin/zig build \
+  --prefix stage4-release \
+  -Denable-llvm \
+  -Dno-lib \
+  -Doptimize=ReleaseFast \
+  -Dstrip \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3-release/bin/zig version)"
+
+# diff returns an error code if the files differ.
+echo "If the following command fails, it means nondeterminism has been"
+echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
+diff stage3-release/bin/zig stage4-release/bin/zig
-- 
2.54.0


From 2da1370a7e8d378ab810c581d5e009b27b47fa62 Mon Sep 17 00:00:00 2001
From: Nils Juto <nilsjuto@posteo.net>
Date: Fri, 27 Feb 2026 13:50:12 +0100
Subject: [PATCH 352/499] sync `CallModifier` in langref with what's actually
 there

---
 doc/langref/builtin.CallModifier struct.zig | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/doc/langref/builtin.CallModifier struct.zig b/doc/langref/builtin.CallModifier struct.zig
index 60fc4f2ac4e4248c9ad462c28d6235fd9c8d6002..2626441a9e294fc449e7bc4dd9cf375ba2576a58 100644
--- a/doc/langref/builtin.CallModifier struct.zig	
+++ b/doc/langref/builtin.CallModifier struct.zig	
@@ -2,9 +2,6 @@ pub const CallModifier = enum {
     /// Equivalent to function call syntax.
     auto,
 
-    /// Equivalent to async keyword used with function call syntax.
-    async_kw,
-
     /// Prevents tail call optimization. This guarantees that the return
     /// address will point to the callsite, as opposed to the callsite's
     /// callsite. If the call is otherwise required to be tail-called
@@ -17,7 +14,7 @@ pub const CallModifier = enum {
 
     /// Asserts that the function call will not suspend. This allows a
     /// non-async function to call an async function.
-    no_async,
+    no_suspend,
 
     /// Guarantees that the call will be generated with tail call optimization.
     /// If this is not possible, a compile error is emitted instead.
-- 
2.54.0


From e779ca72230b5975f48c84ae19c51f0c74f9ecbe Mon Sep 17 00:00:00 2001
From: mintonmu <mintonmu@outlook.com>
Date: Mon, 26 Jan 2026 15:57:34 +0800
Subject: [PATCH 353/499] fix(docs/wasm):zig std html render error function 'a'

---
 lib/docs/wasm/Walk.zig | 88 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 84 insertions(+), 4 deletions(-)

diff --git a/lib/docs/wasm/Walk.zig b/lib/docs/wasm/Walk.zig
index 074d4c2f1462668a6e044cadc0f0e735a83e7a3e..d361f978c0982e679d42c24967b5d11ccb906ed2 100644
--- a/lib/docs/wasm/Walk.zig
+++ b/lib/docs/wasm/Walk.zig
@@ -567,7 +567,7 @@ fn struct_decl(
         .aligned_var_decl,
         => {
             const decl_index = try w.file.add_decl(member, parent_decl);
-            try w.global_var_decl(&namespace.base, decl_index, ast.fullVarDecl(member).?);
+            try w.global_var_decl(&namespace.base, decl_index, true, ast.fullVarDecl(member).?);
         },
 
         .@"comptime",
@@ -579,6 +579,61 @@ fn struct_decl(
     };
 }
 
+/// Traverses a container decl used as an expression without registering its members
+/// as `Decl` entries. This prevents local/test-only helper declarations from
+/// leaking into autodoc symbol lists.
+fn struct_expr(
+    w: *Walk,
+    scope: *Scope,
+    parent_decl: Decl.Index,
+    node: Ast.Node.Index,
+    container_decl: Ast.full.ContainerDecl,
+) Oom!void {
+    const ast = w.file.get_ast();
+
+    const namespace = try gpa.create(Scope.Namespace);
+    namespace.* = .{
+        .parent = scope,
+        .decl_index = parent_decl,
+    };
+    try w.file.get().scopes.putNoClobber(gpa, node, &namespace.base);
+    try w.scanDecls(namespace, container_decl.ast.members);
+
+    for (container_decl.ast.members) |member| switch (ast.nodeTag(member)) {
+        .container_field_init,
+        .container_field_align,
+        .container_field,
+        => try w.container_field(&namespace.base, parent_decl, ast.fullContainerField(member).?),
+
+        .fn_proto,
+        .fn_proto_multi,
+        .fn_proto_one,
+        .fn_proto_simple,
+        .fn_decl,
+        => {
+            var buf: [1]Ast.Node.Index = undefined;
+            const full = ast.fullFnProto(&buf, member).?;
+            const body = if (ast.nodeTag(member) == .fn_decl) ast.nodeData(member).node_and_node[1].toOptional() else .none;
+            try w.fn_decl(&namespace.base, parent_decl, body, full);
+        },
+
+        .global_var_decl,
+        .local_var_decl,
+        .simple_var_decl,
+        .aligned_var_decl,
+        => {
+            // Do not create Decl entries; just walk initializer expressions.
+            try w.global_var_decl(&namespace.base, parent_decl, false, ast.fullVarDecl(member).?);
+        },
+
+        .@"comptime" => try w.expr(&namespace.base, parent_decl, ast.nodeData(member).node),
+
+        .test_decl => try w.expr(&namespace.base, parent_decl, ast.nodeData(member).opt_token_and_node[1]),
+
+        else => unreachable,
+    };
+}
+
 fn comptime_decl(
     w: *Walk,
     scope: *Scope,
@@ -596,13 +651,38 @@ fn global_var_decl(
     w: *Walk,
     scope: *Scope,
     parent_decl: Decl.Index,
+    register_container_members: bool,
     full: Ast.full.VarDecl,
 ) Oom!void {
     try w.maybe_expr(scope, parent_decl, full.ast.type_node);
     try w.maybe_expr(scope, parent_decl, full.ast.align_node);
     try w.maybe_expr(scope, parent_decl, full.ast.addrspace_node);
     try w.maybe_expr(scope, parent_decl, full.ast.section_node);
-    try w.maybe_expr(scope, parent_decl, full.ast.init_node);
+
+    if (full.ast.init_node.unwrap()) |init_node| {
+        if (register_container_members) {
+            switch (w.file.get_ast().nodeTag(init_node)) {
+                .container_decl,
+                .container_decl_trailing,
+                .container_decl_arg,
+                .container_decl_arg_trailing,
+                .container_decl_two,
+                .container_decl_two_trailing,
+                .tagged_union,
+                .tagged_union_trailing,
+                .tagged_union_enum_tag,
+                .tagged_union_enum_tag_trailing,
+                .tagged_union_two,
+                .tagged_union_two_trailing,
+                => {
+                    var buf: [2]Ast.Node.Index = undefined;
+                    return struct_decl(w, scope, parent_decl, init_node, w.file.get_ast().fullContainerDecl(&buf, init_node).?);
+                },
+                else => {},
+            }
+        }
+        try w.expr(scope, parent_decl, init_node);
+    }
 }
 
 fn container_field(
@@ -887,7 +967,7 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
         .tagged_union_two_trailing,
         => {
             var buf: [2]Ast.Node.Index = undefined;
-            return struct_decl(w, scope, parent_decl, node, ast.fullContainerDecl(&buf, node).?);
+            return struct_expr(w, scope, parent_decl, node, ast.fullContainerDecl(&buf, node).?);
         },
 
         .array_type_sentinel => {
@@ -998,7 +1078,7 @@ fn block(
             .aligned_var_decl,
             => {
                 const full = ast.fullVarDecl(node).?;
-                try global_var_decl(w, scope, parent_decl, full);
+                try global_var_decl(w, scope, parent_decl, false, full);
                 const local = try gpa.create(Scope.Local);
                 local.* = .{
                     .parent = scope,
-- 
2.54.0


From 424061381b7dc9fab5a5cd04af699bc88c5f0434 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 27 Feb 2026 20:30:31 +0100
Subject: [PATCH 354/499] ci: enable aarch64-freebsd

---
 .forgejo/workflows/ci.yaml | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 48813b9001d0463d39b7ce8e2566ae5dad555b87..fffd3c0eadf28ac0f4836dd0b1123dd97e41efc8 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -17,6 +17,27 @@ permissions:
   contents: read
 
 jobs:
+  aarch64-freebsd-debug:
+    runs-on: [self-hosted, aarch64-freebsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/aarch64-freebsd-debug.sh
+        timeout-minutes: 240
+  aarch64-freebsd-release:
+    runs-on: [self-hosted, aarch64-freebsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/aarch64-freebsd-release.sh
+        timeout-minutes: 180
+
   aarch64-linux-debug:
     runs-on: [self-hosted, aarch64-linux]
     steps:
-- 
2.54.0


From 8c70fd0a57936cca236a000a17364cbbf7a09673 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 27 Feb 2026 13:38:48 -0800
Subject: [PATCH 355/499] std.Io.Select: introduce cancelDiscard

and make the return value of `cancel` return queue items.

I don't think it's possible to make `cancel` not deadlock with an empty
queue buffer without introducing a new Group primitive.

This is the best I could come up with based on existing primitives.
Let's see if applications find these APIs palatable.
---
 lib/std/Io.zig      | 73 ++++++++++++++++++++++++++++++++++++++-------
 lib/std/Io/test.zig | 26 +++++++++++++++-
 2 files changed, 87 insertions(+), 12 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index cd846e5dae479ab6cab6c2e5ba60b89fe61444ee..a5584da61e145f053f85b86fecfe8385abb992dc 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1184,8 +1184,6 @@ pub fn Select(comptime U: type) type {
     return struct {
         io: Io,
         group: Group,
-        /// The queue is never closed because there may be live resources
-        /// inserted into it which would otherwise leak.
         queue: Queue(U),
 
         const S = @This();
@@ -1235,7 +1233,7 @@ pub fn Select(comptime U: type) type {
                     const raw_result = @call(.auto, function, context.args);
                     const elem = @unionInit(U, @tagName(field), raw_result);
                     context.select.queue.putOneUncancelable(context.select.io, elem) catch |err| switch (err) {
-                        error.Closed => unreachable,
+                        error.Closed => {},
                     };
                     if (@typeInfo(@TypeOf(raw_result)) == .error_union)
                         _ = raw_result catch |err| if (err == error.Canceled) return error.Canceled;
@@ -1274,7 +1272,7 @@ pub fn Select(comptime U: type) type {
                     const raw_result = @call(.auto, function, context.args);
                     const elem = @unionInit(U, @tagName(field), raw_result);
                     context.select.queue.putOneUncancelable(context.select.io, elem) catch |err| switch (err) {
-                        error.Closed => unreachable,
+                        error.Closed => {},
                     };
                     if (@typeInfo(@TypeOf(raw_result)) == .error_union)
                         _ = raw_result catch |err| if (err == error.Canceled) return error.Canceled;
@@ -1286,6 +1284,8 @@ pub fn Select(comptime U: type) type {
 
         /// Blocks until another task of the select finishes.
         ///
+        /// It is legal to call `async` and `concurrent` after this.
+        ///
         /// Threadsafe.
         pub fn await(s: *S) Cancelable!U {
             return s.queue.getOne(s.io) catch |err| switch (err) {
@@ -1299,6 +1299,8 @@ pub fn Select(comptime U: type) type {
         ///
         /// Asserts that `buffer.len >= min`.
         ///
+        /// It is legal to call `async` and `concurrent` after this.
+        ///
         /// Threadsafe.
         pub fn awaitMany(s: *S, buffer: []U, min: usize) Cancelable!usize {
             return s.queue.get(s.io, buffer, min) catch |err| switch (err) {
@@ -1307,16 +1309,53 @@ pub fn Select(comptime U: type) type {
             };
         }
 
-        /// Equivalent to `await` but requests cancelation on all remaining
-        /// tasks owned by the select.
+        /// Requests cancelation on all remaining tasks owned by the select,
+        /// then blocks until they all finish. If the select was initialized
+        /// with insufficient buffer space for all remaining tasks to finish, a
+        /// deadlock occurs.
         ///
-        /// For a description of cancelation and cancelation points, see `Future.cancel`.
+        /// If any of the select tasks allocate resources, those tasks may have
+        /// completed, meaning that this function must be called in a loop
+        /// until `null` is returned in order to deallocate those resources. If
+        /// there is no possibility of resource leaks, `cancelDiscard` is
+        /// preferable.
         ///
-        /// It is illegal to call `await` after this.
+        /// It is illegal to call `await` or `awaitMany` after this.
         ///
-        /// Idempotent. Threadsafe.
-        pub fn cancel(s: *S) void {
-            s.group.cancel(s.io);
+        /// It is safe to call this multiple times, even after `null` is
+        /// returned.
+        ///
+        /// Threadsafe.
+        pub fn cancel(s: *S) ?U {
+            const io = s.io;
+            if (s.group.token.load(.acquire)) |token| {
+                io.vtable.groupCancel(io.userdata, &s.group, token);
+                assert(s.group.token.raw == null);
+                s.queue.close(io);
+            }
+            return s.queue.getOneUncancelable(io) catch |err| switch (err) {
+                error.Closed => return null,
+            };
+        }
+
+        /// Requests cancelation on all remaining tasks owned by the select,
+        /// then blocks until they all finish.
+        ///
+        /// All return values from outstanding tasks are discarded. This
+        /// function is therefore inappropriate to call when a task can return
+        /// an allocated resource. For that use case, see `cancel`.
+        ///
+        /// It is illegal to call `await` or `awaitMany` after this.
+        ///
+        /// It is safe to call this multiple times.
+        ///
+        /// Threadsafe.
+        pub fn cancelDiscard(s: *S) void {
+            const io = s.io;
+            const token = s.group.token.load(.acquire) orelse return;
+            s.queue.close(io);
+            io.vtable.groupCancel(io.userdata, &s.group, token);
+            assert(s.group.token.raw == null);
         }
     };
 }
@@ -1693,6 +1732,12 @@ pub const TypeErasedQueue = struct {
         };
     }
 
+    /// After this is called, the queue enters a "closed" state. A closed
+    /// queue always returns `error.Closed` for put attempts even when
+    /// there is space in the buffer. However, existing elements of the
+    /// queue are retrieved before `error.Closed` is returned.
+    ///
+    /// Threadsafe.
     pub fn close(q: *TypeErasedQueue, io: Io) void {
         q.mutex.lockUncancelable(io);
         defer q.mutex.unlock(io);
@@ -1967,6 +2012,12 @@ pub fn Queue(Elem: type) type {
             return .{ .type_erased = .init(@ptrCast(buffer)) };
         }
 
+        /// After this is called, the queue enters a "closed" state. A closed
+        /// queue always returns `error.Closed` for put attempts even when
+        /// there is space in the buffer. However, existing elements of the
+        /// queue are retrieved before `error.Closed` is returned.
+        ///
+        /// Threadsafe.
         pub fn close(q: *@This(), io: Io) void {
             q.type_erased.close(io);
         }
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 5da87cca28de4f898c8e123c1ddb3151e46cc016..587c23eb85defb5c01dc2435ab50140dfdac43cc 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -835,7 +835,7 @@ test "Select" {
     };
     var buffer: [4]U = undefined;
     var select: Io.Select(U) = .init(io, &buffer);
-    defer select.cancel();
+    defer _ = select.cancel();
 
     select.async(.foo, S.foo, .{});
     select.concurrent(.bar, S.bar, .{io}) catch |err| switch (err) {
@@ -864,3 +864,27 @@ test "Select" {
 
     try testing.expectEqual(42, result);
 }
+
+test "Select with empty buffer, no deadlock" {
+    const S = struct {
+        fn sleeper(io: Io, duration: Io.Duration) Io.Cancelable!void {
+            try io.sleep(duration, .awake);
+        }
+    };
+
+    const io = testing.io;
+
+    const U = union(enum) {
+        sleeper: Io.Cancelable!void,
+    };
+    var select: Io.Select(U) = .init(io, &.{});
+    defer select.cancelDiscard();
+
+    select.concurrent(.sleeper, S.sleeper, .{ io, .fromNanoseconds(1) }) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => return error.SkipZigTest,
+    };
+    select.concurrent(.sleeper, S.sleeper, .{ io, .fromSeconds(600) }) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => return error.SkipZigTest,
+    };
+    assert((try select.await()) == .sleeper);
+}
-- 
2.54.0


From 99229ceb55be717aa1995f1a0105bc6b96a910f6 Mon Sep 17 00:00:00 2001
From: hemisputnik <hemisputnik@proton.me>
Date: Fri, 27 Feb 2026 01:19:20 +0200
Subject: [PATCH 356/499] std.Io.{Writer|Duration}: move duration formatting to
 a format method

Remove the `{D}` format specifier. It is moved into `std.Io.Duration` as
a format method.

Migration plan:

```diff
-writer.print("{D}", .{ns});
+writer.print("{f}", .{std.Io.Duration{ .nanoseconds = ns }});
```

All instances where `{D}` was used have been changed to use
`std.Io.Duration` and `{f}`.

Fixes #31281
---
 lib/build-web/time_report.zig |  78 +++++++-------
 lib/std/Build/Step/Run.zig    |   6 +-
 lib/std/Io.zig                | 124 +++++++++++++++++++++
 lib/std/Io/Writer.zig         | 195 ----------------------------------
 4 files changed, 166 insertions(+), 237 deletions(-)

diff --git a/lib/build-web/time_report.zig b/lib/build-web/time_report.zig
index c19a5abcc9ff7690a0bad35d19105b07f14f0db8..f6e641432c93f7c2dc60cc710903ee907f25c626 100644
--- a/lib/build-web/time_report.zig
+++ b/lib/build-web/time_report.zig
@@ -42,10 +42,10 @@ pub fn genericResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
     if (msg.step_idx >= step_list.*.len) @panic("malformed GenericResult message");
     const inner_html = try std.fmt.allocPrint(gpa,
         \\<code slot="step-name">{[step_name]f}</code>
-        \\<span slot="stat-total-time">{[stat_total_time]D}</span>
+        \\<span slot="stat-total-time">{[stat_total_time]f}</span>
     , .{
         .step_name = fmtEscapeHtml(step_list.*[msg.step_idx].name),
-        .stat_total_time = msg.ns_total,
+        .stat_total_time = std.Io.Duration{ .nanoseconds = msg.ns_total },
     });
     defer gpa.free(inner_html);
     js.updateGeneric(msg.step_idx, inner_html.ptr, inner_html.len);
@@ -139,16 +139,16 @@ pub fn compileResultMessage(msg_bytes: []u8) error{ OutOfMemory, WriteFailed }!v
         \\<span slot="stat-imported-files">{[stat_imported_files]d}</span>
         \\<span slot="stat-generic-instances">{[stat_generic_instances]d}</span>
         \\<span slot="stat-inline-calls">{[stat_inline_calls]d}</span>
-        \\<span slot="stat-compilation-time">{[stat_compilation_time]D}</span>
-        \\<span slot="cpu-time-parse">{[cpu_time_parse]D}</span>
-        \\<span slot="cpu-time-astgen">{[cpu_time_astgen]D}</span>
-        \\<span slot="cpu-time-sema">{[cpu_time_sema]D}</span>
-        \\<span slot="cpu-time-codegen">{[cpu_time_codegen]D}</span>
-        \\<span slot="cpu-time-link">{[cpu_time_link]D}</span>
-        \\<span slot="real-time-files">{[real_time_files]D}</span>
-        \\<span slot="real-time-decls">{[real_time_decls]D}</span>
-        \\<span slot="real-time-llvm-emit">{[real_time_llvm_emit]D}</span>
-        \\<span slot="real-time-link-flush">{[real_time_link_flush]D}</span>
+        \\<span slot="stat-compilation-time">{[stat_compilation_time]f}</span>
+        \\<span slot="cpu-time-parse">{[cpu_time_parse]f}</span>
+        \\<span slot="cpu-time-astgen">{[cpu_time_astgen]f}</span>
+        \\<span slot="cpu-time-sema">{[cpu_time_sema]f}</span>
+        \\<span slot="cpu-time-codegen">{[cpu_time_codegen]f}</span>
+        \\<span slot="cpu-time-link">{[cpu_time_link]f}</span>
+        \\<span slot="real-time-files">{[real_time_files]f}</span>
+        \\<span slot="real-time-decls">{[real_time_decls]f}</span>
+        \\<span slot="real-time-llvm-emit">{[real_time_llvm_emit]f}</span>
+        \\<span slot="real-time-link-flush">{[real_time_link_flush]f}</span>
         \\<pre slot="llvm-pass-timings"><code>{[llvm_pass_timings]f}</code></pre>
         \\
     , .{
@@ -157,17 +157,17 @@ pub fn compileResultMessage(msg_bytes: []u8) error{ OutOfMemory, WriteFailed }!v
         .stat_imported_files = stats.n_imported_files,
         .stat_generic_instances = stats.n_generic_instances,
         .stat_inline_calls = stats.n_inline_calls,
-        .stat_compilation_time = hdr.ns_total,
+        .stat_compilation_time = std.Io.Duration{ .nanoseconds = hdr.ns_total },
 
-        .cpu_time_parse = stats.cpu_ns_parse,
-        .cpu_time_astgen = stats.cpu_ns_astgen,
-        .cpu_time_sema = stats.cpu_ns_sema,
-        .cpu_time_codegen = stats.cpu_ns_codegen,
-        .cpu_time_link = stats.cpu_ns_link,
-        .real_time_files = stats.real_ns_files,
-        .real_time_decls = stats.real_ns_decls,
-        .real_time_llvm_emit = stats.real_ns_llvm_emit,
-        .real_time_link_flush = stats.real_ns_link_flush,
+        .cpu_time_parse = std.Io.Duration{ .nanoseconds = stats.cpu_ns_parse },
+        .cpu_time_astgen = std.Io.Duration{ .nanoseconds = stats.cpu_ns_astgen },
+        .cpu_time_sema = std.Io.Duration{ .nanoseconds = stats.cpu_ns_sema },
+        .cpu_time_codegen = std.Io.Duration{ .nanoseconds = stats.cpu_ns_codegen },
+        .cpu_time_link = std.Io.Duration{ .nanoseconds = stats.cpu_ns_link },
+        .real_time_files = std.Io.Duration{ .nanoseconds = stats.real_ns_files },
+        .real_time_decls = std.Io.Duration{ .nanoseconds = stats.real_ns_decls },
+        .real_time_llvm_emit = std.Io.Duration{ .nanoseconds = stats.real_ns_llvm_emit },
+        .real_time_link_flush = std.Io.Duration{ .nanoseconds = stats.real_ns_link_flush },
 
         .llvm_pass_timings = fmtEscapeHtml(llvm_pass_timings),
     });
@@ -180,18 +180,18 @@ pub fn compileResultMessage(msg_bytes: []u8) error{ OutOfMemory, WriteFailed }!v
         try file_table_html.writer.print(
             \\<tr>
             \\  <th scope="row"><code>{f}</code></th>
-            \\  <td>{D}</td>
-            \\  <td>{D}</td>
-            \\  <td>{D}</td>
-            \\  <td>{D}</td>
+            \\  <td>{f}</td>
+            \\  <td>{f}</td>
+            \\  <td>{f}</td>
+            \\  <td>{f}</td>
             \\</tr>
             \\
         , .{
             fmtEscapeHtml(file.name),
-            file.ns_sema,
-            file.ns_codegen,
-            file.ns_link,
-            file.ns_sema + file.ns_codegen + file.ns_link,
+            std.Io.Duration{ .nanoseconds = file.ns_sema },
+            std.Io.Duration{ .nanoseconds = file.ns_codegen },
+            std.Io.Duration{ .nanoseconds = file.ns_link },
+            std.Io.Duration{ .nanoseconds = file.ns_sema + file.ns_codegen + file.ns_link },
         });
     }
     if (slowest_files.len > max_table_rows) {
@@ -210,20 +210,20 @@ pub fn compileResultMessage(msg_bytes: []u8) error{ OutOfMemory, WriteFailed }!v
             \\  <th scope="row"><code>{f}</code></th>
             \\  <th scope="row"><code>{f}</code></th>
             \\  <td>{d}</td>
-            \\  <td>{D}</td>
-            \\  <td>{D}</td>
-            \\  <td>{D}</td>
-            \\  <td>{D}</td>
+            \\  <td>{f}</td>
+            \\  <td>{f}</td>
+            \\  <td>{f}</td>
+            \\  <td>{f}</td>
             \\</tr>
             \\
         , .{
             fmtEscapeHtml(decl.file_name),
             fmtEscapeHtml(decl.name),
             decl.sema_count,
-            decl.ns_sema,
-            decl.ns_codegen,
-            decl.ns_link,
-            decl.ns_sema + decl.ns_codegen + decl.ns_link,
+            std.Io.Duration{ .nanoseconds = decl.ns_sema },
+            std.Io.Duration{ .nanoseconds = decl.ns_codegen },
+            std.Io.Duration{ .nanoseconds = decl.ns_link },
+            std.Io.Duration{ .nanoseconds = decl.ns_sema + decl.ns_codegen + decl.ns_link },
         });
     }
     if (slowest_decls.len > max_table_rows) {
@@ -265,7 +265,7 @@ pub fn runTestResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
         if (test_ns == std.math.maxInt(u64)) {
             try table_html.appendSlice(gpa, "<td class=\"empty-cell\"></td>"); // didn't run
         } else {
-            try table_html.print(gpa, "<td>{D}</td>", .{test_ns});
+            try table_html.print(gpa, "<td>{f}</td>", .{std.Io.Duration{ .nanoseconds = test_ns }});
         }
         try table_html.appendSlice(gpa, "</tr>\n");
     }
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index e80f57f0bc33db759b32ef03b37c5a355e680f84..8a21e6fef9b3da523b2ad087008b805c7da0e676 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1787,9 +1787,9 @@ fn evalZigTest(
                     // the next test.
                     test_metadata.?.ns_per_test[test_index] = timeout.ns_elapsed;
                     test_results.timeout_count += 1;
-                    try run.step.addError("'{s}' timed out after {D}{s}{s}", .{
+                    try run.step.addError("'{s}' timed out after {f}{s}{s}", .{
                         test_metadata.?.testName(test_index),
-                        timeout.ns_elapsed,
+                        Io.Duration{ .nanoseconds = timeout.ns_elapsed },
                         if (stderr.len != 0) " with stderr:\n" else "",
                         std.mem.trim(u8, stderr, "\n"),
                     });
@@ -1799,7 +1799,7 @@ fn evalZigTest(
                 run.step.result_stderr = try arena.dupe(u8, stderr);
                 // The individual unit test results in `results` are irrelevant: the test runner
                 // is broken! Fail immediately without populating `s.test_results`.
-                return run.step.fail("test runner failed to respond for {D}", .{timeout.ns_elapsed});
+                return run.step.fail("test runner failed to respond for {f}", .{Io.Duration{ .nanoseconds = timeout.ns_elapsed }});
             },
         }
         comptime unreachable;
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index a5584da61e145f053f85b86fecfe8385abb992dc..88813e8ae85eb8aca53a01d4f0a6b3302e8fa43d 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -940,6 +940,130 @@ pub const Duration = struct {
     pub fn toNanoseconds(d: Duration) i96 {
         return d.nanoseconds;
     }
+
+    /// Write number of nanoseconds according to its signed magnitude:
+    /// `[#y][#w][#d][#h][#m]#[.###][n|u|m]s`
+    pub fn format(duration: Duration, w: *Writer) Writer.Error!void {
+        if (duration.nanoseconds < 0) try w.writeByte('-');
+        return formatUnsigned(w, @abs(duration.nanoseconds));
+    }
+
+    fn formatUnsigned(w: *Writer, ns: u96) Writer.Error!void {
+        var ns_remaining = ns;
+        inline for (.{
+            .{ .ns = 365 * std.time.ns_per_day, .sep = 'y' },
+            .{ .ns = std.time.ns_per_week, .sep = 'w' },
+            .{ .ns = std.time.ns_per_day, .sep = 'd' },
+            .{ .ns = std.time.ns_per_hour, .sep = 'h' },
+            .{ .ns = std.time.ns_per_min, .sep = 'm' },
+        }) |unit| {
+            if (ns_remaining >= unit.ns) {
+                const units = ns_remaining / unit.ns;
+                try w.printInt(units, 10, .lower, .{});
+                try w.writeByte(unit.sep);
+                ns_remaining -= units * unit.ns;
+                if (ns_remaining == 0) return;
+            }
+        }
+
+        inline for (.{
+            .{ .ns = std.time.ns_per_s, .sep = "s" },
+            .{ .ns = std.time.ns_per_ms, .sep = "ms" },
+            .{ .ns = std.time.ns_per_us, .sep = "us" },
+        }) |unit| {
+            const kunits = ns_remaining * 1000 / unit.ns;
+            if (kunits >= 1000) {
+                try w.printInt(kunits / 1000, 10, .lower, .{});
+                const frac = kunits % 1000;
+                if (frac > 0) {
+                    // Write up to 3 decimal places
+                    var decimal_buf = [_]u8{ '.', 0, 0, 0 };
+                    var inner: Writer = .fixed(decimal_buf[1..]);
+                    inner.printInt(frac, 10, .lower, .{ .fill = '0', .width = 3 }) catch unreachable;
+                    var end: usize = 4;
+                    while (end > 1) : (end -= 1) {
+                        if (decimal_buf[end - 1] != '0') break;
+                    }
+                    try w.writeAll(decimal_buf[0..end]);
+                }
+                return w.writeAll(unit.sep);
+            }
+        }
+
+        try w.printInt(ns_remaining, 10, .lower, .{});
+        try w.writeAll("ns");
+    }
+
+    test format {
+        try testFormat("0ns", 0);
+        try testFormat("1ns", 1);
+        try testFormat("-1ns", -(1));
+        try testFormat("999ns", std.time.ns_per_us - 1);
+        try testFormat("-999ns", -(std.time.ns_per_us - 1));
+        try testFormat("1us", std.time.ns_per_us);
+        try testFormat("-1us", -(std.time.ns_per_us));
+        try testFormat("1.45us", 1450);
+        try testFormat("-1.45us", -(1450));
+        try testFormat("1.5us", 3 * std.time.ns_per_us / 2);
+        try testFormat("-1.5us", -(3 * std.time.ns_per_us / 2));
+        try testFormat("14.5us", 14500);
+        try testFormat("-14.5us", -(14500));
+        try testFormat("145us", 145000);
+        try testFormat("-145us", -(145000));
+        try testFormat("999.999us", std.time.ns_per_ms - 1);
+        try testFormat("-999.999us", -(std.time.ns_per_ms - 1));
+        try testFormat("1ms", std.time.ns_per_ms + 1);
+        try testFormat("-1ms", -(std.time.ns_per_ms + 1));
+        try testFormat("1.5ms", 3 * std.time.ns_per_ms / 2);
+        try testFormat("-1.5ms", -(3 * std.time.ns_per_ms / 2));
+        try testFormat("1.11ms", 1110000);
+        try testFormat("-1.11ms", -(1110000));
+        try testFormat("1.111ms", 1111000);
+        try testFormat("-1.111ms", -(1111000));
+        try testFormat("1.111ms", 1111100);
+        try testFormat("-1.111ms", -(1111100));
+        try testFormat("999.999ms", std.time.ns_per_s - 1);
+        try testFormat("-999.999ms", -(std.time.ns_per_s - 1));
+        try testFormat("1s", std.time.ns_per_s);
+        try testFormat("-1s", -(std.time.ns_per_s));
+        try testFormat("59.999s", std.time.ns_per_min - 1);
+        try testFormat("-59.999s", -(std.time.ns_per_min - 1));
+        try testFormat("1m", std.time.ns_per_min);
+        try testFormat("-1m", -(std.time.ns_per_min));
+        try testFormat("1h", std.time.ns_per_hour);
+        try testFormat("-1h", -(std.time.ns_per_hour));
+        try testFormat("1d", std.time.ns_per_day);
+        try testFormat("-1d", -(std.time.ns_per_day));
+        try testFormat("1w", std.time.ns_per_week);
+        try testFormat("-1w", -(std.time.ns_per_week));
+        try testFormat("1y", 365 * std.time.ns_per_day);
+        try testFormat("-1y", -(365 * std.time.ns_per_day));
+        try testFormat("1y52w23h59m59.999s", 730 * std.time.ns_per_day - 1); // 365d = 52w1d
+        try testFormat("-1y52w23h59m59.999s", -(730 * std.time.ns_per_day - 1)); // 365d = 52w1d
+        try testFormat("1y1h1.001s", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + std.time.ns_per_ms);
+        try testFormat("-1y1h1.001s", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + std.time.ns_per_ms));
+        try testFormat("1y1h1s", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + 999 * std.time.ns_per_us);
+        try testFormat("-1y1h1s", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + 999 * std.time.ns_per_us));
+        try testFormat("1y1h999.999us", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms - 1);
+        try testFormat("-1y1h999.999us", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms - 1));
+        try testFormat("1y1h1ms", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms);
+        try testFormat("-1y1h1ms", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms));
+        try testFormat("1y1h1ms", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms + 1);
+        try testFormat("-1y1h1ms", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms + 1));
+        try testFormat("1y1m999ns", 365 * std.time.ns_per_day + std.time.ns_per_min + 999);
+        try testFormat("-1y1m999ns", -(365 * std.time.ns_per_day + std.time.ns_per_min + 999));
+        try testFormat("292y24w3d23h47m16.854s", std.math.maxInt(i64));
+        try testFormat("-292y24w3d23h47m16.854s", std.math.minInt(i64) + 1);
+        try testFormat("-292y24w3d23h47m16.854s", std.math.minInt(i64));
+    }
+
+    fn testFormat(expected: []const u8, input: i96) !void {
+        // worst case: "-XXXXXXXXXXXXXyXXwXXdXXhXXmXX.XXXs".len = 34
+        var buf: [34]u8 = undefined;
+        var w: Writer = .fixed(&buf);
+        try w.print("{f}", .{Duration{ .nanoseconds = input }});
+        try std.testing.expectEqualStrings(expected, w.buffered());
+    }
 };
 
 /// Declares under what conditions an operation should return `error.Timeout`.
diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig
index b7da83f3a0f1ea911d2de792a468353afd34c97e..d1cea560c3611fc760f524041daac22fdf586147 100644
--- a/lib/std/Io/Writer.zig
+++ b/lib/std/Io/Writer.zig
@@ -1155,11 +1155,6 @@ pub fn printValue(
                 .@"struct" => return value.formatByteSize(w, .decimal),
                 else => invalidFmtError(fmt, value),
             },
-            'D' => switch (@typeInfo(T)) {
-                .int, .comptime_int => return w.printDuration(value, options),
-                .@"struct" => return value.formatDuration(w),
-                else => invalidFmtError(fmt, value),
-            },
             'e' => switch (@typeInfo(T)) {
                 .float, .comptime_float => return printFloat(w, value, options.toNumber(.scientific, .lower)),
                 .@"struct" => return value.formatNumber(w, options.toNumber(.scientific, .lower)),
@@ -1792,77 +1787,6 @@ pub fn invalidFmtError(comptime fmt: []const u8, value: anytype) noreturn {
     @compileError("invalid format string '" ++ fmt ++ "' for type '" ++ @typeName(@TypeOf(value)) ++ "'");
 }
 
-pub fn printDurationSigned(w: *Writer, ns: i64) Error!void {
-    if (ns < 0) try w.writeByte('-');
-    return w.printDurationUnsigned(@abs(ns));
-}
-
-pub fn printDurationUnsigned(w: *Writer, ns: u64) Error!void {
-    var ns_remaining = ns;
-    inline for (.{
-        .{ .ns = 365 * std.time.ns_per_day, .sep = 'y' },
-        .{ .ns = std.time.ns_per_week, .sep = 'w' },
-        .{ .ns = std.time.ns_per_day, .sep = 'd' },
-        .{ .ns = std.time.ns_per_hour, .sep = 'h' },
-        .{ .ns = std.time.ns_per_min, .sep = 'm' },
-    }) |unit| {
-        if (ns_remaining >= unit.ns) {
-            const units = ns_remaining / unit.ns;
-            try w.printInt(units, 10, .lower, .{});
-            try w.writeByte(unit.sep);
-            ns_remaining -= units * unit.ns;
-            if (ns_remaining == 0) return;
-        }
-    }
-
-    inline for (.{
-        .{ .ns = std.time.ns_per_s, .sep = "s" },
-        .{ .ns = std.time.ns_per_ms, .sep = "ms" },
-        .{ .ns = std.time.ns_per_us, .sep = "us" },
-    }) |unit| {
-        const kunits = ns_remaining * 1000 / unit.ns;
-        if (kunits >= 1000) {
-            try w.printInt(kunits / 1000, 10, .lower, .{});
-            const frac = kunits % 1000;
-            if (frac > 0) {
-                // Write up to 3 decimal places
-                var decimal_buf = [_]u8{ '.', 0, 0, 0 };
-                var inner: Writer = .fixed(decimal_buf[1..]);
-                inner.printInt(frac, 10, .lower, .{ .fill = '0', .width = 3 }) catch unreachable;
-                var end: usize = 4;
-                while (end > 1) : (end -= 1) {
-                    if (decimal_buf[end - 1] != '0') break;
-                }
-                try w.writeAll(decimal_buf[0..end]);
-            }
-            return w.writeAll(unit.sep);
-        }
-    }
-
-    try w.printInt(ns_remaining, 10, .lower, .{});
-    try w.writeAll("ns");
-}
-
-/// Writes number of nanoseconds according to its signed magnitude:
-/// `[#y][#w][#d][#h][#m]#[.###][n|u|m]s`
-/// `nanoseconds` must be an integer that coerces into `u64` or `i64`.
-pub fn printDuration(w: *Writer, nanoseconds: anytype, options: std.fmt.Options) Error!void {
-    // worst case: "-XXXyXXwXXdXXhXXmXX.XXXs".len = 24
-    var buf: [24]u8 = undefined;
-    var sub_writer: Writer = .fixed(&buf);
-    if (@TypeOf(nanoseconds) == comptime_int) {
-        if (nanoseconds >= 0) {
-            sub_writer.printDurationUnsigned(nanoseconds) catch unreachable;
-        } else {
-            sub_writer.printDurationSigned(nanoseconds) catch unreachable;
-        }
-    } else switch (@typeInfo(@TypeOf(nanoseconds)).int.signedness) {
-        .signed => sub_writer.printDurationSigned(nanoseconds) catch unreachable,
-        .unsigned => sub_writer.printDurationUnsigned(nanoseconds) catch unreachable,
-    }
-    return w.alignBufferOptions(sub_writer.buffered(), options);
-}
-
 pub fn printHex(w: *Writer, bytes: []const u8, case: std.fmt.Case) Error!void {
     const charset = switch (case) {
         .upper => "0123456789ABCDEF",
@@ -2129,125 +2053,6 @@ test "printValue max_depth" {
     try testing.expectEqualStrings("{ 1, 2, 3, 4 }", w.buffered());
 }
 
-test printDuration {
-    try testDurationCase("0ns", 0);
-    try testDurationCase("1ns", 1);
-    try testDurationCase("999ns", std.time.ns_per_us - 1);
-    try testDurationCase("1us", std.time.ns_per_us);
-    try testDurationCase("1.45us", 1450);
-    try testDurationCase("1.5us", 3 * std.time.ns_per_us / 2);
-    try testDurationCase("14.5us", 14500);
-    try testDurationCase("145us", 145000);
-    try testDurationCase("999.999us", std.time.ns_per_ms - 1);
-    try testDurationCase("1ms", std.time.ns_per_ms + 1);
-    try testDurationCase("1.5ms", 3 * std.time.ns_per_ms / 2);
-    try testDurationCase("1.11ms", 1110000);
-    try testDurationCase("1.111ms", 1111000);
-    try testDurationCase("1.111ms", 1111100);
-    try testDurationCase("999.999ms", std.time.ns_per_s - 1);
-    try testDurationCase("1s", std.time.ns_per_s);
-    try testDurationCase("59.999s", std.time.ns_per_min - 1);
-    try testDurationCase("1m", std.time.ns_per_min);
-    try testDurationCase("1h", std.time.ns_per_hour);
-    try testDurationCase("1d", std.time.ns_per_day);
-    try testDurationCase("1w", std.time.ns_per_week);
-    try testDurationCase("1y", 365 * std.time.ns_per_day);
-    try testDurationCase("1y52w23h59m59.999s", 730 * std.time.ns_per_day - 1); // 365d = 52w1
-    try testDurationCase("1y1h1.001s", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + std.time.ns_per_ms);
-    try testDurationCase("1y1h1s", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + 999 * std.time.ns_per_us);
-    try testDurationCase("1y1h999.999us", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms - 1);
-    try testDurationCase("1y1h1ms", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms);
-    try testDurationCase("1y1h1ms", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms + 1);
-    try testDurationCase("1y1m999ns", 365 * std.time.ns_per_day + std.time.ns_per_min + 999);
-    try testDurationCase("584y49w23h34m33.709s", std.math.maxInt(u64));
-
-    try testing.expectFmt("=======0ns", "{D:=>10}", .{0});
-    try testing.expectFmt("1ns=======", "{D:=<10}", .{1});
-    try testing.expectFmt("  999ns   ", "{D:^10}", .{std.time.ns_per_us - 1});
-}
-
-test printDurationSigned {
-    try testDurationCaseSigned("0ns", 0);
-    try testDurationCaseSigned("1ns", 1);
-    try testDurationCaseSigned("-1ns", -(1));
-    try testDurationCaseSigned("999ns", std.time.ns_per_us - 1);
-    try testDurationCaseSigned("-999ns", -(std.time.ns_per_us - 1));
-    try testDurationCaseSigned("1us", std.time.ns_per_us);
-    try testDurationCaseSigned("-1us", -(std.time.ns_per_us));
-    try testDurationCaseSigned("1.45us", 1450);
-    try testDurationCaseSigned("-1.45us", -(1450));
-    try testDurationCaseSigned("1.5us", 3 * std.time.ns_per_us / 2);
-    try testDurationCaseSigned("-1.5us", -(3 * std.time.ns_per_us / 2));
-    try testDurationCaseSigned("14.5us", 14500);
-    try testDurationCaseSigned("-14.5us", -(14500));
-    try testDurationCaseSigned("145us", 145000);
-    try testDurationCaseSigned("-145us", -(145000));
-    try testDurationCaseSigned("999.999us", std.time.ns_per_ms - 1);
-    try testDurationCaseSigned("-999.999us", -(std.time.ns_per_ms - 1));
-    try testDurationCaseSigned("1ms", std.time.ns_per_ms + 1);
-    try testDurationCaseSigned("-1ms", -(std.time.ns_per_ms + 1));
-    try testDurationCaseSigned("1.5ms", 3 * std.time.ns_per_ms / 2);
-    try testDurationCaseSigned("-1.5ms", -(3 * std.time.ns_per_ms / 2));
-    try testDurationCaseSigned("1.11ms", 1110000);
-    try testDurationCaseSigned("-1.11ms", -(1110000));
-    try testDurationCaseSigned("1.111ms", 1111000);
-    try testDurationCaseSigned("-1.111ms", -(1111000));
-    try testDurationCaseSigned("1.111ms", 1111100);
-    try testDurationCaseSigned("-1.111ms", -(1111100));
-    try testDurationCaseSigned("999.999ms", std.time.ns_per_s - 1);
-    try testDurationCaseSigned("-999.999ms", -(std.time.ns_per_s - 1));
-    try testDurationCaseSigned("1s", std.time.ns_per_s);
-    try testDurationCaseSigned("-1s", -(std.time.ns_per_s));
-    try testDurationCaseSigned("59.999s", std.time.ns_per_min - 1);
-    try testDurationCaseSigned("-59.999s", -(std.time.ns_per_min - 1));
-    try testDurationCaseSigned("1m", std.time.ns_per_min);
-    try testDurationCaseSigned("-1m", -(std.time.ns_per_min));
-    try testDurationCaseSigned("1h", std.time.ns_per_hour);
-    try testDurationCaseSigned("-1h", -(std.time.ns_per_hour));
-    try testDurationCaseSigned("1d", std.time.ns_per_day);
-    try testDurationCaseSigned("-1d", -(std.time.ns_per_day));
-    try testDurationCaseSigned("1w", std.time.ns_per_week);
-    try testDurationCaseSigned("-1w", -(std.time.ns_per_week));
-    try testDurationCaseSigned("1y", 365 * std.time.ns_per_day);
-    try testDurationCaseSigned("-1y", -(365 * std.time.ns_per_day));
-    try testDurationCaseSigned("1y52w23h59m59.999s", 730 * std.time.ns_per_day - 1); // 365d = 52w1d
-    try testDurationCaseSigned("-1y52w23h59m59.999s", -(730 * std.time.ns_per_day - 1)); // 365d = 52w1d
-    try testDurationCaseSigned("1y1h1.001s", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + std.time.ns_per_ms);
-    try testDurationCaseSigned("-1y1h1.001s", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + std.time.ns_per_ms));
-    try testDurationCaseSigned("1y1h1s", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + 999 * std.time.ns_per_us);
-    try testDurationCaseSigned("-1y1h1s", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_s + 999 * std.time.ns_per_us));
-    try testDurationCaseSigned("1y1h999.999us", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms - 1);
-    try testDurationCaseSigned("-1y1h999.999us", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms - 1));
-    try testDurationCaseSigned("1y1h1ms", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms);
-    try testDurationCaseSigned("-1y1h1ms", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms));
-    try testDurationCaseSigned("1y1h1ms", 365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms + 1);
-    try testDurationCaseSigned("-1y1h1ms", -(365 * std.time.ns_per_day + std.time.ns_per_hour + std.time.ns_per_ms + 1));
-    try testDurationCaseSigned("1y1m999ns", 365 * std.time.ns_per_day + std.time.ns_per_min + 999);
-    try testDurationCaseSigned("-1y1m999ns", -(365 * std.time.ns_per_day + std.time.ns_per_min + 999));
-    try testDurationCaseSigned("292y24w3d23h47m16.854s", std.math.maxInt(i64));
-    try testDurationCaseSigned("-292y24w3d23h47m16.854s", std.math.minInt(i64) + 1);
-    try testDurationCaseSigned("-292y24w3d23h47m16.854s", std.math.minInt(i64));
-
-    try testing.expectFmt("=======0ns", "{D:=>10}", .{0});
-    try testing.expectFmt("1ns=======", "{D:=<10}", .{1});
-    try testing.expectFmt("-1ns======", "{D:=<10}", .{-(1)});
-    try testing.expectFmt("  -999ns  ", "{D:^10}", .{-(std.time.ns_per_us - 1)});
-}
-
-fn testDurationCase(expected: []const u8, input: u64) !void {
-    var buf: [24]u8 = undefined;
-    var w: Writer = .fixed(&buf);
-    try w.printDurationUnsigned(input);
-    try testing.expectEqualStrings(expected, w.buffered());
-}
-
-fn testDurationCaseSigned(expected: []const u8, input: i64) !void {
-    var buf: [24]u8 = undefined;
-    var w: Writer = .fixed(&buf);
-    try w.printDurationSigned(input);
-    try testing.expectEqualStrings(expected, w.buffered());
-}
-
 test printInt {
     try testPrintIntCase("-1", @as(i1, -1), 10, .lower, .{});
 
-- 
2.54.0


From 925f82da098300ac7015d7897fc5202a7ea275a0 Mon Sep 17 00:00:00 2001
From: hemisputnik <hemisputnik@proton.me>
Date: Sat, 28 Feb 2026 00:46:05 +0200
Subject: [PATCH 357/499] std.math.big.int: add log2

---
 lib/std/math/big/int.zig      |  5 +++++
 lib/std/math/big/int_test.zig | 17 +++++++++++++++++
 2 files changed, 22 insertions(+)

diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index e3dcb8d71dbb664df58284ab2e28b887110f0dd7..29c1423a1446184dd4c8ba99a623b56afd03fac8 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -2670,6 +2670,11 @@ pub const Const = struct {
         }
         return @min(result, bits);
     }
+
+    /// Calculate the base 2 logarithm, rounded down.
+    pub fn log2(a: Const) Limb {
+        return a.limbs.len * @bitSizeOf(Limb) - 1 - @clz(a.limbs[a.limbs.len - 1]);
+    }
 };
 
 /// An arbitrary-precision big integer along with an allocator which manages the memory.
diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig
index 34dec3fdde9d106d90b8ffb3dbfec469eb2701af..2c2aeb9df71f86e0f52f39557204a67a6354c315 100644
--- a/lib/std/math/big/int_test.zig
+++ b/lib/std/math/big/int_test.zig
@@ -4072,3 +4072,20 @@ test "ctz" {
     try testing.expectEqual(0, limb_max_squared.ctz(@bitSizeOf(Limb) * 2));
     try testing.expectEqual(0, limb_max_squared.ctz(@bitSizeOf(Limb) * 2 + 1));
 }
+
+test "log2" {
+    var a = try Managed.init(testing.allocator);
+    defer a.deinit();
+
+    try a.setString(2, "1");
+    try testing.expectEqual(0, a.toConst().log2());
+
+    try a.setString(2, "1111011");
+    try testing.expectEqual(6, a.toConst().log2());
+
+    try a.setString(2, "10100111011101010");
+    try testing.expectEqual(16, a.toConst().log2());
+
+    try a.setString(16, "a22d71c87a9ce406da4f5895f9f3cc3d603192baf6c8a2b5c32649d0465bf188fe799b3618085e49d71bdaec01");
+    try testing.expectEqual(359, a.toConst().log2());
+}
-- 
2.54.0


From 02142a54d22c20b07009780d7c79d90950d3b2c8 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 27 Feb 2026 17:26:34 -0800
Subject: [PATCH 358/499] std.Io: remove cancelation propagation assertions

While the general guidance remains useful, it is not the case that
error.Canceled will always pass across the Group task function boundary.

Remove the too-aggressive assertions and add unit test coverage.

Closes #30096
Closes #31340
Closes #31358
---
 lib/std/Io.zig          | 38 ++++++++++--------------
 lib/std/Io/Dispatch.zig | 31 ++++----------------
 lib/std/Io/Kqueue.zig   |  4 +--
 lib/std/Io/Threaded.zig | 65 +++++------------------------------------
 lib/std/Io/Uring.zig    | 31 ++++----------------
 lib/std/Io/test.zig     | 59 +++++++++++++++++++++++++++++++++----
 6 files changed, 89 insertions(+), 139 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 88813e8ae85eb8aca53a01d4f0a6b3302e8fa43d..d9bf914aa4018da8dd5670eef03bc48a8a1a0117 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -124,7 +124,7 @@ pub const VTable = struct {
         /// Copied and then passed to `start`.
         context: []const u8,
         context_alignment: std.mem.Alignment,
-        start: *const fn (context: *const anyopaque) Cancelable!void,
+        start: *const fn (context: *const anyopaque) void,
     ) void,
     /// Thread-safe.
     groupConcurrent: *const fn (
@@ -135,7 +135,7 @@ pub const VTable = struct {
         /// Copied and then passed to `start`.
         context: []const u8,
         context_alignment: std.mem.Alignment,
-        start: *const fn (context: *const anyopaque) Cancelable!void,
+        start: *const fn (context: *const anyopaque) void,
     ) ConcurrentError!void,
     groupAwait: *const fn (?*anyopaque, *Group, token: *anyopaque) Cancelable!void,
     groupCancel: *const fn (?*anyopaque, *Group, token: *anyopaque) void,
@@ -1169,19 +1169,18 @@ pub const Group = struct {
     /// instead of becoming associated with a `Future`.
     ///
     /// The return type of `function` must be coercible to `Cancelable!void`.
+    /// `function` returning `error.Canceled` does nothing because it is an
+    /// cancelation propagation boundary.
     ///
     /// Once this function is called, there are resources associated with the
     /// group. To release those resources, `Group.await` or `Group.cancel` must
     /// eventually be called.
-    ///
-    /// If `error.Canceled` is returned from any operation this task performs,
-    /// it is asserted that `function` returns `error.Canceled`.
     pub fn async(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
-            fn start(context: *const anyopaque) Cancelable!void {
+            fn start(context: *const anyopaque) void {
                 const args_casted: *const Args = @ptrCast(@alignCast(context));
-                return @call(.auto, function, args_casted.*);
+                _ = @as(Cancelable!void, @call(.auto, function, args_casted.*)) catch {};
             }
         };
         io.vtable.groupAsync(io.userdata, g, @ptrCast(&args), .of(Args), TypeErased.start);
@@ -1191,19 +1190,18 @@ pub const Group = struct {
     /// `Group` instead of becoming associated with a `Future`.
     ///
     /// The return type of `function` must be coercible to `Cancelable!void`.
+    /// `function` returning `error.Canceled` does nothing because it is an
+    /// cancelation propagation boundary.
     ///
     /// Once this function is called, there are resources associated with the
     /// group. To release those resources, `Group.await` or `Group.cancel` must
     /// eventually be called.
-    ///
-    /// If `error.Canceled` is returned from any operation this task performs,
-    /// it is asserted that `function` returns `error.Canceled`.
     pub fn concurrent(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) ConcurrentError!void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
-            fn start(context: *const anyopaque) Cancelable!void {
+            fn start(context: *const anyopaque) void {
                 const args_casted: *const Args = @ptrCast(@alignCast(context));
-                return @call(.auto, function, args_casted.*);
+                _ = @as(Cancelable!void, @call(.auto, function, args_casted.*)) catch {};
             }
         };
         return io.vtable.groupConcurrent(io.userdata, g, @ptrCast(&args), .of(Args), TypeErased.start);
@@ -1352,15 +1350,13 @@ pub fn Select(comptime U: type) type {
             const Context = struct {
                 select: *S,
                 args: @TypeOf(args),
-                fn start(type_erased_context: *const anyopaque) Cancelable!void {
+                fn start(type_erased_context: *const anyopaque) void {
                     const context: *const @This() = @ptrCast(@alignCast(type_erased_context));
-                    const raw_result = @call(.auto, function, context.args);
-                    const elem = @unionInit(U, @tagName(field), raw_result);
+                    const result = @call(.auto, function, context.args);
+                    const elem = @unionInit(U, @tagName(field), result);
                     context.select.queue.putOneUncancelable(context.select.io, elem) catch |err| switch (err) {
                         error.Closed => {},
                     };
-                    if (@typeInfo(@TypeOf(raw_result)) == .error_union)
-                        _ = raw_result catch |err| if (err == error.Canceled) return error.Canceled;
                 }
             };
             const context: Context = .{ .select = s, .args = args };
@@ -1391,15 +1387,13 @@ pub fn Select(comptime U: type) type {
             const Context = struct {
                 select: *S,
                 args: @TypeOf(args),
-                fn start(type_erased_context: *const anyopaque) Cancelable!void {
+                fn start(type_erased_context: *const anyopaque) void {
                     const context: *const @This() = @ptrCast(@alignCast(type_erased_context));
-                    const raw_result = @call(.auto, function, context.args);
-                    const elem = @unionInit(U, @tagName(field), raw_result);
+                    const result = @call(.auto, function, context.args);
+                    const elem = @unionInit(U, @tagName(field), result);
                     context.select.queue.putOneUncancelable(context.select.io, elem) catch |err| switch (err) {
                         error.Closed => {},
                     };
-                    if (@typeInfo(@TypeOf(raw_result)) == .error_union)
-                        _ = raw_result catch |err| if (err == error.Canceled) return error.Canceled;
                 }
             };
             const context: Context = .{ .select = s, .args = args };
diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 328fb59162fd8bbdaa28401a3513e1a1c3172cdc..1a1d644276565f00ad65ca4e7183124351159a59 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -1331,7 +1331,7 @@ const Group = struct {
         evented: *Evented,
         group: Group,
         fiber: *Fiber,
-        start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+        start: *const fn (context: *const anyopaque) void,
 
         fn fromFiber(fiber: *Fiber) *Group.AsyncClosure {
             return @ptrFromInt(Fiber.max_context_align.max(.of(Group.AsyncClosure)).backward(
@@ -1370,11 +1370,7 @@ const Group = struct {
             const ev = closure.evented;
             const fiber = closure.fiber;
             message.handle(ev);
-            if (closure.start(closure.contextPointer())) {
-                assert(!fiber.cancel_protection.acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
-            } else |err| switch (err) {
-                error.Canceled => assert(fiber.cancel_protection.acknowledged), // group task returned `error.Canceled` but was never canceled
-            }
+            closure.start(closure.contextPointer());
             if (closure.group.removeFiber(ev, fiber)) |awaiter| ev.queue.async(awaiter, &Fiber.@"resume");
             ev.yield(.destroy);
             unreachable; // switched to dead fiber
@@ -1387,28 +1383,11 @@ fn groupAsync(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     return groupConcurrent(ev, type_erased, context, context_alignment, start) catch {
-        const fiber = Thread.current().currentFiber();
-        const pre_acknowledged = fiber.cancel_protection.acknowledged;
-        const result = start(context.ptr);
-        const post_acknowledged = fiber.cancel_protection.acknowledged;
-        if (result) {
-            if (pre_acknowledged) {
-                assert(post_acknowledged); // group task called `recancel` but was not canceled
-            } else {
-                assert(!post_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
-            }
-        } else |err| switch (err) {
-            // Don't swallow the cancelation: make it visible to the `Group.async` caller.
-            error.Canceled => {
-                assert(!pre_acknowledged); // group task called `recancel` but was not canceled
-                assert(post_acknowledged); // group task returned `error.Canceled` but was never canceled
-                fiber.cancel_protection.recancel();
-            },
-        }
+        start(context.ptr);
     };
 }
 
@@ -1417,7 +1396,7 @@ fn groupConcurrent(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) Io.ConcurrentError!void {
     assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
     assert(context.len <= Fiber.max_context_size); // TODO
diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig
index e70a3b1274c25333564c8a9655d0d974c64b2007..3a4dadea2c6df3586f4982901516d0acae6bc7f1 100644
--- a/lib/std/Io/Kqueue.zig
+++ b/lib/std/Io/Kqueue.zig
@@ -766,7 +766,7 @@ fn groupAsync(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) void {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
@@ -782,7 +782,7 @@ fn groupConcurrent(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) Io.ConcurrentError!void {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index a7e9668309eab37ccf91f34fc4bcdb57744b0b42..c0b6b2b47d8e20503e1c31bc65a9a5f81445712a 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -412,7 +412,7 @@ const Group = struct {
     const Task = struct {
         runnable: Runnable,
         group: *Io.Group,
-        func: *const fn (context: *const anyopaque) Io.Cancelable!void,
+        func: *const fn (context: *const anyopaque) void,
         context_alignment: Alignment,
         alloc_len: usize,
 
@@ -422,7 +422,7 @@ const Group = struct {
             group: Group,
             context: []const u8,
             context_alignment: Alignment,
-            func: *const fn (context: *const anyopaque) Io.Cancelable!void,
+            func: *const fn (context: *const anyopaque) void,
         ) Allocator.Error!*Task {
             const max_context_misalignment = context_alignment.toByteUnits() -| @alignOf(Task);
             const worst_case_context_offset = context_alignment.forward(@sizeOf(Task) + max_context_misalignment);
@@ -477,21 +477,7 @@ const Group = struct {
                 }, .monotonic);
             }
 
-            const result = task.func(task.contextPointer());
-            const cancel_acknowledged = switch (thread.status.load(.monotonic).cancelation) {
-                .none, .canceling => false,
-                .canceled => true,
-                .parked => unreachable,
-                .blocked => unreachable,
-                .blocked_alertable => unreachable,
-                .blocked_alertable_canceling => unreachable,
-                .blocked_canceling => unreachable,
-            };
-            if (result) {
-                assert(!cancel_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
-            } else |err| switch (err) {
-                error.Canceled => assert(cancel_acknowledged), // group task returned `error.Canceled` but was never canceled
-            }
+            task.func(task.contextPointer());
 
             thread.status.store(.{ .cancelation = .none, .awaitable = .null }, .monotonic);
             const old_status = group.status().fetchSub(.{
@@ -2272,7 +2258,7 @@ fn groupAsync(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const g: Group = .{ .ptr = type_erased };
@@ -2323,47 +2309,10 @@ fn groupAsync(
     condSignal(&t.cond);
 }
 fn groupAsyncEager(
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
     context: *const anyopaque,
 ) void {
-    const pre_acknowledged = if (Thread.current) |thread| ack: {
-        break :ack switch (thread.status.load(.monotonic).cancelation) {
-            .none, .canceling => false,
-            .canceled => true,
-            .parked => unreachable,
-            .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
-            .blocked_canceling => unreachable,
-        };
-    } else false;
-    const result = start(context);
-    const post_acknowledged = if (Thread.current) |thread| ack: {
-        break :ack switch (thread.status.load(.monotonic).cancelation) {
-            .none, .canceling => false,
-            .canceled => true,
-            .parked => unreachable,
-            .blocked => unreachable,
-            .blocked_alertable => unreachable,
-            .blocked_alertable_canceling => unreachable,
-            .blocked_canceling => unreachable,
-        };
-    } else false;
-
-    if (result) {
-        if (pre_acknowledged) {
-            assert(post_acknowledged); // group task called `recancel` but was not canceled
-        } else {
-            assert(!post_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
-        }
-    } else |err| switch (err) {
-        // Don't swallow the cancelation: make it visible to the `Group.async` caller.
-        error.Canceled => {
-            assert(!pre_acknowledged); // group task called `recancel` but was not canceled
-            assert(post_acknowledged); // group task returned `error.Canceled` but was never canceled
-            recancelInner();
-        },
-    }
+    start(context);
 }
 
 fn groupConcurrent(
@@ -2371,7 +2320,7 @@ fn groupConcurrent(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) Io.ConcurrentError!void {
     if (builtin.single_threaded) return error.ConcurrencyUnavailable;
 
diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index 12c715c205b4920a6dc6adb5a72a040dab1d11fc..0f4f64334f3da1bbb5eec2701c513bb3762e56d0 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -1738,7 +1738,7 @@ const Group = struct {
         evented: *Evented,
         group: Group,
         fiber: *Fiber,
-        start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+        start: *const fn (context: *const anyopaque) void,
 
         fn fromFiber(fiber: *Fiber) *Group.AsyncClosure {
             return @ptrFromInt(Fiber.max_context_align.max(.of(Group.AsyncClosure)).backward(
@@ -1784,11 +1784,7 @@ const Group = struct {
             const fiber = closure.fiber;
             message.handle(ev);
             assert(fiber.status.queue_next == null);
-            if (closure.start(closure.contextPointer())) {
-                assert(!fiber.cancel_protection.acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
-            } else |err| switch (err) {
-                error.Canceled => assert(fiber.cancel_protection.acknowledged), // group task returned `error.Canceled` but was never canceled
-            }
+            closure.start(closure.contextPointer());
             ev.yield(closure.group.removeFiber(ev, fiber), .destroy);
             unreachable; // switched to dead fiber
         }
@@ -1800,28 +1796,11 @@ fn groupAsync(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     return groupConcurrent(ev, type_erased, context, context_alignment, start) catch {
-        const fiber = Thread.current().currentFiber();
-        const pre_acknowledged = fiber.cancel_protection.acknowledged;
-        const result = start(context.ptr);
-        const post_acknowledged = fiber.cancel_protection.acknowledged;
-        if (result) {
-            if (pre_acknowledged) {
-                assert(post_acknowledged); // group task called `recancel` but was not canceled
-            } else {
-                assert(!post_acknowledged); // group task acknowledged cancelation but did not return `error.Canceled`
-            }
-        } else |err| switch (err) {
-            // Don't swallow the cancelation: make it visible to the `Group.async` caller.
-            error.Canceled => {
-                assert(!pre_acknowledged); // group task called `recancel` but was not canceled
-                assert(post_acknowledged); // group task returned `error.Canceled` but was never canceled
-                fiber.cancel_protection.recancel();
-            },
-        }
+        start(context.ptr);
     };
 }
 
@@ -1830,7 +1809,7 @@ fn groupConcurrent(
     type_erased: *Io.Group,
     context: []const u8,
     context_alignment: Alignment,
-    start: *const fn (context: *const anyopaque) Io.Cancelable!void,
+    start: *const fn (context: *const anyopaque) void,
 ) Io.ConcurrentError!void {
     assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
     assert(context.len <= Fiber.max_context_size); // TODO
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 587c23eb85defb5c01dc2435ab50140dfdac43cc..2de8d1022c4e8da958c2fedfdbd9c0b7249be80e 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -255,8 +255,6 @@ test "Group.cancel" {
 }
 
 test "Group.concurrent" {
-    if (builtin.os.tag == .linux and !builtin.link_libc) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30096
-
     const io = testing.io;
 
     var group: Io.Group = .init;
@@ -265,14 +263,14 @@ test "Group.concurrent" {
 
     group.concurrent(io, count, .{ 1, 10, &results[0] }) catch |err| switch (err) {
         error.ConcurrencyUnavailable => {
-            try testing.expect(builtin.single_threaded);
+            try expect(builtin.single_threaded);
             return;
         },
     };
 
     group.concurrent(io, count, .{ 20, 30, &results[1] }) catch |err| switch (err) {
         error.ConcurrencyUnavailable => {
-            try testing.expect(builtin.single_threaded);
+            try expect(builtin.single_threaded);
             return;
         },
     };
@@ -282,6 +280,57 @@ test "Group.concurrent" {
     try testing.expectEqualSlices(usize, &.{ 45, 245 }, &results);
 }
 
+test "Group materializes error.Cancel" {
+    const S = struct {
+        fn task() Io.Cancelable!void {
+            return error.Canceled;
+        }
+    };
+
+    const io = testing.io;
+
+    var group: Io.Group = .init;
+
+    group.async(io, S.task, .{});
+    group.concurrent(io, S.task, .{}) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => {
+            try expect(builtin.single_threaded);
+            return;
+        },
+    };
+
+    try group.await(io);
+}
+
+test "Group task receives cancelation unknowingly" {
+    const S = struct {
+        io: Io,
+        err: ?Io.Cancelable!void,
+
+        fn task(s: *@This()) void {
+            foo(s);
+        }
+
+        fn foo(s: *@This()) void {
+            s.err = s.io.sleep(.fromSeconds(300), .awake);
+        }
+    };
+
+    const io = testing.io;
+
+    var group: Io.Group = .init;
+    var result: S = .{ .io = io, .err = null };
+    group.concurrent(io, S.task, .{&result}) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => {
+            try expect(builtin.single_threaded);
+            return;
+        },
+    };
+    group.cancel(io);
+
+    try expectError(error.Canceled, result.err.?);
+}
+
 fn testQueue(comptime len: usize) !void {
     const io = testing.io;
     var buf: [len]usize = undefined;
@@ -541,7 +590,7 @@ test "random" {
     io.random(@ptrCast(&b));
     io.random(@ptrCast(&c));
 
-    try std.testing.expect(a ^ b ^ c != 0);
+    try expect(a ^ b ^ c != 0);
 }
 
 test "randomSecure" {
-- 
2.54.0


From b3c8c0df0dc1a23625d823a1c1878004c6b0bc9e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 27 Feb 2026 20:27:43 +0100
Subject: [PATCH 359/499] ci: switch to VS 2026 in x86_64-windows scripts

---
 ci/x86_64-windows-debug.ps1   | 4 ++--
 ci/x86_64-windows-release.ps1 | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/ci/x86_64-windows-debug.ps1 b/ci/x86_64-windows-debug.ps1
index b1486f31bc6f6d57de99ea640bf44865e43861a4..aed6b0cca8916110aba611f8880f2170f02057e9 100644
--- a/ci/x86_64-windows-debug.ps1
+++ b/ci/x86_64-windows-debug.ps1
@@ -87,10 +87,10 @@ stage3-debug\bin\zig test `
   ..\test\behavior.zig
 CheckLastExitCode
 
-Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
+Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
 CheckLastExitCode
 
-Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools" `
+Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools" `
   -DevCmdArguments '-arch=x64 -no_logo' `
   -StartInPath $(Get-Location)
 CheckLastExitCode
diff --git a/ci/x86_64-windows-release.ps1 b/ci/x86_64-windows-release.ps1
index a8674d1d3dcc6b57e775bd9dec11faf04f1279ab..59d1e3c4c7a39872a6aa70b2502854bb1204f403 100644
--- a/ci/x86_64-windows-release.ps1
+++ b/ci/x86_64-windows-release.ps1
@@ -106,10 +106,10 @@ stage3-release\bin\zig.exe test `
   ..\test\behavior.zig
 CheckLastExitCode
 
-Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
+Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
 CheckLastExitCode
 
-Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools" `
+Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools" `
   -DevCmdArguments '-arch=x64 -no_logo' `
   -StartInPath $(Get-Location)
 CheckLastExitCode
-- 
2.54.0


From bd6f512f0c1591cce013e58ded87dcf78ad2b7a2 Mon Sep 17 00:00:00 2001
From: hemisputnik <hemisputnik@proton.me>
Date: Sat, 28 Feb 2026 04:39:32 +0200
Subject: [PATCH 360/499] std.math.big.int: add log10

---
 lib/std/math/big/int.zig      | 56 +++++++++++++++++++++++++++++++++++
 lib/std/math/big/int_test.zig | 20 +++++++++++++
 2 files changed, 76 insertions(+)

diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index 29c1423a1446184dd4c8ba99a623b56afd03fac8..fc79c4c3a7fe7c123d9dc8b1972385a44f9e1b3f 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -63,6 +63,11 @@ pub fn calcLimbLen(scalar: anytype) usize {
     }
 }
 
+/// Same as `calcToStringLimbsBufferLen`, without the useless base check.
+pub fn calcLog10LimbsBufferLen(a_len: usize) usize {
+    return a_len + 2 + a_len + calcDivLimbsBufferLen(a_len, 1);
+}
+
 pub fn calcToStringLimbsBufferLen(a_len: usize, base: u8) usize {
     if (math.isPowerOfTwo(base))
         return 0;
@@ -2675,6 +2680,57 @@ pub const Const = struct {
     pub fn log2(a: Const) Limb {
         return a.limbs.len * @bitSizeOf(Limb) - 1 - @clz(a.limbs[a.limbs.len - 1]);
     }
+
+    /// Calculate the base 10 logarithm, rounded down.
+    ///
+    /// The allocator is used to allocate a temporary buffer.
+    pub fn log10Alloc(a: Const, allocator: Allocator) Allocator.Error!Limb {
+        const limbs_buffer = try allocator.alloc(Limb, calcLog10LimbsBufferLen(a.limbs.len));
+        defer allocator.free(limbs_buffer);
+
+        return a.log10(limbs_buffer);
+    }
+
+    /// Calculate the base 10 logarithm, rounded down.
+    ///
+    /// `limbs_buffer` is used for temporary storage. The amount required is given by `calcLog10LimbsBufferLen`.
+    pub fn log10(a: Const, limbs_buffer: []Limb) Limb {
+        const max_digits_per_limb = std.math.log10(std.math.maxInt(Limb));
+        const limb_base = comptime calc: {
+            var limb_base: comptime_int = 1;
+            for (0..max_digits_per_limb) |_| limb_base *= 10;
+            break :calc limb_base;
+        };
+        const limb_base_as_bigint: Const = .{ .limbs = &.{limb_base}, .positive = true };
+
+        var q: Mutable = .{
+            .limbs = limbs_buffer[0 .. a.limbs.len + 2],
+            .positive = true,
+            .len = a.limbs.len,
+        };
+        @memcpy(q.limbs[0..a.limbs.len], a.limbs);
+
+        var remainder: Mutable = .{
+            .limbs = limbs_buffer[q.limbs.len..][0..a.limbs.len],
+            .positive = true,
+            .len = 1,
+        };
+
+        const division_buf = limbs_buffer[q.limbs.len + remainder.limbs.len ..];
+
+        var num_digits: Limb = 0;
+        while (q.len >= 2) {
+            q.divTrunc(&remainder, q.toConst(), limb_base_as_bigint, division_buf);
+            num_digits += max_digits_per_limb;
+        }
+        var remaining_limb = q.limbs[0];
+        while (remaining_limb != 0) {
+            remaining_limb /= 10;
+            num_digits += 1;
+        }
+
+        return num_digits - 1;
+    }
 };
 
 /// An arbitrary-precision big integer along with an allocator which manages the memory.
diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig
index 2c2aeb9df71f86e0f52f39557204a67a6354c315..d549402f1e70e1b20a50bb0998208922a7dc1eea 100644
--- a/lib/std/math/big/int_test.zig
+++ b/lib/std/math/big/int_test.zig
@@ -4089,3 +4089,23 @@ test "log2" {
     try a.setString(16, "a22d71c87a9ce406da4f5895f9f3cc3d603192baf6c8a2b5c32649d0465bf188fe799b3618085e49d71bdaec01");
     try testing.expectEqual(359, a.toConst().log2());
 }
+
+test "log10" {
+    var a = try Managed.init(testing.allocator);
+    defer a.deinit();
+
+    try a.setString(10, "1");
+    try testing.expectEqual(0, a.toConst().log10Alloc(testing.allocator));
+
+    try a.setString(10, "1234");
+    try testing.expectEqual(3, a.toConst().log10Alloc(testing.allocator));
+
+    try a.setString(10, "123456789");
+    try testing.expectEqual(8, a.toConst().log10Alloc(testing.allocator));
+
+    try a.setString(10, "57594534510580048222343352832931567593656037535732288627581929757527496850784");
+    try testing.expectEqual(76, a.toConst().log10Alloc(testing.allocator));
+
+    try a.setString(10, "504758845984192913149382719638135788792820830414213085834451043864912744833203879823150928260925344757009154551640690830148486352800955148298533547472300");
+    try testing.expectEqual(152, a.toConst().log10Alloc(testing.allocator));
+}
-- 
2.54.0


From bf13b6b41d0b8f96fd8d6a6ebaf294ca7ea43d63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Mar 2026 11:53:05 +0100
Subject: [PATCH 361/499] test: partially disable cmakedefine standalone test

https://codeberg.org/ziglang/zig/issues/31368
---
 test/standalone/cmakedefine/check.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/standalone/cmakedefine/check.zig b/test/standalone/cmakedefine/check.zig
index 8db602f39d6db5f20bb016ade3853b1bf78b7ec3..d353b8700ca480803de217bbd619a4ad84147945 100644
--- a/test/standalone/cmakedefine/check.zig
+++ b/test/standalone/cmakedefine/check.zig
@@ -17,6 +17,8 @@ pub fn main(init: std.process.Init) !void {
     }
     const actual_without_comment = actual[comment_str.len..];
 
+    if (true) return; // https://codeberg.org/ziglang/zig/issues/31368
+
     if (!std.mem.eql(u8, actual_without_comment, expected)) {
         return error.DoesNotMatch;
     }
-- 
2.54.0


From 104e73ecb285bc818c7759e006f308d5031fc2f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Mar 2026 12:04:55 +0100
Subject: [PATCH 362/499] ci: disable aarch64-freebsd

Working through some OOM issues.
---
 .forgejo/workflows/ci.yaml | 40 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index fffd3c0eadf28ac0f4836dd0b1123dd97e41efc8..e70d528a205cce6d86f6d1a06438df2cf053bc97 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -17,26 +17,26 @@ permissions:
   contents: read
 
 jobs:
-  aarch64-freebsd-debug:
-    runs-on: [self-hosted, aarch64-freebsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-freebsd-debug.sh
-        timeout-minutes: 240
-  aarch64-freebsd-release:
-    runs-on: [self-hosted, aarch64-freebsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-freebsd-release.sh
-        timeout-minutes: 180
+  #aarch64-freebsd-debug:
+  #  runs-on: [self-hosted, aarch64-freebsd]
+  #  steps:
+  #    - name: Checkout
+  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+  #      with:
+  #        fetch-depth: 0
+  #    - name: Build and Test
+  #      run: sh ci/aarch64-freebsd-debug.sh
+  #      timeout-minutes: 240
+  #aarch64-freebsd-release:
+  #  runs-on: [self-hosted, aarch64-freebsd]
+  #  steps:
+  #    - name: Checkout
+  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+  #      with:
+  #        fetch-depth: 0
+  #    - name: Build and Test
+  #      run: sh ci/aarch64-freebsd-release.sh
+  #      timeout-minutes: 180
 
   aarch64-linux-debug:
     runs-on: [self-hosted, aarch64-linux]
-- 
2.54.0


From da6d4e28eff7b65589b046d2772516a6d9fd25bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Mar 2026 17:52:57 +0100
Subject: [PATCH 363/499] Revert "ci: disable aarch64-freebsd"

This reverts commit 104e73ecb285bc818c7759e006f308d5031fc2f3.

The OOM issues should be resolved now.
---
 .forgejo/workflows/ci.yaml | 40 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index e70d528a205cce6d86f6d1a06438df2cf053bc97..e2d321a51b85ae00b90d57370485fdd5f136a84d 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -17,26 +17,26 @@ permissions:
   contents: read
 
 jobs:
-  #aarch64-freebsd-debug:
-  #  runs-on: [self-hosted, aarch64-freebsd]
-  #  steps:
-  #    - name: Checkout
-  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-  #      with:
-  #        fetch-depth: 0
-  #    - name: Build and Test
-  #      run: sh ci/aarch64-freebsd-debug.sh
-  #      timeout-minutes: 240
-  #aarch64-freebsd-release:
-  #  runs-on: [self-hosted, aarch64-freebsd]
-  #  steps:
-  #    - name: Checkout
-  #      uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-  #      with:
-  #        fetch-depth: 0
-  #    - name: Build and Test
-  #      run: sh ci/aarch64-freebsd-release.sh
-  #      timeout-minutes: 180
+  aarch64-freebsd-debug:
+    runs-on: [self-hosted, aarch64-freebsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/aarch64-freebsd-debug.sh
+        timeout-minutes: 240
+  aarch64-freebsd-release:
+    runs-on: [self-hosted, aarch64-freebsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/aarch64-freebsd-release.sh
+        timeout-minutes: 240
 
   aarch64-linux-debug:
     runs-on: [self-hosted, aarch64-linux]
-- 
2.54.0


From 74f361a5ce5212ce321fd0ebfa4c158468a161bb Mon Sep 17 00:00:00 2001
From: hemisputnik <hemisputnik@proton.me>
Date: Sun, 1 Mar 2026 14:05:22 +0200
Subject: [PATCH 364/499] std.math.big.int: address log2/log10 reviews

There were good reviews made after #31365 was merged, so this commit
addresses them separately.

1. Assert that the number is greater than zero
2. Use `constants` instead of calculating constants manually
3. Use `Const.bitCountAbs` for log2
---
 lib/std/math/big/int.zig | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index fc79c4c3a7fe7c123d9dc8b1972385a44f9e1b3f..96fee84ddf2c6459a72b6823d4a0ea513a113270 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -2678,7 +2678,9 @@ pub const Const = struct {
 
     /// Calculate the base 2 logarithm, rounded down.
     pub fn log2(a: Const) Limb {
-        return a.limbs.len * @bitSizeOf(Limb) - 1 - @clz(a.limbs[a.limbs.len - 1]);
+        assert(a.positive);
+        assert(!a.eqlZero());
+        return a.bitCountAbs() - 1;
     }
 
     /// Calculate the base 10 logarithm, rounded down.
@@ -2695,13 +2697,9 @@ pub const Const = struct {
     ///
     /// `limbs_buffer` is used for temporary storage. The amount required is given by `calcLog10LimbsBufferLen`.
     pub fn log10(a: Const, limbs_buffer: []Limb) Limb {
-        const max_digits_per_limb = std.math.log10(std.math.maxInt(Limb));
-        const limb_base = comptime calc: {
-            var limb_base: comptime_int = 1;
-            for (0..max_digits_per_limb) |_| limb_base *= 10;
-            break :calc limb_base;
-        };
-        const limb_base_as_bigint: Const = .{ .limbs = &.{limb_base}, .positive = true };
+        assert(a.positive);
+        assert(!a.eqlZero());
+        const limb_base_as_bigint: Const = .{ .limbs = &.{constants.big_bases[10]}, .positive = true };
 
         var q: Mutable = .{
             .limbs = limbs_buffer[0 .. a.limbs.len + 2],
@@ -2721,7 +2719,7 @@ pub const Const = struct {
         var num_digits: Limb = 0;
         while (q.len >= 2) {
             q.divTrunc(&remainder, q.toConst(), limb_base_as_bigint, division_buf);
-            num_digits += max_digits_per_limb;
+            num_digits += constants.digits_per_limb[10];
         }
         var remaining_limb = q.limbs[0];
         while (remaining_limb != 0) {
-- 
2.54.0


From e58fea8227828c0653d687b3baac785ae0564bcd Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Sat, 7 Feb 2026 13:21:24 -0800
Subject: [PATCH 365/499] tar: Fix symlink test when symlinks can't be created
 on Windows

---
 lib/std/tar.zig | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/std/tar.zig b/lib/std/tar.zig
index d108a03219ddfc0c29161972b0cb3707470fb3c5..f6031f709df6bcbc97334ac3bbc2bac4721baa44 100644
--- a/lib/std/tar.zig
+++ b/lib/std/tar.zig
@@ -16,6 +16,7 @@
 //! pax reference: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13
 
 const std = @import("std");
+const builtin = @import("builtin");
 const Io = std.Io;
 const assert = std.debug.assert;
 const testing = std.testing;
@@ -885,10 +886,10 @@ test "create file and symlink" {
     file = try createDirAndFile(io, root.dir, "a/b/c/file2", .default_file);
     file.close(io);
 
-    createDirAndSymlink(io, root.dir, "a/b/c/file2", "symlink1") catch |err| {
-        // On Windows when developer mode is not enabled
-        if (err == error.AccessDenied) return error.SkipZigTest;
-        return err;
+    createDirAndSymlink(io, root.dir, "a/b/c/file2", "symlink1") catch |err| switch (err) {
+        // On Windows, symlinks require developer mode/admin privileges and the underlying filesystem must support symlinks
+        error.AccessDenied, error.PermissionDenied, error.FileSystem => if (builtin.os.tag == .windows) return error.SkipZigTest else return err,
+        else => return err,
     };
     try createDirAndSymlink(io, root.dir, "../../../file1", "d/e/f/symlink2");
 
-- 
2.54.0


From 442b292a3712829578c1b93d406a87f1abcf45b8 Mon Sep 17 00:00:00 2001
From: rpkak <rpkak@noreply.codeberg.org>
Date: Mon, 2 Mar 2026 10:17:55 +0100
Subject: [PATCH 366/499] zig fetch: wait until all jobs are finished

---
 src/main.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.zig b/src/main.zig
index 017f7bcf9477621688c48ab5d336817d78182e28..bb36d00376d5410ed4612feab04b9128871bacd8 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -7224,6 +7224,8 @@ fn cmdFetch(
         error.FetchFailed => {}, // error bundle checked below
     };
 
+    try job_queue.group.await(io);
+
     if (fetch.error_bundle.root_list.items.len > 0) {
         var errors = try fetch.error_bundle.toOwnedBundle("");
         errors.renderToStderr(io, .{}, color) catch {};
-- 
2.54.0


From f75e4027bdb92f6aba265bc1c8d39bea25624016 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Mar 2026 19:24:52 +0100
Subject: [PATCH 367/499] test: disable an error trace test on optimized
 aarch64-netbsd

---
 test/error_traces.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/error_traces.zig b/test/error_traces.zig
index 1e6f338eee5e2b9f5d63ed7dd385cc2c5ab24e17..2590e40552685f686097dee57f6e31e60ecd06de 100644
--- a/test/error_traces.zig
+++ b/test/error_traces.zig
@@ -436,6 +436,7 @@ pub fn addCases(cases: *@import("tests.zig").ErrorTracesContext) void {
             .{ .x86_64, .linux },
             .{ .x86, .linux },
             .{ .aarch64, .freebsd },
+            .{ .aarch64, .netbsd },
             .{ .aarch64, .linux },
             .{ .loongarch64, .linux },
             .{ .powerpc64le, .linux },
-- 
2.54.0


From d182feacf7b9af7fef4f815a90c8b0bdcd3f2dc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Mar 2026 19:26:58 +0100
Subject: [PATCH 368/499] ci: add aarch64-netbsd scripts

---
 ci/aarch64-netbsd-debug.sh   | 63 ++++++++++++++++++++++++++++++++
 ci/aarch64-netbsd-release.sh | 69 ++++++++++++++++++++++++++++++++++++
 2 files changed, 132 insertions(+)
 create mode 100755 ci/aarch64-netbsd-debug.sh
 create mode 100755 ci/aarch64-netbsd-release.sh

diff --git a/ci/aarch64-netbsd-debug.sh b/ci/aarch64-netbsd-debug.sh
new file mode 100755
index 0000000000000000000000000000000000000000..5c87d14f47d15ab5bb82158ef0aa28c2dbafdb07
--- /dev/null
+++ b/ci/aarch64-netbsd-debug.sh
@@ -0,0 +1,63 @@
+#!/bin/sh
+
+# Requires cmake ninja-build
+
+set -x
+set -e
+
+TARGET="aarch64-netbsd-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
+PREFIX="$HOME/deps/$CACHE_BASENAME"
+ZIG="$PREFIX/bin/zig"
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+mkdir build-debug
+cd build-debug
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Debug \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja \
+  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
+  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
+# https://github.com/ziglang/zig/issues/22213
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+stage3-debug/bin/zig build test docs \
+  --maxrss ${ZSF_MAX_RSS:-0} \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  -Dskip-test-incremental \
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib" \
+  --test-timeout 4m
+
+stage3-debug/bin/zig build \
+  --prefix stage4-debug \
+  -Denable-llvm \
+  -Dno-lib \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3-debug/bin/zig version)"
+
+stage4-debug/bin/zig test ../test/behavior.zig
diff --git a/ci/aarch64-netbsd-release.sh b/ci/aarch64-netbsd-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..bf54c10efc835b51f87731bfd082132a7ec8fd19
--- /dev/null
+++ b/ci/aarch64-netbsd-release.sh
@@ -0,0 +1,69 @@
+#!/bin/sh
+
+# Requires cmake ninja-build
+
+set -x
+set -e
+
+TARGET="aarch64-netbsd-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
+PREFIX="$HOME/deps/$CACHE_BASENAME"
+ZIG="$PREFIX/bin/zig"
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+mkdir build-release
+cd build-release
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-release" \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja \
+  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
+  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
+# https://github.com/ziglang/zig/issues/22213
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+stage3-release/bin/zig build test docs \
+  --maxrss ${ZSF_MAX_RSS:-0} \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  -Dskip-test-incremental \
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib" \
+  --test-timeout 4m
+
+# Ensure that stage3 and stage4 are byte-for-byte identical.
+stage3-release/bin/zig build \
+  --prefix stage4-release \
+  -Denable-llvm \
+  -Dno-lib \
+  -Doptimize=ReleaseFast \
+  -Dstrip \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3-release/bin/zig version)"
+
+# diff returns an error code if the files differ.
+echo "If the following command fails, it means nondeterminism has been"
+echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
+diff stage3-release/bin/zig stage4-release/bin/zig
-- 
2.54.0


From d6e9b9eb642542cd0e113a73285680b443a6a9f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 1 Mar 2026 19:28:25 +0100
Subject: [PATCH 369/499] ci: enable aarch64-netbsd

---
 .forgejo/workflows/ci.yaml | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index e2d321a51b85ae00b90d57370485fdd5f136a84d..160271aded4052668cd533db49699e1aaf32f9b9 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -59,6 +59,27 @@ jobs:
         run: sh ci/aarch64-linux-release.sh
         timeout-minutes: 120
 
+  aarch64-netbsd-debug:
+    runs-on: [self-hosted, aarch64-netbsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/aarch64-netbsd-debug.sh
+        timeout-minutes: 300
+  aarch64-netbsd-release:
+    runs-on: [self-hosted, aarch64-netbsd]
+    steps:
+      - name: Checkout
+        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
+        with:
+          fetch-depth: 0
+      - name: Build and Test
+        run: sh ci/aarch64-netbsd-release.sh
+        timeout-minutes: 240
+
   aarch64-macos-debug:
     runs-on: [self-hosted, aarch64-macos]
     steps:
-- 
2.54.0


From 0a2f6a048b1e9c9eee97b463c18aaedad3e31f60 Mon Sep 17 00:00:00 2001
From: invlpg <me@jo.ie>
Date: Sat, 28 Feb 2026 15:01:05 +0100
Subject: [PATCH 370/499] fix msghdr and cmsghdr on non-Linux targets, document
 musl behaviour

The following assertions fail on non-Linux platforms after c0c20105354
which inserted padding based on musl definitions. This padding only
exists on musl to workaround a discrepancy betweeen the POSIX API and
Linux ABI, and is incorrect on other POSIX operating systems.

This change makes the padding musl-only, and documents the reason it
exists. With this change, the assertions pass on Linux and FreeBSD
targets. The corresponding definitions on other targets line up with the
POSIX and FreeBSD ones, so they should work there too.

```zig
const std = @import("std");
const assert = std.debug.assert;
const msghdr = std.c.msghdr;
const cmsghdr = std.c.cmsghdr;

const c = @cImport({
    @cInclude("sys/socket.h");
});

comptime {
    assert(@offsetOf(msghdr, "iovlen") == @offsetOf(c.msghdr, "msg_iovlen"));
    assert(@offsetOf(msghdr, "controllen") == @offsetOf(c.msghdr, "msg_controllen"));
    assert(@offsetOf(msghdr, "control") == @offsetOf(c.msghdr, "msg_control"));
    assert(@offsetOf(msghdr, "flags") == @offsetOf(c.msghdr, "msg_flags"));

    assert(@sizeOf(msghdr) == @sizeOf(c.msghdr));

    assert(@offsetOf(cmsghdr, "len") == @offsetOf(c.cmsghdr, "cmsg_len"));
    assert(@offsetOf(cmsghdr, "level") == @offsetOf(c.cmsghdr, "cmsg_level"));

    assert(@sizeOf(cmsghdr) == @sizeOf(c.cmsghdr));
}
```
---
 lib/std/c.zig | 47 +++++++++++++++++++++++++++++++++++++----------
 1 file changed, 37 insertions(+), 10 deletions(-)

diff --git a/lib/std/c.zig b/lib/std/c.zig
index 653e10576d5e8cc7860e5b7e15f251041a4902d2..8251b17913ec7ce805aaf8aea1afdc45ab15b438 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -4186,18 +4186,45 @@ pub const msghdr = switch (native_os) {
     else => void,
 };
 
+/// There are several instances of struct fields that POSIX defines as either int or socklen_t, but
+/// on Linux are size_t. glibc ignores POSIX, and uses the Linux kernel's definitions. musl on the
+/// other hand aims to be POSIX-ly correct, and defines those fields in a manner aligning with
+/// POSIX.
+///
+/// musl works around this incompatibility between the 64-bit Linux ABI and the POSIX specification
+/// by adding padding fields on either side depending on host endianness:
+///
+///     #if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __BIG_ENDIAN
+///         int __pad2;
+///     #endif
+///         socklen_t msg_controllen;
+///     #if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __LITTLE_ENDIAN
+///         int __pad2;
+///     #endif
+///
+/// To emulate this quirk of musl, the MuslOnlyPadding field is used in these structs
+///
+///     pad0: MuslOnlyPadding(.big) = 0,
+///     msg_controllen: socklen_t,
+///     pad1: MuslOnlyPadding(.little) = 0,
+///
+/// On 32-bit and non-musl systems, these fields will be zero sized, and ignored.
+fn MuslOnlyPadding(endian: std.builtin.Endian) type {
+    return if (builtin.abi.isMusl() and @sizeOf(usize) == 8 and native_endian == endian) u32 else u0;
+}
+
 /// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/sys_socket.h.html
 const posix_msghdr = extern struct {
     name: ?*sockaddr,
     namelen: socklen_t,
     iov: [*]iovec,
-    pad0: if (@sizeOf(usize) == 8 and native_endian == .big) u32 else u0 = 0,
+    pad0: MuslOnlyPadding(.big) = 0,
     iovlen: u32,
-    pad1: if (@sizeOf(usize) == 8 and native_endian == .little) u32 else u0 = 0,
+    pad1: MuslOnlyPadding(.little) = 0,
     control: ?*anyopaque,
-    pad2: if (@sizeOf(usize) == 8 and native_endian == .big) u32 else u0 = 0,
+    pad2: MuslOnlyPadding(.big) = 0,
     controllen: socklen_t,
-    pad3: if (@sizeOf(usize) == 8 and native_endian == .little) u32 else u0 = 0,
+    pad3: MuslOnlyPadding(.little) = 0,
     flags: u32,
 };
 
@@ -4226,13 +4253,13 @@ const posix_msghdr_const = extern struct {
     name: ?*const sockaddr,
     namelen: socklen_t,
     iov: [*]const iovec_const,
-    pad0: if (@sizeOf(usize) == 8 and native_endian == .big) u32 else u0 = 0,
+    pad0: MuslOnlyPadding(.big) = 0,
     iovlen: u32,
-    pad1: if (@sizeOf(usize) == 8 and native_endian == .little) u32 else u0 = 0,
+    pad1: MuslOnlyPadding(.little) = 0,
     control: ?*const anyopaque,
-    pad2: if (@sizeOf(usize) == 8 and native_endian == .big) u32 else u0 = 0,
+    pad2: MuslOnlyPadding(.big) = 0,
     controllen: socklen_t,
-    pad3: if (@sizeOf(usize) == 8 and native_endian == .little) u32 else u0 = 0,
+    pad3: MuslOnlyPadding(.little) = 0,
     flags: u32,
 };
 
@@ -4276,9 +4303,9 @@ pub const cmsghdr = switch (native_os) {
 };
 
 const posix_cmsghdr = extern struct {
-    pad0: if (@sizeOf(usize) == 8 and native_endian == .big) u32 else u0 = 0,
+    pad0: MuslOnlyPadding(.big) = 0,
     len: socklen_t,
-    pad1: if (@sizeOf(usize) == 8 and native_endian == .little) u32 else u0 = 0,
+    pad1: MuslOnlyPadding(.little) = 0,
     level: c_int,
     type: c_int,
 };
-- 
2.54.0


From 421c3c3cc57f05bf53678ee79230c66200a69081 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 2 Mar 2026 14:48:13 +0100
Subject: [PATCH 371/499] ci: update qemu to 10.2.1.1

https://patchwork.kernel.org/project/qemu-devel/list/?series=1059138
---
 ci/x86_64-linux-debug-llvm.sh | 2 +-
 ci/x86_64-linux-debug.sh      | 2 +-
 ci/x86_64-linux-release.sh    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index 815adfbe8e635bc2110a11f779e60b7d0a44fc72..a0e3e01b05bb2bbe27dbd6798933378c71ac8313 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index 01e7fdfff7dbf3e636a20953faf9d17a9a5197d7..75f2e64f4f52e99aebdfa3e4b48b20a154a5514b 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 65f28ac59846a86d4b8177ffaa2131540eec003a..6c0a63ddf5eb5258a3cee2533853a46a06b3c74b 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
-- 
2.54.0


From 0a412853aae9815eb663a88a8a2d37b91c614317 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 2 Mar 2026 08:30:42 -0800
Subject: [PATCH 372/499] std.Io: fix Select cancel deadlock with no tasks

---
 lib/std/Io.zig      |  9 +++------
 lib/std/Io/test.zig | 11 +++++++++++
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index d9bf914aa4018da8dd5670eef03bc48a8a1a0117..7b06ccfb6a254b881ea6be334a356e474a4ec1c7 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1446,11 +1446,8 @@ pub fn Select(comptime U: type) type {
         /// Threadsafe.
         pub fn cancel(s: *S) ?U {
             const io = s.io;
-            if (s.group.token.load(.acquire)) |token| {
-                io.vtable.groupCancel(io.userdata, &s.group, token);
-                assert(s.group.token.raw == null);
-                s.queue.close(io);
-            }
+            s.group.cancel(io);
+            s.queue.close(io);
             return s.queue.getOneUncancelable(io) catch |err| switch (err) {
                 error.Closed => return null,
             };
@@ -1855,7 +1852,7 @@ pub const TypeErasedQueue = struct {
     /// there is space in the buffer. However, existing elements of the
     /// queue are retrieved before `error.Closed` is returned.
     ///
-    /// Threadsafe.
+    /// Idempotent. Threadsafe.
     pub fn close(q: *TypeErasedQueue, io: Io) void {
         q.mutex.lockUncancelable(io);
         defer q.mutex.unlock(io);
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 2de8d1022c4e8da958c2fedfdbd9c0b7249be80e..62ad3c2ec8fc4b182b2071363fd13729c3c86043 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -937,3 +937,14 @@ test "Select with empty buffer, no deadlock" {
     };
     assert((try select.await()) == .sleeper);
 }
+
+test "Select.cancel with no tasks, no deadlock" {
+    const io = testing.io;
+
+    const U = union(enum) {
+        nothing: void,
+        also_nothing: void,
+    };
+    var select: Io.Select(U) = .init(io, &.{});
+    try expectEqual(null, select.cancel());
+}
-- 
2.54.0


From 70058471e341870dc6991cf9cb92a590a94912c2 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Thu, 26 Feb 2026 23:02:11 -0800
Subject: [PATCH 373/499] WindowsSdk: Use ntdll instead of advapi32 APIs for
 registry querying
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The dependency on advapi32.dll actually silently brings along 3 other dlls at runtime (msvcrt.dll, sechost.dll, bcrypt.dll), even if no advapi32 APIs are called. So, this commit actually reduces the number of dlls loaded at runtime by 4 (but only when LLVM is not linked, since LLVM has its own dependency on advapi32.dll).

The data is not super conclusive, but the ntdll version of WindowsSdk appears to run slightly faster than the previous advapi32 version:

Benchmark 1: libc-ntdll.exe ..
  Time (mean ± σ):       6.0 ms ±   0.6 ms    [User: 3.9 ms, System: 7.1 ms]
  Range (min … max):     4.8 ms …   7.9 ms    112 runs

Benchmark 2: libc-advapi32.exe ..
  Time (mean ± σ):       7.2 ms ±   0.5 ms    [User: 5.4 ms, System: 9.2 ms]
  Range (min … max):     6.1 ms …   8.9 ms    103 runs

Summary
  'libc-ntdll.exe ..' ran
    1.21 ± 0.15 times faster than 'libc-advapi32.exe ..'

and this mostly seems to be due to changes in the implementation (the advapi32 APIs do a lot of NtQueryKey calls that the new implementation doesn't do) rather than due to the decrease in dll loading. LLVM-less zig binaries don't show the same reduction (the only difference here is the DLLs being loaded):

Benchmark 1: stage4-ntdll\bin\zig.exe version
  Time (mean ± σ):       3.0 ms ±   0.6 ms    [User: 5.3 ms, System: 4.8 ms]
  Range (min … max):     1.3 ms …   4.2 ms    112 runs

Benchmark 2: stage4-advapi32\bin\zig.exe version
  Time (mean ± σ):       3.5 ms ±   0.6 ms    [User: 6.9 ms, System: 5.5 ms]
  Range (min … max):     2.5 ms …   5.9 ms    111 runs

Summary
  'stage4-ntdll\bin\zig.exe version' ran
    1.16 ± 0.28 times faster than 'stage4-advapi32\bin\zig.exe version'

---

With the removal of the advapi32 dependency, the non-ntdll dependencies that remain in an LLVM-less Zig binary are ws2_32.dll (which brings along rpcrt4.dll at runtime), kernel32.dll (which brings along kernelbase.dll at runtime), and crypt32.dll (which brings along ucrtbase.dll at runtime).
---
 lib/std/os/windows.zig         | 162 ++++--
 lib/std/os/windows/ntdll.zig   |  35 ++
 lib/std/zig/WindowsSdk.zig     | 879 +++++++++++++++++++--------------
 lib/std/zig/system/windows.zig |  58 +--
 4 files changed, 702 insertions(+), 432 deletions(-)

diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 0c91f11ff5693ef51e10bfdf9a8f528c3d15e5e5..8db9db03b8495a6c6cea79f530f788e314575b50 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -3506,6 +3506,16 @@ pub const GUID = extern struct {
         }
         return @as(GUID, @bitCast(bytes));
     }
+
+    pub fn format(self: GUID, w: *std.Io.Writer) std.Io.Writer.Error!void {
+        return w.print("{{{x:0>8}-{x:0>4}-{x:0>4}-{x}-{x}}}", .{
+            self.Data1,
+            self.Data2,
+            self.Data3,
+            self.Data4[0..2],
+            self.Data4[2..8],
+        });
+    }
 };
 
 test GUID {
@@ -3518,6 +3528,16 @@ test GUID {
         },
         GUID.parse("{01234567-89AB-EF10-3254-7698badcfe91}"),
     );
+    try std.testing.expectFmt(
+        "{01234567-89ab-ef10-3254-7698badcfe91}",
+        "{f}",
+        .{GUID.parse("{01234567-89AB-EF10-3254-7698badcfe91}")},
+    );
+    try std.testing.expectFmt(
+        "{00000001-0001-0001-0001-000000000001}",
+        "{f}",
+        .{GUID{ .Data1 = 1, .Data2 = 1, .Data3 = 1, .Data4 = [_]u8{ 0, 1, 0, 0, 0, 0, 0, 1 } }},
+    );
 }
 
 pub const COORD = extern struct {
@@ -3560,7 +3580,7 @@ pub const RTL_QUERY_REGISTRY_TABLE = extern struct {
     Flags: ULONG,
     Name: ?PWSTR,
     EntryContext: ?*anyopaque,
-    DefaultType: ULONG,
+    DefaultType: REG.ValueType,
     DefaultData: ?*anyopaque,
     DefaultLength: ULONG,
 };
@@ -3625,34 +3645,120 @@ pub const RTL_QUERY_REGISTRY_DELETE = 0x00000040;
 /// If the types do not match, the call fails.
 pub const RTL_QUERY_REGISTRY_TYPECHECK = 0x00000100;
 
+/// REG_ is a crowded namespace with a lot of overlapping and unrelated
+/// defines in the Windows headers, so instead of strictly following the
+/// Windows headers names, extra namespaces are added here for clarity.
 pub const REG = struct {
-    /// No value type
-    pub const NONE: ULONG = 0;
-    /// Unicode nul terminated string
-    pub const SZ: ULONG = 1;
-    /// Unicode nul terminated string (with environment variable references)
-    pub const EXPAND_SZ: ULONG = 2;
-    /// Free form binary
-    pub const BINARY: ULONG = 3;
-    /// 32-bit number
-    pub const DWORD: ULONG = 4;
-    /// 32-bit number (same as REG_DWORD)
-    pub const DWORD_LITTLE_ENDIAN: ULONG = 4;
-    /// 32-bit number
-    pub const DWORD_BIG_ENDIAN: ULONG = 5;
-    /// Symbolic Link (unicode)
-    pub const LINK: ULONG = 6;
-    /// Multiple Unicode strings
-    pub const MULTI_SZ: ULONG = 7;
-    /// Resource list in the resource map
-    pub const RESOURCE_LIST: ULONG = 8;
-    /// Resource list in the hardware description
-    pub const FULL_RESOURCE_DESCRIPTOR: ULONG = 9;
-    pub const RESOURCE_REQUIREMENTS_LIST: ULONG = 10;
-    /// 64-bit number
-    pub const QWORD: ULONG = 11;
-    /// 64-bit number (same as REG_QWORD)
-    pub const QWORD_LITTLE_ENDIAN: ULONG = 11;
+    pub const ValueType = enum(ULONG) {
+        /// No value type
+        NONE = 0,
+        /// Unicode nul terminated string
+        SZ = 1,
+        /// Unicode nul terminated string (with environment variable references)
+        EXPAND_SZ = 2,
+        /// Free form binary
+        BINARY = 3,
+        /// 32-bit number
+        DWORD = 4,
+        /// 32-bit number
+        DWORD_BIG_ENDIAN = 5,
+        /// Symbolic Link (unicode)
+        LINK = 6,
+        /// Multiple Unicode strings
+        MULTI_SZ = 7,
+        /// Resource list in the resource map
+        RESOURCE_LIST = 8,
+        /// Resource list in the hardware description
+        FULL_RESOURCE_DESCRIPTOR = 9,
+        RESOURCE_REQUIREMENTS_LIST = 10,
+        /// 64-bit number
+        QWORD = 11,
+        _,
+
+        /// 32-bit number (same as REG_DWORD)
+        pub const DWORD_LITTLE_ENDIAN: ValueType = .DWORD;
+        /// 64-bit number (same as REG_QWORD)
+        pub const QWORD_LITTLE_ENDIAN: ValueType = .QWORD;
+    };
+
+    /// Used with NtOpenKeyEx, maybe others
+    pub const OpenOptions = packed struct(ULONG) {
+        Reserved0: u2 = 0,
+        /// Open for backup or restore
+        /// special access rules privilege required
+        BACKUP_RESTORE: bool = false,
+        /// Open symbolic link
+        OPEN_LINK: bool = false,
+        Reserved3: u28 = 0,
+    };
+
+    /// Used with NtLoadKeyEx, maybe others
+    pub const LoadOptions = packed struct(ULONG) {
+        /// Restore whole hive volatile
+        WHOLE_HIVE_VOLATILE: bool = false,
+        /// Unwind changes to last flush
+        REFRESH_HIVE: bool = false,
+        /// Never lazy flush this hive
+        NO_LAZY_FLUSH: bool = false,
+        /// Force the restore process even when we have open handles on subkeys
+        FORCE_RESTORE: bool = false,
+        /// Loads the hive visible to the calling process
+        APP_HIVE: bool = false,
+        /// Hive cannot be mounted by any other process while in use
+        PROCESS_PRIVATE: bool = false,
+        /// Starts Hive Journal
+        START_JOURNAL: bool = false,
+        /// Grow hive file in exact 4k increments
+        HIVE_EXACT_FILE_GROWTH: bool = false,
+        /// No RM is started for this hive (no transactions)
+        HIVE_NO_RM: bool = false,
+        /// Legacy single logging is used for this hive
+        HIVE_SINGLE_LOG: bool = false,
+        /// This hive might be used by the OS loader
+        BOOT_HIVE: bool = false,
+        /// Load the hive and return a handle to its root kcb
+        LOAD_HIVE_OPEN_HANDLE: bool = false,
+        /// Flush changes to primary hive file size as part of all flushes
+        FLUSH_HIVE_FILE_GROWTH: bool = false,
+        /// Open a hive's files in read-only mode
+        /// The same flag is used for REG_APP_HIVE_OPEN_READ_ONLY:
+        /// Open an app hive's files in read-only mode (if the hive was not previously loaded).
+        OPEN_READ_ONLY: bool = false,
+        /// Load the hive, but don't allow any modification of it
+        IMMUTABLE: bool = false,
+        /// Do not fall back to impersonating the caller if hive file access fails
+        NO_IMPERSONATION_FALLBACK: bool = false,
+        Reserved16: u16 = 0,
+    };
+};
+
+pub const KEY = struct {
+    pub const VALUE = struct {
+        /// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_key_value_information_class
+        pub const INFORMATION_CLASS = enum(c_int) {
+            Basic = 0,
+            Full = 1,
+            Partial = 2,
+            FullAlign64 = 3,
+            PartialAlign64 = 4,
+            Layer = 5,
+            _,
+
+            pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".fields.len;
+        };
+
+        pub const PARTIAL_INFORMATION = extern struct {
+            TitleIndex: ULONG,
+            Type: REG.ValueType,
+            DataLength: ULONG,
+            Data: [0]UCHAR,
+
+            pub fn data(info: *const PARTIAL_INFORMATION) []const UCHAR {
+                const ptr: [*]const UCHAR = @ptrCast(&info.Data);
+                return ptr[0..info.DataLength];
+            }
+        };
+    };
 };
 
 pub const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 77799bc1b4d762d7ba67753ccc232d3a63d90ca8..e4f299e4e6930979f5518f34de158e5794422f8f 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -22,6 +22,7 @@ const HANDLE = windows.HANDLE;
 const HEAP = windows.HEAP;
 const IO_APC_ROUTINE = windows.IO_APC_ROUTINE;
 const IO_STATUS_BLOCK = windows.IO_STATUS_BLOCK;
+const KEY = windows.KEY;
 const KNONVOLATILE_CONTEXT_POINTERS = windows.KNONVOLATILE_CONTEXT_POINTERS;
 const LARGE_INTEGER = windows.LARGE_INTEGER;
 const LDR = windows.LDR;
@@ -37,6 +38,7 @@ const PCWSTR = windows.PCWSTR;
 const PROCESS = windows.PROCESS;
 const PVOID = windows.PVOID;
 const PWSTR = windows.PWSTR;
+const REG = windows.REG;
 const RTL_OSVERSIONINFOW = windows.RTL_OSVERSIONINFOW;
 const RTL_QUERY_REGISTRY_TABLE = windows.RTL_QUERY_REGISTRY_TABLE;
 const RUNTIME_FUNCTION = windows.RUNTIME_FUNCTION;
@@ -724,3 +726,36 @@ pub extern "ntdll" fn RtlWakeConditionVariable(
 pub extern "ntdll" fn RtlWakeAllConditionVariable(
     ConditionVariable: *CONDITION_VARIABLE,
 ) callconv(.winapi) void;
+
+pub extern "ntdll" fn NtOpenKeyEx(
+    KeyHandle: *HANDLE,
+    DesiredAccess: ACCESS_MASK,
+    ObjectAttributes: *const OBJECT.ATTRIBUTES,
+    OpenOptions: REG.OpenOptions,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn RtlOpenCurrentUser(
+    DesiredAccess: ACCESS_MASK,
+    CurrentUserKey: *HANDLE,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtQueryValueKey(
+    KeyHandle: HANDLE,
+    ValueName: *const UNICODE_STRING,
+    KeyValueInformationClass: KEY.VALUE.INFORMATION_CLASS,
+    KeyValueInformation: *anyopaque,
+    /// Length of KeyValueInformation buffer in bytes
+    Length: ULONG,
+    /// On STATUS_SUCCESS, contains the length of the populated portion of the
+    /// provided buffer. On STATUS_BUFFER_OVERFLOW or STATUS_BUFFER_TOO_SMALL,
+    /// contains the minimum `Length` value that would be required to hold the information.
+    ResultLength: *ULONG,
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtLoadKeyEx(
+    TargetKey: *const OBJECT.ATTRIBUTES,
+    SourceFile: *const OBJECT.ATTRIBUTES,
+    Flags: REG.LoadOptions,
+    TrustClassKey: ?HANDLE,
+    Event: ?HANDLE,
+    DesiredAccess: ACCESS_MASK,
+    RootHandle: ?*HANDLE,
+    Reserved: ?*anyopaque,
+) callconv(.winapi) NTSTATUS;
diff --git a/lib/std/zig/WindowsSdk.zig b/lib/std/zig/WindowsSdk.zig
index d6e7e35130c5da5f50405f06d1afd73005fcf358..b234cce55149715626d3ac4c2dd10540ce97df10 100644
--- a/lib/std/zig/WindowsSdk.zig
+++ b/lib/std/zig/WindowsSdk.zig
@@ -7,19 +7,20 @@ const Dir = std.Io.Dir;
 const Writer = std.Io.Writer;
 const Allocator = std.mem.Allocator;
 const Environ = std.process.Environ;
+const L = std.unicode.wtf8ToWtf16LeStringLiteral;
+const is_32_bit = @bitSizeOf(usize) == 32;
 
 windows10sdk: ?Installation,
 windows81sdk: ?Installation,
 msvc_lib_dir: ?[]const u8,
 
 const windows = std.os.windows;
-const RRF = windows.advapi32.RRF;
 
-const windows_kits_reg_key = "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots";
+const windows_kits_reg_key = "Microsoft\\Windows Kits\\Installed Roots";
 
 // https://learn.microsoft.com/en-us/windows/win32/msi/productversion
 const version_major_minor_max_length = "255.255".len;
-// note(bratishkaerik): i think ProductVersion in registry (created by Visual Studio installer) also follows this rule
+// ProductVersion in registry (created by Visual Studio installer) probably also follows this rule
 const product_version_max_length = version_major_minor_max_length + ".65535".len;
 
 /// Find path and version of Windows 10 SDK and Windows 8.1 SDK, and find path to MSVC's `lib/` directory.
@@ -33,13 +34,16 @@ pub fn find(
 ) error{ OutOfMemory, NotFound, PathTooLong }!WindowsSdk {
     if (builtin.os.tag != .windows) return error.NotFound;
 
-    //note(dimenus): If this key doesn't exist, neither the Win 8 SDK nor the Win 10 SDK is installed
-    const roots_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, windows_kits_reg_key, .{ .wow64_32 = true }) catch |err| switch (err) {
+    var registry: Registry = .{};
+    defer registry.deinit();
+
+    // If this key doesn't exist, neither the Win 8 SDK nor the Win 10 SDK is installed
+    const roots_key = registry.openSoftwareKey(.{ .root = .local_machine, .wow64 = .wow64_32 }, L(windows_kits_reg_key)) catch |err| switch (err) {
         error.KeyNotFound => return error.NotFound,
     };
-    defer roots_key.closeKey();
+    defer roots_key.close();
 
-    const windows10sdk = Installation.find(gpa, io, roots_key, "KitsRoot10", "", "v10.0") catch |err| switch (err) {
+    const windows10sdk = Installation.find(gpa, io, &registry, roots_key, L("KitsRoot10"), "", L("v10.0")) catch |err| switch (err) {
         error.InstallationNotFound => null,
         error.PathTooLong => null,
         error.VersionTooLong => null,
@@ -47,7 +51,7 @@ pub fn find(
     };
     errdefer if (windows10sdk) |*w| w.free(gpa);
 
-    const windows81sdk = Installation.find(gpa, io, roots_key, "KitsRoot81", "winver", "v8.1") catch |err| switch (err) {
+    const windows81sdk = Installation.find(gpa, io, &registry, roots_key, L("KitsRoot81"), "winver", L("v8.1")) catch |err| switch (err) {
         error.InstallationNotFound => null,
         error.PathTooLong => null,
         error.VersionTooLong => null,
@@ -55,7 +59,7 @@ pub fn find(
     };
     errdefer if (windows81sdk) |*w| w.free(gpa);
 
-    const msvc_lib_dir: ?[]const u8 = MsvcLibDir.find(gpa, io, arch, environ_map) catch |err| switch (err) {
+    const msvc_lib_dir: ?[]const u8 = MsvcLibDir.find(gpa, io, &registry, arch, environ_map) catch |err| switch (err) {
         error.MsvcLibDirNotFound => null,
         error.OutOfMemory => return error.OutOfMemory,
     };
@@ -149,274 +153,306 @@ fn iterateAndFilterByVersion(
     return dirs.toOwnedSlice();
 }
 
-const OpenOptions = struct {
-    /// Sets the KEY_WOW64_32KEY access flag.
-    /// https://learn.microsoft.com/en-us/windows/win32/winprog64/accessing-an-alternate-registry-view
-    wow64_32: bool = false,
-};
-
-const RegistryWtf8 = struct {
-    key: windows.HKEY,
-
-    /// Assert that `key` is valid WTF-8 string
-    pub fn openKey(hkey: windows.HKEY, key: []const u8, options: OpenOptions) error{KeyNotFound}!RegistryWtf8 {
-        const key_wtf16le: [:0]const u16 = key_wtf16le: {
-            var key_wtf16le_buf: [RegistryWtf16Le.key_name_max_len]u16 = undefined;
-            const key_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(key_wtf16le_buf[0..], key) catch |err| switch (err) {
-                error.InvalidWtf8 => unreachable,
-            };
-            key_wtf16le_buf[key_wtf16le_len] = 0;
-            break :key_wtf16le key_wtf16le_buf[0..key_wtf16le_len :0];
-        };
-
-        const registry_wtf16le = try RegistryWtf16Le.openKey(hkey, key_wtf16le, options);
-        return .{ .key = registry_wtf16le.key };
-    }
-
-    /// Closes key, after that usage is invalid
-    pub fn closeKey(reg: RegistryWtf8) void {
-        const return_code_int: windows.HRESULT = windows.advapi32.RegCloseKey(reg.key);
-        const return_code: windows.Win32Error = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => {},
-            else => {},
+/// Not a general purpose implementation of an ntdll-based Registry API.
+/// Only intended to support the particular calls necessary for the purposes of finding
+/// the SDK/MSVC installation paths.
+///
+/// The advapi32 APIs internally open and cache `\Registry\Machine` and the current user
+/// key when HKEY_LOCAL_MACHINE (HKLM) and HKEY_CURRENT_USER (HKCU) are passed, and also
+/// rewrite key path values to go through WOW6432Node when appropriate.
+///
+/// For example, when opening `Software\Foo` relative to `HKEY_LOCAL_MACHINE` with
+/// the WOW64_32KEY option set, that will end up as a call to NtLoadKeyEx with the path
+/// rewritten to `Software\WOW6432Node\Foo` relative to a cached `\REGISTRY\Machine`
+/// key.
+///
+/// For our purposes, we really only care about 4 potential variations of the `Software` key:
+/// - Relative to HKLM, no redirection through WOW6432Node
+/// - Relative to HKLM, redirected through WOW6432Node
+/// - Relative to HKCU, no redirection through WOW6432Node
+/// - Relative to HKCU, redirected through WOW6432Node
+/// (e.g. all the values we care about are within one of those `Software` keys)
+///
+/// So, we cache those variants of the Software keys instead of HKLM/HKCU and treat them
+/// as the "root" keys that the user can specify, which in turn (1) allows all provided key
+/// paths to be agnostic to WOW6432Node, (2) avoids the need for internal path rewriting,
+/// and (3) works correctly on 32-bit targets without any special support.
+///
+/// For example, instead of an advapi32 call with `Software\Foo` relative to
+/// `HKEY_LOCAL_MACHINE` which may get rewritten to `Software\WOW6432Node\Foo`,
+/// the equivalent is now a call to open `Foo` relative to some Software key variant.
+const Registry = struct {
+    cache: Cache = .{},
+
+    pub fn deinit(self: Registry) void {
+        if (!is_32_bit) {
+            if (self.cache.hklm_software_foreign) |key| windows.CloseHandle(key);
+            if (self.cache.hkcu_software_foreign) |key| windows.CloseHandle(key);
         }
+        if (self.cache.hklm_software_native) |key| windows.CloseHandle(key);
+        if (self.cache.hkcu_software_native) |key| windows.CloseHandle(key);
+        if (self.cache.hkcu) |key| windows.CloseHandle(key);
     }
 
-    /// Get string from registry.
-    /// Caller owns result.
-    pub fn getString(reg: RegistryWtf8, gpa: Allocator, subkey: []const u8, value_name: []const u8) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }![]u8 {
-        const subkey_wtf16le: [:0]const u16 = subkey_wtf16le: {
-            var subkey_wtf16le_buf: [RegistryWtf16Le.key_name_max_len]u16 = undefined;
-            const subkey_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(subkey_wtf16le_buf[0..], subkey) catch unreachable;
-            subkey_wtf16le_buf[subkey_wtf16le_len] = 0;
-            break :subkey_wtf16le subkey_wtf16le_buf[0..subkey_wtf16le_len :0];
-        };
-
-        const value_name_wtf16le: [:0]const u16 = value_name_wtf16le: {
-            var value_name_wtf16le_buf: [RegistryWtf16Le.value_name_max_len]u16 = undefined;
-            const value_name_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(value_name_wtf16le_buf[0..], value_name) catch unreachable;
-            value_name_wtf16le_buf[value_name_wtf16le_len] = 0;
-            break :value_name_wtf16le value_name_wtf16le_buf[0..value_name_wtf16le_len :0];
-        };
-
-        const registry_wtf16le: RegistryWtf16Le = .{ .key = reg.key };
-        const value_wtf16le = try registry_wtf16le.getString(gpa, subkey_wtf16le, value_name_wtf16le);
-        defer gpa.free(value_wtf16le);
-
-        const value_wtf8: []u8 = try std.unicode.wtf16LeToWtf8Alloc(gpa, value_wtf16le);
-        errdefer gpa.free(value_wtf8);
-
-        return value_wtf8;
-    }
-
-    /// Get DWORD (u32) from registry.
-    pub fn getDword(reg: RegistryWtf8, subkey: []const u8, value_name: []const u8) error{ ValueNameNotFound, NotADword, DwordTooLong, DwordNotFound }!u32 {
-        const subkey_wtf16le: [:0]const u16 = subkey_wtf16le: {
-            var subkey_wtf16le_buf: [RegistryWtf16Le.key_name_max_len]u16 = undefined;
-            const subkey_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(subkey_wtf16le_buf[0..], subkey) catch unreachable;
-            subkey_wtf16le_buf[subkey_wtf16le_len] = 0;
-            break :subkey_wtf16le subkey_wtf16le_buf[0..subkey_wtf16le_len :0];
-        };
-
-        const value_name_wtf16le: [:0]const u16 = value_name_wtf16le: {
-            var value_name_wtf16le_buf: [RegistryWtf16Le.value_name_max_len]u16 = undefined;
-            const value_name_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(value_name_wtf16le_buf[0..], value_name) catch unreachable;
-            value_name_wtf16le_buf[value_name_wtf16le_len] = 0;
-            break :value_name_wtf16le value_name_wtf16le_buf[0..value_name_wtf16le_len :0];
-        };
-
-        const registry_wtf16le: RegistryWtf16Le = .{ .key = reg.key };
-        return registry_wtf16le.getDword(subkey_wtf16le, value_name_wtf16le);
-    }
-
-    /// Under private space with flags:
-    /// KEY_QUERY_VALUE and KEY_ENUMERATE_SUB_KEYS.
-    /// After finishing work, call `closeKey`.
-    pub fn loadFromPath(absolute_path: []const u8) error{KeyNotFound}!RegistryWtf8 {
-        const absolute_path_wtf16le: [:0]const u16 = absolute_path_wtf16le: {
-            var absolute_path_wtf16le_buf: [RegistryWtf16Le.value_name_max_len]u16 = undefined;
-            const absolute_path_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(absolute_path_wtf16le_buf[0..], absolute_path) catch unreachable;
-            absolute_path_wtf16le_buf[absolute_path_wtf16le_len] = 0;
-            break :absolute_path_wtf16le absolute_path_wtf16le_buf[0..absolute_path_wtf16le_len :0];
+    const Cache = struct {
+        hklm_software_foreign: if (is_32_bit) void else ?windows.HANDLE = if (is_32_bit) {} else null,
+        hkcu_software_foreign: if (is_32_bit) void else ?windows.HANDLE = if (is_32_bit) {} else null,
+        hklm_software_native: ?windows.HANDLE = null,
+        hkcu_software_native: ?windows.HANDLE = null,
+        hkcu: ?windows.HANDLE = null,
+
+        fn getSoftware(cache: *const Cache, variant: Software) ?windows.HANDLE {
+            if (!is_32_bit and variant.wow64 == .wow64_32) {
+                return switch (variant.root) {
+                    .local_machine => cache.hklm_software_foreign,
+                    .current_user => cache.hkcu_software_foreign,
+                };
+            }
+            return switch (variant.root) {
+                .local_machine => cache.hklm_software_native,
+                .current_user => cache.hkcu_software_native,
+            };
+        }
+    };
+
+    // This does not correspond to HKEY_LOCAL_MACHINE/HKEY_CURRENT_USER
+    // since WOW64 redirection is applicable to e.g. `HKLM\Software` instead of
+    // HKLM/HKCU directly. Since we are only ever interested in the
+    // `Software` key, it makes more sense to treat `Software` as the "root"
+    // since that allows us to work entirely with relative paths that are agnostic
+    // to WOW6432Node redirection.
+    const Software = struct {
+        root: Root,
+        wow64: Wow64 = .native,
+
+        const Root = enum {
+            local_machine,
+            current_user,
         };
 
-        const registry_wtf16le = try RegistryWtf16Le.loadFromPath(absolute_path_wtf16le);
-        return .{ .key = registry_wtf16le.key };
-    }
-};
-
-const RegistryWtf16Le = struct {
-    key: windows.HKEY,
-
-    /// Includes root key (f.e. HKEY_LOCAL_MACHINE).
-    /// https://learn.microsoft.com/en-us/windows/win32/sysinfo/registry-element-size-limits
-    pub const key_name_max_len = 255;
-    /// In Unicode characters.
-    /// https://learn.microsoft.com/en-us/windows/win32/sysinfo/registry-element-size-limits
-    pub const value_name_max_len = 16_383;
-
-    /// Under HKEY_LOCAL_MACHINE with flags:
-    /// KEY_QUERY_VALUE, KEY_ENUMERATE_SUB_KEYS, optionally KEY_WOW64_32KEY.
-    /// After finishing work, call `closeKey`.
-    fn openKey(hkey: windows.HKEY, key_wtf16le: [:0]const u16, options: OpenOptions) error{KeyNotFound}!RegistryWtf16Le {
-        var key: windows.HKEY = undefined;
-        const return_code_int: windows.HRESULT = windows.advapi32.RegOpenKeyExW(
-            hkey,
-            key_wtf16le,
-            0,
-            .{ .SPECIFIC = .{ .KEY = .{
-                .QUERY_VALUE = true,
-                .ENUMERATE_SUB_KEYS = true,
-                .WOW64_32KEY = options.wow64_32,
-            } } },
-            &key,
-        );
-        const return_code: windows.Win32Error = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => {},
-            .FILE_NOT_FOUND => return error.KeyNotFound,
-
-            else => return error.KeyNotFound,
+        fn getOrOpenKey(self: Software, registry: *Registry) !Key {
+            if (registry.cache.getSoftware(self)) |handle| {
+                return .{ .handle = handle };
+            }
+
+            const is_foreign = !is_32_bit and self.wow64 == .wow64_32;
+            switch (self.root) {
+                .local_machine => {
+                    const path = if (is_foreign) L("\\Registry\\Machine\\Software\\WOW6432Node") else L("\\Registry\\Machine\\Software");
+                    var key: Key = undefined;
+                    const attr: windows.OBJECT.ATTRIBUTES = .{
+                        .RootDirectory = null,
+                        .Attributes = .{},
+                        .ObjectName = @constCast(&windows.UNICODE_STRING.init(path)),
+                        .SecurityDescriptor = null,
+                        .SecurityQualityOfService = null,
+                    };
+                    const status = windows.ntdll.NtOpenKeyEx(
+                        &key.handle,
+                        .{ .MAXIMUM_ALLOWED = true },
+                        &attr,
+                        .{},
+                    );
+                    switch (status) {
+                        .SUCCESS => {},
+                        else => return error.KeyNotFound,
+                    }
+                    if (is_foreign) {
+                        registry.cache.hklm_software_foreign = key.handle;
+                    } else {
+                        registry.cache.hklm_software_native = key.handle;
+                    }
+                    return key;
+                },
+                .current_user => {
+                    const cu_handle: windows.HANDLE = registry.cache.hkcu orelse hkcu: {
+                        var cu_handle: windows.HANDLE = undefined;
+                        const status = windows.ntdll.RtlOpenCurrentUser(
+                            .{ .MAXIMUM_ALLOWED = true },
+                            &cu_handle,
+                        );
+                        switch (status) {
+                            .SUCCESS => {},
+                            else => return error.KeyNotFound,
+                        }
+                        registry.cache.hkcu = cu_handle;
+                        break :hkcu cu_handle;
+                    };
+                    const cu_key: Registry.Key = .{ .handle = cu_handle };
+                    const path = if (is_foreign) L("Software\\WOW6432Node") else L("Software");
+                    const key = try cu_key.open(path);
+                    if (is_foreign) {
+                        registry.cache.hkcu_software_foreign = key.handle;
+                    } else {
+                        registry.cache.hkcu_software_native = key.handle;
+                    }
+                    return key;
+                },
+            }
         }
-        return .{ .key = key };
-    }
-
-    /// Closes key, after that usage is invalid
-    fn closeKey(reg: RegistryWtf16Le) void {
-        const return_code_int: windows.HRESULT = windows.advapi32.RegCloseKey(reg.key);
-        const return_code: windows.Win32Error = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => {},
-            else => {},
+    };
+
+    /// For 32-bit programs on a 64-bit operating system, the WOW64
+    /// version of ntdll.dll handles the WOW6432Node redirection before
+    /// calling into ntdll.dll proper, so no special handling is needed
+    /// and this setting is irrelevant in that case.
+    const Wow64 = enum {
+        /// Use 64-bit registry on 64-bit targets and 32-bit registry on
+        /// 32-bit targets.
+        native,
+        /// Go through WOW6432Node on both 32-bit and 64-bit targets,
+        /// if relevant (ignored for 32-bit programs executed on a 32-bit
+        /// OS).
+        wow64_32,
+    };
+
+    fn tryOpenSoftwareKeyWithPrecedence(registry: *Registry, variants: []const Software, sub_path: []const u16) error{KeyNotFound}!Key {
+        for (variants) |variant| {
+            return registry.openSoftwareKey(variant, sub_path) catch continue;
         }
+        return error.KeyNotFound;
     }
 
-    /// Get string ([:0]const u16) from registry.
-    fn getString(reg: RegistryWtf16Le, gpa: Allocator, subkey_wtf16le: [:0]const u16, value_name_wtf16le: [:0]const u16) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }![]const u16 {
-        var actual_type: windows.ULONG = undefined;
+    fn openSoftwareKey(registry: *Registry, software: Software, sub_path: []const u16) error{KeyNotFound}!Key {
+        const software_key = try software.getOrOpenKey(registry);
+        return software_key.open(sub_path);
+    }
 
-        // Calculating length to allocate
-        var value_wtf16le_buf_size: u32 = 0; // in bytes, including any terminating NUL character or characters.
-        var return_code_int: windows.HRESULT = windows.advapi32.RegGetValueW(
-            reg.key,
-            subkey_wtf16le,
-            value_name_wtf16le,
-            RRF.RT_REG_SZ,
-            &actual_type,
-            null,
-            &value_wtf16le_buf_size,
-        );
+    const Key = struct {
+        handle: windows.HANDLE,
 
-        // Check returned code and type
-        var return_code: windows.Win32Error = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => std.debug.assert(value_wtf16le_buf_size != 0),
-            .MORE_DATA => unreachable, // We are only reading length
-            .FILE_NOT_FOUND => return error.ValueNameNotFound,
-            .INVALID_PARAMETER => unreachable, // We didn't combine RRF.SUBKEY_WOW6464KEY and RRF.SUBKEY_WOW6432KEY
-            else => return error.StringNotFound,
-        }
-        switch (actual_type) {
-            windows.REG.SZ => {},
-            else => return error.NotAString,
+        fn close(self: Key) void {
+            windows.CloseHandle(self.handle);
         }
 
-        const value_wtf16le_buf: []u16 = try gpa.alloc(u16, std.math.divCeil(u32, value_wtf16le_buf_size, 2) catch unreachable);
-        errdefer gpa.free(value_wtf16le_buf);
-
-        return_code_int = windows.advapi32.RegGetValueW(
-            reg.key,
-            subkey_wtf16le,
-            value_name_wtf16le,
-            RRF.RT_REG_SZ,
-            &actual_type,
-            value_wtf16le_buf.ptr,
-            &value_wtf16le_buf_size,
-        );
-
-        // Check returned code and (just in case) type again.
-        return_code = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => {},
-            .MORE_DATA => unreachable, // Calculated first time length should be enough, even overestimated
-            .FILE_NOT_FOUND => return error.ValueNameNotFound,
-            .INVALID_PARAMETER => unreachable, // We didn't combine RRF.SUBKEY_WOW6464KEY and RRF.SUBKEY_WOW6432KEY
-            else => return error.StringNotFound,
-        }
-        switch (actual_type) {
-            windows.REG.SZ => {},
-            else => return error.NotAString,
+        fn open(self: Key, sub_path: []const u16) error{KeyNotFound}!Key {
+            var key: Key = undefined;
+            const attr: windows.OBJECT.ATTRIBUTES = .{
+                .RootDirectory = self.handle,
+                .Attributes = .{},
+                .ObjectName = @constCast(&windows.UNICODE_STRING.init(sub_path)),
+                .SecurityDescriptor = null,
+                .SecurityQualityOfService = null,
+            };
+            const status = windows.ntdll.NtOpenKeyEx(
+                &key.handle,
+                .{ .SPECIFIC = .{
+                    .KEY = .{
+                        .QUERY_VALUE = true,
+                        .ENUMERATE_SUB_KEYS = true,
+                    },
+                } },
+                &attr,
+                .{},
+            );
+            switch (status) {
+                .SUCCESS => return key,
+                else => return error.KeyNotFound,
+            }
         }
 
-        const value_wtf16le: []const u16 = value_wtf16le: {
-            // note(bratishkaerik): somehow returned value in `buf_len` is overestimated by Windows and contains extra space
-            // we will just search for zero termination and forget length
-            // Windows sure is strange
-            const value_wtf16le_overestimated: [*:0]const u16 = @ptrCast(value_wtf16le_buf.ptr);
-            break :value_wtf16le std.mem.span(value_wtf16le_overestimated);
+        const ValueEntry = union(enum) {
+            default: void,
+            name: []const u16,
         };
 
-        _ = gpa.resize(value_wtf16le_buf, value_wtf16le.len);
-        return value_wtf16le;
-    }
-
-    /// Get DWORD (u32) from registry.
-    fn getDword(reg: RegistryWtf16Le, subkey_wtf16le: [:0]const u16, value_name_wtf16le: [:0]const u16) error{ ValueNameNotFound, NotADword, DwordTooLong, DwordNotFound }!u32 {
-        var actual_type: windows.ULONG = undefined;
-        var reg_size: u32 = @sizeOf(u32);
-        var reg_value: u32 = 0;
+        fn getString(
+            key: Key,
+            gpa: Allocator,
+            entry: ValueEntry,
+            comptime result_encoding: enum { wtf16, wtf8 },
+        ) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }!(switch (result_encoding) {
+            .wtf8 => []u8,
+            .wtf16 => []u16,
+        }) {
+            const num_data_bytes = windows.MAX_PATH * 2;
+            const stack_buf_len = @sizeOf(windows.KEY.VALUE.PARTIAL_INFORMATION) + num_data_bytes;
+            var stack_info_buf: [stack_buf_len]u8 align(@alignOf(windows.KEY.VALUE.PARTIAL_INFORMATION)) = undefined;
+            var result_len: windows.ULONG = undefined;
+            const rc = windows.ntdll.NtQueryValueKey(
+                key.handle,
+                switch (entry) {
+                    .name => |name| @constCast(&windows.UNICODE_STRING.init(name)),
+                    .default => @constCast(&windows.UNICODE_STRING.empty),
+                },
+                .Partial,
+                &stack_info_buf,
+                stack_buf_len,
+                &result_len,
+            );
+            var heap_info_buf: ?[]align(@alignOf(windows.KEY.VALUE.PARTIAL_INFORMATION)) u8 = null;
+            defer if (heap_info_buf) |buf| gpa.free(buf);
+
+            const info: *const windows.KEY.VALUE.PARTIAL_INFORMATION = switch (rc) {
+                .SUCCESS => @ptrCast(&stack_info_buf),
+                .BUFFER_OVERFLOW, .BUFFER_TOO_SMALL => heap_info: {
+                    heap_info_buf = try gpa.alignedAlloc(u8, .of(windows.KEY.VALUE.PARTIAL_INFORMATION), result_len);
+                    const heap_rc = windows.ntdll.NtQueryValueKey(
+                        key.handle,
+                        switch (entry) {
+                            .name => |name| @constCast(&windows.UNICODE_STRING.init(name)),
+                            .default => @constCast(&windows.UNICODE_STRING.empty),
+                        },
+                        .Partial,
+                        heap_info_buf.?.ptr,
+                        @intCast(heap_info_buf.?.len),
+                        &result_len,
+                    );
+                    switch (heap_rc) {
+                        .SUCCESS => break :heap_info @ptrCast(heap_info_buf.?.ptr),
+                        .OBJECT_NAME_NOT_FOUND => return error.ValueNameNotFound,
+                        else => return error.StringNotFound,
+                    }
+                },
+                .OBJECT_NAME_NOT_FOUND => return error.ValueNameNotFound,
+                else => return error.StringNotFound,
+            };
 
-        const return_code_int: windows.HRESULT = windows.advapi32.RegGetValueW(
-            reg.key,
-            subkey_wtf16le,
-            value_name_wtf16le,
-            RRF.RT_REG_DWORD,
-            &actual_type,
-            &reg_value,
-            &reg_size,
-        );
-        const return_code: windows.Win32Error = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => {},
-            .MORE_DATA => return error.DwordTooLong,
-            .FILE_NOT_FOUND => return error.ValueNameNotFound,
-            .INVALID_PARAMETER => unreachable, // We didn't combine RRF.SUBKEY_WOW6464KEY and RRF.SUBKEY_WOW6432KEY
-            else => return error.DwordNotFound,
+            switch (info.Type) {
+                .SZ => {},
+                else => return error.NotAString,
+            }
+
+            const data_wtf16_with_nul = @as([*]const u16, @ptrCast(@alignCast(info.data())))[0..@divExact(info.DataLength, 2)];
+            const data_wtf16 = std.mem.trimEnd(u16, data_wtf16_with_nul, L("\x00"));
+            switch (result_encoding) {
+                .wtf16 => return gpa.dupe(u16, data_wtf16),
+                .wtf8 => return std.unicode.wtf16LeToWtf8Alloc(gpa, data_wtf16),
+            }
         }
 
-        switch (actual_type) {
-            windows.REG.DWORD => {},
-            else => return error.NotADword,
+        fn getDword(key: Key, entry: ValueEntry) error{ ValueNameNotFound, NotADword, DwordNotFound }!windows.DWORD {
+            const num_data_bytes = @sizeOf(windows.DWORD);
+            const buf_len = @sizeOf(windows.KEY.VALUE.PARTIAL_INFORMATION) + num_data_bytes;
+            var info_buf: [buf_len]u8 align(@alignOf(windows.KEY.VALUE.PARTIAL_INFORMATION)) = undefined;
+            var result_len: windows.ULONG = undefined;
+            const rc = windows.ntdll.NtQueryValueKey(
+                key.handle,
+                switch (entry) {
+                    .name => |name| @constCast(&windows.UNICODE_STRING.init(name)),
+                    .default => @constCast(&windows.UNICODE_STRING.empty),
+                },
+                .Partial,
+                &info_buf,
+                buf_len,
+                &result_len,
+            );
+            switch (rc) {
+                .SUCCESS => {},
+                .OBJECT_NAME_NOT_FOUND => return error.ValueNameNotFound,
+                else => return error.DwordNotFound,
+            }
+
+            const info: *const windows.KEY.VALUE.PARTIAL_INFORMATION = @ptrCast(&info_buf);
+
+            switch (info.Type) {
+                .DWORD => {},
+                else => return error.NotADword,
+            }
+
+            return std.mem.bytesToValue(windows.DWORD, info.data());
         }
-
-        return reg_value;
-    }
-
-    /// Under private space with flags:
-    /// KEY_QUERY_VALUE and KEY_ENUMERATE_SUB_KEYS.
-    /// After finishing work, call `closeKey`.
-    fn loadFromPath(absolute_path_as_wtf16le: [:0]const u16) error{KeyNotFound}!RegistryWtf16Le {
-        var key: windows.HKEY = undefined;
-
-        const return_code_int: windows.HRESULT = std.os.windows.advapi32.RegLoadAppKeyW(
-            absolute_path_as_wtf16le,
-            &key,
-            .{ .SPECIFIC = .{ .KEY = .{
-                .QUERY_VALUE = true,
-                .ENUMERATE_SUB_KEYS = true,
-            } } },
-            0,
-            0,
-        );
-        const return_code: windows.Win32Error = @enumFromInt(return_code_int);
-        switch (return_code) {
-            .SUCCESS => {},
-            else => return error.KeyNotFound,
-        }
-
-        return .{ .key = key };
-    }
+    };
 };
 
 pub const Installation = struct {
@@ -428,20 +464,21 @@ pub const Installation = struct {
     fn find(
         gpa: Allocator,
         io: Io,
-        roots_key: RegistryWtf8,
-        roots_subkey: []const u8,
+        registry: *Registry,
+        roots_key: Registry.Key,
+        roots_subkey: []const u16,
         prefix: []const u8,
-        version_key_name: []const u8,
+        version_key_name: []const u16,
     ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation {
         roots: {
             const installation = findFromRoot(gpa, io, roots_key, roots_subkey, prefix) catch
                 break :roots;
-            if (installation.isValidVersion()) return installation;
+            if (installation.isValidVersion(roots_key)) return installation;
             installation.free(gpa);
         }
         {
-            const installation = try findFromInstallationFolder(gpa, version_key_name);
-            if (installation.isValidVersion()) return installation;
+            const installation = try findFromInstallationFolder(gpa, registry, version_key_name);
+            if (installation.isValidVersion(roots_key)) return installation;
             installation.free(gpa);
         }
         return error.InstallationNotFound;
@@ -450,29 +487,27 @@ pub const Installation = struct {
     fn findFromRoot(
         gpa: Allocator,
         io: Io,
-        roots_key: RegistryWtf8,
-        roots_subkey: []const u8,
+        roots_key: Registry.Key,
+        roots_subkey: []const u16,
         prefix: []const u8,
     ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation {
         const path = path: {
-            const path_maybe_with_trailing_slash = roots_key.getString(gpa, "", roots_subkey) catch |err| switch (err) {
-                error.NotAString => return error.InstallationNotFound,
-                error.ValueNameNotFound => return error.InstallationNotFound,
-                error.StringNotFound => return error.InstallationNotFound,
+            const path_w_maybe_with_trailing_slash = roots_key.getString(gpa, .{ .name = roots_subkey }, .wtf16) catch |err| switch (err) {
+                error.NotAString,
+                error.ValueNameNotFound,
+                error.StringNotFound,
+                => return error.InstallationNotFound,
 
                 error.OutOfMemory => return error.OutOfMemory,
             };
-            if (path_maybe_with_trailing_slash.len > Dir.max_path_bytes or !Dir.path.isAbsolute(path_maybe_with_trailing_slash)) {
-                gpa.free(path_maybe_with_trailing_slash);
-                return error.PathTooLong;
+            defer gpa.free(path_w_maybe_with_trailing_slash);
+
+            if (!std.fs.path.isAbsoluteWindowsWtf16(path_w_maybe_with_trailing_slash)) {
+                return error.InstallationNotFound;
             }
 
-            var path = std.array_list.Managed(u8).fromOwnedSlice(gpa, path_maybe_with_trailing_slash);
-            errdefer path.deinit();
-
-            // String might contain trailing slash, so trim it here
-            if (path.items.len > "C:\\".len and path.getLast() == '\\') _ = path.pop();
-            break :path try path.toOwnedSlice();
+            const path_w = std.mem.trimEnd(u16, path_w_maybe_with_trailing_slash, L("\\/"));
+            break :path try std.unicode.wtf16LeToWtf8Alloc(gpa, path_w);
         };
         errdefer gpa.free(path);
 
@@ -508,70 +543,71 @@ pub const Installation = struct {
 
     fn findFromInstallationFolder(
         gpa: Allocator,
-        version_key_name: []const u8,
+        registry: *Registry,
+        version_key_name: []const u16,
     ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation {
-        var key_name_buf: [RegistryWtf16Le.key_name_max_len]u8 = undefined;
-        const key_name = std.fmt.bufPrint(
-            &key_name_buf,
-            "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\{s}",
-            .{version_key_name},
-        ) catch unreachable;
-        const key = key: for ([_]bool{ true, false }) |wow6432node| {
-            for ([_]windows.HKEY{ windows.HKEY_LOCAL_MACHINE, windows.HKEY_CURRENT_USER }) |hkey| {
-                break :key RegistryWtf8.openKey(hkey, key_name, .{ .wow64_32 = wow6432node }) catch |err| switch (err) {
-                    error.KeyNotFound => return error.InstallationNotFound,
-                };
-            }
-        } else return error.InstallationNotFound;
-        defer key.closeKey();
+        const key_name = try std.mem.concat(gpa, u16, &.{ L("Microsoft\\Microsoft SDKs\\Windows\\"), version_key_name });
+        defer gpa.free(key_name);
+
+        const key = registry.tryOpenSoftwareKeyWithPrecedence(switch (is_32_bit) {
+            true => &.{
+                .{ .root = .local_machine },
+                .{ .root = .current_user },
+            },
+            false => &.{
+                .{ .root = .local_machine, .wow64 = .wow64_32 },
+                .{ .root = .current_user, .wow64 = .wow64_32 },
+                .{ .root = .local_machine, .wow64 = .native },
+                .{ .root = .current_user, .wow64 = .native },
+            },
+        }, key_name) catch {
+            return error.InstallationNotFound;
+        };
+        defer key.close();
 
         const path: []const u8 = path: {
-            const path_maybe_with_trailing_slash = key.getString(gpa, "", "InstallationFolder") catch |err| switch (err) {
-                error.NotAString => return error.InstallationNotFound,
-                error.ValueNameNotFound => return error.InstallationNotFound,
-                error.StringNotFound => return error.InstallationNotFound,
+            const path_w_maybe_with_trailing_slash = key.getString(gpa, .{ .name = L("InstallationFolder") }, .wtf16) catch |err| switch (err) {
+                error.NotAString,
+                error.ValueNameNotFound,
+                error.StringNotFound,
+                => return error.InstallationNotFound,
 
                 error.OutOfMemory => return error.OutOfMemory,
             };
+            defer gpa.free(path_w_maybe_with_trailing_slash);
 
-            if (path_maybe_with_trailing_slash.len > Dir.max_path_bytes or !Dir.path.isAbsolute(path_maybe_with_trailing_slash)) {
-                gpa.free(path_maybe_with_trailing_slash);
-                return error.PathTooLong;
+            if (!std.fs.path.isAbsoluteWindowsWtf16(path_w_maybe_with_trailing_slash)) {
+                return error.InstallationNotFound;
             }
 
-            var path = std.array_list.Managed(u8).fromOwnedSlice(gpa, path_maybe_with_trailing_slash);
-            errdefer path.deinit();
-
-            // String might contain trailing slash, so trim it here
-            if (path.items.len > "C:\\".len and path.getLast() == '\\') _ = path.pop();
-
-            const path_without_trailing_slash = try path.toOwnedSlice();
-            break :path path_without_trailing_slash;
+            const path_w = std.mem.trimEnd(u16, path_w_maybe_with_trailing_slash, L("\\/"));
+            break :path try std.unicode.wtf16LeToWtf8Alloc(gpa, path_w);
         };
         errdefer gpa.free(path);
 
         const version: []const u8 = version: {
-
-            // note(dimenus): Microsoft doesn't include the .0 in the ProductVersion key....
-            const version_without_0 = key.getString(gpa, "", "ProductVersion") catch |err| switch (err) {
-                error.NotAString => return error.InstallationNotFound,
-                error.ValueNameNotFound => return error.InstallationNotFound,
-                error.StringNotFound => return error.InstallationNotFound,
+            // Microsoft doesn't include the .0 in the ProductVersion key
+            const version_without_0 = key.getString(gpa, .{ .name = L("ProductVersion") }, .wtf16) catch |err| switch (err) {
+                error.NotAString,
+                error.ValueNameNotFound,
+                error.StringNotFound,
+                => return error.InstallationNotFound,
 
                 error.OutOfMemory => return error.OutOfMemory,
             };
+            defer gpa.free(version_without_0);
+
             if (version_without_0.len + ".0".len > product_version_max_length) {
-                gpa.free(version_without_0);
                 return error.VersionTooLong;
             }
 
-            var version = std.array_list.Managed(u8).fromOwnedSlice(gpa, version_without_0);
+            var version: std.array_list.Managed(u8) = try .initCapacity(gpa, version_without_0.len + 2);
             errdefer version.deinit();
 
+            try std.unicode.wtf16LeToWtf8ArrayList(&version, version_without_0);
             try version.appendSlice(".0");
 
-            const version_with_0 = try version.toOwnedSlice();
-            break :version version_with_0;
+            break :version try version.toOwnedSlice();
         };
         errdefer gpa.free(version);
 
@@ -579,23 +615,22 @@ pub const Installation = struct {
     }
 
     /// Check whether this version is enumerated in registry.
-    fn isValidVersion(installation: Installation) bool {
-        var buf: [Dir.max_path_bytes]u8 = undefined;
-        const reg_query_as_wtf8 = std.fmt.bufPrint(buf[0..], "{s}\\{s}\\Installed Options", .{
-            windows_kits_reg_key,
-            installation.version,
-        }) catch |err| switch (err) {
-            error.NoSpaceLeft => return false,
-        };
+    fn isValidVersion(installation: Installation, roots_key: Registry.Key) bool {
+        var version_buf: [product_version_max_length]u16 = undefined;
+        const version_len = std.unicode.wtf8ToWtf16Le(&version_buf, installation.version) catch return false;
+        const version = version_buf[0..version_len];
+        const options_key_name = "Installed Options";
+        const buf_len = product_version_max_length + options_key_name.len + 2;
+        var buf: [buf_len]u16 = undefined;
+        var query: std.ArrayList(u16) = .initBuffer(&buf);
+        query.appendSliceAssumeCapacity(version);
+        query.appendAssumeCapacity('\\');
+        query.appendSliceAssumeCapacity(L(options_key_name));
 
-        const options_key = RegistryWtf8.openKey(
-            windows.HKEY_LOCAL_MACHINE,
-            reg_query_as_wtf8,
-            .{ .wow64_32 = true },
-        ) catch |err| switch (err) {
+        const options_key = roots_key.open(query.items) catch |err| switch (err) {
             error.KeyNotFound => return false,
         };
-        defer options_key.closeKey();
+        defer options_key.close();
 
         const option_name = comptime switch (builtin.target.cpu.arch) {
             .thumb => "OptionId.DesktopCPParm",
@@ -605,7 +640,7 @@ pub const Installation = struct {
             else => |tag| @compileError("Windows SDK cannot be detected on architecture " ++ tag),
         };
 
-        const reg_value = options_key.getDword("", option_name) catch return false;
+        const reg_value = options_key.getDword(.{ .name = L(option_name) }) catch return false;
         return (reg_value == 1);
     }
 
@@ -616,14 +651,14 @@ pub const Installation = struct {
 };
 
 const MsvcLibDir = struct {
-    fn findInstancesDirViaSetup(gpa: Allocator, io: Io) error{ OutOfMemory, PathNotFound }!Dir {
-        const vs_setup_key_path = "SOFTWARE\\Microsoft\\VisualStudio\\Setup";
-        const vs_setup_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, vs_setup_key_path, .{}) catch |err| switch (err) {
+    fn findInstancesDirViaSetup(gpa: Allocator, io: Io, registry: *Registry) error{ OutOfMemory, PathNotFound }!Dir {
+        const vs_setup_key_path = L("Microsoft\\VisualStudio\\Setup");
+        const vs_setup_key = registry.openSoftwareKey(.{ .root = .local_machine }, vs_setup_key_path) catch |err| switch (err) {
             error.KeyNotFound => return error.PathNotFound,
         };
-        defer vs_setup_key.closeKey();
+        defer vs_setup_key.close();
 
-        const packages_path = vs_setup_key.getString(gpa, "", "CachePath") catch |err| switch (err) {
+        const packages_path = vs_setup_key.getString(gpa, .{ .name = L("CachePath") }, .wtf8) catch |err| switch (err) {
             error.NotAString,
             error.ValueNameNotFound,
             error.StringNotFound,
@@ -633,22 +668,41 @@ const MsvcLibDir = struct {
         };
         defer gpa.free(packages_path);
 
-        if (!Dir.path.isAbsolute(packages_path)) return error.PathNotFound;
+        if (!std.fs.path.isAbsolute(packages_path)) return error.PathNotFound;
 
-        const instances_path = try Dir.path.join(gpa, &.{ packages_path, "_Instances" });
+        const instances_path = try std.fs.path.join(gpa, &.{ packages_path, "_Instances" });
         defer gpa.free(instances_path);
 
         return Dir.openDirAbsolute(io, instances_path, .{ .iterate = true }) catch return error.PathNotFound;
     }
 
-    fn findInstancesDirViaCLSID(gpa: Allocator, io: Io) error{ OutOfMemory, PathNotFound }!Dir {
+    fn findInstancesDirViaCLSID(gpa: Allocator, io: Io, registry: *Registry) error{ OutOfMemory, PathNotFound }!Dir {
         const setup_configuration_clsid = "{177f0c4a-1cd3-4de7-a32c-71dbbb9fa36d}";
-        const setup_config_key = RegistryWtf8.openKey(windows.HKEY_CLASSES_ROOT, "CLSID\\" ++ setup_configuration_clsid, .{}) catch |err| switch (err) {
+
+        // HKEY_CLASSES_ROOT is not a single key but instead a combination of
+        // HKCU\Software\Classes and HKLM\Software\Classes with HKCU taking precedent
+        // https://learn.microsoft.com/en-us/windows/win32/sysinfo/hkey-classes-root-key
+        //
+        // Instead of a CLASSES_ROOT abstraction, we emulate the behavior with a more
+        // general abstraction, which also means we need to include `Classes` in the path since
+        // we're starting from the `Software` keys instead of the "classes root".
+        //
+        // The advapi32 APIs with `HKEY_CLASSES_ROOT` go through `\REGISTRY\USER\<SID>_Classes`
+        // instead of `\REGISTRY\USER\<SID>\Software\Classes`, but we go through the latter
+        // because it allows us to take advantage of `RtlOpenCurrentUser` to avoid needing to implement
+        // the logic for getting the current user registry path, and it appears that the two keys are
+        // effectively equivalent. Further investigation of the relationship of these keys would probably
+        // be beneficial, though.
+        const setup_config_key = registry.tryOpenSoftwareKeyWithPrecedence(&.{
+            .{ .root = .current_user },
+            .{ .root = .local_machine },
+        }, L("Classes\\CLSID\\" ++ setup_configuration_clsid)) catch |err| switch (err) {
             error.KeyNotFound => return error.PathNotFound,
         };
-        defer setup_config_key.closeKey();
+        defer setup_config_key.close();
 
-        const dll_path = setup_config_key.getString(gpa, "InprocServer32", "") catch |err| switch (err) {
+        const inproc_server = setup_config_key.open(L("InprocServer32")) catch return error.PathNotFound;
+        const dll_path = inproc_server.getString(gpa, .default, .wtf8) catch |err| switch (err) {
             error.NotAString,
             error.ValueNameNotFound,
             error.StringNotFound,
@@ -658,9 +712,9 @@ const MsvcLibDir = struct {
         };
         defer gpa.free(dll_path);
 
-        if (!Dir.path.isAbsolute(dll_path)) return error.PathNotFound;
+        if (!std.fs.path.isAbsolute(dll_path)) return error.PathNotFound;
 
-        var path_it = Dir.path.componentIterator(dll_path);
+        var path_it = std.fs.path.componentIterator(dll_path);
         // the .dll filename
         _ = path_it.last();
         const root_path = while (path_it.previous()) |dir_component| {
@@ -671,7 +725,7 @@ const MsvcLibDir = struct {
             return error.PathNotFound;
         };
 
-        const instances_path = try Dir.path.join(gpa, &.{ root_path, "Packages", "_Instances" });
+        const instances_path = try std.fs.path.join(gpa, &.{ root_path, "Packages", "_Instances" });
         defer gpa.free(instances_path);
 
         return Dir.openDirAbsolute(io, instances_path, .{ .iterate = true }) catch return error.PathNotFound;
@@ -680,12 +734,13 @@ const MsvcLibDir = struct {
     fn findInstancesDir(
         gpa: Allocator,
         io: Io,
+        registry: *Registry,
         environ_map: *const Environ.Map,
     ) error{ OutOfMemory, PathNotFound }!Dir {
         // First, try getting the packages cache path from the registry.
         // This only seems to exist when the path is different from the default.
         method1: {
-            return findInstancesDirViaSetup(gpa, io) catch |err| switch (err) {
+            return findInstancesDirViaSetup(gpa, io, registry) catch |err| switch (err) {
                 error.OutOfMemory => |e| return e,
                 error.PathNotFound => break :method1,
             };
@@ -693,7 +748,7 @@ const MsvcLibDir = struct {
         // Otherwise, try to get the path from the .dll that would have been
         // loaded via COM for SetupConfiguration.
         method2: {
-            return findInstancesDirViaCLSID(gpa, io) catch |err| switch (err) {
+            return findInstancesDirViaCLSID(gpa, io, registry) catch |err| switch (err) {
                 error.OutOfMemory => |e| return e,
                 error.PathNotFound => break :method2,
             };
@@ -703,7 +758,7 @@ const MsvcLibDir = struct {
         method3: {
             const program_data = std.zig.EnvVar.PROGRAMDATA.get(environ_map) orelse break :method3;
 
-            if (!Dir.path.isAbsolute(program_data)) break :method3;
+            if (!std.fs.path.isAbsolute(program_data)) break :method3;
 
             const instances_path = try Dir.path.join(gpa, &.{
                 program_data, "Microsoft", "VisualStudio", "Packages", "_Instances",
@@ -764,6 +819,7 @@ const MsvcLibDir = struct {
     fn findViaCOM(
         gpa: Allocator,
         io: Io,
+        registry: *Registry,
         arch: std.Target.Cpu.Arch,
         environ_map: *const Environ.Map,
     ) error{ OutOfMemory, PathNotFound }![]const u8 {
@@ -771,7 +827,7 @@ const MsvcLibDir = struct {
         // This will contain directories with names of instance IDs like 80a758ca,
         // which will contain `state.json` files that have the version and
         // installation directory.
-        var instances_dir = try findInstancesDir(gpa, io, environ_map);
+        var instances_dir = try findInstancesDir(gpa, io, registry, environ_map);
         defer instances_dir.close(io);
 
         var state_subpath_buf: [Dir.max_name_bytes + 32]u8 = undefined;
@@ -874,7 +930,6 @@ const MsvcLibDir = struct {
         arch: std.Target.Cpu.Arch,
         environ_map: *const Environ.Map,
     ) error{ OutOfMemory, PathNotFound }![]const u8 {
-
         // %localappdata%\Microsoft\VisualStudio\
         // %appdata%\Local\Microsoft\VisualStudio\
         const local_app_data_path = std.zig.EnvVar.LOCALAPPDATA.get(environ_map) orelse return error.PathNotFound;
@@ -883,15 +938,18 @@ const MsvcLibDir = struct {
         });
         defer gpa.free(visualstudio_folder_path);
 
+        if (!Dir.path.isAbsolute(visualstudio_folder_path)) return error.PathNotFound;
+        // To make things easier later on, we open the VisualStudio directory here which
+        // allows us to pass relative paths to NtLoadKeyEx in order to avoid dealing with
+        // conversion to NT namespace paths.
+        var visualstudio_folder = Dir.openDirAbsolute(io, visualstudio_folder_path, .{
+            .iterate = true,
+        }) catch return error.PathNotFound;
+        defer visualstudio_folder.close(io);
+
         const vs_versions: []const []const u8 = vs_versions: {
-            if (!Dir.path.isAbsolute(visualstudio_folder_path)) return error.PathNotFound;
             // enumerate folders that contain `privateregistry.bin`, looking for all versions
             // f.i. %localappdata%\Microsoft\VisualStudio\17.0_9e9cbb98\
-            var visualstudio_folder = Dir.openDirAbsolute(io, visualstudio_folder_path, .{
-                .iterate = true,
-            }) catch return error.PathNotFound;
-            defer visualstudio_folder.close(io);
-
             var iterator = visualstudio_folder.iterate();
             break :vs_versions try iterateAndFilterByVersion(&iterator, gpa, io, "");
         };
@@ -899,25 +957,94 @@ const MsvcLibDir = struct {
             for (vs_versions) |vs_version| gpa.free(vs_version);
             gpa.free(vs_versions);
         }
-        var config_subkey_buf: [RegistryWtf16Le.key_name_max_len * 2]u8 = undefined;
+        var key_path_buf: [windows.NAME_MAX * 2]u16 = undefined;
+        var sub_path_buf: [windows.NAME_MAX * 2]u16 = undefined;
         const source_directories: []const u8 = source_directories: for (vs_versions) |vs_version| {
-            const privateregistry_absolute_path = Dir.path.join(gpa, &.{ visualstudio_folder_path, vs_version, "privateregistry.bin" }) catch continue;
-            defer gpa.free(privateregistry_absolute_path);
-            if (!Dir.path.isAbsolute(privateregistry_absolute_path)) continue;
+            const sub_path = blk: {
+                var buf: std.ArrayList(u16) = .initBuffer(&sub_path_buf);
+                buf.items.len += std.unicode.wtf8ToWtf16Le(buf.unusedCapacitySlice(), vs_version) catch unreachable;
+                buf.appendSliceAssumeCapacity(L("\\privateregistry.bin"));
+                break :blk buf.items;
+            };
 
-            const visualstudio_registry = RegistryWtf8.loadFromPath(privateregistry_absolute_path) catch continue;
-            defer visualstudio_registry.closeKey();
+            // The goal is to emulate advapi32.RegLoadAppKeyW with a direct call
+            // to NtLoadKeyEx instead.
+            //
+            // RegLoadAppKeyW loads the hive into a registry key of the format:
+            // \REGISTRY\A\{fdb2baa5-8ca8-ef03-78d0-3b1f868fd2a9}
+            // where `\REGISTRY\A` is a special unenumerable location intended for
+            // per-app hives, and the GUID is randomly generated (in testing, it
+            // was different for each run of the program).
+            //
+            // The OS is responsible for cleaning up `\REGISTRY\A` whenever all handles
+            // to one of its keys are closed, so we don't have to do anything special
+            // with regards to that.
 
-            const config_subkey = std.fmt.bufPrint(config_subkey_buf[0..], "Software\\Microsoft\\VisualStudio\\{s}_Config", .{vs_version}) catch unreachable;
+            const temp_key_path = blk: {
+                var guid: windows.GUID = undefined;
+                io.random(std.mem.asBytes(&guid));
 
-            const source_directories_value = visualstudio_registry.getString(gpa, config_subkey, "Source Directories") catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                var guid_buf: [38]u8 = undefined;
+                const guid_str = std.fmt.bufPrint(&guid_buf, "{f}", .{guid}) catch unreachable;
+
+                var buf: std.ArrayList(u16) = .initBuffer(&key_path_buf);
+                buf.appendSliceAssumeCapacity(L("\\REGISTRY\\A\\"));
+                buf.items.len += std.unicode.wtf8ToWtf16Le(buf.unusedCapacitySlice(), guid_str) catch unreachable;
+                break :blk buf.items;
+            };
+
+            const target_key: windows.OBJECT.ATTRIBUTES = .{
+                .RootDirectory = null,
+                .Attributes = .{},
+                .ObjectName = @constCast(&windows.UNICODE_STRING.init(temp_key_path)),
+                .SecurityDescriptor = null,
+            };
+            const source_file: windows.OBJECT.ATTRIBUTES = .{
+                .RootDirectory = visualstudio_folder.handle,
+                .Attributes = .{},
+                .ObjectName = @constCast(&windows.UNICODE_STRING.init(sub_path)),
+                .SecurityDescriptor = null,
+            };
+            var root_key: Registry.Key = undefined;
+            const rc = windows.ntdll.NtLoadKeyEx(
+                &target_key,
+                &source_file,
+                .{
+                    .APP_HIVE = true,
+                    // This wasn't set by RegLoadAppKeyW, but it seems relevant
+                    // since we aren't intending to do any modifcation of the hive.
+                    .OPEN_READ_ONLY = true,
+                },
+                null,
+                null,
+                .{ .SPECIFIC = .{
+                    .KEY = .{
+                        .QUERY_VALUE = true,
+                        .ENUMERATE_SUB_KEYS = true,
+                    },
+                } },
+                &root_key.handle,
+                null,
+            );
+            switch (rc) {
+                .SUCCESS => {},
                 else => continue,
-            };
-            if (source_directories_value.len > (Dir.max_path_bytes * 30)) { // note(bratishkaerik): guessing from the fact that on my computer it has 15 paths and at least some of them are not of max length
-                gpa.free(source_directories_value);
-                continue;
             }
+            defer root_key.close();
+
+            const config_path = blk: {
+                var buf: std.ArrayList(u16) = .initBuffer(&key_path_buf);
+                buf.appendSliceAssumeCapacity(L("Software\\Microsoft\\VisualStudio\\"));
+                buf.items.len += std.unicode.wtf8ToWtf16Le(buf.unusedCapacitySlice(), vs_version) catch unreachable;
+                buf.appendSliceAssumeCapacity(L("_Config"));
+                break :blk buf.items;
+            };
+            const config_key = root_key.open(config_path) catch continue;
+
+            const source_directories_value = config_key.getString(gpa, .{ .name = L("Source Directories") }, .wtf8) catch |err| switch (err) {
+                error.OutOfMemory => return error.OutOfMemory,
+                else => continue,
+            };
 
             break :source_directories source_directories_value;
         } else return error.PathNotFound;
@@ -967,6 +1094,7 @@ const MsvcLibDir = struct {
     fn findViaVs7Key(
         gpa: Allocator,
         io: Io,
+        registry: *Registry,
         arch: std.Target.Cpu.Arch,
         environ_map: *const Environ.Map,
     ) error{ OutOfMemory, PathNotFound }![]const u8 {
@@ -986,10 +1114,10 @@ const MsvcLibDir = struct {
                 }
             }
 
-            const vs7_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7", .{ .wow64_32 = true }) catch return error.PathNotFound;
-            defer vs7_key.closeKey();
+            const vs7_key = registry.openSoftwareKey(.{ .root = .local_machine, .wow64 = .wow64_32 }, L("Microsoft\\VisualStudio\\SxS\\VS7")) catch return error.PathNotFound;
+            defer vs7_key.close();
             try_vs7_key: {
-                const path_maybe_with_trailing_slash = vs7_key.getString(gpa, "", "14.0") catch |err| switch (err) {
+                const path_maybe_with_trailing_slash = vs7_key.getString(gpa, .{ .name = L("14.0") }, .wtf8) catch |err| switch (err) {
                     error.OutOfMemory => return error.OutOfMemory,
                     else => break :try_vs7_key,
                 };
@@ -1045,14 +1173,15 @@ const MsvcLibDir = struct {
     pub fn find(
         gpa: Allocator,
         io: Io,
+        registry: *Registry,
         arch: std.Target.Cpu.Arch,
         environ_map: *const Environ.Map,
     ) error{ OutOfMemory, MsvcLibDirNotFound }![]const u8 {
-        const full_path = MsvcLibDir.findViaCOM(gpa, io, arch, environ_map) catch |err1| switch (err1) {
+        const full_path = MsvcLibDir.findViaCOM(gpa, io, registry, arch, environ_map) catch |err1| switch (err1) {
             error.OutOfMemory => return error.OutOfMemory,
             error.PathNotFound => MsvcLibDir.findViaRegistry(gpa, io, arch, environ_map) catch |err2| switch (err2) {
                 error.OutOfMemory => return error.OutOfMemory,
-                error.PathNotFound => MsvcLibDir.findViaVs7Key(gpa, io, arch, environ_map) catch |err3| switch (err3) {
+                error.PathNotFound => MsvcLibDir.findViaVs7Key(gpa, io, registry, arch, environ_map) catch |err3| switch (err3) {
                     error.OutOfMemory => return error.OutOfMemory,
                     error.PathNotFound => return error.MsvcLibDirNotFound,
                 },
diff --git a/lib/std/zig/system/windows.zig b/lib/std/zig/system/windows.zig
index 0a752dd7f9d55d18073830b1bdcfcc6c12af45f7..b34309c09bc47aa69d042cf8462839790af7592a 100644
--- a/lib/std/zig/system/windows.zig
+++ b/lib/std/zig/system/windows.zig
@@ -85,7 +85,7 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
         .Flags = std.os.windows.RTL_QUERY_REGISTRY_SUBKEY | std.os.windows.RTL_QUERY_REGISTRY_REQUIRED,
         .Name = subkey[0..subkey_len :0],
         .EntryContext = null,
-        .DefaultType = REG.NONE,
+        .DefaultType = .NONE,
         .DefaultData = null,
         .DefaultLength = 0,
     };
@@ -95,9 +95,9 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
     inline for (fields_info, 0..) |field, i| {
         const ctx: *anyopaque = blk: {
             switch (@field(args, field.name).value_type) {
-                REG.SZ,
-                REG.EXPAND_SZ,
-                REG.MULTI_SZ,
+                .SZ,
+                .EXPAND_SZ,
+                .MULTI_SZ,
                 => {
                     comptime assert(@sizeOf(std.os.windows.UNICODE_STRING) % 2 == 0);
                     const unicode: *std.os.windows.UNICODE_STRING = @ptrCast(&tmp_bufs[i]);
@@ -109,9 +109,9 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
                     break :blk unicode;
                 },
 
-                REG.DWORD,
-                REG.DWORD_BIG_ENDIAN,
-                REG.QWORD,
+                .DWORD,
+                .DWORD_BIG_ENDIAN,
+                .QWORD,
                 => break :blk &tmp_bufs[i],
 
                 else => unreachable,
@@ -127,7 +127,7 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
             .Flags = std.os.windows.RTL_QUERY_REGISTRY_DIRECT | std.os.windows.RTL_QUERY_REGISTRY_REQUIRED,
             .Name = key_buf[0..key_len :0],
             .EntryContext = ctx,
-            .DefaultType = REG.NONE,
+            .DefaultType = .NONE,
             .DefaultData = null,
             .DefaultLength = 0,
         };
@@ -139,7 +139,7 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
         .Flags = 0,
         .Name = null,
         .EntryContext = null,
-        .DefaultType = 0,
+        .DefaultType = .NONE,
         .DefaultData = null,
         .DefaultLength = 0,
     };
@@ -154,9 +154,9 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
     switch (res) {
         .SUCCESS => {
             inline for (fields_info, 0..) |field, i| switch (@field(args, field.name).value_type) {
-                REG.SZ,
-                REG.EXPAND_SZ,
-                REG.MULTI_SZ,
+                .SZ,
+                .EXPAND_SZ,
+                .MULTI_SZ,
                 => {
                     var buf = @field(args, field.name).value_buf;
                     const entry: *const std.os.windows.UNICODE_STRING = @ptrCast(table[i + 1].EntryContext);
@@ -164,16 +164,16 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
                     buf[len] = 0;
                 },
 
-                REG.DWORD,
-                REG.DWORD_BIG_ENDIAN,
-                REG.QWORD,
+                .DWORD,
+                .DWORD_BIG_ENDIAN,
+                .QWORD,
                 => {
                     const entry: [*]const u8 = @ptrCast(table[i + 1].EntryContext);
                     switch (@field(args, field.name).value_type) {
-                        REG.DWORD, REG.DWORD_BIG_ENDIAN => {
+                        .DWORD, .DWORD_BIG_ENDIAN => {
                             @memcpy(@field(args, field.name).value_buf[0..4], entry[0..4]);
                         },
-                        REG.QWORD => {
+                        .QWORD => {
                             @memcpy(@field(args, field.name).value_buf[0..8], entry[0..8]);
                         },
                         else => unreachable,
@@ -254,18 +254,18 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
                 // CP 4039 -> ID_AA64MMFR1_EL1
                 // CP 403A -> ID_AA64MMFR2_EL1
                 getCpuInfoFromRegistry(i, .{
-                    .{ .key = "CP 4000", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[0])) },
-                    .{ .key = "CP 4020", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[1])) },
-                    .{ .key = "CP 4021", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[2])) },
-                    .{ .key = "CP 4028", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[3])) },
-                    .{ .key = "CP 4029", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[4])) },
-                    .{ .key = "CP 402C", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[5])) },
-                    .{ .key = "CP 402D", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[6])) },
-                    .{ .key = "CP 4030", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[7])) },
-                    .{ .key = "CP 4031", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[8])) },
-                    .{ .key = "CP 4038", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[9])) },
-                    .{ .key = "CP 4039", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[10])) },
-                    .{ .key = "CP 403A", .value_type = REG.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[11])) },
+                    .{ .key = "CP 4000", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[0])) },
+                    .{ .key = "CP 4020", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[1])) },
+                    .{ .key = "CP 4021", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[2])) },
+                    .{ .key = "CP 4028", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[3])) },
+                    .{ .key = "CP 4029", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[4])) },
+                    .{ .key = "CP 402C", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[5])) },
+                    .{ .key = "CP 402D", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[6])) },
+                    .{ .key = "CP 4030", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[7])) },
+                    .{ .key = "CP 4031", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[8])) },
+                    .{ .key = "CP 4038", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[9])) },
+                    .{ .key = "CP 4039", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[10])) },
+                    .{ .key = "CP 403A", .value_type = REG.ValueType.QWORD, .value_buf = @as(*[8]u8, @ptrCast(&registers[11])) },
                 }) catch break :blk null;
 
                 cores[i] = @import("arm.zig").aarch64.detectNativeCpuAndFeatures(current_arch, registers) orelse
-- 
2.54.0


From fdde8e6394c1dd07eb477e66c79f1fa7333bd7de Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Fri, 27 Feb 2026 17:05:25 -0800
Subject: [PATCH 374/499] Delete advapi32 bindings

---
 lib/std/os/windows.zig          |  1 -
 lib/std/os/windows/advapi32.zig | 67 ---------------------------------
 2 files changed, 68 deletions(-)
 delete mode 100644 lib/std/os/windows/advapi32.zig

diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 8db9db03b8495a6c6cea79f530f788e314575b50..8832b1add949df3245eed397ff6f614c54c33d6e 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -15,7 +15,6 @@ const math = std.math;
 const maxInt = std.math.maxInt;
 const UnexpectedError = std.posix.UnexpectedError;
 
-pub const advapi32 = @import("windows/advapi32.zig");
 pub const kernel32 = @import("windows/kernel32.zig");
 pub const ntdll = @import("windows/ntdll.zig");
 pub const ws2_32 = @import("windows/ws2_32.zig");
diff --git a/lib/std/os/windows/advapi32.zig b/lib/std/os/windows/advapi32.zig
deleted file mode 100644
index 90f16b1ec9d03a62e85005bc24c081caa3278774..0000000000000000000000000000000000000000
--- a/lib/std/os/windows/advapi32.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-const std = @import("../../std.zig");
-const windows = std.os.windows;
-const BOOL = windows.BOOL;
-const DWORD = windows.DWORD;
-const HKEY = windows.HKEY;
-const BYTE = windows.BYTE;
-const LPCWSTR = windows.LPCWSTR;
-const LSTATUS = windows.LSTATUS;
-const REGSAM = windows.REGSAM;
-const ULONG = windows.ULONG;
-
-pub extern "advapi32" fn RegOpenKeyExW(
-    hKey: HKEY,
-    lpSubKey: LPCWSTR,
-    ulOptions: DWORD,
-    samDesired: REGSAM,
-    phkResult: *HKEY,
-) callconv(.winapi) LSTATUS;
-
-pub extern "advapi32" fn RegQueryValueExW(
-    hKey: HKEY,
-    lpValueName: LPCWSTR,
-    lpReserved: ?*DWORD,
-    lpType: ?*DWORD,
-    lpData: ?*BYTE,
-    lpcbData: ?*DWORD,
-) callconv(.winapi) LSTATUS;
-
-pub extern "advapi32" fn RegCloseKey(hKey: HKEY) callconv(.winapi) LSTATUS;
-
-pub const RRF = struct {
-    pub const RT_ANY: DWORD = 0x0000ffff;
-
-    pub const RT_DWORD: DWORD = 0x00000018;
-    pub const RT_QWORD: DWORD = 0x00000048;
-
-    pub const RT_REG_BINARY: DWORD = 0x00000008;
-    pub const RT_REG_DWORD: DWORD = 0x00000010;
-    pub const RT_REG_EXPAND_SZ: DWORD = 0x00000004;
-    pub const RT_REG_MULTI_SZ: DWORD = 0x00000020;
-    pub const RT_REG_NONE: DWORD = 0x00000001;
-    pub const RT_REG_QWORD: DWORD = 0x00000040;
-    pub const RT_REG_SZ: DWORD = 0x00000002;
-
-    pub const NOEXPAND: DWORD = 0x10000000;
-    pub const ZEROONFAILURE: DWORD = 0x20000000;
-    pub const SUBKEY_WOW6464KEY: DWORD = 0x00010000;
-    pub const SUBKEY_WOW6432KEY: DWORD = 0x00020000;
-};
-
-pub extern "advapi32" fn RegGetValueW(
-    hkey: HKEY,
-    lpSubKey: LPCWSTR,
-    lpValue: LPCWSTR,
-    dwFlags: DWORD,
-    pdwType: ?*DWORD,
-    pvData: ?*anyopaque,
-    pcbData: ?*DWORD,
-) callconv(.winapi) LSTATUS;
-
-pub extern "advapi32" fn RegLoadAppKeyW(
-    lpFile: LPCWSTR,
-    phkResult: *HKEY,
-    samDesired: REGSAM,
-    dwOptions: DWORD,
-    reserved: DWORD,
-) callconv(.winapi) LSTATUS;
-- 
2.54.0


From d2db1d45f1651d25c779651378b002b027e5f8e4 Mon Sep 17 00:00:00 2001
From: Robby Zambito <contact@robbyzambito.me>
Date: Tue, 27 Jan 2026 16:42:58 -0500
Subject: [PATCH 375/499] fix: inline to propagate comptime-ness to call site

See conversation at: https://ziggit.dev/t/why-is-the-comptime-keyword-needed-in-this-inline-for-loop-condition/14090
---
 lib/std/enums.zig              | 3 ++-
 src/codegen/x86_64/CodeGen.zig | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/std/enums.zig b/lib/std/enums.zig
index 6e21713e6d28c33e2088e88b3c98e5b75a2e5756..406869082e0bd039c1b8bf3a8003047bc1e42a17 100644
--- a/lib/std/enums.zig
+++ b/lib/std/enums.zig
@@ -42,6 +42,7 @@ pub fn EnumFieldStruct(comptime E: type, comptime Data: type, comptime field_def
 /// The result array is in the same order as the input.
 pub inline fn valuesFromFields(comptime E: type, comptime fields: []const EnumField) []const E {
     comptime {
+        @setEvalBranchQuota(@typeInfo(E).@"enum".fields.len + eval_branch_quota_cushion);
         var result: [fields.len]E = undefined;
         for (&result, fields) |*r, f| {
             r.* = @enumFromInt(f.value);
@@ -53,7 +54,7 @@ pub inline fn valuesFromFields(comptime E: type, comptime fields: []const EnumFi
 
 /// Returns the set of all named values in the given enum, in
 /// declaration order.
-pub fn values(comptime E: type) []const E {
+pub inline fn values(comptime E: type) []const E {
     return comptime valuesFromFields(E, @typeInfo(E).@"enum".fields);
 }
 
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 5032a5128998c96891cfe39f56cd5a040562bb2c..6144a421c8cb132aebd77f745bff78618a3e7a0f 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -177113,7 +177113,7 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void {
 }
 
 fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
-    @setEvalBranchQuota(1_100);
+    @setEvalBranchQuota(1_100 + @typeInfo(Mir.Inst.Fixes).@"enum".fields.len);
     const pt = self.pt;
     const zcu = pt.zcu;
     const unwrapped_asm = self.air.unwrapAsm(inst);
-- 
2.54.0


From 852c5d2824afdf3a0997b20923eac15f7569f56a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 3 Mar 2026 22:50:48 +0100
Subject: [PATCH 376/499] build: bump some max_rss values

---
 build.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.zig b/build.zig
index 152ae161d802995dbffdbd112b7b8018a161f51e..06ba1aab65bb127957fb1abb3ba8dafc3d40db9d 100644
--- a/build.zig
+++ b/build.zig
@@ -491,7 +491,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = 3_500_000_000,
+        .max_rss = 4_000_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
@@ -517,7 +517,7 @@ pub fn build(b: *std.Build) !void {
         .skip_llvm = skip_llvm,
         .skip_libc = true,
         .no_builtin = true,
-        .max_rss = 2_000_000_000,
+        .max_rss = 4_000_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
-- 
2.54.0


From 96a19d3a6b867e6e8dc9ddc9c3fdc675521dd41b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 3 Mar 2026 20:43:39 +0100
Subject: [PATCH 377/499] ci: stop downloading tarballs on x86_64-windows

It's annoying to have jobs fail on new machines or when switching tarball. Also
quirky is easily accessible over SSH now, so we can just upload tarballs as we
do for other machines.
---
 ci/x86_64-windows-debug.ps1   | 13 +------------
 ci/x86_64-windows-release.ps1 | 13 +------------
 2 files changed, 2 insertions(+), 24 deletions(-)

diff --git a/ci/x86_64-windows-debug.ps1 b/ci/x86_64-windows-debug.ps1
index aed6b0cca8916110aba611f8880f2170f02057e9..d1031386c51a2c2394253d183c400b95403996ca 100644
--- a/ci/x86_64-windows-debug.ps1
+++ b/ci/x86_64-windows-debug.ps1
@@ -1,21 +1,10 @@
 $TARGET = "x86_64-windows-gnu"
-$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 $MCPU = "baseline"
-$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
-$PREFIX_PATH = "$($Env:USERPROFILE)\$ZIG_LLVM_CLANG_LLD_NAME"
+$PREFIX_PATH = "$($Env:USERPROFILE)\deps\zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 $ZIG = "$PREFIX_PATH\bin\zig.exe"
 $ZIG_LIB_DIR = "$(Get-Location)\lib"
 $ZSF_MAX_RSS = if ($Env:ZSF_MAX_RSS) { $Env:ZSF_MAX_RSS } else { 0 }
 
-if (!(Test-Path "$PREFIX_PATH.zip")) {
-    Write-Output "Downloading $ZIG_LLVM_CLANG_LLD_URL"
-    Invoke-WebRequest -Uri "$ZIG_LLVM_CLANG_LLD_URL" -OutFile "$PREFIX_PATH.zip"
-
-    Write-Output "Extracting..."
-    Add-Type -AssemblyName System.IO.Compression.FileSystem ;
-    [System.IO.Compression.ZipFile]::ExtractToDirectory("$PREFIX_PATH.zip", "$PREFIX_PATH\..")
-}
-
 function CheckLastExitCode {
     if (!$?) {
         exit 1
diff --git a/ci/x86_64-windows-release.ps1 b/ci/x86_64-windows-release.ps1
index 59d1e3c4c7a39872a6aa70b2502854bb1204f403..e24432e076bfefe2128bb95f1e6a60823be7ac0e 100644
--- a/ci/x86_64-windows-release.ps1
+++ b/ci/x86_64-windows-release.ps1
@@ -1,21 +1,10 @@
 $TARGET = "x86_64-windows-gnu"
-$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 $MCPU = "baseline"
-$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
-$PREFIX_PATH = "$($Env:USERPROFILE)\$ZIG_LLVM_CLANG_LLD_NAME"
+$PREFIX_PATH = "$($Env:USERPROFILE)\deps\zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 $ZIG = "$PREFIX_PATH\bin\zig.exe"
 $ZIG_LIB_DIR = "$(Get-Location)\lib"
 $ZSF_MAX_RSS = if ($Env:ZSF_MAX_RSS) { $Env:ZSF_MAX_RSS } else { 0 }
 
-if (!(Test-Path "$PREFIX_PATH.zip")) {
-    Write-Output "Downloading $ZIG_LLVM_CLANG_LLD_URL"
-    Invoke-WebRequest -Uri "$ZIG_LLVM_CLANG_LLD_URL" -OutFile "$PREFIX_PATH.zip"
-
-    Write-Output "Extracting..."
-    Add-Type -AssemblyName System.IO.Compression.FileSystem ;
-    [System.IO.Compression.ZipFile]::ExtractToDirectory("$PREFIX_PATH.zip", "$PREFIX_PATH\..")
-}
-
 function CheckLastExitCode {
     if (!$?) {
         exit 1
-- 
2.54.0


From af1ab5fa08f2c58517f94c253535403e1575c3b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Mar 2026 00:16:29 +0100
Subject: [PATCH 378/499] ci: bump aarch64-freebsd-debug timeout by 1 hour

---
 .forgejo/workflows/ci.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.forgejo/workflows/ci.yaml b/.forgejo/workflows/ci.yaml
index 160271aded4052668cd533db49699e1aaf32f9b9..961198ffbe6b867318694a55dc6be6c0bca7b0c1 100644
--- a/.forgejo/workflows/ci.yaml
+++ b/.forgejo/workflows/ci.yaml
@@ -26,7 +26,7 @@ jobs:
           fetch-depth: 0
       - name: Build and Test
         run: sh ci/aarch64-freebsd-debug.sh
-        timeout-minutes: 240
+        timeout-minutes: 300
   aarch64-freebsd-release:
     runs-on: [self-hosted, aarch64-freebsd]
     steps:
-- 
2.54.0


From ce32003625566dcc3687e9e32be411ccb83a4aaa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Mar 2026 01:21:08 +0100
Subject: [PATCH 379/499] std.Io.net.test: disable `listen on a port, send
 bytes, receive bytes`

https://codeberg.org/ziglang/zig/issues/31388
---
 lib/std/Io/net/test.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/Io/net/test.zig b/lib/std/Io/net/test.zig
index 7904bc4641170ee448af9319f4804d21b439d4ca..fee036502bd14fc7b39c3c7075fc513165359349 100644
--- a/lib/std/Io/net/test.zig
+++ b/lib/std/Io/net/test.zig
@@ -177,6 +177,7 @@ test "resolve DNS" {
 }
 
 test "listen on a port, send bytes, receive bytes" {
+    if (true) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31388
     if (builtin.single_threaded) return error.SkipZigTest;
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-- 
2.54.0


From 0ae1c6b54acf112c7bbcc63a19f7ad8fa9842d2a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Mar 2026 12:14:11 +0100
Subject: [PATCH 380/499] std.Io.RwLock: disable `smoke test` on aarch64-netbsd

https://codeberg.org/ziglang/zig/issues/31393
---
 lib/std/Io/RwLock.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/std/Io/RwLock.zig b/lib/std/Io/RwLock.zig
index 7be4f026e16c150feef443286315567add6bf69c..fff958efe9a8db7d3d6c2c03349acbfc270453bf 100644
--- a/lib/std/Io/RwLock.zig
+++ b/lib/std/Io/RwLock.zig
@@ -114,6 +114,8 @@ test "internal state" {
 }
 
 test "smoke test" {
+    if (builtin.target.cpu.arch.isAARCH64() and builtin.target.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31393
+
     const io = testing.io;
 
     var rl: Io.RwLock = .init;
-- 
2.54.0


From 571543237f64c9ff3ea71ca4734de9b64c3f8cf1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Mar 2026 21:29:48 +0100
Subject: [PATCH 381/499] ci: update to wasmtime 42.0.1

---
 ci/x86_64-linux-debug-llvm.sh | 2 +-
 ci/x86_64-linux-debug.sh      | 2 +-
 ci/x86_64-linux-release.sh    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index a0e3e01b05bb2bbe27dbd6798933378c71ac8313..23a1813f1c9900c67fd56c056785e9f1034e2315 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index 75f2e64f4f52e99aebdfa3e4b48b20a154a5514b..240db22fd99cc6a836757e059a496648a2eed6b8 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 6c0a63ddf5eb5258a3cee2533853a46a06b3c74b..4fea661b98d2281887fb15599b8328676f927276 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -11,7 +11,7 @@ CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v38.0.3-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
-- 
2.54.0


From b778826df5836a4383e06e7434012e9a91a510ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 5 Mar 2026 18:49:31 +0100
Subject: [PATCH 382/499] std.crypto.argon2: disable `kdf` test

https://codeberg.org/ziglang/zig/issues/31402
---
 lib/std/crypto/argon2.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/std/crypto/argon2.zig b/lib/std/crypto/argon2.zig
index f6bf85782db81fa9681bc9eca1a5ffbae8d2f439..69cd0b87ef8f94f3ac76621cde502596a6ebdd91 100644
--- a/lib/std/crypto/argon2.zig
+++ b/lib/std/crypto/argon2.zig
@@ -707,6 +707,8 @@ test "argon2id" {
 }
 
 test "kdf" {
+    if (true) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31402
+
     const password = "password";
     const salt = "somesalt";
 
-- 
2.54.0


From 15f0af09d0ba8e8a6a7b44702913ca309afe2296 Mon Sep 17 00:00:00 2001
From: xeondev <reversedrooms@gmail.com>
Date: Wed, 4 Mar 2026 13:15:06 +0300
Subject: [PATCH 383/499] Io.Threaded.batchAwaitConcurrent: fix poll args

---
 lib/std/Io/Threaded.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index c0b6b2b47d8e20503e1c31bc65a9a5f81445712a..83bda2c865a0ef098bb5c81a9fb719e78adae42b 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2868,7 +2868,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
             break :t @min(@max(0, duration.raw.toMilliseconds()), std.math.maxInt(i32));
         };
         const syscall = try Syscall.start();
-        const rc = posix.system.poll(&poll_buffer, poll_storage.len, timeout_ms);
+        const rc = posix.system.poll(poll_storage.slice.ptr, poll_storage.len, timeout_ms);
         syscall.finish();
         switch (posix.errno(rc)) {
             .SUCCESS => {
-- 
2.54.0


From 4fa465fc8f3b6140e635186b4f0e5acae924adcc Mon Sep 17 00:00:00 2001
From: Koko Bhadra <amlandeep1912@gmail.com>
Date: Tue, 3 Mar 2026 10:15:26 -0500
Subject: [PATCH 384/499] compiler_rt: optimize udivmod large-divisor case with
 trial quotient

Replace the O(n) shift-subtract loop with a constant-time trial
quotient approach (Knuth Algorithm D, TAOCP Vol 2 Section 4.3.1).

The old code iterates clz(b_hi)-clz(a_hi)+1 times (up to 64
iterations of 128-bit arithmetic). The new code uses a single
divwide call to get a trial quotient, then verifies with two
native-width widening multiplies.

Benchmark (Apple M1, ReleaseFast):
- Large divisor, large shift: 87ns -> 7.5ns (11.5x faster)
- Small divisor / uniform: unchanged
---
 lib/compiler_rt/udivmod.zig | 95 ++++++++++++++++++++++++++++++-------
 1 file changed, 77 insertions(+), 18 deletions(-)

diff --git a/lib/compiler_rt/udivmod.zig b/lib/compiler_rt/udivmod.zig
index 44165c0a62b9283aed00b3f1bdae93ada8b43b1c..fdb338c21ac012c786f2fba1c54f9dfc119f0c88 100644
--- a/lib/compiler_rt/udivmod.zig
+++ b/lib/compiler_rt/udivmod.zig
@@ -182,7 +182,7 @@ fn divwide(comptime T: type, _u1: T, _u0: T, v: T, r: *T) T {
 pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
     @setRuntimeSafety(compiler_rt.test_safety);
     const HalfT = HalveInt(T, false).HalfT;
-    const SignedT = std.meta.Int(.signed, @bitSizeOf(T));
+    const half_bits = @bitSizeOf(HalfT);
 
     if (b_ > a_) {
         if (maybe_rem) |rem| {
@@ -214,26 +214,85 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
         return @bitCast(q);
     }
 
-    // 0 <= shift <= 63
-    const shift: Log2Int(T) = @clz(b[hi]) - @clz(a[hi]);
-    var af: T = @bitCast(a);
-    var bf = @as(T, @bitCast(b)) << shift;
+    // Large-divisor case: b[hi] != 0, so the quotient fits in one HalfT word.
+    //
+    // Trial quotient via divwide (Knuth Vol 2, Section 4.3.1):
+    // Normalize the divisor so its high half has the MSB set, then use divwide
+    // on the top bits to get a trial quotient that is at most 1 too large.
+    // This replaces the O(shift) bit-by-bit loop with O(1) operations.
+    const s: Log2Int(HalfT) = @intCast(@clz(b[hi]));
+
+    if (s == 0) {
+        // b[hi] already has its MSB set, so b >= 2^(T_bits - 1). Since a >= b
+        // (we passed the b_ > a_ check), a >= 2^(T_bits - 1) too, meaning
+        // a[hi] also has its MSB set. Therefore a / b < 2, and the quotient
+        // is exactly 1.
+        q = @bitCast(@as(T, 0));
+        q[lo] = 1;
+        if (maybe_rem) |rem| {
+            rem.* = a_ - b_;
+        }
+        return @bitCast(q);
+    }
+
+    // Normalize b: shift left by s so bn_hi has its MSB set.
+    const sr: Log2Int(HalfT) = @intCast(half_bits - @as(
+        std.math.IntFittingRange(0, half_bits),
+        @intCast(s),
+    ));
+    const bn_hi: HalfT = (b[hi] << s) | (b[lo] >> sr);
+
+    // Trial numerator: the top (half_bits + s) bits of (a << s), as [a2:a1].
+    // a2 < bn_hi is guaranteed since a2 < 2^s and bn_hi >= 2^(half_bits - 1).
+    const a2: HalfT = a[hi] >> sr;
+    const a1: HalfT = (a[hi] << s) | (a[lo] >> sr);
+
+    // Trial quotient via divwide: q_hat = floor([a2:a1] / bn_hi).
+    // By Knuth's theorem (normalized divisor), q <= q_hat <= q + 1.
+    var r_tmp: HalfT = undefined;
+    var q_hat: HalfT = divwide(HalfT, a2, a1, bn_hi, &r_tmp);
+
+    // Verify: q_hat * b must not exceed a.
+    // Compute the product using HalfT * HalfT -> T widening multiplications,
+    // which are native single-instruction ops when HalfT fits in a register
+    // (e.g. u64 * u64 -> u128 via mulq on x86_64, mul on aarch64).
+    // product = q_hat * [b[hi]:b[lo]] = [p_top : p_mid : p_lo] (3 half-words)
+    const prod_lo: T = @as(T, q_hat) * @as(T, b[lo]);
+    const prod_hi: T = @as(T, q_hat) * @as(T, b[hi]);
+
+    const prod_lo_parts: [2]HalfT = @bitCast(prod_lo);
+    const prod_hi_parts: [2]HalfT = @bitCast(prod_hi);
+
+    const mid_add = @addWithOverflow(prod_hi_parts[lo], prod_lo_parts[hi]);
+    var p_mid: HalfT = mid_add[0];
+    const p_top: HalfT = prod_hi_parts[hi] +% @as(HalfT, mid_add[1]);
+    var p_lo: HalfT = prod_lo_parts[lo];
+
+    // If product > a, decrement q_hat (at most once, guaranteed by Knuth).
+    if (p_top > 0 or p_mid > a[hi] or (p_mid == a[hi] and p_lo > a[lo])) {
+        q_hat -= 1;
+        // Subtract b from the product for correct remainder computation.
+        // After correction, (q_hat * b) fits in T bits, so borrows into
+        // p_top cancel it to zero -- we only need [p_mid:p_lo].
+        const sub_lo = @subWithOverflow(p_lo, b[lo]);
+        p_lo = sub_lo[0];
+        const sub_mid = @subWithOverflow(p_mid, b[hi]);
+        const sub_mid2 = @subWithOverflow(sub_mid[0], @as(HalfT, sub_lo[1]));
+        p_mid = sub_mid2[0];
+    }
+
     q = @bitCast(@as(T, 0));
+    q[lo] = q_hat;
 
-    for (0..shift + 1) |_| {
-        q[lo] <<= 1;
-        // Branchless version of:
-        // if (af >= bf) {
-        //     af -= bf;
-        //     q[lo] |= 1;
-        // }
-        const s = @as(SignedT, @bitCast(bf -% af -% 1)) >> (@bitSizeOf(T) - 1);
-        q[lo] |= @intCast(s & 1);
-        af -= bf & @as(T, @bitCast(s));
-        bf >>= 1;
-    }
     if (maybe_rem) |rem| {
-        rem.* = @bitCast(af);
+        // remainder = a - q_hat * b = [a[hi]:a[lo]] - [p_mid:p_lo]
+        // This subtraction is non-negative since q_hat <= true quotient.
+        const rem_lo = @subWithOverflow(a[lo], p_lo);
+        r[lo] = rem_lo[0];
+        const rem_hi = @subWithOverflow(a[hi], p_mid);
+        const rem_hi2 = @subWithOverflow(rem_hi[0], @as(HalfT, rem_lo[1]));
+        r[hi] = rem_hi2[0];
+        rem.* = @bitCast(r);
     }
     return @bitCast(q);
 }
-- 
2.54.0


From aa2f318935eba57b82b640bc6a50b4089deeffaf Mon Sep 17 00:00:00 2001
From: Nathan Michaels <nathan@nmichaels.org>
Date: Thu, 5 Mar 2026 13:46:50 +0100
Subject: [PATCH 385/499] std.mem.ReverseIterator: make public

---
 lib/std/mem.zig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 1b109cdfa030394d732234950248ad43172905cf..cc03e5b2c54ccd67ccefe7e854a4385f614f1dae 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -4002,7 +4002,9 @@ test reverse {
         try testing.expectEqualSlices(MyType, &arr, &([_]MyType{ .c, .{ .b = 0 }, .{ .a = .{ 0, 0, 0 } } }));
     }
 }
-fn ReverseIterator(comptime T: type) type {
+
+/// Returned by `reverseIterator`.
+pub fn ReverseIterator(comptime T: type) type {
     const ptr = switch (@typeInfo(T)) {
         .pointer => |ptr| ptr,
         else => @compileError("expected slice or pointer to array, found '" ++ @typeName(T) ++ "'"),
-- 
2.54.0


From 30c8a759978c11620e90bf5117829c92c14bbf28 Mon Sep 17 00:00:00 2001
From: Khitiara <robotbrainify@gmail.com>
Date: Thu, 5 Mar 2026 11:48:42 -0500
Subject: [PATCH 386/499] Fix #20283

---
 lib/docs/wasm/main.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index bee3e4acbcc370261f3b137d40584ea2ad2f8065..586534d2aefc9f664097d5e128971b3773b7b66a 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -803,6 +803,7 @@ fn unpackInner(tar_bytes: []u8) !void {
                 if (std.mem.endsWith(u8, tar_file.name, ".zig")) {
                     log.debug("found file: '{s}'", .{tar_file.name});
                     const file_name = try gpa.dupe(u8, tar_file.name);
+                    std.mem.replaceScalar(u8, file_name, '\\', '/');
                     if (std.mem.indexOfScalar(u8, file_name, '/')) |pkg_name_end| {
                         const pkg_name = file_name[0..pkg_name_end];
                         const gop = try Walk.modules.getOrPut(gpa, pkg_name);
-- 
2.54.0


From 46658257f458b7c3c95d7e10cbde85403f7bdb44 Mon Sep 17 00:00:00 2001
From: breakmit <breakmit@noreply.codeberg.org>
Date: Fri, 6 Mar 2026 04:51:28 +0100
Subject: [PATCH 387/499] Io.Threaded.spawnPosix: implement passing file
 descriptors as stdio (#31379)

`std.process.spawn`: remove the TODO for nonblocking file stdio and document the behavior.

Fix a bug in Io.Uring.dup2 where the function does not return on success

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31379
Reviewed-by: Andrew Kelley <andrew@ziglang.org>
Co-authored-by: breakmit <breakmit@noreply.codeberg.org>
Co-committed-by: breakmit <breakmit@noreply.codeberg.org>
---
 lib/std/Io/Dispatch.zig | 5 +----
 lib/std/Io/Threaded.zig | 2 +-
 lib/std/Io/Uring.zig    | 7 ++-----
 lib/std/process.zig     | 6 ++++++
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 1a1d644276565f00ad65ca4e7183124351159a59..947e8e3070fff48d5bdf725b56f10f3ee1df1ccb 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -4404,10 +4404,7 @@ fn setUpChildIo(
         .close => closeFd(std_fileno),
         .inherit => {},
         .ignore => try ev.dup2(dev_null_fd, std_fileno),
-        .file => |file| {
-            if (file.flags.nonblocking) @panic("TODO implement setUpChildIo when nonblocking file is used");
-            try ev.dup2(file.handle, std_fileno);
-        },
+        .file => |file| try ev.dup2(file.handle, std_fileno),
     }
 }
 
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 83bda2c865a0ef098bb5c81a9fb719e78adae42b..b1804c4605c26aaafe8e0b534669d535b33687f1 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -15659,7 +15659,7 @@ fn setUpChildIo(stdio: process.SpawnOptions.StdIo, pipe_fd: i32, std_fileno: i32
         .close => closeFd(std_fileno),
         .inherit => {},
         .ignore => try dup2(dev_null_fd, std_fileno),
-        .file => @panic("TODO implement setUpChildIo when file is used"),
+        .file => |file| try dup2(file.handle, std_fileno),
     }
 }
 
diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index 0f4f64334f3da1bbb5eec2701c513bb3762e56d0..6031b1b2987fba99b77f27820d35aae3581f8fe4 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -4550,10 +4550,7 @@ fn setUpChildIo(
         .close => _ = linux.close(std_fileno),
         .inherit => {},
         .ignore => try dup2(sync, dev_null_fd, std_fileno),
-        .file => |file| {
-            if (file.flags.nonblocking) @panic("TODO implement setUpChildIo when nonblocking file is used");
-            try dup2(sync, file.handle, std_fileno);
-        },
+        .file => |file| try dup2(sync, file.handle, std_fileno),
     }
 }
 
@@ -4565,7 +4562,7 @@ pub fn dup2(sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t) DupError!void
     while (true) {
         try sync.cancel_region.await(.nothing);
         switch (linux.errno(linux.dup2(old_fd, new_fd))) {
-            .SUCCESS => {},
+            .SUCCESS => return,
             .BUSY, .INTR => {},
             .INVAL => |err| return errnoBug(err), // invalid parameters
             .BADF => |err| return errnoBug(err), // use after free
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 1be0cd628d224db76ea26d19d15336549e6ae3ba..701eb434b5cf918bfcbdf145ffc764881f775d54 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -409,6 +409,12 @@ pub const SpawnOptions = struct {
         /// Inherit the corresponding stream from the parent process.
         inherit,
         /// Pass an already open file from the parent to the child.
+        ///
+        /// Nonblocking mode will be kept in the child process if present. This is
+        /// likely not supported by the child process. For example:
+        /// - Zig's std.Io.File.stdout() assumes blocking mode
+        /// - Rust explicity documents that nonblocking stdio may cause panics
+        /// - C++ standard streams do not support nonblocking file descriptors
         file: File,
         /// Pass a null stream to the child process by opening "/dev/null" on POSIX
         /// and "NUL" on Windows.
-- 
2.54.0


From 5a176d57b6a507e983140de50c22520ddc260954 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 8 Mar 2026 02:01:13 +0100
Subject: [PATCH 388/499] test/llvm_targets.zig: fix a typo

---
 test/llvm_targets.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/llvm_targets.zig b/test/llvm_targets.zig
index 1ff0cf426dde3cffedf14c42d67c6c33d8ba7388..0531de8dd7be27eeb5f0a142706ee9f096cd6b8a 100644
--- a/test/llvm_targets.zig
+++ b/test/llvm_targets.zig
@@ -230,7 +230,7 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .riscv64, .os_tag = .serenity, .abi = .none },
     // .{ .cpu_arch = .riscv64, .os_tag = .uefi, .abi = .none },
 
-    // .{ .cpu_arch = .riscv64, .os_tag = .freestanding, .abi = .none },
+    // .{ .cpu_arch = .riscv64be, .os_tag = .freestanding, .abi = .none },
 
     .{ .cpu_arch = .s390x, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .s390x, .os_tag = .linux, .abi = .gnu },
-- 
2.54.0


From c91bb87b01f988d2bad4e015f65b0767abcbce36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 7 Mar 2026 05:28:28 +0100
Subject: [PATCH 389/499] std.zig.target: enable loongarch64-linux-muslf32

This should still be considered an experimental target as the LP64F ABI has not
been stabilized yet.
---
 lib/std/zig/target.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/zig/target.zig b/lib/std/zig/target.zig
index b8e13d4a606009e9a6fa551b1af211f7bfb0e37e..34709e17ac9f0e9da4ff212c541e144f09d71da0 100644
--- a/lib/std/zig/target.zig
+++ b/lib/std/zig/target.zig
@@ -49,6 +49,7 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnuf64" },
     .{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 }, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnusf" },
     .{ .arch = .loongarch64, .os = .linux, .abi = .musl, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 } },
+    .{ .arch = .loongarch64, .os = .linux, .abi = .muslf32, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 } },
     .{ .arch = .loongarch64, .os = .linux, .abi = .muslsf, .os_ver = .{ .major = 5, .minor = 19, .patch = 0 } },
     .{ .arch = .m68k, .os = .linux, .abi = .gnu, .os_ver = .{ .major = 1, .minor = 3, .patch = 94 } },
     .{ .arch = .m68k, .os = .linux, .abi = .musl, .os_ver = .{ .major = 1, .minor = 3, .patch = 94 } },
-- 
2.54.0


From f16eb18ce8c24ed743aae1faa4980052cb9f4f36 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Fri, 6 Mar 2026 01:54:12 -0800
Subject: [PATCH 390/499] Use / as path separator when writing tar files

The tar format expects `/`, although some untar implementations do seem to handle Windows-style `\` path separators (7-Zip at least).

The tar.Writer API can't really enforce this, though, as doing so would effectively make `\` an illegal character when it's really not. So, it's up to the user to provide paths with the correct path separators.

`Build/WebServer.zig` will still output tars with `\` as a path separator on Windows, but that's currently only used during fuzzing which is not yet implemented on Windows.
---
 lib/compiler/std-docs.zig   | 15 ++++++++++++++-
 lib/std/Build/WebServer.zig |  4 ++++
 lib/std/tar/Writer.zig      | 13 ++++++++++++-
 src/Compilation.zig         | 14 +++++++++++++-
 src/Package/Fetch.zig       |  4 ++++
 5 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/lib/compiler/std-docs.zig b/lib/compiler/std-docs.zig
index c9ce1700519bcb31692cd4623ce81801d7559a83..5660e6e56dbf4c5b60aab76305a22f1de730f64b 100644
--- a/lib/compiler/std-docs.zig
+++ b/lib/compiler/std-docs.zig
@@ -208,6 +208,9 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
     var archiver: std.tar.Writer = .{ .underlying_writer = &response.writer };
     archiver.prefix = "std";
 
+    var path_buf: std.ArrayList(u8) = .empty;
+    defer path_buf.deinit(gpa);
+
     while (try walker.next(io)) |entry| {
         switch (entry.kind) {
             .file => {
@@ -227,7 +230,17 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
             .interface = Io.File.Reader.initInterface(&.{}),
             .size = stat.size,
         };
-        try archiver.writeFileTimestamp(entry.path, &file_reader, stat.mtime);
+
+        const posix_path = if (comptime std.fs.path.sep == std.fs.path.sep_posix)
+            entry.path
+        else blk: {
+            path_buf.clearRetainingCapacity();
+            try path_buf.appendSlice(gpa, entry.path);
+            std.mem.replaceScalar(u8, path_buf.items, std.fs.path.sep, std.fs.path.sep_posix);
+            break :blk path_buf.items;
+        };
+
+        try archiver.writeFileTimestamp(posix_path, &file_reader, stat.mtime);
     }
 
     {
diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index 97759169033432889ab27dda2d27dcc84d1882f7..a54479f667a2157a8cc564efc5ab1d823908286e 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -526,6 +526,10 @@ pub fn serveTarFile(ws: *WebServer, request: *http.Server.Request, paths: []cons
         // resulting in modules named "" and "src". The compiler needs to tell the build system
         // about the module graph so that the build system can correctly encode this information in
         // the tar file.
+        //
+        // Additionally, this needs to ensure that all path separators for both prefix and
+        // sub_path are using the POSIX-style `/` on platforms that don't use it as their native
+        // path separator.
         archiver.prefix = path.root_dir.path orelse graph.cache.cwd;
         try archiver.writeFile(path.sub_path, &file_reader, @intCast(stat.mtime.toSeconds()));
     }
diff --git a/lib/std/tar/Writer.zig b/lib/std/tar/Writer.zig
index aa4d9b1bbbad4cf00c44ed3f3e495080c66f8d7f..8bcd87161a8c1271c84aa4ec868e5021472b89b6 100644
--- a/lib/std/tar/Writer.zig
+++ b/lib/std/tar/Writer.zig
@@ -17,6 +17,7 @@ pub const Options = struct {
 };
 
 underlying_writer: *Io.Writer,
+/// Assumed to use `/` for any path separators.
 prefix: []const u8 = "",
 
 const Error = error{
@@ -26,6 +27,7 @@ const Error = error{
 };
 
 /// Sets prefix for all other write* method paths.
+/// `root` is assumed to use `/` for any path separators.
 pub fn setRoot(w: *Writer, root: []const u8) Error!void {
     if (root.len > 0)
         try w.writeDir(root, .{});
@@ -41,6 +43,7 @@ pub const WriteFileError = Io.Writer.FileError || Error || Io.File.Reader.SizeEr
 
 pub fn writeFileTimestamp(
     w: *Writer,
+    /// Assumed to use `/` for any path separators.
     sub_path: []const u8,
     file_reader: *Io.File.Reader,
     mtime: Io.Timestamp,
@@ -50,6 +53,7 @@ pub fn writeFileTimestamp(
 
 pub fn writeFile(
     w: *Writer,
+    /// Assumed to use `/` for any path separators.
     sub_path: []const u8,
     file_reader: *Io.File.Reader,
     /// If you want to match the file format's expectations, it wants number of
@@ -76,6 +80,7 @@ pub const WriteFileStreamError = Error || Io.Reader.StreamError;
 /// from `reader`, or returns `error.EndOfStream`.
 pub fn writeFileStream(
     w: *Writer,
+    /// Assumed to use `/` for any path separators.
     sub_path: []const u8,
     size: u64,
     reader: *Io.Reader,
@@ -87,7 +92,13 @@ pub fn writeFileStream(
 }
 
 /// Writes file using bytes buffer `content` for size and file content.
-pub fn writeFileBytes(w: *Writer, sub_path: []const u8, content: []const u8, options: Options) Error!void {
+pub fn writeFileBytes(
+    w: *Writer,
+    /// Assumed to use `/` for all path separators.
+    sub_path: []const u8,
+    content: []const u8,
+    options: Options,
+) Error!void {
     try w.writeHeader(.regular, sub_path, "", content.len, options);
     try w.underlying_writer.writeAll(content);
     try w.writePadding(content.len);
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 6a4fab500b3fc0b1a6efb1752b131d4eb592b3e1..521de0b427c4a9cba23daab8e46521bc1ec6ef59 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -5440,6 +5440,9 @@ fn docsCopyModule(
     var archiver: std.tar.Writer = .{ .underlying_writer = &tar_file_writer.interface };
     archiver.prefix = name;
 
+    var path_buf: std.ArrayList(u8) = .empty;
+    defer path_buf.deinit(comp.gpa);
+
     var buffer: [1024]u8 = undefined;
 
     while (try walker.next(io)) |entry| {
@@ -5460,7 +5463,16 @@ fn docsCopyModule(
         const stat = try file.stat(io);
         var file_reader: Io.File.Reader = .initSize(file, io, &buffer, stat.size);
 
-        archiver.writeFileTimestamp(entry.path, &file_reader, stat.mtime) catch |err| {
+        const posix_path = if (comptime std.fs.path.sep == std.fs.path.sep_posix)
+            entry.path
+        else blk: {
+            path_buf.clearRetainingCapacity();
+            try path_buf.appendSlice(comp.gpa, entry.path);
+            std.mem.replaceScalar(u8, path_buf.items, std.fs.path.sep, std.fs.path.sep_posix);
+            break :blk path_buf.items;
+        };
+
+        archiver.writeFileTimestamp(posix_path, &file_reader, stat.mtime) catch |err| {
             return comp.lockAndSetMiscFailure(.docs_copy, "unable to archive {f}{s}: {t}", .{
                 root.fmt(comp), entry.path, err,
             });
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 7226a497218685ee60275dbbbd28fc9f9f529d32..fe57f487b8e614271d409741a57c1f44f40f3f70 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -402,6 +402,10 @@ pub const JobQueue = struct {
                     },
                 }
                 const entry_path = try arena.dupe(u8, entry.path);
+                // If necessary, normalize path separators to POSIX-style since the tar format requires that.
+                if (comptime std.fs.path.sep != std.fs.path.sep_posix) {
+                    std.mem.replaceScalar(u8, entry_path, std.fs.path.sep, std.fs.path.sep_posix);
+                }
                 try scanned_files.append(gpa, entry_path);
             }
 
-- 
2.54.0


From 2c126b8c821e5d1e27e29b8176ae44cd02b0cf14 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Wed, 4 Mar 2026 21:31:03 +0100
Subject: [PATCH 391/499] ci: enable --libc-runtimes with glibc 2.43 and musl
 1.2.5 on x86_64-linux

---
 ci/x86_64-linux-debug-llvm.sh | 1 +
 ci/x86_64-linux-debug.sh      | 1 +
 ci/x86_64-linux-release.sh    | 1 +
 3 files changed, 3 insertions(+)

diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index 23a1813f1c9900c67fd56c056785e9f1034e2315..a37fc6c2a6214888856401ee0d7f1ba1939eb38b 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -56,6 +56,7 @@ stage3-debug/bin/zig build test docs \
   -Dlldb=$HOME/deps/lldb-zig/Debug-e0a42bb34/bin/lldb \
   -Dlibc-test-path=$HOME/deps/libc-test-f2bac77 \
   -fqemu \
+  --libc-runtimes $HOME/deps/glibc-2.43-musl-1.2.5 \
   -fwasmtime \
   -Dstatic-llvm \
   -Dskip-freebsd \
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index 240db22fd99cc6a836757e059a496648a2eed6b8..60203bdcd0c4a66929be7b4d55bdfe416744a20b 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -54,6 +54,7 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dlldb=$HOME/deps/lldb-zig/Debug-e0a42bb34/bin/lldb \
   -fqemu \
+  --libc-runtimes $HOME/deps/glibc-2.43-musl-1.2.5 \
   -fwasmtime \
   -Dstatic-llvm \
   -Dskip-freebsd \
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 4fea661b98d2281887fb15599b8328676f927276..21411ab2af64258aff7910c2dcd3abcdb834cbf3 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -61,6 +61,7 @@ stage3-release/bin/zig build test docs \
   -Dlldb=$HOME/deps/lldb-zig/Release-e0a42bb34/bin/lldb \
   -Dlibc-test-path=$HOME/deps/libc-test-f2bac77 \
   -fqemu \
+  --libc-runtimes $HOME/deps/glibc-2.43-musl-1.2.5 \
   -fwasmtime \
   -Dstatic-llvm \
   -Dskip-test-incremental \
-- 
2.54.0


From 959801030395204a5ce0e2dbcc514e6729899e94 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 8 Mar 2026 19:22:19 +0100
Subject: [PATCH 392/499] README: update section about --libc-runtimes

---
 README.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index b9acf00abd44bf4adad7b625ede101d01f496e6c..2dea88df211df53b69d13e90961ba4ad3ee1c3a7 100644
--- a/README.md
+++ b/README.md
@@ -616,17 +616,17 @@ a few releases old, or may be missing newer targets such as aarch64 and RISC-V.
 [ziglang/qemu-static](https://codeberg.org/ziglang/qemu-static) offers static
 binaries of the latest QEMU version.
 
-##### Testing Non-Native glibc Targets
+##### Testing Non-Native libc Targets
 
-Testing foreign architectures with dynamically linked glibc is one step trickier.
-This requires enabling `--glibc-runtimes /path/to/glibc/multi/install/glibcs`.
-This path is obtained by building glibc for multiple architectures. This
-process for me took an entire day to complete and takes up 65 GiB on my hard
-drive. The CI server does not provide this test coverage.
+Testing foreign architectures with dynamically linked libc is one step trickier.
+This requires enabling `--libc-runtimes /path/to/libcs`. This path is obtained
+by building glibc and musl for multiple architectures. This process for me took
+an entire day to complete and takes up 65 GiB on my hard drive.
 
-[Instructions for producing this path](https://codeberg.org/ziglang/infra/src/branch/master/building-libcs.md#linux-glibc) (just the part with `build-many-glibcs.py`).
+[Instructions for producing this path.](https://codeberg.org/ziglang/infra/src/branch/master/building-libcs.md)
 
-It is understood that most contributors will not have these tests enabled.
+It is understood that most contributors will not have these tests enabled. The
+CI machines provide coverage for these.
 
 #### Testing Windows from a Linux Machine with Wine
 
-- 
2.54.0


From 6def6beacd4b903ca5ebd394b2e2bd508e4364a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 8 Mar 2026 19:23:37 +0100
Subject: [PATCH 393/499] std.zon.parse: disable `std.zon parse float` on
 32-bit x86 in general

https://github.com/ziglang/zig/issues/23922
---
 lib/std/zon/parse.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig
index aaa66227624530ada877829e38503e1b687d40a2..3527f03342b64f5c6f19bad7e163873aeeabcd2b 100644
--- a/lib/std/zon/parse.zig
+++ b/lib/std/zon/parse.zig
@@ -2795,7 +2795,7 @@ test "std.zon negative char" {
 }
 
 test "std.zon parse float" {
-    if (builtin.cpu.arch == .x86 and builtin.abi == .musl and builtin.link_mode == .dynamic) return error.SkipZigTest;
+    if (builtin.cpu.arch == .x86) return error.SkipZigTest;
 
     const gpa = std.testing.allocator;
 
-- 
2.54.0


From dceee570c48a5dbbde02a8a294079a70bb5e2a2f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 8 Mar 2026 18:40:57 -0700
Subject: [PATCH 394/499] Revert "fix(docs/wasm):zig std html render error
 function 'a'"

This reverts commit e779ca72230b5975f48c84ae19c51f0c74f9ecbe.

Closes #31370
---
 lib/docs/wasm/Walk.zig | 88 ++----------------------------------------
 1 file changed, 4 insertions(+), 84 deletions(-)

diff --git a/lib/docs/wasm/Walk.zig b/lib/docs/wasm/Walk.zig
index d361f978c0982e679d42c24967b5d11ccb906ed2..074d4c2f1462668a6e044cadc0f0e735a83e7a3e 100644
--- a/lib/docs/wasm/Walk.zig
+++ b/lib/docs/wasm/Walk.zig
@@ -567,7 +567,7 @@ fn struct_decl(
         .aligned_var_decl,
         => {
             const decl_index = try w.file.add_decl(member, parent_decl);
-            try w.global_var_decl(&namespace.base, decl_index, true, ast.fullVarDecl(member).?);
+            try w.global_var_decl(&namespace.base, decl_index, ast.fullVarDecl(member).?);
         },
 
         .@"comptime",
@@ -579,61 +579,6 @@ fn struct_decl(
     };
 }
 
-/// Traverses a container decl used as an expression without registering its members
-/// as `Decl` entries. This prevents local/test-only helper declarations from
-/// leaking into autodoc symbol lists.
-fn struct_expr(
-    w: *Walk,
-    scope: *Scope,
-    parent_decl: Decl.Index,
-    node: Ast.Node.Index,
-    container_decl: Ast.full.ContainerDecl,
-) Oom!void {
-    const ast = w.file.get_ast();
-
-    const namespace = try gpa.create(Scope.Namespace);
-    namespace.* = .{
-        .parent = scope,
-        .decl_index = parent_decl,
-    };
-    try w.file.get().scopes.putNoClobber(gpa, node, &namespace.base);
-    try w.scanDecls(namespace, container_decl.ast.members);
-
-    for (container_decl.ast.members) |member| switch (ast.nodeTag(member)) {
-        .container_field_init,
-        .container_field_align,
-        .container_field,
-        => try w.container_field(&namespace.base, parent_decl, ast.fullContainerField(member).?),
-
-        .fn_proto,
-        .fn_proto_multi,
-        .fn_proto_one,
-        .fn_proto_simple,
-        .fn_decl,
-        => {
-            var buf: [1]Ast.Node.Index = undefined;
-            const full = ast.fullFnProto(&buf, member).?;
-            const body = if (ast.nodeTag(member) == .fn_decl) ast.nodeData(member).node_and_node[1].toOptional() else .none;
-            try w.fn_decl(&namespace.base, parent_decl, body, full);
-        },
-
-        .global_var_decl,
-        .local_var_decl,
-        .simple_var_decl,
-        .aligned_var_decl,
-        => {
-            // Do not create Decl entries; just walk initializer expressions.
-            try w.global_var_decl(&namespace.base, parent_decl, false, ast.fullVarDecl(member).?);
-        },
-
-        .@"comptime" => try w.expr(&namespace.base, parent_decl, ast.nodeData(member).node),
-
-        .test_decl => try w.expr(&namespace.base, parent_decl, ast.nodeData(member).opt_token_and_node[1]),
-
-        else => unreachable,
-    };
-}
-
 fn comptime_decl(
     w: *Walk,
     scope: *Scope,
@@ -651,38 +596,13 @@ fn global_var_decl(
     w: *Walk,
     scope: *Scope,
     parent_decl: Decl.Index,
-    register_container_members: bool,
     full: Ast.full.VarDecl,
 ) Oom!void {
     try w.maybe_expr(scope, parent_decl, full.ast.type_node);
     try w.maybe_expr(scope, parent_decl, full.ast.align_node);
     try w.maybe_expr(scope, parent_decl, full.ast.addrspace_node);
     try w.maybe_expr(scope, parent_decl, full.ast.section_node);
-
-    if (full.ast.init_node.unwrap()) |init_node| {
-        if (register_container_members) {
-            switch (w.file.get_ast().nodeTag(init_node)) {
-                .container_decl,
-                .container_decl_trailing,
-                .container_decl_arg,
-                .container_decl_arg_trailing,
-                .container_decl_two,
-                .container_decl_two_trailing,
-                .tagged_union,
-                .tagged_union_trailing,
-                .tagged_union_enum_tag,
-                .tagged_union_enum_tag_trailing,
-                .tagged_union_two,
-                .tagged_union_two_trailing,
-                => {
-                    var buf: [2]Ast.Node.Index = undefined;
-                    return struct_decl(w, scope, parent_decl, init_node, w.file.get_ast().fullContainerDecl(&buf, init_node).?);
-                },
-                else => {},
-            }
-        }
-        try w.expr(scope, parent_decl, init_node);
-    }
+    try w.maybe_expr(scope, parent_decl, full.ast.init_node);
 }
 
 fn container_field(
@@ -967,7 +887,7 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
         .tagged_union_two_trailing,
         => {
             var buf: [2]Ast.Node.Index = undefined;
-            return struct_expr(w, scope, parent_decl, node, ast.fullContainerDecl(&buf, node).?);
+            return struct_decl(w, scope, parent_decl, node, ast.fullContainerDecl(&buf, node).?);
         },
 
         .array_type_sentinel => {
@@ -1078,7 +998,7 @@ fn block(
             .aligned_var_decl,
             => {
                 const full = ast.fullVarDecl(node).?;
-                try global_var_decl(w, scope, parent_decl, false, full);
+                try global_var_decl(w, scope, parent_decl, full);
                 const local = try gpa.create(Scope.Local);
                 local.* = .{
                     .parent = scope,
-- 
2.54.0


From 09bf51092ba8f11e342af7bd7d148af63f371709 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 8 Mar 2026 18:41:21 -0700
Subject: [PATCH 395/499] Revert "Fix #20283"

This reverts commit 30c8a759978c11620e90bf5117829c92c14bbf28.

Better fix landed in f16eb18ce8c24ed743aae1faa4980052cb9f4f36.
---
 lib/docs/wasm/main.zig | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index 586534d2aefc9f664097d5e128971b3773b7b66a..bee3e4acbcc370261f3b137d40584ea2ad2f8065 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -803,7 +803,6 @@ fn unpackInner(tar_bytes: []u8) !void {
                 if (std.mem.endsWith(u8, tar_file.name, ".zig")) {
                     log.debug("found file: '{s}'", .{tar_file.name});
                     const file_name = try gpa.dupe(u8, tar_file.name);
-                    std.mem.replaceScalar(u8, file_name, '\\', '/');
                     if (std.mem.indexOfScalar(u8, file_name, '/')) |pkg_name_end| {
                         const pkg_name = file_name[0..pkg_name_end];
                         const gop = try Walk.modules.getOrPut(gpa, pkg_name);
-- 
2.54.0


From 6be202f46633d02e20d0f068a32296113ecb95ca Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Sat, 7 Mar 2026 22:17:20 -0800
Subject: [PATCH 396/499] Io: Add processSetCurrentPath

The logic used to allow providing a path for setting the CWD of a child process in https://codeberg.org/ziglang/zig/pulls/31090 applies here as well:

- Windows must provide a path when setting the CWD, so the path of an `Io.Dir` must be resolved before actually calling RtlSetCurrentDirectory_U
- A directory handle may have multiple paths associated with it, so providing the CWD as a string retains a legitimate use case in cases where the precise path matters
---
 lib/std/Io.zig                         |  1 +
 lib/std/Io/Dispatch.zig                |  3 +-
 lib/std/Io/Threaded.zig                | 39 ++++++++++++++++++++++++++
 lib/std/Io/Uring.zig                   |  3 +-
 lib/std/process.zig                    | 29 +++++++++++++++++++
 test/standalone/posix/cwd.zig          |  6 ++--
 test/standalone/windows_spawn/main.zig |  4 +--
 7 files changed, 77 insertions(+), 8 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 7b06ccfb6a254b881ea6be334a356e474a4ec1c7..932879c99e82b8e7a375148d92a99d05818ea641 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -218,6 +218,7 @@ pub const VTable = struct {
     unlockStderr: *const fn (?*anyopaque) void,
     processCurrentPath: *const fn (?*anyopaque, buffer: []u8) std.process.CurrentPathError!usize,
     processSetCurrentDir: *const fn (?*anyopaque, Dir) std.process.SetCurrentDirError!void,
+    processSetCurrentPath: *const fn (?*anyopaque, []const u8) std.process.SetCurrentPathError!void,
     processReplace: *const fn (?*anyopaque, std.process.ReplaceOptions) std.process.ReplaceError,
     processReplacePath: *const fn (?*anyopaque, Dir, std.process.ReplaceOptions) std.process.ReplaceError,
     processSpawn: *const fn (?*anyopaque, std.process.SpawnOptions) std.process.SpawnError!std.process.Child,
diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index 947e8e3070fff48d5bdf725b56f10f3ee1df1ccb..a9bd960a342976cf252681d641cd14ae9c17c77c 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -434,6 +434,7 @@ pub fn io(ev: *Evented) Io {
             .unlockStderr = unlockStderr,
             .processCurrentPath = processCurrentPath,
             .processSetCurrentDir = processSetCurrentDir,
+            .processSetCurrentPath = processSetCurrentPath,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
             .processSpawn = processSpawn,
@@ -4046,7 +4047,7 @@ fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirEr
     };
 }
 
-fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) ChdirError!void {
+fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) process.SetCurrentPathError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     _ = ev;
     var path_buffer: [c.PATH_MAX]u8 = undefined;
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index b1804c4605c26aaafe8e0b534669d535b33687f1..ca658f0569d7818949293c4b54748865eeef5e02 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1841,6 +1841,7 @@ pub fn io(t: *Threaded) Io {
             .unlockStderr = unlockStderr,
             .processCurrentPath = processCurrentPath,
             .processSetCurrentDir = processSetCurrentDir,
+            .processSetCurrentPath = processSetCurrentPath,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
             .processSpawn = processSpawn,
@@ -2006,6 +2007,7 @@ pub fn ioBasic(t: *Threaded) Io {
             .unlockStderr = unlockStderr,
             .processCurrentPath = processCurrentPath,
             .processSetCurrentDir = processSetCurrentDir,
+            .processSetCurrentPath = processSetCurrentPath,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
             .processSpawn = processSpawn,
@@ -14176,6 +14178,43 @@ fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirEr
     return fchdir(dir.handle);
 }
 
+fn processSetCurrentPath(userdata: ?*anyopaque, path: []const u8) process.SetCurrentPathError!void {
+    const t: *Threaded = @ptrCast(@alignCast(userdata));
+    _ = t;
+
+    if (native_os == .wasi) return error.OperationUnsupported;
+
+    if (is_windows) {
+        var path_w_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
+        const len = std.unicode.calcWtf16LeLen(path) catch return error.InvalidWtf8;
+        if (len > path_w_buf.len) return error.NameTooLong;
+        const path_w_len = std.unicode.wtf8ToWtf16Le(&path_w_buf, path) catch |err| switch (err) {
+            error.InvalidWtf8 => unreachable, // already validated
+        };
+        const path_w = path_w_buf[0..path_w_len];
+
+        const syscall: Syscall = try .start();
+        while (true) switch (windows.ntdll.RtlSetCurrentDirectory_U(&.init(path_w))) {
+            .SUCCESS => return syscall.finish(),
+            .OBJECT_NAME_INVALID => return syscall.fail(error.BadPathName),
+            .OBJECT_NAME_NOT_FOUND => return syscall.fail(error.FileNotFound),
+            .OBJECT_PATH_NOT_FOUND => return syscall.fail(error.FileNotFound),
+            .NO_MEDIA_IN_DEVICE => return syscall.fail(error.NoDevice),
+            .INVALID_PARAMETER => |err| return syscall.ntstatusBug(err),
+            .ACCESS_DENIED => return syscall.fail(error.AccessDenied),
+            .OBJECT_PATH_SYNTAX_BAD => |err| return syscall.ntstatusBug(err),
+            .NOT_A_DIRECTORY => return syscall.fail(error.NotDir),
+            .CANCELLED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            else => |status| return syscall.unexpectedNtstatus(status),
+        };
+    }
+
+    return chdir(path);
+}
+
 pub const PosixAddress = extern union {
     any: posix.sockaddr,
     in: posix.sockaddr.in,
diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index 6031b1b2987fba99b77f27820d35aae3581f8fe4..843c1a0c3c179d9d7562190986fc8e75d44fd558 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -752,6 +752,7 @@ pub fn io(ev: *Evented) Io {
             .unlockStderr = unlockStderr,
             .processCurrentPath = processCurrentPath,
             .processSetCurrentDir = processSetCurrentDir,
+            .processSetCurrentPath = processSetCurrentPath,
             .processReplace = processReplace,
             .processReplacePath = processReplacePath,
             .processSpawn = processSpawn,
@@ -4176,7 +4177,7 @@ fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirEr
     return fchdir(&sync, dir.handle);
 }
 
-fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) ChdirError!void {
+fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) process.SetCurrentPathError!void {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     var path_buffer: [PATH_MAX]u8 = undefined;
     const dir_path_posix = try pathToPosix(dir_path, &path_buffer);
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 701eb434b5cf918bfcbdf145ffc764881f775d54..857a79dd934ef24ce0376ef2296e85a0dc2995cb 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -900,6 +900,35 @@ pub fn setCurrentDir(io: Io, dir: Io.Dir) !void {
     return io.vtable.processSetCurrentDir(io.userdata, dir);
 }
 
+pub const SetCurrentPathError = error{
+    AccessDenied,
+    SymLinkLoop,
+    SystemResources,
+    BadPathName,
+    FileNotFound,
+    FileSystem,
+    NoDevice,
+    NotDir,
+    NameTooLong,
+    OperationUnsupported,
+    /// Windows-only. The path is invalid WTF-8.
+    /// https://wtf-8.codeberg.page/
+    InvalidWtf8,
+} || Io.Cancelable || Io.UnexpectedError;
+
+/// Changes the current working directory to the given path.
+/// Corresponds to "chdir" in libc.
+///
+/// This modifies global process state and can have surprising effects in
+/// multithreaded applications. Most applications and especially libraries
+/// should not call this function as a general rule, however it can have use
+/// cases in, for example, implementing a shell, or child process execution.
+///
+/// Calling this function makes code less portable and less reusable.
+pub fn setCurrentPath(io: Io, path: []const u8) !void {
+    return io.vtable.processSetCurrentPath(io.userdata, path);
+}
+
 pub const LockMemoryError = error{
     UnsupportedOperation,
     PermissionDenied,
diff --git a/test/standalone/posix/cwd.zig b/test/standalone/posix/cwd.zig
index 2588bde34f018f97b2ef799d2809ef7872a3b7df..56b4f1ba70fb656d4129b79a5dcc20d50071fc28 100644
--- a/test/standalone/posix/cwd.zig
+++ b/test/standalone/posix/cwd.zig
@@ -37,7 +37,7 @@ fn test_chdir_self(io: Io) !void {
     const old_cwd = old_cwd_buf[0..try std.process.currentPath(io, &old_cwd_buf)];
 
     // Try changing to the current directory
-    try std.Io.Threaded.chdir(old_cwd);
+    try std.process.setCurrentPath(io, old_cwd);
     try expect_cwd(io, old_cwd);
 }
 
@@ -48,7 +48,7 @@ fn test_chdir_absolute(io: Io) !void {
     const parent = std.fs.path.dirname(old_cwd) orelse unreachable; // old_cwd should be absolute
 
     // Try changing to the parent via a full path
-    try std.Io.Threaded.chdir(parent);
+    try std.process.setCurrentPath(io, parent);
 
     try expect_cwd(io, parent);
 }
@@ -68,7 +68,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
     defer gpa.free(expected_path);
 
     // change current working directory to new test directory
-    try std.Io.Threaded.chdir(subdir_path);
+    try std.process.setCurrentPath(io, subdir_path);
 
     var new_cwd_buf: [path_max]u8 = undefined;
     const new_cwd = new_cwd_buf[0..try std.process.currentPath(io, &new_cwd_buf)];
diff --git a/test/standalone/windows_spawn/main.zig b/test/standalone/windows_spawn/main.zig
index ea28900dac55e76b1c971a55cc9206383a902817..853f6125fb299b7e3aacaec34cfbe96ee74c0b5e 100644
--- a/test/standalone/windows_spawn/main.zig
+++ b/test/standalone/windows_spawn/main.zig
@@ -9,8 +9,6 @@ pub fn main(init: std.process.Init) !void {
     const gpa = init.gpa;
     const io = init.io;
     const process_cwd_path = try std.process.currentPathAlloc(io, init.arena.allocator());
-    var initial_process_cwd = try Io.Dir.cwd().openDir(io, ".", .{});
-    defer initial_process_cwd.close(io);
 
     var it = try init.minimal.args.iterateAllocator(gpa);
     defer it.deinit();
@@ -127,7 +125,7 @@ pub fn main(init: std.process.Init) !void {
 
     // Now let's set the tmp dir as the cwd and set the path only include the "something" sub dir
     try std.process.setCurrentDir(io, tmp_dir);
-    defer std.process.setCurrentDir(io, initial_process_cwd) catch {};
+    defer std.process.setCurrentPath(io, process_cwd_path) catch {};
     const something_subdir_abs_path = try std.mem.concatWithSentinel(gpa, u16, &.{ tmp_absolute_path_w, utf16Literal("\\something") }, 0);
     defer gpa.free(something_subdir_abs_path);
 
-- 
2.54.0


From be0f188990d8aedc3f5bea5c9ab436a7f778d59d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 2 Feb 2026 00:05:51 -0800
Subject: [PATCH 397/499] std.Io: move netReceive to become an Operation

Notably, the timeout becomes provided by the general-purpose Batch API
rather than being special-purposed.
---
 lib/std/Io.zig          |  46 ++++++++-
 lib/std/Io/Threaded.zig | 206 +++++++++++++++++-----------------------
 lib/std/Io/net.zig      |  37 +++-----
 3 files changed, 145 insertions(+), 144 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 932879c99e82b8e7a375148d92a99d05818ea641..87f342f640316343440e5f93e2c1924b81a51c6e 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -243,7 +243,6 @@ pub const VTable = struct {
     netConnectUnix: *const fn (?*anyopaque, *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle,
     netSocketCreatePair: *const fn (?*anyopaque, net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket,
     netSend: *const fn (?*anyopaque, net.Socket.Handle, []net.OutgoingMessage, net.SendFlags) struct { ?net.Socket.SendError, usize },
-    netReceive: *const fn (?*anyopaque, net.Socket.Handle, message_buffer: []net.IncomingMessage, data_buffer: []u8, net.ReceiveFlags, Timeout) struct { ?net.Socket.ReceiveTimeoutError, usize },
     /// Returns 0 on end of stream.
     netRead: *const fn (?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize,
     netWrite: *const fn (?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize,
@@ -261,6 +260,7 @@ pub const Operation = union(enum) {
     /// On Windows this is NtDeviceIoControlFile. On POSIX this is ioctl. On
     /// other systems this tag is unreachable.
     device_io_control: DeviceIoControl,
+    net_receive: NetReceive,
 
     pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
@@ -350,6 +350,35 @@ pub const Operation = union(enum) {
         },
     };
 
+    pub const NetReceive = struct {
+        socket_handle: net.Socket.Handle,
+        message_buffer: []net.IncomingMessage,
+        data_buffer: []u8,
+        flags: net.ReceiveFlags,
+
+        pub const Error = error{
+            /// Insufficient memory or other resource internal to the operating system.
+            SystemResources,
+            /// Per-process limit on the number of open file descriptors has been reached.
+            ProcessFdQuotaExceeded,
+            /// System-wide limit on the total number of open files has been reached.
+            SystemFdQuotaExceeded,
+            /// Local end has been shut down on a connection-oriented socket, or
+            /// the socket was never connected.
+            SocketUnconnected,
+            /// The socket type requires that message be sent atomically, and the
+            /// size of the message to be sent made this impossible. The message
+            /// was not transmitted, or was partially transmitted.
+            MessageOversize,
+            /// Network connection was unexpectedly closed by sender.
+            ConnectionResetByPeer,
+            /// The local network interface used to reach the destination is offline.
+            NetworkDown,
+        } || Io.UnexpectedError;
+
+        pub const Result = struct { ?net.Socket.ReceiveError, usize };
+    };
+
     pub const Result = Result: {
         const operation_fields = @typeInfo(Operation).@"union".fields;
         var field_names: [operation_fields.len][]const u8 = undefined;
@@ -417,6 +446,19 @@ pub fn operate(io: Io, operation: Operation) Cancelable!Operation.Result {
     return io.vtable.operate(io.userdata, operation);
 }
 
+pub const OperateTimeoutError = Cancelable || Timeout.Error || ConcurrentError;
+
+/// Performs one `Operation` with provided `timeout`.
+pub fn operateTimeout(io: Io, operation: Operation, timeout: Timeout) OperateTimeoutError!Operation.Result {
+    var storage: [1]Operation.Storage = undefined;
+    var batch: Batch = .init(&storage);
+    batch.addAt(0, operation);
+    try batch.awaitConcurrent(io, timeout);
+    const completion = batch.next().?;
+    assert(completion.index == 0);
+    return completion.result;
+}
+
 /// Submits many operations together without waiting for all of them to
 /// complete.
 ///
@@ -1716,7 +1758,7 @@ pub const Event = enum(u32) {
     }
 
     /// Blocks until the logical boolean is `true`.
-    pub fn wait(event: *Event, io: Io) Io.Cancelable!void {
+    pub fn wait(event: *Event, io: Io) Cancelable!void {
         if (@cmpxchgStrong(Event, event, .unset, .waiting, .acquire, .acquire)) |prev| switch (prev) {
             .unset => unreachable,
             .waiting => {},
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index ca658f0569d7818949293c4b54748865eeef5e02..07d963b292ce0e2d449b212b61a130b75ec56901 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -61,7 +61,7 @@ disable_memory_mapping: bool,
 
 stderr_writer: File.Writer = .{
     .io = undefined,
-    .interface = Io.File.Writer.initInterface(&.{}),
+    .interface = File.Writer.initInterface(&.{}),
     .file = if (is_windows) undefined else .stderr(),
     .mode = .streaming,
 },
@@ -160,7 +160,7 @@ pub const Environ = struct {
         },
     };
 
-    pub fn scan(environ: *Environ, allocator: std.mem.Allocator) void {
+    pub fn scan(environ: *Environ, allocator: Allocator) void {
         if (is_windows) {
             // This value expires with any call that modifies the environment,
             // which is outside of this Io implementation's control, so references
@@ -1901,10 +1901,6 @@ pub fn io(t: *Threaded) Io {
                 .windows => netSendWindows,
                 else => netSendPosix,
             },
-            .netReceive = switch (native_os) {
-                .windows => netReceiveWindows,
-                else => netReceivePosix,
-            },
             .netInterfaceNameResolve = netInterfaceNameResolve,
             .netInterfaceName = netInterfaceName,
             .netLookup = netLookup,
@@ -2037,7 +2033,6 @@ pub fn ioBasic(t: *Threaded) Io {
             .netWrite = netWriteUnavailable,
             .netWriteFile = netWriteFileUnavailable,
             .netSend = netSendUnavailable,
-            .netReceive = netReceiveUnavailable,
             .netInterfaceNameResolve = netInterfaceNameResolveUnavailable,
             .netInterfaceName = netInterfaceNameUnavailable,
             .netLookup = netLookupUnavailable,
@@ -2638,6 +2633,15 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
             },
         },
         .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
+        .net_receive => |*o| return .{ .net_receive = o: {
+            if (!have_networking) break :o .{ error.NetworkDown, 0 };
+            if (is_windows) break :o netReceiveWindows(t, o.socket_handle, o.message_buffer, o.data_buffer, o.flags);
+            netReceivePosix(o.socket_handle, &o.message_buffer[0], o.data_buffer, o.flags) catch |err| switch (err) {
+                error.Canceled => |e| return e,
+                else => |e| break :o .{ e, 0 },
+            };
+            break :o .{ null, 1 };
+        } },
     }
 }
 
@@ -2662,11 +2666,19 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                 const submission = &b.storage[index.toIndex()].submission;
                 switch (submission.operation) {
                     .file_read_streaming => |o| {
-                        poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.IN, .revents = 0 };
+                        poll_buffer[poll_len] = .{
+                            .fd = o.file.handle,
+                            .events = posix.POLL.IN | posix.POLL.ERR,
+                            .revents = 0,
+                        };
                         poll_len += 1;
                     },
                     .file_write_streaming => |o| {
-                        poll_buffer[poll_len] = .{ .fd = o.file.handle, .events = posix.POLL.OUT, .revents = 0 };
+                        poll_buffer[poll_len] = .{
+                            .fd = o.file.handle,
+                            .events = posix.POLL.OUT | posix.POLL.ERR,
+                            .revents = 0,
+                        };
                         poll_len += 1;
                     },
                     .device_io_control => |o| {
@@ -2677,6 +2689,14 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
                         };
                         poll_len += 1;
                     },
+                    .net_receive => |*o| {
+                        poll_buffer[poll_len] = .{
+                            .fd = o.socket_handle,
+                            .events = posix.POLL.IN | posix.POLL.ERR,
+                            .revents = 0,
+                        };
+                        poll_len += 1;
+                    },
                 }
                 index = submission.node.next;
             }
@@ -2796,12 +2816,12 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     if (!have_poll) return error.ConcurrencyUnavailable;
     var poll_buffer: [poll_buffer_len]posix.pollfd = undefined;
     var poll_storage: struct {
-        gpa: std.mem.Allocator,
+        gpa: Allocator,
         batch: *Io.Batch,
         slice: []posix.pollfd,
         len: u32,
 
-        fn add(storage: *@This(), file: Io.File, events: @FieldType(posix.pollfd, "events")) Io.ConcurrentError!void {
+        fn add(storage: *@This(), fd: File.Handle, events: @FieldType(posix.pollfd, "events")) Io.ConcurrentError!void {
             const len = storage.len;
             if (len == poll_buffer_len) {
                 const slice: []posix.pollfd = if (storage.batch.userdata) |batch_userdata|
@@ -2816,7 +2836,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
                 storage.slice = slice;
             }
             storage.slice[len] = .{
-                .fd = file.handle,
+                .fd = fd,
                 .events = events,
                 .revents = 0,
             };
@@ -2828,9 +2848,10 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         while (index != .none) {
             const submission = &b.storage[index.toIndex()].submission;
             switch (submission.operation) {
-                .file_read_streaming => |o| try poll_storage.add(o.file, posix.POLL.IN),
-                .file_write_streaming => |o| try poll_storage.add(o.file, posix.POLL.OUT),
-                .device_io_control => |o| try poll_storage.add(o.file, posix.POLL.IN | posix.POLL.OUT | posix.POLL.ERR),
+                .file_read_streaming => |o| try poll_storage.add(o.file.handle, posix.POLL.IN | posix.POLL.ERR),
+                .file_write_streaming => |o| try poll_storage.add(o.file.handle, posix.POLL.OUT | posix.POLL.ERR),
+                .device_io_control => |o| try poll_storage.add(o.file.handle, posix.POLL.IN | posix.POLL.OUT | posix.POLL.ERR),
+                .net_receive => |o| try poll_storage.add(o.socket_handle, posix.POLL.IN | posix.POLL.ERR),
             }
             index = submission.node.next;
         }
@@ -3000,6 +3021,7 @@ fn batchApc(
                 .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
                 .file_write_streaming => .{ .file_write_streaming = ntWriteFileResult(iosb) },
                 .device_io_control => .{ .device_io_control = iosb.* },
+                .net_receive => unreachable, // TODO
             };
             storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
         },
@@ -3201,6 +3223,11 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                     };
                 }
             },
+            .net_receive => |o| {
+                if (concurrency) return error.ConcurrencyUnavailable;
+                _ = o;
+                @panic("TODO implement Batch NetReceive on Windows");
+            },
         }
         index = submission.node.next;
     }
@@ -13190,70 +13217,42 @@ fn netSendMany(
 }
 
 fn netReceivePosix(
-    userdata: ?*anyopaque,
-    handle: net.Socket.Handle,
-    message_buffer: []net.IncomingMessage,
+    socket_handle: net.Socket.Handle,
+    message: *net.IncomingMessage,
     data_buffer: []u8,
     flags: net.ReceiveFlags,
-    timeout: Io.Timeout,
-) struct { ?net.Socket.ReceiveTimeoutError, usize } {
-    if (!have_networking) return .{ error.NetworkDown, 0 };
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const t_io = io(t);
-
+) net.Socket.ReceiveError!void {
     // recvmmsg is useless, here's why:
     // * [timeout bug](https://bugzilla.kernel.org/show_bug.cgi?id=75371)
     // * it wants iovecs for each message but we have a better API: one data
     //   buffer to handle all the messages. The better API cannot be lowered to
     //   the split vectors though because reducing the buffer size might make
     //   some messages unreceivable.
-
-    // So the strategy instead is to use non-blocking recvmsg calls, calling
-    // poll() with timeout if the first one returns EAGAIN.
     const posix_flags: u32 =
         @as(u32, if (flags.oob) posix.MSG.OOB else 0) |
         @as(u32, if (flags.peek) posix.MSG.PEEK else 0) |
         @as(u32, if (flags.trunc) posix.MSG.TRUNC else 0) |
-        posix.MSG.DONTWAIT | posix.MSG.NOSIGNAL;
+        posix.MSG.NOSIGNAL;
 
-    var poll_fds: [1]posix.pollfd = .{
-        .{
-            .fd = handle,
-            .events = posix.POLL.IN,
-            .revents = undefined,
-        },
+    var storage: PosixAddress = undefined;
+    var iov: posix.iovec = .{ .base = data_buffer.ptr, .len = data_buffer.len };
+    var msg: posix.msghdr = .{
+        .name = &storage.any,
+        .namelen = @sizeOf(PosixAddress),
+        .iov = (&iov)[0..1],
+        .iovlen = 1,
+        .control = message.control.ptr,
+        .controllen = @intCast(message.control.len),
+        .flags = undefined,
     };
-    var message_i: usize = 0;
-    var data_i: usize = 0;
 
-    const deadline = timeout.toTimestamp(t_io);
-
-    recv: while (true) {
-        if (message_buffer.len - message_i == 0) return .{ null, message_i };
-        const message = &message_buffer[message_i];
-        const remaining_data_buffer = data_buffer[data_i..];
-        var storage: PosixAddress = undefined;
-        var iov: posix.iovec = .{ .base = remaining_data_buffer.ptr, .len = remaining_data_buffer.len };
-        var msg: posix.msghdr = .{
-            .name = &storage.any,
-            .namelen = @sizeOf(PosixAddress),
-            .iov = (&iov)[0..1],
-            .iovlen = 1,
-            .control = message.control.ptr,
-            .controllen = @intCast(message.control.len),
-            .flags = undefined,
-        };
-
-        const recv_rc = rc: {
-            const syscall = Syscall.start() catch |err| return .{ err, message_i };
-            const rc = posix.system.recvmsg(handle, &msg, posix_flags);
-            syscall.finish();
-            break :rc rc;
-        };
-        switch (posix.errno(recv_rc)) {
+    const syscall = try Syscall.start();
+    while (true) {
+        const rc = posix.system.recvmsg(socket_handle, &msg, posix_flags);
+        switch (posix.errno(rc)) {
             .SUCCESS => {
-                const data = remaining_data_buffer[0..@intCast(recv_rc)];
-                data_i += data.len;
+                syscall.finish();
+                const data = data_buffer[0..@intCast(rc)];
                 message.* = .{
                     .from = addressFromPosix(&storage),
                     .data = data,
@@ -13266,78 +13265,45 @@ fn netReceivePosix(
                         .errqueue = if (@hasDecl(posix.MSG, "ERRQUEUE")) (msg.flags & posix.MSG.ERRQUEUE) != 0 else false,
                     },
                 };
-                message_i += 1;
+                return;
+            },
+            .INTR => {
+                try syscall.checkCancel();
                 continue;
             },
-            .AGAIN => while (true) {
-                if (message_i != 0) return .{ null, message_i };
-
-                const max_poll_ms = std.math.maxInt(u31);
-                const timeout_ms: u31 = if (deadline) |d| t: {
-                    const duration = d.durationFromNow(t_io);
-                    if (duration.raw.nanoseconds <= 0) return .{ error.Timeout, message_i };
-                    break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
-                } else max_poll_ms;
-
-                const syscall = Syscall.start() catch |err| return .{ err, message_i };
-                const poll_rc = posix.system.poll(&poll_fds, poll_fds.len, timeout_ms);
-                syscall.finish();
-
-                switch (posix.errno(poll_rc)) {
-                    .SUCCESS => {
-                        if (poll_rc == 0) {
-                            // Although spurious timeouts are OK, when no deadline
-                            // is passed we must not return `error.Timeout`.
-                            if (deadline == null) continue;
-                            return .{ error.Timeout, message_i };
-                        }
-                        continue :recv;
-                    },
-                    .INTR => continue,
-
-                    .FAULT => |err| return .{ errnoBug(err), message_i },
-                    .INVAL => |err| return .{ errnoBug(err), message_i },
-                    .NOMEM => return .{ error.SystemResources, message_i },
-                    else => |err| return .{ posix.unexpectedErrno(err), message_i },
-                }
-            },
-            .INTR => continue,
-
-            .BADF => |err| return .{ errnoBug(err), message_i },
-            .NFILE => return .{ error.SystemFdQuotaExceeded, message_i },
-            .MFILE => return .{ error.ProcessFdQuotaExceeded, message_i },
-            .FAULT => |err| return .{ errnoBug(err), message_i },
-            .INVAL => |err| return .{ errnoBug(err), message_i },
-            .NOBUFS => return .{ error.SystemResources, message_i },
-            .NOMEM => return .{ error.SystemResources, message_i },
-            .NOTCONN => return .{ error.SocketUnconnected, message_i },
-            .NOTSOCK => |err| return .{ errnoBug(err), message_i },
-            .MSGSIZE => return .{ error.MessageOversize, message_i },
-            .PIPE => return .{ error.SocketUnconnected, message_i },
-            .OPNOTSUPP => |err| return .{ errnoBug(err), message_i },
-            .CONNRESET => return .{ error.ConnectionResetByPeer, message_i },
-            .NETDOWN => return .{ error.NetworkDown, message_i },
-            else => |err| return .{ posix.unexpectedErrno(err), message_i },
+            .NFILE => return syscall.fail(error.SystemFdQuotaExceeded),
+            .MFILE => return syscall.fail(error.ProcessFdQuotaExceeded),
+            .NOBUFS => return syscall.fail(error.SystemResources),
+            .NOMEM => return syscall.fail(error.SystemResources),
+            .NOTCONN => return syscall.fail(error.SocketUnconnected),
+            .MSGSIZE => return syscall.fail(error.MessageOversize),
+            .PIPE => return syscall.fail(error.SocketUnconnected),
+            .CONNRESET => return syscall.fail(error.ConnectionResetByPeer),
+            .NETDOWN => return syscall.fail(error.NetworkDown),
+            .AGAIN => |err| return syscall.errnoBug(err),
+            .BADF => |err| return syscall.errnoBug(err),
+            .FAULT => |err| return syscall.errnoBug(err),
+            .INVAL => |err| return syscall.errnoBug(err),
+            .NOTSOCK => |err| return syscall.errnoBug(err),
+            .OPNOTSUPP => |err| return syscall.errnoBug(err),
+            else => |err| return syscall.unexpectedErrno(err),
         }
     }
 }
 
 fn netReceiveWindows(
-    userdata: ?*anyopaque,
-    handle: net.Socket.Handle,
+    t: *Threaded,
+    socket_handle: net.Socket.Handle,
     message_buffer: []net.IncomingMessage,
     data_buffer: []u8,
     flags: net.ReceiveFlags,
-    timeout: Io.Timeout,
-) struct { ?net.Socket.ReceiveTimeoutError, usize } {
+) struct { ?net.Socket.ReceiveError, usize } {
     if (!have_networking) return .{ error.NetworkDown, 0 };
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
-    _ = handle;
+    _ = socket_handle;
     _ = message_buffer;
     _ = data_buffer;
     _ = flags;
-    _ = timeout;
     @panic("TODO implement netReceiveWindows");
 }
 
diff --git a/lib/std/Io/net.zig b/lib/std/Io/net.zig
index 51a8d6647bd80bd28d37ffc43e725e38cfdc89d4..7a49996ff818fa3ea25b4941a99e28a5a404301c 100644
--- a/lib/std/Io/net.zig
+++ b/lib/std/Io/net.zig
@@ -1109,25 +1109,7 @@ pub const Socket = struct {
         if (n != messages.len) return err.?;
     }
 
-    pub const ReceiveError = error{
-        /// Insufficient memory or other resource internal to the operating system.
-        SystemResources,
-        /// Per-process limit on the number of open file descriptors has been reached.
-        ProcessFdQuotaExceeded,
-        /// System-wide limit on the total number of open files has been reached.
-        SystemFdQuotaExceeded,
-        /// Local end has been shut down on a connection-oriented socket, or
-        /// the socket was never connected.
-        SocketUnconnected,
-        /// The socket type requires that message be sent atomically, and the
-        /// size of the message to be sent made this impossible. The message
-        /// was not transmitted, or was partially transmitted.
-        MessageOversize,
-        /// Network connection was unexpectedly closed by sender.
-        ConnectionResetByPeer,
-        /// The local network interface used to reach the destination is offline.
-        NetworkDown,
-    } || Io.UnexpectedError || Io.Cancelable;
+    pub const ReceiveError = Io.Operation.NetReceive.Error || Io.Cancelable;
 
     /// Waits for data. Connectionless.
     ///
@@ -1145,7 +1127,7 @@ pub const Socket = struct {
         return message;
     }
 
-    pub const ReceiveTimeoutError = ReceiveError || Io.Timeout.Error;
+    pub const ReceiveTimeoutError = ReceiveError || Io.Timeout.Error || Io.ConcurrentError;
 
     /// Waits for data. Connectionless.
     ///
@@ -1161,7 +1143,12 @@ pub const Socket = struct {
         timeout: Io.Timeout,
     ) ReceiveTimeoutError!IncomingMessage {
         var message: IncomingMessage = .init;
-        const maybe_err, const count = io.vtable.netReceive(io.userdata, s.handle, (&message)[0..1], buffer, .{}, timeout);
+        const maybe_err, const count = (try io.operateTimeout(.{ .net_receive = .{
+            .socket = s.handle,
+            .message_buffer = (&message)[0..1],
+            .data_buffer = buffer,
+            .flags = .{},
+        } }, timeout)).net_receive;
         if (maybe_err) |err| return err;
         assert(1 == count);
         return message;
@@ -1186,7 +1173,13 @@ pub const Socket = struct {
         flags: ReceiveFlags,
         timeout: Io.Timeout,
     ) struct { ?ReceiveTimeoutError, usize } {
-        return io.vtable.netReceive(io.userdata, s.handle, message_buffer, data_buffer, flags, timeout);
+        const result = io.operateTimeout(.{ .net_receive = .{
+            .socket_handle = s.handle,
+            .message_buffer = message_buffer,
+            .data_buffer = data_buffer,
+            .flags = flags,
+        } }, timeout) catch |err| return .{ err, 0 };
+        return result.net_receive;
     }
 
     pub const CreatePairError = error{
-- 
2.54.0


From 8b69341271db18a03a4aa7400a4c6679c5fbf5c6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Mar 2026 16:34:16 -0800
Subject: [PATCH 398/499] std.Io.Threaded: optimize batchAwaitConcurrent for
 net_receive

Eagerly receive messages with MSG_DONTWAIT before polling. This makes
the DNS resolution use case end up doing:

recvmsg (EAGAIN)
poll
recvmsg (success)
recvmsg (success)

rather than:

poll
recvmsg (success)
poll
recvmsg (success)
---
 lib/std/Io/Threaded.zig | 39 ++++++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 07d963b292ce0e2d449b212b61a130b75ec56901..e74450aa80f2a8be3d9005e6b514cdfac8ba4c16 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2636,8 +2636,9 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
         .net_receive => |*o| return .{ .net_receive = o: {
             if (!have_networking) break :o .{ error.NetworkDown, 0 };
             if (is_windows) break :o netReceiveWindows(t, o.socket_handle, o.message_buffer, o.data_buffer, o.flags);
-            netReceivePosix(o.socket_handle, &o.message_buffer[0], o.data_buffer, o.flags) catch |err| switch (err) {
+            netReceivePosix(o.socket_handle, &o.message_buffer[0], o.data_buffer, o.flags, false) catch |err| switch (err) {
                 error.Canceled => |e| return e,
+                error.WouldBlock => unreachable,
                 else => |e| break :o .{ e, 0 },
             };
             break :o .{ null, 1 };
@@ -2846,19 +2847,41 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     {
         var index = b.submitted.head;
         while (index != .none) {
-            const submission = &b.storage[index.toIndex()].submission;
+            const storage = &b.storage[index.toIndex()];
+            const submission = storage.submission;
             switch (submission.operation) {
                 .file_read_streaming => |o| try poll_storage.add(o.file.handle, posix.POLL.IN | posix.POLL.ERR),
                 .file_write_streaming => |o| try poll_storage.add(o.file.handle, posix.POLL.OUT | posix.POLL.ERR),
                 .device_io_control => |o| try poll_storage.add(o.file.handle, posix.POLL.IN | posix.POLL.OUT | posix.POLL.ERR),
-                .net_receive => |o| try poll_storage.add(o.socket_handle, posix.POLL.IN | posix.POLL.ERR),
+                .net_receive => |*o| nb: {
+                    var data_i: usize = 0;
+                    const result: Io.Operation.Result = .{ .net_receive = for (o.message_buffer, 0..) |*msg, msg_i| {
+                        const remaining_data_buffer = o.data_buffer[data_i..];
+                        netReceivePosix(o.socket_handle, msg, remaining_data_buffer, o.flags, true) catch |err| switch (err) {
+                            error.Canceled => |e| return e,
+                            error.WouldBlock => {
+                                if (msg_i != 0) break .{ null, msg_i };
+                                try poll_storage.add(o.socket_handle, posix.POLL.IN | posix.POLL.ERR);
+                                break :nb;
+                            },
+                            else => |e| break .{ e, 0 },
+                        };
+                        data_i += msg.data.len;
+                    } else .{ null, o.message_buffer.len } };
+                    switch (b.completed.tail) {
+                        .none => b.completed.head = index,
+                        else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
+                    }
+                    storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+                    b.completed.tail = index;
+                },
             }
             index = submission.node.next;
         }
     }
     switch (poll_storage.len) {
         0 => return,
-        1 => if (timeout == .none) {
+        1 => if (timeout == .none and b.completed.head == .none) {
             const index = b.submitted.head;
             const storage = &b.storage[index.toIndex()];
             const result = try operate(t, storage.submission.operation);
@@ -13221,7 +13244,8 @@ fn netReceivePosix(
     message: *net.IncomingMessage,
     data_buffer: []u8,
     flags: net.ReceiveFlags,
-) net.Socket.ReceiveError!void {
+    nonblocking: bool,
+) (net.Socket.ReceiveError || error{WouldBlock})!void {
     // recvmmsg is useless, here's why:
     // * [timeout bug](https://bugzilla.kernel.org/show_bug.cgi?id=75371)
     // * it wants iovecs for each message but we have a better API: one data
@@ -13232,7 +13256,8 @@ fn netReceivePosix(
         @as(u32, if (flags.oob) posix.MSG.OOB else 0) |
         @as(u32, if (flags.peek) posix.MSG.PEEK else 0) |
         @as(u32, if (flags.trunc) posix.MSG.TRUNC else 0) |
-        posix.MSG.NOSIGNAL;
+        posix.MSG.NOSIGNAL |
+        @as(u32, if (nonblocking) posix.MSG.DONTWAIT else 0);
 
     var storage: PosixAddress = undefined;
     var iov: posix.iovec = .{ .base = data_buffer.ptr, .len = data_buffer.len };
@@ -13280,7 +13305,7 @@ fn netReceivePosix(
             .PIPE => return syscall.fail(error.SocketUnconnected),
             .CONNRESET => return syscall.fail(error.ConnectionResetByPeer),
             .NETDOWN => return syscall.fail(error.NetworkDown),
-            .AGAIN => |err| return syscall.errnoBug(err),
+            .AGAIN => return syscall.fail(error.WouldBlock),
             .BADF => |err| return syscall.errnoBug(err),
             .FAULT => |err| return syscall.errnoBug(err),
             .INVAL => |err| return syscall.errnoBug(err),
-- 
2.54.0


From c2ebbd8911d7eec337203bd1de1fd2f3a59273c8 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Mar 2026 17:46:07 -0800
Subject: [PATCH 399/499] std.Io.Threaded: implement net_receive for Windows

---
 lib/std/Io/Threaded.zig       | 131 ++++++++++++++++++++++++++++++----
 lib/std/os/windows/ws2_32.zig |  23 +++---
 2 files changed, 130 insertions(+), 24 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index e74450aa80f2a8be3d9005e6b514cdfac8ba4c16..cc83d6710c106abbc0cd19fc0cca556b62f849e8 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -2649,7 +2649,7 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
 fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
-        batchDrainSubmittedWindows(b, false) catch |err| switch (err) {
+        batchDrainSubmittedWindows(t, b, false) catch |err| switch (err) {
             error.ConcurrencyUnavailable => unreachable, // passed concurrency=false
             else => |e| return e,
         };
@@ -2789,7 +2789,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
         const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(ioBasic(t));
-        try batchDrainSubmittedWindows(b, true);
+        try batchDrainSubmittedWindows(t, b, true);
         while (b.pending.head != .none and b.completed.head == .none) {
             var delay_interval: windows.LARGE_INTEGER = interval: {
                 const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
@@ -3005,6 +3005,31 @@ fn batchCancel(userdata: ?*anyopaque, b: *Io.Batch) void {
     }
 }
 
+fn batchCompleteBlockingWindows(
+    b: *Io.Batch,
+    operation_userdata: *WindowsBatchOperationUserdata,
+    result: Io.Operation.Result,
+) void {
+    const erased_userdata = operation_userdata.toErased();
+    const pending: *Io.Operation.Storage.Pending = @fieldParentPtr("userdata", erased_userdata);
+    switch (pending.node.prev) {
+        .none => b.pending.head = pending.node.next,
+        else => |prev_index| b.storage[prev_index.toIndex()].pending.node.next = pending.node.next,
+    }
+    switch (pending.node.next) {
+        .none => b.pending.tail = pending.node.prev,
+        else => |next_index| b.storage[next_index.toIndex()].pending.node.prev = pending.node.prev,
+    }
+    const storage: *Io.Operation.Storage = @fieldParentPtr("pending", pending);
+    const index: Io.Operation.OptionalIndex = .fromIndex(storage - b.storage.ptr);
+    switch (b.completed.tail) {
+        .none => b.completed.head = index,
+        else => |tail_index| b.storage[tail_index.toIndex()].completion.node.next = index,
+    }
+    b.completed.tail = index;
+    storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
+}
+
 fn batchApc(
     apc_context: ?*anyopaque,
     iosb: *windows.IO_STATUS_BLOCK,
@@ -3044,7 +3069,7 @@ fn batchApc(
                 .file_read_streaming => .{ .file_read_streaming = ntReadFileResult(iosb) },
                 .file_write_streaming => .{ .file_write_streaming = ntWriteFileResult(iosb) },
                 .device_io_control => .{ .device_io_control = iosb.* },
-                .net_receive => unreachable, // TODO
+                .net_receive => unreachable,
             };
             storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
         },
@@ -3052,7 +3077,7 @@ fn batchApc(
 }
 
 /// If `concurrency` is false, `error.ConcurrencyUnavailable` is unreachable.
-fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentError || Io.Cancelable)!void {
+fn batchDrainSubmittedWindows(t: *Threaded, b: *Io.Batch, concurrency: bool) (Io.ConcurrentError || Io.Cancelable)!void {
     var index = b.submitted.head;
     errdefer b.submitted.head = index;
     while (index != .none) {
@@ -3246,10 +3271,12 @@ fn batchDrainSubmittedWindows(b: *Io.Batch, concurrency: bool) (Io.ConcurrentErr
                     };
                 }
             },
-            .net_receive => |o| {
+            .net_receive => |*o| {
+                // TODO integrate with overlapped I/O or equivalent to avoid this error
                 if (concurrency) return error.ConcurrencyUnavailable;
-                _ = o;
-                @panic("TODO implement Batch NetReceive on Windows");
+                batchCompleteBlockingWindows(b, operation_userdata, .{
+                    .net_receive = netReceiveWindows(t, o.socket_handle, o.message_buffer, o.data_buffer, o.flags),
+                });
             },
         }
         index = submission.node.next;
@@ -13323,13 +13350,89 @@ fn netReceiveWindows(
     data_buffer: []u8,
     flags: net.ReceiveFlags,
 ) struct { ?net.Socket.ReceiveError, usize } {
-    if (!have_networking) return .{ error.NetworkDown, 0 };
-    _ = t;
-    _ = socket_handle;
-    _ = message_buffer;
-    _ = data_buffer;
-    _ = flags;
-    @panic("TODO implement netReceiveWindows");
+    netReceiveWindowsOne(t, socket_handle, &message_buffer[0], data_buffer, flags) catch |err| return .{ err, 0 };
+    return .{ null, 1 };
+}
+
+fn netReceiveWindowsOne(
+    t: *Threaded,
+    socket_handle: net.Socket.Handle,
+    message: *net.IncomingMessage,
+    data_buffer: []u8,
+    flags: net.ReceiveFlags,
+) net.Socket.ReceiveError!void {
+    comptime assert(have_networking);
+
+    var windows_flags: u32 =
+        @as(u32, if (flags.oob) ws2_32.MSG.OOB else 0) |
+        @as(u32, if (flags.peek) ws2_32.MSG.PEEK else 0) |
+        @as(u32, if (flags.trunc) ws2_32.MSG.TRUNC else 0);
+
+    var buf: ws2_32.WSABUF = .{
+        .buf = data_buffer.ptr,
+        .len = std.math.cast(u32, data_buffer.len) orelse return error.MessageOversize,
+    };
+    var n: u32 = undefined;
+    var syscall: Syscall = try .start();
+    var from_storage: WsaAddress = undefined;
+    var from_storage_len: i32 = @sizeOf(WsaAddress);
+
+    while (true) {
+        const rc = ws2_32.WSARecvFrom(
+            socket_handle,
+            (&buf)[0..1],
+            1,
+            &n,
+            &windows_flags,
+            &from_storage.any,
+            &from_storage_len,
+            null,
+            null,
+        );
+        if (rc != ws2_32.SOCKET_ERROR) {
+            syscall.finish();
+            message.* = .{
+                .from = addressFromWsa(&from_storage),
+                .data = data_buffer[0..n],
+                .control = &.{},
+                .flags = .{
+                    .eor = false,
+                    .trunc = (windows_flags & ws2_32.MSG.TRUNC) != 0,
+                    .ctrunc = (windows_flags & ws2_32.MSG.CTRUNC) != 0,
+                    .oob = false,
+                    .errqueue = false,
+                },
+            };
+            return;
+        }
+        switch (ws2_32.WSAGetLastError()) {
+            .EINTR, .ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .NOTINITIALISED => {
+                syscall.finish();
+                try initializeWsa(t);
+                syscall = try .start();
+                continue;
+            },
+
+            .ECONNRESET => return syscall.fail(error.ConnectionResetByPeer),
+            .ENETDOWN => return syscall.fail(error.NetworkDown),
+            .ENETRESET => return syscall.fail(error.ConnectionResetByPeer),
+            .ENOTCONN => return syscall.fail(error.SocketUnconnected),
+            .EFAULT => unreachable, // a pointer is not completely contained in user address space.
+
+            else => |err| {
+                syscall.finish();
+                switch (err) {
+                    .EINVAL => return wsaErrorBug(err),
+                    .EMSGSIZE => return wsaErrorBug(err),
+                    else => return windows.unexpectedWSAError(err),
+                }
+            },
+        }
+    }
 }
 
 fn netReceiveUnavailable(
diff --git a/lib/std/os/windows/ws2_32.zig b/lib/std/os/windows/ws2_32.zig
index d5c74e22123056de1719a5d5e433b0047cf5bcf9..0abfe64ec310a04542323e07f8813b6509f859c5 100644
--- a/lib/std/os/windows/ws2_32.zig
+++ b/lib/std/os/windows/ws2_32.zig
@@ -661,17 +661,20 @@ pub const IOC_OUT = 1073741824;
 pub const IOC_IN = 2147483648;
 
 pub const MSG = struct {
-    pub const TRUNC = 256;
-    pub const CTRUNC = 512;
-    pub const BCAST = 1024;
-    pub const MCAST = 2048;
-    pub const ERRQUEUE = 4096;
+    pub const OOB = 0x1;
+    pub const PEEK = 0x2;
+    pub const DONTROUTE = 0x4;
+    pub const WAITALL = 0x8;
+    pub const INTERRUPT = 0x10;
+    pub const PUSH_IMMEDIATE = 0x20;
+
+    pub const TRUNC = 0x0100;
+    pub const CTRUNC = 0x0200;
+    pub const BCAST = 0x0400;
+    pub const MCAST = 0x0800;
+
+    pub const PARTIAL = 0x8000;
 
-    pub const PEEK = 2;
-    pub const WAITALL = 8;
-    pub const PUSH_IMMEDIATE = 32;
-    pub const PARTIAL = 32768;
-    pub const INTERRUPT = 16;
     pub const MAXIOVLEN = 16;
 };
 
-- 
2.54.0


From 4cbf30c2a419df3181b41cb0783e175c54248de2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Mar 2026 18:04:35 -0800
Subject: [PATCH 400/499] std.Io.Uring: implement net_receive operate

Batch implementation still TODO.
---
 lib/std/Io/Threaded.zig | 17 ----------
 lib/std/Io/Uring.zig    | 71 +++++++++++++----------------------------
 2 files changed, 22 insertions(+), 66 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index cc83d6710c106abbc0cd19fc0cca556b62f849e8..1d12f8a55b1a6737c21d9c76f366fdcd01cfe2e7 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -13435,23 +13435,6 @@ fn netReceiveWindowsOne(
     }
 }
 
-fn netReceiveUnavailable(
-    userdata: ?*anyopaque,
-    handle: net.Socket.Handle,
-    message_buffer: []net.IncomingMessage,
-    data_buffer: []u8,
-    flags: net.ReceiveFlags,
-    timeout: Io.Timeout,
-) struct { ?net.Socket.ReceiveTimeoutError, usize } {
-    _ = userdata;
-    _ = handle;
-    _ = message_buffer;
-    _ = data_buffer;
-    _ = flags;
-    _ = timeout;
-    return .{ error.NetworkDown, 0 };
-}
-
 fn netWritePosix(
     userdata: ?*anyopaque,
     fd: net.Socket.Handle,
diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig
index 843c1a0c3c179d9d7562190986fc8e75d44fd558..13c52fc3d7851fa2dd30a0ee572cf53731c9cb55 100644
--- a/lib/std/Io/Uring.zig
+++ b/lib/std/Io/Uring.zig
@@ -777,7 +777,6 @@ pub fn io(ev: *Evented) Io {
             .netConnectUnix = netConnectUnixUnavailable,
             .netSocketCreatePair = netSocketCreatePairUnavailable,
             .netSend = netSendUnavailable,
-            .netReceive = netReceive,
             .netRead = netReadUnavailable,
             .netWrite = netWriteUnavailable,
             .netWriteFile = netWriteFileUnavailable,
@@ -2092,6 +2091,18 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
         .device_io_control => |o| .{
             .device_io_control = try ev.deviceIoControl(try maybe_sync.enterSync(ev), o),
         },
+        .net_receive => |o| .{
+            .net_receive = r: {
+                const opt_err, const n = ev.netReceive(&maybe_sync.cancel_region, o.socket_handle, o.message_buffer, o.data_buffer, o.flags);
+                break :r .{
+                    if (opt_err) |err| switch (err) {
+                        error.Canceled => |e| return e,
+                        else => |e| e,
+                    } else null,
+                    n,
+                };
+            },
+        },
     };
 }
 
@@ -2375,6 +2386,10 @@ fn batchDrainSubmitted(
                 return error.ConcurrencyUnavailable
             else
                 .{ .device_io_control = try ev.deviceIoControl(try maybe_sync.enterSync(ev), o) },
+            .net_receive => |o| {
+                _ = o;
+                @panic("TODO implement batchDrainSubmitted for net_receive");
+            },
         })) |result| {
             switch (batch.completed.tail) {
                 .none => batch.completed.head = index,
@@ -2475,6 +2490,7 @@ fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void {
                     },
                 },
                 .device_io_control => unreachable,
+                .net_receive => @panic("TODO"),
             })) |result| {
                 switch (batch.completed.tail) {
                     .none => batch.completed.head = index,
@@ -5035,37 +5051,16 @@ fn netSendUnavailable(
 }
 
 fn netReceive(
-    userdata: ?*anyopaque,
+    ev: *Evented,
+    cancel_region: *CancelRegion,
     handle: net.Socket.Handle,
     message_buffer: []net.IncomingMessage,
     data_buffer: []u8,
     flags: net.ReceiveFlags,
-    timeout: Io.Timeout,
-) struct { ?net.Socket.ReceiveTimeoutError, usize } {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    const ev_io = ev.io();
-
+) struct { ?net.Socket.ReceiveError, usize } {
     var message_i: usize = 0;
     var data_i: usize = 0;
 
-    const deadline: ?struct {
-        raw: Io.Timestamp,
-        timespec: linux.kernel_timespec,
-        clock: Io.Clock,
-    } = if (timeout.toTimestamp(ev_io)) |deadline| deadline: {
-        const ns = deadline.raw.toNanoseconds();
-        break :deadline .{
-            .raw = deadline.raw,
-            .timespec = .{
-                .sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
-                .nsec = @intCast(@mod(ns, std.time.ns_per_s)),
-            },
-            .clock = deadline.clock,
-        };
-    } else null;
-
-    var cancel_region: CancelRegion = .init();
-    defer cancel_region.deinit();
     while (true) {
         if (message_buffer.len - message_i == 0) return .{ null, message_i };
         const message = &message_buffer[message_i];
@@ -5085,7 +5080,7 @@ fn netReceive(
         const thread = cancel_region.awaitIoUring() catch |err| return .{ err, message_i };
         thread.enqueue().* = .{
             .opcode = .RECVMSG,
-            .flags = if (deadline) |_| linux.IOSQE_IO_LINK else 0,
+            .flags = 0,
             .ioprio = 0,
             .fd = handle,
             .off = 0,
@@ -5102,26 +5097,6 @@ fn netReceive(
             .addr3 = 0,
             .resv = 0,
         };
-        if (deadline) |*deadline_ptr| thread.enqueue().* = .{
-            .opcode = .LINK_TIMEOUT,
-            .flags = linux.IOSQE_CQE_SKIP_SUCCESS,
-            .ioprio = 0,
-            .fd = 0,
-            .off = 0,
-            .addr = @intFromPtr(&deadline_ptr.timespec),
-            .len = 1,
-            .rw_flags = linux.IORING_TIMEOUT_ABS | @as(u32, switch (deadline_ptr.clock) {
-                .real => linux.IORING_TIMEOUT_REALTIME,
-                else => 0,
-                .boot => linux.IORING_TIMEOUT_BOOTTIME,
-            }),
-            .user_data = @intFromEnum(Completion.Userdata.wakeup),
-            .buf_index = 0,
-            .personality = 0,
-            .splice_fd_in = 0,
-            .addr3 = 0,
-            .resv = 0,
-        };
         ev.yield(null, .nothing);
         const completion = cancel_region.completion();
         switch (completion.errno()) {
@@ -5144,9 +5119,7 @@ fn netReceive(
                 continue;
             },
             .AGAIN => unreachable,
-            .INTR, .CANCELED => if (deadline) |d| if (now(ev, d.clock).nanoseconds >= d.raw.nanoseconds)
-                return .{ error.Timeout, message_i },
-
+            .INTR, .CANCELED => {},
             .BADF => |err| return .{ errnoBug(err), message_i },
             .NFILE => return .{ error.SystemFdQuotaExceeded, message_i },
             .MFILE => return .{ error.ProcessFdQuotaExceeded, message_i },
-- 
2.54.0


From dd8de03720588eaaa165da70295e29dd23fe1886 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Mar 2026 18:08:36 -0800
Subject: [PATCH 401/499] std.Io.Dispatch: fix compile errors

---
 lib/std/Io/Dispatch.zig | 22 +++-------------------
 1 file changed, 3 insertions(+), 19 deletions(-)

diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig
index a9bd960a342976cf252681d641cd14ae9c17c77c..1bc5195565c0452ef0363ce561c2609eba4cb5fb 100644
--- a/lib/std/Io/Dispatch.zig
+++ b/lib/std/Io/Dispatch.zig
@@ -459,7 +459,6 @@ pub fn io(ev: *Evented) Io {
             .netConnectUnix = netConnectUnixUnavailable,
             .netSocketCreatePair = netSocketCreatePairUnavailable,
             .netSend = netSendUnavailable,
-            .netReceive = netReceiveUnavailable,
             .netRead = netReadUnavailable,
             .netWrite = netWriteUnavailable,
             .netWriteFile = netWriteFileUnavailable,
@@ -1714,6 +1713,7 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
             },
         },
         .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
+        .net_receive => @panic("TODO implement net_receive operation"),
     }
 }
 
@@ -2134,6 +2134,7 @@ fn batchDrainSubmitted(
                     break :result null;
                 },
                 .device_io_control => {},
+                .net_receive => @panic("TODO implement batched net_receive"),
             };
             if (concurrency) return error.ConcurrencyUnavailable;
             break :result try operate(ev, storage.submission.operation);
@@ -2192,6 +2193,7 @@ fn batchSourceEvent(context: ?*anyopaque) callconv(.c) void {
             } };
         },
         .device_io_control => unreachable,
+        .net_receive => @panic("TODO implement batched net_receive"),
     };
 
     switch (pending.node.prev) {
@@ -4872,24 +4874,6 @@ fn netSendUnavailable(
     return .{ error.NetworkDown, 0 };
 }
 
-fn netReceiveUnavailable(
-    userdata: ?*anyopaque,
-    handle: net.Socket.Handle,
-    message_buffer: []net.IncomingMessage,
-    data_buffer: []u8,
-    flags: net.ReceiveFlags,
-    timeout: Io.Timeout,
-) struct { ?net.Socket.ReceiveTimeoutError, usize } {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = handle;
-    _ = message_buffer;
-    _ = data_buffer;
-    _ = flags;
-    _ = timeout;
-    return .{ error.NetworkDown, 0 };
-}
-
 fn netReadUnavailable(
     userdata: ?*anyopaque,
     fd: net.Socket.Handle,
-- 
2.54.0


From 85ed81bb94ca59da49a128cb6ee5065b130ba06c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 8 Mar 2026 16:12:37 -0700
Subject: [PATCH 402/499] std.Io.Threaded: implement netReceive for Windows

---
 lib/std/Io/Threaded.zig | 75 ++++++++++++++++++++++++++++++++++++++---
 lib/std/Io/net.zig      | 15 +++++----
 2 files changed, 78 insertions(+), 12 deletions(-)

diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 1d12f8a55b1a6737c21d9c76f366fdcd01cfe2e7..81a500e0f980e3d3c14288fe84ca7a815d8c9fac 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -13072,11 +13072,76 @@ fn netSendWindows(
 ) struct { ?net.Socket.SendError, usize } {
     if (!have_networking) return .{ error.NetworkDown, 0 };
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    _ = t;
-    _ = handle;
-    _ = messages;
-    _ = flags;
-    @panic("TODO netSendWindows");
+
+    // Ignored flags: confirm, eor, fastopen
+    const windows_flags: u32 =
+        @as(u32, if (flags.oob) ws2_32.MSG.OOB else 0) |
+        @as(u32, if (flags.dont_route) ws2_32.MSG.DONTROUTE else 0);
+
+    for (messages, 0..) |*m, i| {
+        netSendWindowsOne(t, handle, m, windows_flags) catch |err| return .{ err, i };
+    }
+    return .{ null, messages.len };
+}
+
+fn netSendWindowsOne(
+    t: *Threaded,
+    handle: net.Socket.Handle,
+    message: *net.OutgoingMessage,
+    flags: u32,
+) net.Socket.SendError!void {
+    var buf: ws2_32.WSABUF = .{
+        .buf = @constCast(message.data_ptr),
+        .len = std.math.cast(u32, message.data_len) orelse return error.MessageOversize,
+    };
+    var n: u32 = undefined;
+    var address: WsaAddress = undefined;
+    const address_size = addressToWsa(message.address, &address);
+    var syscall: Syscall = try .start();
+    while (true) {
+        const rc = ws2_32.WSASendTo(
+            handle,
+            (&buf)[0..1],
+            1,
+            &n,
+            flags,
+            &address.any,
+            address_size,
+            null,
+            null,
+        );
+        if (rc != ws2_32.SOCKET_ERROR) {
+            syscall.finish();
+            return;
+        }
+        switch (ws2_32.WSAGetLastError()) {
+            .EINTR, .ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => {
+                try syscall.checkCancel();
+                continue;
+            },
+            .NOTINITIALISED => {
+                syscall.finish();
+                try initializeWsa(t);
+                syscall = try .start();
+                continue;
+            },
+
+            .ECONNRESET => return syscall.fail(error.ConnectionResetByPeer),
+            .ENETDOWN => return syscall.fail(error.NetworkDown),
+            .ENETRESET => return syscall.fail(error.ConnectionResetByPeer),
+            .ENOTCONN => return syscall.fail(error.SocketUnconnected),
+            .EFAULT => unreachable, // a pointer is not completely contained in user address space.
+
+            else => |err| {
+                syscall.finish();
+                switch (err) {
+                    .EINVAL => return wsaErrorBug(err),
+                    .EMSGSIZE => return wsaErrorBug(err),
+                    else => return windows.unexpectedWSAError(err),
+                }
+            },
+        }
+    }
 }
 
 fn netSendUnavailable(
diff --git a/lib/std/Io/net.zig b/lib/std/Io/net.zig
index 7a49996ff818fa3ea25b4941a99e28a5a404301c..6d5b11e1b10907be28241c63c1f611204291d287 100644
--- a/lib/std/Io/net.zig
+++ b/lib/std/Io/net.zig
@@ -1117,12 +1117,13 @@ pub const Socket = struct {
     /// * `receiveTimeout`
     pub fn receive(s: *const Socket, io: Io, buffer: []u8) ReceiveError!IncomingMessage {
         var message: IncomingMessage = .init;
-        const maybe_err, const count = io.vtable.netReceive(io.userdata, s.handle, (&message)[0..1], buffer, .{}, .none);
-        if (maybe_err) |err| switch (err) {
-            // No timeout is passed to `netReceieve`, so it must not return timeout related errors.
-            error.Timeout => unreachable,
-            else => |e| return e,
-        };
+        const maybe_err, const count = (try io.operate(.{ .net_receive = .{
+            .socket_handle = s.handle,
+            .message_buffer = (&message)[0..1],
+            .data_buffer = buffer,
+            .flags = .{},
+        } })).net_receive;
+        if (maybe_err) |err| return err;
         assert(1 == count);
         return message;
     }
@@ -1144,7 +1145,7 @@ pub const Socket = struct {
     ) ReceiveTimeoutError!IncomingMessage {
         var message: IncomingMessage = .init;
         const maybe_err, const count = (try io.operateTimeout(.{ .net_receive = .{
-            .socket = s.handle,
+            .socket_handle = s.handle,
             .message_buffer = (&message)[0..1],
             .data_buffer = buffer,
             .flags = .{},
-- 
2.54.0


From 80625990d5ce82b781de54c4587b489cbd2cd55f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Mar 2026 19:24:55 -0800
Subject: [PATCH 403/499] std: different mechanism for disabling network
 dependency

On Windows, it is sometimes problematic to depend on ws2_32.dll. Before,
users of std.Io.Threaded would have to call ioBasic() rather than io()
in order to avoid unnecessary dependencies on ws2_32.dll. Now, the
application can disable networking with std.Options.

This change is necessary due to moving networking functionality to
be based on Io.Operation, which is a tagged union.
---
 lib/compiler/test_runner.zig                  |   2 +-
 lib/compiler_rt.zig                           |   2 +-
 lib/fuzzer.zig                                |   2 +-
 lib/std/Io/Threaded.zig                       | 166 ++----------------
 lib/std/std.zig                               |   5 +-
 lib/ubsan_rt.zig                              |   4 +
 test/incremental/add_decl                     |  12 +-
 test/incremental/add_decl_namespaced          |  12 +-
 test/incremental/bad_import                   |   4 +-
 test/incremental/change_embed_file            |   6 +-
 test/incremental/change_enum_tag_type         |   6 +-
 test/incremental/change_exports               |  12 +-
 test/incremental/change_fn_type               |   6 +-
 test/incremental/change_generic_line_number   |   4 +-
 test/incremental/change_line_number           |   4 +-
 test/incremental/change_panic_handler         |   6 +-
 .../incremental/change_panic_handler_explicit |   6 +-
 test/incremental/change_shift_op              |   4 +-
 test/incremental/change_struct_same_fields    |   6 +-
 test/incremental/change_zon_file              |   6 +-
 .../change_zon_file_no_result_type            |   2 +-
 test/incremental/compile_log                  |   6 +-
 test/incremental/fix_astgen_failure           |   6 +-
 test/incremental/function_becomes_inline      |   6 +-
 test/incremental/hello                        |   4 +-
 test/incremental/make_decl_pub                |   4 +-
 test/incremental/modify_inline_fn             |   4 +-
 test/incremental/move_src                     |   4 +-
 .../incremental/no_change_preserves_tag_names |   4 +-
 .../recursive_function_becomes_non_recursive  |   4 +-
 test/incremental/remove_enum_field            |   4 +-
 test/incremental/unreferenced_error           |   8 +-
 test/standalone/coff_dwarf/build.zig          |   3 +
 test/standalone/dirname/exists_in.zig         |   2 +-
 test/standalone/dirname/touch.zig             |   2 +-
 test/standalone/issue_5825/build.zig          |   1 +
 test/standalone/mix_o_files/build.zig         |   3 +
 test/standalone/run_cwd/check_file_exists.zig |   2 +-
 test/standalone/shared_library/build.zig      |   5 +-
 test/standalone/windows_argv/build.zig        |   3 +
 40 files changed, 122 insertions(+), 230 deletions(-)

diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig
index 9c100176d502b82277d1c99a6688473276746240..899b5dafbfb7fa2683854b81ff198eb2a7be4573 100644
--- a/lib/compiler/test_runner.zig
+++ b/lib/compiler/test_runner.zig
@@ -17,7 +17,7 @@ var fba: std.heap.FixedBufferAllocator = .init(&fba_buffer);
 var fba_buffer: [8192]u8 = undefined;
 var stdin_buffer: [4096]u8 = undefined;
 var stdout_buffer: [4096]u8 = undefined;
-const runner_threaded_io: Io = Io.Threaded.global_single_threaded.ioBasic();
+const runner_threaded_io: Io = Io.Threaded.global_single_threaded.io();
 
 /// Keep in sync with logic in `std.Build.addRunArtifact` which decides whether
 /// the test runner will communicate with the build runner via `std.zig.Server`.
diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig
index 5c9c7a59af3738ac49d7912b1a1c8de6c7802c59..ce8f49d17b9e3157fdf2c13a4c164faffc12901a 100644
--- a/lib/compiler_rt.zig
+++ b/lib/compiler_rt.zig
@@ -17,7 +17,7 @@ else
     null;
 
 pub const std_options_debug_io: std.Io = if (builtin.is_test)
-    std.Io.Threaded.global_single_threaded.ioBasic()
+    std.Io.Threaded.global_single_threaded.io()
 else
     unreachable;
 
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index b3a6eb5196c1fbad6c2af380d815737892ef5866..c97aeea4e8a7d35be44c4607a2b3b268e0897d0b 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -13,7 +13,7 @@ pub const std_options = std.Options{
     .logFn = logOverride,
 };
 
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 
 fn logOverride(
     comptime level: std.log.Level,
diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig
index 81a500e0f980e3d3c14288fe84ca7a815d8c9fac..59382348e9dcf75313fbc1e55e97dbf907f5091d 100644
--- a/lib/std/Io/Threaded.zig
+++ b/lib/std/Io/Threaded.zig
@@ -1908,142 +1908,10 @@ pub fn io(t: *Threaded) Io {
     };
 }
 
-/// Same as `io` but disables all networking functionality, which has
-/// an additional dependency on Windows (ws2_32).
-pub fn ioBasic(t: *Threaded) Io {
-    return .{
-        .userdata = t,
-        .vtable = &.{
-            .crashHandler = crashHandler,
-
-            .async = async,
-            .concurrent = concurrent,
-            .await = await,
-            .cancel = cancel,
-
-            .groupAsync = groupAsync,
-            .groupConcurrent = groupConcurrent,
-            .groupAwait = groupAwait,
-            .groupCancel = groupCancel,
-
-            .recancel = recancel,
-            .swapCancelProtection = swapCancelProtection,
-            .checkCancel = checkCancel,
-
-            .futexWait = futexWait,
-            .futexWaitUncancelable = futexWaitUncancelable,
-            .futexWake = futexWake,
-
-            .operate = operate,
-            .batchAwaitAsync = batchAwaitAsync,
-            .batchAwaitConcurrent = batchAwaitConcurrent,
-            .batchCancel = batchCancel,
-
-            .dirCreateDir = dirCreateDir,
-            .dirCreateDirPath = dirCreateDirPath,
-            .dirCreateDirPathOpen = dirCreateDirPathOpen,
-            .dirStat = dirStat,
-            .dirStatFile = dirStatFile,
-            .dirAccess = dirAccess,
-            .dirCreateFile = dirCreateFile,
-            .dirCreateFileAtomic = dirCreateFileAtomic,
-            .dirOpenFile = dirOpenFile,
-            .dirOpenDir = dirOpenDir,
-            .dirClose = dirClose,
-            .dirRead = dirRead,
-            .dirRealPath = dirRealPath,
-            .dirRealPathFile = dirRealPathFile,
-            .dirDeleteFile = dirDeleteFile,
-            .dirDeleteDir = dirDeleteDir,
-            .dirRename = dirRename,
-            .dirRenamePreserve = dirRenamePreserve,
-            .dirSymLink = dirSymLink,
-            .dirReadLink = dirReadLink,
-            .dirSetOwner = dirSetOwner,
-            .dirSetFileOwner = dirSetFileOwner,
-            .dirSetPermissions = dirSetPermissions,
-            .dirSetFilePermissions = dirSetFilePermissions,
-            .dirSetTimestamps = dirSetTimestamps,
-            .dirHardLink = dirHardLink,
-
-            .fileStat = fileStat,
-            .fileLength = fileLength,
-            .fileClose = fileClose,
-            .fileWritePositional = fileWritePositional,
-            .fileWriteFileStreaming = fileWriteFileStreaming,
-            .fileWriteFilePositional = fileWriteFilePositional,
-            .fileReadPositional = fileReadPositional,
-            .fileSeekBy = fileSeekBy,
-            .fileSeekTo = fileSeekTo,
-            .fileSync = fileSync,
-            .fileIsTty = fileIsTty,
-            .fileEnableAnsiEscapeCodes = fileEnableAnsiEscapeCodes,
-            .fileSupportsAnsiEscapeCodes = fileSupportsAnsiEscapeCodes,
-            .fileSetLength = fileSetLength,
-            .fileSetOwner = fileSetOwner,
-            .fileSetPermissions = fileSetPermissions,
-            .fileSetTimestamps = fileSetTimestamps,
-            .fileLock = fileLock,
-            .fileTryLock = fileTryLock,
-            .fileUnlock = fileUnlock,
-            .fileDowngradeLock = fileDowngradeLock,
-            .fileRealPath = fileRealPath,
-            .fileHardLink = fileHardLink,
-
-            .fileMemoryMapCreate = fileMemoryMapCreate,
-            .fileMemoryMapDestroy = fileMemoryMapDestroy,
-            .fileMemoryMapSetLength = fileMemoryMapSetLength,
-            .fileMemoryMapRead = fileMemoryMapRead,
-            .fileMemoryMapWrite = fileMemoryMapWrite,
-
-            .processExecutableOpen = processExecutableOpen,
-            .processExecutablePath = processExecutablePath,
-            .lockStderr = lockStderr,
-            .tryLockStderr = tryLockStderr,
-            .unlockStderr = unlockStderr,
-            .processCurrentPath = processCurrentPath,
-            .processSetCurrentDir = processSetCurrentDir,
-            .processSetCurrentPath = processSetCurrentPath,
-            .processReplace = processReplace,
-            .processReplacePath = processReplacePath,
-            .processSpawn = processSpawn,
-            .processSpawnPath = processSpawnPath,
-            .childWait = childWait,
-            .childKill = childKill,
-
-            .progressParentFile = progressParentFile,
-
-            .now = now,
-            .clockResolution = clockResolution,
-            .sleep = sleep,
-
-            .random = random,
-            .randomSecure = randomSecure,
-
-            .netListenIp = netListenIpUnavailable,
-            .netListenUnix = netListenUnixUnavailable,
-            .netAccept = netAcceptUnavailable,
-            .netBindIp = netBindIpUnavailable,
-            .netConnectIp = netConnectIpUnavailable,
-            .netSocketCreatePair = netSocketCreatePairUnavailable,
-            .netConnectUnix = netConnectUnixUnavailable,
-            .netClose = netCloseUnavailable,
-            .netShutdown = netShutdownUnavailable,
-            .netRead = netReadUnavailable,
-            .netWrite = netWriteUnavailable,
-            .netWriteFile = netWriteFileUnavailable,
-            .netSend = netSendUnavailable,
-            .netInterfaceNameResolve = netInterfaceNameResolveUnavailable,
-            .netInterfaceName = netInterfaceNameUnavailable,
-            .netLookup = netLookupUnavailable,
-        },
-    };
-}
-
 pub const socket_flags_unsupported = is_darwin or native_os == .haiku;
 const have_accept4 = !socket_flags_unsupported;
 const have_flock_open_flags = @hasField(posix.O, "EXLOCK");
-const have_networking = native_os != .wasi;
+const have_networking = std.options.networking and native_os != .wasi;
 const have_flock = @TypeOf(posix.system.flock) != void;
 const have_sendmmsg = native_os == .linux;
 const have_futex = switch (builtin.cpu.arch) {
@@ -2595,7 +2463,7 @@ fn futexWait(userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Io.
         return;
     }
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const t_io = ioBasic(t);
+    const t_io = io(t);
     const timeout_ns: ?u64 = ns: {
         const d = timeout.toDurationFromNow(t_io) orelse break :ns null;
         break :ns std.math.lossyCast(u64, d.raw.toNanoseconds());
@@ -2788,7 +2656,7 @@ fn batchAwaitAsync(userdata: ?*anyopaque, b: *Io.Batch) Io.Cancelable!void {
 fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.AwaitConcurrentError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) {
-        const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(ioBasic(t));
+        const deadline: ?Io.Clock.Timestamp = timeout.toTimestamp(io(t));
         try batchDrainSubmittedWindows(t, b, true);
         while (b.pending.head != .none and b.completed.head == .none) {
             var delay_interval: windows.LARGE_INTEGER = interval: {
@@ -2898,7 +2766,7 @@ fn batchAwaitConcurrent(userdata: ?*anyopaque, b: *Io.Batch, timeout: Io.Timeout
         },
         else => {},
     }
-    const t_io = ioBasic(t);
+    const t_io = io(t);
     const deadline = timeout.toTimestamp(t_io);
     while (true) {
         const timeout_ms: i32 = t: {
@@ -3536,7 +3404,7 @@ fn dirCreateDirPathOpenPosix(
     options: Dir.OpenOptions,
 ) Dir.CreateDirPathOpenError!Dir {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const t_io = ioBasic(t);
+    const t_io = io(t);
     return dirOpenDirPosix(t, dir, sub_path, options) catch |err| switch (err) {
         error.FileNotFound => {
             _ = try dir.createDirPathStatus(t_io, sub_path, permissions);
@@ -3657,7 +3525,7 @@ fn dirCreateDirPathOpenWasi(
     options: Dir.OpenOptions,
 ) Dir.CreateDirPathOpenError!Dir {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const t_io = ioBasic(t);
+    const t_io = io(t);
     return dirOpenDirWasi(t, dir, sub_path, options) catch |err| switch (err) {
         error.FileNotFound => {
             _ = try dir.createDirPathStatus(t_io, sub_path, permissions);
@@ -4698,7 +4566,7 @@ fn dirCreateFileAtomic(
     options: Dir.CreateFileAtomicOptions,
 ) Dir.CreateFileAtomicError!File.Atomic {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const t_io = ioBasic(t);
+    const t_io = io(t);
 
     // Linux has O_TMPFILE, but linkat() does not support AT_REPLACE, so it's
     // useless when we have to make up a bogus path name to do the rename()
@@ -10326,19 +10194,19 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut
             const rc = std.c._NSGetExecutablePath(&symlink_path_buf, &n);
             if (rc != 0) return error.NameTooLong;
             const symlink_path = std.mem.sliceTo(&symlink_path_buf, 0);
-            return Io.Dir.realPathFileAbsolute(ioBasic(t), symlink_path, out_buffer) catch |err| switch (err) {
+            return Io.Dir.realPathFileAbsolute(io(t), symlink_path, out_buffer) catch |err| switch (err) {
                 error.NetworkNotFound => unreachable, // Windows-only
                 error.FileBusy => unreachable, // Windows-only
                 else => |e| return e,
             };
         },
-        .linux, .serenity => return Io.Dir.readLinkAbsolute(ioBasic(t), "/proc/self/exe", out_buffer) catch |err| switch (err) {
+        .linux, .serenity => return Io.Dir.readLinkAbsolute(io(t), "/proc/self/exe", out_buffer) catch |err| switch (err) {
             error.UnsupportedReparsePointType => unreachable, // Windows-only
             error.NetworkNotFound => unreachable, // Windows-only
             error.FileBusy => unreachable, // Windows-only
             else => |e| return e,
         },
-        .illumos => return Io.Dir.readLinkAbsolute(ioBasic(t), "/proc/self/path/a.out", out_buffer) catch |err| switch (err) {
+        .illumos => return Io.Dir.readLinkAbsolute(io(t), "/proc/self/path/a.out", out_buffer) catch |err| switch (err) {
             error.UnsupportedReparsePointType => unreachable, // Windows-only
             error.NetworkNotFound => unreachable, // Windows-only
             error.FileBusy => unreachable, // Windows-only
@@ -11700,7 +11568,7 @@ fn sleepPosix(timeout: Io.Timeout) Io.Cancelable!void {
 }
 
 fn sleepWasi(t: *Threaded, timeout: Io.Timeout) Io.Cancelable!void {
-    const t_io = ioBasic(t);
+    const t_io = io(t);
     const w = std.os.wasi;
 
     const clock: w.subscription_clock_t = if (timeout.toDurationFromNow(t_io)) |d| .{
@@ -11729,7 +11597,7 @@ fn sleepWasi(t: *Threaded, timeout: Io.Timeout) Io.Cancelable!void {
 }
 
 fn sleepNanosleep(t: *Threaded, timeout: Io.Timeout) Io.Cancelable!void {
-    const t_io = ioBasic(t);
+    const t_io = io(t);
     const sec_type = @typeInfo(posix.timespec).@"struct".fields[0].type;
     const nsec_type = @typeInfo(posix.timespec).@"struct".fields[1].type;
 
@@ -11961,6 +11829,7 @@ fn netListenUnixWindows(
     options: net.UnixAddress.ListenOptions,
 ) net.UnixAddress.ListenError!net.Socket.Handle {
     if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
+    if (!have_networking) return error.NetworkDown;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
 
     const socket_handle = openSocketWsa(t, posix.AF.UNIX, .{ .mode = .stream }) catch |err| switch (err) {
@@ -12457,6 +12326,7 @@ fn netConnectUnixWindows(
     address: *const net.UnixAddress,
 ) net.UnixAddress.ConnectError!net.Socket.Handle {
     if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
+    if (!have_networking) return error.NetworkDown;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
 
     const socket_handle = try openSocketWsa(t, posix.AF.UNIX, .{ .mode = .stream });
@@ -13426,7 +13296,7 @@ fn netReceiveWindowsOne(
     data_buffer: []u8,
     flags: net.ReceiveFlags,
 ) net.Socket.ReceiveError!void {
-    comptime assert(have_networking);
+    if (!have_networking) return error.NetworkDown;
 
     var windows_flags: u32 =
         @as(u32, if (flags.oob) ws2_32.MSG.OOB else 0) |
@@ -13601,6 +13471,7 @@ fn netWriteWindows(
     data: []const []const u8,
     splat: usize,
 ) net.Stream.Writer.Error!usize {
+    if (!have_networking) return error.NetworkDown;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     comptime assert(is_windows);
 
@@ -13723,6 +13594,7 @@ fn addBuf(v: []posix.iovec_const, i: *iovlen_t, bytes: []const u8) void {
 }
 
 fn netClose(userdata: ?*anyopaque, handles: []const net.Socket.Handle) void {
+    if (!have_networking) unreachable;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
     switch (native_os) {
@@ -13931,7 +13803,7 @@ fn netLookupUnavailable(
     _ = host_name;
     _ = options;
     const t: *Threaded = @ptrCast(@alignCast(userdata));
-    resolved.close(ioBasic(t));
+    resolved.close(io(t));
     return error.NetworkDown;
 }
 
@@ -14214,7 +14086,7 @@ fn tryLockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Can
 
 fn initLockedStderr(t: *Threaded, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
     if (!t.stderr_writer_initialized) {
-        const io_t = ioBasic(t);
+        const io_t = io(t);
         if (is_windows) t.stderr_writer.file = .stderr();
         t.stderr_writer.io = io_t;
         t.stderr_writer_initialized = true;
diff --git a/lib/std/std.zig b/lib/std/std.zig
index d563cdfae7aac1003fb7d91472cd6653f78a5cee..c25241975aee08701fb8c87d3b6f2af2411ad5c5 100644
--- a/lib/std/std.zig
+++ b/lib/std/std.zig
@@ -174,6 +174,9 @@ pub const Options = struct {
     /// stack traces will just print an error to the relevant `Io.Writer` and return.
     allow_stack_tracing: bool = !@import("builtin").strip_debug_info,
 
+    /// Allows disabling networking in std.Io implementations.
+    networking: bool = true,
+
     /// TODO This is a separate decl instead of a field as a workaround around
     /// compilation errors due to zig not being lazy enough.
     pub const logTerminalMode: fn () Io.Terminal.Mode = log.defaultTerminalMode;
@@ -202,7 +205,7 @@ pub const Options = struct {
     /// implementation based on coroutines, one likely wants `std.debug.print`
     /// to directly write to stderr without trying to interact with the code
     /// being debugged.
-    pub const debug_io: Io = if (@hasDecl(root, "std_options_debug_io")) root.std_options_debug_io else debug_threaded_io.?.ioBasic();
+    pub const debug_io: Io = if (@hasDecl(root, "std_options_debug_io")) root.std_options_debug_io else debug_threaded_io.?.io();
 
     /// Overrides `std.Io.File.Permissions`.
     pub const FilePermissions: ?type = if (@hasDecl(root, "std_options_FilePermissions")) root.std_options_FilePermissions else null;
diff --git a/lib/ubsan_rt.zig b/lib/ubsan_rt.zig
index aa5942a0bda0d39229a00266284fa47211abd80c..59278a91161d4ef780539de147c94d54a67aa320 100644
--- a/lib/ubsan_rt.zig
+++ b/lib/ubsan_rt.zig
@@ -3,6 +3,10 @@ const builtin = @import("builtin");
 const assert = std.debug.assert;
 const panic = std.debug.panicExtra;
 
+pub const std_options: std.Options = .{
+    .networking = false,
+};
+
 const SourceLocation = extern struct {
     file_name: ?[*:0]const u8,
     line: u32,
diff --git a/test/incremental/add_decl b/test/incremental/add_decl
index 99f6b2d34fb9c244caac9d0741f7511b6d279bbc..662160fc2dc1038babaab18a234d0917d82675bc 100644
--- a/test/incremental/add_decl
+++ b/test/incremental/add_decl
@@ -10,7 +10,7 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, foo);
 }
 const foo = "good morning\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good morning\n"
 
 #update=add new declaration
@@ -21,7 +21,7 @@ pub fn main() !void {
 }
 const foo = "good morning\n";
 const bar = "good evening\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good morning\n"
 
 #update=reference new declaration
@@ -32,7 +32,7 @@ pub fn main() !void {
 }
 const foo = "good morning\n";
 const bar = "good evening\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good evening\n"
 
 #update=reference missing declaration
@@ -43,7 +43,7 @@ pub fn main() !void {
 }
 const foo = "good morning\n";
 const bar = "good evening\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:3:52: error: use of undeclared identifier 'qux'
 
 #update=add missing declaration
@@ -55,7 +55,7 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const qux = "good night\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good night\n"
 
 #update=remove unused declarations
@@ -65,5 +65,5 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, qux);
 }
 const qux = "good night\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good night\n"
diff --git a/test/incremental/add_decl_namespaced b/test/incremental/add_decl_namespaced
index 6fc22f10b9411cbeaa988618b0f2512d96bcf652..aed78815c81aec020f3a4e4dc6a7bbb8c0054ffe 100644
--- a/test/incremental/add_decl_namespaced
+++ b/test/incremental/add_decl_namespaced
@@ -10,7 +10,7 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().foo);
 }
 const foo = "good morning\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good morning\n"
 
 #update=add new declaration
@@ -21,7 +21,7 @@ pub fn main() !void {
 }
 const foo = "good morning\n";
 const bar = "good evening\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good morning\n"
 
 #update=reference new declaration
@@ -32,7 +32,7 @@ pub fn main() !void {
 }
 const foo = "good morning\n";
 const bar = "good evening\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good evening\n"
 
 #update=reference missing declaration
@@ -43,7 +43,7 @@ pub fn main() !void {
 }
 const foo = "good morning\n";
 const bar = "good evening\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:3:59: error: root source file struct 'main' has no member named 'qux'
 #expect_error=main.zig:1:1: note: struct declared here
 
@@ -56,7 +56,7 @@ pub fn main() !void {
 const foo = "good morning\n";
 const bar = "good evening\n";
 const qux = "good night\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good night\n"
 
 #update=remove unused declarations
@@ -66,5 +66,5 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @This().qux);
 }
 const qux = "good night\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="good night\n"
diff --git a/test/incremental/bad_import b/test/incremental/bad_import
index 20bdb9ae82fcb1588688d3ae9290bf146b1ee142..b9437714033b679afeb2fdea126c7f4d822f9177 100644
--- a/test/incremental/bad_import
+++ b/test/incremental/bad_import
@@ -11,7 +11,7 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "success\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #file=foo.zig
 comptime {
     _ = @import("bad.zig");
@@ -34,5 +34,5 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "success\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="success\n"
diff --git a/test/incremental/change_embed_file b/test/incremental/change_embed_file
index 84c9c334c72283d2ac5637064cd96a4fca37a0fe..92b9ec23e370e047973886cd613e8287adca5214 100644
--- a/test/incremental/change_embed_file
+++ b/test/incremental/change_embed_file
@@ -10,7 +10,7 @@ const string = @embedFile("string.txt");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, string);
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #file=string.txt
 Hello, World!
 #expect_stdout="Hello, World!\n"
@@ -31,7 +31,7 @@ const string = @embedFile("string.txt");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "a hardcoded string\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="a hardcoded string\n"
 
 #update=re-introduce reference to file
@@ -41,7 +41,7 @@ const string = @embedFile("string.txt");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, string);
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:2:27: error: unable to open 'string.txt': FileNotFound
 
 #update=recreate file
diff --git a/test/incremental/change_enum_tag_type b/test/incremental/change_enum_tag_type
index 06b80ac04deb7f36956dff9d20c8704563602adc..97103351995157bd82b99b96913ffaa6165d2f96 100644
--- a/test/incremental/change_enum_tag_type
+++ b/test/incremental/change_enum_tag_type
@@ -19,7 +19,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="a\n"
 #update=too many enum fields
 #file=main.zig
@@ -43,7 +43,7 @@ comptime {
     std.debug.assert(@TypeOf(@intFromEnum(Foo.e)) == Tag);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:7:5: error: enumeration value '4' too large for type 'u2'
 #update=increase tag size
 #file=main.zig
@@ -62,5 +62,5 @@ pub fn main() !void {
     try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="a\n"
diff --git a/test/incremental/change_exports b/test/incremental/change_exports
index a36afb4ee1aae151871068cae685a93df61111f6..05e3111cebe4903384284aaf0ee0daf9abc9c388 100644
--- a/test/incremental/change_exports
+++ b/test/incremental/change_exports
@@ -21,7 +21,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{}\n", .{S.bar});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="123\n"
 
 #update=add conflict
@@ -44,7 +44,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:6:5: error: exported symbol collision: foo
 #expect_error=main.zig:1:1: note: other symbol here
 
@@ -68,7 +68,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="123 456\n"
 
 #update=put exports in decl
@@ -94,7 +94,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="123 456\n"
 
 #update=remove reference to exporting decl
@@ -141,7 +141,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="123 456\n"
 
 #update=reintroduce reference to exporting decl, introducing conflict
@@ -167,7 +167,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:5:5: error: exported symbol collision: bar
 #expect_error=main.zig:2:1: note: other symbol here
 #expect_error=main.zig:6:5: error: exported symbol collision: other
diff --git a/test/incremental/change_fn_type b/test/incremental/change_fn_type
index b4286545e3816227d7d33354885875044c0b72fc..0c512e416e49b208939d07d1c8d80bf42f525afd 100644
--- a/test/incremental/change_fn_type
+++ b/test/incremental/change_fn_type
@@ -12,7 +12,7 @@ fn foo(x: u8) !void {
     return stdout_writer.interface.print("{d}\n", .{x});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="123\n"
 
 #update=change function type
@@ -25,7 +25,7 @@ fn foo(x: i64) !void {
     return stdout_writer.interface.print("{d}\n", .{x});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="123\n"
 
 #update=change function argument
@@ -38,5 +38,5 @@ fn foo(x: i64) !void {
     return stdout_writer.interface.print("{d}\n", .{x});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="-42\n"
diff --git a/test/incremental/change_generic_line_number b/test/incremental/change_generic_line_number
index 2d731b071c644c35bf921e20187820d81660b3b1..45b3d2f0d02ff724012328c84db643de027d11a6 100644
--- a/test/incremental/change_generic_line_number
+++ b/test/incremental/change_generic_line_number
@@ -4,7 +4,7 @@
 #update=initial version
 #file=main.zig
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 fn Printer(message: []const u8) type {
     return struct {
         fn print() !void {
@@ -20,7 +20,7 @@ pub fn main() !void {
 #update=change line number
 #file=main.zig
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 
 fn Printer(message: []const u8) type {
     return struct {
diff --git a/test/incremental/change_line_number b/test/incremental/change_line_number
index 7bafbbfbdd9d69538c094cbfbbfdaaf2b4f6a555..c95b690f7f07003c1fcafdc473334540dda5bd93 100644
--- a/test/incremental/change_line_number
+++ b/test/incremental/change_line_number
@@ -7,7 +7,7 @@ const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "foo\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="foo\n"
 #update=change line number
 #file=main.zig
@@ -16,5 +16,5 @@ const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "foo\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="foo\n"
diff --git a/test/incremental/change_panic_handler b/test/incremental/change_panic_handler
index ebce3bc3121be81a04687dce2b77e7f27c39db4a..2d8e95f6e11b352b791ff66d927cc626f9bfc48b 100644
--- a/test/incremental/change_panic_handler
+++ b/test/incremental/change_panic_handler
@@ -17,7 +17,7 @@ fn myPanic(msg: []const u8, _: ?usize) noreturn {
     std.process.exit(0);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="panic message: integer overflow\n"
 
 #update=change the panic handler body
@@ -35,7 +35,7 @@ fn myPanic(msg: []const u8, _: ?usize) noreturn {
     std.process.exit(0);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="new panic message: integer overflow\n"
 
 #update=change the panic handler function value
@@ -53,5 +53,5 @@ fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
     std.process.exit(0);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="third panic message: integer overflow\n"
diff --git a/test/incremental/change_panic_handler_explicit b/test/incremental/change_panic_handler_explicit
index 366bffca45baab2478be62a00c90e780ef92597e..bf57a076282d7c609e307c333b5ccfb660b6c88e 100644
--- a/test/incremental/change_panic_handler_explicit
+++ b/test/incremental/change_panic_handler_explicit
@@ -47,7 +47,7 @@ fn myPanic(msg: []const u8, _: ?usize) noreturn {
     std.process.exit(0);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="panic message: integer overflow\n"
 
 #update=change the panic handler body
@@ -95,7 +95,7 @@ fn myPanic(msg: []const u8, _: ?usize) noreturn {
     std.process.exit(0);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="new panic message: integer overflow\n"
 
 #update=change the panic handler function value
@@ -143,5 +143,5 @@ fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
     std.process.exit(0);
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="third panic message: integer overflow\n"
diff --git a/test/incremental/change_shift_op b/test/incremental/change_shift_op
index af849c0d5b6c28b3ee5a3d974ff9e74004f05ac0..159ef6f11d1ab0dbd6e7074cd49afa75b02af67e 100644
--- a/test/incremental/change_shift_op
+++ b/test/incremental/change_shift_op
@@ -13,7 +13,7 @@ fn foo(x: u16) !void {
     try stdout_writer.interface.print("0x{x}\n", .{x << 4});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="0x3000\n"
 #update=change to right shift
 #file=main.zig
@@ -25,5 +25,5 @@ fn foo(x: u16) !void {
     try stdout_writer.interface.print("0x{x}\n", .{x >> 4});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="0x130\n"
diff --git a/test/incremental/change_struct_same_fields b/test/incremental/change_struct_same_fields
index 3ba715f906d087a34f5ce7f7aa5a81eb5012ce97..180948337020cba4922e030e2e01ef0a0c189a38 100644
--- a/test/incremental/change_struct_same_fields
+++ b/test/incremental/change_struct_same_fields
@@ -18,7 +18,7 @@ fn foo(val: *const S) !void {
     );
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="100 200\n"
 
 #update=change struct layout
@@ -36,7 +36,7 @@ fn foo(val: *const S) !void {
     );
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="100 200\n"
 
 #update=change values
@@ -54,5 +54,5 @@ fn foo(val: *const S) !void {
     );
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="1234 5678\n"
diff --git a/test/incremental/change_zon_file b/test/incremental/change_zon_file
index a966df5471c270edd0e67568e930e3a91687f839..beeffec4373c4ddf6ce48a7e566cd29f32d4e38f 100644
--- a/test/incremental/change_zon_file
+++ b/test/incremental/change_zon_file
@@ -10,7 +10,7 @@ const message: []const u8 = @import("message.zon");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, message);
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #file=message.zon
 "Hello, World!\n"
 #expect_stdout="Hello, World!\n"
@@ -32,7 +32,7 @@ const message: []const u8 = @import("message.zon");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "a hardcoded string\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=message.zon:1:1: error: unable to load 'message.zon': FileNotFound
 #expect_error=main.zig:2:37: note: file imported here
 
@@ -48,5 +48,5 @@ const message: []const u8 = @import("message.zon");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, message);
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="We're back, World!\n"
diff --git a/test/incremental/change_zon_file_no_result_type b/test/incremental/change_zon_file_no_result_type
index 6b3aa73dc6ee87c6e0e64fb2eaeb56508b8c10c7..d05aecedfbccf72fe96709b3aa42a02042b745a9 100644
--- a/test/incremental/change_zon_file_no_result_type
+++ b/test/incremental/change_zon_file_no_result_type
@@ -6,7 +6,7 @@
 #update=initial version
 #file=main.zig
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @import("foo.zon").message);
 }
diff --git a/test/incremental/compile_log b/test/incremental/compile_log
index 19ff7237f275a9cc946665ef1e8e08015d80bb56..3ed5467a9a175c559bef5b910215a05175fa8d5c 100644
--- a/test/incremental/compile_log
+++ b/test/incremental/compile_log
@@ -10,7 +10,7 @@ const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
 
 #update=add compile log
@@ -20,7 +20,7 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
     @compileLog("this is a log");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:4:5: error: found compile log statement
 #expect_compile_log=@as(*const [13:0]u8, "this is a log")
 
@@ -30,5 +30,5 @@ const std = @import("std");
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
diff --git a/test/incremental/fix_astgen_failure b/test/incremental/fix_astgen_failure
index dca371f521800d85e423cf68f008d78b598cfc97..701e9973a73e5df91b3d2cda86188c15b96ad67b 100644
--- a/test/incremental/fix_astgen_failure
+++ b/test/incremental/fix_astgen_failure
@@ -19,7 +19,7 @@ const std = @import("std");
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
 #update=add new error
 #file=foo.zig
@@ -27,7 +27,7 @@ const std = @import("std");
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, hello_str);
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=foo.zig:3:52: error: use of undeclared identifier 'hello_str'
 #update=fix the new error
 #file=foo.zig
@@ -36,5 +36,5 @@ const hello_str = "Hello, World! Again!\n";
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, hello_str);
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World! Again!\n"
diff --git a/test/incremental/function_becomes_inline b/test/incremental/function_becomes_inline
index 4021575842527a1c9705b411b634b354d44a6e04..eefb4f1a077d437389c79631f6bcd2953821e3f0 100644
--- a/test/incremental/function_becomes_inline
+++ b/test/incremental/function_becomes_inline
@@ -11,7 +11,7 @@ fn foo() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
 
 #update=make function inline
@@ -23,7 +23,7 @@ inline fn foo() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
 
 #update=change string
@@ -35,5 +35,5 @@ inline fn foo() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, `inline` World!\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, `inline` World!\n"
diff --git a/test/incremental/hello b/test/incremental/hello
index 48659e1879ed97bad09ab32130401de4563c23cd..e2146e52be590779e8132e65ba9e5503a2d80e98 100644
--- a/test/incremental/hello
+++ b/test/incremental/hello
@@ -6,7 +6,7 @@
 #update=initial version
 #file=main.zig
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "good morning\n");
 }
@@ -14,7 +14,7 @@ pub fn main() !void {
 #update=change the string
 #file=main.zig
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "おはようございます\n");
 }
diff --git a/test/incremental/make_decl_pub b/test/incremental/make_decl_pub
index b193deb68cf07f5c4709eb42da2a65d2997e4d92..a2c87b8f50114fa9b77216f0b4036e8a55e81fc7 100644
--- a/test/incremental/make_decl_pub
+++ b/test/incremental/make_decl_pub
@@ -14,7 +14,7 @@ const std = @import("std");
 fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:3:12: error: 'hello' is not marked 'pub'
 #expect_error=foo.zig:2:1: note: declared here
 
@@ -24,5 +24,5 @@ const std = @import("std");
 pub fn hello() !void {
     try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
diff --git a/test/incremental/modify_inline_fn b/test/incremental/modify_inline_fn
index 19e201f1d9e2e994c8ff65c4fe780e96d8c818b0..6bf1f0baf29729ca12729955fe1683a6d3cf3706 100644
--- a/test/incremental/modify_inline_fn
+++ b/test/incremental/modify_inline_fn
@@ -13,7 +13,7 @@ pub fn main() !void {
 inline fn getStr() []const u8 {
     return "foo\n";
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="foo\n"
 #update=change the string
 #file=main.zig
@@ -25,5 +25,5 @@ pub fn main() !void {
 inline fn getStr() []const u8 {
     return "bar\n";
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="bar\n"
diff --git a/test/incremental/move_src b/test/incremental/move_src
index b79a25df8df11002a6d4e7b1bf78c976ea760372..a60211e31b86f3dbf3746b28ee39df4c92e83803 100644
--- a/test/incremental/move_src
+++ b/test/incremental/move_src
@@ -16,7 +16,7 @@ fn foo() u32 {
 fn bar() u32 {
     return 123;
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="7 123\n"
 
 #update=add newline
@@ -33,5 +33,5 @@ fn foo() u32 {
 fn bar() u32 {
     return 123;
 }
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="8 123\n"
diff --git a/test/incremental/no_change_preserves_tag_names b/test/incremental/no_change_preserves_tag_names
index dc89face50dbf5acbe8be6f50dddeedac323d3d7..06dc2f069c23634ad1d70ea30b997c555c483241 100644
--- a/test/incremental/no_change_preserves_tag_names
+++ b/test/incremental/no_change_preserves_tag_names
@@ -7,7 +7,7 @@
 #file=main.zig
 const std = @import("std");
 var some_enum: enum { first, second } = .first;
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @tagName(some_enum));
 }
@@ -16,7 +16,7 @@ pub fn main() !void {
 #file=main.zig
 const std = @import("std");
 var some_enum: enum { first, second } = .first;
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, @tagName(some_enum));
 }
diff --git a/test/incremental/recursive_function_becomes_non_recursive b/test/incremental/recursive_function_becomes_non_recursive
index 5cee1bfbcff10ab669ee367e80a833d800df1cc6..ad8c0059fabba099e12f0e2b6055127aab0dc9a2 100644
--- a/test/incremental/recursive_function_becomes_non_recursive
+++ b/test/incremental/recursive_function_becomes_non_recursive
@@ -14,7 +14,7 @@ fn foo(recurse: bool) !void {
     try stdout.writeStreamingAll(io, "non-recursive path\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="non-recursive path\n"
 
 #update=eliminate recursion and change argument
@@ -28,5 +28,5 @@ fn foo(recurse: bool) !void {
     try stdout.writeStreamingAll(io, "non-recursive path\n");
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="x==1\n"
diff --git a/test/incremental/remove_enum_field b/test/incremental/remove_enum_field
index c964285707dec13202b9b917e390b6c90bf509ad..a1bbab8fd0fdaaf65115cb29d2b0210ccc77f862 100644
--- a/test/incremental/remove_enum_field
+++ b/test/incremental/remove_enum_field
@@ -14,7 +14,7 @@ pub fn main() !void {
     try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="1\n"
 #update=remove enum field
 #file=main.zig
@@ -27,6 +27,6 @@ pub fn main() !void {
     try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
 }
 const std = @import("std");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:7:69: error: enum 'main.MyEnum' has no member named 'foo'
 #expect_error=main.zig:1:16: note: enum declared here
diff --git a/test/incremental/unreferenced_error b/test/incremental/unreferenced_error
index c9a3277487c103a656a2b72fcb702fab27862856..25790ed0447950ebefa41f677d594e5dbc4b76f4 100644
--- a/test/incremental/unreferenced_error
+++ b/test/incremental/unreferenced_error
@@ -10,7 +10,7 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, a);
 }
 const a = "Hello, World!\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hello, World!\n"
 
 #update=introduce compile error
@@ -20,7 +20,7 @@ pub fn main() !void {
     try std.Io.File.stdout().writeStreamingAll(io, a);
 }
 const a = @compileError("bad a");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_error=main.zig:5:11: error: bad a
 
 #update=remove error reference
@@ -31,7 +31,7 @@ pub fn main() !void {
 }
 const a = @compileError("bad a");
 const b = "Hi there!\n";
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Hi there!\n"
 
 #update=introduce and remove reference to error
@@ -42,5 +42,5 @@ pub fn main() !void {
 }
 const a = "Back to a\n";
 const b = @compileError("bad b");
-const io = std.Io.Threaded.global_single_threaded.ioBasic();
+const io = std.Io.Threaded.global_single_threaded.io();
 #expect_stdout="Back to a\n"
diff --git a/test/standalone/coff_dwarf/build.zig b/test/standalone/coff_dwarf/build.zig
index d35e744a6c32d5c0b7a98f52c746506c2aefd2e2..0245154dbbe023a318fe3ba0d18f1c810b7958bf 100644
--- a/test/standalone/coff_dwarf/build.zig
+++ b/test/standalone/coff_dwarf/build.zig
@@ -46,6 +46,9 @@ pub fn build(b: *std.Build) void {
     lib.root_module.addCSourceFile(.{ .file = b.path("shared_lib.c"), .flags = &.{"-gdwarf"} });
     exe.root_module.linkLibrary(lib);
 
+    if (target.result.os.tag == .windows)
+        exe.root_module.linkSystemLibrary("ws2_32", .{});
+
     const run = b.addRunArtifact(exe);
     run.expectExitCode(0);
     run.skip_foreign_checks = true;
diff --git a/test/standalone/dirname/exists_in.zig b/test/standalone/dirname/exists_in.zig
index 5900e76b574b1dd5d1628bc38e51133423b785cd..795b979e6f178a4cc65246d8ca0bb24480b1b075 100644
--- a/test/standalone/dirname/exists_in.zig
+++ b/test/standalone/dirname/exists_in.zig
@@ -26,7 +26,7 @@ pub fn main(init: std.process.Init) !void {
         return error.BadUsage;
     };
 
-    const io = std.Io.Threaded.global_single_threaded.ioBasic();
+    const io = std.Io.Threaded.global_single_threaded.io();
 
     var dir = try std.Io.Dir.cwd().openDir(io, dir_path, .{});
     defer dir.close(io);
diff --git a/test/standalone/dirname/touch.zig b/test/standalone/dirname/touch.zig
index 6b0dad536e4661244c70a5ecfb5c41035aec8f17..86aef059362b3e088f58a813a2e0de8043e6ac5e 100644
--- a/test/standalone/dirname/touch.zig
+++ b/test/standalone/dirname/touch.zig
@@ -21,7 +21,7 @@ pub fn main(init: std.process.Init) !void {
     const dir_path = std.Io.Dir.path.dirname(path) orelse unreachable;
     const basename = std.Io.Dir.path.basename(path);
 
-    const io = std.Io.Threaded.global_single_threaded.ioBasic();
+    const io = std.Io.Threaded.global_single_threaded.io();
 
     var dir = try std.Io.Dir.cwd().openDir(io, dir_path, .{});
     defer dir.close(io);
diff --git a/test/standalone/issue_5825/build.zig b/test/standalone/issue_5825/build.zig
index e102febe2dcb702f7df29a6a0b95b8f36d2d096f..e4bc348d78f5701244ffbcf9bdfff24eefabd86e 100644
--- a/test/standalone/issue_5825/build.zig
+++ b/test/standalone/issue_5825/build.zig
@@ -34,6 +34,7 @@ pub fn build(b: *std.Build) void {
     exe.subsystem = .console;
     exe.root_module.linkSystemLibrary("kernel32", .{});
     exe.root_module.linkSystemLibrary("ntdll", .{});
+    exe.root_module.linkSystemLibrary("ws2_32", .{});
     exe.root_module.addObject(obj);
 
     // TODO: actually check the output
diff --git a/test/standalone/mix_o_files/build.zig b/test/standalone/mix_o_files/build.zig
index 12b90f36247b379422b4ff616d671b85d5b5a66c..6ca7877058f2a5fb63e01eb796efd89b9a01f2bf 100644
--- a/test/standalone/mix_o_files/build.zig
+++ b/test/standalone/mix_o_files/build.zig
@@ -16,6 +16,9 @@ pub fn build(b: *std.Build) void {
         }),
     });
 
+    if (target.result.os.tag == .windows)
+        obj.root_module.linkSystemLibrary("ws2_32", .{});
+
     const exe = b.addExecutable(.{
         .name = "test",
         .root_module = b.createModule(.{
diff --git a/test/standalone/run_cwd/check_file_exists.zig b/test/standalone/run_cwd/check_file_exists.zig
index bd4a26b6668cdd328b86ebe43fd56f280e59b0f7..2687cd8488a4bd2bb7c9b747b80e9cfad86c3b07 100644
--- a/test/standalone/run_cwd/check_file_exists.zig
+++ b/test/standalone/run_cwd/check_file_exists.zig
@@ -5,7 +5,7 @@ pub fn main(init: std.process.Init) !void {
     if (args.len != 2) return error.BadUsage;
     const path = args[1];
 
-    const io = std.Io.Threaded.global_single_threaded.ioBasic();
+    const io = std.Io.Threaded.global_single_threaded.io();
 
     std.Io.Dir.cwd().access(io, path, .{}) catch return error.AccessFailed;
 }
diff --git a/test/standalone/shared_library/build.zig b/test/standalone/shared_library/build.zig
index 00c8e9cf34bd2951c814141103beef8d52b34f3c..3e9378eee02922d4024c3e5e6d2a31ea92b49842 100644
--- a/test/standalone/shared_library/build.zig
+++ b/test/standalone/shared_library/build.zig
@@ -5,7 +5,7 @@ pub fn build(b: *std.Build) void {
     b.default_step = test_step;
 
     const optimize: std.builtin.OptimizeMode = .Debug;
-    const target = b.graph.host;
+    const target = b.standardTargetOptions(.{});
 
     const exe_names: []const []const u8 = &.{ "test", "test-dync" };
     const lib_names: []const []const u8 = &.{ "mathtest", "mathtest-dync" };
@@ -24,6 +24,9 @@ pub fn build(b: *std.Build) void {
             }),
         });
 
+        if (target.result.os.tag == .windows)
+            lib.root_module.linkSystemLibrary("ws2_32", .{});
+
         const exe = b.addExecutable(.{
             .name = exe_name,
             .root_module = b.createModule(.{
diff --git a/test/standalone/windows_argv/build.zig b/test/standalone/windows_argv/build.zig
index 019cd34fc84c3f780d85ecbb41e10954bd929b5a..6d20b389c68b5e4bb74ce4efecaff66c272f2f52 100644
--- a/test/standalone/windows_argv/build.zig
+++ b/test/standalone/windows_argv/build.zig
@@ -20,6 +20,8 @@ pub fn build(b: *std.Build) !void {
             .optimize = optimize,
         }),
     });
+    lib_gnu.root_module.linkSystemLibrary("ws2_32", .{});
+
     const verify_gnu = b.addExecutable(.{
         .name = "verify-gnu",
         .root_module = b.createModule(.{
@@ -101,6 +103,7 @@ pub fn build(b: *std.Build) !void {
             .flags = &.{ "-DUNICODE", "-D_UNICODE" },
         });
         verify_msvc.root_module.linkLibrary(lib_msvc);
+        verify_msvc.root_module.linkSystemLibrary("ws2_32", .{});
         verify_msvc.root_module.link_libc = true;
 
         const run_msvc = b.addRunArtifact(fuzz);
-- 
2.54.0


From 1f92162875a3f05942dad6696b206cb9a1394f80 Mon Sep 17 00:00:00 2001
From: mihael <hi@mihaelm.com>
Date: Mon, 9 Mar 2026 23:17:46 +0100
Subject: [PATCH 404/499] Reimplement `cosh` in `libzigc`

The function basically calls the Zig std's implementation.
The changes were tested by running:

```
$ ./build/stage3/bin/zig build -p stage4 -Denable-llvm -Dno-lib

$ stage4/bin/zig build test-libc -Dlibc-test-path=<LIBC-TEST-PATH> -Dtest-filter=cosh -fqemu -fwasmtime --summary line
Build Summary: 921/921 steps succeeded
```
---
 lib/c/math.zig                                |  5 +++
 lib/libc/musl/src/math/cosh.c                 | 40 -----------------
 .../wasi/libc-top-half/musl/src/math/cosh.c   | 44 -------------------
 src/libs/musl.zig                             |  1 -
 src/libs/wasi_libc.zig                        |  1 -
 5 files changed, 5 insertions(+), 86 deletions(-)
 delete mode 100644 lib/libc/musl/src/math/cosh.c
 delete mode 100644 lib/libc/wasi/libc-top-half/musl/src/math/cosh.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index cce37f9000858b41b08d14a9012f5e607a2b2367..ae3491e430c4cb433ab01430b93193ed732ed14b 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -45,6 +45,7 @@ comptime {
         symbol(&atanl, "atanl");
         symbol(&cbrt, "cbrt");
         symbol(&cbrtf, "cbrtf");
+        symbol(&cosh, "cosh");
         symbol(&exp10, "exp10");
         symbol(&exp10f, "exp10f");
         symbol(&hypot, "hypot");
@@ -125,6 +126,10 @@ fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     return math.copysign(x, y);
 }
 
+fn cosh(x: f64) callconv(.c) f64 {
+    return math.cosh(x);
+}
+
 fn cbrt(x: f64) callconv(.c) f64 {
     return math.cbrt(x);
 }
diff --git a/lib/libc/musl/src/math/cosh.c b/lib/libc/musl/src/math/cosh.c
deleted file mode 100644
index 490c15fb166752d18fa4015401f5a27fd34337b6..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/cosh.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "libm.h"
-
-/* cosh(x) = (exp(x) + 1/exp(x))/2
- *         = 1 + 0.5*(exp(x)-1)*(exp(x)-1)/exp(x)
- *         = 1 + x*x/2 + o(x^4)
- */
-double cosh(double x)
-{
-	union {double f; uint64_t i;} u = {.f = x};
-	uint32_t w;
-	double t;
-
-	/* |x| */
-	u.i &= (uint64_t)-1/2;
-	x = u.f;
-	w = u.i >> 32;
-
-	/* |x| < log(2) */
-	if (w < 0x3fe62e42) {
-		if (w < 0x3ff00000 - (26<<20)) {
-			/* raise inexact if x!=0 */
-			FORCE_EVAL(x + 0x1p120f);
-			return 1;
-		}
-		t = expm1(x);
-		return 1 + t*t/(2*(1+t));
-	}
-
-	/* |x| < log(DBL_MAX) */
-	if (w < 0x40862e42) {
-		t = exp(x);
-		/* note: if x>log(0x1p26) then the 1/t is not needed */
-		return 0.5*(t + 1/t);
-	}
-
-	/* |x| > log(DBL_MAX) or nan */
-	/* note: the result is stored to handle overflow */
-	t = __expo2(x, 1.0);
-	return t;
-}
diff --git a/lib/libc/wasi/libc-top-half/musl/src/math/cosh.c b/lib/libc/wasi/libc-top-half/musl/src/math/cosh.c
deleted file mode 100644
index 2cdf0023f8b3725d12c8ec96ba0e6ed30f1d5aae..0000000000000000000000000000000000000000
--- a/lib/libc/wasi/libc-top-half/musl/src/math/cosh.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "libm.h"
-
-/* cosh(x) = (exp(x) + 1/exp(x))/2
- *         = 1 + 0.5*(exp(x)-1)*(exp(x)-1)/exp(x)
- *         = 1 + x*x/2 + o(x^4)
- */
-double cosh(double x)
-{
-	union {double f; uint64_t i;} u = {.f = x};
-	uint32_t w;
-	double t;
-
-	/* |x| */
-	u.i &= (uint64_t)-1/2;
-	x = u.f;
-	w = u.i >> 32;
-
-	/* |x| < log(2) */
-	if (w < 0x3fe62e42) {
-		if (w < 0x3ff00000 - (26<<20)) {
-			/* raise inexact if x!=0 */
-			FORCE_EVAL(x + 0x1p120f);
-			return 1;
-		}
-		t = expm1(x);
-		return 1 + t*t/(2*(1+t));
-	}
-
-	/* |x| < log(DBL_MAX) */
-	if (w < 0x40862e42) {
-		t = exp(x);
-		/* note: if x>log(0x1p26) then the 1/t is not needed */
-		return 0.5*(t + 1/t);
-	}
-
-	/* |x| > log(DBL_MAX) or nan */
-	/* note: the result is stored to handle overflow */
-#ifdef __wasilibc_unmodified_upstream // Wasm doesn't have alternate rounding modes
-	t = __expo2(x, 1.0);
-#else
-	t = __expo2(x);
-#endif
-	return t;
-}
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index d8f5fe28121d5b1e93507bae4edee26c2456ea57..eb49d4c4f136f9b166f4dc81593d7d2ecc9b8daf 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -819,7 +819,6 @@ const src_files = [_][]const u8{
     "musl/src/math/cbrtl.c",
     "musl/src/math/__cos.c",
     "musl/src/math/__cosdf.c",
-    "musl/src/math/cosh.c",
     "musl/src/math/coshf.c",
     "musl/src/math/coshl.c",
     "musl/src/math/__cosl.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 0bdcb724c50c1db7a6253f042d20e0fb4c2e09c9..72b19fe2e6e88e9cb8ead76bd4178248ef1c633c 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -1003,7 +1003,6 @@ const libc_top_half_src_files = [_][]const u8{
     "wasi/libc-top-half/musl/src/locale/locale_map.c",
     "wasi/libc-top-half/musl/src/locale/newlocale.c",
     "wasi/libc-top-half/musl/src/locale/uselocale.c",
-    "wasi/libc-top-half/musl/src/math/cosh.c",
     "wasi/libc-top-half/musl/src/math/coshf.c",
     "wasi/libc-top-half/musl/src/math/__expo2.c",
     "wasi/libc-top-half/musl/src/math/__expo2f.c",
-- 
2.54.0


From 159568a05a222681f54a27310ac15c3043563f95 Mon Sep 17 00:00:00 2001
From: mihael <hi@mihaelm.com>
Date: Tue, 10 Mar 2026 00:09:00 +0100
Subject: [PATCH 405/499] Reimplement `coshf` in `libzigc`

The function basically calls the Zig std's implementation.

The changes were tested by running:

```
$ ./build/stage3/bin/zig build -p stage4 -Denable-llvm -Dno-lib

$ stage4/bin/zig build test-libc -Dlibc-test-path=<LIBC-TEST-PATH> -Dtest-filter=coshf -fqemu -fwasmtime --summary line
Build Summary: 553/553 steps succeeded
```
---
 lib/c/math.zig                                |  5 +++
 lib/libc/mingw/math/coshf.c                   | 10 -----
 lib/libc/musl/src/math/coshf.c                | 33 -----------------
 .../wasi/libc-top-half/musl/src/math/coshf.c  | 37 -------------------
 src/libs/mingw.zig                            |  1 -
 src/libs/musl.zig                             |  1 -
 src/libs/wasi_libc.zig                        |  1 -
 7 files changed, 5 insertions(+), 83 deletions(-)
 delete mode 100644 lib/libc/mingw/math/coshf.c
 delete mode 100644 lib/libc/musl/src/math/coshf.c
 delete mode 100644 lib/libc/wasi/libc-top-half/musl/src/math/coshf.c

diff --git a/lib/c/math.zig b/lib/c/math.zig
index ae3491e430c4cb433ab01430b93193ed732ed14b..281b898ac2061cdad1c41a9fe56361ae9724a3f7 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -31,6 +31,7 @@ comptime {
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        symbol(&coshf, "coshf");
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
         symbol(&nan, "nan");
@@ -130,6 +131,10 @@ fn cosh(x: f64) callconv(.c) f64 {
     return math.cosh(x);
 }
 
+fn coshf(x: f32) callconv(.c) f32 {
+    return math.cosh(x);
+}
+
 fn cbrt(x: f64) callconv(.c) f64 {
     return math.cbrt(x);
 }
diff --git a/lib/libc/mingw/math/coshf.c b/lib/libc/mingw/math/coshf.c
deleted file mode 100644
index 72147f5bfbcb77fdb2754e876472f33583ae2756..0000000000000000000000000000000000000000
--- a/lib/libc/mingw/math/coshf.c
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <math.h>
-float coshf (float x)
-{
-  return (float) cosh (x);
-}
diff --git a/lib/libc/musl/src/math/coshf.c b/lib/libc/musl/src/math/coshf.c
deleted file mode 100644
index e739cff93b1325f931198d8d75b3313359803752..0000000000000000000000000000000000000000
--- a/lib/libc/musl/src/math/coshf.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "libm.h"
-
-float coshf(float x)
-{
-	union {float f; uint32_t i;} u = {.f = x};
-	uint32_t w;
-	float t;
-
-	/* |x| */
-	u.i &= 0x7fffffff;
-	x = u.f;
-	w = u.i;
-
-	/* |x| < log(2) */
-	if (w < 0x3f317217) {
-		if (w < 0x3f800000 - (12<<23)) {
-			FORCE_EVAL(x + 0x1p120f);
-			return 1;
-		}
-		t = expm1f(x);
-		return 1 + t*t/(2*(1+t));
-	}
-
-	/* |x| < log(FLT_MAX) */
-	if (w < 0x42b17217) {
-		t = expf(x);
-		return 0.5f*(t + 1/t);
-	}
-
-	/* |x| > log(FLT_MAX) or nan */
-	t = __expo2f(x, 1.0f);
-	return t;
-}
diff --git a/lib/libc/wasi/libc-top-half/musl/src/math/coshf.c b/lib/libc/wasi/libc-top-half/musl/src/math/coshf.c
deleted file mode 100644
index b946c0b068e6292ac99a53d855fb8b3a6f91bef3..0000000000000000000000000000000000000000
--- a/lib/libc/wasi/libc-top-half/musl/src/math/coshf.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "libm.h"
-
-float coshf(float x)
-{
-	union {float f; uint32_t i;} u = {.f = x};
-	uint32_t w;
-	float t;
-
-	/* |x| */
-	u.i &= 0x7fffffff;
-	x = u.f;
-	w = u.i;
-
-	/* |x| < log(2) */
-	if (w < 0x3f317217) {
-		if (w < 0x3f800000 - (12<<23)) {
-			FORCE_EVAL(x + 0x1p120f);
-			return 1;
-		}
-		t = expm1f(x);
-		return 1 + t*t/(2*(1+t));
-	}
-
-	/* |x| < log(FLT_MAX) */
-	if (w < 0x42b17217) {
-		t = expf(x);
-		return 0.5f*(t + 1/t);
-	}
-
-	/* |x| > log(FLT_MAX) or nan */
-#ifdef __wasilibc_unmodified_upstream // Wasm doesn't have alternate rounding modes
-	t = __expo2f(x, 1.0f);
-#else
-	t = __expo2f(x);
-#endif
-	return t;
-}
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index 0be2b7c0a8c4a13faaac25ad2b3d654d8bd23d1e..70e0d6e8c019e760144004437e10f2e42c0123f5 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -977,7 +977,6 @@ const mingw32_x86_src = [_][]const u8{
 
 const mingw32_x86_32_src = [_][]const u8{
     // ucrtbase
-    "math" ++ path.sep_str ++ "coshf.c",
     "math" ++ path.sep_str ++ "modff.c",
     "math" ++ path.sep_str ++ "powf.c",
     "math" ++ path.sep_str ++ "sinhf.c",
diff --git a/src/libs/musl.zig b/src/libs/musl.zig
index eb49d4c4f136f9b166f4dc81593d7d2ecc9b8daf..482c1a1b29190bac0e48368ab61d77ec196ce157 100644
--- a/src/libs/musl.zig
+++ b/src/libs/musl.zig
@@ -819,7 +819,6 @@ const src_files = [_][]const u8{
     "musl/src/math/cbrtl.c",
     "musl/src/math/__cos.c",
     "musl/src/math/__cosdf.c",
-    "musl/src/math/coshf.c",
     "musl/src/math/coshl.c",
     "musl/src/math/__cosl.c",
     "musl/src/math/cosl.c",
diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig
index 72b19fe2e6e88e9cb8ead76bd4178248ef1c633c..67c1b0e74c2a54bea0e7948fff34205201f3ce7d 100644
--- a/src/libs/wasi_libc.zig
+++ b/src/libs/wasi_libc.zig
@@ -1003,7 +1003,6 @@ const libc_top_half_src_files = [_][]const u8{
     "wasi/libc-top-half/musl/src/locale/locale_map.c",
     "wasi/libc-top-half/musl/src/locale/newlocale.c",
     "wasi/libc-top-half/musl/src/locale/uselocale.c",
-    "wasi/libc-top-half/musl/src/math/coshf.c",
     "wasi/libc-top-half/musl/src/math/__expo2.c",
     "wasi/libc-top-half/musl/src/math/__expo2f.c",
     "wasi/libc-top-half/musl/src/math/fmal.c",
-- 
2.54.0


From 4a0be5613b865c345e2b9daade65ee6fbb139e39 Mon Sep 17 00:00:00 2001
From: mihael <hi@mihaelm.com>
Date: Tue, 10 Mar 2026 00:40:23 +0100
Subject: [PATCH 406/499] Alphabetically sort functions in `libzigc/math`

The functions were sorted alphabetically for easier navigation, and less
confusion where to add a new one. The sorting of comptime exports was
done within the visual "blocks".
---
 lib/c/math.zig | 95 +++++++++++++++++++++++++-------------------------
 1 file changed, 48 insertions(+), 47 deletions(-)

diff --git a/lib/c/math.zig b/lib/c/math.zig
index 281b898ac2061cdad1c41a9fe56361ae9724a3f7..501df810d693e43c2330238dca53e50044c4da0f 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -14,20 +14,20 @@ comptime {
         symbol(&isnanl, "isnanl");
         symbol(&isnanl, "__isnanl");
 
+        symbol(&math.floatTrueMin(f64), "__DENORM");
+        symbol(&math.inf(f64), "__INF");
         symbol(&math.nan(f64), "__QNAN");
         symbol(&math.snan(f64), "__SNAN");
-        symbol(&math.inf(f64), "__INF");
-        symbol(&math.floatTrueMin(f64), "__DENORM");
 
+        symbol(&math.floatTrueMin(f32), "__DENORMF");
+        symbol(&math.inf(f32), "__INFF");
         symbol(&math.nan(f32), "__QNANF");
         symbol(&math.snan(f32), "__SNANF");
-        symbol(&math.inf(f32), "__INFF");
-        symbol(&math.floatTrueMin(f32), "__DENORMF");
 
+        symbol(&math.floatTrueMin(c_longdouble), "__DENORML");
+        symbol(&math.inf(c_longdouble), "__INFL");
         symbol(&math.nan(c_longdouble), "__QNANL");
         symbol(&math.snan(c_longdouble), "__SNANL");
-        symbol(&math.inf(c_longdouble), "__INFL");
-        symbol(&math.floatTrueMin(c_longdouble), "__DENORML");
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -41,8 +41,9 @@ comptime {
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&acos, "acos");
-        symbol(&atanf, "atanf");
+        symbol(&acosf, "acosf");
         symbol(&atan, "atan");
+        symbol(&atanf, "atanf");
         symbol(&atanl, "atanl");
         symbol(&cbrt, "cbrt");
         symbol(&cbrtf, "cbrtf");
@@ -53,14 +54,14 @@ comptime {
         symbol(&pow, "pow");
         symbol(&pow10, "pow10");
         symbol(&pow10f, "pow10f");
-        symbol(&acosf, "acosf");
     }
 
     if (builtin.target.isMuslLibC()) {
-        symbol(&copysignf, "copysignf");
         symbol(&copysign, "copysign");
+        symbol(&copysignf, "copysignf");
         symbol(&rint, "rint");
     }
+
     symbol(&copysignl, "copysignl");
 }
 
@@ -68,14 +69,18 @@ fn acos(x: f64) callconv(.c) f64 {
     return math.acos(x);
 }
 
-fn atanf(x: f32) callconv(.c) f32 {
-    return math.atan(x);
+fn acosf(x: f32) callconv(.c) f32 {
+    return std.math.acos(x);
 }
 
 fn atan(x: f64) callconv(.c) f64 {
     return math.atan(x);
 }
 
+fn atanf(x: f32) callconv(.c) f32 {
+    return math.atan(x);
+}
+
 fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
     return switch (@typeInfo(@TypeOf(x)).float.bits) {
         16 => math.atan(@as(f16, @floatCast(x))),
@@ -87,42 +92,22 @@ fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
     };
 }
 
-fn acosf(x: f32) callconv(.c) f32 {
-    return std.math.acos(x);
+fn cbrt(x: f64) callconv(.c) f64 {
+    return math.cbrt(x);
 }
 
-fn isnan(x: f64) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
-}
-
-fn isnanf(x: f32) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
-}
-
-fn isnanl(x: c_longdouble) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
-}
-
-fn nan(_: [*:0]const c_char) callconv(.c) f64 {
-    return math.nan(f64);
-}
-
-fn nanf(_: [*:0]const c_char) callconv(.c) f32 {
-    return math.nan(f32);
-}
-
-fn nanl(_: [*:0]const c_char) callconv(.c) c_longdouble {
-    return math.nan(c_longdouble);
-}
-
-fn copysignf(x: f32, y: f32) callconv(.c) f32 {
-    return math.copysign(x, y);
+fn cbrtf(x: f32) callconv(.c) f32 {
+    return math.cbrt(x);
 }
 
 fn copysign(x: f64, y: f64) callconv(.c) f64 {
     return math.copysign(x, y);
 }
 
+fn copysignf(x: f32, y: f32) callconv(.c) f32 {
+    return math.copysign(x, y);
+}
+
 fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     return math.copysign(x, y);
 }
@@ -135,14 +120,6 @@ fn coshf(x: f32) callconv(.c) f32 {
     return math.cosh(x);
 }
 
-fn cbrt(x: f64) callconv(.c) f64 {
-    return math.cbrt(x);
-}
-
-fn cbrtf(x: f32) callconv(.c) f32 {
-    return math.cbrt(x);
-}
-
 fn exp10(x: f64) callconv(.c) f64 {
     return math.pow(f64, 10.0, x);
 }
@@ -163,6 +140,30 @@ fn hypotl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     return math.hypot(x, y);
 }
 
+fn isnan(x: f64) callconv(.c) c_int {
+    return if (math.isNan(x)) 1 else 0;
+}
+
+fn isnanf(x: f32) callconv(.c) c_int {
+    return if (math.isNan(x)) 1 else 0;
+}
+
+fn isnanl(x: c_longdouble) callconv(.c) c_int {
+    return if (math.isNan(x)) 1 else 0;
+}
+
+fn nan(_: [*:0]const c_char) callconv(.c) f64 {
+    return math.nan(f64);
+}
+
+fn nanf(_: [*:0]const c_char) callconv(.c) f32 {
+    return math.nan(f32);
+}
+
+fn nanl(_: [*:0]const c_char) callconv(.c) c_longdouble {
+    return math.nan(c_longdouble);
+}
+
 fn pow(x: f64, y: f64) callconv(.c) f64 {
     return math.pow(f64, x, y);
 }
-- 
2.54.0


From 5318045b88f05c8c3505287114e1caec562de763 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 9 Mar 2026 21:24:59 -0700
Subject: [PATCH 407/499] std.Io.Writer: document write and writeAll

closes #31435
---
 lib/std/Io/Writer.zig | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig
index d1cea560c3611fc760f524041daac22fdf586147..0df202e68fc247e91b58a91556eb5d507d5fcacc 100644
--- a/lib/std/Io/Writer.zig
+++ b/lib/std/Io/Writer.zig
@@ -518,6 +518,17 @@ test "writeSplatAll works with a single buffer" {
     try testing.expectEqualStrings("hellohellohello", aw.writer.buffered());
 }
 
+/// Transfers `bytes` to the stream, calling `drain` at most once.
+///
+/// Returns the number of bytes transferred, which may be less than
+/// `bytes.len`, including zero.
+///
+/// A return value less than `bytes.len` does not indicate failure; a
+/// subsequent call may return nonzero, or fail with `error.WriteFailed`.
+///
+/// See also:
+/// * `writeAll`
+/// * `writeVec`
 pub fn write(w: *Writer, bytes: []const u8) Error!usize {
     if (w.end + bytes.len <= w.buffer.len) {
         @branchHint(.likely);
@@ -528,8 +539,13 @@ pub fn write(w: *Writer, bytes: []const u8) Error!usize {
     return w.vtable.drain(w, &.{bytes}, 1);
 }
 
-/// Calls `drain` as many times as necessary such that all of `bytes` are
-/// transferred.
+/// Transfers `bytes` to the stream, calling `drain` as many times as necessary
+/// such that all `bytes` are transferred.
+///
+/// See also:
+/// * `print`
+/// * `writeVecAll`
+/// * `write`
 pub fn writeAll(w: *Writer, bytes: []const u8) Error!void {
     var index: usize = 0;
     while (index < bytes.len) index += try w.write(bytes[index..]);
-- 
2.54.0


From 416ef983c40cf96b522fd976b8fbaf82eaf63906 Mon Sep 17 00:00:00 2001
From: DivergentClouds <27089165+DivergentClouds@users.noreply.github.com>
Date: Wed, 4 Sep 2024 07:28:55 -0700
Subject: [PATCH 408/499] add test for Lock.none

---
 lib/std/fs/test.zig | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 977a285fb4cc122d6cc82da157844df143973494..3201b35166de4c9e119f119bd28f839308aaf419 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -1843,6 +1843,33 @@ test "read from locked file" {
     }.impl);
 }
 
+test "use Lock.none to unlock files" {
+    if (native_os == .wasi) return error.SkipZigTest;
+
+    const io = testing.io;
+
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
+
+    // Create a locked file.
+    const test_file = try tmp.dir.createFile(io, "test_file", .{ .lock = .exclusive, .lock_nonblocking = true });
+    defer test_file.close(io);
+
+    // Attempt to unlock the file via fs.lock with Lock.none.
+    try test_file.lock(io, .none);
+
+    // Attempt to open the file now that it should be unlocked.
+    const test_file2 = try tmp.dir.openFile(io, "test_file", .{ .lock = .exclusive, .lock_nonblocking = true });
+    defer test_file2.close(io);
+
+    // Make sure Lock.none works with tryLock as well.
+    try testing.expect(try test_file2.tryLock(io, .none));
+
+    // Attempt to open the file since it should be unlocked again.
+    const test_file3 = try tmp.dir.openFile(io, "test_file", .{ .lock = .exclusive, .lock_nonblocking = true });
+    test_file3.close(io);
+}
+
 test "walker" {
     const io = testing.io;
 
-- 
2.54.0


From a5dd6444c39e3852962a3b1a74d832ca9fdadd32 Mon Sep 17 00:00:00 2001
From: samy007 <samy2014@free.fr>
Date: Sun, 28 Jul 2024 14:13:58 +0200
Subject: [PATCH 409/499] Add test for calling statFile on a symlink

---
 lib/std/fs/test.zig | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 3201b35166de4c9e119f119bd28f839308aaf419..52b0df581fbcb4b8d8674425489826d86dce0c2a 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -298,6 +298,28 @@ test "File.stat on a File that is a symlink returns Kind.sym_link" {
     }.impl);
 }
 
+test "Dir.statFile on a symlink" {
+    const io = testing.io;
+
+    try testWithAllSupportedPathTypes(struct {
+        fn impl(ctx: *TestContext) !void {
+            const dir_target_path = try ctx.transformPath("test_file");
+            try ctx.dir.writeFile(io, .{
+                .sub_path = dir_target_path,
+                .data = "Some test content",
+            });
+
+            try setupSymlink(io, ctx.dir, dir_target_path, "symlink", .{});
+
+            const file_stat = try ctx.dir.statFile(io, "test_file", .{ .follow_symlinks = false });
+            try testing.expectEqual(File.Kind.file, file_stat.kind);
+
+            const link_stat = try ctx.dir.statFile(io, "symlink", .{ .follow_symlinks = false });
+            try testing.expectEqual(File.Kind.sym_link, link_stat.kind);
+        }
+    }.impl);
+}
+
 test "openDir" {
     const io = testing.io;
 
-- 
2.54.0


From cfe5c88ad6081e284d0caf36cf8d7e80fe39b676 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 10 Mar 2026 09:19:28 +0100
Subject: [PATCH 410/499] std.Io.RwLock: disable `smoke test` on any aarch64
 target

https://codeberg.org/ziglang/zig/issues/31393#issuecomment-11441755
---
 lib/std/Io/RwLock.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/RwLock.zig b/lib/std/Io/RwLock.zig
index fff958efe9a8db7d3d6c2c03349acbfc270453bf..586a94af034d50ed0d632f97abaa29ff29b280b5 100644
--- a/lib/std/Io/RwLock.zig
+++ b/lib/std/Io/RwLock.zig
@@ -114,7 +114,7 @@ test "internal state" {
 }
 
 test "smoke test" {
-    if (builtin.target.cpu.arch.isAARCH64() and builtin.target.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31393
+    if (builtin.target.cpu.arch.isAARCH64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31393
 
     const io = testing.io;
 
-- 
2.54.0


From 048e38624e1b7c1ad140e253f1e5e7c868658089 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 10 Mar 2026 09:17:42 +0100
Subject: [PATCH 411/499] fix: use cmpxchgStrong in `Io.Mutex`

* `cmpxchgWeak` can fail spuriously on LL/SC architectures
and `tryLock` would invalidly return false in those cases.
---
 lib/std/Io.zig | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 87f342f640316343440e5f93e2c1924b81a51c6e..8d51f649e3e79180860e02c2e4930e975cce7e33 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -1577,11 +1577,11 @@ pub const Mutex = extern struct {
     };
 
     pub fn tryLock(m: *Mutex) bool {
-        return m.state.cmpxchgWeak(.unlocked, .locked_once, .acquire, .monotonic) == null;
+        return m.state.cmpxchgStrong(.unlocked, .locked_once, .acquire, .monotonic) == null;
     }
 
     pub fn lock(m: *Mutex, io: Io) Cancelable!void {
-        const initial_state = m.state.cmpxchgWeak(
+        const initial_state = m.state.cmpxchgStrong(
             .unlocked,
             .locked_once,
             .acquire,
@@ -1602,7 +1602,7 @@ pub const Mutex = extern struct {
     ///
     /// For a description of cancelation and cancelation points, see `Future.cancel`.
     pub fn lockUncancelable(m: *Mutex, io: Io) void {
-        const initial_state = m.state.cmpxchgWeak(
+        const initial_state = m.state.cmpxchgStrong(
             .unlocked,
             .locked_once,
             .acquire,
-- 
2.54.0


From 7c2699bed2bf929eb116aa6b1a8e0ed1fd66240b Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 10 Mar 2026 10:05:25 +0100
Subject: [PATCH 412/499] Revert "std.Io.RwLock: disable `smoke test` on any
 aarch64 target"

This reverts commit cfe5c88ad6081e284d0caf36cf8d7e80fe39b676.
---
 lib/std/Io/RwLock.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/Io/RwLock.zig b/lib/std/Io/RwLock.zig
index 586a94af034d50ed0d632f97abaa29ff29b280b5..fff958efe9a8db7d3d6c2c03349acbfc270453bf 100644
--- a/lib/std/Io/RwLock.zig
+++ b/lib/std/Io/RwLock.zig
@@ -114,7 +114,7 @@ test "internal state" {
 }
 
 test "smoke test" {
-    if (builtin.target.cpu.arch.isAARCH64()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31393
+    if (builtin.target.cpu.arch.isAARCH64() and builtin.target.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31393
 
     const io = testing.io;
 
-- 
2.54.0


From 2370dc886cf4bc919d912ea3c0a564f71675fd2e Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 10 Mar 2026 10:05:40 +0100
Subject: [PATCH 413/499] Revert "std.Io.RwLock: disable `smoke test` on
 aarch64-netbsd"

This reverts commit 0ae1c6b54acf112c7bbcc63a19f7ad8fa9842d2a.
---
 lib/std/Io/RwLock.zig | 2 --
 1 file changed, 2 deletions(-)

diff --git a/lib/std/Io/RwLock.zig b/lib/std/Io/RwLock.zig
index fff958efe9a8db7d3d6c2c03349acbfc270453bf..7be4f026e16c150feef443286315567add6bf69c 100644
--- a/lib/std/Io/RwLock.zig
+++ b/lib/std/Io/RwLock.zig
@@ -114,8 +114,6 @@ test "internal state" {
 }
 
 test "smoke test" {
-    if (builtin.target.cpu.arch.isAARCH64() and builtin.target.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31393
-
     const io = testing.io;
 
     var rl: Io.RwLock = .init;
-- 
2.54.0


From 5e8397d5e03269d8a39efb22605ea20102848084 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 12 Jan 2026 14:47:14 +0000
Subject: [PATCH 414/499] Zir: rework container type declarations

Only AstGen and print_zir currently support the new representation, so
attempting to build the compiler will emit (many) compile errors.
---
 lib/std/zig/AstGen.zig | 1652 +++++++++++++---------------------------
 lib/std/zig/Zir.zig    |  942 ++++++++++++++---------
 src/print_zir.zig      |  537 +++----------
 3 files changed, 1205 insertions(+), 1926 deletions(-)

diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 667f5ef045bd431512b3aed957be43e125ddb0ad..6a6585192ddb7efd7dc1b6455ce28cdf27425530 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -3975,81 +3975,67 @@ fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.
     return rvalue(gz, ri, result, node);
 }
 
-const WipMembers = struct {
-    payload: *ArrayList(u32),
-    payload_top: usize,
-    field_bits_start: u32,
-    fields_start: u32,
-    fields_end: u32,
-    decl_index: u32 = 0,
-    field_index: u32 = 0,
-
-    const Self = @This();
-
-    fn init(gpa: Allocator, payload: *ArrayList(u32), decl_count: u32, field_count: u32, comptime bits_per_field: u32, comptime max_field_size: u32) Allocator.Error!Self {
-        const payload_top: u32 = @intCast(payload.items.len);
-        const field_bits_start = payload_top + decl_count;
-        const fields_start = field_bits_start + if (bits_per_field > 0) blk: {
-            const fields_per_u32 = 32 / bits_per_field;
-            break :blk (field_count + fields_per_u32 - 1) / fields_per_u32;
-        } else 0;
-        const payload_end = fields_start + field_count * max_field_size;
-        try payload.resize(gpa, payload_end);
+const Scratch = struct {
+    astgen: *AstGen,
+    scratch_top: u32,
+    fn init(astgen: *AstGen) Scratch {
         return .{
-            .payload = payload,
-            .payload_top = payload_top,
-            .field_bits_start = field_bits_start,
-            .fields_start = fields_start,
-            .fields_end = fields_start,
+            .astgen = astgen,
+            .scratch_top = @intCast(astgen.scratch.items.len),
         };
     }
-
-    fn nextDecl(self: *Self, decl_inst: Zir.Inst.Index) void {
-        self.payload.items[self.payload_top + self.decl_index] = @intFromEnum(decl_inst);
-        self.decl_index += 1;
+    fn reset(s: *Scratch) void {
+        s.astgen.scratch.shrinkRetainingCapacity(s.scratch_top);
+        s.* = undefined;
     }
-
-    fn nextField(self: *Self, comptime bits_per_field: u32, bits: [bits_per_field]bool) void {
-        const fields_per_u32 = 32 / bits_per_field;
-        const index = self.field_bits_start + self.field_index / fields_per_u32;
-        assert(index < self.fields_start);
-        var bit_bag: u32 = if (self.field_index % fields_per_u32 == 0) 0 else self.payload.items[index];
-        bit_bag >>= bits_per_field;
-        comptime var i = 0;
-        inline while (i < bits_per_field) : (i += 1) {
-            bit_bag |= @as(u32, @intFromBool(bits[i])) << (32 - bits_per_field + i);
-        }
-        self.payload.items[index] = bit_bag;
-        self.field_index += 1;
+    fn addSlice(s: *Scratch, len: u32) Allocator.Error!Slice {
+        const start: u32 = @intCast(s.astgen.scratch.items.len);
+        try s.astgen.scratch.resize(s.astgen.gpa, start + len);
+        return .{ .start = start, .len = len };
     }
-
-    fn appendToField(self: *Self, data: u32) void {
-        assert(self.fields_end < self.payload.items.len);
-        self.payload.items[self.fields_end] = data;
-        self.fields_end += 1;
+    fn addOptionalSlice(s: *Scratch, present: bool, len: u32) Allocator.Error!?Slice {
+        if (!present) return null;
+        return try addSlice(s, len);
     }
-
-    fn finishBits(self: *Self, comptime bits_per_field: u32) void {
-        if (bits_per_field > 0) {
-            const fields_per_u32 = 32 / bits_per_field;
-            const empty_field_slots = fields_per_u32 - (self.field_index % fields_per_u32);
-            if (self.field_index > 0 and empty_field_slots < fields_per_u32) {
-                const index = self.field_bits_start + self.field_index / fields_per_u32;
-                self.payload.items[index] >>= @intCast(empty_field_slots * bits_per_field);
-            }
-        }
+    fn appendBodyWithFixups(s: *Scratch, body: []const Zir.Inst.Index) Allocator.Error!u32 {
+        const len = countBodyLenAfterFixups(s.astgen, body);
+        try s.astgen.scratch.ensureUnusedCapacity(s.astgen.gpa, len);
+        appendBodyWithFixupsArrayList(s.astgen, &s.astgen.scratch, body);
+        return len;
     }
-
-    fn declsSlice(self: *Self) []u32 {
-        return self.payload.items[self.payload_top..][0..self.decl_index];
+    /// Returns the slice containing all data added to this `Scratch`.
+    fn all(s: *Scratch) Slice {
+        const len = s.astgen.scratch.items.len - s.scratch_top;
+        return .{ .start = s.scratch_top, .len = @intCast(len) };
     }
+    const Slice = struct {
+        start: u32,
+        len: u32,
+        fn get(s: Slice, astgen: *AstGen) []u32 {
+            return astgen.scratch.items[s.start..][0..s.len];
+        }
+    };
+};
 
-    fn fieldsSlice(self: *Self) []u32 {
-        return self.payload.items[self.field_bits_start..self.fields_end];
-    }
+const WipDecls = struct {
+    astgen: *AstGen,
+    slice: Scratch.Slice,
+    index: u32,
 
-    fn deinit(self: *Self) void {
-        self.payload.items.len = self.payload_top;
+    fn init(scratch: *Scratch, decls_len: u32) Allocator.Error!WipDecls {
+        return .{
+            .astgen = scratch.astgen,
+            .slice = try scratch.addSlice(decls_len),
+            .index = 0,
+        };
+    }
+    fn finish(wip: *WipDecls) void {
+        assert(wip.index == wip.slice.len);
+        wip.* = undefined;
+    }
+    fn nextDecl(wip: *WipDecls, decl_inst: Zir.Inst.Index) void {
+        wip.slice.get(wip.astgen)[wip.index] = @intFromEnum(decl_inst);
+        wip.index += 1;
     }
 };
 
@@ -4057,7 +4043,7 @@ fn fnDecl(
     astgen: *AstGen,
     gz: *GenZir,
     scope: *Scope,
-    wip_members: *WipMembers,
+    wip_decls: *WipDecls,
     decl_node: Ast.Node.Index,
     body_node: Ast.Node.OptionalIndex,
     fn_proto: Ast.full.FnProto,
@@ -4133,7 +4119,7 @@ fn fnDecl(
         assert(!is_extern); // validated by parser (TODO why???)
     }
 
-    wip_members.nextDecl(decl_inst);
+    wip_decls.nextDecl(decl_inst);
 
     var type_gz: GenZir = .{
         .is_comptime = true,
@@ -4488,7 +4474,7 @@ fn globalVarDecl(
     astgen: *AstGen,
     gz: *GenZir,
     scope: *Scope,
-    wip_members: *WipMembers,
+    wip_decls: *WipDecls,
     node: Ast.Node.Index,
     var_decl: Ast.full.VarDecl,
 ) InnerError!void {
@@ -4533,7 +4519,7 @@ fn globalVarDecl(
     const decl_column = astgen.source_column;
 
     const decl_inst = try gz.makeDeclaration(node);
-    wip_members.nextDecl(decl_inst);
+    wip_decls.nextDecl(decl_inst);
 
     if (var_decl.ast.init_node.unwrap()) |init_node| {
         if (is_extern) {
@@ -4635,7 +4621,7 @@ fn comptimeDecl(
     astgen: *AstGen,
     gz: *GenZir,
     scope: *Scope,
-    wip_members: *WipMembers,
+    wip_decls: *WipDecls,
     node: Ast.Node.Index,
 ) InnerError!void {
     const tree = astgen.tree;
@@ -4650,7 +4636,7 @@ fn comptimeDecl(
     // Up top so the ZIR instruction index marks the start range of this
     // top-level declaration.
     const decl_inst = try gz.makeDeclaration(node);
-    wip_members.nextDecl(decl_inst);
+    wip_decls.nextDecl(decl_inst);
     astgen.advanceSourceCursorToNode(node);
 
     // This is just needed for the `setDeclaration` call.
@@ -4698,7 +4684,7 @@ fn testDecl(
     astgen: *AstGen,
     gz: *GenZir,
     scope: *Scope,
-    wip_members: *WipMembers,
+    wip_decls: *WipDecls,
     node: Ast.Node.Index,
 ) InnerError!void {
     const tree = astgen.tree;
@@ -4714,7 +4700,7 @@ fn testDecl(
     // top-level declaration.
     const decl_inst = try gz.makeDeclaration(node);
 
-    wip_members.nextDecl(decl_inst);
+    wip_decls.nextDecl(decl_inst);
     astgen.advanceSourceCursorToNode(node);
 
     // This is just needed for the `setDeclaration` call.
@@ -4914,7 +4900,7 @@ fn structDeclInner(
     node: Ast.Node.Index,
     container_decl: Ast.full.ContainerDecl,
     layout: std.builtin.Type.ContainerLayout,
-    backing_int_node: Ast.Node.OptionalIndex,
+    maybe_backing_int_node: Ast.Node.OptionalIndex,
     name_strat: Zir.Inst.NameStrategy,
 ) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
@@ -4930,27 +4916,39 @@ fn structDeclInner(
         if (node == .root) {
             return astgen.failNode(tuple_field_node, "file cannot be a tuple", .{});
         } else {
-            return tupleDecl(gz, scope, node, container_decl, layout, backing_int_node);
+            return tupleDecl(gz, scope, node, container_decl, layout, maybe_backing_int_node);
         }
     }
 
+    astgen.advanceSourceCursorToNode(node);
+
+    const backing_int_type_ref: Zir.Inst.Ref = ty: {
+        const backing_int_node = maybe_backing_int_node.unwrap() orelse break :ty .none;
+        if (layout != .@"packed") return astgen.failNode(
+            backing_int_node,
+            "non-packed struct does not support backing integer type",
+            .{},
+        );
+        break :ty try typeExpr(gz, scope, backing_int_node);
+    };
+
     const decl_inst = try gz.reserveInstructionIndex();
 
-    if (container_decl.ast.members.len == 0 and backing_int_node == .none) {
+    if (container_decl.ast.members.len == 0 and backing_int_type_ref == .none) {
         try gz.setStruct(decl_inst, .{
             .src_node = node,
+            .name_strat = name_strat,
             .layout = layout,
-            .captures_len = 0,
-            .fields_len = 0,
+            .backing_int_type = .none,
             .decls_len = 0,
-            .has_backing_int = false,
-            .known_non_opv = false,
-            .known_comptime_only = false,
+            .fields_len = 0,
+            .any_field_aligns = false,
+            .any_field_defaults = false,
             .any_comptime_fields = false,
-            .any_default_inits = false,
-            .any_aligned_fields = false,
-            .fields_hash = std.zig.hashSrc(@tagName(layout)),
-            .name_strat = name_strat,
+            .fields_hash = @splat(0),
+            .captures = &.{},
+            .capture_names = &.{},
+            .remaining = &.{},
         });
         return decl_inst.toRef();
     }
@@ -4967,7 +4965,6 @@ fn structDeclInner(
     // The struct_decl instruction introduces a scope in which the decls of the struct
     // are in scope, so that field types, alignments, and default value expressions
     // can refer to decls within the struct itself.
-    astgen.advanceSourceCursorToNode(node);
     var block_scope: GenZir = .{
         .parent = &namespace.base,
         .decl_node_index = node,
@@ -4979,197 +4976,118 @@ fn structDeclInner(
     };
     defer block_scope.unstack();
 
-    const scratch_top = astgen.scratch.items.len;
-    defer astgen.scratch.items.len = scratch_top;
+    const scan_result = try astgen.scanContainer(&namespace, container_decl.ast.members, .@"struct");
 
-    var backing_int_body_len: usize = 0;
-    const backing_int_ref: Zir.Inst.Ref = blk: {
-        if (backing_int_node.unwrap()) |arg| {
-            if (layout != .@"packed") {
-                return astgen.failNode(arg, "non-packed struct does not support backing integer type", .{});
-            } else {
-                const backing_int_ref = try typeExpr(&block_scope, &namespace.base, arg);
-                if (!block_scope.isEmpty()) {
-                    if (!block_scope.endsWithNoReturn()) {
-                        _ = try block_scope.addBreak(.break_inline, decl_inst, backing_int_ref);
-                    }
+    var scratch: Scratch = .init(astgen);
+    defer scratch.reset();
 
-                    const body = block_scope.instructionsSlice();
-                    const old_scratch_len = astgen.scratch.items.len;
-                    try astgen.scratch.ensureUnusedCapacity(gpa, countBodyLenAfterFixups(astgen, body));
-                    appendBodyWithFixupsArrayList(astgen, &astgen.scratch, body);
-                    backing_int_body_len = astgen.scratch.items.len - old_scratch_len;
-                    block_scope.instructions.items.len = block_scope.instructions_top;
-                }
-                break :blk backing_int_ref;
-            }
-        } else {
-            break :blk .none;
-        }
-    };
-
-    const decl_count = try astgen.scanContainer(&namespace, container_decl.ast.members, .@"struct");
-    const field_count: u32 = @intCast(container_decl.ast.members.len - decl_count);
-
-    const bits_per_field = 4;
-    const max_field_size = 5;
-    var wip_members = try WipMembers.init(gpa, &astgen.scratch, decl_count, field_count, bits_per_field, max_field_size);
-    defer wip_members.deinit();
-
-    // We will use the scratch buffer, starting here, for the bodies:
-    //    bodies: { // for every fields_len
-    //        field_type_body_inst: Inst, // for each field_type_body_len
-    //        align_body_inst: Inst, // for each align_body_len
-    //        init_body_inst: Inst, // for each init_body_len
-    //    }
-    // Note that the scratch buffer is simultaneously being used by WipMembers, however
-    // it will not access any elements beyond this point in the ArrayList. It also
-    // accesses via the ArrayList items field so it can handle the scratch buffer being
-    // reallocated.
-    // No defer needed here because it is handled by `wip_members.deinit()` above.
-    const bodies_start = astgen.scratch.items.len;
+    // Replicate the structure of the ZIR trailing data in `scratch`
+    var wip_decls: WipDecls = try .init(&scratch, scan_result.decls_len);
+    const field_names = try scratch.addSlice(scan_result.fields_len);
+    const field_type_body_lens = try scratch.addSlice(scan_result.fields_len);
+    const field_align_body_lens = try scratch.addOptionalSlice(scan_result.any_field_aligns, scan_result.fields_len);
+    const field_default_body_lens = try scratch.addOptionalSlice(scan_result.any_field_values, scan_result.fields_len);
+    const field_comptime_bits = try scratch.addOptionalSlice(
+        scan_result.any_comptime_fields,
+        std.math.divCeil(u32, scan_result.fields_len, 32) catch unreachable,
+    );
+    if (field_comptime_bits) |bits| @memset(bits.get(astgen), 0);
 
     const old_hasher = astgen.src_hasher;
     defer astgen.src_hasher = old_hasher;
-    astgen.src_hasher = std.zig.SrcHasher.init(.{});
-    astgen.src_hasher.update(@tagName(layout));
-    if (backing_int_node.unwrap()) |arg| {
-        astgen.src_hasher.update(tree.getNodeSource(arg));
-    }
+    astgen.src_hasher = .init(.{});
 
-    var known_non_opv = false;
-    var known_comptime_only = false;
-    var any_comptime_fields = false;
-    var any_aligned_fields = false;
-    var any_default_inits = false;
+    var next_field_idx: u32 = 0;
     for (container_decl.ast.members) |member_node| {
-        var member = switch (try containerMember(&block_scope, &namespace.base, &wip_members, member_node)) {
+        var member = switch (try containerMember(&block_scope, &namespace.base, &wip_decls, member_node)) {
             .decl => continue,
             .field => |field| field,
         };
+        const field_idx = next_field_idx;
+        next_field_idx += 1;
 
         astgen.src_hasher.update(tree.getNodeSource(member_node));
 
-        const field_name = try astgen.identAsString(member.ast.main_token);
         member.convertToNonTupleLike(astgen.tree);
         assert(!member.ast.tuple_like);
-        wip_members.appendToField(@intFromEnum(field_name));
 
-        const type_expr = member.ast.type_expr.unwrap() orelse {
-            return astgen.failTok(member.ast.main_token, "struct field missing type", .{});
-        };
+        field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token));
 
-        const field_type = try typeExpr(&block_scope, &namespace.base, type_expr);
-        const have_type_body = !block_scope.isEmpty();
-        const have_align = member.ast.align_expr != .none;
-        const have_value = member.ast.value_expr != .none;
-        const is_comptime = member.comptime_token != null;
+        {
+            const type_node = member.ast.type_expr.unwrap() orelse {
+                return astgen.failTok(member.ast.main_token, "struct field missing type", .{});
+            };
+            const type_ref = try typeExpr(&block_scope, &namespace.base, type_node);
+            if (!block_scope.endsWithNoReturn()) {
+                _ = try block_scope.addBreak(.break_inline, decl_inst, type_ref);
+            }
+            const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+            field_type_body_lens.get(astgen)[field_idx] = body_len;
+            block_scope.instructions.items.len = block_scope.instructions_top;
+        }
 
-        if (is_comptime) {
+        if (member.ast.align_expr.unwrap()) |align_node| {
+            if (layout == .@"packed") {
+                return astgen.failNode(align_node, "unable to override alignment of packed struct fields", .{});
+            }
+            const align_ref = try expr(&block_scope, &namespace.base, coerced_align_ri, align_node);
+            if (!block_scope.endsWithNoReturn()) {
+                _ = try block_scope.addBreak(.break_inline, decl_inst, align_ref);
+            }
+            const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+            field_align_body_lens.?.get(astgen)[field_idx] = body_len;
+            block_scope.instructions.items.len = block_scope.instructions_top;
+        } else if (field_align_body_lens) |lens| {
+            lens.get(astgen)[field_idx] = 0;
+        }
+
+        if (member.ast.value_expr.unwrap()) |default_node| {
+            const ri: ResultInfo = .{ .rl = .{ .coerced_ty = decl_inst.toRef() } };
+            const default_ref = try expr(&block_scope, &namespace.base, ri, default_node);
+            if (!block_scope.endsWithNoReturn()) {
+                _ = try block_scope.addBreak(.break_inline, decl_inst, default_ref);
+            }
+            const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+            field_default_body_lens.?.get(astgen)[field_idx] = body_len;
+            block_scope.instructions.items.len = block_scope.instructions_top;
+        } else if (field_default_body_lens) |lens| {
+            lens.get(astgen)[field_idx] = 0;
+        }
+
+        if (member.comptime_token) |comptime_token| {
             switch (layout) {
-                .@"packed", .@"extern" => return astgen.failTok(member.comptime_token.?, "{s} struct fields cannot be marked comptime", .{@tagName(layout)}),
-                .auto => any_comptime_fields = true,
+                .@"packed", .@"extern" => return astgen.failTok(comptime_token, "{s} struct fields cannot be marked comptime", .{@tagName(layout)}),
+                .auto => {},
             }
-        } else {
-            known_non_opv = known_non_opv or
-                nodeImpliesMoreThanOnePossibleValue(tree, type_expr);
-            known_comptime_only = known_comptime_only or
-                nodeImpliesComptimeOnly(tree, type_expr);
-        }
-        wip_members.nextField(bits_per_field, .{ have_align, have_value, is_comptime, have_type_body });
-
-        if (have_type_body) {
-            if (!block_scope.endsWithNoReturn()) {
-                _ = try block_scope.addBreak(.break_inline, decl_inst, field_type);
+            if (member.ast.value_expr == .none) {
+                return astgen.failTok(comptime_token, "comptime field without default initialization value", .{});
             }
-            const body = block_scope.instructionsSlice();
-            const old_scratch_len = astgen.scratch.items.len;
-            try astgen.scratch.ensureUnusedCapacity(gpa, countBodyLenAfterFixups(astgen, body));
-            appendBodyWithFixupsArrayList(astgen, &astgen.scratch, body);
-            wip_members.appendToField(@intCast(astgen.scratch.items.len - old_scratch_len));
-            block_scope.instructions.items.len = block_scope.instructions_top;
-        } else {
-            wip_members.appendToField(@intFromEnum(field_type));
-        }
-
-        if (member.ast.align_expr.unwrap()) |align_expr| {
-            if (layout == .@"packed") {
-                return astgen.failNode(align_expr, "unable to override alignment of packed struct fields", .{});
-            }
-            any_aligned_fields = true;
-            const align_ref = try expr(&block_scope, &namespace.base, coerced_align_ri, align_expr);
-            if (!block_scope.endsWithNoReturn()) {
-                _ = try block_scope.addBreak(.break_inline, decl_inst, align_ref);
-            }
-            const body = block_scope.instructionsSlice();
-            const old_scratch_len = astgen.scratch.items.len;
-            try astgen.scratch.ensureUnusedCapacity(gpa, countBodyLenAfterFixups(astgen, body));
-            appendBodyWithFixupsArrayList(astgen, &astgen.scratch, body);
-            wip_members.appendToField(@intCast(astgen.scratch.items.len - old_scratch_len));
-            block_scope.instructions.items.len = block_scope.instructions_top;
-        }
-
-        if (member.ast.value_expr.unwrap()) |value_expr| {
-            any_default_inits = true;
-
-            // The decl_inst is used as here so that we can easily reconstruct a mapping
-            // between it and the field type when the fields inits are analyzed.
-            const ri: ResultInfo = .{ .rl = if (field_type == .none) .none else .{ .coerced_ty = decl_inst.toRef() } };
-
-            const default_inst = try expr(&block_scope, &namespace.base, ri, value_expr);
-            if (!block_scope.endsWithNoReturn()) {
-                _ = try block_scope.addBreak(.break_inline, decl_inst, default_inst);
-            }
-            const body = block_scope.instructionsSlice();
-            const old_scratch_len = astgen.scratch.items.len;
-            try astgen.scratch.ensureUnusedCapacity(gpa, countBodyLenAfterFixups(astgen, body));
-            appendBodyWithFixupsArrayList(astgen, &astgen.scratch, body);
-            wip_members.appendToField(@intCast(astgen.scratch.items.len - old_scratch_len));
-            block_scope.instructions.items.len = block_scope.instructions_top;
-        } else if (member.comptime_token) |comptime_token| {
-            return astgen.failTok(comptime_token, "comptime field without default initialization value", .{});
+            const mask = @as(u32, 1) << @intCast(field_idx % 32);
+            field_comptime_bits.?.get(astgen)[field_idx / 32] |= mask;
         }
     }
+    assert(next_field_idx == scan_result.fields_len);
+    wip_decls.finish();
 
     var fields_hash: std.zig.SrcHash = undefined;
     astgen.src_hasher.final(&fields_hash);
 
     try gz.setStruct(decl_inst, .{
         .src_node = node,
+        .name_strat = name_strat,
         .layout = layout,
-        .captures_len = @intCast(namespace.captures.count()),
-        .fields_len = field_count,
-        .decls_len = decl_count,
-        .has_backing_int = backing_int_ref != .none,
-        .known_non_opv = known_non_opv,
-        .known_comptime_only = known_comptime_only,
-        .any_comptime_fields = any_comptime_fields,
-        .any_default_inits = any_default_inits,
-        .any_aligned_fields = any_aligned_fields,
+        .backing_int_type = backing_int_type_ref,
+        .decls_len = scan_result.decls_len,
+        .fields_len = scan_result.fields_len,
+        .any_field_aligns = scan_result.any_field_aligns,
+        .any_field_defaults = scan_result.any_field_values,
+        .any_comptime_fields = scan_result.any_comptime_fields,
         .fields_hash = fields_hash,
-        .name_strat = name_strat,
+        .captures = namespace.captures.keys(),
+        .capture_names = namespace.captures.values(),
+        .remaining = scratch.all().get(astgen),
     });
 
-    wip_members.finishBits(bits_per_field);
-    const decls_slice = wip_members.declsSlice();
-    const fields_slice = wip_members.fieldsSlice();
-    const bodies_slice = astgen.scratch.items[bodies_start..];
-    try astgen.extra.ensureUnusedCapacity(gpa, backing_int_body_len + 2 +
-        decls_slice.len + namespace.captures.count() * 2 + fields_slice.len + bodies_slice.len);
-    astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
-    astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
-    if (backing_int_ref != .none) {
-        astgen.extra.appendAssumeCapacity(@intCast(backing_int_body_len));
-        if (backing_int_body_len == 0) {
-            astgen.extra.appendAssumeCapacity(@intFromEnum(backing_int_ref));
-        } else {
-            astgen.extra.appendSliceAssumeCapacity(astgen.scratch.items[scratch_top..][0..backing_int_body_len]);
-        }
-    }
-    astgen.extra.appendSliceAssumeCapacity(decls_slice);
-    astgen.extra.appendSliceAssumeCapacity(fields_slice);
-    astgen.extra.appendSliceAssumeCapacity(bodies_slice);
-
     block_scope.unstack();
     return decl_inst.toRef();
 }
@@ -5281,11 +5199,34 @@ fn unionDeclInner(
     auto_enum_tok: ?Ast.TokenIndex,
     name_strat: Zir.Inst.NameStrategy,
 ) InnerError!Zir.Inst.Ref {
-    const decl_inst = try gz.reserveInstructionIndex();
-
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
 
+    const explicit_int_or_enum_tag = switch (layout) {
+        .auto => opt_arg_node != .none,
+        .@"extern" => if (opt_arg_node.unwrap()) |arg_node| {
+            return astgen.failNode(arg_node, "{s} union does not support enum tag type", .{@tagName(layout)});
+        } else false,
+        .@"packed" => false,
+    };
+
+    if (auto_enum_tok) |t| {
+        if (layout != .auto) {
+            return astgen.failTok(t, "{s} union does not support enum tag type", .{@tagName(layout)});
+        }
+    }
+
+    const is_tagged = explicit_int_or_enum_tag or auto_enum_tok != null;
+
+    astgen.advanceSourceCursorToNode(node);
+
+    const arg_type_ref: Zir.Inst.Ref = ref: {
+        const arg_node = opt_arg_node.unwrap() orelse break :ref .none;
+        break :ref try typeExpr(gz, scope, arg_node);
+    };
+
+    const decl_inst = try gz.reserveInstructionIndex();
+
     var namespace: Scope.Namespace = .{
         .parent = scope,
         .node = node,
@@ -5298,7 +5239,6 @@ fn unionDeclInner(
     // The union_decl instruction introduces a scope in which the decls of the union
     // are in scope, so that field types, alignments, and default value expressions
     // can refer to decls within the union itself.
-    astgen.advanceSourceCursorToNode(node);
     var block_scope: GenZir = .{
         .parent = &namespace.base,
         .decl_node_index = node,
@@ -5310,42 +5250,31 @@ fn unionDeclInner(
     };
     defer block_scope.unstack();
 
-    const decl_count = try astgen.scanContainer(&namespace, members, .@"union");
-    const field_count: u32 = @intCast(members.len - decl_count);
+    const scan_result = try astgen.scanContainer(&namespace, members, .@"union");
 
-    if (layout != .auto and (auto_enum_tok != null or opt_arg_node != .none)) {
-        if (opt_arg_node.unwrap()) |arg_node| {
-            return astgen.failNode(arg_node, "{s} union does not support enum tag type", .{@tagName(layout)});
-        } else {
-            return astgen.failTok(auto_enum_tok.?, "{s} union does not support enum tag type", .{@tagName(layout)});
-        }
-    }
+    var scratch: Scratch = .init(astgen);
+    defer scratch.reset();
 
-    const arg_inst: Zir.Inst.Ref = if (opt_arg_node.unwrap()) |arg_node|
-        try typeExpr(&block_scope, &namespace.base, arg_node)
-    else
-        .none;
-
-    const bits_per_field = 4;
-    const max_field_size = 4;
-    var any_aligned_fields = false;
-    var wip_members = try WipMembers.init(gpa, &astgen.scratch, decl_count, field_count, bits_per_field, max_field_size);
-    defer wip_members.deinit();
+    // Replicate the structure of the ZIR trailing data in `scratch`
+    var wip_decls: WipDecls = try .init(&scratch, scan_result.decls_len);
+    const field_names = try scratch.addSlice(scan_result.fields_len);
+    const field_type_body_lens = try scratch.addSlice(scan_result.fields_len);
+    const field_align_body_lens = try scratch.addOptionalSlice(scan_result.any_field_aligns, scan_result.fields_len);
+    const field_value_body_lens = try scratch.addOptionalSlice(scan_result.any_field_values, scan_result.fields_len);
 
     const old_hasher = astgen.src_hasher;
     defer astgen.src_hasher = old_hasher;
-    astgen.src_hasher = std.zig.SrcHasher.init(.{});
-    astgen.src_hasher.update(@tagName(layout));
-    astgen.src_hasher.update(&.{@intFromBool(auto_enum_tok != null)});
-    if (opt_arg_node.unwrap()) |arg_node| {
-        astgen.src_hasher.update(astgen.tree.getNodeSource(arg_node));
-    }
+    astgen.src_hasher = .init(.{});
 
+    var next_field_idx: u32 = 0;
     for (members) |member_node| {
-        var member = switch (try containerMember(&block_scope, &namespace.base, &wip_members, member_node)) {
+        var member = switch (try containerMember(&block_scope, &namespace.base, &wip_decls, member_node)) {
             .decl => continue,
             .field => |field| field,
         };
+        const field_idx = next_field_idx;
+        next_field_idx += 1;
+
         astgen.src_hasher.update(astgen.tree.getNodeSource(member_node));
         member.convertToNonTupleLike(astgen.tree);
         if (member.ast.tuple_like) {
@@ -5355,97 +5284,91 @@ fn unionDeclInner(
             return astgen.failTok(comptime_token, "union fields cannot be marked comptime", .{});
         }
 
-        const field_name = try astgen.identAsString(member.ast.main_token);
-        wip_members.appendToField(@intFromEnum(field_name));
+        field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token));
 
-        const have_type = member.ast.type_expr != .none;
-        const have_align = member.ast.align_expr != .none;
-        const have_value = member.ast.value_expr != .none;
-        const unused = false;
-        wip_members.nextField(bits_per_field, .{ have_type, have_align, have_value, unused });
-
-        if (member.ast.type_expr.unwrap()) |type_expr| {
-            const field_type = try typeExpr(&block_scope, &namespace.base, type_expr);
-            wip_members.appendToField(@intFromEnum(field_type));
-        } else if (arg_inst == .none and auto_enum_tok == null) {
+        if (member.ast.type_expr.unwrap()) |type_node| {
+            const type_ref = try typeExpr(&block_scope, &namespace.base, type_node);
+            if (!block_scope.endsWithNoReturn()) {
+                _ = try block_scope.addBreak(.break_inline, decl_inst, type_ref);
+            }
+            const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+            field_type_body_lens.get(astgen)[field_idx] = body_len;
+            block_scope.instructions.items.len = block_scope.instructions_top;
+        } else if (!is_tagged) {
             return astgen.failNode(member_node, "union field missing type", .{});
+        } else {
+            field_type_body_lens.get(astgen)[field_idx] = 0;
         }
-        if (member.ast.align_expr.unwrap()) |align_expr| {
+
+        if (member.ast.align_expr.unwrap()) |align_node| {
             if (layout == .@"packed") {
-                return astgen.failNode(align_expr, "unable to override alignment of packed union fields", .{});
+                return astgen.failNode(align_node, "unable to override alignment of packed union fields", .{});
             }
-            const align_inst = try expr(&block_scope, &block_scope.base, coerced_align_ri, align_expr);
-            wip_members.appendToField(@intFromEnum(align_inst));
-            any_aligned_fields = true;
+            const align_ref = try expr(&block_scope, &namespace.base, coerced_align_ri, align_node);
+            if (!block_scope.endsWithNoReturn()) {
+                _ = try block_scope.addBreak(.break_inline, decl_inst, align_ref);
+            }
+            const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+            field_align_body_lens.?.get(astgen)[field_idx] = body_len;
+            block_scope.instructions.items.len = block_scope.instructions_top;
+        } else if (field_align_body_lens) |lens| {
+            lens.get(astgen)[field_idx] = 0;
         }
-        if (member.ast.value_expr.unwrap()) |value_expr| {
-            if (arg_inst == .none) {
-                return astgen.failNodeNotes(
-                    node,
-                    "explicitly valued tagged union missing integer tag type",
-                    .{},
-                    &[_]u32{
-                        try astgen.errNoteNode(
-                            value_expr,
-                            "tag value specified here",
-                            .{},
-                        ),
-                    },
-                );
+
+        if (member.ast.value_expr.unwrap()) |value_node| {
+            if (!explicit_int_or_enum_tag) return astgen.failNodeNotes(
+                node,
+                "explicitly valued tagged union missing integer tag type",
+                .{},
+                &.{try astgen.errNoteNode(value_node, "tag value specified here", .{})},
+            );
+            if (auto_enum_tok == null) return astgen.failNodeNotes(
+                node,
+                "explicitly valued tagged union requires inferred enum tag type",
+                .{},
+                &.{try astgen.errNoteNode(value_node, "tag value specified here", .{})},
+            );
+            const ri: ResultInfo = .{ .rl = .{ .coerced_ty = decl_inst.toRef() } };
+            const value_ref = try expr(&block_scope, &namespace.base, ri, value_node);
+            if (!block_scope.endsWithNoReturn()) {
+                _ = try block_scope.addBreak(.break_inline, decl_inst, value_ref);
             }
-            if (auto_enum_tok == null) {
-                return astgen.failNodeNotes(
-                    node,
-                    "explicitly valued tagged union requires inferred enum tag type",
-                    .{},
-                    &[_]u32{
-                        try astgen.errNoteNode(
-                            value_expr,
-                            "tag value specified here",
-                            .{},
-                        ),
-                    },
-                );
-            }
-            const tag_value = try expr(&block_scope, &block_scope.base, .{ .rl = .{ .ty = arg_inst } }, value_expr);
-            wip_members.appendToField(@intFromEnum(tag_value));
+            const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+            field_value_body_lens.?.get(astgen)[field_idx] = body_len;
+            block_scope.instructions.items.len = block_scope.instructions_top;
+        } else if (field_value_body_lens) |lens| {
+            lens.get(astgen)[field_idx] = 0;
         }
     }
+    assert(next_field_idx == scan_result.fields_len);
+    wip_decls.finish();
 
     var fields_hash: std.zig.SrcHash = undefined;
     astgen.src_hasher.final(&fields_hash);
 
-    if (!block_scope.isEmpty()) {
-        _ = try block_scope.addBreak(.break_inline, decl_inst, .void_value);
-    }
-
-    const body = block_scope.instructionsSlice();
-    const body_len = astgen.countBodyLenAfterFixups(body);
-
     try gz.setUnion(decl_inst, .{
         .src_node = node,
-        .layout = layout,
-        .tag_type = arg_inst,
-        .captures_len = @intCast(namespace.captures.count()),
-        .body_len = body_len,
-        .fields_len = field_count,
-        .decls_len = decl_count,
-        .auto_enum_tag = auto_enum_tok != null,
-        .any_aligned_fields = any_aligned_fields,
-        .fields_hash = fields_hash,
         .name_strat = name_strat,
+        .kind = switch (layout) {
+            .auto => if (auto_enum_tok == null) l: {
+                break :l if (opt_arg_node == .none) .auto else .tagged_explicit;
+            } else l: {
+                break :l if (opt_arg_node == .none) .tagged_enum else .tagged_enum_explicit;
+            },
+            .@"extern" => .@"extern",
+            .@"packed" => if (opt_arg_node != .none) .packed_explicit else .@"packed",
+        },
+        .arg_type = arg_type_ref,
+        .decls_len = scan_result.decls_len,
+        .fields_len = scan_result.fields_len,
+        .any_field_aligns = scan_result.any_field_aligns,
+        .any_field_values = scan_result.any_field_values,
+        .fields_hash = fields_hash,
+        .captures = namespace.captures.keys(),
+        .capture_names = namespace.captures.values(),
+        .remaining = scratch.all().get(astgen),
     });
 
-    wip_members.finishBits(bits_per_field);
-    const decls_slice = wip_members.declsSlice();
-    const fields_slice = wip_members.fieldsSlice();
-    try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() * 2 + decls_slice.len + body_len + fields_slice.len);
-    astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
-    astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
-    astgen.extra.appendSliceAssumeCapacity(decls_slice);
-    astgen.appendBodyWithFixups(body);
-    astgen.extra.appendSliceAssumeCapacity(fields_slice);
-
     block_scope.unstack();
     return decl_inst.toRef();
 }
@@ -5494,103 +5417,13 @@ fn containerDecl(
             if (container_decl.layout_token) |t| {
                 return astgen.failTok(t, "enums do not support 'packed' or 'extern'; instead provide an explicit integer tag type", .{});
             }
-            // Count total fields as well as how many have explicitly provided tag values.
-            const counts = blk: {
-                var values: usize = 0;
-                var total_fields: usize = 0;
-                var decls: usize = 0;
-                var opt_nonexhaustive_node: Ast.Node.OptionalIndex = .none;
-                var nonfinal_nonexhaustive = false;
-                for (container_decl.ast.members) |member_node| {
-                    var member = tree.fullContainerField(member_node) orelse {
-                        decls += 1;
-                        continue;
-                    };
-                    member.convertToNonTupleLike(astgen.tree);
-                    if (member.ast.tuple_like) {
-                        return astgen.failTok(member.ast.main_token, "enum field missing name", .{});
-                    }
-                    if (member.comptime_token) |comptime_token| {
-                        return astgen.failTok(comptime_token, "enum fields cannot be marked comptime", .{});
-                    }
-                    if (member.ast.type_expr.unwrap()) |type_expr| {
-                        return astgen.failNodeNotes(
-                            type_expr,
-                            "enum fields do not have types",
-                            .{},
-                            &[_]u32{
-                                try astgen.errNoteNode(
-                                    node,
-                                    "consider 'union(enum)' here to make it a tagged union",
-                                    .{},
-                                ),
-                            },
-                        );
-                    }
-                    if (member.ast.align_expr.unwrap()) |align_expr| {
-                        return astgen.failNode(align_expr, "enum fields cannot be aligned", .{});
-                    }
 
-                    const name_token = member.ast.main_token;
-                    if (mem.eql(u8, tree.tokenSlice(name_token), "_")) {
-                        if (opt_nonexhaustive_node.unwrap()) |nonexhaustive_node| {
-                            return astgen.failNodeNotes(
-                                member_node,
-                                "redundant non-exhaustive enum mark",
-                                .{},
-                                &[_]u32{
-                                    try astgen.errNoteNode(
-                                        nonexhaustive_node,
-                                        "other mark here",
-                                        .{},
-                                    ),
-                                },
-                            );
-                        }
-                        opt_nonexhaustive_node = member_node.toOptional();
-                        if (member.ast.value_expr.unwrap()) |value_expr| {
-                            return astgen.failNode(value_expr, "'_' is used to mark an enum as non-exhaustive and cannot be assigned a value", .{});
-                        }
-                        continue;
-                    } else if (opt_nonexhaustive_node != .none) {
-                        nonfinal_nonexhaustive = true;
-                    }
-                    total_fields += 1;
-                    if (member.ast.value_expr.unwrap()) |value_expr| {
-                        if (container_decl.ast.arg == .none) {
-                            return astgen.failNode(value_expr, "value assigned to enum tag with inferred tag type", .{});
-                        }
-                        values += 1;
-                    }
-                }
-                if (nonfinal_nonexhaustive) {
-                    return astgen.failNode(opt_nonexhaustive_node.unwrap().?, "'_' field of non-exhaustive enum must be last", .{});
-                }
-                break :blk .{
-                    .total_fields = total_fields,
-                    .values = values,
-                    .decls = decls,
-                    .nonexhaustive_node = opt_nonexhaustive_node,
-                };
+            astgen.advanceSourceCursorToNode(node);
+
+            const tag_type_ref: Zir.Inst.Ref = ref: {
+                const arg_node = container_decl.ast.arg.unwrap() orelse break :ref .none;
+                break :ref try typeExpr(gz, scope, arg_node);
             };
-            if (counts.nonexhaustive_node != .none and container_decl.ast.arg == .none) {
-                const nonexhaustive_node = counts.nonexhaustive_node.unwrap().?;
-                return astgen.failNodeNotes(
-                    node,
-                    "non-exhaustive enum missing integer tag type",
-                    .{},
-                    &[_]u32{
-                        try astgen.errNoteNode(
-                            nonexhaustive_node,
-                            "marked non-exhaustive here",
-                            .{},
-                        ),
-                    },
-                );
-            }
-            // In this case we must generate ZIR code for the tag values, similar to
-            // how structs are handled above.
-            const nonexhaustive = counts.nonexhaustive_node != .none;
 
             const decl_inst = try gz.reserveInstructionIndex();
 
@@ -5605,7 +5438,6 @@ fn containerDecl(
 
             // The enum_decl instruction introduces a scope in which the decls of the enum
             // are in scope, so that tag values can refer to decls within the enum itself.
-            astgen.advanceSourceCursorToNode(node);
             var block_scope: GenZir = .{
                 .parent = &namespace.base,
                 .decl_node_index = node,
@@ -5617,104 +5449,111 @@ fn containerDecl(
             };
             defer block_scope.unstack();
 
-            _ = try astgen.scanContainer(&namespace, container_decl.ast.members, .@"enum");
-            namespace.base.tag = .namespace;
+            const scan_result = try astgen.scanContainer(&namespace, container_decl.ast.members, .@"enum");
+            // The name `_` is not actually a field; it marks a non-exhaustive enum.
+            const fields_len: u32 = scan_result.fields_len - @intFromBool(scan_result.has_underscore_field);
 
-            const arg_inst: Zir.Inst.Ref = if (container_decl.ast.arg.unwrap()) |arg|
-                try comptimeExpr(&block_scope, &namespace.base, coerced_type_ri, arg, .type)
-            else
-                .none;
+            var scratch: Scratch = .init(astgen);
+            defer scratch.reset();
 
-            const bits_per_field = 1;
-            const max_field_size = 2;
-            var wip_members = try WipMembers.init(gpa, &astgen.scratch, @intCast(counts.decls), @intCast(counts.total_fields), bits_per_field, max_field_size);
-            defer wip_members.deinit();
+            // Replicate the structure of the ZIR trailing data in `scratch`
+            var wip_decls: WipDecls = try .init(&scratch, scan_result.decls_len);
+            const field_names = try scratch.addSlice(fields_len);
+            const field_value_body_lens = try scratch.addOptionalSlice(scan_result.any_field_values, fields_len);
 
             const old_hasher = astgen.src_hasher;
             defer astgen.src_hasher = old_hasher;
-            astgen.src_hasher = std.zig.SrcHasher.init(.{});
-            if (container_decl.ast.arg.unwrap()) |arg| {
-                astgen.src_hasher.update(tree.getNodeSource(arg));
-            }
-            astgen.src_hasher.update(&.{@intFromBool(nonexhaustive)});
+            astgen.src_hasher = .init(.{});
 
+            var next_field_idx: u32 = 0;
+            var opt_nonexhaustive_node: Ast.Node.OptionalIndex = .none;
             for (container_decl.ast.members) |member_node| {
-                if (member_node.toOptional() == counts.nonexhaustive_node)
-                    continue;
-                astgen.src_hasher.update(tree.getNodeSource(member_node));
-                var member = switch (try containerMember(&block_scope, &namespace.base, &wip_members, member_node)) {
+                var member = switch (try containerMember(&block_scope, &namespace.base, &wip_decls, member_node)) {
                     .decl => continue,
                     .field => |field| field,
                 };
                 member.convertToNonTupleLike(astgen.tree);
-                assert(member.comptime_token == null);
-                assert(member.ast.type_expr == .none);
-                assert(member.ast.align_expr == .none);
+                if (member.ast.tuple_like) return astgen.failTok(member.ast.main_token, "enum field missing name", .{});
+                if (member.comptime_token) |t| return astgen.failTok(t, "enum fields cannot be marked comptime", .{});
+                if (member.ast.type_expr.unwrap()) |type_node| {
+                    return astgen.failNodeNotes(type_node, "enum fields do not have types", .{}, &.{
+                        try astgen.errNoteNode(node, "consider 'union(enum)' here to make it a tagged union", .{}),
+                    });
+                }
+                if (member.ast.align_expr.unwrap()) |n| return astgen.failNode(n, "enum fields cannot be aligned", .{});
+                if (mem.eql(u8, tree.tokenSlice(member.ast.main_token), "_")) {
+                    // non-exhaustive mark
+                    assert(scan_result.has_underscore_field);
+                    if (opt_nonexhaustive_node.unwrap()) |prev_node| {
+                        return astgen.failNodeNotes(member_node, "redundant non-exhaustive enum mark", .{}, &.{
+                            try astgen.errNoteNode(prev_node, "other mark here", .{}),
+                        });
+                    }
+                    if (member.ast.value_expr.unwrap()) |value_node| {
+                        return astgen.failNode(value_node, "'_' is used to mark an enum as non-exhaustive and cannot be assigned a value", .{});
+                    }
+                    if (next_field_idx != fields_len) {
+                        return astgen.failNode(member_node, "'_' field of non-exhaustive enum must be last", .{});
+                    }
+                    opt_nonexhaustive_node = member_node.toOptional();
+                    continue;
+                }
 
-                const field_name = try astgen.identAsString(member.ast.main_token);
-                wip_members.appendToField(@intFromEnum(field_name));
+                // This is a real field rather than a non-exhaustive mark.
+                const field_idx = next_field_idx;
+                next_field_idx += 1;
 
-                const have_value = member.ast.value_expr != .none;
-                wip_members.nextField(bits_per_field, .{have_value});
+                astgen.src_hasher.update(tree.getNodeSource(member_node));
 
-                if (member.ast.value_expr.unwrap()) |value_expr| {
-                    if (arg_inst == .none) {
-                        return astgen.failNodeNotes(
-                            node,
-                            "explicitly valued enum missing integer tag type",
-                            .{},
-                            &[_]u32{
-                                try astgen.errNoteNode(
-                                    value_expr,
-                                    "tag value specified here",
-                                    .{},
-                                ),
-                            },
-                        );
+                field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token));
+
+                if (member.ast.value_expr.unwrap()) |value_node| {
+                    if (tag_type_ref == .none) {
+                        return astgen.failNodeNotes(node, "explicitly valued enum missing integer tag type", .{}, &.{
+                            try astgen.errNoteNode(value_node, "tag value specified here", .{}),
+                        });
+                    }
+                    const val_ri: ResultInfo = .{ .rl = .{ .coerced_ty = decl_inst.toRef() } };
+                    const value_ref = try expr(&block_scope, &namespace.base, val_ri, value_node);
+                    if (!block_scope.endsWithNoReturn()) {
+                        _ = try block_scope.addBreak(.break_inline, decl_inst, value_ref);
                     }
-                    const tag_value_inst = try expr(&block_scope, &namespace.base, .{ .rl = .{ .ty = arg_inst } }, value_expr);
-                    wip_members.appendToField(@intFromEnum(tag_value_inst));
+                    const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+                    field_value_body_lens.?.get(astgen)[field_idx] = body_len;
+                    block_scope.instructions.items.len = block_scope.instructions_top;
+                } else if (field_value_body_lens) |lens| {
+                    lens.get(astgen)[field_idx] = 0;
                 }
             }
-
-            if (!block_scope.isEmpty()) {
-                _ = try block_scope.addBreak(.break_inline, decl_inst, .void_value);
-            }
+            assert(scan_result.has_underscore_field == (opt_nonexhaustive_node != .none));
+            assert(next_field_idx == fields_len);
+            wip_decls.finish();
 
             var fields_hash: std.zig.SrcHash = undefined;
             astgen.src_hasher.final(&fields_hash);
 
-            const body = block_scope.instructionsSlice();
-            const body_len = astgen.countBodyLenAfterFixups(body);
-
             try gz.setEnum(decl_inst, .{
                 .src_node = node,
-                .nonexhaustive = nonexhaustive,
-                .tag_type = arg_inst,
-                .captures_len = @intCast(namespace.captures.count()),
-                .body_len = body_len,
-                .fields_len = @intCast(counts.total_fields),
-                .decls_len = @intCast(counts.decls),
+                .name_strat = name_strat,
+                .tag_type = tag_type_ref,
+                .nonexhaustive = scan_result.has_underscore_field,
+                .decls_len = scan_result.decls_len,
+                .fields_len = fields_len,
+                .any_field_values = scan_result.any_field_values,
                 .fields_hash = fields_hash,
-                .name_strat = name_strat,
+                .captures = namespace.captures.keys(),
+                .capture_names = namespace.captures.values(),
+                .remaining = scratch.all().get(astgen),
             });
 
-            wip_members.finishBits(bits_per_field);
-            const decls_slice = wip_members.declsSlice();
-            const fields_slice = wip_members.fieldsSlice();
-            try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() * 2 + decls_slice.len + body_len + fields_slice.len);
-            astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
-            astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
-            astgen.extra.appendSliceAssumeCapacity(decls_slice);
-            astgen.appendBodyWithFixups(body);
-            astgen.extra.appendSliceAssumeCapacity(fields_slice);
-
             block_scope.unstack();
             return rvalue(gz, ri, decl_inst.toRef(), node);
         },
         .keyword_opaque => {
             assert(container_decl.ast.arg == .none);
 
+            astgen.advanceSourceCursorToNode(node);
+
             const decl_inst = try gz.reserveInstructionIndex();
 
             var namespace: Scope.Namespace = .{
@@ -5726,7 +5565,6 @@ fn containerDecl(
             };
             defer namespace.deinit(gpa);
 
-            astgen.advanceSourceCursorToNode(node);
             var block_scope: GenZir = .{
                 .parent = &namespace.base,
                 .decl_node_index = node,
@@ -5738,36 +5576,34 @@ fn containerDecl(
             };
             defer block_scope.unstack();
 
-            const decl_count = try astgen.scanContainer(&namespace, container_decl.ast.members, .@"opaque");
+            const scan_result = try astgen.scanContainer(&namespace, container_decl.ast.members, .@"opaque");
 
-            var wip_members = try WipMembers.init(gpa, &astgen.scratch, decl_count, 0, 0, 0);
-            defer wip_members.deinit();
+            var scratch: Scratch = .init(astgen);
+            defer scratch.reset();
+            var wip_decls: WipDecls = try .init(&scratch, scan_result.decls_len);
 
             if (container_decl.layout_token) |layout_token| {
                 return astgen.failTok(layout_token, "opaque types do not support 'packed' or 'extern'", .{});
             }
 
             for (container_decl.ast.members) |member_node| {
-                const res = try containerMember(&block_scope, &namespace.base, &wip_members, member_node);
-                if (res == .field) {
-                    return astgen.failNode(member_node, "opaque types cannot have fields", .{});
+                switch (try containerMember(&block_scope, &namespace.base, &wip_decls, member_node)) {
+                    .decl => {},
+                    .field => return astgen.failNode(member_node, "opaque types cannot have fields", .{}),
                 }
             }
 
+            wip_decls.finish();
+
             try gz.setOpaque(decl_inst, .{
                 .src_node = node,
-                .captures_len = @intCast(namespace.captures.count()),
-                .decls_len = decl_count,
                 .name_strat = name_strat,
+                .decls_len = scan_result.decls_len,
+                .captures = namespace.captures.keys(),
+                .capture_names = namespace.captures.values(),
+                .decls = @ptrCast(scratch.all().get(astgen)),
             });
 
-            wip_members.finishBits(0);
-            const decls_slice = wip_members.declsSlice();
-            try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() * 2 + decls_slice.len);
-            astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
-            astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
-            astgen.extra.appendSliceAssumeCapacity(decls_slice);
-
             block_scope.unstack();
             return rvalue(gz, ri, decl_inst.toRef(), node);
         },
@@ -5780,7 +5616,7 @@ const ContainerMemberResult = union(enum) { decl, field: Ast.full.ContainerField
 fn containerMember(
     gz: *GenZir,
     scope: *Scope,
-    wip_members: *WipMembers,
+    wip_decls: *WipDecls,
     member_node: Ast.Node.Index,
 ) InnerError!ContainerMemberResult {
     const astgen = gz.astgen;
@@ -5805,13 +5641,13 @@ fn containerMember(
             else
                 .none;
 
-            const prev_decl_index = wip_members.decl_index;
-            astgen.fnDecl(gz, scope, wip_members, member_node, body, full) catch |err| switch (err) {
+            const prev_decl_index = wip_decls.index;
+            astgen.fnDecl(gz, scope, wip_decls, member_node, body, full) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => {
-                    wip_members.decl_index = prev_decl_index;
+                    wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
-                        wip_members,
+                        wip_decls,
                         gz,
                         .@"const",
                         try astgen.identAsString(full.name_token.?),
@@ -5828,13 +5664,13 @@ fn containerMember(
         .aligned_var_decl,
         => {
             const full = tree.fullVarDecl(member_node).?;
-            const prev_decl_index = wip_members.decl_index;
-            astgen.globalVarDecl(gz, scope, wip_members, member_node, full) catch |err| switch (err) {
+            const prev_decl_index = wip_decls.index;
+            astgen.globalVarDecl(gz, scope, wip_decls, member_node, full) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => {
-                    wip_members.decl_index = prev_decl_index;
+                    wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
-                        wip_members,
+                        wip_decls,
                         gz,
                         .@"const", // doesn't really matter
                         try astgen.identAsString(full.ast.mut_token + 1),
@@ -5846,13 +5682,13 @@ fn containerMember(
         },
 
         .@"comptime" => {
-            const prev_decl_index = wip_members.decl_index;
-            astgen.comptimeDecl(gz, scope, wip_members, member_node) catch |err| switch (err) {
+            const prev_decl_index = wip_decls.index;
+            astgen.comptimeDecl(gz, scope, wip_decls, member_node) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => {
-                    wip_members.decl_index = prev_decl_index;
+                    wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
-                        wip_members,
+                        wip_decls,
                         gz,
                         .@"comptime",
                         .empty,
@@ -5863,16 +5699,16 @@ fn containerMember(
             };
         },
         .test_decl => {
-            const prev_decl_index = wip_members.decl_index;
+            const prev_decl_index = wip_decls.index;
             // We need to have *some* decl here so that the decl count matches what's expected.
             // Since it doesn't strictly matter *what* this is, let's save ourselves the trouble
             // of duplicating the test name logic, and just assume this is an unnamed test.
-            astgen.testDecl(gz, scope, wip_members, member_node) catch |err| switch (err) {
+            astgen.testDecl(gz, scope, wip_decls, member_node) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => {
-                    wip_members.decl_index = prev_decl_index;
+                    wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
-                        wip_members,
+                        wip_decls,
                         gz,
                         .unnamed_test,
                         .empty,
@@ -10619,482 +10455,6 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) BuiltinFn.Ev
     }
 }
 
-/// Returns `true` if it is known the type expression has more than one possible value;
-/// `false` otherwise.
-fn nodeImpliesMoreThanOnePossibleValue(tree: *const Ast, start_node: Ast.Node.Index) bool {
-    var node = start_node;
-    while (true) {
-        switch (tree.nodeTag(node)) {
-            .root,
-            .test_decl,
-            .switch_case,
-            .switch_case_inline,
-            .switch_case_one,
-            .switch_case_inline_one,
-            .container_field_init,
-            .container_field_align,
-            .container_field,
-            .asm_output,
-            .asm_input,
-            .global_var_decl,
-            .local_var_decl,
-            .simple_var_decl,
-            .aligned_var_decl,
-            => unreachable,
-
-            .@"return",
-            .@"break",
-            .@"continue",
-            .bit_not,
-            .bool_not,
-            .@"defer",
-            .@"errdefer",
-            .address_of,
-            .negation,
-            .negation_wrap,
-            .@"resume",
-            .array_type,
-            .@"suspend",
-            .fn_decl,
-            .anyframe_literal,
-            .number_literal,
-            .enum_literal,
-            .string_literal,
-            .multiline_string_literal,
-            .char_literal,
-            .unreachable_literal,
-            .error_set_decl,
-            .container_decl,
-            .container_decl_trailing,
-            .container_decl_two,
-            .container_decl_two_trailing,
-            .container_decl_arg,
-            .container_decl_arg_trailing,
-            .tagged_union,
-            .tagged_union_trailing,
-            .tagged_union_two,
-            .tagged_union_two_trailing,
-            .tagged_union_enum_tag,
-            .tagged_union_enum_tag_trailing,
-            .@"asm",
-            .asm_simple,
-            .add,
-            .add_wrap,
-            .add_sat,
-            .array_cat,
-            .array_mult,
-            .assign,
-            .assign_destructure,
-            .assign_bit_and,
-            .assign_bit_or,
-            .assign_shl,
-            .assign_shl_sat,
-            .assign_shr,
-            .assign_bit_xor,
-            .assign_div,
-            .assign_sub,
-            .assign_sub_wrap,
-            .assign_sub_sat,
-            .assign_mod,
-            .assign_add,
-            .assign_add_wrap,
-            .assign_add_sat,
-            .assign_mul,
-            .assign_mul_wrap,
-            .assign_mul_sat,
-            .bang_equal,
-            .bit_and,
-            .bit_or,
-            .shl,
-            .shl_sat,
-            .shr,
-            .bit_xor,
-            .bool_and,
-            .bool_or,
-            .div,
-            .equal_equal,
-            .error_union,
-            .greater_or_equal,
-            .greater_than,
-            .less_or_equal,
-            .less_than,
-            .merge_error_sets,
-            .mod,
-            .mul,
-            .mul_wrap,
-            .mul_sat,
-            .switch_range,
-            .for_range,
-            .field_access,
-            .sub,
-            .sub_wrap,
-            .sub_sat,
-            .slice,
-            .slice_open,
-            .slice_sentinel,
-            .deref,
-            .array_access,
-            .error_value,
-            .while_simple,
-            .while_cont,
-            .for_simple,
-            .if_simple,
-            .@"catch",
-            .@"orelse",
-            .array_init_one,
-            .array_init_one_comma,
-            .array_init_dot_two,
-            .array_init_dot_two_comma,
-            .array_init_dot,
-            .array_init_dot_comma,
-            .array_init,
-            .array_init_comma,
-            .struct_init_one,
-            .struct_init_one_comma,
-            .struct_init_dot_two,
-            .struct_init_dot_two_comma,
-            .struct_init_dot,
-            .struct_init_dot_comma,
-            .struct_init,
-            .struct_init_comma,
-            .@"while",
-            .@"if",
-            .@"for",
-            .@"switch",
-            .switch_comma,
-            .call_one,
-            .call_one_comma,
-            .call,
-            .call_comma,
-            .block_two,
-            .block_two_semicolon,
-            .block,
-            .block_semicolon,
-            .builtin_call,
-            .builtin_call_comma,
-            .builtin_call_two,
-            .builtin_call_two_comma,
-            // these are function bodies, not pointers
-            .fn_proto_simple,
-            .fn_proto_multi,
-            .fn_proto_one,
-            .fn_proto,
-            => return false,
-
-            // Forward the question to the LHS sub-expression.
-            .@"try",
-            .@"comptime",
-            .@"nosuspend",
-            => node = tree.nodeData(node).node,
-            .grouped_expression,
-            .unwrap_optional,
-            => node = tree.nodeData(node).node_and_token[0],
-
-            .ptr_type_aligned,
-            .ptr_type_sentinel,
-            .ptr_type,
-            .ptr_type_bit_range,
-            .optional_type,
-            .anyframe_type,
-            .array_type_sentinel,
-            => return true,
-
-            .identifier => {
-                const ident_bytes = tree.tokenSlice(tree.nodeMainToken(node));
-                if (primitive_instrs.get(ident_bytes)) |primitive| switch (primitive) {
-                    .anyerror_type,
-                    .anyframe_type,
-                    .anyopaque_type,
-                    .bool_type,
-                    .c_int_type,
-                    .c_long_type,
-                    .c_longdouble_type,
-                    .c_longlong_type,
-                    .c_char_type,
-                    .c_short_type,
-                    .c_uint_type,
-                    .c_ulong_type,
-                    .c_ulonglong_type,
-                    .c_ushort_type,
-                    .comptime_float_type,
-                    .comptime_int_type,
-                    .f16_type,
-                    .f32_type,
-                    .f64_type,
-                    .f80_type,
-                    .f128_type,
-                    .i16_type,
-                    .i32_type,
-                    .i64_type,
-                    .i128_type,
-                    .i8_type,
-                    .isize_type,
-                    .type_type,
-                    .u16_type,
-                    .u29_type,
-                    .u32_type,
-                    .u64_type,
-                    .u128_type,
-                    .u1_type,
-                    .u8_type,
-                    .usize_type,
-                    => return true,
-
-                    .void_type,
-                    .bool_false,
-                    .bool_true,
-                    .null_value,
-                    .undef,
-                    .noreturn_type,
-                    => return false,
-
-                    else => unreachable, // that's all the values from `primitives`.
-                } else {
-                    return false;
-                }
-            },
-        }
-    }
-}
-
-/// Returns `true` if it is known the expression is a type that cannot be used at runtime;
-/// `false` otherwise.
-fn nodeImpliesComptimeOnly(tree: *const Ast, start_node: Ast.Node.Index) bool {
-    var node = start_node;
-    while (true) {
-        switch (tree.nodeTag(node)) {
-            .root,
-            .test_decl,
-            .switch_case,
-            .switch_case_inline,
-            .switch_case_one,
-            .switch_case_inline_one,
-            .container_field_init,
-            .container_field_align,
-            .container_field,
-            .asm_output,
-            .asm_input,
-            .global_var_decl,
-            .local_var_decl,
-            .simple_var_decl,
-            .aligned_var_decl,
-            => unreachable,
-
-            .@"return",
-            .@"break",
-            .@"continue",
-            .bit_not,
-            .bool_not,
-            .@"defer",
-            .@"errdefer",
-            .address_of,
-            .negation,
-            .negation_wrap,
-            .@"resume",
-            .array_type,
-            .@"suspend",
-            .fn_decl,
-            .anyframe_literal,
-            .number_literal,
-            .enum_literal,
-            .string_literal,
-            .multiline_string_literal,
-            .char_literal,
-            .unreachable_literal,
-            .error_set_decl,
-            .container_decl,
-            .container_decl_trailing,
-            .container_decl_two,
-            .container_decl_two_trailing,
-            .container_decl_arg,
-            .container_decl_arg_trailing,
-            .tagged_union,
-            .tagged_union_trailing,
-            .tagged_union_two,
-            .tagged_union_two_trailing,
-            .tagged_union_enum_tag,
-            .tagged_union_enum_tag_trailing,
-            .@"asm",
-            .asm_simple,
-            .add,
-            .add_wrap,
-            .add_sat,
-            .array_cat,
-            .array_mult,
-            .assign,
-            .assign_destructure,
-            .assign_bit_and,
-            .assign_bit_or,
-            .assign_shl,
-            .assign_shl_sat,
-            .assign_shr,
-            .assign_bit_xor,
-            .assign_div,
-            .assign_sub,
-            .assign_sub_wrap,
-            .assign_sub_sat,
-            .assign_mod,
-            .assign_add,
-            .assign_add_wrap,
-            .assign_add_sat,
-            .assign_mul,
-            .assign_mul_wrap,
-            .assign_mul_sat,
-            .bang_equal,
-            .bit_and,
-            .bit_or,
-            .shl,
-            .shl_sat,
-            .shr,
-            .bit_xor,
-            .bool_and,
-            .bool_or,
-            .div,
-            .equal_equal,
-            .error_union,
-            .greater_or_equal,
-            .greater_than,
-            .less_or_equal,
-            .less_than,
-            .merge_error_sets,
-            .mod,
-            .mul,
-            .mul_wrap,
-            .mul_sat,
-            .switch_range,
-            .for_range,
-            .field_access,
-            .sub,
-            .sub_wrap,
-            .sub_sat,
-            .slice,
-            .slice_open,
-            .slice_sentinel,
-            .deref,
-            .array_access,
-            .error_value,
-            .while_simple,
-            .while_cont,
-            .for_simple,
-            .if_simple,
-            .@"catch",
-            .@"orelse",
-            .array_init_one,
-            .array_init_one_comma,
-            .array_init_dot_two,
-            .array_init_dot_two_comma,
-            .array_init_dot,
-            .array_init_dot_comma,
-            .array_init,
-            .array_init_comma,
-            .struct_init_one,
-            .struct_init_one_comma,
-            .struct_init_dot_two,
-            .struct_init_dot_two_comma,
-            .struct_init_dot,
-            .struct_init_dot_comma,
-            .struct_init,
-            .struct_init_comma,
-            .@"while",
-            .@"if",
-            .@"for",
-            .@"switch",
-            .switch_comma,
-            .call_one,
-            .call_one_comma,
-            .call,
-            .call_comma,
-            .block_two,
-            .block_two_semicolon,
-            .block,
-            .block_semicolon,
-            .builtin_call,
-            .builtin_call_comma,
-            .builtin_call_two,
-            .builtin_call_two_comma,
-            .ptr_type_aligned,
-            .ptr_type_sentinel,
-            .ptr_type,
-            .ptr_type_bit_range,
-            .optional_type,
-            .anyframe_type,
-            .array_type_sentinel,
-            => return false,
-
-            // these are function bodies, not pointers
-            .fn_proto_simple,
-            .fn_proto_multi,
-            .fn_proto_one,
-            .fn_proto,
-            => return true,
-
-            // Forward the question to the LHS sub-expression.
-            .@"try",
-            .@"comptime",
-            .@"nosuspend",
-            => node = tree.nodeData(node).node,
-            .grouped_expression,
-            .unwrap_optional,
-            => node = tree.nodeData(node).node_and_token[0],
-
-            .identifier => {
-                const ident_bytes = tree.tokenSlice(tree.nodeMainToken(node));
-                if (primitive_instrs.get(ident_bytes)) |primitive| switch (primitive) {
-                    .anyerror_type,
-                    .anyframe_type,
-                    .anyopaque_type,
-                    .bool_type,
-                    .c_int_type,
-                    .c_long_type,
-                    .c_longdouble_type,
-                    .c_longlong_type,
-                    .c_char_type,
-                    .c_short_type,
-                    .c_uint_type,
-                    .c_ulong_type,
-                    .c_ulonglong_type,
-                    .c_ushort_type,
-                    .f16_type,
-                    .f32_type,
-                    .f64_type,
-                    .f80_type,
-                    .f128_type,
-                    .i16_type,
-                    .i32_type,
-                    .i64_type,
-                    .i128_type,
-                    .i8_type,
-                    .isize_type,
-                    .u16_type,
-                    .u29_type,
-                    .u32_type,
-                    .u64_type,
-                    .u128_type,
-                    .u1_type,
-                    .u8_type,
-                    .usize_type,
-                    .void_type,
-                    .bool_false,
-                    .bool_true,
-                    .null_value,
-                    .undef,
-                    .noreturn_type,
-                    => return false,
-
-                    .comptime_float_type,
-                    .comptime_int_type,
-                    .type_type,
-                    => return true,
-
-                    else => unreachable, // that's all the values from `primitives`.
-                } else {
-                    return false;
-                }
-            },
-        }
-    }
-}
-
 /// Applies `rl` semantics to `result`. Expressions which do not do their own handling of
 /// result locations must call this function on their result.
 /// As an example, if `ri.rl` is `.ptr`, it will write the result to the pointer.
@@ -13044,18 +12404,19 @@ const GenZir = struct {
 
     fn setStruct(gz: *GenZir, inst: Zir.Inst.Index, args: struct {
         src_node: Ast.Node.Index,
-        captures_len: u32,
-        fields_len: u32,
-        decls_len: u32,
-        has_backing_int: bool,
+        name_strat: Zir.Inst.NameStrategy,
         layout: std.builtin.Type.ContainerLayout,
-        known_non_opv: bool,
-        known_comptime_only: bool,
+        backing_int_type: Zir.Inst.Ref,
+        decls_len: u32,
+        fields_len: u32,
+        any_field_aligns: bool,
+        any_field_defaults: bool,
         any_comptime_fields: bool,
-        any_default_inits: bool,
-        any_aligned_fields: bool,
         fields_hash: std.zig.SrcHash,
-        name_strat: Zir.Inst.NameStrategy,
+        captures: []const Zir.Inst.Capture,
+        capture_names: []const Zir.NullTerminatedString,
+        /// The trailing declaration list, field information, and body instructions.
+        remaining: []const u32,
     }) !void {
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
@@ -13063,9 +12424,16 @@ const GenZir = struct {
         // Node .root is valid for the root `struct_decl` of a file!
         assert(args.src_node != .root or gz.parent.tag == .top);
 
+        const captures_len: u32 = @intCast(args.captures.len);
+        assert(args.capture_names.len == captures_len);
+
         const fields_hash_arr: [4]u32 = @bitCast(args.fields_hash);
 
-        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len + 3);
+        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len +
+            4 + // `captures_len`, `decls_len`, `fields_len`, `backing_int_type`
+            captures_len * 2 + // `capture`, `capture_name`
+            args.remaining.len);
+
         const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.StructDecl{
             .fields_hash_0 = fields_hash_arr[0],
             .fields_hash_1 = fields_hash_arr[1],
@@ -13075,31 +12443,28 @@ const GenZir = struct {
             .src_node = args.src_node,
         });
 
-        if (args.captures_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.captures_len);
-        }
-        if (args.fields_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.fields_len);
-        }
-        if (args.decls_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.decls_len);
-        }
+        if (captures_len != 0) astgen.extra.appendAssumeCapacity(captures_len);
+        if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
+        if (args.fields_len != 0) astgen.extra.appendAssumeCapacity(args.fields_len);
+        if (args.backing_int_type != .none) astgen.extra.appendAssumeCapacity(@intFromEnum(args.backing_int_type));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
+        astgen.extra.appendSliceAssumeCapacity(args.remaining);
+
         astgen.instructions.set(@intFromEnum(inst), .{
             .tag = .extended,
             .data = .{ .extended = .{
                 .opcode = .struct_decl,
                 .small = @bitCast(Zir.Inst.StructDecl.Small{
-                    .has_captures_len = args.captures_len != 0,
-                    .has_fields_len = args.fields_len != 0,
+                    .has_captures_len = captures_len != 0,
                     .has_decls_len = args.decls_len != 0,
-                    .has_backing_int = args.has_backing_int,
-                    .known_non_opv = args.known_non_opv,
-                    .known_comptime_only = args.known_comptime_only,
+                    .has_fields_len = args.fields_len != 0,
                     .name_strategy = args.name_strat,
                     .layout = args.layout,
+                    .has_backing_int_type = args.backing_int_type != .none,
+                    .any_field_aligns = args.any_field_aligns,
+                    .any_field_defaults = args.any_field_defaults,
                     .any_comptime_fields = args.any_comptime_fields,
-                    .any_default_inits = args.any_default_inits,
-                    .any_aligned_fields = args.any_aligned_fields,
                 }),
                 .operand = payload_index,
             } },
@@ -13108,25 +12473,34 @@ const GenZir = struct {
 
     fn setUnion(gz: *GenZir, inst: Zir.Inst.Index, args: struct {
         src_node: Ast.Node.Index,
-        tag_type: Zir.Inst.Ref,
-        captures_len: u32,
-        body_len: u32,
-        fields_len: u32,
+        name_strat: Zir.Inst.NameStrategy,
+        kind: Zir.Inst.UnionDecl.Kind,
+        arg_type: Zir.Inst.Ref,
         decls_len: u32,
-        layout: std.builtin.Type.ContainerLayout,
-        auto_enum_tag: bool,
-        any_aligned_fields: bool,
+        fields_len: u32,
+        any_field_aligns: bool,
+        any_field_values: bool,
         fields_hash: std.zig.SrcHash,
-        name_strat: Zir.Inst.NameStrategy,
+        captures: []const Zir.Inst.Capture,
+        capture_names: []const Zir.NullTerminatedString,
+        /// The trailing declaration list, field information, and body instructions.
+        remaining: []const u32,
     }) !void {
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
 
         assert(args.src_node != .root);
 
+        const captures_len: u32 = @intCast(args.captures.len);
+        assert(args.capture_names.len == captures_len);
+
         const fields_hash_arr: [4]u32 = @bitCast(args.fields_hash);
 
-        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.UnionDecl).@"struct".fields.len + 5);
+        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.UnionDecl).@"struct".fields.len +
+            4 + // `captures_len`, `decls_len`, `fields_len`, `backing_int_type`
+            captures_len * 2 + // `capture`, `capture_name`
+            args.remaining.len);
+
         const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.UnionDecl{
             .fields_hash_0 = fields_hash_arr[0],
             .fields_hash_1 = fields_hash_arr[1],
@@ -13136,60 +12510,68 @@ const GenZir = struct {
             .src_node = args.src_node,
         });
 
-        if (args.tag_type != .none) {
-            astgen.extra.appendAssumeCapacity(@intFromEnum(args.tag_type));
-        }
-        if (args.captures_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.captures_len);
-        }
-        if (args.body_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.body_len);
-        }
-        if (args.fields_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.fields_len);
-        }
-        if (args.decls_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.decls_len);
-        }
+        if (captures_len != 0) astgen.extra.appendAssumeCapacity(captures_len);
+        if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
+        if (args.fields_len != 0) astgen.extra.appendAssumeCapacity(args.fields_len);
+        if (args.kind.hasArgType()) {
+            assert(args.arg_type != .none);
+            astgen.extra.appendAssumeCapacity(@intFromEnum(args.arg_type));
+        } else {
+            assert(args.arg_type == .none);
+        }
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
+        astgen.extra.appendSliceAssumeCapacity(args.remaining);
+
         astgen.instructions.set(@intFromEnum(inst), .{
             .tag = .extended,
-            .data = .{ .extended = .{
-                .opcode = .union_decl,
-                .small = @bitCast(Zir.Inst.UnionDecl.Small{
-                    .has_tag_type = args.tag_type != .none,
-                    .has_captures_len = args.captures_len != 0,
-                    .has_body_len = args.body_len != 0,
-                    .has_fields_len = args.fields_len != 0,
-                    .has_decls_len = args.decls_len != 0,
-                    .name_strategy = args.name_strat,
-                    .layout = args.layout,
-                    .auto_enum_tag = args.auto_enum_tag,
-                    .any_aligned_fields = args.any_aligned_fields,
-                }),
-                .operand = payload_index,
-            } },
+            .data = .{
+                .extended = .{
+                    .opcode = .union_decl,
+                    .small = @bitCast(Zir.Inst.UnionDecl.Small{
+                        .has_captures_len = captures_len != 0,
+                        .has_decls_len = args.decls_len != 0,
+                        .has_fields_len = args.fields_len != 0,
+                        .name_strategy = args.name_strat,
+                        .kind = args.kind,
+                        .any_field_aligns = args.any_field_aligns,
+                        .any_field_values = args.any_field_values,
+                    }),
+                    .operand = payload_index,
+                },
+            },
         });
     }
 
     fn setEnum(gz: *GenZir, inst: Zir.Inst.Index, args: struct {
         src_node: Ast.Node.Index,
+        name_strat: Zir.Inst.NameStrategy,
         tag_type: Zir.Inst.Ref,
-        captures_len: u32,
-        body_len: u32,
-        fields_len: u32,
-        decls_len: u32,
         nonexhaustive: bool,
+        decls_len: u32,
+        fields_len: u32,
+        any_field_values: bool,
         fields_hash: std.zig.SrcHash,
-        name_strat: Zir.Inst.NameStrategy,
+        captures: []const Zir.Inst.Capture,
+        capture_names: []const Zir.NullTerminatedString,
+        /// The trailing declaration list, field information, and body instructions.
+        remaining: []const u32,
     }) !void {
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
 
         assert(args.src_node != .root);
 
+        const captures_len: u32 = @intCast(args.captures.len);
+        assert(args.capture_names.len == captures_len);
+
         const fields_hash_arr: [4]u32 = @bitCast(args.fields_hash);
 
-        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.EnumDecl).@"struct".fields.len + 5);
+        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.EnumDecl).@"struct".fields.len +
+            4 + // `captures_len`, `decls_len`, `fields_len`, `tag_type`
+            captures_len * 2 + // `capture`, `capture_name`
+            args.remaining.len);
+
         const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.EnumDecl{
             .fields_hash_0 = fields_hash_arr[0],
             .fields_hash_1 = fields_hash_arr[1],
@@ -13199,33 +12581,26 @@ const GenZir = struct {
             .src_node = args.src_node,
         });
 
-        if (args.tag_type != .none) {
-            astgen.extra.appendAssumeCapacity(@intFromEnum(args.tag_type));
-        }
-        if (args.captures_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.captures_len);
-        }
-        if (args.body_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.body_len);
-        }
-        if (args.fields_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.fields_len);
-        }
-        if (args.decls_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.decls_len);
-        }
+        if (captures_len != 0) astgen.extra.appendAssumeCapacity(captures_len);
+        if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
+        if (args.fields_len != 0) astgen.extra.appendAssumeCapacity(args.fields_len);
+        if (args.tag_type != .none) astgen.extra.appendAssumeCapacity(@intFromEnum(args.tag_type));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
+        astgen.extra.appendSliceAssumeCapacity(args.remaining);
+
         astgen.instructions.set(@intFromEnum(inst), .{
             .tag = .extended,
             .data = .{ .extended = .{
                 .opcode = .enum_decl,
                 .small = @bitCast(Zir.Inst.EnumDecl.Small{
-                    .has_tag_type = args.tag_type != .none,
-                    .has_captures_len = args.captures_len != 0,
-                    .has_body_len = args.body_len != 0,
-                    .has_fields_len = args.fields_len != 0,
+                    .has_captures_len = captures_len != 0,
                     .has_decls_len = args.decls_len != 0,
+                    .has_fields_len = args.fields_len != 0,
                     .name_strategy = args.name_strat,
+                    .has_tag_type = args.tag_type != .none,
                     .nonexhaustive = args.nonexhaustive,
+                    .any_field_values = args.any_field_values,
                 }),
                 .operand = payload_index,
             } },
@@ -13234,33 +12609,41 @@ const GenZir = struct {
 
     fn setOpaque(gz: *GenZir, inst: Zir.Inst.Index, args: struct {
         src_node: Ast.Node.Index,
-        captures_len: u32,
-        decls_len: u32,
         name_strat: Zir.Inst.NameStrategy,
+        decls_len: u32,
+        captures: []const Zir.Inst.Capture,
+        capture_names: []const Zir.NullTerminatedString,
+        decls: []const Zir.Inst.Index,
     }) !void {
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
 
         assert(args.src_node != .root);
 
-        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.OpaqueDecl).@"struct".fields.len + 2);
+        const captures_len: u32 = @intCast(args.captures.len);
+        assert(args.capture_names.len == captures_len);
+
+        try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.OpaqueDecl).@"struct".fields.len +
+            2 + // `captures_len`, `decls_len`
+            captures_len * 2 + // `capture`, `capture_name`
+            args.decls.len);
+
         const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.OpaqueDecl{
             .src_line = astgen.source_line,
             .src_node = args.src_node,
         });
+        if (captures_len != 0) astgen.extra.appendAssumeCapacity(captures_len);
+        if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
+        astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.decls));
 
-        if (args.captures_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.captures_len);
-        }
-        if (args.decls_len != 0) {
-            astgen.extra.appendAssumeCapacity(args.decls_len);
-        }
         astgen.instructions.set(@intFromEnum(inst), .{
             .tag = .extended,
             .data = .{ .extended = .{
                 .opcode = .opaque_decl,
                 .small = @bitCast(Zir.Inst.OpaqueDecl.Small{
-                    .has_captures_len = args.captures_len != 0,
+                    .has_captures_len = captures_len != 0,
                     .has_decls_len = args.decls_len != 0,
                     .name_strategy = args.name_strat,
                 }),
@@ -13484,14 +12867,24 @@ fn restoreSourceCursor(astgen: *AstGen, cursor: SourceCursor) void {
     astgen.source_column = cursor.column;
 }
 
+const ScanContainerResult = struct {
+    /// Includes unnamed declarations (e.g. `comptime` decls)
+    decls_len: u32,
+    fields_len: u32,
+    any_field_aligns: bool,
+    any_field_values: bool,
+    any_comptime_fields: bool,
+    /// Whether there is a field named `_` (indicating a non-exhaustive enum)
+    has_underscore_field: bool,
+};
+
 /// Detects name conflicts for decls and fields, and populates `namespace.decls` with all named declarations.
-/// Returns the number of declarations in the namespace, including unnamed declarations (e.g. `comptime` decls).
 fn scanContainer(
     astgen: *AstGen,
     namespace: *Scope.Namespace,
     members: []const Ast.Node.Index,
     container_kind: enum { @"struct", @"union", @"enum", @"opaque" },
-) !u32 {
+) !ScanContainerResult {
     const gpa = astgen.gpa;
     const tree = astgen.tree;
 
@@ -13521,6 +12914,10 @@ fn scanContainer(
 
     var any_duplicates = false;
     var decl_count: u32 = 0;
+    var any_field_aligns = false;
+    var any_field_values = false;
+    var any_comptime_fields = false;
+    var has_underscore_field = false;
     for (members) |member_node| {
         const Kind = enum { decl, field };
         const kind: Kind, const name_token = switch (tree.nodeTag(member_node)) {
@@ -13533,6 +12930,10 @@ fn scanContainer(
                     .@"struct", .@"opaque" => {},
                     .@"union", .@"enum" => full.convertToNonTupleLike(astgen.tree),
                 }
+                if (full.ast.align_expr != .none) any_field_aligns = true;
+                if (full.ast.value_expr != .none) any_field_values = true;
+                if (full.comptime_token != null) any_comptime_fields = true;
+                if (mem.eql(u8, tree.tokenSlice(full.ast.main_token), "_")) has_underscore_field = true;
                 if (full.ast.tuple_like) continue;
                 break :blk .{ .field, full.ast.main_token };
             },
@@ -13698,7 +13099,14 @@ fn scanContainer(
 
     if (!any_duplicates) {
         if (any_invalid_declarations) return error.AnalysisFail;
-        return decl_count;
+        return .{
+            .decls_len = decl_count,
+            .fields_len = @intCast(members.len - decl_count),
+            .any_field_aligns = any_field_aligns,
+            .any_field_values = any_field_values,
+            .any_comptime_fields = any_comptime_fields,
+            .has_underscore_field = has_underscore_field,
+        };
     }
 
     for (names.keys(), names.values()) |name, first| {
@@ -13954,7 +13362,7 @@ const DeclarationName = union(enum) {
 };
 
 fn addFailedDeclaration(
-    wip_members: *WipMembers,
+    wip_decls: *WipDecls,
     gz: *GenZir,
     kind: Zir.Inst.Declaration.Unwrapped.Kind,
     name: Zir.NullTerminatedString,
@@ -13962,7 +13370,7 @@ fn addFailedDeclaration(
     is_pub: bool,
 ) !void {
     const decl_inst = try gz.makeDeclaration(src_node);
-    wip_members.nextDecl(decl_inst);
+    wip_decls.nextDecl(decl_inst);
 
     var dummy_gz = gz.makeSubBlock(&gz.base);
 
diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig
index 0e76f4ff5bf792d033ee6af276b90663742f06bf..165f37edfad0452651ffc51565e1383b67c41a63 100644
--- a/lib/std/zig/Zir.zig
+++ b/lib/std/zig/Zir.zig
@@ -2443,7 +2443,7 @@ pub const Inst = struct {
                 has_align: bool,
                 has_addrspace: bool,
                 has_bit_range: bool,
-                _: u1 = undefined,
+                _: u1 = 0,
             },
             size: std.builtin.Type.Pointer.Size,
             /// Index into extra. See `PtrType`.
@@ -2668,7 +2668,7 @@ pub const Inst = struct {
             has_ret_ty_body: bool,
             has_any_noalias: bool,
             ret_ty_is_generic: bool,
-            _: u23 = undefined,
+            _: u23 = 0,
         };
     };
 
@@ -3134,7 +3134,7 @@ pub const Inst = struct {
         pub const Flags = packed struct {
             is_nosuspend: bool,
             ensure_result_used: bool,
-            _: u30 = undefined,
+            _: u30 = 0,
 
             comptime {
                 if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32)
@@ -3462,33 +3462,20 @@ pub const Inst = struct {
     };
 
     /// Trailing:
-    /// 0. captures_len: u32 // if has_captures_len
-    /// 1. fields_len: u32, // if has_fields_len
-    /// 2. decls_len: u32, // if has_decls_len
-    /// 3. capture: Capture // for every captures_len
-    /// 4. capture_name: NullTerminatedString // for every captures_len
-    /// 5. backing_int_body_len: u32, // if has_backing_int
-    /// 6. backing_int_ref: Ref, // if has_backing_int and backing_int_body_len is 0
-    /// 7. backing_int_body_inst: Inst, // if has_backing_int and backing_int_body_len is > 0
-    /// 8. decl: Index, // for every decls_len; points to a `declaration` instruction
-    /// 9. flags: u32 // for every 8 fields
-    ///    - sets of 4 bits:
-    ///      0b000X: whether corresponding field has an align expression
-    ///      0b00X0: whether corresponding field has a default expression
-    ///      0b0X00: whether corresponding field is comptime
-    ///      0bX000: whether corresponding field has a type expression
-    /// 10. fields: { // for every fields_len
-    ///        field_name: u32,
-    ///        field_type: Ref, // if corresponding bit is not set. none means anytype.
-    ///        field_type_body_len: u32, // if corresponding bit is set
-    ///        align_body_len: u32, // if corresponding bit is set
-    ///        init_body_len: u32, // if corresponding bit is set
-    ///    }
-    /// 11. bodies: { // for every fields_len
-    ///        field_type_body_inst: Inst, // for each field_type_body_len
-    ///        align_body_inst: Inst, // for each align_body_len
-    ///        init_body_inst: Inst, // for each init_body_len
-    ///    }
+    /// 0.  captures_len: u32 // if `has_captures_len`
+    /// 1.  decls_len: u32, // if `has_decls_len`
+    /// 2.  fields_len: u32, // if `has_fields_len`
+    /// 3.  backing_int_type: Ref // if `has_backing_int`
+    /// 4.  capture: Capture // for every `captures_len`
+    /// 5.  capture_name: NullTerminatedString // for every `captures_len`
+    /// 6.  decl: Index, // for every `decls_len`; points to a `declaration` instruction
+    /// 7.  field_name: NullTerminatedString // for every `fields_len`
+    /// 8.  field_type_body_len: u32 // for every `fields_len`
+    /// 9.  field_align_body_len: u32 // for every `fields_len` if `any_field_aligns`
+    /// 10. field_default_body_len: u32 // for every `fields_len` if `any_field_defaults`
+    /// 11. field_comptime_bits: u32 // one bit per `fields_len` if `any_comptime_fields`
+    ///                              // LSB is first field, minimum number of `u32` needed
+    /// 12. body_inst: Inst.Index // type body, then align body, then default body, for each field
     pub const StructDecl = struct {
         // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
         // This hash contains the source of all fields, and any specified attributes (`extern`, backing type, etc).
@@ -3500,19 +3487,18 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
 
-        pub const Small = packed struct {
+        pub const Small = packed struct(u16) {
             has_captures_len: bool,
-            has_fields_len: bool,
             has_decls_len: bool,
-            has_backing_int: bool,
-            known_non_opv: bool,
-            known_comptime_only: bool,
+            has_fields_len: bool,
             name_strategy: NameStrategy,
             layout: std.builtin.Type.ContainerLayout,
-            any_default_inits: bool,
+            /// Always `false` if `layout != .@"packed"`.
+            has_backing_int_type: bool,
+            any_field_aligns: bool,
+            any_field_defaults: bool,
             any_comptime_fields: bool,
-            any_aligned_fields: bool,
-            _: u3 = undefined,
+            _: u5 = 0,
         };
     };
 
@@ -3633,21 +3619,16 @@ pub const Inst = struct {
     };
 
     /// Trailing:
-    /// 0. tag_type: Ref, // if has_tag_type
-    /// 1. captures_len: u32, // if has_captures_len
-    /// 2. body_len: u32, // if has_body_len
-    /// 3. fields_len: u32, // if has_fields_len
-    /// 4. decls_len: u32, // if has_decls_len
-    /// 5. capture: Capture // for every captures_len
-    /// 6. capture_name: NullTerminatedString // for every captures_len
-    /// 7. decl: Index, // for every decls_len; points to a `declaration` instruction
-    /// 8. inst: Index // for every body_len
-    /// 9. has_bits: u32 // for every 32 fields
-    ///    - the bit is whether corresponding field has an value expression
-    /// 10. fields: { // for every fields_len
-    ///        field_name: u32,
-    ///        value: Ref, // if corresponding bit is set
-    ///    }
+    /// 0. captures_len: u32, // if has_captures_len
+    /// 1. decls_len: u32, // if has_decls_len
+    /// 2. fields_len: u32, // if has_fields_len
+    /// 3. tag_type: Ref, // if has_tag_type
+    /// 4. capture: Capture // for every `captures_len`
+    /// 5. capture_name: NullTerminatedString // for every `captures_len`
+    /// 6. decl: Index, // for every `decls_len`; points to a `declaration` instruction
+    /// 7. field_name: NullTerminatedString // for every `fields_len`
+    /// 8. field_value_body_len: u32 // for every `fields_len` if `any_field_values`
+    /// 9. body_inst: Inst.Index // value body for each field
     pub const EnumDecl = struct {
         // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
         // This hash contains the source of all fields, and the backing type if specified.
@@ -3659,40 +3640,31 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
 
-        pub const Small = packed struct {
-            has_tag_type: bool,
+        pub const Small = packed struct(u16) {
             has_captures_len: bool,
-            has_body_len: bool,
-            has_fields_len: bool,
             has_decls_len: bool,
+            has_fields_len: bool,
             name_strategy: NameStrategy,
+            has_tag_type: bool,
             nonexhaustive: bool,
-            _: u8 = undefined,
+            any_field_values: bool,
+            _: u8 = 0,
         };
     };
 
     /// Trailing:
-    /// 0. tag_type: Ref, // if has_tag_type
-    /// 1. captures_len: u32 // if has_captures_len
-    /// 2. body_len: u32, // if has_body_len
-    /// 3. fields_len: u32, // if has_fields_len
-    /// 4. decls_len: u32, // if has_decls_len
-    /// 5. capture: Capture // for every captures_len
-    /// 6. capture_name: NullTerminatedString // for every captures_len
-    /// 7. decl: Index, // for every decls_len; points to a `declaration` instruction
-    /// 8. inst: Index // for every body_len
-    /// 9. has_bits: u32 // for every 8 fields
-    ///    - sets of 4 bits:
-    ///      0b000X: whether corresponding field has a type expression
-    ///      0b00X0: whether corresponding field has a align expression
-    ///      0b0X00: whether corresponding field has a tag value expression
-    ///      0bX000: unused
-    /// 10. fields: { // for every fields_len
-    ///        field_name: NullTerminatedString, // null terminated string index
-    ///        field_type: Ref, // if corresponding bit is set
-    ///        align: Ref, // if corresponding bit is set
-    ///        tag_value: Ref, // if corresponding bit is set
-    ///    }
+    /// 0.  captures_len: u32 // if `has_captures_len`
+    /// 1.  decls_len: u32, // if `has_decls_len`
+    /// 2.  fields_len: u32, // if `has_fields_len`
+    /// 3.  arg_type: Ref, // if `kind.hasArgType()`
+    /// 4.  capture: Capture // for every `captures_len`
+    /// 5.  capture_name: NullTerminatedString // for every `captures_len`
+    /// 6.  decl: Index, // for every `decls_len`; points to a `declaration` instruction
+    /// 7.  field_name: NullTerminatedString // for every `fields_len`
+    /// 8.  field_type_body_len: u32 // for every `fields_len`
+    /// 9 . field_align_body_len: u32 // for every `fields_len` if `any_field_aligns`
+    /// 10. field_value_body_len: u32 // for every `fields_len` if `any_field_values`
+    /// 11. body_inst: Inst.Index // type body, then align body, then value body, for each field
     pub const UnionDecl = struct {
         // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
         // This hash contains the source of all fields, and any specified attributes (`extern` etc).
@@ -3704,23 +3676,47 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
 
-        pub const Small = packed struct {
-            has_tag_type: bool,
+        pub const Small = packed struct(u16) {
             has_captures_len: bool,
-            has_body_len: bool,
-            has_fields_len: bool,
             has_decls_len: bool,
+            has_fields_len: bool,
             name_strategy: NameStrategy,
-            layout: std.builtin.Type.ContainerLayout,
-            /// has_tag_type | auto_enum_tag | result
-            /// -------------------------------------
-            ///    false     | false         |  union { }
-            ///    false     | true          |  union(enum) { }
-            ///    true      | true          |  union(enum(T)) { }
-            ///    true      | false         |  union(T) { }
-            auto_enum_tag: bool,
-            any_aligned_fields: bool,
-            _: u5 = undefined,
+            kind: Kind,
+            any_field_aligns: bool,
+            any_field_values: bool,
+            _: u6 = 0,
+        };
+
+        pub const Kind = enum(u3) {
+            /// `union`
+            auto,
+            /// `union(T)`
+            tagged_explicit,
+            /// `union(enum)`
+            tagged_enum,
+            /// `union(enum(T))`
+            tagged_enum_explicit,
+            /// `extern union`
+            @"extern",
+            /// `packed union`
+            @"packed",
+            /// `packed union(T)`
+            packed_explicit,
+
+            pub fn hasArgType(k: Kind) bool {
+                return switch (k) {
+                    .auto, .tagged_enum, .@"extern", .@"packed" => false,
+                    .tagged_explicit, .tagged_enum_explicit, .packed_explicit => true,
+                };
+            }
+
+            pub fn layout(k: Kind) std.builtin.ContainerLayout {
+                return switch (k) {
+                    .auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto,
+                    .@"extern" => .@"extern",
+                    .@"packed", .packed_explicit => .@"packed",
+                };
+            }
         };
     };
 
@@ -3735,11 +3731,11 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
 
-        pub const Small = packed struct {
+        pub const Small = packed struct(u16) {
             has_captures_len: bool,
             has_decls_len: bool,
             name_strategy: NameStrategy,
-            _: u12 = undefined,
+            _: u12 = 0,
         };
     };
 
@@ -3904,12 +3900,12 @@ pub const Inst = struct {
     pub const AllocExtended = struct {
         src_node: Ast.Node.Offset,
 
-        pub const Small = packed struct {
+        pub const Small = packed struct(u16) {
             has_type: bool,
             has_align: bool,
             is_const: bool,
             is_comptime: bool,
-            _: u12 = undefined,
+            _: u12 = 0,
         };
     };
 
@@ -4012,133 +4008,18 @@ pub const Inst = struct {
     };
 };
 
+/// MLUGG TODO: delete this!
 pub const DeclIterator = struct {
-    extra_index: u32,
-    decls_remaining: u32,
-    zir: Zir,
-
+    decls: []const Inst.Index,
+    index: usize,
     pub fn next(it: *DeclIterator) ?Inst.Index {
-        if (it.decls_remaining == 0) return null;
-        const decl_inst: Zir.Inst.Index = @enumFromInt(it.zir.extra[it.extra_index]);
-        it.extra_index += 1;
-        it.decls_remaining -= 1;
-        assert(it.zir.instructions.items(.tag)[@intFromEnum(decl_inst)] == .declaration);
-        return decl_inst;
+        if (it.index == it.decls.len) return null;
+        defer it.index += 1;
+        return it.decls[it.index];
     }
 };
-
 pub fn declIterator(zir: Zir, decl_inst: Zir.Inst.Index) DeclIterator {
-    const inst = zir.instructions.get(@intFromEnum(decl_inst));
-    assert(inst.tag == .extended);
-    const extended = inst.data.extended;
-    switch (extended.opcode) {
-        .struct_decl => {
-            const small: Inst.StructDecl.Small = @bitCast(extended.small);
-            var extra_index: u32 = @intCast(extended.operand + @typeInfo(Inst.StructDecl).@"struct".fields.len);
-            const captures_len = if (small.has_captures_len) captures_len: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :captures_len captures_len;
-            } else 0;
-            extra_index += @intFromBool(small.has_fields_len);
-            const decls_len = if (small.has_decls_len) decls_len: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :decls_len decls_len;
-            } else 0;
-
-            extra_index += captures_len * 2;
-
-            if (small.has_backing_int) {
-                const backing_int_body_len = zir.extra[extra_index];
-                extra_index += 1; // backing_int_body_len
-                if (backing_int_body_len == 0) {
-                    extra_index += 1; // backing_int_ref
-                } else {
-                    extra_index += backing_int_body_len; // backing_int_body_inst
-                }
-            }
-
-            return .{
-                .extra_index = extra_index,
-                .decls_remaining = decls_len,
-                .zir = zir,
-            };
-        },
-        .enum_decl => {
-            const small: Inst.EnumDecl.Small = @bitCast(extended.small);
-            var extra_index: u32 = @intCast(extended.operand + @typeInfo(Inst.EnumDecl).@"struct".fields.len);
-            extra_index += @intFromBool(small.has_tag_type);
-            const captures_len = if (small.has_captures_len) captures_len: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :captures_len captures_len;
-            } else 0;
-            extra_index += @intFromBool(small.has_body_len);
-            extra_index += @intFromBool(small.has_fields_len);
-            const decls_len = if (small.has_decls_len) decls_len: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :decls_len decls_len;
-            } else 0;
-
-            extra_index += captures_len * 2;
-
-            return .{
-                .extra_index = extra_index,
-                .decls_remaining = decls_len,
-                .zir = zir,
-            };
-        },
-        .union_decl => {
-            const small: Inst.UnionDecl.Small = @bitCast(extended.small);
-            var extra_index: u32 = @intCast(extended.operand + @typeInfo(Inst.UnionDecl).@"struct".fields.len);
-            extra_index += @intFromBool(small.has_tag_type);
-            const captures_len = if (small.has_captures_len) captures_len: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :captures_len captures_len;
-            } else 0;
-            extra_index += @intFromBool(small.has_body_len);
-            extra_index += @intFromBool(small.has_fields_len);
-            const decls_len = if (small.has_decls_len) decls_len: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :decls_len decls_len;
-            } else 0;
-
-            extra_index += captures_len * 2;
-
-            return .{
-                .extra_index = extra_index,
-                .decls_remaining = decls_len,
-                .zir = zir,
-            };
-        },
-        .opaque_decl => {
-            const small: Inst.OpaqueDecl.Small = @bitCast(extended.small);
-            var extra_index: u32 = @intCast(extended.operand + @typeInfo(Inst.OpaqueDecl).@"struct".fields.len);
-            const decls_len = if (small.has_decls_len) decls_len: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :decls_len decls_len;
-            } else 0;
-            const captures_len = if (small.has_captures_len) captures_len: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :captures_len captures_len;
-            } else 0;
-
-            extra_index += captures_len * 2;
-
-            return .{
-                .extra_index = extra_index,
-                .decls_remaining = decls_len,
-                .zir = zir,
-            };
-        },
-        else => unreachable,
-    }
+    return .{ .decls = zir.typeDecls(decl_inst), .index = 0 };
 }
 
 /// `DeclContents` contains all "interesting" instructions found within a declaration by `findTrackable`.
@@ -4524,7 +4405,7 @@ fn findTrackableInner(
                     try zir.findTrackableBody(gpa, contents, defers, body);
                 },
 
-                // Reifications and opaque declarations need tracking, but have no body.
+                // Reifications and opaque declarations need tracking, but have no bodies.
                 .reify_enum,
                 .reify_struct,
                 .reify_union,
@@ -4535,150 +4416,37 @@ fn findTrackableInner(
                 .struct_decl => {
                     try contents.explicit_types.append(gpa, inst);
 
-                    const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-                    const extra = zir.extraData(Zir.Inst.StructDecl, extended.operand);
-                    var extra_index = extra.end;
-                    const captures_len = if (small.has_captures_len) blk: {
-                        const captures_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk captures_len;
-                    } else 0;
-                    const fields_len = if (small.has_fields_len) blk: {
-                        const fields_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk fields_len;
-                    } else 0;
-                    const decls_len = if (small.has_decls_len) blk: {
-                        const decls_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk decls_len;
-                    } else 0;
-                    extra_index += captures_len * 2;
-                    if (small.has_backing_int) {
-                        const backing_int_body_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        if (backing_int_body_len == 0) {
-                            extra_index += 1; // backing_int_ref
-                        } else {
-                            const body = zir.bodySlice(extra_index, backing_int_body_len);
-                            extra_index += backing_int_body_len;
-                            try zir.findTrackableBody(gpa, contents, defers, body);
-                        }
+                    const struct_decl = zir.getStructDecl(inst);
+                    var it = struct_decl.iterateFields();
+                    while (it.next()) |field| {
+                        try zir.findTrackableBody(gpa, contents, defers, field.type_body);
+                        if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
+                        if (field.default_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
                     }
-                    extra_index += decls_len;
-
-                    // This ZIR is structured in a slightly awkward way, so we have to split up the iteration.
-                    // `extra_index` iterates `flags` (bags of bits).
-                    // `fields_extra_index` iterates `fields`.
-                    // We accumulate the total length of bodies into `total_bodies_len`. This is sufficient because
-                    // the bodies are packed together in `extra` and we only need to traverse their instructions (we
-                    // don't really care about the structure).
-
-                    const bits_per_field = 4;
-                    const fields_per_u32 = 32 / bits_per_field;
-                    const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
-                    var cur_bit_bag: u32 = undefined;
-
-                    var fields_extra_index = extra_index + bit_bags_count;
-                    var total_bodies_len: u32 = 0;
-
-                    for (0..fields_len) |field_i| {
-                        if (field_i % fields_per_u32 == 0) {
-                            cur_bit_bag = zir.extra[extra_index];
-                            extra_index += 1;
-                        }
-
-                        const has_align = @as(u1, @truncate(cur_bit_bag)) != 0;
-                        cur_bit_bag >>= 1;
-                        const has_init = @as(u1, @truncate(cur_bit_bag)) != 0;
-                        cur_bit_bag >>= 2; // also skip `is_comptime`; we don't care
-                        const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
-                        cur_bit_bag >>= 1;
-
-                        fields_extra_index += 1; // field_name
-
-                        if (has_type_body) {
-                            const field_type_body_len = zir.extra[fields_extra_index];
-                            total_bodies_len += field_type_body_len;
-                        }
-                        fields_extra_index += 1; // field_type or field_type_body_len
-
-                        if (has_align) {
-                            const align_body_len = zir.extra[fields_extra_index];
-                            fields_extra_index += 1;
-                            total_bodies_len += align_body_len;
-                        }
-
-                        if (has_init) {
-                            const init_body_len = zir.extra[fields_extra_index];
-                            fields_extra_index += 1;
-                            total_bodies_len += init_body_len;
-                        }
-                    }
-
-                    // Now, `fields_extra_index` points to `bodies`. Let's treat this as one big body.
-                    const merged_bodies = zir.bodySlice(fields_extra_index, total_bodies_len);
-                    try zir.findTrackableBody(gpa, contents, defers, merged_bodies);
                 },
 
-                // Union declarations need tracking and have a body.
+                // Union declarations need tracking and have bodies.
                 .union_decl => {
                     try contents.explicit_types.append(gpa, inst);
 
-                    const small: Zir.Inst.UnionDecl.Small = @bitCast(extended.small);
-                    const extra = zir.extraData(Zir.Inst.UnionDecl, extended.operand);
-                    var extra_index = extra.end;
-                    extra_index += @intFromBool(small.has_tag_type);
-                    const captures_len = if (small.has_captures_len) blk: {
-                        const captures_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk captures_len;
-                    } else 0;
-                    const body_len = if (small.has_body_len) blk: {
-                        const body_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk body_len;
-                    } else 0;
-                    extra_index += @intFromBool(small.has_fields_len);
-                    const decls_len = if (small.has_decls_len) blk: {
-                        const decls_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk decls_len;
-                    } else 0;
-                    extra_index += captures_len * 2;
-                    extra_index += decls_len;
-                    const body = zir.bodySlice(extra_index, body_len);
-                    try zir.findTrackableBody(gpa, contents, defers, body);
+                    const union_decl = zir.getUnionDecl(inst);
+                    var it = union_decl.iterateFields();
+                    while (it.next()) |field| {
+                        if (field.type_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
+                        if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
+                        if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
+                    }
                 },
 
-                // Enum declarations need tracking and have a body.
+                // Enum declarations need tracking and have bodies.
                 .enum_decl => {
                     try contents.explicit_types.append(gpa, inst);
 
-                    const small: Zir.Inst.EnumDecl.Small = @bitCast(extended.small);
-                    const extra = zir.extraData(Zir.Inst.EnumDecl, extended.operand);
-                    var extra_index = extra.end;
-                    extra_index += @intFromBool(small.has_tag_type);
-                    const captures_len = if (small.has_captures_len) blk: {
-                        const captures_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk captures_len;
-                    } else 0;
-                    const body_len = if (small.has_body_len) blk: {
-                        const body_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk body_len;
-                    } else 0;
-                    extra_index += @intFromBool(small.has_fields_len);
-                    const decls_len = if (small.has_decls_len) blk: {
-                        const decls_len = zir.extra[extra_index];
-                        extra_index += 1;
-                        break :blk decls_len;
-                    } else 0;
-                    extra_index += captures_len * 2;
-                    extra_index += decls_len;
-                    const body = zir.bodySlice(extra_index, body_len);
-                    try zir.findTrackableBody(gpa, contents, defers, body);
+                    const enum_decl = zir.getEnumDecl(inst);
+                    var it = enum_decl.iterateFields();
+                    while (it.next()) |field| {
+                        if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
+                    }
                 },
             }
         },
@@ -5481,34 +5249,452 @@ pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void {
     }
 }
 
+/// MLUGG TODO: maybe delete these two?
 pub fn typeCapturesLen(zir: Zir, type_decl: Inst.Index) u32 {
     const inst = zir.instructions.get(@intFromEnum(type_decl));
     assert(inst.tag == .extended);
-    switch (inst.data.extended.opcode) {
-        .struct_decl => {
-            const small: Inst.StructDecl.Small = @bitCast(inst.data.extended.small);
-            if (!small.has_captures_len) return 0;
-            const extra = zir.extraData(Inst.StructDecl, inst.data.extended.operand);
-            return zir.extra[extra.end];
-        },
-        .union_decl => {
-            const small: Inst.UnionDecl.Small = @bitCast(inst.data.extended.small);
-            if (!small.has_captures_len) return 0;
-            const extra = zir.extraData(Inst.UnionDecl, inst.data.extended.operand);
-            return zir.extra[extra.end + @intFromBool(small.has_tag_type)];
-        },
-        .enum_decl => {
-            const small: Inst.EnumDecl.Small = @bitCast(inst.data.extended.small);
-            if (!small.has_captures_len) return 0;
-            const extra = zir.extraData(Inst.EnumDecl, inst.data.extended.operand);
-            return zir.extra[extra.end + @intFromBool(small.has_tag_type)];
-        },
-        .opaque_decl => {
-            const small: Inst.OpaqueDecl.Small = @bitCast(inst.data.extended.small);
-            if (!small.has_captures_len) return 0;
-            const extra = zir.extraData(Inst.OpaqueDecl, inst.data.extended.operand);
-            return zir.extra[extra.end];
-        },
+    return switch (inst.data.extended.opcode) {
+        .struct_decl => @intCast(zir.getStructDecl(type_decl).captures.len),
+        .union_decl => @intCast(zir.getUnionDecl(type_decl).captures.len),
+        .enum_decl => @intCast(zir.getEnumDecl(type_decl).captures.len),
+        .opaque_decl => @intCast(zir.getOpaqueDecl(type_decl).captures.len),
         else => unreachable,
+    };
+}
+pub fn typeDecls(zir: Zir, type_decl: Inst.Index) []const Zir.Inst.Index {
+    const inst = zir.instructions.get(@intFromEnum(type_decl));
+    assert(inst.tag == .extended);
+    return switch (inst.data.extended.opcode) {
+        .struct_decl => zir.getStructDecl(type_decl).decls,
+        .union_decl => zir.getUnionDecl(type_decl).decls,
+        .enum_decl => zir.getEnumDecl(type_decl).decls,
+        .opaque_decl => zir.getOpaqueDecl(type_decl).decls,
+        else => unreachable,
+    };
+}
+
+pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDecl {
+    const inst_data = zir.instructions.get(@intFromEnum(struct_decl));
+    assert(inst_data.tag == .extended);
+    assert(inst_data.data.extended.opcode == .struct_decl);
+    const small: Inst.StructDecl.Small = @bitCast(inst_data.data.extended.small);
+    const extra = zir.extraData(Inst.StructDecl, inst_data.data.extended.operand);
+    var extra_index = extra.end;
+    const captures_len: u32 = if (small.has_captures_len) blk: {
+        const captures_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk captures_len;
+    } else 0;
+    const decls_len: u32 = if (small.has_decls_len) blk: {
+        const decls_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk decls_len;
+    } else 0;
+    const fields_len: u32 = if (small.has_fields_len) blk: {
+        const fields_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk fields_len;
+    } else 0;
+    const backing_int_type: Inst.Ref = if (small.has_backing_int_type) ty: {
+        const ty = zir.extra[extra_index];
+        extra_index += 1;
+        break :ty @enumFromInt(ty);
+    } else .none;
+    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
+    extra_index += decls_len;
+    const field_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..fields_len]);
+    extra_index += fields_len;
+    const field_type_body_lens: []const u32 = @ptrCast(zir.extra[extra_index..][0..fields_len]);
+    extra_index += fields_len;
+    const field_align_body_lens: ?[]const u32 = if (small.any_field_aligns) lens: {
+        const lens = zir.extra[extra_index..][0..fields_len];
+        extra_index += fields_len;
+        break :lens @ptrCast(lens);
+    } else null;
+    const field_default_body_lens: ?[]const u32 = if (small.any_field_defaults) lens: {
+        const lens = zir.extra[extra_index..][0..fields_len];
+        extra_index += fields_len;
+        break :lens @ptrCast(lens);
+    } else null;
+    const field_comptime_bits: ?[]const u32 = if (small.any_comptime_fields) bits: {
+        const bits_len = std.math.divCeil(u32, fields_len, 32) catch unreachable;
+        const bits = zir.extra[extra_index..][0..bits_len];
+        extra_index += bits_len;
+        break :bits bits;
+    } else null;
+    const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
+    return .{
+        .src_line = extra.data.src_line,
+        .src_node = extra.data.src_node,
+        .name_strategy = small.name_strategy,
+        .captures = captures,
+        .capture_names = capture_names,
+        .decls = decls,
+        .layout = small.layout,
+        .backing_int_type = backing_int_type,
+        .field_names = field_names,
+        .field_type_body_lens = field_type_body_lens,
+        .field_align_body_lens = field_align_body_lens,
+        .field_default_body_lens = field_default_body_lens,
+        .field_comptime_bits = field_comptime_bits,
+        .field_bodies_overlong = field_bodies_overlong,
+    };
+}
+pub const UnwrappedStructDecl = struct {
+    src_line: u32,
+    src_node: Ast.Node.Index,
+    name_strategy: Inst.NameStrategy,
+
+    captures: []const Inst.Capture,
+    capture_names: []const NullTerminatedString,
+
+    decls: []const Inst.Index,
+
+    layout: std.builtin.Type.ContainerLayout,
+    backing_int_type: Inst.Ref,
+
+    field_names: []const NullTerminatedString,
+    field_type_body_lens: []const u32,
+    field_align_body_lens: ?[]const u32,
+    field_default_body_lens: ?[]const u32,
+    field_comptime_bits: ?[]const u32,
+    field_bodies_overlong: []const Inst.Index,
+
+    pub fn iterateFields(struct_decl: UnwrappedStructDecl) FieldIterator {
+        return .{
+            .next_idx = 0,
+            .names = struct_decl.field_names,
+            .type_body_lens = struct_decl.field_type_body_lens,
+            .align_body_lens = struct_decl.field_align_body_lens,
+            .default_body_lens = struct_decl.field_default_body_lens,
+            .comptime_bits = struct_decl.field_comptime_bits,
+            .bodies_overlong = struct_decl.field_bodies_overlong,
+        };
+    }
+
+    pub const FieldIterator = struct {
+        next_idx: u32,
+        names: []const NullTerminatedString,
+        type_body_lens: []const u32,
+        align_body_lens: ?[]const u32,
+        default_body_lens: ?[]const u32,
+        comptime_bits: ?[]const u32,
+        bodies_overlong: []const Inst.Index,
+        pub const Field = struct {
+            idx: u32,
+            name: NullTerminatedString,
+            type_body: []const Inst.Index,
+            align_body: ?[]const Inst.Index,
+            default_body: ?[]const Inst.Index,
+            is_comptime: bool,
+        };
+        pub fn next(it: *FieldIterator) ?Field {
+            const idx = it.next_idx;
+            if (idx == it.names.len) return null;
+            it.next_idx += 1;
+            return .{
+                .idx = idx,
+                .name = it.names[idx],
+                .type_body = it.body(it.type_body_lens[idx]).?,
+                .align_body = it.body(if (it.align_body_lens) |l| l[idx] else 0),
+                .default_body = it.body(if (it.default_body_lens) |l| l[idx] else 0),
+                .is_comptime = ct: {
+                    const bits = it.comptime_bits orelse break :ct false;
+                    const big = bits[idx / 32];
+                    const shifted = big >> @intCast(idx % 32);
+                    break :ct @as(u1, @truncate(shifted)) == 1;
+                },
+            };
+        }
+        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
+            if (len == 0) return null;
+            const b = it.bodies_overlong[0..len];
+            it.bodies_overlong = it.bodies_overlong[len..];
+            return b;
+        }
+    };
+};
+
+pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl {
+    const inst_data = zir.instructions.get(@intFromEnum(union_decl));
+    assert(inst_data.tag == .extended);
+    assert(inst_data.data.extended.opcode == .union_decl);
+    const small: Inst.UnionDecl.Small = @bitCast(inst_data.data.extended.small);
+    const extra = zir.extraData(Inst.UnionDecl, inst_data.data.extended.operand);
+    var extra_index = extra.end;
+    const captures_len: u32 = if (small.has_captures_len) blk: {
+        const captures_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk captures_len;
+    } else 0;
+    const decls_len: u32 = if (small.has_decls_len) blk: {
+        const decls_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk decls_len;
+    } else 0;
+    const fields_len: u32 = if (small.has_fields_len) blk: {
+        const fields_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk fields_len;
+    } else 0;
+    const arg_type: Inst.Ref = if (small.kind.hasArgType()) ty: {
+        const ty = zir.extra[extra_index];
+        extra_index += 1;
+        break :ty @enumFromInt(ty);
+    } else .none;
+    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
+    extra_index += decls_len;
+    const field_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..fields_len]);
+    extra_index += fields_len;
+    const field_type_body_lens: []const u32 = @ptrCast(zir.extra[extra_index..][0..fields_len]);
+    extra_index += fields_len;
+    const field_align_body_lens: ?[]const u32 = if (small.any_field_aligns) lens: {
+        const lens = zir.extra[extra_index..][0..fields_len];
+        extra_index += fields_len;
+        break :lens @ptrCast(lens);
+    } else null;
+    const field_value_body_lens: ?[]const u32 = if (small.any_field_values) lens: {
+        const lens = zir.extra[extra_index..][0..fields_len];
+        extra_index += fields_len;
+        break :lens @ptrCast(lens);
+    } else null;
+    const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
+    return .{
+        .src_line = extra.data.src_line,
+        .src_node = extra.data.src_node,
+        .name_strategy = small.name_strategy,
+        .captures = captures,
+        .capture_names = capture_names,
+        .decls = decls,
+        .kind = small.kind,
+        .arg_type = arg_type,
+        .field_names = field_names,
+        .field_type_body_lens = field_type_body_lens,
+        .field_align_body_lens = field_align_body_lens,
+        .field_value_body_lens = field_value_body_lens,
+        .field_bodies_overlong = field_bodies_overlong,
+    };
+}
+pub const UnwrappedUnionDecl = struct {
+    src_line: u32,
+    src_node: Ast.Node.Index,
+    name_strategy: Inst.NameStrategy,
+
+    captures: []const Inst.Capture,
+    capture_names: []const NullTerminatedString,
+
+    decls: []const Inst.Index,
+
+    kind: Inst.UnionDecl.Kind,
+    arg_type: Inst.Ref,
+
+    field_names: []const NullTerminatedString,
+    field_type_body_lens: []const u32,
+    field_align_body_lens: ?[]const u32,
+    field_value_body_lens: ?[]const u32,
+    field_bodies_overlong: []const Inst.Index,
+
+    pub fn iterateFields(union_decl: UnwrappedUnionDecl) FieldIterator {
+        return .{
+            .next_idx = 0,
+            .names = union_decl.field_names,
+            .type_body_lens = union_decl.field_type_body_lens,
+            .align_body_lens = union_decl.field_align_body_lens,
+            .value_body_lens = union_decl.field_value_body_lens,
+            .bodies_overlong = union_decl.field_bodies_overlong,
+        };
+    }
+
+    pub const FieldIterator = struct {
+        next_idx: u32,
+        names: []const NullTerminatedString,
+        type_body_lens: []const u32,
+        align_body_lens: ?[]const u32,
+        value_body_lens: ?[]const u32,
+        bodies_overlong: []const Inst.Index,
+        pub const Field = struct {
+            idx: u32,
+            name: NullTerminatedString,
+            type_body: ?[]const Inst.Index,
+            align_body: ?[]const Inst.Index,
+            value_body: ?[]const Inst.Index,
+        };
+        pub fn next(it: *FieldIterator) ?Field {
+            const idx = it.next_idx;
+            if (idx == it.names.len) return null;
+            it.next_idx += 1;
+            return .{
+                .idx = idx,
+                .name = it.names[idx],
+                .type_body = it.body(it.type_body_lens[idx]),
+                .align_body = it.body(if (it.align_body_lens) |l| l[idx] else 0),
+                .value_body = it.body(if (it.value_body_lens) |l| l[idx] else 0),
+            };
+        }
+        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
+            if (len == 0) return null;
+            const b = it.bodies_overlong[0..len];
+            it.bodies_overlong = it.bodies_overlong[len..];
+            return b;
+        }
+    };
+};
+
+pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl {
+    const inst_data = zir.instructions.get(@intFromEnum(enum_decl));
+    assert(inst_data.tag == .extended);
+    assert(inst_data.data.extended.opcode == .enum_decl);
+    const small: Inst.EnumDecl.Small = @bitCast(inst_data.data.extended.small);
+    const extra = zir.extraData(Inst.EnumDecl, inst_data.data.extended.operand);
+    var extra_index = extra.end;
+    const captures_len: u32 = if (small.has_captures_len) blk: {
+        const captures_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk captures_len;
+    } else 0;
+    const decls_len: u32 = if (small.has_decls_len) blk: {
+        const decls_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk decls_len;
+    } else 0;
+    const fields_len: u32 = if (small.has_fields_len) blk: {
+        const fields_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk fields_len;
+    } else 0;
+    const tag_type: Inst.Ref = if (small.has_tag_type) ty: {
+        const ty = zir.extra[extra_index];
+        extra_index += 1;
+        break :ty @enumFromInt(ty);
+    } else .none;
+    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
+    extra_index += decls_len;
+    const field_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..fields_len]);
+    extra_index += fields_len;
+    const field_value_body_lens: ?[]const u32 = if (small.any_field_values) lens: {
+        const lens = zir.extra[extra_index..][0..fields_len];
+        extra_index += fields_len;
+        break :lens @ptrCast(lens);
+    } else null;
+    const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
+    return .{
+        .src_line = extra.data.src_line,
+        .src_node = extra.data.src_node,
+        .name_strategy = small.name_strategy,
+        .captures = captures,
+        .capture_names = capture_names,
+        .decls = decls,
+        .tag_type = tag_type,
+        .nonexhaustive = small.nonexhaustive,
+        .field_names = field_names,
+        .field_value_body_lens = field_value_body_lens,
+        .field_bodies_overlong = field_bodies_overlong,
+    };
+}
+pub const UnwrappedEnumDecl = struct {
+    src_line: u32,
+    src_node: Ast.Node.Index,
+    name_strategy: Inst.NameStrategy,
+
+    captures: []const Inst.Capture,
+    capture_names: []const NullTerminatedString,
+
+    decls: []const Inst.Index,
+
+    tag_type: Inst.Ref,
+    nonexhaustive: bool,
+
+    field_names: []const NullTerminatedString,
+    field_value_body_lens: ?[]const u32,
+    field_bodies_overlong: []const Inst.Index,
+
+    pub fn iterateFields(enum_decl: UnwrappedEnumDecl) FieldIterator {
+        return .{
+            .next_idx = 0,
+            .names = enum_decl.field_names,
+            .value_body_lens = enum_decl.field_value_body_lens,
+            .bodies_overlong = enum_decl.field_bodies_overlong,
+        };
     }
+
+    pub const FieldIterator = struct {
+        next_idx: u32,
+        names: []const NullTerminatedString,
+        value_body_lens: ?[]const u32,
+        bodies_overlong: []const Inst.Index,
+        pub const Field = struct {
+            idx: u32,
+            name: NullTerminatedString,
+            value_body: ?[]const Inst.Index,
+        };
+        pub fn next(it: *FieldIterator) ?Field {
+            const idx = it.next_idx;
+            if (idx == it.names.len) return null;
+            it.next_idx += 1;
+            return .{
+                .idx = idx,
+                .name = it.names[idx],
+                .value_body = it.body(if (it.value_body_lens) |l| l[idx] else 0),
+            };
+        }
+        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
+            if (len == 0) return null;
+            const b = it.bodies_overlong[0..len];
+            it.bodies_overlong = it.bodies_overlong[len..];
+            return b;
+        }
+    };
+};
+
+pub fn getOpaqueDecl(zir: *const Zir, opaque_decl: Inst.Index) UnwrappedOpaqueDecl {
+    const inst_data = zir.instructions.get(@intFromEnum(opaque_decl));
+    assert(inst_data.tag == .extended);
+    assert(inst_data.data.extended.opcode == .opaque_decl);
+    const small: Inst.OpaqueDecl.Small = @bitCast(inst_data.data.extended.small);
+    const extra = zir.extraData(Inst.OpaqueDecl, inst_data.data.extended.operand);
+    var extra_index = extra.end;
+    const captures_len: u32 = if (small.has_captures_len) blk: {
+        const captures_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk captures_len;
+    } else 0;
+    const decls_len: u32 = if (small.has_decls_len) blk: {
+        const decls_len = zir.extra[extra_index];
+        extra_index += 1;
+        break :blk decls_len;
+    } else 0;
+    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
+    extra_index += captures_len;
+    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
+    extra_index += decls_len;
+    return .{
+        .src_line = extra.data.src_line,
+        .src_node = extra.data.src_node,
+        .name_strategy = small.name_strategy,
+        .captures = captures,
+        .capture_names = capture_names,
+        .decls = decls,
+    };
 }
+pub const UnwrappedOpaqueDecl = struct {
+    src_line: u32,
+    src_node: Ast.Node.Index,
+    name_strategy: Inst.NameStrategy,
+    captures: []const Inst.Capture,
+    capture_names: []const NullTerminatedString,
+    decls: []const Inst.Index,
+};
diff --git a/src/print_zir.zig b/src/print_zir.zig
index c3a494de8466600670dff6d74b567cd80ee04a71..cd7d18351ca48c7c767c1347f52e53589a921404 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -548,10 +548,10 @@ const Writer = struct {
             .shl_with_overflow,
             => try self.writeOverflowArithmetic(stream, extended),
 
-            .struct_decl => try self.writeStructDecl(stream, extended),
-            .union_decl => try self.writeUnionDecl(stream, extended),
-            .enum_decl => try self.writeEnumDecl(stream, extended),
-            .opaque_decl => try self.writeOpaqueDecl(stream, extended),
+            .struct_decl => try self.writeStructDecl(stream, inst),
+            .union_decl => try self.writeUnionDecl(stream, inst),
+            .enum_decl => try self.writeEnumDecl(stream, inst),
+            .opaque_decl => try self.writeOpaqueDecl(stream, inst),
 
             .tuple_decl => try self.writeTupleDecl(stream, extended),
 
@@ -1427,187 +1427,57 @@ const Writer = struct {
         try self.writeSrcNode(stream, inst_data.src_node);
     }
 
-    fn writeStructDecl(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void {
-        const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-
-        const extra = self.code.extraData(Zir.Inst.StructDecl, extended.operand);
+    fn writeStructDecl(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void {
+        const struct_decl = self.code.getStructDecl(inst);
 
         const prev_parent_decl_node = self.parent_decl_node;
-        self.parent_decl_node = extra.data.src_node;
+        self.parent_decl_node = struct_decl.src_node;
         defer self.parent_decl_node = prev_parent_decl_node;
 
-        const fields_hash: std.zig.SrcHash = @bitCast([4]u32{
-            extra.data.fields_hash_0,
-            extra.data.fields_hash_1,
-            extra.data.fields_hash_2,
-            extra.data.fields_hash_3,
-        });
-
+        const fields_hash = self.code.getAssociatedSrcHash(inst).?;
         try stream.print("hash({x}) ", .{&fields_hash});
 
-        var extra_index: usize = extra.end;
+        try stream.print("{s}, ", .{@tagName(struct_decl.name_strategy)});
 
-        const captures_len = if (small.has_captures_len) blk: {
-            const captures_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk captures_len;
-        } else 0;
-
-        const fields_len = if (small.has_fields_len) blk: {
-            const fields_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk fields_len;
-        } else 0;
-
-        const decls_len = if (small.has_decls_len) blk: {
-            const decls_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk decls_len;
-        } else 0;
-
-        try self.writeFlag(stream, "known_non_opv, ", small.known_non_opv);
-        try self.writeFlag(stream, "known_comptime_only, ", small.known_comptime_only);
-
-        try stream.print("{s}, ", .{@tagName(small.name_strategy)});
-
-        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
-        try stream.writeAll(", ");
-
-        if (small.has_backing_int) {
-            const backing_int_body_len = self.code.extra[extra_index];
-            extra_index += 1;
+        if (struct_decl.backing_int_type != .none) {
+            assert(struct_decl.layout == .@"packed");
             try stream.writeAll("packed(");
-            if (backing_int_body_len == 0) {
-                const backing_int_ref: Zir.Inst.Ref = @enumFromInt(self.code.extra[extra_index]);
-                extra_index += 1;
-                try self.writeInstRef(stream, backing_int_ref);
-            } else {
-                const body = self.code.bodySlice(extra_index, backing_int_body_len);
-                extra_index += backing_int_body_len;
-                self.indent += 2;
-                try self.writeBracedDecl(stream, body);
-                self.indent -= 2;
-            }
+            try self.writeInstRef(stream, struct_decl.backing_int_type);
             try stream.writeAll("), ");
         } else {
-            try stream.print("{s}, ", .{@tagName(small.layout)});
+            try stream.print("{s}, ", .{@tagName(struct_decl.layout)});
         }
 
-        if (decls_len == 0) {
-            try stream.writeAll("{}, ");
-        } else {
-            try stream.writeAll("{\n");
-            self.indent += 2;
-            try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
-            self.indent -= 2;
-            extra_index += decls_len;
-            try stream.splatByteAll(' ', self.indent);
-            try stream.writeAll("}, ");
-        }
+        try self.writeCaptures(stream, struct_decl.captures, struct_decl.capture_names);
+        try stream.writeAll(", ");
+        try self.writeBracedDecl(stream, struct_decl.decls);
+        try stream.writeAll(", ");
 
-        if (fields_len == 0) {
-            try stream.writeAll("{}, {}) ");
+        if (struct_decl.field_names.len == 0) {
+            try stream.writeAll("{}) ");
         } else {
-            const bits_per_field = 4;
-            const fields_per_u32 = 32 / bits_per_field;
-            const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
-            const Field = struct {
-                type_len: u32 = 0,
-                align_len: u32 = 0,
-                init_len: u32 = 0,
-                type: Zir.Inst.Ref = .none,
-                name: Zir.NullTerminatedString,
-                is_comptime: bool,
-            };
-            const fields = try self.arena.alloc(Field, fields_len);
-            {
-                var bit_bag_index: usize = extra_index;
-                extra_index += bit_bags_count;
-                var cur_bit_bag: u32 = undefined;
-                var field_i: u32 = 0;
-                while (field_i < fields_len) : (field_i += 1) {
-                    if (field_i % fields_per_u32 == 0) {
-                        cur_bit_bag = self.code.extra[bit_bag_index];
-                        bit_bag_index += 1;
-                    }
-                    const has_align = @as(u1, @truncate(cur_bit_bag)) != 0;
-                    cur_bit_bag >>= 1;
-                    const has_default = @as(u1, @truncate(cur_bit_bag)) != 0;
-                    cur_bit_bag >>= 1;
-                    const is_comptime = @as(u1, @truncate(cur_bit_bag)) != 0;
-                    cur_bit_bag >>= 1;
-                    const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
-                    cur_bit_bag >>= 1;
-
-                    const field_name_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index]);
-                    extra_index += 1;
-
-                    fields[field_i] = .{
-                        .is_comptime = is_comptime,
-                        .name = field_name_index,
-                    };
-
-                    if (has_type_body) {
-                        fields[field_i].type_len = self.code.extra[extra_index];
-                    } else {
-                        fields[field_i].type = @enumFromInt(self.code.extra[extra_index]);
-                    }
-                    extra_index += 1;
-
-                    if (has_align) {
-                        fields[field_i].align_len = self.code.extra[extra_index];
-                        extra_index += 1;
-                    }
-
-                    if (has_default) {
-                        fields[field_i].init_len = self.code.extra[extra_index];
-                        extra_index += 1;
-                    }
-                }
-            }
-
             try stream.writeAll("{\n");
             self.indent += 2;
 
-            for (fields, 0..) |field, i| {
+            var it = struct_decl.iterateFields();
+            while (it.next()) |field| {
                 try stream.splatByteAll(' ', self.indent);
                 try self.writeFlag(stream, "comptime ", field.is_comptime);
-                if (field.name != .empty) {
-                    const field_name = self.code.nullTerminatedString(field.name);
-                    try stream.print("{f}: ", .{std.zig.fmtIdP(field_name)});
-                } else {
-                    try stream.print("@\"{d}\": ", .{i});
-                }
-                if (field.type != .none) {
-                    try self.writeInstRef(stream, field.type);
-                }
-
-                if (field.type_len > 0) {
-                    const body = self.code.bodySlice(extra_index, field.type_len);
-                    extra_index += body.len;
-                    self.indent += 2;
-                    try self.writeBracedDecl(stream, body);
-                    self.indent -= 2;
-                }
+                const field_name = self.code.nullTerminatedString(field.name);
+                try stream.print("{f}: ", .{std.zig.fmtIdP(field_name)});
 
-                if (field.align_len > 0) {
-                    const body = self.code.bodySlice(extra_index, field.align_len);
-                    extra_index += body.len;
-                    self.indent += 2;
+                self.indent += 2;
+                try self.writeBracedDecl(stream, field.type_body);
+                if (field.align_body) |body| {
                     try stream.writeAll(" align(");
                     try self.writeBracedDecl(stream, body);
-                    try stream.writeAll(")");
-                    self.indent -= 2;
+                    try stream.writeByte(')');
                 }
-
-                if (field.init_len > 0) {
-                    const body = self.code.bodySlice(extra_index, field.init_len);
-                    extra_index += body.len;
-                    self.indent += 2;
+                if (field.default_body) |body| {
                     try stream.writeAll(" = ");
                     try self.writeBracedDecl(stream, body);
-                    self.indent -= 2;
                 }
+                self.indent -= 2;
 
                 try stream.writeAll(",\n");
             }
@@ -1619,266 +1489,115 @@ const Writer = struct {
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeUnionDecl(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void {
-        const small = @as(Zir.Inst.UnionDecl.Small, @bitCast(extended.small));
-
-        const extra = self.code.extraData(Zir.Inst.UnionDecl, extended.operand);
+    fn writeUnionDecl(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void {
+        const union_decl = self.code.getUnionDecl(inst);
 
         const prev_parent_decl_node = self.parent_decl_node;
-        self.parent_decl_node = extra.data.src_node;
+        self.parent_decl_node = union_decl.src_node;
         defer self.parent_decl_node = prev_parent_decl_node;
 
-        const fields_hash: std.zig.SrcHash = @bitCast([4]u32{
-            extra.data.fields_hash_0,
-            extra.data.fields_hash_1,
-            extra.data.fields_hash_2,
-            extra.data.fields_hash_3,
-        });
-
+        const fields_hash = self.code.getAssociatedSrcHash(inst).?;
         try stream.print("hash({x}) ", .{&fields_hash});
 
-        var extra_index: usize = extra.end;
-
-        const tag_type_ref = if (small.has_tag_type) blk: {
-            const tag_type_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
-            extra_index += 1;
-            break :blk tag_type_ref;
-        } else .none;
-
-        const captures_len = if (small.has_captures_len) blk: {
-            const captures_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk captures_len;
-        } else 0;
-
-        const body_len = if (small.has_body_len) blk: {
-            const body_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk body_len;
-        } else 0;
-
-        const fields_len = if (small.has_fields_len) blk: {
-            const fields_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk fields_len;
-        } else 0;
-
-        const decls_len = if (small.has_decls_len) blk: {
-            const decls_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk decls_len;
-        } else 0;
-
-        try stream.print("{s}, {s}, ", .{
-            @tagName(small.name_strategy), @tagName(small.layout),
-        });
-        try self.writeFlag(stream, "autoenum, ", small.auto_enum_tag);
+        try stream.print("{s}, ", .{@tagName(union_decl.name_strategy)});
+
+        switch (union_decl.kind) {
+            .auto => try stream.writeAll("auto, "),
+            .@"extern" => try stream.writeAll("extern, "),
+            .@"packed" => try stream.writeAll("packed, "),
+            .packed_explicit => {
+                try stream.writeAll("packed(");
+                try self.writeInstRef(stream, union_decl.arg_type);
+                try stream.writeAll("), ");
+            },
+            .tagged_explicit => {
+                try stream.writeAll("auto(");
+                try self.writeInstRef(stream, union_decl.arg_type);
+                try stream.writeAll("), ");
+            },
+            .tagged_enum => try stream.writeAll("auto(enum)"),
+            .tagged_enum_explicit => {
+                try stream.writeAll("auto(enum(");
+                try self.writeInstRef(stream, union_decl.arg_type);
+                try stream.writeAll(")), ");
+            },
+        }
 
-        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
+        try self.writeCaptures(stream, union_decl.captures, union_decl.capture_names);
+        try stream.writeAll(", ");
+        try self.writeBracedDecl(stream, union_decl.decls);
         try stream.writeAll(", ");
 
-        if (decls_len == 0) {
-            try stream.writeAll("{}");
+        if (union_decl.field_names.len == 0) {
+            try stream.writeAll("}) ");
         } else {
             try stream.writeAll("{\n");
             self.indent += 2;
-            try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
-            self.indent -= 2;
-            extra_index += decls_len;
-            try stream.splatByteAll(' ', self.indent);
-            try stream.writeAll("}");
-        }
-
-        if (tag_type_ref != .none) {
-            try stream.writeAll(", ");
-            try self.writeInstRef(stream, tag_type_ref);
-        }
-
-        if (fields_len == 0) {
-            try stream.writeAll("}) ");
-            try self.writeSrcNode(stream, .zero);
-            return;
-        }
-        try stream.writeAll(", ");
 
-        const body = self.code.bodySlice(extra_index, body_len);
-        extra_index += body.len;
+            var it = union_decl.iterateFields();
+            while (it.next()) |field| {
+                try stream.splatByteAll(' ', self.indent);
+                const field_name = self.code.nullTerminatedString(field.name);
+                try stream.print("{f}", .{std.zig.fmtIdP(field_name)});
 
-        try self.writeBracedDecl(stream, body);
-        try stream.writeAll(", {\n");
+                self.indent += 2;
+                if (field.type_body) |body| {
+                    try stream.writeAll(": ");
+                    try self.writeBracedDecl(stream, body);
+                }
+                if (field.align_body) |body| {
+                    try stream.writeAll(" align(");
+                    try self.writeBracedDecl(stream, body);
+                    try stream.writeByte(')');
+                }
+                if (field.value_body) |body| {
+                    try stream.writeAll(" = ");
+                    try self.writeBracedDecl(stream, body);
+                }
+                self.indent -= 2;
 
-        self.indent += 2;
-        const bits_per_field = 4;
-        const fields_per_u32 = 32 / bits_per_field;
-        const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
-        const body_end = extra_index;
-        extra_index += bit_bags_count;
-        var bit_bag_index: usize = body_end;
-        var cur_bit_bag: u32 = undefined;
-        var field_i: u32 = 0;
-        while (field_i < fields_len) : (field_i += 1) {
-            if (field_i % fields_per_u32 == 0) {
-                cur_bit_bag = self.code.extra[bit_bag_index];
-                bit_bag_index += 1;
+                try stream.writeAll(",\n");
             }
-            const has_type = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const has_align = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const has_value = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const unused = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-
-            _ = unused;
-
-            const field_name_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index]);
-            const field_name = self.code.nullTerminatedString(field_name_index);
-            extra_index += 1;
-
+            self.indent -= 2;
             try stream.splatByteAll(' ', self.indent);
-            try stream.print("{f}", .{std.zig.fmtIdP(field_name)});
-
-            if (has_type) {
-                const field_type = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
-                extra_index += 1;
-
-                try stream.writeAll(": ");
-                try self.writeInstRef(stream, field_type);
-            }
-            if (has_align) {
-                const align_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
-                extra_index += 1;
-
-                try stream.writeAll(" align(");
-                try self.writeInstRef(stream, align_ref);
-                try stream.writeAll(")");
-            }
-            if (has_value) {
-                const default_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
-                extra_index += 1;
-
-                try stream.writeAll(" = ");
-                try self.writeInstRef(stream, default_ref);
-            }
-            try stream.writeAll(",\n");
+            try stream.writeAll("}) ");
         }
-
-        self.indent -= 2;
-        try stream.splatByteAll(' ', self.indent);
-        try stream.writeAll("}) ");
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeEnumDecl(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void {
-        const small = @as(Zir.Inst.EnumDecl.Small, @bitCast(extended.small));
-
-        const extra = self.code.extraData(Zir.Inst.EnumDecl, extended.operand);
+    fn writeEnumDecl(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void {
+        const enum_decl = self.code.getEnumDecl(inst);
 
         const prev_parent_decl_node = self.parent_decl_node;
-        self.parent_decl_node = extra.data.src_node;
+        self.parent_decl_node = enum_decl.src_node;
         defer self.parent_decl_node = prev_parent_decl_node;
 
-        const fields_hash: std.zig.SrcHash = @bitCast([4]u32{
-            extra.data.fields_hash_0,
-            extra.data.fields_hash_1,
-            extra.data.fields_hash_2,
-            extra.data.fields_hash_3,
-        });
-
+        const fields_hash = self.code.getAssociatedSrcHash(inst).?;
         try stream.print("hash({x}) ", .{&fields_hash});
 
-        var extra_index: usize = extra.end;
-
-        const tag_type_ref = if (small.has_tag_type) blk: {
-            const tag_type_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
-            extra_index += 1;
-            break :blk tag_type_ref;
-        } else .none;
+        try stream.print("{s}, ", .{@tagName(enum_decl.name_strategy)});
+        try self.writeFlag(stream, "nonexhaustive, ", enum_decl.nonexhaustive);
+        try self.writeInstRef(stream, enum_decl.tag_type);
 
-        const captures_len = if (small.has_captures_len) blk: {
-            const captures_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk captures_len;
-        } else 0;
-
-        const body_len = if (small.has_body_len) blk: {
-            const body_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk body_len;
-        } else 0;
-
-        const fields_len = if (small.has_fields_len) blk: {
-            const fields_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk fields_len;
-        } else 0;
-
-        const decls_len = if (small.has_decls_len) blk: {
-            const decls_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk decls_len;
-        } else 0;
-
-        try stream.print("{s}, ", .{@tagName(small.name_strategy)});
-        try self.writeFlag(stream, "nonexhaustive, ", small.nonexhaustive);
-
-        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
+        try self.writeCaptures(stream, enum_decl.captures, enum_decl.capture_names);
+        try stream.writeAll(", ");
+        try self.writeBracedDecl(stream, enum_decl.decls);
         try stream.writeAll(", ");
 
-        if (decls_len == 0) {
-            try stream.writeAll("{}, ");
-        } else {
-            try stream.writeAll("{\n");
-            self.indent += 2;
-            try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
-            self.indent -= 2;
-            extra_index += decls_len;
-            try stream.splatByteAll(' ', self.indent);
-            try stream.writeAll("}, ");
-        }
-
-        if (tag_type_ref != .none) {
-            try self.writeInstRef(stream, tag_type_ref);
-            try stream.writeAll(", ");
-        }
-
-        const body = self.code.bodySlice(extra_index, body_len);
-        extra_index += body.len;
-
-        try self.writeBracedDecl(stream, body);
-        if (fields_len == 0) {
+        if (enum_decl.field_names.len == 0) {
             try stream.writeAll(", {}) ");
         } else {
             try stream.writeAll(", {\n");
-
             self.indent += 2;
-            const bit_bags_count = std.math.divCeil(usize, fields_len, 32) catch unreachable;
-            const body_end = extra_index;
-            extra_index += bit_bags_count;
-            var bit_bag_index: usize = body_end;
-            var cur_bit_bag: u32 = undefined;
-            var field_i: u32 = 0;
-            while (field_i < fields_len) : (field_i += 1) {
-                if (field_i % 32 == 0) {
-                    cur_bit_bag = self.code.extra[bit_bag_index];
-                    bit_bag_index += 1;
-                }
-                const has_tag_value = @as(u1, @truncate(cur_bit_bag)) != 0;
-                cur_bit_bag >>= 1;
-
-                const field_name = self.code.nullTerminatedString(@enumFromInt(self.code.extra[extra_index]));
-                extra_index += 1;
 
+            var it = enum_decl.iterateFields();
+            while (it.next()) |field| {
                 try stream.splatByteAll(' ', self.indent);
+                const field_name = self.code.nullTerminatedString(field.name);
                 try stream.print("{f}", .{std.zig.fmtIdP(field_name)});
-
-                if (has_tag_value) {
-                    const tag_value_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]));
-                    extra_index += 1;
-
+                if (field.value_body) |body| {
                     try stream.writeAll(" = ");
-                    try self.writeInstRef(stream, tag_value_ref);
+                    try self.writeBracedDecl(stream, body);
                 }
                 try stream.writeAll(",\n");
             }
@@ -1889,47 +1608,18 @@ const Writer = struct {
         try self.writeSrcNode(stream, .zero);
     }
 
-    fn writeOpaqueDecl(
-        self: *Writer,
-        stream: *std.Io.Writer,
-        extended: Zir.Inst.Extended.InstData,
-    ) !void {
-        const small = @as(Zir.Inst.OpaqueDecl.Small, @bitCast(extended.small));
-        const extra = self.code.extraData(Zir.Inst.OpaqueDecl, extended.operand);
+    fn writeOpaqueDecl(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void {
+        const opaque_decl = self.code.getOpaqueDecl(inst);
 
         const prev_parent_decl_node = self.parent_decl_node;
-        self.parent_decl_node = extra.data.src_node;
+        self.parent_decl_node = opaque_decl.src_node;
         defer self.parent_decl_node = prev_parent_decl_node;
 
-        var extra_index: usize = extra.end;
-
-        const captures_len = if (small.has_captures_len) blk: {
-            const captures_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk captures_len;
-        } else 0;
-
-        const decls_len = if (small.has_decls_len) blk: {
-            const decls_len = self.code.extra[extra_index];
-            extra_index += 1;
-            break :blk decls_len;
-        } else 0;
-
-        try stream.print("{s}, ", .{@tagName(small.name_strategy)});
-
-        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
+        try stream.print("{s}, ", .{@tagName(opaque_decl.name_strategy)});
+        try self.writeCaptures(stream, opaque_decl.captures, opaque_decl.capture_names);
         try stream.writeAll(", ");
-
-        if (decls_len == 0) {
-            try stream.writeAll("{}) ");
-        } else {
-            try stream.writeAll("{\n");
-            self.indent += 2;
-            try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
-            self.indent -= 2;
-            try stream.splatByteAll(' ', self.indent);
-            try stream.writeAll("}) ");
-        }
+        try self.writeBracedDecl(stream, opaque_decl.decls);
+        try stream.writeAll(") ");
         try self.writeSrcNode(stream, .zero);
     }
 
@@ -2588,14 +2278,11 @@ const Writer = struct {
         return stream.print("%{d}", .{@intFromEnum(inst)});
     }
 
-    fn writeCaptures(self: *Writer, stream: *std.Io.Writer, extra_index: usize, captures_len: u32) !usize {
-        if (captures_len == 0) {
-            try stream.writeAll("{}");
-            return extra_index;
+    fn writeCaptures(self: *Writer, stream: *std.Io.Writer, captures: []const Zir.Inst.Capture, capture_names: []const Zir.NullTerminatedString) !void {
+        if (captures.len == 0) {
+            assert(capture_names.len == 0);
+            return stream.writeAll("{}");
         }
-
-        const captures: []const Zir.Inst.Capture = @ptrCast(self.code.extra[extra_index..][0..captures_len]);
-        const capture_names: []const Zir.NullTerminatedString = @ptrCast(self.code.extra[extra_index + captures_len ..][0..captures_len]);
         for (captures, capture_names) |capture, name| {
             try stream.writeAll("{ ");
             if (name != .empty) {
@@ -2604,8 +2291,6 @@ const Writer = struct {
             }
             try self.writeCapture(stream, capture);
         }
-
-        return extra_index + 2 * captures_len;
     }
 
     fn writeCapture(self: *Writer, stream: *std.Io.Writer, capture: Zir.Inst.Capture) !void {
-- 
2.54.0


From 510ea6f61f93c722c4cb2c2b39605201cc2f9c32 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 15 Jan 2026 14:01:15 +0000
Subject: [PATCH 415/499] type resolution progress

---
 lib/std/math/big/int.zig         |   14 +-
 lib/std/zig/Zir.zig              |   16 +-
 lib/std/zig/target.zig           |    6 +-
 src/Air.zig                      |   13 +-
 src/Air/types_resolved.zig       |  536 ---
 src/Compilation.zig              |  185 +-
 src/IncrementalDebugServer.zig   |   14 +-
 src/InternPool.zig               | 4702 +++++++++------------
 src/Sema.zig                     | 6549 ++++++++++--------------------
 src/Sema/LowerZon.zig            |   21 +-
 src/Sema/arith.zig               |   39 +-
 src/Sema/bitcast.zig             |   11 +-
 src/Sema/comptime_ptr_access.zig |   38 +-
 src/Sema/type_resolution.zig     |  993 +++++
 src/Type.zig                     | 2927 ++++---------
 src/Value.zig                    |  787 +---
 src/Zcu.zig                      |  163 +-
 src/Zcu/PerThread.zig            | 1504 +++----
 src/codegen.zig                  |    2 +-
 src/codegen/aarch64/Select.zig   |    8 +-
 src/codegen/c.zig                |    8 +-
 src/codegen/llvm.zig             |    2 +-
 src/codegen/mips/abi.zig         |    2 +-
 src/codegen/riscv64/CodeGen.zig  |    5 +-
 src/codegen/spirv/CodeGen.zig    |    2 +-
 src/codegen/x86_64/CodeGen.zig   |   37 +-
 src/link/Dwarf.zig               |    8 +-
 src/mutable_value.zig            |   18 +-
 src/print_value.zig              |   12 +-
 29 files changed, 7305 insertions(+), 11317 deletions(-)
 delete mode 100644 src/Air/types_resolved.zig
 create mode 100644 src/Sema/type_resolution.zig

diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index 96fee84ddf2c6459a72b6823d4a0ea513a113270..9fc50c9e5b1ce4be1f0013af0f906cdd8d0920e2 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -924,7 +924,12 @@ pub const Mutable = struct {
     /// Asserts the result fits in `r`. Upper bound on the number of limbs needed by
     /// r is `calcTwosCompLimbCount(bit_count)`.
     pub fn bitReverse(r: *Mutable, a: Const, signedness: Signedness, bit_count: usize) void {
-        if (bit_count == 0) return;
+        if (bit_count == 0) {
+            r.limbs[0] = 0;
+            r.len = 1;
+            r.positive = true;
+            return;
+        }
 
         r.copy(a);
 
@@ -986,7 +991,12 @@ pub const Mutable = struct {
     /// Asserts the result fits in `r`. Upper bound on the number of limbs needed by
     /// r is `calcTwosCompLimbCount(8*byte_count)`.
     pub fn byteSwap(r: *Mutable, a: Const, signedness: Signedness, byte_count: usize) void {
-        if (byte_count == 0) return;
+        if (byte_count == 0) {
+            r.limbs[0] = 0;
+            r.len = 1;
+            r.positive = true;
+            return;
+        }
 
         r.copy(a);
         const limbs_required = calcTwosCompLimbCount(8 * byte_count);
diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig
index 165f37edfad0452651ffc51565e1383b67c41a63..c0270a9e03e7fe5eca1e0af9d8fdf36e64fc34e3 100644
--- a/lib/std/zig/Zir.zig
+++ b/lib/std/zig/Zir.zig
@@ -3710,7 +3710,7 @@ pub const Inst = struct {
                 };
             }
 
-            pub fn layout(k: Kind) std.builtin.ContainerLayout {
+            pub fn layout(k: Kind) std.builtin.Type.ContainerLayout {
                 return switch (k) {
                     .auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto,
                     .@"extern" => .@"extern",
@@ -4008,20 +4008,6 @@ pub const Inst = struct {
     };
 };
 
-/// MLUGG TODO: delete this!
-pub const DeclIterator = struct {
-    decls: []const Inst.Index,
-    index: usize,
-    pub fn next(it: *DeclIterator) ?Inst.Index {
-        if (it.index == it.decls.len) return null;
-        defer it.index += 1;
-        return it.decls[it.index];
-    }
-};
-pub fn declIterator(zir: Zir, decl_inst: Zir.Inst.Index) DeclIterator {
-    return .{ .decls = zir.typeDecls(decl_inst), .index = 0 };
-}
-
 /// `DeclContents` contains all "interesting" instructions found within a declaration by `findTrackable`.
 /// These instructions are partitioned into a few different sets, since this makes ZIR instruction mapping
 /// more effective.
diff --git a/lib/std/zig/target.zig b/lib/std/zig/target.zig
index 34709e17ac9f0e9da4ff212c541e144f09d71da0..f87b93608650fe1e99955695853b2b7aa02acaf9 100644
--- a/lib/std/zig/target.zig
+++ b/lib/std/zig/target.zig
@@ -503,8 +503,7 @@ pub fn intByteSize(target: *const std.Target, bits: u16) u16 {
 pub fn intAlignment(target: *const std.Target, bits: u16) u16 {
     return switch (target.cpu.arch) {
         .x86 => switch (bits) {
-            0 => 0,
-            1...8 => 1,
+            0...8 => 1,
             9...16 => 2,
             17...32 => 4,
             33...64 => switch (target.os.tag) {
@@ -514,8 +513,7 @@ pub fn intAlignment(target: *const std.Target, bits: u16) u16 {
             else => 16,
         },
         .x86_64 => switch (bits) {
-            0 => 0,
-            1...8 => 1,
+            0...8 => 1,
             9...16 => 2,
             17...32 => 4,
             33...64 => 8,
diff --git a/src/Air.zig b/src/Air.zig
index 28b7a27ba992f375fffa3a96e7045f5de5952d1e..3f7314e11674a00620f6cf9e0da5d6fbb8671d28 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -14,7 +14,6 @@ const Type = @import("Type.zig");
 const Value = @import("Value.zig");
 const Zcu = @import("Zcu.zig");
 const print = @import("Air/print.zig");
-const types_resolved = @import("Air/types_resolved.zig");
 
 pub const Legalize = @import("Air/Legalize.zig");
 pub const Liveness = @import("Air/Liveness.zig");
@@ -173,8 +172,8 @@ pub const Inst = struct {
         /// outside the provenance of the operand, the result is undefined.
         ///
         /// Uses the `ty_pl` field. Payload is `Bin`. The lhs is the pointer,
-        /// rhs is the offset. Result type is the same as lhs. The operand may
-        /// be a slice.
+        /// rhs is the offset. Result type is the same as lhs. The operand type's
+        /// pointer size may be `.slice`, `.many`, or `.c`.
         ptr_add,
         /// Subtract an offset, in element type units, from a pointer,
         /// returning a new pointer. Element type may not be zero bits.
@@ -183,8 +182,8 @@ pub const Inst = struct {
         /// outside the provenance of the operand, the result is undefined.
         ///
         /// Uses the `ty_pl` field. Payload is `Bin`. The lhs is the pointer,
-        /// rhs is the offset. Result type is the same as lhs. The operand may
-        /// be a slice.
+        /// rhs is the offset. Result type is the same as lhs. The operand type's
+        /// pointer size may be `.slice`, `.many`, or `.c`.
         ptr_sub,
         /// Given two operands which can be floats, integers, or vectors, returns the
         /// greater of the operands. For vectors it operates element-wise.
@@ -693,6 +692,7 @@ pub const Inst = struct {
         /// Uses the `ty_pl` field with payload `Bin`.
         slice_elem_ptr,
         /// Given a pointer value, and element index, return the element value at that index.
+        /// The pointer size is either `.c` or `.many`.
         /// Result type is the element type of the pointer operand.
         /// Uses the `bin_op` field.
         ptr_elem_val,
@@ -2440,9 +2440,6 @@ pub fn unwrapShuffleTwo(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index
     };
 }
 
-pub const typesFullyResolved = types_resolved.typesFullyResolved;
-pub const typeFullyResolved = types_resolved.checkType;
-pub const valFullyResolved = types_resolved.checkVal;
 pub const legalize = Legalize.legalize;
 pub const write = print.write;
 pub const writeInst = print.writeInst;
diff --git a/src/Air/types_resolved.zig b/src/Air/types_resolved.zig
deleted file mode 100644
index 216f690414abdf2daea6993536b303812a05866e..0000000000000000000000000000000000000000
--- a/src/Air/types_resolved.zig
+++ /dev/null
@@ -1,536 +0,0 @@
-const Air = @import("../Air.zig");
-const Zcu = @import("../Zcu.zig");
-const Type = @import("../Type.zig");
-const Value = @import("../Value.zig");
-const InternPool = @import("../InternPool.zig");
-
-/// Given a body of AIR instructions, returns whether all type resolution necessary for codegen is complete.
-/// If `false`, then type resolution must have failed, so codegen cannot proceed.
-pub fn typesFullyResolved(air: Air, zcu: *Zcu) bool {
-    return checkBody(air, air.getMainBody(), zcu);
-}
-
-fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
-    const tags = air.instructions.items(.tag);
-    const datas = air.instructions.items(.data);
-
-    for (body) |inst| {
-        const data = datas[@intFromEnum(inst)];
-        switch (tags[@intFromEnum(inst)]) {
-            .inferred_alloc, .inferred_alloc_comptime => unreachable,
-
-            .arg => {
-                if (!checkType(data.arg.ty.toType(), zcu)) return false;
-            },
-
-            .add,
-            .add_safe,
-            .add_optimized,
-            .add_wrap,
-            .add_sat,
-            .sub,
-            .sub_safe,
-            .sub_optimized,
-            .sub_wrap,
-            .sub_sat,
-            .mul,
-            .mul_safe,
-            .mul_optimized,
-            .mul_wrap,
-            .mul_sat,
-            .div_float,
-            .div_float_optimized,
-            .div_trunc,
-            .div_trunc_optimized,
-            .div_floor,
-            .div_floor_optimized,
-            .div_exact,
-            .div_exact_optimized,
-            .rem,
-            .rem_optimized,
-            .mod,
-            .mod_optimized,
-            .max,
-            .min,
-            .bit_and,
-            .bit_or,
-            .shr,
-            .shr_exact,
-            .shl,
-            .shl_exact,
-            .shl_sat,
-            .xor,
-            .cmp_lt,
-            .cmp_lt_optimized,
-            .cmp_lte,
-            .cmp_lte_optimized,
-            .cmp_eq,
-            .cmp_eq_optimized,
-            .cmp_gte,
-            .cmp_gte_optimized,
-            .cmp_gt,
-            .cmp_gt_optimized,
-            .cmp_neq,
-            .cmp_neq_optimized,
-            .bool_and,
-            .bool_or,
-            .store,
-            .store_safe,
-            .set_union_tag,
-            .array_elem_val,
-            .slice_elem_val,
-            .ptr_elem_val,
-            .memset,
-            .memset_safe,
-            .memcpy,
-            .memmove,
-            .atomic_store_unordered,
-            .atomic_store_monotonic,
-            .atomic_store_release,
-            .atomic_store_seq_cst,
-            .legalize_vec_elem_val,
-            => {
-                if (!checkRef(data.bin_op.lhs, zcu)) return false;
-                if (!checkRef(data.bin_op.rhs, zcu)) return false;
-            },
-
-            .not,
-            .bitcast,
-            .clz,
-            .ctz,
-            .popcount,
-            .byte_swap,
-            .bit_reverse,
-            .abs,
-            .load,
-            .fptrunc,
-            .fpext,
-            .intcast,
-            .intcast_safe,
-            .trunc,
-            .optional_payload,
-            .optional_payload_ptr,
-            .optional_payload_ptr_set,
-            .wrap_optional,
-            .unwrap_errunion_payload,
-            .unwrap_errunion_err,
-            .unwrap_errunion_payload_ptr,
-            .unwrap_errunion_err_ptr,
-            .errunion_payload_ptr_set,
-            .wrap_errunion_payload,
-            .wrap_errunion_err,
-            .struct_field_ptr_index_0,
-            .struct_field_ptr_index_1,
-            .struct_field_ptr_index_2,
-            .struct_field_ptr_index_3,
-            .get_union_tag,
-            .slice_len,
-            .slice_ptr,
-            .ptr_slice_len_ptr,
-            .ptr_slice_ptr_ptr,
-            .array_to_slice,
-            .int_from_float,
-            .int_from_float_optimized,
-            .int_from_float_safe,
-            .int_from_float_optimized_safe,
-            .float_from_int,
-            .splat,
-            .error_set_has_value,
-            .addrspace_cast,
-            .c_va_arg,
-            .c_va_copy,
-            => {
-                if (!checkType(data.ty_op.ty.toType(), zcu)) return false;
-                if (!checkRef(data.ty_op.operand, zcu)) return false;
-            },
-
-            .alloc,
-            .ret_ptr,
-            .c_va_start,
-            => {
-                if (!checkType(data.ty, zcu)) return false;
-            },
-
-            .ptr_add,
-            .ptr_sub,
-            .add_with_overflow,
-            .sub_with_overflow,
-            .mul_with_overflow,
-            .shl_with_overflow,
-            .slice,
-            .slice_elem_ptr,
-            .ptr_elem_ptr,
-            => {
-                const bin = air.extraData(Air.Bin, data.ty_pl.payload).data;
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(bin.lhs, zcu)) return false;
-                if (!checkRef(bin.rhs, zcu)) return false;
-            },
-
-            .block,
-            .loop,
-            => {
-                const block = air.unwrapBlock(inst);
-                if (!checkType(block.ty, zcu)) return false;
-                if (!checkBody(
-                    air,
-                    block.body,
-                    zcu,
-                )) return false;
-            },
-
-            .dbg_inline_block => {
-                const block = air.unwrapDbgBlock(inst);
-                if (!checkType(block.ty, zcu)) return false;
-                if (!checkBody(
-                    air,
-                    block.body,
-                    zcu,
-                )) return false;
-            },
-
-            .sqrt,
-            .sin,
-            .cos,
-            .tan,
-            .exp,
-            .exp2,
-            .log,
-            .log2,
-            .log10,
-            .floor,
-            .ceil,
-            .round,
-            .trunc_float,
-            .neg,
-            .neg_optimized,
-            .is_null,
-            .is_non_null,
-            .is_null_ptr,
-            .is_non_null_ptr,
-            .is_err,
-            .is_non_err,
-            .is_err_ptr,
-            .is_non_err_ptr,
-            .ret,
-            .ret_safe,
-            .ret_load,
-            .is_named_enum_value,
-            .tag_name,
-            .error_name,
-            .cmp_lt_errors_len,
-            .c_va_end,
-            .set_err_return_trace,
-            => {
-                if (!checkRef(data.un_op, zcu)) return false;
-            },
-
-            .br, .switch_dispatch => {
-                if (!checkRef(data.br.operand, zcu)) return false;
-            },
-
-            .cmp_vector,
-            .cmp_vector_optimized,
-            => {
-                const extra = air.extraData(Air.VectorCmp, data.ty_pl.payload).data;
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(extra.lhs, zcu)) return false;
-                if (!checkRef(extra.rhs, zcu)) return false;
-            },
-
-            .reduce,
-            .reduce_optimized,
-            => {
-                if (!checkRef(data.reduce.operand, zcu)) return false;
-            },
-
-            .struct_field_ptr,
-            .struct_field_val,
-            => {
-                const extra = air.extraData(Air.StructField, data.ty_pl.payload).data;
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(extra.struct_operand, zcu)) return false;
-            },
-
-            .shuffle_one => {
-                const unwrapped = air.unwrapShuffleOne(zcu, inst);
-                if (!checkType(unwrapped.result_ty, zcu)) return false;
-                if (!checkRef(unwrapped.operand, zcu)) return false;
-                for (unwrapped.mask) |m| switch (m.unwrap()) {
-                    .elem => {},
-                    .value => |val| if (!checkVal(.fromInterned(val), zcu)) return false,
-                };
-            },
-
-            .shuffle_two => {
-                const unwrapped = air.unwrapShuffleTwo(zcu, inst);
-                if (!checkType(unwrapped.result_ty, zcu)) return false;
-                if (!checkRef(unwrapped.operand_a, zcu)) return false;
-                if (!checkRef(unwrapped.operand_b, zcu)) return false;
-                // No values to check because there are no comptime-known values other than undef
-            },
-
-            .cmpxchg_weak,
-            .cmpxchg_strong,
-            => {
-                const extra = air.extraData(Air.Cmpxchg, data.ty_pl.payload).data;
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(extra.ptr, zcu)) return false;
-                if (!checkRef(extra.expected_value, zcu)) return false;
-                if (!checkRef(extra.new_value, zcu)) return false;
-            },
-
-            .aggregate_init => {
-                const ty = data.ty_pl.ty.toType();
-                const elems_len: usize = @intCast(ty.arrayLen(zcu));
-                const elems: []const Air.Inst.Ref = @ptrCast(air.extra.items[data.ty_pl.payload..][0..elems_len]);
-                if (!checkType(ty, zcu)) return false;
-                if (ty.zigTypeTag(zcu) == .@"struct") {
-                    for (elems, 0..) |elem, elem_idx| {
-                        if (ty.structFieldIsComptime(elem_idx, zcu)) continue;
-                        if (!checkRef(elem, zcu)) return false;
-                    }
-                } else {
-                    for (elems) |elem| {
-                        if (!checkRef(elem, zcu)) return false;
-                    }
-                }
-            },
-
-            .union_init => {
-                const extra = air.extraData(Air.UnionInit, data.ty_pl.payload).data;
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(extra.init, zcu)) return false;
-            },
-
-            .field_parent_ptr => {
-                const extra = air.extraData(Air.FieldParentPtr, data.ty_pl.payload).data;
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                if (!checkRef(extra.field_ptr, zcu)) return false;
-            },
-
-            .atomic_load => {
-                if (!checkRef(data.atomic_load.ptr, zcu)) return false;
-            },
-
-            .prefetch => {
-                if (!checkRef(data.prefetch.ptr, zcu)) return false;
-            },
-
-            .runtime_nav_ptr => {
-                if (!checkType(.fromInterned(data.ty_nav.ty), zcu)) return false;
-            },
-
-            .select,
-            .mul_add,
-            .legalize_vec_store_elem,
-            => {
-                const bin = air.extraData(Air.Bin, data.pl_op.payload).data;
-                if (!checkRef(data.pl_op.operand, zcu)) return false;
-                if (!checkRef(bin.lhs, zcu)) return false;
-                if (!checkRef(bin.rhs, zcu)) return false;
-            },
-
-            .atomic_rmw => {
-                const extra = air.extraData(Air.AtomicRmw, data.pl_op.payload).data;
-                if (!checkRef(data.pl_op.operand, zcu)) return false;
-                if (!checkRef(extra.operand, zcu)) return false;
-            },
-
-            .call,
-            .call_always_tail,
-            .call_never_tail,
-            .call_never_inline,
-            => {
-                const call = air.unwrapCall(inst);
-                const args = call.args;
-                if (!checkRef(call.callee, zcu)) return false;
-                for (args) |arg| if (!checkRef(arg, zcu)) return false;
-            },
-
-            .dbg_var_ptr,
-            .dbg_var_val,
-            .dbg_arg_inline,
-            => {
-                if (!checkRef(data.pl_op.operand, zcu)) return false;
-            },
-
-            .@"try", .try_cold => {
-                const unwrapped_try = air.unwrapTry(inst);
-                if (!checkRef(unwrapped_try.error_union, zcu)) return false;
-                if (!checkBody(
-                    air,
-                    unwrapped_try.else_body,
-                    zcu,
-                )) return false;
-            },
-
-            .try_ptr, .try_ptr_cold => {
-                const unwrapped_try = air.unwrapTryPtr(inst);
-                if (!checkType(unwrapped_try.error_union_payload_ptr_ty.toType(), zcu)) return false;
-                if (!checkRef(unwrapped_try.error_union_ptr, zcu)) return false;
-                if (!checkBody(
-                    air,
-                    unwrapped_try.else_body,
-                    zcu,
-                )) return false;
-            },
-
-            .cond_br => {
-                const cond_br = air.unwrapCondBr(inst);
-                if (!checkRef(cond_br.condition, zcu)) return false;
-                if (!checkBody(
-                    air,
-                    cond_br.then_body,
-                    zcu,
-                )) return false;
-                if (!checkBody(
-                    air,
-                    cond_br.else_body,
-                    zcu,
-                )) return false;
-            },
-
-            .switch_br, .loop_switch_br => {
-                const switch_br = air.unwrapSwitch(inst);
-                if (!checkRef(switch_br.operand, zcu)) return false;
-                var it = switch_br.iterateCases();
-                while (it.next()) |case| {
-                    for (case.items) |item| if (!checkRef(item, zcu)) return false;
-                    for (case.ranges) |range| {
-                        if (!checkRef(range[0], zcu)) return false;
-                        if (!checkRef(range[1], zcu)) return false;
-                    }
-                    if (!checkBody(air, case.body, zcu)) return false;
-                }
-                if (!checkBody(air, it.elseBody(), zcu)) return false;
-            },
-
-            .assembly => {
-                const unwrapped_asm = air.unwrapAsm(inst);
-                if (!checkType(data.ty_pl.ty.toType(), zcu)) return false;
-                // Luckily, we only care about the inputs and outputs, so we don't have to do
-                // the whole null-terminated string dance.
-                const outputs = unwrapped_asm.outputs;
-                const inputs = unwrapped_asm.inputs;
-
-                for (outputs) |output| if (output != .none and !checkRef(output, zcu)) return false;
-                for (inputs) |input| if (input != .none and !checkRef(input, zcu)) return false;
-            },
-
-            .legalize_compiler_rt_call => {
-                const rt_call = air.unwrapCompilerRtCall(inst);
-                const args = rt_call.args;
-                for (args) |arg| if (!checkRef(arg, zcu)) return false;
-            },
-
-            .trap,
-            .breakpoint,
-            .ret_addr,
-            .frame_addr,
-            .unreach,
-            .wasm_memory_size,
-            .wasm_memory_grow,
-            .work_item_id,
-            .work_group_size,
-            .work_group_id,
-            .dbg_stmt,
-            .dbg_empty_stmt,
-            .err_return_trace,
-            .save_err_return_trace_index,
-            .repeat,
-            => {},
-        }
-    }
-    return true;
-}
-
-fn checkRef(ref: Air.Inst.Ref, zcu: *Zcu) bool {
-    const ip_index = ref.toInterned() orelse {
-        // This operand refers back to a previous instruction.
-        // We have already checked that instruction's type.
-        // So, there's no need to check this operand's type.
-        return true;
-    };
-    return checkVal(Value.fromInterned(ip_index), zcu);
-}
-
-pub fn checkVal(val: Value, zcu: *Zcu) bool {
-    const ty = val.typeOf(zcu);
-    if (!checkType(ty, zcu)) return false;
-    if (val.isUndef(zcu)) return true;
-    if (ty.toIntern() == .type_type and !checkType(val.toType(), zcu)) return false;
-    // Check for lazy values
-    switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-        .int => |int| switch (int.storage) {
-            .u64, .i64, .big_int => return true,
-            .lazy_align, .lazy_size => |ty_index| {
-                return checkType(Type.fromInterned(ty_index), zcu);
-            },
-        },
-        else => return true,
-    }
-}
-
-pub fn checkType(ty: Type, zcu: *Zcu) bool {
-    const ip = &zcu.intern_pool;
-    if (ty.isGenericPoison()) return true;
-    return switch (ty.zigTypeTag(zcu)) {
-        .type,
-        .void,
-        .bool,
-        .noreturn,
-        .int,
-        .float,
-        .error_set,
-        .@"enum",
-        .@"opaque",
-        .vector,
-        // These types can appear due to some dummy instructions Sema introduces and expects to be omitted by Liveness.
-        // It's a little silly -- but fine, we'll return `true`.
-        .comptime_float,
-        .comptime_int,
-        .undefined,
-        .null,
-        .enum_literal,
-        => true,
-
-        .frame,
-        .@"anyframe",
-        => @panic("TODO Air.types_resolved.checkType async frames"),
-
-        .optional => checkType(ty.childType(zcu), zcu),
-        .error_union => checkType(ty.errorUnionPayload(zcu), zcu),
-        .pointer => checkType(ty.childType(zcu), zcu),
-        .array => checkType(ty.childType(zcu), zcu),
-
-        .@"fn" => {
-            const info = zcu.typeToFunc(ty).?;
-            for (0..info.param_types.len) |i| {
-                const param_ty = info.param_types.get(ip)[i];
-                if (!checkType(Type.fromInterned(param_ty), zcu)) return false;
-            }
-            return checkType(Type.fromInterned(info.return_type), zcu);
-        },
-        .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .struct_type => {
-                const struct_obj = zcu.typeToStruct(ty).?;
-                return switch (struct_obj.layout) {
-                    .@"packed" => struct_obj.backingIntTypeUnordered(ip) != .none,
-                    .auto, .@"extern" => struct_obj.flagsUnordered(ip).fully_resolved,
-                };
-            },
-            .tuple_type => |tuple| {
-                for (0..tuple.types.len) |i| {
-                    const field_is_comptime = tuple.values.get(ip)[i] != .none;
-                    if (field_is_comptime) continue;
-                    const field_ty = tuple.types.get(ip)[i];
-                    if (!checkType(Type.fromInterned(field_ty), zcu)) return false;
-                }
-                return true;
-            },
-            else => unreachable,
-        },
-        .@"union" => return zcu.typeToUnion(ty).?.flagsUnordered(ip).status == .fully_resolved,
-    };
-}
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 521de0b427c4a9cba23daab8e46521bc1ec6ef59..14046f38fc2e41c9aa50efa7586f6815ba67aeb6 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -126,15 +126,7 @@ oneshot_prelink_tasks: std.ArrayList(link.PrelinkTask),
 /// work is queued or not.
 queued_jobs: QueuedJobs,
 
-work_queues: [
-    len: {
-        var len: usize = 0;
-        for (std.enums.values(Job.Tag)) |tag| {
-            len = @max(Job.stage(tag) + 1, len);
-        }
-        break :len len;
-    }
-]std.Deque(Job),
+work_queues: [2]std.Deque(Job),
 
 /// These jobs are to invoke the Clang compiler to create an object file, which
 /// gets linked with the Compilation.
@@ -990,35 +982,27 @@ const Job = union(enum) {
     update_line_number: InternPool.TrackedInst.Index,
     /// The `AnalUnit`, which is *not* a `func`, must be semantically analyzed.
     /// This may be its first time being analyzed, or it may be outdated.
-    /// If the unit is a test function, an `analyze_func` job will then be queued.
-    analyze_comptime_unit: InternPool.AnalUnit,
-    /// This function must be semantically analyzed.
-    /// This may be its first time being analyzed, or it may be outdated.
-    /// After analysis, a `codegen_func` job will be queued.
-    /// These must be separate jobs to ensure any needed type resolution occurs *before* codegen.
-    /// This job is separate from `analyze_comptime_unit` because it has a different priority.
-    analyze_func: InternPool.Index,
+    /// If the unit is a function, a `codegen_func` job will be queued after analysis completes.
+    /// If the unit is a *test* function, an `analyze_func` job will also be queued.
+    analyze_unit: InternPool.AnalUnit,
     /// The main source file for the module needs to be analyzed.
     analyze_mod: *Package.Module,
-    /// Fully resolve the given `struct` or `union` type.
-    resolve_type_fully: InternPool.Index,
 
     /// The value is the index into `windows_libs`.
     windows_import_lib: usize,
 
-    const Tag = @typeInfo(Job).@"union".tag_type.?;
-    fn stage(tag: Tag) usize {
-        return switch (tag) {
-            // Prioritize functions so that codegen can get to work on them on a
-            // separate thread, while Sema goes back to its own work.
-            .resolve_type_fully, .analyze_func, .codegen_func => 0,
+    fn stage(job: *const Job) usize {
+        // Prioritize functions so that codegen can get to work on them on a
+        // separate thread, while Sema goes back to its own work.
+        return switch (job.*) {
+            .codegen_func => 0,
+            .analyze_unit => |unit| switch (unit.unwrap()) {
+                .func => 0,
+                else => 1,
+            },
             else => 1,
         };
     }
-    comptime {
-        // Job dependencies
-        assert(stage(.resolve_type_fully) <= stage(.codegen_func));
-    }
 };
 
 pub const CObject = struct {
@@ -3728,7 +3712,9 @@ const Header = extern struct {
         src_hash_deps_len: u32,
         nav_val_deps_len: u32,
         nav_ty_deps_len: u32,
-        interned_deps_len: u32,
+        type_layout_deps_len: u32,
+        type_inits_deps_len: u32,
+        func_ies_deps_len: u32,
         zon_file_deps_len: u32,
         embed_file_deps_len: u32,
         namespace_deps_len: u32,
@@ -3776,7 +3762,9 @@ pub fn saveState(comp: *Compilation) !void {
                 .src_hash_deps_len = @intCast(ip.src_hash_deps.count()),
                 .nav_val_deps_len = @intCast(ip.nav_val_deps.count()),
                 .nav_ty_deps_len = @intCast(ip.nav_ty_deps.count()),
-                .interned_deps_len = @intCast(ip.interned_deps.count()),
+                .type_layout_deps_len = @intCast(ip.type_layout_deps.count()),
+                .type_inits_deps_len = @intCast(ip.type_inits_deps.count()),
+                .func_ies_deps_len = @intCast(ip.func_ies_deps.count()),
                 .zon_file_deps_len = @intCast(ip.zon_file_deps.count()),
                 .embed_file_deps_len = @intCast(ip.embed_file_deps.count()),
                 .namespace_deps_len = @intCast(ip.namespace_deps.count()),
@@ -3800,7 +3788,7 @@ pub fn saveState(comp: *Compilation) !void {
             },
         });
 
-        try bufs.ensureTotalCapacityPrecise(22 + 9 * pt_headers.items.len);
+        try bufs.ensureTotalCapacityPrecise(26 + 9 * pt_headers.items.len);
         addBuf(&bufs, mem.asBytes(&header));
         addBuf(&bufs, @ptrCast(pt_headers.items));
 
@@ -3810,8 +3798,12 @@ pub fn saveState(comp: *Compilation) !void {
         addBuf(&bufs, @ptrCast(ip.nav_val_deps.values()));
         addBuf(&bufs, @ptrCast(ip.nav_ty_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.nav_ty_deps.values()));
-        addBuf(&bufs, @ptrCast(ip.interned_deps.keys()));
-        addBuf(&bufs, @ptrCast(ip.interned_deps.values()));
+        addBuf(&bufs, @ptrCast(ip.type_layout_deps.keys()));
+        addBuf(&bufs, @ptrCast(ip.type_layout_deps.values()));
+        addBuf(&bufs, @ptrCast(ip.type_inits_deps.keys()));
+        addBuf(&bufs, @ptrCast(ip.type_inits_deps.values()));
+        addBuf(&bufs, @ptrCast(ip.func_ies_deps.keys()));
+        addBuf(&bufs, @ptrCast(ip.func_ies_deps.values()));
         addBuf(&bufs, @ptrCast(ip.zon_file_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.zon_file_deps.values()));
         addBuf(&bufs, @ptrCast(ip.embed_file_deps.keys()));
@@ -4489,7 +4481,7 @@ pub fn addModuleErrorMsg(
                 const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
                     .@"comptime" => "comptime",
                     .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
-                    .type => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
+                    .type_layout, .type_inits => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
                     .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
                     .memoized_state => null,
                 };
@@ -4900,15 +4892,7 @@ fn performAllTheWork(
             // If there's no work queued, check if there's anything outdated
             // which we need to work on, and queue it if so.
             if (try zcu.findOutdatedToAnalyze()) |outdated| {
-                try comp.queueJob(switch (outdated.unwrap()) {
-                    .func => |f| .{ .analyze_func = f },
-                    .memoized_state,
-                    .@"comptime",
-                    .nav_ty,
-                    .nav_val,
-                    .type,
-                    => .{ .analyze_comptime_unit = outdated },
-                });
+                try comp.queueJob(.{ .analyze_unit = outdated });
                 continue;
             }
             zcu.sema_prog_node.end();
@@ -5151,7 +5135,7 @@ fn dispatchPrelinkWork(comp: *Compilation, main_progress_node: std.Progress.Node
 const JobError = Allocator.Error || Io.Cancelable;
 
 pub fn queueJob(comp: *Compilation, job: Job) !void {
-    try comp.work_queues[Job.stage(job)].pushBack(comp.gpa, job);
+    try comp.work_queues[job.stage()].pushBack(comp.gpa, job);
 }
 
 pub fn queueJobs(comp: *Compilation, jobs: []const Job) !void {
@@ -5166,13 +5150,24 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             var owned_air: ?Air = func.air;
             defer if (owned_air) |*air| air.deinit(gpa);
 
-            if (!owned_air.?.typesFullyResolved(zcu)) {
-                // Type resolution failed in a way which affects this function. This is a transitive
-                // failure, but it doesn't need recording, because this function semantically depends
-                // on the failed type, so when it is changed the function is updated.
-                zcu.codegen_prog_node.completeOne();
-                comp.link_prog_node.completeOne();
-                return;
+            {
+                const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
+                defer pt.deactivate();
+                pt.resolveAirTypesForCodegen(&owned_air.?) catch |err| switch (err) {
+                    error.OutOfMemory,
+                    error.Canceled,
+                    => |e| return e,
+
+                    error.AnalysisFail => {
+                        // Type resolution failed, making codegen of this function impossible. This
+                        // is a transitive failure, but it doesn't need recording, because this
+                        // function semantically depends on the failed type, so when it is changed
+                        // the function will be updated.
+                        zcu.codegen_prog_node.completeOne();
+                        comp.link_prog_node.completeOne();
+                        return;
+                    },
+                };
             }
 
             // Some linkers need to refer to the AIR. In that case, the linker is not running
@@ -5198,45 +5193,54 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 }
             }
             assert(nav.status == .fully_resolved);
-            if (!Air.valFullyResolved(zcu.navValue(nav_index), zcu)) {
-                // Type resolution failed in a way which affects this `Nav`. This is a transitive
-                // failure, but it doesn't need recording, because this `Nav` semantically depends
-                // on the failed type, so when it is changed the `Nav` will be updated.
-                comp.link_prog_node.completeOne();
-                return;
+            {
+                const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
+                defer pt.deactivate();
+                pt.resolveValueTypesForCodegen(zcu.navValue(nav_index)) catch |err| switch (err) {
+                    error.OutOfMemory,
+                    error.Canceled,
+                    => |e| return e,
+
+                    error.AnalysisFail => {
+                        // Type resolution failed, making codegen of this `Nav` impossible. This is
+                        // a transitive failure, but it doesn't need recording, because this `Nav`
+                        // semantically depends on the failed type, so when it is changed the value
+                        // of the `Nav` will be updated.
+                        comp.link_prog_node.completeOne();
+                        return;
+                    },
+                };
             }
             try comp.link_queue.enqueueZcu(comp, tid, .{ .link_nav = nav_index });
         },
         .link_type => |ty| {
             const zcu = comp.zcu.?;
             if (zcu.failed_types.fetchSwapRemove(ty)) |*entry| entry.value.deinit(zcu.gpa);
-            if (!Air.typeFullyResolved(.fromInterned(ty), zcu)) {
-                // Type resolution failed in a way which affects this type. This is a transitive
-                // failure, but it doesn't need recording, because this type semantically depends
-                // on the failed type, so when that is changed, this type will be updated.
-                comp.link_prog_node.completeOne();
-                return;
+            {
+                const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
+                defer pt.deactivate();
+                pt.resolveTypeForCodegen(.fromInterned(ty)) catch |err| switch (err) {
+                    error.OutOfMemory,
+                    error.Canceled,
+                    => |e| return e,
+
+                    error.AnalysisFail => {
+                        // Type resolution failed, making codegen of this type impossible. This is
+                        // a transitive failure, but it doesn't need recording, because this type
+                        // semantically depends on the failed type, so when it is changed the type
+                        // will be updated appropriately.
+                        comp.link_prog_node.completeOne();
+                        return;
+                    },
+                };
             }
             try comp.link_queue.enqueueZcu(comp, tid, .{ .link_type = ty });
         },
         .update_line_number => |tracked_inst| {
             try comp.link_queue.enqueueZcu(comp, tid, .{ .update_line_number = tracked_inst });
         },
-        .analyze_func => |func| {
-            const tracy_trace = traceNamed(@src(), "analyze_func");
-            defer tracy_trace.end();
-
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
-            defer pt.deactivate();
-
-            pt.ensureFuncBodyUpToDate(func) catch |err| switch (err) {
-                error.OutOfMemory => |e| return e,
-                error.Canceled => |e| return e,
-                error.AnalysisFail => return,
-            };
-        },
-        .analyze_comptime_unit => |unit| {
-            const tracy_trace = traceNamed(@src(), "analyze_comptime_unit");
+        .analyze_unit => |unit| {
+            const tracy_trace = traceNamed(@src(), "analyze_unit");
             defer tracy_trace.end();
 
             const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
@@ -5246,9 +5250,10 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 .@"comptime" => |cu| pt.ensureComptimeUnitUpToDate(cu),
                 .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav),
                 .nav_val => |nav| pt.ensureNavValUpToDate(nav),
-                .type => |ty| if (pt.ensureTypeUpToDate(ty)) |_| {} else |err| err,
+                .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty)),
+                .type_inits => |ty| pt.ensureTypeInitsUpToDate(.fromInterned(ty)),
                 .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage),
-                .func => unreachable,
+                .func => |func| pt.ensureFuncBodyUpToDate(func),
             };
             maybe_err catch |err| switch (err) {
                 error.OutOfMemory => |e| return e,
@@ -5275,27 +5280,15 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 try pt.zcu.ensureFuncBodyAnalysisQueued(ip.getNav(nav).status.fully_resolved.val);
             }
         },
-        .resolve_type_fully => |ty| {
-            const tracy_trace = traceNamed(@src(), "resolve_type_fully");
-            defer tracy_trace.end();
-
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
-            defer pt.deactivate();
-            Type.fromInterned(ty).resolveFully(pt) catch |err| switch (err) {
-                error.OutOfMemory, error.Canceled => |e| return e,
-                error.AnalysisFail => return,
-            };
-        },
         .analyze_mod => |mod| {
             const tracy_trace = traceNamed(@src(), "analyze_mod");
             defer tracy_trace.end();
 
             const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
             defer pt.deactivate();
-            pt.semaMod(mod) catch |err| switch (err) {
-                error.OutOfMemory, error.Canceled => |e| return e,
-                error.AnalysisFail => return,
-            };
+
+            const mod_root_file = pt.zcu.module_roots.get(mod).?.unwrap().?;
+            try pt.ensureFileAnalyzed(mod_root_file);
         },
         .windows_import_lib => |index| {
             const tracy_trace = traceNamed(@src(), "windows_import_lib");
diff --git a/src/IncrementalDebugServer.zig b/src/IncrementalDebugServer.zig
index b4bc2c812ebd8ad67dce61738989efca3f388058..ce40844057d8e34d409f6ba78eb1b6b59f9085dc 100644
--- a/src/IncrementalDebugServer.zig
+++ b/src/IncrementalDebugServer.zig
@@ -306,12 +306,8 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const
             try w.print("[{d}] ", .{i});
             switch (dependee) {
                 .src_hash, .namespace, .namespace_name, .zon_file, .embed_file => try w.print("{f}", .{zcu.fmtDependee(dependee)}),
-                .nav_val, .nav_ty => |nav| try w.print("{s} {d}", .{ @tagName(dependee), @intFromEnum(nav) }),
-                .interned => |ip_index| switch (ip.indexToKey(ip_index)) {
-                    .struct_type, .union_type, .enum_type => try w.print("type {d}", .{@intFromEnum(ip_index)}),
-                    .func => try w.print("func {d}", .{@intFromEnum(ip_index)}),
-                    else => unreachable,
-                },
+                .nav_val, .nav_ty => |nav| try w.print("{t} {d}", .{ dependee, @intFromEnum(nav) }),
+                .type_layout, .type_inits, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
                 .memoized_state => |stage| try w.print("memoized_state {s}", .{@tagName(stage)}),
             }
             try w.writeByte('\n');
@@ -376,8 +372,10 @@ fn parseAnalUnit(str: []const u8) ?AnalUnit {
         return .wrap(.{ .nav_val = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "nav_ty")) {
         return .wrap(.{ .nav_ty = @enumFromInt(parseIndex(idx_str) orelse return null) });
-    } else if (std.mem.eql(u8, kind, "type")) {
-        return .wrap(.{ .type = @enumFromInt(parseIndex(idx_str) orelse return null) });
+    } else if (std.mem.eql(u8, kind, "type_layout")) {
+        return .wrap(.{ .type_layout = @enumFromInt(parseIndex(idx_str) orelse return null) });
+    } else if (std.mem.eql(u8, kind, "type_inits")) {
+        return .wrap(.{ .type_inits = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "func")) {
         return .wrap(.{ .func = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "memoized_state")) {
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 595bedd5473653ccc2885b3181d5007dfe0b926e..ed4666a5b91a940bab9f91146c2095911c0909ef 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -47,11 +47,15 @@ nav_val_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
 /// Dependencies on the type of a Nav.
 /// Value is index into `dep_entries` of the first dependency on this Nav value.
 nav_ty_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
-/// Dependencies on an interned value, either:
-/// * a runtime function (invalidated when its IES changes)
-/// * a container type requiring resolution (invalidated when the type must be recreated at a new index)
-/// Value is index into `dep_entries` of the first dependency on this interned value.
-interned_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
+/// Dependencies on a function's inferred error set. Key is the function body, not the IES.
+/// Value is index into `dep_entries` of the first dependency on this function's IES.
+func_ies_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
+/// Dependencies on the resolved layout of a `struct` or `union` type.
+/// Value is index into `dep_entries` of the first dependency on this type's layout.
+type_layout_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
+/// Dependencies on the resolved initializers of a `struct` or `enum` type.
+/// Value is index into `dep_entries` of the first dependency on this type's inits.
+type_inits_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
 /// Dependencies on a ZON file. Triggered by `@import` of ZON.
 /// Value is index into `dep_entries` of the first dependency on this ZON file.
 zon_file_deps: std.AutoArrayHashMapUnmanaged(FileIndex, DepEntry.Index),
@@ -104,7 +108,9 @@ pub const empty: InternPool = .{
     .src_hash_deps = .empty,
     .nav_val_deps = .empty,
     .nav_ty_deps = .empty,
-    .interned_deps = .empty,
+    .func_ies_deps = .empty,
+    .type_layout_deps = .empty,
+    .type_inits_deps = .empty,
     .zon_file_deps = .empty,
     .embed_file_deps = .empty,
     .namespace_deps = .empty,
@@ -415,7 +421,8 @@ pub const AnalUnit = packed struct(u64) {
         @"comptime",
         nav_val,
         nav_ty,
-        type,
+        type_layout,
+        type_inits,
         func,
         memoized_state,
     };
@@ -427,9 +434,11 @@ pub const AnalUnit = packed struct(u64) {
         nav_val: Nav.Index,
         /// This `AnalUnit` resolves the type of the given `Nav`.
         nav_ty: Nav.Index,
-        /// This `AnalUnit` resolves the given `struct`/`union`/`enum` type.
-        /// Generated tag enums are never used here (they do not undergo type resolution).
-        type: InternPool.Index,
+        /// This `AnalUnit` resolves the layout of the given `struct` or `union` type.
+        type_layout: InternPool.Index,
+        /// This `AnalUnit` resolves the field inits of the given `struct` or `enum` type.
+        /// The type may be a union's auto-generated tag enum, if the union has explicit field values.
+        type_inits: InternPool.Index,
         /// This `AnalUnit` analyzes the body of the given runtime function.
         func: InternPool.Index,
         /// This `AnalUnit` resolves all state which is memoized in fields on `Zcu`.
@@ -840,7 +849,10 @@ pub const Dependee = union(enum) {
     src_hash: TrackedInst.Index,
     nav_val: Nav.Index,
     nav_ty: Nav.Index,
-    interned: Index,
+    /// Index is the function, not its IES.
+    func_ies: Index,
+    type_layout: Index,
+    type_inits: Index,
     zon_file: FileIndex,
     embed_file: Zcu.EmbedFile.Index,
     namespace: TrackedInst.Index,
@@ -892,7 +904,9 @@ pub fn dependencyIterator(ip: *const InternPool, dependee: Dependee) DependencyI
         .src_hash => |x| ip.src_hash_deps.get(x),
         .nav_val => |x| ip.nav_val_deps.get(x),
         .nav_ty => |x| ip.nav_ty_deps.get(x),
-        .interned => |x| ip.interned_deps.get(x),
+        .func_ies => |x| ip.func_ies_deps.get(x),
+        .type_layout => |x| ip.type_layout_deps.get(x),
+        .type_inits => |x| ip.type_inits_deps.get(x),
         .zon_file => |x| ip.zon_file_deps.get(x),
         .embed_file => |x| ip.embed_file_deps.get(x),
         .namespace => |x| ip.namespace_deps.get(x),
@@ -965,7 +979,9 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend
                 .src_hash => ip.src_hash_deps,
                 .nav_val => ip.nav_val_deps,
                 .nav_ty => ip.nav_ty_deps,
-                .interned => ip.interned_deps,
+                .func_ies => ip.func_ies_deps,
+                .type_layout => ip.type_layout_deps,
+                .type_inits => ip.type_inits_deps,
                 .zon_file => ip.zon_file_deps,
                 .embed_file => ip.embed_file_deps,
                 .namespace => ip.namespace_deps,
@@ -2065,15 +2081,15 @@ pub const Key = union(enum) {
     simple_type: SimpleType,
     /// This represents a struct that has been explicitly declared in source code,
     /// or was created with `@Struct`. It is unique and based on a declaration.
-    struct_type: NamespaceType,
+    struct_type: ContainerType,
     /// This is a tuple type. Tuples are logically similar to structs, but have some
     /// important differences in semantics; they do not undergo staged type resolution,
     /// so cannot be self-referential, and they are not considered container/namespace
     /// types, so cannot have declarations and have structural equality properties.
     tuple_type: TupleType,
-    union_type: NamespaceType,
-    opaque_type: NamespaceType,
-    enum_type: NamespaceType,
+    union_type: ContainerType,
+    opaque_type: ContainerType,
+    enum_type: ContainerType,
     func_type: FuncType,
     error_set_type: ErrorSetType,
     /// The payload is the function body, either a `func_decl` or `func_instance`.
@@ -2211,16 +2227,10 @@ pub const Key = union(enum) {
     /// * `loadUnionType`
     /// * `loadEnumType`
     /// * `loadOpaqueType`
-    pub const NamespaceType = union(enum) {
+    pub const ContainerType = union(enum) {
         /// This type corresponds to an actual source declaration, e.g. `struct { ... }`.
         /// It is hashed based on its ZIR instruction index and set of captures.
         declared: Declared,
-        /// This type is an automatically-generated enum tag type for a union.
-        /// It is hashed based on the index of the union type it corresponds to.
-        generated_tag: struct {
-            /// The union for which this is a tag type.
-            union_type: Index,
-        },
         /// This type originates from a reification via `@Enum`, `@Struct`, `@Union` or from an anonymous initialization.
         /// It is hashed based on its ZIR instruction index and fields, attributes, etc.
         /// To avoid making this key overly complex, the type-specific data is hashed by Sema.
@@ -2231,10 +2241,17 @@ pub const Key = union(enum) {
             /// A hash of this type's attributes, fields, etc, generated by Sema.
             type_hash: u64,
         },
+        /// This type is an automatically-generated enum tag type for this union type.
+        /// It is hashed based on the index of the union type it corresponds to.
+        generated_union_tag: Index,
 
         pub const Declared = struct {
             /// A `struct_decl`, `union_decl`, `enum_decl`, or `opaque_decl` instruction.
             zir_index: TrackedInst.Index,
+            /// If the type declaration had an argument type (tag type or packed backing type), this
+            /// is that type. Otherwise, this is `.none`. It is always `.none` for `opaque` types as
+            /// `opaque(T)` does not exist.
+            arg_ty: Index,
             /// The captured values of this type. These values must be fully resolved per the language spec.
             captures: union(enum) {
                 owned: CaptureValue.Slice,
@@ -2254,7 +2271,6 @@ pub const Key = union(enum) {
         noalias_bits: u32,
         cc: std.builtin.CallingConvention,
         is_var_args: bool,
-        is_generic: bool,
         is_noinline: bool,
 
         pub fn paramIsComptime(self: @This(), i: u5) bool {
@@ -2273,7 +2289,6 @@ pub const Key = union(enum) {
                 a.comptime_bits == b.comptime_bits and
                 a.noalias_bits == b.noalias_bits and
                 a.is_var_args == b.is_var_args and
-                a.is_generic == b.is_generic and
                 a.is_noinline == b.is_noinline and
                 std.meta.eql(a.cc, b.cc);
         }
@@ -2287,7 +2302,6 @@ pub const Key = union(enum) {
             std.hash.autoHash(hasher, self.noalias_bits);
             std.hash.autoHash(hasher, self.cc);
             std.hash.autoHash(hasher, self.is_var_args);
-            std.hash.autoHash(hasher, self.is_generic);
             std.hash.autoHash(hasher, self.is_noinline);
         }
     };
@@ -2471,8 +2485,6 @@ pub const Key = union(enum) {
             u64: u64,
             i64: i64,
             big_int: BigIntConst,
-            lazy_align: Index,
-            lazy_size: Index,
 
             /// Big enough to fit any non-BigInt value
             pub const BigIntSpace = struct {
@@ -2485,7 +2497,6 @@ pub const Key = union(enum) {
                 return switch (storage) {
                     .big_int => |x| x,
                     inline .u64, .i64 => |x| BigIntMutable.init(&space.limbs, x).toConst(),
-                    .lazy_align, .lazy_size => unreachable,
                 };
             }
         };
@@ -2734,6 +2745,7 @@ pub const Key = union(enum) {
                 switch (namespace_type) {
                     .declared => |declared| {
                         std.hash.autoHash(&hasher, declared.zir_index);
+                        std.hash.autoHash(&hasher, declared.arg_ty);
                         const captures = switch (declared.captures) {
                             .owned => |cvs| cvs.get(ip),
                             .external => |cvs| cvs,
@@ -2742,13 +2754,13 @@ pub const Key = union(enum) {
                             std.hash.autoHash(&hasher, cv);
                         }
                     },
-                    .generated_tag => |generated_tag| {
-                        std.hash.autoHash(&hasher, generated_tag.union_type);
-                    },
                     .reified => |reified| {
                         std.hash.autoHash(&hasher, reified.zir_index);
                         std.hash.autoHash(&hasher, reified.type_hash);
                     },
+                    .generated_union_tag => |union_type| {
+                        std.hash.autoHash(&hasher, union_type);
+                    },
                 }
                 return hasher.final();
             },
@@ -2756,23 +2768,12 @@ pub const Key = union(enum) {
             .int => |int| {
                 var hasher = Hash.init(seed);
                 // Canonicalize all integers by converting them to BigIntConst.
-                switch (int.storage) {
-                    .u64, .i64, .big_int => {
-                        var buffer: Key.Int.Storage.BigIntSpace = undefined;
-                        const big_int = int.storage.toBigInt(&buffer);
+                var buffer: Key.Int.Storage.BigIntSpace = undefined;
+                const big_int = int.storage.toBigInt(&buffer);
 
-                        std.hash.autoHash(&hasher, int.ty);
-                        std.hash.autoHash(&hasher, big_int.positive);
-                        for (big_int.limbs) |limb| std.hash.autoHash(&hasher, limb);
-                    },
-                    .lazy_align, .lazy_size => |lazy_ty| {
-                        std.hash.autoHash(
-                            &hasher,
-                            @as(@typeInfo(Key.Int.Storage).@"union".tag_type.?, int.storage),
-                        );
-                        std.hash.autoHash(&hasher, lazy_ty);
-                    },
-                }
+                std.hash.autoHash(&hasher, int.ty);
+                std.hash.autoHash(&hasher, big_int.positive);
+                for (big_int.limbs) |limb| std.hash.autoHash(&hasher, limb);
                 return hasher.final();
             },
 
@@ -3102,27 +3103,16 @@ pub const Key = union(enum) {
                         .u64 => |bb| aa == bb,
                         .i64 => |bb| aa == bb,
                         .big_int => |bb| bb.orderAgainstScalar(aa) == .eq,
-                        .lazy_align, .lazy_size => false,
                     },
                     .i64 => |aa| switch (b_info.storage) {
                         .u64 => |bb| aa == bb,
                         .i64 => |bb| aa == bb,
                         .big_int => |bb| bb.orderAgainstScalar(aa) == .eq,
-                        .lazy_align, .lazy_size => false,
                     },
                     .big_int => |aa| switch (b_info.storage) {
                         .u64 => |bb| aa.orderAgainstScalar(bb) == .eq,
                         .i64 => |bb| aa.orderAgainstScalar(bb) == .eq,
                         .big_int => |bb| aa.eql(bb),
-                        .lazy_align, .lazy_size => false,
-                    },
-                    .lazy_align => |aa| switch (b_info.storage) {
-                        .u64, .i64, .big_int, .lazy_size => false,
-                        .lazy_align => |bb| aa == bb,
-                    },
-                    .lazy_size => |aa| switch (b_info.storage) {
-                        .u64, .i64, .big_int, .lazy_align => false,
-                        .lazy_size => |bb| aa == bb,
                     },
                 };
             },
@@ -3165,6 +3155,7 @@ pub const Key = union(enum) {
                     .declared => |a_d| {
                         const b_d = b_info.declared;
                         if (a_d.zir_index != b_d.zir_index) return false;
+                        if (a_d.arg_ty != b_d.arg_ty) return false;
                         const a_captures = switch (a_d.captures) {
                             .owned => |s| s.get(ip),
                             .external => |cvs| cvs,
@@ -3175,12 +3166,12 @@ pub const Key = union(enum) {
                         };
                         return std.mem.eql(u32, @ptrCast(a_captures), @ptrCast(b_captures));
                     },
-                    .generated_tag => |a_gt| return a_gt.union_type == b_info.generated_tag.union_type,
                     .reified => |a_r| {
                         const b_r = b_info.reified;
                         return a_r.zir_index == b_r.zir_index and
                             a_r.type_hash == b_r.type_hash;
                     },
+                    .generated_union_tag => |a_union_ty| return a_union_ty == b_info.generated_union_tag,
                 }
             },
             .aggregate => |a_info| {
@@ -3313,374 +3304,40 @@ pub const Key = union(enum) {
     }
 };
 
-pub const RequiresComptime = enum(u2) { no, yes, unknown, wip };
-
-// Unlike `Tag.TypeUnion` which is an encoding, and `Key.UnionType` which is a
-// minimal hashmap key, this type is a convenience type that contains info
-// needed by semantic analysis.
-pub const LoadedUnionType = struct {
-    tid: Zcu.PerThread.Id,
-    /// The index of the `Tag.TypeUnion` payload.
-    extra_index: u32,
-    // TODO: the non-fqn will be needed by the new dwarf structure
-    /// The name of this union type.
-    name: NullTerminatedString,
-    /// Represents the declarations inside this union.
-    namespace: NamespaceIndex,
-    /// If this is a declared type with the `.parent` name strategy, this is the `Nav` it was named after.
-    /// Otherwise, this is `.none`.
-    name_nav: Nav.Index.Optional,
-    /// The enum tag type.
-    enum_tag_ty: Index,
-    /// List of field types in declaration order.
-    /// These are `none` until `status` is `have_field_types` or `have_layout`.
-    field_types: Index.Slice,
-    /// List of field alignments in declaration order.
-    /// `none` means the ABI alignment of the type.
-    /// If this slice has length 0 it means all elements are `none`.
-    field_aligns: Alignment.Slice,
-    /// Index of the union_decl or reify ZIR instruction.
-    zir_index: TrackedInst.Index,
-    captures: CaptureValue.Slice,
-
-    pub const RuntimeTag = enum(u2) {
-        none,
-        safety,
-        tagged,
-
-        pub fn hasTag(self: RuntimeTag) bool {
-            return switch (self) {
-                .none => false,
-                .tagged, .safety => true,
-            };
-        }
-    };
-
-    pub const Status = enum(u3) {
-        none,
-        field_types_wip,
-        have_field_types,
-        layout_wip,
-        have_layout,
-        fully_resolved_wip,
-        /// The types and all its fields have had their layout resolved.
-        /// Even through pointer, which `have_layout` does not ensure.
-        fully_resolved,
-
-        pub fn haveFieldTypes(status: Status) bool {
-            return switch (status) {
-                .none,
-                .field_types_wip,
-                => false,
-                .have_field_types,
-                .layout_wip,
-                .have_layout,
-                .fully_resolved_wip,
-                .fully_resolved,
-                => true,
-            };
-        }
-
-        pub fn haveLayout(status: Status) bool {
-            return switch (status) {
-                .none,
-                .field_types_wip,
-                .have_field_types,
-                .layout_wip,
-                => false,
-                .have_layout,
-                .fully_resolved_wip,
-                .fully_resolved,
-                => true,
-            };
-        }
-    };
-
-    pub fn loadTagType(self: LoadedUnionType, ip: *const InternPool) LoadedEnumType {
-        return ip.loadEnumType(self.enum_tag_ty);
-    }
-
-    /// Pointer to an enum type which is used for the tag of the union.
-    /// This type is created even for untagged unions, even when the memory
-    /// layout does not store the tag.
-    /// Whether zig chooses this type or the user specifies it, it is stored here.
-    /// This will be set to the null type until status is `have_field_types`.
-    /// This accessor is provided so that the tag type can be mutated, and so that
-    /// when it is mutated, the mutations are observed.
-    /// The returned pointer expires with any addition to the `InternPool`.
-    fn tagTypePtr(self: LoadedUnionType, ip: *const InternPool) *Index {
-        const extra = ip.getLocalShared(self.tid).extra.acquire();
-        const field_index = std.meta.fieldIndex(Tag.TypeUnion, "tag_ty").?;
-        return @ptrCast(&extra.view().items(.@"0")[self.extra_index + field_index]);
-    }
-
-    pub fn tagTypeUnordered(u: LoadedUnionType, ip: *const InternPool) Index {
-        return @atomicLoad(Index, u.tagTypePtr(ip), .unordered);
-    }
-
-    pub fn setTagType(u: LoadedUnionType, ip: *InternPool, io: Io, tag_type: Index) void {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        @atomicStore(Index, u.tagTypePtr(ip), tag_type, .release);
-    }
-
-    /// The returned pointer expires with any addition to the `InternPool`.
-    fn flagsPtr(self: LoadedUnionType, ip: *const InternPool) *Tag.TypeUnion.Flags {
-        const extra = ip.getLocalShared(self.tid).extra.acquire();
-        const field_index = std.meta.fieldIndex(Tag.TypeUnion, "flags").?;
-        return @ptrCast(&extra.view().items(.@"0")[self.extra_index + field_index]);
-    }
-
-    pub fn flagsUnordered(u: LoadedUnionType, ip: *const InternPool) Tag.TypeUnion.Flags {
-        return @atomicLoad(Tag.TypeUnion.Flags, u.flagsPtr(ip), .unordered);
-    }
-
-    pub fn setStatus(u: LoadedUnionType, ip: *InternPool, io: Io, status: Status) void {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.status = status;
-        @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn setStatusIfLayoutWip(u: LoadedUnionType, ip: *InternPool, io: Io, status: Status) void {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        if (flags.status == .layout_wip) flags.status = status;
-        @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn setAlignment(u: LoadedUnionType, ip: *InternPool, io: Io, alignment: Alignment) void {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.alignment = alignment;
-        @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn assumeRuntimeBitsIfFieldTypesWip(u: LoadedUnionType, ip: *InternPool, io: Io) bool {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer if (flags.status == .field_types_wip) {
-            flags.assumed_runtime_bits = true;
-            @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-        };
-        return flags.status == .field_types_wip;
-    }
-
-    pub fn requiresComptime(u: LoadedUnionType, ip: *const InternPool) RequiresComptime {
-        return u.flagsUnordered(ip).requires_comptime;
-    }
-
-    pub fn setRequiresComptimeWip(u: LoadedUnionType, ip: *InternPool, io: Io) RequiresComptime {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer if (flags.requires_comptime == .unknown) {
-            flags.requires_comptime = .wip;
-            @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-        };
-        return flags.requires_comptime;
-    }
-
-    pub fn setRequiresComptime(u: LoadedUnionType, ip: *InternPool, io: Io, requires_comptime: RequiresComptime) void {
-        assert(requires_comptime != .wip); // see setRequiresComptimeWip
-
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.requires_comptime = requires_comptime;
-        @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn assumePointerAlignedIfFieldTypesWip(u: LoadedUnionType, ip: *InternPool, io: Io, ptr_align: Alignment) bool {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer if (flags.status == .field_types_wip) {
-            flags.alignment = ptr_align;
-            flags.assumed_pointer_aligned = true;
-            @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-        };
-        return flags.status == .field_types_wip;
-    }
-
-    /// The returned pointer expires with any addition to the `InternPool`.
-    fn sizePtr(self: LoadedUnionType, ip: *const InternPool) *u32 {
-        const extra = ip.getLocalShared(self.tid).extra.acquire();
-        const field_index = std.meta.fieldIndex(Tag.TypeUnion, "size").?;
-        return &extra.view().items(.@"0")[self.extra_index + field_index];
-    }
-
-    pub fn sizeUnordered(u: LoadedUnionType, ip: *const InternPool) u32 {
-        return @atomicLoad(u32, u.sizePtr(ip), .unordered);
-    }
-
-    /// The returned pointer expires with any addition to the `InternPool`.
-    fn paddingPtr(self: LoadedUnionType, ip: *const InternPool) *u32 {
-        const extra = ip.getLocalShared(self.tid).extra.acquire();
-        const field_index = std.meta.fieldIndex(Tag.TypeUnion, "padding").?;
-        return &extra.view().items(.@"0")[self.extra_index + field_index];
-    }
-
-    pub fn paddingUnordered(u: LoadedUnionType, ip: *const InternPool) u32 {
-        return @atomicLoad(u32, u.paddingPtr(ip), .unordered);
-    }
-
-    pub fn hasTag(self: LoadedUnionType, ip: *const InternPool) bool {
-        return self.flagsUnordered(ip).runtime_tag.hasTag();
-    }
-
-    pub fn haveFieldTypes(self: LoadedUnionType, ip: *const InternPool) bool {
-        return self.flagsUnordered(ip).status.haveFieldTypes();
-    }
-
-    pub fn haveLayout(self: LoadedUnionType, ip: *const InternPool) bool {
-        return self.flagsUnordered(ip).status.haveLayout();
-    }
-
-    pub fn setHaveLayout(u: LoadedUnionType, ip: *InternPool, io: Io, size: u32, padding: u32, alignment: Alignment) void {
-        const extra_mutex = &ip.getLocal(u.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        @atomicStore(u32, u.sizePtr(ip), size, .unordered);
-        @atomicStore(u32, u.paddingPtr(ip), padding, .unordered);
-        const flags_ptr = u.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.alignment = alignment;
-        flags.status = .have_layout;
-        @atomicStore(Tag.TypeUnion.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn fieldAlign(self: LoadedUnionType, ip: *const InternPool, field_index: usize) Alignment {
-        if (self.field_aligns.len == 0) return .none;
-        return self.field_aligns.get(ip)[field_index];
-    }
-
-    /// This does not mutate the field of LoadedUnionType.
-    pub fn setZirIndex(self: LoadedUnionType, ip: *InternPool, new_zir_index: TrackedInst.Index.Optional) void {
-        const flags_field_index = std.meta.fieldIndex(Tag.TypeUnion, "flags").?;
-        const zir_index_field_index = std.meta.fieldIndex(Tag.TypeUnion, "zir_index").?;
-        const ptr: *TrackedInst.Index.Optional =
-            @ptrCast(&ip.extra_.items[self.flags_index - flags_field_index + zir_index_field_index]);
-        ptr.* = new_zir_index;
-    }
-
-    pub fn setFieldTypes(self: LoadedUnionType, ip: *const InternPool, types: []const Index) void {
-        @memcpy(self.field_types.get(ip), types);
-    }
-
-    pub fn setFieldAligns(self: LoadedUnionType, ip: *const InternPool, aligns: []const Alignment) void {
-        if (aligns.len == 0) return;
-        assert(self.flagsUnordered(ip).any_aligned_fields);
-        @memcpy(self.field_aligns.get(ip), aligns);
-    }
-};
-
-pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
-    const unwrapped_index = index.unwrap(ip);
-    const extra_list = unwrapped_index.getExtra(ip);
-    const data = unwrapped_index.getData(ip);
-    const type_union = extraDataTrail(extra_list, Tag.TypeUnion, data);
-    const fields_len = type_union.data.fields_len;
-
-    var extra_index = type_union.end;
-    const captures_len = if (type_union.data.flags.any_captures) c: {
-        const len = extra_list.view().items(.@"0")[extra_index];
-        extra_index += 1;
-        break :c len;
-    } else 0;
-
-    const captures: CaptureValue.Slice = .{
-        .tid = unwrapped_index.tid,
-        .start = extra_index,
-        .len = captures_len,
-    };
-    extra_index += captures_len;
-    if (type_union.data.flags.is_reified) {
-        extra_index += 2; // PackedU64
-    }
-
-    const field_types: Index.Slice = .{
-        .tid = unwrapped_index.tid,
-        .start = extra_index,
-        .len = fields_len,
-    };
-    extra_index += fields_len;
-
-    const field_aligns = if (type_union.data.flags.any_aligned_fields) a: {
-        const a: Alignment.Slice = .{
-            .tid = unwrapped_index.tid,
-            .start = extra_index,
-            .len = fields_len,
-        };
-        extra_index += std.math.divCeil(u32, fields_len, 4) catch unreachable;
-        break :a a;
-    } else Alignment.Slice.empty;
-
-    return .{
-        .tid = unwrapped_index.tid,
-        .extra_index = data,
-        .name = type_union.data.name,
-        .name_nav = type_union.data.name_nav,
-        .namespace = type_union.data.namespace,
-        .enum_tag_ty = type_union.data.tag_ty,
-        .field_types = field_types,
-        .field_aligns = field_aligns,
-        .zir_index = type_union.data.zir_index,
-        .captures = captures,
-    };
-}
-
 pub const LoadedStructType = struct {
-    tid: Zcu.PerThread.Id,
-    /// The index of the `Tag.TypeStruct` or `Tag.TypeStructPacked` payload.
-    extra_index: u32,
+    /// Index of the `struct_decl` or `reify` ZIR instruction.
+    zir_index: TrackedInst.Index,
+    captures: CaptureValue.Slice,
+
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this struct type.
     name: NullTerminatedString,
-    namespace: NamespaceIndex,
     /// If this is a declared type with the `.parent` name strategy, this is the `Nav` it was named after.
     /// Otherwise, or if this is a file's root struct type, this is `.none`.
     name_nav: Nav.Index.Optional,
-    /// Index of the `struct_decl` or `reify` ZIR instruction.
-    zir_index: TrackedInst.Index,
+    namespace: NamespaceIndex,
+
     layout: std.builtin.Type.ContainerLayout,
+    /// May be `undefined` if `layout != .@"packed"`.
+    packed_backing_mode: PackedBackingMode,
+    /// May be `undefined` if `layout != .@"packed",
+    packed_backing_int_type: Index,
+
+    field_name_map: MapIndex,
     field_names: NullTerminatedString.Slice,
     field_types: Index.Slice,
-    field_inits: Index.Slice,
+    field_defaults: Index.Slice,
     field_aligns: Alignment.Slice,
-    runtime_order: RuntimeOrder.Slice,
-    comptime_bits: ComptimeBits,
-    offsets: Offsets,
-    names_map: OptionalMapIndex,
-    captures: CaptureValue.Slice,
+    field_is_comptime_bits: ComptimeBits,
+    field_runtime_order: RuntimeOrder.Slice,
+    field_offsets: Offsets,
+
+    // These fields are only valid once the layout is resolved, and are never valid for `layout == .@"packed"`.
+    has_no_possible_value: bool,
+    has_one_possible_value: bool,
+    comptime_only: bool,
+    size: u32,
+    alignment: Alignment,
 
     pub const ComptimeBits = struct {
         tid: Zcu.PerThread.Id,
@@ -3690,22 +3347,14 @@ pub const LoadedStructType = struct {
 
         pub const empty: ComptimeBits = .{ .tid = .main, .start = 0, .len = 0 };
 
-        pub fn get(this: ComptimeBits, ip: *const InternPool) []u32 {
+        pub fn getAll(this: ComptimeBits, ip: *const InternPool) []u32 {
             const extra = ip.getLocalShared(this.tid).extra.acquire();
             return extra.view().items(.@"0")[this.start..][0..this.len];
         }
 
-        pub fn getBit(this: ComptimeBits, ip: *const InternPool, i: usize) bool {
+        pub fn get(this: ComptimeBits, ip: *const InternPool, i: usize) bool {
             if (this.len == 0) return false;
-            return @as(u1, @truncate(this.get(ip)[i / 32] >> @intCast(i % 32))) != 0;
-        }
-
-        pub fn setBit(this: ComptimeBits, ip: *const InternPool, i: usize) void {
-            this.get(ip)[i / 32] |= @as(u32, 1) << @intCast(i % 32);
-        }
-
-        pub fn clearBit(this: ComptimeBits, ip: *const InternPool, i: usize) void {
-            this.get(ip)[i / 32] &= ~(@as(u32, 1) << @intCast(i % 32));
+            return @as(u1, @truncate(this.getAll(ip)[i / 32] >> @intCast(i % 32))) != 0;
         }
     };
 
@@ -3753,865 +3402,550 @@ pub const LoadedStructType = struct {
 
     /// Look up field index based on field name.
     pub fn nameIndex(s: LoadedStructType, ip: *const InternPool, name: NullTerminatedString) ?u32 {
-        const names_map = s.names_map.unwrap() orelse {
-            const i = name.toUnsigned(ip) orelse return null;
-            if (i >= s.field_types.len) return null;
-            return i;
-        };
-        const map = names_map.get(ip);
+        const map = s.field_name_map.get(ip);
         const adapter: NullTerminatedString.Adapter = .{ .strings = s.field_names.get(ip) };
         const field_index = map.getIndexAdapted(name, adapter) orelse return null;
         return @intCast(field_index);
     }
 
-    /// Returns the already-existing field with the same name, if any.
-    pub fn addFieldName(
-        s: LoadedStructType,
-        ip: *InternPool,
-        name: NullTerminatedString,
-    ) ?u32 {
-        const extra = ip.getLocalShared(s.tid).extra.acquire();
-        return ip.addFieldName(extra, s.names_map.unwrap().?, s.field_names.start, name);
-    }
-
-    pub fn fieldAlign(s: LoadedStructType, ip: *const InternPool, i: usize) Alignment {
-        if (s.field_aligns.len == 0) return .none;
-        return s.field_aligns.get(ip)[i];
-    }
-
-    pub fn fieldInit(s: LoadedStructType, ip: *const InternPool, i: usize) Index {
-        if (s.field_inits.len == 0) return .none;
-        assert(s.haveFieldInits(ip));
-        return s.field_inits.get(ip)[i];
-    }
-
-    pub fn fieldName(s: LoadedStructType, ip: *const InternPool, i: usize) NullTerminatedString {
-        return s.field_names.get(ip)[i];
-    }
-
-    pub fn fieldIsComptime(s: LoadedStructType, ip: *const InternPool, i: usize) bool {
-        return s.comptime_bits.getBit(ip, i);
-    }
-
-    pub fn setFieldComptime(s: LoadedStructType, ip: *InternPool, i: usize) void {
-        s.comptime_bits.setBit(ip, i);
-    }
-
-    /// The returned pointer expires with any addition to the `InternPool`.
-    /// Asserts the struct is not packed.
-    fn flagsPtr(s: LoadedStructType, ip: *const InternPool) *Tag.TypeStruct.Flags {
-        assert(s.layout != .@"packed");
-        const extra = ip.getLocalShared(s.tid).extra.acquire();
-        const flags_field_index = std.meta.fieldIndex(Tag.TypeStruct, "flags").?;
-        return @ptrCast(&extra.view().items(.@"0")[s.extra_index + flags_field_index]);
-    }
-
-    pub fn flagsUnordered(s: LoadedStructType, ip: *const InternPool) Tag.TypeStruct.Flags {
-        return @atomicLoad(Tag.TypeStruct.Flags, s.flagsPtr(ip), .unordered);
-    }
-
-    /// The returned pointer expires with any addition to the `InternPool`.
-    /// Asserts that the struct is packed.
-    fn packedFlagsPtr(s: LoadedStructType, ip: *const InternPool) *Tag.TypeStructPacked.Flags {
-        assert(s.layout == .@"packed");
-        const extra = ip.getLocalShared(s.tid).extra.acquire();
-        const flags_field_index = std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?;
-        return @ptrCast(&extra.view().items(.@"0")[s.extra_index + flags_field_index]);
-    }
-
-    pub fn packedFlagsUnordered(s: LoadedStructType, ip: *const InternPool) Tag.TypeStructPacked.Flags {
-        return @atomicLoad(Tag.TypeStructPacked.Flags, s.packedFlagsPtr(ip), .unordered);
-    }
-
-    /// Reads the non-opv flag calculated during AstGen. Used to short-circuit more
-    /// complicated logic.
-    pub fn knownNonOpv(s: LoadedStructType, ip: *const InternPool) bool {
-        return switch (s.layout) {
-            .@"packed" => false,
-            .auto, .@"extern" => s.flagsUnordered(ip).known_non_opv,
-        };
-    }
-
-    pub fn requiresComptime(s: LoadedStructType, ip: *const InternPool) RequiresComptime {
-        return s.flagsUnordered(ip).requires_comptime;
-    }
-
-    pub fn setRequiresComptimeWip(s: LoadedStructType, ip: *InternPool, io: Io) RequiresComptime {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer if (flags.requires_comptime == .unknown) {
-            flags.requires_comptime = .wip;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        };
-        return flags.requires_comptime;
-    }
-
-    pub fn setRequiresComptime(s: LoadedStructType, ip: *InternPool, io: Io, requires_comptime: RequiresComptime) void {
-        assert(requires_comptime != .wip); // see setRequiresComptimeWip
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.requires_comptime = requires_comptime;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn assumeRuntimeBitsIfFieldTypesWip(s: LoadedStructType, ip: *InternPool, io: Io) bool {
-        if (s.layout == .@"packed") return false;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer if (flags.field_types_wip) {
-            flags.assumed_runtime_bits = true;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        };
-        return flags.field_types_wip;
-    }
-
-    pub fn setFieldTypesWip(s: LoadedStructType, ip: *InternPool, io: Io) bool {
-        if (s.layout == .@"packed") return false;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer {
-            flags.field_types_wip = true;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        }
-        return flags.field_types_wip;
-    }
-
-    pub fn clearFieldTypesWip(s: LoadedStructType, ip: *InternPool, io: Io) void {
-        if (s.layout == .@"packed") return;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.field_types_wip = false;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn setLayoutWip(s: LoadedStructType, ip: *InternPool, io: Io) bool {
-        if (s.layout == .@"packed") return false;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer {
-            flags.layout_wip = true;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        }
-        return flags.layout_wip;
-    }
-
-    pub fn clearLayoutWip(s: LoadedStructType, ip: *InternPool, io: Io) void {
-        if (s.layout == .@"packed") return;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.layout_wip = false;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn setAlignment(s: LoadedStructType, ip: *InternPool, io: Io, alignment: Alignment) void {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.alignment = alignment;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn assumePointerAlignedIfFieldTypesWip(s: LoadedStructType, ip: *InternPool, io: Io, ptr_align: Alignment) bool {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer if (flags.field_types_wip) {
-            flags.alignment = ptr_align;
-            flags.assumed_pointer_aligned = true;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        };
-        return flags.field_types_wip;
-    }
-
-    pub fn assumePointerAlignedIfWip(s: LoadedStructType, ip: *InternPool, io: Io, ptr_align: Alignment) bool {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer {
-            if (flags.alignment_wip) {
-                flags.alignment = ptr_align;
-                flags.assumed_pointer_aligned = true;
-            } else flags.alignment_wip = true;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        }
-        return flags.alignment_wip;
-    }
-
-    pub fn clearAlignmentWip(s: LoadedStructType, ip: *InternPool, io: Io) void {
-        if (s.layout == .@"packed") return;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.alignment_wip = false;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn setInitsWip(s: LoadedStructType, ip: *InternPool, io: Io) bool {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        switch (s.layout) {
-            .@"packed" => {
-                const flags_ptr = s.packedFlagsPtr(ip);
-                var flags = flags_ptr.*;
-                defer {
-                    flags.field_inits_wip = true;
-                    @atomicStore(Tag.TypeStructPacked.Flags, flags_ptr, flags, .release);
-                }
-                return flags.field_inits_wip;
-            },
-            .auto, .@"extern" => {
-                const flags_ptr = s.flagsPtr(ip);
-                var flags = flags_ptr.*;
-                defer {
-                    flags.field_inits_wip = true;
-                    @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-                }
-                return flags.field_inits_wip;
-            },
-        }
-    }
-
-    pub fn clearInitsWip(s: LoadedStructType, ip: *InternPool, io: Io) void {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        switch (s.layout) {
-            .@"packed" => {
-                const flags_ptr = s.packedFlagsPtr(ip);
-                var flags = flags_ptr.*;
-                flags.field_inits_wip = false;
-                @atomicStore(Tag.TypeStructPacked.Flags, flags_ptr, flags, .release);
-            },
-            .auto, .@"extern" => {
-                const flags_ptr = s.flagsPtr(ip);
-                var flags = flags_ptr.*;
-                flags.field_inits_wip = false;
-                @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-            },
-        }
-    }
-
-    pub fn setFullyResolved(s: LoadedStructType, ip: *InternPool, io: Io) bool {
-        if (s.layout == .@"packed") return true;
-
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        defer {
-            flags.fully_resolved = true;
-            @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-        }
-        return flags.fully_resolved;
-    }
-
-    pub fn clearFullyResolved(s: LoadedStructType, ip: *InternPool, io: Io) void {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.fully_resolved = false;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    /// The returned pointer expires with any addition to the `InternPool`.
-    /// Asserts the struct is not packed.
-    fn sizePtr(s: LoadedStructType, ip: *const InternPool) *u32 {
-        assert(s.layout != .@"packed");
-        const extra = ip.getLocalShared(s.tid).extra.acquire();
-        const size_field_index = std.meta.fieldIndex(Tag.TypeStruct, "size").?;
-        return @ptrCast(&extra.view().items(.@"0")[s.extra_index + size_field_index]);
-    }
-
-    pub fn sizeUnordered(s: LoadedStructType, ip: *const InternPool) u32 {
-        return @atomicLoad(u32, s.sizePtr(ip), .unordered);
-    }
-
-    /// The backing integer type of the packed struct. Whether zig chooses
-    /// this type or the user specifies it, it is stored here. This will be
-    /// set to `none` until the layout is resolved.
-    /// Asserts the struct is packed.
-    fn backingIntTypePtr(s: LoadedStructType, ip: *const InternPool) *Index {
-        assert(s.layout == .@"packed");
-        const extra = ip.getLocalShared(s.tid).extra.acquire();
-        const field_index = std.meta.fieldIndex(Tag.TypeStructPacked, "backing_int_ty").?;
-        return @ptrCast(&extra.view().items(.@"0")[s.extra_index + field_index]);
-    }
-
-    pub fn backingIntTypeUnordered(s: LoadedStructType, ip: *const InternPool) Index {
-        return @atomicLoad(Index, s.backingIntTypePtr(ip), .unordered);
-    }
-
-    pub fn setBackingIntType(s: LoadedStructType, ip: *InternPool, io: Io, backing_int_ty: Index) void {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        @atomicStore(Index, s.backingIntTypePtr(ip), backing_int_ty, .release);
-    }
-
-    /// Asserts the struct is not packed.
-    pub fn setZirIndex(s: LoadedStructType, ip: *InternPool, new_zir_index: TrackedInst.Index.Optional) void {
-        assert(s.layout != .@"packed");
-        const field_index = std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?;
-        ip.extra_.items[s.extra_index + field_index] = @intFromEnum(new_zir_index);
-    }
-
-    pub fn haveFieldTypes(s: LoadedStructType, ip: *const InternPool) bool {
-        const types = s.field_types.get(ip);
-        return types.len == 0 or types[types.len - 1] != .none;
-    }
-
-    pub fn haveFieldInits(s: LoadedStructType, ip: *const InternPool) bool {
-        return switch (s.layout) {
-            .@"packed" => s.packedFlagsUnordered(ip).inits_resolved,
-            .auto, .@"extern" => s.flagsUnordered(ip).inits_resolved,
-        };
-    }
-
-    pub fn setHaveFieldInits(s: LoadedStructType, ip: *InternPool, io: Io) void {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        switch (s.layout) {
-            .@"packed" => {
-                const flags_ptr = s.packedFlagsPtr(ip);
-                var flags = flags_ptr.*;
-                flags.inits_resolved = true;
-                @atomicStore(Tag.TypeStructPacked.Flags, flags_ptr, flags, .release);
-            },
-            .auto, .@"extern" => {
-                const flags_ptr = s.flagsPtr(ip);
-                var flags = flags_ptr.*;
-                flags.inits_resolved = true;
-                @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-            },
-        }
-    }
-
-    pub fn haveLayout(s: LoadedStructType, ip: *const InternPool) bool {
-        return switch (s.layout) {
-            .@"packed" => s.backingIntTypeUnordered(ip) != .none,
-            .auto, .@"extern" => s.flagsUnordered(ip).layout_resolved,
-        };
-    }
-
-    pub fn setLayoutResolved(s: LoadedStructType, ip: *InternPool, io: Io, size: u32, alignment: Alignment) void {
-        const extra_mutex = &ip.getLocal(s.tid).mutate.extra.mutex;
-        extra_mutex.lockUncancelable(io);
-        defer extra_mutex.unlock(io);
-
-        @atomicStore(u32, s.sizePtr(ip), size, .unordered);
-        const flags_ptr = s.flagsPtr(ip);
-        var flags = flags_ptr.*;
-        flags.alignment = alignment;
-        flags.layout_resolved = true;
-        @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
-    }
-
-    pub fn hasReorderedFields(s: LoadedStructType) bool {
-        return s.layout == .auto;
-    }
-
-    pub const RuntimeOrderIterator = struct {
-        ip: *InternPool,
-        field_index: u32,
-        struct_type: InternPool.LoadedStructType,
-
-        pub fn next(it: *@This()) ?u32 {
-            var i = it.field_index;
-
-            if (i >= it.struct_type.field_types.len)
-                return null;
-
-            if (it.struct_type.hasReorderedFields()) {
-                it.field_index += 1;
-                return it.struct_type.runtime_order.get(it.ip)[i].toInt();
-            }
-
-            while (it.struct_type.fieldIsComptime(it.ip, i)) {
-                i += 1;
-                if (i >= it.struct_type.field_types.len)
-                    return null;
-            }
-
-            it.field_index = i + 1;
-            return i;
-        }
-    };
-
     /// Iterates over non-comptime fields in the order they are laid out in memory at runtime.
     /// May or may not include zero-bit fields.
     /// Asserts the struct is not packed.
-    pub fn iterateRuntimeOrder(s: LoadedStructType, ip: *InternPool) RuntimeOrderIterator {
-        assert(s.layout != .@"packed");
-        return .{
-            .ip = ip,
-            .field_index = 0,
-            .struct_type = s,
-        };
+    pub fn iterateRuntimeOrder(s: *const LoadedStructType, ip: *InternPool) RuntimeOrderIterator {
+        switch (s.layout) {
+            .auto => {
+                const ro = std.mem.sliceTo(s.field_runtime_order.get(ip), .omitted);
+                return .{
+                    .runtime_order = ro,
+                    .fields_len = @intCast(ro.len),
+                    .next_index = 0,
+                };
+            },
+            .@"extern" => return .{
+                .runtime_order = null,
+                .fields_len = s.field_names.len,
+                .next_index = 0,
+            },
+            .@"packed" => unreachable,
+        }
     }
+    pub const RuntimeOrderIterator = struct {
+        runtime_order: ?[]const RuntimeOrder,
+        fields_len: u32,
+        next_index: u32,
+        pub fn next(it: *RuntimeOrderIterator) ?u32 {
+            const i = it.next_index;
+            if (i == it.fields_len) return null;
+            it.next_index = i + 1;
+            const ro = it.runtime_order orelse return i;
+            return ro[i].toInt().?;
+        }
+    };
 
+    pub fn iterateRuntimeOrderReverse(s: *const LoadedStructType, ip: *InternPool) ReverseRuntimeOrderIterator {
+        switch (s.layout) {
+            .auto => {
+                const ro = std.mem.sliceTo(s.field_runtime_order.get(ip), .omitted);
+                return .{
+                    .runtime_order = ro,
+                    .last_index = @intCast(ro.len),
+                };
+            },
+            .@"extern" => return .{
+                .runtime_order = null,
+                .last_index = s.field_names.len,
+            },
+            .@"packed" => unreachable,
+        }
+    }
     pub const ReverseRuntimeOrderIterator = struct {
-        ip: *InternPool,
+        runtime_order: ?[]const RuntimeOrder,
         last_index: u32,
-        struct_type: InternPool.LoadedStructType,
-
-        pub fn next(it: *@This()) ?u32 {
-            if (it.last_index == 0)
-                return null;
-
-            if (it.struct_type.hasReorderedFields()) {
-                it.last_index -= 1;
-                const order = it.struct_type.runtime_order.get(it.ip);
-                while (order[it.last_index] == .omitted) {
-                    it.last_index -= 1;
-                    if (it.last_index == 0)
-                        return null;
-                }
-                return order[it.last_index].toInt();
-            }
-
-            it.last_index -= 1;
-            while (it.struct_type.fieldIsComptime(it.ip, it.last_index)) {
-                it.last_index -= 1;
-                if (it.last_index == 0)
-                    return null;
-            }
-
-            return it.last_index;
+        pub fn next(it: *ReverseRuntimeOrderIterator) ?u32 {
+            if (it.last_index == 0) return null;
+            const i = it.last_index - 1;
+            it.last_index = i;
+            const ro = it.runtime_order orelse return i;
+            return ro[i].toInt().?;
         }
     };
-
-    pub fn iterateRuntimeOrderReverse(s: LoadedStructType, ip: *InternPool) ReverseRuntimeOrderIterator {
-        assert(s.layout != .@"packed");
-        return .{
-            .ip = ip,
-            .last_index = s.field_types.len,
-            .struct_type = s,
-        };
-    }
 };
 
-pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
-    const unwrapped_index = index.unwrap(ip);
-    const extra_list = unwrapped_index.getExtra(ip);
-    const extra_items = extra_list.view().items(.@"0");
-    const item = unwrapped_index.getItem(ip);
-    switch (item.tag) {
-        .type_struct => {
-            const name: NullTerminatedString = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "name").?]);
-            const name_nav: Nav.Index.Optional = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "name_nav").?]);
-            const namespace: NamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?]);
-            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?]);
-            const fields_len = extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "fields_len").?];
-            const flags: Tag.TypeStruct.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?], .unordered));
-            var extra_index = item.data + @as(u32, @typeInfo(Tag.TypeStruct).@"struct".fields.len);
-            const captures_len = if (flags.any_captures) c: {
-                const len = extra_list.view().items(.@"0")[extra_index];
-                extra_index += 1;
-                break :c len;
-            } else 0;
-            const captures: CaptureValue.Slice = .{
-                .tid = unwrapped_index.tid,
-                .start = extra_index,
-                .len = captures_len,
-            };
-            extra_index += captures_len;
-            if (flags.is_reified) {
-                extra_index += 2; // type_hash: PackedU64
-            }
-            const field_types: Index.Slice = .{
-                .tid = unwrapped_index.tid,
-                .start = extra_index,
-                .len = fields_len,
-            };
-            extra_index += fields_len;
-            const names_map: OptionalMapIndex, const names = n: {
-                const names_map: OptionalMapIndex = @enumFromInt(extra_list.view().items(.@"0")[extra_index]);
-                extra_index += 1;
-                const names: NullTerminatedString.Slice = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = fields_len,
-                };
-                extra_index += fields_len;
-                break :n .{ names_map, names };
-            };
-            const inits: Index.Slice = if (flags.any_default_inits) i: {
-                const inits: Index.Slice = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = fields_len,
-                };
-                extra_index += fields_len;
-                break :i inits;
-            } else Index.Slice.empty;
-            const aligns: Alignment.Slice = if (flags.any_aligned_fields) a: {
-                const a: Alignment.Slice = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = fields_len,
-                };
-                extra_index += std.math.divCeil(u32, fields_len, 4) catch unreachable;
-                break :a a;
-            } else Alignment.Slice.empty;
-            const comptime_bits: LoadedStructType.ComptimeBits = if (flags.any_comptime_fields) c: {
-                const len = std.math.divCeil(u32, fields_len, 32) catch unreachable;
-                const c: LoadedStructType.ComptimeBits = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = len,
-                };
-                extra_index += len;
-                break :c c;
-            } else LoadedStructType.ComptimeBits.empty;
-            const runtime_order: LoadedStructType.RuntimeOrder.Slice = if (!flags.is_extern) ro: {
-                const ro: LoadedStructType.RuntimeOrder.Slice = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = fields_len,
-                };
-                extra_index += fields_len;
-                break :ro ro;
-            } else LoadedStructType.RuntimeOrder.Slice.empty;
-            const offsets: LoadedStructType.Offsets = o: {
-                const o: LoadedStructType.Offsets = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = fields_len,
-                };
-                extra_index += fields_len;
-                break :o o;
-            };
-            return .{
-                .tid = unwrapped_index.tid,
-                .extra_index = item.data,
-                .name = name,
-                .name_nav = name_nav,
-                .namespace = namespace,
-                .zir_index = zir_index,
-                .layout = if (flags.is_extern) .@"extern" else .auto,
-                .field_names = names,
-                .field_types = field_types,
-                .field_inits = inits,
-                .field_aligns = aligns,
-                .runtime_order = runtime_order,
-                .comptime_bits = comptime_bits,
-                .offsets = offsets,
-                .names_map = names_map,
-                .captures = captures,
-            };
-        },
-        .type_struct_packed, .type_struct_packed_inits => {
-            const name: NullTerminatedString = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "name").?]);
-            const name_nav: Nav.Index.Optional = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "name_nav").?]);
-            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "zir_index").?]);
-            const fields_len = extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "fields_len").?];
-            const namespace: NamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?]);
-            const names_map: MapIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "names_map").?]);
-            const flags: Tag.TypeStructPacked.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?], .unordered));
-            var extra_index = item.data + @as(u32, @typeInfo(Tag.TypeStructPacked).@"struct".fields.len);
-            const has_inits = item.tag == .type_struct_packed_inits;
-            const captures_len = if (flags.any_captures) c: {
-                const len = extra_list.view().items(.@"0")[extra_index];
-                extra_index += 1;
-                break :c len;
-            } else 0;
-            const captures: CaptureValue.Slice = .{
-                .tid = unwrapped_index.tid,
-                .start = extra_index,
-                .len = captures_len,
-            };
-            extra_index += captures_len;
-            if (flags.is_reified) {
-                extra_index += 2; // PackedU64
-            }
-            const field_types: Index.Slice = .{
-                .tid = unwrapped_index.tid,
-                .start = extra_index,
-                .len = fields_len,
-            };
-            extra_index += fields_len;
-            const field_names: NullTerminatedString.Slice = .{
-                .tid = unwrapped_index.tid,
-                .start = extra_index,
-                .len = fields_len,
-            };
-            extra_index += fields_len;
-            const field_inits: Index.Slice = if (has_inits) inits: {
-                const i: Index.Slice = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = fields_len,
-                };
-                extra_index += fields_len;
-                break :inits i;
-            } else Index.Slice.empty;
-            return .{
-                .tid = unwrapped_index.tid,
-                .extra_index = item.data,
-                .name = name,
-                .name_nav = name_nav,
-                .namespace = namespace,
-                .zir_index = zir_index,
-                .layout = .@"packed",
-                .field_names = field_names,
-                .field_types = field_types,
-                .field_inits = field_inits,
-                .field_aligns = Alignment.Slice.empty,
-                .runtime_order = LoadedStructType.RuntimeOrder.Slice.empty,
-                .comptime_bits = LoadedStructType.ComptimeBits.empty,
-                .offsets = LoadedStructType.Offsets.empty,
-                .names_map = names_map.toOptional(),
-                .captures = captures,
-            };
-        },
-        else => unreachable,
-    }
-}
+/// Unlike `Tag.TypeUnion` which is an encoding, and `Key.UnionType` which is a
+/// minimal hashmap key, this type is a convenience type that contains info
+/// needed by semantic analysis.
+pub const LoadedUnionType = struct {
+    /// Index of the `union_decl` or `reify` ZIR instruction.
+    zir_index: TrackedInst.Index,
+    captures: CaptureValue.Slice,
+
+    // TODO: the non-fqn will be needed by the new dwarf structure
+    /// The name of this union type.
+    name: NullTerminatedString,
+    /// If this is a declared type with the `.parent` name strategy, this is the `Nav` it was named after.
+    /// Otherwise, this is `.none`.
+    name_nav: Nav.Index.Optional,
+    namespace: NamespaceIndex,
+
+    layout: std.builtin.Type.ContainerLayout,
+    runtime_tag: RuntimeTag,
+    /// Even if `runtime_tag == .none`, this is populated with the union's "hypothetical" tag type.
+    enum_tag_type: Index,
+    /// May be `undefined` if `layout != .@"packed"`.
+    packed_backing_mode: PackedBackingMode,
+    /// May be `undefined` if `layout != .@"packed",
+    packed_backing_int_type: Index,
+
+    // Field names are not stored here, because fields are guaranteed to map one-to-one to the
+    // fields of the enum tag type. If you need field names, load them from `enum_tag_type`.
+    field_types: Index.Slice,
+    field_aligns: Alignment.Slice,
+
+    // These fields are only valid once the layout is resolved, and are never valid for `layout == .@"packed"`.
+    has_no_possible_value: bool,
+    has_one_possible_value: bool,
+    comptime_only: bool,
+    size: u32,
+    padding: u32,
+    alignment: Alignment,
+
+    pub const RuntimeTag = enum(u2) {
+        none,
+        safety,
+        tagged,
+    };
+};
 
 pub const LoadedEnumType = struct {
+    /// This is `none` iff this is a generated tag type.
+    /// Otherwise, index of the `enum_decl` or `reify` ZIR instruction.
+    zir_index: TrackedInst.Index.Optional,
+    captures: CaptureValue.Slice,
+    /// If `zir_index` is `.none`, this is the union type for which this enum is the tag type.
+    owner_union: Index,
+
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this enum type.
     name: NullTerminatedString,
-    /// Represents the declarations inside this enum.
-    namespace: NamespaceIndex,
     /// If this is a declared type with the `.parent` name strategy, this is the `Nav` it was named after.
     /// Otherwise, this is `.none`.
     name_nav: Nav.Index.Optional,
-    /// An integer type which is used for the numerical value of the enum.
-    /// This field is present regardless of whether the enum has an
-    /// explicitly provided tag type or auto-numbered.
-    tag_ty: Index,
-    /// Set of field names in declaration order.
-    names: NullTerminatedString.Slice,
-    /// Maps integer tag value to field index.
-    /// Entries are in declaration order, same as `fields`.
-    /// If this is empty, it means the enum tags are auto-numbered.
-    values: Index.Slice,
-    tag_mode: TagMode,
-    names_map: MapIndex,
-    /// This is guaranteed to not be `.none` if explicit values are provided.
-    values_map: OptionalMapIndex,
-    /// This is `none` only if this is a generated tag type.
-    zir_index: TrackedInst.Index.Optional,
-    captures: CaptureValue.Slice,
+    namespace: NamespaceIndex,
 
-    pub const TagMode = enum {
-        /// The integer tag type was auto-numbered by zig.
-        auto,
-        /// The integer tag type was provided by the enum declaration, and the enum
-        /// is exhaustive.
-        explicit,
-        /// The integer tag type was provided by the enum declaration, and the enum
-        /// is non-exhaustive.
-        nonexhaustive,
-    };
+    /// An integer type which is used for the numerical value of the enum. Populated immediately, regardless
+    /// of whether the integer tag type was explicitly provided or inferred by the compiler.
+    int_tag_type: Index,
+    int_tag_is_explicit: bool,
+    nonexhaustive: bool,
+
+    /// Uses `NullTerminatedString.Adapter` with `field_names`.
+    field_name_map: MapIndex,
+    /// If this is `.none`, the enum tag type is auto-generated and so the fields are auto-numbered.
+    /// Otherwise, uses `Index.Adapter` with `field_values`.
+    field_value_map: OptionalMapIndex,
+    field_names: NullTerminatedString.Slice,
+    /// Empty if `field_value_map` is `.none`.
+    field_values: Index.Slice,
 
     /// Look up field index based on field name.
-    pub fn nameIndex(self: LoadedEnumType, ip: *const InternPool, name: NullTerminatedString) ?u32 {
-        const map = self.names_map.get(ip);
-        const adapter: NullTerminatedString.Adapter = .{ .strings = self.names.get(ip) };
+    pub fn nameIndex(e: LoadedEnumType, ip: *const InternPool, name: NullTerminatedString) ?u32 {
+        const map = e.field_name_map.get(ip);
+        const adapter: NullTerminatedString.Adapter = .{ .strings = e.field_names.get(ip) };
         const field_index = map.getIndexAdapted(name, adapter) orelse return null;
         return @intCast(field_index);
     }
 
-    /// Look up field index based on tag value.
-    /// Asserts that `values_map` is not `none`.
-    /// This function returns `null` when `tag_val` does not have the
-    /// integer tag type of the enum.
-    pub fn tagValueIndex(self: LoadedEnumType, ip: *const InternPool, tag_val: Index) ?u32 {
-        assert(tag_val != .none);
-        // TODO: we should probably decide a single interface for this function, but currently
-        // it's being called with both tag values and underlying ints. Fix this!
-        const int_tag_val = switch (ip.indexToKey(tag_val)) {
-            .enum_tag => |enum_tag| enum_tag.int,
-            .int => tag_val,
-            else => unreachable,
-        };
-        if (self.values_map.unwrap()) |values_map| {
-            const map = values_map.get(ip);
-            const adapter: Index.Adapter = .{ .indexes = self.values.get(ip) };
-            const field_index = map.getIndexAdapted(int_tag_val, adapter) orelse return null;
+    /// Look up field index based on integer tag value.
+    /// Asserts that the type of `tag_val` is `enum_obj.int_tag_type`.
+    /// Asserts that `tag_val` is not `undefined`.
+    pub fn tagValueIndex(e: LoadedEnumType, ip: *const InternPool, tag_val: Index) ?u32 {
+        assert(ip.typeOf(tag_val) == e.int_tag_type);
+        assert(ip.indexToKey(tag_val) == .int);
+        if (e.field_value_map.unwrap()) |field_value_map| {
+            const map = field_value_map.get(ip);
+            const adapter: Index.Adapter = .{ .indexes = e.field_values.get(ip) };
+            const field_index = map.getIndexAdapted(tag_val, adapter) orelse return null;
             return @intCast(field_index);
         }
-        // Auto-numbered enum. Convert `int_tag_val` to field index.
-        const field_index = switch (ip.indexToKey(int_tag_val).int.storage) {
+        // Auto-numbered enum, so convert `tag_val` to field index
+        const field_index = switch (ip.indexToKey(tag_val).int.storage) {
             inline .u64, .i64 => |x| std.math.cast(u32, x) orelse return null,
             .big_int => |x| x.toInt(u32) catch return null,
-            .lazy_align, .lazy_size => unreachable,
         };
-        return if (field_index < self.names.len) field_index else null;
+        return if (field_index < e.field_names.len) field_index else null;
     }
 };
 
-pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
-    const unwrapped_index = index.unwrap(ip);
-    const extra_list = unwrapped_index.getExtra(ip);
-    const item = unwrapped_index.getItem(ip);
-    const tag_mode: LoadedEnumType.TagMode = switch (item.tag) {
-        .type_enum_auto => {
-            const extra = extraDataTrail(extra_list, EnumAuto, item.data);
-            var extra_index: u32 = @intCast(extra.end);
-            if (extra.data.zir_index == .none) {
-                extra_index += 1; // owner_union
-            }
-            const captures_len = if (extra.data.captures_len == std.math.maxInt(u32)) c: {
-                extra_index += 2; // type_hash: PackedU64
-                break :c 0;
-            } else extra.data.captures_len;
-            return .{
-                .name = extra.data.name,
-                .name_nav = extra.data.name_nav,
-                .namespace = extra.data.namespace,
-                .tag_ty = extra.data.int_tag_type,
-                .names = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index + captures_len,
-                    .len = extra.data.fields_len,
-                },
-                .values = Index.Slice.empty,
-                .tag_mode = .auto,
-                .names_map = extra.data.names_map,
-                .values_map = .none,
-                .zir_index = extra.data.zir_index,
-                .captures = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra_index,
-                    .len = captures_len,
-                },
-            };
-        },
-        .type_enum_explicit => .explicit,
-        .type_enum_nonexhaustive => .nonexhaustive,
-        else => unreachable,
-    };
-    const extra = extraDataTrail(extra_list, EnumExplicit, item.data);
-    var extra_index: u32 = @intCast(extra.end);
-    if (extra.data.zir_index == .none) {
-        extra_index += 1; // owner_union
-    }
-    const captures_len = if (extra.data.captures_len == std.math.maxInt(u32)) c: {
-        extra_index += 2; // type_hash: PackedU64
-        break :c 0;
-    } else extra.data.captures_len;
-    return .{
-        .name = extra.data.name,
-        .name_nav = extra.data.name_nav,
-        .namespace = extra.data.namespace,
-        .tag_ty = extra.data.int_tag_type,
-        .names = .{
-            .tid = unwrapped_index.tid,
-            .start = extra_index + captures_len,
-            .len = extra.data.fields_len,
-        },
-        .values = .{
-            .tid = unwrapped_index.tid,
-            .start = extra_index + captures_len + extra.data.fields_len,
-            .len = if (extra.data.values_map != .none) extra.data.fields_len else 0,
-        },
-        .tag_mode = tag_mode,
-        .names_map = extra.data.names_map,
-        .values_map = extra.data.values_map,
-        .zir_index = extra.data.zir_index,
-        .captures = .{
-            .tid = unwrapped_index.tid,
-            .start = extra_index,
-            .len = captures_len,
-        },
-    };
-}
-
-/// Note that this type doubles as the payload for `Tag.type_opaque`.
 pub const LoadedOpaqueType = struct {
-    /// Contains the declarations inside this opaque.
-    namespace: NamespaceIndex,
+    /// Index of the `opaque_decl` instruction.
+    zir_index: TrackedInst.Index,
+    captures: CaptureValue.Slice,
+
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this opaque type.
     name: NullTerminatedString,
     /// If this is a declared type with the `.parent` name strategy, this is the `Nav` it was named after.
     /// Otherwise, this is `.none`.
     name_nav: Nav.Index.Optional,
-    /// Index of the `opaque_decl` or `reify` instruction.
-    zir_index: TrackedInst.Index,
-    captures: CaptureValue.Slice,
+    namespace: NamespaceIndex,
 };
 
+pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
+    const unwrapped_index = index.unwrap(ip);
+    const extra_list = unwrapped_index.getExtra(ip);
+    const extra_items = extra_list.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    // Exiting this `switch` means this is a `packed struct`.
+    const backing_mode: PackedBackingMode, const any_defaults: bool = switch (item.tag) {
+        .type_struct_packed_auto => .{ .auto, false },
+        .type_struct_packed_explicit => .{ .explicit, false },
+        .type_struct_packed_auto_defaults => .{ .auto, true },
+        .type_struct_packed_explicit_defaults => .{ .explicit, true },
+        .type_struct => {
+            const extra = extraDataTrail(extra_list, Tag.TypeStruct, item.data);
+            var extra_index = extra.end;
+            const captures: CaptureValue.Slice = switch (extra.data.flags.any_captures) {
+                .reified => captures: {
+                    extra_index += 2; // type_hash: PackedU64
+                    break :captures .empty;
+                },
+                .false => .empty,
+                .true => captures: {
+                    const len = extra_items[extra_index];
+                    extra_index += 1;
+                    break :captures .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra_index,
+                        .len = len,
+                    };
+                },
+            };
+            extra_index += captures.len;
+            const field_names: NullTerminatedString.Slice = .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            };
+            extra_index += field_names.len;
+            const field_types: Index.Slice = .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            };
+            extra_index += field_types.len;
+            const field_defaults: Index.Slice = if (extra.data.flags.any_field_defaults) .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            } else .empty;
+            extra_index += field_defaults.len;
+            const field_aligns: Alignment.Slice = if (extra.data.flags.any_field_aligns) .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            } else .empty;
+            extra_index += std.math.divCeil(u32, field_aligns.len, 4) catch unreachable;
+            const field_is_comptime_bits: LoadedStructType.ComptimeBits = if (extra.data.flags.any_comptime_fields) .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = std.math.divCeil(u32, extra.data.fields_len, 32) catch unreachable,
+            } else .empty;
+            extra_index += field_is_comptime_bits.len;
+            const field_runtime_order: LoadedStructType.RuntimeOrder.Slice = if (extra.data.flags.layout == .auto) .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            } else .empty;
+            extra_index += field_runtime_order.len;
+            const field_offsets: LoadedStructType.Offsets = .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            };
+            extra_index += field_offsets.len;
+
+            return .{
+                .zir_index = extra.data.zir_index,
+                .captures = captures,
+                .name = extra.data.name,
+                .name_nav = extra.data.name_nav,
+                .namespace = extra.data.namespace,
+                .layout = switch (extra.data.flags.layout) {
+                    .auto => .auto,
+                    .@"extern" => .@"extern",
+                },
+                .packed_backing_mode = undefined,
+                .packed_backing_int_type = undefined,
+                .field_name_map = extra.data.field_name_map,
+                .field_names = field_names,
+                .field_types = field_types,
+                .field_defaults = field_defaults,
+                .field_aligns = field_aligns,
+                .field_is_comptime_bits = field_is_comptime_bits,
+                .field_runtime_order = field_runtime_order,
+                .field_offsets = field_offsets,
+                .has_no_possible_value = extra.data.flags.has_no_possible_value,
+                .has_one_possible_value = extra.data.flags.has_one_possible_value,
+                .comptime_only = extra.data.flags.comptime_only,
+                .size = extra.data.size,
+                .alignment = extra.data.flags.alignment,
+            };
+        },
+        else => unreachable,
+    };
+    const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, item.data);
+    var extra_index = extra.end;
+    const captures: CaptureValue.Slice = switch (extra.data.captures_len) {
+        .reified => captures: {
+            extra_index += 2; // type_hash: PackedU64
+            break :captures .empty;
+        },
+        _ => .{
+            .tid = unwrapped_index.tid,
+            .start = extra_index,
+            .len = @intFromEnum(extra.data.captures_len),
+        },
+    };
+    extra_index += captures.len;
+    const field_names: NullTerminatedString.Slice = .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    };
+    extra_index += field_names.len;
+    const field_types: Index.Slice = .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    };
+    extra_index += field_types.len;
+    const field_defaults: Index.Slice = if (any_defaults) .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    } else .empty;
+    extra_index += field_defaults.len;
+    return .{
+        .zir_index = extra.data.zir_index,
+        .captures = captures,
+        .name = extra.data.name,
+        .name_nav = extra.data.name_nav,
+        .namespace = extra.data.namespace,
+        .layout = .@"packed",
+        .packed_backing_mode = backing_mode,
+        .packed_backing_int_type = extra.data.backing_int_type,
+        .field_name_map = extra.data.field_name_map,
+        .field_names = field_names,
+        .field_types = field_types,
+        .field_defaults = field_defaults,
+        .field_aligns = .empty,
+        .field_is_comptime_bits = .empty,
+        .field_runtime_order = .empty,
+        .field_offsets = .empty,
+        .has_no_possible_value = undefined,
+        .has_one_possible_value = undefined,
+        .comptime_only = undefined,
+        .size = undefined,
+        .alignment = undefined,
+    };
+}
+
+pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
+    const unwrapped_index = index.unwrap(ip);
+    const extra_list = unwrapped_index.getExtra(ip);
+    const extra_items = extra_list.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    // Exiting this `switch` means this is a `packed union`.
+    const backing_mode: PackedBackingMode = switch (item.tag) {
+        .type_union_packed_auto => .auto,
+        .type_union_packed_explicit => .explicit,
+        .type_union => {
+            const extra = extraDataTrail(extra_list, Tag.TypeUnion, item.data);
+            var extra_index = extra.end;
+            const captures: CaptureValue.Slice = switch (extra.data.flags.any_captures) {
+                .reified => captures: {
+                    extra_index += 2; // type_hash: PackedU64
+                    break :captures .empty;
+                },
+                .false => .empty,
+                .true => captures: {
+                    const len = extra_items[extra_index];
+                    extra_index += 1;
+                    break :captures .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra_index,
+                        .len = len,
+                    };
+                },
+            };
+            extra_index += captures.len;
+            const field_types: Index.Slice = .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            };
+            extra_index += field_types.len;
+            const field_aligns: Alignment.Slice = if (extra.data.flags.any_field_aligns) .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            } else .empty;
+            extra_index += std.math.divCeil(u32, field_aligns.len, 4) catch unreachable;
+
+            return .{
+                .zir_index = extra.data.zir_index,
+                .captures = captures,
+                .name = extra.data.name,
+                .name_nav = extra.data.name_nav,
+                .namespace = extra.data.namespace,
+                .layout = switch (extra.data.flags.layout) {
+                    .auto => .auto,
+                    .@"extern" => .@"extern",
+                },
+                .runtime_tag = extra.data.flags.runtime_tag,
+                .enum_tag_type = extra.data.enum_tag_type,
+                .packed_backing_mode = undefined,
+                .packed_backing_int_type = undefined,
+                .field_types = field_types,
+                .field_aligns = field_aligns,
+                .has_no_possible_value = extra.data.flags.has_no_possible_value,
+                .has_one_possible_value = extra.data.flags.has_one_possible_value,
+                .comptime_only = extra.data.flags.comptime_only,
+                .size = extra.data.size,
+                .padding = extra.data.padding,
+                .alignment = extra.data.flags.alignment,
+            };
+        },
+        else => unreachable,
+    };
+    const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, item.data);
+    var extra_index = extra.end;
+    const captures: CaptureValue.Slice = switch (extra.data.captures_len) {
+        .reified => captures: {
+            extra_index += 2; // type_hash: PackedU64
+            break :captures .empty;
+        },
+        _ => .{
+            .tid = unwrapped_index.tid,
+            .start = extra_index,
+            .len = @intFromEnum(extra.data.captures_len),
+        },
+    };
+    extra_index += captures.len;
+    const field_types: Index.Slice = .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    };
+    extra_index += field_types.len;
+    return .{
+        .zir_index = extra.data.zir_index,
+        .captures = captures,
+        .name = extra.data.name,
+        .name_nav = extra.data.name_nav,
+        .namespace = extra.data.namespace,
+        .layout = .@"packed",
+        .runtime_tag = .none,
+        .enum_tag_type = extra.data.enum_tag_type,
+        .packed_backing_mode = backing_mode,
+        .packed_backing_int_type = extra.data.backing_int_type,
+        .field_types = field_types,
+        .field_aligns = .empty,
+        .has_no_possible_value = undefined,
+        .has_one_possible_value = undefined,
+        .comptime_only = undefined,
+        .size = undefined,
+        .padding = undefined,
+        .alignment = undefined,
+    };
+}
+
+pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
+    const unwrapped_index = index.unwrap(ip);
+    const extra_list = unwrapped_index.getExtra(ip);
+    const extra_items = extra_list.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    const explicit_int_tag: bool, const nonexhaustive: bool = switch (item.tag) {
+        .type_enum_auto => .{ false, false },
+        .type_enum_explicit => .{ true, false },
+        .type_enum_nonexhaustive => .{ true, true },
+        else => unreachable,
+    };
+    const extra = extraDataTrail(extra_list, Tag.TypeEnum, item.data);
+    var extra_index: u32 = @intCast(extra.end);
+    const zir_index: TrackedInst.Index.Optional, const captures: CaptureValue.Slice, const owner_union: Index = switch (extra.data.captures_len) {
+        .reified => info: {
+            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[extra_index]);
+            extra_index += 1;
+            extra_index += 2; // type_hash: PackedU64
+            break :info .{ zir_index.toOptional(), .empty, .none };
+        },
+        .generated_union_tag => info: {
+            const owner_union: Index = @enumFromInt(extra_items[extra_index]);
+            extra_index += 1;
+            break :info .{ .none, .empty, owner_union };
+        },
+        _ => info: {
+            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[extra_index]);
+            extra_index += 1;
+            const captures: CaptureValue.Slice = .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = @intFromEnum(extra.data.captures_len),
+            };
+            extra_index += captures.len;
+            break :info .{ zir_index.toOptional(), captures, .none };
+        },
+    };
+    const field_value_map: OptionalMapIndex = if (explicit_int_tag) m: {
+        const map: MapIndex = @enumFromInt(extra_items[extra_index]);
+        extra_index += 1;
+        break :m map.toOptional();
+    } else .none;
+    const field_names: NullTerminatedString.Slice = .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    };
+    extra_index += field_names.len;
+    const field_values: Index.Slice = if (explicit_int_tag) .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    } else .empty;
+    extra_index += field_values.len;
+    return .{
+        .zir_index = zir_index,
+        .captures = captures,
+        .owner_union = owner_union,
+        .name = extra.data.name,
+        .name_nav = extra.data.name_nav,
+        .namespace = extra.data.namespace,
+        .int_tag_type = extra.data.int_tag_type,
+        .int_tag_is_explicit = explicit_int_tag,
+        .nonexhaustive = nonexhaustive,
+        .field_name_map = extra.data.field_name_map,
+        .field_value_map = field_value_map,
+        .field_names = field_names,
+        .field_values = field_values,
+    };
+}
+
 pub fn loadOpaqueType(ip: *const InternPool, index: Index) LoadedOpaqueType {
     const unwrapped_index = index.unwrap(ip);
     const item = unwrapped_index.getItem(ip);
     assert(item.tag == .type_opaque);
     const extra = extraDataTrail(unwrapped_index.getExtra(ip), Tag.TypeOpaque, item.data);
-    const captures_len = if (extra.data.captures_len == std.math.maxInt(u32))
-        0
-    else
-        extra.data.captures_len;
     return .{
-        .name = extra.data.name,
-        .name_nav = extra.data.name_nav,
-        .namespace = extra.data.namespace,
         .zir_index = extra.data.zir_index,
         .captures = .{
             .tid = unwrapped_index.tid,
             .start = extra.end,
-            .len = captures_len,
+            .len = extra.data.captures_len,
         },
+        .name = extra.data.name,
+        .name_nav = extra.data.name_nav,
+        .namespace = extra.data.namespace,
     };
 }
 
@@ -4819,7 +4153,7 @@ pub const Index = enum(u32) {
     };
 
     /// Used for a map of `Index` values to the index within a list of `Index` values.
-    const Adapter = struct {
+    pub const Adapter = struct {
         indexes: []const Index,
 
         pub fn eql(ctx: @This(), a: Index, b_void: void, b_map_index: usize) bool {
@@ -4891,26 +4225,6 @@ pub const Index = enum(u32) {
     /// Tag to encoding mapping to facilitate fancy debug printing for this type.
     fn dbHelper(self: *Index, tag_to_encoding_map: *struct {
         const DataIsIndex = struct { data: Index };
-        const DataIsExtraIndexOfEnumExplicit = struct {
-            const @"data.fields_len" = opaque {};
-            data: *EnumExplicit,
-            @"trailing.names.len": *@"data.fields_len",
-            @"trailing.values.len": *@"data.fields_len",
-            trailing: struct {
-                names: []NullTerminatedString,
-                values: []Index,
-            },
-        };
-        const DataIsExtraIndexOfTypeTuple = struct {
-            const @"data.fields_len" = opaque {};
-            data: *TypeTuple,
-            @"trailing.types.len": *@"data.fields_len",
-            @"trailing.values.len": *@"data.fields_len",
-            trailing: struct {
-                types: []Index,
-                values: []Index,
-            },
-        };
 
         removed: void,
         type_int_signed: struct { data: u32 },
@@ -4931,21 +4245,7 @@ pub const Index = enum(u32) {
             trailing: struct { names: []NullTerminatedString },
         },
         type_inferred_error_set: DataIsIndex,
-        type_enum_auto: struct {
-            const @"data.fields_len" = opaque {};
-            data: *EnumAuto,
-            @"trailing.names.len": *@"data.fields_len",
-            trailing: struct { names: []NullTerminatedString },
-        },
-        type_enum_explicit: DataIsExtraIndexOfEnumExplicit,
-        type_enum_nonexhaustive: DataIsExtraIndexOfEnumExplicit,
         simple_type: void,
-        type_opaque: struct { data: *Tag.TypeOpaque },
-        type_struct: struct { data: *Tag.TypeStruct },
-        type_struct_packed: struct { data: *Tag.TypeStructPacked },
-        type_struct_packed_inits: struct { data: *Tag.TypeStructPacked },
-        type_tuple: DataIsExtraIndexOfTypeTuple,
-        type_union: struct { data: *Tag.TypeUnion },
         type_function: struct {
             const @"data.flags.has_comptime_bits" = opaque {};
             const @"data.flags.has_noalias_bits" = opaque {};
@@ -4956,6 +4256,29 @@ pub const Index = enum(u32) {
             @"trailing.param_types.len": *@"data.params_len",
             trailing: struct { comptime_bits: []u32, noalias_bits: []u32, param_types: []Index },
         },
+        type_tuple: struct {
+            const @"data.fields_len" = opaque {};
+            data: *TypeTuple,
+            @"trailing.types.len": *@"data.fields_len",
+            @"trailing.values.len": *@"data.fields_len",
+            trailing: struct {
+                types: []Index,
+                values: []Index,
+            },
+        },
+
+        type_struct: struct { data: *Tag.TypeStruct },
+        type_struct_packed_auto: struct { data: *Tag.TypeStructPacked },
+        type_struct_packed_explicit: struct { data: *Tag.TypeStructPacked },
+        type_struct_packed_auto_defaults: struct { data: *Tag.TypeStructPacked },
+        type_struct_packed_explicit_defaults: struct { data: *Tag.TypeStructPacked },
+        type_union: struct { data: *Tag.TypeUnion },
+        type_union_packed_auto: struct { data: *Tag.TypeUnionPacked },
+        type_union_packed_explicit: struct { data: *Tag.TypeUnionPacked },
+        type_enum_auto: struct { data: *Tag.TypeEnum },
+        type_enum_explicit: struct { data: *Tag.TypeEnum },
+        type_enum_nonexhaustive: struct { data: *Tag.TypeEnum },
+        type_opaque: struct { data: *Tag.TypeOpaque },
 
         undef: DataIsIndex,
         simple_value: void,
@@ -4982,8 +4305,6 @@ pub const Index = enum(u32) {
         int_small: struct { data: *IntSmall },
         int_positive: struct { data: u32 },
         int_negative: struct { data: u32 },
-        int_lazy_align: struct { data: *IntLazy },
-        int_lazy_size: struct { data: *IntLazy },
         error_set_error: struct { data: *Key.Error },
         error_union_error: struct { data: *Key.Error },
         error_union_payload: struct { data: *Tag.TypeValue },
@@ -5485,6 +4806,8 @@ pub const Tag = enum(u8) {
     /// assert not this tag. `data` is unused.
     removed,
 
+    /// A type that can be represented with only an enum tag.
+    simple_type,
     /// An integer type.
     /// data is number of bits
     type_int_signed,
@@ -5524,41 +4847,68 @@ pub const Tag = enum(u8) {
     /// The inferred error set type of a function.
     /// data is `Index` of a `func_decl` or `func_instance`.
     type_inferred_error_set,
-    /// An enum type with auto-numbered tag values.
-    /// The enum is exhaustive.
-    /// data is payload index to `EnumAuto`.
+    /// A function body type.
+    /// `data` is extra index to `TypeFunction`.
+    type_function,
+    /// A `TupleType`.
+    /// data is extra index of `TypeTuple`.
+    type_tuple,
+
+    /// A non-packed struct type.
+    /// data is extra index of `TypeStruct`.
+    type_struct,
+    /// `packed struct { ... }` with no default field values.
+    /// data is extra index of `TypeStructPacked`.
+    type_struct_packed_auto,
+    /// `packed struct(T) { ... }` with no default field values.
+    /// data is extra index of `TypeStructPacked`.
+    type_struct_packed_explicit,
+    /// `packed struct { ... }` with one or more default field values.
+    /// data is extra index of `TypeStructPacked`.
+    type_struct_packed_auto_defaults,
+    /// `packed struct(T) { ... }` with one or more default field values.
+    /// data is extra index of `TypeStructPacked`.
+    type_struct_packed_explicit_defaults,
+
+    /// A non-packed union type.
+    /// data is extra index of `TypeUnion`.
+    type_union,
+    /// `packed union { ... }`.
+    /// data is extra index of `TypeUnionPacked`.
+    type_union_packed_auto,
+    /// `packed union(T) { ... }`.
+    /// data is extra index of `TypeUnionPacked`.
+    type_union_packed_explicit,
+
+    /// An exhaustive enum type *without* an explicit integer tag type. The tag type is inferred.
+    ///
+    /// Because the tag type is inferred, there are no explicit field values.
+    ///
+    /// May be the generated tag type for a `union(enum)`.
+    ///
+    /// data is extra index of `TypeEnum`.
     type_enum_auto,
-    /// An enum type with an explicitly provided integer tag type.
-    /// The enum is exhaustive.
-    /// data is payload index to `EnumExplicit`.
+    /// An exhaustive enum type *with* an explicit integer tag type.
+    ///
+    /// May have explicit field values.
+    ///
+    /// May be the generated tag type for a `union(enum(T))`.
+    ///
+    /// data is extra index of `TypeEnum`.
     type_enum_explicit,
-    /// An enum type with an explicitly provided integer tag type.
-    /// The enum is non-exhaustive.
-    /// data is payload index to `EnumExplicit`.
+    /// An non-exhaustive enum type (with an explicit integer tag type, since it is required for
+    /// non-exhaustive enums).
+    ///
+    /// May have explicit field values.
+    ///
+    /// This is *not* a union's generated tag type, because such types are always exhaustive.
+    ///
+    /// data is extra index of `TypeEnum`.
     type_enum_nonexhaustive,
-    /// A type that can be represented with only an enum tag.
-    simple_type,
+
     /// An opaque type.
-    /// data is index of Tag.TypeOpaque in extra.
+    /// data is extra index of `TypeOpaque`.
     type_opaque,
-    /// A non-packed struct type.
-    /// data is 0 or extra index of `TypeStruct`.
-    type_struct,
-    /// A packed struct, no fields have any init values.
-    /// data is extra index of `TypeStructPacked`.
-    type_struct_packed,
-    /// A packed struct, one or more fields have init values.
-    /// data is extra index of `TypeStructPacked`.
-    type_struct_packed_inits,
-    /// A `TupleType`.
-    /// data is extra index of `TypeTuple`.
-    type_tuple,
-    /// A union type.
-    /// `data` is extra index of `TypeUnion`.
-    type_union,
-    /// A function body type.
-    /// `data` is extra index to `TypeFunction`.
-    type_function,
 
     /// Typed `undefined`.
     /// `data` is `Index` of the type.
@@ -5644,12 +4994,6 @@ pub const Tag = enum(u8) {
     /// A negative integer value.
     /// data is a limbs index to `Int`.
     int_negative,
-    /// The ABI alignment of a lazy type.
-    /// data is extra index of `IntLazy`.
-    int_lazy_align,
-    /// The ABI size of a lazy type.
-    /// data is extra index of `IntLazy`.
-    int_lazy_size,
     /// An error value.
     /// data is extra index of `Key.Error`.
     error_set_error,
@@ -5747,24 +5091,77 @@ pub const Tag = enum(u8) {
     const Union = Key.Union;
     const TypePointer = Key.PtrType;
 
+    const struct_packed_encoding = .{
+        .summary = .@"{.payload.name%summary#\"}",
+        .payload = TypeStructPacked,
+        .trailing = struct {
+            type_hash: ?u64,
+            captures: ?[]CaptureValue,
+            field_names: []NullTerminatedString,
+            field_types: []Index,
+        },
+        .config = .{
+            .@"trailing.type_hash.?" = .@"payload.captures_len == .reified",
+            .@"trailing.captures.?" = .@"payload.captures_len != .reified",
+            .@"trailing.captures.?.len" = .@"@intFromEnum(payload.captures_len)",
+            .@"trailing.field_names.len" = .@"payload.fields_len",
+            .@"trailing.field_types.len" = .@"payload.fields_len",
+        },
+    };
+    const struct_packed_defaults_encoding = .{
+        .summary = .@"{.payload.name%summary#\"}",
+        .payload = TypeStructPacked,
+        .trailing = struct {
+            type_hash: ?u64,
+            captures: ?[]CaptureValue,
+            field_names: []NullTerminatedString,
+            field_types: []Index,
+            field_defaults: []Index,
+        },
+        .config = .{
+            .@"trailing.type_hash.?" = .@"payload.captures_len == .reified",
+            .@"trailing.captures.?" = .@"payload.captures_len != .reified",
+            .@"trailing.captures.?.len" = .@"@intFromEnum(payload.captures_len)",
+            .@"trailing.field_names.len" = .@"payload.fields_len",
+            .@"trailing.field_types.len" = .@"payload.fields_len",
+            .@"trailing.field_defaults.len" = .@"payload.fields_len",
+        },
+    };
+    const union_packed_encoding = .{
+        .summary = .@"{.payload.name%summary#\"}",
+        .payload = TypeUnionPacked,
+        .trailing = struct {
+            type_hash: ?u64,
+            captures: ?[]CaptureValue,
+            field_types: []Index,
+        },
+        .config = .{
+            .@"trailing.type_hash.?" = .@"payload.captures_len == .reified",
+            .@"trailing.captures.?" = .@"payload.captures_len != .reified",
+            .@"trailing.captures.?.len" = .@"@intFromEnum(payload.captures_len)",
+            .@"trailing.field_types.len" = .@"payload.fields_len",
+        },
+    };
     const enum_explicit_encoding = .{
         .summary = .@"{.payload.name%summary#\"}",
-        .payload = EnumExplicit,
+        .payload = TypeEnum,
         .trailing = struct {
-            owner_union: Index,
-            captures: ?[]CaptureValue,
+            owner_union: ?Index,
+            zir_index: ?TrackedInst.Index,
             type_hash: ?u64,
+            captures: ?[]CaptureValue,
+            field_value_map: MapIndex,
             field_names: []NullTerminatedString,
-            tag_values: []Index,
+            field_values: []Index,
         },
         .config = .{
-            .@"trailing.owner_union.?" = .@"payload.zir_index == .none",
-            .@"trailing.cau.?" = .@"payload.zir_index != .none",
-            .@"trailing.captures.?" = .@"payload.captures_len < 0xffffffff",
-            .@"trailing.captures.?.len" = .@"payload.captures_len",
-            .@"trailing.type_hash.?" = .@"payload.captures_len == 0xffffffff",
+            .@"trailing.owner_union.?" = .@"payload.captures_len == .generated_union_tag",
+            .@"trailing.zir_index.?" = .@"payload.captures_len != .generated_union_tag",
+            .@"trailing.type_hash.?" = .@"payload.captures_len == .reified",
+            .@"trailing.captures.?" = .@"payload.captures_len != .reified and payload.captures_len != .generated_enum_tag",
+            .@"trailing.captures.?.len" = .@"@intFromEnum(payload.captures_len)",
             .@"trailing.field_names.len" = .@"payload.fields_len",
-            .@"trailing.tag_values.len" = .@"payload.fields_len",
+            .@"trailing.field_values.len" = .@"payload.fields_len",
         },
     };
     const encodings = .{
@@ -5792,107 +5189,7 @@ pub const Tag = enum(u8) {
             .summary = .@"@typeInfo(@typeInfo(@TypeOf({.data%summary})).@\"fn\".return_type.?).error_union.error_set",
             .data = Index,
         },
-        .type_enum_auto = .{
-            .summary = .@"{.payload.name%summary#\"}",
-            .payload = EnumAuto,
-            .trailing = struct {
-                owner_union: ?Index,
-                captures: ?[]CaptureValue,
-                type_hash: ?u64,
-                field_names: []NullTerminatedString,
-            },
-            .config = .{
-                .@"trailing.owner_union.?" = .@"payload.zir_index == .none",
-                .@"trailing.cau.?" = .@"payload.zir_index != .none",
-                .@"trailing.captures.?" = .@"payload.captures_len < 0xffffffff",
-                .@"trailing.captures.?.len" = .@"payload.captures_len",
-                .@"trailing.type_hash.?" = .@"payload.captures_len == 0xffffffff",
-                .@"trailing.field_names.len" = .@"payload.fields_len",
-            },
-        },
-        .type_enum_explicit = enum_explicit_encoding,
-        .type_enum_nonexhaustive = enum_explicit_encoding,
         .simple_type = .{ .summary = .@"{.index%value#.}", .index = SimpleType },
-        .type_opaque = .{
-            .summary = .@"{.payload.name%summary#\"}",
-            .payload = TypeOpaque,
-            .trailing = struct { captures: []CaptureValue },
-            .config = .{ .@"trailing.captures.len" = .@"payload.captures_len" },
-        },
-        .type_struct = .{
-            .summary = .@"{.payload.name%summary#\"}",
-            .payload = TypeStruct,
-            .trailing = struct {
-                captures_len: ?u32,
-                captures: ?[]CaptureValue,
-                type_hash: ?u64,
-                field_types: []Index,
-                field_names_map: OptionalMapIndex,
-                field_names: []NullTerminatedString,
-                field_inits: ?[]Index,
-                field_aligns: ?[]Alignment,
-                field_is_comptime_bits: ?[]u32,
-                field_index: ?[]LoadedStructType.RuntimeOrder,
-                field_offset: []u32,
-            },
-            .config = .{
-                .@"trailing.captures_len.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?.len" = .@"trailing.captures_len.?",
-                .@"trailing.type_hash.?" = .@"payload.flags.is_reified",
-                .@"trailing.field_types.len" = .@"payload.fields_len",
-                .@"trailing.field_names.len" = .@"payload.fields_len",
-                .@"trailing.field_inits.?" = .@"payload.flags.any_default_inits",
-                .@"trailing.field_inits.?.len" = .@"payload.fields_len",
-                .@"trailing.field_aligns.?" = .@"payload.flags.any_aligned_fields",
-                .@"trailing.field_aligns.?.len" = .@"payload.fields_len",
-                .@"trailing.field_is_comptime_bits.?" = .@"payload.flags.any_comptime_fields",
-                .@"trailing.field_is_comptime_bits.?.len" = .@"(payload.fields_len + 31) / 32",
-                .@"trailing.field_index.?" = .@"!payload.flags.is_extern",
-                .@"trailing.field_index.?.len" = .@"payload.fields_len",
-                .@"trailing.field_offset.len" = .@"payload.fields_len",
-            },
-        },
-        .type_struct_packed = .{
-            .summary = .@"{.payload.name%summary#\"}",
-            .payload = TypeStructPacked,
-            .trailing = struct {
-                captures_len: ?u32,
-                captures: ?[]CaptureValue,
-                type_hash: ?u64,
-                field_types: []Index,
-                field_names: []NullTerminatedString,
-            },
-            .config = .{
-                .@"trailing.captures_len.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?.len" = .@"trailing.captures_len.?",
-                .@"trailing.type_hash.?" = .@"payload.is_flags.is_reified",
-                .@"trailing.field_types.len" = .@"payload.fields_len",
-                .@"trailing.field_names.len" = .@"payload.fields_len",
-            },
-        },
-        .type_struct_packed_inits = .{
-            .summary = .@"{.payload.name%summary#\"}",
-            .payload = TypeStructPacked,
-            .trailing = struct {
-                captures_len: ?u32,
-                captures: ?[]CaptureValue,
-                type_hash: ?u64,
-                field_types: []Index,
-                field_names: []NullTerminatedString,
-                field_inits: []Index,
-            },
-            .config = .{
-                .@"trailing.captures_len.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?.len" = .@"trailing.captures_len.?",
-                .@"trailing.type_hash.?" = .@"payload.is_flags.is_reified",
-                .@"trailing.field_types.len" = .@"payload.fields_len",
-                .@"trailing.field_names.len" = .@"payload.fields_len",
-                .@"trailing.field_inits.len" = .@"payload.fields_len",
-            },
-        },
         .type_tuple = .{
             .summary = .@"struct {...}",
             .payload = TypeTuple,
@@ -5905,25 +5202,6 @@ pub const Tag = enum(u8) {
                 .@"trailing.field_values.len" = .@"payload.fields_len",
             },
         },
-        .type_union = .{
-            .summary = .@"{.payload.name%summary#\"}",
-            .payload = TypeUnion,
-            .trailing = struct {
-                captures_len: ?u32,
-                captures: ?[]CaptureValue,
-                type_hash: ?u64,
-                field_types: []Index,
-                field_aligns: []Alignment,
-            },
-            .config = .{
-                .@"trailing.captures_len.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?" = .@"payload.flags.any_captures",
-                .@"trailing.captures.?.len" = .@"trailing.captures_len.?",
-                .@"trailing.type_hash.?" = .@"payload.is_flags.is_reified",
-                .@"trailing.field_types.len" = .@"payload.fields_len",
-                .@"trailing.field_aligns.len" = .@"payload.fields_len",
-            },
-        },
         .type_function = .{
             .summary = .@"fn (...) ... {.payload.return_type%summary}",
             .payload = TypeFunction,
@@ -5941,6 +5219,93 @@ pub const Tag = enum(u8) {
             },
         },
 
+        .type_struct = .{
+            .summary = .@"{.payload.name%summary#\"}",
+            .payload = TypeStruct,
+            .trailing = struct {
+                type_hash: ?u64,
+                captures_len: ?u32,
+                captures: ?[]CaptureValue,
+                field_names: []NullTerminatedString,
+                field_types: []Index,
+                field_defaults: ?[]Index,
+                field_aligns: ?[]Alignment,
+                field_is_comptime_bits: ?[]u32,
+                field_runtime_order: ?[]u32,
+                field_offsets: []u32,
+            },
+            .config = .{
+                .@"trailing.type_hash.?" = .@"payload.flags.any_captures == .reified",
+                .@"trailing.captures_len.?" = .@"payload.flags.any_captures == .true",
+                .@"trailing.captures.?" = .@"payload.flags.any_captures == .true",
+                .@"trailing.captures.?.len" = .@"trailing.captures_len.?",
+                .@"trailing.field_names.len" = .@"payload.fields_len",
+                .@"trailing.field_types.len" = .@"payload.fields_len",
+                .@"trailing.field_defaults.?" = .@"payload.flags.any_field_defaults",
+                .@"trailing.field_defaults.?.len" = .@"payload.fields_len",
+                .@"trailing.field_aligns.?" = .@"payload.flags.any_field_aligns",
+                .@"trailing.field_aligns.?.len" = .@"payload.fields_len",
+                .@"trailing.field_is_comptime_bits.?" = .@"payload.flags.any_comptime_fields",
+                .@"trailing.field_is_comptime_bits.?.len" = .@"(payload.fields_len + 31) / 32",
+                .@"trailing.field_runtime_order.?" = .@"payload.flags.layout == .auto",
+                .@"trailing.field_runtime_order.?.len" = .@"payload.fields_len",
+                .@"trailing.field_offsets.len" = .@"payload.fields_len",
+            },
+        },
+        .type_struct_packed_auto = struct_packed_encoding,
+        .type_struct_packed_explicit = struct_packed_encoding,
+        .type_struct_packed_auto_defaults = struct_packed_defaults_encoding,
+        .type_struct_packed_explicit_defaults = struct_packed_defaults_encoding,
+        .type_union = .{
+            .summary = .@"{.payload.name%summary#\"}",
+            .payload = TypeUnion,
+            .trailing = struct {
+                type_hash: ?u64,
+                captures_len: ?u32,
+                captures: ?[]CaptureValue,
+                field_types: []Index,
+                field_aligns: ?[]Alignment,
+            },
+            .config = .{
+                .@"trailing.type_hash.?" = .@"payload.flags.any_captures == .reified",
+                .@"trailing.captures_len.?" = .@"payload.flags.any_captures == .true",
+                .@"trailing.captures.?" = .@"payload.flags.any_captures == .true",
+                .@"trailing.captures.?.len" = .@"trailing.captures_len.?",
+                .@"trailing.field_types.len" = .@"payload.fields_len",
+                .@"trailing.field_aligns.?" = .@"payloads.flags.any_field_aligns",
+                .@"trailing.field_aligns.?.len" = .@"payload.fields_len",
+            },
+        },
+        .type_union_packed_auto = union_packed_encoding,
+        .type_union_packed_explicit = union_packed_encoding,
+        .type_enum_auto = .{
+            .summary = .@"{.payload.name%summary#\"}",
+            .payload = TypeEnum,
+            .trailing = struct {
+                owner_union: ?Index,
+                zir_index: ?TrackedInst.Index,
+                type_hash: ?u64,
+                captures: ?[]CaptureValue,
+                field_names: []NullTerminatedString,
+            },
+            .config = .{
+                .@"trailing.owner_union.?" = .@"payload.captures_len == .generated_union_tag",
+                .@"trailing.zir_index.?" = .@"payload.captures_len != .generated_union_tag",
+                .@"trailing.type_hash.?" = .@"payload.captures_len == .reified",
+                .@"trailing.captures.?" = .@"payload.captures_len != .reified and payload.captures_len != .generated_enum_tag",
+                .@"trailing.captures.?.len" = .@"@intFromEnum(payload.captures_len)",
+                .@"trailing.field_names.len" = .@"payload.fields_len",
+            },
+        },
+        .type_enum_explicit = enum_explicit_encoding,
+        .type_enum_nonexhaustive = enum_explicit_encoding,
+        .type_opaque = .{
+            .summary = .@"{.payload.name%summary#\"}",
+            .payload = TypeOpaque,
+            .trailing = struct { captures: []CaptureValue },
+            .config = .{ .@"trailing.captures.len" = .@"payload.captures_len" },
+        },
+
         .undef = .{ .summary = .@"@as({.data%summary}, undefined)", .data = Index },
         .simple_value = .{ .summary = .@"{.index%value#.}", .index = SimpleValue },
         .ptr_nav = .{
@@ -5999,8 +5364,6 @@ pub const Tag = enum(u8) {
         .int_small = .{ .summary = .@"@as({.payload.ty%summary}, {.payload.value%value})", .payload = IntSmall },
         .int_positive = .{},
         .int_negative = .{},
-        .int_lazy_align = .{ .summary = .@"@as({.payload.ty%summary}, @alignOf({.payload.lazy_ty%summary}))", .payload = IntLazy },
-        .int_lazy_size = .{ .summary = .@"@as({.payload.ty%summary}, @sizeOf({.payload.lazy_ty%summary}))", .payload = IntLazy },
         .error_set_error = .{ .summary = .@"@as({.payload.ty%summary}, error.@{.payload.name%summary})", .payload = Error },
         .error_union_error = .{ .summary = .@"@as({.payload.ty%summary}, error.@{.payload.name%summary})", .payload = Error },
         .error_union_payload = .{ .summary = .@"@as({.payload.ty%summary}, {.payload.val%summary})", .payload = TypeValue },
@@ -6166,77 +5529,10 @@ pub const Tag = enum(u8) {
         pub const Flags = packed struct(u32) {
             cc: PackedCallingConvention,
             is_var_args: bool,
-            is_generic: bool,
             has_comptime_bits: bool,
             has_noalias_bits: bool,
             is_noinline: bool,
-            _: u9 = 0,
-        };
-    };
-
-    /// Trailing:
-    /// 0. captures_len: u32 // if `any_captures`
-    /// 1. capture: CaptureValue // for each `captures_len`
-    /// 2. type_hash: PackedU64 // if `is_reified`
-    /// 3. field type: Index for each field; declaration order
-    /// 4. field align: Alignment for each field; declaration order
-    pub const TypeUnion = struct {
-        name: NullTerminatedString,
-        name_nav: Nav.Index.Optional,
-        flags: Flags,
-        /// This could be provided through the tag type, but it is more convenient
-        /// to store it directly. This is also necessary for `dumpStatsFallible` to
-        /// work on unresolved types.
-        fields_len: u32,
-        /// Only valid after .have_layout
-        size: u32,
-        /// Only valid after .have_layout
-        padding: u32,
-        namespace: NamespaceIndex,
-        /// The enum that provides the list of field names and values.
-        tag_ty: Index,
-        zir_index: TrackedInst.Index,
-
-        pub const Flags = packed struct(u32) {
-            any_captures: bool,
-            runtime_tag: LoadedUnionType.RuntimeTag,
-            /// If false, the field alignment trailing data is omitted.
-            any_aligned_fields: bool,
-            layout: std.builtin.Type.ContainerLayout,
-            status: LoadedUnionType.Status,
-            requires_comptime: RequiresComptime,
-            assumed_runtime_bits: bool,
-            assumed_pointer_aligned: bool,
-            alignment: Alignment,
-            is_reified: bool,
-            _: u12 = 0,
-        };
-    };
-
-    /// Trailing:
-    /// 0. captures_len: u32 // if `any_captures`
-    /// 1. capture: CaptureValue // for each `captures_len`
-    /// 2. type_hash: PackedU64 // if `is_reified`
-    /// 3. type: Index for each fields_len
-    /// 4. name: NullTerminatedString for each fields_len
-    /// 5. init: Index for each fields_len // if tag is type_struct_packed_inits
-    pub const TypeStructPacked = struct {
-        name: NullTerminatedString,
-        name_nav: Nav.Index.Optional,
-        zir_index: TrackedInst.Index,
-        fields_len: u32,
-        namespace: NamespaceIndex,
-        backing_int_ty: Index,
-        names_map: MapIndex,
-        flags: Flags,
-
-        pub const Flags = packed struct(u32) {
-            any_captures: bool = false,
-            /// Dependency loop detection when resolving field inits.
-            field_inits_wip: bool = false,
-            inits_resolved: bool = false,
-            is_reified: bool = false,
-            _: u28 = 0,
+            _: u10 = 0,
         };
     };
 
@@ -6255,75 +5551,220 @@ pub const Tag = enum(u8) {
     /// than coming up with some other scheme for the data.
     ///
     /// Trailing:
-    /// 0. captures_len: u32 // if `any_captures`
-    /// 1. capture: CaptureValue // for each `captures_len`
-    /// 2. type_hash: PackedU64 // if `is_reified`
-    /// 3. type: Index for each field in declared order
-    /// 4. if any_default_inits:
-    ///    init: Index // for each field in declared order
-    /// 5. if any_aligned_fields:
-    ///    align: Alignment // for each field in declared order
-    /// 6. if any_comptime_fields:
-    ///    field_is_comptime_bits: u32 // minimal number of u32s needed, LSB is field 0
-    /// 7. if not is_extern:
-    ///    field_index: RuntimeOrder // for each field in runtime order
-    /// 8. field_offset: u32 // for each field in declared order, undef until layout_resolved
+    /// 0. type_hash: PackedU64  // if `any_captures == .reified`
+    /// 1. captures_len: u32     // if `any_captures == .true`
+    /// 2. capture: CaptureValue // for each `captures_len`
+    /// 3. field_name: NullTerminatedString // for each `fields_len`
+    /// 4. field_type: Index           // for each `fields_len`
+    /// 5. field_default: Index        // if `any_field_defaults`; for each `fields_len`
+    /// 6. field_align: Alignment      // if `any_field_aligns`; for each `fields_len`
+    /// 7. field_is_comptime_bits: u32 // if `any_comptime_fields`; minimum `u32` for `fields_len`; LSB is field 0
+    /// 8. field_runtime_order: RuntimeOrder // if `layout == .auto`; for each `fields_len`
+    /// 9. field_offset: u32                 // for each `fields_len`
     pub const TypeStruct = struct {
+        zir_index: TrackedInst.Index,
+
         name: NullTerminatedString,
         name_nav: Nav.Index.Optional,
-        zir_index: TrackedInst.Index,
         namespace: NamespaceIndex,
+
         fields_len: u32,
+        field_name_map: MapIndex,
+
+        /// Size in bytes of the whole struct. Always 0 until layout resolved.
+        size: u32,
+
         flags: Flags,
+
+        pub const Flags = packed struct(u32) {
+            any_captures: enum(u2) { true, false, reified },
+
+            /// `packed` layout is represented separately by `TypeStructPacked`.
+            layout: enum(u1) { auto, @"extern" },
+
+            any_comptime_fields: bool,
+            any_field_defaults: bool,
+            any_field_aligns: bool,
+
+            /// Whether the struct is an OPV type. Always `false` until layout resolved.
+            /// The actual OPV is not cached, but caching this bit of state means we avoid
+            /// repeatedly doing redundant checks to find that the struct is not OPV!
+            has_one_possible_value: bool,
+            /// Like `has_one_possible_value`, but for a "noreturn" union (where all fields are noreturn).
+            has_no_possible_value: bool,
+            /// Whether the struct is comptime-only. Always `false` until layout resolved.
+            comptime_only: bool,
+            /// Alignment of the whole struct. Always `.none` until layout resolved.
+            alignment: Alignment,
+
+            _: u17 = 0,
+        };
+    };
+
+    /// Trailing:
+    /// 0. type_hash: PackedU64  // if `captures_len == .reified`
+    /// 1. capture: CaptureValue // if `captures_len != .reified`; for each `captures_len`
+    /// 2. field_name: NullTerminatedString // for each `fields_len`
+    /// 3. field_type: Index                // for each `fields_len`
+    /// 4. field_default: Index             // if item tag implies field defaults; for each `fields_len`
+    pub const TypeStructPacked = struct {
+        zir_index: TrackedInst.Index,
+        captures_len: enum(u32) {
+            reified = std.math.maxInt(u32),
+            _,
+        },
+
+        name: NullTerminatedString,
+        name_nav: Nav.Index.Optional,
+        namespace: NamespaceIndex,
+
+        /// The corresponding `PackedBackingMode` depends on the item's `Tag`.
+        backing_int_type: Index,
+
+        fields_len: u32,
+        field_name_map: MapIndex,
+    };
+
+    /// Field names are intentionally omitted---they are available in `enum_tag_type`.
+    ///
+    /// Trailing:
+    /// 0. type_hash: PackedU64   // if `any_captures == .reified`
+    /// 1. captures_len: u32      // if `any_captures == .true`
+    /// 2. capture: CaptureValue  // if `any_captures == .true`; for each `captures_len`
+    /// 3. field_type: Index      // for each `fields_len`
+    /// 4. field_align: Alignment // for each `fields_len` if `any_field_aligns`
+    pub const TypeUnion = struct {
+        zir_index: TrackedInst.Index,
+
+        name: NullTerminatedString,
+        name_nav: Nav.Index.Optional,
+        namespace: NamespaceIndex,
+        /// The enum that provides the list of field names and values.
+        enum_tag_type: Index,
+
+        /// This could be provided through the tag type, but it is more convenient
+        /// to store it directly. This is also necessary for `dumpStatsFallible` to
+        /// work on unresolved types.
+        /// MLUGG TODO: reconsider, because we resolve the tag type eagerly now.
+        fields_len: u32,
+
+        /// Always 0 until layout resolved.
         size: u32,
+        /// Always 0 until layout resolved.
+        padding: u32,
+
+        flags: Flags,
 
         pub const Flags = packed struct(u32) {
-            any_captures: bool = false,
-            is_extern: bool = false,
-            known_non_opv: bool = false,
-            requires_comptime: RequiresComptime = @enumFromInt(0),
-            assumed_runtime_bits: bool = false,
-            assumed_pointer_aligned: bool = false,
-            any_comptime_fields: bool = false,
-            any_default_inits: bool = false,
-            any_aligned_fields: bool = false,
-            /// `.none` until layout_resolved
-            alignment: Alignment = @enumFromInt(0),
-            /// Dependency loop detection when resolving struct alignment.
-            alignment_wip: bool = false,
-            /// Dependency loop detection when resolving field types.
-            field_types_wip: bool = false,
-            /// Dependency loop detection when resolving struct layout.
-            layout_wip: bool = false,
-            /// Indicates whether `size`, `alignment`, runtime field order, and
-            /// field offets are populated.
-            layout_resolved: bool = false,
-            /// Dependency loop detection when resolving field inits.
-            field_inits_wip: bool = false,
-            /// Indicates whether `field_inits` has been resolved.
-            inits_resolved: bool = false,
-            // The types and all its fields have had their layout resolved. Even through pointer = false,
-            // which `layout_resolved` does not ensure.
-            fully_resolved: bool = false,
-            is_reified: bool = false,
-            _: u8 = 0,
+            any_captures: enum(u2) { true, false, reified },
+
+            /// Whether `enum_tag_type` was explicitly specified with `union(E)` syntax.
+            ///
+            /// For `union(enum(E))` syntax, this is `false`, but the generated enum tag type is
+            /// considered to have an explicitly specified integer tag type.
+            explicit_tag_type: bool,
+
+            /// `packed` layout is represented separately by `TypeStructPacked`.
+            layout: enum(u1) { auto, @"extern" },
+
+            any_field_aligns: bool,
+            runtime_tag: LoadedUnionType.RuntimeTag,
+
+            /// Whether the union is an OPV type. Always `false` until layout resolved.
+            /// The actual OPV is not cached, but caching this bit of state means we avoid
+            /// repeatedly doing redundant checks to find that the union is not OPV!
+            has_one_possible_value: bool,
+            /// Like `has_one_possible_value`, but for a "noreturn" union (where all fields are noreturn).
+            has_no_possible_value: bool,
+            /// Whether the union is comptime-only. Always `false` until layout resolved.
+            comptime_only: bool,
+            /// Alignment of the whole union. Always `.none` until layout resolved.
+            alignment: Alignment,
+
+            _: u16 = 0,
         };
     };
 
+    /// Field names are intentionally omitted---they are available in `enum_tag_type`.
+    ///
+    /// Trailing:
+    /// 0. type_hash: PackedU64  // if `captures_len == .reified`
+    /// 1. capture: CaptureValue // if `captures_len != .reified`; for each `captures_len`
+    /// 2. field_type: Index     // for each `fields_len`
+    pub const TypeUnionPacked = struct {
+        zir_index: TrackedInst.Index,
+        captures_len: enum(u32) {
+            reified = std.math.maxInt(u32),
+            _,
+        },
+
+        name: NullTerminatedString,
+        name_nav: Nav.Index.Optional,
+        namespace: NamespaceIndex,
+
+        /// The corresponding `PackedBackingMode` depends on the item's `Tag`.
+        backing_int_type: Index,
+        /// Although packed unions do not semantically have a tag type, the compiler still assigns
+        /// them a "hypothetical" tag type.
+        enum_tag_type: Index,
+
+        /// This could be provided through the tag type, but it is more convenient
+        /// to store it directly. This is also necessary for `dumpStatsFallible` to
+        /// work on unresolved types.
+        /// MLUGG TODO: reconsider, because we resolve the tag type eagerly now.
+        fields_len: u32,
+    };
+
+    /// Trailing:
+    /// 0. owner_union: Index               // if `captures_len == .generated_union_tag`
+    /// 1. zir_index: TrackedInst.Index     // if `captures_len != .generated_union_tag`
+    /// 2. type_hash: PackedU64             // if `captures_len == .reified`
+    /// 3. capture: CaptureValue            // if `captures_len` is not a named tag; for each `captures_len`
+    /// 4. field_value_map: MapIndex        // if tag is not `.type_enum_auto`
+    /// 5. field_name: NullTerminatedString // for each `fields_len`
+    /// 6. field_value: Index               // if tag is not `.type_enum_auto`; for each `fields_len`
+    pub const TypeEnum = struct {
+        captures_len: enum(u32) {
+            reified = std.math.maxInt(u32),
+            generated_union_tag = std.math.maxInt(u32) - 1,
+            _,
+        },
+
+        name: NullTerminatedString,
+        name_nav: Nav.Index.Optional,
+        namespace: NamespaceIndex,
+
+        /// An integer type which is used for the numerical value of the enum. Whether this was
+        /// user-provided or inferred by the compiler depends on the tag. Either way, the field
+        /// is populated immediately (i.e. does not require any type resolution).
+        int_tag_type: Index,
+
+        fields_len: u32,
+        field_name_map: MapIndex,
+    };
+
     /// Trailing:
     /// 0. capture: CaptureValue // for each `captures_len`
     pub const TypeOpaque = struct {
-        name: NullTerminatedString,
-        name_nav: Nav.Index.Optional,
-        /// Contains the declarations inside this opaque.
-        namespace: NamespaceIndex,
-        /// The index of the `opaque_decl` instruction.
         zir_index: TrackedInst.Index,
-        /// `std.math.maxInt(u32)` indicates this type is reified.
         captures_len: u32,
+
+        name: NullTerminatedString,
+        name_nav: Nav.Index.Optional,
+        namespace: NamespaceIndex,
     };
 };
 
+/// Differentiates between user-provided and compiler-generated backing types for packed aggregates.
+pub const PackedBackingMode = enum(u1) {
+    /// The backing type was explicitly provided by the user, i.e. `packed struct(T)` or `packed union(T)`.
+    /// Type resolution simply *validates* that type.
+    explicit,
+    /// No backing type was explicitly provided by the user. Type layout resolution will populate the
+    /// backing type based on the field types; before then it is invalid (probably `.none`).
+    auto,
+};
+
 /// State that is mutable during semantic analysis. This data is not used for
 /// equality or hashing, except for `inferred_error_set` which is considered
 /// to be part of the type of the function.
@@ -6536,10 +5977,8 @@ pub const Alignment = enum(u6) {
         pub const empty: Slice = .{ .tid = .main, .start = 0, .len = 0 };
 
         pub fn get(slice: Slice, ip: *const InternPool) []Alignment {
-            // TODO: implement @ptrCast between slices changing the length
             const extra = ip.getLocalShared(slice.tid).extra.acquire();
-            //const bytes: []u8 = @ptrCast(extra.view().items(.@"0")[slice.start..]);
-            const bytes: []u8 = std.mem.sliceAsBytes(extra.view().items(.@"0")[slice.start..]);
+            const bytes: []u8 = @ptrCast(extra.view().items(.@"0")[slice.start..]);
             return @ptrCast(bytes[0..slice.len]);
         }
     };
@@ -6596,55 +6035,6 @@ pub const Array = struct {
     }
 };
 
-/// Trailing:
-/// 0. owner_union: Index // if `zir_index == .none`
-/// 1. capture: CaptureValue // for each `captures_len`
-/// 2. type_hash: PackedU64 // if reified (`captures_len == std.math.maxInt(u32)`)
-/// 3. field name: NullTerminatedString for each fields_len; declaration order
-/// 4. tag value: Index for each fields_len; declaration order
-pub const EnumExplicit = struct {
-    name: NullTerminatedString,
-    name_nav: Nav.Index.Optional,
-    /// `std.math.maxInt(u32)` indicates this type is reified.
-    captures_len: u32,
-    namespace: NamespaceIndex,
-    /// An integer type which is used for the numerical value of the enum, which
-    /// has been explicitly provided by the enum declaration.
-    int_tag_type: Index,
-    fields_len: u32,
-    /// Maps field names to declaration index.
-    names_map: MapIndex,
-    /// Maps field values to declaration index.
-    /// If this is `none`, it means the trailing tag values are absent because
-    /// they are auto-numbered.
-    values_map: OptionalMapIndex,
-    /// `none` means this is a generated tag type.
-    /// There will be a trailing union type for which this is a tag.
-    zir_index: TrackedInst.Index.Optional,
-};
-
-/// Trailing:
-/// 0. owner_union: Index // if `zir_index == .none`
-/// 1. capture: CaptureValue // for each `captures_len`
-/// 2. type_hash: PackedU64 // if reified (`captures_len == std.math.maxInt(u32)`)
-/// 3. field name: NullTerminatedString for each fields_len; declaration order
-pub const EnumAuto = struct {
-    name: NullTerminatedString,
-    name_nav: Nav.Index.Optional,
-    /// `std.math.maxInt(u32)` indicates this type is reified.
-    captures_len: u32,
-    namespace: NamespaceIndex,
-    /// An integer type which is used for the numerical value of the enum, which
-    /// was inferred by Zig based on the number of tags.
-    int_tag_type: Index,
-    fields_len: u32,
-    /// Maps field names to declaration index.
-    names_map: MapIndex,
-    /// `none` means this is a generated tag type.
-    /// There will be a trailing union type for which this is a tag.
-    zir_index: TrackedInst.Index.Optional,
-};
-
 pub const PackedU64 = packed struct(u64) {
     a: u32,
     b: u32,
@@ -6827,11 +6217,6 @@ pub const IntSmall = struct {
     value: u32,
 };
 
-pub const IntLazy = struct {
-    ty: Index,
-    lazy_ty: Index,
-};
-
 /// A f64 value, broken up into 2 u32 parts.
 pub const Float64 = struct {
     piece0: u32,
@@ -6994,7 +6379,9 @@ pub fn deinit(ip: *InternPool, gpa: Allocator, io: Io) void {
     ip.src_hash_deps.deinit(gpa);
     ip.nav_val_deps.deinit(gpa);
     ip.nav_ty_deps.deinit(gpa);
-    ip.interned_deps.deinit(gpa);
+    ip.func_ies_deps.deinit(gpa);
+    ip.type_layout_deps.deinit(gpa);
+    ip.type_inits_deps.deinit(gpa);
     ip.zon_file_deps.deinit(gpa);
     ip.embed_file_deps.deinit(gpa);
     ip.namespace_deps.deinit(gpa);
@@ -7130,132 +6517,138 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_inferred_error_set => .{
             .inferred_error_set_type = @enumFromInt(data),
         },
-
-        .type_opaque => .{ .opaque_type = ns: {
-            const extra = extraDataTrail(unwrapped_index.getExtra(ip), Tag.TypeOpaque, data);
-            if (extra.data.captures_len == std.math.maxInt(u32)) {
-                break :ns .{ .reified = .{
-                    .zir_index = extra.data.zir_index,
-                    .type_hash = 0,
-                } };
-            }
-            break :ns .{ .declared = .{
-                .zir_index = extra.data.zir_index,
-                .captures = .{ .owned = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra.end,
-                    .len = extra.data.captures_len,
-                } },
-            } };
-        } },
-
-        .type_struct => .{ .struct_type = ns: {
-            const extra_list = unwrapped_index.getExtra(ip);
-            const extra_items = extra_list.view().items(.@"0");
-            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[data + std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?]);
-            const flags: Tag.TypeStruct.Flags = @bitCast(@atomicLoad(u32, &extra_items[data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?], .unordered));
-            const end_extra_index = data + @as(u32, @typeInfo(Tag.TypeStruct).@"struct".fields.len);
-            if (flags.is_reified) {
-                assert(!flags.any_captures);
-                break :ns .{ .reified = .{
-                    .zir_index = zir_index,
-                    .type_hash = extraData(extra_list, PackedU64, end_extra_index).get(),
-                } };
-            }
-            break :ns .{ .declared = .{
-                .zir_index = zir_index,
-                .captures = .{ .owned = if (flags.any_captures) .{
-                    .tid = unwrapped_index.tid,
-                    .start = end_extra_index + 1,
-                    .len = extra_list.view().items(.@"0")[end_extra_index],
-                } else CaptureValue.Slice.empty },
-            } };
-        } },
-
-        .type_struct_packed, .type_struct_packed_inits => .{ .struct_type = ns: {
-            const extra_list = unwrapped_index.getExtra(ip);
-            const extra_items = extra_list.view().items(.@"0");
-            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "zir_index").?]);
-            const flags: Tag.TypeStructPacked.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?], .unordered));
-            const end_extra_index = data + @as(u32, @typeInfo(Tag.TypeStructPacked).@"struct".fields.len);
-            if (flags.is_reified) {
-                assert(!flags.any_captures);
-                break :ns .{ .reified = .{
-                    .zir_index = zir_index,
-                    .type_hash = extraData(extra_list, PackedU64, end_extra_index).get(),
-                } };
-            }
-            break :ns .{ .declared = .{
-                .zir_index = zir_index,
-                .captures = .{ .owned = if (flags.any_captures) .{
-                    .tid = unwrapped_index.tid,
-                    .start = end_extra_index + 1,
-                    .len = extra_items[end_extra_index],
-                } else CaptureValue.Slice.empty },
-            } };
-        } },
+        .type_function => .{ .func_type = extraFuncType(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) },
         .type_tuple => .{ .tuple_type = extraTypeTuple(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) },
+
+        .type_struct => .{ .struct_type = ns: {
+            const extra_list = unwrapped_index.getExtra(ip);
+            const extra = extraDataTrail(extra_list, Tag.TypeStruct, data);
+            break :ns switch (extra.data.flags.any_captures) {
+                .reified => .{ .reified = .{
+                    .zir_index = extra.data.zir_index,
+                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
+                } },
+                .false => .{ .declared = .{
+                    .zir_index = extra.data.zir_index,
+                    .arg_ty = .none,
+                    .captures = .{ .owned = .empty },
+                } },
+                .true => .{ .declared = .{
+                    .zir_index = extra.data.zir_index,
+                    .arg_ty = .none,
+                    .captures = .{ .owned = .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra.end + 1,
+                        .len = extra_list.view().items(.@"0")[extra.end],
+                    } },
+                } },
+            };
+        } },
+        .type_struct_packed_auto,
+        .type_struct_packed_explicit,
+        .type_struct_packed_auto_defaults,
+        .type_struct_packed_explicit_defaults,
+        => .{ .struct_type = ns: {
+            const extra_list = unwrapped_index.getExtra(ip);
+            const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
+            break :ns switch (extra.data.captures_len) {
+                .reified => .{ .reified = .{
+                    .zir_index = extra.data.zir_index,
+                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
+                } },
+                _ => .{ .declared = .{
+                    .zir_index = extra.data.zir_index,
+                    .arg_ty = switch (item.tag) {
+                        .type_struct_packed_auto, .type_struct_packed_auto_defaults => .none,
+                        .type_struct_packed_explicit, .type_struct_packed_explicit_defaults => extra.data.backing_int_type,
+                        else => unreachable,
+                    },
+                    .captures = .{ .owned = .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra.end,
+                        .len = @intFromEnum(extra.data.captures_len),
+                    } },
+                } },
+            };
+        } },
         .type_union => .{ .union_type = ns: {
             const extra_list = unwrapped_index.getExtra(ip);
             const extra = extraDataTrail(extra_list, Tag.TypeUnion, data);
-            if (extra.data.flags.is_reified) {
-                assert(!extra.data.flags.any_captures);
-                break :ns .{ .reified = .{
+            break :ns switch (extra.data.flags.any_captures) {
+                .reified => .{ .reified = .{
                     .zir_index = extra.data.zir_index,
                     .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
-                } };
-            }
+                } },
+                .false => .{ .declared = .{
+                    .zir_index = extra.data.zir_index,
+                    .arg_ty = if (extra.data.flags.explicit_tag_type) extra.data.enum_tag_type else .none,
+                    .captures = .{ .owned = .empty },
+                } },
+                .true => .{ .declared = .{
+                    .zir_index = extra.data.zir_index,
+                    .arg_ty = if (extra.data.flags.explicit_tag_type) extra.data.enum_tag_type else .none,
+                    .captures = .{ .owned = .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra.end + 1,
+                        .len = extra_list.view().items(.@"0")[extra.end],
+                    } },
+                } },
+            };
+        } },
+        .type_union_packed_auto, .type_union_packed_explicit => .{ .union_type = ns: {
+            const extra_list = unwrapped_index.getExtra(ip);
+            const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, data);
+            break :ns switch (extra.data.captures_len) {
+                .reified => .{ .reified = .{
+                    .zir_index = extra.data.zir_index,
+                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
+                } },
+                _ => .{ .declared = .{
+                    .zir_index = extra.data.zir_index,
+                    .arg_ty = switch (item.tag) {
+                        .type_union_packed_auto => .none,
+                        .type_union_packed_explicit => extra.data.backing_int_type,
+                        else => unreachable,
+                    },
+                    .captures = .{ .owned = .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra.end,
+                        .len = @intFromEnum(extra.data.captures_len),
+                    } },
+                } },
+            };
+        } },
+        .type_enum_auto, .type_enum_explicit, .type_enum_nonexhaustive => .{ .enum_type = ns: {
+            const extra_list = unwrapped_index.getExtra(ip);
+            const extra = extraDataTrail(extra_list, Tag.TypeEnum, data);
+            break :ns switch (extra.data.captures_len) {
+                .reified => .{ .reified = .{
+                    .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
+                    .type_hash = extraData(extra_list, PackedU64, extra.end + 1).get(),
+                } },
+                .generated_union_tag => .{ .generated_union_tag = owner_union: {
+                    break :owner_union @enumFromInt(extra_list.view().items(.@"0")[extra.end]);
+                } },
+                _ => .{ .declared = .{
+                    .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
+                    .arg_ty = switch (item.tag) {
+                        .type_enum_auto => .none,
+                        .type_enum_explicit, .type_enum_nonexhaustive => extra.data.int_tag_type,
+                        else => unreachable,
+                    },
+                    .captures = .{ .owned = .{
+                        .tid = unwrapped_index.tid,
+                        .start = extra.end + 1,
+                        .len = @intFromEnum(extra.data.captures_len),
+                    } },
+                } },
+            };
+        } },
+        .type_opaque => .{ .opaque_type = ns: {
+            const extra = extraDataTrail(unwrapped_index.getExtra(ip), Tag.TypeOpaque, data);
             break :ns .{ .declared = .{
                 .zir_index = extra.data.zir_index,
-                .captures = .{ .owned = if (extra.data.flags.any_captures) .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra.end + 1,
-                    .len = extra_list.view().items(.@"0")[extra.end],
-                } else CaptureValue.Slice.empty },
-            } };
-        } },
-
-        .type_enum_auto => .{ .enum_type = ns: {
-            const extra_list = unwrapped_index.getExtra(ip);
-            const extra = extraDataTrail(extra_list, EnumAuto, data);
-            const zir_index = extra.data.zir_index.unwrap() orelse {
-                assert(extra.data.captures_len == 0);
-                break :ns .{ .generated_tag = .{
-                    .union_type = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
-                } };
-            };
-            if (extra.data.captures_len == std.math.maxInt(u32)) {
-                break :ns .{ .reified = .{
-                    .zir_index = zir_index,
-                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
-                } };
-            }
-            break :ns .{ .declared = .{
-                .zir_index = zir_index,
-                .captures = .{ .owned = .{
-                    .tid = unwrapped_index.tid,
-                    .start = extra.end,
-                    .len = extra.data.captures_len,
-                } },
-            } };
-        } },
-        .type_enum_explicit, .type_enum_nonexhaustive => .{ .enum_type = ns: {
-            const extra_list = unwrapped_index.getExtra(ip);
-            const extra = extraDataTrail(extra_list, EnumExplicit, data);
-            const zir_index = extra.data.zir_index.unwrap() orelse {
-                assert(extra.data.captures_len == 0);
-                break :ns .{ .generated_tag = .{
-                    .union_type = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
-                } };
-            };
-            if (extra.data.captures_len == std.math.maxInt(u32)) {
-                break :ns .{ .reified = .{
-                    .zir_index = zir_index,
-                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
-                } };
-            }
-            break :ns .{ .declared = .{
-                .zir_index = zir_index,
+                .arg_ty = .none,
                 .captures = .{ .owned = .{
                     .tid = unwrapped_index.tid,
                     .start = extra.end,
@@ -7263,7 +6656,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } },
             } };
         } },
-        .type_function => .{ .func_type = extraFuncType(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) },
 
         .undef => .{ .undef = @enumFromInt(data) },
         .opt_null => .{ .opt = .{
@@ -7390,17 +6782,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .storage = .{ .u64 = info.value },
             } };
         },
-        .int_lazy_align, .int_lazy_size => |tag| {
-            const info = extraData(unwrapped_index.getExtra(ip), IntLazy, data);
-            return .{ .int = .{
-                .ty = info.ty,
-                .storage = switch (tag) {
-                    .int_lazy_align => .{ .lazy_align = info.lazy_ty },
-                    .int_lazy_size => .{ .lazy_size = info.lazy_ty },
-                    else => unreachable,
-                },
-            } };
-        },
         .float_f16 => .{ .float = .{
             .ty = .f16_type,
             .storage = .{ .f16 = @bitCast(@as(u16, @intCast(data))) },
@@ -7488,7 +6869,9 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 },
                 .type_array_small,
                 .type_vector,
-                .type_struct_packed,
+                // MLUGG TODO: is this still possible? also, i hate .only_possible_value, it should die in a fire.
+                .type_struct_packed_auto,
+                .type_struct_packed_explicit,
                 => .{ .aggregate = .{
                     .ty = ty,
                     .storage = .{ .elems = &.{} },
@@ -7496,11 +6879,15 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
 
                 // There is only one possible value precisely due to the
                 // fact that this values slice is fully populated!
-                .type_struct, .type_struct_packed_inits => {
+                .type_struct,
+                // MLUGG TODO: is this still possible? also, i hate .only_possible_value, it should die in a fire.
+                .type_struct_packed_auto_defaults,
+                .type_struct_packed_explicit_defaults,
+                => {
                     const info = loadStructType(ip, ty);
                     return .{ .aggregate = .{
                         .ty = ty,
-                        .storage = .{ .elems = @ptrCast(info.field_inits.get(ip)) },
+                        .storage = .{ .elems = @ptrCast(info.field_defaults.get(ip)) },
                     } };
                 },
 
@@ -7634,7 +7021,6 @@ fn extraFuncType(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Ke
         .cc = type_function.data.flags.cc.unpack(),
         .is_var_args = type_function.data.flags.is_var_args,
         .is_noinline = type_function.data.flags.is_noinline,
-        .is_generic = type_function.data.flags.is_generic,
     };
 }
 
@@ -7893,45 +7279,6 @@ fn getOrPutKeyEnsuringAdditionalCapacity(
         .map_index = map_index,
     } };
 }
-/// Like `getOrPutKey`, but asserts that the key already exists, and prepares to replace
-/// its shard entry with a new `Index` anyway. After finalizing this, the old index remains
-/// valid (in that `indexToKey` and similar queries will behave as before), but it will
-/// never be returned from a lookup (`getOrPutKey` etc).
-/// This is used by incremental compilation when an existing container type is outdated. In
-/// this case, the type must be recreated at a new `InternPool.Index`, but the old index must
-/// remain valid since now-unreferenced `AnalUnit`s may retain references to it. The old index
-/// will be cleaned up when the `Zcu` undergoes garbage collection.
-fn putKeyReplace(
-    ip: *InternPool,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    key: Key,
-) GetOrPutKey {
-    const full_hash = key.hash64(ip);
-    const hash: u32 = @truncate(full_hash >> 32);
-    const shard = &ip.shards[@intCast(full_hash & (ip.shards.len - 1))];
-    shard.mutate.map.mutex.lock(io, tid);
-    errdefer shard.mutate.map.mutex.unlock(io);
-    const map = shard.shared.map;
-    const map_mask = map.header().mask();
-    var map_index = hash;
-    while (true) : (map_index += 1) {
-        map_index &= map_mask;
-        const entry = &map.entries[map_index];
-        const index = entry.value;
-        assert(index != .none); // key not present
-        if (entry.hash == hash and ip.indexToKey(index).eql(key, ip)) {
-            break; // we found the entry to replace
-        }
-    }
-    return .{ .new = .{
-        .ip = ip,
-        .tid = tid,
-        .io = io,
-        .shard = shard,
-        .map_index = map_index,
-    } };
-}
 
 pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: Key) Allocator.Error!Index {
     var gop = try ip.getOrPutKey(gpa, io, tid, key);
@@ -8249,23 +7596,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
 
         .int => |int| b: {
             assert(ip.isIntegerType(int.ty));
-            switch (int.storage) {
-                .u64, .i64, .big_int => {},
-                .lazy_align, .lazy_size => |lazy_ty| {
-                    items.appendAssumeCapacity(.{
-                        .tag = switch (int.storage) {
-                            else => unreachable,
-                            .lazy_align => .int_lazy_align,
-                            .lazy_size => .int_lazy_size,
-                        },
-                        .data = try addExtra(extra, IntLazy{
-                            .ty = int.ty,
-                            .lazy_ty = lazy_ty,
-                        }),
-                    });
-                    return gop.put();
-                },
-            }
             switch (int.ty) {
                 .u8_type => switch (int.storage) {
                     .big_int => |big_int| {
@@ -8282,7 +7612,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                         });
                         break :b;
                     },
-                    .lazy_align, .lazy_size => unreachable,
                 },
                 .u16_type => switch (int.storage) {
                     .big_int => |big_int| {
@@ -8299,7 +7628,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                         });
                         break :b;
                     },
-                    .lazy_align, .lazy_size => unreachable,
                 },
                 .u32_type => switch (int.storage) {
                     .big_int => |big_int| {
@@ -8316,7 +7644,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                         });
                         break :b;
                     },
-                    .lazy_align, .lazy_size => unreachable,
                 },
                 .i32_type => switch (int.storage) {
                     .big_int => |big_int| {
@@ -8334,7 +7661,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                         });
                         break :b;
                     },
-                    .lazy_align, .lazy_size => unreachable,
                 },
                 .usize_type => switch (int.storage) {
                     .big_int => |big_int| {
@@ -8355,7 +7681,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                             break :b;
                         }
                     },
-                    .lazy_align, .lazy_size => unreachable,
                 },
                 .comptime_int_type => switch (int.storage) {
                     .big_int => |big_int| {
@@ -8390,7 +7715,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                             break :b;
                         }
                     },
-                    .lazy_align, .lazy_size => unreachable,
                 },
                 else => {},
             }
@@ -8427,7 +7751,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
                     const tag: Tag = if (big_int.positive) .int_positive else .int_negative;
                     try addInt(ip, gpa, io, tid, int.ty, tag, big_int.limbs);
                 },
-                .lazy_align, .lazy_size => unreachable,
             }
         },
 
@@ -8468,7 +7791,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
             assert(ip.isEnumType(enum_tag.ty));
             switch (ip.indexToKey(enum_tag.ty)) {
                 .simple_type => assert(ip.isIntegerType(ip.typeOf(enum_tag.int))),
-                .enum_type => assert(ip.typeOf(enum_tag.int) == ip.loadEnumType(enum_tag.ty).tag_ty),
+                .enum_type => assert(ip.typeOf(enum_tag.int) == ip.loadEnumType(enum_tag.ty).int_tag_type),
                 else => unreachable,
             }
             items.appendAssumeCapacity(.{
@@ -8735,304 +8058,57 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
     return gop.put();
 }
 
-pub fn getUnion(
-    ip: *InternPool,
-    gpa: Allocator,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    un: Key.Union,
-) Allocator.Error!Index {
-    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .un = un });
-    defer gop.deinit();
-    if (gop == .existing) return gop.existing;
-    const local = ip.getLocal(tid);
-    const items = local.getMutableItems(gpa, io);
-    const extra = local.getMutableExtra(gpa, io);
-    try items.ensureUnusedCapacity(1);
-
-    assert(un.ty != .none);
-    assert(un.val != .none);
-    items.appendAssumeCapacity(.{
-        .tag = .union_value,
-        .data = try addExtra(extra, un),
-    });
-
-    return gop.put();
-}
-
-pub const UnionTypeInit = struct {
-    flags: packed struct {
-        runtime_tag: LoadedUnionType.RuntimeTag,
-        any_aligned_fields: bool,
-        layout: std.builtin.Type.ContainerLayout,
-        status: LoadedUnionType.Status,
-        requires_comptime: RequiresComptime,
-        assumed_runtime_bits: bool,
-        assumed_pointer_aligned: bool,
-        alignment: Alignment,
-    },
+pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
     fields_len: u32,
-    enum_tag_ty: Index,
-    /// May have length 0 which leaves the values unset until later.
-    field_types: []const Index,
-    /// May have length 0 which leaves the values unset until later.
-    /// The logic for `any_aligned_fields` is asserted to have been done before
-    /// calling this function.
-    field_aligns: []const Alignment,
-    key: union(enum) {
-        declared: struct {
-            zir_index: TrackedInst.Index,
-            captures: []const CaptureValue,
-        },
-        declared_owned_captures: struct {
-            zir_index: TrackedInst.Index,
-            captures: CaptureValue.Slice,
-        },
-        reified: struct {
-            zir_index: TrackedInst.Index,
-            type_hash: u64,
-        },
-    },
-};
-
-pub fn getUnionType(
-    ip: *InternPool,
-    gpa: Allocator,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    ini: UnionTypeInit,
-    /// If it is known that there is an existing type with this key which is outdated,
-    /// this is passed as `true`, and the type is replaced with one at a fresh index.
-    replace_existing: bool,
-) Allocator.Error!WipNamespaceType.Result {
-    const key: Key = .{ .union_type = switch (ini.key) {
-        .declared => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .captures = .{ .external = d.captures },
-        } },
-        .declared_owned_captures => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .captures = .{ .owned = d.captures },
-        } },
-        .reified => |r| .{ .reified = .{
-            .zir_index = r.zir_index,
-            .type_hash = r.type_hash,
-        } },
-    } };
-    var gop = if (replace_existing)
-        ip.putKeyReplace(io, tid, key)
-    else
-        try ip.getOrPutKey(gpa, io, tid, key);
-    defer gop.deinit();
-    if (gop == .existing) return .{ .existing = gop.existing };
-
-    const local = ip.getLocal(tid);
-    const items = local.getMutableItems(gpa, io);
-    try items.ensureUnusedCapacity(1);
-    const extra = local.getMutableExtra(gpa, io);
-
-    const align_elements_len = if (ini.flags.any_aligned_fields) (ini.fields_len + 3) / 4 else 0;
-    const align_element: u32 = @bitCast([1]u8{@intFromEnum(Alignment.none)} ** 4);
-    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnion).@"struct".fields.len +
-        // TODO: fmt bug
-        // zig fmt: off
-        switch (ini.key) {
-            inline .declared, .declared_owned_captures => |d| @intFromBool(d.captures.len != 0) + d.captures.len,
-            .reified => 2, // type_hash: PackedU64
-        } +
-        // zig fmt: on
-        ini.fields_len + // field types
-        align_elements_len);
-
-    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnion{
-        .flags = .{
-            .any_captures = switch (ini.key) {
-                inline .declared, .declared_owned_captures => |d| d.captures.len != 0,
-                .reified => false,
-            },
-            .runtime_tag = ini.flags.runtime_tag,
-            .any_aligned_fields = ini.flags.any_aligned_fields,
-            .layout = ini.flags.layout,
-            .status = ini.flags.status,
-            .requires_comptime = ini.flags.requires_comptime,
-            .assumed_runtime_bits = ini.flags.assumed_runtime_bits,
-            .assumed_pointer_aligned = ini.flags.assumed_pointer_aligned,
-            .alignment = ini.flags.alignment,
-            .is_reified = switch (ini.key) {
-                .declared, .declared_owned_captures => false,
-                .reified => true,
-            },
-        },
-        .fields_len = ini.fields_len,
-        .size = std.math.maxInt(u32),
-        .padding = std.math.maxInt(u32),
-        .name = undefined, // set by `finish`
-        .name_nav = undefined, // set by `finish`
-        .namespace = undefined, // set by `finish`
-        .tag_ty = ini.enum_tag_ty,
-        .zir_index = switch (ini.key) {
-            inline else => |x| x.zir_index,
-        },
-    });
-
-    items.appendAssumeCapacity(.{
-        .tag = .type_union,
-        .data = extra_index,
-    });
-
-    switch (ini.key) {
-        .declared => |d| if (d.captures.len != 0) {
-            extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)});
-        },
-        .declared_owned_captures => |d| if (d.captures.len != 0) {
-            extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures.get(ip))});
-        },
-        .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-    }
-
-    // field types
-    if (ini.field_types.len > 0) {
-        assert(ini.field_types.len == ini.fields_len);
-        extra.appendSliceAssumeCapacity(.{@ptrCast(ini.field_types)});
-    } else {
-        extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
-    }
-
-    // field alignments
-    if (ini.flags.any_aligned_fields) {
-        extra.appendNTimesAssumeCapacity(.{align_element}, align_elements_len);
-        if (ini.field_aligns.len > 0) {
-            assert(ini.field_aligns.len == ini.fields_len);
-            @memcpy((Alignment.Slice{
-                .tid = tid,
-                .start = @intCast(extra.mutate.len - align_elements_len),
-                .len = @intCast(ini.field_aligns.len),
-            }).get(ip), ini.field_aligns);
-        }
-    } else {
-        assert(ini.field_aligns.len == 0);
-    }
-
-    return .{ .wip = .{
-        .tid = tid,
-        .index = gop.put(),
-        .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name").?,
-        .name_nav_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name_nav").?,
-        .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?,
-    } };
-}
-
-pub const WipNamespaceType = struct {
-    tid: Zcu.PerThread.Id,
-    index: Index,
-    type_name_extra_index: u32,
-    namespace_extra_index: u32,
-    name_nav_extra_index: u32,
-
-    pub fn setName(
-        wip: WipNamespaceType,
-        ip: *InternPool,
-        type_name: NullTerminatedString,
-        /// This should be the `Nav` we are named after if we use the `.parent` name strategy; `.none` otherwise.
-        /// This is also `.none` if we use `.parent` because we are the root struct type for a file.
-        name_nav: Nav.Index.Optional,
-    ) void {
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        const extra_items = extra.view().items(.@"0");
-        extra_items[wip.type_name_extra_index] = @intFromEnum(type_name);
-        extra_items[wip.name_nav_extra_index] = @intFromEnum(name_nav);
-    }
-
-    pub fn finish(
-        wip: WipNamespaceType,
-        ip: *InternPool,
-        namespace: NamespaceIndex,
-    ) Index {
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        const extra_items = extra.view().items(.@"0");
-
-        extra_items[wip.namespace_extra_index] = @intFromEnum(namespace);
-
-        return wip.index;
-    }
-
-    pub fn cancel(wip: WipNamespaceType, ip: *InternPool, tid: Zcu.PerThread.Id) void {
-        ip.remove(tid, wip.index);
-    }
-
-    pub const Result = union(enum) {
-        wip: WipNamespaceType,
-        existing: Index,
-    };
-};
-
-pub const StructTypeInit = struct {
     layout: std.builtin.Type.ContainerLayout,
-    fields_len: u32,
-    known_non_opv: bool,
-    requires_comptime: RequiresComptime,
+    /// The following only applies if `layout == .@"packed"`; this field is ignored otherwise.
+    ///
+    /// The explicitly specified backing integer type. `.none` means the backing integer is inferred
+    /// by the compiler. Asserts that this is an integer type.
+    explicit_packed_backing_type: Index,
     any_comptime_fields: bool,
-    any_default_inits: bool,
-    inits_resolved: bool,
-    any_aligned_fields: bool,
+    any_field_defaults: bool,
+    any_field_aligns: bool,
     key: union(enum) {
         declared: struct {
             zir_index: TrackedInst.Index,
             captures: []const CaptureValue,
         },
-        declared_owned_captures: struct {
-            zir_index: TrackedInst.Index,
-            captures: CaptureValue.Slice,
-        },
         reified: struct {
             zir_index: TrackedInst.Index,
             type_hash: u64,
         },
     },
-};
-
-pub fn getStructType(
-    ip: *InternPool,
-    gpa: Allocator,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    ini: StructTypeInit,
-    /// If it is known that there is an existing type with this key which is outdated,
-    /// this is passed as `true`, and the type is replaced with one at a fresh index.
-    replace_existing: bool,
-) Allocator.Error!WipNamespaceType.Result {
+}) Allocator.Error!WipContainerType.Result {
     const key: Key = .{ .struct_type = switch (ini.key) {
         .declared => |d| .{ .declared = .{
             .zir_index = d.zir_index,
+            .arg_ty = switch (ini.layout) {
+                .auto, .@"extern" => .none,
+                .@"packed" => ini.explicit_packed_backing_type,
+            },
             .captures = .{ .external = d.captures },
         } },
-        .declared_owned_captures => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .captures = .{ .owned = d.captures },
-        } },
         .reified => |r| .{ .reified = .{
             .zir_index = r.zir_index,
             .type_hash = r.type_hash,
         } },
     } };
-    var gop = if (replace_existing)
-        ip.putKeyReplace(io, tid, key)
-    else
-        try ip.getOrPutKey(gpa, io, tid, key);
+    var gop = try ip.getOrPutKey(gpa, io, tid, key);
     defer gop.deinit();
     if (gop == .existing) return .{ .existing = gop.existing };
 
     const local = ip.getLocal(tid);
     const items = local.getMutableItems(gpa, io);
     const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
 
-    const names_map = try ip.addMap(gpa, io, tid, ini.fields_len);
+    const field_name_map = try ip.addMap(gpa, io, tid, ini.fields_len);
     errdefer local.mutate.maps.len -= 1;
 
-    const zir_index = switch (ini.key) {
-        inline else => |x| x.zir_index,
+    const zir_index, const type_hash_captures_extra_len = switch (ini.key) {
+        .declared => |d| .{ d.zir_index, d.captures.len + @intFromBool(ini.layout != .@"packed") },
+        .reified => |r| .{ r.zir_index, 2 },
     };
 
     const is_extern = switch (ini.layout) {
@@ -9040,160 +8116,579 @@ pub fn getStructType(
         .@"extern" => true,
         .@"packed" => {
             try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeStructPacked).@"struct".fields.len +
-                // TODO: fmt bug
-                // zig fmt: off
-                switch (ini.key) {
-                    inline .declared, .declared_owned_captures => |d| @intFromBool(d.captures.len != 0) + d.captures.len,
-                    .reified => 2, // type_hash: PackedU64
-                } +
-                // zig fmt: on
-                ini.fields_len + // types
-                ini.fields_len + // names
-                ini.fields_len); // inits
+                type_hash_captures_extra_len +
+                ini.fields_len + // field_name
+                ini.fields_len + // field_type
+                (if (ini.any_field_defaults) ini.fields_len else 0)); // field_default
+
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStructPacked{
+                .zir_index = zir_index,
+                .captures_len = switch (ini.key) {
+                    .declared => |d| @enumFromInt(d.captures.len),
+                    .reified => .reified,
+                },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
-                .zir_index = zir_index,
-                .fields_len = ini.fields_len,
                 .namespace = undefined, // set by `finish`
-                .backing_int_ty = .none,
-                .names_map = names_map,
-                .flags = .{
-                    .any_captures = switch (ini.key) {
-                        inline .declared, .declared_owned_captures => |d| d.captures.len != 0,
-                        .reified => false,
-                    },
-                    .field_inits_wip = false,
-                    .inits_resolved = ini.inits_resolved,
-                    .is_reified = switch (ini.key) {
-                        .declared, .declared_owned_captures => false,
-                        .reified => true,
-                    },
-                },
-            });
-            try items.append(.{
-                .tag = if (ini.any_default_inits) .type_struct_packed_inits else .type_struct_packed,
-                .data = extra_index,
+                .backing_int_type = ini.explicit_packed_backing_type,
+                .fields_len = ini.fields_len,
+                .field_name_map = field_name_map,
             });
             switch (ini.key) {
-                .declared => |d| if (d.captures.len != 0) {
-                    extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-                    extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)});
-                },
-                .declared_owned_captures => |d| if (d.captures.len != 0) {
-                    extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-                    extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures.get(ip))});
-                },
-                .reified => |r| {
-                    _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash));
-                },
+                .declared => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}),
+                .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
             }
-            extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
-            extra.appendNTimesAssumeCapacity(.{@intFromEnum(OptionalNullTerminatedString.none)}, ini.fields_len);
-            if (ini.any_default_inits) {
-                extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
+            const field_names_start = extra.mutate.len;
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+            if (ini.any_field_defaults) {
+                extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default
             }
+            items.appendAssumeCapacity(.{
+                .tag = switch (ini.explicit_packed_backing_type) {
+                    .none => if (ini.any_field_defaults) .type_struct_packed_auto_defaults else .type_struct_packed_auto,
+                    else => if (ini.any_field_defaults) .type_struct_packed_explicit_defaults else .type_struct_packed_explicit,
+                },
+                .data = extra_index,
+            });
             return .{ .wip = .{
-                .tid = tid,
                 .index = gop.put(),
-                .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name").?,
-                .name_nav_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name_nav").?,
-                .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?,
+                .tid = tid,
+                .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name").?,
+                .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name_nav").?,
+                .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?,
+                .tag_type_index = null,
+                .fields_len = ini.fields_len,
+                .field_name_map = field_name_map,
+                .field_names_start = field_names_start,
+                .field_comptime_bits_start = null,
             } };
         },
     };
 
-    const align_elements_len = if (ini.any_aligned_fields) (ini.fields_len + 3) / 4 else 0;
-    const align_element: u32 = @bitCast([1]u8{@intFromEnum(Alignment.none)} ** 4);
-    const comptime_elements_len = if (ini.any_comptime_fields) (ini.fields_len + 31) / 32 else 0;
-
     try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeStruct).@"struct".fields.len +
-        // TODO: fmt bug
-        // zig fmt: off
-        switch (ini.key) {
-            inline .declared, .declared_owned_captures => |d| @intFromBool(d.captures.len != 0) + d.captures.len,
-            .reified => 2, // type_hash: PackedU64
-        } +
-        // zig fmt: on
-        (ini.fields_len * 5) + // types, names, inits, runtime order, offsets
-        align_elements_len + comptime_elements_len +
-        1); // names_map
+        type_hash_captures_extra_len +
+        ini.fields_len + // field_name
+        ini.fields_len + // field_type
+        (if (ini.any_field_defaults) ini.fields_len else 0) + // field_default
+        (if (ini.any_field_aligns) (ini.fields_len + 3) / 4 else 0) + // field_align
+        (if (ini.any_comptime_fields) (ini.fields_len + 31) / 32 else 0) + // field_is_comptime_bits
+        (if (!is_extern) ini.fields_len else 0) + // field_runtime_order
+        ini.fields_len); // field_offset
+
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStruct{
+        .zir_index = zir_index,
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
-        .zir_index = zir_index,
         .namespace = undefined, // set by `finish`
         .fields_len = ini.fields_len,
-        .size = std.math.maxInt(u32),
+        .field_name_map = field_name_map,
+        .size = 0,
         .flags = .{
             .any_captures = switch (ini.key) {
-                inline .declared, .declared_owned_captures => |d| d.captures.len != 0,
-                .reified => false,
+                .declared => |d| if (d.captures.len != 0) .true else .false,
+                .reified => .reified,
             },
-            .is_extern = is_extern,
-            .known_non_opv = ini.known_non_opv,
-            .requires_comptime = ini.requires_comptime,
-            .assumed_runtime_bits = false,
-            .assumed_pointer_aligned = false,
+            .layout = if (is_extern) .@"extern" else .auto,
             .any_comptime_fields = ini.any_comptime_fields,
-            .any_default_inits = ini.any_default_inits,
-            .any_aligned_fields = ini.any_aligned_fields,
+            .any_field_defaults = ini.any_field_defaults,
+            .any_field_aligns = ini.any_field_aligns,
+            .has_one_possible_value = false,
+            .has_no_possible_value = false,
+            .comptime_only = false,
             .alignment = .none,
-            .alignment_wip = false,
-            .field_types_wip = false,
-            .layout_wip = false,
-            .layout_resolved = false,
-            .field_inits_wip = false,
-            .inits_resolved = ini.inits_resolved,
-            .fully_resolved = false,
-            .is_reified = switch (ini.key) {
-                .declared, .declared_owned_captures => false,
-                .reified => true,
-            },
         },
     });
-    try items.append(.{
+    switch (ini.key) {
+        .declared => |d| if (d.captures.len != 0) {
+            extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
+            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)});
+        },
+        .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
+    }
+    const field_names_start = extra.mutate.len;
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+    if (ini.any_field_defaults) {
+        extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default
+    }
+    if (ini.any_field_aligns) {
+        extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align
+    }
+    const field_comptime_bits_start: ?u32 = if (ini.any_comptime_fields) start: {
+        const start = extra.mutate.len;
+        extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 31) / 32); // field_is_comptime_bits
+        break :start start;
+    } else null;
+    if (!is_extern) {
+        extra.appendNTimesAssumeCapacity(.{@intFromEnum(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order
+    }
+    extra.appendNTimesAssumeCapacity(.{0}, ini.fields_len); // field_offset
+    items.appendAssumeCapacity(.{
         .tag = .type_struct,
         .data = extra_index,
     });
+    return .{ .wip = .{
+        .index = gop.put(),
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?,
+        .tag_type_index = null,
+        .fields_len = ini.fields_len,
+        .field_name_map = field_name_map,
+        .field_names_start = field_names_start,
+        .field_comptime_bits_start = field_comptime_bits_start,
+    } };
+}
+
+pub fn getUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    fields_len: u32,
+    layout: std.builtin.Type.ContainerLayout,
+    /// The explicitly specified backing integer type for a `packed union`.
+    /// `.none` means the backing integer is inferred by the compiler. If set,
+    /// must be an integer type. If the union is not packed, must be `.none`.
+    explicit_packed_backing_type: Index,
+    runtime_tag: LoadedUnionType.RuntimeTag,
+    /// `true` for `union(T)`, but `false` for anything else, including `union(enum(T))`.
+    have_explicit_enum_tag: bool,
+    any_field_aligns: bool,
+    key: union(enum) {
+        declared: struct {
+            zir_index: TrackedInst.Index,
+            captures: []const CaptureValue,
+            /// This is the `T` in one of the following:
+            /// * `union(T)` (enum tag type)
+            /// * `union(enum(T))` (int tag type)
+            /// * `packed union(T)` (int backing type)
+            /// Or `.none` otherwise.
+            arg_ty: InternPool.Index,
+        },
+        reified: struct {
+            zir_index: TrackedInst.Index,
+            type_hash: u64,
+        },
+    },
+}) Allocator.Error!WipContainerType.Result {
+    if (ini.explicit_packed_backing_type != .none) {
+        assert(ip.zigTypeTag(ini.explicit_packed_backing_type) == .int);
+        if (ini.key == .declared) assert(ini.key.declared.arg_ty == ini.explicit_packed_backing_type);
+    }
+    const key: Key = .{ .union_type = switch (ini.key) {
+        .declared => |d| .{ .declared = .{
+            .zir_index = d.zir_index,
+            .arg_ty = d.arg_ty,
+            .captures = .{ .external = d.captures },
+        } },
+        .reified => |r| .{ .reified = .{
+            .zir_index = r.zir_index,
+            .type_hash = r.type_hash,
+        } },
+    } };
+    var gop = try ip.getOrPutKey(gpa, io, tid, key);
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    const zir_index, const type_hash_captures_extra_len = switch (ini.key) {
+        .declared => |d| .{ d.zir_index, d.captures.len + @intFromBool(ini.layout != .@"packed") },
+        .reified => |r| .{ r.zir_index, 2 },
+    };
+
+    const is_extern = switch (ini.layout) {
+        .auto => false,
+        .@"extern" => true,
+        .@"packed" => {
+            try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnionPacked).@"struct".fields.len +
+                type_hash_captures_extra_len +
+                ini.fields_len); // field_type
+
+            const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnionPacked{
+                .zir_index = zir_index,
+                .captures_len = switch (ini.key) {
+                    .declared => |d| @enumFromInt(d.captures.len),
+                    .reified => .reified,
+                },
+                .name = undefined, // set by `finish`
+                .name_nav = undefined, // set by `finish`
+                .namespace = undefined, // set by `finish`
+                .backing_int_type = ini.explicit_packed_backing_type,
+                .enum_tag_type = .none, // set by `setTagType`
+                .fields_len = ini.fields_len,
+            });
+            switch (ini.key) {
+                .declared => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}),
+                .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
+            }
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+            items.appendAssumeCapacity(.{
+                .tag = switch (ini.explicit_packed_backing_type) {
+                    .none => .type_union_packed_auto,
+                    else => .type_union_packed_explicit,
+                },
+                .data = extra_index,
+            });
+            return .{
+                .wip = .{
+                    .index = gop.put(),
+                    .tid = tid,
+                    .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name").?,
+                    .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name_nav").?,
+                    .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "namespace").?,
+                    .tag_type_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "enum_tag_type").?,
+                    .fields_len = 0, // the fields come from the enum, so nothing to set
+                    .field_name_map = undefined,
+                    .field_names_start = undefined,
+                    .field_comptime_bits_start = undefined,
+                },
+            };
+        },
+    };
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnion).@"struct".fields.len +
+        type_hash_captures_extra_len +
+        ini.fields_len + // field_type
+        (if (ini.any_field_aligns) (ini.fields_len + 3) / 4 else 0)); // field_align
+
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnion{
+        .zir_index = zir_index,
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+        .enum_tag_type = .none, // set by `setTagType`
+        .fields_len = ini.fields_len,
+        .size = 0,
+        .padding = 0,
+        .flags = .{
+            .any_captures = switch (ini.key) {
+                .declared => |d| if (d.captures.len != 0) .true else .false,
+                .reified => .reified,
+            },
+            .explicit_tag_type = ini.have_explicit_enum_tag,
+            .layout = if (is_extern) .@"extern" else .auto,
+            .any_field_aligns = ini.any_field_aligns,
+            .runtime_tag = ini.runtime_tag,
+            .has_one_possible_value = false,
+            .has_no_possible_value = false,
+            .comptime_only = false,
+            .alignment = .none,
+        },
+    });
     switch (ini.key) {
         .declared => |d| if (d.captures.len != 0) {
             extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
             extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)});
         },
-        .declared_owned_captures => |d| if (d.captures.len != 0) {
-            extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures.get(ip))});
+        .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
+    }
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+    if (ini.any_field_aligns) {
+        extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align
+    }
+    items.appendAssumeCapacity(.{
+        .tag = .type_union,
+        .data = extra_index,
+    });
+    return .{
+        .wip = .{
+            .index = gop.put(),
+            .tid = tid,
+            .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name").?,
+            .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name_nav").?,
+            .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?,
+            .tag_type_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "enum_tag_type").?,
+            .fields_len = 0, // the fields come from the enum, so nothing to set
+            .field_name_map = undefined,
+            .field_names_start = undefined,
+            .field_comptime_bits_start = undefined,
+        },
+    };
+}
+
+pub fn getEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    fields_len: u32,
+    /// For `enum(T)` or `union(enum(T))`, this is `T`. Asserts `T` is an integer type.
+    /// Otherwise, `.none`.
+    explicit_int_tag_type: Index,
+    nonexhaustive: bool,
+    key: union(enum) {
+        declared: struct {
+            zir_index: TrackedInst.Index,
+            captures: []const CaptureValue,
+        },
+        reified: struct {
+            zir_index: TrackedInst.Index,
+            type_hash: u64,
+        },
+        generated_union_tag: Index,
+    },
+}) Allocator.Error!WipContainerType.Result {
+    const key: Key = .{ .enum_type = switch (ini.key) {
+        .declared => |d| .{ .declared = .{
+            .zir_index = d.zir_index,
+            .arg_ty = ini.explicit_int_tag_type,
+            .captures = .{ .external = d.captures },
+        } },
+        .reified => |r| .{ .reified = .{
+            .zir_index = r.zir_index,
+            .type_hash = r.type_hash,
+        } },
+        .generated_union_tag => |u| .{ .generated_union_tag = u },
+    } };
+    var gop = try ip.getOrPutKey(gpa, io, tid, key);
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    const tag: Tag, const have_values: bool = if (ini.nonexhaustive)
+        .{ .type_enum_nonexhaustive, true }
+    else if (ini.explicit_int_tag_type != .none)
+        .{ .type_enum_explicit, true }
+    else
+        .{ .type_enum_auto, false };
+
+    const field_name_map = try ip.addMap(gpa, io, tid, ini.fields_len);
+    errdefer local.mutate.maps.len -= 1;
+
+    const field_value_map = if (have_values) try ip.addMap(gpa, io, tid, ini.fields_len) else undefined;
+    errdefer local.mutate.maps.len -= @intFromBool(have_values);
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeEnum).@"struct".fields.len +
+        switch (ini.key) {
+            .declared => |d| 1 + d.captures.len, // `zir_index` and `capture`
+            .reified => 3, // `zir_index` and `type_hash`
+            .generated_union_tag => 1, // owner_union
+        } +
+        @intFromBool(have_values) + // field_value_map
+        ini.fields_len + // field_name
+        (if (have_values) ini.fields_len else 0)); // field_value
+
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
+        .captures_len = switch (ini.key) {
+            .declared => |d| @enumFromInt(d.captures.len),
+            .reified => .reified,
+            .generated_union_tag => .generated_union_tag,
+        },
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+        .int_tag_type = ini.explicit_int_tag_type,
+        .fields_len = ini.fields_len,
+        .field_name_map = field_name_map,
+    });
+    switch (ini.key) {
+        .declared => |d| {
+            extra.appendAssumeCapacity(.{@intFromEnum(d.zir_index)}); // zir_index
+            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}); // capture
         },
         .reified => |r| {
-            _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash));
+            extra.appendAssumeCapacity(.{@intFromEnum(r.zir_index)}); // zir_index
+            _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)); // type_hash
+        },
+        .generated_union_tag => |owner_union| {
+            extra.appendAssumeCapacity(.{@intFromEnum(owner_union)}); // owner_union
         },
     }
-    extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
-    extra.appendAssumeCapacity(.{@intFromEnum(names_map)});
-    extra.appendNTimesAssumeCapacity(.{@intFromEnum(OptionalNullTerminatedString.none)}, ini.fields_len);
-    if (ini.any_default_inits) {
-        extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
-    }
-    if (ini.any_aligned_fields) {
-        extra.appendNTimesAssumeCapacity(.{align_element}, align_elements_len);
-    }
-    if (ini.any_comptime_fields) {
-        extra.appendNTimesAssumeCapacity(.{0}, comptime_elements_len);
-    }
-    if (ini.layout == .auto) {
-        extra.appendNTimesAssumeCapacity(.{@intFromEnum(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len);
-    }
-    extra.appendNTimesAssumeCapacity(.{std.math.maxInt(u32)}, ini.fields_len);
+    if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)});
+    const field_names_start = extra.mutate.len;
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+    if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value
+    items.appendAssumeCapacity(.{
+        .tag = tag,
+        .data = extra_index,
+    });
     return .{ .wip = .{
+        .index = gop.put(),
         .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "namespace").?,
+        .tag_type_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "int_tag_type").?,
+        .fields_len = ini.fields_len,
+        .field_name_map = field_name_map,
+        .field_names_start = field_names_start,
+        .field_comptime_bits_start = null,
+    } };
+}
+
+pub fn getOpaqueType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    zir_index: TrackedInst.Index,
+    captures: []const CaptureValue,
+}) Allocator.Error!WipContainerType.Result {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .opaque_type = .{ .declared = .{
+        .zir_index = ini.zir_index,
+        .captures = .{ .external = ini.captures },
+        .arg_ty = .none,
+    } } });
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeOpaque).@"struct".fields.len + ini.captures.len);
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeOpaque{
+        .zir_index = ini.zir_index,
+        .captures_len = @intCast(ini.captures.len),
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+    });
+    extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)});
+    items.appendAssumeCapacity(.{
+        .tag = .type_opaque,
+        .data = extra_index,
+    });
+    return .{ .wip = .{
         .index = gop.put(),
-        .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name").?,
-        .name_nav_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name_nav").?,
-        .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?,
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "namespace").?,
+        .tag_type_index = null,
+        .fields_len = 0,
+        .field_name_map = undefined,
+        .field_names_start = undefined,
+        .field_comptime_bits_start = undefined,
     } };
 }
 
+pub const WipContainerType = struct {
+    index: Index,
+    tid: Zcu.PerThread.Id,
+    type_name_index: u32,
+    name_nav_index: u32,
+    namespace_index: u32,
+
+    tag_type_index: ?u32,
+
+    fields_len: u32,
+    field_name_map: MapIndex,
+    field_names_start: u32,
+    field_comptime_bits_start: ?u32,
+
+    pub fn setName(
+        wip: WipContainerType,
+        ip: *InternPool,
+        type_name: NullTerminatedString,
+        /// This should be the `Nav` we are named after if we use the `.parent` name strategy; `.none` otherwise.
+        /// This is also `.none` if we use `.parent` because we are the root struct type for a file.
+        name_nav: Nav.Index.Optional,
+    ) void {
+        const extra = ip.getLocalShared(wip.tid).extra.acquire();
+        const extra_items = extra.view().items(.@"0");
+        extra_items[wip.type_name_index] = @intFromEnum(type_name);
+        extra_items[wip.name_nav_index] = @intFromEnum(name_nav);
+    }
+
+    pub fn setTagType(
+        wip: WipContainerType,
+        ip: *InternPool,
+        tag_ty: Index,
+    ) void {
+        const extra = ip.getLocalShared(wip.tid).extra.acquire();
+        const extra_items = extra.view().items(.@"0");
+        const i = wip.tag_type_index.?;
+        const old_val: InternPool.Index = @enumFromInt(extra_items[i]);
+        assert(old_val == .none);
+        assert(tag_ty != .none);
+        extra_items[i] = @intFromEnum(tag_ty);
+    }
+
+    /// Returns the already-existing field with the same name, if any.
+    pub fn nextField(
+        wip: WipContainerType,
+        ip: *InternPool,
+        name: NullTerminatedString,
+        marked_comptime: bool,
+    ) ?u32 {
+        assert(wip.fields_len > 0);
+        const extra = ip.getLocalShared(wip.tid).extra.acquire();
+        const extra_items = extra.view().items(.@"0");
+        const map = wip.field_name_map.get(ip);
+        const field_idx = map.count();
+        assert(field_idx < wip.fields_len);
+        const names: []NullTerminatedString = @ptrCast(extra_items[wip.field_names_start..][0..wip.fields_len]);
+        const adapter: NullTerminatedString.Adapter = .{ .strings = names[0..field_idx] };
+        const gop = map.getOrPutAssumeCapacityAdapted(name, adapter);
+        if (gop.found_existing) return @intCast(gop.index);
+        names[field_idx] = name;
+        if (wip.field_comptime_bits_start) |start_idx| {
+            if (marked_comptime) {
+                extra_items[start_idx + field_idx / 32] |= @as(u32, 1) << @intCast(field_idx % 32);
+            }
+        } else {
+            assert(!marked_comptime);
+        }
+        return null;
+    }
+
+    pub fn finish(
+        wip: WipContainerType,
+        ip: *InternPool,
+        namespace: NamespaceIndex,
+    ) Index {
+        const extra = ip.getLocalShared(wip.tid).extra.acquire();
+        const extra_items = extra.view().items(.@"0");
+
+        extra_items[wip.namespace_index] = @intFromEnum(namespace);
+
+        if (wip.fields_len > 0) {
+            assert(wip.field_name_map.get(ip).count() == wip.fields_len);
+        }
+        if (wip.tag_type_index) |i| {
+            const tag_ty: Index = @enumFromInt(extra_items[i]);
+            assert(tag_ty != .none);
+        }
+
+        return wip.index;
+    }
+
+    pub fn cancel(wip: WipContainerType, ip: *InternPool, tid: Zcu.PerThread.Id) void {
+        ip.remove(tid, wip.index);
+    }
+
+    pub const Result = union(enum) {
+        wip: WipContainerType,
+        existing: Index,
+    };
+};
+
+pub fn getUnion(
+    ip: *InternPool,
+    gpa: Allocator,
+    io: Io,
+    tid: Zcu.PerThread.Id,
+    un: Key.Union,
+) Allocator.Error!Index {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .un = un });
+    defer gop.deinit();
+    if (gop == .existing) return gop.existing;
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    assert(un.ty != .none);
+    assert(un.val != .none);
+    items.appendAssumeCapacity(.{
+        .tag = .union_value,
+        .data = try addExtra(extra, un),
+    });
+
+    return gop.put();
+}
+
 pub const TupleTypeInit = struct {
     types: []const Index,
     /// These elements may be `none`, indicating runtime-known.
@@ -9252,10 +8747,7 @@ pub const GetFuncTypeKey = struct {
     /// `null` means generic.
     cc: ?std.builtin.CallingConvention = .auto,
     is_var_args: bool = false,
-    is_generic: bool = false,
     is_noinline: bool = false,
-    section_is_generic: bool = false,
-    addrspace_is_generic: bool = false,
 };
 
 pub fn getFuncType(
@@ -9293,7 +8785,6 @@ pub fn getFuncType(
             .is_var_args = key.is_var_args,
             .has_comptime_bits = key.comptime_bits != 0,
             .has_noalias_bits = key.noalias_bits != 0,
-            .is_generic = key.is_generic,
             .is_noinline = key.is_noinline,
         },
     });
@@ -9480,7 +8971,6 @@ pub const GetFuncDeclIesKey = struct {
     /// null means generic.
     cc: ?std.builtin.CallingConvention,
     is_var_args: bool,
-    is_generic: bool,
     is_noinline: bool,
     zir_body_inst: TrackedInst.Index,
     lbrace_line: u32,
@@ -9564,7 +9054,6 @@ pub fn getFuncDeclIes(
             .is_var_args = key.is_var_args,
             .has_comptime_bits = key.comptime_bits != 0,
             .has_noalias_bits = key.noalias_bits != 0,
-            .is_generic = key.is_generic,
             .is_noinline = key.is_noinline,
         },
     });
@@ -9864,7 +9353,6 @@ fn getFuncInstanceIes(
             .is_var_args = false,
             .has_comptime_bits = false,
             .has_noalias_bits = arg.noalias_bits != 0,
-            .is_generic = false,
             .is_noinline = arg.is_noinline,
         },
     });
@@ -9972,444 +9460,6 @@ fn finishFuncInstance(
     ] = @intFromEnum(nav_index);
 }
 
-pub const EnumTypeInit = struct {
-    has_values: bool,
-    tag_mode: LoadedEnumType.TagMode,
-    fields_len: u32,
-    key: union(enum) {
-        declared: struct {
-            zir_index: TrackedInst.Index,
-            captures: []const CaptureValue,
-        },
-        declared_owned_captures: struct {
-            zir_index: TrackedInst.Index,
-            captures: CaptureValue.Slice,
-        },
-        reified: struct {
-            zir_index: TrackedInst.Index,
-            type_hash: u64,
-        },
-    },
-};
-
-pub const WipEnumType = struct {
-    tid: Zcu.PerThread.Id,
-    index: Index,
-    tag_ty_index: u32,
-    type_name_extra_index: u32,
-    namespace_extra_index: u32,
-    name_nav_extra_index: u32,
-    names_map: MapIndex,
-    names_start: u32,
-    values_map: OptionalMapIndex,
-    values_start: u32,
-
-    pub fn setName(
-        wip: WipEnumType,
-        ip: *InternPool,
-        type_name: NullTerminatedString,
-        /// This should be the `Nav` we are named after if we use the `.parent` name strategy; `.none` otherwise.
-        name_nav: Nav.Index.Optional,
-    ) void {
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        const extra_items = extra.view().items(.@"0");
-        extra_items[wip.type_name_extra_index] = @intFromEnum(type_name);
-        extra_items[wip.name_nav_extra_index] = @intFromEnum(name_nav);
-    }
-
-    pub fn prepare(
-        wip: WipEnumType,
-        ip: *InternPool,
-        namespace: NamespaceIndex,
-    ) void {
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        const extra_items = extra.view().items(.@"0");
-
-        extra_items[wip.namespace_extra_index] = @intFromEnum(namespace);
-    }
-
-    pub fn setTagTy(wip: WipEnumType, ip: *InternPool, tag_ty: Index) void {
-        assert(ip.isIntegerType(tag_ty));
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        extra.view().items(.@"0")[wip.tag_ty_index] = @intFromEnum(tag_ty);
-    }
-
-    pub const FieldConflict = struct {
-        kind: enum { name, value },
-        prev_field_idx: u32,
-    };
-
-    /// Returns the already-existing field with the same name or value, if any.
-    /// If the enum is automatially numbered, `value` must be `.none`.
-    /// Otherwise, the type of `value` must be the integer tag type of the enum.
-    pub fn nextField(wip: WipEnumType, ip: *InternPool, name: NullTerminatedString, value: Index) ?FieldConflict {
-        const unwrapped_index = wip.index.unwrap(ip);
-        const extra_list = ip.getLocalShared(unwrapped_index.tid).extra.acquire();
-        const extra_items = extra_list.view().items(.@"0");
-        if (ip.addFieldName(extra_list, wip.names_map, wip.names_start, name)) |conflict| {
-            return .{ .kind = .name, .prev_field_idx = conflict };
-        }
-        if (value == .none) {
-            assert(wip.values_map == .none);
-            return null;
-        }
-        assert(ip.typeOf(value) == @as(Index, @enumFromInt(extra_items[wip.tag_ty_index])));
-        const map = wip.values_map.unwrap().?.get(ip);
-        const field_index = map.count();
-        const indexes = extra_items[wip.values_start..][0..field_index];
-        const adapter: Index.Adapter = .{ .indexes = @ptrCast(indexes) };
-        const gop = map.getOrPutAssumeCapacityAdapted(value, adapter);
-        if (gop.found_existing) {
-            return .{ .kind = .value, .prev_field_idx = @intCast(gop.index) };
-        }
-        extra_items[wip.values_start + field_index] = @intFromEnum(value);
-        return null;
-    }
-
-    pub fn cancel(wip: WipEnumType, ip: *InternPool, tid: Zcu.PerThread.Id) void {
-        ip.remove(tid, wip.index);
-    }
-
-    pub const Result = union(enum) {
-        wip: WipEnumType,
-        existing: Index,
-    };
-};
-
-pub fn getEnumType(
-    ip: *InternPool,
-    gpa: Allocator,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    ini: EnumTypeInit,
-    /// If it is known that there is an existing type with this key which is outdated,
-    /// this is passed as `true`, and the type is replaced with one at a fresh index.
-    replace_existing: bool,
-) Allocator.Error!WipEnumType.Result {
-    const key: Key = .{ .enum_type = switch (ini.key) {
-        .declared => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .captures = .{ .external = d.captures },
-        } },
-        .declared_owned_captures => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .captures = .{ .owned = d.captures },
-        } },
-        .reified => |r| .{ .reified = .{
-            .zir_index = r.zir_index,
-            .type_hash = r.type_hash,
-        } },
-    } };
-    var gop = if (replace_existing)
-        ip.putKeyReplace(io, tid, key)
-    else
-        try ip.getOrPutKey(gpa, io, tid, key);
-    defer gop.deinit();
-    if (gop == .existing) return .{ .existing = gop.existing };
-
-    const local = ip.getLocal(tid);
-    const items = local.getMutableItems(gpa, io);
-    try items.ensureUnusedCapacity(1);
-    const extra = local.getMutableExtra(gpa, io);
-
-    const names_map = try ip.addMap(gpa, io, tid, ini.fields_len);
-    errdefer local.mutate.maps.len -= 1;
-
-    switch (ini.tag_mode) {
-        .auto => {
-            assert(!ini.has_values);
-            try extra.ensureUnusedCapacity(@typeInfo(EnumAuto).@"struct".fields.len +
-                // TODO: fmt bug
-                // zig fmt: off
-                switch (ini.key) {
-                    inline .declared, .declared_owned_captures => |d| d.captures.len,
-                    .reified => 2, // type_hash: PackedU64
-                } +
-                // zig fmt: on
-                ini.fields_len); // field types
-
-            const extra_index = addExtraAssumeCapacity(extra, EnumAuto{
-                .name = undefined, // set by `prepare`
-                .name_nav = undefined, // set by `prepare`
-                .captures_len = switch (ini.key) {
-                    inline .declared, .declared_owned_captures => |d| @intCast(d.captures.len),
-                    .reified => std.math.maxInt(u32),
-                },
-                .namespace = undefined, // set by `prepare`
-                .int_tag_type = .none, // set by `prepare`
-                .fields_len = ini.fields_len,
-                .names_map = names_map,
-                .zir_index = switch (ini.key) {
-                    inline else => |x| x.zir_index,
-                }.toOptional(),
-            });
-            items.appendAssumeCapacity(.{
-                .tag = .type_enum_auto,
-                .data = extra_index,
-            });
-            switch (ini.key) {
-                .declared => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}),
-                .declared_owned_captures => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures.get(ip))}),
-                .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-            }
-            const names_start = extra.mutate.len;
-            _ = extra.addManyAsSliceAssumeCapacity(ini.fields_len);
-            return .{ .wip = .{
-                .tid = tid,
-                .index = gop.put(),
-                .tag_ty_index = extra_index + std.meta.fieldIndex(EnumAuto, "int_tag_type").?,
-                .type_name_extra_index = extra_index + std.meta.fieldIndex(EnumAuto, "name").?,
-                .name_nav_extra_index = extra_index + std.meta.fieldIndex(EnumAuto, "name_nav").?,
-                .namespace_extra_index = extra_index + std.meta.fieldIndex(EnumAuto, "namespace").?,
-                .names_map = names_map,
-                .names_start = @intCast(names_start),
-                .values_map = .none,
-                .values_start = undefined,
-            } };
-        },
-        .explicit, .nonexhaustive => {
-            const values_map: OptionalMapIndex = if (!ini.has_values) .none else m: {
-                const values_map = try ip.addMap(gpa, io, tid, ini.fields_len);
-                break :m values_map.toOptional();
-            };
-            errdefer if (ini.has_values) {
-                local.mutate.maps.len -= 1;
-            };
-
-            try extra.ensureUnusedCapacity(@typeInfo(EnumExplicit).@"struct".fields.len +
-                // TODO: fmt bug
-                // zig fmt: off
-                switch (ini.key) {
-                    inline .declared, .declared_owned_captures => |d| d.captures.len,
-                    .reified => 2, // type_hash: PackedU64
-                } +
-                // zig fmt: on
-                ini.fields_len + // field types
-                ini.fields_len * @intFromBool(ini.has_values)); // field values
-
-            const extra_index = addExtraAssumeCapacity(extra, EnumExplicit{
-                .name = undefined, // set by `prepare`
-                .name_nav = undefined, // set by `prepare`
-                .captures_len = switch (ini.key) {
-                    inline .declared, .declared_owned_captures => |d| @intCast(d.captures.len),
-                    .reified => std.math.maxInt(u32),
-                },
-                .namespace = undefined, // set by `prepare`
-                .int_tag_type = .none, // set by `prepare`
-                .fields_len = ini.fields_len,
-                .names_map = names_map,
-                .values_map = values_map,
-                .zir_index = switch (ini.key) {
-                    inline else => |x| x.zir_index,
-                }.toOptional(),
-            });
-            items.appendAssumeCapacity(.{
-                .tag = switch (ini.tag_mode) {
-                    .auto => unreachable,
-                    .explicit => .type_enum_explicit,
-                    .nonexhaustive => .type_enum_nonexhaustive,
-                },
-                .data = extra_index,
-            });
-            switch (ini.key) {
-                .declared => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}),
-                .declared_owned_captures => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures.get(ip))}),
-                .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-            }
-            const names_start = extra.mutate.len;
-            _ = extra.addManyAsSliceAssumeCapacity(ini.fields_len);
-            const values_start = extra.mutate.len;
-            if (ini.has_values) {
-                _ = extra.addManyAsSliceAssumeCapacity(ini.fields_len);
-            }
-            return .{ .wip = .{
-                .tid = tid,
-                .index = gop.put(),
-                .tag_ty_index = extra_index + std.meta.fieldIndex(EnumExplicit, "int_tag_type").?,
-                .type_name_extra_index = extra_index + std.meta.fieldIndex(EnumExplicit, "name").?,
-                .name_nav_extra_index = extra_index + std.meta.fieldIndex(EnumExplicit, "name_nav").?,
-                .namespace_extra_index = extra_index + std.meta.fieldIndex(EnumExplicit, "namespace").?,
-                .names_map = names_map,
-                .names_start = @intCast(names_start),
-                .values_map = values_map,
-                .values_start = @intCast(values_start),
-            } };
-        },
-    }
-}
-
-const GeneratedTagEnumTypeInit = struct {
-    name: NullTerminatedString,
-    owner_union_ty: Index,
-    tag_ty: Index,
-    names: []const NullTerminatedString,
-    values: []const Index,
-    tag_mode: LoadedEnumType.TagMode,
-    parent_namespace: NamespaceIndex,
-};
-
-/// Creates an enum type which was automatically-generated as the tag type of a
-/// `union` with no explicit tag type. Since this is only called once per union
-/// type, it asserts that no matching type yet exists.
-pub fn getGeneratedTagEnumType(
-    ip: *InternPool,
-    gpa: Allocator,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    ini: GeneratedTagEnumTypeInit,
-) Allocator.Error!Index {
-    assert(ip.isUnion(ini.owner_union_ty));
-    assert(ip.isIntegerType(ini.tag_ty));
-    for (ini.values) |val| assert(ip.typeOf(val) == ini.tag_ty);
-
-    const local = ip.getLocal(tid);
-    const items = local.getMutableItems(gpa, io);
-    try items.ensureUnusedCapacity(1);
-    const extra = local.getMutableExtra(gpa, io);
-
-    const names_map = try ip.addMap(gpa, io, tid, ini.names.len);
-    errdefer local.mutate.maps.len -= 1;
-    ip.addStringsToMap(names_map, ini.names);
-
-    const fields_len: u32 = @intCast(ini.names.len);
-
-    // Predict the index the enum will live at so we can construct the namespace before releasing the shard's mutex.
-    const enum_index = Index.Unwrapped.wrap(.{
-        .tid = tid,
-        .index = items.mutate.len,
-    }, ip);
-    const parent_namespace = ip.namespacePtr(ini.parent_namespace);
-    const namespace = try ip.createNamespace(gpa, io, tid, .{
-        .parent = ini.parent_namespace.toOptional(),
-        .owner_type = enum_index,
-        .file_scope = parent_namespace.file_scope,
-        .generation = parent_namespace.generation,
-    });
-    errdefer ip.destroyNamespace(tid, namespace);
-
-    const prev_extra_len = extra.mutate.len;
-    switch (ini.tag_mode) {
-        .auto => {
-            try extra.ensureUnusedCapacity(@typeInfo(EnumAuto).@"struct".fields.len +
-                1 + // owner_union
-                fields_len); // field names
-            items.appendAssumeCapacity(.{
-                .tag = .type_enum_auto,
-                .data = addExtraAssumeCapacity(extra, EnumAuto{
-                    .name = ini.name,
-                    .name_nav = .none,
-                    .captures_len = 0,
-                    .namespace = namespace,
-                    .int_tag_type = ini.tag_ty,
-                    .fields_len = fields_len,
-                    .names_map = names_map,
-                    .zir_index = .none,
-                }),
-            });
-            extra.appendAssumeCapacity(.{@intFromEnum(ini.owner_union_ty)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(ini.names)});
-        },
-        .explicit, .nonexhaustive => {
-            try extra.ensureUnusedCapacity(@typeInfo(EnumExplicit).@"struct".fields.len +
-                1 + // owner_union
-                fields_len + // field names
-                ini.values.len); // field values
-
-            const values_map: OptionalMapIndex = if (ini.values.len != 0) m: {
-                const map = try ip.addMap(gpa, io, tid, ini.values.len);
-                ip.addIndexesToMap(map, ini.values);
-                break :m map.toOptional();
-            } else .none;
-            // We don't clean up the values map on error!
-            errdefer @compileError("error path leaks values_map");
-
-            items.appendAssumeCapacity(.{
-                .tag = switch (ini.tag_mode) {
-                    .explicit => .type_enum_explicit,
-                    .nonexhaustive => .type_enum_nonexhaustive,
-                    .auto => unreachable,
-                },
-                .data = addExtraAssumeCapacity(extra, EnumExplicit{
-                    .name = ini.name,
-                    .name_nav = .none,
-                    .captures_len = 0,
-                    .namespace = namespace,
-                    .int_tag_type = ini.tag_ty,
-                    .fields_len = fields_len,
-                    .names_map = names_map,
-                    .values_map = values_map,
-                    .zir_index = .none,
-                }),
-            });
-            extra.appendAssumeCapacity(.{@intFromEnum(ini.owner_union_ty)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(ini.names)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(ini.values)});
-        },
-    }
-    errdefer extra.mutate.len = prev_extra_len;
-    errdefer switch (ini.tag_mode) {
-        .auto => {},
-        .explicit, .nonexhaustive => if (ini.values.len != 0) {
-            local.mutate.maps.len -= 1;
-        },
-    };
-
-    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .enum_type = .{
-        .generated_tag = .{ .union_type = ini.owner_union_ty },
-    } });
-    defer gop.deinit();
-    assert(gop.put() == enum_index);
-    return enum_index;
-}
-
-pub const OpaqueTypeInit = struct {
-    zir_index: TrackedInst.Index,
-    captures: []const CaptureValue,
-};
-
-pub fn getOpaqueType(
-    ip: *InternPool,
-    gpa: Allocator,
-    io: Io,
-    tid: Zcu.PerThread.Id,
-    ini: OpaqueTypeInit,
-) Allocator.Error!WipNamespaceType.Result {
-    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .opaque_type = .{ .declared = .{
-        .zir_index = ini.zir_index,
-        .captures = .{ .external = ini.captures },
-    } } });
-    defer gop.deinit();
-    if (gop == .existing) return .{ .existing = gop.existing };
-
-    const local = ip.getLocal(tid);
-    const items = local.getMutableItems(gpa, io);
-    const extra = local.getMutableExtra(gpa, io);
-    try items.ensureUnusedCapacity(1);
-
-    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeOpaque).@"struct".fields.len + ini.captures.len);
-    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeOpaque{
-        .name = undefined, // set by `finish`
-        .name_nav = undefined, // set by `finish`
-        .namespace = undefined, // set by `finish`
-        .zir_index = ini.zir_index,
-        .captures_len = @intCast(ini.captures.len),
-    });
-    items.appendAssumeCapacity(.{
-        .tag = .type_opaque,
-        .data = extra_index,
-    });
-    extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)});
-    return .{
-        .wip = .{
-            .tid = tid,
-            .index = gop.put(),
-            .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name").?,
-            .name_nav_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name_nav").?,
-            .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "namespace").?,
-        },
-    };
-}
-
 pub fn getIfExists(ip: *const InternPool, key: Key) ?Index {
     const full_hash = key.hash64(ip);
     const hash: u32 = @truncate(full_hash >> 32);
@@ -10534,6 +9584,9 @@ fn addExtraAssumeCapacity(extra: Local.Extra.Mutable, item: anytype) u32 {
             TrackedInst.Index,
             TrackedInst.Index.Optional,
             ComptimeAllocIndex,
+            @FieldType(Tag.TypeStructPacked, "captures_len"),
+            @FieldType(Tag.TypeUnionPacked, "captures_len"),
+            @FieldType(Tag.TypeEnum, "captures_len"),
             => @intFromEnum(@field(item, field.name)),
 
             u32,
@@ -10545,7 +9598,6 @@ fn addExtraAssumeCapacity(extra: Local.Extra.Mutable, item: anytype) u32 {
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
-            Tag.TypeStructPacked.Flags,
             => @bitCast(@field(item, field.name)),
 
             else => @compileError("bad field type: " ++ @typeName(field.type)),
@@ -10597,6 +9649,9 @@ fn extraDataTrail(extra: Local.Extra, comptime T: type, index: u32) struct { dat
             TrackedInst.Index,
             TrackedInst.Index.Optional,
             ComptimeAllocIndex,
+            @FieldType(Tag.TypeStructPacked, "captures_len"),
+            @FieldType(Tag.TypeUnionPacked, "captures_len"),
+            @FieldType(Tag.TypeEnum, "captures_len"),
             => @enumFromInt(extra_item),
 
             u32,
@@ -10607,7 +9662,6 @@ fn extraDataTrail(extra: Local.Extra, comptime T: type, index: u32) struct { dat
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
-            Tag.TypeStructPacked.Flags,
             FuncAnalysis,
             => @bitCast(extra_item),
 
@@ -10786,7 +9840,7 @@ pub fn getCoerced(
         .int => |int| switch (ip.indexToKey(new_ty)) {
             .enum_type => return ip.get(gpa, io, tid, .{ .enum_tag = .{
                 .ty = new_ty,
-                .int = try ip.getCoerced(gpa, io, tid, val, ip.loadEnumType(new_ty).tag_ty),
+                .int = try ip.getCoerced(gpa, io, tid, val, ip.loadEnumType(new_ty).int_tag_type),
             } }),
             .ptr_type => switch (int.storage) {
                 inline .u64, .i64 => |int_val| return ip.get(gpa, io, tid, .{ .ptr = .{
@@ -10795,7 +9849,6 @@ pub fn getCoerced(
                     .byte_offset = @intCast(int_val),
                 } }),
                 .big_int => unreachable, // must be a usize
-                .lazy_align, .lazy_size => {},
             },
             else => if (ip.isIntegerType(new_ty))
                 return ip.getCoercedInts(gpa, io, tid, int, new_ty),
@@ -10825,11 +9878,11 @@ pub fn getCoerced(
                 const index = enum_type.nameIndex(ip, enum_literal).?;
                 return ip.get(gpa, io, tid, .{ .enum_tag = .{
                     .ty = new_ty,
-                    .int = if (enum_type.values.len != 0)
-                        enum_type.values.get(ip)[index]
+                    .int = if (enum_type.field_values.len != 0)
+                        enum_type.field_values.get(ip)[index]
                     else
                         try ip.get(gpa, io, tid, .{ .int = .{
-                            .ty = enum_type.tag_ty,
+                            .ty = enum_type.int_tag_type,
                             .storage = .{ .u64 = index },
                         } }),
                 } });
@@ -11266,92 +10319,10 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                     break :b @sizeOf(Tag.ErrorSet) + (@sizeOf(u32) * info.names_len);
                 },
                 .type_inferred_error_set => 0,
-                .type_enum_explicit, .type_enum_nonexhaustive => b: {
-                    const info = extraData(extra_list, EnumExplicit, data);
-                    var ints = @typeInfo(EnumExplicit).@"struct".fields.len;
-                    if (info.zir_index == .none) ints += 1;
-                    ints += if (info.captures_len != std.math.maxInt(u32))
-                        info.captures_len
-                    else
-                        @typeInfo(PackedU64).@"struct".fields.len;
-                    ints += info.fields_len;
-                    if (info.values_map != .none) ints += info.fields_len;
-                    break :b @sizeOf(u32) * ints;
-                },
-                .type_enum_auto => b: {
-                    const info = extraData(extra_list, EnumAuto, data);
-                    const ints = @typeInfo(EnumAuto).@"struct".fields.len + info.captures_len + info.fields_len;
-                    break :b @sizeOf(u32) * ints;
-                },
-                .type_opaque => b: {
-                    const info = extraData(extra_list, Tag.TypeOpaque, data);
-                    const ints = @typeInfo(Tag.TypeOpaque).@"struct".fields.len + info.captures_len;
-                    break :b @sizeOf(u32) * ints;
-                },
-                .type_struct => b: {
-                    const extra = extraDataTrail(extra_list, Tag.TypeStruct, data);
-                    const info = extra.data;
-                    var ints: usize = @typeInfo(Tag.TypeStruct).@"struct".fields.len;
-                    if (info.flags.any_captures) {
-                        const captures_len = extra_items[extra.end];
-                        ints += 1 + captures_len;
-                    }
-                    ints += info.fields_len; // types
-                    ints += 1; // names_map
-                    ints += info.fields_len; // names
-                    if (info.flags.any_default_inits)
-                        ints += info.fields_len; // inits
-                    if (info.flags.any_aligned_fields)
-                        ints += (info.fields_len + 3) / 4; // aligns
-                    if (info.flags.any_comptime_fields)
-                        ints += (info.fields_len + 31) / 32; // comptime bits
-                    if (!info.flags.is_extern)
-                        ints += info.fields_len; // runtime order
-                    ints += info.fields_len; // offsets
-                    break :b @sizeOf(u32) * ints;
-                },
-                .type_struct_packed => b: {
-                    const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
-                    const captures_len = if (extra.data.flags.any_captures)
-                        extra_items[extra.end]
-                    else
-                        0;
-                    break :b @sizeOf(u32) * (@typeInfo(Tag.TypeStructPacked).@"struct".fields.len +
-                        @intFromBool(extra.data.flags.any_captures) + captures_len +
-                        extra.data.fields_len * 2);
-                },
-                .type_struct_packed_inits => b: {
-                    const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
-                    const captures_len = if (extra.data.flags.any_captures)
-                        extra_items[extra.end]
-                    else
-                        0;
-                    break :b @sizeOf(u32) * (@typeInfo(Tag.TypeStructPacked).@"struct".fields.len +
-                        @intFromBool(extra.data.flags.any_captures) + captures_len +
-                        extra.data.fields_len * 3);
-                },
                 .type_tuple => b: {
                     const info = extraData(extra_list, TypeTuple, data);
                     break :b @sizeOf(TypeTuple) + (@sizeOf(u32) * 2 * info.fields_len);
                 },
-
-                .type_union => b: {
-                    const extra = extraDataTrail(extra_list, Tag.TypeUnion, data);
-                    const captures_len = if (extra.data.flags.any_captures)
-                        extra_items[extra.end]
-                    else
-                        0;
-                    const per_field = @sizeOf(u32); // field type
-                    // 1 byte per field for alignment, rounded up to the nearest 4 bytes
-                    const alignments = if (extra.data.flags.any_aligned_fields)
-                        ((extra.data.fields_len + 3) / 4) * 4
-                    else
-                        0;
-                    break :b @sizeOf(Tag.TypeUnion) +
-                        4 * (@intFromBool(extra.data.flags.any_captures) + captures_len) +
-                        (extra.data.fields_len * per_field) + alignments;
-                },
-
                 .type_function => b: {
                     const info = extraData(extra_list, Tag.TypeFunction, data);
                     break :b @sizeOf(Tag.TypeFunction) +
@@ -11360,6 +10331,127 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                         (@as(u32, 4) * @intFromBool(info.flags.has_noalias_bits));
                 },
 
+                .type_struct => b: {
+                    var n: usize = @typeInfo(Tag.TypeStruct).@"struct".fields.len;
+                    const extra = extraDataTrail(extra_list, Tag.TypeStruct, data);
+                    switch (extra.data.flags.any_captures) {
+                        .reified => n += 2, // type_hash: PackedU64
+                        .true => {
+                            n += 1; // captures_len: u32
+                            n += extra_items[extra.end]; // capture: CaptureValue
+                        },
+                        .false => {},
+                    }
+                    n += extra.data.fields_len; // field_name: NullTerminatedString
+                    n += extra.data.fields_len; // field_type: Index
+                    if (extra.data.flags.any_field_defaults) {
+                        n += extra.data.fields_len; // field_default: Index
+                    }
+                    if (extra.data.flags.any_field_aligns) {
+                        n += (extra.data.fields_len + 3) / 4; // field_align: Alignment
+                    }
+                    if (extra.data.flags.any_comptime_fields) {
+                        n += (extra.data.fields_len + 31) / 32; // field_is_comptime_bits: u32
+                    }
+                    if (extra.data.flags.layout == .auto) {
+                        n += extra.data.fields_len; // field_runtime_order: RuntimeOrder
+                    }
+                    n += extra.data.fields_len; // field_offset: u32
+                    break :b n * @sizeOf(u32);
+                },
+                .type_struct_packed_auto, .type_struct_packed_explicit => b: {
+                    var n: usize = @typeInfo(Tag.TypeStructPacked).@"struct".fields.len;
+                    const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
+                    switch (extra.data.captures_len) {
+                        .reified => n += 2, // type_hash: PackedU64
+                        _ => |len| n += @intFromEnum(len), // capture: CaptureValue
+                    }
+                    n += extra.data.fields_len; // field_name: NullTerminatedString
+                    n += extra.data.fields_len; // field_type: Index
+                    break :b n * @sizeOf(u32);
+                },
+                .type_struct_packed_auto_defaults, .type_struct_packed_explicit_defaults => b: {
+                    var n: usize = @typeInfo(Tag.TypeStructPacked).@"struct".fields.len;
+                    const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
+                    switch (extra.data.captures_len) {
+                        .reified => n += 2, // type_hash: PackedU64
+                        _ => |len| n += @intFromEnum(len), // capture: CaptureValue
+                    }
+                    n += extra.data.fields_len; // field_name: NullTerminatedString
+                    n += extra.data.fields_len; // field_type: Index
+                    n += extra.data.fields_len; // field_default: Index
+                    break :b n * @sizeOf(u32);
+                },
+                .type_union => b: {
+                    var n: usize = @typeInfo(Tag.TypeUnion).@"struct".fields.len;
+                    const extra = extraDataTrail(extra_list, Tag.TypeUnion, data);
+                    switch (extra.data.flags.any_captures) {
+                        .reified => n += 2, // type_hash: PackedU64
+                        .true => {
+                            n += 1; // captures_len: u32
+                            n += extra_items[extra.end]; // capture: CaptureValue
+                        },
+                        .false => {},
+                    }
+                    n += extra.data.fields_len; // field_type: Index
+                    if (extra.data.flags.any_field_aligns) {
+                        n += (extra.data.fields_len + 3) / 4; // field_align: Alignment
+                    }
+                    break :b n * @sizeOf(u32);
+                },
+                .type_union_packed_auto, .type_union_packed_explicit => b: {
+                    var n: usize = @typeInfo(Tag.TypeUnionPacked).@"struct".fields.len;
+                    const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, data);
+                    switch (extra.data.captures_len) {
+                        .reified => n += 2, // type_hash: PackedU64
+                        _ => |len| n += @intFromEnum(len), // capture: CaptureValue
+                    }
+                    n += extra.data.fields_len; // field_type: Index
+                    break :b n * @sizeOf(u32);
+                },
+                .type_enum_auto => b: {
+                    var n: usize = @typeInfo(Tag.TypeEnum).@"struct".fields.len;
+                    const extra = extraData(extra_list, Tag.TypeEnum, data);
+                    switch (extra.captures_len) {
+                        .generated_union_tag => n += 1, // owner_union: Index
+                        .reified => {
+                            n += 1; // zir_index: TrackedInst.Index,
+                            n += 2; // type_hash: PackedU64
+                        },
+                        _ => |len| {
+                            n += 1; // zir_index: TrackedInst.Index,
+                            n += @intFromEnum(len); // capture: CaptureValue
+                        },
+                    }
+                    n += extra.fields_len; // field_name: NullTerminatedString
+                    break :b n * @sizeOf(u32);
+                },
+                .type_enum_explicit, .type_enum_nonexhaustive => b: {
+                    var n: usize = @typeInfo(Tag.TypeEnum).@"struct".fields.len;
+                    const extra = extraData(extra_list, Tag.TypeEnum, data);
+                    switch (extra.captures_len) {
+                        .generated_union_tag => n += 1, // owner_union: Index
+                        .reified => {
+                            n += 1; // zir_index: TrackedInst.Index,
+                            n += 2; // type_hash: PackedU64
+                        },
+                        _ => |len| {
+                            n += 1; // zir_index: TrackedInst.Index,
+                            n += @intFromEnum(len); // capture: CaptureValue
+                        },
+                    }
+                    n += 1; // field_value_map: MapIndex
+                    n += extra.fields_len; // field_name: NullTerminatedString
+                    n += extra.fields_len; // field_value: Index
+                    break :b n * @sizeOf(u32);
+                },
+                .type_opaque => b: {
+                    var n: usize = @typeInfo(Tag.TypeEnum).@"struct".fields.len;
+                    const extra = extraData(extra_list, Tag.TypeOpaque, data);
+                    n += extra.captures_len; // capture: CaptureValue
+                    break :b n * @sizeOf(u32);
+                },
+
                 .undef => 0,
                 .simple_type => 0,
                 .simple_value => 0,
@@ -11393,8 +10485,6 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                     break :b @sizeOf(Int) + int.limbs_len * @sizeOf(Limb);
                 },
 
-                .int_lazy_align, .int_lazy_size => @sizeOf(IntLazy),
-
                 .error_set_error, .error_union_error => @sizeOf(Key.Error),
                 .error_union_payload => @sizeOf(Tag.TypeValue),
                 .enum_literal => 0,
@@ -11484,16 +10574,20 @@ fn dumpAllFallible(ip: *const InternPool, w: *Io.Writer) anyerror!void {
                 .type_anyerror_union,
                 .type_error_set,
                 .type_inferred_error_set,
+                .type_tuple,
+                .type_function,
+                .type_struct,
+                .type_struct_packed_auto,
+                .type_struct_packed_explicit,
+                .type_struct_packed_auto_defaults,
+                .type_struct_packed_explicit_defaults,
+                .type_union,
+                .type_union_packed_auto,
+                .type_union_packed_explicit,
+                .type_enum_auto,
                 .type_enum_explicit,
                 .type_enum_nonexhaustive,
-                .type_enum_auto,
                 .type_opaque,
-                .type_struct,
-                .type_struct_packed,
-                .type_struct_packed_inits,
-                .type_tuple,
-                .type_union,
-                .type_function,
                 .undef,
                 .ptr_nav,
                 .ptr_comptime_alloc,
@@ -11517,8 +10611,6 @@ fn dumpAllFallible(ip: *const InternPool, w: *Io.Writer) anyerror!void {
                 .int_small,
                 .int_positive,
                 .int_negative,
-                .int_lazy_align,
-                .int_lazy_size,
                 .error_set_error,
                 .error_union_error,
                 .error_union_payload,
@@ -12245,16 +11337,20 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
                 .type_anyerror_union,
                 .type_error_set,
                 .type_inferred_error_set,
+                .type_tuple,
+                .type_function,
+                .type_struct,
+                .type_struct_packed_auto,
+                .type_struct_packed_explicit,
+                .type_struct_packed_auto_defaults,
+                .type_struct_packed_explicit_defaults,
+                .type_union,
+                .type_union_packed_auto,
+                .type_union_packed_explicit,
                 .type_enum_auto,
                 .type_enum_explicit,
                 .type_enum_nonexhaustive,
                 .type_opaque,
-                .type_struct,
-                .type_struct_packed,
-                .type_struct_packed_inits,
-                .type_tuple,
-                .type_union,
-                .type_function,
                 => .type_type,
 
                 .undef,
@@ -12278,8 +11374,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
                 .opt_payload,
                 .error_union_payload,
                 .int_small,
-                .int_lazy_align,
-                .int_lazy_size,
                 .error_set_error,
                 .error_union_error,
                 .enum_tag,
@@ -12613,22 +11707,26 @@ pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId {
             .type_inferred_error_set,
             => .error_set,
 
+            .simple_type => unreachable, // handled via Index tag above
+
+            .type_tuple => .@"struct",
+
+            .type_struct,
+            .type_struct_packed_auto,
+            .type_struct_packed_explicit,
+            .type_struct_packed_auto_defaults,
+            .type_struct_packed_explicit_defaults,
+            => .@"struct",
+            .type_union,
+            .type_union_packed_auto,
+            .type_union_packed_explicit,
+            => .@"union",
             .type_enum_auto,
             .type_enum_explicit,
             .type_enum_nonexhaustive,
             => .@"enum",
-
-            .simple_type => unreachable, // handled via Index tag above
-
-            .type_opaque => .@"opaque",
-
-            .type_struct,
-            .type_struct_packed,
-            .type_struct_packed_inits,
-            .type_tuple,
-            => .@"struct",
-
-            .type_union => .@"union",
+            .type_opaque,
+            => .@"opaque",
 
             .type_function => .@"fn",
 
@@ -12658,8 +11756,6 @@ pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId {
             .int_small,
             .int_positive,
             .int_negative,
-            .int_lazy_align,
-            .int_lazy_size,
             .error_set_error,
             .error_union_error,
             .error_union_payload,
@@ -13169,3 +12265,113 @@ const PackedCallingConvention = packed struct(u18) {
         };
     }
 };
+
+/// Asserts that `struct_type` is a non-packed struct type.
+/// As well as calling this function, the caller must also populate these arrays:
+/// * `field_types`
+/// * `field_aligns`
+/// * `field_runtime_order`
+/// * `field_offsets`
+pub fn resolveStructLayout(
+    ip: *InternPool,
+    io: Io,
+    struct_type: Index,
+    size: u32,
+    alignment: Alignment,
+    has_no_possible_value: bool,
+    has_one_possible_value: bool,
+    comptime_only: bool,
+) void {
+    const unwrapped_index = struct_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    assert(item.tag == .type_struct);
+
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "size").?] = size;
+    const flags: *Tag.TypeStruct.Flags = @ptrCast(&extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?]);
+    flags.has_no_possible_value = has_no_possible_value;
+    flags.has_one_possible_value = has_one_possible_value;
+    flags.comptime_only = comptime_only;
+    flags.alignment = alignment;
+}
+
+/// Asserts that `union_type` is a non-packed union type.
+/// As well as calling this function, the caller must also populate these arrays:
+/// * `field_types`
+/// * `field_aligns`
+pub fn resolveUnionLayout(
+    ip: *InternPool,
+    io: Io,
+    union_type: Index,
+    size: u32,
+    padding: u32,
+    alignment: Alignment,
+    has_no_possible_value: bool,
+    has_one_possible_value: bool,
+    comptime_only: bool,
+) void {
+    const unwrapped_index = union_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    assert(item.tag == .type_union);
+
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "size").?] = size;
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "padding").?] = padding;
+    const flags: *Tag.TypeUnion.Flags = @ptrCast(&extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "flags").?]);
+    flags.has_no_possible_value = has_no_possible_value;
+    flags.has_one_possible_value = has_one_possible_value;
+    flags.comptime_only = comptime_only;
+    flags.alignment = alignment;
+}
+
+/// Asserts that `struct_type` is a packed struct type.
+pub fn resolvePackedStructBackingInt(ip: *InternPool, io: Io, struct_type: Index, backing_int_type: Index) void {
+    const unwrapped_index = struct_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    switch (item.tag) {
+        .type_struct_packed_auto,
+        .type_struct_packed_explicit,
+        .type_struct_packed_auto_defaults,
+        .type_struct_packed_explicit_defaults,
+        => {},
+        else => unreachable,
+    }
+
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "backing_int_type").?] = @intFromEnum(backing_int_type);
+}
+
+/// Asserts that `union_type` is a packed union type.
+pub fn resolvePackedUnionBackingInt(ip: *InternPool, io: Io, union_type: Index, backing_int_type: Index) void {
+    const unwrapped_index = union_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    switch (item.tag) {
+        .type_union_packed_auto,
+        .type_union_packed_explicit,
+        => {},
+        else => unreachable,
+    }
+
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "backing_int_type").?] = @intFromEnum(backing_int_type);
+}
diff --git a/src/Sema.zig b/src/Sema.zig
index 58fa1af124239ff05093bc9cf857a16f36de09e4..55fb718a45b989ecac821626638dde9a98ab99b5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -173,13 +173,17 @@ const ComptimeAlloc = struct {
     runtime_index: RuntimeIndex,
 };
 
+/// Asserts that `ty` is not an OPV type.
 /// `src` may be `null` if `is_const` will be set.
 fn newComptimeAlloc(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type, alignment: Alignment) !ComptimeAllocIndex {
     const pt = sema.pt;
-    const init_val = try sema.typeHasOnePossibleValue(ty) orelse try pt.undefValue(ty);
+
+    // Explicit guard because this call mutates the InternPool so cannot be optimized out.
+    if (std.debug.runtime_safety) assert(ty.onePossibleValue(pt) catch @panic("") == null);
+
     const idx = sema.comptime_allocs.items.len;
     try sema.comptime_allocs.append(sema.gpa, .{
-        .val = .{ .interned = init_val.toIntern() },
+        .val = .{ .interned = (try pt.undefValue(ty)).toIntern() },
         .is_const = false,
         .src = src,
         .alignment = alignment,
@@ -1382,10 +1386,10 @@ fn analyzeBodyInner(
                 const extended = datas[@intFromEnum(inst)].extended;
                 break :ext switch (extended.opcode) {
                     // zig fmt: off
-                    .struct_decl        => try sema.zirStructDecl(        block, extended, inst),
-                    .enum_decl          => try sema.zirEnumDecl(          block, extended, inst),
-                    .union_decl         => try sema.zirUnionDecl(         block, extended, inst),
-                    .opaque_decl        => try sema.zirOpaqueDecl(        block, extended, inst),
+                    .struct_decl        => try sema.zirStructDecl(        block, inst),
+                    .enum_decl          => try sema.zirEnumDecl(          block, inst),
+                    .union_decl         => try sema.zirUnionDecl(         block, inst),
+                    .opaque_decl        => try sema.zirOpaqueDecl(        block, inst),
                     .tuple_decl         => try sema.zirTupleDecl(         block, extended),
                     .this               => try sema.zirThis(              block, extended),
                     .ret_addr           => try sema.zirRetAddr(           block, extended),
@@ -1993,6 +1997,24 @@ fn analyzeBodyInner(
             assert(sema.isNoReturn(block.instructions.items[block.instructions.items.len - 1].toRef()));
             break;
         }
+        // <MLUGG TODO REMOVE THIS BLOCK, SILLY OPV CHECK>
+        if (air_inst.toIndex()) |air_inst_index| {
+            switch (sema.air_instructions.items(.tag)[@intFromEnum(air_inst_index)]) {
+                .inferred_alloc, .inferred_alloc_comptime => {},
+                else => {
+                    assert(sema.typeOf(air_inst).onePossibleValue(pt) catch @panic("") == null);
+                    sema.typeOf(air_inst).assertHasLayout(zcu);
+                },
+            }
+        } else {
+            switch (tags[@intFromEnum(inst)]) {
+                // MLUGG TODO: do we actually *want* this exception? we could arguably simplify things without it
+                // e.g. analyzeNavVal could stop doing ensureLayoutResolved in most cases (`extern` is an exception) and instead do `assertHasLayout`
+                .func, .func_inferred, .func_fancy => {}, // exception: we're in a func decl, layout will get resolved in a bit by `analyzeNavVal`
+                else => sema.typeOf(air_inst).assertHasLayout(zcu),
+            }
+        }
+        // </MLUGG TODO REMOVE THIS BLOCK, SILLY OPV CHECK>
         map.putAssumeCapacity(inst, air_inst);
         i += 1;
     }
@@ -2190,7 +2212,7 @@ fn genericPoisonReason(sema: *Sema, block: *Block, ref: Zir.Inst.Ref) GenericPoi
     }
 }
 
-fn analyzeAsType(
+pub fn analyzeAsType(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
@@ -2227,7 +2249,6 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
 
     // var st: StackTrace = undefined;
     const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
-    try stack_trace_ty.resolveFields(pt);
     const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty));
 
     // st.instruction_addresses = &addrs;
@@ -2247,14 +2268,11 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
 }
 
 /// Return the Value corresponding to a given AIR ref, or `null` if it refers to a runtime value.
-fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
+/// TODO MLUGG: remove the error union return!
+fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) error{}!?Value {
     const zcu = sema.pt.zcu;
     assert(inst != .none);
 
-    if (try sema.typeHasOnePossibleValue(sema.typeOf(inst))) |opv| {
-        return opv;
-    }
-
     if (inst.toInterned()) |ip_index| {
         const val: Value = .fromInterned(ip_index);
         assert(val.getVariable(zcu) == null);
@@ -2267,12 +2285,18 @@ fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
             .inferred_alloc_comptime => unreachable, // assertion failure
             else => {},
         }
+        // Assert that the type is not OPV -- if it was, the value would have been comptime-known.
+        // Explicit guard because this could add to the InternPool so cannot be optimized away.
+        if (std.debug.runtime_safety) {
+            const opv = sema.typeOf(inst).onePossibleValue(sema.pt) catch @panic("oom in assert");
+            assert(opv == null);
+        }
         return null;
     }
 }
 
 /// Like `resolveValue`, but emits an error if the value is not comptime-known.
-fn resolveConstValue(
+pub fn resolveConstValue(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
@@ -2301,7 +2325,7 @@ fn resolveDefinedValue(
 }
 
 /// Like `resolveValue`, but emits an error if the value is not comptime-known or is undefined.
-fn resolveConstDefinedValue(
+pub fn resolveConstDefinedValue(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
@@ -2315,11 +2339,6 @@ fn resolveConstDefinedValue(
     return val;
 }
 
-/// Like `resolveValue`, but recursively resolves lazy values before returning.
-fn resolveValueResolveLazy(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
-    return try sema.resolveLazyValue((try sema.resolveValue(inst)) orelse return null);
-}
-
 /// Value Tag may be `undef` or `variable`.
 pub fn resolveFinalDeclValue(
     sema: *Sema,
@@ -2439,13 +2458,14 @@ fn failWithExpectedOptionalType(sema: *Sema, block: *Block, src: LazySrcLoc, non
 
 fn failWithArrayInitNotSupported(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     const msg = msg: {
         const msg = try sema.errMsg(src, "type '{f}' does not support array initialization syntax", .{
             ty.fmt(pt),
         });
         errdefer msg.destroy(sema.gpa);
-        if (ty.isSlice(pt.zcu)) {
-            try sema.errNote(src, msg, "inferred array length is specified with an underscore: '[_]{f}'", .{ty.elemType2(pt.zcu).fmt(pt)});
+        if (ty.isSlice(zcu)) {
+            try sema.errNote(src, msg, "inferred array length is specified with an underscore: '[_]{f}'", .{ty.childType(zcu).fmt(pt)});
         }
         break :msg msg;
     };
@@ -2644,7 +2664,7 @@ pub fn fail(
     src: LazySrcLoc,
     comptime format: []const u8,
     args: anytype,
-) CompileError {
+) SemaError {
     const err_msg = try sema.errMsg(src, format, args);
     inline for (args) |arg| {
         if (@TypeOf(arg) == Type.Formatter) {
@@ -2798,27 +2818,26 @@ fn analyzeAsInt(
 ) !u64 {
     const coerced = try sema.coerce(block, dest_ty, air_ref, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
-    return try val.toUnsignedIntSema(sema.pt);
+    return val.toUnsignedInt(sema.pt.zcu);
 }
 
 fn analyzeValueAsCallconv(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
-    unresolved_val: Value,
+    val: Value,
 ) !std.builtin.CallingConvention {
-    return interpretBuiltinType(sema, block, src, unresolved_val, std.builtin.CallingConvention);
+    return interpretBuiltinType(sema, block, src, val, std.builtin.CallingConvention);
 }
 
 fn interpretBuiltinType(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
-    unresolved_val: Value,
+    val: Value,
     comptime T: type,
 ) !T {
-    const resolved_val = try sema.resolveLazyValue(unresolved_val);
-    return resolved_val.interpret(T, sema.pt) catch |err| switch (err) {
+    return val.interpret(T, sema.pt) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
         error.UndefinedValue => return sema.failWithUseOfUndef(block, src, null),
         error.TypeMismatch => @panic("std.builtin is corrupt"),
@@ -2913,7 +2932,13 @@ fn validateTupleFieldType(
 
 /// Given a ZIR extra index which points to a list of `Zir.Inst.Capture`,
 /// resolves this into a list of `InternPool.CaptureValue` allocated by `arena`.
-fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: usize, captures_len: u32) ![]InternPool.CaptureValue {
+fn getCaptures(
+    sema: *Sema,
+    block: *Block,
+    type_src: LazySrcLoc,
+    zir_captures: []const Zir.Inst.Capture,
+    zir_capture_names: []const Zir.NullTerminatedString,
+) ![]InternPool.CaptureValue {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -2924,41 +2949,38 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
     const parent_ty: Type = .fromInterned(zcu.namespacePtr(block.namespace).owner_type);
     const parent_captures: InternPool.CaptureValue.Slice = parent_ty.getCaptures(zcu);
 
-    const captures = try sema.arena.alloc(InternPool.CaptureValue, captures_len);
+    const captures = try sema.arena.alloc(InternPool.CaptureValue, zir_captures.len);
 
-    for (sema.code.extra[extra_index..][0..captures_len], sema.code.extra[extra_index + captures_len ..][0..captures_len], captures) |raw, raw_name, *capture| {
-        const zir_capture: Zir.Inst.Capture = @bitCast(raw);
-        const zir_name: Zir.NullTerminatedString = @enumFromInt(raw_name);
+    for (zir_captures, zir_capture_names, captures) |zir_capture, zir_name, *capture| {
         const zir_name_slice = sema.code.nullTerminatedString(zir_name);
         capture.* = switch (zir_capture.unwrap()) {
             .nested => |parent_idx| parent_captures.get(ip)[parent_idx],
-            .instruction_load => |ptr_inst| InternPool.CaptureValue.wrap(capture: {
+            .instruction_load => |ptr_inst| capture: {
                 const ptr_ref = try sema.resolveInst(ptr_inst.toRef());
                 const ptr_val = try sema.resolveValue(ptr_ref) orelse {
-                    break :capture .{ .runtime = sema.typeOf(ptr_ref).childType(zcu).toIntern() };
+                    break :capture .wrap(.{ .runtime = sema.typeOf(ptr_ref).childType(zcu).toIntern() });
                 };
                 // TODO: better source location
-                const unresolved_loaded_val = try sema.pointerDeref(block, type_src, ptr_val, sema.typeOf(ptr_ref)) orelse {
-                    break :capture .{ .runtime = sema.typeOf(ptr_ref).childType(zcu).toIntern() };
+                const loaded_val = try sema.pointerDeref(block, type_src, ptr_val, sema.typeOf(ptr_ref)) orelse {
+                    break :capture .wrap(.{ .runtime = sema.typeOf(ptr_ref).childType(zcu).toIntern() });
                 };
-                const loaded_val = try sema.resolveLazyValue(unresolved_loaded_val);
                 if (loaded_val.canMutateComptimeVarState(zcu)) {
                     const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_name_slice, .no_embedded_nulls);
                     return sema.failWithContainsReferenceToComptimeVar(block, type_src, field_name, "captured value", loaded_val);
                 }
-                break :capture .{ .@"comptime" = loaded_val.toIntern() };
-            }),
-            .instruction => |inst| InternPool.CaptureValue.wrap(capture: {
+                break :capture .wrap(.{ .@"comptime" = loaded_val.toIntern() });
+            },
+            .instruction => |inst| capture: {
                 const air_ref = try sema.resolveInst(inst.toRef());
-                if (try sema.resolveValueResolveLazy(air_ref)) |val| {
+                if (try sema.resolveValue(air_ref)) |val| {
                     if (val.canMutateComptimeVarState(zcu)) {
                         const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_name_slice, .no_embedded_nulls);
                         return sema.failWithContainsReferenceToComptimeVar(block, type_src, field_name, "captured value", val);
                     }
-                    break :capture .{ .@"comptime" = val.toIntern() };
+                    break :capture .wrap(.{ .@"comptime" = val.toIntern() });
                 }
-                break :capture .{ .runtime = sema.typeOf(air_ref).toIntern() };
-            }),
+                break :capture .wrap(.{ .runtime = sema.typeOf(air_ref).toIntern() });
+            },
             .decl_val => |str| capture: {
                 const decl_name = try ip.getOrPutString(
                     gpa,
@@ -2968,7 +2990,7 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
                     .no_embedded_nulls,
                 );
                 const nav = try sema.lookupIdentifier(block, decl_name);
-                break :capture InternPool.CaptureValue.wrap(.{ .nav_val = nav });
+                break :capture .wrap(.{ .nav_val = nav });
             },
             .decl_ref => |str| capture: {
                 const decl_name = try ip.getOrPutString(
@@ -2987,621 +3009,6 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
     return captures;
 }
 
-fn zirStructDecl(
-    sema: *Sema,
-    block: *Block,
-    extended: Zir.Inst.Extended.InstData,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-    const extra = sema.code.extraData(Zir.Inst.StructDecl, extended.operand);
-
-    const tracked_inst = try block.trackZir(inst);
-    const src: LazySrcLoc = .{
-        .base_node_inst = tracked_inst,
-        .offset = LazySrcLoc.Offset.nodeOffset(.zero),
-    };
-
-    var extra_index = extra.end;
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-    const decls_len = if (small.has_decls_len) blk: {
-        const decls_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk decls_len;
-    } else 0;
-
-    const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len * 2;
-
-    if (small.has_backing_int) {
-        const backing_int_body_len = sema.code.extra[extra_index];
-        extra_index += 1; // backing_int_body_len
-        if (backing_int_body_len == 0) {
-            extra_index += 1; // backing_int_ref
-        } else {
-            extra_index += backing_int_body_len; // backing_int_body_inst
-        }
-    }
-
-    const struct_init: InternPool.StructTypeInit = .{
-        .layout = small.layout,
-        .fields_len = fields_len,
-        .known_non_opv = small.known_non_opv,
-        .requires_comptime = if (small.known_comptime_only) .yes else .unknown,
-        .any_comptime_fields = small.any_comptime_fields,
-        .any_default_inits = small.any_default_inits,
-        .inits_resolved = false,
-        .any_aligned_fields = small.any_aligned_fields,
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = captures,
-        } },
-    };
-    const wip_ty = switch (try ip.getStructType(gpa, io, pt.tid, struct_init, false)) {
-        .existing => |ty| {
-            const new_ty = try pt.ensureTypeUpToDate(ty);
-
-            // Make sure we update the namespace if the declaration is re-analyzed, to pick
-            // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(zcu));
-
-            try sema.declareDependency(.{ .interned = new_ty });
-            try sema.addTypeReferenceEntry(src, new_ty);
-            return Air.internedToRef(new_ty);
-        },
-        .wip => |wip| wip,
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    const type_name = try sema.createTypeName(
-        block,
-        small.name_strategy,
-        "struct",
-        inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    if (pt.zcu.comp.config.incremental) {
-        try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = tracked_inst });
-    }
-
-    const decls = sema.code.bodySlice(extra_index, decls_len);
-    try pt.scanNamespace(new_namespace_index, decls);
-
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-    try sema.declareDependency(.{ .interned = wip_ty.index });
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return Air.internedToRef(wip_ty.finish(ip, new_namespace_index));
-}
-
-pub fn createTypeName(
-    sema: *Sema,
-    block: *Block,
-    name_strategy: Zir.Inst.NameStrategy,
-    anon_prefix: []const u8,
-    inst: ?Zir.Inst.Index,
-    /// This is used purely to give the type a unique name in the `anon` case.
-    type_index: InternPool.Index,
-) CompileError!struct {
-    name: InternPool.NullTerminatedString,
-    nav: InternPool.Nav.Index.Optional,
-} {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    switch (name_strategy) {
-        .anon => {}, // handled after switch
-        .parent => return .{
-            .name = block.type_name_ctx,
-            .nav = sema.owner.unwrap().nav_val.toOptional(),
-        },
-        .func => func_strat: {
-            const fn_info = sema.code.getFnInfo(ip.funcZirBodyInst(sema.func_index).resolve(ip) orelse return error.AnalysisFail);
-            const zir_tags = sema.code.instructions.items(.tag);
-
-            var aw: std.Io.Writer.Allocating = .init(gpa);
-            defer aw.deinit();
-            const w = &aw.writer;
-            w.print("{f}(", .{block.type_name_ctx.fmt(ip)}) catch return error.OutOfMemory;
-
-            var arg_i: usize = 0;
-            for (fn_info.param_body) |zir_inst| switch (zir_tags[@intFromEnum(zir_inst)]) {
-                .param, .param_comptime, .param_anytype, .param_anytype_comptime => {
-                    const arg = sema.inst_map.get(zir_inst).?;
-                    // If this is being called in a generic function then analyzeCall will
-                    // have already resolved the args and this will work.
-                    // If not then this is a struct type being returned from a non-generic
-                    // function and the name doesn't matter since it will later
-                    // result in a compile error.
-                    const arg_val = try sema.resolveValue(arg) orelse break :func_strat; // fall through to anon strat
-
-                    if (arg_i != 0) w.writeByte(',') catch return error.OutOfMemory;
-
-                    // Limiting the depth here helps avoid type names getting too long, which
-                    // in turn helps to avoid unreasonably long symbol names for namespaced
-                    // symbols. Such names should ideally be human-readable, and additionally,
-                    // some tooling may not support very long symbol names.
-                    w.print("{f}", .{Value.fmtValueSemaFull(.{
-                        .val = arg_val,
-                        .pt = pt,
-                        .opt_sema = sema,
-                        .depth = 1,
-                    })}) catch return error.OutOfMemory;
-
-                    arg_i += 1;
-                    continue;
-                },
-                else => continue,
-            };
-
-            w.writeByte(')') catch return error.OutOfMemory;
-            return .{
-                .name = try ip.getOrPutString(gpa, io, pt.tid, aw.written(), .no_embedded_nulls),
-                .nav = .none,
-            };
-        },
-        .dbg_var => {
-            // TODO: this logic is questionable. We ideally should be traversing the `Block` rather than relying on the order of AstGen instructions.
-            const ref = inst.?.toRef();
-            const zir_tags = sema.code.instructions.items(.tag);
-            const zir_data = sema.code.instructions.items(.data);
-            for (@intFromEnum(inst.?)..zir_tags.len) |i| switch (zir_tags[i]) {
-                .dbg_var_ptr, .dbg_var_val => if (zir_data[i].str_op.operand == ref) {
-                    return .{
-                        .name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{f}.{s}", .{
-                            block.type_name_ctx.fmt(ip), zir_data[i].str_op.getStr(sema.code),
-                        }, .no_embedded_nulls),
-                        .nav = .none,
-                    };
-                },
-                else => {},
-            };
-            // fall through to anon strat
-        },
-    }
-
-    // anon strat handling
-
-    // It would be neat to have "struct:line:column" but this name has
-    // to survive incremental updates, where it may have been shifted down
-    // or up to a different line, but unchanged, and thus not unnecessarily
-    // semantically analyzed.
-    // TODO: that would be possible, by detecting line number changes and renaming
-    // types appropriately. However, `@typeName` becomes a problem then. If we remove
-    // that builtin from the language, we can consider this.
-
-    return .{
-        .name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{f}__{s}_{d}", .{
-            block.type_name_ctx.fmt(ip), anon_prefix, @intFromEnum(type_index),
-        }, .no_embedded_nulls),
-        .nav = .none,
-    };
-}
-
-fn zirEnumDecl(
-    sema: *Sema,
-    block: *Block,
-    extended: Zir.Inst.Extended.InstData,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const small: Zir.Inst.EnumDecl.Small = @bitCast(extended.small);
-    const extra = sema.code.extraData(Zir.Inst.EnumDecl, extended.operand);
-    var extra_index: usize = extra.end;
-
-    const tracked_inst = try block.trackZir(inst);
-    const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(.zero) };
-
-    const tag_type_ref = if (small.has_tag_type) blk: {
-        const tag_type_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
-        extra_index += 1;
-        break :blk tag_type_ref;
-    } else .none;
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-
-    const body_len = if (small.has_body_len) blk: {
-        const body_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk body_len;
-    } else 0;
-
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    const decls_len = if (small.has_decls_len) blk: {
-        const decls_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk decls_len;
-    } else 0;
-
-    const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len * 2;
-
-    const decls = sema.code.bodySlice(extra_index, decls_len);
-    extra_index += decls_len;
-
-    const body = sema.code.bodySlice(extra_index, body_len);
-    extra_index += body.len;
-
-    const bit_bags_count = std.math.divCeil(usize, fields_len, 32) catch unreachable;
-    const body_end = extra_index;
-    extra_index += bit_bags_count;
-
-    const any_values = for (sema.code.extra[body_end..][0..bit_bags_count]) |bag| {
-        if (bag != 0) break true;
-    } else false;
-
-    const enum_init: InternPool.EnumTypeInit = .{
-        .has_values = any_values,
-        .tag_mode = if (small.nonexhaustive)
-            .nonexhaustive
-        else if (tag_type_ref == .none)
-            .auto
-        else
-            .explicit,
-        .fields_len = fields_len,
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = captures,
-        } },
-    };
-    const wip_ty = switch (try ip.getEnumType(gpa, io, pt.tid, enum_init, false)) {
-        .existing => |ty| {
-            const new_ty = try pt.ensureTypeUpToDate(ty);
-
-            // Make sure we update the namespace if the declaration is re-analyzed, to pick
-            // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(zcu));
-
-            try sema.declareDependency(.{ .interned = new_ty });
-            try sema.addTypeReferenceEntry(src, new_ty);
-
-            // Since this is an enum, it has to be resolved immediately.
-            // `ensureTypeUpToDate` has resolved the new type if necessary.
-            // We just need to check for resolution failures.
-            const ty_unit: AnalUnit = .wrap(.{ .type = new_ty });
-            if (zcu.failed_analysis.contains(ty_unit) or zcu.transitive_failed_analysis.contains(ty_unit)) {
-                return error.AnalysisFail;
-            }
-
-            return Air.internedToRef(new_ty);
-        },
-        .wip => |wip| wip,
-    };
-
-    // Once this is `true`, we will not delete the decl or type even upon failure, since we
-    // have finished constructing the type and are in the process of analyzing it.
-    var done = false;
-
-    errdefer if (!done) wip_ty.cancel(ip, pt.tid);
-
-    const type_name = try sema.createTypeName(
-        block,
-        small.name_strategy,
-        "enum",
-        inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-    errdefer if (!done) pt.destroyNamespace(new_namespace_index);
-
-    try pt.scanNamespace(new_namespace_index, decls);
-
-    try sema.declareDependency(.{ .interned = wip_ty.index });
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
-
-    // We've finished the initial construction of this type, and are about to perform analysis.
-    // Set the namespace appropriately, and don't destroy anything on failure.
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    wip_ty.prepare(ip, new_namespace_index);
-    done = true;
-
-    {
-        const tracked_unit = zcu.trackUnitSema(type_name.name.toSlice(ip), null);
-        defer tracked_unit.end(zcu);
-        try Sema.resolveDeclaredEnum(
-            pt,
-            wip_ty,
-            inst,
-            tracked_inst,
-            new_namespace_index,
-            type_name.name,
-            small,
-            body,
-            tag_type_ref,
-            any_values,
-            fields_len,
-            sema.code,
-            body_end,
-        );
-    }
-
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-    return Air.internedToRef(wip_ty.index);
-}
-
-fn zirUnionDecl(
-    sema: *Sema,
-    block: *Block,
-    extended: Zir.Inst.Extended.InstData,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const small: Zir.Inst.UnionDecl.Small = @bitCast(extended.small);
-    const extra = sema.code.extraData(Zir.Inst.UnionDecl, extended.operand);
-    var extra_index: usize = extra.end;
-
-    const tracked_inst = try block.trackZir(inst);
-    const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(.zero) };
-
-    extra_index += @intFromBool(small.has_tag_type);
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-    extra_index += @intFromBool(small.has_body_len);
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    const decls_len = if (small.has_decls_len) blk: {
-        const decls_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk decls_len;
-    } else 0;
-
-    const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len * 2;
-
-    const union_init: InternPool.UnionTypeInit = .{
-        .flags = .{
-            .layout = small.layout,
-            .status = .none,
-            .runtime_tag = if (small.has_tag_type or small.auto_enum_tag)
-                .tagged
-            else if (small.layout != .auto)
-                .none
-            else switch (block.wantSafeTypes()) {
-                true => .safety,
-                false => .none,
-            },
-            .any_aligned_fields = small.any_aligned_fields,
-            .requires_comptime = .unknown,
-            .assumed_runtime_bits = false,
-            .assumed_pointer_aligned = false,
-            .alignment = .none,
-        },
-        .fields_len = fields_len,
-        .enum_tag_ty = .none, // set later
-        .field_types = &.{}, // set later
-        .field_aligns = &.{}, // set later
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = captures,
-        } },
-    };
-    const wip_ty = switch (try ip.getUnionType(gpa, io, pt.tid, union_init, false)) {
-        .existing => |ty| {
-            const new_ty = try pt.ensureTypeUpToDate(ty);
-
-            // Make sure we update the namespace if the declaration is re-analyzed, to pick
-            // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(zcu));
-
-            try sema.declareDependency(.{ .interned = new_ty });
-            try sema.addTypeReferenceEntry(src, new_ty);
-            return Air.internedToRef(new_ty);
-        },
-        .wip => |wip| wip,
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    const type_name = try sema.createTypeName(
-        block,
-        small.name_strategy,
-        "union",
-        inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    if (pt.zcu.comp.config.incremental) {
-        try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = tracked_inst });
-    }
-
-    const decls = sema.code.bodySlice(extra_index, decls_len);
-    try pt.scanNamespace(new_namespace_index, decls);
-
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-    try sema.declareDependency(.{ .interned = wip_ty.index });
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return Air.internedToRef(wip_ty.finish(ip, new_namespace_index));
-}
-
-fn zirOpaqueDecl(
-    sema: *Sema,
-    block: *Block,
-    extended: Zir.Inst.Extended.InstData,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const small: Zir.Inst.OpaqueDecl.Small = @bitCast(extended.small);
-    const extra = sema.code.extraData(Zir.Inst.OpaqueDecl, extended.operand);
-    var extra_index: usize = extra.end;
-
-    const tracked_inst = try block.trackZir(inst);
-    const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(.zero) };
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-
-    const decls_len = if (small.has_decls_len) blk: {
-        const decls_len = sema.code.extra[extra_index];
-        extra_index += 1;
-        break :blk decls_len;
-    } else 0;
-
-    const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len * 2;
-
-    const opaque_init: InternPool.OpaqueTypeInit = .{
-        .zir_index = tracked_inst,
-        .captures = captures,
-    };
-    const wip_ty = switch (try ip.getOpaqueType(gpa, io, pt.tid, opaque_init)) {
-        .existing => |ty| {
-            // Make sure we update the namespace if the declaration is re-analyzed, to pick
-            // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(ty).getNamespaceIndex(zcu));
-
-            try sema.declareDependency(.{ .interned = ty });
-            try sema.addTypeReferenceEntry(src, ty);
-            return Air.internedToRef(ty);
-        },
-        .wip => |wip| wip,
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    const type_name = try sema.createTypeName(
-        block,
-        small.name_strategy,
-        "opaque",
-        inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    const decls = sema.code.bodySlice(extra_index, decls_len);
-    try pt.scanNamespace(new_namespace_index, decls);
-
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return Air.internedToRef(wip_ty.finish(ip, new_namespace_index));
-}
-
 fn zirErrorSetDecl(
     sema: *Sema,
     inst: Zir.Inst.Index,
@@ -3640,16 +3047,16 @@ fn zirRetPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     defer tracy.end();
 
     const pt = sema.pt;
+    const zcu = pt.zcu;
 
     const src = block.nodeOffset(sema.code.instructions.items(.data)[@intFromEnum(inst)].node);
 
-    if (block.isComptime() or try sema.fn_ret_ty.comptimeOnlySema(pt)) {
-        try sema.fn_ret_ty.resolveFields(pt);
+    if (block.isComptime() or sema.fn_ret_ty.comptimeOnly(zcu)) {
         return sema.analyzeComptimeAlloc(block, src, sema.fn_ret_ty, .none);
     }
 
-    const target = pt.zcu.getTarget();
-    const ptr_type = try pt.ptrTypeSema(.{
+    const target = zcu.getTarget();
+    const ptr_type = try pt.ptrType(.{
         .child = sema.fn_ret_ty.toIntern(),
         .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
     });
@@ -3826,6 +3233,7 @@ fn zirAllocExtended(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const extra = sema.code.extraData(Zir.Inst.AllocExtended, extended.operand);
     const var_src = block.nodeOffset(extra.data.src_node);
@@ -3847,37 +3255,20 @@ fn zirAllocExtended(
         break :blk try sema.resolveAlign(block, align_src, align_ref);
     } else .none;
 
-    if (block.isComptime() or small.is_comptime) {
-        if (small.has_type) {
-            return sema.analyzeComptimeAlloc(block, var_src, var_ty, alignment);
-        } else {
-            try sema.air_instructions.append(gpa, .{
-                .tag = .inferred_alloc_comptime,
-                .data = .{ .inferred_alloc_comptime = .{
-                    .alignment = alignment,
-                    .is_const = small.is_const,
-                    .ptr = undefined,
-                } },
-            });
-            return @as(Air.Inst.Index, @enumFromInt(sema.air_instructions.len - 1)).toRef();
-        }
-    }
-
-    if (small.has_type and try var_ty.comptimeOnlySema(pt)) {
-        return sema.analyzeComptimeAlloc(block, var_src, var_ty, alignment);
-    }
-
     if (small.has_type) {
+        try sema.ensureLayoutResolved(var_ty);
+        if (block.isComptime() or small.is_comptime or var_ty.comptimeOnly(zcu)) {
+            return sema.analyzeComptimeAlloc(block, var_src, var_ty, alignment);
+        }
         if (!small.is_const) {
             try sema.validateVarType(block, ty_src, var_ty, false);
         }
         const target = pt.zcu.getTarget();
-        try var_ty.resolveLayout(pt);
-        if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
+        if (sema.func_is_naked and var_ty.hasRuntimeBits(zcu)) {
             const store_src = block.src(.{ .node_offset_store_ptr = extra.data.src_node });
             return sema.fail(block, store_src, "local variable in naked function", .{});
         }
-        const ptr_type = try sema.pt.ptrTypeSema(.{
+        const ptr_type = try pt.ptrType(.{
             .child = var_ty.toIntern(),
             .flags = .{
                 .alignment = alignment,
@@ -3893,6 +3284,19 @@ fn zirAllocExtended(
         return ptr;
     }
 
+    if (block.isComptime() or small.is_comptime) {
+        const iac_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
+        try sema.air_instructions.append(gpa, .{
+            .tag = .inferred_alloc_comptime,
+            .data = .{ .inferred_alloc_comptime = .{
+                .alignment = alignment,
+                .is_const = small.is_const,
+                .ptr = undefined,
+            } },
+        });
+        return iac_index.toRef();
+    }
+
     const result_index = try block.addInstAsIndex(.{
         .tag = .inferred_alloc,
         .data = .{ .inferred_alloc = .{
@@ -3916,6 +3320,7 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
     const var_src = block.nodeOffset(inst_data.src_node);
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
+    try sema.ensureLayoutResolved(var_ty);
     return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
 }
 
@@ -3978,7 +3383,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
         return sema.makePtrConst(block, Air.internedToRef(ptr_val));
     }
 
-    if (try elem_ty.comptimeOnlySema(pt)) {
+    if (elem_ty.comptimeOnly(zcu)) {
         // The value was initialized through RLS, so we didn't detect the runtime condition earlier.
         // TODO: source location of runtime control flow
         const init_src = block.src(.{ .node_offset_var_decl_init = inst_data.src_node });
@@ -4001,20 +3406,23 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
     const alloc_ty = resolved_alloc_ty orelse sema.typeOf(alloc);
     const ptr_info = alloc_ty.ptrInfo(zcu);
     const elem_ty: Type = .fromInterned(ptr_info.child);
+    elem_ty.assertHasLayout(zcu);
 
     const alloc_inst = alloc.toIndex() orelse return null;
     const comptime_info = sema.maybe_comptime_allocs.fetchRemove(alloc_inst) orelse return null;
     const stores = comptime_info.value.stores.items(.inst);
 
+    // If the elem type is OPV, no need to faff about with `stores`; just use the OPV.
+    if (try elem_ty.onePossibleValue(pt)) |opv| {
+        return sema.finishResolveComptimeKnownAllocPtr(block, alloc_ty, opv.toIntern(), null, alloc_inst, comptime_info.value);
+    }
+
+    // Since the elem type isn't OPV, there should have been at least one store.
+    assert(stores.len > 0);
+
     // Since the entry existed in `maybe_comptime_allocs`, the allocation is comptime-known.
     // We will resolve and return its value.
 
-    // We expect to have emitted at least one store, unless the elem type is OPV.
-    if (stores.len == 0) {
-        const val = (try sema.typeHasOnePossibleValue(elem_ty)).?.toIntern();
-        return sema.finishResolveComptimeKnownAllocPtr(block, alloc_ty, val, null, alloc_inst, comptime_info.value);
-    }
-
     // In general, we want to create a comptime alloc of the correct type and
     // apply the stores to that alloc in order. However, before going to all
     // that effort, let's optimize for the common case of a single store.
@@ -4118,7 +3526,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                 const idx_val = (try sema.resolveValue(data.rhs)).?;
                 break :blk .{
                     data.lhs,
-                    .{ .elem = try idx_val.toUnsignedIntSema(pt) },
+                    .{ .elem = idx_val.toUnsignedInt(zcu) },
                 };
             },
             .bitcast => .{
@@ -4150,7 +3558,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                 // If the payload is OPV, we must use that value instead of undef.
                 const opt_ty = Value.fromInterned(decl_parent_ptr).typeOf(zcu).childType(zcu);
                 const payload_ty = opt_ty.optionalChild(zcu);
-                const payload_val = try sema.typeHasOnePossibleValue(payload_ty) orelse try pt.undefValue(payload_ty);
+                const payload_val = try payload_ty.onePossibleValue(pt) orelse try pt.undefValue(payload_ty);
                 const opt_val = try pt.intern(.{ .opt = .{
                     .ty = opt_ty.toIntern(),
                     .val = payload_val.toIntern(),
@@ -4163,7 +3571,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                 // If the payload is OPV, we must use that value instead of undef.
                 const eu_ty = Value.fromInterned(decl_parent_ptr).typeOf(zcu).childType(zcu);
                 const payload_ty = eu_ty.errorUnionPayload(zcu);
-                const payload_val = try sema.typeHasOnePossibleValue(payload_ty) orelse try pt.undefValue(payload_ty);
+                const payload_val = try payload_ty.onePossibleValue(pt) orelse try pt.undefValue(payload_ty);
                 const eu_val = try pt.intern(.{ .error_union = .{
                     .ty = eu_ty.toIntern(),
                     .val = .{ .payload = payload_val.toIntern() },
@@ -4178,7 +3586,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                     // The payload value will be stored later, so undef is a sufficent payload for now.
                     const payload_ty: Type = .fromInterned(union_obj.field_types.get(&zcu.intern_pool)[idx]);
                     const payload_val = try pt.undefValue(payload_ty);
-                    const tag_val = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_ty), idx);
+                    const tag_val = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), idx);
                     const store_val = try pt.unionValue(maybe_union_ty, tag_val, payload_val);
                     try sema.storePtrVal(block, .unneeded, .fromInterned(decl_parent_ptr), store_val, maybe_union_ty);
                 }
@@ -4207,7 +3615,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                 const tag_val: Value = .fromInterned(store_inst.data.bin_op.rhs.toInterned().?);
                 const union_ty = union_ptr_val.typeOf(zcu).childType(zcu);
                 const field_ty = union_ty.unionFieldType(tag_val, zcu).?;
-                if (try sema.typeHasOnePossibleValue(field_ty)) |payload_val| {
+                if (try field_ty.onePossibleValue(pt)) |payload_val| {
                     const new_union_val = try pt.unionValue(union_ty, tag_val, payload_val);
                     try sema.storePtrVal(block, .unneeded, union_ptr_val, new_union_val, union_ty);
                 }
@@ -4289,7 +3697,7 @@ fn finishResolveComptimeKnownAllocPtr(
 fn makePtrTyConst(sema: *Sema, ptr_ty: Type) CompileError!Type {
     var ptr_info = ptr_ty.ptrInfo(sema.pt.zcu);
     ptr_info.flags.is_const = true;
-    return sema.pt.ptrTypeSema(ptr_info);
+    return sema.pt.ptrType(ptr_info);
 }
 
 fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Air.Inst.Ref {
@@ -4326,21 +3734,23 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     defer tracy.end();
 
     const pt = sema.pt;
+    const zcu = pt.zcu;
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
     const var_src = block.nodeOffset(inst_data.src_node);
 
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    if (block.isComptime() or try var_ty.comptimeOnlySema(pt)) {
+    try sema.ensureLayoutResolved(var_ty);
+    if (block.isComptime() or var_ty.comptimeOnly(zcu)) {
         return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
     }
-    if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
+    if (sema.func_is_naked and var_ty.hasRuntimeBits(zcu)) {
         const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
         return sema.fail(block, mut_src, "local variable in naked function", .{});
     }
-    const target = pt.zcu.getTarget();
-    const ptr_type = try pt.ptrTypeSema(.{
+    const target = zcu.getTarget();
+    const ptr_type = try pt.ptrType(.{
         .child = var_ty.toIntern(),
         .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
     });
@@ -4356,21 +3766,24 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     defer tracy.end();
 
     const pt = sema.pt;
+    const zcu = pt.zcu;
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
     const var_src = block.nodeOffset(inst_data.src_node);
+
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
+    try sema.ensureLayoutResolved(var_ty);
     if (block.isComptime()) {
         return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
     }
-    if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
+    if (sema.func_is_naked and var_ty.hasRuntimeBits(zcu)) {
         const store_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
         return sema.fail(block, store_src, "local variable in naked function", .{});
     }
     try sema.validateVarType(block, ty_src, var_ty, false);
-    const target = pt.zcu.getTarget();
-    const ptr_type = try pt.ptrTypeSema(.{
+    const target = zcu.getTarget();
+    const ptr_type = try pt.ptrType(.{
         .child = var_ty.toIntern(),
         .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
     });
@@ -4430,8 +3843,9 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
 
     switch (sema.air_instructions.items(.tag)[@intFromEnum(ptr_inst)]) {
         .inferred_alloc_comptime => {
-            // The work was already done for us by `Sema.storeToInferredAllocComptime`.
-            // All we need to do is return the pointer.
+            // The work was already done for us by `Sema.storeToInferredAllocComptime`. Also, since
+            // we had a value of the exact correct type to store, the result type's layout must be
+            // already resolved. So all we need to do here is return the pointer.
             const iac = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].inferred_alloc_comptime;
             const resolved_ptr = iac.ptr;
 
@@ -4450,7 +3864,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
             };
             if (zcu.intern_pool.isFuncBody(val)) {
                 const ty: Type = .fromInterned(zcu.intern_pool.typeOf(val));
-                if (try ty.fnHasRuntimeBitsSema(pt)) {
+                if (ty.fnHasRuntimeBits(zcu)) {
                     const orig_fn_index = zcu.intern_pool.unwrapCoercedFunc(val);
                     try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_fn_index }));
                     try zcu.ensureFuncBodyAnalysisQueued(orig_fn_index);
@@ -4469,8 +3883,10 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 peer_val.* = bin_op.rhs;
             }
             const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_vals, .none);
+            // The layout of the peers is already resolved, so the layout of `final_elem_ty` is too.
+            final_elem_ty.assertHasLayout(zcu);
 
-            const final_ptr_ty = try pt.ptrTypeSema(.{
+            const final_ptr_ty = try pt.ptrType(.{
                 .child = final_elem_ty.toIntern(),
                 .flags = .{
                     .alignment = ia1.alignment,
@@ -4484,21 +3900,16 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 const const_ptr_ty = try sema.makePtrTyConst(final_ptr_ty);
                 const new_const_ptr = try pt.getCoerced(Value.fromInterned(ptr_val), const_ptr_ty);
 
-                // Unless the block is comptime, `alloc_inferred` always produces
-                // a runtime constant. The final inferred type needs to be
-                // fully resolved so it can be lowered in codegen.
-                try final_elem_ty.resolveFully(pt);
-
                 return Air.internedToRef(new_const_ptr.toIntern());
             }
 
-            if (try final_elem_ty.comptimeOnlySema(pt)) {
+            if (final_elem_ty.comptimeOnly(zcu)) {
                 // The alloc wasn't comptime-known per the above logic, so the
                 // type cannot be comptime-only.
                 // TODO: source location of runtime control flow
                 return sema.fail(block, src, "value with comptime-only type '{f}' depends on runtime control flow", .{final_elem_ty.fmt(pt)});
             }
-            if (sema.func_is_naked and try final_elem_ty.hasRuntimeBitsSema(pt)) {
+            if (sema.func_is_naked and final_elem_ty.hasRuntimeBits(zcu)) {
                 const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
                 return sema.fail(block, mut_src, "local variable in naked function", .{});
             }
@@ -4812,7 +4223,7 @@ fn zirTryOperandTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is_ref: boo
     if (is_ref) {
         var ptr_info = operand_ty.ptrInfo(zcu);
         ptr_info.child = eu_ty.toIntern();
-        const eu_ptr_ty = try pt.ptrTypeSema(ptr_info);
+        const eu_ptr_ty = try pt.ptrType(ptr_info);
         return Air.internedToRef(eu_ptr_ty.toIntern());
     } else {
         return Air.internedToRef(eu_ty.toIntern());
@@ -4935,7 +4346,6 @@ fn validateArrayInitTy(
             return;
         },
         .@"struct" => if (ty.isTuple(zcu)) {
-            try ty.resolveFields(pt);
             const array_len = ty.arrayLen(zcu);
             if (init_count > array_len) {
                 return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{
@@ -5097,12 +4507,16 @@ fn validateStructInit(
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
 
     for (found_fields, 0..) |explicit, i_usize| {
+        const i: u32 = @intCast(i_usize);
+
         if (explicit) continue;
-        const i: u32 = @intCast(i_usize);
+        if (struct_ty.structFieldIsComptime(i, zcu)) continue;
 
-        try struct_ty.resolveStructFieldInits(pt);
-        const default_val = struct_ty.structFieldDefaultValue(i, zcu);
-        if (default_val.toIntern() == .unreachable_value) {
+        if (!struct_ty.isTuple(zcu)) {
+            try sema.ensureFieldInitsResolved(struct_ty);
+        }
+
+        const default_val = struct_ty.structFieldDefaultValue(i, zcu) orelse {
             const field_name = struct_ty.structFieldName(i, zcu).unwrap() orelse {
                 const template = "missing tuple field with index {d}";
                 if (root_msg) |msg| {
@@ -5120,7 +4534,7 @@ fn validateStructInit(
                 root_msg = try sema.errMsg(init_src, template, args);
             }
             continue;
-        }
+        };
 
         const field_src = init_src; // TODO better source location
         const default_field_ptr = if (struct_ty.isTuple(zcu))
@@ -5166,11 +4580,9 @@ fn zirValidatePtrArrayInit(
             var root_msg: ?*Zcu.ErrorMsg = null;
             errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
 
-            try array_ty.resolveStructFieldInits(pt);
             var i = instrs.len;
             while (i < array_len) : (i += 1) {
-                const default_val = array_ty.structFieldDefaultValue(i, zcu).toIntern();
-                if (default_val == .unreachable_value) {
+                if (array_ty.structFieldDefaultValue(i, zcu) == null) {
                     const template = "missing tuple field with index {d}";
                     if (root_msg) |msg| {
                         try sema.errNote(init_src, msg, template, .{i});
@@ -5224,17 +4636,19 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
         .slice => return sema.fail(block, src, "index syntax required for slice type '{f}'", .{operand_ty.fmt(pt)}),
     }
 
-    if ((try sema.typeHasOnePossibleValue(operand_ty.childType(zcu))) != null) {
+    const elem_ty = operand_ty.childType(zcu);
+    try sema.ensureLayoutResolved(elem_ty);
+
+    if (try elem_ty.onePossibleValue(pt) != null) {
         // No need to validate the actual pointer value, we don't need it!
         return;
     }
 
-    const elem_ty = operand_ty.elemType2(zcu);
     if (try sema.resolveValue(operand)) |val| {
         if (val.isUndef(zcu)) {
             return sema.fail(block, src, "cannot dereference undefined value", .{});
         }
-    } else if (try elem_ty.comptimeOnlySema(pt)) {
+    } else if (elem_ty.comptimeOnly(zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(
                 src,
@@ -5373,7 +4787,7 @@ fn failWithBadUnionFieldAccess(
     return sema.failWithOwnedErrorMsg(block, msg);
 }
 
-fn addDeclaredHereNote(sema: *Sema, parent: *Zcu.ErrorMsg, decl_ty: Type) !void {
+pub fn addDeclaredHereNote(sema: *Sema, parent: *Zcu.ErrorMsg, decl_ty: Type) !void {
     const zcu = sema.pt.zcu;
     const src_loc = decl_ty.srcLocOrNull(zcu) orelse return;
     const category = switch (decl_ty.zigTypeTag(zcu)) {
@@ -5443,14 +4857,16 @@ fn storeToInferredAllocComptime(
     const operand_val = try sema.resolveValue(operand) orelse {
         return sema.failWithNeededComptime(block, src, .{ .simple = .stored_to_comptime_var });
     };
-    const alloc_ty = try pt.ptrTypeSema(.{
+    const alloc_ty = try pt.ptrType(.{
         .child = operand_ty.toIntern(),
         .flags = .{
             .alignment = iac.alignment,
             .is_const = iac.is_const,
         },
     });
-    if (iac.is_const and !operand_val.canMutateComptimeVarState(zcu)) {
+    if (try operand_ty.onePossibleValue(pt) != null or
+        (iac.is_const and !operand_val.canMutateComptimeVarState(zcu)))
+    {
         iac.ptr = try pt.intern(.{ .ptr = .{
             .ty = alloc_ty.toIntern(),
             .base_addr = .{ .uav = .{
@@ -5624,7 +5040,7 @@ fn zirCompileLog(
 
         const arg = try sema.resolveInst(arg_ref);
         const arg_ty = sema.typeOf(arg);
-        if (try sema.resolveValueResolveLazy(arg)) |val| {
+        if (try sema.resolveValue(arg)) |val| {
             writer.print("@as({f}, {f})", .{
                 arg_ty.fmt(pt), val.fmtValueSema(pt, sema),
             }) catch return error.OutOfMemory;
@@ -5928,10 +5344,9 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
 
     try pt.ensureFileAnalyzed(new_file_index);
-    const ty = zcu.fileRootType(new_file_index);
-    try sema.declareDependency(.{ .interned = ty });
+    const ty: Type = .fromInterned(zcu.fileRootType(new_file_index));
     try sema.addTypeReferenceEntry(src, ty);
-    return Air.internedToRef(ty);
+    return .fromType(ty);
 }
 
 fn zirSuspendBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -6177,10 +5592,11 @@ fn resolveAnalyzedBlock(
     // to emit a jump instruction to after the block when it encounters the break.
     try parent_block.instructions.append(gpa, merges.block_inst);
     const resolved_ty = try sema.resolvePeerTypes(parent_block, src, merges.results.items, .{ .override = merges.src_locs.items });
+    resolved_ty.assertHasLayout(zcu);
     // TODO add note "missing else causes void value"
 
     const type_src = src; // TODO: better source location
-    if (try resolved_ty.comptimeOnlySema(pt)) {
+    if (resolved_ty.comptimeOnly(zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(type_src, "value with comptime-only type '{f}' depends on runtime control flow", .{resolved_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
@@ -6274,10 +5690,7 @@ fn resolveAnalyzedBlock(
         });
     }
 
-    if (try sema.typeHasOnePossibleValue(resolved_ty)) |block_only_value| {
-        return Air.internedToRef(block_only_value.toIntern());
-    }
-
+    if (try resolved_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
     return merges.block_inst.toRef();
 }
 
@@ -6413,7 +5826,8 @@ fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
         .@"comptime",
         .nav_val,
         .nav_ty,
-        .type,
+        .type_layout,
+        .type_inits,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -6431,7 +5845,8 @@ fn zirDisableIntrinsics(sema: *Sema) CompileError!void {
         .@"comptime",
         .nav_val,
         .nav_ty,
-        .type,
+        .type_layout,
+        .type_inits,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -6589,8 +6004,8 @@ fn addDbgVar(
         .dbg_var_val, .dbg_arg_inline => operand_ty,
         else => unreachable,
     };
-    if (try val_ty.comptimeOnlySema(pt)) return;
-    if (!(try val_ty.hasRuntimeBitsSema(pt))) return;
+    if (val_ty.comptimeOnly(zcu)) return;
+    if (!val_ty.hasRuntimeBits(zcu)) return;
     if (try sema.resolveValue(operand)) |operand_val| {
         if (operand_val.canMutateComptimeVarState(zcu)) return;
     }
@@ -6759,7 +6174,6 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
     if (!block.ownerModule().error_tracing) return .none;
 
     const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
-    try stack_trace_ty.resolveFields(pt);
     const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
     const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) {
         error.AnalysisFail => @panic("std.builtin.StackTrace is corrupt"),
@@ -6803,7 +6217,6 @@ fn popErrorReturnTrace(
         // the result is comptime-known to be a non-error. Either way, pop unconditionally.
 
         const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace);
-        try stack_trace_ty.resolveFields(pt);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
         const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
@@ -6829,7 +6242,6 @@ fn popErrorReturnTrace(
 
         // If non-error, then pop the error return trace by restoring the index.
         const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace);
-        try stack_trace_ty.resolveFields(pt);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
         const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
@@ -6969,7 +6381,6 @@ fn zirCall(
         // need to clean-up our own trace if we were passed to a non-error-handling expression.
         if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) {
             const stack_trace_ty = try sema.getBuiltinType(call_src, .StackTrace);
-            try stack_trace_ty.resolveFields(pt);
             const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
             const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src);
 
@@ -7318,6 +6729,8 @@ fn analyzeCall(
     } else func_src;
 
     const func_ty_info = zcu.typeToFunc(func_ty).?;
+    // MLUGG TODO: this isn't quite the check i want. this includes inline functions, which aren't *generic*...
+    const func_is_generic = !func_ty.fnHasRuntimeBits(zcu);
     if (!callConvIsCallable(func_ty_info.cc)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(
@@ -7353,7 +6766,7 @@ fn analyzeCall(
         else => unreachable,
     } else .{ null, false };
 
-    if (func_ty_info.is_generic and func_val == null) {
+    if (func_is_generic and func_val == null) {
         return sema.failWithNeededComptime(block, func_src, .{ .simple = .generic_call_target });
     }
 
@@ -7369,19 +6782,18 @@ fn analyzeCall(
                 .src = call_src,
                 .r = .{ .simple = .comptime_call_modifier },
             } };
-        } else if (!inline_requested and try Type.fromInterned(func_ty_info.return_type).comptimeOnlySema(pt)) {
-            block.comptime_reason = .{
-                .reason = .{
+        } else if (!inline_requested) {
+            const ret_ty: Type = .fromInterned(func_ty_info.return_type);
+            if (ret_ty.comptimeOnly(zcu)) {
+                block.comptime_reason = .{ .reason = .{
                     .src = call_src,
-                    .r = .{
-                        .comptime_only_ret_ty = .{
-                            .ty = .fromInterned(func_ty_info.return_type),
-                            .is_generic_inst = false,
-                            .ret_ty_src = func_ret_ty_src,
-                        },
-                    },
-                },
-            };
+                    .r = .{ .comptime_only_ret_ty = .{
+                        .ty = .fromInterned(func_ty_info.return_type),
+                        .is_generic_inst = false,
+                        .ret_ty_src = func_ret_ty_src,
+                    } },
+                } };
+            }
         }
     }
 
@@ -7403,13 +6815,13 @@ fn analyzeCall(
     // This is the `inst_map` used when evaluating generic parameters and return types.
     var generic_inst_map: InstMap = .{};
     defer generic_inst_map.deinit(gpa);
-    if (func_ty_info.is_generic) {
+    if (func_is_generic) {
         try generic_inst_map.ensureSpaceForInstructions(gpa, fn_zir_info.param_body);
     }
 
     // This exists so that `generic_block` below can include a "called from here" note back to this
     // call site when analyzing generic parameter/return types.
-    var generic_inlining: Block.Inlining = if (func_ty_info.is_generic) .{
+    var generic_inlining: Block.Inlining = if (func_is_generic) .{
         .call_block = block,
         .call_src = call_src,
         .func = func_val.?.toIntern(),
@@ -7422,7 +6834,7 @@ fn analyzeCall(
     // This is the block in which we evaluate generic function components: that is, generic parameter
     // types and the generic return type. This must not be used if the function is not generic.
     // `comptime_reason` is set as needed.
-    var generic_block: Block = if (func_ty_info.is_generic) .{
+    var generic_block: Block = if (func_is_generic) .{
         .parent = null,
         .sema = sema,
         .namespace = fn_nav.analysis.?.namespace,
@@ -7431,9 +6843,9 @@ fn analyzeCall(
         .src_base_inst = fn_nav.analysis.?.zir_index,
         .type_name_ctx = fn_nav.fqn,
     } else undefined;
-    defer if (func_ty_info.is_generic) generic_block.instructions.deinit(gpa);
+    defer if (func_is_generic) generic_block.instructions.deinit(gpa);
 
-    if (func_ty_info.is_generic) {
+    if (func_is_generic) {
         // We certainly depend on the generic owner's signature!
         try sema.declareDependency(.{ .src_hash = fn_tracked_inst });
     }
@@ -7445,7 +6857,7 @@ fn analyzeCall(
             if (raw != .generic_poison_type) break :ty .fromInterned(raw);
 
             // We must discover the generic parameter type.
-            assert(func_ty_info.is_generic);
+            assert(func_is_generic);
             const param_inst_idx = fn_zir_info.param_body[arg_idx];
             const param_inst = fn_zir.instructions.get(@intFromEnum(param_inst_idx));
             switch (param_inst.tag) {
@@ -7494,11 +6906,11 @@ fn analyzeCall(
             return arg.*; // terminate analysis here
         }
 
-        if (func_ty_info.is_generic) {
+        if (func_is_generic) {
             // We need to put the argument into `generic_inst_map` so that other parameters can refer to it.
             const param_inst_idx = fn_zir_info.param_body[arg_idx];
             const declared_comptime = if (std.math.cast(u5, arg_idx)) |i| func_ty_info.paramIsComptime(i) else false;
-            const param_is_comptime = declared_comptime or try arg_ty.comptimeOnlySema(pt);
+            const param_is_comptime = declared_comptime or arg_ty.comptimeOnly(zcu);
             // We allow comptime-known arguments to propagate to generic types not only for comptime
             // parameters, but if the call is known to be inline.
             if (param_is_comptime or early_known_inline) {
@@ -7516,6 +6928,10 @@ fn analyzeCall(
                     );
                 }
                 generic_inst_map.putAssumeCapacityNoClobber(param_inst_idx, arg.*);
+            } else if (try arg_ty.onePossibleValue(pt)) |opv| {
+                // The argument is comptime-known, even though this is a generic instantiation (as
+                // opposed to an inline call), because the parameter type is OPV.
+                generic_inst_map.putAssumeCapacityNoClobber(param_inst_idx, .fromValue(opv));
             } else {
                 // We need a dummy instruction with this type. It doesn't actually need to be in any block,
                 // since it will never be referenced at runtime!
@@ -7532,7 +6948,7 @@ fn analyzeCall(
     // calls (where it should be the IES of the instantiation). However, it's how we print this
     // in error messages.
     const resolved_ret_ty: Type = ret_ty: {
-        if (!func_ty_info.is_generic) break :ret_ty .fromInterned(func_ty_info.return_type);
+        if (!func_is_generic) break :ret_ty .fromInterned(func_ty_info.return_type);
 
         const maybe_poison_bare = if (fn_zir_info.inferred_error_set) maybe_poison: {
             break :maybe_poison ip.errorUnionPayload(func_ty_info.return_type);
@@ -7542,7 +6958,7 @@ fn analyzeCall(
 
         // Evaluate the generic return type. As with generic parameters, we switch out `sema.code` and `sema.inst_map`.
 
-        assert(func_ty_info.is_generic);
+        assert(func_is_generic);
 
         const old_code = sema.code;
         const old_inst_map = sema.inst_map;
@@ -7584,10 +7000,11 @@ fn analyzeCall(
 
         break :ret_ty full_ty;
     };
+    try sema.ensureLayoutResolved(resolved_ret_ty);
 
     // If we've discovered after evaluating arguments that a generic function instantiation is
     // comptime-only, then we can mark the block as comptime *now*.
-    if (!inline_requested and !block.isComptime() and try resolved_ret_ty.comptimeOnlySema(pt)) {
+    if (!inline_requested and !block.isComptime() and resolved_ret_ty.comptimeOnly(zcu)) {
         block.comptime_reason = .{
             .reason = .{
                 .src = call_src,
@@ -7618,7 +7035,7 @@ fn analyzeCall(
         });
         if (func_ty_info.cc == .auto) {
             switch (sema.owner.unwrap()) {
-                .@"comptime", .nav_ty, .nav_val, .type, .memoized_state => {},
+                .@"comptime", .nav_ty, .nav_val, .type_layout, .type_inits, .memoized_state => {},
                 .func => |owner_func| ip.funcSetHasErrorTrace(io, owner_func, true),
             }
         }
@@ -7626,7 +7043,7 @@ fn analyzeCall(
             try sema.validateRuntimeValue(block, args_info.argSrc(block, arg_idx), arg);
         }
         const runtime_func: Air.Inst.Ref, const runtime_args: []const Air.Inst.Ref = func: {
-            if (!func_ty_info.is_generic) break :func .{ callee, args };
+            if (!func_is_generic) break :func .{ callee, args };
 
             // Instantiate the generic function!
 
@@ -7648,7 +7065,7 @@ fn analyzeCall(
                             break :c true;
                         }
                     }
-                    break :c try arg_ty.comptimeOnlySema(pt);
+                    break :c arg_ty.comptimeOnly(zcu);
                 };
                 const is_noalias = if (std.math.cast(u5, arg_idx)) |i| func_ty_info.paramIsNoalias(i) else false;
 
@@ -7680,6 +7097,7 @@ fn analyzeCall(
                 .generic_owner = func_val.?.toIntern(),
                 .comptime_args = comptime_args,
             });
+            try sema.ensureLayoutResolved(.fromInterned(ip.typeOf(func_instance)));
             if (zcu.comp.debugIncremental()) {
                 const nav = ip.indexToKey(func_instance).func.owner_nav;
                 const gop = try zcu.incremental_debug_state.navs.getOrPut(gpa, nav);
@@ -7753,12 +7171,12 @@ fn analyzeCall(
             return .unreachable_value;
         }
 
-        const result: Air.Inst.Ref = if (try sema.typeHasOnePossibleValue(sema.typeOf(maybe_opv))) |opv|
-            .fromValue(opv)
-        else
-            maybe_opv;
-
-        return result;
+        try sema.ensureLayoutResolved(sema.typeOf(maybe_opv));
+        if (try sema.typeOf(maybe_opv).onePossibleValue(pt)) |opv| {
+            return .fromValue(opv);
+        } else {
+            return maybe_opv;
+        }
     }
 
     // This is an inline call. The function must be comptime-known. We will analyze its body directly using this `Sema`.
@@ -7824,6 +7242,11 @@ fn analyzeCall(
         }
     }
 
+    // We're about to do an inline call; if the return type expression was generic, the return type
+    // may not be resolved yet. It's correct to resolve it because the function is going to return a
+    // value of this type.
+    try sema.ensureLayoutResolved(resolved_ret_ty);
+
     // For an inline call, we depend on the source code of the whole function definition.
     try sema.declareDependency(.{ .src_hash = fn_nav.analysis.?.zir_index });
 
@@ -8000,6 +7423,10 @@ fn analyzeCall(
         break :result try sema.resolveAnalyzedBlock(block, call_src, &child_block, &inlining.merges, need_debug_scope);
     };
 
+    if (sema.typeOf(result_raw).isNoReturn(zcu)) {
+        return .unreachable_value;
+    }
+
     const maybe_opv: Air.Inst.Ref = if (try sema.resolveValue(result_raw)) |result_val| r: {
         const val_resolved = try sema.resolveAdHocInferredErrorSet(block, call_src, result_val.toIntern());
         break :r Air.internedToRef(val_resolved);
@@ -8080,16 +7507,16 @@ fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
     const zcu = pt.zcu;
     const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;
     const maybe_wrapped_indexable_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, bin.lhs) orelse return .generic_poison_type;
+    try sema.ensureLayoutResolved(maybe_wrapped_indexable_ty);
     const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(zcu);
-    try indexable_ty.resolveFields(pt);
     assert(indexable_ty.isIndexable(zcu)); // validated by a previous instruction
-    if (indexable_ty.zigTypeTag(zcu) == .@"struct") {
-        const elem_type = indexable_ty.fieldType(@intFromEnum(bin.rhs), zcu);
-        return Air.internedToRef(elem_type.toIntern());
-    } else {
-        const elem_type = indexable_ty.elemType2(zcu);
-        return Air.internedToRef(elem_type.toIntern());
-    }
+    const elem_ty = switch (indexable_ty.zigTypeTag(zcu)) {
+        .@"struct" => indexable_ty.fieldType(@intFromEnum(bin.rhs), zcu),
+        .array, .vector => indexable_ty.childType(zcu),
+        .pointer => indexable_ty.indexablePtrElem(zcu),
+        else => unreachable,
+    };
+    return .fromType(elem_ty);
 }
 
 fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -8355,7 +7782,7 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     const operand = try sema.coerce(block, err_int_ty, uncasted_operand, operand_src);
 
     if (try sema.resolveDefinedValue(block, operand_src, operand)) |value| {
-        const int = try sema.usizeCast(block, operand_src, try value.toUnsignedIntSema(pt));
+        const int = try sema.usizeCast(block, operand_src, value.toUnsignedInt(zcu));
         if (int > len: {
             const mutate = &ip.global_error_set.mutate;
             mutate.map.mutex.lockUncancelable(io);
@@ -8539,7 +7966,6 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const enum_tag: Air.Inst.Ref = switch (operand_ty.zigTypeTag(zcu)) {
         .@"enum" => operand,
         .@"union" => blk: {
-            try operand_ty.resolveFields(pt);
             const tag_ty = operand_ty.unionTagType(zcu) orelse {
                 return sema.fail(
                     block,
@@ -8568,17 +7994,9 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         });
     }
 
-    if (try sema.typeHasOnePossibleValue(enum_tag_ty)) |opv| {
-        return Air.internedToRef((try pt.getCoerced(opv, int_tag_ty)).toIntern());
-    }
-
     if (try sema.resolveValue(enum_tag)) |enum_tag_val| {
-        if (enum_tag_val.isUndef(zcu)) {
-            return pt.undefRef(int_tag_ty);
-        }
-
-        const val = try enum_tag_val.intFromEnum(enum_tag_ty, pt);
-        return Air.internedToRef(val.toIntern());
+        if (enum_tag_val.isUndef(zcu)) return pt.undefRef(int_tag_ty);
+        return .fromValue(enum_tag_val.intFromEnum(zcu));
     }
 
     try sema.requireRuntimeBlock(block, src, operand_src);
@@ -8626,19 +8044,15 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         return sema.failWithNeededComptime(block, operand_src, .{ .simple = .casted_to_comptime_enum });
     }
 
-    if (try sema.typeHasOnePossibleValue(dest_ty)) |opv| {
+    if (try dest_ty.onePossibleValue(pt)) |opv| {
         if (block.wantSafety()) {
             // The operand is runtime-known but the result is comptime-known. In
             // this case we still need a safety check.
-            const expect_int_val = switch (zcu.intern_pool.indexToKey(opv.toIntern())) {
-                .enum_tag => |enum_tag| enum_tag.int,
-                else => unreachable,
-            };
-            const expect_int_coerced = try pt.getCoerced(.fromInterned(expect_int_val), operand_ty);
-            const ok = try block.addBinOp(.cmp_eq, operand, Air.internedToRef(expect_int_coerced.toIntern()));
+            const expect_int = try pt.getCoerced(opv.intFromEnum(zcu), operand_ty);
+            const ok = try block.addBinOp(.cmp_eq, operand, .fromValue(expect_int));
             try sema.addSafetyCheck(block, src, ok, .invalid_enum_value);
         }
-        return Air.internedToRef(opv.toIntern());
+        return .fromValue(opv);
     }
 
     try sema.requireRuntimeBlock(block, src, operand_src);
@@ -8666,6 +8080,7 @@ fn zirOptionalPayloadPtr(
     return sema.analyzeOptionalPayloadPtr(block, src, optional_ptr, safety_check, false);
 }
 
+/// MLUGG TODO: pre-resolved child?
 fn analyzeOptionalPayloadPtr(
     sema: *Sema,
     block: *Block,
@@ -8685,7 +8100,8 @@ fn analyzeOptionalPayloadPtr(
     }
 
     const child_type = opt_type.optionalChild(zcu);
-    const child_pointer = try pt.ptrTypeSema(.{
+    try sema.ensureLayoutResolved(child_type);
+    const child_pointer = try pt.ptrType(.{
         .child = child_type.toIntern(),
         .flags = .{
             .is_const = optional_ptr_ty.isConstPtr(zcu),
@@ -8698,7 +8114,7 @@ fn analyzeOptionalPayloadPtr(
             if (sema.isComptimeMutablePtr(ptr_val)) {
                 // Set the optional to non-null at comptime.
                 // If the payload is OPV, we must use that value instead of undef.
-                const payload_val = try sema.typeHasOnePossibleValue(child_type) orelse try pt.undefValue(child_type);
+                const payload_val = try child_type.onePossibleValue(pt) orelse try pt.undefValue(child_type);
                 const opt_val = try pt.intern(.{ .opt = .{
                     .ty = opt_type.toIntern(),
                     .val = payload_val.toIntern(),
@@ -8759,7 +8175,7 @@ fn zirOptionalPayload(
             // TODO https://github.com/ziglang/zig/issues/6597
             if (true) break :t operand_ty;
             const ptr_info = operand_ty.ptrInfo(zcu);
-            break :t try pt.ptrTypeSema(.{
+            break :t try pt.ptrType(.{
                 .child = ptr_info.child,
                 .flags = .{
                     .alignment = ptr_info.flags.alignment,
@@ -8784,11 +8200,14 @@ fn zirOptionalPayload(
         return .unreachable_value;
     }
 
-    try sema.requireRuntimeBlock(block, src, null);
     if (safety_check and block.wantSafety()) {
         const is_non_null = try block.addUnOp(.is_non_null, operand);
         try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null);
     }
+
+    // If the payload is OPV, we need the safety check but have a comptime-known result.
+    if (try result_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+
     return block.addTyOp(.optional_payload, result_ty, operand);
 }
 
@@ -8844,8 +8263,8 @@ fn analyzeErrUnionPayload(
         try sema.addSafetyCheckUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err);
     }
 
-    if (try sema.typeHasOnePossibleValue(payload_ty)) |payload_only_value| {
-        return Air.internedToRef(payload_only_value.toIntern());
+    if (try payload_ty.onePossibleValue(pt)) |payload_opv| {
+        return .fromValue(payload_opv);
     }
 
     return block.addTyOp(.unwrap_errunion_payload, payload_ty, operand);
@@ -8867,6 +8286,7 @@ fn zirErrUnionPayloadPtr(
     return sema.analyzeErrUnionPayloadPtr(block, src, operand, false, false);
 }
 
+/// MLUGG TODO LAYOUT: already-resolved child?
 fn analyzeErrUnionPayloadPtr(
     sema: *Sema,
     block: *Block,
@@ -8888,7 +8308,8 @@ fn analyzeErrUnionPayloadPtr(
 
     const err_union_ty = operand_ty.childType(zcu);
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
-    const operand_pointer_ty = try pt.ptrTypeSema(.{
+    try sema.ensureLayoutResolved(payload_ty);
+    const operand_pointer_ty = try pt.ptrType(.{
         .child = payload_ty.toIntern(),
         .flags = .{
             .is_const = operand_ty.isConstPtr(zcu),
@@ -8901,7 +8322,7 @@ fn analyzeErrUnionPayloadPtr(
             if (sema.isComptimeMutablePtr(ptr_val)) {
                 // Set the error union to non-error at comptime.
                 // If the payload is OPV, we must use that value instead of undef.
-                const payload_val = try sema.typeHasOnePossibleValue(payload_ty) orelse try pt.undefValue(payload_ty);
+                const payload_val = try payload_ty.onePossibleValue(pt) orelse try pt.undefValue(payload_ty);
                 const eu_val = try pt.intern(.{ .error_union = .{
                     .ty = err_union_ty.toIntern(),
                     .val = .{ .payload = payload_val.toIntern() },
@@ -9571,10 +8992,6 @@ fn funcCommon(
 
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = src_node_offset });
     const cc_src = block.src(.{ .node_offset_fn_type_cc = src_node_offset });
-    const func_src = block.nodeOffset(src_node_offset);
-
-    const ret_ty_requires_comptime = try bare_return_type.comptimeOnlySema(pt);
-    var is_generic = bare_return_type.isGenericPoison() or ret_ty_requires_comptime;
 
     var comptime_bits: u32 = 0;
     for (block.params.items(.ty), block.params.items(.is_comptime), 0..) |param_ty_ip, param_is_comptime, i| {
@@ -9587,11 +9004,7 @@ fn funcCommon(
             .fn_proto_node_offset = src_node_offset,
             .param_index = @intCast(i),
         } });
-        const param_ty_comptime = try param_ty.comptimeOnlySema(pt);
         const param_ty_generic = param_ty.isGenericPoison();
-        if (param_is_comptime or param_ty_comptime or param_ty_generic) {
-            is_generic = true;
-        }
         if (param_is_comptime) {
             comptime_bits |= @as(u32, 1) << @intCast(i); // TODO: handle cast error
         }
@@ -9609,24 +9022,6 @@ fn funcCommon(
             param_src,
             cc,
         );
-        if (param_ty_comptime and !param_is_comptime and has_body and !block.isComptime()) {
-            const msg = msg: {
-                const msg = try sema.errMsg(param_src, "parameter of type '{f}' must be declared comptime", .{
-                    param_ty.fmt(pt),
-                });
-                errdefer msg.destroy(sema.gpa);
-
-                try sema.explainWhyTypeIsComptime(msg, param_src, param_ty);
-
-                try sema.addDeclaredHereNote(msg, param_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(block, msg);
-        }
-    }
-
-    if (var_args and is_generic) {
-        return sema.fail(block, func_src, "generic function cannot be variadic", .{});
     }
 
     try sema.checkReturnTypeAndCallConvCommon(
@@ -9643,46 +9038,6 @@ fn funcCommon(
         is_noinline,
     );
 
-    // If the return type is comptime-only but not dependent on parameters then
-    // all parameter types also need to be comptime.
-    if (has_body and ret_ty_requires_comptime and !block.isComptime()) comptime_check: {
-        for (block.params.items(.is_comptime)) |is_comptime| {
-            if (!is_comptime) break;
-        } else break :comptime_check;
-        const ies_ret_ty_prefix: []const u8 = if (inferred_error_set) "!" else "";
-        const msg = try sema.errMsg(
-            ret_ty_src,
-            "function with comptime-only return type '{s}{f}' requires all parameters to be comptime",
-            .{ ies_ret_ty_prefix, bare_return_type.fmt(pt) },
-        );
-        errdefer msg.destroy(sema.gpa);
-        try sema.explainWhyTypeIsComptime(msg, ret_ty_src, bare_return_type);
-
-        const tags = sema.code.instructions.items(.tag);
-        const data = sema.code.instructions.items(.data);
-        const param_body = sema.code.getParamBody(func_inst);
-        for (
-            block.params.items(.is_comptime),
-            block.params.items(.name),
-            param_body[0..block.params.len],
-        ) |is_comptime, name_nts, param_index| {
-            if (!is_comptime) {
-                const param_src = block.tokenOffset(switch (tags[@intFromEnum(param_index)]) {
-                    .param => data[@intFromEnum(param_index)].pl_tok.src_tok,
-                    .param_anytype => data[@intFromEnum(param_index)].str_tok.src_tok,
-                    else => unreachable,
-                });
-                const name = sema.code.nullTerminatedString(name_nts);
-                if (name.len != 0) {
-                    try sema.errNote(param_src, msg, "param '{s}' is required to be comptime", .{name});
-                } else {
-                    try sema.errNote(param_src, msg, "param is required to be comptime", .{});
-                }
-            }
-        }
-        return sema.failWithOwnedErrorMsg(block, msg);
-    }
-
     const param_types = block.params.items(.ty);
 
     if (inferred_error_set) {
@@ -9696,7 +9051,6 @@ fn funcCommon(
             .bare_return_type = bare_return_type.toIntern(),
             .cc = cc,
             .is_var_args = var_args,
-            .is_generic = is_generic,
             .is_noinline = is_noinline,
 
             .zir_body_inst = try block.trackZir(func_inst),
@@ -9714,7 +9068,6 @@ fn funcCommon(
         .return_type = bare_return_type.toIntern(),
         .cc = cc,
         .is_var_args = var_args,
-        .is_generic = is_generic,
         .is_noinline = is_noinline,
     });
 
@@ -9845,16 +9198,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     if (!ptr_ty.isPtrAtRuntime(zcu)) {
         return sema.fail(block, ptr_src, "expected pointer, found '{f}'", .{ptr_ty.fmt(pt)});
     }
-    const pointee_ty = ptr_ty.childType(zcu);
-    if (try ptr_ty.comptimeOnlySema(pt)) {
-        const msg = msg: {
-            const msg = try sema.errMsg(ptr_src, "comptime-only type '{f}' has no pointer address", .{pointee_ty.fmt(pt)});
-            errdefer msg.destroy(sema.gpa);
-            try sema.explainWhyTypeIsComptime(msg, ptr_src, pointee_ty);
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(block, msg);
-    }
+
     const len = if (is_vector) operand_ty.vectorLen(zcu) else undefined;
     const dest_ty: Type = if (is_vector) try pt.vectorType(.{ .child = .usize_type, .len = len }) else .usize;
 
@@ -9863,7 +9207,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
             if (operand_val.isUndef(zcu)) {
                 return .undef_usize;
             }
-            const addr = try operand_val.getUnsignedIntSema(pt) orelse {
+            const addr = operand_val.getUnsignedInt(zcu) orelse {
                 // Wasn't an integer pointer. This is a runtime operation.
                 break :ct;
             };
@@ -9879,7 +9223,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
                 new_elem.* = .undef_usize;
                 continue;
             }
-            const addr = try ptr_val.getUnsignedIntSema(pt) orelse {
+            const addr = ptr_val.getUnsignedInt(zcu) orelse {
                 // A vector element wasn't an integer pointer. This is a runtime operation.
                 break :ct;
             };
@@ -10044,7 +9388,7 @@ fn intCast(
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, dest_ty_src, operand_src);
     const is_vector = dest_ty.zigTypeTag(zcu) == .vector;
 
-    if ((try sema.typeHasOnePossibleValue(dest_ty))) |opv| {
+    if (try dest_ty.onePossibleValue(pt)) |opv| {
         // requirement: intCast(u0, input) iff input == 0
         if (block.wantSafety()) {
             try sema.requireRuntimeBlock(block, src, operand_src);
@@ -10382,6 +9726,8 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         };
         return sema.failWithOwnedErrorMsg(block, msg);
     }
+    try sema.checkIndexable(block, src, indexable_ty);
+    try sema.ensureLayoutResolved(indexable_ty.childType(zcu));
     return sema.elemPtrOneLayerOnly(block, src, array_ptr, elem_index, src, false, false);
 }
 
@@ -10764,7 +10110,8 @@ fn analyzeSwitchBlock(
             .{ raw_operand, .none };
 
         const operand_ty = sema.typeOf(val);
-        const maybe_operand_opv = try sema.typeHasOnePossibleValue(operand_ty);
+        operand_ty.assertHasLayout(zcu);
+        const maybe_operand_opv = try operand_ty.onePossibleValue(pt);
         const init_cond: Air.Inst.Ref, const item_ty: Type = switch (operand_ty.zigTypeTag(zcu)) {
             .@"union" => tag: {
                 const tag_ty = operand_ty.unionTagType(zcu).?;
@@ -10776,6 +10123,7 @@ fn analyzeSwitchBlock(
                 operand_ty,
             },
         };
+        item_ty.assertHasLayout(zcu);
 
         if (zir_switch.has_continue and !block.isComptime()) {
             const operand_alloc: Air.Inst.Ref = if (zir_switch.any_maybe_runtime_capture and
@@ -10881,7 +10229,7 @@ fn analyzeSwitchBlock(
         unreachable;
     }
 
-    if (try sema.typeHasOnePossibleValue(item_ty)) |item_opv| {
+    if (try item_ty.onePossibleValue(pt)) |item_opv| {
         // We simplify conditions with OPV to either a `loop` or a `block` since
         // we cannot switch on a value which doesn't exist at runtime.
         assert(operand == .loop); // `simple` should have already been comptime-resolved above!
@@ -11249,8 +10597,8 @@ fn finishSwitchBr(
                 var item = sema.resolveConstDefinedValue(block, .unneeded, range_ref[0], undefined) catch unreachable;
                 const item_last = sema.resolveConstDefinedValue(block, .unneeded, range_ref[1], undefined) catch unreachable;
 
-                if (try item.getUnsignedIntSema(pt)) |first_int| {
-                    if (try item_last.getUnsignedIntSema(pt)) |last_int| {
+                if (item.getUnsignedInt(zcu)) |first_int| {
+                    if (item_last.getUnsignedInt(zcu)) |last_int| {
                         if (std.math.cast(u32, last_int - first_int)) |range_len| {
                             try branch_hints.ensureUnusedCapacity(gpa, range_len);
                         }
@@ -11259,7 +10607,6 @@ fn finishSwitchBr(
 
                 var prev_result_overflowed = false;
                 while (item.compareScalar(.lte, item_last, operand_ty, zcu)) : ({
-                    // Previous validation has resolved any possible lazy values.
                     const int_val: Value, const int_ty: Type = switch (operand_ty.zigTypeTag(zcu)) {
                         .int => .{ item, operand_ty },
                         .@"enum" => b: {
@@ -11896,72 +11243,68 @@ fn validateSwitchBlock(
         try sema.inst_map.ensureSpaceForInstructions(gpa, &.{tag_capture_inst});
     }
 
-    const operand_ty: Type, const item_ty: Type = check_operand: {
-        const operand_ty = operand_ty: {
-            const raw_operand_ty = sema.typeOf(raw_operand);
-            if (operand_is_ref) {
-                try sema.checkPtrType(block, operand_src, raw_operand_ty, false);
-                break :operand_ty raw_operand_ty.childType(zcu);
-            }
-            break :operand_ty raw_operand_ty;
-        };
-
-        const item_ty: Type = item_ty: {
-            switch (operand_ty.zigTypeTag(zcu)) {
-                .@"enum",
-                .error_set,
-                .int,
-                .comptime_int,
-                .type,
-                .enum_literal,
-                .@"fn",
-                .bool,
-                .void,
-                => break :item_ty operand_ty,
+    const operand_ty = operand_ty: {
+        const raw_operand_ty = sema.typeOf(raw_operand);
+        if (operand_is_ref) {
+            try sema.checkPtrType(block, operand_src, raw_operand_ty, false);
+            break :operand_ty raw_operand_ty.childType(zcu);
+        }
+        break :operand_ty raw_operand_ty;
+    };
+    try sema.ensureLayoutResolved(operand_ty);
 
-                .@"union" => {
-                    try operand_ty.resolveFields(pt);
-                    const enum_ty = operand_ty.unionTagType(zcu) orelse {
-                        return sema.failWithOwnedErrorMsg(block, msg: {
-                            const msg = try sema.errMsg(operand_src, "switch on union with no attached enum", .{});
-                            errdefer msg.destroy(sema.gpa);
-                            if (operand_ty.srcLocOrNull(zcu)) |union_src| {
-                                try sema.errNote(union_src, msg, "consider 'union(enum)' here", .{});
-                            }
-                            break :msg msg;
-                        });
-                    };
-                    break :item_ty enum_ty;
-                },
+    const item_ty: Type = item_ty: {
+        switch (operand_ty.zigTypeTag(zcu)) {
+            .@"enum",
+            .error_set,
+            .int,
+            .comptime_int,
+            .type,
+            .enum_literal,
+            .@"fn",
+            .bool,
+            .void,
+            => break :item_ty operand_ty,
 
-                .pointer => {
-                    if (!operand_ty.isSlice(zcu)) {
-                        break :item_ty operand_ty;
-                    }
-                },
+            .@"union" => {
+                const enum_ty = operand_ty.unionTagType(zcu) orelse {
+                    return sema.failWithOwnedErrorMsg(block, msg: {
+                        const msg = try sema.errMsg(operand_src, "switch on union with no attached enum", .{});
+                        errdefer msg.destroy(sema.gpa);
+                        if (operand_ty.srcLocOrNull(zcu)) |union_src| {
+                            try sema.errNote(union_src, msg, "consider 'union(enum)' here", .{});
+                        }
+                        break :msg msg;
+                    });
+                };
+                break :item_ty enum_ty;
+            },
 
-                else => {},
-            }
-            return sema.fail(block, operand_src, "switch on type '{f}'", .{operand_ty.fmt(pt)});
-        };
+            .pointer => {
+                if (!operand_ty.isSlice(zcu)) {
+                    break :item_ty operand_ty;
+                }
+            },
 
-        if (zir_switch.has_continue and !block.isComptime()) {
-            if (try operand_ty.comptimeOnlySema(pt)) {
-                // Even if the operand is comptime-known, this `switch` is runtime.
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(operand_src, "operand of switch loop has comptime-only type '{f}'", .{operand_ty.fmt(pt)});
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(operand_src, msg, "switch loops are evaluated at runtime outside of comptime scopes", .{});
-                    try sema.explainWhyTypeIsComptime(msg, operand_src, operand_ty);
-                    break :msg msg;
-                });
-            }
-            try sema.validateRuntimeValue(block, operand_src, raw_operand);
+            else => {},
         }
-
-        break :check_operand .{ operand_ty, item_ty };
+        return sema.fail(block, operand_src, "switch on type '{f}'", .{operand_ty.fmt(pt)});
     };
 
+    if (zir_switch.has_continue and !block.isComptime()) {
+        if (operand_ty.comptimeOnly(zcu)) {
+            // Even if the operand is comptime-known, this `switch` is runtime.
+            return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(operand_src, "operand of switch loop has comptime-only type '{f}'", .{operand_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(operand_src, msg, "switch loops are evaluated at runtime outside of comptime scopes", .{});
+                try sema.explainWhyTypeIsComptime(msg, operand_src, operand_ty);
+                break :msg msg;
+            });
+        }
+        try sema.validateRuntimeValue(block, operand_src, raw_operand);
+    }
+
     const has_else = zir_switch.else_case != null;
     const has_under = zir_switch.has_under;
 
@@ -12305,7 +11648,7 @@ fn resolveSwitchBlock(
     child_block: *Block,
     operand: SwitchOperand,
     raw_operand_ty: Type,
-    maybe_lazy_cond_val: Value,
+    cond_val: Value,
     merges: *Block.Merges,
     switch_inst: Zir.Inst.Index,
     zir_switch: *const Zir.UnwrappedSwitchBlock,
@@ -12325,9 +11668,6 @@ fn resolveSwitchBlock(
     const err_set = item_ty.zigTypeTag(zcu) == .error_set;
 
     const cond_ref = operand.simple.cond;
-    // We have to resolve lazy values to ensure that comparisons with switch
-    // prong items don't produce false negatives.
-    const cond_val = try sema.resolveLazyValue(maybe_lazy_cond_val);
 
     const case_vals = validated_switch.case_vals;
     var case_val_idx: usize = 0;
@@ -12617,14 +11957,12 @@ fn wantSwitchProngBodyAnalysis(
 ) bool {
     const zcu = sema.pt.zcu;
     if (union_originally) {
-        const unresolved_item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
-        const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable;
+        const item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
         const field_ty = operand_ty.unionFieldType(item_val, zcu).?;
         if (field_ty.isNoReturn(zcu)) return false;
     }
     if (err_set and prong_is_comptime_unreach) {
-        const unresolved_item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
-        const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable;
+        const item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
         const err_name = item_val.getErrorName(zcu).unwrap().?;
         if (!Type.errorSetHasFieldIp(&zcu.intern_pool, operand_ty.toIntern(), err_name)) return false;
     }
@@ -12807,7 +12145,7 @@ fn analyzeSwitchPayloadCapture(
             const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
             if (capture_by_ref) {
                 const operand_ptr_info = sema.typeOf(operand_ptr).ptrInfo(zcu);
-                const ptr_field_ty = try pt.ptrTypeSema(.{
+                const ptr_field_ty = try pt.ptrType(.{
                     .child = field_ty.toIntern(),
                     .flags = .{
                         .is_const = operand_ptr_info.flags.is_const,
@@ -12821,6 +12159,7 @@ fn analyzeSwitchPayloadCapture(
                     const tag_and_val = ip.indexToKey(union_val.toIntern()).un;
                     return .fromIntern(tag_and_val.val);
                 }
+                if (try field_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
                 return case_block.addStructFieldVal(operand_val, field_index, field_ty);
             }
         } else if (capture_by_ref) {
@@ -12914,13 +12253,27 @@ fn analyzeSwitchPayloadCapture(
                     const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len);
                     for (field_indices, dummy_captures) |field_idx, *dummy| {
                         const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]);
-                        const field_ptr_ty = try pt.ptrTypeSema(.{
+                        const field_ptr_ty = try pt.ptrType(.{
                             .child = field_ty.toIntern(),
                             .flags = .{
                                 .is_const = operand_ptr_info.flags.is_const,
                                 .is_volatile = operand_ptr_info.flags.is_volatile,
                                 .address_space = operand_ptr_info.flags.address_space,
-                                .alignment = union_obj.fieldAlign(ip, field_idx),
+                                // TODO MLUGG: double-check this. and, um, EVERYWHERE we do ptr alignment...
+                                .alignment = a: {
+                                    if (operand_ty.explicitFieldAlignment(field_idx, zcu) == .none and
+                                        operand_ptr_info.flags.alignment == .none)
+                                    {
+                                        break :a .none;
+                                    }
+
+                                    const union_align = switch (operand_ptr_info.flags.alignment) {
+                                        .none => operand_ty.abiAlignment(zcu),
+                                        else => |a| a,
+                                    };
+                                    const field_align = operand_ty.resolvedFieldAlignment(field_idx, zcu);
+                                    break :a .minStrict(union_align, field_align);
+                                },
                             },
                         });
                         dummy.* = try pt.undefRef(field_ptr_ty);
@@ -12963,6 +12316,8 @@ fn analyzeSwitchPayloadCapture(
                 return case_block.addStructFieldPtr(operand_ptr, first_field_index, capture_ptr_ty);
             }
 
+            if (try capture_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+
             if (try sema.resolveDefinedValue(case_block, operand_src, operand_val)) |operand_val_val| {
                 if (operand_val_val.isUndef(zcu)) return pt.undefRef(capture_ty);
                 const union_val = ip.indexToKey(operand_val_val.toIntern()).un;
@@ -13119,7 +12474,7 @@ fn analyzeSwitchPayloadCapture(
                     try sema.air_instructions.append(sema.gpa, .{
                         .tag = .get_union_tag,
                         .data = .{ .ty_op = .{
-                            .ty = .fromIntern(union_obj.enum_tag_ty),
+                            .ty = .fromIntern(union_obj.enum_tag_type),
                             .operand = operand_val,
                         } },
                     });
@@ -13261,17 +12616,8 @@ fn resolveSwitchItem(
         }
         break :item_ref try sema.coerce(block, item_ty, uncoerced, item_src);
     };
-    const maybe_lazy = try sema.resolveConstDefinedValue(block, item_src, item_ref, .{ .simple = .switch_item });
-
-    // We have to resolve lazy values here to avoid false negatives when detecting
-    // duplicate items and comparing items to a comptime-known switch operand.
-
-    const val = try sema.resolveLazyValue(maybe_lazy);
-    const ref: Air.Inst.Ref = if (val.toIntern() == maybe_lazy.toIntern())
-        item_ref
-    else
-        .fromValue(val);
-    return .{ .{ .ref = ref, .val = val }, end };
+    const val = try sema.resolveConstDefinedValue(block, item_src, item_ref, .{ .simple = .switch_item });
+    return .{ .{ .ref = item_ref, .val = val }, end };
 }
 
 fn validateSwitchItemOrRange(
@@ -13488,7 +12834,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const name_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const ty = try sema.resolveType(block, ty_src, extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, name_src, extra.rhs, .{ .simple = .field_name });
-    try ty.resolveFields(pt);
+    try sema.ensureLayoutResolved(ty);
     const ip = &zcu.intern_pool;
 
     const has_field = hf: {
@@ -13510,7 +12856,8 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             },
             .union_type => {
                 const union_type = ip.loadUnionType(ty.toIntern());
-                break :hf union_type.loadTagType(ip).nameIndex(ip, field_name) != null;
+                const enum_type = ip.loadEnumType(union_type.enum_tag_type);
+                break :hf enum_type.nameIndex(ip, field_name) != null;
             },
             .enum_type => {
                 break :hf ip.loadEnumType(ty.toIntern()).nameIndex(ip, field_name) != null;
@@ -13569,10 +12916,9 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     switch (file.getMode()) {
         .zig => {
             try pt.ensureFileAnalyzed(file_index);
-            const ty = zcu.fileRootType(file_index);
-            try sema.declareDependency(.{ .interned = ty });
+            const ty: Type = .fromInterned(zcu.fileRootType(file_index));
             try sema.addTypeReferenceEntry(operand_src, ty);
-            return Air.internedToRef(ty);
+            return .fromType(ty);
         },
         .zon => {
             const res_ty: InternPool.Index = b: {
@@ -13692,8 +13038,8 @@ fn zirShl(
     // we already know `scalar_rhs_ty` is valid for `.shl` -- we only need to validate for `.shl_sat`.
     if (air_tag == .shl_sat) _ = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(rhs);
+    const maybe_lhs_val = try sema.resolveValue(lhs);
+    const maybe_rhs_val = try sema.resolveValue(rhs);
 
     const runtime_src = rs: {
         if (maybe_rhs_val) |rhs_val| {
@@ -13713,11 +13059,11 @@ fn zirShl(
             const bits = scalar_ty.intInfo(zcu).bits;
             switch (rhs_ty.zigTypeTag(zcu)) {
                 .int, .comptime_int => {
-                    switch (try rhs_val.orderAgainstZeroSema(pt)) {
+                    switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
                         .gt => {
                             if (air_tag != .shl_sat) {
                                 var rhs_space: Value.BigIntSpace = undefined;
-                                const rhs_bigint = try rhs_val.toBigIntSema(&rhs_space, pt);
+                                const rhs_bigint = rhs_val.toBigInt(&rhs_space, zcu);
                                 if (rhs_bigint.orderAgainstScalar(bits) != .lt) {
                                     return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs_val, rhs_src, null);
                                 }
@@ -13736,11 +13082,11 @@ fn zirShl(
                             .shl, .shl_exact => return sema.failWithUseOfUndef(block, rhs_src, elem_idx),
                             else => unreachable,
                         };
-                        switch (try rhs_elem.orderAgainstZeroSema(pt)) {
+                        switch (Value.order(rhs_elem, .zero_comptime_int, zcu)) {
                             .gt => {
                                 if (air_tag != .shl_sat) {
                                     var rhs_elem_space: Value.BigIntSpace = undefined;
-                                    const rhs_elem_bigint = try rhs_elem.toBigIntSema(&rhs_elem_space, pt);
+                                    const rhs_elem_bigint = rhs_elem.toBigInt(&rhs_elem_space, zcu);
                                     if (rhs_elem_bigint.orderAgainstScalar(bits) != .lt) {
                                         return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs_elem, rhs_src, elem_idx);
                                     }
@@ -13769,7 +13115,7 @@ fn zirShl(
                     .shl, .shl_exact => try sema.checkAllScalarsDefined(block, lhs_src, lhs_val),
                     else => unreachable,
                 }
-                if (try lhs_val.compareAllWithZeroSema(.eq, pt)) return lhs;
+                if (lhs_val.compareAllWithZero(.eq, zcu)) return lhs;
             }
         }
         break :rs rhs_src;
@@ -13785,13 +13131,13 @@ fn zirShl(
             const rt_rhs_scalar_ty = try pt.smallestUnsignedInt(bit_count);
             if (!rhs_ty.isVector(zcu)) break :rt_rhs try pt.intValue(
                 rt_rhs_scalar_ty,
-                @min(try rhs_val.getUnsignedIntSema(pt) orelse bit_count, bit_count),
+                @min(rhs_val.getUnsignedInt(zcu) orelse bit_count, bit_count),
             );
             const rhs_len = rhs_ty.vectorLen(zcu);
             const rhs_elems = try sema.arena.alloc(InternPool.Index, rhs_len);
             for (rhs_elems, 0..) |*rhs_elem, i| rhs_elem.* = (try pt.intValue(
                 rt_rhs_scalar_ty,
-                @min(try (try rhs_val.elemValue(pt, i)).getUnsignedIntSema(pt) orelse bit_count, bit_count),
+                @min((try rhs_val.elemValue(pt, i)).getUnsignedInt(zcu) orelse bit_count, bit_count),
             )).toIntern();
             break :rt_rhs try pt.aggregateValue(try pt.vectorType(.{
                 .len = rhs_len,
@@ -13875,8 +13221,8 @@ fn zirShr(
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     const scalar_ty = lhs_ty.scalarType(zcu);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(rhs);
+    const maybe_lhs_val = try sema.resolveValue(lhs);
+    const maybe_rhs_val = try sema.resolveValue(rhs);
 
     const runtime_src = rs: {
         if (maybe_rhs_val) |rhs_val| {
@@ -13893,10 +13239,10 @@ fn zirShr(
             const bits = scalar_ty.intInfo(zcu).bits;
             switch (rhs_ty.zigTypeTag(zcu)) {
                 .int, .comptime_int => {
-                    switch (try rhs_val.orderAgainstZeroSema(pt)) {
+                    switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
                         .gt => {
                             var rhs_space: Value.BigIntSpace = undefined;
-                            const rhs_bigint = try rhs_val.toBigIntSema(&rhs_space, pt);
+                            const rhs_bigint = rhs_val.toBigInt(&rhs_space, zcu);
                             if (rhs_bigint.orderAgainstScalar(bits) != .lt) {
                                 return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs_val, rhs_src, null);
                             }
@@ -13912,10 +13258,10 @@ fn zirShr(
                         if (rhs_elem.isUndef(zcu)) {
                             return sema.failWithUseOfUndef(block, rhs_src, elem_idx);
                         }
-                        switch (try rhs_elem.orderAgainstZeroSema(pt)) {
+                        switch (Value.order(rhs_elem, .zero_comptime_int, zcu)) {
                             .gt => {
                                 var rhs_elem_space: Value.BigIntSpace = undefined;
-                                const rhs_elem_bigint = try rhs_elem.toBigIntSema(&rhs_elem_space, pt);
+                                const rhs_elem_bigint = rhs_elem.toBigInt(&rhs_elem_space, zcu);
                                 if (rhs_elem_bigint.orderAgainstScalar(bits) != .lt) {
                                     return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs_elem, rhs_src, elem_idx);
                                 }
@@ -13936,7 +13282,7 @@ fn zirShr(
             }
             if (maybe_lhs_val) |lhs_val| {
                 try sema.checkAllScalarsDefined(block, lhs_src, lhs_val);
-                if (try lhs_val.compareAllWithZeroSema(.eq, pt)) return lhs;
+                if (lhs_val.compareAllWithZero(.eq, zcu)) return lhs;
             }
         }
         break :rs rhs_src;
@@ -14011,8 +13357,8 @@ fn zirBitwise(
     const runtime_src = runtime: {
         // TODO: ask the linker what kind of relocations are available, and
         // in some cases emit a Value that means "this decl's address AND'd with this operand".
-        if (try sema.resolveValueResolveLazy(casted_lhs)) |lhs_val| {
-            if (try sema.resolveValueResolveLazy(casted_rhs)) |rhs_val| {
+        if (try sema.resolveValue(casted_lhs)) |lhs_val| {
+            if (try sema.resolveValue(casted_rhs)) |rhs_val| {
                 const result_val = switch (air_tag) {
                     // zig fmt: off
                     .bit_and => try arith.bitwiseBin(sema, resolved_type, lhs_val, rhs_val, .@"and"),
@@ -14106,13 +13452,13 @@ fn analyzeTupleCat(
         var i: u32 = 0;
         while (i < lhs_len) : (i += 1) {
             types[i] = lhs_ty.fieldType(i, zcu).toIntern();
-            const default_val = lhs_ty.structFieldDefaultValue(i, zcu);
-            values[i] = default_val.toIntern();
             const operand_src = block.src(.{ .array_cat_lhs = .{
                 .array_cat_offset = src_node,
                 .elem_index = i,
             } });
-            if (default_val.toIntern() == .unreachable_value) {
+            if (lhs_ty.structFieldDefaultValue(i, zcu)) |default_val| {
+                values[i] = default_val.toIntern();
+            } else {
                 runtime_src = operand_src;
                 values[i] = .none;
             }
@@ -14120,13 +13466,13 @@ fn analyzeTupleCat(
         i = 0;
         while (i < rhs_len) : (i += 1) {
             types[i + lhs_len] = rhs_ty.fieldType(i, zcu).toIntern();
-            const default_val = rhs_ty.structFieldDefaultValue(i, zcu);
-            values[i + lhs_len] = default_val.toIntern();
             const operand_src = block.src(.{ .array_cat_rhs = .{
                 .array_cat_offset = src_node,
                 .elem_index = i,
             } });
-            if (default_val.toIntern() == .unreachable_value) {
+            if (rhs_ty.structFieldDefaultValue(i, zcu)) |default_val| {
+                values[i + lhs_len] = default_val.toIntern();
+            } else {
                 runtime_src = operand_src;
                 values[i + lhs_len] = .none;
             }
@@ -14290,8 +13636,8 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             var elem_i: u32 = 0;
             while (elem_i < lhs_len) : (elem_i += 1) {
                 const lhs_elem_i = elem_i;
-                const elem_default_val = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, zcu) else Value.@"unreachable";
-                const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try lhs_sub_val.elemValue(pt, lhs_elem_i) else elem_default_val;
+                const elem_default_val: ?Value = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, zcu) else null;
+                const elem_val = elem_default_val orelse try lhs_sub_val.elemValue(pt, lhs_elem_i);
                 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
                 const operand_src = block.src(.{ .array_cat_lhs = .{
                     .array_cat_offset = inst_data.src_node,
@@ -14303,8 +13649,8 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
             while (elem_i < result_len) : (elem_i += 1) {
                 const rhs_elem_i = elem_i - lhs_len;
-                const elem_default_val = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, zcu) else Value.@"unreachable";
-                const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try rhs_sub_val.elemValue(pt, rhs_elem_i) else elem_default_val;
+                const elem_default_val: ?Value = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, zcu) else null;
+                const elem_val = elem_default_val orelse try rhs_sub_val.elemValue(pt, rhs_elem_i);
                 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
                 const operand_src = block.src(.{ .array_cat_rhs = .{
                     .array_cat_offset = inst_data.src_node,
@@ -14324,18 +13670,18 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     try sema.requireRuntimeBlock(block, src, runtime_src);
 
     if (ptr_addrspace) |ptr_as| {
-        const constant_alloc_ty = try pt.ptrTypeSema(.{
+        const constant_alloc_ty = try pt.ptrType(.{
             .child = result_ty.toIntern(),
             .flags = .{
                 .address_space = ptr_as,
                 .is_const = true,
             },
         });
-        const alloc_ty = try pt.ptrTypeSema(.{
+        const alloc_ty = try pt.ptrType(.{
             .child = result_ty.toIntern(),
             .flags = .{ .address_space = ptr_as },
         });
-        const elem_ptr_ty = try pt.ptrTypeSema(.{
+        const elem_ptr_ty = try pt.ptrType(.{
             .child = resolved_elem_ty.toIntern(),
             .flags = .{ .address_space = ptr_as },
         });
@@ -14347,7 +13693,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         if (lhs_ty.zigTypeTag(zcu) == .pointer and
             rhs_ty.zigTypeTag(zcu) == .pointer)
         {
-            const slice_ty = try pt.ptrTypeSema(.{
+            const slice_ty = try pt.ptrType(.{
                 .child = resolved_elem_ty.toIntern(),
                 .flags = .{
                     .size = .slice,
@@ -14486,7 +13832,7 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
                             .none => null,
                             else => Value.fromInterned(ptr_info.sentinel),
                         },
-                        .len = try val.sliceLen(pt),
+                        .len = val.sliceLen(zcu),
                     };
                 },
                 .one => {
@@ -14500,8 +13846,20 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
         .@"struct" => {
             if (operand_ty.isTuple(zcu) and peer_ty.isIndexable(zcu)) {
                 assert(!peer_ty.isTuple(zcu));
+                const peer_elem_ty = switch (peer_ty.zigTypeTag(zcu)) {
+                    .pointer => switch (peer_ty.ptrSize(zcu)) {
+                        .one => switch (peer_ty.childType(zcu).zigTypeTag(zcu)) {
+                            .array, .vector => peer_ty.childType(zcu).childType(zcu),
+                            .@"struct" => return null,
+                            else => unreachable,
+                        },
+                        .many, .c, .slice => peer_ty.childType(zcu),
+                    },
+                    .vector, .array => peer_ty.childType(zcu),
+                    else => unreachable,
+                };
                 return .{
-                    .elem_type = peer_ty.elemType2(zcu),
+                    .elem_type = peer_elem_ty,
                     .sentinel = null,
                     .len = operand_ty.arrayLen(zcu),
                 };
@@ -14543,12 +13901,13 @@ fn analyzeTupleMul(
         var runtime_src: ?LazySrcLoc = null;
         for (0..tuple_len) |i| {
             types[i] = operand_ty.fieldType(i, zcu).toIntern();
-            values[i] = operand_ty.structFieldDefaultValue(i, zcu).toIntern();
             const operand_src = block.src(.{ .array_cat_lhs = .{
                 .array_cat_offset = src_node,
                 .elem_index = @intCast(i),
             } });
-            if (values[i] == .unreachable_value) {
+            if (operand_ty.structFieldDefaultValue(i, zcu)) |default_val| {
+                values[i] = default_val.toIntern();
+            } else {
                 runtime_src = operand_src;
                 values[i] = .none; // TODO don't treat unreachable_value as special
             }
@@ -14714,7 +14073,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     }
 
     if (ptr_addrspace) |ptr_as| {
-        const alloc_ty = try pt.ptrTypeSema(.{
+        const alloc_ty = try pt.ptrType(.{
             .child = result_ty.toIntern(),
             .flags = .{
                 .address_space = ptr_as,
@@ -14722,7 +14081,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             },
         });
         const alloc = try block.addTy(.alloc, alloc_ty);
-        const elem_ptr_ty = try pt.ptrTypeSema(.{
+        const elem_ptr_ty = try pt.ptrType(.{
             .child = lhs_info.elem_type.toIntern(),
             .flags = .{ .address_space = ptr_as },
         });
@@ -14859,8 +14218,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     if ((lhs_ty.zigTypeTag(zcu) == .comptime_float and rhs_ty.zigTypeTag(zcu) == .comptime_int) or
         (lhs_ty.zigTypeTag(zcu) == .comptime_int and rhs_ty.zigTypeTag(zcu) == .comptime_float))
@@ -14968,8 +14327,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_exact);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     // Because `@divExact` can trigger Illegal Behavior, undefined operands trigger Illegal Behavior.
 
@@ -15064,8 +14423,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_floor);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -15129,8 +14488,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_trunc);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -15341,8 +14700,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod_rem);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     const lhs_maybe_negative = a: {
         if (lhs_scalar_ty.isUnsignedInt(zcu)) break :a false;
@@ -15440,8 +14799,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -15504,8 +14863,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .rem);
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -15601,12 +14960,12 @@ fn zirOverflowArithmetic(
                 // to the result, even if it is undefined..
                 // Otherwise, if either of the argument is undefined, undefined is returned.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!lhs_val.isUndef(zcu) and lhs_val.compareAllWithZero(.eq, zcu)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = rhs };
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (!rhs_val.isUndef(zcu) and (try rhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!rhs_val.isUndef(zcu) and rhs_val.compareAllWithZero(.eq, zcu)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = lhs };
                     }
                 }
@@ -15627,7 +14986,7 @@ fn zirOverflowArithmetic(
                 if (maybe_rhs_val) |rhs_val| {
                     if (rhs_val.isUndef(zcu)) {
                         break :result .{ .overflow_bit = .undef, .wrapped = .undef };
-                    } else if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
+                    } else if (rhs_val.compareAllWithZero(.eq, zcu)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = lhs };
                     } else if (maybe_lhs_val) |lhs_val| {
                         if (lhs_val.isUndef(zcu)) {
@@ -15642,12 +15001,12 @@ fn zirOverflowArithmetic(
             .mul_with_overflow => {
                 // If either of the arguments is zero, the result is zero and no overflow occured.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu) and try lhs_val.compareAllWithZeroSema(.eq, pt)) {
+                    if (!lhs_val.isUndef(zcu) and lhs_val.compareAllWithZero(.eq, zcu)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = lhs };
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (!rhs_val.isUndef(zcu) and try rhs_val.compareAllWithZeroSema(.eq, pt)) {
+                    if (!rhs_val.isUndef(zcu) and rhs_val.compareAllWithZero(.eq, zcu)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = rhs };
                     }
                 }
@@ -15694,10 +15053,10 @@ fn zirOverflowArithmetic(
                     const bits = scalar_ty.intInfo(zcu).bits;
                     switch (rhs_ty.zigTypeTag(zcu)) {
                         .int, .comptime_int => {
-                            switch (try rhs_val.orderAgainstZeroSema(pt)) {
+                            switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
                                 .gt => {
                                     var rhs_space: Value.BigIntSpace = undefined;
-                                    const rhs_bigint = try rhs_val.toBigIntSema(&rhs_space, pt);
+                                    const rhs_bigint = rhs_val.toBigInt(&rhs_space, zcu);
                                     if (rhs_bigint.orderAgainstScalar(bits) != .lt) {
                                         return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs_val, rhs_src, null);
                                     }
@@ -15711,10 +15070,10 @@ fn zirOverflowArithmetic(
                             for (0..rhs_ty.vectorLen(zcu)) |elem_idx| {
                                 const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
                                 if (rhs_elem.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src, elem_idx);
-                                switch (try rhs_elem.orderAgainstZeroSema(pt)) {
+                                switch (Value.order(rhs_elem, .zero_comptime_int, zcu)) {
                                     .gt => {
                                         var rhs_elem_space: Value.BigIntSpace = undefined;
-                                        const rhs_elem_bigint = try rhs_elem.toBigIntSema(&rhs_elem_space, pt);
+                                        const rhs_elem_bigint = rhs_elem.toBigInt(&rhs_elem_space, zcu);
                                         if (rhs_elem_bigint.orderAgainstScalar(bits) != .lt) {
                                             return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs_elem, rhs_src, elem_idx);
                                         }
@@ -15728,7 +15087,7 @@ fn zirOverflowArithmetic(
                         },
                         else => unreachable,
                     }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
+                    if (rhs_val.compareAllWithZero(.eq, zcu)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = lhs };
                     }
                 } else {
@@ -15737,7 +15096,7 @@ fn zirOverflowArithmetic(
                     }
                     if (maybe_lhs_val) |lhs_val| {
                         try sema.checkAllScalarsDefined(block, lhs_src, lhs_val);
-                        if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
+                        if (lhs_val.compareAllWithZero(.eq, zcu)) {
                             break :result .{ .overflow_bit = try sema.splat(overflow_ty, .zero_u1), .inst = lhs };
                         }
                     }
@@ -15817,16 +15176,16 @@ fn analyzeArithmetic(
                 if (zir_tag != .sub) {
                     return sema.failWithInvalidPtrArithmetic(block, src, "pointer-pointer", "subtraction");
                 }
-                if (!lhs_ty.elemType2(zcu).eql(rhs_ty.elemType2(zcu), zcu)) {
+                if (!lhs_ty.childType(zcu).eql(rhs_ty.childType(zcu), zcu)) {
                     return sema.fail(block, src, "incompatible pointer arithmetic operands '{f}' and '{f}'", .{
                         lhs_ty.fmt(pt), rhs_ty.fmt(pt),
                     });
                 }
 
-                const elem_size = lhs_ty.elemType2(zcu).abiSize(zcu);
+                const elem_size = lhs_ty.childType(zcu).abiSize(zcu);
                 if (elem_size == 0) {
-                    return sema.fail(block, src, "pointer arithmetic requires element type '{f}' to have runtime bits", .{
-                        lhs_ty.elemType2(zcu).fmt(pt),
+                    return sema.fail(block, src, "pointer subtraction requires element type '{f}' to have runtime bits", .{
+                        lhs_ty.childType(zcu).fmt(pt),
                     });
                 }
 
@@ -15875,11 +15234,7 @@ fn analyzeArithmetic(
                         else => return sema.failWithInvalidPtrArithmetic(block, src, "pointer-integer", "addition and subtraction"),
                     };
 
-                    if (!try lhs_ty.elemType2(zcu).hasRuntimeBitsSema(pt)) {
-                        return sema.fail(block, src, "pointer arithmetic requires element type '{f}' to have runtime bits", .{
-                            lhs_ty.elemType2(zcu).fmt(pt),
-                        });
-                    }
+                    try sema.ensureLayoutResolved(lhs_ty.childType(zcu));
                     return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);
                 },
             }
@@ -15915,8 +15270,8 @@ fn analyzeArithmetic(
         else => unreachable,
     };
 
-    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
 
     if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
@@ -15972,6 +15327,7 @@ fn analyzeArithmetic(
     return block.addBinOp(air_tag, casted_lhs, casted_rhs);
 }
 
+/// Asserts that the layout of the pointer child type is already resolved.
 fn analyzePtrArithmetic(
     sema: *Sema,
     block: *Block,
@@ -15993,7 +15349,10 @@ fn analyzePtrArithmetic(
     const ptr_info = ptr_ty.ptrInfo(zcu);
     assert(ptr_info.flags.size == .many or ptr_info.flags.size == .c);
 
-    if ((try sema.typeHasOnePossibleValue(.fromInterned(ptr_info.child))) != null) {
+    const elem_ty: Type = .fromInterned(ptr_info.child);
+    elem_ty.assertHasLayout(zcu);
+
+    if (elem_ty.abiSize(zcu) == 0) {
         // Offset will be multiplied by zero, so result is the same as the base pointer.
         return ptr;
     }
@@ -16007,9 +15366,9 @@ fn analyzePtrArithmetic(
         }
         // If the addend is not a comptime-known value we can still count on
         // it being a multiple of the type size.
-        const elem_size = try Type.fromInterned(ptr_info.child).abiSizeSema(pt);
+        const elem_size = elem_ty.abiSize(zcu);
         const addend = if (opt_off_val) |off_val| a: {
-            const off_int = try sema.usizeCast(block, offset_src, try off_val.toUnsignedIntSema(pt));
+            const off_int = try sema.usizeCast(block, offset_src, off_val.toUnsignedInt(zcu));
             break :a elem_size * off_int;
         } else elem_size;
 
@@ -16022,7 +15381,7 @@ fn analyzePtrArithmetic(
         ));
         assert(new_align != .none);
 
-        break :t try pt.ptrTypeSema(.{
+        break :t try pt.ptrType(.{
             .child = ptr_info.child,
             .sentinel = ptr_info.sentinel,
             .flags = .{
@@ -16041,10 +15400,10 @@ fn analyzePtrArithmetic(
             if (opt_off_val) |offset_val| {
                 if (ptr_val.isUndef(zcu)) return pt.undefRef(new_ptr_ty);
 
-                const offset_int = try sema.usizeCast(block, offset_src, try offset_val.toUnsignedIntSema(pt));
+                const offset_int = try sema.usizeCast(block, offset_src, offset_val.toUnsignedInt(zcu));
                 if (offset_int == 0) return ptr;
                 if (air_tag == .ptr_sub) {
-                    const elem_size = try Type.fromInterned(ptr_info.child).abiSizeSema(pt);
+                    const elem_size = elem_ty.abiSize(zcu);
                     const new_ptr_val = try sema.ptrSubtract(block, op_src, ptr_val, offset_int * elem_size, new_ptr_ty);
                     return Air.internedToRef(new_ptr_val.toIntern());
                 } else {
@@ -16248,6 +15607,7 @@ fn zirAsm(
         buffer[input.c.len + 1 + input.n.len] = 0;
         sema.air_extra.items.len += (input.c.len + input.n.len + (2 + 3)) / 4;
     }
+    if (try expr_ty.toType().onePossibleValue(pt)) |opv| return .fromValue(opv);
     return asm_air;
 }
 
@@ -16343,7 +15703,6 @@ fn analyzeCmpUnionTag(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const union_ty = sema.typeOf(un);
-    try union_ty.resolveFields(pt);
     const union_tag_ty = union_ty.unionTagType(zcu) orelse {
         const msg = msg: {
             const msg = try sema.errMsg(un_src, "comparison of union and enum literal is only valid for tagged union types", .{});
@@ -16534,10 +15893,11 @@ fn runtimeBoolCmp(
 
 fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
-    switch (ty.zigTypeTag(pt.zcu)) {
+    switch (ty.zigTypeTag(zcu)) {
         .@"fn",
         .noreturn,
         .undefined,
@@ -16568,8 +15928,8 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         .@"anyframe",
         => {},
     }
-    const val = try ty.abiSizeLazy(pt);
-    return Air.internedToRef(val.toIntern());
+    try sema.ensureLayoutResolved(ty);
+    return .fromValue(try pt.intValue(.comptime_int, ty.abiSize(zcu)));
 }
 
 fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -16609,8 +15969,8 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         .@"anyframe",
         => {},
     }
-    const bit_size = try operand_ty.bitSizeSema(pt);
-    return pt.intRef(.comptime_int, bit_size);
+    try sema.ensureLayoutResolved(operand_ty);
+    return .fromValue(try pt.intValue(.comptime_int, operand_ty.bitSize(zcu)));
 }
 
 fn zirThis(
@@ -16619,34 +15979,16 @@ fn zirThis(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     _ = extended;
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const namespace = pt.zcu.namespacePtr(block.namespace);
+    const zcu = sema.pt.zcu;
+    const namespace = zcu.namespacePtr(block.namespace);
 
-    switch (pt.zcu.intern_pool.indexToKey(namespace.owner_type)) {
-        .opaque_type => {
-            // Opaque types are never outdated since they don't undergo type resolution, so nothing to do!
-            return Air.internedToRef(namespace.owner_type);
-        },
-        .struct_type, .union_type => {
-            const new_ty = try pt.ensureTypeUpToDate(namespace.owner_type);
-            try sema.declareDependency(.{ .interned = new_ty });
-            return Air.internedToRef(new_ty);
-        },
-        .enum_type => {
-            const new_ty = try pt.ensureTypeUpToDate(namespace.owner_type);
-            try sema.declareDependency(.{ .interned = new_ty });
-            // Since this is an enum, it has to be resolved immediately.
-            // `ensureTypeUpToDate` has resolved the new type if necessary.
-            // We just need to check for resolution failures.
-            const ty_unit: AnalUnit = .wrap(.{ .type = new_ty });
-            if (zcu.failed_analysis.contains(ty_unit) or zcu.transitive_failed_analysis.contains(ty_unit)) {
-                return error.AnalysisFail;
-            }
-            return Air.internedToRef(new_ty);
-        },
+    switch (zcu.intern_pool.indexToKey(namespace.owner_type)) {
+        .opaque_type, .struct_type, .union_type => {},
+        // Enum inits are resolved eagerly. TODO MLUGG: honestly i don't think they SHOULD be lol
+        .enum_type => try sema.ensureFieldInitsResolved(.fromInterned(namespace.owner_type)),
         else => unreachable,
     }
+    return .fromIntern(namespace.owner_type);
 }
 
 fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
@@ -16739,7 +16081,7 @@ fn zirRetAddr(
     _ = sema;
     _ = extended;
     if (block.isComptime()) {
-        // TODO: we could give a meaningful lazy value here. #14938
+        // TODO: we could give a meaningful value here. #14938
         return .zero_usize;
     } else {
         return block.addNoOp(.ret_addr);
@@ -16886,6 +16228,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         try sema.declareDependency(.{ .namespace = type_decl_inst });
     }
 
+    try sema.ensureLayoutResolved(ty);
+
     switch (ty.zigTypeTag(zcu)) {
         .type,
         .void,
@@ -16934,7 +16278,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .child = param_info_ty.toIntern(),
                 });
                 const new_decl_val = (try pt.aggregateValue(new_decl_ty, param_vals)).toIntern();
-                const slice_ty = (try pt.ptrTypeSema(.{
+                const slice_ty = (try pt.ptrType(.{
                     .child = param_info_ty.toIntern(),
                     .flags = .{
                         .size = .slice,
@@ -16976,11 +16320,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 error.OutOfMemory => |e| return e,
             };
 
+            // MLUGG TODO
+            const func_is_generic = false;
+
             const field_values: [5]InternPool.Index = .{
                 // calling_convention: CallingConvention,
                 callconv_val.toIntern(),
                 // is_generic: bool,
-                Value.makeBool(func_ty_info.is_generic).toIntern(),
+                Value.makeBool(func_is_generic).toIntern(),
                 // is_var_args: bool,
                 Value.makeBool(func_ty_info.is_var_args).toIntern(),
                 // return_type: ?type,
@@ -17015,7 +16362,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const field_vals = .{
                 // bits: u16,
-                (try pt.intValue(.u16, ty.bitSize(zcu))).toIntern(),
+                (try pt.intValue(.u16, ty.floatBits(zcu.getTarget()))).toIntern(),
             };
             return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
@@ -17025,10 +16372,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         },
         .pointer => {
             const info = ty.ptrInfo(zcu);
-            const alignment = if (info.flags.alignment.toByteUnits()) |alignment|
-                try pt.intValue(.comptime_int, alignment)
-            else
-                try Type.fromInterned(info.child).lazyAbiAlignment(pt);
+            const alignment_val = try pt.intValue(.comptime_int, bytes: {
+                if (info.flags.alignment.toByteUnits()) |b| break :bytes b;
+                const elem_ty: Type = .fromInterned(info.child);
+                // MLUGG TODO: this resolution is sus, but i doubt i'll solve it in this branch
+                try sema.ensureLayoutResolved(elem_ty);
+                break :bytes elem_ty.abiAlignment(zcu).toByteUnits().?;
+            });
 
             const addrspace_ty = try sema.getBuiltinType(src, .AddressSpace);
             const pointer_ty = try sema.getBuiltinType(src, .@"Type.Pointer");
@@ -17042,7 +16392,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // is_volatile: bool,
                 Value.makeBool(info.flags.is_volatile).toIntern(),
                 // alignment: comptime_int,
-                alignment.toIntern(),
+                alignment_val.toIntern(),
                 // address_space: AddressSpace
                 (try pt.enumValueFieldIndex(addrspace_ty, @intFromEnum(info.flags.address_space))).toIntern(),
                 // child: type,
@@ -17159,7 +16509,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             };
 
             // Build our ?[]const Error value
-            const slice_errors_ty = try pt.ptrTypeSema(.{
+            const slice_errors_ty = try pt.ptrType(.{
                 .child = error_field_ty.toIntern(),
                 .flags = .{
                     .size = .slice,
@@ -17215,19 +16565,19 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             })));
         },
         .@"enum" => {
-            const is_exhaustive = Value.makeBool(ip.loadEnumType(ty.toIntern()).tag_mode != .nonexhaustive);
+            const enum_obj = ip.loadEnumType(ty.toIntern());
+            const is_exhaustive: Value = .makeBool(!enum_obj.nonexhaustive);
 
             const enum_field_ty = try sema.getBuiltinType(src, .@"Type.EnumField");
 
-            const enum_field_vals = try sema.arena.alloc(InternPool.Index, ip.loadEnumType(ty.toIntern()).names.len);
+            const enum_field_vals = try sema.arena.alloc(InternPool.Index, enum_obj.field_names.len);
             for (enum_field_vals, 0..) |*field_val, tag_index| {
-                const enum_type = ip.loadEnumType(ty.toIntern());
-                const value_val = if (enum_type.values.len > 0)
+                const value_val = if (enum_obj.field_values.len > 0)
                     try ip.getCoercedInts(
                         gpa,
                         io,
                         pt.tid,
-                        ip.indexToKey(enum_type.values.get(ip)[tag_index]).int,
+                        ip.indexToKey(enum_obj.field_values.get(ip)[tag_index]).int,
                         .comptime_int_type,
                     )
                 else
@@ -17235,7 +16585,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
                 // TODO: write something like getCoercedInts to avoid needing to dupe
                 const name_val = v: {
-                    const tag_name = enum_type.names.get(ip)[tag_index];
+                    const tag_name = enum_obj.field_names.get(ip)[tag_index];
                     const tag_name_len = tag_name.length(ip);
                     const new_decl_ty = try pt.arrayType(.{
                         .len = tag_name_len,
@@ -17275,7 +16625,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .child = enum_field_ty.toIntern(),
                 });
                 const new_decl_val = (try pt.aggregateValue(fields_array_ty, enum_field_vals)).toIntern();
-                const slice_ty = (try pt.ptrTypeSema(.{
+                const slice_ty = (try pt.ptrType(.{
                     .child = enum_field_ty.toIntern(),
                     .flags = .{
                         .size = .slice,
@@ -17303,7 +16653,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const field_values = .{
                 // tag_type: type,
-                ip.loadEnumType(ty.toIntern()).tag_ty,
+                ip.loadEnumType(ty.toIntern()).int_tag_type,
                 // fields: []const EnumField,
                 fields_val,
                 // decls: []const Declaration,
@@ -17321,17 +16671,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const type_union_ty = try sema.getBuiltinType(src, .@"Type.Union");
             const union_field_ty = try sema.getBuiltinType(src, .@"Type.UnionField");
 
-            try ty.resolveLayout(pt); // Getting alignment requires type layout
-            const union_obj = zcu.typeToUnion(ty).?;
-            const tag_type = union_obj.loadTagType(ip);
-            const layout = union_obj.flagsUnordered(ip).layout;
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            const enum_obj = ip.loadEnumType(union_obj.enum_tag_type);
+            const layout = union_obj.layout;
 
-            const union_field_vals = try gpa.alloc(InternPool.Index, tag_type.names.len);
+            const union_field_vals = try gpa.alloc(InternPool.Index, enum_obj.field_names.len);
             defer gpa.free(union_field_vals);
 
             for (union_field_vals, 0..) |*field_val, field_index| {
                 const name_val = v: {
-                    const field_name = tag_type.names.get(ip)[field_index];
+                    const field_name = enum_obj.field_names.get(ip)[field_index];
                     const field_name_len = field_name.length(ip);
                     const new_decl_ty = try pt.arrayType(.{
                         .len = field_name_len,
@@ -17357,7 +16706,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 };
 
                 const alignment = switch (layout) {
-                    .auto, .@"extern" => try ty.fieldAlignmentSema(field_index, pt),
+                    .auto, .@"extern" => ty.resolvedFieldAlignment(field_index, zcu),
                     .@"packed" => .none,
                 };
 
@@ -17379,7 +16728,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .child = union_field_ty.toIntern(),
                 });
                 const new_decl_val = (try pt.aggregateValue(array_fields_ty, union_field_vals)).toIntern();
-                const slice_ty = (try pt.ptrTypeSema(.{
+                const slice_ty = (try pt.ptrType(.{
                     .child = union_field_ty.toIntern(),
                     .flags = .{
                         .size = .slice,
@@ -17431,8 +16780,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const type_struct_ty = try sema.getBuiltinType(src, .@"Type.Struct");
             const struct_field_ty = try sema.getBuiltinType(src, .@"Type.StructField");
 
-            try ty.resolveLayout(pt); // Getting alignment requires type layout
-
             var struct_field_vals: []InternPool.Index = &.{};
             defer gpa.free(struct_field_vals);
             fv: {
@@ -17468,8 +16815,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                                 } });
                             };
 
-                            try Type.fromInterned(field_ty).resolveLayout(pt);
-
                             const is_comptime = field_val != .none;
                             const opt_default_val = if (is_comptime) Value.fromInterned(field_val) else null;
                             const default_val_ptr = try sema.optRefValue(opt_default_val);
@@ -17492,16 +16837,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .struct_type => ip.loadStructType(ty.toIntern()),
                     else => unreachable,
                 };
+                try sema.ensureFieldInitsResolved(ty); // can't do this sooner, since it's not allowed on tuples
                 struct_field_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len);
 
-                try ty.resolveStructFieldInits(pt);
-
                 for (struct_field_vals, 0..) |*field_val, field_index| {
-                    const field_name = struct_type.fieldName(ip, field_index);
+                    const field_name = struct_type.field_names.get(ip)[field_index];
                     const field_name_len = field_name.length(ip);
                     const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
-                    const field_init = struct_type.fieldInit(ip, field_index);
-                    const field_is_comptime = struct_type.fieldIsComptime(ip, field_index);
+                    const field_default: InternPool.Index = if (struct_type.field_defaults.len > 0) d: {
+                        break :d struct_type.field_defaults.get(ip)[field_index];
+                    } else .none;
+                    const field_is_comptime = struct_type.field_is_comptime_bits.get(ip, field_index);
                     const name_val = v: {
                         const new_decl_ty = try pt.arrayType(.{
                             .len = field_name_len,
@@ -17526,15 +16872,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         } });
                     };
 
-                    const opt_default_val = if (field_init == .none) null else Value.fromInterned(field_init);
+                    const opt_default_val: ?Value = if (field_default == .none) null else .fromInterned(field_default);
                     const default_val_ptr = try sema.optRefValue(opt_default_val);
                     const alignment = switch (struct_type.layout) {
+                        .auto, .@"extern" => ty.resolvedFieldAlignment(field_index, zcu),
                         .@"packed" => .none,
-                        else => try field_ty.structFieldAlignmentSema(
-                            struct_type.fieldAlign(ip, field_index),
-                            struct_type.layout,
-                            pt,
-                        ),
                     };
 
                     const struct_field_fields = .{
@@ -17559,7 +16901,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .child = struct_field_ty.toIntern(),
                 });
                 const new_decl_val = (try pt.aggregateValue(array_fields_ty, struct_field_vals)).toIntern();
-                const slice_ty = (try pt.ptrTypeSema(.{
+                const slice_ty = (try pt.ptrType(.{
                     .child = struct_field_ty.toIntern(),
                     .flags = .{
                         .size = .slice,
@@ -17585,9 +16927,9 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const backing_integer_val = try pt.intern(.{ .opt = .{
                 .ty = (try pt.optionalType(.type_type)).toIntern(),
-                .val = if (zcu.typeToPackedStruct(ty)) |packed_struct| val: {
-                    assert(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)).isInt(zcu));
-                    break :val packed_struct.backingIntTypeUnordered(ip);
+                .val = if (zcu.typeToPackedStruct(ty)) |struct_obj| val: {
+                    assert(Type.fromInterned(struct_obj.packed_backing_int_type).isInt(zcu));
+                    break :val struct_obj.packed_backing_int_type;
                 } else .none,
             } });
 
@@ -17616,7 +16958,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .@"opaque" => {
             const type_opaque_ty = try sema.getBuiltinType(src, .@"Type.Opaque");
 
-            try ty.resolveFields(pt);
             const decls_val = try sema.typeInfoDecls(src, ty.getNamespace(zcu));
 
             const field_values = .{
@@ -17658,7 +16999,7 @@ fn typeInfoDecls(
         .child = declaration_ty.toIntern(),
     });
     const new_decl_val = (try pt.aggregateValue(array_decl_ty, decl_vals.items)).toIntern();
-    const slice_ty = (try pt.ptrTypeSema(.{
+    const slice_ty = (try pt.ptrType(.{
         .child = declaration_ty.toIntern(),
         .flags = .{
             .size = .slice,
@@ -17783,22 +17124,12 @@ fn log2IntType(sema: *Sema, block: *Block, operand: Type, src: LazySrcLoc) Compi
     const zcu = pt.zcu;
     switch (operand.zigTypeTag(zcu)) {
         .comptime_int => return .comptime_int,
-        .int => {
-            const bits = operand.bitSize(zcu);
-            const count = if (bits == 0)
-                0
-            else blk: {
-                var count: u16 = 0;
-                var s = bits - 1;
-                while (s != 0) : (s >>= 1) {
-                    count += 1;
-                }
-                break :blk count;
-            };
-            return pt.intType(.unsigned, count);
-        },
+        .int => return pt.intType(.unsigned, switch (operand.intInfo(zcu).bits) {
+            0 => 0,
+            else => |b| std.math.log2_int_ceil(u16, b),
+        }),
         .vector => {
-            const elem_ty = operand.elemType2(zcu);
+            const elem_ty = operand.childType(zcu);
             const log2_elem_ty = try sema.log2IntType(block, elem_ty, src);
             return pt.vectorType(.{
                 .len = operand.vectorLen(zcu),
@@ -18082,13 +17413,15 @@ fn zirIsNonNullPtr(
     const src = block.nodeOffset(inst_data.src_node);
     const ptr = try sema.resolveInst(inst_data.operand);
     const ptr_ty = sema.typeOf(ptr);
-    try sema.checkNullableType(block, src, sema.typeOf(ptr).elemType2(zcu));
+    assert(ptr_ty.zigTypeTag(zcu) == .pointer);
+    const nullable_ty = ptr_ty.childType(zcu);
+    try sema.checkNullableType(block, src, nullable_ty);
     if (try sema.resolveValue(ptr)) |ptr_val| {
-        if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |loaded_val| {
-            return sema.analyzeIsNull(block, Air.internedToRef(loaded_val.toIntern()), true);
+        if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |nullable_val| {
+            return sema.analyzeIsNull(block, .fromValue(nullable_val), true);
         }
     }
-    if (ptr_ty.childType(zcu).isNullFromType(zcu)) |is_null| {
+    if (nullable_ty.isNullFromType(zcu)) |is_null| {
         return if (is_null) .bool_false else .bool_true;
     }
     return block.addUnOp(.is_non_null_ptr, ptr);
@@ -18125,7 +17458,10 @@ fn zirIsNonErrPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ptr = try sema.resolveInst(inst_data.operand);
-    try sema.checkErrorType(block, src, sema.typeOf(ptr).elemType2(zcu));
+    const ptr_ty = sema.typeOf(ptr);
+    assert(ptr_ty.zigTypeTag(zcu) == .pointer);
+    const error_ty = ptr_ty.childType(zcu);
+    try sema.checkErrorType(block, src, error_ty);
     const loaded = try sema.analyzeLoad(block, src, ptr, src);
     return sema.analyzeIsNonErr(block, src, loaded);
 }
@@ -18294,6 +17630,11 @@ fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!
         } },
     });
     sema.air_extra.appendSliceAssumeCapacity(@ptrCast(sub_block.instructions.items));
+
+    // The payload type might still be OPV, in which case `try_inst` is just there for the runtime
+    // control flow and we should return a comptime-known result.
+    if (try err_union_ty.errorUnionPayload(zcu).onePossibleValue(pt)) |opv| return .fromValue(opv);
+
     return try_inst;
 }
 
@@ -18347,7 +17688,7 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
 
     const operand_ty = sema.typeOf(operand);
     const ptr_info = operand_ty.ptrInfo(zcu);
-    const res_ty = try pt.ptrTypeSema(.{
+    const res_ty = try pt.ptrType(.{
         .child = err_union_ty.errorUnionPayload(zcu).toIntern(),
         .flags = .{
             .is_const = ptr_info.flags.is_const,
@@ -18512,7 +17853,7 @@ fn zirRetImplicit(
 
     const operand = try sema.resolveInst(inst_data.operand);
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = .zero });
-    const base_tag = sema.fn_ret_ty.baseZigTypeTag(zcu);
+    const base_tag = sema.fn_ret_ty.optEuBaseType(zcu).zigTypeTag(zcu);
     if (base_tag == .noreturn) {
         const msg = msg: {
             const msg = try sema.errMsg(ret_ty_src, "function declared '{f}' implicitly returns", .{
@@ -18809,8 +18150,6 @@ fn analyzeRet(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
-    try sema.fn_ret_ty.resolveLayout(pt);
-
     try sema.validateRuntimeValue(block, operand_src, operand);
 
     const air_tag: Air.Inst.Tag = if (block.wantSafety()) .ret_safe else .ret;
@@ -18889,16 +18228,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         extra_i += 1;
         const coerced = try sema.coerce(block, align_ty, try sema.resolveInst(ref), align_src);
         const val = try sema.resolveConstDefinedValue(block, align_src, coerced, .{ .simple = .@"align" });
-        // Check if this happens to be the lazy alignment of our element type, in
-        // which case we can make this 0 without resolving it.
-        switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-            .int => |int| switch (int.storage) {
-                .lazy_align => |lazy_ty| if (lazy_ty == elem_ty.toIntern()) break :blk .none,
-                else => {},
-            },
-            else => {},
-        }
-        const align_bytes = (try val.getUnsignedIntSema(pt)).?;
+        const align_bytes = val.toUnsignedInt(zcu);
         break :blk try sema.validateAlign(block, align_src, align_bytes);
     } else .none;
 
@@ -18928,7 +18258,8 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
                 elem_ty.fmt(pt), bit_offset, bit_offset - host_size * 8, host_size,
             });
         }
-        const elem_bit_size = try elem_ty.bitSizeSema(pt);
+        try sema.ensureLayoutResolved(elem_ty);
+        const elem_bit_size = elem_ty.bitSize(zcu);
         if (elem_bit_size > host_size * 8 - bit_offset) {
             return sema.fail(block, bitoffset_src, "packed type '{f}' at bit offset {d} ends {d} bits after the end of a {d} byte host integer", .{
                 elem_ty.fmt(pt), bit_offset, elem_bit_size - (host_size * 8 - bit_offset), host_size,
@@ -18957,16 +18288,16 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         }
     }
 
-    if (host_size != 0 and !try sema.validatePackedType(elem_ty)) {
+    if (host_size != 0 and !elem_ty.packable(zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(elem_ty_src, "bit-pointer cannot refer to value of type '{f}'", .{elem_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
-            try sema.explainWhyTypeIsNotPacked(msg, elem_ty_src, elem_ty);
+            try sema.explainWhyTypeIsNotPackable(msg, elem_ty_src, elem_ty);
             break :msg msg;
         });
     }
 
-    const ty = try pt.ptrTypeSema(.{
+    const ty = try pt.ptrType(.{
         .child = elem_ty.toIntern(),
         .sentinel = sentinel,
         .flags = .{
@@ -18996,6 +18327,8 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const pt = sema.pt;
     const zcu = pt.zcu;
 
+    try sema.ensureLayoutResolved(obj_ty);
+
     switch (obj_ty.zigTypeTag(zcu)) {
         .@"struct" => return sema.structInitEmpty(block, obj_ty, src, src),
         .array, .vector => return sema.arrayInitEmpty(block, src, obj_ty),
@@ -19058,6 +18391,9 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
             .child = ptr_ty.childType(zcu).toIntern(),
         });
     } else ty_operand;
+
+    try sema.ensureLayoutResolved(init_ty);
+
     const obj_ty = init_ty.optEuBaseType(zcu);
 
     const empty_ref = switch (obj_ty.zigTypeTag(zcu)) {
@@ -19076,6 +18412,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
     }
 }
 
+/// Asserts that the layout of `struct_ty` is already resolved.
 fn structInitEmpty(
     sema: *Sema,
     block: *Block,
@@ -19087,7 +18424,7 @@ fn structInitEmpty(
     const zcu = pt.zcu;
     const gpa = sema.gpa;
     // This logic must be synchronized with that in `zirStructInit`.
-    try struct_ty.resolveFields(pt);
+    struct_ty.assertHasLayout(zcu);
 
     // The init values to use for the struct instance.
     const field_inits = try gpa.alloc(Air.Inst.Ref, struct_ty.structFieldCount(zcu));
@@ -19202,8 +18539,8 @@ fn zirStructInit(
         // The type wasn't actually known, so treat this as an anon struct init.
         return sema.structInitAnon(block, src, inst, .typed_init, extra.data, extra.end, is_ref);
     };
+    try sema.ensureLayoutResolved(result_ty);
     const resolved_ty = result_ty.optEuBaseType(zcu);
-    try resolved_ty.resolveLayout(pt);
 
     if (resolved_ty.zigTypeTag(zcu) == .@"struct") {
         // This logic must be synchronized with that in `zirStructInitEmpty`.
@@ -19226,7 +18563,6 @@ fn zirStructInit(
         var field_i: u32 = 0;
         var extra_index = extra.end;
 
-        const is_packed = resolved_ty.containerLayout(zcu) == .@"packed";
         while (field_i < extra.data.fields_len) : (field_i += 1) {
             const item = sema.code.extraData(Zir.Inst.StructInit.Item, extra_index);
             extra_index = item.end;
@@ -19251,16 +18587,16 @@ fn zirStructInit(
             const uncoerced_init = try sema.resolveInst(item.data.init);
             const field_ty = resolved_ty.fieldType(field_index, zcu);
             field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);
-            if (!is_packed) {
-                try resolved_ty.resolveStructFieldInits(pt);
-                if (try resolved_ty.structFieldValueComptime(pt, field_index)) |default_value| {
-                    const init_val = (try sema.resolveValue(field_inits[field_index])) orelse {
-                        return sema.failWithNeededComptime(block, field_src, .{ .simple = .stored_to_comptime_field });
-                    };
-
-                    if (!init_val.eql(default_value, resolved_ty.fieldType(field_index, zcu), zcu)) {
-                        return sema.failWithInvalidComptimeFieldStore(block, field_src, resolved_ty, field_index);
-                    }
+            if (resolved_ty.structFieldIsComptime(field_index, zcu)) {
+                if (!resolved_ty.isTuple(zcu)) {
+                    try sema.ensureFieldInitsResolved(resolved_ty);
+                }
+                const default_value = (try resolved_ty.structFieldValueComptime(pt, field_index)).?;
+                const init_val = (try sema.resolveValue(field_inits[field_index])) orelse {
+                    return sema.failWithNeededComptime(block, field_src, .{ .simple = .stored_to_comptime_field });
+                };
+                if (!init_val.eql(default_value, resolved_ty.fieldType(field_index, zcu), zcu)) {
+                    return sema.failWithInvalidComptimeFieldStore(block, field_src, resolved_ty, field_index);
                 }
             }
         }
@@ -19315,7 +18651,7 @@ fn zirStructInit(
             return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
         }
 
-        if (try resolved_ty.comptimeOnlySema(pt)) {
+        if (resolved_ty.comptimeOnly(zcu)) {
             return sema.failWithNeededComptime(block, field_src, .{ .comptime_only = .{
                 .ty = resolved_ty,
                 .msg = .union_init,
@@ -19326,7 +18662,7 @@ fn zirStructInit(
 
         if (is_ref) {
             const target = zcu.getTarget();
-            const alloc_ty = try pt.ptrTypeSema(.{
+            const alloc_ty = try pt.ptrType(.{
                 .child = result_ty.toIntern(),
                 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
             });
@@ -19334,9 +18670,8 @@ fn zirStructInit(
             const base_ptr = try sema.optEuBasePtrInit(block, alloc, src);
             const field_ptr = try sema.unionFieldPtr(block, field_src, base_ptr, field_name, field_src, resolved_ty, true);
             try sema.storePtr(block, src, field_ptr, init_inst);
-            if ((try sema.typeHasOnePossibleValue(tag_ty)) == null) {
-                const new_tag = Air.internedToRef(tag_val.toIntern());
-                _ = try block.addBinOp(.set_union_tag, base_ptr, new_tag);
+            if (try tag_ty.onePossibleValue(pt) == null) {
+                _ = try block.addBinOp(.set_union_tag, base_ptr, .fromValue(tag_val));
             }
             return sema.makePtrConst(block, alloc);
         }
@@ -19409,20 +18744,24 @@ fn finishStructInit(
                     continue;
                 }
 
-                try struct_ty.resolveStructFieldInits(pt);
+                try sema.ensureFieldInitsResolved(struct_ty);
 
-                const field_init = struct_type.fieldInit(ip, i);
-                if (field_init == .none) {
-                    const field_name = struct_type.field_names.get(ip)[i];
-                    const template = "missing struct field: {f}";
-                    const args = .{field_name.fmt(ip)};
-                    if (root_msg) |msg| {
-                        try sema.errNote(init_src, msg, template, args);
-                    } else {
-                        root_msg = try sema.errMsg(init_src, template, args);
-                    }
+                const field_default: InternPool.Index = d: {
+                    if (struct_type.field_defaults.len == 0) break :d .none;
+                    break :d struct_type.field_defaults.get(ip)[i];
+                };
+                if (field_default != .none) {
+                    field_inits[i] = .fromIntern(field_default);
+                    continue;
+                }
+
+                const field_name = struct_type.field_names.get(ip)[i];
+                const template = "missing struct field: {f}";
+                const args = .{field_name.fmt(ip)};
+                if (root_msg) |msg| {
+                    try sema.errNote(init_src, msg, template, args);
                 } else {
-                    field_inits[i] = Air.internedToRef(field_init);
+                    root_msg = try sema.errMsg(init_src, template, args);
                 }
             }
         },
@@ -19453,7 +18792,7 @@ fn finishStructInit(
         return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
     };
 
-    if (try struct_ty.comptimeOnlySema(pt)) {
+    if (struct_ty.comptimeOnly(zcu)) {
         return sema.failWithNeededComptime(block, block.src(.{ .init_elem = .{
             .init_node_offset = init_src.offset.node_offset.x,
             .elem_index = @intCast(runtime_index),
@@ -19468,9 +18807,8 @@ fn finishStructInit(
     }
 
     if (is_ref) {
-        try struct_ty.resolveLayout(pt);
         const target = zcu.getTarget();
-        const alloc_ty = try pt.ptrTypeSema(.{
+        const alloc_ty = try pt.ptrType(.{
             .child = result_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
@@ -19489,7 +18827,6 @@ fn finishStructInit(
         .init_node_offset = init_src.offset.node_offset.x,
         .elem_index = @intCast(runtime_index),
     } }));
-    try struct_ty.resolveStructFieldInits(pt);
     const struct_val = try block.addAggregateInit(struct_ty, field_inits);
     return sema.coerce(block, result_ty, struct_val, init_src);
 }
@@ -19585,12 +18922,11 @@ fn structInitAnon(
         break :rs runtime_index;
     };
 
-    // We treat anonymous struct types as reified types, because there are similarities:
-    // * They use a form of structural equivalence, which we can easily model using a custom hash
-    // * They do not have captures
-    // * They immediately have their fields resolved
-    // In general, other code should treat anon struct types and reified struct types identically,
-    // so there's no point having a separate `InternPool.NamespaceType` field for them.
+    // We treat anonymous struct types as reified types, because there are similarities: they have
+    // no captures, and instead use a form of structural equivalence which we can easy represent by
+    // hashing the field names/types/values. They also perform layout resolution immediately. These
+    // similarities mean that other code should actually treat anon struct types and reified struct
+    // types identically anyway, so sharing the representation makes everything simpler.
     const type_hash: u64 = hash: {
         var hasher = std.hash.Wyhash.init(0);
         hasher.update(std.mem.sliceAsBytes(types));
@@ -19599,36 +18935,36 @@ fn structInitAnon(
         break :hash hasher.final();
     };
     const tracked_inst = try block.trackZir(inst);
-    const struct_ty = switch (try ip.getStructType(gpa, io, pt.tid, .{
-        .layout = .auto,
+    const struct_ty: Type = switch (try ip.getStructType(gpa, io, pt.tid, .{
         .fields_len = extra_data.fields_len,
-        .known_non_opv = false,
-        .requires_comptime = .unknown,
+        .layout = .auto,
+        .explicit_packed_backing_type = .none,
         .any_comptime_fields = any_values,
-        .any_default_inits = any_values,
-        .inits_resolved = true,
-        .any_aligned_fields = false,
+        .any_field_defaults = any_values,
+        .any_field_aligns = false,
         .key = .{ .reified = .{
             .zir_index = tracked_inst,
             .type_hash = type_hash,
         } },
-    }, false)) {
+    })) {
         .wip => |wip| ty: {
             errdefer wip.cancel(ip, pt.tid);
-            const type_name = try sema.createTypeName(block, .anon, "struct", inst, wip.index);
-            wip.setName(ip, type_name.name, type_name.nav);
+            // MLUGG TODO obvs this sux
+            const anon_prefix = (try sema.createTypeName(block, .anon, "struct", inst)).anon_prefix;
+            wip.setName(ip, try ip.getOrPutStringFmt(gpa, io, pt.tid, "{s}_{d}", .{ anon_prefix, @intFromEnum(wip.index) }, .no_embedded_nulls), .none);
 
             const struct_type = ip.loadStructType(wip.index);
 
-            for (names, values, 0..) |name, init_val, field_idx| {
-                assert(struct_type.addFieldName(ip, name) == null);
-                if (init_val != .none) struct_type.setFieldComptime(ip, field_idx);
+            for (names, values) |name, init_val| {
+                assert(wip.nextField(ip, name, init_val != .none) == null); // AstGen validated no duplicates for us
             }
 
+            // Populating these means the type is already resolved; we don't need to add it to `zcu.outdated` or anything.
+            // That's important because type resolution relies on types being declared.
             @memcpy(struct_type.field_types.get(ip), types);
-            if (any_values) {
-                @memcpy(struct_type.field_inits.get(ip), values);
-            }
+            @memcpy(struct_type.field_defaults.get(ip), if (any_values) values else @as([]const InternPool.Index, &.{}));
+
+            try type_resolution.finishStructLayout(sema, block, src, wip.index, &struct_type);
 
             const new_namespace_index = try pt.createNamespace(.{
                 .parent = block.namespace.toOptional(),
@@ -19636,7 +18972,6 @@ fn structInitAnon(
                 .file_scope = block.getFileScopeIndex(zcu),
                 .generation = zcu.generation,
             });
-            try zcu.comp.queueJob(.{ .resolve_type_fully = wip.index });
             codegen_type: {
                 if (zcu.comp.config.use_llvm) break :codegen_type;
                 if (block.ownerModule().strip) break :codegen_type;
@@ -19644,22 +18979,21 @@ fn structInitAnon(
                 try zcu.comp.queueJob(.{ .link_type = wip.index });
             }
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-            break :ty wip.finish(ip, new_namespace_index);
+            break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
-        .existing => |ty| ty,
+        .existing => |ty| .fromInterned(ty),
     };
-    try sema.declareDependency(.{ .interned = struct_ty });
     try sema.addTypeReferenceEntry(src, struct_ty);
 
     _ = opt_runtime_index orelse {
-        const struct_val = try pt.aggregateValue(.fromInterned(struct_ty), values);
+        const struct_val = try pt.aggregateValue(struct_ty, values);
         return sema.addConstantMaybeRef(struct_val.toIntern(), is_ref);
     };
 
     if (is_ref) {
         const target = zcu.getTarget();
-        const alloc_ty = try pt.ptrTypeSema(.{
-            .child = struct_ty,
+        const alloc_ty = try pt.ptrType(.{
+            .child = struct_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const alloc = try block.addTy(.alloc, alloc_ty);
@@ -19672,7 +19006,7 @@ fn structInitAnon(
             };
             extra_index = item.end;
 
-            const field_ptr_ty = try pt.ptrTypeSema(.{
+            const field_ptr_ty = try pt.ptrType(.{
                 .child = field_ty,
                 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
             });
@@ -19697,7 +19031,7 @@ fn structInitAnon(
         element_refs[i] = try sema.resolveInst(item.data.init);
     }
 
-    return block.addAggregateInit(.fromInterned(struct_ty), element_refs);
+    return block.addAggregateInit(struct_ty, element_refs);
 }
 
 fn zirArrayInit(
@@ -19737,17 +19071,16 @@ fn zirArrayInit(
         } });
         // Less inits than needed.
         if (i + 2 > args.len) if (is_tuple) {
-            const default_val = array_ty.structFieldDefaultValue(i, zcu).toIntern();
-            if (default_val == .unreachable_value) {
+            const default_val = array_ty.structFieldDefaultValue(i, zcu) orelse {
                 const template = "missing tuple field with index {d}";
                 if (root_msg) |msg| {
                     try sema.errNote(src, msg, template, .{i});
                 } else {
                     root_msg = try sema.errMsg(src, template, .{i});
                 }
-            } else {
-                dest.* = Air.internedToRef(default_val);
-            }
+                continue;
+            };
+            dest.* = .fromValue(default_val);
             continue;
         } else {
             dest.* = Air.internedToRef(sentinel_val.?.toIntern());
@@ -19759,11 +19092,9 @@ fn zirArrayInit(
         const elem_ty = if (is_tuple)
             array_ty.fieldType(i, zcu)
         else
-            array_ty.elemType2(zcu);
+            array_ty.childType(zcu);
         dest.* = try sema.coerce(block, elem_ty, resolved_arg, elem_src);
         if (is_tuple) {
-            if (array_ty.structFieldIsComptime(i, zcu))
-                try array_ty.resolveStructFieldInits(pt);
             if (try array_ty.structFieldValueComptime(pt, i)) |field_val| {
                 const init_val = try sema.resolveConstValue(block, elem_src, dest.*, .{ .simple = .stored_to_comptime_field });
                 if (!field_val.eql(init_val, elem_ty, zcu)) {
@@ -19798,7 +19129,7 @@ fn zirArrayInit(
 
     if (is_ref) {
         const target = zcu.getTarget();
-        const alloc_ty = try pt.ptrTypeSema(.{
+        const alloc_ty = try pt.ptrType(.{
             .child = result_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
@@ -19807,7 +19138,7 @@ fn zirArrayInit(
 
         if (is_tuple) {
             for (resolved_args, 0..) |arg, i| {
-                const elem_ptr_ty = try pt.ptrTypeSema(.{
+                const elem_ptr_ty = try pt.ptrType(.{
                     .child = array_ty.fieldType(i, zcu).toIntern(),
                     .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
                 });
@@ -19820,8 +19151,8 @@ fn zirArrayInit(
             return sema.makePtrConst(block, alloc);
         }
 
-        const elem_ptr_ty = try pt.ptrTypeSema(.{
-            .child = array_ty.elemType2(zcu).toIntern(),
+        const elem_ptr_ty = try pt.ptrType(.{
+            .child = array_ty.childType(zcu).toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const elem_ptr_ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
@@ -19932,14 +19263,14 @@ fn arrayInitAnon(
 
     if (is_ref) {
         const target = sema.pt.zcu.getTarget();
-        const alloc_ty = try pt.ptrTypeSema(.{
+        const alloc_ty = try pt.ptrType(.{
             .child = tuple_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const alloc = try block.addTy(.alloc, alloc_ty);
         for (operands, 0..) |operand, i_usize| {
             const i: u32 = @intCast(i_usize);
-            const field_ptr_ty = try pt.ptrTypeSema(.{
+            const field_ptr_ty = try pt.ptrType(.{
                 .child = types[i],
                 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
             });
@@ -19971,6 +19302,7 @@ fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const field_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const aggregate_ty = try sema.resolveType(block, ty_src, extra.container_type);
     const field_name = try sema.resolveConstStringIntern(block, field_src, extra.field_name, .{ .simple = .field_name });
+    try sema.ensureLayoutResolved(aggregate_ty);
     return sema.fieldType(block, aggregate_ty, field_name, field_src, ty_src);
 }
 
@@ -19990,9 +19322,11 @@ fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(zcu);
     const zir_field_name = sema.code.nullTerminatedString(extra.name_start);
     const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_field_name, .no_embedded_nulls);
+    try sema.ensureLayoutResolved(aggregate_ty);
     return sema.fieldType(block, aggregate_ty, field_name, field_name_src, ty_src);
 }
 
+/// Asserts that the layout of `aggregate_ty` is resolved.
 fn fieldType(
     sema: *Sema,
     block: *Block,
@@ -20006,7 +19340,6 @@ fn fieldType(
     const ip = &zcu.intern_pool;
     var cur_ty = aggregate_ty;
     while (true) {
-        try cur_ty.resolveFields(pt);
         switch (cur_ty.zigTypeTag(zcu)) {
             .@"struct" => switch (ip.indexToKey(cur_ty.toIntern())) {
                 .tuple_type => |tuple| {
@@ -20024,10 +19357,11 @@ fn fieldType(
             },
             .@"union" => {
                 const union_obj = zcu.typeToUnion(cur_ty).?;
-                const field_index = union_obj.loadTagType(ip).nameIndex(ip, field_name) orelse
+                const enum_obj = ip.loadEnumType(union_obj.enum_tag_type);
+                const field_index = enum_obj.nameIndex(ip, field_name) orelse
                     return sema.failWithBadUnionFieldAccess(block, cur_ty, union_obj, field_src, field_name);
                 const field_ty = union_obj.field_types.get(ip)[field_index];
-                return Air.internedToRef(field_ty);
+                return .fromIntern(field_ty);
             },
             .optional => {
                 // Struct/array init through optional requires the child type to not be a pointer.
@@ -20056,7 +19390,6 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
-    try stack_trace_ty.resolveFields(pt);
     const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
     const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern());
 
@@ -20064,7 +19397,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
         .func => |func| if (ip.funcAnalysisUnordered(func).has_error_trace and block.ownerModule().error_tracing) {
             return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
         },
-        .@"comptime", .nav_ty, .nav_val, .type, .memoized_state => {},
+        .@"comptime", .nav_ty, .nav_val, .type_layout, .type_inits, .memoized_state => {},
     }
     return Air.internedToRef(try pt.intern(.{ .opt = .{
         .ty = opt_ptr_stack_trace_ty.toIntern(),
@@ -20083,15 +19416,16 @@ fn zirFrame(
 }
 
 fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    const zcu = sema.pt.zcu;
+    const pt = sema.pt;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
     if (ty.isNoReturn(zcu)) {
         return sema.fail(block, operand_src, "no align available for type '{f}'", .{ty.fmt(sema.pt)});
     }
-    const val = try ty.lazyAbiAlignment(sema.pt);
-    return Air.internedToRef(val.toIntern());
+    try sema.ensureLayoutResolved(ty);
+    return .fromValue(try pt.intValue(.comptime_int, ty.abiAlignment(zcu).toByteUnits().?));
 }
 
 fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -20249,7 +19583,6 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    try operand_ty.resolveLayout(pt);
     const enum_ty = switch (operand_ty.zigTypeTag(zcu)) {
         .enum_literal => {
             const val = (try sema.resolveDefinedValue(block, operand_src, operand)).?;
@@ -20332,7 +19665,7 @@ fn zirReifySliceArgTy(
         // zig fmt: on
     };
 
-    const operand_ty = try pt.ptrTypeSema(.{
+    const operand_ty = try pt.ptrType(.{
         .child = in_scalar_ty.toIntern(),
         .flags = .{ .size = .slice, .is_const = true },
     });
@@ -20342,7 +19675,7 @@ fn zirReifySliceArgTy(
     const operand_val = try sema.resolveConstDefinedValue(block, src, operand_coerced, .{ .simple = comptime_reason });
     const len_val: Value = .fromInterned(zcu.intern_pool.indexToKey(operand_val.toIntern()).slice.len);
     if (len_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, src, null);
-    const len = try len_val.toUnsignedIntSema(pt);
+    const len = len_val.toUnsignedInt(zcu);
 
     return .fromType(try pt.singleConstPtrType(try pt.arrayType(.{
         .len = len,
@@ -20370,7 +19703,7 @@ fn zirReifyEnumValueSliceTy(
     const operand_val = try sema.resolveConstDefinedValue(block, field_names_src, operand_coerced, .{ .simple = .enum_field_names });
     const len_val: Value = .fromInterned(zcu.intern_pool.indexToKey(operand_val.toIntern()).slice.len);
     if (len_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, field_names_src, null);
-    const len = try len_val.toUnsignedIntSema(pt);
+    const len = len_val.toUnsignedInt(zcu);
 
     return .fromType(try pt.singleConstPtrType(try pt.arrayType(.{
         .len = len,
@@ -20422,6 +19755,7 @@ fn zirReifyTuple(
         if (field_ty_val.isUndef(zcu)) {
             return sema.failWithUseOfUndef(block, operand_src, null);
         }
+        try sema.validateTupleFieldType(block, field_ty_val.toType(), operand_src);
         field_ty.* = field_ty_val.toIntern();
     }
 
@@ -20516,7 +19850,7 @@ fn zirReifyPointer(
         }
     }
 
-    return .fromType(try pt.ptrTypeSema(.{
+    return .fromType(try pt.ptrType(.{
         .child = elem_ty.toIntern(),
         .sentinel = if (opt_sentinel) |s| s.toIntern() else .none,
         .flags = .{
@@ -20571,6 +19905,7 @@ fn zirReifyFn(
     const param_attrs_arr = try sema.derefSliceAsArray(block, param_attrs_src, param_attrs_slice, .{ .simple = .fn_param_attrs });
 
     const ret_ty = try sema.resolveType(block, ret_ty_src, extra.ret_ty);
+    try sema.ensureLayoutResolved(ret_ty);
 
     const fn_attrs_uncoerced = try sema.resolveInst(extra.fn_attrs);
     const fn_attrs_coerced = try sema.coerce(block, fn_attrs_ty, fn_attrs_uncoerced, fn_attrs_src);
@@ -20595,7 +19930,8 @@ fn zirReifyFn(
             param_types_src,
             fn_attrs.@"callconv",
         );
-        if (try param_ty.comptimeOnlySema(pt)) {
+        try sema.ensureLayoutResolved(param_ty);
+        if (param_ty.comptimeOnly(zcu)) {
             return sema.fail(block, param_attrs_src, "cannot reify function type with comptime-only parameter type '{f}'", .{param_ty.fmt(pt)});
         }
         if (param_attrs.@"noalias") {
@@ -20621,7 +19957,7 @@ fn zirReifyFn(
         false,
         false,
     );
-    if (try ret_ty.comptimeOnlySema(pt)) {
+    if (ret_ty.comptimeOnly(zcu)) {
         return sema.fail(block, param_attrs_src, "cannot reify function type with comptime-only return type '{f}'", .{ret_ty.fmt(pt)});
     }
 
@@ -20632,7 +19968,6 @@ fn zirReifyFn(
         .return_type = ret_ty.toIntern(),
         .cc = fn_attrs.@"callconv",
         .is_var_args = fn_attrs.varargs,
-        .is_generic = false,
         .is_noinline = false,
     }));
 }
@@ -20791,8 +20126,7 @@ fn zirReifyStruct(
                 field_attrs_src,
                 .{ .simple = .struct_field_default_value },
             );
-            // Resolve the value so that lazy values do not create distinct types.
-            break :d (try sema.resolveLazyValue(deref_val)).toIntern();
+            break :d deref_val.toIntern();
         };
 
         std.hash.autoHash(&hasher, .{
@@ -20823,36 +20157,31 @@ fn zirReifyStruct(
     }
 
     const wip_ty = switch (try ip.getStructType(gpa, io, pt.tid, .{
-        .layout = layout,
         .fields_len = @intCast(fields_len),
-        .known_non_opv = false,
-        .requires_comptime = .unknown,
+        .layout = layout,
+        .explicit_packed_backing_type = if (backing_int_ty) |t| t.toIntern() else .none,
         .any_comptime_fields = any_comptime_fields,
-        .any_default_inits = any_default_inits,
-        .any_aligned_fields = any_aligned_fields,
-        .inits_resolved = true,
+        .any_field_defaults = any_default_inits,
+        .any_field_aligns = any_aligned_fields,
         .key = .{ .reified = .{
             .zir_index = tracked_inst,
             .type_hash = hasher.final(),
         } },
-    }, false)) {
+    })) {
         .wip => |wip| wip,
         .existing => |ty| {
-            try sema.declareDependency(.{ .interned = ty });
-            try sema.addTypeReferenceEntry(src, ty);
-            return Air.internedToRef(ty);
+            try sema.addTypeReferenceEntry(src, .fromInterned(ty));
+            return .fromIntern(ty);
         },
     };
     errdefer wip_ty.cancel(ip, pt.tid);
 
-    const type_name = try sema.createTypeName(
+    _ = try (try sema.createTypeName(
         block,
         name_strategy,
         "struct",
         inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
+    )).apply(&wip_ty, pt);
 
     const wip_struct_type = ip.loadStructType(wip_ty.index);
 
@@ -20860,38 +20189,27 @@ fn zirReifyStruct(
         const field_name_val = try field_names_arr.elemValue(pt, field_idx);
         const field_attrs_val = try field_attrs_arr.elemValue(pt, field_idx);
 
-        const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
-
         // Don't pass a reason; first loop acts as a check that this is valid.
         const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
-        if (wip_struct_type.addFieldName(ip, field_name)) |prev_index| {
+        const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
+        const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
+            std.builtin.Type.StructField.Attributes,
+            "comptime",
+        ).?);
+        const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
+            std.builtin.Type.StructField.Attributes,
+            "align",
+        ).?);
+        const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
+            std.builtin.Type.StructField.Attributes,
+            "default_value_ptr",
+        ).?);
+
+        if (wip_ty.nextField(ip, field_name, field_attr_comptime.toBool())) |prev_index| {
             _ = prev_index; // TODO: better source location
             return sema.fail(block, field_names_src, "duplicate struct field name {f}", .{field_name.fmt(ip)});
         }
 
-        const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
-            std.builtin.Type.StructField.Attributes,
-            "comptime",
-        ).?);
-        const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
-            std.builtin.Type.StructField.Attributes,
-            "align",
-        ).?);
-        const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
-            std.builtin.Type.StructField.Attributes,
-            "default_value_ptr",
-        ).?);
-
-        if (field_attr_align.optionalValue(zcu)) |field_align_val| {
-            assert(layout != .@"packed");
-            const bytes = try field_align_val.toUnsignedIntSema(pt);
-            const a = try sema.validateAlign(block, field_attrs_src, bytes);
-            wip_struct_type.field_aligns.get(ip)[field_idx] = a;
-        } else if (any_aligned_fields) {
-            assert(layout != .@"packed");
-            wip_struct_type.field_aligns.get(ip)[field_idx] = .none;
-        }
-
         const field_default: InternPool.Index = d: {
             const ptr_val = field_attr_default_value_ptr.optionalValue(zcu) orelse break :d .none;
             assert(any_default_inits);
@@ -20902,20 +20220,11 @@ fn zirReifyStruct(
             if (deref_val.canMutateComptimeVarState(zcu)) {
                 return sema.failWithContainsReferenceToComptimeVar(block, field_attrs_src, field_name, "field default value", deref_val);
             }
-            break :d (try sema.resolveLazyValue(deref_val)).toIntern();
+            break :d deref_val.toIntern();
         };
 
-        if (field_attr_comptime.toBool()) {
-            assert(layout == .auto);
-            if (field_default == .none) {
-                return sema.fail(block, field_attrs_src, "comptime field without default initialization value", .{});
-            }
-            wip_struct_type.setFieldComptime(ip, field_idx);
-        }
-
-        wip_struct_type.field_types.get(ip)[field_idx] = field_ty.toIntern();
-        if (field_default != .none) {
-            wip_struct_type.field_inits.get(ip)[field_idx] = field_default;
+        if (field_attr_comptime.toBool() and field_default == .none) {
+            return sema.fail(block, field_attrs_src, "comptime field without default initialization value", .{});
         }
 
         switch (field_ty.zigTypeTag(zcu)) {
@@ -20945,32 +20254,55 @@ fn zirReifyStruct(
                     break :msg msg;
                 });
             },
-            .@"packed" => if (!try sema.validatePackedType(field_ty)) {
+            .@"packed" => if (!field_ty.packable(zcu)) {
                 return sema.failWithOwnedErrorMsg(block, msg: {
                     const msg = try sema.errMsg(field_types_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
                     errdefer msg.destroy(gpa);
-                    try sema.explainWhyTypeIsNotPacked(msg, field_types_src, field_ty);
+                    try sema.explainWhyTypeIsNotPackable(msg, field_types_src, field_ty);
                     try sema.addDeclaredHereNote(msg, field_ty);
                     break :msg msg;
                 });
             },
         }
+
+        wip_struct_type.field_types.get(ip)[field_idx] = field_ty.toIntern();
+        if (field_default != .none) {
+            wip_struct_type.field_defaults.get(ip)[field_idx] = field_default;
+        }
+
+        if (field_attr_align.optionalValue(zcu)) |field_align_val| {
+            assert(layout != .@"packed");
+            const bytes = field_align_val.toUnsignedInt(zcu);
+            const a = try sema.validateAlign(block, field_attrs_src, bytes);
+            wip_struct_type.field_aligns.get(ip)[field_idx] = a;
+        } else if (any_aligned_fields) {
+            assert(layout != .@"packed");
+            wip_struct_type.field_aligns.get(ip)[field_idx] = .none;
+        }
     }
 
     if (layout == .@"packed") {
-        var fields_bit_sum: u64 = 0;
-        for (0..wip_struct_type.field_types.len) |field_idx| {
+        var field_bits: u64 = 0;
+        for (0..fields_len) |field_idx| {
             const field_ty: Type = .fromInterned(wip_struct_type.field_types.get(ip)[field_idx]);
-            try field_ty.resolveLayout(pt);
-            fields_bit_sum += field_ty.bitSize(zcu);
-        }
-        if (backing_int_ty) |ty| {
-            try sema.checkBackingIntType(block, src, ty, fields_bit_sum);
-            wip_struct_type.setBackingIntType(ip, io, ty.toIntern());
-        } else {
-            const ty = try pt.intType(.unsigned, @intCast(fields_bit_sum));
-            wip_struct_type.setBackingIntType(ip, io, ty.toIntern());
+            try sema.ensureLayoutResolved(field_ty);
+            field_bits += field_ty.bitSize(zcu);
         }
+        try type_resolution.resolvePackedStructBackingInt(
+            sema,
+            block,
+            field_bits,
+            .fromInterned(wip_ty.index),
+            &wip_struct_type,
+        );
+    } else {
+        try type_resolution.finishStructLayout(
+            sema,
+            block,
+            src,
+            wip_ty.index,
+            &wip_struct_type,
+        );
     }
 
     const new_namespace_index = try pt.createNamespace(.{
@@ -20980,16 +20312,13 @@ fn zirReifyStruct(
         .generation = zcu.generation,
     });
 
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
         if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
         zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
         try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
     }
-    try sema.declareDependency(.{ .interned = wip_ty.index });
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
+    try sema.addTypeReferenceEntry(src, .fromInterned(wip_ty.index));
     if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
     return .fromIntern(wip_ty.finish(ip, new_namespace_index));
 }
@@ -21134,62 +20463,52 @@ fn zirReifyUnion(
     }
 
     // Some basic validation to avoid a bogus `getUnionType` call...
-    const explicit_tag_ty: ?Type = if (arg_ty_val.optionalValue(zcu)) |arg_ty| ty: {
+    const explicit_tag_ty: ?Type, const explicit_packed_backing_type: ?Type = ty: {
+        const arg_ty = arg_ty_val.optionalValue(zcu) orelse break :ty .{ null, null };
         switch (layout) {
-            .@"extern", .@"packed" => return sema.fail(block, arg_ty_src, "{t} union does not support enum tag type", .{layout}),
-            .auto => {},
+            .@"extern" => return sema.fail(block, arg_ty_src, "extern union does not support enum tag type", .{}),
+            .@"packed" => break :ty .{ null, arg_ty.toType() },
+            .auto => break :ty .{ arg_ty.toType(), null },
         }
-        break :ty arg_ty.toType();
-    } else null;
+    };
     if (any_aligned_fields and layout == .@"packed") {
         return sema.fail(block, field_attrs_src, "packed union fields cannot be aligned", .{});
     }
 
     const wip_ty = switch (try ip.getUnionType(gpa, io, pt.tid, .{
-        .flags = .{
-            .layout = layout,
-            .status = .none,
-            .runtime_tag = rt: {
-                if (explicit_tag_ty != null) break :rt .tagged;
-                if (layout == .auto and block.wantSafeTypes()) break :rt .safety;
-                break :rt .none;
-            },
-            .any_aligned_fields = any_aligned_fields,
-            .requires_comptime = .unknown,
-            .assumed_runtime_bits = false,
-            .assumed_pointer_aligned = false,
-            .alignment = .none,
-        },
         .fields_len = @intCast(fields_len),
-        .enum_tag_ty = .none, // set later because not yet validated
-        .field_types = &.{}, // set later
-        .field_aligns = &.{}, // set later
+        .layout = layout,
+        .explicit_packed_backing_type = if (explicit_packed_backing_type) |t| t.toIntern() else .none,
+        .runtime_tag = rt: {
+            if (explicit_tag_ty != null) break :rt .tagged;
+            if (layout == .auto and block.wantSafeTypes()) break :rt .safety;
+            break :rt .none;
+        },
+        .have_explicit_enum_tag = explicit_tag_ty != null,
+        .any_field_aligns = any_aligned_fields,
         .key = .{ .reified = .{
             .zir_index = tracked_inst,
             .type_hash = hasher.final(),
         } },
-    }, false)) {
+    })) {
         .wip => |wip| wip,
         .existing => |ty| {
-            try sema.declareDependency(.{ .interned = ty });
-            try sema.addTypeReferenceEntry(src, ty);
-            return Air.internedToRef(ty);
+            try sema.addTypeReferenceEntry(src, .fromInterned(ty));
+            return .fromIntern(ty);
         },
     };
     errdefer wip_ty.cancel(ip, pt.tid);
 
-    const type_name = try sema.createTypeName(
+    const type_name = try (try sema.createTypeName(
         block,
         name_strategy,
         "union",
         inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
+    )).apply(&wip_ty, pt);
 
     const loaded_union = ip.loadUnionType(wip_ty.index);
 
-    const enum_tag_ty, const has_explicit_tag = if (explicit_tag_ty) |enum_tag_ty| tag: {
+    const generated_tag_ty: InternPool.Index = if (explicit_tag_ty) |enum_tag_ty| generated_tag: {
         if (enum_tag_ty.zigTypeTag(zcu) != .@"enum") {
             return sema.fail(block, arg_ty_src, "tag type must be an enum type", .{});
         }
@@ -21227,26 +20546,67 @@ fn zirReifyUnion(
             try sema.addDeclaredHereNote(msg, enum_tag_ty);
             break :msg msg;
         });
-        break :tag .{ enum_tag_ty.toIntern(), true };
-    } else tag: {
-        // We must track field names and set up the tag type ourselves.
-        var field_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void) = .empty;
-        try field_names.ensureTotalCapacity(sema.arena, fields_len);
+        wip_ty.setTagType(ip, enum_tag_ty.toIntern());
+        break :generated_tag .none;
+    } else generated_tag: {
+        // Generate the union's hypothetical tag type.
+        const wip_tag_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
+            .fields_len = @intCast(fields_len),
+            .explicit_int_tag_type = .none,
+            .nonexhaustive = false,
+            .key = .{ .generated_union_tag = wip_ty.index },
+        })) {
+            .existing => unreachable, // enum type is keyed on this union type which we're only just creating
+            .wip => |wip_tag_ty| wip_tag_ty,
+        };
+        errdefer wip_tag_ty.cancel(ip, pt.tid);
 
+        // Set its name based on the union's name
+        _ = wip_tag_ty.setName(ip, try ip.getOrPutStringFmt(
+            gpa,
+            io,
+            pt.tid,
+            "@typeInfo({f}).@\"union\".tag_type.?",
+            .{type_name.fmt(ip)},
+            .no_embedded_nulls,
+        ), .none);
+
+        // Populate its fields (and report any duplicates)
         for (0..fields_len) |field_idx| {
             const field_name_val = try field_names_arr.elemValue(pt, field_idx);
             // Don't pass a reason; first loop acts as a check that this is valid.
             const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
-            const gop = field_names.getOrPutAssumeCapacity(field_name);
-            if (gop.found_existing) {
-                // TODO: better source location
-                return sema.fail(block, field_names_src, "duplicate union field {f}", .{field_name.fmt(ip)});
-            }
+            if (wip_tag_ty.nextField(ip, field_name, false)) |prev_field_idx| return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(src, "duplicate union field '{f}' at index '{d}", .{ field_name.fmt(ip), field_idx });
+                errdefer msg.destroy(gpa);
+                try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_idx});
+                break :msg msg;
+            });
         }
-        const enum_tag_ty = try sema.generateUnionTagTypeSimple(block, field_names.keys(), wip_ty.index, type_name.name);
-        break :tag .{ enum_tag_ty, false };
+
+        // Populate the enum tag type's *integer* tag type
+        wip_tag_ty.setTagType(ip, int_tag_ty: {
+            // Infer the int tag type from the field count
+            const bits = Type.smallestUnsignedBits(fields_len -| 1);
+            break :int_tag_ty (try pt.intType(.unsigned, bits)).toIntern();
+        });
+
+        // Lastly, it needs a dummy namespace
+        const enum_tag_type_namespace = try pt.createNamespace(.{
+            .parent = block.namespace.toOptional(),
+            .owner_type = wip_tag_ty.index,
+            .file_scope = block.getFileScopeIndex(zcu),
+            .generation = zcu.generation,
+        });
+        errdefer pt.destroyNamespace(enum_tag_type_namespace);
+
+        wip_ty.setTagType(ip, wip_tag_ty.index);
+
+        break :generated_tag wip_tag_ty.finish(ip, enum_tag_type_namespace);
     };
-    errdefer if (!has_explicit_tag) ip.remove(pt.tid, enum_tag_ty); // remove generated tag type on error
+    // If we fail to create the union type, we must delete the generated enum tag type, since it
+    // would hold a reference to the deleted union.
+    errdefer if (generated_tag_ty != .none) ip.remove(pt.tid, generated_tag_ty);
 
     for (0..fields_len) |field_idx| {
         const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
@@ -21279,12 +20639,12 @@ fn zirReifyUnion(
                     break :msg msg;
                 });
             },
-            .@"packed" => if (!try sema.validatePackedType(field_ty)) {
+            .@"packed" => if (!field_ty.packable(zcu)) {
                 return sema.failWithOwnedErrorMsg(block, msg: {
                     const msg = try sema.errMsg(field_types_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
                     errdefer msg.destroy(gpa);
 
-                    try sema.explainWhyTypeIsNotPacked(msg, field_types_src, field_ty);
+                    try sema.explainWhyTypeIsNotPackable(msg, field_types_src, field_ty);
 
                     try sema.addDeclaredHereNote(msg, field_ty);
                     break :msg msg;
@@ -21303,8 +20663,24 @@ fn zirReifyUnion(
         }
     }
 
-    loaded_union.setTagType(ip, io, enum_tag_ty);
-    loaded_union.setStatus(ip, io, .have_field_types);
+    if (layout == .@"packed") {
+        try type_resolution.resolvePackedUnionBackingInt(
+            sema,
+            block,
+            .fromInterned(wip_ty.index),
+            &loaded_union,
+            true,
+        );
+    } else {
+        try type_resolution.finishUnionLayout(
+            sema,
+            block,
+            src,
+            wip_ty.index,
+            &loaded_union,
+            explicit_tag_ty orelse .fromInterned(generated_tag_ty),
+        );
+    }
 
     const new_namespace_index = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
@@ -21313,17 +20689,16 @@ fn zirReifyUnion(
         .generation = zcu.generation,
     });
 
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
         if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
         zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
         try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
     }
-    try sema.declareDependency(.{ .interned = wip_ty.index });
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
+    try sema.addTypeReferenceEntry(src, .fromInterned(wip_ty.index));
+    if (zcu.comp.debugIncremental()) {
+        try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
+    }
     return .fromIntern(wip_ty.finish(ip, new_namespace_index));
 }
 
@@ -21436,86 +20811,84 @@ fn zirReifyEnum(
     }
 
     const wip_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
-        .has_values = true,
-        .tag_mode = if (nonexhaustive) .nonexhaustive else .explicit,
         .fields_len = @intCast(fields_len),
+        .explicit_int_tag_type = tag_ty.toIntern(),
+        .nonexhaustive = nonexhaustive,
         .key = .{ .reified = .{
             .zir_index = tracked_inst,
             .type_hash = hasher.final(),
         } },
-    }, false)) {
+    })) {
         .wip => |wip| wip,
         .existing => |ty| {
-            try sema.declareDependency(.{ .interned = ty });
-            try sema.addTypeReferenceEntry(src, ty);
+            try sema.addTypeReferenceEntry(src, .fromInterned(ty));
             return .fromIntern(ty);
         },
     };
-    var done = false;
-    errdefer if (!done) wip_ty.cancel(ip, pt.tid);
+    errdefer wip_ty.cancel(ip, pt.tid);
 
-    const type_name = try sema.createTypeName(
+    _ = try (try sema.createTypeName(
         block,
         name_strategy,
         "enum",
         inst,
-        wip_ty.index,
-    );
-    wip_ty.setName(ip, type_name.name, type_name.nav);
-
-    const new_namespace_index = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-
-    try sema.declareDependency(.{ .interned = wip_ty.index });
-    try sema.addTypeReferenceEntry(src, wip_ty.index);
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    wip_ty.prepare(ip, new_namespace_index);
-    wip_ty.setTagTy(ip, tag_ty.toIntern());
-    done = true;
+    )).apply(&wip_ty, pt);
 
     for (0..fields_len) |field_idx| {
         const field_name_val = try field_names_arr.elemValue(pt, field_idx);
         // Don't pass a reason; first loop acts as a check that this is valid.
         const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
+        if (wip_ty.nextField(ip, field_name, false)) |prev_field_idx| return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(field_names_src, "duplicate enum field '{f}' at index '{d}'", .{ field_name.fmt(ip), field_idx });
+            errdefer msg.destroy(gpa);
+            try sema.errNote(field_names_src, msg, "previous field at index '{d}'", .{prev_field_idx});
+            break :msg msg;
+        });
+    }
 
+    const enum_obj = ip.loadEnumType(wip_ty.index);
+    const field_value_map = enum_obj.field_value_map.unwrap().?;
+    for (0..fields_len) |field_idx| {
         const field_val = try field_values_arr.elemValue(pt, field_idx);
-
-        if (wip_ty.nextField(ip, field_name, field_val.toIntern())) |conflict| {
-            return sema.failWithOwnedErrorMsg(block, switch (conflict.kind) {
-                .name => msg: {
-                    const msg = try sema.errMsg(field_names_src, "duplicate enum field '{f}'", .{field_name.fmt(ip)});
-                    errdefer msg.destroy(gpa);
-                    _ = conflict.prev_field_idx; // TODO: this note is incorrect
-                    try sema.errNote(field_names_src, msg, "other field here", .{});
-                    break :msg msg;
-                },
-                .value => msg: {
-                    const msg = try sema.errMsg(field_values_src, "enum tag value {f} already taken", .{field_val.fmtValueSema(pt, sema)});
-                    errdefer msg.destroy(gpa);
-                    _ = conflict.prev_field_idx; // TODO: this note is incorrect
-                    try sema.errNote(field_values_src, msg, "other enum tag value here", .{});
-                    break :msg msg;
-                },
+        const field_values = enum_obj.field_values.get(ip);
+        field_values[field_idx] = field_val.toIntern();
+        const adapter: InternPool.Index.Adapter = .{ .indexes = field_values[0..field_idx] };
+        const gop = field_value_map.get(ip).getOrPutAssumeCapacityAdapted(field_val.toIntern(), adapter);
+        if (gop.found_existing) return sema.failWithOwnedErrorMsg(block, msg: {
+            const field_names = enum_obj.field_names.get(ip);
+            const this_field_name = field_names[field_idx];
+            const prev_field_name = field_names[gop.index];
+            const msg = try sema.errMsg(field_names_src, "duplicate enum tag value '{f}' in field '{f}'", .{
+                field_val.fmtValueSema(pt, sema),
+                this_field_name.fmt(ip),
             });
-        }
+            errdefer msg.destroy(gpa);
+            try sema.errNote(field_names_src, msg, "previous usage in field '{f}'", .{prev_field_name.fmt(ip)});
+            break :msg msg;
+        });
     }
 
     if (nonexhaustive and fields_len > 1 and std.math.log2_int(u64, fields_len) == tag_ty.bitSize(zcu)) {
         return sema.fail(block, src, "non-exhaustive enum specified every value", .{});
     }
 
+    const new_namespace_index = try pt.createNamespace(.{
+        .parent = block.namespace.toOptional(),
+        .owner_type = wip_ty.index,
+        .file_scope = block.getFileScopeIndex(zcu),
+        .generation = zcu.generation,
+    });
+
     codegen_type: {
         if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
         zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
         try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
     }
-    return Air.internedToRef(wip_ty.index);
+
+    try sema.addTypeReferenceEntry(src, .fromInterned(wip_ty.index));
+    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
+    return .fromIntern(wip_ty.finish(ip, new_namespace_index));
 }
 
 fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref {
@@ -21573,7 +20946,8 @@ fn zirCVaEnd(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
     const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.operand);
 
     try sema.requireRuntimeBlock(block, src, null);
-    return block.addUnOp(.c_va_end, va_list_ref);
+    _ = try block.addUnOp(.c_va_end, va_list_ref);
+    return .void_value;
 }
 
 fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
@@ -21683,8 +21057,20 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     _ = try sema.checkIntType(block, operand_src, operand_scalar_ty);
 
     if (try sema.resolveValue(operand)) |operand_val| {
-        const result_val = try operand_val.floatFromIntAdvanced(sema.arena, operand_ty, dest_ty, pt, .sema);
-        return Air.internedToRef(result_val.toIntern());
+        if (operand_val.isUndef(zcu)) return .fromValue(try pt.undefValue(dest_ty));
+        if (dest_ty.zigTypeTag(zcu) != .vector) {
+            return .fromValue(try pt.floatValue(dest_ty, operand_val.toFloat(f128, zcu)));
+        }
+        const dest_elems = try sema.arena.alloc(InternPool.Index, dest_ty.vectorLen(zcu));
+        for (dest_elems, 0..) |*out_elem, elem_idx| {
+            const orig_elem = try operand_val.elemValue(pt, elem_idx);
+            const casted_elem = if (orig_elem.isUndef(zcu))
+                try pt.undefValue(dest_scalar_ty)
+            else
+                try pt.floatValue(dest_scalar_ty, orig_elem.toFloat(f128, zcu));
+            out_elem.* = casted_elem.toIntern();
+        }
+        return .fromValue(try pt.aggregateValue(dest_ty, dest_elems));
     } else if (dest_scalar_ty.zigTypeTag(zcu) == .comptime_float) {
         return sema.failWithNeededComptime(block, operand_src, .{ .simple = .casted_to_comptime_float });
     }
@@ -21719,8 +21105,11 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const ptr_ty = dest_ty.scalarType(zcu);
     try sema.checkPtrType(block, src, ptr_ty, true);
 
-    const elem_ty = ptr_ty.elemType2(zcu);
-    const ptr_align = try ptr_ty.ptrAlignmentSema(pt);
+    const elem_ty = ptr_ty.nullablePtrElem(zcu);
+
+    // We'll need to validate the pointer alignment.
+    try sema.ensureLayoutResolved(elem_ty);
+    const ptr_align = ptr_ty.ptrAlignment(zcu);
 
     if (ptr_ty.isSlice(zcu)) {
         const msg = msg: {
@@ -21746,18 +21135,9 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
         }
         return Air.internedToRef((try pt.aggregateValue(dest_ty, new_elems)).toIntern());
     }
-    if (try ptr_ty.comptimeOnlySema(pt)) {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(src, "pointer to comptime-only type '{f}' must be comptime-known, but operand is runtime-known", .{ptr_ty.fmt(pt)});
-            errdefer msg.destroy(sema.gpa);
-
-            try sema.explainWhyTypeIsComptime(msg, src, ptr_ty);
-            break :msg msg;
-        });
-    }
     try sema.requireRuntimeBlock(block, src, operand_src);
     try sema.checkLogicalPtrOperation(block, src, ptr_ty);
-    if (block.wantSafety() and (try elem_ty.hasRuntimeBitsSema(pt) or elem_ty.zigTypeTag(zcu) == .@"fn")) {
+    if (block.wantSafety()) {
         if (!ptr_ty.isAllowzeroPtr(zcu)) {
             const is_non_zero = if (is_vector) all_non_zero: {
                 const zero_usize = Air.internedToRef((try sema.splat(operand_ty, .zero_usize)).toIntern());
@@ -21804,7 +21184,7 @@ fn ptrFromIntVal(
         }
         return sema.failWithUseOfUndef(block, operand_src, vec_idx);
     }
-    const addr = try operand_val.toUnsignedIntSema(pt);
+    const addr = operand_val.toUnsignedInt(zcu);
     if (!ptr_ty.isAllowzeroPtr(zcu) and addr == 0)
         return sema.fail(block, operand_src, "pointer type '{f}' does not allow address zero", .{ptr_ty.fmt(pt)});
     if (addr != 0 and ptr_align != .none) {
@@ -22043,8 +21423,8 @@ fn ptrCastFull(
     const src_info = operand_ty.ptrInfo(zcu);
     const dest_info = dest_ty.ptrInfo(zcu);
 
-    try Type.fromInterned(src_info.child).resolveLayout(pt);
-    try Type.fromInterned(dest_info.child).resolveLayout(pt);
+    try sema.ensureLayoutResolved(.fromInterned(src_info.child));
+    try sema.ensureLayoutResolved(.fromInterned(dest_info.child));
 
     const DestSliceLen = union(enum) {
         undef,
@@ -22079,9 +21459,9 @@ fn ptrCastFull(
                     .pointer => operand_val,
                     else => unreachable,
                 };
-                const slice_len_resolved = try sema.resolveLazyValue(.fromInterned(zcu.intern_pool.sliceLen(slice_val.toIntern())));
-                if (slice_len_resolved.isUndef(zcu)) break :len .undef;
-                break :src .{ .fromInterned(src_info.child), slice_len_resolved.toUnsignedInt(zcu) };
+                const slice_len: Value = .fromInterned(zcu.intern_pool.sliceLen(slice_val.toIntern()));
+                if (slice_len.isUndef(zcu)) break :len .undef;
+                break :src .{ .fromInterned(src_info.child), slice_len.toUnsignedInt(zcu) };
             },
             .many, .c => {
                 return sema.fail(block, src, "cannot infer length of slice from {s}", .{pointerSizeString(src_info.flags.size)});
@@ -22395,7 +21775,7 @@ fn ptrCastFull(
         };
 
         if (dest_align.compare(.gt, src_align)) {
-            if (try ptr_val.getUnsignedIntSema(pt)) |addr| {
+            if (ptr_val.getUnsignedInt(zcu)) |addr| {
                 const masked_addr = if (Type.fromInterned(dest_info.child).fnPtrMaskOrNull(zcu)) |mask|
                     addr & mask
                 else
@@ -22464,7 +21844,7 @@ fn ptrCastFull(
         // Now, do an addrspace cast if necessary!
         if (!flags.addrspace_cast) break :ptr pre_addrspace_cast;
 
-        const intermediate_ptr_ty = try pt.ptrTypeSema(info: {
+        const intermediate_ptr_ty = try pt.ptrType(info: {
             var info = src_info;
             info.flags.address_space = dest_info.flags.address_space;
             break :info info;
@@ -22638,7 +22018,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
     if (flags.volatile_cast) ptr_info.flags.is_volatile = false;
 
     const dest_ty = blk: {
-        const dest_ty = try pt.ptrTypeSema(ptr_info);
+        const dest_ty = try pt.ptrType(ptr_info);
         if (operand_ty.zigTypeTag(zcu) == .optional) {
             break :blk try pt.optionalType(dest_ty.toIntern());
         }
@@ -22678,48 +22058,24 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         return sema.coerce(block, dest_ty, operand, operand_src);
     }
 
+    if (try dest_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+
     const dest_info = dest_scalar_ty.intInfo(zcu);
 
-    if (try sema.typeHasOnePossibleValue(dest_ty)) |val| {
-        return Air.internedToRef(val.toIntern());
-    }
-
     if (operand_scalar_ty.zigTypeTag(zcu) != .comptime_int) {
         const operand_info = operand_ty.intInfo(zcu);
-        if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
-            return Air.internedToRef(val.toIntern());
-        }
 
         if (operand_info.signedness != dest_info.signedness) {
             return sema.fail(block, operand_src, "expected {s} integer type, found '{f}'", .{
                 @tagName(dest_info.signedness), operand_ty.fmt(pt),
             });
         }
-        switch (std.math.order(dest_info.bits, operand_info.bits)) {
-            .gt => {
-                const msg = msg: {
-                    const msg = try sema.errMsg(
-                        src,
-                        "destination type '{f}' has more bits than source type '{f}'",
-                        .{ dest_ty.fmt(pt), operand_ty.fmt(pt) },
-                    );
-                    errdefer msg.destroy(sema.gpa);
-                    try sema.errNote(src, msg, "destination type has {d} bits", .{
-                        dest_info.bits,
-                    });
-                    try sema.errNote(operand_src, msg, "operand type has {d} bits", .{
-                        operand_info.bits,
-                    });
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(block, msg);
-            },
-            .eq => return operand,
-            .lt => {},
+        if (dest_info.bits >= operand_info.bits) {
+            return sema.coerce(block, dest_ty, operand, operand_src);
         }
     }
 
-    if (try sema.resolveValueResolveLazy(operand)) |val| {
+    if (try sema.resolveValue(operand)) |val| {
         const result_val = try arith.truncate(sema, val, operand_ty, dest_ty, dest_info.signedness, dest_info.bits);
         return Air.internedToRef(result_val.toIntern());
     }
@@ -22745,10 +22101,6 @@ fn zirBitCount(
     _ = try sema.checkIntOrVector(block, operand, operand_src);
     const bits = operand_ty.intInfo(zcu).bits;
 
-    if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
-        return Air.internedToRef(val.toIntern());
-    }
-
     const result_scalar_ty = try pt.smallestUnsignedInt(bits);
     switch (operand_ty.zigTypeTag(zcu)) {
         .vector => {
@@ -22774,7 +22126,7 @@ fn zirBitCount(
             }
         },
         .int => {
-            if (try sema.resolveValueResolveLazy(operand)) |val| {
+            if (try sema.resolveValue(operand)) |val| {
                 if (val.isUndef(zcu)) return pt.undefRef(result_scalar_ty);
                 return pt.intRef(result_scalar_ty, comptimeOp(val, operand_ty, zcu));
             } else {
@@ -22803,9 +22155,6 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             .{ scalar_ty.fmt(pt), bits },
         );
     }
-    if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
-        return .fromValue(val);
-    }
     if (try sema.resolveValue(operand)) |operand_val| {
         return .fromValue(try arith.byteSwap(sema, operand_val, operand_ty));
     }
@@ -22819,9 +22168,6 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const operand_ty = sema.typeOf(operand);
     _ = try sema.checkIntOrVector(block, operand, operand_src);
 
-    if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
-        return .fromValue(val);
-    }
     if (try sema.resolveValue(operand)) |operand_val| {
         return .fromValue(try arith.bitReverse(sema, operand_val, operand_ty));
     }
@@ -22849,10 +22195,11 @@ fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u6
     const ty = try sema.resolveType(block, ty_src, extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, field_name_src, extra.rhs, .{ .simple = .field_name });
 
+    try sema.ensureLayoutResolved(ty);
+
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    try ty.resolveLayout(pt);
     switch (ty.zigTypeTag(zcu)) {
         .@"struct" => {},
         else => return sema.fail(block, ty_src, "expected struct type, found '{f}'", .{ty.fmt(pt)}),
@@ -23126,7 +22473,7 @@ fn checkAtomicPtrOperand(
     const ptr_data = switch (ptr_ty.zigTypeTag(zcu)) {
         .pointer => ptr_ty.ptrInfo(zcu),
         else => {
-            const wanted_ptr_ty = try pt.ptrTypeSema(wanted_ptr_data);
+            const wanted_ptr_ty = try pt.ptrType(wanted_ptr_data);
             _ = try sema.coerce(block, wanted_ptr_ty, ptr, ptr_src);
             unreachable;
         },
@@ -23136,7 +22483,7 @@ fn checkAtomicPtrOperand(
     wanted_ptr_data.flags.is_allowzero = ptr_data.flags.is_allowzero;
     wanted_ptr_data.flags.is_volatile = ptr_data.flags.is_volatile;
 
-    const wanted_ptr_ty = try pt.ptrTypeSema(wanted_ptr_data);
+    const wanted_ptr_ty = try pt.ptrType(wanted_ptr_data);
     const casted_ptr = try sema.coerce(block, wanted_ptr_ty, ptr, ptr_src);
 
     return casted_ptr;
@@ -23470,11 +22817,8 @@ fn zirCmpxchg(
     const result_ty = try pt.optionalType(elem_ty.toIntern());
 
     // special case zero bit types
-    if ((try sema.typeHasOnePossibleValue(elem_ty)) != null) {
-        return Air.internedToRef((try pt.intern(.{ .opt = .{
-            .ty = result_ty.toIntern(),
-            .val = .none,
-        } })));
+    if (try elem_ty.onePossibleValue(pt) != null) {
+        return .fromValue(try pt.nullValue(result_ty));
     }
 
     const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
@@ -23537,11 +22881,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
 
     const len = try sema.usizeCast(block, src, dest_ty.arrayLen(zcu));
 
-    if (try sema.typeHasOnePossibleValue(dest_ty)) |val| {
-        return Air.internedToRef(val.toIntern());
-    }
-
-    // We also need this case because `[0:s]T` is not OPV.
+    // If the length is 0, the result is comptime-known even if the operand isn't.
     if (len == 0) return .fromValue(try pt.aggregateValue(dest_ty, &.{}));
 
     const maybe_sentinel = dest_ty.sentinel(zcu);
@@ -23733,7 +23073,7 @@ fn analyzeShuffle(
             continue;
         }
         // Safe because mask elements are `i32` and we already checked for undef:
-        const raw = (try sema.resolveLazyValue(mask_val)).toSignedInt(zcu);
+        const raw = mask_val.toSignedInt(zcu);
         if (raw >= 0) {
             const idx: u32 = @intCast(raw);
             a_used = true;
@@ -23938,6 +23278,8 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, true);
     const order = try sema.resolveAtomicOrder(block, order_src, extra.ordering, .{ .simple = .atomic_order });
 
+    try sema.ensureLayoutResolved(elem_ty);
+
     switch (order) {
         .release, .acq_rel => {
             return sema.fail(
@@ -23950,9 +23292,7 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
         else => {},
     }
 
-    if (try sema.typeHasOnePossibleValue(elem_ty)) |val| {
-        return Air.internedToRef(val.toIntern());
-    }
+    if (try elem_ty.onePossibleValue(sema.pt)) |opv| return .fromValue(opv);
 
     if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
         if (try sema.pointerDeref(block, ptr_src, ptr_val, sema.typeOf(ptr))) |elem_val| {
@@ -24009,9 +23349,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     }
 
     // special case zero bit types
-    if (try sema.typeHasOnePossibleValue(elem_ty)) |val| {
-        return Air.internedToRef(val.toIntern());
-    }
+    if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
     const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
         const maybe_operand_val = try sema.resolveValue(operand);
@@ -24260,11 +23598,11 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
         return sema.fail(block, inst_src, "expected single pointer type, found '{f}'", .{parent_ptr_ty.fmt(pt)});
     }
     const parent_ty: Type = .fromInterned(parent_ptr_info.child);
+    try sema.ensureLayoutResolved(parent_ty);
     switch (parent_ty.zigTypeTag(zcu)) {
         .@"struct", .@"union" => {},
         else => return sema.fail(block, inst_src, "expected pointer to struct or union type, found '{f}'", .{parent_ptr_ty.fmt(pt)}),
     }
-    try parent_ty.resolveLayout(pt);
 
     const field_name = try sema.resolveConstStringIntern(block, field_name_src, extra.field_name, .{ .simple = .field_name });
     const field_index = switch (parent_ty.zigTypeTag(zcu)) {
@@ -24293,7 +23631,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     var actual_parent_ptr_info: InternPool.Key.PtrType = .{
         .child = parent_ty.toIntern(),
         .flags = .{
-            .alignment = try parent_ptr_ty.ptrAlignmentSema(pt),
+            .alignment = parent_ptr_ty.ptrAlignment(zcu),
             .is_const = field_ptr_info.flags.is_const,
             .is_volatile = field_ptr_info.flags.is_volatile,
             .is_allowzero = field_ptr_info.flags.is_allowzero,
@@ -24305,7 +23643,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     var actual_field_ptr_info: InternPool.Key.PtrType = .{
         .child = field_ty.toIntern(),
         .flags = .{
-            .alignment = try field_ptr_ty.ptrAlignmentSema(pt),
+            .alignment = field_ptr_ty.ptrAlignment(zcu),
             .is_const = field_ptr_info.flags.is_const,
             .is_volatile = field_ptr_info.flags.is_volatile,
             .is_allowzero = field_ptr_info.flags.is_allowzero,
@@ -24315,23 +23653,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     };
     switch (parent_ty.containerLayout(zcu)) {
         .auto => {
-            actual_parent_ptr_info.flags.alignment = actual_field_ptr_info.flags.alignment.minStrict(
-                if (zcu.typeToStruct(parent_ty)) |struct_obj|
-                    try field_ty.structFieldAlignmentSema(
-                        struct_obj.fieldAlign(ip, field_index),
-                        struct_obj.layout,
-                        pt,
-                    )
-                else if (zcu.typeToUnion(parent_ty)) |union_obj|
-                    try field_ty.unionFieldAlignmentSema(
-                        union_obj.fieldAlign(ip, field_index),
-                        union_obj.flagsUnordered(ip).layout,
-                        pt,
-                    )
-                else
-                    actual_field_ptr_info.flags.alignment,
-            );
-
+            actual_parent_ptr_info.flags.alignment = parent_ty.resolvedFieldAlignment(field_index, zcu);
             actual_parent_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
             actual_field_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
         },
@@ -24357,9 +23679,9 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
         },
     }
 
-    const actual_field_ptr_ty = try pt.ptrTypeSema(actual_field_ptr_info);
+    const actual_field_ptr_ty = try pt.ptrType(actual_field_ptr_info);
     const casted_field_ptr = try sema.coerce(block, actual_field_ptr_ty, field_ptr, field_ptr_src);
-    const actual_parent_ptr_ty = try pt.ptrTypeSema(actual_parent_ptr_info);
+    const actual_parent_ptr_ty = try pt.ptrType(actual_parent_ptr_info);
 
     const result = if (try sema.resolveDefinedValue(block, field_ptr_src, casted_field_ptr)) |field_ptr_val| result: {
         switch (parent_ty.zigTypeTag(zcu)) {
@@ -24590,7 +23912,7 @@ fn analyzeMinMax(
         const operand_scalar_ty = sema.typeOf(operand).scalarType(zcu);
         const want_strat: TypeStrat = switch (operand_scalar_ty.zigTypeTag(zcu)) {
             .comptime_int => s: {
-                const val = (try sema.resolveValueResolveLazy(operand)).?;
+                const val = (try sema.resolveValue(operand)).?;
                 if (val.isUndef(zcu)) break :s .none;
                 break :s .{ .int = .{
                     .all_comptime_int = true,
@@ -24609,7 +23931,7 @@ fn analyzeMinMax(
                 // (replaced with just the simple calls to `Type.minInt`/`Type.maxInt`) so that we only
                 // use the input *types* to determine the result type.
                 const min: Value, const max: Value = bounds: {
-                    if (try sema.resolveValueResolveLazy(operand)) |operand_val| {
+                    if (try sema.resolveValue(operand)) |operand_val| {
                         if (vector_len) |len| {
                             var min = try operand_val.elemValue(pt, 0);
                             var max = min;
@@ -24696,6 +24018,9 @@ fn analyzeMinMax(
         .child = intermediate_scalar_ty.toIntern(),
     }) else intermediate_scalar_ty;
 
+    // We might have refined all the way down to an OPV type---check now.
+    if (try result_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+
     // This value, if not `null`, will have type `intermediate_ty`.
     const comptime_part: ?Value = ct: {
         // Contains the comptime-known scalar result values.
@@ -24712,7 +24037,7 @@ fn analyzeMinMax(
         var opt_runtime_src: ?LazySrcLoc = null;
 
         for (operands, operand_srcs) |operand, operand_src| {
-            const operand_val = try sema.resolveValueResolveLazy(operand) orelse {
+            const operand_val = try sema.resolveValue(operand) orelse {
                 if (opt_runtime_src == null) opt_runtime_src = operand_src;
                 continue;
             };
@@ -24819,7 +24144,7 @@ fn upgradeToArrayPtr(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, len: u64) !A
         // Already an array pointer.
         return ptr;
     }
-    const new_ty = try pt.ptrTypeSema(.{
+    const new_ty = try pt.ptrType(.{
         .child = (try pt.arrayType(.{
             .len = len,
             .sentinel = info.sentinel,
@@ -24883,6 +24208,9 @@ fn zirMemcpy(
     const dest_elem_ty = dest_ty.indexablePtrElem(zcu);
     const src_elem_ty = src_ty.indexablePtrElem(zcu);
 
+    try sema.ensureLayoutResolved(dest_elem_ty);
+    try sema.ensureLayoutResolved(src_elem_ty);
+
     const imc = try sema.coerceInMemoryAllowed(
         block,
         dest_elem_ty,
@@ -24946,13 +24274,13 @@ fn zirMemcpy(
     }
 
     zero_bit: {
-        const src_comptime = try src_elem_ty.comptimeOnlySema(pt);
-        const dest_comptime = try dest_elem_ty.comptimeOnlySema(pt);
+        const src_comptime = src_elem_ty.comptimeOnly(zcu);
+        const dest_comptime = dest_elem_ty.comptimeOnly(zcu);
         assert(src_comptime == dest_comptime); // IMC
         if (src_comptime) break :zero_bit;
 
-        const src_has_bits = try src_elem_ty.hasRuntimeBitsIgnoreComptimeSema(pt);
-        const dest_has_bits = try dest_elem_ty.hasRuntimeBitsIgnoreComptimeSema(pt);
+        const src_has_bits = src_elem_ty.hasRuntimeBits(zcu);
+        const dest_has_bits = dest_elem_ty.hasRuntimeBits(zcu);
         assert(src_has_bits == dest_has_bits); // IMC
         if (src_has_bits) break :zero_bit;
 
@@ -24968,7 +24296,7 @@ fn zirMemcpy(
         const raw_dest_ptr = if (dest_ty.isSlice(zcu)) dest_ptr_val.slicePtr(zcu) else dest_ptr_val;
         const raw_src_ptr = if (src_ty.isSlice(zcu)) src_ptr_val.slicePtr(zcu) else src_ptr_val;
 
-        const len_u64 = try len_val.?.toUnsignedIntSema(pt);
+        const len_u64 = len_val.?.toUnsignedInt(zcu);
 
         if (check_aliasing) {
             if (Value.doPointersOverlap(
@@ -25018,7 +24346,7 @@ fn zirMemcpy(
     var new_dest_ptr = dest_ptr;
     var new_src_ptr = src_ptr;
     if (len_val) |val| {
-        const len = try val.toUnsignedIntSema(pt);
+        const len = val.toUnsignedInt(zcu);
         if (len == 0) {
             // This AIR instruction guarantees length > 0 if it is comptime-known.
             return;
@@ -25067,7 +24395,7 @@ fn zirMemcpy(
             assert(dest_manyptr_ty_key.flags.size == .one);
             dest_manyptr_ty_key.child = dest_elem_ty.toIntern();
             dest_manyptr_ty_key.flags.size = .many;
-            break :ptr try sema.coerceCompatiblePtrs(block, try pt.ptrTypeSema(dest_manyptr_ty_key), new_dest_ptr, dest_src);
+            break :ptr try sema.coerceCompatiblePtrs(block, try pt.ptrType(dest_manyptr_ty_key), new_dest_ptr, dest_src);
         } else new_dest_ptr;
 
         const new_src_ptr_ty = sema.typeOf(new_src_ptr);
@@ -25078,7 +24406,7 @@ fn zirMemcpy(
             assert(src_manyptr_ty_key.flags.size == .one);
             src_manyptr_ty_key.child = src_elem_ty.toIntern();
             src_manyptr_ty_key.flags.size = .many;
-            break :ptr try sema.coerceCompatiblePtrs(block, try pt.ptrTypeSema(src_manyptr_ty_key), new_src_ptr, src_src);
+            break :ptr try sema.coerceCompatiblePtrs(block, try pt.ptrType(src_manyptr_ty_key), new_src_ptr, src_src);
         } else new_src_ptr;
 
         // ok1: dest >= src + len
@@ -25148,7 +24476,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const runtime_src = rs: {
         const len_air_ref = try sema.fieldVal(block, src, dest_ptr, try ip.getOrPutString(gpa, io, pt.tid, "len", .no_embedded_nulls), dest_src);
         const len_val = (try sema.resolveDefinedValue(block, dest_src, len_air_ref)) orelse break :rs dest_src;
-        const len_u64 = try len_val.toUnsignedIntSema(pt);
+        const len_u64 = len_val.toUnsignedInt(zcu);
         const len = try sema.usizeCast(block, dest_src, len_u64);
         if (len == 0) {
             // This AIR instruction guarantees length > 0 if it is comptime-known.
@@ -25436,7 +24764,7 @@ fn resolvePrefetchOptions(
 
     return std.builtin.PrefetchOptions{
         .rw = try sema.interpretBuiltinType(block, rw_src, rw_val, std.builtin.PrefetchOptions.Rw),
-        .locality = @intCast(try locality_val.toUnsignedIntSema(pt)),
+        .locality = @intCast(locality_val.toUnsignedInt(zcu)),
         .cache = try sema.interpretBuiltinType(block, cache_src, cache_val, std.builtin.PrefetchOptions.Cache),
     };
 }
@@ -25626,7 +24954,7 @@ fn zirBuiltinExtern(
         // So, for now, just use our containing `declaration`.
         .zir_index = switch (sema.owner.unwrap()) {
             .@"comptime" => |cu| ip.getComptimeUnit(cu).zir_index,
-            .type => |owner_ty| Type.fromInterned(owner_ty).typeDeclInst(zcu).?,
+            .type_layout, .type_inits => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
             .memoized_state => unreachable,
             .nav_ty, .nav_val => |nav| ip.getNav(nav).analysis.?.zir_index,
             .func => |func| zir_index: {
@@ -25839,7 +25167,8 @@ fn requireRuntimeBlock(sema: *Sema, block: *Block, src: LazySrcLoc, runtime_src:
     }
 }
 
-/// Emit a compile error if type cannot be used for a runtime variable.
+/// Emit a compile error if `var_ty` cannot be used for a runtime variable.
+/// Asserts that the layout of `var_ty` is already resolved.
 pub fn validateVarType(
     sema: *Sema,
     block: *Block,
@@ -25849,6 +25178,7 @@ pub fn validateVarType(
 ) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    var_ty.assertHasLayout(zcu);
     if (is_extern) {
         if (!try sema.validateExternType(var_ty, .other)) {
             const msg = msg: {
@@ -25870,7 +25200,7 @@ pub fn validateVarType(
         }
     }
 
-    if (!try var_ty.comptimeOnlySema(pt)) return;
+    if (!var_ty.comptimeOnly(zcu)) return;
 
     const msg = msg: {
         const msg = try sema.errMsg(src, "variable of type '{f}' must be const or comptime", .{var_ty.fmt(pt)});
@@ -25886,49 +25216,28 @@ pub fn validateVarType(
     return sema.failWithOwnedErrorMsg(block, msg);
 }
 
-const TypeSet = std.AutoHashMapUnmanaged(InternPool.Index, void);
-
 fn explainWhyTypeIsComptime(
     sema: *Sema,
     msg: *Zcu.ErrorMsg,
-    src_loc: LazySrcLoc,
+    src: LazySrcLoc,
     ty: Type,
-) CompileError!void {
-    var type_set = TypeSet{};
-    defer type_set.deinit(sema.gpa);
-
-    try ty.resolveFully(sema.pt);
-    return sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty, &type_set);
-}
-
-fn explainWhyTypeIsComptimeInner(
-    sema: *Sema,
-    msg: *Zcu.ErrorMsg,
-    src_loc: LazySrcLoc,
-    ty: Type,
-    type_set: *TypeSet,
 ) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
+    assert(ty.comptimeOnly(zcu));
     switch (ty.zigTypeTag(zcu)) {
         .bool,
         .int,
         .float,
         .error_set,
-        .@"enum",
         .frame,
         .@"anyframe",
         .void,
-        => return,
-
-        .@"fn" => {
-            try sema.errNote(src_loc, msg, "use '*const {f}' for a function pointer type", .{ty.fmt(pt)});
-        },
-
-        .type => {
-            try sema.errNote(src_loc, msg, "types are not available at runtime", .{});
-        },
+        .@"enum",
+        .@"opaque",
+        .pointer,
+        => unreachable, // not comptime-only
 
         .comptime_float,
         .comptime_int,
@@ -25936,78 +25245,53 @@ fn explainWhyTypeIsComptimeInner(
         .noreturn,
         .undefined,
         .null,
-        => return,
+        => return, // no explanation needed
 
-        .@"opaque" => {
-            try sema.errNote(src_loc, msg, "opaque type '{f}' has undefined size", .{ty.fmt(pt)});
-        },
+        .array, .vector => try sema.explainWhyTypeIsComptime(msg, src, ty.childType(zcu)),
+        .optional => try sema.explainWhyTypeIsComptime(msg, src, ty.optionalChild(zcu)),
+        .error_union => try sema.explainWhyTypeIsComptime(msg, src, ty.errorUnionPayload(zcu)),
 
-        .array, .vector => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(zcu), type_set);
-        },
-        .pointer => {
-            const elem_ty = ty.elemType2(zcu);
-            if (elem_ty.zigTypeTag(zcu) == .@"fn") {
-                const fn_info = zcu.typeToFunc(elem_ty).?;
-                if (fn_info.is_generic) {
-                    try sema.errNote(src_loc, msg, "function is generic", .{});
-                }
-                switch (fn_info.cc) {
-                    .@"inline" => try sema.errNote(src_loc, msg, "function has inline calling convention", .{}),
-                    else => {},
-                }
-                if (Type.fromInterned(fn_info.return_type).comptimeOnly(zcu)) {
-                    try sema.errNote(src_loc, msg, "function has a comptime-only return type", .{});
-                }
-                return;
-            }
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(zcu), type_set);
-        },
-
-        .optional => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.optionalChild(zcu), type_set);
-        },
-        .error_union => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.errorUnionPayload(zcu), type_set);
-        },
-
-        .@"struct" => {
-            if ((try type_set.getOrPut(sema.gpa, ty.toIntern())).found_existing) return;
+        .@"fn" => try sema.errNote(src, msg, "use '*const {f}' for a function pointer type", .{ty.fmt(pt)}),
+        .type => try sema.errNote(src, msg, "types are not available at runtime", .{}),
 
-            if (zcu.typeToStruct(ty)) |struct_type| {
-                for (0..struct_type.field_types.len) |i| {
-                    const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-                    const field_src: LazySrcLoc = .{
-                        .base_node_inst = struct_type.zir_index,
-                        .offset = .{ .container_field_type = @intCast(i) },
-                    };
-
-                    if (try field_ty.comptimeOnlySema(pt)) {
-                        try sema.errNote(field_src, msg, "struct requires comptime because of this field", .{});
-                        try sema.explainWhyTypeIsComptimeInner(msg, field_src, field_ty, type_set);
-                    }
-                }
+        .@"struct" => if (zcu.typeToStruct(ty)) |struct_type| {
+            ty.assertHasLayout(zcu);
+            for (0..struct_type.field_types.len) |i| {
+                const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
+                if (!field_ty.comptimeOnly(zcu)) continue;
+                const field_src: LazySrcLoc = .{
+                    .base_node_inst = struct_type.zir_index,
+                    .offset = .{ .container_field_type = @intCast(i) },
+                };
+                try sema.errNote(field_src, msg, "struct requires comptime because of this field", .{});
+                return sema.explainWhyTypeIsComptime(msg, field_src, field_ty);
+            }
+            unreachable;
+        } else {
+            const tuple = ip.indexToKey(ty.toIntern()).tuple_type;
+            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty_ip, field_val_ip| {
+                if (field_val_ip != .none) continue;
+                const field_ty: Type = .fromInterned(field_ty_ip);
+                if (!field_ty.comptimeOnly(zcu)) continue;
+                try sema.errNote(src, msg, "tuple requires comptime because of field of type '{f}'", .{field_ty.fmt(pt)});
+                return sema.explainWhyTypeIsComptime(msg, src, field_ty);
             }
-            // TODO tuples
+            unreachable;
         },
 
         .@"union" => {
-            if ((try type_set.getOrPut(sema.gpa, ty.toIntern())).found_existing) return;
-
-            if (zcu.typeToUnion(ty)) |union_obj| {
-                for (0..union_obj.field_types.len) |i| {
-                    const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[i]);
-                    const field_src: LazySrcLoc = .{
-                        .base_node_inst = union_obj.zir_index,
-                        .offset = .{ .container_field_type = @intCast(i) },
-                    };
-
-                    if (try field_ty.comptimeOnlySema(pt)) {
-                        try sema.errNote(field_src, msg, "union requires comptime because of this field", .{});
-                        try sema.explainWhyTypeIsComptimeInner(msg, field_src, field_ty, type_set);
-                    }
-                }
+            const union_obj = zcu.typeToUnion(ty).?;
+            for (0..union_obj.field_types.len) |i| {
+                const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[i]);
+                if (!field_ty.comptimeOnly(zcu)) continue;
+                const field_src: LazySrcLoc = .{
+                    .base_node_inst = union_obj.zir_index,
+                    .offset = .{ .container_field_type = @intCast(i) },
+                };
+                try sema.errNote(field_src, msg, "union requires comptime because of this field", .{});
+                return sema.explainWhyTypeIsComptime(msg, field_src, field_ty);
             }
+            unreachable;
         },
     }
 }
@@ -26022,9 +25306,8 @@ const ExternPosition = enum {
 };
 
 /// Returns true if `ty` is allowed in extern types.
-/// Does *NOT* require `ty` to be resolved in any way.
-/// Calls `resolveLayout` for packed containers.
-fn validateExternType(
+/// Does not require `ty` to be resolved in any way.
+pub fn validateExternType(
     sema: *Sema,
     ty: Type,
     position: ExternPosition,
@@ -26042,7 +25325,16 @@ fn validateExternType(
         .error_set,
         .frame,
         => return false,
-        .void => return position == .union_field or position == .ret_ty or position == .struct_field or position == .element,
+        .void => return switch (position) {
+            .ret_ty,
+            .union_field,
+            .struct_field,
+            .element,
+            => true,
+            .param_ty,
+            .other,
+            => false,
+        },
         .noreturn => return position == .ret_ty,
         .@"opaque",
         .bool,
@@ -26050,10 +25342,12 @@ fn validateExternType(
         .@"anyframe",
         => return true,
         .pointer => {
-            if (ty.childType(zcu).zigTypeTag(zcu) == .@"fn") {
-                return ty.isConstPtr(zcu) and try sema.validateExternType(ty.childType(zcu), .other);
+            if (ty.isSlice(zcu)) return false;
+            const child_ty = ty.childType(zcu);
+            if (child_ty.zigTypeTag(zcu) == .@"fn") {
+                return ty.isConstPtr(zcu) and try sema.validateExternType(child_ty, .other);
             }
-            return !(ty.isSlice(zcu) or try ty.comptimeOnlySema(pt));
+            return true;
         },
         .int => switch (ty.intInfo(zcu).bits) {
             0, 8, 16, 32, 64, 128 => return true,
@@ -26069,29 +25363,42 @@ fn validateExternType(
             return !target_util.fnCallConvAllowsZigTypes(ty.fnCallingConvention(zcu));
         },
         .@"enum" => {
-            return sema.validateExternType(ty.intTagType(zcu), position);
+            const enum_obj = zcu.intern_pool.loadEnumType(ty.toIntern());
+            if (!enum_obj.int_tag_is_explicit) return false;
+            return sema.validateExternType(.fromInterned(enum_obj.int_tag_type), position);
         },
-        .@"struct", .@"union" => switch (ty.containerLayout(zcu)) {
-            .@"extern" => return true,
-            .@"packed" => {
-                const bit_size = try ty.bitSizeSema(pt);
-                switch (bit_size) {
-                    0, 8, 16, 32, 64, 128 => return true,
-                    else => return false,
-                }
-            },
-            .auto => return !(try ty.hasRuntimeBitsSema(pt)),
+        .@"struct" => {
+            const struct_obj = zcu.intern_pool.loadStructType(ty.toIntern());
+            return switch (struct_obj.layout) {
+                .auto => false,
+                .@"extern" => true,
+                .@"packed" => switch (struct_obj.packed_backing_mode) {
+                    .auto => false,
+                    .explicit => try sema.validateExternType(.fromInterned(struct_obj.packed_backing_int_type), position),
+                },
+            };
+        },
+        .@"union" => {
+            const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
+            return switch (union_obj.layout) {
+                .auto => false,
+                .@"extern" => true,
+                .@"packed" => switch (union_obj.packed_backing_mode) {
+                    .auto => false,
+                    .explicit => try sema.validateExternType(.fromInterned(union_obj.packed_backing_int_type), position),
+                },
+            };
         },
         .array => {
             if (position == .ret_ty or position == .param_ty) return false;
-            return sema.validateExternType(ty.elemType2(zcu), .element);
+            return sema.validateExternType(ty.childType(zcu), .element);
         },
-        .vector => return sema.validateExternType(ty.elemType2(zcu), .element),
+        .vector => return sema.validateExternType(ty.childType(zcu), .element),
         .optional => return ty.isPtrLikeOptional(zcu),
     }
 }
 
-fn explainWhyTypeIsNotExtern(
+pub fn explainWhyTypeIsNotExtern(
     sema: *Sema,
     msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
@@ -26125,9 +25432,6 @@ fn explainWhyTypeIsNotExtern(
                 const pointee_ty = ty.childType(zcu);
                 if (!ty.isConstPtr(zcu) and pointee_ty.zigTypeTag(zcu) == .@"fn") {
                     try sema.errNote(src_loc, msg, "pointer to extern function must be 'const'", .{});
-                } else if (try ty.comptimeOnlySema(pt)) {
-                    try sema.errNote(src_loc, msg, "pointer to comptime-only type '{f}'", .{pointee_ty.fmt(pt)});
-                    try sema.explainWhyTypeIsComptime(msg, src_loc, ty);
                 }
                 try sema.explainWhyTypeIsNotExtern(msg, src_loc, pointee_ty, .other);
             }
@@ -26157,6 +25461,7 @@ fn explainWhyTypeIsNotExtern(
             try sema.errNote(src_loc, msg, "enum tag type '{f}' is not extern compatible", .{tag_ty.fmt(pt)});
             try sema.explainWhyTypeIsNotExtern(msg, src_loc, tag_ty, position);
         },
+        // MLUGG TODO: these notes are bad now (because ABI sized packed type also needs explicit backing type)
         .@"struct" => try sema.errNote(src_loc, msg, "only extern structs and ABI sized packed structs are extern compatible", .{}),
         .@"union" => try sema.errNote(src_loc, msg, "only extern unions and ABI sized packed unions are extern compatible", .{}),
         .array => {
@@ -26165,51 +25470,14 @@ fn explainWhyTypeIsNotExtern(
             } else if (position == .param_ty) {
                 return sema.errNote(src_loc, msg, "arrays are not allowed as a parameter type", .{});
             }
-            try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(zcu), .element);
+            try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.childType(zcu), .element);
         },
-        .vector => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(zcu), .element),
+        .vector => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.childType(zcu), .element),
         .optional => try sema.errNote(src_loc, msg, "only pointer like optionals are extern compatible", .{}),
     }
 }
 
-/// Returns true if `ty` is allowed in packed types.
-/// Does not require `ty` to be resolved in any way, but may resolve whether it is comptime-only.
-fn validatePackedType(sema: *Sema, ty: Type) !bool {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    return switch (ty.zigTypeTag(zcu)) {
-        .type,
-        .comptime_float,
-        .comptime_int,
-        .enum_literal,
-        .undefined,
-        .null,
-        .error_union,
-        .error_set,
-        .frame,
-        .noreturn,
-        .@"opaque",
-        .@"anyframe",
-        .@"fn",
-        .array,
-        => false,
-        .optional => return ty.isPtrLikeOptional(zcu),
-        .void,
-        .bool,
-        .float,
-        .int,
-        .vector,
-        => true,
-        .@"enum" => switch (zcu.intern_pool.loadEnumType(ty.toIntern()).tag_mode) {
-            .auto => false,
-            .explicit, .nonexhaustive => true,
-        },
-        .pointer => !ty.isSlice(zcu) and !try ty.comptimeOnlySema(pt),
-        .@"struct", .@"union" => ty.containerLayout(zcu) == .@"packed",
-    };
-}
-
-fn explainWhyTypeIsNotPacked(
+pub fn explainWhyTypeIsNotPackable(
     sema: *Sema,
     msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
@@ -26250,8 +25518,8 @@ fn explainWhyTypeIsNotPacked(
             try sema.errNote(src_loc, msg, "type has no guaranteed in-memory representation", .{});
             try sema.errNote(src_loc, msg, "use '*const ' to make a function pointer type", .{});
         },
-        .@"struct" => try sema.errNote(src_loc, msg, "only packed structs layout are allowed in packed types", .{}),
-        .@"union" => try sema.errNote(src_loc, msg, "only packed unions layout are allowed in packed types", .{}),
+        .@"struct" => try sema.errNote(src_loc, msg, "struct in packed type must have packed layout", .{}),
+        .@"union" => try sema.errNote(src_loc, msg, "union in packed type must have packed layout", .{}),
     }
 }
 
@@ -26277,7 +25545,7 @@ fn getPanicIdFunc(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !In
     try sema.ensureMemoizedStateResolved(src, .panic);
     const panic_fn_index = zcu.builtin_decl_values.get(panic_id.toBuiltin());
     switch (sema.owner.unwrap()) {
-        .@"comptime", .nav_ty, .nav_val, .type, .memoized_state => {},
+        .@"comptime", .nav_ty, .nav_val, .type_layout, .type_inits, .memoized_state => {},
         .func => |owner_func| zcu.intern_pool.funcSetHasErrorTrace(io, owner_func, true),
     }
     return panic_fn_index;
@@ -26555,7 +25823,8 @@ fn fieldPtrLoad(
     const zcu = pt.zcu;
     const object_ptr_ty = sema.typeOf(object_ptr);
     const pointee_ty = object_ptr_ty.childType(zcu);
-    if (try typeHasOnePossibleValue(sema, pointee_ty)) |opv| {
+    try sema.ensureLayoutResolved(pointee_ty); // MLUGG TODO
+    if (try pointee_ty.onePossibleValue(pt)) |opv| {
         const object: Air.Inst.Ref = .fromValue(opv);
         return fieldVal(sema, block, src, object, field_name, field_name_src);
     }
@@ -26603,7 +25872,7 @@ fn fieldVal(
                 return Air.internedToRef((try pt.intValue(.usize, inner_ty.arrayLen(zcu))).toIntern());
             } else if (field_name.eqlSlice("ptr", ip) and is_pointer_to) {
                 const ptr_info = object_ty.ptrInfo(zcu);
-                const result_ty = try pt.ptrTypeSema(.{
+                const result_ty = try pt.ptrType(.{
                     .child = Type.fromInterned(ptr_info.child).childType(zcu).toIntern(),
                     .sentinel = if (inner_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
@@ -26693,7 +25962,6 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try child_type.resolveFields(pt);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index_usize| {
                             const field_index: u32 = @intCast(field_index_usize);
@@ -26731,6 +25999,7 @@ fn fieldVal(
         },
         .@"struct" => if (is_pointer_to) {
             // Avoid loading the entire struct by fetching a pointer and loading that
+            try sema.ensureLayoutResolved(inner_ty);
             const field_ptr = try sema.structFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
@@ -26738,6 +26007,7 @@ fn fieldVal(
         },
         .@"union" => if (is_pointer_to) {
             // Avoid loading the entire union by fetching a pointer and loading that
+            try sema.ensureLayoutResolved(inner_ty);
             const field_ptr = try sema.unionFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
@@ -26787,7 +26057,7 @@ fn fieldPtr(
                 return uavRef(sema, int_val.toIntern());
             } else if (field_name.eqlSlice("ptr", ip) and is_pointer_to) {
                 const ptr_info = object_ty.ptrInfo(zcu);
-                const new_ptr_ty = try pt.ptrTypeSema(.{
+                const new_ptr_ty = try pt.ptrType(.{
                     .child = Type.fromInterned(ptr_info.child).childType(zcu).toIntern(),
                     .sentinel = if (inner_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
@@ -26802,7 +26072,7 @@ fn fieldPtr(
                     .packed_offset = ptr_info.packed_offset,
                 });
                 const ptr_ptr_info = object_ptr_ty.ptrInfo(zcu);
-                const result_ty = try pt.ptrTypeSema(.{
+                const result_ty = try pt.ptrType(.{
                     .child = new_ptr_ty.toIntern(),
                     .sentinel = if (object_ptr_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
@@ -26836,7 +26106,7 @@ fn fieldPtr(
             if (field_name.eqlSlice("ptr", ip)) {
                 const slice_ptr_ty = inner_ty.slicePtrFieldType(zcu);
 
-                const result_ty = try pt.ptrTypeSema(.{
+                const result_ty = try pt.ptrType(.{
                     .child = slice_ptr_ty.toIntern(),
                     .flags = .{
                         .is_const = !attr_ptr_ty.ptrIsMutable(zcu),
@@ -26854,7 +26124,7 @@ fn fieldPtr(
                 try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
                 return field_ptr;
             } else if (field_name.eqlSlice("len", ip)) {
-                const result_ty = try pt.ptrTypeSema(.{
+                const result_ty = try pt.ptrType(.{
                     .child = .usize_type,
                     .flags = .{
                         .is_const = !attr_ptr_ty.ptrIsMutable(zcu),
@@ -26925,7 +26195,6 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try child_type.resolveFields(pt);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index| {
                             const field_index_u32: u32 = @intCast(field_index);
@@ -26960,6 +26229,7 @@ fn fieldPtr(
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
                 object_ptr;
+            try sema.ensureLayoutResolved(inner_ty);
             const field_ptr = try sema.structFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty, initializing);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
@@ -26969,6 +26239,7 @@ fn fieldPtr(
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
                 object_ptr;
+            try sema.ensureLayoutResolved(inner_ty);
             const field_ptr = try sema.unionFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty, initializing);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
@@ -27012,6 +26283,7 @@ fn fieldCallBind(
     // Optionally dereference a second pointer to get the concrete type.
     const is_double_ptr = inner_ty.zigTypeTag(zcu) == .pointer and inner_ty.ptrSize(zcu) == .one;
     const concrete_ty = if (is_double_ptr) inner_ty.childType(zcu) else inner_ty;
+    try sema.ensureLayoutResolved(concrete_ty);
     const ptr_ty = if (is_double_ptr) inner_ty else raw_ptr_ty;
     const object_ptr = if (is_double_ptr)
         try sema.analyzeLoad(block, src, raw_ptr, src)
@@ -27021,10 +26293,8 @@ fn fieldCallBind(
     find_field: {
         switch (concrete_ty.zigTypeTag(zcu)) {
             .@"struct" => {
-                try concrete_ty.resolveFields(pt);
                 if (zcu.typeToStruct(concrete_ty)) |struct_type| {
-                    const field_index = struct_type.nameIndex(ip, field_name) orelse
-                        break :find_field;
+                    const field_index = struct_type.nameIndex(ip, field_name) orelse break :find_field;
                     const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
 
                     return sema.finishFieldCallBind(block, src, ptr_ty, field_ty, field_index, object_ptr);
@@ -27047,9 +26317,9 @@ fn fieldCallBind(
                 }
             },
             .@"union" => {
-                try concrete_ty.resolveFields(pt);
                 const union_obj = zcu.typeToUnion(concrete_ty).?;
-                _ = union_obj.loadTagType(ip).nameIndex(ip, field_name) orelse break :find_field;
+                const enum_obj = ip.loadEnumType(union_obj.enum_tag_type);
+                if (enum_obj.nameIndex(ip, field_name) == null) break :find_field;
                 const field_ptr = try unionFieldPtr(sema, block, src, object_ptr, field_name, field_name_src, concrete_ty, false);
                 return .{ .direct = try sema.analyzeLoad(block, src, field_ptr, src) };
             },
@@ -27163,7 +26433,7 @@ fn finishFieldCallBind(
 ) CompileError!ResolvedFieldCallee {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const ptr_field_ty = try pt.ptrTypeSema(.{
+    const ptr_field_ty = try pt.ptrType(.{
         .child = field_ty.toIntern(),
         .flags = .{
             .is_const = !ptr_ty.ptrIsMutable(zcu),
@@ -27174,7 +26444,9 @@ fn finishFieldCallBind(
     const container_ty = ptr_ty.childType(zcu);
     if (container_ty.zigTypeTag(zcu) == .@"struct") {
         if (container_ty.structFieldIsComptime(field_index, zcu)) {
-            try container_ty.resolveStructFieldInits(pt);
+            if (!container_ty.isTuple(zcu)) {
+                try sema.ensureFieldInitsResolved(container_ty);
+            }
             const default_val = (try container_ty.structFieldValueComptime(pt, field_index)).?;
             return .{ .direct = Air.internedToRef(default_val.toIntern()) };
         }
@@ -27239,6 +26511,7 @@ fn namespaceLookupVal(
     return try sema.analyzeNavVal(block, src, nav);
 }
 
+/// Asserts that the layout of `struct_ty` is already resolved.
 fn structFieldPtr(
     sema: *Sema,
     block: *Block,
@@ -27252,10 +26525,9 @@ fn structFieldPtr(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    assert(struct_ty.zigTypeTag(zcu) == .@"struct");
 
-    try struct_ty.resolveFields(pt);
-    try struct_ty.resolveLayout(pt);
+    assert(struct_ty.zigTypeTag(zcu) == .@"struct");
+    struct_ty.assertHasLayout(zcu);
 
     if (struct_ty.isTuple(zcu)) {
         if (field_name.eqlSlice("len", ip)) {
@@ -27274,6 +26546,7 @@ fn structFieldPtr(
     return sema.structFieldPtrByIndex(block, src, struct_ptr, field_index, struct_ty);
 }
 
+/// Asserts that the layout of `struct_ty` is already resolved.
 fn structFieldPtrByIndex(
     sema: *Sema,
     block: *Block,
@@ -27286,8 +26559,10 @@ fn structFieldPtrByIndex(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
+    struct_ty.assertHasLayout(zcu);
+
     const struct_type = zcu.typeToStruct(struct_ty).?;
-    const field_is_comptime = struct_type.fieldIsComptime(ip, field_index);
+    const field_is_comptime = struct_type.field_is_comptime_bits.get(ip, field_index);
 
     // Comptime fields are handled later
     if (!field_is_comptime) {
@@ -27300,6 +26575,7 @@ fn structFieldPtrByIndex(
     const field_ty = struct_type.field_types.get(ip)[field_index];
     const struct_ptr_ty = sema.typeOf(struct_ptr);
     const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(zcu);
+    assert(struct_ptr_ty_info.child == struct_ty.toIntern());
 
     var ptr_ty_data: InternPool.Key.PtrType = .{
         .child = field_ty,
@@ -27313,7 +26589,7 @@ fn structFieldPtrByIndex(
     const parent_align = if (struct_ptr_ty_info.flags.alignment != .none)
         struct_ptr_ty_info.flags.alignment
     else
-        try Type.fromInterned(struct_ptr_ty_info.child).abiAlignmentSema(pt);
+        struct_ty.abiAlignment(zcu);
 
     if (struct_type.layout == .@"packed") {
         assert(!field_is_comptime);
@@ -27325,31 +26601,32 @@ fn structFieldPtrByIndex(
         // For extern structs, field alignment might be bigger than type's
         // natural alignment. Eg, in `extern struct { x: u32, y: u16 }` the
         // second field is aligned as u32.
-        const field_offset = struct_ty.structFieldOffset(field_index, zcu);
-        ptr_ty_data.flags.alignment = if (parent_align == .none)
-            .none
-        else
-            @enumFromInt(@min(@intFromEnum(parent_align), @ctz(field_offset)));
+        ptr_ty_data.flags.alignment = a: {
+            const field_off = struct_ty.structFieldOffset(field_index, zcu);
+            if (field_off == 0) break :a struct_ptr_ty_info.flags.alignment;
+            const true_field_align: Alignment = .fromLog2Units(@ctz(field_off));
+            if (struct_ptr_ty_info.flags.alignment == .none and
+                true_field_align == Type.fromInterned(field_ty).abiAlignment(zcu))
+            {
+                break :a .none;
+            }
+            break :a .minStrict(true_field_align, parent_align);
+        };
     } else {
         // Our alignment is capped at the field alignment.
-        const field_align = try Type.fromInterned(field_ty).structFieldAlignmentSema(
-            struct_type.fieldAlign(ip, field_index),
-            struct_type.layout,
-            pt,
-        );
         ptr_ty_data.flags.alignment = if (struct_ptr_ty_info.flags.alignment == .none)
-            field_align
+            struct_ty.explicitFieldAlignment(field_index, zcu)
         else
-            field_align.min(parent_align);
+            struct_ty.resolvedFieldAlignment(field_index, zcu).min(parent_align);
     }
 
-    const ptr_field_ty = try pt.ptrTypeSema(ptr_ty_data);
+    const ptr_field_ty = try pt.ptrType(ptr_ty_data);
 
     if (field_is_comptime) {
-        try struct_ty.resolveStructFieldInits(pt);
+        try sema.ensureFieldInitsResolved(struct_ty);
         const val = try pt.intern(.{ .ptr = .{
             .ty = ptr_field_ty.toIntern(),
-            .base_addr = .{ .comptime_field = struct_type.field_inits.get(ip)[field_index] },
+            .base_addr = .{ .comptime_field = struct_type.field_defaults.get(ip)[field_index] },
             .byte_offset = 0,
         } });
         return Air.internedToRef(val);
@@ -27371,32 +26648,26 @@ fn structFieldVal(
     const ip = &zcu.intern_pool;
     assert(struct_ty.zigTypeTag(zcu) == .@"struct");
 
-    try struct_ty.resolveFields(pt);
-
     switch (ip.indexToKey(struct_ty.toIntern())) {
         .struct_type => {
             const struct_type = ip.loadStructType(struct_ty.toIntern());
 
             const field_index = struct_type.nameIndex(ip, field_name) orelse
                 return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_name_src, field_name);
-            if (struct_type.fieldIsComptime(ip, field_index)) {
-                try struct_ty.resolveStructFieldInits(pt);
-                return Air.internedToRef(struct_type.field_inits.get(ip)[field_index]);
+            if (struct_type.field_is_comptime_bits.get(ip, field_index)) {
+                try sema.ensureFieldInitsResolved(struct_ty);
+                return .fromIntern(struct_type.field_defaults.get(ip)[field_index]);
             }
 
             const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
-            if (try sema.typeHasOnePossibleValue(field_ty)) |field_val|
-                return Air.internedToRef(field_val.toIntern());
+            if (try field_ty.onePossibleValue(pt)) |field_val|
+                return .fromValue(field_val);
 
             if (try sema.resolveValue(struct_byval)) |struct_val| {
                 if (struct_val.isUndef(zcu)) return pt.undefRef(field_ty);
-                if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
-                    return Air.internedToRef(opv.toIntern());
-                }
-                return Air.internedToRef((try struct_val.fieldValue(pt, field_index)).toIntern());
+                return .fromValue(try struct_val.fieldValue(pt, field_index));
             }
 
-            try field_ty.resolveLayout(pt);
             return block.addStructFieldVal(struct_byval, field_index, field_ty);
         },
         .tuple_type => {
@@ -27457,16 +26728,13 @@ fn tupleFieldValByIndex(
     const zcu = pt.zcu;
     const field_ty = tuple_ty.fieldType(field_index, zcu);
 
-    if (tuple_ty.structFieldIsComptime(field_index, zcu))
-        try tuple_ty.resolveStructFieldInits(pt);
     if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_value| {
         return Air.internedToRef(default_value.toIntern());
     }
 
+    if (try field_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+
     if (try sema.resolveValue(tuple_byval)) |tuple_val| {
-        if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
-            return Air.internedToRef(opv.toIntern());
-        }
         return switch (zcu.intern_pool.indexToKey(tuple_val.toIntern())) {
             .undef => pt.undefRef(field_ty),
             .aggregate => |aggregate| Air.internedToRef(switch (aggregate.storage) {
@@ -27478,10 +26746,10 @@ fn tupleFieldValByIndex(
         };
     }
 
-    try field_ty.resolveLayout(pt);
     return block.addStructFieldVal(tuple_byval, field_index, field_ty);
 }
 
+/// Asserts that the layout of `union_ty` is already resolved.
 fn unionFieldPtr(
     sema: *Sema,
     block: *Block,
@@ -27497,31 +26765,31 @@ fn unionFieldPtr(
     const ip = &zcu.intern_pool;
 
     assert(union_ty.zigTypeTag(zcu) == .@"union");
+    union_ty.assertHasLayout(zcu);
 
     const union_ptr_ty = sema.typeOf(union_ptr);
     const union_ptr_info = union_ptr_ty.ptrInfo(zcu);
-    try union_ty.resolveFields(pt);
     const union_obj = zcu.typeToUnion(union_ty).?;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-    const ptr_field_ty = try pt.ptrTypeSema(.{
+    const ptr_field_ty = try pt.ptrType(.{
         .child = field_ty.toIntern(),
         .flags = .{
             .is_const = union_ptr_info.flags.is_const,
             .is_volatile = union_ptr_info.flags.is_volatile,
             .address_space = union_ptr_info.flags.address_space,
-            .alignment = if (union_obj.flagsUnordered(ip).layout == .auto) blk: {
-                const union_align = if (union_ptr_info.flags.alignment != .none)
-                    union_ptr_info.flags.alignment
-                else
-                    try union_ty.abiAlignmentSema(pt);
-                const field_align = try union_ty.fieldAlignmentSema(field_index, pt);
-                break :blk union_align.min(field_align);
-            } else union_ptr_info.flags.alignment,
+            .alignment = a: {
+                if (union_obj.layout != .auto) break :a union_ptr_info.flags.alignment;
+                if (union_ptr_info.flags.alignment == .none) {
+                    break :a union_ty.explicitFieldAlignment(field_index, zcu);
+                }
+                const field_align = union_ty.resolvedFieldAlignment(field_index, zcu);
+                break :a union_ptr_info.flags.alignment.min(field_align);
+            },
         },
         .packed_offset = union_ptr_info.packed_offset,
     });
-    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_ty).enumFieldIndex(field_name, zcu).?);
+    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_type).enumFieldIndex(field_name, zcu).?);
 
     if (initializing and field_ty.zigTypeTag(zcu) == .noreturn) {
         const msg = msg: {
@@ -27538,16 +26806,16 @@ fn unionFieldPtr(
     }
 
     if (try sema.resolveDefinedValue(block, src, union_ptr)) |union_ptr_val| ct: {
-        switch (union_obj.flagsUnordered(ip).layout) {
+        switch (union_obj.layout) {
             .auto => if (initializing) {
                 if (!sema.isComptimeMutablePtr(union_ptr_val)) {
                     // The initialization is a runtime operation.
                     break :ct;
                 }
                 // Store to the union to initialize the tag.
-                const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_ty), enum_field_index);
+                const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
                 const payload_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-                const new_union_val = try pt.unionValue(union_ty, field_tag, try pt.undefValue(payload_ty));
+                const new_union_val = try pt.unionValue(union_ty, field_tag, try payload_ty.onePossibleValue(pt) orelse try pt.undefValue(payload_ty));
                 try sema.storePtrVal(block, src, union_ptr_val, new_union_val, union_ty);
             } else {
                 const union_val = (try sema.pointerDeref(block, src, union_ptr_val, union_ptr_ty)) orelse
@@ -27556,12 +26824,12 @@ fn unionFieldPtr(
                     return sema.failWithUseOfUndef(block, src, null);
                 }
                 const un = ip.indexToKey(union_val.toIntern()).un;
-                const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_ty), enum_field_index);
+                const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
                 const tag_matches = un.tag == field_tag.toIntern();
                 if (!tag_matches) {
                     const msg = msg: {
-                        const active_index = Type.fromInterned(union_obj.enum_tag_ty).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
-                        const active_field_name = Type.fromInterned(union_obj.enum_tag_ty).enumFieldName(active_index, zcu);
+                        const active_index = Type.fromInterned(union_obj.enum_tag_type).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
+                        const active_field_name = Type.fromInterned(union_obj.enum_tag_type).enumFieldName(active_index, zcu);
                         const msg = try sema.errMsg(src, "access of union field '{f}' while field '{f}' is active", .{
                             field_name.fmt(ip),
                             active_field_name.fmt(ip),
@@ -27582,15 +26850,15 @@ fn unionFieldPtr(
     // If the union has a tag, we must either set or or safety check it depending on `initializing`.
     tag: {
         if (union_ty.containerLayout(zcu) != .auto) break :tag;
-        const tag_ty: Type = .fromInterned(union_obj.enum_tag_ty);
-        if (try sema.typeHasOnePossibleValue(tag_ty) != null) break :tag;
+        const tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
+        if (try tag_ty.onePossibleValue(pt) != null) break :tag;
         // There is a hypothetical non-trivial tag. We must set it even if not there at runtime, but
         // only emit a safety check if it's available at runtime (i.e. it's safety-tagged).
         const want_tag = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
         if (initializing) {
             const set_tag_inst = try block.addBinOp(.set_union_tag, union_ptr, .fromValue(want_tag));
             try sema.checkComptimeKnownStore(block, set_tag_inst, .unneeded); // `unneeded` since this isn't a "proper" store
-        } else if (block.wantSafety() and union_obj.hasTag(ip)) {
+        } else if (block.wantSafety() and union_obj.runtime_tag != .none) {
             // The tag exists at runtime (safety tag), so emit a safety check.
             // TODO would it be better if get_union_tag supported pointers to unions?
             const union_val = try block.addTyOp(.load, union_ty, union_ptr);
@@ -27619,26 +26887,25 @@ fn unionFieldVal(
     const ip = &zcu.intern_pool;
     assert(union_ty.zigTypeTag(zcu) == .@"union");
 
-    try union_ty.resolveFields(pt);
     const union_obj = zcu.typeToUnion(union_ty).?;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_ty).enumFieldIndex(field_name, zcu).?);
+    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_type).enumFieldIndex(field_name, zcu).?);
 
     if (try sema.resolveValue(union_byval)) |union_val| {
         if (union_val.isUndef(zcu)) return pt.undefRef(field_ty);
 
         const un = ip.indexToKey(union_val.toIntern()).un;
-        const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_ty), enum_field_index);
+        const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
         const tag_matches = un.tag == field_tag.toIntern();
-        switch (union_obj.flagsUnordered(ip).layout) {
+        switch (union_obj.layout) {
             .auto => {
                 if (tag_matches) {
                     return Air.internedToRef(un.val);
                 } else {
                     const msg = msg: {
-                        const active_index = Type.fromInterned(union_obj.enum_tag_ty).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
-                        const active_field_name = Type.fromInterned(union_obj.enum_tag_ty).enumFieldName(active_index, zcu);
+                        const active_index = Type.fromInterned(union_obj.enum_tag_type).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
+                        const active_field_name = Type.fromInterned(union_obj.enum_tag_type).enumFieldName(active_index, zcu);
                         const msg = try sema.errMsg(src, "access of union field '{f}' while field '{f}' is active", .{
                             field_name.fmt(ip), active_field_name.fmt(ip),
                         });
@@ -27658,18 +26925,18 @@ fn unionFieldVal(
             .@"packed" => if (tag_matches) {
                 // Fast path - no need to use bitcast logic.
                 return Air.internedToRef(un.val);
-            } else if (try sema.bitCastVal(union_val, field_ty, 0, try union_ty.bitSizeSema(pt), 0)) |field_val| {
+            } else if (try sema.bitCastVal(union_val, field_ty, 0, union_ty.bitSize(zcu), 0)) |field_val| {
                 return Air.internedToRef(field_val.toIntern());
             },
         }
     }
 
-    if (union_obj.flagsUnordered(ip).layout == .auto and block.wantSafety() and
+    if (union_obj.layout == .auto and block.wantSafety() and
         union_ty.unionTagTypeSafety(zcu) != null and union_obj.field_types.len > 1)
     {
-        const wanted_tag_val = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_ty), enum_field_index);
+        const wanted_tag_val = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
         const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern());
-        const active_tag = try block.addTyOp(.get_union_tag, .fromInterned(union_obj.enum_tag_ty), union_byval);
+        const active_tag = try block.addTyOp(.get_union_tag, .fromInterned(union_obj.enum_tag_type), union_byval);
         try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, wanted_tag);
     }
 
@@ -27678,11 +26945,8 @@ fn unionFieldVal(
         return .unreachable_value;
     }
 
-    if (try sema.typeHasOnePossibleValue(field_ty)) |field_only_value| {
-        return Air.internedToRef(field_only_value.toIntern());
-    }
+    if (try field_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
-    try field_ty.resolveLayout(pt);
     return block.addStructFieldVal(union_byval, field_index, field_ty);
 }
 
@@ -27706,17 +26970,19 @@ fn elemPtr(
         else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{f}'", .{indexable_ptr_ty.fmt(pt)}),
     };
     try sema.checkIndexable(block, src, indexable_ty);
+    try sema.ensureLayoutResolved(indexable_ty);
 
     const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {
         .array, .vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
         .@"struct" => blk: {
             // Tuple field access.
             const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{ .simple = .tuple_field_index });
-            const index: u32 = @intCast(try index_val.toUnsignedIntSema(pt));
+            const index: u32 = @intCast(index_val.toUnsignedInt(zcu));
             break :blk try sema.tupleFieldPtr(block, src, indexable_ptr, elem_index_src, index, init);
         },
         else => {
             const indexable = try sema.analyzeLoad(block, indexable_ptr_src, indexable_ptr, indexable_ptr_src);
+            try sema.ensureLayoutResolved(sema.typeOf(indexable).childType(zcu));
             return elemPtrOneLayerOnly(sema, block, src, indexable, elem_index, elem_index_src, init, oob_safety);
         },
     };
@@ -27725,7 +26991,7 @@ fn elemPtr(
     return elem_ptr;
 }
 
-/// Asserts that the type of indexable is pointer.
+/// Asserts that `indexable` is an indexable pointer whose child type has its layout already resolved.
 fn elemPtrOneLayerOnly(
     sema: *Sema,
     block: *Block,
@@ -27741,7 +27007,10 @@ fn elemPtrOneLayerOnly(
     const pt = sema.pt;
     const zcu = pt.zcu;
 
-    try sema.checkIndexable(block, src, indexable_ty);
+    assert(indexable_ty.isIndexable(zcu));
+    assert(indexable_ty.zigTypeTag(zcu) == .pointer);
+    const child_ty = indexable_ty.childType(zcu);
+    child_ty.assertHasLayout(zcu);
 
     switch (indexable_ty.ptrSize(zcu)) {
         .slice => return sema.elemPtrSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
@@ -27751,7 +27020,7 @@ fn elemPtrOneLayerOnly(
             ct: {
                 const ptr_val = maybe_ptr_val orelse break :ct;
                 const index_val = maybe_index_val orelse break :ct;
-                const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
+                const index: usize = @intCast(index_val.toUnsignedInt(zcu));
                 const elem_ptr = try ptr_val.ptrElem(index, pt);
                 return Air.internedToRef(elem_ptr.toIntern());
             }
@@ -27762,7 +27031,7 @@ fn elemPtrOneLayerOnly(
             try sema.validateRuntimeElemAccess(block, elem_index_src, result_ty, indexable_ty, indexable_src);
             try sema.validateRuntimeValue(block, indexable_src, indexable);
 
-            if (!try result_ty.childType(zcu).hasRuntimeBitsIgnoreComptimeSema(pt)) {
+            if (result_ty.childType(zcu).abiSize(zcu) == 0) {
                 // zero-bit child type; just bitcast the pointer
                 return block.addBitCast(result_ty, indexable);
             }
@@ -27770,13 +27039,12 @@ fn elemPtrOneLayerOnly(
             return block.addPtrElemPtr(indexable, elem_index, result_ty);
         },
         .one => {
-            const child_ty = indexable_ty.childType(zcu);
             const elem_ptr = switch (child_ty.zigTypeTag(zcu)) {
                 .array, .vector => try sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety),
                 .@"struct" => blk: {
                     assert(child_ty.isTuple(zcu));
                     const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{ .simple = .tuple_field_index });
-                    const index: u32 = @intCast(try index_val.toUnsignedIntSema(pt));
+                    const index: u32 = @intCast(index_val.toUnsignedInt(zcu));
                     break :blk try sema.tupleFieldPtr(block, indexable_src, indexable, elem_index_src, index, false);
                 },
                 else => unreachable, // Guaranteed by checkIndexable
@@ -27808,45 +27076,45 @@ fn elemVal(
     const elem_index = try sema.coerce(block, .usize, elem_index_uncasted, elem_index_src);
 
     switch (indexable_ty.zigTypeTag(zcu)) {
-        .pointer => switch (indexable_ty.ptrSize(zcu)) {
-            .slice => return sema.elemValSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
-            .many, .c => {
-                const maybe_indexable_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
-                const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
-                const elem_ty = indexable_ty.elemType2(zcu);
+        .pointer => {
+            const child_ty = indexable_ty.childType(zcu);
+            try sema.ensureLayoutResolved(child_ty);
+            switch (indexable_ty.ptrSize(zcu)) {
+                .slice => return sema.elemValSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
+                .many, .c => {
+                    const maybe_indexable_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
+                    const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
 
-                ct: {
-                    const indexable_val = maybe_indexable_val orelse break :ct;
-                    const index_val = maybe_index_val orelse break :ct;
-                    const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
-                    const many_ptr_ty = try pt.manyConstPtrType(elem_ty);
-                    const many_ptr_val = try pt.getCoerced(indexable_val, many_ptr_ty);
-                    const elem_ptr_ty = try pt.singleConstPtrType(elem_ty);
-                    const elem_ptr_val = try many_ptr_val.ptrElem(index, pt);
-                    const elem_val = try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty) orelse break :ct;
-                    return Air.internedToRef((try pt.getCoerced(elem_val, elem_ty)).toIntern());
-                }
+                    ct: {
+                        const indexable_val = maybe_indexable_val orelse break :ct;
+                        const index_val = maybe_index_val orelse break :ct;
+                        const index: usize = @intCast(index_val.toUnsignedInt(zcu));
+                        const many_ptr_ty = try pt.manyConstPtrType(child_ty);
+                        const many_ptr_val = try pt.getCoerced(indexable_val, many_ptr_ty);
+                        const elem_ptr_ty = try pt.singleConstPtrType(child_ty);
+                        const elem_ptr_val = try many_ptr_val.ptrElem(index, pt);
+                        const elem_val = try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty) orelse break :ct;
+                        return Air.internedToRef((try pt.getCoerced(elem_val, child_ty)).toIntern());
+                    }
 
-                if (try sema.typeHasOnePossibleValue(elem_ty)) |elem_only_value| {
-                    return Air.internedToRef(elem_only_value.toIntern());
-                }
+                    if (try child_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
-                try sema.checkLogicalPtrOperation(block, src, indexable_ty);
-                return block.addBinOp(.ptr_elem_val, indexable, elem_index);
-            },
-            .one => {
-                arr_sent: {
-                    const inner_ty = indexable_ty.childType(zcu);
-                    if (inner_ty.zigTypeTag(zcu) != .array) break :arr_sent;
-                    const sentinel = inner_ty.sentinel(zcu) orelse break :arr_sent;
-                    const index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index) orelse break :arr_sent;
-                    const index = try sema.usizeCast(block, src, try index_val.toUnsignedIntSema(pt));
-                    if (index != inner_ty.arrayLen(zcu)) break :arr_sent;
-                    return Air.internedToRef(sentinel.toIntern());
-                }
-                const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
-                return sema.analyzeLoad(block, indexable_src, elem_ptr, elem_index_src);
-            },
+                    try sema.checkLogicalPtrOperation(block, src, indexable_ty);
+                    return block.addBinOp(.ptr_elem_val, indexable, elem_index);
+                },
+                .one => {
+                    arr_sent: {
+                        if (child_ty.zigTypeTag(zcu) != .array) break :arr_sent;
+                        const sentinel = child_ty.sentinel(zcu) orelse break :arr_sent;
+                        const index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index) orelse break :arr_sent;
+                        const index = try sema.usizeCast(block, src, index_val.toUnsignedInt(zcu));
+                        if (index != child_ty.arrayLen(zcu)) break :arr_sent;
+                        return .fromValue(sentinel);
+                    }
+                    const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
+                    return sema.analyzeLoad(block, indexable_src, elem_ptr, elem_index_src);
+                },
+            }
         },
         .array => return sema.elemValArray(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
         .vector => {
@@ -27856,7 +27124,7 @@ fn elemVal(
         .@"struct" => {
             // Tuple field access.
             const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{ .simple = .tuple_field_index });
-            const index: u32 = @intCast(try index_val.toUnsignedIntSema(pt));
+            const index: u32 = @intCast(index_val.toUnsignedInt(zcu));
             return sema.tupleField(block, indexable_src, indexable, elem_index_src, index);
         },
         else => unreachable,
@@ -27864,6 +27132,7 @@ fn elemVal(
 }
 
 /// Called when the index or indexable is runtime known.
+/// Asserts that the layout of `elem_ty` is already resolved.
 fn validateRuntimeElemAccess(
     sema: *Sema,
     block: *Block,
@@ -27875,7 +27144,7 @@ fn validateRuntimeElemAccess(
     const pt = sema.pt;
     const zcu = pt.zcu;
 
-    if (try elem_ty.comptimeOnlySema(sema.pt)) {
+    if (elem_ty.comptimeOnly(zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(
                 elem_index_src,
@@ -27900,6 +27169,7 @@ fn validateRuntimeElemAccess(
     }
 }
 
+/// Asserts that the layout of the tuple type is already resolved.
 fn tupleFieldPtr(
     sema: *Sema,
     block: *Block,
@@ -27914,9 +27184,10 @@ fn tupleFieldPtr(
     const tuple_ptr_ty = sema.typeOf(tuple_ptr);
     const tuple_ptr_info = tuple_ptr_ty.ptrInfo(zcu);
     const tuple_ty: Type = .fromInterned(tuple_ptr_info.child);
-    try tuple_ty.resolveFields(pt);
     const field_count = tuple_ty.structFieldCount(zcu);
 
+    tuple_ty.assertHasLayout(zcu);
+
     if (field_count == 0) {
         return sema.fail(block, tuple_ptr_src, "indexing into empty tuple is not allowed", .{});
     }
@@ -27928,7 +27199,7 @@ fn tupleFieldPtr(
     }
 
     const field_ty = tuple_ty.fieldType(field_index, zcu);
-    const ptr_field_ty = try pt.ptrTypeSema(.{
+    const ptr_field_ty = try pt.ptrType(.{
         .child = field_ty.toIntern(),
         .flags = .{
             .is_const = tuple_ptr_info.flags.is_const,
@@ -27938,15 +27209,12 @@ fn tupleFieldPtr(
                 if (tuple_ptr_info.flags.alignment == .none) break :a .none;
                 // The tuple pointer isn't naturally aligned, so the field pointer might be underaligned.
                 const tuple_align = tuple_ptr_info.flags.alignment;
-                const field_align = try field_ty.abiAlignmentSema(pt);
+                const field_align = field_ty.abiAlignment(zcu);
                 break :a tuple_align.min(field_align);
             },
         },
     });
 
-    if (tuple_ty.structFieldIsComptime(field_index, zcu))
-        try tuple_ty.resolveStructFieldInits(pt);
-
     if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_val| {
         return Air.internedToRef((try pt.intern(.{ .ptr = .{
             .ty = ptr_field_ty.toIntern(),
@@ -27978,7 +27246,6 @@ fn tupleField(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const tuple_ty = sema.typeOf(tuple);
-    try tuple_ty.resolveFields(pt);
     const field_count = tuple_ty.structFieldCount(zcu);
 
     if (field_count == 0) {
@@ -27993,8 +27260,6 @@ fn tupleField(
 
     const field_ty = tuple_ty.fieldType(field_index, zcu);
 
-    if (tuple_ty.structFieldIsComptime(field_index, zcu))
-        try tuple_ty.resolveStructFieldInits(pt);
     if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_value| {
         return Air.internedToRef(default_value.toIntern()); // comptime field
     }
@@ -28006,7 +27271,6 @@ fn tupleField(
 
     try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_src);
 
-    try field_ty.resolveLayout(pt);
     return block.addStructFieldVal(tuple, field_index, field_ty);
 }
 
@@ -28037,7 +27301,7 @@ fn elemValArray(
     const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
 
     if (maybe_index_val) |index_val| {
-        const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
+        const index: usize = @intCast(index_val.toUnsignedInt(zcu));
         if (array_sent) |s| {
             if (index == array_len) {
                 return Air.internedToRef(s.toIntern());
@@ -28053,10 +27317,11 @@ fn elemValArray(
             return pt.undefRef(elem_ty);
         }
         if (maybe_index_val) |index_val| {
-            const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
-            const elem_val = try array_val.elemValue(pt, index);
-            return Air.internedToRef(elem_val.toIntern());
+            const index: usize = @intCast(index_val.toUnsignedInt(zcu));
+            return .fromValue(try array_val.elemValue(pt, index));
         }
+        // Since the array is comptime-known, it might be OPV, in which case the index is irrelevant.
+        if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
     }
 
     try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, array_ty, array_src);
@@ -28071,12 +27336,10 @@ fn elemValArray(
         }
     }
 
-    if (try sema.typeHasOnePossibleValue(elem_ty)) |elem_val|
-        return Air.internedToRef(elem_val.toIntern());
-
     return block.addBinOp(.array_elem_val, array, elem_index);
 }
 
+/// Asserts that the layout of the array or vector is already resolved.
 fn elemPtrArray(
     sema: *Sema,
     block: *Block,
@@ -28103,7 +27366,7 @@ fn elemPtrArray(
     const maybe_undef_array_ptr_val = try sema.resolveValue(array_ptr);
     // The index must not be undefined since it can be out of bounds.
     const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
-        const index = try sema.usizeCast(block, elem_index_src, try index_val.toUnsignedIntSema(pt));
+        const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(zcu));
         if (index >= array_len_s) {
             const sentinel_label: []const u8 = if (array_sent) " +1 (sentinel)" else "";
             return sema.fail(block, elem_index_src, "index {d} outside array of length {d}{s}", .{ index, array_len, sentinel_label });
@@ -28115,6 +27378,7 @@ fn elemPtrArray(
         return sema.fail(block, elem_index_src, "vector index not comptime known", .{});
     }
 
+    array_ty.assertHasLayout(zcu);
     const elem_ptr_ty = try array_ptr_ty.elemPtrType(offset, pt);
 
     if (maybe_undef_array_ptr_val) |array_ptr_val| {
@@ -28128,7 +27392,7 @@ fn elemPtrArray(
     }
 
     if (!init) {
-        try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.elemType2(zcu), array_ty, array_ptr_src);
+        try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.childType(zcu), array_ty, array_ptr_src);
         try sema.validateRuntimeValue(block, array_ptr_src, array_ptr);
     }
 
@@ -28142,6 +27406,7 @@ fn elemPtrArray(
     return block.addPtrElemPtr(array_ptr, elem_index, elem_ptr_ty);
 }
 
+/// Asserts that the layout of the slice element type is already resolved.
 fn elemValSlice(
     sema: *Sema,
     block: *Block,
@@ -28156,9 +27421,11 @@ fn elemValSlice(
     const zcu = pt.zcu;
     const slice_ty = sema.typeOf(slice);
     const slice_sent = slice_ty.sentinel(zcu) != null;
-    const elem_ty = slice_ty.elemType2(zcu);
+    const elem_ty = slice_ty.childType(zcu);
     var runtime_src = slice_src;
 
+    elem_ty.assertHasLayout(zcu);
+
     // slice must be defined since it can dereferenced as null
     const maybe_slice_val = try sema.resolveDefinedValue(block, slice_src, slice);
     // index must be defined since it can index out of bounds
@@ -28166,13 +27433,13 @@ fn elemValSlice(
 
     if (maybe_slice_val) |slice_val| {
         runtime_src = elem_index_src;
-        const slice_len = try slice_val.sliceLen(pt);
+        const slice_len = slice_val.sliceLen(zcu);
         const slice_len_s = slice_len + @intFromBool(slice_sent);
         if (slice_len_s == 0) {
             return sema.fail(block, slice_src, "indexing into empty slice is not allowed", .{});
         }
         if (maybe_index_val) |index_val| {
-            const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
+            const index: usize = @intCast(index_val.toUnsignedInt(zcu));
             if (index >= slice_len_s) {
                 const sentinel_label: []const u8 = if (slice_sent) " +1 (sentinel)" else "";
                 return sema.fail(block, elem_index_src, "index {d} outside slice of length {d}{s}", .{ index, slice_len, sentinel_label });
@@ -28186,16 +27453,14 @@ fn elemValSlice(
         }
     }
 
-    if (try sema.typeHasOnePossibleValue(elem_ty)) |elem_only_value| {
-        return Air.internedToRef(elem_only_value.toIntern());
-    }
+    if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
     try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, slice_ty, slice_src);
     try sema.validateRuntimeValue(block, slice_src, slice);
 
     if (oob_safety and block.wantSafety()) {
         const len_inst = if (maybe_slice_val) |slice_val|
-            try pt.intRef(.usize, try slice_val.sliceLen(pt))
+            try pt.intRef(.usize, slice_val.sliceLen(zcu))
         else
             try block.addTyOp(.slice_len, .usize, slice);
         const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
@@ -28204,6 +27469,7 @@ fn elemValSlice(
     return block.addBinOp(.slice_elem_val, slice, elem_index);
 }
 
+/// Asserts that the layout of the slice element type is already resolved.
 fn elemPtrSlice(
     sema: *Sema,
     block: *Block,
@@ -28219,11 +27485,12 @@ fn elemPtrSlice(
     const slice_ty = sema.typeOf(slice);
     const slice_sent = slice_ty.sentinel(zcu) != null;
 
+    slice_ty.childType(zcu).assertHasLayout(zcu);
+
     const maybe_undef_slice_val = try sema.resolveValue(slice);
     // The index must not be undefined since it can be out of bounds.
     const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
-        const index = try sema.usizeCast(block, elem_index_src, try index_val.toUnsignedIntSema(pt));
-        break :o index;
+        break :o try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(zcu));
     } else null;
 
     const elem_ptr_ty = try slice_ty.elemPtrType(offset, pt);
@@ -28232,7 +27499,7 @@ fn elemPtrSlice(
         if (slice_val.isUndef(zcu)) {
             return pt.undefRef(elem_ptr_ty);
         }
-        const slice_len = try slice_val.sliceLen(pt);
+        const slice_len = slice_val.sliceLen(zcu);
         const slice_len_s = slice_len + @intFromBool(slice_sent);
         if (slice_len_s == 0) {
             return sema.fail(block, slice_src, "indexing into empty slice is not allowed", .{});
@@ -28254,13 +27521,13 @@ fn elemPtrSlice(
         const len_inst = len: {
             if (maybe_undef_slice_val) |slice_val|
                 if (!slice_val.isUndef(zcu))
-                    break :len try pt.intRef(.usize, try slice_val.sliceLen(pt));
+                    break :len try pt.intRef(.usize, slice_val.sliceLen(zcu));
             break :len try block.addTyOp(.slice_len, .usize, slice);
         };
         const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
         try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
     }
-    if (!try slice_ty.childType(zcu).hasRuntimeBitsIgnoreComptimeSema(pt)) {
+    if (slice_ty.childType(zcu).abiSize(zcu) == 0) {
         // zero-bit child type; just extract the pointer and bitcast it
         const slice_ptr = try block.addTyOp(.slice_ptr, slice_ty.slicePtrFieldType(zcu), slice);
         return block.addBitCast(elem_ptr_ty, slice_ptr);
@@ -28331,10 +27598,12 @@ fn coerceExtra(
     if (dest_ty.isGenericPoison()) return inst;
 
     const dest_ty_src = inst_src; // TODO better source location
-    try dest_ty.resolveFields(pt);
     const inst_ty = sema.typeOf(inst);
-    try inst_ty.resolveFields(pt);
     const target = zcu.getTarget();
+
+    inst_ty.assertHasLayout(zcu);
+    try sema.ensureLayoutResolved(dest_ty);
+
     // If the types are the same, we can return the operand.
     if (dest_ty.eql(inst_ty, zcu))
         return inst;
@@ -28357,7 +27626,7 @@ fn coerceExtra(
             if (maybe_inst_val) |val| {
                 // undefined sets the optional bit also to undefined.
                 if (val.toIntern() == .undef) {
-                    return pt.undefRef(dest_ty);
+                    return .fromValue(try dest_ty.onePossibleValue(pt) orelse try pt.undefValue(dest_ty));
                 }
 
                 // null to ?T
@@ -28372,11 +27641,11 @@ fn coerceExtra(
             // cast from ?*T and ?[*]T to ?*anyopaque
             // but don't do it if the source type is a double pointer
             if (dest_ty.isPtrLikeOptional(zcu) and
-                dest_ty.elemType2(zcu).toIntern() == .anyopaque_type and
+                dest_ty.nullablePtrElem(zcu).toIntern() == .anyopaque_type and
                 inst_ty.isPtrAtRuntime(zcu))
             anyopaque_check: {
                 if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :optional;
-                const elem_ty = inst_ty.elemType2(zcu);
+                const elem_ty = inst_ty.nullablePtrElem(zcu);
                 if (elem_ty.zigTypeTag(zcu) == .pointer or elem_ty.isPtrLikeOptional(zcu)) {
                     in_memory_result = .{ .double_ptr_to_anyopaque = .{
                         .actual = inst_ty,
@@ -28520,7 +27789,7 @@ fn coerceExtra(
             // but don't do it if the source type is a double pointer
             if (dest_info.child == .anyopaque_type and inst_ty.zigTypeTag(zcu) == .pointer) to_anyopaque: {
                 if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :pointer;
-                const elem_ty = inst_ty.elemType2(zcu);
+                const elem_ty = inst_ty.childType(zcu);
                 if (elem_ty.zigTypeTag(zcu) == .pointer or elem_ty.isPtrLikeOptional(zcu)) {
                     in_memory_result = .{ .double_ptr_to_anyopaque = .{
                         .actual = inst_ty,
@@ -28616,7 +27885,9 @@ fn coerceExtra(
                     // empty tuple to zero-length slice
                     // note that this allows coercing to a mutable slice.
                     if (inst_child_ty.structFieldCount(zcu) == 0) {
-                        const align_val = try dest_ty.ptrAlignmentSema(pt);
+                        // TODO MLUGG: this is *unacceptably* stupid. we're resolving the child for the alignment value
+                        try sema.ensureLayoutResolved(dest_ty.childType(zcu));
+                        const align_val = dest_ty.ptrAlignment(zcu);
                         return Air.internedToRef(try pt.intern(.{ .slice = .{
                             .ty = dest_ty.toIntern(),
                             .ptr = try pt.intern(.{ .ptr = .{
@@ -28689,7 +27960,7 @@ fn coerceExtra(
                         return sema.fail(block, inst_src, "type '{f}' cannot represent integer value '{f}'", .{ dest_ty.fmt(pt), val.fmtValueSema(pt, sema) });
                     }
                     return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-                        .undef => try pt.undefRef(dest_ty),
+                        .undef => .fromValue(try dest_ty.onePossibleValue(pt) orelse try pt.undefValue(dest_ty)),
                         .int => |int| Air.internedToRef(
                             try zcu.intern_pool.getCoercedInts(gpa, io, pt.tid, int, dest_ty.toIntern()),
                         ),
@@ -28768,7 +28039,7 @@ fn coerceExtra(
                     }
                     break :int;
                 };
-                const result_val = try val.floatFromIntAdvanced(sema.arena, inst_ty, dest_ty, pt, .sema);
+                const result_val = try pt.floatValue(dest_ty, val.toFloat(f128, zcu));
                 const fits: bool = switch (ip.indexToKey(result_val.toIntern())) {
                     else => unreachable,
                     .undef => true,
@@ -28905,11 +28176,11 @@ fn coerceExtra(
         else => true,
     };
 
-    if (can_coerce_to) {
+    if (can_coerce_to and inst == .undef) {
         // undefined to anything. We do this after the big switch above so that
         // special logic has a chance to run first, such as `*[N]T` to `[]T` which
         // should initialize the length field of the slice.
-        if (maybe_inst_val) |val| if (val.toIntern() == .undef) return pt.undefRef(dest_ty);
+        return .fromValue(try dest_ty.onePossibleValue(pt) orelse try pt.undefValue(dest_ty));
     }
 
     if (!opts.report_err) return error.NotCoercible;
@@ -29444,17 +28715,13 @@ pub fn coerceInMemoryAllowed(
     }
 
     // Pointers / Pointer-like Optionals
-    const maybe_dest_ptr_ty = try sema.typePtrOrOptionalPtrTy(dest_ty);
-    const maybe_src_ptr_ty = try sema.typePtrOrOptionalPtrTy(src_ty);
-    if (maybe_dest_ptr_ty) |dest_ptr_ty| {
-        if (maybe_src_ptr_ty) |src_ptr_ty| {
-            return try sema.coerceInMemoryAllowedPtrs(block, dest_ty, src_ty, dest_ptr_ty, src_ptr_ty, dest_is_mut, target, dest_src, src_src);
-        }
+    if (dest_ty.isPtrAtRuntime(zcu) and src_ty.isPtrAtRuntime(zcu)) {
+        return try sema.coerceInMemoryAllowedPtrs(block, dest_ty, src_ty, dest_is_mut, target, dest_src, src_src);
     }
 
     // Slices
     if (dest_ty.isSlice(zcu) and src_ty.isSlice(zcu)) {
-        return try sema.coerceInMemoryAllowedPtrs(block, dest_ty, src_ty, dest_ty, src_ty, dest_is_mut, target, dest_src, src_src);
+        return try sema.coerceInMemoryAllowedPtrs(block, dest_ty, src_ty, dest_is_mut, target, dest_src, src_src);
     }
 
     // Functions
@@ -29554,7 +28821,8 @@ pub fn coerceInMemoryAllowed(
 
     // Optionals
     if (dest_tag == .optional and src_tag == .optional) {
-        if ((maybe_dest_ptr_ty != null) != (maybe_src_ptr_ty != null)) {
+        if (dest_ty.isPtrAtRuntime(zcu) or src_ty.isPtrAtRuntime(zcu)) {
+            // Only one is, because we already handled when both are.
             return .{ .optional_shape = .{
                 .actual = src_ty,
                 .wanted = dest_ty,
@@ -29581,7 +28849,7 @@ pub fn coerceInMemoryAllowed(
         const field_count = dest_ty.structFieldCount(zcu);
         for (0..field_count) |field_idx| {
             if (dest_ty.structFieldIsComptime(field_idx, zcu) != src_ty.structFieldIsComptime(field_idx, zcu)) break :tuple;
-            if (dest_ty.fieldAlignment(field_idx, zcu) != src_ty.fieldAlignment(field_idx, zcu)) break :tuple;
+            if (dest_ty.resolvedFieldAlignment(field_idx, zcu) != src_ty.resolvedFieldAlignment(field_idx, zcu)) break :tuple;
             const dest_field_ty = dest_ty.fieldType(field_idx, zcu);
             const src_field_ty = src_ty.fieldType(field_idx, zcu);
             const field = try sema.coerceInMemoryAllowed(block, dest_field_ty, src_field_ty, dest_is_mut, target, dest_src, src_src, null);
@@ -29714,11 +28982,7 @@ fn coerceInMemoryAllowedFns(
 
     {
         if (dest_info.is_var_args != src_info.is_var_args) {
-            return InMemoryCoercionResult{ .fn_var_args = dest_info.is_var_args };
-        }
-
-        if (dest_info.is_generic != src_info.is_generic) {
-            return InMemoryCoercionResult{ .fn_generic = dest_info.is_generic };
+            return .{ .fn_var_args = dest_info.is_var_args };
         }
 
         const callconv_ok = callconvCoerceAllowed(target, src_info.cc, dest_info.cc) and
@@ -29731,6 +28995,12 @@ fn coerceInMemoryAllowedFns(
             } };
         }
 
+        try sema.ensureLayoutResolved(src_ty);
+        try sema.ensureLayoutResolved(dest_ty);
+        const src_is_runtime = src_ty.fnHasRuntimeBits(zcu);
+        const dest_is_runtime = dest_ty.fnHasRuntimeBits(zcu);
+        if (src_is_runtime != dest_is_runtime) return .{ .fn_generic = !dest_is_runtime };
+
         if (!switch (src_info.return_type) {
             .generic_poison_type => true,
             .noreturn_type => !dest_is_mut,
@@ -29780,7 +29050,8 @@ fn coerceInMemoryAllowedFns(
             const src_is_comptime = src_info.paramIsComptime(@intCast(param_i));
             const dest_is_comptime = dest_info.paramIsComptime(@intCast(param_i));
             if (src_is_comptime == dest_is_comptime) break :comptime_param;
-            if (!dest_is_mut and src_is_comptime and !dest_is_comptime and try dest_param_ty.comptimeOnlySema(pt)) {
+            try sema.ensureLayoutResolved(dest_param_ty);
+            if (!dest_is_mut and src_is_comptime and !dest_is_comptime and dest_param_ty.comptimeOnly(zcu)) {
                 // A parameter which is marked `comptime` can drop that annotation if the type is comptime-only.
                 // The function remains generic, and the parameter is going to be comptime-resolved either way,
                 // so this just affects whether or not the argument is comptime-evaluated at the call site.
@@ -29861,8 +29132,6 @@ fn coerceInMemoryAllowedPtrs(
     block: *Block,
     dest_ty: Type,
     src_ty: Type,
-    dest_ptr_ty: Type,
-    src_ptr_ty: Type,
     /// If set, the coercion must be valid in both directions.
     dest_is_mut: bool,
     target: *const std.Target,
@@ -29875,8 +29144,8 @@ fn coerceInMemoryAllowedPtrs(
     const gpa = comp.gpa;
     const io = comp.io;
 
-    const dest_info = dest_ptr_ty.ptrInfo(zcu);
-    const src_info = src_ptr_ty.ptrInfo(zcu);
+    const dest_info = dest_ty.ptrInfo(zcu);
+    const src_info = src_ty.ptrInfo(zcu);
 
     const ok_ptr_size = src_info.flags.size == dest_info.flags.size or
         src_info.flags.size == .c or dest_info.flags.size == .c;
@@ -30008,16 +29277,14 @@ fn coerceInMemoryAllowedPtrs(
     if (src_info.flags.alignment != .none or dest_info.flags.alignment != .none or
         dest_info.child != src_info.child)
     {
-        const src_align = if (src_info.flags.alignment != .none)
-            src_info.flags.alignment
-        else
-            try Type.fromInterned(src_info.child).abiAlignmentSema(pt);
-
-        const dest_align = if (dest_info.flags.alignment != .none)
-            dest_info.flags.alignment
-        else
-            try Type.fromInterned(dest_info.child).abiAlignmentSema(pt);
-
+        const src_align = if (src_info.flags.alignment == .none) a: {
+            try sema.ensureLayoutResolved(src_child);
+            break :a src_child.abiAlignment(zcu);
+        } else src_info.flags.alignment;
+        const dest_align = if (dest_info.flags.alignment == .none) a: {
+            try sema.ensureLayoutResolved(dest_child);
+            break :a dest_child.abiAlignment(zcu);
+        } else dest_info.flags.alignment;
         if (dest_align.compare(if (dest_is_mut) .neq else .gt, src_align)) {
             return InMemoryCoercionResult{ .ptr_alignment = .{
                 .actual = src_align,
@@ -30180,9 +29447,16 @@ fn storePtr2(
         return sema.storePtrVal(block, src, ptr_val, operand_val, elem_ty);
     };
 
+    // We do this after the possible comptime store above, for the case of field_ptr stores
+    // to unions because we want the comptime tag to be set, even if the field type is void.
+    // MLUGG TODO: that's insane, the runtime and comptime sematics should be the same. just set the tag at the same damn time
+    if (try elem_ty.onePossibleValue(pt) != null) {
+        return;
+    }
+
     // We're performing the store at runtime; as such, we need to make sure the pointee type
     // is not comptime-only. We can hit this case with a `@ptrFromInt` pointer.
-    if (try elem_ty.comptimeOnlySema(pt)) {
+    if (elem_ty.comptimeOnly(zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "cannot store comptime-only type '{f}' at runtime", .{elem_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
@@ -30191,12 +29465,6 @@ fn storePtr2(
         });
     }
 
-    // We do this after the possible comptime store above, for the case of field_ptr stores
-    // to unions because we want the comptime tag to be set, even if the field type is void.
-    if ((try sema.typeHasOnePossibleValue(elem_ty)) != null) {
-        return;
-    }
-
     try sema.requireRuntimeBlock(block, src, runtime_src);
 
     const store_inst = if (is_ret)
@@ -30361,10 +29629,10 @@ fn bitCast(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    try dest_ty.resolveLayout(pt);
-
     const old_ty = sema.typeOf(inst);
-    try old_ty.resolveLayout(pt);
+
+    old_ty.assertHasLayout(zcu);
+    try sema.ensureLayoutResolved(dest_ty);
 
     const dest_bits = dest_ty.bitSize(zcu);
     const old_bits = old_ty.bitSize(zcu);
@@ -30510,9 +29778,7 @@ fn coerceCompatiblePtrs(
     }
     try sema.requireRuntimeBlock(block, inst_src, null);
     const inst_allows_zero = inst_ty.zigTypeTag(zcu) != .pointer or inst_ty.ptrAllowsZero(zcu);
-    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero(zcu) and
-        (try dest_ty.elemType2(zcu).hasRuntimeBitsSema(pt) or dest_ty.elemType2(zcu).zigTypeTag(zcu) == .@"fn"))
-    {
+    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero(zcu)) {
         try sema.checkLogicalPtrOperation(block, inst_src, inst_ty);
         const actual_ptr = if (inst_ty.isSlice(zcu))
             try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty)
@@ -30532,6 +29798,7 @@ fn coerceCompatiblePtrs(
     return new_ptr;
 }
 
+/// Asserts that the layout of `union_ty` is already resolved.
 fn coerceEnumToUnion(
     sema: *Sema,
     block: *Block,
@@ -30545,18 +29812,21 @@ fn coerceEnumToUnion(
     const ip = &zcu.intern_pool;
     const inst_ty = sema.typeOf(inst);
 
-    const tag_ty = union_ty.unionTagType(zcu) orelse {
-        const msg = msg: {
-            const msg = try sema.typeMismatchErrMsg(inst_src, union_ty, inst_ty);
-            errdefer msg.destroy(sema.gpa);
-            try sema.errNote(union_ty_src, msg, "cannot coerce enum to untagged union", .{});
-            try sema.addDeclaredHereNote(msg, union_ty);
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(block, msg);
-    };
+    union_ty.assertHasLayout(zcu);
 
-    const enum_tag = try sema.coerce(block, tag_ty, inst, inst_src);
+    const union_obj = zcu.typeToUnion(union_ty).?;
+    const enum_ty: Type = .fromInterned(union_obj.enum_tag_type);
+    const enum_obj = ip.loadEnumType(enum_ty.toIntern());
+
+    if (union_obj.runtime_tag != .tagged) return sema.failWithOwnedErrorMsg(block, msg: {
+        const msg = try sema.typeMismatchErrMsg(inst_src, union_ty, inst_ty);
+        errdefer msg.destroy(sema.gpa);
+        try sema.errNote(union_ty_src, msg, "cannot coerce enum to untagged union", .{});
+        try sema.addDeclaredHereNote(msg, union_ty);
+        break :msg msg;
+    });
+
+    const enum_tag = try sema.coerce(block, enum_ty, inst, inst_src);
     if (try sema.resolveDefinedValue(block, inst_src, enum_tag)) |val| {
         const field_index = union_ty.unionTagFieldIndex(val, pt.zcu) orelse {
             return sema.fail(block, inst_src, "union '{f}' has no tag with value '{f}'", .{
@@ -30564,15 +29834,12 @@ fn coerceEnumToUnion(
             });
         };
 
-        const union_obj = zcu.typeToUnion(union_ty).?;
+        const field_name = enum_obj.field_names.get(ip)[field_index];
         const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-        try field_ty.resolveFields(pt);
         if (field_ty.zigTypeTag(zcu) == .noreturn) {
             const msg = msg: {
                 const msg = try sema.errMsg(inst_src, "cannot initialize 'noreturn' field of union", .{});
                 errdefer msg.destroy(sema.gpa);
-
-                const field_name = union_obj.loadTagType(ip).names.get(ip)[field_index];
                 try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{
                     field_name.fmt(ip),
                 });
@@ -30581,42 +29848,35 @@ fn coerceEnumToUnion(
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         }
-        const opv = (try sema.typeHasOnePossibleValue(field_ty)) orelse {
-            const msg = msg: {
-                const field_name = union_obj.loadTagType(ip).names.get(ip)[field_index];
-                const msg = try sema.errMsg(inst_src, "coercion from enum '{f}' to union '{f}' must initialize '{f}' field '{f}'", .{
-                    inst_ty.fmt(pt),  union_ty.fmt(pt),
-                    field_ty.fmt(pt), field_name.fmt(ip),
-                });
-                errdefer msg.destroy(sema.gpa);
+        const opv = try field_ty.onePossibleValue(pt) orelse return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(inst_src, "coercion from enum '{f}' to union '{f}' must initialize '{f}' field '{f}'", .{
+                inst_ty.fmt(pt),  union_ty.fmt(pt),
+                field_ty.fmt(pt), field_name.fmt(ip),
+            });
+            errdefer msg.destroy(sema.gpa);
 
-                try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{
-                    field_name.fmt(ip),
-                });
-                try sema.addDeclaredHereNote(msg, union_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(block, msg);
-        };
+            try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{field_name.fmt(ip)});
+            try sema.addDeclaredHereNote(msg, union_ty);
+            break :msg msg;
+        });
 
         return Air.internedToRef((try pt.unionValue(union_ty, val, opv)).toIntern());
     }
 
     try sema.requireRuntimeBlock(block, inst_src, null);
 
-    if (tag_ty.isNonexhaustiveEnum(zcu)) {
+    if (enum_ty.isNonexhaustiveEnum(zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(inst_src, "runtime coercion to union '{f}' from non-exhaustive enum", .{
                 union_ty.fmt(pt),
             });
             errdefer msg.destroy(sema.gpa);
-            try sema.addDeclaredHereNote(msg, tag_ty);
+            try sema.addDeclaredHereNote(msg, enum_ty);
             break :msg msg;
         };
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
-    const union_obj = zcu.typeToUnion(union_ty).?;
     {
         var msg: ?*Zcu.ErrorMsg = null;
         errdefer if (msg) |some| some.destroy(sema.gpa);
@@ -30626,7 +29886,7 @@ fn coerceEnumToUnion(
                 const err_msg = msg orelse try sema.errMsg(
                     inst_src,
                     "runtime coercion from enum '{f}' to union '{f}' which has a 'noreturn' field",
-                    .{ tag_ty.fmt(pt), union_ty.fmt(pt) },
+                    .{ enum_ty.fmt(pt), union_ty.fmt(pt) },
                 );
                 msg = err_msg;
 
@@ -30649,14 +29909,14 @@ fn coerceEnumToUnion(
         const msg = try sema.errMsg(
             inst_src,
             "runtime coercion from enum '{f}' to union '{f}' which has non-void fields",
-            .{ tag_ty.fmt(pt), union_ty.fmt(pt) },
+            .{ enum_ty.fmt(pt), union_ty.fmt(pt) },
         );
         errdefer msg.destroy(sema.gpa);
 
         for (0..union_obj.field_types.len) |field_index| {
-            const field_name = union_obj.loadTagType(ip).names.get(ip)[field_index];
+            const field_name = enum_obj.field_names.get(ip)[field_index];
             const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-            if (!(try field_ty.hasRuntimeBitsSema(pt))) continue;
+            if (try field_ty.onePossibleValue(pt) != null) continue;
             try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' has type '{f}'", .{
                 field_name.fmt(ip),
                 field_ty.fmt(pt),
@@ -30904,19 +30164,16 @@ fn coerceTupleToTuple(
         const field_i: u32 = @intCast(field_index_usize);
         const field_src = inst_src; // TODO better source location
 
-        const field_ty = switch (ip.indexToKey(tuple_ty.toIntern())) {
-            .tuple_type => |tuple_type| tuple_type.types.get(ip)[field_index_usize],
-            .struct_type => ip.loadStructType(tuple_ty.toIntern()).field_types.get(ip)[field_index_usize],
-            else => unreachable,
-        };
-        const default_val = switch (ip.indexToKey(tuple_ty.toIntern())) {
-            .tuple_type => |tuple_type| tuple_type.values.get(ip)[field_index_usize],
-            .struct_type => ip.loadStructType(tuple_ty.toIntern()).fieldInit(ip, field_index_usize),
-            else => unreachable,
-        };
-
         const field_index: u32 = @intCast(field_index_usize);
 
+        const field_ty, const default_val = field: {
+            const tuple_type = ip.indexToKey(tuple_ty.toIntern()).tuple_type;
+            break :field .{
+                tuple_type.types.get(ip)[field_index],
+                tuple_type.values.get(ip)[field_index],
+            };
+        };
+
         const elem_ref = try sema.tupleField(block, inst_src, inst, field_src, field_i);
         const coerced = try sema.coerce(block, .fromInterned(field_ty), elem_ref, field_src);
         field_refs[field_index] = coerced;
@@ -30946,11 +30203,7 @@ fn coerceTupleToTuple(
         const i: u32 = @intCast(i_usize);
         if (field_ref.* != .none) continue;
 
-        const default_val = switch (ip.indexToKey(tuple_ty.toIntern())) {
-            .tuple_type => |tuple_type| tuple_type.values.get(ip)[i],
-            .struct_type => ip.loadStructType(tuple_ty.toIntern()).fieldInit(ip, i),
-            else => unreachable,
-        };
+        const default_val = ip.indexToKey(tuple_ty.toIntern()).tuple_type.values.get(ip)[i];
 
         const field_src = inst_src; // TODO better source location
         if (default_val == .none) {
@@ -31019,13 +30272,13 @@ fn addReferenceEntry(
 pub fn addTypeReferenceEntry(
     sema: *Sema,
     src: LazySrcLoc,
-    referenced_type: InternPool.Index,
+    referenced_type: Type,
 ) !void {
     const zcu = sema.pt.zcu;
     if (!zcu.comp.config.incremental and zcu.comp.reference_trace == 0) return;
-    const gop = try sema.type_references.getOrPut(sema.gpa, referenced_type);
+    const gop = try sema.type_references.getOrPut(sema.gpa, referenced_type.toIntern());
     if (gop.found_existing) return;
-    try zcu.addTypeReference(sema.owner, referenced_type, src);
+    try zcu.addTypeReference(sema.owner, referenced_type.toIntern(), src);
 }
 
 fn ensureMemoizedStateResolved(sema: *Sema, src: LazySrcLoc, stage: InternPool.MemoizedStateStage) SemaError!void {
@@ -31143,7 +30396,7 @@ fn analyzeNavRefInner(sema: *Sema, block: *Block, src: LazySrcLoc, orig_nav_inde
         .type_resolved => |r| .{ r.type, r.alignment, r.@"addrspace", r.is_const },
         .fully_resolved => |r| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", r.is_const },
     };
-    const ptr_ty = try pt.ptrTypeSema(.{
+    const ptr_ty = try pt.ptrType(.{
         .child = ty,
         .flags = .{
             .alignment = alignment,
@@ -31185,7 +30438,7 @@ fn maybeQueueFuncBodyAnalysis(sema: *Sema, block: *Block, src: LazySrcLoc, nav_i
     try sema.ensureNavResolved(block, src, nav_index, .type);
     const nav_ty: Type = .fromInterned(ip.getNav(nav_index).typeOf(ip));
     if (nav_ty.zigTypeTag(zcu) != .@"fn") return;
-    if (!try nav_ty.fnHasRuntimeBitsSema(pt)) return;
+    if (!nav_ty.fnHasRuntimeBits(zcu)) return;
 
     try sema.ensureNavResolved(block, src, nav_index, .fully);
     const nav_val = zcu.navValue(nav_index);
@@ -31218,14 +30471,14 @@ fn analyzeRef(
     // it's just that we can only use the *type* of the result, since the value is runtime-known.
 
     const address_space = target_util.defaultAddressSpace(zcu.getTarget(), .local);
-    const ptr_type = try pt.ptrTypeSema(.{
+    const ptr_type = try pt.ptrType(.{
         .child = operand_ty.toIntern(),
         .flags = .{
             .is_const = true,
             .address_space = address_space,
         },
     });
-    const mut_ptr_type = try pt.ptrTypeSema(.{
+    const mut_ptr_type = try pt.ptrType(.{
         .child = operand_ty.toIntern(),
         .flags = .{ .address_space = address_space },
     });
@@ -31261,9 +30514,8 @@ fn analyzeLoad(
         return sema.fail(block, ptr_src, "cannot load opaque type '{f}'", .{elem_ty.fmt(pt)});
     }
 
-    if (try sema.typeHasOnePossibleValue(elem_ty)) |opv| {
-        return Air.internedToRef(opv.toIntern());
-    }
+    try sema.ensureLayoutResolved(elem_ty);
+    if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
     if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
         if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |elem_val| {
@@ -31271,6 +30523,13 @@ fn analyzeLoad(
         }
     }
 
+    if (elem_ty.comptimeOnly(zcu)) return sema.failWithOwnedErrorMsg(block, msg: {
+        const msg = try sema.errMsg(src, "cannot load comptime-only type '{f}'", .{elem_ty.fmt(pt)});
+        errdefer msg.destroy(zcu.gpa);
+        try sema.errNote(ptr_src, msg, "pointer of type '{f}' is runtime-known", .{ptr_ty.fmt(pt)});
+        break :msg msg;
+    });
+
     return block.addTyOp(.load, elem_ty, ptr);
 }
 
@@ -31332,7 +30591,7 @@ fn analyzeSliceLen(
         if (slice_val.isUndef(zcu)) {
             return .undef_usize;
         }
-        return pt.intRef(.usize, try slice_val.sliceLen(pt));
+        return pt.intRef(.usize, slice_val.sliceLen(zcu));
     }
     try sema.requireRuntimeBlock(block, src, null);
     return block.addTyOp(.slice_len, .usize, slice_inst);
@@ -31682,6 +30941,8 @@ fn analyzeSlice(
         else => return sema.fail(block, src, "slice of non-array type '{f}'", .{ptr_ptr_child_ty.fmt(pt)}),
     }
 
+    try sema.ensureLayoutResolved(elem_ty);
+
     const ptr = if (slice_ty.isSlice(zcu))
         try sema.analyzeSlicePtr(block, ptr_src, ptr_or_slice, slice_ty)
     else if (array_ty.zigTypeTag(zcu) == .array) ptr: {
@@ -31690,7 +30951,7 @@ fn analyzeSlice(
         assert(manyptr_ty_key.flags.size == .one);
         manyptr_ty_key.child = elem_ty.toIntern();
         manyptr_ty_key.flags.size = .many;
-        break :ptr try sema.coerceCompatiblePtrs(block, try pt.ptrTypeSema(manyptr_ty_key), ptr_or_slice, ptr_src);
+        break :ptr try sema.coerceCompatiblePtrs(block, try pt.ptrType(manyptr_ty_key), ptr_or_slice, ptr_src);
     } else ptr_or_slice;
 
     const start = try sema.coerce(block, .usize, uncasted_start, start_src);
@@ -31759,7 +31020,7 @@ fn analyzeSlice(
                             return sema.fail(block, src, "slice of undefined", .{});
                         }
                         const has_sentinel = slice_ty.sentinel(zcu) != null;
-                        const slice_len = try slice_val.sliceLen(pt);
+                        const slice_len = slice_val.sliceLen(zcu);
                         const len_plus_sent = slice_len + @intFromBool(has_sentinel);
                         const slice_len_val_with_sentinel = try pt.intValue(.usize, len_plus_sent);
                         if (!(try sema.compareAll(end_val, .lte, slice_len_val_with_sentinel, .usize))) {
@@ -31774,7 +31035,7 @@ fn analyzeSlice(
                                 "end index {f} out of bounds for slice of length {d}{s}",
                                 .{
                                     end_val.fmtValueSema(pt, sema),
-                                    try slice_val.sliceLen(pt),
+                                    slice_val.sliceLen(zcu),
                                     sentinel_label,
                                 },
                             );
@@ -31943,9 +31204,9 @@ fn analyzeSlice(
     const new_allowzero = new_ptr_ty_info.flags.is_allowzero and sema.typeOf(ptr).ptrSize(zcu) != .c;
 
     if (opt_new_len_val) |new_len_val| {
-        const new_len_int = try new_len_val.toUnsignedIntSema(pt);
+        const new_len_int = new_len_val.toUnsignedInt(zcu);
 
-        const return_ty = try pt.ptrTypeSema(.{
+        const return_ty = try pt.ptrType(.{
             .child = (try pt.arrayType(.{
                 .len = new_len_int,
                 .sentinel = if (sentinel) |s| s.toIntern() else .none,
@@ -32009,7 +31270,7 @@ fn analyzeSlice(
         return sema.fail(block, src, "non-zero length slice of undefined pointer", .{});
     }
 
-    const return_ty = try pt.ptrTypeSema(.{
+    const return_ty = try pt.ptrType(.{
         .child = elem_ty.toIntern(),
         .sentinel = if (sentinel) |s| s.toIntern() else .none,
         .flags = .{
@@ -32037,7 +31298,7 @@ fn analyzeSlice(
             if (try sema.resolveDefinedValue(block, src, ptr_or_slice)) |slice_val| {
                 // we don't need to add one for sentinels because the
                 // underlying value data includes the sentinel
-                break :blk try pt.intRef(.usize, try slice_val.sliceLen(pt));
+                break :blk try pt.intRef(.usize, slice_val.sliceLen(zcu));
             }
 
             const slice_len_inst = try block.addTyOp(.slice_len, .usize, ptr_or_slice);
@@ -32158,16 +31419,10 @@ fn cmpNumeric(
 
     const runtime_src: LazySrcLoc = if (maybe_lhs_val) |lhs_val| rs: {
         if (maybe_rhs_val) |rhs_val| {
-            const res = try Value.compareHeteroSema(lhs_val, op, rhs_val, pt);
-            return if (res) .bool_true else .bool_false;
+            return .fromValue(.makeBool(Value.compareHetero(lhs_val, op, rhs_val, zcu)));
         } else break :rs rhs_src;
     } else lhs_src;
 
-    // TODO handle comparisons against lazy zero values
-    // Some values can be compared against zero without being runtime-known or without forcing
-    // a full resolution of their value, for example `@sizeOf(@Frame(function))` is known to
-    // always be nonzero, and we benefit from not forcing the full evaluation and stack frame layout
-    // of this function if we don't need to.
     try sema.requireRuntimeBlock(block, src, runtime_src);
 
     // For floats, emit a float comparison instruction.
@@ -32207,11 +31462,11 @@ fn cmpNumeric(
     // a signed integer with mantissa bits + 1, and if there was any non-integral part of the float,
     // add/subtract 1.
     const lhs_is_signed = if (maybe_lhs_val) |lhs_val|
-        !(try lhs_val.compareAllWithZeroSema(.gte, pt))
+        !lhs_val.compareAllWithZero(.gte, zcu)
     else
         (lhs_ty.isRuntimeFloat() or lhs_ty.isSignedInt(zcu));
     const rhs_is_signed = if (maybe_rhs_val) |rhs_val|
-        !(try rhs_val.compareAllWithZeroSema(.gte, pt))
+        !rhs_val.compareAllWithZero(.gte, zcu)
     else
         (rhs_ty.isRuntimeFloat() or rhs_ty.isSignedInt(zcu));
     const dest_int_is_signed = lhs_is_signed or rhs_is_signed;
@@ -32219,10 +31474,9 @@ fn cmpNumeric(
     var dest_float_type: ?Type = null;
 
     var lhs_bits: usize = undefined;
-    if (maybe_lhs_val) |unresolved_lhs_val| {
-        const lhs_val = try sema.resolveLazyValue(unresolved_lhs_val);
+    if (maybe_lhs_val) |lhs_val| {
         if (!rhs_is_signed) {
-            switch (lhs_val.orderAgainstZero(zcu)) {
+            switch (Value.order(lhs_val, .zero_comptime_int, zcu)) {
                 .gt => {},
                 .eq => switch (op) { // LHS = 0, RHS is unsigned
                     .lte => return .bool_true,
@@ -32263,10 +31517,9 @@ fn cmpNumeric(
     }
 
     var rhs_bits: usize = undefined;
-    if (maybe_rhs_val) |unresolved_rhs_val| {
-        const rhs_val = try sema.resolveLazyValue(unresolved_rhs_val);
+    if (maybe_rhs_val) |rhs_val| {
         if (!lhs_is_signed) {
-            switch (rhs_val.orderAgainstZero(zcu)) {
+            switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
                 .gt => {},
                 .eq => switch (op) { // RHS = 0, LHS is unsigned
                     .gte => return .bool_true,
@@ -32328,7 +31581,7 @@ fn compareIntsOnlyPossibleResult(
     lhs_val: Value,
     op: std.math.CompareOperator,
     rhs_ty: Type,
-) SemaError!?bool {
+) Allocator.Error!?bool {
     const pt = sema.pt;
     const zcu = pt.zcu;
 
@@ -32337,11 +31590,11 @@ fn compareIntsOnlyPossibleResult(
 
     if (min_rhs.toIntern() == max_rhs.toIntern()) {
         // RHS is effectively comptime-known.
-        return try Value.compareHeteroSema(lhs_val, op, min_rhs, pt);
+        return Value.compareHetero(lhs_val, op, min_rhs, zcu);
     }
 
-    const against_min = try lhs_val.orderAdvanced(min_rhs, .sema, zcu, pt.tid);
-    const against_max = try lhs_val.orderAdvanced(max_rhs, .sema, zcu, pt.tid);
+    const against_min = lhs_val.order(min_rhs, zcu);
+    const against_max = lhs_val.order(max_rhs, zcu);
 
     switch (op) {
         .eq => {
@@ -32529,9 +31782,7 @@ fn unionToTag(
 ) !Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    if ((try sema.typeHasOnePossibleValue(enum_ty))) |opv| {
-        return Air.internedToRef(opv.toIntern());
-    }
+    if (try enum_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
     if (try sema.resolveValue(un)) |un_val| {
         const tag_val = un_val.unionTag(zcu).?;
         if (tag_val.isUndef(zcu))
@@ -33240,18 +32491,24 @@ fn resolvePeerTypesInner(
                     ptr_info.sentinel = .none;
                 }
 
-                // Note that the align can be always non-zero; Zcu.ptrType will canonicalize it
-                ptr_info.flags.alignment = InternPool.Alignment.min(
-                    if (ptr_info.flags.alignment != .none)
-                        ptr_info.flags.alignment
-                    else
-                        Type.fromInterned(ptr_info.child).abiAlignment(zcu),
-
-                    if (peer_info.flags.alignment != .none)
-                        peer_info.flags.alignment
-                    else
-                        Type.fromInterned(peer_info.child).abiAlignment(zcu),
-                );
+                ptr_info.flags.alignment = a: {
+                    // If both alignments are implicit, the result alignment is implicit.
+                    // e.g. '[*c]u32' + '[*c]c_uint' -> '[*c]u32'
+                    if (ptr_info.flags.alignment == .none and peer_info.flags.alignment == .none) {
+                        break :a .none;
+                    }
+                    // Otherwise (if either alignment is explicit), the result alignment is explicit.
+                    // e.g. '[*c]u32' + '[*c]align(4) c_uint' -> '[*c]align(4) u32'
+                    const cur_align = switch (ptr_info.flags.alignment) {
+                        .none => Type.fromInterned(ptr_info.child).abiAlignment(zcu),
+                        else => ptr_info.flags.alignment,
+                    };
+                    const new_align = switch (peer_info.flags.alignment) {
+                        .none => Type.fromInterned(peer_info.child).abiAlignment(zcu),
+                        else => peer_info.flags.alignment,
+                    };
+                    break :a .minStrict(cur_align, new_align);
+                };
                 if (ptr_info.flags.address_space != peer_info.flags.address_space) {
                     return .{ .conflict = .{
                         .peer_idx_a = first_idx,
@@ -33273,7 +32530,7 @@ fn resolvePeerTypesInner(
 
                 opt_ptr_info = ptr_info;
             }
-            return .{ .success = try pt.ptrTypeSema(opt_ptr_info.?) };
+            return .{ .success = try pt.ptrType(opt_ptr_info.?) };
         },
 
         .ptr => {
@@ -33281,7 +32538,6 @@ fn resolvePeerTypesInner(
             // if there were no actual slices. Else, we want the slice index to report a conflict.
             var opt_slice_idx: ?usize = null;
 
-            var any_abi_aligned = false;
             var opt_ptr_info: ?InternPool.Key.PtrType = null;
             var first_idx: usize = undefined;
             var other_idx: usize = undefined; // We sometimes need a second peer index to report a generic error
@@ -33325,15 +32581,24 @@ fn resolvePeerTypesInner(
                     .peer_idx_b = i,
                 } };
 
-                // Note that the align can be always non-zero; Type.ptr will canonicalize it
-                if (peer_info.flags.alignment == .none) {
-                    any_abi_aligned = true;
-                } else if (ptr_info.flags.alignment == .none) {
-                    any_abi_aligned = true;
-                    ptr_info.flags.alignment = peer_info.flags.alignment;
-                } else {
-                    ptr_info.flags.alignment = ptr_info.flags.alignment.minStrict(peer_info.flags.alignment);
-                }
+                ptr_info.flags.alignment = a: {
+                    // If both alignments are implicit, the result alignment is implicit.
+                    // e.g. '[*c]u32' + '[*c]c_uint' -> '[*c]u32'
+                    if (ptr_info.flags.alignment == .none and peer_info.flags.alignment == .none) {
+                        break :a .none;
+                    }
+                    // Otherwise (if either alignment is explicit), the result alignment is explicit.
+                    // e.g. '[*c]u32' + '[*c]align(4) c_uint' -> '[*c]align(4) u32'
+                    const cur_align = switch (ptr_info.flags.alignment) {
+                        .none => Type.fromInterned(ptr_info.child).abiAlignment(zcu),
+                        else => ptr_info.flags.alignment,
+                    };
+                    const new_align = switch (peer_info.flags.alignment) {
+                        .none => Type.fromInterned(peer_info.child).abiAlignment(zcu),
+                        else => peer_info.flags.alignment,
+                    };
+                    break :a .minStrict(cur_align, new_align);
+                };
 
                 if (ptr_info.flags.address_space != peer_info.flags.address_space) {
                     return generic_err;
@@ -33582,13 +32847,7 @@ fn resolvePeerTypesInner(
                 },
             }
 
-            if (any_abi_aligned and opt_ptr_info.?.flags.alignment != .none) {
-                opt_ptr_info.?.flags.alignment = opt_ptr_info.?.flags.alignment.minStrict(
-                    try Type.fromInterned(pointee).abiAlignmentSema(pt),
-                );
-            }
-
-            return .{ .success = try pt.ptrTypeSema(opt_ptr_info.?) };
+            return .{ .success = try pt.ptrType(opt_ptr_info.?) };
         },
 
         .func => {
@@ -33731,7 +32990,7 @@ fn resolvePeerTypesInner(
                             .peer_idx_b = i,
                         } };
                         any_comptime_known = true;
-                        ptr_opt_val.* = try sema.resolveLazyValue(opt_val.?);
+                        ptr_opt_val.* = opt_val.?;
                         continue;
                     },
                     .int => {},
@@ -33924,7 +33183,6 @@ fn resolvePeerTypesInner(
                 var comptime_val: ?Value = null;
                 for (peer_tys) |opt_ty| {
                     const struct_ty = opt_ty orelse continue;
-                    try struct_ty.resolveStructFieldInits(pt);
 
                     const uncoerced_field_val = try struct_ty.structFieldValueComptime(pt, field_index) orelse {
                         comptime_val = null;
@@ -34058,344 +33316,6 @@ pub fn resolveIes(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError!void
     }
 }
 
-pub fn resolveFnTypes(sema: *Sema, fn_ty: Type, src: LazySrcLoc) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const fn_ty_info = zcu.typeToFunc(fn_ty).?;
-
-    try Type.fromInterned(fn_ty_info.return_type).resolveFully(pt);
-
-    if (zcu.comp.config.any_error_tracing and
-        Type.fromInterned(fn_ty_info.return_type).isError(zcu))
-    {
-        // Ensure the type exists so that backends can assume that.
-        _ = try sema.getBuiltinType(src, .StackTrace);
-    }
-
-    for (0..fn_ty_info.param_types.len) |i| {
-        try Type.fromInterned(fn_ty_info.param_types.get(ip)[i]).resolveFully(pt);
-    }
-}
-
-fn resolveLazyValue(sema: *Sema, val: Value) CompileError!Value {
-    return val.resolveLazy(sema.arena, sema.pt);
-}
-
-/// Resolve a struct's alignment only without triggering resolution of its layout.
-/// Asserts that the alignment is not yet resolved and the layout is non-packed.
-pub fn resolveStructAlignment(
-    sema: *Sema,
-    ty: InternPool.Index,
-    struct_type: InternPool.LoadedStructType,
-) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-    const target = zcu.getTarget();
-
-    assert(sema.owner.unwrap().type == ty);
-
-    assert(struct_type.layout != .@"packed");
-    assert(struct_type.flagsUnordered(ip).alignment == .none);
-
-    const ptr_align = Alignment.fromByteUnits(@divExact(target.ptrBitWidth(), 8));
-
-    // We'll guess "pointer-aligned", if the struct has an
-    // underaligned pointer field then some allocations
-    // might require explicit alignment.
-    if (struct_type.assumePointerAlignedIfFieldTypesWip(ip, io, ptr_align)) return;
-
-    try sema.resolveStructFieldTypes(ty, struct_type);
-
-    // We'll guess "pointer-aligned", if the struct has an
-    // underaligned pointer field then some allocations
-    // might require explicit alignment.
-    if (struct_type.assumePointerAlignedIfWip(ip, io, ptr_align)) return;
-    defer struct_type.clearAlignmentWip(ip, io);
-
-    // No `zcu.trackUnitSema` calls, since this phase isn't really doing any semantic analysis.
-    // It's just triggering *other* analysis, alongside a simple loop over already-resolved info.
-
-    var alignment: Alignment = .@"1";
-
-    for (0..struct_type.field_types.len) |i| {
-        const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-        if (struct_type.fieldIsComptime(ip, i) or try field_ty.comptimeOnlySema(pt))
-            continue;
-        const field_align = try field_ty.structFieldAlignmentSema(
-            struct_type.fieldAlign(ip, i),
-            struct_type.layout,
-            pt,
-        );
-        alignment = alignment.maxStrict(field_align);
-    }
-
-    struct_type.setAlignment(ip, io, alignment);
-}
-
-pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const io = zcu.comp.io;
-    const struct_type = zcu.typeToStruct(ty) orelse return;
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    if (struct_type.haveLayout(ip))
-        return;
-
-    try sema.resolveStructFieldTypes(ty.toIntern(), struct_type);
-
-    // No `zcu.trackUnitSema` calls, since this phase isn't really doing any semantic analysis.
-    // It's just triggering *other* analysis, alongside a simple loop over already-resolved info.
-
-    if (struct_type.layout == .@"packed") {
-        sema.backingIntType(struct_type) catch |err| switch (err) {
-            error.AnalysisFail, error.OutOfMemory, error.Canceled => |e| return e,
-            error.ComptimeBreak, error.ComptimeReturn => unreachable,
-        };
-        return;
-    }
-
-    if (struct_type.setLayoutWip(ip, io)) {
-        const msg = try sema.errMsg(
-            ty.srcLoc(zcu),
-            "struct '{f}' depends on itself",
-            .{ty.fmt(pt)},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-    defer struct_type.clearLayoutWip(ip, io);
-
-    const aligns = try sema.arena.alloc(Alignment, struct_type.field_types.len);
-    const sizes = try sema.arena.alloc(u64, struct_type.field_types.len);
-
-    var big_align: Alignment = .@"1";
-
-    for (aligns, sizes, 0..) |*field_align, *field_size, i| {
-        const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-        if (struct_type.fieldIsComptime(ip, i) or try field_ty.comptimeOnlySema(pt)) {
-            struct_type.offsets.get(ip)[i] = 0;
-            field_size.* = 0;
-            field_align.* = .none;
-            continue;
-        }
-
-        field_size.* = field_ty.abiSizeSema(pt) catch |err| switch (err) {
-            error.AnalysisFail => {
-                const msg = sema.err orelse return err;
-                try sema.addFieldErrNote(ty, i, msg, "while checking this field", .{});
-                return err;
-            },
-            else => return err,
-        };
-        field_align.* = try field_ty.structFieldAlignmentSema(
-            struct_type.fieldAlign(ip, i),
-            struct_type.layout,
-            pt,
-        );
-        big_align = big_align.maxStrict(field_align.*);
-    }
-
-    if (struct_type.flagsUnordered(ip).assumed_runtime_bits and !(try ty.hasRuntimeBitsSema(pt))) {
-        const msg = try sema.errMsg(
-            ty.srcLoc(zcu),
-            "struct layout depends on it having runtime bits",
-            .{},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-
-    if (struct_type.flagsUnordered(ip).assumed_pointer_aligned and
-        big_align.compareStrict(.neq, Alignment.fromByteUnits(@divExact(zcu.getTarget().ptrBitWidth(), 8))))
-    {
-        const msg = try sema.errMsg(
-            ty.srcLoc(zcu),
-            "struct layout depends on being pointer aligned",
-            .{},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-
-    if (struct_type.hasReorderedFields()) {
-        const runtime_order = struct_type.runtime_order.get(ip);
-
-        for (runtime_order, 0..) |*ro, i| {
-            const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-            if (struct_type.fieldIsComptime(ip, i) or try field_ty.comptimeOnlySema(pt)) {
-                ro.* = .omitted;
-            } else {
-                ro.* = @enumFromInt(i);
-            }
-        }
-
-        const RuntimeOrder = InternPool.LoadedStructType.RuntimeOrder;
-
-        const AlignSortContext = struct {
-            aligns: []const Alignment,
-
-            fn lessThan(ctx: @This(), a: RuntimeOrder, b: RuntimeOrder) bool {
-                if (a == .omitted) return false;
-                if (b == .omitted) return true;
-                const a_align = ctx.aligns[@intFromEnum(a)];
-                const b_align = ctx.aligns[@intFromEnum(b)];
-                return a_align.compare(.gt, b_align);
-            }
-        };
-        if (!zcu.backendSupportsFeature(.field_reordering)) {
-            // TODO: we should probably also reorder tuple fields? This is a bit weird because it'll involve
-            // mutating the `InternPool` for a non-container type.
-            //
-            // TODO: implement field reordering support in all the backends!
-            //
-            // This logic does not reorder fields; it only moves the omitted ones to the end
-            // so that logic elsewhere does not need to special-case here.
-            var i: usize = 0;
-            var off: usize = 0;
-            while (i + off < runtime_order.len) {
-                if (runtime_order[i + off] == .omitted) {
-                    off += 1;
-                    continue;
-                }
-                runtime_order[i] = runtime_order[i + off];
-                i += 1;
-            }
-            @memset(runtime_order[i..], .omitted);
-        } else {
-            mem.sortUnstable(RuntimeOrder, runtime_order, AlignSortContext{
-                .aligns = aligns,
-            }, AlignSortContext.lessThan);
-        }
-    }
-
-    // Calculate size, alignment, and field offsets.
-    const offsets = struct_type.offsets.get(ip);
-    var it = struct_type.iterateRuntimeOrder(ip);
-    var offset: u64 = 0;
-    while (it.next()) |i| {
-        offsets[i] = @intCast(aligns[i].forward(offset));
-        offset = offsets[i] + sizes[i];
-    }
-    const size = std.math.cast(u32, big_align.forward(offset)) orelse {
-        const msg = try sema.errMsg(
-            ty.srcLoc(zcu),
-            "struct layout requires size {d}, this compiler implementation supports up to {d}",
-            .{ big_align.forward(offset), std.math.maxInt(u32) },
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    };
-    struct_type.setLayoutResolved(ip, io, size, big_align);
-    _ = try ty.comptimeOnlySema(pt);
-}
-
-fn backingIntType(
-    sema: *Sema,
-    struct_type: InternPool.LoadedStructType,
-) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    var analysis_arena = std.heap.ArenaAllocator.init(gpa);
-    defer analysis_arena.deinit();
-
-    var block: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = struct_type.namespace,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = null, // set below if needed
-        .src_base_inst = struct_type.zir_index,
-        .type_name_ctx = struct_type.name,
-    };
-    defer assert(block.instructions.items.len == 0);
-
-    const fields_bit_sum = blk: {
-        var accumulator: u64 = 0;
-        for (0..struct_type.field_types.len) |i| {
-            const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-            accumulator += try field_ty.bitSizeSema(pt);
-        }
-        break :blk accumulator;
-    };
-
-    const zir = zcu.namespacePtr(struct_type.namespace).fileScope(zcu).zir.?;
-    const zir_index = struct_type.zir_index.resolve(ip) orelse return error.AnalysisFail;
-    const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
-    assert(extended.opcode == .struct_decl);
-    const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-
-    if (small.has_backing_int) {
-        var extra_index: usize = extended.operand + @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len;
-        const captures_len = if (small.has_captures_len) blk: {
-            const captures_len = zir.extra[extra_index];
-            extra_index += 1;
-            break :blk captures_len;
-        } else 0;
-        extra_index += @intFromBool(small.has_fields_len);
-        extra_index += @intFromBool(small.has_decls_len);
-
-        extra_index += captures_len * 2;
-
-        const backing_int_body_len = zir.extra[extra_index];
-        extra_index += 1;
-
-        const backing_int_src: LazySrcLoc = .{
-            .base_node_inst = struct_type.zir_index,
-            .offset = .{ .node_offset_container_tag = .zero },
-        };
-        block.comptime_reason = .{ .reason = .{
-            .src = backing_int_src,
-            .r = .{ .simple = .type },
-        } };
-        const backing_int_ty = blk: {
-            if (backing_int_body_len == 0) {
-                const backing_int_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-                break :blk try sema.resolveType(&block, backing_int_src, backing_int_ref);
-            } else {
-                const body = zir.bodySlice(extra_index, backing_int_body_len);
-                const ty_ref = try sema.resolveInlineBody(&block, body, zir_index);
-                break :blk try sema.analyzeAsType(&block, backing_int_src, ty_ref);
-            }
-        };
-
-        try sema.checkBackingIntType(&block, backing_int_src, backing_int_ty, fields_bit_sum);
-        struct_type.setBackingIntType(ip, io, backing_int_ty.toIntern());
-    } else {
-        if (fields_bit_sum > std.math.maxInt(u16)) {
-            return sema.fail(&block, block.nodeOffset(.zero), "size of packed struct '{d}' exceeds maximum bit width of 65535", .{fields_bit_sum});
-        }
-        const backing_int_ty = try pt.intType(.unsigned, @intCast(fields_bit_sum));
-        struct_type.setBackingIntType(ip, io, backing_int_ty.toIntern());
-    }
-
-    try sema.flushExports();
-}
-
-fn checkBackingIntType(sema: *Sema, block: *Block, src: LazySrcLoc, backing_int_ty: Type, fields_bit_sum: u64) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-
-    if (!backing_int_ty.isInt(zcu)) {
-        return sema.fail(block, src, "expected backing integer type, found '{f}'", .{backing_int_ty.fmt(pt)});
-    }
-    if (backing_int_ty.bitSize(zcu) != fields_bit_sum) {
-        return sema.fail(
-            block,
-            src,
-            "backing integer type '{f}' has bit size {d} but the struct fields have a total bit size of {d}",
-            .{ backing_int_ty.fmt(pt), backing_int_ty.bitSize(zcu), fields_bit_sum },
-        );
-    }
-}
-
 fn checkIndexable(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
     const pt = sema.pt;
     if (!ty.isIndexable(pt.zcu)) {
@@ -34432,358 +33352,6 @@ fn checkMemOperand(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void
     return sema.failWithOwnedErrorMsg(block, msg);
 }
 
-/// Resolve a unions's alignment only without triggering resolution of its layout.
-/// Asserts that the alignment is not yet resolved.
-pub fn resolveUnionAlignment(
-    sema: *Sema,
-    ty: Type,
-    union_type: InternPool.LoadedUnionType,
-) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-    const target = zcu.getTarget();
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    assert(!union_type.haveLayout(ip));
-
-    const ptr_align = Alignment.fromByteUnits(@divExact(target.ptrBitWidth(), 8));
-
-    // We'll guess "pointer-aligned", if the union has an
-    // underaligned pointer field then some allocations
-    // might require explicit alignment.
-    if (union_type.assumePointerAlignedIfFieldTypesWip(ip, io, ptr_align)) return;
-
-    try sema.resolveUnionFieldTypes(ty, union_type);
-
-    // No `zcu.trackUnitSema` calls, since this phase isn't really doing any semantic analysis.
-    // It's just triggering *other* analysis, alongside a simple loop over already-resolved info.
-
-    var max_align: Alignment = .@"1";
-    for (0..union_type.field_types.len) |field_index| {
-        const field_ty: Type = .fromInterned(union_type.field_types.get(ip)[field_index]);
-        if (!(try field_ty.hasRuntimeBitsSema(pt))) continue;
-
-        const explicit_align = union_type.fieldAlign(ip, field_index);
-        const field_align = if (explicit_align != .none)
-            explicit_align
-        else
-            try field_ty.abiAlignmentSema(sema.pt);
-
-        max_align = max_align.max(field_align);
-    }
-
-    union_type.setAlignment(ip, io, max_align);
-}
-
-/// This logic must be kept in sync with `Type.getUnionLayout`.
-pub fn resolveUnionLayout(sema: *Sema, ty: Type) SemaError!void {
-    const pt = sema.pt;
-    const io = pt.zcu.comp.io;
-    const ip = &pt.zcu.intern_pool;
-
-    try sema.resolveUnionFieldTypes(ty, ip.loadUnionType(ty.ip_index));
-
-    // Load again, since the tag type might have changed due to resolution.
-    const union_type = ip.loadUnionType(ty.ip_index);
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    const old_flags = union_type.flagsUnordered(ip);
-    switch (old_flags.status) {
-        .none, .have_field_types => {},
-        .field_types_wip, .layout_wip => {
-            const msg = try sema.errMsg(
-                ty.srcLoc(pt.zcu),
-                "union '{f}' depends on itself",
-                .{ty.fmt(pt)},
-            );
-            return sema.failWithOwnedErrorMsg(null, msg);
-        },
-        .have_layout, .fully_resolved_wip, .fully_resolved => return,
-    }
-
-    errdefer union_type.setStatusIfLayoutWip(ip, io, old_flags.status);
-
-    union_type.setStatus(ip, io, .layout_wip);
-
-    // No `zcu.trackUnitSema` calls, since this phase isn't really doing any semantic analysis.
-    // It's just triggering *other* analysis, alongside a simple loop over already-resolved info.
-
-    var max_size: u64 = 0;
-    var max_align: Alignment = .@"1";
-    for (0..union_type.field_types.len) |field_index| {
-        const field_ty: Type = .fromInterned(union_type.field_types.get(ip)[field_index]);
-        if (field_ty.isNoReturn(pt.zcu)) continue;
-
-        // We need to call `hasRuntimeBits` before calling `abiSize` to prevent reachable `unreachable`s,
-        // but `hasRuntimeBits` only resolves field types and so may infinite recurse on a layout wip type,
-        // so we must resolve the layout manually first, instead of waiting for `abiSize` to do it for us.
-        // This is arguably just hacking around bugs in both `abiSize` for not allowing arbitrary types to
-        // be queried, enabling failures to be handled with the emission of a compile error, and also in
-        // `hasRuntimeBits` for ever being able to infinite recurse in the first place.
-        try field_ty.resolveLayout(pt);
-
-        if (try field_ty.hasRuntimeBitsSema(pt)) {
-            max_size = @max(max_size, field_ty.abiSizeSema(pt) catch |err| switch (err) {
-                error.AnalysisFail => {
-                    const msg = sema.err orelse return err;
-                    try sema.addFieldErrNote(ty, field_index, msg, "while checking this field", .{});
-                    return err;
-                },
-                else => return err,
-            });
-        }
-
-        const explicit_align = union_type.fieldAlign(ip, field_index);
-        const field_align = if (explicit_align != .none)
-            explicit_align
-        else
-            try field_ty.abiAlignmentSema(pt);
-        max_align = max_align.max(field_align);
-    }
-
-    const has_runtime_tag = union_type.flagsUnordered(ip).runtime_tag.hasTag() and
-        try Type.fromInterned(union_type.enum_tag_ty).hasRuntimeBitsSema(pt);
-    const size, const alignment, const padding = if (has_runtime_tag) layout: {
-        const enum_tag_type: Type = .fromInterned(union_type.enum_tag_ty);
-        const tag_align = try enum_tag_type.abiAlignmentSema(pt);
-        const tag_size = try enum_tag_type.abiSizeSema(pt);
-
-        // Put the tag before or after the payload depending on which one's
-        // alignment is greater.
-        var size: u64 = 0;
-        var padding: u32 = 0;
-        if (tag_align.order(max_align).compare(.gte)) {
-            // {Tag, Payload}
-            size += tag_size;
-            size = max_align.forward(size);
-            size += max_size;
-            const prev_size = size;
-            size = tag_align.forward(size);
-            padding = @intCast(size - prev_size);
-        } else {
-            // {Payload, Tag}
-            size += max_size;
-            size = switch (pt.zcu.getTarget().ofmt) {
-                .c => max_align,
-                else => tag_align,
-            }.forward(size);
-            size += tag_size;
-            const prev_size = size;
-            size = max_align.forward(size);
-            padding = @intCast(size - prev_size);
-        }
-
-        break :layout .{ size, max_align.max(tag_align), padding };
-    } else .{ max_align.forward(max_size), max_align, 0 };
-
-    const casted_size = std.math.cast(u32, size) orelse {
-        const msg = try sema.errMsg(
-            ty.srcLoc(pt.zcu),
-            "union layout requires size {d}, this compiler implementation supports up to {d}",
-            .{ size, std.math.maxInt(u32) },
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    };
-    union_type.setHaveLayout(ip, io, casted_size, padding, alignment);
-
-    if (union_type.flagsUnordered(ip).assumed_runtime_bits and !(try ty.hasRuntimeBitsSema(pt))) {
-        const msg = try sema.errMsg(
-            ty.srcLoc(pt.zcu),
-            "union layout depends on it having runtime bits",
-            .{},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-
-    if (union_type.flagsUnordered(ip).assumed_pointer_aligned and
-        alignment.compareStrict(.neq, Alignment.fromByteUnits(@divExact(pt.zcu.getTarget().ptrBitWidth(), 8))))
-    {
-        const msg = try sema.errMsg(
-            ty.srcLoc(pt.zcu),
-            "union layout depends on being pointer aligned",
-            .{},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-    _ = try ty.comptimeOnlySema(pt);
-}
-
-/// Returns `error.AnalysisFail` if any of the types (recursively) failed to
-/// be resolved.
-pub fn resolveStructFully(sema: *Sema, ty: Type) SemaError!void {
-    try sema.resolveStructLayout(ty);
-    try sema.resolveStructFieldInits(ty);
-
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-    const struct_type = zcu.typeToStruct(ty).?;
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    if (struct_type.setFullyResolved(ip, io)) return;
-    errdefer struct_type.clearFullyResolved(ip, io);
-
-    // No `zcu.trackUnitSema` calls, since this phase isn't really doing any semantic analysis.
-    // It's just triggering *other* analysis, alongside a simple loop over already-resolved info.
-
-    // After we have resolve struct layout we have to go over the fields again to
-    // make sure pointer fields get their child types resolved as well.
-    // See also similar code for unions.
-
-    for (0..struct_type.field_types.len) |i| {
-        const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-        try field_ty.resolveFully(pt);
-    }
-}
-
-pub fn resolveUnionFully(sema: *Sema, ty: Type) SemaError!void {
-    try sema.resolveUnionLayout(ty);
-
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-    const union_obj = zcu.typeToUnion(ty).?;
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    switch (union_obj.flagsUnordered(ip).status) {
-        .none, .have_field_types, .field_types_wip, .layout_wip, .have_layout => {},
-        .fully_resolved_wip, .fully_resolved => return,
-    }
-
-    // No `zcu.trackUnitSema` calls, since this phase isn't really doing any semantic analysis.
-    // It's just triggering *other* analysis, alongside a simple loop over already-resolved info.
-
-    {
-        // After we have resolve union layout we have to go over the fields again to
-        // make sure pointer fields get their child types resolved as well.
-        // See also similar code for structs.
-        const prev_status = union_obj.flagsUnordered(ip).status;
-        errdefer union_obj.setStatus(ip, io, prev_status);
-
-        union_obj.setStatus(ip, io, .fully_resolved_wip);
-        for (0..union_obj.field_types.len) |field_index| {
-            const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-            try field_ty.resolveFully(pt);
-        }
-        union_obj.setStatus(ip, io, .fully_resolved);
-    }
-
-    // And let's not forget comptime-only status.
-    _ = try ty.comptimeOnlySema(pt);
-}
-
-pub fn resolveStructFieldTypes(
-    sema: *Sema,
-    ty: InternPool.Index,
-    struct_type: InternPool.LoadedStructType,
-) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-
-    assert(sema.owner.unwrap().type == ty);
-
-    if (struct_type.haveFieldTypes(ip)) return;
-
-    if (struct_type.setFieldTypesWip(ip, io)) {
-        const msg = try sema.errMsg(
-            Type.fromInterned(ty).srcLoc(zcu),
-            "struct '{f}' depends on itself",
-            .{Type.fromInterned(ty).fmt(pt)},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-    defer struct_type.clearFieldTypesWip(ip, io);
-
-    // can't happen earlier than this because we only want the progress node if not already resolved
-    const tracked_unit = zcu.trackUnitSema(struct_type.name.toSlice(ip), null);
-    defer tracked_unit.end(zcu);
-
-    sema.structFields(struct_type) catch |err| switch (err) {
-        error.AnalysisFail, error.OutOfMemory, error.Canceled => |e| return e,
-        error.ComptimeBreak, error.ComptimeReturn => unreachable,
-    };
-}
-
-pub fn resolveStructFieldInits(sema: *Sema, ty: Type) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-    const struct_type = zcu.typeToStruct(ty) orelse return;
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    // Inits can start as resolved
-    if (struct_type.haveFieldInits(ip)) return;
-
-    try sema.resolveStructLayout(ty);
-
-    if (struct_type.setInitsWip(ip, io)) {
-        const msg = try sema.errMsg(
-            ty.srcLoc(zcu),
-            "struct '{f}' depends on itself",
-            .{ty.fmt(pt)},
-        );
-        return sema.failWithOwnedErrorMsg(null, msg);
-    }
-    defer struct_type.clearInitsWip(ip, io);
-
-    // can't happen earlier than this because we only want the progress node if not already resolved
-    const tracked_unit = zcu.trackUnitSema(struct_type.name.toSlice(ip), null);
-    defer tracked_unit.end(zcu);
-
-    sema.structFieldInits(struct_type) catch |err| switch (err) {
-        error.AnalysisFail, error.OutOfMemory, error.Canceled => |e| return e,
-        error.ComptimeBreak, error.ComptimeReturn => unreachable,
-    };
-    struct_type.setHaveFieldInits(ip, io);
-}
-
-pub fn resolveUnionFieldTypes(sema: *Sema, ty: Type, union_type: InternPool.LoadedUnionType) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-
-    assert(sema.owner.unwrap().type == ty.toIntern());
-
-    switch (union_type.flagsUnordered(ip).status) {
-        .none => {},
-        .field_types_wip => {
-            const msg = try sema.errMsg(ty.srcLoc(zcu), "union '{f}' depends on itself", .{ty.fmt(pt)});
-            return sema.failWithOwnedErrorMsg(null, msg);
-        },
-        .have_field_types,
-        .have_layout,
-        .layout_wip,
-        .fully_resolved_wip,
-        .fully_resolved,
-        => return,
-    }
-
-    // can't happen earlier than this because we only want the progress node if not already resolved
-    const tracked_unit = zcu.trackUnitSema(union_type.name.toSlice(ip), null);
-    defer tracked_unit.end(zcu);
-
-    union_type.setStatus(ip, io, .field_types_wip);
-    errdefer union_type.setStatus(ip, io, .none);
-    sema.unionFields(ty.toIntern(), union_type) catch |err| switch (err) {
-        error.AnalysisFail, error.OutOfMemory, error.Canceled => |e| return e,
-        error.ComptimeBreak, error.ComptimeReturn => unreachable,
-    };
-    union_type.setStatus(ip, io, .have_field_types);
-}
-
 /// Returns a normal error set corresponding to the fully populated inferred
 /// error set.
 fn resolveInferredErrorSet(
@@ -34798,8 +33366,9 @@ fn resolveInferredErrorSet(
     const func_index = ip.iesFuncIndex(ies_index);
     const func = zcu.funcInfo(func_index);
 
-    try sema.declareDependency(.{ .interned = func_index }); // resolved IES
+    try sema.declareDependency(.{ .func_ies = func_index });
 
+    // MLUGG TODO: this feels kinda bad now... instead check for outdated whenver we grab this?
     try zcu.maybeUnresolveIes(func_index);
     const resolved_ty = func.resolvedErrorSetUnordered(ip);
     if (resolved_ty != .none) return resolved_ty;
@@ -34820,7 +33389,7 @@ fn resolveInferredErrorSet(
     if (ies_func_info.return_type == .generic_poison_type) {
         assert(ies_func_info.cc == .@"inline");
     } else if (ip.errorUnionSet(ies_func_info.return_type) == ies_index) {
-        if (ies_func_info.is_generic) {
+        if (!Type.fromInterned(func.ty).fnHasRuntimeBits(zcu)) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "unable to resolve inferred error set of generic function", .{});
                 errdefer msg.destroy(sema.gpa);
@@ -34935,1248 +33504,6 @@ fn resolveInferredErrorSetTy(
     }
 }
 
-fn structZirInfo(zir: Zir, zir_index: Zir.Inst.Index) struct {
-    /// fields_len
-    usize,
-    Zir.Inst.StructDecl.Small,
-    /// extra_index
-    usize,
-} {
-    const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
-    assert(extended.opcode == .struct_decl);
-    const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-    var extra_index: usize = extended.operand + @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len;
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    const decls_len = if (small.has_decls_len) decls_len: {
-        const decls_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :decls_len decls_len;
-    } else 0;
-
-    extra_index += captures_len * 2;
-
-    // The backing integer cannot be handled until `resolveStructLayout()`.
-    if (small.has_backing_int) {
-        const backing_int_body_len = zir.extra[extra_index];
-        extra_index += 1; // backing_int_body_len
-        if (backing_int_body_len == 0) {
-            extra_index += 1; // backing_int_ref
-        } else {
-            extra_index += backing_int_body_len; // backing_int_body_inst
-        }
-    }
-
-    // Skip over decls.
-    extra_index += decls_len;
-
-    return .{ fields_len, small, extra_index };
-}
-
-fn structFields(
-    sema: *Sema,
-    struct_type: InternPool.LoadedStructType,
-) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const namespace_index = struct_type.namespace;
-    const zir = zcu.namespacePtr(namespace_index).fileScope(zcu).zir.?;
-    const zir_index = struct_type.zir_index.resolve(ip) orelse return error.AnalysisFail;
-
-    const fields_len, _, var extra_index = structZirInfo(zir, zir_index);
-
-    if (fields_len == 0) switch (struct_type.layout) {
-        .@"packed" => {
-            try sema.backingIntType(struct_type);
-            return;
-        },
-        .auto, .@"extern" => {
-            struct_type.setLayoutResolved(ip, io, 0, .none);
-            return;
-        },
-    };
-
-    var block_scope: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = namespace_index,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = .{ .reason = .{
-            .src = .{
-                .base_node_inst = struct_type.zir_index,
-                .offset = .nodeOffset(.zero),
-            },
-            .r = .{ .simple = .type },
-        } },
-        .src_base_inst = struct_type.zir_index,
-        .type_name_ctx = struct_type.name,
-    };
-    defer assert(block_scope.instructions.items.len == 0);
-
-    const Field = struct {
-        type_body_len: u32 = 0,
-        align_body_len: u32 = 0,
-        init_body_len: u32 = 0,
-        type_ref: Zir.Inst.Ref = .none,
-    };
-    const fields = try sema.arena.alloc(Field, fields_len);
-
-    var any_inits = false;
-    var any_aligned = false;
-
-    {
-        const bits_per_field = 4;
-        const fields_per_u32 = 32 / bits_per_field;
-        const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
-        const flags_index = extra_index;
-        var bit_bag_index: usize = flags_index;
-        extra_index += bit_bags_count;
-        var cur_bit_bag: u32 = undefined;
-        var field_i: u32 = 0;
-        while (field_i < fields_len) : (field_i += 1) {
-            if (field_i % fields_per_u32 == 0) {
-                cur_bit_bag = zir.extra[bit_bag_index];
-                bit_bag_index += 1;
-            }
-            const has_align = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const has_init = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const is_comptime = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-
-            if (is_comptime) struct_type.setFieldComptime(ip, field_i);
-
-            const field_name_zir: [:0]const u8 = zir.nullTerminatedString(@enumFromInt(zir.extra[extra_index]));
-            extra_index += 1; // field_name
-
-            fields[field_i] = .{};
-
-            if (has_type_body) {
-                fields[field_i].type_body_len = zir.extra[extra_index];
-            } else {
-                fields[field_i].type_ref = @enumFromInt(zir.extra[extra_index]);
-            }
-            extra_index += 1;
-
-            // This string needs to outlive the ZIR code.
-            const field_name = try ip.getOrPutString(gpa, io, pt.tid, field_name_zir, .no_embedded_nulls);
-            assert(struct_type.addFieldName(ip, field_name) == null);
-
-            if (has_align) {
-                fields[field_i].align_body_len = zir.extra[extra_index];
-                extra_index += 1;
-                any_aligned = true;
-            }
-            if (has_init) {
-                fields[field_i].init_body_len = zir.extra[extra_index];
-                extra_index += 1;
-                any_inits = true;
-            }
-        }
-    }
-
-    // Next we do only types and alignments, saving the inits for a second pass,
-    // so that init values may depend on type layout.
-
-    for (fields, 0..) |zir_field, field_i| {
-        const ty_src: LazySrcLoc = .{
-            .base_node_inst = struct_type.zir_index,
-            .offset = .{ .container_field_type = @intCast(field_i) },
-        };
-        const field_ty: Type = ty: {
-            if (zir_field.type_ref != .none) {
-                break :ty try sema.resolveType(&block_scope, ty_src, zir_field.type_ref);
-            }
-            assert(zir_field.type_body_len != 0);
-            const body = zir.bodySlice(extra_index, zir_field.type_body_len);
-            extra_index += body.len;
-            const ty_ref = try sema.resolveInlineBody(&block_scope, body, zir_index);
-            break :ty try sema.analyzeAsType(&block_scope, ty_src, ty_ref);
-        };
-
-        struct_type.field_types.get(ip)[field_i] = field_ty.toIntern();
-
-        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
-            const msg = msg: {
-                const msg = try sema.errMsg(ty_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
-                errdefer msg.destroy(sema.gpa);
-
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(&block_scope, msg);
-        }
-        if (field_ty.zigTypeTag(zcu) == .noreturn) {
-            const msg = msg: {
-                const msg = try sema.errMsg(ty_src, "struct fields cannot be 'noreturn'", .{});
-                errdefer msg.destroy(sema.gpa);
-
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(&block_scope, msg);
-        }
-        switch (struct_type.layout) {
-            .@"extern" => if (!try sema.validateExternType(field_ty, .struct_field)) {
-                const msg = msg: {
-                    const msg = try sema.errMsg(ty_src, "extern structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(sema.gpa);
-
-                    try sema.explainWhyTypeIsNotExtern(msg, ty_src, field_ty, .struct_field);
-
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(&block_scope, msg);
-            },
-            .@"packed" => if (!try sema.validatePackedType(field_ty)) {
-                const msg = msg: {
-                    const msg = try sema.errMsg(ty_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(sema.gpa);
-
-                    try sema.explainWhyTypeIsNotPacked(msg, ty_src, field_ty);
-
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(&block_scope, msg);
-            },
-            else => {},
-        }
-
-        if (zir_field.align_body_len > 0) {
-            const body = zir.bodySlice(extra_index, zir_field.align_body_len);
-            extra_index += body.len;
-            const align_ref = try sema.resolveInlineBody(&block_scope, body, zir_index);
-            const align_src: LazySrcLoc = .{
-                .base_node_inst = struct_type.zir_index,
-                .offset = .{ .container_field_align = @intCast(field_i) },
-            };
-            const field_align = try sema.analyzeAsAlign(&block_scope, align_src, align_ref);
-            struct_type.field_aligns.get(ip)[field_i] = field_align;
-        }
-
-        extra_index += zir_field.init_body_len;
-    }
-
-    struct_type.clearFieldTypesWip(ip, io);
-    if (!any_inits) struct_type.setHaveFieldInits(ip, io);
-
-    try sema.flushExports();
-}
-
-// This logic must be kept in sync with `structFields`
-fn structFieldInits(
-    sema: *Sema,
-    struct_type: InternPool.LoadedStructType,
-) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-
-    assert(!struct_type.haveFieldInits(ip));
-
-    const namespace_index = struct_type.namespace;
-    const zir = zcu.namespacePtr(namespace_index).fileScope(zcu).zir.?;
-    const zir_index = struct_type.zir_index.resolve(ip) orelse return error.AnalysisFail;
-    const fields_len, _, var extra_index = structZirInfo(zir, zir_index);
-
-    var block_scope: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = namespace_index,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = undefined, // set when `block_scope` is used
-        .src_base_inst = struct_type.zir_index,
-        .type_name_ctx = struct_type.name,
-    };
-    defer assert(block_scope.instructions.items.len == 0);
-
-    const Field = struct {
-        type_body_len: u32 = 0,
-        align_body_len: u32 = 0,
-        init_body_len: u32 = 0,
-    };
-    const fields = try sema.arena.alloc(Field, fields_len);
-
-    var any_inits = false;
-
-    {
-        const bits_per_field = 4;
-        const fields_per_u32 = 32 / bits_per_field;
-        const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
-        const flags_index = extra_index;
-        var bit_bag_index: usize = flags_index;
-        extra_index += bit_bags_count;
-        var cur_bit_bag: u32 = undefined;
-        var field_i: u32 = 0;
-        while (field_i < fields_len) : (field_i += 1) {
-            if (field_i % fields_per_u32 == 0) {
-                cur_bit_bag = zir.extra[bit_bag_index];
-                bit_bag_index += 1;
-            }
-            const has_align = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-            const has_init = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 2;
-            const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
-            cur_bit_bag >>= 1;
-
-            extra_index += 1; // field_name
-
-            fields[field_i] = .{};
-
-            if (has_type_body) fields[field_i].type_body_len = zir.extra[extra_index];
-            extra_index += 1;
-
-            if (has_align) {
-                fields[field_i].align_body_len = zir.extra[extra_index];
-                extra_index += 1;
-            }
-            if (has_init) {
-                fields[field_i].init_body_len = zir.extra[extra_index];
-                extra_index += 1;
-                any_inits = true;
-            }
-        }
-    }
-
-    if (any_inits) {
-        for (fields, 0..) |zir_field, field_i| {
-            extra_index += zir_field.type_body_len;
-            extra_index += zir_field.align_body_len;
-            const body = zir.bodySlice(extra_index, zir_field.init_body_len);
-            extra_index += zir_field.init_body_len;
-
-            if (body.len == 0) continue;
-
-            // Pre-populate the type mapping the body expects to be there.
-            // In init bodies, the zir index of the struct itself is used
-            // to refer to the current field type.
-
-            const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_i]);
-            const type_ref = Air.internedToRef(field_ty.toIntern());
-            try sema.inst_map.ensureSpaceForInstructions(sema.gpa, &.{zir_index});
-            sema.inst_map.putAssumeCapacity(zir_index, type_ref);
-
-            const init_src: LazySrcLoc = .{
-                .base_node_inst = struct_type.zir_index,
-                .offset = .{ .container_field_value = @intCast(field_i) },
-            };
-
-            block_scope.comptime_reason = .{ .reason = .{
-                .src = init_src,
-                .r = .{ .simple = .struct_field_default_value },
-            } };
-            const init = try sema.resolveInlineBody(&block_scope, body, zir_index);
-            const coerced = try sema.coerce(&block_scope, field_ty, init, init_src);
-            const default_val = try sema.resolveConstValue(&block_scope, init_src, coerced, null);
-
-            if (default_val.canMutateComptimeVarState(zcu)) {
-                return sema.failWithContainsReferenceToComptimeVar(
-                    &block_scope,
-                    init_src,
-                    struct_type.fieldName(ip, field_i),
-                    "field default value",
-                    default_val,
-                );
-            }
-            struct_type.field_inits.get(ip)[field_i] = default_val.toIntern();
-        }
-    }
-
-    try sema.flushExports();
-}
-
-fn unionFields(
-    sema: *Sema,
-    union_ty: InternPool.Index,
-    union_type: InternPool.LoadedUnionType,
-) CompileError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const zir = zcu.namespacePtr(union_type.namespace).fileScope(zcu).zir.?;
-    const zir_index = union_type.zir_index.resolve(ip) orelse return error.AnalysisFail;
-    const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
-    assert(extended.opcode == .union_decl);
-    const small: Zir.Inst.UnionDecl.Small = @bitCast(extended.small);
-    const extra = zir.extraData(Zir.Inst.UnionDecl, extended.operand);
-    var extra_index: usize = extra.end;
-
-    const tag_type_ref: Zir.Inst.Ref = if (small.has_tag_type) blk: {
-        const ty_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-        extra_index += 1;
-        break :blk ty_ref;
-    } else .none;
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-
-    const body_len = if (small.has_body_len) blk: {
-        const body_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk body_len;
-    } else 0;
-
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    const decls_len = if (small.has_decls_len) decls_len: {
-        const decls_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :decls_len decls_len;
-    } else 0;
-
-    // Skip over captures and decls.
-    extra_index += captures_len * 2 + decls_len;
-
-    const body = zir.bodySlice(extra_index, body_len);
-    extra_index += body.len;
-
-    const src: LazySrcLoc = .{
-        .base_node_inst = union_type.zir_index,
-        .offset = .nodeOffset(.zero),
-    };
-
-    var block_scope: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = union_type.namespace,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = .{ .reason = .{
-            .src = src,
-            .r = .{ .simple = .type },
-        } },
-        .src_base_inst = union_type.zir_index,
-        .type_name_ctx = union_type.name,
-    };
-    defer assert(block_scope.instructions.items.len == 0);
-
-    if (body.len != 0) {
-        _ = try sema.analyzeInlineBody(&block_scope, body, zir_index);
-    }
-
-    var int_tag_ty: Type = undefined;
-    var enum_field_names: []InternPool.NullTerminatedString = &.{};
-    var enum_field_vals: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty;
-    var explicit_tags_seen: []bool = &.{};
-    if (tag_type_ref != .none) {
-        const tag_ty_src: LazySrcLoc = .{
-            .base_node_inst = union_type.zir_index,
-            .offset = .{ .node_offset_container_tag = .zero },
-        };
-        const provided_ty = try sema.resolveType(&block_scope, tag_ty_src, tag_type_ref);
-        if (small.auto_enum_tag) {
-            // The provided type is an integer type and we must construct the enum tag type here.
-            int_tag_ty = provided_ty;
-            if (int_tag_ty.zigTypeTag(zcu) != .int and int_tag_ty.zigTypeTag(zcu) != .comptime_int) {
-                return sema.fail(&block_scope, tag_ty_src, "expected integer tag type, found '{f}'", .{int_tag_ty.fmt(pt)});
-            }
-
-            if (fields_len > 0) {
-                const field_count_val = try pt.intValue(.comptime_int, fields_len - 1);
-                if (!(try sema.intFitsInType(field_count_val, int_tag_ty, null))) {
-                    const msg = msg: {
-                        const msg = try sema.errMsg(tag_ty_src, "specified integer tag type cannot represent every field", .{});
-                        errdefer msg.destroy(sema.gpa);
-                        try sema.errNote(tag_ty_src, msg, "type '{f}' cannot fit values in range 0...{d}", .{
-                            int_tag_ty.fmt(pt),
-                            fields_len - 1,
-                        });
-                        break :msg msg;
-                    };
-                    return sema.failWithOwnedErrorMsg(&block_scope, msg);
-                }
-                enum_field_names = try sema.arena.alloc(InternPool.NullTerminatedString, fields_len);
-                try enum_field_vals.ensureTotalCapacity(sema.arena, fields_len);
-            }
-        } else {
-            // The provided type is the enum tag type.
-            const enum_type = switch (ip.indexToKey(provided_ty.toIntern())) {
-                .enum_type => ip.loadEnumType(provided_ty.toIntern()),
-                else => return sema.fail(&block_scope, tag_ty_src, "expected enum tag type, found '{f}'", .{provided_ty.fmt(pt)}),
-            };
-            union_type.setTagType(ip, io, provided_ty.toIntern());
-            // The fields of the union must match the enum exactly.
-            // A flag per field is used to check for missing and extraneous fields.
-            explicit_tags_seen = try sema.arena.alloc(bool, enum_type.names.len);
-            @memset(explicit_tags_seen, false);
-        }
-    } else {
-        // If auto_enum_tag is false, this is an untagged union. However, for semantic analysis
-        // purposes, we still auto-generate an enum tag type the same way. That the union is
-        // untagged is represented by the Type tag (union vs union_tagged).
-        enum_field_names = try sema.arena.alloc(InternPool.NullTerminatedString, fields_len);
-    }
-
-    var field_types: std.ArrayList(InternPool.Index) = .empty;
-    var field_aligns: std.ArrayList(InternPool.Alignment) = .empty;
-
-    try field_types.ensureTotalCapacityPrecise(sema.arena, fields_len);
-    if (small.any_aligned_fields)
-        try field_aligns.ensureTotalCapacityPrecise(sema.arena, fields_len);
-
-    var max_bits: u64 = 0;
-    var min_bits: u64 = std.math.maxInt(u64);
-    var max_bits_src: LazySrcLoc = undefined;
-    var min_bits_src: LazySrcLoc = undefined;
-    var max_bits_ty: Type = undefined;
-    var min_bits_ty: Type = undefined;
-    const bits_per_field = 4;
-    const fields_per_u32 = 32 / bits_per_field;
-    const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
-    var bit_bag_index: usize = extra_index;
-    extra_index += bit_bags_count;
-    var cur_bit_bag: u32 = undefined;
-    var field_i: u32 = 0;
-    var last_tag_val: ?Value = null;
-    const layout = union_type.flagsUnordered(ip).layout;
-    while (field_i < fields_len) : (field_i += 1) {
-        if (field_i % fields_per_u32 == 0) {
-            cur_bit_bag = zir.extra[bit_bag_index];
-            bit_bag_index += 1;
-        }
-        const has_type = @as(u1, @truncate(cur_bit_bag)) != 0;
-        cur_bit_bag >>= 1;
-        const has_align = @as(u1, @truncate(cur_bit_bag)) != 0;
-        cur_bit_bag >>= 1;
-        const has_tag = @as(u1, @truncate(cur_bit_bag)) != 0;
-        cur_bit_bag >>= 1;
-        const unused = @as(u1, @truncate(cur_bit_bag)) != 0;
-        cur_bit_bag >>= 1;
-        _ = unused;
-
-        const field_name_index: Zir.NullTerminatedString = @enumFromInt(zir.extra[extra_index]);
-        const field_name_zir = zir.nullTerminatedString(field_name_index);
-        extra_index += 1;
-
-        const field_type_ref: Zir.Inst.Ref = if (has_type) blk: {
-            const field_type_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-            extra_index += 1;
-            break :blk field_type_ref;
-        } else .none;
-
-        const align_ref: Zir.Inst.Ref = if (has_align) blk: {
-            const align_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-            extra_index += 1;
-            break :blk align_ref;
-        } else .none;
-
-        const tag_ref: Air.Inst.Ref = if (has_tag) blk: {
-            const tag_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-            extra_index += 1;
-            break :blk try sema.resolveInst(tag_ref);
-        } else .none;
-
-        const name_src: LazySrcLoc = .{
-            .base_node_inst = union_type.zir_index,
-            .offset = .{ .container_field_name = field_i },
-        };
-        const value_src: LazySrcLoc = .{
-            .base_node_inst = union_type.zir_index,
-            .offset = .{ .container_field_value = field_i },
-        };
-        const align_src: LazySrcLoc = .{
-            .base_node_inst = union_type.zir_index,
-            .offset = .{ .container_field_align = field_i },
-        };
-        const type_src: LazySrcLoc = .{
-            .base_node_inst = union_type.zir_index,
-            .offset = .{ .container_field_type = field_i },
-        };
-
-        if (enum_field_vals.capacity() > 0) {
-            const enum_tag_val = if (tag_ref != .none) blk: {
-                const coerced = try sema.coerce(&block_scope, int_tag_ty, tag_ref, value_src);
-                const val = try sema.resolveConstDefinedValue(&block_scope, value_src, coerced, .{ .simple = .enum_field_tag_value });
-                last_tag_val = val;
-
-                break :blk val;
-            } else blk: {
-                if (last_tag_val) |last_tag| {
-                    const result = try arith.incrementDefinedInt(sema, int_tag_ty, last_tag);
-                    if (result.overflow) return sema.fail(
-                        &block_scope,
-                        value_src,
-                        "enumeration value '{f}' too large for type '{f}'",
-                        .{ result.val.fmtValueSema(pt, sema), int_tag_ty.fmt(pt) },
-                    );
-                    last_tag_val = result.val;
-                } else {
-                    last_tag_val = try pt.intValue(int_tag_ty, 0);
-                }
-                break :blk last_tag_val.?;
-            };
-            const gop = enum_field_vals.getOrPutAssumeCapacity(enum_tag_val.toIntern());
-            if (gop.found_existing) {
-                const other_value_src: LazySrcLoc = .{
-                    .base_node_inst = union_type.zir_index,
-                    .offset = .{ .container_field_value = @intCast(gop.index) },
-                };
-                const msg = msg: {
-                    const msg = try sema.errMsg(
-                        value_src,
-                        "enum tag value {f} already taken",
-                        .{enum_tag_val.fmtValueSema(pt, sema)},
-                    );
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(other_value_src, msg, "other occurrence here", .{});
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(&block_scope, msg);
-            }
-        }
-
-        // This string needs to outlive the ZIR code.
-        const field_name = try ip.getOrPutString(gpa, io, pt.tid, field_name_zir, .no_embedded_nulls);
-        if (enum_field_names.len != 0) {
-            enum_field_names[field_i] = field_name;
-        }
-
-        const field_ty: Type = if (!has_type)
-            .void
-        else if (field_type_ref == .none)
-            .noreturn
-        else
-            try sema.resolveType(&block_scope, type_src, field_type_ref);
-
-        if (explicit_tags_seen.len > 0) {
-            const tag_ty = union_type.tagTypeUnordered(ip);
-            const tag_info = ip.loadEnumType(tag_ty);
-            const enum_index = tag_info.nameIndex(ip, field_name) orelse {
-                return sema.fail(&block_scope, name_src, "no field named '{f}' in enum '{f}'", .{
-                    field_name.fmt(ip), Type.fromInterned(tag_ty).fmt(pt),
-                });
-            };
-
-            // No check for duplicate because the check already happened in order
-            // to create the enum type in the first place.
-            assert(!explicit_tags_seen[enum_index]);
-            explicit_tags_seen[enum_index] = true;
-
-            // Enforce the enum fields and the union fields being in the same order.
-            if (enum_index != field_i) {
-                const msg = msg: {
-                    const enum_field_src: LazySrcLoc = .{
-                        .base_node_inst = Type.fromInterned(tag_ty).typeDeclInstAllowGeneratedTag(zcu).?,
-                        .offset = .{ .container_field_name = enum_index },
-                    };
-                    const msg = try sema.errMsg(name_src, "union field '{f}' ordered differently than corresponding enum field", .{
-                        field_name.fmt(ip),
-                    });
-                    errdefer msg.destroy(sema.gpa);
-                    try sema.errNote(enum_field_src, msg, "enum field here", .{});
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(&block_scope, msg);
-            }
-        }
-
-        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
-            const msg = msg: {
-                const msg = try sema.errMsg(type_src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
-                errdefer msg.destroy(sema.gpa);
-
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(&block_scope, msg);
-        }
-        switch (layout) {
-            .@"extern" => if (!try sema.validateExternType(field_ty, .union_field)) {
-                const msg = msg: {
-                    const msg = try sema.errMsg(type_src, "extern unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(sema.gpa);
-
-                    try sema.explainWhyTypeIsNotExtern(msg, type_src, field_ty, .union_field);
-
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(&block_scope, msg);
-            },
-            .@"packed" => {
-                if (!try sema.validatePackedType(field_ty)) {
-                    const msg = msg: {
-                        const msg = try sema.errMsg(type_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                        errdefer msg.destroy(sema.gpa);
-
-                        try sema.explainWhyTypeIsNotPacked(msg, type_src, field_ty);
-
-                        try sema.addDeclaredHereNote(msg, field_ty);
-                        break :msg msg;
-                    };
-                    return sema.failWithOwnedErrorMsg(&block_scope, msg);
-                }
-                const field_bits = try field_ty.bitSizeSema(pt);
-                if (field_bits >= max_bits) {
-                    max_bits = field_bits;
-                    max_bits_src = type_src;
-                    max_bits_ty = field_ty;
-                }
-                if (field_bits <= min_bits) {
-                    min_bits = field_bits;
-                    min_bits_src = type_src;
-                    min_bits_ty = field_ty;
-                }
-            },
-            .auto => {},
-        }
-
-        field_types.appendAssumeCapacity(field_ty.toIntern());
-
-        if (small.any_aligned_fields) {
-            field_aligns.appendAssumeCapacity(if (align_ref != .none)
-                try sema.resolveAlign(&block_scope, align_src, align_ref)
-            else
-                .none);
-        } else {
-            assert(align_ref == .none);
-        }
-    }
-
-    union_type.setFieldTypes(ip, field_types.items);
-    union_type.setFieldAligns(ip, field_aligns.items);
-
-    if (layout == .@"packed" and fields_len != 0 and min_bits != max_bits) {
-        const msg = msg: {
-            const msg = try sema.errMsg(src, "packed union has fields with mismatching bit sizes", .{});
-            errdefer msg.destroy(sema.gpa);
-            try sema.errNote(min_bits_src, msg, "{d} bits here", .{min_bits});
-            try sema.addDeclaredHereNote(msg, min_bits_ty);
-            try sema.errNote(max_bits_src, msg, "{d} bits here", .{max_bits});
-            try sema.addDeclaredHereNote(msg, max_bits_ty);
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(&block_scope, msg);
-    }
-
-    if (explicit_tags_seen.len > 0) {
-        const tag_ty = union_type.tagTypeUnordered(ip);
-        const tag_info = ip.loadEnumType(tag_ty);
-        if (tag_info.names.len > fields_len) {
-            const msg = msg: {
-                const msg = try sema.errMsg(src, "enum field(s) missing in union", .{});
-                errdefer msg.destroy(sema.gpa);
-
-                for (tag_info.names.get(ip), 0..) |field_name, field_index| {
-                    if (explicit_tags_seen[field_index]) continue;
-                    try sema.addFieldErrNote(.fromInterned(tag_ty), field_index, msg, "field '{f}' missing, declared here", .{
-                        field_name.fmt(ip),
-                    });
-                }
-                try sema.addDeclaredHereNote(msg, .fromInterned(tag_ty));
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(&block_scope, msg);
-        }
-    } else if (enum_field_vals.count() > 0) {
-        const enum_ty = try sema.generateUnionTagTypeNumbered(&block_scope, enum_field_names, enum_field_vals.keys(), union_ty, union_type.name);
-        union_type.setTagType(ip, io, enum_ty);
-    } else {
-        const enum_ty = try sema.generateUnionTagTypeSimple(&block_scope, enum_field_names, union_ty, union_type.name);
-        union_type.setTagType(ip, io, enum_ty);
-    }
-
-    try sema.flushExports();
-}
-
-fn generateUnionTagTypeNumbered(
-    sema: *Sema,
-    block: *Block,
-    enum_field_names: []const InternPool.NullTerminatedString,
-    enum_field_vals: []const InternPool.Index,
-    union_type: InternPool.Index,
-    union_name: InternPool.NullTerminatedString,
-) !InternPool.Index {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const name = try ip.getOrPutStringFmt(
-        gpa,
-        io,
-        pt.tid,
-        "@typeInfo({f}).@\"union\".tag_type.?",
-        .{union_name.fmt(ip)},
-        .no_embedded_nulls,
-    );
-
-    const enum_ty = try ip.getGeneratedTagEnumType(gpa, io, pt.tid, .{
-        .name = name,
-        .owner_union_ty = union_type,
-        .tag_ty = if (enum_field_vals.len == 0)
-            (try pt.intType(.unsigned, 0)).toIntern()
-        else
-            ip.typeOf(enum_field_vals[0]),
-        .names = enum_field_names,
-        .values = enum_field_vals,
-        .tag_mode = .explicit,
-        .parent_namespace = block.namespace,
-    });
-
-    return enum_ty;
-}
-
-fn generateUnionTagTypeSimple(
-    sema: *Sema,
-    block: *Block,
-    enum_field_names: []const InternPool.NullTerminatedString,
-    union_type: InternPool.Index,
-    union_name: InternPool.NullTerminatedString,
-) !InternPool.Index {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const name = try ip.getOrPutStringFmt(
-        gpa,
-        io,
-        pt.tid,
-        "@typeInfo({f}).@\"union\".tag_type.?",
-        .{union_name.fmt(ip)},
-        .no_embedded_nulls,
-    );
-
-    const enum_ty = try ip.getGeneratedTagEnumType(gpa, io, pt.tid, .{
-        .name = name,
-        .owner_union_ty = union_type,
-        .tag_ty = (try pt.smallestUnsignedInt(enum_field_names.len -| 1)).toIntern(),
-        .names = enum_field_names,
-        .values = &.{},
-        .tag_mode = .auto,
-        .parent_namespace = block.namespace,
-    });
-
-    return enum_ty;
-}
-
-/// There is another implementation of this in `Type.onePossibleValue`. This one
-/// in `Sema` is for calling during semantic analysis, and performs field resolution
-/// to get the answer. The one in `Type` is for calling during codegen and asserts
-/// that the types are already resolved.
-/// TODO assert the return value matches `ty.onePossibleValue`
-pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    return switch (ty.toIntern()) {
-        .u0_type,
-        .i0_type,
-        => try pt.intValue(ty, 0),
-        .u1_type,
-        .u8_type,
-        .i8_type,
-        .u16_type,
-        .i16_type,
-        .u29_type,
-        .u32_type,
-        .i32_type,
-        .u64_type,
-        .i64_type,
-        .u80_type,
-        .u128_type,
-        .i128_type,
-        .u256_type,
-        .usize_type,
-        .isize_type,
-        .c_char_type,
-        .c_short_type,
-        .c_ushort_type,
-        .c_int_type,
-        .c_uint_type,
-        .c_long_type,
-        .c_ulong_type,
-        .c_longlong_type,
-        .c_ulonglong_type,
-        .c_longdouble_type,
-        .f16_type,
-        .f32_type,
-        .f64_type,
-        .f80_type,
-        .f128_type,
-        .anyopaque_type,
-        .bool_type,
-        .type_type,
-        .anyerror_type,
-        .adhoc_inferred_error_set_type,
-        .comptime_int_type,
-        .comptime_float_type,
-        .enum_literal_type,
-        .ptr_usize_type,
-        .ptr_const_comptime_int_type,
-        .manyptr_u8_type,
-        .manyptr_const_u8_type,
-        .manyptr_const_u8_sentinel_0_type,
-        .manyptr_const_slice_const_u8_type,
-        .slice_const_u8_type,
-        .slice_const_u8_sentinel_0_type,
-        .slice_const_slice_const_u8_type,
-        .optional_type_type,
-        .manyptr_const_type_type,
-        .slice_const_type_type,
-        .vector_8_i8_type,
-        .vector_16_i8_type,
-        .vector_32_i8_type,
-        .vector_64_i8_type,
-        .vector_1_u8_type,
-        .vector_2_u8_type,
-        .vector_4_u8_type,
-        .vector_8_u8_type,
-        .vector_16_u8_type,
-        .vector_32_u8_type,
-        .vector_64_u8_type,
-        .vector_2_i16_type,
-        .vector_4_i16_type,
-        .vector_8_i16_type,
-        .vector_16_i16_type,
-        .vector_32_i16_type,
-        .vector_4_u16_type,
-        .vector_8_u16_type,
-        .vector_16_u16_type,
-        .vector_32_u16_type,
-        .vector_2_i32_type,
-        .vector_4_i32_type,
-        .vector_8_i32_type,
-        .vector_16_i32_type,
-        .vector_4_u32_type,
-        .vector_8_u32_type,
-        .vector_16_u32_type,
-        .vector_2_i64_type,
-        .vector_4_i64_type,
-        .vector_8_i64_type,
-        .vector_2_u64_type,
-        .vector_4_u64_type,
-        .vector_8_u64_type,
-        .vector_1_u128_type,
-        .vector_2_u128_type,
-        .vector_1_u256_type,
-        .vector_4_f16_type,
-        .vector_8_f16_type,
-        .vector_16_f16_type,
-        .vector_32_f16_type,
-        .vector_2_f32_type,
-        .vector_4_f32_type,
-        .vector_8_f32_type,
-        .vector_16_f32_type,
-        .vector_2_f64_type,
-        .vector_4_f64_type,
-        .vector_8_f64_type,
-        .anyerror_void_error_union_type,
-        => null,
-        .void_type => Value.void,
-        .noreturn_type => Value.@"unreachable",
-        .anyframe_type => unreachable,
-        .null_type => Value.null,
-        .undefined_type => Value.undef,
-        .optional_noreturn_type => try pt.nullValue(ty),
-        .generic_poison_type => unreachable,
-        .empty_tuple_type => Value.empty_tuple,
-        // values, not types
-        .undef,
-        .undef_bool,
-        .undef_usize,
-        .undef_u1,
-        .zero,
-        .zero_usize,
-        .zero_u1,
-        .zero_u8,
-        .one,
-        .one_usize,
-        .one_u1,
-        .one_u8,
-        .four_u8,
-        .negative_one,
-        .void_value,
-        .unreachable_value,
-        .null_value,
-        .bool_true,
-        .bool_false,
-        .empty_tuple,
-        // invalid
-        .none,
-        => unreachable,
-
-        _ => switch (ty.toIntern().unwrap(ip).getTag(ip)) {
-            .removed => unreachable,
-
-            .type_int_signed, // i0 handled above
-            .type_int_unsigned, // u0 handled above
-            .type_pointer,
-            .type_slice,
-            .type_anyframe,
-            .type_error_union,
-            .type_anyerror_union,
-            .type_error_set,
-            .type_inferred_error_set,
-            .type_opaque,
-            .type_function,
-            => null,
-
-            .simple_type, // handled above
-            // values, not types
-            .undef,
-            .simple_value,
-            .ptr_nav,
-            .ptr_uav,
-            .ptr_uav_aligned,
-            .ptr_comptime_alloc,
-            .ptr_comptime_field,
-            .ptr_int,
-            .ptr_eu_payload,
-            .ptr_opt_payload,
-            .ptr_elem,
-            .ptr_field,
-            .ptr_slice,
-            .opt_payload,
-            .opt_null,
-            .int_u8,
-            .int_u16,
-            .int_u32,
-            .int_i32,
-            .int_usize,
-            .int_comptime_int_u32,
-            .int_comptime_int_i32,
-            .int_small,
-            .int_positive,
-            .int_negative,
-            .int_lazy_align,
-            .int_lazy_size,
-            .error_set_error,
-            .error_union_error,
-            .error_union_payload,
-            .enum_literal,
-            .enum_tag,
-            .float_f16,
-            .float_f32,
-            .float_f64,
-            .float_f80,
-            .float_f128,
-            .float_c_longdouble_f80,
-            .float_c_longdouble_f128,
-            .float_comptime_float,
-            .variable,
-            .threadlocal_variable,
-            .@"extern",
-            .func_decl,
-            .func_instance,
-            .func_coerced,
-            .only_possible_value,
-            .union_value,
-            .bytes,
-            .aggregate,
-            .repeated,
-            // memoized value, not types
-            .memoized_call,
-            => unreachable,
-
-            .type_array_big,
-            .type_array_small,
-            .type_vector,
-            .type_enum_auto,
-            .type_enum_explicit,
-            .type_enum_nonexhaustive,
-            .type_struct,
-            .type_struct_packed,
-            .type_struct_packed_inits,
-            .type_tuple,
-            .type_union,
-            => switch (ip.indexToKey(ty.toIntern())) {
-                inline .array_type, .vector_type => |seq_type, seq_tag| {
-                    const has_sentinel = seq_tag == .array_type and seq_type.sentinel != .none;
-                    if (seq_type.len + @intFromBool(has_sentinel) == 0) return try pt.aggregateValue(ty, &.{});
-                    if (try sema.typeHasOnePossibleValue(.fromInterned(seq_type.child))) |opv| {
-                        return try pt.aggregateSplatValue(ty, opv);
-                    }
-                    return null;
-                },
-
-                .struct_type => {
-                    // Resolving the layout first helps to avoid loops.
-                    // If the type has a coherent layout, we can recurse through fields safely.
-                    try ty.resolveLayout(pt);
-
-                    const struct_type = ip.loadStructType(ty.toIntern());
-
-                    if (struct_type.field_types.len == 0) {
-                        // In this case the struct has no fields at all and
-                        // therefore has one possible value.
-                        return try pt.aggregateValue(ty, &.{});
-                    }
-
-                    const field_vals = try sema.arena.alloc(
-                        InternPool.Index,
-                        struct_type.field_types.len,
-                    );
-                    for (field_vals, 0..) |*field_val, i| {
-                        if (struct_type.fieldIsComptime(ip, i)) {
-                            try ty.resolveStructFieldInits(pt);
-                            field_val.* = struct_type.field_inits.get(ip)[i];
-                            continue;
-                        }
-                        const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[i]);
-                        if (try sema.typeHasOnePossibleValue(field_ty)) |field_opv| {
-                            field_val.* = field_opv.toIntern();
-                        } else return null;
-                    }
-
-                    // In this case the struct has no runtime-known fields and
-                    // therefore has one possible value.
-                    return try pt.aggregateValue(ty, field_vals);
-                },
-
-                .tuple_type => |tuple| {
-                    try ty.resolveLayout(pt);
-
-                    if (tuple.types.len == 0) {
-                        return try pt.aggregateValue(ty, &.{});
-                    }
-
-                    const field_vals = try sema.arena.alloc(
-                        InternPool.Index,
-                        tuple.types.len,
-                    );
-                    for (
-                        field_vals,
-                        tuple.types.get(ip),
-                        tuple.values.get(ip),
-                    ) |*field_val, field_ty, field_comptime_val| {
-                        if (field_comptime_val != .none) {
-                            field_val.* = field_comptime_val;
-                            continue;
-                        }
-                        if (try sema.typeHasOnePossibleValue(.fromInterned(field_ty))) |opv| {
-                            field_val.* = opv.toIntern();
-                        } else return null;
-                    }
-
-                    return try pt.aggregateValue(ty, field_vals);
-                },
-
-                .union_type => {
-                    // Resolving the layout first helps to avoid loops.
-                    // If the type has a coherent layout, we can recurse through fields safely.
-                    try ty.resolveLayout(pt);
-
-                    const union_obj = ip.loadUnionType(ty.toIntern());
-                    const tag_val = (try sema.typeHasOnePossibleValue(.fromInterned(union_obj.tagTypeUnordered(ip)))) orelse
-                        return null;
-                    if (union_obj.field_types.len == 0) {
-                        const only = try pt.intern(.{ .empty_enum_value = ty.toIntern() });
-                        return Value.fromInterned(only);
-                    }
-                    const only_field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[0]);
-                    const val_val = (try sema.typeHasOnePossibleValue(only_field_ty)) orelse
-                        return null;
-                    const only = try pt.internUnion(.{
-                        .ty = ty.toIntern(),
-                        .tag = tag_val.toIntern(),
-                        .val = val_val.toIntern(),
-                    });
-                    return Value.fromInterned(only);
-                },
-
-                .enum_type => {
-                    const enum_type = ip.loadEnumType(ty.toIntern());
-                    switch (enum_type.tag_mode) {
-                        .nonexhaustive => {
-                            if (enum_type.tag_ty == .comptime_int_type) return null;
-
-                            if (try sema.typeHasOnePossibleValue(.fromInterned(enum_type.tag_ty))) |int_opv| {
-                                const only = try pt.intern(.{ .enum_tag = .{
-                                    .ty = ty.toIntern(),
-                                    .int = int_opv.toIntern(),
-                                } });
-                                return Value.fromInterned(only);
-                            }
-
-                            return null;
-                        },
-                        .auto, .explicit => {
-                            if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(zcu)) return null;
-
-                            return Value.fromInterned(switch (enum_type.names.len) {
-                                0 => try pt.intern(.{ .empty_enum_value = ty.toIntern() }),
-                                1 => try pt.intern(.{ .enum_tag = .{
-                                    .ty = ty.toIntern(),
-                                    .int = if (enum_type.values.len == 0)
-                                        (try pt.intValue(.fromInterned(enum_type.tag_ty), 0)).toIntern()
-                                    else
-                                        try ip.getCoercedInts(
-                                            gpa,
-                                            io,
-                                            pt.tid,
-                                            ip.indexToKey(enum_type.values.get(ip)[0]).int,
-                                            enum_type.tag_ty,
-                                        ),
-                                } }),
-                                else => return null,
-                            });
-                        },
-                    }
-                },
-
-                else => unreachable,
-            },
-
-            .type_optional => {
-                const payload_ip = ip.indexToKey(ty.toIntern()).opt_type;
-                // Although ?noreturn is handled above, the element type
-                // can be effectively noreturn for example via an empty
-                // enum or error set.
-                if (ip.isNoReturn(payload_ip)) return try pt.nullValue(ty);
-                return null;
-            },
-        },
-    };
-}
-
 /// Returns the type of the AIR instruction.
 fn typeOf(sema: *Sema, inst: Air.Inst.Ref) Type {
     return sema.getTmpAir().typeOf(inst, &sema.pt.zcu.intern_pool);
@@ -36235,6 +33562,7 @@ fn isComptimeKnown(
     return (try sema.resolveValue(inst)) != null;
 }
 
+/// Asserts that the layout of `var_type` has already been resolved.
 fn analyzeComptimeAlloc(
     sema: *Sema,
     block: *Block,
@@ -36245,10 +33573,9 @@ fn analyzeComptimeAlloc(
     const pt = sema.pt;
     const zcu = pt.zcu;
 
-    // Needed to make an anon decl with type `var_type` (the `finish()` call below).
-    _ = try sema.typeHasOnePossibleValue(var_type);
+    var_type.assertHasLayout(zcu);
 
-    const ptr_type = try pt.ptrTypeSema(.{
+    const ptr_type = try pt.ptrType(.{
         .child = var_type.toIntern(),
         .flags = .{
             .alignment = alignment,
@@ -36256,13 +33583,23 @@ fn analyzeComptimeAlloc(
         },
     });
 
-    const alloc = try sema.newComptimeAlloc(block, src, var_type, alignment);
-
-    return Air.internedToRef((try pt.intern(.{ .ptr = .{
-        .ty = ptr_type.toIntern(),
-        .base_addr = .{ .comptime_alloc = alloc },
-        .byte_offset = 0,
-    } })));
+    if (try var_type.onePossibleValue(pt)) |opv| {
+        return .fromIntern(try pt.intern(.{ .ptr = .{
+            .ty = ptr_type.toIntern(),
+            .base_addr = .{ .uav = .{
+                .val = opv.toIntern(),
+                .orig_ty = ptr_type.toIntern(),
+            } },
+            .byte_offset = 0,
+        } }));
+    } else {
+        const alloc = try sema.newComptimeAlloc(block, src, var_type, alignment);
+        return .fromIntern(try pt.intern(.{ .ptr = .{
+            .ty = ptr_type.toIntern(),
+            .base_addr = .{ .comptime_alloc = alloc },
+            .byte_offset = 0,
+        } }));
+    }
 }
 
 fn resolveAddressSpace(
@@ -36363,40 +33700,6 @@ fn usizeCast(sema: *Sema, block: *Block, src: LazySrcLoc, int: u64) CompileError
     return std.math.cast(usize, int) orelse return sema.fail(block, src, "expression produces integer value '{d}' which is too big for this compiler implementation to handle", .{int});
 }
 
-/// For pointer-like optionals, it returns the pointer type. For pointers,
-/// the type is returned unmodified.
-/// This can return `error.AnalysisFail` because it sometimes requires resolving whether
-/// a type has zero bits, which can cause a "foo depends on itself" compile error.
-/// This logic must be kept in sync with `Type.isPtrLikeOptional`.
-fn typePtrOrOptionalPtrTy(sema: *Sema, ty: Type) !?Type {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-            .one, .many, .c => ty,
-            .slice => null,
-        },
-        .opt_type => |opt_child| switch (zcu.intern_pool.indexToKey(opt_child)) {
-            .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-                .slice, .c => null,
-                .many, .one => {
-                    if (ptr_type.flags.is_allowzero) return null;
-
-                    // optionals of zero sized types behave like bools, not pointers
-                    const payload_ty: Type = .fromInterned(opt_child);
-                    if ((try sema.typeHasOnePossibleValue(payload_ty)) != null) {
-                        return null;
-                    }
-
-                    return payload_ty;
-                },
-            },
-            else => null,
-        },
-        else => null,
-    };
-}
-
 fn unionFieldIndex(
     sema: *Sema,
     block: *Block,
@@ -36407,9 +33710,9 @@ fn unionFieldIndex(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    try union_ty.resolveFields(pt);
     const union_obj = zcu.typeToUnion(union_ty).?;
-    const field_index = union_obj.loadTagType(ip).nameIndex(ip, field_name) orelse
+    const enum_obj = ip.loadEnumType(union_obj.enum_tag_type);
+    const field_index = enum_obj.nameIndex(ip, field_name) orelse
         return sema.failWithBadUnionFieldAccess(block, union_ty, union_obj, field_src, field_name);
     return @intCast(field_index);
 }
@@ -36424,7 +33727,6 @@ fn structFieldIndex(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    try struct_ty.resolveFields(pt);
     const struct_type = zcu.typeToStruct(struct_ty).?;
     return struct_type.nameIndex(ip, field_name) orelse
         return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_src, field_name);
@@ -36513,6 +33815,7 @@ fn intFromFloatScalar(
 /// Vectors are also accepted. Vector results are reduced with AND.
 ///
 /// If provided, `vector_index` reports the first element that failed the range check.
+/// MLUGG TODO: move to `Value` or `Type`?
 fn intFitsInType(
     sema: *Sema,
     val: Value,
@@ -36535,30 +33838,10 @@ fn intFitsInType(
                     .unsigned => info.bits >= ptr_bits,
                 };
             },
-            .int => |int| switch (int.storage) {
-                .u64, .i64, .big_int => {
-                    var buffer: InternPool.Key.Int.Storage.BigIntSpace = undefined;
-                    const big_int = int.storage.toBigInt(&buffer);
-                    return big_int.fitsInTwosComp(info.signedness, info.bits);
-                },
-                .lazy_align => |lazy_ty| {
-                    const max_needed_bits = @as(u16, 16) + @intFromBool(info.signedness == .signed);
-                    // If it is u16 or bigger we know the alignment fits without resolving it.
-                    if (info.bits >= max_needed_bits) return true;
-                    const x = try Type.fromInterned(lazy_ty).abiAlignmentSema(pt);
-                    if (x == .none) return true;
-                    const actual_needed_bits = @as(usize, x.toLog2Units()) + 1 + @intFromBool(info.signedness == .signed);
-                    return info.bits >= actual_needed_bits;
-                },
-                .lazy_size => |lazy_ty| {
-                    const max_needed_bits = @as(u16, 64) + @intFromBool(info.signedness == .signed);
-                    // If it is u64 or bigger we know the size fits without resolving it.
-                    if (info.bits >= max_needed_bits) return true;
-                    const x = try Type.fromInterned(lazy_ty).abiSizeSema(pt);
-                    if (x == 0) return true;
-                    const actual_needed_bits = std.math.log2(x) + 1 + @intFromBool(info.signedness == .signed);
-                    return info.bits >= actual_needed_bits;
-                },
+            .int => |int| {
+                var buffer: InternPool.Key.Int.Storage.BigIntSpace = undefined;
+                const big_int = int.storage.toBigInt(&buffer);
+                return big_int.fitsInTwosComp(info.signedness, info.bits);
             },
             .aggregate => |aggregate| {
                 assert(ty.zigTypeTag(zcu) == .vector);
@@ -36588,23 +33871,23 @@ fn intFitsInType(
 
 fn intInRange(sema: *Sema, tag_ty: Type, int_val: Value, end: usize) !bool {
     const pt = sema.pt;
-    if (!(try int_val.compareAllWithZeroSema(.gte, pt))) return false;
+    if (!int_val.compareAllWithZero(.gte, pt.zcu)) return false;
     const end_val = try pt.intValue(tag_ty, end);
     if (!(try sema.compareAll(int_val, .lt, end_val, tag_ty))) return false;
     return true;
 }
 
-/// Asserts the type is an enum.
+/// Asserts the type is an exhaustive enum.
 fn enumHasInt(sema: *Sema, ty: Type, int: Value) CompileError!bool {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const enum_type = zcu.intern_pool.loadEnumType(ty.toIntern());
-    assert(enum_type.tag_mode != .nonexhaustive);
+    assert(!enum_type.nonexhaustive);
     // The `tagValueIndex` function call below relies on the type being the integer tag type.
     // `getCoerced` assumes the value will fit the new type.
-    if (!(try sema.intFitsInType(int, .fromInterned(enum_type.tag_ty), null))) return false;
-    const int_coerced = try pt.getCoerced(int, .fromInterned(enum_type.tag_ty));
-
+    const int_tag_ty: Type = .fromInterned(enum_type.int_tag_type);
+    if (!try sema.intFitsInType(int, int_tag_ty, null)) return false;
+    const int_coerced = try pt.getCoerced(int, int_tag_ty);
     return enum_type.tagValueIndex(&zcu.intern_pool, int_coerced.toIntern()) != null;
 }
 
@@ -36636,6 +33919,7 @@ fn compareAll(
 }
 
 /// Asserts the values are comparable. Both operands have type `ty`.
+/// MLUGG TODO: move to `Value`?
 fn compareScalar(
     sema: *Sema,
     lhs: Value,
@@ -36644,17 +33928,19 @@ fn compareScalar(
     ty: Type,
 ) CompileError!bool {
     const pt = sema.pt;
+    const zcu = pt.zcu;
+
     const coerced_lhs = try pt.getCoerced(lhs, ty);
     const coerced_rhs = try pt.getCoerced(rhs, ty);
 
     // Equality comparisons of signed zero and NaN need to use floating point semantics
-    if (coerced_lhs.isFloat(pt.zcu) or coerced_rhs.isFloat(pt.zcu))
-        return Value.compareHeteroSema(coerced_lhs, op, coerced_rhs, pt);
+    if (coerced_lhs.isFloat(zcu) or coerced_rhs.isFloat(zcu))
+        return Value.compareHetero(coerced_lhs, op, coerced_rhs, zcu);
 
     switch (op) {
-        .eq => return sema.valuesEqual(coerced_lhs, coerced_rhs, ty),
-        .neq => return !(try sema.valuesEqual(coerced_lhs, coerced_rhs, ty)),
-        else => return Value.compareHeteroSema(coerced_lhs, op, coerced_rhs, pt),
+        .eq => return Value.eql(coerced_lhs, coerced_rhs, ty, zcu),
+        .neq => return !Value.eql(coerced_lhs, coerced_rhs, ty, zcu),
+        else => return Value.compareHetero(coerced_lhs, op, coerced_rhs, zcu),
     }
 }
 
@@ -36799,7 +34085,7 @@ fn validateRuntimeValue(sema: *Sema, block: *Block, val_src: LazySrcLoc, val: Ai
     });
 }
 
-fn failWithContainsReferenceToComptimeVar(sema: *Sema, block: *Block, src: LazySrcLoc, value_name: InternPool.NullTerminatedString, kind_of_value: []const u8, val: ?Value) CompileError {
+pub fn failWithContainsReferenceToComptimeVar(sema: *Sema, block: *Block, src: LazySrcLoc, value_name: InternPool.NullTerminatedString, kind_of_value: []const u8, val: ?Value) CompileError {
     return sema.failWithOwnedErrorMsg(block, msg: {
         const msg = try sema.errMsg(src, "{s} contains reference to comptime var", .{kind_of_value});
         errdefer msg.destroy(sema.gpa);
@@ -36867,11 +34153,7 @@ fn notePathToComptimeAllocPtr(
         else => {}, // there will be another stage
     }
 
-    const derivation = comptime_ptr.pointerDerivationAdvanced(arena, pt, false, sema) catch |err| switch (err) {
-        error.OutOfMemory => |e| return e,
-        error.Canceled => @panic("TODO"), // pls don't be cancelable mlugg
-        error.AnalysisFail => unreachable,
-    };
+    const derivation = try comptime_ptr.pointerDerivationAdvanced(arena, pt, false, sema);
 
     var second_path_aw: std.Io.Writer.Allocating = .init(arena);
     defer second_path_aw.deinit();
@@ -37058,12 +34340,12 @@ fn maybeDerefSliceAsArray(
         else => unreachable,
     };
     const elem_ty = Type.fromInterned(slice.ty).childType(zcu);
-    const len = try Value.fromInterned(slice.len).toUnsignedIntSema(pt);
+    const len = Value.fromInterned(slice.len).toUnsignedInt(zcu);
     const array_ty = try pt.arrayType(.{
         .child = elem_ty.toIntern(),
         .len = len,
     });
-    const ptr_ty = try pt.ptrTypeSema(p: {
+    const ptr_ty = try pt.ptrType(p: {
         var p = Type.fromInterned(slice.ty).ptrInfo(zcu);
         p.flags.size = .one;
         p.child = array_ty.toIntern();
@@ -37129,238 +34411,6 @@ pub fn flushExports(sema: *Sema) !void {
     }
 }
 
-/// Called as soon as a `declared` enum type is created.
-/// Resolves the tag type and field inits.
-/// Marks the `src_inst` dependency on the enum's declaration, so call sites need not do this.
-pub fn resolveDeclaredEnum(
-    pt: Zcu.PerThread,
-    wip_ty: InternPool.WipEnumType,
-    inst: Zir.Inst.Index,
-    tracked_inst: InternPool.TrackedInst.Index,
-    namespace: InternPool.NamespaceIndex,
-    type_name: InternPool.NullTerminatedString,
-    small: Zir.Inst.EnumDecl.Small,
-    body: []const Zir.Inst.Index,
-    tag_type_ref: Zir.Inst.Ref,
-    any_values: bool,
-    fields_len: u32,
-    zir: Zir,
-    body_end: usize,
-) Zcu.SemaError!void {
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
-
-    const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(.zero) };
-
-    var arena: std.heap.ArenaAllocator = .init(gpa);
-    defer arena.deinit();
-
-    var comptime_err_ret_trace: std.array_list.Managed(Zcu.LazySrcLoc) = .init(gpa);
-    defer comptime_err_ret_trace.deinit();
-
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = arena.allocator(),
-        .code = zir,
-        .owner = .wrap(.{ .type = wip_ty.index }),
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = .void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
-
-    if (zcu.comp.debugIncremental()) {
-        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, sema.owner);
-        info.last_update_gen = zcu.generation;
-    }
-
-    try sema.declareDependency(.{ .src_hash = tracked_inst });
-
-    var block: Block = .{
-        .parent = null,
-        .sema = &sema,
-        .namespace = namespace,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = .{ .reason = .{
-            .src = src,
-            .r = .{ .simple = .enum_field_values },
-        } },
-        .src_base_inst = tracked_inst,
-        .type_name_ctx = type_name,
-    };
-    defer block.instructions.deinit(gpa);
-
-    sema.resolveDeclaredEnumInner(
-        &block,
-        wip_ty,
-        inst,
-        tracked_inst,
-        src,
-        small,
-        body,
-        tag_type_ref,
-        any_values,
-        fields_len,
-        zir,
-        body_end,
-    ) catch |err| switch (err) {
-        error.ComptimeBreak => unreachable,
-        error.ComptimeReturn => unreachable,
-        error.OutOfMemory, error.Canceled => |e| return e,
-        error.AnalysisFail => {
-            if (!zcu.failed_analysis.contains(sema.owner)) {
-                try zcu.transitive_failed_analysis.put(gpa, sema.owner, {});
-            }
-            return error.AnalysisFail;
-        },
-    };
-}
-
-fn resolveDeclaredEnumInner(
-    sema: *Sema,
-    block: *Block,
-    wip_ty: InternPool.WipEnumType,
-    inst: Zir.Inst.Index,
-    tracked_inst: InternPool.TrackedInst.Index,
-    src: LazySrcLoc,
-    small: Zir.Inst.EnumDecl.Small,
-    body: []const Zir.Inst.Index,
-    tag_type_ref: Zir.Inst.Ref,
-    any_values: bool,
-    fields_len: u32,
-    zir: Zir,
-    body_end: usize,
-) Zcu.CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const bit_bags_count = std.math.divCeil(usize, fields_len, 32) catch unreachable;
-
-    const tag_ty_src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = .{ .node_offset_container_tag = .zero } };
-
-    const int_tag_ty = ty: {
-        if (body.len != 0) {
-            _ = try sema.analyzeInlineBody(block, body, inst);
-        }
-
-        if (tag_type_ref != .none) {
-            const ty = try sema.resolveType(block, tag_ty_src, tag_type_ref);
-            if (ty.zigTypeTag(zcu) != .int and ty.zigTypeTag(zcu) != .comptime_int) {
-                return sema.fail(block, tag_ty_src, "expected integer tag type, found '{f}'", .{ty.fmt(pt)});
-            }
-            break :ty ty;
-        } else if (fields_len == 0) {
-            break :ty try pt.intType(.unsigned, 0);
-        } else {
-            const bits = std.math.log2_int_ceil(usize, fields_len);
-            break :ty try pt.intType(.unsigned, bits);
-        }
-    };
-
-    wip_ty.setTagTy(ip, int_tag_ty.toIntern());
-
-    var extra_index = body_end + bit_bags_count;
-    var bit_bag_index: usize = body_end;
-    var cur_bit_bag: u32 = undefined;
-    var last_tag_val: ?Value = null;
-    for (0..fields_len) |field_i_usize| {
-        const field_i: u32 = @intCast(field_i_usize);
-        if (field_i % 32 == 0) {
-            cur_bit_bag = zir.extra[bit_bag_index];
-            bit_bag_index += 1;
-        }
-        const has_tag_value = @as(u1, @truncate(cur_bit_bag)) != 0;
-        cur_bit_bag >>= 1;
-
-        const field_name_index: Zir.NullTerminatedString = @enumFromInt(zir.extra[extra_index]);
-        const field_name_zir = zir.nullTerminatedString(field_name_index);
-        extra_index += 1; // field name
-
-        const field_name = try ip.getOrPutString(gpa, io, pt.tid, field_name_zir, .no_embedded_nulls);
-
-        const value_src: LazySrcLoc = .{
-            .base_node_inst = tracked_inst,
-            .offset = .{ .container_field_value = field_i },
-        };
-
-        const tag_overflow = if (has_tag_value) overflow: {
-            const tag_val_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-            extra_index += 1;
-            const tag_inst = try sema.resolveInst(tag_val_ref);
-            last_tag_val = try sema.resolveConstDefinedValue(block, .{
-                .base_node_inst = tracked_inst,
-                .offset = .{ .container_field_name = field_i },
-            }, tag_inst, .{ .simple = .enum_field_tag_value });
-            if (!(try sema.intFitsInType(last_tag_val.?, int_tag_ty, null))) break :overflow true;
-            last_tag_val = try pt.getCoerced(last_tag_val.?, int_tag_ty);
-            if (wip_ty.nextField(ip, field_name, last_tag_val.?.toIntern())) |conflict| {
-                assert(conflict.kind == .value); // AstGen validated names are unique
-                const other_field_src: LazySrcLoc = .{
-                    .base_node_inst = tracked_inst,
-                    .offset = .{ .container_field_value = conflict.prev_field_idx },
-                };
-                const msg = msg: {
-                    const msg = try sema.errMsg(value_src, "enum tag value {f} already taken", .{last_tag_val.?.fmtValueSema(pt, sema)});
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(other_field_src, msg, "other occurrence here", .{});
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(block, msg);
-            }
-            break :overflow false;
-        } else if (any_values) overflow: {
-            if (last_tag_val) |last_tag| {
-                const result = try arith.incrementDefinedInt(sema, int_tag_ty, last_tag);
-                last_tag_val = result.val;
-                if (result.overflow) break :overflow true;
-            } else {
-                last_tag_val = try pt.intValue(int_tag_ty, 0);
-            }
-            if (wip_ty.nextField(ip, field_name, last_tag_val.?.toIntern())) |conflict| {
-                assert(conflict.kind == .value); // AstGen validated names are unique
-                const other_field_src: LazySrcLoc = .{
-                    .base_node_inst = tracked_inst,
-                    .offset = .{ .container_field_value = conflict.prev_field_idx },
-                };
-                const msg = msg: {
-                    const msg = try sema.errMsg(value_src, "enum tag value {f} already taken", .{last_tag_val.?.fmtValueSema(pt, sema)});
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(other_field_src, msg, "other occurrence here", .{});
-                    break :msg msg;
-                };
-                return sema.failWithOwnedErrorMsg(block, msg);
-            }
-            break :overflow false;
-        } else overflow: {
-            assert(wip_ty.nextField(ip, field_name, .none) == null);
-            last_tag_val = try pt.intValue(.comptime_int, field_i);
-            if (!try sema.intFitsInType(last_tag_val.?, int_tag_ty, null)) break :overflow true;
-            last_tag_val = try pt.getCoerced(last_tag_val.?, int_tag_ty);
-            break :overflow false;
-        };
-
-        if (tag_overflow) {
-            const msg = try sema.errMsg(value_src, "enumeration value '{f}' too large for type '{f}'", .{
-                last_tag_val.?.fmtValueSema(pt, sema), int_tag_ty.fmt(pt),
-            });
-            return sema.failWithOwnedErrorMsg(block, msg);
-        }
-    }
-    if (small.nonexhaustive and int_tag_ty.toIntern() != .comptime_int_type) {
-        if (fields_len >= 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(zcu)) {
-            return sema.fail(block, src, "non-exhaustive enum specifies every value", .{});
-        }
-    }
-}
-
 pub const bitCastVal = @import("Sema/bitcast.zig").bitCast;
 pub const bitCastSpliceVal = @import("Sema/bitcast.zig").bitCastSplice;
 
@@ -37369,6 +34419,11 @@ const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadR
 const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr;
 const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult;
 
+// MLUGG TODO: decide how to do the namespacing here
+pub const type_resolution = @import("Sema/type_resolution.zig");
+pub const ensureLayoutResolved = type_resolution.ensureLayoutResolved;
+pub const ensureFieldInitsResolved = type_resolution.ensureFieldInitsResolved;
+
 pub fn getBuiltinType(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) SemaError!Type {
     assert(decl.kind() == .type);
     try sema.ensureMemoizedStateResolved(src, decl.stage());
@@ -37483,11 +34538,11 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, simple_src: LazySrcLoc,
             const result = try sema.analyzeNavVal(block, src, nav);
 
             const uncoerced_val = try sema.resolveConstDefinedValue(block, src, result, null);
-            const maybe_lazy_val: Value = switch (builtin_decl.kind()) {
+            const val: Value = switch (builtin_decl.kind()) {
                 .type => if (uncoerced_val.typeOf(zcu).zigTypeTag(zcu) != .type) {
                     return sema.fail(block, src, "{s}.{s} is not a type", .{ parent_name, name });
                 } else val: {
-                    try uncoerced_val.toType().resolveFully(pt);
+                    try sema.ensureLayoutResolved(uncoerced_val.toType());
                     break :val uncoerced_val;
                 },
                 .func => val: {
@@ -37500,7 +34555,6 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, simple_src: LazySrcLoc,
                     break :val .fromInterned(coerced.toInterned().?);
                 },
             };
-            const val = try sema.resolveLazyValue(maybe_lazy_val);
 
             const prev = zcu.builtin_decl_values.get(builtin_decl);
             if (val.toIntern() != prev) {
@@ -37539,7 +34593,6 @@ fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Typ
         => try pt.funcType(.{
             .param_types = &.{ .generic_poison_type, .generic_poison_type },
             .return_type = .noreturn_type,
-            .is_generic = true,
         }),
 
         // `fn (anyerror) noreturn`
@@ -37590,3 +34643,823 @@ fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Typ
         else => unreachable,
     };
 }
+
+/// TODO MLUGG: this is a gnarly hack
+const PartialTypeName = union(enum) {
+    exact: struct {
+        name: InternPool.NullTerminatedString,
+        nav: InternPool.Nav.Index.Optional,
+    },
+    anon_prefix: []const u8,
+    fn apply(
+        name: PartialTypeName,
+        wip: *const InternPool.WipContainerType,
+        pt: Zcu.PerThread,
+    ) (Allocator.Error || std.Io.Cancelable)!InternPool.NullTerminatedString {
+        const zcu = pt.zcu;
+        const comp = zcu.comp;
+        const ip = &zcu.intern_pool;
+        switch (name) {
+            .exact => |e| {
+                wip.setName(ip, e.name, e.nav);
+                return e.name;
+            },
+            .anon_prefix => |prefix| {
+                const resolved_name = try ip.getOrPutStringFmt(
+                    comp.gpa,
+                    comp.io,
+                    pt.tid,
+                    "{s}_{d}",
+                    .{ prefix, @intFromEnum(wip.index) },
+                    .no_embedded_nulls,
+                );
+                wip.setName(ip, resolved_name, .none);
+                return resolved_name;
+            },
+        }
+    }
+};
+pub fn createTypeName(
+    sema: *Sema,
+    block: *Block,
+    name_strategy: Zir.Inst.NameStrategy,
+    anon_prefix: []const u8,
+    inst: Zir.Inst.Index,
+) CompileError!PartialTypeName {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    switch (name_strategy) {
+        .anon => {}, // handled after switch
+        .parent => return .{ .exact = .{
+            .name = block.type_name_ctx,
+            .nav = sema.owner.unwrap().nav_val.toOptional(),
+        } },
+        .func => func_strat: {
+            const fn_info = sema.code.getFnInfo(ip.funcZirBodyInst(sema.func_index).resolve(ip) orelse return error.AnalysisFail);
+            const zir_tags = sema.code.instructions.items(.tag);
+
+            var aw: std.Io.Writer.Allocating = .init(gpa);
+            defer aw.deinit();
+            const w = &aw.writer;
+            w.print("{f}(", .{block.type_name_ctx.fmt(ip)}) catch return error.OutOfMemory;
+
+            var arg_i: usize = 0;
+            for (fn_info.param_body) |zir_inst| switch (zir_tags[@intFromEnum(zir_inst)]) {
+                .param, .param_comptime, .param_anytype, .param_anytype_comptime => {
+                    const arg = sema.inst_map.get(zir_inst).?;
+                    // If this is being called in a generic function then analyzeCall will
+                    // have already resolved the args and this will work.
+                    // If not then this is a struct type being returned from a non-generic
+                    // function and the name doesn't matter since it will later
+                    // result in a compile error.
+                    const arg_val = try sema.resolveValue(arg) orelse break :func_strat; // fall through to anon strat
+
+                    if (arg_i != 0) w.writeByte(',') catch return error.OutOfMemory;
+
+                    // Limiting the depth here helps avoid type names getting too long, which
+                    // in turn helps to avoid unreasonably long symbol names for namespaced
+                    // symbols. Such names should ideally be human-readable, and additionally,
+                    // some tooling may not support very long symbol names.
+                    w.print("{f}", .{Value.fmtValueSemaFull(.{
+                        .val = arg_val,
+                        .pt = pt,
+                        .opt_sema = sema,
+                        .depth = 1,
+                    })}) catch return error.OutOfMemory;
+
+                    arg_i += 1;
+                    continue;
+                },
+                else => continue,
+            };
+
+            w.writeByte(')') catch return error.OutOfMemory;
+            return .{ .exact = .{
+                .name = try ip.getOrPutString(gpa, io, pt.tid, aw.written(), .no_embedded_nulls),
+                .nav = .none,
+            } };
+        },
+        .dbg_var => {
+            // TODO: this logic is questionable. We ideally should be traversing the `Block` rather than relying on the order of AstGen instructions.
+            const ref = inst.toRef();
+            const zir_tags = sema.code.instructions.items(.tag);
+            const zir_data = sema.code.instructions.items(.data);
+            for (@intFromEnum(inst)..zir_tags.len) |i| switch (zir_tags[i]) {
+                .dbg_var_ptr, .dbg_var_val => if (zir_data[i].str_op.operand == ref) {
+                    return .{ .exact = .{
+                        .name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{f}.{s}", .{
+                            block.type_name_ctx.fmt(ip), zir_data[i].str_op.getStr(sema.code),
+                        }, .no_embedded_nulls),
+                        .nav = .none,
+                    } };
+                },
+                else => {},
+            };
+            // fall through to anon strat
+        },
+    }
+
+    // anon strat handling
+
+    // It would be neat to have "struct:line:column" but this name has
+    // to survive incremental updates, where it may have been shifted down
+    // or up to a different line, but unchanged, and thus not unnecessarily
+    // semantically analyzed.
+    // TODO: that would be possible, by detecting line number changes and renaming
+    // types appropriately. However, `@typeName` becomes a problem then. If we remove
+    // that builtin from the language, we can consider this.
+
+    return .{ .anon_prefix = try std.fmt.allocPrint(
+        sema.arena,
+        "{f}__{s}",
+        .{ block.type_name_ctx.fmt(ip), anon_prefix },
+    ) };
+}
+
+pub fn analyzeStructDecl(
+    pt: Zcu.PerThread,
+    file_index: Zcu.File.Index,
+    zir: *const Zir,
+    parent_namespace: InternPool.OptionalNamespaceIndex,
+    tracked_inst: InternPool.TrackedInst.Index,
+    struct_decl: *const Zir.UnwrappedStructDecl,
+    explicit_backing_type: ?Type,
+    captures: []const InternPool.CaptureValue,
+    type_name: PartialTypeName,
+) (Allocator.Error || std.Io.Cancelable)!Type {
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    const wip = switch (try ip.getStructType(gpa, io, pt.tid, .{
+        .fields_len = @intCast(struct_decl.field_names.len),
+        .layout = struct_decl.layout,
+        .explicit_packed_backing_type = if (explicit_backing_type) |ty| ty.toIntern() else .none,
+        .any_comptime_fields = struct_decl.field_comptime_bits != null,
+        .any_field_defaults = struct_decl.field_default_body_lens != null,
+        .any_field_aligns = struct_decl.field_align_body_lens != null,
+        .key = .{ .declared = .{
+            .zir_index = tracked_inst,
+            .captures = captures,
+        } },
+    })) {
+        .existing => |ty| return .fromInterned(ty),
+        .wip => |wip| wip,
+    };
+    errdefer wip.cancel(ip, pt.tid);
+
+    _ = try type_name.apply(&wip, pt);
+
+    var field_it = struct_decl.iterateFields();
+    while (field_it.next()) |field| {
+        const name_slice = zir.nullTerminatedString(field.name);
+        const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
+        assert(wip.nextField(ip, name, field.is_comptime) == null); // AstGen validated this for us
+    }
+
+    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+        .parent = parent_namespace,
+        .owner_type = wip.index,
+        .file_scope = file_index,
+        .generation = zcu.generation,
+    });
+    errdefer pt.destroyNamespace(new_namespace_index);
+
+    try pt.scanNamespace(new_namespace_index, struct_decl.decls);
+
+    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_inits = wip.index }) });
+
+    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+
+    try zcu.outdated.ensureUnusedCapacity(gpa, 2);
+    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
+    errdefer comptime unreachable; // because we don't remove the `outdated` entries
+    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), 0);
+    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), {});
+
+    return .fromInterned(wip.finish(ip, new_namespace_index));
+}
+const AnalyzeUnionDeclError = error{
+    OutOfMemory,
+    Canceled,
+    /// `packed union(T)` syntax was used, but `T` was not an integer type.
+    ExplicitBackingNotInt,
+    /// `union(enum(T))` syntax was used, but `T` was not an integer type.
+    ExplicitTagNotInt,
+    /// `union(T)` syntax was used, but `T` was not an enum type.
+    ExplicitTagNotEnum,
+    /// `union(T)` syntax was used, but the fields of the union do not exactly
+    /// correspond to the fields of the enum `T`.
+    ExplicitTagFieldMismatch,
+};
+fn analyzeUnionDecl(
+    pt: Zcu.PerThread,
+    file_index: Zcu.File.Index,
+    zir: *const Zir,
+    parent_namespace: InternPool.OptionalNamespaceIndex,
+    want_safe_types: bool,
+    tracked_inst: InternPool.TrackedInst.Index,
+    union_decl: *const Zir.UnwrappedUnionDecl,
+    arg_type: ?Type,
+    captures: []const InternPool.CaptureValue,
+    type_name: PartialTypeName,
+) AnalyzeUnionDeclError!Type {
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    switch (union_decl.kind) {
+        .tagged_explicit => if (arg_type.?.zigTypeTag(zcu) != .@"enum") {
+            return error.ExplicitTagNotEnum;
+        },
+        .tagged_enum_explicit => if (arg_type.?.zigTypeTag(zcu) != .int) {
+            return error.ExplicitTagNotInt;
+        },
+        .packed_explicit => if (arg_type.?.zigTypeTag(zcu) != .int) {
+            return error.ExplicitBackingNotInt;
+        },
+        .auto,
+        .tagged_enum,
+        .@"extern",
+        .@"packed",
+        => assert(arg_type == null),
+    }
+
+    const wip = switch (try ip.getUnionType(gpa, io, pt.tid, .{
+        .fields_len = @intCast(union_decl.field_names.len),
+        .layout = union_decl.kind.layout(),
+        .explicit_packed_backing_type = switch (union_decl.kind) {
+            .packed_explicit => arg_type.?.toIntern(),
+            else => .none,
+        },
+        .runtime_tag = switch (union_decl.kind) {
+            .auto => if (want_safe_types) .safety else .none,
+
+            .tagged_explicit,
+            .tagged_enum,
+            .tagged_enum_explicit,
+            => .tagged,
+
+            .@"extern",
+            .@"packed",
+            .packed_explicit,
+            => .none,
+        },
+        .have_explicit_enum_tag = union_decl.kind == .tagged_explicit,
+        .any_field_aligns = union_decl.field_align_body_lens != null,
+        .key = .{ .declared = .{
+            .zir_index = tracked_inst,
+            .captures = captures,
+            .arg_ty = if (arg_type) |t| t.toIntern() else .none,
+        } },
+    })) {
+        .existing => |ty| return .fromInterned(ty),
+        .wip => |wip| wip,
+    };
+    errdefer wip.cancel(ip, pt.tid);
+
+    const resolved_type_name = try type_name.apply(&wip, pt);
+
+    const generated_tag_ty: InternPool.Index = if (union_decl.kind == .tagged_explicit) generated_tag_ty: {
+        const tag_type = arg_type.?;
+        const enum_field_names = ip.loadEnumType(tag_type.toIntern()).field_names;
+        // Check that the enum field names match the union field names
+        if (union_decl.field_names.len != enum_field_names.len) {
+            return error.ExplicitTagFieldMismatch;
+        }
+        for (union_decl.field_names, enum_field_names.get(ip)) |union_field_zir, enum_field_ip| {
+            const union_field_name = zir.nullTerminatedString(union_field_zir);
+            const enum_field_name = enum_field_ip.toSlice(ip);
+            if (!std.mem.eql(u8, union_field_name, enum_field_name)) {
+                return error.ExplicitTagFieldMismatch;
+            }
+        }
+        wip.setTagType(ip, tag_type.toIntern());
+        break :generated_tag_ty .none;
+    } else generated_tag_ty: {
+        // Generate a tag type. Even if the union is untagged (`.none`), we still generate a
+        // hypothetical tag type.
+        const wip_tag_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
+            .fields_len = @intCast(union_decl.field_names.len),
+            .explicit_int_tag_type = switch (union_decl.kind) {
+                .tagged_enum_explicit => arg_type.?.toIntern(),
+                else => .none,
+            },
+            .nonexhaustive = false,
+            .key = .{ .generated_union_tag = wip.index },
+        })) {
+            .existing => unreachable, // enum type is keyed on this union type which we're only just creating
+            .wip => |wip_tag_ty| wip_tag_ty,
+        };
+        errdefer wip_tag_ty.cancel(ip, pt.tid);
+        // Populate the generated tag type's name
+        const tag_type_name = try ip.getOrPutStringFmt(
+            gpa,
+            io,
+            pt.tid,
+            "@typeInfo({f}).@\"union\".tag_type.?",
+            .{resolved_type_name.fmt(ip)},
+            .no_embedded_nulls,
+        );
+        wip_tag_ty.setName(ip, tag_type_name, .none);
+        // Populate the generated tag type's field names
+        for (union_decl.field_names) |zir_name| {
+            const name_slice = zir.nullTerminatedString(zir_name);
+            const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
+            assert(wip_tag_ty.nextField(ip, name, false) == null); // AstGen validated this for us
+        }
+        // If not explicitly given, populate the generated tag type's *integer* tag type
+        switch (union_decl.kind) {
+            .tagged_enum_explicit => {}, // already set by `getEnumType`
+            else => {
+                // Infer the int tag type from the field count
+                const bits = Type.smallestUnsignedBits(union_decl.field_names.len -| 1);
+                const int_tag_type = try pt.intType(.unsigned, bits);
+                wip_tag_ty.setTagType(ip, int_tag_type.toIntern());
+            },
+        }
+        // Create a dummy namespace for the generated tag type
+        const new_namespace_index = try pt.createNamespace(.{
+            .parent = parent_namespace,
+            .owner_type = wip_tag_ty.index,
+            .file_scope = file_index,
+            .generation = zcu.generation,
+        });
+        errdefer pt.destroyNamespace(new_namespace_index);
+        wip.setTagType(ip, wip_tag_ty.index);
+        break :generated_tag_ty wip_tag_ty.finish(ip, new_namespace_index);
+    };
+    // If we fail to create the union type, we must delete the generated enum tag type, since it
+    // would hold a reference to the deleted union.
+    errdefer if (generated_tag_ty != .none) ip.remove(pt.tid, generated_tag_ty);
+
+    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+        .parent = parent_namespace,
+        .owner_type = wip.index,
+        .file_scope = file_index,
+        .generation = zcu.generation,
+    });
+    errdefer pt.destroyNamespace(new_namespace_index);
+
+    try pt.scanNamespace(new_namespace_index, union_decl.decls);
+
+    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
+    if (generated_tag_ty != .none) {
+        try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_inits = generated_tag_ty }) });
+    }
+
+    if (zcu.comp.debugIncremental()) {
+        try zcu.incremental_debug_state.newType(zcu, wip.index);
+        if (generated_tag_ty != .none) {
+            try zcu.incremental_debug_state.newType(zcu, generated_tag_ty);
+        }
+    }
+
+    try zcu.outdated.ensureUnusedCapacity(gpa, 2);
+    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
+    errdefer comptime unreachable; // because we don't remove the `outdated` entry
+    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+    if (generated_tag_ty != .none) {
+        zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = generated_tag_ty }), 0);
+        zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = generated_tag_ty }), {});
+    }
+
+    return .fromInterned(wip.finish(ip, new_namespace_index));
+}
+const AnalyzeEnumDeclError = error{
+    OutOfMemory,
+    Canceled,
+    /// `enum(T)` syntax was used, but `T` was not an integer type.
+    ExplicitTagNotInt,
+};
+fn analyzeEnumDecl(
+    pt: Zcu.PerThread,
+    file_index: Zcu.File.Index,
+    zir: *const Zir,
+    parent_namespace: InternPool.OptionalNamespaceIndex,
+    tracked_inst: InternPool.TrackedInst.Index,
+    enum_decl: *const Zir.UnwrappedEnumDecl,
+    explicit_tag_type: ?Type,
+    captures: []const InternPool.CaptureValue,
+    type_name: PartialTypeName,
+) AnalyzeEnumDeclError!Type {
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    if (explicit_tag_type) |ty| {
+        // MLUGG TODO: make a final call on whether comptime_int is a valid int tag type, and follow it everywhere.
+        // i think not in the name of simplicity, but my opinion might depend on whether it's broken in practice today
+        switch (ty.zigTypeTag(zcu)) {
+            .int, .comptime_int => {},
+            else => return error.ExplicitTagNotInt,
+        }
+    }
+
+    const wip = switch (try ip.getEnumType(gpa, io, pt.tid, .{
+        .fields_len = @intCast(enum_decl.field_names.len),
+        .explicit_int_tag_type = if (explicit_tag_type) |ty| ty.toIntern() else .none,
+        .nonexhaustive = enum_decl.nonexhaustive,
+        .key = .{ .declared = .{
+            .zir_index = tracked_inst,
+            .captures = captures,
+        } },
+    })) {
+        .existing => |ty| return .fromInterned(ty),
+        .wip => |wip| wip,
+    };
+    errdefer wip.cancel(ip, pt.tid);
+
+    _ = try type_name.apply(&wip, pt);
+
+    var field_it = enum_decl.iterateFields();
+    while (field_it.next()) |field| {
+        const name_slice = zir.nullTerminatedString(field.name);
+        const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
+        assert(wip.nextField(ip, name, false) == null); // AstGen validated this for us
+    }
+
+    if (explicit_tag_type == null) {
+        // Infer the int tag type from the field count
+        const bits = Type.smallestUnsignedBits(enum_decl.field_names.len -| 1);
+        const int_tag_ty = try pt.intType(.unsigned, bits);
+        wip.setTagType(ip, int_tag_ty.toIntern());
+    }
+
+    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+        .parent = parent_namespace,
+        .owner_type = wip.index,
+        .file_scope = file_index,
+        .generation = zcu.generation,
+    });
+    errdefer pt.destroyNamespace(new_namespace_index);
+
+    try pt.scanNamespace(new_namespace_index, enum_decl.decls);
+
+    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_inits = wip.index }) });
+
+    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+
+    try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+    errdefer comptime unreachable; // because we don't remove the `outdated` entry
+    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), 0);
+    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), {});
+
+    return .fromInterned(wip.finish(ip, new_namespace_index));
+}
+fn analyzeOpaqueDecl(
+    pt: Zcu.PerThread,
+    file_index: Zcu.File.Index,
+    parent_namespace: InternPool.OptionalNamespaceIndex,
+    tracked_inst: InternPool.TrackedInst.Index,
+    opaque_decl: *const Zir.UnwrappedOpaqueDecl,
+    captures: []const InternPool.CaptureValue,
+    type_name: PartialTypeName,
+) (Allocator.Error || std.Io.Cancelable)!Type {
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    const wip = switch (try ip.getOpaqueType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .captures = captures,
+    })) {
+        .existing => |ty| return .fromInterned(ty),
+        .wip => |wip| wip,
+    };
+    errdefer wip.cancel(ip, pt.tid);
+
+    _ = try type_name.apply(&wip, pt);
+
+    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+        .parent = parent_namespace,
+        .owner_type = wip.index,
+        .file_scope = file_index,
+        .generation = zcu.generation,
+    });
+    errdefer pt.destroyNamespace(new_namespace_index);
+
+    try pt.scanNamespace(new_namespace_index, opaque_decl.decls);
+
+    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+    return .fromInterned(wip.finish(ip, new_namespace_index));
+}
+
+fn zirStructDecl(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+
+    const tracked_inst = try block.trackZir(inst);
+
+    const src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .nodeOffset(.zero),
+    };
+    const backing_ty_src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .{ .node_offset_container_tag = .zero },
+    };
+
+    const struct_decl = sema.code.getStructDecl(inst);
+
+    const captures = try sema.getCaptures(block, src, struct_decl.captures, struct_decl.capture_names);
+
+    const backing_int_type: ?Type = ty: {
+        if (struct_decl.backing_int_type == .none) break :ty null;
+        break :ty try sema.resolveType(block, backing_ty_src, struct_decl.backing_int_type);
+        // MLUGG TODO validate it's an int!
+    };
+
+    const ty = try analyzeStructDecl(
+        pt,
+        block.getFileScopeIndex(zcu),
+        &sema.code,
+        block.namespace.toOptional(),
+        tracked_inst,
+        &struct_decl,
+        backing_int_type,
+        captures,
+        try sema.createTypeName(block, struct_decl.name_strategy, "struct", inst),
+    );
+
+    try sema.addTypeReferenceEntry(src, ty);
+
+    // Make sure we update the namespace if the declaration is re-analyzed, to pick
+    // up on e.g. changed comptime decls.
+    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
+    try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
+
+    return .fromIntern(ty.toIntern());
+}
+fn zirUnionDecl(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    const tracked_inst = try block.trackZir(inst);
+
+    const src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .nodeOffset(.zero),
+    };
+    const arg_ty_src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .{ .node_offset_container_tag = .zero },
+    };
+
+    const union_decl = sema.code.getUnionDecl(inst);
+
+    const captures = try sema.getCaptures(block, src, union_decl.captures, union_decl.capture_names);
+
+    const arg_type: ?Type = ty: {
+        if (union_decl.arg_type == .none) break :ty null;
+        break :ty try sema.resolveType(block, arg_ty_src, union_decl.arg_type);
+    };
+
+    const ty = analyzeUnionDecl(
+        pt,
+        block.getFileScopeIndex(zcu),
+        &sema.code,
+        block.namespace.toOptional(),
+        block.wantSafeTypes(),
+        tracked_inst,
+        &union_decl,
+        arg_type,
+        captures,
+        try sema.createTypeName(block, union_decl.name_strategy, "union", inst),
+    ) catch |err| switch (err) {
+        error.OutOfMemory,
+        error.Canceled,
+        => |e| return e,
+
+        error.ExplicitBackingNotInt => return sema.fail(
+            block,
+            arg_ty_src,
+            "expected integer backing type, found '{f}'",
+            .{arg_type.?.fmt(pt)},
+        ),
+        error.ExplicitTagNotInt => return sema.fail(
+            block,
+            arg_ty_src,
+            "expected integer tag type, found '{f}'",
+            .{arg_type.?.fmt(pt)},
+        ),
+        error.ExplicitTagNotEnum => return sema.fail(
+            block,
+            arg_ty_src,
+            "expected enum tag type, found '{f}'",
+            .{arg_type.?.fmt(pt)},
+        ),
+        error.ExplicitTagFieldMismatch => {
+            const enum_obj = ip.loadEnumType(arg_type.?.toIntern());
+            const enum_to_union_map = try sema.arena.alloc(?u32, enum_obj.field_names.len);
+            @memset(enum_to_union_map, null);
+            for (union_decl.field_names, 0..) |field_name_zir, union_field_idx| {
+                const field_name_ip = try ip.getOrPutString(gpa, io, pt.tid, sema.code.nullTerminatedString(field_name_zir), .no_embedded_nulls);
+                if (enum_obj.nameIndex(ip, field_name_ip)) |enum_field_idx| {
+                    enum_to_union_map[enum_field_idx] = @intCast(union_field_idx);
+                    continue;
+                }
+                const union_field_src: LazySrcLoc = .{
+                    .base_node_inst = tracked_inst,
+                    .offset = .{ .container_field_name = @intCast(union_field_idx) },
+                };
+                return sema.failWithOwnedErrorMsg(block, msg: {
+                    const msg = try sema.errMsg(union_field_src, "no field named '{f}' in enum '{f}'", .{ field_name_ip.fmt(ip), arg_type.?.fmt(pt) });
+                    errdefer msg.destroy(gpa);
+                    try sema.addDeclaredHereNote(msg, arg_type.?);
+                    break :msg msg;
+                });
+            }
+            for (enum_to_union_map, 0..) |union_field_idx, enum_field_idx| {
+                if (union_field_idx != null) continue;
+                const field_name_ip = enum_obj.field_names.get(ip)[enum_field_idx];
+                const enum_field_src: LazySrcLoc = .{
+                    .base_node_inst = arg_type.?.typeDeclInstAllowGeneratedTag(zcu).?,
+                    .offset = .{ .container_field_name = @intCast(enum_field_idx) },
+                };
+                return sema.failWithOwnedErrorMsg(block, msg: {
+                    const msg = try sema.errMsg(src, "enum field '{f}' missing from union", .{field_name_ip.fmt(ip)});
+                    errdefer msg.destroy(gpa);
+                    try sema.errNote(enum_field_src, msg, "enum field here", .{});
+                    break :msg msg;
+                });
+            }
+            for (enum_to_union_map, 0..) |union_field_idx, enum_field_idx| {
+                if (union_field_idx.? == enum_field_idx) continue;
+                const field_name = sema.code.nullTerminatedString(
+                    union_decl.field_names[union_field_idx.?],
+                );
+                const union_field_src: LazySrcLoc = .{
+                    .base_node_inst = tracked_inst,
+                    .offset = .{ .container_field_name = union_field_idx.? },
+                };
+                const enum_field_src: LazySrcLoc = .{
+                    .base_node_inst = arg_type.?.typeDeclInstAllowGeneratedTag(zcu).?,
+                    .offset = .{ .container_field_name = @intCast(enum_field_idx) },
+                };
+                return sema.failWithOwnedErrorMsg(block, msg: {
+                    const msg = try sema.errMsg(src, "union field order does not match tag enum field order", .{});
+                    errdefer msg.destroy(gpa);
+                    try sema.errNote(union_field_src, msg, "union field '{s}' is index {d}", .{ field_name, union_field_idx.? });
+                    try sema.errNote(enum_field_src, msg, "enum field '{s}' is index {d}", .{ field_name, enum_field_idx });
+                    break :msg msg;
+                });
+            }
+            unreachable;
+        },
+    };
+
+    const enum_tag_ty = ty.unionTagTypeHypothetical(zcu);
+    switch (ip.indexToKey(enum_tag_ty.toIntern()).enum_type) {
+        .declared, .reified => {},
+        .generated_union_tag => |owner_union_ty| {
+            assert(owner_union_ty == ty.toIntern());
+            // generated tag type [MLUGG]
+            // Enum inits are resolved eagerly. TODO MLUGG: honestly i don't think they SHOULD be lol
+            try sema.ensureFieldInitsResolved(.fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_type));
+        },
+    }
+
+    try sema.addTypeReferenceEntry(src, ty);
+
+    // Make sure we update the namespace if the declaration is re-analyzed, to pick
+    // up on e.g. changed comptime decls.
+    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
+    try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
+
+    return .fromIntern(ty.toIntern());
+}
+fn zirEnumDecl(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+
+    const tracked_inst = try block.trackZir(inst);
+
+    const src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .nodeOffset(.zero),
+    };
+    const tag_ty_src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .{ .node_offset_container_tag = .zero },
+    };
+
+    const enum_decl = sema.code.getEnumDecl(inst);
+
+    const captures = try sema.getCaptures(block, src, enum_decl.captures, enum_decl.capture_names);
+
+    const tag_type: ?Type = ty: {
+        if (enum_decl.tag_type == .none) break :ty null;
+        break :ty try sema.resolveType(block, tag_ty_src, enum_decl.tag_type);
+    };
+
+    const ty = analyzeEnumDecl(
+        pt,
+        block.getFileScopeIndex(zcu),
+        &sema.code,
+        block.namespace.toOptional(),
+        tracked_inst,
+        &enum_decl,
+        tag_type,
+        captures,
+        try sema.createTypeName(block, enum_decl.name_strategy, "enum", inst),
+    ) catch |err| switch (err) {
+        error.OutOfMemory,
+        error.Canceled,
+        => |e| return e,
+
+        error.ExplicitTagNotInt => return sema.fail(
+            block,
+            tag_ty_src,
+            "expected integer tag type, found '{f}'",
+            .{tag_type.?.fmt(pt)},
+        ),
+    };
+
+    // Enum inits are resolved eagerly. TODO MLUGG: honestly i don't think they SHOULD be lol
+    try sema.ensureFieldInitsResolved(ty);
+
+    try sema.addTypeReferenceEntry(src, ty);
+
+    // Make sure we update the namespace if the declaration is re-analyzed, to pick
+    // up on e.g. changed comptime decls.
+    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
+    try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
+
+    return .fromIntern(ty.toIntern());
+}
+fn zirOpaqueDecl(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+
+    const tracked_inst = try block.trackZir(inst);
+
+    const src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .nodeOffset(.zero),
+    };
+
+    const opaque_decl = sema.code.getOpaqueDecl(inst);
+
+    const captures = try sema.getCaptures(block, src, opaque_decl.captures, opaque_decl.capture_names);
+
+    const ty = try analyzeOpaqueDecl(
+        pt,
+        block.getFileScopeIndex(zcu),
+        block.namespace.toOptional(),
+        tracked_inst,
+        &opaque_decl,
+        captures,
+        try sema.createTypeName(block, opaque_decl.name_strategy, "opaque", inst),
+    );
+
+    try sema.addTypeReferenceEntry(src, ty);
+
+    // Make sure we update the namespace if the declaration is re-analyzed, to pick
+    // up on e.g. changed comptime decls.
+    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
+    try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
+
+    return .fromIntern(ty.toIntern());
+}
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index 76cf3d7f2cc05310e4402cc3fe43072d2a07fc59..78d1d8d1df28af4b827e6d869d0e8352acd168ee 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -125,6 +125,7 @@ fn lowerExprAnonResTy(self: *LowerZon, node: Zoir.Node.Index) CompileError!Inter
             return (try pt.aggregateValue(.fromInterned(ty), values)).toIntern();
         },
         .struct_literal => |init| {
+            if (true) @panic("MLUGG TODO");
             const elems = try self.sema.arena.alloc(InternPool.Index, init.names.len);
             for (0..init.names.len) |i| {
                 elems[i] = try self.lowerExprAnonResTy(init.vals.at(@intCast(i)));
@@ -299,7 +300,7 @@ fn checkTypeInner(
         } else {
             const gop = try visited.getOrPut(sema.arena, ty.toIntern());
             if (gop.found_existing) return;
-            try ty.resolveFields(pt);
+            try sema.ensureLayoutResolved(ty);
             const struct_info = zcu.typeToStruct(ty).?;
             for (struct_info.field_types.get(ip)) |field_type| {
                 try self.checkTypeInner(.fromInterned(field_type), null, visited);
@@ -308,7 +309,7 @@ fn checkTypeInner(
         .@"union" => {
             const gop = try visited.getOrPut(sema.arena, ty.toIntern());
             if (gop.found_existing) return;
-            try ty.resolveFields(pt);
+            try sema.ensureLayoutResolved(ty);
             const union_info = zcu.typeToUnion(ty).?;
             for (union_info.field_types.get(ip)) |field_type| {
                 if (field_type != .void_type) {
@@ -767,8 +768,8 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
 
-    try res_ty.resolveFields(self.sema.pt);
-    try res_ty.resolveStructFieldInits(self.sema.pt);
+    try self.sema.ensureLayoutResolved(res_ty);
+    try self.sema.ensureFieldInitsResolved(res_ty);
     const struct_info = self.sema.pt.zcu.typeToStruct(res_ty).?;
 
     const fields: @FieldType(Zoir.Node, "struct_literal") = switch (node.get(self.file.zoir.?)) {
@@ -779,7 +780,7 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
 
     const field_values = try self.sema.arena.alloc(InternPool.Index, struct_info.field_names.len);
 
-    const field_defaults = struct_info.field_inits.get(ip);
+    const field_defaults = struct_info.field_defaults.get(ip);
     if (field_defaults.len > 0) {
         @memcpy(field_values, field_defaults);
     } else {
@@ -803,7 +804,7 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
         const field_type: Type = .fromInterned(struct_info.field_types.get(ip)[name_index]);
         field_values[name_index] = try self.lowerExprKnownResTy(field_node, field_type);
 
-        if (struct_info.comptime_bits.getBit(ip, name_index)) {
+        if (struct_info.field_is_comptime_bits.get(ip, name_index)) {
             const val = ip.indexToKey(field_values[name_index]);
             const default = ip.indexToKey(field_defaults[name_index]);
             if (!val.eql(default, ip)) {
@@ -918,9 +919,9 @@ fn lowerUnion(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
-    try res_ty.resolveFields(self.sema.pt);
-    const union_info = self.sema.pt.zcu.typeToUnion(res_ty).?;
-    const enum_tag_info = union_info.loadTagType(ip);
+    try self.sema.ensureLayoutResolved(res_ty);
+    const union_info = pt.zcu.typeToUnion(res_ty).?;
+    const enum_tag_info = ip.loadEnumType(union_info.enum_tag_type);
 
     const field_name, const maybe_field_node = switch (node.get(self.file.zoir.?)) {
         .enum_literal => |name| b: {
@@ -956,7 +957,7 @@ fn lowerUnion(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.
     const name_index = enum_tag_info.nameIndex(ip, field_name) orelse {
         return error.WrongType;
     };
-    const tag = try self.sema.pt.enumValueFieldIndex(.fromInterned(union_info.enum_tag_ty), name_index);
+    const tag = try self.sema.pt.enumValueFieldIndex(.fromInterned(union_info.enum_tag_type), name_index);
     const field_type: Type = .fromInterned(union_info.field_types.get(ip)[name_index]);
     const val = if (maybe_field_node) |field_node| b: {
         if (field_type.toIntern() == .void_type) {
diff --git a/src/Sema/arith.zig b/src/Sema/arith.zig
index c646dc7b2167450ba54779bf2d83af6e0de86cc1..161b6e1ce03ad4ffd9ee8372f49fb39a8a279207 100644
--- a/src/Sema/arith.zig
+++ b/src/Sema/arith.zig
@@ -1053,7 +1053,7 @@ fn shlScalar(
             if (rhs_val.isUndef(zcu)) return rhs_val;
         },
     }
-    switch (try rhs_val.orderAgainstZeroSema(pt)) {
+    switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
         .gt => {},
         .eq => return lhs_val,
         .lt => return sema.failWithNegativeShiftAmount(block, rhs_src, rhs_val, vec_idx),
@@ -1090,7 +1090,7 @@ fn shlWithOverflowScalar(
     if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src, vec_idx);
     if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src, vec_idx);
 
-    switch (try rhs_val.orderAgainstZeroSema(pt)) {
+    switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
         .gt => {},
         .eq => return .{ .overflow_bit = .zero_u1, .wrapped_result = lhs_val },
         .lt => return sema.failWithNegativeShiftAmount(block, rhs_src, rhs_val, vec_idx),
@@ -1169,7 +1169,7 @@ fn shrScalar(
     if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src, vec_idx);
     if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src, vec_idx);
 
-    switch (try rhs_val.orderAgainstZeroSema(pt)) {
+    switch (Value.order(rhs_val, .zero_comptime_int, zcu)) {
         .gt => {},
         .eq => return lhs_val,
         .lt => return sema.failWithNegativeShiftAmount(block, rhs_src, rhs_val, vec_idx),
@@ -1430,8 +1430,8 @@ fn intAddWithOverflowInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value
     const info = ty.intInfo(zcu);
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         std.math.big.int.calcTwosCompLimbCount(info.bits),
@@ -1512,8 +1512,8 @@ fn intSubWithOverflowInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value
     const info = ty.intInfo(zcu);
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         std.math.big.int.calcTwosCompLimbCount(info.bits),
@@ -1597,8 +1597,8 @@ fn intMulWithOverflowInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value
     const info = ty.intInfo(zcu);
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         lhs_bigint.limbs.len + rhs_bigint.limbs.len,
@@ -1840,7 +1840,7 @@ fn intShl(
     var lhs_space: Value.BigIntSpace = undefined;
     const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
 
-    const shift_amt: usize = @intCast(try rhs.toUnsignedIntSema(pt));
+    const shift_amt: usize = @intCast(rhs.toUnsignedInt(zcu));
     if (shift_amt >= info.bits) {
         return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs, rhs_src, vec_idx);
     }
@@ -1862,7 +1862,7 @@ fn intShlSat(
     const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
 
     const shift_amt: usize = amt: {
-        if (try rhs.getUnsignedIntSema(pt)) |shift_amt_u64| {
+        if (rhs.getUnsignedInt(zcu)) |shift_amt_u64| {
             if (std.math.cast(usize, shift_amt_u64)) |shift_amt| break :amt shift_amt;
         }
         // We only support ints with up to 2^16 - 1 bits, so this
@@ -1895,9 +1895,9 @@ fn intShlWithOverflow(
     const info = lhs_ty.intInfo(zcu);
 
     var lhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
 
-    const shift_amt: usize = @intCast(try rhs.toUnsignedIntSema(pt));
+    const shift_amt: usize = @intCast(rhs.toUnsignedInt(zcu));
     if (shift_amt >= info.bits) {
         return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs, rhs_src, vec_idx);
     }
@@ -1924,9 +1924,10 @@ fn comptimeIntShl(
     vec_idx: ?usize,
 ) !Value {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     var lhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    if (try rhs.getUnsignedIntSema(pt)) |shift_amt_u64| {
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    if (rhs.getUnsignedInt(zcu)) |shift_amt_u64| {
         if (std.math.cast(usize, shift_amt_u64)) |shift_amt| {
             const result_bigint = try intShlInner(sema, lhs_bigint, shift_amt);
             return pt.intValue_big(.comptime_int, result_bigint.toConst());
@@ -1963,15 +1964,15 @@ fn intShr(
     const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
 
     const shift_amt: usize = if (rhs_ty.toIntern() == .comptime_int_type) amt: {
-        if (try rhs.getUnsignedIntSema(pt)) |shift_amt_u64| {
+        if (rhs.getUnsignedInt(zcu)) |shift_amt_u64| {
             if (std.math.cast(usize, shift_amt_u64)) |shift_amt| break :amt shift_amt;
         }
-        if (try rhs.compareAllWithZeroSema(.lt, pt)) {
+        if (rhs.compareAllWithZero(.lt, zcu)) {
             return sema.failWithNegativeShiftAmount(block, rhs_src, rhs, vec_idx);
         } else {
             return sema.failWithUnsupportedComptimeShiftAmount(block, rhs_src, vec_idx);
         }
-    } else @intCast(try rhs.toUnsignedIntSema(pt));
+    } else @intCast(rhs.toUnsignedInt(zcu));
 
     if (lhs_ty.toIntern() != .comptime_int_type and shift_amt >= lhs_ty.intInfo(zcu).bits) {
         return sema.failWithTooLargeShiftAmount(block, lhs_ty, rhs, rhs_src, vec_idx);
@@ -2006,7 +2007,7 @@ fn intBitReverse(sema: *Sema, val: Value, ty: Type) !Value {
     const info = ty.intInfo(zcu);
 
     var val_space: Value.BigIntSpace = undefined;
-    const val_bigint = try val.toBigIntSema(&val_space, pt);
+    const val_bigint = val.toBigInt(&val_space, zcu);
 
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
diff --git a/src/Sema/bitcast.zig b/src/Sema/bitcast.zig
index bc1859e51b4a60d58d628efef3c0158fc295aa6e..ee70bd1746466aaf57c8812083f37892e69dac59 100644
--- a/src/Sema/bitcast.zig
+++ b/src/Sema/bitcast.zig
@@ -79,8 +79,8 @@ fn bitCastInner(
 
     const val_ty = val.typeOf(zcu);
 
-    try val_ty.resolveLayout(pt);
-    try dest_ty.resolveLayout(pt);
+    val_ty.assertHasLayout(zcu);
+    try sema.ensureLayoutResolved(dest_ty);
 
     assert(val_ty.hasWellDefinedLayout(zcu));
 
@@ -138,8 +138,8 @@ fn bitCastSpliceInner(
     const val_ty = val.typeOf(zcu);
     const splice_val_ty = splice_val.typeOf(zcu);
 
-    try val_ty.resolveLayout(pt);
-    try splice_val_ty.resolveLayout(pt);
+    try sema.ensureLayoutResolved(val_ty);
+    try sema.ensureLayoutResolved(splice_val_ty);
 
     const splice_bits = splice_val_ty.bitSize(zcu);
 
@@ -673,6 +673,9 @@ const PackValueBits = struct {
     fn primitive(pack: *PackValueBits, want_ty: Type) BitCastError!Value {
         const pt = pack.pt;
         const zcu = pt.zcu;
+
+        if (try want_ty.onePossibleValue(pt)) |opv| return opv;
+
         const vals, const bit_offset = pack.prepareBits(want_ty.bitSize(zcu));
 
         for (vals) |val| {
diff --git a/src/Sema/comptime_ptr_access.zig b/src/Sema/comptime_ptr_access.zig
index 4e101ecd0f962fa49a2aa73ac228ce6c6fe7e3c0..c74b5c2d75fab499c27a973584d3aa0748515a94 100644
--- a/src/Sema/comptime_ptr_access.zig
+++ b/src/Sema/comptime_ptr_access.zig
@@ -67,7 +67,7 @@ pub fn storeComptimePtr(
 
     {
         const store_ty: Type = .fromInterned(ptr_info.child);
-        if (!try store_ty.comptimeOnlySema(pt) and !try store_ty.hasRuntimeBitsIgnoreComptimeSema(pt)) {
+        if (!store_ty.comptimeOnly(zcu) and !store_ty.hasRuntimeBits(zcu)) {
             // zero-bit store; nothing to do
             return .success;
         }
@@ -354,8 +354,8 @@ fn loadComptimePtrInner(
         const load_one_ty, const load_count = load_ty.arrayBase(zcu);
 
         const extra_base_index: u64 = if (ptr.byte_offset == 0) 0 else idx: {
-            if (try load_one_ty.comptimeOnlySema(pt)) break :restructure_array;
-            const elem_len = try load_one_ty.abiSizeSema(pt);
+            if (load_one_ty.comptimeOnly(zcu)) break :restructure_array;
+            const elem_len = load_one_ty.abiSize(zcu);
             if (ptr.byte_offset % elem_len != 0) break :restructure_array;
             break :idx @divExact(ptr.byte_offset, elem_len);
         };
@@ -401,12 +401,12 @@ fn loadComptimePtrInner(
     var cur_offset = ptr.byte_offset;
 
     if (load_ty.zigTypeTag(zcu) == .array and array_offset > 0) {
-        cur_offset += try load_ty.childType(zcu).abiSizeSema(pt) * array_offset;
+        cur_offset += load_ty.childType(zcu).abiSize(zcu) * array_offset;
     }
 
-    const need_bytes = if (host_bits > 0) (host_bits + 7) / 8 else try load_ty.abiSizeSema(pt);
+    const need_bytes = if (host_bits > 0) (host_bits + 7) / 8 else load_ty.abiSize(zcu);
 
-    if (cur_offset + need_bytes > try cur_val.typeOf(zcu).abiSizeSema(pt)) {
+    if (cur_offset + need_bytes > cur_val.typeOf(zcu).abiSize(zcu)) {
         return .{ .out_of_bounds = cur_val.typeOf(zcu) };
     }
 
@@ -441,7 +441,7 @@ fn loadComptimePtrInner(
             .optional => break, // this can only be a pointer-like optional so is terminal
             .array => {
                 const elem_ty = cur_ty.childType(zcu);
-                const elem_size = try elem_ty.abiSizeSema(pt);
+                const elem_size = elem_ty.abiSize(zcu);
                 const elem_idx = cur_offset / elem_size;
                 const next_elem_off = elem_size * (elem_idx + 1);
                 if (cur_offset + need_bytes <= next_elem_off) {
@@ -457,7 +457,7 @@ fn loadComptimePtrInner(
                 .@"packed" => break, // let the bitcast logic handle this
                 .@"extern" => for (0..cur_ty.structFieldCount(zcu)) |field_idx| {
                     const start_off = cur_ty.structFieldOffset(field_idx, zcu);
-                    const end_off = start_off + try cur_ty.fieldType(field_idx, zcu).abiSizeSema(pt);
+                    const end_off = start_off + cur_ty.fieldType(field_idx, zcu).abiSize(zcu);
                     if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
                         cur_val = try cur_val.getElem(sema.pt, field_idx);
                         cur_offset -= start_off;
@@ -484,7 +484,7 @@ fn loadComptimePtrInner(
                     };
                     // The payload always has offset 0. If it's big enough
                     // to represent the whole load type, we can use it.
-                    if (try payload.typeOf(zcu).abiSizeSema(pt) >= need_bytes) {
+                    if (payload.typeOf(zcu).abiSize(zcu) >= need_bytes) {
                         cur_val = payload;
                     } else {
                         break;
@@ -753,8 +753,8 @@ fn prepareComptimePtrStore(
 
         const store_one_ty, const store_count = store_ty.arrayBase(zcu);
         const extra_base_index: u64 = if (ptr.byte_offset == 0) 0 else idx: {
-            if (try store_one_ty.comptimeOnlySema(pt)) break :restructure_array;
-            const elem_len = try store_one_ty.abiSizeSema(pt);
+            if (store_one_ty.comptimeOnly(zcu)) break :restructure_array;
+            const elem_len = store_one_ty.abiSize(zcu);
             if (ptr.byte_offset % elem_len != 0) break :restructure_array;
             break :idx @divExact(ptr.byte_offset, elem_len);
         };
@@ -807,11 +807,11 @@ fn prepareComptimePtrStore(
     var cur_val: *MutableValue, var cur_offset: u64 = switch (base_strat) {
         .direct => |direct| .{ direct.val, 0 },
         // It's okay to do `abiSize` - the comptime-only case will be caught below.
-        .index => |index| .{ index.val, index.elem_index * try index.val.typeOf(zcu).childType(zcu).abiSizeSema(pt) },
+        .index => |index| .{ index.val, index.elem_index * index.val.typeOf(zcu).childType(zcu).abiSize(zcu) },
         .flat_index => |flat_index| .{
             flat_index.val,
             // It's okay to do `abiSize` - the comptime-only case will be caught below.
-            flat_index.flat_elem_index * try flat_index.val.typeOf(zcu).arrayBase(zcu)[0].abiSizeSema(pt),
+            flat_index.flat_elem_index * flat_index.val.typeOf(zcu).arrayBase(zcu)[0].abiSize(zcu),
         },
         .reinterpret => |r| .{ r.val, r.byte_offset },
         else => unreachable,
@@ -823,12 +823,12 @@ fn prepareComptimePtrStore(
     }
 
     if (store_ty.zigTypeTag(zcu) == .array and array_offset > 0) {
-        cur_offset += try store_ty.childType(zcu).abiSizeSema(pt) * array_offset;
+        cur_offset += store_ty.childType(zcu).abiSize(zcu) * array_offset;
     }
 
-    const need_bytes = try store_ty.abiSizeSema(pt);
+    const need_bytes = store_ty.abiSize(zcu);
 
-    if (cur_offset + need_bytes > try cur_val.typeOf(zcu).abiSizeSema(pt)) {
+    if (cur_offset + need_bytes > cur_val.typeOf(zcu).abiSize(zcu)) {
         return .{ .out_of_bounds = cur_val.typeOf(zcu) };
     }
 
@@ -863,7 +863,7 @@ fn prepareComptimePtrStore(
             .optional => break, // this can only be a pointer-like optional so is terminal
             .array => {
                 const elem_ty = cur_ty.childType(zcu);
-                const elem_size = try elem_ty.abiSizeSema(pt);
+                const elem_size = elem_ty.abiSize(zcu);
                 const elem_idx = cur_offset / elem_size;
                 const next_elem_off = elem_size * (elem_idx + 1);
                 if (cur_offset + need_bytes <= next_elem_off) {
@@ -879,7 +879,7 @@ fn prepareComptimePtrStore(
                 .@"packed" => break, // let the bitcast logic handle this
                 .@"extern" => for (0..cur_ty.structFieldCount(zcu)) |field_idx| {
                     const start_off = cur_ty.structFieldOffset(field_idx, zcu);
-                    const end_off = start_off + try cur_ty.fieldType(field_idx, zcu).abiSizeSema(pt);
+                    const end_off = start_off + cur_ty.fieldType(field_idx, zcu).abiSize(zcu);
                     if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
                         cur_val = try cur_val.elem(pt, sema.arena, field_idx);
                         cur_offset -= start_off;
@@ -902,7 +902,7 @@ fn prepareComptimePtrStore(
                     };
                     // The payload always has offset 0. If it's big enough
                     // to represent the whole load type, we can use it.
-                    if (try payload.typeOf(zcu).abiSizeSema(pt) >= need_bytes) {
+                    if (payload.typeOf(zcu).abiSize(zcu) >= need_bytes) {
                         cur_val = payload;
                     } else {
                         break;
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f54a7b944e41f3c39161836a49654b177abb7c99
--- /dev/null
+++ b/src/Sema/type_resolution.zig
@@ -0,0 +1,993 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const mem = std.mem;
+
+const Sema = @import("../Sema.zig");
+const Block = Sema.Block;
+const Type = @import("../Type.zig");
+const Value = @import("../Value.zig");
+const Zcu = @import("../Zcu.zig");
+const CompileError = Zcu.CompileError;
+const SemaError = Zcu.SemaError;
+const LazySrcLoc = Zcu.LazySrcLoc;
+const InternPool = @import("../InternPool.zig");
+const Alignment = InternPool.Alignment;
+const arith = @import("arith.zig");
+
+/// Ensures that `ty` has known layout, including alignment, size, and (where relevant) field offsets.
+/// `ty` may be any type; its layout is resolved *recursively* if necessary.
+/// Adds incremental dependencies tracking any required type resolution.
+/// MLUGG TODO: to make the langspec non-stupid, we need to call this from WAY fewer places (the conditions need to be less specific).
+/// e.g. I think creating the type `fn (A, B) C` should force layout resolution of `A`,`B`,`C`, which will simplify some `analyzeCall` logic.
+///      wait i just realised that's probably a terrible idea, fns are a common cause of dep loops rn... so maybe not lol idk...
+///      perhaps "layout resolution" for a function should resolve layout of ret ty and stuff, idk. justification: the "layout" of a function is whether
+///      fnHasRuntimeBits, which depends whether the ret ty is comptime-only, i.e. the ret ty layout
+/// MLUGG TODO: to be clear, i should audit EVERY use of this before PRing
+pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    switch (ip.indexToKey(ty.toIntern())) {
+        .int_type,
+        .ptr_type,
+        .anyframe_type,
+        .simple_type,
+        .opaque_type,
+        .enum_type,
+        .error_set_type,
+        .inferred_error_set_type,
+        => {},
+
+        .func_type => |func_type| {
+            for (func_type.param_types.get(ip)) |param_ty| {
+                try ensureLayoutResolved(sema, .fromInterned(param_ty));
+            }
+            try ensureLayoutResolved(sema, .fromInterned(func_type.return_type));
+        },
+
+        .array_type => |arr| return ensureLayoutResolved(sema, .fromInterned(arr.child)),
+        .vector_type => |vec| return ensureLayoutResolved(sema, .fromInterned(vec.child)),
+        .opt_type => |child| return ensureLayoutResolved(sema, .fromInterned(child)),
+        .error_union_type => |eu| return ensureLayoutResolved(sema, .fromInterned(eu.payload_type)),
+        .tuple_type => |tuple| for (tuple.types.get(ip)) |field_ty| {
+            try ensureLayoutResolved(sema, .fromInterned(field_ty));
+        },
+        .struct_type, .union_type => {
+            try sema.declareDependency(.{ .type_layout = ty.toIntern() });
+            if (zcu.analysis_in_progress.contains(.wrap(.{ .type_layout = ty.toIntern() }))) {
+                // TODO: better error message
+                return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
+                    ty.srcLoc(zcu),
+                    "{s} '{f}' depends on itself",
+                    .{ @tagName(ty.zigTypeTag(zcu)), ty.fmt(pt) },
+                ));
+            }
+            try pt.ensureTypeLayoutUpToDate(ty);
+        },
+
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .empty_enum_value,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
+    }
+}
+
+/// Asserts that `ty` is either a `struct` type, or an `enum` type.
+/// If `ty` is a struct, ensures that fields' default values are resolved.
+/// If `ty` is an enum, ensures that fields' integer tag valus are resolved.
+/// Adds incremental dependencies tracking the required type resolution.
+pub fn ensureFieldInitsResolved(sema: *Sema, ty: Type) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    switch (ip.indexToKey(ty.toIntern())) {
+        .struct_type, .enum_type => {},
+        else => unreachable, // assertion failure
+    }
+
+    try sema.declareDependency(.{ .type_inits = ty.toIntern() });
+    if (zcu.analysis_in_progress.contains(.wrap(.{ .type_inits = ty.toIntern() }))) {
+        // TODO: better error message
+        return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
+            ty.srcLoc(zcu),
+            "{s} '{f}' depends on itself",
+            .{ @tagName(ty.zigTypeTag(zcu)), ty.fmt(pt) },
+        ));
+    }
+    try pt.ensureTypeInitsUpToDate(ty);
+}
+/// Asserts that `struct_ty` is a non-packed non-tuple struct, and that `sema.owner` is that type.
+/// This function *does* register the `src_hash` dependency on the struct.
+pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().type_layout == struct_ty.toIntern());
+
+    const struct_obj = ip.loadStructType(struct_ty.toIntern());
+    const zir_index = struct_obj.zir_index.resolve(ip).?;
+
+    assert(struct_obj.layout != .@"packed");
+
+    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = struct_obj.namespace,
+        .instructions = .{},
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = struct_obj.zir_index,
+        .type_name_ctx = struct_obj.name,
+    };
+    defer assert(block.instructions.items.len == 0);
+
+    const zir_struct = sema.code.getStructDecl(zir_index);
+    var field_it = zir_struct.iterateFields();
+    while (field_it.next()) |zir_field| {
+        const field_ty_src: LazySrcLoc = .{
+            .base_node_inst = struct_obj.zir_index,
+            .offset = .{ .container_field_type = zir_field.idx },
+        };
+        const field_align_src: LazySrcLoc = .{
+            .base_node_inst = struct_obj.zir_index,
+            .offset = .{ .container_field_align = zir_field.idx },
+        };
+
+        const field_ty: Type = field_ty: {
+            block.comptime_reason = .{ .reason = .{
+                .src = field_ty_src,
+                .r = .{ .simple = .struct_field_types },
+            } };
+            const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
+            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
+        };
+        assert(!field_ty.isGenericPoison());
+
+        try sema.ensureLayoutResolved(field_ty);
+
+        const explicit_field_align: Alignment = a: {
+            block.comptime_reason = .{ .reason = .{
+                .src = field_align_src,
+                .r = .{ .simple = .struct_field_attrs },
+            } };
+            const align_body = zir_field.align_body orelse break :a .none;
+            const align_ref = try sema.resolveInlineBody(&block, align_body, zir_index);
+            break :a try sema.analyzeAsAlign(&block, field_align_src, align_ref);
+        };
+
+        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        if (struct_obj.layout == .@"extern" and !try sema.validateExternType(field_ty, .struct_field)) {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "extern structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.explainWhyTypeIsNotExtern(msg, field_ty_src, field_ty, .struct_field);
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+
+        struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+        if (struct_obj.field_aligns.len != 0) {
+            struct_obj.field_aligns.get(ip)[zir_field.idx] = explicit_field_align;
+        } else {
+            assert(explicit_field_align == .none);
+        }
+    }
+
+    try finishStructLayout(sema, &block, struct_ty.srcLoc(zcu), struct_ty.toIntern(), &struct_obj);
+}
+
+/// Called after populating field types and alignments; populates field offsets, runtime order, and
+/// overall struct layout information (size, alignment, comptime-only state, etc).
+pub fn finishStructLayout(
+    sema: *Sema,
+    /// Only used to report compile errors.
+    block: *Block,
+    struct_src: LazySrcLoc,
+    struct_ty: InternPool.Index,
+    struct_obj: *const InternPool.LoadedStructType,
+) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+    var comptime_only = false;
+    var one_possible_value = true;
+    var struct_align: Alignment = .@"1";
+    // Unlike `struct_obj.field_aligns`, these are not `.none`.
+    const resolved_field_aligns = try sema.arena.alloc(Alignment, struct_obj.field_names.len);
+    for (resolved_field_aligns, 0..) |*align_out, field_idx| {
+        const field_ty: Type = .fromInterned(struct_obj.field_types.get(ip)[field_idx]);
+        const field_align: Alignment = a: {
+            if (struct_obj.field_aligns.len != 0) {
+                const a = struct_obj.field_aligns.get(ip)[field_idx];
+                if (a != .none) break :a a;
+            }
+            break :a field_ty.defaultStructFieldAlignment(struct_obj.layout, zcu);
+        };
+        if (!struct_obj.field_is_comptime_bits.get(ip, field_idx)) {
+            // Non-`comptime` fields contribute to the struct's layout.
+            struct_align = struct_align.maxStrict(field_align);
+            if (field_ty.comptimeOnly(zcu)) comptime_only = true;
+            if (try field_ty.onePossibleValue(pt) == null) one_possible_value = false;
+            if (struct_obj.layout == .auto) {
+                struct_obj.field_runtime_order.get(ip)[field_idx] = @enumFromInt(field_idx);
+            }
+        } else if (struct_obj.layout == .auto) {
+            struct_obj.field_runtime_order.get(ip)[field_idx] = .omitted; // comptime fields are not in the runtime order
+        }
+        align_out.* = field_align;
+    }
+    if (struct_obj.layout == .auto) {
+        const runtime_order = struct_obj.field_runtime_order.get(ip);
+        // This logic does not reorder fields; it only moves the omitted ones to the end so that logic
+        // elsewhere does not need to special-case. TODO: support field reordering in all the backends!
+        if (!zcu.backendSupportsFeature(.field_reordering)) {
+            var i: usize = 0;
+            var off: usize = 0;
+            while (i + off < runtime_order.len) {
+                if (runtime_order[i + off] == .omitted) {
+                    off += 1;
+                } else {
+                    runtime_order[i] = runtime_order[i + off];
+                    i += 1;
+                }
+            }
+        } else {
+            // Sort by descending alignment to minimize padding.
+            const RuntimeOrder = InternPool.LoadedStructType.RuntimeOrder;
+            const AlignSortCtx = struct {
+                aligns: []const Alignment,
+                fn lessThan(ctx: @This(), a: RuntimeOrder, b: RuntimeOrder) bool {
+                    assert(a != .unresolved);
+                    assert(b != .unresolved);
+                    if (a == .omitted) return false;
+                    if (b == .omitted) return true;
+                    const a_align = ctx.aligns[@intFromEnum(a)];
+                    const b_align = ctx.aligns[@intFromEnum(b)];
+                    return a_align.compare(.gt, b_align);
+                }
+            };
+            mem.sortUnstable(
+                RuntimeOrder,
+                runtime_order,
+                @as(AlignSortCtx, .{ .aligns = resolved_field_aligns }),
+                AlignSortCtx.lessThan,
+            );
+        }
+    }
+
+    var runtime_order_it = struct_obj.iterateRuntimeOrder(ip);
+    var cur_offset: u64 = 0;
+    while (runtime_order_it.next()) |field_idx| {
+        const field_ty: Type = .fromInterned(struct_obj.field_types.get(ip)[field_idx]);
+        const offset = resolved_field_aligns[field_idx].forward(cur_offset);
+        struct_obj.field_offsets.get(ip)[field_idx] = @truncate(offset); // truncate because the overflow is handled below
+        cur_offset = offset + field_ty.abiSize(zcu);
+    }
+    const struct_size = std.math.cast(u32, struct_align.forward(cur_offset)) orelse return sema.fail(
+        block,
+        struct_src,
+        "struct layout requires size {d}, this compiler implementation supports up to {d}",
+        .{ struct_align.forward(cur_offset), std.math.maxInt(u32) },
+    );
+    ip.resolveStructLayout(
+        io,
+        struct_ty,
+        struct_size,
+        struct_align,
+        false, // MLUGG TODO XXX NPV
+        one_possible_value,
+        comptime_only,
+    );
+}
+
+/// Asserts that `struct_ty` is a packed struct, and that `sema.owner` is that type.
+/// This function *does* register the `src_hash` dependency on the struct.
+pub fn resolvePackedStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().type_layout == struct_ty.toIntern());
+
+    const struct_obj = ip.loadStructType(struct_ty.toIntern());
+    const zir_index = struct_obj.zir_index.resolve(ip).?;
+
+    assert(struct_obj.layout == .@"packed");
+
+    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = struct_obj.namespace,
+        .instructions = .{},
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = struct_obj.zir_index,
+        .type_name_ctx = struct_obj.name,
+    };
+    defer assert(block.instructions.items.len == 0);
+
+    var field_bits: u64 = 0;
+    const zir_struct = sema.code.getStructDecl(zir_index);
+    var field_it = zir_struct.iterateFields();
+    while (field_it.next()) |zir_field| {
+        const field_ty_src: LazySrcLoc = .{
+            .base_node_inst = struct_obj.zir_index,
+            .offset = .{ .container_field_type = zir_field.idx },
+        };
+        const field_ty: Type = field_ty: {
+            block.comptime_reason = .{ .reason = .{
+                .src = field_ty_src,
+                .r = .{ .simple = .struct_field_types },
+            } };
+            const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
+            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
+        };
+        assert(!field_ty.isGenericPoison());
+        struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+
+        try sema.ensureLayoutResolved(field_ty);
+
+        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        if (!field_ty.packable(zcu)) {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.explainWhyTypeIsNotPackable(msg, field_ty_src, field_ty);
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
+        field_bits += field_ty.bitSize(zcu);
+    }
+
+    try resolvePackedStructBackingInt(sema, &block, field_bits, struct_ty, &struct_obj);
+}
+
+pub fn resolvePackedStructBackingInt(
+    sema: *Sema,
+    block: *Block,
+    field_bits: u64,
+    struct_ty: Type,
+    struct_obj: *const InternPool.LoadedStructType,
+) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    switch (struct_obj.packed_backing_mode) {
+        .explicit => {
+            // We only need to validate the type.
+            const backing_ty: Type = .fromInterned(struct_obj.packed_backing_int_type);
+            assert(backing_ty.zigTypeTag(zcu) == .int);
+            if (field_bits != backing_ty.intInfo(zcu).bits) return sema.failWithOwnedErrorMsg(block, msg: {
+                const src = struct_ty.srcLoc(zcu);
+                const msg = try sema.errMsg(src, "backing integer bit width does not match total bit width of fields", .{});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) });
+                try sema.errNote(src, msg, "struct fields have total bit width '{d}'", .{field_bits});
+                break :msg msg;
+            });
+        },
+        .auto => {
+            // We need to generate the inferred tag.
+            const want_bits = std.math.cast(u16, field_bits) orelse return sema.fail(
+                block,
+                struct_ty.srcLoc(zcu),
+                "packed struct bit width '{d}' exceeds maximum bit width of 65535",
+                .{field_bits},
+            );
+            const backing_int = try pt.intType(.unsigned, want_bits);
+            ip.resolvePackedStructBackingInt(io, struct_ty.toIntern(), backing_int.toIntern());
+        },
+    }
+}
+
+/// Asserts that `struct_ty` is a non-tuple struct, and that `sema.owner` is that type.
+/// This function *does* register the `src_hash` dependency on the struct.
+pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().type_inits == struct_ty.toIntern());
+
+    try sema.ensureLayoutResolved(struct_ty);
+
+    const struct_obj = ip.loadStructType(struct_ty.toIntern());
+    const zir_index = struct_obj.zir_index.resolve(ip).?;
+
+    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
+
+    if (struct_obj.field_defaults.len == 0) {
+        // The struct has no default field values, so the slice has been omitted.
+        return;
+    }
+
+    const field_types = struct_obj.field_types.get(ip);
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = struct_obj.namespace,
+        .instructions = .{},
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = struct_obj.zir_index,
+        .type_name_ctx = struct_obj.name,
+    };
+    defer assert(block.instructions.items.len == 0);
+
+    // We'll need to map the struct decl instruction to provide result types
+    try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
+
+    const zir_struct = sema.code.getStructDecl(zir_index);
+    var field_it = zir_struct.iterateFields();
+    while (field_it.next()) |zir_field| {
+        const default_val_src: LazySrcLoc = .{
+            .base_node_inst = struct_obj.zir_index,
+            .offset = .{ .container_field_value = zir_field.idx },
+        };
+        block.comptime_reason = .{ .reason = .{
+            .src = default_val_src,
+            .r = .{ .simple = .struct_field_default_value },
+        } };
+        const default_body = zir_field.default_body orelse {
+            struct_obj.field_defaults.get(ip)[zir_field.idx] = .none;
+            continue;
+        };
+        const field_ty: Type = .fromInterned(field_types[zir_field.idx]);
+        const uncoerced = ref: {
+            // Provide the result type
+            sema.inst_map.putAssumeCapacity(zir_index, .fromIntern(field_ty.toIntern()));
+            defer assert(sema.inst_map.remove(zir_index));
+            break :ref try sema.resolveInlineBody(&block, default_body, zir_index);
+        };
+        const coerced = try sema.coerce(&block, field_ty, uncoerced, default_val_src);
+        const default_val = try sema.resolveConstValue(&block, default_val_src, coerced, null);
+        if (default_val.canMutateComptimeVarState(zcu)) {
+            const field_name = struct_obj.field_names.get(ip)[zir_field.idx];
+            return sema.failWithContainsReferenceToComptimeVar(&block, default_val_src, field_name, "field default value", default_val);
+        }
+        struct_obj.field_defaults.get(ip)[zir_field.idx] = default_val.toIntern();
+    }
+}
+
+/// This logic must be kept in sync with `Type.getUnionLayout`.
+pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().type_layout == union_ty.toIntern());
+
+    const union_obj = ip.loadUnionType(union_ty.toIntern());
+    const zir_index = union_obj.zir_index.resolve(ip).?;
+
+    assert(union_obj.layout != .@"packed");
+
+    try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = union_obj.namespace,
+        .instructions = .{},
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = union_obj.zir_index,
+        .type_name_ctx = union_obj.name,
+    };
+    defer assert(block.instructions.items.len == 0);
+
+    const zir_union = sema.code.getUnionDecl(zir_index);
+    var field_it = zir_union.iterateFields();
+    while (field_it.next()) |zir_field| {
+        const field_ty_src: LazySrcLoc = .{
+            .base_node_inst = union_obj.zir_index,
+            .offset = .{ .container_field_type = zir_field.idx },
+        };
+        const field_align_src: LazySrcLoc = .{
+            .base_node_inst = union_obj.zir_index,
+            .offset = .{ .container_field_align = zir_field.idx },
+        };
+
+        const field_ty: Type = field_ty: {
+            block.comptime_reason = .{ .reason = .{
+                .src = field_ty_src,
+                .r = .{ .simple = .union_field_types },
+            } };
+            const type_body = zir_field.type_body orelse break :field_ty .void;
+            const type_ref = try sema.resolveInlineBody(&block, type_body, zir_index);
+            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
+        };
+        assert(!field_ty.isGenericPoison());
+        union_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+
+        try sema.ensureLayoutResolved(field_ty);
+
+        const explicit_field_align: Alignment = a: {
+            block.comptime_reason = .{ .reason = .{
+                .src = field_align_src,
+                .r = .{ .simple = .union_field_attrs },
+            } };
+            const align_body = zir_field.align_body orelse break :a .none;
+            const align_ref = try sema.resolveInlineBody(&block, align_body, zir_index);
+            break :a try sema.analyzeAsAlign(&block, field_align_src, align_ref);
+        };
+
+        if (union_obj.field_aligns.len != 0) {
+            union_obj.field_aligns.get(ip)[zir_field.idx] = explicit_field_align;
+        } else {
+            assert(explicit_field_align == .none);
+        }
+
+        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        if (union_obj.layout == .@"extern" and !try sema.validateExternType(field_ty, .union_field)) {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "extern unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.explainWhyTypeIsNotExtern(msg, field_ty_src, field_ty, .union_field);
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+    }
+
+    try finishUnionLayout(
+        sema,
+        &block,
+        union_ty.srcLoc(zcu),
+        union_ty.toIntern(),
+        &union_obj,
+        .fromInterned(union_obj.enum_tag_type),
+    );
+}
+
+/// Called after populating field types and alignments; populates overall union layout
+/// information (size, alignment, comptime-only state, etc).
+pub fn finishUnionLayout(
+    sema: *Sema,
+    /// Only used to report compile errors.
+    block: *Block,
+    union_src: LazySrcLoc,
+    union_ty: InternPool.Index,
+    union_obj: *const InternPool.LoadedUnionType,
+    enum_tag_ty: Type,
+) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+
+    var payload_align: Alignment = .@"1";
+    var payload_size: u64 = 0;
+    var comptime_only = false;
+    var possible_values: enum { none, one, many } = .none;
+    for (0..union_obj.field_types.len) |field_idx| {
+        const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]);
+        const field_align: Alignment = a: {
+            if (union_obj.field_aligns.len != 0) {
+                const a = union_obj.field_aligns.get(ip)[field_idx];
+                if (a != .none) break :a a;
+            }
+            break :a field_ty.abiAlignment(zcu);
+        };
+        payload_align = payload_align.maxStrict(field_align);
+        payload_size = @max(payload_size, field_ty.abiSize(zcu));
+        if (field_ty.comptimeOnly(zcu)) comptime_only = true;
+        if (!field_ty.isNoReturn(zcu)) {
+            if (try field_ty.onePossibleValue(pt) != null) {
+                possible_values = .many; // this field alone has many possible values
+            } else switch (possible_values) {
+                .none => possible_values = .one, // there were none, now there is this field's OPV
+                .one => possible_values = .many, // there was one, now there are two
+                .many => {},
+            }
+        }
+    }
+
+    const size: u64, const padding: u64, const alignment: Alignment = layout: {
+        if (union_obj.runtime_tag == .none) {
+            break :layout .{ payload_align.forward(payload_size), 0, payload_align };
+        }
+        const tag_align = enum_tag_ty.abiAlignment(zcu);
+        const tag_size = enum_tag_ty.abiSize(zcu);
+        // The layout will either be (tag, payload, padding) or (payload, tag, padding) depending on
+        // which has larger alignment. So the overall size is just the tag and payload sizes, added,
+        // and padded to the larger alignment.
+        const alignment = tag_align.maxStrict(payload_align);
+        const unpadded_size = tag_size + payload_size;
+        const size = alignment.forward(unpadded_size);
+        break :layout .{ size, size - unpadded_size, alignment };
+    };
+
+    const casted_size = std.math.cast(u32, size) orelse return sema.fail(
+        block,
+        union_src,
+        "union layout requires size {d}, this compiler implementation supports up to {d}",
+        .{ size, std.math.maxInt(u32) },
+    );
+    ip.resolveUnionLayout(
+        io,
+        union_ty,
+        casted_size,
+        @intCast(padding), // okay because padding is no greater than size
+        alignment,
+        possible_values == .none, // MLUGG TODO: make sure queries use `LoadedUnionType.has_no_possible_value`!
+        possible_values == .one,
+        comptime_only,
+    );
+}
+
+pub fn resolvePackedUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().type_layout == union_ty.toIntern());
+
+    const union_obj = ip.loadUnionType(union_ty.toIntern());
+    const zir_index = union_obj.zir_index.resolve(ip).?;
+
+    assert(union_obj.layout == .@"packed");
+
+    try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = union_obj.namespace,
+        .instructions = .{},
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = union_obj.zir_index,
+        .type_name_ctx = union_obj.name,
+    };
+    defer assert(block.instructions.items.len == 0);
+
+    const zir_union = sema.code.getUnionDecl(zir_index);
+    var field_it = zir_union.iterateFields();
+    while (field_it.next()) |zir_field| {
+        const field_ty_src: LazySrcLoc = .{
+            .base_node_inst = union_obj.zir_index,
+            .offset = .{ .container_field_type = zir_field.idx },
+        };
+        const field_ty: Type = field_ty: {
+            block.comptime_reason = .{ .reason = .{
+                .src = field_ty_src,
+                .r = .{ .simple = .union_field_types },
+            } };
+            // MLUGG TODO: i think this should probably be a compile error? (if so, it's an astgen one, right?)
+            const type_body = zir_field.type_body orelse break :field_ty .void;
+            const type_ref = try sema.resolveInlineBody(&block, type_body, zir_index);
+            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
+        };
+        assert(!field_ty.isGenericPoison());
+        union_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+
+        assert(zir_field.align_body == null); // packed union fields cannot be aligned
+        assert(zir_field.value_body == null); // packed union fields cannot have tag values
+
+        try sema.ensureLayoutResolved(field_ty);
+
+        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        if (!field_ty.packable(zcu)) {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.explainWhyTypeIsNotPackable(msg, field_ty_src, field_ty);
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
+    }
+
+    try resolvePackedUnionBackingInt(sema, &block, union_ty, &union_obj, false);
+}
+
+/// MLUGG TODO doc comment; asserts all fields are resolved or whatever
+pub fn resolvePackedUnionBackingInt(
+    sema: *Sema,
+    block: *Block,
+    union_ty: Type,
+    union_obj: *const InternPool.LoadedUnionType,
+    is_reified: bool,
+) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
+    switch (union_obj.packed_backing_mode) {
+        .explicit => {
+            const backing_int_type: Type = .fromInterned(union_obj.packed_backing_int_type);
+            const backing_int_bits = backing_int_type.intInfo(zcu).bits;
+            for (union_obj.field_types.get(ip), 0..) |field_type_ip, field_idx| {
+                const field_type: Type = .fromInterned(field_type_ip);
+                const field_bits = field_type.bitSize(zcu);
+                if (field_bits != backing_int_bits) return sema.failWithOwnedErrorMsg(block, msg: {
+                    const field_ty_src: LazySrcLoc = .{
+                        .base_node_inst = union_obj.zir_index,
+                        .offset = if (is_reified)
+                            .nodeOffset(.zero)
+                        else
+                            .{ .container_field_type = @intCast(field_idx) },
+                    };
+                    const msg = try sema.errMsg(field_ty_src, "field bit width does not match backing integer", .{});
+                    errdefer msg.destroy(gpa);
+                    try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
+                    try sema.errNote(field_ty_src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_int_type.fmt(pt), backing_int_bits });
+                    try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
+                    break :msg msg;
+                });
+            }
+        },
+        .auto => switch (union_obj.field_types.len) {
+            0 => ip.resolvePackedUnionBackingInt(io, union_ty.toIntern(), .u0_type),
+            else => {
+                const field_types = union_obj.field_types.get(ip);
+                const first_field_type: Type = .fromInterned(field_types[0]);
+                const first_field_bits = first_field_type.bitSize(zcu);
+                for (field_types[1..], 1..) |field_type_ip, field_idx| {
+                    const field_type: Type = .fromInterned(field_type_ip);
+                    const field_bits = field_type.bitSize(zcu);
+                    if (field_bits != first_field_bits) return sema.failWithOwnedErrorMsg(block, msg: {
+                        const first_field_ty_src: LazySrcLoc = .{
+                            .base_node_inst = union_obj.zir_index,
+                            .offset = if (is_reified)
+                                .nodeOffset(.zero)
+                            else
+                                .{ .container_field_type = 0 },
+                        };
+                        const field_ty_src: LazySrcLoc = .{
+                            .base_node_inst = union_obj.zir_index,
+                            .offset = if (is_reified)
+                                .nodeOffset(.zero)
+                            else
+                                .{ .container_field_type = @intCast(field_idx) },
+                        };
+                        const msg = try sema.errMsg(field_ty_src, "field bit width does not match earlier field", .{});
+                        errdefer msg.destroy(gpa);
+                        try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
+                        try sema.errNote(first_field_ty_src, msg, "other field type '{f}' has bit width '{d}'", .{ first_field_type.fmt(pt), first_field_bits });
+                        try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
+                        break :msg msg;
+                    });
+                }
+                const backing_int_bits = std.math.cast(u16, first_field_bits) orelse return sema.fail(
+                    block,
+                    block.nodeOffset(.zero),
+                    "packed union bit width '{d}' exceeds maximum bit width of 65535",
+                    .{first_field_bits},
+                );
+                const backing_int_type = try pt.intType(.unsigned, backing_int_bits);
+                ip.resolvePackedUnionBackingInt(io, union_ty.toIntern(), backing_int_type.toIntern());
+            },
+        },
+    }
+}
+
+/// Asserts that `enum_ty` is an enum and that `sema.owner` is that type.
+/// This function *does* register the `src_hash` dependency on the enum.
+pub fn resolveEnumValues(sema: *Sema, enum_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().type_inits == enum_ty.toIntern());
+
+    const enum_obj = ip.loadEnumType(enum_ty.toIntern());
+
+    // We'll populate this map.
+    const field_value_map = enum_obj.field_value_map.unwrap() orelse {
+        // The enum has an automatically generated tag and is auto-numbered. We know that we have
+        // generated a suitably large type in `analyzeEnumDecl`, so we have no work to do.
+        return;
+    };
+
+    const maybe_parent_union_obj: ?InternPool.LoadedUnionType = un: {
+        if (enum_obj.owner_union == .none) break :un null;
+        break :un ip.loadUnionType(enum_obj.owner_union);
+    };
+    const tracked_inst = enum_obj.zir_index.unwrap() orelse maybe_parent_union_obj.?.zir_index;
+    const zir_index = tracked_inst.resolve(ip).?;
+
+    try sema.declareDependency(.{ .src_hash = tracked_inst });
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = enum_obj.namespace,
+        .instructions = .{},
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = tracked_inst,
+        .type_name_ctx = enum_obj.name,
+    };
+    defer assert(block.instructions.items.len == 0);
+
+    const int_tag_ty: Type = .fromInterned(enum_obj.int_tag_type);
+
+    // Map the enum (or union) decl instruction to provide the tag type as the result type
+    try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
+    sema.inst_map.putAssumeCapacity(zir_index, .fromIntern(int_tag_ty.toIntern()));
+    defer assert(sema.inst_map.remove(zir_index));
+
+    // First, populate any explicitly provided values. This is the part that actually depends on
+    // the ZIR, and hence depends on whether this is a declared or generated enum. If any explicit
+    // value is invalid, we'll emit an error here.
+    if (maybe_parent_union_obj) |union_obj| {
+        const zir_union = sema.code.getUnionDecl(zir_index);
+        var field_it = zir_union.iterateFields();
+        while (field_it.next()) |zir_field| {
+            const field_val_src: LazySrcLoc = .{
+                .base_node_inst = union_obj.zir_index,
+                .offset = .{ .container_field_value = zir_field.idx },
+            };
+            block.comptime_reason = .{ .reason = .{
+                .src = field_val_src,
+                .r = .{ .simple = .enum_field_values },
+            } };
+            const value_body = zir_field.value_body orelse {
+                enum_obj.field_values.get(ip)[zir_field.idx] = .none;
+                continue;
+            };
+            const uncoerced = try sema.resolveInlineBody(&block, value_body, zir_index);
+            const coerced = try sema.coerce(&block, int_tag_ty, uncoerced, field_val_src);
+            const val = try sema.resolveConstValue(&block, field_val_src, coerced, null);
+            enum_obj.field_values.get(ip)[zir_field.idx] = val.toIntern();
+        }
+    } else {
+        const zir_enum = sema.code.getEnumDecl(zir_index);
+        var field_it = zir_enum.iterateFields();
+        while (field_it.next()) |zir_field| {
+            const field_val_src: LazySrcLoc = .{
+                .base_node_inst = enum_obj.zir_index.unwrap().?,
+                .offset = .{ .container_field_value = zir_field.idx },
+            };
+            block.comptime_reason = .{ .reason = .{
+                .src = field_val_src,
+                .r = .{ .simple = .enum_field_values },
+            } };
+            const value_body = zir_field.value_body orelse {
+                enum_obj.field_values.get(ip)[zir_field.idx] = .none;
+                continue;
+            };
+            const uncoerced = try sema.resolveInlineBody(&block, value_body, zir_index);
+            const coerced = try sema.coerce(&block, int_tag_ty, uncoerced, field_val_src);
+            const val = try sema.resolveConstDefinedValue(&block, field_val_src, coerced, null);
+            enum_obj.field_values.get(ip)[zir_field.idx] = val.toIntern();
+        }
+    }
+
+    // Explicit values are set. Now we'll go through the whole array and figure out the final
+    // field values. This is also where we'll detect duplicates.
+
+    for (0..enum_obj.field_names.len) |field_idx| {
+        const field_val_src: LazySrcLoc = .{
+            .base_node_inst = tracked_inst,
+            .offset = .{ .container_field_value = @intCast(field_idx) },
+        };
+        // If the field value was not specified, compute the implicit value.
+        const field_val = val: {
+            const explicit_val = enum_obj.field_values.get(ip)[field_idx];
+            if (explicit_val != .none) break :val explicit_val;
+            if (field_idx == 0) {
+                // Implicit value is 0, which is valid for every integer type.
+                const val = (try pt.intValue(int_tag_ty, 0)).toIntern();
+                enum_obj.field_values.get(ip)[field_idx] = val;
+                break :val val;
+            }
+            // Implicit non-initial value: take the previous field value and add one.
+            const prev_field_val: Value = .fromInterned(enum_obj.field_values.get(ip)[field_idx - 1]);
+            const result = try arith.incrementDefinedInt(sema, int_tag_ty, prev_field_val);
+            if (result.overflow) return sema.fail(
+                &block,
+                field_val_src,
+                "enum tag value '{f}' too large for type '{f}'",
+                .{ result.val.fmtValueSema(pt, sema), int_tag_ty.fmt(pt) },
+            );
+            const val = result.val.toIntern();
+            enum_obj.field_values.get(ip)[field_idx] = val;
+            break :val val;
+        };
+        const adapter: InternPool.Index.Adapter = .{ .indexes = enum_obj.field_values.get(ip)[0..field_idx] };
+        const gop = field_value_map.get(ip).getOrPutAssumeCapacityAdapted(field_val, adapter);
+        if (!gop.found_existing) continue;
+        const prev_field_val_src: LazySrcLoc = .{
+            .base_node_inst = tracked_inst,
+            .offset = .{ .container_field_value = @intCast(gop.index) },
+        };
+        return sema.failWithOwnedErrorMsg(&block, msg: {
+            const msg = try sema.errMsg(field_val_src, "enum tag value '{f}' already taken", .{
+                Value.fromInterned(field_val).fmtValueSema(pt, sema),
+            });
+            errdefer msg.destroy(gpa);
+            try sema.errNote(prev_field_val_src, msg, "previous occurrence here", .{});
+            break :msg msg;
+        });
+    }
+
+    if (enum_obj.nonexhaustive and int_tag_ty.toIntern() != .comptime_int_type) {
+        const fields_len = enum_obj.field_names.len;
+        if (fields_len >= 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(zcu)) {
+            return sema.fail(&block, block.nodeOffset(.zero), "non-exhaustive enum specifies every value", .{});
+        }
+    }
+}
diff --git a/src/Type.zig b/src/Type.zig
index 57d8a0a5ede75204e3382f4740f28c9b83799681..52dc5ed1ebb7918d930f51d21c65ba68a8178be5 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -12,12 +12,10 @@ const Target = std.Target;
 const Zcu = @import("Zcu.zig");
 const log = std.log.scoped(.Type);
 const target_util = @import("target.zig");
-const Sema = @import("Sema.zig");
 const InternPool = @import("InternPool.zig");
 const Alignment = InternPool.Alignment;
 const Zir = std.zig.Zir;
 const Type = @This();
-const SemaError = Zcu.SemaError;
 
 ip_index: InternPool.Index,
 
@@ -25,16 +23,6 @@ pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.builtin.TypeId {
     return zcu.intern_pool.zigTypeTag(ty.toIntern());
 }
 
-pub fn baseZigTypeTag(self: Type, mod: *Zcu) std.builtin.TypeId {
-    return switch (self.zigTypeTag(mod)) {
-        .error_union => self.errorUnionPayload(mod).baseZigTypeTag(mod),
-        .optional => {
-            return self.optionalChild(mod).baseZigTypeTag(mod);
-        },
-        else => |t| t,
-    };
-}
-
 /// Asserts the type is resolved.
 pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
     return switch (ty.zigTypeTag(zcu)) {
@@ -44,7 +32,7 @@ pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
         .comptime_int,
         => true,
 
-        .vector => ty.elemType2(zcu).isSelfComparable(zcu, is_equality_cmp),
+        .vector => ty.childType(zcu).isSelfComparable(zcu, is_equality_cmp),
 
         .bool,
         .type,
@@ -121,11 +109,7 @@ pub fn eql(a: Type, b: Type, zcu: *const Zcu) bool {
     return a.toIntern() == b.toIntern();
 }
 
-pub fn format(ty: Type, writer: *std.Io.Writer) !void {
-    _ = ty;
-    _ = writer;
-    @compileError("do not format types directly; use either ty.fmtDebug() or ty.fmt()");
-}
+pub const format = @compileError("do not format types directly; use either ty.fmtDebug() or ty.fmt()");
 
 pub const Formatter = std.fmt.Alt(Format, Format.default);
 
@@ -440,31 +424,7 @@ pub fn toIntern(ty: Type) InternPool.Index {
 }
 
 pub fn toValue(self: Type) Value {
-    return Value.fromInterned(self.toIntern());
-}
-
-const RuntimeBitsError = SemaError || error{NeedLazy};
-
-pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
-    return hasRuntimeBitsInner(ty, false, .eager, zcu, {}) catch unreachable;
-}
-
-pub fn hasRuntimeBitsSema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
-    return hasRuntimeBitsInner(ty, false, .sema, pt.zcu, pt.tid) catch |err| switch (err) {
-        error.NeedLazy => unreachable, // this would require a resolve strat of lazy
-        else => |e| return e,
-    };
-}
-
-pub fn hasRuntimeBitsIgnoreComptime(ty: Type, zcu: *const Zcu) bool {
-    return hasRuntimeBitsInner(ty, true, .eager, zcu, {}) catch unreachable;
-}
-
-pub fn hasRuntimeBitsIgnoreComptimeSema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
-    return hasRuntimeBitsInner(ty, true, .sema, pt.zcu, pt.tid) catch |err| switch (err) {
-        error.NeedLazy => unreachable, // this would require a resolve strat of lazy
-        else => |e| return e,
-    };
+    return .fromInterned(self.toIntern());
 }
 
 /// true if and only if the type takes up space in memory at runtime.
@@ -476,205 +436,126 @@ pub fn hasRuntimeBitsIgnoreComptimeSema(ty: Type, pt: Zcu.PerThread) SemaError!b
 /// * the type has only one possible value, making its ABI size 0.
 ///   - an enum with an explicit tag type has the ABI size of the integer tag type,
 ///     making it one-possible-value only if the integer tag type has 0 bits.
-/// When `ignore_comptime_only` is true, then types that are comptime-only
-/// may return false positives.
-pub fn hasRuntimeBitsInner(
-    ty: Type,
-    ignore_comptime_only: bool,
-    comptime strat: ResolveStratLazy,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) RuntimeBitsError!bool {
+pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
-    const io = zcu.comp.io;
-    return switch (ty.toIntern()) {
-        .empty_tuple_type => false,
-        else => switch (ip.indexToKey(ty.toIntern())) {
-            .int_type => |int_type| int_type.bits != 0,
-            .ptr_type => {
-                // Pointers to zero-bit types still have a runtime address; however, pointers
-                // to comptime-only types do not, with the exception of function pointers.
-                if (ignore_comptime_only) return true;
-                return switch (strat) {
-                    .sema => {
-                        const pt = strat.pt(zcu, tid);
-                        return !try ty.comptimeOnlySema(pt);
-                    },
-                    .eager => !ty.comptimeOnly(zcu),
-                    .lazy => error.NeedLazy,
-                };
-            },
-            .anyframe_type => true,
-            .array_type => |array_type| return array_type.lenIncludingSentinel() > 0 and
-                try Type.fromInterned(array_type.child).hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid),
-            .vector_type => |vector_type| return vector_type.len > 0 and
-                try Type.fromInterned(vector_type.child).hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid),
-            .opt_type => |child| {
-                const child_ty = Type.fromInterned(child);
-                if (child_ty.isNoReturn(zcu)) {
-                    // Then the optional is comptime-known to be null.
-                    return false;
-                }
-                if (ignore_comptime_only) return true;
-                return switch (strat) {
-                    .sema => !try child_ty.comptimeOnlyInner(.sema, zcu, tid),
-                    .eager => !child_ty.comptimeOnly(zcu),
-                    .lazy => error.NeedLazy,
-                };
-            },
-            .error_union_type,
-            .error_set_type,
-            .inferred_error_set_type,
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .int_type => |int_type| int_type.bits != 0,
+        .ptr_type => true,
+        .anyframe_type => true,
+        .array_type => |array_type| array_type.lenIncludingSentinel() > 0 and
+            Type.fromInterned(array_type.child).hasRuntimeBits(zcu),
+        .vector_type => |vector_type| vector_type.len > 0 and
+            Type.fromInterned(vector_type.child).hasRuntimeBits(zcu),
+        .opt_type => |child| !Type.fromInterned(child).isNoReturn(zcu),
+
+        .error_union_type,
+        .error_set_type,
+        .inferred_error_set_type,
+        => true,
+
+        // These are function *bodies*, not pointers.
+        // They return false here because they are comptime-only types.
+        // Special exceptions have to be made when emitting functions due to
+        // this returning false.
+        .func_type => false,
+
+        .simple_type => |t| switch (t) {
+            .f16,
+            .f32,
+            .f64,
+            .f80,
+            .f128,
+            .usize,
+            .isize,
+            .c_char,
+            .c_short,
+            .c_ushort,
+            .c_int,
+            .c_uint,
+            .c_long,
+            .c_ulong,
+            .c_longlong,
+            .c_ulonglong,
+            .c_longdouble,
+            .bool,
+            .anyerror,
+            .adhoc_inferred_error_set,
+            .anyopaque,
             => true,
 
-            // These are function *bodies*, not pointers.
-            // They return false here because they are comptime-only types.
-            // Special exceptions have to be made when emitting functions due to
-            // this returning false.
-            .func_type => false,
-
-            .simple_type => |t| switch (t) {
-                .f16,
-                .f32,
-                .f64,
-                .f80,
-                .f128,
-                .usize,
-                .isize,
-                .c_char,
-                .c_short,
-                .c_ushort,
-                .c_int,
-                .c_uint,
-                .c_long,
-                .c_ulong,
-                .c_longlong,
-                .c_ulonglong,
-                .c_longdouble,
-                .bool,
-                .anyerror,
-                .adhoc_inferred_error_set,
-                .anyopaque,
-                => true,
-
-                // These are false because they are comptime-only types.
-                .void,
-                .type,
-                .comptime_int,
-                .comptime_float,
-                .noreturn,
-                .null,
-                .undefined,
-                .enum_literal,
-                => false,
-
-                .generic_poison => unreachable,
-            },
-            .struct_type => {
-                const struct_type = ip.loadStructType(ty.toIntern());
-                if (strat != .eager and struct_type.assumeRuntimeBitsIfFieldTypesWip(ip, io)) {
-                    // In this case, we guess that hasRuntimeBits() for this type is true,
-                    // and then later if our guess was incorrect, we emit a compile error.
-                    return true;
-                }
-                switch (strat) {
-                    .sema => try ty.resolveFields(strat.pt(zcu, tid)),
-                    .eager => assert(struct_type.haveFieldTypes(ip)),
-                    .lazy => if (!struct_type.haveFieldTypes(ip)) return error.NeedLazy,
-                }
-                for (0..struct_type.field_types.len) |i| {
-                    if (struct_type.comptime_bits.getBit(ip, i)) continue;
-                    const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-                    if (try field_ty.hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid))
-                        return true;
-                } else {
-                    return false;
-                }
-            },
-            .tuple_type => |tuple| {
-                for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
-                    if (val != .none) continue; // comptime field
-                    if (try Type.fromInterned(field_ty).hasRuntimeBitsInner(
-                        ignore_comptime_only,
-                        strat,
-                        zcu,
-                        tid,
-                    )) return true;
-                }
-                return false;
-            },
-
-            .union_type => {
-                const union_type = ip.loadUnionType(ty.toIntern());
-                const union_flags = union_type.flagsUnordered(ip);
-                switch (union_flags.runtime_tag) {
-                    .none => if (strat != .eager) {
-                        // In this case, we guess that hasRuntimeBits() for this type is true,
-                        // and then later if our guess was incorrect, we emit a compile error.
-                        if (union_type.assumeRuntimeBitsIfFieldTypesWip(ip, io)) return true;
-                    },
-                    .safety, .tagged => {},
-                }
-                switch (strat) {
-                    .sema => try ty.resolveFields(strat.pt(zcu, tid)),
-                    .eager => assert(union_flags.status.haveFieldTypes()),
-                    .lazy => if (!union_flags.status.haveFieldTypes())
-                        return error.NeedLazy,
-                }
-                switch (union_flags.runtime_tag) {
-                    .none => {},
-                    .safety, .tagged => {
-                        const tag_ty = union_type.tagTypeUnordered(ip);
-                        assert(tag_ty != .none); // tag_ty should have been resolved above
-                        if (try Type.fromInterned(tag_ty).hasRuntimeBitsInner(
-                            ignore_comptime_only,
-                            strat,
-                            zcu,
-                            tid,
-                        )) {
-                            return true;
-                        }
-                    },
-                }
-                for (0..union_type.field_types.len) |field_index| {
-                    const field_ty = Type.fromInterned(union_type.field_types.get(ip)[field_index]);
-                    if (try field_ty.hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid))
-                        return true;
-                } else {
-                    return false;
-                }
-            },
-
-            .opaque_type => true,
-            .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).hasRuntimeBitsInner(
-                ignore_comptime_only,
-                strat,
-                zcu,
-                tid,
-            ),
-
-            // values, not types
-            .undef,
-            .simple_value,
-            .variable,
-            .@"extern",
-            .func,
-            .int,
-            .err,
-            .error_union,
+            .void,
+            .noreturn,
+            => false,
+
+            // primitive comptime-only types
+            .type,
+            .comptime_int,
+            .comptime_float,
+            .null,
+            .undefined,
             .enum_literal,
-            .enum_tag,
-            .empty_enum_value,
-            .float,
-            .ptr,
-            .slice,
-            .opt,
-            .aggregate,
-            .un,
-            // memoization, not types
-            .memoized_call,
-            => unreachable,
+            => false,
+
+            .generic_poison => unreachable,
         },
+        .struct_type => {
+            // TODO MLUGG: memoize this state when resolving struct?
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            for (struct_obj.field_types.get(ip), 0..) |field_ty_ip, field_idx| {
+                if (struct_obj.field_is_comptime_bits.get(ip, field_idx)) continue;
+                const field_ty: Type = .fromInterned(field_ty_ip);
+                if (field_ty.hasRuntimeBits(zcu)) return true;
+            }
+            return false;
+        },
+        .tuple_type => |tuple| {
+            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
+                if (val != .none) continue; // comptime field
+                if (Type.fromInterned(field_ty).hasRuntimeBits(zcu)) return true;
+            }
+            return false;
+        },
+        .union_type => {
+            // TODO MLUGG: memoize this state when resolving union?
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            switch (union_obj.runtime_tag) {
+                .none => {},
+                .safety, .tagged => {
+                    if (Type.fromInterned(union_obj.enum_tag_type).hasRuntimeBits(zcu)) return true;
+                },
+            }
+            for (union_obj.field_types.get(ip)) |field_ty_ip| {
+                const field_ty: Type = .fromInterned(field_ty_ip);
+                if (field_ty.hasRuntimeBits(zcu)) return true;
+            }
+            return false;
+        },
+
+        // MLUGG TODO: i think this can go away and the assert move to the defer?
+        .opaque_type => true,
+        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).hasRuntimeBits(zcu),
+
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .empty_enum_value,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
     };
 }
 
@@ -739,16 +620,15 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
         },
         .struct_type => ip.loadStructType(ty.toIntern()).layout != .auto,
         .union_type => {
-            const union_type = ip.loadUnionType(ty.toIntern());
-            return switch (union_type.flagsUnordered(ip).runtime_tag) {
-                .none, .safety => union_type.flagsUnordered(ip).layout != .auto,
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            if (union_obj.layout == .auto) return false;
+            return switch (union_obj.runtime_tag) {
+                .none => true,
                 .tagged => false,
+                .safety => unreachable, // well-defined layout can't have a safety tag
             };
         },
-        .enum_type => switch (ip.loadEnumType(ty.toIntern()).tag_mode) {
-            .auto => false,
-            .explicit, .nonexhaustive => true,
-        },
+        .enum_type => ip.loadEnumType(ty.toIntern()).int_tag_is_explicit,
 
         // values, not types
         .undef,
@@ -774,28 +654,20 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
     };
 }
 
-pub fn fnHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
-    return ty.fnHasRuntimeBitsInner(.normal, zcu, {}) catch unreachable;
-}
-
-pub fn fnHasRuntimeBitsSema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
-    return try ty.fnHasRuntimeBitsInner(.sema, pt.zcu, pt.tid);
-}
-
 /// Determines whether a function type has runtime bits, i.e. whether a
 /// function with this type can exist at runtime.
 /// Asserts that `ty` is a function type.
-pub fn fnHasRuntimeBitsInner(
-    ty: Type,
-    comptime strat: ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!bool {
-    const fn_info = zcu.typeToFunc(ty).?;
-    if (fn_info.is_generic) return false;
-    if (fn_info.is_var_args) return true;
+pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *Zcu) bool {
+    const fn_info = zcu.typeToFunc(fn_ty).?;
+    if (fn_info.comptime_bits != 0) return false;
+    for (fn_info.param_types.get(&zcu.intern_pool)) |param_ty| {
+        if (param_ty == .generic_poison_type) return false;
+        if (Type.fromInterned(param_ty).comptimeOnly(zcu)) return false;
+    }
+    if (fn_info.return_type == .generic_poison_type) return false;
+    if (Type.fromInterned(fn_info.return_type).comptimeOnly(zcu)) return false;
     if (fn_info.cc == .@"inline") return false;
-    return !try Type.fromInterned(fn_info.return_type).comptimeOnlyInner(strat, zcu, tid);
+    return true;
 }
 
 pub fn isFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
@@ -806,10 +678,11 @@ pub fn isFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
 }
 
 /// Same as `isFnOrHasRuntimeBits` but comptime-only types may return a false positive.
+/// MLUGG TODO: this function is a bit silly now...
 pub fn isFnOrHasRuntimeBitsIgnoreComptime(ty: Type, zcu: *Zcu) bool {
     return switch (ty.zigTypeTag(zcu)) {
         .@"fn" => true,
-        else => return ty.hasRuntimeBitsIgnoreComptime(zcu),
+        else => return ty.hasRuntimeBits(zcu),
     };
 }
 
@@ -818,29 +691,15 @@ pub fn isNoReturn(ty: Type, zcu: *const Zcu) bool {
 }
 
 /// Never returns `none`. Asserts that all necessary type resolution is already done.
-pub fn ptrAlignment(ty: Type, zcu: *Zcu) Alignment {
-    return ptrAlignmentInner(ty, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn ptrAlignmentSema(ty: Type, pt: Zcu.PerThread) SemaError!Alignment {
-    return try ty.ptrAlignmentInner(.sema, pt.zcu, pt.tid);
-}
-
-pub fn ptrAlignmentInner(
-    ty: Type,
-    comptime strat: ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) !Alignment {
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .ptr_type => |ptr_type| {
-            if (ptr_type.flags.alignment != .none) return ptr_type.flags.alignment;
-            const res = try Type.fromInterned(ptr_type.child).abiAlignmentInner(strat.toLazy(), zcu, tid);
-            return res.scalar;
-        },
-        .opt_type => |child| Type.fromInterned(child).ptrAlignmentInner(strat, zcu, tid),
+pub fn ptrAlignment(ptr_ty: Type, zcu: *Zcu) Alignment {
+    const ip = &zcu.intern_pool;
+    const ptr_key: InternPool.Key.PtrType = switch (ip.indexToKey(ptr_ty.toIntern())) {
+        .ptr_type => |key| key,
+        .opt_type => |child| ip.indexToKey(child).ptr_type,
         else => unreachable,
     };
+    if (ptr_key.flags.alignment != .none) return ptr_key.flags.alignment;
+    return Type.fromInterned(ptr_key.child).abiAlignment(zcu);
 }
 
 pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace {
@@ -851,861 +710,347 @@ pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace {
     };
 }
 
-/// May capture a reference to `ty`.
-/// Returned value has type `comptime_int`.
-pub fn lazyAbiAlignment(ty: Type, pt: Zcu.PerThread) !Value {
-    switch (try ty.abiAlignmentInner(.lazy, pt.zcu, pt.tid)) {
-        .val => |val| return val,
-        .scalar => |x| return pt.intValue(Type.comptime_int, x.toByteUnits() orelse 0),
-    }
-}
-
-pub const AbiAlignmentInner = union(enum) {
-    scalar: Alignment,
-    val: Value,
-};
-
-pub const ResolveStratLazy = enum {
-    /// Return a `lazy_size` or `lazy_align` value if necessary.
-    /// This value can be resolved later using `Value.resolveLazy`.
-    lazy,
-    /// Return a scalar result, expecting all necessary type resolution to be completed.
-    /// Backends should typically use this, since they must not perform type resolution.
-    eager,
-    /// Return a scalar result, performing type resolution as necessary.
-    /// This should typically be used from semantic analysis.
-    sema,
-
-    pub fn Tid(strat: ResolveStratLazy) type {
-        return switch (strat) {
-            .lazy, .sema => Zcu.PerThread.Id,
-            .eager => void,
-        };
-    }
-
-    pub fn ZcuPtr(strat: ResolveStratLazy) type {
-        return switch (strat) {
-            .eager => *const Zcu,
-            .sema, .lazy => *Zcu,
-        };
-    }
-
-    pub fn pt(
-        comptime strat: ResolveStratLazy,
-        zcu: strat.ZcuPtr(),
-        tid: strat.Tid(),
-    ) switch (strat) {
-        .lazy, .sema => Zcu.PerThread,
-        .eager => void,
-    } {
-        return switch (strat) {
-            .lazy, .sema => .{ .tid = tid, .zcu = zcu },
-            else => {},
-        };
-    }
-};
-
-/// The chosen strategy can be easily optimized away in release builds.
-/// However, in debug builds, it helps to avoid accidentally resolving types in backends.
-pub const ResolveStrat = enum {
-    /// Assert that all necessary resolution is completed.
-    /// Backends should typically use this, since they must not perform type resolution.
-    normal,
-    /// Perform type resolution as necessary using `Zcu`.
-    /// This should typically be used from semantic analysis.
-    sema,
-
-    pub fn Tid(strat: ResolveStrat) type {
-        return switch (strat) {
-            .sema => Zcu.PerThread.Id,
-            .normal => void,
-        };
-    }
-
-    pub fn ZcuPtr(strat: ResolveStrat) type {
-        return switch (strat) {
-            .normal => *const Zcu,
-            .sema => *Zcu,
-        };
-    }
-
-    pub fn pt(comptime strat: ResolveStrat, zcu: strat.ZcuPtr(), tid: strat.Tid()) switch (strat) {
-        .sema => Zcu.PerThread,
-        .normal => void,
-    } {
-        return switch (strat) {
-            .sema => .{ .tid = tid, .zcu = zcu },
-            .normal => {},
-        };
-    }
-
-    pub inline fn toLazy(strat: ResolveStrat) ResolveStratLazy {
-        return switch (strat) {
-            .normal => .eager,
-            .sema => .sema,
-        };
-    }
-};
-
 /// Never returns `none`. Asserts that all necessary type resolution is already done.
+/// MLUGG TODO:  check that it really does never return `.none`
 pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
-    return (ty.abiAlignmentInner(.eager, zcu, {}) catch unreachable).scalar;
-}
-
-pub fn abiAlignmentSema(ty: Type, pt: Zcu.PerThread) SemaError!Alignment {
-    return (try ty.abiAlignmentInner(.sema, pt.zcu, pt.tid)).scalar;
-}
-
-/// If you pass `eager` you will get back `scalar` and assert the type is resolved.
-/// In this case there will be no error, guaranteed.
-/// If you pass `lazy` you may get back `scalar` or `val`.
-/// If `val` is returned, a reference to `ty` has been captured.
-/// If you pass `sema` you will get back `scalar` and resolve the type if
-/// necessary, possibly returning a CompileError.
-pub fn abiAlignmentInner(
-    ty: Type,
-    comptime strat: ResolveStratLazy,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!AbiAlignmentInner {
-    const pt = strat.pt(zcu, tid);
-    const target = zcu.getTarget();
     const ip = &zcu.intern_pool;
-
-    switch (ty.toIntern()) {
-        .empty_tuple_type => return .{ .scalar = .@"1" },
-        else => switch (ip.indexToKey(ty.toIntern())) {
-            .int_type => |int_type| {
-                if (int_type.bits == 0) return .{ .scalar = .@"1" };
-                return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, int_type.bits)) };
-            },
-            .ptr_type, .anyframe_type => {
-                return .{ .scalar = ptrAbiAlignment(target) };
-            },
-            .array_type => |array_type| {
-                return Type.fromInterned(array_type.child).abiAlignmentInner(strat, zcu, tid);
-            },
-            .vector_type => |vector_type| {
-                if (vector_type.len == 0) return .{ .scalar = .@"1" };
-                switch (zcu.comp.getZigBackend()) {
-                    else => {
-                        // This is fine because the child type of a vector always has a bit-size known
-                        // without needing any type resolution.
-                        const elem_bits: u32 = @intCast(Type.fromInterned(vector_type.child).bitSize(zcu));
-                        if (elem_bits == 0) return .{ .scalar = .@"1" };
-                        const bytes = ((elem_bits * vector_type.len) + 7) / 8;
-                        const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
-                        return .{ .scalar = Alignment.fromByteUnits(alignment) };
-                    },
-                    .stage2_c => {
-                        return Type.fromInterned(vector_type.child).abiAlignmentInner(strat, zcu, tid);
-                    },
-                    .stage2_x86_64 => {
-                        if (vector_type.child == .bool_type) {
-                            if (vector_type.len > 256 and target.cpu.has(.x86, .avx512f)) return .{ .scalar = .@"64" };
-                            if (vector_type.len > 128 and target.cpu.has(.x86, .avx)) return .{ .scalar = .@"32" };
-                            if (vector_type.len > 64) return .{ .scalar = .@"16" };
-                            const bytes = std.math.divCeil(u32, vector_type.len, 8) catch unreachable;
-                            const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
-                            return .{ .scalar = Alignment.fromByteUnits(alignment) };
-                        }
-                        const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeInner(strat, zcu, tid)).scalar);
-                        if (elem_bytes == 0) return .{ .scalar = .@"1" };
-                        const bytes = elem_bytes * vector_type.len;
-                        if (bytes > 32 and target.cpu.has(.x86, .avx512f)) return .{ .scalar = .@"64" };
-                        if (bytes > 16 and target.cpu.has(.x86, .avx)) return .{ .scalar = .@"32" };
-                        return .{ .scalar = .@"16" };
-                    },
-                }
-            },
-
-            .opt_type => return ty.abiAlignmentInnerOptional(strat, zcu, tid),
-            .error_union_type => |info| return ty.abiAlignmentInnerErrorUnion(
-                strat,
-                zcu,
-                tid,
-                Type.fromInterned(info.payload_type),
-            ),
-
-            .error_set_type, .inferred_error_set_type => {
-                const bits = zcu.errorSetBits();
-                if (bits == 0) return .{ .scalar = .@"1" };
-                return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, bits)) };
-            },
-
-            // represents machine code; not a pointer
-            .func_type => return .{ .scalar = target_util.minFunctionAlignment(target) },
-
-            .simple_type => |t| switch (t) {
-                .bool,
-                .anyopaque,
-                => return .{ .scalar = .@"1" },
-
-                .usize,
-                .isize,
-                => return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())) },
-
-                .c_char => return .{ .scalar = cTypeAlign(target, .char) },
-                .c_short => return .{ .scalar = cTypeAlign(target, .short) },
-                .c_ushort => return .{ .scalar = cTypeAlign(target, .ushort) },
-                .c_int => return .{ .scalar = cTypeAlign(target, .int) },
-                .c_uint => return .{ .scalar = cTypeAlign(target, .uint) },
-                .c_long => return .{ .scalar = cTypeAlign(target, .long) },
-                .c_ulong => return .{ .scalar = cTypeAlign(target, .ulong) },
-                .c_longlong => return .{ .scalar = cTypeAlign(target, .longlong) },
-                .c_ulonglong => return .{ .scalar = cTypeAlign(target, .ulonglong) },
-                .c_longdouble => return .{ .scalar = cTypeAlign(target, .longdouble) },
-
-                .f16 => return .{ .scalar = .@"2" },
-                .f32 => return .{ .scalar = cTypeAlign(target, .float) },
-                .f64 => switch (target.cTypeBitSize(.double)) {
-                    64 => return .{ .scalar = cTypeAlign(target, .double) },
-                    else => return .{ .scalar = .@"8" },
-                },
-                .f80 => switch (target.cTypeBitSize(.longdouble)) {
-                    80 => return .{ .scalar = cTypeAlign(target, .longdouble) },
-                    else => return .{ .scalar = Type.u80.abiAlignment(zcu) },
+    const target = zcu.getTarget();
+    assertHasLayout(ty, zcu);
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .int_type => |int_type| {
+            if (int_type.bits == 0) return .@"1";
+            return .fromByteUnits(std.zig.target.intAlignment(target, int_type.bits));
+        },
+        .ptr_type, .anyframe_type => ptrAbiAlignment(target),
+        .array_type => |array_type| Type.fromInterned(array_type.child).abiAlignment(zcu),
+        .vector_type => |vector_type| {
+            if (vector_type.len == 0) return .@"1";
+            switch (zcu.comp.getZigBackend()) {
+                else => {
+                    const elem_bits: u32 = @intCast(Type.fromInterned(vector_type.child).bitSize(zcu));
+                    if (elem_bits == 0) return .@"1";
+                    const bytes = ((elem_bits * vector_type.len) + 7) / 8;
+                    return .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, bytes));
                 },
-                .f128 => switch (target.cTypeBitSize(.longdouble)) {
-                    128 => return .{ .scalar = cTypeAlign(target, .longdouble) },
-                    else => return .{ .scalar = .@"16" },
-                },
-
-                .anyerror, .adhoc_inferred_error_set => {
-                    const bits = zcu.errorSetBits();
-                    if (bits == 0) return .{ .scalar = .@"1" };
-                    return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, bits)) };
-                },
-
-                .void,
-                .type,
-                .comptime_int,
-                .comptime_float,
-                .null,
-                .undefined,
-                .enum_literal,
-                => return .{ .scalar = .@"1" },
-
-                .noreturn => unreachable,
-                .generic_poison => unreachable,
-            },
-            .struct_type => {
-                const struct_type = ip.loadStructType(ty.toIntern());
-                if (struct_type.layout == .@"packed") {
-                    switch (strat) {
-                        .sema => try ty.resolveLayout(pt),
-                        .lazy => if (struct_type.backingIntTypeUnordered(ip) == .none) return .{
-                            .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                .ty = .comptime_int_type,
-                                .storage = .{ .lazy_align = ty.toIntern() },
-                            } })),
-                        },
-                        .eager => {},
-                    }
-                    return .{ .scalar = Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).abiAlignment(zcu) };
-                }
-
-                if (struct_type.flagsUnordered(ip).alignment == .none) switch (strat) {
-                    .eager => unreachable, // struct alignment not resolved
-                    .sema => try ty.resolveStructAlignment(pt),
-                    .lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                        .ty = .comptime_int_type,
-                        .storage = .{ .lazy_align = ty.toIntern() },
-                    } })) },
-                };
-
-                return .{ .scalar = struct_type.flagsUnordered(ip).alignment };
-            },
-            .tuple_type => |tuple| {
-                var big_align: Alignment = .@"1";
-                for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
-                    if (val != .none) continue; // comptime field
-                    switch (try Type.fromInterned(field_ty).abiAlignmentInner(strat, zcu, tid)) {
-                        .scalar => |field_align| big_align = big_align.max(field_align),
-                        .val => switch (strat) {
-                            .eager => unreachable, // field type alignment not resolved
-                            .sema => unreachable, // passed to abiAlignmentInner above
-                            .lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                .ty = .comptime_int_type,
-                                .storage = .{ .lazy_align = ty.toIntern() },
-                            } })) },
-                        },
+                .stage2_c => return Type.fromInterned(vector_type.child).abiAlignment(zcu),
+                .stage2_x86_64 => {
+                    if (vector_type.child == .bool_type) {
+                        if (vector_type.len > 256 and target.cpu.has(.x86, .avx512f)) return .@"64";
+                        if (vector_type.len > 128 and target.cpu.has(.x86, .avx)) return .@"32";
+                        if (vector_type.len > 64) return .@"16";
+                        const bytes = std.math.divCeil(u32, vector_type.len, 8) catch unreachable;
+                        return .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, bytes));
                     }
-                }
-                return .{ .scalar = big_align };
-            },
-            .union_type => {
-                const union_type = ip.loadUnionType(ty.toIntern());
-
-                if (union_type.flagsUnordered(ip).alignment == .none) switch (strat) {
-                    .eager => unreachable, // union layout not resolved
-                    .sema => try ty.resolveUnionAlignment(pt),
-                    .lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                        .ty = .comptime_int_type,
-                        .storage = .{ .lazy_align = ty.toIntern() },
-                    } })) },
-                };
-
-                return .{ .scalar = union_type.flagsUnordered(ip).alignment };
-            },
-            .opaque_type => return .{ .scalar = .@"1" },
-            .enum_type => return .{
-                .scalar = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).abiAlignment(zcu),
-            },
-
-            // values, not types
-            .undef,
-            .simple_value,
-            .variable,
-            .@"extern",
-            .func,
-            .int,
-            .err,
-            .error_union,
+                    const elem_bytes: u32 = @intCast(Type.fromInterned(vector_type.child).abiSize(zcu));
+                    if (elem_bytes == 0) return .@"1";
+                    const bytes = elem_bytes * vector_type.len;
+                    if (bytes > 32 and target.cpu.has(.x86, .avx512f)) return .@"64";
+                    if (bytes > 16 and target.cpu.has(.x86, .avx)) return .@"32";
+                    return .@"16";
+                },
+            }
+        },
+
+        .opt_type => |child| Type.fromInterned(child).abiAlignment(zcu),
+        .error_union_type => |eu| Alignment.maxStrict(
+            Type.fromInterned(eu.payload_type).abiAlignment(zcu),
+            errorAbiAlignment(zcu),
+        ),
+
+        .error_set_type, .inferred_error_set_type => errorAbiAlignment(zcu),
+
+        .func_type => target_util.minFunctionAlignment(target),
+
+        .simple_type => |t| switch (t) {
+            .bool,
+            .void,
+            .noreturn,
+            .anyopaque,
+            .type,
+            .comptime_int,
+            .comptime_float,
+            .null,
+            .undefined,
             .enum_literal,
-            .enum_tag,
-            .empty_enum_value,
-            .float,
-            .ptr,
-            .slice,
-            .opt,
-            .aggregate,
-            .un,
-            // memoization, not types
-            .memoized_call,
-            => unreachable,
-        },
-    }
-}
+            => .@"1",
 
-fn abiAlignmentInnerErrorUnion(
-    ty: Type,
-    comptime strat: ResolveStratLazy,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-    payload_ty: Type,
-) SemaError!AbiAlignmentInner {
-    // This code needs to be kept in sync with the equivalent switch prong
-    // in abiSizeInner.
-    const code_align = Type.anyerror.abiAlignment(zcu);
-    switch (strat) {
-        .eager, .sema => {
-            if (!(payload_ty.hasRuntimeBitsInner(false, strat, zcu, tid) catch |err| switch (err) {
-                error.NeedLazy => if (strat == .lazy) {
-                    const pt = strat.pt(zcu, tid);
-                    return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                        .ty = .comptime_int_type,
-                        .storage = .{ .lazy_align = ty.toIntern() },
-                    } })) };
-                } else unreachable,
-                else => |e| return e,
-            })) {
-                return .{ .scalar = code_align };
-            }
-            return .{ .scalar = code_align.max(
-                (try payload_ty.abiAlignmentInner(strat, zcu, tid)).scalar,
-            ) };
-        },
-        .lazy => {
-            const pt = strat.pt(zcu, tid);
-            switch (try payload_ty.abiAlignmentInner(strat, zcu, tid)) {
-                .scalar => |payload_align| return .{ .scalar = code_align.max(payload_align) },
-                .val => {},
-            }
-            return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                .ty = .comptime_int_type,
-                .storage = .{ .lazy_align = ty.toIntern() },
-            } })) };
-        },
-    }
-}
+            .anyerror, .adhoc_inferred_error_set => errorAbiAlignment(zcu),
+            .usize, .isize => .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
 
-fn abiAlignmentInnerOptional(
-    ty: Type,
-    comptime strat: ResolveStratLazy,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!AbiAlignmentInner {
-    const pt = strat.pt(zcu, tid);
-    const target = zcu.getTarget();
-    const child_type = ty.optionalChild(zcu);
+            .c_char => cTypeAlign(target, .char),
+            .c_short => cTypeAlign(target, .short),
+            .c_ushort => cTypeAlign(target, .ushort),
+            .c_int => cTypeAlign(target, .int),
+            .c_uint => cTypeAlign(target, .uint),
+            .c_long => cTypeAlign(target, .long),
+            .c_ulong => cTypeAlign(target, .ulong),
+            .c_longlong => cTypeAlign(target, .longlong),
+            .c_ulonglong => cTypeAlign(target, .ulonglong),
+            .c_longdouble => cTypeAlign(target, .longdouble),
 
-    switch (child_type.zigTypeTag(zcu)) {
-        .pointer => return .{ .scalar = ptrAbiAlignment(target) },
-        .error_set => return Type.anyerror.abiAlignmentInner(strat, zcu, tid),
-        .noreturn => return .{ .scalar = .@"1" },
-        else => {},
-    }
+            .f16 => .@"2",
+            .f32 => cTypeAlign(target, .float),
+            .f64 => switch (target.cTypeBitSize(.double)) {
+                64 => cTypeAlign(target, .double),
+                else => .@"8",
+            },
+            .f80 => switch (target.cTypeBitSize(.longdouble)) {
+                80 => cTypeAlign(target, .longdouble),
+                else => Type.u80.abiAlignment(zcu),
+            },
+            .f128 => switch (target.cTypeBitSize(.longdouble)) {
+                128 => cTypeAlign(target, .longdouble),
+                else => .@"16",
+            },
 
-    switch (strat) {
-        .eager, .sema => {
-            if (!(child_type.hasRuntimeBitsInner(false, strat, zcu, tid) catch |err| switch (err) {
-                error.NeedLazy => if (strat == .lazy) {
-                    return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                        .ty = .comptime_int_type,
-                        .storage = .{ .lazy_align = ty.toIntern() },
-                    } })) };
-                } else unreachable,
-                else => |e| return e,
-            })) {
-                return .{ .scalar = .@"1" };
+            .generic_poison => unreachable,
+        },
+        .tuple_type => |tuple| {
+            var big_align: Alignment = .@"1";
+            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
+                if (val != .none) continue; // comptime field
+                const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
+                big_align = big_align.max(field_align);
             }
-            return child_type.abiAlignmentInner(strat, zcu, tid);
+            return big_align;
         },
-        .lazy => switch (try child_type.abiAlignmentInner(strat, zcu, tid)) {
-            .scalar => |x| return .{ .scalar = x.max(.@"1") },
-            .val => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                .ty = .comptime_int_type,
-                .storage = .{ .lazy_align = ty.toIntern() },
-            } })) },
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            switch (struct_obj.layout) {
+                .@"packed" => return Type.fromInterned(struct_obj.packed_backing_int_type).abiAlignment(zcu),
+                .auto, .@"extern" => return struct_obj.alignment,
+            }
         },
-    }
-}
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            switch (union_obj.layout) {
+                .@"packed" => return Type.fromInterned(union_obj.packed_backing_int_type).abiAlignment(zcu),
+                .auto, .@"extern" => return getUnionLayout(union_obj, zcu).abi_align,
+            }
+        },
+        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).abiAlignment(zcu),
+        .opaque_type => .@"1",
 
-const AbiSizeInner = union(enum) {
-    scalar: u64,
-    val: Value,
-};
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .empty_enum_value,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
+    };
+}
 
-/// Asserts the type has the ABI size already resolved.
-/// Types that return false for hasRuntimeBits() return 0.
+/// Asserts that `ty` is not an opaque type.
 pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
-    return (abiSizeInner(ty, .eager, zcu, {}) catch unreachable).scalar;
-}
-
-/// May capture a reference to `ty`.
-pub fn abiSizeLazy(ty: Type, pt: Zcu.PerThread) !Value {
-    switch (try ty.abiSizeInner(.lazy, pt.zcu, pt.tid)) {
-        .val => |val| return val,
-        .scalar => |x| return pt.intValue(Type.comptime_int, x),
-    }
-}
-
-pub fn abiSizeSema(ty: Type, pt: Zcu.PerThread) SemaError!u64 {
-    return (try abiSizeInner(ty, .sema, pt.zcu, pt.tid)).scalar;
-}
-
-/// If you pass `eager` you will get back `scalar` and assert the type is resolved.
-/// In this case there will be no error, guaranteed.
-/// If you pass `lazy` you may get back `scalar` or `val`.
-/// If `val` is returned, a reference to `ty` has been captured.
-/// If you pass `sema` you will get back `scalar` and resolve the type if
-/// necessary, possibly returning a CompileError.
-pub fn abiSizeInner(
-    ty: Type,
-    comptime strat: ResolveStratLazy,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!AbiSizeInner {
-    const target = zcu.getTarget();
     const ip = &zcu.intern_pool;
-
-    switch (ty.toIntern()) {
-        .empty_tuple_type => return .{ .scalar = 0 },
-
-        else => switch (ip.indexToKey(ty.toIntern())) {
-            .int_type => |int_type| {
-                if (int_type.bits == 0) return .{ .scalar = 0 };
-                return .{ .scalar = std.zig.target.intByteSize(target, int_type.bits) };
-            },
-            .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-                .slice => return .{ .scalar = @divExact(target.ptrBitWidth(), 8) * 2 },
-                else => return .{ .scalar = @divExact(target.ptrBitWidth(), 8) },
-            },
-            .anyframe_type => return .{ .scalar = @divExact(target.ptrBitWidth(), 8) },
-
-            .array_type => |array_type| {
-                const len = array_type.lenIncludingSentinel();
-                if (len == 0) return .{ .scalar = 0 };
-                switch (try Type.fromInterned(array_type.child).abiSizeInner(strat, zcu, tid)) {
-                    .scalar => |elem_size| return .{ .scalar = len * elem_size },
-                    .val => switch (strat) {
-                        .sema, .eager => unreachable,
-                        .lazy => {
-                            const pt = strat.pt(zcu, tid);
-                            return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                .ty = .comptime_int_type,
-                                .storage = .{ .lazy_size = ty.toIntern() },
-                            } })) };
-                        },
-                    },
-                }
-            },
-            .vector_type => |vector_type| {
-                const sub_strat: ResolveStrat = switch (strat) {
-                    .sema => .sema,
-                    .eager => .normal,
-                    .lazy => {
-                        const pt = strat.pt(zcu, tid);
-                        return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                            .ty = .comptime_int_type,
-                            .storage = .{ .lazy_size = ty.toIntern() },
-                        } })) };
-                    },
-                };
-                const alignment = (try ty.abiAlignmentInner(strat, zcu, tid)).scalar;
-                const total_bytes = switch (zcu.comp.getZigBackend()) {
-                    else => total_bytes: {
-                        const elem_bits = try Type.fromInterned(vector_type.child).bitSizeInner(sub_strat, zcu, tid);
-                        const total_bits = elem_bits * vector_type.len;
-                        break :total_bytes (total_bits + 7) / 8;
-                    },
-                    .stage2_c => total_bytes: {
-                        const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeInner(strat, zcu, tid)).scalar);
-                        break :total_bytes elem_bytes * vector_type.len;
-                    },
-                    .stage2_x86_64 => total_bytes: {
-                        if (vector_type.child == .bool_type) break :total_bytes std.math.divCeil(u32, vector_type.len, 8) catch unreachable;
-                        const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeInner(strat, zcu, tid)).scalar);
-                        break :total_bytes elem_bytes * vector_type.len;
-                    },
-                };
-                return .{ .scalar = alignment.forward(total_bytes) };
-            },
-
-            .opt_type => return ty.abiSizeInnerOptional(strat, zcu, tid),
-
-            .error_set_type, .inferred_error_set_type => {
-                const bits = zcu.errorSetBits();
-                if (bits == 0) return .{ .scalar = 0 };
-                return .{ .scalar = std.zig.target.intByteSize(target, bits) };
-            },
-
-            .error_union_type => |error_union_type| {
-                const payload_ty = Type.fromInterned(error_union_type.payload_type);
-                // This code needs to be kept in sync with the equivalent switch prong
-                // in abiAlignmentInner.
-                const code_size = Type.anyerror.abiSize(zcu);
-                if (!(payload_ty.hasRuntimeBitsInner(false, strat, zcu, tid) catch |err| switch (err) {
-                    error.NeedLazy => if (strat == .lazy) {
-                        const pt = strat.pt(zcu, tid);
-                        return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                            .ty = .comptime_int_type,
-                            .storage = .{ .lazy_size = ty.toIntern() },
-                        } })) };
-                    } else unreachable,
-                    else => |e| return e,
-                })) {
-                    // Same as anyerror.
-                    return .{ .scalar = code_size };
-                }
-                const code_align = Type.anyerror.abiAlignment(zcu);
-                const payload_align = (try payload_ty.abiAlignmentInner(strat, zcu, tid)).scalar;
-                const payload_size = switch (try payload_ty.abiSizeInner(strat, zcu, tid)) {
-                    .scalar => |elem_size| elem_size,
-                    .val => switch (strat) {
-                        .sema => unreachable,
-                        .eager => unreachable,
-                        .lazy => {
-                            const pt = strat.pt(zcu, tid);
-                            return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                .ty = .comptime_int_type,
-                                .storage = .{ .lazy_size = ty.toIntern() },
-                            } })) };
-                        },
-                    },
-                };
-
-                var size: u64 = 0;
-                if (code_align.compare(.gt, payload_align)) {
-                    size += code_size;
-                    size = payload_align.forward(size);
-                    size += payload_size;
-                    size = code_align.forward(size);
-                } else {
-                    size += payload_size;
-                    size = code_align.forward(size);
-                    size += code_size;
-                    size = payload_align.forward(size);
-                }
-                return .{ .scalar = size };
-            },
-            .func_type => unreachable, // represents machine code; not a pointer
-            .simple_type => |t| switch (t) {
-                .bool => return .{ .scalar = 1 },
-
-                .f16 => return .{ .scalar = 2 },
-                .f32 => return .{ .scalar = 4 },
-                .f64 => return .{ .scalar = 8 },
-                .f128 => return .{ .scalar = 16 },
-                .f80 => switch (target.cTypeBitSize(.longdouble)) {
-                    80 => return .{ .scalar = target.cTypeByteSize(.longdouble) },
-                    else => return .{ .scalar = Type.u80.abiSize(zcu) },
+    const target = zcu.getTarget();
+    assertHasLayout(ty, zcu);
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .int_type => |int_type| std.zig.target.intByteSize(target, int_type.bits),
+        .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
+            .slice => ptrAbiSize(target) * 2,
+            .one, .many, .c => ptrAbiSize(target),
+        },
+        .anyframe_type => ptrAbiSize(target),
+        .array_type => |arr| arr.lenIncludingSentinel() * Type.fromInterned(arr.child).abiSize(zcu),
+        .vector_type => |vec| {
+            const elem_ty: Type = .fromInterned(vec.child);
+            const bytes = switch (zcu.comp.getZigBackend()) {
+                else => std.math.divCeil(u64, vec.len * elem_ty.bitSize(zcu), 8) catch unreachable,
+                .stage2_c => vec.len * elem_ty.abiSize(zcu),
+                .stage2_x86_64 => switch (elem_ty.toIntern()) {
+                    .bool_type => std.math.divCeil(u64, vec.len, 8) catch unreachable,
+                    else => vec.len * elem_ty.abiSize(zcu),
                 },
-
-                .usize,
-                .isize,
-                => return .{ .scalar = @divExact(target.ptrBitWidth(), 8) },
-
-                .c_char => return .{ .scalar = target.cTypeByteSize(.char) },
-                .c_short => return .{ .scalar = target.cTypeByteSize(.short) },
-                .c_ushort => return .{ .scalar = target.cTypeByteSize(.ushort) },
-                .c_int => return .{ .scalar = target.cTypeByteSize(.int) },
-                .c_uint => return .{ .scalar = target.cTypeByteSize(.uint) },
-                .c_long => return .{ .scalar = target.cTypeByteSize(.long) },
-                .c_ulong => return .{ .scalar = target.cTypeByteSize(.ulong) },
-                .c_longlong => return .{ .scalar = target.cTypeByteSize(.longlong) },
-                .c_ulonglong => return .{ .scalar = target.cTypeByteSize(.ulonglong) },
-                .c_longdouble => return .{ .scalar = target.cTypeByteSize(.longdouble) },
-
-                .anyopaque,
-                .void,
-                .type,
-                .comptime_int,
-                .comptime_float,
-                .null,
-                .undefined,
-                .enum_literal,
-                => return .{ .scalar = 0 },
-
-                .anyerror, .adhoc_inferred_error_set => {
-                    const bits = zcu.errorSetBits();
-                    if (bits == 0) return .{ .scalar = 0 };
-                    return .{ .scalar = std.zig.target.intByteSize(target, bits) };
-                },
-
-                .noreturn => unreachable,
-                .generic_poison => unreachable,
-            },
-            .struct_type => {
-                const struct_type = ip.loadStructType(ty.toIntern());
-                switch (strat) {
-                    .sema => try ty.resolveLayout(strat.pt(zcu, tid)),
-                    .lazy => {
-                        const pt = strat.pt(zcu, tid);
-                        switch (struct_type.layout) {
-                            .@"packed" => {
-                                if (struct_type.backingIntTypeUnordered(ip) == .none) return .{
-                                    .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                        .ty = .comptime_int_type,
-                                        .storage = .{ .lazy_size = ty.toIntern() },
-                                    } })),
-                                };
-                            },
-                            .auto, .@"extern" => {
-                                if (!struct_type.haveLayout(ip)) return .{
-                                    .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                        .ty = .comptime_int_type,
-                                        .storage = .{ .lazy_size = ty.toIntern() },
-                                    } })),
-                                };
-                            },
-                        }
-                    },
-                    .eager => {},
-                }
-                switch (struct_type.layout) {
-                    .@"packed" => return .{
-                        .scalar = Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).abiSize(zcu),
-                    },
-                    .auto, .@"extern" => {
-                        assert(struct_type.haveLayout(ip));
-                        return .{ .scalar = struct_type.sizeUnordered(ip) };
-                    },
-                }
-            },
-            .tuple_type => |tuple| {
-                switch (strat) {
-                    .sema => try ty.resolveLayout(strat.pt(zcu, tid)),
-                    .lazy, .eager => {},
-                }
-                const field_count = tuple.types.len;
-                if (field_count == 0) {
-                    return .{ .scalar = 0 };
-                }
-                return .{ .scalar = ty.structFieldOffset(field_count, zcu) };
-            },
-
-            .union_type => {
-                const union_type = ip.loadUnionType(ty.toIntern());
-                switch (strat) {
-                    .sema => try ty.resolveLayout(strat.pt(zcu, tid)),
-                    .lazy => {
-                        const pt = strat.pt(zcu, tid);
-                        if (!union_type.flagsUnordered(ip).status.haveLayout()) return .{
-                            .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                                .ty = .comptime_int_type,
-                                .storage = .{ .lazy_size = ty.toIntern() },
-                            } })),
-                        };
-                    },
-                    .eager => {},
-                }
-
-                assert(union_type.haveLayout(ip));
-                return .{ .scalar = union_type.sizeUnordered(ip) };
-            },
-            .opaque_type => unreachable, // no size available
-            .enum_type => return .{ .scalar = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).abiSize(zcu) },
-
-            // values, not types
-            .undef,
-            .simple_value,
-            .variable,
-            .@"extern",
-            .func,
-            .int,
-            .err,
-            .error_union,
+            };
+            return ty.abiAlignment(zcu).forward(bytes);
+        },
+        .opt_type => |child_ty_ip| {
+            const child_ty: Type = .fromInterned(child_ty_ip);
+            if (child_ty.isNoReturn(zcu)) return 0;
+            const child_size = child_ty.abiSize(zcu);
+            if (ty.optionalReprIsPayload(zcu)) return child_size;
+            // Optional types are represented as a struct with the child type as the first
+            // field and a boolean as the second. Since the child type's abi alignment is
+            // guaranteed to be >= that of bool's (1 byte) the added size is exactly equal
+            // to the child type's ABI alignment.
+            return child_size + child_ty.abiAlignment(zcu).toByteUnits().?;
+        },
+        .error_set_type, .inferred_error_set_type => errorAbiSize(zcu),
+        .error_union_type => |error_union| {
+            const payload_ty: Type = .fromInterned(error_union.payload_type);
+            // This code needs to be kept in sync with the equivalent switch prong
+            // in abiAlignmentInner.
+            const code_size = errorAbiSize(zcu);
+            const code_align = errorAbiAlignment(zcu);
+            const payload_size = payload_ty.abiSize(zcu);
+            const payload_align = payload_ty.abiAlignment(zcu);
+            // The layout will either be (code, payload, padding) or (payload, code, padding)
+            // depending on which has larger alignment. So the overall size is just the code
+            // and payload sizes added and padded to the larger alignment.
+            const big_align = code_align.maxStrict(payload_align);
+            return big_align.forward(payload_size + code_size);
+        },
+        .func_type => 0,
+        .simple_type => |t| switch (t) {
+            .void,
+            .noreturn,
+            .type,
+            .comptime_int,
+            .comptime_float,
+            .null,
+            .undefined,
             .enum_literal,
-            .enum_tag,
-            .empty_enum_value,
-            .float,
-            .ptr,
-            .slice,
-            .opt,
-            .aggregate,
-            .un,
-            // memoization, not types
-            .memoized_call,
-            => unreachable,
-        },
-    }
-}
-
-fn abiSizeInnerOptional(
-    ty: Type,
-    comptime strat: ResolveStratLazy,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!AbiSizeInner {
-    const child_ty = ty.optionalChild(zcu);
+            => 0,
 
-    if (child_ty.isNoReturn(zcu)) {
-        return .{ .scalar = 0 };
-    }
+            .bool => 1,
+            .anyerror, .adhoc_inferred_error_set => errorAbiSize(zcu),
+            .usize, .isize => ptrAbiSize(target),
 
-    if (!(child_ty.hasRuntimeBitsInner(false, strat, zcu, tid) catch |err| switch (err) {
-        error.NeedLazy => if (strat == .lazy) {
-            const pt = strat.pt(zcu, tid);
-            return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
-                .ty = .comptime_int_type,
-                .storage = .{ .lazy_size = ty.toIntern() },
-            } })) };
-        } else unreachable,
-        else => |e| return e,
-    })) return .{ .scalar = 1 };
+            .c_char => target.cTypeByteSize(.char),
+            .c_short => target.cTypeByteSize(.short),
+            .c_ushort => target.cTypeByteSize(.ushort),
+            .c_int => target.cTypeByteSize(.int),
+            .c_uint => target.cTypeByteSize(.uint),
+            .c_long => target.cTypeByteSize(.long),
+            .c_ulong => target.cTypeByteSize(.ulong),
+            .c_longlong => target.cTypeByteSize(.longlong),
+            .c_ulonglong => target.cTypeByteSize(.ulonglong),
+            .c_longdouble => target.cTypeByteSize(.longdouble),
 
-    if (ty.optionalReprIsPayload(zcu)) {
-        return child_ty.abiSizeInner(strat, zcu, tid);
-    }
+            .f16 => 2,
+            .f32 => 4,
+            .f64 => 8,
+            .f80 => switch (target.cTypeBitSize(.longdouble)) {
+                80 => target.cTypeByteSize(.longdouble),
+                else => Type.u80.abiSize(zcu),
+            },
+            .f128 => 16,
 
-    const payload_size = switch (try child_ty.abiSizeInner(strat, zcu, tid)) {
-        .scalar => |elem_size| elem_size,
-        .val => switch (strat) {
-            .sema => unreachable,
-            .eager => unreachable,
-            .lazy => return .{ .val = Value.fromInterned(try strat.pt(zcu, tid).intern(.{ .int = .{
-                .ty = .comptime_int_type,
-                .storage = .{ .lazy_size = ty.toIntern() },
-            } })) },
+            .anyopaque => unreachable,
+            .generic_poison => unreachable,
+        },
+        .tuple_type => |tuple| ty.structFieldOffset(tuple.types.len, zcu),
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            switch (struct_obj.layout) {
+                .@"packed" => return Type.fromInterned(struct_obj.packed_backing_int_type).abiSize(zcu),
+                .auto, .@"extern" => return struct_obj.size,
+            }
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            switch (union_obj.layout) {
+                .@"packed" => return Type.fromInterned(union_obj.packed_backing_int_type).abiSize(zcu),
+                .auto, .@"extern" => return union_obj.size,
+            }
         },
-    };
+        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).abiSize(zcu),
+        .opaque_type => unreachable,
 
-    // Optional types are represented as a struct with the child type as the first
-    // field and a boolean as the second. Since the child type's abi alignment is
-    // guaranteed to be >= that of bool's (1 byte) the added size is exactly equal
-    // to the child type's ABI alignment.
-    return .{
-        .scalar = (child_ty.abiAlignment(zcu).toByteUnits() orelse 0) + payload_size,
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .empty_enum_value,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
     };
 }
 
 pub fn ptrAbiAlignment(target: *const Target) Alignment {
-    return Alignment.fromNonzeroByteUnits(@divExact(target.ptrBitWidth(), 8));
+    return .fromNonzeroByteUnits(@divExact(target.ptrBitWidth(), 8));
+}
+pub fn ptrAbiSize(target: *const Target) u64 {
+    return @divExact(target.ptrBitWidth(), 8);
+}
+pub fn errorAbiAlignment(zcu: *const Zcu) Alignment {
+    return .fromNonzeroByteUnits(std.zig.target.intAlignment(zcu.getTarget(), zcu.errorSetBits()));
+}
+pub fn errorAbiSize(zcu: *const Zcu) u64 {
+    return std.zig.target.intByteSize(zcu.getTarget(), zcu.errorSetBits());
 }
 
+/// Asserts that `ty` is not an opaque or comptime-only type.
+/// Once #19755 is implemented, this query will only work on types with a defined bit-level representation.
 pub fn bitSize(ty: Type, zcu: *const Zcu) u64 {
-    return bitSizeInner(ty, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn bitSizeSema(ty: Type, pt: Zcu.PerThread) SemaError!u64 {
-    return bitSizeInner(ty, .sema, pt.zcu, pt.tid);
-}
-
-pub fn bitSizeInner(
-    ty: Type,
-    comptime strat: ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!u64 {
     const target = zcu.getTarget();
     const ip = &zcu.intern_pool;
-
-    const strat_lazy: ResolveStratLazy = strat.toLazy();
-
-    switch (ip.indexToKey(ty.toIntern())) {
-        .int_type => |int_type| return int_type.bits,
+    assertHasLayout(ty, zcu);
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .int_type => |int_type| int_type.bits,
         .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-            .slice => return target.ptrBitWidth() * 2,
-            else => return target.ptrBitWidth(),
+            .slice => target.ptrBitWidth() * 2,
+            else => target.ptrBitWidth(),
         },
-        .anyframe_type => return target.ptrBitWidth(),
-
+        .anyframe_type => target.ptrBitWidth(),
         .array_type => |array_type| {
-            const len = array_type.lenIncludingSentinel();
-            if (len == 0) return 0;
             const elem_ty: Type = .fromInterned(array_type.child);
-            switch (zcu.comp.getZigBackend()) {
-                else => {
-                    const elem_size = (try elem_ty.abiSizeInner(strat_lazy, zcu, tid)).scalar;
-                    if (elem_size == 0) return 0;
-                    const elem_bit_size = try elem_ty.bitSizeInner(strat, zcu, tid);
-                    return (len - 1) * 8 * elem_size + elem_bit_size;
+            const len = array_type.lenIncludingSentinel();
+            return switch (zcu.comp.getZigBackend()) {
+                .stage2_x86_64 => len * elem_ty.bitSize(zcu),
+                // this case will be removed under #19755
+                else => switch (len) {
+                    0 => 0,
+                    else => (len - 1) * 8 * elem_ty.abiSize(zcu) + elem_ty.bitSize(zcu),
                 },
-                .stage2_x86_64 => {
-                    const elem_bit_size = try elem_ty.bitSizeInner(strat, zcu, tid);
-                    return elem_bit_size * len;
-                },
-            }
-        },
-        .vector_type => |vector_type| {
-            const child_ty: Type = .fromInterned(vector_type.child);
-            const elem_bit_size = try child_ty.bitSizeInner(strat, zcu, tid);
-            return elem_bit_size * vector_type.len;
-        },
-        .opt_type => {
-            // Optionals and error unions are not packed so their bitsize
-            // includes padding bits.
-            return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
+            };
         },
+        .vector_type => |vec| vec.len * Type.fromInterned(vec.child).bitSize(zcu),
+        .error_set_type, .inferred_error_set_type => zcu.errorSetBits(),
+        .func_type => unreachable,
 
-        .error_set_type, .inferred_error_set_type => return zcu.errorSetBits(),
-
-        .error_union_type => {
-            // Optionals and error unions are not packed so their bitsize
-            // includes padding bits.
-            return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
-        },
-        .func_type => unreachable, // represents machine code; not a pointer
         .simple_type => |t| switch (t) {
-            .f16 => return 16,
-            .f32 => return 32,
-            .f64 => return 64,
-            .f80 => return 80,
-            .f128 => return 128,
+            .void => 0,
+            .bool => 1,
+            .anyerror, .adhoc_inferred_error_set => zcu.errorSetBits(),
+            .usize, .isize => target.ptrBitWidth(),
 
-            .usize,
-            .isize,
-            => return target.ptrBitWidth(),
+            .c_char => target.cTypeBitSize(.char),
+            .c_short => target.cTypeBitSize(.short),
+            .c_ushort => target.cTypeBitSize(.ushort),
+            .c_int => target.cTypeBitSize(.int),
+            .c_uint => target.cTypeBitSize(.uint),
+            .c_long => target.cTypeBitSize(.long),
+            .c_ulong => target.cTypeBitSize(.ulong),
+            .c_longlong => target.cTypeBitSize(.longlong),
+            .c_ulonglong => target.cTypeBitSize(.ulonglong),
+            .c_longdouble => target.cTypeBitSize(.longdouble),
 
-            .c_char => return target.cTypeBitSize(.char),
-            .c_short => return target.cTypeBitSize(.short),
-            .c_ushort => return target.cTypeBitSize(.ushort),
-            .c_int => return target.cTypeBitSize(.int),
-            .c_uint => return target.cTypeBitSize(.uint),
-            .c_long => return target.cTypeBitSize(.long),
-            .c_ulong => return target.cTypeBitSize(.ulong),
-            .c_longlong => return target.cTypeBitSize(.longlong),
-            .c_ulonglong => return target.cTypeBitSize(.ulonglong),
-            .c_longdouble => return target.cTypeBitSize(.longdouble),
-
-            .bool => return 1,
-            .void => return 0,
-
-            .anyerror,
-            .adhoc_inferred_error_set,
-            => return zcu.errorSetBits(),
+            .f16 => 16,
+            .f32 => 32,
+            .f64 => 64,
+            .f80 => 80,
+            .f128 => 128,
 
             .anyopaque => unreachable,
             .type => unreachable,
@@ -1717,49 +1062,30 @@ pub fn bitSizeInner(
             .enum_literal => unreachable,
             .generic_poison => unreachable,
         },
+
         .struct_type => {
-            const struct_type = ip.loadStructType(ty.toIntern());
-            const is_packed = struct_type.layout == .@"packed";
-            if (strat == .sema) {
-                const pt = strat.pt(zcu, tid);
-                try ty.resolveFields(pt);
-                if (is_packed) try ty.resolveLayout(pt);
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            switch (struct_obj.layout) {
+                .@"packed" => return Type.fromInterned(struct_obj.packed_backing_int_type).bitSize(zcu),
+                .auto, .@"extern" => return struct_obj.size * 8, // will be `unreachable` under #19755
             }
-            if (is_packed) {
-                return try Type.fromInterned(struct_type.backingIntTypeUnordered(ip))
-                    .bitSizeInner(strat, zcu, tid);
-            }
-            return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
-        },
-
-        .tuple_type => {
-            return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
         },
-
         .union_type => {
-            const union_type = ip.loadUnionType(ty.toIntern());
-            const is_packed = ty.containerLayout(zcu) == .@"packed";
-            if (strat == .sema) {
-                const pt = strat.pt(zcu, tid);
-                try ty.resolveFields(pt);
-                if (is_packed) try ty.resolveLayout(pt);
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            switch (union_obj.layout) {
+                .@"packed" => return Type.fromInterned(union_obj.packed_backing_int_type).bitSize(zcu),
+                .auto, .@"extern" => return union_obj.size * 8, // will be `unreachable` under #19755
             }
-            if (!is_packed) {
-                return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
-            }
-            assert(union_type.flagsUnordered(ip).status.haveFieldTypes());
-
-            var size: u64 = 0;
-            for (0..union_type.field_types.len) |field_index| {
-                const field_ty = union_type.field_types.get(ip)[field_index];
-                size = @max(size, try Type.fromInterned(field_ty).bitSizeInner(strat, zcu, tid));
-            }
-
-            return size;
         },
+        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).bitSize(zcu),
+
+        // will be `unreachable` under #19755
+        .opt_type,
+        .error_union_type,
+        .tuple_type,
+        => ty.abiSize(zcu) * 8,
+
         .opaque_type => unreachable,
-        .enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty)
-            .bitSizeInner(strat, zcu, tid),
 
         // values, not types
         .undef,
@@ -1782,23 +1108,6 @@ pub fn bitSizeInner(
         // memoization, not types
         .memoized_call,
         => unreachable,
-    }
-}
-
-/// Returns true if the type's layout is already resolved and it is safe
-/// to use `abiSize`, `abiAlignment` and `bitSize` on it.
-pub fn layoutIsResolved(ty: Type, zcu: *const Zcu) bool {
-    const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).haveLayout(ip),
-        .union_type => ip.loadUnionType(ty.toIntern()).haveLayout(ip),
-        .array_type => |array_type| {
-            if (array_type.lenIncludingSentinel() == 0) return true;
-            return Type.fromInterned(array_type.child).layoutIsResolved(zcu);
-        },
-        .opt_type => |child| Type.fromInterned(child).layoutIsResolved(zcu),
-        .error_union_type => |k| Type.fromInterned(k.payload_type).layoutIsResolved(zcu),
-        else => true,
     };
 }
 
@@ -1841,7 +1150,7 @@ pub fn isSliceAtRuntime(ty: Type, zcu: *const Zcu) bool {
 }
 
 pub fn slicePtrFieldType(ty: Type, zcu: *const Zcu) Type {
-    return Type.fromInterned(zcu.intern_pool.slicePtrType(ty.toIntern()));
+    return .fromInterned(zcu.intern_pool.slicePtrType(ty.toIntern()));
 }
 
 pub fn isConstPtr(ty: Type, zcu: *const Zcu) bool {
@@ -1897,10 +1206,7 @@ pub fn isPtrAtRuntime(ty: Type, zcu: *const Zcu) bool {
 /// For pointer-like optionals, returns true, otherwise returns the allowzero property
 /// of pointers.
 pub fn ptrAllowsZero(ty: Type, zcu: *const Zcu) bool {
-    if (ty.isPtrLikeOptional(zcu)) {
-        return true;
-    }
-    return ty.ptrInfo(zcu).flags.is_allowzero;
+    return ty.isPtrLikeOptional(zcu) or ty.ptrInfo(zcu).flags.is_allowzero;
 }
 
 /// See also `isPtrLikeOptional`.
@@ -1918,7 +1224,6 @@ pub fn optionalReprIsPayload(ty: Type, zcu: *const Zcu) bool {
 
 /// Returns true if the type is optional and would be lowered to a single pointer
 /// address value, using 0 for null. Note that this returns true for C pointers.
-/// This function must be kept in sync with `Sema.typePtrOrOptionalPtrTy`.
 pub fn isPtrLikeOptional(ty: Type, zcu: *const Zcu) bool {
     return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
         .ptr_type => |ptr_type| ptr_type.flags.size == .c,
@@ -1947,52 +1252,75 @@ pub fn childTypeIp(ty: Type, ip: *const InternPool) Type {
     return Type.fromInterned(ip.childType(ty.toIntern()));
 }
 
-/// For `*[N]T`,       returns `T`.
-/// For `?*T`,         returns `T`.
-/// For `?*[N]T`,      returns `T`.
-/// For `?[*]T`,       returns `T`.
-/// For `*T`,          returns `T`.
-/// For `[*]T`,        returns `T`.
-/// For `[N]T`,        returns `T`.
-/// For `[]T`,         returns `T`.
-/// For `anyframe->T`, returns `T`.
-pub fn elemType2(ty: Type, zcu: *const Zcu) Type {
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-            .one => Type.fromInterned(ptr_type.child).shallowElemType(zcu),
-            .many, .c, .slice => Type.fromInterned(ptr_type.child),
+/// Similar to `childType`, but for pointer-like (or slice-like) optionals, gets the child type
+/// of the *pointer* type. Asserts that `ty` is either a pointer or a pointer-like optional.
+///
+/// Essentially, unwraps any one of the following into `T`:
+/// ```
+/// *T    ?*T    *allowzero T
+/// [*]T  ?[*]T  [*]allowzero T
+/// []T   ?[]T   []allowzero T
+/// [*c]T
+/// ```
+/// This is primarily useful in Sema to implement operations which can act on optional pointers.
+pub fn nullablePtrElem(ty: Type, zcu: *const Zcu) Type {
+    switch (ty.zigTypeTag(zcu)) {
+        .pointer => return ty.childType(zcu),
+        .optional => {
+            const ptr_ty = ty.childType(zcu);
+            const ptr_info = zcu.intern_pool.indexToKey(ptr_ty.toIntern()).ptr_type;
+            assert(ptr_info.flags.size != .c);
+            assert(!ptr_info.flags.is_allowzero);
+            return .fromInterned(ptr_info.child);
         },
-        .anyframe_type => |child| {
-            assert(child != .none);
-            return Type.fromInterned(child);
-        },
-        .vector_type => |vector_type| Type.fromInterned(vector_type.child),
-        .array_type => |array_type| Type.fromInterned(array_type.child),
-        .opt_type => |child| Type.fromInterned(zcu.intern_pool.childType(child)),
         else => unreachable,
-    };
+    }
 }
 
 /// Given that `ty` is an indexable pointer, returns its element type. Specifically:
 /// * for `*[n]T`, returns `T`
+/// * for `*@Vector(n, T)`, returns `T`
 /// * for `[]T`, returns `T`
 /// * for `[*]T`, returns `T`
 /// * for `[*c]T`, returns `T`
+///
+/// Tuples are not supported because they do not have a single element type.
+///
+/// MLUGG TODO: should i even have this one? it's a subset of indexableElem
 pub fn indexablePtrElem(ty: Type, zcu: *const Zcu) Type {
     const ip = &zcu.intern_pool;
     const ptr_type = ip.indexToKey(ty.toIntern()).ptr_type;
-    switch (ptr_type.flags.size) {
+    return switch (ptr_type.flags.size) {
         .many, .slice, .c => return .fromInterned(ptr_type.child),
-        .one => {},
-    }
-    const array_type = ip.indexToKey(ptr_type.child).array_type;
-    return .fromInterned(array_type.child);
+        .one => switch (ip.indexToKey(ptr_type.child)) {
+            inline .array_type, .vector_type => |arr| return .fromInterned(arr.child),
+            else => unreachable,
+        },
+    };
 }
 
-fn shallowElemType(child_ty: Type, zcu: *const Zcu) Type {
-    return switch (child_ty.zigTypeTag(zcu)) {
-        .array, .vector => child_ty.childType(zcu),
-        else => child_ty,
+/// Given that `ty` is an indexable type, returns its element type. Specifically:
+/// * for `[n]T`, returns `T`
+/// * for `@Vector(n, T)`, returns `T`
+/// * for `*[n]T`, returns `T`
+/// * for `*@Vector(n, T)`, returns `T`
+/// * for `[]T`, returns `T`
+/// * for `[*]T`, returns `T`
+/// * for `[*c]T`, returns `T`
+///
+/// Tuples are not supported because they do not have a single element type.
+pub fn indexableElem(ty: Type, zcu: *const Zcu) Type {
+    const ip = &zcu.intern_pool;
+    return switch (ip.indexToKey(ty.toIntern())) {
+        inline .array_type, .vector_type => |arr| .fromInterned(arr.child),
+        .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
+            .many, .slice, .c => .fromInterned(ptr_type.child),
+            .one => switch (ip.indexToKey(ptr_type.child)) {
+                inline .array_type, .vector_type => |arr| .fromInterned(arr.child),
+                else => unreachable,
+            },
+        },
+        else => unreachable,
     };
 }
 
@@ -2004,17 +1332,17 @@ pub fn scalarType(ty: Type, zcu: *const Zcu) Type {
     };
 }
 
-/// Asserts that the type is an optional.
-/// Note that for C pointers this returns the type unmodified.
+/// Asserts that the type is an optional, or a C pointer.
+/// For C pointers this returns the type unmodified.
 pub fn optionalChild(ty: Type, zcu: *const Zcu) Type {
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .opt_type => |child| Type.fromInterned(child),
-        .ptr_type => |ptr_type| b: {
+    switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
+        .opt_type => |child| return .fromInterned(child),
+        .ptr_type => |ptr_type| {
             assert(ptr_type.flags.size == .c);
-            break :b ty;
+            return ty;
         },
         else => unreachable,
-    };
+    }
 }
 
 /// Returns the tag type of a union, if the type is a union and it has a tag type.
@@ -2025,15 +1353,11 @@ pub fn unionTagType(ty: Type, zcu: *const Zcu) ?Type {
         .union_type => {},
         else => return null,
     }
-    const union_type = ip.loadUnionType(ty.toIntern());
-    const union_flags = union_type.flagsUnordered(ip);
-    switch (union_flags.runtime_tag) {
-        .tagged => {
-            assert(union_flags.status.haveFieldTypes());
-            return Type.fromInterned(union_type.enum_tag_ty);
-        },
-        else => return null,
-    }
+    const union_obj = ip.loadUnionType(ty.toIntern());
+    return switch (union_obj.runtime_tag) {
+        .tagged => .fromInterned(union_obj.enum_tag_type),
+        .none, .safety => null,
+    };
 }
 
 /// Same as `unionTagType` but includes safety tag.
@@ -2043,9 +1367,8 @@ pub fn unionTagTypeSafety(ty: Type, zcu: *const Zcu) ?Type {
     return switch (ip.indexToKey(ty.toIntern())) {
         .union_type => {
             const union_type = ip.loadUnionType(ty.toIntern());
-            if (!union_type.hasTag(ip)) return null;
-            assert(union_type.haveFieldTypes(ip));
-            return Type.fromInterned(union_type.enum_tag_ty);
+            if (union_type.runtime_tag == .none) return null;
+            return Type.fromInterned(union_type.enum_tag_type);
         },
         else => null,
     };
@@ -2055,7 +1378,7 @@ pub fn unionTagTypeSafety(ty: Type, zcu: *const Zcu) ?Type {
 /// not be stored at runtime.
 pub fn unionTagTypeHypothetical(ty: Type, zcu: *const Zcu) Type {
     const union_obj = zcu.typeToUnion(ty).?;
-    return Type.fromInterned(union_obj.enum_tag_ty);
+    return Type.fromInterned(union_obj.enum_tag_type);
 }
 
 pub fn unionFieldType(ty: Type, enum_tag: Value, zcu: *const Zcu) ?Type {
@@ -2105,9 +1428,9 @@ pub fn unionGetLayout(ty: Type, zcu: *const Zcu) Zcu.UnionLayout {
 pub fn containerLayout(ty: Type, zcu: *const Zcu) std.builtin.Type.ContainerLayout {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).layout,
         .tuple_type => .auto,
-        .union_type => ip.loadUnionType(ty.toIntern()).flagsUnordered(ip).layout,
+        .struct_type => ip.loadStructType(ty.toIntern()).layout,
+        .union_type => ip.loadUnionType(ty.toIntern()).layout,
         else => unreachable,
     };
 }
@@ -2182,33 +1505,6 @@ pub fn errorSetHasFieldIp(
     };
 }
 
-/// Returns whether ty, which must be an error set, includes an error `name`.
-/// Might return a false negative if `ty` is an inferred error set and not fully
-/// resolved yet.
-pub fn errorSetHasField(ty: Type, name: []const u8, zcu: *const Zcu) bool {
-    const ip = &zcu.intern_pool;
-    return switch (ty.toIntern()) {
-        .anyerror_type => true,
-        else => switch (ip.indexToKey(ty.toIntern())) {
-            .error_set_type => |error_set_type| {
-                // If the string is not interned, then the field certainly is not present.
-                const field_name_interned = ip.getString(name).unwrap() orelse return false;
-                return error_set_type.nameIndex(ip, field_name_interned) != null;
-            },
-            .inferred_error_set_type => |i| switch (ip.funcIesResolvedUnordered(i)) {
-                .anyerror_type => true,
-                .none => false,
-                else => |t| {
-                    // If the string is not interned, then the field certainly is not present.
-                    const field_name_interned = ip.getString(name).unwrap() orelse return false;
-                    return ip.indexToKey(t).error_set_type.nameIndex(ip, field_name_interned) != null;
-                },
-            },
-            else => unreachable,
-        },
-    };
-}
-
 /// Asserts the type is an array or vector or struct.
 pub fn arrayLen(ty: Type, zcu: *const Zcu) u64 {
     return ty.arrayLenIp(&zcu.intern_pool);
@@ -2308,8 +1604,12 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
         .c_ulonglong_type => return .{ .signedness = .unsigned, .bits = target.cTypeBitSize(.ulonglong) },
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => |int_type| return int_type,
-            .struct_type => ty = Type.fromInterned(ip.loadStructType(ty.toIntern()).backingIntTypeUnordered(ip)),
-            .enum_type => ty = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty),
+            .struct_type => {
+                const struct_obj = ip.loadStructType(ty.toIntern());
+                assert(struct_obj.layout == .@"packed");
+                ty = .fromInterned(struct_obj.packed_backing_int_type);
+            },
+            .enum_type => ty = .fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type),
             .vector_type => |vector_type| ty = Type.fromInterned(vector_type.child),
 
             .error_set_type, .inferred_error_set_type => {
@@ -2355,25 +1655,6 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
     };
 }
 
-pub fn isNamedInt(ty: Type) bool {
-    return switch (ty.toIntern()) {
-        .usize_type,
-        .isize_type,
-        .c_char_type,
-        .c_short_type,
-        .c_ushort_type,
-        .c_int_type,
-        .c_uint_type,
-        .c_long_type,
-        .c_ulong_type,
-        .c_longlong_type,
-        .c_ulonglong_type,
-        => true,
-
-        else => false,
-    };
-}
-
 /// Returns `false` for `comptime_float`.
 pub fn isRuntimeFloat(ty: Type) bool {
     return switch (ty.toIntern()) {
@@ -2488,17 +1769,16 @@ pub fn isNumeric(ty: Type, zcu: *const Zcu) bool {
     };
 }
 
-/// During semantic analysis, instead call `Sema.typeHasOnePossibleValue` which
-/// resolves field types rather than asserting they are already resolved.
+/// MLUGG TODO: deal with our friends structs and unions
 pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
-    const io = comp.io;
     const ip = &zcu.intern_pool;
+    assertHasLayout(starting_type, zcu);
     var ty = starting_type;
     while (true) switch (ty.toIntern()) {
-        .empty_tuple_type => return Value.empty_tuple,
+        .empty_tuple_type => return .empty_tuple,
 
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => |int_type| {
@@ -2563,31 +1843,37 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
                 .adhoc_inferred_error_set,
                 => return null,
 
-                .void => return Value.void,
-                .noreturn => return Value.@"unreachable",
-                .null => return Value.null,
-                .undefined => return Value.undef,
+                .void => return .void,
+                .noreturn => return .@"unreachable",
+                .null => return .null,
+                .undefined => return .undef,
 
                 .generic_poison => unreachable,
             },
             .struct_type => {
-                const struct_type = ip.loadStructType(ty.toIntern());
-                assert(struct_type.haveFieldTypes(ip));
-                if (struct_type.knownNonOpv(ip))
-                    return null;
-                const field_vals = try zcu.gpa.alloc(InternPool.Index, struct_type.field_types.len);
-                defer zcu.gpa.free(field_vals);
+                const struct_obj = ip.loadStructType(ty.toIntern());
+                if (struct_obj.layout == .@"packed") {
+                    const backing_ty: Type = .fromInterned(struct_obj.packed_backing_int_type);
+                    const backing_val = try backing_ty.onePossibleValue(pt) orelse return null;
+                    _ = backing_val; // MLUGG TODO: represent unions as their bits!
+                } else {
+                    if (!struct_obj.has_one_possible_value) return null;
+                }
+                // There is an OPV.
+                const field_vals = try gpa.alloc(InternPool.Index, struct_obj.field_types.len);
+                defer gpa.free(field_vals);
                 for (field_vals, 0..) |*field_val, i_usize| {
                     const i: u32 = @intCast(i_usize);
-                    if (struct_type.fieldIsComptime(ip, i)) {
-                        assert(struct_type.haveFieldInits(ip));
-                        field_val.* = struct_type.field_inits.get(ip)[i];
+                    if (struct_obj.field_is_comptime_bits.get(ip, i)) {
+                        // MLUGG TODO: this is kinda a problem... we don't necessarily know the opv field vals!
+                        // for now i'm just not letting structs with comptime fields be opv :)
+                        if (true) return null;
+                        assertHasInits(ty, zcu);
+                        field_val.* = struct_obj.field_defaults.get(ip)[i];
                         continue;
                     }
-                    const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-                    if (try field_ty.onePossibleValue(pt)) |field_opv| {
-                        field_val.* = field_opv.toIntern();
-                    } else return null;
+                    const field_ty = Type.fromInterned(struct_obj.field_types.get(ip)[i]);
+                    field_val.* = (try field_ty.onePossibleValue(pt)).?.toIntern();
                 }
 
                 // In this case the struct has no runtime-known fields and
@@ -2623,12 +1909,13 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
             },
 
             .union_type => {
+                // MLUGG TODO: is this nonsensical or what!!!!!!
                 const union_obj = ip.loadUnionType(ty.toIntern());
-                const tag_val = (try Type.fromInterned(union_obj.enum_tag_ty).onePossibleValue(pt)) orelse
+                const tag_val = (try Type.fromInterned(union_obj.enum_tag_type).onePossibleValue(pt)) orelse
                     return null;
                 if (union_obj.field_types.len == 0) {
                     const only = try pt.intern(.{ .empty_enum_value = ty.toIntern() });
-                    return Value.fromInterned(only);
+                    return .fromInterned(only);
                 }
                 const only_field_ty = union_obj.field_types.get(ip)[0];
                 const val_val = (try Type.fromInterned(only_field_ty).onePossibleValue(pt)) orelse
@@ -2638,47 +1925,34 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
                     .tag = tag_val.toIntern(),
                     .val = val_val.toIntern(),
                 });
-                return Value.fromInterned(only);
+                return .fromInterned(only);
             },
             .opaque_type => return null,
             .enum_type => {
-                const enum_type = ip.loadEnumType(ty.toIntern());
-                switch (enum_type.tag_mode) {
-                    .nonexhaustive => {
-                        if (enum_type.tag_ty == .comptime_int_type) return null;
-
-                        if (try Type.fromInterned(enum_type.tag_ty).onePossibleValue(pt)) |int_opv| {
-                            const only = try pt.intern(.{ .enum_tag = .{
-                                .ty = ty.toIntern(),
-                                .int = int_opv.toIntern(),
-                            } });
-                            return Value.fromInterned(only);
-                        }
-
-                        return null;
-                    },
-                    .auto, .explicit => {
-                        if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(zcu)) return null;
-
-                        return Value.fromInterned(switch (enum_type.names.len) {
-                            0 => try pt.intern(.{ .empty_enum_value = ty.toIntern() }),
-                            1 => try pt.intern(.{ .enum_tag = .{
-                                .ty = ty.toIntern(),
-                                .int = if (enum_type.values.len == 0)
-                                    (try pt.intValue(.fromInterned(enum_type.tag_ty), 0)).toIntern()
-                                else
-                                    try ip.getCoercedInts(
-                                        gpa,
-                                        io,
-                                        pt.tid,
-                                        ip.indexToKey(enum_type.values.get(ip)[0]).int,
-                                        enum_type.tag_ty,
-                                    ),
-                            } }),
-                            else => return null,
-                        });
-                    },
+                const enum_obj = ip.loadEnumType(ty.toIntern());
+                if (enum_obj.nonexhaustive) {
+                    const int_opv = try Type.fromInterned(enum_obj.int_tag_type).onePossibleValue(pt) orelse return null;
+                    return .fromInterned(try pt.intern(.{ .enum_tag = .{
+                        .ty = ty.toIntern(),
+                        .int = int_opv.toIntern(),
+                    } }));
                 }
+                // MLUGG TODO: this is to preserve existing semantics, i REALLY don't fuck with it...
+                if (enum_obj.int_tag_type == .comptime_int_type) {
+                    return switch (enum_obj.field_names.len) {
+                        0 => .fromInterned(try pt.intern(.{ .empty_enum_value = ty.toIntern() })),
+                        1 => try pt.enumValueFieldIndex(ty, 0),
+                        else => null,
+                    };
+                }
+                const int_tag_opv = try Type.fromInterned(enum_obj.int_tag_type).onePossibleValue(pt) orelse return null;
+                if (enum_obj.field_names.len == 0) {
+                    return .fromInterned(try pt.intern(.{ .empty_enum_value = ty.toIntern() }));
+                }
+                return .fromInterned(try pt.intern(.{ .enum_tag = .{
+                    .ty = ty.toIntern(),
+                    .int = int_tag_opv.toIntern(),
+                } }));
             },
 
             // values, not types
@@ -2706,211 +1980,106 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
     };
 }
 
-/// During semantic analysis, instead call `ty.comptimeOnlySema` which
-/// resolves field types rather than asserting they are already resolved.
+/// Asserts that `ty` has its layout resolved. `generic_poison` will return `false`.
 pub fn comptimeOnly(ty: Type, zcu: *const Zcu) bool {
-    return ty.comptimeOnlyInner(.normal, zcu, {}) catch unreachable;
-}
-
-pub fn comptimeOnlySema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
-    return try ty.comptimeOnlyInner(.sema, pt.zcu, pt.tid);
-}
-
-/// `generic_poison` will return false.
-/// May return false negatives when structs and unions are having their field types resolved.
-pub fn comptimeOnlyInner(
-    ty: Type,
-    comptime strat: ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!bool {
     const ip = &zcu.intern_pool;
-    const io = zcu.comp.io;
-    return switch (ty.toIntern()) {
-        .empty_tuple_type => false,
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .array_type => |array_type| return Type.fromInterned(array_type.child).comptimeOnly(zcu),
+        .vector_type => |vector_type| return Type.fromInterned(vector_type.child).comptimeOnly(zcu),
+        .opt_type => |child| return Type.fromInterned(child).comptimeOnly(zcu),
+        .error_union_type => |error_union_type| return Type.fromInterned(error_union_type.payload_type).comptimeOnly(zcu),
+        .enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).comptimeOnly(zcu),
 
-        else => switch (ip.indexToKey(ty.toIntern())) {
-            .int_type => false,
-            .ptr_type => |ptr_type| {
-                const child_ty = Type.fromInterned(ptr_type.child);
-                switch (child_ty.zigTypeTag(zcu)) {
-                    .@"fn" => return !try child_ty.fnHasRuntimeBitsInner(strat, zcu, tid),
-                    .@"opaque" => return false,
-                    else => return child_ty.comptimeOnlyInner(strat, zcu, tid),
-                }
-            },
-            .anyframe_type => |child| {
-                if (child == .none) return false;
-                return Type.fromInterned(child).comptimeOnlyInner(strat, zcu, tid);
-            },
-            .array_type => |array_type| return Type.fromInterned(array_type.child).comptimeOnlyInner(strat, zcu, tid),
-            .vector_type => |vector_type| return Type.fromInterned(vector_type.child).comptimeOnlyInner(strat, zcu, tid),
-            .opt_type => |child| return Type.fromInterned(child).comptimeOnlyInner(strat, zcu, tid),
-            .error_union_type => |error_union_type| return Type.fromInterned(error_union_type.payload_type).comptimeOnlyInner(strat, zcu, tid),
+        .int_type,
+        .ptr_type,
+        .anyframe_type,
+        .error_set_type,
+        .inferred_error_set_type,
+        .opaque_type,
+        => false,
 
-            .error_set_type,
-            .inferred_error_set_type,
+        // These are function bodies, not function pointers.
+        .func_type => true,
+
+        .simple_type => |t| switch (t) {
+            .f16,
+            .f32,
+            .f64,
+            .f80,
+            .f128,
+            .usize,
+            .isize,
+            .c_char,
+            .c_short,
+            .c_ushort,
+            .c_int,
+            .c_uint,
+            .c_long,
+            .c_ulong,
+            .c_longlong,
+            .c_ulonglong,
+            .c_longdouble,
+            .anyopaque,
+            .bool,
+            .void,
+            .anyerror,
+            .adhoc_inferred_error_set,
+            .noreturn,
+            .generic_poison,
             => false,
 
-            // These are function bodies, not function pointers.
-            .func_type => true,
-
-            .simple_type => |t| switch (t) {
-                .f16,
-                .f32,
-                .f64,
-                .f80,
-                .f128,
-                .usize,
-                .isize,
-                .c_char,
-                .c_short,
-                .c_ushort,
-                .c_int,
-                .c_uint,
-                .c_long,
-                .c_ulong,
-                .c_longlong,
-                .c_ulonglong,
-                .c_longdouble,
-                .anyopaque,
-                .bool,
-                .void,
-                .anyerror,
-                .adhoc_inferred_error_set,
-                .noreturn,
-                .generic_poison,
-                => false,
-
-                .type,
-                .comptime_int,
-                .comptime_float,
-                .null,
-                .undefined,
-                .enum_literal,
-                => true,
-            },
-            .struct_type => {
-                const struct_type = ip.loadStructType(ty.toIntern());
-                // packed structs cannot be comptime-only because they have a well-defined
-                // memory layout and every field has a well-defined bit pattern.
-                if (struct_type.layout == .@"packed")
-                    return false;
-
-                return switch (strat) {
-                    .normal => switch (struct_type.requiresComptime(ip)) {
-                        .wip => unreachable,
-                        .no => false,
-                        .yes => true,
-                        .unknown => unreachable,
-                    },
-                    .sema => switch (struct_type.setRequiresComptimeWip(ip, io)) {
-                        .no, .wip => false,
-                        .yes => true,
-                        .unknown => {
-                            if (struct_type.flagsUnordered(ip).field_types_wip) {
-                                struct_type.setRequiresComptime(ip, io, .unknown);
-                                return false;
-                            }
-
-                            errdefer struct_type.setRequiresComptime(ip, io, .unknown);
-
-                            const pt = strat.pt(zcu, tid);
-                            try ty.resolveFields(pt);
-
-                            for (0..struct_type.field_types.len) |i_usize| {
-                                const i: u32 = @intCast(i_usize);
-                                if (struct_type.fieldIsComptime(ip, i)) continue;
-                                const field_ty = struct_type.field_types.get(ip)[i];
-                                if (try Type.fromInterned(field_ty).comptimeOnlyInner(strat, zcu, tid)) {
-                                    // Note that this does not cause the layout to
-                                    // be considered resolved. Comptime-only types
-                                    // still maintain a layout of their
-                                    // runtime-known fields.
-                                    struct_type.setRequiresComptime(ip, io, .yes);
-                                    return true;
-                                }
-                            }
-
-                            struct_type.setRequiresComptime(ip, io, .no);
-                            return false;
-                        },
-                    },
-                };
-            },
-
-            .tuple_type => |tuple| {
-                for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
-                    const have_comptime_val = val != .none;
-                    if (!have_comptime_val and try Type.fromInterned(field_ty).comptimeOnlyInner(strat, zcu, tid)) return true;
-                }
-                return false;
-            },
-
-            .union_type => {
-                const union_type = ip.loadUnionType(ty.toIntern());
-                return switch (strat) {
-                    .normal => switch (union_type.requiresComptime(ip)) {
-                        .wip => unreachable,
-                        .no => false,
-                        .yes => true,
-                        .unknown => unreachable,
-                    },
-                    .sema => switch (union_type.setRequiresComptimeWip(ip, io)) {
-                        .no, .wip => return false,
-                        .yes => return true,
-                        .unknown => {
-                            if (union_type.flagsUnordered(ip).status == .field_types_wip) {
-                                union_type.setRequiresComptime(ip, io, .unknown);
-                                return false;
-                            }
-
-                            errdefer union_type.setRequiresComptime(ip, io, .unknown);
-
-                            const pt = strat.pt(zcu, tid);
-                            try ty.resolveFields(pt);
-
-                            for (0..union_type.field_types.len) |field_idx| {
-                                const field_ty = union_type.field_types.get(ip)[field_idx];
-                                if (try Type.fromInterned(field_ty).comptimeOnlyInner(strat, zcu, tid)) {
-                                    union_type.setRequiresComptime(ip, io, .yes);
-                                    return true;
-                                }
-                            }
-
-                            union_type.setRequiresComptime(ip, io, .no);
-                            return false;
-                        },
-                    },
-                };
-            },
-
-            .opaque_type => false,
-
-            .enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).comptimeOnlyInner(strat, zcu, tid),
-
-            // values, not types
-            .undef,
-            .simple_value,
-            .variable,
-            .@"extern",
-            .func,
-            .int,
-            .err,
-            .error_union,
+            .type,
+            .comptime_int,
+            .comptime_float,
+            .null,
+            .undefined,
             .enum_literal,
-            .enum_tag,
-            .empty_enum_value,
-            .float,
-            .ptr,
-            .slice,
-            .opt,
-            .aggregate,
-            .un,
-            // memoization, not types
-            .memoized_call,
-            => unreachable,
+            => true,
         },
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            return switch (struct_obj.layout) {
+                .@"packed" => false,
+                .auto, .@"extern" => struct_obj.comptime_only,
+            };
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            return switch (union_obj.layout) {
+                .@"packed" => false,
+                .auto, .@"extern" => union_obj.comptime_only,
+            };
+        },
+        .tuple_type => |tuple| {
+            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
+                if (val != .none) continue;
+                if (!Type.fromInterned(field_ty).comptimeOnly(zcu)) continue;
+                return true;
+            }
+            return false;
+        },
+
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .empty_enum_value,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
     };
 }
 
@@ -3056,20 +2225,18 @@ pub fn maxIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
 /// Asserts the type is an enum or a union.
 pub fn intTagType(ty: Type, zcu: *const Zcu) Type {
     const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .union_type => Type.fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_ty).intTagType(zcu),
-        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty),
+    const enum_ty: Type = switch (ip.indexToKey(ty.toIntern())) {
+        .union_type => .fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_type),
+        .enum_type => ty,
         else => unreachable,
     };
+    return .fromInterned(ip.loadEnumType(enum_ty.toIntern()).int_tag_type);
 }
 
 pub fn isNonexhaustiveEnum(ty: Type, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .enum_type => switch (ip.loadEnumType(ty.toIntern()).tag_mode) {
-            .nonexhaustive => true,
-            .auto, .explicit => false,
-        },
+        .enum_type => ip.loadEnumType(ty.toIntern()).nonexhaustive,
         else => false,
     };
 }
@@ -3090,16 +2257,16 @@ pub fn errorSetNames(ty: Type, zcu: *const Zcu) InternPool.NullTerminatedString.
 }
 
 pub fn enumFields(ty: Type, zcu: *const Zcu) InternPool.NullTerminatedString.Slice {
-    return zcu.intern_pool.loadEnumType(ty.toIntern()).names;
+    return zcu.intern_pool.loadEnumType(ty.toIntern()).field_names;
 }
 
 pub fn enumFieldCount(ty: Type, zcu: *const Zcu) usize {
-    return zcu.intern_pool.loadEnumType(ty.toIntern()).names.len;
+    return zcu.intern_pool.loadEnumType(ty.toIntern()).field_names.len;
 }
 
 pub fn enumFieldName(ty: Type, field_index: usize, zcu: *const Zcu) InternPool.NullTerminatedString {
     const ip = &zcu.intern_pool;
-    return ip.loadEnumType(ty.toIntern()).names.get(ip)[field_index];
+    return ip.loadEnumType(ty.toIntern()).field_names.get(ip)[field_index];
 }
 
 pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, zcu: *const Zcu) ?u32 {
@@ -3119,7 +2286,7 @@ pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
         .enum_tag => |info| info.int,
         else => unreachable,
     };
-    assert(ip.typeOf(int_tag) == enum_type.tag_ty);
+    assert(ip.typeOf(int_tag) == enum_type.int_tag_type);
     return enum_type.tagValueIndex(ip, int_tag);
 }
 
@@ -3127,7 +2294,7 @@ pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
 pub fn structFieldName(ty: Type, index: usize, zcu: *const Zcu) InternPool.OptionalNullTerminatedString {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).fieldName(ip, index).toOptional(),
+        .struct_type => ip.loadStructType(ty.toIntern()).field_names.get(ip)[index].toOptional(),
         .tuple_type => .none,
         else => unreachable,
     };
@@ -3145,174 +2312,95 @@ pub fn structFieldCount(ty: Type, zcu: *const Zcu) u32 {
 /// Returns the field type. Supports structs and unions.
 pub fn fieldType(ty: Type, index: usize, zcu: *const Zcu) Type {
     const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => Type.fromInterned(ip.loadStructType(ty.toIntern()).field_types.get(ip)[index]),
-        .union_type => {
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            return Type.fromInterned(union_obj.field_types.get(ip)[index]);
-        },
-        .tuple_type => |tuple| Type.fromInterned(tuple.types.get(ip)[index]),
+    const types = switch (ip.indexToKey(ty.toIntern())) {
+        .struct_type => ip.loadStructType(ty.toIntern()).field_types,
+        .union_type => ip.loadUnionType(ty.toIntern()).field_types,
+        .tuple_type => |tuple| tuple.types,
         else => unreachable,
     };
+    return .fromInterned(types.get(ip)[index]);
 }
 
-pub fn fieldAlignment(ty: Type, index: usize, zcu: *Zcu) Alignment {
-    return ty.fieldAlignmentInner(index, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn fieldAlignmentSema(ty: Type, index: usize, pt: Zcu.PerThread) SemaError!Alignment {
-    return try ty.fieldAlignmentInner(index, .sema, pt.zcu, pt.tid);
-}
+// TODO MLUGG: clean up doc comments and usages of `{resolved,explicit}FieldAlignment`
 
-/// Returns the field alignment. Supports structs and unions.
-/// If `strat` is `.sema`, may perform type resolution.
-/// Asserts the layout is not packed.
-///
-/// Provide the struct field as the `ty`.
-pub fn fieldAlignmentInner(
-    ty: Type,
-    index: usize,
-    comptime strat: ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!Alignment {
-    const ip = &zcu.intern_pool;
-    switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => {
-            const struct_type = ip.loadStructType(ty.toIntern());
-            assert(struct_type.layout != .@"packed");
-            const explicit_align = struct_type.fieldAlign(ip, index);
-            const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[index]);
-            return field_ty.structFieldAlignmentInner(explicit_align, struct_type.layout, strat, zcu, tid);
-        },
-        .tuple_type => |tuple| {
-            return (try Type.fromInterned(tuple.types.get(ip)[index]).abiAlignmentInner(
-                strat.toLazy(),
-                zcu,
-                tid,
-            )).scalar;
-        },
-        .union_type => {
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            const layout = union_obj.flagsUnordered(ip).layout;
-            assert(layout != .@"packed");
-            const explicit_align = union_obj.fieldAlign(ip, index);
-            const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[index]);
-            return field_ty.unionFieldAlignmentInner(explicit_align, layout, strat, zcu, tid);
-        },
-        else => unreachable,
+/// Returns the alignment of the given struct, tuple, or union field.
+/// Asserts that the layout of `ty` is resolved. Asserts that `ty` is not packed.
+/// Never returns `.none`, even if the field's alignment was not specified.
+pub fn resolvedFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment {
+    switch (ty.explicitFieldAlignment(index, zcu)) {
+        .none => {},
+        else => |explicit| return explicit,
     }
+    const ip = &zcu.intern_pool;
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .tuple_type => |tuple| Type.fromInterned(tuple.types.get(ip)[index]).abiAlignment(zcu),
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            const field_ty: Type = .fromInterned(struct_obj.field_types.get(ip)[index]);
+            return field_ty.defaultStructFieldAlignment(struct_obj.layout, zcu);
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[index]);
+            return field_ty.abiAlignment(zcu);
+        },
+        else => unreachable,
+    };
 }
 
-/// Returns the alignment of a non-packed struct field. Assert the layout is not packed.
-///
-/// Asserts that all resolution needed was done.
-pub fn structFieldAlignment(
+pub fn explicitFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment {
+    const ip = &zcu.intern_pool;
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .tuple_type => .none,
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            assert(struct_obj.layout != .@"packed");
+            if (struct_obj.field_aligns.len == 0) return .none;
+            return struct_obj.field_aligns.get(ip)[index];
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            assert(union_obj.layout != .@"packed");
+            if (union_obj.field_aligns.len == 0) return .none;
+            return union_obj.field_aligns.get(ip)[index];
+        },
+        else => unreachable,
+    };
+}
+
+/// Returns the alignment a struct field will have if not explicitly specified.
+/// Asserts that the layout of `field_ty` is resolved. Asserts that `layout` is not `.@"packed"`.
+pub fn defaultStructFieldAlignment(
     field_ty: Type,
-    explicit_alignment: InternPool.Alignment,
     layout: std.builtin.Type.ContainerLayout,
-    zcu: *Zcu,
+    zcu: *const Zcu,
 ) Alignment {
-    return field_ty.structFieldAlignmentInner(
-        explicit_alignment,
-        layout,
-        .normal,
-        zcu,
-        {},
-    ) catch unreachable;
-}
-
-/// Returns the alignment of a non-packed struct field. Assert the layout is not packed.
-/// May do type resolution when needed.
-/// Asserts that all resolution needed was done.
-pub fn structFieldAlignmentSema(
-    field_ty: Type,
-    explicit_alignment: InternPool.Alignment,
-    layout: std.builtin.Type.ContainerLayout,
-    pt: Zcu.PerThread,
-) SemaError!Alignment {
-    return try field_ty.structFieldAlignmentInner(
-        explicit_alignment,
-        layout,
-        .sema,
-        pt.zcu,
-        pt.tid,
-    );
-}
-
-/// Returns the alignment of a non-packed struct field. Asserts the layout is not packed.
-/// If `strat` is `.sema`, may perform type resolution.
-pub fn structFieldAlignmentInner(
-    field_ty: Type,
-    explicit_alignment: Alignment,
-    layout: std.builtin.Type.ContainerLayout,
-    comptime strat: Type.ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!Alignment {
-    assert(layout != .@"packed");
-    if (explicit_alignment != .none) return explicit_alignment;
-    const ty_abi_align = (try field_ty.abiAlignmentInner(
-        strat.toLazy(),
-        zcu,
-        tid,
-    )).scalar;
-    switch (layout) {
+    const overalign_big_int = switch (layout) {
         .@"packed" => unreachable,
-        .auto => if (zcu.getTarget().ofmt != .c) return ty_abi_align,
-        .@"extern" => {},
+        .auto => zcu.getTarget().ofmt == .c,
+        .@"extern" => true,
+    };
+    const abi_align = field_ty.abiAlignment(zcu);
+    assert(abi_align != .none);
+    if (overalign_big_int and field_ty.isAbiInt(zcu) and field_ty.intInfo(zcu).bits >= 128) {
+        return abi_align.maxStrict(.@"16");
     }
-    // extern
-    if (field_ty.isAbiInt(zcu) and field_ty.intInfo(zcu).bits >= 128) {
-        return ty_abi_align.maxStrict(.@"16");
-    }
-    return ty_abi_align;
-}
-
-pub fn unionFieldAlignmentSema(
-    field_ty: Type,
-    explicit_alignment: Alignment,
-    layout: std.builtin.Type.ContainerLayout,
-    pt: Zcu.PerThread,
-) SemaError!Alignment {
-    return field_ty.unionFieldAlignmentInner(
-        explicit_alignment,
-        layout,
-        .sema,
-        pt.zcu,
-        pt.tid,
-    );
-}
-
-pub fn unionFieldAlignmentInner(
-    field_ty: Type,
-    explicit_alignment: Alignment,
-    layout: std.builtin.Type.ContainerLayout,
-    comptime strat: Type.ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) SemaError!Alignment {
-    assert(layout != .@"packed");
-    if (explicit_alignment != .none) return explicit_alignment;
-    if (field_ty.isNoReturn(zcu)) return .none;
-    return (try field_ty.abiAlignmentInner(strat.toLazy(), zcu, tid)).scalar;
+    return abi_align;
 }
 
-pub fn structFieldDefaultValue(ty: Type, index: usize, zcu: *const Zcu) Value {
+pub fn structFieldDefaultValue(ty: Type, index: usize, zcu: *const Zcu) ?Value {
     const ip = &zcu.intern_pool;
     switch (ip.indexToKey(ty.toIntern())) {
         .struct_type => {
-            const struct_type = ip.loadStructType(ty.toIntern());
-            const val = struct_type.fieldInit(ip, index);
-            // TODO: avoid using `unreachable` to indicate this.
-            if (val == .none) return Value.@"unreachable";
-            return Value.fromInterned(val);
+            const field_defaults = ip.loadStructType(ty.toIntern()).field_defaults.get(ip);
+            if (field_defaults.len == 0) return null;
+            if (field_defaults[index] == .none) return null;
+            return .fromInterned(field_defaults[index]);
         },
         .tuple_type => |tuple| {
             const val = tuple.values.get(ip)[index];
-            // TODO: avoid using `unreachable` to indicate this.
-            if (val == .none) return Value.@"unreachable";
-            return Value.fromInterned(val);
+            if (val == .none) return null;
+            return .fromInterned(val);
         },
         else => unreachable,
     }
@@ -3324,9 +2412,9 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
     switch (ip.indexToKey(ty.toIntern())) {
         .struct_type => {
             const struct_type = ip.loadStructType(ty.toIntern());
-            if (struct_type.fieldIsComptime(ip, index)) {
-                assert(struct_type.haveFieldInits(ip));
-                return Value.fromInterned(struct_type.field_inits.get(ip)[index]);
+            if (struct_type.field_is_comptime_bits.get(ip, index)) {
+                assertHasInits(ty, zcu);
+                return .fromInterned(struct_type.field_defaults.get(ip)[index]);
             } else {
                 return Type.fromInterned(struct_type.field_types.get(ip)[index]).onePossibleValue(pt);
             }
@@ -3336,7 +2424,7 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
             if (val == .none) {
                 return Type.fromInterned(tuple.types.get(ip)[index]).onePossibleValue(pt);
             } else {
-                return Value.fromInterned(val);
+                return .fromInterned(val);
             }
         },
         else => unreachable,
@@ -3346,7 +2434,7 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
 pub fn structFieldIsComptime(ty: Type, index: usize, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).fieldIsComptime(ip, index),
+        .struct_type => ip.loadStructType(ty.toIntern()).field_is_comptime_bits.get(ip, index),
         .tuple_type => |tuple| tuple.values.get(ip)[index] != .none,
         else => unreachable,
     };
@@ -3357,15 +2445,15 @@ pub const FieldOffset = struct {
     offset: u64,
 };
 
-/// Supports structs and unions.
+/// Supports structs, tuples, and unions.
 pub fn structFieldOffset(ty: Type, index: usize, zcu: *const Zcu) u64 {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     switch (ip.indexToKey(ty.toIntern())) {
         .struct_type => {
             const struct_type = ip.loadStructType(ty.toIntern());
-            assert(struct_type.haveLayout(ip));
             assert(struct_type.layout != .@"packed");
-            return struct_type.offsets.get(ip)[index];
+            return struct_type.field_offsets.get(ip)[index];
         },
 
         .tuple_type => |tuple| {
@@ -3391,7 +2479,7 @@ pub fn structFieldOffset(ty: Type, index: usize, zcu: *const Zcu) u64 {
 
         .union_type => {
             const union_type = ip.loadUnionType(ty.toIntern());
-            if (!union_type.hasTag(ip))
+            if (union_type.runtime_tag == .none)
                 return 0;
             const layout = Type.getUnionLayout(union_type, zcu);
             if (layout.tag_align.compare(.gte, layout.payload_align)) {
@@ -3414,7 +2502,7 @@ pub fn srcLocOrNull(ty: Type, zcu: *Zcu) ?Zcu.LazySrcLoc {
             .struct_type, .union_type, .opaque_type, .enum_type => |info| switch (info) {
                 .declared => |d| d.zir_index,
                 .reified => |r| r.zir_index,
-                .generated_tag => |gt| ip.loadUnionType(gt.union_type).zir_index,
+                .generated_union_tag => |union_ty| ip.loadUnionType(union_ty).zir_index,
             },
             else => return null,
         },
@@ -3438,8 +2526,8 @@ pub fn isTuple(ty: Type, zcu: *const Zcu) bool {
     };
 }
 
-/// Traverses optional child types and error union payloads until the type
-/// is not a pointer. For `E!?u32`, returns `u32`; for `*u8`, returns `*u8`.
+/// Traverses optional child types and error union payloads until the type is neither of those.
+/// For `E!?u32`, returns `u32`; for `*u8`, returns `*u8`.
 pub fn optEuBaseType(ty: Type, zcu: *const Zcu) Type {
     var cur = ty;
     while (true) switch (cur.zigTypeTag(zcu)) {
@@ -3488,7 +2576,7 @@ pub fn typeDeclInstAllowGeneratedTag(ty: Type, zcu: *const Zcu) ?InternPool.Trac
         .union_type => ip.loadUnionType(ty.toIntern()).zir_index,
         .enum_type => |e| switch (e) {
             .declared, .reified => ip.loadEnumType(ty.toIntern()).zir_index.unwrap().?,
-            .generated_tag => |gt| ip.loadUnionType(gt.union_type).zir_index,
+            .generated_union_tag => |union_ty| ip.loadUnionType(union_ty).zir_index,
         },
         .opaque_type => ip.loadOpaqueType(ty.toIntern()).zir_index,
         else => null,
@@ -3505,7 +2593,7 @@ pub fn typeDeclSrcLine(ty: Type, zcu: *Zcu) ?u32 {
         .struct_type, .union_type, .opaque_type, .enum_type => |info| switch (info) {
             .declared => |d| d.zir_index,
             .reified => |r| r.zir_index,
-            .generated_tag => |gt| ip.loadUnionType(gt.union_type).zir_index,
+            .generated_union_tag => |union_ty| ip.loadUnionType(union_ty).zir_index,
         },
         else => return null,
     };
@@ -3520,10 +2608,10 @@ pub fn typeDeclSrcLine(ty: Type, zcu: *Zcu) ?u32 {
         .struct_init, .struct_init_ref => zir.extraData(Zir.Inst.StructInit, inst.data.pl_node.payload_index).data.abs_line,
         .struct_init_anon => zir.extraData(Zir.Inst.StructInitAnon, inst.data.pl_node.payload_index).data.abs_line,
         .extended => switch (inst.data.extended.opcode) {
-            .struct_decl => zir.extraData(Zir.Inst.StructDecl, inst.data.extended.operand).data.src_line,
-            .union_decl => zir.extraData(Zir.Inst.UnionDecl, inst.data.extended.operand).data.src_line,
-            .enum_decl => zir.extraData(Zir.Inst.EnumDecl, inst.data.extended.operand).data.src_line,
-            .opaque_decl => zir.extraData(Zir.Inst.OpaqueDecl, inst.data.extended.operand).data.src_line,
+            .struct_decl => zir.getStructDecl(info.inst).src_line,
+            .union_decl => zir.getUnionDecl(info.inst).src_line,
+            .enum_decl => zir.getEnumDecl(info.inst).src_line,
+            .opaque_decl => zir.getOpaqueDecl(info.inst).src_line,
             .reify_enum => zir.extraData(Zir.Inst.ReifyEnum, inst.data.extended.operand).data.src_line,
             .reify_struct => zir.extraData(Zir.Inst.ReifyStruct, inst.data.extended.operand).data.src_line,
             .reify_union => zir.extraData(Zir.Inst.ReifyUnion, inst.data.extended.operand).data.src_line,
@@ -3594,330 +2682,8 @@ pub fn packedStructFieldPtrInfo(
     };
 }
 
-pub fn resolveLayout(ty: Type, pt: Zcu.PerThread) SemaError!void {
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    switch (ty.zigTypeTag(zcu)) {
-        .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .tuple_type => |tuple_type| for (0..tuple_type.types.len) |i| {
-                const field_ty = Type.fromInterned(tuple_type.types.get(ip)[i]);
-                try field_ty.resolveLayout(pt);
-            },
-            .struct_type => return ty.resolveStructInner(pt, .layout),
-            else => unreachable,
-        },
-        .@"union" => return ty.resolveUnionInner(pt, .layout),
-        .array => {
-            if (ty.arrayLenIncludingSentinel(zcu) == 0) return;
-            const elem_ty = ty.childType(zcu);
-            return elem_ty.resolveLayout(pt);
-        },
-        .optional => {
-            const payload_ty = ty.optionalChild(zcu);
-            return payload_ty.resolveLayout(pt);
-        },
-        .error_union => {
-            const payload_ty = ty.errorUnionPayload(zcu);
-            return payload_ty.resolveLayout(pt);
-        },
-        .@"fn" => {
-            const info = zcu.typeToFunc(ty).?;
-            if (info.is_generic) {
-                // Resolving of generic function types is deferred to when
-                // the function is instantiated.
-                return;
-            }
-            for (0..info.param_types.len) |i| {
-                const param_ty = info.param_types.get(ip)[i];
-                try Type.fromInterned(param_ty).resolveLayout(pt);
-            }
-            try Type.fromInterned(info.return_type).resolveLayout(pt);
-        },
-        else => {},
-    }
-}
-
-pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
-    const ip = &pt.zcu.intern_pool;
-    const ty_ip = ty.toIntern();
-
-    switch (ty_ip) {
-        .none => unreachable,
-
-        .u0_type,
-        .i0_type,
-        .u1_type,
-        .u8_type,
-        .i8_type,
-        .u16_type,
-        .i16_type,
-        .u29_type,
-        .u32_type,
-        .i32_type,
-        .u64_type,
-        .i64_type,
-        .u80_type,
-        .u128_type,
-        .i128_type,
-        .usize_type,
-        .isize_type,
-        .c_char_type,
-        .c_short_type,
-        .c_ushort_type,
-        .c_int_type,
-        .c_uint_type,
-        .c_long_type,
-        .c_ulong_type,
-        .c_longlong_type,
-        .c_ulonglong_type,
-        .c_longdouble_type,
-        .f16_type,
-        .f32_type,
-        .f64_type,
-        .f80_type,
-        .f128_type,
-        .anyopaque_type,
-        .bool_type,
-        .void_type,
-        .type_type,
-        .anyerror_type,
-        .adhoc_inferred_error_set_type,
-        .comptime_int_type,
-        .comptime_float_type,
-        .noreturn_type,
-        .anyframe_type,
-        .null_type,
-        .undefined_type,
-        .enum_literal_type,
-        .ptr_usize_type,
-        .ptr_const_comptime_int_type,
-        .manyptr_u8_type,
-        .manyptr_const_u8_type,
-        .manyptr_const_u8_sentinel_0_type,
-        .slice_const_u8_type,
-        .slice_const_u8_sentinel_0_type,
-        .optional_noreturn_type,
-        .anyerror_void_error_union_type,
-        .generic_poison_type,
-        .empty_tuple_type,
-        => {},
-
-        .undef => unreachable,
-        .zero => unreachable,
-        .zero_usize => unreachable,
-        .zero_u1 => unreachable,
-        .zero_u8 => unreachable,
-        .one => unreachable,
-        .one_usize => unreachable,
-        .one_u1 => unreachable,
-        .one_u8 => unreachable,
-        .four_u8 => unreachable,
-        .negative_one => unreachable,
-        .void_value => unreachable,
-        .unreachable_value => unreachable,
-        .null_value => unreachable,
-        .bool_true => unreachable,
-        .bool_false => unreachable,
-        .empty_tuple => unreachable,
-
-        else => switch (ty_ip.unwrap(ip).getTag(ip)) {
-            .type_struct,
-            .type_struct_packed,
-            .type_struct_packed_inits,
-            => return ty.resolveStructInner(pt, .fields),
-
-            .type_union => return ty.resolveUnionInner(pt, .fields),
-
-            else => {},
-        },
-    }
-}
-
-pub fn resolveFully(ty: Type, pt: Zcu.PerThread) SemaError!void {
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-
-    switch (ty.zigTypeTag(zcu)) {
-        .type,
-        .void,
-        .bool,
-        .noreturn,
-        .int,
-        .float,
-        .comptime_float,
-        .comptime_int,
-        .undefined,
-        .null,
-        .error_set,
-        .@"enum",
-        .@"opaque",
-        .frame,
-        .@"anyframe",
-        .vector,
-        .enum_literal,
-        => {},
-
-        .pointer => return ty.childType(zcu).resolveFully(pt),
-        .array => return ty.childType(zcu).resolveFully(pt),
-        .optional => return ty.optionalChild(zcu).resolveFully(pt),
-        .error_union => return ty.errorUnionPayload(zcu).resolveFully(pt),
-        .@"fn" => {
-            const info = zcu.typeToFunc(ty).?;
-            if (info.is_generic) return;
-            for (0..info.param_types.len) |i| {
-                const param_ty = info.param_types.get(ip)[i];
-                try Type.fromInterned(param_ty).resolveFully(pt);
-            }
-            try Type.fromInterned(info.return_type).resolveFully(pt);
-        },
-
-        .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .tuple_type => |tuple_type| for (0..tuple_type.types.len) |i| {
-                const field_ty = Type.fromInterned(tuple_type.types.get(ip)[i]);
-                try field_ty.resolveFully(pt);
-            },
-            .struct_type => return ty.resolveStructInner(pt, .full),
-            else => unreachable,
-        },
-        .@"union" => return ty.resolveUnionInner(pt, .full),
-    }
-}
-
-pub fn resolveStructFieldInits(ty: Type, pt: Zcu.PerThread) SemaError!void {
-    // TODO: stop calling this for tuples!
-    _ = pt.zcu.typeToStruct(ty) orelse return;
-    return ty.resolveStructInner(pt, .inits);
-}
-
-pub fn resolveStructAlignment(ty: Type, pt: Zcu.PerThread) SemaError!void {
-    return ty.resolveStructInner(pt, .alignment);
-}
-
-pub fn resolveUnionAlignment(ty: Type, pt: Zcu.PerThread) SemaError!void {
-    return ty.resolveUnionInner(pt, .alignment);
-}
-
-/// `ty` must be a struct.
-fn resolveStructInner(
-    ty: Type,
-    pt: Zcu.PerThread,
-    resolution: enum { fields, inits, alignment, layout, full },
-) SemaError!void {
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
-
-    const struct_obj = zcu.typeToStruct(ty).?;
-    const owner: InternPool.AnalUnit = .wrap(.{ .type = ty.toIntern() });
-
-    if (zcu.failed_analysis.contains(owner) or zcu.transitive_failed_analysis.contains(owner)) {
-        return error.AnalysisFail;
-    }
-
-    if (zcu.comp.debugIncremental()) {
-        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, owner);
-        info.last_update_gen = zcu.generation;
-    }
-
-    var analysis_arena = std.heap.ArenaAllocator.init(gpa);
-    defer analysis_arena.deinit();
-
-    var comptime_err_ret_trace = std.array_list.Managed(Zcu.LazySrcLoc).init(gpa);
-    defer comptime_err_ret_trace.deinit();
-
-    const zir = zcu.namespacePtr(struct_obj.namespace).fileScope(zcu).zir.?;
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = analysis_arena.allocator(),
-        .code = zir,
-        .owner = owner,
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = Type.void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
-
-    (switch (resolution) {
-        .fields => sema.resolveStructFieldTypes(ty.toIntern(), struct_obj),
-        .inits => sema.resolveStructFieldInits(ty),
-        .alignment => sema.resolveStructAlignment(ty.toIntern(), struct_obj),
-        .layout => sema.resolveStructLayout(ty),
-        .full => sema.resolveStructFully(ty),
-    }) catch |err| switch (err) {
-        error.AnalysisFail => {
-            if (!zcu.failed_analysis.contains(owner)) {
-                try zcu.transitive_failed_analysis.put(gpa, owner, {});
-            }
-            return error.AnalysisFail;
-        },
-        error.OutOfMemory, error.Canceled => |e| return e,
-    };
-}
-
-/// `ty` must be a union.
-fn resolveUnionInner(
-    ty: Type,
-    pt: Zcu.PerThread,
-    resolution: enum { fields, alignment, layout, full },
-) SemaError!void {
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
-
-    const union_obj = zcu.typeToUnion(ty).?;
-    const owner: InternPool.AnalUnit = .wrap(.{ .type = ty.toIntern() });
-
-    if (zcu.failed_analysis.contains(owner) or zcu.transitive_failed_analysis.contains(owner)) {
-        return error.AnalysisFail;
-    }
-
-    if (zcu.comp.debugIncremental()) {
-        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, owner);
-        info.last_update_gen = zcu.generation;
-    }
-
-    var analysis_arena = std.heap.ArenaAllocator.init(gpa);
-    defer analysis_arena.deinit();
-
-    var comptime_err_ret_trace = std.array_list.Managed(Zcu.LazySrcLoc).init(gpa);
-    defer comptime_err_ret_trace.deinit();
-
-    const zir = zcu.namespacePtr(union_obj.namespace).fileScope(zcu).zir.?;
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = analysis_arena.allocator(),
-        .code = zir,
-        .owner = owner,
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = Type.void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
-
-    (switch (resolution) {
-        .fields => sema.resolveUnionFieldTypes(ty, union_obj),
-        .alignment => sema.resolveUnionAlignment(ty, union_obj),
-        .layout => sema.resolveUnionLayout(ty),
-        .full => sema.resolveUnionFully(ty),
-    }) catch |err| switch (err) {
-        error.AnalysisFail => {
-            if (!zcu.failed_analysis.contains(owner)) {
-                try zcu.transitive_failed_analysis.put(gpa, owner, {});
-            }
-            return error.AnalysisFail;
-        },
-        error.OutOfMemory => |e| return e,
-        error.Canceled => |e| return e,
-    };
-}
-
 pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu) Zcu.UnionLayout {
     const ip = &zcu.intern_pool;
-    assert(loaded_union.haveLayout(ip));
     var most_aligned_field: u32 = 0;
     var most_aligned_field_align: InternPool.Alignment = .@"1";
     var most_aligned_field_size: u64 = 0;
@@ -3928,11 +2694,14 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
         const field_ty: Type = .fromInterned(field_ty_ip_index);
         if (field_ty.isNoReturn(zcu)) continue;
 
-        const explicit_align = loaded_union.fieldAlign(ip, field_index);
-        const field_align = if (explicit_align != .none)
-            explicit_align
-        else
-            field_ty.abiAlignment(zcu);
+        const field_align: InternPool.Alignment = a: {
+            const explicit_aligns = loaded_union.field_aligns.get(ip);
+            if (explicit_aligns.len > 0) {
+                const a = explicit_aligns[field_index];
+                if (a != .none) break :a a;
+            }
+            break :a field_ty.abiAlignment(zcu);
+        };
         if (field_ty.hasRuntimeBits(zcu)) {
             const field_size = field_ty.abiSize(zcu);
             if (field_size > payload_size) {
@@ -3947,8 +2716,9 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
         }
         payload_align = payload_align.max(field_align);
     }
-    const have_tag = loaded_union.flagsUnordered(ip).runtime_tag.hasTag();
-    if (!have_tag or !Type.fromInterned(loaded_union.enum_tag_ty).hasRuntimeBits(zcu)) {
+    if (loaded_union.runtime_tag == .none or
+        !Type.fromInterned(loaded_union.enum_tag_type).hasRuntimeBits(zcu))
+    {
         return .{
             .abi_size = payload_align.forward(payload_size),
             .abi_align = payload_align,
@@ -3963,10 +2733,10 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
         };
     }
 
-    const tag_size = Type.fromInterned(loaded_union.enum_tag_ty).abiSize(zcu);
-    const tag_align = Type.fromInterned(loaded_union.enum_tag_ty).abiAlignment(zcu).max(.@"1");
+    const tag_size = Type.fromInterned(loaded_union.enum_tag_type).abiSize(zcu);
+    const tag_align = Type.fromInterned(loaded_union.enum_tag_type).abiAlignment(zcu).max(.@"1");
     return .{
-        .abi_size = loaded_union.sizeUnordered(ip),
+        .abi_size = loaded_union.size,
         .abi_align = tag_align.max(payload_align),
         .most_aligned_field = most_aligned_field,
         .most_aligned_field_size = most_aligned_field_size,
@@ -3975,7 +2745,7 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
         .payload_align = payload_align,
         .tag_align = tag_align,
         .tag_size = tag_size,
-        .padding = loaded_union.paddingUnordered(ip),
+        .padding = loaded_union.padding,
     };
 }
 
@@ -3989,10 +2759,17 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
 /// Handles const-ness and address spaces in particular.
 /// This code is duplicated in `Sema.analyzePtrArithmetic`.
 /// May perform type resolution and return a transitive `error.AnalysisFail`.
+/// MLUGG TODO audit this shit
 pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {
     const zcu = pt.zcu;
     const ptr_info = ptr_ty.ptrInfo(zcu);
-    const elem_ty = ptr_ty.elemType2(zcu);
+    const elem_ty: Type = switch (ptr_info.flags.size) {
+        .one => switch (Type.fromInterned(ptr_info.child).zigTypeTag(zcu)) {
+            .array, .vector => Type.fromInterned(ptr_info.child).childType(zcu),
+            else => .fromInterned(ptr_info.child),
+        },
+        .many, .c, .slice => .fromInterned(ptr_info.child),
+    };
     const is_allowzero = ptr_info.flags.is_allowzero and (offset orelse 0) == 0;
     const parent_ty = ptr_ty.childType(zcu);
 
@@ -4024,7 +2801,7 @@ pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {
         }
         // If the addend is not a comptime-known value we can still count on
         // it being a multiple of the type size.
-        const elem_size = (try elem_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar;
+        const elem_size = elem_ty.abiSize(zcu);
         const addend = if (offset) |off| elem_size * off else elem_size;
 
         // The resulting pointer is aligned to the lcd between the offset (an
@@ -4037,7 +2814,7 @@ pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {
         assert(new_align != .none);
         break :a new_align;
     };
-    return pt.ptrTypeSema(.{
+    return pt.ptrType(.{
         .child = elem_ty.toIntern(),
         .flags = .{
             .alignment = alignment,
@@ -4069,11 +2846,107 @@ pub fn containerTypeName(ty: Type, ip: *const InternPool) InternPool.NullTermina
 /// Returns `null` otherwise.
 pub fn isNullFromType(ty: Type, zcu: *const Zcu) ?bool {
     if (ty.zigTypeTag(zcu) != .optional and !ty.isCPtr(zcu)) return false;
-    const child = ty.optionalChild(zcu);
-    if (child.zigTypeTag(zcu) == .noreturn) return true; // `?noreturn` is always null
+    if (ty.optionalChild(zcu).isNoReturn(zcu)) return true; // `?noreturn` is always null
     return null;
 }
 
+/// Returns true if `ty` is allowed in packed types.
+pub fn packable(ty: Type, zcu: *const Zcu) bool {
+    return switch (ty.zigTypeTag(zcu)) {
+        .type,
+        .comptime_float,
+        .comptime_int,
+        .enum_literal,
+        .undefined,
+        .null,
+        .error_union,
+        .error_set,
+        .frame,
+        .noreturn,
+        .@"opaque",
+        .@"anyframe",
+        .@"fn",
+        .array,
+        => false,
+        .optional => return ty.isPtrLikeOptional(zcu),
+        .void,
+        .bool,
+        .float,
+        .int,
+        .vector,
+        => true,
+        .@"enum" => zcu.intern_pool.loadEnumType(ty.toIntern()).int_tag_is_explicit,
+        .pointer => !ty.isSlice(zcu),
+        .@"struct", .@"union" => ty.containerLayout(zcu) == .@"packed",
+    };
+}
+
+/// Asserts that `ty` has resolved layout.
+pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
+    switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
+        .int_type,
+        .ptr_type,
+        .anyframe_type,
+        .simple_type,
+        .opaque_type,
+        .enum_type,
+        .error_set_type,
+        .inferred_error_set_type,
+        => {},
+        .func_type => |func_type| {
+            for (func_type.param_types.get(&zcu.intern_pool)) |param_ty| {
+                assertHasLayout(.fromInterned(param_ty), zcu);
+            }
+            assertHasLayout(.fromInterned(func_type.return_type), zcu);
+        },
+        .array_type => |arr| assertHasLayout(.fromInterned(arr.child), zcu),
+        .vector_type => |vec| assertHasLayout(.fromInterned(vec.child), zcu),
+        .opt_type => |child| assertHasLayout(.fromInterned(child), zcu),
+        .error_union_type => |eu| assertHasLayout(.fromInterned(eu.payload_type), zcu),
+        .tuple_type => |tuple| for (tuple.types.get(&zcu.intern_pool)) |field_ty| {
+            assertHasLayout(.fromInterned(field_ty), zcu);
+        },
+        .struct_type, .union_type => {
+            const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
+            assert(!zcu.outdated.contains(unit));
+            assert(!zcu.potentially_outdated.contains(unit));
+        },
+        else => unreachable, // assertion failure; not a struct or union
+
+        // values, not types
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .empty_enum_value,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
+    }
+}
+
+/// Asserts that `ty` is an enum or struct type whose field values/defaults are resolved.
+pub fn assertHasInits(ty: Type, zcu: *const Zcu) void {
+    switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
+        .struct_type, .enum_type => {},
+        else => unreachable,
+    }
+    const unit: InternPool.AnalUnit = .wrap(.{ .type_inits = ty.toIntern() });
+    assert(!zcu.outdated.contains(unit));
+    assert(!zcu.potentially_outdated.contains(unit));
+}
+
 /// Recursively walks the type and marks for each subtype how many times it has been seen
 fn collectSubtypes(ty: Type, pt: Zcu.PerThread, visited: *std.AutoArrayHashMapUnmanaged(Type, u16)) error{OutOfMemory}!void {
     const zcu = pt.zcu;
diff --git a/src/Value.zig b/src/Value.zig
index 103140d3c9a3df0878f1ceb254ba2bb483ea2865..5986eee6d652b135fd2b28bfc2f839bdd578486e 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -146,80 +146,22 @@ pub fn toType(self: Value) Type {
     return Type.fromInterned(self.toIntern());
 }
 
-pub fn intFromEnum(val: Value, ty: Type, pt: Zcu.PerThread) Allocator.Error!Value {
-    const ip = &pt.zcu.intern_pool;
-    const enum_ty = ip.typeOf(val.toIntern());
-    return switch (ip.indexToKey(enum_ty)) {
-        // Assume it is already an integer and return it directly.
-        .simple_type, .int_type => val,
-        .enum_literal => |enum_literal| {
-            const field_index = ty.enumFieldIndex(enum_literal, pt.zcu).?;
-            switch (ip.indexToKey(ty.toIntern())) {
-                // Assume it is already an integer and return it directly.
-                .simple_type, .int_type => return val,
-                .enum_type => {
-                    const enum_type = ip.loadEnumType(ty.toIntern());
-                    if (enum_type.values.len != 0) {
-                        return Value.fromInterned(enum_type.values.get(ip)[field_index]);
-                    } else {
-                        // Field index and integer values are the same.
-                        return pt.intValue(Type.fromInterned(enum_type.tag_ty), field_index);
-                    }
-                },
-                else => unreachable,
-            }
-        },
-        .enum_type => try pt.getCoerced(val, Type.fromInterned(ip.loadEnumType(enum_ty).tag_ty)),
-        else => unreachable,
-    };
+pub fn intFromEnum(val: Value, zcu: *const Zcu) Value {
+    return .fromInterned(zcu.intern_pool.indexToKey(val.toIntern()).enum_tag.int);
 }
 
-pub const ResolveStrat = Type.ResolveStrat;
-
-/// Asserts the value is an integer.
+/// Asserts that `val` is an integer.
 pub fn toBigInt(val: Value, space: *BigIntSpace, zcu: *Zcu) BigIntConst {
-    return val.toBigIntAdvanced(space, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn toBigIntSema(val: Value, space: *BigIntSpace, pt: Zcu.PerThread) !BigIntConst {
-    return try val.toBigIntAdvanced(space, .sema, pt.zcu, pt.tid);
-}
-
-/// Asserts the value is an integer.
-pub fn toBigIntAdvanced(
-    val: Value,
-    space: *BigIntSpace,
-    comptime strat: ResolveStrat,
-    zcu: *Zcu,
-    tid: strat.Tid(),
-) Zcu.SemaError!BigIntConst {
+    if (val.getUnsignedInt(zcu)) |x| {
+        return BigIntMutable.init(&space.limbs, x).toConst();
+    }
     const ip = &zcu.intern_pool;
-    return switch (val.toIntern()) {
-        .bool_false => BigIntMutable.init(&space.limbs, 0).toConst(),
-        .bool_true => BigIntMutable.init(&space.limbs, 1).toConst(),
-        .null_value => BigIntMutable.init(&space.limbs, 0).toConst(),
-        else => switch (ip.indexToKey(val.toIntern())) {
-            .int => |int| switch (int.storage) {
-                .u64, .i64, .big_int => int.storage.toBigInt(space),
-                .lazy_align, .lazy_size => |ty| {
-                    if (strat == .sema) try Type.fromInterned(ty).resolveLayout(strat.pt(zcu, tid));
-                    const x = switch (int.storage) {
-                        else => unreachable,
-                        .lazy_align => Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0,
-                        .lazy_size => Type.fromInterned(ty).abiSize(zcu),
-                    };
-                    return BigIntMutable.init(&space.limbs, x).toConst();
-                },
-            },
-            .enum_tag => |enum_tag| Value.fromInterned(enum_tag.int).toBigIntAdvanced(space, strat, zcu, tid),
-            .opt, .ptr => BigIntMutable.init(
-                &space.limbs,
-                (try val.getUnsignedIntInner(strat, zcu, tid)).?,
-            ).toConst(),
-            .err => |err| BigIntMutable.init(&space.limbs, ip.getErrorValueIfExists(err.name).?).toConst(),
-            else => unreachable,
-        },
+    const int_key = switch (ip.indexToKey(val.toIntern())) {
+        .enum_tag => |enum_tag| ip.indexToKey(enum_tag.int).int,
+        .int => |int| int,
+        else => unreachable,
     };
+    return int_key.storage.toBigInt(space);
 }
 
 pub fn isFuncBody(val: Value, zcu: *Zcu) bool {
@@ -240,31 +182,17 @@ pub fn getVariable(val: Value, mod: *Zcu) ?InternPool.Key.Variable {
     };
 }
 
-/// If the value fits in a u64, return it, otherwise null.
-/// Asserts not undefined.
-pub fn getUnsignedInt(val: Value, zcu: *const Zcu) ?u64 {
-    return getUnsignedIntInner(val, .normal, zcu, {}) catch unreachable;
-}
-
-/// Asserts the value is an integer and it fits in a u64
+/// Asserts the value is a (defined) integer and it fits in a u64.
 pub fn toUnsignedInt(val: Value, zcu: *const Zcu) u64 {
     return getUnsignedInt(val, zcu).?;
 }
 
-pub fn getUnsignedIntSema(val: Value, pt: Zcu.PerThread) !?u64 {
-    return try val.getUnsignedIntInner(.sema, pt.zcu, pt.tid);
-}
-
 /// If the value fits in a u64, return it, otherwise null.
 /// Asserts not undefined.
-pub fn getUnsignedIntInner(
-    val: Value,
-    comptime strat: ResolveStrat,
-    zcu: strat.ZcuPtr(),
-    tid: strat.Tid(),
-) !?u64 {
+pub fn getUnsignedInt(val: Value, zcu: *const Zcu) ?u64 {
     return switch (val.toIntern()) {
         .undef => unreachable,
+        .null_value => 0,
         .bool_false => 0,
         .bool_true => 1,
         else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
@@ -273,37 +201,27 @@ pub fn getUnsignedIntInner(
                 .big_int => |big_int| big_int.toInt(u64) catch null,
                 .u64 => |x| x,
                 .i64 => |x| std.math.cast(u64, x),
-                .lazy_align => |ty| (try Type.fromInterned(ty).abiAlignmentInner(strat.toLazy(), zcu, tid)).scalar.toByteUnits() orelse 0,
-                .lazy_size => |ty| (try Type.fromInterned(ty).abiSizeInner(strat.toLazy(), zcu, tid)).scalar,
             },
             .ptr => |ptr| switch (ptr.base_addr) {
                 .int => ptr.byte_offset,
                 .field => |field| {
-                    const base_addr = (try Value.fromInterned(field.base).getUnsignedIntInner(strat, zcu, tid)) orelse return null;
+                    const base_addr = Value.fromInterned(field.base).getUnsignedInt(zcu) orelse return null;
                     const struct_ty = Value.fromInterned(field.base).typeOf(zcu).childType(zcu);
-                    if (strat == .sema) {
-                        const pt = strat.pt(zcu, tid);
-                        try struct_ty.resolveLayout(pt);
-                    }
                     return base_addr + struct_ty.structFieldOffset(@intCast(field.index), zcu) + ptr.byte_offset;
                 },
                 else => null,
             },
             .opt => |opt| switch (opt.val) {
                 .none => 0,
-                else => |payload| Value.fromInterned(payload).getUnsignedIntInner(strat, zcu, tid),
+                else => |payload| Value.fromInterned(payload).getUnsignedInt(zcu),
             },
-            .enum_tag => |enum_tag| return Value.fromInterned(enum_tag.int).getUnsignedIntInner(strat, zcu, tid),
+            .enum_tag => |enum_tag| Value.fromInterned(enum_tag.int).getUnsignedInt(zcu),
+            .err => |err| zcu.intern_pool.getErrorValueIfExists(err.name).?,
             else => null,
         },
     };
 }
 
-/// Asserts the value is an integer and it fits in a u64
-pub fn toUnsignedIntSema(val: Value, pt: Zcu.PerThread) !u64 {
-    return (try getUnsignedIntInner(val, .sema, pt.zcu, pt.tid)).?;
-}
-
 /// Asserts the value is an integer and it fits in a i64
 pub fn toSignedInt(val: Value, zcu: *const Zcu) i64 {
     return switch (val.toIntern()) {
@@ -314,8 +232,6 @@ pub fn toSignedInt(val: Value, zcu: *const Zcu) i64 {
                 .big_int => |big_int| big_int.toInt(i64) catch unreachable,
                 .i64 => |x| x,
                 .u64 => |x| @intCast(x),
-                .lazy_align => |ty| @intCast(Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0),
-                .lazy_size => |ty| @intCast(Type.fromInterned(ty).abiSize(zcu)),
             },
             else => unreachable,
         },
@@ -487,22 +403,16 @@ pub fn writeToPackedMemory(
                 buffer[byte_index] &= ~(@as(u8, 1) << @as(u3, @intCast(bit_offset % 8)));
             }
         },
-        .int, .@"enum" => {
-            if (buffer.len == 0) return;
+        .@"enum" => {
+            const int_val = val.intFromEnum(zcu);
+            return int_val.writeToPackedMemory(int_val.typeOf(zcu), pt, buffer, bit_offset);
+        },
+        .int => {
             const bits = ty.intInfo(zcu).bits;
-            if (bits == 0) return;
-
-            switch (ip.indexToKey((try val.intFromEnum(ty, pt)).toIntern()).int.storage) {
+            if (bits == 0 or buffer.len == 0) return;
+            switch (ip.indexToKey(val.toIntern()).int.storage) {
                 inline .u64, .i64 => |int| std.mem.writeVarPackedInt(buffer, bit_offset, bits, int, endian),
                 .big_int => |bigint| bigint.writePackedTwosComplement(buffer, bit_offset, bits, endian),
-                .lazy_align => |lazy_align| {
-                    const num = Type.fromInterned(lazy_align).abiAlignment(zcu).toByteUnits() orelse 0;
-                    std.mem.writeVarPackedInt(buffer, bit_offset, bits, num, endian);
-                },
-                .lazy_size => |lazy_size| {
-                    const num = Type.fromInterned(lazy_size).abiSize(zcu);
-                    std.mem.writeVarPackedInt(buffer, bit_offset, bits, num, endian);
-                },
             }
         },
         .float => switch (ty.floatBits(target)) {
@@ -548,19 +458,15 @@ pub fn writeToPackedMemory(
         },
         .@"union" => {
             const union_obj = zcu.typeToUnion(ty).?;
-            switch (union_obj.flagsUnordered(ip).layout) {
-                .auto, .@"extern" => unreachable, // Handled in non-packed writeToMemory
-                .@"packed" => {
-                    if (val.unionTag(zcu)) |union_tag| {
-                        const field_index = zcu.unionTagFieldIndex(union_obj, union_tag).?;
-                        const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-                        const field_val = try val.fieldValue(pt, field_index);
-                        return field_val.writeToPackedMemory(field_type, pt, buffer, bit_offset);
-                    } else {
-                        const backing_ty = try ty.unionBackingType(pt);
-                        return val.unionValue(zcu).writeToPackedMemory(backing_ty, pt, buffer, bit_offset);
-                    }
-                },
+            assert(union_obj.layout == .@"packed");
+            if (val.unionTag(zcu)) |union_tag| {
+                const field_index = zcu.unionTagFieldIndex(union_obj, union_tag).?;
+                const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
+                const field_val = try val.fieldValue(pt, field_index);
+                return field_val.writeToPackedMemory(field_type, pt, buffer, bit_offset);
+            } else {
+                const backing_ty = try ty.unionBackingType(pt);
+                return val.unionValue(zcu).writeToPackedMemory(backing_ty, pt, buffer, bit_offset);
             }
         },
         .pointer => {
@@ -729,24 +635,15 @@ pub fn readFromPackedMemory(
         },
         .pointer => {
             assert(!ty.isSlice(zcu)); // No well defined layout.
-            const int_val = try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena);
-            return Value.fromInterned(try pt.intern(.{ .ptr = .{
-                .ty = ty.toIntern(),
-                .base_addr = .int,
-                .byte_offset = int_val.toUnsignedInt(zcu),
-            } }));
+            const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena)).toUnsignedInt(zcu);
+            return pt.ptrIntValue(ty, addr);
         },
         .optional => {
             assert(ty.isPtrLikeOptional(zcu));
-            const child_ty = ty.optionalChild(zcu);
-            const child_val = try readFromPackedMemory(child_ty, pt, buffer, bit_offset, arena);
+            const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena)).toUnsignedInt(zcu);
             return Value.fromInterned(try pt.intern(.{ .opt = .{
                 .ty = ty.toIntern(),
-                .val = switch (child_val.orderAgainstZero(zcu)) {
-                    .lt => unreachable,
-                    .eq => .none,
-                    .gt => child_val.toIntern(),
-                },
+                .val = (try pt.ptrIntValue(ty.childType(zcu), addr)).toIntern(),
             } }));
         },
         else => @panic("TODO implement readFromPackedMemory for more types"),
@@ -764,8 +661,6 @@ pub fn toFloat(val: Value, comptime T: type, zcu: *const Zcu) T {
                 }
                 return @floatFromInt(x);
             },
-            .lazy_align => |ty| @floatFromInt(Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0),
-            .lazy_size => |ty| @floatFromInt(Type.fromInterned(ty).abiSize(zcu)),
         },
         .float => |float| switch (float.storage) {
             inline else => |x| @floatCast(x),
@@ -819,110 +714,8 @@ pub fn floatCast(val: Value, dest_ty: Type, pt: Zcu.PerThread) !Value {
     } }));
 }
 
-pub fn orderAgainstZero(lhs: Value, zcu: *Zcu) std.math.Order {
-    return orderAgainstZeroInner(lhs, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn orderAgainstZeroSema(lhs: Value, pt: Zcu.PerThread) !std.math.Order {
-    return try orderAgainstZeroInner(lhs, .sema, pt.zcu, pt.tid);
-}
-
-pub fn orderAgainstZeroInner(
-    lhs: Value,
-    comptime strat: ResolveStrat,
-    zcu: *Zcu,
-    tid: strat.Tid(),
-) Zcu.SemaError!std.math.Order {
-    return switch (lhs.toIntern()) {
-        .bool_false => .eq,
-        .bool_true => .gt,
-        else => switch (zcu.intern_pool.indexToKey(lhs.toIntern())) {
-            .ptr => |ptr| if (ptr.byte_offset > 0) .gt else switch (ptr.base_addr) {
-                .nav, .comptime_alloc, .comptime_field => .gt,
-                .int => .eq,
-                else => unreachable,
-            },
-            .int => |int| switch (int.storage) {
-                .big_int => |big_int| big_int.orderAgainstScalar(0),
-                inline .u64, .i64 => |x| std.math.order(x, 0),
-                .lazy_align => .gt, // alignment is never 0
-                .lazy_size => |ty| return if (Type.fromInterned(ty).hasRuntimeBitsInner(
-                    false,
-                    strat.toLazy(),
-                    zcu,
-                    tid,
-                ) catch |err| switch (err) {
-                    error.NeedLazy => unreachable,
-                    else => |e| return e,
-                }) .gt else .eq,
-            },
-            .enum_tag => |enum_tag| Value.fromInterned(enum_tag.int).orderAgainstZeroInner(strat, zcu, tid),
-            .float => |float| switch (float.storage) {
-                inline else => |x| std.math.order(x, 0),
-            },
-            .err => .gt, // error values cannot be 0
-            else => unreachable,
-        },
-    };
-}
-
-/// Asserts the value is comparable.
-pub fn order(lhs: Value, rhs: Value, zcu: *Zcu) std.math.Order {
-    return orderAdvanced(lhs, rhs, .normal, zcu, {}) catch unreachable;
-}
-
-/// Asserts the value is comparable.
-pub fn orderAdvanced(
-    lhs: Value,
-    rhs: Value,
-    comptime strat: ResolveStrat,
-    zcu: *Zcu,
-    tid: strat.Tid(),
-) !std.math.Order {
-    const lhs_against_zero = try lhs.orderAgainstZeroInner(strat, zcu, tid);
-    const rhs_against_zero = try rhs.orderAgainstZeroInner(strat, zcu, tid);
-    switch (lhs_against_zero) {
-        .lt => if (rhs_against_zero != .lt) return .lt,
-        .eq => return rhs_against_zero.invert(),
-        .gt => {},
-    }
-    switch (rhs_against_zero) {
-        .lt => if (lhs_against_zero != .lt) return .gt,
-        .eq => return lhs_against_zero,
-        .gt => {},
-    }
-
-    if (lhs.isFloat(zcu) or rhs.isFloat(zcu)) {
-        const lhs_f128 = lhs.toFloat(f128, zcu);
-        const rhs_f128 = rhs.toFloat(f128, zcu);
-        return std.math.order(lhs_f128, rhs_f128);
-    }
-
-    var lhs_bigint_space: BigIntSpace = undefined;
-    var rhs_bigint_space: BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_bigint_space, strat, zcu, tid);
-    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_bigint_space, strat, zcu, tid);
-    return lhs_bigint.order(rhs_bigint);
-}
-
-/// Asserts the value is comparable. Does not take a type parameter because it supports
-/// comparisons between heterogeneous types.
+/// Asserts the value is comparable. Supports comparisons between heterogeneous types.
 pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value, zcu: *Zcu) bool {
-    return compareHeteroAdvanced(lhs, op, rhs, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn compareHeteroSema(lhs: Value, op: std.math.CompareOperator, rhs: Value, pt: Zcu.PerThread) !bool {
-    return try compareHeteroAdvanced(lhs, op, rhs, .sema, pt.zcu, pt.tid);
-}
-
-pub fn compareHeteroAdvanced(
-    lhs: Value,
-    op: std.math.CompareOperator,
-    rhs: Value,
-    comptime strat: ResolveStrat,
-    zcu: *Zcu,
-    tid: strat.Tid(),
-) !bool {
     if (lhs.pointerNav(zcu)) |lhs_nav| {
         if (rhs.pointerNav(zcu)) |rhs_nav| {
             switch (op) {
@@ -944,9 +737,21 @@ pub fn compareHeteroAdvanced(
             else => {},
         }
     }
-
     if (lhs.isNan(zcu) or rhs.isNan(zcu)) return op == .neq;
-    return (try orderAdvanced(lhs, rhs, strat, zcu, tid)).compare(op);
+    return order(lhs, rhs, zcu).compare(op);
+}
+
+pub fn order(lhs: Value, rhs: Value, zcu: *Zcu) std.math.Order {
+    if (lhs.isFloat(zcu) or rhs.isFloat(zcu)) {
+        const lhs_f128 = lhs.toFloat(f128, zcu);
+        const rhs_f128 = rhs.toFloat(f128, zcu);
+        return std.math.order(lhs_f128, rhs_f128);
+    }
+    var lhs_bigint_space: BigIntSpace = undefined;
+    var rhs_bigint_space: BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_bigint_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_bigint_space, zcu);
+    return lhs_bigint.order(rhs_bigint);
 }
 
 /// Asserts the values are comparable. Both operands have type `ty`.
@@ -987,56 +792,32 @@ pub fn compareScalar(
 /// Returns `false` if the value or any vector element is undefined.
 ///
 /// Note that `!compareAllWithZero(.eq, ...) != compareAllWithZero(.neq, ...)`
+/// TODO MLUGG: lowkey wanna delete this
 pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator, zcu: *Zcu) bool {
-    return compareAllWithZeroAdvancedExtra(lhs, op, .normal, zcu, {}) catch unreachable;
-}
-
-pub fn compareAllWithZeroSema(
-    lhs: Value,
-    op: std.math.CompareOperator,
-    pt: Zcu.PerThread,
-) Zcu.CompileError!bool {
-    return compareAllWithZeroAdvancedExtra(lhs, op, .sema, pt.zcu, pt.tid);
-}
-
-pub fn compareAllWithZeroAdvancedExtra(
-    lhs: Value,
-    op: std.math.CompareOperator,
-    comptime strat: ResolveStrat,
-    zcu: *Zcu,
-    tid: strat.Tid(),
-) Zcu.CompileError!bool {
-    if (lhs.isInf(zcu)) {
-        switch (op) {
-            .neq => return true,
-            .eq => return false,
-            .gt, .gte => return !lhs.isNegativeInf(zcu),
-            .lt, .lte => return lhs.isNegativeInf(zcu),
-        }
-    }
-
-    switch (zcu.intern_pool.indexToKey(lhs.toIntern())) {
+    return switch (zcu.intern_pool.indexToKey(lhs.toIntern())) {
         .float => |float| switch (float.storage) {
-            inline else => |x| if (std.math.isNan(x)) return op == .neq,
+            inline else => |x| std.math.compare(x, op, 0),
         },
-        .aggregate => |aggregate| return switch (aggregate.storage) {
-            .bytes => |bytes| for (bytes.toSlice(lhs.typeOf(zcu).arrayLenIncludingSentinel(zcu), &zcu.intern_pool)) |byte| {
-                if (!std.math.order(byte, 0).compare(op)) break false;
+        .aggregate => |aggregate| switch (aggregate.storage) {
+            .bytes => |bytes| for (bytes.toSlice(
+                lhs.typeOf(zcu).arrayLenIncludingSentinel(zcu),
+                &zcu.intern_pool,
+            )) |byte| {
+                if (!std.math.compare(byte, op, 0)) break false;
             } else true,
             .elems => |elems| for (elems) |elem| {
-                if (!try Value.fromInterned(elem).compareAllWithZeroAdvancedExtra(op, strat, zcu, tid)) break false;
+                if (!Value.fromInterned(elem).compareAllWithZero(op, zcu)) break false;
             } else true,
-            .repeated_elem => |elem| Value.fromInterned(elem).compareAllWithZeroAdvancedExtra(op, strat, zcu, tid),
+            .repeated_elem => |elem| Value.fromInterned(elem).compareAllWithZero(op, zcu),
         },
-        .undef => return false,
-        else => {},
-    }
-    return (try orderAgainstZeroInner(lhs, strat, zcu, tid)).compare(op);
+        .undef => false,
+        else => order(lhs, .zero_comptime_int, zcu).compare(op),
+    };
 }
 
 pub fn eql(a: Value, b: Value, ty: Type, zcu: *Zcu) bool {
-    assert(zcu.intern_pool.typeOf(a.toIntern()) == ty.toIntern());
-    assert(zcu.intern_pool.typeOf(b.toIntern()) == ty.toIntern());
+    assert(a.typeOf(zcu).toIntern() == ty.toIntern());
+    assert(b.typeOf(zcu).toIntern() == ty.toIntern());
     return a.toIntern() == b.toIntern();
 }
 
@@ -1088,16 +869,13 @@ pub fn pointerNav(val: Value, zcu: *Zcu) ?InternPool.Nav.Index {
 pub const slice_ptr_index = 0;
 pub const slice_len_index = 1;
 
+pub fn sliceLen(val: Value, zcu: *Zcu) u64 {
+    return Value.fromInterned(zcu.intern_pool.sliceLen(val.toIntern())).toUnsignedInt(zcu);
+}
 pub fn slicePtr(val: Value, zcu: *Zcu) Value {
     return Value.fromInterned(zcu.intern_pool.slicePtr(val.toIntern()));
 }
 
-/// Gets the `len` field of a slice value as a `u64`.
-/// Resolves the length using `Sema` if necessary.
-pub fn sliceLen(val: Value, pt: Zcu.PerThread) !u64 {
-    return Value.fromInterned(pt.zcu.intern_pool.sliceLen(val.toIntern())).toUnsignedIntSema(pt);
-}
-
 /// Asserts the value is an aggregate, and returns the element value at the given index.
 pub fn elemValue(val: Value, pt: Zcu.PerThread, index: usize) Allocator.Error!Value {
     const zcu = pt.zcu;
@@ -1123,62 +901,6 @@ pub fn elemValue(val: Value, pt: Zcu.PerThread, index: usize) Allocator.Error!Va
     }
 }
 
-pub fn isLazyAlign(val: Value, zcu: *Zcu) bool {
-    return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-        .int => |int| int.storage == .lazy_align,
-        else => false,
-    };
-}
-
-pub fn isLazySize(val: Value, zcu: *Zcu) bool {
-    return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-        .int => |int| int.storage == .lazy_size,
-        else => false,
-    };
-}
-
-// Asserts that the provided start/end are in-bounds.
-pub fn sliceArray(
-    val: Value,
-    sema: *Sema,
-    start: usize,
-    end: usize,
-) error{OutOfMemory}!Value {
-    const pt = sema.pt;
-    const ip = &pt.zcu.intern_pool;
-    const io = pt.zcu.comp.io;
-    return Value.fromInterned(try pt.intern(.{
-        .aggregate = .{
-            .ty = switch (pt.zcu.intern_pool.indexToKey(pt.zcu.intern_pool.typeOf(val.toIntern()))) {
-                .array_type => |array_type| try pt.arrayType(.{
-                    .len = @intCast(end - start),
-                    .child = array_type.child,
-                    .sentinel = if (end == array_type.len) array_type.sentinel else .none,
-                }),
-                .vector_type => |vector_type| try pt.vectorType(.{
-                    .len = @intCast(end - start),
-                    .child = vector_type.child,
-                }),
-                else => unreachable,
-            }.toIntern(),
-            .storage = switch (ip.indexToKey(val.toIntern()).aggregate.storage) {
-                .bytes => |bytes| storage: {
-                    try ip.string_bytes.ensureUnusedCapacity(sema.gpa, end - start + 1);
-                    break :storage .{ .bytes = try ip.getOrPutString(
-                        sema.gpa,
-                        io,
-                        bytes.toSlice(end, ip)[start..],
-                        .maybe_embedded_nulls,
-                    ) };
-                },
-                // TODO: write something like getCoercedInts to avoid needing to dupe
-                .elems => |elems| .{ .elems = try sema.arena.dupe(InternPool.Index, elems[start..end]) },
-                .repeated_elem => |elem| .{ .repeated_elem = elem },
-            },
-        },
-    }));
-}
-
 pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {
     const zcu = pt.zcu;
     return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
@@ -1334,63 +1056,6 @@ pub fn isFloat(self: Value, zcu: *const Zcu) bool {
     };
 }
 
-pub fn floatFromInt(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, zcu: *Zcu) !Value {
-    return floatFromIntAdvanced(val, arena, int_ty, float_ty, zcu, .normal) catch |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
-        else => unreachable,
-    };
-}
-
-pub fn floatFromIntAdvanced(
-    val: Value,
-    arena: Allocator,
-    int_ty: Type,
-    float_ty: Type,
-    pt: Zcu.PerThread,
-    comptime strat: ResolveStrat,
-) !Value {
-    const zcu = pt.zcu;
-    if (int_ty.zigTypeTag(zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, int_ty.vectorLen(zcu));
-        const scalar_ty = float_ty.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const elem_val = try val.elemValue(pt, i);
-            scalar.* = (try floatFromIntScalar(elem_val, scalar_ty, pt, strat)).toIntern();
-        }
-        return pt.aggregateValue(float_ty, result_data);
-    }
-    return floatFromIntScalar(val, float_ty, pt, strat);
-}
-
-pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Value {
-    return switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {
-        .undef => try pt.undefValue(float_ty),
-        .int => |int| switch (int.storage) {
-            .big_int => |big_int| pt.floatValue(float_ty, big_int.toFloat(f128, .nearest_even)[0]),
-            inline .u64, .i64 => |x| floatFromIntInner(x, float_ty, pt),
-            .lazy_align => |ty| floatFromIntInner((try Type.fromInterned(ty).abiAlignmentInner(strat.toLazy(), pt.zcu, pt.tid)).scalar.toByteUnits() orelse 0, float_ty, pt),
-            .lazy_size => |ty| floatFromIntInner((try Type.fromInterned(ty).abiSizeInner(strat.toLazy(), pt.zcu, pt.tid)).scalar, float_ty, pt),
-        },
-        else => unreachable,
-    };
-}
-
-fn floatFromIntInner(x: anytype, dest_ty: Type, pt: Zcu.PerThread) !Value {
-    const target = pt.zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (dest_ty.floatBits(target)) {
-        16 => .{ .f16 = @floatFromInt(x) },
-        32 => .{ .f32 = @floatFromInt(x) },
-        64 => .{ .f64 = @floatFromInt(x) },
-        80 => .{ .f80 = @floatFromInt(x) },
-        128 => .{ .f128 = @floatFromInt(x) },
-        else => unreachable,
-    };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = dest_ty.toIntern(),
-        .storage = storage,
-    } }));
-}
-
 fn calcLimbLenFloat(scalar: anytype) usize {
     if (scalar == 0) {
         return 1;
@@ -1410,11 +1075,11 @@ pub fn numberMax(lhs: Value, rhs: Value, zcu: *Zcu) Value {
     if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return undef;
     if (lhs.isNan(zcu)) return rhs;
     if (rhs.isNan(zcu)) return lhs;
-
-    return switch (order(lhs, rhs, zcu)) {
-        .lt => rhs,
-        .gt, .eq => lhs,
-    };
+    if (compareHetero(lhs, .gt, rhs, zcu)) {
+        return lhs;
+    } else {
+        return rhs;
+    }
 }
 
 /// Supports both floats and ints; handles undefined.
@@ -1422,11 +1087,11 @@ pub fn numberMin(lhs: Value, rhs: Value, zcu: *Zcu) Value {
     if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return undef;
     if (lhs.isNan(zcu)) return rhs;
     if (rhs.isNan(zcu)) return lhs;
-
-    return switch (order(lhs, rhs, zcu)) {
-        .lt => lhs,
-        .gt, .eq => rhs,
-    };
+    if (compareHetero(lhs, .lt, rhs, zcu)) {
+        return lhs;
+    } else {
+        return rhs;
+    }
 }
 
 /// Returns true if the value is a floating point type and is NaN. Returns false otherwise.
@@ -2035,6 +1700,7 @@ pub fn makeBool(x: bool) Value {
 /// Returns a pointer to the payload of the optional.
 ///
 /// May perform type resolution.
+/// MLUGG TODO audit
 pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr_ty = parent_ptr.typeOf(zcu);
@@ -2044,7 +1710,7 @@ pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     assert(ptr_size == .one or ptr_size == .c);
     assert(opt_ty.zigTypeTag(zcu) == .optional);
 
-    const result_ty = try pt.ptrTypeSema(info: {
+    const result_ty = try pt.ptrType(info: {
         var new = parent_ptr_ty.ptrInfo(zcu);
         // We can correctly preserve alignment `.none`, since an optional has the same
         // natural alignment as its child type.
@@ -2070,6 +1736,7 @@ pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
 /// `parent_ptr` must be a single-pointer to some error union.
 /// Returns a pointer to the payload of the error union.
 /// May perform type resolution.
+/// MLUGG TODO audit
 pub fn ptrEuPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr_ty = parent_ptr.typeOf(zcu);
@@ -2078,7 +1745,7 @@ pub fn ptrEuPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     assert(parent_ptr_ty.ptrSize(zcu) == .one);
     assert(eu_ty.zigTypeTag(zcu) == .error_union);
 
-    const result_ty = try pt.ptrTypeSema(info: {
+    const result_ty = try pt.ptrType(info: {
         var new = parent_ptr_ty.ptrInfo(zcu);
         // We can correctly preserve alignment `.none`, since an error union has a
         // natural alignment greater than or equal to that of its payload type.
@@ -2096,6 +1763,8 @@ pub fn ptrEuPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     } }));
 }
 
+// MLUGG TODO: audit ptrField etc in terms of resolution, and probably move them under sema
+
 /// `parent_ptr` must be a single-pointer or c pointer to a struct, union, or slice.
 ///
 /// Returns a pointer to the aggregate field at the specified index.
@@ -2112,23 +1781,34 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
     assert(parent_ptr_info.flags.size == .one or parent_ptr_info.flags.size == .c);
 
     // Exiting this `switch` indicates that the `field` pointer representation should be used.
-    // `field_align` may be `.none` to represent the natural alignment of `field_ty`, but is not necessarily.
-    const field_ty: Type, const field_align: InternPool.Alignment = switch (aggregate_ty.zigTypeTag(zcu)) {
+    const field_ty: Type, const new_align: InternPool.Alignment = switch (aggregate_ty.zigTypeTag(zcu)) {
         .@"struct" => field: {
             const field_ty = aggregate_ty.fieldType(field_idx, zcu);
             switch (aggregate_ty.containerLayout(zcu)) {
-                .auto => break :field .{ field_ty, try aggregate_ty.fieldAlignmentSema(field_idx, pt) },
+                .auto => break :field .{ field_ty, a: {
+                    if (parent_ptr_info.flags.alignment == .none) {
+                        break :a aggregate_ty.explicitFieldAlignment(field_idx, zcu);
+                    }
+                    const field_align = aggregate_ty.resolvedFieldAlignment(field_idx, zcu);
+                    break :a field_align.min(parent_ptr_info.flags.alignment);
+                } },
                 .@"extern" => {
                     // Well-defined layout, so just offset the pointer appropriately.
-                    try aggregate_ty.resolveLayout(pt);
                     const byte_off = aggregate_ty.structFieldOffset(field_idx, zcu);
-                    const field_align = a: {
+                    const field_align: InternPool.Alignment = a: {
+                        if (byte_off == 0) break :a parent_ptr_info.flags.alignment;
+                        const true_field_align: InternPool.Alignment = .fromLog2Units(@ctz(byte_off));
+                        if (parent_ptr_info.flags.alignment == .none and
+                            true_field_align == field_ty.abiAlignment(zcu))
+                        {
+                            break :a .none;
+                        }
                         const parent_align = if (parent_ptr_info.flags.alignment == .none) pa: {
-                            break :pa try aggregate_ty.abiAlignmentSema(pt);
+                            break :pa aggregate_ty.abiAlignment(zcu);
                         } else parent_ptr_info.flags.alignment;
-                        break :a InternPool.Alignment.fromLog2Units(@min(parent_align.toLog2Units(), @ctz(byte_off)));
+                        break :a .minStrict(true_field_align, parent_align);
                     };
-                    const result_ty = try pt.ptrTypeSema(info: {
+                    const result_ty = try pt.ptrType(info: {
                         var new = parent_ptr_info;
                         new.child = field_ty.toIntern();
                         new.flags.alignment = field_align;
@@ -2143,7 +1823,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
                         new.packed_offset = packed_offset;
                         new.child = field_ty.toIntern();
                         if (new.flags.alignment == .none) {
-                            new.flags.alignment = try aggregate_ty.abiAlignmentSema(pt);
+                            new.flags.alignment = aggregate_ty.abiAlignment(zcu);
                         }
                         break :info new;
                     });
@@ -2155,10 +1835,16 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
             const union_obj = zcu.typeToUnion(aggregate_ty).?;
             const field_ty = Type.fromInterned(union_obj.field_types.get(&zcu.intern_pool)[field_idx]);
             switch (aggregate_ty.containerLayout(zcu)) {
-                .auto => break :field .{ field_ty, try aggregate_ty.fieldAlignmentSema(field_idx, pt) },
+                .auto => break :field .{ field_ty, a: {
+                    if (parent_ptr_info.flags.alignment == .none) {
+                        break :a aggregate_ty.explicitFieldAlignment(field_idx, zcu);
+                    }
+                    const field_align = aggregate_ty.resolvedFieldAlignment(field_idx, zcu);
+                    break :a field_align.min(parent_ptr_info.flags.alignment);
+                } },
                 .@"extern" => {
                     // Point to the same address.
-                    const result_ty = try pt.ptrTypeSema(info: {
+                    const result_ty = try pt.ptrType(info: {
                         var new = parent_ptr_info;
                         new.child = field_ty.toIntern();
                         break :info new;
@@ -2166,59 +1852,30 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
                     return pt.getCoerced(parent_ptr, result_ty);
                 },
                 .@"packed" => {
-                    // If the field has an ABI size matching its bit size, then we can continue to use a
-                    // non-bit pointer if the parent pointer is also a non-bit pointer.
-                    if (parent_ptr_info.packed_offset.host_size == 0 and (try field_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar * 8 == try field_ty.bitSizeSema(pt)) {
-                        // We must offset the pointer on big-endian targets, since the bits of packed memory don't align nicely.
-                        const byte_offset = switch (zcu.getTarget().cpu.arch.endian()) {
-                            .little => 0,
-                            .big => (try aggregate_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar - (try field_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar,
-                        };
-                        const result_ty = try pt.ptrTypeSema(info: {
-                            var new = parent_ptr_info;
-                            new.child = field_ty.toIntern();
-                            new.flags.alignment = InternPool.Alignment.fromLog2Units(
-                                @ctz(byte_offset | (try parent_ptr_ty.ptrAlignmentSema(pt)).toByteUnits().?),
-                            );
-                            break :info new;
-                        });
-                        return parent_ptr.getOffsetPtr(byte_offset, result_ty, pt);
-                    } else {
-                        // The result must be a bit-pointer if it is not already.
-                        const result_ty = try pt.ptrTypeSema(info: {
-                            var new = parent_ptr_info;
-                            new.child = field_ty.toIntern();
-                            if (new.packed_offset.host_size == 0) {
-                                new.packed_offset.host_size = @intCast(((try aggregate_ty.bitSizeSema(pt)) + 7) / 8);
-                                assert(new.packed_offset.bit_offset == 0);
-                            }
-                            break :info new;
-                        });
-                        return pt.getCoerced(parent_ptr, result_ty);
-                    }
+                    const result_ty = try pt.ptrType(info: {
+                        var new = parent_ptr_info;
+                        new.child = field_ty.toIntern();
+                        break :info new;
+                    });
+                    return pt.getCoerced(parent_ptr, result_ty);
                 },
             }
         },
         .pointer => field_ty: {
             assert(aggregate_ty.isSlice(zcu));
-            break :field_ty switch (field_idx) {
-                Value.slice_ptr_index => .{ aggregate_ty.slicePtrFieldType(zcu), Type.usize.abiAlignment(zcu) },
-                Value.slice_len_index => .{ Type.usize, Type.usize.abiAlignment(zcu) },
+            break :field_ty .{ switch (field_idx) {
+                Value.slice_ptr_index => aggregate_ty.slicePtrFieldType(zcu),
+                Value.slice_len_index => Type.usize,
                 else => unreachable,
-            };
+            }, switch (parent_ptr_info.flags.alignment) {
+                .none => .none,
+                else => Type.usize.abiAlignment(zcu).min(parent_ptr_info.flags.alignment),
+            } };
         },
         else => unreachable,
     };
 
-    const new_align: InternPool.Alignment = if (parent_ptr_info.flags.alignment != .none) a: {
-        const ty_align = (try field_ty.abiAlignmentInner(.sema, zcu, pt.tid)).scalar;
-        const true_field_align = if (field_align == .none) ty_align else field_align;
-        const new_align = true_field_align.min(parent_ptr_info.flags.alignment);
-        if (new_align == ty_align) break :a .none;
-        break :a new_align;
-    } else field_align;
-
-    const result_ty = try pt.ptrTypeSema(info: {
+    const result_ty = try pt.ptrType(info: {
         var new = parent_ptr_info;
         new.child = field_ty.toIntern();
         new.flags.alignment = new_align;
@@ -2241,6 +1898,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
 /// `orig_parent_ptr` must be either a single-pointer to an array or vector, or a many-pointer or C-pointer or slice.
 /// Returns a pointer to the element at the specified index.
 /// May perform type resolution.
+/// MLUGG TODO AUDIT
 pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr = switch (orig_parent_ptr.typeOf(zcu).ptrSize(zcu)) {
@@ -2267,21 +1925,19 @@ pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value
 
     const strat: PtrStrat = switch (parent_ptr_ty.ptrSize(zcu)) {
         .one => switch (elem_ty.zigTypeTag(zcu)) {
-            .vector => .{ .offset = field_idx * @divExact(try elem_ty.childType(zcu).bitSizeSema(pt), 8) },
+            .vector => .{ .offset = field_idx * @divExact(elem_ty.childType(zcu).bitSize(zcu), 8) },
             .array => strat: {
                 const arr_elem_ty = elem_ty.childType(zcu);
-                if (try arr_elem_ty.comptimeOnlySema(pt)) {
-                    break :strat .{ .elem_ptr = arr_elem_ty };
-                }
-                break :strat .{ .offset = field_idx * (try arr_elem_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar };
+                if (arr_elem_ty.comptimeOnly(zcu)) break :strat .{ .elem_ptr = arr_elem_ty };
+                break :strat .{ .offset = field_idx * arr_elem_ty.abiSize(zcu) };
             },
             else => unreachable,
         },
 
-        .many, .c => if (try elem_ty.comptimeOnlySema(pt))
+        .many, .c => if (elem_ty.comptimeOnly(zcu))
             .{ .elem_ptr = elem_ty }
         else
-            .{ .offset = field_idx * (try elem_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar },
+            .{ .offset = field_idx * elem_ty.abiSize(zcu) },
 
         .slice => unreachable,
     };
@@ -2430,6 +2086,7 @@ pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread) Al
 /// which prefer field/elem accesses when lowering constant pointer values.
 /// It is also used by the Value printing logic for pointers.
 pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, comptime resolve_types: bool, opt_sema: ?*Sema) !PointerDeriveStep {
+    // MLUGG TODO: audit tf outta this code
     const zcu = pt.zcu;
     const ptr = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
     const base_derive: PointerDeriveStep = switch (ptr.base_addr) {
@@ -2454,7 +2111,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
         .comptime_alloc => |idx| base: {
             const sema = opt_sema.?;
             const alloc = sema.getComptimeAlloc(idx);
-            const val = try alloc.val.intern(pt, sema.arena);
+            const val = try alloc.val.intern(pt, arena);
             const ty = val.typeOf(zcu);
             break :base .{ .comptime_alloc_ptr = .{
                 .idx = idx,
@@ -2492,24 +2149,14 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const base_ptr = Value.fromInterned(field.base);
             const base_ptr_ty = base_ptr.typeOf(zcu);
             const agg_ty = base_ptr_ty.childType(zcu);
-            const field_ty, const field_align = switch (agg_ty.zigTypeTag(zcu)) {
-                .@"struct" => .{ agg_ty.fieldType(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner(
-                    @intCast(field.index),
-                    if (resolve_types) .sema else .normal,
-                    pt.zcu,
-                    if (resolve_types) pt.tid else {},
-                ) },
-                .@"union" => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner(
-                    @intCast(field.index),
-                    if (resolve_types) .sema else .normal,
-                    pt.zcu,
-                    if (resolve_types) pt.tid else {},
-                ) },
-                .pointer => .{ switch (field.index) {
-                    Value.slice_ptr_index => agg_ty.slicePtrFieldType(zcu),
-                    Value.slice_len_index => Type.usize,
+            if (resolve_types) try opt_sema.?.ensureLayoutResolved(agg_ty);
+            const field_ty: Type, const field_align: InternPool.Alignment = switch (agg_ty.zigTypeTag(zcu)) {
+                .@"struct", .@"union" => .{ agg_ty.fieldType(@intCast(field.index), zcu), agg_ty.resolvedFieldAlignment(@intCast(field.index), pt.zcu) },
+                .pointer => switch (field.index) {
+                    Value.slice_ptr_index => .{ agg_ty.slicePtrFieldType(zcu), Type.ptrAbiAlignment(zcu.getTarget()) },
+                    Value.slice_len_index => .{ .usize, Type.abiAlignment(.usize, zcu) },
                     else => unreachable,
-                }, Type.usize.abiAlignment(zcu) },
+                },
                 else => unreachable,
             };
             const base_align = base_ptr_ty.ptrAlignment(zcu);
@@ -2720,148 +2367,6 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
     } };
 }
 
-pub fn resolveLazy(
-    val: Value,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) Zcu.SemaError!Value {
-    switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {
-        .int => |int| switch (int.storage) {
-            .u64, .i64, .big_int => return val,
-            .lazy_align, .lazy_size => return pt.intValue(
-                Type.fromInterned(int.ty),
-                try val.toUnsignedIntSema(pt),
-            ),
-        },
-        .slice => |slice| {
-            const ptr = try Value.fromInterned(slice.ptr).resolveLazy(arena, pt);
-            const len = try Value.fromInterned(slice.len).resolveLazy(arena, pt);
-            if (ptr.toIntern() == slice.ptr and len.toIntern() == slice.len) return val;
-            return Value.fromInterned(try pt.intern(.{ .slice = .{
-                .ty = slice.ty,
-                .ptr = ptr.toIntern(),
-                .len = len.toIntern(),
-            } }));
-        },
-        .ptr => |ptr| {
-            switch (ptr.base_addr) {
-                .nav, .comptime_alloc, .uav, .int => return val,
-                .comptime_field => |field_val| {
-                    const resolved_field_val = (try Value.fromInterned(field_val).resolveLazy(arena, pt)).toIntern();
-                    return if (resolved_field_val == field_val)
-                        val
-                    else
-                        Value.fromInterned(try pt.intern(.{ .ptr = .{
-                            .ty = ptr.ty,
-                            .base_addr = .{ .comptime_field = resolved_field_val },
-                            .byte_offset = ptr.byte_offset,
-                        } }));
-                },
-                .eu_payload, .opt_payload => |base| {
-                    const resolved_base = (try Value.fromInterned(base).resolveLazy(arena, pt)).toIntern();
-                    return if (resolved_base == base)
-                        val
-                    else
-                        Value.fromInterned(try pt.intern(.{ .ptr = .{
-                            .ty = ptr.ty,
-                            .base_addr = switch (ptr.base_addr) {
-                                .eu_payload => .{ .eu_payload = resolved_base },
-                                .opt_payload => .{ .opt_payload = resolved_base },
-                                else => unreachable,
-                            },
-                            .byte_offset = ptr.byte_offset,
-                        } }));
-                },
-                .arr_elem, .field => |base_index| {
-                    const resolved_base = (try Value.fromInterned(base_index.base).resolveLazy(arena, pt)).toIntern();
-                    return if (resolved_base == base_index.base)
-                        val
-                    else
-                        Value.fromInterned(try pt.intern(.{ .ptr = .{
-                            .ty = ptr.ty,
-                            .base_addr = switch (ptr.base_addr) {
-                                .arr_elem => .{ .arr_elem = .{
-                                    .base = resolved_base,
-                                    .index = base_index.index,
-                                } },
-                                .field => .{ .field = .{
-                                    .base = resolved_base,
-                                    .index = base_index.index,
-                                } },
-                                else => unreachable,
-                            },
-                            .byte_offset = ptr.byte_offset,
-                        } }));
-                },
-            }
-        },
-        .aggregate => |aggregate| switch (aggregate.storage) {
-            .bytes => return val,
-            .elems => |elems| {
-                var resolved_elems: []InternPool.Index = &.{};
-                for (elems, 0..) |elem, i| {
-                    const resolved_elem = (try Value.fromInterned(elem).resolveLazy(arena, pt)).toIntern();
-                    if (resolved_elems.len == 0 and resolved_elem != elem) {
-                        resolved_elems = try arena.alloc(InternPool.Index, elems.len);
-                        @memcpy(resolved_elems[0..i], elems[0..i]);
-                    }
-                    if (resolved_elems.len > 0) resolved_elems[i] = resolved_elem;
-                }
-                return if (resolved_elems.len == 0)
-                    val
-                else
-                    pt.aggregateValue(.fromInterned(aggregate.ty), resolved_elems);
-            },
-            .repeated_elem => |elem| {
-                const resolved_elem = try Value.fromInterned(elem).resolveLazy(arena, pt);
-                return if (resolved_elem.toIntern() == elem)
-                    val
-                else
-                    pt.aggregateSplatValue(.fromInterned(aggregate.ty), resolved_elem);
-            },
-        },
-        .un => |un| {
-            const resolved_tag = if (un.tag == .none)
-                .none
-            else
-                (try Value.fromInterned(un.tag).resolveLazy(arena, pt)).toIntern();
-            const resolved_val = (try Value.fromInterned(un.val).resolveLazy(arena, pt)).toIntern();
-            return if (resolved_tag == un.tag and resolved_val == un.val)
-                val
-            else
-                Value.fromInterned(try pt.internUnion(.{
-                    .ty = un.ty,
-                    .tag = resolved_tag,
-                    .val = resolved_val,
-                }));
-        },
-        .error_union => |eu| switch (eu.val) {
-            .err_name => return val,
-            .payload => |payload| {
-                const resolved_payload = try Value.fromInterned(payload).resolveLazy(arena, pt);
-                if (resolved_payload.toIntern() == payload) return val;
-                return .fromInterned(try pt.intern(.{ .error_union = .{
-                    .ty = eu.ty,
-                    .val = .{ .payload = resolved_payload.toIntern() },
-                } }));
-            },
-        },
-        .opt => |opt| switch (opt.val) {
-            .none => return val,
-            else => |payload| {
-                const resolved_payload = try Value.fromInterned(payload).resolveLazy(arena, pt);
-                if (resolved_payload.toIntern() == payload) return val;
-                return .fromInterned(try pt.intern(.{ .opt = .{
-                    .ty = opt.ty,
-                    .val = resolved_payload.toIntern(),
-                } }));
-            },
-        },
-
-        else => return val,
-    }
-}
-
 const InterpretMode = enum {
     /// In this mode, types are assumed to match what the compiler was built with in terms of field
     /// order, field types, etc. This improves compiler performance. However, it means that certain
@@ -2878,7 +2383,6 @@ const interpret_mode: InterpretMode = @field(InterpretMode, @tagName(build_optio
 
 /// Given a `Value` representing a comptime-known value of type `T`, unwrap it into an actual `T` known to the compiler.
 /// This is useful for accessing `std.builtin` structures received from comptime logic.
-/// `val` must be fully resolved.
 pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMemory, UndefinedValue, TypeMismatch }!T {
     const zcu = pt.zcu;
     const io = zcu.comp.io;
@@ -2917,7 +2421,6 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe
         },
 
         .int => switch (ip.indexToKey(val.toIntern()).int.storage) {
-            .lazy_align, .lazy_size => unreachable, // `val` is fully resolved
             inline .u64, .i64 => |x| std.math.cast(T, x) orelse return error.TypeMismatch,
             .big_int => |big| big.toInt(T) catch return error.TypeMismatch,
         },
diff --git a/src/Zcu.zig b/src/Zcu.zig
index f2d6dbf497a1f47faef87d208c082c364867bb9e..e1760fecb95c1871ca3229becbebc6d224e4173a 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -14,6 +14,8 @@ const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const log = std.log.scoped(.zcu);
+const deps_log = std.log.scoped(.zcu_deps);
+const refs_log = std.log.scoped(.zcu_refs);
 const BigIntConst = std.math.big.int.Const;
 const BigIntMutable = std.math.big.int.Mutable;
 const Target = std.Target;
@@ -2685,10 +2687,10 @@ pub const LazySrcLoc = struct {
             .struct_init, .struct_init_ref => zir.extraData(Zir.Inst.StructInit, inst.data.pl_node.payload_index).data.abs_node,
             .struct_init_anon => zir.extraData(Zir.Inst.StructInitAnon, inst.data.pl_node.payload_index).data.abs_node,
             .extended => switch (inst.data.extended.opcode) {
-                .struct_decl => zir.extraData(Zir.Inst.StructDecl, inst.data.extended.operand).data.src_node,
-                .union_decl => zir.extraData(Zir.Inst.UnionDecl, inst.data.extended.operand).data.src_node,
-                .enum_decl => zir.extraData(Zir.Inst.EnumDecl, inst.data.extended.operand).data.src_node,
-                .opaque_decl => zir.extraData(Zir.Inst.OpaqueDecl, inst.data.extended.operand).data.src_node,
+                .struct_decl => zir.getStructDecl(zir_inst).src_node,
+                .union_decl => zir.getUnionDecl(zir_inst).src_node,
+                .enum_decl => zir.getEnumDecl(zir_inst).src_node,
+                .opaque_decl => zir.getOpaqueDecl(zir_inst).src_node,
                 .reify_enum => zir.extraData(Zir.Inst.ReifyEnum, inst.data.extended.operand).data.node,
                 .reify_struct => zir.extraData(Zir.Inst.ReifyStruct, inst.data.extended.operand).data.node,
                 .reify_union => zir.extraData(Zir.Inst.ReifyUnion, inst.data.extended.operand).data.node,
@@ -3063,7 +3065,7 @@ pub fn markDependeeOutdated(
     marked_po: enum { not_marked_po, marked_po },
     dependee: InternPool.Dependee,
 ) !void {
-    log.debug("outdated dependee: {f}", .{zcu.fmtDependee(dependee)});
+    deps_log.debug("outdated dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = zcu.intern_pool.dependencyIterator(dependee);
     while (it.next()) |depender| {
         if (zcu.outdated.getPtr(depender)) |po_dep_count| {
@@ -3071,9 +3073,9 @@ pub fn markDependeeOutdated(
                 .not_marked_po => {},
                 .marked_po => {
                     po_dep_count.* -= 1;
-                    log.debug("outdated {f} => already outdated {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), po_dep_count.* });
+                    deps_log.debug("outdated {f} => already outdated {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), po_dep_count.* });
                     if (po_dep_count.* == 0) {
-                        log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
+                        deps_log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
                         try zcu.outdated_ready.put(zcu.gpa, depender, {});
                     }
                 },
@@ -3094,9 +3096,9 @@ pub fn markDependeeOutdated(
             depender,
             new_po_dep_count,
         );
-        log.debug("outdated {f} => new outdated {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), new_po_dep_count });
+        deps_log.debug("outdated {f} => new outdated {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), new_po_dep_count });
         if (new_po_dep_count == 0) {
-            log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
+            deps_log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
             try zcu.outdated_ready.put(zcu.gpa, depender, {});
         }
         // If this is a Decl and was not previously PO, we must recursively
@@ -3109,16 +3111,16 @@ pub fn markDependeeOutdated(
 }
 
 pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
-    log.debug("up-to-date dependee: {f}", .{zcu.fmtDependee(dependee)});
+    deps_log.debug("up-to-date dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = zcu.intern_pool.dependencyIterator(dependee);
     while (it.next()) |depender| {
         if (zcu.outdated.getPtr(depender)) |po_dep_count| {
             // This depender is already outdated, but it now has one
             // less PO dependency!
             po_dep_count.* -= 1;
-            log.debug("up-to-date {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), po_dep_count.* });
+            deps_log.debug("up-to-date {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), po_dep_count.* });
             if (po_dep_count.* == 0) {
-                log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
+                deps_log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
                 try zcu.outdated_ready.put(zcu.gpa, depender, {});
             }
             continue;
@@ -3132,11 +3134,11 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
         };
         if (ptr.* > 1) {
             ptr.* -= 1;
-            log.debug("up-to-date {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), ptr.* });
+            deps_log.debug("up-to-date {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), ptr.* });
             continue;
         }
 
-        log.debug("up-to-date {f} => {f} po_deps=0 (up-to-date)", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender) });
+        deps_log.debug("up-to-date {f} => {f} po_deps=0 (up-to-date)", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender) });
 
         // This dependency is no longer PO, i.e. is known to be up-to-date.
         assert(zcu.potentially_outdated.swapRemove(depender));
@@ -3146,8 +3148,9 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
             .@"comptime" => {},
             .nav_val => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_val = nav }),
             .nav_ty => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_ty = nav }),
-            .type => |ty| try zcu.markPoDependeeUpToDate(.{ .interned = ty }),
-            .func => |func| try zcu.markPoDependeeUpToDate(.{ .interned = func }),
+            .type_layout => |ty| try zcu.markPoDependeeUpToDate(.{ .type_layout = ty }),
+            .type_inits => |ty| try zcu.markPoDependeeUpToDate(.{ .type_inits = ty }),
+            .func => |func| try zcu.markPoDependeeUpToDate(.{ .func_ies = func }),
             .memoized_state => |stage| try zcu.markPoDependeeUpToDate(.{ .memoized_state = stage }),
         }
     }
@@ -3161,11 +3164,12 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
         .@"comptime" => return, // analysis of a comptime decl can't outdate any dependencies
         .nav_val => |nav| .{ .nav_val = nav },
         .nav_ty => |nav| .{ .nav_ty = nav },
-        .type => |ty| .{ .interned = ty },
-        .func => |func_index| .{ .interned = func_index }, // IES
+        .type_layout => |ty| .{ .type_layout = ty },
+        .type_inits => |ty| .{ .type_inits = ty },
+        .func => |func_index| .{ .func_ies = func_index },
         .memoized_state => |stage| .{ .memoized_state = stage },
     };
-    log.debug("potentially outdated dependee: {f}", .{zcu.fmtDependee(dependee)});
+    deps_log.debug("potentially outdated dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = ip.dependencyIterator(dependee);
     while (it.next()) |po| {
         if (zcu.outdated.getPtr(po)) |po_dep_count| {
@@ -3175,17 +3179,17 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
                 _ = zcu.outdated_ready.swapRemove(po);
             }
             po_dep_count.* += 1;
-            log.debug("po {f} => {f} [outdated] po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po), po_dep_count.* });
+            deps_log.debug("po {f} => {f} [outdated] po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po), po_dep_count.* });
             continue;
         }
         if (zcu.potentially_outdated.getPtr(po)) |n| {
             // There is now one more PO dependency.
             n.* += 1;
-            log.debug("po {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po), n.* });
+            deps_log.debug("po {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po), n.* });
             continue;
         }
         try zcu.potentially_outdated.putNoClobber(zcu.gpa, po, 1);
-        log.debug("po {f} => {f} po_deps=1", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po) });
+        deps_log.debug("po {f} => {f} po_deps=1", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po) });
         // This AnalUnit was not already PO, so we must recursively mark its dependers as also PO.
         try zcu.markTransitiveDependersPotentiallyOutdated(po);
     }
@@ -3240,13 +3244,15 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
     var chosen_unit: ?AnalUnit = null;
     var chosen_unit_dependers: u32 = undefined;
 
+    // MLUGG TODO: i'm 99% sure this is now impossible. check!!!
     inline for (.{ zcu.outdated.keys(), zcu.potentially_outdated.keys() }) |outdated_units| {
         for (outdated_units) |unit| {
             var n: u32 = 0;
             var it = ip.dependencyIterator(switch (unit.unwrap()) {
                 .func => continue, // a `func` definitely can't be causing the loop so it is a bad choice
                 .@"comptime" => continue, // a `comptime` block can't even be depended on so it is a terrible choice
-                .type => |ty| .{ .interned = ty },
+                .type_layout => |ty| .{ .type_layout = ty },
+                .type_inits => |ty| .{ .type_inits = ty },
                 .nav_val => |nav| .{ .nav_val = nav },
                 .nav_ty => |nav| .{ .nav_ty = nav },
                 .memoized_state => {
@@ -3377,25 +3383,21 @@ pub fn mapOldZirToNew(
         var comptime_decls: std.ArrayList(Zir.Inst.Index) = .empty;
         defer comptime_decls.deinit(gpa);
 
-        {
-            var old_decl_it = old_zir.declIterator(match_item.old_inst);
-            while (old_decl_it.next()) |old_decl_inst| {
-                const old_decl = old_zir.getDeclaration(old_decl_inst);
-                switch (old_decl.kind) {
-                    .@"comptime" => try comptime_decls.append(gpa, old_decl_inst),
-                    .unnamed_test => try unnamed_tests.append(gpa, old_decl_inst),
-                    .@"test" => try named_tests.put(gpa, old_zir.nullTerminatedString(old_decl.name), old_decl_inst),
-                    .decltest => try named_decltests.put(gpa, old_zir.nullTerminatedString(old_decl.name), old_decl_inst),
-                    .@"const", .@"var" => try named_decls.put(gpa, old_zir.nullTerminatedString(old_decl.name), old_decl_inst),
-                }
+        for (old_zir.typeDecls(match_item.old_inst)) |old_decl_inst| {
+            const old_decl = old_zir.getDeclaration(old_decl_inst);
+            switch (old_decl.kind) {
+                .@"comptime" => try comptime_decls.append(gpa, old_decl_inst),
+                .unnamed_test => try unnamed_tests.append(gpa, old_decl_inst),
+                .@"test" => try named_tests.put(gpa, old_zir.nullTerminatedString(old_decl.name), old_decl_inst),
+                .decltest => try named_decltests.put(gpa, old_zir.nullTerminatedString(old_decl.name), old_decl_inst),
+                .@"const", .@"var" => try named_decls.put(gpa, old_zir.nullTerminatedString(old_decl.name), old_decl_inst),
             }
         }
 
         var unnamed_test_idx: u32 = 0;
         var comptime_decl_idx: u32 = 0;
 
-        var new_decl_it = new_zir.declIterator(match_item.new_inst);
-        while (new_decl_it.next()) |new_decl_inst| {
+        for (new_zir.typeDecls(match_item.new_inst)) |new_decl_inst| {
             const new_decl = new_zir.getDeclaration(new_decl_inst);
             // Attempt to match this to a declaration in the old ZIR:
             // * For named declarations (`const`/`var`/`fn`), we match based on name.
@@ -3494,7 +3496,7 @@ pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func_index: InternPool.Index) !vo
     }
 
     try zcu.func_body_analysis_queued.ensureUnusedCapacity(zcu.gpa, 1);
-    try zcu.comp.queueJob(.{ .analyze_func = func_index });
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .func = func_index }) });
     zcu.func_body_analysis_queued.putAssumeCapacityNoClobber(func_index, {});
 }
 
@@ -3513,7 +3515,7 @@ pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav_id: InternPool.Nav.Index) !void
     }
 
     try zcu.nav_val_analysis_queued.ensureUnusedCapacity(zcu.gpa, 1);
-    try zcu.comp.queueJob(.{ .analyze_comptime_unit = .wrap(.{ .nav_val = nav_id }) });
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .nav_val = nav_id }) });
     zcu.nav_val_analysis_queued.putAssumeCapacityNoClobber(nav_id, {});
 }
 
@@ -3908,8 +3910,7 @@ pub fn atomicPtrAlignment(
     return error.BadType;
 }
 
-/// Returns null in the following cases:
-/// * Not a struct.
+/// Returns null if `ty` is not a struct.
 pub fn typeToStruct(zcu: *const Zcu, ty: Type) ?InternPool.LoadedStructType {
     if (ty.ip_index == .none) return null;
     const ip = &zcu.intern_pool;
@@ -3936,7 +3937,6 @@ pub fn structPackedFieldBitOffset(
 ) u16 {
     const ip = &zcu.intern_pool;
     assert(struct_type.layout == .@"packed");
-    assert(struct_type.haveLayout(ip));
     var bit_sum: u64 = 0;
     for (0..struct_type.field_types.len) |i| {
         if (i == field_index) {
@@ -3995,8 +3995,10 @@ pub const UnionLayout = struct {
 pub fn unionTagFieldIndex(zcu: *const Zcu, loaded_union: InternPool.LoadedUnionType, enum_tag: Value) ?u32 {
     const ip = &zcu.intern_pool;
     if (enum_tag.toIntern() == .none) return null;
-    assert(ip.typeOf(enum_tag.toIntern()) == loaded_union.enum_tag_ty);
-    return loaded_union.loadTagType(ip).tagValueIndex(ip, enum_tag.toIntern());
+    const enum_tag_key = ip.indexToKey(enum_tag.toIntern()).enum_tag;
+    assert(enum_tag_key.ty == loaded_union.enum_tag_type);
+    const loaded_enum = ip.loadEnumType(loaded_union.enum_tag_type);
+    return loaded_enum.tagValueIndex(ip, enum_tag_key.int);
 }
 
 pub const ResolvedReference = struct {
@@ -4049,31 +4051,36 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
             const referencer = types.values()[type_idx];
             type_idx += 1;
 
-            log.debug("handle type '{f}'", .{Type.fromInterned(ty).containerTypeName(ip).fmt(ip)});
+            refs_log.debug("handle type '{f}'", .{Type.fromInterned(ty).containerTypeName(ip).fmt(ip)});
 
-            // If this type undergoes type resolution, the corresponding `AnalUnit` is automatically referenced.
-            const has_resolution: bool = switch (ip.indexToKey(ty)) {
-                .struct_type, .union_type => true,
-                .enum_type => |k| k != .generated_tag,
-                .opaque_type => false,
+            // If this type undergoes type resolution, the corresponding `AnalUnit`s are automatically referenced.
+            const has_layout: bool, const has_inits: bool = switch (ip.indexToKey(ty)) {
+                .struct_type => .{ true, true },
+                .union_type => .{ true, false },
+                .enum_type => .{ false, true },
+                .opaque_type => .{ false, false },
                 else => unreachable,
             };
-            if (has_resolution) {
+            if (has_layout) {
                 // this should only be referenced by the type
-                const unit: AnalUnit = .wrap(.{ .type = ty });
+                const unit: AnalUnit = .wrap(.{ .type_layout = ty });
+                try units.putNoClobber(gpa, unit, referencer);
+            }
+            if (has_inits) {
+                // this should only be referenced by the type
+                const unit: AnalUnit = .wrap(.{ .type_inits = ty });
                 try units.putNoClobber(gpa, unit, referencer);
             }
 
             // If this is a union with a generated tag, its tag type is automatically referenced.
             // We don't add this reference for non-generated tags, as those will already be referenced via the union's type resolution, with a better source location.
-            if (zcu.typeToUnion(Type.fromInterned(ty))) |union_obj| {
-                const tag_ty = union_obj.enum_tag_ty;
-                if (tag_ty != .none) {
-                    if (ip.indexToKey(tag_ty).enum_type == .generated_tag) {
-                        const gop = try types.getOrPut(gpa, tag_ty);
-                        if (!gop.found_existing) gop.value_ptr.* = referencer;
-                    }
-                }
+            implicit_tag: {
+                const loaded_union = zcu.typeToUnion(.fromInterned(ty)) orelse break :implicit_tag;
+                const tag_ty = loaded_union.enum_tag_type;
+                if (ip.indexToKey(tag_ty).enum_type != .generated_union_tag) break :implicit_tag;
+                const gop = try types.getOrPut(gpa, tag_ty);
+                if (gop.found_existing) break :implicit_tag;
+                gop.value_ptr.* = referencer;
             }
 
             // Queue any decls within this type which would be automatically analyzed.
@@ -4084,7 +4091,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                 const unit: AnalUnit = .wrap(.{ .@"comptime" = cu });
                 const gop = try units.getOrPut(gpa, unit);
                 if (!gop.found_existing) {
-                    log.debug("type '{f}': ref comptime %{}", .{
+                    refs_log.debug("type '{f}': ref comptime %{}", .{
                         Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
                         @intFromEnum(ip.getComptimeUnit(cu).zir_index.resolve(ip) orelse continue),
                     });
@@ -4118,7 +4125,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                     {
                         const gop = try units.getOrPut(gpa, .wrap(.{ .nav_val = nav_id }));
                         if (!gop.found_existing) {
-                            log.debug("type '{f}': ref test %{}", .{
+                            refs_log.debug("type '{f}': ref test %{}", .{
                                 Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
                                 @intFromEnum(inst_info.inst),
                             });
@@ -4141,7 +4148,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                     const unit: AnalUnit = .wrap(.{ .nav_val = nav });
                     const gop = try units.getOrPut(gpa, unit);
                     if (!gop.found_existing) {
-                        log.debug("type '{f}': ref named %{}", .{
+                        refs_log.debug("type '{f}': ref named %{}", .{
                             Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
                             @intFromEnum(inst_info.inst),
                         });
@@ -4158,7 +4165,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                     const unit: AnalUnit = .wrap(.{ .nav_val = nav });
                     const gop = try units.getOrPut(gpa, unit);
                     if (!gop.found_existing) {
-                        log.debug("type '{f}': ref named %{}", .{
+                        refs_log.debug("type '{f}': ref named %{}", .{
                             Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
                             @intFromEnum(inst_info.inst),
                         });
@@ -4177,14 +4184,14 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                 const other: AnalUnit = .wrap(switch (unit.unwrap()) {
                     .nav_val => |n| .{ .nav_ty = n },
                     .nav_ty => |n| .{ .nav_val = n },
-                    .@"comptime", .type, .func, .memoized_state => break :queue_paired,
+                    .@"comptime", .type_layout, .type_inits, .func, .memoized_state => break :queue_paired,
                 });
                 const gop = try units.getOrPut(gpa, other);
                 if (gop.found_existing) break :queue_paired;
                 gop.value_ptr.* = units.values()[unit_idx]; // same reference location
             }
 
-            log.debug("handle unit '{f}'", .{zcu.fmtAnalUnit(unit)});
+            refs_log.debug("handle unit '{f}'", .{zcu.fmtAnalUnit(unit)});
 
             if (zcu.reference_table.get(unit)) |first_ref_idx| {
                 assert(first_ref_idx != std.math.maxInt(u32));
@@ -4193,7 +4200,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                     const ref = zcu.all_references.items[ref_idx];
                     const gop = try units.getOrPut(gpa, ref.referenced);
                     if (!gop.found_existing) {
-                        log.debug("unit '{f}': ref unit '{f}'", .{
+                        refs_log.debug("unit '{f}': ref unit '{f}'", .{
                             zcu.fmtAnalUnit(unit),
                             zcu.fmtAnalUnit(ref.referenced),
                         });
@@ -4213,7 +4220,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                     const ref = zcu.all_type_references.items[ref_idx];
                     const gop = try types.getOrPut(gpa, ref.referenced);
                     if (!gop.found_existing) {
-                        log.debug("unit '{f}': ref type '{f}'", .{
+                        refs_log.debug("unit '{f}': ref type '{f}'", .{
                             zcu.fmtAnalUnit(unit),
                             Type.fromInterned(ref.referenced).containerTypeName(ip).fmt(ip),
                         });
@@ -4323,9 +4330,8 @@ fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void
                 return writer.print("comptime(inst=<lost> [{}])", .{@intFromEnum(cu_id)});
             }
         },
-        .nav_val => |nav| return writer.print("nav_val('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }),
-        .nav_ty => |nav| return writer.print("nav_ty('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }),
-        .type => |ty| return writer.print("ty('{f}' [{}])", .{ Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
+        .nav_val, .nav_ty => |nav, tag| return writer.print("{t}('{f}' [{}])", .{ tag, ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }),
+        .type_layout, .type_inits => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
         .func => |func| {
             const nav = zcu.funcInfo(func).owner_nav;
             return writer.print("func('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(func) });
@@ -4347,18 +4353,17 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void
             const file_path = zcu.fileByIndex(info.file).path;
             return writer.print("inst('{f}', %{d})", .{ file_path.fmt(zcu.comp), @intFromEnum(info.inst) });
         },
-        .nav_val => |nav| {
+        .nav_val, .nav_ty => |nav, tag| {
             const fqn = ip.getNav(nav).fqn;
-            return writer.print("nav_val('{f}')", .{fqn.fmt(ip)});
+            return writer.print("{t}('{f}')", .{ tag, fqn.fmt(ip) });
         },
-        .nav_ty => |nav| {
-            const fqn = ip.getNav(nav).fqn;
-            return writer.print("nav_ty('{f}')", .{fqn.fmt(ip)});
+        .type_layout, .type_inits => |ip_index, tag| {
+            const name = Type.fromInterned(ip_index).containerTypeName(ip);
+            return writer.print("{t}('{f}')", .{ tag, name.fmt(ip) });
         },
-        .interned => |ip_index| switch (ip.indexToKey(ip_index)) {
-            .struct_type, .union_type, .enum_type => return writer.print("type('{f}')", .{Type.fromInterned(ip_index).containerTypeName(ip).fmt(ip)}),
-            .func => |f| return writer.print("ies('{f}')", .{ip.getNav(f.owner_nav).fqn.fmt(ip)}),
-            else => unreachable,
+        .func_ies => |ip_index| {
+            const fqn = ip.getNav(ip.indexToKey(ip_index).func.owner_nav).fqn;
+            return writer.print("func_ies('{f}')", .{fqn.fmt(ip)});
         },
         .zon_file => |file| {
             const file_path = zcu.fileByIndex(file).path;
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 5472afc5f02682b3f9083b4d710e1c5616c74d57..f9faef2f7a36f0d77cbf86db7c7e355db8038056 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -598,44 +598,38 @@ pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
             // Value is whether the declaration is `pub`.
             var old_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, bool) = .empty;
             defer old_names.deinit(zcu.gpa);
-            {
-                var it = old_zir.declIterator(old_inst);
-                while (it.next()) |decl_inst| {
-                    const old_decl = old_zir.getDeclaration(decl_inst);
-                    if (old_decl.name == .empty) continue;
-                    const name_ip = try zcu.intern_pool.getOrPutString(
-                        zcu.gpa,
-                        io,
-                        pt.tid,
-                        old_zir.nullTerminatedString(old_decl.name),
-                        .no_embedded_nulls,
-                    );
-                    try old_names.put(zcu.gpa, name_ip, old_decl.is_pub);
-                }
+            for (old_zir.typeDecls(old_inst)) |decl_inst| {
+                const old_decl = old_zir.getDeclaration(decl_inst);
+                if (old_decl.name == .empty) continue;
+                const name_ip = try zcu.intern_pool.getOrPutString(
+                    zcu.gpa,
+                    io,
+                    pt.tid,
+                    old_zir.nullTerminatedString(old_decl.name),
+                    .no_embedded_nulls,
+                );
+                try old_names.put(zcu.gpa, name_ip, old_decl.is_pub);
             }
             var any_change = false;
-            {
-                var it = new_zir.declIterator(new_inst);
-                while (it.next()) |decl_inst| {
-                    const new_decl = new_zir.getDeclaration(decl_inst);
-                    if (new_decl.name == .empty) continue;
-                    const name_ip = try zcu.intern_pool.getOrPutString(
-                        zcu.gpa,
-                        io,
-                        pt.tid,
-                        new_zir.nullTerminatedString(new_decl.name),
-                        .no_embedded_nulls,
-                    );
-                    if (old_names.fetchSwapRemove(name_ip)) |kv| {
-                        if (kv.value == new_decl.is_pub) continue;
-                    }
-                    // Name added, or changed whether it's pub
-                    any_change = true;
-                    try zcu.markDependeeOutdated(.not_marked_po, .{ .namespace_name = .{
-                        .namespace = tracked_inst_index,
-                        .name = name_ip,
-                    } });
+            for (new_zir.typeDecls(new_inst)) |decl_inst| {
+                const new_decl = new_zir.getDeclaration(decl_inst);
+                if (new_decl.name == .empty) continue;
+                const name_ip = try zcu.intern_pool.getOrPutString(
+                    zcu.gpa,
+                    io,
+                    pt.tid,
+                    new_zir.nullTerminatedString(new_decl.name),
+                    .no_embedded_nulls,
+                );
+                if (old_names.fetchSwapRemove(name_ip)) |kv| {
+                    if (kv.value == new_decl.is_pub) continue;
                 }
+                // Name added, or changed whether it's pub
+                any_change = true;
+                try zcu.markDependeeOutdated(.not_marked_po, .{ .namespace_name = .{
+                    .namespace = tracked_inst_index,
+                    .name = name_ip,
+                } });
             }
             // The only elements remaining in `old_names` now are any names which were removed.
             for (old_names.keys()) |name_ip| {
@@ -674,24 +668,49 @@ pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
     }
 }
 
-/// Ensures that `zcu.fileRootType` on this `file_index` gives an up-to-date answer.
-/// Returns `error.AnalysisFail` if the file has an error.
-pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
-    const file_root_type = pt.zcu.fileRootType(file_index);
-    if (file_root_type != .none) {
-        if (pt.ensureTypeUpToDate(file_root_type)) |_| {
-            return;
-        } else |err| switch (err) {
-            error.AnalysisFail => {
-                // The file's root `struct_decl` has, at some point, been lost, because the file failed AstGen.
-                // Clear `file_root_type`, and try the `semaFile` call below, in case the instruction has since
-                // been discovered under a new `TrackedInst.Index`.
-                pt.zcu.setFileRootType(file_index, .none);
-            },
-            else => |e| return e,
-        }
-    }
-    return pt.semaFile(file_index);
+/// Ensures that `zcu.fileRootType` on this `file_index` is populated (not `.none`). This implies
+/// that the file's namespace is scanned, discovering declarations.
+///
+/// Typical Zig compilations begin by claling this function on the root source file of the standard
+/// library, `lib/std/std.zig`. The resulting namespace scan discovers a `comptime` declaration in
+/// that file, which is queued for analysis, and everything goes from there.
+pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Allocator.Error || Io.Cancelable)!void {
+    dev.check(.sema);
+
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const io = comp.io;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    if (zcu.fileRootType(file_index) != .none) return; // already good
+
+    const file = zcu.fileByIndex(file_index);
+    assert(file.getMode() == .zig);
+    const struct_decl = file.zir.?.getStructDecl(.main_struct_inst);
+    const tracked_inst = try ip.trackZir(gpa, io, pt.tid, .{
+        .file = file_index,
+        .inst = .main_struct_inst,
+    });
+    const file_root_type = try Sema.analyzeStructDecl(
+        pt,
+        file_index,
+        &file.zir.?,
+        .none,
+        tracked_inst,
+        &struct_decl,
+        null,
+        &.{},
+        .{ .exact = .{
+            .name = try file.internFullyQualifiedName(pt),
+            .nav = .none,
+        } },
+    );
+    zcu.setFileRootType(file_index, file_root_type.toIntern());
+    if (zcu.comp.time_report) |*tr| tr.stats.n_imported_files += 1;
 }
 
 /// Ensures that all memoized state on `Zcu` is up-to-date, performing re-analysis if necessary.
@@ -1012,6 +1031,238 @@ fn analyzeComptimeUnit(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu
     try sema.flushExports();
 }
 
+/// Ensures that the layout of the given `struct` or `union` type is fully up-to-date, performing
+/// re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!) or union. Returns
+/// `error.AnalysisFail` if an analysis error is encountered during type resolution; the caller is
+/// free to ignore this, since the error is already registered.
+pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const zcu = pt.zcu;
+    const gpa = zcu.gpa;
+
+    const anal_unit: AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
+
+    log.debug("ensureTypeLayoutUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
+
+    assert(!zcu.analysis_in_progress.contains(anal_unit));
+
+    // Determine whether or not this type is outdated. For this kind of `AnalUnit`, that's
+    // the only indicator as to whether or not analysis is required; when a struct/union is
+    // first created, it's marked as outdated.
+    // MLUGG TODO: make that actually true, it's a good strategy here!
+
+    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
+        zcu.potentially_outdated.swapRemove(anal_unit);
+
+    if (was_outdated) {
+        _ = zcu.outdated_ready.swapRemove(anal_unit);
+        // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
+        if (dev.env.supports(.incremental)) {
+            zcu.deleteUnitExports(anal_unit);
+            zcu.deleteUnitReferences(anal_unit);
+            zcu.deleteUnitCompileLogs(anal_unit);
+            if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
+                kv.value.destroy(gpa);
+            }
+            _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
+            zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
+        }
+        // For types, we already know that we have to invalidate all dependees.
+        // TODO: we actually *could* detect whether everything was the same. should we bother?
+        try zcu.markDependeeOutdated(.marked_po, .{ .type_layout = ty.toIntern() });
+    } else {
+        // We can trust the current information about this unit.
+        if (zcu.failed_analysis.contains(anal_unit)) return error.AnalysisFail;
+        if (zcu.transitive_failed_analysis.contains(anal_unit)) return error.AnalysisFail;
+        return;
+    }
+
+    if (zcu.comp.debugIncremental()) {
+        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, anal_unit);
+        info.last_update_gen = zcu.generation;
+        info.deps.clearRetainingCapacity();
+    }
+
+    const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(&zcu.intern_pool).toSlice(&zcu.intern_pool), null);
+    defer unit_tracking.end(zcu);
+
+    try zcu.analysis_in_progress.put(gpa, anal_unit, {});
+    defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
+
+    var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
+    defer analysis_arena.deinit();
+
+    var comptime_err_ret_trace: std.array_list.Managed(Zcu.LazySrcLoc) = .init(gpa);
+    defer comptime_err_ret_trace.deinit();
+
+    const file = zcu.namespacePtr(ty.getNamespaceIndex(zcu)).fileScope(zcu);
+
+    var sema: Sema = .{
+        .pt = pt,
+        .gpa = gpa,
+        .arena = analysis_arena.allocator(),
+        .code = file.zir.?,
+        .owner = anal_unit,
+        .func_index = .none,
+        .func_is_naked = false,
+        .fn_ret_ty = .void,
+        .fn_ret_ty_ies = null,
+        .comptime_err_ret_trace = &comptime_err_ret_trace,
+    };
+    defer sema.deinit();
+
+    const result = switch (ty.containerLayout(zcu)) {
+        .auto, .@"extern" => switch (ty.zigTypeTag(zcu)) {
+            .@"struct" => Sema.type_resolution.resolveStructLayout(&sema, ty),
+            .@"union" => Sema.type_resolution.resolveUnionLayout(&sema, ty),
+            else => unreachable,
+        },
+        .@"packed" => switch (ty.zigTypeTag(zcu)) {
+            .@"struct" => Sema.type_resolution.resolvePackedStructLayout(&sema, ty),
+            .@"union" => Sema.type_resolution.resolvePackedUnionLayout(&sema, ty),
+            else => unreachable,
+        },
+    };
+    result catch |err| switch (err) {
+        error.AnalysisFail => {
+            if (!zcu.failed_analysis.contains(anal_unit)) {
+                // If this unit caused the error, it would have an entry in `failed_analysis`.
+                // Since it does not, this must be a transitive failure.
+                try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
+                log.debug("mark transitive analysis failure for {f}", .{zcu.fmtAnalUnit(anal_unit)});
+            }
+            return error.AnalysisFail;
+        },
+        error.OutOfMemory,
+        error.Canceled,
+        => |e| return e,
+        error.ComptimeReturn => unreachable,
+        error.ComptimeBreak => unreachable,
+    };
+
+    sema.flushExports() catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+    };
+
+    codegen_type: {
+        if (zcu.comp.config.use_llvm) break :codegen_type;
+        if (file.mod.?.strip) break :codegen_type;
+        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
+        try zcu.comp.queueJob(.{ .link_type = ty.toIntern() });
+    }
+}
+
+/// Ensures that the default/tag values of the given `struct` or `enum` type are fully up-to-date,
+/// performing re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!) or an enum.
+/// Returns `error.AnalysisFail` if an analysis error is encountered during resolution; the caller
+/// is free to ignore this, since the error is already registered.
+pub fn ensureTypeInitsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const zcu = pt.zcu;
+    const gpa = zcu.gpa;
+
+    const anal_unit: AnalUnit = .wrap(.{ .type_inits = ty.toIntern() });
+
+    log.debug("ensureTypeInitsUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
+
+    assert(!zcu.analysis_in_progress.contains(anal_unit));
+
+    // Determine whether or not this type is outdated. For this kind of `AnalUnit`, that's
+    // the only indicator as to whether or not analysis is required; when a struct/enum is
+    // first created, it's marked as outdated.
+    // MLUGG TODO: make that actually true, it's a good strategy here!
+
+    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
+        zcu.potentially_outdated.swapRemove(anal_unit);
+
+    if (was_outdated) {
+        _ = zcu.outdated_ready.swapRemove(anal_unit);
+        // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
+        if (dev.env.supports(.incremental)) {
+            zcu.deleteUnitExports(anal_unit);
+            zcu.deleteUnitReferences(anal_unit);
+            zcu.deleteUnitCompileLogs(anal_unit);
+            if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
+                kv.value.destroy(gpa);
+            }
+            _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
+            zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
+        }
+        // For types, we already know that we have to invalidate all dependees.
+        // TODO: we actually *could* detect whether everything was the same. should we bother?
+        try zcu.markDependeeOutdated(.marked_po, .{ .type_inits = ty.toIntern() });
+    } else {
+        // We can trust the current information about this unit.
+        if (zcu.failed_analysis.contains(anal_unit)) return error.AnalysisFail;
+        if (zcu.transitive_failed_analysis.contains(anal_unit)) return error.AnalysisFail;
+        return;
+    }
+
+    if (zcu.comp.debugIncremental()) {
+        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, anal_unit);
+        info.last_update_gen = zcu.generation;
+        info.deps.clearRetainingCapacity();
+    }
+
+    const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(&zcu.intern_pool).toSlice(&zcu.intern_pool), null);
+    defer unit_tracking.end(zcu);
+
+    try zcu.analysis_in_progress.put(gpa, anal_unit, {});
+    defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
+
+    var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
+    defer analysis_arena.deinit();
+
+    var comptime_err_ret_trace: std.array_list.Managed(Zcu.LazySrcLoc) = .init(gpa);
+    defer comptime_err_ret_trace.deinit();
+
+    const zir = zcu.namespacePtr(ty.getNamespaceIndex(zcu)).fileScope(zcu).zir.?;
+
+    var sema: Sema = .{
+        .pt = pt,
+        .gpa = gpa,
+        .arena = analysis_arena.allocator(),
+        .code = zir,
+        .owner = anal_unit,
+        .func_index = .none,
+        .func_is_naked = false,
+        .fn_ret_ty = .void,
+        .fn_ret_ty_ies = null,
+        .comptime_err_ret_trace = &comptime_err_ret_trace,
+    };
+    defer sema.deinit();
+
+    const result = switch (ty.zigTypeTag(zcu)) {
+        .@"struct" => Sema.type_resolution.resolveStructDefaults(&sema, ty),
+        .@"enum" => Sema.type_resolution.resolveEnumValues(&sema, ty),
+        else => unreachable,
+    };
+    result catch |err| switch (err) {
+        error.AnalysisFail => {
+            if (!zcu.failed_analysis.contains(anal_unit)) {
+                // If this unit caused the error, it would have an entry in `failed_analysis`.
+                // Since it does not, this must be a transitive failure.
+                try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
+                log.debug("mark transitive analysis failure for {f}", .{zcu.fmtAnalUnit(anal_unit)});
+            }
+            return error.AnalysisFail;
+        },
+        error.OutOfMemory,
+        error.Canceled,
+        => |e| return e,
+        error.ComptimeReturn => unreachable,
+        error.ComptimeBreak => unreachable,
+    };
+
+    sema.flushExports() catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+    };
+}
+
 /// Ensures that the resolved value of the given `Nav` is fully up-to-date, performing re-analysis
 /// if necessary. Returns `error.AnalysisFail` if an analysis error is encountered; the caller is
 /// free to ignore this, since the error is already registered.
@@ -1360,7 +1611,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
 
     // This resolves the type of the resolved value, not that value itself. If `nav_val` is a struct type,
     // this resolves the type `type` (which needs no resolution), not the struct itself.
-    try nav_ty.resolveLayout(pt);
+    try sema.ensureLayoutResolved(nav_ty);
 
     const queue_linker_work, const is_owned_fn = switch (ip.indexToKey(nav_val.toIntern())) {
         .func => |f| .{ true, f.owner_nav == nav_id }, // note that this lets function aliases reach codegen
@@ -1377,7 +1628,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
         if (zir_decl.align_body != null and !target_util.supportsFunctionAlignment(zcu.getTarget())) {
             return sema.fail(&block, align_src, "target does not support function alignment", .{});
         }
-    } else if (try nav_ty.comptimeOnlySema(pt)) {
+    } else if (nav_ty.comptimeOnly(zcu)) {
         // alignment, linksection, addrspace annotations are not allowed for comptime-only types.
         const reason: []const u8 = switch (ip.indexToKey(nav_val.toIntern())) {
             .func => "function alias", // slightly clearer message, since you *can* specify these on function *declarations*
@@ -1420,12 +1671,11 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
     queue_codegen: {
         if (!queue_linker_work) break :queue_codegen;
 
-        if (!try nav_ty.hasRuntimeBitsSema(pt)) {
+        if (!nav_ty.hasRuntimeBits(zcu)) {
             if (zcu.comp.config.use_llvm) break :queue_codegen;
             if (file.mod.?.strip) break :queue_codegen;
         }
 
-        // This job depends on any resolve_type_fully jobs queued up before it.
         zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
         try zcu.comp.queueJob(.{ .link_nav = nav_id });
     }
@@ -1628,7 +1878,7 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
         break :ty .fromInterned(type_ref.toInterned().?);
     };
 
-    try resolved_ty.resolveLayout(pt);
+    try sema.ensureLayoutResolved(resolved_ty);
 
     // In the case where the type is specified, this function is also responsible for resolving
     // the pointer modifiers, i.e. alignment, linksection, addrspace.
@@ -1765,9 +2015,9 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
 
     if (was_outdated) {
         if (ies_outdated) {
-            try zcu.markDependeeOutdated(.marked_po, .{ .interned = func_index });
+            try zcu.markDependeeOutdated(.marked_po, .{ .func_ies = func_index });
         } else {
-            try zcu.markPoDependeeUpToDate(.{ .interned = func_index });
+            try zcu.markPoDependeeUpToDate(.{ .func_ies = func_index });
         }
     }
 
@@ -1817,7 +2067,7 @@ fn analyzeFuncBody(
 
     log.debug("analyze and generate fn body {f}", .{zcu.fmtAnalUnit(anal_unit)});
 
-    var air = try pt.analyzeFnBodyInner(func_index);
+    var air = try pt.analyzeFuncBodyInner(func_index);
     errdefer air.deinit(gpa);
 
     const ies_outdated = !func.analysisUnordered(ip).inferred_error_set or
@@ -1833,7 +2083,6 @@ fn analyzeFuncBody(
         return .{ .ies_outdated = ies_outdated };
     }
 
-    // This job depends on any resolve_type_fully jobs queued up before it.
     zcu.codegen_prog_node.increaseEstimatedTotalItems(1);
     comp.link_prog_node.increaseEstimatedTotalItems(1);
     try comp.queueJob(.{ .codegen_func = .{
@@ -1844,94 +2093,12 @@ fn analyzeFuncBody(
     return .{ .ies_outdated = ies_outdated };
 }
 
-pub fn semaMod(pt: Zcu.PerThread, mod: *Module) !void {
-    dev.check(.sema);
-    const file_index = pt.zcu.module_roots.get(mod).?.unwrap().?;
-    const root_type = pt.zcu.fileRootType(file_index);
-    if (root_type == .none) {
-        return pt.semaFile(file_index);
-    }
-}
-
-fn createFileRootStruct(
-    pt: Zcu.PerThread,
-    file_index: Zcu.File.Index,
-    namespace_index: Zcu.Namespace.Index,
-    replace_existing: bool,
-) Allocator.Error!InternPool.Index {
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
-    const io = zcu.comp.io;
-    const ip = &zcu.intern_pool;
-    const file = zcu.fileByIndex(file_index);
-    const extended = file.zir.?.instructions.items(.data)[@intFromEnum(Zir.Inst.Index.main_struct_inst)].extended;
-    assert(extended.opcode == .struct_decl);
-    const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-    assert(!small.has_captures_len);
-    assert(!small.has_backing_int);
-    assert(small.layout == .auto);
-    var extra_index: usize = extended.operand + @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len;
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = file.zir.?.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-    const decls_len = if (small.has_decls_len) blk: {
-        const decls_len = file.zir.?.extra[extra_index];
-        extra_index += 1;
-        break :blk decls_len;
-    } else 0;
-    const decls = file.zir.?.bodySlice(extra_index, decls_len);
-    extra_index += decls_len;
-
-    const tracked_inst = try ip.trackZir(gpa, io, pt.tid, .{
-        .file = file_index,
-        .inst = .main_struct_inst,
-    });
-    const wip_ty = switch (try ip.getStructType(gpa, io, pt.tid, .{
-        .layout = .auto,
-        .fields_len = fields_len,
-        .known_non_opv = small.known_non_opv,
-        .requires_comptime = if (small.known_comptime_only) .yes else .unknown,
-        .any_comptime_fields = small.any_comptime_fields,
-        .any_default_inits = small.any_default_inits,
-        .inits_resolved = false,
-        .any_aligned_fields = small.any_aligned_fields,
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = &.{},
-        } },
-    }, replace_existing)) {
-        .existing => unreachable, // we wouldn't be analysing the file root if this type existed
-        .wip => |wip| wip,
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    wip_ty.setName(ip, try file.internFullyQualifiedName(pt), .none);
-    ip.namespacePtr(namespace_index).owner_type = wip_ty.index;
-
-    if (zcu.comp.config.incremental) {
-        try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = tracked_inst });
-    }
-
-    try pt.scanNamespace(namespace_index, decls);
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
-    codegen_type: {
-        if (file.mod.?.strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-    zcu.setFileRootType(file_index, wip_ty.index);
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return wip_ty.finish(ip, namespace_index);
-}
-
 /// Re-scan the namespace of a file's root struct type on an incremental update.
 /// The file must have successfully populated ZIR.
 /// If the file's root struct type is not populated (the file is unreferenced), nothing is done.
 /// This is called by `updateZirRefs` for all updated files before the main work loop.
 /// This function does not perform any semantic analysis.
+/// MLUGG TODO: mmmmm i have no idea if this makes sense... tbhwy i just want to update all *changed* namespaces at the start of an update or something lol
 fn updateFileNamespace(pt: Zcu.PerThread, file_index: Zcu.File.Index) Allocator.Error!void {
     const zcu = pt.zcu;
 
@@ -1945,48 +2112,11 @@ fn updateFileNamespace(pt: Zcu.PerThread, file_index: Zcu.File.Index) Allocator.
     });
 
     const namespace_index = Type.fromInterned(file_root_type).getNamespaceIndex(zcu);
-    const decls = decls: {
-        const extended = file.zir.?.instructions.items(.data)[@intFromEnum(Zir.Inst.Index.main_struct_inst)].extended;
-        const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-
-        var extra_index: usize = extended.operand + @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len;
-        extra_index += @intFromBool(small.has_fields_len);
-        const decls_len = if (small.has_decls_len) blk: {
-            const decls_len = file.zir.?.extra[extra_index];
-            extra_index += 1;
-            break :blk decls_len;
-        } else 0;
-        break :decls file.zir.?.bodySlice(extra_index, decls_len);
-    };
+    const decls = file.zir.?.getStructDecl(.main_struct_inst).decls;
     try pt.scanNamespace(namespace_index, decls);
     zcu.namespacePtr(namespace_index).generation = zcu.generation;
 }
 
-fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const zcu = pt.zcu;
-    const file = zcu.fileByIndex(file_index);
-    assert(file.getMode() == .zig);
-    assert(zcu.fileRootType(file_index) == .none);
-
-    assert(file.zir != null);
-
-    const new_namespace_index = try pt.createNamespace(.{
-        .parent = .none,
-        .owner_type = undefined, // set in `createFileRootStruct`
-        .file_scope = file_index,
-        .generation = zcu.generation,
-    });
-    const struct_ty = try pt.createFileRootStruct(file_index, new_namespace_index, false);
-    errdefer zcu.intern_pool.remove(pt.tid, struct_ty);
-
-    if (zcu.comp.time_report) |*tr| {
-        tr.stats.n_imported_files += 1;
-    }
-}
-
 /// Called by AstGen worker threads when an import is seen. If `new_file` is returned, the caller is
 /// then responsible for queueing a new AstGen job for the new file.
 /// Assumes that `comp.mutex` is NOT locked. It will be locked by this function where necessary.
@@ -2878,15 +3008,15 @@ const ScanDeclIter = struct {
 
         if (existing_unit == null and (want_analysis or decl.linkage == .@"export")) {
             log.debug(
-                "scanDecl queue analyze_comptime_unit file='{s}' unit={f}",
+                "scanDecl queue analyze_unit file='{s}' unit={f}",
                 .{ namespace.fileScope(zcu).sub_file_path, zcu.fmtAnalUnit(unit) },
             );
-            try comp.queueJob(.{ .analyze_comptime_unit = unit });
+            try comp.queueJob(.{ .analyze_unit = unit });
         }
     }
 };
 
-fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!Air {
+fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!Air {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -3020,16 +3150,12 @@ fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaE
         const gop = sema.inst_map.getOrPutAssumeCapacity(inst);
         if (gop.found_existing) continue; // provided above by comptime arg
 
-        const param_ty = fn_ty_info.param_types.get(ip)[runtime_param_index];
+        const param_ty: Type = .fromInterned(fn_ty_info.param_types.get(ip)[runtime_param_index]);
         runtime_param_index += 1;
 
-        const opt_opv = sema.typeHasOnePossibleValue(Type.fromInterned(param_ty)) catch |err| switch (err) {
-            error.ComptimeReturn => unreachable,
-            error.ComptimeBreak => unreachable,
-            else => |e| return e,
-        };
-        if (opt_opv) |opv| {
-            gop.value_ptr.* = Air.internedToRef(opv.toIntern());
+        try sema.ensureLayoutResolved(param_ty);
+        if (try param_ty.onePossibleValue(pt)) |opv| {
+            gop.value_ptr.* = .fromValue(opv);
             continue;
         }
         const arg_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
@@ -3038,12 +3164,14 @@ fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaE
         sema.air_instructions.appendAssumeCapacity(.{
             .tag = .arg,
             .data = .{ .arg = .{
-                .ty = Air.internedToRef(param_ty),
+                .ty = .fromIntern(param_ty.toIntern()),
                 .zir_param_index = @intCast(zir_param_index),
             } },
         });
     }
 
+    try sema.ensureLayoutResolved(sema.fn_ret_ty);
+
     const last_arg_index = inner_block.instructions.items.len;
 
     // Save the error trace as our first action in the function.
@@ -3103,21 +3231,9 @@ fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaE
         func.setResolvedErrorSet(ip, io, ies.resolved);
     }
 
+    // MLUGG TODO: i think this can go away and the assert move to the defer?
     assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
-    // Finally we must resolve the return type and parameter types so that backends
-    // have full access to type information.
-    // Crucially, this happens *after* we set the function state to success above,
-    // so that dependencies on the function body will now be satisfied rather than
-    // result in circular dependency errors.
-    // TODO: this can go away once we fix backends having to resolve `StackTrace`.
-    // The codegen timing guarantees that the parameter types will be populated.
-    sema.resolveFnTypes(fn_ty, inner_block.nodeOffset(.zero)) catch |err| switch (err) {
-        error.ComptimeReturn => unreachable,
-        error.ComptimeBreak => unreachable,
-        else => |e| return e,
-    };
-
     try sema.flushExports();
 
     defer {
@@ -3605,16 +3721,6 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!
 
     if (info.flags.size == .c) canon_info.flags.is_allowzero = true;
 
-    // Canonicalize non-zero alignment. If it matches the ABI alignment of the pointee
-    // type, we change it to 0 here. If this causes an assertion trip because the
-    // pointee type needs to be resolved more, that needs to be done before calling
-    // this ptr() function.
-    if (info.flags.alignment != .none and
-        info.flags.alignment == Type.fromInterned(info.child).abiAlignment(pt.zcu))
-    {
-        canon_info.flags.alignment = .none;
-    }
-
     switch (info.flags.vector_index) {
         // Canonicalize host_size. If it matches the bit size of the pointee type,
         // we change it to 0 here. If this causes an assertion trip, the pointee type
@@ -3632,16 +3738,6 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!
     return Type.fromInterned(try pt.intern(.{ .ptr_type = canon_info }));
 }
 
-/// Like `ptrType`, but if `info` specifies an `alignment`, first ensures the pointer
-/// child type's alignment is resolved so that an invalid alignment is not used.
-/// In general, prefer this function during semantic analysis.
-pub fn ptrTypeSema(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Zcu.SemaError!Type {
-    if (info.flags.alignment != .none) {
-        _ = try Type.fromInterned(info.child).abiAlignmentSema(pt);
-    }
-    return pt.ptrType(info);
-}
-
 pub fn singleMutPtrType(pt: Zcu.PerThread, child_type: Type) Allocator.Error!Type {
     return pt.ptrType(.{ .child = child_type.toIntern() });
 }
@@ -3739,31 +3835,37 @@ pub fn enumValue(pt: Zcu.PerThread, ty: Type, tag_int: InternPool.Index) Allocat
 /// declaration order.
 pub fn enumValueFieldIndex(pt: Zcu.PerThread, ty: Type, field_index: u32) Allocator.Error!Value {
     const ip = &pt.zcu.intern_pool;
+    ty.assertHasInits(pt.zcu);
     const enum_type = ip.loadEnumType(ty.toIntern());
 
-    if (enum_type.values.len == 0) {
+    assert(field_index < enum_type.field_names.len);
+
+    if (enum_type.field_values.len == 0) {
         // Auto-numbered fields.
         return Value.fromInterned(try pt.intern(.{ .enum_tag = .{
             .ty = ty.toIntern(),
             .int = try pt.intern(.{ .int = .{
-                .ty = enum_type.tag_ty,
+                .ty = enum_type.int_tag_type,
                 .storage = .{ .u64 = field_index },
             } }),
         } }));
     }
 
-    return Value.fromInterned(try pt.intern(.{ .enum_tag = .{
+    return .fromInterned(try pt.intern(.{ .enum_tag = .{
         .ty = ty.toIntern(),
-        .int = enum_type.values.get(ip)[field_index],
+        .int = enum_type.field_values.get(ip)[field_index],
     } }));
 }
 
 pub fn undefValue(pt: Zcu.PerThread, ty: Type) Allocator.Error!Value {
-    return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
+    if (std.debug.runtime_safety) {
+        assert(try ty.onePossibleValue(pt) == null);
+    }
+    return .fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
 }
 
 pub fn undefRef(pt: Zcu.PerThread, ty: Type) Allocator.Error!Air.Inst.Ref {
-    return Air.internedToRef((try pt.undefValue(ty)).toIntern());
+    return .fromValue(try pt.undefValue(ty));
 }
 
 pub fn intValue(pt: Zcu.PerThread, ty: Type, x: anytype) Allocator.Error!Value {
@@ -3916,7 +4018,7 @@ pub fn intFittingRange(pt: Zcu.PerThread, min: Value, max: Value) !Type {
         assert(Value.order(min, max, zcu).compare(.lte));
     }
 
-    const sign = min.orderAgainstZero(zcu) == .lt;
+    const sign = min.compareHetero(.lt, .zero_comptime_int, zcu);
 
     const min_val_bits = pt.intBitsForValue(min, sign);
     const max_val_bits = pt.intBitsForValue(max, sign);
@@ -3955,12 +4057,6 @@ pub fn intBitsForValue(pt: Zcu.PerThread, val: Value, sign: bool) u16 {
 
             return @as(u16, @intCast(big.bitCountTwosComp()));
         },
-        .lazy_align => |lazy_ty| {
-            return Type.smallestUnsignedBits(Type.fromInterned(lazy_ty).abiAlignment(pt.zcu).toByteUnits() orelse 0) + @intFromBool(sign);
-        },
-        .lazy_size => |lazy_ty| {
-            return Type.smallestUnsignedBits(Type.fromInterned(lazy_ty).abiSize(pt.zcu)) + @intFromBool(sign);
-        },
     }
 }
 
@@ -3993,7 +4089,6 @@ pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!
     const comp = zcu.comp;
     const result = try zcu.intern_pool.getExtern(comp.gpa, comp.io, pt.tid, key);
     if (result.new_nav.unwrap()) |nav| {
-        // This job depends on any resolve_type_fully jobs queued up before it.
         comp.link_prog_node.increaseEstimatedTotalItems(1);
         try comp.queueJob(.{ .link_nav = nav });
         if (comp.debugIncremental()) try zcu.incremental_debug_state.newNav(zcu, nav);
@@ -4013,367 +4108,6 @@ pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPo
     return ty.abiAlignment(zcu);
 }
 
-/// `ty` is a container type requiring resolution (struct, union, or enum).
-/// If `ty` is outdated, it is recreated at a new `InternPool.Index`, which is returned.
-/// If the type cannot be recreated because it has been lost, `error.AnalysisFail` is returned.
-/// If `ty` is not outdated, that same `InternPool.Index` is returned.
-/// If `ty` has already been replaced by this function, the new index will not be returned again.
-/// Also, if `ty` is an enum, this function will resolve the new type if needed, and the call site
-/// is responsible for checking `[transitive_]failed_analysis` to detect resolution failures.
-pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index) Zcu.SemaError!InternPool.Index {
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
-    const ip = &zcu.intern_pool;
-
-    const anal_unit: AnalUnit = .wrap(.{ .type = ty });
-    const outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
-
-    if (outdated) {
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
-        try zcu.markDependeeOutdated(.marked_po, .{ .interned = ty });
-    }
-
-    const ty_key = switch (ip.indexToKey(ty)) {
-        .struct_type, .union_type, .enum_type => |key| key,
-        else => unreachable,
-    };
-    const declared_ty_key = switch (ty_key) {
-        .reified => unreachable, // never outdated
-        .generated_tag => unreachable, // never outdated
-        .declared => |d| d,
-    };
-
-    if (declared_ty_key.zir_index.resolve(ip) == null) {
-        // The instruction has been lost -- this type is dead.
-        return error.AnalysisFail;
-    }
-
-    if (!outdated) return ty;
-
-    // We will recreate the type at a new `InternPool.Index`.
-
-    // Delete old state which is no longer in use. Technically, this is not necessary: these exports,
-    // references, etc, will be ignored because the type itself is unreferenced. However, it allows
-    // reusing the memory which is currently being used to track this state.
-    zcu.deleteUnitExports(anal_unit);
-    zcu.deleteUnitReferences(anal_unit);
-    zcu.deleteUnitCompileLogs(anal_unit);
-    if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-        kv.value.destroy(gpa);
-    }
-    _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
-    zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
-
-    if (zcu.comp.debugIncremental()) {
-        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, anal_unit);
-        info.last_update_gen = zcu.generation;
-        info.deps.clearRetainingCapacity();
-    }
-
-    switch (ip.indexToKey(ty)) {
-        .struct_type => return pt.recreateStructType(ty, declared_ty_key),
-        .union_type => return pt.recreateUnionType(ty, declared_ty_key),
-        .enum_type => return pt.recreateEnumType(ty, declared_ty_key),
-        else => unreachable,
-    }
-}
-
-fn recreateStructType(
-    pt: Zcu.PerThread,
-    old_ty: InternPool.Index,
-    key: InternPool.Key.NamespaceType.Declared,
-) Allocator.Error!InternPool.Index {
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const inst_info = key.zir_index.resolveFull(ip).?;
-    const file = zcu.fileByIndex(inst_info.file);
-    const zir = file.zir.?;
-
-    assert(zir.instructions.items(.tag)[@intFromEnum(inst_info.inst)] == .extended);
-    const extended = zir.instructions.items(.data)[@intFromEnum(inst_info.inst)].extended;
-    assert(extended.opcode == .struct_decl);
-    const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-    const extra = zir.extraData(Zir.Inst.StructDecl, extended.operand);
-    var extra_index = extra.end;
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    assert(captures_len == key.captures.owned.len); // synchronises with logic in `Zcu.mapOldZirToNew`
-
-    const struct_obj = ip.loadStructType(old_ty);
-
-    const wip_ty = switch (try ip.getStructType(gpa, io, pt.tid, .{
-        .layout = small.layout,
-        .fields_len = fields_len,
-        .known_non_opv = small.known_non_opv,
-        .requires_comptime = if (small.known_comptime_only) .yes else .unknown,
-        .any_comptime_fields = small.any_comptime_fields,
-        .any_default_inits = small.any_default_inits,
-        .inits_resolved = false,
-        .any_aligned_fields = small.any_aligned_fields,
-        .key = .{ .declared_owned_captures = .{
-            .zir_index = key.zir_index,
-            .captures = key.captures.owned,
-        } },
-    }, true)) {
-        .wip => |wip| wip,
-        .existing => unreachable, // we passed `replace_existing`
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    wip_ty.setName(ip, struct_obj.name, struct_obj.name_nav);
-    try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = key.zir_index });
-    zcu.namespacePtr(struct_obj.namespace).owner_type = wip_ty.index;
-    // No need to re-scan the namespace -- `zirStructDecl` will ultimately do that if the type is still alive.
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
-
-    codegen_type: {
-        if (file.mod.?.strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    const new_ty = wip_ty.finish(ip, struct_obj.namespace);
-    if (inst_info.inst == .main_struct_inst) {
-        // This is the root type of a file! Update the reference.
-        zcu.setFileRootType(inst_info.file, new_ty);
-    }
-    return new_ty;
-}
-
-fn recreateUnionType(
-    pt: Zcu.PerThread,
-    old_ty: InternPool.Index,
-    key: InternPool.Key.NamespaceType.Declared,
-) Allocator.Error!InternPool.Index {
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const inst_info = key.zir_index.resolveFull(ip).?;
-    const file = zcu.fileByIndex(inst_info.file);
-    const zir = file.zir.?;
-
-    assert(zir.instructions.items(.tag)[@intFromEnum(inst_info.inst)] == .extended);
-    const extended = zir.instructions.items(.data)[@intFromEnum(inst_info.inst)].extended;
-    assert(extended.opcode == .union_decl);
-    const small: Zir.Inst.UnionDecl.Small = @bitCast(extended.small);
-    const extra = zir.extraData(Zir.Inst.UnionDecl, extended.operand);
-    var extra_index = extra.end;
-
-    extra_index += @intFromBool(small.has_tag_type);
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-    extra_index += @intFromBool(small.has_body_len);
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    assert(captures_len == key.captures.owned.len); // synchronises with logic in `Zcu.mapOldZirToNew`
-
-    const union_obj = ip.loadUnionType(old_ty);
-
-    const namespace_index = union_obj.namespace;
-
-    const wip_ty = switch (try ip.getUnionType(gpa, io, pt.tid, .{
-        .flags = .{
-            .layout = small.layout,
-            .status = .none,
-            .runtime_tag = if (small.has_tag_type or small.auto_enum_tag)
-                .tagged
-            else if (small.layout != .auto)
-                .none
-            else switch (true) { // TODO
-                true => .safety,
-                false => .none,
-            },
-            .any_aligned_fields = small.any_aligned_fields,
-            .requires_comptime = .unknown,
-            .assumed_runtime_bits = false,
-            .assumed_pointer_aligned = false,
-            .alignment = .none,
-        },
-        .fields_len = fields_len,
-        .enum_tag_ty = .none, // set later
-        .field_types = &.{}, // set later
-        .field_aligns = &.{}, // set later
-        .key = .{ .declared_owned_captures = .{
-            .zir_index = key.zir_index,
-            .captures = key.captures.owned,
-        } },
-    }, true)) {
-        .wip => |wip| wip,
-        .existing => unreachable, // we passed `replace_existing`
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    wip_ty.setName(ip, union_obj.name, union_obj.name_nav);
-    try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = key.zir_index });
-    zcu.namespacePtr(namespace_index).owner_type = wip_ty.index;
-    // No need to re-scan the namespace -- `zirUnionDecl` will ultimately do that if the type is still alive.
-    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
-
-    codegen_type: {
-        if (file.mod.?.strip) break :codegen_type;
-        // This job depends on any resolve_type_fully jobs queued up before it.
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return wip_ty.finish(ip, namespace_index);
-}
-
-/// This *does* call `Sema.resolveDeclaredEnum`, but errors from it are not propagated.
-/// Call sites are resposible for checking `[transitive_]failed_analysis` after `ensureTypeUpToDate`
-/// returns in order to detect resolution failures.
-fn recreateEnumType(
-    pt: Zcu.PerThread,
-    old_ty: InternPool.Index,
-    key: InternPool.Key.NamespaceType.Declared,
-) (Allocator.Error || Io.Cancelable)!InternPool.Index {
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const inst_info = key.zir_index.resolveFull(ip).?;
-    const file = zcu.fileByIndex(inst_info.file);
-    const zir = file.zir.?;
-
-    assert(zir.instructions.items(.tag)[@intFromEnum(inst_info.inst)] == .extended);
-    const extended = zir.instructions.items(.data)[@intFromEnum(inst_info.inst)].extended;
-    assert(extended.opcode == .enum_decl);
-    const small: Zir.Inst.EnumDecl.Small = @bitCast(extended.small);
-    const extra = zir.extraData(Zir.Inst.EnumDecl, extended.operand);
-    var extra_index = extra.end;
-
-    const tag_type_ref = if (small.has_tag_type) blk: {
-        const tag_type_ref: Zir.Inst.Ref = @enumFromInt(zir.extra[extra_index]);
-        extra_index += 1;
-        break :blk tag_type_ref;
-    } else .none;
-
-    const captures_len = if (small.has_captures_len) blk: {
-        const captures_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk captures_len;
-    } else 0;
-
-    const body_len = if (small.has_body_len) blk: {
-        const body_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk body_len;
-    } else 0;
-
-    const fields_len = if (small.has_fields_len) blk: {
-        const fields_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk fields_len;
-    } else 0;
-
-    const decls_len = if (small.has_decls_len) blk: {
-        const decls_len = zir.extra[extra_index];
-        extra_index += 1;
-        break :blk decls_len;
-    } else 0;
-
-    assert(captures_len == key.captures.owned.len); // synchronises with logic in `Zcu.mapOldZirToNew`
-
-    extra_index += captures_len * 2;
-    extra_index += decls_len;
-
-    const body = zir.bodySlice(extra_index, body_len);
-    extra_index += body.len;
-
-    const bit_bags_count = std.math.divCeil(usize, fields_len, 32) catch unreachable;
-    const body_end = extra_index;
-    extra_index += bit_bags_count;
-
-    const any_values = for (zir.extra[body_end..][0..bit_bags_count]) |bag| {
-        if (bag != 0) break true;
-    } else false;
-
-    const enum_obj = ip.loadEnumType(old_ty);
-
-    const namespace_index = enum_obj.namespace;
-
-    const wip_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
-        .has_values = any_values,
-        .tag_mode = if (small.nonexhaustive)
-            .nonexhaustive
-        else if (tag_type_ref == .none)
-            .auto
-        else
-            .explicit,
-        .fields_len = fields_len,
-        .key = .{ .declared_owned_captures = .{
-            .zir_index = key.zir_index,
-            .captures = key.captures.owned,
-        } },
-    }, true)) {
-        .wip => |wip| wip,
-        .existing => unreachable, // we passed `replace_existing`
-    };
-    var done = true;
-    errdefer if (!done) wip_ty.cancel(ip, pt.tid);
-
-    wip_ty.setName(ip, enum_obj.name, enum_obj.name_nav);
-
-    zcu.namespacePtr(namespace_index).owner_type = wip_ty.index;
-    // No need to re-scan the namespace -- `zirEnumDecl` will ultimately do that if the type is still alive.
-
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    wip_ty.prepare(ip, namespace_index);
-    done = true;
-
-    Sema.resolveDeclaredEnum(
-        pt,
-        wip_ty,
-        inst_info.inst,
-        key.zir_index,
-        namespace_index,
-        enum_obj.name,
-        small,
-        body,
-        tag_type_ref,
-        any_values,
-        fields_len,
-        zir,
-        body_end,
-    ) catch |err| switch (err) {
-        error.OutOfMemory => |e| return e,
-        error.Canceled => |e| return e,
-        error.AnalysisFail => {}, // call sites are responsible for checking `[transitive_]failed_analysis` to detect this
-    };
-
-    return wip_ty.index;
-}
-
 /// Given a namespace, re-scan its declarations from the type definition if they have not
 /// yet been re-scanned on this update.
 /// If the type declaration instruction has been lost, returns `error.AnalysisFail`.
@@ -4396,7 +4130,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
     };
 
     const key = switch (full_key) {
-        .reified, .generated_tag => {
+        .reified, .generated_union_tag => {
             // Namespace always empty, so up-to-date.
             namespace.generation = zcu.generation;
             return;
@@ -4408,100 +4142,13 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
 
     const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
     const file = zcu.fileByIndex(inst_info.file);
-    const zir = file.zir.?;
-
-    assert(zir.instructions.items(.tag)[@intFromEnum(inst_info.inst)] == .extended);
-    const extended = zir.instructions.items(.data)[@intFromEnum(inst_info.inst)].extended;
+    const zir = &file.zir.?;
 
     const decls = switch (container) {
-        .@"struct" => decls: {
-            assert(extended.opcode == .struct_decl);
-            const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
-            const extra = zir.extraData(Zir.Inst.StructDecl, extended.operand);
-            var extra_index = extra.end;
-            const captures_len = if (small.has_captures_len) blk: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk captures_len;
-            } else 0;
-            extra_index += @intFromBool(small.has_fields_len);
-            const decls_len = if (small.has_decls_len) blk: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk decls_len;
-            } else 0;
-            extra_index += captures_len * 2;
-            if (small.has_backing_int) {
-                const backing_int_body_len = zir.extra[extra_index];
-                extra_index += 1; // backing_int_body_len
-                if (backing_int_body_len == 0) {
-                    extra_index += 1; // backing_int_ref
-                } else {
-                    extra_index += backing_int_body_len; // backing_int_body_inst
-                }
-            }
-            break :decls zir.bodySlice(extra_index, decls_len);
-        },
-        .@"union" => decls: {
-            assert(extended.opcode == .union_decl);
-            const small: Zir.Inst.UnionDecl.Small = @bitCast(extended.small);
-            const extra = zir.extraData(Zir.Inst.UnionDecl, extended.operand);
-            var extra_index = extra.end;
-            extra_index += @intFromBool(small.has_tag_type);
-            const captures_len = if (small.has_captures_len) blk: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk captures_len;
-            } else 0;
-            extra_index += @intFromBool(small.has_body_len);
-            extra_index += @intFromBool(small.has_fields_len);
-            const decls_len = if (small.has_decls_len) blk: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk decls_len;
-            } else 0;
-            extra_index += captures_len * 2;
-            break :decls zir.bodySlice(extra_index, decls_len);
-        },
-        .@"enum" => decls: {
-            assert(extended.opcode == .enum_decl);
-            const small: Zir.Inst.EnumDecl.Small = @bitCast(extended.small);
-            const extra = zir.extraData(Zir.Inst.EnumDecl, extended.operand);
-            var extra_index = extra.end;
-            extra_index += @intFromBool(small.has_tag_type);
-            const captures_len = if (small.has_captures_len) blk: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk captures_len;
-            } else 0;
-            extra_index += @intFromBool(small.has_body_len);
-            extra_index += @intFromBool(small.has_fields_len);
-            const decls_len = if (small.has_decls_len) blk: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk decls_len;
-            } else 0;
-            extra_index += captures_len * 2;
-            break :decls zir.bodySlice(extra_index, decls_len);
-        },
-        .@"opaque" => decls: {
-            assert(extended.opcode == .opaque_decl);
-            const small: Zir.Inst.OpaqueDecl.Small = @bitCast(extended.small);
-            const extra = zir.extraData(Zir.Inst.OpaqueDecl, extended.operand);
-            var extra_index = extra.end;
-            const captures_len = if (small.has_captures_len) blk: {
-                const captures_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk captures_len;
-            } else 0;
-            const decls_len = if (small.has_decls_len) blk: {
-                const decls_len = zir.extra[extra_index];
-                extra_index += 1;
-                break :blk decls_len;
-            } else 0;
-            extra_index += captures_len * 2;
-            break :decls zir.bodySlice(extra_index, decls_len);
-        },
+        .@"struct" => zir.getStructDecl(inst_info.inst).decls,
+        .@"union" => zir.getUnionDecl(inst_info.inst).decls,
+        .@"enum" => zir.getEnumDecl(inst_info.inst).decls,
+        .@"opaque" => zir.getOpaqueDecl(inst_info.inst).decls,
     };
 
     try pt.scanNamespace(namespace_index, decls);
@@ -4509,7 +4156,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
 }
 
 pub fn refValue(pt: Zcu.PerThread, val: InternPool.Index) Zcu.SemaError!InternPool.Index {
-    const ptr_ty = (try pt.ptrTypeSema(.{
+    const ptr_ty = (try pt.ptrType(.{
         .child = pt.zcu.intern_pool.typeOf(val),
         .flags = .{
             .alignment = .none,
@@ -4703,3 +4350,466 @@ fn printVerboseAir(
     try air.write(w, pt, liveness);
     try w.print("# End Function AIR: {f}\n\n", .{fqn.fmt(ip)});
 }
+
+// MLUGG TODO: these functions are all blatant hacks. See if I can remove them!
+pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    if (ty.isGenericPoison()) return;
+    switch (ty.zigTypeTag(zcu)) {
+        .type,
+        .void,
+        .bool,
+        .noreturn,
+        .int,
+        .float,
+        .error_set,
+        .@"opaque",
+        .comptime_float,
+        .comptime_int,
+        .undefined,
+        .null,
+        .enum_literal,
+        => {},
+
+        .frame, .@"anyframe" => @panic("TODO resolveTypeForCodegen async frames"),
+
+        .optional => try pt.resolveTypeForCodegen(ty.childType(zcu)),
+        .error_union => try pt.resolveTypeForCodegen(ty.errorUnionPayload(zcu)),
+        .pointer => try pt.resolveTypeForCodegen(ty.childType(zcu)),
+        .array => try pt.resolveTypeForCodegen(ty.childType(zcu)),
+        .vector => try pt.resolveTypeForCodegen(ty.childType(zcu)),
+
+        .@"fn" => {
+            const info = zcu.typeToFunc(ty).?;
+            for (0..info.param_types.len) |i| {
+                const param_ty = info.param_types.get(ip)[i];
+                try pt.resolveTypeForCodegen(.fromInterned(param_ty));
+            }
+            try pt.resolveTypeForCodegen(.fromInterned(info.return_type));
+        },
+
+        .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
+            .struct_type => {
+                try pt.ensureTypeLayoutUpToDate(ty);
+                try pt.ensureTypeInitsUpToDate(ty);
+            },
+            .tuple_type => |tuple| for (0..tuple.types.len) |i| {
+                const field_is_comptime = tuple.values.get(ip)[i] != .none;
+                if (field_is_comptime) continue;
+                const field_ty = tuple.types.get(ip)[i];
+                try pt.resolveTypeForCodegen(.fromInterned(field_ty));
+            },
+            else => unreachable,
+        },
+
+        .@"union" => try pt.ensureTypeLayoutUpToDate(ty),
+        .@"enum" => try pt.ensureTypeInitsUpToDate(ty),
+    }
+}
+pub fn resolveValueTypesForCodegen(pt: Zcu.PerThread, val: Value) Zcu.SemaError!void {
+    const zcu = pt.zcu;
+    const ty: Type = switch (val.typeOf(zcu).toIntern()) {
+        .type_type => if (val.isUndef(zcu)) {
+            return;
+        } else val.toType(),
+        else => |ty| .fromInterned(ty),
+    };
+    return pt.resolveTypeForCodegen(ty);
+}
+pub fn resolveAirTypesForCodegen(pt: Zcu.PerThread, air: *const Air) Zcu.SemaError!void {
+    return pt.resolveBodyTypesForCodegen(air, air.getMainBody());
+}
+fn resolveBodyTypesForCodegen(pt: Zcu.PerThread, air: *const Air, body: []const Air.Inst.Index) Zcu.SemaError!void {
+    const zcu = pt.zcu;
+    const tags = air.instructions.items(.tag);
+    const datas = air.instructions.items(.data);
+    for (body) |inst| {
+        const data = datas[@intFromEnum(inst)];
+        switch (tags[@intFromEnum(inst)]) {
+            .inferred_alloc, .inferred_alloc_comptime => unreachable,
+
+            .arg => try pt.resolveTypeForCodegen(data.arg.ty.toType()),
+
+            .add,
+            .add_safe,
+            .add_optimized,
+            .add_wrap,
+            .add_sat,
+            .sub,
+            .sub_safe,
+            .sub_optimized,
+            .sub_wrap,
+            .sub_sat,
+            .mul,
+            .mul_safe,
+            .mul_optimized,
+            .mul_wrap,
+            .mul_sat,
+            .div_float,
+            .div_float_optimized,
+            .div_trunc,
+            .div_trunc_optimized,
+            .div_floor,
+            .div_floor_optimized,
+            .div_exact,
+            .div_exact_optimized,
+            .rem,
+            .rem_optimized,
+            .mod,
+            .mod_optimized,
+            .max,
+            .min,
+            .bit_and,
+            .bit_or,
+            .shr,
+            .shr_exact,
+            .shl,
+            .shl_exact,
+            .shl_sat,
+            .xor,
+            .cmp_lt,
+            .cmp_lt_optimized,
+            .cmp_lte,
+            .cmp_lte_optimized,
+            .cmp_eq,
+            .cmp_eq_optimized,
+            .cmp_gte,
+            .cmp_gte_optimized,
+            .cmp_gt,
+            .cmp_gt_optimized,
+            .cmp_neq,
+            .cmp_neq_optimized,
+            .bool_and,
+            .bool_or,
+            .store,
+            .store_safe,
+            .set_union_tag,
+            .array_elem_val,
+            .slice_elem_val,
+            .ptr_elem_val,
+            .memset,
+            .memset_safe,
+            .memcpy,
+            .memmove,
+            .atomic_store_unordered,
+            .atomic_store_monotonic,
+            .atomic_store_release,
+            .atomic_store_seq_cst,
+            .legalize_vec_elem_val,
+            => {
+                try pt.resolveRefTypesForCodegen(data.bin_op.lhs);
+                try pt.resolveRefTypesForCodegen(data.bin_op.rhs);
+            },
+
+            .not,
+            .bitcast,
+            .clz,
+            .ctz,
+            .popcount,
+            .byte_swap,
+            .bit_reverse,
+            .abs,
+            .load,
+            .fptrunc,
+            .fpext,
+            .intcast,
+            .intcast_safe,
+            .trunc,
+            .optional_payload,
+            .optional_payload_ptr,
+            .optional_payload_ptr_set,
+            .wrap_optional,
+            .unwrap_errunion_payload,
+            .unwrap_errunion_err,
+            .unwrap_errunion_payload_ptr,
+            .unwrap_errunion_err_ptr,
+            .errunion_payload_ptr_set,
+            .wrap_errunion_payload,
+            .wrap_errunion_err,
+            .struct_field_ptr_index_0,
+            .struct_field_ptr_index_1,
+            .struct_field_ptr_index_2,
+            .struct_field_ptr_index_3,
+            .get_union_tag,
+            .slice_len,
+            .slice_ptr,
+            .ptr_slice_len_ptr,
+            .ptr_slice_ptr_ptr,
+            .array_to_slice,
+            .int_from_float,
+            .int_from_float_optimized,
+            .int_from_float_safe,
+            .int_from_float_optimized_safe,
+            .float_from_int,
+            .splat,
+            .error_set_has_value,
+            .addrspace_cast,
+            .c_va_arg,
+            .c_va_copy,
+            => {
+                try pt.resolveTypeForCodegen(data.ty_op.ty.toType());
+                try pt.resolveRefTypesForCodegen(data.ty_op.operand);
+            },
+
+            .alloc,
+            .ret_ptr,
+            .c_va_start,
+            => try pt.resolveTypeForCodegen(data.ty),
+
+            .ptr_add,
+            .ptr_sub,
+            .add_with_overflow,
+            .sub_with_overflow,
+            .mul_with_overflow,
+            .shl_with_overflow,
+            .slice,
+            .slice_elem_ptr,
+            .ptr_elem_ptr,
+            => {
+                const bin = air.extraData(Air.Bin, data.ty_pl.payload).data;
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                try pt.resolveRefTypesForCodegen(bin.lhs);
+                try pt.resolveRefTypesForCodegen(bin.rhs);
+            },
+
+            .block,
+            .loop,
+            => {
+                const block = air.unwrapBlock(inst);
+                try pt.resolveTypeForCodegen(block.ty);
+                try pt.resolveBodyTypesForCodegen(air, block.body);
+            },
+
+            .dbg_inline_block => {
+                const block = air.unwrapDbgBlock(inst);
+                try pt.resolveTypeForCodegen(block.ty);
+                try pt.resolveBodyTypesForCodegen(air, block.body);
+            },
+
+            .sqrt,
+            .sin,
+            .cos,
+            .tan,
+            .exp,
+            .exp2,
+            .log,
+            .log2,
+            .log10,
+            .floor,
+            .ceil,
+            .round,
+            .trunc_float,
+            .neg,
+            .neg_optimized,
+            .is_null,
+            .is_non_null,
+            .is_null_ptr,
+            .is_non_null_ptr,
+            .is_err,
+            .is_non_err,
+            .is_err_ptr,
+            .is_non_err_ptr,
+            .ret,
+            .ret_safe,
+            .ret_load,
+            .is_named_enum_value,
+            .tag_name,
+            .error_name,
+            .cmp_lt_errors_len,
+            .c_va_end,
+            .set_err_return_trace,
+            => try pt.resolveRefTypesForCodegen(data.un_op),
+
+            .br, .switch_dispatch => try pt.resolveRefTypesForCodegen(data.br.operand),
+
+            .cmp_vector,
+            .cmp_vector_optimized,
+            => {
+                const extra = air.extraData(Air.VectorCmp, data.ty_pl.payload).data;
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                try pt.resolveRefTypesForCodegen(extra.lhs);
+                try pt.resolveRefTypesForCodegen(extra.rhs);
+            },
+
+            .reduce,
+            .reduce_optimized,
+            => try pt.resolveRefTypesForCodegen(data.reduce.operand),
+
+            .struct_field_ptr,
+            .struct_field_val,
+            => {
+                const extra = air.extraData(Air.StructField, data.ty_pl.payload).data;
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                try pt.resolveRefTypesForCodegen(extra.struct_operand);
+            },
+
+            .shuffle_one => {
+                const unwrapped = air.unwrapShuffleOne(zcu, inst);
+                try pt.resolveTypeForCodegen(unwrapped.result_ty);
+                try pt.resolveRefTypesForCodegen(unwrapped.operand);
+                for (unwrapped.mask) |m| switch (m.unwrap()) {
+                    .elem => {},
+                    .value => |val| try pt.resolveValueTypesForCodegen(.fromInterned(val)),
+                };
+            },
+
+            .shuffle_two => {
+                const unwrapped = air.unwrapShuffleTwo(zcu, inst);
+                try pt.resolveTypeForCodegen(unwrapped.result_ty);
+                try pt.resolveRefTypesForCodegen(unwrapped.operand_a);
+                try pt.resolveRefTypesForCodegen(unwrapped.operand_b);
+                // No values to check because there are no comptime-known values other than undef
+            },
+
+            .cmpxchg_weak,
+            .cmpxchg_strong,
+            => {
+                const extra = air.extraData(Air.Cmpxchg, data.ty_pl.payload).data;
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                try pt.resolveRefTypesForCodegen(extra.ptr);
+                try pt.resolveRefTypesForCodegen(extra.expected_value);
+                try pt.resolveRefTypesForCodegen(extra.new_value);
+            },
+
+            .aggregate_init => {
+                const ty = data.ty_pl.ty.toType();
+                const elems_len: usize = @intCast(ty.arrayLen(zcu));
+                const elems: []const Air.Inst.Ref = @ptrCast(air.extra.items[data.ty_pl.payload..][0..elems_len]);
+                try pt.resolveTypeForCodegen(ty);
+                if (ty.zigTypeTag(zcu) == .@"struct") {
+                    for (elems, 0..) |elem, elem_idx| {
+                        if (ty.structFieldIsComptime(elem_idx, zcu)) continue;
+                        try pt.resolveRefTypesForCodegen(elem);
+                    }
+                } else {
+                    for (elems) |elem| {
+                        try pt.resolveRefTypesForCodegen(elem);
+                    }
+                }
+            },
+
+            .union_init => {
+                const extra = air.extraData(Air.UnionInit, data.ty_pl.payload).data;
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                try pt.resolveRefTypesForCodegen(extra.init);
+            },
+
+            .field_parent_ptr => {
+                const extra = air.extraData(Air.FieldParentPtr, data.ty_pl.payload).data;
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                try pt.resolveRefTypesForCodegen(extra.field_ptr);
+            },
+
+            .atomic_load => try pt.resolveRefTypesForCodegen(data.atomic_load.ptr),
+
+            .prefetch => try pt.resolveRefTypesForCodegen(data.prefetch.ptr),
+
+            .runtime_nav_ptr => try pt.resolveTypeForCodegen(.fromInterned(data.ty_nav.ty)),
+
+            .select,
+            .mul_add,
+            .legalize_vec_store_elem,
+            => {
+                const bin = air.extraData(Air.Bin, data.pl_op.payload).data;
+                try pt.resolveRefTypesForCodegen(data.pl_op.operand);
+                try pt.resolveRefTypesForCodegen(bin.lhs);
+                try pt.resolveRefTypesForCodegen(bin.rhs);
+            },
+
+            .atomic_rmw => {
+                const extra = air.extraData(Air.AtomicRmw, data.pl_op.payload).data;
+                try pt.resolveRefTypesForCodegen(data.pl_op.operand);
+                try pt.resolveRefTypesForCodegen(extra.operand);
+            },
+
+            .call,
+            .call_always_tail,
+            .call_never_tail,
+            .call_never_inline,
+            => {
+                const call = air.unwrapCall(inst);
+                try pt.resolveRefTypesForCodegen(call.callee);
+                for (call.args) |arg| try pt.resolveRefTypesForCodegen(arg);
+            },
+
+            .dbg_var_ptr,
+            .dbg_var_val,
+            .dbg_arg_inline,
+            => try pt.resolveRefTypesForCodegen(data.pl_op.operand),
+
+            .@"try", .try_cold => {
+                const @"try" = air.unwrapTry(inst);
+                try pt.resolveRefTypesForCodegen(@"try".error_union);
+                try pt.resolveBodyTypesForCodegen(air, @"try".else_body);
+            },
+
+            .try_ptr, .try_ptr_cold => {
+                const try_ptr = air.unwrapTryPtr(inst);
+                try pt.resolveTypeForCodegen(try_ptr.error_union_payload_ptr_ty.toType());
+                try pt.resolveRefTypesForCodegen(try_ptr.error_union_ptr);
+                try pt.resolveBodyTypesForCodegen(air, try_ptr.else_body);
+            },
+
+            .cond_br => {
+                const cond_br = air.unwrapCondBr(inst);
+                try pt.resolveRefTypesForCodegen(cond_br.condition);
+                try pt.resolveBodyTypesForCodegen(air, cond_br.then_body);
+                try pt.resolveBodyTypesForCodegen(air, cond_br.else_body);
+            },
+
+            .switch_br, .loop_switch_br => {
+                const switch_br = air.unwrapSwitch(inst);
+                try pt.resolveRefTypesForCodegen(switch_br.operand);
+                var it = switch_br.iterateCases();
+                while (it.next()) |case| {
+                    for (case.items) |item| {
+                        try pt.resolveRefTypesForCodegen(item);
+                    }
+                    for (case.ranges) |range| {
+                        try pt.resolveRefTypesForCodegen(range[0]);
+                        try pt.resolveRefTypesForCodegen(range[1]);
+                    }
+                    try pt.resolveBodyTypesForCodegen(air, case.body);
+                }
+                try pt.resolveBodyTypesForCodegen(air, it.elseBody());
+            },
+
+            .assembly => {
+                const @"asm" = air.unwrapAsm(inst);
+                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
+                for (@"asm".outputs) |output| if (output != .none) try pt.resolveRefTypesForCodegen(output);
+                for (@"asm".inputs) |input| if (input != .none) try pt.resolveRefTypesForCodegen(input);
+            },
+
+            .legalize_compiler_rt_call => {
+                const compiler_rt_call = air.unwrapCompilerRtCall(inst);
+                for (compiler_rt_call.args) |arg| try pt.resolveRefTypesForCodegen(arg);
+            },
+
+            .trap,
+            .breakpoint,
+            .ret_addr,
+            .frame_addr,
+            .unreach,
+            .wasm_memory_size,
+            .wasm_memory_grow,
+            .work_item_id,
+            .work_group_size,
+            .work_group_id,
+            .dbg_stmt,
+            .dbg_empty_stmt,
+            .err_return_trace,
+            .save_err_return_trace_index,
+            .repeat,
+            => {},
+        }
+    }
+}
+fn resolveRefTypesForCodegen(pt: Zcu.PerThread, ref: Air.Inst.Ref) Zcu.SemaError!void {
+    const ip_index = ref.toInterned() orelse {
+        // `ref` refers to a prior instruction, which we already did the resolution for.
+        return;
+    };
+    return pt.resolveValueTypesForCodegen(.fromInterned(ip_index));
+}
diff --git a/src/codegen.zig b/src/codegen.zig
index 6bdfa32f45f277ecd40d18e990f5f7219b81f5e4..176649f5b3d90bfca38ab60da0877734440761ee 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -1088,7 +1088,7 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
                                     return .{ .immediate = fn_ty.abiAlignment(zcu).toByteUnits().? };
                                 }
                             } else if (ty.zigTypeTag(zcu) == .pointer) {
-                                const elem_ty = ty.elemType2(zcu);
+                                const elem_ty = ty.childType(zcu);
                                 if (!elem_ty.hasRuntimeBits(zcu)) {
                                     return .{ .immediate = elem_ty.abiAlignment(zcu).toByteUnits().? };
                                 }
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index 55f0d7fcc0e37b35198f01c2ff88c96cfd72aca4..0e6387949aa8d337f9c731db050551f710fa31e9 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -2464,7 +2464,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
 
                 const ty_pl = air.data(air.inst_index).ty_pl;
                 const bin_op = isel.air.extraData(Air.Bin, ty_pl.payload).data;
-                const elem_size = ty_pl.ty.toType().elemType2(zcu).abiSize(zcu);
+                const elem_size = ty_pl.ty.toType().childType(zcu).abiSize(zcu);
 
                 const base_vi = try isel.use(bin_op.lhs);
                 var base_part_it = base_vi.field(ty_pl.ty.toType(), 0, 8);
@@ -6145,7 +6145,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 } else {
                     const elem_ptr_ra = try isel.allocIntReg();
                     defer isel.freeReg(elem_ptr_ra);
-                    if (!try elem_vi.value.load(isel, slice_ty.elemType2(zcu), elem_ptr_ra, .{
+                    if (!try elem_vi.value.load(isel, slice_ty.childType(zcu), elem_ptr_ra, .{
                         .@"volatile" = ptr_info.flags.is_volatile,
                     })) break :unused;
                     const slice_vi = try isel.use(bin_op.lhs);
@@ -6253,7 +6253,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 } else {
                     const elem_ptr_ra = try isel.allocIntReg();
                     defer isel.freeReg(elem_ptr_ra);
-                    if (!try elem_vi.value.load(isel, ptr_ty.elemType2(zcu), elem_ptr_ra, .{
+                    if (!try elem_vi.value.load(isel, ptr_ty.childType(zcu), elem_ptr_ra, .{
                         .@"volatile" = ptr_info.flags.is_volatile,
                     })) break :unused;
                     const base_vi = try isel.use(bin_op.lhs);
@@ -6594,7 +6594,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                     if (try isel.hasRepeatedByteRepr(.fromInterned(fill_val))) |fill_byte|
                         break :fill_byte .{ .constant = fill_byte };
                 }
-                switch (dst_ty.elemType2(zcu).abiSize(zcu)) {
+                switch (dst_ty.indexablePtrElem(zcu).abiSize(zcu)) {
                     0 => unreachable,
                     1 => break :fill_byte .{ .value = bin_op.rhs },
                     2, 4, 8 => |size| {
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 106737a8331c523f9ecddad0e0138f31a10ea06f..831a64779bc423595b5433b4d70eaf8a5c0fbf37 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -3676,7 +3676,7 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const ptr_ty = f.typeOf(bin_op.lhs);
-    const elem_has_bits = ptr_ty.elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu);
+    const elem_has_bits = ptr_ty.indexablePtrElem(zcu).hasRuntimeBitsIgnoreComptime(zcu);
 
     const ptr = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3738,7 +3738,7 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const slice_ty = f.typeOf(bin_op.lhs);
-    const elem_ty = slice_ty.elemType2(zcu);
+    const elem_ty = slice_ty.childType(zcu);
     const elem_has_bits = elem_ty.hasRuntimeBitsIgnoreComptime(zcu);
 
     const slice = try f.resolveInst(bin_op.lhs);
@@ -4502,7 +4502,7 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const inst_scalar_ty = inst_ty.scalarType(zcu);
-    const elem_ty = inst_scalar_ty.elemType2(zcu);
+    const elem_ty = inst_scalar_ty.indexablePtrElem(zcu);
     if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return f.moveCValue(inst, inst_ty, lhs);
     const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
 
@@ -7037,7 +7037,7 @@ fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CV
     try w.writeAll(", ");
     try writeArrayLen(f, dest_ptr, dest_ty);
     try w.writeAll(" * sizeof(");
-    try f.renderType(w, dest_ty.elemType2(zcu));
+    try f.renderType(w, dest_ty.indexablePtrElem(zcu));
     try w.writeAll("));");
     try f.object.newline();
 
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 4ef72e8ab7fed1786845aa5b8e08d1ddfe6091fa..1327b7b2e1c9985b30f53c4411a8fcf8afa9f89c 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -2112,7 +2112,7 @@ pub const Object = struct {
                 return debug_array_type;
             },
             .vector => {
-                const elem_ty = ty.elemType2(zcu);
+                const elem_ty = ty.childType(zcu);
                 // Vector elements cannot be padded since that would make
                 // @bitSizOf(elem) * len > @bitSizOf(vec).
                 // Neither gdb nor lldb seem to be able to display non-byte sized
diff --git a/src/codegen/mips/abi.zig b/src/codegen/mips/abi.zig
index 02c4c637a4c362ea4b3a826fbd27b72598fcc2cb..6678b74ebc32dceed774331667cdf9d498855947 100644
--- a/src/codegen/mips/abi.zig
+++ b/src/codegen/mips/abi.zig
@@ -44,7 +44,7 @@ pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
             return .byval;
         },
         .vector => {
-            const elem_type = ty.elemType2(zcu);
+            const elem_type = ty.childType(zcu);
             switch (elem_type.zigTypeTag(zcu)) {
                 .bool, .int => {
                     const bit_size = ty.bitSize(zcu);
diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig
index 1f70f5f4de379ad0e01f75be35f0d13695f5b766..dd4ca3f88bbc6bc082a00ab1e62a1b685e068e06 100644
--- a/src/codegen/riscv64/CodeGen.zig
+++ b/src/codegen/riscv64/CodeGen.zig
@@ -2673,7 +2673,7 @@ fn genBinOp(
             defer func.register_manager.unlockReg(tmp_lock);
 
             // RISC-V has no immediate mul, so we copy the size to a temporary register
-            const elem_size = lhs_ty.elemType2(zcu).abiSize(zcu);
+            const elem_size = lhs_ty.indexablePtrElem(zcu).abiSize(zcu);
             const elem_size_reg = try func.copyToTmpRegister(Type.u64, .{ .immediate = elem_size });
 
             try func.genBinOp(
@@ -3913,9 +3913,8 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void {
     const base_ptr_ty = func.typeOf(bin_op.lhs);
 
     const result: MCValue = if (!is_volatile and func.liveness.isUnused(inst)) .unreach else result: {
-        const elem_ty = base_ptr_ty.elemType2(zcu);
+        const elem_ty = base_ptr_ty.indexablePtrElem(zcu);
         if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
-
         const base_ptr_mcv = try func.resolveInst(bin_op.lhs);
         const base_ptr_lock: ?RegisterLock = switch (base_ptr_mcv) {
             .register => |reg| func.register_manager.lockRegAssumeUnused(reg),
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index 2222bb9a050341495a7ca97f6b5a4b9dd5b189ec..e6850df250db68f6b34050f93cb19717ff90ecb2 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -4381,7 +4381,7 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
 fn ptrElemPtr(cg: *CodeGen, ptr_ty: Type, ptr_id: Id, index_id: Id) !Id {
     const zcu = cg.module.zcu;
     // Construct new pointer type for the resulting pointer
-    const elem_ty = ptr_ty.elemType2(zcu); // use elemType() so that we get T for *[N]T.
+    const elem_ty = ptr_ty.indexablePtrElem(zcu);
     const elem_ty_id = try cg.resolveType(elem_ty, .indirect);
     const elem_ptr_ty_id = try cg.module.ptrType(elem_ty_id, cg.module.storageClass(ptr_ty.ptrAddressSpace(zcu)));
     if (ptr_ty.isSinglePointer(zcu)) {
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 6144a421c8cb132aebd77f745bff78618a3e7a0f..58987558d218402d252b81ff51901b85bcd74f78 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -43261,7 +43261,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
-                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
+                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().childType(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .simm32, .none } },
                     },
@@ -43375,7 +43375,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
-                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
+                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().childType(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .simm32, .none } },
                     },
@@ -103926,7 +103926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .array_elem_val, .legalize_vec_elem_val => {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const array_ty = cg.typeOf(bin_op.lhs);
-                const res_ty = array_ty.elemType2(zcu);
+                const res_ty = array_ty.childType(zcu);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{
@@ -104121,7 +104121,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             },
             .slice_elem_val, .ptr_elem_val => {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
-                const res_ty = cg.typeOf(bin_op.lhs).elemType2(zcu);
+                const res_ty = cg.typeOf(bin_op.lhs).indexablePtrElem(zcu);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
@@ -187919,7 +187919,6 @@ const Select = struct {
         unsigned_int: Memory.Size,
         elem_size_is: u8,
         po2_elem_size,
-        elem_int: Memory.Size,
 
         const OfIsSizes = struct { of: Memory.Size, is: Memory.Size };
 
@@ -188178,12 +188177,8 @@ const Select = struct {
                     .signed => false,
                     .unsigned => size.bitSize(cg.target) >= int_info.bits,
                 } else false,
-                .elem_size_is => |size| size == ty.elemType2(zcu).abiSize(zcu),
-                .po2_elem_size => std.math.isPowerOfTwo(ty.elemType2(zcu).abiSize(zcu)),
-                .elem_int => |size| if (cg.intInfo(ty.elemType2(zcu))) |elem_int_info|
-                    size.bitSize(cg.target) >= elem_int_info.bits
-                else
-                    false,
+                .elem_size_is => |size| size == ty.indexablePtrElem(zcu).abiSize(zcu),
+                .po2_elem_size => std.math.isPowerOfTwo(ty.indexablePtrElem(zcu).abiSize(zcu)),
             };
         }
     };
@@ -189918,20 +189913,20 @@ const Select = struct {
                 .dst0_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).abiSize(s.cg.pt.zcu)),
                 .delta_size => @intCast(@as(SignedImm, @intCast(op.flags.base.ref.typeOf(s).abiSize(s.cg.pt.zcu))) -
                     @as(SignedImm, @intCast(op.flags.index.ref.typeOf(s).abiSize(s.cg.pt.zcu)))),
-                .delta_elem_size => @intCast(@as(SignedImm, @intCast(op.flags.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))) -
-                    @as(SignedImm, @intCast(op.flags.index.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)))),
+                .delta_elem_size => @intCast(@as(SignedImm, @intCast(op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))) -
+                    @as(SignedImm, @intCast(op.flags.index.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)))),
                 .unaligned_size => @intCast(s.cg.unalignedSize(op.flags.base.ref.typeOf(s))),
                 .unaligned_size_add_elem_size => {
                     const ty = op.flags.base.ref.typeOf(s);
-                    break :lhs @intCast(s.cg.unalignedSize(ty) + ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu));
+                    break :lhs @intCast(s.cg.unalignedSize(ty) + ty.scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu));
                 },
                 .unaligned_size_sub_elem_size => {
                     const ty = op.flags.base.ref.typeOf(s);
-                    break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu));
+                    break :lhs @intCast(s.cg.unalignedSize(ty) - ty.scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu));
                 },
                 .unaligned_size_sub_2_elem_size => {
                     const ty = op.flags.base.ref.typeOf(s);
-                    break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * 2);
+                    break :lhs @intCast(s.cg.unalignedSize(ty) - ty.scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * 2);
                 },
                 .bit_size => @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s))),
                 .src0_bit_size => @intCast(s.cg.nonBoolScalarBitSize(Select.Operand.Ref.src0.typeOf(s))),
@@ -189944,10 +189939,10 @@ const Select = struct {
                     op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu),
                     @divExact(op.flags.base.size.bitSize(s.cg.target), 8),
                 )),
-                .elem_size => @intCast(op.flags.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
-                .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
-                .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
-                .src0_elem_size_mul_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) *
+                .elem_size => @intCast(op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
+                .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
+                .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
+                .src0_elem_size_mul_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) *
                     Select.Operand.Ref.src1.valueOf(s).immediate),
                 .vector_index => switch (op.flags.base.ref.typeOf(s).ptrInfo(s.cg.pt.zcu).flags.vector_index) {
                     .none => unreachable,
@@ -189956,7 +189951,7 @@ const Select = struct {
                 .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate),
                 .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) -
                     @as(SignedImm, @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))),
-                .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))),
+                .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))),
                 .elem_mask => @as(u8, std.math.maxInt(u8)) >> @intCast(
                     8 - ((s.cg.unalignedSize(op.flags.base.ref.typeOf(s)) - 1) %
                         @divExact(op.flags.base.size.bitSize(s.cg.target), 8) + 1 >>
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 19bbee45b3a12d6883f3e7803475eb960c5a1784..fdd516ff17bc3a2349580cde73a179daa2f51523 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -4575,10 +4575,10 @@ fn updateContainerTypeWriterError(
             const name_strat: Zir.Inst.NameStrategy = switch (decl_inst.tag) {
                 .struct_init, .struct_init_ref, .struct_init_anon => .anon,
                 .extended => switch (decl_inst.data.extended.opcode) {
-                    .struct_decl => @as(Zir.Inst.StructDecl.Small, @bitCast(decl_inst.data.extended.small)).name_strategy,
-                    .enum_decl => @as(Zir.Inst.EnumDecl.Small, @bitCast(decl_inst.data.extended.small)).name_strategy,
-                    .union_decl => @as(Zir.Inst.UnionDecl.Small, @bitCast(decl_inst.data.extended.small)).name_strategy,
-                    .opaque_decl => @as(Zir.Inst.OpaqueDecl.Small, @bitCast(decl_inst.data.extended.small)).name_strategy,
+                    .struct_decl => file.zir.?.getStructDecl(inst_info.inst).name_strategy,
+                    .union_decl => file.zir.?.getUnionDecl(inst_info.inst).name_strategy,
+                    .enum_decl => file.zir.?.getEnumDecl(inst_info.inst).name_strategy,
+                    .opaque_decl => file.zir.?.getOpaqueDecl(inst_info.inst).name_strategy,
 
                     .reify_enum,
                     .reify_struct,
diff --git a/src/mutable_value.zig b/src/mutable_value.zig
index c9eb993944e15366de31846611b76cd070064fe9..97d6f22b3b90e5d9215ec011760ee6feb9c0d3f1 100644
--- a/src/mutable_value.zig
+++ b/src/mutable_value.zig
@@ -18,7 +18,7 @@ pub const MutableValue = union(enum) {
     opt_payload: SubValue,
     /// An aggregate consisting of a single repeated value.
     repeated: SubValue,
-    /// An aggregate of `u8` consisting of "plain" bytes (no lazy or undefined elements).
+    /// An aggregate of `u8` consisting of "plain" bytes (no undefined elements).
     bytes: Bytes,
     /// An aggregate with arbitrary sub-values.
     aggregate: Aggregate,
@@ -415,16 +415,7 @@ pub const MutableValue = union(enum) {
                 } else if (!is_struct and is_trivial_int and Type.fromInterned(a.ty).childType(zcu).toIntern() == .u8_type) {
                     // See if we can switch to `bytes` repr
                     for (a.elems) |e| {
-                        switch (e) {
-                            else => break,
-                            .interned => |ip_index| switch (ip.indexToKey(ip_index)) {
-                                else => break,
-                                .int => |int| switch (int.storage) {
-                                    .u64, .i64, .big_int => {},
-                                    .lazy_align, .lazy_size => break,
-                                },
-                            },
-                        }
+                        if (!e.isTrivialInt(zcu)) break;
                     } else {
                         const bytes = try arena.alloc(u8, a.elems.len);
                         for (a.elems, bytes) |elem_val, *b| {
@@ -494,10 +485,7 @@ pub const MutableValue = union(enum) {
             else => false,
             .interned => |ip_index| switch (zcu.intern_pool.indexToKey(ip_index)) {
                 else => false,
-                .int => |int| switch (int.storage) {
-                    .u64, .i64, .big_int => true,
-                    .lazy_align, .lazy_size => false,
-                },
+                .int => true,
             },
         };
     }
diff --git a/src/print_value.zig b/src/print_value.zig
index 28c25954272bccaa8069ff570043e34625236c6c..e58288a16a999c3ee2c17dbd3b31fd8fec4a59d9 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -81,14 +81,6 @@ pub fn print(
         .int => |int| switch (int.storage) {
             inline .u64, .i64 => |x| try writer.print("{d}", .{x}),
             .big_int => |x| try writer.print("{d}", .{x}),
-            .lazy_align => |ty| if (opt_sema != null) {
-                const a = try Type.fromInterned(ty).abiAlignmentSema(pt);
-                try writer.print("{d}", .{a.toByteUnits() orelse 0});
-            } else try writer.print("@alignOf({f})", .{Type.fromInterned(ty).fmt(pt)}),
-            .lazy_size => |ty| if (opt_sema != null) {
-                const s = try Type.fromInterned(ty).abiSizeSema(pt);
-                try writer.print("{d}", .{s});
-            } else try writer.print("@sizeOf({f})", .{Type.fromInterned(ty).fmt(pt)}),
         },
         .err => |err| try writer.print("error.{f}", .{
             err.name.fmt(ip),
@@ -104,8 +96,8 @@ pub fn print(
         }),
         .enum_tag => |enum_tag| {
             const enum_type = ip.loadEnumType(val.typeOf(zcu).toIntern());
-            if (enum_type.tagValueIndex(ip, val.toIntern())) |tag_index| {
-                return writer.print(".{f}", .{enum_type.names.get(ip)[tag_index].fmt(ip)});
+            if (enum_type.tagValueIndex(ip, enum_tag.int)) |tag_index| {
+                return writer.print(".{f}", .{enum_type.field_names.get(ip)[tag_index].fmt(ip)});
             }
             if (level == 0) {
                 return writer.writeAll("@enumFromInt(...)");
-- 
2.54.0


From 792830d69cd335a49de97b617d3f668aa544b181 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 25 Jan 2026 11:12:26 +0000
Subject: [PATCH 416/499] std: work around language changes

---
 lib/std/elf.zig              |  4 ++--
 lib/std/meta.zig             |  2 +-
 lib/std/multi_array_list.zig | 22 ++++++++++++++--------
 lib/std/os/linux.zig         |  2 +-
 lib/std/testing.zig          |  5 ++---
 lib/std/zon/Serializer.zig   |  4 +++-
 6 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/lib/std/elf.zig b/lib/std/elf.zig
index 962e0ceb9e22f655c9542c94928c98691d63a4fb..b9ddf88123e6a6d6c4aa5b5691e92a0dd6370b3e 100644
--- a/lib/std/elf.zig
+++ b/lib/std/elf.zig
@@ -1071,7 +1071,7 @@ pub const Elf32 = struct {
     pub const Shdr = extern struct {
         name: Word,
         type: SHT,
-        flags: packed struct { shf: SHF },
+        flags: packed struct(Word) { shf: SHF },
         addr: Elf32.Addr,
         offset: Elf32.Off,
         size: Word,
@@ -1161,7 +1161,7 @@ pub const Elf64 = struct {
     pub const Shdr = extern struct {
         name: Word,
         type: SHT,
-        flags: packed struct { shf: SHF, unused: Word = 0 },
+        flags: packed struct(Xword) { shf: SHF, unused: Word = 0 },
         addr: Elf64.Addr,
         offset: Elf64.Off,
         size: Xword,
diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index f1afa9bc7a049c5e4e13546e307b551e93e863c9..6236f1a56bfc9c841044d35362699d555df19cff 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -315,7 +315,7 @@ test declarationInfo {
         try testing.expect(comptime mem.eql(u8, info.name, "a"));
     }
 }
-pub fn fields(comptime T: type) switch (@typeInfo(T)) {
+pub inline fn fields(comptime T: type) switch (@typeInfo(T)) {
     .@"struct" => []const Type.StructField,
     .@"union" => []const Type.UnionField,
     .@"enum" => []const Type.EnumField,
diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig
index 990b85a238ebf056ad7031c92db088ae366c5eb4..92d094f0cc93e96600b03d33f46db1c298c159c1 100644
--- a/lib/std/multi_array_list.zig
+++ b/lib/std/multi_array_list.zig
@@ -19,7 +19,11 @@ const testing = std.testing;
 /// For unions you can call `.items(.tags)` or `.items(.data)`.
 pub fn MultiArrayList(comptime T: type) type {
     return struct {
-        bytes: [*]align(@alignOf(T)) u8 = undefined,
+        /// This pointer is always aligned to the boundary `sizes.big_align`; this is not specified
+        /// in the type to avoid `MultiArrayList(T)` depending on the alignment of `T` because this
+        /// can lead to dependency loops. See `allocatedBytes` which `@alignCast`s this pointer to
+        /// the correct type.
+        bytes: [*]u8 = undefined,
         len: usize = 0,
         capacity: usize = 0,
 
@@ -133,10 +137,8 @@ pub fn MultiArrayList(comptime T: type) type {
                 if (self.ptrs.len == 0 or self.capacity == 0) {
                     return .{};
                 }
-                const unaligned_ptr = self.ptrs[sizes.fields[0]];
-                const aligned_ptr: [*]align(@alignOf(Elem)) u8 = @alignCast(unaligned_ptr);
                 return .{
-                    .bytes = aligned_ptr,
+                    .bytes = self.ptrs[sizes.fields[0]],
                     .len = self.len,
                     .capacity = self.capacity,
                 };
@@ -179,6 +181,7 @@ pub fn MultiArrayList(comptime T: type) type {
         const fields = meta.fields(Elem);
         /// `sizes.bytes` is an array of @sizeOf each T field. Sorted by alignment, descending.
         /// `sizes.fields` is an array mapping from `sizes.bytes` array index to field index.
+        /// `sizes.big_align` is the overall alignment of the allocation, which equals the maximum field alignment.
         const sizes = blk: {
             const Data = struct {
                 size: usize,
@@ -186,12 +189,14 @@ pub fn MultiArrayList(comptime T: type) type {
                 alignment: usize,
             };
             var data: [fields.len]Data = undefined;
+            var big_align: usize = 1;
             for (fields, 0..) |field_info, i| {
                 data[i] = .{
                     .size = @sizeOf(field_info.type),
                     .size_index = i,
                     .alignment = if (@sizeOf(field_info.type) == 0) 1 else field_info.alignment,
                 };
+                big_align = @max(big_align, @alignOf(field_info.type));
             }
             const Sort = struct {
                 fn lessThan(context: void, lhs: Data, rhs: Data) bool {
@@ -210,6 +215,7 @@ pub fn MultiArrayList(comptime T: type) type {
             break :blk .{
                 .bytes = sizes_bytes,
                 .fields = field_indexes,
+                .big_align = mem.Alignment.fromByteUnits(big_align),
             };
         };
 
@@ -452,7 +458,7 @@ pub fn MultiArrayList(comptime T: type) type {
             assert(new_len <= self.capacity);
             assert(new_len <= self.len);
 
-            const other_bytes = gpa.alignedAlloc(u8, .of(Elem), capacityInBytes(new_len)) catch {
+            const other_bytes = gpa.alignedAlloc(u8, sizes.big_align, capacityInBytes(new_len)) catch {
                 const self_slice = self.slice();
                 inline for (fields, 0..) |field_info, i| {
                     if (@sizeOf(field_info.type) != 0) {
@@ -533,7 +539,7 @@ pub fn MultiArrayList(comptime T: type) type {
         /// `new_capacity` must be greater or equal to `len`.
         pub fn setCapacity(self: *Self, gpa: Allocator, new_capacity: usize) Allocator.Error!void {
             assert(new_capacity >= self.len);
-            const new_bytes = try gpa.alignedAlloc(u8, .of(Elem), capacityInBytes(new_capacity));
+            const new_bytes = try gpa.alignedAlloc(u8, sizes.big_align, capacityInBytes(new_capacity));
             if (self.len == 0) {
                 gpa.free(self.allocatedBytes());
                 self.bytes = new_bytes.ptr;
@@ -650,8 +656,8 @@ pub fn MultiArrayList(comptime T: type) type {
             return elem_bytes * capacity;
         }
 
-        fn allocatedBytes(self: Self) []align(@alignOf(Elem)) u8 {
-            return self.bytes[0..capacityInBytes(self.capacity)];
+        fn allocatedBytes(self: Self) []align(sizes.big_align.toByteUnits()) u8 {
+            return @alignCast(self.bytes[0..capacityInBytes(self.capacity)]);
         }
 
         fn FieldType(comptime field: Field) type {
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index cbe085a3af73ded631610881042cf0ed43844767..b884e8ea793d190ad8684824296656cf7ab86171 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -7113,7 +7113,7 @@ pub const io_uring_buf_reg = extern struct {
     flags: Flags,
     resv: [3]u64,
 
-    pub const Flags = packed struct {
+    pub const Flags = packed struct(u16) {
         _0: u1 = 0,
         /// Incremental buffer consumption.
         inc: bool,
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 09919f8b69220c51607e875dee868ea6a048d1a5..bfb50039ea2272242ec911d739b00830bbc4360f 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -950,9 +950,8 @@ test "expectEqualDeep primitive type" {
 }
 
 test "expectEqualDeep pointer" {
-    const a = 1;
-    const b = 1;
-    try expectEqualDeep(&a, &b);
+    try comptime expectEqualDeep(&1, &1);
+    try expectEqualDeep(&@as(u32, 1), &@as(u32, 1));
 }
 
 test "expectEqualDeep composite type" {
diff --git a/lib/std/zon/Serializer.zig b/lib/std/zon/Serializer.zig
index 6f92a64dbdcf6a48867725780692c39b62e9ee21..c30c0e09d8051c0eafab2e8e4ba2a85d46aa1db2 100644
--- a/lib/std/zon/Serializer.zig
+++ b/lib/std/zon/Serializer.zig
@@ -793,9 +793,11 @@ test checkValueDepth {
     try expectValueDepthEquals(2, @as(?u32, 1));
     try expectValueDepthEquals(1, @as(?u32, null));
     try expectValueDepthEquals(1, null);
-    try expectValueDepthEquals(2, &1);
     try expectValueDepthEquals(3, &@as(?u32, 1));
 
+    // The pointer drops the implicit comptime-ness, so we need to specify 'comptime' here
+    try comptime expectValueDepthEquals(2, &1);
+
     const Union = union(enum) {
         x: u32,
         y: struct { x: u32 },
-- 
2.54.0


From 6e49697ef576e86799c8365492082fdee9d216a9 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 22 Jan 2026 16:30:15 +0000
Subject: [PATCH 417/499] backend progress

The x86_64 backend now compiles and, with `-fstrip`, kinda works!
---
 src/InternPool.zig             |  14 +++++
 src/Zcu/PerThread.zig          |   1 +
 src/codegen.zig                |  92 +++++++++++-----------------
 src/codegen/x86_64/CodeGen.zig |  62 ++++++++++---------
 src/codegen/x86_64/abi.zig     |  12 ++--
 src/link/Dwarf.zig             | 108 ++++++++++++++++-----------------
 6 files changed, 144 insertions(+), 145 deletions(-)

diff --git a/src/InternPool.zig b/src/InternPool.zig
index ed4666a5b91a940bab9f91146c2095911c0909ef..28846c3f70ce14a85c09e4ce7d703816f3fe543b 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -4150,6 +4150,13 @@ pub const Index = enum(u32) {
             const extra = ip.getLocalShared(slice.tid).extra.acquire();
             return @ptrCast(extra.view().items(.@"0")[slice.start..][0..slice.len]);
         }
+
+        /// If `slice` is empty (`slice.len == 0`), returns `.none`.
+        /// Otherwise, asserts that `index < slice.len`, and returns the value at `index`.
+        pub fn getOrNone(slice: Slice, ip: *const InternPool, index: usize) Index {
+            if (slice.len == 0) return .none;
+            return slice.get(ip)[index];
+        }
     };
 
     /// Used for a map of `Index` values to the index within a list of `Index` values.
@@ -5981,6 +5988,13 @@ pub const Alignment = enum(u6) {
             const bytes: []u8 = @ptrCast(extra.view().items(.@"0")[slice.start..]);
             return @ptrCast(bytes[0..slice.len]);
         }
+
+        /// If `slice` is empty (`slice.len == 0`), returns `.none`.
+        /// Otherwise, asserts that `index < slice.len`, and returns the value at `index`.
+        pub fn getOrNone(slice: Slice, ip: *const InternPool, index: usize) Alignment {
+            if (slice.len == 0) return .none;
+            return slice.get(ip)[index];
+        }
     };
 
     pub fn toRelaxedCompareUnits(a: Alignment) u8 {
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index f9faef2f7a36f0d77cbf86db7c7e355db8038056..e3c0c21244b2ae29b643bcc20b350796f27e25f8 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -4097,6 +4097,7 @@ pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!
 }
 
 // TODO: this shouldn't need a `PerThread`! Fix the signature of `Type.abiAlignment`.
+// MLUGG TODO: that's done, move it!
 pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPool.Alignment {
     const zcu = pt.zcu;
     const ty: Type, const alignment = switch (zcu.intern_pool.getNav(nav_index).status) {
diff --git a/src/codegen.zig b/src/codegen.zig
index 176649f5b3d90bfca38ab60da0877734440761ee..67575beb3f6f1a5b55a02fe75c0c8b9a576f906f 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -377,7 +377,7 @@ pub fn generateSymbol(
                 .payload => 0,
             };
 
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_ty.hasRuntimeBits(zcu)) {
                 try w.writeInt(u16, err_val, endian);
                 return;
             }
@@ -610,7 +610,7 @@ pub fn generateSymbol(
                     .auto, .@"extern" => {
                         const struct_begin = w.end;
                         const field_types = struct_type.field_types.get(ip);
-                        const offsets = struct_type.offsets.get(ip);
+                        const offsets = struct_type.field_offsets.get(ip);
 
                         var it = struct_type.iterateRuntimeOrder(ip);
                         while (it.next()) |field_index| {
@@ -635,13 +635,11 @@ pub fn generateSymbol(
                             try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), w, reloc_parent);
                         }
 
-                        const size = struct_type.sizeUnordered(ip);
-                        const alignment = struct_type.flagsUnordered(ip).alignment.toByteUnits().?;
+                        assert(struct_type.alignment.check(struct_type.size));
 
-                        const padding = math.cast(
-                            usize,
-                            std.mem.alignForward(u64, size, @max(alignment, 1)) - (w.end - struct_begin),
-                        ) orelse return error.Overflow;
+                        const padding = math.cast(usize, struct_type.size - (w.end - struct_begin)) orelse {
+                            return error.Overflow;
+                        };
                         if (padding > 0) try w.splatByteAll(0, padding);
                     },
                 }
@@ -1060,51 +1058,38 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
 
     switch (ty.zigTypeTag(zcu)) {
         .void => return .none,
+        .bool => return .{ .immediate = @intFromBool(val.toBool()) },
         .pointer => switch (ty.ptrSize(zcu)) {
             .slice => {},
-            else => switch (val.toIntern()) {
-                .null_value => {
-                    return .{ .immediate = 0 };
-                },
-                else => switch (ip.indexToKey(val.toIntern())) {
-                    .int => {
-                        return .{ .immediate = val.toUnsignedInt(zcu) };
-                    },
-                    .ptr => |ptr| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
-                        .nav => |nav| {
-                            if (!ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
-                                const imm: u64 = switch (@divExact(target.ptrBitWidth(), 8)) {
-                                    1 => 0xaa,
-                                    2 => 0xaaaa,
-                                    4 => 0xaaaaaaaa,
-                                    8 => 0xaaaaaaaaaaaaaaaa,
-                                    else => unreachable,
-                                };
-                                return .{ .immediate = imm };
-                            }
+            .one, .many, .c => {
+                const elem_ty = ty.childType(zcu);
+                const ptr = ip.indexToKey(val.toIntern()).ptr;
+                if (ptr.base_addr == .int) return .{ .immediate = ptr.byte_offset };
+                switch (ptr.base_addr) {
+                    .int => unreachable, // handled above
 
-                            if (ty.castPtrToFn(zcu)) |fn_ty| {
-                                if (zcu.typeToFunc(fn_ty).?.is_generic) {
-                                    return .{ .immediate = fn_ty.abiAlignment(zcu).toByteUnits().? };
-                                }
-                            } else if (ty.zigTypeTag(zcu) == .pointer) {
-                                const elem_ty = ty.childType(zcu);
-                                if (!elem_ty.hasRuntimeBits(zcu)) {
-                                    return .{ .immediate = elem_ty.abiAlignment(zcu).toByteUnits().? };
-                                }
-                            }
+                    .nav => |nav| if (elem_ty.isFnOrHasRuntimeBits(zcu)) {
+                        return .{ .lea_nav = nav };
+                    } else {
+                        // Create the 0xaa bit pattern...
+                        const undef_ptr_bits: u64 = @intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() + 1)) / 3);
+                        // ...but align the pointer
+                        const alignment = pt.navAlignment(nav);
+                        return .{ .immediate = alignment.forward(undef_ptr_bits) };
+                    },
 
-                            return .{ .lea_nav = nav };
-                        },
-                        .uav => |uav| if (Value.fromInterned(uav.val).typeOf(zcu).hasRuntimeBits(zcu))
-                            return .{ .lea_uav = uav }
-                        else
-                            return .{ .immediate = Type.fromInterned(uav.orig_ty).ptrAlignment(zcu)
-                                .forward(@intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() | 1)) / 3)) },
-                        else => {},
+                    .uav => |uav| if (elem_ty.isFnOrHasRuntimeBits(zcu)) {
+                        return .{ .lea_uav = uav };
+                    } else {
+                        // Create the 0xaa bit pattern...
+                        const undef_ptr_bits: u64 = @intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() + 1)) / 3);
+                        // ...but align the pointer
+                        const alignment = Type.fromInterned(uav.orig_ty).ptrAlignment(zcu);
+                        return .{ .immediate = alignment.forward(undef_ptr_bits) };
                     },
+
                     else => {},
-                },
+                }
             },
         },
         .int => {
@@ -1117,9 +1102,6 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
                 return .{ .immediate = unsigned };
             }
         },
-        .bool => {
-            return .{ .immediate = @intFromBool(val.toBool()) };
-        },
         .optional => {
             if (ty.isPtrLikeOptional(zcu)) {
                 return lowerValue(
@@ -1147,7 +1129,7 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
         .error_union => {
             const err_type = ty.errorUnionSet(zcu);
             const payload_type = ty.errorUnionPayload(zcu);
-            if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_type.hasRuntimeBits(zcu)) {
                 // We use the error type directly as the type.
                 const err_int_ty = try pt.errorIntType();
                 switch (ip.indexToKey(val.toIntern()).error_union.val) {
@@ -1187,10 +1169,10 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
 }
 
 pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
+    if (!payload_ty.hasRuntimeBits(zcu)) return 0;
     const payload_align = payload_ty.abiAlignment(zcu);
     const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBits(zcu)) {
         return 0;
     } else {
         return payload_align.forward(Type.anyerror.abiSize(zcu));
@@ -1198,10 +1180,10 @@ pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
 }
 
 pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
+    if (!payload_ty.hasRuntimeBits(zcu)) return 0;
     const payload_align = payload_ty.abiAlignment(zcu);
     const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBits(zcu)) {
         return error_align.forward(payload_ty.abiSize(zcu));
     } else {
         return 0;
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 58987558d218402d252b81ff51901b85bcd74f78..872404b71572de6124f68ed84dfbca6b5122152f 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -43261,7 +43261,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
-                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().childType(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
+                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().childType(zcu).hasRuntimeBits(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .simm32, .none } },
                     },
@@ -43375,7 +43375,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
-                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().childType(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
+                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().childType(zcu).hasRuntimeBits(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .simm32, .none } },
                     },
@@ -103699,7 +103699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .optional_payload => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
-                const pl = if (!hack_around_sema_opv_bugs or ty_op.ty.toType().hasRuntimeBitsIgnoreComptime(zcu))
+                const pl = if (!hack_around_sema_opv_bugs or ty_op.ty.toType().hasRuntimeBits(zcu))
                     try ops[0].read(ty_op.ty.toType(), .{}, cg)
                 else
                     try cg.tempInit(ty_op.ty.toType(), .none);
@@ -103745,7 +103745,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const eu_pl_ty = ty_op.ty.toType();
                 const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu));
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
-                const pl = if (!hack_around_sema_opv_bugs or eu_pl_ty.hasRuntimeBitsIgnoreComptime(zcu))
+                const pl = if (!hack_around_sema_opv_bugs or eu_pl_ty.hasRuntimeBits(zcu))
                     try ops[0].read(eu_pl_ty, .{ .disp = eu_pl_off }, cg)
                 else
                     try cg.tempInit(eu_pl_ty, .none);
@@ -103864,7 +103864,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .@"packed" => unreachable,
                 };
                 var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand});
-                var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBitsIgnoreComptime(zcu))
+                var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBits(zcu))
                     try ops[0].read(field_ty, .{ .disp = field_off }, cg)
                 else
                     try cg.tempInit(field_ty, .none);
@@ -104125,7 +104125,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
-                if (!hack_around_sema_opv_bugs or res_ty.hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{
+                if (!hack_around_sema_opv_bugs or res_ty.hasRuntimeBits(zcu)) cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{
                     .dst_constraints = .{ .{ .int = .byte }, .any },
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .simm32, .none } },
@@ -171422,10 +171422,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .auto, .@"extern" => {
                                 for (elems, 0..) |elem_ref, field_index| {
                                     const elem_dies = bt.feed();
-                                    if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
-                                    if (!hack_around_sema_opv_bugs or Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]).hasRuntimeBitsIgnoreComptime(zcu)) {
+                                    if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
+                                    if (!hack_around_sema_opv_bugs or Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]).hasRuntimeBits(zcu)) {
                                         var elem = try cg.tempFromOperand(elem_ref, elem_dies);
-                                        try res.write(&elem, .{ .disp = @intCast(loaded_struct.offsets.get(ip)[field_index]) }, cg);
+                                        try res.write(&elem, .{ .disp = @intCast(loaded_struct.field_offsets.get(ip)[field_index]) }, cg);
                                         try elem.die(cg);
                                         try cg.resetTemps(reset_index);
                                     }
@@ -171441,7 +171441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             const elem_dies = bt.feed();
                             if (tuple_type.values.get(ip)[field_index] != .none) continue;
                             const field_type = Type.fromInterned(tuple_type.types.get(ip)[field_index]);
-                            if (!hack_around_sema_opv_bugs or field_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+                            if (!hack_around_sema_opv_bugs or field_type.hasRuntimeBits(zcu)) {
                                 elem_disp = @intCast(field_type.abiAlignment(zcu).forward(elem_disp));
                                 var elem = try cg.tempFromOperand(elem_ref, elem_dies);
                                 try res.write(&elem, .{ .disp = elem_disp }, cg);
@@ -173756,7 +173756,7 @@ fn genLazy(cg: *CodeGen, lazy_sym: link.File.LazySymbol) InnerError!void {
 
             var data_off: i32 = 0;
             const reset_index = cg.next_temp_index;
-            const tag_names = ip.loadEnumType(lazy_sym.ty).names;
+            const tag_names = ip.loadEnumType(lazy_sym.ty).field_names;
             for (0..tag_names.len) |tag_index| {
                 var enum_temp = try cg.tempInit(enum_ty, if (enum_ty.abiSize(zcu) <= @as(u4, switch (cg.target.cpu.arch) {
                     else => unreachable,
@@ -174334,7 +174334,7 @@ fn genUnwrapErrUnionPayloadMir(
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
 
     const result: MCValue = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
+        if (!payload_ty.hasRuntimeBits(zcu)) break :result .none;
 
         const payload_off: u31 = @intCast(codegen.errUnionPayloadOffset(payload_ty, zcu));
         switch (err_union) {
@@ -174450,7 +174450,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE
     const pt = self.pt;
     const zcu = pt.zcu;
     const dst_ty = ptr_ty.childType(zcu);
-    if (!dst_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
+    if (!dst_ty.hasRuntimeBits(zcu)) return;
     switch (ptr_mcv) {
         .none,
         .unreach,
@@ -174503,7 +174503,7 @@ fn store(
     const pt = self.pt;
     const zcu = pt.zcu;
     const src_ty = ptr_ty.childType(zcu);
-    if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
+    if (!src_ty.hasRuntimeBits(zcu)) return;
     switch (ptr_mcv) {
         .none,
         .unreach,
@@ -176615,7 +176615,7 @@ fn lowerSwitchBr(
             break :condition_index condition_index;
         };
         try cg.spillEflagsIfOccupied();
-        if (min.?.orderAgainstZero(zcu).compare(.neq)) try cg.genBinOpMir(
+        if (Value.compareHetero(min.?, .neq, .zero_comptime_int, zcu)) try cg.genBinOpMir(
             .{ ._, .sub },
             condition_ty,
             condition_index,
@@ -176957,7 +176957,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void {
         const unsigned_condition_ty = try self.pt.intType(.unsigned, self.intInfo(condition_ty).?.bits);
         const condition_mcv = block_tracking.short;
         try self.spillEflagsIfOccupied();
-        if (table.min.orderAgainstZero(self.pt.zcu).compare(.neq)) try self.genBinOpMir(
+        if (Value.compareHetero(table.min, .neq, .zero_comptime_int, self.pt.zcu)) try self.genBinOpMir(
             .{ ._, .sub },
             condition_ty,
             condition_mcv,
@@ -177054,8 +177054,7 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
 
     const block_ty = self.typeOfIndex(br.block_inst);
-    const block_unused =
-        !block_ty.hasRuntimeBitsIgnoreComptime(zcu) or self.liveness.isUnused(br.block_inst);
+    const block_unused = !block_ty.hasRuntimeBits(zcu) or self.liveness.isUnused(br.block_inst);
     const block_tracking = self.inst_tracking.getPtr(br.block_inst).?;
     const block_data = self.blocks.getPtr(br.block_inst).?;
     const first_br = block_data.relocs.items.len == 0;
@@ -180986,7 +180985,7 @@ fn resolveInst(self: *CodeGen, ref: Air.Inst.Ref) InnerError!MCValue {
     const ty = self.typeOf(ref);
 
     // If the type has no codegen bits, no need to store it.
-    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
+    if (!ty.hasRuntimeBits(zcu)) return .none;
 
     const mcv: MCValue = if (ref.toIndex()) |inst| mcv: {
         break :mcv self.inst_tracking.getPtr(inst).?.short;
@@ -181105,7 +181104,7 @@ fn resolveCallingConventionValues(
             // Return values
             if (ret_ty.isNoReturn(zcu)) {
                 result.return_value = .init(.unreach);
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            } else if (!ret_ty.hasRuntimeBits(zcu)) {
                 // TODO: is this even possible for C calling convention?
                 result.return_value = .init(.none);
             } else {
@@ -181182,7 +181181,7 @@ fn resolveCallingConventionValues(
 
             // Input params
             params: for (param_types, result.args) |ty, *arg| {
-                assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+                assert(ty.hasRuntimeBits(zcu));
                 result.air_arg_count += 1;
                 switch (cc) {
                     .x86_64_sysv => {},
@@ -181327,7 +181326,7 @@ fn resolveCallingConventionValues(
             // Return values
             result.return_value = if (ret_ty.isNoReturn(zcu))
                 .init(.unreach)
-            else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu))
+            else if (!ret_ty.hasRuntimeBits(zcu))
                 .init(.none)
             else return_value: {
                 const ret_gpr = abi.getCAbiIntReturnRegs(cc);
@@ -181357,7 +181356,7 @@ fn resolveCallingConventionValues(
 
             // Input params
             for (param_types, result.args) |param_ty, *arg| {
-                if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                if (!param_ty.hasRuntimeBits(zcu)) {
                     arg.* = .none;
                     continue;
                 }
@@ -181721,7 +181720,7 @@ fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
             .one, .many, .c => .{ .signedness = .unsigned, .bits = cg.target.ptrBitWidth() },
             .slice => null,
         },
-        .opt_type => |opt_child| return if (!Type.fromInterned(opt_child).hasRuntimeBitsIgnoreComptime(zcu))
+        .opt_type => |opt_child| return if (!Type.fromInterned(opt_child).hasRuntimeBits(zcu))
             .{ .signedness = .unsigned, .bits = 1 }
         else switch (ip.indexToKey(opt_child)) {
             .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
@@ -181734,7 +181733,7 @@ fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
             else => null,
         },
         .error_union_type => |error_union_type| return if (!Type.fromInterned(error_union_type.payload_type)
-            .hasRuntimeBitsIgnoreComptime(zcu)) .{ .signedness = .unsigned, .bits = zcu.errorSetBits() } else null,
+            .hasRuntimeBits(zcu)) .{ .signedness = .unsigned, .bits = zcu.errorSetBits() } else null,
         .simple_type => |simple_type| return switch (simple_type) {
             .bool => .{ .signedness = .unsigned, .bits = 1 },
             .anyerror => .{ .signedness = .unsigned, .bits = zcu.errorSetBits() },
@@ -181767,14 +181766,17 @@ fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
             const loaded_struct = ip.loadStructType(ty_index);
             switch (loaded_struct.layout) {
                 .auto, .@"extern" => return null,
-                .@"packed" => ty_index = loaded_struct.backingIntTypeUnordered(ip),
+                .@"packed" => ty_index = loaded_struct.packed_backing_int_type,
             }
         },
-        .union_type => return switch (ip.loadUnionType(ty_index).flagsUnordered(ip).layout) {
-            .auto, .@"extern" => null,
-            .@"packed" => .{ .signedness = .unsigned, .bits = @intCast(ty.bitSize(zcu)) },
+        .union_type => {
+            const loaded_union = ip.loadUnionType(ty_index);
+            switch (loaded_union.layout) {
+                .auto, .@"extern" => return null,
+                .@"packed" => ty_index = loaded_union.packed_backing_int_type,
+            }
         },
-        .enum_type => ty_index = ip.loadEnumType(ty_index).tag_ty,
+        .enum_type => ty_index = ip.loadEnumType(ty_index).int_tag_type,
         .error_set_type, .inferred_error_set_type => return .{ .signedness = .unsigned, .bits = zcu.errorSetBits() },
         else => return null,
     };
diff --git a/src/codegen/x86_64/abi.zig b/src/codegen/x86_64/abi.zig
index 2a296dc9304266d85d8fd8618c88b8c20c4c4f33..e0838d23264a61048e55ad2567a590075044284b 100644
--- a/src/codegen/x86_64/abi.zig
+++ b/src/codegen/x86_64/abi.zig
@@ -339,7 +339,7 @@ fn classifySystemVStruct(
     var field_it = loaded_struct.iterateRuntimeOrder(ip);
     while (field_it.next()) |field_index| {
         const field_ty = Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-        const field_align = loaded_struct.fieldAlign(ip, field_index);
+        const field_align = loaded_struct.field_aligns.getOrNone(ip, field_index);
         byte_offset = std.mem.alignForward(
             u64,
             byte_offset,
@@ -355,7 +355,7 @@ fn classifySystemVStruct(
                 .@"packed" => {},
             }
         } else if (zcu.typeToUnion(field_ty)) |field_loaded_union| {
-            switch (field_loaded_union.flagsUnordered(ip).layout) {
+            switch (field_loaded_union.layout) {
                 .auto => unreachable,
                 .@"extern" => {
                     byte_offset = classifySystemVUnion(result, byte_offset, field_loaded_union, zcu, target);
@@ -369,11 +369,11 @@ fn classifySystemVStruct(
             result_class.* = result_class.combineSystemV(field_class);
         byte_offset += field_ty.abiSize(zcu);
     }
-    const final_byte_offset = starting_byte_offset + loaded_struct.sizeUnordered(ip);
+    const final_byte_offset = starting_byte_offset + loaded_struct.size;
     std.debug.assert(final_byte_offset == std.mem.alignForward(
         u64,
         byte_offset,
-        loaded_struct.flagsUnordered(ip).alignment.toByteUnits().?,
+        loaded_struct.alignment.toByteUnits().?,
     ));
     return final_byte_offset;
 }
@@ -398,7 +398,7 @@ fn classifySystemVUnion(
                 .@"packed" => {},
             }
         } else if (zcu.typeToUnion(field_ty)) |field_loaded_union| {
-            switch (field_loaded_union.flagsUnordered(ip).layout) {
+            switch (field_loaded_union.layout) {
                 .auto => unreachable,
                 .@"extern" => {
                     _ = classifySystemVUnion(result, starting_byte_offset, field_loaded_union, zcu, target);
@@ -411,7 +411,7 @@ fn classifySystemVUnion(
         for (result[@intCast(starting_byte_offset / 8)..][0..field_classes.len], field_classes) |*result_class, field_class|
             result_class.* = result_class.combineSystemV(field_class);
     }
-    return starting_byte_offset + loaded_union.sizeUnordered(ip);
+    return starting_byte_offset + loaded_union.size;
 }
 
 pub const zigcc = struct {
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index fdd516ff17bc3a2349580cde73a179daa2f51523..f77518d4655514850cdaab6dfc3cde9ee76a7d4a 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -2243,8 +2243,8 @@ pub const WipNav = struct {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         var big_int_space: Value.BigIntSpace = undefined;
-        try wip_nav.bigIntConstValue(abbrev_code, .fromInterned(loaded_enum.tag_ty), if (loaded_enum.values.len > 0)
-            Value.fromInterned(loaded_enum.values.get(ip)[field_index]).toBigInt(&big_int_space, zcu)
+        try wip_nav.bigIntConstValue(abbrev_code, .fromInterned(loaded_enum.int_tag_type), if (loaded_enum.field_values.len > 0)
+            Value.fromInterned(loaded_enum.field_values.get(ip)[field_index]).toBigInt(&big_int_space, zcu)
         else
             std.math.big.int.Mutable.init(&big_int_space.limbs, field_index).toConst());
     }
@@ -3164,8 +3164,8 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                         try diw.writeUleb128(nav_val.toType().abiSize(zcu));
                         try diw.writeUleb128(nav_val.toType().abiAlignment(zcu).toByteUnits().?);
                         for (0..loaded_struct.field_types.len) |field_index| {
-                            const is_comptime = loaded_struct.fieldIsComptime(ip, field_index);
-                            const field_init = loaded_struct.fieldInit(ip, field_index);
+                            const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
+                            const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
                             assert(!(is_comptime and field_init == .none));
                             const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                             const has_runtime_bits, const has_comptime_state = switch (field_init) {
@@ -3191,11 +3191,11 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                                     .struct_field
                             else
                                 .struct_field);
-                            try wip_nav.strp(loaded_struct.fieldName(ip, field_index).toSlice(ip));
+                            try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
                             try wip_nav.refType(field_type);
                             if (!is_comptime) {
-                                try diw.writeUleb128(loaded_struct.offsets.get(ip)[field_index]);
-                                try diw.writeUleb128(loaded_struct.fieldAlign(ip, field_index).toByteUnits() orelse
+                                try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
+                                try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                                     field_type.abiAlignment(zcu).toByteUnits().?);
                             }
                             if (has_comptime_state)
@@ -3212,11 +3212,11 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                         .generic_decl = .generic_decl_const,
                         .decl_instance = .decl_instance_packed_struct,
                     }, &nav, inst_info.file, &decl);
-                    try wip_nav.refType(.fromInterned(loaded_struct.backingIntTypeUnordered(ip)));
+                    try wip_nav.refType(.fromInterned(loaded_struct.packed_backing_int_type));
                     var field_bit_offset: u16 = 0;
                     for (0..loaded_struct.field_types.len) |field_index| {
                         try wip_nav.abbrevCode(.packed_struct_field);
-                        try wip_nav.strp(loaded_struct.fieldName(ip, field_index).toSlice(ip));
+                        try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
                         const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                         try wip_nav.refType(field_type);
                         try diw.writeUleb128(field_bit_offset);
@@ -3246,7 +3246,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             }
             wip_nav.entry = nav_gop.value_ptr.*;
             const diw = &wip_nav.debug_info.writer;
-            try wip_nav.declCommon(if (loaded_enum.names.len > 0) .{
+            try wip_nav.declCommon(if (loaded_enum.field_names.len > 0) .{
                 .decl = .decl_enum,
                 .generic_decl = .generic_decl_const,
                 .decl_instance = .decl_instance_enum,
@@ -3255,16 +3255,16 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                 .generic_decl = .generic_decl_const,
                 .decl_instance = .decl_instance_empty_enum,
             }, &nav, inst_info.file, &decl);
-            try wip_nav.refType(.fromInterned(loaded_enum.tag_ty));
-            for (0..loaded_enum.names.len) |field_index| {
+            try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
+            for (0..loaded_enum.field_names.len) |field_index| {
                 try wip_nav.enumConstValue(loaded_enum, .{
                     .sdata = .signed_enum_field,
                     .udata = .unsigned_enum_field,
                     .block = .big_enum_field,
                 }, field_index);
-                try wip_nav.strp(loaded_enum.names.get(ip)[field_index].toSlice(ip));
+                try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
             }
-            if (loaded_enum.names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+            if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
             break :tag .done;
         },
         .union_type => tag: {
@@ -3293,8 +3293,8 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             const union_layout = Type.getUnionLayout(loaded_union, zcu);
             try diw.writeUleb128(union_layout.abi_size);
             try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
-            const loaded_tag = loaded_union.loadTagType(ip);
-            if (loaded_union.hasTag(ip)) {
+            const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
+            if (loaded_union.runtime_tag != .none) {
                 try wip_nav.abbrevCode(.tagged_union);
                 try wip_nav.infoSectionOffset(
                     .debug_info,
@@ -3305,7 +3305,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                 {
                     try wip_nav.abbrevCode(.generated_field);
                     try wip_nav.strp("tag");
-                    try wip_nav.refType(.fromInterned(loaded_union.enum_tag_ty));
+                    try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
                     try diw.writeUleb128(union_layout.tagOffset());
 
                     for (0..loaded_union.field_types.len) |field_index| {
@@ -3316,11 +3316,11 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                         }, field_index);
                         {
                             try wip_nav.abbrevCode(.struct_field);
-                            try wip_nav.strp(loaded_tag.names.get(ip)[field_index].toSlice(ip));
+                            try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
                             const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
                             try wip_nav.refType(field_type);
                             try diw.writeUleb128(union_layout.payloadOffset());
-                            try diw.writeUleb128(loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse
+                            try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                                 if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
                         }
                         try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
@@ -3329,10 +3329,10 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                 try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
             } else for (0..loaded_union.field_types.len) |field_index| {
                 try wip_nav.abbrevCode(.untagged_union_field);
-                try wip_nav.strp(loaded_tag.names.get(ip)[field_index].toSlice(ip));
+                try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
                 const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
                 try wip_nav.refType(field_type);
-                try diw.writeUleb128(loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse
+                try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                     if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
             }
             try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
@@ -3877,18 +3877,18 @@ fn updateLazyType(
         },
         .enum_type => {
             const loaded_enum = ip.loadEnumType(type_index);
-            try wip_nav.abbrevCode(if (loaded_enum.names.len == 0) .generated_empty_enum_type else .generated_enum_type);
+            try wip_nav.abbrevCode(if (loaded_enum.field_names.len == 0) .generated_empty_enum_type else .generated_enum_type);
             try wip_nav.strp(name);
-            try wip_nav.refType(.fromInterned(loaded_enum.tag_ty));
-            for (0..loaded_enum.names.len) |field_index| {
+            try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
+            for (0..loaded_enum.field_names.len) |field_index| {
                 try wip_nav.enumConstValue(loaded_enum, .{
                     .sdata = .signed_enum_field,
                     .udata = .unsigned_enum_field,
                     .block = .big_enum_field,
                 }, field_index);
-                try wip_nav.strp(loaded_enum.names.get(ip)[field_index].toSlice(ip));
+                try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
             }
-            if (loaded_enum.names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+            if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
         },
         .func_type => |func_type| {
             const is_nullary = func_type.param_types.len == 0 and !func_type.is_var_args;
@@ -4349,7 +4349,7 @@ fn updateLazyValue(
                     const loaded_struct_type = ip.loadStructType(aggregate.ty);
                     assert(loaded_struct_type.layout == .auto);
                     for (0..loaded_struct_type.field_types.len) |field_index| {
-                        if (loaded_struct_type.fieldIsComptime(ip, field_index)) continue;
+                        if (loaded_struct_type.field_is_comptime_bits.get(ip, field_index)) continue;
                         const field_type: Type = .fromInterned(loaded_struct_type.field_types.get(ip)[field_index]);
                         const has_runtime_bits = field_type.hasRuntimeBits(zcu);
                         const has_comptime_state = field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null;
@@ -4359,7 +4359,7 @@ fn updateLazyValue(
                             .comptime_value_field_runtime_bits
                         else
                             continue);
-                        try wip_nav.strp(loaded_struct_type.fieldName(ip, field_index).toSlice(ip));
+                        try wip_nav.strp(loaded_struct_type.field_names.get(ip)[field_index].toSlice(ip));
                         const field_value: Value = .fromInterned(switch (aggregate.storage) {
                             .bytes => unreachable,
                             .elems => |elems| elems[field_index],
@@ -4427,10 +4427,10 @@ fn updateLazyValue(
             try wip_nav.refType(.fromInterned(un.ty));
             field: {
                 const loaded_union_type = ip.loadUnionType(un.ty);
-                assert(loaded_union_type.flagsUnordered(ip).layout == .auto);
+                assert(loaded_union_type.layout == .auto);
                 const field_index = zcu.unionTagFieldIndex(loaded_union_type, Value.fromInterned(un.tag)).?;
                 const field_ty: Type = .fromInterned(loaded_union_type.field_types.get(ip)[field_index]);
-                const field_name = loaded_union_type.loadTagType(ip).names.get(ip)[field_index];
+                const field_name = ip.loadEnumType(loaded_union_type.enum_tag_type).field_names.get(ip)[field_index];
                 const has_runtime_bits = field_ty.hasRuntimeBits(zcu);
                 const has_comptime_state = field_ty.comptimeOnly(zcu) and try field_ty.onePossibleValue(pt) == null;
                 try wip_nav.abbrevCode(if (has_comptime_state)
@@ -4521,8 +4521,8 @@ fn updateContainerTypeWriterError(
             try diw.writeUleb128(ty.abiSize(zcu));
             try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
             for (0..loaded_struct.field_types.len) |field_index| {
-                const is_comptime = loaded_struct.fieldIsComptime(ip, field_index);
-                const field_init = loaded_struct.fieldInit(ip, field_index);
+                const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
+                const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
                 assert(!(is_comptime and field_init == .none));
                 const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                 const has_runtime_bits, const has_comptime_state = switch (field_init) {
@@ -4548,11 +4548,11 @@ fn updateContainerTypeWriterError(
                         .struct_field
                 else
                     .struct_field);
-                try wip_nav.strp(loaded_struct.fieldName(ip, field_index).toSlice(ip));
+                try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
                 try wip_nav.refType(field_type);
                 if (!is_comptime) {
-                    try diw.writeUleb128(loaded_struct.offsets.get(ip)[field_index]);
-                    try diw.writeUleb128(loaded_struct.fieldAlign(ip, field_index).toByteUnits() orelse
+                    try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
+                    try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                         field_type.abiAlignment(zcu).toByteUnits().?);
                 }
                 if (has_comptime_state)
@@ -4628,8 +4628,8 @@ fn updateContainerTypeWriterError(
                             try diw.writeUleb128(ty.abiSize(zcu));
                             try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
                             for (0..loaded_struct.field_types.len) |field_index| {
-                                const is_comptime = loaded_struct.fieldIsComptime(ip, field_index);
-                                const field_init = loaded_struct.fieldInit(ip, field_index);
+                                const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
+                                const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
                                 assert(!(is_comptime and field_init == .none));
                                 const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                                 const has_runtime_bits, const has_comptime_state = switch (field_init) {
@@ -4655,11 +4655,11 @@ fn updateContainerTypeWriterError(
                                         .struct_field
                                 else
                                     .struct_field);
-                                try wip_nav.strp(loaded_struct.fieldName(ip, field_index).toSlice(ip));
+                                try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
                                 try wip_nav.refType(field_type);
                                 if (!is_comptime) {
-                                    try diw.writeUleb128(loaded_struct.offsets.get(ip)[field_index]);
-                                    try diw.writeUleb128(loaded_struct.fieldAlign(ip, field_index).toByteUnits() orelse
+                                    try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
+                                    try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                                         field_type.abiAlignment(zcu).toByteUnits().?);
                                 }
                                 if (has_comptime_state)
@@ -4674,11 +4674,11 @@ fn updateContainerTypeWriterError(
                         try wip_nav.abbrevCode(if (loaded_struct.field_types.len > 0) .packed_struct_type else .empty_packed_struct_type);
                         try diw.writeUleb128(file_gop.index);
                         try wip_nav.strp(name);
-                        try wip_nav.refType(.fromInterned(loaded_struct.backingIntTypeUnordered(ip)));
+                        try wip_nav.refType(.fromInterned(loaded_struct.packed_backing_int_type));
                         var field_bit_offset: u16 = 0;
                         for (0..loaded_struct.field_types.len) |field_index| {
                             try wip_nav.abbrevCode(.packed_struct_field);
-                            try wip_nav.strp(loaded_struct.fieldName(ip, field_index).toSlice(ip));
+                            try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
                             const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                             try wip_nav.refType(field_type);
                             try diw.writeUleb128(field_bit_offset);
@@ -4690,19 +4690,19 @@ fn updateContainerTypeWriterError(
             },
             .enum_type => {
                 const loaded_enum = ip.loadEnumType(type_index);
-                try wip_nav.abbrevCode(if (loaded_enum.names.len > 0) .enum_type else .empty_enum_type);
+                try wip_nav.abbrevCode(if (loaded_enum.field_names.len > 0) .enum_type else .empty_enum_type);
                 try diw.writeUleb128(file_gop.index);
                 try wip_nav.strp(name);
-                try wip_nav.refType(.fromInterned(loaded_enum.tag_ty));
-                for (0..loaded_enum.names.len) |field_index| {
+                try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
+                for (0..loaded_enum.field_names.len) |field_index| {
                     try wip_nav.enumConstValue(loaded_enum, .{
                         .sdata = .signed_enum_field,
                         .udata = .unsigned_enum_field,
                         .block = .big_enum_field,
                     }, field_index);
-                    try wip_nav.strp(loaded_enum.names.get(ip)[field_index].toSlice(ip));
+                    try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
                 }
-                if (loaded_enum.names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
             },
             .union_type => {
                 const loaded_union = ip.loadUnionType(type_index);
@@ -4712,8 +4712,8 @@ fn updateContainerTypeWriterError(
                 const union_layout = Type.getUnionLayout(loaded_union, zcu);
                 try diw.writeUleb128(union_layout.abi_size);
                 try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
-                const loaded_tag = loaded_union.loadTagType(ip);
-                if (loaded_union.hasTag(ip)) {
+                const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
+                if (loaded_union.runtime_tag != .none) {
                     try wip_nav.abbrevCode(.tagged_union);
                     try wip_nav.infoSectionOffset(
                         .debug_info,
@@ -4724,7 +4724,7 @@ fn updateContainerTypeWriterError(
                     {
                         try wip_nav.abbrevCode(.generated_field);
                         try wip_nav.strp("tag");
-                        try wip_nav.refType(.fromInterned(loaded_union.enum_tag_ty));
+                        try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
                         try diw.writeUleb128(union_layout.tagOffset());
 
                         for (0..loaded_union.field_types.len) |field_index| {
@@ -4735,11 +4735,11 @@ fn updateContainerTypeWriterError(
                             }, field_index);
                             {
                                 try wip_nav.abbrevCode(.struct_field);
-                                try wip_nav.strp(loaded_tag.names.get(ip)[field_index].toSlice(ip));
+                                try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
                                 const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
                                 try wip_nav.refType(field_type);
                                 try diw.writeUleb128(union_layout.payloadOffset());
-                                try diw.writeUleb128(loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse
+                                try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                                     if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
                             }
                             try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
@@ -4748,10 +4748,10 @@ fn updateContainerTypeWriterError(
                     try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
                 } else for (0..loaded_union.field_types.len) |field_index| {
                     try wip_nav.abbrevCode(.untagged_union_field);
-                    try wip_nav.strp(loaded_tag.names.get(ip)[field_index].toSlice(ip));
+                    try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
                     const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
                     try wip_nav.refType(field_type);
-                    try diw.writeUleb128(loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse
+                    try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
                         if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
                 }
                 if (loaded_union.field_types.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-- 
2.54.0


From 3086c7977bee8cfe41c385d3ba389971b9a28380 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 23 Jan 2026 09:59:32 +0000
Subject: [PATCH 418/499] type resolution progress

---
 lib/std/zig.zig                 |    9 +
 lib/std/zig/AstGen.zig          |  123 +-
 lib/std/zig/Zir.zig             |   78 +-
 src/Compilation.zig             |   12 +-
 src/IncrementalDebugServer.zig  |    6 +-
 src/InternPool.zig              | 1298 +++++++++++------
 src/Sema.zig                    | 2343 ++++++++++---------------------
 src/Sema/LowerZon.zig           |    2 +-
 src/Sema/type_resolution.zig    | 1185 ++++++++++------
 src/Type.zig                    |  377 +++--
 src/Value.zig                   |   61 +-
 src/Zcu.zig                     |  234 ++-
 src/Zcu/PerThread.zig           |  155 +-
 src/codegen.zig                 |   11 +-
 src/codegen/aarch64/Select.zig  |   14 +-
 src/codegen/c.zig               |   17 +-
 src/codegen/llvm.zig            |   15 +-
 src/codegen/riscv64/CodeGen.zig |    4 +-
 src/codegen/spirv/CodeGen.zig   |   13 +-
 src/codegen/wasm/CodeGen.zig    |    3 +-
 src/codegen/x86_64/CodeGen.zig  |   14 +-
 src/link/Coff.zig               |    2 +-
 src/link/Elf/ZigObject.zig      |    2 +-
 src/link/Elf2.zig               |    2 +-
 src/link/MachO/ZigObject.zig    |    8 +-
 src/print_value.zig             |   38 +-
 src/print_zir.zig               |   26 +-
 27 files changed, 3064 insertions(+), 2988 deletions(-)

diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index ba799c650e74229e4f3812fe67742bc0550b8925..26abf81a11a6b3707b84bd86f2b1a33a4b6b92b9 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -837,6 +837,10 @@ pub const SimpleComptimeReason = enum(u32) {
     tuple_field_types,
     enum_field_names,
     enum_field_values,
+    union_enum_tag_type,
+    enum_int_tag_type,
+    packed_struct_backing_int_type,
+    packed_union_backing_int_type,
 
     // Evaluating at comptime because decl/field name must be comptime-known.
     decl_name,
@@ -925,6 +929,11 @@ pub const SimpleComptimeReason = enum(u32) {
             .enum_field_names    => "enum field names must be comptime-known",
             .enum_field_values   => "enum field values must be comptime-known",
 
+            .union_enum_tag_type            => "enum tag type of union must be comptime-known",
+            .enum_int_tag_type              => "integer tag type of enum must be comptime-known",
+            .packed_struct_backing_int_type => "packed struct backing integer type must be comptime-known",
+            .packed_union_backing_int_type  => "packed struct backing integer type must be comptime-known",
+
             .decl_name         => "declaration name must be comptime-known",
             .field_name        => "field name must be comptime-known",
             .tuple_field_index => "tuple field index must be comptime-known",
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 6a6585192ddb7efd7dc1b6455ce28cdf27425530..046330c46bedffaa8d16036ccb041264373c34b7 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -4922,24 +4922,14 @@ fn structDeclInner(
 
     astgen.advanceSourceCursorToNode(node);
 
-    const backing_int_type_ref: Zir.Inst.Ref = ty: {
-        const backing_int_node = maybe_backing_int_node.unwrap() orelse break :ty .none;
-        if (layout != .@"packed") return astgen.failNode(
-            backing_int_node,
-            "non-packed struct does not support backing integer type",
-            .{},
-        );
-        break :ty try typeExpr(gz, scope, backing_int_node);
-    };
-
     const decl_inst = try gz.reserveInstructionIndex();
 
-    if (container_decl.ast.members.len == 0 and backing_int_type_ref == .none) {
+    if (container_decl.ast.members.len == 0 and maybe_backing_int_node == .none) {
         try gz.setStruct(decl_inst, .{
             .src_node = node,
             .name_strat = name_strat,
             .layout = layout,
-            .backing_int_type = .none,
+            .backing_int_type_body_len = null,
             .decls_len = 0,
             .fields_len = 0,
             .any_field_aligns = false,
@@ -4993,6 +4983,22 @@ fn structDeclInner(
     );
     if (field_comptime_bits) |bits| @memset(bits.get(astgen), 0);
 
+    // Before any field bodies comes the backing int type, if specified.
+    const backing_int_type_body_len: ?u32 = if (maybe_backing_int_node.unwrap()) |backing_int_node| len: {
+        if (layout != .@"packed") return astgen.failNode(
+            backing_int_node,
+            "non-packed struct does not support backing integer type",
+            .{},
+        );
+        const type_ref = try typeExpr(&block_scope, &namespace.base, backing_int_node);
+        if (!block_scope.endsWithNoReturn()) {
+            _ = try block_scope.addBreak(.break_inline, decl_inst, type_ref);
+        }
+        const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+        block_scope.instructions.items.len = block_scope.instructions_top;
+        break :len body_len;
+    } else null;
+
     const old_hasher = astgen.src_hasher;
     defer astgen.src_hasher = old_hasher;
     astgen.src_hasher = .init(.{});
@@ -5076,7 +5082,7 @@ fn structDeclInner(
         .src_node = node,
         .name_strat = name_strat,
         .layout = layout,
-        .backing_int_type = backing_int_type_ref,
+        .backing_int_type_body_len = backing_int_type_body_len,
         .decls_len = scan_result.decls_len,
         .fields_len = scan_result.fields_len,
         .any_field_aligns = scan_result.any_field_aligns,
@@ -5220,11 +5226,6 @@ fn unionDeclInner(
 
     astgen.advanceSourceCursorToNode(node);
 
-    const arg_type_ref: Zir.Inst.Ref = ref: {
-        const arg_node = opt_arg_node.unwrap() orelse break :ref .none;
-        break :ref try typeExpr(gz, scope, arg_node);
-    };
-
     const decl_inst = try gz.reserveInstructionIndex();
 
     var namespace: Scope.Namespace = .{
@@ -5262,6 +5263,17 @@ fn unionDeclInner(
     const field_align_body_lens = try scratch.addOptionalSlice(scan_result.any_field_aligns, scan_result.fields_len);
     const field_value_body_lens = try scratch.addOptionalSlice(scan_result.any_field_values, scan_result.fields_len);
 
+    // Before any field bodies comes the tag/backing type, if specified.
+    const arg_type_body_len: ?u32 = if (opt_arg_node.unwrap()) |arg_node| len: {
+        const type_ref = try typeExpr(&block_scope, &namespace.base, arg_node);
+        if (!block_scope.endsWithNoReturn()) {
+            _ = try block_scope.addBreak(.break_inline, decl_inst, type_ref);
+        }
+        const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+        block_scope.instructions.items.len = block_scope.instructions_top;
+        break :len body_len;
+    } else null;
+
     const old_hasher = astgen.src_hasher;
     defer astgen.src_hasher = old_hasher;
     astgen.src_hasher = .init(.{});
@@ -5358,7 +5370,7 @@ fn unionDeclInner(
             .@"extern" => .@"extern",
             .@"packed" => if (opt_arg_node != .none) .packed_explicit else .@"packed",
         },
-        .arg_type = arg_type_ref,
+        .arg_type_body_len = arg_type_body_len,
         .decls_len = scan_result.decls_len,
         .fields_len = scan_result.fields_len,
         .any_field_aligns = scan_result.any_field_aligns,
@@ -5420,11 +5432,6 @@ fn containerDecl(
 
             astgen.advanceSourceCursorToNode(node);
 
-            const tag_type_ref: Zir.Inst.Ref = ref: {
-                const arg_node = container_decl.ast.arg.unwrap() orelse break :ref .none;
-                break :ref try typeExpr(gz, scope, arg_node);
-            };
-
             const decl_inst = try gz.reserveInstructionIndex();
 
             var namespace: Scope.Namespace = .{
@@ -5461,6 +5468,17 @@ fn containerDecl(
             const field_names = try scratch.addSlice(fields_len);
             const field_value_body_lens = try scratch.addOptionalSlice(scan_result.any_field_values, fields_len);
 
+            // Before any field bodies comes the tag type, if specified.
+            const tag_type_body_len: ?u32 = if (container_decl.ast.arg.unwrap()) |tag_type_node| len: {
+                const type_ref = try typeExpr(&block_scope, &namespace.base, tag_type_node);
+                if (!block_scope.endsWithNoReturn()) {
+                    _ = try block_scope.addBreak(.break_inline, decl_inst, type_ref);
+                }
+                const body_len = try scratch.appendBodyWithFixups(block_scope.instructionsSlice());
+                block_scope.instructions.items.len = block_scope.instructions_top;
+                break :len body_len;
+            } else null;
+
             const old_hasher = astgen.src_hasher;
             defer astgen.src_hasher = old_hasher;
             astgen.src_hasher = .init(.{});
@@ -5508,7 +5526,7 @@ fn containerDecl(
                 field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token));
 
                 if (member.ast.value_expr.unwrap()) |value_node| {
-                    if (tag_type_ref == .none) {
+                    if (tag_type_body_len == null) {
                         return astgen.failNodeNotes(node, "explicitly valued enum missing integer tag type", .{}, &.{
                             try astgen.errNoteNode(value_node, "tag value specified here", .{}),
                         });
@@ -5535,7 +5553,7 @@ fn containerDecl(
             try gz.setEnum(decl_inst, .{
                 .src_node = node,
                 .name_strat = name_strat,
-                .tag_type = tag_type_ref,
+                .tag_type_body_len = tag_type_body_len,
                 .nonexhaustive = scan_result.has_underscore_field,
                 .decls_len = scan_result.decls_len,
                 .fields_len = fields_len,
@@ -12406,7 +12424,7 @@ const GenZir = struct {
         src_node: Ast.Node.Index,
         name_strat: Zir.Inst.NameStrategy,
         layout: std.builtin.Type.ContainerLayout,
-        backing_int_type: Zir.Inst.Ref,
+        backing_int_type_body_len: ?u32,
         decls_len: u32,
         fields_len: u32,
         any_field_aligns: bool,
@@ -12430,7 +12448,7 @@ const GenZir = struct {
         const fields_hash_arr: [4]u32 = @bitCast(args.fields_hash);
 
         try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.StructDecl).@"struct".fields.len +
-            4 + // `captures_len`, `decls_len`, `fields_len`, `backing_int_type`
+            4 + // `captures_len`, `decls_len`, `fields_len`, `backing_int_type_body_len`
             captures_len * 2 + // `capture`, `capture_name`
             args.remaining.len);
 
@@ -12446,7 +12464,7 @@ const GenZir = struct {
         if (captures_len != 0) astgen.extra.appendAssumeCapacity(captures_len);
         if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
         if (args.fields_len != 0) astgen.extra.appendAssumeCapacity(args.fields_len);
-        if (args.backing_int_type != .none) astgen.extra.appendAssumeCapacity(@intFromEnum(args.backing_int_type));
+        if (args.backing_int_type_body_len) |n| astgen.extra.appendAssumeCapacity(n);
         astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
         astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
         astgen.extra.appendSliceAssumeCapacity(args.remaining);
@@ -12461,7 +12479,7 @@ const GenZir = struct {
                     .has_fields_len = args.fields_len != 0,
                     .name_strategy = args.name_strat,
                     .layout = args.layout,
-                    .has_backing_int_type = args.backing_int_type != .none,
+                    .has_backing_int_type = args.backing_int_type_body_len != null,
                     .any_field_aligns = args.any_field_aligns,
                     .any_field_defaults = args.any_field_defaults,
                     .any_comptime_fields = args.any_comptime_fields,
@@ -12475,7 +12493,7 @@ const GenZir = struct {
         src_node: Ast.Node.Index,
         name_strat: Zir.Inst.NameStrategy,
         kind: Zir.Inst.UnionDecl.Kind,
-        arg_type: Zir.Inst.Ref,
+        arg_type_body_len: ?u32,
         decls_len: u32,
         fields_len: u32,
         any_field_aligns: bool,
@@ -12497,7 +12515,7 @@ const GenZir = struct {
         const fields_hash_arr: [4]u32 = @bitCast(args.fields_hash);
 
         try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.UnionDecl).@"struct".fields.len +
-            4 + // `captures_len`, `decls_len`, `fields_len`, `backing_int_type`
+            4 + // `captures_len`, `decls_len`, `fields_len`, `arg_type_body_len`
             captures_len * 2 + // `capture`, `capture_name`
             args.remaining.len);
 
@@ -12514,10 +12532,9 @@ const GenZir = struct {
         if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
         if (args.fields_len != 0) astgen.extra.appendAssumeCapacity(args.fields_len);
         if (args.kind.hasArgType()) {
-            assert(args.arg_type != .none);
-            astgen.extra.appendAssumeCapacity(@intFromEnum(args.arg_type));
+            astgen.extra.appendAssumeCapacity(args.arg_type_body_len.?);
         } else {
-            assert(args.arg_type == .none);
+            assert(args.arg_type_body_len == null);
         }
         astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
         astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
@@ -12525,28 +12542,26 @@ const GenZir = struct {
 
         astgen.instructions.set(@intFromEnum(inst), .{
             .tag = .extended,
-            .data = .{
-                .extended = .{
-                    .opcode = .union_decl,
-                    .small = @bitCast(Zir.Inst.UnionDecl.Small{
-                        .has_captures_len = captures_len != 0,
-                        .has_decls_len = args.decls_len != 0,
-                        .has_fields_len = args.fields_len != 0,
-                        .name_strategy = args.name_strat,
-                        .kind = args.kind,
-                        .any_field_aligns = args.any_field_aligns,
-                        .any_field_values = args.any_field_values,
-                    }),
-                    .operand = payload_index,
-                },
-            },
+            .data = .{ .extended = .{
+                .opcode = .union_decl,
+                .small = @bitCast(Zir.Inst.UnionDecl.Small{
+                    .has_captures_len = captures_len != 0,
+                    .has_decls_len = args.decls_len != 0,
+                    .has_fields_len = args.fields_len != 0,
+                    .name_strategy = args.name_strat,
+                    .kind = args.kind,
+                    .any_field_aligns = args.any_field_aligns,
+                    .any_field_values = args.any_field_values,
+                }),
+                .operand = payload_index,
+            } },
         });
     }
 
     fn setEnum(gz: *GenZir, inst: Zir.Inst.Index, args: struct {
         src_node: Ast.Node.Index,
         name_strat: Zir.Inst.NameStrategy,
-        tag_type: Zir.Inst.Ref,
+        tag_type_body_len: ?u32,
         nonexhaustive: bool,
         decls_len: u32,
         fields_len: u32,
@@ -12568,7 +12583,7 @@ const GenZir = struct {
         const fields_hash_arr: [4]u32 = @bitCast(args.fields_hash);
 
         try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.EnumDecl).@"struct".fields.len +
-            4 + // `captures_len`, `decls_len`, `fields_len`, `tag_type`
+            4 + // `captures_len`, `decls_len`, `fields_len`, `tag_type_body_len`
             captures_len * 2 + // `capture`, `capture_name`
             args.remaining.len);
 
@@ -12584,7 +12599,7 @@ const GenZir = struct {
         if (captures_len != 0) astgen.extra.appendAssumeCapacity(captures_len);
         if (args.decls_len != 0) astgen.extra.appendAssumeCapacity(args.decls_len);
         if (args.fields_len != 0) astgen.extra.appendAssumeCapacity(args.fields_len);
-        if (args.tag_type != .none) astgen.extra.appendAssumeCapacity(@intFromEnum(args.tag_type));
+        if (args.tag_type_body_len) |n| astgen.extra.appendAssumeCapacity(n);
         astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.captures));
         astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names));
         astgen.extra.appendSliceAssumeCapacity(args.remaining);
@@ -12598,7 +12613,7 @@ const GenZir = struct {
                     .has_decls_len = args.decls_len != 0,
                     .has_fields_len = args.fields_len != 0,
                     .name_strategy = args.name_strat,
-                    .has_tag_type = args.tag_type != .none,
+                    .has_tag_type = args.tag_type_body_len != null,
                     .nonexhaustive = args.nonexhaustive,
                     .any_field_values = args.any_field_values,
                 }),
diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig
index c0270a9e03e7fe5eca1e0af9d8fdf36e64fc34e3..94c76b429cb49845757ac0f4c0c40bc27d9f0c27 100644
--- a/lib/std/zig/Zir.zig
+++ b/lib/std/zig/Zir.zig
@@ -3465,7 +3465,7 @@ pub const Inst = struct {
     /// 0.  captures_len: u32 // if `has_captures_len`
     /// 1.  decls_len: u32, // if `has_decls_len`
     /// 2.  fields_len: u32, // if `has_fields_len`
-    /// 3.  backing_int_type: Ref // if `has_backing_int`
+    /// 3.  backing_int_body_len: u32 // if `has_backing_int`
     /// 4.  capture: Capture // for every `captures_len`
     /// 5.  capture_name: NullTerminatedString // for every `captures_len`
     /// 6.  decl: Index, // for every `decls_len`; points to a `declaration` instruction
@@ -3475,7 +3475,8 @@ pub const Inst = struct {
     /// 10. field_default_body_len: u32 // for every `fields_len` if `any_field_defaults`
     /// 11. field_comptime_bits: u32 // one bit per `fields_len` if `any_comptime_fields`
     ///                              // LSB is first field, minimum number of `u32` needed
-    /// 12. body_inst: Inst.Index // type body, then align body, then default body, for each field
+    /// 12. backing_int_body_inst: Inst.Index // for each `backing_int_body_len`
+    /// 13. body_inst: Inst.Index // type body, then align body, then default body, for each field
     pub const StructDecl = struct {
         // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
         // This hash contains the source of all fields, and any specified attributes (`extern`, backing type, etc).
@@ -3622,13 +3623,14 @@ pub const Inst = struct {
     /// 0. captures_len: u32, // if has_captures_len
     /// 1. decls_len: u32, // if has_decls_len
     /// 2. fields_len: u32, // if has_fields_len
-    /// 3. tag_type: Ref, // if has_tag_type
+    /// 3. tag_type_body_len: u32, // if has_tag_type
     /// 4. capture: Capture // for every `captures_len`
     /// 5. capture_name: NullTerminatedString // for every `captures_len`
     /// 6. decl: Index, // for every `decls_len`; points to a `declaration` instruction
     /// 7. field_name: NullTerminatedString // for every `fields_len`
     /// 8. field_value_body_len: u32 // for every `fields_len` if `any_field_values`
-    /// 9. body_inst: Inst.Index // value body for each field
+    /// 9. tag_type_body_inst: Inst.Index // for each `tag_type_body_len`
+    /// 10. body_inst: Inst.Index // value body for each field
     pub const EnumDecl = struct {
         // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
         // This hash contains the source of all fields, and the backing type if specified.
@@ -3656,7 +3658,7 @@ pub const Inst = struct {
     /// 0.  captures_len: u32 // if `has_captures_len`
     /// 1.  decls_len: u32, // if `has_decls_len`
     /// 2.  fields_len: u32, // if `has_fields_len`
-    /// 3.  arg_type: Ref, // if `kind.hasArgType()`
+    /// 3.  arg_type_body_len: u32, // if `kind.hasArgType()`
     /// 4.  capture: Capture // for every `captures_len`
     /// 5.  capture_name: NullTerminatedString // for every `captures_len`
     /// 6.  decl: Index, // for every `decls_len`; points to a `declaration` instruction
@@ -3664,7 +3666,8 @@ pub const Inst = struct {
     /// 8.  field_type_body_len: u32 // for every `fields_len`
     /// 9 . field_align_body_len: u32 // for every `fields_len` if `any_field_aligns`
     /// 10. field_value_body_len: u32 // for every `fields_len` if `any_field_values`
-    /// 11. body_inst: Inst.Index // type body, then align body, then value body, for each field
+    /// 11. arg_type_body_inst: Inst.Index // for each `arg_type_body_len`
+    /// 12. body_inst: Inst.Index // type body, then align body, then value body, for each field
     pub const UnionDecl = struct {
         // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
         // This hash contains the source of all fields, and any specified attributes (`extern` etc).
@@ -5235,18 +5238,6 @@ pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void {
     }
 }
 
-/// MLUGG TODO: maybe delete these two?
-pub fn typeCapturesLen(zir: Zir, type_decl: Inst.Index) u32 {
-    const inst = zir.instructions.get(@intFromEnum(type_decl));
-    assert(inst.tag == .extended);
-    return switch (inst.data.extended.opcode) {
-        .struct_decl => @intCast(zir.getStructDecl(type_decl).captures.len),
-        .union_decl => @intCast(zir.getUnionDecl(type_decl).captures.len),
-        .enum_decl => @intCast(zir.getEnumDecl(type_decl).captures.len),
-        .opaque_decl => @intCast(zir.getOpaqueDecl(type_decl).captures.len),
-        else => unreachable,
-    };
-}
 pub fn typeDecls(zir: Zir, type_decl: Inst.Index) []const Zir.Inst.Index {
     const inst = zir.instructions.get(@intFromEnum(type_decl));
     assert(inst.tag == .extended);
@@ -5281,11 +5272,11 @@ pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDe
         extra_index += 1;
         break :blk fields_len;
     } else 0;
-    const backing_int_type: Inst.Ref = if (small.has_backing_int_type) ty: {
-        const ty = zir.extra[extra_index];
+    const backing_int_type_body_len: u32 = if (small.has_backing_int_type) len: {
+        const body_len = zir.extra[extra_index];
         extra_index += 1;
-        break :ty @enumFromInt(ty);
-    } else .none;
+        break :len body_len;
+    } else 0;
     const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
     extra_index += captures_len;
     const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
@@ -5312,6 +5303,11 @@ pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDe
         extra_index += bits_len;
         break :bits bits;
     } else null;
+    const backing_int_type_body: ?[]const Zir.Inst.Index = switch (backing_int_type_body_len) {
+        0 => null,
+        else => |n| zir.bodySlice(extra_index, n),
+    };
+    extra_index += backing_int_type_body_len;
     const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
     return .{
         .src_line = extra.data.src_line,
@@ -5321,7 +5317,7 @@ pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDe
         .capture_names = capture_names,
         .decls = decls,
         .layout = small.layout,
-        .backing_int_type = backing_int_type,
+        .backing_int_type_body = backing_int_type_body,
         .field_names = field_names,
         .field_type_body_lens = field_type_body_lens,
         .field_align_body_lens = field_align_body_lens,
@@ -5341,7 +5337,7 @@ pub const UnwrappedStructDecl = struct {
     decls: []const Inst.Index,
 
     layout: std.builtin.Type.ContainerLayout,
-    backing_int_type: Inst.Ref,
+    backing_int_type_body: ?[]const Inst.Index,
 
     field_names: []const NullTerminatedString,
     field_type_body_lens: []const u32,
@@ -5427,11 +5423,11 @@ pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl
         extra_index += 1;
         break :blk fields_len;
     } else 0;
-    const arg_type: Inst.Ref = if (small.kind.hasArgType()) ty: {
-        const ty = zir.extra[extra_index];
+    const arg_type_body_len: u32 = if (small.kind.hasArgType()) len: {
+        const body_len = zir.extra[extra_index];
         extra_index += 1;
-        break :ty @enumFromInt(ty);
-    } else .none;
+        break :len body_len;
+    } else 0;
     const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
     extra_index += captures_len;
     const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
@@ -5452,6 +5448,11 @@ pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl
         extra_index += fields_len;
         break :lens @ptrCast(lens);
     } else null;
+    const arg_type_body: ?[]const Zir.Inst.Index = switch (arg_type_body_len) {
+        0 => null,
+        else => |n| zir.bodySlice(extra_index, n),
+    };
+    extra_index += arg_type_body_len;
     const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
     return .{
         .src_line = extra.data.src_line,
@@ -5461,7 +5462,7 @@ pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl
         .capture_names = capture_names,
         .decls = decls,
         .kind = small.kind,
-        .arg_type = arg_type,
+        .arg_type_body = arg_type_body,
         .field_names = field_names,
         .field_type_body_lens = field_type_body_lens,
         .field_align_body_lens = field_align_body_lens,
@@ -5480,7 +5481,7 @@ pub const UnwrappedUnionDecl = struct {
     decls: []const Inst.Index,
 
     kind: Inst.UnionDecl.Kind,
-    arg_type: Inst.Ref,
+    arg_type_body: ?[]const Inst.Index,
 
     field_names: []const NullTerminatedString,
     field_type_body_lens: []const u32,
@@ -5556,11 +5557,11 @@ pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl {
         extra_index += 1;
         break :blk fields_len;
     } else 0;
-    const tag_type: Inst.Ref = if (small.has_tag_type) ty: {
-        const ty = zir.extra[extra_index];
+    const tag_type_body_len: u32 = if (small.has_tag_type) len: {
+        const body_len = zir.extra[extra_index];
         extra_index += 1;
-        break :ty @enumFromInt(ty);
-    } else .none;
+        break :len body_len;
+    } else 0;
     const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
     extra_index += captures_len;
     const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
@@ -5574,6 +5575,11 @@ pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl {
         extra_index += fields_len;
         break :lens @ptrCast(lens);
     } else null;
+    const tag_type_body: ?[]const Zir.Inst.Index = switch (tag_type_body_len) {
+        0 => null,
+        else => |n| zir.bodySlice(extra_index, n),
+    };
+    extra_index += tag_type_body_len;
     const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
     return .{
         .src_line = extra.data.src_line,
@@ -5582,7 +5588,7 @@ pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl {
         .captures = captures,
         .capture_names = capture_names,
         .decls = decls,
-        .tag_type = tag_type,
+        .tag_type_body = tag_type_body,
         .nonexhaustive = small.nonexhaustive,
         .field_names = field_names,
         .field_value_body_lens = field_value_body_lens,
@@ -5599,7 +5605,7 @@ pub const UnwrappedEnumDecl = struct {
 
     decls: []const Inst.Index,
 
-    tag_type: Inst.Ref,
+    tag_type_body: ?[]const Inst.Index,
     nonexhaustive: bool,
 
     field_names: []const NullTerminatedString,
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 14046f38fc2e41c9aa50efa7586f6815ba67aeb6..64afabc76394a03c4b421345213ce9a189be34de 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3713,7 +3713,7 @@ const Header = extern struct {
         nav_val_deps_len: u32,
         nav_ty_deps_len: u32,
         type_layout_deps_len: u32,
-        type_inits_deps_len: u32,
+        struct_defaults_deps_len: u32,
         func_ies_deps_len: u32,
         zon_file_deps_len: u32,
         embed_file_deps_len: u32,
@@ -3763,7 +3763,7 @@ pub fn saveState(comp: *Compilation) !void {
                 .nav_val_deps_len = @intCast(ip.nav_val_deps.count()),
                 .nav_ty_deps_len = @intCast(ip.nav_ty_deps.count()),
                 .type_layout_deps_len = @intCast(ip.type_layout_deps.count()),
-                .type_inits_deps_len = @intCast(ip.type_inits_deps.count()),
+                .struct_defaults_deps_len = @intCast(ip.struct_defaults_deps.count()),
                 .func_ies_deps_len = @intCast(ip.func_ies_deps.count()),
                 .zon_file_deps_len = @intCast(ip.zon_file_deps.count()),
                 .embed_file_deps_len = @intCast(ip.embed_file_deps.count()),
@@ -3800,8 +3800,8 @@ pub fn saveState(comp: *Compilation) !void {
         addBuf(&bufs, @ptrCast(ip.nav_ty_deps.values()));
         addBuf(&bufs, @ptrCast(ip.type_layout_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.type_layout_deps.values()));
-        addBuf(&bufs, @ptrCast(ip.type_inits_deps.keys()));
-        addBuf(&bufs, @ptrCast(ip.type_inits_deps.values()));
+        addBuf(&bufs, @ptrCast(ip.struct_defaults_deps.keys()));
+        addBuf(&bufs, @ptrCast(ip.struct_defaults_deps.values()));
         addBuf(&bufs, @ptrCast(ip.func_ies_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.func_ies_deps.values()));
         addBuf(&bufs, @ptrCast(ip.zon_file_deps.keys()));
@@ -4481,7 +4481,7 @@ pub fn addModuleErrorMsg(
                 const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
                     .@"comptime" => "comptime",
                     .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
-                    .type_layout, .type_inits => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
+                    .type_layout, .struct_defaults => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
                     .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
                     .memoized_state => null,
                 };
@@ -5251,7 +5251,7 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav),
                 .nav_val => |nav| pt.ensureNavValUpToDate(nav),
                 .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty)),
-                .type_inits => |ty| pt.ensureTypeInitsUpToDate(.fromInterned(ty)),
+                .struct_defaults => |ty| pt.ensureStructDefaultsUpToDate(.fromInterned(ty)),
                 .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage),
                 .func => |func| pt.ensureFuncBodyUpToDate(func),
             };
diff --git a/src/IncrementalDebugServer.zig b/src/IncrementalDebugServer.zig
index ce40844057d8e34d409f6ba78eb1b6b59f9085dc..7d0dc8e89b6fd9fd257733839e924de1ce92a25f 100644
--- a/src/IncrementalDebugServer.zig
+++ b/src/IncrementalDebugServer.zig
@@ -307,7 +307,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const
             switch (dependee) {
                 .src_hash, .namespace, .namespace_name, .zon_file, .embed_file => try w.print("{f}", .{zcu.fmtDependee(dependee)}),
                 .nav_val, .nav_ty => |nav| try w.print("{t} {d}", .{ dependee, @intFromEnum(nav) }),
-                .type_layout, .type_inits, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
+                .type_layout, .struct_defaults, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
                 .memoized_state => |stage| try w.print("memoized_state {s}", .{@tagName(stage)}),
             }
             try w.writeByte('\n');
@@ -374,8 +374,8 @@ fn parseAnalUnit(str: []const u8) ?AnalUnit {
         return .wrap(.{ .nav_ty = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "type_layout")) {
         return .wrap(.{ .type_layout = @enumFromInt(parseIndex(idx_str) orelse return null) });
-    } else if (std.mem.eql(u8, kind, "type_inits")) {
-        return .wrap(.{ .type_inits = @enumFromInt(parseIndex(idx_str) orelse return null) });
+    } else if (std.mem.eql(u8, kind, "struct_defaults")) {
+        return .wrap(.{ .struct_defaults = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "func")) {
         return .wrap(.{ .func = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "memoized_state")) {
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 28846c3f70ce14a85c09e4ce7d703816f3fe543b..ce9622e54d57bc0703d9151a5bbd35e3ef57298c 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -50,12 +50,12 @@ nav_ty_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
 /// Dependencies on a function's inferred error set. Key is the function body, not the IES.
 /// Value is index into `dep_entries` of the first dependency on this function's IES.
 func_ies_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
-/// Dependencies on the resolved layout of a `struct` or `union` type.
+/// Dependencies on the resolved layout of a `struct`, `union`, or `enum` type.
 /// Value is index into `dep_entries` of the first dependency on this type's layout.
 type_layout_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
-/// Dependencies on the resolved initializers of a `struct` or `enum` type.
+/// Dependencies on the resolved default field values of a `struct` type.
 /// Value is index into `dep_entries` of the first dependency on this type's inits.
-type_inits_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
+struct_defaults_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
 /// Dependencies on a ZON file. Triggered by `@import` of ZON.
 /// Value is index into `dep_entries` of the first dependency on this ZON file.
 zon_file_deps: std.AutoArrayHashMapUnmanaged(FileIndex, DepEntry.Index),
@@ -110,7 +110,7 @@ pub const empty: InternPool = .{
     .nav_ty_deps = .empty,
     .func_ies_deps = .empty,
     .type_layout_deps = .empty,
-    .type_inits_deps = .empty,
+    .struct_defaults_deps = .empty,
     .zon_file_deps = .empty,
     .embed_file_deps = .empty,
     .namespace_deps = .empty,
@@ -422,7 +422,7 @@ pub const AnalUnit = packed struct(u64) {
         nav_val,
         nav_ty,
         type_layout,
-        type_inits,
+        struct_defaults,
         func,
         memoized_state,
     };
@@ -434,11 +434,10 @@ pub const AnalUnit = packed struct(u64) {
         nav_val: Nav.Index,
         /// This `AnalUnit` resolves the type of the given `Nav`.
         nav_ty: Nav.Index,
-        /// This `AnalUnit` resolves the layout of the given `struct` or `union` type.
+        /// This `AnalUnit` resolves the layout of the given `struct`, `union`, or `enum` type.
         type_layout: InternPool.Index,
-        /// This `AnalUnit` resolves the field inits of the given `struct` or `enum` type.
-        /// The type may be a union's auto-generated tag enum, if the union has explicit field values.
-        type_inits: InternPool.Index,
+        /// This `AnalUnit` resolves the default field values of the given `struct` type.
+        struct_defaults: InternPool.Index,
         /// This `AnalUnit` analyzes the body of the given runtime function.
         func: InternPool.Index,
         /// This `AnalUnit` resolves all state which is memoized in fields on `Zcu`.
@@ -852,7 +851,7 @@ pub const Dependee = union(enum) {
     /// Index is the function, not its IES.
     func_ies: Index,
     type_layout: Index,
-    type_inits: Index,
+    struct_defaults: Index,
     zon_file: FileIndex,
     embed_file: Zcu.EmbedFile.Index,
     namespace: TrackedInst.Index,
@@ -906,7 +905,7 @@ pub fn dependencyIterator(ip: *const InternPool, dependee: Dependee) DependencyI
         .nav_ty => |x| ip.nav_ty_deps.get(x),
         .func_ies => |x| ip.func_ies_deps.get(x),
         .type_layout => |x| ip.type_layout_deps.get(x),
-        .type_inits => |x| ip.type_inits_deps.get(x),
+        .struct_defaults => |x| ip.struct_defaults_deps.get(x),
         .zon_file => |x| ip.zon_file_deps.get(x),
         .embed_file => |x| ip.embed_file_deps.get(x),
         .namespace => |x| ip.namespace_deps.get(x),
@@ -981,7 +980,7 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend
                 .nav_ty => ip.nav_ty_deps,
                 .func_ies => ip.func_ies_deps,
                 .type_layout => ip.type_layout_deps,
-                .type_inits => ip.type_inits_deps,
+                .struct_defaults => ip.struct_defaults_deps,
                 .zon_file => ip.zon_file_deps,
                 .embed_file => ip.embed_file_deps,
                 .namespace => ip.namespace_deps,
@@ -2248,10 +2247,6 @@ pub const Key = union(enum) {
         pub const Declared = struct {
             /// A `struct_decl`, `union_decl`, `enum_decl`, or `opaque_decl` instruction.
             zir_index: TrackedInst.Index,
-            /// If the type declaration had an argument type (tag type or packed backing type), this
-            /// is that type. Otherwise, this is `.none`. It is always `.none` for `opaque` types as
-            /// `opaque(T)` does not exist.
-            arg_ty: Index,
             /// The captured values of this type. These values must be fully resolved per the language spec.
             captures: union(enum) {
                 owned: CaptureValue.Slice,
@@ -2745,7 +2740,6 @@ pub const Key = union(enum) {
                 switch (namespace_type) {
                     .declared => |declared| {
                         std.hash.autoHash(&hasher, declared.zir_index);
-                        std.hash.autoHash(&hasher, declared.arg_ty);
                         const captures = switch (declared.captures) {
                             .owned => |cvs| cvs.get(ip),
                             .external => |cvs| cvs,
@@ -3155,7 +3149,6 @@ pub const Key = union(enum) {
                     .declared => |a_d| {
                         const b_d = b_info.declared;
                         if (a_d.zir_index != b_d.zir_index) return false;
-                        if (a_d.arg_ty != b_d.arg_ty) return false;
                         const a_captures = switch (a_d.captures) {
                             .owned => |s| s.get(ip),
                             .external => |cvs| cvs,
@@ -3295,7 +3288,6 @@ pub const Key = union(enum) {
                 .void => .void_type,
                 .null => .null_type,
                 .false, .true => .bool_type,
-                .empty_tuple => .empty_tuple_type,
                 .@"unreachable" => .noreturn_type,
             },
 
@@ -3308,6 +3300,7 @@ pub const LoadedStructType = struct {
     /// Index of the `struct_decl` or `reify` ZIR instruction.
     zir_index: TrackedInst.Index,
     captures: CaptureValue.Slice,
+    is_reified: bool,
 
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this struct type.
@@ -3319,10 +3312,9 @@ pub const LoadedStructType = struct {
 
     layout: std.builtin.Type.ContainerLayout,
     /// May be `undefined` if `layout != .@"packed"`.
-    packed_backing_mode: PackedBackingMode,
-    /// May be `undefined` if `layout != .@"packed",
-    packed_backing_int_type: Index,
+    packed_backing_mode: BackingTypeMode,
 
+    // The remaining fields are only valid once the struct's layout is resolved.
     field_name_map: MapIndex,
     field_names: NullTerminatedString.Slice,
     field_types: Index.Slice,
@@ -3331,11 +3323,11 @@ pub const LoadedStructType = struct {
     field_is_comptime_bits: ComptimeBits,
     field_runtime_order: RuntimeOrder.Slice,
     field_offsets: Offsets,
-
-    // These fields are only valid once the layout is resolved, and are never valid for `layout == .@"packed"`.
+    packed_backing_int_type: Index,
     has_no_possible_value: bool,
     has_one_possible_value: bool,
     comptime_only: bool,
+    has_runtime_bits: bool,
     size: u32,
     alignment: Alignment,
 
@@ -3478,6 +3470,7 @@ pub const LoadedUnionType = struct {
     /// Index of the `union_decl` or `reify` ZIR instruction.
     zir_index: TrackedInst.Index,
     captures: CaptureValue.Slice,
+    is_reified: bool,
 
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this union type.
@@ -3488,23 +3481,26 @@ pub const LoadedUnionType = struct {
     namespace: NamespaceIndex,
 
     layout: std.builtin.Type.ContainerLayout,
+    enum_tag_mode: BackingTypeMode,
+    /// May be `undefined` if `layout != .@"packed"`.
+    packed_backing_mode: BackingTypeMode,
+
+    /// Only reified unions store field names; typically they should be loaded from `enum_tag_type`
+    /// instead. Reified unions store them because type resolution needs them in order to validate
+    /// or populate `enum_tag_type`.
+    reified_field_names: NullTerminatedString.Slice,
+
+    // The remaining fields are only valid once the union's layout is resolved.
+    field_types: Index.Slice,
+    field_aligns: Alignment.Slice,
     runtime_tag: RuntimeTag,
     /// Even if `runtime_tag == .none`, this is populated with the union's "hypothetical" tag type.
     enum_tag_type: Index,
-    /// May be `undefined` if `layout != .@"packed"`.
-    packed_backing_mode: PackedBackingMode,
-    /// May be `undefined` if `layout != .@"packed",
     packed_backing_int_type: Index,
-
-    // Field names are not stored here, because fields are guaranteed to map one-to-one to the
-    // fields of the enum tag type. If you need field names, load them from `enum_tag_type`.
-    field_types: Index.Slice,
-    field_aligns: Alignment.Slice,
-
-    // These fields are only valid once the layout is resolved, and are never valid for `layout == .@"packed"`.
     has_no_possible_value: bool,
     has_one_possible_value: bool,
     comptime_only: bool,
+    has_runtime_bits: bool,
     size: u32,
     padding: u32,
     alignment: Alignment,
@@ -3523,6 +3519,7 @@ pub const LoadedEnumType = struct {
     captures: CaptureValue.Slice,
     /// If `zir_index` is `.none`, this is the union type for which this enum is the tag type.
     owner_union: Index,
+    is_reified: bool,
 
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this enum type.
@@ -3532,19 +3529,14 @@ pub const LoadedEnumType = struct {
     name_nav: Nav.Index.Optional,
     namespace: NamespaceIndex,
 
-    /// An integer type which is used for the numerical value of the enum. Populated immediately, regardless
-    /// of whether the integer tag type was explicitly provided or inferred by the compiler.
-    int_tag_type: Index,
-    int_tag_is_explicit: bool,
+    int_tag_mode: BackingTypeMode,
     nonexhaustive: bool,
 
-    /// Uses `NullTerminatedString.Adapter` with `field_names`.
+    // The remaining fields are only valid once the enum's layout is resolved.
+    int_tag_type: Index,
     field_name_map: MapIndex,
-    /// If this is `.none`, the enum tag type is auto-generated and so the fields are auto-numbered.
-    /// Otherwise, uses `Index.Adapter` with `field_values`.
+    field_names: NullTerminatedString.Slice,
     field_value_map: OptionalMapIndex,
-    field_names: NullTerminatedString.Slice,
-    /// Empty if `field_value_map` is `.none`.
     field_values: Index.Slice,
 
     /// Look up field index based on field name.
@@ -3596,7 +3588,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
     const extra_items = extra_list.view().items(.@"0");
     const item = unwrapped_index.getItem(ip);
     // Exiting this `switch` means this is a `packed struct`.
-    const backing_mode: PackedBackingMode, const any_defaults: bool = switch (item.tag) {
+    const backing_mode: BackingTypeMode, const any_defaults: bool = switch (item.tag) {
         .type_struct_packed_auto => .{ .auto, false },
         .type_struct_packed_explicit => .{ .explicit, false },
         .type_struct_packed_auto_defaults => .{ .auto, true },
@@ -3667,6 +3659,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
             return .{
                 .zir_index = extra.data.zir_index,
                 .captures = captures,
+                .is_reified = extra.data.flags.any_captures == .reified,
                 .name = extra.data.name,
                 .name_nav = extra.data.name_nav,
                 .namespace = extra.data.namespace,
@@ -3675,7 +3668,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                     .@"extern" => .@"extern",
                 },
                 .packed_backing_mode = undefined,
-                .packed_backing_int_type = undefined,
+
                 .field_name_map = extra.data.field_name_map,
                 .field_names = field_names,
                 .field_types = field_types,
@@ -3684,9 +3677,11 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .field_is_comptime_bits = field_is_comptime_bits,
                 .field_runtime_order = field_runtime_order,
                 .field_offsets = field_offsets,
+                .packed_backing_int_type = .none,
                 .has_no_possible_value = extra.data.flags.has_no_possible_value,
                 .has_one_possible_value = extra.data.flags.has_one_possible_value,
                 .comptime_only = extra.data.flags.comptime_only,
+                .has_runtime_bits = extra.data.flags.has_runtime_bits,
                 .size = extra.data.size,
                 .alignment = extra.data.flags.alignment,
             };
@@ -3728,12 +3723,13 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
     return .{
         .zir_index = extra.data.zir_index,
         .captures = captures,
+        .is_reified = extra.data.captures_len == .reified,
         .name = extra.data.name,
         .name_nav = extra.data.name_nav,
         .namespace = extra.data.namespace,
         .layout = .@"packed",
         .packed_backing_mode = backing_mode,
-        .packed_backing_int_type = extra.data.backing_int_type,
+
         .field_name_map = extra.data.field_name_map,
         .field_names = field_names,
         .field_types = field_types,
@@ -3742,9 +3738,11 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
         .field_is_comptime_bits = .empty,
         .field_runtime_order = .empty,
         .field_offsets = .empty,
+        .packed_backing_int_type = extra.data.backing_int_type,
         .has_no_possible_value = undefined,
         .has_one_possible_value = undefined,
         .comptime_only = undefined,
+        .has_runtime_bits = undefined,
         .size = undefined,
         .alignment = undefined,
     };
@@ -3756,7 +3754,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
     const extra_items = extra_list.view().items(.@"0");
     const item = unwrapped_index.getItem(ip);
     // Exiting this `switch` means this is a `packed union`.
-    const backing_mode: PackedBackingMode = switch (item.tag) {
+    const backing_mode: BackingTypeMode = switch (item.tag) {
         .type_union_packed_auto => .auto,
         .type_union_packed_explicit => .explicit,
         .type_union => {
@@ -3779,6 +3777,12 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
                 },
             };
             extra_index += captures.len;
+            const reified_field_names: NullTerminatedString.Slice = if (extra.data.flags.any_captures == .reified) .{
+                .tid = unwrapped_index.tid,
+                .start = extra_index,
+                .len = extra.data.fields_len,
+            } else .empty;
+            extra_index += reified_field_names.len;
             const field_types: Index.Slice = .{
                 .tid = unwrapped_index.tid,
                 .start = extra_index,
@@ -3795,6 +3799,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
             return .{
                 .zir_index = extra.data.zir_index,
                 .captures = captures,
+                .is_reified = extra.data.flags.any_captures == .reified,
                 .name = extra.data.name,
                 .name_nav = extra.data.name_nav,
                 .namespace = extra.data.namespace,
@@ -3803,14 +3808,17 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
                     .@"extern" => .@"extern",
                 },
                 .runtime_tag = extra.data.flags.runtime_tag,
+                .enum_tag_mode = extra.data.flags.enum_tag_mode,
                 .enum_tag_type = extra.data.enum_tag_type,
                 .packed_backing_mode = undefined,
                 .packed_backing_int_type = undefined,
+                .reified_field_names = reified_field_names,
                 .field_types = field_types,
                 .field_aligns = field_aligns,
                 .has_no_possible_value = extra.data.flags.has_no_possible_value,
                 .has_one_possible_value = extra.data.flags.has_one_possible_value,
                 .comptime_only = extra.data.flags.comptime_only,
+                .has_runtime_bits = extra.data.flags.has_runtime_bits,
                 .size = extra.data.size,
                 .padding = extra.data.padding,
                 .alignment = extra.data.flags.alignment,
@@ -3832,6 +3840,12 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
         },
     };
     extra_index += captures.len;
+    const reified_field_names: NullTerminatedString.Slice = if (extra.data.captures_len == .reified) .{
+        .tid = unwrapped_index.tid,
+        .start = extra_index,
+        .len = extra.data.fields_len,
+    } else .empty;
+    extra_index += reified_field_names.len;
     const field_types: Index.Slice = .{
         .tid = unwrapped_index.tid,
         .start = extra_index,
@@ -3841,19 +3855,23 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
     return .{
         .zir_index = extra.data.zir_index,
         .captures = captures,
+        .is_reified = extra.data.captures_len == .reified,
         .name = extra.data.name,
         .name_nav = extra.data.name_nav,
         .namespace = extra.data.namespace,
         .layout = .@"packed",
         .runtime_tag = .none,
+        .enum_tag_mode = .auto,
         .enum_tag_type = extra.data.enum_tag_type,
         .packed_backing_mode = backing_mode,
         .packed_backing_int_type = extra.data.backing_int_type,
+        .reified_field_names = reified_field_names,
         .field_types = field_types,
         .field_aligns = .empty,
         .has_no_possible_value = undefined,
         .has_one_possible_value = undefined,
         .comptime_only = undefined,
+        .has_runtime_bits = undefined,
         .size = undefined,
         .padding = undefined,
         .alignment = undefined,
@@ -3917,12 +3935,13 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
     return .{
         .zir_index = zir_index,
         .captures = captures,
+        .is_reified = extra.data.captures_len == .reified,
         .owner_union = owner_union,
         .name = extra.data.name,
         .name_nav = extra.data.name_nav,
         .namespace = extra.data.namespace,
         .int_tag_type = extra.data.int_tag_type,
-        .int_tag_is_explicit = explicit_int_tag,
+        .int_tag_mode = if (explicit_int_tag) .explicit else .auto,
         .nonexhaustive = nonexhaustive,
         .field_name_map = extra.data.field_name_map,
         .field_value_map = field_value_map,
@@ -4160,7 +4179,7 @@ pub const Index = enum(u32) {
     };
 
     /// Used for a map of `Index` values to the index within a list of `Index` values.
-    pub const Adapter = struct {
+    const Adapter = struct {
         indexes: []const Index,
 
         pub fn eql(ctx: @This(), a: Index, b_void: void, b_map_index: usize) bool {
@@ -4365,7 +4384,7 @@ pub const Index = enum(u32) {
     }) void {
         _ = self;
         const map_fields = @typeInfo(@typeInfo(@TypeOf(tag_to_encoding_map)).pointer.child).@"struct".fields;
-        @setEvalBranchQuota(2_000);
+        @setEvalBranchQuota(3_000);
         inline for (@typeInfo(Tag).@"enum".fields, 0..) |tag, start| {
             inline for (0..map_fields.len) |offset| {
                 if (comptime std.mem.eql(u8, tag.name, map_fields[(start + offset) % map_fields.len].name)) break;
@@ -4797,7 +4816,11 @@ pub const static_keys: [static_len]Key = .{
     .{ .simple_value = .null },
     .{ .simple_value = .true },
     .{ .simple_value = .false },
-    .{ .simple_value = .empty_tuple },
+
+    .{ .aggregate = .{
+        .ty = .empty_tuple_type,
+        .storage = .{ .elems = &.{} },
+    } },
 };
 
 /// How many items in the InternPool are statically known.
@@ -5601,10 +5624,12 @@ pub const Tag = enum(u8) {
             has_no_possible_value: bool,
             /// Whether the struct is comptime-only. Always `false` until layout resolved.
             comptime_only: bool,
+            /// Whether the struct has runtime bits. Always `false` until layout resolved.
+            has_runtime_bits: bool,
             /// Alignment of the whole struct. Always `.none` until layout resolved.
             alignment: Alignment,
 
-            _: u17 = 0,
+            _: u16 = 0,
         };
     };
 
@@ -5625,21 +5650,25 @@ pub const Tag = enum(u8) {
         name_nav: Nav.Index.Optional,
         namespace: NamespaceIndex,
 
-        /// The corresponding `PackedBackingMode` depends on the item's `Tag`.
+        /// The corresponding `BackingTypeMode` depends on the item's `Tag`.
         backing_int_type: Index,
 
         fields_len: u32,
         field_name_map: MapIndex,
     };
 
-    /// Field names are intentionally omitted---they are available in `enum_tag_type`.
+    /// For declared unions, field names are intentionally omitted because they are available in
+    /// `enum_tag_type`. However, reified unions do store field names, because they are needed by
+    /// type resolution to create or validate the enum tag type (type resolution for declared unions
+    /// instead fetches field names from ZIR).
     ///
     /// Trailing:
     /// 0. type_hash: PackedU64   // if `any_captures == .reified`
     /// 1. captures_len: u32      // if `any_captures == .true`
     /// 2. capture: CaptureValue  // if `any_captures == .true`; for each `captures_len`
-    /// 3. field_type: Index      // for each `fields_len`
-    /// 4. field_align: Alignment // for each `fields_len` if `any_field_aligns`
+    /// 3. reified_field_name: NullTerminatedString // if `any_captures == .reified`; for each `fields_len`
+    /// 4. field_type: Index      // for each `fields_len`
+    /// 5. field_align: Alignment // for each `fields_len` if `any_field_aligns`
     pub const TypeUnion = struct {
         zir_index: TrackedInst.Index,
 
@@ -5652,7 +5681,6 @@ pub const Tag = enum(u8) {
         /// This could be provided through the tag type, but it is more convenient
         /// to store it directly. This is also necessary for `dumpStatsFallible` to
         /// work on unresolved types.
-        /// MLUGG TODO: reconsider, because we resolve the tag type eagerly now.
         fields_len: u32,
 
         /// Always 0 until layout resolved.
@@ -5669,7 +5697,7 @@ pub const Tag = enum(u8) {
             ///
             /// For `union(enum(E))` syntax, this is `false`, but the generated enum tag type is
             /// considered to have an explicitly specified integer tag type.
-            explicit_tag_type: bool,
+            enum_tag_mode: BackingTypeMode,
 
             /// `packed` layout is represented separately by `TypeStructPacked`.
             layout: enum(u1) { auto, @"extern" },
@@ -5685,19 +5713,25 @@ pub const Tag = enum(u8) {
             has_no_possible_value: bool,
             /// Whether the union is comptime-only. Always `false` until layout resolved.
             comptime_only: bool,
+            /// Whether the union has runtime bits. Always `false` until layout resolved.
+            has_runtime_bits: bool,
             /// Alignment of the whole union. Always `.none` until layout resolved.
             alignment: Alignment,
 
-            _: u16 = 0,
+            _: u15 = 0,
         };
     };
 
-    /// Field names are intentionally omitted---they are available in `enum_tag_type`.
+    /// For declared unions, field names are intentionally omitted because they are available in
+    /// `enum_tag_type`. However, reified unions do store field names, because they are needed by
+    /// type resolution to create or validate the enum tag type (type resolution for declared unions
+    /// instead fetches field names from ZIR).
     ///
     /// Trailing:
     /// 0. type_hash: PackedU64  // if `captures_len == .reified`
     /// 1. capture: CaptureValue // if `captures_len != .reified`; for each `captures_len`
-    /// 2. field_type: Index     // for each `fields_len`
+    /// 2. reified_field_name: NullTerminatedString // if `captures_len == .reified`; for each `fields_len`
+    /// 3. field_type: Index     // for each `fields_len`
     pub const TypeUnionPacked = struct {
         zir_index: TrackedInst.Index,
         captures_len: enum(u32) {
@@ -5709,7 +5743,7 @@ pub const Tag = enum(u8) {
         name_nav: Nav.Index.Optional,
         namespace: NamespaceIndex,
 
-        /// The corresponding `PackedBackingMode` depends on the item's `Tag`.
+        /// The corresponding `BackingTypeMode` depends on the item's `Tag`.
         backing_int_type: Index,
         /// Although packed unions do not semantically have a tag type, the compiler still assigns
         /// them a "hypothetical" tag type.
@@ -5718,7 +5752,6 @@ pub const Tag = enum(u8) {
         /// This could be provided through the tag type, but it is more convenient
         /// to store it directly. This is also necessary for `dumpStatsFallible` to
         /// work on unresolved types.
-        /// MLUGG TODO: reconsider, because we resolve the tag type eagerly now.
         fields_len: u32,
     };
 
@@ -5742,8 +5775,7 @@ pub const Tag = enum(u8) {
         namespace: NamespaceIndex,
 
         /// An integer type which is used for the numerical value of the enum. Whether this was
-        /// user-provided or inferred by the compiler depends on the tag. Either way, the field
-        /// is populated immediately (i.e. does not require any type resolution).
+        /// user-provided or inferred by the compiler depends on the tag.
         int_tag_type: Index,
 
         fields_len: u32,
@@ -5762,13 +5794,17 @@ pub const Tag = enum(u8) {
     };
 };
 
-/// Differentiates between user-provided and compiler-generated backing types for packed aggregates.
-pub const PackedBackingMode = enum(u1) {
-    /// The backing type was explicitly provided by the user, i.e. `packed struct(T)` or `packed union(T)`.
-    /// Type resolution simply *validates* that type.
+/// Differentiates between user-provided and compiler-generated backing types for packed and tagged types.
+pub const BackingTypeMode = enum(u1) {
+    /// The backing type was explicitly provided by the user. For instance:
+    ///   union(T)
+    ///   enum(T)
+    ///   packed struct(T)
+    ///   packed union(T)
+    /// Type layout resolution will evaluate the user-provided expression and validate that type.
     explicit,
-    /// No backing type was explicitly provided by the user. Type layout resolution will populate the
-    /// backing type based on the field types; before then it is invalid (probably `.none`).
+    /// No backing type was explicitly provided by the user. Type layout resolution will populate
+    /// an inferred/generated type.
     auto,
 };
 
@@ -5852,8 +5888,6 @@ pub const SimpleValue = enum(u32) {
     void = @intFromEnum(Index.void_value),
     /// This is untyped `null`.
     null = @intFromEnum(Index.null_value),
-    /// This is the untyped empty struct/array literal: `.{}`
-    empty_tuple = @intFromEnum(Index.empty_tuple),
     true = @intFromEnum(Index.bool_true),
     false = @intFromEnum(Index.bool_false),
     @"unreachable" = @intFromEnum(Index.unreachable_value),
@@ -6395,7 +6429,7 @@ pub fn deinit(ip: *InternPool, gpa: Allocator, io: Io) void {
     ip.nav_ty_deps.deinit(gpa);
     ip.func_ies_deps.deinit(gpa);
     ip.type_layout_deps.deinit(gpa);
-    ip.type_inits_deps.deinit(gpa);
+    ip.struct_defaults_deps.deinit(gpa);
     ip.zon_file_deps.deinit(gpa);
     ip.embed_file_deps.deinit(gpa);
     ip.namespace_deps.deinit(gpa);
@@ -6544,12 +6578,10 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } },
                 .false => .{ .declared = .{
                     .zir_index = extra.data.zir_index,
-                    .arg_ty = .none,
                     .captures = .{ .owned = .empty },
                 } },
                 .true => .{ .declared = .{
                     .zir_index = extra.data.zir_index,
-                    .arg_ty = .none,
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end + 1,
@@ -6572,11 +6604,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } },
                 _ => .{ .declared = .{
                     .zir_index = extra.data.zir_index,
-                    .arg_ty = switch (item.tag) {
-                        .type_struct_packed_auto, .type_struct_packed_auto_defaults => .none,
-                        .type_struct_packed_explicit, .type_struct_packed_explicit_defaults => extra.data.backing_int_type,
-                        else => unreachable,
-                    },
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end,
@@ -6595,12 +6622,10 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } },
                 .false => .{ .declared = .{
                     .zir_index = extra.data.zir_index,
-                    .arg_ty = if (extra.data.flags.explicit_tag_type) extra.data.enum_tag_type else .none,
                     .captures = .{ .owned = .empty },
                 } },
                 .true => .{ .declared = .{
                     .zir_index = extra.data.zir_index,
-                    .arg_ty = if (extra.data.flags.explicit_tag_type) extra.data.enum_tag_type else .none,
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end + 1,
@@ -6619,11 +6644,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } },
                 _ => .{ .declared = .{
                     .zir_index = extra.data.zir_index,
-                    .arg_ty = switch (item.tag) {
-                        .type_union_packed_auto => .none,
-                        .type_union_packed_explicit => extra.data.backing_int_type,
-                        else => unreachable,
-                    },
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end,
@@ -6645,11 +6665,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } },
                 _ => .{ .declared = .{
                     .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
-                    .arg_ty = switch (item.tag) {
-                        .type_enum_auto => .none,
-                        .type_enum_explicit, .type_enum_nonexhaustive => extra.data.int_tag_type,
-                        else => unreachable,
-                    },
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end + 1,
@@ -6662,7 +6677,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             const extra = extraDataTrail(unwrapped_index.getExtra(ip), Tag.TypeOpaque, data);
             break :ns .{ .declared = .{
                 .zir_index = extra.data.zir_index,
-                .arg_ty = .none,
                 .captures = .{ .owned = .{
                     .tid = unwrapped_index.tid,
                     .start = extra.end,
@@ -6883,7 +6897,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 },
                 .type_array_small,
                 .type_vector,
-                // MLUGG TODO: is this still possible? also, i hate .only_possible_value, it should die in a fire.
                 .type_struct_packed_auto,
                 .type_struct_packed_explicit,
                 => .{ .aggregate = .{
@@ -6894,7 +6907,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 // There is only one possible value precisely due to the
                 // fact that this values slice is fully populated!
                 .type_struct,
-                // MLUGG TODO: is this still possible? also, i hate .only_possible_value, it should die in a fire.
                 .type_struct_packed_auto_defaults,
                 .type_struct_packed_explicit_defaults,
                 => {
@@ -7445,12 +7457,12 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
             });
         },
 
-        .struct_type => unreachable, // use getStructType() instead
+        .struct_type => unreachable, // instead use: getDeclaredStructType, getReifiedStructType
+        .union_type => unreachable, // instead use: getDeclaredUnionType, getReifiedUnionType
+        .enum_type => unreachable, // instead use: getDeclaredEnumType, getReifiedEnumType, getGeneratedEnumTagType
+        .opaque_type => unreachable, // instead use: getDeclaredOpaqueType
+
         .tuple_type => unreachable, // use getTupleType() instead
-        .union_type => unreachable, // use getUnionType() instead
-        .opaque_type => unreachable, // use getOpaqueType() instead
-
-        .enum_type => unreachable, // use getEnumType() instead
         .func_type => unreachable, // use getFuncType() instead
         .@"extern" => unreachable, // use getExtern() instead
         .func => unreachable, // use getFuncInstance() or getFuncDecl() instead
@@ -8072,43 +8084,180 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
     return gop.put();
 }
 
-pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+pub fn getDeclaredStructType(
+    ip: *InternPool,
+    gpa: Allocator,
+    io: Io,
+    tid: Zcu.PerThread.Id,
+    ini: struct {
+        zir_index: TrackedInst.Index,
+        captures: []const CaptureValue,
+
+        // If the value of any of the following fields would change on an incremental update, then logic
+        // in `Zcu.mapOldZirToNew` must detect that (these properties are all trivially known from ZIR)
+        // and refuse to map the type declaration. This causes `zir_index` to change so that a new type
+        // will be interned at a fresh index.
+        //
+        // In the future, it would be good to remove all of those fields from `ini`, and in fact just
+        // have a single function `getDeclaredContainer` which is suitable for all container types.
+        // However, this requires some major changes to how container types are represented in the
+        // InternPool, so that it is possible for their backing storage to be "reallocated" as needed
+        // during type resolution.
+        fields_len: u32,
+        layout: std.builtin.Type.ContainerLayout,
+        any_comptime_fields: bool,
+        any_field_defaults: bool,
+        any_field_aligns: bool,
+        packed_backing_mode: BackingTypeMode,
+    },
+) Allocator.Error!WipContainerType.Result {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .struct_type = .{ .declared = .{
+        .zir_index = ini.zir_index,
+        .captures = .{ .external = ini.captures },
+    } } });
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    const field_name_map = try ip.addMap(gpa, io, tid, ini.fields_len);
+    errdefer local.mutate.maps.len -= 1;
+
+    const is_extern = switch (ini.layout) {
+        .auto => false,
+        .@"extern" => true,
+        .@"packed" => {
+            try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeStructPacked).@"struct".fields.len +
+                ini.captures.len + // capture
+                ini.fields_len + // field_name
+                ini.fields_len + // field_type
+                (if (ini.any_field_defaults) ini.fields_len else 0)); // field_default
+
+            const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStructPacked{
+                .zir_index = ini.zir_index,
+                .captures_len = @enumFromInt(ini.captures.len),
+                .name = undefined, // set by `finish`
+                .name_nav = undefined, // set by `finish`
+                .namespace = undefined, // set by `finish`
+                .backing_int_type = .none,
+                .fields_len = ini.fields_len,
+                .field_name_map = field_name_map,
+            });
+            extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+            if (ini.any_field_defaults) {
+                extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default
+            }
+            items.appendAssumeCapacity(.{
+                .tag = switch (ini.packed_backing_mode) {
+                    .auto => if (ini.any_field_defaults) .type_struct_packed_auto_defaults else .type_struct_packed_auto,
+                    .explicit => if (ini.any_field_defaults) .type_struct_packed_explicit_defaults else .type_struct_packed_explicit,
+                },
+                .data = extra_index,
+            });
+            return .{ .wip = .{
+                .index = gop.put(),
+                .tid = tid,
+                .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name").?,
+                .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name_nav").?,
+                .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?,
+                .field_names = undefined,
+                .field_types = undefined,
+                .field_values = undefined,
+                .field_aligns = undefined,
+                .field_is_comptime_bits = undefined,
+            } };
+        },
+    };
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeStruct).@"struct".fields.len +
+        1 + // captures_len
+        ini.captures.len + // capture
+        ini.fields_len + // field_name
+        ini.fields_len + // field_type
+        (if (ini.any_field_defaults) ini.fields_len else 0) + // field_default
+        (if (ini.any_field_aligns) (ini.fields_len + 3) / 4 else 0) + // field_align
+        (if (ini.any_comptime_fields) (ini.fields_len + 31) / 32 else 0) + // field_is_comptime_bits
+        (if (!is_extern) ini.fields_len else 0) + // field_runtime_order
+        ini.fields_len); // field_offset
+
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStruct{
+        .zir_index = ini.zir_index,
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+        .fields_len = ini.fields_len,
+        .field_name_map = field_name_map,
+        .size = 0,
+        .flags = .{
+            .any_captures = if (ini.captures.len != 0) .true else .false,
+            .layout = if (is_extern) .@"extern" else .auto,
+            .any_comptime_fields = ini.any_comptime_fields,
+            .any_field_defaults = ini.any_field_defaults,
+            .any_field_aligns = ini.any_field_aligns,
+            .has_one_possible_value = false,
+            .has_no_possible_value = false,
+            .comptime_only = false,
+            .has_runtime_bits = false,
+            .alignment = .none,
+        },
+    });
+    if (ini.captures.len != 0) {
+        extra.appendAssumeCapacity(.{@intCast(ini.captures.len)}); // captures_len
+        extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture
+    }
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+    if (ini.any_field_defaults) {
+        extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default
+    }
+    if (ini.any_field_aligns) {
+        extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align
+    }
+    if (ini.any_comptime_fields) {
+        extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 31) / 32); // field_is_comptime_bits
+    }
+    if (!is_extern) {
+        extra.appendNTimesAssumeCapacity(.{@intFromEnum(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order
+    }
+    extra.appendNTimesAssumeCapacity(.{0}, ini.fields_len); // field_offset
+    items.appendAssumeCapacity(.{
+        .tag = .type_struct,
+        .data = extra_index,
+    });
+    return .{ .wip = .{
+        .index = gop.put(),
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?,
+        .field_names = undefined,
+        .field_types = undefined,
+        .field_values = undefined,
+        .field_aligns = undefined,
+        .field_is_comptime_bits = undefined,
+    } };
+}
+
+pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    zir_index: TrackedInst.Index,
+    type_hash: u64,
     fields_len: u32,
     layout: std.builtin.Type.ContainerLayout,
-    /// The following only applies if `layout == .@"packed"`; this field is ignored otherwise.
-    ///
-    /// The explicitly specified backing integer type. `.none` means the backing integer is inferred
-    /// by the compiler. Asserts that this is an integer type.
-    explicit_packed_backing_type: Index,
     any_comptime_fields: bool,
     any_field_defaults: bool,
     any_field_aligns: bool,
-    key: union(enum) {
-        declared: struct {
-            zir_index: TrackedInst.Index,
-            captures: []const CaptureValue,
-        },
-        reified: struct {
-            zir_index: TrackedInst.Index,
-            type_hash: u64,
-        },
-    },
+    /// Explicitly specified backing int type. `.none` if not packed or if backing type is inferred.
+    packed_backing_int_type: Index,
 }) Allocator.Error!WipContainerType.Result {
-    const key: Key = .{ .struct_type = switch (ini.key) {
-        .declared => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .arg_ty = switch (ini.layout) {
-                .auto, .@"extern" => .none,
-                .@"packed" => ini.explicit_packed_backing_type,
-            },
-            .captures = .{ .external = d.captures },
-        } },
-        .reified => |r| .{ .reified = .{
-            .zir_index = r.zir_index,
-            .type_hash = r.type_hash,
-        } },
-    } };
-    var gop = try ip.getOrPutKey(gpa, io, tid, key);
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .struct_type = .{ .reified = .{
+        .zir_index = ini.zir_index,
+        .type_hash = ini.type_hash,
+    } } });
     defer gop.deinit();
     if (gop == .existing) return .{ .existing = gop.existing };
 
@@ -8120,46 +8269,37 @@ pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
     const field_name_map = try ip.addMap(gpa, io, tid, ini.fields_len);
     errdefer local.mutate.maps.len -= 1;
 
-    const zir_index, const type_hash_captures_extra_len = switch (ini.key) {
-        .declared => |d| .{ d.zir_index, d.captures.len + @intFromBool(ini.layout != .@"packed") },
-        .reified => |r| .{ r.zir_index, 2 },
-    };
-
     const is_extern = switch (ini.layout) {
         .auto => false,
         .@"extern" => true,
         .@"packed" => {
             try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeStructPacked).@"struct".fields.len +
-                type_hash_captures_extra_len +
+                2 + // type_hash
                 ini.fields_len + // field_name
                 ini.fields_len + // field_type
                 (if (ini.any_field_defaults) ini.fields_len else 0)); // field_default
 
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStructPacked{
-                .zir_index = zir_index,
-                .captures_len = switch (ini.key) {
-                    .declared => |d| @enumFromInt(d.captures.len),
-                    .reified => .reified,
-                },
+                .zir_index = ini.zir_index,
+                .captures_len = .reified,
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
                 .namespace = undefined, // set by `finish`
-                .backing_int_type = ini.explicit_packed_backing_type,
+                .backing_int_type = ini.packed_backing_int_type,
                 .fields_len = ini.fields_len,
                 .field_name_map = field_name_map,
             });
-            switch (ini.key) {
-                .declared => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}),
-                .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-            }
+            _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash
             const field_names_start = extra.mutate.len;
             extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+            const field_types_start = extra.mutate.len;
             extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+            const field_defaults_start = extra.mutate.len;
             if (ini.any_field_defaults) {
                 extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default
             }
             items.appendAssumeCapacity(.{
-                .tag = switch (ini.explicit_packed_backing_type) {
+                .tag = switch (ini.packed_backing_int_type) {
                     .none => if (ini.any_field_defaults) .type_struct_packed_auto_defaults else .type_struct_packed_auto,
                     else => if (ini.any_field_defaults) .type_struct_packed_explicit_defaults else .type_struct_packed_explicit,
                 },
@@ -8171,17 +8311,20 @@ pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
                 .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name").?,
                 .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name_nav").?,
                 .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?,
-                .tag_type_index = null,
-                .fields_len = ini.fields_len,
-                .field_name_map = field_name_map,
-                .field_names_start = field_names_start,
-                .field_comptime_bits_start = null,
+                .field_names = .{ .tid = tid, .start = field_names_start, .len = ini.fields_len },
+                .field_types = .{ .tid = tid, .start = field_types_start, .len = ini.fields_len },
+                .field_values = if (ini.any_field_defaults)
+                    .{ .tid = tid, .start = field_defaults_start, .len = ini.fields_len }
+                else
+                    undefined,
+                .field_aligns = undefined,
+                .field_is_comptime_bits = undefined,
             } };
         },
     };
 
     try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeStruct).@"struct".fields.len +
-        type_hash_captures_extra_len +
+        2 + // type_hash
         ini.fields_len + // field_name
         ini.fields_len + // field_type
         (if (ini.any_field_defaults) ini.fields_len else 0) + // field_default
@@ -8191,7 +8334,7 @@ pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
         ini.fields_len); // field_offset
 
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStruct{
-        .zir_index = zir_index,
+        .zir_index = ini.zir_index,
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
         .namespace = undefined, // set by `finish`
@@ -8199,10 +8342,7 @@ pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
         .field_name_map = field_name_map,
         .size = 0,
         .flags = .{
-            .any_captures = switch (ini.key) {
-                .declared => |d| if (d.captures.len != 0) .true else .false,
-                .reified => .reified,
-            },
+            .any_captures = .reified,
             .layout = if (is_extern) .@"extern" else .auto,
             .any_comptime_fields = ini.any_comptime_fields,
             .any_field_defaults = ini.any_field_defaults,
@@ -8210,30 +8350,27 @@ pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
             .has_one_possible_value = false,
             .has_no_possible_value = false,
             .comptime_only = false,
+            .has_runtime_bits = false,
             .alignment = .none,
         },
     });
-    switch (ini.key) {
-        .declared => |d| if (d.captures.len != 0) {
-            extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)});
-        },
-        .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-    }
+    _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash
     const field_names_start = extra.mutate.len;
     extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+    const field_types_start = extra.mutate.len;
     extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+    const field_defaults_start = extra.mutate.len;
     if (ini.any_field_defaults) {
         extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default
     }
+    const field_aligns_start = extra.mutate.len;
     if (ini.any_field_aligns) {
         extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align
     }
-    const field_comptime_bits_start: ?u32 = if (ini.any_comptime_fields) start: {
-        const start = extra.mutate.len;
+    const field_is_comptime_bits_start = extra.mutate.len;
+    if (ini.any_comptime_fields) {
         extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 31) / 32); // field_is_comptime_bits
-        break :start start;
-    } else null;
+    }
     if (!is_extern) {
         extra.appendNTimesAssumeCapacity(.{@intFromEnum(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order
     }
@@ -8248,58 +8385,174 @@ pub fn getStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
         .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name").?,
         .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name_nav").?,
         .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?,
-        .tag_type_index = null,
+        .field_names = .{ .tid = tid, .start = field_names_start, .len = ini.fields_len },
+        .field_types = .{ .tid = tid, .start = field_types_start, .len = ini.fields_len },
+        .field_values = if (ini.any_field_defaults)
+            .{ .tid = tid, .start = field_defaults_start, .len = ini.fields_len }
+        else
+            undefined,
+        .field_aligns = if (ini.any_field_aligns)
+            .{ .tid = tid, .start = field_aligns_start, .len = ini.fields_len }
+        else
+            undefined,
+        .field_is_comptime_bits = if (ini.any_comptime_fields)
+            .{ .tid = tid, .start = field_is_comptime_bits_start, .len = (ini.fields_len + 31) / 32 }
+        else
+            undefined,
+    } };
+}
+
+pub fn getDeclaredUnionType(
+    ip: *InternPool,
+    gpa: Allocator,
+    io: Io,
+    tid: Zcu.PerThread.Id,
+    ini: struct {
+        zir_index: TrackedInst.Index,
+        captures: []const CaptureValue,
+
+        // If the value of any of the following fields would change on an incremental update, then logic
+        // in `Zcu.mapOldZirToNew` must detect that (these properties are all trivially known from ZIR)
+        // and refuse to map the type declaration. This causes `zir_index` to change so that a new type
+        // will be interned at a fresh index.
+        //
+        // In the future, it would be good to remove all of those fields from `ini`, and in fact just
+        // have a single function `getDeclaredContainer` which is suitable for all container types.
+        // However, this requires some major changes to how container types are represented in the
+        // InternPool, so that it is possible for their backing storage to be "reallocated" as needed
+        // during type resolution.
+        fields_len: u32,
+        layout: std.builtin.Type.ContainerLayout,
+        any_field_aligns: bool,
+        runtime_tag: LoadedUnionType.RuntimeTag,
+        enum_tag_mode: BackingTypeMode,
+        packed_backing_mode: BackingTypeMode,
+    },
+) Allocator.Error!WipContainerType.Result {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .union_type = .{ .declared = .{
+        .zir_index = ini.zir_index,
+        .captures = .{ .external = ini.captures },
+    } } });
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    const is_extern = switch (ini.layout) {
+        .auto => false,
+        .@"extern" => true,
+        .@"packed" => {
+            try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnionPacked).@"struct".fields.len +
+                ini.captures.len + // capture
+                ini.fields_len); // field_type
+
+            const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnionPacked{
+                .zir_index = ini.zir_index,
+                .captures_len = @enumFromInt(ini.captures.len),
+                .name = undefined, // set by `finish`
+                .name_nav = undefined, // set by `finish`
+                .namespace = undefined, // set by `finish`
+                .backing_int_type = .none,
+                .enum_tag_type = .none,
+                .fields_len = ini.fields_len,
+            });
+            extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+            items.appendAssumeCapacity(.{
+                .tag = switch (ini.packed_backing_mode) {
+                    .auto => .type_union_packed_auto,
+                    .explicit => .type_union_packed_explicit,
+                },
+                .data = extra_index,
+            });
+            return .{ .wip = .{
+                .index = gop.put(),
+                .tid = tid,
+                .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name").?,
+                .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name_nav").?,
+                .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "namespace").?,
+                .field_names = undefined,
+                .field_types = undefined,
+                .field_values = undefined,
+                .field_aligns = undefined,
+                .field_is_comptime_bits = undefined,
+            } };
+        },
+    };
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnion).@"struct".fields.len +
+        1 + // captures_len
+        ini.captures.len + // capture
+        ini.fields_len + // field_type
+        (if (ini.any_field_aligns) (ini.fields_len + 3) / 4 else 0)); // field_align
+
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnion{
+        .zir_index = ini.zir_index,
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+        .enum_tag_type = .none,
         .fields_len = ini.fields_len,
-        .field_name_map = field_name_map,
-        .field_names_start = field_names_start,
-        .field_comptime_bits_start = field_comptime_bits_start,
+        .size = 0,
+        .padding = 0,
+        .flags = .{
+            .any_captures = if (ini.captures.len != 0) .true else .false,
+            .enum_tag_mode = ini.enum_tag_mode,
+            .layout = if (is_extern) .@"extern" else .auto,
+            .any_field_aligns = ini.any_field_aligns,
+            .runtime_tag = ini.runtime_tag,
+            .has_one_possible_value = false,
+            .has_no_possible_value = false,
+            .comptime_only = false,
+            .has_runtime_bits = false,
+            .alignment = .none,
+        },
+    });
+    if (ini.captures.len > 0) {
+        extra.appendAssumeCapacity(.{@intCast(ini.captures.len)}); // captures_len
+        extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture
+    }
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+    if (ini.any_field_aligns) {
+        extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align
+    }
+    items.appendAssumeCapacity(.{
+        .tag = .type_union,
+        .data = extra_index,
+    });
+    return .{ .wip = .{
+        .index = gop.put(),
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?,
+        .field_names = undefined,
+        .field_types = undefined,
+        .field_values = undefined,
+        .field_aligns = undefined,
+        .field_is_comptime_bits = undefined,
     } };
 }
 
-pub fn getUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    zir_index: TrackedInst.Index,
+    type_hash: u64,
     fields_len: u32,
     layout: std.builtin.Type.ContainerLayout,
-    /// The explicitly specified backing integer type for a `packed union`.
-    /// `.none` means the backing integer is inferred by the compiler. If set,
-    /// must be an integer type. If the union is not packed, must be `.none`.
-    explicit_packed_backing_type: Index,
+    any_field_aligns: bool,
     runtime_tag: LoadedUnionType.RuntimeTag,
-    /// `true` for `union(T)`, but `false` for anything else, including `union(enum(T))`.
-    have_explicit_enum_tag: bool,
-    any_field_aligns: bool,
-    key: union(enum) {
-        declared: struct {
-            zir_index: TrackedInst.Index,
-            captures: []const CaptureValue,
-            /// This is the `T` in one of the following:
-            /// * `union(T)` (enum tag type)
-            /// * `union(enum(T))` (int tag type)
-            /// * `packed union(T)` (int backing type)
-            /// Or `.none` otherwise.
-            arg_ty: InternPool.Index,
-        },
-        reified: struct {
-            zir_index: TrackedInst.Index,
-            type_hash: u64,
-        },
-    },
+    /// Explicitly specified enum tag type. `.none` if `runtime_tag != .tagged`.
+    enum_tag_type: Index,
+    /// Explicitly specified backing int type. `.none` if not packed or if backing type is inferred.
+    packed_backing_int_type: Index,
 }) Allocator.Error!WipContainerType.Result {
-    if (ini.explicit_packed_backing_type != .none) {
-        assert(ip.zigTypeTag(ini.explicit_packed_backing_type) == .int);
-        if (ini.key == .declared) assert(ini.key.declared.arg_ty == ini.explicit_packed_backing_type);
-    }
-    const key: Key = .{ .union_type = switch (ini.key) {
-        .declared => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .arg_ty = d.arg_ty,
-            .captures = .{ .external = d.captures },
-        } },
-        .reified => |r| .{ .reified = .{
-            .zir_index = r.zir_index,
-            .type_hash = r.type_hash,
-        } },
-    } };
-    var gop = try ip.getOrPutKey(gpa, io, tid, key);
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .union_type = .{ .reified = .{
+        .zir_index = ini.zir_index,
+        .type_hash = ini.type_hash,
+    } } });
     defer gop.deinit();
     if (gop == .existing) return .{ .existing = gop.existing };
 
@@ -8308,98 +8561,86 @@ pub fn getUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.
     const extra = local.getMutableExtra(gpa, io);
     try items.ensureUnusedCapacity(1);
 
-    const zir_index, const type_hash_captures_extra_len = switch (ini.key) {
-        .declared => |d| .{ d.zir_index, d.captures.len + @intFromBool(ini.layout != .@"packed") },
-        .reified => |r| .{ r.zir_index, 2 },
-    };
-
     const is_extern = switch (ini.layout) {
         .auto => false,
         .@"extern" => true,
         .@"packed" => {
             try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnionPacked).@"struct".fields.len +
-                type_hash_captures_extra_len +
+                2 + // type_hash
+                ini.fields_len + // reified_field_name
                 ini.fields_len); // field_type
 
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnionPacked{
-                .zir_index = zir_index,
-                .captures_len = switch (ini.key) {
-                    .declared => |d| @enumFromInt(d.captures.len),
-                    .reified => .reified,
-                },
+                .zir_index = ini.zir_index,
+                .captures_len = .reified,
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
                 .namespace = undefined, // set by `finish`
-                .backing_int_type = ini.explicit_packed_backing_type,
-                .enum_tag_type = .none, // set by `setTagType`
+                .backing_int_type = ini.packed_backing_int_type,
+                .enum_tag_type = .none,
                 .fields_len = ini.fields_len,
             });
-            switch (ini.key) {
-                .declared => |d| extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}),
-                .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-            }
+            _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash
+            const field_names_start = extra.mutate.len;
+            extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // reified_field_name
+            const field_types_start = extra.mutate.len;
             extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
             items.appendAssumeCapacity(.{
-                .tag = switch (ini.explicit_packed_backing_type) {
+                .tag = switch (ini.packed_backing_int_type) {
                     .none => .type_union_packed_auto,
                     else => .type_union_packed_explicit,
                 },
                 .data = extra_index,
             });
-            return .{
-                .wip = .{
-                    .index = gop.put(),
-                    .tid = tid,
-                    .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name").?,
-                    .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name_nav").?,
-                    .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "namespace").?,
-                    .tag_type_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "enum_tag_type").?,
-                    .fields_len = 0, // the fields come from the enum, so nothing to set
-                    .field_name_map = undefined,
-                    .field_names_start = undefined,
-                    .field_comptime_bits_start = undefined,
-                },
-            };
+            return .{ .wip = .{
+                .index = gop.put(),
+                .tid = tid,
+                .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name").?,
+                .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "name_nav").?,
+                .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnionPacked, "namespace").?,
+                .field_names = .{ .tid = tid, .start = field_names_start, .len = ini.fields_len },
+                .field_types = .{ .tid = tid, .start = field_types_start, .len = ini.fields_len },
+                .field_values = undefined,
+                .field_aligns = undefined,
+                .field_is_comptime_bits = undefined,
+            } };
         },
     };
 
     try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeUnion).@"struct".fields.len +
-        type_hash_captures_extra_len +
+        2 + // type_hash
+        ini.fields_len + // reified_field_name
         ini.fields_len + // field_type
         (if (ini.any_field_aligns) (ini.fields_len + 3) / 4 else 0)); // field_align
 
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnion{
-        .zir_index = zir_index,
+        .zir_index = ini.zir_index,
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
         .namespace = undefined, // set by `finish`
-        .enum_tag_type = .none, // set by `setTagType`
+        .enum_tag_type = ini.enum_tag_type,
         .fields_len = ini.fields_len,
         .size = 0,
         .padding = 0,
         .flags = .{
-            .any_captures = switch (ini.key) {
-                .declared => |d| if (d.captures.len != 0) .true else .false,
-                .reified => .reified,
-            },
-            .explicit_tag_type = ini.have_explicit_enum_tag,
+            .any_captures = .reified,
+            .enum_tag_mode = if (ini.enum_tag_type == .none) .auto else .explicit,
             .layout = if (is_extern) .@"extern" else .auto,
             .any_field_aligns = ini.any_field_aligns,
             .runtime_tag = ini.runtime_tag,
             .has_one_possible_value = false,
             .has_no_possible_value = false,
             .comptime_only = false,
+            .has_runtime_bits = false,
             .alignment = .none,
         },
     });
-    switch (ini.key) {
-        .declared => |d| if (d.captures.len != 0) {
-            extra.appendAssumeCapacity(.{@intCast(d.captures.len)});
-            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)});
-        },
-        .reified => |r| _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)),
-    }
+    _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash));
+    const field_names_start = extra.mutate.len;
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // reified_field_name
+    const field_types_start = extra.mutate.len;
     extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type
+    const field_aligns_start = extra.mutate.len;
     if (ini.any_field_aligns) {
         extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align
     }
@@ -8407,53 +8648,124 @@ pub fn getUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.
         .tag = .type_union,
         .data = extra_index,
     });
-    return .{
-        .wip = .{
-            .index = gop.put(),
-            .tid = tid,
-            .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name").?,
-            .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name_nav").?,
-            .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?,
-            .tag_type_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "enum_tag_type").?,
-            .fields_len = 0, // the fields come from the enum, so nothing to set
-            .field_name_map = undefined,
-            .field_names_start = undefined,
-            .field_comptime_bits_start = undefined,
-        },
-    };
+    return .{ .wip = .{
+        .index = gop.put(),
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?,
+        .field_names = .{ .tid = tid, .start = field_names_start, .len = ini.fields_len },
+        .field_types = .{ .tid = tid, .start = field_types_start, .len = ini.fields_len },
+        .field_values = undefined,
+        .field_aligns = if (ini.any_field_aligns)
+            .{ .tid = tid, .start = field_aligns_start, .len = ini.fields_len }
+        else
+            undefined,
+        .field_is_comptime_bits = undefined,
+    } };
 }
 
-pub fn getEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
-    fields_len: u32,
-    /// For `enum(T)` or `union(enum(T))`, this is `T`. Asserts `T` is an integer type.
-    /// Otherwise, `.none`.
-    explicit_int_tag_type: Index,
-    nonexhaustive: bool,
-    key: union(enum) {
-        declared: struct {
-            zir_index: TrackedInst.Index,
-            captures: []const CaptureValue,
-        },
-        reified: struct {
-            zir_index: TrackedInst.Index,
-            type_hash: u64,
-        },
-        generated_union_tag: Index,
+pub fn getDeclaredEnumType(
+    ip: *InternPool,
+    gpa: Allocator,
+    io: Io,
+    tid: Zcu.PerThread.Id,
+    ini: struct {
+        zir_index: TrackedInst.Index,
+        captures: []const CaptureValue,
+
+        // If the value of any of the following fields would change on an incremental update, then logic
+        // in `Zcu.mapOldZirToNew` must detect that (these properties are all trivially known from ZIR)
+        // and refuse to map the type declaration. This causes `zir_index` to change so that a new type
+        // will be interned at a fresh index.
+        //
+        // In the future, it would be good to remove all of those fields from `ini`, and in fact just
+        // have a single function `getDeclaredContainer` which is suitable for all container types.
+        // However, this requires some major changes to how container types are represented in the
+        // InternPool, so that it is possible for their backing storage to be "reallocated" as needed
+        // during type resolution.
+        fields_len: u32,
+        nonexhaustive: bool,
+        /// For `enum(T)` this is `.explicit`. Otherwise this is `.none`.
+        int_tag_mode: BackingTypeMode,
     },
-}) Allocator.Error!WipContainerType.Result {
-    const key: Key = .{ .enum_type = switch (ini.key) {
-        .declared => |d| .{ .declared = .{
-            .zir_index = d.zir_index,
-            .arg_ty = ini.explicit_int_tag_type,
-            .captures = .{ .external = d.captures },
-        } },
-        .reified => |r| .{ .reified = .{
-            .zir_index = r.zir_index,
-            .type_hash = r.type_hash,
-        } },
-        .generated_union_tag => |u| .{ .generated_union_tag = u },
+) Allocator.Error!WipContainerType.Result {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .enum_type = .{ .declared = .{
+        .zir_index = ini.zir_index,
+        .captures = .{ .external = ini.captures },
+    } } });
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    const tag: Tag, const have_values: bool = if (ini.nonexhaustive)
+        .{ .type_enum_nonexhaustive, true }
+    else if (ini.int_tag_mode == .explicit)
+        .{ .type_enum_explicit, true }
+    else
+        .{ .type_enum_auto, false };
+
+    const field_name_map = try ip.addMap(gpa, io, tid, ini.fields_len);
+    errdefer local.mutate.maps.len -= 1;
+
+    const field_value_map = if (have_values) try ip.addMap(gpa, io, tid, ini.fields_len) else undefined;
+    errdefer local.mutate.maps.len -= @intFromBool(have_values);
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeEnum).@"struct".fields.len +
+        1 + // zir_index
+        ini.captures.len + // capture
+        @intFromBool(have_values) + // field_value_map
+        ini.fields_len + // field_name
+        (if (have_values) ini.fields_len else 0)); // field_value
+
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
+        .captures_len = @enumFromInt(ini.captures.len),
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+        .int_tag_type = .none,
+        .fields_len = ini.fields_len,
+        .field_name_map = field_name_map,
+    });
+    extra.appendAssumeCapacity(.{@intFromEnum(ini.zir_index)}); // zir_index
+    extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture
+    if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)}); // field_value_map
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+    if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value
+    items.appendAssumeCapacity(.{
+        .tag = tag,
+        .data = extra_index,
+    });
+    return .{ .wip = .{
+        .index = gop.put(),
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "namespace").?,
+        .field_names = undefined,
+        .field_types = undefined,
+        .field_values = undefined,
+        .field_aligns = undefined,
+        .field_is_comptime_bits = undefined,
     } };
-    var gop = try ip.getOrPutKey(gpa, io, tid, key);
+}
+
+pub fn getReifiedEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    zir_index: TrackedInst.Index,
+    type_hash: u64,
+    fields_len: u32,
+    nonexhaustive: bool,
+    /// Explicitly specified int tag type, or `.none` if the int tag type is inferred.
+    int_tag_type: Index,
+}) Allocator.Error!WipContainerType.Result {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .enum_type = .{ .reified = .{
+        .zir_index = ini.zir_index,
+        .type_hash = ini.type_hash,
+    } } });
     defer gop.deinit();
     if (gop == .existing) return .{ .existing = gop.existing };
 
@@ -8464,7 +8776,7 @@ pub fn getEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.I
 
     const tag: Tag, const have_values: bool = if (ini.nonexhaustive)
         .{ .type_enum_nonexhaustive, true }
-    else if (ini.explicit_int_tag_type != .none)
+    else if (ini.int_tag_type != .none)
         .{ .type_enum_explicit, true }
     else
         .{ .type_enum_auto, false };
@@ -8476,47 +8788,100 @@ pub fn getEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.I
     errdefer local.mutate.maps.len -= @intFromBool(have_values);
 
     try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeEnum).@"struct".fields.len +
-        switch (ini.key) {
-            .declared => |d| 1 + d.captures.len, // `zir_index` and `capture`
-            .reified => 3, // `zir_index` and `type_hash`
-            .generated_union_tag => 1, // owner_union
-        } +
+        1 + // zir_index
+        2 + // type_hash
+        @intFromBool(have_values) + // field_value_map
+        ini.fields_len + // field_name
+        (if (have_values) ini.fields_len else 0)); // field_value
+
+    const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
+        .captures_len = .reified,
+        .name = undefined, // set by `finish`
+        .name_nav = undefined, // set by `finish`
+        .namespace = undefined, // set by `finish`
+        .int_tag_type = ini.int_tag_type,
+        .fields_len = ini.fields_len,
+        .field_name_map = field_name_map,
+    });
+    extra.appendAssumeCapacity(.{@intFromEnum(ini.zir_index)}); // zir_index
+    _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash
+    if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)}); // field_value_map
+    const field_names_start = extra.mutate.len;
+    extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
+    const field_values_start = extra.mutate.len;
+    if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value
+    items.appendAssumeCapacity(.{
+        .tag = tag,
+        .data = extra_index,
+    });
+    return .{ .wip = .{
+        .index = gop.put(),
+        .tid = tid,
+        .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name").?,
+        .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name_nav").?,
+        .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "namespace").?,
+        .field_names = .{ .tid = tid, .start = field_names_start, .len = ini.fields_len },
+        .field_types = undefined,
+        .field_values = if (have_values)
+            .{ .tid = tid, .start = field_values_start, .len = ini.fields_len }
+        else
+            undefined,
+        .field_aligns = undefined,
+        .field_is_comptime_bits = undefined,
+    } };
+}
+
+pub fn getGeneratedEnumTagType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+    /// The union type for which this enum is a generated tag.
+    union_type: Index,
+    /// For `union(enum(T))` this is `.explicit`. Otherwise this is `.none`.
+    int_tag_mode: BackingTypeMode,
+    fields_len: u32,
+}) Allocator.Error!WipContainerType.Result {
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .enum_type = .{ .generated_union_tag = ini.union_type } });
+    defer gop.deinit();
+    if (gop == .existing) return .{ .existing = gop.existing };
+
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
+    const field_name_map = try ip.addMap(gpa, io, tid, ini.fields_len);
+    errdefer local.mutate.maps.len -= 1;
+
+    const have_values = switch (ini.int_tag_mode) {
+        .explicit => true,
+        .auto => false,
+    };
+
+    const field_value_map = if (have_values) try ip.addMap(gpa, io, tid, ini.fields_len) else undefined;
+    errdefer local.mutate.maps.len -= @intFromBool(have_values);
+
+    try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeEnum).@"struct".fields.len +
+        1 + // owner_union
         @intFromBool(have_values) + // field_value_map
         ini.fields_len + // field_name
         (if (have_values) ini.fields_len else 0)); // field_value
 
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
-        .captures_len = switch (ini.key) {
-            .declared => |d| @enumFromInt(d.captures.len),
-            .reified => .reified,
-            .generated_union_tag => .generated_union_tag,
-        },
+        .captures_len = .generated_union_tag,
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
         .namespace = undefined, // set by `finish`
-        .int_tag_type = ini.explicit_int_tag_type,
+        .int_tag_type = .none,
         .fields_len = ini.fields_len,
         .field_name_map = field_name_map,
     });
-    switch (ini.key) {
-        .declared => |d| {
-            extra.appendAssumeCapacity(.{@intFromEnum(d.zir_index)}); // zir_index
-            extra.appendSliceAssumeCapacity(.{@ptrCast(d.captures)}); // capture
-        },
-        .reified => |r| {
-            extra.appendAssumeCapacity(.{@intFromEnum(r.zir_index)}); // zir_index
-            _ = addExtraAssumeCapacity(extra, PackedU64.init(r.type_hash)); // type_hash
-        },
-        .generated_union_tag => |owner_union| {
-            extra.appendAssumeCapacity(.{@intFromEnum(owner_union)}); // owner_union
-        },
-    }
+    extra.appendAssumeCapacity(.{@intFromEnum(ini.union_type)}); // owner_union
     if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)});
-    const field_names_start = extra.mutate.len;
     extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name
     if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value
     items.appendAssumeCapacity(.{
-        .tag = tag,
+        .tag = switch (ini.int_tag_mode) {
+            .auto => .type_enum_auto,
+            .explicit => .type_enum_explicit,
+        },
         .data = extra_index,
     });
     return .{ .wip = .{
@@ -8525,22 +8890,21 @@ pub fn getEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.I
         .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name").?,
         .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "name_nav").?,
         .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "namespace").?,
-        .tag_type_index = extra_index + std.meta.fieldIndex(Tag.TypeEnum, "int_tag_type").?,
-        .fields_len = ini.fields_len,
-        .field_name_map = field_name_map,
-        .field_names_start = field_names_start,
-        .field_comptime_bits_start = null,
+        .field_names = undefined,
+        .field_types = undefined,
+        .field_values = undefined,
+        .field_aligns = undefined,
+        .field_is_comptime_bits = undefined,
     } };
 }
 
-pub fn getOpaqueType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
+pub fn getDeclaredOpaqueType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, ini: struct {
     zir_index: TrackedInst.Index,
     captures: []const CaptureValue,
 }) Allocator.Error!WipContainerType.Result {
     var gop = try ip.getOrPutKey(gpa, io, tid, .{ .opaque_type = .{ .declared = .{
         .zir_index = ini.zir_index,
         .captures = .{ .external = ini.captures },
-        .arg_ty = .none,
     } } });
     defer gop.deinit();
     if (gop == .existing) return .{ .existing = gop.existing };
@@ -8569,11 +8933,11 @@ pub fn getOpaqueType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread
         .type_name_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name").?,
         .name_nav_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name_nav").?,
         .namespace_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "namespace").?,
-        .tag_type_index = null,
-        .fields_len = 0,
-        .field_name_map = undefined,
-        .field_names_start = undefined,
-        .field_comptime_bits_start = undefined,
+        .field_names = undefined,
+        .field_types = undefined,
+        .field_values = undefined,
+        .field_aligns = undefined,
+        .field_is_comptime_bits = undefined,
     } };
 }
 
@@ -8584,12 +8948,15 @@ pub const WipContainerType = struct {
     name_nav_index: u32,
     namespace_index: u32,
 
-    tag_type_index: ?u32,
-
-    fields_len: u32,
-    field_name_map: MapIndex,
-    field_names_start: u32,
-    field_comptime_bits_start: ?u32,
+    // These fields are only populated when creating reified types, because reified types populate
+    // field information immediately, with type resolution only handling validation. This is in
+    // contrast to declared types, where field information is populated by the type resolution
+    // process evaluating ZIR expressions.
+    field_names: NullTerminatedString.Slice,
+    field_types: Index.Slice,
+    field_values: Index.Slice,
+    field_aligns: Alignment.Slice,
+    field_is_comptime_bits: LoadedStructType.ComptimeBits,
 
     pub fn setName(
         wip: WipContainerType,
@@ -8605,48 +8972,6 @@ pub const WipContainerType = struct {
         extra_items[wip.name_nav_index] = @intFromEnum(name_nav);
     }
 
-    pub fn setTagType(
-        wip: WipContainerType,
-        ip: *InternPool,
-        tag_ty: Index,
-    ) void {
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        const extra_items = extra.view().items(.@"0");
-        const i = wip.tag_type_index.?;
-        const old_val: InternPool.Index = @enumFromInt(extra_items[i]);
-        assert(old_val == .none);
-        assert(tag_ty != .none);
-        extra_items[i] = @intFromEnum(tag_ty);
-    }
-
-    /// Returns the already-existing field with the same name, if any.
-    pub fn nextField(
-        wip: WipContainerType,
-        ip: *InternPool,
-        name: NullTerminatedString,
-        marked_comptime: bool,
-    ) ?u32 {
-        assert(wip.fields_len > 0);
-        const extra = ip.getLocalShared(wip.tid).extra.acquire();
-        const extra_items = extra.view().items(.@"0");
-        const map = wip.field_name_map.get(ip);
-        const field_idx = map.count();
-        assert(field_idx < wip.fields_len);
-        const names: []NullTerminatedString = @ptrCast(extra_items[wip.field_names_start..][0..wip.fields_len]);
-        const adapter: NullTerminatedString.Adapter = .{ .strings = names[0..field_idx] };
-        const gop = map.getOrPutAssumeCapacityAdapted(name, adapter);
-        if (gop.found_existing) return @intCast(gop.index);
-        names[field_idx] = name;
-        if (wip.field_comptime_bits_start) |start_idx| {
-            if (marked_comptime) {
-                extra_items[start_idx + field_idx / 32] |= @as(u32, 1) << @intCast(field_idx % 32);
-            }
-        } else {
-            assert(!marked_comptime);
-        }
-        return null;
-    }
-
     pub fn finish(
         wip: WipContainerType,
         ip: *InternPool,
@@ -8657,14 +8982,6 @@ pub const WipContainerType = struct {
 
         extra_items[wip.namespace_index] = @intFromEnum(namespace);
 
-        if (wip.fields_len > 0) {
-            assert(wip.field_name_map.get(ip).count() == wip.fields_len);
-        }
-        if (wip.tag_type_index) |i| {
-            const tag_ty: Index = @enumFromInt(extra_items[i]);
-            assert(tag_ty != .none);
-        }
-
         return wip.index;
     }
 
@@ -9504,19 +9821,6 @@ fn addStringsToMap(
     }
 }
 
-fn addIndexesToMap(
-    ip: *InternPool,
-    map_index: MapIndex,
-    indexes: []const Index,
-) void {
-    const map = map_index.get(ip);
-    const adapter: Index.Adapter = .{ .indexes = indexes };
-    for (indexes) |index| {
-        const gop = map.getOrPutAssumeCapacityAdapted(index, adapter);
-        assert(!gop.found_existing);
-    }
-}
-
 fn addMap(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, cap: usize) Allocator.Error!MapIndex {
     const maps = ip.getLocal(tid).getMutableMaps(gpa, io);
     const unwrapped: MapIndex.Unwrapped = .{ .tid = tid, .index = maps.mutate.len };
@@ -10260,10 +10564,78 @@ pub fn dump(ip: *const InternPool) void {
     const stderr = std.debug.lockStderr(&buffer);
     defer std.debug.unlockStderr();
     const w = &stderr.file_writer.interface;
+    dumpDependencyStatsFallible(ip, w) catch return;
     dumpStatsFallible(ip, w, std.heap.page_allocator) catch return;
     dumpAllFallible(ip, w) catch return;
 }
 
+fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
+    const dep_entries_len = ip.dep_entries.items.len - ip.free_dep_entries.items.len;
+    const src_hash_deps_len = ip.src_hash_deps.count();
+    const nav_val_deps_len = ip.nav_val_deps.count();
+    const nav_ty_deps_len = ip.nav_ty_deps.count();
+    const func_ies_deps_len = ip.func_ies_deps.count();
+    const type_layout_deps_len = ip.type_layout_deps.count();
+    const struct_defaults_deps_len = ip.struct_defaults_deps.count();
+    const zon_file_deps_len = ip.zon_file_deps.count();
+    const embed_file_deps_len = ip.embed_file_deps.count();
+    const namespace_deps_len = ip.namespace_deps.count();
+    const namespace_name_deps_len = ip.namespace_name_deps.count();
+    const dep_entries_size = dep_entries_len * @sizeOf(DepEntry);
+    const src_hash_deps_size = src_hash_deps_len * 8;
+    const nav_val_deps_size = nav_val_deps_len * 8;
+    const nav_ty_deps_size = nav_ty_deps_len * 8;
+    const func_ies_deps_size = func_ies_deps_len * 8;
+    const type_layout_deps_size = type_layout_deps_len * 8;
+    const struct_defaults_deps_size = struct_defaults_deps_len * 8;
+    const zon_file_deps_size = zon_file_deps_len * 8;
+    const embed_file_deps_size = embed_file_deps_len * 8;
+    const namespace_deps_size = namespace_deps_len * 8;
+    const namespace_name_deps_size = namespace_name_deps_len * (@sizeOf(NamespaceNameKey) + 4);
+
+    try w.print(
+        \\InternPool dependencies: {d} bytes
+        \\  {d} entries: {d} bytes
+        \\  {d} src_hash: {d} bytes
+        \\  {d} nav_val: {d} bytes
+        \\  {d} nav_ty: {d} bytes
+        \\  {d} func_ies: {d} bytes
+        \\  {d} type_layout: {d} bytes
+        \\  {d} struct_defaults: {d} bytes
+        \\  {d} zon_file: {d} bytes
+        \\  {d} embed_file: {d} bytes
+        \\  {d} namespace: {d} bytes
+        \\  {d} namespace_name: {d} bytes
+        \\
+    , .{
+        dep_entries_size + src_hash_deps_size + nav_val_deps_size + nav_ty_deps_size +
+            func_ies_deps_size + type_layout_deps_size + struct_defaults_deps_size + zon_file_deps_size +
+            embed_file_deps_size + namespace_deps_size + namespace_name_deps_size,
+        dep_entries_len,
+        dep_entries_size,
+        src_hash_deps_len,
+        src_hash_deps_size,
+        nav_val_deps_len,
+        nav_val_deps_size,
+        nav_ty_deps_len,
+        nav_ty_deps_size,
+        func_ies_deps_len,
+        func_ies_deps_size,
+        type_layout_deps_len,
+        type_layout_deps_size,
+        struct_defaults_deps_len,
+        struct_defaults_deps_size,
+        zon_file_deps_len,
+        zon_file_deps_size,
+        embed_file_deps_len,
+        embed_file_deps_size,
+        namespace_deps_len,
+        namespace_deps_size,
+        namespace_name_deps_len,
+        namespace_name_deps_size,
+    });
+}
+
 fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !void {
     var items_len: usize = 0;
     var extra_len: usize = 0;
@@ -10278,10 +10650,10 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
     const limbs_size = 8 * limbs_len;
 
     // TODO: map overhead size is not taken into account
-    const total_size = @sizeOf(InternPool) + items_size + extra_size + limbs_size;
+    const total_size = items_size + extra_size + limbs_size;
 
-    std.debug.print(
-        \\InternPool size: {d} bytes
+    try w.print(
+        \\InternPool values: {d} bytes
         \\  {d} items: {d} bytes
         \\  {d} extra: {d} bytes
         \\  {d} limbs: {d} bytes
@@ -10302,6 +10674,8 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
     };
     var counts = std.AutoArrayHashMap(Tag, TagStats).init(arena);
     for (ip.locals) |*local| {
+        // Early check for length 0, because `view()` is invalid if capacity is 0
+        if (local.mutate.items.len == 0) continue;
         const items = local.shared.items.view().slice();
         const extra_list = local.shared.extra;
         const extra_items = extra_list.view().items(.@"0");
@@ -10562,6 +10936,8 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
 
 fn dumpAllFallible(ip: *const InternPool, w: *Io.Writer) anyerror!void {
     for (ip.locals, 0..) |*local, tid| {
+        // Early check for length 0, because `view()` is invalid if capacity is 0
+        if (local.mutate.items.len == 0) continue;
         const items = local.shared.items.view();
         for (
             items.items(.tag)[0..local.mutate.items.len],
@@ -11981,22 +12357,42 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index {
     };
 }
 
-/// Returns the already-existing field with the same name, if any.
+/// Puts `name` into `names_slice` at the next index (that being the current length of `map`).
+/// Also inserts the name into `map`. If there is an existing field with this name, its index
+/// is returned. Otherwise, `null` is returned.
 pub fn addFieldName(
     ip: *InternPool,
-    extra: Local.Extra,
-    names_map: MapIndex,
-    names_start: u32,
+    names: NullTerminatedString.Slice,
+    map: MapIndex,
     name: NullTerminatedString,
 ) ?u32 {
-    const extra_items = extra.view().items(.@"0");
-    const map = names_map.get(ip);
-    const field_index = map.count();
-    const strings = extra_items[names_start..][0..field_index];
-    const adapter: NullTerminatedString.Adapter = .{ .strings = @ptrCast(strings) };
-    const gop = map.getOrPutAssumeCapacityAdapted(name, adapter);
+    const m = map.get(ip);
+    const field_idx = m.count();
+    const names_slice = names.get(ip);
+    names_slice[field_idx] = name;
+    const adapter: NullTerminatedString.Adapter = .{ .strings = names_slice[0..field_idx] };
+    const gop = m.getOrPutAssumeCapacityAdapted(name, adapter);
     if (gop.found_existing) return @intCast(gop.index);
-    extra_items[names_start + field_index] = @intFromEnum(name);
+    assert(gop.index == field_idx);
+    return null;
+}
+
+/// Like `addFieldName`, but instead of adding a field name to a struct, union, or enum, adds a
+/// field tag value for an enum.
+pub fn addFieldTagValue(
+    ip: *InternPool,
+    values: Index.Slice,
+    map: MapIndex,
+    value: Index,
+) ?u32 {
+    const m = map.get(ip);
+    const field_idx = m.count();
+    const values_slice = values.get(ip);
+    values_slice[field_idx] = value;
+    const adapter: Index.Adapter = .{ .indexes = values_slice[0..field_idx] };
+    const gop = m.getOrPutAssumeCapacityAdapted(value, adapter);
+    if (gop.found_existing) return @intCast(gop.index);
+    assert(gop.index == field_idx);
     return null;
 }
 
@@ -12295,6 +12691,7 @@ pub fn resolveStructLayout(
     has_no_possible_value: bool,
     has_one_possible_value: bool,
     comptime_only: bool,
+    has_runtime_bits: bool,
 ) void {
     const unwrapped_index = struct_type.unwrap(ip);
 
@@ -12311,6 +12708,7 @@ pub fn resolveStructLayout(
     flags.has_no_possible_value = has_no_possible_value;
     flags.has_one_possible_value = has_one_possible_value;
     flags.comptime_only = comptime_only;
+    flags.has_runtime_bits = has_runtime_bits;
     flags.alignment = alignment;
 }
 
@@ -12322,12 +12720,14 @@ pub fn resolveUnionLayout(
     ip: *InternPool,
     io: Io,
     union_type: Index,
+    enum_tag_type: Index,
     size: u32,
     padding: u32,
     alignment: Alignment,
     has_no_possible_value: bool,
     has_one_possible_value: bool,
     comptime_only: bool,
+    has_runtime_bits: bool,
 ) void {
     const unwrapped_index = union_type.unwrap(ip);
 
@@ -12339,17 +12739,24 @@ pub fn resolveUnionLayout(
     const item = unwrapped_index.getItem(ip);
     assert(item.tag == .type_union);
 
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "enum_tag_type").?] = @intFromEnum(enum_tag_type);
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "size").?] = size;
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "padding").?] = padding;
     const flags: *Tag.TypeUnion.Flags = @ptrCast(&extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "flags").?]);
     flags.has_no_possible_value = has_no_possible_value;
     flags.has_one_possible_value = has_one_possible_value;
     flags.comptime_only = comptime_only;
+    flags.has_runtime_bits = has_runtime_bits;
     flags.alignment = alignment;
 }
 
 /// Asserts that `struct_type` is a packed struct type.
-pub fn resolvePackedStructBackingInt(ip: *InternPool, io: Io, struct_type: Index, backing_int_type: Index) void {
+pub fn resolvePackedStructLayout(
+    ip: *InternPool,
+    io: Io,
+    struct_type: Index,
+    backing_int_type: Index,
+) void {
     const unwrapped_index = struct_type.unwrap(ip);
 
     const local = ip.getLocal(unwrapped_index.tid);
@@ -12371,7 +12778,13 @@ pub fn resolvePackedStructBackingInt(ip: *InternPool, io: Io, struct_type: Index
 }
 
 /// Asserts that `union_type` is a packed union type.
-pub fn resolvePackedUnionBackingInt(ip: *InternPool, io: Io, union_type: Index, backing_int_type: Index) void {
+pub fn resolvePackedUnionLayout(
+    ip: *InternPool,
+    io: Io,
+    union_type: Index,
+    enum_tag_type: Index,
+    backing_int_type: Index,
+) void {
     const unwrapped_index = union_type.unwrap(ip);
 
     const local = ip.getLocal(unwrapped_index.tid);
@@ -12387,5 +12800,32 @@ pub fn resolvePackedUnionBackingInt(ip: *InternPool, io: Io, union_type: Index,
         else => unreachable,
     }
 
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "enum_tag_type").?] = @intFromEnum(enum_tag_type);
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "backing_int_type").?] = @intFromEnum(backing_int_type);
 }
+
+/// Asserts that `enum_type` is an enum type.
+pub fn resolveEnumLayout(
+    ip: *InternPool,
+    io: Io,
+    enum_type: Index,
+    int_tag_type: Index,
+) void {
+    const unwrapped_index = enum_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    switch (item.tag) {
+        .type_enum_auto,
+        .type_enum_explicit,
+        .type_enum_nonexhaustive,
+        => {},
+        else => unreachable,
+    }
+
+    extra_items[item.data + std.meta.fieldIndex(Tag.TypeEnum, "int_tag_type").?] = @intFromEnum(int_tag_type);
+}
diff --git a/src/Sema.zig b/src/Sema.zig
index 55fb718a45b989ecac821626638dde9a98ab99b5..d1482b86812e6168d0e4fd75ba90f41016903244 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -397,7 +397,7 @@ pub const Block = struct {
     /// The name of the current "context" for naming namespace types.
     /// The interpretation of this depends on the name strategy in ZIR, but the name
     /// is always incorporated into the type name somehow.
-    /// See `Sema.createTypeName`.
+    /// See `Sema.setTypeName`.
     type_name_ctx: InternPool.NullTerminatedString,
 
     /// Create a `LazySrcLoc` based on an `Offset` from the code being analyzed in this block.
@@ -1158,7 +1158,7 @@ fn analyzeBodyInner(
             }, inst });
         }
 
-        const air_inst: Air.Inst.Ref = inst: switch (tags[@intFromEnum(inst)]) {
+        const air_ref: Air.Inst.Ref = inst: switch (tags[@intFromEnum(inst)]) {
             // zig fmt: off
             .alloc                        => try sema.zirAlloc(block, inst),
             .alloc_inferred               => try sema.zirAllocInferred(block, true),
@@ -1991,31 +1991,33 @@ fn analyzeBodyInner(
                 break :blk .void_value;
             },
         };
-        if (sema.isNoReturn(air_inst)) {
+        if (sema.isNoReturn(air_ref)) {
             // We're going to assume that the body itself is noreturn, so let's ensure that now
             assert(block.instructions.items.len > 0);
             assert(sema.isNoReturn(block.instructions.items[block.instructions.items.len - 1].toRef()));
             break;
         }
-        // <MLUGG TODO REMOVE THIS BLOCK, SILLY OPV CHECK>
-        if (air_inst.toIndex()) |air_inst_index| {
-            switch (sema.air_instructions.items(.tag)[@intFromEnum(air_inst_index)]) {
-                .inferred_alloc, .inferred_alloc_comptime => {},
-                else => {
-                    assert(sema.typeOf(air_inst).onePossibleValue(pt) catch @panic("") == null);
-                    sema.typeOf(air_inst).assertHasLayout(zcu);
-                },
-            }
-        } else {
-            switch (tags[@intFromEnum(inst)]) {
-                // MLUGG TODO: do we actually *want* this exception? we could arguably simplify things without it
-                // e.g. analyzeNavVal could stop doing ensureLayoutResolved in most cases (`extern` is an exception) and instead do `assertHasLayout`
-                .func, .func_inferred, .func_fancy => {}, // exception: we're in a func decl, layout will get resolved in a bit by `analyzeNavVal`
-                else => sema.typeOf(air_inst).assertHasLayout(zcu),
+
+        // We must resolve the layout of a type before creating a value of that type. Therefore,
+        // the layout of the type of `air_ref` must already be resolved.
+        check_type: {
+            if (air_ref.toIndex()) |air_inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(air_inst)]) {
+                .inferred_alloc, .inferred_alloc_comptime => break :check_type,
+                else => {},
+            };
+            sema.typeOf(air_ref).assertHasLayout(zcu);
+            // If the type has an OPV, `air_ref` must be that OPV: there is no other interned value
+            // it could be, and it would be a bug for the value to not be comptime-known when it has
+            // an OPV. Behind a `std.debug.runtime_safety` check because `onePossibleValue` mutates
+            // the InternPool so cannot be optimized out.
+            if (std.debug.runtime_safety) {
+                if (try sema.typeOf(air_ref).onePossibleValue(pt)) |opv| {
+                    assert(air_ref == Air.Inst.Ref.fromValue(opv));
+                }
             }
         }
-        // </MLUGG TODO REMOVE THIS BLOCK, SILLY OPV CHECK>
-        map.putAssumeCapacity(inst, air_inst);
+
+        map.putAssumeCapacity(inst, air_ref);
         i += 1;
     }
 }
@@ -2097,7 +2099,7 @@ pub fn resolveConstStringIntern(
 
 fn resolveTypeOrPoison(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) !?Type {
     const air_inst = try sema.resolveInst(zir_ref);
-    const ty = try sema.analyzeAsType(block, src, air_inst);
+    const ty = try sema.analyzeAsType(block, src, .type, air_inst);
     if (ty.isGenericPoison()) return null;
     return ty;
 }
@@ -2216,11 +2218,12 @@ pub fn analyzeAsType(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
+    reason: std.zig.SimpleComptimeReason,
     air_inst: Air.Inst.Ref,
 ) !Type {
     const wanted_type: Type = .type;
     const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
-    const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, .{ .simple = .type });
+    const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, .{ .simple = reason });
     return val.toType();
 }
 
@@ -4112,9 +4115,11 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 /// or error union pointed to, initializing these pointers along the way.
 /// Given a `*E!?T`, returns a (valid) `*T`.
 /// May invalidate already-stored payload data.
+/// Asserts that the layout of the pointer child type is already resolved.
 fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcLoc) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    sema.typeOf(ptr).childType(zcu).assertHasLayout(zcu);
     var base_ptr = ptr;
     while (true) switch (sema.typeOf(base_ptr).childType(zcu).zigTypeTag(zcu)) {
         .error_union => base_ptr = try sema.analyzeErrUnionPayloadPtr(block, src, base_ptr, false, true),
@@ -4128,6 +4133,7 @@ fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcL
 fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ptr = try sema.resolveInst(un_node.operand);
+    try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu));
     return sema.optEuBasePtrInit(block, ptr, block.nodeOffset(un_node.src_node));
 }
 
@@ -4513,7 +4519,7 @@ fn validateStructInit(
         if (struct_ty.structFieldIsComptime(i, zcu)) continue;
 
         if (!struct_ty.isTuple(zcu)) {
-            try sema.ensureFieldInitsResolved(struct_ty);
+            try sema.ensureStructDefaultsResolved(struct_ty);
         }
 
         const default_val = struct_ty.structFieldDefaultValue(i, zcu) orelse {
@@ -5737,7 +5743,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
             }
             if (zcu.llvm_object != null and options.linkage == .internal) return;
             const export_ty = Value.fromInterned(uav.val).typeOf(zcu);
-            if (!try sema.validateExternType(export_ty, .other)) {
+            if (!export_ty.validateExtern(.other, zcu)) {
                 return sema.failWithOwnedErrorMsg(block, msg: {
                     const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
                     errdefer msg.destroy(sema.gpa);
@@ -5789,7 +5795,7 @@ pub fn analyzeExport(
     const exported_nav = ip.getNav(exported_nav_index);
     const export_ty: Type = .fromInterned(exported_nav.typeOf(ip));
 
-    if (!try sema.validateExternType(export_ty, .other)) {
+    if (!export_ty.validateExtern(.other, zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
             errdefer msg.destroy(gpa);
@@ -5827,7 +5833,7 @@ fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
         .nav_val,
         .nav_ty,
         .type_layout,
-        .type_inits,
+        .struct_defaults,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -5846,7 +5852,7 @@ fn zirDisableIntrinsics(sema: *Sema) CompileError!void {
         .nav_val,
         .nav_ty,
         .type_layout,
-        .type_inits,
+        .struct_defaults,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -6729,8 +6735,28 @@ fn analyzeCall(
     } else func_src;
 
     const func_ty_info = zcu.typeToFunc(func_ty).?;
-    // MLUGG TODO: this isn't quite the check i want. this includes inline functions, which aren't *generic*...
-    const func_is_generic = !func_ty.fnHasRuntimeBits(zcu);
+    const any_comptime_params = func_ty_info.comptime_bits != 0 or ct: {
+        for (func_ty_info.param_types.get(ip)) |param_ty| {
+            if (Type.fromInterned(param_ty).comptimeOnly(zcu)) break :ct true;
+        }
+        break :ct Type.fromInterned(func_ty_info.return_type).comptimeOnly(zcu);
+    };
+    const any_generic_types = generic: {
+        for (func_ty_info.param_types.get(ip)) |param_ty| {
+            if (param_ty == .generic_poison_type) break :generic true;
+        }
+        const ret_ty: Type = .fromInterned(func_ty_info.return_type);
+        if (ret_ty.toIntern() == .generic_poison_type) {
+            break :generic true;
+        }
+        if (ret_ty.zigTypeTag(zcu) == .error_union and
+            ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type)
+        {
+            break :generic true;
+        }
+        break :generic false;
+    };
+
     if (!callConvIsCallable(func_ty_info.cc)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(
@@ -6766,7 +6792,7 @@ fn analyzeCall(
         else => unreachable,
     } else .{ null, false };
 
-    if (func_is_generic and func_val == null) {
+    if ((any_generic_types or any_comptime_params) and func_val == null) {
         return sema.failWithNeededComptime(block, func_src, .{ .simple = .generic_call_target });
     }
 
@@ -6815,13 +6841,13 @@ fn analyzeCall(
     // This is the `inst_map` used when evaluating generic parameters and return types.
     var generic_inst_map: InstMap = .{};
     defer generic_inst_map.deinit(gpa);
-    if (func_is_generic) {
+    if (any_generic_types) {
         try generic_inst_map.ensureSpaceForInstructions(gpa, fn_zir_info.param_body);
     }
 
     // This exists so that `generic_block` below can include a "called from here" note back to this
     // call site when analyzing generic parameter/return types.
-    var generic_inlining: Block.Inlining = if (func_is_generic) .{
+    var generic_inlining: Block.Inlining = if (any_generic_types) .{
         .call_block = block,
         .call_src = call_src,
         .func = func_val.?.toIntern(),
@@ -6834,7 +6860,7 @@ fn analyzeCall(
     // This is the block in which we evaluate generic function components: that is, generic parameter
     // types and the generic return type. This must not be used if the function is not generic.
     // `comptime_reason` is set as needed.
-    var generic_block: Block = if (func_is_generic) .{
+    var generic_block: Block = if (any_generic_types) .{
         .parent = null,
         .sema = sema,
         .namespace = fn_nav.analysis.?.namespace,
@@ -6843,9 +6869,9 @@ fn analyzeCall(
         .src_base_inst = fn_nav.analysis.?.zir_index,
         .type_name_ctx = fn_nav.fqn,
     } else undefined;
-    defer if (func_is_generic) generic_block.instructions.deinit(gpa);
+    defer if (any_generic_types) generic_block.instructions.deinit(gpa);
 
-    if (func_is_generic) {
+    if (any_generic_types) {
         // We certainly depend on the generic owner's signature!
         try sema.declareDependency(.{ .src_hash = fn_tracked_inst });
     }
@@ -6857,7 +6883,7 @@ fn analyzeCall(
             if (raw != .generic_poison_type) break :ty .fromInterned(raw);
 
             // We must discover the generic parameter type.
-            assert(func_is_generic);
+            assert(any_generic_types);
             const param_inst_idx = fn_zir_info.param_body[arg_idx];
             const param_inst = fn_zir.instructions.get(@intFromEnum(param_inst_idx));
             switch (param_inst.tag) {
@@ -6888,7 +6914,7 @@ fn analyzeCall(
             } };
 
             const ty_ref = try sema.resolveInlineBody(&generic_block, body, param_inst_idx);
-            const param_ty = try sema.analyzeAsType(&generic_block, param_src, ty_ref);
+            const param_ty = try sema.analyzeAsType(&generic_block, param_src, .fn_param_types, ty_ref);
 
             if (!param_ty.isValidParamType(zcu)) {
                 const opaque_str = if (param_ty.zigTypeTag(zcu) == .@"opaque") "opaque " else "";
@@ -6906,7 +6932,7 @@ fn analyzeCall(
             return arg.*; // terminate analysis here
         }
 
-        if (func_is_generic) {
+        if (any_generic_types) {
             // We need to put the argument into `generic_inst_map` so that other parameters can refer to it.
             const param_inst_idx = fn_zir_info.param_body[arg_idx];
             const declared_comptime = if (std.math.cast(u5, arg_idx)) |i| func_ty_info.paramIsComptime(i) else false;
@@ -6948,7 +6974,7 @@ fn analyzeCall(
     // calls (where it should be the IES of the instantiation). However, it's how we print this
     // in error messages.
     const resolved_ret_ty: Type = ret_ty: {
-        if (!func_is_generic) break :ret_ty .fromInterned(func_ty_info.return_type);
+        if (!any_generic_types) break :ret_ty .fromInterned(func_ty_info.return_type);
 
         const maybe_poison_bare = if (fn_zir_info.inferred_error_set) maybe_poison: {
             break :maybe_poison ip.errorUnionPayload(func_ty_info.return_type);
@@ -6958,7 +6984,7 @@ fn analyzeCall(
 
         // Evaluate the generic return type. As with generic parameters, we switch out `sema.code` and `sema.inst_map`.
 
-        assert(func_is_generic);
+        assert(any_generic_types);
 
         const old_code = sema.code;
         const old_inst_map = sema.inst_map;
@@ -6981,7 +7007,7 @@ fn analyzeCall(
         } else bare: {
             assert(fn_zir_info.ret_ty_body.len != 0);
             const ty_ref = try sema.resolveInlineBody(&generic_block, fn_zir_info.ret_ty_body, fn_zir_inst);
-            break :bare try sema.analyzeAsType(&generic_block, func_ret_ty_src, ty_ref);
+            break :bare try sema.analyzeAsType(&generic_block, func_ret_ty_src, .fn_ret_ty, ty_ref);
         };
         assert(bare_ty.toIntern() != .generic_poison_type);
 
@@ -7035,7 +7061,7 @@ fn analyzeCall(
         });
         if (func_ty_info.cc == .auto) {
             switch (sema.owner.unwrap()) {
-                .@"comptime", .nav_ty, .nav_val, .type_layout, .type_inits, .memoized_state => {},
+                .@"comptime", .nav_ty, .nav_val, .type_layout, .struct_defaults, .memoized_state => {},
                 .func => |owner_func| ip.funcSetHasErrorTrace(io, owner_func, true),
             }
         }
@@ -7043,7 +7069,7 @@ fn analyzeCall(
             try sema.validateRuntimeValue(block, args_info.argSrc(block, arg_idx), arg);
         }
         const runtime_func: Air.Inst.Ref, const runtime_args: []const Air.Inst.Ref = func: {
-            if (!func_is_generic) break :func .{ callee, args };
+            if (!any_generic_types and !any_comptime_params) break :func .{ callee, args };
 
             // Instantiate the generic function!
 
@@ -7512,9 +7538,7 @@ fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
     assert(indexable_ty.isIndexable(zcu)); // validated by a previous instruction
     const elem_ty = switch (indexable_ty.zigTypeTag(zcu)) {
         .@"struct" => indexable_ty.fieldType(@intFromEnum(bin.rhs), zcu),
-        .array, .vector => indexable_ty.childType(zcu),
-        .pointer => indexable_ty.indexablePtrElem(zcu),
-        else => unreachable,
+        else => indexable_ty.indexableElem(zcu),
     };
     return .fromType(elem_ty);
 }
@@ -7835,8 +7859,8 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
         };
         return sema.failWithOwnedErrorMsg(block, msg);
     }
-    const lhs_ty = try sema.analyzeAsType(block, lhs_src, lhs);
-    const rhs_ty = try sema.analyzeAsType(block, rhs_src, rhs);
+    const lhs_ty = try sema.analyzeAsType(block, lhs_src, .type, lhs);
+    const rhs_ty = try sema.analyzeAsType(block, rhs_src, .type, rhs);
     if (lhs_ty.zigTypeTag(zcu) != .error_set)
         return sema.fail(block, lhs_src, "expected error set type, found '{f}'", .{lhs_ty.fmt(pt)});
     if (rhs_ty.zigTypeTag(zcu) != .error_set)
@@ -8017,12 +8041,13 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     if (dest_ty.zigTypeTag(zcu) != .@"enum") {
         return sema.fail(block, src, "expected enum, found '{f}'", .{dest_ty.fmt(pt)});
     }
+    try sema.ensureLayoutResolved(dest_ty);
     _ = try sema.checkIntType(block, operand_src, operand_ty);
 
     if (try sema.resolveValue(operand)) |int_val| {
         if (dest_ty.isNonexhaustiveEnum(zcu)) {
             const int_tag_ty = dest_ty.intTagType(zcu);
-            if (try sema.intFitsInType(int_val, int_tag_ty, null)) {
+            if (int_val.intFitsInType(int_tag_ty, null, zcu)) {
                 return Air.internedToRef((try pt.getCoerced(int_val, dest_ty)).toIntern());
             }
             return sema.fail(block, src, "int value '{f}' out of range of non-exhaustive enum '{f}'", .{
@@ -8077,10 +8102,14 @@ fn zirOptionalPayloadPtr(
     const optional_ptr = try sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
 
+    const ptr_ty = sema.typeOf(optional_ptr);
+    assert(ptr_ty.zigTypeTag(sema.pt.zcu) == .pointer);
+    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu));
+
     return sema.analyzeOptionalPayloadPtr(block, src, optional_ptr, safety_check, false);
 }
 
-/// MLUGG TODO: pre-resolved child?
+/// Asserts that the layout of the pointer child type is already resolved.
 fn analyzeOptionalPayloadPtr(
     sema: *Sema,
     block: *Block,
@@ -8095,12 +8124,12 @@ fn analyzeOptionalPayloadPtr(
     assert(optional_ptr_ty.zigTypeTag(zcu) == .pointer);
 
     const opt_type = optional_ptr_ty.childType(zcu);
+    opt_type.assertHasLayout(zcu);
     if (opt_type.zigTypeTag(zcu) != .optional) {
         return sema.failWithExpectedOptionalType(block, src, opt_type);
     }
 
     const child_type = opt_type.optionalChild(zcu);
-    try sema.ensureLayoutResolved(child_type);
     const child_pointer = try pt.ptrType(.{
         .child = child_type.toIntern(),
         .flags = .{
@@ -8283,10 +8312,14 @@ fn zirErrUnionPayloadPtr(
     const operand = try sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
 
+    const ptr_ty = sema.typeOf(operand);
+    assert(ptr_ty.zigTypeTag(sema.pt.zcu) == .pointer);
+    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu));
+
     return sema.analyzeErrUnionPayloadPtr(block, src, operand, false, false);
 }
 
-/// MLUGG TODO LAYOUT: already-resolved child?
+/// Asserts that the layout of the pointer child type is already resolved.
 fn analyzeErrUnionPayloadPtr(
     sema: *Sema,
     block: *Block,
@@ -8307,8 +8340,8 @@ fn analyzeErrUnionPayloadPtr(
     }
 
     const err_union_ty = operand_ty.childType(zcu);
+    err_union_ty.assertHasLayout(zcu);
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
-    try sema.ensureLayoutResolved(payload_ty);
     const operand_pointer_ty = try pt.ptrType(.{
         .child = payload_ty.toIntern(),
         .flags = .{
@@ -8744,7 +8777,7 @@ fn checkParamTypeCommon(
     }
     if (!param_ty.isGenericPoison() and
         !target_util.fnCallConvAllowsZigTypes(cc) and
-        !try sema.validateExternType(param_ty, .param_ty))
+        !param_ty.validateExtern(.param_ty, zcu))
     {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(param_src, "parameter of type '{f}' not allowed in function with calling convention '{s}'", .{
@@ -8818,7 +8851,7 @@ fn checkReturnTypeAndCallConvCommon(
     }
     if (!bare_ret_ty.isGenericPoison() and
         !target_util.fnCallConvAllowsZigTypes(@"callconv") and
-        (inferred_error_set or !try sema.validateExternType(bare_ret_ty, .ret_ty)))
+        (inferred_error_set or !bare_ret_ty.validateExtern(.ret_ty, zcu)))
     {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(ret_ty_src, "return type '{s}{f}' not allowed in function with calling convention '{s}'", .{
@@ -9042,7 +9075,7 @@ fn funcCommon(
 
     if (inferred_error_set) {
         assert(has_body);
-        return .fromIntern(try ip.getFuncDeclIes(gpa, io, pt.tid, .{
+        const func_val: Value = .fromInterned(try ip.getFuncDeclIes(gpa, io, pt.tid, .{
             .owner_nav = sema.owner.unwrap().nav_val,
 
             .param_types = param_types,
@@ -9059,6 +9092,8 @@ fn funcCommon(
             .lbrace_column = @as(u16, @truncate(src_locs.columns)),
             .rbrace_column = @as(u16, @truncate(src_locs.columns >> 16)),
         }));
+        try sema.ensureLayoutResolved(func_val.typeOf(zcu));
+        return .fromValue(func_val);
     }
 
     const func_ty = try ip.getFuncType(gpa, io, pt.tid, .{
@@ -9072,6 +9107,7 @@ fn funcCommon(
     });
 
     if (has_body) {
+        try sema.ensureLayoutResolved(.fromInterned(func_ty));
         return .fromIntern(try ip.getFuncDecl(gpa, io, pt.tid, .{
             .owner_nav = sema.owner.unwrap().nav_val,
             .ty = func_ty,
@@ -9109,7 +9145,7 @@ fn zirParam(
         }
 
         const param_ty_inst = try sema.resolveInlineBody(block, body, inst);
-        break :ty try sema.analyzeAsType(block, src, param_ty_inst);
+        break :ty try sema.analyzeAsType(block, src, .fn_param_types, param_ty_inst);
     };
 
     try block.params.append(sema.arena, .{
@@ -9948,6 +9984,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
                 err_union_ty.fmt(pt),
             });
         }
+        try sema.ensureLayoutResolved(err_union_ty);
 
         const non_err_cond = if (non_err_case.operand_is_ref)
             try sema.analyzePtrIsNonErr(block, operand_src, eu_maybe_ptr)
@@ -12924,7 +12961,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             const res_ty: InternPool.Index = b: {
                 if (extra.res_ty == .none) break :b .none;
                 const res_ty_inst = try sema.resolveInst(extra.res_ty);
-                const res_ty = try sema.analyzeAsType(block, operand_src, res_ty_inst);
+                const res_ty = try sema.analyzeAsType(block, operand_src, .type, res_ty_inst);
                 if (res_ty.isGenericPoison()) break :b .none;
                 break :b res_ty.toIntern();
             };
@@ -15683,8 +15720,8 @@ fn zirCmpEq(
         return block.addBinOp(air_tag, lhs, rhs);
     }
     if (lhs_ty_tag == .type and rhs_ty_tag == .type) {
-        const lhs_as_type = try sema.analyzeAsType(block, lhs_src, lhs);
-        const rhs_as_type = try sema.analyzeAsType(block, rhs_src, rhs);
+        const lhs_as_type = try sema.analyzeAsType(block, lhs_src, .type, lhs);
+        const rhs_as_type = try sema.analyzeAsType(block, rhs_src, .type, rhs);
         return if (lhs_as_type.eql(rhs_as_type, zcu) == (op == .eq)) .bool_true else .bool_false;
     }
     return sema.analyzeCmp(block, src, lhs, rhs, op, lhs_src, rhs_src, true);
@@ -15979,16 +16016,7 @@ fn zirThis(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     _ = extended;
-    const zcu = sema.pt.zcu;
-    const namespace = zcu.namespacePtr(block.namespace);
-
-    switch (zcu.intern_pool.indexToKey(namespace.owner_type)) {
-        .opaque_type, .struct_type, .union_type => {},
-        // Enum inits are resolved eagerly. TODO MLUGG: honestly i don't think they SHOULD be lol
-        .enum_type => try sema.ensureFieldInitsResolved(.fromInterned(namespace.owner_type)),
-        else => unreachable,
-    }
-    return .fromIntern(namespace.owner_type);
+    return .fromIntern(sema.pt.zcu.namespacePtr(block.namespace).owner_type);
 }
 
 fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
@@ -16224,12 +16252,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const type_info_ty = try sema.getBuiltinType(src, .Type);
     const type_info_tag_ty = type_info_ty.unionTagType(zcu).?;
 
+    try sema.ensureLayoutResolved(ty);
+
     if (ty.typeDeclInst(zcu)) |type_decl_inst| {
         try sema.declareDependency(.{ .namespace = type_decl_inst });
     }
 
-    try sema.ensureLayoutResolved(ty);
-
     switch (ty.zigTypeTag(zcu)) {
         .type,
         .void,
@@ -16240,7 +16268,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .undefined,
         .null,
         .enum_literal,
-        => |type_info_tag| return unionInitFromEnumTag(sema, block, src, type_info_ty, @intFromEnum(type_info_tag), .void_value),
+        => |type_info_tag| return .fromValue(try pt.unionValue(
+            type_info_ty,
+            Value.uninterpret(type_info_tag, type_info_tag_ty, pt) catch |err| switch (err) {
+                error.TypeMismatch => @panic("std.builtin is corrupt"),
+                error.OutOfMemory => |e| return e,
+            },
+            .void,
+        )),
 
         .@"fn" => {
             const fn_info_ty = try sema.getBuiltinType(src, .@"Type.Fn");
@@ -16248,9 +16283,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const func_ty_info = zcu.typeToFunc(ty).?;
             const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len);
+            var func_is_generic = false;
             for (param_vals, 0..) |*param_val, i| {
                 const param_ty = func_ty_info.param_types.get(ip)[i];
                 const is_generic = param_ty == .generic_poison_type;
+                if (is_generic or Type.fromInterned(param_ty).comptimeOnly(zcu)) func_is_generic = true;
                 const param_ty_val = try pt.intern(.{ .opt = .{
                     .ty = try pt.intern(.{ .opt_type = .type_type }),
                     .val = if (is_generic) .none else param_ty,
@@ -16300,18 +16337,21 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 } });
             };
 
+            const ret_ty_is_generic = generic: {
+                const ret_ty: Type = .fromInterned(func_ty_info.return_type);
+                if (ret_ty.toIntern() == .generic_poison_type) break :generic true;
+                if (ret_ty.zigTypeTag(zcu) == .error_union) {
+                    if (ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type) {
+                        break :generic true;
+                    }
+                }
+                break :generic false;
+            };
+            if (ret_ty_is_generic) func_is_generic = true;
+
             const ret_ty_opt = try pt.intern(.{ .opt = .{
                 .ty = try pt.intern(.{ .opt_type = .type_type }),
-                .val = opt_val: {
-                    const ret_ty: Type = .fromInterned(func_ty_info.return_type);
-                    if (ret_ty.toIntern() == .generic_poison_type) break :opt_val .none;
-                    if (ret_ty.zigTypeTag(zcu) == .error_union) {
-                        if (ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type) {
-                            break :opt_val .none;
-                        }
-                    }
-                    break :opt_val ret_ty.toIntern();
-                },
+                .val = if (ret_ty_is_generic) .none else func_ty_info.return_type,
             } });
 
             const callconv_ty = try sema.getBuiltinType(src, .CallingConvention);
@@ -16320,9 +16360,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 error.OutOfMemory => |e| return e,
             };
 
-            // MLUGG TODO
-            const func_is_generic = false;
-
             const field_values: [5]InternPool.Index = .{
                 // calling_convention: CallingConvention,
                 callconv_val.toIntern(),
@@ -16837,7 +16874,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .struct_type => ip.loadStructType(ty.toIntern()),
                     else => unreachable,
                 };
-                try sema.ensureFieldInitsResolved(ty); // can't do this sooner, since it's not allowed on tuples
+                try sema.ensureStructDefaultsResolved(ty); // can't do this sooner, since it's not allowed on tuples
                 struct_field_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len);
 
                 for (struct_field_vals, 0..) |*field_val, field_index| {
@@ -18193,7 +18230,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
 
     const elem_ty = blk: {
         const air_inst = try sema.resolveInst(extra.data.elem_type);
-        const ty = sema.analyzeAsType(block, elem_ty_src, air_inst) catch |err| {
+        const ty = sema.analyzeAsType(block, elem_ty_src, .type, air_inst) catch |err| {
             if (err == error.AnalysisFail and sema.err != null and sema.typeOf(air_inst).isSinglePointer(zcu)) {
                 try sema.errNote(elem_ty_src, sema.err.?, "use '.*' to dereference pointer", .{});
             }
@@ -18274,7 +18311,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     } else if (inst_data.size != .one and elem_ty.zigTypeTag(zcu) == .@"opaque") {
         return sema.fail(block, elem_ty_src, "indexable pointer to opaque type '{f}' not allowed", .{elem_ty.fmt(pt)});
     } else if (inst_data.size == .c) {
-        if (!try sema.validateExternType(elem_ty, .other)) {
+        if (!elem_ty.validateExtern(.other, zcu)) {
             const msg = msg: {
                 const msg = try sema.errMsg(elem_ty_src, "C pointers cannot point to non-C-ABI-compatible type '{f}'", .{elem_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
@@ -18288,11 +18325,11 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         }
     }
 
-    if (host_size != 0 and !elem_ty.packable(zcu)) {
-        return sema.failWithOwnedErrorMsg(block, msg: {
+    if (host_size != 0) {
+        if (elem_ty.unpackable(zcu)) |reason| return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(elem_ty_src, "bit-pointer cannot refer to value of type '{f}'", .{elem_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
-            try sema.explainWhyTypeIsNotPackable(msg, elem_ty_src, elem_ty);
+            try sema.explainWhyTypeIsUnpackable(msg, elem_ty_src, reason);
             break :msg msg;
         });
     }
@@ -18455,63 +18492,32 @@ fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) Com
 
 fn zirUnionInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const field_src = block.builtinCallArgSrc(inst_data.src_node, 1);
-    const init_src = block.builtinCallArgSrc(inst_data.src_node, 2);
+    const payload_src = block.builtinCallArgSrc(inst_data.src_node, 2);
     const extra = sema.code.extraData(Zir.Inst.UnionInit, inst_data.payload_index).data;
     const union_ty = try sema.resolveType(block, ty_src, extra.union_type);
     if (union_ty.zigTypeTag(pt.zcu) != .@"union") {
         return sema.fail(block, ty_src, "expected union type, found '{f}'", .{union_ty.fmt(pt)});
     }
+    union_ty.assertHasLayout(zcu); // from a previous `field_type_ref` instruction
     const field_name = try sema.resolveConstStringIntern(block, field_src, extra.field_name, .{ .simple = .union_field_names });
-    const init = try sema.resolveInst(extra.init);
-    return sema.unionInit(block, init, init_src, union_ty, ty_src, field_name, field_src);
-}
-
-fn unionInit(
-    sema: *Sema,
-    block: *Block,
-    uncasted_init: Air.Inst.Ref,
-    init_src: LazySrcLoc,
-    union_ty: Type,
-    union_ty_src: LazySrcLoc,
-    field_name: InternPool.NullTerminatedString,
-    field_src: LazySrcLoc,
-) CompileError!Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
     const field_ty: Type = .fromInterned(zcu.typeToUnion(union_ty).?.field_types.get(ip)[field_index]);
-    const init = try sema.coerce(block, field_ty, uncasted_init, init_src);
-    _ = union_ty_src;
-    return unionInitFromEnumTag(sema, block, init_src, union_ty, field_index, init);
-}
 
-fn unionInitFromEnumTag(
-    sema: *Sema,
-    block: *Block,
-    init_src: LazySrcLoc,
-    union_ty: Type,
-    field_index: u32,
-    init: Air.Inst.Ref,
-) !Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
+    const payload = try sema.coerce(block, field_ty, try sema.resolveInst(extra.init), payload_src);
 
-    if (try sema.resolveValue(init)) |init_val| {
+    if (try sema.resolveValue(payload)) |payload_val| {
         const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
-        return Air.internedToRef((try pt.internUnion(.{
-            .ty = union_ty.toIntern(),
-            .tag = tag_val.toIntern(),
-            .val = init_val.toIntern(),
-        })));
+        return .fromValue(try pt.unionValue(union_ty, tag_val, payload_val));
     }
 
-    try sema.requireRuntimeBlock(block, init_src, null);
-    return block.addUnionInit(union_ty, field_index, init);
+    try sema.requireRuntimeBlock(block, payload_src, null);
+    return block.addUnionInit(union_ty, field_index, payload);
 }
 
 fn zirStructInit(
@@ -18588,9 +18594,6 @@ fn zirStructInit(
             const field_ty = resolved_ty.fieldType(field_index, zcu);
             field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);
             if (resolved_ty.structFieldIsComptime(field_index, zcu)) {
-                if (!resolved_ty.isTuple(zcu)) {
-                    try sema.ensureFieldInitsResolved(resolved_ty);
-                }
                 const default_value = (try resolved_ty.structFieldValueComptime(pt, field_index)).?;
                 const init_val = (try sema.resolveValue(field_inits[field_index])) orelse {
                     return sema.failWithNeededComptime(block, field_src, .{ .simple = .stored_to_comptime_field });
@@ -18744,7 +18747,12 @@ fn finishStructInit(
                     continue;
                 }
 
-                try sema.ensureFieldInitsResolved(struct_ty);
+                if (struct_type.field_is_comptime_bits.get(ip, i)) {
+                    field_inits[i] = .fromIntern(struct_type.field_defaults.get(ip)[i]);
+                    continue;
+                }
+
+                try sema.ensureStructDefaultsResolved(struct_ty);
 
                 const field_default: InternPool.Index = d: {
                     if (struct_type.field_defaults.len == 0) break :d .none;
@@ -18935,55 +18943,54 @@ fn structInitAnon(
         break :hash hasher.final();
     };
     const tracked_inst = try block.trackZir(inst);
-    const struct_ty: Type = switch (try ip.getStructType(gpa, io, pt.tid, .{
+    const struct_ty: Type = switch (try ip.getReifiedStructType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .type_hash = type_hash,
         .fields_len = extra_data.fields_len,
         .layout = .auto,
-        .explicit_packed_backing_type = .none,
         .any_comptime_fields = any_values,
         .any_field_defaults = any_values,
         .any_field_aligns = false,
-        .key = .{ .reified = .{
-            .zir_index = tracked_inst,
-            .type_hash = type_hash,
-        } },
+        .packed_backing_int_type = .none,
     })) {
+        .existing => |ty| .fromInterned(ty),
         .wip => |wip| ty: {
             errdefer wip.cancel(ip, pt.tid);
-            // MLUGG TODO obvs this sux
-            const anon_prefix = (try sema.createTypeName(block, .anon, "struct", inst)).anon_prefix;
-            wip.setName(ip, try ip.getOrPutStringFmt(gpa, io, pt.tid, "{s}_{d}", .{ anon_prefix, @intFromEnum(wip.index) }, .no_embedded_nulls), .none);
+            try sema.setTypeName(block, &wip, .anon, "struct", inst);
 
-            const struct_type = ip.loadStructType(wip.index);
-
-            for (names, values) |name, init_val| {
-                assert(wip.nextField(ip, name, init_val != .none) == null); // AstGen validated no duplicates for us
+            // Reified structs have field information populated immediately.
+            @memcpy(wip.field_names.get(ip), names);
+            @memcpy(wip.field_types.get(ip), types);
+            if (any_values) {
+                @memcpy(wip.field_values.get(ip), values);
+                @memset(wip.field_is_comptime_bits.getAll(ip), 0);
+                for (values, 0..) |val, field_index| {
+                    if (val == .none) continue;
+                    const bit_bag_index = field_index / 32;
+                    const mask = @as(u32, 1) << @intCast(field_index % 32);
+                    wip.field_is_comptime_bits.getAll(ip)[bit_bag_index] |= mask;
+                }
             }
 
-            // Populating these means the type is already resolved; we don't need to add it to `zcu.outdated` or anything.
-            // That's important because type resolution relies on types being declared.
-            @memcpy(struct_type.field_types.get(ip), types);
-            @memcpy(struct_type.field_defaults.get(ip), if (any_values) values else @as([]const InternPool.Index, &.{}));
-
-            try type_resolution.finishStructLayout(sema, block, src, wip.index, &struct_type);
-
             const new_namespace_index = try pt.createNamespace(.{
                 .parent = block.namespace.toOptional(),
                 .owner_type = wip.index,
                 .file_scope = block.getFileScopeIndex(zcu),
                 .generation = zcu.generation,
             });
-            codegen_type: {
-                if (zcu.comp.config.use_llvm) break :codegen_type;
-                if (block.ownerModule().strip) break :codegen_type;
-                zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-                try zcu.comp.queueJob(.{ .link_type = wip.index });
-            }
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entries
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
-        .existing => |ty| .fromInterned(ty),
     };
     try sema.addTypeReferenceEntry(src, struct_ty);
+    try sema.ensureLayoutResolved(struct_ty);
 
     _ = opt_runtime_index orelse {
         const struct_val = try pt.aggregateValue(struct_ty, values);
@@ -19338,6 +19345,7 @@ fn fieldType(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
+    aggregate_ty.assertHasLayout(zcu);
     var cur_ty = aggregate_ty;
     while (true) {
         switch (cur_ty.zigTypeTag(zcu)) {
@@ -19397,7 +19405,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
         .func => |func| if (ip.funcAnalysisUnordered(func).has_error_trace and block.ownerModule().error_tracing) {
             return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
         },
-        .@"comptime", .nav_ty, .nav_val, .type_layout, .type_inits, .memoized_state => {},
+        .@"comptime", .nav_ty, .nav_val, .type_layout, .struct_defaults, .memoized_state => {},
     }
     return Air.internedToRef(try pt.intern(.{ .opt = .{
         .ty = opt_ptr_stack_trace_ty.toIntern(),
@@ -19823,7 +19831,7 @@ fn zirReifyPointer(
         else => {},
     }
 
-    if (size == .c and !try sema.validateExternType(elem_ty, .other)) {
+    if (size == .c and !elem_ty.validateExtern(.other, zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "C pointers cannot point to non-C-ABI-compatible type '{f}'", .{elem_ty.fmt(pt)});
             errdefer msg.destroy(gpa);
@@ -19988,6 +19996,7 @@ fn zirReifyStruct(
     const name_strategy: Zir.Inst.NameStrategy = @enumFromInt(extended.small);
     const extra = sema.code.extraData(Zir.Inst.ReifyStruct, extended.operand).data;
     const tracked_inst = try block.trackZir(inst);
+
     const src: LazySrcLoc = .{
         .base_node_inst = tracked_inst,
         .offset = .nodeOffset(.zero),
@@ -20039,7 +20048,7 @@ fn zirReifyStruct(
 
     const backing_int_ty_uncoerced = try sema.resolveInst(extra.backing_ty);
     const backing_int_ty_coerced = try sema.coerce(block, .optional_type, backing_int_ty_uncoerced, backing_ty_src);
-    const backing_int_ty_val = try sema.resolveConstDefinedValue(block, backing_ty_src, backing_int_ty_coerced, .{ .simple = .type });
+    const backing_int_ty_val = try sema.resolveConstDefinedValue(block, backing_ty_src, backing_int_ty_coerced, .{ .simple = .packed_struct_backing_int_type });
 
     const field_names_uncoerced = try sema.resolveInst(extra.field_names);
     const field_names_coerced = try sema.coerce(block, .slice_const_slice_const_u8, field_names_uncoerced, field_names_src);
@@ -20079,19 +20088,30 @@ fn zirReifyStruct(
         return sema.failWithUseOfUndef(block, backing_ty_src, null);
     }
 
-    // The validation work here is non-trivial, and it's possible the type already exists.
-    // So in this first pass, let's just construct a hash to optimize for this case. If the
-    // inputs turn out to be invalid, we can cancel the WIP type later.
+    // Most validation of this type happens during type resolution. We basically need to do the work
+    // which AstGen would normally do. An exception is checking for duplicate field names, which is
+    // handled by type resolution---it just simplifies some logic a little.
+
+    // As well as validation, we're going to gather some information about the fields, and construct
+    // a hash representing the inputs for deduplication purposes.
 
     var any_comptime_fields = false;
-    var any_default_inits = false;
-    var any_aligned_fields = false;
+    var any_field_defaults = false;
+    var any_field_aligns = false;
 
-    // For deduplication purposes, we must create a hash including all details of this type.
     // TODO: use a longer hash!
     var hasher = std.hash.Wyhash.init(0);
     std.hash.autoHash(&hasher, layout);
     std.hash.autoHash(&hasher, backing_int_ty_val);
+
+    const backing_int_ty: ?Type = if (backing_int_ty_val.optionalValue(zcu)) |backing| ty: {
+        switch (layout) {
+            .auto, .@"extern" => return sema.fail(block, backing_ty_src, "non-packed struct does not support backing integer type", .{}),
+            .@"packed" => {},
+        }
+        break :ty backing.toType();
+    } else null;
+
     // The field *type* array has already been deduplicated for us thanks to the InternPool!
     std.hash.autoHash(&hasher, field_types_arr);
     // However, for field names and attributes, we need to actually iterate the individual fields,
@@ -20126,201 +20146,126 @@ fn zirReifyStruct(
                 field_attrs_src,
                 .{ .simple = .struct_field_default_value },
             );
+            if (deref_val.canMutateComptimeVarState(zcu)) {
+                return sema.failWithContainsReferenceToComptimeVar(block, field_attrs_src, field_name, "field default value", deref_val);
+            }
+            any_field_defaults = true;
             break :d deref_val.toIntern();
         };
 
+        if (field_attr_comptime.toBool()) {
+            if (field_default == .none) {
+                return sema.fail(block, field_attrs_src, "comptime field without default initialization value", .{});
+            }
+            if (layout != .auto) {
+                return sema.fail(block, field_attrs_src, "{t} struct fields cannot be marked comptime", .{layout});
+            }
+            any_comptime_fields = true;
+        }
+
+        if (field_attr_align.optionalValue(zcu)) |align_val| {
+            if (layout == .@"packed") {
+                return sema.fail(block, field_attrs_src, "packed struct fields cannot be aligned", .{});
+            }
+            // Trigger a compile error if the alignment is invalid.
+            _ = try sema.validateAlign(block, field_attrs_src, align_val.toUnsignedInt(zcu));
+            any_field_aligns = true;
+        }
+
         std.hash.autoHash(&hasher, .{
             field_name,
             field_attr_comptime,
             field_attr_align,
             field_default,
         });
-
-        if (field_attr_comptime.toBool()) any_comptime_fields = true;
-        if (field_attr_align.optionalValue(zcu)) |_| any_aligned_fields = true;
-        if (field_default != .none) any_default_inits = true;
-    }
-
-    // Some basic validation to avoid a bogus `getStructType` call...
-    const backing_int_ty: ?Type = if (backing_int_ty_val.optionalValue(zcu)) |backing| ty: {
-        switch (layout) {
-            .auto, .@"extern" => return sema.fail(block, backing_ty_src, "non-packed struct does not support backing integer type", .{}),
-            .@"packed" => {},
-        }
-        break :ty backing.toType();
-    } else null;
-    if (any_aligned_fields and layout == .@"packed") {
-        return sema.fail(block, field_attrs_src, "packed struct fields cannot be aligned", .{});
-    }
-    if (any_comptime_fields and layout != .auto) {
-        return sema.fail(block, field_attrs_src, "{t} struct fields cannot be marked comptime", .{layout});
     }
 
-    const wip_ty = switch (try ip.getStructType(gpa, io, pt.tid, .{
+    switch (try ip.getReifiedStructType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .type_hash = hasher.final(),
         .fields_len = @intCast(fields_len),
         .layout = layout,
-        .explicit_packed_backing_type = if (backing_int_ty) |t| t.toIntern() else .none,
         .any_comptime_fields = any_comptime_fields,
-        .any_field_defaults = any_default_inits,
-        .any_field_aligns = any_aligned_fields,
-        .key = .{ .reified = .{
-            .zir_index = tracked_inst,
-            .type_hash = hasher.final(),
-        } },
+        .any_field_defaults = any_field_defaults,
+        .any_field_aligns = any_field_aligns,
+        .packed_backing_int_type = if (backing_int_ty) |ty| ty.toIntern() else .none,
     })) {
-        .wip => |wip| wip,
         .existing => |ty| {
             try sema.addTypeReferenceEntry(src, .fromInterned(ty));
             return .fromIntern(ty);
         },
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
+        .wip => |wip| {
+            errdefer wip.cancel(ip, pt.tid);
+            try sema.setTypeName(block, &wip, name_strategy, "struct", inst);
+            for (0..fields_len) |field_idx| {
+                const field_name_val = try field_names_arr.elemValue(pt, field_idx);
+                const field_attrs_val = try field_attrs_arr.elemValue(pt, field_idx);
 
-    _ = try (try sema.createTypeName(
-        block,
-        name_strategy,
-        "struct",
-        inst,
-    )).apply(&wip_ty, pt);
+                // No source location or reason; first loop checked this is valid.
+                const field_name = try sema.sliceToIpString(block, .unneeded, field_name_val, undefined);
+                wip.field_names.get(ip)[field_idx] = field_name;
 
-    const wip_struct_type = ip.loadStructType(wip_ty.index);
+                const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
+                wip.field_types.get(ip)[field_idx] = field_ty.toIntern();
 
-    for (0..fields_len) |field_idx| {
-        const field_name_val = try field_names_arr.elemValue(pt, field_idx);
-        const field_attrs_val = try field_attrs_arr.elemValue(pt, field_idx);
+                const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
+                    std.builtin.Type.StructField.Attributes,
+                    "comptime",
+                ).?);
+                const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
+                    std.builtin.Type.StructField.Attributes,
+                    "align",
+                ).?);
+                const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
+                    std.builtin.Type.StructField.Attributes,
+                    "default_value_ptr",
+                ).?);
 
-        // Don't pass a reason; first loop acts as a check that this is valid.
-        const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
-        const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
-        const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
-            std.builtin.Type.StructField.Attributes,
-            "comptime",
-        ).?);
-        const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
-            std.builtin.Type.StructField.Attributes,
-            "align",
-        ).?);
-        const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
-            std.builtin.Type.StructField.Attributes,
-            "default_value_ptr",
-        ).?);
+                if (field_attr_comptime.toBool()) {
+                    const bit_bag_index = field_idx / 32;
+                    const mask = @as(u32, 1) << @intCast(field_idx % 32);
+                    wip.field_is_comptime_bits.getAll(ip)[bit_bag_index] |= mask;
+                }
 
-        if (wip_ty.nextField(ip, field_name, field_attr_comptime.toBool())) |prev_index| {
-            _ = prev_index; // TODO: better source location
-            return sema.fail(block, field_names_src, "duplicate struct field name {f}", .{field_name.fmt(ip)});
-        }
+                if (field_attr_default_value_ptr.optionalValue(zcu)) |ptr_val| {
+                    const ptr_ty = try pt.singleConstPtrType(field_ty);
+                    // No source location; first loop checked this is valid.
+                    const deref_val = (try sema.pointerDeref(block, .unneeded, ptr_val, ptr_ty)).?;
+                    wip.field_values.get(ip)[field_idx] = deref_val.toIntern();
+                } else if (any_field_defaults) {
+                    wip.field_values.get(ip)[field_idx] = .none;
+                }
 
-        const field_default: InternPool.Index = d: {
-            const ptr_val = field_attr_default_value_ptr.optionalValue(zcu) orelse break :d .none;
-            assert(any_default_inits);
-            const ptr_ty = try pt.singleConstPtrType(field_ty);
-            // The first loop checked that this is comptime-dereferencable.
-            const deref_val = (try sema.pointerDeref(block, field_attrs_src, ptr_val, ptr_ty)).?;
-            // ...but we've not checked this yet!
-            if (deref_val.canMutateComptimeVarState(zcu)) {
-                return sema.failWithContainsReferenceToComptimeVar(block, field_attrs_src, field_name, "field default value", deref_val);
+                if (field_attr_align.optionalValue(zcu)) |field_align_val| {
+                    const bytes = field_align_val.toUnsignedInt(zcu);
+                    // No source location; first loop checked this is valid.
+                    const a = try sema.validateAlign(block, .unneeded, bytes);
+                    wip.field_aligns.get(ip)[field_idx] = a;
+                } else if (any_field_aligns) {
+                    wip.field_aligns.get(ip)[field_idx] = .none;
+                }
             }
-            break :d deref_val.toIntern();
-        };
 
-        if (field_attr_comptime.toBool() and field_default == .none) {
-            return sema.fail(block, field_attrs_src, "comptime field without default initialization value", .{});
-        }
-
-        switch (field_ty.zigTypeTag(zcu)) {
-            .@"opaque" => return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(field_types_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
-                errdefer msg.destroy(gpa);
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            }),
-            .noreturn => return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(field_types_src, "struct fields cannot be 'noreturn'", .{});
-                errdefer msg.destroy(gpa);
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            }),
-            else => {},
-        }
-
-        switch (layout) {
-            .auto => {},
-            .@"extern" => if (!try sema.validateExternType(field_ty, .struct_field)) {
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(field_types_src, "extern structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(gpa);
-                    try sema.explainWhyTypeIsNotExtern(msg, field_types_src, field_ty, .struct_field);
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                });
-            },
-            .@"packed" => if (!field_ty.packable(zcu)) {
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(field_types_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(gpa);
-                    try sema.explainWhyTypeIsNotPackable(msg, field_types_src, field_ty);
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                });
-            },
-        }
-
-        wip_struct_type.field_types.get(ip)[field_idx] = field_ty.toIntern();
-        if (field_default != .none) {
-            wip_struct_type.field_defaults.get(ip)[field_idx] = field_default;
-        }
-
-        if (field_attr_align.optionalValue(zcu)) |field_align_val| {
-            assert(layout != .@"packed");
-            const bytes = field_align_val.toUnsignedInt(zcu);
-            const a = try sema.validateAlign(block, field_attrs_src, bytes);
-            wip_struct_type.field_aligns.get(ip)[field_idx] = a;
-        } else if (any_aligned_fields) {
-            assert(layout != .@"packed");
-            wip_struct_type.field_aligns.get(ip)[field_idx] = .none;
-        }
-    }
-
-    if (layout == .@"packed") {
-        var field_bits: u64 = 0;
-        for (0..fields_len) |field_idx| {
-            const field_ty: Type = .fromInterned(wip_struct_type.field_types.get(ip)[field_idx]);
-            try sema.ensureLayoutResolved(field_ty);
-            field_bits += field_ty.bitSize(zcu);
-        }
-        try type_resolution.resolvePackedStructBackingInt(
-            sema,
-            block,
-            field_bits,
-            .fromInterned(wip_ty.index),
-            &wip_struct_type,
-        );
-    } else {
-        try type_resolution.finishStructLayout(
-            sema,
-            block,
-            src,
-            wip_ty.index,
-            &wip_struct_type,
-        );
-    }
-
-    const new_namespace_index = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
+            const new_namespace_index = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
+            });
+            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
+
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entries
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+
+            return .fromIntern(wip.finish(ip, new_namespace_index));
+        },
     }
-    try sema.addTypeReferenceEntry(src, .fromInterned(wip_ty.index));
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return .fromIntern(wip_ty.finish(ip, new_namespace_index));
 }
 
 fn zirReifyUnion(
@@ -20390,7 +20335,10 @@ fn zirReifyUnion(
 
     const arg_ty_uncoerced = try sema.resolveInst(extra.arg_ty);
     const arg_ty_coerced = try sema.coerce(block, .optional_type, arg_ty_uncoerced, arg_ty_src);
-    const arg_ty_val = try sema.resolveConstDefinedValue(block, arg_ty_src, arg_ty_coerced, .{ .simple = .type });
+    const arg_ty_val = try sema.resolveConstDefinedValue(block, arg_ty_src, arg_ty_coerced, switch (layout) {
+        .@"packed" => .{ .simple = .packed_union_backing_int_type },
+        .auto, .@"extern" => .{ .simple = .union_enum_tag_type },
+    });
 
     const field_names_uncoerced = try sema.resolveInst(extra.field_names);
     const field_names_coerced = try sema.coerce(block, .slice_const_slice_const_u8, field_names_uncoerced, field_names_src);
@@ -20430,39 +20378,20 @@ fn zirReifyUnion(
         return sema.failWithUseOfUndef(block, arg_ty_src, null);
     }
 
-    // The validation work here is non-trivial, and it's possible the type already exists.
-    // So in this first pass, let's just construct a hash to optimize for this case. If the
-    // inputs turn out to be invalid, we can cancel the WIP type later.
+    // Most validation of this type happens during type resolution. We basically need to do the work
+    // which AstGen would normally do. An exception is checking for duplicate field names, which is
+    // handled by type resolution---it just simplifies some logic a little.
 
-    var any_aligned_fields = false;
+    // As well as validation, we're going to gather some information about the fields, and construct
+    // a hash representing the inputs for deduplication purposes.
+
+    var any_field_aligns = false;
 
-    // For deduplication purposes, we must create a hash including all details of this type.
     // TODO: use a longer hash!
     var hasher = std.hash.Wyhash.init(0);
     std.hash.autoHash(&hasher, layout);
     std.hash.autoHash(&hasher, arg_ty_val);
-    // `field_types_arr` and `field_attrs_arr` are already deduplicated by the InternPool!
-    std.hash.autoHash(&hasher, field_types_arr);
-    std.hash.autoHash(&hasher, field_attrs_arr);
-    // However, for field names, we need to iterate the individual fields, because the pointers (the
-    // names are slices) mean that distinct values could ultimately result in the same union type.
-    for (0..fields_len) |field_idx| {
-        const field_name_val = try field_names_arr.elemValue(pt, field_idx);
-        const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, .{ .simple = .union_field_names });
-        std.hash.autoHash(&hasher, field_name);
 
-        const field_attrs = try sema.interpretBuiltinType(
-            block,
-            field_attrs_src,
-            try field_attrs_arr.elemValue(pt, field_idx),
-            std.builtin.Type.UnionField.Attributes,
-        );
-        if (field_attrs.@"align" != null) {
-            any_aligned_fields = true;
-        }
-    }
-
-    // Some basic validation to avoid a bogus `getUnionType` call...
     const explicit_tag_ty: ?Type, const explicit_packed_backing_type: ?Type = ty: {
         const arg_ty = arg_ty_val.optionalValue(zcu) orelse break :ty .{ null, null };
         switch (layout) {
@@ -20471,235 +20400,101 @@ fn zirReifyUnion(
             .auto => break :ty .{ arg_ty.toType(), null },
         }
     };
-    if (any_aligned_fields and layout == .@"packed") {
-        return sema.fail(block, field_attrs_src, "packed union fields cannot be aligned", .{});
+
+    // `field_types_arr` and `field_attrs_arr` are already deduplicated by the InternPool!
+    std.hash.autoHash(&hasher, field_types_arr);
+    std.hash.autoHash(&hasher, field_attrs_arr);
+    // However, for field names, we need to iterate the individual fields, because the pointers (the
+    // names are slices) mean that distinct values could ultimately result in the same union type.
+    for (0..fields_len) |field_idx| {
+        const field_name_val = try field_names_arr.elemValue(pt, field_idx);
+        const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, .{ .simple = .union_field_names });
+        std.hash.autoHash(&hasher, field_name);
+
+        const field_attrs = try sema.interpretBuiltinType(
+            block,
+            field_attrs_src,
+            try field_attrs_arr.elemValue(pt, field_idx),
+            std.builtin.Type.UnionField.Attributes,
+        );
+        if (field_attrs.@"align") |bytes| {
+            if (layout == .@"packed") {
+                return sema.fail(block, field_attrs_src, "packed union fields cannot be aligned", .{});
+            }
+            // Trigger a compile error if the alignment is invalid.
+            _ = try sema.validateAlign(block, field_attrs_src, bytes);
+            any_field_aligns = true;
+        }
     }
 
-    const wip_ty = switch (try ip.getUnionType(gpa, io, pt.tid, .{
+    switch (try ip.getReifiedUnionType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .type_hash = hasher.final(),
         .fields_len = @intCast(fields_len),
         .layout = layout,
-        .explicit_packed_backing_type = if (explicit_packed_backing_type) |t| t.toIntern() else .none,
+        .any_field_aligns = any_field_aligns,
         .runtime_tag = rt: {
             if (explicit_tag_ty != null) break :rt .tagged;
             if (layout == .auto and block.wantSafeTypes()) break :rt .safety;
             break :rt .none;
         },
-        .have_explicit_enum_tag = explicit_tag_ty != null,
-        .any_field_aligns = any_aligned_fields,
-        .key = .{ .reified = .{
-            .zir_index = tracked_inst,
-            .type_hash = hasher.final(),
-        } },
+        .enum_tag_type = if (explicit_tag_ty) |ty| ty.toIntern() else .none,
+        .packed_backing_int_type = if (explicit_packed_backing_type) |ty| ty.toIntern() else .none,
     })) {
-        .wip => |wip| wip,
         .existing => |ty| {
             try sema.addTypeReferenceEntry(src, .fromInterned(ty));
             return .fromIntern(ty);
         },
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
-
-    const type_name = try (try sema.createTypeName(
-        block,
-        name_strategy,
-        "union",
-        inst,
-    )).apply(&wip_ty, pt);
-
-    const loaded_union = ip.loadUnionType(wip_ty.index);
-
-    const generated_tag_ty: InternPool.Index = if (explicit_tag_ty) |enum_tag_ty| generated_tag: {
-        if (enum_tag_ty.zigTypeTag(zcu) != .@"enum") {
-            return sema.fail(block, arg_ty_src, "tag type must be an enum type", .{});
-        }
-
-        const tag_ty_fields_len = enum_tag_ty.enumFieldCount(zcu);
-
-        for (0..fields_len) |field_idx| {
-            const field_name_val = try field_names_arr.elemValue(pt, field_idx);
-            // Don't pass a reason; first loop acts as a check that this is valid.
-            const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
-
-            if (field_idx >= tag_ty_fields_len) {
-                return sema.fail(block, field_names_src, "no field named '{f}' in enum '{f}'", .{
-                    field_name.fmt(ip), enum_tag_ty.fmt(pt),
-                });
-            }
-
-            const enum_field_name = enum_tag_ty.enumFieldName(field_idx, zcu);
-            if (enum_field_name != field_name) {
-                return sema.fail(block, field_names_src, "union field name '{f}' does not match enum field name '{f}'", .{
-                    field_name.fmt(ip), enum_field_name.fmt(ip),
-                });
-            }
-        }
-        if (tag_ty_fields_len > fields_len) return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(field_names_src, "{d} enum fields missing in union", .{
-                tag_ty_fields_len - fields_len,
-            });
-            errdefer msg.destroy(gpa);
-            for (fields_len..tag_ty_fields_len) |enum_field_idx| {
-                try sema.addFieldErrNote(enum_tag_ty, enum_field_idx, msg, "field '{f}' missing, declared here", .{
-                    enum_tag_ty.enumFieldName(enum_field_idx, zcu).fmt(ip),
-                });
+        .wip => |wip| {
+            errdefer wip.cancel(ip, pt.tid);
+            try sema.setTypeName(block, &wip, name_strategy, "union", inst);
+
+            for (0..fields_len) |field_idx| {
+                const field_name_val = try field_names_arr.elemValue(pt, field_idx);
+                // No source location or reason; first loop checked this is valid.
+                const field_name = try sema.sliceToIpString(block, .unneeded, field_name_val, undefined);
+                wip.field_names.get(ip)[field_idx] = field_name;
+
+                const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
+                wip.field_types.get(ip)[field_idx] = field_ty.toIntern();
+
+                // No source location; first loop checked this is valid.
+                const field_attrs = try sema.interpretBuiltinType(
+                    block,
+                    .unneeded,
+                    try field_attrs_arr.elemValue(pt, field_idx),
+                    std.builtin.Type.UnionField.Attributes,
+                );
+                if (field_attrs.@"align") |bytes| {
+                    // No source location; first loop checked this is valid.
+                    const a = try sema.validateAlign(block, .unneeded, bytes);
+                    wip.field_aligns.get(ip)[field_idx] = a;
+                } else if (any_field_aligns) {
+                    wip.field_aligns.get(ip)[field_idx] = .none;
+                }
             }
-            try sema.addDeclaredHereNote(msg, enum_tag_ty);
-            break :msg msg;
-        });
-        wip_ty.setTagType(ip, enum_tag_ty.toIntern());
-        break :generated_tag .none;
-    } else generated_tag: {
-        // Generate the union's hypothetical tag type.
-        const wip_tag_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
-            .fields_len = @intCast(fields_len),
-            .explicit_int_tag_type = .none,
-            .nonexhaustive = false,
-            .key = .{ .generated_union_tag = wip_ty.index },
-        })) {
-            .existing => unreachable, // enum type is keyed on this union type which we're only just creating
-            .wip => |wip_tag_ty| wip_tag_ty,
-        };
-        errdefer wip_tag_ty.cancel(ip, pt.tid);
-
-        // Set its name based on the union's name
-        _ = wip_tag_ty.setName(ip, try ip.getOrPutStringFmt(
-            gpa,
-            io,
-            pt.tid,
-            "@typeInfo({f}).@\"union\".tag_type.?",
-            .{type_name.fmt(ip)},
-            .no_embedded_nulls,
-        ), .none);
 
-        // Populate its fields (and report any duplicates)
-        for (0..fields_len) |field_idx| {
-            const field_name_val = try field_names_arr.elemValue(pt, field_idx);
-            // Don't pass a reason; first loop acts as a check that this is valid.
-            const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
-            if (wip_tag_ty.nextField(ip, field_name, false)) |prev_field_idx| return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(src, "duplicate union field '{f}' at index '{d}", .{ field_name.fmt(ip), field_idx });
-                errdefer msg.destroy(gpa);
-                try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_idx});
-                break :msg msg;
+            const new_namespace_index = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
             });
-        }
-
-        // Populate the enum tag type's *integer* tag type
-        wip_tag_ty.setTagType(ip, int_tag_ty: {
-            // Infer the int tag type from the field count
-            const bits = Type.smallestUnsignedBits(fields_len -| 1);
-            break :int_tag_ty (try pt.intType(.unsigned, bits)).toIntern();
-        });
-
-        // Lastly, it needs a dummy namespace
-        const enum_tag_type_namespace = try pt.createNamespace(.{
-            .parent = block.namespace.toOptional(),
-            .owner_type = wip_tag_ty.index,
-            .file_scope = block.getFileScopeIndex(zcu),
-            .generation = zcu.generation,
-        });
-        errdefer pt.destroyNamespace(enum_tag_type_namespace);
-
-        wip_ty.setTagType(ip, wip_tag_ty.index);
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
 
-        break :generated_tag wip_tag_ty.finish(ip, enum_tag_type_namespace);
-    };
-    // If we fail to create the union type, we must delete the generated enum tag type, since it
-    // would hold a reference to the deleted union.
-    errdefer if (generated_tag_ty != .none) ip.remove(pt.tid, generated_tag_ty);
+            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
 
-    for (0..fields_len) |field_idx| {
-        const field_ty = (try field_types_arr.elemValue(pt, field_idx)).toType();
-        const field_attrs = try sema.interpretBuiltinType(
-            block,
-            field_attrs_src,
-            try field_attrs_arr.elemValue(pt, field_idx),
-            std.builtin.Type.UnionField.Attributes,
-        );
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entry
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
 
-        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
-            return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(field_types_src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
-                errdefer msg.destroy(gpa);
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            });
-        }
-
-        switch (layout) {
-            .auto => {},
-            .@"extern" => if (!try sema.validateExternType(field_ty, .union_field)) {
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(field_types_src, "extern unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(gpa);
-
-                    try sema.explainWhyTypeIsNotExtern(msg, field_types_src, field_ty, .union_field);
-
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                });
-            },
-            .@"packed" => if (!field_ty.packable(zcu)) {
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(field_types_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                    errdefer msg.destroy(gpa);
-
-                    try sema.explainWhyTypeIsNotPackable(msg, field_types_src, field_ty);
-
-                    try sema.addDeclaredHereNote(msg, field_ty);
-                    break :msg msg;
-                });
-            },
-        }
-
-        loaded_union.field_types.get(ip)[field_idx] = field_ty.toIntern();
-        if (field_attrs.@"align") |bytes| {
-            assert(layout != .@"packed");
-            const a = try sema.validateAlign(block, field_attrs_src, bytes);
-            loaded_union.field_aligns.get(ip)[field_idx] = a;
-        } else if (any_aligned_fields) {
-            assert(layout != .@"packed");
-            loaded_union.field_aligns.get(ip)[field_idx] = .none;
-        }
-    }
-
-    if (layout == .@"packed") {
-        try type_resolution.resolvePackedUnionBackingInt(
-            sema,
-            block,
-            .fromInterned(wip_ty.index),
-            &loaded_union,
-            true,
-        );
-    } else {
-        try type_resolution.finishUnionLayout(
-            sema,
-            block,
-            src,
-            wip_ty.index,
-            &loaded_union,
-            explicit_tag_ty orelse .fromInterned(generated_tag_ty),
-        );
-    }
-
-    const new_namespace_index = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
-
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
-    try sema.addTypeReferenceEntry(src, .fromInterned(wip_ty.index));
-    if (zcu.comp.debugIncremental()) {
-        try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
+            return .fromIntern(wip.finish(ip, new_namespace_index));
+        },
     }
-    return .fromIntern(wip_ty.finish(ip, new_namespace_index));
 }
 
 fn zirReifyEnum(
@@ -20754,10 +20549,10 @@ fn zirReifyEnum(
 
     const enum_mode_ty = try sema.getBuiltinType(mode_src, .@"Type.Enum.Mode");
 
-    const tag_ty = try sema.resolveType(block, tag_ty_src, extra.tag_ty);
-    if (tag_ty.zigTypeTag(zcu) != .int) {
-        return sema.fail(block, tag_ty_src, "tag type must be an integer type", .{});
-    }
+    const tag_ty_uncoerced = try sema.resolveInst(extra.tag_ty);
+    const tag_ty_coerced = try sema.coerce(block, .type, tag_ty_uncoerced, tag_ty_src);
+    const tag_ty_val = try sema.resolveConstDefinedValue(block, tag_ty_src, tag_ty_coerced, .{ .simple = .enum_int_tag_type });
+    const tag_ty = tag_ty_val.toType();
 
     const mode_uncoerced = try sema.resolveInst(extra.mode);
     const mode_coerced = try sema.coerce(block, enum_mode_ty, mode_uncoerced, mode_src);
@@ -20790,11 +20585,13 @@ fn zirReifyEnum(
     }
     // We don't need to check `field_names_arr`, because `sliceToIpString` will check that for us.
 
-    // The validation work here is non-trivial, and it's possible the type already exists.
-    // So in this first pass, let's just construct a hash to optimize for this case. If the
-    // inputs turn out to be invalid, we can cancel the WIP type later.
+    // Most validation of this type happens during type resolution. We basically need to do the work
+    // which AstGen would normally do. An exception is checking for duplicate field names, which is
+    // handled by type resolution---it just simplifies some logic a little.
+
+    // As well as validation, we're going to gather some information about the fields, and construct
+    // a hash representing the inputs for deduplication purposes.
 
-    // For deduplication purposes, we must create a hash including all details of this type.
     // TODO: use a longer hash!
     var hasher = std.hash.Wyhash.init(0);
     std.hash.autoHash(&hasher, tag_ty.toIntern());
@@ -20810,85 +20607,55 @@ fn zirReifyEnum(
         std.hash.autoHash(&hasher, field_name);
     }
 
-    const wip_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
+    switch (try ip.getReifiedEnumType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .type_hash = hasher.final(),
         .fields_len = @intCast(fields_len),
-        .explicit_int_tag_type = tag_ty.toIntern(),
         .nonexhaustive = nonexhaustive,
-        .key = .{ .reified = .{
-            .zir_index = tracked_inst,
-            .type_hash = hasher.final(),
-        } },
+        .int_tag_type = tag_ty.toIntern(),
     })) {
-        .wip => |wip| wip,
         .existing => |ty| {
             try sema.addTypeReferenceEntry(src, .fromInterned(ty));
             return .fromIntern(ty);
         },
-    };
-    errdefer wip_ty.cancel(ip, pt.tid);
+        .wip => |wip| {
+            errdefer wip.cancel(ip, pt.tid);
 
-    _ = try (try sema.createTypeName(
-        block,
-        name_strategy,
-        "enum",
-        inst,
-    )).apply(&wip_ty, pt);
+            try sema.setTypeName(block, &wip, name_strategy, "enum", inst);
 
-    for (0..fields_len) |field_idx| {
-        const field_name_val = try field_names_arr.elemValue(pt, field_idx);
-        // Don't pass a reason; first loop acts as a check that this is valid.
-        const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, undefined);
-        if (wip_ty.nextField(ip, field_name, false)) |prev_field_idx| return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(field_names_src, "duplicate enum field '{f}' at index '{d}'", .{ field_name.fmt(ip), field_idx });
-            errdefer msg.destroy(gpa);
-            try sema.errNote(field_names_src, msg, "previous field at index '{d}'", .{prev_field_idx});
-            break :msg msg;
-        });
-    }
+            // Populate field names and values. Duplicate checking will be handled by type resolution.
+            for (0..fields_len) |field_index| {
+                const field_name_val = try field_names_arr.elemValue(pt, field_index);
+                // No source location or reason; first loop checked this is valid.
+                const field_name = try sema.sliceToIpString(block, .unneeded, field_name_val, undefined);
+                wip.field_names.get(ip)[field_index] = field_name;
 
-    const enum_obj = ip.loadEnumType(wip_ty.index);
-    const field_value_map = enum_obj.field_value_map.unwrap().?;
-    for (0..fields_len) |field_idx| {
-        const field_val = try field_values_arr.elemValue(pt, field_idx);
-        const field_values = enum_obj.field_values.get(ip);
-        field_values[field_idx] = field_val.toIntern();
-        const adapter: InternPool.Index.Adapter = .{ .indexes = field_values[0..field_idx] };
-        const gop = field_value_map.get(ip).getOrPutAssumeCapacityAdapted(field_val.toIntern(), adapter);
-        if (gop.found_existing) return sema.failWithOwnedErrorMsg(block, msg: {
-            const field_names = enum_obj.field_names.get(ip);
-            const this_field_name = field_names[field_idx];
-            const prev_field_name = field_names[gop.index];
-            const msg = try sema.errMsg(field_names_src, "duplicate enum tag value '{f}' in field '{f}'", .{
-                field_val.fmtValueSema(pt, sema),
-                this_field_name.fmt(ip),
+                const field_val = try field_values_arr.elemValue(pt, field_index);
+                wip.field_values.get(ip)[field_index] = field_val.toIntern();
+            }
+
+            const new_namespace_index = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
             });
-            errdefer msg.destroy(gpa);
-            try sema.errNote(field_names_src, msg, "previous usage in field '{f}'", .{prev_field_name.fmt(ip)});
-            break :msg msg;
-        });
-    }
 
-    if (nonexhaustive and fields_len > 1 and std.math.log2_int(u64, fields_len) == tag_ty.bitSize(zcu)) {
-        return sema.fail(block, src, "non-exhaustive enum specified every value", .{});
-    }
+            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-    const new_namespace_index = try pt.createNamespace(.{
-        .parent = block.namespace.toOptional(),
-        .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = zcu.generation,
-    });
+            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
 
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (block.ownerModule().strip) break :codegen_type;
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
-    }
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entry
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
 
-    try sema.addTypeReferenceEntry(src, .fromInterned(wip_ty.index));
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip_ty.index);
-    return .fromIntern(wip_ty.finish(ip, new_namespace_index));
+            return .fromIntern(wip.finish(ip, new_namespace_index));
+        },
+    }
 }
 
 fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref {
@@ -20909,7 +20676,7 @@ fn zirCVaArg(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
     const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.lhs);
     const arg_ty = try sema.resolveType(block, ty_src, extra.rhs);
 
-    if (!try sema.validateExternType(arg_ty, .param_ty)) {
+    if (!arg_ty.validateExtern(.param_ty, sema.pt.zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(ty_src, "cannot get '{f}' from variadic argument", .{arg_ty.fmt(sema.pt)});
             errdefer msg.destroy(sema.gpa);
@@ -24205,8 +23972,8 @@ fn zirMemcpy(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
-    const dest_elem_ty = dest_ty.indexablePtrElem(zcu);
-    const src_elem_ty = src_ty.indexablePtrElem(zcu);
+    const dest_elem_ty = dest_ty.indexableElem(zcu);
+    const src_elem_ty = src_ty.indexableElem(zcu);
 
     try sema.ensureLayoutResolved(dest_elem_ty);
     try sema.ensureLayoutResolved(src_elem_ty);
@@ -24906,7 +24673,7 @@ fn zirBuiltinExtern(
     if (!ty.isPtrAtRuntime(zcu)) {
         return sema.fail(block, ty_src, "expected (optional) pointer", .{});
     }
-    if (!try sema.validateExternType(ty, .other)) {
+    if (!ty.validateExtern(.other, zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(ty_src, "extern symbol cannot have type '{f}'", .{ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
@@ -24954,7 +24721,7 @@ fn zirBuiltinExtern(
         // So, for now, just use our containing `declaration`.
         .zir_index = switch (sema.owner.unwrap()) {
             .@"comptime" => |cu| ip.getComptimeUnit(cu).zir_index,
-            .type_layout, .type_inits => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
+            .type_layout, .struct_defaults => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
             .memoized_state => unreachable,
             .nav_ty, .nav_val => |nav| ip.getNav(nav).analysis.?.zir_index,
             .func => |func| zir_index: {
@@ -25060,6 +24827,7 @@ fn zirBuiltinValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
         // Values are handled here.
         .calling_convention_c => {
             const callconv_ty = try sema.getBuiltinType(src, .CallingConvention);
+            // Cannot use `Value.uninterpret` because `c` is a *declaration* whose value depends on the target.
             return try sema.namespaceLookupVal(
                 block,
                 src,
@@ -25068,17 +24836,15 @@ fn zirBuiltinValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
             ) orelse @panic("std.builtin is corrupt");
         },
         .calling_convention_inline => {
-            comptime assert(@typeInfo(std.builtin.CallingConvention.Tag).@"enum".tag_type == u8);
             const callconv_ty = try sema.getBuiltinType(src, .CallingConvention);
-            const callconv_tag_ty = callconv_ty.unionTagType(zcu) orelse @panic("std.builtin is corrupt");
-            const inline_tag_val = try pt.enumValue(
-                callconv_tag_ty,
-                (try pt.intValue(
-                    .u8,
-                    @intFromEnum(std.builtin.CallingConvention.@"inline"),
-                )).toIntern(),
-            );
-            return sema.coerce(block, callconv_ty, Air.internedToRef(inline_tag_val.toIntern()), src);
+            return .fromValue(Value.uninterpret(
+                @as(std.builtin.CallingConvention, .@"inline"),
+                callconv_ty,
+                pt,
+            ) catch |err| switch (err) {
+                error.TypeMismatch => @panic("std.builtin is corrupt"),
+                error.OutOfMemory => |e| return e,
+            });
         },
     };
     return .fromType(try sema.getBuiltinType(src, builtin_type));
@@ -25180,7 +24946,7 @@ pub fn validateVarType(
     const zcu = pt.zcu;
     var_ty.assertHasLayout(zcu);
     if (is_extern) {
-        if (!try sema.validateExternType(var_ty, .other)) {
+        if (!var_ty.validateExtern(.other, zcu)) {
             const msg = msg: {
                 const msg = try sema.errMsg(src, "extern variable cannot have type '{f}'", .{var_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
@@ -25296,124 +25062,17 @@ fn explainWhyTypeIsComptime(
     }
 }
 
-const ExternPosition = enum {
-    ret_ty,
-    param_ty,
-    union_field,
-    struct_field,
-    element,
-    other,
-};
-
-/// Returns true if `ty` is allowed in extern types.
-/// Does not require `ty` to be resolved in any way.
-pub fn validateExternType(
-    sema: *Sema,
-    ty: Type,
-    position: ExternPosition,
-) !bool {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(zcu)) {
-        .type,
-        .comptime_float,
-        .comptime_int,
-        .enum_literal,
-        .undefined,
-        .null,
-        .error_union,
-        .error_set,
-        .frame,
-        => return false,
-        .void => return switch (position) {
-            .ret_ty,
-            .union_field,
-            .struct_field,
-            .element,
-            => true,
-            .param_ty,
-            .other,
-            => false,
-        },
-        .noreturn => return position == .ret_ty,
-        .@"opaque",
-        .bool,
-        .float,
-        .@"anyframe",
-        => return true,
-        .pointer => {
-            if (ty.isSlice(zcu)) return false;
-            const child_ty = ty.childType(zcu);
-            if (child_ty.zigTypeTag(zcu) == .@"fn") {
-                return ty.isConstPtr(zcu) and try sema.validateExternType(child_ty, .other);
-            }
-            return true;
-        },
-        .int => switch (ty.intInfo(zcu).bits) {
-            0, 8, 16, 32, 64, 128 => return true,
-            else => return false,
-        },
-        .@"fn" => {
-            if (position != .other) return false;
-            // For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI.
-            // The goal is to experiment with more integrated CPU/GPU code.
-            if (ty.fnCallingConvention(zcu) == .nvptx_kernel) {
-                return true;
-            }
-            return !target_util.fnCallConvAllowsZigTypes(ty.fnCallingConvention(zcu));
-        },
-        .@"enum" => {
-            const enum_obj = zcu.intern_pool.loadEnumType(ty.toIntern());
-            if (!enum_obj.int_tag_is_explicit) return false;
-            return sema.validateExternType(.fromInterned(enum_obj.int_tag_type), position);
-        },
-        .@"struct" => {
-            const struct_obj = zcu.intern_pool.loadStructType(ty.toIntern());
-            return switch (struct_obj.layout) {
-                .auto => false,
-                .@"extern" => true,
-                .@"packed" => switch (struct_obj.packed_backing_mode) {
-                    .auto => false,
-                    .explicit => try sema.validateExternType(.fromInterned(struct_obj.packed_backing_int_type), position),
-                },
-            };
-        },
-        .@"union" => {
-            const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
-            return switch (union_obj.layout) {
-                .auto => false,
-                .@"extern" => true,
-                .@"packed" => switch (union_obj.packed_backing_mode) {
-                    .auto => false,
-                    .explicit => try sema.validateExternType(.fromInterned(union_obj.packed_backing_int_type), position),
-                },
-            };
-        },
-        .array => {
-            if (position == .ret_ty or position == .param_ty) return false;
-            return sema.validateExternType(ty.childType(zcu), .element);
-        },
-        .vector => return sema.validateExternType(ty.childType(zcu), .element),
-        .optional => return ty.isPtrLikeOptional(zcu),
-    }
-}
-
+/// Keep in sync with `Type.validateExtern`.
 pub fn explainWhyTypeIsNotExtern(
     sema: *Sema,
     msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
     ty: Type,
-    position: ExternPosition,
+    position: Type.ExternPosition,
 ) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     switch (ty.zigTypeTag(zcu)) {
-        .@"opaque",
-        .bool,
-        .float,
-        .@"anyframe",
-        => return,
-
         .type,
         .comptime_float,
         .comptime_int,
@@ -25425,101 +25084,110 @@ pub fn explainWhyTypeIsNotExtern(
         .frame,
         => return,
 
-        .pointer => {
-            if (ty.isSlice(zcu)) {
-                try sema.errNote(src_loc, msg, "slices have no guaranteed in-memory representation", .{});
-            } else {
-                const pointee_ty = ty.childType(zcu);
-                if (!ty.isConstPtr(zcu) and pointee_ty.zigTypeTag(zcu) == .@"fn") {
-                    try sema.errNote(src_loc, msg, "pointer to extern function must be 'const'", .{});
-                }
-                try sema.explainWhyTypeIsNotExtern(msg, src_loc, pointee_ty, .other);
-            }
-        },
-        .void => try sema.errNote(src_loc, msg, "'void' is a zero bit type; for C 'void' use 'anyopaque'", .{}),
+        .void => try sema.errNote(src_loc, msg, "'void' is a zero bit type", .{}),
         .noreturn => try sema.errNote(src_loc, msg, "'noreturn' is only allowed as a return type", .{}),
+
+        .@"opaque",
+        .bool,
+        .float,
+        .@"anyframe",
+        => unreachable, // these *are* allowed
+
+        .pointer => if (ty.isSlice(zcu)) {
+            try sema.errNote(src_loc, msg, "slices have no guaranteed in-memory representation", .{});
+        } else {
+            assert(ty.childType(zcu).zigTypeTag(zcu) == .@"fn");
+            if (!ty.isConstPtr(zcu)) {
+                try sema.errNote(src_loc, msg, "pointer to extern function must be 'const'", .{});
+            } else {
+                try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.childType(zcu), .other);
+            }
+        },
         .int => if (!std.math.isPowerOfTwo(ty.intInfo(zcu).bits)) {
             try sema.errNote(src_loc, msg, "only integers with 0 or power of two bits are extern compatible", .{});
         } else {
             try sema.errNote(src_loc, msg, "only integers with 0, 8, 16, 32, 64 and 128 bits are extern compatible", .{});
         },
-        .@"fn" => {
-            if (position != .other) {
-                try sema.errNote(src_loc, msg, "type has no guaranteed in-memory representation", .{});
-                try sema.errNote(src_loc, msg, "use '*const ' to make a function pointer type", .{});
-                return;
-            }
-            switch (ty.fnCallingConvention(zcu)) {
-                .auto => try sema.errNote(src_loc, msg, "extern function must specify calling convention", .{}),
-                .async => try sema.errNote(src_loc, msg, "async function cannot be extern", .{}),
-                .@"inline" => try sema.errNote(src_loc, msg, "inline function cannot be extern", .{}),
-                else => return,
-            }
+        .@"fn" => if (position != .other) {
+            try sema.errNote(src_loc, msg, "type has no guaranteed in-memory representation", .{});
+            try sema.errNote(src_loc, msg, "use '*const ' to make a function pointer type", .{});
+        } else switch (ty.fnCallingConvention(zcu)) {
+            .auto => try sema.errNote(src_loc, msg, "extern function must specify calling convention", .{}),
+            else => |cc| try sema.errNote(src_loc, msg, "{t} function cannot be extern", .{cc}),
         },
         .@"enum" => {
             const tag_ty = ty.intTagType(zcu);
             try sema.errNote(src_loc, msg, "enum tag type '{f}' is not extern compatible", .{tag_ty.fmt(pt)});
             try sema.explainWhyTypeIsNotExtern(msg, src_loc, tag_ty, position);
         },
-        // MLUGG TODO: these notes are bad now (because ABI sized packed type also needs explicit backing type)
-        .@"struct" => try sema.errNote(src_loc, msg, "only extern structs and ABI sized packed structs are extern compatible", .{}),
-        .@"union" => try sema.errNote(src_loc, msg, "only extern unions and ABI sized packed unions are extern compatible", .{}),
-        .array => {
-            if (position == .ret_ty) {
-                return sema.errNote(src_loc, msg, "arrays are not allowed as a return type", .{});
-            } else if (position == .param_ty) {
-                return sema.errNote(src_loc, msg, "arrays are not allowed as a parameter type", .{});
+        .@"struct" => {
+            const struct_obj = zcu.intern_pool.loadStructType(ty.toIntern());
+            switch (struct_obj.layout) {
+                .auto => try sema.errNote(src_loc, msg, "struct with automatic layout has no guaranteed in-memory representation", .{}),
+                .@"extern" => unreachable,
+                .@"packed" => switch (struct_obj.packed_backing_mode) {
+                    .auto => try sema.errNote(src_loc, msg, "inferred backing integer of packed struct has unspecified signedness", .{}),
+                    .explicit => {
+                        const backing_int_ty: Type = .fromInterned(struct_obj.packed_backing_int_type);
+                        try sema.errNote(src_loc, msg, "packed struct backing integer type '{f}' is not extern compatible", .{backing_int_ty.fmt(pt)});
+                        try sema.explainWhyTypeIsNotExtern(msg, src_loc, backing_int_ty, position);
+                    },
+                },
             }
-            try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.childType(zcu), .element);
+        },
+        .@"union" => {
+            const union_obj = zcu.intern_pool.loadStructType(ty.toIntern());
+            switch (union_obj.layout) {
+                .auto => try sema.errNote(src_loc, msg, "union with automatic layout has no guaranteed in-memory representation", .{}),
+                .@"extern" => unreachable,
+                .@"packed" => switch (union_obj.packed_backing_mode) {
+                    .auto => try sema.errNote(src_loc, msg, "inferred backing integer of packed union has unspecified signedness", .{}),
+                    .explicit => {
+                        const backing_int_ty: Type = .fromInterned(union_obj.packed_backing_int_type);
+                        try sema.errNote(src_loc, msg, "packed union backing integer type '{f}' is not extern compatible", .{backing_int_ty.fmt(pt)});
+                        try sema.explainWhyTypeIsNotExtern(msg, src_loc, backing_int_ty, position);
+                    },
+                },
+            }
+        },
+        .array => switch (position) {
+            .ret_ty => try sema.errNote(src_loc, msg, "arrays are not allowed as a return type", .{}),
+            .param_ty => try sema.errNote(src_loc, msg, "arrays are not allowed as a parameter type", .{}),
+            else => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.childType(zcu), .element),
         },
         .vector => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.childType(zcu), .element),
-        .optional => try sema.errNote(src_loc, msg, "only pointer like optionals are extern compatible", .{}),
+        .optional => try sema.errNote(src_loc, msg, "non-pointer optionals have no guaranteed in-memory representation", .{}),
     }
 }
 
-pub fn explainWhyTypeIsNotPackable(
+pub fn explainWhyTypeIsUnpackable(
     sema: *Sema,
     msg: *Zcu.ErrorMsg,
-    src_loc: LazySrcLoc,
-    ty: Type,
+    src: LazySrcLoc,
+    reason: Type.UnpackableReason,
 ) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    switch (ty.zigTypeTag(zcu)) {
-        .void,
-        .bool,
-        .float,
-        .int,
-        .vector,
-        .@"enum",
-        => return,
-        .type,
-        .comptime_float,
-        .comptime_int,
-        .enum_literal,
-        .undefined,
-        .null,
-        .frame,
-        .noreturn,
-        .@"opaque",
-        .error_union,
-        .error_set,
-        .@"anyframe",
-        .optional,
-        .array,
-        => try sema.errNote(src_loc, msg, "type has no guaranteed in-memory representation", .{}),
-        .pointer => if (ty.isSlice(zcu)) {
-            try sema.errNote(src_loc, msg, "slices have no guaranteed in-memory representation", .{});
-        } else {
-            try sema.errNote(src_loc, msg, "comptime-only pointer has no guaranteed in-memory representation", .{});
-            try sema.explainWhyTypeIsComptime(msg, src_loc, ty);
+    switch (reason) {
+        .comptime_only => try sema.errNote(src, msg, "comptime-only types have no bit-packed representation", .{}),
+        .pointer => {
+            try sema.errNote(src, msg, "pointers cannot be directly bitpacked", .{});
+            try sema.errNote(src, msg, "consider using 'usize' and '@intFromPtr'", .{});
         },
-        .@"fn" => {
-            try sema.errNote(src_loc, msg, "type has no guaranteed in-memory representation", .{});
-            try sema.errNote(src_loc, msg, "use '*const ' to make a function pointer type", .{});
+        .enum_inferred_int_tag => |enum_ty| {
+            const enum_src = enum_ty.srcLoc(zcu);
+            try sema.errNote(enum_src, msg, "integer tag type of enum is inferred", .{});
+            try sema.errNote(enum_src, msg, "consider explicitly specifying the integer tag type", .{});
         },
-        .@"struct" => try sema.errNote(src_loc, msg, "struct in packed type must have packed layout", .{}),
-        .@"union" => try sema.errNote(src_loc, msg, "union in packed type must have packed layout", .{}),
+        .non_packed_struct => |struct_ty| {
+            try sema.errNote(src, msg, "non-packed structs do not have a bit-packed representation", .{});
+            try sema.addDeclaredHereNote(msg, struct_ty);
+        },
+        .non_packed_union => |union_ty| {
+            try sema.errNote(src, msg, "non-packed unions do not have a bit-packed representation", .{});
+            try sema.addDeclaredHereNote(msg, union_ty);
+        },
+        .other => try sema.errNote(src, msg, "type does not have a bit-packed representation", .{}),
     }
 }
 
@@ -25545,7 +25213,7 @@ fn getPanicIdFunc(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !In
     try sema.ensureMemoizedStateResolved(src, .panic);
     const panic_fn_index = zcu.builtin_decl_values.get(panic_id.toBuiltin());
     switch (sema.owner.unwrap()) {
-        .@"comptime", .nav_ty, .nav_val, .type_layout, .type_inits, .memoized_state => {},
+        .@"comptime", .nav_ty, .nav_val, .type_layout, .struct_defaults, .memoized_state => {},
         .func => |owner_func| zcu.intern_pool.funcSetHasErrorTrace(io, owner_func, true),
     }
     return panic_fn_index;
@@ -25962,6 +25630,7 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
+                    try sema.ensureLayoutResolved(child_type);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index_usize| {
                             const field_index: u32 = @intCast(field_index_usize);
@@ -25974,6 +25643,7 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
+                    try sema.ensureLayoutResolved(child_type);
                     const field_index_usize = child_type.enumFieldIndex(field_name, zcu) orelse
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     const field_index: u32 = @intCast(field_index_usize);
@@ -26195,6 +25865,7 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
+                    try sema.ensureLayoutResolved(child_type);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index| {
                             const field_index_u32: u32 = @intCast(field_index);
@@ -26208,6 +25879,7 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
+                    try sema.ensureLayoutResolved(child_type);
                     const field_index = child_type.enumFieldIndex(field_name, zcu) orelse {
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     };
@@ -26444,9 +26116,6 @@ fn finishFieldCallBind(
     const container_ty = ptr_ty.childType(zcu);
     if (container_ty.zigTypeTag(zcu) == .@"struct") {
         if (container_ty.structFieldIsComptime(field_index, zcu)) {
-            if (!container_ty.isTuple(zcu)) {
-                try sema.ensureFieldInitsResolved(container_ty);
-            }
             const default_val = (try container_ty.structFieldValueComptime(pt, field_index)).?;
             return .{ .direct = Air.internedToRef(default_val.toIntern()) };
         }
@@ -26623,7 +26292,7 @@ fn structFieldPtrByIndex(
     const ptr_field_ty = try pt.ptrType(ptr_ty_data);
 
     if (field_is_comptime) {
-        try sema.ensureFieldInitsResolved(struct_ty);
+        assert(struct_type.field_defaults.get(ip)[field_index] != .none);
         const val = try pt.intern(.{ .ptr = .{
             .ty = ptr_field_ty.toIntern(),
             .base_addr = .{ .comptime_field = struct_type.field_defaults.get(ip)[field_index] },
@@ -26647,6 +26316,8 @@ fn structFieldVal(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     assert(struct_ty.zigTypeTag(zcu) == .@"struct");
+    assert(sema.typeOf(struct_byval).toIntern() == struct_ty.toIntern());
+    struct_ty.assertHasLayout(zcu);
 
     switch (ip.indexToKey(struct_ty.toIntern())) {
         .struct_type => {
@@ -26655,7 +26326,6 @@ fn structFieldVal(
             const field_index = struct_type.nameIndex(ip, field_name) orelse
                 return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_name_src, field_name);
             if (struct_type.field_is_comptime_bits.get(ip, field_index)) {
-                try sema.ensureFieldInitsResolved(struct_ty);
                 return .fromIntern(struct_type.field_defaults.get(ip)[field_index]);
             }
 
@@ -26886,6 +26556,8 @@ fn unionFieldVal(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     assert(union_ty.zigTypeTag(zcu) == .@"union");
+    assert(sema.typeOf(union_byval).toIntern() == union_ty.toIntern());
+    union_ty.assertHasLayout(zcu);
 
     const union_obj = zcu.typeToUnion(union_ty).?;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
@@ -27149,11 +26821,11 @@ fn validateRuntimeElemAccess(
             const msg = try sema.errMsg(
                 elem_index_src,
                 "values of type '{f}' must be comptime-known, but index value is runtime-known",
-                .{parent_ty.fmt(sema.pt)},
+                .{elem_ty.fmt(sema.pt)},
             );
             errdefer msg.destroy(sema.gpa);
 
-            try sema.explainWhyTypeIsComptime(msg, parent_src, parent_ty);
+            try sema.explainWhyTypeIsComptime(msg, parent_src, elem_ty);
 
             break :msg msg;
         };
@@ -27885,18 +27557,14 @@ fn coerceExtra(
                     // empty tuple to zero-length slice
                     // note that this allows coercing to a mutable slice.
                     if (inst_child_ty.structFieldCount(zcu) == 0) {
-                        // TODO MLUGG: this is *unacceptably* stupid. we're resolving the child for the alignment value
-                        try sema.ensureLayoutResolved(dest_ty.childType(zcu));
-                        const align_val = dest_ty.ptrAlignment(zcu);
-                        return Air.internedToRef(try pt.intern(.{ .slice = .{
-                            .ty = dest_ty.toIntern(),
-                            .ptr = try pt.intern(.{ .ptr = .{
-                                .ty = dest_ty.slicePtrFieldType(zcu).toIntern(),
-                                .base_addr = .int,
-                                .byte_offset = align_val.toByteUnits().?,
-                            } }),
-                            .len = .zero_usize,
-                        } }));
+                        const empty_array_ty = try pt.arrayType(.{
+                            .len = 0,
+                            .child = dest_info.child,
+                            .sentinel = dest_info.sentinel,
+                        });
+                        const empty_array_val = try pt.aggregateValue(empty_array_ty, &.{});
+                        const empty_array_ptr = try sema.uavRef(empty_array_val.toIntern());
+                        return sema.coerceArrayPtrToSlice(block, dest_ty, empty_array_ptr, inst_src);
                     }
 
                     // pointer to tuple to slice
@@ -27955,7 +27623,7 @@ fn coerceExtra(
             .int, .comptime_int => {
                 if (maybe_inst_val) |val| {
                     // comptime-known integer to other number
-                    if (!(try sema.intFitsInType(val, dest_ty, null))) {
+                    if (!val.intFitsInType(dest_ty, null, zcu)) {
                         if (!opts.report_err) return error.NotCoercible;
                         return sema.fail(block, inst_src, "type '{f}' cannot represent integer value '{f}'", .{ dest_ty.fmt(pt), val.fmtValueSema(pt, sema) });
                     }
@@ -28039,28 +27707,26 @@ fn coerceExtra(
                     }
                     break :int;
                 };
+                if (val.isUndef(zcu)) {
+                    return .fromValue(try pt.undefValue(dest_ty));
+                }
                 const result_val = try pt.floatValue(dest_ty, val.toFloat(f128, zcu));
-                const fits: bool = switch (ip.indexToKey(result_val.toIntern())) {
-                    else => unreachable,
-                    .undef => true,
-                    .float => |float| fits: {
-                        var buffer: InternPool.Key.Int.Storage.BigIntSpace = undefined;
-                        const operand_big_int = val.toBigInt(&buffer, zcu);
-                        switch (float.storage) {
-                            inline else => |x| {
-                                if (!std.math.isFinite(x)) break :fits false;
-                                var result_big_int: std.math.big.int.Mutable = .{
-                                    .limbs = try sema.arena.alloc(std.math.big.Limb, std.math.big.int.calcLimbLen(x)),
-                                    .len = undefined,
-                                    .positive = undefined,
-                                };
-                                switch (result_big_int.setFloat(x, .nearest_even)) {
-                                    .inexact => break :fits false,
-                                    .exact => {},
-                                }
-                                break :fits result_big_int.toConst().eql(operand_big_int);
-                            },
+                const float = ip.indexToKey(result_val.toIntern()).float;
+                var buffer: InternPool.Key.Int.Storage.BigIntSpace = undefined;
+                const operand_big_int = val.toBigInt(&buffer, zcu);
+                const fits = switch (float.storage) {
+                    inline else => |x| fits: {
+                        if (!std.math.isFinite(x)) break :fits false;
+                        var result_big_int: std.math.big.int.Mutable = .{
+                            .limbs = try sema.arena.alloc(std.math.big.Limb, std.math.big.int.calcLimbLen(x)),
+                            .len = undefined,
+                            .positive = undefined,
+                        };
+                        switch (result_big_int.setFloat(x, .nearest_even)) {
+                            .inexact => break :fits false,
+                            .exact => {},
                         }
+                        break :fits result_big_int.toConst().eql(operand_big_int);
                     },
                 };
                 if (!fits) return sema.fail(
@@ -28699,7 +28365,7 @@ pub fn coerceInMemoryAllowed(
     // Comptime int to regular int.
     if (dest_tag == .int and src_tag == .comptime_int) {
         if (src_val) |val| {
-            if (!(try sema.intFitsInType(val, dest_ty, null))) {
+            if (!val.intFitsInType(dest_ty, null, zcu)) {
                 return .{ .comptime_int_not_coercible = .{ .wanted = dest_ty, .actual = val } };
             }
         }
@@ -29333,7 +28999,7 @@ fn coerceVarArgParam(
             }
         },
         else => if (uncasted_ty.isAbiInt(zcu)) int: {
-            if (!try sema.validateExternType(uncasted_ty, .param_ty)) break :int inst;
+            if (!uncasted_ty.validateExtern(.param_ty, zcu)) break :int inst;
             const target = zcu.getTarget();
             const uncasted_info = uncasted_ty.intInfo(zcu);
             if (uncasted_info.bits <= target.cTypeBitSize(switch (uncasted_info.signedness) {
@@ -29362,7 +29028,7 @@ fn coerceVarArgParam(
     };
 
     const coerced_ty = sema.typeOf(coerced);
-    if (!try sema.validateExternType(coerced_ty, .param_ty)) {
+    if (!coerced_ty.validateExtern(.param_ty, zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(inst_src, "cannot pass '{f}' to variadic function", .{coerced_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
@@ -33283,12 +32949,12 @@ fn typeIsArrayLike(sema: *Sema, ty: Type) ?ArrayLike {
             .elem_ty = ty.childType(zcu),
         },
         .@"struct" => {
+            if (!ty.isTuple(zcu)) return null;
             const field_count = ty.structFieldCount(zcu);
             if (field_count == 0) return .{
                 .len = 0,
                 .elem_ty = .noreturn,
             };
-            if (!ty.isTuple(zcu)) return null;
             const elem_ty = ty.fieldType(0, zcu);
             for (1..field_count) |i| {
                 if (!ty.fieldType(i, zcu).eql(elem_ty, zcu)) {
@@ -33700,6 +33366,7 @@ fn usizeCast(sema: *Sema, block: *Block, src: LazySrcLoc, int: u64) CompileError
     return std.math.cast(usize, int) orelse return sema.fail(block, src, "expression produces integer value '{d}' which is too big for this compiler implementation to handle", .{int});
 }
 
+/// Asserts that the layout of `union_ty` is already resolved.
 fn unionFieldIndex(
     sema: *Sema,
     block: *Block,
@@ -33717,6 +33384,7 @@ fn unionFieldIndex(
     return @intCast(field_index);
 }
 
+/// Asserts that the layout of `struct_ty` is already resolved.
 fn structFieldIndex(
     sema: *Sema,
     block: *Block,
@@ -33811,64 +33479,6 @@ fn intFromFloatScalar(
     return pt.getCoerced(cti_result, int_ty);
 }
 
-/// Asserts the value is an integer, and the destination type is ComptimeInt or Int.
-/// Vectors are also accepted. Vector results are reduced with AND.
-///
-/// If provided, `vector_index` reports the first element that failed the range check.
-/// MLUGG TODO: move to `Value` or `Type`?
-fn intFitsInType(
-    sema: *Sema,
-    val: Value,
-    ty: Type,
-    vector_index: ?*usize,
-) CompileError!bool {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (ty.toIntern() == .comptime_int_type) return true;
-    const info = ty.intInfo(zcu);
-    switch (val.toIntern()) {
-        .zero_usize, .zero_u8 => return true,
-        else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-            .undef => return true,
-            .variable, .@"extern", .func, .ptr => {
-                const target = zcu.getTarget();
-                const ptr_bits = target.ptrBitWidth();
-                return switch (info.signedness) {
-                    .signed => info.bits > ptr_bits,
-                    .unsigned => info.bits >= ptr_bits,
-                };
-            },
-            .int => |int| {
-                var buffer: InternPool.Key.Int.Storage.BigIntSpace = undefined;
-                const big_int = int.storage.toBigInt(&buffer);
-                return big_int.fitsInTwosComp(info.signedness, info.bits);
-            },
-            .aggregate => |aggregate| {
-                assert(ty.zigTypeTag(zcu) == .vector);
-                return switch (aggregate.storage) {
-                    .bytes => |bytes| for (bytes.toSlice(ty.vectorLen(zcu), &zcu.intern_pool), 0..) |byte, i| {
-                        if (byte == 0) continue;
-                        const actual_needed_bits = std.math.log2(byte) + 1 + @intFromBool(info.signedness == .signed);
-                        if (info.bits >= actual_needed_bits) continue;
-                        if (vector_index) |vi| vi.* = i;
-                        break false;
-                    } else true,
-                    .elems, .repeated_elem => for (switch (aggregate.storage) {
-                        .bytes => unreachable,
-                        .elems => |elems| elems,
-                        .repeated_elem => |elem| @as(*const [1]InternPool.Index, &elem),
-                    }, 0..) |elem, i| {
-                        if (try sema.intFitsInType(Value.fromInterned(elem), ty.scalarType(zcu), null)) continue;
-                        if (vector_index) |vi| vi.* = i;
-                        break false;
-                    } else true,
-                };
-            },
-            else => unreachable,
-        },
-    }
-}
-
 fn intInRange(sema: *Sema, tag_ty: Type, int_val: Value, end: usize) !bool {
     const pt = sema.pt;
     if (!int_val.compareAllWithZero(.gte, pt.zcu)) return false;
@@ -33886,7 +33496,7 @@ fn enumHasInt(sema: *Sema, ty: Type, int: Value) CompileError!bool {
     // The `tagValueIndex` function call below relies on the type being the integer tag type.
     // `getCoerced` assumes the value will fit the new type.
     const int_tag_ty: Type = .fromInterned(enum_type.int_tag_type);
-    if (!try sema.intFitsInType(int, int_tag_ty, null)) return false;
+    if (!int.intFitsInType(int_tag_ty, null, zcu)) return false;
     const int_coerced = try pt.getCoerced(int, int_tag_ty);
     return enum_type.tagValueIndex(&zcu.intern_pool, int_coerced.toIntern()) != null;
 }
@@ -33919,7 +33529,6 @@ fn compareAll(
 }
 
 /// Asserts the values are comparable. Both operands have type `ty`.
-/// MLUGG TODO: move to `Value`?
 fn compareScalar(
     sema: *Sema,
     lhs: Value,
@@ -34422,7 +34031,7 @@ const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStor
 // MLUGG TODO: decide how to do the namespacing here
 pub const type_resolution = @import("Sema/type_resolution.zig");
 pub const ensureLayoutResolved = type_resolution.ensureLayoutResolved;
-pub const ensureFieldInitsResolved = type_resolution.ensureFieldInitsResolved;
+pub const ensureStructDefaultsResolved = type_resolution.ensureStructDefaultsResolved;
 
 pub fn getBuiltinType(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) SemaError!Type {
     assert(decl.kind() == .type);
@@ -34644,48 +34253,14 @@ fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Typ
     };
 }
 
-/// TODO MLUGG: this is a gnarly hack
-const PartialTypeName = union(enum) {
-    exact: struct {
-        name: InternPool.NullTerminatedString,
-        nav: InternPool.Nav.Index.Optional,
-    },
-    anon_prefix: []const u8,
-    fn apply(
-        name: PartialTypeName,
-        wip: *const InternPool.WipContainerType,
-        pt: Zcu.PerThread,
-    ) (Allocator.Error || std.Io.Cancelable)!InternPool.NullTerminatedString {
-        const zcu = pt.zcu;
-        const comp = zcu.comp;
-        const ip = &zcu.intern_pool;
-        switch (name) {
-            .exact => |e| {
-                wip.setName(ip, e.name, e.nav);
-                return e.name;
-            },
-            .anon_prefix => |prefix| {
-                const resolved_name = try ip.getOrPutStringFmt(
-                    comp.gpa,
-                    comp.io,
-                    pt.tid,
-                    "{s}_{d}",
-                    .{ prefix, @intFromEnum(wip.index) },
-                    .no_embedded_nulls,
-                );
-                wip.setName(ip, resolved_name, .none);
-                return resolved_name;
-            },
-        }
-    }
-};
-pub fn createTypeName(
+fn setTypeName(
     sema: *Sema,
     block: *Block,
+    wip: *const InternPool.WipContainerType,
     name_strategy: Zir.Inst.NameStrategy,
     anon_prefix: []const u8,
     inst: Zir.Inst.Index,
-) CompileError!PartialTypeName {
+) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -34693,13 +34268,26 @@ pub fn createTypeName(
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
-    switch (name_strategy) {
-        .anon => {}, // handled after switch
-        .parent => return .{ .exact = .{
-            .name = block.type_name_ctx,
-            .nav = sema.owner.unwrap().nav_val.toOptional(),
-        } },
-        .func => func_strat: {
+    strat: switch (name_strategy) {
+        .anon => {
+            // It would be neat to have "struct:line:column" but this name has
+            // to survive incremental updates, where it may have been shifted down
+            // or up to a different line, but unchanged, and thus not unnecessarily
+            // semantically analyzed.
+            // TODO: that would be possible, by detecting line number changes and renaming
+            // types appropriately. However, `@typeName` becomes a problem then. If we remove
+            // that builtin from the language, we can consider this.
+            wip.setName(ip, try ip.getOrPutStringFmt(
+                gpa,
+                io,
+                pt.tid,
+                "{f}__{s}_{d}",
+                .{ block.type_name_ctx.fmt(ip), anon_prefix, @intFromEnum(wip.index) },
+                .no_embedded_nulls,
+            ), .none);
+        },
+        .parent => wip.setName(ip, block.type_name_ctx, sema.owner.unwrap().nav_val.toOptional()),
+        .func => {
             const fn_info = sema.code.getFnInfo(ip.funcZirBodyInst(sema.func_index).resolve(ip) orelse return error.AnalysisFail);
             const zir_tags = sema.code.instructions.items(.tag);
 
@@ -34717,7 +34305,9 @@ pub fn createTypeName(
                     // If not then this is a struct type being returned from a non-generic
                     // function and the name doesn't matter since it will later
                     // result in a compile error.
-                    const arg_val = try sema.resolveValue(arg) orelse break :func_strat; // fall through to anon strat
+                    const arg_val = try sema.resolveValue(arg) orelse {
+                        continue :strat .anon;
+                    };
 
                     if (arg_i != 0) w.writeByte(',') catch return error.OutOfMemory;
 
@@ -34739,174 +34329,133 @@ pub fn createTypeName(
             };
 
             w.writeByte(')') catch return error.OutOfMemory;
-            return .{ .exact = .{
-                .name = try ip.getOrPutString(gpa, io, pt.tid, aw.written(), .no_embedded_nulls),
-                .nav = .none,
-            } };
+            const name = try ip.getOrPutString(gpa, io, pt.tid, aw.written(), .no_embedded_nulls);
+            wip.setName(ip, name, .none);
         },
         .dbg_var => {
             // TODO: this logic is questionable. We ideally should be traversing the `Block` rather than relying on the order of AstGen instructions.
             const ref = inst.toRef();
             const zir_tags = sema.code.instructions.items(.tag);
             const zir_data = sema.code.instructions.items(.data);
-            for (@intFromEnum(inst)..zir_tags.len) |i| switch (zir_tags[i]) {
+            const var_name = for (@intFromEnum(inst)..zir_tags.len) |i| switch (zir_tags[i]) {
                 .dbg_var_ptr, .dbg_var_val => if (zir_data[i].str_op.operand == ref) {
-                    return .{ .exact = .{
-                        .name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{f}.{s}", .{
-                            block.type_name_ctx.fmt(ip), zir_data[i].str_op.getStr(sema.code),
-                        }, .no_embedded_nulls),
-                        .nav = .none,
-                    } };
+                    break zir_data[i].str_op.getStr(sema.code);
                 },
                 else => {},
+            } else {
+                continue :strat .anon;
             };
-            // fall through to anon strat
+            const name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{f}.{s}", .{
+                block.type_name_ctx.fmt(ip), var_name,
+            }, .no_embedded_nulls);
+            wip.setName(ip, name, .none);
         },
     }
-
-    // anon strat handling
-
-    // It would be neat to have "struct:line:column" but this name has
-    // to survive incremental updates, where it may have been shifted down
-    // or up to a different line, but unchanged, and thus not unnecessarily
-    // semantically analyzed.
-    // TODO: that would be possible, by detecting line number changes and renaming
-    // types appropriately. However, `@typeName` becomes a problem then. If we remove
-    // that builtin from the language, we can consider this.
-
-    return .{ .anon_prefix = try std.fmt.allocPrint(
-        sema.arena,
-        "{f}__{s}",
-        .{ block.type_name_ctx.fmt(ip), anon_prefix },
-    ) };
 }
 
-pub fn analyzeStructDecl(
-    pt: Zcu.PerThread,
-    file_index: Zcu.File.Index,
-    zir: *const Zir,
-    parent_namespace: InternPool.OptionalNamespaceIndex,
-    tracked_inst: InternPool.TrackedInst.Index,
-    struct_decl: *const Zir.UnwrappedStructDecl,
-    explicit_backing_type: ?Type,
-    captures: []const InternPool.CaptureValue,
-    type_name: PartialTypeName,
-) (Allocator.Error || std.Io.Cancelable)!Type {
+fn zirStructDecl(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
-    const wip = switch (try ip.getStructType(gpa, io, pt.tid, .{
+    const tracked_inst = try block.trackZir(inst);
+
+    const src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .nodeOffset(.zero),
+    };
+
+    const struct_decl = sema.code.getStructDecl(inst);
+
+    const captures = try sema.getCaptures(block, src, struct_decl.captures, struct_decl.capture_names);
+
+    const ty: Type = switch (try ip.getDeclaredStructType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .captures = captures,
         .fields_len = @intCast(struct_decl.field_names.len),
         .layout = struct_decl.layout,
-        .explicit_packed_backing_type = if (explicit_backing_type) |ty| ty.toIntern() else .none,
         .any_comptime_fields = struct_decl.field_comptime_bits != null,
         .any_field_defaults = struct_decl.field_default_body_lens != null,
         .any_field_aligns = struct_decl.field_align_body_lens != null,
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = captures,
-        } },
+        .packed_backing_mode = if (struct_decl.backing_int_type_body != null) .explicit else .auto,
     })) {
-        .existing => |ty| return .fromInterned(ty),
-        .wip => |wip| wip,
+        .existing => |ty| .fromInterned(ty),
+        .wip => |wip| ty: {
+            errdefer wip.cancel(ip, pt.tid);
+            try sema.setTypeName(block, &wip, struct_decl.name_strategy, "struct", inst);
+            const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
+            });
+            errdefer pt.destroyNamespace(new_namespace_index);
+            try pt.scanNamespace(new_namespace_index, struct_decl.decls);
+            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .struct_defaults = wip.index }) });
+
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+
+            try zcu.outdated.ensureUnusedCapacity(gpa, 2);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entries
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), {});
+
+            break :ty .fromInterned(wip.finish(ip, new_namespace_index));
+        },
     };
-    errdefer wip.cancel(ip, pt.tid);
 
-    _ = try type_name.apply(&wip, pt);
+    try sema.addTypeReferenceEntry(src, ty);
 
-    var field_it = struct_decl.iterateFields();
-    while (field_it.next()) |field| {
-        const name_slice = zir.nullTerminatedString(field.name);
-        const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
-        assert(wip.nextField(ip, name, field.is_comptime) == null); // AstGen validated this for us
-    }
+    // Make sure we update the namespace if the declaration is re-analyzed, to pick
+    // up on e.g. changed comptime decls.
+    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
+    try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
 
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = parent_namespace,
-        .owner_type = wip.index,
-        .file_scope = file_index,
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    try pt.scanNamespace(new_namespace_index, struct_decl.decls);
-
-    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_inits = wip.index }) });
-
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
-    try zcu.outdated.ensureUnusedCapacity(gpa, 2);
-    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
-    errdefer comptime unreachable; // because we don't remove the `outdated` entries
-    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), 0);
-    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), {});
-
-    return .fromInterned(wip.finish(ip, new_namespace_index));
+    return .fromIntern(ty.toIntern());
 }
-const AnalyzeUnionDeclError = error{
-    OutOfMemory,
-    Canceled,
-    /// `packed union(T)` syntax was used, but `T` was not an integer type.
-    ExplicitBackingNotInt,
-    /// `union(enum(T))` syntax was used, but `T` was not an integer type.
-    ExplicitTagNotInt,
-    /// `union(T)` syntax was used, but `T` was not an enum type.
-    ExplicitTagNotEnum,
-    /// `union(T)` syntax was used, but the fields of the union do not exactly
-    /// correspond to the fields of the enum `T`.
-    ExplicitTagFieldMismatch,
-};
-fn analyzeUnionDecl(
-    pt: Zcu.PerThread,
-    file_index: Zcu.File.Index,
-    zir: *const Zir,
-    parent_namespace: InternPool.OptionalNamespaceIndex,
-    want_safe_types: bool,
-    tracked_inst: InternPool.TrackedInst.Index,
-    union_decl: *const Zir.UnwrappedUnionDecl,
-    arg_type: ?Type,
-    captures: []const InternPool.CaptureValue,
-    type_name: PartialTypeName,
-) AnalyzeUnionDeclError!Type {
+fn zirUnionDecl(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
-    switch (union_decl.kind) {
-        .tagged_explicit => if (arg_type.?.zigTypeTag(zcu) != .@"enum") {
-            return error.ExplicitTagNotEnum;
-        },
-        .tagged_enum_explicit => if (arg_type.?.zigTypeTag(zcu) != .int) {
-            return error.ExplicitTagNotInt;
-        },
-        .packed_explicit => if (arg_type.?.zigTypeTag(zcu) != .int) {
-            return error.ExplicitBackingNotInt;
-        },
-        .auto,
-        .tagged_enum,
-        .@"extern",
-        .@"packed",
-        => assert(arg_type == null),
-    }
+    const tracked_inst = try block.trackZir(inst);
 
-    const wip = switch (try ip.getUnionType(gpa, io, pt.tid, .{
+    const src: LazySrcLoc = .{
+        .base_node_inst = tracked_inst,
+        .offset = .nodeOffset(.zero),
+    };
+
+    const union_decl = sema.code.getUnionDecl(inst);
+
+    const captures = try sema.getCaptures(block, src, union_decl.captures, union_decl.capture_names);
+
+    const ty: Type = switch (try ip.getDeclaredUnionType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .captures = captures,
         .fields_len = @intCast(union_decl.field_names.len),
         .layout = union_decl.kind.layout(),
-        .explicit_packed_backing_type = switch (union_decl.kind) {
-            .packed_explicit => arg_type.?.toIntern(),
-            else => .none,
-        },
+        .any_field_aligns = union_decl.field_align_body_lens != null,
         .runtime_tag = switch (union_decl.kind) {
-            .auto => if (want_safe_types) .safety else .none,
+            .auto => if (block.wantSafeTypes()) .safety else .none,
 
             .tagged_explicit,
             .tagged_enum,
@@ -34918,441 +34467,45 @@ fn analyzeUnionDecl(
             .packed_explicit,
             => .none,
         },
-        .have_explicit_enum_tag = union_decl.kind == .tagged_explicit,
-        .any_field_aligns = union_decl.field_align_body_lens != null,
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = captures,
-            .arg_ty = if (arg_type) |t| t.toIntern() else .none,
-        } },
-    })) {
-        .existing => |ty| return .fromInterned(ty),
-        .wip => |wip| wip,
-    };
-    errdefer wip.cancel(ip, pt.tid);
-
-    const resolved_type_name = try type_name.apply(&wip, pt);
-
-    const generated_tag_ty: InternPool.Index = if (union_decl.kind == .tagged_explicit) generated_tag_ty: {
-        const tag_type = arg_type.?;
-        const enum_field_names = ip.loadEnumType(tag_type.toIntern()).field_names;
-        // Check that the enum field names match the union field names
-        if (union_decl.field_names.len != enum_field_names.len) {
-            return error.ExplicitTagFieldMismatch;
-        }
-        for (union_decl.field_names, enum_field_names.get(ip)) |union_field_zir, enum_field_ip| {
-            const union_field_name = zir.nullTerminatedString(union_field_zir);
-            const enum_field_name = enum_field_ip.toSlice(ip);
-            if (!std.mem.eql(u8, union_field_name, enum_field_name)) {
-                return error.ExplicitTagFieldMismatch;
-            }
-        }
-        wip.setTagType(ip, tag_type.toIntern());
-        break :generated_tag_ty .none;
-    } else generated_tag_ty: {
-        // Generate a tag type. Even if the union is untagged (`.none`), we still generate a
-        // hypothetical tag type.
-        const wip_tag_ty = switch (try ip.getEnumType(gpa, io, pt.tid, .{
-            .fields_len = @intCast(union_decl.field_names.len),
-            .explicit_int_tag_type = switch (union_decl.kind) {
-                .tagged_enum_explicit => arg_type.?.toIntern(),
-                else => .none,
-            },
-            .nonexhaustive = false,
-            .key = .{ .generated_union_tag = wip.index },
-        })) {
-            .existing => unreachable, // enum type is keyed on this union type which we're only just creating
-            .wip => |wip_tag_ty| wip_tag_ty,
-        };
-        errdefer wip_tag_ty.cancel(ip, pt.tid);
-        // Populate the generated tag type's name
-        const tag_type_name = try ip.getOrPutStringFmt(
-            gpa,
-            io,
-            pt.tid,
-            "@typeInfo({f}).@\"union\".tag_type.?",
-            .{resolved_type_name.fmt(ip)},
-            .no_embedded_nulls,
-        );
-        wip_tag_ty.setName(ip, tag_type_name, .none);
-        // Populate the generated tag type's field names
-        for (union_decl.field_names) |zir_name| {
-            const name_slice = zir.nullTerminatedString(zir_name);
-            const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
-            assert(wip_tag_ty.nextField(ip, name, false) == null); // AstGen validated this for us
-        }
-        // If not explicitly given, populate the generated tag type's *integer* tag type
-        switch (union_decl.kind) {
-            .tagged_enum_explicit => {}, // already set by `getEnumType`
-            else => {
-                // Infer the int tag type from the field count
-                const bits = Type.smallestUnsignedBits(union_decl.field_names.len -| 1);
-                const int_tag_type = try pt.intType(.unsigned, bits);
-                wip_tag_ty.setTagType(ip, int_tag_type.toIntern());
-            },
-        }
-        // Create a dummy namespace for the generated tag type
-        const new_namespace_index = try pt.createNamespace(.{
-            .parent = parent_namespace,
-            .owner_type = wip_tag_ty.index,
-            .file_scope = file_index,
-            .generation = zcu.generation,
-        });
-        errdefer pt.destroyNamespace(new_namespace_index);
-        wip.setTagType(ip, wip_tag_ty.index);
-        break :generated_tag_ty wip_tag_ty.finish(ip, new_namespace_index);
-    };
-    // If we fail to create the union type, we must delete the generated enum tag type, since it
-    // would hold a reference to the deleted union.
-    errdefer if (generated_tag_ty != .none) ip.remove(pt.tid, generated_tag_ty);
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = parent_namespace,
-        .owner_type = wip.index,
-        .file_scope = file_index,
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    try pt.scanNamespace(new_namespace_index, union_decl.decls);
-
-    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-    if (generated_tag_ty != .none) {
-        try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_inits = generated_tag_ty }) });
-    }
-
-    if (zcu.comp.debugIncremental()) {
-        try zcu.incremental_debug_state.newType(zcu, wip.index);
-        if (generated_tag_ty != .none) {
-            try zcu.incremental_debug_state.newType(zcu, generated_tag_ty);
-        }
-    }
-
-    try zcu.outdated.ensureUnusedCapacity(gpa, 2);
-    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
-    errdefer comptime unreachable; // because we don't remove the `outdated` entry
-    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-    if (generated_tag_ty != .none) {
-        zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = generated_tag_ty }), 0);
-        zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = generated_tag_ty }), {});
-    }
-
-    return .fromInterned(wip.finish(ip, new_namespace_index));
-}
-const AnalyzeEnumDeclError = error{
-    OutOfMemory,
-    Canceled,
-    /// `enum(T)` syntax was used, but `T` was not an integer type.
-    ExplicitTagNotInt,
-};
-fn analyzeEnumDecl(
-    pt: Zcu.PerThread,
-    file_index: Zcu.File.Index,
-    zir: *const Zir,
-    parent_namespace: InternPool.OptionalNamespaceIndex,
-    tracked_inst: InternPool.TrackedInst.Index,
-    enum_decl: *const Zir.UnwrappedEnumDecl,
-    explicit_tag_type: ?Type,
-    captures: []const InternPool.CaptureValue,
-    type_name: PartialTypeName,
-) AnalyzeEnumDeclError!Type {
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    if (explicit_tag_type) |ty| {
-        // MLUGG TODO: make a final call on whether comptime_int is a valid int tag type, and follow it everywhere.
-        // i think not in the name of simplicity, but my opinion might depend on whether it's broken in practice today
-        switch (ty.zigTypeTag(zcu)) {
-            .int, .comptime_int => {},
-            else => return error.ExplicitTagNotInt,
-        }
-    }
-
-    const wip = switch (try ip.getEnumType(gpa, io, pt.tid, .{
-        .fields_len = @intCast(enum_decl.field_names.len),
-        .explicit_int_tag_type = if (explicit_tag_type) |ty| ty.toIntern() else .none,
-        .nonexhaustive = enum_decl.nonexhaustive,
-        .key = .{ .declared = .{
-            .zir_index = tracked_inst,
-            .captures = captures,
-        } },
-    })) {
-        .existing => |ty| return .fromInterned(ty),
-        .wip => |wip| wip,
-    };
-    errdefer wip.cancel(ip, pt.tid);
-
-    _ = try type_name.apply(&wip, pt);
-
-    var field_it = enum_decl.iterateFields();
-    while (field_it.next()) |field| {
-        const name_slice = zir.nullTerminatedString(field.name);
-        const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
-        assert(wip.nextField(ip, name, false) == null); // AstGen validated this for us
-    }
-
-    if (explicit_tag_type == null) {
-        // Infer the int tag type from the field count
-        const bits = Type.smallestUnsignedBits(enum_decl.field_names.len -| 1);
-        const int_tag_ty = try pt.intType(.unsigned, bits);
-        wip.setTagType(ip, int_tag_ty.toIntern());
-    }
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = parent_namespace,
-        .owner_type = wip.index,
-        .file_scope = file_index,
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    try pt.scanNamespace(new_namespace_index, enum_decl.decls);
-
-    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_inits = wip.index }) });
-
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
-    try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-    errdefer comptime unreachable; // because we don't remove the `outdated` entry
-    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), 0);
-    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_inits = wip.index }), {});
-
-    return .fromInterned(wip.finish(ip, new_namespace_index));
-}
-fn analyzeOpaqueDecl(
-    pt: Zcu.PerThread,
-    file_index: Zcu.File.Index,
-    parent_namespace: InternPool.OptionalNamespaceIndex,
-    tracked_inst: InternPool.TrackedInst.Index,
-    opaque_decl: *const Zir.UnwrappedOpaqueDecl,
-    captures: []const InternPool.CaptureValue,
-    type_name: PartialTypeName,
-) (Allocator.Error || std.Io.Cancelable)!Type {
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const wip = switch (try ip.getOpaqueType(gpa, io, pt.tid, .{
-        .zir_index = tracked_inst,
-        .captures = captures,
+        .enum_tag_mode = switch (union_decl.kind) {
+            .tagged_explicit => .explicit,
+            else => .auto,
+        },
+        .packed_backing_mode = switch (union_decl.kind) {
+            .packed_explicit => .explicit,
+            else => .auto,
+        },
     })) {
-        .existing => |ty| return .fromInterned(ty),
-        .wip => |wip| wip,
-    };
-    errdefer wip.cancel(ip, pt.tid);
-
-    _ = try type_name.apply(&wip, pt);
-
-    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-        .parent = parent_namespace,
-        .owner_type = wip.index,
-        .file_scope = file_index,
-        .generation = zcu.generation,
-    });
-    errdefer pt.destroyNamespace(new_namespace_index);
-
-    try pt.scanNamespace(new_namespace_index, opaque_decl.decls);
-
-    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-    return .fromInterned(wip.finish(ip, new_namespace_index));
-}
-
-fn zirStructDecl(
-    sema: *Sema,
-    block: *Block,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
+        .existing => |ty| .fromInterned(ty),
+        .wip => |wip| ty: {
+            errdefer wip.cancel(ip, pt.tid);
+            try sema.setTypeName(block, &wip, union_decl.name_strategy, "union", inst);
 
-    const tracked_inst = try block.trackZir(inst);
+            const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
+            });
+            errdefer pt.destroyNamespace(new_namespace_index);
 
-    const src: LazySrcLoc = .{
-        .base_node_inst = tracked_inst,
-        .offset = .nodeOffset(.zero),
-    };
-    const backing_ty_src: LazySrcLoc = .{
-        .base_node_inst = tracked_inst,
-        .offset = .{ .node_offset_container_tag = .zero },
-    };
-
-    const struct_decl = sema.code.getStructDecl(inst);
-
-    const captures = try sema.getCaptures(block, src, struct_decl.captures, struct_decl.capture_names);
-
-    const backing_int_type: ?Type = ty: {
-        if (struct_decl.backing_int_type == .none) break :ty null;
-        break :ty try sema.resolveType(block, backing_ty_src, struct_decl.backing_int_type);
-        // MLUGG TODO validate it's an int!
-    };
+            try pt.scanNamespace(new_namespace_index, union_decl.decls);
 
-    const ty = try analyzeStructDecl(
-        pt,
-        block.getFileScopeIndex(zcu),
-        &sema.code,
-        block.namespace.toOptional(),
-        tracked_inst,
-        &struct_decl,
-        backing_int_type,
-        captures,
-        try sema.createTypeName(block, struct_decl.name_strategy, "struct", inst),
-    );
+            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
 
-    try sema.addTypeReferenceEntry(src, ty);
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-    // Make sure we update the namespace if the declaration is re-analyzed, to pick
-    // up on e.g. changed comptime decls.
-    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
-    try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entry
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
 
-    return .fromIntern(ty.toIntern());
-}
-fn zirUnionDecl(
-    sema: *Sema,
-    block: *Block,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    const tracked_inst = try block.trackZir(inst);
-
-    const src: LazySrcLoc = .{
-        .base_node_inst = tracked_inst,
-        .offset = .nodeOffset(.zero),
-    };
-    const arg_ty_src: LazySrcLoc = .{
-        .base_node_inst = tracked_inst,
-        .offset = .{ .node_offset_container_tag = .zero },
-    };
-
-    const union_decl = sema.code.getUnionDecl(inst);
-
-    const captures = try sema.getCaptures(block, src, union_decl.captures, union_decl.capture_names);
-
-    const arg_type: ?Type = ty: {
-        if (union_decl.arg_type == .none) break :ty null;
-        break :ty try sema.resolveType(block, arg_ty_src, union_decl.arg_type);
-    };
-
-    const ty = analyzeUnionDecl(
-        pt,
-        block.getFileScopeIndex(zcu),
-        &sema.code,
-        block.namespace.toOptional(),
-        block.wantSafeTypes(),
-        tracked_inst,
-        &union_decl,
-        arg_type,
-        captures,
-        try sema.createTypeName(block, union_decl.name_strategy, "union", inst),
-    ) catch |err| switch (err) {
-        error.OutOfMemory,
-        error.Canceled,
-        => |e| return e,
-
-        error.ExplicitBackingNotInt => return sema.fail(
-            block,
-            arg_ty_src,
-            "expected integer backing type, found '{f}'",
-            .{arg_type.?.fmt(pt)},
-        ),
-        error.ExplicitTagNotInt => return sema.fail(
-            block,
-            arg_ty_src,
-            "expected integer tag type, found '{f}'",
-            .{arg_type.?.fmt(pt)},
-        ),
-        error.ExplicitTagNotEnum => return sema.fail(
-            block,
-            arg_ty_src,
-            "expected enum tag type, found '{f}'",
-            .{arg_type.?.fmt(pt)},
-        ),
-        error.ExplicitTagFieldMismatch => {
-            const enum_obj = ip.loadEnumType(arg_type.?.toIntern());
-            const enum_to_union_map = try sema.arena.alloc(?u32, enum_obj.field_names.len);
-            @memset(enum_to_union_map, null);
-            for (union_decl.field_names, 0..) |field_name_zir, union_field_idx| {
-                const field_name_ip = try ip.getOrPutString(gpa, io, pt.tid, sema.code.nullTerminatedString(field_name_zir), .no_embedded_nulls);
-                if (enum_obj.nameIndex(ip, field_name_ip)) |enum_field_idx| {
-                    enum_to_union_map[enum_field_idx] = @intCast(union_field_idx);
-                    continue;
-                }
-                const union_field_src: LazySrcLoc = .{
-                    .base_node_inst = tracked_inst,
-                    .offset = .{ .container_field_name = @intCast(union_field_idx) },
-                };
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(union_field_src, "no field named '{f}' in enum '{f}'", .{ field_name_ip.fmt(ip), arg_type.?.fmt(pt) });
-                    errdefer msg.destroy(gpa);
-                    try sema.addDeclaredHereNote(msg, arg_type.?);
-                    break :msg msg;
-                });
-            }
-            for (enum_to_union_map, 0..) |union_field_idx, enum_field_idx| {
-                if (union_field_idx != null) continue;
-                const field_name_ip = enum_obj.field_names.get(ip)[enum_field_idx];
-                const enum_field_src: LazySrcLoc = .{
-                    .base_node_inst = arg_type.?.typeDeclInstAllowGeneratedTag(zcu).?,
-                    .offset = .{ .container_field_name = @intCast(enum_field_idx) },
-                };
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(src, "enum field '{f}' missing from union", .{field_name_ip.fmt(ip)});
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(enum_field_src, msg, "enum field here", .{});
-                    break :msg msg;
-                });
-            }
-            for (enum_to_union_map, 0..) |union_field_idx, enum_field_idx| {
-                if (union_field_idx.? == enum_field_idx) continue;
-                const field_name = sema.code.nullTerminatedString(
-                    union_decl.field_names[union_field_idx.?],
-                );
-                const union_field_src: LazySrcLoc = .{
-                    .base_node_inst = tracked_inst,
-                    .offset = .{ .container_field_name = union_field_idx.? },
-                };
-                const enum_field_src: LazySrcLoc = .{
-                    .base_node_inst = arg_type.?.typeDeclInstAllowGeneratedTag(zcu).?,
-                    .offset = .{ .container_field_name = @intCast(enum_field_idx) },
-                };
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(src, "union field order does not match tag enum field order", .{});
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(union_field_src, msg, "union field '{s}' is index {d}", .{ field_name, union_field_idx.? });
-                    try sema.errNote(enum_field_src, msg, "enum field '{s}' is index {d}", .{ field_name, enum_field_idx });
-                    break :msg msg;
-                });
-            }
-            unreachable;
+            break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
 
-    const enum_tag_ty = ty.unionTagTypeHypothetical(zcu);
-    switch (ip.indexToKey(enum_tag_ty.toIntern()).enum_type) {
-        .declared, .reified => {},
-        .generated_union_tag => |owner_union_ty| {
-            assert(owner_union_ty == ty.toIntern());
-            // generated tag type [MLUGG]
-            // Enum inits are resolved eagerly. TODO MLUGG: honestly i don't think they SHOULD be lol
-            try sema.ensureFieldInitsResolved(.fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_type));
-        },
-    }
-
     try sema.addTypeReferenceEntry(src, ty);
 
     // Make sure we update the namespace if the declaration is re-analyzed, to pick
@@ -35369,6 +34522,10 @@ fn zirEnumDecl(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
 
     const tracked_inst = try block.trackZir(inst);
 
@@ -35376,45 +34533,48 @@ fn zirEnumDecl(
         .base_node_inst = tracked_inst,
         .offset = .nodeOffset(.zero),
     };
-    const tag_ty_src: LazySrcLoc = .{
-        .base_node_inst = tracked_inst,
-        .offset = .{ .node_offset_container_tag = .zero },
-    };
 
     const enum_decl = sema.code.getEnumDecl(inst);
 
     const captures = try sema.getCaptures(block, src, enum_decl.captures, enum_decl.capture_names);
 
-    const tag_type: ?Type = ty: {
-        if (enum_decl.tag_type == .none) break :ty null;
-        break :ty try sema.resolveType(block, tag_ty_src, enum_decl.tag_type);
-    };
+    const ty: Type = switch (try ip.getDeclaredEnumType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .captures = captures,
+        .fields_len = @intCast(enum_decl.field_names.len),
+        .nonexhaustive = enum_decl.nonexhaustive,
+        .int_tag_mode = if (enum_decl.tag_type_body != null) .explicit else .auto,
+    })) {
+        .existing => |ty| .fromInterned(ty),
+        .wip => |wip| ty: {
+            errdefer wip.cancel(ip, pt.tid);
 
-    const ty = analyzeEnumDecl(
-        pt,
-        block.getFileScopeIndex(zcu),
-        &sema.code,
-        block.namespace.toOptional(),
-        tracked_inst,
-        &enum_decl,
-        tag_type,
-        captures,
-        try sema.createTypeName(block, enum_decl.name_strategy, "enum", inst),
-    ) catch |err| switch (err) {
-        error.OutOfMemory,
-        error.Canceled,
-        => |e| return e,
+            try sema.setTypeName(block, &wip, enum_decl.name_strategy, "enum", inst);
 
-        error.ExplicitTagNotInt => return sema.fail(
-            block,
-            tag_ty_src,
-            "expected integer tag type, found '{f}'",
-            .{tag_type.?.fmt(pt)},
-        ),
-    };
+            const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
+            });
+            errdefer pt.destroyNamespace(new_namespace_index);
+
+            try pt.scanNamespace(new_namespace_index, enum_decl.decls);
+
+            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
 
-    // Enum inits are resolved eagerly. TODO MLUGG: honestly i don't think they SHOULD be lol
-    try sema.ensureFieldInitsResolved(ty);
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entry
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+
+            break :ty .fromInterned(wip.finish(ip, new_namespace_index));
+        },
+    };
 
     try sema.addTypeReferenceEntry(src, ty);
 
@@ -35432,6 +34592,10 @@ fn zirOpaqueDecl(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const ip = &zcu.intern_pool;
 
     const tracked_inst = try block.trackZir(inst);
 
@@ -35444,15 +34608,26 @@ fn zirOpaqueDecl(
 
     const captures = try sema.getCaptures(block, src, opaque_decl.captures, opaque_decl.capture_names);
 
-    const ty = try analyzeOpaqueDecl(
-        pt,
-        block.getFileScopeIndex(zcu),
-        block.namespace.toOptional(),
-        tracked_inst,
-        &opaque_decl,
-        captures,
-        try sema.createTypeName(block, opaque_decl.name_strategy, "opaque", inst),
-    );
+    const ty: Type = switch (try ip.getDeclaredOpaqueType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .captures = captures,
+    })) {
+        .existing => |ty| .fromInterned(ty),
+        .wip => |wip| ty: {
+            errdefer wip.cancel(ip, pt.tid);
+            try sema.setTypeName(block, &wip, opaque_decl.name_strategy, "opaque", inst);
+            const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
+            });
+            errdefer pt.destroyNamespace(new_namespace_index);
+            try pt.scanNamespace(new_namespace_index, opaque_decl.decls);
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+            break :ty .fromInterned(wip.finish(ip, new_namespace_index));
+        },
+    };
 
     try sema.addTypeReferenceEntry(src, ty);
 
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index 78d1d8d1df28af4b827e6d869d0e8352acd168ee..bb10a39729ad41d3e74af62428b671985c13a0cf 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -769,7 +769,7 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
     const ip = &pt.zcu.intern_pool;
 
     try self.sema.ensureLayoutResolved(res_ty);
-    try self.sema.ensureFieldInitsResolved(res_ty);
+    try self.sema.ensureStructDefaultsResolved(res_ty);
     const struct_info = self.sema.pt.zcu.typeToStruct(res_ty).?;
 
     const fields: @FieldType(Zoir.Node, "struct_literal") = switch (node.get(self.file.zoir.?)) {
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index f54a7b944e41f3c39161836a49654b177abb7c99..f346d217ae2b361af26498ba5a0f86651c1d6a08 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -18,10 +18,6 @@ const arith = @import("arith.zig");
 /// `ty` may be any type; its layout is resolved *recursively* if necessary.
 /// Adds incremental dependencies tracking any required type resolution.
 /// MLUGG TODO: to make the langspec non-stupid, we need to call this from WAY fewer places (the conditions need to be less specific).
-/// e.g. I think creating the type `fn (A, B) C` should force layout resolution of `A`,`B`,`C`, which will simplify some `analyzeCall` logic.
-///      wait i just realised that's probably a terrible idea, fns are a common cause of dep loops rn... so maybe not lol idk...
-///      perhaps "layout resolution" for a function should resolve layout of ret ty and stuff, idk. justification: the "layout" of a function is whether
-///      fnHasRuntimeBits, which depends whether the ret ty is comptime-only, i.e. the ret ty layout
 /// MLUGG TODO: to be clear, i should audit EVERY use of this before PRing
 pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
     const pt = sema.pt;
@@ -33,7 +29,6 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
         .anyframe_type,
         .simple_type,
         .opaque_type,
-        .enum_type,
         .error_set_type,
         .inferred_error_set_type,
         => {},
@@ -52,7 +47,7 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
         .tuple_type => |tuple| for (tuple.types.get(ip)) |field_ty| {
             try ensureLayoutResolved(sema, .fromInterned(field_ty));
         },
-        .struct_type, .union_type => {
+        .struct_type, .union_type, .enum_type => {
             try sema.declareDependency(.{ .type_layout = ty.toIntern() });
             if (zcu.analysis_in_progress.contains(.wrap(.{ .type_layout = ty.toIntern() }))) {
                 // TODO: better error message
@@ -89,36 +84,36 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
     }
 }
 
-/// Asserts that `ty` is either a `struct` type, or an `enum` type.
-/// If `ty` is a struct, ensures that fields' default values are resolved.
-/// If `ty` is an enum, ensures that fields' integer tag valus are resolved.
-/// Adds incremental dependencies tracking the required type resolution.
-pub fn ensureFieldInitsResolved(sema: *Sema, ty: Type) SemaError!void {
+/// Asserts that `ty` is a non-tuple `struct` type, and ensures that its fields' default values
+/// are resolved. Adds incremental dependencies tracking the required type resolution.
+///
+/// It is not necessary to call this function to query the values of comptime fields: those values
+/// are available from type *layout* resolution, see `ensureLayoutResolved`.
+pub fn ensureStructDefaultsResolved(sema: *Sema, ty: Type) SemaError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type, .enum_type => {},
-        else => unreachable, // assertion failure
-    }
+    assert(ip.indexToKey(ty.toIntern()) == .struct_type);
 
-    try sema.declareDependency(.{ .type_inits = ty.toIntern() });
-    if (zcu.analysis_in_progress.contains(.wrap(.{ .type_inits = ty.toIntern() }))) {
+    try sema.declareDependency(.{ .struct_defaults = ty.toIntern() });
+    if (zcu.analysis_in_progress.contains(.wrap(.{ .struct_defaults = ty.toIntern() }))) {
         // TODO: better error message
         return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
             ty.srcLoc(zcu),
-            "{s} '{f}' depends on itself",
-            .{ @tagName(ty.zigTypeTag(zcu)), ty.fmt(pt) },
+            "struct '{f}' depends on itself",
+            .{ty.fmt(pt)},
         ));
     }
-    try pt.ensureTypeInitsUpToDate(ty);
+    try pt.ensureStructDefaultsUpToDate(ty);
 }
+
 /// Asserts that `struct_ty` is a non-packed non-tuple struct, and that `sema.owner` is that type.
 /// This function *does* register the `src_hash` dependency on the struct.
 pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
+    const io = comp.io;
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
@@ -127,10 +122,6 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
     const struct_obj = ip.loadStructType(struct_ty.toIntern());
     const zir_index = struct_obj.zir_index.resolve(ip).?;
 
-    assert(struct_obj.layout != .@"packed");
-
-    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
-
     var block: Block = .{
         .parent = null,
         .sema = sema,
@@ -143,40 +134,93 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
     };
     defer assert(block.instructions.items.len == 0);
 
-    const zir_struct = sema.code.getStructDecl(zir_index);
-    var field_it = zir_struct.iterateFields();
-    while (field_it.next()) |zir_field| {
-        const field_ty_src: LazySrcLoc = .{
-            .base_node_inst = struct_obj.zir_index,
-            .offset = .{ .container_field_type = zir_field.idx },
-        };
-        const field_align_src: LazySrcLoc = .{
-            .base_node_inst = struct_obj.zir_index,
-            .offset = .{ .container_field_align = zir_field.idx },
-        };
-
-        const field_ty: Type = field_ty: {
-            block.comptime_reason = .{ .reason = .{
-                .src = field_ty_src,
-                .r = .{ .simple = .struct_field_types },
-            } };
-            const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
-            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
-        };
+    // There may be old field names in here from a previous update.
+    struct_obj.field_name_map.get(ip).clearRetainingCapacity();
+
+    if (struct_obj.is_reified) {
+        // The field names are populated, but we haven't checked for duplicates (nor populated the map) yet.
+        for (0..struct_obj.field_names.len) |field_index| {
+            const name = struct_obj.field_names.get(ip)[field_index];
+            if (ip.addFieldName(struct_obj.field_names, struct_obj.field_name_map, name)) |prev_field_index| {
+                return sema.failWithOwnedErrorMsg(&block, msg: {
+                    const src = block.nodeOffset(.zero);
+                    const msg = try sema.errMsg(src, "duplicate struct field '{f}' at index '{d}", .{ name.fmt(ip), field_index });
+                    errdefer msg.destroy(gpa);
+                    try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_index});
+                    break :msg msg;
+                });
+            }
+        }
+    } else {
+        // Declared structs do not yet have field information populated:
+        // * field names
+        // * field comptime-ness
+        // * field types
+        // * field aligns
+        // It's our job to populate these now.
+        try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
+
+        // Likewise, comptime bits may be set. We clear them all first because it avoids needing
+        // "unset bit with AND" logic below (instead we only need the "set bit with OR" case).
+        @memset(struct_obj.field_is_comptime_bits.getAll(ip), 0);
+
+        const zir_struct = sema.code.getStructDecl(zir_index);
+        var field_it = zir_struct.iterateFields();
+        while (field_it.next()) |zir_field| {
+            {
+                const name_slice = sema.code.nullTerminatedString(zir_field.name);
+                const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
+                assert(ip.addFieldName(struct_obj.field_names, struct_obj.field_name_map, name) == null); // AstGen validated this for us
+            }
+
+            if (zir_field.is_comptime) {
+                const bit_bag_index = zir_field.idx / 32;
+                const mask = @as(u32, 1) << @intCast(zir_field.idx % 32);
+                struct_obj.field_is_comptime_bits.getAll(ip)[bit_bag_index] |= mask;
+            }
+
+            {
+                const field_ty_src = block.src(.{ .container_field_type = zir_field.idx });
+                const field_ty: Type = field_ty: {
+                    block.comptime_reason = .{ .reason = .{
+                        .src = field_ty_src,
+                        .r = .{ .simple = .struct_field_types },
+                    } };
+                    const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
+                    break :field_ty try sema.analyzeAsType(&block, field_ty_src, .struct_field_types, type_ref);
+                };
+                struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+            }
+
+            if (struct_obj.field_aligns.len == 0) {
+                assert(zir_field.align_body == null);
+            } else {
+                const field_align_src = block.src(.{ .container_field_align = zir_field.idx });
+                const field_align: Alignment = a: {
+                    block.comptime_reason = .{ .reason = .{
+                        .src = field_align_src,
+                        .r = .{ .simple = .struct_field_attrs },
+                    } };
+                    const align_body = zir_field.align_body orelse break :a .none;
+                    const align_ref = try sema.resolveInlineBody(&block, align_body, zir_index);
+                    break :a try sema.analyzeAsAlign(&block, field_align_src, align_ref);
+                };
+                struct_obj.field_aligns.get(ip)[zir_field.idx] = field_align;
+            }
+        }
+    }
+
+    if (struct_obj.layout == .@"packed") {
+        return resolvePackedStructLayout(sema, &block, struct_ty, &struct_obj);
+    }
+
+    // Resolve the layout of all fields, and check their types are allowed.
+    for (struct_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
-
+        const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
         try sema.ensureLayoutResolved(field_ty);
 
-        const explicit_field_align: Alignment = a: {
-            block.comptime_reason = .{ .reason = .{
-                .src = field_align_src,
-                .r = .{ .simple = .struct_field_attrs },
-            } };
-            const align_body = zir_field.align_body orelse break :a .none;
-            const align_ref = try sema.resolveInlineBody(&block, align_body, zir_index);
-            break :a try sema.analyzeAsAlign(&block, field_align_src, align_ref);
-        };
-
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
@@ -186,7 +230,8 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 break :msg msg;
             });
         }
-        if (struct_obj.layout == .@"extern" and !try sema.validateExternType(field_ty, .struct_field)) {
+
+        if (struct_obj.layout == .@"extern" and !field_ty.validateExtern(.struct_field, zcu)) {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "extern structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
                 errdefer msg.destroy(gpa);
@@ -195,35 +240,14 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 break :msg msg;
             });
         }
-
-        struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
-        if (struct_obj.field_aligns.len != 0) {
-            struct_obj.field_aligns.get(ip)[zir_field.idx] = explicit_field_align;
-        } else {
-            assert(explicit_field_align == .none);
-        }
     }
 
-    try finishStructLayout(sema, &block, struct_ty.srcLoc(zcu), struct_ty.toIntern(), &struct_obj);
-}
+    // Fields are okay. Now we need to resolve the struct's overall layout (size, field offsets, etc).
 
-/// Called after populating field types and alignments; populates field offsets, runtime order, and
-/// overall struct layout information (size, alignment, comptime-only state, etc).
-pub fn finishStructLayout(
-    sema: *Sema,
-    /// Only used to report compile errors.
-    block: *Block,
-    struct_src: LazySrcLoc,
-    struct_ty: InternPool.Index,
-    struct_obj: *const InternPool.LoadedStructType,
-) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
+    var any_comptime_fields = false;
     var comptime_only = false;
     var one_possible_value = true;
+    var has_runtime_bits = false;
     var struct_align: Alignment = .@"1";
     // Unlike `struct_obj.field_aligns`, these are not `.none`.
     const resolved_field_aligns = try sema.arena.alloc(Alignment, struct_obj.field_names.len);
@@ -240,12 +264,15 @@ pub fn finishStructLayout(
             // Non-`comptime` fields contribute to the struct's layout.
             struct_align = struct_align.maxStrict(field_align);
             if (field_ty.comptimeOnly(zcu)) comptime_only = true;
+            if (field_ty.hasRuntimeBits(zcu)) has_runtime_bits = true;
             if (try field_ty.onePossibleValue(pt) == null) one_possible_value = false;
             if (struct_obj.layout == .auto) {
                 struct_obj.field_runtime_order.get(ip)[field_idx] = @enumFromInt(field_idx);
             }
-        } else if (struct_obj.layout == .auto) {
+        } else {
+            assert(struct_obj.layout == .auto); // comptime fields not allowed in extern or packed structs
             struct_obj.field_runtime_order.get(ip)[field_idx] = .omitted; // comptime fields are not in the runtime order
+            any_comptime_fields = true;
         }
         align_out.* = field_align;
     }
@@ -297,75 +324,53 @@ pub fn finishStructLayout(
         cur_offset = offset + field_ty.abiSize(zcu);
     }
     const struct_size = std.math.cast(u32, struct_align.forward(cur_offset)) orelse return sema.fail(
-        block,
-        struct_src,
+        &block,
+        struct_ty.srcLoc(zcu),
         "struct layout requires size {d}, this compiler implementation supports up to {d}",
         .{ struct_align.forward(cur_offset), std.math.maxInt(u32) },
     );
     ip.resolveStructLayout(
         io,
-        struct_ty,
+        struct_ty.toIntern(),
         struct_size,
         struct_align,
         false, // MLUGG TODO XXX NPV
         one_possible_value,
         comptime_only,
+        has_runtime_bits,
     );
+
+    if (any_comptime_fields and !struct_obj.is_reified) {
+        // We also resolve field inits in this case. MLUGG TODO: this sucks, see TODO in resolveStructDefaults
+        return resolveStructDefaultsInner(sema, &block, &struct_obj);
+    }
 }
 
 /// Asserts that `struct_ty` is a packed struct, and that `sema.owner` is that type.
 /// This function *does* register the `src_hash` dependency on the struct.
-pub fn resolvePackedStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
+fn resolvePackedStructLayout(
+    sema: *Sema,
+    block: *Block,
+    struct_ty: Type,
+    struct_obj: *const InternPool.LoadedStructType,
+) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
+    const io = comp.io;
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
-    assert(sema.owner.unwrap().type_layout == struct_ty.toIntern());
-
-    const struct_obj = ip.loadStructType(struct_ty.toIntern());
-    const zir_index = struct_obj.zir_index.resolve(ip).?;
-
-    assert(struct_obj.layout == .@"packed");
-
-    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
-
-    var block: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = struct_obj.namespace,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = undefined, // always set before using `block`
-        .src_base_inst = struct_obj.zir_index,
-        .type_name_ctx = struct_obj.name,
-    };
-    defer assert(block.instructions.items.len == 0);
-
+    // Resolve the layout of all fields, and check their types are allowed.
+    // Also count the number of bits while we're at it.
     var field_bits: u64 = 0;
-    const zir_struct = sema.code.getStructDecl(zir_index);
-    var field_it = zir_struct.iterateFields();
-    while (field_it.next()) |zir_field| {
-        const field_ty_src: LazySrcLoc = .{
-            .base_node_inst = struct_obj.zir_index,
-            .offset = .{ .container_field_type = zir_field.idx },
-        };
-        const field_ty: Type = field_ty: {
-            block.comptime_reason = .{ .reason = .{
-                .src = field_ty_src,
-                .r = .{ .simple = .struct_field_types },
-            } };
-            const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
-            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
-        };
+    for (struct_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
-        struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
-
+        const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
         try sema.ensureLayoutResolved(field_ty);
-
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
-            return sema.failWithOwnedErrorMsg(&block, msg: {
+            return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
                 errdefer msg.destroy(gpa);
                 try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
@@ -373,62 +378,73 @@ pub fn resolvePackedStructLayout(sema: *Sema, struct_ty: Type) CompileError!void
                 break :msg msg;
             });
         }
-        if (!field_ty.packable(zcu)) {
-            return sema.failWithOwnedErrorMsg(&block, msg: {
-                const msg = try sema.errMsg(field_ty_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                errdefer msg.destroy(gpa);
-                try sema.explainWhyTypeIsNotPackable(msg, field_ty_src, field_ty);
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            });
-        }
+        if (field_ty.unpackable(zcu)) |reason| return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(field_ty_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
+            errdefer msg.destroy(gpa);
+            try sema.explainWhyTypeIsUnpackable(msg, field_ty_src, reason);
+            try sema.addDeclaredHereNote(msg, field_ty);
+            break :msg msg;
+        });
         assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
         field_bits += field_ty.bitSize(zcu);
     }
 
-    try resolvePackedStructBackingInt(sema, &block, field_bits, struct_ty, &struct_obj);
-}
+    const explicit_backing_int_ty: ?Type = if (struct_obj.is_reified) ty: {
+        break :ty switch (struct_obj.packed_backing_mode) {
+            .explicit => .fromInterned(struct_obj.packed_backing_int_type),
+            .auto => null,
+        };
+    } else ty: {
+        const zir_index = struct_obj.zir_index.resolve(ip).?;
+        const zir_struct = sema.code.getStructDecl(zir_index);
+        const backing_int_type_body = zir_struct.backing_int_type_body orelse {
+            break :ty null; // inferred backing type
+        };
+        // Explicitly specified, so evaluate the backing int type expression.
+        const backing_int_type_src = block.src(.container_arg);
+        block.comptime_reason = .{ .reason = .{
+            .src = backing_int_type_src,
+            .r = .{ .simple = .packed_struct_backing_int_type },
+        } };
+        const type_ref = try sema.resolveInlineBody(block, backing_int_type_body, zir_index);
+        break :ty try sema.analyzeAsType(block, backing_int_type_src, .packed_struct_backing_int_type, type_ref);
+    };
 
-pub fn resolvePackedStructBackingInt(
-    sema: *Sema,
-    block: *Block,
-    field_bits: u64,
-    struct_ty: Type,
-    struct_obj: *const InternPool.LoadedStructType,
-) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
-    switch (struct_obj.packed_backing_mode) {
-        .explicit => {
-            // We only need to validate the type.
-            const backing_ty: Type = .fromInterned(struct_obj.packed_backing_int_type);
-            assert(backing_ty.zigTypeTag(zcu) == .int);
-            if (field_bits != backing_ty.intInfo(zcu).bits) return sema.failWithOwnedErrorMsg(block, msg: {
-                const src = struct_ty.srcLoc(zcu);
-                const msg = try sema.errMsg(src, "backing integer bit width does not match total bit width of fields", .{});
-                errdefer msg.destroy(gpa);
-                try sema.errNote(src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) });
-                try sema.errNote(src, msg, "struct fields have total bit width '{d}'", .{field_bits});
-                break :msg msg;
-            });
-        },
-        .auto => {
-            // We need to generate the inferred tag.
-            const want_bits = std.math.cast(u16, field_bits) orelse return sema.fail(
-                block,
-                struct_ty.srcLoc(zcu),
-                "packed struct bit width '{d}' exceeds maximum bit width of 65535",
-                .{field_bits},
-            );
-            const backing_int = try pt.intType(.unsigned, want_bits);
-            ip.resolvePackedStructBackingInt(io, struct_ty.toIntern(), backing_int.toIntern());
-        },
-    }
+    // Finally, either validate or infer the backing int type.
+    const backing_int_ty: Type = if (explicit_backing_int_ty) |backing_ty| ty: {
+        // We only need to validate the type.
+        if (backing_ty.zigTypeTag(zcu) != .int) return sema.failWithOwnedErrorMsg(block, msg: {
+            const src = struct_ty.srcLoc(zcu);
+            const msg = try sema.errMsg(src, "expected backing integer type, found '{f}'", .{backing_ty.fmt(pt)});
+            errdefer msg.destroy(gpa);
+            try sema.errNote(src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) });
+            try sema.errNote(src, msg, "struct fields have total bit width '{d}'", .{field_bits});
+            break :msg msg;
+        });
+        if (field_bits != backing_ty.intInfo(zcu).bits) return sema.failWithOwnedErrorMsg(block, msg: {
+            const src = struct_ty.srcLoc(zcu);
+            const msg = try sema.errMsg(src, "backing integer bit width does not match total bit width of fields", .{});
+            errdefer msg.destroy(gpa);
+            try sema.errNote(src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) });
+            try sema.errNote(src, msg, "struct fields have total bit width '{d}'", .{field_bits});
+            break :msg msg;
+        });
+        break :ty backing_ty;
+    } else ty: {
+        // We need to generate the inferred tag.
+        const backing_int_bits = std.math.cast(u16, field_bits) orelse return sema.fail(
+            block,
+            struct_ty.srcLoc(zcu),
+            "packed struct bit width '{d}' exceeds maximum bit width of 65535",
+            .{field_bits},
+        );
+        break :ty try pt.intType(.unsigned, backing_int_bits);
+    };
+    ip.resolvePackedStructLayout(
+        io,
+        struct_ty.toIntern(),
+        backing_int_ty.toIntern(),
+    );
 }
 
 /// Asserts that `struct_ty` is a non-tuple struct, and that `sema.owner` is that type.
@@ -436,25 +452,33 @@ pub fn resolvePackedStructBackingInt(
 pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
-    assert(sema.owner.unwrap().type_inits == struct_ty.toIntern());
+    assert(sema.owner.unwrap().struct_defaults == struct_ty.toIntern());
 
     try sema.ensureLayoutResolved(struct_ty);
 
     const struct_obj = ip.loadStructType(struct_ty.toIntern());
-    const zir_index = struct_obj.zir_index.resolve(ip).?;
 
     try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
 
+    // This logic isn't used for reified structs, because the signature of `@Struct` requires that
+    // default values are populated and correctly typed from the moment the struct type is interned
+    // (because `Sema.zirReifyStruct` had to dereference the default value from a pointer).
+    assert(!struct_obj.is_reified);
+
     if (struct_obj.field_defaults.len == 0) {
         // The struct has no default field values, so the slice has been omitted.
         return;
     }
 
-    const field_types = struct_obj.field_types.get(ip);
+    for (struct_obj.field_is_comptime_bits.getAll(ip)) |bit_bag| {
+        if (bit_bag != 0) {
+            // There is a comptime field, so layout resolution already filled in the defaults for us!
+            // MLUGG TODO: perhaps a better idea would be for layout resolution to populate only the defaults *for comptime fields*.
+            return;
+        }
+    }
 
     var block: Block = .{
         .parent = null,
@@ -468,16 +492,30 @@ pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
     };
     defer assert(block.instructions.items.len == 0);
 
+    return resolveStructDefaultsInner(sema, &block, &struct_obj);
+}
+/// MLUGG TODO: i dislike this, see the 'TODO' in the prev func
+fn resolveStructDefaultsInner(
+    sema: *Sema,
+    block: *Block,
+    struct_obj: *const InternPool.LoadedStructType,
+) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
     // We'll need to map the struct decl instruction to provide result types
+    const zir_index = struct_obj.zir_index.resolve(ip).?;
     try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
 
+    const field_types = struct_obj.field_types.get(ip);
+
     const zir_struct = sema.code.getStructDecl(zir_index);
     var field_it = zir_struct.iterateFields();
     while (field_it.next()) |zir_field| {
-        const default_val_src: LazySrcLoc = .{
-            .base_node_inst = struct_obj.zir_index,
-            .offset = .{ .container_field_value = zir_field.idx },
-        };
+        const default_val_src = block.src(.{ .container_field_value = zir_field.idx });
         block.comptime_reason = .{ .reason = .{
             .src = default_val_src,
             .r = .{ .simple = .struct_field_default_value },
@@ -491,13 +529,13 @@ pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
             // Provide the result type
             sema.inst_map.putAssumeCapacity(zir_index, .fromIntern(field_ty.toIntern()));
             defer assert(sema.inst_map.remove(zir_index));
-            break :ref try sema.resolveInlineBody(&block, default_body, zir_index);
+            break :ref try sema.resolveInlineBody(block, default_body, zir_index);
         };
-        const coerced = try sema.coerce(&block, field_ty, uncoerced, default_val_src);
-        const default_val = try sema.resolveConstValue(&block, default_val_src, coerced, null);
+        const coerced = try sema.coerce(block, field_ty, uncoerced, default_val_src);
+        const default_val = try sema.resolveConstValue(block, default_val_src, coerced, null);
         if (default_val.canMutateComptimeVarState(zcu)) {
             const field_name = struct_obj.field_names.get(ip)[zir_field.idx];
-            return sema.failWithContainsReferenceToComptimeVar(&block, default_val_src, field_name, "field default value", default_val);
+            return sema.failWithContainsReferenceToComptimeVar(block, default_val_src, field_name, "field default value", default_val);
         }
         struct_obj.field_defaults.get(ip)[zir_field.idx] = default_val.toIntern();
     }
@@ -508,6 +546,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
+    const io = comp.io;
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
@@ -516,10 +555,6 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     const union_obj = ip.loadUnionType(union_ty.toIntern());
     const zir_index = union_obj.zir_index.resolve(ip).?;
 
-    assert(union_obj.layout != .@"packed");
-
-    try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
-
     var block: Block = .{
         .parent = null,
         .sema = sema,
@@ -532,48 +567,169 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     };
     defer assert(block.instructions.items.len == 0);
 
-    const zir_union = sema.code.getUnionDecl(zir_index);
-    var field_it = zir_union.iterateFields();
-    while (field_it.next()) |zir_field| {
-        const field_ty_src: LazySrcLoc = .{
-            .base_node_inst = union_obj.zir_index,
-            .offset = .{ .container_field_type = zir_field.idx },
-        };
-        const field_align_src: LazySrcLoc = .{
-            .base_node_inst = union_obj.zir_index,
-            .offset = .{ .container_field_align = zir_field.idx },
+    // MLUGG TODO: this is fucking ugly bro
+    const explicit_enum_tag_ty: ?Type = if (union_obj.is_reified) ty: {
+        break :ty switch (union_obj.enum_tag_mode) {
+            .explicit => .fromInterned(union_obj.enum_tag_type),
+            .auto => null,
         };
+    } else ty: {
+        const zir_union = sema.code.getUnionDecl(zir_index);
+        if (zir_union.kind != .tagged_explicit) {
+            break :ty null; // enum tag type will be automatically generated
+        }
+        // Explicitly specified, so evaluate the enum tag type expression.
+        const tag_type_body = zir_union.arg_type_body.?;
+        const tag_type_src = block.src(.container_arg);
+        block.comptime_reason = .{ .reason = .{
+            .src = tag_type_src,
+            .r = .{ .simple = .union_enum_tag_type },
+        } };
+        const type_ref = try sema.resolveInlineBody(&block, tag_type_body, zir_index);
+        break :ty try sema.analyzeAsType(&block, tag_type_src, .union_enum_tag_type, type_ref);
+    };
+    const enum_tag_ty: Type = if (explicit_enum_tag_ty) |enum_tag_ty| ty: {
+        if (enum_tag_ty.zigTypeTag(zcu) != .@"enum") return sema.fail(
+            &block,
+            block.src(.container_arg),
+            "expected enum tag type, found '{f}'",
+            .{enum_tag_ty.fmt(pt)},
+        );
+        break :ty enum_tag_ty;
+    } else switch (try ip.getGeneratedEnumTagType(gpa, io, pt.tid, .{
+        .union_type = union_ty.toIntern(),
+        // MLUGG TODO: a bit hacky icl
+        .int_tag_mode = mode: {
+            if (union_obj.is_reified) break :mode .auto;
+            const zir_union = sema.code.getUnionDecl(zir_index);
+            if (zir_union.kind != .tagged_enum_explicit) break :mode .auto;
+            break :mode .explicit;
+        },
+        .fields_len = @intCast(union_obj.field_types.len),
+    })) {
+        .existing => |tag_ty| .fromInterned(tag_ty),
+        .wip => |wip| tag_ty: {
+            errdefer wip.cancel(ip, pt.tid);
+            _ = wip.setName(ip, try ip.getOrPutStringFmt(
+                gpa,
+                io,
+                pt.tid,
+                "@typeInfo({f}).@\"union\".tag_type.?",
+                .{union_obj.name.fmt(ip)},
+                .no_embedded_nulls,
+            ), .none);
+            const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+                .parent = union_obj.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = zcu.namespacePtr(union_obj.namespace).file_scope,
+                .generation = zcu.generation,
+            });
+            if (comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable; // because we don't remove the `outdated` entry
+            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+            break :tag_ty .fromInterned(wip.finish(ip, new_namespace_index));
+        },
+    };
 
-        const field_ty: Type = field_ty: {
-            block.comptime_reason = .{ .reason = .{
-                .src = field_ty_src,
-                .r = .{ .simple = .union_field_types },
-            } };
-            const type_body = zir_field.type_body orelse break :field_ty .void;
-            const type_ref = try sema.resolveInlineBody(&block, type_body, zir_index);
-            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
-        };
+    try sema.ensureLayoutResolved(enum_tag_ty);
+    const enum_obj = ip.loadEnumType(enum_tag_ty.toIntern());
+
+    if (union_obj.is_reified) {
+        // We have field names in `union_obj.reified_field_names`, but we haven't
+        // checked them against the backing type yet.
+        const union_field_names = union_obj.reified_field_names.get(ip);
+        match_fields: {
+            // We can efficiently *check* if the fields match...
+            if (union_field_names.len == enum_obj.field_names.len) {
+                for (union_field_names, enum_obj.field_names.get(ip)) |union_field_name, enum_field_name| {
+                    if (!std.mem.eql(u8, union_field_name.toSlice(ip), enum_field_name.toSlice(ip))) break;
+                } else {
+                    break :match_fields;
+                }
+            }
+            // ...but if they don't, reporting a nice error is a little more involved. If some field
+            // is present in the enum but not the union, or vice versa, we will report that instead
+            // of a generic "field order mismatch" error. Of course, this error is impossible for a
+            // generated tag type, because we populated that from the union ZIR!
+            assert(enum_obj.owner_union != union_ty.toIntern());
+            return failUnionFieldMismatch(sema, &block, union_field_names, enum_tag_ty, &enum_obj);
+        }
+    } else {
+        // Declared unions do not have field types or aligns populated yet.
+        // We also need to check the field names match the backing enum.
+        try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
+        const zir_union = sema.code.getUnionDecl(zir_index);
+
+        // We'll first check the field names against the backing enum, and only analyze the types
+        // once we know the fields match one-to-one.
+        match_fields: {
+            // We can efficiently *check* if the fields match...
+            if (zir_union.field_names.len == enum_obj.field_names.len) {
+                for (zir_union.field_names, enum_obj.field_names.get(ip)) |union_field_name_zir, enum_field_name| {
+                    const union_field_name_slice = sema.code.nullTerminatedString(union_field_name_zir);
+                    if (!std.mem.eql(u8, union_field_name_slice, enum_field_name.toSlice(ip))) break;
+                } else {
+                    break :match_fields;
+                }
+            }
+            // ...but if they don't, reporting a nice error is a little more involved. If some field
+            // is present in the enum but not the union, or vice versa, we will report that instead
+            // of a generic "field order mismatch" error. Of course, this error is impossible for a
+            // generated tag type, because we populated that from the union ZIR!
+            assert(enum_obj.owner_union != union_ty.toIntern());
+            const union_field_names = try sema.arena.alloc(InternPool.NullTerminatedString, zir_union.field_names.len);
+            for (zir_union.field_names, union_field_names) |name_zir, *name| {
+                name.* = try ip.getOrPutString(gpa, io, pt.tid, sema.code.nullTerminatedString(name_zir), .no_embedded_nulls);
+            }
+            return failUnionFieldMismatch(sema, &block, union_field_names, enum_tag_ty, &enum_obj);
+        }
+
+        // Field names okay; populate types and aligns.
+        var field_it = zir_union.iterateFields();
+        while (field_it.next()) |zir_field| {
+            const field_ty_src = block.src(.{ .container_field_type = zir_field.idx });
+            const field_ty: Type = field_ty: {
+                block.comptime_reason = .{ .reason = .{
+                    .src = field_ty_src,
+                    .r = .{ .simple = .union_field_types },
+                } };
+                const type_body = zir_field.type_body orelse break :field_ty .void;
+                const type_ref = try sema.resolveInlineBody(&block, type_body, zir_index);
+                break :field_ty try sema.analyzeAsType(&block, field_ty_src, .union_field_types, type_ref);
+            };
+            union_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+
+            const field_align_src = block.src(.{ .container_field_align = zir_field.idx });
+            const explicit_field_align: Alignment = a: {
+                block.comptime_reason = .{ .reason = .{
+                    .src = field_align_src,
+                    .r = .{ .simple = .union_field_attrs },
+                } };
+                const align_body = zir_field.align_body orelse break :a .none;
+                const align_ref = try sema.resolveInlineBody(&block, align_body, zir_index);
+                break :a try sema.analyzeAsAlign(&block, field_align_src, align_ref);
+            };
+            if (union_obj.field_aligns.len != 0) {
+                union_obj.field_aligns.get(ip)[zir_field.idx] = explicit_field_align;
+            } else {
+                assert(explicit_field_align == .none);
+            }
+        }
+    }
+
+    if (union_obj.layout == .@"packed") {
+        return resolvePackedUnionLayout(sema, &block, union_ty, &union_obj, enum_tag_ty);
+    }
+
+    // Resolve the layout of all fields, and check their types are allowed.
+    for (union_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
-        union_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
-
+        const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
         try sema.ensureLayoutResolved(field_ty);
-
-        const explicit_field_align: Alignment = a: {
-            block.comptime_reason = .{ .reason = .{
-                .src = field_align_src,
-                .r = .{ .simple = .union_field_attrs },
-            } };
-            const align_body = zir_field.align_body orelse break :a .none;
-            const align_ref = try sema.resolveInlineBody(&block, align_body, zir_index);
-            break :a try sema.analyzeAsAlign(&block, field_align_src, align_ref);
-        };
-
-        if (union_obj.field_aligns.len != 0) {
-            union_obj.field_aligns.get(ip)[zir_field.idx] = explicit_field_align;
-        } else {
-            assert(explicit_field_align == .none);
-        }
-
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
@@ -583,7 +739,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
                 break :msg msg;
             });
         }
-        if (union_obj.layout == .@"extern" and !try sema.validateExternType(field_ty, .union_field)) {
+        if (union_obj.layout == .@"extern" and !field_ty.validateExtern(.union_field, zcu)) {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "extern unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
                 errdefer msg.destroy(gpa);
@@ -594,36 +750,11 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         }
     }
 
-    try finishUnionLayout(
-        sema,
-        &block,
-        union_ty.srcLoc(zcu),
-        union_ty.toIntern(),
-        &union_obj,
-        .fromInterned(union_obj.enum_tag_type),
-    );
-}
-
-/// Called after populating field types and alignments; populates overall union layout
-/// information (size, alignment, comptime-only state, etc).
-pub fn finishUnionLayout(
-    sema: *Sema,
-    /// Only used to report compile errors.
-    block: *Block,
-    union_src: LazySrcLoc,
-    union_ty: InternPool.Index,
-    union_obj: *const InternPool.LoadedUnionType,
-    enum_tag_ty: Type,
-) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const io = comp.io;
-    const ip = &zcu.intern_pool;
-
+    // Fields are okay. Now we need to resolve the union's overall layout (size, alignment, etc).
     var payload_align: Alignment = .@"1";
     var payload_size: u64 = 0;
     var comptime_only = false;
+    var has_runtime_bits = union_obj.runtime_tag != .none and enum_tag_ty.hasRuntimeBits(zcu);
     var possible_values: enum { none, one, many } = .none;
     for (0..union_obj.field_types.len) |field_idx| {
         const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]);
@@ -637,6 +768,7 @@ pub fn finishUnionLayout(
         payload_align = payload_align.maxStrict(field_align);
         payload_size = @max(payload_size, field_ty.abiSize(zcu));
         if (field_ty.comptimeOnly(zcu)) comptime_only = true;
+        if (field_ty.hasRuntimeBits(zcu)) has_runtime_bits = true;
         if (!field_ty.isNoReturn(zcu)) {
             if (try field_ty.onePossibleValue(pt) != null) {
                 possible_values = .many; // this field alone has many possible values
@@ -664,211 +796,210 @@ pub fn finishUnionLayout(
     };
 
     const casted_size = std.math.cast(u32, size) orelse return sema.fail(
-        block,
-        union_src,
+        &block,
+        union_ty.srcLoc(zcu),
         "union layout requires size {d}, this compiler implementation supports up to {d}",
         .{ size, std.math.maxInt(u32) },
     );
     ip.resolveUnionLayout(
         io,
-        union_ty,
+        union_ty.toIntern(),
+        enum_tag_ty.toIntern(),
         casted_size,
         @intCast(padding), // okay because padding is no greater than size
         alignment,
         possible_values == .none, // MLUGG TODO: make sure queries use `LoadedUnionType.has_no_possible_value`!
         possible_values == .one,
         comptime_only,
+        has_runtime_bits,
     );
 }
-
-pub fn resolvePackedUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
+fn failUnionFieldMismatch(sema: *Sema, block: *Block, union_field_names: []const InternPool.NullTerminatedString, enum_tag_ty: Type, enum_obj: *const InternPool.LoadedEnumType) CompileError {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
-
-    assert(sema.owner.unwrap().type_layout == union_ty.toIntern());
-
-    const union_obj = ip.loadUnionType(union_ty.toIntern());
-    const zir_index = union_obj.zir_index.resolve(ip).?;
-
-    assert(union_obj.layout == .@"packed");
-
-    try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
-
-    var block: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = union_obj.namespace,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = undefined, // always set before using `block`
-        .src_base_inst = union_obj.zir_index,
-        .type_name_ctx = union_obj.name,
-    };
-    defer assert(block.instructions.items.len == 0);
-
-    const zir_union = sema.code.getUnionDecl(zir_index);
-    var field_it = zir_union.iterateFields();
-    while (field_it.next()) |zir_field| {
-        const field_ty_src: LazySrcLoc = .{
-            .base_node_inst = union_obj.zir_index,
-            .offset = .{ .container_field_type = zir_field.idx },
+    const enum_to_union_map = try sema.arena.alloc(?u32, enum_obj.field_names.len);
+    @memset(enum_to_union_map, null);
+    for (union_field_names, 0..) |field_name, union_field_index| {
+        if (enum_obj.nameIndex(ip, field_name)) |enum_field_index| {
+            enum_to_union_map[enum_field_index] = @intCast(union_field_index);
+            continue;
+        }
+        const union_field_src = block.src(.{ .container_field_name = @intCast(union_field_index) });
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(union_field_src, "no field named '{f}' in enum '{f}'", .{ field_name.fmt(ip), enum_tag_ty.fmt(pt) });
+            errdefer msg.destroy(gpa);
+            try sema.addDeclaredHereNote(msg, enum_tag_ty);
+            break :msg msg;
+        });
+    }
+    for (enum_to_union_map, 0..) |union_field_index, enum_field_index| {
+        if (union_field_index != null) continue;
+        const field_name_ip = enum_obj.field_names.get(ip)[enum_field_index];
+        const enum_field_src: LazySrcLoc = .{
+            .base_node_inst = enum_tag_ty.typeDeclInstAllowGeneratedTag(zcu).?,
+            .offset = .{ .container_field_name = @intCast(enum_field_index) },
         };
-        const field_ty: Type = field_ty: {
-            block.comptime_reason = .{ .reason = .{
-                .src = field_ty_src,
-                .r = .{ .simple = .union_field_types },
-            } };
-            // MLUGG TODO: i think this should probably be a compile error? (if so, it's an astgen one, right?)
-            const type_body = zir_field.type_body orelse break :field_ty .void;
-            const type_ref = try sema.resolveInlineBody(&block, type_body, zir_index);
-            break :field_ty try sema.analyzeAsType(&block, field_ty_src, type_ref);
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(block.nodeOffset(.zero), "enum field '{f}' missing from union", .{field_name_ip.fmt(ip)});
+            errdefer msg.destroy(gpa);
+            try sema.errNote(enum_field_src, msg, "enum field here", .{});
+            break :msg msg;
+        });
+    }
+    // The only problem is the field ordering.
+    for (enum_to_union_map, 0..) |union_field_index, enum_field_index| {
+        if (union_field_index.? == enum_field_index) continue;
+        const field_name = enum_obj.field_names.get(ip)[enum_field_index];
+        const union_field_src = block.src(.{ .container_field_name = union_field_index.? });
+        const enum_field_src: LazySrcLoc = .{
+            .base_node_inst = enum_tag_ty.typeDeclInstAllowGeneratedTag(zcu).?,
+            .offset = .{ .container_field_name = @intCast(enum_field_index) },
         };
-        assert(!field_ty.isGenericPoison());
-        union_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
-
-        assert(zir_field.align_body == null); // packed union fields cannot be aligned
-        assert(zir_field.value_body == null); // packed union fields cannot have tag values
-
-        try sema.ensureLayoutResolved(field_ty);
-
-        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
-            return sema.failWithOwnedErrorMsg(&block, msg: {
-                const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
-                errdefer msg.destroy(gpa);
-                try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            });
-        }
-        if (!field_ty.packable(zcu)) {
-            return sema.failWithOwnedErrorMsg(&block, msg: {
-                const msg = try sema.errMsg(field_ty_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
-                errdefer msg.destroy(gpa);
-                try sema.explainWhyTypeIsNotPackable(msg, field_ty_src, field_ty);
-                try sema.addDeclaredHereNote(msg, field_ty);
-                break :msg msg;
-            });
-        }
-        assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(block.nodeOffset(.zero), "union field order does not match tag enum field order", .{});
+            errdefer msg.destroy(gpa);
+            try sema.errNote(union_field_src, msg, "union field '{f}' is index {d}", .{ field_name.fmt(ip), union_field_index.? });
+            try sema.errNote(enum_field_src, msg, "enum field '{f}' is index {d}", .{ field_name.fmt(ip), enum_field_index });
+            break :msg msg;
+        });
     }
-
-    try resolvePackedUnionBackingInt(sema, &block, union_ty, &union_obj, false);
+    unreachable; // we already determined that *something* is wrong
 }
-
-/// MLUGG TODO doc comment; asserts all fields are resolved or whatever
-pub fn resolvePackedUnionBackingInt(
+fn resolvePackedUnionLayout(
     sema: *Sema,
     block: *Block,
     union_ty: Type,
     union_obj: *const InternPool.LoadedUnionType,
-    is_reified: bool,
-) SemaError!void {
+    enum_tag_ty: Type,
+) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
-    const gpa = comp.gpa;
     const io = comp.io;
+    const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
-    switch (union_obj.packed_backing_mode) {
-        .explicit => {
-            const backing_int_type: Type = .fromInterned(union_obj.packed_backing_int_type);
-            const backing_int_bits = backing_int_type.intInfo(zcu).bits;
-            for (union_obj.field_types.get(ip), 0..) |field_type_ip, field_idx| {
-                const field_type: Type = .fromInterned(field_type_ip);
-                const field_bits = field_type.bitSize(zcu);
-                if (field_bits != backing_int_bits) return sema.failWithOwnedErrorMsg(block, msg: {
-                    const field_ty_src: LazySrcLoc = .{
-                        .base_node_inst = union_obj.zir_index,
-                        .offset = if (is_reified)
-                            .nodeOffset(.zero)
-                        else
-                            .{ .container_field_type = @intCast(field_idx) },
-                    };
-                    const msg = try sema.errMsg(field_ty_src, "field bit width does not match backing integer", .{});
-                    errdefer msg.destroy(gpa);
-                    try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
-                    try sema.errNote(field_ty_src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_int_type.fmt(pt), backing_int_bits });
-                    try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
-                    break :msg msg;
-                });
-            }
-        },
-        .auto => switch (union_obj.field_types.len) {
-            0 => ip.resolvePackedUnionBackingInt(io, union_ty.toIntern(), .u0_type),
-            else => {
-                const field_types = union_obj.field_types.get(ip);
-                const first_field_type: Type = .fromInterned(field_types[0]);
-                const first_field_bits = first_field_type.bitSize(zcu);
-                for (field_types[1..], 1..) |field_type_ip, field_idx| {
-                    const field_type: Type = .fromInterned(field_type_ip);
-                    const field_bits = field_type.bitSize(zcu);
-                    if (field_bits != first_field_bits) return sema.failWithOwnedErrorMsg(block, msg: {
-                        const first_field_ty_src: LazySrcLoc = .{
-                            .base_node_inst = union_obj.zir_index,
-                            .offset = if (is_reified)
-                                .nodeOffset(.zero)
-                            else
-                                .{ .container_field_type = 0 },
-                        };
-                        const field_ty_src: LazySrcLoc = .{
-                            .base_node_inst = union_obj.zir_index,
-                            .offset = if (is_reified)
-                                .nodeOffset(.zero)
-                            else
-                                .{ .container_field_type = @intCast(field_idx) },
-                        };
-                        const msg = try sema.errMsg(field_ty_src, "field bit width does not match earlier field", .{});
-                        errdefer msg.destroy(gpa);
-                        try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
-                        try sema.errNote(first_field_ty_src, msg, "other field type '{f}' has bit width '{d}'", .{ first_field_type.fmt(pt), first_field_bits });
-                        try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
-                        break :msg msg;
-                    });
-                }
-                const backing_int_bits = std.math.cast(u16, first_field_bits) orelse return sema.fail(
-                    block,
-                    block.nodeOffset(.zero),
-                    "packed union bit width '{d}' exceeds maximum bit width of 65535",
-                    .{first_field_bits},
-                );
-                const backing_int_type = try pt.intType(.unsigned, backing_int_bits);
-                ip.resolvePackedUnionBackingInt(io, union_ty.toIntern(), backing_int_type.toIntern());
-            },
-        },
+
+    // Resolve the layout of all fields, and check their types are allowed.
+    for (union_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
+        assert(!field_ty.isGenericPoison());
+        const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
+        try sema.ensureLayoutResolved(field_ty);
+        if (field_ty.zigTypeTag(zcu) == .@"opaque") {
+            return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "opaque types have unknown size", .{});
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            });
+        }
+        if (field_ty.unpackable(zcu)) |reason| return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(field_ty_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
+            errdefer msg.destroy(gpa);
+            try sema.explainWhyTypeIsUnpackable(msg, field_ty_src, reason);
+            try sema.addDeclaredHereNote(msg, field_ty);
+            break :msg msg;
+        });
+        assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
     }
+
+    const explicit_backing_int_ty: ?Type = if (union_obj.is_reified) ty: {
+        switch (union_obj.packed_backing_mode) {
+            .explicit => break :ty .fromInterned(union_obj.packed_backing_int_type),
+            .auto => break :ty null,
+        }
+    } else ty: {
+        const zir_index = union_obj.zir_index.resolve(ip).?;
+        const zir_union = sema.code.getUnionDecl(zir_index);
+        const backing_int_type_body = zir_union.arg_type_body orelse {
+            break :ty null; // inferred backing type
+        };
+        // Explicitly specified, so evaluate the backing int type expression.
+        const backing_int_type_src = block.src(.container_arg);
+        block.comptime_reason = .{ .reason = .{
+            .src = backing_int_type_src,
+            .r = .{ .simple = .packed_union_backing_int_type },
+        } };
+        const type_ref = try sema.resolveInlineBody(block, backing_int_type_body, zir_index);
+        break :ty try sema.analyzeAsType(block, backing_int_type_src, .packed_union_backing_int_type, type_ref);
+    };
+
+    // Finally, either validate or infer the backing int type.
+    const backing_int_ty: Type = if (explicit_backing_int_ty) |backing_ty| ty: {
+        const backing_int_bits = backing_ty.intInfo(zcu).bits;
+        for (union_obj.field_types.get(ip), 0..) |field_type_ip, field_idx| {
+            const field_type: Type = .fromInterned(field_type_ip);
+            const field_bits = field_type.bitSize(zcu);
+            if (field_bits != backing_int_bits) return sema.failWithOwnedErrorMsg(block, msg: {
+                const field_ty_src = block.src(.{ .container_field_type = @intCast(field_idx) });
+                const msg = try sema.errMsg(field_ty_src, "field bit width does not match backing integer", .{});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
+                try sema.errNote(field_ty_src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_int_bits });
+                try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
+                break :msg msg;
+            });
+        }
+        break :ty backing_ty;
+    } else if (union_obj.field_types.len == 0) ty: {
+        // Special case: there is no first field to infer the type from. Treat the union as empty (zero-bit).
+        break :ty .u0;
+    } else ty: {
+        const field_types = union_obj.field_types.get(ip);
+        const first_field_type: Type = .fromInterned(field_types[0]);
+        const first_field_bits = first_field_type.bitSize(zcu);
+        for (field_types[1..], 1..) |field_type_ip, field_idx| {
+            const field_type: Type = .fromInterned(field_type_ip);
+            const field_bits = field_type.bitSize(zcu);
+            if (field_bits != first_field_bits) return sema.failWithOwnedErrorMsg(block, msg: {
+                const first_field_ty_src = block.src(.{ .container_field_type = 0 });
+                const field_ty_src = block.src(.{ .container_field_type = @intCast(field_idx) });
+                const msg = try sema.errMsg(field_ty_src, "field bit width does not match earlier field", .{});
+                errdefer msg.destroy(gpa);
+                try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
+                try sema.errNote(first_field_ty_src, msg, "other field type '{f}' has bit width '{d}'", .{ first_field_type.fmt(pt), first_field_bits });
+                try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
+                break :msg msg;
+            });
+        }
+        const backing_int_bits = std.math.cast(u16, first_field_bits) orelse return sema.fail(
+            block,
+            union_ty.srcLoc(zcu),
+            "packed union bit width '{d}' exceeds maximum bit width of 65535",
+            .{first_field_bits},
+        );
+        break :ty try pt.intType(.unsigned, backing_int_bits);
+    };
+    ip.resolvePackedUnionLayout(
+        io,
+        union_ty.toIntern(),
+        enum_tag_ty.toIntern(),
+        backing_int_ty.toIntern(),
+    );
 }
 
-/// Asserts that `enum_ty` is an enum and that `sema.owner` is that type.
-/// This function *does* register the `src_hash` dependency on the enum.
-pub fn resolveEnumValues(sema: *Sema, enum_ty: Type) CompileError!void {
+pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
+    const io = comp.io;
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
-    assert(sema.owner.unwrap().type_inits == enum_ty.toIntern());
+    assert(sema.owner.unwrap().type_layout == enum_ty.toIntern());
 
     const enum_obj = ip.loadEnumType(enum_ty.toIntern());
 
-    // We'll populate this map.
-    const field_value_map = enum_obj.field_value_map.unwrap() orelse {
-        // The enum has an automatically generated tag and is auto-numbered. We know that we have
-        // generated a suitably large type in `analyzeEnumDecl`, so we have no work to do.
-        return;
-    };
-
     const maybe_parent_union_obj: ?InternPool.LoadedUnionType = un: {
         if (enum_obj.owner_union == .none) break :un null;
         break :un ip.loadUnionType(enum_obj.owner_union);
     };
+
     const tracked_inst = enum_obj.zir_index.unwrap() orelse maybe_parent_union_obj.?.zir_index;
-    const zir_index = tracked_inst.resolve(ip).?;
-
-    try sema.declareDependency(.{ .src_hash = tracked_inst });
 
     var block: Block = .{
         .parent = null,
@@ -882,7 +1013,139 @@ pub fn resolveEnumValues(sema: *Sema, enum_ty: Type) CompileError!void {
     };
     defer assert(block.instructions.items.len == 0);
 
-    const int_tag_ty: Type = .fromInterned(enum_obj.int_tag_type);
+    // There may be old field names in the map from a previous update.
+    enum_obj.field_name_map.get(ip).clearRetainingCapacity();
+
+    if (maybe_parent_union_obj) |*union_obj| {
+        if (union_obj.is_reified) {
+            // In the case of reification, the union stores the field names, just for us to copy.
+            @memcpy(enum_obj.field_names.get(ip), union_obj.reified_field_names.get(ip));
+            // The list of field names is now populated, but we haven't checked for duplicates yet,
+            // nor have we populated the hash map.
+            for (0..enum_obj.field_names.len) |field_index| {
+                const name = enum_obj.field_names.get(ip)[field_index];
+                if (ip.addFieldName(enum_obj.field_names, enum_obj.field_name_map, name)) |prev_field_index| {
+                    return sema.failWithOwnedErrorMsg(&block, msg: {
+                        const src = block.nodeOffset(.zero);
+                        const msg = try sema.errMsg(src, "duplicate union field '{f}' at index '{d}", .{ name.fmt(ip), field_index });
+                        errdefer msg.destroy(gpa);
+                        try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_index});
+                        break :msg msg;
+                    });
+                }
+            }
+        } else {
+            // Generated tag enums for declared unions do not yet have field names populated. It is
+            // our job to populate them now.
+            try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
+            const zir_union = sema.code.getUnionDecl(union_obj.zir_index.resolve(ip).?);
+            for (zir_union.field_names) |zir_field_name| {
+                const name_slice = sema.code.nullTerminatedString(zir_field_name);
+                const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
+                assert(ip.addFieldName(enum_obj.field_names, enum_obj.field_name_map, name) == null); // AstGen validated this for us
+            }
+        }
+    } else {
+        if (enum_obj.is_reified) {
+            // The field names are populated, but we haven't checked for duplicates (nor populated the map) yet.
+            for (0..enum_obj.field_names.len) |field_index| {
+                const name = enum_obj.field_names.get(ip)[field_index];
+                if (ip.addFieldName(enum_obj.field_names, enum_obj.field_name_map, name)) |prev_field_index| {
+                    return sema.failWithOwnedErrorMsg(&block, msg: {
+                        const src = block.nodeOffset(.zero);
+                        const msg = try sema.errMsg(src, "duplicate enum field '{f}' at index '{d}", .{ name.fmt(ip), field_index });
+                        errdefer msg.destroy(gpa);
+                        try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_index});
+                        break :msg msg;
+                    });
+                }
+            }
+        } else {
+            // Declared enums do not yet have field names populated. It is our job to populate them now.
+            try sema.declareDependency(.{ .src_hash = enum_obj.zir_index.unwrap().? });
+            const zir_enum = sema.code.getEnumDecl(enum_obj.zir_index.unwrap().?.resolve(ip).?);
+            for (zir_enum.field_names) |zir_field_name| {
+                const name_slice = sema.code.nullTerminatedString(zir_field_name);
+                const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
+                assert(ip.addFieldName(enum_obj.field_names, enum_obj.field_name_map, name) == null); // AstGen validated this for us
+            }
+        }
+    }
+
+    // Field names populated; now deal with the backing integer type. If explicitly provided,
+    // validate it; otherwise, infer it.
+
+    const explicit_int_tag_ty: ?Type = if (enum_obj.is_reified) ty: {
+        break :ty switch (enum_obj.int_tag_mode) {
+            .explicit => .fromInterned(enum_obj.int_tag_type),
+            .auto => null,
+        };
+    } else if (maybe_parent_union_obj) |*union_obj| ty: {
+        if (union_obj.is_reified) {
+            // Reification has no equivalent of 'union(enum(T))'.
+            break :ty null;
+        }
+        const zir_index = union_obj.zir_index.resolve(ip).?;
+        const zir_union = sema.code.getUnionDecl(zir_index);
+        if (zir_union.kind != .tagged_enum_explicit) {
+            break :ty null; // int tag type will be inferred
+        }
+        // Explicitly specified, so evaluate the int tag type expression.
+        const tag_type_body = zir_union.arg_type_body.?;
+        const tag_type_src = block.src(.container_arg);
+        block.comptime_reason = .{ .reason = .{
+            .src = tag_type_src,
+            .r = .{ .simple = .enum_int_tag_type },
+        } };
+        const type_ref = try sema.resolveInlineBody(&block, tag_type_body, zir_index);
+        break :ty try sema.analyzeAsType(&block, tag_type_src, .enum_int_tag_type, type_ref);
+    } else ty: {
+        const zir_index = enum_obj.zir_index.unwrap().?.resolve(ip).?;
+        const zir_enum = sema.code.getEnumDecl(zir_index);
+        const tag_type_body = zir_enum.tag_type_body orelse {
+            break :ty null; // int tag type will be inferred
+        };
+        // Explicitly specified, so evaluate the int tag type expression.
+        const tag_type_src = block.src(.container_arg);
+        block.comptime_reason = .{ .reason = .{
+            .src = tag_type_src,
+            .r = .{ .simple = .enum_int_tag_type },
+        } };
+        const type_ref = try sema.resolveInlineBody(&block, tag_type_body, zir_index);
+        break :ty try sema.analyzeAsType(&block, tag_type_src, .enum_int_tag_type, type_ref);
+    };
+    const int_tag_ty: Type = if (explicit_int_tag_ty) |int_tag_ty| ty: {
+        if (int_tag_ty.zigTypeTag(zcu) != .int) return sema.fail(
+            &block,
+            block.src(.container_arg),
+            "expected integer tag type, found '{f}'",
+            .{int_tag_ty.fmt(pt)},
+        );
+        break :ty int_tag_ty;
+    } else ty: {
+        // Infer the int tag type from the field count
+        const bits = Type.smallestUnsignedBits(enum_obj.field_names.len -| 1);
+        break :ty try pt.intType(.unsigned, bits);
+    };
+
+    ip.resolveEnumLayout(io, enum_ty.toIntern(), int_tag_ty.toIntern());
+
+    // Finally, deal with field values. For declared types we need to analyze the expressions, while
+    // reified types already have them populated; but either way, we need to populate the hash map
+    // (and validate the values along the way).
+
+    // We'll populate this map.
+    const field_value_map = enum_obj.field_value_map.unwrap() orelse {
+        // The enum is auto-numbered with an inferred tag type. We know that the tag type generated
+        // earlier is sufficient for the number of fields, so we have nothing more to do.
+        assert(enum_obj.int_tag_mode == .auto);
+        return;
+    };
+
+    // There may be old field values in here from a previous update.
+    field_value_map.get(ip).clearRetainingCapacity();
+
+    const zir_index = tracked_inst.resolve(ip).?;
 
     // Map the enum (or union) decl instruction to provide the tag type as the result type
     try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
@@ -891,36 +1154,38 @@ pub fn resolveEnumValues(sema: *Sema, enum_ty: Type) CompileError!void {
 
     // First, populate any explicitly provided values. This is the part that actually depends on
     // the ZIR, and hence depends on whether this is a declared or generated enum. If any explicit
-    // value is invalid, we'll emit an error here.
+    // value is straight-up invalid, we'll emit an error here.
     if (maybe_parent_union_obj) |union_obj| {
-        const zir_union = sema.code.getUnionDecl(zir_index);
-        var field_it = zir_union.iterateFields();
-        while (field_it.next()) |zir_field| {
-            const field_val_src: LazySrcLoc = .{
-                .base_node_inst = union_obj.zir_index,
-                .offset = .{ .container_field_value = zir_field.idx },
-            };
-            block.comptime_reason = .{ .reason = .{
-                .src = field_val_src,
-                .r = .{ .simple = .enum_field_values },
-            } };
-            const value_body = zir_field.value_body orelse {
-                enum_obj.field_values.get(ip)[zir_field.idx] = .none;
-                continue;
-            };
-            const uncoerced = try sema.resolveInlineBody(&block, value_body, zir_index);
-            const coerced = try sema.coerce(&block, int_tag_ty, uncoerced, field_val_src);
-            const val = try sema.resolveConstValue(&block, field_val_src, coerced, null);
-            enum_obj.field_values.get(ip)[zir_field.idx] = val.toIntern();
+        if (union_obj.is_reified) {
+            // Generated tag type for reified union; values already populated.
+        } else {
+            // Generated tag type for declared union; evaluate the expressions given in the union declaration.
+            const zir_union = sema.code.getUnionDecl(zir_index);
+            var field_it = zir_union.iterateFields();
+            while (field_it.next()) |zir_field| {
+                const field_val_src = block.src(.{ .container_field_value = zir_field.idx });
+                block.comptime_reason = .{ .reason = .{
+                    .src = field_val_src,
+                    .r = .{ .simple = .enum_field_values },
+                } };
+                const value_body = zir_field.value_body orelse {
+                    enum_obj.field_values.get(ip)[zir_field.idx] = .none;
+                    continue;
+                };
+                const uncoerced = try sema.resolveInlineBody(&block, value_body, zir_index);
+                const coerced = try sema.coerce(&block, int_tag_ty, uncoerced, field_val_src);
+                const val = try sema.resolveConstValue(&block, field_val_src, coerced, null);
+                enum_obj.field_values.get(ip)[zir_field.idx] = val.toIntern();
+            }
         }
+    } else if (enum_obj.is_reified) {
+        // Reified enum; values already populated.
     } else {
+        // Declared enum; evaluate the expressions given in the enum declaration.
         const zir_enum = sema.code.getEnumDecl(zir_index);
         var field_it = zir_enum.iterateFields();
         while (field_it.next()) |zir_field| {
-            const field_val_src: LazySrcLoc = .{
-                .base_node_inst = enum_obj.zir_index.unwrap().?,
-                .offset = .{ .container_field_value = zir_field.idx },
-            };
+            const field_val_src = block.src(.{ .container_field_value = zir_field.idx });
             block.comptime_reason = .{ .reason = .{
                 .src = field_val_src,
                 .r = .{ .simple = .enum_field_values },
@@ -940,14 +1205,14 @@ pub fn resolveEnumValues(sema: *Sema, enum_ty: Type) CompileError!void {
     // field values. This is also where we'll detect duplicates.
 
     for (0..enum_obj.field_names.len) |field_idx| {
-        const field_val_src: LazySrcLoc = .{
-            .base_node_inst = tracked_inst,
-            .offset = .{ .container_field_value = @intCast(field_idx) },
-        };
+        const field_val_src = block.src(.{ .container_field_value = @intCast(field_idx) });
         // If the field value was not specified, compute the implicit value.
         const field_val = val: {
             const explicit_val = enum_obj.field_values.get(ip)[field_idx];
-            if (explicit_val != .none) break :val explicit_val;
+            if (explicit_val != .none) {
+                assert(ip.typeOf(explicit_val) == int_tag_ty.toIntern());
+                break :val explicit_val;
+            }
             if (field_idx == 0) {
                 // Implicit value is 0, which is valid for every integer type.
                 const val = (try pt.intValue(int_tag_ty, 0)).toIntern();
@@ -967,23 +1232,23 @@ pub fn resolveEnumValues(sema: *Sema, enum_ty: Type) CompileError!void {
             enum_obj.field_values.get(ip)[field_idx] = val;
             break :val val;
         };
-        const adapter: InternPool.Index.Adapter = .{ .indexes = enum_obj.field_values.get(ip)[0..field_idx] };
-        const gop = field_value_map.get(ip).getOrPutAssumeCapacityAdapted(field_val, adapter);
-        if (!gop.found_existing) continue;
-        const prev_field_val_src: LazySrcLoc = .{
-            .base_node_inst = tracked_inst,
-            .offset = .{ .container_field_value = @intCast(gop.index) },
-        };
-        return sema.failWithOwnedErrorMsg(&block, msg: {
-            const msg = try sema.errMsg(field_val_src, "enum tag value '{f}' already taken", .{
-                Value.fromInterned(field_val).fmtValueSema(pt, sema),
+        if (ip.addFieldTagValue(enum_obj.field_values, field_value_map, field_val)) |prev_field_index| {
+            return sema.failWithOwnedErrorMsg(&block, msg: {
+                const prev_field_val_src = block.src(.{ .container_field_value = prev_field_index });
+                const msg = try sema.errMsg(field_val_src, "enum tag value '{f}' for field '{f}' already taken", .{
+                    Value.fromInterned(field_val).fmtValueSema(pt, sema),
+                    enum_obj.field_names.get(ip)[field_idx].fmt(ip),
+                });
+                errdefer msg.destroy(gpa);
+                try sema.errNote(prev_field_val_src, msg, "previous occurrence in field '{f}'", .{
+                    enum_obj.field_names.get(ip)[prev_field_index].fmt(ip),
+                });
+                break :msg msg;
             });
-            errdefer msg.destroy(gpa);
-            try sema.errNote(prev_field_val_src, msg, "previous occurrence here", .{});
-            break :msg msg;
-        });
+        }
     }
 
+    // MLUGG TODO: fate of this line rests on whether comptime_int is a valid int tag type
     if (enum_obj.nonexhaustive and int_tag_ty.toIntern() != .comptime_int_type) {
         const fields_len = enum_obj.field_names.len;
         if (fields_len >= 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(zcu)) {
diff --git a/src/Type.zig b/src/Type.zig
index 52dc5ed1ebb7918d930f51d21c65ba68a8178be5..111f6347ed2d0f72cd70db20a59dfc806fe140e8 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -437,6 +437,7 @@ pub fn toValue(self: Type) Value {
 ///   - an enum with an explicit tag type has the ABI size of the integer tag type,
 ///     making it one-possible-value only if the integer tag type has 0 bits.
 pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
+    ty.assertHasLayout(zcu);
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
         .int_type => |int_type| int_type.bits != 0,
@@ -499,14 +500,18 @@ pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
             .generic_poison => unreachable,
         },
         .struct_type => {
-            // TODO MLUGG: memoize this state when resolving struct?
             const struct_obj = ip.loadStructType(ty.toIntern());
-            for (struct_obj.field_types.get(ip), 0..) |field_ty_ip, field_idx| {
-                if (struct_obj.field_is_comptime_bits.get(ip, field_idx)) continue;
-                const field_ty: Type = .fromInterned(field_ty_ip);
-                if (field_ty.hasRuntimeBits(zcu)) return true;
+            switch (struct_obj.layout) {
+                .auto, .@"extern" => return struct_obj.has_runtime_bits,
+                .@"packed" => return Type.fromInterned(struct_obj.packed_backing_int_type).hasRuntimeBits(zcu),
+            }
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            switch (union_obj.layout) {
+                .auto, .@"extern" => return union_obj.has_runtime_bits,
+                .@"packed" => return Type.fromInterned(union_obj.packed_backing_int_type).hasRuntimeBits(zcu),
             }
-            return false;
         },
         .tuple_type => |tuple| {
             for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
@@ -515,23 +520,8 @@ pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
             }
             return false;
         },
-        .union_type => {
-            // TODO MLUGG: memoize this state when resolving union?
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            switch (union_obj.runtime_tag) {
-                .none => {},
-                .safety, .tagged => {
-                    if (Type.fromInterned(union_obj.enum_tag_type).hasRuntimeBits(zcu)) return true;
-                },
-            }
-            for (union_obj.field_types.get(ip)) |field_ty_ip| {
-                const field_ty: Type = .fromInterned(field_ty_ip);
-                if (field_ty.hasRuntimeBits(zcu)) return true;
-            }
-            return false;
-        },
 
-        // MLUGG TODO: i think this can go away and the assert move to the defer?
+        // MLUGG TODO: this answer was already here but... does it actually make sense?
         .opaque_type => true,
         .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).hasRuntimeBits(zcu),
 
@@ -618,17 +608,18 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
             .generic_poison,
             => false,
         },
-        .struct_type => ip.loadStructType(ty.toIntern()).layout != .auto,
-        .union_type => {
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            if (union_obj.layout == .auto) return false;
-            return switch (union_obj.runtime_tag) {
-                .none => true,
-                .tagged => false,
-                .safety => unreachable, // well-defined layout can't have a safety tag
-            };
+        .struct_type => switch (ip.loadStructType(ty.toIntern()).layout) {
+            .auto => false,
+            .@"extern", .@"packed" => true,
+        },
+        .union_type => switch (ip.loadUnionType(ty.toIntern()).layout) {
+            .auto => false,
+            .@"extern", .@"packed" => true,
+        },
+        .enum_type => switch (ip.loadEnumType(ty.toIntern()).int_tag_mode) {
+            .explicit => true,
+            .auto => false,
         },
-        .enum_type => ip.loadEnumType(ty.toIntern()).int_tag_is_explicit,
 
         // values, not types
         .undef,
@@ -664,28 +655,29 @@ pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *Zcu) bool {
         if (param_ty == .generic_poison_type) return false;
         if (Type.fromInterned(param_ty).comptimeOnly(zcu)) return false;
     }
+    const ret_ty: Type = .fromInterned(fn_info.return_type);
+    if (ret_ty.toIntern() == .generic_poison_type) {
+        return false;
+    }
+    if (ret_ty.zigTypeTag(zcu) == .error_union and
+        ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type)
+    {
+        return false;
+    }
     if (fn_info.return_type == .generic_poison_type) return false;
     if (Type.fromInterned(fn_info.return_type).comptimeOnly(zcu)) return false;
     if (fn_info.cc == .@"inline") return false;
     return true;
 }
 
-pub fn isFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
+/// Like `hasRuntimeBits`, but also returns `true` for runtime functions.
+pub fn isRuntimeFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
     switch (ty.zigTypeTag(zcu)) {
         .@"fn" => return ty.fnHasRuntimeBits(zcu),
         else => return ty.hasRuntimeBits(zcu),
     }
 }
 
-/// Same as `isFnOrHasRuntimeBits` but comptime-only types may return a false positive.
-/// MLUGG TODO: this function is a bit silly now...
-pub fn isFnOrHasRuntimeBitsIgnoreComptime(ty: Type, zcu: *Zcu) bool {
-    return switch (ty.zigTypeTag(zcu)) {
-        .@"fn" => true,
-        else => return ty.hasRuntimeBits(zcu),
-    };
-}
-
 pub fn isNoReturn(ty: Type, zcu: *const Zcu) bool {
     return zcu.intern_pool.isNoReturn(ty.toIntern());
 }
@@ -711,7 +703,6 @@ pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace {
 }
 
 /// Never returns `none`. Asserts that all necessary type resolution is already done.
-/// MLUGG TODO:  check that it really does never return `.none`
 pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
     const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
@@ -810,7 +801,7 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
             for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
                 if (val != .none) continue; // comptime field
                 const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
-                big_align = big_align.max(field_align);
+                big_align = big_align.maxStrict(field_align);
             }
             return big_align;
         },
@@ -818,14 +809,20 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
             const struct_obj = ip.loadStructType(ty.toIntern());
             switch (struct_obj.layout) {
                 .@"packed" => return Type.fromInterned(struct_obj.packed_backing_int_type).abiAlignment(zcu),
-                .auto, .@"extern" => return struct_obj.alignment,
+                .auto, .@"extern" => {
+                    assert(struct_obj.alignment != .none);
+                    return struct_obj.alignment;
+                },
             }
         },
         .union_type => {
             const union_obj = ip.loadUnionType(ty.toIntern());
             switch (union_obj.layout) {
                 .@"packed" => return Type.fromInterned(union_obj.packed_backing_int_type).abiAlignment(zcu),
-                .auto, .@"extern" => return getUnionLayout(union_obj, zcu).abi_align,
+                .auto, .@"extern" => {
+                    assert(union_obj.alignment != .none);
+                    return union_obj.alignment;
+                },
             }
         },
         .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).abiAlignment(zcu),
@@ -1277,38 +1274,17 @@ pub fn nullablePtrElem(ty: Type, zcu: *const Zcu) Type {
     }
 }
 
-/// Given that `ty` is an indexable pointer, returns its element type. Specifically:
-/// * for `*[n]T`, returns `T`
-/// * for `*@Vector(n, T)`, returns `T`
-/// * for `[]T`, returns `T`
-/// * for `[*]T`, returns `T`
-/// * for `[*c]T`, returns `T`
+/// Asserts that `ty` is an indexable type, and returns its element type. Tuples (and pointers to
+/// tuples) are not supported because they do not have a single element type.
 ///
-/// Tuples are not supported because they do not have a single element type.
-///
-/// MLUGG TODO: should i even have this one? it's a subset of indexableElem
-pub fn indexablePtrElem(ty: Type, zcu: *const Zcu) Type {
-    const ip = &zcu.intern_pool;
-    const ptr_type = ip.indexToKey(ty.toIntern()).ptr_type;
-    return switch (ptr_type.flags.size) {
-        .many, .slice, .c => return .fromInterned(ptr_type.child),
-        .one => switch (ip.indexToKey(ptr_type.child)) {
-            inline .array_type, .vector_type => |arr| return .fromInterned(arr.child),
-            else => unreachable,
-        },
-    };
-}
-
-/// Given that `ty` is an indexable type, returns its element type. Specifically:
-/// * for `[n]T`, returns `T`
-/// * for `@Vector(n, T)`, returns `T`
-/// * for `*[n]T`, returns `T`
-/// * for `*@Vector(n, T)`, returns `T`
-/// * for `[]T`, returns `T`
-/// * for `[*]T`, returns `T`
-/// * for `[*c]T`, returns `T`
-///
-/// Tuples are not supported because they do not have a single element type.
+/// Returns `T` for each of the following types:
+/// * `[n]T`
+/// * `@Vector(n, T)`
+/// * `*[n]T`
+/// * `*@Vector(n, T)`
+/// * `[]T`
+/// * `[*]T`
+/// * `[*c]T`
 pub fn indexableElem(ty: Type, zcu: *const Zcu) Type {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
@@ -1348,6 +1324,7 @@ pub fn optionalChild(ty: Type, zcu: *const Zcu) Type {
 /// Returns the tag type of a union, if the type is a union and it has a tag type.
 /// Otherwise, returns `null`.
 pub fn unionTagType(ty: Type, zcu: *const Zcu) ?Type {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     switch (ip.indexToKey(ty.toIntern())) {
         .union_type => {},
@@ -1363,6 +1340,7 @@ pub fn unionTagType(ty: Type, zcu: *const Zcu) ?Type {
 /// Same as `unionTagType` but includes safety tag.
 /// Codegen should use this version.
 pub fn unionTagTypeSafety(ty: Type, zcu: *const Zcu) ?Type {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
         .union_type => {
@@ -1377,11 +1355,13 @@ pub fn unionTagTypeSafety(ty: Type, zcu: *const Zcu) ?Type {
 /// Asserts the type is a union; returns the tag type, even if the tag will
 /// not be stored at runtime.
 pub fn unionTagTypeHypothetical(ty: Type, zcu: *const Zcu) Type {
+    assertHasLayout(ty, zcu);
     const union_obj = zcu.typeToUnion(ty).?;
     return Type.fromInterned(union_obj.enum_tag_type);
 }
 
 pub fn unionFieldType(ty: Type, enum_tag: Value, zcu: *const Zcu) ?Type {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     const union_obj = zcu.typeToUnion(ty).?;
     const union_fields = union_obj.field_types.get(ip);
@@ -1390,17 +1370,20 @@ pub fn unionFieldType(ty: Type, enum_tag: Value, zcu: *const Zcu) ?Type {
 }
 
 pub fn unionFieldTypeByIndex(ty: Type, index: usize, zcu: *const Zcu) Type {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     const union_obj = zcu.typeToUnion(ty).?;
     return Type.fromInterned(union_obj.field_types.get(ip)[index]);
 }
 
 pub fn unionTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
+    assertHasLayout(ty, zcu);
     const union_obj = zcu.typeToUnion(ty).?;
     return zcu.unionTagFieldIndex(union_obj, enum_tag);
 }
 
 pub fn unionHasAllZeroBitFieldTypes(ty: Type, zcu: *Zcu) bool {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     const union_obj = zcu.typeToUnion(ty).?;
     for (union_obj.field_types.get(ip)) |field_ty| {
@@ -1413,14 +1396,17 @@ pub fn unionHasAllZeroBitFieldTypes(ty: Type, zcu: *Zcu) bool {
 /// Asserts the type is either an extern or packed union.
 pub fn unionBackingType(ty: Type, pt: Zcu.PerThread) !Type {
     const zcu = pt.zcu;
-    return switch (ty.containerLayout(zcu)) {
+    assertHasLayout(ty, zcu);
+    const loaded_union = zcu.intern_pool.loadUnionType(ty.toIntern());
+    return switch (loaded_union.layout) {
         .@"extern" => try pt.arrayType(.{ .len = ty.abiSize(zcu), .child = .u8_type }),
-        .@"packed" => try pt.intType(.unsigned, @intCast(ty.bitSize(zcu))),
+        .@"packed" => .fromInterned(loaded_union.packed_backing_int_type),
         .auto => unreachable,
     };
 }
 
 pub fn unionGetLayout(ty: Type, zcu: *const Zcu) Zcu.UnionLayout {
+    assertHasLayout(ty, zcu);
     const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
     return Type.getUnionLayout(union_obj, zcu);
 }
@@ -1865,11 +1851,8 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
                 for (field_vals, 0..) |*field_val, i_usize| {
                     const i: u32 = @intCast(i_usize);
                     if (struct_obj.field_is_comptime_bits.get(ip, i)) {
-                        // MLUGG TODO: this is kinda a problem... we don't necessarily know the opv field vals!
-                        // for now i'm just not letting structs with comptime fields be opv :)
-                        if (true) return null;
-                        assertHasInits(ty, zcu);
                         field_val.* = struct_obj.field_defaults.get(ip)[i];
+                        assert(field_val.* != .none);
                         continue;
                     }
                     const field_ty = Type.fromInterned(struct_obj.field_types.get(ip)[i]);
@@ -2257,19 +2240,23 @@ pub fn errorSetNames(ty: Type, zcu: *const Zcu) InternPool.NullTerminatedString.
 }
 
 pub fn enumFields(ty: Type, zcu: *const Zcu) InternPool.NullTerminatedString.Slice {
+    assertHasLayout(ty, zcu);
     return zcu.intern_pool.loadEnumType(ty.toIntern()).field_names;
 }
 
 pub fn enumFieldCount(ty: Type, zcu: *const Zcu) usize {
+    assertHasLayout(ty, zcu);
     return zcu.intern_pool.loadEnumType(ty.toIntern()).field_names.len;
 }
 
 pub fn enumFieldName(ty: Type, field_index: usize, zcu: *const Zcu) InternPool.NullTerminatedString {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     return ip.loadEnumType(ty.toIntern()).field_names.get(ip)[field_index];
 }
 
 pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, zcu: *const Zcu) ?u32 {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     const enum_type = ip.loadEnumType(ty.toIntern());
     return enum_type.nameIndex(ip, field_name);
@@ -2279,6 +2266,7 @@ pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, zcu
 /// an integer which represents the enum value. Returns the field index in
 /// declaration order, or `null` if `enum_tag` does not match any field.
 pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
+    assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
     const enum_type = ip.loadEnumType(ty.toIntern());
     const int_tag = switch (ip.indexToKey(enum_tag.toIntern())) {
@@ -2293,28 +2281,40 @@ pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
 /// Returns none in the case of a tuple which uses the integer index as the field name.
 pub fn structFieldName(ty: Type, index: usize, zcu: *const Zcu) InternPool.OptionalNullTerminatedString {
     const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).field_names.get(ip)[index].toOptional(),
-        .tuple_type => .none,
+    switch (ip.indexToKey(ty.toIntern())) {
+        .struct_type => {
+            assertHasLayout(ty, zcu);
+            return ip.loadStructType(ty.toIntern()).field_names.get(ip)[index].toOptional();
+        },
+        .tuple_type => return .none,
         else => unreachable,
-    };
+    }
 }
 
 pub fn structFieldCount(ty: Type, zcu: *const Zcu) u32 {
     const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).field_types.len,
-        .tuple_type => |tuple| tuple.types.len,
+    switch (ip.indexToKey(ty.toIntern())) {
+        .struct_type => {
+            assertHasLayout(ty, zcu);
+            return ip.loadStructType(ty.toIntern()).field_types.len;
+        },
+        .tuple_type => |tuple| return tuple.types.len,
         else => unreachable,
-    };
+    }
 }
 
 /// Returns the field type. Supports structs and unions.
 pub fn fieldType(ty: Type, index: usize, zcu: *const Zcu) Type {
     const ip = &zcu.intern_pool;
     const types = switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).field_types,
-        .union_type => ip.loadUnionType(ty.toIntern()).field_types,
+        .struct_type => types: {
+            assertHasLayout(ty, zcu);
+            break :types ip.loadStructType(ty.toIntern()).field_types;
+        },
+        .union_type => types: {
+            assertHasLayout(ty, zcu);
+            break :types ip.loadUnionType(ty.toIntern()).field_types;
+        },
         .tuple_type => |tuple| tuple.types,
         else => unreachable,
     };
@@ -2335,11 +2335,13 @@ pub fn resolvedFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment
     return switch (ip.indexToKey(ty.toIntern())) {
         .tuple_type => |tuple| Type.fromInterned(tuple.types.get(ip)[index]).abiAlignment(zcu),
         .struct_type => {
+            assertHasLayout(ty, zcu);
             const struct_obj = ip.loadStructType(ty.toIntern());
             const field_ty: Type = .fromInterned(struct_obj.field_types.get(ip)[index]);
             return field_ty.defaultStructFieldAlignment(struct_obj.layout, zcu);
         },
         .union_type => {
+            assertHasLayout(ty, zcu);
             const union_obj = ip.loadUnionType(ty.toIntern());
             const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[index]);
             return field_ty.abiAlignment(zcu);
@@ -2353,12 +2355,14 @@ pub fn explicitFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment
     return switch (ip.indexToKey(ty.toIntern())) {
         .tuple_type => .none,
         .struct_type => {
+            assertHasLayout(ty, zcu);
             const struct_obj = ip.loadStructType(ty.toIntern());
             assert(struct_obj.layout != .@"packed");
             if (struct_obj.field_aligns.len == 0) return .none;
             return struct_obj.field_aligns.get(ip)[index];
         },
         .union_type => {
+            assertHasLayout(ty, zcu);
             const union_obj = ip.loadUnionType(ty.toIntern());
             assert(union_obj.layout != .@"packed");
             if (union_obj.field_aligns.len == 0) return .none;
@@ -2413,7 +2417,6 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
         .struct_type => {
             const struct_type = ip.loadStructType(ty.toIntern());
             if (struct_type.field_is_comptime_bits.get(ip, index)) {
-                assertHasInits(ty, zcu);
                 return .fromInterned(struct_type.field_defaults.get(ip)[index]);
             } else {
                 return Type.fromInterned(struct_type.field_types.get(ip)[index]).onePossibleValue(pt);
@@ -2433,11 +2436,14 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
 
 pub fn structFieldIsComptime(ty: Type, index: usize, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).field_is_comptime_bits.get(ip, index),
-        .tuple_type => |tuple| tuple.values.get(ip)[index] != .none,
+    switch (ip.indexToKey(ty.toIntern())) {
+        .struct_type => {
+            assertHasLayout(ty, zcu);
+            return ip.loadStructType(ty.toIntern()).field_is_comptime_bits.get(ip, index);
+        },
+        .tuple_type => |tuple| return tuple.values.get(ip)[index] != .none,
         else => unreachable,
-    };
+    }
 }
 
 pub const FieldOffset = struct {
@@ -2850,34 +2856,166 @@ pub fn isNullFromType(ty: Type, zcu: *const Zcu) ?bool {
     return null;
 }
 
-/// Returns true if `ty` is allowed in packed types.
-pub fn packable(ty: Type, zcu: *const Zcu) bool {
+pub const UnpackableReason = union(enum) {
+    comptime_only,
+    pointer,
+    enum_inferred_int_tag: Type,
+    non_packed_struct: Type,
+    non_packed_union: Type,
+    other,
+};
+
+/// Returns `null` iff `ty` is allowed in packed types.
+pub fn unpackable(ty: Type, zcu: *const Zcu) ?UnpackableReason {
     return switch (ty.zigTypeTag(zcu)) {
+        .void,
+        .bool,
+        .float,
+        .int,
+        => null,
+
         .type,
         .comptime_float,
         .comptime_int,
         .enum_literal,
         .undefined,
         .null,
+        => .comptime_only,
+
+        .noreturn,
+        .@"opaque",
         .error_union,
         .error_set,
         .frame,
-        .noreturn,
-        .@"opaque",
         .@"anyframe",
         .@"fn",
         .array,
-        => false,
-        .optional => return ty.isPtrLikeOptional(zcu),
-        .void,
-        .bool,
-        .float,
-        .int,
         .vector,
+        => .other,
+
+        .optional => if (ty.isPtrLikeOptional(zcu))
+            .pointer
+        else
+            .other,
+
+        .pointer => .pointer,
+
+        .@"enum" => switch (zcu.intern_pool.loadEnumType(ty.toIntern()).int_tag_mode) {
+            .explicit => null,
+            .auto => .{ .enum_inferred_int_tag = ty },
+        },
+
+        .@"struct" => switch (ty.containerLayout(zcu)) {
+            .@"packed" => null,
+            .auto, .@"extern" => .{ .non_packed_struct = ty },
+        },
+        .@"union" => switch (ty.containerLayout(zcu)) {
+            .@"packed" => null,
+            .auto, .@"extern" => .{ .non_packed_union = ty },
+        },
+    };
+}
+
+pub const ExternPosition = enum {
+    ret_ty,
+    param_ty,
+    union_field,
+    struct_field,
+    element,
+    other,
+};
+
+/// Returns true if `ty` is allowed in extern types.
+/// Does not require `ty` to be resolved in any way.
+/// Keep in sync with `Sema.explainWhyTypeIsNotExtern`.
+pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool {
+    return switch (ty.zigTypeTag(zcu)) {
+        .type,
+        .comptime_float,
+        .comptime_int,
+        .enum_literal,
+        .undefined,
+        .null,
+        .error_union,
+        .error_set,
+        .frame,
+        => false,
+
+        .void => switch (position) {
+            .ret_ty,
+            .union_field,
+            .struct_field,
+            .element,
+            => true,
+            .param_ty,
+            .other,
+            => false,
+        },
+
+        .noreturn => position == .ret_ty,
+
+        .@"opaque",
+        .bool,
+        .float,
+        .@"anyframe",
         => true,
-        .@"enum" => zcu.intern_pool.loadEnumType(ty.toIntern()).int_tag_is_explicit,
-        .pointer => !ty.isSlice(zcu),
-        .@"struct", .@"union" => ty.containerLayout(zcu) == .@"packed",
+
+        .pointer => {
+            if (ty.isSlice(zcu)) return false;
+            const child_ty = ty.childType(zcu);
+            if (child_ty.zigTypeTag(zcu) == .@"fn") {
+                return ty.isConstPtr(zcu) and child_ty.validateExtern(.other, zcu);
+            }
+            return true;
+        },
+        .int => switch (ty.intInfo(zcu).bits) {
+            0, 8, 16, 32, 64, 128 => true,
+            else => false,
+        },
+        .@"fn" => {
+            if (position != .other) return false;
+            // For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI.
+            // The goal is to experiment with more integrated CPU/GPU code.
+            if (ty.fnCallingConvention(zcu) == .nvptx_kernel) {
+                return true;
+            }
+            return !target_util.fnCallConvAllowsZigTypes(ty.fnCallingConvention(zcu));
+        },
+        .@"enum" => {
+            const enum_obj = zcu.intern_pool.loadEnumType(ty.toIntern());
+            return switch (enum_obj.int_tag_mode) {
+                .auto => false,
+                .explicit => Type.fromInterned(enum_obj.int_tag_type).validateExtern(position, zcu),
+            };
+        },
+        .@"struct" => {
+            const struct_obj = zcu.intern_pool.loadStructType(ty.toIntern());
+            return switch (struct_obj.layout) {
+                .auto => false,
+                .@"extern" => true,
+                .@"packed" => switch (struct_obj.packed_backing_mode) {
+                    .auto => false,
+                    .explicit => Type.fromInterned(struct_obj.packed_backing_int_type).validateExtern(position, zcu),
+                },
+            };
+        },
+        .@"union" => {
+            const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
+            return switch (union_obj.layout) {
+                .auto => false,
+                .@"extern" => true,
+                .@"packed" => switch (union_obj.packed_backing_mode) {
+                    .auto => false,
+                    .explicit => Type.fromInterned(union_obj.packed_backing_int_type).validateExtern(position, zcu),
+                },
+            };
+        },
+        .array => {
+            if (position == .ret_ty or position == .param_ty) return false;
+            return ty.childType(zcu).validateExtern(.element, zcu);
+        },
+        .vector => ty.childType(zcu).validateExtern(.element, zcu),
+        .optional => ty.isPtrLikeOptional(zcu),
     };
 }
 
@@ -2889,7 +3027,6 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         .anyframe_type,
         .simple_type,
         .opaque_type,
-        .enum_type,
         .error_set_type,
         .inferred_error_set_type,
         => {},
@@ -2906,12 +3043,11 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         .tuple_type => |tuple| for (tuple.types.get(&zcu.intern_pool)) |field_ty| {
             assertHasLayout(.fromInterned(field_ty), zcu);
         },
-        .struct_type, .union_type => {
+        .struct_type, .union_type, .enum_type => {
             const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
             assert(!zcu.outdated.contains(unit));
             assert(!zcu.potentially_outdated.contains(unit));
         },
-        else => unreachable, // assertion failure; not a struct or union
 
         // values, not types
         .simple_value,
@@ -2930,23 +3066,13 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         .opt,
         .aggregate,
         .un,
+        .undef,
         // memoization, not types
         .memoized_call,
         => unreachable,
     }
 }
 
-/// Asserts that `ty` is an enum or struct type whose field values/defaults are resolved.
-pub fn assertHasInits(ty: Type, zcu: *const Zcu) void {
-    switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .struct_type, .enum_type => {},
-        else => unreachable,
-    }
-    const unit: InternPool.AnalUnit = .wrap(.{ .type_inits = ty.toIntern() });
-    assert(!zcu.outdated.contains(unit));
-    assert(!zcu.potentially_outdated.contains(unit));
-}
-
 /// Recursively walks the type and marks for each subtype how many times it has been seen
 fn collectSubtypes(ty: Type, pt: Zcu.PerThread, visited: *std.AutoArrayHashMapUnmanaged(Type, u16)) error{OutOfMemory}!void {
     const zcu = pt.zcu;
@@ -3116,6 +3242,7 @@ pub const Comparison = struct {
     };
 };
 
+pub const @"u0": Type = .{ .ip_index = .u0_type };
 pub const @"u1": Type = .{ .ip_index = .u1_type };
 pub const @"u8": Type = .{ .ip_index = .u8_type };
 pub const @"u16": Type = .{ .ip_index = .u16_type };
diff --git a/src/Value.zig b/src/Value.zig
index 5986eee6d652b135fd2b28bfc2f839bdd578486e..ca9ef9604627beb12c9014b9372f42eb1aac538a 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -2207,7 +2207,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
 
     const ptr_ty_info = Type.fromInterned(ptr.ty).ptrInfo(zcu);
     const need_child: Type = .fromInterned(ptr_ty_info.child);
-    if (need_child.comptimeOnly(zcu)) {
+    if (need_child.comptimeOnly(zcu) or need_child.zigTypeTag(zcu) == .@"opaque") {
         // No refinement can happen - this pointer is presumably invalid.
         // Just offset it.
         const parent = try arena.create(PointerDeriveStep);
@@ -2595,8 +2595,8 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory
 pub fn doPointersOverlap(ptr_val_a: Value, ptr_val_b: Value, elem_count: u64, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
 
-    const a_elem_ty = ptr_val_a.typeOf(zcu).indexablePtrElem(zcu);
-    const b_elem_ty = ptr_val_b.typeOf(zcu).indexablePtrElem(zcu);
+    const a_elem_ty = ptr_val_a.typeOf(zcu).indexableElem(zcu);
+    const b_elem_ty = ptr_val_b.typeOf(zcu).indexableElem(zcu);
 
     const a_ptr = ip.indexToKey(ptr_val_a.toIntern()).ptr;
     const b_ptr = ip.indexToKey(ptr_val_b.toIntern()).ptr;
@@ -2682,3 +2682,58 @@ pub fn eqlScalarNum(lhs: Value, rhs: Value, zcu: *Zcu) bool {
     const rhs_bigint = rhs.toBigInt(&rhs_bigint_space, zcu);
     return lhs_bigint.eql(rhs_bigint);
 }
+
+/// Asserts the value is an integer, and the destination type is ComptimeInt or Int.
+/// Vectors are also accepted. Vector results are reduced with AND.
+///
+/// If provided, `vector_index` reports the first element that failed the range check.
+pub fn intFitsInType(
+    val: Value,
+    ty: Type,
+    vector_index: ?*usize,
+    zcu: *const Zcu,
+) bool {
+    if (ty.toIntern() == .comptime_int_type) return true;
+    const info = ty.intInfo(zcu);
+    switch (val.toIntern()) {
+        .zero_usize, .zero_u8 => return true,
+        else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
+            .undef => return true,
+            .variable, .@"extern", .func, .ptr => {
+                const target = zcu.getTarget();
+                const ptr_bits = target.ptrBitWidth();
+                return switch (info.signedness) {
+                    .signed => info.bits > ptr_bits,
+                    .unsigned => info.bits >= ptr_bits,
+                };
+            },
+            .int => |int| {
+                var buffer: InternPool.Key.Int.Storage.BigIntSpace = undefined;
+                const big_int = int.storage.toBigInt(&buffer);
+                return big_int.fitsInTwosComp(info.signedness, info.bits);
+            },
+            .aggregate => |aggregate| {
+                assert(ty.zigTypeTag(zcu) == .vector);
+                return switch (aggregate.storage) {
+                    .bytes => |bytes| for (bytes.toSlice(ty.vectorLen(zcu), &zcu.intern_pool), 0..) |byte, i| {
+                        if (byte == 0) continue;
+                        const actual_needed_bits = std.math.log2(byte) + 1 + @intFromBool(info.signedness == .signed);
+                        if (info.bits >= actual_needed_bits) continue;
+                        if (vector_index) |vi| vi.* = i;
+                        break false;
+                    } else true,
+                    .elems, .repeated_elem => for (switch (aggregate.storage) {
+                        .bytes => unreachable,
+                        .elems => |elems| elems,
+                        .repeated_elem => |elem| @as(*const [1]InternPool.Index, &elem),
+                    }, 0..) |elem, i| {
+                        if (Value.fromInterned(elem).intFitsInType(ty.scalarType(zcu), null, zcu)) continue;
+                        if (vector_index) |vi| vi.* = i;
+                        break false;
+                    } else true,
+                };
+            },
+            else => unreachable,
+        },
+    }
+}
diff --git a/src/Zcu.zig b/src/Zcu.zig
index e1760fecb95c1871ca3229becbebc6d224e4173a..5aef6a11d17d13d43176c782d53b3de4287bc2af 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -1912,40 +1912,6 @@ pub const SrcLoc = struct {
                 const full = tree.fullPtrType(parent_node).?;
                 return tree.nodeToSpan(full.ast.bit_range_end.unwrap().?);
             },
-            .node_offset_container_tag => |node_off| {
-                const tree = try src_loc.file_scope.getTree(zcu);
-                const parent_node = node_off.toAbsolute(src_loc.base_node);
-
-                switch (tree.nodeTag(parent_node)) {
-                    .container_decl_arg, .container_decl_arg_trailing => {
-                        const full = tree.containerDeclArg(parent_node);
-                        const arg_node = full.ast.arg.unwrap().?;
-                        return tree.nodeToSpan(arg_node);
-                    },
-                    .tagged_union_enum_tag, .tagged_union_enum_tag_trailing => {
-                        const full = tree.taggedUnionEnumTag(parent_node);
-                        const arg_node = full.ast.arg.unwrap().?;
-
-                        return tree.tokensToSpan(
-                            tree.firstToken(arg_node) - 2,
-                            tree.lastToken(arg_node) + 1,
-                            tree.nodeMainToken(arg_node),
-                        );
-                    },
-                    else => unreachable,
-                }
-            },
-            .node_offset_field_default => |node_off| {
-                const tree = try src_loc.file_scope.getTree(zcu);
-                const parent_node = node_off.toAbsolute(src_loc.base_node);
-
-                const full: Ast.full.ContainerField = switch (tree.nodeTag(parent_node)) {
-                    .container_field => tree.containerField(parent_node),
-                    .container_field_init => tree.containerFieldInit(parent_node),
-                    else => unreachable,
-                };
-                return tree.nodeToSpan(full.ast.value_expr.unwrap().?);
-            },
             .node_offset_init_ty => |node_off| {
                 const tree = try src_loc.file_scope.getTree(zcu);
                 const parent_node = node_off.toAbsolute(src_loc.base_node);
@@ -2021,6 +1987,14 @@ pub const SrcLoc = struct {
                 }
                 return tree.nodeToSpan(node);
             },
+            .container_arg => {
+                const tree = try src_loc.file_scope.getTree(zcu);
+                const node = src_loc.base_node;
+                var buf: [2]Ast.Node.Index = undefined;
+                const container_decl = tree.fullContainerDecl(&buf, node) orelse return tree.nodeToSpan(node);
+                const arg_node = container_decl.ast.arg.unwrap() orelse return tree.nodeToSpan(node);
+                return tree.nodeToSpan(arg_node);
+            },
             .container_field_name,
             .container_field_value,
             .container_field_type,
@@ -2262,7 +2236,11 @@ pub const SrcLoc = struct {
                 var param_it = full.iterate(tree);
                 for (0..param_idx) |_| assert(param_it.next() != null);
                 const param = param_it.next().?;
-                return tree.nodeToSpan(param.type_expr.?);
+                if (param.anytype_ellipsis3) |tok| {
+                    return tree.tokenToSpan(tok);
+                } else {
+                    return tree.nodeToSpan(param.type_expr.?);
+                }
             },
         }
     }
@@ -2484,10 +2462,6 @@ pub const LazySrcLoc = struct {
         node_offset_ptr_bitoffset: Ast.Node.Offset,
         /// The source location points to the host size of a pointer.
         node_offset_ptr_hostsize: Ast.Node.Offset,
-        /// The source location points to the tag type of an union or an enum.
-        node_offset_container_tag: Ast.Node.Offset,
-        /// The source location points to the default value of a field.
-        node_offset_field_default: Ast.Node.Offset,
         /// The source location points to the type of an array or struct initializer.
         node_offset_init_ty: Ast.Node.Offset,
         /// The source location points to the LHS of an assignment (or assign-op, e.g. `+=`).
@@ -2532,6 +2506,11 @@ pub const LazySrcLoc = struct {
         fn_proto_param_type: FnProtoParam,
         array_cat_lhs: ArrayCat,
         array_cat_rhs: ArrayCat,
+        /// The source location points to the backing or tag type expression of
+        /// the container type declaration at the base node.
+        ///
+        /// For 'union(enum(T))', this points to 'T', not 'enum(T)'.
+        container_arg,
         /// The source location points to the name of the field at the given index
         /// of the container type declaration at the base node.
         container_field_name: u32,
@@ -3149,7 +3128,7 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
             .nav_val => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_val = nav }),
             .nav_ty => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_ty = nav }),
             .type_layout => |ty| try zcu.markPoDependeeUpToDate(.{ .type_layout = ty }),
-            .type_inits => |ty| try zcu.markPoDependeeUpToDate(.{ .type_inits = ty }),
+            .struct_defaults => |ty| try zcu.markPoDependeeUpToDate(.{ .struct_defaults = ty }),
             .func => |func| try zcu.markPoDependeeUpToDate(.{ .func_ies = func }),
             .memoized_state => |stage| try zcu.markPoDependeeUpToDate(.{ .memoized_state = stage }),
         }
@@ -3165,7 +3144,7 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
         .nav_val => |nav| .{ .nav_val = nav },
         .nav_ty => |nav| .{ .nav_ty = nav },
         .type_layout => |ty| .{ .type_layout = ty },
-        .type_inits => |ty| .{ .type_inits = ty },
+        .struct_defaults => |ty| .{ .struct_defaults = ty },
         .func => |func_index| .{ .func_ies = func_index },
         .memoized_state => |stage| .{ .memoized_state = stage },
     };
@@ -3195,88 +3174,44 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
     }
 }
 
+/// Selects an outdated `AnalUnit` to analyze next. Called from the main semantic analysis loop when
+/// there is no work immediately queued. The unit is chosen such that it is unlikely to require any
+/// recursive analysis (all of its previously-marked dependencies are already up-to-date), because
+/// recursive analysis can cause over-analysis on incremental updates.
 pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
     if (!zcu.comp.config.incremental) return null;
 
-    if (zcu.outdated.count() == 0) {
-        // Any units in `potentially_outdated` must just be stuck in loops with one another: none of those
-        // units have had any outdated dependencies so far, and all of their remaining PO deps are triggered
-        // by other units in `potentially_outdated`. So, we can safety assume those units up-to-date.
-        zcu.potentially_outdated.clearRetainingCapacity();
-        log.debug("findOutdatedToAnalyze: no outdated depender", .{});
-        return null;
-    }
-
-    // Our goal is to find an outdated AnalUnit which itself has no outdated or
-    // PO dependencies. Most of the time, such an AnalUnit will exist - we track
-    // them in the `outdated_ready` set for efficiency. However, this is not
-    // necessarily the case, since the Decl dependency graph may contain loops
-    // via mutually recursive definitions:
-    //   pub const A = struct { b: *B };
-    //   pub const B = struct { b: *A };
-    // In this case, we must defer to more complex logic below.
-
     if (zcu.outdated_ready.count() > 0) {
         const unit = zcu.outdated_ready.keys()[0];
-        log.debug("findOutdatedToAnalyze: trivial {f}", .{zcu.fmtAnalUnit(unit)});
+        log.debug("findOutdatedToAnalyze: {f}", .{zcu.fmtAnalUnit(unit)});
         return unit;
     }
 
-    // There is no single AnalUnit which is ready for re-analysis. Instead, we must assume that some
-    // AnalUnit with PO dependencies is outdated -- e.g. in the above example we arbitrarily pick one of
-    // A or B. We should definitely not select a function, since a function can't be responsible for the
-    // loop (IES dependencies can't have loops). We should also, of course, not select a `comptime`
-    // declaration, since you can't depend on those!
+    // Usually, getting here means that everything is up-to-date, so there is no more work to do. We
+    // will see that `zcu.outdated` and `zcu.potentially_outdated` are both empty.
+    //
+    // However, if a previous update had a dependency loop compile error, there is a cycle in the
+    // dependency graph (which is usually acyclic), which can cause a scenario where no unit appears
+    // to be ready, because they're all waiting for the next in the loop to be up-to-date. In that
+    // case, we usually have to just bite the bullet and analyze one of them. An exception is if
+    // `zcu.outdated` is empty but `zcu.potentially_outdated` is non-empty: in that case, the only
+    // possible situation is a cycle where everything is actually up-to-date, so we can clear out
+    // `zcu.potentially_outdated` and we are done.
 
-    // The choice of this unit could have a big impact on how much total analysis we perform, since
-    // if analysis concludes any dependencies on its result are up-to-date, then other PO AnalUnit
-    // may be resolved as up-to-date. To hopefully avoid doing too much work, let's find a unit
-    // which the most things depend on - the idea is that this will resolve a lot of loops (but this
-    // is only a heuristic).
+    if (zcu.outdated.count() == 0) {
+        // Everything is up-to-date. There could be lingering entries in `zcu.potentially_outdated`
+        // from a dependency loop on a previous update.
+        zcu.potentially_outdated.clearRetainingCapacity();
+        log.debug("findOutdatedToAnalyze: all up-to-date", .{});
+        return null;
+    }
 
-    log.debug("findOutdatedToAnalyze: no trivial ready, using heuristic; {d} outdated, {d} PO", .{
+    const unit = zcu.outdated.keys()[0];
+    log.debug("findOutdatedToAnalyze: dependency loop affecting {d} units, selected {f}", .{
         zcu.outdated.count(),
-        zcu.potentially_outdated.count(),
+        zcu.fmtAnalUnit(unit),
     });
-
-    const ip = &zcu.intern_pool;
-
-    var chosen_unit: ?AnalUnit = null;
-    var chosen_unit_dependers: u32 = undefined;
-
-    // MLUGG TODO: i'm 99% sure this is now impossible. check!!!
-    inline for (.{ zcu.outdated.keys(), zcu.potentially_outdated.keys() }) |outdated_units| {
-        for (outdated_units) |unit| {
-            var n: u32 = 0;
-            var it = ip.dependencyIterator(switch (unit.unwrap()) {
-                .func => continue, // a `func` definitely can't be causing the loop so it is a bad choice
-                .@"comptime" => continue, // a `comptime` block can't even be depended on so it is a terrible choice
-                .type_layout => |ty| .{ .type_layout = ty },
-                .type_inits => |ty| .{ .type_inits = ty },
-                .nav_val => |nav| .{ .nav_val = nav },
-                .nav_ty => |nav| .{ .nav_ty = nav },
-                .memoized_state => {
-                    // If we've hit a loop and some `.memoized_state` is outdated, we should make that choice eagerly.
-                    // In general, it's good to resolve this early on, since -- for instance -- almost every function
-                    // references the panic handler.
-                    return unit;
-                },
-            });
-            while (it.next()) |_| n += 1;
-
-            if (chosen_unit == null or n > chosen_unit_dependers) {
-                chosen_unit = unit;
-                chosen_unit_dependers = n;
-            }
-        }
-    }
-
-    log.debug("findOutdatedToAnalyze: heuristic returned '{f}' ({d} dependers)", .{
-        zcu.fmtAnalUnit(chosen_unit.?),
-        chosen_unit_dependers,
-    });
-
-    return chosen_unit.?;
+    return unit;
 }
 
 /// During an incremental update, before semantic analysis, call this to flush all values from
@@ -3356,12 +3291,59 @@ pub fn mapOldZirToNew(
     }
 
     while (match_stack.pop()) |match_item| {
-        // First, a check: if the number of captures of this type has changed, we can't map it, because
-        // we wouldn't know how to correlate type information with the last update.
-        // Synchronizes with logic in `Zcu.PerThread.recreateStructType` etc.
-        if (old_zir.typeCapturesLen(match_item.old_inst) != new_zir.typeCapturesLen(match_item.new_inst)) {
-            // Don't map this type or anything within it.
-            continue;
+        // There are some properties of type declarations which cannot change across incremental
+        // updates. If they have, we need to ignore this mapping. These properties are essentially
+        // everything passed into `InternPool.getDeclaredStructType` (likewise for unions, enums,
+        // and opaques).
+        const old_tag = old_zir.instructions.items(.data)[@intFromEnum(match_item.old_inst)].extended.opcode;
+        const new_tag = new_zir.instructions.items(.data)[@intFromEnum(match_item.new_inst)].extended.opcode;
+        if (old_tag != new_tag) continue;
+        switch (old_tag) {
+            .struct_decl => {
+                const old = old_zir.getStructDecl(match_item.old_inst);
+                const new = new_zir.getStructDecl(match_item.new_inst);
+                if (old.captures.len != new.captures.len) continue;
+                if (old.field_names.len != new.field_names.len) continue;
+                if (old.layout != new.layout) continue;
+                const old_any_field_aligns = old.field_align_body_lens != null;
+                const old_any_field_defaults = old.field_default_body_lens != null;
+                const old_any_comptime_fields = old.field_comptime_bits != null;
+                const old_explicit_backing_int = old.backing_int_type_body != null;
+                const new_any_field_aligns = new.field_align_body_lens != null;
+                const new_any_field_defaults = new.field_default_body_lens != null;
+                const new_any_comptime_fields = new.field_comptime_bits != null;
+                const new_explicit_backing_int = new.backing_int_type_body != null;
+                if (old_any_field_aligns != new_any_field_aligns) continue;
+                if (old_any_field_defaults != new_any_field_defaults) continue;
+                if (old_any_comptime_fields != new_any_comptime_fields) continue;
+                if (old_explicit_backing_int != new_explicit_backing_int) continue;
+            },
+            .union_decl => {
+                const old = old_zir.getUnionDecl(match_item.old_inst);
+                const new = new_zir.getUnionDecl(match_item.new_inst);
+                if (old.captures.len != new.captures.len) continue;
+                if (old.field_names.len != new.field_names.len) continue;
+                if (old.kind != new.kind) continue;
+                const old_any_field_aligns = old.field_align_body_lens != null;
+                const new_any_field_aligns = new.field_align_body_lens != null;
+                if (old_any_field_aligns != new_any_field_aligns) continue;
+            },
+            .enum_decl => {
+                const old = old_zir.getEnumDecl(match_item.old_inst);
+                const new = new_zir.getEnumDecl(match_item.new_inst);
+                if (old.captures.len != new.captures.len) continue;
+                if (old.field_names.len != new.field_names.len) continue;
+                if (old.nonexhaustive != new.nonexhaustive) continue;
+                const old_explicit_tag_type = old.tag_type_body != null;
+                const new_explicit_tag_type = new.tag_type_body != null;
+                if (old_explicit_tag_type != new_explicit_tag_type) continue;
+            },
+            .opaque_decl => {
+                const old = old_zir.getOpaqueDecl(match_item.old_inst);
+                const new = new_zir.getOpaqueDecl(match_item.new_inst);
+                if (old.captures.len != new.captures.len) continue;
+            },
+            else => unreachable,
         }
 
         // Match the namespace declaration itself
@@ -4068,7 +4050,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
             }
             if (has_inits) {
                 // this should only be referenced by the type
-                const unit: AnalUnit = .wrap(.{ .type_inits = ty });
+                const unit: AnalUnit = .wrap(.{ .struct_defaults = ty });
                 try units.putNoClobber(gpa, unit, referencer);
             }
 
@@ -4184,7 +4166,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                 const other: AnalUnit = .wrap(switch (unit.unwrap()) {
                     .nav_val => |n| .{ .nav_ty = n },
                     .nav_ty => |n| .{ .nav_val = n },
-                    .@"comptime", .type_layout, .type_inits, .func, .memoized_state => break :queue_paired,
+                    .@"comptime", .type_layout, .struct_defaults, .func, .memoized_state => break :queue_paired,
                 });
                 const gop = try units.getOrPut(gpa, other);
                 if (gop.found_existing) break :queue_paired;
@@ -4305,6 +4287,16 @@ pub fn navFileScope(zcu: *Zcu, nav: InternPool.Nav.Index) *File {
     return zcu.fileByIndex(zcu.navFileScopeIndex(nav));
 }
 
+pub fn navAlignment(zcu: *Zcu, nav_index: InternPool.Nav.Index) InternPool.Alignment {
+    const ty: Type, const alignment = switch (zcu.intern_pool.getNav(nav_index).status) {
+        .unresolved => unreachable,
+        .type_resolved => |r| .{ .fromInterned(r.type), r.alignment },
+        .fully_resolved => |r| .{ Value.fromInterned(r.val).typeOf(zcu), r.alignment },
+    };
+    if (alignment != .none) return alignment;
+    return ty.abiAlignment(zcu);
+}
+
 pub fn fmtAnalUnit(zcu: *Zcu, unit: AnalUnit) std.fmt.Alt(FormatAnalUnit, formatAnalUnit) {
     return .{ .data = .{ .unit = unit, .zcu = zcu } };
 }
@@ -4331,7 +4323,7 @@ fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void
             }
         },
         .nav_val, .nav_ty => |nav, tag| return writer.print("{t}('{f}' [{}])", .{ tag, ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }),
-        .type_layout, .type_inits => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
+        .type_layout, .struct_defaults => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
         .func => |func| {
             const nav = zcu.funcInfo(func).owner_nav;
             return writer.print("func('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(func) });
@@ -4357,7 +4349,7 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void
             const fqn = ip.getNav(nav).fqn;
             return writer.print("{t}('{f}')", .{ tag, fqn.fmt(ip) });
         },
-        .type_layout, .type_inits => |ip_index, tag| {
+        .type_layout, .struct_defaults => |ip_index, tag| {
             const name = Type.fromInterned(ip_index).containerTypeName(ip);
             return writer.print("{t}('{f}')", .{ tag, name.fmt(ip) });
         },
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index e3c0c21244b2ae29b643bcc20b350796f27e25f8..d937367c4ac871c61e7bd285e9ddf04f7df175c7 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -695,20 +695,46 @@ pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Alloca
         .file = file_index,
         .inst = .main_struct_inst,
     });
-    const file_root_type = try Sema.analyzeStructDecl(
-        pt,
-        file_index,
-        &file.zir.?,
-        .none,
-        tracked_inst,
-        &struct_decl,
-        null,
-        &.{},
-        .{ .exact = .{
-            .name = try file.internFullyQualifiedName(pt),
-            .nav = .none,
-        } },
-    );
+    const wip: InternPool.WipContainerType = switch (try ip.getDeclaredStructType(gpa, io, pt.tid, .{
+        .zir_index = tracked_inst,
+        .captures = &.{},
+        .fields_len = @intCast(struct_decl.field_names.len),
+        .layout = struct_decl.layout,
+        .any_comptime_fields = struct_decl.field_comptime_bits != null,
+        .any_field_defaults = struct_decl.field_default_body_lens != null,
+        .any_field_aligns = struct_decl.field_align_body_lens != null,
+        .packed_backing_mode = if (struct_decl.backing_int_type_body != null) .explicit else .auto,
+    })) {
+        .existing => unreachable, // it would have been set as `zcu.fileRootType` already
+        .wip => |wip| wip,
+    };
+    errdefer wip.cancel(ip, pt.tid);
+
+    wip.setName(ip, try file.internFullyQualifiedName(pt), .none);
+    const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+        .parent = .none,
+        .owner_type = wip.index,
+        .file_scope = file_index,
+        .generation = zcu.generation,
+    });
+    errdefer pt.destroyNamespace(new_namespace_index);
+    try pt.scanNamespace(new_namespace_index, struct_decl.decls);
+    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
+    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .struct_defaults = wip.index }) });
+
+    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+
+    try zcu.outdated.ensureUnusedCapacity(gpa, 2);
+    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
+    errdefer comptime unreachable; // because we don't remove the `outdated` entries
+    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
+    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), 0);
+    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
+    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), {});
+
+    const file_root_type: Type = .fromInterned(wip.finish(ip, new_namespace_index));
+
     zcu.setFileRootType(file_index, file_root_type.toIntern());
     if (zcu.comp.time_report) |*tr| tr.stats.n_imported_files += 1;
 }
@@ -1048,11 +1074,6 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
-    // Determine whether or not this type is outdated. For this kind of `AnalUnit`, that's
-    // the only indicator as to whether or not analysis is required; when a struct/union is
-    // first created, it's marked as outdated.
-    // MLUGG TODO: make that actually true, it's a good strategy here!
-
     const was_outdated = zcu.outdated.swapRemove(anal_unit) or
         zcu.potentially_outdated.swapRemove(anal_unit);
 
@@ -1113,17 +1134,11 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
     };
     defer sema.deinit();
 
-    const result = switch (ty.containerLayout(zcu)) {
-        .auto, .@"extern" => switch (ty.zigTypeTag(zcu)) {
-            .@"struct" => Sema.type_resolution.resolveStructLayout(&sema, ty),
-            .@"union" => Sema.type_resolution.resolveUnionLayout(&sema, ty),
-            else => unreachable,
-        },
-        .@"packed" => switch (ty.zigTypeTag(zcu)) {
-            .@"struct" => Sema.type_resolution.resolvePackedStructLayout(&sema, ty),
-            .@"union" => Sema.type_resolution.resolvePackedUnionLayout(&sema, ty),
-            else => unreachable,
-        },
+    const result = switch (ty.zigTypeTag(zcu)) {
+        .@"enum" => Sema.type_resolution.resolveEnumLayout(&sema, ty),
+        .@"struct" => Sema.type_resolution.resolveStructLayout(&sema, ty),
+        .@"union" => Sema.type_resolution.resolveUnionLayout(&sema, ty),
+        else => unreachable,
     };
     result catch |err| switch (err) {
         error.AnalysisFail => {
@@ -1145,36 +1160,31 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
     sema.flushExports() catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
     };
-
-    codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
-        if (file.mod.?.strip) break :codegen_type;
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_type = ty.toIntern() });
-    }
 }
 
-/// Ensures that the default/tag values of the given `struct` or `enum` type are fully up-to-date,
-/// performing re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!) or an enum.
-/// Returns `error.AnalysisFail` if an analysis error is encountered during resolution; the caller
-/// is free to ignore this, since the error is already registered.
-pub fn ensureTypeInitsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
+/// Ensures that the default values of the given "declared" (not reified) `struct` type are fully
+/// up-to-date, performing re-analysis if necessary. Asserts that `ty` is a struct (not tuple) type.
+/// Returns `error.AnalysisFail` if an analysis error is encountered while resolving the default
+/// field values; the caller is free to ignore this, since the error is already registered.
+pub fn ensureStructDefaultsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
 
-    const anal_unit: AnalUnit = .wrap(.{ .type_inits = ty.toIntern() });
+    assert(ty.zigTypeTag(zcu) == .@"struct");
+    assert(!ty.isTuple(zcu));
 
-    log.debug("ensureTypeInitsUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
+    const anal_unit: AnalUnit = .wrap(.{ .struct_defaults = ty.toIntern() });
+
+    log.debug("ensureStructDefaultsUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
     // Determine whether or not this type is outdated. For this kind of `AnalUnit`, that's
     // the only indicator as to whether or not analysis is required; when a struct/enum is
     // first created, it's marked as outdated.
-    // MLUGG TODO: make that actually true, it's a good strategy here!
 
     const was_outdated = zcu.outdated.swapRemove(anal_unit) or
         zcu.potentially_outdated.swapRemove(anal_unit);
@@ -1194,7 +1204,7 @@ pub fn ensureTypeInitsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
         }
         // For types, we already know that we have to invalidate all dependees.
         // TODO: we actually *could* detect whether everything was the same. should we bother?
-        try zcu.markDependeeOutdated(.marked_po, .{ .type_inits = ty.toIntern() });
+        try zcu.markDependeeOutdated(.marked_po, .{ .struct_defaults = ty.toIntern() });
     } else {
         // We can trust the current information about this unit.
         if (zcu.failed_analysis.contains(anal_unit)) return error.AnalysisFail;
@@ -1236,12 +1246,7 @@ pub fn ensureTypeInitsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
     };
     defer sema.deinit();
 
-    const result = switch (ty.zigTypeTag(zcu)) {
-        .@"struct" => Sema.type_resolution.resolveStructDefaults(&sema, ty),
-        .@"enum" => Sema.type_resolution.resolveEnumValues(&sema, ty),
-        else => unreachable,
-    };
-    result catch |err| switch (err) {
+    Sema.type_resolution.resolveStructDefaults(&sema, ty) catch |err| switch (err) {
         error.AnalysisFail => {
             if (!zcu.failed_analysis.contains(anal_unit)) {
                 // If this unit caused the error, it would have an entry in `failed_analysis`.
@@ -1270,20 +1275,6 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
     const tracy = trace(@src());
     defer tracy.end();
 
-    // TODO: document this elsewhere mlugg!
-    // For my own benefit, here's how a namespace update for a normal (non-file-root) type works:
-    // `const S = struct { ... };`
-    // We are adding or removing a declaration within this `struct`.
-    // * `S` registers a dependency on `.{ .src_hash = (declaration of S) }`
-    // * Any change to the `struct` body -- including changing a declaration -- invalidates this
-    // * `S` is re-analyzed, but notes:
-    //   * there is an existing struct instance (at this `TrackedInst` with these captures)
-    //   * the struct's resolution is up-to-date (because nothing about the fields changed)
-    // * so, it uses the same `struct`
-    // * but this doesn't stop it from updating the namespace!
-    //   * we basically do `scanDecls`, updating the namespace as needed
-    // * so everyone lived happily ever after
-
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
@@ -3033,7 +3024,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
     const zir = file.zir.?;
 
     try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {});
-    errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);
+    defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
     func.setAnalyzed(ip, io);
     if (func.analysisUnordered(ip).inferred_error_set) {
@@ -3231,9 +3222,6 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
         func.setResolvedErrorSet(ip, io, ies.resolved);
     }
 
-    // MLUGG TODO: i think this can go away and the assert move to the defer?
-    assert(zcu.analysis_in_progress.swapRemove(anal_unit));
-
     try sema.flushExports();
 
     defer {
@@ -3835,7 +3823,6 @@ pub fn enumValue(pt: Zcu.PerThread, ty: Type, tag_int: InternPool.Index) Allocat
 /// declaration order.
 pub fn enumValueFieldIndex(pt: Zcu.PerThread, ty: Type, field_index: u32) Allocator.Error!Value {
     const ip = &pt.zcu.intern_pool;
-    ty.assertHasInits(pt.zcu);
     const enum_type = ip.loadEnumType(ty.toIntern());
 
     assert(field_index < enum_type.field_names.len);
@@ -3859,7 +3846,9 @@ pub fn enumValueFieldIndex(pt: Zcu.PerThread, ty: Type, field_index: u32) Alloca
 
 pub fn undefValue(pt: Zcu.PerThread, ty: Type) Allocator.Error!Value {
     if (std.debug.runtime_safety) {
-        assert(try ty.onePossibleValue(pt) == null);
+        if (try ty.onePossibleValue(pt)) |opv| {
+            assert(opv.isUndef(pt.zcu));
+        }
     }
     return .fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
 }
@@ -3941,7 +3930,10 @@ pub fn aggregateValue(pt: Zcu.PerThread, ty: Type, elems: []const InternPool.Ind
     for (elems) |elem| {
         if (!Value.fromInterned(elem).isUndef(pt.zcu)) break;
     } else if (elems.len > 0) {
-        return pt.undefValue(ty); // all-undef
+        // All undef, so return an undef struct. However, don't use `undefValue`, because its
+        // non-OPV assertion can loop on `[1]@TypeOf(undefined)`: that type has an OPV of
+        // `.{undefined}`, which here we normalize to `undefined`.
+        return .fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
     }
     return .fromInterned(try pt.intern(.{ .aggregate = .{
         .ty = ty.toIntern(),
@@ -4096,19 +4088,6 @@ pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!
     return result.index;
 }
 
-// TODO: this shouldn't need a `PerThread`! Fix the signature of `Type.abiAlignment`.
-// MLUGG TODO: that's done, move it!
-pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPool.Alignment {
-    const zcu = pt.zcu;
-    const ty: Type, const alignment = switch (zcu.intern_pool.getNav(nav_index).status) {
-        .unresolved => unreachable,
-        .type_resolved => |r| .{ .fromInterned(r.type), r.alignment },
-        .fully_resolved => |r| .{ Value.fromInterned(r.val).typeOf(zcu), r.alignment },
-    };
-    if (alignment != .none) return alignment;
-    return ty.abiAlignment(zcu);
-}
-
 /// Given a namespace, re-scan its declarations from the type definition if they have not
 /// yet been re-scanned on this update.
 /// If the type declaration instruction has been lost, returns `error.AnalysisFail`.
@@ -4393,7 +4372,7 @@ pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
         .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
             .struct_type => {
                 try pt.ensureTypeLayoutUpToDate(ty);
-                try pt.ensureTypeInitsUpToDate(ty);
+                try pt.ensureStructDefaultsUpToDate(ty);
             },
             .tuple_type => |tuple| for (0..tuple.types.len) |i| {
                 const field_is_comptime = tuple.values.get(ip)[i] != .none;
@@ -4405,7 +4384,7 @@ pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
         },
 
         .@"union" => try pt.ensureTypeLayoutUpToDate(ty),
-        .@"enum" => try pt.ensureTypeInitsUpToDate(ty),
+        .@"enum" => try pt.ensureTypeLayoutUpToDate(ty),
     }
 }
 pub fn resolveValueTypesForCodegen(pt: Zcu.PerThread, val: Value) Zcu.SemaError!void {
diff --git a/src/codegen.zig b/src/codegen.zig
index 67575beb3f6f1a5b55a02fe75c0c8b9a576f906f..e9acab66e4c2b8a618447ea6fad9659ab1c39243 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -347,7 +347,6 @@ pub fn generateSymbol(
             .void => unreachable, // non-runtime value
             .null => unreachable, // non-runtime value
             .@"unreachable" => unreachable, // non-runtime value
-            .empty_tuple => return,
             .false, .true => try w.writeByte(switch (simple_value) {
                 .false => 0,
                 .true => 1,
@@ -1065,20 +1064,20 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
                 const elem_ty = ty.childType(zcu);
                 const ptr = ip.indexToKey(val.toIntern()).ptr;
                 if (ptr.base_addr == .int) return .{ .immediate = ptr.byte_offset };
-                switch (ptr.base_addr) {
+                if (ptr.byte_offset == 0) switch (ptr.base_addr) {
                     .int => unreachable, // handled above
 
-                    .nav => |nav| if (elem_ty.isFnOrHasRuntimeBits(zcu)) {
+                    .nav => |nav| if (elem_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
                         return .{ .lea_nav = nav };
                     } else {
                         // Create the 0xaa bit pattern...
                         const undef_ptr_bits: u64 = @intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() + 1)) / 3);
                         // ...but align the pointer
-                        const alignment = pt.navAlignment(nav);
+                        const alignment = zcu.navAlignment(nav);
                         return .{ .immediate = alignment.forward(undef_ptr_bits) };
                     },
 
-                    .uav => |uav| if (elem_ty.isFnOrHasRuntimeBits(zcu)) {
+                    .uav => |uav| if (elem_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
                         return .{ .lea_uav = uav };
                     } else {
                         // Create the 0xaa bit pattern...
@@ -1089,7 +1088,7 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
                     },
 
                     else => {},
-                }
+                };
             },
         },
         .int => {
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index 0e6387949aa8d337f9c731db050551f710fa31e9..74494649056adbe9d0baeceea5f320c9b12f5d95 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -6594,7 +6594,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                     if (try isel.hasRepeatedByteRepr(.fromInterned(fill_val))) |fill_byte|
                         break :fill_byte .{ .constant = fill_byte };
                 }
-                switch (dst_ty.indexablePtrElem(zcu).abiSize(zcu)) {
+                switch (dst_ty.indexableElem(zcu).abiSize(zcu)) {
                     0 => unreachable,
                     1 => break :fill_byte .{ .value = bin_op.rhs },
                     2, 4, 8 => |size| {
@@ -7217,7 +7217,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 const ptr_ra = try ptr_vi.value.defReg(isel) orelse break :unused;
 
                 const ty_nav = air.data(air.inst_index).ty_nav;
-                if (ZigType.fromInterned(ip.getNav(ty_nav.nav).typeOf(ip)).isFnOrHasRuntimeBits(zcu)) switch (true) {
+                if (ZigType.fromInterned(ip.getNav(ty_nav.nav).typeOf(ip)).isRuntimeFnOrHasRuntimeBits(zcu)) switch (true) {
                     false => {
                         try isel.nav_relocs.append(gpa, .{
                             .nav = ty_nav.nav,
@@ -7240,7 +7240,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                         });
                         try isel.emit(.adrp(ptr_ra.x(), 0));
                     },
-                } else try isel.movImmediate(ptr_ra.x(), isel.pt.navAlignment(ty_nav.nav).forward(0xaaaaaaaaaaaaaaaa));
+                } else try isel.movImmediate(ptr_ra.x(), zcu.navAlignment(ty_nav.nav).forward(0xaaaaaaaaaaaaaaaa));
             }
             if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
         },
@@ -10738,7 +10738,7 @@ pub const Value = struct {
                                     } }),
                                 }),
                                 .simple_value => |simple_value| switch (simple_value) {
-                                    .undefined, .void, .null, .empty_tuple, .@"unreachable" => unreachable,
+                                    .undefined, .void, .null, .@"unreachable" => unreachable,
                                     .true => continue :constant_key .{ .int = .{
                                         .ty = .bool_type,
                                         .storage = .{ .u64 = 1 },
@@ -10931,7 +10931,7 @@ pub const Value = struct {
                                 .ptr => |ptr| {
                                     assert(offset == 0 and size == 8);
                                     break :free switch (ptr.base_addr) {
-                                        .nav => |nav| if (ZigType.fromInterned(ip.getNav(nav).typeOf(ip)).isFnOrHasRuntimeBits(zcu)) switch (true) {
+                                        .nav => |nav| if (ZigType.fromInterned(ip.getNav(nav).typeOf(ip)).isRuntimeFnOrHasRuntimeBits(zcu)) switch (true) {
                                             false => {
                                                 try isel.nav_relocs.append(zcu.gpa, .{
                                                     .nav = nav,
@@ -10965,9 +10965,9 @@ pub const Value = struct {
                                             },
                                         } else continue :constant_key .{ .int = .{
                                             .ty = .usize_type,
-                                            .storage = .{ .u64 = isel.pt.navAlignment(nav).forward(0xaaaaaaaaaaaaaaaa) },
+                                            .storage = .{ .u64 = zcu.navAlignment(nav).forward(0xaaaaaaaaaaaaaaaa) },
                                         } },
-                                        .uav => |uav| if (ZigType.fromInterned(ip.typeOf(uav.val)).isFnOrHasRuntimeBits(zcu)) switch (true) {
+                                        .uav => |uav| if (ZigType.fromInterned(ip.typeOf(uav.val)).isRuntimeFnOrHasRuntimeBits(zcu)) switch (true) {
                                             false => {
                                                 try isel.uav_relocs.append(zcu.gpa, .{
                                                     .uav = uav,
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 831a64779bc423595b5433b4d70eaf8a5c0fbf37..5e9f21e1aada16d7fa98ebd9a9c01d7b11a35d8c 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -789,7 +789,7 @@ pub const DeclGen = struct {
 
         // Render an undefined pointer if we have a pointer to a zero-bit or comptime type.
         const ptr_ty: Type = .fromInterned(uav.orig_ty);
-        if (ptr_ty.isPtrAtRuntime(zcu) and !uav_ty.isFnOrHasRuntimeBits(zcu)) {
+        if (ptr_ty.isPtrAtRuntime(zcu) and !uav_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
             return dg.writeCValue(w, .{ .undef = ptr_ty });
         }
 
@@ -862,7 +862,7 @@ pub const DeclGen = struct {
         // Render an undefined pointer if we have a pointer to a zero-bit or comptime type.
         const nav_ty: Type = .fromInterned(ip.getNav(owner_nav).typeOf(ip));
         const ptr_ty = try pt.navPtrType(owner_nav);
-        if (!nav_ty.isFnOrHasRuntimeBits(zcu)) {
+        if (!nav_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
             return dg.writeCValue(w, .{ .undef = ptr_ty });
         }
 
@@ -1043,7 +1043,6 @@ pub const DeclGen = struct {
                 .undefined => unreachable,
                 .void => unreachable,
                 .null => unreachable,
-                .empty_tuple => unreachable,
                 .@"unreachable" => unreachable,
 
                 .false => try w.writeAll("false"),
@@ -3077,7 +3076,7 @@ pub fn genDecl(o: *Object) Error!void {
     const nav = ip.getNav(o.dg.pass.nav);
     const nav_ty: Type = .fromInterned(nav.typeOf(ip));
 
-    if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) return;
+    if (!nav_ty.hasRuntimeBits(zcu)) return;
     switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .@"extern" => |@"extern"| {
             if (!ip.isFunctionType(nav_ty.toIntern())) return o.dg.renderFwdDecl(o.dg.pass.nav, .{
@@ -3676,7 +3675,7 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const ptr_ty = f.typeOf(bin_op.lhs);
-    const elem_has_bits = ptr_ty.indexablePtrElem(zcu).hasRuntimeBitsIgnoreComptime(zcu);
+    const elem_has_bits = ptr_ty.indexableElem(zcu).hasRuntimeBitsIgnoreComptime(zcu);
 
     const ptr = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3792,7 +3791,7 @@ fn airAlloc(f: *Function, inst: Air.Inst.Index) !CValue {
     const zcu = pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const elem_ty = inst_ty.childType(zcu);
-    if (!elem_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) return .{ .undef = inst_ty };
+    if (!elem_ty.hasRuntimeBits(zcu)) return .{ .undef = inst_ty };
 
     const local = try f.allocLocalValue(.{
         .ctype = try f.ctypeFromType(elem_ty, .complete),
@@ -3829,7 +3828,7 @@ fn airRetPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const zcu = pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const elem_ty = inst_ty.childType(zcu);
-    if (!elem_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) return .{ .undef = inst_ty };
+    if (!elem_ty.hasRuntimeBits(zcu)) return .{ .undef = inst_ty };
 
     const local = try f.allocLocalValue(.{
         .ctype = try f.ctypeFromType(elem_ty, .complete),
@@ -4502,7 +4501,7 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const inst_scalar_ty = inst_ty.scalarType(zcu);
-    const elem_ty = inst_scalar_ty.indexablePtrElem(zcu);
+    const elem_ty = inst_scalar_ty.indexableElem(zcu);
     if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return f.moveCValue(inst, inst_ty, lhs);
     const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
 
@@ -7037,7 +7036,7 @@ fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CV
     try w.writeAll(", ");
     try writeArrayLen(f, dest_ptr, dest_ty);
     try w.writeAll(" * sizeof(");
-    try f.renderType(w, dest_ty.indexablePtrElem(zcu));
+    try f.renderType(w, dest_ty.indexableElem(zcu));
     try w.writeAll("));");
     try f.object.newline();
 
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 1327b7b2e1c9985b30f53c4411a8fcf8afa9f89c..ad115504baec4eaad608f6f3cf9d614a3e9d610d 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3725,7 +3725,6 @@ pub const Object = struct {
                 .undefined => unreachable, // non-runtime value
                 .void => unreachable, // non-runtime value
                 .null => unreachable, // non-runtime value
-                .empty_tuple => unreachable, // non-runtime value
                 .@"unreachable" => unreachable, // non-runtime value
 
                 .false => .false,
@@ -4604,7 +4603,7 @@ pub const NavGen = struct {
             _ = try o.resolveLlvmFunction(pt, owner_nav);
         } else {
             const variable_index = try o.resolveGlobalNav(pt, nav_index);
-            variable_index.setAlignment(pt.navAlignment(nav_index).toLlvm(), &o.builder);
+            variable_index.setAlignment(zcu.navAlignment(nav_index).toLlvm(), &o.builder);
             if (resolved.@"linksection".toSlice(ip)) |section|
                 variable_index.setSection(try o.builder.string(section), &o.builder);
             if (is_const) variable_index.setMutability(.constant, &o.builder);
@@ -5953,7 +5952,7 @@ pub const FuncGen = struct {
             return .none;
         }
 
-        const have_block_result = inst_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu);
+        const have_block_result = inst_ty.hasRuntimeBits(zcu);
 
         var breaks: BreakList = if (have_block_result) .{ .list = .{} } else .{ .len = 0 };
         defer if (have_block_result) breaks.list.deinit(self.gpa);
@@ -6000,7 +5999,7 @@ pub const FuncGen = struct {
 
         // Add the values to the lists only if the break provides a value.
         const operand_ty = self.typeOf(branch.operand);
-        if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+        if (operand_ty.hasRuntimeBits(zcu)) {
             const val = try self.resolveInst(branch.operand);
 
             // For the phi node, we need the basic blocks and the values of the
@@ -9581,7 +9580,7 @@ pub const FuncGen = struct {
         const zcu = pt.zcu;
         const ptr_ty = self.typeOfIndex(inst);
         const pointee_type = ptr_ty.childType(zcu);
-        if (!pointee_type.isFnOrHasRuntimeBitsIgnoreComptime(zcu))
+        if (!pointee_type.hasRuntimeBits(zcu))
             return (try o.lowerPtrToVoid(pt, ptr_ty)).toValue();
 
         const pointee_llvm_ty = try o.lowerType(pt, pointee_type);
@@ -9595,7 +9594,7 @@ pub const FuncGen = struct {
         const zcu = pt.zcu;
         const ptr_ty = self.typeOfIndex(inst);
         const ret_ty = ptr_ty.childType(zcu);
-        if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu))
+        if (!ret_ty.hasRuntimeBits(zcu))
             return (try o.lowerPtrToVoid(pt, ptr_ty)).toValue();
         if (self.ret_ptr != .none) return self.ret_ptr;
         const ret_llvm_ty = try o.lowerType(pt, ret_ty);
@@ -9897,7 +9896,7 @@ pub const FuncGen = struct {
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
         const operand_ty = ptr_ty.childType(zcu);
-        if (!operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) return .none;
+        if (!operand_ty.hasRuntimeBits(zcu)) return .none;
         const ptr = try self.resolveInst(bin_op.lhs);
         var element = try self.resolveInst(bin_op.rhs);
         const llvm_abi_ty = try o.getAtomicAbiType(pt, operand_ty, false);
@@ -11478,7 +11477,7 @@ pub const FuncGen = struct {
         const zcu = pt.zcu;
         const info = ptr_ty.ptrInfo(zcu);
         const elem_ty = Type.fromInterned(info.child);
-        if (!elem_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!elem_ty.hasRuntimeBits(zcu)) {
             return;
         }
         const ptr_alignment = ptr_ty.ptrAlignment(zcu).toLlvm();
diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig
index dd4ca3f88bbc6bc082a00ab1e62a1b685e068e06..72174554adc862a80034a2af57721703cba0c7a2 100644
--- a/src/codegen/riscv64/CodeGen.zig
+++ b/src/codegen/riscv64/CodeGen.zig
@@ -2673,7 +2673,7 @@ fn genBinOp(
             defer func.register_manager.unlockReg(tmp_lock);
 
             // RISC-V has no immediate mul, so we copy the size to a temporary register
-            const elem_size = lhs_ty.indexablePtrElem(zcu).abiSize(zcu);
+            const elem_size = lhs_ty.indexableElem(zcu).abiSize(zcu);
             const elem_size_reg = try func.copyToTmpRegister(Type.u64, .{ .immediate = elem_size });
 
             try func.genBinOp(
@@ -3913,7 +3913,7 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void {
     const base_ptr_ty = func.typeOf(bin_op.lhs);
 
     const result: MCValue = if (!is_volatile and func.liveness.isUnused(inst)) .unreach else result: {
-        const elem_ty = base_ptr_ty.indexablePtrElem(zcu);
+        const elem_ty = base_ptr_ty.indexableElem(zcu);
         if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const base_ptr_mcv = try func.resolveInst(bin_op.lhs);
         const base_ptr_lock: ?RegisterLock = switch (base_ptr_mcv) {
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index e6850df250db68f6b34050f93cb19717ff90ecb2..5217002f22ecaa5dc3aad1a2035040baa6132e5c 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -821,7 +821,6 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
                 .undefined,
                 .void,
                 .null,
-                .empty_tuple,
                 .@"unreachable",
                 => unreachable, // non-runtime values
 
@@ -1150,7 +1149,7 @@ fn constantUavRef(
     }
 
     // const is_fn_body = decl_ty.zigTypeTag(zcu) == .@"fn";
-    if (!uav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!uav_ty.hasRuntimeBits(zcu)) {
         // Pointer to nothing - return undefined
         return cg.module.constUndef(ty_id);
     }
@@ -1196,7 +1195,7 @@ fn constantNavRef(cg: *CodeGen, ty: Type, nav_index: InternPool.Nav.Index) !Id {
         },
     }
 
-    if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!nav_ty.hasRuntimeBits(zcu)) {
         // Pointer to nothing - return undefined.
         return cg.module.constUndef(ty_id);
     }
@@ -4381,7 +4380,7 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
 fn ptrElemPtr(cg: *CodeGen, ptr_ty: Type, ptr_id: Id, index_id: Id) !Id {
     const zcu = cg.module.zcu;
     // Construct new pointer type for the resulting pointer
-    const elem_ty = ptr_ty.indexablePtrElem(zcu);
+    const elem_ty = ptr_ty.indexableElem(zcu);
     const elem_ty_id = try cg.resolveType(elem_ty, .indirect);
     const elem_ptr_ty_id = try cg.module.ptrType(elem_ty_id, cg.module.storageClass(ptr_ty.ptrAddressSpace(zcu)));
     if (ptr_ty.isSinglePointer(zcu)) {
@@ -5028,7 +5027,7 @@ fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index)
     const gpa = cg.module.gpa;
     const zcu = cg.module.zcu;
     const ty = cg.typeOfIndex(inst);
-    const have_block_result = ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu);
+    const have_block_result = ty.hasRuntimeBits(zcu);
 
     const cf = switch (cg.control_flow) {
         .structured => |*cf| cf,
@@ -5166,7 +5165,7 @@ fn airBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
 
     switch (cg.control_flow) {
         .structured => |*cf| {
-            if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+            if (operand_ty.hasRuntimeBits(zcu)) {
                 const operand_id = try cg.resolve(br.operand);
                 const block_result_var_id = cf.block_results.get(br.block_inst).?;
                 try cg.store(operand_ty, block_result_var_id, operand_id, .{});
@@ -5177,7 +5176,7 @@ fn airBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
         },
         .unstructured => |cf| {
             const block = cf.blocks.get(br.block_inst).?;
-            if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+            if (operand_ty.hasRuntimeBits(zcu)) {
                 const operand_id = try cg.resolve(br.operand);
                 // block_label should not be undefined here, lest there
                 // is a br or br_void in the function's body.
diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig
index 90de3461cacbfdb90b07a3f2898598ed27be9ac7..955e9b51d361ec75ea1c1b5ab08c71dc7f2cbd40 100644
--- a/src/codegen/wasm/CodeGen.zig
+++ b/src/codegen/wasm/CodeGen.zig
@@ -2099,7 +2099,7 @@ fn airRetPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const child_type = cg.typeOfIndex(inst).childType(zcu);
 
     const result = result: {
-        if (!child_type.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!child_type.hasRuntimeBits(zcu)) {
             break :result try cg.allocStack(Type.usize); // create pointer to void
         }
 
@@ -3161,7 +3161,6 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             .undefined,
             .void,
             .null,
-            .empty_tuple,
             .@"unreachable",
             => unreachable, // non-runtime values
             .false, .true => return .{ .imm32 = switch (simple_value) {
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 872404b71572de6124f68ed84dfbca6b5122152f..a9898398d7318fc1cf6046fac752c998ae3a5282 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -104121,7 +104121,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             },
             .slice_elem_val, .ptr_elem_val => {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
-                const res_ty = cg.typeOf(bin_op.lhs).indexablePtrElem(zcu);
+                const res_ty = cg.typeOf(bin_op.lhs).indexableElem(zcu);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toSlicePtr(cg);
                 var res: [1]Temp = undefined;
@@ -188179,8 +188179,8 @@ const Select = struct {
                     .signed => false,
                     .unsigned => size.bitSize(cg.target) >= int_info.bits,
                 } else false,
-                .elem_size_is => |size| size == ty.indexablePtrElem(zcu).abiSize(zcu),
-                .po2_elem_size => std.math.isPowerOfTwo(ty.indexablePtrElem(zcu).abiSize(zcu)),
+                .elem_size_is => |size| size == ty.indexableElem(zcu).abiSize(zcu),
+                .po2_elem_size => std.math.isPowerOfTwo(ty.indexableElem(zcu).abiSize(zcu)),
             };
         }
     };
@@ -189941,9 +189941,9 @@ const Select = struct {
                     op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu),
                     @divExact(op.flags.base.size.bitSize(s.cg.target), 8),
                 )),
-                .elem_size => @intCast(op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
-                .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
-                .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
+                .elem_size => @intCast(op.flags.base.ref.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
+                .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
+                .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
                 .src0_elem_size_mul_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) *
                     Select.Operand.Ref.src1.valueOf(s).immediate),
                 .vector_index => switch (op.flags.base.ref.typeOf(s).ptrInfo(s.cg.pt.zcu).flags.vector_index) {
@@ -189953,7 +189953,7 @@ const Select = struct {
                 .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate),
                 .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) -
                     @as(SignedImm, @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))),
-                .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))),
+                .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).indexableElem(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))),
                 .elem_mask => @as(u8, std.math.maxInt(u8)) >> @intCast(
                     8 - ((s.cg.unalignedSize(op.flags.base.ref.typeOf(s)) - 1) %
                         @divExact(op.flags.base.size.bitSize(s.cg.target), 8) + 1 >>
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 03b757f5b4c9e079cb61c277e305ccc4bdd81472..7440711574f72c47d003f63ff48adee2e522b9e8 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -1552,7 +1552,7 @@ fn updateNavInner(coff: *Coff, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde
                 const sec_si = try coff.navSection(zcu, nav.status.fully_resolved);
                 try coff.nodes.ensureUnusedCapacity(gpa, 1);
                 const ni = try coff.mf.addLastChildNode(gpa, sec_si.node(coff), .{
-                    .alignment = pt.navAlignment(nav_index).toStdMem(),
+                    .alignment = zcu.navAlignment(nav_index).toStdMem(),
                     .moved = true,
                 });
                 coff.nodes.appendAssumeCapacity(.{ .nav = nmi });
diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig
index 588b4e3fc39a2f2af664b996575157558991db75..96db16681ca6a89c0570ab14f1ae09a7e6d5d91b 100644
--- a/src/link/Elf/ZigObject.zig
+++ b/src/link/Elf/ZigObject.zig
@@ -1479,7 +1479,7 @@ fn updateTlv(
 
     log.debug("updateTlv {f}({d})", .{ nav.fqn.fmt(ip), nav_index });
 
-    const required_alignment = pt.navAlignment(nav_index);
+    const required_alignment = zcu.navAlignment(nav_index);
 
     const sym = self.symbol(sym_index);
     const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig
index 81e6c23af82805f96d09409637b0e14e0dc49165..bab805af760d7ea4a5c6433bf6bccb96602dcb5b 100644
--- a/src/link/Elf2.zig
+++ b/src/link/Elf2.zig
@@ -2906,7 +2906,7 @@ fn updateNavInner(elf: *Elf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index)
                 try elf.nodes.ensureUnusedCapacity(gpa, 1);
                 const sec_si = elf.navSection(ip, nav.status.fully_resolved);
                 const ni = try elf.mf.addLastChildNode(gpa, sec_si.node(elf), .{
-                    .alignment = pt.navAlignment(nav_index).toStdMem(),
+                    .alignment = zcu.navAlignment(nav_index).toStdMem(),
                     .moved = true,
                 });
                 elf.nodes.appendAssumeCapacity(.{ .nav = nmi });
diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig
index 49555c2746a46dc0ee9617aea5f0de67d35ef313..fc3ac0fca8f5588ad67cd10c9a7a563f16a2aec4 100644
--- a/src/link/MachO/ZigObject.zig
+++ b/src/link/MachO/ZigObject.zig
@@ -925,7 +925,7 @@ pub fn updateNav(
 
         const sect_index = try self.getNavOutputSection(macho_file, zcu, nav_index, code);
         if (isThreadlocal(macho_file, nav_index))
-            try self.updateTlv(macho_file, pt, nav_index, sym_index, sect_index, code)
+            try self.updateTlv(macho_file, zcu, nav_index, sym_index, sect_index, code)
         else
             try self.updateNavCode(macho_file, pt, nav_index, sym_index, sect_index, code);
 
@@ -1030,13 +1030,13 @@ fn updateNavCode(
 fn updateTlv(
     self: *ZigObject,
     macho_file: *MachO,
-    pt: Zcu.PerThread,
+    zcu: *Zcu,
     nav_index: InternPool.Nav.Index,
     sym_index: Symbol.Index,
     sect_index: u8,
     code: []const u8,
 ) !void {
-    const ip = &pt.zcu.intern_pool;
+    const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
 
     log.debug("updateTlv {f} (0x{x})", .{ nav.fqn.fmt(ip), nav_index });
@@ -1045,7 +1045,7 @@ fn updateTlv(
     const init_sym_index = try self.createTlvInitializer(
         macho_file,
         nav.fqn.toSlice(ip),
-        pt.navAlignment(nav_index),
+        zcu.navAlignment(nav_index),
         sect_index,
         code,
     );
diff --git a/src/print_value.zig b/src/print_value.zig
index e58288a16a999c3ee2c17dbd3b31fd8fec4a59d9..5b29bb04d68d3bf380601e2bed30e2cbe4912e86 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -72,8 +72,13 @@ pub fn print(
         .undef => try writer.writeAll("undefined"),
         .simple_value => |simple_value| switch (simple_value) {
             .void => try writer.writeAll("{}"),
-            .empty_tuple => try writer.writeAll(".{}"),
-            else => try writer.writeAll(@tagName(simple_value)),
+
+            .undefined,
+            .null,
+            .true,
+            .false,
+            .@"unreachable",
+            => try writer.writeAll(@tagName(simple_value)),
         },
         .variable => try writer.writeAll("(variable)"),
         .@"extern" => |e| try writer.print("(extern '{f}')", .{e.name.fmt(ip)}),
@@ -248,17 +253,26 @@ fn printAggregate(
     const len = ty.arrayLen(zcu);
 
     if (is_ref) try writer.writeByte('&');
-    try writer.writeAll(".{ ");
-
-    const max_len = @min(len, max_aggregate_items);
-    for (0..max_len) |i| {
-        if (i != 0) try writer.writeAll(", ");
-        try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
+    switch (len) {
+        0 => try writer.writeAll(".{}"),
+        1 => {
+            try writer.writeAll(".{");
+            try print(try val.fieldValue(pt, 0), writer, level - 1, pt, opt_sema);
+            try writer.writeByte('}');
+        },
+        else => {
+            try writer.writeAll(".{ ");
+            const max_len = @min(len, max_aggregate_items);
+            for (0..max_len) |i| {
+                if (i != 0) try writer.writeAll(", ");
+                try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
+            }
+            if (len > max_aggregate_items) {
+                try writer.writeAll(", ...");
+            }
+            try writer.writeAll(" }");
+        },
     }
-    if (len > max_aggregate_items) {
-        try writer.writeAll(", ...");
-    }
-    return writer.writeAll(" }");
 }
 
 fn printPtr(
diff --git a/src/print_zir.zig b/src/print_zir.zig
index cd7d18351ca48c7c767c1347f52e53589a921404..34c816fad62fc80355601fdbc723d2b3e8d02974 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -1439,10 +1439,10 @@ const Writer = struct {
 
         try stream.print("{s}, ", .{@tagName(struct_decl.name_strategy)});
 
-        if (struct_decl.backing_int_type != .none) {
+        if (struct_decl.backing_int_type_body) |backing_int_type_body| {
             assert(struct_decl.layout == .@"packed");
             try stream.writeAll("packed(");
-            try self.writeInstRef(stream, struct_decl.backing_int_type);
+            try self.writeBracedDecl(stream, backing_int_type_body);
             try stream.writeAll("), ");
         } else {
             try stream.print("{s}, ", .{@tagName(struct_decl.layout)});
@@ -1507,18 +1507,18 @@ const Writer = struct {
             .@"packed" => try stream.writeAll("packed, "),
             .packed_explicit => {
                 try stream.writeAll("packed(");
-                try self.writeInstRef(stream, union_decl.arg_type);
+                try self.writeBracedDecl(stream, union_decl.arg_type_body.?);
                 try stream.writeAll("), ");
             },
             .tagged_explicit => {
-                try stream.writeAll("auto(");
-                try self.writeInstRef(stream, union_decl.arg_type);
+                try stream.writeAll("tagged(");
+                try self.writeBracedDecl(stream, union_decl.arg_type_body.?);
                 try stream.writeAll("), ");
             },
-            .tagged_enum => try stream.writeAll("auto(enum)"),
+            .tagged_enum => try stream.writeAll("tagged(enum), "),
             .tagged_enum_explicit => {
-                try stream.writeAll("auto(enum(");
-                try self.writeInstRef(stream, union_decl.arg_type);
+                try stream.writeAll("tagged(enum(");
+                try self.writeBracedDecl(stream, union_decl.arg_type_body.?);
                 try stream.writeAll(")), ");
             },
         }
@@ -1577,7 +1577,11 @@ const Writer = struct {
 
         try stream.print("{s}, ", .{@tagName(enum_decl.name_strategy)});
         try self.writeFlag(stream, "nonexhaustive, ", enum_decl.nonexhaustive);
-        try self.writeInstRef(stream, enum_decl.tag_type);
+        if (enum_decl.tag_type_body) |tag_type_body| {
+            try stream.writeAll("tag(");
+            try self.writeBracedDecl(stream, tag_type_body);
+            try stream.writeAll("), ");
+        }
 
         try self.writeCaptures(stream, enum_decl.captures, enum_decl.capture_names);
         try stream.writeAll(", ");
@@ -1585,9 +1589,9 @@ const Writer = struct {
         try stream.writeAll(", ");
 
         if (enum_decl.field_names.len == 0) {
-            try stream.writeAll(", {}) ");
+            try stream.writeAll("{}) ");
         } else {
-            try stream.writeAll(", {\n");
+            try stream.writeAll("{\n");
             self.indent += 2;
 
             var it = enum_decl.iterateFields();
-- 
2.54.0


From e3e9ae12bd3a7c08f3ed41e801f6cf34bec01af2 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 26 Jan 2026 21:14:08 +0000
Subject: [PATCH 419/499] Sema: remove unnecessary error sets from resolveInst
 and resolveValue

---
 src/Sema.zig | 821 +++++++++++++++++++++++++--------------------------
 1 file changed, 410 insertions(+), 411 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index d1482b86812e6168d0e4fd75ba90f41016903244..09c974fb256e4709030a8e6540e468140af8131c 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1086,7 +1086,7 @@ fn analyzeInlineBody(
         // This control flow goes further up the stack.
         return error.ComptimeBreak;
     }
-    return try sema.resolveInst(break_inst.data.@"break".operand);
+    return sema.resolveInst(break_inst.data.@"break".operand);
 }
 
 /// Like `analyzeInlineBody`, but if the body does not break with a value, returns
@@ -1873,7 +1873,7 @@ fn analyzeBodyInner(
 
                 const break_data = opt_break_data orelse break;
                 if (inst == break_data.block_inst) {
-                    break :blk try sema.resolveInst(break_data.operand);
+                    break :blk sema.resolveInst(break_data.operand);
                 } else {
                     // `comptime_break_inst` preserved from `analyzeBodyInner` above.
                     return error.ComptimeBreak;
@@ -1894,7 +1894,7 @@ fn analyzeBodyInner(
                     extra.end + then_body.len,
                     extra.data.else_body_len,
                 );
-                const uncasted_cond = try sema.resolveInst(extra.data.condition);
+                const uncasted_cond = sema.resolveInst(extra.data.condition);
                 const cond = try sema.coerce(block, .bool, uncasted_cond, cond_src);
                 const cond_val = try sema.resolveConstDefinedValue(
                     block,
@@ -1920,7 +1920,7 @@ fn analyzeBodyInner(
                 const operand_src = block.src(.{ .node_offset_try_operand = inst_data.src_node });
                 const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index);
                 const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len);
-                const err_union = try sema.resolveInst(extra.data.operand);
+                const err_union = sema.resolveInst(extra.data.operand);
                 const err_union_ty = sema.typeOf(err_union);
                 if (err_union_ty.zigTypeTag(zcu) != .error_union) {
                     return sema.failWithOwnedErrorMsg(block, msg: {
@@ -1946,7 +1946,7 @@ fn analyzeBodyInner(
                 const operand_src = block.src(.{ .node_offset_try_operand = inst_data.src_node });
                 const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index);
                 const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len);
-                const operand = try sema.resolveInst(extra.data.operand);
+                const operand = sema.resolveInst(extra.data.operand);
                 const err_union = try sema.analyzeLoad(block, src, operand, operand_src);
                 const is_non_err_val = (try sema.resolveIsNonErrVal(block, operand_src, err_union)).?;
                 if (is_non_err_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, operand_src, null);
@@ -1975,7 +1975,7 @@ fn analyzeBodyInner(
                 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].defer_err_code;
                 const extra = sema.code.extraData(Zir.Inst.DeferErrCode, inst_data.payload_index).data;
                 const defer_body = sema.code.bodySlice(extra.index, extra.len);
-                const err_code = try sema.resolveInst(inst_data.err_code);
+                const err_code = sema.resolveInst(inst_data.err_code);
                 try map.ensureSpaceForInstructions(sema.gpa, defer_body);
                 map.putAssumeCapacity(extra.remapped_err_code, err_code);
                 if (sema.analyzeBodyInner(block, defer_body)) {
@@ -2022,7 +2022,7 @@ fn analyzeBodyInner(
     }
 }
 
-pub fn resolveInstAllowNone(sema: *Sema, zir_ref: Zir.Inst.Ref) !Air.Inst.Ref {
+fn resolveInstAllowNone(sema: *Sema, zir_ref: Zir.Inst.Ref) Air.Inst.Ref {
     if (zir_ref == .none) {
         return .none;
     } else {
@@ -2030,7 +2030,7 @@ pub fn resolveInstAllowNone(sema: *Sema, zir_ref: Zir.Inst.Ref) !Air.Inst.Ref {
     }
 }
 
-pub fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) !Air.Inst.Ref {
+fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) Air.Inst.Ref {
     assert(zir_ref != .none);
     if (zir_ref.toIndex()) |i| {
         return sema.inst_map.get(i).?;
@@ -2047,7 +2047,7 @@ fn resolveConstBool(
     zir_ref: Zir.Inst.Ref,
     reason: ComptimeReason,
 ) !bool {
-    const air_inst = try sema.resolveInst(zir_ref);
+    const air_inst = sema.resolveInst(zir_ref);
     const wanted_type: Type = .bool;
     const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, reason);
@@ -2063,7 +2063,7 @@ fn resolveConstString(
     /// being comptime-resolved is that the block is being comptime-evaluated.
     reason: ?ComptimeReason,
 ) ![]u8 {
-    const air_inst = try sema.resolveInst(zir_ref);
+    const air_inst = sema.resolveInst(zir_ref);
     return sema.toConstString(block, src, air_inst, reason);
 }
 
@@ -2090,7 +2090,7 @@ pub fn resolveConstStringIntern(
     zir_ref: Zir.Inst.Ref,
     reason: ComptimeReason,
 ) !InternPool.NullTerminatedString {
-    const air_inst = try sema.resolveInst(zir_ref);
+    const air_inst = sema.resolveInst(zir_ref);
     const wanted_type: Type = .slice_const_u8;
     const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, reason);
@@ -2098,7 +2098,7 @@ pub fn resolveConstStringIntern(
 }
 
 fn resolveTypeOrPoison(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) !?Type {
-    const air_inst = try sema.resolveInst(zir_ref);
+    const air_inst = sema.resolveInst(zir_ref);
     const ty = try sema.analyzeAsType(block, src, .type, air_inst);
     if (ty.isGenericPoison()) return null;
     return ty;
@@ -2192,7 +2192,7 @@ fn genericPoisonReason(sema: *Sema, block: *Block, ref: Zir.Inst.Ref) GenericPoi
                 // There are two cases here: the pointer type may already have been
                 // generic poison, or it may have been an anyopaque pointer.
                 const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-                const operand_ref = try sema.resolveInst(un_node.operand);
+                const operand_ref = sema.resolveInst(un_node.operand);
                 const operand_val = operand_ref.toInterned() orelse return .unknown;
                 if (operand_val == .generic_poison_type) {
                     // The pointer was generic poison - keep looking.
@@ -2271,8 +2271,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
 }
 
 /// Return the Value corresponding to a given AIR ref, or `null` if it refers to a runtime value.
-/// TODO MLUGG: remove the error union return!
-fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) error{}!?Value {
+fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) ?Value {
     const zcu = sema.pt.zcu;
     assert(inst != .none);
 
@@ -2308,7 +2307,7 @@ pub fn resolveConstValue(
     /// being comptime-resolved is that the block is being comptime-evaluated.
     reason: ?ComptimeReason,
 ) CompileError!Value {
-    return try sema.resolveValue(inst) orelse {
+    return sema.resolveValue(inst) orelse {
         return sema.failWithNeededComptime(block, src, reason);
     };
 }
@@ -2322,7 +2321,7 @@ fn resolveDefinedValue(
 ) CompileError!?Value {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const val = try sema.resolveValue(air_ref) orelse return null;
+    const val = sema.resolveValue(air_ref) orelse return null;
     if (val.isUndef(zcu)) return sema.failWithUseOfUndef(block, src, null);
     return val;
 }
@@ -2795,7 +2794,7 @@ fn resolveAlign(
     src: LazySrcLoc,
     zir_ref: Zir.Inst.Ref,
 ) !Alignment {
-    const air_ref = try sema.resolveInst(zir_ref);
+    const air_ref = sema.resolveInst(zir_ref);
     return sema.analyzeAsAlign(block, src, air_ref);
 }
 
@@ -2807,7 +2806,7 @@ fn resolveInt(
     dest_ty: Type,
     reason: ComptimeReason,
 ) !u64 {
-    const air_ref = try sema.resolveInst(zir_ref);
+    const air_ref = sema.resolveInst(zir_ref);
     return sema.analyzeAsInt(block, src, air_ref, dest_ty, reason);
 }
 
@@ -2886,7 +2885,7 @@ fn zirTupleDecl(
         field_ty.* = field_type.toIntern();
         field_init.* = init: {
             if (zir_field_init != .none) {
-                const uncoerced_field_init = try sema.resolveInst(zir_field_init);
+                const uncoerced_field_init = sema.resolveInst(zir_field_init);
                 const coerced_field_init = try sema.coerce(block, field_type, uncoerced_field_init, init_src);
                 const field_init_val = try sema.resolveConstDefinedValue(block, init_src, coerced_field_init, .{ .simple = .tuple_field_default_value });
                 if (field_init_val.canMutateComptimeVarState(zcu)) {
@@ -2959,8 +2958,8 @@ fn getCaptures(
         capture.* = switch (zir_capture.unwrap()) {
             .nested => |parent_idx| parent_captures.get(ip)[parent_idx],
             .instruction_load => |ptr_inst| capture: {
-                const ptr_ref = try sema.resolveInst(ptr_inst.toRef());
-                const ptr_val = try sema.resolveValue(ptr_ref) orelse {
+                const ptr_ref = sema.resolveInst(ptr_inst.toRef());
+                const ptr_val = sema.resolveValue(ptr_ref) orelse {
                     break :capture .wrap(.{ .runtime = sema.typeOf(ptr_ref).childType(zcu).toIntern() });
                 };
                 // TODO: better source location
@@ -2974,8 +2973,8 @@ fn getCaptures(
                 break :capture .wrap(.{ .@"comptime" = loaded_val.toIntern() });
             },
             .instruction => |inst| capture: {
-                const air_ref = try sema.resolveInst(inst.toRef());
-                if (try sema.resolveValue(air_ref)) |val| {
+                const air_ref = sema.resolveInst(inst.toRef());
+                if (sema.resolveValue(air_ref)) |val| {
                     if (val.canMutateComptimeVarState(zcu)) {
                         const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_name_slice, .no_embedded_nulls);
                         return sema.failWithContainsReferenceToComptimeVar(block, type_src, field_name, "captured value", val);
@@ -3079,7 +3078,7 @@ fn zirRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     return sema.analyzeRef(block, block.tokenOffset(inst_data.src_tok), operand);
 }
 
@@ -3088,7 +3087,7 @@ fn zirEnsureResultUsed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
 
     return sema.ensureResultUsed(block, sema.typeOf(operand), src);
@@ -3134,7 +3133,7 @@ fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     const pt = sema.pt;
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
     const operand_ty = sema.typeOf(operand);
     switch (operand_ty.zigTypeTag(zcu)) {
@@ -3160,7 +3159,7 @@ fn zirEnsureErrUnionPayloadVoid(sema: *Sema, block: *Block, inst: Zir.Inst.Index
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const err_union_ty = if (operand_ty.zigTypeTag(zcu) == .pointer)
         operand_ty.childType(zcu)
@@ -3185,7 +3184,7 @@ fn zirIndexablePtrLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const object = try sema.resolveInst(inst_data.operand);
+    const object = sema.resolveInst(inst_data.operand);
 
     return indexablePtrLen(sema, block, src, object);
 }
@@ -3331,7 +3330,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const pt = sema.pt;
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const alloc = try sema.resolveInst(inst_data.operand);
+    const alloc = sema.resolveInst(inst_data.operand);
     const alloc_ty = sema.typeOf(alloc);
     const ptr_info = alloc_ty.ptrInfo(zcu);
     const elem_ty: Type = .fromInterned(ptr_info.child);
@@ -3340,7 +3339,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     // However, if the final constructed value does not reference comptime-mutable memory, we wish
     // to promote it to an anon decl.
     already_ct: {
-        const ptr_val = try sema.resolveValue(alloc) orelse break :already_ct;
+        const ptr_val = sema.resolveValue(alloc) orelse break :already_ct;
 
         // If this was a comptime inferred alloc, then `storeToInferredAllocComptime`
         // might have already done our job and created an anon decl ref.
@@ -3526,7 +3525,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                     Air.Bin,
                     tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_pl.payload,
                 ).data;
-                const idx_val = (try sema.resolveValue(data.rhs)).?;
+                const idx_val = sema.resolveValue(data.rhs).?;
                 break :blk .{
                     data.lhs,
                     .{ .elem = idx_val.toUnsignedInt(zcu) },
@@ -3625,7 +3624,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
             },
             .store, .store_safe => {
                 const air_ptr_inst = store_inst.data.bin_op.lhs.toIndex().?;
-                const store_val = (try sema.resolveValue(store_inst.data.bin_op.rhs)).?;
+                const store_val = sema.resolveValue(store_inst.data.bin_op.rhs).?;
                 const new_ptr = ptr_mapping.get(air_ptr_inst).?;
                 try sema.storePtrVal(block, .unneeded, .fromInterned(new_ptr), store_val, store_val.typeOf(zcu));
             },
@@ -3708,7 +3707,7 @@ fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Ai
     const const_ptr_ty = try sema.makePtrTyConst(alloc_ty);
 
     // Detect if a comptime value simply needs to have its type changed.
-    if (try sema.resolveValue(alloc)) |val| {
+    if (sema.resolveValue(alloc)) |val| {
         return Air.internedToRef((try sema.pt.getCoerced(val, const_ptr_ty)).toIntern());
     }
 
@@ -3840,7 +3839,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
-    const ptr = try sema.resolveInst(inst_data.operand);
+    const ptr = sema.resolveInst(inst_data.operand);
     const ptr_inst = ptr.toIndex().?;
     const target = zcu.getTarget();
 
@@ -4005,7 +4004,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 
         const arg_len_uncoerced = if (zir_arg_pair[1] == .none) l: {
             // This argument is an indexable.
-            const object = try sema.resolveInst(zir_arg_pair[0]);
+            const object = sema.resolveInst(zir_arg_pair[0]);
             const object_ty = sema.typeOf(object);
             if (!object_ty.isIndexable(zcu)) {
                 // Instead of using checkIndexable we customize this error.
@@ -4026,8 +4025,8 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             break :l try sema.fieldVal(block, arg_src, object, try ip.getOrPutString(gpa, io, pt.tid, "len", .no_embedded_nulls), arg_src);
         } else l: {
             // This argument is a range.
-            const range_start = try sema.resolveInst(zir_arg_pair[0]);
-            const range_end = try sema.resolveInst(zir_arg_pair[1]);
+            const range_start = sema.resolveInst(zir_arg_pair[0]);
+            const range_end = sema.resolveInst(zir_arg_pair[1]);
             if (try sema.resolveDefinedValue(block, arg_src, range_start)) |start| {
                 if (try sema.valuesEqual(start, .zero_usize, .usize)) break :l range_end;
             }
@@ -4077,7 +4076,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                 const i: u32 = @intCast(i_usize);
                 if (zir_arg_pair[0] == .none) continue;
                 if (zir_arg_pair[1] != .none) continue;
-                const object = try sema.resolveInst(zir_arg_pair[0]);
+                const object = sema.resolveInst(zir_arg_pair[0]);
                 const object_ty = sema.typeOf(object);
                 const arg_src = block.src(.{ .for_input = .{
                     .for_node_offset = inst_data.src_node,
@@ -4132,7 +4131,7 @@ fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcL
 
 fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const ptr = try sema.resolveInst(un_node.operand);
+    const ptr = sema.resolveInst(un_node.operand);
     try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu));
     return sema.optEuBasePtrInit(block, ptr, block.nodeOffset(un_node.src_node));
 }
@@ -4143,7 +4142,7 @@ fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(pl_node.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data;
-    const uncoerced_val = try sema.resolveInst(extra.rhs);
+    const uncoerced_val = sema.resolveInst(extra.rhs);
     const maybe_wrapped_ptr_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, extra.lhs) orelse return uncoerced_val;
     const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu);
     assert(ptr_ty.zigTypeTag(zcu) == .pointer); // validated by a previous instruction
@@ -4259,7 +4258,7 @@ fn zirValidateConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
 
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(un_node.src_node);
-    const init_ref = try sema.resolveInst(un_node.operand);
+    const init_ref = sema.resolveInst(un_node.operand);
     if (!try sema.isComptimeKnown(init_ref)) {
         return sema.failWithNeededComptime(block, src, null);
     }
@@ -4402,7 +4401,7 @@ fn zirValidatePtrStructInit(
     const instrs = sema.code.bodySlice(validate_extra.end, validate_extra.data.body_len);
     const field_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node;
     const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data;
-    const object_ptr = try sema.resolveInst(field_ptr_extra.lhs);
+    const object_ptr = sema.resolveInst(field_ptr_extra.lhs);
     const agg_ty = sema.typeOf(object_ptr).childType(zcu).optEuBaseType(zcu);
     switch (agg_ty.zigTypeTag(zcu)) {
         .@"struct" => return sema.validateStructInit(
@@ -4571,7 +4570,7 @@ fn zirValidatePtrArrayInit(
     const instrs = sema.code.bodySlice(validate_extra.end, validate_extra.data.body_len);
     const first_elem_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node;
     const elem_ptr_extra = sema.code.extraData(Zir.Inst.ElemPtrImm, first_elem_ptr_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(elem_ptr_extra.ptr);
+    const array_ptr = sema.resolveInst(elem_ptr_extra.ptr);
     const array_ty = sema.typeOf(array_ptr).childType(zcu).optEuBaseType(zcu);
     const array_len = array_ty.arrayLen(zcu);
 
@@ -4631,7 +4630,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
 
     if (operand_ty.zigTypeTag(zcu) != .pointer) {
@@ -4650,7 +4649,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
         return;
     }
 
-    if (try sema.resolveValue(operand)) |val| {
+    if (sema.resolveValue(operand)) |val| {
         if (val.isUndef(zcu)) {
             return sema.fail(block, src, "cannot dereference undefined value", .{});
         }
@@ -4685,7 +4684,7 @@ fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const extra = sema.code.extraData(Zir.Inst.ValidateDestructure, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
     const destructure_src = block.nodeOffset(extra.destructure_node);
-    const operand = try sema.resolveInst(extra.operand);
+    const operand = sema.resolveInst(extra.operand);
     const operand_ty = sema.typeOf(operand);
 
     if (!typeIsDestructurable(operand_ty, zcu)) {
@@ -4813,8 +4812,8 @@ fn zirStoreToInferredPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi
     const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(pl_node.src_node);
     const bin = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data;
-    const ptr = try sema.resolveInst(bin.lhs);
-    const operand = try sema.resolveInst(bin.rhs);
+    const ptr = sema.resolveInst(bin.lhs);
+    const operand = sema.resolveInst(bin.rhs);
     const ptr_inst = ptr.toIndex().?;
     const air_datas = sema.air_instructions.items(.data);
 
@@ -4860,7 +4859,7 @@ fn storeToInferredAllocComptime(
     const operand_ty = sema.typeOf(operand);
     // There will be only one store_to_inferred_ptr because we are running at comptime.
     // The alloc will turn into a Decl or a ComptimeAlloc.
-    const operand_val = try sema.resolveValue(operand) orelse {
+    const operand_val = sema.resolveValue(operand) orelse {
         return sema.failWithNeededComptime(block, src, .{ .simple = .stored_to_comptime_var });
     };
     const alloc_ty = try pt.ptrType(.{
@@ -4909,8 +4908,8 @@ fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!v
     const inst_data = zir_datas[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const ptr = try sema.resolveInst(extra.lhs);
-    const operand = try sema.resolveInst(extra.rhs);
+    const ptr = sema.resolveInst(extra.lhs);
+    const operand = sema.resolveInst(extra.rhs);
 
     const is_ret = if (extra.lhs.toIndex()) |ptr_index|
         zir_tags[@intFromEnum(ptr_index)] == .ret_ptr
@@ -5044,9 +5043,9 @@ fn zirCompileLog(
     for (args, 0..) |arg_ref, i| {
         if (i != 0) writer.writeAll(", ") catch return error.OutOfMemory;
 
-        const arg = try sema.resolveInst(arg_ref);
+        const arg = sema.resolveInst(arg_ref);
         const arg_ty = sema.typeOf(arg);
-        if (try sema.resolveValue(arg)) |val| {
+        if (sema.resolveValue(arg)) |val| {
             writer.print("@as({f}, {f})", .{
                 arg_ty.fmt(pt), val.fmtValueSema(pt, sema),
             }) catch return error.OutOfMemory;
@@ -5094,7 +5093,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const msg_inst = try sema.resolveInst(inst_data.operand);
+    const msg_inst = sema.resolveInst(inst_data.operand);
 
     const arg_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const coerced_msg = try sema.coerce(block, .slice_const_u8, msg_inst, arg_src);
@@ -5464,7 +5463,7 @@ fn resolveBlockBody(
                 const break_data = sema.code.instructions.items(.data)[@intFromEnum(break_inst)].@"break";
                 const extra = sema.code.extraData(Zir.Inst.Break, break_data.payload_index).data;
                 if (extra.block_inst == body_inst) {
-                    return try sema.resolveInst(break_data.operand);
+                    return sema.resolveInst(break_data.operand);
                 } else {
                     return error.ComptimeBreak;
                 }
@@ -5555,7 +5554,7 @@ fn resolveAnalyzedBlock(
         // Okay, we need a runtime block. If the value is comptime-known, the
         // block should just return void, and we return the merge result
         // directly. Otherwise, we can defer to the logic below.
-        if (try sema.resolveValue(merges.results.items[0])) |result_val| {
+        if (sema.resolveValue(merges.results.items[0])) |result_val| {
             // Create a block containing all instruction from the body.
             try parent_block.instructions.append(gpa, merges.block_inst);
             switch (block_tag) {
@@ -5714,7 +5713,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const ptr_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const options_src = block.builtinCallArgSrc(inst_data.src_node, 1);
 
-    const ptr = try sema.resolveInst(extra.exported);
+    const ptr = sema.resolveInst(extra.exported);
     const ptr_val = try sema.resolveConstDefinedValue(block, ptr_src, ptr, .{ .simple = .export_target });
     const ptr_ty = ptr_val.typeOf(zcu);
 
@@ -5878,7 +5877,7 @@ fn zirBreak(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) CompileError
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"break";
     const extra = sema.code.extraData(Zir.Inst.Break, inst_data.payload_index).data;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const zir_block = extra.block_inst;
 
     var block = start_block;
@@ -5912,7 +5911,7 @@ fn zirSwitchContinue(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) Com
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"break";
     const extra = sema.code.extraData(Zir.Inst.Break, inst_data.payload_index).data;
     const operand_src = start_block.nodeOffset(extra.operand_src_node.unwrap().?);
-    const uncoerced_operand = try sema.resolveInst(inst_data.operand);
+    const uncoerced_operand = sema.resolveInst(inst_data.operand);
     const switch_inst = extra.block_inst;
 
     switch (sema.code.instructions.items(.tag)[@intFromEnum(switch_inst)]) {
@@ -5921,7 +5920,7 @@ fn zirSwitchContinue(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) Com
         else => unreachable, // assertion failure
     }
 
-    const operand_ty = (try sema.resolveInst(switch_inst.toRef())).toType();
+    const operand_ty = (sema.resolveInst(switch_inst.toRef())).toType();
     const operand = try sema.coerce(start_block, operand_ty, uncoerced_operand, operand_src);
     try sema.validateRuntimeValue(start_block, operand_src, operand);
 
@@ -5988,7 +5987,7 @@ fn zirDbgVar(
     air_tag: Air.Inst.Tag,
 ) CompileError!void {
     const str_op = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_op;
-    const operand = try sema.resolveInst(str_op.operand);
+    const operand = sema.resolveInst(str_op.operand);
     const name = str_op.getStr(sema.code);
     try sema.addDbgVar(block, operand, air_tag, name);
 }
@@ -6012,7 +6011,7 @@ fn addDbgVar(
     };
     if (val_ty.comptimeOnly(zcu)) return;
     if (!val_ty.hasRuntimeBits(zcu)) return;
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         if (operand_val.canMutateComptimeVarState(zcu)) return;
     }
 
@@ -6151,7 +6150,7 @@ fn funcDeclSrcInst(sema: *Sema, func_inst: Air.Inst.Ref) !?InternPool.TrackedIns
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const func_val = try sema.resolveValue(func_inst) orelse return null;
+    const func_val = sema.resolveValue(func_inst) orelse return null;
     if (func_val.isUndef(zcu)) return null;
     const nav = switch (ip.indexToKey(func_val.toIntern())) {
         .@"extern" => |e| e.owner_nav,
@@ -6323,9 +6322,9 @@ fn zirCall(
     const pop_error_return_trace = extra.data.flags.pop_error_return_trace;
 
     const callee: ResolvedFieldCallee = switch (kind) {
-        .direct => .{ .direct = try sema.resolveInst(extra.data.callee) },
+        .direct => .{ .direct = sema.resolveInst(extra.data.callee) },
         .field => blk: {
-            const object_ptr = try sema.resolveInst(extra.data.obj_ptr);
+            const object_ptr = sema.resolveInst(extra.data.obj_ptr);
             const field_name = try zcu.intern_pool.getOrPutString(
                 gpa,
                 io,
@@ -7097,7 +7096,7 @@ fn analyzeCall(
 
                 if (is_comptime) {
                     // We already emitted an error if the argument isn't comptime-known.
-                    comptime_arg.* = (try sema.resolveValue(arg)).?.toIntern();
+                    comptime_arg.* = sema.resolveValue(arg).?.toIntern();
                 } else {
                     comptime_arg.* = .none;
                     if (is_noalias) {
@@ -7139,7 +7138,7 @@ fn analyzeCall(
         };
 
         ref_func: {
-            const runtime_func_val = try sema.resolveValue(runtime_func) orelse break :ref_func;
+            const runtime_func_val = sema.resolveValue(runtime_func) orelse break :ref_func;
             if (!ip.isFuncBody(runtime_func_val.toIntern())) break :ref_func;
             const orig_fn_index = ip.unwrapCoercedFunc(runtime_func_val.toIntern());
             try sema.addReferenceEntry(block, call_src, .wrap(.{ .func = orig_fn_index }));
@@ -7285,14 +7284,14 @@ fn analyzeCall(
         if (zcu.comp.config.incremental) break :m false;
         if (!block.isComptime()) break :m false;
         for (args) |a| {
-            const val = (try sema.resolveValue(a)).?;
+            const val = sema.resolveValue(a).?;
             if (val.canMutateComptimeVarState(zcu)) break :m false;
         }
         break :m true;
     };
     const memoized_arg_values: []const InternPool.Index = if (want_memoize) arg_vals: {
         const vals = try sema.arena.alloc(InternPool.Index, args.len);
-        for (vals, args) |*v, a| v.* = (try sema.resolveValue(a)).?.toIntern();
+        for (vals, args) |*v, a| v.* = sema.resolveValue(a).?.toIntern();
         break :arg_vals vals;
     } else undefined;
     if (want_memoize) memoize: {
@@ -7453,7 +7452,7 @@ fn analyzeCall(
         return .unreachable_value;
     }
 
-    const maybe_opv: Air.Inst.Ref = if (try sema.resolveValue(result_raw)) |result_val| r: {
+    const maybe_opv: Air.Inst.Ref = if (sema.resolveValue(result_raw)) |result_val| r: {
         const val_resolved = try sema.resolveAdHocInferredErrorSet(block, call_src, result_val.toIntern());
         break :r Air.internedToRef(val_resolved);
     } else r: {
@@ -7465,7 +7464,7 @@ fn analyzeCall(
     };
 
     if (block.isComptime()) {
-        const result_val = (try sema.resolveValue(maybe_opv)).?;
+        const result_val = sema.resolveValue(maybe_opv).?;
         if (want_memoize and sema.allow_memoize and !result_val.canMutateComptimeVarState(zcu)) {
             _ = try pt.intern(.{ .memoized_call = .{
                 .func = func_val.?.toIntern(),
@@ -7641,7 +7640,7 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
     const len = try sema.resolveInt(block, len_src, extra.len, .usize, .{ .simple = .array_length });
     const elem_type = try sema.resolveType(block, elem_src, extra.elem_type);
     try sema.validateArrayElemType(block, elem_type, elem_src);
-    const uncasted_sentinel = try sema.resolveInst(extra.sentinel);
+    const uncasted_sentinel = sema.resolveInst(extra.sentinel);
     const sentinel = try sema.coerce(block, elem_type, uncasted_sentinel, sentinel_src);
     const sentinel_val = try sema.resolveConstDefinedValue(block, sentinel_src, sentinel, .{ .simple = .array_sentinel });
     if (sentinel_val.canMutateComptimeVarState(zcu)) {
@@ -7757,11 +7756,11 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
-    const uncasted_operand = try sema.resolveInst(extra.operand);
+    const uncasted_operand = sema.resolveInst(extra.operand);
     const operand = try sema.coerce(block, .anyerror, uncasted_operand, operand_src);
     const err_int_ty = try pt.errorIntType();
 
-    if (try sema.resolveValue(operand)) |val| {
+    if (sema.resolveValue(operand)) |val| {
         if (val.isUndef(zcu)) {
             return pt.undefRef(err_int_ty);
         }
@@ -7801,7 +7800,7 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
-    const uncasted_operand = try sema.resolveInst(extra.operand);
+    const uncasted_operand = sema.resolveInst(extra.operand);
     const err_int_ty = try pt.errorIntType();
     const operand = try sema.coerce(block, err_int_ty, uncasted_operand, operand_src);
 
@@ -7848,8 +7847,8 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     if (sema.typeOf(lhs).zigTypeTag(zcu) == .bool and sema.typeOf(rhs).zigTypeTag(zcu) == .bool) {
         const msg = msg: {
             const msg = try sema.errMsg(lhs_src, "expected error set type, found 'bool'", .{});
@@ -7984,7 +7983,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
 
     const enum_tag: Air.Inst.Ref = switch (operand_ty.zigTypeTag(zcu)) {
@@ -8018,7 +8017,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         });
     }
 
-    if (try sema.resolveValue(enum_tag)) |enum_tag_val| {
+    if (sema.resolveValue(enum_tag)) |enum_tag_val| {
         if (enum_tag_val.isUndef(zcu)) return pt.undefRef(int_tag_ty);
         return .fromValue(enum_tag_val.intFromEnum(zcu));
     }
@@ -8035,7 +8034,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@enumFromInt");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
 
     if (dest_ty.zigTypeTag(zcu) != .@"enum") {
@@ -8044,7 +8043,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     try sema.ensureLayoutResolved(dest_ty);
     _ = try sema.checkIntType(block, operand_src, operand_ty);
 
-    if (try sema.resolveValue(operand)) |int_val| {
+    if (sema.resolveValue(operand)) |int_val| {
         if (dest_ty.isNonexhaustiveEnum(zcu)) {
             const int_tag_ty = dest_ty.intTagType(zcu);
             if (int_val.intFitsInType(int_tag_ty, null, zcu)) {
@@ -8099,7 +8098,7 @@ fn zirOptionalPayloadPtr(
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const optional_ptr = try sema.resolveInst(inst_data.operand);
+    const optional_ptr = sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
 
     const ptr_ty = sema.typeOf(optional_ptr);
@@ -8193,7 +8192,7 @@ fn zirOptionalPayload(
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const result_ty = switch (operand_ty.zigTypeTag(zcu)) {
         .optional => operand_ty.optionalChild(zcu),
@@ -8253,7 +8252,7 @@ fn zirErrUnionPayload(
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_src = src;
     const err_union_ty = sema.typeOf(operand);
     if (err_union_ty.zigTypeTag(zcu) != .error_union) {
@@ -8309,7 +8308,7 @@ fn zirErrUnionPayloadPtr(
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
 
     const ptr_ty = sema.typeOf(operand);
@@ -8402,7 +8401,7 @@ fn zirErrUnionCode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     return sema.analyzeErrUnionCode(block, src, operand);
 }
 
@@ -8438,7 +8437,7 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     return sema.analyzeErrUnionCodePtr(block, src, operand);
 }
 
@@ -9201,7 +9200,7 @@ fn analyzeAs(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const operand = try sema.resolveInst(zir_operand);
+    const operand = sema.resolveInst(zir_operand);
     const dest_ty = try sema.resolveTypeOrPoison(block, src, zir_dest_type) orelse return operand;
     switch (dest_ty.zigTypeTag(zcu)) {
         .@"opaque" => return sema.fail(block, src, "cannot cast to opaque type '{f}'", .{dest_ty.fmt(pt)}),
@@ -9227,7 +9226,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ptr_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const ptr_ty = operand_ty.scalarType(zcu);
     const is_vector = operand_ty.zigTypeTag(zcu) == .vector;
@@ -9238,7 +9237,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const len = if (is_vector) operand_ty.vectorLen(zcu) else undefined;
     const dest_ty: Type = if (is_vector) try pt.vectorType(.{ .child = .usize_type, .len = len }) else .usize;
 
-    if (try sema.resolveValue(operand)) |operand_val| ct: {
+    if (sema.resolveValue(operand)) |operand_val| ct: {
         if (!is_vector) {
             if (operand_val.isUndef(zcu)) {
                 return .undef_usize;
@@ -9297,7 +9296,7 @@ fn zirFieldPtrLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
         sema.code.nullTerminatedString(extra.field_name_start),
         .no_embedded_nulls,
     );
-    const object_ptr = try sema.resolveInst(extra.lhs);
+    const object_ptr = sema.resolveInst(extra.lhs);
     return fieldPtrLoad(sema, block, src, object_ptr, field_name, field_name_src);
 }
 
@@ -9322,7 +9321,7 @@ fn zirFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         sema.code.nullTerminatedString(extra.field_name_start),
         .no_embedded_nulls,
     );
-    const object_ptr = try sema.resolveInst(extra.lhs);
+    const object_ptr = sema.resolveInst(extra.lhs);
     return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src, false);
 }
 
@@ -9347,7 +9346,7 @@ fn zirStructInitFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi
         sema.code.nullTerminatedString(extra.field_name_start),
         .no_embedded_nulls,
     );
-    const object_ptr = try sema.resolveInst(extra.lhs);
+    const object_ptr = sema.resolveInst(extra.lhs);
     const struct_ty = sema.typeOf(object_ptr).childType(zcu);
     switch (struct_ty.zigTypeTag(zcu)) {
         .@"struct", .@"union" => {
@@ -9367,7 +9366,7 @@ fn zirFieldPtrNamedLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
     const src = block.nodeOffset(inst_data.src_node);
     const field_name_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data;
-    const object_ptr = try sema.resolveInst(extra.lhs);
+    const object_ptr = sema.resolveInst(extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, field_name_src, extra.field_name, .{ .simple = .field_name });
     return fieldPtrLoad(sema, block, src, object_ptr, field_name, field_name_src);
 }
@@ -9380,7 +9379,7 @@ fn zirFieldPtrNamed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const src = block.nodeOffset(inst_data.src_node);
     const field_name_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data;
-    const object_ptr = try sema.resolveInst(extra.lhs);
+    const object_ptr = sema.resolveInst(extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, field_name_src, extra.field_name, .{ .simple = .field_name });
     return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src, false);
 }
@@ -9395,7 +9394,7 @@ fn zirIntCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
 
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@intCast");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
 
     return sema.intCast(block, block.nodeOffset(inst_data.src_node), dest_ty, src, operand, operand_src);
 }
@@ -9470,7 +9469,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
 
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@bitCast");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
     switch (dest_ty.zigTypeTag(zcu)) {
         .@"anyframe",
@@ -9638,7 +9637,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@floatCast");
     const dest_scalar_ty = dest_ty.scalarType(zcu);
 
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
     const operand_scalar_ty = operand_ty.scalarType(zcu);
 
@@ -9667,7 +9666,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         ),
     }
 
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         if (!is_vector) {
             return Air.internedToRef((try operand_val.floatCast(dest_ty, pt)).toIntern());
         }
@@ -9699,8 +9698,8 @@ fn zirElemVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const array = try sema.resolveInst(extra.lhs);
-    const elem_index = try sema.resolveInst(extra.rhs);
+    const array = sema.resolveInst(extra.lhs);
+    const elem_index = sema.resolveInst(extra.rhs);
     return sema.elemVal(block, src, array, elem_index, src, false);
 }
 
@@ -9712,8 +9711,8 @@ fn zirElemPtrLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const src = block.nodeOffset(inst_data.src_node);
     const elem_index_src = block.src(.{ .node_offset_array_access_index = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const uncoerced_elem_index = try sema.resolveInst(extra.rhs);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const uncoerced_elem_index = sema.resolveInst(extra.rhs);
     if (try sema.resolveDefinedValue(block, src, array_ptr)) |array_ptr_val| {
         const array_ptr_ty = sema.typeOf(array_ptr);
         if (try sema.pointerDeref(block, src, array_ptr_val, array_ptr_ty)) |array_val| {
@@ -9731,7 +9730,7 @@ fn zirElemValImm(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].elem_val_imm;
-    const array = try sema.resolveInst(inst_data.operand);
+    const array = sema.resolveInst(inst_data.operand);
     const elem_index = try sema.pt.intRef(.usize, inst_data.idx);
     return sema.elemVal(block, LazySrcLoc.unneeded, array, elem_index, LazySrcLoc.unneeded, false);
 }
@@ -9745,8 +9744,8 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const elem_index = try sema.resolveInst(extra.rhs);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const elem_index = sema.resolveInst(extra.rhs);
     const indexable_ty = sema.typeOf(array_ptr);
     if (indexable_ty.zigTypeTag(zcu) != .pointer) {
         const capture_src = block.src(.{ .for_capture_from_input = inst_data.src_node });
@@ -9775,8 +9774,8 @@ fn zirElemPtrNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const src = block.nodeOffset(inst_data.src_node);
     const elem_index_src = block.src(.{ .node_offset_array_access_index = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const uncoerced_elem_index = try sema.resolveInst(extra.rhs);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const uncoerced_elem_index = sema.resolveInst(extra.rhs);
     const elem_index = try sema.coerce(block, .usize, uncoerced_elem_index, elem_index_src);
     return sema.elemPtr(block, src, array_ptr, elem_index, elem_index_src, false, true);
 }
@@ -9790,7 +9789,7 @@ fn zirArrayInitElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.ptr);
+    const array_ptr = sema.resolveInst(extra.ptr);
     const elem_index = try pt.intRef(.usize, extra.index);
     const array_ty = sema.typeOf(array_ptr).childType(zcu);
     switch (array_ty.zigTypeTag(zcu)) {
@@ -9809,8 +9808,8 @@ fn zirSliceStart(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.SliceStart, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const start = try sema.resolveInst(extra.start);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const start = sema.resolveInst(extra.start);
     const ptr_src = block.src(.{ .node_offset_slice_ptr = inst_data.src_node });
     const start_src = block.src(.{ .node_offset_slice_start = inst_data.src_node });
     const end_src = block.src(.{ .node_offset_slice_end = inst_data.src_node });
@@ -9825,9 +9824,9 @@ fn zirSliceEnd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.SliceEnd, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const start = try sema.resolveInst(extra.start);
-    const end = try sema.resolveInst(extra.end);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const start = sema.resolveInst(extra.start);
+    const end = sema.resolveInst(extra.end);
     const ptr_src = block.src(.{ .node_offset_slice_ptr = inst_data.src_node });
     const start_src = block.src(.{ .node_offset_slice_start = inst_data.src_node });
     const end_src = block.src(.{ .node_offset_slice_end = inst_data.src_node });
@@ -9843,10 +9842,10 @@ fn zirSliceSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const src = block.nodeOffset(inst_data.src_node);
     const sentinel_src = block.src(.{ .node_offset_slice_sentinel = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.SliceSentinel, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const start = try sema.resolveInst(extra.start);
-    const end: Air.Inst.Ref = if (extra.end == .none) .none else try sema.resolveInst(extra.end);
-    const sentinel = try sema.resolveInst(extra.sentinel);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const start = sema.resolveInst(extra.start);
+    const end: Air.Inst.Ref = if (extra.end == .none) .none else sema.resolveInst(extra.end);
+    const sentinel = sema.resolveInst(extra.sentinel);
     const ptr_src = block.src(.{ .node_offset_slice_ptr = inst_data.src_node });
     const start_src = block.src(.{ .node_offset_slice_start = inst_data.src_node });
     const end_src = block.src(.{ .node_offset_slice_end = inst_data.src_node });
@@ -9861,10 +9860,10 @@ fn zirSliceLength(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.SliceLength, inst_data.payload_index).data;
-    const array_ptr = try sema.resolveInst(extra.lhs);
-    const start = try sema.resolveInst(extra.start);
-    const len = try sema.resolveInst(extra.len);
-    const sentinel = if (extra.sentinel == .none) .none else try sema.resolveInst(extra.sentinel);
+    const array_ptr = sema.resolveInst(extra.lhs);
+    const start = sema.resolveInst(extra.start);
+    const len = sema.resolveInst(extra.len);
+    const sentinel = if (extra.sentinel == .none) .none else sema.resolveInst(extra.sentinel);
     const ptr_src = block.src(.{ .node_offset_slice_ptr = inst_data.src_node });
     const start_src = block.src(.{ .node_offset_slice_start = extra.start_src_node_offset });
     const end_src = block.src(.{ .node_offset_slice_end = inst_data.src_node });
@@ -9892,7 +9891,7 @@ fn zirSliceSentinelTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     // This is like the logic in `analyzeSlice`; since we've evaluated the LHS as an lvalue, we will
     // have a double pointer if it was already a pointer.
 
-    const lhs_ptr_ty = sema.typeOf(try sema.resolveInst(inst_data.operand));
+    const lhs_ptr_ty = sema.typeOf(sema.resolveInst(inst_data.operand));
     const lhs_ty = switch (lhs_ptr_ty.zigTypeTag(zcu)) {
         .pointer => lhs_ptr_ty.childType(zcu),
         else => return sema.fail(block, ptr_src, "expected pointer, found '{f}'", .{lhs_ptr_ty.fmt(pt)}),
@@ -9972,7 +9971,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     // Lastly, we analyze the error prong(s) as a regular switch.
 
     const raw_switch_operand, const non_err_cond, const non_err_hint = non_err: {
-        const eu_maybe_ptr = try sema.resolveInst(zir_switch.main_operand);
+        const eu_maybe_ptr = sema.resolveInst(zir_switch.main_operand);
         const err_union_ty: Type = err_union_ty: {
             const raw_operand_ty = sema.typeOf(eu_maybe_ptr);
             if (!non_err_case.operand_is_ref) break :err_union_ty raw_operand_ty;
@@ -10106,7 +10105,7 @@ fn zirSwitchBlock(
     defer child_block.instructions.deinit(sema.gpa);
     defer merges.deinit(sema.gpa);
 
-    const raw_operand = try sema.resolveInst(zir_switch.main_operand);
+    const raw_operand = sema.resolveInst(zir_switch.main_operand);
     const validated_switch = try sema.validateSwitchBlock(block, raw_operand, operand_is_ref, inst, &zir_switch);
     const maybe_ref = try sema.analyzeSwitchBlock(block, &child_block, raw_operand, operand_is_ref, merges, inst, &zir_switch, &validated_switch);
     return maybe_ref orelse {
@@ -10234,7 +10233,7 @@ fn analyzeSwitchBlock(
                     if (extra.block_inst != switch_inst) return error.ComptimeBreak;
                     // This is a `switch_continue` targeting this block. Change the operand and start over.
                     const new_operand_src = child_block.nodeOffset(extra.operand_src_node.unwrap().?);
-                    const new_operand_uncoerced = try sema.resolveInst(break_inst.data.@"break".operand);
+                    const new_operand_uncoerced = sema.resolveInst(break_inst.data.@"break".operand);
                     const new_operand = try sema.coerce(child_block, raw_operand_ty, new_operand_uncoerced, new_operand_src);
 
                     try sema.emitBackwardBranch(child_block, src);
@@ -12641,7 +12640,7 @@ fn resolveSwitchItem(
             // We allow prongs with errors which are not part of the error set
             // being switched on if their prong body is `=> comptime unreachable,`.
             switch (try sema.coerceInMemoryAllowedErrorSets(block, item_ty, uncoerced_ty, item_src, item_src)) {
-                .ok => if (try sema.resolveValue(uncoerced)) |uncoerced_val| {
+                .ok => if (sema.resolveValue(uncoerced)) |uncoerced_val| {
                     break :item_ref try sema.coerceInMemory(uncoerced_val, item_ty);
                 },
                 .missing_error => if (prong_is_comptime_unreach) {
@@ -12805,7 +12804,7 @@ fn maybeErrorUnwrap(
             },
             .panic => {
                 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-                const msg_inst = try sema.resolveInst(inst_data.operand);
+                const msg_inst = sema.resolveInst(inst_data.operand);
 
                 const panic_fn = try getBuiltin(sema, operand_src, .@"panic.call");
                 const args: [2]Air.Inst.Ref = .{ msg_inst, .null_value };
@@ -12828,7 +12827,7 @@ fn maybeErrorUnwrapCondbr(sema: *Sema, block: *Block, body: []const Zir.Inst.Ind
     if (sema.code.instructions.items(.tag)[@intFromEnum(index)] != .is_non_err) return;
 
     const err_inst_data = sema.code.instructions.items(.data)[@intFromEnum(index)].un_node;
-    const err_operand = try sema.resolveInst(err_inst_data.operand);
+    const err_operand = sema.resolveInst(err_inst_data.operand);
     const operand_ty = sema.typeOf(err_operand);
     if (operand_ty.zigTypeTag(zcu) == .error_set) {
         try sema.maybeErrorUnwrapComptime(block, body, err_operand);
@@ -12960,7 +12959,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         .zon => {
             const res_ty: InternPool.Index = b: {
                 if (extra.res_ty == .none) break :b .none;
-                const res_ty_inst = try sema.resolveInst(extra.res_ty);
+                const res_ty_inst = sema.resolveInst(extra.res_ty);
                 const res_ty = try sema.analyzeAsType(block, operand_src, .type, res_ty_inst);
                 if (res_ty.isGenericPoison()) break :b .none;
                 break :b res_ty.toIntern();
@@ -13048,8 +13047,8 @@ fn zirShl(
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
 
@@ -13075,8 +13074,8 @@ fn zirShl(
     // we already know `scalar_rhs_ty` is valid for `.shl` -- we only need to validate for `.shl_sat`.
     if (air_tag == .shl_sat) _ = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
 
-    const maybe_lhs_val = try sema.resolveValue(lhs);
-    const maybe_rhs_val = try sema.resolveValue(rhs);
+    const maybe_lhs_val = sema.resolveValue(lhs);
+    const maybe_rhs_val = sema.resolveValue(rhs);
 
     const runtime_src = rs: {
         if (maybe_rhs_val) |rhs_val| {
@@ -13238,8 +13237,8 @@ fn zirShr(
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
 
@@ -13258,8 +13257,8 @@ fn zirShr(
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     const scalar_ty = lhs_ty.scalarType(zcu);
 
-    const maybe_lhs_val = try sema.resolveValue(lhs);
-    const maybe_rhs_val = try sema.resolveValue(rhs);
+    const maybe_lhs_val = sema.resolveValue(lhs);
+    const maybe_rhs_val = sema.resolveValue(rhs);
 
     const runtime_src = rs: {
         if (maybe_rhs_val) |rhs_val| {
@@ -13371,8 +13370,8 @@ fn zirBitwise(
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
@@ -13394,8 +13393,8 @@ fn zirBitwise(
     const runtime_src = runtime: {
         // TODO: ask the linker what kind of relocations are available, and
         // in some cases emit a Value that means "this decl's address AND'd with this operand".
-        if (try sema.resolveValue(casted_lhs)) |lhs_val| {
-            if (try sema.resolveValue(casted_rhs)) |rhs_val| {
+        if (sema.resolveValue(casted_lhs)) |lhs_val| {
+            if (sema.resolveValue(casted_rhs)) |rhs_val| {
                 const result_val = switch (air_tag) {
                     // zig fmt: off
                     .bit_and => try arith.bitwiseBin(sema, resolved_type, lhs_val, rhs_val, .@"and"),
@@ -13423,7 +13422,7 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const scalar_ty = operand_ty.scalarType(zcu);
     const scalar_tag = scalar_ty.zigTypeTag(zcu);
@@ -13441,7 +13440,7 @@ fn analyzeBitNot(
     src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const operand_ty = sema.typeOf(operand);
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         const result_val = try arith.bitwiseNot(sema, operand_ty, operand_val);
         return Air.internedToRef(result_val.toIntern());
     }
@@ -13551,8 +13550,8 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const src = block.nodeOffset(inst_data.src_node);
@@ -13646,12 +13645,12 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     };
 
     const runtime_src = if (switch (lhs_ty.zigTypeTag(zcu)) {
-        .array, .@"struct" => try sema.resolveValue(lhs),
+        .array, .@"struct" => sema.resolveValue(lhs),
         .pointer => try sema.resolveDefinedValue(block, lhs_src, lhs),
         else => unreachable,
     }) |lhs_val| rs: {
         if (switch (rhs_ty.zigTypeTag(zcu)) {
-            .array, .@"struct" => try sema.resolveValue(rhs),
+            .array, .@"struct" => sema.resolveValue(rhs),
             .pointer => try sema.resolveDefinedValue(block, rhs_src, rhs),
             else => unreachable,
         }) |rhs_val| {
@@ -13989,7 +13988,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.ArrayMul, inst_data.payload_index).data;
-    const uncoerced_lhs = try sema.resolveInst(extra.lhs);
+    const uncoerced_lhs = sema.resolveInst(extra.lhs);
     const uncoerced_lhs_ty = sema.typeOf(uncoerced_lhs);
     const src: LazySrcLoc = block.nodeOffset(inst_data.src_node);
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
@@ -14068,7 +14067,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const ptr_addrspace = if (lhs_ty.zigTypeTag(zcu) == .pointer) lhs_ty.ptrAddressSpace(zcu) else null;
     const lhs_len = try sema.usizeCast(block, lhs_src, lhs_info.len);
 
-    if (try sema.resolveValue(lhs)) |lhs_val| ct: {
+    if (sema.resolveValue(lhs)) |lhs_val| ct: {
         const lhs_sub_val = if (lhs_ty.isSinglePointer(zcu))
             try sema.pointerDeref(block, lhs_src, lhs_val, lhs_ty) orelse break :ct
         else if (lhs_ty.isSlice(zcu))
@@ -14157,7 +14156,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const lhs_src = src;
     const rhs_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
 
-    const rhs = try sema.resolveInst(inst_data.operand);
+    const rhs = sema.resolveInst(inst_data.operand);
     const rhs_ty = sema.typeOf(rhs);
     const rhs_scalar_ty = rhs_ty.scalarType(zcu);
 
@@ -14170,7 +14169,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 
     if (rhs_scalar_ty.isAnyFloat()) {
         // We handle float negation here to ensure negative zero is represented in the bits.
-        if (try sema.resolveValue(rhs)) |rhs_val| {
+        if (sema.resolveValue(rhs)) |rhs_val| {
             const result = try arith.negateFloat(sema, rhs_ty, rhs_val);
             return Air.internedToRef(result.toIntern());
         }
@@ -14190,7 +14189,7 @@ fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const lhs_src = src;
     const rhs_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
 
-    const rhs = try sema.resolveInst(inst_data.operand);
+    const rhs = sema.resolveInst(inst_data.operand);
     const rhs_ty = sema.typeOf(rhs);
     const rhs_scalar_ty = rhs_ty.scalarType(zcu);
 
@@ -14218,8 +14217,8 @@ fn zirArithmetic(
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
 
     return sema.analyzeArithmetic(block, zir_tag, lhs, rhs, src, lhs_src, rhs_src, safety);
 }
@@ -14232,8 +14231,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14255,8 +14254,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     if ((lhs_ty.zigTypeTag(zcu) == .comptime_float and rhs_ty.zigTypeTag(zcu) == .comptime_int) or
         (lhs_ty.zigTypeTag(zcu) == .comptime_int and rhs_ty.zigTypeTag(zcu) == .comptime_float))
@@ -14341,8 +14340,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14364,8 +14363,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_exact);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     // Because `@divExact` can trigger Illegal Behavior, undefined operands trigger Illegal Behavior.
 
@@ -14437,8 +14436,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14460,8 +14459,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_floor);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -14502,8 +14501,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14525,8 +14524,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_trunc);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -14713,8 +14712,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14737,8 +14736,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod_rem);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     const lhs_maybe_negative = a: {
         if (lhs_scalar_ty.isUnsignedInt(zcu)) break :a false;
@@ -14814,8 +14813,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14836,8 +14835,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -14878,8 +14877,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const lhs_zig_ty_tag = lhs_ty.zigTypeTag(zcu);
@@ -14900,8 +14899,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .rem);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     const allow_div_zero = !is_int and
         resolved_type.toIntern() != .comptime_float_type and
@@ -14949,8 +14948,8 @@ fn zirOverflowArithmetic(
     const lhs_src = block.builtinCallArgSrc(extra.node, 0);
     const rhs_src = block.builtinCallArgSrc(extra.node, 1);
 
-    const uncasted_lhs = try sema.resolveInst(extra.lhs);
-    const uncasted_rhs = try sema.resolveInst(extra.rhs);
+    const uncasted_lhs = sema.resolveInst(extra.lhs);
+    const uncasted_rhs = sema.resolveInst(extra.rhs);
 
     const lhs_ty = sema.typeOf(uncasted_lhs);
     const rhs_ty = sema.typeOf(uncasted_rhs);
@@ -14980,8 +14979,8 @@ fn zirOverflowArithmetic(
         return sema.fail(block, src, "expected vector of integers or integer tag type, found '{f}'", .{dest_ty.fmt(pt)});
     }
 
-    const maybe_lhs_val = try sema.resolveValue(lhs);
-    const maybe_rhs_val = try sema.resolveValue(rhs);
+    const maybe_lhs_val = sema.resolveValue(lhs);
+    const maybe_rhs_val = sema.resolveValue(rhs);
 
     const tuple_ty = try pt.overflowArithmeticTupleType(dest_ty);
     const overflow_ty: Type = .fromInterned(ip.indexToKey(tuple_ty.toIntern()).tuple_type.types.get(ip)[1]);
@@ -15163,7 +15162,7 @@ fn zirOverflowArithmetic(
     };
 
     if (result.inst != .none) {
-        if (try sema.resolveValue(result.inst)) |some| {
+        if (sema.resolveValue(result.inst)) |some| {
             result.wrapped = some;
             result.inst = .none;
         }
@@ -15227,8 +15226,8 @@ fn analyzeArithmetic(
                 }
 
                 const runtime_src = runtime_src: {
-                    if (try sema.resolveValue(lhs)) |lhs_value| {
-                        if (try sema.resolveValue(rhs)) |rhs_value| {
+                    if (sema.resolveValue(lhs)) |lhs_value| {
+                        if (sema.resolveValue(rhs)) |rhs_value| {
                             const lhs_ptr = switch (zcu.intern_pool.indexToKey(lhs_value.toIntern())) {
                                 .undef => return sema.failWithUseOfUndef(block, lhs_src, null),
                                 .ptr => |ptr| ptr,
@@ -15307,8 +15306,8 @@ fn analyzeArithmetic(
         else => unreachable,
     };
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
 
     if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
@@ -15380,7 +15379,7 @@ fn analyzePtrArithmetic(
     const offset = try sema.coerce(block, .usize, uncasted_offset, offset_src);
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const opt_ptr_val = try sema.resolveValue(ptr);
+    const opt_ptr_val = sema.resolveValue(ptr);
     const opt_off_val = try sema.resolveDefinedValue(block, offset_src, offset);
     const ptr_ty = sema.typeOf(ptr);
     const ptr_info = ptr_ty.ptrInfo(zcu);
@@ -15473,7 +15472,7 @@ fn zirLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.In
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ptr_src = src; // TODO better source location
-    const ptr = try sema.resolveInst(inst_data.operand);
+    const ptr = sema.resolveInst(inst_data.operand);
     return sema.analyzeLoad(block, src, ptr, ptr_src);
 }
 
@@ -15547,7 +15546,7 @@ fn zirAsm(
             const out_ty = try sema.resolveType(block, ret_ty_src, output.data.operand);
             expr_ty = Air.internedToRef(out_ty.toIntern());
         } else {
-            const inst = try sema.resolveInst(output.data.operand);
+            const inst = sema.resolveInst(output.data.operand);
             if (!sema.checkRuntimeValue(inst)) {
                 const output_name = try ip.getOrPutString(gpa, io, pt.tid, name, .no_embedded_nulls);
                 return sema.failWithContainsReferenceToComptimeVar(block, output_src, output_name, "assembly output", .fromInterned(inst.toInterned().?));
@@ -15577,7 +15576,7 @@ fn zirAsm(
         } });
         extra_i = input.end;
 
-        const uncasted_arg = try sema.resolveInst(input.data.operand);
+        const uncasted_arg = sema.resolveInst(input.data.operand);
         const name = sema.code.nullTerminatedString(input.data.name);
         if (!sema.checkRuntimeValue(uncasted_arg)) {
             const input_name = try ip.getOrPutString(gpa, io, pt.tid, name, .no_embedded_nulls);
@@ -15600,7 +15599,7 @@ fn zirAsm(
     const clobbers = if (extra.data.clobbers == .none) empty: {
         const clobbers_ty = try sema.getBuiltinType(src, .@"assembly.Clobbers");
         break :empty try sema.structInitEmpty(block, clobbers_ty, src, src);
-    } else try sema.resolveInst(extra.data.clobbers); // Already coerced by AstGen.
+    } else sema.resolveInst(extra.data.clobbers); // Already coerced by AstGen.
     const clobbers_val = try sema.resolveConstDefinedValue(block, src, clobbers, .{ .simple = .clobber });
     needed_capacity += asm_source.len / 4 + 1;
 
@@ -15666,8 +15665,8 @@ fn zirCmpEq(
     const src: LazySrcLoc = block.nodeOffset(inst_data.src_node);
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
 
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
@@ -15700,8 +15699,8 @@ fn zirCmpEq(
 
     if (lhs_ty_tag == .error_set and rhs_ty_tag == .error_set) {
         const runtime_src: LazySrcLoc = src: {
-            if (try sema.resolveValue(lhs)) |lval| {
-                if (try sema.resolveValue(rhs)) |rval| {
+            if (sema.resolveValue(lhs)) |lval| {
+                if (sema.resolveValue(rhs)) |rval| {
                     if (lval.isUndef(zcu) or rval.isUndef(zcu)) return .undef_bool;
                     const lkey = zcu.intern_pool.indexToKey(lval.toIntern());
                     const rkey = zcu.intern_pool.indexToKey(rval.toIntern());
@@ -15754,7 +15753,7 @@ fn analyzeCmpUnionTag(
     const coerced_tag = try sema.coerce(block, union_tag_ty, tag, tag_src);
     const coerced_union = try sema.coerce(block, union_tag_ty, un, un_src);
 
-    if (try sema.resolveValue(coerced_tag)) |enum_val| {
+    if (sema.resolveValue(coerced_tag)) |enum_val| {
         if (enum_val.isUndef(zcu)) return .undef_bool;
         const field_ty = union_ty.unionFieldType(enum_val, zcu).?;
         if (field_ty.zigTypeTag(zcu) == .noreturn) {
@@ -15780,8 +15779,8 @@ fn zirCmp(
     const src: LazySrcLoc = block.nodeOffset(inst_data.src_node);
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     return sema.analyzeCmp(block, src, lhs, rhs, op, lhs_src, rhs_src, false);
 }
 
@@ -15864,8 +15863,8 @@ fn cmpSelf(
     const zcu = pt.zcu;
     const resolved_type = sema.typeOf(casted_lhs);
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
     if (maybe_lhs_val) |v| if (v.isUndef(zcu)) return .undef_bool;
     if (maybe_rhs_val) |v| if (v.isUndef(zcu)) return .undef_bool;
 
@@ -17118,7 +17117,7 @@ fn zirTypeof(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     _ = block;
     const zir_datas = sema.code.instructions.items(.data);
     const inst_data = zir_datas[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     return Air.internedToRef(operand_ty.toIntern());
 }
@@ -17150,7 +17149,7 @@ fn zirTypeofBuiltin(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
 fn zirTypeofLog2IntType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const res_ty = try sema.log2IntType(block, operand_ty, src);
     return Air.internedToRef(res_ty.toIntern());
@@ -17220,7 +17219,7 @@ fn zirTypeofPeer(
     defer sema.gpa.free(inst_list);
 
     for (args, 0..) |arg_ref, i| {
-        inst_list[i] = try sema.resolveInst(arg_ref);
+        inst_list[i] = sema.resolveInst(arg_ref);
     }
 
     const result_type = try sema.resolvePeerTypes(block, src, inst_list, .{ .typeof_builtin_call_node_offset = extra.data.src_node });
@@ -17233,7 +17232,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
-    const uncasted_operand = try sema.resolveInst(inst_data.operand);
+    const uncasted_operand = sema.resolveInst(inst_data.operand);
     const uncasted_ty = sema.typeOf(uncasted_operand);
     if (uncasted_ty.isVector(zcu)) {
         if (uncasted_ty.scalarType(zcu).zigTypeTag(zcu) != .bool) {
@@ -17244,7 +17243,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         return analyzeBitNot(sema, block, uncasted_operand, src);
     }
     const operand = try sema.coerce(block, .bool, uncasted_operand, operand_src);
-    if (try sema.resolveValue(operand)) |val| {
+    if (sema.resolveValue(operand)) |val| {
         return if (val.isUndef(zcu)) .undef_bool else if (val.toBool()) .bool_false else .bool_true;
     }
     try sema.requireRuntimeBlock(block, src, null);
@@ -17268,7 +17267,7 @@ fn zirBoolBr(
     const inst_data = datas[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index);
 
-    const uncoerced_lhs = try sema.resolveInst(extra.data.lhs);
+    const uncoerced_lhs = sema.resolveInst(extra.data.lhs);
     const body = sema.code.bodySlice(extra.end, extra.data.body_len);
     const lhs_src = parent_block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
     const rhs_src = parent_block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
@@ -17431,7 +17430,7 @@ fn zirIsNonNull(
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     try sema.checkNullableType(block, src, sema.typeOf(operand));
     return sema.analyzeIsNull(block, operand, true);
 }
@@ -17448,12 +17447,12 @@ fn zirIsNonNullPtr(
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const ptr = try sema.resolveInst(inst_data.operand);
+    const ptr = sema.resolveInst(inst_data.operand);
     const ptr_ty = sema.typeOf(ptr);
     assert(ptr_ty.zigTypeTag(zcu) == .pointer);
     const nullable_ty = ptr_ty.childType(zcu);
     try sema.checkNullableType(block, src, nullable_ty);
-    if (try sema.resolveValue(ptr)) |ptr_val| {
+    if (sema.resolveValue(ptr)) |ptr_val| {
         if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |nullable_val| {
             return sema.analyzeIsNull(block, .fromValue(nullable_val), true);
         }
@@ -17481,7 +17480,7 @@ fn zirIsNonErr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     try sema.checkErrorType(block, src, sema.typeOf(operand));
     return sema.analyzeIsNonErr(block, src, operand);
 }
@@ -17494,7 +17493,7 @@ fn zirIsNonErrPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const ptr = try sema.resolveInst(inst_data.operand);
+    const ptr = sema.resolveInst(inst_data.operand);
     const ptr_ty = sema.typeOf(ptr);
     assert(ptr_ty.zigTypeTag(zcu) == .pointer);
     const error_ty = ptr_ty.childType(zcu);
@@ -17509,7 +17508,7 @@ fn zirRetIsNonErr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     return sema.analyzeIsNonErr(block, src, operand);
 }
 
@@ -17530,7 +17529,7 @@ fn zirCondbr(
     const then_body = sema.code.bodySlice(extra.end, extra.data.then_body_len);
     const else_body = sema.code.bodySlice(extra.end + then_body.len, extra.data.else_body_len);
 
-    const uncasted_cond = try sema.resolveInst(extra.data.condition);
+    const uncasted_cond = sema.resolveInst(extra.data.condition);
     const cond = try sema.coerce(parent_block, .bool, uncasted_cond, cond_src);
 
     if (try sema.resolveDefinedValue(parent_block, cond_src, cond)) |cond_val| {
@@ -17566,7 +17565,7 @@ fn zirCondbr(
         if (sema.code.instructions.items(.tag)[@intFromEnum(index)] != .is_non_err) break :blk null;
 
         const err_inst_data = sema.code.instructions.items(.data)[@intFromEnum(index)].un_node;
-        const err_operand = try sema.resolveInst(err_inst_data.operand);
+        const err_operand = sema.resolveInst(err_inst_data.operand);
         const operand_ty = sema.typeOf(err_operand);
         assert(operand_ty.zigTypeTag(zcu) == .error_union);
         const result_ty = operand_ty.errorUnionSet(zcu);
@@ -17614,7 +17613,7 @@ fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!
     const operand_src = parent_block.src(.{ .node_offset_try_operand = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index);
     const body = sema.code.bodySlice(extra.end, extra.data.body_len);
-    const err_union = try sema.resolveInst(extra.data.operand);
+    const err_union = sema.resolveInst(extra.data.operand);
     const err_union_ty = sema.typeOf(err_union);
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -17681,7 +17680,7 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
     const operand_src = parent_block.src(.{ .node_offset_try_operand = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index);
     const body = sema.code.bodySlice(extra.end, extra.data.body_len);
-    const operand = try sema.resolveInst(extra.data.operand);
+    const operand = sema.resolveInst(extra.data.operand);
     const err_union = try sema.analyzeLoad(parent_block, src, operand, operand_src);
     const err_union_ty = sema.typeOf(err_union);
     const pt = sema.pt;
@@ -17802,7 +17801,7 @@ fn ensurePostHoc(sema: *Sema, block: *Block, dest_block: Zir.Inst.Index) !*Label
 fn addRuntimeBreak(sema: *Sema, child_block: *Block, block_inst: Zir.Inst.Index, break_operand: Zir.Inst.Ref) !void {
     const labeled_block = try sema.ensurePostHoc(child_block, block_inst);
 
-    const operand = try sema.resolveInst(break_operand);
+    const operand = sema.resolveInst(break_operand);
     const br_ref = try child_block.addBr(labeled_block.label.merges.block_inst, operand);
 
     try labeled_block.label.merges.results.append(sema.gpa, operand);
@@ -17888,7 +17887,7 @@ fn zirRetImplicit(
         return;
     }
 
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = .zero });
     const base_tag = sema.fn_ret_ty.optEuBaseType(zcu).zigTypeTag(zcu);
     if (base_tag == .noreturn) {
@@ -17921,7 +17920,7 @@ fn zirRetNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!voi
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
 
     return sema.analyzeRet(block, operand, src, block.src(.{ .node_offset_return_operand = inst_data.src_node }));
@@ -17933,7 +17932,7 @@ fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!voi
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const ret_ptr = try sema.resolveInst(inst_data.operand);
+    const ret_ptr = sema.resolveInst(inst_data.operand);
 
     if (block.isComptime() or block.inlining != null or sema.func_is_naked) {
         const operand = try sema.analyzeLoad(block, src, ret_ptr, src);
@@ -18030,7 +18029,7 @@ fn zirSaveErrRetIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     if (block.isComptime() or block.is_typeof) return;
 
     const save_index = inst_data.operand == .none or b: {
-        const operand = try sema.resolveInst(inst_data.operand);
+        const operand = sema.resolveInst(inst_data.operand);
         const operand_ty = sema.typeOf(operand);
         break :b operand_ty.isError(zcu);
     };
@@ -18079,7 +18078,7 @@ fn restoreErrRetIndex(sema: *Sema, start_block: *Block, src: LazySrcLoc, target_
         return; // No need to restore
     };
 
-    const operand = try sema.resolveInstAllowNone(operand_zir);
+    const operand = sema.resolveInstAllowNone(operand_zir);
 
     if (start_block.isComptime() or start_block.is_typeof) {
         const is_non_error = if (operand != .none) blk: {
@@ -18229,7 +18228,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const hostsize_src = block.src(.{ .node_offset_ptr_hostsize = extra.data.src_node });
 
     const elem_ty = blk: {
-        const air_inst = try sema.resolveInst(extra.data.elem_type);
+        const air_inst = sema.resolveInst(extra.data.elem_type);
         const ty = sema.analyzeAsType(block, elem_ty_src, .type, air_inst) catch |err| {
             if (err == error.AnalysisFail and sema.err != null and sema.typeOf(air_inst).isSinglePointer(zcu)) {
                 try sema.errNote(elem_ty_src, sema.err.?, "use '.*' to dereference pointer", .{});
@@ -18250,7 +18249,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const sentinel = if (inst_data.flags.has_sentinel) blk: {
         const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
         extra_i += 1;
-        const coerced = try sema.coerce(block, elem_ty, try sema.resolveInst(ref), sentinel_src);
+        const coerced = try sema.coerce(block, elem_ty, sema.resolveInst(ref), sentinel_src);
         const val = try sema.resolveConstDefinedValue(block, sentinel_src, coerced, .{ .simple = .pointer_sentinel });
         try checkSentinelType(sema, block, sentinel_src, elem_ty);
         if (val.canMutateComptimeVarState(zcu)) {
@@ -18263,7 +18262,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const abi_align: Alignment = if (inst_data.flags.has_align) blk: {
         const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
         extra_i += 1;
-        const coerced = try sema.coerce(block, align_ty, try sema.resolveInst(ref), align_src);
+        const coerced = try sema.coerce(block, align_ty, sema.resolveInst(ref), align_src);
         const val = try sema.resolveConstDefinedValue(block, align_src, coerced, .{ .simple = .@"align" });
         const align_bytes = val.toUnsignedInt(zcu);
         break :blk try sema.validateAlign(block, align_src, align_bytes);
@@ -18442,7 +18441,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
     const init_ref = try sema.coerce(block, init_ty, empty_ref, src);
 
     if (is_byref) {
-        const init_val = (try sema.resolveValue(init_ref)).?;
+        const init_val = sema.resolveValue(init_ref).?;
         return sema.uavRef(init_val.toIntern());
     } else {
         return init_ref;
@@ -18508,9 +18507,9 @@ fn zirUnionInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
     const field_ty: Type = .fromInterned(zcu.typeToUnion(union_ty).?.field_types.get(ip)[field_index]);
 
-    const payload = try sema.coerce(block, field_ty, try sema.resolveInst(extra.init), payload_src);
+    const payload = try sema.coerce(block, field_ty, sema.resolveInst(extra.init), payload_src);
 
-    if (try sema.resolveValue(payload)) |payload_val| {
+    if (sema.resolveValue(payload)) |payload_val| {
         const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
         return .fromValue(try pt.unionValue(union_ty, tag_val, payload_val));
@@ -18590,12 +18589,12 @@ fn zirStructInit(
             assert(field_inits[field_index] == .none);
             field_assign_idxs[field_index] = field_i;
             found_fields[field_index] = item.data.field_type;
-            const uncoerced_init = try sema.resolveInst(item.data.init);
+            const uncoerced_init = sema.resolveInst(item.data.init);
             const field_ty = resolved_ty.fieldType(field_index, zcu);
             field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);
             if (resolved_ty.structFieldIsComptime(field_index, zcu)) {
                 const default_value = (try resolved_ty.structFieldValueComptime(pt, field_index)).?;
-                const init_val = (try sema.resolveValue(field_inits[field_index])) orelse {
+                const init_val = sema.resolveValue(field_inits[field_index]) orelse {
                     return sema.failWithNeededComptime(block, field_src, .{ .simple = .stored_to_comptime_field });
                 };
                 if (!init_val.eql(default_value, resolved_ty.fieldType(field_index, zcu), zcu)) {
@@ -18640,17 +18639,17 @@ fn zirStructInit(
             });
         }
 
-        const uncoerced_init_inst = try sema.resolveInst(item.data.init);
+        const uncoerced_init_inst = sema.resolveInst(item.data.init);
         const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);
 
-        if (try sema.resolveValue(init_inst)) |val| {
+        if (sema.resolveValue(init_inst)) |val| {
             const struct_val = Value.fromInterned(try pt.internUnion(.{
                 .ty = resolved_ty.toIntern(),
                 .tag = tag_val.toIntern(),
                 .val = val.toIntern(),
             }));
             const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src);
-            const final_val = (try sema.resolveValue(final_val_inst)).?;
+            const final_val = sema.resolveValue(final_val_inst).?;
             return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
         }
 
@@ -18792,11 +18791,11 @@ fn finishStructInit(
     const runtime_index = opt_runtime_index orelse {
         const elems = try sema.arena.alloc(InternPool.Index, field_inits.len);
         for (elems, field_inits) |*elem, field_init| {
-            elem.* = (sema.resolveValue(field_init) catch unreachable).?.toIntern();
+            elem.* = sema.resolveValue(field_init).?.toIntern();
         }
         const struct_val = try pt.aggregateValue(struct_ty, elems);
         const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), init_src);
-        const final_val = (try sema.resolveValue(final_val_inst)).?;
+        const final_val = sema.resolveValue(final_val_inst).?;
         return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
     };
 
@@ -18903,7 +18902,7 @@ fn structInitAnon(
 
             field_name.* = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, name, .no_embedded_nulls);
 
-            const init = try sema.resolveInst(item.data.init);
+            const init = sema.resolveInst(item.data.init);
             field_ty.* = sema.typeOf(init).toIntern();
             if (Type.fromInterned(field_ty.*).zigTypeTag(zcu) == .@"opaque") {
                 const msg = msg: {
@@ -18919,7 +18918,7 @@ fn structInitAnon(
                 };
                 return sema.failWithOwnedErrorMsg(block, msg);
             }
-            if (try sema.resolveValue(init)) |init_val| {
+            if (sema.resolveValue(init)) |init_val| {
                 field_val.* = init_val.toIntern();
                 any_values = true;
             } else {
@@ -19018,7 +19017,7 @@ fn structInitAnon(
                 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
             });
             if (values[i] == .none) {
-                const init = try sema.resolveInst(item.data.init);
+                const init = sema.resolveInst(item.data.init);
                 const field_ptr = try block.addStructFieldPtr(alloc, i, field_ptr_ty);
                 _ = try block.addBinOp(.store, field_ptr, init);
             }
@@ -19035,7 +19034,7 @@ fn structInitAnon(
             .typed_init => sema.code.extraData(Zir.Inst.StructInit.Item, extra_index),
         };
         extra_index = item.end;
-        element_refs[i] = try sema.resolveInst(item.data.init);
+        element_refs[i] = sema.resolveInst(item.data.init);
     }
 
     return block.addAggregateInit(struct_ty, element_refs);
@@ -19095,7 +19094,7 @@ fn zirArrayInit(
         };
 
         const arg = args[i + 1];
-        const resolved_arg = try sema.resolveInst(arg);
+        const resolved_arg = sema.resolveInst(arg);
         const elem_ty = if (is_tuple)
             array_ty.fieldType(i, zcu)
         else
@@ -19126,11 +19125,11 @@ fn zirArrayInit(
         const elem_vals = try sema.arena.alloc(InternPool.Index, resolved_args.len);
         for (elem_vals, resolved_args) |*val, arg| {
             // We checked that all args are comptime above.
-            val.* = (sema.resolveValue(arg) catch unreachable).?.toIntern();
+            val.* = sema.resolveValue(arg).?.toIntern();
         }
         const arr_val = try pt.aggregateValue(array_ty, elem_vals);
         const result_ref = try sema.coerce(block, result_ty, Air.internedToRef(arr_val.toIntern()), src);
-        const result_val = (try sema.resolveValue(result_ref)).?;
+        const result_val = (sema.resolveValue(result_ref)).?;
         return sema.addConstantMaybeRef(result_val.toIntern(), is_ref);
     };
 
@@ -19213,7 +19212,7 @@ fn arrayInitAnon(
                 .init_node_offset = src.offset.node_offset.x,
                 .elem_index = @intCast(i),
             } });
-            const elem = try sema.resolveInst(operand);
+            const elem = sema.resolveInst(operand);
             types[i] = sema.typeOf(elem).toIntern();
             if (Type.fromInterned(types[i]).zigTypeTag(zcu) == .@"opaque") {
                 const msg = msg: {
@@ -19225,7 +19224,7 @@ fn arrayInitAnon(
                 };
                 return sema.failWithOwnedErrorMsg(block, msg);
             }
-            if (try sema.resolveValue(elem)) |val| {
+            if (sema.resolveValue(elem)) |val| {
                 values[i] = val.toIntern();
                 any_comptime = true;
             } else {
@@ -19265,7 +19264,7 @@ fn arrayInitAnon(
             .init_node_offset = src.offset.node_offset.x,
             .elem_index = @intCast(i),
         } });
-        try sema.validateRuntimeValue(block, operand_src, try sema.resolveInst(operand));
+        try sema.validateRuntimeValue(block, operand_src, sema.resolveInst(operand));
     }
 
     if (is_ref) {
@@ -19283,7 +19282,7 @@ fn arrayInitAnon(
             });
             if (values[i] == .none) {
                 const field_ptr = try block.addStructFieldPtr(alloc, i, field_ptr_ty);
-                _ = try block.addBinOp(.store, field_ptr, try sema.resolveInst(operand));
+                _ = try block.addBinOp(.store, field_ptr, sema.resolveInst(operand));
             }
         }
 
@@ -19292,7 +19291,7 @@ fn arrayInitAnon(
 
     const element_refs = try sema.arena.alloc(Air.Inst.Ref, operands.len);
     for (operands, 0..) |operand, i| {
-        element_refs[i] = try sema.resolveInst(operand);
+        element_refs[i] = sema.resolveInst(operand);
     }
 
     return block.addAggregateInit(tuple_ty, element_refs);
@@ -19441,7 +19440,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const is_vector = operand_ty.zigTypeTag(zcu) == .vector;
     const operand_scalar_ty = operand_ty.scalarType(zcu);
@@ -19450,7 +19449,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     }
     const len = if (is_vector) operand_ty.vectorLen(zcu) else undefined;
     const dest_ty: Type = if (is_vector) try pt.vectorType(.{ .child = .u1_type, .len = len }) else .u1;
-    if (try sema.resolveValue(operand)) |val| {
+    if (sema.resolveValue(operand)) |val| {
         if (!is_vector) {
             return if (val.isUndef(zcu)) .undef_u1 else if (val.toBool()) .one_u1 else .zero_u1;
         }
@@ -19473,7 +19472,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
 fn zirErrorName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const uncoerced_operand = try sema.resolveInst(inst_data.operand);
+    const uncoerced_operand = sema.resolveInst(inst_data.operand);
     const operand = try sema.coerce(block, .anyerror, uncoerced_operand, operand_src);
 
     if (try sema.resolveDefinedValue(block, operand_src, operand)) |val| {
@@ -19494,7 +19493,7 @@ fn zirAbs(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand_ty = sema.typeOf(operand);
     const scalar_ty = operand_ty.scalarType(zcu);
@@ -19525,7 +19524,7 @@ fn maybeConstantUnaryMath(
     const pt = sema.pt;
     const zcu = pt.zcu;
     switch (result_ty.zigTypeTag(zcu)) {
-        .vector => if (try sema.resolveValue(operand)) |val| {
+        .vector => if (sema.resolveValue(operand)) |val| {
             const scalar_ty = result_ty.scalarType(zcu);
             const vec_len = result_ty.vectorLen(zcu);
             if (val.isUndef(zcu))
@@ -19538,7 +19537,7 @@ fn maybeConstantUnaryMath(
             }
             return Air.internedToRef((try pt.aggregateValue(result_ty, elems)).toIntern());
         },
-        else => if (try sema.resolveValue(operand)) |operand_val| {
+        else => if (sema.resolveValue(operand)) |operand_val| {
             if (operand_val.isUndef(zcu))
                 return try pt.undefRef(result_ty);
             const result_val = try eval(operand_val, result_ty, sema.arena, pt);
@@ -19561,7 +19560,7 @@ fn zirUnaryMath(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand_ty = sema.typeOf(operand);
     const scalar_ty = operand_ty.scalarType(zcu);
@@ -19586,7 +19585,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const src = block.nodeOffset(inst_data.src_node);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -19678,7 +19677,7 @@ fn zirReifySliceArgTy(
         .flags = .{ .size = .slice, .is_const = true },
     });
 
-    const operand_uncoerced = try sema.resolveInst(extra.operand);
+    const operand_uncoerced = sema.resolveInst(extra.operand);
     const operand_coerced = try sema.coerce(block, operand_ty, operand_uncoerced, src);
     const operand_val = try sema.resolveConstDefinedValue(block, src, operand_coerced, .{ .simple = comptime_reason });
     const len_val: Value = .fromInterned(zcu.intern_pool.indexToKey(operand_val.toIntern()).slice.len);
@@ -19706,7 +19705,7 @@ fn zirReifyEnumValueSliceTy(
 
     const int_tag_ty = try sema.resolveType(block, int_tag_ty_src, extra.lhs);
 
-    const operand_uncoerced = try sema.resolveInst(extra.rhs);
+    const operand_uncoerced = sema.resolveInst(extra.rhs);
     const operand_coerced = try sema.coerce(block, .slice_const_slice_const_u8, operand_uncoerced, field_names_src);
     const operand_val = try sema.resolveConstDefinedValue(block, field_names_src, operand_coerced, .{ .simple = .enum_field_names });
     const len_val: Value = .fromInterned(zcu.intern_pool.indexToKey(operand_val.toIntern()).slice.len);
@@ -19751,7 +19750,7 @@ fn zirReifyTuple(
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 
-    const types_uncoerced = try sema.resolveInst(extra.operand);
+    const types_uncoerced = sema.resolveInst(extra.operand);
     const types_coerced = try sema.coerce(block, .slice_const_type, types_uncoerced, operand_src);
     const types_slice_val = try sema.resolveConstDefinedValue(block, operand_src, types_coerced, .{ .simple = .tuple_field_types });
     const types_array_val = try sema.derefSliceAsArray(block, operand_src, types_slice_val, .{ .simple = .tuple_field_types });
@@ -19798,12 +19797,12 @@ fn zirReifyPointer(
     const size_ty = try sema.getBuiltinType(size_src, .@"Type.Pointer.Size");
     const attrs_ty = try sema.getBuiltinType(attrs_src, .@"Type.Pointer.Attributes");
 
-    const size_uncoerced = try sema.resolveInst(extra.size);
+    const size_uncoerced = sema.resolveInst(extra.size);
     const size_coerced = try sema.coerce(block, size_ty, size_uncoerced, size_src);
     const size_val = try sema.resolveConstDefinedValue(block, size_src, size_coerced, .{ .simple = .pointer_size });
     const size = try sema.interpretBuiltinType(block, size_src, size_val, std.builtin.Type.Pointer.Size);
 
-    const attrs_uncoerced = try sema.resolveInst(extra.attrs);
+    const attrs_uncoerced = sema.resolveInst(extra.attrs);
     const attrs_coerced = try sema.coerce(block, attrs_ty, attrs_uncoerced, attrs_src);
     const attrs_val = try sema.resolveConstDefinedValue(block, attrs_src, attrs_coerced, .{ .simple = .pointer_attrs });
     const attrs = try sema.interpretBuiltinType(block, attrs_src, attrs_val, std.builtin.Type.Pointer.Attributes);
@@ -19842,7 +19841,7 @@ fn zirReifyPointer(
     }
 
     const sentinel_ty = try pt.optionalType(elem_ty.toIntern());
-    const sentinel_uncoerced = try sema.resolveInst(extra.sentinel);
+    const sentinel_uncoerced = sema.resolveInst(extra.sentinel);
     const sentinel_coerced = try sema.coerce(block, sentinel_ty, sentinel_uncoerced, sentinel_src);
     const sentinel_val = try sema.resolveConstDefinedValue(block, sentinel_src, sentinel_coerced, .{ .simple = .pointer_sentinel });
     const opt_sentinel = sentinel_val.optionalValue(zcu);
@@ -19896,7 +19895,7 @@ fn zirReifyFn(
     const single_param_attrs_ty = try sema.getBuiltinType(param_attrs_src, .@"Type.Fn.Param.Attributes");
     const fn_attrs_ty = try sema.getBuiltinType(fn_attrs_src, .@"Type.Fn.Attributes");
 
-    const param_types_uncoerced = try sema.resolveInst(extra.param_types);
+    const param_types_uncoerced = sema.resolveInst(extra.param_types);
     const param_types_coerced = try sema.coerce(block, .slice_const_type, param_types_uncoerced, param_types_src);
     const param_types_slice = try sema.resolveConstDefinedValue(block, param_types_src, param_types_coerced, .{ .simple = .fn_param_types });
     const param_types_arr = try sema.derefSliceAsArray(block, param_types_src, param_types_slice, .{ .simple = .fn_param_types });
@@ -19907,7 +19906,7 @@ fn zirReifyFn(
         .len = params_len,
         .child = single_param_attrs_ty.toIntern(),
     }));
-    const param_attrs_uncoerced = try sema.resolveInst(extra.param_attrs);
+    const param_attrs_uncoerced = sema.resolveInst(extra.param_attrs);
     const param_attrs_coerced = try sema.coerce(block, param_attrs_ty, param_attrs_uncoerced, param_attrs_src);
     const param_attrs_slice = try sema.resolveConstDefinedValue(block, param_attrs_src, param_attrs_coerced, .{ .simple = .fn_param_attrs });
     const param_attrs_arr = try sema.derefSliceAsArray(block, param_attrs_src, param_attrs_slice, .{ .simple = .fn_param_attrs });
@@ -19915,7 +19914,7 @@ fn zirReifyFn(
     const ret_ty = try sema.resolveType(block, ret_ty_src, extra.ret_ty);
     try sema.ensureLayoutResolved(ret_ty);
 
-    const fn_attrs_uncoerced = try sema.resolveInst(extra.fn_attrs);
+    const fn_attrs_uncoerced = sema.resolveInst(extra.fn_attrs);
     const fn_attrs_coerced = try sema.coerce(block, fn_attrs_ty, fn_attrs_uncoerced, fn_attrs_src);
     const fn_attrs_val = try sema.resolveConstDefinedValue(block, fn_attrs_src, fn_attrs_coerced, .{ .simple = .fn_attrs });
     const fn_attrs = try sema.interpretBuiltinType(block, fn_attrs_src, fn_attrs_val, std.builtin.Type.Fn.Attributes);
@@ -20041,16 +20040,16 @@ fn zirReifyStruct(
     const container_layout_ty = try sema.getBuiltinType(layout_src, .@"Type.ContainerLayout");
     const single_field_attrs_ty = try sema.getBuiltinType(field_attrs_src, .@"Type.StructField.Attributes");
 
-    const layout_uncoerced = try sema.resolveInst(extra.layout);
+    const layout_uncoerced = sema.resolveInst(extra.layout);
     const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src);
     const layout_val = try sema.resolveConstDefinedValue(block, layout_src, layout_coerced, .{ .simple = .struct_layout });
     const layout = try sema.interpretBuiltinType(block, layout_src, layout_val, std.builtin.Type.ContainerLayout);
 
-    const backing_int_ty_uncoerced = try sema.resolveInst(extra.backing_ty);
+    const backing_int_ty_uncoerced = sema.resolveInst(extra.backing_ty);
     const backing_int_ty_coerced = try sema.coerce(block, .optional_type, backing_int_ty_uncoerced, backing_ty_src);
     const backing_int_ty_val = try sema.resolveConstDefinedValue(block, backing_ty_src, backing_int_ty_coerced, .{ .simple = .packed_struct_backing_int_type });
 
-    const field_names_uncoerced = try sema.resolveInst(extra.field_names);
+    const field_names_uncoerced = sema.resolveInst(extra.field_names);
     const field_names_coerced = try sema.coerce(block, .slice_const_slice_const_u8, field_names_uncoerced, field_names_src);
     const field_names_slice = try sema.resolveConstDefinedValue(block, field_names_src, field_names_coerced, .{ .simple = .struct_field_names });
     const field_names_arr = try sema.derefSliceAsArray(block, field_names_src, field_names_slice, .{ .simple = .struct_field_names });
@@ -20066,12 +20065,12 @@ fn zirReifyStruct(
         .child = single_field_attrs_ty.toIntern(),
     }));
 
-    const field_types_uncoerced = try sema.resolveInst(extra.field_types);
+    const field_types_uncoerced = sema.resolveInst(extra.field_types);
     const field_types_coerced = try sema.coerce(block, field_types_ty, field_types_uncoerced, field_types_src);
     const field_types_slice = try sema.resolveConstDefinedValue(block, field_types_src, field_types_coerced, .{ .simple = .struct_field_types });
     const field_types_arr = try sema.derefSliceAsArray(block, field_types_src, field_types_slice, .{ .simple = .struct_field_types });
 
-    const field_attrs_uncoerced = try sema.resolveInst(extra.field_attrs);
+    const field_attrs_uncoerced = sema.resolveInst(extra.field_attrs);
     const field_attrs_coerced = try sema.coerce(block, field_attrs_ty, field_attrs_uncoerced, field_attrs_src);
     const field_attrs_slice = try sema.resolveConstDefinedValue(block, field_attrs_src, field_attrs_coerced, .{ .simple = .struct_field_attrs });
     const field_attrs_arr = try sema.derefSliceAsArray(block, field_attrs_src, field_attrs_slice, .{ .simple = .struct_field_attrs });
@@ -20328,19 +20327,19 @@ fn zirReifyUnion(
     const container_layout_ty = try sema.getBuiltinType(layout_src, .@"Type.ContainerLayout");
     const single_field_attrs_ty = try sema.getBuiltinType(field_attrs_src, .@"Type.UnionField.Attributes");
 
-    const layout_uncoerced = try sema.resolveInst(extra.layout);
+    const layout_uncoerced = sema.resolveInst(extra.layout);
     const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src);
     const layout_val = try sema.resolveConstDefinedValue(block, layout_src, layout_coerced, .{ .simple = .union_layout });
     const layout = try sema.interpretBuiltinType(block, layout_src, layout_val, std.builtin.Type.ContainerLayout);
 
-    const arg_ty_uncoerced = try sema.resolveInst(extra.arg_ty);
+    const arg_ty_uncoerced = sema.resolveInst(extra.arg_ty);
     const arg_ty_coerced = try sema.coerce(block, .optional_type, arg_ty_uncoerced, arg_ty_src);
     const arg_ty_val = try sema.resolveConstDefinedValue(block, arg_ty_src, arg_ty_coerced, switch (layout) {
         .@"packed" => .{ .simple = .packed_union_backing_int_type },
         .auto, .@"extern" => .{ .simple = .union_enum_tag_type },
     });
 
-    const field_names_uncoerced = try sema.resolveInst(extra.field_names);
+    const field_names_uncoerced = sema.resolveInst(extra.field_names);
     const field_names_coerced = try sema.coerce(block, .slice_const_slice_const_u8, field_names_uncoerced, field_names_src);
     const field_names_slice = try sema.resolveConstDefinedValue(block, field_names_src, field_names_coerced, .{ .simple = .union_field_names });
     const field_names_arr = try sema.derefSliceAsArray(block, field_names_src, field_names_slice, .{ .simple = .union_field_names });
@@ -20356,12 +20355,12 @@ fn zirReifyUnion(
         .child = single_field_attrs_ty.toIntern(),
     }));
 
-    const field_types_uncoerced = try sema.resolveInst(extra.field_types);
+    const field_types_uncoerced = sema.resolveInst(extra.field_types);
     const field_types_coerced = try sema.coerce(block, field_types_ty, field_types_uncoerced, field_types_src);
     const field_types_slice = try sema.resolveConstDefinedValue(block, field_types_src, field_types_coerced, .{ .simple = .union_field_types });
     const field_types_arr = try sema.derefSliceAsArray(block, field_types_src, field_types_slice, .{ .simple = .union_field_types });
 
-    const field_attrs_uncoerced = try sema.resolveInst(extra.field_attrs);
+    const field_attrs_uncoerced = sema.resolveInst(extra.field_attrs);
     const field_attrs_coerced = try sema.coerce(block, field_attrs_ty, field_attrs_uncoerced, field_attrs_src);
     const field_attrs_slice = try sema.resolveConstDefinedValue(block, field_attrs_src, field_attrs_coerced, .{ .simple = .union_field_attrs });
     const field_attrs_arr = try sema.derefSliceAsArray(block, field_attrs_src, field_attrs_slice, .{ .simple = .union_field_attrs });
@@ -20549,12 +20548,12 @@ fn zirReifyEnum(
 
     const enum_mode_ty = try sema.getBuiltinType(mode_src, .@"Type.Enum.Mode");
 
-    const tag_ty_uncoerced = try sema.resolveInst(extra.tag_ty);
+    const tag_ty_uncoerced = sema.resolveInst(extra.tag_ty);
     const tag_ty_coerced = try sema.coerce(block, .type, tag_ty_uncoerced, tag_ty_src);
     const tag_ty_val = try sema.resolveConstDefinedValue(block, tag_ty_src, tag_ty_coerced, .{ .simple = .enum_int_tag_type });
     const tag_ty = tag_ty_val.toType();
 
-    const mode_uncoerced = try sema.resolveInst(extra.mode);
+    const mode_uncoerced = sema.resolveInst(extra.mode);
     const mode_coerced = try sema.coerce(block, enum_mode_ty, mode_uncoerced, mode_src);
     const mode_val = try sema.resolveConstDefinedValue(block, mode_src, mode_coerced, .{ .simple = .type });
     const nonexhaustive = switch (try sema.interpretBuiltinType(block, mode_src, mode_val, std.builtin.Type.Enum.Mode)) {
@@ -20562,7 +20561,7 @@ fn zirReifyEnum(
         .nonexhaustive => true,
     };
 
-    const field_names_uncoerced = try sema.resolveInst(extra.field_names);
+    const field_names_uncoerced = sema.resolveInst(extra.field_names);
     const field_names_coerced = try sema.coerce(block, .slice_const_slice_const_u8, field_names_uncoerced, field_names_src);
     const field_names_slice = try sema.resolveConstDefinedValue(block, field_names_src, field_names_coerced, .{ .simple = .enum_field_names });
     const field_names_arr = try sema.derefSliceAsArray(block, field_names_src, field_names_slice, .{ .simple = .enum_field_names });
@@ -20574,7 +20573,7 @@ fn zirReifyEnum(
         .child = tag_ty.toIntern(),
     }));
 
-    const field_values_uncoerced = try sema.resolveInst(extra.field_values);
+    const field_values_uncoerced = sema.resolveInst(extra.field_values);
     const field_values_coerced = try sema.coerce(block, field_values_ty, field_values_uncoerced, field_values_src);
     const field_values_slice = try sema.resolveConstDefinedValue(block, field_values_src, field_values_coerced, .{ .simple = .enum_field_values });
     const field_values_arr = try sema.derefSliceAsArray(block, field_values_src, field_values_slice, .{ .simple = .enum_field_values });
@@ -20663,7 +20662,7 @@ fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.In
     const va_list_ty = try sema.getBuiltinType(src, .VaList);
     const va_list_ptr = try pt.singleMutPtrType(va_list_ty);
 
-    const inst = try sema.resolveInst(zir_ref);
+    const inst = sema.resolveInst(zir_ref);
     return sema.coerce(block, va_list_ptr, inst, src);
 }
 
@@ -20759,7 +20758,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@intFromFloat");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
 
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, src, operand_src);
@@ -20771,7 +20770,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     _ = try sema.checkIntType(block, src, dest_scalar_ty);
     try sema.checkFloatType(block, operand_src, operand_scalar_ty);
 
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         const result_val = try sema.intFromFloat(block, operand_src, operand_val, operand_ty, dest_ty, .truncate);
         return Air.internedToRef(result_val.toIntern());
     } else if (dest_scalar_ty.zigTypeTag(zcu) == .comptime_int) {
@@ -20812,7 +20811,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@floatFromInt");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
 
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, src, operand_src);
@@ -20823,7 +20822,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     try sema.checkFloatType(block, src, dest_scalar_ty);
     _ = try sema.checkIntType(block, operand_src, operand_scalar_ty);
 
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         if (operand_val.isUndef(zcu)) return .fromValue(try pt.undefValue(dest_ty));
         if (dest_ty.zigTypeTag(zcu) != .vector) {
             return .fromValue(try pt.floatValue(dest_ty, operand_val.toFloat(f128, zcu)));
@@ -20855,7 +20854,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
 
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const operand_res = try sema.resolveInst(extra.rhs);
+    const operand_res = sema.resolveInst(extra.rhs);
 
     const uncoerced_operand_ty = sema.typeOf(operand_res);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu, "@ptrFromInt");
@@ -20983,7 +20982,7 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_opt, "@errorCast");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
 
     const dest_tag = dest_ty.zigTypeTag(zcu);
@@ -21134,7 +21133,7 @@ fn zirPtrCastFull(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDa
     const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.src(.{ .node_offset_ptrcast_operand = extra.node });
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu, flags.needResultTypeBuiltinName());
     return sema.ptrCastFull(
         block,
@@ -21153,7 +21152,7 @@ fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu, "@ptrCast");
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
 
     return sema.ptrCastFull(
         block,
@@ -21219,7 +21218,7 @@ fn ptrCastFull(
                 };
             },
             .slice => src: {
-                const operand_val = try sema.resolveValue(operand) orelse break :src .{ .fromInterned(src_info.child), null };
+                const operand_val = sema.resolveValue(operand) orelse break :src .{ .fromInterned(src_info.child), null };
                 if (operand_val.isUndef(zcu)) break :len .undef;
                 const slice_val = switch (operand_ty.zigTypeTag(zcu)) {
                     .optional => operand_val.optionalValue(zcu) orelse break :len .undef,
@@ -21516,7 +21515,7 @@ fn ptrCastFull(
 
     ct: {
         if (flags.addrspace_cast) break :ct; // cannot `@addrSpaceCast` at comptime
-        const operand_val = try sema.resolveValue(operand) orelse break :ct;
+        const operand_val = sema.resolveValue(operand) orelse break :ct;
 
         if (operand_val.isUndef(zcu)) {
             if (!dest_ty.ptrAllowsZero(zcu)) {
@@ -21776,7 +21775,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.src(.{ .node_offset_ptrcast_operand = extra.node });
-    const operand = try sema.resolveInst(extra.operand);
+    const operand = sema.resolveInst(extra.operand);
     const operand_ty = sema.typeOf(operand);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
 
@@ -21792,7 +21791,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
         break :blk dest_ty;
     };
 
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         return Air.internedToRef((try pt.getCoerced(operand_val, dest_ty)).toIntern());
     }
 
@@ -21811,7 +21810,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@truncate");
     const dest_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, dest_ty, src);
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
     const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
 
@@ -21842,7 +21841,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         }
     }
 
-    if (try sema.resolveValue(operand)) |val| {
+    if (sema.resolveValue(operand)) |val| {
         const result_val = try arith.truncate(sema, val, operand_ty, dest_ty, dest_info.signedness, dest_info.bits);
         return Air.internedToRef(result_val.toIntern());
     }
@@ -21863,7 +21862,7 @@ fn zirBitCount(
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     _ = try sema.checkIntOrVector(block, operand, operand_src);
     const bits = operand_ty.intInfo(zcu).bits;
@@ -21876,7 +21875,7 @@ fn zirBitCount(
                 .len = vec_len,
                 .child = result_scalar_ty.toIntern(),
             });
-            if (try sema.resolveValue(operand)) |val| {
+            if (sema.resolveValue(operand)) |val| {
                 if (val.isUndef(zcu)) return pt.undefRef(result_ty);
 
                 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
@@ -21893,7 +21892,7 @@ fn zirBitCount(
             }
         },
         .int => {
-            if (try sema.resolveValue(operand)) |val| {
+            if (sema.resolveValue(operand)) |val| {
                 if (val.isUndef(zcu)) return pt.undefRef(result_scalar_ty);
                 return pt.intRef(result_scalar_ty, comptimeOp(val, operand_ty, zcu));
             } else {
@@ -21910,7 +21909,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src);
     const bits = scalar_ty.intInfo(zcu).bits;
@@ -21922,7 +21921,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             .{ scalar_ty.fmt(pt), bits },
         );
     }
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         return .fromValue(try arith.byteSwap(sema, operand_val, operand_ty));
     }
     return block.addTyOp(.byte_swap, operand_ty, operand);
@@ -21931,11 +21930,11 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
-    const operand = try sema.resolveInst(inst_data.operand);
+    const operand = sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     _ = try sema.checkIntOrVector(block, operand, operand_src);
 
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         return .fromValue(try arith.bitReverse(sema, operand_val, operand_ty));
     }
     return block.addTyOp(.bit_reverse, operand_ty, operand);
@@ -22359,8 +22358,8 @@ fn checkSimdBinOp(
         .len = vec_len,
         .lhs = lhs,
         .rhs = rhs,
-        .lhs_val = try sema.resolveValue(lhs),
-        .rhs_val = try sema.resolveValue(rhs),
+        .lhs_val = sema.resolveValue(lhs),
+        .rhs_val = sema.resolveValue(rhs),
         .result_ty = result_ty,
         .scalar_ty = result_ty.scalarType(zcu),
     };
@@ -22452,7 +22451,7 @@ fn resolveExportOptions(
     const ip = &zcu.intern_pool;
 
     const export_options_ty = try sema.getBuiltinType(src, .ExportOptions);
-    const air_ref = try sema.resolveInst(zir_ref);
+    const air_ref = sema.resolveInst(zir_ref);
     const options = try sema.coerce(block, export_options_ty, air_ref, src);
 
     const name_src = block.src(.{ .init_field_name = src.offset.node_offset_builtin_call_arg.builtin_call_node });
@@ -22505,7 +22504,7 @@ fn resolveBuiltinEnum(
     reason: ComptimeReason,
 ) CompileError!@field(std.builtin, @tagName(name)) {
     const ty = try sema.getBuiltinType(src, name);
-    const air_ref = try sema.resolveInst(zir_ref);
+    const air_ref = sema.resolveInst(zir_ref);
     const coerced = try sema.coerce(block, ty, air_ref, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
     return sema.interpretBuiltinType(block, src, val, @field(std.builtin, @tagName(name)));
@@ -22552,7 +22551,7 @@ fn zirCmpxchg(
     const success_order_src = block.builtinCallArgSrc(extra.node, 4);
     const failure_order_src = block.builtinCallArgSrc(extra.node, 5);
     // zig fmt: on
-    const expected_value = try sema.resolveInst(extra.expected_value);
+    const expected_value = sema.resolveInst(extra.expected_value);
     const elem_ty = sema.typeOf(expected_value);
     if (elem_ty.zigTypeTag(zcu) == .float) {
         return sema.fail(
@@ -22562,9 +22561,9 @@ fn zirCmpxchg(
             .{elem_ty.fmt(pt)},
         );
     }
-    const uncasted_ptr = try sema.resolveInst(extra.ptr);
+    const uncasted_ptr = sema.resolveInst(extra.ptr);
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, false);
-    const new_value = try sema.coerce(block, elem_ty, try sema.resolveInst(extra.new_value), new_value_src);
+    const new_value = try sema.coerce(block, elem_ty, sema.resolveInst(extra.new_value), new_value_src);
     const success_order = try sema.resolveAtomicOrder(block, success_order_src, extra.success_order, .{ .simple = .atomic_order });
     const failure_order = try sema.resolveAtomicOrder(block, failure_order_src, extra.failure_order, .{ .simple = .atomic_order });
 
@@ -22589,8 +22588,8 @@ fn zirCmpxchg(
     }
 
     const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
-        if (try sema.resolveValue(expected_value)) |expected_val| {
-            if (try sema.resolveValue(new_value)) |new_val| {
+        if (sema.resolveValue(expected_value)) |expected_val| {
+            if (sema.resolveValue(new_value)) |new_val| {
                 if (expected_val.isUndef(zcu) or new_val.isUndef(zcu)) {
                     // TODO: this should probably cause the memory stored at the pointer
                     // to become undef as well
@@ -22642,7 +22641,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
         else => return sema.fail(block, src, "expected array or vector type, found '{f}'", .{dest_ty.fmt(pt)}),
     }
 
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const scalar_ty = dest_ty.childType(zcu);
     const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);
 
@@ -22653,7 +22652,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
 
     const maybe_sentinel = dest_ty.sentinel(zcu);
 
-    if (try sema.resolveValue(scalar)) |scalar_val| {
+    if (sema.resolveValue(scalar)) |scalar_val| {
         full: {
             if (dest_ty.zigTypeTag(zcu) == .vector) break :full;
             const sentinel = maybe_sentinel orelse break :full;
@@ -22688,7 +22687,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const op_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const operation = try sema.resolveBuiltinEnum(block, op_src, extra.lhs, .ReduceOp, .{ .simple = .operand_reduce_operation });
-    const operand = try sema.resolveInst(extra.rhs);
+    const operand = sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -22722,7 +22721,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         return sema.fail(block, operand_src, "@reduce operation requires a vector with nonzero length", .{});
     }
 
-    if (try sema.resolveValue(operand)) |operand_val| {
+    if (sema.resolveValue(operand)) |operand_val| {
         if (operand_val.isUndef(zcu)) return pt.undefRef(scalar_ty);
 
         var accum: Value = try operand_val.elemValue(pt, 0);
@@ -22758,9 +22757,9 @@ fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
 
     const elem_ty = try sema.resolveType(block, elem_ty_src, extra.elem_type);
     try sema.checkVectorElemType(block, elem_ty_src, elem_ty);
-    const a = try sema.resolveInst(extra.a);
-    const b = try sema.resolveInst(extra.b);
-    var mask = try sema.resolveInst(extra.mask);
+    const a = sema.resolveInst(extra.a);
+    const b = sema.resolveInst(extra.b);
+    var mask = sema.resolveInst(extra.mask);
     var mask_ty = sema.typeOf(mask);
 
     const mask_len = switch (sema.typeOf(mask).zigTypeTag(zcu)) {
@@ -22867,8 +22866,8 @@ fn analyzeShuffle(
         }
     }
 
-    const maybe_a_val = try sema.resolveValue(a_coerced);
-    const maybe_b_val = try sema.resolveValue(b_coerced);
+    const maybe_a_val = sema.resolveValue(a_coerced);
+    const maybe_b_val = sema.resolveValue(b_coerced);
 
     const a_rt = a_used and maybe_a_val == null;
     const b_rt = b_used and maybe_b_val == null;
@@ -22956,7 +22955,7 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
 
     const elem_ty = try sema.resolveType(block, elem_ty_src, extra.elem_type);
     try sema.checkVectorElemType(block, elem_ty_src, elem_ty);
-    const pred_uncoerced = try sema.resolveInst(extra.pred);
+    const pred_uncoerced = sema.resolveInst(extra.pred);
     const pred_ty = sema.typeOf(pred_uncoerced);
 
     const vec_len_u64 = switch (pred_ty.zigTypeTag(zcu)) {
@@ -22975,12 +22974,12 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
         .len = vec_len,
         .child = elem_ty.toIntern(),
     });
-    const a = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.a), a_src);
-    const b = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.b), b_src);
+    const a = try sema.coerce(block, vec_ty, sema.resolveInst(extra.a), a_src);
+    const b = try sema.coerce(block, vec_ty, sema.resolveInst(extra.b), b_src);
 
-    const maybe_pred = try sema.resolveValue(pred);
-    const maybe_a = try sema.resolveValue(a);
-    const maybe_b = try sema.resolveValue(b);
+    const maybe_pred = sema.resolveValue(pred);
+    const maybe_a = sema.resolveValue(a);
+    const maybe_b = sema.resolveValue(b);
 
     const runtime_src = if (maybe_pred) |pred_val| rs: {
         if (pred_val.isUndef(zcu)) return pt.undefRef(vec_ty);
@@ -23041,7 +23040,7 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const order_src   = block.builtinCallArgSrc(inst_data.src_node, 2);
     // zig fmt: on
     const elem_ty = try sema.resolveType(block, elem_ty_src, extra.elem_type);
-    const uncasted_ptr = try sema.resolveInst(extra.ptr);
+    const uncasted_ptr = sema.resolveInst(extra.ptr);
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, true);
     const order = try sema.resolveAtomicOrder(block, order_src, extra.ordering, .{ .simple = .atomic_order });
 
@@ -23090,9 +23089,9 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     const operand_src    = block.builtinCallArgSrc(inst_data.src_node, 3);
     const order_src      = block.builtinCallArgSrc(inst_data.src_node, 4);
     // zig fmt: on
-    const operand = try sema.resolveInst(extra.operand);
+    const operand = sema.resolveInst(extra.operand);
     const elem_ty = sema.typeOf(operand);
-    const uncasted_ptr = try sema.resolveInst(extra.ptr);
+    const uncasted_ptr = sema.resolveInst(extra.ptr);
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, false);
     const op = try sema.resolveAtomicRmwOp(block, op_src, extra.operation);
 
@@ -23119,7 +23118,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
     const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
-        const maybe_operand_val = try sema.resolveValue(operand);
+        const maybe_operand_val = sema.resolveValue(operand);
         const operand_val = maybe_operand_val orelse {
             try sema.checkPtrIsNotComptimeMutable(block, ptr_val, ptr_src, operand_src);
             break :rs operand_src;
@@ -23170,9 +23169,9 @@ fn zirAtomicStore(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 2);
     const order_src   = block.builtinCallArgSrc(inst_data.src_node, 3);
     // zig fmt: on
-    const operand = try sema.resolveInst(extra.operand);
+    const operand = sema.resolveInst(extra.operand);
     const elem_ty = sema.typeOf(operand);
-    const uncasted_ptr = try sema.resolveInst(extra.ptr);
+    const uncasted_ptr = sema.resolveInst(extra.ptr);
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, false);
     const order = try sema.resolveAtomicOrder(block, order_src, extra.ordering, .{ .simple = .atomic_order });
 
@@ -23203,14 +23202,14 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const mulend2_src = block.builtinCallArgSrc(inst_data.src_node, 2);
     const addend_src = block.builtinCallArgSrc(inst_data.src_node, 3);
 
-    const addend = try sema.resolveInst(extra.addend);
+    const addend = sema.resolveInst(extra.addend);
     const ty = sema.typeOf(addend);
-    const mulend1 = try sema.coerce(block, ty, try sema.resolveInst(extra.mulend1), mulend1_src);
-    const mulend2 = try sema.coerce(block, ty, try sema.resolveInst(extra.mulend2), mulend2_src);
+    const mulend1 = try sema.coerce(block, ty, sema.resolveInst(extra.mulend1), mulend1_src);
+    const mulend2 = try sema.coerce(block, ty, sema.resolveInst(extra.mulend2), mulend2_src);
 
-    const maybe_mulend1 = try sema.resolveValue(mulend1);
-    const maybe_mulend2 = try sema.resolveValue(mulend2);
-    const maybe_addend = try sema.resolveValue(addend);
+    const maybe_mulend1 = sema.resolveValue(mulend1);
+    const maybe_mulend2 = sema.resolveValue(mulend2);
+    const maybe_addend = sema.resolveValue(addend);
     const pt = sema.pt;
     const zcu = pt.zcu;
 
@@ -23272,10 +23271,10 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const call_src = block.nodeOffset(inst_data.src_node);
 
     const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data;
-    const func = try sema.resolveInst(extra.callee);
+    const func = sema.resolveInst(extra.callee);
 
     const modifier_ty = try sema.getBuiltinType(call_src, .CallModifier);
-    const air_ref = try sema.resolveInst(extra.modifier);
+    const air_ref = sema.resolveInst(extra.modifier);
     const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);
     const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{ .simple = .call_modifier });
     var modifier = try sema.interpretBuiltinType(block, modifier_src, modifier_val, std.builtin.CallModifier);
@@ -23313,7 +23312,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         },
     }
 
-    const args = try sema.resolveInst(extra.args);
+    const args = sema.resolveInst(extra.args);
 
     const args_ty = sema.typeOf(args);
     if (!args_ty.isTuple(zcu)) {
@@ -23390,7 +23389,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
         return sema.fail(block, field_name_src, "cannot get @fieldParentPtr of a comptime field", .{});
     }
 
-    const field_ptr = try sema.resolveInst(extra.field_ptr);
+    const field_ptr = sema.resolveInst(extra.field_ptr);
     const field_ptr_ty = sema.typeOf(field_ptr);
     try sema.checkPtrOperand(block, field_ptr_src, field_ptr_ty);
     const field_ptr_info = field_ptr_ty.ptrInfo(zcu);
@@ -23555,8 +23554,8 @@ fn zirMinMax(
     const src = block.nodeOffset(inst_data.src_node);
     const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1);
-    const lhs = try sema.resolveInst(extra.lhs);
-    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
     return sema.analyzeMinMax(block, src, air_tag, &.{ lhs, rhs }, &.{ lhs_src, rhs_src });
 }
 
@@ -23576,7 +23575,7 @@ fn zirMinMaxMulti(
 
     for (operands, air_refs, operand_srcs, 0..) |zir_ref, *air_ref, *op_src, i| {
         op_src.* = block.builtinCallArgSrc(src_node, @intCast(i));
-        air_ref.* = try sema.resolveInst(zir_ref);
+        air_ref.* = sema.resolveInst(zir_ref);
     }
 
     return sema.analyzeMinMax(block, src, air_tag, air_refs, operand_srcs);
@@ -23679,7 +23678,7 @@ fn analyzeMinMax(
         const operand_scalar_ty = sema.typeOf(operand).scalarType(zcu);
         const want_strat: TypeStrat = switch (operand_scalar_ty.zigTypeTag(zcu)) {
             .comptime_int => s: {
-                const val = (try sema.resolveValue(operand)).?;
+                const val = sema.resolveValue(operand).?;
                 if (val.isUndef(zcu)) break :s .none;
                 break :s .{ .int = .{
                     .all_comptime_int = true,
@@ -23698,7 +23697,7 @@ fn analyzeMinMax(
                 // (replaced with just the simple calls to `Type.minInt`/`Type.maxInt`) so that we only
                 // use the input *types* to determine the result type.
                 const min: Value, const max: Value = bounds: {
-                    if (try sema.resolveValue(operand)) |operand_val| {
+                    if (sema.resolveValue(operand)) |operand_val| {
                         if (vector_len) |len| {
                             var min = try operand_val.elemValue(pt, 0);
                             var max = min;
@@ -23804,7 +23803,7 @@ fn analyzeMinMax(
         var opt_runtime_src: ?LazySrcLoc = null;
 
         for (operands, operand_srcs) |operand, operand_src| {
-            const operand_val = try sema.resolveValue(operand) orelse {
+            const operand_val = sema.resolveValue(operand) orelse {
                 if (opt_runtime_src == null) opt_runtime_src = operand_src;
                 continue;
             };
@@ -23944,8 +23943,8 @@ fn zirMemcpy(
     const src = block.nodeOffset(inst_data.src_node);
     const dest_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const src_src = block.builtinCallArgSrc(inst_data.src_node, 1);
-    const dest_ptr = try sema.resolveInst(extra.lhs);
-    const src_ptr = try sema.resolveInst(extra.rhs);
+    const dest_ptr = sema.resolveInst(extra.lhs);
+    const src_ptr = sema.resolveInst(extra.rhs);
     const dest_ty = sema.typeOf(dest_ptr);
     const src_ty = sema.typeOf(src_ptr);
     const dest_len = try indexablePtrLenOrNone(sema, block, dest_src, dest_ptr);
@@ -24208,8 +24207,8 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const src = block.nodeOffset(inst_data.src_node);
     const dest_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const value_src = block.builtinCallArgSrc(inst_data.src_node, 1);
-    const dest_ptr = try sema.resolveInst(extra.lhs);
-    const uncoerced_elem = try sema.resolveInst(extra.rhs);
+    const dest_ptr = sema.resolveInst(extra.lhs);
+    const uncoerced_elem = sema.resolveInst(extra.rhs);
     const dest_ptr_ty = sema.typeOf(dest_ptr);
     try checkMemOperand(sema, block, dest_src, dest_ptr_ty);
 
@@ -24252,7 +24251,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
 
         const ptr_val = try sema.resolveDefinedValue(block, dest_src, dest_ptr) orelse break :rs dest_src;
         if (!sema.isComptimeMutablePtr(ptr_val)) break :rs dest_src;
-        const elem_val = try sema.resolveValue(elem) orelse break :rs value_src;
+        const elem_val = sema.resolveValue(elem) orelse break :rs value_src;
         const array_ty = try pt.arrayType(.{
             .child = dest_elem_ty.toIntern(),
             .len = len_u64,
@@ -24322,7 +24321,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
         const cc_ty = try sema.getBuiltinType(cc_src, .CallingConvention);
-        const uncoerced_cc = try sema.resolveInst(cc_ref);
+        const uncoerced_cc = sema.resolveInst(cc_ref);
         const coerced_cc = try sema.coerce(block, cc_ty, uncoerced_cc, cc_src);
         const cc_val = try sema.resolveConstDefinedValue(block, cc_src, coerced_cc, .{ .simple = .@"callconv" });
         break :blk try sema.analyzeValueAsCallconv(block, cc_src, cc_val);
@@ -24439,7 +24438,7 @@ fn zirCDefine(
     const val_src = block.builtinCallArgSrc(extra.node, 1);
 
     const name = try sema.resolveConstString(block, name_src, extra.lhs, .{ .simple = .operand_cDefine_macro_name });
-    const rhs = try sema.resolveInst(extra.rhs);
+    const rhs = sema.resolveInst(extra.rhs);
     if (sema.typeOf(rhs).zigTypeTag(zcu) != .void) {
         const value = try sema.resolveConstString(block, val_src, extra.rhs, .{ .simple = .operand_cDefine_macro_value });
         try block.c_import_buf.?.print("#define {s} {s}\n", .{ name, value });
@@ -24488,7 +24487,7 @@ fn zirWasmMemoryGrow(
     }
 
     const index: u32 = @intCast(try sema.resolveInt(block, index_src, extra.lhs, .u32, .{ .simple = .wasm_memory_index }));
-    const delta = try sema.coerce(block, .usize, try sema.resolveInst(extra.rhs), delta_src);
+    const delta = try sema.coerce(block, .usize, sema.resolveInst(extra.rhs), delta_src);
 
     try sema.requireRuntimeBlock(block, builtin_src, null);
     return block.addInst(.{
@@ -24514,7 +24513,7 @@ fn resolvePrefetchOptions(
     const ip = &zcu.intern_pool;
 
     const options_ty = try sema.getBuiltinType(src, .PrefetchOptions);
-    const options = try sema.coerce(block, options_ty, try sema.resolveInst(zir_ref), src);
+    const options = try sema.coerce(block, options_ty, sema.resolveInst(zir_ref), src);
 
     const rw_src = block.src(.{ .init_field_rw = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const locality_src = block.src(.{ .init_field_locality = src.offset.node_offset_builtin_call_arg.builtin_call_node });
@@ -24544,7 +24543,7 @@ fn zirPrefetch(
     const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
     const ptr_src = block.builtinCallArgSrc(extra.node, 0);
     const opts_src = block.builtinCallArgSrc(extra.node, 1);
-    const ptr = try sema.resolveInst(extra.lhs);
+    const ptr = sema.resolveInst(extra.lhs);
     try sema.checkPtrOperand(block, ptr_src, sema.typeOf(ptr));
 
     const options = try sema.resolvePrefetchOptions(block, opts_src, extra.rhs);
@@ -24586,7 +24585,7 @@ fn resolveExternOptions(
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
-    const options_inst = try sema.resolveInst(zir_ref);
+    const options_inst = sema.resolveInst(zir_ref);
     const extern_options_ty = try sema.getBuiltinType(src, .ExternOptions);
     const options = try sema.coerce(block, extern_options_ty, options_inst, src);
 
@@ -24738,7 +24737,7 @@ fn zirBuiltinExtern(
 
     const uncasted_ptr = try sema.analyzeNavRef(block, src, ip.indexToKey(extern_val).@"extern".owner_nav);
     // We want to cast to `ty`, but that isn't necessarily an allowed coercion.
-    if (try sema.resolveValue(uncasted_ptr)) |uncasted_ptr_val| {
+    if (sema.resolveValue(uncasted_ptr)) |uncasted_ptr_val| {
         const casted_ptr_val = try pt.getCoerced(uncasted_ptr_val, ty);
         return Air.internedToRef(casted_ptr_val.toIntern());
     } else {
@@ -24854,7 +24853,7 @@ fn zirInplaceArithResultTy(sema: *Sema, extended: Zir.Inst.Extended.InstData) Co
     const pt = sema.pt;
     const zcu = pt.zcu;
 
-    const lhs = try sema.resolveInst(@enumFromInt(extended.operand));
+    const lhs = sema.resolveInst(@enumFromInt(extended.operand));
     const lhs_ty = sema.typeOf(lhs);
 
     const op: Zir.Inst.InplaceOp = @enumFromInt(extended.small);
@@ -24879,7 +24878,7 @@ fn zirInplaceArithResultTy(sema: *Sema, extended: Zir.Inst.Extended.InstData) Co
 
 fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
-    const uncoerced_hint = try sema.resolveInst(extra.operand);
+    const uncoerced_hint = sema.resolveInst(extra.operand);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 
     const hint_ty = try sema.getBuiltinType(operand_src, .BranchHint);
@@ -26333,7 +26332,7 @@ fn structFieldVal(
             if (try field_ty.onePossibleValue(pt)) |field_val|
                 return .fromValue(field_val);
 
-            if (try sema.resolveValue(struct_byval)) |struct_val| {
+            if (sema.resolveValue(struct_byval)) |struct_val| {
                 if (struct_val.isUndef(zcu)) return pt.undefRef(field_ty);
                 return .fromValue(try struct_val.fieldValue(pt, field_index));
             }
@@ -26404,7 +26403,7 @@ fn tupleFieldValByIndex(
 
     if (try field_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
-    if (try sema.resolveValue(tuple_byval)) |tuple_val| {
+    if (sema.resolveValue(tuple_byval)) |tuple_val| {
         return switch (zcu.intern_pool.indexToKey(tuple_val.toIntern())) {
             .undef => pt.undefRef(field_ty),
             .aggregate => |aggregate| Air.internedToRef(switch (aggregate.storage) {
@@ -26564,7 +26563,7 @@ fn unionFieldVal(
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
     const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_type).enumFieldIndex(field_name, zcu).?);
 
-    if (try sema.resolveValue(union_byval)) |union_val| {
+    if (sema.resolveValue(union_byval)) |union_val| {
         if (union_val.isUndef(zcu)) return pt.undefRef(field_ty);
 
         const un = ip.indexToKey(union_val.toIntern()).un;
@@ -26895,7 +26894,7 @@ fn tupleFieldPtr(
         } })));
     }
 
-    if (try sema.resolveValue(tuple_ptr)) |tuple_ptr_val| {
+    if (sema.resolveValue(tuple_ptr)) |tuple_ptr_val| {
         const field_ptr_val = try tuple_ptr_val.ptrField(field_index, pt);
         return Air.internedToRef(field_ptr_val.toIntern());
     }
@@ -26936,7 +26935,7 @@ fn tupleField(
         return Air.internedToRef(default_value.toIntern()); // comptime field
     }
 
-    if (try sema.resolveValue(tuple)) |tuple_val| {
+    if (sema.resolveValue(tuple)) |tuple_val| {
         if (tuple_val.isUndef(zcu)) return pt.undefRef(field_ty);
         return Air.internedToRef((try tuple_val.fieldValue(pt, field_index)).toIntern());
     }
@@ -26968,7 +26967,7 @@ fn elemValArray(
         return sema.fail(block, array_src, "indexing into empty array is not allowed", .{});
     }
 
-    const maybe_undef_array_val = try sema.resolveValue(array);
+    const maybe_undef_array_val = sema.resolveValue(array);
     // index must be defined since it can access out of bounds
     const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
 
@@ -27035,7 +27034,7 @@ fn elemPtrArray(
         return sema.fail(block, array_ptr_src, "indexing into empty array is not allowed", .{});
     }
 
-    const maybe_undef_array_ptr_val = try sema.resolveValue(array_ptr);
+    const maybe_undef_array_ptr_val = sema.resolveValue(array_ptr);
     // The index must not be undefined since it can be out of bounds.
     const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
         const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(zcu));
@@ -27159,7 +27158,7 @@ fn elemPtrSlice(
 
     slice_ty.childType(zcu).assertHasLayout(zcu);
 
-    const maybe_undef_slice_val = try sema.resolveValue(slice);
+    const maybe_undef_slice_val = sema.resolveValue(slice);
     // The index must not be undefined since it can be out of bounds.
     const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
         break :o try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(zcu));
@@ -27280,7 +27279,7 @@ fn coerceExtra(
     if (dest_ty.eql(inst_ty, zcu))
         return inst;
 
-    const maybe_inst_val = try sema.resolveValue(inst);
+    const maybe_inst_val = sema.resolveValue(inst);
 
     var in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src, maybe_inst_val);
     if (in_memory_result == .ok) {
@@ -29104,7 +29103,7 @@ fn storePtr2(
         error.NotCoercible => unreachable,
         else => |e| return e,
     };
-    const maybe_operand_val = try sema.resolveValue(operand);
+    const maybe_operand_val = sema.resolveValue(operand);
 
     const runtime_src = rs: {
         const ptr_val = try sema.resolveDefinedValue(block, ptr_src, ptr) orelse break :rs ptr_src;
@@ -29157,7 +29156,7 @@ fn checkComptimeKnownStore(sema: *Sema, block: *Block, store_inst_ref: Air.Inst.
         const maybe_base_alloc = sema.base_allocs.get(ptr) orelse break :known;
         const maybe_comptime_alloc = sema.maybe_comptime_allocs.getPtr(maybe_base_alloc) orelse break :known;
 
-        if ((try sema.resolveValue(operand)) != null and
+        if (sema.resolveValue(operand) != null and
             block.runtime_index == maybe_comptime_alloc.runtime_index)
         {
             try maybe_comptime_alloc.stores.append(sema.arena, .{
@@ -29206,7 +29205,7 @@ fn checkKnownAllocPtr(sema: *Sema, block: *Block, base_ptr: Air.Inst.Ref, new_pt
 
             // If the index value is runtime-known, this pointer is also runtime-known, so
             // we must in turn make the alloc value runtime-known.
-            if (null == try sema.resolveValue(index_ref)) {
+            if (null == sema.resolveValue(index_ref)) {
                 try sema.markMaybeComptimeAllocRuntime(block, alloc_inst);
             }
         },
@@ -29312,7 +29311,7 @@ fn bitCast(
         });
     }
 
-    if (try sema.resolveValue(inst)) |val| {
+    if (sema.resolveValue(inst)) |val| {
         if (val.isUndef(zcu))
             return pt.undefRef(dest_ty);
         if (old_ty.zigTypeTag(zcu) == .error_set and dest_ty.zigTypeTag(zcu) == .error_set) {
@@ -29338,7 +29337,7 @@ fn coerceArrayPtrToSlice(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    if (try sema.resolveValue(inst)) |val| {
+    if (sema.resolveValue(inst)) |val| {
         const ptr_array_ty = sema.typeOf(inst);
         const array_ty = ptr_array_ty.childType(zcu);
         const slice_ptr_ty = dest_ty.slicePtrFieldType(zcu);
@@ -29433,7 +29432,7 @@ fn coerceCompatiblePtrs(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const inst_ty = sema.typeOf(inst);
-    if (try sema.resolveValue(inst)) |val| {
+    if (sema.resolveValue(inst)) |val| {
         if (!val.isUndef(zcu) and val.isNull(zcu) and !dest_ty.isAllowzeroPtr(zcu)) {
             return sema.fail(block, inst_src, "null pointer casted to type '{f}'", .{dest_ty.fmt(pt)});
         }
@@ -29611,7 +29610,7 @@ fn coerceArrayLike(
     // try coercion of the whole array
     const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src, null);
     if (in_memory_result == .ok) {
-        if (try sema.resolveValue(inst)) |inst_val| {
+        if (sema.resolveValue(inst)) |inst_val| {
             // These types share the same comptime value representation.
             return sema.coerceInMemory(inst_val, dest_ty);
         }
@@ -29634,7 +29633,7 @@ fn coerceArrayLike(
     }
 
     const dest_elem_ty = dest_ty.childType(zcu);
-    if (dest_ty.isVector(zcu) and inst_ty.isVector(zcu) and (try sema.resolveValue(inst)) == null) {
+    if (dest_ty.isVector(zcu) and inst_ty.isVector(zcu) and sema.resolveValue(inst) == null) {
         const inst_elem_ty = inst_ty.childType(zcu);
         switch (dest_elem_ty.zigTypeTag(zcu)) {
             .int => if (inst_elem_ty.isInt(zcu)) {
@@ -29674,7 +29673,7 @@ fn coerceArrayLike(
         const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);
         ref.* = coerced;
         if (runtime_src == null) {
-            if (try sema.resolveValue(coerced)) |elem_val| {
+            if (sema.resolveValue(coerced)) |elem_val| {
                 val.* = elem_val.toIntern();
             } else {
                 runtime_src = elem_src;
@@ -29735,7 +29734,7 @@ fn coerceTupleToArray(
         const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);
         ref.* = coerced;
         if (runtime_src == null) {
-            if (try sema.resolveValue(coerced)) |elem_val| {
+            if (sema.resolveValue(coerced)) |elem_val| {
                 val.* = elem_val.toIntern();
             } else {
                 runtime_src = elem_src;
@@ -29844,7 +29843,7 @@ fn coerceTupleToTuple(
         const coerced = try sema.coerce(block, .fromInterned(field_ty), elem_ref, field_src);
         field_refs[field_index] = coerced;
         if (default_val != .none) {
-            const init_val = (try sema.resolveValue(coerced)) orelse {
+            const init_val = sema.resolveValue(coerced) orelse {
                 return sema.failWithNeededComptime(block, field_src, .{ .simple = .stored_to_comptime_field });
             };
 
@@ -29853,7 +29852,7 @@ fn coerceTupleToTuple(
             }
         }
         if (runtime_src == null) {
-            if (try sema.resolveValue(coerced)) |field_val| {
+            if (sema.resolveValue(coerced)) |field_val| {
                 field_vals[field_index] = field_val.toIntern();
             } else {
                 runtime_src = field_src;
@@ -30125,7 +30124,7 @@ fn analyzeRef(
     const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
 
-    if (try sema.resolveValue(operand)) |val| {
+    if (sema.resolveValue(operand)) |val| {
         switch (zcu.intern_pool.indexToKey(val.toIntern())) {
             .@"extern" => |e| return sema.analyzeNavRef(block, src, e.owner_nav),
             .func => |f| return sema.analyzeNavRef(block, src, f.owner_nav),
@@ -30209,7 +30208,7 @@ fn analyzeSlicePtr(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const result_ty = slice_ty.slicePtrFieldType(zcu);
-    if (try sema.resolveValue(slice)) |val| {
+    if (sema.resolveValue(slice)) |val| {
         if (val.isUndef(zcu)) return pt.undefRef(result_ty);
         return Air.internedToRef(val.slicePtr(zcu).toIntern());
     }
@@ -30229,7 +30228,7 @@ fn analyzeOptionalSlicePtr(
     const slice_ty = opt_slice_ty.optionalChild(zcu);
     const result_ty = slice_ty.slicePtrFieldType(zcu);
 
-    if (try sema.resolveValue(opt_slice)) |opt_val| {
+    if (sema.resolveValue(opt_slice)) |opt_val| {
         if (opt_val.isUndef(zcu)) return pt.undefRef(result_ty);
         const slice_ptr: InternPool.Index = if (opt_val.optionalValue(zcu)) |val|
             val.slicePtr(zcu).toIntern()
@@ -30253,7 +30252,7 @@ fn analyzeSliceLen(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    if (try sema.resolveValue(slice_inst)) |slice_val| {
+    if (sema.resolveValue(slice_inst)) |slice_val| {
         if (slice_val.isUndef(zcu)) {
             return .undef_usize;
         }
@@ -30272,7 +30271,7 @@ fn analyzeIsNull(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const result_ty: Type = .bool;
-    if (try sema.resolveValue(operand)) |opt_val| {
+    if (sema.resolveValue(operand)) |opt_val| {
         if (opt_val.isUndef(zcu)) {
             return pt.undefRef(result_ty);
         }
@@ -30306,7 +30305,7 @@ fn resolvePtrIsNonErrVal(
     }
     assert(child_ty.zigTypeTag(zcu) == .error_union);
 
-    if (try sema.resolveValue(operand)) |eu_ptr_val| {
+    if (sema.resolveValue(operand)) |eu_ptr_val| {
         if (eu_ptr_val.isUndef(zcu)) return .undef_bool;
         if (try sema.pointerDeref(block, src, eu_ptr_val, ptr_ty)) |err_union| {
             if (err_union.isUndef(zcu)) return .undef_bool;
@@ -30329,7 +30328,7 @@ fn resolveIsNonErrVal(
     }
     assert(sema.typeOf(operand).zigTypeTag(zcu) == .error_union);
 
-    if (try sema.resolveValue(operand)) |err_union| {
+    if (sema.resolveValue(operand)) |err_union| {
         if (err_union.isUndef(zcu)) return .undef_bool;
         return .makeBool(err_union.getErrorName(zcu) == .none);
     }
@@ -30681,7 +30680,7 @@ fn analyzeSlice(
                     break :end try sema.coerce(block, .usize, uncasted_end, end_src);
                 } else try sema.coerce(block, .usize, uncasted_end_opt, end_src);
                 if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| {
-                    if (try sema.resolveValue(ptr_or_slice)) |slice_val| {
+                    if (sema.resolveValue(ptr_or_slice)) |slice_val| {
                         if (slice_val.isUndef(zcu)) {
                             return sema.fail(block, src, "slice of undefined", .{});
                         }
@@ -30803,7 +30802,7 @@ fn analyzeSlice(
                 );
             }
             checked_start_lte_end = true;
-            if (try sema.resolveValue(new_ptr)) |ptr_val| sentinel_check: {
+            if (sema.resolveValue(new_ptr)) |ptr_val| sentinel_check: {
                 const expected_sentinel = sentinel orelse break :sentinel_check;
                 const start_int = start_val.toUnsignedInt(zcu);
                 const end_int = end_val.toUnsignedInt(zcu);
@@ -30887,7 +30886,7 @@ fn analyzeSlice(
             },
         });
 
-        const opt_new_ptr_val = try sema.resolveValue(new_ptr);
+        const opt_new_ptr_val = sema.resolveValue(new_ptr);
         const new_ptr_val = opt_new_ptr_val orelse {
             const result = try block.addBitCast(return_ty, new_ptr);
             if (block.wantSafety()) {
@@ -31034,8 +31033,8 @@ fn cmpNumeric(
     else
         uncasted_rhs;
 
-    const maybe_lhs_val = try sema.resolveValue(lhs);
-    const maybe_rhs_val = try sema.resolveValue(rhs);
+    const maybe_lhs_val = sema.resolveValue(lhs);
+    const maybe_rhs_val = sema.resolveValue(rhs);
 
     // If the LHS is const, check if there is a guaranteed result which does not depend on ths RHS value.
     if (maybe_lhs_val) |lhs_val| {
@@ -31320,8 +31319,8 @@ fn cmpVector(
         .child = .bool_type,
     });
 
-    const maybe_lhs_val = try sema.resolveValue(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValue(casted_rhs);
+    const maybe_lhs_val = sema.resolveValue(casted_lhs);
+    const maybe_rhs_val = sema.resolveValue(casted_rhs);
     if (maybe_lhs_val) |v| if (v.isUndef(zcu)) return pt.undefRef(result_ty);
     if (maybe_rhs_val) |v| if (v.isUndef(zcu)) return pt.undefRef(result_ty);
 
@@ -31343,7 +31342,7 @@ fn wrapOptional(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
-    if (try sema.resolveValue(inst)) |val| {
+    if (sema.resolveValue(inst)) |val| {
         return Air.internedToRef((try sema.pt.intern(.{ .opt = .{
             .ty = dest_ty.toIntern(),
             .val = val.toIntern(),
@@ -31365,7 +31364,7 @@ fn wrapErrorUnionPayload(
     const zcu = pt.zcu;
     const dest_payload_ty = dest_ty.errorUnionPayload(zcu);
     const coerced = try sema.coerceExtra(block, dest_payload_ty, inst, inst_src, .{ .report_err = false });
-    if (try sema.resolveValue(coerced)) |val| {
+    if (sema.resolveValue(coerced)) |val| {
         return Air.internedToRef((try pt.intern(.{ .error_union = .{
             .ty = dest_ty.toIntern(),
             .val = .{ .payload = val.toIntern() },
@@ -31387,7 +31386,7 @@ fn wrapErrorUnionSet(
     const ip = &zcu.intern_pool;
     const inst_ty = sema.typeOf(inst);
     const dest_err_set_ty = dest_ty.errorUnionSet(zcu);
-    if (try sema.resolveValue(inst)) |val| {
+    if (sema.resolveValue(inst)) |val| {
         const expected_name = zcu.intern_pool.indexToKey(val.toIntern()).err.name;
         switch (dest_err_set_ty.toIntern()) {
             .anyerror_type => {},
@@ -31449,7 +31448,7 @@ fn unionToTag(
     const pt = sema.pt;
     const zcu = pt.zcu;
     if (try enum_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
-    if (try sema.resolveValue(un)) |un_val| {
+    if (sema.resolveValue(un)) |un_val| {
         const tag_val = un_val.unionTag(zcu).?;
         if (tag_val.isUndef(zcu))
             return try pt.undefRef(enum_ty);
@@ -31796,7 +31795,7 @@ fn resolvePeerTypes(
 
     for (instructions, peer_tys, peer_vals) |inst, *ty, *val| {
         ty.* = sema.typeOf(inst);
-        val.* = try sema.resolveValue(inst);
+        val.* = sema.resolveValue(inst);
     }
 
     switch (try sema.resolvePeerTypesInner(block, src, peer_tys, peer_vals)) {
@@ -32863,7 +32862,7 @@ fn resolvePeerTypesInner(
                         },
                         else => |e| return e,
                     };
-                    const coerced_val = (try sema.resolveValue(coerced_inst)) orelse continue;
+                    const coerced_val = sema.resolveValue(coerced_inst) orelse continue;
                     const existing = comptime_val orelse {
                         comptime_val = coerced_val;
                         continue;
@@ -33225,7 +33224,7 @@ fn isComptimeKnown(
     sema: *Sema,
     inst: Air.Inst.Ref,
 ) !bool {
-    return (try sema.resolveValue(inst)) != null;
+    return sema.resolveValue(inst) != null;
 }
 
 /// Asserts that the layout of `var_type` has already been resolved.
@@ -33275,7 +33274,7 @@ fn resolveAddressSpace(
     zir_ref: Zir.Inst.Ref,
     ctx: std.Target.AddressSpaceContext,
 ) !std.builtin.AddressSpace {
-    const air_ref = try sema.resolveInst(zir_ref);
+    const air_ref = sema.resolveInst(zir_ref);
     return sema.analyzeAsAddressSpace(block, src, air_ref, ctx);
 }
 
@@ -34305,7 +34304,7 @@ fn setTypeName(
                     // If not then this is a struct type being returned from a non-generic
                     // function and the name doesn't matter since it will later
                     // result in a compile error.
-                    const arg_val = try sema.resolveValue(arg) orelse {
+                    const arg_val = sema.resolveValue(arg) orelse {
                         continue :strat .anon;
                     };
 
-- 
2.54.0


From 334189ce6d20d6d1100f115252d5589fadb064b1 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 27 Jan 2026 11:46:48 +0000
Subject: [PATCH 420/499] compiler: simplify IESes

It is always a bug in Sema to check whether an IES is resolved. This is
because whether the IES is resolved depends on whether the function
which owns it has been analyzed yet, which depends on the order the
compiler analyzes declarations in, which it is incorrect to have any
dependency on. Instead, we must always either not look at the resolved
set, or resolve it first (with `Sema.ensureFuncIesResolved`) and then
look at the definitely-resolved concrete error set.

Luckily, removing a bunch of the buggy logic which tried to
opportunistically use already-resolved inferred error sets actually
didn't regress anything! It seems this logic was mostly left over from
before Andrew reworked inferred error sets, and had become essentially
dead code. This is because inferred error sets are stricter than they
used to be, and in particular, we make no attempt to support mutual
recursion.

I suspect that most of the logic touching IESes can be simplified even
further than I have done here without regressing any existing code; my
goal in this commit was just to remove any *buggy* code I could find.
---
 src/Sema.zig                 | 560 ++++++++++++++---------------------
 src/Sema/type_resolution.zig |  10 +-
 src/Type.zig                 |  11 +-
 src/Value.zig                |   4 +-
 src/Zcu.zig                  |  27 +-
 5 files changed, 232 insertions(+), 380 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 09c974fb256e4709030a8e6540e468140af8131c..2fffe8ae546af74951980c583506ba82647b0d60 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7870,21 +7870,21 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
         return .anyerror_type;
     }
 
-    if (ip.isInferredErrorSetType(lhs_ty.toIntern())) {
-        switch (try sema.resolveInferredErrorSet(block, src, lhs_ty.toIntern())) {
-            // isAnyError might have changed from a false negative to a true
-            // positive after resolution.
-            .anyerror_type => return .anyerror_type,
-            else => {},
-        }
+    switch (ip.indexToKey(lhs_ty.toIntern())) {
+        .inferred_error_set_type => |func_index| {
+            try sema.ensureFuncIesResolved(block, src, func_index);
+            if (ip.funcIesResolvedUnordered(func_index) == .anyerror_type) return .anyerror_type;
+        },
+        .error_set_type => {},
+        else => unreachable,
     }
-    if (ip.isInferredErrorSetType(rhs_ty.toIntern())) {
-        switch (try sema.resolveInferredErrorSet(block, src, rhs_ty.toIntern())) {
-            // isAnyError might have changed from a false negative to a true
-            // positive after resolution.
-            .anyerror_type => return .anyerror_type,
-            else => {},
-        }
+    switch (ip.indexToKey(rhs_ty.toIntern())) {
+        .inferred_error_set_type => |func_index| {
+            try sema.ensureFuncIesResolved(block, src, func_index);
+            if (ip.funcIesResolvedUnordered(func_index) == .anyerror_type) return .anyerror_type;
+        },
+        .error_set_type => {},
+        else => unreachable,
     }
 
     const err_set_ty = try sema.errorSetMerge(lhs_ty, rhs_ty);
@@ -12000,7 +12000,7 @@ fn wantSwitchProngBodyAnalysis(
     if (err_set and prong_is_comptime_unreach) {
         const item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
         const err_name = item_val.getErrorName(zcu).unwrap().?;
-        if (!Type.errorSetHasFieldIp(&zcu.intern_pool, operand_ty.toIntern(), err_name)) return false;
+        if (!operand_ty.errorSetHasField(err_name, zcu)) return false;
     }
     return true;
 }
@@ -21023,34 +21023,61 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
         else => unreachable,
     };
 
-    const disjoint = disjoint: {
-        // Try avoiding resolving inferred error sets if we can
-        if (!dest_err_ty.isAnyError(zcu) and dest_err_ty.errorSetIsEmpty(zcu)) break :disjoint true;
-        if (!operand_err_ty.isAnyError(zcu) and operand_err_ty.errorSetIsEmpty(zcu)) break :disjoint true;
-        if (dest_err_ty.isAnyError(zcu)) break :disjoint false;
-        if (operand_err_ty.isAnyError(zcu)) break :disjoint false;
-        const dest_err_names = dest_err_ty.errorSetNames(zcu);
-        for (0..dest_err_names.len) |dest_err_index| {
-            if (Type.errorSetHasFieldIp(ip, operand_err_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))
-                break :disjoint false;
-        }
+    switch (ip.indexToKey(operand_err_ty.toIntern())) {
+        .inferred_error_set_type => |func| try sema.ensureFuncIesResolved(block, src, func),
+        else => {},
+    }
 
-        if (!ip.isInferredErrorSetType(dest_err_ty.toIntern()) and
-            !ip.isInferredErrorSetType(operand_err_ty.toIntern()))
-        {
-            break :disjoint true;
-        }
-
-        _ = try sema.resolveInferredErrorSetTy(block, src, dest_err_ty.toIntern());
-        _ = try sema.resolveInferredErrorSetTy(block, operand_src, operand_err_ty.toIntern());
-        for (0..dest_err_names.len) |dest_err_index| {
-            if (Type.errorSetHasFieldIp(ip, operand_err_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))
-                break :disjoint false;
-        }
-
-        break :disjoint true;
+    const result: enum {
+        /// The operand and destination error sets are disjoint, i.e. have no errors in common.
+        disjoint,
+        /// The destination error set is a superset of the operand error set, so the operation is
+        /// effectively equivalent to a coercion.
+        superset,
+        /// The operand and destination error sets have *some* errors in common, but the destination
+        /// is not a superset of the operand, so a safety check may be needed.
+        overlap,
+    } = if (operand_err_ty.errorSetIsEmpty(zcu)) res: {
+        break :res .disjoint;
+    } else check: switch (dest_err_ty.toIntern()) {
+        .anyerror_type => .superset,
+        .adhoc_inferred_error_set_type => {
+            // `@errorCast` to this function's own error set.
+            try sema.fn_ret_ty_ies.?.addErrorSet(operand_err_ty, ip, sema.arena);
+            break :check .superset;
+        },
+        else => |err_set_ty| switch (ip.indexToKey(err_set_ty)) {
+            .inferred_error_set_type => |func_index| {
+                if (sema.fn_ret_ty_ies) |dst_ies| {
+                    if (dst_ies.func == func_index) {
+                        // `@errorCast` to this function's own error set.
+                        try sema.fn_ret_ty_ies.?.addErrorSet(operand_err_ty, ip, sema.arena);
+                        break :check .superset;
+                    }
+                }
+                try sema.ensureFuncIesResolved(block, src, func_index);
+                continue :check ip.funcIesResolvedUnordered(func_index);
+            },
+            .error_set_type => |dest| {
+                if (operand_err_ty.isAnyError(zcu)) break :check .superset;
+                var dest_has_all = true;
+                var dest_has_any = false;
+                for (operand_err_ty.errorSetNames(zcu).get(ip)) |operand_err_name| {
+                    if (dest.nameIndex(ip, operand_err_name) != null) {
+                        dest_has_any = true;
+                    } else {
+                        dest_has_all = false;
+                    }
+                }
+                if (!dest_has_any) break :check .disjoint;
+                if (dest_has_all) break :check .superset;
+                break :check .overlap;
+            },
+            else => unreachable,
+        },
     };
-    if (disjoint and !(operand_tag == .error_union and dest_tag == .error_union)) {
+
+    if (result == .disjoint and !(operand_tag == .error_union and dest_tag == .error_union)) {
         return sema.fail(block, src, "error sets '{f}' and '{f}' have no common errors", .{
             operand_err_ty.fmt(pt), dest_err_ty.fmt(pt),
         });
@@ -21058,25 +21085,30 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
 
     // operand must be defined since it can be an invalid error value
     if (try sema.resolveDefinedValue(block, operand_src, operand)) |operand_val| {
-        const err_name: InternPool.NullTerminatedString = switch (operand_tag) {
-            .error_set => ip.indexToKey(operand_val.toIntern()).err.name,
-            .error_union => switch (ip.indexToKey(operand_val.toIntern()).error_union.val) {
+        const err_name: InternPool.NullTerminatedString = switch (ip.indexToKey(operand_val.toIntern())) {
+            .err => |err| err.name,
+            .error_union => |eu| switch (eu.val) {
                 .err_name => |name| name,
                 .payload => |payload_val| {
                     assert(dest_tag == .error_union); // should be guaranteed from the type checks above
-                    return sema.coerce(block, dest_ty, Air.internedToRef(payload_val), operand_src);
+                    const dest_payload_ty = dest_ty.errorUnionPayload(zcu);
+                    const coerced_payload = try sema.coerce(block, dest_payload_ty, .fromIntern(payload_val), operand_src);
+                    return sema.wrapErrorUnionPayload(block, dest_ty, coerced_payload, operand_src) catch |err| switch (err) {
+                        error.NotCoercible => unreachable,
+                        else => |e| return e,
+                    };
                 },
             },
             else => unreachable,
         };
 
-        if (!dest_err_ty.isAnyError(zcu) and !Type.errorSetHasFieldIp(ip, dest_err_ty.toIntern(), err_name)) {
+        if (!dest_err_ty.isAnyError(zcu) and !dest_err_ty.errorSetHasField(err_name, zcu)) {
             return sema.fail(block, src, "'error.{f}' not a member of error set '{f}'", .{
                 err_name.fmt(ip), dest_err_ty.fmt(pt),
             });
         }
 
-        return Air.internedToRef(try pt.intern(switch (dest_tag) {
+        return .fromIntern(try pt.intern(switch (dest_tag) {
             .error_set => .{ .err = .{
                 .ty = dest_ty.toIntern(),
                 .name = err_name,
@@ -21090,21 +21122,17 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
     }
 
     const err_int_ty = try pt.errorIntType();
-    if (block.wantSafety() and !dest_err_ty.isAnyError(zcu) and
-        dest_err_ty.toIntern() != .adhoc_inferred_error_set_type and
-        zcu.backendSupportsFeature(.error_set_has_value))
-    {
+    if (block.wantSafety() and result != .superset and zcu.backendSupportsFeature(.error_set_has_value)) {
         const err_code_inst = switch (operand_tag) {
             .error_set => operand,
             .error_union => try block.addTyOp(.unwrap_errunion_err, operand_err_ty, operand),
             else => unreachable,
         };
         const err_int_inst = try block.addBitCast(err_int_ty, err_code_inst);
-
         if (dest_tag == .error_union) {
             const zero_err = try pt.intRef(err_int_ty, 0);
             const is_zero = try block.addBinOp(.cmp_eq, err_int_inst, zero_err);
-            if (disjoint) {
+            if (result == .disjoint) {
                 // Error must be zero.
                 try sema.addSafetyCheck(block, src, is_zero, .invalid_error_code);
             } else {
@@ -25599,31 +25627,28 @@ fn fieldVal(
 
             switch (child_type.zigTypeTag(zcu)) {
                 .error_set => {
-                    switch (ip.indexToKey(child_type.toIntern())) {
-                        .error_set_type => |error_set_type| blk: {
-                            if (error_set_type.nameIndex(ip, field_name) != null) break :blk;
+                    const err_set_ty: Type = err_set: switch (ip.indexToKey(child_type.toIntern())) {
+                        .inferred_error_set_type => |func_index| {
+                            try sema.ensureFuncIesResolved(block, src, func_index);
+                            const resolved_ies = ip.funcIesResolvedUnordered(func_index);
+                            continue :err_set ip.indexToKey(resolved_ies);
+                        },
+                        .error_set_type => |err_set| if (err_set.nameIndex(ip, field_name) == null) {
                             return sema.fail(block, src, "no error named '{f}' in '{f}'", .{
                                 field_name.fmt(ip), child_type.fmt(pt),
                             });
-                        },
-                        .inferred_error_set_type => {
-                            return sema.fail(block, src, "TODO handle inferred error sets here", .{});
-                        },
+                        } else child_type,
                         .simple_type => |t| {
                             assert(t == .anyerror);
                             _ = try pt.getErrorValue(field_name);
+                            break :err_set try pt.singleErrorSetType(field_name);
                         },
                         else => unreachable,
-                    }
-
-                    const error_set_type = if (!child_type.isAnyError(zcu))
-                        child_type
-                    else
-                        try pt.singleErrorSetType(field_name);
-                    return Air.internedToRef((try pt.intern(.{ .err = .{
-                        .ty = error_set_type.toIntern(),
+                    };
+                    return .fromIntern(try pt.intern(.{ .err = .{
+                        .ty = err_set_ty.toIntern(),
                         .name = field_name,
-                    } })));
+                    } }));
                 },
                 .@"union" => {
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
@@ -25832,31 +25857,26 @@ fn fieldPtr(
 
             switch (child_type.zigTypeTag(zcu)) {
                 .error_set => {
-                    switch (ip.indexToKey(child_type.toIntern())) {
-                        .error_set_type => |error_set_type| blk: {
-                            if (error_set_type.nameIndex(ip, field_name) != null) {
-                                break :blk;
-                            }
+                    const err_set_ty: Type = err_set: switch (ip.indexToKey(child_type.toIntern())) {
+                        .inferred_error_set_type => |func_index| {
+                            try sema.ensureFuncIesResolved(block, src, func_index);
+                            const resolved_ies = ip.funcIesResolvedUnordered(func_index);
+                            continue :err_set ip.indexToKey(resolved_ies);
+                        },
+                        .error_set_type => |err_set| if (err_set.nameIndex(ip, field_name) == null) {
                             return sema.fail(block, src, "no error named '{f}' in '{f}'", .{
                                 field_name.fmt(ip), child_type.fmt(pt),
                             });
-                        },
-                        .inferred_error_set_type => {
-                            return sema.fail(block, src, "TODO handle inferred error sets here", .{});
-                        },
+                        } else child_type,
                         .simple_type => |t| {
                             assert(t == .anyerror);
                             _ = try pt.getErrorValue(field_name);
+                            break :err_set try pt.singleErrorSetType(field_name);
                         },
                         else => unreachable,
-                    }
-
-                    const error_set_type = if (!child_type.isAnyError(zcu))
-                        child_type
-                    else
-                        try pt.singleErrorSetType(field_name);
+                    };
                     return uavRef(sema, try pt.intern(.{ .err = .{
-                        .ty = error_set_type.toIntern(),
+                        .ty = err_set_ty.toIntern(),
                         .name = field_name,
                     } }));
                 },
@@ -27760,23 +27780,27 @@ fn coerceExtra(
             else => {},
         },
         .error_union => switch (inst_ty.zigTypeTag(zcu)) {
-            .error_set => {
-                // E to E!T
-                return sema.wrapErrorUnionSet(block, dest_ty, inst, inst_src);
+            // E to E!T
+            .error_set => if (sema.wrapErrorUnionSet(block, dest_ty, inst, inst_src)) |res| {
+                return res;
+            } else |err| switch (err) {
+                error.NotCoercible => if (in_memory_result == .no_match) {
+                    // Try to give more useful notes
+                    const err_set_type = dest_ty.errorUnionSet(zcu);
+                    in_memory_result = try sema.coerceInMemoryAllowed(block, err_set_type, inst_ty, false, target, dest_ty_src, inst_src, maybe_inst_val);
+                },
+                else => |e| return e,
             },
-            else => eu: {
-                // T to E!T
-                return sema.wrapErrorUnionPayload(block, dest_ty, inst, inst_src) catch |err| switch (err) {
-                    error.NotCoercible => {
-                        if (in_memory_result == .no_match) {
-                            const payload_type = dest_ty.errorUnionPayload(zcu);
-                            // Try to give more useful notes
-                            in_memory_result = try sema.coerceInMemoryAllowed(block, payload_type, inst_ty, false, target, dest_ty_src, inst_src, maybe_inst_val);
-                        }
-                        break :eu;
-                    },
-                    else => |e| return e,
-                };
+            // T to E!T
+            else => if (sema.wrapErrorUnionPayload(block, dest_ty, inst, inst_src)) |res| {
+                return res;
+            } else |err| switch (err) {
+                error.NotCoercible => if (in_memory_result == .no_match) {
+                    // Try to give more useful notes
+                    const payload_type = dest_ty.errorUnionPayload(zcu);
+                    in_memory_result = try sema.coerceInMemoryAllowed(block, payload_type, inst_ty, false, target, dest_ty_src, inst_src, maybe_inst_val);
+                },
+                else => |e| return e,
             },
         },
         .@"union" => switch (inst_ty.zigTypeTag(zcu)) {
@@ -28542,89 +28566,62 @@ fn coerceInMemoryAllowedErrorSets(
     const gpa = sema.gpa;
     const ip = &zcu.intern_pool;
 
-    // Coercion to `anyerror`. Note that this check can return false negatives
-    // in case the error sets did not get resolved.
-    if (dest_ty.isAnyError(zcu)) {
-        return .ok;
-    }
-
-    if (dest_ty.toIntern() == .adhoc_inferred_error_set_type) {
-        // We are trying to coerce an error set to the current function's
-        // inferred error set.
-        const dst_ies = sema.fn_ret_ty_ies.?;
-        try dst_ies.addErrorSet(src_ty, ip, sema.arena);
-        return .ok;
-    }
-
-    if (ip.isInferredErrorSetType(dest_ty.toIntern())) {
-        const dst_ies_func_index = ip.iesFuncIndex(dest_ty.toIntern());
-        if (sema.fn_ret_ty_ies) |dst_ies| {
-            if (dst_ies.func == dst_ies_func_index) {
-                // We are trying to coerce an error set to the current function's
-                // inferred error set.
-                try dst_ies.addErrorSet(src_ty, ip, sema.arena);
-                return .ok;
-            }
-        }
-        switch (try sema.resolveInferredErrorSet(block, dest_src, dest_ty.toIntern())) {
-            // isAnyError might have changed from a false negative to a true
-            // positive after resolution.
-            .anyerror_type => return .ok,
-            else => {},
-        }
-    }
-
-    var missing_error_buf = std.array_list.Managed(InternPool.NullTerminatedString).init(gpa);
-    defer missing_error_buf.deinit();
-
-    switch (src_ty.toIntern()) {
-        .anyerror_type => switch (ip.indexToKey(dest_ty.toIntern())) {
-            .simple_type => unreachable, // filtered out above
-            .error_set_type, .inferred_error_set_type => return .from_anyerror,
-            else => unreachable,
+    const dest_set: InternPool.Key.ErrorSetType = err_set: switch (dest_ty.toIntern()) {
+        .anyerror_type => return .ok,
+        .adhoc_inferred_error_set_type => {
+            // We are trying to coerce an error set to the current function's
+            // inferred error set.
+            const dst_ies = sema.fn_ret_ty_ies.?;
+            try dst_ies.addErrorSet(src_ty, ip, sema.arena);
+            return .ok;
         },
-
-        else => switch (ip.indexToKey(src_ty.toIntern())) {
-            .inferred_error_set_type => {
-                const resolved_src_ty = try sema.resolveInferredErrorSet(block, src_src, src_ty.toIntern());
-                // src anyerror status might have changed after the resolution.
-                if (resolved_src_ty == .anyerror_type) {
-                    // dest_ty.isAnyError(zcu) == true is already checked for at this point.
-                    return .from_anyerror;
-                }
-
-                for (ip.indexToKey(resolved_src_ty).error_set_type.names.get(ip)) |key| {
-                    if (!Type.errorSetHasFieldIp(ip, dest_ty.toIntern(), key)) {
-                        try missing_error_buf.append(key);
+        else => |err_set_ty| switch (ip.indexToKey(err_set_ty)) {
+            .inferred_error_set_type => |func_index| {
+                if (sema.fn_ret_ty_ies) |dst_ies| {
+                    if (dst_ies.func == func_index) {
+                        // We are trying to coerce an error set to the current function's
+                        // inferred error set.
+                        try dst_ies.addErrorSet(src_ty, ip, sema.arena);
+                        return .ok;
                     }
                 }
-
-                if (missing_error_buf.items.len != 0) {
-                    return InMemoryCoercionResult{
-                        .missing_error = try sema.arena.dupe(InternPool.NullTerminatedString, missing_error_buf.items),
-                    };
-                }
-
-                return .ok;
+                try sema.ensureFuncIesResolved(block, dest_src, func_index);
+                continue :err_set ip.funcIesResolvedUnordered(func_index);
             },
-            .error_set_type => |error_set_type| {
-                for (error_set_type.names.get(ip)) |name| {
-                    if (!Type.errorSetHasFieldIp(ip, dest_ty.toIntern(), name)) {
-                        try missing_error_buf.append(name);
-                    }
-                }
-
-                if (missing_error_buf.items.len != 0) {
-                    return InMemoryCoercionResult{
-                        .missing_error = try sema.arena.dupe(InternPool.NullTerminatedString, missing_error_buf.items),
-                    };
-                }
-
-                return .ok;
+            .error_set_type => |err_set| err_set,
+            else => unreachable,
+        },
+    };
+
+    const src_names: InternPool.NullTerminatedString.Slice = err_set: switch (src_ty.toIntern()) {
+        .anyerror_type => return .from_anyerror,
+        else => |err_set_ty| switch (ip.indexToKey(err_set_ty)) {
+            .inferred_error_set_type => |func_index| {
+                try sema.ensureFuncIesResolved(block, src_src, func_index);
+                continue :err_set ip.funcIesResolvedUnordered(func_index);
             },
+            .error_set_type => |err_set| err_set.names,
             else => unreachable,
         },
+    };
+
+    var missing_error_buf: std.ArrayList(InternPool.NullTerminatedString) = .empty;
+    defer missing_error_buf.deinit(gpa);
+
+    for (src_names.get(ip)) |name| {
+        if (dest_set.nameIndex(ip, name) == null) {
+            try missing_error_buf.append(gpa, name);
+        }
     }
+
+    if (missing_error_buf.items.len != 0) {
+        return .{ .missing_error = try sema.arena.dupe(
+            InternPool.NullTerminatedString,
+            missing_error_buf.items,
+        ) };
+    }
+
+    return .ok;
 }
 
 fn coerceInMemoryAllowedFns(
@@ -30357,76 +30354,34 @@ fn resolveIsNonErrFromType(
 
     // exception if the error union error set is known to be empty,
     // we allow the comparison but always make it comptime-known.
-    const set_ty = ip.errorUnionSet(operand_ty.toIntern());
-    switch (set_ty) {
-        .anyerror_type => {},
-        .adhoc_inferred_error_set_type => if (sema.fn_ret_ty_ies) |ies| blk: {
-            // If the error set is empty, we must return a comptime true or false.
-            // However we want to avoid unnecessarily resolving an inferred error set
-            // in case it is already non-empty.
-            switch (ies.resolved) {
-                .anyerror_type => break :blk,
-                .none => {},
-                else => |i| if (ip.indexToKey(i).error_set_type.names.len != 0) break :blk,
-            }
-
-            if (ies.errors.count() != 0) return null;
-            switch (ies.resolved) {
-                .anyerror_type => return null,
-                .none => {},
-                else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) {
-                    0 => return .true,
-                    else => return null,
-                },
-            }
-            // We do not have a comptime answer because this inferred error
-            // set is not resolved, and an instruction later in this function
-            // body may or may not cause an error to be added to this set.
-            return null;
+    return err_set: switch (ip.errorUnionSet(operand_ty.toIntern())) {
+        .anyerror_type => null,
+        .adhoc_inferred_error_set_type => {
+            // This is *our* error set; that is, we're currently analyzing the function
+            // which owns it. Trying to resolve it now would cause a dependency loop.
+            // Instead, accept that we don't know.
+            if (true) return null;
         },
-        else => switch (ip.indexToKey(set_ty)) {
-            .error_set_type => |error_set_type| {
-                if (error_set_type.names.len == 0) return .true;
+        else => |set_ty| switch (ip.indexToKey(set_ty)) {
+            .error_set_type => |error_set_type| switch (error_set_type.names.len) {
+                0 => .true,
+                else => null,
             },
-            .inferred_error_set_type => |func_index| blk: {
-                // If the error set is empty, we must return a comptime true or false.
-                // However we want to avoid unnecessarily resolving an inferred error set
-                // in case it is already non-empty.
-                try zcu.maybeUnresolveIes(func_index);
-                switch (ip.funcIesResolvedUnordered(func_index)) {
-                    .anyerror_type => break :blk,
-                    .none => {},
-                    else => |i| if (ip.indexToKey(i).error_set_type.names.len != 0) break :blk,
-                }
+            .inferred_error_set_type => |func_index| {
                 if (sema.fn_ret_ty_ies) |ies| {
                     if (ies.func == func_index) {
-                        // Try to avoid resolving inferred error set if possible.
-                        if (ies.errors.count() != 0) return null;
-                        switch (ies.resolved) {
-                            .anyerror_type => return null,
-                            .none => {},
-                            else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) {
-                                0 => return .true,
-                                else => return null,
-                            },
-                        }
-                        // We do not have a comptime answer because this inferred error
-                        // set is not resolved, and an instruction later in this function
-                        // body may or may not cause an error to be added to this set.
+                        // This is *our* error set; that is, we're currently analyzing the function
+                        // which owns it. Trying to resolve it now would cause a dependency loop.
+                        // Instead, accept that we don't know.
                         return null;
                     }
                 }
-                const resolved_ty = try sema.resolveInferredErrorSet(block, src, set_ty);
-                if (resolved_ty == .anyerror_type)
-                    break :blk;
-                if (ip.indexToKey(resolved_ty).error_set_type.names.len == 0)
-                    return .true;
+                try sema.ensureFuncIesResolved(block, src, func_index);
+                continue :err_set ip.funcIesResolvedUnordered(func_index);
             },
             else => unreachable,
         },
-    }
-
-    return null;
+    };
 }
 
 fn analyzeIsNonErr(
@@ -31384,58 +31339,16 @@ fn wrapErrorUnionSet(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const inst_ty = sema.typeOf(inst);
     const dest_err_set_ty = dest_ty.errorUnionSet(zcu);
-    if (sema.resolveValue(inst)) |val| {
-        const expected_name = zcu.intern_pool.indexToKey(val.toIntern()).err.name;
-        switch (dest_err_set_ty.toIntern()) {
-            .anyerror_type => {},
-            .adhoc_inferred_error_set_type => ok: {
-                const ies = sema.fn_ret_ty_ies.?;
-                switch (ies.resolved) {
-                    .anyerror_type => break :ok,
-                    .none => if (.ok == try sema.coerceInMemoryAllowedErrorSets(block, dest_err_set_ty, inst_ty, inst_src, inst_src)) {
-                        break :ok;
-                    },
-                    else => |i| if (ip.indexToKey(i).error_set_type.nameIndex(ip, expected_name) != null) {
-                        break :ok;
-                    },
-                }
-                return sema.failWithTypeMismatch(block, inst_src, dest_err_set_ty, inst_ty);
-            },
-            else => switch (ip.indexToKey(dest_err_set_ty.toIntern())) {
-                .error_set_type => |error_set_type| ok: {
-                    if (error_set_type.nameIndex(ip, expected_name) != null) break :ok;
-                    return sema.failWithTypeMismatch(block, inst_src, dest_err_set_ty, inst_ty);
-                },
-                .inferred_error_set_type => |func_index| ok: {
-                    // We carefully do this in an order that avoids unnecessarily
-                    // resolving the destination error set type.
-                    try zcu.maybeUnresolveIes(func_index);
-                    switch (ip.funcIesResolvedUnordered(func_index)) {
-                        .anyerror_type => break :ok,
-                        .none => if (.ok == try sema.coerceInMemoryAllowedErrorSets(block, dest_err_set_ty, inst_ty, inst_src, inst_src)) {
-                            break :ok;
-                        },
-                        else => |i| if (ip.indexToKey(i).error_set_type.nameIndex(ip, expected_name) != null) {
-                            break :ok;
-                        },
-                    }
-
-                    return sema.failWithTypeMismatch(block, inst_src, dest_err_set_ty, inst_ty);
-                },
-                else => unreachable,
-            },
-        }
-        return Air.internedToRef((try pt.intern(.{ .error_union = .{
+    const coerced = try sema.coerceExtra(block, dest_err_set_ty, inst, inst_src, .{ .report_err = false });
+    if (try sema.resolveDefinedValue(block, inst_src, coerced)) |error_val| {
+        return .fromIntern(try pt.intern(.{ .error_union = .{
             .ty = dest_ty.toIntern(),
-            .val = .{ .err_name = expected_name },
-        } })));
+            .val = .{ .err_name = ip.indexToKey(error_val.toIntern()).err.name },
+        } }));
+    } else {
+        return block.addTyOp(.wrap_errunion_err, dest_ty, coerced);
     }
-
-    try sema.requireRuntimeBlock(block, inst_src, null);
-    const coerced = try sema.coerce(block, dest_err_set_ty, inst, inst_src);
-    return block.addTyOp(.wrap_errunion_err, dest_ty, coerced);
 }
 
 fn unionToTag(
@@ -32969,18 +32882,6 @@ fn typeIsArrayLike(sema: *Sema, ty: Type) ?ArrayLike {
     };
 }
 
-pub fn resolveIes(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-
-    if (sema.fn_ret_ty_ies) |ies| {
-        try sema.resolveInferredErrorSetPtr(block, src, ies);
-        assert(ies.resolved != .none);
-        ip.funcIesResolved(sema.func_index).* = ies.resolved;
-    }
-}
-
 fn checkIndexable(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
     const pt = sema.pt;
     if (!ty.isIndexable(pt.zcu)) {
@@ -33017,63 +32918,31 @@ fn checkMemOperand(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void
     return sema.failWithOwnedErrorMsg(block, msg);
 }
 
-/// Returns a normal error set corresponding to the fully populated inferred
-/// error set.
-fn resolveInferredErrorSet(
+/// Resolves the inferred error set of the given function, so that the corresponding concrete error
+/// set is available by calling `InternPool.funcIesResolvedUnordered` on `func_index`.
+///
+/// Asserts that `func_index` is a function. Also asserts that it is not a coerced function, because
+/// coerced functions do not own inferred error sets.
+fn ensureFuncIesResolved(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
-    ies_index: InternPool.Index,
-) CompileError!InternPool.Index {
+    func_index: InternPool.Index,
+) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const func_index = ip.iesFuncIndex(ies_index);
-    const func = zcu.funcInfo(func_index);
+
+    assert(ip.unwrapCoercedFunc(func_index) == func_index);
 
     try sema.declareDependency(.{ .func_ies = func_index });
-
-    // MLUGG TODO: this feels kinda bad now... instead check for outdated whenver we grab this?
-    try zcu.maybeUnresolveIes(func_index);
-    const resolved_ty = func.resolvedErrorSetUnordered(ip);
-    if (resolved_ty != .none) return resolved_ty;
+    try sema.addReferenceEntry(block, src, .wrap(.{ .func = func_index }));
 
     if (zcu.analysis_in_progress.contains(.wrap(.{ .func = func_index }))) {
         return sema.fail(block, src, "unable to resolve inferred error set", .{});
     }
 
-    // In order to ensure that all dependencies are properly added to the set,
-    // we need to ensure the function body is analyzed of the inferred error
-    // set. However, in the case of comptime/inline function calls with
-    // inferred error sets, each call gets an adhoc InferredErrorSet object, which
-    // has no corresponding function body.
-    const ies_func_info = zcu.typeToFunc(.fromInterned(func.ty)).?;
-    // if ies declared by a inline function with generic return type, the return_type should be generic_poison,
-    // because inline function does not create a new declaration, and the ies has been filled with analyzeCall,
-    // so here we can simply skip this case.
-    if (ies_func_info.return_type == .generic_poison_type) {
-        assert(ies_func_info.cc == .@"inline");
-    } else if (ip.errorUnionSet(ies_func_info.return_type) == ies_index) {
-        if (!Type.fromInterned(func.ty).fnHasRuntimeBits(zcu)) {
-            return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(src, "unable to resolve inferred error set of generic function", .{});
-                errdefer msg.destroy(sema.gpa);
-                try sema.errNote(zcu.navSrcLoc(func.owner_nav), msg, "generic function declared here", .{});
-                break :msg msg;
-            });
-        }
-        // In this case we are dealing with the actual InferredErrorSet object that
-        // corresponds to the function, not one created to track an inline/comptime call.
-        const orig_func_index = ip.unwrapCoercedFunc(func_index);
-        try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_func_index }));
-        try pt.ensureFuncBodyUpToDate(orig_func_index);
-    }
-
-    // This will now have been resolved by the logic at the end of `Zcu.analyzeFnBody`
-    // which calls `resolveInferredErrorSetPtr`.
-    const final_resolved_ty = func.resolvedErrorSetUnordered(ip);
-    assert(final_resolved_ty != .none);
-    return final_resolved_ty;
+    try pt.ensureFuncBodyUpToDate(func_index);
 }
 
 pub fn resolveInferredErrorSetPtr(
@@ -33091,7 +32960,9 @@ pub fn resolveInferredErrorSetPtr(
 
     for (ies.inferred_error_sets.keys()) |other_ies_index| {
         if (ies_index == other_ies_index) continue;
-        switch (try sema.resolveInferredErrorSet(block, src, other_ies_index)) {
+        const other_func_index = ip.iesFuncIndex(other_ies_index);
+        try sema.ensureFuncIesResolved(block, src, other_func_index);
+        switch (ip.funcIesResolvedUnordered(other_func_index)) {
             .anyerror_type => {
                 ies.resolved = .anyerror_type;
                 return;
@@ -33164,7 +33035,10 @@ fn resolveInferredErrorSetTy(
     if (ty == .anyerror_type) return ty;
     switch (ip.indexToKey(ty)) {
         .error_set_type => return ty,
-        .inferred_error_set_type => return sema.resolveInferredErrorSet(block, src, ty),
+        .inferred_error_set_type => |func_index| {
+            try sema.ensureFuncIesResolved(block, src, func_index);
+            return ip.funcIesResolvedUnordered(func_index);
+        },
         else => unreachable,
     }
 }
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index f346d217ae2b361af26498ba5a0f86651c1d6a08..f18cf9aaaeae1557d1a69799516d0f7687096dd0 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -132,7 +132,7 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         .src_base_inst = struct_obj.zir_index,
         .type_name_ctx = struct_obj.name,
     };
-    defer assert(block.instructions.items.len == 0);
+    defer block.instructions.deinit(gpa);
 
     // There may be old field names in here from a previous update.
     struct_obj.field_name_map.get(ip).clearRetainingCapacity();
@@ -452,6 +452,8 @@ fn resolvePackedStructLayout(
 pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
     assert(sema.owner.unwrap().struct_defaults == struct_ty.toIntern());
@@ -490,7 +492,7 @@ pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
         .src_base_inst = struct_obj.zir_index,
         .type_name_ctx = struct_obj.name,
     };
-    defer assert(block.instructions.items.len == 0);
+    defer block.instructions.deinit(gpa);
 
     return resolveStructDefaultsInner(sema, &block, &struct_obj);
 }
@@ -565,7 +567,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         .src_base_inst = union_obj.zir_index,
         .type_name_ctx = union_obj.name,
     };
-    defer assert(block.instructions.items.len == 0);
+    defer block.instructions.deinit(gpa);
 
     // MLUGG TODO: this is fucking ugly bro
     const explicit_enum_tag_ty: ?Type = if (union_obj.is_reified) ty: {
@@ -1011,7 +1013,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
         .src_base_inst = tracked_inst,
         .type_name_ctx = enum_obj.name,
     };
-    defer assert(block.instructions.items.len == 0);
+    defer block.instructions.deinit(gpa);
 
     // There may be old field names in the map from a previous update.
     enum_obj.field_name_map.get(ip).clearRetainingCapacity();
diff --git a/src/Type.zig b/src/Type.zig
index 111f6347ed2d0f72cd70db20a59dfc806fe140e8..ca94c09bf04fc00503dc414541a0861194cf4256 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -1472,14 +1472,15 @@ pub fn isError(ty: Type, zcu: *const Zcu) bool {
 /// Returns whether ty, which must be an error set, includes an error `name`.
 /// Might return a false negative if `ty` is an inferred error set and not fully
 /// resolved yet.
-pub fn errorSetHasFieldIp(
-    ip: *const InternPool,
-    ty: InternPool.Index,
+pub fn errorSetHasField(
+    ty: Type,
     name: InternPool.NullTerminatedString,
+    zcu: *const Zcu,
 ) bool {
-    return switch (ty) {
+    const ip = &zcu.intern_pool;
+    return switch (ty.toIntern()) {
         .anyerror_type => true,
-        else => switch (ip.indexToKey(ty)) {
+        else => switch (ip.indexToKey(ty.toIntern())) {
             .error_set_type => |error_set_type| error_set_type.nameIndex(ip, name) != null,
             .inferred_error_set_type => |i| switch (ip.funcIesResolvedUnordered(i)) {
                 .anyerror_type => true,
diff --git a/src/Value.zig b/src/Value.zig
index ca9ef9604627beb12c9014b9372f42eb1aac538a..de7aacd1e1f2c84737acb243aa1565ac5fc0a94b 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -641,9 +641,9 @@ pub fn readFromPackedMemory(
         .optional => {
             assert(ty.isPtrLikeOptional(zcu));
             const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena)).toUnsignedInt(zcu);
-            return Value.fromInterned(try pt.intern(.{ .opt = .{
+            return .fromInterned(try pt.intern(.{ .opt = .{
                 .ty = ty.toIntern(),
-                .val = (try pt.ptrIntValue(ty.childType(zcu), addr)).toIntern(),
+                .val = if (addr == 0) .none else (try pt.ptrIntValue(ty.childType(zcu), addr)).toIntern(),
             } }));
         },
         else => @panic("TODO implement readFromPackedMemory for more types"),
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 5aef6a11d17d13d43176c782d53b3de4287bc2af..3b17bc1c0981d1e19f57db43412f4b309484faf4 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4059,6 +4059,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
             implicit_tag: {
                 const loaded_union = zcu.typeToUnion(.fromInterned(ty)) orelse break :implicit_tag;
                 const tag_ty = loaded_union.enum_tag_type;
+                if (tag_ty == .none) break :implicit_tag;
                 if (ip.indexToKey(tag_ty).enum_type != .generated_union_tag) break :implicit_tag;
                 const gop = try types.getOrPut(gpa, tag_ty);
                 if (gop.found_existing) break :implicit_tag;
@@ -4383,32 +4384,6 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void
     }
 }
 
-/// Given the `InternPool.Index` of a function, set its resolved IES to `.none` if it
-/// may be outdated. `Sema` should do this before ever loading a resolved IES.
-pub fn maybeUnresolveIes(zcu: *Zcu, func_index: InternPool.Index) !void {
-    const unit = AnalUnit.wrap(.{ .func = func_index });
-    if (zcu.outdated.contains(unit) or zcu.potentially_outdated.contains(unit)) {
-        // We're consulting the resolved IES now, but the function is outdated, so its
-        // IES may have changed. We have to assume the IES is outdated and set the resolved
-        // set back to `.none`.
-        //
-        // This will cause `PerThread.analyzeFnBody` to mark the IES as outdated when it's
-        // eventually hit.
-        //
-        // Since the IES needs to be resolved, the function body will now definitely need
-        // re-analysis (even if the IES turns out to be the same!), so mark it as
-        // definitely-outdated if it's only PO.
-        if (zcu.potentially_outdated.fetchSwapRemove(unit)) |kv| {
-            const gpa = zcu.gpa;
-            try zcu.outdated.putNoClobber(gpa, unit, kv.value);
-            if (kv.value == 0) {
-                try zcu.outdated_ready.put(gpa, unit, {});
-            }
-        }
-        zcu.intern_pool.funcSetIesResolved(zcu.comp.io, func_index, .none);
-    }
-}
-
 pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enum) {
     ok,
     bad_arch: []const std.Target.Cpu.Arch, // value is allowed archs for cc
-- 
2.54.0


From 911294116d5df0db3b431f9117f42bf8074a3b83 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 27 Jan 2026 17:13:14 +0000
Subject: [PATCH 421/499] compiler: make type resolution lazy

...and rework some of the incremental reference tracking. Almost all
kinds of AnalUnit have one property in common: they might never be
referenced in any update despite conceptually "existing", in which case
we don't want to waste time semantically analyzing them. As of the lazy
type resolution introduced in this commit, the only units to which this
does not apply are `memoized_state` and `@"comptime"`. Previously, I had
a somewhat hacky system in `Zcu` for dealing with this, but I now have a
better understanding of the design incremental compilation is converging
on, so can implement a better solution. By finding a few unused bits
lying around (...or making them), we can represent a single bit of state
indicating whether something's corresponding units have ever been
referenced. This is akin to the units being in `Zcu.outdated`, with the
key difference being that the compiler will *not* attempt to analyze
units which are in this state. Once they are first referenced or
depended on, the flag is set to true and the unit is added to `outdated`
so that it can participate in the normal dependency resolution logic.
---
 src/InternPool.zig           | 412 ++++++++++++++++++++++++++++-------
 src/Sema.zig                 | 204 ++++++-----------
 src/Sema/LowerZon.zig        |  11 +-
 src/Sema/bitcast.zig         |   6 +-
 src/Sema/type_resolution.zig |  68 +++---
 src/Type.zig                 |  15 +-
 src/Value.zig                |   2 +-
 src/Zcu.zig                  |  97 ++-------
 src/Zcu/PerThread.zig        |  67 ++----
 9 files changed, 515 insertions(+), 367 deletions(-)

diff --git a/src/InternPool.zig b/src/InternPool.zig
index ce9622e54d57bc0703d9151a5bbd35e3ef57298c..230ef78d63dd4190c712a6b955b5ea594d89ddb6 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -546,6 +546,8 @@ pub const Nav = struct {
     analysis: ?struct {
         namespace: NamespaceIndex,
         zir_index: TrackedInst.Index,
+        /// Initially `false`. Set to `true` by `setWantNavAnalysis`.
+        wanted: bool,
     },
     status: union(enum) {
         /// This `Nav` is pending semantic analysis.
@@ -743,7 +745,7 @@ pub const Nav = struct {
     const Repr = struct {
         name: NullTerminatedString,
         fqn: NullTerminatedString,
-        // The following 1 fields are either both populated, or both `.none`.
+        // The following 2 fields are either both populated, or both `.none`.
         analysis_namespace: OptionalNamespaceIndex,
         analysis_zir_index: TrackedInst.Index.Optional,
         /// Populated only if `bits.status != .unresolved`.
@@ -762,7 +764,7 @@ pub const Nav = struct {
             @"addrspace": std.builtin.AddressSpace,
             /// Populated only if `bits.status == .type_resolved`.
             is_threadlocal: bool,
-            _: u1 = 0,
+            want_analysis: bool,
         };
 
         fn unpack(repr: Repr) Nav {
@@ -772,6 +774,7 @@ pub const Nav = struct {
                 .analysis = if (repr.analysis_namespace.unwrap()) |namespace| .{
                     .namespace = namespace,
                     .zir_index = repr.analysis_zir_index.unwrap().?,
+                    .wanted = repr.bits.want_analysis,
                 } else a: {
                     assert(repr.analysis_zir_index == .none);
                     break :a null;
@@ -824,6 +827,7 @@ pub const Nav = struct {
                     .alignment = .none,
                     .@"addrspace" = .generic,
                     .is_threadlocal = false,
+                    .want_analysis = if (nav.analysis) |a| a.wanted else false,
                 },
                 .type_resolved => |r| .{
                     .status = if (r.is_extern_decl) .type_resolved_extern_decl else .type_resolved,
@@ -831,6 +835,7 @@ pub const Nav = struct {
                     .alignment = r.alignment,
                     .@"addrspace" = r.@"addrspace",
                     .is_threadlocal = r.is_threadlocal,
+                    .want_analysis = if (nav.analysis) |a| a.wanted else false,
                 },
                 .fully_resolved => |r| .{
                     .status = .fully_resolved,
@@ -838,6 +843,7 @@ pub const Nav = struct {
                     .alignment = r.alignment,
                     .@"addrspace" = r.@"addrspace",
                     .is_threadlocal = false,
+                    .want_analysis = if (nav.analysis) |a| a.wanted else false,
                 },
             },
         };
@@ -2412,17 +2418,6 @@ pub const Key = union(enum) {
             @atomicStore(FuncAnalysis, analysis_ptr, analysis, .release);
         }
 
-        pub fn setAnalyzed(func: Func, ip: *InternPool, io: Io) void {
-            const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex;
-            extra_mutex.lockUncancelable(io);
-            defer extra_mutex.unlock(io);
-
-            const analysis_ptr = func.analysisPtr(ip);
-            var analysis = analysis_ptr.*;
-            analysis.is_analyzed = true;
-            @atomicStore(FuncAnalysis, analysis_ptr, analysis, .release);
-        }
-
         /// Returns a pointer that becomes invalid after any additions to the `InternPool`.
         fn zirBodyInstPtr(func: Func, ip: *const InternPool) *TrackedInst.Index {
             const extra = ip.getLocalShared(func.tid).extra.acquire();
@@ -3314,6 +3309,25 @@ pub const LoadedStructType = struct {
     /// May be `undefined` if `layout != .@"packed"`.
     packed_backing_mode: BackingTypeMode,
 
+    /// Initially `false`, and set to `true` once any dependency on or reference to the struct's
+    /// layout is encountered, after which it is never reset to `false`, even across incremental
+    /// updates.
+    ///
+    /// This field is purely an optimization to avoid resolving the layout of types whose layouts
+    /// are never demanded. If this field is `true` but the layout is not actually needed, the
+    /// compiler frontend resolves this by traversing the reference graph at the end of each update
+    /// with `Zcu.resolveReferences` and hiding compile errors which arise from this analysis.
+    want_layout: bool,
+    /// Initially `false`, and set to `true` once any dependency on or reference to the struct's
+    /// default field values is encountered, after which it is never reset to `false`, even across
+    /// incremental updates.
+    ///
+    /// This field is purely an optimization to avoid resolving the layout of types whose layouts
+    /// are never demanded. If this field is `true` but the layout is not actually needed, the
+    /// compiler frontend resolves this by traversing the reference graph at the end of each update
+    /// with `Zcu.resolveReferences` and hiding compile errors which arise from this analysis.
+    want_defaults: bool,
+
     // The remaining fields are only valid once the struct's layout is resolved.
     field_name_map: MapIndex,
     field_names: NullTerminatedString.Slice,
@@ -3490,6 +3504,16 @@ pub const LoadedUnionType = struct {
     /// or populate `enum_tag_type`.
     reified_field_names: NullTerminatedString.Slice,
 
+    /// Initially `false`, and set to `true` once any dependency on or reference to the struct's
+    /// layout is encountered, after which it is never reset to `false`, even across incremental
+    /// updates.
+    ///
+    /// This field is purely an optimization to avoid resolving the layout of types whose layouts
+    /// are never demanded. If this field is `true` but the layout is not actually needed, the
+    /// compiler frontend resolves this by traversing the reference graph at the end of each update
+    /// with `Zcu.resolveReferences` and hiding compile errors which arise from this analysis.
+    want_layout: bool,
+
     // The remaining fields are only valid once the union's layout is resolved.
     field_types: Index.Slice,
     field_aligns: Alignment.Slice,
@@ -3532,6 +3556,16 @@ pub const LoadedEnumType = struct {
     int_tag_mode: BackingTypeMode,
     nonexhaustive: bool,
 
+    /// Initially `false`, and set to `true` once any dependency on or reference to the struct's
+    /// layout is encountered, after which it is never reset to `false`, even across incremental
+    /// updates.
+    ///
+    /// This field is purely an optimization to avoid resolving the layout of types whose layouts
+    /// are never demanded. If this field is `true` but the layout is not actually needed, the
+    /// compiler frontend resolves this by traversing the reference graph at the end of each update
+    /// with `Zcu.resolveReferences` and hiding compile errors which arise from this analysis.
+    want_layout: bool,
+
     // The remaining fields are only valid once the enum's layout is resolved.
     int_tag_type: Index,
     field_name_map: MapIndex,
@@ -3669,6 +3703,9 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 },
                 .packed_backing_mode = undefined,
 
+                .want_layout = extra.data.flags.want_layout,
+                .want_defaults = extra.data.flags.want_defaults,
+
                 .field_name_map = extra.data.field_name_map,
                 .field_names = field_names,
                 .field_types = field_types,
@@ -3690,15 +3727,15 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
     };
     const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, item.data);
     var extra_index = extra.end;
-    const captures: CaptureValue.Slice = switch (extra.data.captures_len) {
+    const captures: CaptureValue.Slice = switch (extra.data.bits.captures_len) {
         .reified => captures: {
             extra_index += 2; // type_hash: PackedU64
             break :captures .empty;
         },
-        _ => .{
+        _ => |n| .{
             .tid = unwrapped_index.tid,
             .start = extra_index,
-            .len = @intFromEnum(extra.data.captures_len),
+            .len = @intFromEnum(n),
         },
     };
     extra_index += captures.len;
@@ -3723,13 +3760,16 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
     return .{
         .zir_index = extra.data.zir_index,
         .captures = captures,
-        .is_reified = extra.data.captures_len == .reified,
+        .is_reified = extra.data.bits.captures_len == .reified,
         .name = extra.data.name,
         .name_nav = extra.data.name_nav,
         .namespace = extra.data.namespace,
         .layout = .@"packed",
         .packed_backing_mode = backing_mode,
 
+        .want_layout = extra.data.bits.want_layout,
+        .want_defaults = extra.data.bits.want_defaults,
+
         .field_name_map = extra.data.field_name_map,
         .field_names = field_names,
         .field_types = field_types,
@@ -3813,6 +3853,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
                 .packed_backing_mode = undefined,
                 .packed_backing_int_type = undefined,
                 .reified_field_names = reified_field_names,
+                .want_layout = extra.data.flags.want_layout,
                 .field_types = field_types,
                 .field_aligns = field_aligns,
                 .has_no_possible_value = extra.data.flags.has_no_possible_value,
@@ -3828,19 +3869,19 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
     };
     const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, item.data);
     var extra_index = extra.end;
-    const captures: CaptureValue.Slice = switch (extra.data.captures_len) {
+    const captures: CaptureValue.Slice = switch (extra.data.bits.captures_len) {
         .reified => captures: {
             extra_index += 2; // type_hash: PackedU64
             break :captures .empty;
         },
-        _ => .{
+        _ => |n| .{
             .tid = unwrapped_index.tid,
             .start = extra_index,
-            .len = @intFromEnum(extra.data.captures_len),
+            .len = @intFromEnum(n),
         },
     };
     extra_index += captures.len;
-    const reified_field_names: NullTerminatedString.Slice = if (extra.data.captures_len == .reified) .{
+    const reified_field_names: NullTerminatedString.Slice = if (extra.data.bits.captures_len == .reified) .{
         .tid = unwrapped_index.tid,
         .start = extra_index,
         .len = extra.data.fields_len,
@@ -3855,7 +3896,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
     return .{
         .zir_index = extra.data.zir_index,
         .captures = captures,
-        .is_reified = extra.data.captures_len == .reified,
+        .is_reified = extra.data.bits.captures_len == .reified,
         .name = extra.data.name,
         .name_nav = extra.data.name_nav,
         .namespace = extra.data.namespace,
@@ -3866,6 +3907,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
         .packed_backing_mode = backing_mode,
         .packed_backing_int_type = extra.data.backing_int_type,
         .reified_field_names = reified_field_names,
+        .want_layout = extra.data.bits.want_layout,
         .field_types = field_types,
         .field_aligns = .empty,
         .has_no_possible_value = undefined,
@@ -3891,7 +3933,7 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
     };
     const extra = extraDataTrail(extra_list, Tag.TypeEnum, item.data);
     var extra_index: u32 = @intCast(extra.end);
-    const zir_index: TrackedInst.Index.Optional, const captures: CaptureValue.Slice, const owner_union: Index = switch (extra.data.captures_len) {
+    const zir_index: TrackedInst.Index.Optional, const captures: CaptureValue.Slice, const owner_union: Index = switch (extra.data.bits.captures_len) {
         .reified => info: {
             const zir_index: TrackedInst.Index = @enumFromInt(extra_items[extra_index]);
             extra_index += 1;
@@ -3903,13 +3945,13 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
             extra_index += 1;
             break :info .{ .none, .empty, owner_union };
         },
-        _ => info: {
+        _ => |n| info: {
             const zir_index: TrackedInst.Index = @enumFromInt(extra_items[extra_index]);
             extra_index += 1;
             const captures: CaptureValue.Slice = .{
                 .tid = unwrapped_index.tid,
                 .start = extra_index,
-                .len = @intFromEnum(extra.data.captures_len),
+                .len = @intFromEnum(n),
             };
             extra_index += captures.len;
             break :info .{ zir_index.toOptional(), captures, .none };
@@ -3935,7 +3977,7 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
     return .{
         .zir_index = zir_index,
         .captures = captures,
-        .is_reified = extra.data.captures_len == .reified,
+        .is_reified = extra.data.bits.captures_len == .reified,
         .owner_union = owner_union,
         .name = extra.data.name,
         .name_nav = extra.data.name_nav,
@@ -3943,6 +3985,7 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
         .int_tag_type = extra.data.int_tag_type,
         .int_tag_mode = if (explicit_int_tag) .explicit else .auto,
         .nonexhaustive = nonexhaustive,
+        .want_layout = extra.data.bits.want_layout,
         .field_name_map = extra.data.field_name_map,
         .field_value_map = field_value_map,
         .field_names = field_names,
@@ -5629,7 +5672,10 @@ pub const Tag = enum(u8) {
             /// Alignment of the whole struct. Always `.none` until layout resolved.
             alignment: Alignment,
 
-            _: u16 = 0,
+            want_layout: bool,
+            want_defaults: bool,
+
+            _: u14 = 0,
         };
     };
 
@@ -5641,10 +5687,7 @@ pub const Tag = enum(u8) {
     /// 4. field_default: Index             // if item tag implies field defaults; for each `fields_len`
     pub const TypeStructPacked = struct {
         zir_index: TrackedInst.Index,
-        captures_len: enum(u32) {
-            reified = std.math.maxInt(u32),
-            _,
-        },
+        bits: Bits,
 
         name: NullTerminatedString,
         name_nav: Nav.Index.Optional,
@@ -5655,6 +5698,15 @@ pub const Tag = enum(u8) {
 
         fields_len: u32,
         field_name_map: MapIndex,
+
+        const Bits = packed struct(u32) {
+            captures_len: enum(u30) {
+                reified = std.math.maxInt(u30),
+                _,
+            },
+            want_layout: bool,
+            want_defaults: bool,
+        };
     };
 
     /// For declared unions, field names are intentionally omitted because they are available in
@@ -5718,7 +5770,9 @@ pub const Tag = enum(u8) {
             /// Alignment of the whole union. Always `.none` until layout resolved.
             alignment: Alignment,
 
-            _: u15 = 0,
+            want_layout: bool,
+
+            _: u14 = 0,
         };
     };
 
@@ -5734,10 +5788,7 @@ pub const Tag = enum(u8) {
     /// 3. field_type: Index     // for each `fields_len`
     pub const TypeUnionPacked = struct {
         zir_index: TrackedInst.Index,
-        captures_len: enum(u32) {
-            reified = std.math.maxInt(u32),
-            _,
-        },
+        bits: Bits,
 
         name: NullTerminatedString,
         name_nav: Nav.Index.Optional,
@@ -5753,6 +5804,14 @@ pub const Tag = enum(u8) {
         /// to store it directly. This is also necessary for `dumpStatsFallible` to
         /// work on unresolved types.
         fields_len: u32,
+
+        const Bits = packed struct(u32) {
+            captures_len: enum(u31) {
+                reified = std.math.maxInt(u31),
+                _,
+            },
+            want_layout: bool,
+        };
     };
 
     /// Trailing:
@@ -5764,11 +5823,7 @@ pub const Tag = enum(u8) {
     /// 5. field_name: NullTerminatedString // for each `fields_len`
     /// 6. field_value: Index               // if tag is not `.type_enum_auto`; for each `fields_len`
     pub const TypeEnum = struct {
-        captures_len: enum(u32) {
-            reified = std.math.maxInt(u32),
-            generated_union_tag = std.math.maxInt(u32) - 1,
-            _,
-        },
+        bits: Bits,
 
         name: NullTerminatedString,
         name_nav: Nav.Index.Optional,
@@ -5780,6 +5835,15 @@ pub const Tag = enum(u8) {
 
         fields_len: u32,
         field_name_map: MapIndex,
+
+        const Bits = packed struct(u32) {
+            captures_len: enum(u31) {
+                reified = std.math.maxInt(u31),
+                generated_union_tag = std.math.maxInt(u31) - 1,
+                _,
+            },
+            want_layout: bool,
+        };
     };
 
     /// Trailing:
@@ -5812,7 +5876,7 @@ pub const BackingTypeMode = enum(u1) {
 /// equality or hashing, except for `inferred_error_set` which is considered
 /// to be part of the type of the function.
 pub const FuncAnalysis = packed struct(u32) {
-    is_analyzed: bool,
+    want_runtime_analysis: bool,
     branch_hint: std.builtin.BranchHint,
     is_noinline: bool,
     has_error_trace: bool,
@@ -6597,17 +6661,17 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         => .{ .struct_type = ns: {
             const extra_list = unwrapped_index.getExtra(ip);
             const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
-            break :ns switch (extra.data.captures_len) {
+            break :ns switch (extra.data.bits.captures_len) {
                 .reified => .{ .reified = .{
                     .zir_index = extra.data.zir_index,
                     .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
                 } },
-                _ => .{ .declared = .{
+                _ => |len| .{ .declared = .{
                     .zir_index = extra.data.zir_index,
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end,
-                        .len = @intFromEnum(extra.data.captures_len),
+                        .len = @intFromEnum(len),
                     } },
                 } },
             };
@@ -6637,17 +6701,17 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_union_packed_auto, .type_union_packed_explicit => .{ .union_type = ns: {
             const extra_list = unwrapped_index.getExtra(ip);
             const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, data);
-            break :ns switch (extra.data.captures_len) {
+            break :ns switch (extra.data.bits.captures_len) {
                 .reified => .{ .reified = .{
                     .zir_index = extra.data.zir_index,
                     .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
                 } },
-                _ => .{ .declared = .{
+                _ => |len| .{ .declared = .{
                     .zir_index = extra.data.zir_index,
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end,
-                        .len = @intFromEnum(extra.data.captures_len),
+                        .len = @intFromEnum(len),
                     } },
                 } },
             };
@@ -6655,7 +6719,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_enum_auto, .type_enum_explicit, .type_enum_nonexhaustive => .{ .enum_type = ns: {
             const extra_list = unwrapped_index.getExtra(ip);
             const extra = extraDataTrail(extra_list, Tag.TypeEnum, data);
-            break :ns switch (extra.data.captures_len) {
+            break :ns switch (extra.data.bits.captures_len) {
                 .reified => .{ .reified = .{
                     .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
                     .type_hash = extraData(extra_list, PackedU64, extra.end + 1).get(),
@@ -6663,12 +6727,12 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .generated_union_tag => .{ .generated_union_tag = owner_union: {
                     break :owner_union @enumFromInt(extra_list.view().items(.@"0")[extra.end]);
                 } },
-                _ => .{ .declared = .{
+                _ => |len| .{ .declared = .{
                     .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]),
                     .captures = .{ .owned = .{
                         .tid = unwrapped_index.tid,
                         .start = extra.end + 1,
-                        .len = @intFromEnum(extra.data.captures_len),
+                        .len = @intFromEnum(len),
                     } },
                 } },
             };
@@ -8138,7 +8202,11 @@ pub fn getDeclaredStructType(
 
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStructPacked{
                 .zir_index = ini.zir_index,
-                .captures_len = @enumFromInt(ini.captures.len),
+                .bits = .{
+                    .captures_len = @enumFromInt(ini.captures.len),
+                    .want_layout = false,
+                    .want_defaults = false,
+                },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
                 .namespace = undefined, // set by `finish`
@@ -8204,6 +8272,8 @@ pub fn getDeclaredStructType(
             .comptime_only = false,
             .has_runtime_bits = false,
             .alignment = .none,
+            .want_layout = false,
+            .want_defaults = false,
         },
     });
     if (ini.captures.len != 0) {
@@ -8281,7 +8351,11 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe
 
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStructPacked{
                 .zir_index = ini.zir_index,
-                .captures_len = .reified,
+                .bits = .{
+                    .captures_len = .reified,
+                    .want_layout = false,
+                    .want_defaults = false,
+                },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
                 .namespace = undefined, // set by `finish`
@@ -8352,6 +8426,8 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe
             .comptime_only = false,
             .has_runtime_bits = false,
             .alignment = .none,
+            .want_layout = false,
+            .want_defaults = false,
         },
     });
     _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash
@@ -8451,7 +8527,10 @@ pub fn getDeclaredUnionType(
 
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnionPacked{
                 .zir_index = ini.zir_index,
-                .captures_len = @enumFromInt(ini.captures.len),
+                .bits = .{
+                    .captures_len = @enumFromInt(ini.captures.len),
+                    .want_layout = false,
+                },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
                 .namespace = undefined, // set by `finish`
@@ -8509,6 +8588,7 @@ pub fn getDeclaredUnionType(
             .comptime_only = false,
             .has_runtime_bits = false,
             .alignment = .none,
+            .want_layout = false,
         },
     });
     if (ini.captures.len > 0) {
@@ -8572,7 +8652,10 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per
 
             const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnionPacked{
                 .zir_index = ini.zir_index,
-                .captures_len = .reified,
+                .bits = .{
+                    .captures_len = .reified,
+                    .want_layout = false,
+                },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
                 .namespace = undefined, // set by `finish`
@@ -8633,6 +8716,7 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per
             .comptime_only = false,
             .has_runtime_bits = false,
             .alignment = .none,
+            .want_layout = false,
         },
     });
     _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash));
@@ -8723,7 +8807,10 @@ pub fn getDeclaredEnumType(
         (if (have_values) ini.fields_len else 0)); // field_value
 
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
-        .captures_len = @enumFromInt(ini.captures.len),
+        .bits = .{
+            .captures_len = @enumFromInt(ini.captures.len),
+            .want_layout = false,
+        },
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
         .namespace = undefined, // set by `finish`
@@ -8795,7 +8882,10 @@ pub fn getReifiedEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerT
         (if (have_values) ini.fields_len else 0)); // field_value
 
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
-        .captures_len = .reified,
+        .bits = .{
+            .captures_len = .reified,
+            .want_layout = false,
+        },
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
         .namespace = undefined, // set by `finish`
@@ -8865,7 +8955,10 @@ pub fn getGeneratedEnumTagType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu
         (if (have_values) ini.fields_len else 0)); // field_value
 
     const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{
-        .captures_len = .generated_union_tag,
+        .bits = .{
+            .captures_len = .generated_union_tag,
+            .want_layout = false,
+        },
         .name = undefined, // set by `finish`
         .name_nav = undefined, // set by `finish`
         .namespace = undefined, // set by `finish`
@@ -9249,7 +9342,7 @@ pub fn getFuncDecl(
 
     const func_decl_extra_index = addExtraAssumeCapacity(extra, Tag.FuncDecl{
         .analysis = .{
-            .is_analyzed = false,
+            .want_runtime_analysis = false,
             .branch_hint = .none,
             .is_noinline = key.is_noinline,
             .has_error_trace = false,
@@ -9359,7 +9452,7 @@ pub fn getFuncDeclIes(
 
     const func_decl_extra_index = addExtraAssumeCapacity(extra, Tag.FuncDecl{
         .analysis = .{
-            .is_analyzed = false,
+            .want_runtime_analysis = false,
             .branch_hint = .none,
             .is_noinline = key.is_noinline,
             .has_error_trace = false,
@@ -9557,7 +9650,7 @@ pub fn getFuncInstance(
 
     const func_extra_index = addExtraAssumeCapacity(extra, Tag.FuncInstance{
         .analysis = .{
-            .is_analyzed = false,
+            .want_runtime_analysis = false,
             .branch_hint = .none,
             .is_noinline = arg.is_noinline,
             .has_error_trace = false,
@@ -9658,7 +9751,7 @@ fn getFuncInstanceIes(
 
     const func_extra_index = addExtraAssumeCapacity(extra, Tag.FuncInstance{
         .analysis = .{
-            .is_analyzed = false,
+            .want_runtime_analysis = false,
             .branch_hint = .none,
             .is_noinline = arg.is_noinline,
             .has_error_trace = false,
@@ -9902,9 +9995,6 @@ fn addExtraAssumeCapacity(extra: Local.Extra.Mutable, item: anytype) u32 {
             TrackedInst.Index,
             TrackedInst.Index.Optional,
             ComptimeAllocIndex,
-            @FieldType(Tag.TypeStructPacked, "captures_len"),
-            @FieldType(Tag.TypeUnionPacked, "captures_len"),
-            @FieldType(Tag.TypeEnum, "captures_len"),
             => @intFromEnum(@field(item, field.name)),
 
             u32,
@@ -9916,6 +10006,9 @@ fn addExtraAssumeCapacity(extra: Local.Extra.Mutable, item: anytype) u32 {
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
+            Tag.TypeStructPacked.Bits,
+            Tag.TypeUnionPacked.Bits,
+            Tag.TypeEnum.Bits,
             => @bitCast(@field(item, field.name)),
 
             else => @compileError("bad field type: " ++ @typeName(field.type)),
@@ -9967,9 +10060,6 @@ fn extraDataTrail(extra: Local.Extra, comptime T: type, index: u32) struct { dat
             TrackedInst.Index,
             TrackedInst.Index.Optional,
             ComptimeAllocIndex,
-            @FieldType(Tag.TypeStructPacked, "captures_len"),
-            @FieldType(Tag.TypeUnionPacked, "captures_len"),
-            @FieldType(Tag.TypeEnum, "captures_len"),
             => @enumFromInt(extra_item),
 
             u32,
@@ -9981,6 +10071,9 @@ fn extraDataTrail(extra: Local.Extra, comptime T: type, index: u32) struct { dat
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
             FuncAnalysis,
+            Tag.TypeStructPacked.Bits,
+            Tag.TypeUnionPacked.Bits,
+            Tag.TypeEnum.Bits,
             => @bitCast(extra_item),
 
             else => @compileError("bad field type: " ++ @typeName(field.type)),
@@ -10750,7 +10843,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                 .type_struct_packed_auto, .type_struct_packed_explicit => b: {
                     var n: usize = @typeInfo(Tag.TypeStructPacked).@"struct".fields.len;
                     const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
-                    switch (extra.data.captures_len) {
+                    switch (extra.data.bits.captures_len) {
                         .reified => n += 2, // type_hash: PackedU64
                         _ => |len| n += @intFromEnum(len), // capture: CaptureValue
                     }
@@ -10761,7 +10854,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                 .type_struct_packed_auto_defaults, .type_struct_packed_explicit_defaults => b: {
                     var n: usize = @typeInfo(Tag.TypeStructPacked).@"struct".fields.len;
                     const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
-                    switch (extra.data.captures_len) {
+                    switch (extra.data.bits.captures_len) {
                         .reified => n += 2, // type_hash: PackedU64
                         _ => |len| n += @intFromEnum(len), // capture: CaptureValue
                     }
@@ -10790,7 +10883,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                 .type_union_packed_auto, .type_union_packed_explicit => b: {
                     var n: usize = @typeInfo(Tag.TypeUnionPacked).@"struct".fields.len;
                     const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, data);
-                    switch (extra.data.captures_len) {
+                    switch (extra.data.bits.captures_len) {
                         .reified => n += 2, // type_hash: PackedU64
                         _ => |len| n += @intFromEnum(len), // capture: CaptureValue
                     }
@@ -10800,7 +10893,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                 .type_enum_auto => b: {
                     var n: usize = @typeInfo(Tag.TypeEnum).@"struct".fields.len;
                     const extra = extraData(extra_list, Tag.TypeEnum, data);
-                    switch (extra.captures_len) {
+                    switch (extra.bits.captures_len) {
                         .generated_union_tag => n += 1, // owner_union: Index
                         .reified => {
                             n += 1; // zir_index: TrackedInst.Index,
@@ -10817,7 +10910,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                 .type_enum_explicit, .type_enum_nonexhaustive => b: {
                     var n: usize = @typeInfo(Tag.TypeEnum).@"struct".fields.len;
                     const extra = extraData(extra_list, Tag.TypeEnum, data);
-                    switch (extra.captures_len) {
+                    switch (extra.bits.captures_len) {
                         .generated_union_tag => n += 1, // owner_union: Index
                         .reified => {
                             n += 1; // zir_index: TrackedInst.Index,
@@ -11204,6 +11297,7 @@ pub fn createDeclNav(
         .analysis = .{
             .namespace = namespace,
             .zir_index = zir_index,
+            .wanted = false,
         },
         .status = .unresolved,
     }));
@@ -12829,3 +12923,175 @@ pub fn resolveEnumLayout(
 
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeEnum, "int_tag_type").?] = @intFromEnum(int_tag_type);
 }
+
+/// Sets the "want_layout" flag on the given struct, union, or enum type. Returns true if the flag
+/// was *not* already set, meaning we have just discovered the first reference to this type's
+/// layout. This flag is never reset to false, and exists purely as an optimization; for details,
+/// see doc comments in `LoadedStructType`.
+pub fn setWantTypeLayout(ip: *InternPool, io: Io, container_type: Index) bool {
+    const unwrapped_index = container_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    switch (item.tag) {
+        .type_struct_packed_auto,
+        .type_struct_packed_explicit,
+        .type_struct_packed_auto_defaults,
+        .type_struct_packed_explicit_defaults,
+        => {
+            const bits: *Tag.TypeStructPacked.Bits = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "bits").?
+            ]);
+            if (bits.want_layout) {
+                return false;
+            } else {
+                bits.want_layout = true;
+                return true;
+            }
+        },
+
+        .type_struct => {
+            const flags: *Tag.TypeStruct.Flags = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?
+            ]);
+            if (flags.want_layout) {
+                return false;
+            } else {
+                flags.want_layout = true;
+                return true;
+            }
+        },
+
+        .type_union_packed_auto,
+        .type_union_packed_explicit,
+        => {
+            const bits: *Tag.TypeUnionPacked.Bits = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "bits").?
+            ]);
+            if (bits.want_layout) {
+                return false;
+            } else {
+                bits.want_layout = true;
+                return true;
+            }
+        },
+
+        .type_union => {
+            const flags: *Tag.TypeUnion.Flags = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeUnion, "flags").?
+            ]);
+            if (flags.want_layout) {
+                return false;
+            } else {
+                flags.want_layout = true;
+                return true;
+            }
+        },
+
+        .type_enum_auto,
+        .type_enum_explicit,
+        .type_enum_nonexhaustive,
+        => {
+            const bits: *Tag.TypeEnum.Bits = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeEnum, "bits").?
+            ]);
+            if (bits.want_layout) {
+                return false;
+            } else {
+                bits.want_layout = true;
+                return true;
+            }
+        },
+
+        else => unreachable,
+    }
+}
+
+/// Like `setWantTypeLayout`, but for the default field values of a struct (so this sets the
+/// `want_defaults` flag rather than the `want_layout` flag).
+pub fn setWantStructDefaults(ip: *InternPool, io: Io, struct_type: Index) bool {
+    const unwrapped_index = struct_type.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const extra_items = local.shared.extra.view().items(.@"0");
+    const item = unwrapped_index.getItem(ip);
+    switch (item.tag) {
+        .type_struct_packed_auto,
+        .type_struct_packed_explicit,
+        .type_struct_packed_auto_defaults,
+        .type_struct_packed_explicit_defaults,
+        => {
+            const bits: *Tag.TypeStructPacked.Bits = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "bits").?
+            ]);
+            if (bits.want_defaults) {
+                return false;
+            } else {
+                bits.want_defaults = true;
+                return true;
+            }
+        },
+
+        .type_struct => {
+            const flags: *Tag.TypeStruct.Flags = @ptrCast(&extra_items[
+                item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?
+            ]);
+            if (flags.want_defaults) {
+                return false;
+            } else {
+                flags.want_defaults = true;
+                return true;
+            }
+        },
+
+        else => unreachable,
+    }
+}
+
+/// Like `setWantTypeLayout`, but for runtime analysis of a function body, using the
+/// `FuncAnalysis.want_runtime_analysis` flag.
+pub fn setWantRuntimeFnAnalysis(ip: *InternPool, io: Io, func_index: Index) bool {
+    const unwrapped_index = func_index.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const a = funcAnalysisPtr(ip, func_index);
+    if (a.want_runtime_analysis) {
+        return false;
+    } else {
+        a.want_runtime_analysis = true;
+        return true;
+    }
+}
+
+/// Like `setWantTypeLayout`, but for runtime analysis of a `Nav`, using the `Nav.analysis.wanted` flag.
+pub fn setWantNavAnalysis(ip: *InternPool, io: Io, nav_index: Nav.Index) bool {
+    const unwrapped = nav_index.unwrap(ip);
+
+    const local = ip.getLocal(unwrapped.tid);
+    local.mutate.extra.mutex.lockUncancelable(io);
+    defer local.mutate.extra.mutex.unlock(io);
+
+    const navs = local.shared.navs.view();
+
+    if (navs.items(.analysis_namespace)[unwrapped.index] == .none) {
+        return false;
+    }
+
+    const bits = &navs.items(.bits)[unwrapped.index];
+    if (bits.want_analysis) {
+        return false;
+    } else {
+        bits.want_analysis = true;
+        return true;
+    }
+}
diff --git a/src/Sema.zig b/src/Sema.zig
index 2fffe8ae546af74951980c583506ba82647b0d60..a506a7e6bbc369bf6a9906d2cda4dd6b41450317 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3258,7 +3258,7 @@ fn zirAllocExtended(
     } else .none;
 
     if (small.has_type) {
-        try sema.ensureLayoutResolved(var_ty);
+        try sema.ensureLayoutResolved(var_ty, ty_src);
         if (block.isComptime() or small.is_comptime or var_ty.comptimeOnly(zcu)) {
             return sema.analyzeComptimeAlloc(block, var_src, var_ty, alignment);
         }
@@ -3322,7 +3322,7 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
     const var_src = block.nodeOffset(inst_data.src_node);
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    try sema.ensureLayoutResolved(var_ty);
+    try sema.ensureLayoutResolved(var_ty, ty_src);
     return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
 }
 
@@ -3743,7 +3743,7 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     const var_src = block.nodeOffset(inst_data.src_node);
 
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    try sema.ensureLayoutResolved(var_ty);
+    try sema.ensureLayoutResolved(var_ty, ty_src);
     if (block.isComptime() or var_ty.comptimeOnly(zcu)) {
         return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
     }
@@ -3775,7 +3775,7 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const var_src = block.nodeOffset(inst_data.src_node);
 
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    try sema.ensureLayoutResolved(var_ty);
+    try sema.ensureLayoutResolved(var_ty, ty_src);
     if (block.isComptime()) {
         return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
     }
@@ -4132,8 +4132,9 @@ fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcL
 fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ptr = sema.resolveInst(un_node.operand);
-    try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu));
-    return sema.optEuBasePtrInit(block, ptr, block.nodeOffset(un_node.src_node));
+    const src = block.nodeOffset(un_node.src_node);
+    try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu), src);
+    return sema.optEuBasePtrInit(block, ptr, src);
 }
 
 fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -4518,7 +4519,7 @@ fn validateStructInit(
         if (struct_ty.structFieldIsComptime(i, zcu)) continue;
 
         if (!struct_ty.isTuple(zcu)) {
-            try sema.ensureStructDefaultsResolved(struct_ty);
+            try sema.ensureStructDefaultsResolved(struct_ty, init_src);
         }
 
         const default_val = struct_ty.structFieldDefaultValue(i, zcu) orelse {
@@ -4642,7 +4643,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     }
 
     const elem_ty = operand_ty.childType(zcu);
-    try sema.ensureLayoutResolved(elem_ty);
+    try sema.ensureLayoutResolved(elem_ty, src);
 
     if (try elem_ty.onePossibleValue(pt) != null) {
         // No need to validate the actual pointer value, we don't need it!
@@ -7025,7 +7026,7 @@ fn analyzeCall(
 
         break :ret_ty full_ty;
     };
-    try sema.ensureLayoutResolved(resolved_ret_ty);
+    try sema.ensureLayoutResolved(resolved_ret_ty, func_ret_ty_src);
 
     // If we've discovered after evaluating arguments that a generic function instantiation is
     // comptime-only, then we can mark the block as comptime *now*.
@@ -7122,7 +7123,7 @@ fn analyzeCall(
                 .generic_owner = func_val.?.toIntern(),
                 .comptime_args = comptime_args,
             });
-            try sema.ensureLayoutResolved(.fromInterned(ip.typeOf(func_instance)));
+            try sema.ensureLayoutResolved(.fromInterned(ip.typeOf(func_instance)), call_src);
             if (zcu.comp.debugIncremental()) {
                 const nav = ip.indexToKey(func_instance).func.owner_nav;
                 const gop = try zcu.incremental_debug_state.navs.getOrPut(gpa, nav);
@@ -7196,7 +7197,7 @@ fn analyzeCall(
             return .unreachable_value;
         }
 
-        try sema.ensureLayoutResolved(sema.typeOf(maybe_opv));
+        try sema.ensureLayoutResolved(sema.typeOf(maybe_opv), func_ret_ty_src);
         if (try sema.typeOf(maybe_opv).onePossibleValue(pt)) |opv| {
             return .fromValue(opv);
         } else {
@@ -7270,7 +7271,7 @@ fn analyzeCall(
     // We're about to do an inline call; if the return type expression was generic, the return type
     // may not be resolved yet. It's correct to resolve it because the function is going to return a
     // value of this type.
-    try sema.ensureLayoutResolved(resolved_ret_ty);
+    try sema.ensureLayoutResolved(resolved_ret_ty, func_ret_ty_src);
 
     // For an inline call, we depend on the source code of the whole function definition.
     try sema.declareDependency(.{ .src_hash = fn_nav.analysis.?.zir_index });
@@ -7532,7 +7533,6 @@ fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
     const zcu = pt.zcu;
     const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;
     const maybe_wrapped_indexable_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, bin.lhs) orelse return .generic_poison_type;
-    try sema.ensureLayoutResolved(maybe_wrapped_indexable_ty);
     const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(zcu);
     assert(indexable_ty.isIndexable(zcu)); // validated by a previous instruction
     const elem_ty = switch (indexable_ty.zigTypeTag(zcu)) {
@@ -8040,7 +8040,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     if (dest_ty.zigTypeTag(zcu) != .@"enum") {
         return sema.fail(block, src, "expected enum, found '{f}'", .{dest_ty.fmt(pt)});
     }
-    try sema.ensureLayoutResolved(dest_ty);
+    try sema.ensureLayoutResolved(dest_ty, src);
     _ = try sema.checkIntType(block, operand_src, operand_ty);
 
     if (sema.resolveValue(operand)) |int_val| {
@@ -8103,7 +8103,7 @@ fn zirOptionalPayloadPtr(
 
     const ptr_ty = sema.typeOf(optional_ptr);
     assert(ptr_ty.zigTypeTag(sema.pt.zcu) == .pointer);
-    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu));
+    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu), src);
 
     return sema.analyzeOptionalPayloadPtr(block, src, optional_ptr, safety_check, false);
 }
@@ -8313,7 +8313,7 @@ fn zirErrUnionPayloadPtr(
 
     const ptr_ty = sema.typeOf(operand);
     assert(ptr_ty.zigTypeTag(sema.pt.zcu) == .pointer);
-    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu));
+    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu), src);
 
     return sema.analyzeErrUnionPayloadPtr(block, src, operand, false, false);
 }
@@ -9022,6 +9022,7 @@ fn funcCommon(
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
+    const src = block.nodeOffset(src_node_offset);
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = src_node_offset });
     const cc_src = block.src(.{ .node_offset_fn_type_cc = src_node_offset });
 
@@ -9091,7 +9092,7 @@ fn funcCommon(
             .lbrace_column = @as(u16, @truncate(src_locs.columns)),
             .rbrace_column = @as(u16, @truncate(src_locs.columns >> 16)),
         }));
-        try sema.ensureLayoutResolved(func_val.typeOf(zcu));
+        try sema.ensureLayoutResolved(func_val.typeOf(zcu), src);
         return .fromValue(func_val);
     }
 
@@ -9106,7 +9107,7 @@ fn funcCommon(
     });
 
     if (has_body) {
-        try sema.ensureLayoutResolved(.fromInterned(func_ty));
+        try sema.ensureLayoutResolved(.fromInterned(func_ty), src);
         return .fromIntern(try ip.getFuncDecl(gpa, io, pt.tid, .{
             .owner_nav = sema.owner.unwrap().nav_val,
             .ty = func_ty,
@@ -9762,7 +9763,7 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         return sema.failWithOwnedErrorMsg(block, msg);
     }
     try sema.checkIndexable(block, src, indexable_ty);
-    try sema.ensureLayoutResolved(indexable_ty.childType(zcu));
+    try sema.ensureLayoutResolved(indexable_ty.childType(zcu), src);
     return sema.elemPtrOneLayerOnly(block, src, array_ptr, elem_index, src, false, false);
 }
 
@@ -9983,7 +9984,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
                 err_union_ty.fmt(pt),
             });
         }
-        try sema.ensureLayoutResolved(err_union_ty);
+        try sema.ensureLayoutResolved(err_union_ty, operand_src);
 
         const non_err_cond = if (non_err_case.operand_is_ref)
             try sema.analyzePtrIsNonErr(block, operand_src, eu_maybe_ptr)
@@ -11287,7 +11288,7 @@ fn validateSwitchBlock(
         }
         break :operand_ty raw_operand_ty;
     };
-    try sema.ensureLayoutResolved(operand_ty);
+    try sema.ensureLayoutResolved(operand_ty, operand_src);
 
     const item_ty: Type = item_ty: {
         switch (operand_ty.zigTypeTag(zcu)) {
@@ -12870,7 +12871,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const name_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const ty = try sema.resolveType(block, ty_src, extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, name_src, extra.rhs, .{ .simple = .field_name });
-    try sema.ensureLayoutResolved(ty);
+    try sema.ensureLayoutResolved(ty, ty_src);
     const ip = &zcu.intern_pool;
 
     const has_field = hf: {
@@ -15270,7 +15271,7 @@ fn analyzeArithmetic(
                         else => return sema.failWithInvalidPtrArithmetic(block, src, "pointer-integer", "addition and subtraction"),
                     };
 
-                    try sema.ensureLayoutResolved(lhs_ty.childType(zcu));
+                    try sema.ensureLayoutResolved(lhs_ty.childType(zcu), src);
                     return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);
                 },
             }
@@ -15964,7 +15965,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         .@"anyframe",
         => {},
     }
-    try sema.ensureLayoutResolved(ty);
+    try sema.ensureLayoutResolved(ty, operand_src);
     return .fromValue(try pt.intValue(.comptime_int, ty.abiSize(zcu)));
 }
 
@@ -16005,7 +16006,7 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         .@"anyframe",
         => {},
     }
-    try sema.ensureLayoutResolved(operand_ty);
+    try sema.ensureLayoutResolved(operand_ty, operand_src);
     return .fromValue(try pt.intValue(.comptime_int, operand_ty.bitSize(zcu)));
 }
 
@@ -16251,7 +16252,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const type_info_ty = try sema.getBuiltinType(src, .Type);
     const type_info_tag_ty = type_info_ty.unionTagType(zcu).?;
 
-    try sema.ensureLayoutResolved(ty);
+    try sema.ensureLayoutResolved(ty, src);
 
     if (ty.typeDeclInst(zcu)) |type_decl_inst| {
         try sema.declareDependency(.{ .namespace = type_decl_inst });
@@ -16412,7 +16413,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 if (info.flags.alignment.toByteUnits()) |b| break :bytes b;
                 const elem_ty: Type = .fromInterned(info.child);
                 // MLUGG TODO: this resolution is sus, but i doubt i'll solve it in this branch
-                try sema.ensureLayoutResolved(elem_ty);
+                try sema.ensureLayoutResolved(elem_ty, src);
                 break :bytes elem_ty.abiAlignment(zcu).toByteUnits().?;
             });
 
@@ -16873,7 +16874,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .struct_type => ip.loadStructType(ty.toIntern()),
                     else => unreachable,
                 };
-                try sema.ensureStructDefaultsResolved(ty); // can't do this sooner, since it's not allowed on tuples
+                try sema.ensureStructDefaultsResolved(ty, src); // can't do this sooner, since it's not allowed on tuples
                 struct_field_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len);
 
                 for (struct_field_vals, 0..) |*field_val, field_index| {
@@ -18294,7 +18295,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
                 elem_ty.fmt(pt), bit_offset, bit_offset - host_size * 8, host_size,
             });
         }
-        try sema.ensureLayoutResolved(elem_ty);
+        try sema.ensureLayoutResolved(elem_ty, elem_ty_src);
         const elem_bit_size = elem_ty.bitSize(zcu);
         if (elem_bit_size > host_size * 8 - bit_offset) {
             return sema.fail(block, bitoffset_src, "packed type '{f}' at bit offset {d} ends {d} bits after the end of a {d} byte host integer", .{
@@ -18363,7 +18364,7 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const pt = sema.pt;
     const zcu = pt.zcu;
 
-    try sema.ensureLayoutResolved(obj_ty);
+    try sema.ensureLayoutResolved(obj_ty, ty_src);
 
     switch (obj_ty.zigTypeTag(zcu)) {
         .@"struct" => return sema.structInitEmpty(block, obj_ty, src, src),
@@ -18428,7 +18429,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
         });
     } else ty_operand;
 
-    try sema.ensureLayoutResolved(init_ty);
+    try sema.ensureLayoutResolved(init_ty, src);
 
     const obj_ty = init_ty.optEuBaseType(zcu);
 
@@ -18544,7 +18545,7 @@ fn zirStructInit(
         // The type wasn't actually known, so treat this as an anon struct init.
         return sema.structInitAnon(block, src, inst, .typed_init, extra.data, extra.end, is_ref);
     };
-    try sema.ensureLayoutResolved(result_ty);
+    try sema.ensureLayoutResolved(result_ty, src);
     const resolved_ty = result_ty.optEuBaseType(zcu);
 
     if (resolved_ty.zigTypeTag(zcu) == .@"struct") {
@@ -18751,7 +18752,7 @@ fn finishStructInit(
                     continue;
                 }
 
-                try sema.ensureStructDefaultsResolved(struct_ty);
+                try sema.ensureStructDefaultsResolved(struct_ty, init_src);
 
                 const field_default: InternPool.Index = d: {
                     if (struct_type.field_defaults.len == 0) break :d .none;
@@ -18979,17 +18980,11 @@ fn structInitAnon(
             });
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entries
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
     try sema.addTypeReferenceEntry(src, struct_ty);
-    try sema.ensureLayoutResolved(struct_ty);
+    try sema.ensureLayoutResolved(struct_ty, src);
 
     _ = opt_runtime_index orelse {
         const struct_val = try pt.aggregateValue(struct_ty, values);
@@ -19308,7 +19303,7 @@ fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const field_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const aggregate_ty = try sema.resolveType(block, ty_src, extra.container_type);
     const field_name = try sema.resolveConstStringIntern(block, field_src, extra.field_name, .{ .simple = .field_name });
-    try sema.ensureLayoutResolved(aggregate_ty);
+    try sema.ensureLayoutResolved(aggregate_ty, ty_src);
     return sema.fieldType(block, aggregate_ty, field_name, field_src, ty_src);
 }
 
@@ -19328,7 +19323,7 @@ fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(zcu);
     const zir_field_name = sema.code.nullTerminatedString(extra.name_start);
     const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_field_name, .no_embedded_nulls);
-    try sema.ensureLayoutResolved(aggregate_ty);
+    try sema.ensureLayoutResolved(aggregate_ty, ty_src);
     return sema.fieldType(block, aggregate_ty, field_name, field_name_src, ty_src);
 }
 
@@ -19431,7 +19426,7 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     if (ty.isNoReturn(zcu)) {
         return sema.fail(block, operand_src, "no align available for type '{f}'", .{ty.fmt(sema.pt)});
     }
-    try sema.ensureLayoutResolved(ty);
+    try sema.ensureLayoutResolved(ty, operand_src);
     return .fromValue(try pt.intValue(.comptime_int, ty.abiAlignment(zcu).toByteUnits().?));
 }
 
@@ -19912,7 +19907,7 @@ fn zirReifyFn(
     const param_attrs_arr = try sema.derefSliceAsArray(block, param_attrs_src, param_attrs_slice, .{ .simple = .fn_param_attrs });
 
     const ret_ty = try sema.resolveType(block, ret_ty_src, extra.ret_ty);
-    try sema.ensureLayoutResolved(ret_ty);
+    try sema.ensureLayoutResolved(ret_ty, ret_ty_src);
 
     const fn_attrs_uncoerced = sema.resolveInst(extra.fn_attrs);
     const fn_attrs_coerced = try sema.coerce(block, fn_attrs_ty, fn_attrs_uncoerced, fn_attrs_src);
@@ -19937,7 +19932,7 @@ fn zirReifyFn(
             param_types_src,
             fn_attrs.@"callconv",
         );
-        try sema.ensureLayoutResolved(param_ty);
+        try sema.ensureLayoutResolved(param_ty, param_types_src);
         if (param_ty.comptimeOnly(zcu)) {
             return sema.fail(block, param_attrs_src, "cannot reify function type with comptime-only parameter type '{f}'", .{param_ty.fmt(pt)});
         }
@@ -20253,14 +20248,6 @@ fn zirReifyStruct(
             });
             try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entries
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
 
             return .fromIntern(wip.finish(ip, new_namespace_index));
         },
@@ -20482,15 +20469,6 @@ fn zirReifyUnion(
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
             try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
 
-            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entry
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-
             return .fromIntern(wip.finish(ip, new_namespace_index));
         },
     }
@@ -20643,15 +20621,6 @@ fn zirReifyEnum(
             try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entry
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-
             return .fromIntern(wip.finish(ip, new_namespace_index));
         },
     }
@@ -20874,7 +20843,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const elem_ty = ptr_ty.nullablePtrElem(zcu);
 
     // We'll need to validate the pointer alignment.
-    try sema.ensureLayoutResolved(elem_ty);
+    try sema.ensureLayoutResolved(elem_ty, src);
     const ptr_align = ptr_ty.ptrAlignment(zcu);
 
     if (ptr_ty.isSlice(zcu)) {
@@ -21217,8 +21186,8 @@ fn ptrCastFull(
     const src_info = operand_ty.ptrInfo(zcu);
     const dest_info = dest_ty.ptrInfo(zcu);
 
-    try sema.ensureLayoutResolved(.fromInterned(src_info.child));
-    try sema.ensureLayoutResolved(.fromInterned(dest_info.child));
+    try sema.ensureLayoutResolved(.fromInterned(src_info.child), operand_src);
+    try sema.ensureLayoutResolved(.fromInterned(dest_info.child), src);
 
     const DestSliceLen = union(enum) {
         undef,
@@ -21989,7 +21958,7 @@ fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u6
     const ty = try sema.resolveType(block, ty_src, extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, field_name_src, extra.rhs, .{ .simple = .field_name });
 
-    try sema.ensureLayoutResolved(ty);
+    try sema.ensureLayoutResolved(ty, ty_src);
 
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -23072,7 +23041,7 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, true);
     const order = try sema.resolveAtomicOrder(block, order_src, extra.ordering, .{ .simple = .atomic_order });
 
-    try sema.ensureLayoutResolved(elem_ty);
+    try sema.ensureLayoutResolved(elem_ty, elem_ty_src);
 
     switch (order) {
         .release, .acq_rel => {
@@ -23392,7 +23361,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
         return sema.fail(block, inst_src, "expected single pointer type, found '{f}'", .{parent_ptr_ty.fmt(pt)});
     }
     const parent_ty: Type = .fromInterned(parent_ptr_info.child);
-    try sema.ensureLayoutResolved(parent_ty);
+    try sema.ensureLayoutResolved(parent_ty, inst_src);
     switch (parent_ty.zigTypeTag(zcu)) {
         .@"struct", .@"union" => {},
         else => return sema.fail(block, inst_src, "expected pointer to struct or union type, found '{f}'", .{parent_ptr_ty.fmt(pt)}),
@@ -24002,8 +23971,8 @@ fn zirMemcpy(
     const dest_elem_ty = dest_ty.indexableElem(zcu);
     const src_elem_ty = src_ty.indexableElem(zcu);
 
-    try sema.ensureLayoutResolved(dest_elem_ty);
-    try sema.ensureLayoutResolved(src_elem_ty);
+    try sema.ensureLayoutResolved(dest_elem_ty, dest_src);
+    try sema.ensureLayoutResolved(src_elem_ty, src_src);
 
     const imc = try sema.coerceInMemoryAllowed(
         block,
@@ -25518,7 +25487,7 @@ fn fieldPtrLoad(
     const zcu = pt.zcu;
     const object_ptr_ty = sema.typeOf(object_ptr);
     const pointee_ty = object_ptr_ty.childType(zcu);
-    try sema.ensureLayoutResolved(pointee_ty); // MLUGG TODO
+    try sema.ensureLayoutResolved(pointee_ty, src); // MLUGG TODO
     if (try pointee_ty.onePossibleValue(pt)) |opv| {
         const object: Air.Inst.Ref = .fromValue(opv);
         return fieldVal(sema, block, src, object, field_name, field_name_src);
@@ -25654,7 +25623,7 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type);
+                    try sema.ensureLayoutResolved(child_type, src);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index_usize| {
                             const field_index: u32 = @intCast(field_index_usize);
@@ -25667,7 +25636,7 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type);
+                    try sema.ensureLayoutResolved(child_type, src);
                     const field_index_usize = child_type.enumFieldIndex(field_name, zcu) orelse
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     const field_index: u32 = @intCast(field_index_usize);
@@ -25693,7 +25662,7 @@ fn fieldVal(
         },
         .@"struct" => if (is_pointer_to) {
             // Avoid loading the entire struct by fetching a pointer and loading that
-            try sema.ensureLayoutResolved(inner_ty);
+            try sema.ensureLayoutResolved(inner_ty, src);
             const field_ptr = try sema.structFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
@@ -25701,7 +25670,7 @@ fn fieldVal(
         },
         .@"union" => if (is_pointer_to) {
             // Avoid loading the entire union by fetching a pointer and loading that
-            try sema.ensureLayoutResolved(inner_ty);
+            try sema.ensureLayoutResolved(inner_ty, src);
             const field_ptr = try sema.unionFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
@@ -25884,7 +25853,7 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type);
+                    try sema.ensureLayoutResolved(child_type, src);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index| {
                             const field_index_u32: u32 = @intCast(field_index);
@@ -25898,7 +25867,7 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type);
+                    try sema.ensureLayoutResolved(child_type, src);
                     const field_index = child_type.enumFieldIndex(field_name, zcu) orelse {
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     };
@@ -25920,7 +25889,7 @@ fn fieldPtr(
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
                 object_ptr;
-            try sema.ensureLayoutResolved(inner_ty);
+            try sema.ensureLayoutResolved(inner_ty, src);
             const field_ptr = try sema.structFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty, initializing);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
@@ -25930,7 +25899,7 @@ fn fieldPtr(
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
                 object_ptr;
-            try sema.ensureLayoutResolved(inner_ty);
+            try sema.ensureLayoutResolved(inner_ty, src);
             const field_ptr = try sema.unionFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty, initializing);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
@@ -25974,7 +25943,7 @@ fn fieldCallBind(
     // Optionally dereference a second pointer to get the concrete type.
     const is_double_ptr = inner_ty.zigTypeTag(zcu) == .pointer and inner_ty.ptrSize(zcu) == .one;
     const concrete_ty = if (is_double_ptr) inner_ty.childType(zcu) else inner_ty;
-    try sema.ensureLayoutResolved(concrete_ty);
+    try sema.ensureLayoutResolved(concrete_ty, src);
     const ptr_ty = if (is_double_ptr) inner_ty else raw_ptr_ty;
     const object_ptr = if (is_double_ptr)
         try sema.analyzeLoad(block, src, raw_ptr, src)
@@ -26661,7 +26630,7 @@ fn elemPtr(
         else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{f}'", .{indexable_ptr_ty.fmt(pt)}),
     };
     try sema.checkIndexable(block, src, indexable_ty);
-    try sema.ensureLayoutResolved(indexable_ty);
+    try sema.ensureLayoutResolved(indexable_ty, src);
 
     const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {
         .array, .vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
@@ -26673,7 +26642,7 @@ fn elemPtr(
         },
         else => {
             const indexable = try sema.analyzeLoad(block, indexable_ptr_src, indexable_ptr, indexable_ptr_src);
-            try sema.ensureLayoutResolved(sema.typeOf(indexable).childType(zcu));
+            try sema.ensureLayoutResolved(sema.typeOf(indexable).childType(zcu), src);
             return elemPtrOneLayerOnly(sema, block, src, indexable, elem_index, elem_index_src, init, oob_safety);
         },
     };
@@ -26769,7 +26738,7 @@ fn elemVal(
     switch (indexable_ty.zigTypeTag(zcu)) {
         .pointer => {
             const child_ty = indexable_ty.childType(zcu);
-            try sema.ensureLayoutResolved(child_ty);
+            try sema.ensureLayoutResolved(child_ty, src);
             switch (indexable_ty.ptrSize(zcu)) {
                 .slice => return sema.elemValSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
                 .many, .c => {
@@ -27293,7 +27262,7 @@ fn coerceExtra(
     const target = zcu.getTarget();
 
     inst_ty.assertHasLayout(zcu);
-    try sema.ensureLayoutResolved(dest_ty);
+    try sema.ensureLayoutResolved(dest_ty, inst_src);
 
     // If the types are the same, we can return the operand.
     if (dest_ty.eql(inst_ty, zcu))
@@ -28657,8 +28626,8 @@ fn coerceInMemoryAllowedFns(
             } };
         }
 
-        try sema.ensureLayoutResolved(src_ty);
-        try sema.ensureLayoutResolved(dest_ty);
+        try sema.ensureLayoutResolved(src_ty, src_src);
+        try sema.ensureLayoutResolved(dest_ty, dest_src);
         const src_is_runtime = src_ty.fnHasRuntimeBits(zcu);
         const dest_is_runtime = dest_ty.fnHasRuntimeBits(zcu);
         if (src_is_runtime != dest_is_runtime) return .{ .fn_generic = !dest_is_runtime };
@@ -28712,7 +28681,7 @@ fn coerceInMemoryAllowedFns(
             const src_is_comptime = src_info.paramIsComptime(@intCast(param_i));
             const dest_is_comptime = dest_info.paramIsComptime(@intCast(param_i));
             if (src_is_comptime == dest_is_comptime) break :comptime_param;
-            try sema.ensureLayoutResolved(dest_param_ty);
+            try sema.ensureLayoutResolved(dest_param_ty, dest_src);
             if (!dest_is_mut and src_is_comptime and !dest_is_comptime and dest_param_ty.comptimeOnly(zcu)) {
                 // A parameter which is marked `comptime` can drop that annotation if the type is comptime-only.
                 // The function remains generic, and the parameter is going to be comptime-resolved either way,
@@ -28940,11 +28909,11 @@ fn coerceInMemoryAllowedPtrs(
         dest_info.child != src_info.child)
     {
         const src_align = if (src_info.flags.alignment == .none) a: {
-            try sema.ensureLayoutResolved(src_child);
+            try sema.ensureLayoutResolved(src_child, src_src);
             break :a src_child.abiAlignment(zcu);
         } else src_info.flags.alignment;
         const dest_align = if (dest_info.flags.alignment == .none) a: {
-            try sema.ensureLayoutResolved(dest_child);
+            try sema.ensureLayoutResolved(dest_child, dest_src);
             break :a dest_child.abiAlignment(zcu);
         } else dest_info.flags.alignment;
         if (dest_align.compare(if (dest_is_mut) .neq else .gt, src_align)) {
@@ -29294,7 +29263,7 @@ fn bitCast(
     const old_ty = sema.typeOf(inst);
 
     old_ty.assertHasLayout(zcu);
-    try sema.ensureLayoutResolved(dest_ty);
+    try sema.ensureLayoutResolved(dest_ty, inst_src);
 
     const dest_bits = dest_ty.bitSize(zcu);
     const old_bits = old_ty.bitSize(zcu);
@@ -29908,7 +29877,7 @@ fn analyzeNavVal(
     return sema.analyzeLoad(block, src, ref, src);
 }
 
-fn addReferenceEntry(
+pub fn addReferenceEntry(
     sema: *Sema,
     opt_block: ?*Block,
     src: LazySrcLoc,
@@ -30176,7 +30145,7 @@ fn analyzeLoad(
         return sema.fail(block, ptr_src, "cannot load opaque type '{f}'", .{elem_ty.fmt(pt)});
     }
 
-    try sema.ensureLayoutResolved(elem_ty);
+    try sema.ensureLayoutResolved(elem_ty, src);
     if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
     if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
@@ -30561,7 +30530,7 @@ fn analyzeSlice(
         else => return sema.fail(block, src, "slice of non-array type '{f}'", .{ptr_ptr_child_ty.fmt(pt)}),
     }
 
-    try sema.ensureLayoutResolved(elem_ty);
+    try sema.ensureLayoutResolved(elem_ty, src);
 
     const ptr = if (slice_ty.isSlice(zcu))
         try sema.analyzeSlicePtr(block, ptr_src, ptr_or_slice, slice_ty)
@@ -34024,7 +33993,7 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, simple_src: LazySrcLoc,
                 .type => if (uncoerced_val.typeOf(zcu).zigTypeTag(zcu) != .type) {
                     return sema.fail(block, src, "{s}.{s} is not a type", .{ parent_name, name });
                 } else val: {
-                    try sema.ensureLayoutResolved(uncoerced_val.toType());
+                    try sema.ensureLayoutResolved(uncoerced_val.toType(), src);
                     break :val uncoerced_val;
                 },
                 .func => val: {
@@ -34271,20 +34240,9 @@ fn zirStructDecl(
             });
             errdefer pt.destroyNamespace(new_namespace_index);
             try pt.scanNamespace(new_namespace_index, struct_decl.decls);
-            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .struct_defaults = wip.index }) });
 
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-            try zcu.outdated.ensureUnusedCapacity(gpa, 2);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entries
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), {});
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
@@ -34364,17 +34322,8 @@ fn zirUnionDecl(
 
             try pt.scanNamespace(new_namespace_index, union_decl.decls);
 
-            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entry
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
@@ -34434,17 +34383,8 @@ fn zirEnumDecl(
 
             try pt.scanNamespace(new_namespace_index, enum_decl.decls);
 
-            // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-            try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entry
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index bb10a39729ad41d3e74af62428b671985c13a0cf..71256ae44ddc4e6283171172bfb0cdda3f8eb50e 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -300,7 +300,7 @@ fn checkTypeInner(
         } else {
             const gop = try visited.getOrPut(sema.arena, ty.toIntern());
             if (gop.found_existing) return;
-            try sema.ensureLayoutResolved(ty);
+            try sema.ensureLayoutResolved(ty, self.import_loc);
             const struct_info = zcu.typeToStruct(ty).?;
             for (struct_info.field_types.get(ip)) |field_type| {
                 try self.checkTypeInner(.fromInterned(field_type), null, visited);
@@ -309,7 +309,7 @@ fn checkTypeInner(
         .@"union" => {
             const gop = try visited.getOrPut(sema.arena, ty.toIntern());
             if (gop.found_existing) return;
-            try sema.ensureLayoutResolved(ty);
+            try sema.ensureLayoutResolved(ty, self.import_loc);
             const union_info = zcu.typeToUnion(ty).?;
             for (union_info.field_types.get(ip)) |field_type| {
                 if (field_type != .void_type) {
@@ -646,6 +646,7 @@ fn lowerEnum(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.I
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
+    try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
     switch (node.get(self.file.zoir.?)) {
         .enum_literal => |field_name| {
             const field_name_interned = try ip.getOrPutString(
@@ -768,8 +769,8 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
 
-    try self.sema.ensureLayoutResolved(res_ty);
-    try self.sema.ensureStructDefaultsResolved(res_ty);
+    try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
+    try self.sema.ensureStructDefaultsResolved(res_ty, self.import_loc);
     const struct_info = self.sema.pt.zcu.typeToStruct(res_ty).?;
 
     const fields: @FieldType(Zoir.Node, "struct_literal") = switch (node.get(self.file.zoir.?)) {
@@ -919,7 +920,7 @@ fn lowerUnion(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
-    try self.sema.ensureLayoutResolved(res_ty);
+    try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
     const union_info = pt.zcu.typeToUnion(res_ty).?;
     const enum_tag_info = ip.loadEnumType(union_info.enum_tag_type);
 
diff --git a/src/Sema/bitcast.zig b/src/Sema/bitcast.zig
index ee70bd1746466aaf57c8812083f37892e69dac59..b496db1ce0e167aad6cacf51568ecc9bb91cde97 100644
--- a/src/Sema/bitcast.zig
+++ b/src/Sema/bitcast.zig
@@ -80,7 +80,7 @@ fn bitCastInner(
     const val_ty = val.typeOf(zcu);
 
     val_ty.assertHasLayout(zcu);
-    try sema.ensureLayoutResolved(dest_ty);
+    dest_ty.assertHasLayout(zcu);
 
     assert(val_ty.hasWellDefinedLayout(zcu));
 
@@ -138,8 +138,8 @@ fn bitCastSpliceInner(
     const val_ty = val.typeOf(zcu);
     const splice_val_ty = splice_val.typeOf(zcu);
 
-    try sema.ensureLayoutResolved(val_ty);
-    try sema.ensureLayoutResolved(splice_val_ty);
+    val_ty.assertHasLayout(zcu);
+    splice_val_ty.assertHasLayout(zcu);
 
     const splice_bits = splice_val_ty.bitSize(zcu);
 
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index f18cf9aaaeae1557d1a69799516d0f7687096dd0..970cf4f0116328dc6f84fe4c1e755eb71a4a915a 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -19,7 +19,7 @@ const arith = @import("arith.zig");
 /// Adds incremental dependencies tracking any required type resolution.
 /// MLUGG TODO: to make the langspec non-stupid, we need to call this from WAY fewer places (the conditions need to be less specific).
 /// MLUGG TODO: to be clear, i should audit EVERY use of this before PRing
-pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
+pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -35,20 +35,21 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
 
         .func_type => |func_type| {
             for (func_type.param_types.get(ip)) |param_ty| {
-                try ensureLayoutResolved(sema, .fromInterned(param_ty));
+                try ensureLayoutResolved(sema, .fromInterned(param_ty), src);
             }
-            try ensureLayoutResolved(sema, .fromInterned(func_type.return_type));
+            try ensureLayoutResolved(sema, .fromInterned(func_type.return_type), src);
         },
 
-        .array_type => |arr| return ensureLayoutResolved(sema, .fromInterned(arr.child)),
-        .vector_type => |vec| return ensureLayoutResolved(sema, .fromInterned(vec.child)),
-        .opt_type => |child| return ensureLayoutResolved(sema, .fromInterned(child)),
-        .error_union_type => |eu| return ensureLayoutResolved(sema, .fromInterned(eu.payload_type)),
+        .array_type => |arr| return ensureLayoutResolved(sema, .fromInterned(arr.child), src),
+        .vector_type => |vec| return ensureLayoutResolved(sema, .fromInterned(vec.child), src),
+        .opt_type => |child| return ensureLayoutResolved(sema, .fromInterned(child), src),
+        .error_union_type => |eu| return ensureLayoutResolved(sema, .fromInterned(eu.payload_type), src),
         .tuple_type => |tuple| for (tuple.types.get(ip)) |field_ty| {
-            try ensureLayoutResolved(sema, .fromInterned(field_ty));
+            try ensureLayoutResolved(sema, .fromInterned(field_ty), src);
         },
         .struct_type, .union_type, .enum_type => {
             try sema.declareDependency(.{ .type_layout = ty.toIntern() });
+            try sema.addReferenceEntry(null, src, .wrap(.{ .type_layout = ty.toIntern() }));
             if (zcu.analysis_in_progress.contains(.wrap(.{ .type_layout = ty.toIntern() }))) {
                 // TODO: better error message
                 return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
@@ -89,13 +90,14 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type) SemaError!void {
 ///
 /// It is not necessary to call this function to query the values of comptime fields: those values
 /// are available from type *layout* resolution, see `ensureLayoutResolved`.
-pub fn ensureStructDefaultsResolved(sema: *Sema, ty: Type) SemaError!void {
+pub fn ensureStructDefaultsResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     assert(ip.indexToKey(ty.toIntern()) == .struct_type);
 
     try sema.declareDependency(.{ .struct_defaults = ty.toIntern() });
+    try sema.addReferenceEntry(null, src, .wrap(.{ .struct_defaults = ty.toIntern() }));
     if (zcu.analysis_in_progress.contains(.wrap(.{ .struct_defaults = ty.toIntern() }))) {
         // TODO: better error message
         return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
@@ -120,7 +122,8 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
     assert(sema.owner.unwrap().type_layout == struct_ty.toIntern());
 
     const struct_obj = ip.loadStructType(struct_ty.toIntern());
-    const zir_index = struct_obj.zir_index.resolve(ip).?;
+    assert(struct_obj.want_layout);
+    const zir_index = struct_obj.zir_index.resolve(ip) orelse return error.AnalysisFail;
 
     var block: Block = .{
         .parent = null,
@@ -219,7 +222,7 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src);
 
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
@@ -368,7 +371,7 @@ fn resolvePackedStructLayout(
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src);
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
@@ -458,17 +461,20 @@ pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
 
     assert(sema.owner.unwrap().struct_defaults == struct_ty.toIntern());
 
-    try sema.ensureLayoutResolved(struct_ty);
+    try sema.ensureLayoutResolved(struct_ty, struct_ty.srcLoc(zcu));
 
     const struct_obj = ip.loadStructType(struct_ty.toIntern());
+    assert(struct_obj.want_defaults);
+
+    if (struct_obj.is_reified) {
+        // `Sema.zirReifyStruct` has already populated the default field values *and* (by loading
+        // the default values from pointers) validated their types, so we have nothing to do. We
+        // don't even need to mark any dependencies.
+        return;
+    }
 
     try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
 
-    // This logic isn't used for reified structs, because the signature of `@Struct` requires that
-    // default values are populated and correctly typed from the moment the struct type is interned
-    // (because `Sema.zirReifyStruct` had to dereference the default value from a pointer).
-    assert(!struct_obj.is_reified);
-
     if (struct_obj.field_defaults.len == 0) {
         // The struct has no default field values, so the slice has been omitted.
         return;
@@ -509,7 +515,7 @@ fn resolveStructDefaultsInner(
     const ip = &zcu.intern_pool;
 
     // We'll need to map the struct decl instruction to provide result types
-    const zir_index = struct_obj.zir_index.resolve(ip).?;
+    const zir_index = struct_obj.zir_index.resolve(ip) orelse return error.AnalysisFail;
     try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
 
     const field_types = struct_obj.field_types.get(ip);
@@ -555,7 +561,8 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     assert(sema.owner.unwrap().type_layout == union_ty.toIntern());
 
     const union_obj = ip.loadUnionType(union_ty.toIntern());
-    const zir_index = union_obj.zir_index.resolve(ip).?;
+    assert(union_obj.want_layout);
+    const zir_index = union_obj.zir_index.resolve(ip) orelse return error.AnalysisFail;
 
     var block: Block = .{
         .parent = null,
@@ -627,16 +634,11 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
                 .generation = zcu.generation,
             });
             if (comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-            try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-            try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-            errdefer comptime unreachable; // because we don't remove the `outdated` entry
-            zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-            zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
             break :tag_ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
 
-    try sema.ensureLayoutResolved(enum_tag_ty);
+    try sema.ensureLayoutResolved(enum_tag_ty, block.src(.container_arg));
     const enum_obj = ip.loadEnumType(enum_tag_ty.toIntern());
 
     if (union_obj.is_reified) {
@@ -731,7 +733,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src);
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
@@ -889,7 +891,7 @@ fn resolvePackedUnionLayout(
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src);
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
@@ -995,6 +997,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
     assert(sema.owner.unwrap().type_layout == enum_ty.toIntern());
 
     const enum_obj = ip.loadEnumType(enum_ty.toIntern());
+    assert(enum_obj.want_layout);
 
     const maybe_parent_union_obj: ?InternPool.LoadedUnionType = un: {
         if (enum_obj.owner_union == .none) break :un null;
@@ -1002,6 +1005,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
     };
 
     const tracked_inst = enum_obj.zir_index.unwrap() orelse maybe_parent_union_obj.?.zir_index;
+    const zir_index = tracked_inst.resolve(ip) orelse return error.AnalysisFail;
 
     var block: Block = .{
         .parent = null,
@@ -1040,7 +1044,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
             // Generated tag enums for declared unions do not yet have field names populated. It is
             // our job to populate them now.
             try sema.declareDependency(.{ .src_hash = union_obj.zir_index });
-            const zir_union = sema.code.getUnionDecl(union_obj.zir_index.resolve(ip).?);
+            const zir_union = sema.code.getUnionDecl(zir_index);
             for (zir_union.field_names) |zir_field_name| {
                 const name_slice = sema.code.nullTerminatedString(zir_field_name);
                 const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
@@ -1065,7 +1069,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
         } else {
             // Declared enums do not yet have field names populated. It is our job to populate them now.
             try sema.declareDependency(.{ .src_hash = enum_obj.zir_index.unwrap().? });
-            const zir_enum = sema.code.getEnumDecl(enum_obj.zir_index.unwrap().?.resolve(ip).?);
+            const zir_enum = sema.code.getEnumDecl(zir_index);
             for (zir_enum.field_names) |zir_field_name| {
                 const name_slice = sema.code.nullTerminatedString(zir_field_name);
                 const name = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
@@ -1087,7 +1091,6 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
             // Reification has no equivalent of 'union(enum(T))'.
             break :ty null;
         }
-        const zir_index = union_obj.zir_index.resolve(ip).?;
         const zir_union = sema.code.getUnionDecl(zir_index);
         if (zir_union.kind != .tagged_enum_explicit) {
             break :ty null; // int tag type will be inferred
@@ -1102,7 +1105,6 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
         const type_ref = try sema.resolveInlineBody(&block, tag_type_body, zir_index);
         break :ty try sema.analyzeAsType(&block, tag_type_src, .enum_int_tag_type, type_ref);
     } else ty: {
-        const zir_index = enum_obj.zir_index.unwrap().?.resolve(ip).?;
         const zir_enum = sema.code.getEnumDecl(zir_index);
         const tag_type_body = zir_enum.tag_type_body orelse {
             break :ty null; // int tag type will be inferred
@@ -1147,8 +1149,6 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
     // There may be old field values in here from a previous update.
     field_value_map.get(ip).clearRetainingCapacity();
 
-    const zir_index = tracked_inst.resolve(ip).?;
-
     // Map the enum (or union) decl instruction to provide the tag type as the result type
     try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
     sema.inst_map.putAssumeCapacity(zir_index, .fromIntern(int_tag_ty.toIntern()));
diff --git a/src/Type.zig b/src/Type.zig
index ca94c09bf04fc00503dc414541a0861194cf4256..5b5839cf6f40e5953e182162289aa2e7b05ba96d 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -3044,7 +3044,20 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         .tuple_type => |tuple| for (tuple.types.get(&zcu.intern_pool)) |field_ty| {
             assertHasLayout(.fromInterned(field_ty), zcu);
         },
-        .struct_type, .union_type, .enum_type => {
+        .struct_type => {
+            assert(zcu.intern_pool.loadStructType(ty.toIntern()).want_layout);
+            const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
+            assert(!zcu.outdated.contains(unit));
+            assert(!zcu.potentially_outdated.contains(unit));
+        },
+        .union_type => {
+            assert(zcu.intern_pool.loadUnionType(ty.toIntern()).want_layout);
+            const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
+            assert(!zcu.outdated.contains(unit));
+            assert(!zcu.potentially_outdated.contains(unit));
+        },
+        .enum_type => {
+            assert(zcu.intern_pool.loadEnumType(ty.toIntern()).want_layout);
             const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
             assert(!zcu.outdated.contains(unit));
             assert(!zcu.potentially_outdated.contains(unit));
diff --git a/src/Value.zig b/src/Value.zig
index de7aacd1e1f2c84737acb243aa1565ac5fc0a94b..d513e5d07d9d07311a7d15b106e57795b54e92be 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -2149,7 +2149,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const base_ptr = Value.fromInterned(field.base);
             const base_ptr_ty = base_ptr.typeOf(zcu);
             const agg_ty = base_ptr_ty.childType(zcu);
-            if (resolve_types) try opt_sema.?.ensureLayoutResolved(agg_ty);
+            if (resolve_types) try opt_sema.?.ensureLayoutResolved(agg_ty, .unneeded); // MLUGG TODO: unneeded is a hack
             const field_ty: Type, const field_align: InternPool.Alignment = switch (agg_ty.zigTypeTag(zcu)) {
                 .@"struct", .@"union" => .{ agg_ty.fieldType(@intCast(field.index), zcu), agg_ty.resolvedFieldAlignment(@intCast(field.index), pt.zcu) },
                 .pointer => switch (field.index) {
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 3b17bc1c0981d1e19f57db43412f4b309484faf4..aedbf7043c32aa83d8e7988d8bd3bb2304476632 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -266,9 +266,6 @@ outdated_ready: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
 /// it as outdated.
 retryable_failures: std.ArrayList(AnalUnit) = .empty,
 
-func_body_analysis_queued: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty,
-nav_val_analysis_queued: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty,
-
 /// These are the modules which we initially queue for analysis in `Compilation.update`.
 /// `resolveReferences` will use these as the root of its reachability traversal.
 analysis_roots_buffer: [5]*Package.Module,
@@ -2814,9 +2811,6 @@ pub fn deinit(zcu: *Zcu) void {
         zcu.outdated_ready.deinit(gpa);
         zcu.retryable_failures.deinit(gpa);
 
-        zcu.func_body_analysis_queued.deinit(gpa);
-        zcu.nav_val_analysis_queued.deinit(gpa);
-
         zcu.test_functions.deinit(gpa);
 
         for (zcu.global_assembly.values()) |s| {
@@ -3179,8 +3173,6 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
 /// recursive analysis (all of its previously-marked dependencies are already up-to-date), because
 /// recursive analysis can cause over-analysis on incremental updates.
 pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
-    if (!zcu.comp.config.incremental) return null;
-
     if (zcu.outdated_ready.count() > 0) {
         const unit = zcu.outdated_ready.keys()[0];
         log.debug("findOutdatedToAnalyze: {f}", .{zcu.fmtAnalUnit(unit)});
@@ -3458,47 +3450,35 @@ pub fn mapOldZirToNew(
 /// The caller is responsible for ensuring the function decl itself is already
 /// analyzed, and for ensuring it can exist at runtime (see
 /// `Type.fnHasRuntimeBitsSema`). This function does *not* guarantee that the body
-/// will be analyzed when it returns: for that, see `ensureFuncBodyAnalyzed`.
-pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func_index: InternPool.Index) !void {
+/// will be analyzed when it returns: for that, see `PerThread.ensureFuncBodyUpToDate`.
+pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func: InternPool.Index) !void {
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
     const ip = &zcu.intern_pool;
-
-    const func = zcu.funcInfo(func_index);
-
-    assert(func.ty == func.uncoerced_ty); // analyze the body of the original function, not a coerced one
-
-    if (zcu.func_body_analysis_queued.contains(func_index)) return;
-
-    if (func.analysisUnordered(ip).is_analyzed) {
-        if (!zcu.outdated.contains(.wrap(.{ .func = func_index })) and
-            !zcu.potentially_outdated.contains(.wrap(.{ .func = func_index })))
-        {
-            // This function has been analyzed before and is definitely up-to-date.
-            return;
-        }
+    assert(func == ip.unwrapCoercedFunc(func)); // analyze the body of the original function, not a coerced one
+    if (ip.setWantRuntimeFnAnalysis(io, func)) {
+        // This is the first reference to this function, so we must ensure it will be analyzed.
+        const unit: AnalUnit = .wrap(.{ .func = func });
+        try zcu.outdated.putNoClobber(gpa, unit, 0);
+        try zcu.outdated_ready.putNoClobber(gpa, unit, {});
     }
-
-    try zcu.func_body_analysis_queued.ensureUnusedCapacity(zcu.gpa, 1);
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .func = func_index }) });
-    zcu.func_body_analysis_queued.putAssumeCapacityNoClobber(func_index, {});
 }
 
-pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav_id: InternPool.Nav.Index) !void {
+pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav: InternPool.Nav.Index) !void {
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
     const ip = &zcu.intern_pool;
-
-    if (zcu.nav_val_analysis_queued.contains(nav_id)) return;
-
-    if (ip.getNav(nav_id).status == .fully_resolved) {
-        if (!zcu.outdated.contains(.wrap(.{ .nav_val = nav_id })) and
-            !zcu.potentially_outdated.contains(.wrap(.{ .nav_val = nav_id })))
-        {
-            // This `Nav` has been analyzed before and is definitely up-to-date.
-            return;
-        }
+    if (ip.setWantNavAnalysis(io, nav)) {
+        // This is the first reference to this function, so we must ensure it will be analyzed.
+        try zcu.outdated.ensureUnusedCapacity(gpa, 2);
+        try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
+        zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .nav_val = nav }), 0);
+        zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .nav_ty = nav }), 0);
+        zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .nav_val = nav }), {});
+        zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .nav_ty = nav }), {});
     }
-
-    try zcu.nav_val_analysis_queued.ensureUnusedCapacity(zcu.gpa, 1);
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .nav_val = nav_id }) });
-    zcu.nav_val_analysis_queued.putAssumeCapacityNoClobber(nav_id, {});
 }
 
 pub const ImportResult = struct {
@@ -4035,37 +4015,6 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
 
             refs_log.debug("handle type '{f}'", .{Type.fromInterned(ty).containerTypeName(ip).fmt(ip)});
 
-            // If this type undergoes type resolution, the corresponding `AnalUnit`s are automatically referenced.
-            const has_layout: bool, const has_inits: bool = switch (ip.indexToKey(ty)) {
-                .struct_type => .{ true, true },
-                .union_type => .{ true, false },
-                .enum_type => .{ false, true },
-                .opaque_type => .{ false, false },
-                else => unreachable,
-            };
-            if (has_layout) {
-                // this should only be referenced by the type
-                const unit: AnalUnit = .wrap(.{ .type_layout = ty });
-                try units.putNoClobber(gpa, unit, referencer);
-            }
-            if (has_inits) {
-                // this should only be referenced by the type
-                const unit: AnalUnit = .wrap(.{ .struct_defaults = ty });
-                try units.putNoClobber(gpa, unit, referencer);
-            }
-
-            // If this is a union with a generated tag, its tag type is automatically referenced.
-            // We don't add this reference for non-generated tags, as those will already be referenced via the union's type resolution, with a better source location.
-            implicit_tag: {
-                const loaded_union = zcu.typeToUnion(.fromInterned(ty)) orelse break :implicit_tag;
-                const tag_ty = loaded_union.enum_tag_type;
-                if (tag_ty == .none) break :implicit_tag;
-                if (ip.indexToKey(tag_ty).enum_type != .generated_union_tag) break :implicit_tag;
-                const gop = try types.getOrPut(gpa, tag_ty);
-                if (gop.found_existing) break :implicit_tag;
-                gop.value_ptr.* = referencer;
-            }
-
             // Queue any decls within this type which would be automatically analyzed.
             // Keep in sync with analysis queueing logic in `Zcu.PerThread.ScanDeclIter.scanDecl`.
             const ns = Type.fromInterned(ty).getNamespace(zcu).unwrap().?;
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index d937367c4ac871c61e7bd285e9ddf04f7df175c7..00c911caf4e67e3a7dcf5691ebe7cf45d53ff002 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -719,20 +719,9 @@ pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Alloca
     });
     errdefer pt.destroyNamespace(new_namespace_index);
     try pt.scanNamespace(new_namespace_index, struct_decl.decls);
-    // MLUGG TODO: we could potentially revert this language change if we wanted? don't mind
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .type_layout = wip.index }) });
-    try zcu.comp.queueJob(.{ .analyze_unit = .wrap(.{ .struct_defaults = wip.index }) });
 
     if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
 
-    try zcu.outdated.ensureUnusedCapacity(gpa, 2);
-    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
-    errdefer comptime unreachable; // because we don't remove the `outdated` entries
-    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), 0);
-    zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), 0);
-    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .type_layout = wip.index }), {});
-    zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = wip.index }), {});
-
     const file_root_type: Type = .fromInterned(wip.finish(ip, new_namespace_index));
 
     zcu.setFileRootType(file_index, file_root_type.toIntern());
@@ -1075,11 +1064,12 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
     const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
+        zcu.potentially_outdated.swapRemove(anal_unit) or
+        zcu.intern_pool.setWantTypeLayout(zcu.comp.io, ty.toIntern());
 
     if (was_outdated) {
         _ = zcu.outdated_ready.swapRemove(anal_unit);
-        // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
+        // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
             zcu.deleteUnitExports(anal_unit);
             zcu.deleteUnitReferences(anal_unit);
@@ -1182,16 +1172,13 @@ pub fn ensureStructDefaultsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!v
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
-    // Determine whether or not this type is outdated. For this kind of `AnalUnit`, that's
-    // the only indicator as to whether or not analysis is required; when a struct/enum is
-    // first created, it's marked as outdated.
-
     const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
+        zcu.potentially_outdated.swapRemove(anal_unit) or
+        zcu.intern_pool.setWantStructDefaults(zcu.comp.io, ty.toIntern());
 
     if (was_outdated) {
         _ = zcu.outdated_ready.swapRemove(anal_unit);
-        // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
+        // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
             zcu.deleteUnitExports(anal_unit);
             zcu.deleteUnitReferences(anal_unit);
@@ -1279,8 +1266,6 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
 
-    _ = zcu.nav_val_analysis_queued.swapRemove(nav_id);
-
     const anal_unit: AnalUnit = .wrap(.{ .nav_val = nav_id });
     const nav = ip.getNav(nav_id);
 
@@ -1288,6 +1273,8 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
+    try zcu.ensureNavValAnalysisQueued(nav_id);
+
     // Determine whether or not this `Nav`'s value is outdated. This also includes checking if the
     // status is `.unresolved`, which indicates that the value is outdated because it has *never*
     // been analyzed so far.
@@ -1317,10 +1304,8 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
     } else {
         // We can trust the current information about this unit.
         if (prev_failed) return error.AnalysisFail;
-        switch (nav.status) {
-            .unresolved, .type_resolved => {},
-            .fully_resolved => return,
-        }
+        assert(nav.status == .fully_resolved);
+        return;
     }
 
     if (zcu.comp.debugIncremental()) {
@@ -1488,9 +1473,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
 
     const maybe_ty: ?Type = if (zir_decl.type_body != null) ty: {
         // Since we have a type body, the type is resolved separately!
-        // Of course, we need to make sure we depend on it properly.
-        try sema.declareDependency(.{ .nav_ty = nav_id });
-        try pt.ensureNavTypeUpToDate(nav_id);
+        try sema.ensureNavResolved(&block, init_src, nav_id, .type);
         break :ty .fromInterned(ip.getNav(nav_id).typeOf(ip));
     } else null;
 
@@ -1602,7 +1585,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
 
     // This resolves the type of the resolved value, not that value itself. If `nav_val` is a struct type,
     // this resolves the type `type` (which needs no resolution), not the struct itself.
-    try sema.ensureLayoutResolved(nav_ty);
+    try sema.ensureLayoutResolved(nav_ty, init_src);
 
     const queue_linker_work, const is_owned_fn = switch (ip.indexToKey(nav_val.toIntern())) {
         .func => |f| .{ true, f.owner_nav == nav_id }, // note that this lets function aliases reach codegen
@@ -1692,6 +1675,8 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
+    try zcu.ensureNavValAnalysisQueued(nav_id);
+
     const type_resolved_by_value: bool = from_val: {
         const analysis = nav.analysis orelse break :from_val false;
         const inst_resolved = analysis.zir_index.resolveFull(ip) orelse break :from_val false;
@@ -1733,10 +1718,8 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc
     } else {
         // We can trust the current information about this unit.
         if (prev_failed) return error.AnalysisFail;
-        switch (nav.status) {
-            .unresolved => {},
-            .type_resolved, .fully_resolved => return,
-        }
+        assert(nav.status != .unresolved);
+        return;
     }
 
     if (zcu.comp.debugIncremental()) {
@@ -1869,7 +1852,7 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
         break :ty .fromInterned(type_ref.toInterned().?);
     };
 
-    try sema.ensureLayoutResolved(resolved_ty);
+    try sema.ensureLayoutResolved(resolved_ty, ty_src);
 
     // In the case where the type is specified, this function is also responsible for resolving
     // the pointer modifiers, i.e. alignment, linksection, addrspace.
@@ -1929,8 +1912,6 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
 
-    _ = zcu.func_body_analysis_queued.swapRemove(func_index);
-
     const anal_unit: AnalUnit = .wrap(.{ .func = func_index });
 
     log.debug("ensureFuncBodyUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
@@ -1942,7 +1923,8 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
     assert(func.ty == func.uncoerced_ty); // analyze the body of the original function, not a coerced one
 
     const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
+        zcu.potentially_outdated.swapRemove(anal_unit) or
+        ip.setWantRuntimeFnAnalysis(zcu.comp.io, func_index);
 
     const prev_failed = zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit);
 
@@ -1958,10 +1940,8 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
         _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
     } else {
         // We can trust the current information about this function.
-        if (prev_failed) {
-            return error.AnalysisFail;
-        }
-        if (func.analysisUnordered(ip).is_analyzed) return;
+        if (prev_failed) return error.AnalysisFail;
+        return;
     }
 
     if (zcu.comp.debugIncremental()) {
@@ -3026,7 +3006,6 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
     try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {});
     defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
-    func.setAnalyzed(ip, io);
     if (func.analysisUnordered(ip).inferred_error_set) {
         func.setResolvedErrorSet(ip, io, .none);
     }
@@ -3144,7 +3123,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
         const param_ty: Type = .fromInterned(fn_ty_info.param_types.get(ip)[runtime_param_index]);
         runtime_param_index += 1;
 
-        try sema.ensureLayoutResolved(param_ty);
+        try sema.ensureLayoutResolved(param_ty, inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) }));
         if (try param_ty.onePossibleValue(pt)) |opv| {
             gop.value_ptr.* = .fromValue(opv);
             continue;
@@ -3161,7 +3140,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
         });
     }
 
-    try sema.ensureLayoutResolved(sema.fn_ret_ty);
+    try sema.ensureLayoutResolved(sema.fn_ret_ty, inner_block.src(.{ .node_offset_fn_type_ret_ty = .zero }));
 
     const last_arg_index = inner_block.instructions.items.len;
 
-- 
2.54.0


From b19074d252e7eb833b653263acd20e64a7fe26ff Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 28 Jan 2026 13:10:07 +0000
Subject: [PATCH 422/499] compiler: represent bitpacks as their backing integer

Now that https://github.com/ziglang/zig/issues/24657 has been
implemented, the compiler can simplify its internal representation of
comptime-known `packed struct` and `packed union` values. Instead of
storing them field-wise, we can simply store their backing integer
value. This simplifies many operations and improves efficiency in some
cases.
---
 src/Air/print.zig               |  44 +++-----
 src/InternPool.zig              |  75 +++++++++++---
 src/Sema.zig                    |  50 +++++++--
 src/Sema/bitcast.zig            | 169 +++++++++++++++---------------
 src/Sema/type_resolution.zig    |   1 +
 src/Type.zig                    |  41 ++++++--
 src/Value.zig                   | 160 ++++++++++++++--------------
 src/Zcu/PerThread.zig           |   9 ++
 src/codegen.zig                 |  42 ++------
 src/codegen/aarch64/Select.zig  |  46 ++++-----
 src/codegen/c.zig               | 178 ++++++++++++--------------------
 src/codegen/llvm.zig            |  39 +++----
 src/codegen/riscv64/CodeGen.zig |  45 ++++----
 src/codegen/spirv/CodeGen.zig   |   2 +-
 src/codegen/wasm/CodeGen.zig    |   4 +-
 src/codegen/x86_64/CodeGen.zig  |  65 ++++++------
 src/link/Dwarf.zig              |  11 ++
 src/mutable_value.zig           |  26 +++--
 src/print_value.zig             |  28 ++++-
 19 files changed, 532 insertions(+), 503 deletions(-)

diff --git a/src/Air/print.zig b/src/Air/print.zig
index 0c126fab22d364b97c49ed6d896801fe4c66451e..f6c0f5a03b8f1c957b0129978358888977690de7 100644
--- a/src/Air/print.zig
+++ b/src/Air/print.zig
@@ -692,33 +692,23 @@ const Writer = struct {
 
         const zcu = w.pt.zcu;
         const ip = &zcu.intern_pool;
-        const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
-        const struct_type: Type = .fromInterned(aggregate.ty);
-        switch (aggregate.storage) {
-            .elems => |elems| for (elems, 0..) |elem, i| {
-                switch (elem) {
-                    .bool_true => {
-                        const clobber = struct_type.structFieldName(i, zcu).toSlice(ip).?;
-                        assert(clobber.len != 0);
-                        try s.writeAll(", ~{");
-                        try s.writeAll(clobber);
-                        try s.writeAll("}");
-                    },
-                    .bool_false => continue,
-                    else => unreachable,
-                }
-            },
-            .repeated_elem => |elem| {
-                try s.writeAll(", ");
-                try s.writeAll(switch (elem) {
-                    .bool_true => "<all clobbers>",
-                    .bool_false => "<no clobbers>",
-                    else => unreachable,
-                });
-            },
-            .bytes => |bytes| {
-                try s.print(", {x}", .{bytes});
-            },
+        const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+        const clobbers_ty = clobbers_val.typeOf(zcu);
+        var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+        const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
+        for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
+            assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
+            const limb_bits = @bitSizeOf(std.math.big.Limb);
+            if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+            switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
+                0 => continue, // field is false
+                1 => {}, // field is true
+            }
+            const clobber = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
+            assert(clobber.len != 0);
+            try s.writeAll(", ~{");
+            try s.writeAll(clobber);
+            try s.writeAll("}");
         }
         const asm_source = unwrapped_asm.source;
         try s.print(", \"{f}\"", .{std.zig.fmtString(asm_source)});
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 230ef78d63dd4190c712a6b955b5ea594d89ddb6..7028d690094d195183e3e33b991ddc2ce17572b1 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -2130,6 +2130,8 @@ pub const Key = union(enum) {
     aggregate: Aggregate,
     /// An instance of a union.
     un: Union,
+    /// An instance of a `packed struct` or `packed union`.
+    bitpack: Bitpack,
 
     /// A comptime function call with a memoized result.
     memoized_call: Key.MemoizedCall,
@@ -2681,6 +2683,15 @@ pub const Key = union(enum) {
         };
     };
 
+    /// As well as a key, this type doubles as the payload in `extra` for `Tag.bitpack`.
+    pub const Bitpack = struct {
+        /// The `packed struct` or `packed union` type.
+        ty: Index,
+        /// The contents of the bitpack, represented as the backing integer value. The type of this
+        /// value is the same as the backing integer type of `ty`.
+        backing_int_val: Index,
+    };
+
     pub const MemoizedCall = struct {
         func: Index,
         arg_values: []const Index,
@@ -2919,6 +2930,8 @@ pub const Key = union(enum) {
                 asBytes(&e.relocation) ++
                 asBytes(&e.is_const) ++ asBytes(&e.alignment) ++ asBytes(&e.@"addrspace") ++
                 asBytes(&e.zir_index) ++ &[1]u8{@intFromEnum(e.source)}),
+
+            .bitpack => |bitpack| Hash.hash(seed, asBytes(&bitpack.ty) ++ asBytes(&bitpack.backing_int_val)),
         };
     }
 
@@ -2996,6 +3009,10 @@ pub const Key = union(enum) {
                 const b_info = b.empty_enum_value;
                 return a_info == b_info;
             },
+            .bitpack => |a_info| {
+                const b_info = b.bitpack;
+                return a_info.ty == b_info.ty and a_info.backing_int_val == b_info.backing_int_val;
+            },
 
             .variable => |a_info| {
                 const b_info = b.variable;
@@ -3271,6 +3288,7 @@ pub const Key = union(enum) {
             .enum_tag,
             .aggregate,
             .un,
+            .bitpack,
             => |x| x.ty,
 
             .enum_literal => .enum_literal_type,
@@ -4417,6 +4435,7 @@ pub const Index = enum(u32) {
             trailing: struct { element_values: []Index },
         },
         repeated: struct { data: *Repeated },
+        bitpack: struct { data: *Key.Bitpack },
 
         memoized_call: struct {
             const @"data.args_len" = opaque {};
@@ -5152,6 +5171,9 @@ pub const Tag = enum(u8) {
     /// An instance of an array or vector with every element being the same value.
     /// data is extra index to `Repeated`.
     repeated,
+    /// An instance of a `packed struct` or `packed union`.
+    /// data is extra index to `Key.Bitpack`.
+    bitpack,
 
     /// A memoized comptime function call result.
     /// data is extra index to `MemoizedCall`
@@ -5485,6 +5507,7 @@ pub const Tag = enum(u8) {
             .config = .{ .@"trailing.elements.len" = .@"payload.ty.payload.fields_len" },
         },
         .repeated = .{ .summary = .@"@as({.payload.ty%summary}, @splat({.payload.elem_val%summary}))", .payload = Repeated },
+        .bitpack = .{ .summary = .@"@as({.payload.ty%summary}, {})", .payload = Key.Bitpack },
 
         .memoized_call = .{
             .summary = .@"@memoize({.payload.func%summary})",
@@ -7043,6 +7066,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         },
         .enum_literal => .{ .enum_literal = @enumFromInt(data) },
         .enum_tag => .{ .enum_tag = extraData(unwrapped_index.getExtra(ip), Tag.EnumTag, data) },
+        .bitpack => .{ .bitpack = extraData(unwrapped_index.getExtra(ip), Key.Bitpack, data) },
 
         .memoized_call => {
             const extra_list = unwrapped_index.getExtra(ip);
@@ -7938,15 +7962,14 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
         .aggregate => |aggregate| {
             const ty_key = ip.indexToKey(aggregate.ty);
             const len = ip.aggregateTypeLen(aggregate.ty);
-            const child = switch (ty_key) {
-                .array_type => |array_type| array_type.child,
-                .vector_type => |vector_type| vector_type.child,
-                .tuple_type, .struct_type => .none,
-                else => unreachable,
-            };
-            const sentinel = switch (ty_key) {
-                .array_type => |array_type| array_type.sentinel,
-                .vector_type, .tuple_type, .struct_type => .none,
+            const child: Index, const sentinel: Index = switch (ty_key) {
+                .array_type => |array_type| .{ array_type.child, array_type.sentinel },
+                .vector_type => |vector_type| .{ vector_type.child, .none },
+                .tuple_type => .{ .none, .none },
+                .struct_type => child: {
+                    assert(ip.loadStructType(aggregate.ty).layout != .@"packed");
+                    break :child .{ .none, .none };
+                },
                 else => unreachable,
             };
             const len_including_sentinel = len + @intFromBool(sentinel != .none);
@@ -8128,6 +8151,18 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
             extra.appendSliceAssumeCapacity(.{@ptrCast(aggregate.storage.elems)});
             if (sentinel != .none) extra.appendAssumeCapacity(.{@intFromEnum(sentinel)});
         },
+        .bitpack => |bitpack| {
+            switch (ip.zigTypeTag(bitpack.ty)) {
+                .@"struct" => assert(ip.typeOf(bitpack.backing_int_val) == ip.loadStructType(bitpack.ty).packed_backing_int_type),
+                .@"union" => assert(ip.typeOf(bitpack.backing_int_val) == ip.loadUnionType(bitpack.ty).packed_backing_int_type),
+                else => unreachable,
+            }
+            assert(!ip.isUndef(bitpack.backing_int_val));
+            items.appendAssumeCapacity(.{
+                .tag = .bitpack,
+                .data = try addExtra(extra, bitpack),
+            });
+        },
 
         .memoized_call => |memoized_call| {
             for (memoized_call.arg_values) |arg| assert(arg != .none);
@@ -9095,16 +9130,18 @@ pub fn getUnion(
     tid: Zcu.PerThread.Id,
     un: Key.Union,
 ) Allocator.Error!Index {
-    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .un = un });
-    defer gop.deinit();
-    if (gop == .existing) return gop.existing;
-    const local = ip.getLocal(tid);
-    const items = local.getMutableItems(gpa, io);
-    const extra = local.getMutableExtra(gpa, io);
-    try items.ensureUnusedCapacity(1);
-
     assert(un.ty != .none);
     assert(un.val != .none);
+    assert(ip.loadUnionType(un.ty).layout != .@"packed");
+
+    var gop = try ip.getOrPutKey(gpa, io, tid, .{ .un = un });
+    defer gop.deinit();
+    if (gop == .existing) return gop.existing;
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa, io);
+    const extra = local.getMutableExtra(gpa, io);
+    try items.ensureUnusedCapacity(1);
+
     items.appendAssumeCapacity(.{
         .tag = .union_value,
         .data = try addExtra(extra, un),
@@ -11003,6 +11040,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo
                 .func_coerced => @sizeOf(Tag.FuncCoerced),
                 .only_possible_value => 0,
                 .union_value => @sizeOf(Key.Union),
+                .bitpack => 2 * @sizeOf(u32),
 
                 .memoized_call => b: {
                     const info = extraData(extra_list, MemoizedCall, data);
@@ -11117,6 +11155,7 @@ fn dumpAllFallible(ip: *const InternPool, w: *Io.Writer) anyerror!void {
                 .func_instance,
                 .func_coerced,
                 .union_value,
+                .bitpack,
                 .memoized_call,
                 => try w.print("{d}", .{data}),
 
@@ -11871,6 +11910,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
                 .bytes,
                 .aggregate,
                 .repeated,
+                .bitpack,
                 => |t| {
                     const extra_list = unwrapped_index.getExtra(ip);
                     return @enumFromInt(extra_list.view().items(.@"0")[item.data + std.meta.fieldIndex(t.Payload(), "ty").?]);
@@ -12264,6 +12304,7 @@ pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId {
             .bytes,
             .aggregate,
             .repeated,
+            .bitpack,
             // memoization, not types
             .memoized_call,
             => unreachable,
diff --git a/src/Sema.zig b/src/Sema.zig
index a506a7e6bbc369bf6a9906d2cda4dd6b41450317..60f04974372927d734327b71cef6118d53bc0797 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3583,7 +3583,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
             },
             .field => |idx| ptr: {
                 const maybe_union_ty = Value.fromInterned(decl_parent_ptr).typeOf(zcu).childType(zcu);
-                if (zcu.typeToUnion(maybe_union_ty)) |union_obj| {
+                if (zcu.typeToUnion(maybe_union_ty)) |union_obj| if (union_obj.layout == .auto) {
                     // As this is a union field, we must store to the pointer now to set the tag.
                     // The payload value will be stored later, so undef is a sufficent payload for now.
                     const payload_ty: Type = .fromInterned(union_obj.field_types.get(&zcu.intern_pool)[idx]);
@@ -3591,7 +3591,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                     const tag_val = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), idx);
                     const store_val = try pt.unionValue(maybe_union_ty, tag_val, payload_val);
                     try sema.storePtrVal(block, .unneeded, .fromInterned(decl_parent_ptr), store_val, maybe_union_ty);
-                }
+                };
                 break :ptr (try Value.fromInterned(decl_parent_ptr).ptrField(idx, pt)).toIntern();
             },
             .elem => |idx| (try Value.fromInterned(decl_parent_ptr).ptrElem(idx, pt)).toIntern(),
@@ -18510,6 +18510,10 @@ fn zirUnionInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
 
     const payload = try sema.coerce(block, field_ty, sema.resolveInst(extra.init), payload_src);
 
+    if (union_ty.containerLayout(zcu) == .@"packed") {
+        return sema.bitCast(block, union_ty, payload, block.nodeOffset(inst_data.src_node), payload_src);
+    }
+
     if (sema.resolveValue(payload)) |payload_val| {
         const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
@@ -18643,6 +18647,10 @@ fn zirStructInit(
         const uncoerced_init_inst = sema.resolveInst(item.data.init);
         const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);
 
+        if (resolved_ty.containerLayout(zcu) == .@"packed") {
+            return sema.bitCast(block, resolved_ty, init_inst, src, field_src);
+        }
+
         if (sema.resolveValue(init_inst)) |val| {
             const struct_val = Value.fromInterned(try pt.internUnion(.{
                 .ty = resolved_ty.toIntern(),
@@ -18789,15 +18797,35 @@ fn finishStructInit(
         }
     } else null;
 
-    const runtime_index = opt_runtime_index orelse {
-        const elems = try sema.arena.alloc(InternPool.Index, field_inits.len);
-        for (elems, field_inits) |*elem, field_init| {
-            elem.* = sema.resolveValue(field_init).?.toIntern();
-        }
-        const struct_val = try pt.aggregateValue(struct_ty, elems);
-        const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), init_src);
-        const final_val = sema.resolveValue(final_val_inst).?;
-        return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
+    const runtime_index = opt_runtime_index orelse switch (struct_ty.containerLayout(zcu)) {
+        .auto, .@"extern" => {
+            const elems = try sema.arena.alloc(InternPool.Index, field_inits.len);
+            for (elems, field_inits) |*elem, field_init| {
+                elem.* = sema.resolveValue(field_init).?.toIntern();
+            }
+            const struct_val = try pt.aggregateValue(struct_ty, elems);
+            const final_val_ref = try sema.coerce(block, result_ty, .fromValue(struct_val), init_src);
+            return sema.addConstantMaybeRef(final_val_ref.toInterned().?, is_ref);
+        },
+        .@"packed" => {
+            const buf = try sema.arena.alloc(u8, (struct_ty.bitSize(zcu) + 7) / 8);
+            var bit_offset: u16 = 0;
+            for (field_inits) |field_init| {
+                const field_val = sema.resolveValue(field_init).?;
+                field_val.writeToPackedMemory(pt, buf, bit_offset) catch |err| switch (err) {
+                    error.ReinterpretDeclRef => unreachable, // bitpack fields cannot be pointers
+                    error.OutOfMemory => |e| return e,
+                };
+                bit_offset += @intCast(field_val.typeOf(zcu).bitSize(zcu));
+            }
+            assert(bit_offset == struct_ty.bitSize(zcu));
+            const struct_val = Value.readFromPackedMemory(struct_ty, pt, buf, 0, sema.arena) catch |err| switch (err) {
+                error.IllDefinedMemoryLayout => unreachable, // bitpacks have well-defined layout
+                error.OutOfMemory => |e| return e,
+            };
+            const final_val_ref = try sema.coerce(block, result_ty, .fromValue(struct_val), init_src);
+            return sema.addConstantMaybeRef(final_val_ref.toInterned().?, is_ref);
+        },
     };
 
     if (struct_ty.comptimeOnly(zcu)) {
diff --git a/src/Sema/bitcast.zig b/src/Sema/bitcast.zig
index b496db1ce0e167aad6cacf51568ecc9bb91cde97..f06528b6240f4766730353a6dc50d3b8e3c41607 100644
--- a/src/Sema/bitcast.zig
+++ b/src/Sema/bitcast.zig
@@ -273,6 +273,8 @@ const UnpackValueBits = struct {
             .opt,
             => try unpack.primitive(val),
 
+            .bitpack => |bitpack| try unpack.primitive(.fromInterned(bitpack.backing_int_val)),
+
             .aggregate => switch (ty.zigTypeTag(zcu)) {
                 .vector => {
                     const len: usize = @intCast(ty.arrayLen(zcu));
@@ -443,7 +445,7 @@ const UnpackValueBits = struct {
                 // This @intCast is okay because no primitive can exceed the size of a u16.
                 const int_ty = try unpack.pt.intType(.unsigned, @intCast(bit_count));
                 const buf = try unpack.arena.alloc(u8, @intCast((val_bits + 7) / 8));
-                try val.writeToPackedMemory(ty, unpack.pt, buf, 0);
+                try val.writeToPackedMemory(unpack.pt, buf, 0);
                 const sub_val = try Value.readFromPackedMemory(int_ty, unpack.pt, buf, @intCast(bit_offset), unpack.arena);
                 try unpack.primitive(sub_val);
             },
@@ -565,102 +567,103 @@ const PackValueBits = struct {
                     return pt.aggregateValue(ty, elems);
                 },
                 .@"packed" => {
-                    // All fields are in order with no padding.
-                    // This is identical between LE and BE targets.
-                    const elems = try arena.alloc(InternPool.Index, ty.structFieldCount(zcu));
-                    for (elems, 0..) |*elem, i| {
-                        const field_ty = ty.fieldType(i, zcu);
-                        elem.* = (try pack.get(field_ty)).toIntern();
-                    }
-                    return pt.aggregateValue(ty, elems);
+                    const backing_int_val = try pack.primitive(ty.bitpackBackingInt(zcu));
+                    return pt.bitpackValue(ty, backing_int_val);
                 },
             },
-            .@"union" => {
-                // We will attempt to read as the backing representation. If this emits
-                // `error.ReinterpretDeclRef`, we will try each union field, preferring larger ones.
-                // We will also attempt smaller fields when we get `undefined`, as if some bits are
-                // defined we want to include them.
-                // TODO: this is very very bad. We need a more sophisticated union representation.
+            .@"union" => switch (ty.containerLayout(zcu)) {
+                .auto => unreachable, // ill-defined layout
+                .@"extern" => {
+                    // We will attempt to read as the backing representation. If this emits
+                    // `error.ReinterpretDeclRef`, we will try each union field, preferring larger ones.
+                    // We will also attempt smaller fields when we get `undefined`, as if some bits are
+                    // defined we want to include them.
+                    // TODO: this is very very bad. We need a more sophisticated union representation.
 
-                const prev_unpacked = pack.unpacked;
-                const prev_bit_offset = pack.bit_offset;
+                    const prev_unpacked = pack.unpacked;
+                    const prev_bit_offset = pack.bit_offset;
 
-                const backing_ty = try ty.unionBackingType(pt);
+                    const backing_ty = try ty.externUnionBackingType(pt);
 
-                backing: {
-                    const backing_val = pack.get(backing_ty) catch |err| switch (err) {
-                        error.ReinterpretDeclRef => {
+                    backing: {
+                        const backing_val = pack.get(backing_ty) catch |err| switch (err) {
+                            error.ReinterpretDeclRef => {
+                                pack.unpacked = prev_unpacked;
+                                pack.bit_offset = prev_bit_offset;
+                                break :backing;
+                            },
+                            else => |e| return e,
+                        };
+                        if (backing_val.isUndef(zcu)) {
                             pack.unpacked = prev_unpacked;
                             pack.bit_offset = prev_bit_offset;
                             break :backing;
-                        },
-                        else => |e| return e,
+                        }
+                        return Value.fromInterned(try pt.internUnion(.{
+                            .ty = ty.toIntern(),
+                            .tag = .none,
+                            .val = backing_val.toIntern(),
+                        }));
+                    }
+
+                    const field_order = try pack.arena.alloc(u32, ty.unionTagTypeHypothetical(zcu).enumFieldCount(zcu));
+                    for (field_order, 0..) |*f, i| f.* = @intCast(i);
+                    // Sort `field_order` to put the fields with the largest bit sizes first.
+                    const SizeSortCtx = struct {
+                        zcu: *Zcu,
+                        field_types: []const InternPool.Index,
+                        fn lessThan(ctx: @This(), a_idx: u32, b_idx: u32) bool {
+                            const a_ty = Type.fromInterned(ctx.field_types[a_idx]);
+                            const b_ty = Type.fromInterned(ctx.field_types[b_idx]);
+                            return a_ty.bitSize(ctx.zcu) > b_ty.bitSize(ctx.zcu);
+                        }
                     };
-                    if (backing_val.isUndef(zcu)) {
-                        pack.unpacked = prev_unpacked;
-                        pack.bit_offset = prev_bit_offset;
-                        break :backing;
+                    std.mem.sortUnstable(u32, field_order, SizeSortCtx{
+                        .zcu = zcu,
+                        .field_types = zcu.typeToUnion(ty).?.field_types.get(ip),
+                    }, SizeSortCtx.lessThan);
+
+                    const padding_after = endian == .little or ty.containerLayout(zcu) == .@"packed";
+
+                    for (field_order) |field_idx| {
+                        const field_ty = Type.fromInterned(zcu.typeToUnion(ty).?.field_types.get(ip)[field_idx]);
+                        const pad_bits = ty.bitSize(zcu) - field_ty.bitSize(zcu);
+                        if (!padding_after) try pack.padding(pad_bits);
+                        const field_val = pack.get(field_ty) catch |err| switch (err) {
+                            error.ReinterpretDeclRef => {
+                                pack.unpacked = prev_unpacked;
+                                pack.bit_offset = prev_bit_offset;
+                                continue;
+                            },
+                            else => |e| return e,
+                        };
+                        if (padding_after) try pack.padding(pad_bits);
+                        if (field_val.isUndef(zcu)) {
+                            pack.unpacked = prev_unpacked;
+                            pack.bit_offset = prev_bit_offset;
+                            continue;
+                        }
+                        const tag_val = try pt.enumValueFieldIndex(ty.unionTagTypeHypothetical(zcu), field_idx);
+                        return Value.fromInterned(try pt.internUnion(.{
+                            .ty = ty.toIntern(),
+                            .tag = tag_val.toIntern(),
+                            .val = field_val.toIntern(),
+                        }));
                     }
+
+                    // No field could represent the value. Just do whatever happens when we try to read
+                    // the backing type - either `undefined` or `error.ReinterpretDeclRef`.
+                    const backing_val = try pack.get(backing_ty);
                     return Value.fromInterned(try pt.internUnion(.{
                         .ty = ty.toIntern(),
                         .tag = .none,
                         .val = backing_val.toIntern(),
                     }));
-                }
-
-                const field_order = try pack.arena.alloc(u32, ty.unionTagTypeHypothetical(zcu).enumFieldCount(zcu));
-                for (field_order, 0..) |*f, i| f.* = @intCast(i);
-                // Sort `field_order` to put the fields with the largest bit sizes first.
-                const SizeSortCtx = struct {
-                    zcu: *Zcu,
-                    field_types: []const InternPool.Index,
-                    fn lessThan(ctx: @This(), a_idx: u32, b_idx: u32) bool {
-                        const a_ty = Type.fromInterned(ctx.field_types[a_idx]);
-                        const b_ty = Type.fromInterned(ctx.field_types[b_idx]);
-                        return a_ty.bitSize(ctx.zcu) > b_ty.bitSize(ctx.zcu);
-                    }
-                };
-                std.mem.sortUnstable(u32, field_order, SizeSortCtx{
-                    .zcu = zcu,
-                    .field_types = zcu.typeToUnion(ty).?.field_types.get(ip),
-                }, SizeSortCtx.lessThan);
-
-                const padding_after = endian == .little or ty.containerLayout(zcu) == .@"packed";
-
-                for (field_order) |field_idx| {
-                    const field_ty = Type.fromInterned(zcu.typeToUnion(ty).?.field_types.get(ip)[field_idx]);
-                    const pad_bits = ty.bitSize(zcu) - field_ty.bitSize(zcu);
-                    if (!padding_after) try pack.padding(pad_bits);
-                    const field_val = pack.get(field_ty) catch |err| switch (err) {
-                        error.ReinterpretDeclRef => {
-                            pack.unpacked = prev_unpacked;
-                            pack.bit_offset = prev_bit_offset;
-                            continue;
-                        },
-                        else => |e| return e,
-                    };
-                    if (padding_after) try pack.padding(pad_bits);
-                    if (field_val.isUndef(zcu)) {
-                        pack.unpacked = prev_unpacked;
-                        pack.bit_offset = prev_bit_offset;
-                        continue;
-                    }
-                    const tag_val = try pt.enumValueFieldIndex(ty.unionTagTypeHypothetical(zcu), field_idx);
-                    return Value.fromInterned(try pt.internUnion(.{
-                        .ty = ty.toIntern(),
-                        .tag = tag_val.toIntern(),
-                        .val = field_val.toIntern(),
-                    }));
-                }
-
-                // No field could represent the value. Just do whatever happens when we try to read
-                // the backing type - either `undefined` or `error.ReinterpretDeclRef`.
-                const backing_val = try pack.get(backing_ty);
-                return Value.fromInterned(try pt.internUnion(.{
-                    .ty = ty.toIntern(),
-                    .tag = .none,
-                    .val = backing_val.toIntern(),
-                }));
+                },
+                .@"packed" => {
+                    const backing_int_val = try pack.primitive(ty.bitpackBackingInt(zcu));
+                    return pt.bitpackValue(ty, backing_int_val);
+                },
             },
             else => return pack.primitive(ty),
         }
@@ -722,7 +725,7 @@ const PackValueBits = struct {
             const val = Value.fromInterned(ip_val);
             const ty = val.typeOf(zcu);
             if (!val.isUndef(zcu)) {
-                try val.writeToPackedMemory(ty, pt, buf, cur_bit_off);
+                try val.writeToPackedMemory(pt, buf, cur_bit_off);
             }
             cur_bit_off += @intCast(ty.bitSize(zcu));
         }
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 970cf4f0116328dc6f84fe4c1e755eb71a4a915a..1096c9cbe7d31cbd32958c0dcdfde5eae03b56bf 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -79,6 +79,7 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!vo
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
diff --git a/src/Type.zig b/src/Type.zig
index 5b5839cf6f40e5953e182162289aa2e7b05ba96d..9cca3d104320edfc2f0fbf63cc64a30d7256fa0b 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -407,6 +407,7 @@ pub fn print(ty: Type, writer: *std.Io.Writer, pt: Zcu.PerThread, ctx: ?*Compari
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -543,6 +544,7 @@ pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -639,6 +641,7 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -846,6 +849,7 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -978,6 +982,7 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -1102,6 +1107,7 @@ pub fn bitSize(ty: Type, zcu: *const Zcu) u64 {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -1393,16 +1399,16 @@ pub fn unionHasAllZeroBitFieldTypes(ty: Type, zcu: *Zcu) bool {
 }
 
 /// Returns the type used for backing storage of this union during comptime operations.
-/// Asserts the type is either an extern or packed union.
-pub fn unionBackingType(ty: Type, pt: Zcu.PerThread) !Type {
+/// Asserts the type is an extern union.
+pub fn externUnionBackingType(ty: Type, pt: Zcu.PerThread) !Type {
     const zcu = pt.zcu;
     assertHasLayout(ty, zcu);
     const loaded_union = zcu.intern_pool.loadUnionType(ty.toIntern());
-    return switch (loaded_union.layout) {
-        .@"extern" => try pt.arrayType(.{ .len = ty.abiSize(zcu), .child = .u8_type }),
-        .@"packed" => .fromInterned(loaded_union.packed_backing_int_type),
+    switch (loaded_union.layout) {
+        .@"extern" => return pt.arrayType(.{ .len = ty.abiSize(zcu), .child = .u8_type }),
+        .@"packed" => unreachable,
         .auto => unreachable,
-    };
+    }
 }
 
 pub fn unionGetLayout(ty: Type, zcu: *const Zcu) Zcu.UnionLayout {
@@ -1421,6 +1427,15 @@ pub fn containerLayout(ty: Type, zcu: *const Zcu) std.builtin.Type.ContainerLayo
     };
 }
 
+pub fn bitpackBackingInt(ty: Type, zcu: *const Zcu) Type {
+    const ip = &zcu.intern_pool;
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .struct_type => .fromInterned(ip.loadStructType(ty.toIntern()).packed_backing_int_type),
+        .union_type => .fromInterned(ip.loadUnionType(ty.toIntern()).packed_backing_int_type),
+        else => unreachable,
+    };
+}
+
 /// Asserts that the type is an error union.
 pub fn errorUnionPayload(ty: Type, zcu: *const Zcu) Type {
     return Type.fromInterned(zcu.intern_pool.indexToKey(ty.toIntern()).error_union_type.payload_type);
@@ -1635,6 +1650,7 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
             .opt,
             .aggregate,
             .un,
+            .bitpack,
             // memoization, not types
             .memoized_call,
             => unreachable,
@@ -1842,7 +1858,7 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
                 if (struct_obj.layout == .@"packed") {
                     const backing_ty: Type = .fromInterned(struct_obj.packed_backing_int_type);
                     const backing_val = try backing_ty.onePossibleValue(pt) orelse return null;
-                    _ = backing_val; // MLUGG TODO: represent unions as their bits!
+                    return try pt.bitpackValue(ty, backing_val);
                 } else {
                     if (!struct_obj.has_one_possible_value) return null;
                 }
@@ -1893,8 +1909,13 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
             },
 
             .union_type => {
-                // MLUGG TODO: is this nonsensical or what!!!!!!
                 const union_obj = ip.loadUnionType(ty.toIntern());
+                if (union_obj.layout == .@"packed") {
+                    const backing_ty: Type = .fromInterned(union_obj.packed_backing_int_type);
+                    const backing_val = try backing_ty.onePossibleValue(pt) orelse return null;
+                    return try pt.bitpackValue(ty, backing_val);
+                }
+                // MLUGG TODO: is this nonsensical or what!!!!!!
                 const tag_val = (try Type.fromInterned(union_obj.enum_tag_type).onePossibleValue(pt)) orelse
                     return null;
                 if (union_obj.field_types.len == 0) {
@@ -1957,6 +1978,7 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
             .opt,
             .aggregate,
             .un,
+            .bitpack,
             // memoization, not types
             .memoized_call,
             => unreachable,
@@ -2061,6 +2083,7 @@ pub fn comptimeOnly(ty: Type, zcu: *const Zcu) bool {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -3080,6 +3103,7 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         .undef,
         // memoization, not types
         .memoized_call,
@@ -3158,6 +3182,7 @@ fn collectSubtypes(ty: Type, pt: Zcu.PerThread, visited: *std.AutoArrayHashMapUn
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
diff --git a/src/Value.zig b/src/Value.zig
index d513e5d07d9d07311a7d15b106e57795b54e92be..774a6758ceff8d82fc579f580b33de17ad4fef75 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -158,6 +158,7 @@ pub fn toBigInt(val: Value, space: *BigIntSpace, zcu: *Zcu) BigIntConst {
     const ip = &zcu.intern_pool;
     const int_key = switch (ip.indexToKey(val.toIntern())) {
         .enum_tag => |enum_tag| ip.indexToKey(enum_tag.int).int,
+        .bitpack => |bitpack| ip.indexToKey(bitpack.backing_int_val).int,
         .int => |int| int,
         else => unreachable,
     };
@@ -216,6 +217,7 @@ pub fn getUnsignedInt(val: Value, zcu: *const Zcu) ?u64 {
                 else => |payload| Value.fromInterned(payload).getUnsignedInt(zcu),
             },
             .enum_tag => |enum_tag| Value.fromInterned(enum_tag.int).getUnsignedInt(zcu),
+            .bitpack => |bitpack| Value.fromInterned(bitpack.backing_int_val).getUnsignedInt(zcu),
             .err => |err| zcu.intern_pool.getErrorValueIfExists(err.name).?,
             else => null,
         },
@@ -309,7 +311,7 @@ pub fn writeToMemory(val: Value, pt: Zcu.PerThread, buffer: []u8) error{
             // We use byte_count instead of abi_size here, so that any padding bytes
             // follow the data bytes, on both big- and little-endian systems.
             const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
-            return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);
+            return writeToPackedMemory(val, pt, buffer[0..byte_count], 0);
         },
         .@"struct" => {
             const struct_type = zcu.typeToStruct(ty) orelse return error.IllDefinedMemoryLayout;
@@ -328,8 +330,8 @@ pub fn writeToMemory(val: Value, pt: Zcu.PerThread, buffer: []u8) error{
                     try writeToMemory(field_val, pt, buffer[off..]);
                 },
                 .@"packed" => {
-                    const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
-                    return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);
+                    const int_index = ip.indexToKey(val.toIntern()).bitpack.backing_int_val;
+                    return Value.fromInterned(int_index).writeToMemory(pt, buffer);
                 },
             }
         },
@@ -344,15 +346,14 @@ pub fn writeToMemory(val: Value, pt: Zcu.PerThread, buffer: []u8) error{
                     const byte_count: usize = @intCast(field_type.abiSize(zcu));
                     return writeToMemory(field_val, pt, buffer[0..byte_count]);
                 } else {
-                    const backing_ty = try ty.unionBackingType(pt);
+                    const backing_ty = try ty.externUnionBackingType(pt);
                     const byte_count: usize = @intCast(backing_ty.abiSize(zcu));
                     return writeToMemory(val.unionValue(zcu), pt, buffer[0..byte_count]);
                 }
             },
             .@"packed" => {
-                const backing_ty = try ty.unionBackingType(pt);
-                const byte_count: usize = @intCast(backing_ty.abiSize(zcu));
-                return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);
+                const int_val: Value = .fromInterned(ip.indexToKey(val.toIntern()).bitpack.backing_int_val);
+                return writeToMemory(int_val, pt, buffer);
             },
         },
         .optional => {
@@ -374,7 +375,6 @@ pub fn writeToMemory(val: Value, pt: Zcu.PerThread, buffer: []u8) error{
 /// big-endian packed memory layouts start at the end of the buffer.
 pub fn writeToPackedMemory(
     val: Value,
-    ty: Type,
     pt: Zcu.PerThread,
     buffer: []u8,
     bit_offset: usize,
@@ -383,6 +383,7 @@ pub fn writeToPackedMemory(
     const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
     const endian = target.cpu.arch.endian();
+    const ty = val.typeOf(zcu);
     if (val.isUndef(zcu)) {
         const bit_size: usize = @intCast(ty.bitSize(zcu));
         if (bit_size != 0) {
@@ -405,7 +406,13 @@ pub fn writeToPackedMemory(
         },
         .@"enum" => {
             const int_val = val.intFromEnum(zcu);
-            return int_val.writeToPackedMemory(int_val.typeOf(zcu), pt, buffer, bit_offset);
+            return int_val.writeToPackedMemory(pt, buffer, bit_offset);
+        },
+        .pointer => {
+            assert(!ty.isSlice(zcu)); // No well defined layout.
+            if (ip.getBackingAddrTag(val.toIntern()).? != .int) return error.ReinterpretDeclRef;
+            const addr = val.toUnsignedInt(zcu);
+            std.mem.writeVarPackedInt(buffer, bit_offset, zcu.getTarget().ptrBitWidth(), addr, endian);
         },
         .int => {
             const bits = ty.intInfo(zcu).bits;
@@ -434,54 +441,21 @@ pub fn writeToPackedMemory(
                 // On big-endian systems, LLVM reverses the element order of vectors by default
                 const tgt_elem_i = if (endian == .big) len - elem_i - 1 else elem_i;
                 const elem_val = try val.elemValue(pt, tgt_elem_i);
-                try elem_val.writeToPackedMemory(elem_ty, pt, buffer, bit_offset + bits);
+                try elem_val.writeToPackedMemory(pt, buffer, bit_offset + bits);
                 bits += elem_bit_size;
             }
         },
-        .@"struct" => {
-            const struct_type = ip.loadStructType(ty.toIntern());
-            // Sema is supposed to have emitted a compile error already in the case of Auto,
-            // and Extern is handled in non-packed writeToMemory.
-            assert(struct_type.layout == .@"packed");
-            var bits: u16 = 0;
-            for (0..struct_type.field_types.len) |i| {
-                const field_val = Value.fromInterned(switch (ip.indexToKey(val.toIntern()).aggregate.storage) {
-                    .bytes => unreachable,
-                    .elems => |elems| elems[i],
-                    .repeated_elem => |elem| elem,
-                });
-                const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-                const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
-                try field_val.writeToPackedMemory(field_ty, pt, buffer, bit_offset + bits);
-                bits += field_bits;
-            }
-        },
-        .@"union" => {
-            const union_obj = zcu.typeToUnion(ty).?;
-            assert(union_obj.layout == .@"packed");
-            if (val.unionTag(zcu)) |union_tag| {
-                const field_index = zcu.unionTagFieldIndex(union_obj, union_tag).?;
-                const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-                const field_val = try val.fieldValue(pt, field_index);
-                return field_val.writeToPackedMemory(field_type, pt, buffer, bit_offset);
-            } else {
-                const backing_ty = try ty.unionBackingType(pt);
-                return val.unionValue(zcu).writeToPackedMemory(backing_ty, pt, buffer, bit_offset);
-            }
-        },
-        .pointer => {
-            assert(!ty.isSlice(zcu)); // No well defined layout.
-            if (ip.getBackingAddrTag(val.toIntern()).? != .int) return error.ReinterpretDeclRef;
-            return val.writeToPackedMemory(Type.usize, pt, buffer, bit_offset);
+        .@"struct", .@"union" => {
+            assert(ty.containerLayout(zcu) == .@"packed");
+            const int_val: Value = .fromInterned(ip.indexToKey(val.toIntern()).bitpack.backing_int_val);
+            return int_val.writeToPackedMemory(pt, buffer, bit_offset);
         },
         .optional => {
             assert(ty.isPtrLikeOptional(zcu));
-            const child = ty.optionalChild(zcu);
-            const opt_val = val.optionalValue(zcu);
-            if (opt_val) |some| {
-                return some.writeToPackedMemory(child, pt, buffer, bit_offset);
+            if (val.optionalValue(zcu)) |ptr_val| {
+                return ptr_val.writeToPackedMemory(pt, buffer, bit_offset);
             } else {
-                return writeToPackedMemory(try pt.intValue(Type.usize, 0), Type.usize, pt, buffer, bit_offset);
+                return Value.zero_usize.writeToPackedMemory(pt, buffer, bit_offset);
             }
         },
         else => @panic("TODO implement writeToPackedMemory for more types"),
@@ -531,13 +505,12 @@ pub fn readFromPackedMemory(
     pt: Zcu.PerThread,
     buffer: []const u8,
     bit_offset: usize,
-    arena: Allocator,
+    gpa: Allocator,
 ) error{
     IllDefinedMemoryLayout,
     OutOfMemory,
 }!Value {
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
     const endian = target.cpu.arch.endian();
     switch (ty.zigTypeTag(zcu)) {
@@ -571,7 +544,8 @@ pub fn readFromPackedMemory(
             const abi_size: usize = @intCast(ty.abiSize(zcu));
             const Limb = std.math.big.Limb;
             const limb_count = (abi_size + @sizeOf(Limb) - 1) / @sizeOf(Limb);
-            const limbs_buffer = try arena.alloc(Limb, limb_count);
+            const limbs_buffer = try gpa.alloc(Limb, limb_count);
+            defer gpa.free(limbs_buffer);
 
             var bigint = BigIntMutable.init(limbs_buffer, 0);
             bigint.readPackedTwosComplement(buffer, bit_offset, bits, endian, int_info.signedness);
@@ -579,7 +553,7 @@ pub fn readFromPackedMemory(
         },
         .@"enum" => {
             const int_ty = ty.intTagType(zcu);
-            const int_val = try Value.readFromPackedMemory(int_ty, pt, buffer, bit_offset, arena);
+            const int_val = try Value.readFromPackedMemory(int_ty, pt, buffer, bit_offset, gpa);
             return pt.getCoerced(int_val, ty);
         },
         .float => return Value.fromInterned(try pt.intern(.{ .float = .{
@@ -595,52 +569,32 @@ pub fn readFromPackedMemory(
         } })),
         .vector => {
             const elem_ty = ty.childType(zcu);
-            const elems = try arena.alloc(InternPool.Index, @intCast(ty.arrayLen(zcu)));
+            const elems = try gpa.alloc(InternPool.Index, @intCast(ty.arrayLen(zcu)));
+            defer gpa.free(elems);
 
             var bits: u16 = 0;
             const elem_bit_size: u16 = @intCast(elem_ty.bitSize(zcu));
             for (elems, 0..) |_, i| {
                 // On big-endian systems, LLVM reverses the element order of vectors by default
                 const tgt_elem_i = if (endian == .big) elems.len - i - 1 else i;
-                elems[tgt_elem_i] = (try readFromPackedMemory(elem_ty, pt, buffer, bit_offset + bits, arena)).toIntern();
+                elems[tgt_elem_i] = (try readFromPackedMemory(elem_ty, pt, buffer, bit_offset + bits, gpa)).toIntern();
                 bits += elem_bit_size;
             }
             return pt.aggregateValue(ty, elems);
         },
-        .@"struct" => {
-            // Sema is supposed to have emitted a compile error already for Auto layout structs,
-            // and Extern is handled by non-packed readFromMemory.
-            const struct_type = zcu.typeToPackedStruct(ty).?;
-            var bits: u16 = 0;
-            const field_vals = try arena.alloc(InternPool.Index, struct_type.field_types.len);
-            for (field_vals, 0..) |*field_val, i| {
-                const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-                const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
-                field_val.* = (try readFromPackedMemory(field_ty, pt, buffer, bit_offset + bits, arena)).toIntern();
-                bits += field_bits;
-            }
-            return pt.aggregateValue(ty, field_vals);
-        },
-        .@"union" => switch (ty.containerLayout(zcu)) {
-            .auto, .@"extern" => unreachable, // Handled by non-packed readFromMemory
-            .@"packed" => {
-                const backing_ty = try ty.unionBackingType(pt);
-                const val = (try readFromPackedMemory(backing_ty, pt, buffer, bit_offset, arena)).toIntern();
-                return Value.fromInterned(try pt.internUnion(.{
-                    .ty = ty.toIntern(),
-                    .tag = .none,
-                    .val = val,
-                }));
-            },
+        .@"struct", .@"union" => {
+            assert(ty.containerLayout(zcu) == .@"packed");
+            const int_val: Value = try .readFromPackedMemory(ty.bitpackBackingInt(zcu), pt, buffer, bit_offset, gpa);
+            return pt.bitpackValue(ty, int_val);
         },
         .pointer => {
             assert(!ty.isSlice(zcu)); // No well defined layout.
-            const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena)).toUnsignedInt(zcu);
+            const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, gpa)).toUnsignedInt(zcu);
             return pt.ptrIntValue(ty, addr);
         },
         .optional => {
             assert(ty.isPtrLikeOptional(zcu));
-            const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena)).toUnsignedInt(zcu);
+            const addr = (try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, gpa)).toUnsignedInt(zcu);
             return .fromInterned(try pt.intern(.{ .opt = .{
                 .ty = ty.toIntern(),
                 .val = if (addr == 0) .none else (try pt.ptrIntValue(ty.childType(zcu), addr)).toIntern(),
@@ -915,8 +869,44 @@ pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {
             .elems => |elems| elems[index],
             .repeated_elem => |elem| elem,
         }),
-        // TODO assert the tag is correct
-        .un => |un| Value.fromInterned(un.val),
+        .un => |un| {
+            switch (Type.fromInterned(un.ty).containerLayout(zcu)) {
+                .auto, .@"extern" => {}, // TODO assert the tag is correct
+                .@"packed" => unreachable,
+            }
+            return .fromInterned(un.val);
+        },
+        .bitpack => |bitpack| {
+            const ty: Type = .fromInterned(bitpack.ty);
+            assert(ty.containerLayout(zcu) == .@"packed");
+            const int_val: Value = .fromInterned(bitpack.backing_int_val);
+            assert(!int_val.isUndef(zcu));
+            const field_ty = ty.fieldType(index, zcu);
+            const field_bit_offset: u16 = switch (ty.zigTypeTag(zcu)) {
+                .@"union" => 0,
+                .@"struct" => off: {
+                    var off: u16 = 0;
+                    for (0..index) |preceding_field_index| {
+                        off += @intCast(ty.fieldType(preceding_field_index, zcu).bitSize(zcu));
+                    }
+                    break :off off;
+                },
+                else => unreachable,
+            };
+            // Avoid hitting gpa for accesses to small packed structs
+            var sfba_state = std.heap.stackFallback(128, zcu.comp.gpa);
+            const sfba = sfba_state.get();
+            const buf = try sfba.alloc(u8, (ty.bitSize(zcu) + 7) / 8);
+            defer sfba.free(buf);
+            int_val.writeToPackedMemory(pt, buf, 0) catch |err| switch (err) {
+                error.ReinterpretDeclRef => unreachable, // it's an integer
+                error.OutOfMemory => |e| return e,
+            };
+            return Value.readFromPackedMemory(field_ty, pt, buf, field_bit_offset, sfba) catch |err| switch (err) {
+                error.IllDefinedMemoryLayout => unreachable, // it's a bitpack
+                error.OutOfMemory => |e| return e,
+            };
+        },
         else => unreachable,
     };
 }
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 00c911caf4e67e3a7dcf5691ebe7cf45d53ff002..186d6147d13622463f56d708f07a62d8b0e128c2 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -3950,6 +3950,15 @@ pub fn floatValue(pt: Zcu.PerThread, ty: Type, x: anytype) Allocator.Error!Value
     } }));
 }
 
+/// Create a value whose type is a `packed struct` or `packed union`, from the backing integer value.
+pub fn bitpackValue(pt: Zcu.PerThread, ty: Type, backing_int_val: Value) Allocator.Error!Value {
+    assert(backing_int_val.typeOf(pt.zcu).toIntern() == ty.bitpackBackingInt(pt.zcu).toIntern());
+    return .fromInterned(try pt.intern(.{ .bitpack = .{
+        .ty = ty.toIntern(),
+        .backing_int_val = backing_int_val.toIntern(),
+    } }));
+}
+
 pub fn nullValue(pt: Zcu.PerThread, opt_ty: Type) Allocator.Error!Value {
     assert(pt.zcu.intern_pool.isOptionalType(opt_ty.toIntern()));
     return Value.fromInterned(try pt.intern(.{ .opt = .{
diff --git a/src/codegen.zig b/src/codegen.zig
index e9acab66e4c2b8a618447ea6fad9659ab1c39243..9edb90fb51056d9ad56f913982b001ff8750e52b 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -570,42 +570,7 @@ pub fn generateSymbol(
             .struct_type => {
                 const struct_type = ip.loadStructType(ty.toIntern());
                 switch (struct_type.layout) {
-                    .@"packed" => {
-                        const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
-                        const start = w.end;
-                        const buffer = try w.writableSlice(abi_size);
-                        @memset(buffer, 0);
-                        var bits: u16 = 0;
-
-                        for (struct_type.field_types.get(ip), 0..) |field_ty, index| {
-                            const field_val = switch (aggregate.storage) {
-                                .bytes => |bytes| try pt.intern(.{ .int = .{
-                                    .ty = field_ty,
-                                    .storage = .{ .u64 = bytes.at(index, ip) },
-                                } }),
-                                .elems => |elems| elems[index],
-                                .repeated_elem => |elem| elem,
-                            };
-
-                            // pointer may point to a decl which must be marked used
-                            // but can also result in a relocation. Therefore we handle those separately.
-                            if (Type.fromInterned(field_ty).zigTypeTag(zcu) == .pointer) {
-                                const field_offset = std.math.divExact(u16, bits, 8) catch |err| switch (err) {
-                                    error.DivisionByZero => unreachable,
-                                    error.UnexpectedRemainder => return error.RelocationNotByteAligned,
-                                };
-                                w.end = start + field_offset;
-                                defer {
-                                    assert(w.end == start + field_offset + @divExact(target.ptrBitWidth(), 8));
-                                    w.end = start + abi_size;
-                                }
-                                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), w, reloc_parent);
-                            } else {
-                                Value.fromInterned(field_val).writeToPackedMemory(.fromInterned(field_ty), pt, buffer, bits) catch unreachable;
-                            }
-                            bits += @intCast(Type.fromInterned(field_ty).bitSize(zcu));
-                        }
-                    },
+                    .@"packed" => unreachable,
                     .auto, .@"extern" => {
                         const struct_begin = w.end;
                         const field_types = struct_type.field_types.get(ip);
@@ -683,6 +648,7 @@ pub fn generateSymbol(
                 }
             }
         },
+        .bitpack => |bitpack| try generateSymbol(bin_file, pt, src_loc, .fromInterned(bitpack.backing_int_val), w, reloc_parent),
         .memoized_call => unreachable,
     }
 }
@@ -1120,6 +1086,10 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
                 target,
             );
         },
+        .@"struct", .@"union" => if (ty.containerLayout(zcu) == .@"packed") {
+            const bitpack = ip.indexToKey(val.toIntern()).bitpack;
+            return lowerValue(pt, .fromInterned(bitpack.backing_int_val), target);
+        },
         .error_set => {
             const err_name = ip.indexToKey(val.toIntern()).err.name;
             const error_index = ip.getErrorValueIfExists(err_name).?;
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index 74494649056adbe9d0baeceea5f320c9b12f5d95..f9ff7874770ed1bd1b995a3689a89242c7211898 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -2791,17 +2791,17 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 } else return isel.fail("invalid constraint: '{s}'", .{constraint});
             }
 
-            const clobbers = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
-            const clobbers_ty: ZigType = .fromInterned(clobbers.ty);
+            const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+            const clobbers_ty = clobbers_val.typeOf(zcu);
+            var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+            const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
-                switch (switch (clobbers.storage) {
-                    .bytes => unreachable,
-                    .elems => |elems| elems[field_index],
-                    .repeated_elem => |repeated_elem| repeated_elem,
-                }) {
-                    else => unreachable,
-                    .bool_false => continue,
-                    .bool_true => {},
+                assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
+                const limb_bits = @bitSizeOf(std.math.big.Limb);
+                if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
+                    0 => continue, // field is false
+                    1 => {}, // field is true
                 }
                 const clobber_name = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
                 if (std.mem.eql(u8, clobber_name, "memory")) continue;
@@ -2816,14 +2816,11 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 }
             }
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
-                switch (switch (clobbers.storage) {
-                    .bytes => unreachable,
-                    .elems => |elems| elems[field_index],
-                    .repeated_elem => |repeated_elem| repeated_elem,
-                }) {
-                    else => unreachable,
-                    .bool_false => continue,
-                    .bool_true => {},
+                const limb_bits = @bitSizeOf(std.math.big.Limb);
+                if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> field_index % limb_bits))) {
+                    0 => continue, // field is false
+                    1 => {}, // field is true
                 }
                 const clobber_name = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
                 if (std.mem.eql(u8, clobber_name, "memory")) continue;
@@ -2872,14 +2869,11 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             }
 
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
-                switch (switch (clobbers.storage) {
-                    .bytes => unreachable,
-                    .elems => |elems| elems[field_index],
-                    .repeated_elem => |repeated_elem| repeated_elem,
-                }) {
-                    else => unreachable,
-                    .bool_false => continue,
-                    .bool_true => {},
+                const limb_bits = @bitSizeOf(std.math.big.Limb);
+                if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> field_index % limb_bits))) {
+                    0 => continue, // field is false
+                    1 => {}, // field is true
                 }
                 const clobber_name = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
                 if (std.mem.eql(u8, clobber_name, "memory")) continue;
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 5e9f21e1aada16d7fa98ebd9a9c01d7b11a35d8c..69c4e91d999c4340e0fe18f299ba88787052a66a 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -1362,77 +1362,42 @@ pub const DeclGen = struct {
                 },
                 .struct_type => {
                     const loaded_struct = ip.loadStructType(ty.toIntern());
-                    switch (loaded_struct.layout) {
-                        .auto, .@"extern" => {
-                            if (!location.isInitializer()) {
-                                try w.writeByte('(');
-                                try dg.renderCType(w, ctype);
-                                try w.writeByte(')');
-                            }
+                    assert(loaded_struct.layout != .@"packed");
 
-                            try w.writeByte('{');
-                            var field_it = loaded_struct.iterateRuntimeOrder(ip);
-                            var need_comma = false;
-                            while (field_it.next()) |field_index| {
-                                const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                    if (!location.isInitializer()) {
+                        try w.writeByte('(');
+                        try dg.renderCType(w, ctype);
+                        try w.writeByte(')');
+                    }
+
+                    try w.writeByte('{');
+                    var field_it = loaded_struct.iterateRuntimeOrder(ip);
+                    var need_comma = false;
+                    while (field_it.next()) |field_index| {
+                        const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
+                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
 
-                                if (need_comma) try w.writeByte(',');
-                                need_comma = true;
-                                const field_val = switch (ip.indexToKey(val.toIntern()).aggregate.storage) {
-                                    .bytes => |bytes| try pt.intern(.{ .int = .{
-                                        .ty = field_ty.toIntern(),
-                                        .storage = .{ .u64 = bytes.at(field_index, ip) },
-                                    } }),
-                                    .elems => |elems| elems[field_index],
-                                    .repeated_elem => |elem| elem,
-                                };
-                                try dg.renderValue(w, Value.fromInterned(field_val), initializer_type);
-                            }
-                            try w.writeByte('}');
-                        },
-                        .@"packed" => {
-                            // https://github.com/ziglang/zig/issues/24657 will eliminate most of the
-                            // following logic, leaving only the recursive `renderValue` call. Once
-                            // that proposal is implemented, a `packed struct` will literally be
-                            // represented in the InternPool by its comptime-known backing integer.
-                            var arena: std.heap.ArenaAllocator = .init(zcu.gpa);
-                            defer arena.deinit();
-                            const backing_ty: Type = .fromInterned(loaded_struct.backingIntTypeUnordered(ip));
-                            const buf = try arena.allocator().alloc(u8, @intCast(ty.abiSize(zcu)));
-                            val.writeToMemory(pt, buf) catch |err| switch (err) {
-                                error.IllDefinedMemoryLayout => unreachable,
-                                error.OutOfMemory => |e| return e,
-                                error.ReinterpretDeclRef, error.Unimplemented => return dg.fail("TODO: C backend: lower packed struct value", .{}),
-                            };
-                            const backing_val: Value = try .readUintFromMemory(backing_ty, pt, buf, arena.allocator());
-                            return dg.renderValue(w, backing_val, location);
-                        },
+                        if (need_comma) try w.writeByte(',');
+                        need_comma = true;
+                        const field_val = switch (ip.indexToKey(val.toIntern()).aggregate.storage) {
+                            .bytes => |bytes| try pt.intern(.{ .int = .{
+                                .ty = field_ty.toIntern(),
+                                .storage = .{ .u64 = bytes.at(field_index, ip) },
+                            } }),
+                            .elems => |elems| elems[field_index],
+                            .repeated_elem => |elem| elem,
+                        };
+                        try dg.renderValue(w, Value.fromInterned(field_val), initializer_type);
                     }
+                    try w.writeByte('}');
                 },
                 else => unreachable,
             },
+            .bitpack => |bitpack| return dg.renderValue(w, .fromInterned(bitpack.backing_int_val), location),
             .un => |un| {
                 const loaded_union = ip.loadUnionType(ty.toIntern());
-                if (loaded_union.flagsUnordered(ip).layout == .@"packed") {
-                    // https://github.com/ziglang/zig/issues/24657 will eliminate most of the
-                    // following logic, leaving only the recursive `renderValue` call. Once
-                    // that proposal is implemented, a `packed union` will literally be
-                    // represented in the InternPool by its comptime-known backing integer.
-                    var arena: std.heap.ArenaAllocator = .init(zcu.gpa);
-                    defer arena.deinit();
-                    const backing_ty = try ty.unionBackingType(pt);
-                    const buf = try arena.allocator().alloc(u8, @intCast(ty.abiSize(zcu)));
-                    val.writeToMemory(pt, buf) catch |err| switch (err) {
-                        error.IllDefinedMemoryLayout => unreachable,
-                        error.OutOfMemory => |e| return e,
-                        error.ReinterpretDeclRef, error.Unimplemented => return dg.fail("TODO: C backend: lower packed union value", .{}),
-                    };
-                    const backing_val: Value = try .readUintFromMemory(backing_ty, pt, buf, arena.allocator());
-                    return dg.renderValue(w, backing_val, location);
-                }
                 if (un.tag == .none) {
-                    const backing_ty = try ty.unionBackingType(pt);
+                    const backing_ty = try ty.externUnionBackingType(pt);
                     assert(loaded_union.flagsUnordered(ip).layout == .@"extern");
                     if (location == .StaticInitializer) {
                         return dg.fail("TODO: C backend: implement extern union backing type rendering in static initializers", .{});
@@ -1642,11 +1607,7 @@ pub const DeclGen = struct {
                             }
                             return w.writeByte('}');
                         },
-                        .@"packed" => return dg.renderUndefValue(
-                            w,
-                            .fromInterned(loaded_struct.backingIntTypeUnordered(ip)),
-                            location,
-                        ),
+                        .@"packed" => return dg.renderUndefValue(w, ty.bitpackBackingInt(zcu), location),
                     }
                 },
                 .tuple_type => |tuple_info| {
@@ -1714,11 +1675,7 @@ pub const DeclGen = struct {
                             }
                             if (has_tag) try w.writeByte('}');
                         },
-                        .@"packed" => return dg.renderUndefValue(
-                            w,
-                            try ty.unionBackingType(pt),
-                            location,
-                        ),
+                        .@"packed" => return dg.renderUndefValue(w, ty.bitpackBackingInt(zcu), location),
                     }
                 },
                 .error_union_type => |error_union_type| switch (ctype.info(ctype_pool)) {
@@ -5623,48 +5580,45 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
         }
         try w.writeByte(':');
         const ip = &zcu.intern_pool;
-        const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
-        const struct_type: Type = .fromInterned(aggregate.ty);
-        switch (aggregate.storage) {
-            .elems => |elems| for (elems, 0..) |elem, i| switch (elem) {
-                .bool_true => {
-                    const field_name = struct_type.structFieldName(i, zcu).toSlice(ip).?;
-                    assert(field_name.len != 0);
+        const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+        const clobbers_ty = clobbers_val.typeOf(zcu);
+        var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+        const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
+        for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
+            assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
+            const limb_bits = @bitSizeOf(std.math.big.Limb);
+            if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+            switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
+                0 => continue, // field is false
+                1 => {}, // field is true
+            }
+            const field_name = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
+            assert(field_name.len != 0);
 
-                    const target = &f.object.dg.mod.resolved_target.result;
-                    var c_name_buf: [16]u8 = undefined;
-                    const name =
-                        if ((target.cpu.arch.isMIPS() or target.cpu.arch == .alpha) and field_name[0] == 'r') name: {
-                            // Convert "rN" to "$N"
-                            const c_name = (&c_name_buf)[0..field_name.len];
-                            @memcpy(c_name, field_name);
-                            c_name_buf[0] = '$';
-                            break :name c_name;
-                        } else if ((target.cpu.arch.isMIPS() and (mem.startsWith(u8, field_name, "fcc") or field_name[0] == 'w')) or
-                        ((target.cpu.arch.isMIPS() or target.cpu.arch == .alpha) and field_name[0] == 'f') or
-                        (target.cpu.arch == .kvx and !mem.eql(u8, field_name, "memory"))) name: {
-                            // "$" prefix for these registers
-                            c_name_buf[0] = '$';
-                            @memcpy((&c_name_buf)[1..][0..field_name.len], field_name);
-                            break :name (&c_name_buf)[0 .. 1 + field_name.len];
-                        } else if (target.cpu.arch.isSPARC() and
-                        (mem.eql(u8, field_name, "ccr") or mem.eql(u8, field_name, "icc") or mem.eql(u8, field_name, "xcc"))) name: {
-                            // C compilers just use `icc` to encompass all of these.
-                            break :name "icc";
-                        } else field_name;
+            const target = &f.object.dg.mod.resolved_target.result;
+            var c_name_buf: [16]u8 = undefined;
+            const name =
+                if ((target.cpu.arch.isMIPS() or target.cpu.arch == .alpha) and field_name[0] == 'r') name: {
+                    // Convert "rN" to "$N"
+                    const c_name = (&c_name_buf)[0..field_name.len];
+                    @memcpy(c_name, field_name);
+                    c_name_buf[0] = '$';
+                    break :name c_name;
+                } else if ((target.cpu.arch.isMIPS() and (mem.startsWith(u8, field_name, "fcc") or field_name[0] == 'w')) or
+                ((target.cpu.arch.isMIPS() or target.cpu.arch == .alpha) and field_name[0] == 'f') or
+                (target.cpu.arch == .kvx and !mem.eql(u8, field_name, "memory"))) name: {
+                    // "$" prefix for these registers
+                    c_name_buf[0] = '$';
+                    @memcpy((&c_name_buf)[1..][0..field_name.len], field_name);
+                    break :name (&c_name_buf)[0 .. 1 + field_name.len];
+                } else if (target.cpu.arch.isSPARC() and
+                (mem.eql(u8, field_name, "ccr") or mem.eql(u8, field_name, "icc") or mem.eql(u8, field_name, "xcc"))) name: {
+                    // C compilers just use `icc` to encompass all of these.
+                    break :name "icc";
+                } else field_name;
 
-                    try w.print(" {f}", .{fmtStringLiteral(name, null)});
-                    (try w.writableArray(1))[0] = ',';
-                },
-                .bool_false => continue,
-                else => unreachable,
-            },
-            .repeated_elem => |elem| switch (elem) {
-                .bool_true => @panic("TODO"),
-                .bool_false => {},
-                else => unreachable,
-            },
-            .bytes => @panic("TODO"),
+            try w.print(" {f}", .{fmtStringLiteral(name, null)});
+            (try w.writableArray(1))[0] = ',';
         }
         w.undo(1); // erase the last comma
         try w.writeAll(");");
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index ad115504baec4eaad608f6f3cf9d614a3e9d610d..695bb82133aea39b4478c3a9ad4f4ec4c07be6cc 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3680,7 +3680,7 @@ pub const Object = struct {
         const limbs = try allocator.alloc(std.math.big.Limb, std.math.big.int.calcTwosCompLimbCount(bits));
         defer allocator.free(limbs);
 
-        val.writeToPackedMemory(ty, pt, buffer, 0) catch unreachable;
+        val.writeToPackedMemory(pt, buffer, 0) catch unreachable;
 
         var big: std.math.big.int.Mutable = .init(limbs, 0);
         big.readTwosComplement(buffer, bits, target.cpu.arch.endian(), .unsigned);
@@ -7467,29 +7467,20 @@ pub const FuncGen = struct {
         }
 
         const ip = &zcu.intern_pool;
-        const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
-        const struct_type: Type = .fromInterned(aggregate.ty);
-        if (total_i != 0) try llvm_constraints.append(gpa, ',');
-        switch (aggregate.storage) {
-            .elems => |elems| for (elems, 0..) |elem, i| {
-                switch (elem) {
-                    .bool_true => {
-                        const name = struct_type.structFieldName(i, zcu).toSlice(ip).?;
-                        total_i += try appendConstraints(gpa, &llvm_constraints, name, target);
-                    },
-                    .bool_false => continue,
-                    else => unreachable,
-                }
-            },
-            .repeated_elem => |elem| switch (elem) {
-                .bool_true => for (0..struct_type.structFieldCount(zcu)) |i| {
-                    const name = struct_type.structFieldName(i, zcu).toSlice(ip).?;
-                    total_i += try appendConstraints(gpa, &llvm_constraints, name, target);
-                },
-                .bool_false => {},
-                else => unreachable,
-            },
-            .bytes => @panic("TODO"),
+        const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+        const clobbers_ty = clobbers_val.typeOf(zcu);
+        var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+        const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
+        for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
+            assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
+            const limb_bits = @bitSizeOf(std.math.big.Limb);
+            if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+            switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
+                0 => continue, // field is false
+                1 => {}, // field is true
+            }
+            const name = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
+            total_i += try appendConstraints(gpa, &llvm_constraints, name, target);
         }
 
         // We have finished scanning through all inputs/outputs, so the number of
diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig
index 72174554adc862a80034a2af57721703cba0c7a2..1f5b6224d7ef7fbe1cfe1aaa2fc55889db0676ca 100644
--- a/src/codegen/riscv64/CodeGen.zig
+++ b/src/codegen/riscv64/CodeGen.zig
@@ -6149,31 +6149,26 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void {
 
     const zcu = func.pt.zcu;
     const ip = &zcu.intern_pool;
-    const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
-    const struct_type: Type = .fromInterned(aggregate.ty);
-    switch (aggregate.storage) {
-        .elems => |elems| for (elems, 0..) |elem, i| {
-            switch (elem) {
-                .bool_true => {
-                    const clobber = struct_type.structFieldName(i, zcu).toSlice(ip).?;
-                    assert(clobber.len != 0);
-                    if (std.mem.eql(u8, clobber, "memory")) {
-                        // nothing really to do
-                    } else {
-                        try func.register_manager.getReg(parseRegName(clobber) orelse
-                            return func.fail("invalid clobber: '{s}'", .{clobber}), null);
-                    }
-                },
-                .bool_false => continue,
-                else => unreachable,
-            }
-        },
-        .repeated_elem => |elem| switch (elem) {
-            .bool_true => @panic("TODO"),
-            .bool_false => {},
-            else => unreachable,
-        },
-        .bytes => @panic("TODO"),
+    const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+    const clobbers_ty = clobbers_val.typeOf(zcu);
+    var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+    const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
+    for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
+        assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
+        const limb_bits = @bitSizeOf(std.math.big.Limb);
+        if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+        switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
+            0 => continue, // field is false
+            1 => {}, // field is true
+        }
+        const clobber = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
+        assert(clobber.len != 0);
+        if (std.mem.eql(u8, clobber, "memory")) {
+            // nothing really to do
+        } else {
+            try func.register_manager.getReg(parseRegName(clobber) orelse
+                return func.fail("invalid clobber: '{s}'", .{clobber}), null);
+        }
     }
 
     const Label = struct {
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index 5217002f22ecaa5dc3aad1a2035040baa6132e5c..709de66a412e409ea6017d0a15a631156fe133e4 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -969,7 +969,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
                         const bytes = std.mem.alignForward(u16, cg.module.backingIntBits(bits).@"0", 8) / 8;
                         var limbs: [8]u8 = undefined;
                         @memset(&limbs, 0);
-                        val.writeToPackedMemory(ty, pt, limbs[0..bytes], 0) catch unreachable;
+                        val.writeToPackedMemory(pt, limbs[0..bytes], 0) catch unreachable;
                         const backing_ty: Type = .fromInterned(struct_type.backingIntTypeUnordered(ip));
                         return try cg.constInt(backing_ty, @as(u64, @bitCast(limbs)));
                     }
diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig
index 955e9b51d361ec75ea1c1b5ab08c71dc7f2cbd40..cdcaac93025a4902f1d123c485e80076558a84ed 100644
--- a/src/codegen/wasm/CodeGen.zig
+++ b/src/codegen/wasm/CodeGen.zig
@@ -3253,7 +3253,7 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
                 // are by-ref types.
                 assert(struct_type.layout == .@"packed");
                 var buf: [8]u8 = .{0} ** 8; // zero the buffer so we do not read 0xaa as integer
-                val.writeToPackedMemory(ty, pt, &buf, 0) catch unreachable;
+                val.writeToPackedMemory(pt, &buf, 0) catch unreachable;
                 const backing_int_ty = Type.fromInterned(struct_type.backingIntTypeUnordered(ip));
                 const int_val = try pt.intValue(
                     backing_int_ty,
@@ -3267,7 +3267,7 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             const int_type = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
 
             var buf: [8]u8 = .{0} ** 8; // zero the buffer so we do not read 0xaa as integer
-            val.writeToPackedMemory(ty, pt, &buf, 0) catch unreachable;
+            val.writeToPackedMemory(pt, &buf, 0) catch unreachable;
             const int_val = try pt.intValue(
                 int_type,
                 mem.readInt(u64, &buf, .little),
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index a9898398d7318fc1cf6046fac752c998ae3a5282..2a7558505b3c4b1bedad6466d7c15452534c78c1 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -177294,41 +177294,38 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
     }
 
     const ip = &zcu.intern_pool;
-    const aggregate = ip.indexToKey(unwrapped_asm.clobbers).aggregate;
-    const struct_type: Type = .fromInterned(aggregate.ty);
-    switch (aggregate.storage) {
-        .elems => |elems| for (elems, 0..) |elem, i| switch (elem) {
-            .bool_true => {
-                const clobber = struct_type.structFieldName(i, zcu).toSlice(ip).?;
-                assert(clobber.len != 0);
+    const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+    const clobbers_ty = clobbers_val.typeOf(zcu);
+    var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+    const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
+    for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
+        assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
+        const limb_bits = @bitSizeOf(std.math.big.Limb);
+        if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
+        switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
+            0 => continue, // field is false
+            1 => {}, // field is true
+        }
+        const clobber = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
+        assert(clobber.len != 0);
 
-                if (std.mem.eql(u8, clobber, "memory") or
-                    std.mem.eql(u8, clobber, "fpsr") or
-                    std.mem.eql(u8, clobber, "fpcr") or
-                    std.mem.eql(u8, clobber, "mxcsr") or
-                    std.mem.eql(u8, clobber, "dirflag"))
-                {
-                    // ok, sure
-                } else if (std.mem.eql(u8, clobber, "cc") or
-                    std.mem.eql(u8, clobber, "flags") or
-                    std.mem.eql(u8, clobber, "eflags") or
-                    std.mem.eql(u8, clobber, "rflags"))
-                {
-                    try self.spillEflagsIfOccupied();
-                } else {
-                    try self.register_manager.getReg(parseRegName(clobber) orelse
-                        return self.fail("invalid clobber: '{s}'", .{clobber}), null);
-                }
-            },
-            .bool_false => continue,
-            else => unreachable,
-        },
-        .repeated_elem => |elem| switch (elem) {
-            .bool_true => @panic("TODO"),
-            .bool_false => {},
-            else => unreachable,
-        },
-        .bytes => @panic("TODO"),
+        if (std.mem.eql(u8, clobber, "memory") or
+            std.mem.eql(u8, clobber, "fpsr") or
+            std.mem.eql(u8, clobber, "fpcr") or
+            std.mem.eql(u8, clobber, "mxcsr") or
+            std.mem.eql(u8, clobber, "dirflag"))
+        {
+            // ok, sure
+        } else if (std.mem.eql(u8, clobber, "cc") or
+            std.mem.eql(u8, clobber, "flags") or
+            std.mem.eql(u8, clobber, "eflags") or
+            std.mem.eql(u8, clobber, "rflags"))
+        {
+            try self.spillEflagsIfOccupied();
+        } else {
+            try self.register_manager.getReg(parseRegName(clobber) orelse
+                return self.fail("invalid clobber: '{s}'", .{clobber}), null);
+        }
     }
 
     const Label = struct {
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index f77518d4655514850cdaab6dfc3cde9ee76a7d4a..027d5391a56231bc342f6cfe7e8d55a5a08379fa 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -3378,6 +3378,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         => .decl_const,
         .variable => .decl_var,
         .@"extern" => unreachable,
@@ -4014,6 +4015,7 @@ fn updateLazyType(
         .opt,
         .aggregate,
         .un,
+        .bitpack,
         // memoization, not types
         .memoized_call,
         => unreachable,
@@ -4092,6 +4094,15 @@ fn updateLazyValue(
             }, .fromInterned(int.ty), Value.fromInterned(value_index).toBigInt(&big_int_space, zcu));
             try wip_nav.refType(.fromInterned(int.ty));
         },
+        .bitpack => |bitpack| {
+            const backing_int_val: Value = .fromInterned(bitpack.backing_int_val);
+            try wip_nav.bigIntConstValue(.{
+                .sdata = .sdata_comptime_value,
+                .udata = .udata_comptime_value,
+                .block = .block_comptime_value,
+            }, backing_int_val.typeOf(zcu), backing_int_val.toBigInt(&big_int_space, zcu));
+            try wip_nav.refType(.fromInterned(bitpack.ty));
+        },
         .err => |err| {
             try wip_nav.abbrevCode(.udata_comptime_value);
             try wip_nav.refType(.fromInterned(err.ty));
diff --git a/src/mutable_value.zig b/src/mutable_value.zig
index 97d6f22b3b90e5d9215ec011760ee6feb9c0d3f1..8ddd434837ea2d1036229757d8ec20c3df5a45e5 100644
--- a/src/mutable_value.zig
+++ b/src/mutable_value.zig
@@ -97,8 +97,8 @@ pub const MutableValue = union(enum) {
     /// * Non-error error unions use `eu_payload`
     /// * Non-null optionals use `eu_payload
     /// * Slices use `slice`
-    /// * Unions use `un`
-    /// * Aggregates use `repeated` or `bytes` or `aggregate`
+    /// * Unions use `un` (excluding packed unions)
+    /// * Aggregates use `repeated` or `bytes` or `aggregate` (excluding packed structs)
     /// If `!allow_bytes`, the `bytes` representation will not be used.
     /// If `!allow_repeated`, the `repeated` representation will not be used.
     pub fn unintern(
@@ -209,6 +209,7 @@ pub const MutableValue = union(enum) {
                 .undef => |ty_ip| switch (Type.fromInterned(ty_ip).zigTypeTag(zcu)) {
                     .@"struct", .array, .vector => |type_tag| {
                         const ty = Type.fromInterned(ty_ip);
+                        if (type_tag == .@"struct" and ty.containerLayout(zcu) == .@"packed") return;
                         const opt_sent = ty.sentinel(zcu);
                         if (type_tag == .@"struct" or opt_sent != null or !allow_repeated) {
                             const len_no_sent = ip.aggregateTypeLen(ty_ip);
@@ -241,15 +242,18 @@ pub const MutableValue = union(enum) {
                             } };
                         }
                     },
-                    .@"union" => {
-                        const payload = try arena.create(MutableValue);
-                        const backing_ty = try Type.fromInterned(ty_ip).unionBackingType(pt);
-                        payload.* = .{ .interned = try pt.intern(.{ .undef = backing_ty.toIntern() }) };
-                        mv.* = .{ .un = .{
-                            .ty = ty_ip,
-                            .tag = .none,
-                            .payload = payload,
-                        } };
+                    .@"union" => switch (Type.fromInterned(ty_ip).containerLayout(zcu)) {
+                        .auto, .@"packed" => {},
+                        .@"extern" => {
+                            const payload = try arena.create(MutableValue);
+                            const backing_ty = try Type.fromInterned(ty_ip).externUnionBackingType(pt);
+                            payload.* = .{ .interned = try pt.intern(.{ .undef = backing_ty.toIntern() }) };
+                            mv.* = .{ .un = .{
+                                .ty = ty_ip,
+                                .tag = .none,
+                                .payload = payload,
+                            } };
+                        },
                     },
                     .pointer => {
                         const ptr_ty = ip.indexToKey(ty_ip).ptr_type;
diff --git a/src/print_value.zig b/src/print_value.zig
index 5b29bb04d68d3bf380601e2bed30e2cbe4912e86..d472472481350ff57a47ed3277c6a54cc161d374 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -164,7 +164,7 @@ pub fn print(
                 return;
             }
             if (un.tag == .none) {
-                const backing_ty = try val.typeOf(zcu).unionBackingType(pt);
+                const backing_ty = try val.typeOf(zcu).externUnionBackingType(pt);
                 try writer.print("@bitCast(@as({f}, ", .{backing_ty.fmt(pt)});
                 try print(Value.fromInterned(un.val), writer, level - 1, pt, opt_sema);
                 try writer.writeAll("))");
@@ -176,6 +176,32 @@ pub fn print(
                 try writer.writeAll(" }");
             }
         },
+        .bitpack => |bitpack| {
+            const ty: Type = .fromInterned(bitpack.ty);
+            switch (ty.zigTypeTag(zcu)) {
+                .@"struct" => {
+                    if (ty.structFieldCount(zcu) == 0) {
+                        return writer.writeAll(".{}");
+                    }
+                    try writer.writeAll(".{ ");
+                    const max_len = @min(ty.structFieldCount(zcu), max_aggregate_items);
+                    for (0..max_len) |i| {
+                        if (i != 0) try writer.writeAll(", ");
+                        const field_name = ty.structFieldName(@intCast(i), zcu).unwrap().?;
+                        try writer.print(".{f} = ", .{field_name.fmt(ip)});
+                        try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
+                    }
+                    try writer.writeAll(" }");
+                    return;
+                },
+                .@"union" => {
+                    try writer.print("@bitCast(@as({f}, ", .{ty.bitpackBackingInt(zcu).fmt(pt)});
+                    try print(.fromInterned(bitpack.backing_int_val), writer, level - 1, pt, opt_sema);
+                    try writer.writeAll("))");
+                },
+                else => unreachable,
+            }
+        },
         .memoized_call => unreachable,
     }
 }
-- 
2.54.0


From 187fef209f73336163337474dc02f46c7c89ac3a Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 29 Jan 2026 08:54:59 +0000
Subject: [PATCH 423/499] compiler: rework OPV and noreturn-like types

---
 src/Air/Liveness.zig           |   2 +-
 src/Air/Liveness/Verify.zig    |   2 +-
 src/InternPool.zig             | 169 ++----
 src/Sema.zig                   | 438 +++++++---------
 src/Sema/bitcast.zig           |   2 -
 src/Sema/type_resolution.zig   | 122 +++--
 src/Type.zig                   | 917 ++++++++++++++++-----------------
 src/Value.zig                  |   7 +-
 src/Zcu/PerThread.zig          |   9 +-
 src/codegen.zig                |   2 -
 src/codegen/aarch64/Select.zig |   8 +-
 src/codegen/c.zig              |  28 +-
 src/codegen/c/Type.zig         |  14 +-
 src/codegen/llvm.zig           |   3 -
 src/codegen/spirv/CodeGen.zig  |   6 +-
 src/codegen/wasm/CodeGen.zig   |  12 +-
 src/codegen/x86_64/CodeGen.zig |   2 +-
 src/link/Dwarf.zig             |  41 +-
 src/print_value.zig            |   2 -
 19 files changed, 827 insertions(+), 959 deletions(-)

diff --git a/src/Air/Liveness.zig b/src/Air/Liveness.zig
index a85944c4678455126d04403e1c48486db9d6e860..5c98dc96fca8c54208556eff486475cede9513a6 100644
--- a/src/Air/Liveness.zig
+++ b/src/Air/Liveness.zig
@@ -999,7 +999,7 @@ fn analyzeInstBlock(
 
             // If the block is noreturn, block deaths not only aren't useful, they're impossible to
             // find: there could be more stuff alive after the block than before it!
-            if (!a.intern_pool.isNoReturn(ty.toIntern())) {
+            if (!ty.isNoReturn(a.zcu)) {
                 // The block kills the difference in the live sets
                 const block_scope = data.block_scopes.get(inst).?;
                 const num_deaths = data.live_set.count() - block_scope.live_set.count();
diff --git a/src/Air/Liveness/Verify.zig b/src/Air/Liveness/Verify.zig
index fc83574d070c018fc54ed095d4c67f0bf7698fb2..7f820e65981b1d4247b363c061269c8d893ce239 100644
--- a/src/Air/Liveness/Verify.zig
+++ b/src/Air/Liveness/Verify.zig
@@ -465,7 +465,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
 
                 for (block_liveness.deaths) |death| try self.verifyDeath(inst, death);
 
-                if (ip.isNoReturn(block_ty.toIntern())) {
+                if (block_ty.isNoReturn(self.zcu)) {
                     assert(!self.blocks.contains(inst));
                 } else {
                     var live = if (self.blocks.fetchRemove(inst)) |kv| kv.value else {
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 7028d690094d195183e3e33b991ddc2ce17572b1..31e37dd98e80f38e1141ce70d86940511cfe1914 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -17,6 +17,7 @@ const Hash = std.hash.Wyhash;
 const Zir = std.zig.Zir;
 
 const Zcu = @import("Zcu.zig");
+const TypeClass = @import("Type.zig").Class;
 
 /// One item per thread, indexed by `tid`, which is dense and unique per thread.
 locals: []Local,
@@ -2113,10 +2114,6 @@ pub const Key = union(enum) {
     enum_literal: NullTerminatedString,
     /// A specific enum tag, indicated by the integer tag value.
     enum_tag: EnumTag,
-    /// An empty enum or union. TODO: this value's existence is strange, because such a type in
-    /// reality has no values. See #15909.
-    /// Payload is the type for which we are an empty value.
-    empty_enum_value: Index,
     float: Float,
     ptr: Ptr,
     slice: Slice,
@@ -2722,7 +2719,6 @@ pub const Key = union(enum) {
             .err,
             .enum_literal,
             .enum_tag,
-            .empty_enum_value,
             .inferred_error_set_type,
             .un,
             => |x| Hash.hash(seed, asBytes(&x)),
@@ -3005,10 +3001,6 @@ pub const Key = union(enum) {
                 const b_info = b.enum_tag;
                 return std.meta.eql(a_info, b_info);
             },
-            .empty_enum_value => |a_info| {
-                const b_info = b.empty_enum_value;
-                return a_info == b_info;
-            },
             .bitpack => |a_info| {
                 const b_info = b.bitpack;
                 return a_info.ty == b_info.ty and a_info.backing_int_val == b_info.backing_int_val;
@@ -3294,10 +3286,8 @@ pub const Key = union(enum) {
             .enum_literal => .enum_literal_type,
 
             .undef => |x| x,
-            .empty_enum_value => |x| x,
 
             .simple_value => |s| switch (s) {
-                .undefined => .undefined_type,
                 .void => .void_type,
                 .null => .null_type,
                 .false, .true => .bool_type,
@@ -3356,10 +3346,7 @@ pub const LoadedStructType = struct {
     field_runtime_order: RuntimeOrder.Slice,
     field_offsets: Offsets,
     packed_backing_int_type: Index,
-    has_no_possible_value: bool,
-    has_one_possible_value: bool,
-    comptime_only: bool,
-    has_runtime_bits: bool,
+    class: TypeClass,
     size: u32,
     alignment: Alignment,
 
@@ -3535,19 +3522,21 @@ pub const LoadedUnionType = struct {
     // The remaining fields are only valid once the union's layout is resolved.
     field_types: Index.Slice,
     field_aligns: Alignment.Slice,
-    runtime_tag: RuntimeTag,
-    /// Even if `runtime_tag == .none`, this is populated with the union's "hypothetical" tag type.
+    tag_usage: TagUsage,
+    /// While `tag_usage` indicates whether the union should logically contain a tag, it may be
+    /// omitted if the union layout is resolved as OPV or NPV. This field is `true` iff there is an
+    /// actual runtime tag in the union layout.
+    has_runtime_tag: bool,
+    /// Even if `tag_usage == .none` and `has_runtime_tag == false`, this is still populated with
+    /// the union's "hypothetical" tag type.
     enum_tag_type: Index,
     packed_backing_int_type: Index,
-    has_no_possible_value: bool,
-    has_one_possible_value: bool,
-    comptime_only: bool,
-    has_runtime_bits: bool,
+    class: TypeClass,
     size: u32,
     padding: u32,
     alignment: Alignment,
 
-    pub const RuntimeTag = enum(u2) {
+    pub const TagUsage = enum(u2) {
         none,
         safety,
         tagged,
@@ -3733,10 +3722,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .field_runtime_order = field_runtime_order,
                 .field_offsets = field_offsets,
                 .packed_backing_int_type = .none,
-                .has_no_possible_value = extra.data.flags.has_no_possible_value,
-                .has_one_possible_value = extra.data.flags.has_one_possible_value,
-                .comptime_only = extra.data.flags.comptime_only,
-                .has_runtime_bits = extra.data.flags.has_runtime_bits,
+                .class = extra.data.flags.class,
                 .size = extra.data.size,
                 .alignment = extra.data.flags.alignment,
             };
@@ -3797,10 +3783,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
         .field_runtime_order = .empty,
         .field_offsets = .empty,
         .packed_backing_int_type = extra.data.backing_int_type,
-        .has_no_possible_value = undefined,
-        .has_one_possible_value = undefined,
-        .comptime_only = undefined,
-        .has_runtime_bits = undefined,
+        .class = undefined,
         .size = undefined,
         .alignment = undefined,
     };
@@ -3865,7 +3848,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
                     .auto => .auto,
                     .@"extern" => .@"extern",
                 },
-                .runtime_tag = extra.data.flags.runtime_tag,
+                .tag_usage = extra.data.flags.tag_usage,
                 .enum_tag_mode = extra.data.flags.enum_tag_mode,
                 .enum_tag_type = extra.data.enum_tag_type,
                 .packed_backing_mode = undefined,
@@ -3874,10 +3857,8 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
                 .want_layout = extra.data.flags.want_layout,
                 .field_types = field_types,
                 .field_aligns = field_aligns,
-                .has_no_possible_value = extra.data.flags.has_no_possible_value,
-                .has_one_possible_value = extra.data.flags.has_one_possible_value,
-                .comptime_only = extra.data.flags.comptime_only,
-                .has_runtime_bits = extra.data.flags.has_runtime_bits,
+                .has_runtime_tag = extra.data.flags.has_runtime_tag,
+                .class = extra.data.flags.class,
                 .size = extra.data.size,
                 .padding = extra.data.padding,
                 .alignment = extra.data.flags.alignment,
@@ -3919,7 +3900,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
         .name_nav = extra.data.name_nav,
         .namespace = extra.data.namespace,
         .layout = .@"packed",
-        .runtime_tag = .none,
+        .tag_usage = .none,
         .enum_tag_mode = .auto,
         .enum_tag_type = extra.data.enum_tag_type,
         .packed_backing_mode = backing_mode,
@@ -3928,10 +3909,8 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
         .want_layout = extra.data.bits.want_layout,
         .field_types = field_types,
         .field_aligns = .empty,
-        .has_no_possible_value = undefined,
-        .has_one_possible_value = undefined,
-        .comptime_only = undefined,
-        .has_runtime_bits = undefined,
+        .has_runtime_tag = undefined,
+        .class = undefined,
         .size = undefined,
         .padding = undefined,
         .alignment = undefined,
@@ -4818,7 +4797,7 @@ pub const static_keys: [static_len]Key = .{
         .values = .empty,
     } },
 
-    .{ .simple_value = .undefined },
+    .{ .undef = .undefined_type },
     .{ .undef = .bool_type },
     .{ .undef = .usize_type },
     .{ .undef = .u1_type },
@@ -5682,23 +5661,14 @@ pub const Tag = enum(u8) {
             any_field_defaults: bool,
             any_field_aligns: bool,
 
-            /// Whether the struct is an OPV type. Always `false` until layout resolved.
-            /// The actual OPV is not cached, but caching this bit of state means we avoid
-            /// repeatedly doing redundant checks to find that the struct is not OPV!
-            has_one_possible_value: bool,
-            /// Like `has_one_possible_value`, but for a "noreturn" union (where all fields are noreturn).
-            has_no_possible_value: bool,
-            /// Whether the struct is comptime-only. Always `false` until layout resolved.
-            comptime_only: bool,
-            /// Whether the struct has runtime bits. Always `false` until layout resolved.
-            has_runtime_bits: bool,
+            class: TypeClass,
             /// Alignment of the whole struct. Always `.none` until layout resolved.
             alignment: Alignment,
 
             want_layout: bool,
             want_defaults: bool,
 
-            _: u14 = 0,
+            _: u15 = 0,
         };
     };
 
@@ -5778,18 +5748,11 @@ pub const Tag = enum(u8) {
             layout: enum(u1) { auto, @"extern" },
 
             any_field_aligns: bool,
-            runtime_tag: LoadedUnionType.RuntimeTag,
+            tag_usage: LoadedUnionType.TagUsage,
+
+            class: TypeClass,
+            has_runtime_tag: bool,
 
-            /// Whether the union is an OPV type. Always `false` until layout resolved.
-            /// The actual OPV is not cached, but caching this bit of state means we avoid
-            /// repeatedly doing redundant checks to find that the union is not OPV!
-            has_one_possible_value: bool,
-            /// Like `has_one_possible_value`, but for a "noreturn" union (where all fields are noreturn).
-            has_no_possible_value: bool,
-            /// Whether the union is comptime-only. Always `false` until layout resolved.
-            comptime_only: bool,
-            /// Whether the union has runtime bits. Always `false` until layout resolved.
-            has_runtime_bits: bool,
             /// Alignment of the whole union. Always `.none` until layout resolved.
             alignment: Alignment,
 
@@ -5970,8 +5933,6 @@ pub const SimpleType = enum(u32) {
 };
 
 pub const SimpleValue = enum(u32) {
-    /// This is untyped `undefined`.
-    undefined = @intFromEnum(Index.undef),
     void = @intFromEnum(Index.void_value),
     /// This is untyped `null`.
     null = @intFromEnum(Index.null_value),
@@ -7016,11 +6977,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                     } };
                 },
 
-                .type_enum_auto,
-                .type_enum_explicit,
-                .type_union,
-                => .{ .empty_enum_value = ty },
-
                 else => unreachable,
             };
         },
@@ -7914,11 +7870,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key:
             });
         },
 
-        .empty_enum_value => |enum_or_union_ty| items.appendAssumeCapacity(.{
-            .tag = .only_possible_value,
-            .data = @intFromEnum(enum_or_union_ty),
-        }),
-
         .float => |float| {
             switch (float.ty) {
                 .f16_type => items.appendAssumeCapacity(.{
@@ -8302,10 +8253,7 @@ pub fn getDeclaredStructType(
             .any_comptime_fields = ini.any_comptime_fields,
             .any_field_defaults = ini.any_field_defaults,
             .any_field_aligns = ini.any_field_aligns,
-            .has_one_possible_value = false,
-            .has_no_possible_value = false,
-            .comptime_only = false,
-            .has_runtime_bits = false,
+            .class = .no_possible_value,
             .alignment = .none,
             .want_layout = false,
             .want_defaults = false,
@@ -8456,10 +8404,7 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe
             .any_comptime_fields = ini.any_comptime_fields,
             .any_field_defaults = ini.any_field_defaults,
             .any_field_aligns = ini.any_field_aligns,
-            .has_one_possible_value = false,
-            .has_no_possible_value = false,
-            .comptime_only = false,
-            .has_runtime_bits = false,
+            .class = .no_possible_value,
             .alignment = .none,
             .want_layout = false,
             .want_defaults = false,
@@ -8535,7 +8480,7 @@ pub fn getDeclaredUnionType(
         fields_len: u32,
         layout: std.builtin.Type.ContainerLayout,
         any_field_aligns: bool,
-        runtime_tag: LoadedUnionType.RuntimeTag,
+        tag_usage: LoadedUnionType.TagUsage,
         enum_tag_mode: BackingTypeMode,
         packed_backing_mode: BackingTypeMode,
     },
@@ -8617,11 +8562,9 @@ pub fn getDeclaredUnionType(
             .enum_tag_mode = ini.enum_tag_mode,
             .layout = if (is_extern) .@"extern" else .auto,
             .any_field_aligns = ini.any_field_aligns,
-            .runtime_tag = ini.runtime_tag,
-            .has_one_possible_value = false,
-            .has_no_possible_value = false,
-            .comptime_only = false,
-            .has_runtime_bits = false,
+            .tag_usage = ini.tag_usage,
+            .class = .no_possible_value,
+            .has_runtime_tag = false,
             .alignment = .none,
             .want_layout = false,
         },
@@ -8658,8 +8601,8 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per
     fields_len: u32,
     layout: std.builtin.Type.ContainerLayout,
     any_field_aligns: bool,
-    runtime_tag: LoadedUnionType.RuntimeTag,
-    /// Explicitly specified enum tag type. `.none` if `runtime_tag != .tagged`.
+    tag_usage: LoadedUnionType.TagUsage,
+    /// Explicitly specified enum tag type. `.none` if `tag_usage != .tagged`.
     enum_tag_type: Index,
     /// Explicitly specified backing int type. `.none` if not packed or if backing type is inferred.
     packed_backing_int_type: Index,
@@ -8745,11 +8688,9 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per
             .enum_tag_mode = if (ini.enum_tag_type == .none) .auto else .explicit,
             .layout = if (is_extern) .@"extern" else .auto,
             .any_field_aligns = ini.any_field_aligns,
-            .runtime_tag = ini.runtime_tag,
-            .has_one_possible_value = false,
-            .has_no_possible_value = false,
-            .comptime_only = false,
-            .has_runtime_bits = false,
+            .tag_usage = ini.tag_usage,
+            .class = .no_possible_value,
+            .has_runtime_tag = false,
             .alignment = .none,
             .want_layout = false,
         },
@@ -12007,20 +11948,6 @@ pub fn funcTypeReturnType(ip: *const InternPool, ty: Index) Index {
     ]);
 }
 
-pub fn isNoReturn(ip: *const InternPool, ty: Index) bool {
-    switch (ty) {
-        .noreturn_type => return true,
-        else => {
-            const unwrapped_ty = ty.unwrap(ip);
-            const ty_item = unwrapped_ty.getItem(ip);
-            return switch (ty_item.tag) {
-                .type_error_set => unwrapped_ty.getExtra(ip).view().items(.@"0")[ty_item.data + std.meta.fieldIndex(Tag.ErrorSet, "names_len").?] == 0,
-                else => false,
-            };
-        },
-    }
-}
-
 pub fn isUndef(ip: *const InternPool, val: Index) bool {
     return val == .undef or val.unwrap(ip).getTag(ip) == .undef;
 }
@@ -12823,10 +12750,7 @@ pub fn resolveStructLayout(
     struct_type: Index,
     size: u32,
     alignment: Alignment,
-    has_no_possible_value: bool,
-    has_one_possible_value: bool,
-    comptime_only: bool,
-    has_runtime_bits: bool,
+    class: TypeClass,
 ) void {
     const unwrapped_index = struct_type.unwrap(ip);
 
@@ -12840,10 +12764,7 @@ pub fn resolveStructLayout(
 
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "size").?] = size;
     const flags: *Tag.TypeStruct.Flags = @ptrCast(&extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?]);
-    flags.has_no_possible_value = has_no_possible_value;
-    flags.has_one_possible_value = has_one_possible_value;
-    flags.comptime_only = comptime_only;
-    flags.has_runtime_bits = has_runtime_bits;
+    flags.class = class;
     flags.alignment = alignment;
 }
 
@@ -12856,13 +12777,11 @@ pub fn resolveUnionLayout(
     io: Io,
     union_type: Index,
     enum_tag_type: Index,
+    class: TypeClass,
+    has_runtime_tag: bool,
     size: u32,
     padding: u32,
     alignment: Alignment,
-    has_no_possible_value: bool,
-    has_one_possible_value: bool,
-    comptime_only: bool,
-    has_runtime_bits: bool,
 ) void {
     const unwrapped_index = union_type.unwrap(ip);
 
@@ -12878,10 +12797,8 @@ pub fn resolveUnionLayout(
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "size").?] = size;
     extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "padding").?] = padding;
     const flags: *Tag.TypeUnion.Flags = @ptrCast(&extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "flags").?]);
-    flags.has_no_possible_value = has_no_possible_value;
-    flags.has_one_possible_value = has_one_possible_value;
-    flags.comptime_only = comptime_only;
-    flags.has_runtime_bits = has_runtime_bits;
+    flags.class = class;
+    flags.has_runtime_tag = has_runtime_tag;
     flags.alignment = alignment;
 }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 60f04974372927d734327b71cef6118d53bc0797..cd6625fdaba233ed72cdbd31b9d79617dd40267d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -178,8 +178,11 @@ const ComptimeAlloc = struct {
 fn newComptimeAlloc(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type, alignment: Alignment) !ComptimeAllocIndex {
     const pt = sema.pt;
 
-    // Explicit guard because this call mutates the InternPool so cannot be optimized out.
-    if (std.debug.runtime_safety) assert(ty.onePossibleValue(pt) catch @panic("") == null);
+    switch (ty.classify(pt.zcu)) {
+        .no_possible_value => unreachable,
+        .one_possible_value => unreachable,
+        else => {},
+    }
 
     const idx = sema.comptime_allocs.items.len;
     try sema.comptime_allocs.append(sema.gpa, .{
@@ -1991,31 +1994,28 @@ fn analyzeBodyInner(
                 break :blk .void_value;
             },
         };
-        if (sema.isNoReturn(air_ref)) {
-            // We're going to assume that the body itself is noreturn, so let's ensure that now
-            assert(block.instructions.items.len > 0);
-            assert(sema.isNoReturn(block.instructions.items[block.instructions.items.len - 1].toRef()));
-            break;
-        }
 
+        const is_inferred_alloc = if (air_ref.toIndex()) |air_inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(air_inst)]) {
+            .inferred_alloc, .inferred_alloc_comptime => true,
+            else => false,
+        } else false;
         // We must resolve the layout of a type before creating a value of that type. Therefore,
-        // the layout of the type of `air_ref` must already be resolved.
-        check_type: {
-            if (air_ref.toIndex()) |air_inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(air_inst)]) {
-                .inferred_alloc, .inferred_alloc_comptime => break :check_type,
-                else => {},
-            };
-            sema.typeOf(air_ref).assertHasLayout(zcu);
-            // If the type has an OPV, `air_ref` must be that OPV: there is no other interned value
-            // it could be, and it would be a bug for the value to not be comptime-known when it has
-            // an OPV. Behind a `std.debug.runtime_safety` check because `onePossibleValue` mutates
-            // the InternPool so cannot be optimized out.
-            if (std.debug.runtime_safety) {
-                if (try sema.typeOf(air_ref).onePossibleValue(pt)) |opv| {
-                    assert(air_ref == Air.Inst.Ref.fromValue(opv));
-                }
-            }
-        }
+        // the layout of the type of `air_ref` must already be resolved. The call to `classify`
+        // doubles as an assertion of this.
+        if (!is_inferred_alloc) switch (sema.typeOf(air_ref).classify(zcu)) {
+            .no_possible_value => {
+                // The instruction result was noreturn, which should mean that the body itself now
+                // ends with a noreturn instruction. Let's confirm that.
+                const last_inst = block.instructions.items[block.instructions.items.len - 1];
+                const last_inst_ty = sema.typeOf(last_inst.toRef());
+                assert(last_inst_ty.classify(zcu) == .no_possible_value);
+                break;
+            },
+            .one_possible_value => assert(air_ref.toInterned() != null), // the value should be comptime-known
+            .partially_comptime => assert(air_ref.toInterned() != null), // the value should be comptime-known
+            .fully_comptime => assert(air_ref.toInterned() != null), // the value should be comptime-known
+            .runtime => {},
+        };
 
         map.putAssumeCapacity(inst, air_ref);
         i += 1;
@@ -2287,11 +2287,12 @@ fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) ?Value {
             .inferred_alloc_comptime => unreachable, // assertion failure
             else => {},
         }
-        // Assert that the type is not OPV -- if it was, the value would have been comptime-known.
-        // Explicit guard because this could add to the InternPool so cannot be optimized away.
-        if (std.debug.runtime_safety) {
-            const opv = sema.typeOf(inst).onePossibleValue(sema.pt) catch @panic("oom in assert");
-            assert(opv == null);
+        switch (sema.typeOf(inst).classify(zcu)) {
+            .no_possible_value => unreachable, // values of this type do not exist
+            .one_possible_value => unreachable, // the value should be comptime-known
+            .partially_comptime => unreachable, // the value should be comptime-known
+            .fully_comptime => unreachable, // the value should be comptime-known
+            .runtime => {},
         }
         return null;
     }
@@ -4645,16 +4646,21 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const elem_ty = operand_ty.childType(zcu);
     try sema.ensureLayoutResolved(elem_ty, src);
 
-    if (try elem_ty.onePossibleValue(pt) != null) {
-        // No need to validate the actual pointer value, we don't need it!
-        return;
-    }
+    const need_comptime = switch (elem_ty.classify(zcu)) {
+        .no_possible_value => return sema.fail(block, src, "cannot load {s} type '{f}'", .{
+            if (elem_ty.zigTypeTag(zcu) == .@"opaque") "opaque" else "uninstantiable",
+            elem_ty.fmt(pt),
+        }),
+        .one_possible_value => return, // no need to validate the actual pointer value!
+        .runtime => false,
+        .partially_comptime, .fully_comptime => true,
+    };
 
     if (sema.resolveValue(operand)) |val| {
         if (val.isUndef(zcu)) {
             return sema.fail(block, src, "cannot dereference undefined value", .{});
         }
-    } else if (elem_ty.comptimeOnly(zcu)) {
+    } else if (need_comptime) {
         const msg = msg: {
             const msg = try sema.errMsg(
                 src,
@@ -4870,7 +4876,7 @@ fn storeToInferredAllocComptime(
             .is_const = iac.is_const,
         },
     });
-    if (try operand_ty.onePossibleValue(pt) != null or
+    if (operand_ty.classify(zcu) == .one_possible_value or
         (iac.is_const and !operand_val.canMutateComptimeVarState(zcu)))
     {
         iac.ptr = try pt.intern(.{ .ptr = .{
@@ -6672,7 +6678,7 @@ const CallArgsInfo = union(enum) {
                     return sema.failWithNeededComptime(block, cai.argSrc(block, arg_index), null);
                 }
 
-                if (sema.typeOf(uncoerced_arg).zigTypeTag(zcu) == .noreturn) {
+                if (sema.typeOf(uncoerced_arg).classify(zcu) == .no_possible_value) {
                     // This terminates resolution of arguments. The caller should
                     // propagate this.
                     return uncoerced_arg;
@@ -6928,7 +6934,7 @@ fn analyzeCall(
 
         arg.* = try args_info.analyzeArg(sema, block, arg_idx, param_ty, func_ty_info, callee, maybe_func_inst);
         const arg_ty = sema.typeOf(arg.*);
-        if (arg_ty.zigTypeTag(zcu) == .noreturn) {
+        if (arg_ty.classify(zcu) == .no_possible_value) {
             return arg.*; // terminate analysis here
         }
 
@@ -7183,7 +7189,7 @@ fn analyzeCall(
             return sema.handleTailCall(block, call_src, runtime_func_ty, maybe_opv);
         }
 
-        if (ip.isNoReturn(resolved_ret_ty.toIntern())) {
+        if (resolved_ret_ty.isNoReturn(zcu)) {
             const want_check = c: {
                 if (!block.wantSafety()) break :c false;
                 if (func_val != null) break :c false;
@@ -7989,16 +7995,16 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const enum_tag: Air.Inst.Ref = switch (operand_ty.zigTypeTag(zcu)) {
         .@"enum" => operand,
         .@"union" => blk: {
-            const tag_ty = operand_ty.unionTagType(zcu) orelse {
+            if (operand_ty.unionTagType(zcu) == null) {
                 return sema.fail(
                     block,
                     operand_src,
                     "untagged union '{f}' cannot be converted to integer",
                     .{operand_ty.fmt(pt)},
                 );
-            };
+            }
 
-            break :blk try sema.unionToTag(block, tag_ty, operand, operand_src);
+            break :blk try sema.unionToTag(block, operand);
         },
         else => {
             return sema.fail(block, operand_src, "expected enum or tagged union, found '{f}'", .{
@@ -10151,9 +10157,8 @@ fn analyzeSwitchBlock(
         const maybe_operand_opv = try operand_ty.onePossibleValue(pt);
         const init_cond: Air.Inst.Ref, const item_ty: Type = switch (operand_ty.zigTypeTag(zcu)) {
             .@"union" => tag: {
-                const tag_ty = operand_ty.unionTagType(zcu).?;
-                const tag_val = try sema.unionToTag(block, tag_ty, val, operand_src);
-                break :tag .{ tag_val, tag_ty };
+                const tag_val = try sema.unionToTag(block, val);
+                break :tag .{ tag_val, sema.typeOf(tag_val) };
             },
             else => .{
                 if (maybe_operand_opv) |operand_opv| .fromValue(operand_opv) else val,
@@ -10245,7 +10250,7 @@ fn analyzeSwitchBlock(
                         .{ new_operand, .none };
 
                     const new_cond_ref = if (union_originally)
-                        try sema.unionToTag(child_block, item_ty, new_val, src)
+                        try sema.unionToTag(child_block, new_val)
                     else
                         new_val;
 
@@ -12147,8 +12152,7 @@ fn analyzeSwitchTagCapture(
         .item_refs => |refs| if (refs.len == 1) return refs[0],
         .special => {},
     }
-    const tag_ty = operand_ty.unionTagType(zcu).?;
-    return sema.unionToTag(case_block, tag_ty, operand_val, tag_capture_src);
+    return sema.unionToTag(case_block, operand_val);
 }
 
 fn analyzeSwitchPayloadCapture(
@@ -15389,9 +15393,12 @@ fn analyzePtrArithmetic(
     const elem_ty: Type = .fromInterned(ptr_info.child);
     elem_ty.assertHasLayout(zcu);
 
-    if (elem_ty.abiSize(zcu) == 0) {
-        // Offset will be multiplied by zero, so result is the same as the base pointer.
-        return ptr;
+    switch (elem_ty.classify(zcu)) {
+        .no_possible_value, .one_possible_value => {
+            // Offset will be multiplied by zero, so result is the same as the base pointer.
+            return ptr;
+        },
+        else => {},
     }
 
     const new_ptr_ty = t: {
@@ -15757,7 +15764,7 @@ fn analyzeCmpUnionTag(
     if (sema.resolveValue(coerced_tag)) |enum_val| {
         if (enum_val.isUndef(zcu)) return .undef_bool;
         const field_ty = union_ty.unionFieldType(enum_val, zcu).?;
-        if (field_ty.zigTypeTag(zcu) == .noreturn) {
+        if (field_ty.classify(zcu) == .no_possible_value) {
             return .bool_false;
         }
     }
@@ -15934,39 +15941,22 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
-    switch (ty.zigTypeTag(zcu)) {
-        .@"fn",
-        .noreturn,
-        .undefined,
-        .null,
-        .@"opaque",
-        => return sema.fail(block, operand_src, "no size available for type '{f}'", .{ty.fmt(pt)}),
-
-        .type,
-        .enum_literal,
-        .comptime_float,
-        .comptime_int,
-        .void,
-        => return .zero,
-
-        .bool,
-        .int,
-        .float,
-        .pointer,
-        .array,
-        .@"struct",
-        .optional,
-        .error_union,
-        .error_set,
-        .@"enum",
-        .@"union",
-        .vector,
-        .frame,
-        .@"anyframe",
-        => {},
-    }
     try sema.ensureLayoutResolved(ty, operand_src);
-    return .fromValue(try pt.intValue(.comptime_int, ty.abiSize(zcu)));
+    switch (ty.classify(zcu)) {
+        .no_possible_value,
+        => return sema.fail(block, operand_src, "no size available for uninstantiable type '{f}'", .{ty.fmt(pt)}),
+
+        .partially_comptime,
+        .fully_comptime,
+        => return sema.fail(block, operand_src, "no size available for comptime-only type '{f}'", .{ty.fmt(pt)}),
+
+        .one_possible_value => {
+            assert(ty.abiSize(zcu) == 0);
+            return .zero;
+        },
+
+        .runtime => return .fromValue(try pt.intValue(.comptime_int, ty.abiSize(zcu))),
+    }
 }
 
 fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -18631,9 +18621,9 @@ fn zirStructInit(
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
         const field_ty: Type = .fromInterned(zcu.typeToUnion(resolved_ty).?.field_types.get(ip)[field_index]);
 
-        if (field_ty.zigTypeTag(zcu) == .noreturn) {
+        if (field_ty.classify(zcu) == .no_possible_value) {
             return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(src, "cannot initialize 'noreturn' field of union", .{});
+                const msg = try sema.errMsg(src, "cannot initialize union field with uninstantiable type '{f}'", .{field_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
 
                 try sema.addFieldErrNote(resolved_ty, field_index, msg, "field '{f}' declared here", .{
@@ -18648,7 +18638,13 @@ fn zirStructInit(
         const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);
 
         if (resolved_ty.containerLayout(zcu) == .@"packed") {
-            return sema.bitCast(block, resolved_ty, init_inst, src, field_src);
+            const union_val = try sema.bitCast(block, resolved_ty, init_inst, src, field_src);
+            const result_val = try sema.coerce(block, result_ty, union_val, src);
+            if (is_ref) {
+                return sema.analyzeRef(block, src, result_val);
+            } else {
+                return result_val;
+            }
         }
 
         if (sema.resolveValue(init_inst)) |val| {
@@ -18681,9 +18677,6 @@ fn zirStructInit(
             const base_ptr = try sema.optEuBasePtrInit(block, alloc, src);
             const field_ptr = try sema.unionFieldPtr(block, field_src, base_ptr, field_name, field_src, resolved_ty, true);
             try sema.storePtr(block, src, field_ptr, init_inst);
-            if (try tag_ty.onePossibleValue(pt) == null) {
-                _ = try block.addBinOp(.set_union_tag, base_ptr, .fromValue(tag_val));
-            }
             return sema.makePtrConst(block, alloc);
         }
 
@@ -19451,10 +19444,10 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
+    try sema.ensureLayoutResolved(ty, operand_src);
     if (ty.isNoReturn(zcu)) {
         return sema.fail(block, operand_src, "no align available for type '{f}'", .{ty.fmt(sema.pt)});
     }
-    try sema.ensureLayoutResolved(ty, operand_src);
     return .fromValue(try pt.intValue(.comptime_int, ty.abiAlignment(zcu).toByteUnits().?));
 }
 
@@ -20447,10 +20440,10 @@ fn zirReifyUnion(
         .fields_len = @intCast(fields_len),
         .layout = layout,
         .any_field_aligns = any_field_aligns,
-        .runtime_tag = rt: {
-            if (explicit_tag_ty != null) break :rt .tagged;
-            if (layout == .auto and block.wantSafeTypes()) break :rt .safety;
-            break :rt .none;
+        .tag_usage = tag: {
+            if (explicit_tag_ty != null) break :tag .tagged;
+            if (layout == .auto and block.wantSafeTypes()) break :tag .safety;
+            break :tag .none;
         },
         .enum_tag_type = if (explicit_tag_ty) |ty| ty.toIntern() else .none,
         .packed_backing_int_type = if (explicit_packed_backing_type) |ty| ty.toIntern() else .none,
@@ -22608,7 +22601,7 @@ fn zirCmpxchg(
     const result_ty = try pt.optionalType(elem_ty.toIntern());
 
     // special case zero bit types
-    if (try elem_ty.onePossibleValue(pt) != null) {
+    if (elem_ty.classify(zcu) == .one_possible_value) {
         return .fromValue(try pt.nullValue(result_ty));
     }
 
@@ -25514,8 +25507,9 @@ fn fieldPtrLoad(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const object_ptr_ty = sema.typeOf(object_ptr);
+    assert(object_ptr_ty.zigTypeTag(zcu) == .pointer);
     const pointee_ty = object_ptr_ty.childType(zcu);
-    try sema.ensureLayoutResolved(pointee_ty, src); // MLUGG TODO
+    try sema.ensureLayoutResolved(pointee_ty, src);
     if (try pointee_ty.onePossibleValue(pt)) |opv| {
         const object: Air.Inst.Ref = .fromValue(opv);
         return fieldVal(sema, block, src, object, field_name, field_name_src);
@@ -26477,9 +26471,9 @@ fn unionFieldPtr(
     });
     const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_type).enumFieldIndex(field_name, zcu).?);
 
-    if (initializing and field_ty.zigTypeTag(zcu) == .noreturn) {
+    if (initializing and field_ty.classify(zcu) == .no_possible_value) {
         const msg = msg: {
-            const msg = try sema.errMsg(src, "cannot initialize 'noreturn' field of union", .{});
+            const msg = try sema.errMsg(src, "cannot initialize union field with uninstantiable type '{f}'", .{field_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 
             try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{
@@ -26529,30 +26523,29 @@ fn unionFieldPtr(
             },
             .@"packed", .@"extern" => {},
         }
-        const field_ptr_val = try union_ptr_val.ptrField(field_index, pt);
-        return Air.internedToRef(field_ptr_val.toIntern());
+        return .fromValue(try union_ptr_val.ptrField(field_index, pt));
     }
 
     // If the union has a tag, we must either set or or safety check it depending on `initializing`.
     tag: {
         if (union_ty.containerLayout(zcu) != .auto) break :tag;
         const tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
-        if (try tag_ty.onePossibleValue(pt) != null) break :tag;
+        if (tag_ty.classify(zcu) == .one_possible_value) break :tag;
         // There is a hypothetical non-trivial tag. We must set it even if not there at runtime, but
         // only emit a safety check if it's available at runtime (i.e. it's safety-tagged).
         const want_tag = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
         if (initializing) {
             const set_tag_inst = try block.addBinOp(.set_union_tag, union_ptr, .fromValue(want_tag));
             try sema.checkComptimeKnownStore(block, set_tag_inst, .unneeded); // `unneeded` since this isn't a "proper" store
-        } else if (block.wantSafety() and union_obj.runtime_tag != .none) {
-            // The tag exists at runtime (safety tag), so emit a safety check.
+        } else if (block.wantSafety() and union_obj.has_runtime_tag) {
+            // The tag exists at runtime (actual or safety tag), so emit a safety check.
             // TODO would it be better if get_union_tag supported pointers to unions?
             const union_val = try block.addTyOp(.load, union_ty, union_ptr);
             const active_tag = try block.addTyOp(.get_union_tag, tag_ty, union_val);
             try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, .fromValue(want_tag));
         }
     }
-    if (field_ty.zigTypeTag(zcu) == .noreturn) {
+    if (field_ty.classify(zcu) == .no_possible_value) {
         _ = try block.addNoOp(.unreach);
         return .unreachable_value;
     }
@@ -26578,57 +26571,40 @@ fn unionFieldVal(
     const union_obj = zcu.typeToUnion(union_ty).?;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_type).enumFieldIndex(field_name, zcu).?);
+    const enum_tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
 
     if (sema.resolveValue(union_byval)) |union_val| {
         if (union_val.isUndef(zcu)) return pt.undefRef(field_ty);
-
-        const un = ip.indexToKey(union_val.toIntern()).un;
-        const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
-        const tag_matches = un.tag == field_tag.toIntern();
         switch (union_obj.layout) {
             .auto => {
-                if (tag_matches) {
-                    return Air.internedToRef(un.val);
-                } else {
-                    const msg = msg: {
-                        const active_index = Type.fromInterned(union_obj.enum_tag_type).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
-                        const active_field_name = Type.fromInterned(union_obj.enum_tag_type).enumFieldName(active_index, zcu);
-                        const msg = try sema.errMsg(src, "access of union field '{f}' while field '{f}' is active", .{
-                            field_name.fmt(ip), active_field_name.fmt(ip),
-                        });
-                        errdefer msg.destroy(sema.gpa);
-                        try sema.addDeclaredHereNote(msg, union_ty);
-                        break :msg msg;
-                    };
-                    return sema.failWithOwnedErrorMsg(block, msg);
-                }
+                const active_tag_val = union_val.unionTag(zcu).?;
+                const active_index = enum_tag_ty.enumTagFieldIndex(active_tag_val, zcu).?;
+                if (active_index == field_index) return .fromValue(union_val.unionPayload(zcu));
+                return sema.fail(block, src, "access of union field '{f}' while field '{f}' is active", .{
+                    field_name.fmt(ip), enum_tag_ty.enumFieldName(active_index, zcu).fmt(ip),
+                });
             },
-            .@"extern" => if (tag_matches) {
-                // Fast path - no need to use bitcast logic.
-                return Air.internedToRef(un.val);
-            } else if (try sema.bitCastVal(union_val, field_ty, 0, 0, 0)) |field_val| {
-                return Air.internedToRef(field_val.toIntern());
+            .@"extern" => if (try sema.bitCastVal(union_val, field_ty, 0, 0, 0)) |field_val| {
+                return .fromValue(field_val);
+            } else {
+                // Runtime-known due to a pointer-to-integer conversion.
             },
-            .@"packed" => if (tag_matches) {
-                // Fast path - no need to use bitcast logic.
-                return Air.internedToRef(un.val);
-            } else if (try sema.bitCastVal(union_val, field_ty, 0, union_ty.bitSize(zcu), 0)) |field_val| {
-                return Air.internedToRef(field_val.toIntern());
+            .@"packed" => {
+                const field_val = try sema.bitCastVal(union_val, field_ty, 0, union_ty.bitSize(zcu), 0) orelse {
+                    unreachable; // `null` is only possible if the input value contains a pointer, which a packed union cannot.
+                };
+                return .fromValue(field_val);
             },
         }
     }
 
-    if (union_obj.layout == .auto and block.wantSafety() and
-        union_ty.unionTagTypeSafety(zcu) != null and union_obj.field_types.len > 1)
-    {
-        const wanted_tag_val = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
-        const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern());
-        const active_tag = try block.addTyOp(.get_union_tag, .fromInterned(union_obj.enum_tag_type), union_byval);
-        try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, wanted_tag);
+    if (union_obj.layout == .auto and block.wantSafety() and union_obj.has_runtime_tag) {
+        const wanted_tag_val = try pt.enumValueFieldIndex(enum_tag_ty, field_index);
+        const active_tag = try block.addTyOp(.get_union_tag, enum_tag_ty, union_byval);
+        try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, .fromValue(wanted_tag_val));
     }
 
-    if (field_ty.zigTypeTag(zcu) == .noreturn) {
+    if (field_ty.classify(zcu) == .no_possible_value) {
         _ = try block.addNoOp(.unreach);
         return .unreachable_value;
     }
@@ -27767,11 +27743,10 @@ fn coerceExtra(
                 };
                 return Air.internedToRef((try pt.enumValueFieldIndex(dest_ty, @intCast(field_index))).toIntern());
             },
-            .@"union" => blk: {
+            .@"union" => if (inst_ty.unionTagType(zcu)) |enum_tag_ty| {
                 // union to its own tag type
-                const union_tag_ty = inst_ty.unionTagType(zcu) orelse break :blk;
-                if (union_tag_ty.eql(dest_ty, zcu)) {
-                    return sema.unionToTag(block, dest_ty, inst, inst_src);
+                if (enum_tag_ty.toIntern() == dest_ty.toIntern()) {
+                    return sema.unionToTag(block, inst);
                 }
             },
             else => {},
@@ -27857,18 +27832,16 @@ fn coerceExtra(
         else => {},
     }
 
-    const can_coerce_to = switch (dest_ty.zigTypeTag(zcu)) {
-        .noreturn, .@"opaque" => false,
-        else => true,
+    const dest_is_npv = switch (dest_ty.classify(zcu)) {
+        .no_possible_value => true,
+        .one_possible_value => if (inst == .undef) {
+            return .fromValue((try dest_ty.onePossibleValue(pt)).?);
+        } else false,
+        .runtime, .fully_comptime, .partially_comptime => if (inst == .undef) {
+            return .fromValue(try pt.undefValue(dest_ty));
+        } else false,
     };
 
-    if (can_coerce_to and inst == .undef) {
-        // undefined to anything. We do this after the big switch above so that
-        // special logic has a chance to run first, such as `*[N]T` to `[]T` which
-        // should initialize the length field of the slice.
-        return .fromValue(try dest_ty.onePossibleValue(pt) orelse try pt.undefValue(dest_ty));
-    }
-
     if (!opts.report_err) return error.NotCoercible;
 
     if (opts.is_ret and dest_ty.zigTypeTag(zcu) == .noreturn) {
@@ -27890,8 +27863,8 @@ fn coerceExtra(
         const msg = try sema.typeMismatchErrMsg(inst_src, dest_ty, inst_ty);
         errdefer msg.destroy(sema.gpa);
 
-        if (!can_coerce_to) {
-            try sema.errNote(inst_src, msg, "cannot coerce to '{f}'", .{dest_ty.fmt(pt)});
+        if (dest_is_npv) {
+            try sema.errNote(inst_src, msg, "cannot coerce to uninstantiable type '{f}'", .{dest_ty.fmt(pt)});
         }
 
         // E!T to T
@@ -29099,6 +29072,13 @@ fn storePtr2(
     };
     const maybe_operand_val = sema.resolveValue(operand);
 
+    const comptime_only = switch (elem_ty.classify(zcu)) {
+        .no_possible_value => unreachable, // the coercion should have failed
+        .one_possible_value => return, // no actual store operation is necessary
+        .runtime => false,
+        .partially_comptime, .fully_comptime => true,
+    };
+
     const runtime_src = rs: {
         const ptr_val = try sema.resolveDefinedValue(block, ptr_src, ptr) orelse break :rs ptr_src;
         if (!sema.isComptimeMutablePtr(ptr_val)) break :rs ptr_src;
@@ -29106,16 +29086,9 @@ fn storePtr2(
         return sema.storePtrVal(block, src, ptr_val, operand_val, elem_ty);
     };
 
-    // We do this after the possible comptime store above, for the case of field_ptr stores
-    // to unions because we want the comptime tag to be set, even if the field type is void.
-    // MLUGG TODO: that's insane, the runtime and comptime sematics should be the same. just set the tag at the same damn time
-    if (try elem_ty.onePossibleValue(pt) != null) {
-        return;
-    }
-
     // We're performing the store at runtime; as such, we need to make sure the pointee type
     // is not comptime-only. We can hit this case with a `@ptrFromInt` pointer.
-    if (elem_ty.comptimeOnly(zcu)) {
+    if (comptime_only) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "cannot store comptime-only type '{f}' at runtime", .{elem_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
@@ -29477,7 +29450,7 @@ fn coerceEnumToUnion(
     const enum_ty: Type = .fromInterned(union_obj.enum_tag_type);
     const enum_obj = ip.loadEnumType(enum_ty.toIntern());
 
-    if (union_obj.runtime_tag != .tagged) return sema.failWithOwnedErrorMsg(block, msg: {
+    if (union_obj.tag_usage != .tagged) return sema.failWithOwnedErrorMsg(block, msg: {
         const msg = try sema.typeMismatchErrMsg(inst_src, union_ty, inst_ty);
         errdefer msg.destroy(sema.gpa);
         try sema.errNote(union_ty_src, msg, "cannot coerce enum to untagged union", .{});
@@ -29495,31 +29468,35 @@ fn coerceEnumToUnion(
 
         const field_name = enum_obj.field_names.get(ip)[field_index];
         const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-        if (field_ty.zigTypeTag(zcu) == .noreturn) {
-            const msg = msg: {
-                const msg = try sema.errMsg(inst_src, "cannot initialize 'noreturn' field of union", .{});
+        switch (field_ty.classify(zcu)) {
+            .one_possible_value => return .fromValue(try pt.unionValue(
+                union_ty,
+                val,
+                (try field_ty.onePossibleValue(pt)).?,
+            )),
+
+            .no_possible_value => return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(inst_src, "cannot initialize union field with uninstantiable type '{f}'", .{field_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
                 try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{
                     field_name.fmt(ip),
                 });
                 try sema.addDeclaredHereNote(msg, union_ty);
                 break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(block, msg);
+            }),
+
+            else => return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(inst_src, "coercion from enum '{f}' to union '{f}' must initialize '{f}' field '{f}'", .{
+                    inst_ty.fmt(pt),  union_ty.fmt(pt),
+                    field_ty.fmt(pt), field_name.fmt(ip),
+                });
+                errdefer msg.destroy(sema.gpa);
+
+                try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{field_name.fmt(ip)});
+                try sema.addDeclaredHereNote(msg, union_ty);
+                break :msg msg;
+            }),
         }
-        const opv = try field_ty.onePossibleValue(pt) orelse return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(inst_src, "coercion from enum '{f}' to union '{f}' must initialize '{f}' field '{f}'", .{
-                inst_ty.fmt(pt),  union_ty.fmt(pt),
-                field_ty.fmt(pt), field_name.fmt(ip),
-            });
-            errdefer msg.destroy(sema.gpa);
-
-            try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' declared here", .{field_name.fmt(ip)});
-            try sema.addDeclaredHereNote(msg, union_ty);
-            break :msg msg;
-        });
-
-        return Air.internedToRef((try pt.unionValue(union_ty, val, opv)).toIntern());
     }
 
     try sema.requireRuntimeBlock(block, inst_src, null);
@@ -29536,32 +29513,14 @@ fn coerceEnumToUnion(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
-    {
-        var msg: ?*Zcu.ErrorMsg = null;
-        errdefer if (msg) |some| some.destroy(sema.gpa);
-
-        for (union_obj.field_types.get(ip), 0..) |field_ty, field_index| {
-            if (Type.fromInterned(field_ty).zigTypeTag(zcu) == .noreturn) {
-                const err_msg = msg orelse try sema.errMsg(
-                    inst_src,
-                    "runtime coercion from enum '{f}' to union '{f}' which has a 'noreturn' field",
-                    .{ enum_ty.fmt(pt), union_ty.fmt(pt) },
-                );
-                msg = err_msg;
-
-                try sema.addFieldErrNote(union_ty, field_index, err_msg, "'noreturn' field here", .{});
-            }
-        }
-        if (msg) |some| {
-            msg = null;
-            try sema.addDeclaredHereNote(some, union_ty);
-            return sema.failWithOwnedErrorMsg(block, some);
-        }
-    }
-
-    // If the union has all fields 0 bits, the union value is just the enum value.
     if (union_ty.unionHasAllZeroBitFieldTypes(zcu)) {
-        return block.addBitCast(union_ty, enum_tag);
+        if (try union_ty.onePossibleValue(pt)) |opv| {
+            // The tag had redundant bits, but we've omitted the tag from the union's runtime layout, so the union is OPV and hence runtime-known.
+            return .fromValue(opv);
+        } else {
+            // The union layout is just the tag, so we can bitcast the enum straight to the union.
+            return block.addBitCast(union_ty, enum_tag);
+        }
     }
 
     const msg = msg: {
@@ -29575,9 +29534,15 @@ fn coerceEnumToUnion(
         for (0..union_obj.field_types.len) |field_index| {
             const field_name = enum_obj.field_names.get(ip)[field_index];
             const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-            if (try field_ty.onePossibleValue(pt) != null) continue;
-            try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' has type '{f}'", .{
+            const ty_description: []const u8 = switch (field_ty.classify(zcu)) {
+                .one_possible_value => continue,
+                .no_possible_value => "uninstantiable type",
+                else => "type",
+            };
+            if (field_ty.classify(zcu) == .one_possible_value) continue;
+            try sema.addFieldErrNote(union_ty, field_index, msg, "field '{f}' has {s} '{f}'", .{
                 field_name.fmt(ip),
+                ty_description,
                 field_ty.fmt(pt),
             });
         }
@@ -30345,7 +30310,7 @@ fn resolveIsNonErrFromType(
     assert(ot == .error_union);
 
     const payload_ty = operand_ty.errorUnionPayload(zcu);
-    if (payload_ty.zigTypeTag(zcu) == .noreturn) {
+    if (payload_ty.classify(zcu) == .no_possible_value) {
         return .false;
     }
 
@@ -31348,24 +31313,28 @@ fn wrapErrorUnionSet(
     }
 }
 
-fn unionToTag(
-    sema: *Sema,
-    block: *Block,
-    enum_ty: Type,
-    un: Air.Inst.Ref,
-    un_src: LazySrcLoc,
-) !Air.Inst.Ref {
+/// Returns the enum tag value for the active tag of a tagged union value.
+///
+/// Asserts that the type of `un` is a tagged union type.
+fn unionToTag(sema: *Sema, block: *Block, un: Air.Inst.Ref) !Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    if (try enum_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+    const ip = &zcu.intern_pool;
+    const union_obj = ip.loadUnionType(sema.typeOf(un).toIntern());
+    assert(union_obj.tag_usage == .tagged);
     if (sema.resolveValue(un)) |un_val| {
-        const tag_val = un_val.unionTag(zcu).?;
-        if (tag_val.isUndef(zcu))
-            return try pt.undefRef(enum_ty);
-        return Air.internedToRef(tag_val.toIntern());
+        return .fromValue(un_val.unionTag(zcu).?);
     }
-    try sema.requireRuntimeBlock(block, un_src, null);
-    return block.addTyOp(.get_union_tag, enum_ty, un);
+    const enum_tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
+    if (!union_obj.has_runtime_tag) {
+        // This means that only one field is possible.
+        const field_index = for (union_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
+            const field_ty: Type = .fromInterned(field_ty_ip);
+            if (field_ty.classify(zcu) != .no_possible_value) break field_index;
+        } else unreachable;
+        return .fromValue(try pt.enumValueFieldIndex(enum_tag_ty, @intCast(field_index)));
+    }
+    return block.addTyOp(.get_union_tag, enum_tag_ty, un);
 }
 
 const PeerResolveStrategy = enum {
@@ -33491,15 +33460,6 @@ fn isNoReturn(sema: *Sema, ref: Air.Inst.Ref) bool {
     return sema.typeOf(ref).isNoReturn(sema.pt.zcu);
 }
 
-/// Avoids crashing the compiler when asking if inferred allocations are known to be a certain zig type.
-fn isKnownZigType(sema: *Sema, ref: Air.Inst.Ref, tag: std.builtin.TypeId) bool {
-    if (ref.toIndex()) |inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(inst)]) {
-        .inferred_alloc, .inferred_alloc_comptime => return false,
-        else => {},
-    };
-    return sema.typeOf(ref).zigTypeTag(sema.pt.zcu) == tag;
-}
-
 pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {
     const pt = sema.pt;
     if (!pt.zcu.comp.config.incremental) return;
@@ -33744,7 +33704,6 @@ fn anyUndef(sema: *Sema, block: *Block, src: LazySrcLoc, val: Value) !bool {
     const zcu = pt.zcu;
     return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
         .undef => true,
-        .simple_value => |v| v == .undefined,
         .slice => {
             // If the slice contents are runtime-known, reification will fail later on with a
             // specific error message.
@@ -33898,7 +33857,6 @@ const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadR
 const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr;
 const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult;
 
-// MLUGG TODO: decide how to do the namespacing here
 pub const type_resolution = @import("Sema/type_resolution.zig");
 pub const ensureLayoutResolved = type_resolution.ensureLayoutResolved;
 pub const ensureStructDefaultsResolved = type_resolution.ensureStructDefaultsResolved;
@@ -34313,7 +34271,7 @@ fn zirUnionDecl(
         .fields_len = @intCast(union_decl.field_names.len),
         .layout = union_decl.kind.layout(),
         .any_field_aligns = union_decl.field_align_body_lens != null,
-        .runtime_tag = switch (union_decl.kind) {
+        .tag_usage = switch (union_decl.kind) {
             .auto => if (block.wantSafeTypes()) .safety else .none,
 
             .tagged_explicit,
diff --git a/src/Sema/bitcast.zig b/src/Sema/bitcast.zig
index f06528b6240f4766730353a6dc50d3b8e3c41607..43456c218ba08f987b444d35b8ef5dc8ad053cb7 100644
--- a/src/Sema/bitcast.zig
+++ b/src/Sema/bitcast.zig
@@ -267,7 +267,6 @@ const UnpackValueBits = struct {
             .int,
             .enum_tag,
             .simple_value,
-            .empty_enum_value,
             .float,
             .ptr,
             .opt,
@@ -453,7 +452,6 @@ const UnpackValueBits = struct {
             // The only values here with runtime bits are `true` and `false.
             // These are both 1 bit, so will never need truncating.
             .simple_value => unreachable,
-            .empty_enum_value => unreachable, // zero-bit
             else => unreachable, // zero-bit or not primitives
         }
     }
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 1096c9cbe7d31cbd32958c0dcdfde5eae03b56bf..50f0f7e3156921fa42cae5e80768d067e245b941 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -72,7 +72,6 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!vo
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -249,10 +248,10 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
     // Fields are okay. Now we need to resolve the struct's overall layout (size, field offsets, etc).
 
     var any_comptime_fields = false;
-    var comptime_only = false;
-    var one_possible_value = true;
-    var has_runtime_bits = false;
     var struct_align: Alignment = .@"1";
+    var has_no_possible_value = false;
+    var has_runtime_state = false;
+    var has_comptime_state = false;
     // Unlike `struct_obj.field_aligns`, these are not `.none`.
     const resolved_field_aligns = try sema.arena.alloc(Alignment, struct_obj.field_names.len);
     for (resolved_field_aligns, 0..) |*align_out, field_idx| {
@@ -264,22 +263,37 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
             }
             break :a field_ty.defaultStructFieldAlignment(struct_obj.layout, zcu);
         };
-        if (!struct_obj.field_is_comptime_bits.get(ip, field_idx)) {
-            // Non-`comptime` fields contribute to the struct's layout.
-            struct_align = struct_align.maxStrict(field_align);
-            if (field_ty.comptimeOnly(zcu)) comptime_only = true;
-            if (field_ty.hasRuntimeBits(zcu)) has_runtime_bits = true;
-            if (try field_ty.onePossibleValue(pt) == null) one_possible_value = false;
-            if (struct_obj.layout == .auto) {
-                struct_obj.field_runtime_order.get(ip)[field_idx] = @enumFromInt(field_idx);
-            }
-        } else {
+        align_out.* = field_align;
+        if (struct_obj.field_is_comptime_bits.get(ip, field_idx)) {
             assert(struct_obj.layout == .auto); // comptime fields not allowed in extern or packed structs
             struct_obj.field_runtime_order.get(ip)[field_idx] = .omitted; // comptime fields are not in the runtime order
             any_comptime_fields = true;
+            continue; // `comptime` fields do not contribute to the struct layout
+        }
+        struct_align = struct_align.maxStrict(field_align);
+        if (struct_obj.layout == .auto) {
+            struct_obj.field_runtime_order.get(ip)[field_idx] = @enumFromInt(field_idx);
+        }
+        switch (field_ty.classify(zcu)) {
+            .one_possible_value => {},
+            .no_possible_value => has_no_possible_value = true,
+            .runtime => has_runtime_state = true,
+            .fully_comptime => has_comptime_state = true,
+            .partially_comptime => {
+                has_runtime_state = true;
+                has_comptime_state = true;
+            },
         }
-        align_out.* = field_align;
     }
+    const class: Type.Class = class: {
+        if (has_no_possible_value) break :class .no_possible_value;
+        if (has_comptime_state) {
+            break :class if (has_runtime_state) .partially_comptime else .fully_comptime;
+        } else {
+            break :class if (has_runtime_state) .runtime else .one_possible_value;
+        }
+    };
+
     if (struct_obj.layout == .auto) {
         const runtime_order = struct_obj.field_runtime_order.get(ip);
         // This logic does not reorder fields; it only moves the omitted ones to the end so that logic
@@ -327,21 +341,21 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         struct_obj.field_offsets.get(ip)[field_idx] = @truncate(offset); // truncate because the overflow is handled below
         cur_offset = offset + field_ty.abiSize(zcu);
     }
-    const struct_size = std.math.cast(u32, struct_align.forward(cur_offset)) orelse return sema.fail(
-        &block,
-        struct_ty.srcLoc(zcu),
-        "struct layout requires size {d}, this compiler implementation supports up to {d}",
-        .{ struct_align.forward(cur_offset), std.math.maxInt(u32) },
-    );
+    const struct_size: u32 = switch (class) {
+        .no_possible_value => 0,
+        else => std.math.cast(u32, struct_align.forward(cur_offset)) orelse return sema.fail(
+            &block,
+            struct_ty.srcLoc(zcu),
+            "struct layout requires size {d}, this compiler implementation supports up to {d}",
+            .{ struct_align.forward(cur_offset), std.math.maxInt(u32) },
+        ),
+    };
     ip.resolveStructLayout(
         io,
         struct_ty.toIntern(),
         struct_size,
         struct_align,
-        false, // MLUGG TODO XXX NPV
-        one_possible_value,
-        comptime_only,
-        has_runtime_bits,
+        class,
     );
 
     if (any_comptime_fields and !struct_obj.is_reified) {
@@ -758,9 +772,8 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     // Fields are okay. Now we need to resolve the union's overall layout (size, alignment, etc).
     var payload_align: Alignment = .@"1";
     var payload_size: u64 = 0;
-    var comptime_only = false;
-    var has_runtime_bits = union_obj.runtime_tag != .none and enum_tag_ty.hasRuntimeBits(zcu);
-    var possible_values: enum { none, one, many } = .none;
+    var possible_tags: u32 = 0;
+    var payload_has_comptime_state = false;
     for (0..union_obj.field_types.len) |field_idx| {
         const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]);
         const field_align: Alignment = a: {
@@ -772,21 +785,41 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         };
         payload_align = payload_align.maxStrict(field_align);
         payload_size = @max(payload_size, field_ty.abiSize(zcu));
-        if (field_ty.comptimeOnly(zcu)) comptime_only = true;
-        if (field_ty.hasRuntimeBits(zcu)) has_runtime_bits = true;
-        if (!field_ty.isNoReturn(zcu)) {
-            if (try field_ty.onePossibleValue(pt) != null) {
-                possible_values = .many; // this field alone has many possible values
-            } else switch (possible_values) {
-                .none => possible_values = .one, // there were none, now there is this field's OPV
-                .one => possible_values = .many, // there was one, now there are two
-                .many => {},
-            }
+
+        switch (field_ty.classify(zcu)) {
+            .no_possible_value => {}, // uninstantiable field has no effect
+            .one_possible_value, .runtime => {
+                possible_tags += 1;
+            },
+            .partially_comptime, .fully_comptime => {
+                possible_tags += 1;
+                payload_has_comptime_state = true;
+            },
         }
     }
 
+    // We only need a runtime tag if there are multiple possible active fields *and* the union is
+    // not going to be comptime-only. Even if there are still runtime bits in the payload, the tag
+    // does not require runtime bits in a comptime-only union, because it is impossible to get a
+    // pointer to a union's tag.
+    const has_runtime_tag = switch (possible_tags) {
+        0, 1 => false,
+        else => union_obj.tag_usage != .none and !payload_has_comptime_state,
+    };
+
+    const class: Type.Class = class: {
+        if (possible_tags == 0) {
+            break :class .no_possible_value;
+        }
+        if (payload_has_comptime_state) {
+            break :class if (payload_size > 0) .partially_comptime else .fully_comptime;
+        }
+        const have_runtime_bits = has_runtime_tag or payload_size > 0;
+        break :class if (have_runtime_bits) .runtime else .one_possible_value;
+    };
+
     const size: u64, const padding: u64, const alignment: Alignment = layout: {
-        if (union_obj.runtime_tag == .none) {
+        if (!has_runtime_tag) {
             break :layout .{ payload_align.forward(payload_size), 0, payload_align };
         }
         const tag_align = enum_tag_ty.abiAlignment(zcu);
@@ -800,6 +833,11 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         break :layout .{ size, size - unpadded_size, alignment };
     };
 
+    if (class == .no_possible_value or class == .one_possible_value) {
+        assert(size == 0);
+        assert(padding == 0);
+    }
+
     const casted_size = std.math.cast(u32, size) orelse return sema.fail(
         &block,
         union_ty.srcLoc(zcu),
@@ -810,13 +848,11 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         io,
         union_ty.toIntern(),
         enum_tag_ty.toIntern(),
+        class,
+        has_runtime_tag,
         casted_size,
         @intCast(padding), // okay because padding is no greater than size
         alignment,
-        possible_values == .none, // MLUGG TODO: make sure queries use `LoadedUnionType.has_no_possible_value`!
-        possible_values == .one,
-        comptime_only,
-        has_runtime_bits,
     );
 }
 fn failUnionFieldMismatch(sema: *Sema, block: *Block, union_field_names: []const InternPool.NullTerminatedString, enum_tag_ty: Type, enum_obj: *const InternPool.LoadedEnumType) CompileError {
diff --git a/src/Type.zig b/src/Type.zig
index 9cca3d104320edfc2f0fbf63cc64a30d7256fa0b..8b1c71cc9631a8085c4b8908ce09d1c9d69a057b 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -23,6 +23,240 @@ pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.builtin.TypeId {
     return zcu.intern_pool.zigTypeTag(ty.toIntern());
 }
 
+/// Every type is a member of exactly one "class" which determines:
+/// * whether values of the type can exist at all
+/// * whether values of the type can be runtime-knwon
+/// * whether the type is considered comptime-only
+/// * whether the type has runtime bits (nonzero ABI size)
+pub const Class = enum(u3) {
+    /// Values of this type cannot exist because the type semantically has no values. Attempting to
+    /// create a value of this type (such as by coercing `undefined`) always emits a compile error.
+    ///
+    /// Not comptime-only. No runtime bits, i.e. ABI size is 0.
+    ///
+    /// Exhaustive list of no-possible-value ("NPV") types:
+    /// * `noreturn`
+    /// * `anyopaque`, and any `opaque` type
+    /// * `[n]T` where `n` is non-zero and `T` is NPV
+    /// * Any tuple where at least one non-`comptime` field has an NPV type
+    /// * Any enum whose backing type is `noreturn`
+    /// * Any struct where at least one non-`comptime` field has an NPV type
+    /// * Any union where every field has an NPV type (including unions with no fields)
+    ///   * If the union would typically have a runtime tag, even if that tag would have runtime
+    ///     bits, the union type is still NPV; the runtime tag is effectively omitted.
+    no_possible_value,
+
+    /// Values of this type are always comptime-known because there is only one value inhabiting the
+    /// type. This matches the colloquial understanding of a "zero-bit type".
+    ///
+    /// Not comptime-only (although always comptime-known). No runtime bits, i.e. ABI size is 0.
+    ///
+    /// Exhaustive list of one-possible-value ("OPV") types:
+    /// * `void`
+    /// * `u0`, `i0`
+    /// * `[0]T` for any `T`
+    /// * `[n]T` where `T` is OPV
+    /// * `[n:s]T` where `T` is OPV
+    /// * `@Vector(0, T)` for any `T`
+    /// * `@Vector(n, T)` where `T` is OPV
+    /// * Any tuple where every non-`comptime` field has an OPV type (including tuples with no fields)
+    /// * Any enum whose backing type is OPV
+    /// * Any struct where every non-`comptime` field has an OPV type (including structs with no fields)
+    /// * Any union with no runtime tag where all fields have OPV
+    /// * Any union where one field has an OPV type, and either:
+    ///   * All other fields have NPV types (in this case, if there would be a runtime tag, it is omitted)
+    ///   * All other fields have NPV or OPV types, and the union has no runtime tag
+    one_possible_value,
+
+    /// The type holds state (so it is neither NPV nor OPV), but contains no comptime-only state, so
+    /// values may be runtime-known.
+    ///
+    /// Not comptime-only. Has runtime bits, i.e. ABI size is non-zero.
+    ///
+    /// Most types which are typically used in Zig inhabit this class. For instance, all pointer
+    /// types, all integer types other than `u0` and `i0`, and most user-defined aggregates fall
+    /// into this category.
+    runtime,
+
+    /// The type holds state (so it is neither NPV nor OPV). Some, but not all, of the contained
+    /// state is comptime-only.
+    ///
+    /// Comptime-only. Has runtime bits, i.e. ABI size is non-zero.
+    ///
+    /// Partially-comptime types arise from aggregates (`struct`s, `union`s, or tuples) which have
+    /// some fields with fully-comptime types (such as `comptime_int`) and some fields with runtime
+    /// types (such as `u8`). Because the user may acquire pointers to these fields, pointers to the
+    /// embedded runtime state must be valid, so backends are required to lower the runtime state
+    /// within the type.
+    ///
+    /// Note that logically-runtime state which cannot be directly referenced by the user (such as
+    /// the enum tag of a tagged union type, or the "populated" bit of an optional type) does not
+    /// cause a type to be partially-comptime.
+    partially_comptime,
+
+    /// The type contains exclusively comptime-only state.
+    ///
+    /// Comptime-only. No runtime bits, i.e. ABI size is 0.
+    ///
+    /// Fully-comptime types arise from a handful of primitive fully-comptime types:
+    /// * `type`
+    /// * `comptime_int`
+    /// * `comptime_float`
+    /// * `@EnumLiteral()`
+    /// * `@TypeOf(null)`
+    /// * `@TypeOf(undefined)`
+    ///
+    /// Then, aggregates containing fully-comptime types may themselves be either fully-comptime or
+    /// partially-comptime; see the doc comment on `.partially_comptime` for details.
+    fully_comptime,
+};
+
+/// Returns the `Class` for the type `ty`. Asserts that the layout of `ty` is resolved.
+pub fn classify(ty: Type, zcu: *const Zcu) Class {
+    ty.assertHasLayout(zcu);
+    const ip = &zcu.intern_pool;
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .simple_type => |t| switch (t) {
+            .f16,
+            .f32,
+            .f64,
+            .f80,
+            .f128,
+            .usize,
+            .isize,
+            .c_char,
+            .c_short,
+            .c_ushort,
+            .c_int,
+            .c_uint,
+            .c_long,
+            .c_ulong,
+            .c_longlong,
+            .c_ulonglong,
+            .c_longdouble,
+            .bool,
+            .anyerror,
+            .adhoc_inferred_error_set,
+            => .runtime,
+
+            .anyopaque => .no_possible_value,
+
+            .type,
+            .comptime_int,
+            .comptime_float,
+            .enum_literal,
+            .null,
+            .undefined,
+            => .fully_comptime,
+
+            .void => .one_possible_value,
+            .noreturn => .no_possible_value,
+
+            .generic_poison => unreachable,
+        },
+
+        .error_set_type,
+        .inferred_error_set_type,
+        .ptr_type,
+        .anyframe_type,
+        => .runtime,
+
+        .func_type => .fully_comptime,
+
+        .opaque_type => .no_possible_value,
+
+        .error_union_type => |eu| switch (Type.fromInterned(eu.payload_type).classify(zcu)) {
+            .no_possible_value,
+            .one_possible_value,
+            .runtime,
+            => .runtime,
+
+            .partially_comptime => .partially_comptime,
+            // It may seem that this should be `.partially_comptime` due to the error set, however
+            // there is no way to take a pointer to the error set of an error union, so it does not
+            // actually necessitate runtime bits.
+            .fully_comptime => .fully_comptime,
+        },
+
+        .int_type => |int| switch (int.bits) {
+            0 => .one_possible_value,
+            else => .runtime,
+        },
+        .array_type => |arr| {
+            if (arr.len == 0 and arr.sentinel == .none) return .one_possible_value;
+            return Type.fromInterned(arr.child).classify(zcu);
+        },
+        .vector_type => |vec| {
+            if (vec.len == 0) return .one_possible_value;
+            return Type.fromInterned(vec.child).classify(zcu);
+        },
+        .opt_type => |child| switch (Type.fromInterned(child).classify(zcu)) {
+            .no_possible_value => .one_possible_value,
+            .one_possible_value => .runtime,
+            else => |class| class,
+        },
+        .tuple_type => |tuple| {
+            var has_runtime_state = false;
+            var has_comptime_state = false;
+            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, field_comptime_val| {
+                if (field_comptime_val != .none) continue;
+                switch (Type.fromInterned(field_ty).classify(zcu)) {
+                    .no_possible_value => return .no_possible_value,
+                    .one_possible_value => {},
+                    .runtime => has_runtime_state = true,
+                    .fully_comptime => has_comptime_state = true,
+                    .partially_comptime => {
+                        has_runtime_state = true;
+                        has_comptime_state = true;
+                    },
+                }
+            }
+            if (has_comptime_state) {
+                return if (has_runtime_state) .partially_comptime else .fully_comptime;
+            } else {
+                return if (has_runtime_state) .runtime else .one_possible_value;
+            }
+        },
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            return switch (struct_obj.layout) {
+                .auto, .@"extern" => struct_obj.class,
+                .@"packed" => Type.fromInterned(struct_obj.packed_backing_int_type).classify(zcu),
+            };
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            return switch (union_obj.layout) {
+                .auto, .@"extern" => union_obj.class,
+                .@"packed" => Type.fromInterned(union_obj.packed_backing_int_type).classify(zcu),
+            };
+        },
+        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).classify(zcu),
+
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        .bitpack,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
+    };
+}
+
 /// Asserts the type is resolved.
 pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
     return switch (ty.zigTypeTag(zcu)) {
@@ -400,7 +634,6 @@ pub fn print(ty: Type, writer: *std.Io.Writer, pt: Zcu.PerThread, ctx: ?*Compari
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -438,116 +671,9 @@ pub fn toValue(self: Type) Value {
 ///   - an enum with an explicit tag type has the ABI size of the integer tag type,
 ///     making it one-possible-value only if the integer tag type has 0 bits.
 pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
-    ty.assertHasLayout(zcu);
-    const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .int_type => |int_type| int_type.bits != 0,
-        .ptr_type => true,
-        .anyframe_type => true,
-        .array_type => |array_type| array_type.lenIncludingSentinel() > 0 and
-            Type.fromInterned(array_type.child).hasRuntimeBits(zcu),
-        .vector_type => |vector_type| vector_type.len > 0 and
-            Type.fromInterned(vector_type.child).hasRuntimeBits(zcu),
-        .opt_type => |child| !Type.fromInterned(child).isNoReturn(zcu),
-
-        .error_union_type,
-        .error_set_type,
-        .inferred_error_set_type,
-        => true,
-
-        // These are function *bodies*, not pointers.
-        // They return false here because they are comptime-only types.
-        // Special exceptions have to be made when emitting functions due to
-        // this returning false.
-        .func_type => false,
-
-        .simple_type => |t| switch (t) {
-            .f16,
-            .f32,
-            .f64,
-            .f80,
-            .f128,
-            .usize,
-            .isize,
-            .c_char,
-            .c_short,
-            .c_ushort,
-            .c_int,
-            .c_uint,
-            .c_long,
-            .c_ulong,
-            .c_longlong,
-            .c_ulonglong,
-            .c_longdouble,
-            .bool,
-            .anyerror,
-            .adhoc_inferred_error_set,
-            .anyopaque,
-            => true,
-
-            .void,
-            .noreturn,
-            => false,
-
-            // primitive comptime-only types
-            .type,
-            .comptime_int,
-            .comptime_float,
-            .null,
-            .undefined,
-            .enum_literal,
-            => false,
-
-            .generic_poison => unreachable,
-        },
-        .struct_type => {
-            const struct_obj = ip.loadStructType(ty.toIntern());
-            switch (struct_obj.layout) {
-                .auto, .@"extern" => return struct_obj.has_runtime_bits,
-                .@"packed" => return Type.fromInterned(struct_obj.packed_backing_int_type).hasRuntimeBits(zcu),
-            }
-        },
-        .union_type => {
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            switch (union_obj.layout) {
-                .auto, .@"extern" => return union_obj.has_runtime_bits,
-                .@"packed" => return Type.fromInterned(union_obj.packed_backing_int_type).hasRuntimeBits(zcu),
-            }
-        },
-        .tuple_type => |tuple| {
-            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
-                if (val != .none) continue; // comptime field
-                if (Type.fromInterned(field_ty).hasRuntimeBits(zcu)) return true;
-            }
-            return false;
-        },
-
-        // MLUGG TODO: this answer was already here but... does it actually make sense?
-        .opaque_type => true,
-        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).hasRuntimeBits(zcu),
-
-        // values, not types
-        .undef,
-        .simple_value,
-        .variable,
-        .@"extern",
-        .func,
-        .int,
-        .err,
-        .error_union,
-        .enum_literal,
-        .enum_tag,
-        .empty_enum_value,
-        .float,
-        .ptr,
-        .slice,
-        .opt,
-        .aggregate,
-        .un,
-        .bitpack,
-        // memoization, not types
-        .memoized_call,
-        => unreachable,
+    return switch (ty.classify(zcu)) {
+        .no_possible_value, .one_possible_value, .fully_comptime => false,
+        .runtime, .partially_comptime => true,
     };
 }
 
@@ -634,7 +760,6 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -681,8 +806,12 @@ pub fn isRuntimeFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
     }
 }
 
+/// Returns whether `ty` is NPV, meaning it is "like `noreturn`" in a sense. See doc comments on
+/// `Class` for more details.
+///
+/// Exactly equivalent to `ty.classify(zcu) == .no_possible_value`.
 pub fn isNoReturn(ty: Type, zcu: *const Zcu) bool {
-    return zcu.intern_pool.isNoReturn(ty.toIntern());
+    return ty.classify(zcu) == .no_possible_value;
 }
 
 /// Never returns `none`. Asserts that all necessary type resolution is already done.
@@ -705,7 +834,10 @@ pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace {
     };
 }
 
-/// Never returns `none`. Asserts that all necessary type resolution is already done.
+/// Never returns `.none`. Asserts that the layout of `ty` is resolved.
+///
+/// Unlike ABI size, a type's ABI alignment is not affected by its `Class`. In other words, any
+/// alignment is possible regardless of the result of `ty.classify(zcu)`.
 pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
     const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
@@ -842,7 +974,6 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -856,7 +987,11 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
     };
 }
 
-/// Asserts that `ty` is not an opaque type.
+/// Asserts that `ty` is not an opaque type, and that the layout of `ty` is resolved.
+///
+/// If the type is NPV, OPV, or fully-comptime (see `Class`), the return value of this function is
+/// guaranteed to be zero. Otherwise (if the type is runtime or partially-comptime) the return value
+/// is guaranteed to be non-zero.
 pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
     const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
@@ -883,29 +1018,26 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
         },
         .opt_type => |child_ty_ip| {
             const child_ty: Type = .fromInterned(child_ty_ip);
-            if (child_ty.isNoReturn(zcu)) return 0;
-            const child_size = child_ty.abiSize(zcu);
-            if (ty.optionalReprIsPayload(zcu)) return child_size;
+            if (child_ty.classify(zcu) == .no_possible_value) return 0;
+            if (ty.optionalReprIsPayload(zcu)) return child_ty.abiSize(zcu);
             // Optional types are represented as a struct with the child type as the first
             // field and a boolean as the second. Since the child type's abi alignment is
             // guaranteed to be >= that of bool's (1 byte) the added size is exactly equal
             // to the child type's ABI alignment.
-            return child_size + child_ty.abiAlignment(zcu).toByteUnits().?;
+            return child_ty.abiSize(zcu) + child_ty.abiAlignment(zcu).toByteUnits().?;
         },
         .error_set_type, .inferred_error_set_type => errorAbiSize(zcu),
         .error_union_type => |error_union| {
             const payload_ty: Type = .fromInterned(error_union.payload_type);
-            // This code needs to be kept in sync with the equivalent switch prong
-            // in abiAlignmentInner.
-            const code_size = errorAbiSize(zcu);
-            const code_align = errorAbiAlignment(zcu);
-            const payload_size = payload_ty.abiSize(zcu);
-            const payload_align = payload_ty.abiAlignment(zcu);
+            switch (payload_ty.classify(zcu)) {
+                .fully_comptime => return 0, // error set does not require runtime bits, see comment in `classify`
+                else => {},
+            }
             // The layout will either be (code, payload, padding) or (payload, code, padding)
             // depending on which has larger alignment. So the overall size is just the code
             // and payload sizes added and padded to the larger alignment.
-            const big_align = code_align.maxStrict(payload_align);
-            return big_align.forward(payload_size + code_size);
+            const big_align: Alignment = .maxStrict(errorAbiAlignment(zcu), payload_ty.abiAlignment(zcu));
+            return big_align.forward(errorAbiSize(zcu) + payload_ty.abiSize(zcu));
         },
         .func_type => 0,
         .simple_type => |t| switch (t) {
@@ -946,7 +1078,12 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
             .anyopaque => unreachable,
             .generic_poison => unreachable,
         },
-        .tuple_type => |tuple| ty.structFieldOffset(tuple.types.len, zcu),
+        .tuple_type => |tuple| switch (ty.classify(zcu)) {
+            // `structFieldOffset` is bogus on NPV tuples, because there may be some fields with
+            // non-zero size.
+            .no_possible_value => 0,
+            else => ty.structFieldOffset(tuple.types.len, zcu),
+        },
         .struct_type => {
             const struct_obj = ip.loadStructType(ty.toIntern());
             switch (struct_obj.layout) {
@@ -975,7 +1112,6 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -1100,7 +1236,6 @@ pub fn bitSize(ty: Type, zcu: *const Zcu) u64 {
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -1327,8 +1462,7 @@ pub fn optionalChild(ty: Type, zcu: *const Zcu) Type {
     }
 }
 
-/// Returns the tag type of a union, if the type is a union and it has a tag type.
-/// Otherwise, returns `null`.
+/// If `ty` is a tagged union, returns its tag type. Otherwise, returns `null`.
 pub fn unionTagType(ty: Type, zcu: *const Zcu) ?Type {
     assertHasLayout(ty, zcu);
     const ip = &zcu.intern_pool;
@@ -1337,33 +1471,28 @@ pub fn unionTagType(ty: Type, zcu: *const Zcu) ?Type {
         else => return null,
     }
     const union_obj = ip.loadUnionType(ty.toIntern());
-    return switch (union_obj.runtime_tag) {
+    return switch (union_obj.tag_usage) {
         .tagged => .fromInterned(union_obj.enum_tag_type),
         .none, .safety => null,
     };
 }
 
-/// Same as `unionTagType` but includes safety tag.
-/// Codegen should use this version.
-pub fn unionTagTypeSafety(ty: Type, zcu: *const Zcu) ?Type {
+/// If the given union type contains a tag (including a safety tag) in its runtime layout, returns
+/// its enum tag type. Otherwise, returns null. Asserts that `ty` is a union type.
+///
+/// In general, codegen logic should call this function instead of `unionTagType`.
+pub fn unionTagTypeRuntime(ty: Type, zcu: *const Zcu) ?Type {
     assertHasLayout(ty, zcu);
-    const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .union_type => {
-            const union_type = ip.loadUnionType(ty.toIntern());
-            if (union_type.runtime_tag == .none) return null;
-            return Type.fromInterned(union_type.enum_tag_type);
-        },
-        else => null,
-    };
+    const union_type = zcu.intern_pool.loadUnionType(ty.toIntern());
+    if (!union_type.has_runtime_tag) return null;
+    return .fromInterned(union_type.enum_tag_type);
 }
 
-/// Asserts the type is a union; returns the tag type, even if the tag will
-/// not be stored at runtime.
+/// Asserts that `ty` is a union type, and returns its tag type, even if the tag will not be stored at runtime.
 pub fn unionTagTypeHypothetical(ty: Type, zcu: *const Zcu) Type {
     assertHasLayout(ty, zcu);
-    const union_obj = zcu.typeToUnion(ty).?;
-    return Type.fromInterned(union_obj.enum_tag_type);
+    const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
+    return .fromInterned(union_obj.enum_tag_type);
 }
 
 pub fn unionFieldType(ty: Type, enum_tag: Value, zcu: *const Zcu) ?Type {
@@ -1573,12 +1702,12 @@ pub fn isUnsignedInt(ty: Type, zcu: *const Zcu) bool {
     };
 }
 
-/// Returns true for integers, enums, error sets, and packed structs.
+/// Returns true for integers, enums, error sets, and packed structs/unions.
 /// If this function returns true, then intInfo() can be called on the type.
 pub fn isAbiInt(ty: Type, zcu: *const Zcu) bool {
     return switch (ty.zigTypeTag(zcu)) {
         .int, .@"enum", .error_set => true,
-        .@"struct" => ty.containerLayout(zcu) == .@"packed",
+        .@"struct", .@"union" => ty.containerLayout(zcu) == .@"packed",
         else => false,
     };
 }
@@ -1611,6 +1740,11 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
                 assert(struct_obj.layout == .@"packed");
                 ty = .fromInterned(struct_obj.packed_backing_int_type);
             },
+            .union_type => {
+                const union_obj = ip.loadUnionType(ty.toIntern());
+                assert(union_obj.layout == .@"packed");
+                ty = .fromInterned(union_obj.packed_backing_int_type);
+            },
             .enum_type => ty = .fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type),
             .vector_type => |vector_type| ty = Type.fromInterned(vector_type.child),
 
@@ -1629,7 +1763,6 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
             .func_type => unreachable,
             .simple_type => unreachable, // handled via Index enum tag above
 
-            .union_type => unreachable,
             .opaque_type => unreachable,
 
             // values, not types
@@ -1643,7 +1776,6 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
             .error_union,
             .enum_literal,
             .enum_tag,
-            .empty_enum_value,
             .float,
             .ptr,
             .slice,
@@ -1772,321 +1904,181 @@ pub fn isNumeric(ty: Type, zcu: *const Zcu) bool {
     };
 }
 
-/// MLUGG TODO: deal with our friends structs and unions
-pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
+/// If the type's classification is `Class.one_possible_value` (see `classify`), returns the only
+/// possible value for the type. Otherwise, returns `null`.
+pub fn onePossibleValue(ty: Type, pt: Zcu.PerThread) !?Value {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
-    assertHasLayout(starting_type, zcu);
-    var ty = starting_type;
-    while (true) switch (ty.toIntern()) {
-        .empty_tuple_type => return .empty_tuple,
+    assertHasLayout(ty, zcu);
+    return switch (ip.indexToKey(ty.toIntern())) {
+        .ptr_type,
+        .error_union_type,
+        .func_type,
+        .anyframe_type,
+        .error_set_type,
+        .inferred_error_set_type,
+        .opaque_type,
+        => null,
 
-        else => switch (ip.indexToKey(ty.toIntern())) {
-            .int_type => |int_type| {
-                if (int_type.bits == 0) {
-                    return try pt.intValue(ty, 0);
-                } else {
-                    return null;
-                }
-            },
+        .simple_type => |t| switch (t) {
+            .f16,
+            .f32,
+            .f64,
+            .f80,
+            .f128,
+            .usize,
+            .isize,
+            .c_char,
+            .c_short,
+            .c_ushort,
+            .c_int,
+            .c_uint,
+            .c_long,
+            .c_ulong,
+            .c_longlong,
+            .c_ulonglong,
+            .c_longdouble,
+            .anyopaque,
+            .bool,
+            .type,
+            .anyerror,
+            .comptime_int,
+            .comptime_float,
+            .enum_literal,
+            .adhoc_inferred_error_set,
+            .null,
+            .undefined,
+            .noreturn,
+            => null,
 
-            .ptr_type,
-            .error_union_type,
-            .func_type,
-            .anyframe_type,
-            .error_set_type,
-            .inferred_error_set_type,
-            => return null,
+            .void => .void,
 
-            inline .array_type, .vector_type => |seq_type, seq_tag| {
-                const has_sentinel = seq_tag == .array_type and seq_type.sentinel != .none;
-                if (seq_type.len + @intFromBool(has_sentinel) == 0) {
-                    return try pt.aggregateValue(ty, &.{});
-                }
-                if (try Type.fromInterned(seq_type.child).onePossibleValue(pt)) |opv| {
-                    return try pt.aggregateSplatValue(ty, opv);
-                }
-                return null;
-            },
-            .opt_type => |child| {
-                if (child == .noreturn_type) {
-                    return try pt.nullValue(ty);
-                } else {
-                    return null;
-                }
-            },
+            .generic_poison => unreachable,
+        },
 
-            .simple_type => |t| switch (t) {
-                .f16,
-                .f32,
-                .f64,
-                .f80,
-                .f128,
-                .usize,
-                .isize,
-                .c_char,
-                .c_short,
-                .c_ushort,
-                .c_int,
-                .c_uint,
-                .c_long,
-                .c_ulong,
-                .c_longlong,
-                .c_ulonglong,
-                .c_longdouble,
-                .anyopaque,
-                .bool,
-                .type,
-                .anyerror,
-                .comptime_int,
-                .comptime_float,
-                .enum_literal,
-                .adhoc_inferred_error_set,
-                => return null,
+        .int_type => |int_type| switch (int_type.bits) {
+            0 => try pt.intValue(ty, 0),
+            else => null,
+        },
 
-                .void => return .void,
-                .noreturn => return .@"unreachable",
-                .null => return .null,
-                .undefined => return .undef,
-
-                .generic_poison => unreachable,
-            },
-            .struct_type => {
-                const struct_obj = ip.loadStructType(ty.toIntern());
-                if (struct_obj.layout == .@"packed") {
+        inline .array_type, .vector_type => |seq_type, seq_tag| {
+            const has_sentinel = seq_tag == .array_type and seq_type.sentinel != .none;
+            if (seq_type.len + @intFromBool(has_sentinel) == 0) {
+                return try pt.aggregateValue(ty, &.{});
+            }
+            if (try Type.fromInterned(seq_type.child).onePossibleValue(pt)) |opv| {
+                return try pt.aggregateSplatValue(ty, opv);
+            }
+            return null;
+        },
+        .opt_type => |child| switch (Type.fromInterned(child).classify(zcu)) {
+            .no_possible_value => try pt.nullValue(ty),
+            else => null,
+        },
+        .tuple_type => |tuple| {
+            // Check *whether* the OPV exists first, because constructing it is a little more expensive.
+            if (ty.classify(zcu) != .one_possible_value) return null;
+            const field_vals = try zcu.gpa.dupe(InternPool.Index, tuple.values.get(ip));
+            defer zcu.gpa.free(field_vals);
+            for (field_vals, tuple.types.get(ip)) |*field_val, field_ty_ip| {
+                if (field_val.* != .none) continue; // comptime field value
+                const field_ty: Type = .fromInterned(field_ty_ip);
+                field_val.* = (try field_ty.onePossibleValue(pt)).?.toIntern();
+            }
+            return try pt.aggregateValue(ty, field_vals);
+        },
+        .struct_type => {
+            const struct_obj = ip.loadStructType(ty.toIntern());
+            switch (struct_obj.layout) {
+                .auto, .@"extern" => {},
+                .@"packed" => {
                     const backing_ty: Type = .fromInterned(struct_obj.packed_backing_int_type);
                     const backing_val = try backing_ty.onePossibleValue(pt) orelse return null;
                     return try pt.bitpackValue(ty, backing_val);
-                } else {
-                    if (!struct_obj.has_one_possible_value) return null;
+                },
+            }
+            // Type resolution already figured out whether there is an OPV, but if there is, it's
+            // our job to compute it.
+            if (struct_obj.class != .one_possible_value) return null;
+            const field_vals = try gpa.alloc(InternPool.Index, struct_obj.field_types.len);
+            defer gpa.free(field_vals);
+            for (field_vals, 0..) |*field_val, i_usize| {
+                const i: u32 = @intCast(i_usize);
+                if (struct_obj.field_is_comptime_bits.get(ip, i)) {
+                    field_val.* = struct_obj.field_defaults.get(ip)[i];
+                    assert(field_val.* != .none);
+                    continue;
                 }
-                // There is an OPV.
-                const field_vals = try gpa.alloc(InternPool.Index, struct_obj.field_types.len);
-                defer gpa.free(field_vals);
-                for (field_vals, 0..) |*field_val, i_usize| {
-                    const i: u32 = @intCast(i_usize);
-                    if (struct_obj.field_is_comptime_bits.get(ip, i)) {
-                        field_val.* = struct_obj.field_defaults.get(ip)[i];
-                        assert(field_val.* != .none);
-                        continue;
-                    }
-                    const field_ty = Type.fromInterned(struct_obj.field_types.get(ip)[i]);
-                    field_val.* = (try field_ty.onePossibleValue(pt)).?.toIntern();
-                }
-
-                // In this case the struct has no runtime-known fields and
-                // therefore has one possible value.
-                return try pt.aggregateValue(ty, field_vals);
-            },
-
-            .tuple_type => |tuple| {
-                if (tuple.types.len == 0) {
-                    return try pt.aggregateValue(ty, &.{});
-                }
-
-                const field_vals = try zcu.gpa.alloc(
-                    InternPool.Index,
-                    tuple.types.len,
-                );
-                defer zcu.gpa.free(field_vals);
-                for (
-                    field_vals,
-                    tuple.types.get(ip),
-                    tuple.values.get(ip),
-                ) |*field_val, field_ty, field_comptime_val| {
-                    if (field_comptime_val != .none) {
-                        field_val.* = field_comptime_val;
-                        continue;
-                    }
-                    if (try Type.fromInterned(field_ty).onePossibleValue(pt)) |opv| {
-                        field_val.* = opv.toIntern();
-                    } else return null;
-                }
-
-                return try pt.aggregateValue(ty, field_vals);
-            },
-
-            .union_type => {
-                const union_obj = ip.loadUnionType(ty.toIntern());
-                if (union_obj.layout == .@"packed") {
-                    const backing_ty: Type = .fromInterned(union_obj.packed_backing_int_type);
-                    const backing_val = try backing_ty.onePossibleValue(pt) orelse return null;
-                    return try pt.bitpackValue(ty, backing_val);
-                }
-                // MLUGG TODO: is this nonsensical or what!!!!!!
-                const tag_val = (try Type.fromInterned(union_obj.enum_tag_type).onePossibleValue(pt)) orelse
-                    return null;
-                if (union_obj.field_types.len == 0) {
-                    const only = try pt.intern(.{ .empty_enum_value = ty.toIntern() });
-                    return .fromInterned(only);
-                }
-                const only_field_ty = union_obj.field_types.get(ip)[0];
-                const val_val = (try Type.fromInterned(only_field_ty).onePossibleValue(pt)) orelse
-                    return null;
-                const only = try pt.internUnion(.{
-                    .ty = ty.toIntern(),
-                    .tag = tag_val.toIntern(),
-                    .val = val_val.toIntern(),
-                });
-                return .fromInterned(only);
-            },
-            .opaque_type => return null,
-            .enum_type => {
-                const enum_obj = ip.loadEnumType(ty.toIntern());
-                if (enum_obj.nonexhaustive) {
-                    const int_opv = try Type.fromInterned(enum_obj.int_tag_type).onePossibleValue(pt) orelse return null;
-                    return .fromInterned(try pt.intern(.{ .enum_tag = .{
-                        .ty = ty.toIntern(),
-                        .int = int_opv.toIntern(),
-                    } }));
-                }
-                // MLUGG TODO: this is to preserve existing semantics, i REALLY don't fuck with it...
-                if (enum_obj.int_tag_type == .comptime_int_type) {
-                    return switch (enum_obj.field_names.len) {
-                        0 => .fromInterned(try pt.intern(.{ .empty_enum_value = ty.toIntern() })),
-                        1 => try pt.enumValueFieldIndex(ty, 0),
-                        else => null,
-                    };
-                }
-                const int_tag_opv = try Type.fromInterned(enum_obj.int_tag_type).onePossibleValue(pt) orelse return null;
-                if (enum_obj.field_names.len == 0) {
-                    return .fromInterned(try pt.intern(.{ .empty_enum_value = ty.toIntern() }));
+                const field_ty: Type = .fromInterned(struct_obj.field_types.get(ip)[i]);
+                field_val.* = (try field_ty.onePossibleValue(pt)).?.toIntern();
+            }
+            return try pt.aggregateValue(ty, field_vals);
+        },
+        .union_type => {
+            const union_obj = ip.loadUnionType(ty.toIntern());
+            if (union_obj.layout == .@"packed") {
+                const backing_ty: Type = .fromInterned(union_obj.packed_backing_int_type);
+                const backing_val = try backing_ty.onePossibleValue(pt) orelse return null;
+                return try pt.bitpackValue(ty, backing_val);
+            }
+            // Type resolution already figured out whether there is an OPV, but if there is, it's
+            // our job to compute it.
+            if (union_obj.class != .one_possible_value) return null;
+            // The OPV comes from exactly one field whose type is OPV, while all others are NPV.
+            for (union_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
+                const field_ty: Type = .fromInterned(field_ty_ip);
+                switch (field_ty.classify(zcu)) {
+                    .no_possible_value => continue,
+                    .one_possible_value => {},
+                    else => unreachable,
                 }
-                return .fromInterned(try pt.intern(.{ .enum_tag = .{
-                    .ty = ty.toIntern(),
-                    .int = int_tag_opv.toIntern(),
-                } }));
-            },
-
-            // values, not types
-            .undef,
-            .simple_value,
-            .variable,
-            .@"extern",
-            .func,
-            .int,
-            .err,
-            .error_union,
-            .enum_literal,
-            .enum_tag,
-            .empty_enum_value,
-            .float,
-            .ptr,
-            .slice,
-            .opt,
-            .aggregate,
-            .un,
-            .bitpack,
-            // memoization, not types
-            .memoized_call,
-            => unreachable,
+                // This field is the one!
+                const enum_tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
+                const tag_val = try pt.enumValueFieldIndex(enum_tag_ty, @intCast(field_index));
+                const payload_val = (try field_ty.onePossibleValue(pt)).?;
+                return try pt.unionValue(ty, tag_val, payload_val);
+            } else unreachable;
         },
+        .enum_type => if (try ty.intTagType(zcu).onePossibleValue(pt)) |int_tag_opv| {
+            return .fromInterned(try pt.intern(.{ .enum_tag = .{
+                .ty = ty.toIntern(),
+                .int = int_tag_opv.toIntern(),
+            } }));
+        } else null,
+
+        // values, not types
+        .undef,
+        .simple_value,
+        .variable,
+        .@"extern",
+        .func,
+        .int,
+        .err,
+        .error_union,
+        .enum_literal,
+        .enum_tag,
+        .float,
+        .ptr,
+        .slice,
+        .opt,
+        .aggregate,
+        .un,
+        .bitpack,
+        // memoization, not types
+        .memoized_call,
+        => unreachable,
     };
 }
 
 /// Asserts that `ty` has its layout resolved. `generic_poison` will return `false`.
 pub fn comptimeOnly(ty: Type, zcu: *const Zcu) bool {
-    const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .array_type => |array_type| return Type.fromInterned(array_type.child).comptimeOnly(zcu),
-        .vector_type => |vector_type| return Type.fromInterned(vector_type.child).comptimeOnly(zcu),
-        .opt_type => |child| return Type.fromInterned(child).comptimeOnly(zcu),
-        .error_union_type => |error_union_type| return Type.fromInterned(error_union_type.payload_type).comptimeOnly(zcu),
-        .enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).comptimeOnly(zcu),
-
-        .int_type,
-        .ptr_type,
-        .anyframe_type,
-        .error_set_type,
-        .inferred_error_set_type,
-        .opaque_type,
-        => false,
-
-        // These are function bodies, not function pointers.
-        .func_type => true,
-
-        .simple_type => |t| switch (t) {
-            .f16,
-            .f32,
-            .f64,
-            .f80,
-            .f128,
-            .usize,
-            .isize,
-            .c_char,
-            .c_short,
-            .c_ushort,
-            .c_int,
-            .c_uint,
-            .c_long,
-            .c_ulong,
-            .c_longlong,
-            .c_ulonglong,
-            .c_longdouble,
-            .anyopaque,
-            .bool,
-            .void,
-            .anyerror,
-            .adhoc_inferred_error_set,
-            .noreturn,
-            .generic_poison,
-            => false,
-
-            .type,
-            .comptime_int,
-            .comptime_float,
-            .null,
-            .undefined,
-            .enum_literal,
-            => true,
-        },
-        .struct_type => {
-            const struct_obj = ip.loadStructType(ty.toIntern());
-            return switch (struct_obj.layout) {
-                .@"packed" => false,
-                .auto, .@"extern" => struct_obj.comptime_only,
-            };
-        },
-        .union_type => {
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            return switch (union_obj.layout) {
-                .@"packed" => false,
-                .auto, .@"extern" => union_obj.comptime_only,
-            };
-        },
-        .tuple_type => |tuple| {
-            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
-                if (val != .none) continue;
-                if (!Type.fromInterned(field_ty).comptimeOnly(zcu)) continue;
-                return true;
-            }
-            return false;
-        },
-
-        // values, not types
-        .undef,
-        .simple_value,
-        .variable,
-        .@"extern",
-        .func,
-        .int,
-        .err,
-        .error_union,
-        .enum_literal,
-        .enum_tag,
-        .empty_enum_value,
-        .float,
-        .ptr,
-        .slice,
-        .opt,
-        .aggregate,
-        .un,
-        .bitpack,
-        // memoization, not types
-        .memoized_call,
-        => unreachable,
+    if (ty.toIntern() == .generic_poison_type) return false;
+    if (ty.zigTypeTag(zcu) == .error_union and ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type) return false;
+    return switch (ty.classify(zcu)) {
+        .no_possible_value, .one_possible_value, .runtime => false,
+        .partially_comptime, .fully_comptime => true,
     };
 }
 
@@ -2286,8 +2278,8 @@ pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, zcu
     return enum_type.nameIndex(ip, field_name);
 }
 
-/// Asserts `ty` is an enum. `enum_tag` can either be `enum_field_index` or
-/// an integer which represents the enum value. Returns the field index in
+/// Asserts `ty` is an enum. `enum_tag` can either be the actual enum tag value
+/// or an integer which represents the enum value. Returns the field index in
 /// declaration order, or `null` if `enum_tag` does not match any field.
 pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
     assertHasLayout(ty, zcu);
@@ -2327,7 +2319,7 @@ pub fn structFieldCount(ty: Type, zcu: *const Zcu) u32 {
     }
 }
 
-/// Returns the field type. Supports structs and unions.
+/// Returns the field type. Supports tuples, structs, and unions.
 pub fn fieldType(ty: Type, index: usize, zcu: *const Zcu) Type {
     const ip = &zcu.intern_pool;
     const types = switch (ip.indexToKey(ty.toIntern())) {
@@ -2493,7 +2485,7 @@ pub fn structFieldOffset(ty: Type, index: usize, zcu: *const Zcu) u64 {
             for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty, field_val, i| {
                 if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) {
                     // comptime field
-                    if (i == index) return offset;
+                    if (i == index) return 0;
                     continue;
                 }
 
@@ -2509,8 +2501,7 @@ pub fn structFieldOffset(ty: Type, index: usize, zcu: *const Zcu) u64 {
 
         .union_type => {
             const union_type = ip.loadUnionType(ty.toIntern());
-            if (union_type.runtime_tag == .none)
-                return 0;
+            if (!union_type.has_runtime_tag) return 0;
             const layout = Type.getUnionLayout(union_type, zcu);
             if (layout.tag_align.compare(.gte, layout.payload_align)) {
                 // {Tag, Payload}
@@ -2746,7 +2737,7 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
         }
         payload_align = payload_align.max(field_align);
     }
-    if (loaded_union.runtime_tag == .none or
+    if (!loaded_union.has_runtime_tag or
         !Type.fromInterned(loaded_union.enum_tag_type).hasRuntimeBits(zcu))
     {
         return .{
@@ -2872,11 +2863,19 @@ pub fn containerTypeName(ty: Type, ip: *const InternPool) InternPool.NullTermina
 }
 
 /// Returns `true` if a value of this type is always `null`.
-/// Returns `false` if a value of this type is neve `null`.
+/// Returns `false` if a value of this type is never `null`.
 /// Returns `null` otherwise.
 pub fn isNullFromType(ty: Type, zcu: *const Zcu) ?bool {
     if (ty.zigTypeTag(zcu) != .optional and !ty.isCPtr(zcu)) return false;
-    if (ty.optionalChild(zcu).isNoReturn(zcu)) return true; // `?noreturn` is always null
+    const payload_ty = ty.optionalChild(zcu);
+    if (payload_ty.classify(zcu) == .no_possible_value) return true; // `?noreturn` etc
+
+    // Although it has runtime bits, `?error{}` is always null. MLUGG TODO: think for a bit...
+    switch (zcu.intern_pool.indexToKey(payload_ty.toIntern())) {
+        .error_set_type => |error_set| if (error_set.names.len == 0) return true,
+        else => {},
+    }
+
     return null;
 }
 
@@ -3096,7 +3095,6 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -3175,7 +3173,6 @@ fn collectSubtypes(ty: Type, pt: Zcu.PerThread, visited: *std.AutoArrayHashMapUn
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
diff --git a/src/Value.zig b/src/Value.zig
index 774a6758ceff8d82fc579f580b33de17ad4fef75..d158aa558c1c63a5cab26832774270680a61e5e7 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -348,7 +348,7 @@ pub fn writeToMemory(val: Value, pt: Zcu.PerThread, buffer: []u8) error{
                 } else {
                     const backing_ty = try ty.externUnionBackingType(pt);
                     const byte_count: usize = @intCast(backing_ty.abiSize(zcu));
-                    return writeToMemory(val.unionValue(zcu), pt, buffer[0..byte_count]);
+                    return writeToMemory(val.unionPayload(zcu), pt, buffer[0..byte_count]);
                 }
             },
             .@"packed" => {
@@ -746,7 +746,6 @@ pub fn compareScalar(
 /// Returns `false` if the value or any vector element is undefined.
 ///
 /// Note that `!compareAllWithZero(.eq, ...) != compareAllWithZero(.neq, ...)`
-/// TODO MLUGG: lowkey wanna delete this
 pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator, zcu: *Zcu) bool {
     return switch (zcu.intern_pool.indexToKey(lhs.toIntern())) {
         .float => |float| switch (float.storage) {
@@ -919,7 +918,7 @@ pub fn unionTag(val: Value, zcu: *Zcu) ?Value {
     };
 }
 
-pub fn unionValue(val: Value, zcu: *Zcu) Value {
+pub fn unionPayload(val: Value, zcu: *Zcu) Value {
     return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
         .un => |un| Value.fromInterned(un.val),
         else => unreachable,
@@ -2442,7 +2441,7 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe
                 inline else => |tag_comptime| @unionInit(
                     T,
                     @tagName(tag_comptime),
-                    try val.unionValue(zcu).interpret(@FieldType(T, @tagName(tag_comptime)), pt),
+                    try val.unionPayload(zcu).interpret(@FieldType(T, @tagName(tag_comptime)), pt),
                 ),
             };
         },
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 186d6147d13622463f56d708f07a62d8b0e128c2..46e275045ac39d580acc8bf33dd45e671d19d39f 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -3825,9 +3825,7 @@ pub fn enumValueFieldIndex(pt: Zcu.PerThread, ty: Type, field_index: u32) Alloca
 
 pub fn undefValue(pt: Zcu.PerThread, ty: Type) Allocator.Error!Value {
     if (std.debug.runtime_safety) {
-        if (try ty.onePossibleValue(pt)) |opv| {
-            assert(opv.isUndef(pt.zcu));
-        }
+        assert(ty.classify(pt.zcu) != .one_possible_value);
     }
     return .fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
 }
@@ -3909,10 +3907,7 @@ pub fn aggregateValue(pt: Zcu.PerThread, ty: Type, elems: []const InternPool.Ind
     for (elems) |elem| {
         if (!Value.fromInterned(elem).isUndef(pt.zcu)) break;
     } else if (elems.len > 0) {
-        // All undef, so return an undef struct. However, don't use `undefValue`, because its
-        // non-OPV assertion can loop on `[1]@TypeOf(undefined)`: that type has an OPV of
-        // `.{undefined}`, which here we normalize to `undefined`.
-        return .fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
+        return pt.undefValue(ty);
     }
     return .fromInterned(try pt.intern(.{ .aggregate = .{
         .ty = ty.toIntern(),
diff --git a/src/codegen.zig b/src/codegen.zig
index 9edb90fb51056d9ad56f913982b001ff8750e52b..45b70dee2ac19600117a0a08eec0087b234c7013 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -343,7 +343,6 @@ pub fn generateSymbol(
 
         .undef => unreachable, // handled above
         .simple_value => |simple_value| switch (simple_value) {
-            .undefined => unreachable, // non-runtime value
             .void => unreachable, // non-runtime value
             .null => unreachable, // non-runtime value
             .@"unreachable" => unreachable, // non-runtime value
@@ -357,7 +356,6 @@ pub fn generateSymbol(
         .@"extern",
         .func,
         .enum_literal,
-        .empty_enum_value,
         => unreachable, // non-runtime values
         .int => {
             const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index f9ff7874770ed1bd1b995a3689a89242c7211898..a95faca765385b3b4b879b0cf5b0e7885adf4e49 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -10588,7 +10588,6 @@ pub const Value = struct {
                     .error_union,
                     .enum_literal,
                     .enum_tag,
-                    .empty_enum_value,
                     .float,
                     .ptr,
                     .slice,
@@ -10711,7 +10710,6 @@ pub const Value = struct {
                                 .inferred_error_set_type,
 
                                 .enum_literal,
-                                .empty_enum_value,
                                 .memoized_call,
                                 => unreachable, // not a runtime value
                                 .undef => break :free try isel.emit(if (mat.ra.isVector()) .movi(switch (size) {
@@ -10732,7 +10730,7 @@ pub const Value = struct {
                                     } }),
                                 }),
                                 .simple_value => |simple_value| switch (simple_value) {
-                                    .undefined, .void, .null, .@"unreachable" => unreachable,
+                                    .void, .null, .@"unreachable" => unreachable,
                                     .true => continue :constant_key .{ .int = .{
                                         .ty = .bool_type,
                                         .storage = .{ .u64 = 1 },
@@ -11408,7 +11406,6 @@ fn writeKeyToMemory(isel: *Select, constant_key: InternPool.Key, buffer: []u8) e
         .inferred_error_set_type,
 
         .enum_literal,
-        .empty_enum_value,
         .memoized_call,
         => unreachable, // not a runtime value
         .err => |err| {
@@ -12085,7 +12082,7 @@ pub const CallAbiIterator = struct {
         const zcu = isel.pt.zcu;
         const ip = &zcu.intern_pool;
 
-        if (ty.isNoReturn(zcu) or !ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
+        if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
         try isel.values.ensureUnusedCapacity(zcu.gpa, Value.max_parts);
         const wip_vi = isel.initValue(ty);
         type_key: switch (ip.indexToKey(ty.toIntern())) {
@@ -12326,7 +12323,6 @@ pub const CallAbiIterator = struct {
             .error_union,
             .enum_literal,
             .enum_tag,
-            .empty_enum_value,
             .float,
             .ptr,
             .slice,
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 69c4e91d999c4340e0fe18f299ba88787052a66a..f0df1aa1c0d0f072944a1f6d6dbd2bfc5f462f75 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -1040,7 +1040,6 @@ pub const DeclGen = struct {
             .undef => unreachable, // handled above
             .simple_value => |simple_value| switch (simple_value) {
                 // non-runtime values
-                .undefined => unreachable,
                 .void => unreachable,
                 .null => unreachable,
                 .@"unreachable" => unreachable,
@@ -1052,7 +1051,6 @@ pub const DeclGen = struct {
             .@"extern",
             .func,
             .enum_literal,
-            .empty_enum_value,
             => unreachable, // non-runtime values
             .int => |int| switch (int.storage) {
                 .u64, .i64, .big_int => try w.print("{f}", .{try dg.fmtIntLiteralDec(val, location)}),
@@ -1756,7 +1754,6 @@ pub const DeclGen = struct {
                 .error_union,
                 .enum_literal,
                 .enum_tag,
-                .empty_enum_value,
                 .float,
                 .ptr,
                 .slice,
@@ -5848,7 +5845,7 @@ fn fieldLocation(
                 .auto, .@"extern" => {
                     const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
                     if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu))
-                        return if (loaded_union.hasTag(ip) and !container_ty.unionHasAllZeroBitFieldTypes(zcu))
+                        return if (loaded_union.has_runtime_tag and !container_ty.unionHasAllZeroBitFieldTypes(zcu))
                             .{ .field = .{ .identifier = "payload" } }
                         else
                             .begin;
@@ -7022,7 +7019,7 @@ fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
     const union_ty = f.typeOf(bin_op.lhs).childType(zcu);
     const layout = union_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) return .none;
-    const tag_ty = union_ty.unionTagTypeSafety(zcu).?;
+    const tag_ty = union_ty.unionTagTypeRuntime(zcu).?;
 
     const w = &f.object.code.writer;
     const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
@@ -7462,18 +7459,15 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const local = try f.allocLocal(inst, union_ty);
 
-    const field: CValue = if (union_ty.unionTagTypeSafety(zcu)) |tag_ty| field: {
-        const layout = union_ty.unionGetLayout(zcu);
-        if (layout.tag_size != 0) {
-            const field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
-            const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
-
-            const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
-            try f.writeCValueMember(w, local, .{ .identifier = "tag" });
-            try a.assign(f, w);
-            try w.print("{f}", .{try f.fmtIntLiteralDec(try tag_val.intFromEnum(tag_ty, pt))});
-            try a.end(f, w);
-        }
+    const field: CValue = if (union_ty.unionTagTypeRuntime(zcu)) |tag_ty| field: {
+        assert(union_ty.unionGetLayout(zcu).tag_size != 0);
+        const field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
+        const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
+        const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
+        try f.writeCValueMember(w, local, .{ .identifier = "tag" });
+        try a.assign(f, w);
+        try w.print("{f}", .{try f.fmtIntLiteralDec(try tag_val.intFromEnum(tag_ty, pt))});
+        try a.end(f, w);
         break :field .{ .payload_identifier = field_name.toSlice(ip) };
     } else .{ .identifier = field_name.toSlice(ip) };
 
diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig
index 0bcdb207fc693b3acb38cd2a2c458dee9d61dbe3..3ee61a90b656759d0848af6f74e0ab313f9c34c2 100644
--- a/src/codegen/c/Type.zig
+++ b/src/codegen/c/Type.zig
@@ -2479,7 +2479,7 @@ pub const Pool = struct {
                     return pool.fromFields(allocator, .@"struct", &fields, kind);
                 },
                 .opt_type => |payload_type| {
-                    if (ip.isNoReturn(payload_type)) return .void;
+                    if (Type.fromInterned(payload_type).isNoReturn(zcu)) return .void;
                     const payload_ctype = try pool.fromType(
                         allocator,
                         scratch,
@@ -2521,7 +2521,7 @@ pub const Pool = struct {
                         .signedness = .unsigned,
                         .bits = error_set_bits,
                     }, mod, kind);
-                    if (ip.isNoReturn(error_union_info.payload_type)) return error_set_ctype;
+                    if (Type.fromInterned(error_union_info.payload_type).isNoReturn(zcu)) return error_set_ctype;
                     const payload_type = Type.fromInterned(error_union_info.payload_type);
                     const payload_ctype = try pool.fromType(
                         allocator,
@@ -2684,9 +2684,8 @@ pub const Pool = struct {
                     const loaded_union = ip.loadUnionType(ip_index);
                     switch (loaded_union.flagsUnordered(ip).layout) {
                         .auto, .@"extern" => {
-                            const has_tag = loaded_union.hasTag(ip);
                             const fwd_decl = try pool.getFwdDecl(allocator, .{
-                                .tag = if (has_tag) .@"struct" else .@"union",
+                                .tag = if (loaded_union.has_runtime_tag) .@"struct" else .@"union",
                                 .name = .{ .index = ip_index },
                             });
                             if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
@@ -2707,7 +2706,7 @@ pub const Pool = struct {
                                 const field_type = Type.fromInterned(
                                     loaded_union.field_types.get(ip)[field_index],
                                 );
-                                if (ip.isNoReturn(field_type.toIntern())) continue;
+                                if (field_type.isNoReturn(zcu)) continue;
                                 const field_ctype = try pool.fromType(
                                     allocator,
                                     scratch,
@@ -2738,7 +2737,7 @@ pub const Pool = struct {
                                 scratch.items.len - scratch_top,
                                 @typeInfo(Field).@"struct".fields.len,
                             ));
-                            if (!has_tag) {
+                            if (!loaded_union.has_runtime_tag) {
                                 if (fields_len == 0) return .void;
                                 try pool.ensureUnusedCapacity(allocator, 1);
                                 const extra_index = try pool.addHashedExtra(
@@ -2836,7 +2835,7 @@ pub const Pool = struct {
                     var hasher = Hasher.init;
                     const return_type = Type.fromInterned(func_info.return_type);
                     const return_ctype: CType =
-                        if (!ip.isNoReturn(func_info.return_type)) try pool.fromType(
+                        if (!Type.fromInterned(func_info.return_type).isNoReturn(zcu)) try pool.fromType(
                             allocator,
                             scratch,
                             return_type,
@@ -2889,7 +2888,6 @@ pub const Pool = struct {
                 .error_union,
                 .enum_literal,
                 .enum_tag,
-                .empty_enum_value,
                 .float,
                 .ptr,
                 .slice,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 695bb82133aea39b4478c3a9ad4f4ec4c07be6cc..b952f8c22567527c10c76afcd7c8970481418263 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3516,7 +3516,6 @@ pub const Object = struct {
                 .error_union,
                 .enum_literal,
                 .enum_tag,
-                .empty_enum_value,
                 .float,
                 .ptr,
                 .slice,
@@ -3722,7 +3721,6 @@ pub const Object = struct {
 
             .undef => unreachable, // handled above
             .simple_value => |simple_value| switch (simple_value) {
-                .undefined => unreachable, // non-runtime value
                 .void => unreachable, // non-runtime value
                 .null => unreachable, // non-runtime value
                 .@"unreachable" => unreachable, // non-runtime value
@@ -3732,7 +3730,6 @@ pub const Object = struct {
             },
             .variable,
             .enum_literal,
-            .empty_enum_value,
             => unreachable, // non-runtime values
             .@"extern" => |@"extern"| {
                 const function_index = try o.resolveLlvmFunction(pt, @"extern".owner_nav);
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index 709de66a412e409ea6017d0a15a631156fe133e4..217581a72ce28eb36f6f0a08a78640124ad2e293 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -814,11 +814,9 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
             .@"extern",
             .func,
             .enum_literal,
-            .empty_enum_value,
             => unreachable, // non-runtime values
 
             .simple_value => |simple_value| switch (simple_value) {
-                .undefined,
                 .void,
                 .null,
                 .@"unreachable",
@@ -4482,7 +4480,7 @@ fn airSetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) !void {
 
     if (layout.tag_size == 0) return;
 
-    const tag_ty = un_ty.unionTagTypeSafety(zcu).?;
+    const tag_ty = un_ty.unionTagTypeRuntime(zcu).?;
     const tag_ty_id = try cg.resolveType(tag_ty, .indirect);
     const tag_ptr_ty_id = try cg.module.ptrType(tag_ty_id, cg.module.storageClass(un_ptr_ty.ptrAddressSpace(zcu)));
 
@@ -4508,7 +4506,7 @@ fn airGetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const union_handle = try cg.resolve(ty_op.operand);
     if (!layout.has_payload) return union_handle;
 
-    const tag_ty = un_ty.unionTagTypeSafety(zcu).?;
+    const tag_ty = un_ty.unionTagTypeRuntime(zcu).?;
     return try cg.extractField(tag_ty, union_handle, layout.tag_index);
 }
 
diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig
index cdcaac93025a4902f1d123c485e80076558a84ed..6b5cd3c1c556aaf63343a2fe33e4966f96203a01 100644
--- a/src/codegen/wasm/CodeGen.zig
+++ b/src/codegen/wasm/CodeGen.zig
@@ -1244,7 +1244,7 @@ fn generateInner(cg: *CodeGen, any_returns: bool) InnerError!Mir {
     if (any_returns and cg.air.instructions.len > 0) {
         const inst: Air.Inst.Index = @enumFromInt(cg.air.instructions.len - 1);
         const last_inst_ty = cg.typeOfIndex(inst);
-        if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(zcu) or last_inst_ty.isNoReturn(zcu)) {
+        if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             try cg.addTag(.@"unreachable");
         }
     }
@@ -2201,9 +2201,6 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
     const result_value = result_value: {
         if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
             break :result_value .none;
-        } else if (ret_ty.isNoReturn(zcu)) {
-            try cg.addTag(.@"unreachable");
-            break :result_value .none;
         } else if (first_param_sret) {
             break :result_value sret;
         } else if (zcu.typeToFunc(fn_ty).?.cc == .wasm_mvp) {
@@ -3158,7 +3155,6 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
 
         .undef => unreachable, // handled above
         .simple_value => |simple_value| switch (simple_value) {
-            .undefined,
             .void,
             .null,
             .@"unreachable",
@@ -3173,7 +3169,6 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
         .@"extern",
         .func,
         .enum_literal,
-        .empty_enum_value,
         => unreachable, // non-runtime values
         .int => {
             const int_info = ty.intInfo(zcu);
@@ -5340,7 +5335,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         const field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
 
         const tag_int = blk: {
-            const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
+            const tag_ty = union_ty.unionTagTypeRuntime(zcu).?;
             const enum_field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
             const tag_val = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
             break :blk try cg.lowerConstant(tag_val, tag_ty);
@@ -7109,9 +7104,6 @@ fn callIntrinsic(
 
     if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
         return .none;
-    } else if (return_type.isNoReturn(zcu)) {
-        try cg.addTag(.@"unreachable");
-        return .none;
     } else if (want_sret_param) {
         return sret;
     } else {
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index 2a7558505b3c4b1bedad6466d7c15452534c78c1..f46f87ccff5846df798fc470fbb97e06c3cd59e7 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -171467,7 +171467,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const union_layout = union_ty.unionGetLayout(zcu);
                 if (union_layout.tag_size > 0) {
                     var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex(
-                        union_ty.unionTagTypeSafety(zcu).?,
+                        union_ty.unionTagTypeRuntime(zcu).?,
                         union_init.field_index,
                     ));
                     try res.write(&tag_temp, .{
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 027d5391a56231bc342f6cfe7e8d55a5a08379fa..1d87a42601427050245a3c1f6b2e314b515b0d0b 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -1603,7 +1603,7 @@ pub const WipNav = struct {
         const zcu = pt.zcu;
         const ty = val.typeOf(zcu);
         const has_runtime_bits = ty.hasRuntimeBits(zcu);
-        const has_comptime_state = ty.comptimeOnly(zcu) and try ty.onePossibleValue(pt) == null;
+        const has_comptime_state = ty.comptimeOnly(zcu);
         try wip_nav.abbrevCode(if (has_runtime_bits and has_comptime_state) switch (tag) {
             .comptime_arg => if (opt_name) |_| .comptime_arg_runtime_bits_comptime_state else .unnamed_comptime_arg_runtime_bits_comptime_state,
             .local_const => if (opt_name) |_| .local_const_runtime_bits_comptime_state else unreachable,
@@ -2108,7 +2108,7 @@ pub const WipNav = struct {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         const ty = value.typeOf(zcu);
-        if (std.debug.runtime_safety) assert(ty.comptimeOnly(zcu) and try ty.onePossibleValue(wip_nav.pt) == null);
+        if (std.debug.runtime_safety) assert(ty.comptimeOnly(zcu));
         if (ty.toIntern() == .type_type) return wip_nav.getTypeEntry(value.toType());
         if (ip.isFunctionType(ty.toIntern()) and !value.isUndef(zcu)) return wip_nav.getNavEntry(switch (ip.indexToKey(value.toIntern())) {
             else => unreachable,
@@ -2705,7 +2705,7 @@ fn initWipNavInner(
                 try wip_nav.refType(.fromInterned(if (maybe_func_type) |func_type| func_type.return_type else @"extern".ty));
                 if (maybe_func_type) |func_type| {
                     try wip_nav.infoAddrSym(sym_index, 0);
-                    try diw.writeByte(@intFromBool(ip.isNoReturn(func_type.return_type)));
+                    try diw.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu)));
                     if (func_type.param_types.len > 0 or func_type.is_var_args) {
                         for (func_type.param_types.get(ip)) |param_type| {
                             try wip_nav.abbrevCode(.extern_param);
@@ -2733,7 +2733,7 @@ fn initWipNavInner(
                     try wip_nav.strp(@"extern".name.toSlice(ip));
                     try wip_nav.refType(.fromInterned(func_type.return_type));
                     try wip_nav.infoAddrSym(sym_index, 0);
-                    try diw.writeByte(@intFromBool(ip.isNoReturn(func_type.return_type)));
+                    try diw.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu)));
                     if (func_type.param_types.len > 0 or func_type.is_var_args) {
                         for (func_type.param_types.get(ip)) |param_type| {
                             try wip_nav.abbrevCode(.extern_param);
@@ -2818,7 +2818,7 @@ fn initWipNavInner(
                 else => |a| a.maxStrict(target_info.minFunctionAlignment(target)),
             }.toByteUnits().?);
             try diw.writeByte(@intFromBool(decl.linkage != .normal));
-            try diw.writeByte(@intFromBool(ip.isNoReturn(func_type.return_type)));
+            try diw.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu)));
 
             const dlw = &wip_nav.debug_line.writer;
             try dlw.writeByte(DW.LNS.extended_op);
@@ -3172,7 +3172,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                                 .none => .{ false, false },
                                 else => .{
                                     field_type.hasRuntimeBits(zcu),
-                                    field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null,
+                                    field_type.comptimeOnly(zcu),
                                 },
                             };
                             try wip_nav.abbrevCode(if (is_comptime)
@@ -3294,7 +3294,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             try diw.writeUleb128(union_layout.abi_size);
             try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
             const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
-            if (loaded_union.runtime_tag != .none) {
+            if (loaded_union.has_runtime_tag) {
                 try wip_nav.abbrevCode(.tagged_union);
                 try wip_nav.infoSectionOffset(
                     .debug_info,
@@ -3371,7 +3371,6 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -3465,7 +3464,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             const diw = &wip_nav.debug_info.writer;
             const nav_ty = nav_val.typeOf(zcu);
             const has_runtime_bits = nav_ty.hasRuntimeBits(zcu);
-            const has_comptime_state = nav_ty.comptimeOnly(zcu) and try nav_ty.onePossibleValue(pt) == null;
+            const has_comptime_state = nav_ty.comptimeOnly(zcu);
             try wip_nav.declCommon(if (has_runtime_bits and has_comptime_state) .{
                 .decl = .decl_const_runtime_bits_comptime_state,
                 .generic_decl = .generic_decl_const,
@@ -3845,7 +3844,7 @@ fn updateLazyType(
                     .none => .{ false, false },
                     else => .{
                         field_type.hasRuntimeBits(zcu),
-                        field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null,
+                        field_type.comptimeOnly(zcu),
                     },
                 };
                 try wip_nav.abbrevCode(if (has_comptime_state)
@@ -4008,7 +4007,6 @@ fn updateLazyType(
         .error_union,
         .enum_literal,
         .enum_tag,
-        .empty_enum_value,
         .float,
         .ptr,
         .slice,
@@ -4128,7 +4126,7 @@ fn updateLazyValue(
                 .payload => |payload_val| {
                     const payload_type: Type = .fromInterned(ip.typeOf(payload_val));
                     const has_runtime_bits = payload_type.hasRuntimeBits(zcu);
-                    const has_comptime_state = payload_type.comptimeOnly(zcu) and try payload_type.onePossibleValue(pt) == null;
+                    const has_comptime_state = payload_type.comptimeOnly(zcu);
                     try wip_nav.abbrevCode(if (has_comptime_state)
                         .comptime_value_field_comptime_state
                     else if (has_runtime_bits)
@@ -4164,7 +4162,6 @@ fn updateLazyValue(
             }, .fromInterned(int.ty), Value.fromInterned(value_index).toBigInt(&big_int_space, zcu));
             try wip_nav.refType(.fromInterned(enum_tag.ty));
         },
-        .empty_enum_value => unreachable,
         .float => |float| {
             switch (float.storage) {
                 .f16 => |f16_val| {
@@ -4209,7 +4206,7 @@ fn updateLazyValue(
                         .comptime_alloc, .comptime_field => unreachable,
                         .uav => |uav| {
                             const uav_ty: Type = .fromInterned(ip.typeOf(uav.val));
-                            if (try uav_ty.onePossibleValue(pt)) |_| {
+                            if (uav_ty.classify(zcu) == .one_possible_value) {
                                 try wip_nav.abbrevCode(if (zero_bit_accesses.items.len > 0)
                                     .aggregate_udata_comptime_value
                                 else
@@ -4337,7 +4334,7 @@ fn updateLazyValue(
             }
             if (opt.val != .none) child_field: {
                 const has_runtime_bits = opt_child_type.hasRuntimeBits(zcu);
-                const has_comptime_state = opt_child_type.comptimeOnly(zcu) and try opt_child_type.onePossibleValue(pt) == null;
+                const has_comptime_state = opt_child_type.comptimeOnly(zcu);
                 try wip_nav.abbrevCode(if (has_comptime_state)
                     .comptime_value_field_comptime_state
                 else if (has_runtime_bits)
@@ -4363,7 +4360,7 @@ fn updateLazyValue(
                         if (loaded_struct_type.field_is_comptime_bits.get(ip, field_index)) continue;
                         const field_type: Type = .fromInterned(loaded_struct_type.field_types.get(ip)[field_index]);
                         const has_runtime_bits = field_type.hasRuntimeBits(zcu);
-                        const has_comptime_state = field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null;
+                        const has_comptime_state = field_type.comptimeOnly(zcu);
                         try wip_nav.abbrevCode(if (has_comptime_state)
                             .comptime_value_field_comptime_state
                         else if (has_runtime_bits)
@@ -4386,7 +4383,7 @@ fn updateLazyValue(
                     if (tuple_type.values.get(ip)[field_index] != .none) continue;
                     const field_type: Type = .fromInterned(tuple_type.types.get(ip)[field_index]);
                     const has_runtime_bits = field_type.hasRuntimeBits(zcu);
-                    const has_comptime_state = field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null;
+                    const has_comptime_state = field_type.comptimeOnly(zcu);
                     try wip_nav.abbrevCode(if (has_comptime_state)
                         .comptime_value_field_comptime_state
                     else if (has_runtime_bits)
@@ -4411,7 +4408,7 @@ fn updateLazyValue(
                 inline .array_type, .vector_type => |sequence_type| {
                     const child_type: Type = .fromInterned(sequence_type.child);
                     const has_runtime_bits = child_type.hasRuntimeBits(zcu);
-                    const has_comptime_state = child_type.comptimeOnly(zcu) and try child_type.onePossibleValue(pt) == null;
+                    const has_comptime_state = child_type.comptimeOnly(zcu);
                     for (switch (aggregate.storage) {
                         .bytes => unreachable,
                         .elems => |elems| elems,
@@ -4443,7 +4440,7 @@ fn updateLazyValue(
                 const field_ty: Type = .fromInterned(loaded_union_type.field_types.get(ip)[field_index]);
                 const field_name = ip.loadEnumType(loaded_union_type.enum_tag_type).field_names.get(ip)[field_index];
                 const has_runtime_bits = field_ty.hasRuntimeBits(zcu);
-                const has_comptime_state = field_ty.comptimeOnly(zcu) and try field_ty.onePossibleValue(pt) == null;
+                const has_comptime_state = field_ty.comptimeOnly(zcu);
                 try wip_nav.abbrevCode(if (has_comptime_state)
                     .comptime_value_field_comptime_state
                 else if (has_runtime_bits)
@@ -4540,7 +4537,7 @@ fn updateContainerTypeWriterError(
                     .none => .{ false, false },
                     else => .{
                         field_type.hasRuntimeBits(zcu),
-                        field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null,
+                        field_type.comptimeOnly(zcu),
                     },
                 };
                 try wip_nav.abbrevCode(if (is_comptime)
@@ -4647,7 +4644,7 @@ fn updateContainerTypeWriterError(
                                     .none => .{ false, false },
                                     else => .{
                                         field_type.hasRuntimeBits(zcu),
-                                        field_type.comptimeOnly(zcu) and try field_type.onePossibleValue(pt) == null,
+                                        field_type.comptimeOnly(zcu),
                                     },
                                 };
                                 try wip_nav.abbrevCode(if (is_comptime)
@@ -4724,7 +4721,7 @@ fn updateContainerTypeWriterError(
                 try diw.writeUleb128(union_layout.abi_size);
                 try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
                 const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
-                if (loaded_union.runtime_tag != .none) {
+                if (loaded_union.has_runtime_tag) {
                     try wip_nav.abbrevCode(.tagged_union);
                     try wip_nav.infoSectionOffset(
                         .debug_info,
diff --git a/src/print_value.zig b/src/print_value.zig
index d472472481350ff57a47ed3277c6a54cc161d374..d05fe09ec15416b21e5adfe7324f6375fd6d6ff5 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -73,7 +73,6 @@ pub fn print(
         .simple_value => |simple_value| switch (simple_value) {
             .void => try writer.writeAll("{}"),
 
-            .undefined,
             .null,
             .true,
             .false,
@@ -111,7 +110,6 @@ pub fn print(
             try print(Value.fromInterned(enum_tag.int), writer, level - 1, pt, opt_sema);
             try writer.writeAll(")");
         },
-        .empty_enum_value => try writer.writeAll("(empty enum value)"),
         .float => |float| switch (float.storage) {
             inline else => |x| try writer.print("{d}", .{@as(f64, @floatCast(x))}),
         },
-- 
2.54.0


From 8eefe86939e917e4e85049325bff8c5a43f50f95 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 29 Jan 2026 18:11:19 +0000
Subject: [PATCH 424/499] std: remove default values from ArrayList

These were deprecated in the 0.14.0 release cycle almost a year ago, so
they can definitely be deleted now.
---
 lib/std/Build/Fuzz.zig                   |  4 ++--
 lib/std/Build/Module.zig                 | 14 +++++++-------
 lib/std/Build/Step.zig                   |  2 +-
 lib/std/Build/Step/Run.zig               |  8 ++++----
 lib/std/Build/Step/UpdateSourceFiles.zig |  2 +-
 lib/std/Build/Step/WriteFile.zig         |  4 ++--
 lib/std/Io/Dir.zig                       |  2 +-
 lib/std/array_list.zig                   |  4 ++--
 lib/std/compress/lzma.zig                |  2 +-
 lib/std/compress/lzma2.zig               |  2 +-
 lib/std/debug/Coverage.zig               |  6 +++---
 lib/std/zig/Ast.zig                      |  8 ++++----
 lib/std/zig/AstGen.zig                   |  2 +-
 lib/std/zig/ErrorBundle.zig              | 12 ++++++------
 src/Package/Manifest.zig                 |  6 +++---
 15 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index b2477f50884b34100e772960ca4a2c387ddd0008..e4104661add503c549ef09fbb3b16244683a9ce4 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -390,7 +390,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
         .coverage = std.debug.Coverage.init,
         .mapped_memory = undefined, // populated below
         .source_locations = undefined, // populated below
-        .entry_points = .{},
+        .entry_points = .empty,
         .start_timestamp = ws.now(),
         .start_n_runs = undefined, // populated below
     };
@@ -450,7 +450,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
 
     // Unfortunately the PCs array that LLVM gives us from the 8-bit PC
     // counters feature is not sorted.
-    var sorted_pcs: std.MultiArrayList(struct { pc: u64, index: u32, sl: Coverage.SourceLocation }) = .{};
+    var sorted_pcs: std.MultiArrayList(struct { pc: u64, index: u32, sl: Coverage.SourceLocation }) = .empty;
     defer sorted_pcs.deinit(gpa);
     try sorted_pcs.resize(gpa, pcs.len);
     @memcpy(sorted_pcs.items(.pc), pcs);
diff --git a/lib/std/Build/Module.zig b/lib/std/Build/Module.zig
index 657f8bb74eed1773400caa86c66e0b36211fbe1c..959e110c4ad47a5ddd95a508f91a3b49c66636ea 100644
--- a/lib/std/Build/Module.zig
+++ b/lib/std/Build/Module.zig
@@ -275,18 +275,18 @@ pub fn init(
             m.* = .{
                 .owner = owner,
                 .root_source_file = if (options.root_source_file) |lp| lp.dupe(owner) else null,
-                .import_table = .{},
+                .import_table = .empty,
                 .resolved_target = options.target,
                 .optimize = options.optimize,
                 .link_libc = options.link_libc,
                 .link_libcpp = options.link_libcpp,
                 .dwarf_format = options.dwarf_format,
-                .c_macros = .{},
-                .include_dirs = .{},
-                .lib_paths = .{},
-                .rpaths = .{},
-                .frameworks = .{},
-                .link_objects = .{},
+                .c_macros = .empty,
+                .include_dirs = .empty,
+                .lib_paths = .empty,
+                .rpaths = .empty,
+                .frameworks = .empty,
+                .link_objects = .empty,
                 .strip = options.strip,
                 .unwind_tables = options.unwind_tables,
                 .single_threaded = options.single_threaded,
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index b518826843caad753b23051f92840af7b6143a22..5876614099b38b9608006650b464978a87443b6f 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -250,7 +250,7 @@ pub fn init(options: StepOptions) Step {
             const first_ret_addr = options.first_ret_addr orelse @returnAddress();
             break :blk std.debug.captureCurrentStackTrace(.{ .first_address = first_ret_addr }, addr_buf);
         },
-        .result_error_msgs = .{},
+        .result_error_msgs = .empty,
         .result_error_bundle = std.zig.ErrorBundle.empty,
         .result_stderr = "",
         .result_cached = false,
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 8a21e6fef9b3da523b2ad087008b805c7da0e676..63c9f4e6d4c823a32d0d348935c44be2cec84eb9 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -213,13 +213,13 @@ pub fn create(owner: *std.Build, name: []const u8) *Run {
             .owner = owner,
             .makeFn = make,
         }),
-        .argv = .{},
+        .argv = .empty,
         .cwd = null,
         .environ_map = null,
         .disable_zig_progress = false,
         .stdio = .infer_from_args,
         .stdin = .none,
-        .file_inputs = .{},
+        .file_inputs = .empty,
         .rename_step_with_output_arg = true,
         .skip_foreign_checks = false,
         .failing_to_execute_foreign_is_an_error = true,
@@ -228,7 +228,7 @@ pub fn create(owner: *std.Build, name: []const u8) *Run {
         .captured_stderr = null,
         .dep_output_file = null,
         .has_side_effects = false,
-        .fuzz_tests = .{},
+        .fuzz_tests = .empty,
         .rebuilt_executable = null,
         .producer = null,
     };
@@ -642,7 +642,7 @@ pub fn addCheck(run: *Run, new_check: StdIo.Check) void {
 
     switch (run.stdio) {
         .infer_from_args => {
-            run.stdio = .{ .check = .{} };
+            run.stdio = .{ .check = .empty };
             run.stdio.check.append(b.allocator, new_check) catch @panic("OOM");
         },
         .check => |*checks| checks.append(b.allocator, new_check) catch @panic("OOM"),
diff --git a/lib/std/Build/Step/UpdateSourceFiles.zig b/lib/std/Build/Step/UpdateSourceFiles.zig
index 1c4c94f9cf65c1167d72a0ac92c8c5c9ec17a805..0cc3b787c3f8416c284b0977ea9e73b9bf405fd7 100644
--- a/lib/std/Build/Step/UpdateSourceFiles.zig
+++ b/lib/std/Build/Step/UpdateSourceFiles.zig
@@ -35,7 +35,7 @@ pub fn create(owner: *std.Build) *UpdateSourceFiles {
             .owner = owner,
             .makeFn = make,
         }),
-        .output_source_files = .{},
+        .output_source_files = .empty,
     };
     return usf;
 }
diff --git a/lib/std/Build/Step/WriteFile.zig b/lib/std/Build/Step/WriteFile.zig
index 0c0e2b5d8637c10a5c6acae515927c84d690c371..3613fa3fef8fa5ac1a5587a4c4cdcca96661b7b6 100644
--- a/lib/std/Build/Step/WriteFile.zig
+++ b/lib/std/Build/Step/WriteFile.zig
@@ -94,8 +94,8 @@ pub fn create(owner: *std.Build) *WriteFile {
             .owner = owner,
             .makeFn = make,
         }),
-        .files = .{},
-        .directories = .{},
+        .files = .empty,
+        .directories = .empty,
         .generated_directory = .{ .step = &write_file.step },
     };
     return write_file;
diff --git a/lib/std/Io/Dir.zig b/lib/std/Io/Dir.zig
index 85ab6b77d4990420c32086efaf634dc0fc830938..3e38849f7f60fa80cdd4b3903ccc4e5f07ad4d12 100644
--- a/lib/std/Io/Dir.zig
+++ b/lib/std/Io/Dir.zig
@@ -334,7 +334,7 @@ pub fn walkSelectively(dir: Dir, allocator: Allocator) !SelectiveWalker {
 
     return .{
         .stack = stack,
-        .name_buffer = .{},
+        .name_buffer = .empty,
         .allocator = allocator,
     };
 }
diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index f15388d7b5df62c3112b4ab0902ee587425c0442..d763233beda0ec7805ed71af07932bfe88fecf8a 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -582,10 +582,10 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
         /// functions of this ArrayList in accordance with the respective
         /// documentation. In all cases, "invalidated" means that the memory
         /// has been passed to an allocator's resize or free function.
-        items: Slice = &[_]T{},
+        items: Slice,
         /// How many T values this list can hold without allocating
         /// additional memory.
-        capacity: usize = 0,
+        capacity: usize,
 
         /// An ArrayList containing no elements.
         pub const empty: Self = .{
diff --git a/lib/std/compress/lzma.zig b/lib/std/compress/lzma.zig
index 7a586298bea5f7b3db346ce9e5cccb834cb05e47..4e3c6146167868e04f257cdec38cb9eb83ae642a 100644
--- a/lib/std/compress/lzma.zig
+++ b/lib/std/compress/lzma.zig
@@ -349,7 +349,7 @@ pub const Decode = struct {
 
         pub fn init(dict_size: usize, mem_limit: usize) CircularBuffer {
             return .{
-                .buf = .{},
+                .buf = .empty,
                 .dict_size = dict_size,
                 .mem_limit = mem_limit,
                 .cursor = 0,
diff --git a/lib/std/compress/lzma2.zig b/lib/std/compress/lzma2.zig
index 7d743f9a1b6c87c06b0aeca93cd8019eb0b75404..42c887c042bac9b239036e2f7bbfbb1657966b20 100644
--- a/lib/std/compress/lzma2.zig
+++ b/lib/std/compress/lzma2.zig
@@ -16,7 +16,7 @@ pub const AccumBuffer = struct {
 
     pub fn init(memlimit: usize) AccumBuffer {
         return .{
-            .buf = .{},
+            .buf = .empty,
             .memlimit = memlimit,
             .len = 0,
         };
diff --git a/lib/std/debug/Coverage.zig b/lib/std/debug/Coverage.zig
index 81dfce853e0e66c706be73f09407de80d37f339f..b3e16382cc45dff17d34b9bf57f7accb63d918e5 100644
--- a/lib/std/debug/Coverage.zig
+++ b/lib/std/debug/Coverage.zig
@@ -27,10 +27,10 @@ string_bytes: std.ArrayList(u8),
 mutex: Io.Mutex,
 
 pub const init: Coverage = .{
-    .directories = .{},
-    .files = .{},
+    .directories = .empty,
+    .files = .empty,
     .mutex = .init,
-    .string_bytes = .{},
+    .string_bytes = .empty,
 };
 
 pub const String = enum(u32) {
diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig
index 3c039b5fe5a54be45e0ca9c4bcee2ba9699a7f57..8620df51fa0dea04e3c075951bf0df0c161dd363 100644
--- a/lib/std/zig/Ast.zig
+++ b/lib/std/zig/Ast.zig
@@ -175,10 +175,10 @@ pub fn parseTokens(
         .source = source,
         .gpa = gpa,
         .tokens = tokens,
-        .errors = .{},
-        .nodes = .{},
-        .extra_data = .{},
-        .scratch = .{},
+        .errors = .empty,
+        .nodes = .empty,
+        .extra_data = .empty,
+        .scratch = .empty,
         .tok_i = 0,
     };
     defer parser.errors.deinit(gpa);
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 046330c46bedffaa8d16036ccb041264373c34b7..1fcb9f5eb2aac77802763ac742913899c71ede4e 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -1780,7 +1780,7 @@ fn structInitExpr(
                 try gop.value_ptr.append(sfba_allocator, name_token);
                 any_duplicate = true;
             } else {
-                gop.value_ptr.* = .{};
+                gop.value_ptr.* = .empty;
                 try gop.value_ptr.append(sfba_allocator, name_token);
             }
         }
diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
index c5275729ae5f1a6efd58ff65b813cc98863b49ff..64aafd110efb9a4d8247450ac85049286871e05a 100644
--- a/lib/std/zig/ErrorBundle.zig
+++ b/lib/std/zig/ErrorBundle.zig
@@ -340,9 +340,9 @@ pub const Wip = struct {
     pub fn init(wip: *Wip, gpa: Allocator) !void {
         wip.* = .{
             .gpa = gpa,
-            .string_bytes = .{},
-            .extra = .{},
-            .root_list = .{},
+            .string_bytes = .empty,
+            .extra = .empty,
+            .root_list = .empty,
         };
 
         // So that 0 can be used to indicate a null string.
@@ -371,9 +371,9 @@ pub const Wip = struct {
             wip.deinit();
             wip.* = .{
                 .gpa = gpa,
-                .string_bytes = .{},
-                .extra = .{},
-                .root_list = .{},
+                .string_bytes = .empty,
+                .extra = .empty,
+                .root_list = .empty,
             };
             return empty;
         }
diff --git a/src/Package/Manifest.zig b/src/Package/Manifest.zig
index 3370ef1d47dd6c771c5428adabe7160ea4964992..90d61c963b8a6ac8d6f62028f1e37f4d38a70fb5 100644
--- a/src/Package/Manifest.zig
+++ b/src/Package/Manifest.zig
@@ -66,7 +66,7 @@ pub fn parse(gpa: Allocator, ast: *const Ast, rng: std.Random, options: ParseOpt
         .gpa = gpa,
         .ast = ast.*,
         .arena = arena_instance.allocator(),
-        .errors = .{},
+        .errors = .empty,
 
         .name = undefined,
         .id = 0,
@@ -74,10 +74,10 @@ pub fn parse(gpa: Allocator, ast: *const Ast, rng: std.Random, options: ParseOpt
         .version_node = undefined,
         .dependencies = .{},
         .dependencies_node = .none,
-        .paths = .{},
+        .paths = .empty,
         .allow_missing_paths_field = options.allow_missing_paths_field,
         .minimum_zig_version = null,
-        .buf = .{},
+        .buf = .empty,
     };
     defer p.buf.deinit(gpa);
     defer p.errors.deinit(gpa);
-- 
2.54.0


From 650185692dc6fb6b9c2c4e591d37cb94410972e1 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 29 Jan 2026 18:44:25 +0000
Subject: [PATCH 425/499] compiler: merge struct default value resolution into
 layout resolution

This actually doesn't cause any dependency loops in std, which is pretty
much my benchmark for it being acceptable. This can be reverted if it
turns out to be problematic, but for now, let's err on the side of
language simplicity.

To be clear, this *does* regress some cases which previously worked: I
will have to remove some behavior tests as a result of this commit. To
be honest, the tests which look to be failing as a result of this are
things which I think are generally unadvisable; I actually reckon a bit
more friction to use default field values in non-trivial ways might be a
good thing to stop people from misusing them as much. Struct fields
should very rarely have default values; about the only common situation
where they make sense is "options" structs.
---
 src/Air/Liveness.zig           |   8 +-
 src/Compilation.zig            |   9 +-
 src/IncrementalDebugServer.zig |   4 +-
 src/InternPool.zig             |  87 +--------------
 src/Sema.zig                   |  68 +++++-------
 src/Sema/LowerZon.zig          |   1 -
 src/Sema/type_resolution.zig   | 189 ++++++++-------------------------
 src/Zcu.zig                    |   8 +-
 src/Zcu/PerThread.zig          | 122 ++-------------------
 src/codegen/c/Type.zig         |  12 +--
 src/link/Elf/Object.zig        |   2 +-
 src/link/Elf/ZigObject.zig     |   6 +-
 src/link/MachO/ZigObject.zig   |   4 +-
 src/link/Wasm.zig              |   4 +-
 src/main.zig                   |  18 ++--
 15 files changed, 120 insertions(+), 422 deletions(-)

diff --git a/src/Air/Liveness.zig b/src/Air/Liveness.zig
index 5c98dc96fca8c54208556eff486475cede9513a6..384a056988b40b6a59fc4f9a582c7869bf994d3e 100644
--- a/src/Air/Liveness.zig
+++ b/src/Air/Liveness.zig
@@ -153,8 +153,8 @@ pub fn analyze(zcu: *Zcu, air: Air, intern_pool: *InternPool) Allocator.Error!Li
             usize,
             (air.instructions.len * bpi + @bitSizeOf(usize) - 1) / @bitSizeOf(usize),
         ),
-        .extra = .{},
-        .special = .{},
+        .extra = .empty,
+        .special = .empty,
         .intern_pool = intern_pool,
     };
     errdefer gpa.free(a.tomb_bits);
@@ -175,7 +175,7 @@ pub fn analyze(zcu: *Zcu, air: Air, intern_pool: *InternPool) Allocator.Error!Li
         var data: LivenessPassData(.main_analysis) = .{};
         defer data.deinit(gpa);
         data.old_extra = a.extra;
-        a.extra = .{};
+        a.extra = .empty;
         try analyzeBody(&a, .main_analysis, &data, main_body);
         assert(data.live_set.count() == 0);
     }
@@ -1360,7 +1360,7 @@ fn analyzeInstSwitchBr(
             const mirrored_deaths = try gpa.alloc(DeathList, ncases + 1);
             defer gpa.free(mirrored_deaths);
 
-            @memset(mirrored_deaths, .{});
+            @memset(mirrored_deaths, .empty);
             defer for (mirrored_deaths) |*md| md.deinit(gpa);
 
             {
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 64afabc76394a03c4b421345213ce9a189be34de..ba8a2907f9116e618941b6bad6e1cf2f35f76a7f 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3713,7 +3713,6 @@ const Header = extern struct {
         nav_val_deps_len: u32,
         nav_ty_deps_len: u32,
         type_layout_deps_len: u32,
-        struct_defaults_deps_len: u32,
         func_ies_deps_len: u32,
         zon_file_deps_len: u32,
         embed_file_deps_len: u32,
@@ -3763,7 +3762,6 @@ pub fn saveState(comp: *Compilation) !void {
                 .nav_val_deps_len = @intCast(ip.nav_val_deps.count()),
                 .nav_ty_deps_len = @intCast(ip.nav_ty_deps.count()),
                 .type_layout_deps_len = @intCast(ip.type_layout_deps.count()),
-                .struct_defaults_deps_len = @intCast(ip.struct_defaults_deps.count()),
                 .func_ies_deps_len = @intCast(ip.func_ies_deps.count()),
                 .zon_file_deps_len = @intCast(ip.zon_file_deps.count()),
                 .embed_file_deps_len = @intCast(ip.embed_file_deps.count()),
@@ -3788,7 +3786,7 @@ pub fn saveState(comp: *Compilation) !void {
             },
         });
 
-        try bufs.ensureTotalCapacityPrecise(26 + 9 * pt_headers.items.len);
+        try bufs.ensureTotalCapacityPrecise(24 + 9 * pt_headers.items.len);
         addBuf(&bufs, mem.asBytes(&header));
         addBuf(&bufs, @ptrCast(pt_headers.items));
 
@@ -3800,8 +3798,6 @@ pub fn saveState(comp: *Compilation) !void {
         addBuf(&bufs, @ptrCast(ip.nav_ty_deps.values()));
         addBuf(&bufs, @ptrCast(ip.type_layout_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.type_layout_deps.values()));
-        addBuf(&bufs, @ptrCast(ip.struct_defaults_deps.keys()));
-        addBuf(&bufs, @ptrCast(ip.struct_defaults_deps.values()));
         addBuf(&bufs, @ptrCast(ip.func_ies_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.func_ies_deps.values()));
         addBuf(&bufs, @ptrCast(ip.zon_file_deps.keys()));
@@ -4481,7 +4477,7 @@ pub fn addModuleErrorMsg(
                 const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
                     .@"comptime" => "comptime",
                     .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
-                    .type_layout, .struct_defaults => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
+                    .type_layout => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
                     .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
                     .memoized_state => null,
                 };
@@ -5251,7 +5247,6 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav),
                 .nav_val => |nav| pt.ensureNavValUpToDate(nav),
                 .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty)),
-                .struct_defaults => |ty| pt.ensureStructDefaultsUpToDate(.fromInterned(ty)),
                 .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage),
                 .func => |func| pt.ensureFuncBodyUpToDate(func),
             };
diff --git a/src/IncrementalDebugServer.zig b/src/IncrementalDebugServer.zig
index 7d0dc8e89b6fd9fd257733839e924de1ce92a25f..782b34320586299b259336e70cca63d9fba32376 100644
--- a/src/IncrementalDebugServer.zig
+++ b/src/IncrementalDebugServer.zig
@@ -307,7 +307,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const
             switch (dependee) {
                 .src_hash, .namespace, .namespace_name, .zon_file, .embed_file => try w.print("{f}", .{zcu.fmtDependee(dependee)}),
                 .nav_val, .nav_ty => |nav| try w.print("{t} {d}", .{ dependee, @intFromEnum(nav) }),
-                .type_layout, .struct_defaults, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
+                .type_layout, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
                 .memoized_state => |stage| try w.print("memoized_state {s}", .{@tagName(stage)}),
             }
             try w.writeByte('\n');
@@ -374,8 +374,6 @@ fn parseAnalUnit(str: []const u8) ?AnalUnit {
         return .wrap(.{ .nav_ty = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "type_layout")) {
         return .wrap(.{ .type_layout = @enumFromInt(parseIndex(idx_str) orelse return null) });
-    } else if (std.mem.eql(u8, kind, "struct_defaults")) {
-        return .wrap(.{ .struct_defaults = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "func")) {
         return .wrap(.{ .func = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "memoized_state")) {
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 31e37dd98e80f38e1141ce70d86940511cfe1914..388d0a04f74fd88f6b479395044c84a90d351469 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -54,9 +54,6 @@ func_ies_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
 /// Dependencies on the resolved layout of a `struct`, `union`, or `enum` type.
 /// Value is index into `dep_entries` of the first dependency on this type's layout.
 type_layout_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
-/// Dependencies on the resolved default field values of a `struct` type.
-/// Value is index into `dep_entries` of the first dependency on this type's inits.
-struct_defaults_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
 /// Dependencies on a ZON file. Triggered by `@import` of ZON.
 /// Value is index into `dep_entries` of the first dependency on this ZON file.
 zon_file_deps: std.AutoArrayHashMapUnmanaged(FileIndex, DepEntry.Index),
@@ -111,7 +108,6 @@ pub const empty: InternPool = .{
     .nav_ty_deps = .empty,
     .func_ies_deps = .empty,
     .type_layout_deps = .empty,
-    .struct_defaults_deps = .empty,
     .zon_file_deps = .empty,
     .embed_file_deps = .empty,
     .namespace_deps = .empty,
@@ -423,7 +419,6 @@ pub const AnalUnit = packed struct(u64) {
         nav_val,
         nav_ty,
         type_layout,
-        struct_defaults,
         func,
         memoized_state,
     };
@@ -437,8 +432,6 @@ pub const AnalUnit = packed struct(u64) {
         nav_ty: Nav.Index,
         /// This `AnalUnit` resolves the layout of the given `struct`, `union`, or `enum` type.
         type_layout: InternPool.Index,
-        /// This `AnalUnit` resolves the default field values of the given `struct` type.
-        struct_defaults: InternPool.Index,
         /// This `AnalUnit` analyzes the body of the given runtime function.
         func: InternPool.Index,
         /// This `AnalUnit` resolves all state which is memoized in fields on `Zcu`.
@@ -858,7 +851,6 @@ pub const Dependee = union(enum) {
     /// Index is the function, not its IES.
     func_ies: Index,
     type_layout: Index,
-    struct_defaults: Index,
     zon_file: FileIndex,
     embed_file: Zcu.EmbedFile.Index,
     namespace: TrackedInst.Index,
@@ -912,7 +904,6 @@ pub fn dependencyIterator(ip: *const InternPool, dependee: Dependee) DependencyI
         .nav_ty => |x| ip.nav_ty_deps.get(x),
         .func_ies => |x| ip.func_ies_deps.get(x),
         .type_layout => |x| ip.type_layout_deps.get(x),
-        .struct_defaults => |x| ip.struct_defaults_deps.get(x),
         .zon_file => |x| ip.zon_file_deps.get(x),
         .embed_file => |x| ip.embed_file_deps.get(x),
         .namespace => |x| ip.namespace_deps.get(x),
@@ -987,7 +978,6 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend
                 .nav_ty => ip.nav_ty_deps,
                 .func_ies => ip.func_ies_deps,
                 .type_layout => ip.type_layout_deps,
-                .struct_defaults => ip.struct_defaults_deps,
                 .zon_file => ip.zon_file_deps,
                 .embed_file => ip.embed_file_deps,
                 .namespace => ip.namespace_deps,
@@ -3326,15 +3316,6 @@ pub const LoadedStructType = struct {
     /// compiler frontend resolves this by traversing the reference graph at the end of each update
     /// with `Zcu.resolveReferences` and hiding compile errors which arise from this analysis.
     want_layout: bool,
-    /// Initially `false`, and set to `true` once any dependency on or reference to the struct's
-    /// default field values is encountered, after which it is never reset to `false`, even across
-    /// incremental updates.
-    ///
-    /// This field is purely an optimization to avoid resolving the layout of types whose layouts
-    /// are never demanded. If this field is `true` but the layout is not actually needed, the
-    /// compiler frontend resolves this by traversing the reference graph at the end of each update
-    /// with `Zcu.resolveReferences` and hiding compile errors which arise from this analysis.
-    want_defaults: bool,
 
     // The remaining fields are only valid once the struct's layout is resolved.
     field_name_map: MapIndex,
@@ -3711,7 +3692,6 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .packed_backing_mode = undefined,
 
                 .want_layout = extra.data.flags.want_layout,
-                .want_defaults = extra.data.flags.want_defaults,
 
                 .field_name_map = extra.data.field_name_map,
                 .field_names = field_names,
@@ -3772,7 +3752,6 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
         .packed_backing_mode = backing_mode,
 
         .want_layout = extra.data.bits.want_layout,
-        .want_defaults = extra.data.bits.want_defaults,
 
         .field_name_map = extra.data.field_name_map,
         .field_names = field_names,
@@ -5666,9 +5645,8 @@ pub const Tag = enum(u8) {
             alignment: Alignment,
 
             want_layout: bool,
-            want_defaults: bool,
 
-            _: u15 = 0,
+            _: u16 = 0,
         };
     };
 
@@ -5693,12 +5671,11 @@ pub const Tag = enum(u8) {
         field_name_map: MapIndex,
 
         const Bits = packed struct(u32) {
-            captures_len: enum(u30) {
-                reified = std.math.maxInt(u30),
+            captures_len: enum(u31) {
+                reified = std.math.maxInt(u31),
                 _,
             },
             want_layout: bool,
-            want_defaults: bool,
         };
     };
 
@@ -6477,7 +6454,6 @@ pub fn deinit(ip: *InternPool, gpa: Allocator, io: Io) void {
     ip.nav_ty_deps.deinit(gpa);
     ip.func_ies_deps.deinit(gpa);
     ip.type_layout_deps.deinit(gpa);
-    ip.struct_defaults_deps.deinit(gpa);
     ip.zon_file_deps.deinit(gpa);
     ip.embed_file_deps.deinit(gpa);
     ip.namespace_deps.deinit(gpa);
@@ -8191,7 +8167,6 @@ pub fn getDeclaredStructType(
                 .bits = .{
                     .captures_len = @enumFromInt(ini.captures.len),
                     .want_layout = false,
-                    .want_defaults = false,
                 },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
@@ -8256,7 +8231,6 @@ pub fn getDeclaredStructType(
             .class = .no_possible_value,
             .alignment = .none,
             .want_layout = false,
-            .want_defaults = false,
         },
     });
     if (ini.captures.len != 0) {
@@ -8337,7 +8311,6 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe
                 .bits = .{
                     .captures_len = .reified,
                     .want_layout = false,
-                    .want_defaults = false,
                 },
                 .name = undefined, // set by `finish`
                 .name_nav = undefined, // set by `finish`
@@ -8407,7 +8380,6 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe
             .class = .no_possible_value,
             .alignment = .none,
             .want_layout = false,
-            .want_defaults = false,
         },
     });
     _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash
@@ -10647,7 +10619,6 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
     const nav_ty_deps_len = ip.nav_ty_deps.count();
     const func_ies_deps_len = ip.func_ies_deps.count();
     const type_layout_deps_len = ip.type_layout_deps.count();
-    const struct_defaults_deps_len = ip.struct_defaults_deps.count();
     const zon_file_deps_len = ip.zon_file_deps.count();
     const embed_file_deps_len = ip.embed_file_deps.count();
     const namespace_deps_len = ip.namespace_deps.count();
@@ -10658,7 +10629,6 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
     const nav_ty_deps_size = nav_ty_deps_len * 8;
     const func_ies_deps_size = func_ies_deps_len * 8;
     const type_layout_deps_size = type_layout_deps_len * 8;
-    const struct_defaults_deps_size = struct_defaults_deps_len * 8;
     const zon_file_deps_size = zon_file_deps_len * 8;
     const embed_file_deps_size = embed_file_deps_len * 8;
     const namespace_deps_size = namespace_deps_len * 8;
@@ -10672,7 +10642,6 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
         \\  {d} nav_ty: {d} bytes
         \\  {d} func_ies: {d} bytes
         \\  {d} type_layout: {d} bytes
-        \\  {d} struct_defaults: {d} bytes
         \\  {d} zon_file: {d} bytes
         \\  {d} embed_file: {d} bytes
         \\  {d} namespace: {d} bytes
@@ -10680,7 +10649,7 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
         \\
     , .{
         dep_entries_size + src_hash_deps_size + nav_val_deps_size + nav_ty_deps_size +
-            func_ies_deps_size + type_layout_deps_size + struct_defaults_deps_size + zon_file_deps_size +
+            func_ies_deps_size + type_layout_deps_size + zon_file_deps_size +
             embed_file_deps_size + namespace_deps_size + namespace_name_deps_size,
         dep_entries_len,
         dep_entries_size,
@@ -10694,8 +10663,6 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
         func_ies_deps_size,
         type_layout_deps_len,
         type_layout_deps_size,
-        struct_defaults_deps_len,
-        struct_defaults_deps_size,
         zon_file_deps_len,
         zon_file_deps_size,
         embed_file_deps_len,
@@ -11136,7 +11103,7 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator,
             const info = extraData(extra_list, Tag.FuncInstance, data);
 
             const gop = try instances.getOrPut(arena, info.generic_owner);
-            if (!gop.found_existing) gop.value_ptr.* = .{};
+            if (!gop.found_existing) gop.value_ptr.* = .empty;
 
             try gop.value_ptr.append(
                 arena,
@@ -12969,50 +12936,6 @@ pub fn setWantTypeLayout(ip: *InternPool, io: Io, container_type: Index) bool {
     }
 }
 
-/// Like `setWantTypeLayout`, but for the default field values of a struct (so this sets the
-/// `want_defaults` flag rather than the `want_layout` flag).
-pub fn setWantStructDefaults(ip: *InternPool, io: Io, struct_type: Index) bool {
-    const unwrapped_index = struct_type.unwrap(ip);
-
-    const local = ip.getLocal(unwrapped_index.tid);
-    local.mutate.extra.mutex.lockUncancelable(io);
-    defer local.mutate.extra.mutex.unlock(io);
-
-    const extra_items = local.shared.extra.view().items(.@"0");
-    const item = unwrapped_index.getItem(ip);
-    switch (item.tag) {
-        .type_struct_packed_auto,
-        .type_struct_packed_explicit,
-        .type_struct_packed_auto_defaults,
-        .type_struct_packed_explicit_defaults,
-        => {
-            const bits: *Tag.TypeStructPacked.Bits = @ptrCast(&extra_items[
-                item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "bits").?
-            ]);
-            if (bits.want_defaults) {
-                return false;
-            } else {
-                bits.want_defaults = true;
-                return true;
-            }
-        },
-
-        .type_struct => {
-            const flags: *Tag.TypeStruct.Flags = @ptrCast(&extra_items[
-                item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?
-            ]);
-            if (flags.want_defaults) {
-                return false;
-            } else {
-                flags.want_defaults = true;
-                return true;
-            }
-        },
-
-        else => unreachable,
-    }
-}
-
 /// Like `setWantTypeLayout`, but for runtime analysis of a function body, using the
 /// `FuncAnalysis.want_runtime_analysis` flag.
 pub fn setWantRuntimeFnAnalysis(ip: *InternPool, io: Io, func_index: Index) bool {
diff --git a/src/Sema.zig b/src/Sema.zig
index cd6625fdaba233ed72cdbd31b9d79617dd40267d..276a06a938b0c868a183ee2626db940d22cf866d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -4519,10 +4519,6 @@ fn validateStructInit(
         if (explicit) continue;
         if (struct_ty.structFieldIsComptime(i, zcu)) continue;
 
-        if (!struct_ty.isTuple(zcu)) {
-            try sema.ensureStructDefaultsResolved(struct_ty, init_src);
-        }
-
         const default_val = struct_ty.structFieldDefaultValue(i, zcu) orelse {
             const field_name = struct_ty.structFieldName(i, zcu).unwrap() orelse {
                 const template = "missing tuple field with index {d}";
@@ -5180,9 +5176,9 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
     var label: Block.Label = .{
         .zir_block = inst,
         .merges = .{
-            .src_locs = .{},
-            .results = .{},
-            .br_list = .{},
+            .src_locs = .empty,
+            .results = .empty,
+            .br_list = .empty,
             .block_inst = block_inst,
         },
     };
@@ -5254,7 +5250,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
         .parent = parent_block,
         .sema = sema,
         .namespace = parent_block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = parent_block.inlining,
         .comptime_reason = .{ .reason = .{
             .src = src,
@@ -5389,9 +5385,9 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErro
     var label: Block.Label = .{
         .zir_block = inst,
         .merges = .{
-            .src_locs = .{},
-            .results = .{},
-            .br_list = .{},
+            .src_locs = .empty,
+            .results = .empty,
+            .br_list = .empty,
             .block_inst = block_inst,
         },
     };
@@ -5400,7 +5396,7 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErro
         .parent = parent_block,
         .sema = sema,
         .namespace = parent_block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .label = &label,
         .inlining = parent_block.inlining,
         .comptime_reason = parent_block.comptime_reason,
@@ -5839,7 +5835,6 @@ fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
         .nav_val,
         .nav_ty,
         .type_layout,
-        .struct_defaults,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -5858,7 +5853,6 @@ fn zirDisableIntrinsics(sema: *Sema) CompileError!void {
         .nav_val,
         .nav_ty,
         .type_layout,
-        .struct_defaults,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -6870,7 +6864,7 @@ fn analyzeCall(
         .parent = null,
         .sema = sema,
         .namespace = fn_nav.analysis.?.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = &generic_inlining,
         .src_base_inst = fn_nav.analysis.?.zir_index,
         .type_name_ctx = fn_nav.fqn,
@@ -7067,7 +7061,7 @@ fn analyzeCall(
         });
         if (func_ty_info.cc == .auto) {
             switch (sema.owner.unwrap()) {
-                .@"comptime", .nav_ty, .nav_val, .type_layout, .struct_defaults, .memoized_state => {},
+                .@"comptime", .nav_ty, .nav_val, .type_layout, .memoized_state => {},
                 .func => |owner_func| ip.funcSetHasErrorTrace(io, owner_func, true),
             }
         }
@@ -7382,7 +7376,7 @@ fn analyzeCall(
         .parent = null,
         .sema = sema,
         .namespace = fn_nav.analysis.?.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = &inlining,
         .is_typeof = block.is_typeof,
         .comptime_reason = if (block.isComptime()) .inlining_parent else null,
@@ -9945,9 +9939,9 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     var label: Block.Label = .{
         .zir_block = inst,
         .merges = .{
-            .src_locs = .{},
-            .results = .{},
-            .br_list = .{},
+            .src_locs = .empty,
+            .results = .empty,
+            .br_list = .empty,
             .block_inst = block_inst,
         },
     };
@@ -10100,9 +10094,9 @@ fn zirSwitchBlock(
     var label: Block.Label = .{
         .zir_block = inst,
         .merges = .{
-            .src_locs = .{},
-            .results = .{},
-            .br_list = .{},
+            .src_locs = .empty,
+            .results = .empty,
+            .br_list = .empty,
             .block_inst = block_inst,
         },
     };
@@ -16864,7 +16858,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .struct_type => ip.loadStructType(ty.toIntern()),
                     else => unreachable,
                 };
-                try sema.ensureStructDefaultsResolved(ty, src); // can't do this sooner, since it's not allowed on tuples
                 struct_field_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len);
 
                 for (struct_field_vals, 0..) |*field_val, field_index| {
@@ -17122,7 +17115,7 @@ fn zirTypeofBuiltin(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
         .parent = block,
         .sema = sema,
         .namespace = block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = block.inlining,
         .comptime_reason = null,
         .is_typeof = true,
@@ -17190,7 +17183,7 @@ fn zirTypeofPeer(
         .parent = block,
         .sema = sema,
         .namespace = block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = block.inlining,
         .comptime_reason = null,
         .is_typeof = true,
@@ -17764,9 +17757,9 @@ fn ensurePostHoc(sema: *Sema, block: *Block, dest_block: Zir.Inst.Index) !*Label
         .label = .{
             .zir_block = dest_block,
             .merges = .{
-                .src_locs = .{},
-                .results = .{},
-                .br_list = .{},
+                .src_locs = .empty,
+                .results = .empty,
+                .br_list = .empty,
                 .block_inst = new_block_inst,
             },
         },
@@ -17774,7 +17767,7 @@ fn ensurePostHoc(sema: *Sema, block: *Block, dest_block: Zir.Inst.Index) !*Label
             .parent = block,
             .sema = sema,
             .namespace = block.namespace,
-            .instructions = .{},
+            .instructions = .empty,
             .label = &labeled_block.label,
             .inlining = block.inlining,
             .comptime_reason = block.comptime_reason,
@@ -18753,8 +18746,6 @@ fn finishStructInit(
                     continue;
                 }
 
-                try sema.ensureStructDefaultsResolved(struct_ty, init_src);
-
                 const field_default: InternPool.Index = d: {
                     if (struct_type.field_defaults.len == 0) break :d .none;
                     break :d struct_type.field_defaults.get(ip)[i];
@@ -19420,7 +19411,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
         .func => |func| if (ip.funcAnalysisUnordered(func).has_error_trace and block.ownerModule().error_tracing) {
             return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
         },
-        .@"comptime", .nav_ty, .nav_val, .type_layout, .struct_defaults, .memoized_state => {},
+        .@"comptime", .nav_ty, .nav_val, .type_layout, .memoized_state => {},
     }
     return Air.internedToRef(try pt.intern(.{ .opt = .{
         .ty = opt_ptr_stack_trace_ty.toIntern(),
@@ -24738,7 +24729,7 @@ fn zirBuiltinExtern(
         // So, for now, just use our containing `declaration`.
         .zir_index = switch (sema.owner.unwrap()) {
             .@"comptime" => |cu| ip.getComptimeUnit(cu).zir_index,
-            .type_layout, .struct_defaults => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
+            .type_layout => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
             .memoized_state => unreachable,
             .nav_ty, .nav_val => |nav| ip.getNav(nav).analysis.?.zir_index,
             .func => |func| zir_index: {
@@ -25230,7 +25221,7 @@ fn getPanicIdFunc(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !In
     try sema.ensureMemoizedStateResolved(src, .panic);
     const panic_fn_index = zcu.builtin_decl_values.get(panic_id.toBuiltin());
     switch (sema.owner.unwrap()) {
-        .@"comptime", .nav_ty, .nav_val, .type_layout, .struct_defaults, .memoized_state => {},
+        .@"comptime", .nav_ty, .nav_val, .type_layout, .memoized_state => {},
         .func => |owner_func| zcu.intern_pool.funcSetHasErrorTrace(io, owner_func, true),
     }
     return panic_fn_index;
@@ -25250,7 +25241,7 @@ fn addSafetyCheck(
         .parent = parent_block,
         .sema = sema,
         .namespace = parent_block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = parent_block.inlining,
         .comptime_reason = null,
         .src_base_inst = parent_block.src_base_inst,
@@ -25344,7 +25335,7 @@ fn addSafetyCheckUnwrapError(
         .parent = parent_block,
         .sema = sema,
         .namespace = parent_block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = parent_block.inlining,
         .comptime_reason = null,
         .src_base_inst = parent_block.src_base_inst,
@@ -25449,7 +25440,7 @@ fn addSafetyCheckCall(
         .parent = parent_block,
         .sema = sema,
         .namespace = parent_block.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = parent_block.inlining,
         .comptime_reason = null,
         .src_base_inst = parent_block.src_base_inst,
@@ -33859,7 +33850,6 @@ const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStor
 
 pub const type_resolution = @import("Sema/type_resolution.zig");
 pub const ensureLayoutResolved = type_resolution.ensureLayoutResolved;
-pub const ensureStructDefaultsResolved = type_resolution.ensureStructDefaultsResolved;
 
 pub fn getBuiltinType(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) SemaError!Type {
     assert(decl.kind() == .type);
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index 71256ae44ddc4e6283171172bfb0cdda3f8eb50e..b755c5daaae8f6ed6688b2529ad563f347b445d4 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -770,7 +770,6 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
     const ip = &pt.zcu.intern_pool;
 
     try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
-    try self.sema.ensureStructDefaultsResolved(res_ty, self.import_loc);
     const struct_info = self.sema.pt.zcu.typeToStruct(res_ty).?;
 
     const fields: @FieldType(Zoir.Node, "struct_literal") = switch (node.get(self.file.zoir.?)) {
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 50f0f7e3156921fa42cae5e80768d067e245b941..2a28d7aa0456e2cdb0d545ff7208ca4e0e615c4f 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -85,30 +85,6 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!vo
     }
 }
 
-/// Asserts that `ty` is a non-tuple `struct` type, and ensures that its fields' default values
-/// are resolved. Adds incremental dependencies tracking the required type resolution.
-///
-/// It is not necessary to call this function to query the values of comptime fields: those values
-/// are available from type *layout* resolution, see `ensureLayoutResolved`.
-pub fn ensureStructDefaultsResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    assert(ip.indexToKey(ty.toIntern()) == .struct_type);
-
-    try sema.declareDependency(.{ .struct_defaults = ty.toIntern() });
-    try sema.addReferenceEntry(null, src, .wrap(.{ .struct_defaults = ty.toIntern() }));
-    if (zcu.analysis_in_progress.contains(.wrap(.{ .struct_defaults = ty.toIntern() }))) {
-        // TODO: better error message
-        return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
-            ty.srcLoc(zcu),
-            "struct '{f}' depends on itself",
-            .{ty.fmt(pt)},
-        ));
-    }
-    try pt.ensureStructDefaultsUpToDate(ty);
-}
-
 /// Asserts that `struct_ty` is a non-packed non-tuple struct, and that `sema.owner` is that type.
 /// This function *does* register the `src_hash` dependency on the struct.
 pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
@@ -129,7 +105,7 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         .parent = null,
         .sema = sema,
         .namespace = struct_obj.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = undefined, // always set before using `block`
         .src_base_inst = struct_obj.zir_index,
@@ -168,6 +144,13 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         @memset(struct_obj.field_is_comptime_bits.getAll(ip), 0);
 
         const zir_struct = sema.code.getStructDecl(zir_index);
+
+        // If we have any default values to resolve, we'll need to map the struct decl instruction
+        // to the result type.
+        if (zir_struct.field_default_body_lens != null) {
+            try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
+        }
+
         var field_it = zir_struct.iterateFields();
         while (field_it.next()) |zir_field| {
             {
@@ -182,18 +165,16 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 struct_obj.field_is_comptime_bits.getAll(ip)[bit_bag_index] |= mask;
             }
 
-            {
+            const field_ty: Type = field_ty: {
                 const field_ty_src = block.src(.{ .container_field_type = zir_field.idx });
-                const field_ty: Type = field_ty: {
-                    block.comptime_reason = .{ .reason = .{
-                        .src = field_ty_src,
-                        .r = .{ .simple = .struct_field_types },
-                    } };
-                    const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
-                    break :field_ty try sema.analyzeAsType(&block, field_ty_src, .struct_field_types, type_ref);
-                };
-                struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
-            }
+                block.comptime_reason = .{ .reason = .{
+                    .src = field_ty_src,
+                    .r = .{ .simple = .struct_field_types },
+                } };
+                const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
+                break :field_ty try sema.analyzeAsType(&block, field_ty_src, .struct_field_types, type_ref);
+            };
+            struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
 
             if (struct_obj.field_aligns.len == 0) {
                 assert(zir_field.align_body == null);
@@ -210,6 +191,31 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 };
                 struct_obj.field_aligns.get(ip)[zir_field.idx] = field_align;
             }
+
+            if (struct_obj.field_defaults.len == 0) {
+                assert(zir_field.default_body == null);
+            } else {
+                const field_default_src = block.src(.{ .container_field_value = zir_field.idx });
+                const field_default: InternPool.Index = d: {
+                    block.comptime_reason = .{ .reason = .{
+                        .src = field_default_src,
+                        .r = .{ .simple = .struct_field_default_value },
+                    } };
+                    const default_body = zir_field.default_body orelse break :d .none;
+                    // Provide the result type
+                    sema.inst_map.putAssumeCapacity(zir_index, .fromType(field_ty));
+                    defer assert(sema.inst_map.remove(zir_index));
+                    const uncoerced_default_val = try sema.resolveInlineBody(&block, default_body, zir_index);
+                    const coerced_default_val = try sema.coerce(&block, field_ty, uncoerced_default_val, field_default_src);
+                    const default_val = try sema.resolveConstValue(&block, field_default_src, coerced_default_val, null);
+                    if (default_val.canMutateComptimeVarState(zcu)) {
+                        const field_name = struct_obj.field_names.get(ip)[zir_field.idx];
+                        return sema.failWithContainsReferenceToComptimeVar(&block, field_default_src, field_name, "field default value", default_val);
+                    }
+                    break :d default_val.toIntern();
+                };
+                struct_obj.field_defaults.get(ip)[zir_field.idx] = field_default;
+            }
         }
     }
 
@@ -357,11 +363,6 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         struct_align,
         class,
     );
-
-    if (any_comptime_fields and !struct_obj.is_reified) {
-        // We also resolve field inits in this case. MLUGG TODO: this sucks, see TODO in resolveStructDefaults
-        return resolveStructDefaultsInner(sema, &block, &struct_obj);
-    }
 }
 
 /// Asserts that `struct_ty` is a packed struct, and that `sema.owner` is that type.
@@ -465,105 +466,6 @@ fn resolvePackedStructLayout(
     );
 }
 
-/// Asserts that `struct_ty` is a non-tuple struct, and that `sema.owner` is that type.
-/// This function *does* register the `src_hash` dependency on the struct.
-pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const ip = &zcu.intern_pool;
-
-    assert(sema.owner.unwrap().struct_defaults == struct_ty.toIntern());
-
-    try sema.ensureLayoutResolved(struct_ty, struct_ty.srcLoc(zcu));
-
-    const struct_obj = ip.loadStructType(struct_ty.toIntern());
-    assert(struct_obj.want_defaults);
-
-    if (struct_obj.is_reified) {
-        // `Sema.zirReifyStruct` has already populated the default field values *and* (by loading
-        // the default values from pointers) validated their types, so we have nothing to do. We
-        // don't even need to mark any dependencies.
-        return;
-    }
-
-    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
-
-    if (struct_obj.field_defaults.len == 0) {
-        // The struct has no default field values, so the slice has been omitted.
-        return;
-    }
-
-    for (struct_obj.field_is_comptime_bits.getAll(ip)) |bit_bag| {
-        if (bit_bag != 0) {
-            // There is a comptime field, so layout resolution already filled in the defaults for us!
-            // MLUGG TODO: perhaps a better idea would be for layout resolution to populate only the defaults *for comptime fields*.
-            return;
-        }
-    }
-
-    var block: Block = .{
-        .parent = null,
-        .sema = sema,
-        .namespace = struct_obj.namespace,
-        .instructions = .{},
-        .inlining = null,
-        .comptime_reason = undefined, // always set before using `block`
-        .src_base_inst = struct_obj.zir_index,
-        .type_name_ctx = struct_obj.name,
-    };
-    defer block.instructions.deinit(gpa);
-
-    return resolveStructDefaultsInner(sema, &block, &struct_obj);
-}
-/// MLUGG TODO: i dislike this, see the 'TODO' in the prev func
-fn resolveStructDefaultsInner(
-    sema: *Sema,
-    block: *Block,
-    struct_obj: *const InternPool.LoadedStructType,
-) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const comp = zcu.comp;
-    const gpa = comp.gpa;
-    const ip = &zcu.intern_pool;
-
-    // We'll need to map the struct decl instruction to provide result types
-    const zir_index = struct_obj.zir_index.resolve(ip) orelse return error.AnalysisFail;
-    try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
-
-    const field_types = struct_obj.field_types.get(ip);
-
-    const zir_struct = sema.code.getStructDecl(zir_index);
-    var field_it = zir_struct.iterateFields();
-    while (field_it.next()) |zir_field| {
-        const default_val_src = block.src(.{ .container_field_value = zir_field.idx });
-        block.comptime_reason = .{ .reason = .{
-            .src = default_val_src,
-            .r = .{ .simple = .struct_field_default_value },
-        } };
-        const default_body = zir_field.default_body orelse {
-            struct_obj.field_defaults.get(ip)[zir_field.idx] = .none;
-            continue;
-        };
-        const field_ty: Type = .fromInterned(field_types[zir_field.idx]);
-        const uncoerced = ref: {
-            // Provide the result type
-            sema.inst_map.putAssumeCapacity(zir_index, .fromIntern(field_ty.toIntern()));
-            defer assert(sema.inst_map.remove(zir_index));
-            break :ref try sema.resolveInlineBody(block, default_body, zir_index);
-        };
-        const coerced = try sema.coerce(block, field_ty, uncoerced, default_val_src);
-        const default_val = try sema.resolveConstValue(block, default_val_src, coerced, null);
-        if (default_val.canMutateComptimeVarState(zcu)) {
-            const field_name = struct_obj.field_names.get(ip)[zir_field.idx];
-            return sema.failWithContainsReferenceToComptimeVar(block, default_val_src, field_name, "field default value", default_val);
-        }
-        struct_obj.field_defaults.get(ip)[zir_field.idx] = default_val.toIntern();
-    }
-}
-
 /// This logic must be kept in sync with `Type.getUnionLayout`.
 pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     const pt = sema.pt;
@@ -583,7 +485,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         .parent = null,
         .sema = sema,
         .namespace = union_obj.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = undefined, // always set before using `block`
         .src_base_inst = union_obj.zir_index,
@@ -1048,7 +950,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
         .parent = null,
         .sema = sema,
         .namespace = enum_obj.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = undefined, // always set before using `block`
         .src_base_inst = tracked_inst,
@@ -1287,8 +1189,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
         }
     }
 
-    // MLUGG TODO: fate of this line rests on whether comptime_int is a valid int tag type
-    if (enum_obj.nonexhaustive and int_tag_ty.toIntern() != .comptime_int_type) {
+    if (enum_obj.nonexhaustive) {
         const fields_len = enum_obj.field_names.len;
         if (fields_len >= 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(zcu)) {
             return sema.fail(&block, block.nodeOffset(.zero), "non-exhaustive enum specifies every value", .{});
diff --git a/src/Zcu.zig b/src/Zcu.zig
index aedbf7043c32aa83d8e7988d8bd3bb2304476632..9ae8e47a754aaf88121af4c800f2601b38fe0589 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -3122,7 +3122,6 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
             .nav_val => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_val = nav }),
             .nav_ty => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_ty = nav }),
             .type_layout => |ty| try zcu.markPoDependeeUpToDate(.{ .type_layout = ty }),
-            .struct_defaults => |ty| try zcu.markPoDependeeUpToDate(.{ .struct_defaults = ty }),
             .func => |func| try zcu.markPoDependeeUpToDate(.{ .func_ies = func }),
             .memoized_state => |stage| try zcu.markPoDependeeUpToDate(.{ .memoized_state = stage }),
         }
@@ -3138,7 +3137,6 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
         .nav_val => |nav| .{ .nav_val = nav },
         .nav_ty => |nav| .{ .nav_ty = nav },
         .type_layout => |ty| .{ .type_layout = ty },
-        .struct_defaults => |ty| .{ .struct_defaults = ty },
         .func => |func_index| .{ .func_ies = func_index },
         .memoized_state => |stage| .{ .memoized_state = stage },
     };
@@ -4116,7 +4114,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?R
                 const other: AnalUnit = .wrap(switch (unit.unwrap()) {
                     .nav_val => |n| .{ .nav_ty = n },
                     .nav_ty => |n| .{ .nav_val = n },
-                    .@"comptime", .type_layout, .struct_defaults, .func, .memoized_state => break :queue_paired,
+                    .@"comptime", .type_layout, .func, .memoized_state => break :queue_paired,
                 });
                 const gop = try units.getOrPut(gpa, other);
                 if (gop.found_existing) break :queue_paired;
@@ -4273,7 +4271,7 @@ fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void
             }
         },
         .nav_val, .nav_ty => |nav, tag| return writer.print("{t}('{f}' [{}])", .{ tag, ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }),
-        .type_layout, .struct_defaults => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
+        .type_layout => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
         .func => |func| {
             const nav = zcu.funcInfo(func).owner_nav;
             return writer.print("func('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(func) });
@@ -4299,7 +4297,7 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void
             const fqn = ip.getNav(nav).fqn;
             return writer.print("{t}('{f}')", .{ tag, fqn.fmt(ip) });
         },
-        .type_layout, .struct_defaults => |ip_index, tag| {
+        .type_layout => |ip_index, tag| {
             const name = Type.fromInterned(ip_index).containerTypeName(ip);
             return writer.print("{t}('{f}')", .{ tag, name.fmt(ip) });
         },
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 46e275045ac39d580acc8bf33dd45e671d19d39f..7de74743c3540370784ee7e26d50f052fa4a679e 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -865,7 +865,7 @@ fn analyzeMemoizedState(pt: Zcu.PerThread, stage: InternPool.MemoizedStateStage)
         .parent = null,
         .sema = &sema,
         .namespace = std_namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = .{ .reason = .{
             .src = src,
@@ -1014,7 +1014,7 @@ fn analyzeComptimeUnit(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu
         .parent = null,
         .sema = &sema,
         .namespace = comptime_unit.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = .{ .reason = .{
             .src = .{
@@ -1152,109 +1152,6 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
     };
 }
 
-/// Ensures that the default values of the given "declared" (not reified) `struct` type are fully
-/// up-to-date, performing re-analysis if necessary. Asserts that `ty` is a struct (not tuple) type.
-/// Returns `error.AnalysisFail` if an analysis error is encountered while resolving the default
-/// field values; the caller is free to ignore this, since the error is already registered.
-pub fn ensureStructDefaultsUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
-
-    assert(ty.zigTypeTag(zcu) == .@"struct");
-    assert(!ty.isTuple(zcu));
-
-    const anal_unit: AnalUnit = .wrap(.{ .struct_defaults = ty.toIntern() });
-
-    log.debug("ensureStructDefaultsUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
-
-    assert(!zcu.analysis_in_progress.contains(anal_unit));
-
-    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit) or
-        zcu.intern_pool.setWantStructDefaults(zcu.comp.io, ty.toIntern());
-
-    if (was_outdated) {
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
-        // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
-        if (dev.env.supports(.incremental)) {
-            zcu.deleteUnitExports(anal_unit);
-            zcu.deleteUnitReferences(anal_unit);
-            zcu.deleteUnitCompileLogs(anal_unit);
-            if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-                kv.value.destroy(gpa);
-            }
-            _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
-            zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
-        }
-        // For types, we already know that we have to invalidate all dependees.
-        // TODO: we actually *could* detect whether everything was the same. should we bother?
-        try zcu.markDependeeOutdated(.marked_po, .{ .struct_defaults = ty.toIntern() });
-    } else {
-        // We can trust the current information about this unit.
-        if (zcu.failed_analysis.contains(anal_unit)) return error.AnalysisFail;
-        if (zcu.transitive_failed_analysis.contains(anal_unit)) return error.AnalysisFail;
-        return;
-    }
-
-    if (zcu.comp.debugIncremental()) {
-        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, anal_unit);
-        info.last_update_gen = zcu.generation;
-        info.deps.clearRetainingCapacity();
-    }
-
-    const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(&zcu.intern_pool).toSlice(&zcu.intern_pool), null);
-    defer unit_tracking.end(zcu);
-
-    try zcu.analysis_in_progress.put(gpa, anal_unit, {});
-    defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
-
-    var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
-    defer analysis_arena.deinit();
-
-    var comptime_err_ret_trace: std.array_list.Managed(Zcu.LazySrcLoc) = .init(gpa);
-    defer comptime_err_ret_trace.deinit();
-
-    const zir = zcu.namespacePtr(ty.getNamespaceIndex(zcu)).fileScope(zcu).zir.?;
-
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = analysis_arena.allocator(),
-        .code = zir,
-        .owner = anal_unit,
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = .void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
-
-    Sema.type_resolution.resolveStructDefaults(&sema, ty) catch |err| switch (err) {
-        error.AnalysisFail => {
-            if (!zcu.failed_analysis.contains(anal_unit)) {
-                // If this unit caused the error, it would have an entry in `failed_analysis`.
-                // Since it does not, this must be a transitive failure.
-                try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
-                log.debug("mark transitive analysis failure for {f}", .{zcu.fmtAnalUnit(anal_unit)});
-            }
-            return error.AnalysisFail;
-        },
-        error.OutOfMemory,
-        error.Canceled,
-        => |e| return e,
-        error.ComptimeReturn => unreachable,
-        error.ComptimeBreak => unreachable,
-    };
-
-    sema.flushExports() catch |err| switch (err) {
-        error.OutOfMemory => |e| return e,
-    };
-}
-
 /// Ensures that the resolved value of the given `Nav` is fully up-to-date, performing re-analysis
 /// if necessary. Returns `error.AnalysisFail` if an analysis error is encountered; the caller is
 /// free to ignore this, since the error is already registered.
@@ -1452,7 +1349,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
         .parent = null,
         .sema = &sema,
         .namespace = old_nav.analysis.?.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = undefined, // set below
         .src_base_inst = old_nav.analysis.?.zir_index,
@@ -1831,7 +1728,7 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
         .parent = null,
         .sema = &sema,
         .namespace = old_nav.analysis.?.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = undefined, // set below
         .src_base_inst = old_nav.analysis.?.zir_index,
@@ -3078,7 +2975,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
         .parent = null,
         .sema = &sema,
         .namespace = decl_nav.analysis.?.namespace,
-        .instructions = .{},
+        .instructions = .empty,
         .inlining = null,
         .comptime_reason = null,
         .src_base_inst = decl_nav.analysis.?.zir_index,
@@ -3327,7 +3224,7 @@ pub fn processExports(pt: Zcu.PerThread) !void {
                 break :gop .{ gop.value_ptr, gop.found_existing };
             },
         };
-        if (!found_existing) value_ptr.* = .{};
+        if (!found_existing) value_ptr.* = .empty;
         try value_ptr.append(gpa, export_idx);
     }
 
@@ -3356,7 +3253,7 @@ pub fn processExports(pt: Zcu.PerThread) !void {
                     break :gop .{ gop.value_ptr, gop.found_existing };
                 },
             };
-            if (!found_existing) value_ptr.* = .{};
+            if (!found_existing) value_ptr.* = .empty;
             try value_ptr.append(gpa, @enumFromInt(export_idx));
         }
     }
@@ -4353,10 +4250,7 @@ pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
         },
 
         .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .struct_type => {
-                try pt.ensureTypeLayoutUpToDate(ty);
-                try pt.ensureStructDefaultsUpToDate(ty);
-            },
+            .struct_type => try pt.ensureTypeLayoutUpToDate(ty),
             .tuple_type => |tuple| for (0..tuple.types.len) |i| {
                 const field_is_comptime = tuple.values.get(ip)[i] != .none;
                 if (field_is_comptime) continue;
diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig
index 3ee61a90b656759d0848af6f74e0ab313f9c34c2..f28dd48a1775ad0f4deea189ba22121b0c62af10 100644
--- a/src/codegen/c/Type.zig
+++ b/src/codegen/c/Type.zig
@@ -1054,13 +1054,13 @@ pub const Pool = struct {
     };
 
     pub const empty: Pool = .{
-        .map = .{},
-        .items = .{},
-        .extra = .{},
+        .map = .empty,
+        .items = .empty,
+        .extra = .empty,
 
-        .string_map = .{},
-        .string_indices = .{},
-        .string_bytes = .{},
+        .string_map = .empty,
+        .string_indices = .empty,
+        .string_bytes = .empty,
     };
 
     pub fn init(pool: *Pool, allocator: std.mem.Allocator) !void {
diff --git a/src/link/Elf/Object.zig b/src/link/Elf/Object.zig
index ebdd1f20989a897c831738289772906a98afe0fd..d17b0b7b17d4bd28db40bf57f561f02a19d4c988 100644
--- a/src/link/Elf/Object.zig
+++ b/src/link/Elf/Object.zig
@@ -775,7 +775,7 @@ pub fn checkDuplicates(self: *Object, dupes: anytype, elf_file: *Elf) error{OutO
 
         const gop = try dupes.getOrPut(self.symbols_resolver.items[i]);
         if (!gop.found_existing) {
-            gop.value_ptr.* = .{};
+            gop.value_ptr.* = .empty;
         }
         try gop.value_ptr.append(elf_file.base.comp.gpa, self.index);
     }
diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig
index 96db16681ca6a89c0570ab14f1ae09a7e6d5d91b..9bf352c1b10bbf2ee85215dcba1f4225c5e843b9 100644
--- a/src/link/Elf/ZigObject.zig
+++ b/src/link/Elf/ZigObject.zig
@@ -84,7 +84,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
     const ptr_size = elf_file.ptrWidthBytes();
 
     try self.atoms.append(gpa, .{ .extra_index = try self.addAtomExtra(gpa, .{}) }); // null input section
-    try self.relocs.append(gpa, .{}); // null relocs section
+    try self.relocs.append(gpa, .empty); // null relocs section
     try self.strtab.buffer.append(gpa, 0);
 
     {
@@ -546,7 +546,7 @@ fn newAtom(self: *ZigObject, allocator: Allocator, name_off: u32) !Atom.Index {
     atom_ptr.name_offset = name_off;
 
     const relocs_index: u32 = @intCast(self.relocs.items.len);
-    self.relocs.addOneAssumeCapacity().* = .{};
+    self.relocs.addOneAssumeCapacity().* = .empty;
     atom_ptr.relocs_section_index = relocs_index;
 
     return index;
@@ -730,7 +730,7 @@ pub fn checkDuplicates(self: *ZigObject, dupes: anytype, elf_file: *Elf) error{O
 
         const gop = try dupes.getOrPut(self.symbols_resolver.items[i]);
         if (!gop.found_existing) {
-            gop.value_ptr.* = .{};
+            gop.value_ptr.* = .empty;
         }
         try gop.value_ptr.append(elf_file.base.comp.gpa, self.index);
     }
diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig
index fc3ac0fca8f5588ad67cd10c9a7a563f16a2aec4..b17dc099077f15af9be3f6913419b0a4507eb7d9 100644
--- a/src/link/MachO/ZigObject.zig
+++ b/src/link/MachO/ZigObject.zig
@@ -3,7 +3,7 @@ data: std.ArrayList(u8) = .empty,
 basename: []const u8,
 index: File.Index,
 
-symtab: std.MultiArrayList(Nlist) = .{},
+symtab: std.MultiArrayList(Nlist) = .empty,
 strtab: StringTable = .{},
 
 symbols: std.ArrayList(Symbol) = .empty,
@@ -29,7 +29,7 @@ uavs: UavTable = .{},
 tlv_initializers: TlvInitializerTable = .{},
 
 /// A table of relocations.
-relocs: RelocationTable = .{},
+relocs: RelocationTable = .empty,
 
 dwarf: ?Dwarf = null,
 
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index af800d77d263b0a99a43833494ad90884a2dd260..a9e7f35c2118d313cdcd40d99a4dd6aa1141cea5 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -78,7 +78,7 @@ export_table: bool,
 /// Output name of the file
 name: []const u8,
 /// List of relocatable files to be linked into the final binary.
-objects: std.ArrayList(Object) = .{},
+objects: std.ArrayList(Object) = .empty,
 
 func_types: std.AutoArrayHashMapUnmanaged(FunctionType, void) = .empty,
 /// Provides a mapping of both imports and provided functions to symbol name.
@@ -278,7 +278,7 @@ any_tls_relocs: bool = false,
 any_passive_inits: bool = false,
 
 /// All MIR instructions for all Zcu functions.
-mir_instructions: std.MultiArrayList(Mir.Inst) = .{},
+mir_instructions: std.MultiArrayList(Mir.Inst) = .empty,
 /// Corresponds to `mir_instructions`.
 mir_extra: std.ArrayList(u32) = .empty,
 /// All local types for all Zcu functions.
diff --git a/src/main.zig b/src/main.zig
index bb36d00376d5410ed4612feab04b9128871bacd8..7167cae4e29b3e36b4c46589e0be178f1e4f501b 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -979,7 +979,7 @@ fn buildOutputType(
         .dirs = undefined,
         .object_format = null,
         .dynamic_linker = null,
-        .modules = .{},
+        .modules = .empty,
         .opts = .{
             .is_test = switch (arg_mode) {
                 .zig_test, .zig_test_obj => true,
@@ -1006,18 +1006,18 @@ fn buildOutputType(
         .windows_libs = .empty,
         .link_inputs = .empty,
 
-        .c_source_files = .{},
-        .rc_source_files = .{},
+        .c_source_files = .empty,
+        .rc_source_files = .empty,
 
-        .llvm_m_args = .{},
+        .llvm_m_args = .empty,
         .sysroot = null,
-        .lib_directories = .{}, // populated by createModule()
-        .lib_dir_args = .{}, // populated from CLI arg parsing
+        .lib_directories = .empty, // populated by createModule()
+        .lib_dir_args = .empty, // populated from CLI arg parsing
         .libc_installation = null,
         .want_native_include_dirs = false,
-        .frameworks = .{},
-        .framework_dirs = .{},
-        .rpath_list = .{},
+        .frameworks = .empty,
+        .framework_dirs = .empty,
+        .rpath_list = .empty,
         .each_lib_rpath = null,
         .libc_paths_file = EnvVar.ZIG_LIBC.get(environ_map),
         .native_system_include_paths = &.{},
-- 
2.54.0


From 38fdced8bb255d3460afefaacce9dc89dab97def Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 31 Jan 2026 10:19:12 +0000
Subject: [PATCH 426/499] Sema: small cleanup

---
 src/Sema/type_resolution.zig | 118 ++++++++++++++++++-----------------
 1 file changed, 60 insertions(+), 58 deletions(-)

diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 2a28d7aa0456e2cdb0d545ff7208ca4e0e615c4f..a7b862289b6de72b34e2739a684effcddc6a60fc 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -493,65 +493,67 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     };
     defer block.instructions.deinit(gpa);
 
-    // MLUGG TODO: this is fucking ugly bro
-    const explicit_enum_tag_ty: ?Type = if (union_obj.is_reified) ty: {
-        break :ty switch (union_obj.enum_tag_mode) {
-            .explicit => .fromInterned(union_obj.enum_tag_type),
-            .auto => null,
-        };
-    } else ty: {
-        const zir_union = sema.code.getUnionDecl(zir_index);
-        if (zir_union.kind != .tagged_explicit) {
-            break :ty null; // enum tag type will be automatically generated
-        }
-        // Explicitly specified, so evaluate the enum tag type expression.
-        const tag_type_body = zir_union.arg_type_body.?;
-        const tag_type_src = block.src(.container_arg);
-        block.comptime_reason = .{ .reason = .{
-            .src = tag_type_src,
-            .r = .{ .simple = .union_enum_tag_type },
-        } };
-        const type_ref = try sema.resolveInlineBody(&block, tag_type_body, zir_index);
-        break :ty try sema.analyzeAsType(&block, tag_type_src, .union_enum_tag_type, type_ref);
-    };
-    const enum_tag_ty: Type = if (explicit_enum_tag_ty) |enum_tag_ty| ty: {
-        if (enum_tag_ty.zigTypeTag(zcu) != .@"enum") return sema.fail(
-            &block,
-            block.src(.container_arg),
-            "expected enum tag type, found '{f}'",
-            .{enum_tag_ty.fmt(pt)},
-        );
-        break :ty enum_tag_ty;
-    } else switch (try ip.getGeneratedEnumTagType(gpa, io, pt.tid, .{
-        .union_type = union_ty.toIntern(),
-        // MLUGG TODO: a bit hacky icl
-        .int_tag_mode = mode: {
-            if (union_obj.is_reified) break :mode .auto;
-            const zir_union = sema.code.getUnionDecl(zir_index);
-            if (zir_union.kind != .tagged_enum_explicit) break :mode .auto;
-            break :mode .explicit;
+    const enum_tag_ty: Type = switch (union_obj.enum_tag_mode) {
+        .explicit => validated_tag_ty: {
+            // If the union is reified, its enum tag type is already populated. If the union is
+            // declared, we need to evaluate the enum tag type expression (the `E` in `union(E)`).
+            const tag_ty: Type = switch (union_obj.is_reified) {
+                true => .fromInterned(union_obj.enum_tag_type),
+                false => tag_ty: {
+                    const zir_union = sema.code.getUnionDecl(zir_index);
+                    assert(zir_union.kind == .tagged_explicit); // `Zcu.mapOldZirToNew` guarantees that the ZIR mapping preserves `kind`
+                    const tag_type_body = zir_union.arg_type_body.?;
+                    const tag_type_src = block.src(.container_arg);
+                    block.comptime_reason = .{ .reason = .{
+                        .src = tag_type_src,
+                        .r = .{ .simple = .union_enum_tag_type },
+                    } };
+                    const type_ref = try sema.resolveInlineBody(&block, tag_type_body, zir_index);
+                    break :tag_ty try sema.analyzeAsType(&block, tag_type_src, .union_enum_tag_type, type_ref);
+                },
+            };
+            // Because the type is explicitly specified, we need to validate it.
+            if (tag_ty.zigTypeTag(zcu) != .@"enum") return sema.fail(
+                &block,
+                block.src(.container_arg),
+                "expected enum tag type, found '{f}'",
+                .{tag_ty.fmt(pt)},
+            );
+            break :validated_tag_ty tag_ty;
         },
-        .fields_len = @intCast(union_obj.field_types.len),
-    })) {
-        .existing => |tag_ty| .fromInterned(tag_ty),
-        .wip => |wip| tag_ty: {
-            errdefer wip.cancel(ip, pt.tid);
-            _ = wip.setName(ip, try ip.getOrPutStringFmt(
-                gpa,
-                io,
-                pt.tid,
-                "@typeInfo({f}).@\"union\".tag_type.?",
-                .{union_obj.name.fmt(ip)},
-                .no_embedded_nulls,
-            ), .none);
-            const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
-                .parent = union_obj.namespace.toOptional(),
-                .owner_type = wip.index,
-                .file_scope = zcu.namespacePtr(union_obj.namespace).file_scope,
-                .generation = zcu.generation,
-            });
-            if (comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-            break :tag_ty .fromInterned(wip.finish(ip, new_namespace_index));
+        // If no tag type was specified, we generate one keyed on this union type.
+        .auto => switch (try ip.getGeneratedEnumTagType(gpa, io, pt.tid, .{
+            .union_type = union_ty.toIntern(),
+            // The int tag for this enum is usually inferred---the exception is `union(enum(T))`.
+            .int_tag_mode = switch (union_obj.is_reified) {
+                true => .auto,
+                false => switch (sema.code.getUnionDecl(zir_index).kind) {
+                    .tagged_enum_explicit => .auto,
+                    else => .explicit,
+                },
+            },
+            .fields_len = @intCast(union_obj.field_types.len),
+        })) {
+            .existing => |tag_ty| .fromInterned(tag_ty),
+            .wip => |wip| tag_ty: {
+                errdefer wip.cancel(ip, pt.tid);
+                _ = wip.setName(ip, try ip.getOrPutStringFmt(
+                    gpa,
+                    io,
+                    pt.tid,
+                    "@typeInfo({f}).@\"union\".tag_type.?",
+                    .{union_obj.name.fmt(ip)},
+                    .no_embedded_nulls,
+                ), .none);
+                const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
+                    .parent = union_obj.namespace.toOptional(),
+                    .owner_type = wip.index,
+                    .file_scope = zcu.namespacePtr(union_obj.namespace).file_scope,
+                    .generation = zcu.generation,
+                });
+                if (comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+                break :tag_ty .fromInterned(wip.finish(ip, new_namespace_index));
+            },
         },
     };
 
-- 
2.54.0


From b8997f871fc63cee28d94168330d84f177543f2c Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 31 Jan 2026 18:14:31 +0000
Subject: [PATCH 427/499] Sema: clean up and fix alignment handling

---
 src/Sema.zig                  | 935 ++++++++++++++++------------------
 src/Type.zig                  | 345 ++++++++-----
 src/Value.zig                 | 304 +++--------
 src/Zcu.zig                   |   6 +-
 src/Zcu/PerThread.zig         |  24 +-
 src/codegen/c.zig             |   2 +-
 src/codegen/spirv/CodeGen.zig |   2 +-
 src/print_value.zig           |  20 +-
 8 files changed, 740 insertions(+), 898 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 276a06a938b0c868a183ee2626db940d22cf866d..fd4e067fe37d0705fb8c5722b970b777981ee7c4 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3595,7 +3595,20 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
                 };
                 break :ptr (try Value.fromInterned(decl_parent_ptr).ptrField(idx, pt)).toIntern();
             },
-            .elem => |idx| (try Value.fromInterned(decl_parent_ptr).ptrElem(idx, pt)).toIntern(),
+            .elem => |idx| ptr: {
+                const parent_ptr_val: Value = .fromInterned(decl_parent_ptr);
+                if (parent_ptr_val.typeOf(zcu).childType(zcu).zigTypeTag(zcu) == .vector) {
+                    const elem_ptr_ty: Type = .fromInterned(new_ptr_ty);
+                    // Vectors are a bit weird; see logic in `elemPtrVector`.
+                    if (elem_ptr_ty.ptrInfo(zcu).flags.vector_index != .none) {
+                        break :ptr (try pt.getCoerced(parent_ptr_val, elem_ptr_ty)).toIntern();
+                    } else {
+                        const bit_offset = idx * @divExact(elem_ptr_ty.childType(zcu).bitSize(zcu), 8);
+                        break :ptr (try parent_ptr_val.getOffsetPtr(bit_offset, elem_ptr_ty, pt)).toIntern();
+                    }
+                }
+                break :ptr (try parent_ptr_val.ptrElem(idx, pt)).toIntern();
+            },
         };
         try ptr_mapping.put(air_ptr, new_ptr);
     }
@@ -4540,10 +4553,7 @@ fn validateStructInit(
         };
 
         const field_src = init_src; // TODO better source location
-        const default_field_ptr = if (struct_ty.isTuple(zcu))
-            try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(i), true)
-        else
-            try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(i), struct_ty);
+        const default_field_ptr = try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(i), struct_ty);
         try sema.checkKnownAllocPtr(block, struct_ptr, default_field_ptr);
         try sema.storePtr2(block, init_src, default_field_ptr, init_src, .fromValue(default_val), field_src, .store);
     }
@@ -4959,11 +4969,11 @@ pub fn addStrLit(sema: *Sema, string: InternPool.String, len: u64) CompileError!
         .ty = array_ty.toIntern(),
         .storage = .{ .bytes = string },
     } });
-    return sema.uavRef(val);
+    return sema.uavRef(.fromInterned(val));
 }
 
-fn uavRef(sema: *Sema, val: InternPool.Index) CompileError!Air.Inst.Ref {
-    return Air.internedToRef(try sema.pt.refValue(val));
+fn uavRef(sema: *Sema, val: Value) CompileError!Air.Inst.Ref {
+    return .fromValue(try sema.pt.uavValue(val));
 }
 
 fn zirInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -6226,7 +6236,7 @@ fn popErrorReturnTrace(
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
         const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-        const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, stack_trace_ty, true);
+        const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, stack_trace_ty);
         try sema.storePtr2(block, src, field_ptr, src, saved_error_trace_index, src, .store);
     } else if (is_non_error == null) {
         // The result might be an error. If it is, we leave the error trace alone. If it isn't, we need
@@ -6251,7 +6261,7 @@ fn popErrorReturnTrace(
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
         const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-        const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, stack_trace_ty, true);
+        const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, stack_trace_ty);
         try sema.storePtr2(&then_block, src, field_ptr, src, saved_error_trace_index, src, .store);
         _ = try then_block.addBr(cond_block_inst, .void_value);
 
@@ -8196,23 +8206,10 @@ fn zirOptionalPayload(
     const operand_ty = sema.typeOf(operand);
     const result_ty = switch (operand_ty.zigTypeTag(zcu)) {
         .optional => operand_ty.optionalChild(zcu),
-        .pointer => t: {
-            if (operand_ty.ptrSize(zcu) != .c) {
-                return sema.failWithExpectedOptionalType(block, src, operand_ty);
-            }
-            // TODO https://github.com/ziglang/zig/issues/6597
-            if (true) break :t operand_ty;
-            const ptr_info = operand_ty.ptrInfo(zcu);
-            break :t try pt.ptrType(.{
-                .child = ptr_info.child,
-                .flags = .{
-                    .alignment = ptr_info.flags.alignment,
-                    .is_const = ptr_info.flags.is_const,
-                    .is_volatile = ptr_info.flags.is_volatile,
-                    .is_allowzero = ptr_info.flags.is_allowzero,
-                    .address_space = ptr_info.flags.address_space,
-                },
-            });
+        // TODO: https://github.com/ziglang/zig/issues/6597 will eliminate this branch so that we only need to handle optionals.
+        .pointer => switch (operand_ty.ptrSize(zcu)) {
+            .c => operand_ty, // if `ptr` is a `[*c]T`, then `ptr.?` is also a `[*c]T`
+            .one, .many, .slice => return sema.failWithExpectedOptionalType(block, src, operand_ty),
         },
         else => return sema.failWithExpectedOptionalType(block, src, operand_ty),
     };
@@ -10322,10 +10319,10 @@ fn analyzeSwitchBlock(
             const payload_inst: Zir.Inst.Index = if (capture != .none) inst: {
                 const payload_inst = zir_switch.payload_capture_placeholder.unwrap() orelse switch_inst;
                 const payload_ref: Air.Inst.Ref = payload_ref: {
-                    const item_val: InternPool.Index = switch (operand_ty.zigTypeTag(zcu)) {
+                    const item_val: Value = switch (operand_ty.zigTypeTag(zcu)) {
                         .@"union" => item_val: {
                             if (maybe_operand_opv) |operand_opv| {
-                                break :item_val zcu.intern_pool.indexToKey(operand_opv.toIntern()).un.val;
+                                break :item_val .fromInterned(zcu.intern_pool.indexToKey(operand_opv.toIntern()).un.val);
                             }
                             assert(union_originally); // operand type must be union, otherwise it would be an OPV type here
                             assert(zir_switch.any_maybe_runtime_capture); // there's a payload capture
@@ -10362,10 +10359,10 @@ fn analyzeSwitchBlock(
                                 validated_switch.else_err_ty,
                             );
                         },
-                        else => item_opv.toIntern(),
+                        else => item_opv,
                     };
                     break :payload_ref switch (capture) {
-                        .by_val => .fromIntern(item_val),
+                        .by_val => .fromValue(item_val),
                         .by_ref => try sema.uavRef(item_val),
                         .none => unreachable,
                     };
@@ -12198,7 +12195,7 @@ fn analyzeSwitchPayloadCapture(
                 return case_block.addStructFieldVal(operand_val, field_index, field_ty);
             }
         } else if (capture_by_ref) {
-            return sema.uavRef(item_val.toIntern());
+            return sema.uavRef(item_val);
         } else {
             return kind.inline_ref;
         }
@@ -12280,37 +12277,14 @@ fn analyzeSwitchPayloadCapture(
 
             // By-reference captures have some further restrictions which make them easier to emit
             if (capture_by_ref) {
-                const operand_ptr_info = sema.typeOf(operand_ptr).ptrInfo(zcu);
+                const operand_ptr_ty = sema.typeOf(operand_ptr);
                 const capture_ptr_ty = resolve: {
                     // By-ref captures of hetereogeneous types are only allowed if all field
                     // pointer types are peer resolvable to each other.
                     // We need values to run PTR on, so make a bunch of undef constants.
                     const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len);
-                    for (field_indices, dummy_captures) |field_idx, *dummy| {
-                        const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]);
-                        const field_ptr_ty = try pt.ptrType(.{
-                            .child = field_ty.toIntern(),
-                            .flags = .{
-                                .is_const = operand_ptr_info.flags.is_const,
-                                .is_volatile = operand_ptr_info.flags.is_volatile,
-                                .address_space = operand_ptr_info.flags.address_space,
-                                // TODO MLUGG: double-check this. and, um, EVERYWHERE we do ptr alignment...
-                                .alignment = a: {
-                                    if (operand_ty.explicitFieldAlignment(field_idx, zcu) == .none and
-                                        operand_ptr_info.flags.alignment == .none)
-                                    {
-                                        break :a .none;
-                                    }
-
-                                    const union_align = switch (operand_ptr_info.flags.alignment) {
-                                        .none => operand_ty.abiAlignment(zcu),
-                                        else => |a| a,
-                                    };
-                                    const field_align = operand_ty.resolvedFieldAlignment(field_idx, zcu);
-                                    break :a .minStrict(union_align, field_align);
-                                },
-                            },
-                        });
+                    for (field_indices, dummy_captures) |field_index, *dummy| {
+                        const field_ptr_ty = try operand_ptr_ty.fieldPtrType(field_index, pt);
                         dummy.* = try pt.undefRef(field_ptr_ty);
                     }
                     const case_srcs = try sema.arena.alloc(?LazySrcLoc, case_vals.len);
@@ -13696,7 +13670,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 element_vals[elem_i] = coerced_elem_val.toIntern();
             }
             return sema.addConstantMaybeRef(
-                (try pt.aggregateValue(result_ty, element_vals)).toIntern(),
+                try pt.aggregateValue(result_ty, element_vals),
                 ptr_addrspace != null,
             );
         } else break :rs rhs_src;
@@ -14094,7 +14068,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
             break :v try pt.aggregateValue(result_ty, element_vals);
         };
-        return sema.addConstantMaybeRef(val.toIntern(), ptr_addrspace != null);
+        return sema.addConstantMaybeRef(val, ptr_addrspace != null);
     }
 
     try sema.requireRuntimeBlock(block, src, lhs_src);
@@ -15270,7 +15244,7 @@ fn analyzeArithmetic(
                     };
 
                     try sema.ensureLayoutResolved(lhs_ty.childType(zcu), src);
-                    return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);
+                    return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, rhs_src);
                 },
             }
         }
@@ -15370,7 +15344,6 @@ fn analyzePtrArithmetic(
     ptr: Air.Inst.Ref,
     uncasted_offset: Air.Inst.Ref,
     air_tag: Air.Inst.Tag,
-    ptr_src: LazySrcLoc,
     offset_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     // TODO if the operand is comptime-known to be negative, or is a negative int,
@@ -15378,12 +15351,14 @@ fn analyzePtrArithmetic(
     const offset = try sema.coerce(block, .usize, uncasted_offset, offset_src);
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const opt_ptr_val = sema.resolveValue(ptr);
-    const opt_off_val = try sema.resolveDefinedValue(block, offset_src, offset);
     const ptr_ty = sema.typeOf(ptr);
     const ptr_info = ptr_ty.ptrInfo(zcu);
     assert(ptr_info.flags.size == .many or ptr_info.flags.size == .c);
 
+    const maybe_index: ?u64 = if (try sema.resolveDefinedValue(block, offset_src, offset)) |val| off: {
+        break :off val.toUnsignedInt(zcu);
+    } else null;
+
     const elem_ty: Type = .fromInterned(ptr_info.child);
     elem_ty.assertHasLayout(zcu);
 
@@ -15395,70 +15370,36 @@ fn analyzePtrArithmetic(
         else => {},
     }
 
-    const new_ptr_ty = t: {
-        // Calculate the new pointer alignment.
-        // This code is duplicated in `Type.elemPtrType`.
-        if (ptr_info.flags.alignment == .none) {
-            // ABI-aligned pointer. Any pointer arithmetic maintains the same ABI-alignedness.
-            break :t ptr_ty;
+    const elem_ptr_ty = try ptr_ty.elemPtrType(maybe_index, pt);
+    // `elem_ptr_ty` is a single-item pointer, but we want a many-item or C pointer, and to preserve
+    // any input sentinel.
+    const new_ptr_ty = try pt.ptrType(info: {
+        var info = elem_ptr_ty.ptrInfo(zcu);
+        info.flags.size = ptr_info.flags.size;
+        info.sentinel = ptr_info.sentinel;
+        break :info info;
+    });
+
+    ct: {
+        const ptr_val = sema.resolveValue(ptr) orelse break :ct;
+        if (ptr_val.isUndef(zcu)) return pt.undefRef(new_ptr_ty);
+        const index = maybe_index orelse break :ct;
+
+        if (index == 0) return ptr;
+        if (air_tag == .ptr_sub) {
+            const elem_size = elem_ty.abiSize(zcu);
+            return .fromValue(try sema.ptrSubtract(block, op_src, ptr_val, index * elem_size, new_ptr_ty));
+        } else {
+            return .fromValue(try pt.getCoerced(try ptr_val.ptrElem(index, pt), new_ptr_ty));
         }
-        // If the addend is not a comptime-known value we can still count on
-        // it being a multiple of the type size.
-        const elem_size = elem_ty.abiSize(zcu);
-        const addend = if (opt_off_val) |off_val| a: {
-            const off_int = try sema.usizeCast(block, offset_src, off_val.toUnsignedInt(zcu));
-            break :a elem_size * off_int;
-        } else elem_size;
+    }
 
-        // The resulting pointer is aligned to the lcd between the offset (an
-        // arbitrary number) and the alignment factor (always a power of two,
-        // non zero).
-        const new_align: Alignment = @enumFromInt(@min(
-            @ctz(addend),
-            @intFromEnum(ptr_info.flags.alignment),
-        ));
-        assert(new_align != .none);
-
-        break :t try pt.ptrType(.{
-            .child = ptr_info.child,
-            .sentinel = ptr_info.sentinel,
-            .flags = .{
-                .size = ptr_info.flags.size,
-                .alignment = new_align,
-                .is_const = ptr_info.flags.is_const,
-                .is_volatile = ptr_info.flags.is_volatile,
-                .is_allowzero = ptr_info.flags.is_allowzero,
-                .address_space = ptr_info.flags.address_space,
-            },
-        });
-    };
-
-    const runtime_src = rs: {
-        if (opt_ptr_val) |ptr_val| {
-            if (opt_off_val) |offset_val| {
-                if (ptr_val.isUndef(zcu)) return pt.undefRef(new_ptr_ty);
-
-                const offset_int = try sema.usizeCast(block, offset_src, offset_val.toUnsignedInt(zcu));
-                if (offset_int == 0) return ptr;
-                if (air_tag == .ptr_sub) {
-                    const elem_size = elem_ty.abiSize(zcu);
-                    const new_ptr_val = try sema.ptrSubtract(block, op_src, ptr_val, offset_int * elem_size, new_ptr_ty);
-                    return Air.internedToRef(new_ptr_val.toIntern());
-                } else {
-                    const new_ptr_val = try pt.getCoerced(try ptr_val.ptrElem(offset_int, pt), new_ptr_ty);
-                    return Air.internedToRef(new_ptr_val.toIntern());
-                }
-            } else break :rs offset_src;
-        } else break :rs ptr_src;
-    };
-
-    try sema.requireRuntimeBlock(block, op_src, runtime_src);
     try sema.checkLogicalPtrOperation(block, op_src, ptr_ty);
 
     return block.addInst(.{
         .tag = air_tag,
         .data = .{ .ty_pl = .{
-            .ty = Air.internedToRef(new_ptr_ty.toIntern()),
+            .ty = .fromType(new_ptr_ty),
             .payload = try sema.addExtra(Air.Bin{
                 .lhs = ptr,
                 .rhs = offset,
@@ -16222,6 +16163,11 @@ fn zirBuiltinSrc(
     return Air.internedToRef((try pt.aggregateValue(src_loc_ty, &fields)).toIntern());
 }
 
+/// MLUGG TODO: once this branch is in a more stable state, I need to make a language change so that
+/// `std.builtin.Type` makes all `alignment` fields `?usize` instead of `comptime_int`, to prevent
+/// explicit alignment annotations from sneaking in without the user requesting any; but doing that
+/// right now would be really annoying because it would break the base compiler. I need to have the
+/// compiler more-or-less fully migrated first.
 fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -16726,17 +16672,21 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     } });
                 };
 
+                const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
+
                 const alignment = switch (layout) {
-                    .auto, .@"extern" => ty.resolvedFieldAlignment(field_index, zcu),
+                    .auto, .@"extern" => switch (ty.explicitFieldAlignment(field_index, zcu)) {
+                        .none => field_ty.abiAlignment(zcu),
+                        else => |a| a,
+                    },
                     .@"packed" => .none,
                 };
 
-                const field_ty = union_obj.field_types.get(ip)[field_index];
                 const union_field_fields = .{
                     // name: [:0]const u8,
                     name_val,
                     // type: type,
-                    field_ty,
+                    field_ty.toIntern(),
                     // alignment: comptime_int,
                     (try pt.intValue(.comptime_int, alignment.toByteUnits() orelse 0)).toIntern(),
                 };
@@ -16895,7 +16845,10 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     const opt_default_val: ?Value = if (field_default == .none) null else .fromInterned(field_default);
                     const default_val_ptr = try sema.optRefValue(opt_default_val);
                     const alignment = switch (struct_type.layout) {
-                        .auto, .@"extern" => ty.resolvedFieldAlignment(field_index, zcu),
+                        .auto, .@"extern" => switch (ty.explicitFieldAlignment(field_index, zcu)) {
+                            .none => field_ty.defaultStructFieldAlignment(struct_type.layout, zcu),
+                            else => |a| a,
+                        },
                         .@"packed" => .none,
                     };
 
@@ -18425,8 +18378,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
     const init_ref = try sema.coerce(block, init_ty, empty_ref, src);
 
     if (is_byref) {
-        const init_val = sema.resolveValue(init_ref).?;
-        return sema.uavRef(init_val.toIntern());
+        return sema.uavRef(sema.resolveValue(init_ref).?);
     } else {
         return init_ref;
     }
@@ -18648,7 +18600,7 @@ fn zirStructInit(
             }));
             const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src);
             const final_val = sema.resolveValue(final_val_inst).?;
-            return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
+            return sema.addConstantMaybeRef(final_val, is_ref);
         }
 
         if (resolved_ty.comptimeOnly(zcu)) {
@@ -18789,7 +18741,7 @@ fn finishStructInit(
             }
             const struct_val = try pt.aggregateValue(struct_ty, elems);
             const final_val_ref = try sema.coerce(block, result_ty, .fromValue(struct_val), init_src);
-            return sema.addConstantMaybeRef(final_val_ref.toInterned().?, is_ref);
+            return sema.addConstantMaybeRef(sema.resolveValue(final_val_ref).?, is_ref);
         },
         .@"packed" => {
             const buf = try sema.arena.alloc(u8, (struct_ty.bitSize(zcu) + 7) / 8);
@@ -18808,7 +18760,7 @@ fn finishStructInit(
                 error.OutOfMemory => |e| return e,
             };
             const final_val_ref = try sema.coerce(block, result_ty, .fromValue(struct_val), init_src);
-            return sema.addConstantMaybeRef(final_val_ref.toInterned().?, is_ref);
+            return sema.addConstantMaybeRef(sema.resolveValue(final_val_ref).?, is_ref);
         },
     };
 
@@ -19000,7 +18952,7 @@ fn structInitAnon(
 
     _ = opt_runtime_index orelse {
         const struct_val = try pt.aggregateValue(struct_ty, values);
-        return sema.addConstantMaybeRef(struct_val.toIntern(), is_ref);
+        return sema.addConstantMaybeRef(struct_val, is_ref);
     };
 
     if (is_ref) {
@@ -19137,7 +19089,7 @@ fn zirArrayInit(
         const arr_val = try pt.aggregateValue(array_ty, elem_vals);
         const result_ref = try sema.coerce(block, result_ty, Air.internedToRef(arr_val.toIntern()), src);
         const result_val = (sema.resolveValue(result_ref)).?;
-        return sema.addConstantMaybeRef(result_val.toIntern(), is_ref);
+        return sema.addConstantMaybeRef(result_val, is_ref);
     };
 
     if (is_ref) {
@@ -19261,7 +19213,7 @@ fn arrayInitAnon(
 
     const runtime_src = opt_runtime_src orelse {
         const tuple_val = try pt.aggregateValue(tuple_ty, values);
-        return sema.addConstantMaybeRef(tuple_val.toIntern(), is_ref);
+        return sema.addConstantMaybeRef(tuple_val, is_ref);
     };
 
     try sema.requireRuntimeBlock(block, src, runtime_src);
@@ -19304,8 +19256,8 @@ fn arrayInitAnon(
     return block.addAggregateInit(tuple_ty, element_refs);
 }
 
-fn addConstantMaybeRef(sema: *Sema, val: InternPool.Index, is_ref: bool) !Air.Inst.Ref {
-    return if (is_ref) sema.uavRef(val) else Air.internedToRef(val);
+fn addConstantMaybeRef(sema: *Sema, val: Value, is_ref: bool) !Air.Inst.Ref {
+    return if (is_ref) sema.uavRef(val) else .fromValue(val);
 }
 
 fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -23401,125 +23353,74 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     const field_ptr = sema.resolveInst(extra.field_ptr);
     const field_ptr_ty = sema.typeOf(field_ptr);
     try sema.checkPtrOperand(block, field_ptr_src, field_ptr_ty);
-    const field_ptr_info = field_ptr_ty.ptrInfo(zcu);
 
-    var actual_parent_ptr_info: InternPool.Key.PtrType = .{
-        .child = parent_ty.toIntern(),
-        .flags = .{
-            .alignment = parent_ptr_ty.ptrAlignment(zcu),
-            .is_const = field_ptr_info.flags.is_const,
-            .is_volatile = field_ptr_info.flags.is_volatile,
-            .is_allowzero = field_ptr_info.flags.is_allowzero,
-            .address_space = field_ptr_info.flags.address_space,
-        },
-        .packed_offset = parent_ptr_info.packed_offset,
-    };
-    const field_ty = parent_ty.fieldType(field_index, zcu);
-    var actual_field_ptr_info: InternPool.Key.PtrType = .{
-        .child = field_ty.toIntern(),
-        .flags = .{
-            .alignment = field_ptr_ty.ptrAlignment(zcu),
-            .is_const = field_ptr_info.flags.is_const,
-            .is_volatile = field_ptr_info.flags.is_volatile,
-            .is_allowzero = field_ptr_info.flags.is_allowzero,
-            .address_space = field_ptr_info.flags.address_space,
-        },
-        .packed_offset = field_ptr_info.packed_offset,
-    };
-    switch (parent_ty.containerLayout(zcu)) {
-        .auto => {
-            actual_parent_ptr_info.flags.alignment = parent_ty.resolvedFieldAlignment(field_index, zcu);
-            actual_parent_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
-            actual_field_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
-        },
-        .@"extern" => {
-            const field_offset = parent_ty.structFieldOffset(field_index, zcu);
-            actual_parent_ptr_info.flags.alignment = actual_field_ptr_info.flags.alignment.minStrict(if (field_offset > 0)
-                Alignment.fromLog2Units(@ctz(field_offset))
-            else
-                actual_field_ptr_info.flags.alignment);
+    const hypothetical_field_ptr_ty = try parent_ptr_ty.fieldPtrType(field_index, pt);
+    const casted_field_ptr = try sema.ptrCastFull(
+        block,
+        flags,
+        inst_src,
+        field_ptr,
+        field_ptr_src,
+        hypothetical_field_ptr_ty,
+        "@fieldParentPtr",
+    );
 
-            actual_parent_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
-            actual_field_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
-        },
-        .@"packed" => {
-            const byte_offset = std.math.divExact(u32, @abs(@as(i32, actual_parent_ptr_info.packed_offset.bit_offset) +
-                (if (zcu.typeToStruct(parent_ty)) |struct_obj| zcu.structPackedFieldBitOffset(struct_obj, field_index) else 0) -
-                actual_field_ptr_info.packed_offset.bit_offset), 8) catch
-                return sema.fail(block, inst_src, "pointer bit-offset mismatch", .{});
-            actual_parent_ptr_info.flags.alignment = actual_field_ptr_info.flags.alignment.minStrict(if (byte_offset > 0)
-                Alignment.fromLog2Units(@ctz(byte_offset))
-            else
-                actual_field_ptr_info.flags.alignment);
-        },
-    }
+    const unaligned_parent_ptr_ty = try pt.ptrType(info: {
+        var info = parent_ptr_ty.ptrInfo(zcu);
+        info.flags.alignment = hypothetical_field_ptr_ty.ptrAlignment(zcu);
+        break :info info;
+    });
 
-    const actual_field_ptr_ty = try pt.ptrType(actual_field_ptr_info);
-    const casted_field_ptr = try sema.coerce(block, actual_field_ptr_ty, field_ptr, field_ptr_src);
-    const actual_parent_ptr_ty = try pt.ptrType(actual_parent_ptr_info);
-
-    const result = if (try sema.resolveDefinedValue(block, field_ptr_src, casted_field_ptr)) |field_ptr_val| result: {
-        switch (parent_ty.zigTypeTag(zcu)) {
-            .@"struct" => switch (parent_ty.containerLayout(zcu)) {
-                .auto => {},
-                .@"extern" => {
-                    const byte_offset = parent_ty.structFieldOffset(field_index, zcu);
-                    const parent_ptr_val = try sema.ptrSubtract(block, field_ptr_src, field_ptr_val, byte_offset, actual_parent_ptr_ty);
-                    break :result Air.internedToRef(parent_ptr_val.toIntern());
-                },
-                .@"packed" => {
-                    // Logic lifted from type computation above - I'm just assuming it's correct.
-                    // `catch unreachable` since error case handled above.
-                    const byte_offset = std.math.divExact(u32, @abs(@as(i32, actual_parent_ptr_info.packed_offset.bit_offset) +
-                        zcu.structPackedFieldBitOffset(zcu.typeToStruct(parent_ty).?, field_index) -
-                        actual_field_ptr_info.packed_offset.bit_offset), 8) catch unreachable;
-                    const parent_ptr_val = try sema.ptrSubtract(block, field_ptr_src, field_ptr_val, byte_offset, actual_parent_ptr_ty);
-                    break :result Air.internedToRef(parent_ptr_val.toIntern());
-                },
-            },
-            .@"union" => switch (parent_ty.containerLayout(zcu)) {
-                .auto => {},
-                .@"extern", .@"packed" => {
-                    // For an extern or packed union, just coerce the pointer.
-                    const parent_ptr_val = try pt.getCoerced(field_ptr_val, actual_parent_ptr_ty);
-                    break :result Air.internedToRef(parent_ptr_val.toIntern());
-                },
-            },
+    const unaligned_parent_ptr: Air.Inst.Ref = if (try sema.resolveDefinedValue(
+        block,
+        field_ptr_src,
+        casted_field_ptr,
+    )) |field_ptr_val| switch (parent_ty.containerLayout(zcu)) {
+        .@"packed" => .fromValue(try pt.getCoerced(field_ptr_val, unaligned_parent_ptr_ty)),
+        .@"extern" => switch (parent_ty.zigTypeTag(zcu)) {
+            .@"struct" => .fromValue(try sema.ptrSubtract(
+                block,
+                field_ptr_src,
+                field_ptr_val,
+                parent_ty.structFieldOffset(field_index, zcu),
+                unaligned_parent_ptr_ty,
+            )),
+            .@"union" => .fromValue(try pt.getCoerced(field_ptr_val, unaligned_parent_ptr_ty)),
             else => unreachable,
-        }
-
-        const opt_field: ?InternPool.Key.Ptr.BaseAddr.BaseIndex = opt_field: {
-            const ptr = switch (ip.indexToKey(field_ptr_val.toIntern())) {
-                .ptr => |ptr| ptr,
-                else => break :opt_field null,
-            };
-            if (ptr.byte_offset != 0) break :opt_field null;
-            break :opt_field switch (ptr.base_addr) {
-                .field => |field| field,
-                else => null,
+        },
+        .auto => result: {
+            const opt_field: ?InternPool.Key.Ptr.BaseAddr.BaseIndex = opt_field: {
+                const ptr = switch (ip.indexToKey(field_ptr_val.toIntern())) {
+                    .ptr => |ptr| ptr,
+                    else => break :opt_field null,
+                };
+                if (ptr.byte_offset != 0) break :opt_field null;
+                break :opt_field switch (ptr.base_addr) {
+                    .field => |field| field,
+                    else => null,
+                };
             };
-        };
 
-        const field = opt_field orelse {
-            return sema.fail(block, field_ptr_src, "pointer value not based on parent struct", .{});
-        };
+            const field = opt_field orelse {
+                return sema.fail(block, field_ptr_src, "pointer value not based on parent struct", .{});
+            };
 
-        if (Value.fromInterned(field.base).typeOf(zcu).childType(zcu).toIntern() != parent_ty.toIntern()) {
-            return sema.fail(block, field_ptr_src, "pointer value not based on parent struct", .{});
-        }
+            if (Value.fromInterned(field.base).typeOf(zcu).childType(zcu).toIntern() != parent_ty.toIntern()) {
+                return sema.fail(block, field_ptr_src, "pointer value not based on parent struct", .{});
+            }
 
-        if (field.index != field_index) {
-            return sema.fail(block, inst_src, "field '{f}' has index '{d}' but pointer value is index '{d}' of struct '{f}'", .{
-                field_name.fmt(ip), field_index, field.index, parent_ty.fmt(pt),
-            });
-        }
-        break :result try sema.coerce(block, actual_parent_ptr_ty, Air.internedToRef(field.base), inst_src);
+            if (field.index != field_index) {
+                return sema.fail(block, inst_src, "field '{f}' has index '{d}' but pointer value is index '{d}' of struct '{f}'", .{
+                    field_name.fmt(ip), field_index, field.index, parent_ty.fmt(pt),
+                });
+            }
+            break :result .fromValue(try pt.getCoerced(.fromInterned(field.base), unaligned_parent_ptr_ty));
+        },
     } else result: {
-        try sema.requireRuntimeBlock(block, inst_src, field_ptr_src);
         break :result try block.addInst(.{
             .tag = .field_parent_ptr,
             .data = .{ .ty_pl = .{
-                .ty = Air.internedToRef(actual_parent_ptr_ty.toIntern()),
+                .ty = .fromType(unaligned_parent_ptr_ty),
                 .payload = try block.sema.addExtra(Air.FieldParentPtr{
                     .field_ptr = casted_field_ptr,
                     .field_index = @intCast(field_index),
@@ -23527,14 +23428,61 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
             } },
         });
     };
-    return sema.ptrCastFull(block, flags, inst_src, result, inst_src, parent_ptr_ty, "@fieldParentPtr");
+
+    // There's one more error condition: if the hypothetical field pointer type has a lower
+    // alignment than the parent pointer type, then we need an `@alignCast`. Note that the earlier
+    // `ptrCastFull` may *also* have "used" the `@alignCast`; that would be a case where the field
+    // is naturally less aligned than the rest of the struct, *and* the field pointer is itself
+    // underaligned compared to the field alignment. For example, `struct { a: u32, b: u16 }` with
+    // a field pointer of type `*align(1) u16`.
+    switch (hypothetical_field_ptr_ty.ptrAlignment(zcu).order(parent_ptr_ty.ptrAlignment(zcu))) {
+        .gt => unreachable, // getting a field pointer can never increase alignment
+        .eq => return unaligned_parent_ptr,
+        .lt => if (flags.align_cast) {
+            // Go through `ptrCastFull` for the safety check.
+            return sema.ptrCastFull(
+                block,
+                flags,
+                inst_src,
+                unaligned_parent_ptr,
+                inst_src,
+                parent_ptr_ty,
+                "@fieldParentPtr",
+            );
+        } else return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(inst_src, "@fieldParentPtr increases pointer alignment", .{});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(inst_src, msg, "parent pointer type '{f}' has alignment '{d}'", .{
+                parent_ptr_ty.fmt(pt),
+                parent_ptr_ty.abiAlignment(zcu),
+            });
+            if (parent_ty.isTuple(zcu)) {
+                try sema.errNote(field_ptr_src, msg, "tuple field '{d}' limits alignment to '{d}'", .{
+                    field_index,
+                    field_ptr_ty.ptrAlignment(zcu),
+                });
+            } else {
+                try sema.errNote(parent_ty.srcLoc(zcu), msg, "{t} field '{f}' limits alignment to '{d}'", .{
+                    parent_ty.zigTypeTag(zcu),
+                    switch (parent_ty.zigTypeTag(zcu)) {
+                        .@"struct" => parent_ty.structFieldName(field_index, zcu).unwrap().?.fmt(ip),
+                        .@"union" => parent_ty.unionTagTypeHypothetical(zcu).enumFieldName(field_index, zcu).fmt(ip),
+                        else => unreachable,
+                    },
+                    field_ptr_ty.ptrAlignment(zcu),
+                });
+            }
+            try sema.errNote(inst_src, msg, "use @alignCast to assert pointer alignment", .{});
+            break :msg msg;
+        }),
+    }
 }
 
 fn ptrSubtract(sema: *Sema, block: *Block, src: LazySrcLoc, ptr_val: Value, byte_subtract: u64, new_ty: Type) !Value {
     const pt = sema.pt;
     const zcu = pt.zcu;
     if (byte_subtract == 0) return pt.getCoerced(ptr_val, new_ty);
-    var ptr = switch (zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
+    const ptr = switch (zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
         .undef => return sema.failWithUseOfUndef(block, src, null),
         .ptr => |ptr| ptr,
         else => unreachable,
@@ -23547,9 +23495,11 @@ fn ptrSubtract(sema: *Sema, block: *Block, src: LazySrcLoc, ptr_val: Value, byte
             break :msg msg;
         });
     }
-    ptr.byte_offset -= byte_subtract;
-    ptr.ty = new_ty.toIntern();
-    return Value.fromInterned(try pt.intern(.{ .ptr = ptr }));
+    return Value.fromInterned(try pt.intern(.{ .ptr = .{
+        .ty = new_ty.toIntern(),
+        .base_addr = ptr.base_addr,
+        .byte_offset = ptr.byte_offset - byte_subtract,
+    } }));
 }
 
 fn zirMinMax(
@@ -24186,8 +24136,8 @@ fn zirMemcpy(
 
         // ok1: dest >= src + len
         // ok2: src >= dest + len
-        const src_plus_len = try sema.analyzePtrArithmetic(block, src, raw_src_ptr, len, .ptr_add, src_src, src);
-        const dest_plus_len = try sema.analyzePtrArithmetic(block, src, raw_dest_ptr, len, .ptr_add, dest_src, src);
+        const src_plus_len = try sema.analyzePtrArithmetic(block, src, raw_src_ptr, len, .ptr_add, src);
+        const dest_plus_len = try sema.analyzePtrArithmetic(block, src, raw_dest_ptr, len, .ptr_add, src);
         const ok1 = try block.addBinOp(.cmp_gte, raw_dest_ptr, src_plus_len);
         const ok2 = try block.addBinOp(.cmp_gte, new_src_ptr, dest_plus_len);
         const ok = try block.addBinOp(.bool_or, ok1, ok2);
@@ -25402,21 +25352,36 @@ fn addSafetyCheckSentinelMismatch(
     const expected_sentinel = Air.internedToRef(expected_sentinel_val.toIntern());
 
     const ptr_ty = sema.typeOf(ptr);
-    const actual_sentinel = if (ptr_ty.isSlice(zcu))
-        try parent_block.addBinOp(.slice_elem_val, ptr, sentinel_index)
-    else blk: {
-        const elem_ptr_ty = try ptr_ty.elemPtrType(null, pt);
-        const sentinel_ptr = try parent_block.addPtrElemPtr(ptr, sentinel_index, elem_ptr_ty);
-        break :blk try parent_block.addTyOp(.load, sentinel_ty, sentinel_ptr);
-    };
-
-    const ok = if (sentinel_ty.zigTypeTag(zcu) == .vector) ok: {
-        const eql = try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq);
-        break :ok try parent_block.addReduce(eql, .And);
-    } else ok: {
-        assert(sentinel_ty.isSelfComparable(zcu, true));
-        break :ok try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel);
+    const ptr_info = ptr_ty.ptrInfo(zcu);
+    const actual_sentinel: Air.Inst.Ref = switch (ptr_ty.ptrSize(zcu)) {
+        .slice => try parent_block.addBinOp(.slice_elem_val, ptr, sentinel_index),
+        .one => s: {
+            const array_ty: Type = .fromInterned(ptr_info.child);
+            assert(array_ty.zigTypeTag(zcu) == .array);
+            assert(array_ty.childType(zcu).toIntern() == sentinel_ty.toIntern());
+            const many_ptr_ty = try pt.ptrType(.{
+                .child = sentinel_ty.toIntern(),
+                .flags = .{
+                    .size = .many,
+                    .is_const = ptr_info.flags.is_const,
+                    .is_volatile = ptr_info.flags.is_volatile,
+                    .is_allowzero = ptr_info.flags.is_allowzero,
+                    .alignment = switch (ptr_info.flags.alignment) {
+                        .none => .none,
+                        else => |ptr_align| .minStrict(ptr_align, sentinel_ty.abiAlignment(zcu)),
+                    },
+                    .address_space = ptr_info.flags.address_space,
+                },
+            });
+            const many_ptr = try parent_block.addBitCast(many_ptr_ty, ptr);
+            break :s try parent_block.addBinOp(.ptr_elem_val, many_ptr, sentinel_index);
+        },
+        .many => unreachable,
+        .c => unreachable,
     };
+    assert(sema.typeOf(actual_sentinel).toIntern() == sentinel_ty.toIntern());
+    assert(sentinel_ty.isSelfComparable(zcu, true));
+    const ok = try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel);
 
     return addSafetyCheckCall(sema, parent_block, src, ok, .@"panic.sentinelMismatch", &.{
         expected_sentinel, actual_sentinel,
@@ -25676,7 +25641,7 @@ fn fieldVal(
         .@"struct" => if (is_pointer_to) {
             // Avoid loading the entire struct by fetching a pointer and loading that
             try sema.ensureLayoutResolved(inner_ty, src);
-            const field_ptr = try sema.structFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
+            const field_ptr = try sema.structFieldPtr(block, src, object, field_name, field_name_src, inner_ty);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
             return sema.structFieldVal(block, object, field_name, field_name_src, inner_ty);
@@ -25730,7 +25695,7 @@ fn fieldPtr(
         .array => {
             if (field_name.eqlSlice("len", ip)) {
                 const int_val = try pt.intValue(.usize, inner_ty.arrayLen(zcu));
-                return uavRef(sema, int_val.toIntern());
+                return uavRef(sema, int_val);
             } else if (field_name.eqlSlice("ptr", ip) and is_pointer_to) {
                 const ptr_info = object_ty.ptrInfo(zcu);
                 const new_ptr_ty = try pt.ptrType(.{
@@ -25752,6 +25717,7 @@ fn fieldPtr(
                     .child = new_ptr_ty.toIntern(),
                     .sentinel = if (object_ptr_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
+                        .size = .one,
                         .alignment = ptr_ptr_info.flags.alignment,
                         .is_const = ptr_ptr_info.flags.is_const,
                         .is_volatile = ptr_ptr_info.flags.is_volatile,
@@ -25857,10 +25823,10 @@ fn fieldPtr(
                         },
                         else => unreachable,
                     };
-                    return uavRef(sema, try pt.intern(.{ .err = .{
+                    return uavRef(sema, .fromInterned(try pt.intern(.{ .err = .{
                         .ty = err_set_ty.toIntern(),
                         .name = field_name,
-                    } }));
+                    } })));
                 },
                 .@"union" => {
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
@@ -25871,7 +25837,7 @@ fn fieldPtr(
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index| {
                             const field_index_u32: u32 = @intCast(field_index);
                             const idx_val = try pt.enumValueFieldIndex(enum_ty, field_index_u32);
-                            return uavRef(sema, idx_val.toIntern());
+                            return uavRef(sema, idx_val);
                         }
                     }
                     return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
@@ -25886,7 +25852,7 @@ fn fieldPtr(
                     };
                     const field_index_u32: u32 = @intCast(field_index);
                     const idx_val = try pt.enumValueFieldIndex(child_type, field_index_u32);
-                    return uavRef(sema, idx_val.toIntern());
+                    return uavRef(sema, idx_val);
                 },
                 .@"struct", .@"opaque" => {
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
@@ -25903,7 +25869,7 @@ fn fieldPtr(
             else
                 object_ptr;
             try sema.ensureLayoutResolved(inner_ty, src);
-            const field_ptr = try sema.structFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty, initializing);
+            const field_ptr = try sema.structFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
         },
@@ -26190,7 +26156,6 @@ fn structFieldPtr(
     field_name: InternPool.NullTerminatedString,
     field_name_src: LazySrcLoc,
     struct_ty: Type,
-    initializing: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -26199,23 +26164,24 @@ fn structFieldPtr(
     assert(struct_ty.zigTypeTag(zcu) == .@"struct");
     struct_ty.assertHasLayout(zcu);
 
-    if (struct_ty.isTuple(zcu)) {
+    const field_index: u32 = if (struct_ty.isTuple(zcu)) field_index: {
         if (field_name.eqlSlice("len", ip)) {
             const len_inst = try pt.intRef(.usize, struct_ty.structFieldCount(zcu));
             return sema.analyzeRef(block, src, len_inst);
         }
-        const field_index = try sema.tupleFieldIndex(block, struct_ty, field_name, field_name_src);
-        return sema.tupleFieldPtr(block, src, struct_ptr, field_name_src, field_index, initializing);
-    }
-
-    const struct_type = zcu.typeToStruct(struct_ty).?;
-
-    const field_index = struct_type.nameIndex(ip, field_name) orelse
-        return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_name_src, field_name);
+        break :field_index try sema.tupleFieldIndex(block, struct_ty, field_name, field_name_src);
+    } else field_index: {
+        const struct_type = zcu.typeToStruct(struct_ty).?;
+        break :field_index struct_type.nameIndex(ip, field_name) orelse {
+            return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_name_src, field_name);
+        };
+    };
 
     return sema.structFieldPtrByIndex(block, src, struct_ptr, field_index, struct_ty);
 }
 
+/// Supports both structs and unions.
+///
 /// Asserts that the layout of `struct_ty` is already resolved.
 fn structFieldPtrByIndex(
     sema: *Sema,
@@ -26227,82 +26193,23 @@ fn structFieldPtrByIndex(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
 
     struct_ty.assertHasLayout(zcu);
-
-    const struct_type = zcu.typeToStruct(struct_ty).?;
-    const field_is_comptime = struct_type.field_is_comptime_bits.get(ip, field_index);
-
-    // Comptime fields are handled later
-    if (!field_is_comptime) {
-        if (try sema.resolveDefinedValue(block, src, struct_ptr)) |struct_ptr_val| {
-            const val = try struct_ptr_val.ptrField(field_index, pt);
-            return Air.internedToRef(val.toIntern());
-        }
-    }
-
-    const field_ty = struct_type.field_types.get(ip)[field_index];
     const struct_ptr_ty = sema.typeOf(struct_ptr);
-    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(zcu);
-    assert(struct_ptr_ty_info.child == struct_ty.toIntern());
 
-    var ptr_ty_data: InternPool.Key.PtrType = .{
-        .child = field_ty,
-        .flags = .{
-            .is_const = struct_ptr_ty_info.flags.is_const,
-            .is_volatile = struct_ptr_ty_info.flags.is_volatile,
-            .address_space = struct_ptr_ty_info.flags.address_space,
-        },
-    };
-
-    const parent_align = if (struct_ptr_ty_info.flags.alignment != .none)
-        struct_ptr_ty_info.flags.alignment
-    else
-        struct_ty.abiAlignment(zcu);
-
-    if (struct_type.layout == .@"packed") {
-        assert(!field_is_comptime);
-        const packed_offset = struct_ty.packedStructFieldPtrInfo(struct_ptr_ty, field_index, pt);
-        ptr_ty_data.flags.alignment = parent_align;
-        ptr_ty_data.packed_offset = packed_offset;
-    } else if (struct_type.layout == .@"extern") {
-        assert(!field_is_comptime);
-        // For extern structs, field alignment might be bigger than type's
-        // natural alignment. Eg, in `extern struct { x: u32, y: u16 }` the
-        // second field is aligned as u32.
-        ptr_ty_data.flags.alignment = a: {
-            const field_off = struct_ty.structFieldOffset(field_index, zcu);
-            if (field_off == 0) break :a struct_ptr_ty_info.flags.alignment;
-            const true_field_align: Alignment = .fromLog2Units(@ctz(field_off));
-            if (struct_ptr_ty_info.flags.alignment == .none and
-                true_field_align == Type.fromInterned(field_ty).abiAlignment(zcu))
-            {
-                break :a .none;
-            }
-            break :a .minStrict(true_field_align, parent_align);
-        };
-    } else {
-        // Our alignment is capped at the field alignment.
-        ptr_ty_data.flags.alignment = if (struct_ptr_ty_info.flags.alignment == .none)
-            struct_ty.explicitFieldAlignment(field_index, zcu)
-        else
-            struct_ty.resolvedFieldAlignment(field_index, zcu).min(parent_align);
-    }
-
-    const ptr_field_ty = try pt.ptrType(ptr_ty_data);
-
-    if (field_is_comptime) {
-        assert(struct_type.field_defaults.get(ip)[field_index] != .none);
-        const val = try pt.intern(.{ .ptr = .{
-            .ty = ptr_field_ty.toIntern(),
-            .base_addr = .{ .comptime_field = struct_type.field_defaults.get(ip)[field_index] },
+    if (struct_ty.structFieldIsComptime(field_index, zcu)) {
+        const field_ptr_ty = try struct_ptr_ty.fieldPtrType(field_index, pt);
+        return .fromIntern(try pt.intern(.{ .ptr = .{
+            .ty = field_ptr_ty.toIntern(),
+            .base_addr = .{ .comptime_field = struct_ty.structFieldDefaultValue(field_index, zcu).?.toIntern() },
             .byte_offset = 0,
-        } });
-        return Air.internedToRef(val);
+        } }));
+    } else if (try sema.resolveDefinedValue(block, src, struct_ptr)) |struct_ptr_val| {
+        return .fromValue(try struct_ptr_val.ptrField(field_index, pt));
+    } else {
+        const field_ptr_ty = try struct_ptr_ty.fieldPtrType(field_index, pt);
+        return block.addStructFieldPtr(struct_ptr, field_index, field_ptr_ty);
     }
-
-    return block.addStructFieldPtr(struct_ptr, field_index, ptr_field_ty);
 }
 
 fn structFieldVal(
@@ -26438,29 +26345,11 @@ fn unionFieldPtr(
     assert(union_ty.zigTypeTag(zcu) == .@"union");
     union_ty.assertHasLayout(zcu);
 
-    const union_ptr_ty = sema.typeOf(union_ptr);
-    const union_ptr_info = union_ptr_ty.ptrInfo(zcu);
     const union_obj = zcu.typeToUnion(union_ty).?;
+    const tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
+
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-    const ptr_field_ty = try pt.ptrType(.{
-        .child = field_ty.toIntern(),
-        .flags = .{
-            .is_const = union_ptr_info.flags.is_const,
-            .is_volatile = union_ptr_info.flags.is_volatile,
-            .address_space = union_ptr_info.flags.address_space,
-            .alignment = a: {
-                if (union_obj.layout != .auto) break :a union_ptr_info.flags.alignment;
-                if (union_ptr_info.flags.alignment == .none) {
-                    break :a union_ty.explicitFieldAlignment(field_index, zcu);
-                }
-                const field_align = union_ty.resolvedFieldAlignment(field_index, zcu);
-                break :a union_ptr_info.flags.alignment.min(field_align);
-            },
-        },
-        .packed_offset = union_ptr_info.packed_offset,
-    });
-    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_type).enumFieldIndex(field_name, zcu).?);
 
     if (initializing and field_ty.classify(zcu) == .no_possible_value) {
         const msg = msg: {
@@ -26484,23 +26373,17 @@ fn unionFieldPtr(
                     break :ct;
                 }
                 // Store to the union to initialize the tag.
-                const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
-                const payload_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
-                const new_union_val = try pt.unionValue(union_ty, field_tag, try payload_ty.onePossibleValue(pt) orelse try pt.undefValue(payload_ty));
+                const field_tag = try pt.enumValueFieldIndex(tag_ty, field_index);
+                const payload_val = try field_ty.onePossibleValue(pt) orelse try pt.undefValue(field_ty);
+                const new_union_val = try pt.unionValue(union_ty, field_tag, payload_val);
                 try sema.storePtrVal(block, src, union_ptr_val, new_union_val, union_ty);
             } else {
-                const union_val = (try sema.pointerDeref(block, src, union_ptr_val, union_ptr_ty)) orelse
-                    break :ct;
-                if (union_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, src, null);
-                }
-                const un = ip.indexToKey(union_val.toIntern()).un;
-                const field_tag = try pt.enumValueFieldIndex(.fromInterned(union_obj.enum_tag_type), enum_field_index);
-                const tag_matches = un.tag == field_tag.toIntern();
-                if (!tag_matches) {
+                const union_val = try sema.pointerDeref(block, src, union_ptr_val, union_ptr_val.typeOf(zcu)) orelse break :ct;
+                if (union_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, src, null);
+                const active_index = tag_ty.enumTagFieldIndex(union_val.unionTag(zcu).?, zcu).?;
+                if (active_index != field_index) {
                     const msg = msg: {
-                        const active_index = Type.fromInterned(union_obj.enum_tag_type).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
-                        const active_field_name = Type.fromInterned(union_obj.enum_tag_type).enumFieldName(active_index, zcu);
+                        const active_field_name = tag_ty.enumFieldName(active_index, zcu);
                         const msg = try sema.errMsg(src, "access of union field '{f}' while field '{f}' is active", .{
                             field_name.fmt(ip),
                             active_field_name.fmt(ip),
@@ -26520,11 +26403,10 @@ fn unionFieldPtr(
     // If the union has a tag, we must either set or or safety check it depending on `initializing`.
     tag: {
         if (union_ty.containerLayout(zcu) != .auto) break :tag;
-        const tag_ty: Type = .fromInterned(union_obj.enum_tag_type);
         if (tag_ty.classify(zcu) == .one_possible_value) break :tag;
         // There is a hypothetical non-trivial tag. We must set it even if not there at runtime, but
         // only emit a safety check if it's available at runtime (i.e. it's safety-tagged).
-        const want_tag = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
+        const want_tag = try pt.enumValueFieldIndex(tag_ty, field_index);
         if (initializing) {
             const set_tag_inst = try block.addBinOp(.set_union_tag, union_ptr, .fromValue(want_tag));
             try sema.checkComptimeKnownStore(block, set_tag_inst, .unneeded); // `unneeded` since this isn't a "proper" store
@@ -26540,7 +26422,9 @@ fn unionFieldPtr(
         _ = try block.addNoOp(.unreach);
         return .unreachable_value;
     }
-    return block.addStructFieldPtr(union_ptr, field_index, ptr_field_ty);
+
+    const field_ptr_ty = try sema.typeOf(union_ptr).fieldPtrType(field_index, pt);
+    return block.addStructFieldPtr(union_ptr, field_index, field_ptr_ty);
 }
 
 fn unionFieldVal(
@@ -26628,13 +26512,9 @@ fn elemPtr(
     try sema.ensureLayoutResolved(indexable_ty, src);
 
     const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {
-        .array, .vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
-        .@"struct" => blk: {
-            // Tuple field access.
-            const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{ .simple = .tuple_field_index });
-            const index: u32 = @intCast(index_val.toUnsignedInt(zcu));
-            break :blk try sema.tupleFieldPtr(block, src, indexable_ptr, elem_index_src, index, init);
-        },
+        .vector => try sema.elemPtrVector(block, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init),
+        .array => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
+        .@"struct" => try sema.tupleElemPtr(block, src, indexable_ptr, elem_index, elem_index_src),
         else => {
             const indexable = try sema.analyzeLoad(block, indexable_ptr_src, indexable_ptr, indexable_ptr_src);
             try sema.ensureLayoutResolved(sema.typeOf(indexable).childType(zcu), src);
@@ -26672,21 +26552,21 @@ fn elemPtrOneLayerOnly(
         .many, .c => {
             const maybe_ptr_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
             const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
+            const maybe_index: ?u64 = if (maybe_index_val) |val| val.toUnsignedInt(zcu) else null;
             ct: {
                 const ptr_val = maybe_ptr_val orelse break :ct;
-                const index_val = maybe_index_val orelse break :ct;
-                const index: usize = @intCast(index_val.toUnsignedInt(zcu));
-                const elem_ptr = try ptr_val.ptrElem(index, pt);
-                return Air.internedToRef(elem_ptr.toIntern());
+                const index: usize = @intCast(maybe_index orelse break :ct);
+                return .fromValue(try ptr_val.ptrElem(index, pt));
             }
 
             try sema.checkLogicalPtrOperation(block, src, indexable_ty);
-            const result_ty = try indexable_ty.elemPtrType(null, pt);
+
+            const result_ty = try indexable_ty.elemPtrType(maybe_index, pt);
 
             try sema.validateRuntimeElemAccess(block, elem_index_src, result_ty, indexable_ty, indexable_src);
             try sema.validateRuntimeValue(block, indexable_src, indexable);
 
-            if (result_ty.childType(zcu).abiSize(zcu) == 0) {
+            if (child_ty.abiSize(zcu) == 0) {
                 // zero-bit child type; just bitcast the pointer
                 return block.addBitCast(result_ty, indexable);
             }
@@ -26695,13 +26575,9 @@ fn elemPtrOneLayerOnly(
         },
         .one => {
             const elem_ptr = switch (child_ty.zigTypeTag(zcu)) {
-                .array, .vector => try sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety),
-                .@"struct" => blk: {
-                    assert(child_ty.isTuple(zcu));
-                    const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{ .simple = .tuple_field_index });
-                    const index: u32 = @intCast(index_val.toUnsignedInt(zcu));
-                    break :blk try sema.tupleFieldPtr(block, indexable_src, indexable, elem_index_src, index, false);
-                },
+                .vector => try sema.elemPtrVector(block, indexable_src, indexable, elem_index_src, elem_index, init),
+                .array => try sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety),
+                .@"struct" => try sema.tupleElemPtr(block, indexable_src, indexable, elem_index, elem_index_src),
                 else => unreachable, // Guaranteed by checkIndexable
             };
             try sema.checkKnownAllocPtr(block, indexable, elem_ptr);
@@ -26746,10 +26622,8 @@ fn elemVal(
                         const index: usize = @intCast(index_val.toUnsignedInt(zcu));
                         const many_ptr_ty = try pt.manyConstPtrType(child_ty);
                         const many_ptr_val = try pt.getCoerced(indexable_val, many_ptr_ty);
-                        const elem_ptr_ty = try pt.singleConstPtrType(child_ty);
                         const elem_ptr_val = try many_ptr_val.ptrElem(index, pt);
-                        const elem_val = try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty) orelse break :ct;
-                        return Air.internedToRef((try pt.getCoerced(elem_val, child_ty)).toIntern());
+                        return sema.analyzeLoad(block, src, .fromValue(elem_ptr_val), indexable_src);
                     }
 
                     if (try child_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
@@ -26824,70 +26698,38 @@ fn validateRuntimeElemAccess(
     }
 }
 
-/// Asserts that the layout of the tuple type is already resolved.
-fn tupleFieldPtr(
+/// Validates `elem_index`, and returns a pointer to that field using `structFieldPtrByIndex`.
+///
+/// Asserts that the type of `tuple_ptr` is a single-item pointer whose child type is a tuple.
+fn tupleElemPtr(
     sema: *Sema,
     block: *Block,
-    tuple_ptr_src: LazySrcLoc,
+    src: LazySrcLoc,
     tuple_ptr: Air.Inst.Ref,
-    field_index_src: LazySrcLoc,
-    field_index: u32,
-    init: bool,
+    elem_index: Air.Inst.Ref,
+    elem_index_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const tuple_ptr_ty = sema.typeOf(tuple_ptr);
-    const tuple_ptr_info = tuple_ptr_ty.ptrInfo(zcu);
-    const tuple_ty: Type = .fromInterned(tuple_ptr_info.child);
+    assert(tuple_ptr_ty.isSinglePointer(zcu));
+    const tuple_ty = tuple_ptr_ty.childType(zcu);
+    assert(tuple_ty.isTuple(zcu));
+
     const field_count = tuple_ty.structFieldCount(zcu);
-
-    tuple_ty.assertHasLayout(zcu);
-
     if (field_count == 0) {
-        return sema.fail(block, tuple_ptr_src, "indexing into empty tuple is not allowed", .{});
+        return sema.fail(block, src, "indexing into empty tuple is not allowed", .{});
     }
 
-    if (field_index >= field_count) {
-        return sema.fail(block, field_index_src, "index {d} outside tuple of length {d}", .{
-            field_index, field_count,
+    const elem_index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{ .simple = .tuple_field_index });
+    const index = elem_index_val.getUnsignedInt(zcu);
+    if (index == null or index.? >= field_count) {
+        return sema.fail(block, elem_index_src, "index '{f}' out of bounds of tuple '{f}'", .{
+            elem_index_val.fmtValueSema(pt, sema), tuple_ty.fmt(pt),
         });
     }
 
-    const field_ty = tuple_ty.fieldType(field_index, zcu);
-    const ptr_field_ty = try pt.ptrType(.{
-        .child = field_ty.toIntern(),
-        .flags = .{
-            .is_const = tuple_ptr_info.flags.is_const,
-            .is_volatile = tuple_ptr_info.flags.is_volatile,
-            .address_space = tuple_ptr_info.flags.address_space,
-            .alignment = a: {
-                if (tuple_ptr_info.flags.alignment == .none) break :a .none;
-                // The tuple pointer isn't naturally aligned, so the field pointer might be underaligned.
-                const tuple_align = tuple_ptr_info.flags.alignment;
-                const field_align = field_ty.abiAlignment(zcu);
-                break :a tuple_align.min(field_align);
-            },
-        },
-    });
-
-    if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_val| {
-        return Air.internedToRef((try pt.intern(.{ .ptr = .{
-            .ty = ptr_field_ty.toIntern(),
-            .base_addr = .{ .comptime_field = default_val.toIntern() },
-            .byte_offset = 0,
-        } })));
-    }
-
-    if (sema.resolveValue(tuple_ptr)) |tuple_ptr_val| {
-        const field_ptr_val = try tuple_ptr_val.ptrField(field_index, pt);
-        return Air.internedToRef(field_ptr_val.toIntern());
-    }
-
-    if (!init) {
-        try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_ptr_src);
-    }
-
-    return block.addStructFieldPtr(tuple_ptr, field_index, ptr_field_ty);
+    return sema.structFieldPtrByIndex(block, src, tuple_ptr, @intCast(index.?), tuple_ty);
 }
 
 fn tupleField(
@@ -26994,7 +26836,102 @@ fn elemValArray(
     return block.addBinOp(.array_elem_val, array, elem_index);
 }
 
-/// Asserts that the layout of the array or vector is already resolved.
+fn elemPtrVector(
+    sema: *Sema,
+    block: *Block,
+    vector_ptr_src: LazySrcLoc,
+    vector_ptr: Air.Inst.Ref,
+    elem_index_src: LazySrcLoc,
+    elem_index: Air.Inst.Ref,
+    init: bool,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const vector_ptr_ty = sema.typeOf(vector_ptr);
+    const vector_ty = vector_ptr_ty.childType(zcu);
+    assert(vector_ty.zigTypeTag(zcu) == .vector);
+    const vector_len = vector_ty.vectorLen(zcu);
+
+    if (vector_len == 0) {
+        return sema.fail(block, vector_ptr_src, "cannot index into empty vector", .{});
+    }
+
+    const maybe_vector_ptr_val = sema.resolveValue(vector_ptr);
+    // The index must not be undefined since it can be out of bounds.
+    const index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index) orelse {
+        return sema.fail(block, elem_index_src, "vector index not comptime known", .{});
+    };
+    const index = index_val.toUnsignedInt(zcu);
+    if (index >= vector_len) {
+        return sema.fail(block, elem_index_src, "index {d} outside vector of length {d}", .{ index, vector_len });
+    }
+
+    const elem_ty = vector_ty.childType(zcu);
+    const elem_bits = elem_ty.bitSize(zcu);
+    // Exiting this block means the operation is a runtime one.
+    const elem_ptr_ty: Type = if (elem_bits < 8 or !std.math.isPowerOfTwo(elem_bits)) elem_ptr_ty: {
+        // Use a packed pointer (i.e. vector_index != 0)
+        const vector_ptr_info = vector_ptr_ty.ptrInfo(zcu);
+        const elem_ptr_ty = try pt.ptrType(.{
+            .child = elem_ty.toIntern(),
+            .flags = .{
+                .size = .one,
+                .alignment = vector_ptr_info.flags.alignment,
+                .is_const = vector_ptr_info.flags.is_const,
+                .is_volatile = vector_ptr_info.flags.is_volatile,
+                .is_allowzero = vector_ptr_info.flags.is_allowzero,
+                .address_space = vector_ptr_info.flags.address_space,
+                .vector_index = @enumFromInt(index),
+            },
+            .packed_offset = .{
+                .host_size = @intCast(vector_len),
+                .bit_offset = 0,
+            },
+        });
+        if (maybe_vector_ptr_val) |ptr_val| {
+            if (ptr_val.isUndef(zcu)) return pt.undefRef(elem_ptr_ty);
+            return .fromValue(try pt.getCoerced(ptr_val, elem_ptr_ty));
+        }
+        break :elem_ptr_ty elem_ptr_ty;
+    } else elem_ptr_ty: {
+        // Use a normal pointer (i.e. vector_index == 0)
+        const vector_ptr_info = vector_ptr_ty.ptrInfo(zcu);
+        const elem_ptr_ty = try pt.ptrType(.{
+            .child = elem_ty.toIntern(),
+            .flags = .{
+                .size = .one,
+                // TODO: this logic was ported from old code, but it's bogus. This entire block will
+                // go away when https://github.com/ziglang/zig/issues/24061 is implemented anyway.
+                .alignment = switch (vector_ptr_info.flags.alignment) {
+                    .none => .none,
+                    else => |vec_align| switch (index * elem_ty.abiSize(zcu)) {
+                        0 => vec_align,
+                        else => |byte_offset| .minStrict(vec_align, .fromLog2Units(@ctz(byte_offset))),
+                    },
+                },
+                .is_const = vector_ptr_info.flags.is_const,
+                .is_volatile = vector_ptr_info.flags.is_volatile,
+                .is_allowzero = vector_ptr_info.flags.is_allowzero,
+                .address_space = vector_ptr_info.flags.address_space,
+            },
+        });
+        if (maybe_vector_ptr_val) |ptr_val| {
+            if (ptr_val.isUndef(zcu)) return pt.undefRef(elem_ptr_ty);
+            const bit_offset = index * @divExact(elem_ty.bitSize(zcu), 8);
+            return .fromValue(try ptr_val.getOffsetPtr(bit_offset, elem_ptr_ty, pt));
+        }
+        break :elem_ptr_ty elem_ptr_ty;
+    };
+
+    if (!init) {
+        try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, vector_ty, vector_ptr_src);
+        try sema.validateRuntimeValue(block, vector_ptr_src, vector_ptr);
+    }
+
+    return block.addPtrElemPtr(vector_ptr, elem_index, elem_ptr_ty);
+}
+
+/// Asserts that the layout of the array is already resolved.
 fn elemPtrArray(
     sema: *Sema,
     block: *Block,
@@ -27009,19 +26946,21 @@ fn elemPtrArray(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const array_ptr_ty = sema.typeOf(array_ptr);
+    assert(array_ptr_ty.ptrSize(zcu) == .one);
     const array_ty = array_ptr_ty.childType(zcu);
+    assert(array_ty.zigTypeTag(zcu) == .array);
     const array_sent = array_ty.sentinel(zcu) != null;
     const array_len = array_ty.arrayLen(zcu);
     const array_len_s = array_len + @intFromBool(array_sent);
 
     if (array_len_s == 0) {
-        return sema.fail(block, array_ptr_src, "indexing into empty array is not allowed", .{});
+        return sema.fail(block, array_ptr_src, "cannot index into empty array", .{});
     }
 
     const maybe_undef_array_ptr_val = sema.resolveValue(array_ptr);
     // The index must not be undefined since it can be out of bounds.
-    const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
-        const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(zcu));
+    const maybe_index: ?u64 = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
+        const index = index_val.toUnsignedInt(zcu);
         if (index >= array_len_s) {
             const sentinel_label: []const u8 = if (array_sent) " +1 (sentinel)" else "";
             return sema.fail(block, elem_index_src, "index {d} outside array of length {d}{s}", .{ index, array_len, sentinel_label });
@@ -27029,20 +26968,15 @@ fn elemPtrArray(
         break :o index;
     } else null;
 
-    if (offset == null and array_ty.zigTypeTag(zcu) == .vector) {
-        return sema.fail(block, elem_index_src, "vector index not comptime known", .{});
-    }
-
     array_ty.assertHasLayout(zcu);
-    const elem_ptr_ty = try array_ptr_ty.elemPtrType(offset, pt);
+    const elem_ptr_ty = try array_ptr_ty.elemPtrType(maybe_index, pt);
 
     if (maybe_undef_array_ptr_val) |array_ptr_val| {
         if (array_ptr_val.isUndef(zcu)) {
             return pt.undefRef(elem_ptr_ty);
         }
-        if (offset) |index| {
-            const elem_ptr = try array_ptr_val.ptrElem(index, pt);
-            return Air.internedToRef(elem_ptr.toIntern());
+        if (maybe_index) |index| {
+            return .fromValue(try array_ptr_val.ptrElem(index, pt));
         }
     }
 
@@ -27052,7 +26986,7 @@ fn elemPtrArray(
     }
 
     // Runtime check is only needed if unable to comptime check.
-    if (oob_safety and block.wantSafety() and offset == null) {
+    if (oob_safety and block.wantSafety() and maybe_index == null) {
         const len_inst = try pt.intRef(.usize, array_len);
         const cmp_op: Air.Inst.Tag = if (array_sent) .cmp_lte else .cmp_lt;
         try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
@@ -27075,9 +27009,9 @@ fn elemValSlice(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const slice_ty = sema.typeOf(slice);
+    assert(slice_ty.isSlice(zcu));
     const slice_sent = slice_ty.sentinel(zcu) != null;
     const elem_ty = slice_ty.childType(zcu);
-    var runtime_src = slice_src;
 
     elem_ty.assertHasLayout(zcu);
 
@@ -27087,7 +27021,6 @@ fn elemValSlice(
     const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
 
     if (maybe_slice_val) |slice_val| {
-        runtime_src = elem_index_src;
         const slice_len = slice_val.sliceLen(zcu);
         const slice_len_s = slice_len + @intFromBool(slice_sent);
         if (slice_len_s == 0) {
@@ -27099,12 +27032,8 @@ fn elemValSlice(
                 const sentinel_label: []const u8 = if (slice_sent) " +1 (sentinel)" else "";
                 return sema.fail(block, elem_index_src, "index {d} outside slice of length {d}{s}", .{ index, slice_len, sentinel_label });
             }
-            const elem_ptr_ty = try slice_ty.elemPtrType(index, pt);
             const elem_ptr_val = try slice_val.ptrElem(index, pt);
-            if (try sema.pointerDeref(block, slice_src, elem_ptr_val, elem_ptr_ty)) |elem_val| {
-                return Air.internedToRef(elem_val.toIntern());
-            }
-            runtime_src = slice_src;
+            return sema.analyzeLoad(block, src, .fromValue(elem_ptr_val), slice_src);
         }
     }
 
@@ -27138,17 +27067,19 @@ fn elemPtrSlice(
     const pt = sema.pt;
     const zcu = pt.zcu;
     const slice_ty = sema.typeOf(slice);
+    assert(slice_ty.isSlice(zcu));
     const slice_sent = slice_ty.sentinel(zcu) != null;
-
-    slice_ty.childType(zcu).assertHasLayout(zcu);
+    const elem_ty = slice_ty.childType(zcu);
+    elem_ty.assertHasLayout(zcu);
 
     const maybe_undef_slice_val = sema.resolveValue(slice);
     // The index must not be undefined since it can be out of bounds.
-    const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
-        break :o try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(zcu));
+    const offset: ?u64 = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
+        break :o index_val.toUnsignedInt(zcu);
     } else null;
 
     const elem_ptr_ty = try slice_ty.elemPtrType(offset, pt);
+    assert(elem_ptr_ty.childType(zcu).toIntern() == elem_ty.toIntern());
 
     if (maybe_undef_slice_val) |slice_val| {
         if (slice_val.isUndef(zcu)) {
@@ -27157,15 +27088,14 @@ fn elemPtrSlice(
         const slice_len = slice_val.sliceLen(zcu);
         const slice_len_s = slice_len + @intFromBool(slice_sent);
         if (slice_len_s == 0) {
-            return sema.fail(block, slice_src, "indexing into empty slice is not allowed", .{});
+            return sema.fail(block, slice_src, "cannot index into empty slice", .{});
         }
         if (offset) |index| {
             if (index >= slice_len_s) {
                 const sentinel_label: []const u8 = if (slice_sent) " +1 (sentinel)" else "";
                 return sema.fail(block, elem_index_src, "index {d} outside slice of length {d}{s}", .{ index, slice_len, sentinel_label });
             }
-            const elem_ptr_val = try slice_val.ptrElem(index, pt);
-            return Air.internedToRef(elem_ptr_val.toIntern());
+            return .fromValue(try slice_val.ptrElem(index, pt));
         }
     }
 
@@ -27182,7 +27112,7 @@ fn elemPtrSlice(
         const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
         try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
     }
-    if (slice_ty.childType(zcu).abiSize(zcu) == 0) {
+    if (elem_ty.abiSize(zcu) == 0) {
         // zero-bit child type; just extract the pointer and bitcast it
         const slice_ptr = try block.addTyOp(.slice_ptr, slice_ty.slicePtrFieldType(zcu), slice);
         return block.addBitCast(elem_ptr_ty, slice_ptr);
@@ -27546,7 +27476,7 @@ fn coerceExtra(
                             .sentinel = dest_info.sentinel,
                         });
                         const empty_array_val = try pt.aggregateValue(empty_array_ty, &.{});
-                        const empty_array_ptr = try sema.uavRef(empty_array_val.toIntern());
+                        const empty_array_ptr = try sema.uavRef(empty_array_val);
                         return sema.coerceArrayPtrToSlice(block, dest_ty, empty_array_ptr, inst_src);
                     }
 
@@ -28499,7 +28429,6 @@ pub fn coerceInMemoryAllowed(
         const field_count = dest_ty.structFieldCount(zcu);
         for (0..field_count) |field_idx| {
             if (dest_ty.structFieldIsComptime(field_idx, zcu) != src_ty.structFieldIsComptime(field_idx, zcu)) break :tuple;
-            if (dest_ty.resolvedFieldAlignment(field_idx, zcu) != src_ty.resolvedFieldAlignment(field_idx, zcu)) break :tuple;
             const dest_field_ty = dest_ty.fieldType(field_idx, zcu);
             const src_field_ty = src_ty.fieldType(field_idx, zcu);
             const field = try sema.coerceInMemoryAllowed(block, dest_field_ty, src_field_ty, dest_is_mut, target, dest_src, src_src, null);
@@ -29953,12 +29882,14 @@ pub fn ensureNavResolved(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index:
 fn optRefValue(sema: *Sema, opt_val: ?Value) !Value {
     const pt = sema.pt;
     const ptr_anyopaque_ty = try pt.singleConstPtrType(.anyopaque);
-    return Value.fromInterned(try pt.intern(.{ .opt = .{
-        .ty = (try pt.optionalType(ptr_anyopaque_ty.toIntern())).toIntern(),
-        .val = if (opt_val) |val| (try pt.getCoerced(
-            Value.fromInterned(try pt.refValue(val.toIntern())),
-            ptr_anyopaque_ty,
-        )).toIntern() else .none,
+    const opt_ptr_anyopaque_ty = try pt.optionalType(ptr_anyopaque_ty.toIntern());
+    return .fromInterned(try pt.intern(.{ .opt = .{
+        .ty = opt_ptr_anyopaque_ty.toIntern(),
+        .val = payload: {
+            const val = opt_val orelse break :payload .none;
+            const ptr_val = try pt.getCoerced(try pt.uavValue(val), ptr_anyopaque_ty);
+            break :payload ptr_val.toIntern();
+        },
     } }));
 }
 
@@ -30078,7 +30009,7 @@ fn analyzeRef(
         switch (zcu.intern_pool.indexToKey(val.toIntern())) {
             .@"extern" => |e| return sema.analyzeNavRef(block, src, e.owner_nav),
             .func => |f| return sema.analyzeNavRef(block, src, f.owner_nav),
-            else => return uavRef(sema, val.toIntern()),
+            else => return uavRef(sema, val),
         }
     }
 
@@ -30528,7 +30459,7 @@ fn analyzeSlice(
     } else ptr_or_slice;
 
     const start = try sema.coerce(block, .usize, uncasted_start, start_src);
-    const new_ptr = try sema.analyzePtrArithmetic(block, src, ptr, start, .ptr_add, ptr_src, start_src);
+    const new_ptr = try sema.analyzePtrArithmetic(block, src, ptr, start, .ptr_add, start_src);
     const new_ptr_ty = sema.typeOf(new_ptr);
 
     // true if and only if the end index of the slice, implicitly or explicitly, equals
@@ -30666,7 +30597,7 @@ fn analyzeSlice(
                 break :msg msg;
             });
         }
-        return sema.analyzePtrArithmetic(block, src, ptr, start, .ptr_add, ptr_src, start_src);
+        return sema.analyzePtrArithmetic(block, src, ptr, start, .ptr_add, start_src);
     };
 
     const sentinel = s: {
@@ -32118,12 +32049,12 @@ fn resolvePeerTypesInner(
 
                 ptr_info.flags.alignment = a: {
                     // If both alignments are implicit, the result alignment is implicit.
-                    // e.g. '[*c]u32' + '[*c]c_uint' -> '[*c]u32'
+                    // e.g. '*u32' + '*c_uint' -> '*u32'
                     if (ptr_info.flags.alignment == .none and peer_info.flags.alignment == .none) {
                         break :a .none;
                     }
                     // Otherwise (if either alignment is explicit), the result alignment is explicit.
-                    // e.g. '[*c]u32' + '[*c]align(4) c_uint' -> '[*c]align(4) u32'
+                    // e.g. '*u32' + '*align(4) c_uint' -> '*align(4) u32'
                     const cur_align = switch (ptr_info.flags.alignment) {
                         .none => Type.fromInterned(ptr_info.child).abiAlignment(zcu),
                         else => ptr_info.flags.alignment,
@@ -33583,7 +33514,7 @@ fn notePathToComptimeAllocPtr(
         else => {}, // there will be another stage
     }
 
-    const derivation = try comptime_ptr.pointerDerivationAdvanced(arena, pt, false, sema);
+    const derivation = try comptime_ptr.pointerDerivation(arena, pt, sema);
 
     var second_path_aw: std.Io.Writer.Allocating = .init(arena);
     defer second_path_aw.deinit();
diff --git a/src/Type.zig b/src/Type.zig
index 8b1c71cc9631a8085c4b8908ce09d1c9d69a057b..81ee1e560e6505eb6721b13b6fbdd2338e1694e0 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -2337,35 +2337,11 @@ pub fn fieldType(ty: Type, index: usize, zcu: *const Zcu) Type {
     return .fromInterned(types.get(ip)[index]);
 }
 
-// TODO MLUGG: clean up doc comments and usages of `{resolved,explicit}FieldAlignment`
-
-/// Returns the alignment of the given struct, tuple, or union field.
-/// Asserts that the layout of `ty` is resolved. Asserts that `ty` is not packed.
-/// Never returns `.none`, even if the field's alignment was not specified.
-pub fn resolvedFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment {
-    switch (ty.explicitFieldAlignment(index, zcu)) {
-        .none => {},
-        else => |explicit| return explicit,
-    }
-    const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .tuple_type => |tuple| Type.fromInterned(tuple.types.get(ip)[index]).abiAlignment(zcu),
-        .struct_type => {
-            assertHasLayout(ty, zcu);
-            const struct_obj = ip.loadStructType(ty.toIntern());
-            const field_ty: Type = .fromInterned(struct_obj.field_types.get(ip)[index]);
-            return field_ty.defaultStructFieldAlignment(struct_obj.layout, zcu);
-        },
-        .union_type => {
-            assertHasLayout(ty, zcu);
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[index]);
-            return field_ty.abiAlignment(zcu);
-        },
-        else => unreachable,
-    };
-}
-
+/// If an alignment was explicitly specified for the given field of the struct or union type `ty`,
+/// returns that. Otherwise, returns `.none`. This function also supports tuples, for which it
+/// always returns `.none`.
+///
+/// Asserts that the layout of `ty` is resolved, unless `ty` is a tuple.
 pub fn explicitFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
@@ -2388,7 +2364,10 @@ pub fn explicitFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment
     };
 }
 
-/// Returns the alignment a struct field will have if not explicitly specified.
+/// Returns the alignment a struct field of type `field_ty` will be given if no alignment is
+/// explicitly specified. However, in an `extern struct`, a higher alignment may be available due
+/// to the struct's full layout (i.e. a field might coincidentally be more aligned).
+///
 /// Asserts that the layout of `field_ty` is resolved. Asserts that `layout` is not `.@"packed"`.
 pub fn defaultStructFieldAlignment(
     field_ty: Type,
@@ -2664,45 +2643,6 @@ pub fn arrayBase(ty: Type, zcu: *const Zcu) struct { Type, u64 } {
     return .{ cur_ty, cur_len };
 }
 
-/// Returns a bit-pointer with the same value and a new packed offset.
-pub fn packedStructFieldPtrInfo(
-    struct_ty: Type,
-    parent_ptr_ty: Type,
-    field_idx: u32,
-    pt: Zcu.PerThread,
-) InternPool.Key.PtrType.PackedOffset {
-    comptime assert(Type.packed_struct_layout_version == 2);
-
-    const zcu = pt.zcu;
-    const parent_ptr_info = parent_ptr_ty.ptrInfo(zcu);
-
-    var bit_offset: u16 = 0;
-    var running_bits: u16 = 0;
-    for (0..struct_ty.structFieldCount(zcu)) |i| {
-        const f_ty = struct_ty.fieldType(i, zcu);
-        if (i == field_idx) {
-            bit_offset = running_bits;
-        }
-        running_bits += @intCast(f_ty.bitSize(zcu));
-    }
-
-    const res_host_size: u16, const res_bit_offset: u16 = if (parent_ptr_info.packed_offset.host_size != 0) .{
-        parent_ptr_info.packed_offset.host_size,
-        parent_ptr_info.packed_offset.bit_offset + bit_offset,
-    } else .{
-        switch (zcu.comp.getZigBackend()) {
-            else => (running_bits + 7) / 8,
-            .stage2_x86_64, .stage2_c => @intCast(struct_ty.abiSize(zcu)),
-        },
-        bit_offset,
-    };
-
-    return .{
-        .host_size = res_host_size,
-        .bit_offset = res_bit_offset,
-    };
-}
-
 pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu) Zcu.UnionLayout {
     const ip = &zcu.intern_pool;
     var most_aligned_field: u32 = 0;
@@ -2770,88 +2710,225 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu)
     };
 }
 
-/// Returns the type of a pointer to an element.
-/// Asserts that the type is a pointer, and that the element type is indexable.
-/// If the element index is comptime-known, it must be passed in `offset`.
-/// For *@Vector(n, T), return *align(a:b:h:v) T
-/// For *[N]T, return *T
-/// For [*]T, returns *T
-/// For []T, returns *T
-/// Handles const-ness and address spaces in particular.
-/// This code is duplicated in `Sema.analyzePtrArithmetic`.
-/// May perform type resolution and return a transitive `error.AnalysisFail`.
-/// MLUGG TODO audit this shit
-pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {
+/// Asserts that `ptr_ty` is either a many-item pointer, a slice, a C pointer, or a single pointer
+/// to array (in other words, a pointer which is indexed by pointer arithmetic), and returns the
+/// type of the element pointer at the given index.
+///
+/// Asserts that the layout of the pointer element type is resolved.
+///
+/// If `index` is `null`, the index is an arbitrary runtime-known value.
+pub fn elemPtrType(ptr_ty: Type, index: ?u64, pt: Zcu.PerThread) Allocator.Error!Type {
     const zcu = pt.zcu;
-    const ptr_info = ptr_ty.ptrInfo(zcu);
+    const ip = &zcu.intern_pool;
+    const ptr_info = ip.indexToKey(ptr_ty.toIntern()).ptr_type;
     const elem_ty: Type = switch (ptr_info.flags.size) {
-        .one => switch (Type.fromInterned(ptr_info.child).zigTypeTag(zcu)) {
-            .array, .vector => Type.fromInterned(ptr_info.child).childType(zcu),
-            else => .fromInterned(ptr_info.child),
+        .slice, .many, .c => .fromInterned(ptr_info.child),
+        .one => switch (ip.indexToKey(ptr_info.child)) {
+            .array_type => |array_type| .fromInterned(array_type.child),
+            else => unreachable,
         },
-        .many, .c, .slice => .fromInterned(ptr_info.child),
     };
-    const is_allowzero = ptr_info.flags.is_allowzero and (offset orelse 0) == 0;
-    const parent_ty = ptr_ty.childType(zcu);
+    elem_ty.assertHasLayout(zcu);
+    const elem_align: Alignment = switch (elem_ty.classify(zcu)) {
+        .no_possible_value,
+        .one_possible_value,
+        => ptr_info.flags.alignment,
 
-    const VI = InternPool.Key.PtrType.VectorIndex;
+        .partially_comptime,
+        .fully_comptime,
+        => switch (ptr_info.flags.alignment) {
+            .none => .none,
+            else => |array_align| .minStrict(array_align, elem_ty.abiAlignment(zcu)),
+        },
 
-    const vector_info: struct {
-        host_size: u16 = 0,
-        alignment: Alignment = .none,
-        vector_index: VI = .none,
-    } = if (parent_ty.isVector(zcu) and ptr_info.flags.size == .one) blk: {
-        const elem_bits = elem_ty.bitSize(zcu);
-        if (elem_bits == 0) break :blk .{};
-        const is_packed = elem_bits < 8 or !std.math.isPowerOfTwo(elem_bits);
-        if (!is_packed) break :blk .{};
-
-        break :blk .{
-            .host_size = @intCast(parent_ty.arrayLen(zcu)),
-            .alignment = parent_ty.abiAlignment(zcu),
-            .vector_index = @enumFromInt(offset.?),
-        };
-    } else .{};
-
-    const alignment: Alignment = a: {
-        // Calculate the new pointer alignment.
-        if (ptr_info.flags.alignment == .none) {
-            // In case of an ABI-aligned pointer, any pointer arithmetic
-            // maintains the same ABI-alignedness.
-            break :a vector_info.alignment;
-        }
-        // If the addend is not a comptime-known value we can still count on
-        // it being a multiple of the type size.
-        const elem_size = elem_ty.abiSize(zcu);
-        const addend = if (offset) |off| elem_size * off else elem_size;
-
-        // The resulting pointer is aligned to the lcd between the offset (an
-        // arbitrary number) and the alignment factor (always a power of two,
-        // non zero).
-        const new_align: Alignment = @enumFromInt(@min(
-            @ctz(addend),
-            ptr_info.flags.alignment.toLog2Units(),
-        ));
-        assert(new_align != .none);
-        break :a new_align;
+        .runtime => switch (ptr_info.flags.alignment) {
+            .none => .none,
+            else => |array_align| elem_align: {
+                // If the index is runtime-known, use 1 as it gives the minimum possible alignment.
+                const effective_index = index orelse 1;
+                if (effective_index == 0) break :elem_align array_align;
+                const byte_offset = effective_index * elem_ty.abiSize(zcu);
+                break :elem_align .minStrict(array_align, .fromLog2Units(@ctz(byte_offset)));
+            },
+        },
     };
     return pt.ptrType(.{
         .child = elem_ty.toIntern(),
         .flags = .{
-            .alignment = alignment,
+            .size = .one,
             .is_const = ptr_info.flags.is_const,
             .is_volatile = ptr_info.flags.is_volatile,
-            .is_allowzero = is_allowzero,
+            .is_allowzero = ptr_info.flags.is_allowzero and (index == null or index == 0),
             .address_space = ptr_info.flags.address_space,
-            .vector_index = vector_info.vector_index,
-        },
-        .packed_offset = .{
-            .host_size = vector_info.host_size,
-            .bit_offset = 0,
+            .alignment = elem_align,
         },
     });
 }
 
+/// Asserts that `ptr_ty` is a pointer (single-item or C) to a struct, union, tuple, or slice, and
+/// returns the type of a pointer to the field at `field_index`.
+///
+/// Asserts that the layout of the pointer child type is resolved.
+///
+/// For slices, `Value.slice_ptr_index` and `Value.slice_len_index` are used for the field index.
+pub fn fieldPtrType(ptr_ty: Type, field_index: u32, pt: Zcu.PerThread) Allocator.Error!Type {
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const ptr_info = ip.indexToKey(ptr_ty.toIntern()).ptr_type;
+    assert(ptr_info.flags.size == .one or ptr_info.flags.size == .c);
+    const aggregate_ty: Type = .fromInterned(ptr_info.child);
+    aggregate_ty.assertHasLayout(zcu);
+    // We only exit this `switch` for default-layout aggregates, where the field pointer alignment
+    // is a simple minimum of the aggregate pointer alignment and the field alignment.
+    // `field_align` is `.none` if there is no explicit alignment annotation.
+    const field_ty: Type, const field_align: Alignment = switch (aggregate_ty.zigTypeTag(zcu)) {
+        .@"struct" => switch (aggregate_ty.containerLayout(zcu)) {
+            .auto => field: {
+                if (aggregate_ty.isTuple(zcu)) {
+                    break :field .{ aggregate_ty.fieldType(field_index, zcu), .none };
+                }
+                const struct_obj = ip.loadStructType(aggregate_ty.toIntern());
+                break :field .{
+                    .fromInterned(struct_obj.field_types.get(ip)[field_index]),
+                    struct_obj.field_aligns.getOrNone(ip, field_index),
+                };
+            },
+            .@"extern" => {
+                // Field alignment is determined based on the actual field offset. For instance, in
+                // `extern struct { x: u32, y: u16 }`, the `y` field is 4-byte aligned.
+                const field_ty = aggregate_ty.fieldType(field_index, zcu);
+                const field_offset = aggregate_ty.structFieldOffset(field_index, zcu);
+                const parent_align = switch (ptr_info.flags.alignment) {
+                    .none => aggregate_ty.abiAlignment(zcu),
+                    else => |a| a,
+                };
+                const actual_field_align = switch (field_offset) {
+                    0 => parent_align,
+                    else => parent_align.minStrict(.fromLog2Units(@ctz(field_offset))),
+                };
+                const field_ptr_align: Alignment = a: {
+                    if (parent_align == .none and
+                        aggregate_ty.explicitFieldAlignment(field_index, zcu) == .none and
+                        actual_field_align == field_ty.abiAlignment(zcu))
+                    {
+                        // There's no user-specified 'align' in sight, and the alignment from the
+                        // field offset matches the field type's natural alignment, so just use a
+                        // default-aligned pointer.
+                        break :a .none;
+                    }
+                    break :a actual_field_align;
+                };
+                var field_ptr_info = ptr_info;
+                field_ptr_info.child = field_ty.toIntern();
+                field_ptr_info.flags.alignment = field_ptr_align;
+                return pt.ptrType(field_ptr_info);
+            },
+            .@"packed" => {
+                var field_ptr_info = ptr_info;
+                if (field_ptr_info.flags.alignment == .none) {
+                    field_ptr_info.flags.alignment = aggregate_ty.abiAlignment(zcu);
+                }
+                field_ptr_info.packed_offset = packed_offset: {
+                    comptime assert(Type.packed_struct_layout_version == 2);
+                    const bit_offset = zcu.structPackedFieldBitOffset(
+                        ip.loadStructType(aggregate_ty.toIntern()),
+                        field_index,
+                    );
+                    break :packed_offset if (ptr_info.packed_offset.host_size != 0) .{
+                        .host_size = ptr_info.packed_offset.host_size,
+                        .bit_offset = ptr_info.packed_offset.bit_offset + bit_offset,
+                    } else .{
+                        .host_size = switch (zcu.comp.getZigBackend()) {
+                            else => @intCast((aggregate_ty.bitSize(zcu) + 7) / 8),
+                            .stage2_x86_64, .stage2_c => @intCast(aggregate_ty.abiSize(zcu)),
+                        },
+                        .bit_offset = ptr_info.packed_offset.bit_offset + bit_offset,
+                    };
+                };
+                field_ptr_info.child = aggregate_ty.fieldType(field_index, zcu).toIntern();
+                return pt.ptrType(field_ptr_info);
+            },
+        },
+        .@"union" => switch (aggregate_ty.containerLayout(zcu)) {
+            .auto => field: {
+                const union_obj = ip.loadUnionType(aggregate_ty.toIntern());
+                break :field .{
+                    .fromInterned(union_obj.field_types.get(ip)[field_index]),
+                    union_obj.field_aligns.getOrNone(ip, field_index),
+                };
+            },
+            .@"extern" => {
+                // The alignment always matches that of the union pointer. If the union pointer is
+                // default aligned (`.none`), we may need to explicitly align the result pointer.
+                const field_ty = aggregate_ty.fieldType(field_index, zcu);
+                var field_ptr_info = ptr_info;
+                field_ptr_info.child = field_ty.toIntern();
+                if (field_ptr_info.flags.alignment == .none and
+                    Alignment.compareStrict(field_ty.abiAlignment(zcu), .neq, aggregate_ty.abiAlignment(zcu)))
+                {
+                    field_ptr_info.flags.alignment = aggregate_ty.abiAlignment(zcu);
+                }
+                return pt.ptrType(field_ptr_info);
+            },
+            .@"packed" => {
+                const field_ty = aggregate_ty.fieldType(field_index, zcu);
+                var field_ptr_info = ptr_info;
+                if (field_ptr_info.flags.alignment == .none) {
+                    const resolved_align = aggregate_ty.abiAlignment(zcu);
+                    if (field_ty.abiAlignment(zcu) != resolved_align) {
+                        field_ptr_info.flags.alignment = resolved_align;
+                    }
+                }
+                field_ptr_info.child = aggregate_ty.fieldType(field_index, zcu).toIntern();
+                return pt.ptrType(field_ptr_info);
+            },
+        },
+        .pointer => field: {
+            assert(aggregate_ty.isSlice(zcu));
+            break :field switch (field_index) {
+                Value.slice_ptr_index => .{ aggregate_ty.slicePtrFieldType(zcu), .none },
+                Value.slice_len_index => .{ .usize, .none },
+                else => unreachable,
+            };
+        },
+        else => unreachable,
+    };
+    const field_ptr_align: Alignment = a: {
+        if (aggregate_ty.zigTypeTag(zcu) == .@"struct" and aggregate_ty.structFieldIsComptime(field_index, zcu)) {
+            // For `comptime` fields, just use exactly what was specified, or ABI alignment if nothing was specified.
+            break :a field_align;
+        }
+        const actual_field_align = switch (field_align) {
+            .none => switch (ip.indexToKey(aggregate_ty.toIntern())) {
+                .tuple_type, .union_type => field_ty.abiAlignment(zcu),
+                .struct_type => field_ty.defaultStructFieldAlignment(.auto, zcu),
+                .ptr_type => Type.usize.abiAlignment(zcu),
+                else => unreachable,
+            },
+            else => |a| a,
+        };
+        const actual_aggregate_align = switch (ptr_info.flags.alignment) {
+            .none => aggregate_ty.abiAlignment(zcu),
+            else => |a| a,
+        };
+        if (actual_aggregate_align.compareStrict(.lt, actual_field_align)) {
+            // Underaligned aggregate; use that alignment.
+            assert(ptr_info.flags.alignment != .none);
+            break :a actual_aggregate_align;
+        }
+        if (field_align == .none and actual_field_align == field_ty.abiAlignment(zcu)) {
+            // No explicit annotation on the field (nor an unusual default), and the aggregate
+            // alignment is irrelevant to us, so return an un-annotated pointer.
+            break :a .none;
+        }
+        break :a actual_field_align;
+    };
+    var field_ptr_info = ptr_info;
+    field_ptr_info.flags.alignment = field_ptr_align;
+    field_ptr_info.child = field_ty.toIntern();
+    return pt.ptrType(field_ptr_info);
+}
+
 pub fn containerTypeName(ty: Type, ip: *const InternPool) InternPool.NullTerminatedString {
     return switch (ip.indexToKey(ty.toIntern())) {
         .struct_type => ip.loadStructType(ty.toIntern()).name,
diff --git a/src/Value.zig b/src/Value.zig
index d158aa558c1c63a5cab26832774270680a61e5e7..5cc20853da7634efc3b0925d77fa01ab65c1e9a7 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -1687,9 +1687,6 @@ pub fn makeBool(x: bool) Value {
 /// `parent_ptr` must be a single-pointer or C pointer to some optional.
 ///
 /// Returns a pointer to the payload of the optional.
-///
-/// May perform type resolution.
-/// MLUGG TODO audit
 pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr_ty = parent_ptr.typeOf(zcu);
@@ -1715,7 +1712,7 @@ pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     }
 
     const base_ptr = try parent_ptr.canonicalizeBasePtr(.one, opt_ty, pt);
-    return Value.fromInterned(try pt.intern(.{ .ptr = .{
+    return .fromInterned(try pt.intern(.{ .ptr = .{
         .ty = result_ty.toIntern(),
         .base_addr = .{ .opt_payload = base_ptr.toIntern() },
         .byte_offset = 0,
@@ -1724,8 +1721,6 @@ pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
 
 /// `parent_ptr` must be a single-pointer to some error union.
 /// Returns a pointer to the payload of the error union.
-/// May perform type resolution.
-/// MLUGG TODO audit
 pub fn ptrEuPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr_ty = parent_ptr.typeOf(zcu);
@@ -1745,137 +1740,57 @@ pub fn ptrEuPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value {
     if (parent_ptr.isUndef(zcu)) return pt.undefValue(result_ty);
 
     const base_ptr = try parent_ptr.canonicalizeBasePtr(.one, eu_ty, pt);
-    return Value.fromInterned(try pt.intern(.{ .ptr = .{
+    return .fromInterned(try pt.intern(.{ .ptr = .{
         .ty = result_ty.toIntern(),
         .base_addr = .{ .eu_payload = base_ptr.toIntern() },
         .byte_offset = 0,
     } }));
 }
 
-// MLUGG TODO: audit ptrField etc in terms of resolution, and probably move them under sema
-
-/// `parent_ptr` must be a single-pointer or c pointer to a struct, union, or slice.
+/// `parent_ptr` must be a single-item pointer or C pointer to a struct, union, or slice.
 ///
 /// Returns a pointer to the aggregate field at the specified index.
 ///
 /// For slices, uses `slice_ptr_index` and `slice_len_index`.
 ///
-/// May perform type resolution.
+/// Asserts that the layout of the aggregate type is resolved.
 pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr_ty = parent_ptr.typeOf(zcu);
     const aggregate_ty = parent_ptr_ty.childType(zcu);
+    aggregate_ty.assertHasLayout(zcu);
 
     const parent_ptr_info = parent_ptr_ty.ptrInfo(zcu);
     assert(parent_ptr_info.flags.size == .one or parent_ptr_info.flags.size == .c);
 
-    // Exiting this `switch` indicates that the `field` pointer representation should be used.
-    const field_ty: Type, const new_align: InternPool.Alignment = switch (aggregate_ty.zigTypeTag(zcu)) {
-        .@"struct" => field: {
-            const field_ty = aggregate_ty.fieldType(field_idx, zcu);
-            switch (aggregate_ty.containerLayout(zcu)) {
-                .auto => break :field .{ field_ty, a: {
-                    if (parent_ptr_info.flags.alignment == .none) {
-                        break :a aggregate_ty.explicitFieldAlignment(field_idx, zcu);
-                    }
-                    const field_align = aggregate_ty.resolvedFieldAlignment(field_idx, zcu);
-                    break :a field_align.min(parent_ptr_info.flags.alignment);
-                } },
-                .@"extern" => {
-                    // Well-defined layout, so just offset the pointer appropriately.
-                    const byte_off = aggregate_ty.structFieldOffset(field_idx, zcu);
-                    const field_align: InternPool.Alignment = a: {
-                        if (byte_off == 0) break :a parent_ptr_info.flags.alignment;
-                        const true_field_align: InternPool.Alignment = .fromLog2Units(@ctz(byte_off));
-                        if (parent_ptr_info.flags.alignment == .none and
-                            true_field_align == field_ty.abiAlignment(zcu))
-                        {
-                            break :a .none;
-                        }
-                        const parent_align = if (parent_ptr_info.flags.alignment == .none) pa: {
-                            break :pa aggregate_ty.abiAlignment(zcu);
-                        } else parent_ptr_info.flags.alignment;
-                        break :a .minStrict(true_field_align, parent_align);
-                    };
-                    const result_ty = try pt.ptrType(info: {
-                        var new = parent_ptr_info;
-                        new.child = field_ty.toIntern();
-                        new.flags.alignment = field_align;
-                        break :info new;
-                    });
-                    return parent_ptr.getOffsetPtr(byte_off, result_ty, pt);
-                },
-                .@"packed" => {
-                    const packed_offset = aggregate_ty.packedStructFieldPtrInfo(parent_ptr_ty, field_idx, pt);
-                    const result_ty = try pt.ptrType(info: {
-                        var new = parent_ptr_info;
-                        new.packed_offset = packed_offset;
-                        new.child = field_ty.toIntern();
-                        if (new.flags.alignment == .none) {
-                            new.flags.alignment = aggregate_ty.abiAlignment(zcu);
-                        }
-                        break :info new;
-                    });
-                    return pt.getCoerced(parent_ptr, result_ty);
-                },
-            }
+    const field_ptr_ty = try parent_ptr_ty.fieldPtrType(field_idx, pt);
+
+    switch (aggregate_ty.zigTypeTag(zcu)) {
+        .pointer => assert(aggregate_ty.isSlice(zcu)),
+        .@"struct" => switch (aggregate_ty.containerLayout(zcu)) {
+            .auto => {},
+            .@"extern" => return parent_ptr.getOffsetPtr(
+                aggregate_ty.structFieldOffset(field_idx, zcu),
+                field_ptr_ty,
+                pt,
+            ),
+            .@"packed" => return pt.getCoerced(parent_ptr, field_ptr_ty),
         },
-        .@"union" => field: {
-            const union_obj = zcu.typeToUnion(aggregate_ty).?;
-            const field_ty = Type.fromInterned(union_obj.field_types.get(&zcu.intern_pool)[field_idx]);
-            switch (aggregate_ty.containerLayout(zcu)) {
-                .auto => break :field .{ field_ty, a: {
-                    if (parent_ptr_info.flags.alignment == .none) {
-                        break :a aggregate_ty.explicitFieldAlignment(field_idx, zcu);
-                    }
-                    const field_align = aggregate_ty.resolvedFieldAlignment(field_idx, zcu);
-                    break :a field_align.min(parent_ptr_info.flags.alignment);
-                } },
-                .@"extern" => {
-                    // Point to the same address.
-                    const result_ty = try pt.ptrType(info: {
-                        var new = parent_ptr_info;
-                        new.child = field_ty.toIntern();
-                        break :info new;
-                    });
-                    return pt.getCoerced(parent_ptr, result_ty);
-                },
-                .@"packed" => {
-                    const result_ty = try pt.ptrType(info: {
-                        var new = parent_ptr_info;
-                        new.child = field_ty.toIntern();
-                        break :info new;
-                    });
-                    return pt.getCoerced(parent_ptr, result_ty);
-                },
-            }
-        },
-        .pointer => field_ty: {
-            assert(aggregate_ty.isSlice(zcu));
-            break :field_ty .{ switch (field_idx) {
-                Value.slice_ptr_index => aggregate_ty.slicePtrFieldType(zcu),
-                Value.slice_len_index => Type.usize,
-                else => unreachable,
-            }, switch (parent_ptr_info.flags.alignment) {
-                .none => .none,
-                else => Type.usize.abiAlignment(zcu).min(parent_ptr_info.flags.alignment),
-            } };
+        .@"union" => switch (aggregate_ty.containerLayout(zcu)) {
+            .auto => {},
+            .@"packed", .@"extern" => return pt.getCoerced(parent_ptr, field_ptr_ty),
         },
         else => unreachable,
-    };
+    }
 
-    const result_ty = try pt.ptrType(info: {
-        var new = parent_ptr_info;
-        new.child = field_ty.toIntern();
-        new.flags.alignment = new_align;
-        break :info new;
-    });
+    // If we get here, we need to use the `.field` comptime pointer representation, because the
+    // aggregate does not have a well-defined layout.
 
-    if (parent_ptr.isUndef(zcu)) return pt.undefValue(result_ty);
+    if (parent_ptr.isUndef(zcu)) return pt.undefValue(field_ptr_ty);
 
     const base_ptr = try parent_ptr.canonicalizeBasePtr(.one, aggregate_ty, pt);
-    return Value.fromInterned(try pt.intern(.{ .ptr = .{
-        .ty = result_ty.toIntern(),
+    return .fromInterned(try pt.intern(.{ .ptr = .{
+        .ty = field_ptr_ty.toIntern(),
         .base_addr = .{ .field = .{
             .base = base_ptr.toIntern(),
             .index = field_idx,
@@ -1884,10 +1799,9 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
     } }));
 }
 
-/// `orig_parent_ptr` must be either a single-pointer to an array or vector, or a many-pointer or C-pointer or slice.
+/// `orig_parent_ptr` must be either a single-pointer to an array, a slice, a many-item pointer, or a C pointer.
 /// Returns a pointer to the element at the specified index.
-/// May perform type resolution.
-/// MLUGG TODO AUDIT
+/// Asserts that the layout of the pointer element type is resolved.
 pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     const parent_ptr = switch (orig_parent_ptr.typeOf(zcu).ptrSize(zcu)) {
@@ -1896,77 +1810,50 @@ pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value
     };
 
     const parent_ptr_ty = parent_ptr.typeOf(zcu);
-    const elem_ty = parent_ptr_ty.childType(zcu);
-    const result_ty = try parent_ptr_ty.elemPtrType(@intCast(field_idx), pt);
+    const result_ty = try parent_ptr_ty.elemPtrType(field_idx, pt);
+    const elem_ty = result_ty.childType(zcu);
+    elem_ty.assertHasLayout(zcu);
 
     if (parent_ptr.isUndef(zcu)) return pt.undefValue(result_ty);
 
-    if (result_ty.ptrInfo(zcu).packed_offset.host_size != 0) {
-        // Since we have a bit-pointer, the pointer address should be unchanged.
-        assert(elem_ty.zigTypeTag(zcu) == .vector);
+    if (!elem_ty.comptimeOnly(zcu)) {
+        const byte_offset = field_idx * elem_ty.abiSize(zcu);
+        return parent_ptr.getOffsetPtr(byte_offset, result_ty, pt);
+    }
+
+    // Comptime-only element type.
+
+    if (field_idx == 0) {
         return pt.getCoerced(parent_ptr, result_ty);
     }
 
-    const PtrStrat = union(enum) {
-        offset: u64,
-        elem_ptr: Type, // many-ptr elem ty
-    };
-
-    const strat: PtrStrat = switch (parent_ptr_ty.ptrSize(zcu)) {
-        .one => switch (elem_ty.zigTypeTag(zcu)) {
-            .vector => .{ .offset = field_idx * @divExact(elem_ty.childType(zcu).bitSize(zcu), 8) },
-            .array => strat: {
-                const arr_elem_ty = elem_ty.childType(zcu);
-                if (arr_elem_ty.comptimeOnly(zcu)) break :strat .{ .elem_ptr = arr_elem_ty };
-                break :strat .{ .offset = field_idx * arr_elem_ty.abiSize(zcu) };
-            },
-            else => unreachable,
-        },
-
-        .many, .c => if (elem_ty.comptimeOnly(zcu))
-            .{ .elem_ptr = elem_ty }
-        else
-            .{ .offset = field_idx * elem_ty.abiSize(zcu) },
-
-        .slice => unreachable,
-    };
-
-    switch (strat) {
-        .offset => |byte_offset| {
-            return parent_ptr.getOffsetPtr(byte_offset, result_ty, pt);
-        },
-        .elem_ptr => |manyptr_elem_ty| if (field_idx == 0) {
-            return pt.getCoerced(parent_ptr, result_ty);
-        } else {
-            const arr_base_ty, const arr_base_len = manyptr_elem_ty.arrayBase(zcu);
-            const base_idx = arr_base_len * field_idx;
-            const parent_info = zcu.intern_pool.indexToKey(parent_ptr.toIntern()).ptr;
-            switch (parent_info.base_addr) {
-                .arr_elem => |arr_elem| {
-                    if (Value.fromInterned(arr_elem.base).typeOf(zcu).childType(zcu).toIntern() == arr_base_ty.toIntern()) {
-                        // We already have a pointer to an element of an array of this type.
-                        // Just modify the index.
-                        return Value.fromInterned(try pt.intern(.{ .ptr = ptr: {
-                            var new = parent_info;
-                            new.base_addr.arr_elem.index += base_idx;
-                            new.ty = result_ty.toIntern();
-                            break :ptr new;
-                        } }));
-                    }
-                },
-                else => {},
+    const arr_base_ty, const arr_base_len = elem_ty.arrayBase(zcu);
+    const base_idx = arr_base_len * field_idx;
+    const parent_info = zcu.intern_pool.indexToKey(parent_ptr.toIntern()).ptr;
+    switch (parent_info.base_addr) {
+        .arr_elem => |arr_elem| {
+            if (Value.fromInterned(arr_elem.base).typeOf(zcu).childType(zcu).toIntern() == arr_base_ty.toIntern()) {
+                // We already have a pointer to an element of an array of this type.
+                // Just modify the index.
+                return .fromInterned(try pt.intern(.{ .ptr = ptr: {
+                    var new = parent_info;
+                    new.base_addr.arr_elem.index += base_idx;
+                    new.ty = result_ty.toIntern();
+                    break :ptr new;
+                } }));
             }
-            const base_ptr = try parent_ptr.canonicalizeBasePtr(.many, arr_base_ty, pt);
-            return Value.fromInterned(try pt.intern(.{ .ptr = .{
-                .ty = result_ty.toIntern(),
-                .base_addr = .{ .arr_elem = .{
-                    .base = base_ptr.toIntern(),
-                    .index = base_idx,
-                } },
-                .byte_offset = 0,
-            } }));
         },
+        else => {},
     }
+    const base_ptr = try parent_ptr.canonicalizeBasePtr(.many, arr_base_ty, pt);
+    return .fromInterned(try pt.intern(.{ .ptr = .{
+        .ty = result_ty.toIntern(),
+        .base_addr = .{ .arr_elem = .{
+            .base = base_ptr.toIntern(),
+            .index = base_idx,
+        } },
+        .byte_offset = 0,
+    } }));
 }
 
 fn canonicalizeBasePtr(base_ptr: Value, want_size: std.builtin.Type.Pointer.Size, want_child: Type, pt: Zcu.PerThread) !Value {
@@ -2062,19 +1949,11 @@ pub const PointerDeriveStep = union(enum) {
     }
 };
 
-pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread) Allocator.Error!PointerDeriveStep {
-    return ptr_val.pointerDerivationAdvanced(arena, pt, false, null) catch |err| switch (err) {
-        error.OutOfMemory => |e| return e,
-        error.Canceled => @panic("TODO"), // pls remove from error set mlugg
-        error.AnalysisFail => unreachable,
-    };
-}
-
 /// Given a pointer value, get the sequence of steps to derive it, ideally by taking
 /// only field and element pointers with no casts. This can be used by codegen backends
 /// which prefer field/elem accesses when lowering constant pointer values.
 /// It is also used by the Value printing logic for pointers.
-pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, comptime resolve_types: bool, opt_sema: ?*Sema) !PointerDeriveStep {
+pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, opt_sema: ?*Sema) Allocator.Error!PointerDeriveStep {
     // MLUGG TODO: audit tf outta this code
     const zcu = pt.zcu;
     const ptr = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
@@ -2118,7 +1997,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const base_ptr = Value.fromInterned(eu_ptr);
             const base_ptr_ty = base_ptr.typeOf(zcu);
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(eu_ptr), arena, pt, resolve_types, opt_sema);
+            parent_step.* = try pointerDerivation(.fromInterned(eu_ptr), arena, pt, opt_sema);
             break :base .{ .eu_payload_ptr = .{
                 .parent = parent_step,
                 .result_ptr_ty = try pt.adjustPtrTypeChild(base_ptr_ty, base_ptr_ty.childType(zcu).errorUnionPayload(zcu)),
@@ -2128,7 +2007,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const base_ptr = Value.fromInterned(opt_ptr);
             const base_ptr_ty = base_ptr.typeOf(zcu);
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(opt_ptr), arena, pt, resolve_types, opt_sema);
+            parent_step.* = try pointerDerivation(.fromInterned(opt_ptr), arena, pt, opt_sema);
             break :base .{ .opt_payload_ptr = .{
                 .parent = parent_step,
                 .result_ptr_ty = try pt.adjustPtrTypeChild(base_ptr_ty, base_ptr_ty.childType(zcu).optionalChild(zcu)),
@@ -2137,48 +2016,27 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
         .field => |field| base: {
             const base_ptr = Value.fromInterned(field.base);
             const base_ptr_ty = base_ptr.typeOf(zcu);
-            const agg_ty = base_ptr_ty.childType(zcu);
-            if (resolve_types) try opt_sema.?.ensureLayoutResolved(agg_ty, .unneeded); // MLUGG TODO: unneeded is a hack
-            const field_ty: Type, const field_align: InternPool.Alignment = switch (agg_ty.zigTypeTag(zcu)) {
-                .@"struct", .@"union" => .{ agg_ty.fieldType(@intCast(field.index), zcu), agg_ty.resolvedFieldAlignment(@intCast(field.index), pt.zcu) },
-                .pointer => switch (field.index) {
-                    Value.slice_ptr_index => .{ agg_ty.slicePtrFieldType(zcu), Type.ptrAbiAlignment(zcu.getTarget()) },
-                    Value.slice_len_index => .{ .usize, Type.abiAlignment(.usize, zcu) },
-                    else => unreachable,
-                },
-                else => unreachable,
-            };
-            const base_align = base_ptr_ty.ptrAlignment(zcu);
-            const result_align = field_align.minStrict(base_align);
-            const result_ty = try pt.ptrType(.{
-                .child = field_ty.toIntern(),
-                .flags = flags: {
-                    var flags = base_ptr_ty.ptrInfo(zcu).flags;
-                    if (result_align == field_ty.abiAlignment(zcu)) {
-                        flags.alignment = .none;
-                    } else {
-                        flags.alignment = result_align;
-                    }
-                    break :flags flags;
-                },
-            });
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(base_ptr, arena, pt, resolve_types, opt_sema);
+            parent_step.* = try pointerDerivation(base_ptr, arena, pt, opt_sema);
             break :base .{ .field_ptr = .{
                 .parent = parent_step,
                 .field_idx = @intCast(field.index),
-                .result_ptr_ty = result_ty,
+                .result_ptr_ty = try base_ptr_ty.fieldPtrType(@intCast(field.index), pt),
             } };
         },
         .arr_elem => |arr_elem| base: {
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(arr_elem.base), arena, pt, resolve_types, opt_sema);
+            parent_step.* = try pointerDerivation(.fromInterned(arr_elem.base), arena, pt, opt_sema);
             const parent_ptr_info = (try parent_step.ptrType(pt)).ptrInfo(zcu);
             const result_ptr_ty = try pt.ptrType(.{
                 .child = parent_ptr_info.child,
                 .flags = flags: {
                     var flags = parent_ptr_info.flags;
                     flags.size = .one;
+                    if (flags.alignment != .none) flags.alignment = .minStrict(
+                        flags.alignment,
+                        Type.fromInterned(parent_ptr_info.child).abiAlignment(zcu),
+                    );
                     break :flags flags;
                 },
             });
@@ -2299,26 +2157,12 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
                     const end_off = start_off + field_ty.abiSize(zcu);
                     if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
                         const old_ptr_ty = try cur_derive.ptrType(pt);
-                        const parent_align = old_ptr_ty.ptrAlignment(zcu);
-                        const field_align = InternPool.Alignment.fromLog2Units(@min(parent_align.toLog2Units(), @ctz(start_off)));
                         const parent = try arena.create(PointerDeriveStep);
                         parent.* = cur_derive;
-                        const new_ptr_ty = try pt.ptrType(.{
-                            .child = field_ty.toIntern(),
-                            .flags = flags: {
-                                var flags = old_ptr_ty.ptrInfo(zcu).flags;
-                                if (field_align == field_ty.abiAlignment(zcu)) {
-                                    flags.alignment = .none;
-                                } else {
-                                    flags.alignment = field_align;
-                                }
-                                break :flags flags;
-                            },
-                        });
                         cur_derive = .{ .field_ptr = .{
                             .parent = parent,
                             .field_idx = @intCast(field_idx),
-                            .result_ptr_ty = new_ptr_ty,
+                            .result_ptr_ty = try old_ptr_ty.fieldPtrType(@intCast(field_idx), pt),
                         } };
                         cur_offset -= start_off;
                         break;
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 9ae8e47a754aaf88121af4c800f2601b38fe0589..19702aee088915922972df9555c7a8a628529956 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -3813,9 +3813,9 @@ pub const AtomicPtrAlignmentDiagnostics = struct {
     max_bits: u16 = undefined,
 };
 
-/// If ABI alignment of `ty` is OK for atomic operations, returns 0.
-/// Otherwise returns the alignment required on a pointer for the target
-/// to perform atomic operations.
+/// Returns the alignment required for the target to perform atomic operations on type `ty` (that
+/// is, the required align attribute on the pointer). If the ABI alignment of `ty` is sufficient,
+/// returns `.none`.
 // TODO this function does not take into account CPU features, which can affect
 // this value. Audit this!
 pub fn atomicPtrAlignment(
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 7de74743c3540370784ee7e26d50f052fa4a679e..703edd41152fa80601c25647114b42192408fa08 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -3943,10 +3943,7 @@ pub fn navPtrType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Allocator.Err
     return pt.ptrType(.{
         .child = ty,
         .flags = .{
-            .alignment = if (alignment == Type.fromInterned(ty).abiAlignment(zcu))
-                .none
-            else
-                alignment,
+            .alignment = alignment,
             .address_space = @"addrspace",
             .is_const = is_const,
         },
@@ -4015,23 +4012,24 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
     namespace.generation = zcu.generation;
 }
 
-pub fn refValue(pt: Zcu.PerThread, val: InternPool.Index) Zcu.SemaError!InternPool.Index {
-    const ptr_ty = (try pt.ptrType(.{
-        .child = pt.zcu.intern_pool.typeOf(val),
+pub fn uavValue(pt: Zcu.PerThread, val: Value) Zcu.SemaError!Value {
+    const zcu = pt.zcu;
+    const ptr_ty = try pt.ptrType(.{
+        .child = val.typeOf(zcu).toIntern(),
         .flags = .{
             .alignment = .none,
             .is_const = true,
             .address_space = .generic,
         },
-    })).toIntern();
-    return pt.intern(.{ .ptr = .{
-        .ty = ptr_ty,
+    });
+    return .fromInterned(try pt.intern(.{ .ptr = .{
+        .ty = ptr_ty.toIntern(),
         .base_addr = .{ .uav = .{
-            .val = val,
-            .orig_ty = ptr_ty,
+            .val = val.toIntern(),
+            .orig_ty = ptr_ty.toIntern(),
         } },
         .byte_offset = 0,
-    } });
+    } }));
 }
 
 pub fn addDependency(pt: Zcu.PerThread, unit: AnalUnit, dependee: InternPool.Dependee) Allocator.Error!void {
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index f0df1aa1c0d0f072944a1f6d6dbd2bfc5f462f75..879dc0e45a649a24692c7b49d0af71de71f061c8 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -1215,7 +1215,7 @@ pub const DeclGen = struct {
             .ptr => {
                 var arena = std.heap.ArenaAllocator.init(zcu.gpa);
                 defer arena.deinit();
-                const derivation = try val.pointerDerivation(arena.allocator(), pt);
+                const derivation = try val.pointerDerivation(arena.allocator(), pt, null);
                 try dg.renderPointer(w, derivation, location);
             },
             .opt => |opt| switch (ctype.info(ctype_pool)) {
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index 217581a72ce28eb36f6f0a08a78640124ad2e293..d303af6d610ded6effd8ff80e41cdab36650bd90 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -1038,7 +1038,7 @@ fn constantPtr(cg: *CodeGen, ptr_val: Value) !Id {
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
 
-    const derivation = try ptr_val.pointerDerivation(arena.allocator(), pt);
+    const derivation = try ptr_val.pointerDerivation(arena.allocator(), pt, null);
     return cg.derivePtr(derivation);
 }
 
diff --git a/src/print_value.zig b/src/print_value.zig
index d05fe09ec15416b21e5adfe7324f6375fd6d6ff5..46fbe63a6b12c2d755efffb62c2ef98a590af966 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -25,10 +25,7 @@ pub fn formatSema(ctx: FormatContext, writer: *Writer) Writer.Error!void {
     const sema = ctx.opt_sema.?;
     return print(ctx.val, writer, ctx.depth, ctx.pt, sema) catch |err| switch (err) {
         error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function
-        error.ComptimeBreak, error.ComptimeReturn => unreachable,
-        error.AnalysisFail => unreachable, // TODO: re-evaluate when we use `sema` more fully
-        error.Canceled => @panic("TODO"), // pls stop returning this error mlugg
-        else => |e| return e,
+        error.WriteFailed => |e| return e,
     };
 }
 
@@ -36,9 +33,7 @@ pub fn format(ctx: FormatContext, writer: *Writer) Writer.Error!void {
     std.debug.assert(ctx.opt_sema == null);
     return print(ctx.val, writer, ctx.depth, ctx.pt, null) catch |err| switch (err) {
         error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function
-        error.ComptimeBreak, error.ComptimeReturn, error.AnalysisFail => unreachable,
-        error.Canceled => @panic("TODO"), // pls stop returning this error mlugg
-        else => |e| return e,
+        error.WriteFailed => |e| return e,
     };
 }
 
@@ -48,7 +43,7 @@ pub fn print(
     level: u8,
     pt: Zcu.PerThread,
     opt_sema: ?*Sema,
-) (Writer.Error || Zcu.CompileError)!void {
+) (Writer.Error || Allocator.Error)!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     switch (ip.indexToKey(val.toIntern())) {
@@ -212,7 +207,7 @@ fn printAggregate(
     level: u8,
     pt: Zcu.PerThread,
     opt_sema: ?*Sema,
-) (Writer.Error || Zcu.CompileError)!void {
+) (Writer.Error || Allocator.Error)!void {
     if (level == 0) {
         if (is_ref) try writer.writeByte('&');
         return writer.writeAll(".{ ... }");
@@ -307,7 +302,7 @@ fn printPtr(
     level: u8,
     pt: Zcu.PerThread,
     opt_sema: ?*Sema,
-) (Writer.Error || Zcu.CompileError)!void {
+) (Writer.Error || Allocator.Error)!void {
     const ptr = switch (pt.zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
         .undef => return writer.writeAll("undefined"),
         .ptr => |ptr| ptr,
@@ -332,10 +327,7 @@ fn printPtr(
 
     var arena = std.heap.ArenaAllocator.init(pt.zcu.gpa);
     defer arena.deinit();
-    const derivation = if (opt_sema) |sema|
-        try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, true, sema)
-    else
-        try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, false, null);
+    const derivation = try ptr_val.pointerDerivation(arena.allocator(), pt, opt_sema);
 
     _ = try printPtrDerivation(derivation, writer, pt, want_kind, .{ .print_val = .{
         .level = level,
-- 
2.54.0


From a9bfc94ee65f1dafe5c67bb8fbd58cd2372cfd28 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 2 Feb 2026 13:32:06 +0000
Subject: [PATCH 428/499] compiler: small misc cleanups

---
 lib/std/zig.zig       |   4 +-
 src/Compilation.zig   |  23 +++----
 src/Sema.zig          | 140 +++++++++++++++++++++++-------------------
 src/Zcu/PerThread.zig |  50 ++-------------
 4 files changed, 94 insertions(+), 123 deletions(-)

diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index 26abf81a11a6b3707b84bd86f2b1a33a4b6b92b9..ca72dac442f36a5d4858780e0e9d61e021a553b7 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -868,7 +868,7 @@ pub const SimpleComptimeReason = enum(u32) {
     casted_to_comptime_enum,
     casted_to_comptime_int,
     casted_to_comptime_float,
-    panic_handler,
+    std_builtin_decl,
 
     pub fn message(r: SimpleComptimeReason) []const u8 {
         return switch (r) {
@@ -957,7 +957,7 @@ pub const SimpleComptimeReason = enum(u32) {
             .casted_to_comptime_enum      => "value casted to enum with 'comptime_int' tag type must be comptime-known",
             .casted_to_comptime_int       => "value casted to 'comptime_int' must be comptime-known",
             .casted_to_comptime_float     => "value casted to 'comptime_float' must be comptime-known",
-            .panic_handler                => "panic handler must be comptime-known",
+            .std_builtin_decl             => "'std.builtin' declaration values must be comptime-known",
             // zig fmt: on
         };
     }
diff --git a/src/Compilation.zig b/src/Compilation.zig
index ba8a2907f9116e618941b6bad6e1cf2f35f76a7f..8b863c302202da3246c240f4612ec03e81f12afc 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -986,7 +986,9 @@ const Job = union(enum) {
     /// If the unit is a *test* function, an `analyze_func` job will also be queued.
     analyze_unit: InternPool.AnalUnit,
     /// The main source file for the module needs to be analyzed.
-    analyze_mod: *Package.Module,
+    /// For every module which is an analysis root, analyze the main struct type of the module's
+    /// root source file. This is how semantic analysis begins.
+    analyze_roots,
 
     /// The value is the index into `windows_libs`.
     windows_import_lib: usize,
@@ -1396,7 +1398,6 @@ pub const MiscTask = enum {
     wasi_libc_crt_file,
     compiler_rt,
     libzigc,
-    analyze_mod,
     link_depfile,
     docs_copy,
     docs_wasm,
@@ -4840,9 +4841,7 @@ fn performAllTheWork(
         try zcu.flushRetryableFailures();
 
         // It's analysis time! Queue up our initial analysis.
-        for (zcu.analysisRoots()) |mod| {
-            try comp.queueJob(.{ .analyze_mod = mod });
-        }
+        try comp.queueJob(.analyze_roots);
 
         zcu.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
         if (comp.bin_file != null) {
@@ -5275,15 +5274,17 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 try pt.zcu.ensureFuncBodyAnalysisQueued(ip.getNav(nav).status.fully_resolved.val);
             }
         },
-        .analyze_mod => |mod| {
-            const tracy_trace = traceNamed(@src(), "analyze_mod");
+        .analyze_roots => {
+            const tracy_trace = traceNamed(@src(), "analyze_roots");
             defer tracy_trace.end();
 
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
+            const zcu = comp.zcu.?;
+            const pt: Zcu.PerThread = .activate(zcu, tid);
             defer pt.deactivate();
-
-            const mod_root_file = pt.zcu.module_roots.get(mod).?.unwrap().?;
-            try pt.ensureFileAnalyzed(mod_root_file);
+            for (zcu.analysisRoots()) |analysis_root_mod| {
+                const analysis_root_file = zcu.module_roots.get(analysis_root_mod).?.unwrap().?;
+                try pt.ensureFileAnalyzed(analysis_root_file);
+            }
         },
         .windows_import_lib => |index| {
             const tracy_trace = traceNamed(@src(), "windows_import_lib");
diff --git a/src/Sema.zig b/src/Sema.zig
index fd4e067fe37d0705fb8c5722b970b777981ee7c4..799da305ed7495a8c78120dfe639b00798bb36d4 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2308,6 +2308,7 @@ pub fn resolveConstValue(
     /// being comptime-resolved is that the block is being comptime-evaluated.
     reason: ?ComptimeReason,
 ) CompileError!Value {
+    assert(reason != null or block.isComptime());
     return sema.resolveValue(inst) orelse {
         return sema.failWithNeededComptime(block, src, reason);
     };
@@ -12927,6 +12928,8 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             try pt.ensureFileAnalyzed(file_index);
             const ty: Type = .fromInterned(zcu.fileRootType(file_index));
             try sema.addTypeReferenceEntry(operand_src, ty);
+            // No need for `ensureNamespaceUpToDate`, because `Zcu.PerThread.updateFileNamespace`
+            // already made sure that all root file structs have up-to-date namespaces.
             return .fromType(ty);
         },
         .zon => {
@@ -16342,7 +16345,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const alignment_val = try pt.intValue(.comptime_int, bytes: {
                 if (info.flags.alignment.toByteUnits()) |b| break :bytes b;
                 const elem_ty: Type = .fromInterned(info.child);
-                // MLUGG TODO: this resolution is sus, but i doubt i'll solve it in this branch
                 try sema.ensureLayoutResolved(elem_ty, src);
                 break :bytes elem_ty.abiAlignment(zcu).toByteUnits().?;
             });
@@ -18942,12 +18944,13 @@ fn structInitAnon(
                 .file_scope = block.getFileScopeIndex(zcu),
                 .generation = zcu.generation,
             });
+            errdefer pt.destroyNamespace(new_namespace_index);
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
     try sema.addTypeReferenceEntry(src, struct_ty);
+    // No need for `ensureNamespaceUpToDate` because this type's namespace is always empty.
     try sema.ensureLayoutResolved(struct_ty, src);
 
     _ = opt_runtime_index orelse {
@@ -20150,6 +20153,7 @@ fn zirReifyStruct(
     })) {
         .existing => |ty| {
             try sema.addTypeReferenceEntry(src, .fromInterned(ty));
+            // No need for `ensureNamespaceUpToDate` because this type's namespace is always empty.
             return .fromIntern(ty);
         },
         .wip => |wip| {
@@ -20210,9 +20214,9 @@ fn zirReifyStruct(
                 .file_scope = block.getFileScopeIndex(zcu),
                 .generation = zcu.generation,
             });
-            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
+            errdefer pt.destroyNamespace(new_namespace_index);
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
+            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
             return .fromIntern(wip.finish(ip, new_namespace_index));
         },
     }
@@ -20393,6 +20397,7 @@ fn zirReifyUnion(
     })) {
         .existing => |ty| {
             try sema.addTypeReferenceEntry(src, .fromInterned(ty));
+            // No need for `ensureNamespaceUpToDate` because this type's namespace is always empty.
             return .fromIntern(ty);
         },
         .wip => |wip| {
@@ -20430,9 +20435,9 @@ fn zirReifyUnion(
                 .file_scope = block.getFileScopeIndex(zcu),
                 .generation = zcu.generation,
             });
+            errdefer pt.destroyNamespace(new_namespace_index);
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
             try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
-
             return .fromIntern(wip.finish(ip, new_namespace_index));
         },
     }
@@ -20557,6 +20562,7 @@ fn zirReifyEnum(
     })) {
         .existing => |ty| {
             try sema.addTypeReferenceEntry(src, .fromInterned(ty));
+            // No need for `ensureNamespaceUpToDate` because this type's namespace is always empty.
             return .fromIntern(ty);
         },
         .wip => |wip| {
@@ -20581,10 +20587,9 @@ fn zirReifyEnum(
                 .file_scope = block.getFileScopeIndex(zcu),
                 .generation = zcu.generation,
             });
-
-            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
+            errdefer pt.destroyNamespace(new_namespace_index);
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
+            try sema.addTypeReferenceEntry(src, .fromInterned(wip.index));
             return .fromIntern(wip.finish(ip, new_namespace_index));
         },
     }
@@ -33861,7 +33866,7 @@ pub fn resolveNavPtrModifiers(
     };
 }
 
-pub fn analyzeMemoizedState(sema: *Sema, block: *Block, simple_src: LazySrcLoc, builtin_namespace: InternPool.NamespaceIndex, stage: InternPool.MemoizedStateStage) CompileError!bool {
+pub fn analyzeMemoizedState(sema: *Sema, stage: InternPool.MemoizedStateStage) CompileError!bool {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -33869,53 +33874,87 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, simple_src: LazySrcLoc,
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
+    // This `Block` acts kind of like it's evaluating a `comptime` declaration in the root source
+    // file of the standard library. In particular, its namespace is the root std namespace.
+    var block: Block = block: {
+        // Get the main struct type of the root source file of `std`. No need for a reference entry
+        // because `std` is always an analysis root.
+        const std_file_index = zcu.module_roots.get(zcu.std_mod).?.unwrap().?;
+        try pt.ensureFileAnalyzed(std_file_index);
+        const std_type: Type = .fromInterned(zcu.fileRootType(std_file_index));
+        break :block .{
+            .parent = null,
+            .sema = sema,
+            .namespace = std_type.getNamespaceIndex(zcu),
+            .instructions = .empty,
+            .inlining = null,
+            .comptime_reason = null,
+            .src_base_inst = std_type.typeDeclInst(zcu).?,
+            .type_name_ctx = .empty,
+        };
+    };
+    defer block.instructions.deinit(gpa);
+
+    const std_builtin_ty: Type = ty: {
+        const std_src = block.nodeOffset(.zero);
+        const decl_name = try ip.getOrPutString(gpa, io, pt.tid, "builtin", .no_embedded_nulls);
+        const nav = try sema.namespaceLookup(&block, std_src, block.namespace, decl_name) orelse {
+            return sema.fail(&block, std_src, "'std' missing 'builtin'", .{});
+        };
+        const uncoerced_val = try sema.analyzeNavVal(&block, std_src, nav);
+        const decl_src: LazySrcLoc = .{
+            .base_node_inst = ip.getNav(nav).srcInst(ip),
+            .offset = .nodeOffset(.zero),
+        };
+        break :ty try sema.analyzeAsType(&block, decl_src, .std_builtin_decl, uncoerced_val);
+    };
+
     var any_changed = false;
 
     inline for (comptime std.enums.values(Zcu.BuiltinDecl)) |builtin_decl| {
         if (stage == comptime builtin_decl.stage()) {
-            const parent_ns: Zcu.Namespace.Index, const parent_name: []const u8, const name: []const u8 = switch (comptime builtin_decl.access()) {
-                .direct => |name| .{ builtin_namespace, "std.builtin", name },
+            const parent_ns_ty: Type, const parent_name: []const u8, const name: []const u8 = switch (comptime builtin_decl.access()) {
+                .direct => |name| .{ std_builtin_ty, "std.builtin", name },
                 .nested => |nested| access: {
-                    const parent_ty: Type = .fromInterned(zcu.builtin_decl_values.get(nested[0]));
-                    const parent_ns = parent_ty.getNamespace(zcu).unwrap() orelse {
-                        return sema.fail(block, simple_src, "std.builtin.{s} is not a container type", .{@tagName(nested[0])});
-                    };
-                    break :access .{ parent_ns, "std.builtin." ++ @tagName(nested[0]), nested[1] };
+                    const parent_decl, const name = nested;
+                    const parent_ty: Type = .fromInterned(zcu.builtin_decl_values.get(parent_decl));
+                    break :access .{ parent_ty, "std.builtin." ++ @tagName(parent_decl), name };
                 },
             };
 
+            const parent_ns = parent_ns_ty.getNamespace(zcu).unwrap() orelse {
+                return sema.fail(&block, block.nodeOffset(.zero), "'{s}' is not a container type", .{parent_name});
+            };
+            const parent_ty_src = parent_ns_ty.srcLoc(zcu);
             const name_nts = try ip.getOrPutString(gpa, io, pt.tid, name, .no_embedded_nulls);
-            const nav = try sema.namespaceLookup(block, simple_src, parent_ns, name_nts) orelse
-                return sema.fail(block, simple_src, "{s} missing {s}", .{ parent_name, name });
+            const nav = try sema.namespaceLookup(&block, parent_ty_src, parent_ns, name_nts) orelse {
+                return sema.fail(&block, parent_ty_src, "'{s}' missing '{s}'", .{ parent_name, name });
+            };
+            const uncoerced_val = try sema.analyzeNavVal(&block, parent_ty_src, nav);
 
-            const src: LazySrcLoc = .{
+            const decl_src: LazySrcLoc = .{
                 .base_node_inst = ip.getNav(nav).srcInst(ip),
                 .offset = .nodeOffset(.zero),
             };
 
-            const result = try sema.analyzeNavVal(block, src, nav);
-
-            const uncoerced_val = try sema.resolveConstDefinedValue(block, src, result, null);
             const val: Value = switch (builtin_decl.kind()) {
-                .type => if (uncoerced_val.typeOf(zcu).zigTypeTag(zcu) != .type) {
-                    return sema.fail(block, src, "{s}.{s} is not a type", .{ parent_name, name });
-                } else val: {
-                    try sema.ensureLayoutResolved(uncoerced_val.toType(), src);
-                    break :val uncoerced_val;
+                .type => val: {
+                    const ty = try sema.analyzeAsType(&block, decl_src, .std_builtin_decl, uncoerced_val);
+                    try sema.ensureLayoutResolved(ty, decl_src);
+                    break :val ty.toValue();
                 },
                 .func => val: {
                     const func_ty = try sema.getExpectedBuiltinFnType(builtin_decl);
-                    const coerced = try sema.coerce(block, func_ty, Air.internedToRef(uncoerced_val.toIntern()), src);
-                    break :val .fromInterned(coerced.toInterned().?);
+                    const coerced = try sema.coerce(&block, func_ty, uncoerced_val, decl_src);
+                    break :val try sema.resolveConstDefinedValue(&block, decl_src, coerced, .{ .simple = .std_builtin_decl });
                 },
                 .string => val: {
-                    const coerced = try sema.coerce(block, .slice_const_u8, Air.internedToRef(uncoerced_val.toIntern()), src);
-                    break :val .fromInterned(coerced.toInterned().?);
+                    const coerced = try sema.coerce(&block, .slice_const_u8, uncoerced_val, decl_src);
+                    break :val try sema.resolveConstDefinedValue(&block, decl_src, coerced, .{ .simple = .std_builtin_decl });
                 },
             };
 
-            const prev = zcu.builtin_decl_values.get(builtin_decl);
-            if (val.toIntern() != prev) {
+            if (zcu.builtin_decl_values.get(builtin_decl) != val.toIntern()) {
                 zcu.builtin_decl_values.set(builtin_decl, val.toIntern());
                 any_changed = true;
             }
@@ -34147,21 +34186,15 @@ fn zirStructDecl(
             });
             errdefer pt.destroyNamespace(new_namespace_index);
             try pt.scanNamespace(new_namespace_index, struct_decl.decls);
-
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
 
     try sema.addTypeReferenceEntry(src, ty);
-
-    // Make sure we update the namespace if the declaration is re-analyzed, to pick
-    // up on e.g. changed comptime decls.
-    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
     try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
 
-    return .fromIntern(ty.toIntern());
+    return .fromType(ty);
 }
 fn zirUnionDecl(
     sema: *Sema,
@@ -34218,7 +34251,6 @@ fn zirUnionDecl(
         .wip => |wip| ty: {
             errdefer wip.cancel(ip, pt.tid);
             try sema.setTypeName(block, &wip, union_decl.name_strategy, "union", inst);
-
             const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
                 .parent = block.namespace.toOptional(),
                 .owner_type = wip.index,
@@ -34226,23 +34258,16 @@ fn zirUnionDecl(
                 .generation = zcu.generation,
             });
             errdefer pt.destroyNamespace(new_namespace_index);
-
             try pt.scanNamespace(new_namespace_index, union_decl.decls);
-
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
 
     try sema.addTypeReferenceEntry(src, ty);
-
-    // Make sure we update the namespace if the declaration is re-analyzed, to pick
-    // up on e.g. changed comptime decls.
-    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
     try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
 
-    return .fromIntern(ty.toIntern());
+    return .fromType(ty);
 }
 fn zirEnumDecl(
     sema: *Sema,
@@ -34277,9 +34302,7 @@ fn zirEnumDecl(
         .existing => |ty| .fromInterned(ty),
         .wip => |wip| ty: {
             errdefer wip.cancel(ip, pt.tid);
-
             try sema.setTypeName(block, &wip, enum_decl.name_strategy, "enum", inst);
-
             const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
                 .parent = block.namespace.toOptional(),
                 .owner_type = wip.index,
@@ -34287,23 +34310,16 @@ fn zirEnumDecl(
                 .generation = zcu.generation,
             });
             errdefer pt.destroyNamespace(new_namespace_index);
-
             try pt.scanNamespace(new_namespace_index, enum_decl.decls);
-
             if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
             break :ty .fromInterned(wip.finish(ip, new_namespace_index));
         },
     };
 
     try sema.addTypeReferenceEntry(src, ty);
-
-    // Make sure we update the namespace if the declaration is re-analyzed, to pick
-    // up on e.g. changed comptime decls.
-    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
     try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
 
-    return .fromIntern(ty.toIntern());
+    return .fromType(ty);
 }
 fn zirOpaqueDecl(
     sema: *Sema,
@@ -34350,11 +34366,7 @@ fn zirOpaqueDecl(
     };
 
     try sema.addTypeReferenceEntry(src, ty);
-
-    // Make sure we update the namespace if the declaration is re-analyzed, to pick
-    // up on e.g. changed comptime decls.
-    // TODO MLUGG: me no likey, maybe model namespaces less badly idk
     try pt.ensureNamespaceUpToDate(ty.getNamespaceIndex(zcu));
 
-    return .fromIntern(ty.toIntern());
+    return .fromType(ty);
 }
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 703edd41152fa80601c25647114b42192408fa08..8d6af9c3ad7c4e688be88323f3578ce571a2f500 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -688,6 +688,8 @@ pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Alloca
 
     if (zcu.fileRootType(file_index) != .none) return; // already good
 
+    if (zcu.comp.time_report) |*tr| tr.stats.n_imported_files += 1;
+
     const file = zcu.fileByIndex(file_index);
     assert(file.getMode() == .zig);
     const struct_decl = file.zir.?.getStructDecl(.main_struct_inst);
@@ -719,13 +721,8 @@ pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Alloca
     });
     errdefer pt.destroyNamespace(new_namespace_index);
     try pt.scanNamespace(new_namespace_index, struct_decl.decls);
-
     if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
-
-    const file_root_type: Type = .fromInterned(wip.finish(ip, new_namespace_index));
-
-    zcu.setFileRootType(file_index, file_root_type.toIntern());
-    if (zcu.comp.time_report) |*tr| tr.stats.n_imported_files += 1;
+    zcu.setFileRootType(file_index, wip.finish(ip, new_namespace_index));
 }
 
 /// Ensures that all memoized state on `Zcu` is up-to-date, performing re-analysis if necessary.
@@ -810,37 +807,14 @@ pub fn ensureMemoizedStateUpToDate(pt: Zcu.PerThread, stage: InternPool.Memoized
 
 fn analyzeMemoizedState(pt: Zcu.PerThread, stage: InternPool.MemoizedStateStage) Zcu.CompileError!bool {
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
     const comp = zcu.comp;
     const gpa = comp.gpa;
-    const io = comp.io;
 
     const unit: AnalUnit = .wrap(.{ .memoized_state = stage });
 
     try zcu.analysis_in_progress.putNoClobber(gpa, unit, {});
     defer assert(zcu.analysis_in_progress.swapRemove(unit));
 
-    // Before we begin, collect:
-    // * The type `std`, and its namespace
-    // * The type `std.builtin`, and its namespace
-    // * A semi-reasonable source location
-    const std_file_index = zcu.module_roots.get(zcu.std_mod).?.unwrap().?;
-    try pt.ensureFileAnalyzed(std_file_index);
-    const std_type: Type = .fromInterned(zcu.fileRootType(std_file_index));
-    const std_namespace = std_type.getNamespaceIndex(zcu);
-    try pt.ensureNamespaceUpToDate(std_namespace);
-    const builtin_str = try ip.getOrPutString(gpa, io, pt.tid, "builtin", .no_embedded_nulls);
-    const builtin_nav = zcu.namespacePtr(std_namespace).pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse
-        @panic("lib/std.zig is corrupt and missing 'builtin'");
-    try pt.ensureNavValUpToDate(builtin_nav);
-    const builtin_type: Type = .fromInterned(ip.getNav(builtin_nav).status.fully_resolved.val);
-    const builtin_namespace = builtin_type.getNamespaceIndex(zcu);
-    try pt.ensureNamespaceUpToDate(builtin_namespace);
-    const src: Zcu.LazySrcLoc = .{
-        .base_node_inst = builtin_type.typeDeclInst(zcu).?,
-        .offset = .{ .byte_abs = 0 },
-    };
-
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
     defer analysis_arena.deinit();
 
@@ -861,22 +835,7 @@ fn analyzeMemoizedState(pt: Zcu.PerThread, stage: InternPool.MemoizedStateStage)
     };
     defer sema.deinit();
 
-    var block: Sema.Block = .{
-        .parent = null,
-        .sema = &sema,
-        .namespace = std_namespace,
-        .instructions = .empty,
-        .inlining = null,
-        .comptime_reason = .{ .reason = .{
-            .src = src,
-            .r = .{ .simple = .type },
-        } },
-        .src_base_inst = src.base_node_inst,
-        .type_name_ctx = .empty,
-    };
-    defer block.instructions.deinit(gpa);
-
-    return sema.analyzeMemoizedState(&block, src, builtin_namespace, stage);
+    return sema.analyzeMemoizedState(stage);
 }
 
 /// Ensures that the state of the given `ComptimeUnit` is fully up-to-date, performing re-analysis
@@ -1966,7 +1925,6 @@ fn analyzeFuncBody(
 /// If the file's root struct type is not populated (the file is unreferenced), nothing is done.
 /// This is called by `updateZirRefs` for all updated files before the main work loop.
 /// This function does not perform any semantic analysis.
-/// MLUGG TODO: mmmmm i have no idea if this makes sense... tbhwy i just want to update all *changed* namespaces at the start of an update or something lol
 fn updateFileNamespace(pt: Zcu.PerThread, file_index: Zcu.File.Index) Allocator.Error!void {
     const zcu = pt.zcu;
 
-- 
2.54.0


From 1826ba69d81e182f6bd7cf4ea9b944bd6c713a28 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Feb 2026 13:59:07 +0000
Subject: [PATCH 429/499] compiler: make dependency loop errors good

---
 lib/std/zig/ErrorBundle.zig           |   4 +
 src/Compilation.zig                   | 115 +-------
 src/Sema.zig                          | 262 ++++++++++--------
 src/Sema/LowerZon.zig                 |  10 +-
 src/Sema/type_resolution.zig          |  93 +++++--
 src/Zcu.zig                           | 364 +++++++++++++++++++++++---
 src/Zcu/PerThread.zig                 | 224 +++++++---------
 test/incremental/type_dependency_loop |  55 ++++
 tools/incr-check.zig                  |  76 +++---
 9 files changed, 763 insertions(+), 440 deletions(-)
 create mode 100644 test/incremental/type_dependency_loop

diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
index 64aafd110efb9a4d8247450ac85049286871e05a..ef3cd3d783509ca7de73eba085f6f411d7cc0a30 100644
--- a/lib/std/zig/ErrorBundle.zig
+++ b/lib/std/zig/ErrorBundle.zig
@@ -243,12 +243,14 @@ fn renderErrorMessage(
         }
         try t.setColor(.reset);
         if (src.data.source_line != 0 and options.include_source_line) {
+            try w.splatByteAll(' ', indent);
             const line = eb.nullTerminatedString(src.data.source_line);
             for (line) |b| switch (b) {
                 '\t' => try w.writeByte(' '),
                 else => try w.writeByte(b),
             };
             try w.writeByte('\n');
+            try w.splatByteAll(' ', indent);
             // TODO basic unicode code point monospace width
             const before_caret = src.data.span_main - src.data.span_start;
             // -1 since span.main includes the caret
@@ -267,11 +269,13 @@ fn renderErrorMessage(
         if (src.data.reference_trace_len > 0 and options.include_reference_trace) {
             try t.setColor(.reset);
             try t.setColor(.dim);
+            try w.splatByteAll(' ', indent);
             try w.print("referenced by:\n", .{});
             var ref_index = src.end;
             for (0..src.data.reference_trace_len) |_| {
                 const ref_trace = eb.extraData(ReferenceTrace, ref_index);
                 ref_index = ref_trace.end;
+                try w.splatByteAll(' ', indent);
                 if (ref_trace.data.src_loc != .none) {
                     const ref_src = eb.getSourceLocation(ref_trace.data.src_loc);
                     try w.print("    {s}: {s}:{d}:{d}\n", .{
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 8b863c302202da3246c240f4612ec03e81f12afc..59fa186d82804de016b8f5c241976992b70c3174 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -4189,6 +4189,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
                 }
             }
         }
+        try zcu.addDependencyLoopErrors(&bundle);
         for (zcu.failed_codegen.values()) |error_msg| {
             try addModuleErrorMsg(zcu, &bundle, error_msg.*, false);
         }
@@ -4208,7 +4209,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
                 .notes_len = 1,
             });
             const notes_start = try bundle.reserveNotes(1);
-            bundle.extra.items[notes_start] = @intFromEnum(try bundle.addErrorMessage(.{
+            bundle.extra.items[notes_start] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{
                 .msg = try bundle.printString("use '--error-limit {d}' to increase limit", .{
                     actual_error_count,
                 }),
@@ -4230,10 +4231,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
             .notes_len = 2,
         });
         const notes_start = try bundle.reserveNotes(2);
-        bundle.extra.items[notes_start + 0] = @intFromEnum(try bundle.addErrorMessage(.{
+        bundle.extra.items[notes_start + 0] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{
             .msg = try bundle.addString("run 'zig libc -h' to learn about libc installations"),
         }));
-        bundle.extra.items[notes_start + 1] = @intFromEnum(try bundle.addErrorMessage(.{
+        bundle.extra.items[notes_start + 1] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{
             .msg = try bundle.addString("run 'zig targets' to see the targets for which zig can always provide libc"),
         }));
     }
@@ -4428,7 +4429,6 @@ pub fn addModuleErrorMsg(
     already_added_error: bool,
 ) Allocator.Error!void {
     const gpa = eb.gpa;
-    const ip = &zcu.intern_pool;
     const err_src_loc = module_err_msg.src_loc.upgrade(zcu);
     const err_source = err_src_loc.file_scope.getSource(zcu) catch |err| {
         return unableToLoadZcuFile(zcu, eb, err_src_loc.file_scope, err);
@@ -4441,66 +4441,12 @@ pub fn addModuleErrorMsg(
     var ref_traces: std.ArrayList(ErrorBundle.ReferenceTrace) = .empty;
     defer ref_traces.deinit(gpa);
 
-    rt: {
-        const rt_root = module_err_msg.reference_trace_root.unwrap() orelse break :rt;
-        const max_references = zcu.comp.reference_trace orelse refs: {
-            if (already_added_error) break :rt;
+    if (module_err_msg.reference_trace_root.unwrap()) |root| {
+        const frame_limit: u32 = zcu.comp.reference_trace orelse refs: {
+            if (already_added_error) break :refs 0;
             break :refs default_reference_trace_len;
         };
-
-        const all_references = try zcu.resolveReferences();
-
-        var seen: std.AutoHashMapUnmanaged(InternPool.AnalUnit, void) = .empty;
-        defer seen.deinit(gpa);
-
-        var referenced_by = rt_root;
-        while (all_references.get(referenced_by)) |maybe_ref| {
-            const ref = maybe_ref orelse break;
-            const gop = try seen.getOrPut(gpa, ref.referencer);
-            if (gop.found_existing) break;
-            if (ref_traces.items.len < max_references) {
-                var last_call_src = ref.src;
-                var opt_inline_frame = ref.inline_frame;
-                while (opt_inline_frame.unwrap()) |inline_frame| {
-                    const f = inline_frame.ptr(zcu).*;
-                    const func_nav = ip.indexToKey(f.callee).func.owner_nav;
-                    const func_name = ip.getNav(func_nav).name.toSlice(ip);
-                    addReferenceTraceFrame(zcu, eb, &ref_traces, func_name, last_call_src, true) catch |err| switch (err) {
-                        error.OutOfMemory => |e| return e,
-                        error.AlreadyReported => {
-                            // An incomplete reference trace isn't the end of the world; just cut it off.
-                            break :rt;
-                        },
-                    };
-                    last_call_src = f.call_src;
-                    opt_inline_frame = f.parent;
-                }
-                const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
-                    .@"comptime" => "comptime",
-                    .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
-                    .type_layout => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
-                    .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
-                    .memoized_state => null,
-                };
-                if (root_name) |n| {
-                    addReferenceTraceFrame(zcu, eb, &ref_traces, n, last_call_src, false) catch |err| switch (err) {
-                        error.OutOfMemory => |e| return e,
-                        error.AlreadyReported => {
-                            // An incomplete reference trace isn't the end of the world; just cut it off.
-                            break :rt;
-                        },
-                    };
-                }
-            }
-            referenced_by = ref.referencer;
-        }
-
-        if (seen.count() > ref_traces.items.len) {
-            try ref_traces.append(gpa, .{
-                .decl_name = @intCast(seen.count() - ref_traces.items.len),
-                .src_loc = .none,
-            });
-        }
+        try zcu.populateReferenceTrace(root, frame_limit, eb, &ref_traces);
     }
 
     const src_loc = try eb.addSourceLocation(.{
@@ -4565,43 +4511,10 @@ pub fn addModuleErrorMsg(
     const notes_start = try eb.reserveNotes(notes_len);
 
     for (notes_start.., notes.keys()) |i, note| {
-        eb.extra.items[i] = @intFromEnum(try eb.addErrorMessage(note));
+        eb.extra.items[i] = @intFromEnum(eb.addErrorMessageAssumeCapacity(note));
     }
 }
 
-fn addReferenceTraceFrame(
-    zcu: *Zcu,
-    eb: *ErrorBundle.Wip,
-    ref_traces: *std.ArrayList(ErrorBundle.ReferenceTrace),
-    name: []const u8,
-    lazy_src: Zcu.LazySrcLoc,
-    inlined: bool,
-) error{ OutOfMemory, AlreadyReported }!void {
-    const gpa = zcu.gpa;
-    const src = lazy_src.upgrade(zcu);
-    const source = src.file_scope.getSource(zcu) catch |err| {
-        try unableToLoadZcuFile(zcu, eb, src.file_scope, err);
-        return error.AlreadyReported;
-    };
-    const span = src.span(zcu) catch |err| {
-        try unableToLoadZcuFile(zcu, eb, src.file_scope, err);
-        return error.AlreadyReported;
-    };
-    const loc = std.zig.findLineColumn(source, span.main);
-    try ref_traces.append(gpa, .{
-        .decl_name = try eb.printString("{s}{s}", .{ name, if (inlined) " [inlined]" else "" }),
-        .src_loc = try eb.addSourceLocation(.{
-            .src_path = try eb.printString("{f}", .{src.file_scope.path.fmt(zcu.comp)}),
-            .span_start = span.start,
-            .span_main = span.main,
-            .span_end = span.end,
-            .line = @intCast(loc.line),
-            .column = @intCast(loc.column),
-            .source_line = 0,
-        }),
-    });
-}
-
 fn addWholeFileError(
     zcu: *Zcu,
     eb: *ErrorBundle.Wip,
@@ -5243,11 +5156,11 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
 
             const maybe_err: Zcu.SemaError!void = switch (unit.unwrap()) {
                 .@"comptime" => |cu| pt.ensureComptimeUnitUpToDate(cu),
-                .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav),
-                .nav_val => |nav| pt.ensureNavValUpToDate(nav),
-                .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty)),
-                .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage),
-                .func => |func| pt.ensureFuncBodyUpToDate(func),
+                .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav, null),
+                .nav_val => |nav| pt.ensureNavValUpToDate(nav, null),
+                .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty), null),
+                .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage, null),
+                .func => |func| pt.ensureFuncBodyUpToDate(func, null),
             };
             maybe_err catch |err| switch (err) {
                 error.OutOfMemory => |e| return e,
diff --git a/src/Sema.zig b/src/Sema.zig
index 799da305ed7495a8c78120dfe639b00798bb36d4..cbfe6421db8b7fc50a3954664eb93e3c0ff295f5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3260,7 +3260,7 @@ fn zirAllocExtended(
     } else .none;
 
     if (small.has_type) {
-        try sema.ensureLayoutResolved(var_ty, ty_src);
+        try sema.ensureLayoutResolved(var_ty, var_src, if (small.is_const) .constant else .variable);
         if (block.isComptime() or small.is_comptime or var_ty.comptimeOnly(zcu)) {
             return sema.analyzeComptimeAlloc(block, var_src, var_ty, alignment);
         }
@@ -3324,7 +3324,7 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
     const var_src = block.nodeOffset(inst_data.src_node);
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    try sema.ensureLayoutResolved(var_ty, ty_src);
+    try sema.ensureLayoutResolved(var_ty, var_src, .variable);
     return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
 }
 
@@ -3758,7 +3758,7 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     const var_src = block.nodeOffset(inst_data.src_node);
 
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    try sema.ensureLayoutResolved(var_ty, ty_src);
+    try sema.ensureLayoutResolved(var_ty, var_src, .constant);
     if (block.isComptime() or var_ty.comptimeOnly(zcu)) {
         return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
     }
@@ -3790,7 +3790,7 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const var_src = block.nodeOffset(inst_data.src_node);
 
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    try sema.ensureLayoutResolved(var_ty, ty_src);
+    try sema.ensureLayoutResolved(var_ty, var_src, .variable);
     if (block.isComptime()) {
         return sema.analyzeComptimeAlloc(block, var_src, var_ty, .none);
     }
@@ -4148,7 +4148,7 @@ fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ptr = sema.resolveInst(un_node.operand);
     const src = block.nodeOffset(un_node.src_node);
-    try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu), src);
+    try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu), src, .init);
     return sema.optEuBasePtrInit(block, ptr, src);
 }
 
@@ -4651,7 +4651,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     }
 
     const elem_ty = operand_ty.childType(zcu);
-    try sema.ensureLayoutResolved(elem_ty, src);
+    try sema.ensureLayoutResolved(elem_ty, src, .ptr_access);
 
     const need_comptime = switch (elem_ty.classify(zcu)) {
         .no_possible_value => return sema.fail(block, src, "cannot load {s} type '{f}'", .{
@@ -7037,7 +7037,7 @@ fn analyzeCall(
 
         break :ret_ty full_ty;
     };
-    try sema.ensureLayoutResolved(resolved_ret_ty, func_ret_ty_src);
+    try sema.ensureLayoutResolved(resolved_ret_ty, func_ret_ty_src, .return_type);
 
     // If we've discovered after evaluating arguments that a generic function instantiation is
     // comptime-only, then we can mark the block as comptime *now*.
@@ -7134,7 +7134,6 @@ fn analyzeCall(
                 .generic_owner = func_val.?.toIntern(),
                 .comptime_args = comptime_args,
             });
-            try sema.ensureLayoutResolved(.fromInterned(ip.typeOf(func_instance)), call_src);
             if (zcu.comp.debugIncremental()) {
                 const nav = ip.indexToKey(func_instance).func.owner_nav;
                 const gop = try zcu.incremental_debug_state.navs.getOrPut(gpa, nav);
@@ -7169,7 +7168,7 @@ fn analyzeCall(
         };
 
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).@"struct".fields.len + runtime_args.len);
-        const maybe_opv = try block.addInst(.{
+        const call_ref = try block.addInst(.{
             .tag = call_tag,
             .data = .{ .pl_op = .{
                 .operand = runtime_func,
@@ -7180,8 +7179,10 @@ fn analyzeCall(
         });
         sema.appendRefsAssumeCapacity(runtime_args);
 
+        const actual_ret_ty = sema.typeOf(call_ref);
+
         if (ensure_result_used) {
-            try sema.ensureResultUsed(block, sema.typeOf(maybe_opv), call_src);
+            try sema.ensureResultUsed(block, actual_ret_ty, call_src);
         }
 
         if (call_tag == .call_always_tail) {
@@ -7191,28 +7192,31 @@ fn analyzeCall(
                 .pointer => func_or_ptr_ty.childType(zcu),
                 else => unreachable,
             };
-            return sema.handleTailCall(block, call_src, runtime_func_ty, maybe_opv);
+            return sema.handleTailCall(block, call_src, runtime_func_ty, call_ref);
         }
 
-        if (resolved_ret_ty.isNoReturn(zcu)) {
-            const want_check = c: {
-                if (!block.wantSafety()) break :c false;
-                if (func_val != null) break :c false;
-                break :c true;
-            };
-            if (want_check) {
-                try sema.safetyPanic(block, call_src, .noreturn_returned);
-            } else {
-                _ = try block.addNoOp(.unreach);
-            }
-            return .unreachable_value;
-        }
-
-        try sema.ensureLayoutResolved(sema.typeOf(maybe_opv), func_ret_ty_src);
-        if (try sema.typeOf(maybe_opv).onePossibleValue(pt)) |opv| {
-            return .fromValue(opv);
-        } else {
-            return maybe_opv;
+        switch (actual_ret_ty.classify(zcu)) {
+            .no_possible_value => {
+                const want_check = c: {
+                    if (!block.wantSafety()) break :c false;
+                    if (func_val != null) break :c false;
+                    break :c true;
+                };
+                if (want_check) {
+                    try sema.safetyPanic(block, call_src, .noreturn_returned);
+                } else {
+                    _ = try block.addNoOp(.unreach);
+                }
+                return .unreachable_value;
+            },
+            .one_possible_value => {
+                return .fromValue((try actual_ret_ty.onePossibleValue(pt)).?);
+            },
+            .runtime => {
+                return call_ref;
+            },
+            .partially_comptime => unreachable,
+            .fully_comptime => unreachable,
         }
     }
 
@@ -7279,11 +7283,6 @@ fn analyzeCall(
         }
     }
 
-    // We're about to do an inline call; if the return type expression was generic, the return type
-    // may not be resolved yet. It's correct to resolve it because the function is going to return a
-    // value of this type.
-    try sema.ensureLayoutResolved(resolved_ret_ty, func_ret_ty_src);
-
     // For an inline call, we depend on the source code of the whole function definition.
     try sema.declareDependency(.{ .src_hash = fn_nav.analysis.?.zir_index });
 
@@ -8051,7 +8050,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     if (dest_ty.zigTypeTag(zcu) != .@"enum") {
         return sema.fail(block, src, "expected enum, found '{f}'", .{dest_ty.fmt(pt)});
     }
-    try sema.ensureLayoutResolved(dest_ty, src);
+    try sema.ensureLayoutResolved(dest_ty, src, .init);
     _ = try sema.checkIntType(block, operand_src, operand_ty);
 
     if (sema.resolveValue(operand)) |int_val| {
@@ -8114,7 +8113,7 @@ fn zirOptionalPayloadPtr(
 
     const ptr_ty = sema.typeOf(optional_ptr);
     assert(ptr_ty.zigTypeTag(sema.pt.zcu) == .pointer);
-    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu), src);
+    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu), src, .ptr_access);
 
     return sema.analyzeOptionalPayloadPtr(block, src, optional_ptr, safety_check, false);
 }
@@ -8311,7 +8310,7 @@ fn zirErrUnionPayloadPtr(
 
     const ptr_ty = sema.typeOf(operand);
     assert(ptr_ty.zigTypeTag(sema.pt.zcu) == .pointer);
-    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu), src);
+    try sema.ensureLayoutResolved(ptr_ty.childType(sema.pt.zcu), src, .ptr_access);
 
     return sema.analyzeErrUnionPayloadPtr(block, src, operand, false, false);
 }
@@ -9020,7 +9019,6 @@ fn funcCommon(
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
-    const src = block.nodeOffset(src_node_offset);
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = src_node_offset });
     const cc_src = block.src(.{ .node_offset_fn_type_cc = src_node_offset });
 
@@ -9090,7 +9088,7 @@ fn funcCommon(
             .lbrace_column = @as(u16, @truncate(src_locs.columns)),
             .rbrace_column = @as(u16, @truncate(src_locs.columns >> 16)),
         }));
-        try sema.ensureLayoutResolved(func_val.typeOf(zcu), src);
+        try sema.ensureLayoutResolved(func_val.typeOf(zcu), ret_ty_src, .return_type);
         return .fromValue(func_val);
     }
 
@@ -9105,7 +9103,7 @@ fn funcCommon(
     });
 
     if (has_body) {
-        try sema.ensureLayoutResolved(.fromInterned(func_ty), src);
+        try sema.ensureLayoutResolved(.fromInterned(func_ty), ret_ty_src, .return_type);
         return .fromIntern(try ip.getFuncDecl(gpa, io, pt.tid, .{
             .owner_nav = sema.owner.unwrap().nav_val,
             .ty = func_ty,
@@ -9761,7 +9759,7 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         return sema.failWithOwnedErrorMsg(block, msg);
     }
     try sema.checkIndexable(block, src, indexable_ty);
-    try sema.ensureLayoutResolved(indexable_ty.childType(zcu), src);
+    try sema.ensureLayoutResolved(indexable_ty.childType(zcu), src, .ptr_access);
     return sema.elemPtrOneLayerOnly(block, src, array_ptr, elem_index, src, false, false);
 }
 
@@ -9975,14 +9973,15 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
             const raw_operand_ty = sema.typeOf(eu_maybe_ptr);
             if (!non_err_case.operand_is_ref) break :err_union_ty raw_operand_ty;
             try sema.checkPtrOperand(block, operand_src, raw_operand_ty);
-            break :err_union_ty raw_operand_ty.childType(zcu);
+            const child_ty = raw_operand_ty.childType(zcu);
+            try sema.ensureLayoutResolved(child_ty, operand_src, .ptr_access);
+            break :err_union_ty child_ty;
         };
         if (err_union_ty.zigTypeTag(zcu) != .error_union) {
             return sema.fail(block, operand_src, "expected error union type, found '{f}'", .{
                 err_union_ty.fmt(pt),
             });
         }
-        try sema.ensureLayoutResolved(err_union_ty, operand_src);
 
         const non_err_cond = if (non_err_case.operand_is_ref)
             try sema.analyzePtrIsNonErr(block, operand_src, eu_maybe_ptr)
@@ -11281,11 +11280,12 @@ fn validateSwitchBlock(
         const raw_operand_ty = sema.typeOf(raw_operand);
         if (operand_is_ref) {
             try sema.checkPtrType(block, operand_src, raw_operand_ty, false);
-            break :operand_ty raw_operand_ty.childType(zcu);
+            const child_ty = raw_operand_ty.childType(zcu);
+            try sema.ensureLayoutResolved(child_ty, operand_src, .ptr_access);
+            break :operand_ty child_ty;
         }
         break :operand_ty raw_operand_ty;
     };
-    try sema.ensureLayoutResolved(operand_ty, operand_src);
 
     const item_ty: Type = item_ty: {
         switch (operand_ty.zigTypeTag(zcu)) {
@@ -12844,7 +12844,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const name_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const ty = try sema.resolveType(block, ty_src, extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, name_src, extra.rhs, .{ .simple = .field_name });
-    try sema.ensureLayoutResolved(ty, ty_src);
+    try sema.ensureLayoutResolved(ty, ty_src, .field_queried);
     const ip = &zcu.intern_pool;
 
     const has_field = hf: {
@@ -15194,6 +15194,7 @@ fn analyzeArithmetic(
                     });
                 }
 
+                try sema.ensureLayoutResolved(lhs_ty.childType(zcu), src, .ptr_offset);
                 const elem_size = lhs_ty.childType(zcu).abiSize(zcu);
                 if (elem_size == 0) {
                     return sema.fail(block, src, "pointer subtraction requires element type '{f}' to have runtime bits", .{
@@ -15246,7 +15247,7 @@ fn analyzeArithmetic(
                         else => return sema.failWithInvalidPtrArithmetic(block, src, "pointer-integer", "addition and subtraction"),
                     };
 
-                    try sema.ensureLayoutResolved(lhs_ty.childType(zcu), src);
+                    try sema.ensureLayoutResolved(lhs_ty.childType(zcu), src, .ptr_offset);
                     return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, rhs_src);
                 },
             }
@@ -15879,7 +15880,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
-    try sema.ensureLayoutResolved(ty, operand_src);
+    try sema.ensureLayoutResolved(ty, operand_src, .size_of);
     switch (ty.classify(zcu)) {
         .no_possible_value,
         => return sema.fail(block, operand_src, "no size available for uninstantiable type '{f}'", .{ty.fmt(pt)}),
@@ -15934,7 +15935,7 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         .@"anyframe",
         => {},
     }
-    try sema.ensureLayoutResolved(operand_ty, operand_src);
+    try sema.ensureLayoutResolved(operand_ty, operand_src, .size_of);
     return .fromValue(try pt.intValue(.comptime_int, operand_ty.bitSize(zcu)));
 }
 
@@ -16185,7 +16186,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const type_info_ty = try sema.getBuiltinType(src, .Type);
     const type_info_tag_ty = type_info_ty.unionTagType(zcu).?;
 
-    try sema.ensureLayoutResolved(ty, src);
+    try sema.ensureLayoutResolved(ty, src, .type_info);
 
     if (ty.typeDeclInst(zcu)) |type_decl_inst| {
         try sema.declareDependency(.{ .namespace = type_decl_inst });
@@ -16345,7 +16346,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const alignment_val = try pt.intValue(.comptime_int, bytes: {
                 if (info.flags.alignment.toByteUnits()) |b| break :bytes b;
                 const elem_ty: Type = .fromInterned(info.child);
-                try sema.ensureLayoutResolved(elem_ty, src);
+                try sema.ensureLayoutResolved(elem_ty, src, .type_info);
                 break :bytes elem_ty.abiAlignment(zcu).toByteUnits().?;
             });
 
@@ -18233,7 +18234,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
                 elem_ty.fmt(pt), bit_offset, bit_offset - host_size * 8, host_size,
             });
         }
-        try sema.ensureLayoutResolved(elem_ty, elem_ty_src);
+        try sema.ensureLayoutResolved(elem_ty, elem_ty_src, .bit_ptr_child);
         const elem_bit_size = elem_ty.bitSize(zcu);
         if (elem_bit_size > host_size * 8 - bit_offset) {
             return sema.fail(block, bitoffset_src, "packed type '{f}' at bit offset {d} ends {d} bits after the end of a {d} byte host integer", .{
@@ -18302,7 +18303,7 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const pt = sema.pt;
     const zcu = pt.zcu;
 
-    try sema.ensureLayoutResolved(obj_ty, ty_src);
+    try sema.ensureLayoutResolved(obj_ty, ty_src, .init);
 
     switch (obj_ty.zigTypeTag(zcu)) {
         .@"struct" => return sema.structInitEmpty(block, obj_ty, src, src),
@@ -18367,7 +18368,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
         });
     } else ty_operand;
 
-    try sema.ensureLayoutResolved(init_ty, src);
+    try sema.ensureLayoutResolved(init_ty, src, .init);
 
     const obj_ty = init_ty.optEuBaseType(zcu);
 
@@ -18486,7 +18487,7 @@ fn zirStructInit(
         // The type wasn't actually known, so treat this as an anon struct init.
         return sema.structInitAnon(block, src, inst, .typed_init, extra.data, extra.end, is_ref);
     };
-    try sema.ensureLayoutResolved(result_ty, src);
+    try sema.ensureLayoutResolved(result_ty, src, .init);
     const resolved_ty = result_ty.optEuBaseType(zcu);
 
     if (resolved_ty.zigTypeTag(zcu) == .@"struct") {
@@ -18951,7 +18952,7 @@ fn structInitAnon(
     };
     try sema.addTypeReferenceEntry(src, struct_ty);
     // No need for `ensureNamespaceUpToDate` because this type's namespace is always empty.
-    try sema.ensureLayoutResolved(struct_ty, src);
+    try sema.ensureLayoutResolved(struct_ty, src, .init);
 
     _ = opt_runtime_index orelse {
         const struct_val = try pt.aggregateValue(struct_ty, values);
@@ -19270,7 +19271,7 @@ fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const field_src = block.builtinCallArgSrc(inst_data.src_node, 1);
     const aggregate_ty = try sema.resolveType(block, ty_src, extra.container_type);
     const field_name = try sema.resolveConstStringIntern(block, field_src, extra.field_name, .{ .simple = .field_name });
-    try sema.ensureLayoutResolved(aggregate_ty, ty_src);
+    try sema.ensureLayoutResolved(aggregate_ty, ty_src, .field_queried);
     return sema.fieldType(block, aggregate_ty, field_name, field_src, ty_src);
 }
 
@@ -19290,7 +19291,7 @@ fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(zcu);
     const zir_field_name = sema.code.nullTerminatedString(extra.name_start);
     const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_field_name, .no_embedded_nulls);
-    try sema.ensureLayoutResolved(aggregate_ty, ty_src);
+    try sema.ensureLayoutResolved(aggregate_ty, ty_src, .init);
     return sema.fieldType(block, aggregate_ty, field_name, field_name_src, ty_src);
 }
 
@@ -19390,7 +19391,7 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
-    try sema.ensureLayoutResolved(ty, operand_src);
+    try sema.ensureLayoutResolved(ty, operand_src, .align_of);
     if (ty.isNoReturn(zcu)) {
         return sema.fail(block, operand_src, "no align available for type '{f}'", .{ty.fmt(sema.pt)});
     }
@@ -19874,7 +19875,6 @@ fn zirReifyFn(
     const param_attrs_arr = try sema.derefSliceAsArray(block, param_attrs_src, param_attrs_slice, .{ .simple = .fn_param_attrs });
 
     const ret_ty = try sema.resolveType(block, ret_ty_src, extra.ret_ty);
-    try sema.ensureLayoutResolved(ret_ty, ret_ty_src);
 
     const fn_attrs_uncoerced = sema.resolveInst(extra.fn_attrs);
     const fn_attrs_coerced = try sema.coerce(block, fn_attrs_ty, fn_attrs_uncoerced, fn_attrs_src);
@@ -19899,10 +19899,6 @@ fn zirReifyFn(
             param_types_src,
             fn_attrs.@"callconv",
         );
-        try sema.ensureLayoutResolved(param_ty, param_types_src);
-        if (param_ty.comptimeOnly(zcu)) {
-            return sema.fail(block, param_attrs_src, "cannot reify function type with comptime-only parameter type '{f}'", .{param_ty.fmt(pt)});
-        }
         if (param_attrs.@"noalias") {
             if (param_idx > 31) {
                 return sema.fail(block, param_attrs_src, "this compiler implementation only supports 'noalias' on the first 32 parameters", .{});
@@ -20811,8 +20807,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
 
     const elem_ty = ptr_ty.nullablePtrElem(zcu);
 
-    // We'll need to validate the pointer alignment.
-    try sema.ensureLayoutResolved(elem_ty, src);
+    try sema.ensureLayoutResolved(elem_ty, src, .align_check);
     const ptr_align = ptr_ty.ptrAlignment(zcu);
 
     if (ptr_ty.isSlice(zcu)) {
@@ -21155,8 +21150,8 @@ fn ptrCastFull(
     const src_info = operand_ty.ptrInfo(zcu);
     const dest_info = dest_ty.ptrInfo(zcu);
 
-    try sema.ensureLayoutResolved(.fromInterned(src_info.child), operand_src);
-    try sema.ensureLayoutResolved(.fromInterned(dest_info.child), src);
+    try sema.ensureLayoutResolved(.fromInterned(src_info.child), operand_src, .align_check);
+    try sema.ensureLayoutResolved(.fromInterned(dest_info.child), src, .align_check);
 
     const DestSliceLen = union(enum) {
         undef,
@@ -21927,7 +21922,7 @@ fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u6
     const ty = try sema.resolveType(block, ty_src, extra.lhs);
     const field_name = try sema.resolveConstStringIntern(block, field_name_src, extra.rhs, .{ .simple = .field_name });
 
-    try sema.ensureLayoutResolved(ty, ty_src);
+    try sema.ensureLayoutResolved(ty, ty_src, .field_queried);
 
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -23010,7 +23005,7 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, true);
     const order = try sema.resolveAtomicOrder(block, order_src, extra.ordering, .{ .simple = .atomic_order });
 
-    try sema.ensureLayoutResolved(elem_ty, elem_ty_src);
+    try sema.ensureLayoutResolved(elem_ty, elem_ty_src, .ptr_access);
 
     switch (order) {
         .release, .acq_rel => {
@@ -23330,7 +23325,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
         return sema.fail(block, inst_src, "expected single pointer type, found '{f}'", .{parent_ptr_ty.fmt(pt)});
     }
     const parent_ty: Type = .fromInterned(parent_ptr_info.child);
-    try sema.ensureLayoutResolved(parent_ty, inst_src);
+    try sema.ensureLayoutResolved(parent_ty, inst_src, .field_used);
     switch (parent_ty.zigTypeTag(zcu)) {
         .@"struct", .@"union" => {},
         else => return sema.fail(block, inst_src, "expected pointer to struct or union type, found '{f}'", .{parent_ptr_ty.fmt(pt)}),
@@ -23938,8 +23933,8 @@ fn zirMemcpy(
     const dest_elem_ty = dest_ty.indexableElem(zcu);
     const src_elem_ty = src_ty.indexableElem(zcu);
 
-    try sema.ensureLayoutResolved(dest_elem_ty, dest_src);
-    try sema.ensureLayoutResolved(src_elem_ty, src_src);
+    try sema.ensureLayoutResolved(dest_elem_ty, dest_src, .ptr_access);
+    try sema.ensureLayoutResolved(src_elem_ty, src_src, .ptr_access);
 
     const imc = try sema.coerceInMemoryAllowed(
         block,
@@ -25470,7 +25465,7 @@ fn fieldPtrLoad(
     const object_ptr_ty = sema.typeOf(object_ptr);
     assert(object_ptr_ty.zigTypeTag(zcu) == .pointer);
     const pointee_ty = object_ptr_ty.childType(zcu);
-    try sema.ensureLayoutResolved(pointee_ty, src);
+    try sema.ensureLayoutResolved(pointee_ty, src, .ptr_access);
     if (try pointee_ty.onePossibleValue(pt)) |opv| {
         const object: Air.Inst.Ref = .fromValue(opv);
         return fieldVal(sema, block, src, object, field_name, field_name_src);
@@ -25606,7 +25601,7 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type, src);
+                    try sema.ensureLayoutResolved(child_type, src, .field_used);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index_usize| {
                             const field_index: u32 = @intCast(field_index_usize);
@@ -25619,7 +25614,7 @@ fn fieldVal(
                     if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type, src);
+                    try sema.ensureLayoutResolved(child_type, src, .field_used);
                     const field_index_usize = child_type.enumFieldIndex(field_name, zcu) orelse
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     const field_index: u32 = @intCast(field_index_usize);
@@ -25645,7 +25640,7 @@ fn fieldVal(
         },
         .@"struct" => if (is_pointer_to) {
             // Avoid loading the entire struct by fetching a pointer and loading that
-            try sema.ensureLayoutResolved(inner_ty, src);
+            try sema.ensureLayoutResolved(inner_ty, src, .ptr_access);
             const field_ptr = try sema.structFieldPtr(block, src, object, field_name, field_name_src, inner_ty);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
@@ -25653,7 +25648,7 @@ fn fieldVal(
         },
         .@"union" => if (is_pointer_to) {
             // Avoid loading the entire union by fetching a pointer and loading that
-            try sema.ensureLayoutResolved(inner_ty, src);
+            try sema.ensureLayoutResolved(inner_ty, src, .ptr_access);
             const field_ptr = try sema.unionFieldPtr(block, src, object, field_name, field_name_src, inner_ty, false);
             return sema.analyzeLoad(block, src, field_ptr, object_src);
         } else {
@@ -25837,7 +25832,7 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type, src);
+                    try sema.ensureLayoutResolved(child_type, src, .field_used);
                     if (child_type.unionTagType(zcu)) |enum_ty| {
                         if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index| {
                             const field_index_u32: u32 = @intCast(field_index);
@@ -25851,7 +25846,7 @@ fn fieldPtr(
                     if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    try sema.ensureLayoutResolved(child_type, src);
+                    try sema.ensureLayoutResolved(child_type, src, .field_used);
                     const field_index = child_type.enumFieldIndex(field_name, zcu) orelse {
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     };
@@ -25873,7 +25868,7 @@ fn fieldPtr(
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
                 object_ptr;
-            try sema.ensureLayoutResolved(inner_ty, src);
+            try sema.ensureLayoutResolved(inner_ty, src, .ptr_access);
             const field_ptr = try sema.structFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
@@ -25883,7 +25878,7 @@ fn fieldPtr(
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
                 object_ptr;
-            try sema.ensureLayoutResolved(inner_ty, src);
+            try sema.ensureLayoutResolved(inner_ty, src, .ptr_access);
             const field_ptr = try sema.unionFieldPtr(block, src, inner_ptr, field_name, field_name_src, inner_ty, initializing);
             try sema.checkKnownAllocPtr(block, inner_ptr, field_ptr);
             return field_ptr;
@@ -25927,7 +25922,7 @@ fn fieldCallBind(
     // Optionally dereference a second pointer to get the concrete type.
     const is_double_ptr = inner_ty.zigTypeTag(zcu) == .pointer and inner_ty.ptrSize(zcu) == .one;
     const concrete_ty = if (is_double_ptr) inner_ty.childType(zcu) else inner_ty;
-    try sema.ensureLayoutResolved(concrete_ty, src);
+    try sema.ensureLayoutResolved(concrete_ty, src, .ptr_access);
     const ptr_ty = if (is_double_ptr) inner_ty else raw_ptr_ty;
     const object_ptr = if (is_double_ptr)
         try sema.analyzeLoad(block, src, raw_ptr, src)
@@ -26514,7 +26509,7 @@ fn elemPtr(
         else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{f}'", .{indexable_ptr_ty.fmt(pt)}),
     };
     try sema.checkIndexable(block, src, indexable_ty);
-    try sema.ensureLayoutResolved(indexable_ty, src);
+    try sema.ensureLayoutResolved(indexable_ty, src, .ptr_access);
 
     const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {
         .vector => try sema.elemPtrVector(block, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init),
@@ -26522,7 +26517,7 @@ fn elemPtr(
         .@"struct" => try sema.tupleElemPtr(block, src, indexable_ptr, elem_index, elem_index_src),
         else => {
             const indexable = try sema.analyzeLoad(block, indexable_ptr_src, indexable_ptr, indexable_ptr_src);
-            try sema.ensureLayoutResolved(sema.typeOf(indexable).childType(zcu), src);
+            try sema.ensureLayoutResolved(sema.typeOf(indexable).childType(zcu), src, .ptr_access);
             return elemPtrOneLayerOnly(sema, block, src, indexable, elem_index, elem_index_src, init, oob_safety);
         },
     };
@@ -26614,7 +26609,7 @@ fn elemVal(
     switch (indexable_ty.zigTypeTag(zcu)) {
         .pointer => {
             const child_ty = indexable_ty.childType(zcu);
-            try sema.ensureLayoutResolved(child_ty, src);
+            try sema.ensureLayoutResolved(child_ty, src, .ptr_access);
             switch (indexable_ty.ptrSize(zcu)) {
                 .slice => return sema.elemValSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
                 .many, .c => {
@@ -27192,7 +27187,7 @@ fn coerceExtra(
     const target = zcu.getTarget();
 
     inst_ty.assertHasLayout(zcu);
-    try sema.ensureLayoutResolved(dest_ty, inst_src);
+    try sema.ensureLayoutResolved(dest_ty, inst_src, .coerce);
 
     // If the types are the same, we can return the operand.
     if (dest_ty.eql(inst_ty, zcu))
@@ -28552,8 +28547,8 @@ fn coerceInMemoryAllowedFns(
             } };
         }
 
-        try sema.ensureLayoutResolved(src_ty, src_src);
-        try sema.ensureLayoutResolved(dest_ty, dest_src);
+        try sema.ensureLayoutResolved(src_ty, src_src, .coerce);
+        try sema.ensureLayoutResolved(dest_ty, dest_src, .coerce);
         const src_is_runtime = src_ty.fnHasRuntimeBits(zcu);
         const dest_is_runtime = dest_ty.fnHasRuntimeBits(zcu);
         if (src_is_runtime != dest_is_runtime) return .{ .fn_generic = !dest_is_runtime };
@@ -28607,7 +28602,6 @@ fn coerceInMemoryAllowedFns(
             const src_is_comptime = src_info.paramIsComptime(@intCast(param_i));
             const dest_is_comptime = dest_info.paramIsComptime(@intCast(param_i));
             if (src_is_comptime == dest_is_comptime) break :comptime_param;
-            try sema.ensureLayoutResolved(dest_param_ty, dest_src);
             if (!dest_is_mut and src_is_comptime and !dest_is_comptime and dest_param_ty.comptimeOnly(zcu)) {
                 // A parameter which is marked `comptime` can drop that annotation if the type is comptime-only.
                 // The function remains generic, and the parameter is going to be comptime-resolved either way,
@@ -28835,11 +28829,11 @@ fn coerceInMemoryAllowedPtrs(
         dest_info.child != src_info.child)
     {
         const src_align = if (src_info.flags.alignment == .none) a: {
-            try sema.ensureLayoutResolved(src_child, src_src);
+            try sema.ensureLayoutResolved(src_child, src_src, .align_check);
             break :a src_child.abiAlignment(zcu);
         } else src_info.flags.alignment;
         const dest_align = if (dest_info.flags.alignment == .none) a: {
-            try sema.ensureLayoutResolved(dest_child, dest_src);
+            try sema.ensureLayoutResolved(dest_child, dest_src, .align_check);
             break :a dest_child.abiAlignment(zcu);
         } else dest_info.flags.alignment;
         if (dest_align.compare(if (dest_is_mut) .neq else .gt, src_align)) {
@@ -29189,7 +29183,7 @@ fn bitCast(
     const old_ty = sema.typeOf(inst);
 
     old_ty.assertHasLayout(zcu);
-    try sema.ensureLayoutResolved(dest_ty, inst_src);
+    try sema.ensureLayoutResolved(dest_ty, inst_src, .init);
 
     const dest_bits = dest_ty.bitSize(zcu);
     const old_bits = old_ty.bitSize(zcu);
@@ -29837,10 +29831,11 @@ fn ensureMemoizedStateResolved(sema: *Sema, src: LazySrcLoc, stage: InternPool.M
     try sema.addReferenceEntry(null, src, unit);
     try sema.declareDependency(.{ .memoized_state = stage });
 
+    const reason: Zcu.DependencyReason = .{ .src = src, .type_layout_reason = undefined };
     if (pt.zcu.analysis_in_progress.contains(unit)) {
-        return sema.failWithOwnedErrorMsg(null, try sema.errMsg(src, "dependency loop detected", .{}));
+        return sema.failWithDependencyLoop(unit, &reason);
     }
-    try pt.ensureMemoizedStateUpToDate(stage);
+    try pt.ensureMemoizedStateUpToDate(stage, &reason);
 }
 
 pub fn ensureNavResolved(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index: InternPool.Nav.Index, kind: enum { type, fully }) CompileError!void {
@@ -29854,11 +29849,6 @@ pub fn ensureNavResolved(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index:
         return;
     }
 
-    try sema.declareDependency(switch (kind) {
-        .type => .{ .nav_ty = nav_index },
-        .fully => .{ .nav_val = nav_index },
-    });
-
     // Note that even if `nav.status == .resolved`, we must still trigger `ensureNavValUpToDate`
     // to make sure the value is up-to-date on incremental updates.
 
@@ -29867,20 +29857,23 @@ pub fn ensureNavResolved(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index:
         .fully => .{ .nav_val = nav_index },
     });
     try sema.addReferenceEntry(block, src, anal_unit);
+    try sema.declareDependency(switch (kind) {
+        .type => .{ .nav_ty = nav_index },
+        .fully => .{ .nav_val = nav_index },
+    });
+
+    const reason: Zcu.DependencyReason = .{ .src = src, .type_layout_reason = undefined };
 
     if (zcu.analysis_in_progress.contains(anal_unit)) {
-        return sema.failWithOwnedErrorMsg(null, try sema.errMsg(.{
-            .base_node_inst = nav.analysis.?.zir_index,
-            .offset = LazySrcLoc.Offset.nodeOffset(.zero),
-        }, "dependency loop detected", .{}));
+        return sema.failWithDependencyLoop(anal_unit, &reason);
     }
 
     switch (kind) {
         .type => {
             try zcu.ensureNavValAnalysisQueued(nav_index);
-            return pt.ensureNavTypeUpToDate(nav_index);
+            return pt.ensureNavTypeUpToDate(nav_index, &reason);
         },
-        .fully => return pt.ensureNavValUpToDate(nav_index),
+        .fully => return pt.ensureNavValUpToDate(nav_index, &reason),
     }
 }
 
@@ -30065,7 +30058,7 @@ fn analyzeLoad(
         return sema.fail(block, ptr_src, "cannot load opaque type '{f}'", .{elem_ty.fmt(pt)});
     }
 
-    try sema.ensureLayoutResolved(elem_ty, src);
+    try sema.ensureLayoutResolved(elem_ty, src, .ptr_access);
     if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
 
     if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
@@ -30249,7 +30242,7 @@ fn resolveIsNonErrFromType(
             // This is *our* error set; that is, we're currently analyzing the function
             // which owns it. Trying to resolve it now would cause a dependency loop.
             // Instead, accept that we don't know.
-            if (true) return null;
+            return null;
         },
         else => |set_ty| switch (ip.indexToKey(set_ty)) {
             .error_set_type => |error_set_type| switch (error_set_type.names.len) {
@@ -30450,7 +30443,7 @@ fn analyzeSlice(
         else => return sema.fail(block, src, "slice of non-array type '{f}'", .{ptr_ptr_child_ty.fmt(pt)}),
     }
 
-    try sema.ensureLayoutResolved(elem_ty, src);
+    try sema.ensureLayoutResolved(elem_ty, src, .ptr_access);
 
     const ptr = if (slice_ty.isSlice(zcu))
         try sema.analyzeSlicePtr(block, ptr_src, ptr_or_slice, slice_ty)
@@ -32831,11 +32824,13 @@ fn ensureFuncIesResolved(
     try sema.declareDependency(.{ .func_ies = func_index });
     try sema.addReferenceEntry(block, src, .wrap(.{ .func = func_index }));
 
+    const reason: Zcu.DependencyReason = .{ .src = src, .type_layout_reason = undefined };
+
     if (zcu.analysis_in_progress.contains(.wrap(.{ .func = func_index }))) {
-        return sema.fail(block, src, "unable to resolve inferred error set", .{});
+        return sema.failWithDependencyLoop(.wrap(.{ .func = func_index }), &reason);
     }
 
-    try pt.ensureFuncBodyUpToDate(func_index);
+    try pt.ensureFuncBodyUpToDate(func_index, &reason);
 }
 
 pub fn resolveInferredErrorSetPtr(
@@ -33749,6 +33744,8 @@ pub fn flushExports(sema: *Sema) !void {
     //
     // So, pick up and delete any existing exports. This strategy performs
     // redundant work, but that's okay, because this case is exceedingly rare.
+    //
+    // MLUGG TODO: is this still possible? if not, delete this logic and combine deleteUnitExports into resetUnit
     if (zcu.single_exports.get(sema.owner)) |export_idx| {
         try sema.exports.append(gpa, export_idx.ptr(zcu).*);
     } else if (zcu.multi_exports.get(sema.owner)) |info| {
@@ -33940,7 +33937,7 @@ pub fn analyzeMemoizedState(sema: *Sema, stage: InternPool.MemoizedStateStage) C
             const val: Value = switch (builtin_decl.kind()) {
                 .type => val: {
                     const ty = try sema.analyzeAsType(&block, decl_src, .std_builtin_decl, uncoerced_val);
-                    try sema.ensureLayoutResolved(ty, decl_src);
+                    try sema.ensureLayoutResolved(ty, decl_src, .builtin_type);
                     break :val ty.toValue();
                 },
                 .func => val: {
@@ -34370,3 +34367,42 @@ fn zirOpaqueDecl(
 
     return .fromType(ty);
 }
+
+/// Registers an error indicating a dependency loop: we have introduced a dependency on `want` (with
+/// reason `want_reason`) but have learnt that `want` is already in `zcu.analysis_in_progress`.
+pub fn failWithDependencyLoop(
+    sema: *Sema,
+    want: AnalUnit,
+    want_reason: *const Zcu.DependencyReason,
+) SemaError {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const gpa = zcu.comp.gpa;
+
+    const in_progress_len = zcu.analysis_in_progress.count();
+    var index = zcu.analysis_in_progress.getIndex(want).? + 1;
+
+    try zcu.dependency_loops.ensureUnusedCapacity(gpa, 1);
+    try zcu.dependency_loop_nodes.ensureUnusedCapacity(gpa, in_progress_len - index + 1);
+
+    zcu.dependency_loops.putAssumeCapacityNoClobber(want, {});
+
+    while (index <= in_progress_len) : (index += 1) {
+        const parent_unit = zcu.analysis_in_progress.keys()[index - 1];
+        const unit, const reason = if (index == in_progress_len) .{
+            want,
+            want_reason,
+        } else .{
+            zcu.analysis_in_progress.keys()[index],
+            zcu.analysis_in_progress.values()[index],
+        };
+
+        zcu.dependency_loop_nodes.putAssumeCapacityNoClobber(parent_unit, .{
+            .unit = unit,
+            .reason = reason.?.*,
+        });
+    }
+
+    // A dependency loop error will be reported. Mark us all as transitive failures.
+    return error.AnalysisFail;
+}
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index b755c5daaae8f6ed6688b2529ad563f347b445d4..cf809603c03a177c4aefe40407b3b649a1921cff 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -300,7 +300,7 @@ fn checkTypeInner(
         } else {
             const gop = try visited.getOrPut(sema.arena, ty.toIntern());
             if (gop.found_existing) return;
-            try sema.ensureLayoutResolved(ty, self.import_loc);
+            try sema.ensureLayoutResolved(ty, self.import_loc, .init);
             const struct_info = zcu.typeToStruct(ty).?;
             for (struct_info.field_types.get(ip)) |field_type| {
                 try self.checkTypeInner(.fromInterned(field_type), null, visited);
@@ -309,7 +309,7 @@ fn checkTypeInner(
         .@"union" => {
             const gop = try visited.getOrPut(sema.arena, ty.toIntern());
             if (gop.found_existing) return;
-            try sema.ensureLayoutResolved(ty, self.import_loc);
+            try sema.ensureLayoutResolved(ty, self.import_loc, .init);
             const union_info = zcu.typeToUnion(ty).?;
             for (union_info.field_types.get(ip)) |field_type| {
                 if (field_type != .void_type) {
@@ -646,7 +646,7 @@ fn lowerEnum(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.I
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
-    try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
+    try self.sema.ensureLayoutResolved(res_ty, self.import_loc, .init);
     switch (node.get(self.file.zoir.?)) {
         .enum_literal => |field_name| {
             const field_name_interned = try ip.getOrPutString(
@@ -769,7 +769,7 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
 
-    try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
+    try self.sema.ensureLayoutResolved(res_ty, self.import_loc, .init);
     const struct_info = self.sema.pt.zcu.typeToStruct(res_ty).?;
 
     const fields: @FieldType(Zoir.Node, "struct_literal") = switch (node.get(self.file.zoir.?)) {
@@ -919,7 +919,7 @@ fn lowerUnion(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.
     const gpa = comp.gpa;
     const io = comp.io;
     const ip = &pt.zcu.intern_pool;
-    try self.sema.ensureLayoutResolved(res_ty, self.import_loc);
+    try self.sema.ensureLayoutResolved(res_ty, self.import_loc, .init);
     const union_info = pt.zcu.typeToUnion(res_ty).?;
     const enum_tag_info = ip.loadEnumType(union_info.enum_tag_type);
 
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index a7b862289b6de72b34e2739a684effcddc6a60fc..07349457a44ee78f7435e9609833b9e588bf1248 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -14,12 +14,64 @@ const InternPool = @import("../InternPool.zig");
 const Alignment = InternPool.Alignment;
 const arith = @import("arith.zig");
 
+pub const LayoutResolveReason = enum {
+    variable,
+    constant,
+    parameter,
+    return_type,
+    field,
+    backing_enum,
+    init,
+    coerce,
+    ptr_access,
+    ptr_offset,
+    field_used,
+    field_queried,
+    size_of,
+    align_of,
+    type_info,
+    align_check,
+    bit_ptr_child,
+    builtin_type,
+
+    /// Written after string: "while resolving type 'T' "
+    /// e.g. "while resolving type 'MyStruct' for variable declared here"
+    pub fn msg(r: LayoutResolveReason) []const u8 {
+        return switch (r) {
+            // zig fmt: off
+            .variable      => "for variable declared here",
+            .constant      => "for constant declared here",
+            .parameter     => "for function parameter declared here",
+            .return_type   => "for function return type declared here",
+            .field         => "for field declared here",
+            .backing_enum  => "for backing enum type declared here",
+            .init          => "for initialization performed here",
+            .coerce        => "for coercion performed here",
+            .ptr_access    => "for pointer access here",
+            .ptr_offset    => "for pointer offset here",
+            .field_used    => "for field usage here",
+            .field_queried => "for field query here",
+            .size_of       => "for size query here",
+            .align_of      => "for alignment query here",
+            .type_info     => "for type information query here",
+            .align_check   => "for alignment check here",
+            .bit_ptr_child => "for bit size check here",
+            .builtin_type  => "from 'std.builtin'",
+            // zig fmt: on
+        };
+    }
+};
+
 /// Ensures that `ty` has known layout, including alignment, size, and (where relevant) field offsets.
 /// `ty` may be any type; its layout is resolved *recursively* if necessary.
 /// Adds incremental dependencies tracking any required type resolution.
-/// MLUGG TODO: to make the langspec non-stupid, we need to call this from WAY fewer places (the conditions need to be less specific).
-/// MLUGG TODO: to be clear, i should audit EVERY use of this before PRing
-pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!void {
+pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc, reason: LayoutResolveReason) SemaError!void {
+    return ensureLayoutResolvedInner(sema, ty, ty, &.{
+        .src = src,
+        .type_layout_reason = reason,
+    });
+}
+fn ensureLayoutResolvedInner(sema: *Sema, ty: Type, orig_ty: Type, reason: *const Zcu.DependencyReason) SemaError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -35,30 +87,25 @@ pub fn ensureLayoutResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!vo
 
         .func_type => |func_type| {
             for (func_type.param_types.get(ip)) |param_ty| {
-                try ensureLayoutResolved(sema, .fromInterned(param_ty), src);
+                try ensureLayoutResolvedInner(sema, .fromInterned(param_ty), orig_ty, reason);
             }
-            try ensureLayoutResolved(sema, .fromInterned(func_type.return_type), src);
+            try ensureLayoutResolvedInner(sema, .fromInterned(func_type.return_type), orig_ty, reason);
         },
 
-        .array_type => |arr| return ensureLayoutResolved(sema, .fromInterned(arr.child), src),
-        .vector_type => |vec| return ensureLayoutResolved(sema, .fromInterned(vec.child), src),
-        .opt_type => |child| return ensureLayoutResolved(sema, .fromInterned(child), src),
-        .error_union_type => |eu| return ensureLayoutResolved(sema, .fromInterned(eu.payload_type), src),
+        .array_type => |arr| return ensureLayoutResolvedInner(sema, .fromInterned(arr.child), orig_ty, reason),
+        .vector_type => |vec| return ensureLayoutResolvedInner(sema, .fromInterned(vec.child), orig_ty, reason),
+        .opt_type => |child| return ensureLayoutResolvedInner(sema, .fromInterned(child), orig_ty, reason),
+        .error_union_type => |eu| return ensureLayoutResolvedInner(sema, .fromInterned(eu.payload_type), orig_ty, reason),
         .tuple_type => |tuple| for (tuple.types.get(ip)) |field_ty| {
-            try ensureLayoutResolved(sema, .fromInterned(field_ty), src);
+            try ensureLayoutResolvedInner(sema, .fromInterned(field_ty), orig_ty, reason);
         },
         .struct_type, .union_type, .enum_type => {
             try sema.declareDependency(.{ .type_layout = ty.toIntern() });
-            try sema.addReferenceEntry(null, src, .wrap(.{ .type_layout = ty.toIntern() }));
+            try sema.addReferenceEntry(null, reason.src, .wrap(.{ .type_layout = ty.toIntern() }));
             if (zcu.analysis_in_progress.contains(.wrap(.{ .type_layout = ty.toIntern() }))) {
-                // TODO: better error message
-                return sema.failWithOwnedErrorMsg(null, try sema.errMsg(
-                    ty.srcLoc(zcu),
-                    "{s} '{f}' depends on itself",
-                    .{ @tagName(ty.zigTypeTag(zcu)), ty.fmt(pt) },
-                ));
+                return sema.failWithDependencyLoop(.wrap(.{ .type_layout = ty.toIntern() }), reason);
             }
-            try pt.ensureTypeLayoutUpToDate(ty);
+            try pt.ensureTypeLayoutUpToDate(ty, reason);
         },
 
         // values, not types
@@ -228,7 +275,7 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty, field_ty_src);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src, .field);
 
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
@@ -387,7 +434,7 @@ fn resolvePackedStructLayout(
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty, field_ty_src);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src, .field);
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
@@ -557,7 +604,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         },
     };
 
-    try sema.ensureLayoutResolved(enum_tag_ty, block.src(.container_arg));
+    try sema.ensureLayoutResolved(enum_tag_ty, block.src(.container_arg), .backing_enum);
     const enum_obj = ip.loadEnumType(enum_tag_ty.toIntern());
 
     if (union_obj.is_reified) {
@@ -652,7 +699,7 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty, field_ty_src);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src, .field);
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
@@ -832,7 +879,7 @@ fn resolvePackedUnionLayout(
         const field_ty: Type = .fromInterned(field_ty_ip);
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
-        try sema.ensureLayoutResolved(field_ty, field_ty_src);
+        try sema.ensureLayoutResolved(field_ty, field_ty_src, .field);
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in union", .{field_ty.fmt(pt)});
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 19702aee088915922972df9555c7a8a628529956..49abdbed5607582a4a33d40642edd762baaab5bb 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -119,7 +119,7 @@ module_roots: std.AutoArrayHashMapUnmanaged(*Package.Module, File.Index.Optional
 ///
 /// Always accessed through `ImportTableAdapter`, where keys are fully resolved
 /// file paths in order to ensure files are properly deduplicated. This table owns
-/// the keys and values.
+/// the keysand values.
 ///
 /// Protected by Compilation's mutex.
 ///
@@ -177,7 +177,9 @@ embed_table: std.ArrayHashMapUnmanaged(
 /// is not yet implemented.
 intern_pool: InternPool = .empty,
 
-analysis_in_progress: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
+/// Value explains why this `AnalUnit` is being analyzed. It is `null` for the topmost analysis
+/// (index 0), and non-`null` for all others.
+analysis_in_progress: std.AutoArrayHashMapUnmanaged(AnalUnit, ?*const DependencyReason) = .empty,
 /// The ErrorMsg memory is owned by the `AnalUnit`, using Module's general purpose allocator.
 failed_analysis: std.AutoArrayHashMapUnmanaged(AnalUnit, *ErrorMsg) = .empty,
 /// This `AnalUnit` failed semantic analysis because it required analysis of another `AnalUnit` which itself failed.
@@ -189,6 +191,19 @@ transitive_failed_analysis: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .emp
 /// codegen and linking run on a separate thread.
 failed_codegen: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, *ErrorMsg) = .empty,
 failed_types: std.AutoArrayHashMapUnmanaged(InternPool.Index, *ErrorMsg) = .empty,
+
+/// Key is an `AnalUnit` which is in `dependency_loop_nodes`. For each dependency loop, exactly one
+/// unit in the loop is in this map, though the choice is arbitrary and not necessarily reproducible
+/// between compilations. So, instead of (for instance) defining where the dependency loop "starts",
+/// this map simply exists to allow easily iterating all dependency loops exactly once.
+dependency_loops: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
+/// Key is an `AnalUnit`, value is the `AnalUnit` which the key references and why it does so.
+/// All units in here form loops. To iterate loops, see `dependency_loops`.
+dependency_loop_nodes: std.AutoArrayHashMapUnmanaged(AnalUnit, struct {
+    unit: AnalUnit,
+    reason: DependencyReason,
+}) = .empty,
+
 /// Keep track of `@compileLog`s per `AnalUnit`.
 /// We track the source location of the first `@compileLog` call, and all logged lines as a linked list.
 /// The list is singly linked, but we do track its tail for fast appends (optimizing many logs in one unit).
@@ -321,6 +336,12 @@ codegen_task_pool: CodegenTaskPool,
 
 generation: u32 = 0,
 
+pub const DependencyReason = struct {
+    src: LazySrcLoc,
+    /// Only populated if this is for a `.type_layout` unit.
+    type_layout_reason: Sema.type_resolution.LayoutResolveReason,
+};
+
 pub const IncrementalDebugState = struct {
     /// All container types in the ZCU, even dead ones.
     /// Value is the generation the type was created on.
@@ -2778,6 +2799,8 @@ pub fn deinit(zcu: *Zcu) void {
         zcu.analysis_in_progress.deinit(gpa);
         zcu.failed_analysis.deinit(gpa);
         zcu.transitive_failed_analysis.deinit(gpa);
+        zcu.dependency_loops.deinit(gpa);
+        zcu.dependency_loop_nodes.deinit(gpa);
         zcu.failed_codegen.deinit(gpa);
         zcu.failed_types.deinit(gpa);
 
@@ -3536,15 +3559,47 @@ pub fn deleteUnitExports(zcu: *Zcu, anal_unit: AnalUnit) void {
     }
 }
 
-/// Delete all references in `reference_table` which are caused by this `AnalUnit`.
+/// Prepares `unit` for re-analysis by clearing all of the following state:
+/// * Compile errors associated with `unit`
+/// * Compile logs associated with `unit`
+/// * Dependencies from `unit` on other things
+/// * References from `unit` to other units
+/// Delete all references in `reference_table` which are caused by `unit`, and all dependencies it
+/// has. Called in preparation for re-analysis, which will recreate references and dependencies.
 /// Re-analysis of the `AnalUnit` will cause appropriate references to be recreated.
-pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {
-    const gpa = zcu.gpa;
+pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void {
+    const gpa = zcu.comp.gpa;
 
+    // Compile errors
+    if (zcu.failed_analysis.fetchSwapRemove(unit)) |kv| {
+        kv.value.destroy(gpa);
+    } else if (zcu.dependency_loop_nodes.swapRemove(unit)) {
+        _ = zcu.dependency_loops.swapRemove(unit);
+        _ = zcu.transitive_failed_analysis.swapRemove(unit);
+    } else {
+        _ = zcu.transitive_failed_analysis.swapRemove(unit);
+    }
+
+    // Compile logs
+    if (zcu.compile_logs.fetchSwapRemove(unit)) |kv| {
+        var opt_line_idx = kv.value.first_line.toOptional();
+        while (opt_line_idx.unwrap()) |line_idx| {
+            zcu.free_compile_log_lines.append(gpa, line_idx) catch {
+                // This space will be reused eventually, so we need not propagate this error.
+                // Just leak it for now, and let GC reclaim it later on.
+                break;
+            };
+            opt_line_idx = line_idx.get(zcu).next;
+        }
+    }
+
+    // Dependencies
+    zcu.intern_pool.removeDependenciesForDepender(gpa, unit);
+
+    // References
     zcu.clearCachedResolvedReferences();
-
     unit_refs: {
-        const kv = zcu.reference_table.fetchSwapRemove(anal_unit) orelse break :unit_refs;
+        const kv = zcu.reference_table.fetchSwapRemove(unit) orelse break :unit_refs;
         var idx = kv.value;
 
         while (idx != std.math.maxInt(u32)) {
@@ -3572,9 +3627,8 @@ pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {
             }
         }
     }
-
     type_refs: {
-        const kv = zcu.type_reference_table.fetchSwapRemove(anal_unit) orelse break :type_refs;
+        const kv = zcu.type_reference_table.fetchSwapRemove(unit) orelse break :type_refs;
         var idx = kv.value;
 
         while (idx != std.math.maxInt(u32)) {
@@ -3588,22 +3642,6 @@ pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {
     }
 }
 
-/// Delete all compile logs performed by this `AnalUnit`.
-/// Re-analysis of the `AnalUnit` will cause logs to be rediscovered.
-pub fn deleteUnitCompileLogs(zcu: *Zcu, anal_unit: AnalUnit) void {
-    const kv = zcu.compile_logs.fetchSwapRemove(anal_unit) orelse return;
-    const gpa = zcu.gpa;
-    var opt_line_idx = kv.value.first_line.toOptional();
-    while (opt_line_idx.unwrap()) |line_idx| {
-        zcu.free_compile_log_lines.append(gpa, line_idx) catch {
-            // This space will be reused eventually, so we need not propagate this error.
-            // Just leak it for now, and let GC reclaim it later on.
-            return;
-        };
-        opt_line_idx = line_idx.get(zcu).next;
-    }
-}
-
 pub fn addInlineReferenceFrame(zcu: *Zcu, frame: InlineReferenceFrame) Allocator.Error!Zcu.InlineReferenceFrame.Index {
     const frame_idx: InlineReferenceFrame.Index = zcu.free_inline_reference_frames.pop() orelse idx: {
         _ = try zcu.inline_reference_frames.addOne(zcu.gpa);
@@ -4252,11 +4290,7 @@ pub fn fmtDependee(zcu: *Zcu, d: InternPool.Dependee) std.fmt.Alt(FormatDependee
     return .{ .data = .{ .dependee = d, .zcu = zcu } };
 }
 
-const FormatAnalUnit = struct {
-    unit: AnalUnit,
-    zcu: *Zcu,
-};
-
+const FormatAnalUnit = struct { unit: AnalUnit, zcu: *const Zcu };
 fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void {
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
@@ -4280,8 +4314,7 @@ fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void
     }
 }
 
-const FormatDependee = struct { dependee: InternPool.Dependee, zcu: *Zcu };
-
+const FormatDependee = struct { dependee: InternPool.Dependee, zcu: *const Zcu };
 fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void {
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
@@ -4666,6 +4699,273 @@ fn explainWhyFileIsInModule(
     }
 }
 
+pub fn addDependencyLoopErrors(zcu: *Zcu, eb: *std.zig.ErrorBundle.Wip) Allocator.Error!void {
+    const gpa = zcu.comp.gpa;
+
+    const all_references = try zcu.resolveReferences();
+
+    var units: std.ArrayList(AnalUnit) = .empty;
+    defer units.deinit(gpa);
+
+    // TODO: sort the dependency loops somehow to make the error bundle reproducible
+    for (zcu.dependency_loops.keys()) |arbitrary_unit| {
+        units.clearRetainingCapacity();
+
+        var cur = arbitrary_unit;
+        while (true) {
+            try units.append(gpa, cur);
+            cur = zcu.dependency_loop_nodes.get(cur).?.unit;
+            if (cur == arbitrary_unit) break;
+        }
+
+        // `units` now contains all units in the loop. We need to pick a starting point somewhere
+        // along that loop to begin. We will pick whichever node has the shortest reference trace,
+        // because the other units may well just be referenced *by* that one! This is also likely
+        // to match the user's intuition for where the loop "starts".
+        var start_index: usize = 0;
+        var start_depth: u32 = depth: {
+            var depth: u32 = 0;
+            var opt_ref = all_references.get(units.items[0]) orelse {
+                // This dependency loop is actually unreferenced, so we don't need to emit a compile
+                // error at all! Move onto the next dependency loop.
+                continue;
+            };
+            while (opt_ref) |ref| : (opt_ref = all_references.get(ref.referencer).?) depth += 1;
+            break :depth depth;
+        };
+        for (units.items[1..], 1..) |unit, index| {
+            var depth: u32 = 0;
+            var opt_ref = all_references.get(unit).?;
+            while (opt_ref) |ref| : (opt_ref = all_references.get(ref.referencer).?) depth += 1;
+            if (depth < start_depth) {
+                start_index = index;
+                start_depth = depth;
+            }
+        }
+
+        // Collect a reference trace for the start of the loop.
+        var ref_trace: std.ArrayList(std.zig.ErrorBundle.ReferenceTrace) = .empty;
+        defer ref_trace.deinit(gpa);
+        const frame_limit = zcu.comp.reference_trace orelse 0;
+        try zcu.populateReferenceTrace(units.items[start_index], frame_limit, eb, &ref_trace);
+
+        // Collect all notes first so we don't leave an incomplete root error message on `error.AlreadyReported`.
+        const note_buf = try gpa.alloc(std.zig.ErrorBundle.MessageIndex, units.items.len + 1);
+        defer gpa.free(note_buf);
+        note_buf[0] = addDependencyLoopNote(zcu, eb, units.items[start_index], ref_trace.items) catch |err| switch (err) {
+            error.AlreadyReported => return, // give up on the dep loop error
+            error.OutOfMemory => |e| return e,
+        };
+        for (units.items[start_index + 1 ..], note_buf[1 .. units.items.len - start_index]) |unit, *note| {
+            note.* = addDependencyLoopNote(zcu, eb, unit, &.{}) catch |err| switch (err) {
+                error.AlreadyReported => return, // give up on the dep loop error
+                error.OutOfMemory => |e| return e,
+            };
+        }
+        for (units.items[0..start_index], note_buf[units.items.len - start_index .. units.items.len]) |unit, *note| {
+            note.* = addDependencyLoopNote(zcu, eb, unit, &.{}) catch |err| switch (err) {
+                error.AlreadyReported => return, // give up on the dep loop error
+                error.OutOfMemory => |e| return e,
+            };
+        }
+        note_buf[units.items.len] = try eb.addErrorMessage(.{
+            .msg = try eb.addString("eliminate any one of these dependencies to break the loop"),
+            .src_loc = .none,
+        });
+
+        try eb.addRootErrorMessage(.{
+            .msg = try eb.printString("dependency loop with length {d}", .{units.items.len}),
+            .src_loc = .none,
+            .notes_len = @intCast(units.items.len + 1),
+        });
+        const notes_start = try eb.reserveNotes(@intCast(units.items.len + 1));
+        const notes: []std.zig.ErrorBundle.MessageIndex = @ptrCast(eb.extra.items[notes_start..]);
+        @memcpy(notes, note_buf);
+    }
+}
+fn addDependencyLoopNote(
+    zcu: *Zcu,
+    eb: *std.zig.ErrorBundle.Wip,
+    source_unit: AnalUnit,
+    ref_trace: []const std.zig.ErrorBundle.ReferenceTrace,
+) (Allocator.Error || error{AlreadyReported})!std.zig.ErrorBundle.MessageIndex {
+    const ip = &zcu.intern_pool;
+    const comp = zcu.comp;
+
+    const fmt_source: std.fmt.Alt(FormatAnalUnit, formatDependencyLoopSourceUnit) = .{ .data = .{
+        .unit = source_unit,
+        .zcu = zcu,
+    } };
+
+    const dep_node = zcu.dependency_loop_nodes.get(source_unit).?;
+
+    const msg: std.zig.ErrorBundle.String = switch (dep_node.unit.unwrap()) {
+        .@"comptime" => unreachable, // cannot be involved in a dependency loop
+        .nav_val => |nav| try eb.printString("{f} uses value of declaration '{f}' here", .{
+            fmt_source, ip.getNav(nav).fqn.fmt(ip),
+        }),
+        .nav_ty => |nav| try eb.printString("{f} uses type of declaration '{f}' here", .{
+            fmt_source, ip.getNav(nav).fqn.fmt(ip),
+        }),
+        .memoized_state => |stage| switch (stage) {
+            .panic => try eb.printString("{f} requires panic handler for call here", .{fmt_source}),
+            else => try eb.printString("{f} requires 'std.builtin' declarations here", .{fmt_source}),
+        },
+        .func => |func| try eb.printString("{f} uses inferred error set of function '{f}' here", .{
+            fmt_source, ip.getNav(zcu.funcInfo(func).owner_nav).fqn.fmt(ip),
+        }),
+        .type_layout => |ty| try eb.printString("{f} depends on type '{f}' {s}", .{
+            fmt_source,
+            Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
+            dep_node.reason.type_layout_reason.msg(),
+        }),
+    };
+
+    const src_loc = dep_node.reason.src.upgrade(zcu);
+    const source = src_loc.file_scope.getSource(zcu) catch |err| {
+        try Compilation.unableToLoadZcuFile(zcu, eb, src_loc.file_scope, err);
+        return error.AlreadyReported;
+    };
+    const span = src_loc.span(zcu) catch |err| {
+        try Compilation.unableToLoadZcuFile(zcu, eb, src_loc.file_scope, err);
+        return error.AlreadyReported;
+    };
+    const loc = std.zig.findLineColumn(source, span.main);
+    const eb_src = try eb.addSourceLocation(.{
+        .src_path = try eb.printString("{f}", .{src_loc.file_scope.path.fmt(comp)}),
+        .span_start = span.start,
+        .span_main = span.main,
+        .span_end = span.end,
+        .line = @intCast(loc.line),
+        .column = @intCast(loc.column),
+        .source_line = try eb.addString(loc.source_line),
+        .reference_trace_len = @intCast(ref_trace.len),
+    });
+    for (ref_trace) |rt| try eb.addReferenceTrace(rt);
+    return eb.addErrorMessage(.{
+        .msg = msg,
+        .src_loc = eb_src,
+    });
+}
+fn formatDependencyLoopSourceUnit(data: FormatAnalUnit, w: *Io.Writer) Io.Writer.Error!void {
+    const zcu = data.zcu;
+    const ip = &zcu.intern_pool;
+    switch (data.unit.unwrap()) {
+        .@"comptime" => unreachable, // cannot be involved in a dependency loop
+        .nav_val => |nav| try w.print("value of declaration '{f}'", .{ip.getNav(nav).fqn.fmt(ip)}),
+        .nav_ty => |nav| try w.print("type of declaration '{f}'", .{ip.getNav(nav).fqn.fmt(ip)}),
+        .memoized_state => |stage| switch (stage) {
+            .panic => try w.writeAll("panic handler"),
+            else => try w.writeAll("'std.builtin' declarations"),
+        },
+        .type_layout => |ty| try w.print("type '{f}'", .{
+            Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
+        }),
+        .func => |func| try w.print("function '{f}'", .{
+            ip.getNav(zcu.funcInfo(func).owner_nav).fqn.fmt(ip),
+        }),
+    }
+}
+
+pub fn populateReferenceTrace(
+    zcu: *Zcu,
+    root: AnalUnit,
+    frame_limit: u32,
+    eb: *std.zig.ErrorBundle.Wip,
+    ref_trace: *std.ArrayList(std.zig.ErrorBundle.ReferenceTrace),
+) Allocator.Error!void {
+    const ip = &zcu.intern_pool;
+    const gpa = zcu.comp.gpa;
+
+    if (frame_limit == 0) return;
+
+    const all_references = try zcu.resolveReferences();
+
+    var seen: std.AutoHashMapUnmanaged(InternPool.AnalUnit, void) = .empty;
+    defer seen.deinit(gpa);
+
+    var referenced_by = root;
+    while (all_references.get(referenced_by)) |maybe_ref| {
+        const ref = maybe_ref orelse break;
+        const gop = try seen.getOrPut(gpa, ref.referencer);
+        if (gop.found_existing) break;
+        if (ref_trace.items.len < frame_limit) {
+            var last_call_src = ref.src;
+            var opt_inline_frame = ref.inline_frame;
+            while (opt_inline_frame.unwrap()) |inline_frame| {
+                const f = inline_frame.ptr(zcu).*;
+                const func_nav = ip.indexToKey(f.callee).func.owner_nav;
+                const func_name = ip.getNav(func_nav).name.toSlice(ip);
+                addReferenceTraceFrame(zcu, eb, ref_trace, func_name, last_call_src, true) catch |err| switch (err) {
+                    error.OutOfMemory => |e| return e,
+                    error.AlreadyReported => {
+                        // An incomplete reference trace isn't the end of the world; just cut it off.
+                        return;
+                    },
+                };
+                last_call_src = f.call_src;
+                opt_inline_frame = f.parent;
+            }
+            const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
+                .@"comptime" => "comptime",
+                .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
+                .type_layout => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
+                .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
+                .memoized_state => null,
+            };
+            if (root_name) |n| {
+                addReferenceTraceFrame(zcu, eb, ref_trace, n, last_call_src, false) catch |err| switch (err) {
+                    error.OutOfMemory => |e| return e,
+                    error.AlreadyReported => {
+                        // An incomplete reference trace isn't the end of the world; just cut it off.
+                        return;
+                    },
+                };
+            }
+        }
+        referenced_by = ref.referencer;
+    }
+
+    if (seen.count() > ref_trace.items.len) {
+        try ref_trace.append(gpa, .{
+            .decl_name = @intCast(seen.count() - ref_trace.items.len),
+            .src_loc = .none,
+        });
+    }
+}
+fn addReferenceTraceFrame(
+    zcu: *Zcu,
+    eb: *std.zig.ErrorBundle.Wip,
+    ref_trace: *std.ArrayList(std.zig.ErrorBundle.ReferenceTrace),
+    name: []const u8,
+    lazy_src: Zcu.LazySrcLoc,
+    inlined: bool,
+) error{ OutOfMemory, AlreadyReported }!void {
+    const gpa = zcu.gpa;
+    const src = lazy_src.upgrade(zcu);
+    const source = src.file_scope.getSource(zcu) catch |err| {
+        try Compilation.unableToLoadZcuFile(zcu, eb, src.file_scope, err);
+        return error.AlreadyReported;
+    };
+    const span = src.span(zcu) catch |err| {
+        try Compilation.unableToLoadZcuFile(zcu, eb, src.file_scope, err);
+        return error.AlreadyReported;
+    };
+    const loc = std.zig.findLineColumn(source, span.main);
+    try ref_trace.append(gpa, .{
+        .decl_name = try eb.printString("{s}{s}", .{ name, if (inlined) " [inlined]" else "" }),
+        .src_loc = try eb.addSourceLocation(.{
+            .src_path = try eb.printString("{f}", .{src.file_scope.path.fmt(zcu.comp)}),
+            .span_start = span.start,
+            .span_main = span.main,
+            .span_end = span.end,
+            .line = @intCast(loc.line),
+            .column = @intCast(loc.column),
+            .source_line = 0,
+        }),
+    });
+}
+
 const TrackedUnitSema = struct {
     /// `null` means we created the node, so should end it.
     old_name: ?[std.Progress.Node.max_name_len]u8,
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 8d6af9c3ad7c4e688be88323f3578ce571a2f500..954d1cd3bff44529db52325785eb7aa7d1c1f0d2 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -728,7 +728,12 @@ pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Alloca
 /// Ensures that all memoized state on `Zcu` is up-to-date, performing re-analysis if necessary.
 /// Returns `error.AnalysisFail` if an analysis error is encountered; the caller is free to ignore
 /// this, since the error is already registered, but it must not use the value of memoized fields.
-pub fn ensureMemoizedStateUpToDate(pt: Zcu.PerThread, stage: InternPool.MemoizedStateStage) Zcu.SemaError!void {
+pub fn ensureMemoizedStateUpToDate(
+    pt: Zcu.PerThread,
+    stage: InternPool.MemoizedStateStage,
+    /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -748,12 +753,7 @@ pub fn ensureMemoizedStateUpToDate(pt: Zcu.PerThread, stage: InternPool.Memoized
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(unit);
         // No need for `deleteUnitExports` because we never export anything.
-        zcu.deleteUnitReferences(unit);
-        zcu.deleteUnitCompileLogs(unit);
-        if (zcu.failed_analysis.fetchSwapRemove(unit)) |kv| {
-            kv.value.destroy(gpa);
-        }
-        _ = zcu.transitive_failed_analysis.swapRemove(unit);
+        zcu.resetUnit(unit);
     } else {
         if (prev_failed) return error.AnalysisFail;
         // We use an arbitrary element to check if the state has been resolved yet.
@@ -772,7 +772,7 @@ pub fn ensureMemoizedStateUpToDate(pt: Zcu.PerThread, stage: InternPool.Memoized
         info.deps.clearRetainingCapacity();
     }
 
-    const any_changed: bool, const new_failed: bool = if (pt.analyzeMemoizedState(stage)) |any_changed|
+    const any_changed: bool, const new_failed: bool = if (pt.analyzeMemoizedState(stage, reason)) |any_changed|
         .{ any_changed or prev_failed, false }
     else |err| switch (err) {
         error.AnalysisFail => res: {
@@ -805,14 +805,18 @@ pub fn ensureMemoizedStateUpToDate(pt: Zcu.PerThread, stage: InternPool.Memoized
     if (new_failed) return error.AnalysisFail;
 }
 
-fn analyzeMemoizedState(pt: Zcu.PerThread, stage: InternPool.MemoizedStateStage) Zcu.CompileError!bool {
+fn analyzeMemoizedState(
+    pt: Zcu.PerThread,
+    stage: InternPool.MemoizedStateStage,
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.CompileError!bool {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
 
     const unit: AnalUnit = .wrap(.{ .memoized_state = stage });
 
-    try zcu.analysis_in_progress.putNoClobber(gpa, unit, {});
+    try zcu.analysis_in_progress.putNoClobber(gpa, unit, reason);
     defer assert(zcu.analysis_in_progress.swapRemove(unit));
 
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
@@ -871,13 +875,7 @@ pub fn ensureComptimeUnitUpToDate(pt: Zcu.PerThread, cu_id: InternPool.ComptimeU
         // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
             zcu.deleteUnitExports(anal_unit);
-            zcu.deleteUnitReferences(anal_unit);
-            zcu.deleteUnitCompileLogs(anal_unit);
-            if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-                kv.value.destroy(gpa);
-            }
-            _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
-            zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
+            zcu.resetUnit(anal_unit);
         }
     } else {
         // We can trust the current information about this unit.
@@ -943,7 +941,7 @@ fn analyzeComptimeUnit(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu
     const file = zcu.fileByIndex(inst_resolved.file);
     const zir = file.zir.?;
 
-    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {});
+    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, null);
     defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
@@ -1009,7 +1007,12 @@ fn analyzeComptimeUnit(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu
 /// re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!) or union. Returns
 /// `error.AnalysisFail` if an analysis error is encountered during type resolution; the caller is
 /// free to ignore this, since the error is already registered.
-pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
+pub fn ensureTypeLayoutUpToDate(
+    pt: Zcu.PerThread,
+    ty: Type,
+    /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1031,13 +1034,7 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
         // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
             zcu.deleteUnitExports(anal_unit);
-            zcu.deleteUnitReferences(anal_unit);
-            zcu.deleteUnitCompileLogs(anal_unit);
-            if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-                kv.value.destroy(gpa);
-            }
-            _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
-            zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
+            zcu.resetUnit(anal_unit);
         }
         // For types, we already know that we have to invalidate all dependees.
         // TODO: we actually *could* detect whether everything was the same. should we bother?
@@ -1058,7 +1055,7 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
     const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(&zcu.intern_pool).toSlice(&zcu.intern_pool), null);
     defer unit_tracking.end(zcu);
 
-    try zcu.analysis_in_progress.put(gpa, anal_unit, {});
+    try zcu.analysis_in_progress.put(gpa, anal_unit, reason);
     defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
@@ -1114,7 +1111,12 @@ pub fn ensureTypeLayoutUpToDate(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void
 /// Ensures that the resolved value of the given `Nav` is fully up-to-date, performing re-analysis
 /// if necessary. Returns `error.AnalysisFail` if an analysis error is encountered; the caller is
 /// free to ignore this, since the error is already registered.
-pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.SemaError!void {
+pub fn ensureNavValUpToDate(
+    pt: Zcu.PerThread,
+    nav_id: InternPool.Nav.Index,
+    /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1150,13 +1152,7 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(anal_unit);
         zcu.deleteUnitExports(anal_unit);
-        zcu.deleteUnitReferences(anal_unit);
-        zcu.deleteUnitCompileLogs(anal_unit);
-        if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-            kv.value.destroy(gpa);
-        }
-        _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
-        ip.removeDependenciesForDepender(gpa, anal_unit);
+        zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
         if (prev_failed) return error.AnalysisFail;
@@ -1173,7 +1169,7 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
     const unit_tracking = zcu.trackUnitSema(nav.fqn.toSlice(ip), nav.srcInst(ip));
     defer unit_tracking.end(zcu);
 
-    const invalidate_value: bool, const new_failed: bool = if (pt.analyzeNavVal(nav_id)) |result| res: {
+    const invalidate_value: bool, const new_failed: bool = if (pt.analyzeNavVal(nav_id, reason)) |result| res: {
         break :res .{
             // If the unit has gone from failed to success, we still need to invalidate the dependencies.
             result.val_changed or prev_failed,
@@ -1217,39 +1213,14 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
         }
     }
 
-    // If there isn't a type annotation, then we have also just resolved the type. That means the
-    // the type is up-to-date, so it won't have the chance to mark its own dependency on the value;
-    // we must do that ourselves.
-    type_deps_on_val: {
-        const inst_resolved = nav.analysis.?.zir_index.resolveFull(ip) orelse break :type_deps_on_val;
-        const file = zcu.fileByIndex(inst_resolved.file);
-        const zir_decl = file.zir.?.getDeclaration(inst_resolved.inst);
-        if (zir_decl.type_body != null) break :type_deps_on_val;
-        // The type does indeed depend on the value. We are responsible for populating all state of
-        // the `nav_ty`, including exports, references, errors, and dependencies.
-        const ty_unit: AnalUnit = .wrap(.{ .nav_ty = nav_id });
-        const ty_was_outdated = zcu.outdated.swapRemove(ty_unit) or
-            zcu.potentially_outdated.swapRemove(ty_unit);
-        if (ty_was_outdated) {
-            _ = zcu.outdated_ready.swapRemove(ty_unit);
-            zcu.deleteUnitExports(ty_unit);
-            zcu.deleteUnitReferences(ty_unit);
-            zcu.deleteUnitCompileLogs(ty_unit);
-            if (zcu.failed_analysis.fetchSwapRemove(ty_unit)) |kv| {
-                kv.value.destroy(gpa);
-            }
-            _ = zcu.transitive_failed_analysis.swapRemove(ty_unit);
-            ip.removeDependenciesForDepender(gpa, ty_unit);
-        }
-        try pt.addDependency(ty_unit, .{ .nav_val = nav_id });
-        if (new_failed) try zcu.transitive_failed_analysis.put(gpa, ty_unit, {});
-        if (ty_was_outdated) try zcu.markDependeeOutdated(.marked_po, .{ .nav_ty = nav_id });
-    }
-
     if (new_failed) return error.AnalysisFail;
 }
 
-fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileError!struct { val_changed: bool } {
+fn analyzeNavVal(
+    pt: Zcu.PerThread,
+    nav_id: InternPool.Nav.Index,
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.CompileError!struct { val_changed: bool } {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const comp = zcu.comp;
@@ -1266,17 +1237,9 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
     const zir = file.zir.?;
     const zir_decl = zir.getDeclaration(inst_resolved.inst);
 
-    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {});
+    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, reason);
     errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);
 
-    // If there's no type body, we are also resolving the type here.
-    if (zir_decl.type_body == null) {
-        try zcu.analysis_in_progress.putNoClobber(gpa, .wrap(.{ .nav_ty = nav_id }), {});
-    }
-    errdefer if (zir_decl.type_body == null) {
-        _ = zcu.analysis_in_progress.swapRemove(.wrap(.{ .nav_ty = nav_id }));
-    };
-
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
     defer analysis_arena.deinit();
 
@@ -1352,9 +1315,6 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
 
     const nav_ty: Type = maybe_ty orelse final_val.?.typeOf(zcu);
 
-    // First, we must resolve the declaration's type. To do this, we analyze the type body if available,
-    // or otherwise, we analyze the value body, populating `early_val` in the process.
-
     const is_const = is_const: switch (zir_decl.kind) {
         .@"comptime" => unreachable, // this is not a Nav
         .unnamed_test, .@"test", .decltest => {
@@ -1441,7 +1401,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
 
     // This resolves the type of the resolved value, not that value itself. If `nav_val` is a struct type,
     // this resolves the type `type` (which needs no resolution), not the struct itself.
-    try sema.ensureLayoutResolved(nav_ty, init_src);
+    try sema.ensureLayoutResolved(nav_ty, block.nodeOffset(.zero), if (zir_decl.kind == .@"var") .variable else .constant);
 
     const queue_linker_work, const is_owned_fn = switch (ip.indexToKey(nav_val.toIntern())) {
         .func => |f| .{ true, f.owner_nav == nav_id }, // note that this lets function aliases reach codegen
@@ -1460,18 +1420,18 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
         }
     } else if (nav_ty.comptimeOnly(zcu)) {
         // alignment, linksection, addrspace annotations are not allowed for comptime-only types.
-        const reason: []const u8 = switch (ip.indexToKey(nav_val.toIntern())) {
+        const cannot_align_reason: []const u8 = switch (ip.indexToKey(nav_val.toIntern())) {
             .func => "function alias", // slightly clearer message, since you *can* specify these on function *declarations*
             else => "comptime-only type",
         };
         if (zir_decl.align_body != null) {
-            return sema.fail(&block, align_src, "cannot specify alignment of {s}", .{reason});
+            return sema.fail(&block, align_src, "cannot specify alignment of {s}", .{cannot_align_reason});
         }
         if (zir_decl.linksection_body != null) {
-            return sema.fail(&block, section_src, "cannot specify linksection of {s}", .{reason});
+            return sema.fail(&block, section_src, "cannot specify linksection of {s}", .{cannot_align_reason});
         }
         if (zir_decl.addrspace_body != null) {
-            return sema.fail(&block, addrspace_src, "cannot specify addrspace of {s}", .{reason});
+            return sema.fail(&block, addrspace_src, "cannot specify addrspace of {s}", .{cannot_align_reason});
         }
     }
 
@@ -1484,10 +1444,8 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
     });
 
     // Mark the unit as completed before evaluating the export!
+    // MLUGG TODO: do we really need to do this?
     assert(zcu.analysis_in_progress.swapRemove(anal_unit));
-    if (zir_decl.type_body == null) {
-        assert(zcu.analysis_in_progress.swapRemove(.wrap(.{ .nav_ty = nav_id })));
-    }
 
     if (zir_decl.linkage == .@"export") {
         const export_src = block.src(.{ .token_offset = @enumFromInt(@intFromBool(zir_decl.is_pub)) });
@@ -1516,7 +1474,12 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
     }
 }
 
-pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.SemaError!void {
+pub fn ensureNavTypeUpToDate(
+    pt: Zcu.PerThread,
+    nav_id: InternPool.Nav.Index,
+    /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1533,18 +1496,6 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc
 
     try zcu.ensureNavValAnalysisQueued(nav_id);
 
-    const type_resolved_by_value: bool = from_val: {
-        const analysis = nav.analysis orelse break :from_val false;
-        const inst_resolved = analysis.zir_index.resolveFull(ip) orelse break :from_val false;
-        const file = zcu.fileByIndex(inst_resolved.file);
-        const zir_decl = file.zir.?.getDeclaration(inst_resolved.inst);
-        break :from_val zir_decl.type_body == null;
-    };
-    if (type_resolved_by_value) {
-        // Logic at the end of `ensureNavValUpToDate` is directly responsible for populating our state.
-        return pt.ensureNavValUpToDate(nav_id);
-    }
-
     // Determine whether or not this `Nav`'s type is outdated. This also includes checking if the
     // status is `.unresolved`, which indicates that the value is outdated because it has *never*
     // been analyzed so far.
@@ -1564,13 +1515,7 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(anal_unit);
         zcu.deleteUnitExports(anal_unit);
-        zcu.deleteUnitReferences(anal_unit);
-        zcu.deleteUnitCompileLogs(anal_unit);
-        if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-            kv.value.destroy(gpa);
-        }
-        _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
-        ip.removeDependenciesForDepender(gpa, anal_unit);
+        zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
         if (prev_failed) return error.AnalysisFail;
@@ -1587,7 +1532,7 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc
     const unit_tracking = zcu.trackUnitSema(nav.fqn.toSlice(ip), nav.srcInst(ip));
     defer unit_tracking.end(zcu);
 
-    const invalidate_type: bool, const new_failed: bool = if (pt.analyzeNavType(nav_id)) |result| res: {
+    const invalidate_type: bool, const new_failed: bool = if (pt.analyzeNavType(nav_id, reason)) |result| res: {
         break :res .{
             // If the unit has gone from failed to success, we still need to invalidate the dependencies.
             result.type_changed or prev_failed,
@@ -1634,7 +1579,11 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc
     if (new_failed) return error.AnalysisFail;
 }
 
-fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileError!struct { type_changed: bool } {
+fn analyzeNavType(
+    pt: Zcu.PerThread,
+    nav_id: InternPool.Nav.Index,
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.CompileError!struct { type_changed: bool } {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = comp.gpa;
@@ -1650,11 +1599,10 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
     const file = zcu.fileByIndex(inst_resolved.file);
     const zir = file.zir.?;
 
-    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {});
+    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, reason);
     defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
     const zir_decl = zir.getDeclaration(inst_resolved.inst);
-    const type_body = zir_decl.type_body.?;
 
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
     defer analysis_arena.deinit();
@@ -1696,6 +1644,17 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
     defer block.instructions.deinit(gpa);
 
     const ty_src = block.src(.{ .node_offset_var_decl_ty = .zero });
+    const init_src = block.src(.{ .node_offset_var_decl_init = .zero });
+
+    const type_body = zir_decl.type_body orelse {
+        // There is no type annotation, so we just need to use the declaration's value.
+        try sema.ensureNavResolved(&block, init_src, nav_id, .fully);
+        // We don't actually know what the type of this Nav was before it was resolved, so we just
+        // have to assume we were outdated. This isn't too bad, because assuming there was also no
+        // type annotation last update, we should only be re-analyzed if the value changes (it's our
+        // only dependency), or if there was a dependency loop.
+        return .{ .type_changed = true };
+    };
 
     block.comptime_reason = .{ .reason = .{
         .src = ty_src,
@@ -1708,7 +1667,7 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
         break :ty .fromInterned(type_ref.toInterned().?);
     };
 
-    try sema.ensureLayoutResolved(resolved_ty, ty_src);
+    try sema.ensureLayoutResolved(resolved_ty, block.nodeOffset(.zero), if (zir_decl.kind == .@"var") .variable else .constant);
 
     // In the case where the type is specified, this function is also responsible for resolving
     // the pointer modifiers, i.e. alignment, linksection, addrspace.
@@ -1758,7 +1717,12 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
     return .{ .type_changed = true };
 }
 
-pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!void {
+pub fn ensureFuncBodyUpToDate(
+    pt: Zcu.PerThread,
+    func_index: InternPool.Index,
+    /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!void {
     dev.check(.sema);
 
     const tracy = trace(@src());
@@ -1788,12 +1752,7 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(anal_unit);
         zcu.deleteUnitExports(anal_unit);
-        zcu.deleteUnitReferences(anal_unit);
-        zcu.deleteUnitCompileLogs(anal_unit);
-        if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) |kv| {
-            kv.value.destroy(gpa);
-        }
-        _ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
+        zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this function.
         if (prev_failed) return error.AnalysisFail;
@@ -1813,7 +1772,7 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
     );
     defer unit_tracking.end(zcu);
 
-    const ies_outdated, const new_failed = if (pt.analyzeFuncBody(func_index)) |result|
+    const ies_outdated, const new_failed = if (pt.analyzeFuncBody(func_index, reason)) |result|
         .{ prev_failed or result.ies_outdated, false }
     else |err| switch (err) {
         error.AnalysisFail => res: {
@@ -1854,6 +1813,7 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Z
 fn analyzeFuncBody(
     pt: Zcu.PerThread,
     func_index: InternPool.Index,
+    reason: ?*const Zcu.DependencyReason,
 ) Zcu.SemaError!struct { ies_outdated: bool } {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -1868,7 +1828,7 @@ fn analyzeFuncBody(
 
     if (func.generic_owner == .none) {
         // Among another things, this ensures that the function's `zir_body_inst` is correct.
-        try pt.ensureNavValUpToDate(func.owner_nav);
+        try pt.ensureNavValUpToDate(func.owner_nav, reason);
         if (ip.getNav(func.owner_nav).status.fully_resolved.val != func_index) {
             // This function is no longer referenced! There's no point in re-analyzing it.
             // Just mark a transitive failure and move on.
@@ -1877,7 +1837,7 @@ fn analyzeFuncBody(
     } else {
         const go_nav = zcu.funcInfo(func.generic_owner).owner_nav;
         // Among another things, this ensures that the function's `zir_body_inst` is correct.
-        try pt.ensureNavValUpToDate(go_nav);
+        try pt.ensureNavValUpToDate(go_nav, reason);
         if (ip.getNav(go_nav).status.fully_resolved.val != func.generic_owner) {
             // The generic owner is no longer referenced, so this function is also unreferenced.
             // There's no point in re-analyzing it. Just mark a transitive failure and move on.
@@ -1894,7 +1854,7 @@ fn analyzeFuncBody(
 
     log.debug("analyze and generate fn body {f}", .{zcu.fmtAnalUnit(anal_unit)});
 
-    var air = try pt.analyzeFuncBodyInner(func_index);
+    var air = try pt.analyzeFuncBodyInner(func_index, reason);
     errdefer air.deinit(gpa);
 
     const ies_outdated = !func.analysisUnordered(ip).inferred_error_set or
@@ -2842,7 +2802,11 @@ const ScanDeclIter = struct {
     }
 };
 
-fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!Air {
+fn analyzeFuncBodyInner(
+    pt: Zcu.PerThread,
+    func_index: InternPool.Index,
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!Air {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -2858,7 +2822,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
     const file = zcu.fileByIndex(inst_info.file);
     const zir = file.zir.?;
 
-    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {});
+    try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, reason);
     defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
     if (func.analysisUnordered(ip).inferred_error_set) {
@@ -2879,8 +2843,6 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
 
     const func_nav = ip.getNav(func.owner_nav);
 
-    zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
-
     var analysis_arena = std.heap.ArenaAllocator.init(gpa);
     defer analysis_arena.deinit();
 
@@ -2978,7 +2940,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
         const param_ty: Type = .fromInterned(fn_ty_info.param_types.get(ip)[runtime_param_index]);
         runtime_param_index += 1;
 
-        try sema.ensureLayoutResolved(param_ty, inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) }));
+        try sema.ensureLayoutResolved(param_ty, inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) }), .parameter);
         if (try param_ty.onePossibleValue(pt)) |opv| {
             gop.value_ptr.* = .fromValue(opv);
             continue;
@@ -2995,7 +2957,7 @@ fn analyzeFuncBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.Sem
         });
     }
 
-    try sema.ensureLayoutResolved(sema.fn_ret_ty, inner_block.src(.{ .node_offset_fn_type_ret_ty = .zero }));
+    try sema.ensureLayoutResolved(sema.fn_ret_ty, inner_block.src(.{ .node_offset_fn_type_ret_ty = .zero }), .return_type);
 
     const last_arg_index = inner_block.instructions.items.len;
 
@@ -4206,7 +4168,7 @@ pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
         },
 
         .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .struct_type => try pt.ensureTypeLayoutUpToDate(ty),
+            .struct_type => try pt.ensureTypeLayoutUpToDate(ty, null),
             .tuple_type => |tuple| for (0..tuple.types.len) |i| {
                 const field_is_comptime = tuple.values.get(ip)[i] != .none;
                 if (field_is_comptime) continue;
@@ -4216,8 +4178,8 @@ pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
             else => unreachable,
         },
 
-        .@"union" => try pt.ensureTypeLayoutUpToDate(ty),
-        .@"enum" => try pt.ensureTypeLayoutUpToDate(ty),
+        .@"union" => try pt.ensureTypeLayoutUpToDate(ty, null),
+        .@"enum" => try pt.ensureTypeLayoutUpToDate(ty, null),
     }
 }
 pub fn resolveValueTypesForCodegen(pt: Zcu.PerThread, val: Value) Zcu.SemaError!void {
diff --git a/test/incremental/type_dependency_loop b/test/incremental/type_dependency_loop
new file mode 100644
index 0000000000000000000000000000000000000000..40f41bf19fe4bb4d7a19b5a4a40a0a10fb361ca9
--- /dev/null
+++ b/test/incremental/type_dependency_loop
@@ -0,0 +1,55 @@
+#target=x86_64-linux-selfhosted
+#target=x86_64-windows-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#target=wasm32-wasi-selfhosted
+#update=initial version
+#file=main.zig
+pub const A = struct { b: B };
+pub const B = struct { a: A };
+pub fn main() void {
+    _ = @as(B, undefined);
+}
+#expect_error=:error: dependency loop with length 2
+#expect_error=main.zig:2:27: note: type 'main.B' depends on type 'main.A' for field declared here
+#expect_error=main.zig:1:27: note: type 'main.A' depends on type 'main.B' for field declared here
+#expect_error=:note: eliminate any one of these dependencies to break the loop
+
+#update=remove reference to dependency loop
+#file=main.zig
+pub const A = struct { b: B };
+pub const B = struct { a: A };
+pub fn main() void {
+    _ = B;
+}
+#expect_stdout=""
+
+#update=change dependency loop without fixing it
+#file=main.zig
+pub const A = struct { b: B };
+pub const B = struct { a: *align(@alignOf(A)) A };
+pub fn main() void {
+    _ = B;
+}
+#expect_stdout=""
+
+#update=reference dependency loop again
+#file=main.zig
+pub const A = struct { b: B };
+pub const B = struct { a: *align(@alignOf(A)) A };
+pub fn main() void {
+    _ = @as(B, undefined);
+}
+#expect_error=:error: dependency loop with length 2
+#expect_error=main.zig:2:43: note: type 'main.B' depends on type 'main.A' for alignment query here
+#expect_error=main.zig:1:27: note: type 'main.A' depends on type 'main.B' for field declared here
+#expect_error=:note: eliminate any one of these dependencies to break the loop
+
+#update=fix dependency loop
+#file=main.zig
+pub const A = struct { b: B };
+pub const B = struct { a: *A };
+pub fn main() void {
+    _ = @as(B, undefined);
+}
+#expect_stdout=""
diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index 171af570361c4986b3ddd75ac909d2ba6b1a7551..87a782c2d314d7e2467fbd8e6fe35a3e27bf0489 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -417,29 +417,32 @@ const Eval = struct {
         is_note: bool,
         err_idx: std.zig.ErrorBundle.MessageIndex,
     ) Allocator.Error!void {
+        const io = eval.io;
         const err = eb.getErrorMessage(err_idx);
-        if (err.src_loc == .none) @panic("TODO error message with no source location");
         if (err.count != 1) @panic("TODO error message with count>1");
         const msg = eb.nullTerminatedString(err.msg);
-        const src = eb.getSourceLocation(err.src_loc);
-        const raw_filename = eb.nullTerminatedString(src.src_path);
-
-        const io = eval.io;
-
-        // We need to replace backslashes for consistency between platforms.
-        const filename = name: {
-            if (std.mem.indexOfScalar(u8, raw_filename, '\\') == null) break :name raw_filename;
-            const copied = try eval.arena.dupe(u8, raw_filename);
-            std.mem.replaceScalar(u8, copied, '\\', '/');
-            break :name copied;
+        const matches = matches: {
+            if (expected.is_note != is_note) break :matches false;
+            if (!std.mem.eql(u8, expected.msg, msg)) break :matches false;
+            if (err.src_loc == .none) {
+                break :matches expected.src == null;
+            }
+            const expected_src = expected.src orelse break :matches false;
+            const src = eb.getSourceLocation(err.src_loc);
+            const raw_filename = eb.nullTerminatedString(src.src_path);
+            // We need to replace backslashes for consistency between platforms.
+            const filename = name: {
+                if (std.mem.indexOfScalar(u8, raw_filename, '\\') == null) break :name raw_filename;
+                const copied = try eval.arena.dupe(u8, raw_filename);
+                std.mem.replaceScalar(u8, copied, '\\', '/');
+                break :name copied;
+            };
+            if (!std.mem.eql(u8, expected_src.filename, filename)) break :matches false;
+            if (expected_src.line != src.line + 1) break :matches false;
+            if (expected_src.column != src.column + 1) break :matches false;
+            break :matches true;
         };
-
-        if (expected.is_note != is_note or
-            !std.mem.eql(u8, expected.filename, filename) or
-            expected.line != src.line + 1 or
-            expected.column != src.column + 1 or
-            !std.mem.eql(u8, expected.msg, msg))
-        {
+        if (!matches) {
             eb.renderToStderr(io, .{}, .auto) catch {};
             eval.fatal("compile error did not match expected error", .{});
         }
@@ -714,10 +717,12 @@ const Case = struct {
 
     const ExpectedError = struct {
         is_note: bool,
-        filename: []const u8,
-        line: u32,
-        column: u32,
         msg: []const u8,
+        src: ?struct {
+            filename: []const u8,
+            line: u32,
+            column: u32,
+        },
     };
 
     fn parse(arena: Allocator, io: Io, bytes: []const u8) !Case {
@@ -930,16 +935,16 @@ fn parseExpectedError(str: []const u8, l: usize) Case.ExpectedError {
 
     var it = std.mem.splitScalar(u8, str, ':');
     const filename = it.first();
-    const line_str = it.next() orelse fatal("line {d}: incomplete error specification", .{l});
-    const column_str = it.next() orelse fatal("line {d}: incomplete error specification", .{l});
+    const line_str, const column_str = if (filename.len > 0) .{
+        it.next() orelse fatal("line {d}: incomplete error specification", .{l}),
+        it.next() orelse fatal("line {d}: incomplete error specification", .{l}),
+    } else .{ undefined, undefined };
     const error_or_note_str = std.mem.trim(
         u8,
         it.next() orelse fatal("line {d}: incomplete error specification", .{l}),
         " ",
     );
-    const message = std.mem.trim(u8, it.rest(), " ");
-    if (filename.len == 0) fatal("line {d}: empty filename", .{l});
-    if (message.len == 0) fatal("line {d}: empty error message", .{l});
+
     const is_note = if (std.mem.eql(u8, error_or_note_str, "error"))
         false
     else if (std.mem.eql(u8, error_or_note_str, "note"))
@@ -947,18 +952,19 @@ fn parseExpectedError(str: []const u8, l: usize) Case.ExpectedError {
     else
         fatal("line {d}: expeted 'error' or 'note', found '{s}'", .{ l, error_or_note_str });
 
-    const line = std.fmt.parseInt(u32, line_str, 10) catch
-        fatal("line {d}: invalid line number '{s}'", .{ l, line_str });
-
-    const column = std.fmt.parseInt(u32, column_str, 10) catch
-        fatal("line {d}: invalid column number '{s}'", .{ l, column_str });
+    const message = std.mem.trim(u8, it.rest(), " ");
+    if (message.len == 0) fatal("line {d}: empty error message", .{l});
 
     return .{
         .is_note = is_note,
-        .filename = filename,
-        .line = line,
-        .column = column,
         .msg = message,
+        .src = if (filename.len == 0) null else .{
+            .filename = filename,
+            .line = std.fmt.parseInt(u32, line_str, 10) catch
+                fatal("line {d}: invalid line number '{s}'", .{ l, line_str }),
+            .column = std.fmt.parseInt(u32, column_str, 10) catch
+                fatal("line {d}: invalid column number '{s}'", .{ l, column_str }),
+        },
     };
 }
 
-- 
2.54.0


From c91b06ef52f31090b3c8fda9b9a419bf1391d805 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Mar 2026 19:13:59 +0000
Subject: [PATCH 430/499] incr-check: fix successful -fno-emit-bin updates

---
 tools/incr-check.zig | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index 87a782c2d314d7e2467fbd8e6fe35a3e27bf0489..6b3351b315a3c23a443faca94c61bae0367a304e 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -338,7 +338,7 @@ const Eval = struct {
 
                     if (eval.target.backend == .sema) {
                         try eval.checkSuccessOutcome(update, null, prog_node);
-                        // This message indicates the end of the update.
+                        continue;
                     }
 
                     const digest = r.takeArray(Cache.bin_digest_len) catch unreachable;
@@ -352,7 +352,6 @@ const Eval = struct {
                     const bin_path = try Dir.path.join(arena, &.{ result_dir, bin_name });
 
                     try eval.checkSuccessOutcome(update, bin_path, prog_node);
-                    // This message indicates the end of the update.
                 },
                 else => {
                     // Ignore other messages.
-- 
2.54.0


From 03e23bcbdea2e832307085e5855ca20b51ac9d9a Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 7 Feb 2026 12:23:54 +0000
Subject: [PATCH 431/499] resolve some of my TODOs

---
 src/Sema.zig          | 141 ++++++++++++++++++++----------------------
 src/Sema/LowerZon.zig | 110 +++++++++++++++-----------------
 src/Value.zig         |   1 -
 src/Zcu.zig           |  72 ++++++++++-----------
 src/Zcu/PerThread.zig |  14 +----
 5 files changed, 148 insertions(+), 190 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index cbfe6421db8b7fc50a3954664eb93e3c0ff295f5..0504bb7e5e251d656e2daf1f0e016d098a80e520 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5746,91 +5746,94 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         }
     }
 
+    const export_ty = ptr_ty.childType(zcu);
+    if (!export_ty.validateExtern(.other, zcu)) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
+            errdefer msg.destroy(sema.gpa);
+            try sema.explainWhyTypeIsNotExtern(msg, src, export_ty, .other);
+            try sema.addDeclaredHereNote(msg, export_ty);
+            break :msg msg;
+        });
+    }
+
     const ptr_info = ip.indexToKey(ptr_val.toIntern()).ptr;
-    switch (ptr_info.base_addr) {
+    const target: Zcu.Exported = switch (ptr_info.base_addr) {
         .comptime_alloc, .int, .comptime_field => return sema.fail(block, ptr_src, "export target must be a global variable or a comptime-known constant", .{}),
         .eu_payload, .opt_payload, .field, .arr_elem => return sema.fail(block, ptr_src, "TODO: export pointer in middle of value", .{}),
-        .uav => |uav| {
-            if (ptr_info.byte_offset != 0) {
-                return sema.fail(block, ptr_src, "TODO: export pointer in middle of value", .{});
+        .uav => |uav| .{ .uav = uav.val },
+        .nav => |orig_nav| target: {
+            try sema.ensureNavResolved(block, src, orig_nav, .fully);
+            const export_nav = switch (ip.indexToKey(ip.getNav(orig_nav).status.fully_resolved.val)) {
+                .variable => |v| v.owner_nav,
+                .@"extern" => |e| e.owner_nav,
+                .func => |f| f.owner_nav,
+                else => orig_nav,
+            };
+            if (ip.getNav(export_nav).getExtern(ip) != null) {
+                return sema.fail(block, src, "export target cannot be extern", .{});
             }
-            if (zcu.llvm_object != null and options.linkage == .internal) return;
-            const export_ty = Value.fromInterned(uav.val).typeOf(zcu);
-            if (!export_ty.validateExtern(.other, zcu)) {
-                return sema.failWithOwnedErrorMsg(block, msg: {
-                    const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
-                    errdefer msg.destroy(sema.gpa);
-                    try sema.explainWhyTypeIsNotExtern(msg, src, export_ty, .other);
-                    try sema.addDeclaredHereNote(msg, export_ty);
-                    break :msg msg;
-                });
-            }
-            try sema.exports.append(zcu.gpa, .{
-                .opts = options,
-                .src = src,
-                .exported = .{ .uav = uav.val },
-                .status = .in_progress,
-            });
-        },
-        .nav => |nav| {
-            if (ptr_info.byte_offset != 0) {
-                return sema.fail(block, ptr_src, "TODO: export pointer in middle of value", .{});
-            }
-            try sema.analyzeExport(block, src, options, nav);
+            try sema.maybeQueueFuncBodyAnalysis(block, src, export_nav);
+            break :target .{ .nav = export_nav };
         },
+    };
+    if (ptr_info.byte_offset != 0) {
+        return sema.fail(block, ptr_src, "TODO: export pointer in middle of value", .{});
     }
+    if (zcu.llvm_object != null and options.linkage == .internal) return;
+    try sema.exports.append(zcu.gpa, .{
+        .opts = options,
+        .src = src,
+        .exported = target,
+        .status = .in_progress,
+    });
 }
 
-pub fn analyzeExport(
+/// Asserts that `sema.owner` is a `.nav_val` whose value is resolved.
+///
+/// Exports that `Nav` by the given name with all other options set to default.
+pub fn analyzeExportSelfNav(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
-    options: Zcu.Export.Options,
-    orig_nav_index: InternPool.Nav.Index,
+    name: InternPool.NullTerminatedString,
 ) !void {
     const gpa = sema.gpa;
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
-    if (zcu.llvm_object != null and options.linkage == .internal)
-        return;
+    const orig_nav = sema.owner.unwrap().nav_val;
+    const export_val: Value = .fromInterned(ip.getNav(orig_nav).status.fully_resolved.val);
+    const export_ty = export_val.typeOf(zcu);
 
-    try sema.ensureNavResolved(block, src, orig_nav_index, .fully);
+    if (!export_ty.validateExtern(.other, zcu)) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
+            errdefer msg.destroy(gpa);
+            try sema.explainWhyTypeIsNotExtern(msg, src, export_ty, .other);
+            try sema.addDeclaredHereNote(msg, export_ty);
+            break :msg msg;
+        });
+    }
 
-    const exported_nav_index = switch (ip.indexToKey(ip.getNav(orig_nav_index).status.fully_resolved.val)) {
+    const export_nav = switch (ip.indexToKey(export_val.toIntern())) {
         .variable => |v| v.owner_nav,
         .@"extern" => |e| e.owner_nav,
-        .func => |f| f.owner_nav,
-        else => orig_nav_index,
+        .func => |f| export_nav: {
+            assert(export_ty.fnHasRuntimeBits(zcu)); // otherwise `validateExtern` failed above
+            const orig_fn_index = ip.unwrapCoercedFunc(export_val.toIntern());
+            try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_fn_index }));
+            try zcu.ensureFuncBodyAnalysisQueued(orig_fn_index);
+            break :export_nav f.owner_nav;
+        },
+        else => orig_nav,
     };
 
-    const exported_nav = ip.getNav(exported_nav_index);
-    const export_ty: Type = .fromInterned(exported_nav.typeOf(ip));
-
-    if (!export_ty.validateExtern(.other, zcu)) {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
-            errdefer msg.destroy(gpa);
-
-            try sema.explainWhyTypeIsNotExtern(msg, src, export_ty, .other);
-
-            try sema.addDeclaredHereNote(msg, export_ty);
-            break :msg msg;
-        });
-    }
-
-    // TODO: some backends might support re-exporting extern decls
-    if (exported_nav.getExtern(ip) != null) {
-        return sema.fail(block, src, "export target cannot be extern", .{});
-    }
-
-    try sema.maybeQueueFuncBodyAnalysis(block, src, exported_nav_index);
-
     try sema.exports.append(gpa, .{
-        .opts = options,
+        .opts = .{ .name = name },
         .src = src,
-        .exported = .{ .nav = exported_nav_index },
+        .exported = .{ .nav = export_nav },
         .status = .in_progress,
     });
 }
@@ -33739,21 +33742,9 @@ pub fn flushExports(sema: *Sema) !void {
     const zcu = sema.pt.zcu;
     const gpa = zcu.gpa;
 
-    // There may be existing exports. For instance, a struct may export
-    // things during both field type resolution and field default resolution.
-    //
-    // So, pick up and delete any existing exports. This strategy performs
-    // redundant work, but that's okay, because this case is exceedingly rare.
-    //
-    // MLUGG TODO: is this still possible? if not, delete this logic and combine deleteUnitExports into resetUnit
-    if (zcu.single_exports.get(sema.owner)) |export_idx| {
-        try sema.exports.append(gpa, export_idx.ptr(zcu).*);
-    } else if (zcu.multi_exports.get(sema.owner)) |info| {
-        try sema.exports.appendSlice(gpa, zcu.all_exports.items[info.index..][0..info.len]);
-    }
-    zcu.deleteUnitExports(sema.owner);
+    assert(!zcu.single_exports.contains(sema.owner));
+    assert(!zcu.multi_exports.contains(sema.owner));
 
-    // `sema.exports` is completed; store the data into the `Zcu`.
     if (sema.exports.items.len == 1) {
         try zcu.single_exports.ensureUnusedCapacity(gpa, 1);
         const export_idx: Zcu.Export.Index = zcu.free_exports.pop() orelse idx: {
@@ -34038,7 +34029,7 @@ fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Typ
     };
 }
 
-fn setTypeName(
+pub fn setTypeName(
     sema: *Sema,
     block: *Block,
     wip: *const InternPool.WipContainerType,
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index cf809603c03a177c4aefe40407b3b649a1921cff..06218806a44b24cf4433ed9b7738b27515a55154 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -125,89 +125,77 @@ fn lowerExprAnonResTy(self: *LowerZon, node: Zoir.Node.Index) CompileError!Inter
             return (try pt.aggregateValue(.fromInterned(ty), values)).toIntern();
         },
         .struct_literal => |init| {
-            if (true) @panic("MLUGG TODO");
             const elems = try self.sema.arena.alloc(InternPool.Index, init.names.len);
             for (0..init.names.len) |i| {
                 elems[i] = try self.lowerExprAnonResTy(init.vals.at(@intCast(i)));
             }
-            const struct_ty = switch (try ip.getStructType(
-                gpa,
-                io,
-                pt.tid,
-                .{
-                    .layout = .auto,
-                    .fields_len = @intCast(init.names.len),
-                    .known_non_opv = false,
-                    .requires_comptime = .no,
-                    .any_comptime_fields = true,
-                    .any_default_inits = true,
-                    .inits_resolved = true,
-                    .any_aligned_fields = false,
-                    .key = .{ .reified = .{
-                        .zir_index = self.base_node_inst,
-                        .type_hash = hash: {
-                            var hasher: std.hash.Wyhash = .init(0);
-                            hasher.update(std.mem.asBytes(&node));
-                            hasher.update(std.mem.sliceAsBytes(elems));
-                            hasher.update(std.mem.sliceAsBytes(init.names));
-                            break :hash hasher.final();
-                        },
-                    } },
+            const struct_ty: Type = switch (try ip.getReifiedStructType(gpa, io, pt.tid, .{
+                .zir_index = self.base_node_inst,
+                .type_hash = hash: {
+                    var hasher: std.hash.Wyhash = .init(0);
+                    hasher.update(std.mem.asBytes(&node));
+                    hasher.update(std.mem.sliceAsBytes(elems));
+                    hasher.update(std.mem.sliceAsBytes(init.names));
+                    break :hash hasher.final();
                 },
-                false,
-            )) {
+                .fields_len = @intCast(init.names.len),
+                .layout = .auto,
+                .any_comptime_fields = true,
+                .any_field_defaults = true,
+                .any_field_aligns = false,
+                .packed_backing_int_type = .none,
+            })) {
+                .existing => |ty| .fromInterned(ty),
                 .wip => |wip| ty: {
                     errdefer wip.cancel(ip, pt.tid);
-                    const type_name = try self.sema.createTypeName(
-                        self.block,
-                        .anon,
-                        "struct",
-                        self.base_node_inst.resolve(ip),
-                        wip.index,
-                    );
-                    wip.setName(ip, type_name.name, type_name.nav);
+                    const block = self.block;
+                    const zcu = pt.zcu;
+                    try self.sema.setTypeName(block, &wip, .anon, "struct", self.base_node_inst.resolve(ip).?);
 
-                    const struct_type = ip.loadStructType(wip.index);
-
-                    for (init.names, 0..) |name, field_idx| {
-                        const name_interned = try ip.getOrPutString(
+                    // Reified structs have field information populated immediately.
+                    @memcpy(wip.field_values.get(ip), elems);
+                    if (init.names.len > 0) {
+                        // All fields are comptime, but unused bits remain zeroed.
+                        const unused_bits = switch (init.names.len % 32) {
+                            0 => 0,
+                            else => |n| 32 - n,
+                        };
+                        const comptime_bits = wip.field_is_comptime_bits.getAll(ip);
+                        @memset(comptime_bits[0 .. comptime_bits.len - 1], std.math.maxInt(u32));
+                        comptime_bits[comptime_bits.len - 1] = @as(u32, std.math.maxInt(u32)) >> @intCast(unused_bits);
+                    }
+                    for (
+                        init.names,
+                        wip.field_names.get(ip),
+                        wip.field_types.get(ip),
+                        wip.field_values.get(ip),
+                    ) |zoir_name, *field_name, *field_ty, field_val| {
+                        field_name.* = try ip.getOrPutString(
                             gpa,
                             io,
                             pt.tid,
-                            name.get(self.file.zoir.?),
+                            zoir_name.get(self.file.zoir.?),
                             .no_embedded_nulls,
                         );
-                        assert(struct_type.addFieldName(ip, name_interned) == null);
-                        struct_type.setFieldComptime(ip, field_idx);
-                    }
-
-                    @memcpy(struct_type.field_inits.get(ip), elems);
-                    const types = struct_type.field_types.get(ip);
-                    for (0..init.names.len) |i| {
-                        types[i] = Value.fromInterned(elems[i]).typeOf(pt.zcu).toIntern();
+                        field_ty.* = ip.typeOf(field_val);
                     }
 
                     const new_namespace_index = try pt.createNamespace(.{
-                        .parent = self.block.namespace.toOptional(),
+                        .parent = block.namespace.toOptional(),
                         .owner_type = wip.index,
-                        .file_scope = self.block.getFileScopeIndex(pt.zcu),
-                        .generation = pt.zcu.generation,
+                        .file_scope = block.getFileScopeIndex(zcu),
+                        .generation = zcu.generation,
                     });
-                    try pt.zcu.comp.queueJob(.{ .resolve_type_fully = wip.index });
-                    codegen_type: {
-                        if (pt.zcu.comp.config.use_llvm) break :codegen_type;
-                        if (self.block.ownerModule().strip) break :codegen_type;
-                        pt.zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-                        try pt.zcu.comp.queueJob(.{ .link_type = wip.index });
-                    }
-                    break :ty wip.finish(ip, new_namespace_index);
+                    errdefer pt.destroyNamespace(new_namespace_index);
+                    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newType(zcu, wip.index);
+                    break :ty .fromInterned(wip.finish(ip, new_namespace_index));
                 },
-                .existing => |ty| ty,
             };
-            try self.sema.declareDependency(.{ .interned = struct_ty });
             try self.sema.addTypeReferenceEntry(self.nodeSrc(node), struct_ty);
+            // No need for `ensureNamespaceUpToDate` because this type's namespace is always empty.
+            try self.sema.ensureLayoutResolved(struct_ty, self.nodeSrc(node), .init);
 
-            return (try pt.aggregateValue(.fromInterned(struct_ty), elems)).toIntern();
+            return (try pt.aggregateValue(struct_ty, elems)).toIntern();
         },
     }
 }
diff --git a/src/Value.zig b/src/Value.zig
index 5cc20853da7634efc3b0925d77fa01ab65c1e9a7..cf8d0acc67377b3a871fe15cbd55cac4d0ef7221 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -1954,7 +1954,6 @@ pub const PointerDeriveStep = union(enum) {
 /// which prefer field/elem accesses when lowering constant pointer values.
 /// It is also used by the Value printing logic for pointers.
 pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, opt_sema: ?*Sema) Allocator.Error!PointerDeriveStep {
-    // MLUGG TODO: audit tf outta this code
     const zcu = pt.zcu;
     const ptr = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
     const base_derive: PointerDeriveStep = switch (ptr.base_addr) {
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 49abdbed5607582a4a33d40642edd762baaab5bb..ce90f2c417abc94c2b146c922f907c2b17a69e24 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -3518,50 +3518,10 @@ pub const ImportResult = struct {
     module: ?*Package.Module,
 };
 
-/// Delete all the Export objects that are caused by this `AnalUnit`. Re-analysis of
-/// this `AnalUnit` will cause them to be re-created (or not).
-pub fn deleteUnitExports(zcu: *Zcu, anal_unit: AnalUnit) void {
-    const gpa = zcu.gpa;
-
-    const exports_base, const exports_len = if (zcu.single_exports.fetchSwapRemove(anal_unit)) |kv|
-        .{ @intFromEnum(kv.value), 1 }
-    else if (zcu.multi_exports.fetchSwapRemove(anal_unit)) |info|
-        .{ info.value.index, info.value.len }
-    else
-        return;
-
-    const exports = zcu.all_exports.items[exports_base..][0..exports_len];
-
-    // In an only-c build, we're guaranteed to never use incremental compilation, so there are
-    // guaranteed not to be any exports in the output file that need deleting (since we only call
-    // `updateExports` on flush).
-    // This case is needed because in some rare edge cases, `Sema` wants to add and delete exports
-    // within a single update.
-    if (dev.env.supports(.incremental)) {
-        for (exports, exports_base..) |exp, export_index_usize| {
-            const export_idx: Export.Index = @enumFromInt(export_index_usize);
-            if (zcu.comp.bin_file) |lf| {
-                lf.deleteExport(exp.exported, exp.opts.name);
-            }
-            if (zcu.failed_exports.fetchSwapRemove(export_idx)) |failed_kv| {
-                failed_kv.value.destroy(gpa);
-            }
-        }
-    }
-
-    zcu.free_exports.ensureUnusedCapacity(gpa, exports_len) catch {
-        // This space will be reused eventually, so we need not propagate this error.
-        // Just leak it for now, and let GC reclaim it later on.
-        return;
-    };
-    for (exports_base..exports_base + exports_len) |export_idx| {
-        zcu.free_exports.appendAssumeCapacity(@enumFromInt(export_idx));
-    }
-}
-
 /// Prepares `unit` for re-analysis by clearing all of the following state:
 /// * Compile errors associated with `unit`
 /// * Compile logs associated with `unit`
+/// * Exports performed by `unit`
 /// * Dependencies from `unit` on other things
 /// * References from `unit` to other units
 /// Delete all references in `reference_table` which are caused by `unit`, and all dependencies it
@@ -3593,6 +3553,36 @@ pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void {
         }
     }
 
+    // Exports
+    exports: {
+        const base: u32, const len: u32 = index: {
+            if (zcu.single_exports.fetchSwapRemove(unit)) |kv| {
+                break :index .{ @intFromEnum(kv.value), 1 };
+            }
+            if (zcu.multi_exports.fetchSwapRemove(unit)) |kv| {
+                break :index .{ kv.value.index, kv.value.len };
+            }
+            break :exports;
+        };
+        for (zcu.all_exports.items[base..][0..len], base..) |exp, exp_index_usize| {
+            const exp_index: Export.Index = @enumFromInt(exp_index_usize);
+            if (zcu.comp.bin_file) |lf| {
+                lf.deleteExport(exp.exported, exp.opts.name);
+            }
+            if (zcu.failed_exports.fetchSwapRemove(exp_index)) |failed_kv| {
+                failed_kv.value.destroy(gpa);
+            }
+        }
+        zcu.free_exports.ensureUnusedCapacity(gpa, len) catch {
+            // This space will be reused eventually, so we need not propagate this error.
+            // Just leak it for now, and let GC reclaim it later on.
+            break :exports;
+        };
+        for (base..base + len) |exp_index| {
+            zcu.free_exports.appendAssumeCapacity(@enumFromInt(exp_index));
+        }
+    }
+
     // Dependencies
     zcu.intern_pool.removeDependenciesForDepender(gpa, unit);
 
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 954d1cd3bff44529db52325785eb7aa7d1c1f0d2..b9ad8f3dfdd1375df0606f538d6ecdeb72abec82 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -752,7 +752,6 @@ pub fn ensureMemoizedStateUpToDate(
     if (was_outdated) {
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(unit);
-        // No need for `deleteUnitExports` because we never export anything.
         zcu.resetUnit(unit);
     } else {
         if (prev_failed) return error.AnalysisFail;
@@ -874,7 +873,6 @@ pub fn ensureComptimeUnitUpToDate(pt: Zcu.PerThread, cu_id: InternPool.ComptimeU
         _ = zcu.outdated_ready.swapRemove(anal_unit);
         // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
-            zcu.deleteUnitExports(anal_unit);
             zcu.resetUnit(anal_unit);
         }
     } else {
@@ -1033,7 +1031,6 @@ pub fn ensureTypeLayoutUpToDate(
         _ = zcu.outdated_ready.swapRemove(anal_unit);
         // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
-            zcu.deleteUnitExports(anal_unit);
             zcu.resetUnit(anal_unit);
         }
         // For types, we already know that we have to invalidate all dependees.
@@ -1151,7 +1148,6 @@ pub fn ensureNavValUpToDate(
     if (was_outdated) {
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(anal_unit);
-        zcu.deleteUnitExports(anal_unit);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
@@ -1238,7 +1234,7 @@ fn analyzeNavVal(
     const zir_decl = zir.getDeclaration(inst_resolved.inst);
 
     try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, reason);
-    errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);
+    defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
     var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
     defer analysis_arena.deinit();
@@ -1443,15 +1439,11 @@ fn analyzeNavVal(
         .@"addrspace" = modifiers.@"addrspace",
     });
 
-    // Mark the unit as completed before evaluating the export!
-    // MLUGG TODO: do we really need to do this?
-    assert(zcu.analysis_in_progress.swapRemove(anal_unit));
-
     if (zir_decl.linkage == .@"export") {
         const export_src = block.src(.{ .token_offset = @enumFromInt(@intFromBool(zir_decl.is_pub)) });
         const name_slice = zir.nullTerminatedString(zir_decl.name);
         const name_ip = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls);
-        try sema.analyzeExport(&block, export_src, .{ .name = name_ip }, nav_id);
+        try sema.analyzeExportSelfNav(&block, export_src, name_ip);
     }
 
     try sema.flushExports();
@@ -1514,7 +1506,6 @@ pub fn ensureNavTypeUpToDate(
     if (was_outdated) {
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(anal_unit);
-        zcu.deleteUnitExports(anal_unit);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
@@ -1751,7 +1742,6 @@ pub fn ensureFuncBodyUpToDate(
     if (was_outdated) {
         dev.check(.incremental);
         _ = zcu.outdated_ready.swapRemove(anal_unit);
-        zcu.deleteUnitExports(anal_unit);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this function.
-- 
2.54.0


From 4e92592fee6b414757b2e6c088e20ca9a1b21f44 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 13:10:21 +0000
Subject: [PATCH 432/499] compiler: error set bugfixes

---
 src/Sema.zig | 117 ++++++++++++++++++++++++++++++++++++++-------------
 src/Type.zig |  63 +++++++++++++++------------
 2 files changed, 124 insertions(+), 56 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 0504bb7e5e251d656e2daf1f0e016d098a80e520..b0271ffde091e2cfe9c5b442d244e15ae76b020b 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -15629,10 +15629,10 @@ fn zirCmpEq(
 
     // comparing null with optionals
     if (lhs_ty_tag == .null and (rhs_ty_tag == .optional or rhs_ty.isCPtr(zcu))) {
-        return sema.analyzeIsNull(block, rhs, op == .neq);
+        return sema.analyzeIsNull(block, src, rhs, op == .neq);
     }
     if (rhs_ty_tag == .null and (lhs_ty_tag == .optional or lhs_ty.isCPtr(zcu))) {
-        return sema.analyzeIsNull(block, lhs, op == .neq);
+        return sema.analyzeIsNull(block, src, lhs, op == .neq);
     }
 
     if (lhs_ty_tag == .null or rhs_ty_tag == .null) {
@@ -17375,7 +17375,7 @@ fn zirIsNonNull(
     const src = block.nodeOffset(inst_data.src_node);
     const operand = sema.resolveInst(inst_data.operand);
     try sema.checkNullableType(block, src, sema.typeOf(operand));
-    return sema.analyzeIsNull(block, operand, true);
+    return sema.analyzeIsNull(block, src, operand, true);
 }
 
 fn zirIsNonNullPtr(
@@ -17394,15 +17394,19 @@ fn zirIsNonNullPtr(
     const ptr_ty = sema.typeOf(ptr);
     assert(ptr_ty.zigTypeTag(zcu) == .pointer);
     const nullable_ty = ptr_ty.childType(zcu);
+
     try sema.checkNullableType(block, src, nullable_ty);
+
+    if (try sema.resolveIsNullFromType(block, src, nullable_ty)) |is_null| {
+        return .fromValue(.makeBool(!is_null));
+    }
+
     if (sema.resolveValue(ptr)) |ptr_val| {
         if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |nullable_val| {
-            return sema.analyzeIsNull(block, .fromValue(nullable_val), true);
+            return sema.analyzeIsNull(block, src, .fromValue(nullable_val), true);
         }
     }
-    if (nullable_ty.isNullFromType(zcu)) |is_null| {
-        return if (is_null) .bool_false else .bool_true;
-    }
+
     return block.addUnOp(.is_non_null_ptr, ptr);
 }
 
@@ -30147,25 +30151,25 @@ fn analyzeSliceLen(
 fn analyzeIsNull(
     sema: *Sema,
     block: *Block,
+    src: LazySrcLoc,
     operand: Air.Inst.Ref,
     invert_logic: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const result_ty: Type = .bool;
+
+    if (try sema.resolveIsNullFromType(block, src, sema.typeOf(operand))) |is_null| {
+        return .fromValue(.makeBool(is_null != invert_logic)); // XOR
+    }
+
     if (sema.resolveValue(operand)) |opt_val| {
         if (opt_val.isUndef(zcu)) {
-            return pt.undefRef(result_ty);
+            return pt.undefRef(.bool);
         }
         const is_null = opt_val.isNull(zcu);
-        const bool_value = if (invert_logic) !is_null else is_null;
-        return if (bool_value) .bool_true else .bool_false;
+        return .fromValue(.makeBool(is_null != invert_logic)); // XOR
     }
 
-    if (sema.typeOf(operand).isNullFromType(zcu)) |is_null| {
-        const result = is_null != invert_logic;
-        return if (result) .bool_true else .bool_false;
-    }
     const air_tag: Air.Inst.Tag = if (invert_logic) .is_non_null else .is_null;
     return block.addUnOp(air_tag, operand);
 }
@@ -30218,6 +30222,35 @@ fn resolveIsNonErrVal(
     return null;
 }
 
+fn resolveIsNullFromType(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    ty: Type,
+) CompileError!?bool {
+    const zcu = sema.pt.zcu;
+    return switch (ty.zigTypeTag(zcu)) {
+        else => false,
+        .null => true,
+        .pointer => switch (ty.ptrSize(zcu)) {
+            .c => null,
+            else => false,
+        },
+        .optional => {
+            const payload_ty = ty.optionalChild(zcu);
+            if (payload_ty.classify(zcu) == .no_possible_value) {
+                return true; // e.g. `?noreturn`
+            }
+            if (payload_ty.zigTypeTag(zcu) == .error_set and
+                try sema.resolveErrSetIsEmpty(block, src, payload_ty))
+            {
+                return true; // e.g. `?error{}`
+            }
+            return null;
+        },
+    };
+}
+
 fn resolveIsNonErrFromType(
     sema: *Sema,
     block: *Block,
@@ -30226,7 +30259,6 @@ fn resolveIsNonErrFromType(
 ) CompileError!?Value {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
     const ot = operand_ty.zigTypeTag(zcu);
     if (ot != .error_set and ot != .error_union) return .true;
     if (ot == .error_set) return .false;
@@ -30236,29 +30268,54 @@ fn resolveIsNonErrFromType(
     if (payload_ty.classify(zcu) == .no_possible_value) {
         return .false;
     }
+    if (try sema.resolveErrSetIsEmpty(block, src, operand_ty.errorUnionSet(zcu))) {
+        return .true;
+    }
+    return null;
+}
 
-    // exception if the error union error set is known to be empty,
-    // we allow the comparison but always make it comptime-known.
-    return err_set: switch (ip.errorUnionSet(operand_ty.toIntern())) {
-        .anyerror_type => null,
+/// Returns `true` iff the error set type `orig_err_set_ty` contains no errors.
+///
+/// This is used to give comptime answers for whether `error{}!T` is an error or a payload, as well
+/// as whether `?error{}` is null. The type `error{}` cannot be NPV, as it has runtime bits, but the
+/// only value of that type which can exist is `undefined`; semantically it has no "legal" value.
+/// TODO: this runs into some unsolved language design questions about such types. Performing a
+/// coercion from `@as(E, undefined)` to `E!T` needs to semantically result in an `undefined` error
+/// union if our implementation is to be legal, and likewise for coercing `@as(E, undefined)` to
+/// `?E` (for an error set `E`) because our implementation uses the zero error value at runtime to
+/// represent `null`. The unsolved problem is the exact rules for `undefined` propagation through
+/// these types: for instance, what if `@as(u32, undfined)` is coerced to `?u32`? What about error
+/// union *payloads*, i.e. `@as(u32, undefined)` to `E!u32`? That one is analagous to the optional
+/// example in some ways, but right now I believe there is code which relies on that coercion giving
+/// a well-defined error union with an `undefined` payload.
+/// Relevant issues/discussions:
+/// * https://github.com/ziglang/zig/issues/1831
+/// * https://github.com/ziglang/zig/issues/6762
+/// * https://github.com/ziglang/zig/issues/1831#issuecomment-722129239
+fn resolveErrSetIsEmpty(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    orig_err_set_ty: Type,
+) CompileError!bool {
+    const ip = &sema.pt.zcu.intern_pool;
+    err_set: switch (orig_err_set_ty.toIntern()) {
+        .anyerror_type => return false,
         .adhoc_inferred_error_set_type => {
             // This is *our* error set; that is, we're currently analyzing the function
             // which owns it. Trying to resolve it now would cause a dependency loop.
             // Instead, accept that we don't know.
-            return null;
+            return false;
         },
-        else => |set_ty| switch (ip.indexToKey(set_ty)) {
-            .error_set_type => |error_set_type| switch (error_set_type.names.len) {
-                0 => .true,
-                else => null,
-            },
+        else => |err_set_ty| switch (ip.indexToKey(err_set_ty)) {
+            .error_set_type => |es| return es.names.len == 0,
             .inferred_error_set_type => |func_index| {
                 if (sema.fn_ret_ty_ies) |ies| {
                     if (ies.func == func_index) {
                         // This is *our* error set; that is, we're currently analyzing the function
                         // which owns it. Trying to resolve it now would cause a dependency loop.
                         // Instead, accept that we don't know.
-                        return null;
+                        return false;
                     }
                 }
                 try sema.ensureFuncIesResolved(block, src, func_index);
@@ -30266,7 +30323,7 @@ fn resolveIsNonErrFromType(
             },
             else => unreachable,
         },
-    };
+    }
 }
 
 fn analyzeIsNonErr(
@@ -30732,7 +30789,7 @@ fn analyzeSlice(
             if (block.wantSafety()) {
                 // requirement: slicing C ptr is non-null
                 if (ptr_ptr_child_ty.isCPtr(zcu)) {
-                    const is_non_null = try sema.analyzeIsNull(block, ptr, true);
+                    const is_non_null = try block.addUnOp(.is_non_null, ptr);
                     try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null);
                 }
 
@@ -30792,7 +30849,7 @@ fn analyzeSlice(
     if (block.wantSafety()) {
         // requirement: slicing C ptr is non-null
         if (ptr_ptr_child_ty.isCPtr(zcu)) {
-            const is_non_null = try sema.analyzeIsNull(block, ptr, true);
+            const is_non_null = try block.addUnOp(.is_non_null, ptr);
             try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null);
         }
 
diff --git a/src/Type.zig b/src/Type.zig
index 81ee1e560e6505eb6721b13b6fbdd2338e1694e0..3eb14f3b533c2fe9f2e30e312b473e9b4719b6f4 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -661,15 +661,28 @@ pub fn toValue(self: Type) Value {
     return .fromInterned(self.toIntern());
 }
 
-/// true if and only if the type takes up space in memory at runtime.
-/// There are two reasons a type will return false:
-/// * the type is a comptime-only type. For example, the type `type` itself.
-///   - note, however, that a struct can have mixed fields and only the non-comptime-only
-///     fields will count towards the ABI size. For example, `struct {T: type, x: i32}`
-///     hasRuntimeBits()=true and abiSize()=4
-/// * the type has only one possible value, making its ABI size 0.
-///   - an enum with an explicit tag type has the ABI size of the integer tag type,
-///     making it one-possible-value only if the integer tag type has 0 bits.
+/// Returns `true` if and only if the type takes up space in memory at runtime. This is also exactly
+/// whether or not the backend/linker needs to be sent values of this type to emit to the binary.
+///
+/// Types without runtime bits have an ABI size of 0; all other types have a non-zero ABI size. All
+/// types, regardless of whether they have runtime bits, have a non-zero ABI alignment.
+///
+/// Comptime-only types may still have runtime bits. For instance, `struct { a: u32, b: type }` is a
+/// comptime-only type, but it nonetheless has runtime bits and a runtime memory layout (where the
+/// field `b: type` is omitted). This is because a user may take a pointer to the field `a`, which
+/// must then be valid to use at runtime.
+///
+/// This function is a trivial wrapper around `classify`:
+///
+/// * Types with one possible value, such as `void`, or no possible value, such as `noreturn`, do
+///   not have runtime bits and have an ABI size of 0 because they simply contain no state.
+///
+/// * Types which are fully comptime, such as `type` and `comptime_int`, do not have runtime bits
+///   because they contain only comptime state. (This compiler implementation also currently makes
+///   types like `struct { x: comptime_int }` fully comptime, but that could change in the future if
+///   we start inserting hidden safety fields into them.)
+///
+/// * All other types contain some runtime state, so have runtime bits and a non-zero ABI size.
 pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
     return switch (ty.classify(zcu)) {
         .no_possible_value, .one_possible_value, .fully_comptime => false,
@@ -1576,6 +1589,11 @@ pub fn errorUnionSet(ty: Type, zcu: *const Zcu) Type {
 }
 
 /// Returns false for unresolved inferred error sets.
+///
+/// TODO: this function will behave incorrectly under incremental compilation, because in that case
+/// it may see an outdated resolved error set. This function must be either deleted, or its contract
+/// changed to require the caller to resolve the error set beforehand. If you must introduce new
+/// call sites, please make sure the error set in question is definitely resolved first!
 pub fn errorSetIsEmpty(ty: Type, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
     return switch (ty.toIntern()) {
@@ -1594,6 +1612,11 @@ pub fn errorSetIsEmpty(ty: Type, zcu: *const Zcu) bool {
 /// Returns true if it is an error set that includes anyerror, false otherwise.
 /// Note that the result may be a false negative if the type did not get error set
 /// resolution prior to this call.
+///
+/// TODO: this function will behave incorrectly under incremental compilation, because in that case
+/// it may see an outdated resolved error set. This function must be either deleted, or its contract
+/// changed to require the caller to resolve the error set beforehand. If you must introduce new
+/// call sites, please make sure the error set in question is definitely resolved first!
 pub fn isAnyError(ty: Type, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
     return switch (ty.toIntern()) {
@@ -1616,6 +1639,11 @@ pub fn isError(ty: Type, zcu: *const Zcu) bool {
 /// Returns whether ty, which must be an error set, includes an error `name`.
 /// Might return a false negative if `ty` is an inferred error set and not fully
 /// resolved yet.
+///
+/// TODO: this function will behave incorrectly under incremental compilation, because in that case
+/// it may see an outdated resolved error set. This function must be either deleted, or its contract
+/// changed to require the caller to resolve the error set beforehand. If you must introduce new
+/// call sites, please make sure the error set in question is definitely resolved first!
 pub fn errorSetHasField(
     ty: Type,
     name: InternPool.NullTerminatedString,
@@ -2939,23 +2967,6 @@ pub fn containerTypeName(ty: Type, ip: *const InternPool) InternPool.NullTermina
     };
 }
 
-/// Returns `true` if a value of this type is always `null`.
-/// Returns `false` if a value of this type is never `null`.
-/// Returns `null` otherwise.
-pub fn isNullFromType(ty: Type, zcu: *const Zcu) ?bool {
-    if (ty.zigTypeTag(zcu) != .optional and !ty.isCPtr(zcu)) return false;
-    const payload_ty = ty.optionalChild(zcu);
-    if (payload_ty.classify(zcu) == .no_possible_value) return true; // `?noreturn` etc
-
-    // Although it has runtime bits, `?error{}` is always null. MLUGG TODO: think for a bit...
-    switch (zcu.intern_pool.indexToKey(payload_ty.toIntern())) {
-        .error_set_type => |error_set| if (error_set.names.len == 0) return true,
-        else => {},
-    }
-
-    return null;
-}
-
 pub const UnpackableReason = union(enum) {
     comptime_only,
     pointer,
-- 
2.54.0


From 96d6b22067cccd644190e9b63f8f5bc13b6e93db Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 13:24:03 +0000
Subject: [PATCH 433/499] tests: update for accepted language change

'comptime_int' is no longer considered a valid backing type for an enum.
In other words, 'enum(comptime_int)' is a compile error. This change is
accepted to simplify the language.
---
 test/behavior/enum.zig                        | 16 ---------
 test/behavior/union.zig                       | 35 +++++++------------
 .../enum_backed_by_comptime_int.zig           |  8 +++++
 ...int_must_be_casted_from_comptime_value.zig | 12 -------
 ...acked_by_comptime_int_must_be_comptime.zig |  9 -----
 ..._backed_by_enum_backed_by_comptime_int.zig |  9 +++++
 6 files changed, 29 insertions(+), 60 deletions(-)
 create mode 100644 test/cases/compile_errors/enum_backed_by_comptime_int.zig
 delete mode 100644 test/cases/compile_errors/enum_backed_by_comptime_int_must_be_casted_from_comptime_value.zig
 delete mode 100644 test/cases/compile_errors/enum_backed_by_comptime_int_must_be_comptime.zig
 create mode 100644 test/cases/compile_errors/union_backed_by_enum_backed_by_comptime_int.zig

diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index d49b27d4d41841bc40b5b8bd61fff45ebc709942..a222bd605143b3de2ca5ca9f1c4f93d3760c3173 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -823,15 +823,6 @@ test "enum with one member and u1 tag type @intFromEnum" {
     try expect(@intFromEnum(Enum.Test) == 0);
 }
 
-test "enum with comptime_int tag type" {
-    const Enum = enum(comptime_int) {
-        One = 3,
-        Two = 2,
-        Three = 1,
-    };
-    comptime assert(Tag(Enum) == comptime_int);
-}
-
 test "enum with one member default to u0 tag type" {
     const E0 = enum { X };
     comptime assert(Tag(E0) == u0);
@@ -1274,13 +1265,6 @@ fn getLazyInitialized(param: enum(u8) {
     return @intFromEnum(param);
 }
 
-test "Non-exhaustive enum backed by comptime_int" {
-    const E = enum(comptime_int) { a, b, c, _ };
-    comptime var e: E = .a;
-    e = @as(E, @enumFromInt(378089457309184723749));
-    try expect(@intFromEnum(e) == 378089457309184723749);
-}
-
 test "matching captures causes enum equivalence" {
     const S = struct {
         fn Nonexhaustive(comptime I: type) type {
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index a9e950a255cc6036e75e6d6df584756b537b0ac9..a7b7c20a361d192a034363cc64a06ecc1f2b572a 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -703,25 +703,23 @@ test "union with only 1 field casted to its enum type which has enum value speci
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const Literal = union(enum) {
-        Number: f64,
-        Bool: bool,
+        number: f64,
+        bool: bool,
     };
 
-    const ExprTag = enum(comptime_int) {
-        Literal = 33,
-    };
+    const ExprTag = enum(u32) { literal = 33 };
+    const Expr = union(ExprTag) { literal: Literal };
 
-    const Expr = union(ExprTag) {
-        Literal: Literal,
-    };
+    comptime assert(Tag(ExprTag) == u32);
+
+    var e: Expr = undefined;
+    e = .{ .literal = .{ .bool = true } };
 
-    var e = Expr{ .Literal = Literal{ .Bool = true } };
-    _ = &e;
-    comptime assert(Tag(ExprTag) == comptime_int);
-    const t = comptime @as(ExprTag, e);
-    try expect(t == Expr.Literal);
-    try expect(@intFromEnum(t) == 33);
+    const t: ExprTag = e;
+    comptime assert(t == Expr.literal);
     comptime assert(@intFromEnum(t) == 33);
+    try expect(t == Expr.literal);
+    try expect(@intFromEnum(t) == 33);
 }
 
 test "@intFromEnum works on unions" {
@@ -893,15 +891,6 @@ test "union no tag with struct member" {
     u.foo();
 }
 
-test "union with comptime_int tag" {
-    const Union = union(enum(comptime_int)) {
-        X: u32,
-        Y: u16,
-        Z: u8,
-    };
-    comptime assert(Tag(Tag(Union)) == comptime_int);
-}
-
 test "extern union doesn't trigger field check at comptime" {
     const U = extern union {
         x: u32,
diff --git a/test/cases/compile_errors/enum_backed_by_comptime_int.zig b/test/cases/compile_errors/enum_backed_by_comptime_int.zig
new file mode 100644
index 0000000000000000000000000000000000000000..069e36ecc4b6d321fd5f621e8875199b389be711
--- /dev/null
+++ b/test/cases/compile_errors/enum_backed_by_comptime_int.zig
@@ -0,0 +1,8 @@
+const E = enum(comptime_int) { a };
+comptime {
+    _ = E.a;
+}
+
+// error
+//
+// :1:16: error: expected integer tag type, found 'comptime_int'
diff --git a/test/cases/compile_errors/enum_backed_by_comptime_int_must_be_casted_from_comptime_value.zig b/test/cases/compile_errors/enum_backed_by_comptime_int_must_be_casted_from_comptime_value.zig
deleted file mode 100644
index a4ce1680ffd32acf2e0edde87dab93378099f57a..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/enum_backed_by_comptime_int_must_be_casted_from_comptime_value.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    const Tag = enum(comptime_int) { a, b };
-
-    var v: u32 = 0;
-    _ = &v;
-    _ = @as(Tag, @enumFromInt(v));
-}
-
-// error
-//
-// :6:31: error: unable to resolve comptime value
-// :6:31: note: value casted to enum with 'comptime_int' tag type must be comptime-known
diff --git a/test/cases/compile_errors/enum_backed_by_comptime_int_must_be_comptime.zig b/test/cases/compile_errors/enum_backed_by_comptime_int_must_be_comptime.zig
deleted file mode 100644
index 6f55e8c2779e5312647910553e4ffbadb8454c3c..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/enum_backed_by_comptime_int_must_be_comptime.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub export fn entry() void {
-    const E = enum(comptime_int) { a, b, c, _ };
-    var e: E = .a;
-    _ = &e;
-}
-
-// error
-//
-// :3:12: error: variable of type 'tmp.entry.E' must be const or comptime
diff --git a/test/cases/compile_errors/union_backed_by_enum_backed_by_comptime_int.zig b/test/cases/compile_errors/union_backed_by_enum_backed_by_comptime_int.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7217c65b59f2d96922705af883ccb0623aea98e0
--- /dev/null
+++ b/test/cases/compile_errors/union_backed_by_enum_backed_by_comptime_int.zig
@@ -0,0 +1,9 @@
+const U = union(enum(comptime_int)) { a: u32 };
+comptime {
+    const u: U = .{ .a = 123 };
+    _ = u;
+}
+
+// error
+//
+// :1:22: error: expected integer tag type, found 'comptime_int'
-- 
2.54.0


From 5c41b6db87702017791b824ec9d76d5da00c354b Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 13:56:01 +0000
Subject: [PATCH 434/499] Sema: disallow empty extern/packed unions

These types don't really make much sense: you can't pack together bits
of a type which cannot exist, nor can you pass it over an ABI boundary.
---
 src/Sema/type_resolution.zig | 28 ++++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 07349457a44ee78f7435e9609833b9e588bf1248..adc787136f93d6e69cce6464926369def5de3388 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -347,6 +347,12 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         }
     };
 
+    switch (struct_obj.layout) {
+        .auto => {},
+        .@"extern" => assert(class != .no_possible_value), // field types are all extern, so are not NPV
+        .@"packed" => unreachable,
+    }
+
     if (struct_obj.layout == .auto) {
         const runtime_order = struct_obj.field_runtime_order.get(ip);
         // This logic does not reorder fields; it only moves the omitted ones to the end so that logic
@@ -451,7 +457,12 @@ fn resolvePackedStructLayout(
             try sema.addDeclaredHereNote(msg, field_ty);
             break :msg msg;
         });
-        assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
+        switch (field_ty.classify(zcu)) {
+            .one_possible_value, .runtime => {},
+            .no_possible_value => unreachable, // packable types are not NPV
+            .partially_comptime => unreachable, // packable types are not comptime-only
+            .fully_comptime => unreachable, // packable types are not comptime-only
+        }
         field_bits += field_ty.bitSize(zcu);
     }
 
@@ -749,6 +760,13 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
         }
     }
 
+    // Uninstantiable `extern union`s don't make sense; disallow them.
+    if (possible_tags == 0 and union_obj.layout != .auto) {
+        // Field types are all extern, so not NPV; thus zero possible tags means no tags at all.
+        assert(union_obj.field_types.len == 0);
+        return sema.fail(&block, union_ty.srcLoc(zcu), "extern union has no fields", .{});
+    }
+
     // We only need a runtime tag if there are multiple possible active fields *and* the union is
     // not going to be comptime-only. Even if there are still runtime bits in the payload, the tag
     // does not require runtime bits in a comptime-only union, because it is impossible to get a
@@ -874,6 +892,11 @@ fn resolvePackedUnionLayout(
     const gpa = comp.gpa;
     const ip = &zcu.intern_pool;
 
+    // Uninstantiable `packed union`s don't make sense; disallow them.
+    if (union_obj.field_types.len == 0) {
+        return sema.fail(block, union_ty.srcLoc(zcu), "packed union has no fields", .{});
+    }
+
     // Resolve the layout of all fields, and check their types are allowed.
     for (union_obj.field_types.get(ip), 0..) |field_ty_ip, field_index| {
         const field_ty: Type = .fromInterned(field_ty_ip);
@@ -937,9 +960,6 @@ fn resolvePackedUnionLayout(
             });
         }
         break :ty backing_ty;
-    } else if (union_obj.field_types.len == 0) ty: {
-        // Special case: there is no first field to infer the type from. Treat the union as empty (zero-bit).
-        break :ty .u0;
     } else ty: {
         const field_types = union_obj.field_types.get(ip);
         const first_field_type: Type = .fromInterned(field_types[0]);
-- 
2.54.0


From ffc5242169d67840e0d1420b792696fc1b3d1722 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:04:51 +0000
Subject: [PATCH 435/499] Sema: small NPV fixes

---
 src/Sema.zig | 12 +-----------
 src/Type.zig | 24 +++++++++++++++++++++---
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index b0271ffde091e2cfe9c5b442d244e15ae76b020b..140e69fe6ffe1e3e16e4cf6176a8ff48bf89000d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -19400,7 +19400,7 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
     try sema.ensureLayoutResolved(ty, operand_src, .align_of);
     if (ty.isNoReturn(zcu)) {
-        return sema.fail(block, operand_src, "no align available for type '{f}'", .{ty.fmt(sema.pt)});
+        return sema.fail(block, operand_src, "no align available for uninstantiable type '{f}'", .{ty.fmt(sema.pt)});
     }
     return .fromValue(try pt.intValue(.comptime_int, ty.abiAlignment(zcu).toByteUnits().?));
 }
@@ -33432,16 +33432,6 @@ fn errorSetMerge(sema: *Sema, lhs: Type, rhs: Type) !Type {
     return pt.errorSetFromUnsortedNames(names.keys());
 }
 
-/// Avoids crashing the compiler when asking if inferred allocations are noreturn.
-fn isNoReturn(sema: *Sema, ref: Air.Inst.Ref) bool {
-    if (ref == .unreachable_value) return true;
-    if (ref.toIndex()) |inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(inst)]) {
-        .inferred_alloc, .inferred_alloc_comptime => return false,
-        else => {},
-    };
-    return sema.typeOf(ref).isNoReturn(sema.pt.zcu);
-}
-
 pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {
     const pt = sema.pt;
     if (!pt.zcu.comp.config.incremental) return;
diff --git a/src/Type.zig b/src/Type.zig
index 3eb14f3b533c2fe9f2e30e312b473e9b4719b6f4..234850376558acefd34b85a0ed43285945c6f60d 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -790,11 +790,21 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
 /// function with this type can exist at runtime.
 /// Asserts that `ty` is a function type.
 pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *Zcu) bool {
+    assertHasLayout(fn_ty, zcu);
     const fn_info = zcu.typeToFunc(fn_ty).?;
     if (fn_info.comptime_bits != 0) return false;
     for (fn_info.param_types.get(&zcu.intern_pool)) |param_ty| {
         if (param_ty == .generic_poison_type) return false;
-        if (Type.fromInterned(param_ty).comptimeOnly(zcu)) return false;
+        switch (Type.fromInterned(param_ty).classify(zcu)) {
+            .fully_comptime,
+            .partially_comptime,
+            .no_possible_value,
+            => return false,
+
+            .one_possible_value,
+            .runtime,
+            => {},
+        }
     }
     const ret_ty: Type = .fromInterned(fn_info.return_type);
     if (ret_ty.toIntern() == .generic_poison_type) {
@@ -805,8 +815,16 @@ pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *Zcu) bool {
     {
         return false;
     }
-    if (fn_info.return_type == .generic_poison_type) return false;
-    if (Type.fromInterned(fn_info.return_type).comptimeOnly(zcu)) return false;
+    switch (ret_ty.classify(zcu)) {
+        .fully_comptime,
+        .partially_comptime,
+        => return false,
+
+        .no_possible_value,
+        .one_possible_value,
+        .runtime,
+        => {},
+    }
     if (fn_info.cc == .@"inline") return false;
     return true;
 }
-- 
2.54.0


From 4f7344dec0bc61916f0c9af99bc5b5e5b7167da3 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:11:09 +0000
Subject: [PATCH 436/499] tests: update for accepted language change

Unions with no fields are now "uninstantiable" types, which work like
`noreturn` in that values of this type cannot exist. Enums with no
fields are different because they are currently considered `extern`
types, though https://github.com/ziglang/zig/issues/19855 will change
this in the future.
---
 test/behavior.zig                             |  1 -
 test/behavior/empty_union.zig                 | 66 ---------------
 test/behavior/enum.zig                        | 23 ++++++
 .../compile_errors/empty_extern_union.zig     |  8 ++
 .../compile_errors/empty_packed_union.zig     |  8 ++
 .../compile_errors/initialize_empty_union.zig | 81 +++++++++++++++++++
 .../sizeof_alignof_empty_union.zig            | 75 +++++++++++++++++
 7 files changed, 195 insertions(+), 67 deletions(-)
 delete mode 100644 test/behavior/empty_union.zig
 create mode 100644 test/cases/compile_errors/empty_extern_union.zig
 create mode 100644 test/cases/compile_errors/empty_packed_union.zig
 create mode 100644 test/cases/compile_errors/initialize_empty_union.zig
 create mode 100644 test/cases/compile_errors/sizeof_alignof_empty_union.zig

diff --git a/test/behavior.zig b/test/behavior.zig
index e4153c91bbea3721f79807393053f87c22f4ac52..c9c06e934230692c95d07b96d911fb09a80d3bdf 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -24,7 +24,6 @@ test {
     _ = @import("behavior/duplicated_test_names.zig");
     _ = @import("behavior/defer.zig");
     _ = @import("behavior/destructure.zig");
-    _ = @import("behavior/empty_union.zig");
     _ = @import("behavior/enum.zig");
     _ = @import("behavior/error.zig");
     _ = @import("behavior/eval.zig");
diff --git a/test/behavior/empty_union.zig b/test/behavior/empty_union.zig
deleted file mode 100644
index f05feacfafd7e429ff01aa3c65e376acaba63441..0000000000000000000000000000000000000000
--- a/test/behavior/empty_union.zig
+++ /dev/null
@@ -1,66 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const expect = std.testing.expect;
-
-test "switch on empty enum" {
-    const E = enum {};
-    var e: E = undefined;
-    _ = &e;
-    switch (e) {}
-}
-
-test "switch on empty enum with a specified tag type" {
-    const E = enum(u8) {};
-    var e: E = undefined;
-    _ = &e;
-    switch (e) {}
-}
-
-test "switch on empty auto numbered tagged union" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-
-    const U = union(enum(u8)) {};
-    var u: U = undefined;
-    _ = &u;
-    switch (u) {}
-}
-
-test "switch on empty tagged union" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-
-    const E = enum {};
-    const U = union(E) {};
-    var u: U = undefined;
-    _ = &u;
-    switch (u) {}
-}
-
-test "empty union" {
-    const U = union {};
-    try expect(@sizeOf(U) == 0);
-    try expect(@alignOf(U) == 1);
-}
-
-test "empty extern union" {
-    const U = extern union {};
-    try expect(@sizeOf(U) == 0);
-    try expect(@alignOf(U) == 1);
-}
-
-test "empty union passed as argument" {
-    const U = union(enum) {
-        fn f(u: @This()) void {
-            switch (u) {}
-        }
-    };
-    U.f(@as(U, undefined));
-}
-
-test "empty enum passed as argument" {
-    const E = enum {
-        fn f(e: @This()) void {
-            switch (e) {}
-        }
-    };
-    E.f(@as(E, undefined));
-}
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index a222bd605143b3de2ca5ca9f1c4f93d3760c3173..4dd5ae08da6e0bf73f81b148ae060c99b7ca2be2 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -1331,3 +1331,26 @@ test "comptime @enumFromInt with signed arithmetic" {
     comptime assert(x == .bar);
     comptime assert(@intFromEnum(x) == 0);
 }
+
+test "switch on empty enum" {
+    const E = enum {};
+    var e: E = undefined;
+    _ = &e;
+    switch (e) {}
+}
+
+test "switch on empty enum with a specified tag type" {
+    const E = enum(u8) {};
+    var e: E = undefined;
+    _ = &e;
+    switch (e) {}
+}
+
+test "empty enum passed as argument" {
+    const E = enum {
+        fn f(e: @This()) void {
+            switch (e) {}
+        }
+    };
+    E.f(@as(E, undefined));
+}
diff --git a/test/cases/compile_errors/empty_extern_union.zig b/test/cases/compile_errors/empty_extern_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..44d6269617ec06c17a97a544085070af52fa1e9d
--- /dev/null
+++ b/test/cases/compile_errors/empty_extern_union.zig
@@ -0,0 +1,8 @@
+export fn foo() void {
+    const U = extern union {};
+    _ = @as(U, undefined);
+}
+
+// error
+//
+// :2:22: error: extern union has no fields
diff --git a/test/cases/compile_errors/empty_packed_union.zig b/test/cases/compile_errors/empty_packed_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..87209670974eb706dd1385ba8e427944b5209278
--- /dev/null
+++ b/test/cases/compile_errors/empty_packed_union.zig
@@ -0,0 +1,8 @@
+export fn foo() void {
+    const U = packed union {};
+    _ = @as(U, undefined);
+}
+
+// error
+//
+// :2:22: error: packed union has no fields
diff --git a/test/cases/compile_errors/initialize_empty_union.zig b/test/cases/compile_errors/initialize_empty_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c84633da268c5f4e885ffa33a993cb0d3eeeecf5
--- /dev/null
+++ b/test/cases/compile_errors/initialize_empty_union.zig
@@ -0,0 +1,81 @@
+const EnumInferred = enum {};
+const EnumExplicit = enum(u8) {};
+const EnumNonexhaustive = enum(u8) { _ };
+
+const U0 = union {};
+const U1 = union(enum) {};
+const U2 = union(enum(u8)) {};
+const U3 = union(EnumInferred) {};
+const U4 = union(EnumExplicit) {};
+const U5 = union(EnumNonexhaustive) {};
+
+export fn init0() void {
+    _ = @as(U0, undefined);
+}
+export fn init1() void {
+    _ = @as(U1, undefined);
+}
+export fn init2() void {
+    _ = @as(U2, undefined);
+}
+export fn init3() void {
+    _ = @as(U3, undefined);
+}
+export fn init4() void {
+    _ = @as(U4, undefined);
+}
+export fn init5() void {
+    _ = @as(U5, undefined);
+}
+
+export fn deref0(ptr: *const U0) void {
+    _ = ptr.*;
+}
+export fn deref1(ptr: *const U1) void {
+    _ = ptr.*;
+}
+export fn deref2(ptr: *const U2) void {
+    _ = ptr.*;
+}
+export fn deref3(ptr: *const U3) void {
+    _ = ptr.*;
+}
+export fn deref4(ptr: *const U4) void {
+    _ = ptr.*;
+}
+export fn deref5(ptr: *const U5) void {
+    _ = ptr.*;
+}
+
+// error
+//
+// :13:17: error: expected type 'initialize_empty_union.U0', found '@TypeOf(undefined)'
+// :13:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U0'
+// :5:12: note: union declared here
+// :16:17: error: expected type 'initialize_empty_union.U1', found '@TypeOf(undefined)'
+// :16:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U1'
+// :6:12: note: union declared here
+// :19:17: error: expected type 'initialize_empty_union.U2', found '@TypeOf(undefined)'
+// :19:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U2'
+// :7:12: note: union declared here
+// :22:17: error: expected type 'initialize_empty_union.U3', found '@TypeOf(undefined)'
+// :22:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U3'
+// :8:12: note: union declared here
+// :25:17: error: expected type 'initialize_empty_union.U4', found '@TypeOf(undefined)'
+// :25:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U4'
+// :9:12: note: union declared here
+// :28:17: error: expected type 'initialize_empty_union.U5', found '@TypeOf(undefined)'
+// :28:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U5'
+// :10:12: note: union declared here
+// :32:12: error: cannot load uninstantiable type 'initialize_empty_union.U0'
+// :5:12: note: union declared here
+// :35:12: error: cannot load uninstantiable type 'initialize_empty_union.U1'
+// :6:12: note: union declared here
+// :38:12: error: cannot load uninstantiable type 'initialize_empty_union.U2'
+// :7:12: note: union declared here
+// :41:12: error: cannot load uninstantiable type 'initialize_empty_union.U3'
+// :8:12: note: union declared here
+// :44:12: error: cannot load uninstantiable type 'initialize_empty_union.U4'
+// :9:12: note: union declared here
+// :47:12: error: cannot load uninstantiable type 'initialize_empty_union.U5'
+// :10:12: note: union declared here
diff --git a/test/cases/compile_errors/sizeof_alignof_empty_union.zig b/test/cases/compile_errors/sizeof_alignof_empty_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..920b3b5af8a6281cce83860996d8af8eca3011f4
--- /dev/null
+++ b/test/cases/compile_errors/sizeof_alignof_empty_union.zig
@@ -0,0 +1,75 @@
+const EnumInferred = enum {};
+const EnumExplicit = enum(u8) {};
+const EnumNonexhaustive = enum(u8) { _ };
+
+const U0 = union {};
+const U1 = union(enum) {};
+const U2 = union(enum(u8)) {};
+const U3 = union(EnumInferred) {};
+const U4 = union(EnumExplicit) {};
+const U5 = union(EnumNonexhaustive) {};
+
+export fn size0() void {
+    _ = @sizeOf(U0);
+}
+export fn size1() void {
+    _ = @sizeOf(U1);
+}
+export fn size2() void {
+    _ = @sizeOf(U2);
+}
+export fn size3() void {
+    _ = @sizeOf(U3);
+}
+export fn size4() void {
+    _ = @sizeOf(U4);
+}
+export fn size5() void {
+    _ = @sizeOf(U5);
+}
+
+export fn align0() void {
+    _ = @alignOf(U0);
+}
+export fn align1() void {
+    _ = @alignOf(U1);
+}
+export fn align2() void {
+    _ = @alignOf(U2);
+}
+export fn align3() void {
+    _ = @alignOf(U3);
+}
+export fn align4() void {
+    _ = @alignOf(U4);
+}
+export fn align5() void {
+    _ = @alignOf(U5);
+}
+
+// error
+//
+// :13:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U0'
+// :5:12: note: union declared here
+// :16:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U1'
+// :6:12: note: union declared here
+// :19:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U2'
+// :7:12: note: union declared here
+// :22:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U3'
+// :8:12: note: union declared here
+// :25:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U4'
+// :9:12: note: union declared here
+// :28:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U5'
+// :10:12: note: union declared here
+// :32:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U0'
+// :5:12: note: union declared here
+// :35:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U1'
+// :6:12: note: union declared here
+// :38:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U2'
+// :7:12: note: union declared here
+// :41:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U3'
+// :8:12: note: union declared here
+// :44:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U4'
+// :9:12: note: union declared here
+// :47:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U5'
+// :10:12: note: union declared here
-- 
2.54.0


From da2006a38c63ac84aa9a075193bd72cf2d1716a2 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:21:08 +0000
Subject: [PATCH 437/499] tests: unions without fields need not store their tag
 at runtime

...because the union semantically has no possible value so cannot be
stored to or loaded from memory anyway.
---
 test/behavior/union.zig | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index a7b7c20a361d192a034363cc64a06ecc1f2b572a..1760f02c2299cf774153c64f24b76151249830e9 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1020,7 +1020,7 @@ test "containers with single-field enums" {
     try comptime S.doTheTest();
 }
 
-test "@unionInit on union with tag but no fields" {
+test "@unionInit on union with u8 tag but no fields" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
@@ -1036,10 +1036,6 @@ test "@unionInit on union with tag but no fields" {
             }
         };
 
-        comptime {
-            assert(@sizeOf(Data) == 1);
-        }
-
         fn doTheTest() !void {
             var data: Data = .{ .no_op = {} };
             _ = &data;
-- 
2.54.0


From 031d109310fe1f7e68314069ddf5d0d1dd342098 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:39:43 +0000
Subject: [PATCH 438/499] Sema: small error message fix

---
 src/Sema/type_resolution.zig | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index adc787136f93d6e69cce6464926369def5de3388..089ad64e254f28fc638980bf7c4533f95a8d9ec0 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -454,7 +454,6 @@ fn resolvePackedStructLayout(
             const msg = try sema.errMsg(field_ty_src, "packed structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
             errdefer msg.destroy(gpa);
             try sema.explainWhyTypeIsUnpackable(msg, field_ty_src, reason);
-            try sema.addDeclaredHereNote(msg, field_ty);
             break :msg msg;
         });
         switch (field_ty.classify(zcu)) {
-- 
2.54.0


From f9183edf08214d3ff014cfe26a5f218385ef5ccc Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:40:18 +0000
Subject: [PATCH 439/499] tests: update for accepted language change

`packed struct`s and `packed union`s can no longer contain pointer
fields. There are a few reasons for this, but in particular, binary
formats do not typically support the relocation types we would need to
lower such values into static memory. See the proposal at
https://github.com/ziglang/zig/issues/24657 for details.
---
 test/behavior/bitcast.zig                     | 29 ------
 test/behavior/packed-struct.zig               | 98 -------------------
 test/behavior/packed-union.zig                | 12 ---
 test/behavior/union.zig                       | 30 +-----
 ...truct_with_fields_of_not_allowed_types.zig |  8 ++
 ...cked_union_with_automatic_layout_field.zig | 18 ----
 ...union_with_fields_of_not_allowed_types.zig | 20 ++++
 7 files changed, 33 insertions(+), 182 deletions(-)
 delete mode 100644 test/cases/compile_errors/packed_union_with_automatic_layout_field.zig
 create mode 100644 test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig

diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 90cf8a5c776b07b538a27b19df5a3362471319a0..90d185c63f52d6c013564f629d61ba9cdbbc202f 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -511,35 +511,6 @@ test "@bitCast of packed struct of bools all false" {
     try expect(@as(u8, @as(u4, @bitCast(p))) == 0);
 }
 
-test "@bitCast of packed struct containing pointer" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://discourse.llvm.org/t/rfc-remove-most-constant-expressions/63179
-
-    const S = struct {
-        const A = packed struct {
-            ptr: *const u32,
-        };
-
-        const B = packed struct {
-            ptr: *const i32,
-        };
-
-        fn doTheTest() !void {
-            const x: u32 = 123;
-            var a: A = undefined;
-            a = .{ .ptr = &x };
-            const b: B = @bitCast(a);
-            try expect(b.ptr.* == 123);
-        }
-    };
-
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
 test "@bitCast of extern struct containing pointer" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 72e97bef959debf39b1a3d22b6a13cf96bd56682..1b019acb7243acaa2ccb0896b766666fabd6e83f 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -438,27 +438,6 @@ test "nested packed struct field pointers" {
     try expectEqual(6, ptr_p1_b.*);
 }
 
-test "load pointer from packed struct" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const A = struct {
-        index: u16,
-    };
-    const B = packed struct {
-        x: *A,
-        y: u32,
-    };
-    var a: A = .{ .index = 123 };
-    const b_list: []const B = &.{.{ .x = &a, .y = 99 }};
-    for (b_list) |b| {
-        try expect(b.x.index == 123);
-    }
-}
-
 test "@intFromPtr on a packed struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -601,19 +580,6 @@ test "packed struct fields modification" {
     try expect(@as(u16, @bitCast(Small.p)) == 0x1313);
 }
 
-test "optional pointer in packed struct" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const T = packed struct { ptr: ?*const u8 };
-    var n: u8 = 0;
-    const x = T{ .ptr = &n };
-    try expect(x.ptr.? == &n);
-}
-
 test "nested packed struct field access test" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO packed structs larger than 64 bits
@@ -1042,48 +1008,6 @@ test "packed struct acts as a namespace" {
     try expect(foo == .fizz);
 }
 
-test "pointer loaded correctly from packed struct" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // crashes MSVC
-
-    const RAM = struct {
-        data: [0xFFFF + 1]u8,
-        fn new() !@This() {
-            return .{ .data = [_]u8{0} ** 0x10000 };
-        }
-        fn get(self: *@This(), addr: u16) u8 {
-            return self.data[addr];
-        }
-    };
-
-    const CPU = packed struct {
-        interrupts: bool,
-        ram: *RAM,
-        fn new(ram: *RAM) !@This() {
-            return .{
-                .ram = ram,
-                .interrupts = false,
-            };
-        }
-        fn tick(self: *@This()) !void {
-            const queued_interrupts = self.ram.get(0xFFFF) & self.ram.get(0xFF0F);
-            if (self.interrupts and queued_interrupts != 0) {
-                self.interrupts = false;
-            }
-        }
-    };
-
-    var ram = try RAM.new();
-    var cpu = try CPU.new(&ram);
-    try cpu.tick();
-    try std.testing.expect(cpu.interrupts == false);
-}
-
 test "assignment to non-byte-aligned field in packed struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1227,13 +1151,6 @@ test "2-byte packed struct argument in C calling convention" {
     }
 }
 
-test "packed struct contains optional pointer" {
-    const foo: packed struct {
-        a: ?*@This() = null,
-    } = .{};
-    try expect(foo.a == null);
-}
-
 test "packed struct equality" {
     const Foo = packed struct {
         a: u4,
@@ -1297,21 +1214,6 @@ test "assign packed struct initialized with RLS to packed struct literal field"
     try expect(outer.x == x);
 }
 
-test "byte-aligned packed relocation" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
-    const S = struct {
-        var global: u8 align(2) = 0;
-        var packed_value: packed struct { x: u8, y: *align(2) u8 } = .{ .x = 111, .y = &global };
-    };
-    try expect(S.packed_value.x == 111);
-    try expect(S.packed_value.y == &S.global);
-}
-
 test "packed struct store of comparison result" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
diff --git a/test/behavior/packed-union.zig b/test/behavior/packed-union.zig
index bbb2f612b6788be2b1a7be647195004dd81da0c2..f625c8b0733ba6b0819feaf568ab6e4796f6cf47 100644
--- a/test/behavior/packed-union.zig
+++ b/test/behavior/packed-union.zig
@@ -177,15 +177,3 @@ test "assigning to non-active field at comptime" {
         test_bits.bits = .{};
     }
 }
-
-test "comptime packed union of pointers" {
-    const U = packed union {
-        a: *const u32,
-        b: *const [1]u32,
-    };
-
-    const x: u32 = 123;
-    const u: U = .{ .a = &x };
-
-    comptime assert(u.b[0] == 123);
-}
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 1760f02c2299cf774153c64f24b76151249830e9..9badc9dabd11bd6709c95ae32ba755f6cc3b9bd2 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -217,26 +217,6 @@ test "union with specified enum tag" {
     try comptime doTest();
 }
 
-test "packed union generates correctly aligned type" {
-    // This test will be removed after the following accepted proposal is implemented:
-    // https://github.com/ziglang/zig/issues/24657
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-
-    const U = packed union {
-        f1: *const fn () error{TestUnexpectedResult}!void,
-        f2: usize,
-    };
-    var foo = [_]U{
-        U{ .f1 = doTest },
-        U{ .f2 = 0 },
-    };
-    try foo[0].f1();
-}
-
 fn doTest() error{TestUnexpectedResult}!void {
     try expect((try bar(Payload{ .A = 1234 })) == -10);
 }
@@ -359,12 +339,12 @@ test "simple union(enum(u32))" {
     try expect(@intFromEnum(@as(Tag(MultipleChoice), x)) == 60);
 }
 
-const PackedPtrOrInt = packed union {
-    ptr: *u8,
-    int: usize,
-};
 test "packed union size" {
-    comptime assert(@sizeOf(PackedPtrOrInt) == @sizeOf(usize));
+    const U = packed union {
+        signed: isize,
+        unsigned: usize,
+    };
+    comptime assert(@sizeOf(U) == @sizeOf(usize));
 }
 
 const ZeroBits = union {
diff --git a/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig b/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig
index b5bf3d6f3a2b2c8d44f30e0e08ec78961f5eec59..5f4482421d65b8144ace994483cf8342aa35006b 100644
--- a/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig
+++ b/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig
@@ -76,6 +76,11 @@ export fn entry14() void {
         x: E,
     });
 }
+export fn entry15() void {
+    _ = @sizeOf(packed struct {
+        x: *const u32,
+    });
+}
 
 // error
 //
@@ -103,3 +108,6 @@ export fn entry14() void {
 // :70:12: note: types are not available at runtime
 // :76:12: error: packed structs cannot contain fields of type 'tmp.entry14.E'
 // :74:15: note: enum declared here
+// :81:12: error: packed structs cannot contain fields of type '*const u32'
+// :81:12: note: pointers cannot be directly bitpacked
+// :81:12: note: consider using 'usize' and '@intFromPtr'
diff --git a/test/cases/compile_errors/packed_union_with_automatic_layout_field.zig b/test/cases/compile_errors/packed_union_with_automatic_layout_field.zig
deleted file mode 100644
index c37e987c1c15399d22f8ffe5eab38bdd9ef2b4b1..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/packed_union_with_automatic_layout_field.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Foo = struct {
-    a: u32,
-    b: f32,
-};
-const Payload = packed union {
-    A: Foo,
-    B: bool,
-};
-export fn entry() void {
-    const a: Payload = .{ .B = true };
-    _ = a;
-}
-
-// error
-//
-// :6:8: error: packed unions cannot contain fields of type 'tmp.Foo'
-// :6:8: note: only packed structs layout are allowed in packed types
-// :1:13: note: struct declared here
diff --git a/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig b/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cfbdf4e90aeaab22aa6637066e68d1a1ce0348ac
--- /dev/null
+++ b/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig
@@ -0,0 +1,20 @@
+export fn entry0() void {
+    _ = @sizeOf(packed union {
+        foo: struct { a: u32 },
+        bar: bool,
+    });
+}
+export fn entry1() void {
+    _ = @sizeOf(packed union {
+        x: *const u32,
+    });
+}
+
+// error
+//
+// :3:14: error: packed unions cannot contain fields of type 'packed_union_with_fields_of_not_allowed_types.entry0__union_180__struct_182'
+// :3:14: note: non-packed structs do not have a bit-packed representation
+// :3:14: note: struct declared here
+// :9:12: error: packed unions cannot contain fields of type '*const u32'
+// :9:12: note: pointers cannot be directly bitpacked
+// :9:12: note: consider using 'usize' and '@intFromPtr'
-- 
2.54.0


From a226008e32af8700d1aa05bcaef50cb3cf1205d0 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:58:03 +0000
Subject: [PATCH 440/499] Sema: minor fix

---
 src/Sema.zig | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 140e69fe6ffe1e3e16e4cf6176a8ff48bf89000d..40a1126c9f27bc39982cceebd2f43a91f4efb716 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -15913,12 +15913,12 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         .undefined,
         .null,
         .@"opaque",
+        .type,
+        .enum_literal,
+        .comptime_float,
+        .comptime_int,
         => return sema.fail(block, operand_src, "no size available for type '{f}'", .{operand_ty.fmt(pt)}),
 
-        .type,
-        .enum_literal,
-        .comptime_float,
-        .comptime_int,
         .void,
         => return .zero,
 
-- 
2.54.0


From 21b42af5aa6bc25dd99d2e425aa3df6bac80476e Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 14:58:32 +0000
Subject: [PATCH 441/499] tests: update for accepted language change

`@sizeOf` and `@bitSizeOf` are now more restricted: they are not allowed
on comptime-only or NPV (uninstantiable) types. This is because there is
no correct way to actually use the returned ABI size (e.g. you cannot
copy a comptime-only type by copying all of its runtime bits), so having
a non-zero return value had no benefit and was simply confusing.
---
 test/behavior/sizeof_and_typeof.zig           | 25 -------------------
 test/behavior/type.zig                        |  4 +--
 .../cases/compile_errors/alignOf_bad_type.zig | 10 ++++++--
 test/cases/compile_errors/sizeOf_bad_type.zig | 22 ++++++++++++++--
 4 files changed, 30 insertions(+), 31 deletions(-)

diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index a6087787b5bfec02334554fa527d1011a8bf4a96..2fb89bc484bb9ab682c2627800debbe546531b2b 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -11,13 +11,6 @@ test "@sizeOf and @TypeOf" {
 const x: u16 = 13;
 const z: @TypeOf(x) = 19;
 
-test "@sizeOf on compile-time types" {
-    try expect(@sizeOf(comptime_int) == 0);
-    try expect(@sizeOf(comptime_float) == 0);
-    try expect(@sizeOf(@TypeOf(.hi)) == 0);
-    try expect(@sizeOf(@TypeOf(type)) == 0);
-}
-
 test "@TypeOf() with multiple arguments" {
     {
         var var_1: u32 = undefined;
@@ -265,10 +258,6 @@ test "lazy size cast to float" {
     }
 }
 
-test "bitSizeOf comptime_int" {
-    try expect(@bitSizeOf(comptime_int) == 0);
-}
-
 test "runtime instructions inside typeof in comptime only scope" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -336,20 +325,6 @@ test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
     try std.testing.expect(t.next == null);
 }
 
-test "@sizeOf reified union zero-size payload fields" {
-    comptime {
-        try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{}, &.{}, &.{})));
-        try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{"a"}, &.{void}, &.{.{}})));
-        if (builtin.mode == .Debug or builtin.mode == .ReleaseSafe) {
-            try std.testing.expect(1 == @sizeOf(@Union(.auto, null, &.{ "a", "b" }, &.{ void, void }, &.{ .{}, .{} })));
-            try std.testing.expect(1 == @sizeOf(@Union(.auto, null, &.{ "a", "b", "c" }, &.{ void, void, void }, &.{ .{}, .{}, .{} })));
-        } else {
-            try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{ "a", "b" }, &.{ void, void }, &.{ .{}, .{} })));
-            try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{ "a", "b", "c" }, &.{ void, void, void }, &.{ .{}, .{}, .{} })));
-        }
-    }
-}
-
 const FILE = extern struct {
     dummy_field: u8,
 };
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index ef27522a63038a36429063607d7d48768195268f..88358db1829cdb9b51018b595d49170f7482b8bc 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -278,13 +278,13 @@ test "Type.Union from regular enum" {
 test "Type.Union from empty regular enum" {
     const E = enum {};
     const U = @Union(.auto, E, &.{}, &.{}, &.{});
-    try testing.expectEqual(@sizeOf(U), 0);
+    try testing.expectEqual(@typeInfo(U).@"union".fields.len, 0);
 }
 
 test "Type.Union from empty Type.Enum" {
     const E = @Enum(u0, .exhaustive, &.{}, &.{});
     const U = @Union(.auto, E, &.{}, &.{}, &.{});
-    try testing.expectEqual(@sizeOf(U), 0);
+    try testing.expectEqual(@typeInfo(U).@"union".fields.len, 0);
 }
 
 test "Type.Fn" {
diff --git a/test/cases/compile_errors/alignOf_bad_type.zig b/test/cases/compile_errors/alignOf_bad_type.zig
index 253adceb0547552ba531eb93a50f989d770a3b7c..93dcfa3b94922a74c2edb4720cd0232ddabbb795 100644
--- a/test/cases/compile_errors/alignOf_bad_type.zig
+++ b/test/cases/compile_errors/alignOf_bad_type.zig
@@ -1,7 +1,13 @@
-export fn entry() usize {
+export fn entry0() usize {
     return @alignOf(noreturn);
 }
+const S = struct { a: u32, b: noreturn };
+export fn entry1() usize {
+    return @alignOf(S);
+}
 
 // error
 //
-// :2:21: error: no align available for type 'noreturn'
+// :2:21: error: no align available for uninstantiable type 'noreturn'
+// :6:21: error: no align available for uninstantiable type 'alignOf_bad_type.S'
+// :4:11: note: struct declared here
diff --git a/test/cases/compile_errors/sizeOf_bad_type.zig b/test/cases/compile_errors/sizeOf_bad_type.zig
index 93dec1f88eeddfaf5352b183ad54886cbfb3e39c..c81ad7450f3d34e9af7e0eabcc2917e4303027f1 100644
--- a/test/cases/compile_errors/sizeOf_bad_type.zig
+++ b/test/cases/compile_errors/sizeOf_bad_type.zig
@@ -1,7 +1,25 @@
-export fn entry() usize {
+export fn entry0() usize {
     return @sizeOf(@TypeOf(null));
 }
+export fn entry1() usize {
+    return @sizeOf(comptime_int);
+}
+export fn entry2() usize {
+    return @sizeOf(noreturn);
+}
+const S3 = struct { a: u32, b: comptime_int };
+export fn entry3() usize {
+    return @sizeOf(S3);
+}
+const S4 = struct { a: u32, b: noreturn };
+export fn entry4() usize {
+    return @sizeOf(S4);
+}
 
 // error
 //
-// :2:20: error: no size available for type '@TypeOf(null)'
+// :2:20: error: no size available for comptime-only type '@TypeOf(null)'
+// :5:20: error: no size available for comptime-only type 'comptime_int'
+// :8:20: error: no size available for uninstantiable type 'noreturn'
+// :12:20: error: no size available for comptime-only type 'tmp.S3'
+// :16:20: error: no size available for uninstantiable type 'tmp.S4'
-- 
2.54.0


From c9fc921abdfddcfed3383488dc1eaf23dcdeaa54 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 15:14:57 +0000
Subject: [PATCH 442/499] tests: update for accepted language change

Pointers to comptime-only types (e.g. `*type`) are no longer themselves
comptime-only types. This means explicit `comptime` annotations are
required in a few more places. However, it also introduces the ability
to access pointers to (including slices of) comptime-only types at
runtime, provided only runtime fields are being accessed.
---
 test/behavior/slice.zig  |  2 +-
 test/behavior/struct.zig | 23 ++++++++++++++++++++++-
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig
index 4de7b26d34f735b5a11976b3c3d05734e5f39e56..b13003dc5092f4395e211d24b2fef3baad0c05a4 100644
--- a/test/behavior/slice.zig
+++ b/test/behavior/slice.zig
@@ -160,7 +160,7 @@ test "slice of type" {
 
 test "pass a slice of types to a function" {
     const S = struct {
-        fn checkTypesSlice(types_slice: []const type) !void {
+        fn checkTypesSlice(comptime types_slice: []const type) !void {
             try expect(types_slice.len == 2);
             try expect(types_slice[0] == anyerror);
             try expect(types_slice[1] == bool);
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 6422aef034bf3b4fbcf1e16acce3742944828a04..e6a355864629600f6294492ee11e4cf7c73f5674 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -2177,7 +2177,7 @@ test "avoid unused field function body compile error" {
 
 test "pass a pointer to a comptime-only struct field to a function" {
     const S = struct {
-        fn checkField(field_ptr: *const type) !void {
+        fn checkField(comptime field_ptr: *const type) !void {
             try expect(field_ptr.* == u42);
         }
     };
@@ -2233,3 +2233,24 @@ test "overaligned extern struct fields" {
     try expect(std.mem.isAligned(@intFromPtr(&e.c), @alignOf(u32)));
     try expect(std.mem.isAligned(@intFromPtr(&e.d), @alignOf(B)));
 }
+
+test "runtime-known slice of comptime-only struct" {
+    const Mixed = struct { index: u32, T: type };
+
+    const static = struct {
+        fn doTheTest(index_offset: usize, s: []const Mixed) !void {
+            for (s, index_offset..) |*mixed, index| {
+                try expect(mixed.index == index);
+            }
+        }
+    };
+
+    try static.doTheTest(10, &.{
+        .{ .index = 10, .T = u8 },
+        .{ .index = 11, .T = noreturn },
+        .{ .index = 12, .T = *opaque {} },
+        .{ .index = 13, .T = undefined },
+        .{ .index = 14, .T = @TypeOf(undefined) },
+        .{ .index = 15, .T = Mixed },
+    });
+}
-- 
2.54.0


From e2669689c46630afd3adb99c496a6895c6c95a15 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 15:22:42 +0000
Subject: [PATCH 443/499] behavior: auto structs with zero fields are not
 extern types

---
 test/behavior/sizeof_and_typeof.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index 2fb89bc484bb9ab682c2627800debbe546531b2b..65deede0768638791f5da2cb4b74db82ea6c0caa 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -366,7 +366,7 @@ test "Extern function calls in @TypeOf" {
 
         extern fn s_do_thing([*c]const @This(), b: c_int) c_short;
     };
-    const E = struct {
+    const E = extern struct {
         export fn s_do_thing(a: [*c]const @This(), b: c_int) c_short {
             _ = a;
             _ = b;
-- 
2.54.0


From be4c4ce2787537f860c8578eb9e497f66c2e9baf Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 15:39:21 +0000
Subject: [PATCH 444/499] Zcu: improve dependency loop errors with only one
 item

In this case, we can write the error much more simply.
---
 src/Zcu.zig | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/src/Zcu.zig b/src/Zcu.zig
index ce90f2c417abc94c2b146c922f907c2b17a69e24..fc770ba4ea1924d34d238e8bb13fd3107332a1ec 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4739,21 +4739,32 @@ pub fn addDependencyLoopErrors(zcu: *Zcu, eb: *std.zig.ErrorBundle.Wip) Allocato
         const frame_limit = zcu.comp.reference_trace orelse 0;
         try zcu.populateReferenceTrace(units.items[start_index], frame_limit, eb, &ref_trace);
 
+        if (units.items.len == 1) {
+            // Don't do a complicated message with multiple notes, just do a single error message.
+            assert(start_index == 0);
+            const root_msg = addDependencyLoopErrorLine(zcu, eb, units.items[start_index], ref_trace.items) catch |err| switch (err) {
+                error.AlreadyReported => return, // give up on the dep loop error
+                error.OutOfMemory => |e| return e,
+            };
+            try eb.root_list.append(eb.gpa, root_msg);
+            continue;
+        }
+
         // Collect all notes first so we don't leave an incomplete root error message on `error.AlreadyReported`.
         const note_buf = try gpa.alloc(std.zig.ErrorBundle.MessageIndex, units.items.len + 1);
         defer gpa.free(note_buf);
-        note_buf[0] = addDependencyLoopNote(zcu, eb, units.items[start_index], ref_trace.items) catch |err| switch (err) {
+        note_buf[0] = addDependencyLoopErrorLine(zcu, eb, units.items[start_index], ref_trace.items) catch |err| switch (err) {
             error.AlreadyReported => return, // give up on the dep loop error
             error.OutOfMemory => |e| return e,
         };
         for (units.items[start_index + 1 ..], note_buf[1 .. units.items.len - start_index]) |unit, *note| {
-            note.* = addDependencyLoopNote(zcu, eb, unit, &.{}) catch |err| switch (err) {
+            note.* = addDependencyLoopErrorLine(zcu, eb, unit, &.{}) catch |err| switch (err) {
                 error.AlreadyReported => return, // give up on the dep loop error
                 error.OutOfMemory => |e| return e,
             };
         }
         for (units.items[0..start_index], note_buf[units.items.len - start_index .. units.items.len]) |unit, *note| {
-            note.* = addDependencyLoopNote(zcu, eb, unit, &.{}) catch |err| switch (err) {
+            note.* = addDependencyLoopErrorLine(zcu, eb, unit, &.{}) catch |err| switch (err) {
                 error.AlreadyReported => return, // give up on the dep loop error
                 error.OutOfMemory => |e| return e,
             };
@@ -4773,7 +4784,7 @@ pub fn addDependencyLoopErrors(zcu: *Zcu, eb: *std.zig.ErrorBundle.Wip) Allocato
         @memcpy(notes, note_buf);
     }
 }
-fn addDependencyLoopNote(
+fn addDependencyLoopErrorLine(
     zcu: *Zcu,
     eb: *std.zig.ErrorBundle.Wip,
     source_unit: AnalUnit,
@@ -4789,7 +4800,16 @@ fn addDependencyLoopNote(
 
     const dep_node = zcu.dependency_loop_nodes.get(source_unit).?;
 
-    const msg: std.zig.ErrorBundle.String = switch (dep_node.unit.unwrap()) {
+    const msg: std.zig.ErrorBundle.String = if (dep_node.unit == source_unit) switch (source_unit.unwrap()) {
+        .@"comptime" => unreachable, // cannot be involved in a dependency loop
+        .nav_ty, .nav_val => try eb.printString("{f} depends on itself here", .{fmt_source}),
+        .memoized_state => unreachable, // memoized_state definitely does not *directly* depend on itself
+        .func => try eb.printString("{f} uses its own inferred error set here", .{fmt_source}),
+        .type_layout => try eb.printString("{f} depends on itself {s}", .{
+            fmt_source,
+            dep_node.reason.type_layout_reason.msg(),
+        }),
+    } else switch (dep_node.unit.unwrap()) {
         .@"comptime" => unreachable, // cannot be involved in a dependency loop
         .nav_val => |nav| try eb.printString("{f} uses value of declaration '{f}' here", .{
             fmt_source, ip.getNav(nav).fqn.fmt(ip),
-- 
2.54.0


From 1364cba90d41cb2f33380b23d534aaddbd6ceff2 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 15:52:12 +0000
Subject: [PATCH 445/499] behavior: update for type resolution changes

---
 test/behavior/array.zig                       | 22 -------------------
 test/behavior/sizeof_and_typeof.zig           | 15 -------------
 .../struct_contains_slice_of_itself.zig       |  2 +-
 3 files changed, 1 insertion(+), 38 deletions(-)

diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index b28ee267c2e03a1a1b758ea6256b7f3fc23ebb09..2bd85555297beed2d7b33de499e272ddc639a175 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -539,28 +539,6 @@ test "sentinel element count towards the ABI size calculation" {
     try comptime S.doTheTest();
 }
 
-test "zero-sized array with recursive type definition" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const U = struct {
-        fn foo(comptime T: type, comptime n: usize) type {
-            return struct {
-                s: [n]T,
-                x: usize = n,
-            };
-        }
-    };
-
-    const S = struct {
-        list: U.foo(@This(), 0),
-    };
-
-    var t: S = .{ .list = .{ .s = undefined } };
-    _ = &t;
-    try expect(@as(usize, 0) == t.list.x);
-}
-
 test "type coercion of anon struct literal to array" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index 65deede0768638791f5da2cb4b74db82ea6c0caa..cb6c334cb7448bdd403c419baaad2eb9d92443d9 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -120,21 +120,6 @@ test "@bitOffsetOf" {
     try expect(@offsetOf(A, "g") * 8 == @bitOffsetOf(A, "g"));
 }
 
-test "@sizeOf(T) == 0 doesn't force resolving struct size" {
-    const S = struct {
-        const Foo = struct {
-            y: if (@sizeOf(Foo) == 0) u64 else u32,
-        };
-        const Bar = struct {
-            x: i32,
-            y: if (0 == @sizeOf(Bar)) u64 else u32,
-        };
-    };
-
-    try expect(@sizeOf(S.Foo) == 4);
-    try expect(@sizeOf(S.Bar) == 8);
-}
-
 test "@TypeOf() has no runtime side effects" {
     const S = struct {
         fn foo(comptime T: type, ptr: *T) T {
diff --git a/test/behavior/struct_contains_slice_of_itself.zig b/test/behavior/struct_contains_slice_of_itself.zig
index 5cf8d8134a1cc91abbc392c0acf7c1765f3e50bc..541babee6bb62d10cf05f141545eafe9766aefd7 100644
--- a/test/behavior/struct_contains_slice_of_itself.zig
+++ b/test/behavior/struct_contains_slice_of_itself.zig
@@ -8,7 +8,7 @@ const Node = struct {
 
 const NodeAligned = struct {
     payload: i32,
-    children: []align(@alignOf(NodeAligned)) NodeAligned,
+    children: []align(1) NodeAligned,
 };
 
 test "struct contains slice of itself" {
-- 
2.54.0


From 12ddd5a698577e22a0bb5ed788ea4b9729a45b5d Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Feb 2026 15:58:51 +0000
Subject: [PATCH 446/499] behavior: update for changes to struct field default
 value resolution

This is separate from the previous commit so that these changes can be
easily reverted in the event that we decide to allow more granularity in
default value resolution in exchange for increased language complexity.
---
 test/behavior/eval.zig   | 114 ---------------------------------------
 test/behavior/struct.zig |  58 ++------------------
 test/behavior/union.zig  |  49 -----------------
 3 files changed, 3 insertions(+), 218 deletions(-)

diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 8f45405e94838c9c7768616a9f1f1dd24c2baa7f..9e3cd732f0e3b41152fbbb51732283bbe9c07192 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -1081,120 +1081,6 @@ test "comptime break operand passing through runtime switch converted to runtime
     try comptime S.doTheTest('b');
 }
 
-test "no dependency loop for alignment of self struct" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const S = struct {
-        fn doTheTest() !void {
-            var a: namespace.A = undefined;
-            a.d = .{ .g = &buf };
-            a.d.g[3] = 42;
-            a.d.g[3] += 1;
-            try expect(a.d.g[3] == 43);
-        }
-
-        var buf: [10]u8 align(@alignOf([*]u8)) = undefined;
-
-        const namespace = struct {
-            const B = struct { a: A };
-            const A = C(B);
-        };
-
-        pub fn C(comptime B: type) type {
-            return struct {
-                d: D(F) = .{},
-
-                const F = struct { b: B };
-            };
-        }
-
-        pub fn D(comptime F: type) type {
-            return struct {
-                g: [*]align(@alignOf(F)) u8 = undefined,
-            };
-        }
-    };
-    try S.doTheTest();
-}
-
-test "no dependency loop for alignment of self bare union" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const S = struct {
-        fn doTheTest() !void {
-            var a: namespace.A = undefined;
-            a.d = .{ .g = &buf };
-            a.d.g[3] = 42;
-            a.d.g[3] += 1;
-            try expect(a.d.g[3] == 43);
-        }
-
-        var buf: [10]u8 align(@alignOf([*]u8)) = undefined;
-
-        const namespace = struct {
-            const B = union { a: A, b: void };
-            const A = C(B);
-        };
-
-        pub fn C(comptime B: type) type {
-            return struct {
-                d: D(F) = .{},
-
-                const F = struct { b: B };
-            };
-        }
-
-        pub fn D(comptime F: type) type {
-            return struct {
-                g: [*]align(@alignOf(F)) u8 = undefined,
-            };
-        }
-    };
-    try S.doTheTest();
-}
-
-test "no dependency loop for alignment of self tagged union" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const S = struct {
-        fn doTheTest() !void {
-            var a: namespace.A = undefined;
-            a.d = .{ .g = &buf };
-            a.d.g[3] = 42;
-            a.d.g[3] += 1;
-            try expect(a.d.g[3] == 43);
-        }
-
-        var buf: [10]u8 align(@alignOf([*]u8)) = undefined;
-
-        const namespace = struct {
-            const B = union(enum) { a: A, b: void };
-            const A = C(B);
-        };
-
-        pub fn C(comptime B: type) type {
-            return struct {
-                d: D(F) = .{},
-
-                const F = struct { b: B };
-            };
-        }
-
-        pub fn D(comptime F: type) type {
-            return struct {
-                g: [*]align(@alignOf(F)) u8 = undefined,
-            };
-        }
-    };
-    try S.doTheTest();
-}
-
 test "equality of pointers to comptime const" {
     const a: i32 = undefined;
     comptime assert(&a == &a);
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index e6a355864629600f6294492ee11e4cf7c73f5674..37dc873d60385608367b1841362aaadb21254e5c 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -1249,20 +1249,6 @@ test "store to comptime field" {
     }
 }
 
-test "struct field init value is size of the struct" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-
-    const namespace = struct {
-        const S = extern struct {
-            size: u8 = @sizeOf(S),
-            blah: u16,
-        };
-    };
-    var s: namespace.S = .{ .blah = 1234 };
-    _ = &s;
-    try expect(s.size == 4);
-}
-
 test "under-aligned struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1710,41 +1696,19 @@ test "comptimeness of optional and error union payload is analyzed properly" {
     try std.testing.expectEqual(3, x);
 }
 
-test "initializer uses own alignment" {
-    const S = struct {
-        x: u32 = @alignOf(@This()) + 1,
-    };
-
-    var s: S = .{};
-    _ = &s;
-    try expectEqual(4, @alignOf(S));
-    try expectEqual(@as(usize, 5), s.x);
-}
-
-test "initializer uses own size" {
-    const S = struct {
-        x: u32 = @sizeOf(@This()) + 1,
-    };
-
-    var s: S = .{};
-    _ = &s;
-    try expectEqual(4, @sizeOf(S));
-    try expectEqual(@as(usize, 5), s.x);
-}
-
 test "initializer takes a pointer to a variable inside its struct" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const namespace = struct {
         const S = struct {
-            s: *S = &S.instance,
-            var instance: S = undefined;
+            x: *u32 = &S.int,
+            var int: u32 = undefined;
         };
 
         fn doTheTest() !void {
             var foo: S = .{};
             _ = &foo;
-            try expectEqual(&S.instance, foo.s);
+            try expectEqual(&S.int, foo.x);
         }
     };
 
@@ -1775,22 +1739,6 @@ test "circular dependency through pointer field of a struct" {
     try expect(outer.middle.inner == null);
 }
 
-test "field calls do not force struct field init resolution" {
-    const S = struct {
-        x: u32 = blk: {
-            _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
-            break :blk 123;
-        },
-        dummyFn: *const fn () void = undefined,
-        fn make() @This() {
-            return .{};
-        }
-    };
-    var s: S = .{};
-    _ = &s;
-    try expect(s.x == 123);
-}
-
 test "tuple with comptime-only field" {
     const S = struct {
         fn getTuple() struct { comptime_int } {
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 9badc9dabd11bd6709c95ae32ba755f6cc3b9bd2..b081d9b33a06e41df101c7f55f2d716821be30fe 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1796,55 +1796,6 @@ test "reinterpret packed union inside packed struct" {
     try S.doTheTest();
 }
 
-test "inner struct initializer uses union layout" {
-    const namespace = struct {
-        const U = union {
-            a: struct {
-                x: u32 = @alignOf(U) + 1,
-            },
-            b: struct {
-                y: u16 = @sizeOf(U) + 2,
-            },
-        };
-    };
-
-    {
-        const u: namespace.U = .{ .a = .{} };
-        try expectEqual(4, @alignOf(namespace.U));
-        try expectEqual(@as(usize, 5), u.a.x);
-    }
-
-    {
-        const u: namespace.U = .{ .b = .{} };
-        try expectEqual(@as(usize, @sizeOf(namespace.U) + 2), u.b.y);
-    }
-}
-
-test "inner struct initializer uses packed union layout" {
-    const namespace = struct {
-        const U = packed union {
-            a: packed struct {
-                x: u32 = @alignOf(U) + 1,
-            },
-            b: packed struct(u32) {
-                y: u16 = @sizeOf(U) + 2,
-                padding: u16 = 0,
-            },
-        };
-    };
-
-    {
-        const u: namespace.U = .{ .a = .{} };
-        try expectEqual(4, @alignOf(namespace.U));
-        try expectEqual(@as(usize, 5), u.a.x);
-    }
-
-    {
-        const u: namespace.U = .{ .b = .{} };
-        try expectEqual(@as(usize, @sizeOf(namespace.U) + 2), u.b.y);
-    }
-}
-
 test "extern union initialized via reintepreted struct field initializer" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
-- 
2.54.0


From 5865abf7f5ea2d4500cb8387252d9efee26ecae1 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 9 Feb 2026 10:20:58 +0000
Subject: [PATCH 447/499] Sema: defer extern function type validation to
 declaration or call

Because of packed structs, checking whether a type is extern-compatible
requires that its layout be resolved. For functions to do this
validation as soon as the function type is created would lead to
dependency loops in cases like '*const fn (*@This()) void callconv(.c)`.

Therefore, when creating a function *type*, we no longer perform this
check immediately, instead waiting until the function is called.
---
 src/Sema.zig                 | 258 +++++++++++++++++++++--------------
 src/Sema/type_resolution.zig |   4 +-
 src/Type.zig                 |   3 +-
 3 files changed, 156 insertions(+), 109 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 40a1126c9f27bc39982cceebd2f43a91f4efb716..d5aef143392ca4cceefec718c4c9acb1bbf3c7a2 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5747,6 +5747,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     }
 
     const export_ty = ptr_ty.childType(zcu);
+    try sema.ensureLayoutResolved(export_ty, src, .@"export");
     if (!export_ty.validateExtern(.other, zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "unable to export type '{f}'", .{export_ty.fmt(pt)});
@@ -6749,6 +6750,37 @@ fn analyzeCall(
     } else func_src;
 
     const func_ty_info = zcu.typeToFunc(func_ty).?;
+
+    for (func_ty_info.param_types.get(ip), 0..) |param_ty_ip, param_index| {
+        const arg_src = args_info.argSrc(block, param_index);
+        try sema.ensureLayoutResolved(.fromInterned(param_ty_ip), arg_src, .init);
+    }
+    try sema.ensureLayoutResolved(.fromInterned(func_ty_info.return_type), func_ret_ty_src, .return_type);
+    try sema.validateResolvedFuncType(
+        block,
+        func_ty_info.cc,
+        func_ty_info.param_types.get(ip),
+        .fromInterned(func_ty_info.return_type),
+        func_src,
+        maybe_func_inst,
+    );
+
+    if (!callConvIsCallable(func_ty_info.cc)) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(
+                func_src,
+                "unable to call function with calling convention '{s}'",
+                .{@tagName(func_ty_info.cc)},
+            );
+            errdefer msg.destroy(gpa);
+            if (maybe_func_inst) |func_inst| try sema.errNote(.{
+                .base_node_inst = func_inst,
+                .offset = .nodeOffset(.zero),
+            }, msg, "function declared here", .{});
+            break :msg msg;
+        });
+    }
+
     const any_comptime_params = func_ty_info.comptime_bits != 0 or ct: {
         for (func_ty_info.param_types.get(ip)) |param_ty| {
             if (Type.fromInterned(param_ty).comptimeOnly(zcu)) break :ct true;
@@ -6771,22 +6803,6 @@ fn analyzeCall(
         break :generic false;
     };
 
-    if (!callConvIsCallable(func_ty_info.cc)) {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(
-                func_src,
-                "unable to call function with calling convention '{s}'",
-                .{@tagName(func_ty_info.cc)},
-            );
-            errdefer msg.destroy(gpa);
-            if (maybe_func_inst) |func_inst| try sema.errNote(.{
-                .base_node_inst = func_inst,
-                .offset = .nodeOffset(.zero),
-            }, msg, "function declared here", .{});
-            break :msg msg;
-        });
-    }
-
     // We need this value in a few code paths.
     const callee_val = try sema.resolveDefinedValue(block, call_src, callee);
     // If the callee is a comptime-known *non-extern* function, `func_val` is populated.
@@ -8755,11 +8771,12 @@ fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc:
     }
 }
 
-fn checkParamTypeCommon(
+fn checkParamType(
     sema: *Sema,
     block: *Block,
     param_idx: u32,
     param_ty: Type,
+    param_is_comptime: bool,
     param_is_noalias: bool,
     param_src: LazySrcLoc,
     cc: std.builtin.CallingConvention,
@@ -8774,29 +8791,22 @@ fn checkParamTypeCommon(
             opaque_str, param_ty.fmt(pt),
         });
     }
-    if (!param_ty.isGenericPoison() and
-        !target_util.fnCallConvAllowsZigTypes(cc) and
-        !param_ty.validateExtern(.param_ty, zcu))
-    {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(param_src, "parameter of type '{f}' not allowed in function with calling convention '{s}'", .{
-                param_ty.fmt(pt), @tagName(cc),
-            });
-            errdefer msg.destroy(sema.gpa);
-
-            try sema.explainWhyTypeIsNotExtern(msg, param_src, param_ty, .param_ty);
-
-            try sema.addDeclaredHereNote(msg, param_ty);
-            break :msg msg;
-        });
+    if (!target_util.fnCallConvAllowsZigTypes(cc)) {
+        if (param_is_comptime) {
+            return sema.fail(block, param_src, "comptime parameters not allowed in function with calling convention '{t}'", .{cc});
+        }
+        if (param_ty.isGenericPoison()) {
+            return sema.fail(block, param_src, "generic parameters not allowed in function with calling convention '{t}'", .{cc});
+        }
+        // The `validateExtern` check happens later, in `validateResolvedFuncType`.
     }
     switch (cc) {
         .x86_64_interrupt, .x86_interrupt => {
             const err_code_size = target.ptrBitWidth();
             switch (param_idx) {
-                0 => if (param_ty.zigTypeTag(zcu) != .pointer) return sema.fail(block, param_src, "first parameter of function with '{s}' calling convention must be a pointer type", .{@tagName(cc)}),
-                1 => if (param_ty.bitSize(zcu) != err_code_size) return sema.fail(block, param_src, "second parameter of function with '{s}' calling convention must be a {d}-bit integer", .{ @tagName(cc), err_code_size }),
-                else => return sema.fail(block, param_src, "'{s}' calling convention supports up to 2 parameters, found {d}", .{ @tagName(cc), param_idx + 1 }),
+                0 => if (param_ty.zigTypeTag(zcu) != .pointer) return sema.fail(block, param_src, "first parameter of function with '{t}' calling convention must be a pointer type", .{cc}),
+                1 => if (param_ty.bitSize(zcu) != err_code_size) return sema.fail(block, param_src, "second parameter of function with '{t}' calling convention must be a {d}-bit integer", .{ cc, err_code_size }),
+                else => return sema.fail(block, param_src, "'{t}' calling convention supports up to 2 parameters, found {d}", .{ cc, param_idx + 1 }),
             }
         },
         .arc_interrupt,
@@ -8812,7 +8822,7 @@ fn checkParamTypeCommon(
         .m68k_interrupt,
         .msp430_interrupt,
         .avr_signal,
-        => return sema.fail(block, param_src, "parameters are not allowed with '{s}' calling convention", .{@tagName(cc)}),
+        => return sema.fail(block, param_src, "parameters are not allowed with '{t}' calling convention", .{cc}),
         else => {},
     }
     if (param_is_noalias and !param_ty.isGenericPoison() and !param_ty.isPtrAtRuntime(zcu) and !param_ty.isSliceAtRuntime(zcu)) {
@@ -8820,7 +8830,7 @@ fn checkParamTypeCommon(
     }
 }
 
-fn checkReturnTypeAndCallConvCommon(
+fn checkReturnTypeAndCallConv(
     sema: *Sema,
     block: *Block,
     bare_ret_ty: Type,
@@ -8834,7 +8844,6 @@ fn checkReturnTypeAndCallConvCommon(
 ) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const gpa = zcu.gpa;
     if (opt_varargs_src) |varargs_src| {
         try sema.checkCallConvSupportsVarArgs(block, varargs_src, @"callconv");
     }
@@ -8848,21 +8857,14 @@ fn checkReturnTypeAndCallConvCommon(
             opaque_str, ies_ret_ty_prefix, bare_ret_ty.fmt(pt),
         });
     }
-    if (!bare_ret_ty.isGenericPoison() and
-        !target_util.fnCallConvAllowsZigTypes(@"callconv") and
-        (inferred_error_set or !bare_ret_ty.validateExtern(.ret_ty, zcu)))
-    {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(ret_ty_src, "return type '{s}{f}' not allowed in function with calling convention '{s}'", .{
-                ies_ret_ty_prefix, bare_ret_ty.fmt(pt), @tagName(@"callconv"),
-            });
-            errdefer msg.destroy(gpa);
-            if (!inferred_error_set) {
-                try sema.explainWhyTypeIsNotExtern(msg, ret_ty_src, bare_ret_ty, .ret_ty);
-                try sema.addDeclaredHereNote(msg, bare_ret_ty);
-            }
-            break :msg msg;
-        });
+    if (!target_util.fnCallConvAllowsZigTypes(@"callconv")) {
+        if (inferred_error_set) {
+            return sema.fail(block, ret_ty_src, "return type '!{f}' not allowed in function with calling convention '{t}'", .{ bare_ret_ty.fmt(pt), @"callconv" });
+        }
+        if (bare_ret_ty.isGenericPoison()) {
+            return sema.fail(block, ret_ty_src, "generic return type not allowed in function with calling convention '{t}'", .{@"callconv"});
+        }
+        // The `validateExtern` check happens later, in `validateResolvedFuncType`.
     }
     validate_incoming_stack_align: {
         const a: u64 = switch (@"callconv") {
@@ -8897,7 +8899,7 @@ fn checkReturnTypeAndCallConvCommon(
                 else => false,
             };
             if (!ret_ok) {
-                return sema.fail(block, ret_ty_src, "function with calling convention '{s}' must return 'void' or 'noreturn'", .{@tagName(@"callconv")});
+                return sema.fail(block, ret_ty_src, "function with calling convention '{t}' must return 'void' or 'noreturn'", .{@"callconv"});
             }
         },
         .@"inline" => if (is_noinline) {
@@ -8918,18 +8920,76 @@ fn checkReturnTypeAndCallConvCommon(
                     }
                 }
             };
-            return sema.fail(block, callconv_src, "calling convention '{s}' only available on architectures {f}", .{
-                @tagName(@"callconv"),
-                ArchListFormatter{ .archs = allowed_archs },
+            return sema.fail(block, callconv_src, "calling convention '{t}' only available on architectures {f}", .{
+                @"callconv", ArchListFormatter{ .archs = allowed_archs },
             });
         },
-        .bad_backend => |bad_backend| return sema.fail(block, callconv_src, "calling convention '{s}' not supported by compiler backend '{s}'", .{
-            @tagName(@"callconv"),
-            @tagName(bad_backend),
+        .bad_backend => |bad_backend| return sema.fail(block, callconv_src, "calling convention '{t}' not supported by compiler backend '{t}'", .{
+            @"callconv", bad_backend,
         }),
     }
 }
 
+/// To avoid forcing type layout resolution too quickly, some validation of function types cannot be
+/// performed when the type is first constructed, and instead must happen when either (a) a function
+/// with that type is declared, or (b) a function with that type is called. That validation is
+/// handled here.
+///
+/// Asserts that all parameter types and return types have their layout fully resolved.
+fn validateResolvedFuncType(
+    sema: *Sema,
+    block: *Block,
+    @"callconv": std.builtin.CallingConvention,
+    param_types: []const InternPool.Index,
+    ret_ty: Type,
+    src: LazySrcLoc,
+    maybe_func_decl_inst: ?InternPool.TrackedInst.Index,
+) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const gpa = zcu.comp.gpa;
+    if (!target_util.fnCallConvAllowsZigTypes(@"callconv")) {
+        // Check that all parameter types are extern-compatible.
+        for (param_types, 0..) |param_ty_ip, param_index| {
+            const param_ty: Type = .fromInterned(param_ty_ip);
+            if (!param_ty.validateExtern(.param_ty, zcu)) {
+                const param_src: LazySrcLoc = if (maybe_func_decl_inst) |inst| .{
+                    .base_node_inst = inst,
+                    .offset = .{ .fn_proto_param = .{
+                        .fn_proto_node_offset = .zero,
+                        .param_index = @intCast(param_index),
+                    } },
+                } else src;
+                return sema.failWithOwnedErrorMsg(block, msg: {
+                    const msg = try sema.errMsg(param_src, "parameter of type '{f}' not allowed in function with calling convention '{t}'", .{
+                        param_ty.fmt(pt), @"callconv",
+                    });
+                    errdefer msg.destroy(gpa);
+                    try sema.explainWhyTypeIsNotExtern(msg, param_src, param_ty, .param_ty);
+                    try sema.addDeclaredHereNote(msg, param_ty);
+                    break :msg msg;
+                });
+            }
+        }
+        // Check that the return type is extern-compatible.
+        if (!ret_ty.validateExtern(.ret_ty, zcu)) {
+            const ret_ty_src: LazySrcLoc = if (maybe_func_decl_inst) |inst| .{
+                .base_node_inst = inst,
+                .offset = .{ .node_offset_fn_type_ret_ty = .zero },
+            } else src;
+            return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(ret_ty_src, "return type '{f}' not allowed in function with calling convention '{t}'", .{
+                    ret_ty.fmt(pt), @"callconv",
+                });
+                errdefer msg.destroy(gpa);
+                try sema.explainWhyTypeIsNotExtern(msg, ret_ty_src, ret_ty, .ret_ty);
+                try sema.addDeclaredHereNote(msg, ret_ty);
+                break :msg msg;
+            });
+        }
+    }
+}
+
 fn callConvIsCallable(cc: std.builtin.CallingConvention.Tag) bool {
     return switch (cc) {
         .naked,
@@ -9022,6 +9082,7 @@ fn funcCommon(
     const io = comp.io;
     const ip = &zcu.intern_pool;
 
+    const src = block.nodeOffset(src_node_offset);
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = src_node_offset });
     const cc_src = block.src(.{ .node_offset_fn_type_cc = src_node_offset });
 
@@ -9036,27 +9097,21 @@ fn funcCommon(
             .fn_proto_node_offset = src_node_offset,
             .param_index = @intCast(i),
         } });
-        const param_ty_generic = param_ty.isGenericPoison();
         if (param_is_comptime) {
             comptime_bits |= @as(u32, 1) << @intCast(i); // TODO: handle cast error
         }
-        if (param_is_comptime and !target_util.fnCallConvAllowsZigTypes(cc)) {
-            return sema.fail(block, param_src, "comptime parameters not allowed in function with calling convention '{s}'", .{@tagName(cc)});
-        }
-        if (param_ty_generic and !target_util.fnCallConvAllowsZigTypes(cc)) {
-            return sema.fail(block, param_src, "generic parameters not allowed in function with calling convention '{s}'", .{@tagName(cc)});
-        }
-        try sema.checkParamTypeCommon(
+        try sema.checkParamType(
             block,
             @intCast(i),
             param_ty,
+            param_is_comptime,
             is_noalias,
             param_src,
             cc,
         );
     }
 
-    try sema.checkReturnTypeAndCallConvCommon(
+    try sema.checkReturnTypeAndCallConv(
         block,
         bare_return_type,
         ret_ty_src,
@@ -9072,9 +9127,29 @@ fn funcCommon(
 
     const param_types = block.params.items(.ty);
 
+    if (has_body) {
+        for (param_types, 0..) |param_ty_ip, param_index| {
+            const param_ty: Type = .fromInterned(param_ty_ip);
+            const param_src = block.src(.{ .fn_proto_param = .{
+                .fn_proto_node_offset = src_node_offset,
+                .param_index = @intCast(param_index),
+            } });
+            try sema.ensureLayoutResolved(param_ty, param_src, .parameter);
+        }
+        try sema.ensureLayoutResolved(bare_return_type, ret_ty_src, .return_type);
+        try sema.validateResolvedFuncType(
+            block,
+            cc,
+            param_types,
+            bare_return_type,
+            src,
+            ip.getNav(sema.owner.unwrap().nav_val).srcInst(ip),
+        );
+    }
+
     if (inferred_error_set) {
         assert(has_body);
-        const func_val: Value = .fromInterned(try ip.getFuncDeclIes(gpa, io, pt.tid, .{
+        return .fromIntern(try ip.getFuncDeclIes(gpa, io, pt.tid, .{
             .owner_nav = sema.owner.unwrap().nav_val,
 
             .param_types = param_types,
@@ -9091,8 +9166,6 @@ fn funcCommon(
             .lbrace_column = @as(u16, @truncate(src_locs.columns)),
             .rbrace_column = @as(u16, @truncate(src_locs.columns >> 16)),
         }));
-        try sema.ensureLayoutResolved(func_val.typeOf(zcu), ret_ty_src, .return_type);
-        return .fromValue(func_val);
     }
 
     const func_ty = try ip.getFuncType(gpa, io, pt.tid, .{
@@ -9106,7 +9179,6 @@ fn funcCommon(
     });
 
     if (has_body) {
-        try sema.ensureLayoutResolved(.fromInterned(func_ty), ret_ty_src, .return_type);
         return .fromIntern(try ip.getFuncDecl(gpa, io, pt.tid, .{
             .owner_nav = sema.owner.unwrap().nav_val,
             .ty = func_ty,
@@ -18256,19 +18328,6 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         }
     } else if (inst_data.size != .one and elem_ty.zigTypeTag(zcu) == .@"opaque") {
         return sema.fail(block, elem_ty_src, "indexable pointer to opaque type '{f}' not allowed", .{elem_ty.fmt(pt)});
-    } else if (inst_data.size == .c) {
-        if (!elem_ty.validateExtern(.other, zcu)) {
-            const msg = msg: {
-                const msg = try sema.errMsg(elem_ty_src, "C pointers cannot point to non-C-ABI-compatible type '{f}'", .{elem_ty.fmt(pt)});
-                errdefer msg.destroy(sema.gpa);
-
-                try sema.explainWhyTypeIsNotExtern(msg, elem_ty_src, elem_ty, .other);
-
-                try sema.addDeclaredHereNote(msg, elem_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(block, msg);
-        }
     }
 
     if (host_size != 0) {
@@ -19800,16 +19859,6 @@ fn zirReifyPointer(
         else => {},
     }
 
-    if (size == .c and !elem_ty.validateExtern(.other, zcu)) {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(src, "C pointers cannot point to non-C-ABI-compatible type '{f}'", .{elem_ty.fmt(pt)});
-            errdefer msg.destroy(gpa);
-            try sema.explainWhyTypeIsNotExtern(msg, elem_ty_src, elem_ty, .other);
-            try sema.addDeclaredHereNote(msg, elem_ty);
-            break :msg msg;
-        });
-    }
-
     const sentinel_ty = try pt.optionalType(elem_ty.toIntern());
     const sentinel_uncoerced = sema.resolveInst(extra.sentinel);
     const sentinel_coerced = try sema.coerce(block, sentinel_ty, sentinel_uncoerced, sentinel_src);
@@ -19898,10 +19947,11 @@ fn zirReifyFn(
             try param_attrs_arr.elemValue(pt, param_idx),
             std.builtin.Type.Fn.Param.Attributes,
         );
-        try sema.checkParamTypeCommon(
+        try sema.checkParamType(
             block,
             @intCast(param_idx),
             param_ty,
+            false,
             param_attrs.@"noalias",
             param_types_src,
             fn_attrs.@"callconv",
@@ -19919,7 +19969,7 @@ fn zirReifyFn(
         try sema.checkCallConvSupportsVarArgs(block, fn_attrs_src, fn_attrs.@"callconv");
     }
 
-    try sema.checkReturnTypeAndCallConvCommon(
+    try sema.checkReturnTypeAndCallConv(
         block,
         ret_ty,
         ret_ty_src,
@@ -19929,9 +19979,6 @@ fn zirReifyFn(
         false,
         false,
     );
-    if (ret_ty.comptimeOnly(zcu)) {
-        return sema.fail(block, param_attrs_src, "cannot reify function type with comptime-only return type '{f}'", .{ret_ty.fmt(pt)});
-    }
 
     return .fromIntern(try ip.getFuncType(gpa, io, pt.tid, .{
         .param_types = param_types_ip,
@@ -20615,7 +20662,7 @@ fn zirCVaArg(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
 
     const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.lhs);
     const arg_ty = try sema.resolveType(block, ty_src, extra.rhs);
-
+    try sema.ensureLayoutResolved(arg_ty, ty_src, .parameter);
     if (!arg_ty.validateExtern(.param_ty, sema.pt.zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(ty_src, "cannot get '{f}' from variadic argument", .{arg_ty.fmt(sema.pt)});
@@ -24639,13 +24686,12 @@ fn zirBuiltinExtern(
         return sema.fail(block, ty_src, "expected (optional) pointer", .{});
     }
     if (!ty.validateExtern(.other, zcu)) {
-        const msg = msg: {
+        return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(ty_src, "extern symbol cannot have type '{f}'", .{ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
             try sema.explainWhyTypeIsNotExtern(msg, ty_src, ty, .other);
             break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(block, msg);
+        });
     }
 
     const options = try sema.resolveExternOptions(block, options_src, extra.rhs);
@@ -25034,7 +25080,7 @@ pub fn explainWhyTypeIsNotExtern(
     src_loc: LazySrcLoc,
     ty: Type,
     position: Type.ExternPosition,
-) CompileError!void {
+) SemaError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     switch (ty.zigTypeTag(zcu)) {
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 089ad64e254f28fc638980bf7c4533f95a8d9ec0..b3413ade051c6d1672117644e61ebf9397e7ee94 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -32,6 +32,7 @@ pub const LayoutResolveReason = enum {
     type_info,
     align_check,
     bit_ptr_child,
+    @"export",
     builtin_type,
 
     /// Written after string: "while resolving type 'T' "
@@ -56,6 +57,7 @@ pub const LayoutResolveReason = enum {
             .type_info     => "for type information query here",
             .align_check   => "for alignment check here",
             .bit_ptr_child => "for bit size check here",
+            .@"export"     => "for export here",
             .builtin_type  => "from 'std.builtin'",
             // zig fmt: on
         };
@@ -276,7 +278,6 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         assert(!field_ty.isGenericPoison());
         const field_ty_src = block.src(.{ .container_field_type = @intCast(field_index) });
         try sema.ensureLayoutResolved(field_ty, field_ty_src, .field);
-
         if (field_ty.zigTypeTag(zcu) == .@"opaque") {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "cannot directly embed opaque type '{f}' in struct", .{field_ty.fmt(pt)});
@@ -286,7 +287,6 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 break :msg msg;
             });
         }
-
         if (struct_obj.layout == .@"extern" and !field_ty.validateExtern(.struct_field, zcu)) {
             return sema.failWithOwnedErrorMsg(&block, msg: {
                 const msg = try sema.errMsg(field_ty_src, "extern structs cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
diff --git a/src/Type.zig b/src/Type.zig
index 234850376558acefd34b85a0ed43285945c6f60d..8c67ea975958712554e1711e3e9e409f745e91f5 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -3055,9 +3055,10 @@ pub const ExternPosition = enum {
 };
 
 /// Returns true if `ty` is allowed in extern types.
-/// Does not require `ty` to be resolved in any way.
+/// Asserts that `ty` is fully resolved.
 /// Keep in sync with `Sema.explainWhyTypeIsNotExtern`.
 pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool {
+    ty.assertHasLayout(zcu);
     return switch (ty.zigTypeTag(zcu)) {
         .type,
         .comptime_float,
-- 
2.54.0


From 8d8140349fe2ea3197f8eea71cc120a0e8fa08d8 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 9 Feb 2026 10:39:31 +0000
Subject: [PATCH 448/499] simple little no-objection src/Type.zig correction

---
 src/Type.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Type.zig b/src/Type.zig
index 8c67ea975958712554e1711e3e9e409f745e91f5..d7fffdf45a79df551d0ff9581e9de2646e90cc9e 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -2853,7 +2853,7 @@ pub fn fieldPtrType(ptr_ty: Type, field_index: u32, pt: Zcu.PerThread) Allocator
                     else => parent_align.minStrict(.fromLog2Units(@ctz(field_offset))),
                 };
                 const field_ptr_align: Alignment = a: {
-                    if (parent_align == .none and
+                    if (ptr_info.flags.alignment == .none and
                         aggregate_ty.explicitFieldAlignment(field_index, zcu) == .none and
                         actual_field_align == field_ty.abiAlignment(zcu))
                     {
-- 
2.54.0


From 09d0b1f87a740e968ef739e75729204ff470c98a Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 9 Feb 2026 10:41:56 +0000
Subject: [PATCH 449/499] behavior: misc fixes

They compile now! They don't *pass*, but they *compile*!
---
 test/behavior/align.zig         | 22 +++++++++++++++-------
 test/behavior/bitcast.zig       |  3 ---
 test/behavior/call.zig          | 11 +++++------
 test/behavior/eval.zig          |  7 -------
 test/behavior/packed-struct.zig |  2 +-
 test/behavior/switch.zig        | 11 +++++------
 6 files changed, 26 insertions(+), 30 deletions(-)

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index b971c78596d2ef0811c8041fa199d9d387492ed3..2cbde2d56c7a72f770b6dc6d9915df05bb81f1d1 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -307,11 +307,15 @@ test "runtime-known array index has best alignment possible" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     // take full advantage of over-alignment
-    var array align(4) = [_]u8{ 1, 2, 3, 4 };
+    var array align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
     comptime assert(@TypeOf(&array[0]) == *align(4) u8);
-    comptime assert(@TypeOf(&array[1]) == *u8);
+    comptime assert(@TypeOf(&array[1]) == *align(1) u8);
     comptime assert(@TypeOf(&array[2]) == *align(2) u8);
-    comptime assert(@TypeOf(&array[3]) == *u8);
+    comptime assert(@TypeOf(&array[3]) == *align(1) u8);
+    comptime assert(@TypeOf(&array[4]) == *align(4) u8);
+    comptime assert(@TypeOf(&array[5]) == *align(1) u8);
+    comptime assert(@TypeOf(&array[6]) == *align(2) u8);
+    comptime assert(@TypeOf(&array[7]) == *align(1) u8);
 
     // because align is too small but we still figure out to use 2
     var bigger align(2) = [_]u64{ 1, 2, 3, 4 };
@@ -332,10 +336,14 @@ test "runtime-known array index has best alignment possible" {
     try testIndex(smaller[runtime_zero..].ptr, 3, *align(2) u32);
 
     // has to use ABI alignment because index known at runtime only
-    try testIndex2(&array, 0, *u8);
-    try testIndex2(&array, 1, *u8);
-    try testIndex2(&array, 2, *u8);
-    try testIndex2(&array, 3, *u8);
+    try testIndex2(&array, 0, *align(1) u8);
+    try testIndex2(&array, 1, *align(1) u8);
+    try testIndex2(&array, 2, *align(1) u8);
+    try testIndex2(&array, 3, *align(1) u8);
+    try testIndex2(&array, 4, *align(1) u8);
+    try testIndex2(&array, 5, *align(1) u8);
+    try testIndex2(&array, 6, *align(1) u8);
+    try testIndex2(&array, 7, *align(1) u8);
 }
 fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) !void {
     comptime assert(@TypeOf(&smaller[index]) == T);
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 90d185c63f52d6c013564f629d61ba9cdbbc202f..910356e3608f50f60873d7e565f027c5dce041ed 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -350,9 +350,6 @@ test "comptime @bitCast packed struct to int and back" {
         iint_neg2: i3 = -2,
         float: f32 = 3.14,
         @"enum": enum(u2) { A, B = 1, C, D } = .B,
-        vectorb: @Vector(3, bool) = .{ true, false, true },
-        vectori: @Vector(2, u8) = .{ 127, 42 },
-        vectorf: @Vector(2, f16) = .{ 3.14, 2.71 },
     };
     const Int = @typeInfo(S).@"struct".backing_integer.?;
 
diff --git a/test/behavior/call.zig b/test/behavior/call.zig
index 3433cc59712750f434f33f9112c68846126020e0..fd134499439cc8fd647aac316e5f2e6f3e2de910 100644
--- a/test/behavior/call.zig
+++ b/test/behavior/call.zig
@@ -551,19 +551,18 @@ test "generic function pointer can be called" {
 
 test "value returned from comptime function is comptime known" {
     const S = struct {
-        fn fields(comptime T: type) switch (@typeInfo(T)) {
-            .@"struct" => []const std.builtin.Type.StructField,
+        fn fieldCount(comptime T: type) switch (@typeInfo(T)) {
+            .@"struct" => comptime_int,
             else => unreachable,
         } {
             return switch (@typeInfo(T)) {
-                .@"struct" => |info| info.fields,
+                .@"struct" => |info| info.fields.len,
                 else => unreachable,
             };
         }
     };
-    const fields_list = S.fields(@TypeOf(.{}));
-    if (fields_list.len != 0)
-        @compileError("Argument count mismatch");
+    const fields_len = S.fieldCount(@TypeOf(.{}));
+    comptime assert(fields_len == 0);
 }
 
 test "registers get overwritten when ignoring return" {
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 9e3cd732f0e3b41152fbbb51732283bbe9c07192..03550fef70d73da7b334842a25ed383d8867cc8b 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -719,13 +719,6 @@ fn testVarInsideInlineLoop(args: anytype) !void {
     }
 }
 
-test "*align(1) u16 is the same as *align(1:0:2) u16" {
-    comptime {
-        try expect(*align(1:0:2) u16 == *align(1) u16);
-        try expect(*align(2:0:2) u16 == *u16);
-    }
-}
-
 test "array concatenation of function calls" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 1b019acb7243acaa2ccb0896b766666fabd6e83f..d5b01f7c12f71ac5e88976a4d50587ffc460a857 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -820,7 +820,7 @@ test "packed struct passed to callconv(.c) function" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
-        const Packed = packed struct {
+        const Packed = packed struct(u64) {
             a: u16,
             b: bool = true,
             c: bool = true,
diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig
index 316421ea3603c98f9a6313ca3c9f60a39a5302f7..784305bca786a054dd19d32fa97f58087635818f 100644
--- a/test/behavior/switch.zig
+++ b/test/behavior/switch.zig
@@ -645,7 +645,7 @@ test "switch prong pointer capture alignment" {
             }
 
             switch (u) {
-                .a, .c => |*p| comptime assert(@TypeOf(p) == *const u8),
+                .a, .c => |*p| comptime assert(@TypeOf(p) == *align(1) const u8),
                 .b => |*p| {
                     _ = p;
                     return error.TestFailed;
@@ -1141,24 +1141,23 @@ test "decl literals as switch cases" {
     try comptime E.doTheTest(.foo);
 }
 
-// TODO audit after #15909 and/or #19855 are decided/implemented
+// TODO audit after #15909 and/or #19855 are decided/implemented.
+// When we do that, consider adding an 'error{}' case if possible.
 test "switch with uninstantiable union fields" {
     const U = union(enum) {
         ok: void,
         a: noreturn,
         b: noreturn,
-        c: error{},
 
         fn doTheTest(u: @This()) void {
             switch (u) {
                 .ok => {},
                 .a => comptime unreachable,
                 .b => comptime unreachable,
-                .c => comptime unreachable,
             }
             switch (u) {
                 .ok => {},
-                .a, .b, .c => comptime unreachable,
+                .a, .b => comptime unreachable,
             }
             switch (u) {
                 .ok => {},
@@ -1166,7 +1165,7 @@ test "switch with uninstantiable union fields" {
             }
             switch (u) {
                 .a => comptime unreachable,
-                .ok, .b, .c => {},
+                .ok, .b => {},
             }
         }
     };
-- 
2.54.0


From b00ef1aea1a456ad8b175534add8bb324cb39bba Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 9 Feb 2026 11:23:46 +0000
Subject: [PATCH 450/499] Zcu: prevent data races from `Type.assertHasLayout`

---
 src/Type.zig          | 12 ++----
 src/Zcu.zig           | 87 +++++++++++++++++++++++++++++++++++++++----
 src/Zcu/PerThread.zig | 34 +++++------------
 3 files changed, 91 insertions(+), 42 deletions(-)

diff --git a/src/Type.zig b/src/Type.zig
index d7fffdf45a79df551d0ff9581e9de2646e90cc9e..0fe87e983b065cb43124eb1b6adc5b7c0a4888cd 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -3175,21 +3175,15 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
         },
         .struct_type => {
             assert(zcu.intern_pool.loadStructType(ty.toIntern()).want_layout);
-            const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
-            assert(!zcu.outdated.contains(unit));
-            assert(!zcu.potentially_outdated.contains(unit));
+            zcu.assertUpToDate(.wrap(.{ .type_layout = ty.toIntern() }));
         },
         .union_type => {
             assert(zcu.intern_pool.loadUnionType(ty.toIntern()).want_layout);
-            const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
-            assert(!zcu.outdated.contains(unit));
-            assert(!zcu.potentially_outdated.contains(unit));
+            zcu.assertUpToDate(.wrap(.{ .type_layout = ty.toIntern() }));
         },
         .enum_type => {
             assert(zcu.intern_pool.loadEnumType(ty.toIntern()).want_layout);
-            const unit: InternPool.AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
-            assert(!zcu.outdated.contains(unit));
-            assert(!zcu.potentially_outdated.contains(unit));
+            zcu.assertUpToDate(.wrap(.{ .type_layout = ty.toIntern() }));
         },
 
         // values, not types
diff --git a/src/Zcu.zig b/src/Zcu.zig
index fc770ba4ea1924d34d238e8bb13fd3107332a1ec..4e48ff694602c4fb3833e9b133279aea76aa588d 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -264,6 +264,10 @@ cimport_errors: std.AutoArrayHashMapUnmanaged(AnalUnit, std.zig.ErrorBundle) = .
 /// Maximum amount of distinct error values, set by --error-limit
 error_limit: ErrorInt,
 
+/// In safe builds, `Type.assertHasLayout` may be called cross-thread, so this lock
+/// guards accesses to `outdated` and `potentially_outdated`. In unsafe builds, the
+/// lock is not needed and is compiled out.
+outdated_lock: if (std.debug.runtime_safety) std.Io.RwLock else void = if (std.debug.runtime_safety) .init,
 /// Value is the number of PO dependencies of this AnalUnit.
 /// This value will decrease as we perform semantic analysis to learn what is outdated.
 /// If any of these PO deps is outdated, this value will be moved to `outdated`.
@@ -3063,6 +3067,8 @@ pub fn markDependeeOutdated(
 ) !void {
     deps_log.debug("outdated dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = zcu.intern_pool.dependencyIterator(dependee);
+    if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
+    defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
     while (it.next()) |depender| {
         if (zcu.outdated.getPtr(depender)) |po_dep_count| {
             switch (marked_po) {
@@ -3107,6 +3113,12 @@ pub fn markDependeeOutdated(
 }
 
 pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
+    if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
+    defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
+    return markPoDependeeUpToDateInner(zcu, dependee);
+}
+/// Assumes that `zcu.outdated_lock` is already held exclusively.
+fn markPoDependeeUpToDateInner(zcu: *Zcu, dependee: InternPool.Dependee) !void {
     deps_log.debug("up-to-date dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = zcu.intern_pool.dependencyIterator(dependee);
     while (it.next()) |depender| {
@@ -3142,17 +3154,19 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
         // as no longer PO.
         switch (depender.unwrap()) {
             .@"comptime" => {},
-            .nav_val => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_val = nav }),
-            .nav_ty => |nav| try zcu.markPoDependeeUpToDate(.{ .nav_ty = nav }),
-            .type_layout => |ty| try zcu.markPoDependeeUpToDate(.{ .type_layout = ty }),
-            .func => |func| try zcu.markPoDependeeUpToDate(.{ .func_ies = func }),
-            .memoized_state => |stage| try zcu.markPoDependeeUpToDate(.{ .memoized_state = stage }),
+            .nav_val => |nav| try zcu.markPoDependeeUpToDateInner(.{ .nav_val = nav }),
+            .nav_ty => |nav| try zcu.markPoDependeeUpToDateInner(.{ .nav_ty = nav }),
+            .type_layout => |ty| try zcu.markPoDependeeUpToDateInner(.{ .type_layout = ty }),
+            .func => |func| try zcu.markPoDependeeUpToDateInner(.{ .func_ies = func }),
+            .memoized_state => |stage| try zcu.markPoDependeeUpToDateInner(.{ .memoized_state = stage }),
         }
     }
 }
 
 /// Given a AnalUnit which is newly outdated or PO, mark all AnalUnits which may
 /// in turn be PO, due to a dependency on the original AnalUnit's tyval or IES.
+///
+/// Assumes that `zcu.outdated_lock` is already held exclusively.
 fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUnit) !void {
     const ip = &zcu.intern_pool;
     const dependee: InternPool.Dependee = switch (maybe_outdated.unwrap()) {
@@ -3211,6 +3225,9 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
     // possible situation is a cycle where everything is actually up-to-date, so we can clear out
     // `zcu.potentially_outdated` and we are done.
 
+    if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
+    defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
+
     if (zcu.outdated.count() == 0) {
         // Everything is up-to-date. There could be lingering entries in `zcu.potentially_outdated`
         // from a dependency loop on a previous update.
@@ -3230,7 +3247,10 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
 /// During an incremental update, before semantic analysis, call this to flush all values from
 /// `retryable_failures` and mark them as outdated so they get re-analyzed.
 pub fn flushRetryableFailures(zcu: *Zcu) !void {
-    const gpa = zcu.gpa;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(comp.io);
+    defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(comp.io);
     for (zcu.retryable_failures.items) |depender| {
         if (zcu.outdated.contains(depender)) continue;
         if (zcu.potentially_outdated.fetchSwapRemove(depender)) |kv| {
@@ -3481,8 +3501,12 @@ pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func: InternPool.Index) !void {
     if (ip.setWantRuntimeFnAnalysis(io, func)) {
         // This is the first reference to this function, so we must ensure it will be analyzed.
         const unit: AnalUnit = .wrap(.{ .func = func });
-        try zcu.outdated.putNoClobber(gpa, unit, 0);
-        try zcu.outdated_ready.putNoClobber(gpa, unit, {});
+        if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
+        defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
+        try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+        try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+        zcu.outdated.putAssumeCapacityNoClobber(unit, 0);
+        zcu.outdated_ready.putAssumeCapacityNoClobber(unit, {});
     }
 }
 
@@ -3493,6 +3517,8 @@ pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav: InternPool.Nav.Index) !void {
     const ip = &zcu.intern_pool;
     if (ip.setWantNavAnalysis(io, nav)) {
         // This is the first reference to this function, so we must ensure it will be analyzed.
+        if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
+        defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
         try zcu.outdated.ensureUnusedCapacity(gpa, 2);
         try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
         zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .nav_val = nav }), 0);
@@ -3502,6 +3528,51 @@ pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav: InternPool.Nav.Index) !void {
     }
 }
 
+/// Called when an `InternPool.ComptimeUnit` is first created to mark it as outdated so that it will
+/// be semantically analyzed.
+pub fn queueComptimeUnitAnalysis(zcu: *Zcu, cu: InternPool.ComptimeUnit.Id) Allocator.Error!void {
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+    const unit: AnalUnit = .wrap(.{ .@"comptime" = cu });
+    if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(io);
+    defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(io);
+    try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+    zcu.outdated.putAssumeCapacityNoClobber(unit, 0);
+    zcu.outdated_ready.putAssumeCapacityNoClobber(unit, {});
+}
+
+/// If `unit` was marked as outdated or porentially outdated, clears that status and returns `true`.
+/// Otherwise, returns `false`.
+pub fn clearOutdatedState(zcu: *Zcu, unit: AnalUnit) bool {
+    const io = zcu.comp.io;
+    if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(io);
+    defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(io);
+    if (zcu.outdated.fetchSwapRemove(unit)) |kv| {
+        if (kv.value == 0) assert(zcu.outdated_ready.swapRemove(unit));
+        return true;
+    } else if (zcu.potentially_outdated.swapRemove(unit)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/// This function takes a `*const Zcu` and `@constCast`s it so that it can be called from functions
+/// in `Type` which otherwise do not modify the `Zcu`.
+pub fn assertUpToDate(zcu: *const Zcu, unit: AnalUnit) void {
+    if (!std.debug.runtime_safety) return;
+
+    const io = zcu.comp.io;
+
+    @constCast(zcu).outdated_lock.lockSharedUncancelable(io);
+    defer @constCast(zcu).outdated_lock.unlockShared(io);
+
+    assert(!zcu.outdated.contains(unit));
+    assert(!zcu.potentially_outdated.contains(unit));
+}
+
 pub const ImportResult = struct {
     /// Whether `file` has been newly created; in other words, whether this is the first import of
     /// this file. This should only be `true` when importing files during AstGen. After that, all
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index b9ad8f3dfdd1375df0606f538d6ecdeb72abec82..194b6fd283a8f33755c3a83c4494bb9363d7b794 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -746,12 +746,11 @@ pub fn ensureMemoizedStateUpToDate(
 
     assert(!zcu.analysis_in_progress.contains(unit));
 
-    const was_outdated = zcu.outdated.swapRemove(unit) or zcu.potentially_outdated.swapRemove(unit);
+    const was_outdated = zcu.clearOutdatedState(unit);
     const prev_failed = zcu.failed_analysis.contains(unit) or zcu.transitive_failed_analysis.contains(unit);
 
     if (was_outdated) {
         dev.check(.incremental);
-        _ = zcu.outdated_ready.swapRemove(unit);
         zcu.resetUnit(unit);
     } else {
         if (prev_failed) return error.AnalysisFail;
@@ -866,11 +865,9 @@ pub fn ensureComptimeUnitUpToDate(pt: Zcu.PerThread, cu_id: InternPool.ComptimeU
     // result in over-analysis if analysis occurs in a poor order; we do our best to avoid this by
     // carefully choosing which units to re-analyze. See `Zcu.findOutdatedToAnalyze`.
 
-    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
+    const was_outdated = zcu.clearOutdatedState(anal_unit);
 
     if (was_outdated) {
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
         // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
             zcu.resetUnit(anal_unit);
@@ -1023,12 +1020,10 @@ pub fn ensureTypeLayoutUpToDate(
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
-    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit) or
+    const was_outdated = zcu.clearOutdatedState(anal_unit) or
         zcu.intern_pool.setWantTypeLayout(zcu.comp.io, ty.toIntern());
 
     if (was_outdated) {
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
         // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
         if (dev.env.supports(.incremental)) {
             zcu.resetUnit(anal_unit);
@@ -1139,15 +1134,13 @@ pub fn ensureNavValUpToDate(
     // result in over-analysis if analysis occurs in a poor order; we do our best to avoid this by
     // carefully choosing which units to re-analyze. See `Zcu.findOutdatedToAnalyze`.
 
-    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
+    const was_outdated = zcu.clearOutdatedState(anal_unit);
 
     const prev_failed = zcu.failed_analysis.contains(anal_unit) or
         zcu.transitive_failed_analysis.contains(anal_unit);
 
     if (was_outdated) {
         dev.check(.incremental);
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
@@ -1497,15 +1490,13 @@ pub fn ensureNavTypeUpToDate(
     // result in over-analysis if analysis occurs in a poor order; we do our best to avoid this by
     // carefully choosing which units to re-analyze. See `Zcu.findOutdatedToAnalyze`.
 
-    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit);
+    const was_outdated = zcu.clearOutdatedState(anal_unit);
 
     const prev_failed = zcu.failed_analysis.contains(anal_unit) or
         zcu.transitive_failed_analysis.contains(anal_unit);
 
     if (was_outdated) {
         dev.check(.incremental);
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
@@ -1733,15 +1724,13 @@ pub fn ensureFuncBodyUpToDate(
 
     assert(func.ty == func.uncoerced_ty); // analyze the body of the original function, not a coerced one
 
-    const was_outdated = zcu.outdated.swapRemove(anal_unit) or
-        zcu.potentially_outdated.swapRemove(anal_unit) or
+    const was_outdated = zcu.clearOutdatedState(anal_unit) or
         ip.setWantRuntimeFnAnalysis(zcu.comp.io, func_index);
 
     const prev_failed = zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit);
 
     if (was_outdated) {
         dev.check(.incremental);
-        _ = zcu.outdated_ready.swapRemove(anal_unit);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this function.
@@ -2712,27 +2701,22 @@ const ScanDeclIter = struct {
 
         const existing_unit = iter.existing_by_inst.get(tracked_inst);
 
-        const unit, const want_analysis = switch (decl.kind) {
+        const unit: AnalUnit, const want_analysis = switch (decl.kind) {
             .@"comptime" => unit: {
                 const cu = if (existing_unit) |eu|
                     eu.unwrap().@"comptime"
                 else
                     try ip.createComptimeUnit(gpa, io, pt.tid, tracked_inst, namespace_index);
 
-                const unit: AnalUnit = .wrap(.{ .@"comptime" = cu });
-
                 try namespace.comptime_decls.append(gpa, cu);
 
                 if (existing_unit == null) {
                     // For a `comptime` declaration, whether to analyze is based solely on whether the unit
                     // is outdated. So, add this fresh one to `outdated` and `outdated_ready`.
-                    try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-                    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-                    zcu.outdated.putAssumeCapacityNoClobber(unit, 0);
-                    zcu.outdated_ready.putAssumeCapacityNoClobber(unit, {});
+                    try zcu.queueComptimeUnitAnalysis(cu);
                 }
 
-                break :unit .{ unit, true };
+                break :unit .{ .wrap(.{ .@"comptime" = cu }), true };
             },
             else => unit: {
                 const name = maybe_name.unwrap().?;
-- 
2.54.0


From 774911b4ce6c1aef44b33aee90ca341ab2fe669d Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 11 Feb 2026 14:57:23 +0000
Subject: [PATCH 451/499] behavior: small tweaks for new semantics

---
 test/behavior/align.zig    | 34 +++++++++++++++++++++++++++++++---
 test/behavior/generics.zig |  5 +----
 2 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 2cbde2d56c7a72f770b6dc6d9915df05bb81f1d1..a59bed56ba8c4e46892b25ca834cf7f45e54ec21 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -30,13 +30,41 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
     var runtime_index: usize = 1;
     _ = &runtime_index;
     const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
-    try expect(@TypeOf(slice) == []u8);
+    try expect(@TypeOf(slice) == []align(1) u8);
     try expect(slice.len == 0);
     try expect(@as(u2, @truncate(@intFromPtr(slice.ptr) - 1)) == 0);
 }
 
-test "default alignment allows unspecified in type syntax" {
-    try expect(*u32 == *align(@alignOf(u32)) u32);
+test "implicitly-aligned pointer is coercible to equivalent explicitly-aligned pointer" {
+    const A = *u32;
+    const B = *align(@alignOf(u32)) u32;
+
+    comptime assert(A != B);
+
+    const static = struct {
+        fn doTheTest() !void {
+            var buf: u32 = 123;
+
+            const ptr: A = &buf;
+            const coerced_ptr: B = ptr;
+
+            try expect(ptr == coerced_ptr);
+            try expect(ptr.* == 123);
+            try expect(coerced_ptr.* == 123);
+
+            const ptr_ptr: *const A = &ptr;
+            const coerced_ptr_ptr: *const B = ptr_ptr;
+
+            try expect(ptr_ptr == coerced_ptr_ptr);
+            try expect(ptr_ptr.* == &buf);
+            try expect(coerced_ptr_ptr.* == &buf);
+            try expect(ptr_ptr.*.* == 123);
+            try expect(coerced_ptr_ptr.*.* == 123);
+        }
+    };
+
+    try static.doTheTest();
+    try comptime static.doTheTest();
 }
 
 test "implicitly decreasing pointer alignment" {
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index 65a5a1b0070fa81c60774de2686f0b215f95f5ca..89ff5764a88bc2428ec76312e7702b6bf558fd11 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -339,7 +339,7 @@ test "generic instantiation of tagged union with only one field" {
     try expect(S.foo(.{ .s = "ab" }) == 2);
 }
 
-test "nested generic function" {
+test "generic parameter type is function type" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const S = struct {
@@ -349,10 +349,7 @@ test "nested generic function" {
         fn bar(a: u32) anyerror!void {
             try expect(a == 123);
         }
-
-        fn g(_: *const fn (anytype) void) void {}
     };
-    try expect(@typeInfo(@TypeOf(S.g)).@"fn".is_generic);
     try S.foo(u32, S.bar, 123);
 }
 
-- 
2.54.0


From 7170e0f02043d157cb4e10c6333e125c10395a63 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 11 Feb 2026 14:57:59 +0000
Subject: [PATCH 452/499] Sema: small fixes

---
 src/Sema.zig                 | 54 ++++++++++++++++++++++++------------
 src/Sema/type_resolution.zig |  4 +--
 2 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index d5aef143392ca4cceefec718c4c9acb1bbf3c7a2..81bce68e682a19a2d1895b5d2e7ce6af6c6ad820 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -15263,17 +15263,29 @@ fn analyzeArithmetic(
                 if (zir_tag != .sub) {
                     return sema.failWithInvalidPtrArithmetic(block, src, "pointer-pointer", "subtraction");
                 }
-                if (!lhs_ty.childType(zcu).eql(rhs_ty.childType(zcu), zcu)) {
+
+                // MLUGG TODO: these semantics are insane and matching them is causing my soul to fragment into a thousand pieces
+                const lhs_elem_ty = ty: {
+                    const ptr_elem_ty = lhs_ty.childType(zcu);
+                    if (lhs_ty.ptrSize(zcu) == .one and ptr_elem_ty.isArrayOrVector(zcu)) break :ty ptr_elem_ty.childType(zcu);
+                    break :ty ptr_elem_ty;
+                };
+                const rhs_elem_ty = ty: {
+                    const ptr_elem_ty = rhs_ty.childType(zcu);
+                    if (rhs_ty.ptrSize(zcu) == .one and ptr_elem_ty.isArrayOrVector(zcu)) break :ty ptr_elem_ty.childType(zcu);
+                    break :ty ptr_elem_ty;
+                };
+                if (lhs_elem_ty.toIntern() != rhs_elem_ty.toIntern()) {
                     return sema.fail(block, src, "incompatible pointer arithmetic operands '{f}' and '{f}'", .{
                         lhs_ty.fmt(pt), rhs_ty.fmt(pt),
                     });
                 }
 
-                try sema.ensureLayoutResolved(lhs_ty.childType(zcu), src, .ptr_offset);
-                const elem_size = lhs_ty.childType(zcu).abiSize(zcu);
+                try sema.ensureLayoutResolved(lhs_elem_ty, src, .ptr_offset);
+                const elem_size = lhs_elem_ty.abiSize(zcu);
                 if (elem_size == 0) {
                     return sema.fail(block, src, "pointer subtraction requires element type '{f}' to have runtime bits", .{
-                        lhs_ty.childType(zcu).fmt(pt),
+                        lhs_elem_ty.fmt(pt),
                     });
                 }
 
@@ -16293,20 +16305,24 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const func_ty_info = zcu.typeToFunc(ty).?;
             const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len);
             var func_is_generic = false;
-            for (param_vals, 0..) |*param_val, i| {
-                const param_ty = func_ty_info.param_types.get(ip)[i];
+
+            for (param_vals, 0..) |*param_val, param_index| {
+                const param_ty = func_ty_info.param_types.get(ip)[param_index];
                 const is_generic = param_ty == .generic_poison_type;
-                if (is_generic or Type.fromInterned(param_ty).comptimeOnly(zcu)) func_is_generic = true;
+                const is_noalias, const is_comptime = flags: {
+                    const i = std.math.cast(u5, param_index) orelse break :flags .{ false, false };
+                    break :flags .{ func_ty_info.paramIsNoalias(i), func_ty_info.paramIsComptime(i) };
+                };
+
+                if (is_generic or is_comptime or Type.fromInterned(param_ty).comptimeOnly(zcu)) {
+                    func_is_generic = true;
+                }
+
                 const param_ty_val = try pt.intern(.{ .opt = .{
                     .ty = try pt.intern(.{ .opt_type = .type_type }),
                     .val = if (is_generic) .none else param_ty,
                 } });
 
-                const is_noalias = blk: {
-                    const index = std.math.cast(u5, i) orelse break :blk false;
-                    break :blk @as(u1, @truncate(func_ty_info.noalias_bits >> index)) != 0;
-                };
-
                 const param_fields = .{
                     // is_generic: bool,
                     Value.makeBool(is_generic).toIntern(),
@@ -16348,15 +16364,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const ret_ty_is_generic = generic: {
                 const ret_ty: Type = .fromInterned(func_ty_info.return_type);
-                if (ret_ty.toIntern() == .generic_poison_type) break :generic true;
-                if (ret_ty.zigTypeTag(zcu) == .error_union) {
-                    if (ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type) {
-                        break :generic true;
-                    }
+                if (ret_ty.toIntern() == .generic_poison_type or
+                    (ret_ty.zigTypeTag(zcu) == .error_union and
+                        ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type))
+                {
+                    break :generic true;
                 }
                 break :generic false;
             };
-            if (ret_ty_is_generic) func_is_generic = true;
+            if (ret_ty_is_generic or Type.fromInterned(func_ty_info.return_type).comptimeOnly(zcu)) {
+                func_is_generic = true;
+            }
 
             const ret_ty_opt = try pt.intern(.{ .opt = .{
                 .ty = try pt.intern(.{ .opt_type = .type_type }),
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index b3413ade051c6d1672117644e61ebf9397e7ee94..5e4e8a4ccd84e8080f71162262560a934977b34f 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -585,8 +585,8 @@ pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
             .int_tag_mode = switch (union_obj.is_reified) {
                 true => .auto,
                 false => switch (sema.code.getUnionDecl(zir_index).kind) {
-                    .tagged_enum_explicit => .auto,
-                    else => .explicit,
+                    .tagged_enum_explicit => .explicit,
+                    else => .auto,
                 },
             },
             .fields_len = @intCast(union_obj.field_types.len),
-- 
2.54.0


From bcb1a6bdf3ef1f39784298deaf2adfb91ea5c5c1 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 11 Feb 2026 15:05:33 +0000
Subject: [PATCH 453/499] compiler: make Dwarf and self-hosted x86_64 happy

Introduces a small abstraction, `link.DebugConstPool`, to deal with
lowering type/value information into debug info when it may not be known
until type resolution (which in some cases will *never* happen). It is
currently only used by self-hosted DWARF logic, but it will also be of
use to the LLVM backend (which is my next focus).
---
 src/Compilation.zig         |   75 +-
 src/Zcu/PerThread.zig       |  492 +----------
 src/codegen.zig             |   37 +-
 src/link.zig                |   46 +-
 src/link/DebugConstPool.zig |  287 +++++++
 src/link/Dwarf.zig          | 1544 +++++++++++++++--------------------
 src/link/Elf.zig            |    3 +-
 src/link/Elf/ZigObject.zig  |    3 +-
 8 files changed, 1026 insertions(+), 1461 deletions(-)
 create mode 100644 src/link/DebugConstPool.zig

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 59fa186d82804de016b8f5c241976992b70c3174..66483ebd727709e21a586c354137269303b8cd3a 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -956,8 +956,7 @@ pub const RcSourceFile = struct {
 
 const Job = union(enum) {
     /// Given the generated AIR for a function, put it onto the code generation queue.
-    /// This `Job` exists (instead of the `link.ZcuTask` being directly queued) to ensure that
-    /// all types are resolved before the linker task is queued.
+    /// MLUGG TODO: because type resolution is no longer necessary, we can remove this now
     /// If the backend does not support `Zcu.Feature.separate_thread`, codegen and linking happen immediately.
     /// Before queueing this `Job`, increase the estimated total item count for both
     /// `comp.zcu.?.codegen_prog_node` and `comp.link_prog_node`.
@@ -967,17 +966,10 @@ const Job = union(enum) {
         air: Air,
     },
     /// Queue a `link.ZcuTask` to emit this non-function `Nav` into the output binary.
-    /// This `Job` exists (instead of the `link.ZcuTask` being directly queued) to ensure that
-    /// all types are resolved before the linker task is queued.
+    /// MLUGG TODO: because type resolution is no longer necessary, we can remove this now
     /// If the backend does not support `Zcu.Feature.separate_thread`, the task is run immediately.
     /// Before queueing this `Job`, increase the estimated total item count for `comp.link_prog_node`.
     link_nav: InternPool.Nav.Index,
-    /// Queue a `link.ZcuTask` to emit debug information for this container type.
-    /// This `Job` exists (instead of the `link.ZcuTask` being directly queued) to ensure that
-    /// all types are resolved before the linker task is queued.
-    /// If the backend does not support `Zcu.Feature.separate_thread`, the task is run immediately.
-    /// Before queueing this `Job`, increase the estimated total item count for `comp.link_prog_node`.
-    link_type: InternPool.Index,
     /// Before queueing this `Job`, increase the estimated total item count for `comp.link_prog_node`.
     update_line_number: InternPool.TrackedInst.Index,
     /// The `AnalUnit`, which is *not* a `func`, must be semantically analyzed.
@@ -5058,26 +5050,6 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
             var owned_air: ?Air = func.air;
             defer if (owned_air) |*air| air.deinit(gpa);
 
-            {
-                const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
-                defer pt.deactivate();
-                pt.resolveAirTypesForCodegen(&owned_air.?) catch |err| switch (err) {
-                    error.OutOfMemory,
-                    error.Canceled,
-                    => |e| return e,
-
-                    error.AnalysisFail => {
-                        // Type resolution failed, making codegen of this function impossible. This
-                        // is a transitive failure, but it doesn't need recording, because this
-                        // function semantically depends on the failed type, so when it is changed
-                        // the function will be updated.
-                        zcu.codegen_prog_node.completeOne();
-                        comp.link_prog_node.completeOne();
-                        return;
-                    },
-                };
-            }
-
             // Some linkers need to refer to the AIR. In that case, the linker is not running
             // concurrently, so we'll just keep ownership of the AIR for ourselves instead of
             // letting the codegen job destroy it.
@@ -5101,51 +5073,10 @@ fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!v
                 }
             }
             assert(nav.status == .fully_resolved);
-            {
-                const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
-                defer pt.deactivate();
-                pt.resolveValueTypesForCodegen(zcu.navValue(nav_index)) catch |err| switch (err) {
-                    error.OutOfMemory,
-                    error.Canceled,
-                    => |e| return e,
-
-                    error.AnalysisFail => {
-                        // Type resolution failed, making codegen of this `Nav` impossible. This is
-                        // a transitive failure, but it doesn't need recording, because this `Nav`
-                        // semantically depends on the failed type, so when it is changed the value
-                        // of the `Nav` will be updated.
-                        comp.link_prog_node.completeOne();
-                        return;
-                    },
-                };
-            }
             try comp.link_queue.enqueueZcu(comp, tid, .{ .link_nav = nav_index });
         },
-        .link_type => |ty| {
-            const zcu = comp.zcu.?;
-            if (zcu.failed_types.fetchSwapRemove(ty)) |*entry| entry.value.deinit(zcu.gpa);
-            {
-                const pt: Zcu.PerThread = .activate(zcu, @enumFromInt(tid));
-                defer pt.deactivate();
-                pt.resolveTypeForCodegen(.fromInterned(ty)) catch |err| switch (err) {
-                    error.OutOfMemory,
-                    error.Canceled,
-                    => |e| return e,
-
-                    error.AnalysisFail => {
-                        // Type resolution failed, making codegen of this type impossible. This is
-                        // a transitive failure, but it doesn't need recording, because this type
-                        // semantically depends on the failed type, so when it is changed the type
-                        // will be updated appropriately.
-                        comp.link_prog_node.completeOne();
-                        return;
-                    },
-                };
-            }
-            try comp.link_queue.enqueueZcu(comp, tid, .{ .link_type = ty });
-        },
         .update_line_number => |tracked_inst| {
-            try comp.link_queue.enqueueZcu(comp, tid, .{ .update_line_number = tracked_inst });
+            try comp.link_queue.enqueueZcu(comp, tid, .{ .debug_update_line_number = tracked_inst });
         },
         .analyze_unit => |unit| {
             const tracy_trace = traceNamed(@src(), "analyze_unit");
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 194b6fd283a8f33755c3a83c4494bb9363d7b794..babf66ee720fe48fbb8d8d46ab5cd85344229318 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -998,10 +998,10 @@ fn analyzeComptimeUnit(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu
     try sema.flushExports();
 }
 
-/// Ensures that the layout of the given `struct` or `union` type is fully up-to-date, performing
-/// re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!) or union. Returns
-/// `error.AnalysisFail` if an analysis error is encountered during type resolution; the caller is
-/// free to ignore this, since the error is already registered.
+/// Ensures that the layout of the given `struct`, `union`, or `enum` type is fully up-to-date,
+/// performing re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!), union, or
+/// enum type. Returns `error.AnalysisFail` if an analysis error is encountered during type
+/// resolution; the caller is free to ignore this, since the error is already registered.
 pub fn ensureTypeLayoutUpToDate(
     pt: Zcu.PerThread,
     ty: Type,
@@ -1012,7 +1012,8 @@ pub fn ensureTypeLayoutUpToDate(
     defer tracy.end();
 
     const zcu = pt.zcu;
-    const gpa = zcu.gpa;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
 
     const anal_unit: AnalUnit = .wrap(.{ .type_layout = ty.toIntern() });
 
@@ -1021,7 +1022,7 @@ pub fn ensureTypeLayoutUpToDate(
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
     const was_outdated = zcu.clearOutdatedState(anal_unit) or
-        zcu.intern_pool.setWantTypeLayout(zcu.comp.io, ty.toIntern());
+        zcu.intern_pool.setWantTypeLayout(comp.io, ty.toIntern());
 
     if (was_outdated) {
         // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
@@ -1038,7 +1039,7 @@ pub fn ensureTypeLayoutUpToDate(
         return;
     }
 
-    if (zcu.comp.debugIncremental()) {
+    if (comp.debugIncremental()) {
         const info = try zcu.incremental_debug_state.getUnitInfo(gpa, anal_unit);
         info.last_update_gen = zcu.generation;
         info.deps.clearRetainingCapacity();
@@ -1078,15 +1079,17 @@ pub fn ensureTypeLayoutUpToDate(
         .@"union" => Sema.type_resolution.resolveUnionLayout(&sema, ty),
         else => unreachable,
     };
-    result catch |err| switch (err) {
-        error.AnalysisFail => {
+    const new_success: bool = if (result) s: {
+        break :s true;
+    } else |err| switch (err) {
+        error.AnalysisFail => success: {
             if (!zcu.failed_analysis.contains(anal_unit)) {
                 // If this unit caused the error, it would have an entry in `failed_analysis`.
                 // Since it does not, this must be a transitive failure.
                 try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
                 log.debug("mark transitive analysis failure for {f}", .{zcu.fmtAnalUnit(anal_unit)});
             }
-            return error.AnalysisFail;
+            break :success false;
         },
         error.OutOfMemory,
         error.Canceled,
@@ -1098,6 +1101,15 @@ pub fn ensureTypeLayoutUpToDate(
     sema.flushExports() catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
     };
+
+    // We don't need to `markDependeeOutdated`/`markPoDependeeUpToDate` here, because we already
+    // marked the layout as outdated at the top of this function. However, we do need to tell the
+    // debug info logic in the backend about this type.
+    comp.link_prog_node.increaseEstimatedTotalItems(1);
+    try comp.link_queue.enqueueZcu(comp, pt.tid, .{ .debug_update_container_type = .{
+        .ty = ty.toIntern(),
+        .success = new_success,
+    } });
 }
 
 /// Ensures that the resolved value of the given `Nav` is fully up-to-date, performing re-analysis
@@ -4102,463 +4114,3 @@ fn printVerboseAir(
     try air.write(w, pt, liveness);
     try w.print("# End Function AIR: {f}\n\n", .{fqn.fmt(ip)});
 }
-
-// MLUGG TODO: these functions are all blatant hacks. See if I can remove them!
-pub fn resolveTypeForCodegen(pt: Zcu.PerThread, ty: Type) Zcu.SemaError!void {
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    if (ty.isGenericPoison()) return;
-    switch (ty.zigTypeTag(zcu)) {
-        .type,
-        .void,
-        .bool,
-        .noreturn,
-        .int,
-        .float,
-        .error_set,
-        .@"opaque",
-        .comptime_float,
-        .comptime_int,
-        .undefined,
-        .null,
-        .enum_literal,
-        => {},
-
-        .frame, .@"anyframe" => @panic("TODO resolveTypeForCodegen async frames"),
-
-        .optional => try pt.resolveTypeForCodegen(ty.childType(zcu)),
-        .error_union => try pt.resolveTypeForCodegen(ty.errorUnionPayload(zcu)),
-        .pointer => try pt.resolveTypeForCodegen(ty.childType(zcu)),
-        .array => try pt.resolveTypeForCodegen(ty.childType(zcu)),
-        .vector => try pt.resolveTypeForCodegen(ty.childType(zcu)),
-
-        .@"fn" => {
-            const info = zcu.typeToFunc(ty).?;
-            for (0..info.param_types.len) |i| {
-                const param_ty = info.param_types.get(ip)[i];
-                try pt.resolveTypeForCodegen(.fromInterned(param_ty));
-            }
-            try pt.resolveTypeForCodegen(.fromInterned(info.return_type));
-        },
-
-        .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .struct_type => try pt.ensureTypeLayoutUpToDate(ty, null),
-            .tuple_type => |tuple| for (0..tuple.types.len) |i| {
-                const field_is_comptime = tuple.values.get(ip)[i] != .none;
-                if (field_is_comptime) continue;
-                const field_ty = tuple.types.get(ip)[i];
-                try pt.resolveTypeForCodegen(.fromInterned(field_ty));
-            },
-            else => unreachable,
-        },
-
-        .@"union" => try pt.ensureTypeLayoutUpToDate(ty, null),
-        .@"enum" => try pt.ensureTypeLayoutUpToDate(ty, null),
-    }
-}
-pub fn resolveValueTypesForCodegen(pt: Zcu.PerThread, val: Value) Zcu.SemaError!void {
-    const zcu = pt.zcu;
-    const ty: Type = switch (val.typeOf(zcu).toIntern()) {
-        .type_type => if (val.isUndef(zcu)) {
-            return;
-        } else val.toType(),
-        else => |ty| .fromInterned(ty),
-    };
-    return pt.resolveTypeForCodegen(ty);
-}
-pub fn resolveAirTypesForCodegen(pt: Zcu.PerThread, air: *const Air) Zcu.SemaError!void {
-    return pt.resolveBodyTypesForCodegen(air, air.getMainBody());
-}
-fn resolveBodyTypesForCodegen(pt: Zcu.PerThread, air: *const Air, body: []const Air.Inst.Index) Zcu.SemaError!void {
-    const zcu = pt.zcu;
-    const tags = air.instructions.items(.tag);
-    const datas = air.instructions.items(.data);
-    for (body) |inst| {
-        const data = datas[@intFromEnum(inst)];
-        switch (tags[@intFromEnum(inst)]) {
-            .inferred_alloc, .inferred_alloc_comptime => unreachable,
-
-            .arg => try pt.resolveTypeForCodegen(data.arg.ty.toType()),
-
-            .add,
-            .add_safe,
-            .add_optimized,
-            .add_wrap,
-            .add_sat,
-            .sub,
-            .sub_safe,
-            .sub_optimized,
-            .sub_wrap,
-            .sub_sat,
-            .mul,
-            .mul_safe,
-            .mul_optimized,
-            .mul_wrap,
-            .mul_sat,
-            .div_float,
-            .div_float_optimized,
-            .div_trunc,
-            .div_trunc_optimized,
-            .div_floor,
-            .div_floor_optimized,
-            .div_exact,
-            .div_exact_optimized,
-            .rem,
-            .rem_optimized,
-            .mod,
-            .mod_optimized,
-            .max,
-            .min,
-            .bit_and,
-            .bit_or,
-            .shr,
-            .shr_exact,
-            .shl,
-            .shl_exact,
-            .shl_sat,
-            .xor,
-            .cmp_lt,
-            .cmp_lt_optimized,
-            .cmp_lte,
-            .cmp_lte_optimized,
-            .cmp_eq,
-            .cmp_eq_optimized,
-            .cmp_gte,
-            .cmp_gte_optimized,
-            .cmp_gt,
-            .cmp_gt_optimized,
-            .cmp_neq,
-            .cmp_neq_optimized,
-            .bool_and,
-            .bool_or,
-            .store,
-            .store_safe,
-            .set_union_tag,
-            .array_elem_val,
-            .slice_elem_val,
-            .ptr_elem_val,
-            .memset,
-            .memset_safe,
-            .memcpy,
-            .memmove,
-            .atomic_store_unordered,
-            .atomic_store_monotonic,
-            .atomic_store_release,
-            .atomic_store_seq_cst,
-            .legalize_vec_elem_val,
-            => {
-                try pt.resolveRefTypesForCodegen(data.bin_op.lhs);
-                try pt.resolveRefTypesForCodegen(data.bin_op.rhs);
-            },
-
-            .not,
-            .bitcast,
-            .clz,
-            .ctz,
-            .popcount,
-            .byte_swap,
-            .bit_reverse,
-            .abs,
-            .load,
-            .fptrunc,
-            .fpext,
-            .intcast,
-            .intcast_safe,
-            .trunc,
-            .optional_payload,
-            .optional_payload_ptr,
-            .optional_payload_ptr_set,
-            .wrap_optional,
-            .unwrap_errunion_payload,
-            .unwrap_errunion_err,
-            .unwrap_errunion_payload_ptr,
-            .unwrap_errunion_err_ptr,
-            .errunion_payload_ptr_set,
-            .wrap_errunion_payload,
-            .wrap_errunion_err,
-            .struct_field_ptr_index_0,
-            .struct_field_ptr_index_1,
-            .struct_field_ptr_index_2,
-            .struct_field_ptr_index_3,
-            .get_union_tag,
-            .slice_len,
-            .slice_ptr,
-            .ptr_slice_len_ptr,
-            .ptr_slice_ptr_ptr,
-            .array_to_slice,
-            .int_from_float,
-            .int_from_float_optimized,
-            .int_from_float_safe,
-            .int_from_float_optimized_safe,
-            .float_from_int,
-            .splat,
-            .error_set_has_value,
-            .addrspace_cast,
-            .c_va_arg,
-            .c_va_copy,
-            => {
-                try pt.resolveTypeForCodegen(data.ty_op.ty.toType());
-                try pt.resolveRefTypesForCodegen(data.ty_op.operand);
-            },
-
-            .alloc,
-            .ret_ptr,
-            .c_va_start,
-            => try pt.resolveTypeForCodegen(data.ty),
-
-            .ptr_add,
-            .ptr_sub,
-            .add_with_overflow,
-            .sub_with_overflow,
-            .mul_with_overflow,
-            .shl_with_overflow,
-            .slice,
-            .slice_elem_ptr,
-            .ptr_elem_ptr,
-            => {
-                const bin = air.extraData(Air.Bin, data.ty_pl.payload).data;
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                try pt.resolveRefTypesForCodegen(bin.lhs);
-                try pt.resolveRefTypesForCodegen(bin.rhs);
-            },
-
-            .block,
-            .loop,
-            => {
-                const block = air.unwrapBlock(inst);
-                try pt.resolveTypeForCodegen(block.ty);
-                try pt.resolveBodyTypesForCodegen(air, block.body);
-            },
-
-            .dbg_inline_block => {
-                const block = air.unwrapDbgBlock(inst);
-                try pt.resolveTypeForCodegen(block.ty);
-                try pt.resolveBodyTypesForCodegen(air, block.body);
-            },
-
-            .sqrt,
-            .sin,
-            .cos,
-            .tan,
-            .exp,
-            .exp2,
-            .log,
-            .log2,
-            .log10,
-            .floor,
-            .ceil,
-            .round,
-            .trunc_float,
-            .neg,
-            .neg_optimized,
-            .is_null,
-            .is_non_null,
-            .is_null_ptr,
-            .is_non_null_ptr,
-            .is_err,
-            .is_non_err,
-            .is_err_ptr,
-            .is_non_err_ptr,
-            .ret,
-            .ret_safe,
-            .ret_load,
-            .is_named_enum_value,
-            .tag_name,
-            .error_name,
-            .cmp_lt_errors_len,
-            .c_va_end,
-            .set_err_return_trace,
-            => try pt.resolveRefTypesForCodegen(data.un_op),
-
-            .br, .switch_dispatch => try pt.resolveRefTypesForCodegen(data.br.operand),
-
-            .cmp_vector,
-            .cmp_vector_optimized,
-            => {
-                const extra = air.extraData(Air.VectorCmp, data.ty_pl.payload).data;
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                try pt.resolveRefTypesForCodegen(extra.lhs);
-                try pt.resolveRefTypesForCodegen(extra.rhs);
-            },
-
-            .reduce,
-            .reduce_optimized,
-            => try pt.resolveRefTypesForCodegen(data.reduce.operand),
-
-            .struct_field_ptr,
-            .struct_field_val,
-            => {
-                const extra = air.extraData(Air.StructField, data.ty_pl.payload).data;
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                try pt.resolveRefTypesForCodegen(extra.struct_operand);
-            },
-
-            .shuffle_one => {
-                const unwrapped = air.unwrapShuffleOne(zcu, inst);
-                try pt.resolveTypeForCodegen(unwrapped.result_ty);
-                try pt.resolveRefTypesForCodegen(unwrapped.operand);
-                for (unwrapped.mask) |m| switch (m.unwrap()) {
-                    .elem => {},
-                    .value => |val| try pt.resolveValueTypesForCodegen(.fromInterned(val)),
-                };
-            },
-
-            .shuffle_two => {
-                const unwrapped = air.unwrapShuffleTwo(zcu, inst);
-                try pt.resolveTypeForCodegen(unwrapped.result_ty);
-                try pt.resolveRefTypesForCodegen(unwrapped.operand_a);
-                try pt.resolveRefTypesForCodegen(unwrapped.operand_b);
-                // No values to check because there are no comptime-known values other than undef
-            },
-
-            .cmpxchg_weak,
-            .cmpxchg_strong,
-            => {
-                const extra = air.extraData(Air.Cmpxchg, data.ty_pl.payload).data;
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                try pt.resolveRefTypesForCodegen(extra.ptr);
-                try pt.resolveRefTypesForCodegen(extra.expected_value);
-                try pt.resolveRefTypesForCodegen(extra.new_value);
-            },
-
-            .aggregate_init => {
-                const ty = data.ty_pl.ty.toType();
-                const elems_len: usize = @intCast(ty.arrayLen(zcu));
-                const elems: []const Air.Inst.Ref = @ptrCast(air.extra.items[data.ty_pl.payload..][0..elems_len]);
-                try pt.resolveTypeForCodegen(ty);
-                if (ty.zigTypeTag(zcu) == .@"struct") {
-                    for (elems, 0..) |elem, elem_idx| {
-                        if (ty.structFieldIsComptime(elem_idx, zcu)) continue;
-                        try pt.resolveRefTypesForCodegen(elem);
-                    }
-                } else {
-                    for (elems) |elem| {
-                        try pt.resolveRefTypesForCodegen(elem);
-                    }
-                }
-            },
-
-            .union_init => {
-                const extra = air.extraData(Air.UnionInit, data.ty_pl.payload).data;
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                try pt.resolveRefTypesForCodegen(extra.init);
-            },
-
-            .field_parent_ptr => {
-                const extra = air.extraData(Air.FieldParentPtr, data.ty_pl.payload).data;
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                try pt.resolveRefTypesForCodegen(extra.field_ptr);
-            },
-
-            .atomic_load => try pt.resolveRefTypesForCodegen(data.atomic_load.ptr),
-
-            .prefetch => try pt.resolveRefTypesForCodegen(data.prefetch.ptr),
-
-            .runtime_nav_ptr => try pt.resolveTypeForCodegen(.fromInterned(data.ty_nav.ty)),
-
-            .select,
-            .mul_add,
-            .legalize_vec_store_elem,
-            => {
-                const bin = air.extraData(Air.Bin, data.pl_op.payload).data;
-                try pt.resolveRefTypesForCodegen(data.pl_op.operand);
-                try pt.resolveRefTypesForCodegen(bin.lhs);
-                try pt.resolveRefTypesForCodegen(bin.rhs);
-            },
-
-            .atomic_rmw => {
-                const extra = air.extraData(Air.AtomicRmw, data.pl_op.payload).data;
-                try pt.resolveRefTypesForCodegen(data.pl_op.operand);
-                try pt.resolveRefTypesForCodegen(extra.operand);
-            },
-
-            .call,
-            .call_always_tail,
-            .call_never_tail,
-            .call_never_inline,
-            => {
-                const call = air.unwrapCall(inst);
-                try pt.resolveRefTypesForCodegen(call.callee);
-                for (call.args) |arg| try pt.resolveRefTypesForCodegen(arg);
-            },
-
-            .dbg_var_ptr,
-            .dbg_var_val,
-            .dbg_arg_inline,
-            => try pt.resolveRefTypesForCodegen(data.pl_op.operand),
-
-            .@"try", .try_cold => {
-                const @"try" = air.unwrapTry(inst);
-                try pt.resolveRefTypesForCodegen(@"try".error_union);
-                try pt.resolveBodyTypesForCodegen(air, @"try".else_body);
-            },
-
-            .try_ptr, .try_ptr_cold => {
-                const try_ptr = air.unwrapTryPtr(inst);
-                try pt.resolveTypeForCodegen(try_ptr.error_union_payload_ptr_ty.toType());
-                try pt.resolveRefTypesForCodegen(try_ptr.error_union_ptr);
-                try pt.resolveBodyTypesForCodegen(air, try_ptr.else_body);
-            },
-
-            .cond_br => {
-                const cond_br = air.unwrapCondBr(inst);
-                try pt.resolveRefTypesForCodegen(cond_br.condition);
-                try pt.resolveBodyTypesForCodegen(air, cond_br.then_body);
-                try pt.resolveBodyTypesForCodegen(air, cond_br.else_body);
-            },
-
-            .switch_br, .loop_switch_br => {
-                const switch_br = air.unwrapSwitch(inst);
-                try pt.resolveRefTypesForCodegen(switch_br.operand);
-                var it = switch_br.iterateCases();
-                while (it.next()) |case| {
-                    for (case.items) |item| {
-                        try pt.resolveRefTypesForCodegen(item);
-                    }
-                    for (case.ranges) |range| {
-                        try pt.resolveRefTypesForCodegen(range[0]);
-                        try pt.resolveRefTypesForCodegen(range[1]);
-                    }
-                    try pt.resolveBodyTypesForCodegen(air, case.body);
-                }
-                try pt.resolveBodyTypesForCodegen(air, it.elseBody());
-            },
-
-            .assembly => {
-                const @"asm" = air.unwrapAsm(inst);
-                try pt.resolveTypeForCodegen(data.ty_pl.ty.toType());
-                for (@"asm".outputs) |output| if (output != .none) try pt.resolveRefTypesForCodegen(output);
-                for (@"asm".inputs) |input| if (input != .none) try pt.resolveRefTypesForCodegen(input);
-            },
-
-            .legalize_compiler_rt_call => {
-                const compiler_rt_call = air.unwrapCompilerRtCall(inst);
-                for (compiler_rt_call.args) |arg| try pt.resolveRefTypesForCodegen(arg);
-            },
-
-            .trap,
-            .breakpoint,
-            .ret_addr,
-            .frame_addr,
-            .unreach,
-            .wasm_memory_size,
-            .wasm_memory_grow,
-            .work_item_id,
-            .work_group_size,
-            .work_group_id,
-            .dbg_stmt,
-            .dbg_empty_stmt,
-            .err_return_trace,
-            .save_err_return_trace_index,
-            .repeat,
-            => {},
-        }
-    }
-}
-fn resolveRefTypesForCodegen(pt: Zcu.PerThread, ref: Air.Inst.Ref) Zcu.SemaError!void {
-    const ip_index = ref.toInterned() orelse {
-        // `ref` refers to a prior instruction, which we already did the resolution for.
-        return;
-    };
-    return pt.resolveValueTypesForCodegen(.fromInterned(ip_index));
-}
diff --git a/src/codegen.zig b/src/codegen.zig
index 45b70dee2ac19600117a0a08eec0087b234c7013..9608095dc61dfc3ce1c4b68a2c297bcd5439a2ac 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -700,7 +700,14 @@ fn lowerPtr(
             };
             return lowerPtr(bin_file, pt, src_loc, field.base, w, reloc_parent, offset + field_off);
         },
-        .arr_elem, .comptime_field, .comptime_alloc => unreachable,
+        .arr_elem => |arr_elem| {
+            const base_ptr_ty = Value.fromInterned(arr_elem.base).typeOf(zcu);
+            assert(base_ptr_ty.ptrSize(zcu) == .many);
+            const elem_size = base_ptr_ty.childType(zcu).abiSize(zcu);
+            return lowerPtr(bin_file, pt, src_loc, arr_elem.base, w, reloc_parent, offset + elem_size * arr_elem.index);
+        },
+        .comptime_alloc => unreachable,
+        .comptime_field => unreachable,
     };
 }
 
@@ -781,9 +788,8 @@ fn lowerNavRef(
     const ptr_width_bytes = @divExact(target.ptrBitWidth(), 8);
     const is_obj = lf.comp.config.output_mode == .Obj;
     const nav_ty = Type.fromInterned(ip.getNav(nav_index).typeOf(ip));
-    const is_fn_body = nav_ty.zigTypeTag(zcu) == .@"fn";
 
-    if (!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) {
+    if (!nav_ty.isRuntimeFnOrHasRuntimeBits(zcu) and ip.getNav(nav_index).getExtern(ip) == null) {
         try w.splatByteAll(0xaa, ptr_width_bytes);
         return;
     }
@@ -795,7 +801,7 @@ fn lowerNavRef(
             dev.check(link.File.Tag.wasm.devFeature());
             const wasm = lf.cast(.wasm).?;
             assert(reloc_parent == .none);
-            if (is_fn_body) {
+            if (nav_ty.zigTypeTag(zcu) == .@"fn") {
                 const gop = try wasm.zcu_indirect_function_set.getOrPut(gpa, nav_index);
                 if (!gop.found_existing) gop.value_ptr.* = {};
                 if (is_obj) {
@@ -1025,23 +1031,26 @@ pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allo
         .pointer => switch (ty.ptrSize(zcu)) {
             .slice => {},
             .one, .many, .c => {
-                const elem_ty = ty.childType(zcu);
                 const ptr = ip.indexToKey(val.toIntern()).ptr;
                 if (ptr.base_addr == .int) return .{ .immediate = ptr.byte_offset };
                 if (ptr.byte_offset == 0) switch (ptr.base_addr) {
                     .int => unreachable, // handled above
 
-                    .nav => |nav| if (elem_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
-                        return .{ .lea_nav = nav };
-                    } else {
-                        // Create the 0xaa bit pattern...
-                        const undef_ptr_bits: u64 = @intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() + 1)) / 3);
-                        // ...but align the pointer
-                        const alignment = zcu.navAlignment(nav);
-                        return .{ .immediate = alignment.forward(undef_ptr_bits) };
+                    .nav => |nav_index| {
+                        const nav = ip.getNav(nav_index);
+                        const nav_ty: Type = .fromInterned(nav.typeOf(ip));
+                        if (nav_ty.isRuntimeFnOrHasRuntimeBits(zcu) or nav.getExtern(ip) != null) {
+                            return .{ .lea_nav = nav_index };
+                        } else {
+                            // Create the 0xaa bit pattern...
+                            const undef_ptr_bits: u64 = @intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() + 1)) / 3);
+                            // ...but align the pointer
+                            const alignment = zcu.navAlignment(nav_index);
+                            return .{ .immediate = alignment.forward(undef_ptr_bits) };
+                        }
                     },
 
-                    .uav => |uav| if (elem_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
+                    .uav => |uav| if (Value.fromInterned(uav.val).typeOf(zcu).isRuntimeFnOrHasRuntimeBits(zcu)) {
                         return .{ .lea_uav = uav };
                     } else {
                         // Create the 0xaa bit pattern...
diff --git a/src/link.zig b/src/link.zig
index 4999c8a31affc3964f8cf129f6bb50c8c5a87675..c8ae7a6bb4dbb8cd8d0e782b6e6178dd65f049a7 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -798,14 +798,27 @@ pub const File = struct {
     };
 
     /// Never called when LLVM is codegenning the ZCU.
-    fn updateContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index) UpdateContainerTypeError!void {
+    fn updateContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index, success: bool) UpdateContainerTypeError!void {
         assert(base.comp.zcu.?.llvm_object == null);
         switch (base.tag) {
             .lld => unreachable,
             else => {},
             inline .elf => |tag| {
                 dev.check(tag.devFeature());
-                return @as(*tag.Type(), @fieldParentPtr("base", base)).updateContainerType(pt, ty);
+                return @as(*tag.Type(), @fieldParentPtr("base", base)).updateContainerType(pt, ty, success);
+            },
+        }
+    }
+
+    /// Never called when LLVM is codegenning the ZCU.
+    fn clearContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index) UpdateContainerTypeError!void {
+        assert(base.comp.zcu.?.llvm_object == null);
+        switch (base.tag) {
+            .lld => unreachable,
+            else => {},
+            inline .elf => |tag| {
+                dev.check(tag.devFeature());
+                return @as(*tag.Type(), @fieldParentPtr("base", base)).clearContainerType(pt, ty);
             },
         }
     }
@@ -1375,8 +1388,14 @@ pub const ZcuTask = union(enum) {
     link_nav: InternPool.Nav.Index,
     /// Write the machine code for a function to the output file.
     link_func: Zcu.CodegenTaskPool.Index,
-    link_type: InternPool.Index,
-    update_line_number: InternPool.TrackedInst.Index,
+    /// This struct/union/enum type has finished type resolution (successfully or otherwise), so the
+    /// linker can now lower debug information for this type (and any structural types which depend
+    /// on it, such as `?T`, `struct { T }`, `[2]T`, etc).
+    debug_update_container_type: struct {
+        ty: InternPool.Index,
+        success: bool,
+    },
+    debug_update_line_number: InternPool.TrackedInst.Index,
 };
 
 pub fn doPrelinkTask(comp: *Compilation, task: PrelinkTask) void {
@@ -1563,21 +1582,24 @@ pub fn doZcuTask(comp: *Compilation, tid: Zcu.PerThread.Id, task: ZcuTask) void
             }
             break :nav ip.indexToKey(func).func.owner_nav;
         },
-        .link_type => |ty| nav: {
-            const name = Type.fromInterned(ty).containerTypeName(ip).toSlice(ip);
-            const nav_prog_node = comp.link_prog_node.start(name, 0);
-            defer nav_prog_node.end();
-            if (zcu.llvm_object == null) {
+        .debug_update_container_type => |container_update| nav: {
+            const name = Type.fromInterned(container_update.ty).containerTypeName(ip).toSlice(ip);
+            const ty_prog_node = comp.link_prog_node.start(name, 0);
+            defer ty_prog_node.end();
+            if (zcu.llvm_object) |llvm_object| {
+                _ = llvm_object;
+                @compileError("MLUGG TODO");
+            } else {
                 if (comp.bin_file) |lf| {
-                    lf.updateContainerType(pt, ty) catch |err| switch (err) {
+                    lf.updateContainerType(pt, container_update.ty, container_update.success) catch |err| switch (err) {
                         error.OutOfMemory => diags.setAllocFailure(),
-                        error.TypeFailureReported => assert(zcu.failed_types.contains(ty)),
+                        error.TypeFailureReported => assert(zcu.failed_types.contains(container_update.ty)),
                     };
                 }
             }
             break :nav null;
         },
-        .update_line_number => |ti| nav: {
+        .debug_update_line_number => |ti| nav: {
             const nav_prog_node = comp.link_prog_node.start("Update line number", 0);
             defer nav_prog_node.end();
             if (pt.zcu.llvm_object == null) {
diff --git a/src/link/DebugConstPool.zig b/src/link/DebugConstPool.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ce7f32551b63401a94bce51d02f388398f8912e4
--- /dev/null
+++ b/src/link/DebugConstPool.zig
@@ -0,0 +1,287 @@
+/// Helper type for debug information implementations (such as `link.Dwarf`) to help them emit
+/// information about comptime-known values (constants), including types.
+///
+/// Every constant with associated debug information is assigned an `Index` by calling `get`. The
+/// pool will track which container types do and do not have a resolved layout, as well as which
+/// constants in the pool depend on which types, and call into the implementation to emit debug
+/// information for a constant only when all information is available.
+///
+/// Indices into the pool are dense, and constants are never removed from the pool, so the debug
+/// info implementation can store information for each one with a simple `ArrayList`.
+///
+/// To use `DebugConstPool`, the debug info implementation is required to:
+/// * forward `updateContainerType` calls to its `DebugConstPool`
+/// * expose some callback functions---see functions in `DebugInfo`
+/// * ensure that any `get` call is eventually followed by a `flushPending` call
+const DebugConstPool = @This();
+
+values: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+pending: std.ArrayList(Index),
+complete_containers: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+container_deps: std.AutoArrayHashMapUnmanaged(InternPool.Index, ContainerDepEntry.Index),
+container_dep_entries: std.ArrayList(ContainerDepEntry),
+
+pub const empty: DebugConstPool = .{
+    .values = .empty,
+    .pending = .empty,
+    .complete_containers = .empty,
+    .container_deps = .empty,
+    .container_dep_entries = .empty,
+};
+
+pub fn deinit(pool: *DebugConstPool, gpa: Allocator) void {
+    pool.values.deinit(gpa);
+    pool.pending.deinit(gpa);
+    pool.complete_containers.deinit(gpa);
+    pool.container_deps.deinit(gpa);
+    pool.container_dep_entries.deinit(gpa);
+}
+
+pub const Index = enum(u32) {
+    _,
+    pub fn val(i: Index, pool: *const DebugConstPool) InternPool.Index {
+        return pool.values.keys()[@intFromEnum(i)];
+    }
+};
+
+pub const DebugInfo = union(enum) {
+    dwarf: *@import("Dwarf.zig"),
+    llvm: @import("../codegen/llvm.zig").Object.Ptr,
+
+    /// Inform the debug info implementation that the new constant `val` was added to the pool at
+    /// the given index (which equals the current pool length) due to a `get` call. It is guaranteed
+    /// that there will eventually be a call to either `updateConst` or `updateConstIncomplete`
+    /// following the `addConst` call, to actually populate the constant's debug info.
+    fn addConst(
+        di: DebugInfo,
+        pt: Zcu.PerThread,
+        index: Index,
+        val: InternPool.Index,
+    ) !void {
+        switch (di) {
+            inline else => |impl| return impl.addConst(pt, index, val),
+        }
+    }
+
+    /// Tell the debug info implementation to emit information for the constant `val`, which is in
+    /// the pool at the given index. `val` is "complete", which means:
+    /// * If it is a type, its layout is known.
+    /// * Otherwise, the layout of its type is known.
+    fn updateConst(
+        di: DebugInfo,
+        pt: Zcu.PerThread,
+        index: Index,
+        val: InternPool.Index,
+    ) !void {
+        switch (di) {
+            inline else => |impl| return impl.updateConst(pt, index, val),
+        }
+    }
+
+    /// Tell the debug info implementation to emit information for the constant `val`, which is in
+    /// the pool at the given index. `val` is "incomplete", meaning the implementation cannot emit
+    /// full information for it (for instance, perhaps it is a struct type which was never actually
+    /// initialized so never had its layout resolved). Instead, the implementation must emit some
+    /// form of placeholder entry representing an incomplete/unknown constant.
+    fn updateConstIncomplete(
+        di: DebugInfo,
+        pt: Zcu.PerThread,
+        index: Index,
+        val: InternPool.Index,
+    ) !void {
+        switch (di) {
+            inline else => |impl| return impl.updateConstIncomplete(pt, index, val),
+        }
+    }
+};
+
+const ContainerDepEntry = extern struct {
+    next: ContainerDepEntry.Index.Optional,
+    depender: DebugConstPool.Index,
+    const Index = enum(u32) {
+        _,
+        const Optional = enum(u32) {
+            none = std.math.maxInt(u32),
+            _,
+            fn unwrap(o: Optional) ?ContainerDepEntry.Index {
+                return switch (o) {
+                    .none => null,
+                    else => @enumFromInt(@intFromEnum(o)),
+                };
+            }
+        };
+        fn toOptional(i: ContainerDepEntry.Index) Optional {
+            return @enumFromInt(@intFromEnum(i));
+        }
+        fn ptr(i: ContainerDepEntry.Index, pool: *DebugConstPool) *ContainerDepEntry {
+            return &pool.container_dep_entries.items[@intFromEnum(i)];
+        }
+    };
+};
+
+/// Calls to `link.File.updateContainerType` must be forwarded to this function so that the debug
+/// constant pool has up-to-date information about the resolution status of types.
+pub fn updateContainerType(
+    pool: *DebugConstPool,
+    pt: Zcu.PerThread,
+    di: DebugInfo,
+    container_ty: InternPool.Index,
+    success: bool,
+) !void {
+    if (success) {
+        const gpa = pt.zcu.comp.gpa;
+        try pool.complete_containers.put(gpa, container_ty, {});
+    } else {
+        _ = pool.complete_containers.fetchSwapRemove(container_ty);
+    }
+    var opt_dep = pool.container_deps.get(container_ty);
+    while (opt_dep) |dep| : (opt_dep = dep.ptr(pool).next.unwrap()) {
+        try pool.update(pt, di, dep.ptr(pool).depender);
+    }
+}
+
+/// After this is called, there may be a constant for which debug information (complete or not) has
+/// not yet been emitted, so the user must call `flushPending` at some point after this call.
+pub fn get(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo, val: InternPool.Index) !DebugConstPool.Index {
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const gpa = zcu.comp.gpa;
+    const gop = try pool.values.getOrPut(gpa, val);
+    const index: DebugConstPool.Index = @enumFromInt(gop.index);
+    if (!gop.found_existing) {
+        const ty: Type = switch (ip.typeOf(val)) {
+            .type_type => if (ip.isUndef(val)) .type else .fromInterned(val),
+            else => |ty| .fromInterned(ty),
+        };
+        try pool.registerTypeDeps(index, ty, zcu);
+        try pool.pending.append(gpa, index);
+        try di.addConst(pt, index, val);
+    }
+    return index;
+}
+pub fn flushPending(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo) !void {
+    while (pool.pending.pop()) |pending_ty| {
+        try pool.update(pt, di, pending_ty);
+    }
+}
+
+fn update(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo, index: DebugConstPool.Index) !void {
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const val = index.val(pool);
+    const ty: Type = switch (ip.typeOf(val)) {
+        .type_type => if (ip.isUndef(val)) .type else .fromInterned(val),
+        else => |ty| .fromInterned(ty),
+    };
+    if (pool.checkType(ty, zcu)) {
+        try di.updateConst(pt, index, val);
+    } else {
+        try di.updateConstIncomplete(pt, index, val);
+    }
+}
+fn checkType(pool: *const DebugConstPool, ty: Type, zcu: *const Zcu) bool {
+    if (ty.isGenericPoison()) return true;
+    return switch (ty.zigTypeTag(zcu)) {
+        .type,
+        .void,
+        .bool,
+        .noreturn,
+        .int,
+        .float,
+        .pointer,
+        .comptime_float,
+        .comptime_int,
+        .undefined,
+        .null,
+        .error_set,
+        .@"opaque",
+        .frame,
+        .@"anyframe",
+        .enum_literal,
+        => true,
+
+        .array, .vector => pool.checkType(ty.childType(zcu), zcu),
+        .optional => pool.checkType(ty.optionalChild(zcu), zcu),
+        .error_union => pool.checkType(ty.errorUnionPayload(zcu), zcu),
+        .@"fn" => {
+            const ip = &zcu.intern_pool;
+            const func = ip.indexToKey(ty.toIntern()).func_type;
+            for (func.param_types.get(ip)) |param_ty_ip| {
+                if (!pool.checkType(.fromInterned(param_ty_ip), zcu)) return false;
+            }
+            return pool.checkType(.fromInterned(func.return_type), zcu);
+        },
+        .@"struct" => if (ty.isTuple(zcu)) {
+            for (0..ty.structFieldCount(zcu)) |field_index| {
+                if (!pool.checkType(ty.fieldType(field_index, zcu), zcu)) return false;
+            }
+            return true;
+        } else {
+            return pool.complete_containers.contains(ty.toIntern());
+        },
+        .@"union", .@"enum" => {
+            return pool.complete_containers.contains(ty.toIntern());
+        },
+    };
+}
+fn registerTypeDeps(pool: *DebugConstPool, root: Index, ty: Type, zcu: *const Zcu) Allocator.Error!void {
+    if (ty.isGenericPoison()) return;
+    switch (ty.zigTypeTag(zcu)) {
+        .type,
+        .void,
+        .bool,
+        .noreturn,
+        .int,
+        .float,
+        .pointer,
+        .comptime_float,
+        .comptime_int,
+        .undefined,
+        .null,
+        .error_set,
+        .@"opaque",
+        .frame,
+        .@"anyframe",
+        .enum_literal,
+        => {},
+
+        .array, .vector => try pool.registerTypeDeps(root, ty.childType(zcu), zcu),
+        .optional => try pool.registerTypeDeps(root, ty.optionalChild(zcu), zcu),
+        .error_union => try pool.registerTypeDeps(root, ty.errorUnionPayload(zcu), zcu),
+        .@"fn" => {
+            const ip = &zcu.intern_pool;
+            const func = ip.indexToKey(ty.toIntern()).func_type;
+            for (func.param_types.get(ip)) |param_ty_ip| {
+                try pool.registerTypeDeps(root, .fromInterned(param_ty_ip), zcu);
+            }
+            try pool.registerTypeDeps(root, .fromInterned(func.return_type), zcu);
+        },
+        .@"struct", .@"union", .@"enum" => if (ty.isTuple(zcu)) {
+            for (0..ty.structFieldCount(zcu)) |field_index| {
+                try pool.registerTypeDeps(root, ty.fieldType(field_index, zcu), zcu);
+            }
+        } else {
+            // `ty` is a container; register the dependency.
+
+            const gpa = zcu.comp.gpa;
+            try pool.container_deps.ensureUnusedCapacity(gpa, 1);
+            try pool.container_dep_entries.ensureUnusedCapacity(gpa, 1);
+            errdefer comptime unreachable;
+
+            const gop = pool.container_deps.getOrPutAssumeCapacity(ty.toIntern());
+            const entry: ContainerDepEntry.Index = @enumFromInt(pool.container_dep_entries.items.len);
+            pool.container_dep_entries.appendAssumeCapacity(.{
+                .next = if (gop.found_existing) gop.value_ptr.toOptional() else .none,
+                .depender = root,
+            });
+            gop.value_ptr.* = entry;
+        },
+    }
+}
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const InternPool = @import("../InternPool.zig");
+const Type = @import("../Type.zig");
+const Zcu = @import("../Zcu.zig");
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 1d87a42601427050245a3c1f6b2e314b515b0d0b..3094e8671e72456103a2a9f1e47df1a0816b1800 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -18,6 +18,7 @@ const codegen = @import("../codegen.zig");
 const dev = @import("../dev.zig");
 const link = @import("../link.zig");
 const target_info = @import("../target.zig");
+const DebugConstPool = @import("DebugConstPool.zig");
 
 gpa: Allocator,
 bin_file: *link.File,
@@ -25,9 +26,11 @@ format: DW.Format,
 endian: std.builtin.Endian,
 address_size: AddressSize,
 
+const_pool: DebugConstPool,
+
 mods: std.AutoArrayHashMapUnmanaged(*Module, ModInfo),
-types: std.AutoArrayHashMapUnmanaged(InternPool.Index, Entry.Index),
-values: std.AutoArrayHashMapUnmanaged(InternPool.Index, Entry.Index),
+/// Indices are `DebugConstPool.Index`.
+values: std.ArrayList(struct { Unit.Index, Entry.Index }),
 navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, Entry.Index),
 decls: std.AutoArrayHashMapUnmanaged(InternPool.TrackedInst.Index, Entry.Index),
 
@@ -1034,15 +1037,14 @@ const Entry = struct {
             });
             const zcu = dwarf.bin_file.comp.zcu.?;
             const ip = &zcu.intern_pool;
-            for (dwarf.types.keys(), dwarf.types.values()) |ty, other_entry| {
-                const ty_unit: Unit.Index = if (Type.fromInterned(ty).typeDeclInst(zcu)) |inst_index|
-                    dwarf.getUnit(zcu.fileByIndex(inst_index.resolveFile(ip)).mod.?) catch unreachable
-                else
-                    .main;
-                if (sec.getUnit(ty_unit) == unit and unit.getEntry(other_entry) == entry)
-                    log.err("missing Type({f}({d}))", .{
-                        Type.fromInterned(ty).fmt(.{ .tid = .main, .zcu = zcu }),
-                        @intFromEnum(ty),
+            for (0.., dwarf.values.items) |raw_index, unit_and_entry| {
+                const index: DebugConstPool.Index = @enumFromInt(raw_index);
+                const val = index.val(&dwarf.const_pool);
+                const val_unit, const val_entry = unit_and_entry;
+                if (sec.getUnit(val_unit) == unit and unit.getEntry(val_entry) == entry)
+                    log.err("missing Value({f}({d}))", .{
+                        Value.fromInterned(val).fmtValue(.{ .tid = .main, .zcu = zcu }),
+                        @intFromEnum(val),
                     });
             }
             for (dwarf.navs.keys(), dwarf.navs.values()) |nav, other_entry| {
@@ -1520,7 +1522,6 @@ pub const WipNav = struct {
     debug_info: Writer.Allocating,
     debug_line: Writer.Allocating,
     debug_loclists: Writer.Allocating,
-    pending_lazy: PendingLazy,
 
     pub fn deinit(wip_nav: *WipNav) void {
         const gpa = wip_nav.dwarf.gpa;
@@ -1529,8 +1530,6 @@ pub const WipNav = struct {
         wip_nav.debug_info.deinit();
         wip_nav.debug_line.deinit();
         wip_nav.debug_loclists.deinit();
-        wip_nav.pending_lazy.types.deinit(gpa);
-        wip_nav.pending_lazy.values.deinit(gpa);
     }
 
     pub fn genDebugFrame(wip_nav: *WipNav, loc: u32, cfa: Cfa) UpdateError!void {
@@ -1945,6 +1944,12 @@ pub const WipNav = struct {
         try wip_nav.infoSectionOffset(.debug_str, StringSection.unit, try wip_nav.dwarf.debug_str.addString(wip_nav.dwarf, str), 0);
     }
 
+    fn strpFmt(wip_nav: *WipNav, comptime fmt: []const u8, args: anytype) (UpdateError || Writer.Error)!void {
+        const str = try std.fmt.allocPrint(wip_nav.dwarf.gpa, fmt, args);
+        defer wip_nav.dwarf.gpa.free(str);
+        return wip_nav.strp(str);
+    }
+
     const ExprLocCounter = struct {
         dw: Writer.Discarding,
         section_offset_bytes: u32,
@@ -2054,74 +2059,16 @@ pub const WipNav = struct {
         try dfw.splatByteAll(0, @intFromEnum(wip_nav.dwarf.address_size));
     }
 
-    fn getNavEntry(
-        wip_nav: *WipNav,
-        nav_index: InternPool.Nav.Index,
-    ) UpdateError!struct { Unit.Index, Entry.Index } {
-        const zcu = wip_nav.pt.zcu;
-        const ip = &zcu.intern_pool;
-        const nav = ip.getNav(nav_index);
-        const unit = try wip_nav.dwarf.getUnit(zcu.fileByIndex(nav.srcInst(ip).resolveFile(ip)).mod.?);
-        const gop = try wip_nav.dwarf.navs.getOrPut(wip_nav.dwarf.gpa, nav_index);
-        if (gop.found_existing) return .{ unit, gop.value_ptr.* };
-        const entry = try wip_nav.dwarf.addCommonEntry(unit);
-        gop.value_ptr.* = entry;
-        return .{ unit, entry };
-    }
-
     fn refNav(
         wip_nav: *WipNav,
         nav_index: InternPool.Nav.Index,
     ) (UpdateError || Writer.Error)!void {
-        const unit, const entry = try wip_nav.getNavEntry(nav_index);
+        const unit, const entry = try wip_nav.dwarf.getNavEntry(nav_index);
         try wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
     }
 
-    fn getTypeEntry(wip_nav: *WipNav, ty: Type) UpdateError!struct { Unit.Index, Entry.Index } {
-        const zcu = wip_nav.pt.zcu;
-        const ip = &zcu.intern_pool;
-        const maybe_inst_index = ty.typeDeclInst(zcu);
-        const unit = if (maybe_inst_index) |inst_index| switch (switch (ip.indexToKey(ty.toIntern())) {
-            else => unreachable,
-            .struct_type => ip.loadStructType(ty.toIntern()).name_nav,
-            .union_type => ip.loadUnionType(ty.toIntern()).name_nav,
-            .enum_type => ip.loadEnumType(ty.toIntern()).name_nav,
-            .opaque_type => ip.loadOpaqueType(ty.toIntern()).name_nav,
-        }) {
-            .none => try wip_nav.dwarf.getUnit(zcu.fileByIndex(inst_index.resolveFile(ip)).mod.?),
-            else => |name_nav| return wip_nav.getNavEntry(name_nav.unwrap().?),
-        } else .main;
-        const gop = try wip_nav.dwarf.types.getOrPut(wip_nav.dwarf.gpa, ty.toIntern());
-        if (gop.found_existing) return .{ unit, gop.value_ptr.* };
-        const entry = try wip_nav.dwarf.addCommonEntry(unit);
-        gop.value_ptr.* = entry;
-        if (maybe_inst_index == null) try wip_nav.pending_lazy.types.append(wip_nav.dwarf.gpa, ty.toIntern());
-        return .{ unit, entry };
-    }
-
     fn refType(wip_nav: *WipNav, ty: Type) (UpdateError || Writer.Error)!void {
-        const unit, const entry = try wip_nav.getTypeEntry(ty);
-        try wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
-    }
-
-    fn getValueEntry(wip_nav: *WipNav, value: Value) UpdateError!struct { Unit.Index, Entry.Index } {
-        const zcu = wip_nav.pt.zcu;
-        const ip = &zcu.intern_pool;
-        const ty = value.typeOf(zcu);
-        if (std.debug.runtime_safety) assert(ty.comptimeOnly(zcu));
-        if (ty.toIntern() == .type_type) return wip_nav.getTypeEntry(value.toType());
-        if (ip.isFunctionType(ty.toIntern()) and !value.isUndef(zcu)) return wip_nav.getNavEntry(switch (ip.indexToKey(value.toIntern())) {
-            else => unreachable,
-            .func => |func| func.owner_nav,
-            .@"extern" => |@"extern"| @"extern".owner_nav,
-        });
-        const gop = try wip_nav.dwarf.values.getOrPut(wip_nav.dwarf.gpa, value.toIntern());
-        const unit: Unit.Index = .main;
-        if (gop.found_existing) return .{ unit, gop.value_ptr.* };
-        const entry = try wip_nav.dwarf.addCommonEntry(unit);
-        gop.value_ptr.* = entry;
-        try wip_nav.pending_lazy.values.append(wip_nav.dwarf.gpa, value.toIntern());
-        return .{ unit, entry };
+        return wip_nav.refValue(ty.toValue());
     }
 
     fn refValue(wip_nav: *WipNav, value: Value) (UpdateError || Writer.Error)!void {
@@ -2129,6 +2076,15 @@ pub const WipNav = struct {
         try wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
     }
 
+    fn getValueEntry(wip_nav: *WipNav, value: Value) UpdateError!struct { Unit.Index, Entry.Index } {
+        if (value.typeOf(wip_nav.pt.zcu).toIntern() != .type_type) {
+            assert(value.typeOf(wip_nav.pt.zcu).comptimeOnly(wip_nav.pt.zcu));
+        }
+        const dwarf = wip_nav.dwarf;
+        const index = try dwarf.const_pool.get(wip_nav.pt, .{ .dwarf = dwarf }, value.toIntern());
+        return dwarf.values.items[@intFromEnum(index)];
+    }
+
     fn refForward(wip_nav: *WipNav) (Allocator.Error || Writer.Error)!u32 {
         const dwarf = wip_nav.dwarf;
         const diw = &wip_nav.debug_info.writer;
@@ -2156,7 +2112,7 @@ pub const WipNav = struct {
     ) (UpdateError || Writer.Error)!void {
         const ty = val.typeOf(wip_nav.pt.zcu);
         const diw = &wip_nav.debug_info.writer;
-        const size = if (ty.hasRuntimeBits(wip_nav.pt.zcu)) ty.abiSize(wip_nav.pt.zcu) else 0;
+        const size = ty.abiSize(wip_nav.pt.zcu);
         try diw.writeUleb128(size);
         if (size == 0) return;
         const old_end = wip_nav.debug_info.writer.end;
@@ -2331,22 +2287,6 @@ pub const WipNav = struct {
         try wip_nav.refType(parent_type.?);
         try wip_nav.infoSectionOffset(.debug_info, wip_nav.unit, generic_decl_entry, 0);
     }
-
-    const PendingLazy = struct {
-        types: std.ArrayList(InternPool.Index),
-        values: std.ArrayList(InternPool.Index),
-
-        const empty: PendingLazy = .{ .types = .empty, .values = .empty };
-    };
-
-    fn updateLazy(wip_nav: *WipNav, src_loc: Zcu.LazySrcLoc) (UpdateError || Writer.Error)!void {
-        while (true) if (wip_nav.pending_lazy.types.pop()) |pending_ty|
-            try wip_nav.dwarf.updateLazyType(wip_nav.pt, src_loc, pending_ty, &wip_nav.pending_lazy)
-        else if (wip_nav.pending_lazy.values.pop()) |pending_val|
-            try wip_nav.dwarf.updateLazyValue(wip_nav.pt, src_loc, pending_val, &wip_nav.pending_lazy)
-        else
-            break;
-    }
 };
 
 /// When allocating, the ideal_capacity is calculated by
@@ -2372,8 +2312,9 @@ pub fn init(lf: *link.File, format: DW.Format) Dwarf {
         },
         .endian = target.cpu.arch.endian(),
 
+        .const_pool = .empty,
+
         .mods = .empty,
-        .types = .empty,
         .values = .empty,
         .navs = .empty,
         .decls = .empty,
@@ -2544,9 +2485,9 @@ pub fn initMetadata(dwarf: *Dwarf) UpdateError!void {
 
 pub fn deinit(dwarf: *Dwarf) void {
     const gpa = dwarf.gpa;
+    dwarf.const_pool.deinit(gpa);
     for (dwarf.mods.values()) |*mod_info| mod_info.deinit(gpa);
     dwarf.mods.deinit(gpa);
-    dwarf.types.deinit(gpa);
     dwarf.values.deinit(gpa);
     dwarf.navs.deinit(gpa);
     dwarf.decls.deinit(gpa);
@@ -2562,6 +2503,21 @@ pub fn deinit(dwarf: *Dwarf) void {
     dwarf.* = undefined;
 }
 
+fn getNavEntry(
+    dwarf: *Dwarf,
+    nav_index: InternPool.Nav.Index,
+) UpdateError!struct { Unit.Index, Entry.Index } {
+    const zcu = dwarf.bin_file.comp.zcu.?;
+    const ip = &zcu.intern_pool;
+    const nav = ip.getNav(nav_index);
+    const unit = try dwarf.getUnit(zcu.fileByIndex(nav.srcInst(ip).resolveFile(ip)).mod.?);
+    const gop = try dwarf.navs.getOrPut(dwarf.gpa, nav_index);
+    if (gop.found_existing) return .{ unit, gop.value_ptr.* };
+    const entry = try dwarf.addCommonEntry(unit);
+    gop.value_ptr.* = entry;
+    return .{ unit, entry };
+}
+
 fn getUnit(dwarf: *Dwarf, mod: *Module) !Unit.Index {
     const mod_gop = try dwarf.mods.getOrPut(dwarf.gpa, mod);
     const unit: Unit.Index = @enumFromInt(mod_gop.index);
@@ -2622,6 +2578,10 @@ fn getModInfo(dwarf: *Dwarf, unit: Unit.Index) *ModInfo {
     return &dwarf.mods.values()[@intFromEnum(unit)];
 }
 
+fn getUnitModule(dwarf: *Dwarf, unit: Unit.Index) *Module {
+    return dwarf.mods.keys()[@intFromEnum(unit)];
+}
+
 pub fn initWipNav(
     dwarf: *Dwarf,
     pt: Zcu.PerThread,
@@ -2683,7 +2643,6 @@ fn initWipNavInner(
         .debug_info = .init(dwarf.gpa),
         .debug_line = .init(dwarf.gpa),
         .debug_loclists = .init(dwarf.gpa),
-        .pending_lazy = .empty,
     };
     errdefer wip_nav.deinit();
 
@@ -3050,7 +3009,7 @@ fn finishWipNavWriterError(
     }
     try dwarf.debug_loclists.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_loclists.written());
 
-    try wip_nav.updateLazy(zcu.navSrcLoc(nav_index));
+    try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
 }
 
 pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) error{ OutOfMemory, CodegenFail }!void {
@@ -3087,34 +3046,12 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
         return;
     }
 
-    var wip_nav: WipNav = .{
-        .dwarf = dwarf,
-        .pt = pt,
-        .unit = try dwarf.getUnit(file.mod.?),
-        .entry = undefined,
-        .any_children = false,
-        .func = .none,
-        .func_sym_index = undefined,
-        .func_high_pc = undefined,
-        .blocks = undefined,
-        .cfi = undefined,
-        .debug_frame = .init(dwarf.gpa),
-        .debug_info = .init(dwarf.gpa),
-        .debug_line = .init(dwarf.gpa),
-        .debug_loclists = .init(dwarf.gpa),
-        .pending_lazy = .empty,
-    };
-    defer wip_nav.deinit();
-
-    const nav_gop = try dwarf.navs.getOrPut(dwarf.gpa, nav_index);
-    errdefer _ = if (!nav_gop.found_existing) dwarf.navs.pop();
-
     const tag: union(enum) {
-        done,
-        decl_alias,
-        decl_var,
-        decl_const,
-        decl_func_alias: InternPool.Nav.Index,
+        alias,
+        @"var",
+        @"const",
+        func: Type,
+        func_alias: InternPool.Nav.Index,
     } = switch (ip.indexToKey(nav_val.toIntern())) {
         .int_type,
         .ptr_type,
@@ -3128,242 +3065,49 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
         .func_type,
         .error_set_type,
         .inferred_error_set_type,
-        => .decl_alias,
+        => .alias,
+
         .struct_type => tag: {
             const loaded_struct = ip.loadStructType(nav_val.toIntern());
-            if (loaded_struct.zir_index.resolveFile(ip) != inst_info.file) break :tag .decl_alias;
-
-            const type_gop = try dwarf.types.getOrPut(dwarf.gpa, nav_val.toIntern());
-            if (type_gop.found_existing) {
-                if (dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(type_gop.value_ptr.*).len > 0) break :tag .decl_alias;
-                assert(!nav_gop.found_existing);
-                nav_gop.value_ptr.* = type_gop.value_ptr.*;
-            } else {
-                if (nav_gop.found_existing)
-                    dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(nav_gop.value_ptr.*).clear()
-                else
-                    nav_gop.value_ptr.* = try dwarf.addCommonEntry(wip_nav.unit);
-                type_gop.value_ptr.* = nav_gop.value_ptr.*;
+            if (nav_index.toOptional() == loaded_struct.name_nav) {
+                // This Nav's entry is populated by the type, not the actual Nav.
+                _ = try dwarf.const_pool.get(pt, .{ .dwarf = dwarf }, nav_val.toIntern());
+                try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
+                return;
             }
-            wip_nav.entry = nav_gop.value_ptr.*;
-
-            const diw = &wip_nav.debug_info.writer;
-
-            switch (loaded_struct.layout) {
-                .auto, .@"extern" => {
-                    try wip_nav.declCommon(if (loaded_struct.field_types.len == 0) .{
-                        .decl = .decl_namespace_struct,
-                        .generic_decl = .generic_decl_const,
-                        .decl_instance = .decl_instance_namespace_struct,
-                    } else .{
-                        .decl = .decl_struct,
-                        .generic_decl = .generic_decl_const,
-                        .decl_instance = .decl_instance_struct,
-                    }, &nav, inst_info.file, &decl);
-                    if (loaded_struct.field_types.len == 0) try diw.writeByte(@intFromBool(false)) else {
-                        try diw.writeUleb128(nav_val.toType().abiSize(zcu));
-                        try diw.writeUleb128(nav_val.toType().abiAlignment(zcu).toByteUnits().?);
-                        for (0..loaded_struct.field_types.len) |field_index| {
-                            const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
-                            const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
-                            assert(!(is_comptime and field_init == .none));
-                            const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                            const has_runtime_bits, const has_comptime_state = switch (field_init) {
-                                .none => .{ false, false },
-                                else => .{
-                                    field_type.hasRuntimeBits(zcu),
-                                    field_type.comptimeOnly(zcu),
-                                },
-                            };
-                            try wip_nav.abbrevCode(if (is_comptime)
-                                if (has_comptime_state)
-                                    .struct_field_comptime_comptime_state
-                                else if (has_runtime_bits)
-                                    .struct_field_comptime_runtime_bits
-                                else
-                                    .struct_field_comptime
-                            else if (field_init != .none)
-                                if (has_comptime_state)
-                                    .struct_field_default_comptime_state
-                                else if (has_runtime_bits)
-                                    .struct_field_default_runtime_bits
-                                else
-                                    .struct_field
-                            else
-                                .struct_field);
-                            try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
-                            try wip_nav.refType(field_type);
-                            if (!is_comptime) {
-                                try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
-                                try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                                    field_type.abiAlignment(zcu).toByteUnits().?);
-                            }
-                            if (has_comptime_state)
-                                try wip_nav.refValue(.fromInterned(field_init))
-                            else if (has_runtime_bits)
-                                try wip_nav.blockValue(nav_src_loc, .fromInterned(field_init));
-                        }
-                        try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                    }
-                },
-                .@"packed" => {
-                    try wip_nav.declCommon(.{
-                        .decl = .decl_packed_struct,
-                        .generic_decl = .generic_decl_const,
-                        .decl_instance = .decl_instance_packed_struct,
-                    }, &nav, inst_info.file, &decl);
-                    try wip_nav.refType(.fromInterned(loaded_struct.packed_backing_int_type));
-                    var field_bit_offset: u16 = 0;
-                    for (0..loaded_struct.field_types.len) |field_index| {
-                        try wip_nav.abbrevCode(.packed_struct_field);
-                        try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
-                        const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                        try wip_nav.refType(field_type);
-                        try diw.writeUleb128(field_bit_offset);
-                        field_bit_offset += @intCast(field_type.bitSize(zcu));
-                    }
-                    try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                },
-            }
-            break :tag .done;
+            break :tag .alias;
         },
         .enum_type => tag: {
             const loaded_enum = ip.loadEnumType(nav_val.toIntern());
-            const type_zir_index = loaded_enum.zir_index.unwrap() orelse break :tag .decl_alias;
-            if (type_zir_index.resolveFile(ip) != inst_info.file) break :tag .decl_alias;
-
-            const type_gop = try dwarf.types.getOrPut(dwarf.gpa, nav_val.toIntern());
-            if (type_gop.found_existing) {
-                if (dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(type_gop.value_ptr.*).len > 0) break :tag .decl_alias;
-                assert(!nav_gop.found_existing);
-                nav_gop.value_ptr.* = type_gop.value_ptr.*;
-            } else {
-                if (nav_gop.found_existing)
-                    dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(nav_gop.value_ptr.*).clear()
-                else
-                    nav_gop.value_ptr.* = try dwarf.addCommonEntry(wip_nav.unit);
-                type_gop.value_ptr.* = nav_gop.value_ptr.*;
+            if (nav_index.toOptional() == loaded_enum.name_nav) {
+                // This Nav's entry is populated by the type, not the actual Nav.
+                _ = try dwarf.const_pool.get(pt, .{ .dwarf = dwarf }, nav_val.toIntern());
+                try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
+                return;
             }
-            wip_nav.entry = nav_gop.value_ptr.*;
-            const diw = &wip_nav.debug_info.writer;
-            try wip_nav.declCommon(if (loaded_enum.field_names.len > 0) .{
-                .decl = .decl_enum,
-                .generic_decl = .generic_decl_const,
-                .decl_instance = .decl_instance_enum,
-            } else .{
-                .decl = .decl_empty_enum,
-                .generic_decl = .generic_decl_const,
-                .decl_instance = .decl_instance_empty_enum,
-            }, &nav, inst_info.file, &decl);
-            try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
-            for (0..loaded_enum.field_names.len) |field_index| {
-                try wip_nav.enumConstValue(loaded_enum, .{
-                    .sdata = .signed_enum_field,
-                    .udata = .unsigned_enum_field,
-                    .block = .big_enum_field,
-                }, field_index);
-                try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
-            }
-            if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            break :tag .done;
+            break :tag .alias;
         },
         .union_type => tag: {
             const loaded_union = ip.loadUnionType(nav_val.toIntern());
-            if (loaded_union.zir_index.resolveFile(ip) != inst_info.file) break :tag .decl_alias;
-
-            const type_gop = try dwarf.types.getOrPut(dwarf.gpa, nav_val.toIntern());
-            if (type_gop.found_existing) {
-                if (dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(type_gop.value_ptr.*).len > 0) break :tag .decl_alias;
-                assert(!nav_gop.found_existing);
-                nav_gop.value_ptr.* = type_gop.value_ptr.*;
-            } else {
-                if (nav_gop.found_existing)
-                    dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(nav_gop.value_ptr.*).clear()
-                else
-                    nav_gop.value_ptr.* = try dwarf.addCommonEntry(wip_nav.unit);
-                type_gop.value_ptr.* = nav_gop.value_ptr.*;
+            if (nav_index.toOptional() == loaded_union.name_nav) {
+                // This Nav's entry is populated by the type, not the actual Nav.
+                _ = try dwarf.const_pool.get(pt, .{ .dwarf = dwarf }, nav_val.toIntern());
+                try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
+                return;
             }
-            wip_nav.entry = nav_gop.value_ptr.*;
-            const diw = &wip_nav.debug_info.writer;
-            try wip_nav.declCommon(.{
-                .decl = .decl_union,
-                .generic_decl = .generic_decl_const,
-                .decl_instance = .decl_instance_union,
-            }, &nav, inst_info.file, &decl);
-            const union_layout = Type.getUnionLayout(loaded_union, zcu);
-            try diw.writeUleb128(union_layout.abi_size);
-            try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
-            const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
-            if (loaded_union.has_runtime_tag) {
-                try wip_nav.abbrevCode(.tagged_union);
-                try wip_nav.infoSectionOffset(
-                    .debug_info,
-                    wip_nav.unit,
-                    wip_nav.entry,
-                    @intCast(diw.end + dwarf.sectionOffsetBytes()),
-                );
-                {
-                    try wip_nav.abbrevCode(.generated_field);
-                    try wip_nav.strp("tag");
-                    try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
-                    try diw.writeUleb128(union_layout.tagOffset());
-
-                    for (0..loaded_union.field_types.len) |field_index| {
-                        try wip_nav.enumConstValue(loaded_tag, .{
-                            .sdata = .signed_tagged_union_field,
-                            .udata = .unsigned_tagged_union_field,
-                            .block = .big_tagged_union_field,
-                        }, field_index);
-                        {
-                            try wip_nav.abbrevCode(.struct_field);
-                            try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
-                            const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                            try wip_nav.refType(field_type);
-                            try diw.writeUleb128(union_layout.payloadOffset());
-                            try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                                if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
-                        }
-                        try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                    }
-                }
-                try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            } else for (0..loaded_union.field_types.len) |field_index| {
-                try wip_nav.abbrevCode(.untagged_union_field);
-                try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
-                const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                try wip_nav.refType(field_type);
-                try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                    if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
-            }
-            try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            break :tag .done;
+            break :tag .alias;
         },
         .opaque_type => tag: {
             const loaded_opaque = ip.loadOpaqueType(nav_val.toIntern());
-            if (loaded_opaque.zir_index.resolveFile(ip) != inst_info.file) break :tag .decl_alias;
-
-            const type_gop = try dwarf.types.getOrPut(dwarf.gpa, nav_val.toIntern());
-            if (type_gop.found_existing) {
-                if (dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(type_gop.value_ptr.*).len > 0) break :tag .decl_alias;
-                assert(!nav_gop.found_existing);
-                nav_gop.value_ptr.* = type_gop.value_ptr.*;
-            } else {
-                if (nav_gop.found_existing)
-                    dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(nav_gop.value_ptr.*).clear()
-                else
-                    nav_gop.value_ptr.* = try dwarf.addCommonEntry(wip_nav.unit);
-                type_gop.value_ptr.* = nav_gop.value_ptr.*;
+            if (nav_index.toOptional() == loaded_opaque.name_nav) {
+                // This Nav's entry is populated by the type, not the actual Nav.
+                _ = try dwarf.const_pool.get(pt, .{ .dwarf = dwarf }, nav_val.toIntern());
+                try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
+                return;
             }
-            wip_nav.entry = nav_gop.value_ptr.*;
-            const diw = &wip_nav.debug_info.writer;
-            try wip_nav.declCommon(.{
-                .decl = .decl_namespace_struct,
-                .generic_decl = .generic_decl_const,
-                .decl_instance = .decl_instance_namespace_struct,
-            }, &nav, inst_info.file, &decl);
-            try diw.writeByte(@intFromBool(true));
-            break :tag .done;
+            break :tag .alias;
         },
+
         .undef,
         .simple_value,
         .int,
@@ -3378,63 +3122,69 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
         .aggregate,
         .un,
         .bitpack,
-        => .decl_const,
-        .variable => .decl_var,
+        => .@"const",
+
+        .variable => .@"var",
+
         .@"extern" => unreachable,
+
         .func => |func| tag: {
-            if (func.owner_nav != nav_index) break :tag .{ .decl_func_alias = func.owner_nav };
-            if (nav_gop.found_existing) switch (try dwarf.debug_info.declAbbrevCode(wip_nav.unit, nav_gop.value_ptr.*)) {
-                .null => {},
-                else => unreachable,
-                .decl_nullary_func, .decl_func, .decl_instance_nullary_func, .decl_instance_func => return,
-                .decl_nullary_func_generic,
-                .decl_func_generic,
-                .decl_instance_nullary_func_generic,
-                .decl_instance_func_generic,
-                => dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(nav_gop.value_ptr.*).clear(),
-            } else nav_gop.value_ptr.* = try dwarf.addCommonEntry(wip_nav.unit);
-            wip_nav.entry = nav_gop.value_ptr.*;
-
-            const func_type = ip.indexToKey(func.ty).func_type;
-            const is_nullary = !func_type.is_var_args and for (0..func_type.param_types.len) |param_index| {
-                if (!func_type.paramIsComptime(std.math.cast(u5, param_index) orelse break false)) break false;
-            } else true;
-            const diw = &wip_nav.debug_info.writer;
-            try wip_nav.declCommon(if (is_nullary) .{
-                .decl = .decl_nullary_func_generic,
-                .generic_decl = .generic_decl_func,
-                .decl_instance = .decl_instance_nullary_func_generic,
-            } else .{
-                .decl = .decl_func_generic,
-                .generic_decl = .generic_decl_func,
-                .decl_instance = .decl_instance_func_generic,
-            }, &nav, inst_info.file, &decl);
-            try wip_nav.refType(.fromInterned(func_type.return_type));
-            if (!is_nullary) {
-                for (0..func_type.param_types.len) |param_index| {
-                    if (std.math.cast(u5, param_index)) |small_param_index|
-                        if (func_type.paramIsComptime(small_param_index)) continue;
-                    try wip_nav.abbrevCode(.func_type_param);
-                    try wip_nav.refType(.fromInterned(func_type.param_types.get(ip)[param_index]));
-                }
-                if (func_type.is_var_args) try wip_nav.abbrevCode(.is_var_args);
-                try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            }
-            break :tag .done;
+            if (func.owner_nav != nav_index) break :tag .{ .func_alias = func.owner_nav };
+            break :tag .{ .func = .fromInterned(func.ty) };
         },
+
         // memoization, not types
         .memoized_call => unreachable,
     };
-    if (tag != .done) {
-        if (nav_gop.found_existing)
-            dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(nav_gop.value_ptr.*).clear()
-        else
-            nav_gop.value_ptr.* = try dwarf.addCommonEntry(wip_nav.unit);
-        wip_nav.entry = nav_gop.value_ptr.*;
+
+    const unit = try dwarf.getUnit(file.mod.?);
+
+    const nav_gop = try dwarf.navs.getOrPut(dwarf.gpa, nav_index);
+    errdefer _ = if (!nav_gop.found_existing) dwarf.navs.pop();
+
+    if (nav_gop.found_existing) {
+        if (tag == .func) switch (try dwarf.debug_info.declAbbrevCode(unit, nav_gop.value_ptr.*)) {
+            else => unreachable,
+
+            .decl_nullary_func,
+            .decl_func,
+            .decl_instance_nullary_func,
+            .decl_instance_func,
+            => return,
+
+            .null,
+            .decl_nullary_func_generic,
+            .decl_func_generic,
+            .decl_instance_nullary_func_generic,
+            .decl_instance_func_generic,
+            => {},
+        };
+        dwarf.debug_info.section.getUnit(unit).getEntry(nav_gop.value_ptr.*).clear();
+    } else {
+        nav_gop.value_ptr.* = try dwarf.addCommonEntry(unit);
     }
+
+    var wip_nav: WipNav = .{
+        .dwarf = dwarf,
+        .pt = pt,
+        .unit = unit,
+        .entry = nav_gop.value_ptr.*,
+        .any_children = false,
+        .func = .none,
+        .func_sym_index = undefined,
+        .func_high_pc = undefined,
+        .blocks = undefined,
+        .cfi = undefined,
+        .debug_frame = .init(dwarf.gpa),
+        .debug_info = .init(dwarf.gpa),
+        .debug_line = .init(dwarf.gpa),
+        .debug_loclists = .init(dwarf.gpa),
+    };
+    defer wip_nav.deinit();
+    const diw = &wip_nav.debug_info.writer;
+
     switch (tag) {
-        .done => {},
-        .decl_alias => {
+        .alias => {
             try wip_nav.declCommon(.{
                 .decl = .decl_alias,
                 .generic_decl = .generic_decl_const,
@@ -3442,8 +3192,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             }, &nav, inst_info.file, &decl);
             try wip_nav.refType(nav_val.toType());
         },
-        .decl_var => {
-            const diw = &wip_nav.debug_info.writer;
+        .@"var" => {
             try wip_nav.declCommon(.{
                 .decl = .decl_var,
                 .generic_decl = .generic_decl_var,
@@ -3460,8 +3209,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
                 nav_ty.abiAlignment(zcu).toByteUnits().?);
             try diw.writeByte(@intFromBool(decl.linkage != .normal));
         },
-        .decl_const => {
-            const diw = &wip_nav.debug_info.writer;
+        .@"const" => {
             const nav_ty = nav_val.typeOf(zcu);
             const has_runtime_bits = nav_ty.hasRuntimeBits(zcu);
             const has_comptime_state = nav_ty.comptimeOnly(zcu);
@@ -3496,7 +3244,33 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             try wip_nav.abbrevCode(.is_const);
             try wip_nav.refType(nav_ty);
         },
-        .decl_func_alias => |owner_nav| {
+        .func => |func_ty| {
+            const func_type = ip.indexToKey(func_ty.toIntern()).func_type;
+            const is_nullary = !func_type.is_var_args and for (0..func_type.param_types.len) |param_index| {
+                if (!func_type.paramIsComptime(std.math.cast(u5, param_index) orelse break false)) break false;
+            } else true;
+            try wip_nav.declCommon(if (is_nullary) .{
+                .decl = .decl_nullary_func_generic,
+                .generic_decl = .generic_decl_func,
+                .decl_instance = .decl_instance_nullary_func_generic,
+            } else .{
+                .decl = .decl_func_generic,
+                .generic_decl = .generic_decl_func,
+                .decl_instance = .decl_instance_func_generic,
+            }, &nav, inst_info.file, &decl);
+            try wip_nav.refType(.fromInterned(func_type.return_type));
+            if (!is_nullary) {
+                for (0..func_type.param_types.len) |param_index| {
+                    if (std.math.cast(u5, param_index)) |small_param_index|
+                        if (func_type.paramIsComptime(small_param_index)) continue;
+                    try wip_nav.abbrevCode(.func_type_param);
+                    try wip_nav.refType(.fromInterned(func_type.param_types.get(ip)[param_index]));
+                }
+                if (func_type.is_var_args) try wip_nav.abbrevCode(.is_var_args);
+                try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+            }
+        },
+        .func_alias => |owner_nav| {
             try wip_nav.declCommon(.{
                 .decl = .decl_alias,
                 .generic_decl = .generic_decl_const,
@@ -3505,31 +3279,81 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
             try wip_nav.refNav(owner_nav);
         },
     }
-    try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
-    try wip_nav.updateLazy(nav_src_loc);
+    try dwarf.debug_info.section.replaceEntry(unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
+    try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
 }
 
-fn updateLazyType(
+pub fn updateContainerType(
     dwarf: *Dwarf,
     pt: Zcu.PerThread,
-    src_loc: Zcu.LazySrcLoc,
-    type_index: InternPool.Index,
-    pending_lazy: *WipNav.PendingLazy,
-) (UpdateError || Writer.Error)!void {
+    ty: InternPool.Index,
+    success: bool,
+) !void {
+    try dwarf.const_pool.updateContainerType(pt, .{ .dwarf = dwarf }, ty, success);
+}
+/// Should only be called by the `DebugConstPool` implementation.
+pub fn addConst(dwarf: *Dwarf, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) !void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    assert(ip.typeOf(type_index) == .type_type);
-    const ty: Type = .fromInterned(type_index);
-    switch (type_index) {
-        .generic_poison_type => log.debug("updateLazyType({s})", .{"anytype"}),
-        else => log.debug("updateLazyType({f})", .{ty.fmt(pt)}),
+
+    const unit: Unit.Index, const entry: Entry.Index = switch (ip.indexToKey(val)) {
+        else => .{ .main, try dwarf.addCommonEntry(.main) },
+        .func => |func| try dwarf.getNavEntry(func.owner_nav),
+        .@"extern" => |@"extern"| try dwarf.getNavEntry(@"extern".owner_nav),
+        .struct_type, .union_type, .enum_type, .opaque_type => |_, tag| entry: {
+            const name_nav = switch (tag) {
+                .struct_type => ip.loadStructType(val).name_nav,
+                .union_type => ip.loadUnionType(val).name_nav,
+                .enum_type => ip.loadEnumType(val).name_nav,
+                .opaque_type => ip.loadOpaqueType(val).name_nav,
+                else => unreachable,
+            };
+            if (name_nav.unwrap()) |nav| {
+                break :entry try dwarf.getNavEntry(nav);
+            } else {
+                const zir_index = Type.fromInterned(val).typeDeclInstAllowGeneratedTag(zcu).?;
+                const unit = try dwarf.getUnit(zcu.fileByIndex(zir_index.resolveFile(ip)).mod.?);
+                break :entry .{ unit, try dwarf.addCommonEntry(unit) };
+            }
+        },
+    };
+
+    assert(@intFromEnum(index) == dwarf.values.items.len);
+    try dwarf.values.append(dwarf.gpa, .{ unit, entry });
+}
+/// Should only be called by the `DebugConstPool` implementation.
+///
+/// Emits a "dummy" DIE for the given comptime-only value (which may be a type). For types, this is
+/// an opaque type. Otherwise, it is an undefined value of the value's type.
+pub fn updateConstIncomplete(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: DebugConstPool.Index, value_index: InternPool.Index) !void {
+    const zcu = pt.zcu;
+
+    const val: Value = .fromInterned(value_index);
+
+    switch (value_index) {
+        .generic_poison_type => log.debug("updateValueIncomplete(anytype)", .{}),
+        else => log.debug("updateValueIncomplete(@as({f}, {f}))", .{
+            val.typeOf(zcu).fmt(pt),
+            val.fmtValue(pt),
+        }),
     }
 
+    const unit, const entry = dwarf.values.items[@intFromEnum(debug_const_index)];
+
+    for ([_]*Section{
+        &dwarf.debug_aranges.section,
+        &dwarf.debug_aranges.section,
+        &dwarf.debug_info.section,
+        &dwarf.debug_line.section,
+        &dwarf.debug_loclists.section,
+        &dwarf.debug_rnglists.section,
+    }) |sec| sec.getUnit(unit).getEntry(entry).clear();
+
     var wip_nav: WipNav = .{
         .dwarf = dwarf,
         .pt = pt,
-        .unit = .main,
-        .entry = dwarf.types.get(type_index).?,
+        .unit = unit,
+        .entry = entry,
         .any_children = false,
         .func = .none,
         .func_sym_index = undefined,
@@ -3540,43 +3364,119 @@ fn updateLazyType(
         .debug_info = .init(dwarf.gpa),
         .debug_line = .init(dwarf.gpa),
         .debug_loclists = .init(dwarf.gpa),
-        .pending_lazy = pending_lazy.*,
     };
-    defer {
-        pending_lazy.* = wip_nav.pending_lazy;
-        wip_nav.pending_lazy = .empty;
-        wip_nav.deinit();
-    }
-    const diw = &wip_nav.debug_info.writer;
-    const name = switch (type_index) {
-        .generic_poison_type => "",
-        else => try std.fmt.allocPrint(dwarf.gpa, "{f}", .{ty.fmt(pt)}),
-    };
-    defer dwarf.gpa.free(name);
-
-    switch (ip.indexToKey(type_index)) {
-        .undef => {
+    defer wip_nav.deinit();
+    switch (val.typeOf(zcu).toIntern()) {
+        .type_type => {
+            try wip_nav.abbrevCode(.generated_empty_struct_type);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
+            try wip_nav.debug_info.writer.writeByte(@intFromBool(true));
+        },
+        else => |ty| {
             try wip_nav.abbrevCode(.undefined_comptime_value);
-            try wip_nav.refType(.type);
+            try wip_nav.refType(.fromInterned(ty));
         },
+    }
+    try dwarf.debug_info.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_info.written());
+    try dwarf.debug_loclists.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_loclists.written());
+}
+/// Should only be called by the `DebugConstPool` implementation.
+///
+/// Emits a DIE for the given comptime-only value (which may be a type).
+pub fn updateConst(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: DebugConstPool.Index, value_index: InternPool.Index) !void {
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+
+    const val: Value = .fromInterned(value_index);
+
+    if (val.typeOf(zcu).toIntern() == .type_type and !val.isUndef(zcu)) {
+        val.toType().assertHasLayout(zcu);
+    } else {
+        val.typeOf(zcu).assertHasLayout(zcu);
+    }
+
+    const value_ip_key = ip.indexToKey(value_index);
+    switch (value_ip_key) {
+        .func => return, // populated by the Nav instead (`updateComptimeNav` or `initWipNav`)
+        .@"extern" => return, // populated by the Nav instead (`initWipNav`)
+        else => {},
+    }
+
+    switch (value_index) {
+        .generic_poison_type => log.debug("updateValue(anytype)", .{}),
+        else => log.debug("updateValue(@as({f}, {f}))", .{
+            val.typeOf(zcu).fmt(pt),
+            val.fmtValue(pt),
+        }),
+    }
+
+    const unit, const entry = dwarf.values.items[@intFromEnum(debug_const_index)];
+
+    for ([_]*Section{
+        &dwarf.debug_aranges.section,
+        &dwarf.debug_info.section,
+        &dwarf.debug_line.section,
+        &dwarf.debug_loclists.section,
+        &dwarf.debug_rnglists.section,
+    }) |sec| sec.getUnit(unit).getEntry(entry).clear();
+
+    var wip_nav: WipNav = .{
+        .dwarf = dwarf,
+        .pt = pt,
+        .unit = unit,
+        .entry = entry,
+        .any_children = false,
+        .func = .none,
+        .func_sym_index = undefined,
+        .func_high_pc = undefined,
+        .blocks = undefined,
+        .cfi = undefined,
+        .debug_frame = .init(dwarf.gpa),
+        .debug_info = .init(dwarf.gpa),
+        .debug_line = .init(dwarf.gpa),
+        .debug_loclists = .init(dwarf.gpa),
+    };
+    defer wip_nav.deinit();
+
+    // TODO: we really shouldn't need source locations at this point in the pipeline: we've lost
+    // that information by now. If the linker fundamentally cannot lower certain values, that needs
+    // to be caught in the frontend; if it can only hit transient failures, they should be reported
+    // without trying to tie them to a bogus source location.
+    const src_loc: Zcu.LazySrcLoc = .{
+        .base_node_inst = inst: {
+            const mod_root_file_index = zcu.module_roots.get(dwarf.getUnitModule(unit)).?.unwrap().?;
+            const mod_root_type_index = zcu.fileRootType(mod_root_file_index);
+            break :inst ip.loadStructType(mod_root_type_index).zir_index;
+        },
+        .offset = .{ .byte_abs = 0 },
+    };
+
+    const diw = &wip_nav.debug_info.writer;
+    var big_int_space: Value.BigIntSpace = undefined;
+    switch (value_ip_key) {
+        .func => unreachable, // handled above
+        .@"extern" => unreachable, // handled above
+
         .int_type => |int_type| {
             try wip_nav.abbrevCode(.numeric_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             try diw.writeByte(switch (int_type.signedness) {
                 inline .signed, .unsigned => |signedness| @field(DW.ATE, @tagName(signedness)),
             });
             try diw.writeUleb128(int_type.bits);
-            try diw.writeUleb128(ty.abiSize(zcu));
-            try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+            try diw.writeUleb128(val.toType().abiSize(zcu));
+            try diw.writeUleb128(val.toType().abiAlignment(zcu).toByteUnits().?);
         },
         .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
             .one, .many, .c => {
                 const ptr_child_type: Type = .fromInterned(ptr_type.child);
-                try wip_nav.abbrevCode(if (ptr_type.sentinel == .none) .ptr_type else .ptr_sentinel_type);
-                try wip_nav.strp(name);
+                try wip_nav.abbrevCode(switch (ptr_type.flags.alignment) {
+                    .none => if (ptr_type.sentinel == .none) .ptr_type else .ptr_sentinel_type,
+                    else => if (ptr_type.sentinel == .none) .ptr_aligned_type else .ptr_aligned_sentinel_type,
+                });
+                try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
                 if (ptr_type.sentinel != .none) try wip_nav.blockValue(src_loc, .fromInterned(ptr_type.sentinel));
-                try diw.writeUleb128(ptr_type.flags.alignment.toByteUnits() orelse
-                    ptr_child_type.abiAlignment(zcu).toByteUnits().?);
+                if (ptr_type.flags.alignment.toByteUnits()) |a| try diw.writeUleb128(a);
                 try diw.writeByte(@intFromEnum(ptr_type.flags.address_space));
                 if (ptr_type.flags.is_const or ptr_type.flags.is_volatile) try wip_nav.infoSectionOffset(
                     .debug_info,
@@ -3600,12 +3500,12 @@ fn updateLazyType(
             },
             .slice => {
                 try wip_nav.abbrevCode(.generated_struct_type);
-                try wip_nav.strp(name);
-                try diw.writeUleb128(ty.abiSize(zcu));
-                try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+                try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
+                try diw.writeUleb128(val.toType().abiSize(zcu));
+                try diw.writeUleb128(val.toType().abiAlignment(zcu).toByteUnits().?);
                 try wip_nav.abbrevCode(.generated_field);
                 try wip_nav.strp("ptr");
-                const ptr_field_type = ty.slicePtrFieldType(zcu);
+                const ptr_field_type = val.toType().slicePtrFieldType(zcu);
                 try wip_nav.refType(ptr_field_type);
                 try diw.writeUleb128(0);
                 try wip_nav.abbrevCode(.generated_field);
@@ -3619,7 +3519,7 @@ fn updateLazyType(
         .array_type => |array_type| {
             const array_child_type: Type = .fromInterned(array_type.child);
             try wip_nav.abbrevCode(if (array_type.sentinel == .none) .array_type else .array_sentinel_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             if (array_type.sentinel != .none) try wip_nav.blockValue(src_loc, .fromInterned(array_type.sentinel));
             try wip_nav.refType(array_child_type);
             try wip_nav.abbrevCode(.array_len);
@@ -3629,7 +3529,7 @@ fn updateLazyType(
         },
         .vector_type => |vector_type| {
             try wip_nav.abbrevCode(.vector_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             try wip_nav.refType(.fromInterned(vector_type.child));
             try wip_nav.abbrevCode(.array_len);
             try wip_nav.refType(.usize);
@@ -3640,9 +3540,9 @@ fn updateLazyType(
             const opt_child_type: Type = .fromInterned(opt_child_type_index);
             const opt_repr = optRepr(opt_child_type, zcu);
             try wip_nav.abbrevCode(.generated_union_type);
-            try wip_nav.strp(name);
-            try diw.writeUleb128(ty.abiSize(zcu));
-            try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
+            try diw.writeUleb128(val.toType().abiSize(zcu));
+            try diw.writeUleb128(val.toType().abiAlignment(zcu).toByteUnits().?);
             switch (opt_repr) {
                 .opv_null => {
                     try wip_nav.abbrevCode(.generated_field);
@@ -3720,12 +3620,12 @@ fn updateLazyType(
             };
 
             try wip_nav.abbrevCode(.generated_union_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             if (error_union_type.error_set_type != .generic_poison_type and
                 error_union_type.payload_type != .generic_poison_type)
             {
-                try diw.writeUleb128(ty.abiSize(zcu));
-                try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+                try diw.writeUleb128(val.toType().abiSize(zcu));
+                try diw.writeUleb128(val.toType().abiAlignment(zcu).toByteUnits().?);
             } else {
                 try diw.writeUleb128(0);
                 try diw.writeUleb128(1);
@@ -3791,20 +3691,24 @@ fn updateLazyType(
             .bool,
             => {
                 try wip_nav.abbrevCode(.numeric_type);
-                try wip_nav.strp(name);
-                try diw.writeByte(if (type_index == .bool_type)
+                try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
+                try diw.writeByte(if (value_index == .bool_type)
                     DW.ATE.boolean
-                else if (ty.isRuntimeFloat())
+                else if (val.toType().isRuntimeFloat())
                     DW.ATE.float
-                else if (ty.isSignedInt(zcu))
+                else if (val.toType().isSignedInt(zcu))
                     DW.ATE.signed
-                else if (ty.isUnsignedInt(zcu))
+                else if (val.toType().isUnsignedInt(zcu))
                     DW.ATE.unsigned
                 else
                     unreachable);
-                try diw.writeUleb128(ty.bitSize(zcu));
-                try diw.writeUleb128(ty.abiSize(zcu));
-                try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+                try diw.writeUleb128(val.toType().bitSize(zcu));
+                try diw.writeUleb128(val.toType().abiSize(zcu));
+                try diw.writeUleb128(val.toType().abiAlignment(zcu).toByteUnits().?);
+            },
+            .generic_poison => {
+                try wip_nav.abbrevCode(.void_type);
+                try wip_nav.strp("anytype");
             },
             .anyopaque,
             .void,
@@ -3815,37 +3719,29 @@ fn updateLazyType(
             .null,
             .undefined,
             .enum_literal,
-            .generic_poison,
             => {
                 try wip_nav.abbrevCode(.void_type);
-                try wip_nav.strp(if (type_index == .generic_poison_type) "anytype" else name);
+                try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             },
             .anyerror => return, // delay until flush
             .adhoc_inferred_error_set => unreachable,
         },
-        .struct_type,
-        .union_type,
-        .opaque_type,
-        => unreachable,
         .tuple_type => |tuple_type| if (tuple_type.types.len == 0) {
             try wip_nav.abbrevCode(.generated_empty_struct_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             try diw.writeByte(@intFromBool(false));
         } else {
             try wip_nav.abbrevCode(.generated_struct_type);
-            try wip_nav.strp(name);
-            try diw.writeUleb128(ty.abiSize(zcu));
-            try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
+            try diw.writeUleb128(val.toType().abiSize(zcu));
+            try diw.writeUleb128(val.toType().abiAlignment(zcu).toByteUnits().?);
             var field_byte_offset: u64 = 0;
             for (0..tuple_type.types.len) |field_index| {
                 const comptime_value = tuple_type.values.get(ip)[field_index];
                 const field_type: Type = .fromInterned(tuple_type.types.get(ip)[field_index]);
                 const has_runtime_bits, const has_comptime_state = switch (comptime_value) {
                     .none => .{ false, false },
-                    else => .{
-                        field_type.hasRuntimeBits(zcu),
-                        field_type.comptimeOnly(zcu),
-                    },
+                    else => .{ field_type.hasRuntimeBits(zcu), field_type.comptimeOnly(zcu) },
                 };
                 try wip_nav.abbrevCode(if (has_comptime_state)
                     .struct_field_comptime_comptime_state
@@ -3875,25 +3771,259 @@ fn updateLazyType(
             }
             try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
         },
+        .struct_type => {
+            const loaded_struct = ip.loadStructType(value_index);
+            const ty = val.toType();
+            const file = loaded_struct.zir_index.resolveFile(ip);
+            switch (loaded_struct.layout) {
+                .auto, .@"extern" => {
+                    const struct_is_file: bool = if (loaded_struct.zir_index.resolve(ip)) |inst| f: {
+                        break :f inst == .main_struct_inst;
+                    } else false;
+                    if (loaded_struct.name_nav.unwrap()) |nav_index| {
+                        assert(!struct_is_file);
+                        const nav = ip.getNav(nav_index);
+                        const decl_inst = nav.srcInst(ip).resolve(ip).?;
+                        const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+                        try wip_nav.declCommon(if (loaded_struct.field_types.len == 0) .{
+                            .decl = .decl_namespace_struct,
+                            .generic_decl = .generic_decl_const,
+                            .decl_instance = .decl_instance_namespace_struct,
+                        } else .{
+                            .decl = .decl_struct,
+                            .generic_decl = .generic_decl_const,
+                            .decl_instance = .decl_instance_struct,
+                        }, &nav, file, &decl);
+                    } else {
+                        const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
+                        try wip_nav.abbrevCode(switch (loaded_struct.field_types.len) {
+                            0 => if (struct_is_file) .empty_file else .empty_struct_type,
+                            else => if (struct_is_file) .file else .struct_type,
+                        });
+                        try diw.writeUleb128(file_gop.index);
+                        try wip_nav.strp(loaded_struct.name.toSlice(ip));
+                    }
+                    if (loaded_struct.field_types.len == 0) {
+                        if (!struct_is_file) try diw.writeByte(@intFromBool(false));
+                    } else {
+                        try diw.writeUleb128(ty.abiSize(zcu));
+                        try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
+                        for (0..loaded_struct.field_types.len) |field_index| {
+                            const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
+                            const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
+                            assert(!(is_comptime and field_init == .none));
+                            const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
+                            const has_runtime_bits, const has_comptime_state = switch (field_init) {
+                                .none => .{ false, false },
+                                else => .{
+                                    field_type.hasRuntimeBits(zcu),
+                                    field_type.comptimeOnly(zcu),
+                                },
+                            };
+                            try wip_nav.abbrevCode(if (is_comptime)
+                                if (has_comptime_state)
+                                    .struct_field_comptime_comptime_state
+                                else if (has_runtime_bits)
+                                    .struct_field_comptime_runtime_bits
+                                else
+                                    .struct_field_comptime
+                            else if (field_init != .none)
+                                if (has_comptime_state)
+                                    .struct_field_default_comptime_state
+                                else if (has_runtime_bits)
+                                    .struct_field_default_runtime_bits
+                                else
+                                    .struct_field
+                            else
+                                .struct_field);
+                            try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
+                            try wip_nav.refType(field_type);
+                            if (!is_comptime) {
+                                try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
+                                try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
+                                    field_type.abiAlignment(zcu).toByteUnits().?);
+                            }
+                            if (has_comptime_state)
+                                try wip_nav.refValue(.fromInterned(field_init))
+                            else if (has_runtime_bits)
+                                try wip_nav.blockValue(ty.srcLoc(zcu), .fromInterned(field_init));
+                        }
+                        try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                    }
+                },
+                .@"packed" => {
+                    const need_terminator: bool = if (loaded_struct.name_nav.unwrap()) |nav_index| t: {
+                        const nav = ip.getNav(nav_index);
+                        const decl_inst = nav.srcInst(ip).resolve(ip).?;
+                        const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+                        try wip_nav.declCommon(.{
+                            .decl = .decl_packed_struct,
+                            .generic_decl = .generic_decl_const,
+                            .decl_instance = .decl_instance_packed_struct,
+                        }, &nav, file, &decl);
+                        break :t true;
+                    } else t: {
+                        const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
+                        try wip_nav.abbrevCode(if (loaded_struct.field_types.len > 0) .packed_struct_type else .empty_packed_struct_type);
+                        try diw.writeUleb128(file_gop.index);
+                        try wip_nav.strp(loaded_struct.name.toSlice(ip));
+                        break :t loaded_struct.field_types.len > 0;
+                    };
+                    try wip_nav.refType(.fromInterned(loaded_struct.packed_backing_int_type));
+                    var field_bit_offset: u16 = 0;
+                    for (0..loaded_struct.field_types.len) |field_index| {
+                        try wip_nav.abbrevCode(.packed_struct_field);
+                        try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
+                        const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
+                        try wip_nav.refType(field_type);
+                        try diw.writeUleb128(field_bit_offset);
+                        field_bit_offset += @intCast(field_type.bitSize(zcu));
+                    }
+                    if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                },
+            }
+        },
+        .union_type => {
+            const loaded_union = ip.loadUnionType(value_index);
+            const file = loaded_union.zir_index.resolveFile(ip);
+            const need_terminator: bool = if (loaded_union.name_nav.unwrap()) |nav_index| t: {
+                const nav = ip.getNav(nav_index);
+                const decl_inst = nav.srcInst(ip).resolve(ip).?;
+                const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+                try wip_nav.declCommon(.{
+                    .decl = .decl_union,
+                    .generic_decl = .generic_decl_const,
+                    .decl_instance = .decl_instance_union,
+                }, &nav, file, &decl);
+                break :t true;
+            } else t: {
+                const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
+                try wip_nav.abbrevCode(if (loaded_union.field_types.len > 0) .union_type else .empty_union_type);
+                try diw.writeUleb128(file_gop.index);
+                try wip_nav.strp(loaded_union.name.toSlice(ip));
+                break :t loaded_union.field_types.len > 0;
+            };
+            const union_layout = Type.getUnionLayout(loaded_union, zcu);
+            try diw.writeUleb128(union_layout.abi_size);
+            try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
+            const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
+            if (loaded_union.has_runtime_tag) {
+                try wip_nav.abbrevCode(.tagged_union);
+                try wip_nav.infoSectionOffset(
+                    .debug_info,
+                    wip_nav.unit,
+                    wip_nav.entry,
+                    @intCast(diw.end + dwarf.sectionOffsetBytes()),
+                );
+                {
+                    try wip_nav.abbrevCode(.generated_field);
+                    try wip_nav.strp("tag");
+                    try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
+                    try diw.writeUleb128(union_layout.tagOffset());
+
+                    for (0..loaded_union.field_types.len) |field_index| {
+                        try wip_nav.enumConstValue(loaded_tag, .{
+                            .sdata = .signed_tagged_union_field,
+                            .udata = .unsigned_tagged_union_field,
+                            .block = .big_tagged_union_field,
+                        }, field_index);
+                        {
+                            try wip_nav.abbrevCode(.struct_field);
+                            try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
+                            const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
+                            try wip_nav.refType(field_type);
+                            try diw.writeUleb128(union_layout.payloadOffset());
+                            try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
+                                if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
+                        }
+                        try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                    }
+                }
+                try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+            } else for (0..loaded_union.field_types.len) |field_index| {
+                try wip_nav.abbrevCode(.untagged_union_field);
+                try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
+                const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
+                try wip_nav.refType(field_type);
+                try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
+                    if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
+            }
+            if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+        },
         .enum_type => {
-            const loaded_enum = ip.loadEnumType(type_index);
-            try wip_nav.abbrevCode(if (loaded_enum.field_names.len == 0) .generated_empty_enum_type else .generated_enum_type);
-            try wip_nav.strp(name);
-            try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
-            for (0..loaded_enum.field_names.len) |field_index| {
-                try wip_nav.enumConstValue(loaded_enum, .{
-                    .sdata = .signed_enum_field,
-                    .udata = .unsigned_enum_field,
-                    .block = .big_enum_field,
-                }, field_index);
-                try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
+            const loaded_enum = ip.loadEnumType(value_index);
+            if (loaded_enum.zir_index.unwrap()) |zir_index| {
+                assert(loaded_enum.owner_union == .none);
+                const file = zir_index.resolveFile(ip);
+                if (loaded_enum.name_nav.unwrap()) |nav_index| {
+                    const nav = ip.getNav(nav_index);
+                    const decl_inst = nav.srcInst(ip).resolve(ip).?;
+                    const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+                    try wip_nav.declCommon(if (loaded_enum.field_names.len > 0) .{
+                        .decl = .decl_enum,
+                        .generic_decl = .generic_decl_const,
+                        .decl_instance = .decl_instance_enum,
+                    } else .{
+                        .decl = .decl_empty_enum,
+                        .generic_decl = .generic_decl_const,
+                        .decl_instance = .decl_instance_empty_enum,
+                    }, &nav, file, &decl);
+                } else {
+                    const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
+                    try wip_nav.abbrevCode(if (loaded_enum.field_names.len > 0) .enum_type else .empty_enum_type);
+                    try diw.writeUleb128(file_gop.index);
+                    try wip_nav.strp(loaded_enum.name.toSlice(ip));
+                }
+                try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
+                for (0..loaded_enum.field_names.len) |field_index| {
+                    try wip_nav.enumConstValue(loaded_enum, .{
+                        .sdata = .signed_enum_field,
+                        .udata = .unsigned_enum_field,
+                        .block = .big_enum_field,
+                    }, field_index);
+                    try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
+                }
+                if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+            } else {
+                assert(loaded_enum.owner_union != .none);
+                try wip_nav.abbrevCode(if (loaded_enum.field_names.len == 0) .generated_empty_enum_type else .generated_enum_type);
+                try wip_nav.strp(loaded_enum.name.toSlice(ip));
+                try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
+                for (0..loaded_enum.field_names.len) |field_index| {
+                    try wip_nav.enumConstValue(loaded_enum, .{
+                        .sdata = .signed_enum_field,
+                        .udata = .unsigned_enum_field,
+                        .block = .big_enum_field,
+                    }, field_index);
+                    try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
+                }
+                if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
             }
-            if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+        },
+        .opaque_type => {
+            const loaded_opaque = ip.loadOpaqueType(value_index);
+            const file = loaded_opaque.zir_index.resolveFile(ip);
+            if (loaded_opaque.name_nav.unwrap()) |nav_index| {
+                const nav = ip.getNav(nav_index);
+                const decl_inst = nav.srcInst(ip).resolve(ip).?;
+                const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+                try wip_nav.declCommon(.{
+                    .decl = .decl_namespace_struct,
+                    .generic_decl = .generic_decl_const,
+                    .decl_instance = .decl_instance_namespace_struct,
+                }, &nav, file, &decl);
+            } else {
+                const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
+                try wip_nav.abbrevCode(.empty_struct_type);
+                try diw.writeUleb128(file_gop.index);
+                try wip_nav.strp(loaded_opaque.name.toSlice(ip));
+            }
+            try diw.writeByte(@intFromBool(true));
         },
         .func_type => |func_type| {
             const is_nullary = func_type.param_types.len == 0 and !func_type.is_var_args;
             try wip_nav.abbrevCode(if (is_nullary) .nullary_func_type else .func_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             const cc: DW.CC = cc: {
                 if (zcu.getTarget().cCallingConvention()) |cc| {
                     if (@as(std.builtin.CallingConvention.Tag, cc) == func_type.cc) {
@@ -3975,7 +4105,7 @@ fn updateLazyType(
         },
         .error_set_type => |error_set_type| {
             try wip_nav.abbrevCode(if (error_set_type.names.len == 0) .generated_empty_enum_type else .generated_enum_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             try wip_nav.refType(.fromInterned(try pt.intern(.{ .int_type = .{
                 .signedness = .unsigned,
                 .bits = zcu.errorSetBits(),
@@ -3990,100 +4120,28 @@ fn updateLazyType(
         },
         .inferred_error_set_type => |func| {
             try wip_nav.abbrevCode(.inferred_error_set_type);
-            try wip_nav.strp(name);
+            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             try wip_nav.refType(.fromInterned(switch (ip.funcIesResolvedUnordered(func)) {
                 .none => .anyerror_type,
                 else => |ies| ies,
             }));
         },
 
-        // values, not types
-        .simple_value,
-        .variable,
-        .@"extern",
-        .func,
-        .int,
-        .err,
-        .error_union,
-        .enum_literal,
-        .enum_tag,
-        .float,
-        .ptr,
-        .slice,
-        .opt,
-        .aggregate,
-        .un,
-        .bitpack,
-        // memoization, not types
-        .memoized_call,
-        => unreachable,
-    }
-    try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
-}
-
-fn updateLazyValue(
-    dwarf: *Dwarf,
-    pt: Zcu.PerThread,
-    src_loc: Zcu.LazySrcLoc,
-    value_index: InternPool.Index,
-    pending_lazy: *WipNav.PendingLazy,
-) (UpdateError || Writer.Error)!void {
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    assert(ip.typeOf(value_index) != .type_type);
-    log.debug("updateLazyValue(@as({f}, {f}))", .{
-        Value.fromInterned(value_index).typeOf(zcu).fmt(pt),
-        Value.fromInterned(value_index).fmtValue(pt),
-    });
-    var wip_nav: WipNav = .{
-        .dwarf = dwarf,
-        .pt = pt,
-        .unit = .main,
-        .entry = dwarf.values.get(value_index).?,
-        .any_children = false,
-        .func = .none,
-        .func_sym_index = undefined,
-        .func_high_pc = undefined,
-        .blocks = undefined,
-        .cfi = undefined,
-        .debug_frame = .init(dwarf.gpa),
-        .debug_info = .init(dwarf.gpa),
-        .debug_line = .init(dwarf.gpa),
-        .debug_loclists = .init(dwarf.gpa),
-        .pending_lazy = pending_lazy.*,
-    };
-    defer {
-        pending_lazy.* = wip_nav.pending_lazy;
-        wip_nav.pending_lazy = .empty;
-        wip_nav.deinit();
-    }
-    const diw = &wip_nav.debug_info.writer;
-    var big_int_space: Value.BigIntSpace = undefined;
-    switch (ip.indexToKey(value_index)) {
-        .int_type,
-        .ptr_type,
-        .array_type,
-        .vector_type,
-        .opt_type,
-        .anyframe_type,
-        .error_union_type,
-        .simple_type,
-        .struct_type,
-        .tuple_type,
-        .union_type,
-        .opaque_type,
-        .enum_type,
-        .func_type,
-        .error_set_type,
-        .inferred_error_set_type,
-        => unreachable, // already handled
         .undef => |ty| {
             try wip_nav.abbrevCode(.undefined_comptime_value);
             try wip_nav.refType(.fromInterned(ty));
         },
-        .simple_value => unreachable, // opv state
-        .variable, .@"extern" => unreachable, // not a value
-        .func => unreachable, // already handled
+        .simple_value => |simple_value| switch (simple_value) {
+            .void => unreachable, // opv state
+            .true, .false => unreachable, // runtime bits
+            .@"unreachable" => unreachable, // not a value
+            .null => {
+                // TODO: proper representation for this
+                try wip_nav.abbrevCode(.undefined_comptime_value);
+                try wip_nav.refType(.null);
+            },
+        },
+        .variable => unreachable, // not a value
         .int => |int| {
             try wip_nav.bigIntConstValue(.{
                 .sdata = .sdata_comptime_value,
@@ -4202,7 +4260,7 @@ fn updateLazyValue(
                 var byte_offset = ptr.byte_offset;
                 const base_unit, const base_entry = while (true) {
                     const base_ptr, const access: Access = base_ptr_access: switch (base_addr) {
-                        .nav => |nav_index| break try wip_nav.getNavEntry(nav_index),
+                        .nav => |nav_index| break try dwarf.getNavEntry(nav_index),
                         .comptime_alloc, .comptime_field => unreachable,
                         .uav => |uav| {
                             const uav_ty: Type = .fromInterned(ip.typeOf(uav.val));
@@ -4319,17 +4377,7 @@ fn updateLazyValue(
                 switch (optRepr(opt_child_type, zcu)) {
                     .opv_null => try diw.writeUleb128(0),
                     .unpacked => try wip_nav.blockValue(src_loc, .makeBool(opt.val != .none)),
-                    .error_set => try wip_nav.blockValue(src_loc, .fromInterned(value_index)),
-                    .pointer => if (opt_child_type.comptimeOnly(zcu)) {
-                        var buf: [8]u8 = undefined;
-                        const bytes = buf[0..@divExact(zcu.getTarget().ptrBitWidth(), 8)];
-                        dwarf.writeInt(bytes, switch (opt.val) {
-                            .none => 0,
-                            else => opt_child_type.ptrAlignment(zcu).toByteUnits().?,
-                        });
-                        try diw.writeUleb128(bytes.len);
-                        try diw.writeAll(bytes);
-                    } else try wip_nav.blockValue(src_loc, .fromInterned(value_index)),
+                    .error_set, .pointer => try wip_nav.blockValue(src_loc, .fromInterned(value_index)),
                 }
             }
             if (opt.val != .none) child_field: {
@@ -4457,7 +4505,8 @@ fn updateLazyValue(
         },
         .memoized_call => unreachable, // not a value
     }
-    try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
+    try dwarf.debug_info.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_info.written());
+    try dwarf.debug_loclists.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_loclists.written());
 }
 
 fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum { unpacked, opv_null, error_set, pointer } {
@@ -4472,312 +4521,6 @@ fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum { unpacked, opv_null, err
     };
 }
 
-pub fn updateContainerType(
-    dwarf: *Dwarf,
-    pt: Zcu.PerThread,
-    type_index: InternPool.Index,
-) UpdateError!void {
-    return dwarf.updateContainerTypeWriterError(pt, type_index) catch |err| switch (err) {
-        error.WriteFailed => error.OutOfMemory,
-        else => |e| e,
-    };
-}
-fn updateContainerTypeWriterError(
-    dwarf: *Dwarf,
-    pt: Zcu.PerThread,
-    type_index: InternPool.Index,
-) (UpdateError || Writer.Error)!void {
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const ty: Type = .fromInterned(type_index);
-    const ty_src_loc = ty.srcLoc(zcu);
-    log.debug("updateContainerType({f})", .{ty.fmt(pt)});
-
-    const inst_info = ty.typeDeclInst(zcu).?.resolveFull(ip).?;
-    const file = zcu.fileByIndex(inst_info.file);
-    const unit = try dwarf.getUnit(file.mod.?);
-    const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, inst_info.file);
-    if (inst_info.inst == .main_struct_inst) {
-        const type_gop = try dwarf.types.getOrPut(dwarf.gpa, type_index);
-        if (!type_gop.found_existing) type_gop.value_ptr.* = try dwarf.addCommonEntry(unit);
-        var wip_nav: WipNav = .{
-            .dwarf = dwarf,
-            .pt = pt,
-            .unit = unit,
-            .entry = type_gop.value_ptr.*,
-            .any_children = false,
-            .func = .none,
-            .func_sym_index = undefined,
-            .func_high_pc = undefined,
-            .blocks = undefined,
-            .cfi = undefined,
-            .debug_frame = .init(dwarf.gpa),
-            .debug_info = .init(dwarf.gpa),
-            .debug_line = .init(dwarf.gpa),
-            .debug_loclists = .init(dwarf.gpa),
-            .pending_lazy = .empty,
-        };
-        defer wip_nav.deinit();
-
-        const loaded_struct = ip.loadStructType(type_index);
-
-        const diw = &wip_nav.debug_info.writer;
-        try wip_nav.abbrevCode(if (loaded_struct.field_types.len == 0) .empty_file else .file);
-        try diw.writeUleb128(file_gop.index);
-        try wip_nav.strp(loaded_struct.name.toSlice(ip));
-        if (loaded_struct.field_types.len > 0) {
-            try diw.writeUleb128(ty.abiSize(zcu));
-            try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
-            for (0..loaded_struct.field_types.len) |field_index| {
-                const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
-                const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
-                assert(!(is_comptime and field_init == .none));
-                const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                const has_runtime_bits, const has_comptime_state = switch (field_init) {
-                    .none => .{ false, false },
-                    else => .{
-                        field_type.hasRuntimeBits(zcu),
-                        field_type.comptimeOnly(zcu),
-                    },
-                };
-                try wip_nav.abbrevCode(if (is_comptime)
-                    if (has_comptime_state)
-                        .struct_field_comptime_comptime_state
-                    else if (has_runtime_bits)
-                        .struct_field_comptime_runtime_bits
-                    else
-                        .struct_field_comptime
-                else if (field_init != .none)
-                    if (has_comptime_state)
-                        .struct_field_default_comptime_state
-                    else if (has_runtime_bits)
-                        .struct_field_default_runtime_bits
-                    else
-                        .struct_field
-                else
-                    .struct_field);
-                try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
-                try wip_nav.refType(field_type);
-                if (!is_comptime) {
-                    try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
-                    try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                        field_type.abiAlignment(zcu).toByteUnits().?);
-                }
-                if (has_comptime_state)
-                    try wip_nav.refValue(.fromInterned(field_init))
-                else if (has_runtime_bits)
-                    try wip_nav.blockValue(ty_src_loc, .fromInterned(field_init));
-            }
-            try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-        }
-
-        try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
-        try wip_nav.updateLazy(ty_src_loc);
-    } else {
-        {
-            // Note that changes to ZIR instruction tracking only need to update this code
-            // if a newly-tracked instruction can be a type's owner `zir_index`.
-            comptime assert(Zir.inst_tracking_version == 0);
-
-            const decl_inst = file.zir.?.instructions.get(@intFromEnum(inst_info.inst));
-            const name_strat: Zir.Inst.NameStrategy = switch (decl_inst.tag) {
-                .struct_init, .struct_init_ref, .struct_init_anon => .anon,
-                .extended => switch (decl_inst.data.extended.opcode) {
-                    .struct_decl => file.zir.?.getStructDecl(inst_info.inst).name_strategy,
-                    .union_decl => file.zir.?.getUnionDecl(inst_info.inst).name_strategy,
-                    .enum_decl => file.zir.?.getEnumDecl(inst_info.inst).name_strategy,
-                    .opaque_decl => file.zir.?.getOpaqueDecl(inst_info.inst).name_strategy,
-
-                    .reify_enum,
-                    .reify_struct,
-                    .reify_union,
-                    => @enumFromInt(decl_inst.data.extended.small),
-
-                    else => unreachable,
-                },
-                else => unreachable,
-            };
-            if (name_strat == .parent) return;
-        }
-
-        const type_gop = try dwarf.types.getOrPut(dwarf.gpa, type_index);
-        if (!type_gop.found_existing) type_gop.value_ptr.* = try dwarf.addCommonEntry(unit);
-        var wip_nav: WipNav = .{
-            .dwarf = dwarf,
-            .pt = pt,
-            .unit = unit,
-            .entry = type_gop.value_ptr.*,
-            .any_children = false,
-            .func = .none,
-            .func_sym_index = undefined,
-            .func_high_pc = undefined,
-            .blocks = undefined,
-            .cfi = undefined,
-            .debug_frame = .init(dwarf.gpa),
-            .debug_info = .init(dwarf.gpa),
-            .debug_line = .init(dwarf.gpa),
-            .debug_loclists = .init(dwarf.gpa),
-            .pending_lazy = .empty,
-        };
-        defer wip_nav.deinit();
-        const diw = &wip_nav.debug_info.writer;
-        const name = try std.fmt.allocPrint(dwarf.gpa, "{f}", .{ty.fmt(pt)});
-        defer dwarf.gpa.free(name);
-
-        switch (ip.indexToKey(type_index)) {
-            .struct_type => {
-                const loaded_struct = ip.loadStructType(type_index);
-                switch (loaded_struct.layout) {
-                    .auto, .@"extern" => {
-                        try wip_nav.abbrevCode(if (loaded_struct.field_types.len == 0) .empty_struct_type else .struct_type);
-                        try diw.writeUleb128(file_gop.index);
-                        try wip_nav.strp(name);
-                        if (loaded_struct.field_types.len == 0) try diw.writeByte(@intFromBool(false)) else {
-                            try diw.writeUleb128(ty.abiSize(zcu));
-                            try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
-                            for (0..loaded_struct.field_types.len) |field_index| {
-                                const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
-                                const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
-                                assert(!(is_comptime and field_init == .none));
-                                const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                                const has_runtime_bits, const has_comptime_state = switch (field_init) {
-                                    .none => .{ false, false },
-                                    else => .{
-                                        field_type.hasRuntimeBits(zcu),
-                                        field_type.comptimeOnly(zcu),
-                                    },
-                                };
-                                try wip_nav.abbrevCode(if (is_comptime)
-                                    if (has_comptime_state)
-                                        .struct_field_comptime_comptime_state
-                                    else if (has_runtime_bits)
-                                        .struct_field_comptime_runtime_bits
-                                    else
-                                        .struct_field_comptime
-                                else if (field_init != .none)
-                                    if (has_comptime_state)
-                                        .struct_field_default_comptime_state
-                                    else if (has_runtime_bits)
-                                        .struct_field_default_runtime_bits
-                                    else
-                                        .struct_field
-                                else
-                                    .struct_field);
-                                try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
-                                try wip_nav.refType(field_type);
-                                if (!is_comptime) {
-                                    try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
-                                    try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                                        field_type.abiAlignment(zcu).toByteUnits().?);
-                                }
-                                if (has_comptime_state)
-                                    try wip_nav.refValue(.fromInterned(field_init))
-                                else if (has_runtime_bits)
-                                    try wip_nav.blockValue(ty_src_loc, .fromInterned(field_init));
-                            }
-                            try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                        }
-                    },
-                    .@"packed" => {
-                        try wip_nav.abbrevCode(if (loaded_struct.field_types.len > 0) .packed_struct_type else .empty_packed_struct_type);
-                        try diw.writeUleb128(file_gop.index);
-                        try wip_nav.strp(name);
-                        try wip_nav.refType(.fromInterned(loaded_struct.packed_backing_int_type));
-                        var field_bit_offset: u16 = 0;
-                        for (0..loaded_struct.field_types.len) |field_index| {
-                            try wip_nav.abbrevCode(.packed_struct_field);
-                            try wip_nav.strp(loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
-                            const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                            try wip_nav.refType(field_type);
-                            try diw.writeUleb128(field_bit_offset);
-                            field_bit_offset += @intCast(field_type.bitSize(zcu));
-                        }
-                        if (loaded_struct.field_types.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                    },
-                }
-            },
-            .enum_type => {
-                const loaded_enum = ip.loadEnumType(type_index);
-                try wip_nav.abbrevCode(if (loaded_enum.field_names.len > 0) .enum_type else .empty_enum_type);
-                try diw.writeUleb128(file_gop.index);
-                try wip_nav.strp(name);
-                try wip_nav.refType(.fromInterned(loaded_enum.int_tag_type));
-                for (0..loaded_enum.field_names.len) |field_index| {
-                    try wip_nav.enumConstValue(loaded_enum, .{
-                        .sdata = .signed_enum_field,
-                        .udata = .unsigned_enum_field,
-                        .block = .big_enum_field,
-                    }, field_index);
-                    try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
-                }
-                if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            },
-            .union_type => {
-                const loaded_union = ip.loadUnionType(type_index);
-                try wip_nav.abbrevCode(if (loaded_union.field_types.len > 0) .union_type else .empty_union_type);
-                try diw.writeUleb128(file_gop.index);
-                try wip_nav.strp(name);
-                const union_layout = Type.getUnionLayout(loaded_union, zcu);
-                try diw.writeUleb128(union_layout.abi_size);
-                try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
-                const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
-                if (loaded_union.has_runtime_tag) {
-                    try wip_nav.abbrevCode(.tagged_union);
-                    try wip_nav.infoSectionOffset(
-                        .debug_info,
-                        wip_nav.unit,
-                        wip_nav.entry,
-                        @intCast(diw.end + dwarf.sectionOffsetBytes()),
-                    );
-                    {
-                        try wip_nav.abbrevCode(.generated_field);
-                        try wip_nav.strp("tag");
-                        try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
-                        try diw.writeUleb128(union_layout.tagOffset());
-
-                        for (0..loaded_union.field_types.len) |field_index| {
-                            try wip_nav.enumConstValue(loaded_tag, .{
-                                .sdata = .signed_tagged_union_field,
-                                .udata = .unsigned_tagged_union_field,
-                                .block = .big_tagged_union_field,
-                            }, field_index);
-                            {
-                                try wip_nav.abbrevCode(.struct_field);
-                                try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
-                                const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                                try wip_nav.refType(field_type);
-                                try diw.writeUleb128(union_layout.payloadOffset());
-                                try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                                    if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
-                            }
-                            try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                        }
-                    }
-                    try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-                } else for (0..loaded_union.field_types.len) |field_index| {
-                    try wip_nav.abbrevCode(.untagged_union_field);
-                    try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
-                    const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                    try wip_nav.refType(field_type);
-                    try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                        if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
-                }
-                if (loaded_union.field_types.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            },
-            .opaque_type => {
-                try wip_nav.abbrevCode(.empty_struct_type);
-                try diw.writeUleb128(file_gop.index);
-                try wip_nav.strp(name);
-                try diw.writeByte(@intFromBool(true));
-            },
-            else => unreachable,
-        }
-        try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
-        try dwarf.debug_loclists.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_loclists.written());
-        try wip_nav.updateLazy(ty_src_loc);
-    }
-}
-
 pub fn updateLineNumber(dwarf: *Dwarf, zcu: *Zcu, zir_index: InternPool.TrackedInst.Index) UpdateError!void {
     const comp = dwarf.bin_file.comp;
     const io = comp.io;
@@ -4840,14 +4583,15 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
     const comp = dwarf.bin_file.comp;
     const io = comp.io;
 
+    // Update `anyerror` based on the finished global error set.
     {
-        const type_gop = try dwarf.types.getOrPut(dwarf.gpa, .anyerror_type);
-        if (!type_gop.found_existing) type_gop.value_ptr.* = try dwarf.addCommonEntry(.main);
+        const index = try dwarf.const_pool.get(pt, .{ .dwarf = dwarf }, .anyerror_type);
+        const unit, const entry = dwarf.values.items[@intFromEnum(index)];
         var wip_nav: WipNav = .{
             .dwarf = dwarf,
             .pt = pt,
-            .unit = .main,
-            .entry = type_gop.value_ptr.*,
+            .unit = unit,
+            .entry = entry,
             .any_children = false,
             .func = .none,
             .func_sym_index = undefined,
@@ -4858,7 +4602,6 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
             .debug_info = .init(dwarf.gpa),
             .debug_line = .init(dwarf.gpa),
             .debug_loclists = .init(dwarf.gpa),
-            .pending_lazy = .empty,
         };
         defer wip_nav.deinit();
         const diw = &wip_nav.debug_info.writer;
@@ -4876,7 +4619,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
         }
         if (global_error_set_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
         try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
-        try wip_nav.updateLazy(.unneeded);
+        try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf });
     }
 
     for (dwarf.mods.keys(), dwarf.mods.values()) |mod, *mod_info| {
@@ -5324,6 +5067,8 @@ const AbbrevCode = enum {
     inferred_error_set_type,
     ptr_type,
     ptr_sentinel_type,
+    ptr_aligned_type,
+    ptr_aligned_sentinel_type,
     is_const,
     is_volatile,
     array_type,
@@ -5960,12 +5705,29 @@ const AbbrevCode = enum {
             .tag = .pointer_type,
             .attrs = &.{
                 .{ .name, .strp },
-                .{ .alignment, .udata },
                 .{ .address_class, .data1 },
                 .{ .type, .ref_addr },
             },
         },
         .ptr_sentinel_type = .{
+            .tag = .pointer_type,
+            .attrs = &.{
+                .{ .name, .strp },
+                .{ .ZIG_sentinel, .block },
+                .{ .address_class, .data1 },
+                .{ .type, .ref_addr },
+            },
+        },
+        .ptr_aligned_type = .{
+            .tag = .pointer_type,
+            .attrs = &.{
+                .{ .name, .strp },
+                .{ .alignment, .udata },
+                .{ .address_class, .data1 },
+                .{ .type, .ref_addr },
+            },
+        },
+        .ptr_aligned_sentinel_type = .{
             .tag = .pointer_type,
             .attrs = &.{
                 .{ .name, .strp },
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 85f37f88ce8b55c984f6d1e5c97c689b80659d4b..dd4c2abd248eafea4b6705a79a5c15eaf3b409d2 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1711,13 +1711,14 @@ pub fn updateContainerType(
     self: *Elf,
     pt: Zcu.PerThread,
     ty: InternPool.Index,
+    success: bool,
 ) link.File.UpdateContainerTypeError!void {
     if (build_options.skip_non_native and builtin.object_format != .elf) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
-    return self.zigObjectPtr().?.updateContainerType(pt, ty) catch |err| switch (err) {
+    return self.zigObjectPtr().?.updateContainerType(pt, ty, success) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         else => |e| {
             try zcu.failed_types.putNoClobber(gpa, ty, try Zcu.ErrorMsg.create(
diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig
index 9bf352c1b10bbf2ee85215dcba1f4225c5e843b9..91133412e8fc85f75e02070f546deb174a0c128a 100644
--- a/src/link/Elf/ZigObject.zig
+++ b/src/link/Elf/ZigObject.zig
@@ -1719,11 +1719,12 @@ pub fn updateContainerType(
     self: *ZigObject,
     pt: Zcu.PerThread,
     ty: InternPool.Index,
+    success: bool,
 ) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    if (self.dwarf) |*dwarf| try dwarf.updateContainerType(pt, ty);
+    if (self.dwarf) |*dwarf| try dwarf.updateContainerType(pt, ty, success);
 }
 
 fn updateLazySymbol(
-- 
2.54.0


From 0a7387c41004b8378c75e476c8a4bd058b15030d Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 11 Feb 2026 15:22:52 +0000
Subject: [PATCH 454/499] jacob broke the law

---
 src/Sema.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 81bce68e682a19a2d1895b5d2e7ce6af6c6ad820..686bb62bb3a777b19e19679c9368ff667f69961e 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -22236,7 +22236,7 @@ fn checkAtomicPtrOperand(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    try elem_ty.resolveLayout(pt);
+    try sema.ensureLayoutResolved(elem_ty, elem_ty_src, .ptr_access);
     var diag: Zcu.AtomicPtrAlignmentDiagnostics = .{};
     const alignment = zcu.atomicPtrAlignment(elem_ty, &diag) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-- 
2.54.0


From f7a1ccfc56ed2d5605aa6ee25ac8d609f4c0d2a5 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 12 Feb 2026 11:10:52 +0000
Subject: [PATCH 455/499] compiler: fix up LLVM backend, and improve its debug
 info

The LLVM backend can now run the behavior tests and standard library
tests, like the x86_64 backend can. This commit required me to make a
lot of changes to how the LLVM backend lowers debug information, and
while I was doing that, I improved a few things:

* `anyerror` is now an enum type (and other error sets just wrap it), so
  error values appear by name in debuggers

* Fixed broken lowering for tagged unions with zero-width payloads

* Associate container types with source locations in all cases

* Avoid depending on the order of type resolution (using the new
  `DebugConstPool` abstraction), so debug information will contain all
  available type information rather than just the subset which happens
  to be resolved when the backend lowers that debug type
---
 lib/std/zig/llvm/BitcodeReader.zig |   10 +-
 lib/std/zig/llvm/Builder.zig       |  101 +-
 src/Sema.zig                       |   29 +-
 src/Zcu/PerThread.zig              |    8 +-
 src/codegen/aarch64/abi.zig        |    2 +-
 src/codegen/arm/abi.zig            |   24 +-
 src/codegen/llvm.zig               | 1637 +++++++++++++---------------
 src/codegen/mips/abi.zig           |    2 +-
 src/codegen/riscv64/abi.zig        |    4 +-
 src/codegen/wasm/abi.zig           |    6 +-
 src/link.zig                       |    6 +-
 src/link/DebugConstPool.zig        |    3 +
 src/link/Dwarf.zig                 |    2 +-
 13 files changed, 859 insertions(+), 975 deletions(-)

diff --git a/lib/std/zig/llvm/BitcodeReader.zig b/lib/std/zig/llvm/BitcodeReader.zig
index d7b923c3c83c3625c80c57756d27f52323975786..e32e8afc033e0dc233bb7f37aea493f6bbcb1c9e 100644
--- a/lib/std/zig/llvm/BitcodeReader.zig
+++ b/lib/std/zig/llvm/BitcodeReader.zig
@@ -34,8 +34,8 @@ pub const Block = struct {
 
         const default: Info = .{
             .block_name = &.{},
-            .record_names = .{},
-            .abbrevs = .{ .abbrevs = .{} },
+            .record_names = .empty,
+            .abbrevs = .{ .abbrevs = .empty },
         };
 
         const set_bid_id: u32 = 1;
@@ -109,8 +109,8 @@ pub fn init(allocator: std.mem.Allocator, options: InitOptions) BitcodeReader {
         .keep_names = options.keep_names,
         .bit_buffer = 0,
         .bit_offset = 0,
-        .stack = .{},
-        .block_info = .{},
+        .stack = .empty,
+        .block_info = .empty,
     };
 }
 
@@ -278,7 +278,7 @@ fn startBlock(bc: *BitcodeReader, block_id: ?u32, new_abbrev_len: u6) !void {
     state.* = .{
         .block_id = block_id,
         .abbrev_id_width = new_abbrev_len,
-        .abbrevs = .{ .abbrevs = .{} },
+        .abbrevs = .{ .abbrevs = .empty },
     };
     try state.abbrevs.abbrevs.ensureTotalCapacity(
         bc.allocator,
diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index 66d20df34810c62e2741ed066906a519032af6ef..81b99c25725a20f0bbb7ed61ac611974e98d6dac 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -1627,7 +1627,7 @@ pub const FunctionAttributes = enum(u32) {
     const params_index = 2;
 
     pub const Wip = struct {
-        maps: Maps = .{},
+        maps: Maps = .empty,
 
         const Map = std.AutoArrayHashMapUnmanaged(Attribute.Kind, Attribute.Index);
         const Maps = std.ArrayList(Map);
@@ -4048,7 +4048,7 @@ pub const Function = struct {
     section: String = .none,
     alignment: Alignment = .default,
     blocks: []const Block = &.{},
-    instructions: std.MultiArrayList(Instruction) = .{},
+    instructions: std.MultiArrayList(Instruction) = .empty,
     names: [*]const String = &[0]String{},
     value_indices: [*]const u32 = &[0]u32{},
     strip: bool,
@@ -5222,13 +5222,13 @@ pub const WipFunction = struct {
             .prev_debug_location = .no_location,
             .debug_location = .no_location,
             .cursor = undefined,
-            .blocks = .{},
-            .instructions = .{},
-            .names = .{},
+            .blocks = .empty,
+            .instructions = .empty,
+            .names = .empty,
             .strip = options.strip,
-            .debug_locations = .{},
-            .debug_values = .{},
-            .extra = .{},
+            .debug_locations = .empty,
+            .debug_values = .empty,
+            .extra = .empty,
         };
         errdefer self.deinit();
 
@@ -5265,7 +5265,7 @@ pub const WipFunction = struct {
         self.blocks.appendAssumeCapacity(.{
             .name = final_name,
             .incoming = incoming,
-            .instructions = .{},
+            .instructions = .empty,
         });
         return index;
     }
@@ -6325,7 +6325,7 @@ pub const WipFunction = struct {
         function.blocks = &.{};
         gpa.free(function.names[0..function.instructions.len]);
         function.debug_locations.deinit(gpa);
-        function.debug_locations = .{};
+        function.debug_locations = .empty;
         gpa.free(function.debug_values);
         function.debug_values = &.{};
         gpa.free(function.extra);
@@ -8391,7 +8391,7 @@ pub const Metadata = packed struct(u32) {
         map: std.AutoArrayHashMapUnmanaged(union(enum) {
             metadata: Metadata,
             debug_location: DebugLocation.Location,
-        }, void) = .{},
+        }, void) = .empty,
 
         const FormatData = struct {
             formatter: *Formatter,
@@ -8649,52 +8649,52 @@ pub fn init(options: Options) Allocator.Error!Builder {
         .source_filename = .none,
         .data_layout = .none,
         .target_triple = .none,
-        .module_asm = .{},
+        .module_asm = .empty,
 
-        .string_map = .{},
-        .string_indices = .{},
-        .string_bytes = .{},
+        .string_map = .empty,
+        .string_indices = .empty,
+        .string_bytes = .empty,
 
-        .types = .{},
+        .types = .empty,
         .next_unnamed_type = @enumFromInt(0),
-        .next_unique_type_id = .{},
-        .type_map = .{},
-        .type_items = .{},
-        .type_extra = .{},
+        .next_unique_type_id = .empty,
+        .type_map = .empty,
+        .type_items = .empty,
+        .type_extra = .empty,
 
-        .attributes = .{},
-        .attributes_map = .{},
-        .attributes_indices = .{},
-        .attributes_extra = .{},
+        .attributes = .empty,
+        .attributes_map = .empty,
+        .attributes_indices = .empty,
+        .attributes_extra = .empty,
 
-        .function_attributes_set = .{},
+        .function_attributes_set = .empty,
 
-        .globals = .{},
+        .globals = .empty,
         .next_unnamed_global = @enumFromInt(0),
         .next_replaced_global = .none,
-        .next_unique_global_id = .{},
-        .aliases = .{},
-        .variables = .{},
-        .functions = .{},
+        .next_unique_global_id = .empty,
+        .aliases = .empty,
+        .variables = .empty,
+        .functions = .empty,
 
-        .strtab_string_map = .{},
-        .strtab_string_indices = .{},
-        .strtab_string_bytes = .{},
+        .strtab_string_map = .empty,
+        .strtab_string_indices = .empty,
+        .strtab_string_bytes = .empty,
 
-        .constant_map = .{},
-        .constant_items = .{},
-        .constant_extra = .{},
-        .constant_limbs = .{},
+        .constant_map = .empty,
+        .constant_items = .empty,
+        .constant_extra = .empty,
+        .constant_limbs = .empty,
 
-        .metadata_map = .{},
-        .metadata_items = .{},
-        .metadata_extra = .{},
-        .metadata_limbs = .{},
-        .metadata_forward_references = .{},
-        .metadata_named = .{},
-        .metadata_string_map = .{},
-        .metadata_string_indices = .{},
-        .metadata_string_bytes = .{},
+        .metadata_map = .empty,
+        .metadata_items = .empty,
+        .metadata_extra = .empty,
+        .metadata_limbs = .empty,
+        .metadata_forward_references = .empty,
+        .metadata_named = .empty,
+        .metadata_string_map = .empty,
+        .metadata_string_indices = .empty,
+        .metadata_string_bytes = .empty,
     };
     errdefer self.deinit();
 
@@ -12069,7 +12069,7 @@ pub fn trailingMetadataStringAssumeCapacity(self: *Builder) Metadata.String {
     const start = self.metadata_string_indices.getLast();
     const bytes: []const u8 = self.metadata_string_bytes.items[start..];
     assert(bytes.len > 0);
-    const gop = self.metadata_string_map.getOrPutAssumeCapacityAdapted(bytes, String.Adapter{ .builder = self });
+    const gop = self.metadata_string_map.getOrPutAssumeCapacityAdapted(bytes, Metadata.String.Adapter{ .builder = self });
     if (gop.found_existing) {
         self.metadata_string_bytes.shrinkRetainingCapacity(start);
     } else {
@@ -12467,11 +12467,12 @@ pub fn metadataConstant(self: *Builder, value: Constant) Allocator.Error!Metadat
     return self.metadataConstantAssumeCapacity(value);
 }
 
+/// Resolves the given forward reference to the given value (which is not itself a forward
+/// reference). If the forward reference is already resolved, its target is replaced.
 pub fn resolveDebugForwardReference(self: *Builder, fwd_ref: Metadata, value: Metadata) void {
     assert(fwd_ref.kind == .forward);
-    const resolved = &self.metadata_forward_references.items[fwd_ref.index];
-    assert(resolved.is_none);
-    resolved.* = value.toOptional();
+    assert(value.kind != .forward);
+    self.metadata_forward_references.items[fwd_ref.index] = value.toOptional();
 }
 
 fn metadataSimpleAssumeCapacity(self: *Builder, tag: Metadata.Tag, value: anytype) Metadata {
diff --git a/src/Sema.zig b/src/Sema.zig
index 686bb62bb3a777b19e19679c9368ff667f69961e..f1f2d895165a9408b06b2672dadfb52000d81ff1 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7096,7 +7096,13 @@ fn analyzeCall(
             }
         }
         for (args, 0..) |arg, arg_idx| {
-            try sema.validateRuntimeValue(block, args_info.argSrc(block, arg_idx), arg);
+            const arg_src = args_info.argSrc(block, arg_idx);
+            const arg_ty = sema.typeOf(arg);
+            try sema.validateRuntimeValue(block, arg_src, arg);
+            if (arg_ty.isPtrAtRuntime(zcu) or arg_ty.isSliceAtRuntime(zcu)) {
+                // LLVM wants this information for an "align" attribute on the argument.
+                try sema.ensureLayoutResolved(arg_ty.nullablePtrElem(zcu), arg_src, .init);
+            }
         }
         const runtime_func: Air.Inst.Ref, const runtime_args: []const Air.Inst.Ref = func: {
             if (!any_generic_types and !any_comptime_params) break :func .{ callee, args };
@@ -24270,6 +24276,13 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
 
     const elem = try sema.coerce(block, dest_elem_ty, uncoerced_elem, value_src);
 
+    const comptime_only_elem = switch (dest_elem_ty.classify(zcu)) {
+        .no_possible_value => unreachable, // `elem` is a value of this type
+        .one_possible_value => return, // no work to do
+        .runtime => false,
+        .partially_comptime, .fully_comptime => true,
+    };
+
     const runtime_src = rs: {
         const len_air_ref = try sema.fieldVal(block, src, dest_ptr, try ip.getOrPutString(gpa, io, pt.tid, "len", .no_embedded_nulls), dest_src);
         const len_val = (try sema.resolveDefinedValue(block, dest_src, len_air_ref)) orelse break :rs dest_src;
@@ -24299,6 +24312,15 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         return sema.storePtrVal(block, src, array_ptr_val, array_val, array_ty);
     };
 
+    if (comptime_only_elem) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(src, "cannot store comptime-only element '{f}' at runtime", .{dest_elem_ty.fmt(pt)});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(dest_src, msg, "operation is runtime due to destination pointer", .{});
+            break :msg msg;
+        });
+    }
+
     try sema.requireRuntimeBlock(block, src, runtime_src);
     try sema.validateRuntimeValue(block, dest_src, dest_ptr);
     try sema.validateRuntimeValue(block, value_src, elem);
@@ -27063,6 +27085,11 @@ fn elemPtrArray(
         try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
     }
 
+    if (array_ty.childType(zcu).abiSize(zcu) == 0) {
+        // zero-bit child type; just bitcast the pointer
+        return block.addBitCast(elem_ptr_ty, array_ptr);
+    }
+
     return block.addPtrElemPtr(array_ptr, elem_index, elem_ptr_ty);
 }
 
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index babf66ee720fe48fbb8d8d46ab5cd85344229318..73cb527f79791881e05d28cdb18f0bb63ec43737 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -2926,7 +2926,13 @@ fn analyzeFuncBodyInner(
         const param_ty: Type = .fromInterned(fn_ty_info.param_types.get(ip)[runtime_param_index]);
         runtime_param_index += 1;
 
-        try sema.ensureLayoutResolved(param_ty, inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) }), .parameter);
+        const param_ty_src = inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) });
+
+        try sema.ensureLayoutResolved(param_ty, param_ty_src, .parameter);
+        if (param_ty.isPtrAtRuntime(zcu) or param_ty.isSliceAtRuntime(zcu)) {
+            // LLVM wants this information for an "align" attribute on the parameter.
+            try sema.ensureLayoutResolved(param_ty.nullablePtrElem(zcu), param_ty_src, .parameter);
+        }
         if (try param_ty.onePossibleValue(pt)) |opv| {
             gop.value_ptr.* = .fromValue(opv);
             continue;
diff --git a/src/codegen/aarch64/abi.zig b/src/codegen/aarch64/abi.zig
index 9587415287d52becdb1f4d2e33d8e522134f3cd3..5b32aded166799de4851622e9235ae1f2914fa5c 100644
--- a/src/codegen/aarch64/abi.zig
+++ b/src/codegen/aarch64/abi.zig
@@ -13,7 +13,7 @@ pub const Class = union(enum) {
 
 /// For `float_array` the second element will be the amount of floats.
 pub fn classifyType(ty: Type, zcu: *Zcu) Class {
-    assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+    assert(ty.hasRuntimeBits(zcu));
 
     var maybe_float_bits: ?u16 = null;
     switch (ty.zigTypeTag(zcu)) {
diff --git a/src/codegen/arm/abi.zig b/src/codegen/arm/abi.zig
index 23606d6145c45d80f1dde0d1405337fb2b1958bd..22bd34274f49e24d5538302a1a9c285414085c01 100644
--- a/src/codegen/arm/abi.zig
+++ b/src/codegen/arm/abi.zig
@@ -23,7 +23,7 @@ pub const Class = union(enum) {
 pub const Context = enum { ret, arg };
 
 pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
-    assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+    assert(ty.hasRuntimeBits(zcu));
 
     var maybe_float_bits: ?u16 = null;
     const max_byval_size = 512;
@@ -39,22 +39,22 @@ pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
             const float_count = countFloats(ty, zcu, &maybe_float_bits);
             if (float_count <= byval_float_count) return .byval;
 
+            if (ty.abiAlignment(zcu).compare(.gt, .@"32")) {
+                return Class.arrSize(bit_size, 64);
+            }
+
             const fields = ty.structFieldCount(zcu);
             var i: u32 = 0;
             while (i < fields) : (i += 1) {
                 const field_ty = ty.fieldType(i, zcu);
-                const field_alignment = ty.fieldAlignment(i, zcu);
-                const field_size = field_ty.bitSize(zcu);
-                if (field_size > 32 or field_alignment.compare(.gt, .@"32")) {
-                    return Class.arrSize(bit_size, 64);
-                }
+                if (field_ty.bitSize(zcu) > 32) return Class.arrSize(bit_size, 64);
             }
             return Class.arrSize(bit_size, 32);
         },
         .@"union" => {
             const bit_size = ty.bitSize(zcu);
             const union_obj = zcu.typeToUnion(ty).?;
-            if (union_obj.flagsUnordered(ip).layout == .@"packed") {
+            if (union_obj.layout == .@"packed") {
                 if (bit_size > 64) return .memory;
                 return .byval;
             }
@@ -62,10 +62,12 @@ pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
             const float_count = countFloats(ty, zcu, &maybe_float_bits);
             if (float_count <= byval_float_count) return .byval;
 
-            for (union_obj.field_types.get(ip), 0..) |field_ty, field_index| {
-                if (Type.fromInterned(field_ty).bitSize(zcu) > 32 or
-                    ty.fieldAlignment(field_index, zcu).compare(.gt, .@"32"))
-                {
+            if (union_obj.alignment.compareStrict(.gt, .@"32")) {
+                return Class.arrSize(bit_size, 64);
+            }
+
+            for (union_obj.field_types.get(ip)) |field_ty| {
+                if (Type.fromInterned(field_ty).bitSize(zcu) > 32) {
                     return Class.arrSize(bit_size, 64);
                 }
             }
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index b952f8c22567527c10c76afcd7c8970481418263..185dcb0fe1702e632661b49b8c1d80250c5a7b4a 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -23,6 +23,7 @@ const Package = @import("../Package.zig");
 const Air = @import("../Air.zig");
 const Value = @import("../Value.zig");
 const Type = @import("../Type.zig");
+const DebugConstPool = link.DebugConstPool;
 const codegen = @import("../codegen.zig");
 const x86_64_abi = @import("x86_64/abi.zig");
 const wasm_c_abi = @import("wasm/abi.zig");
@@ -529,9 +530,15 @@ pub const Object = struct {
     debug_globals: std.ArrayList(Builder.Metadata),
 
     debug_file_map: std.AutoHashMapUnmanaged(Zcu.File.Index, Builder.Metadata),
-    debug_type_map: std.AutoHashMapUnmanaged(InternPool.Index, Builder.Metadata),
 
-    debug_unresolved_namespace_scopes: std.AutoArrayHashMapUnmanaged(InternPool.NamespaceIndex, Builder.Metadata),
+    /// This pool *only* contains types (and does not contain `@as(type, undefined)`).
+    debug_type_pool: DebugConstPool,
+    /// Keyed on `DebugConstPool.Index`.
+    debug_types: std.ArrayList(Builder.Metadata),
+    /// Initially `.none`, set if the type `anyerror` is lowered to a debug type. The type will not
+    /// actually be created until `emit`, which must resolve this reference with an appropriate enum
+    /// type from the global error set.
+    debug_anyerror_fwd_ref: Builder.Metadata.Optional,
 
     target: *const std.Target,
     /// Ideally we would use `llvm_module.getNamedFunction` to go from *Decl to LLVM function,
@@ -657,21 +664,22 @@ pub const Object = struct {
             .debug_compile_unit = debug_compile_unit,
             .debug_enums_fwd_ref = debug_enums_fwd_ref,
             .debug_globals_fwd_ref = debug_globals_fwd_ref,
-            .debug_enums = .{},
-            .debug_globals = .{},
-            .debug_file_map = .{},
-            .debug_type_map = .{},
-            .debug_unresolved_namespace_scopes = .{},
+            .debug_enums = .empty,
+            .debug_globals = .empty,
+            .debug_file_map = .empty,
+            .debug_type_pool = .empty,
+            .debug_types = .empty,
+            .debug_anyerror_fwd_ref = .none,
             .target = target,
-            .nav_map = .{},
-            .uav_map = .{},
-            .enum_tag_name_map = .{},
-            .named_enum_map = .{},
-            .type_map = .{},
+            .nav_map = .empty,
+            .uav_map = .empty,
+            .enum_tag_name_map = .empty,
+            .named_enum_map = .empty,
+            .type_map = .empty,
             .error_name_table = .none,
             .null_opt_usize = .no_init,
-            .struct_field_map = .{},
-            .used = .{},
+            .struct_field_map = .empty,
+            .used = .empty,
         };
         return obj;
     }
@@ -681,8 +689,8 @@ pub const Object = struct {
         self.debug_enums.deinit(gpa);
         self.debug_globals.deinit(gpa);
         self.debug_file_map.deinit(gpa);
-        self.debug_type_map.deinit(gpa);
-        self.debug_unresolved_namespace_scopes.deinit(gpa);
+        self.debug_type_pool.deinit(gpa);
+        self.debug_types.deinit(gpa);
         self.nav_map.deinit(gpa);
         self.uav_map.deinit(gpa);
         self.enum_tag_name_map.deinit(gpa);
@@ -824,19 +832,13 @@ pub const Object = struct {
             }
 
             if (!o.builder.strip) {
-                {
-                    var i: usize = 0;
-                    while (i < o.debug_unresolved_namespace_scopes.count()) : (i += 1) {
-                        const namespace_index = o.debug_unresolved_namespace_scopes.keys()[i];
-                        const fwd_ref = o.debug_unresolved_namespace_scopes.values()[i];
-
-                        const namespace = zcu.namespacePtr(namespace_index);
-                        const debug_type = try o.lowerDebugType(pt, Type.fromInterned(namespace.owner_type));
-
-                        o.builder.resolveDebugForwardReference(fwd_ref, debug_type);
-                    }
+                if (o.debug_anyerror_fwd_ref.unwrap()) |fwd_ref| {
+                    const debug_anyerror_type = try o.lowerDebugAnyerrorType(pt);
+                    o.builder.resolveDebugForwardReference(fwd_ref, debug_anyerror_type);
                 }
 
+                try o.flushPendingDebugTypes(pt);
+
                 o.builder.resolveDebugForwardReference(
                     o.debug_enums_fwd_ref.unwrap().?,
                     try o.builder.metadataTuple(o.debug_enums.items),
@@ -1472,7 +1474,7 @@ pub const Object = struct {
 
             const line_number = zcu.navSrcLine(func.owner_nav) + 1;
             const is_internal_linkage = ip.indexToKey(nav.status.fully_resolved.val) != .@"extern";
-            const debug_decl_type = try o.lowerDebugType(pt, fn_ty);
+            const debug_decl_type = try o.getDebugType(pt, fn_ty);
 
             const subprogram = try o.builder.debugSubprogram(
                 file,
@@ -1522,7 +1524,7 @@ pub const Object = struct {
 
             break :f .{
                 .counters_variable = counters_variable,
-                .pcs = .{},
+                .pcs = .empty,
             };
         };
 
@@ -1538,10 +1540,10 @@ pub const Object = struct {
             .args = args.items,
             .arg_index = 0,
             .arg_inline_index = 0,
-            .func_inst_table = .{},
-            .blocks = .{},
-            .loops = .{},
-            .switch_dispatch_info = .{},
+            .func_inst_table = .empty,
+            .blocks = .empty,
+            .loops = .empty,
+            .switch_dispatch_info = .empty,
             .sync_scope = if (owner_mod.single_threaded) .singlethread else .system,
             .file = file,
             .scope = subprogram,
@@ -1599,6 +1601,7 @@ pub const Object = struct {
         }
 
         try fg.wip.finish();
+        try o.flushPendingDebugTypes(pt);
     }
 
     pub fn updateNav(self: *Object, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void {
@@ -1615,6 +1618,14 @@ pub const Object = struct {
             },
             else => |e| return e,
         };
+        try self.flushPendingDebugTypes(pt);
+    }
+
+    fn flushPendingDebugTypes(o: *Object, pt: Zcu.PerThread) Allocator.Error!void {
+        o.debug_type_pool.flushPending(pt, .{ .llvm = o }) catch |err| switch (err) {
+            error.OutOfMemory => |e| return e,
+            else => unreachable, // TODO: stop self-hosted backends from returning all of this crap!
+        };
     }
 
     pub fn updateExports(
@@ -1810,6 +1821,57 @@ pub const Object = struct {
         }
     }
 
+    pub fn updateContainerType(o: *Object, pt: Zcu.PerThread, ty: InternPool.Index, success: bool) Allocator.Error!void {
+        if (!o.builder.strip) {
+            o.debug_type_pool.updateContainerType(pt, .{ .llvm = o }, ty, success) catch |err| switch (err) {
+                error.OutOfMemory => |e| return e,
+                else => unreachable, // TODO: stop self-hosted backends from returning all of this crap!
+            };
+        }
+    }
+
+    /// Should only be called by the `DebugConstPool` implementation.
+    ///
+    /// `val` is always a type because `o.debug_type_pool` only contains types.
+    pub fn addConst(o: *Object, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+        const zcu = pt.zcu;
+        const gpa = zcu.comp.gpa;
+        assert(zcu.intern_pool.typeOf(val) == .type_type);
+        assert(@intFromEnum(index) == o.debug_types.items.len);
+        try o.debug_types.ensureUnusedCapacity(gpa, 1);
+        const fwd_ref = try o.builder.debugForwardReference();
+        o.debug_types.appendAssumeCapacity(fwd_ref);
+        if (val == .anyerror_type) {
+            assert(o.debug_anyerror_fwd_ref.is_none);
+            o.debug_anyerror_fwd_ref = fwd_ref.toOptional();
+        }
+    }
+    /// Should only be called by the `DebugConstPool` implementation.
+    ///
+    /// `val` is always a type because `o.debug_type_pool` only contains types.
+    pub fn updateConstIncomplete(o: *Object, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+        assert(pt.zcu.intern_pool.typeOf(val) == .type_type);
+        const fwd_ref = o.debug_types.items[@intFromEnum(index)];
+        assert(val != .anyerror_type);
+        const name_str = try o.builder.metadataStringFmt("{f}", .{Type.fromInterned(val).fmt(pt)});
+        const debug_incomplete_type = try o.builder.debugSignedType(name_str, 0);
+        o.builder.resolveDebugForwardReference(fwd_ref, debug_incomplete_type);
+    }
+    /// Should only be called by the `DebugConstPool` implementation.
+    ///
+    /// `val` is always a type because `o.debug_type_pool` only contains types.
+    pub fn updateConst(o: *Object, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+        assert(pt.zcu.intern_pool.typeOf(val) == .type_type);
+        const fwd_ref = o.debug_types.items[@intFromEnum(index)];
+        if (val == .anyerror_type) {
+            // Don't lower this now; it will be populated in `emit` instead.
+            assert(o.debug_anyerror_fwd_ref == fwd_ref.toOptional());
+            return;
+        }
+        const debug_type = try o.lowerDebugType(pt, .fromInterned(val), fwd_ref);
+        o.builder.resolveDebugForwardReference(fwd_ref, debug_type);
+    }
+
     fn getDebugFile(o: *Object, pt: Zcu.PerThread, file_index: Zcu.File.Index) Allocator.Error!Builder.Metadata {
         const gpa = o.gpa;
         const gop = try o.debug_file_map.getOrPut(gpa, file_index);
@@ -1826,10 +1888,22 @@ pub const Object = struct {
         return gop.value_ptr.*;
     }
 
-    pub fn lowerDebugType(
+    fn getDebugType(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error!Builder.Metadata {
+        assert(!o.builder.strip);
+        const index = o.debug_type_pool.get(pt, .{ .llvm = o }, ty.toIntern()) catch |err| switch (err) {
+            error.OutOfMemory => |e| return e,
+            else => unreachable, // TODO: stop self-hosted backends from returning all of this crap!
+        };
+        return o.debug_types.items[@intFromEnum(index)];
+    }
+
+    /// In codegen logic, instead of calling this directly, use `getDebugType` to get a forward
+    /// reference which will be populated only when all necessary type resolution is complete.
+    fn lowerDebugType(
         o: *Object,
         pt: Zcu.PerThread,
         ty: Type,
+        ty_fwd_ref: Builder.Metadata,
     ) Allocator.Error!Builder.Metadata {
         assert(!o.builder.strip);
 
@@ -1838,267 +1912,96 @@ pub const Object = struct {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
 
-        if (o.debug_type_map.get(ty.toIntern())) |debug_type| return debug_type;
+        const name = try o.builder.metadataStringFmt("{f}", .{ty.fmt(pt)});
 
         switch (ty.zigTypeTag(zcu)) {
             .void,
             .noreturn,
-            => {
-                const debug_void_type = try o.builder.debugSignedType(
-                    try o.builder.metadataString("void"),
-                    0,
-                );
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_void_type);
-                return debug_void_type;
-            },
+            .comptime_int,
+            .comptime_float,
+            .type,
+            .undefined,
+            .null,
+            .enum_literal,
+            => return o.builder.debugSignedType(name, 0),
+
             .int => {
                 const info = ty.intInfo(zcu);
-                assert(info.bits != 0);
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-                const builder_name = try o.builder.metadataString(name);
-                const debug_bits = ty.abiSize(zcu) * 8; // lldb cannot handle non-byte sized types
-                const debug_int_type = switch (info.signedness) {
-                    .signed => try o.builder.debugSignedType(builder_name, debug_bits),
-                    .unsigned => try o.builder.debugUnsignedType(builder_name, debug_bits),
+                const bits = ty.abiSize(zcu) * 8; // lldb cannot handle non-byte sized types
+                return switch (info.signedness) {
+                    .signed => try o.builder.debugSignedType(name, bits),
+                    .unsigned => try o.builder.debugUnsignedType(name, bits),
                 };
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_int_type);
-                return debug_int_type;
-            },
-            .@"enum" => {
-                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const debug_enum_type = try o.makeEmptyNamespaceDebugType(pt, ty);
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_enum_type);
-                    return debug_enum_type;
-                }
-
-                const enum_type = ip.loadEnumType(ty.toIntern());
-                const enumerators = try gpa.alloc(Builder.Metadata, enum_type.names.len);
-                defer gpa.free(enumerators);
-
-                const int_ty = Type.fromInterned(enum_type.tag_ty);
-                const int_info = ty.intInfo(zcu);
-                assert(int_info.bits != 0);
-
-                for (enum_type.names.get(ip), 0..) |field_name_ip, i| {
-                    var bigint_space: Value.BigIntSpace = undefined;
-                    const bigint = if (enum_type.values.len != 0)
-                        Value.fromInterned(enum_type.values.get(ip)[i]).toBigInt(&bigint_space, zcu)
-                    else
-                        std.math.big.int.Mutable.init(&bigint_space.limbs, i).toConst();
-
-                    enumerators[i] = try o.builder.debugEnumerator(
-                        try o.builder.metadataString(field_name_ip.toSlice(ip)),
-                        int_info.signedness == .unsigned,
-                        int_info.bits,
-                        bigint,
-                    );
-                }
-
-                const file = try o.getDebugFile(pt, ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip));
-                const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
-                    try o.namespaceToDebugScope(pt, parent_namespace)
-                else
-                    file;
-
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-
-                const debug_enum_type = try o.builder.debugEnumerationType(
-                    try o.builder.metadataString(name),
-                    file,
-                    scope,
-                    ty.typeDeclSrcLine(zcu).? + 1, // Line
-                    try o.lowerDebugType(pt, int_ty),
-                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
-                    try o.builder.metadataTuple(enumerators),
-                );
-
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_enum_type);
-                try o.debug_enums.append(gpa, debug_enum_type);
-                return debug_enum_type;
             },
             .float => {
-                const bits = ty.floatBits(target);
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-                const debug_float_type = try o.builder.debugFloatType(
-                    try o.builder.metadataString(name),
-                    bits,
-                );
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_float_type);
-                return debug_float_type;
+                return o.builder.debugFloatType(name, ty.floatBits(target));
             },
             .bool => {
-                const debug_bool_type = try o.builder.debugBoolType(
-                    try o.builder.metadataString("bool"),
+                return o.builder.debugBoolType(
+                    name,
                     8, // lldb cannot handle non-byte sized types
                 );
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_bool_type);
-                return debug_bool_type;
             },
             .pointer => {
-                // Normalize everything that the debug info does not represent.
-                const ptr_info = ty.ptrInfo(zcu);
-
-                if (ptr_info.sentinel != .none or
-                    ptr_info.flags.address_space != .generic or
-                    ptr_info.packed_offset.bit_offset != 0 or
-                    ptr_info.packed_offset.host_size != 0 or
-                    ptr_info.flags.vector_index != .none or
-                    ptr_info.flags.is_allowzero or
-                    ptr_info.flags.is_const or
-                    ptr_info.flags.is_volatile or
-                    ptr_info.flags.size == .many or ptr_info.flags.size == .c or
-                    !Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(zcu))
-                {
-                    const bland_ptr_ty = try pt.ptrType(.{
-                        .child = if (!Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(zcu))
-                            .anyopaque_type
-                        else
-                            ptr_info.child,
-                        .flags = .{
-                            .alignment = ptr_info.flags.alignment,
-                            .size = switch (ptr_info.flags.size) {
-                                .many, .c, .one => .one,
-                                .slice => .slice,
-                            },
-                        },
-                    });
-                    const debug_ptr_type = try o.lowerDebugType(pt, bland_ptr_ty);
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_ptr_type);
-                    return debug_ptr_type;
-                }
-
-                const debug_fwd_ref = try o.builder.debugForwardReference();
-
-                // Set as forward reference while the type is lowered in case it references itself
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_fwd_ref);
+                const ptr_size = Type.ptrAbiSize(zcu.getTarget());
+                const ptr_align = Type.ptrAbiAlignment(zcu.getTarget());
 
                 if (ty.isSlice(zcu)) {
-                    const ptr_ty = ty.slicePtrFieldType(zcu);
-                    const len_ty = Type.usize;
-
-                    const name = try o.allocTypeName(pt, ty);
-                    defer gpa.free(name);
-                    const line = 0;
-
-                    const ptr_size = ptr_ty.abiSize(zcu);
-                    const ptr_align = ptr_ty.abiAlignment(zcu);
-                    const len_size = len_ty.abiSize(zcu);
-                    const len_align = len_ty.abiAlignment(zcu);
-
-                    const len_offset = len_align.forward(ptr_size);
-
                     const debug_ptr_type = try o.builder.debugMemberType(
                         try o.builder.metadataString("ptr"),
                         null, // File
-                        debug_fwd_ref,
+                        ty_fwd_ref,
                         0, // Line
-                        try o.lowerDebugType(pt, ptr_ty),
+                        try o.getDebugType(pt, ty.slicePtrFieldType(zcu)),
                         ptr_size * 8,
-                        (ptr_align.toByteUnits() orelse 0) * 8,
+                        ptr_align.toByteUnits().? * 8,
                         0, // Offset
                     );
 
                     const debug_len_type = try o.builder.debugMemberType(
                         try o.builder.metadataString("len"),
                         null, // File
-                        debug_fwd_ref,
+                        ty_fwd_ref,
                         0, // Line
-                        try o.lowerDebugType(pt, len_ty),
-                        len_size * 8,
-                        (len_align.toByteUnits() orelse 0) * 8,
-                        len_offset * 8,
+                        try o.getDebugType(pt, .usize),
+                        ptr_size * 8,
+                        ptr_align.toByteUnits().? * 8,
+                        ptr_size * 8,
                     );
 
-                    const debug_slice_type = try o.builder.debugStructType(
-                        try o.builder.metadataString(name),
+                    return o.builder.debugStructType(
+                        name,
                         null, // File
                         o.debug_compile_unit.unwrap().?, // Scope
-                        line,
+                        0, // Line
                         null, // Underlying type
-                        ty.abiSize(zcu) * 8,
-                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                        ptr_size * 2 * 8,
+                        ptr_align.toByteUnits().? * 8,
                         try o.builder.metadataTuple(&.{
                             debug_ptr_type,
                             debug_len_type,
                         }),
                     );
-
-                    o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_slice_type);
-
-                    // Set to real type now that it has been lowered fully
-                    const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                    map_ptr.* = debug_slice_type;
-
-                    return debug_slice_type;
                 }
 
-                const debug_elem_ty = try o.lowerDebugType(pt, Type.fromInterned(ptr_info.child));
-
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-
-                const debug_ptr_type = try o.builder.debugPointerType(
-                    try o.builder.metadataString(name),
+                return o.builder.debugPointerType(
+                    name,
                     null, // File
                     null, // Scope
                     0, // Line
-                    debug_elem_ty,
-                    target.ptrBitWidth(),
-                    (ty.ptrAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    try o.getDebugType(pt, ty.childType(zcu)),
+                    ptr_size * 8,
+                    ptr_align.toByteUnits().? * 8,
                     0, // Offset
                 );
-
-                o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_ptr_type);
-
-                // Set to real type now that it has been lowered fully
-                const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                map_ptr.* = debug_ptr_type;
-
-                return debug_ptr_type;
-            },
-            .@"opaque" => {
-                if (ty.toIntern() == .anyopaque_type) {
-                    const debug_opaque_type = try o.builder.debugSignedType(
-                        try o.builder.metadataString("anyopaque"),
-                        0,
-                    );
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_opaque_type);
-                    return debug_opaque_type;
-                }
-
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-
-                const file = try o.getDebugFile(pt, ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip));
-                const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
-                    try o.namespaceToDebugScope(pt, parent_namespace)
-                else
-                    file;
-
-                const debug_opaque_type = try o.builder.debugStructType(
-                    try o.builder.metadataString(name),
-                    file,
-                    scope,
-                    ty.typeDeclSrcLine(zcu).? + 1, // Line
-                    null, // Underlying type
-                    0, // Size
-                    0, // Align
-                    null, // Fields
-                );
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_opaque_type);
-                return debug_opaque_type;
             },
             .array => {
-                const debug_array_type = try o.builder.debugArrayType(
+                return o.builder.debugArrayType(
                     null, // Name
                     null, // File
                     null, // Scope
                     0, // Line
-                    try o.lowerDebugType(pt, ty.childType(zcu)),
+                    try o.getDebugType(pt, ty.childType(zcu)),
                     ty.abiSize(zcu) * 8,
                     (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.metadataTuple(&.{
@@ -2108,8 +2011,6 @@ pub const Object = struct {
                         ),
                     }),
                 );
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_array_type);
-                return debug_array_type;
             },
             .vector => {
                 const elem_ty = ty.childType(zcu);
@@ -2120,23 +2021,17 @@ pub const Object = struct {
                 const debug_elem_type = switch (elem_ty.zigTypeTag(zcu)) {
                     .int => blk: {
                         const info = elem_ty.intInfo(zcu);
-                        assert(info.bits != 0);
-                        const name = try o.allocTypeName(pt, ty);
-                        defer gpa.free(name);
-                        const builder_name = try o.builder.metadataString(name);
                         break :blk switch (info.signedness) {
-                            .signed => try o.builder.debugSignedType(builder_name, info.bits),
-                            .unsigned => try o.builder.debugUnsignedType(builder_name, info.bits),
+                            .signed => try o.builder.debugSignedType(name, info.bits),
+                            .unsigned => try o.builder.debugUnsignedType(name, info.bits),
                         };
                     },
-                    .bool => try o.builder.debugBoolType(
-                        try o.builder.metadataString("bool"),
-                        1,
-                    ),
-                    else => try o.lowerDebugType(pt, ty.childType(zcu)),
+                    .bool => try o.builder.debugBoolType(try o.builder.metadataString("bool"), 1),
+                    .pointer, .optional, .float => try o.getDebugType(pt, elem_ty),
+                    else => unreachable,
                 };
 
-                const debug_vector_type = try o.builder.debugVectorType(
+                return o.builder.debugVectorType(
                     null, // Name
                     null, // File
                     null, // Scope
@@ -2151,71 +2046,64 @@ pub const Object = struct {
                         ),
                     }),
                 );
-
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_vector_type);
-                return debug_vector_type;
             },
             .optional => {
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-                const child_ty = ty.optionalChild(zcu);
-                if (!child_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const debug_bool_type = try o.builder.debugBoolType(
-                        try o.builder.metadataString(name),
-                        8,
-                    );
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_bool_type);
-                    return debug_bool_type;
-                }
-
-                const debug_fwd_ref = try o.builder.debugForwardReference();
-
-                // Set as forward reference while the type is lowered in case it references itself
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_fwd_ref);
-
+                const payload_ty = ty.optionalChild(zcu);
                 if (ty.optionalReprIsPayload(zcu)) {
-                    const debug_optional_type = try o.lowerDebugType(pt, child_ty);
-
-                    o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_optional_type);
-
-                    // Set to real type now that it has been lowered fully
-                    const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                    map_ptr.* = debug_optional_type;
-
-                    return debug_optional_type;
+                    // MLUGG TODO: these should use DW_TAG_typedef instead, but std.zig.llvm.Builder currently lacks support for those.
+                    const payload_member = try o.builder.debugMemberType(
+                        try o.builder.metadataString("payload"),
+                        null, // file
+                        ty_fwd_ref,
+                        0, // line
+                        try o.getDebugType(pt, .anyerror),
+                        ty.abiSize(zcu) * 8,
+                        ty.abiAlignment(zcu).toByteUnits().? * 8,
+                        0, // offset
+                    );
+                    return o.builder.debugStructType(
+                        name,
+                        null, // file
+                        o.debug_compile_unit.unwrap().?, // scope
+                        0, // line
+                        null, // underlying type
+                        ty.abiSize(zcu) * 8,
+                        ty.abiAlignment(zcu).toByteUnits().? * 8,
+                        try o.builder.metadataTuple(&.{payload_member}),
+                    );
                 }
 
+                const payload_size = payload_ty.abiSize(zcu);
+
                 const non_null_ty = Type.u8;
-                const payload_size = child_ty.abiSize(zcu);
-                const payload_align = child_ty.abiAlignment(zcu);
                 const non_null_size = non_null_ty.abiSize(zcu);
                 const non_null_align = non_null_ty.abiAlignment(zcu);
                 const non_null_offset = non_null_align.forward(payload_size);
 
-                const debug_data_type = try o.builder.debugMemberType(
-                    try o.builder.metadataString("data"),
-                    null, // File
-                    debug_fwd_ref,
-                    0, // Line
-                    try o.lowerDebugType(pt, child_ty),
+                const debug_payload_type = try o.builder.debugMemberType(
+                    try o.builder.metadataString("payload"),
+                    null, // file
+                    ty_fwd_ref,
+                    0, // line
+                    try o.getDebugType(pt, payload_ty),
                     payload_size * 8,
-                    (payload_align.toByteUnits() orelse 0) * 8,
-                    0, // Offset
+                    payload_ty.abiAlignment(zcu).toByteUnits().? * 8,
+                    0, // offset
                 );
 
                 const debug_some_type = try o.builder.debugMemberType(
                     try o.builder.metadataString("some"),
                     null,
-                    debug_fwd_ref,
+                    ty_fwd_ref,
                     0,
-                    try o.lowerDebugType(pt, non_null_ty),
+                    try o.getDebugType(pt, non_null_ty),
                     non_null_size * 8,
-                    (non_null_align.toByteUnits() orelse 0) * 8,
+                    non_null_align.toByteUnits().? * 8,
                     non_null_offset * 8,
                 );
 
-                const debug_optional_type = try o.builder.debugStructType(
-                    try o.builder.metadataString(name),
+                return o.builder.debugStructType(
+                    name,
                     null, // File
                     o.debug_compile_unit.unwrap().?, // Scope
                     0, // Line
@@ -2223,494 +2111,498 @@ pub const Object = struct {
                     ty.abiSize(zcu) * 8,
                     (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.metadataTuple(&.{
-                        debug_data_type,
+                        debug_payload_type,
                         debug_some_type,
                     }),
                 );
-
-                o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_optional_type);
-
-                // Set to real type now that it has been lowered fully
-                const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                map_ptr.* = debug_optional_type;
-
-                return debug_optional_type;
             },
             .error_union => {
+                const error_ty = ty.errorUnionSet(zcu);
                 const payload_ty = ty.errorUnionPayload(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    // TODO: Maybe remove?
-                    const debug_error_union_type = try o.lowerDebugType(pt, Type.anyerror);
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_error_union_type);
-                    return debug_error_union_type;
-                }
 
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-
-                const error_size = Type.anyerror.abiSize(zcu);
-                const error_align = Type.anyerror.abiAlignment(zcu);
+                const error_size = error_ty.abiSize(zcu);
+                const error_align = error_ty.abiAlignment(zcu);
                 const payload_size = payload_ty.abiSize(zcu);
                 const payload_align = payload_ty.abiAlignment(zcu);
 
-                var error_index: u32 = undefined;
-                var payload_index: u32 = undefined;
-                var error_offset: u64 = undefined;
-                var payload_offset: u64 = undefined;
-                if (error_align.compare(.gt, payload_align)) {
-                    error_index = 0;
-                    payload_index = 1;
-                    error_offset = 0;
-                    payload_offset = payload_align.forward(error_size);
-                } else {
-                    payload_index = 0;
-                    error_index = 1;
-                    payload_offset = 0;
-                    error_offset = error_align.forward(payload_size);
-                }
-
-                const debug_fwd_ref = try o.builder.debugForwardReference();
+                const error_index: u1, const payload_index: u1, const error_offset: u64, const payload_offset: u64 = fields: {
+                    if (error_align.compare(.gt, payload_align)) {
+                        break :fields .{ 0, 1, 0, payload_align.forward(error_size) };
+                    } else {
+                        break :fields .{ 1, 0, error_align.forward(payload_size), 0 };
+                    }
+                };
 
                 var fields: [2]Builder.Metadata = undefined;
                 fields[error_index] = try o.builder.debugMemberType(
-                    try o.builder.metadataString("tag"),
+                    try o.builder.metadataString("error"),
                     null, // File
-                    debug_fwd_ref,
+                    ty_fwd_ref,
                     0, // Line
-                    try o.lowerDebugType(pt, Type.anyerror),
+                    try o.getDebugType(pt, error_ty),
                     error_size * 8,
-                    (error_align.toByteUnits() orelse 0) * 8,
+                    error_align.toByteUnits().? * 8,
                     error_offset * 8,
                 );
                 fields[payload_index] = try o.builder.debugMemberType(
-                    try o.builder.metadataString("value"),
+                    try o.builder.metadataString("payload"),
                     null, // File
-                    debug_fwd_ref,
+                    ty_fwd_ref,
                     0, // Line
-                    try o.lowerDebugType(pt, payload_ty),
+                    try o.getDebugType(pt, payload_ty),
                     payload_size * 8,
-                    (payload_align.toByteUnits() orelse 0) * 8,
+                    payload_align.toByteUnits().? * 8,
                     payload_offset * 8,
                 );
 
-                const debug_error_union_type = try o.builder.debugStructType(
-                    try o.builder.metadataString(name),
+                return try o.builder.debugStructType(
+                    name,
                     null, // File
-                    o.debug_compile_unit.unwrap().?, // Sope
+                    o.debug_compile_unit.unwrap().?, // Scope
                     0, // Line
                     null, // Underlying type
                     ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
                     try o.builder.metadataTuple(&fields),
                 );
-
-                o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_error_union_type);
-
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_error_union_type);
-                return debug_error_union_type;
             },
             .error_set => {
-                const debug_error_set = try o.builder.debugUnsignedType(
-                    try o.builder.metadataString("anyerror"),
-                    16,
+                assert(ty.toIntern() != .anyerror_type); // handled specially in `updateConst`; will be populated by `emit` instead
+                // Error sets are just named wrappers around `anyerror`.
+                // MLUGG TODO: these should use DW_TAG_typedef instead, but std.zig.llvm.Builder currently lacks support for those.
+                const anyerror_member = try o.builder.debugMemberType(
+                    try o.builder.metadataString("error"),
+                    null, // file
+                    ty_fwd_ref,
+                    0, // line
+                    try o.getDebugType(pt, .anyerror),
+                    ty.abiSize(zcu) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
+                    0, // offset
+                );
+                return o.builder.debugStructType(
+                    name,
+                    null, // file
+                    o.debug_compile_unit.unwrap().?, // scope
+                    0, // line
+                    null, // underlying type
+                    ty.abiSize(zcu) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
+                    try o.builder.metadataTuple(&.{anyerror_member}),
+                );
+            },
+            .@"fn" => {
+                if (!ty.fnHasRuntimeBits(zcu)) {
+                    return o.builder.debugSignedType(name, 0);
+                }
+
+                const fn_info = zcu.typeToFunc(ty).?;
+
+                var debug_param_types: std.ArrayList(Builder.Metadata) = try .initCapacity(gpa, 3 + fn_info.param_types.len);
+                defer debug_param_types.deinit(gpa);
+
+                // Return type goes first.
+                const sret = firstParamSRet(fn_info, zcu, target);
+                const ret_ty: Type = if (sret) .void else .fromInterned(fn_info.return_type);
+                debug_param_types.appendAssumeCapacity(try o.getDebugType(pt, ret_ty));
+
+                if (sret) {
+                    const ptr_ty = try pt.singleMutPtrType(Type.fromInterned(fn_info.return_type));
+                    debug_param_types.appendAssumeCapacity(try o.getDebugType(pt, ptr_ty));
+                }
+
+                if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) {
+                    // Stack trace pointer.
+                    debug_param_types.appendAssumeCapacity(try o.getDebugType(pt, .ptr_usize));
+                }
+
+                for (fn_info.param_types.get(ip)) |param_ty_ip| {
+                    const param_ty: Type = .fromInterned(param_ty_ip);
+                    if (!param_ty.hasRuntimeBits(zcu)) continue;
+                    if (isByRef(param_ty, zcu)) {
+                        const ptr_ty = try pt.singleConstPtrType(param_ty);
+                        debug_param_types.appendAssumeCapacity(try o.getDebugType(pt, ptr_ty));
+                    } else {
+                        debug_param_types.appendAssumeCapacity(try o.getDebugType(pt, param_ty));
+                    }
+                }
+
+                return o.builder.debugSubroutineType(
+                    try o.builder.metadataTuple(debug_param_types.items),
                 );
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_error_set);
-                return debug_error_set;
             },
             .@"struct" => {
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-
-                if (zcu.typeToPackedStruct(ty)) |struct_type| {
-                    const backing_int_ty = struct_type.backingIntTypeUnordered(ip);
-                    if (backing_int_ty != .none) {
-                        const info = Type.fromInterned(backing_int_ty).intInfo(zcu);
-                        const builder_name = try o.builder.metadataString(name);
-                        const debug_int_type = switch (info.signedness) {
-                            .signed => try o.builder.debugSignedType(builder_name, ty.abiSize(zcu) * 8),
-                            .unsigned => try o.builder.debugUnsignedType(builder_name, ty.abiSize(zcu) * 8),
-                        };
-                        try o.debug_type_map.put(gpa, ty.toIntern(), debug_int_type);
-                        return debug_int_type;
+                if (ty.isTuple(zcu)) {
+                    const tuple = ip.indexToKey(ty.toIntern()).tuple_type;
+                    var fields: std.ArrayList(Builder.Metadata) = .empty;
+                    defer fields.deinit(gpa);
+
+                    try fields.ensureUnusedCapacity(gpa, tuple.types.len);
+
+                    comptime assert(struct_layout_version == 2);
+                    var offset: u64 = 0;
+
+                    for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty_ip, field_val, i| {
+                        const field_ty: Type = .fromInterned(field_ty_ip);
+                        if (field_val != .none or !field_ty.hasRuntimeBits(zcu)) continue;
+
+                        const field_size = field_ty.abiSize(zcu);
+                        const field_align = field_ty.abiAlignment(zcu);
+                        const field_offset = field_align.forward(offset);
+                        offset = field_offset + field_size;
+
+                        fields.appendAssumeCapacity(try o.builder.debugMemberType(
+                            try o.builder.metadataStringFmt("{d}", .{i}),
+                            null, // file
+                            ty_fwd_ref,
+                            0, // line
+                            try o.getDebugType(pt, field_ty),
+                            field_size * 8,
+                            field_align.toByteUnits().? * 8,
+                            field_offset * 8,
+                        ));
                     }
+
+                    return o.builder.debugStructType(
+                        name,
+                        null, // file
+                        o.debug_compile_unit.unwrap().?,
+                        0, // line
+                        null, // underlying type
+                        ty.abiSize(zcu) * 8,
+                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                        try o.builder.metadataTuple(fields.items),
+                    );
                 }
 
-                switch (ip.indexToKey(ty.toIntern())) {
-                    .tuple_type => |tuple| {
-                        var fields: std.ArrayList(Builder.Metadata) = .empty;
-                        defer fields.deinit(gpa);
+                const struct_type = zcu.typeToStruct(ty).?;
 
-                        try fields.ensureUnusedCapacity(gpa, tuple.types.len);
+                const file = try o.getDebugFile(pt, struct_type.zir_index.resolveFile(ip));
+                const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
+                    try o.namespaceToDebugScope(pt, parent_namespace)
+                else
+                    file;
 
+                const line = ty.typeDeclSrcLine(zcu).? + 1;
+
+                var fields: std.ArrayList(Builder.Metadata) = .empty;
+                defer fields.deinit(gpa);
+
+                switch (struct_type.layout) {
+                    .@"packed" => {
+                        try fields.ensureTotalCapacityPrecise(gpa, 1);
+                        fields.appendAssumeCapacity(try o.builder.debugMemberType(
+                            try o.builder.metadataString("bits"),
+                            null, // file
+                            ty_fwd_ref,
+                            0, // line
+                            try o.getDebugType(pt, .fromInterned(struct_type.packed_backing_int_type)),
+                            ty.abiSize(zcu) * 8,
+                            ty.abiAlignment(zcu).toByteUnits().? * 8,
+                            0, // offset
+                        ));
+                    },
+                    .auto, .@"extern" => {
                         comptime assert(struct_layout_version == 2);
-                        var offset: u64 = 0;
-
-                        const debug_fwd_ref = try o.builder.debugForwardReference();
-
-                        for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty, field_val, i| {
-                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
-
-                            const field_size = Type.fromInterned(field_ty).abiSize(zcu);
-                            const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
-                            const field_offset = field_align.forward(offset);
-                            offset = field_offset + field_size;
-
-                            var name_buf: [32]u8 = undefined;
-                            const field_name = std.fmt.bufPrint(&name_buf, "{d}", .{i}) catch unreachable;
-
+                        try fields.ensureTotalCapacityPrecise(gpa, struct_type.field_types.len);
+                        var it = struct_type.iterateRuntimeOrder(ip);
+                        while (it.next()) |field_index| {
+                            const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
+                            if (!field_ty.hasRuntimeBits(zcu)) continue;
+                            const field_size = field_ty.abiSize(zcu);
+                            const field_align = switch (ty.explicitFieldAlignment(field_index, zcu)) {
+                                .none => field_ty.abiAlignment(zcu),
+                                else => |a| a,
+                            };
+                            const field_offset = struct_type.field_offsets.get(ip)[field_index];
+                            const field_name = struct_type.field_names.get(ip)[field_index];
                             fields.appendAssumeCapacity(try o.builder.debugMemberType(
-                                try o.builder.metadataString(field_name),
-                                null, // File
-                                debug_fwd_ref,
-                                0,
-                                try o.lowerDebugType(pt, Type.fromInterned(field_ty)),
+                                try o.builder.metadataString(field_name.toSlice(ip)),
+                                null, // file
+                                ty_fwd_ref,
+                                0, // line
+                                try o.getDebugType(pt, field_ty),
                                 field_size * 8,
-                                (field_align.toByteUnits() orelse 0) * 8,
+                                field_align.toByteUnits().? * 8,
                                 field_offset * 8,
                             ));
                         }
-
-                        const debug_struct_type = try o.builder.debugStructType(
-                            try o.builder.metadataString(name),
-                            null, // File
-                            o.debug_compile_unit.unwrap().?, // Scope
-                            0, // Line
-                            null, // Underlying type
-                            ty.abiSize(zcu) * 8,
-                            (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
-                            try o.builder.metadataTuple(fields.items),
-                        );
-
-                        o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_struct_type);
-
-                        try o.debug_type_map.put(gpa, ty.toIntern(), debug_struct_type);
-                        return debug_struct_type;
-                    },
-                    .struct_type => {
-                        if (!ip.loadStructType(ty.toIntern()).haveFieldTypes(ip)) {
-                            // This can happen if a struct type makes it all the way to
-                            // flush() without ever being instantiated or referenced (even
-                            // via pointer). The only reason we are hearing about it now is
-                            // that it is being used as a namespace to put other debug types
-                            // into. Therefore we can satisfy this by making an empty namespace,
-                            // rather than changing the frontend to unnecessarily resolve the
-                            // struct field types.
-                            const debug_struct_type = try o.makeEmptyNamespaceDebugType(pt, ty);
-                            try o.debug_type_map.put(gpa, ty.toIntern(), debug_struct_type);
-                            return debug_struct_type;
-                        }
                     },
-                    else => {},
-                }
-
-                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const debug_struct_type = try o.makeEmptyNamespaceDebugType(pt, ty);
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_struct_type);
-                    return debug_struct_type;
-                }
-
-                const struct_type = zcu.typeToStruct(ty).?;
-
-                var fields: std.ArrayList(Builder.Metadata) = .empty;
-                defer fields.deinit(gpa);
-
-                try fields.ensureUnusedCapacity(gpa, struct_type.field_types.len);
-
-                const debug_fwd_ref = try o.builder.debugForwardReference();
-
-                // Set as forward reference while the type is lowered in case it references itself
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_fwd_ref);
-
-                comptime assert(struct_layout_version == 2);
-                var it = struct_type.iterateRuntimeOrder(ip);
-                while (it.next()) |field_index| {
-                    const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    const field_size = field_ty.abiSize(zcu);
-                    const field_align = ty.fieldAlignment(field_index, zcu);
-                    const field_offset = ty.structFieldOffset(field_index, zcu);
-                    const field_name = struct_type.fieldName(ip, field_index);
-                    fields.appendAssumeCapacity(try o.builder.debugMemberType(
-                        try o.builder.metadataString(field_name.toSlice(ip)),
-                        null, // File
-                        debug_fwd_ref,
-                        0, // Line
-                        try o.lowerDebugType(pt, field_ty),
-                        field_size * 8,
-                        (field_align.toByteUnits() orelse 0) * 8,
-                        field_offset * 8,
-                    ));
                 }
 
-                const debug_struct_type = try o.builder.debugStructType(
-                    try o.builder.metadataString(name),
-                    null, // File
-                    o.debug_compile_unit.unwrap().?, // Scope
-                    0, // Line
-                    null, // Underlying type
+                return o.builder.debugStructType(
+                    name,
+                    file,
+                    scope,
+                    line,
+                    null, // underlying type
                     ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
                     try o.builder.metadataTuple(fields.items),
                 );
-
-                o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_struct_type);
-
-                // Set to real type now that it has been lowered fully
-                const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                map_ptr.* = debug_struct_type;
-
-                return debug_struct_type;
             },
             .@"union" => {
-                const name = try o.allocTypeName(pt, ty);
-                defer gpa.free(name);
-
                 const union_type = ip.loadUnionType(ty.toIntern());
-                if (!union_type.haveFieldTypes(ip) or
-                    !ty.hasRuntimeBitsIgnoreComptime(zcu) or
-                    !union_type.haveLayout(ip))
-                {
-                    const debug_union_type = try o.makeEmptyNamespaceDebugType(pt, ty);
-                    try o.debug_type_map.put(gpa, ty.toIntern(), debug_union_type);
-                    return debug_union_type;
-                }
 
+                const file = try o.getDebugFile(pt, union_type.zir_index.resolveFile(ip));
+                const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
+                    try o.namespaceToDebugScope(pt, parent_namespace)
+                else
+                    file;
+
+                const line = ty.typeDeclSrcLine(zcu).? + 1;
+
+                const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
                 const layout = Type.getUnionLayout(union_type, zcu);
 
-                const debug_fwd_ref = try o.builder.debugForwardReference();
-
-                // Set as forward reference while the type is lowered in case it references itself
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_fwd_ref);
-
                 if (layout.payload_size == 0) {
-                    const debug_union_type = try o.builder.debugStructType(
-                        try o.builder.metadataString(name),
-                        null, // File
-                        o.debug_compile_unit.unwrap().?, // Scope
-                        0, // Line
-                        null, // Underlying type
+                    const tag_member = try o.builder.debugMemberType(
+                        try o.builder.metadataString("tag"),
+                        null, // file
+                        ty_fwd_ref,
+                        0, // line
+                        try o.getDebugType(pt, enum_tag_ty),
+                        layout.tag_size * 8,
+                        layout.tag_align.toByteUnits().? * 8,
+                        0, // offset
+                    );
+                    return o.builder.debugStructType(
+                        name,
+                        file,
+                        scope,
+                        line,
+                        null, // underlying type
                         ty.abiSize(zcu) * 8,
-                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
-                        try o.builder.metadataTuple(
-                            &.{try o.lowerDebugType(pt, Type.fromInterned(union_type.enum_tag_ty))},
-                        ),
+                        ty.abiAlignment(zcu).toByteUnits().? * 8,
+                        try o.builder.metadataTuple(&.{tag_member}),
                     );
-
-                    // Set to real type now that it has been lowered fully
-                    const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                    map_ptr.* = debug_union_type;
-
-                    return debug_union_type;
                 }
 
-                var fields: std.ArrayList(Builder.Metadata) = .empty;
+                var fields: std.ArrayList(Builder.Metadata) = try .initCapacity(gpa, union_type.field_types.len);
                 defer fields.deinit(gpa);
 
-                try fields.ensureUnusedCapacity(gpa, union_type.loadTagType(ip).names.len);
-
-                const debug_union_fwd_ref = if (layout.tag_size == 0)
-                    debug_fwd_ref
+                const payload_fwd_ref = if (layout.tag_size == 0)
+                    ty_fwd_ref
                 else
                     try o.builder.debugForwardReference();
 
-                const tag_type = union_type.loadTagType(ip);
-
-                for (0..tag_type.names.len) |field_index| {
+                for (0..union_type.field_types.len) |field_index| {
                     const field_ty = union_type.field_types.get(ip)[field_index];
-                    if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
 
                     const field_size = Type.fromInterned(field_ty).abiSize(zcu);
-                    const field_align: InternPool.Alignment = switch (union_type.flagsUnordered(ip).layout) {
+                    const field_align: InternPool.Alignment = switch (union_type.layout) {
                         .@"packed" => .none,
-                        .auto, .@"extern" => ty.fieldAlignment(field_index, zcu),
+                        .auto, .@"extern" => ty.explicitFieldAlignment(field_index, zcu),
                     };
 
-                    const field_name = tag_type.names.get(ip)[field_index];
+                    const field_name = enum_tag_ty.enumFieldName(field_index, zcu);
                     fields.appendAssumeCapacity(try o.builder.debugMemberType(
                         try o.builder.metadataString(field_name.toSlice(ip)),
-                        null, // File
-                        debug_union_fwd_ref,
-                        0, // Line
-                        try o.lowerDebugType(pt, Type.fromInterned(field_ty)),
+                        null, // file
+                        payload_fwd_ref,
+                        0, // line
+                        try o.getDebugType(pt, .fromInterned(field_ty)),
                         field_size * 8,
                         (field_align.toByteUnits() orelse 0) * 8,
-                        0, // Offset
+                        0, // offset
                     ));
                 }
 
-                var union_name_buf: ?[:0]const u8 = null;
-                defer if (union_name_buf) |buf| gpa.free(buf);
-                const union_name = if (layout.tag_size == 0) name else name: {
-                    union_name_buf = try std.fmt.allocPrintSentinel(gpa, "{s}:Payload", .{name}, 0);
-                    break :name union_name_buf.?;
-                };
-
-                const debug_union_type = try o.builder.debugUnionType(
-                    try o.builder.metadataString(union_name),
-                    null, // File
-                    o.debug_compile_unit.unwrap().?, // Scope
-                    0, // Line
-                    null, // Underlying type
+                const debug_payload_type = try o.builder.debugUnionType(
+                    payload_name: {
+                        if (layout.tag_size == 0) break :payload_name name;
+                        break :payload_name try o.builder.metadataStringFmt("{s}:Payload", .{name.slice(&o.builder)});
+                    },
+                    file,
+                    scope,
+                    line,
+                    null, // underlying type
                     layout.payload_size * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
                     try o.builder.metadataTuple(fields.items),
                 );
 
-                o.builder.resolveDebugForwardReference(debug_union_fwd_ref, debug_union_type);
-
                 if (layout.tag_size == 0) {
-                    // Set to real type now that it has been lowered fully
-                    const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                    map_ptr.* = debug_union_type;
-
-                    return debug_union_type;
+                    return debug_payload_type;
                 }
 
-                var tag_offset: u64 = undefined;
-                var payload_offset: u64 = undefined;
-                if (layout.tag_align.compare(.gte, layout.payload_align)) {
-                    tag_offset = 0;
-                    payload_offset = layout.payload_align.forward(layout.tag_size);
-                } else {
-                    payload_offset = 0;
-                    tag_offset = layout.tag_align.forward(layout.payload_size);
-                }
+                o.builder.resolveDebugForwardReference(payload_fwd_ref, debug_payload_type);
+
+                const tag_offset: u64, const payload_offset: u64 = offsets: {
+                    if (layout.tag_align.compare(.gte, layout.payload_align)) {
+                        break :offsets .{ 0, layout.payload_align.forward(layout.tag_size) };
+                    } else {
+                        break :offsets .{ layout.tag_align.forward(layout.payload_size), 0 };
+                    }
+                };
 
-                const debug_tag_type = try o.builder.debugMemberType(
+                const tag_member_type = try o.builder.debugMemberType(
                     try o.builder.metadataString("tag"),
-                    null, // File
-                    debug_fwd_ref,
-                    0, // Line
-                    try o.lowerDebugType(pt, Type.fromInterned(union_type.enum_tag_ty)),
+                    null, // file
+                    ty_fwd_ref,
+                    0, // line
+                    try o.getDebugType(pt, enum_tag_ty),
                     layout.tag_size * 8,
-                    (layout.tag_align.toByteUnits() orelse 0) * 8,
+                    layout.tag_align.toByteUnits().? * 8,
                     tag_offset * 8,
                 );
 
-                const debug_payload_type = try o.builder.debugMemberType(
+                const payload_member_type = try o.builder.debugMemberType(
                     try o.builder.metadataString("payload"),
-                    null, // File
-                    debug_fwd_ref,
-                    0, // Line
-                    debug_union_type,
+                    null, // file
+                    ty_fwd_ref,
+                    0, // line
+                    debug_payload_type,
                     layout.payload_size * 8,
-                    (layout.payload_align.toByteUnits() orelse 0) * 8,
+                    layout.payload_align.toByteUnits().? * 8,
                     payload_offset * 8,
                 );
 
                 const full_fields: [2]Builder.Metadata =
                     if (layout.tag_align.compare(.gte, layout.payload_align))
-                        .{ debug_tag_type, debug_payload_type }
+                        .{ tag_member_type, payload_member_type }
                     else
-                        .{ debug_payload_type, debug_tag_type };
+                        .{ payload_member_type, tag_member_type };
 
-                const debug_tagged_union_type = try o.builder.debugStructType(
-                    try o.builder.metadataString(name),
-                    null, // File
-                    o.debug_compile_unit.unwrap().?, // Scope
-                    0, // Line
-                    null, // Underlying type
+                return o.builder.debugStructType(
+                    name,
+                    file,
+                    scope,
+                    line,
+                    null, // underlying type
                     ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
                     try o.builder.metadataTuple(&full_fields),
                 );
+            },
+            .@"enum" => {
+                const file = try o.getDebugFile(pt, ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip));
+                const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
+                    try o.namespaceToDebugScope(pt, parent_namespace)
+                else
+                    file;
 
-                o.builder.resolveDebugForwardReference(debug_fwd_ref, debug_tagged_union_type);
-
-                // Set to real type now that it has been lowered fully
-                const map_ptr = o.debug_type_map.getPtr(ty.toIntern()) orelse unreachable;
-                map_ptr.* = debug_tagged_union_type;
+                const line = ty.typeDeclSrcLine(zcu).? + 1;
 
-                return debug_tagged_union_type;
-            },
-            .@"fn" => {
-                const fn_info = zcu.typeToFunc(ty).?;
-
-                var debug_param_types = std.array_list.Managed(Builder.Metadata).init(gpa);
-                defer debug_param_types.deinit();
-
-                try debug_param_types.ensureUnusedCapacity(3 + fn_info.param_types.len);
-
-                // Return type goes first.
-                if (Type.fromInterned(fn_info.return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const sret = firstParamSRet(fn_info, zcu, target);
-                    const ret_ty = if (sret) Type.void else Type.fromInterned(fn_info.return_type);
-                    debug_param_types.appendAssumeCapacity(try o.lowerDebugType(pt, ret_ty));
-
-                    if (sret) {
-                        const ptr_ty = try pt.singleMutPtrType(Type.fromInterned(fn_info.return_type));
-                        debug_param_types.appendAssumeCapacity(try o.lowerDebugType(pt, ptr_ty));
-                    }
-                } else {
-                    debug_param_types.appendAssumeCapacity(try o.lowerDebugType(pt, Type.void));
+                if (!ty.hasRuntimeBits(zcu)) {
+                    return o.builder.debugStructType(
+                        name,
+                        file,
+                        scope,
+                        line,
+                        null, // underlying type
+                        ty.abiSize(zcu) * 8,
+                        ty.abiAlignment(zcu).toByteUnits().? * 8,
+                        null, // fields
+                    );
                 }
 
-                if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) {
-                    // Stack trace pointer.
-                    debug_param_types.appendAssumeCapacity(try o.lowerDebugType(pt, .fromInterned(.ptr_usize_type)));
-                }
+                const enum_type = ip.loadEnumType(ty.toIntern());
+                const enumerators = try gpa.alloc(Builder.Metadata, enum_type.field_names.len);
+                defer gpa.free(enumerators);
 
-                for (0..fn_info.param_types.len) |i| {
-                    const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[i]);
-                    if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                const int_ty: Type = .fromInterned(enum_type.int_tag_type);
+                const int_info = ty.intInfo(zcu);
+                assert(int_info.bits != 0);
 
-                    if (isByRef(param_ty, zcu)) {
-                        const ptr_ty = try pt.singleMutPtrType(param_ty);
-                        debug_param_types.appendAssumeCapacity(try o.lowerDebugType(pt, ptr_ty));
-                    } else {
-                        debug_param_types.appendAssumeCapacity(try o.lowerDebugType(pt, param_ty));
-                    }
+                for (enumerators, enum_type.field_names.get(ip), 0..) |*out, field_name, field_index| {
+                    var space: Value.BigIntSpace = undefined;
+                    const field_val: std.math.big.int.Const = switch (enum_type.field_values.len) {
+                        0 => std.math.big.int.Mutable.init(&space.limbs, field_index).toConst(),
+                        else => Value.fromInterned(enum_type.field_values.get(ip)[field_index]).toBigInt(&space, zcu),
+                    };
+                    out.* = try o.builder.debugEnumerator(
+                        try o.builder.metadataString(field_name.toSlice(ip)),
+                        int_info.signedness == .unsigned,
+                        int_info.bits,
+                        field_val,
+                    );
                 }
 
-                const debug_function_type = try o.builder.debugSubroutineType(
-                    try o.builder.metadataTuple(debug_param_types.items),
+                const debug_enum_type = try o.builder.debugEnumerationType(
+                    name,
+                    file,
+                    scope,
+                    line,
+                    try o.getDebugType(pt, int_ty),
+                    ty.abiSize(zcu) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
+                    try o.builder.metadataTuple(enumerators),
                 );
-
-                try o.debug_type_map.put(gpa, ty.toIntern(), debug_function_type);
-                return debug_function_type;
+                try o.debug_enums.append(gpa, debug_enum_type);
+                return debug_enum_type;
             },
-            .comptime_int => unreachable,
-            .comptime_float => unreachable,
-            .type => unreachable,
-            .undefined => unreachable,
-            .null => unreachable,
-            .enum_literal => unreachable,
+            .@"opaque" => {
+                if (ty.toIntern() == .anyopaque_type) {
+                    return o.builder.debugSignedType(name, 0);
+                }
+
+                const file = try o.getDebugFile(pt, ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip));
+                const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
+                    try o.namespaceToDebugScope(pt, parent_namespace)
+                else
+                    file;
+
+                const line = ty.typeDeclSrcLine(zcu).? + 1;
 
+                return o.builder.debugStructType(
+                    name,
+                    file,
+                    scope,
+                    line,
+                    null, // underlying type
+                    0, // size
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
+                    null, // fields
+                );
+            },
             .frame => @panic("TODO implement lowerDebugType for Frame types"),
             .@"anyframe" => @panic("TODO implement lowerDebugType for AnyFrame types"),
         }
     }
 
+    /// Called in `emit` so that the global error set is fully populated.
+    fn lowerDebugAnyerrorType(o: *Object, pt: Zcu.PerThread) Allocator.Error!Builder.Metadata {
+        const zcu = pt.zcu;
+        const ip = &zcu.intern_pool;
+        const gpa = zcu.comp.gpa;
+
+        const error_set_bits = zcu.errorSetBits();
+        const error_names = ip.global_error_set.getNamesFromMainThread();
+
+        const enumerators = try gpa.alloc(Builder.Metadata, error_names.len);
+        defer gpa.free(enumerators);
+
+        for (enumerators, error_names, 1..) |*out, error_name, error_value| {
+            var space: Value.BigIntSpace = undefined;
+            var bigint: std.math.big.int.Mutable = .init(&space.limbs, error_value);
+            out.* = try o.builder.debugEnumerator(
+                try o.builder.metadataString(error_name.toSlice(ip)),
+                true, // unsigned
+                error_set_bits,
+                bigint.toConst(),
+            );
+        }
+
+        const debug_enum_type = try o.builder.debugEnumerationType(
+            try o.builder.metadataString("anyerror"),
+            null, // file
+            o.debug_compile_unit.unwrap().?, // scope
+            0, // line
+            try o.getDebugType(pt, try pt.intType(.unsigned, error_set_bits)),
+            Type.anyerror.abiSize(zcu) * 8,
+            Type.anyerror.abiAlignment(zcu).toByteUnits().? * 8,
+            try o.builder.metadataTuple(enumerators),
+        );
+        try o.debug_enums.append(gpa, debug_enum_type);
+        return debug_enum_type;
+    }
+
     fn namespaceToDebugScope(o: *Object, pt: Zcu.PerThread, namespace_index: InternPool.NamespaceIndex) !Builder.Metadata {
         const zcu = pt.zcu;
         const namespace = zcu.namespacePtr(namespace_index);
         if (namespace.parent == .none) return try o.getDebugFile(pt, namespace.file_scope);
-
-        const gop = try o.debug_unresolved_namespace_scopes.getOrPut(o.gpa, namespace_index);
-
-        if (!gop.found_existing) gop.value_ptr.* = try o.builder.debugForwardReference();
-
-        return gop.value_ptr.*;
-    }
-
-    fn makeEmptyNamespaceDebugType(o: *Object, pt: Zcu.PerThread, ty: Type) !Builder.Metadata {
-        const zcu = pt.zcu;
-        const ip = &zcu.intern_pool;
-        const file = try o.getDebugFile(pt, ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip));
-        const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
-            try o.namespaceToDebugScope(pt, parent_namespace)
-        else
-            file;
-        return o.builder.debugStructType(
-            try o.builder.metadataString(ty.containerTypeName(ip).toSlice(ip)), // TODO use fully qualified name
-            file,
-            scope,
-            ty.typeDeclSrcLine(zcu).? + 1,
-            null,
-            0,
-            0,
-            null,
-        );
+        return o.getDebugType(pt, .fromInterned(namespace.owner_type));
     }
 
     fn allocTypeName(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error![:0]const u8 {
@@ -2885,40 +2777,6 @@ pub const Object = struct {
 
         if (fn_info.return_type == .noreturn_type) try attributes.addFnAttr(.noreturn, &o.builder);
 
-        // Add parameter attributes. We handle only the case of extern functions (no body)
-        // because functions with bodies are handled in `updateFunc`.
-        if (is_extern) {
-            var it = iterateParamTypes(o, pt, fn_info);
-            it.llvm_index = llvm_arg_i;
-            while (try it.next()) |lowering| switch (lowering) {
-                .byval => {
-                    const param_index = it.zig_index - 1;
-                    const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[param_index]);
-                    if (!isByRef(param_ty, zcu)) {
-                        try o.addByValParamAttrs(pt, &attributes, param_ty, param_index, fn_info, it.llvm_index - 1);
-                    }
-                },
-                .byref => {
-                    const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
-                    const param_llvm_ty = try o.lowerType(pt, param_ty);
-                    const alignment = param_ty.abiAlignment(zcu);
-                    try o.addByRefParamAttrs(&attributes, it.llvm_index - 1, alignment.toLlvm(), it.byval_attr, param_llvm_ty);
-                },
-                .byref_mut => try attributes.addParamAttr(it.llvm_index - 1, .noundef, &o.builder),
-                // No attributes needed for these.
-                .no_bits,
-                .abi_sized_int,
-                .multiple_llvm_types,
-                .float_array,
-                .i32_array,
-                .i64_array,
-                => continue,
-
-                .slice => unreachable, // extern functions do not support slice types.
-
-            };
-        }
-
         function_index.setAttributes(try attributes.finish(&o.builder), &o.builder);
         return function_index;
     }
@@ -3223,7 +3081,7 @@ pub const Object = struct {
                 ),
                 .opt_type => |child_ty| {
                     // Must stay in sync with `opt_payload` logic in `lowerPtr`.
-                    if (!Type.fromInterned(child_ty).hasRuntimeBitsIgnoreComptime(zcu)) return .i8;
+                    if (!Type.fromInterned(child_ty).hasRuntimeBits(zcu)) return .i8;
 
                     const payload_ty = try o.lowerType(pt, Type.fromInterned(child_ty));
                     if (t.optionalReprIsPayload(zcu)) return payload_ty;
@@ -3245,7 +3103,7 @@ pub const Object = struct {
                     // Must stay in sync with `codegen.errUnionPayloadOffset`.
                     // See logic in `lowerPtr`.
                     const error_type = try o.errorIntType(pt);
-                    if (!Type.fromInterned(error_union_type.payload_type).hasRuntimeBitsIgnoreComptime(zcu))
+                    if (!Type.fromInterned(error_union_type.payload_type).hasRuntimeBits(zcu))
                         return error_type;
                     const payload_type = try o.lowerType(pt, Type.fromInterned(error_union_type.payload_type));
 
@@ -3287,7 +3145,7 @@ pub const Object = struct {
                     const struct_type = ip.loadStructType(t.toIntern());
 
                     if (struct_type.layout == .@"packed") {
-                        const int_ty = try o.lowerType(pt, Type.fromInterned(struct_type.backingIntTypeUnordered(ip)));
+                        const int_ty = try o.lowerType(pt, .fromInterned(struct_type.packed_backing_int_type));
                         try o.type_map.put(o.gpa, t.toIntern(), int_ty);
                         return int_ty;
                     }
@@ -3301,18 +3159,16 @@ pub const Object = struct {
 
                     comptime assert(struct_layout_version == 2);
                     var offset: u64 = 0;
-                    var big_align: InternPool.Alignment = .@"1";
                     var struct_kind: Builder.Type.Structure.Kind = .normal;
                     // When we encounter a zero-bit field, we place it here so we know to map it to the next non-zero-bit field (if any).
                     var it = struct_type.iterateRuntimeOrder(ip);
                     while (it.next()) |field_index| {
                         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                        const field_align = t.fieldAlignment(field_index, zcu);
-                        const field_ty_align = field_ty.abiAlignment(zcu);
-                        if (field_align.compare(.lt, field_ty_align)) struct_kind = .@"packed";
-                        big_align = big_align.max(field_align);
                         const prev_offset = offset;
-                        offset = field_align.forward(offset);
+                        offset = struct_type.field_offsets.get(ip)[field_index];
+                        if (@ctz(offset) < field_ty.abiAlignment(zcu).toLog2Units()) {
+                            struct_kind = .@"packed";
+                        }
 
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) try llvm_field_types.append(
@@ -3320,11 +3176,11 @@ pub const Object = struct {
                             try o.builder.arrayType(padding_len, .i8),
                         );
 
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                        if (!field_ty.hasRuntimeBits(zcu)) {
                             // This is a zero-bit field. If there are runtime bits after this field,
                             // map to the next LLVM field (which we know exists): otherwise, don't
                             // map the field, indicating it's at the end of the struct.
-                            if (offset != struct_type.sizeUnordered(ip)) {
+                            if (offset != struct_type.size) {
                                 try o.struct_field_map.put(o.gpa, .{
                                     .struct_ty = t.toIntern(),
                                     .field_index = field_index,
@@ -3343,7 +3199,7 @@ pub const Object = struct {
                     }
                     {
                         const prev_offset = offset;
-                        offset = big_align.forward(offset);
+                        offset = struct_type.alignment.forward(offset);
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) try llvm_field_types.append(
                             o.gpa,
@@ -3391,7 +3247,7 @@ pub const Object = struct {
                             o.gpa,
                             try o.builder.arrayType(padding_len, .i8),
                         );
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) {
+                        if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) {
                             // This is a zero-bit field. If there are runtime bits after this field,
                             // map to the next LLVM field (which we know exists): otherwise, don't
                             // map the field, indicating it's at the end of the struct.
@@ -3428,14 +3284,14 @@ pub const Object = struct {
                     const union_obj = ip.loadUnionType(t.toIntern());
                     const layout = Type.getUnionLayout(union_obj, zcu);
 
-                    if (union_obj.flagsUnordered(ip).layout == .@"packed") {
-                        const int_ty = try o.builder.intType(@intCast(t.bitSize(zcu)));
+                    if (union_obj.layout == .@"packed") {
+                        const int_ty = try o.lowerType(pt, .fromInterned(union_obj.packed_backing_int_type));
                         try o.type_map.put(o.gpa, t.toIntern(), int_ty);
                         return int_ty;
                     }
 
                     if (layout.payload_size == 0) {
-                        const enum_tag_ty = try o.lowerType(pt, Type.fromInterned(union_obj.enum_tag_ty));
+                        const enum_tag_ty = try o.lowerType(pt, .fromInterned(union_obj.enum_tag_type));
                         try o.type_map.put(o.gpa, t.toIntern(), enum_tag_ty);
                         return enum_tag_ty;
                     }
@@ -3467,7 +3323,7 @@ pub const Object = struct {
                         );
                         return ty;
                     }
-                    const enum_tag_ty = try o.lowerType(pt, Type.fromInterned(union_obj.enum_tag_ty));
+                    const enum_tag_ty = try o.lowerType(pt, .fromInterned(union_obj.enum_tag_type));
 
                     // Put the tag before or after the payload depending on which one's
                     // alignment is greater.
@@ -3502,7 +3358,7 @@ pub const Object = struct {
                     }
                     return gop.value_ptr.*;
                 },
-                .enum_type => try o.lowerType(pt, Type.fromInterned(ip.loadEnumType(t.toIntern()).tag_ty)),
+                .enum_type => try o.lowerType(pt, t.intTagType(zcu)),
                 .func_type => |func_type| try o.lowerTypeFn(pt, func_type),
                 .error_set_type, .inferred_error_set_type => try o.errorIntType(pt),
                 // values, not types
@@ -3522,6 +3378,7 @@ pub const Object = struct {
                 .opt,
                 .aggregate,
                 .un,
+                .bitpack,
                 // memoization, not types
                 .memoized_call,
                 => unreachable,
@@ -3529,20 +3386,6 @@ pub const Object = struct {
         };
     }
 
-    /// Use this instead of lowerType when you want to handle correctly the case of elem_ty
-    /// being a zero bit type, but it should still be lowered as an i8 in such case.
-    /// There are other similar cases handled here as well.
-    fn lowerPtrElemTy(o: *Object, pt: Zcu.PerThread, elem_ty: Type) Allocator.Error!Builder.Type {
-        const zcu = pt.zcu;
-        const lower_elem_ty = switch (elem_ty.zigTypeTag(zcu)) {
-            .@"opaque" => true,
-            .@"fn" => !zcu.typeToFunc(elem_ty).?.is_generic,
-            .array => elem_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu),
-            else => elem_ty.hasRuntimeBitsIgnoreComptime(zcu),
-        };
-        return if (lower_elem_ty) try o.lowerType(pt, elem_ty) else .i8;
-    }
-
     fn lowerTypeFn(o: *Object, pt: Zcu.PerThread, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
@@ -3641,7 +3484,7 @@ pub const Object = struct {
                 if (layout.payload_size == 0) return o.lowerValue(pt, un.tag);
 
                 const union_obj = zcu.typeToUnion(ty).?;
-                const container_layout = union_obj.flagsUnordered(ip).layout;
+                const container_layout = union_obj.layout;
 
                 assert(container_layout == .@"packed");
 
@@ -3699,7 +3542,9 @@ pub const Object = struct {
             return o.builder.undefConst(try o.lowerType(pt, Type.fromInterned(val_key.typeOf())));
         }
 
-        const ty = Type.fromInterned(val_key.typeOf());
+        const ty: Type = .fromInterned(val_key.typeOf());
+        ty.assertHasLayout(zcu);
+
         return switch (val_key) {
             .int_type,
             .ptr_type,
@@ -3759,7 +3604,7 @@ pub const Object = struct {
                 };
                 const err_int_ty = try pt.errorIntType();
                 const payload_type = ty.errorUnionPayload(zcu);
-                if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+                if (!payload_type.hasRuntimeBits(zcu)) {
                     // We use the error type directly as the type.
                     return o.lowerValue(pt, err_val);
                 }
@@ -3821,7 +3666,7 @@ pub const Object = struct {
                 const payload_ty = ty.optionalChild(zcu);
 
                 const non_null_bit = try o.builder.intConst(.i8, @intFromBool(opt.val != .none));
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                if (!payload_ty.hasRuntimeBits(zcu)) {
                     return non_null_bit;
                 }
                 const llvm_ty = try o.lowerType(pt, ty);
@@ -3857,6 +3702,7 @@ pub const Object = struct {
                     fields[0..llvm_ty_fields.len],
                 ), vals[0..llvm_ty_fields.len]);
             },
+            .bitpack => |bitpack| return o.lowerValue(pt, bitpack.backing_int_val),
             .aggregate => |aggregate| switch (ip.indexToKey(ty.toIntern())) {
                 .array_type => |array_type| switch (aggregate.storage) {
                     .bytes => |bytes| try o.builder.stringConst(try o.builder.string(
@@ -3988,7 +3834,7 @@ pub const Object = struct {
                         0..,
                     ) |field_ty, field_val, field_index| {
                         if (field_val != .none) continue;
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
 
                         const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
                         big_align = big_align.max(field_align);
@@ -4034,16 +3880,8 @@ pub const Object = struct {
                 },
                 .struct_type => {
                     const struct_type = ip.loadStructType(ty.toIntern());
-                    assert(struct_type.haveLayout(ip));
                     const struct_ty = try o.lowerType(pt, ty);
-                    if (struct_type.layout == .@"packed") {
-                        comptime assert(Type.packed_struct_layout_version == 2);
-
-                        const bits = ty.bitSize(zcu);
-                        const llvm_int_ty = try o.builder.intType(@intCast(bits));
-
-                        return o.lowerValueToInt(pt, llvm_int_ty, arg_val);
-                    }
+                    assert(struct_type.layout != .@"packed");
                     const llvm_len = struct_ty.aggregateLen(&o.builder);
 
                     const ExpectedContents = extern struct {
@@ -4063,15 +3901,12 @@ pub const Object = struct {
                     comptime assert(struct_layout_version == 2);
                     var llvm_index: usize = 0;
                     var offset: u64 = 0;
-                    var big_align: InternPool.Alignment = .@"1";
                     var need_unnamed = false;
                     var field_it = struct_type.iterateRuntimeOrder(ip);
                     while (field_it.next()) |field_index| {
                         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                        const field_align = ty.fieldAlignment(field_index, zcu);
-                        big_align = big_align.max(field_align);
                         const prev_offset = offset;
-                        offset = field_align.forward(offset);
+                        offset = struct_type.field_offsets.get(ip)[field_index];
 
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) {
@@ -4084,7 +3919,7 @@ pub const Object = struct {
                             llvm_index += 1;
                         }
 
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                        if (!field_ty.hasRuntimeBits(zcu)) {
                             // This is a zero-bit field - we only needed it for the alignment.
                             continue;
                         }
@@ -4102,7 +3937,7 @@ pub const Object = struct {
                     }
                     {
                         const prev_offset = offset;
-                        offset = big_align.forward(offset);
+                        offset = struct_type.alignment.forward(offset);
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) {
                             fields[llvm_index] = try o.builder.arrayType(padding_len, .i8);
@@ -4126,19 +3961,13 @@ pub const Object = struct {
                 if (layout.payload_size == 0) return o.lowerValue(pt, un.tag);
 
                 const union_obj = zcu.typeToUnion(ty).?;
-                const container_layout = union_obj.flagsUnordered(ip).layout;
+                const container_layout = union_obj.layout;
+                assert(container_layout != .@"packed");
 
                 var need_unnamed = false;
                 const payload = if (un.tag != .none) p: {
                     const field_index = zcu.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
                     const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-                    if (container_layout == .@"packed") {
-                        if (!field_ty.hasRuntimeBits(zcu)) return o.builder.intConst(union_ty, 0);
-                        const bits = ty.bitSize(zcu);
-                        const llvm_int_ty = try o.builder.intType(@intCast(bits));
-
-                        return o.lowerValueToInt(pt, llvm_int_ty, arg_val);
-                    }
 
                     // Sometimes we must make an unnamed struct because LLVM does
                     // not support bitcasting our payload struct to the true union payload type.
@@ -4146,7 +3975,7 @@ pub const Object = struct {
                     // must pointer cast to the expected type before accessing the union.
                     need_unnamed = layout.most_aligned_field != field_index;
 
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                    if (!field_ty.hasRuntimeBits(zcu)) {
                         const padding_len = layout.payload_size;
                         break :p try o.builder.undefConst(try o.builder.arrayType(padding_len, .i8));
                     }
@@ -4165,13 +3994,6 @@ pub const Object = struct {
                     );
                 } else p: {
                     assert(layout.tag_size == 0);
-                    if (container_layout == .@"packed") {
-                        const bits = ty.bitSize(zcu);
-                        const llvm_int_ty = try o.builder.intType(@intCast(bits));
-
-                        return o.lowerValueToInt(pt, llvm_int_ty, arg_val);
-                    }
-
                     const union_val = try o.lowerValue(pt, un.val);
                     need_unnamed = true;
                     break :p union_val;
@@ -4273,7 +4095,14 @@ pub const Object = struct {
                 };
                 return o.lowerPtr(pt, field.base, offset + field_off);
             },
-            .arr_elem, .comptime_field, .comptime_alloc => unreachable,
+            .arr_elem => |arr_elem| {
+                const base_ptr_ty = Value.fromInterned(arr_elem.base).typeOf(zcu);
+                assert(base_ptr_ty.ptrSize(zcu) == .many);
+                const elem_size = base_ptr_ty.childType(zcu).abiSize(zcu);
+                return o.lowerPtr(pt, arr_elem.base, offset + elem_size * arr_elem.index);
+            },
+            .comptime_field => unreachable,
+            .comptime_alloc => unreachable,
         };
     }
 
@@ -4298,12 +4127,11 @@ pub const Object = struct {
 
         const ptr_ty = Type.fromInterned(uav.orig_ty);
 
-        const is_fn_body = uav_ty.zigTypeTag(zcu) == .@"fn";
-        if ((!is_fn_body and !uav_ty.hasRuntimeBits(zcu)) or
-            (is_fn_body and zcu.typeToFunc(uav_ty).?.is_generic)) return o.lowerPtrToVoid(pt, ptr_ty);
+        if (!uav_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
+            return o.lowerPtrToVoid(pt, ptr_ty);
+        }
 
-        if (is_fn_body)
-            @panic("TODO");
+        assert(uav_ty.zigTypeTag(zcu) != .@"fn"); // should be using a Nav ref
 
         const llvm_addr_space = toLlvmAddressSpace(ptr_ty.ptrAddressSpace(zcu), target);
         const alignment = ptr_ty.ptrAlignment(zcu);
@@ -4326,14 +4154,11 @@ pub const Object = struct {
         const nav_ty = Type.fromInterned(nav.typeOf(ip));
         const ptr_ty = try pt.navPtrType(nav_index);
 
-        const is_fn_body = nav_ty.zigTypeTag(zcu) == .@"fn";
-        if ((!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) or
-            (is_fn_body and zcu.typeToFunc(nav_ty).?.is_generic))
-        {
+        if (nav.getExtern(ip) == null and !nav_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
             return o.lowerPtrToVoid(pt, ptr_ty);
         }
 
-        const llvm_global = if (is_fn_body)
+        const llvm_global = if (nav_ty.zigTypeTag(zcu) == .@"fn")
             (try o.resolveLlvmFunction(pt, nav_index)).ptrConst(&o.builder).global
         else
             (try o.resolveGlobalNav(pt, nav_index)).ptrConst(&o.builder).global;
@@ -4376,21 +4201,18 @@ pub const Object = struct {
     /// types to work around a LLVM deficiency when targeting ARM/AArch64.
     fn getAtomicAbiType(o: *Object, pt: Zcu.PerThread, ty: Type, is_rmw_xchg: bool) Allocator.Error!Builder.Type {
         const zcu = pt.zcu;
-        const ip = &zcu.intern_pool;
-        const int_ty = switch (ty.zigTypeTag(zcu)) {
-            .int => ty,
-            .@"enum" => ty.intTagType(zcu),
-            .@"struct" => Type.fromInterned(ip.loadStructType(ty.toIntern()).backingIntTypeUnordered(ip)),
+        switch (ty.zigTypeTag(zcu)) {
+            .int, .@"enum", .@"struct", .@"union" => {},
             .float => {
                 if (!is_rmw_xchg) return .none;
                 return o.builder.intType(@intCast(ty.abiSize(zcu) * 8));
             },
             .bool => return .i8,
             else => return .none,
-        };
-        const bit_count = int_ty.intInfo(zcu).bits;
+        }
+        const bit_count = ty.bitSize(zcu);
         if (!std.math.isPowerOfTwo(bit_count) or (bit_count % 8) != 0) {
-            return o.builder.intType(@intCast(int_ty.abiSize(zcu) * 8));
+            return o.builder.intType(@intCast(ty.abiSize(zcu) * 8));
         } else {
             return .none;
         }
@@ -4498,7 +4320,7 @@ pub const Object = struct {
         const ret_ty = try o.lowerType(pt, Type.slice_const_u8_sentinel_0);
         const target = &zcu.root_mod.resolved_target.result;
         const function_index = try o.builder.addFunction(
-            try o.builder.fnType(ret_ty, &.{try o.lowerType(pt, Type.fromInterned(enum_type.tag_ty))}, .normal),
+            try o.builder.fnType(ret_ty, &.{try o.lowerType(pt, Type.fromInterned(enum_type.int_tag_type))}, .normal),
             try o.builder.strtabStringFmt("__zig_tag_name_{f}", .{enum_type.name.fmt(ip)}),
             toLlvmAddressSpace(.generic, target),
         );
@@ -4521,12 +4343,16 @@ pub const Object = struct {
 
         const bad_value_block = try wip.block(1, "BadValue");
         const tag_int_value = wip.arg(0);
-        var wip_switch =
-            try wip.@"switch"(tag_int_value, bad_value_block, @intCast(enum_type.names.len), .none);
+        var wip_switch = try wip.@"switch"(
+            tag_int_value,
+            bad_value_block,
+            @intCast(enum_type.field_names.len),
+            .none,
+        );
         defer wip_switch.finish(&wip);
 
-        for (0..enum_type.names.len) |field_index| {
-            const name = try o.builder.stringNull(enum_type.names.get(ip)[field_index].toSlice(ip));
+        for (0..enum_type.field_names.len) |field_index| {
+            const name = try o.builder.stringNull(enum_type.field_names.get(ip)[field_index].toSlice(ip));
             const name_init = try o.builder.stringConst(name);
             const name_variable_index =
                 try o.builder.addVariable(.empty, name_init.typeOf(&o.builder), .default);
@@ -4597,7 +4423,41 @@ pub const NavGen = struct {
         const ty = Type.fromInterned(nav.typeOf(ip));
 
         if (linkage != .internal and ip.isFunctionType(ty.toIntern())) {
-            _ = try o.resolveLlvmFunction(pt, owner_nav);
+            const function_index = try o.resolveLlvmFunction(pt, owner_nav);
+            // Add parameter attributes which weren't set by `resolveLlvmFunction`
+            const fn_info = zcu.typeToFunc(ty).?;
+            var attributes = try function_index.ptrConst(&o.builder).attributes.toWip(&o.builder);
+            defer attributes.deinit(&o.builder);
+            var it = iterateParamTypes(o, pt, fn_info);
+            if (firstParamSRet(fn_info, zcu, zcu.getTarget())) it.llvm_index += 1;
+            if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) it.llvm_index += 1;
+            while (try it.next()) |lowering| switch (lowering) {
+                .byval => {
+                    const param_index = it.zig_index - 1;
+                    const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[param_index]);
+                    if (!isByRef(param_ty, zcu)) {
+                        try o.addByValParamAttrs(pt, &attributes, param_ty, param_index, fn_info, it.llvm_index - 1);
+                    }
+                },
+                .byref => {
+                    const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
+                    const param_llvm_ty = try o.lowerType(pt, param_ty);
+                    const alignment = param_ty.abiAlignment(zcu);
+                    try o.addByRefParamAttrs(&attributes, it.llvm_index - 1, alignment.toLlvm(), it.byval_attr, param_llvm_ty);
+                },
+                .byref_mut => try attributes.addParamAttr(it.llvm_index - 1, .noundef, &o.builder),
+                // No attributes needed for these.
+                .no_bits,
+                .abi_sized_int,
+                .multiple_llvm_types,
+                .float_array,
+                .i32_array,
+                .i64_array,
+                => continue,
+
+                .slice => unreachable, // extern functions do not support slice types.
+            };
+            function_index.setAttributes(try attributes.finish(&o.builder), &o.builder);
         } else {
             const variable_index = try o.resolveGlobalNav(pt, nav_index);
             variable_index.setAlignment(zcu.navAlignment(nav_index).toLlvm(), &o.builder);
@@ -4626,7 +4486,7 @@ pub const NavGen = struct {
                     debug_file, // File
                     debug_file, // Scope
                     line_number,
-                    try o.lowerDebugType(pt, ty),
+                    try o.getDebugType(pt, ty),
                     variable_index,
                     .{ .local = linkage == .internal },
                 );
@@ -4748,7 +4608,7 @@ pub const FuncGen = struct {
     /// Have we seen loads or stores involving `allowzero` pointers?
     allowzero_access: bool = false,
 
-    pub fn maybeMarkAllowZeroAccess(self: *FuncGen, info: InternPool.Key.PtrType) void {
+    fn maybeMarkAllowZeroAccess(self: *FuncGen, info: InternPool.Key.PtrType) void {
         // LLVM already considers null pointers to be valid in non-generic address spaces, so avoid
         // pessimizing optimization for functions with accesses to such pointers.
         if (info.flags.address_space == .generic and info.flags.is_allowzero) self.allowzero_access = true;
@@ -5216,7 +5076,7 @@ pub const FuncGen = struct {
                 try o.builder.metadataString(nav.fqn.toSlice(&zcu.intern_pool)),
                 line_number,
                 line_number + func.lbrace_line,
-                try o.lowerDebugType(pt, fn_ty),
+                try o.getDebugType(pt, fn_ty),
                 .{
                     .di_flags = .{ .StaticMember = true },
                     .sp_flags = .{
@@ -5514,7 +5374,7 @@ pub const FuncGen = struct {
             return .none;
         }
 
-        if (self.liveness.isUnused(inst) or !return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (self.liveness.isUnused(inst) or !return_type.hasRuntimeBits(zcu)) {
             return .none;
         }
 
@@ -5633,7 +5493,7 @@ pub const FuncGen = struct {
             return;
         }
         const fn_info = zcu.typeToFunc(Type.fromInterned(ip.getNav(self.ng.nav_index).typeOf(ip))).?;
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!ret_ty.hasRuntimeBits(zcu)) {
             if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
                 // Functions with an empty error set are emitted with an error code
                 // return type and return zero so they can be function pointers coerced
@@ -5698,7 +5558,7 @@ pub const FuncGen = struct {
         const ptr_ty = self.typeOf(un_op);
         const ret_ty = ptr_ty.childType(zcu);
         const fn_info = zcu.typeToFunc(Type.fromInterned(ip.getNav(self.ng.nav_index).typeOf(ip))).?;
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!ret_ty.hasRuntimeBits(zcu)) {
             if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
                 // Functions with an empty error set are emitted with an error code
                 // return type and return zero so they can be function pointers coerced
@@ -5829,14 +5689,13 @@ pub const FuncGen = struct {
         const o = self.ng.object;
         const pt = self.ng.pt;
         const zcu = pt.zcu;
-        const ip = &zcu.intern_pool;
         const scalar_ty = operand_ty.scalarType(zcu);
         const int_ty = switch (scalar_ty.zigTypeTag(zcu)) {
             .@"enum" => scalar_ty.intTagType(zcu),
             .int, .bool, .pointer, .error_set => scalar_ty,
             .optional => blk: {
                 const payload_ty = operand_ty.optionalChild(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu) or
+                if (!payload_ty.hasRuntimeBits(zcu) or
                     operand_ty.optionalReprIsPayload(zcu))
                 {
                     break :blk operand_ty;
@@ -5908,12 +5767,7 @@ pub const FuncGen = struct {
                 return phi.toValue();
             },
             .float => return self.buildFloatCmp(fast, op, operand_ty, .{ lhs, rhs }),
-            .@"struct" => blk: {
-                const struct_obj = ip.loadStructType(scalar_ty.toIntern());
-                assert(struct_obj.layout == .@"packed");
-                const backing_index = struct_obj.backingIntTypeUnordered(ip);
-                break :blk Type.fromInterned(backing_index);
-            },
+            .@"struct" => scalar_ty.bitpackBackingInt(zcu),
             else => unreachable,
         };
         const is_signed = int_ty.isSignedInt(zcu);
@@ -6305,7 +6159,7 @@ pub const FuncGen = struct {
         const pt = fg.ng.pt;
         const zcu = pt.zcu;
         const payload_ty = err_union_ty.errorUnionPayload(zcu);
-        const payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
+        const payload_has_bits = payload_ty.hasRuntimeBits(zcu);
         const err_union_llvm_ty = try o.lowerType(pt, err_union_ty);
         const error_type = try o.errorIntType(pt);
 
@@ -6641,7 +6495,7 @@ pub const FuncGen = struct {
         const len = try o.builder.intValue(llvm_usize, array_ty.arrayLen(zcu));
         const slice_llvm_ty = try o.lowerType(pt, self.typeOfIndex(inst));
         const operand = try self.resolveInst(ty_op.operand);
-        if (!array_ty.hasRuntimeBitsIgnoreComptime(zcu))
+        if (!array_ty.hasRuntimeBits(zcu))
             return self.wip.buildAggregate(slice_llvm_ty, &.{ operand, len }, "");
         const ptr = try self.wip.gep(.inbounds, try o.lowerType(pt, array_ty), operand, &.{
             try o.builder.intValue(llvm_usize, 0), try o.builder.intValue(llvm_usize, 0),
@@ -6824,7 +6678,7 @@ pub const FuncGen = struct {
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const slice_ptr = try self.resolveInst(ty_op.operand);
         const slice_ptr_ty = self.typeOf(ty_op.operand);
-        const slice_llvm_ty = try o.lowerPtrElemTy(pt, slice_ptr_ty.childType(zcu));
+        const slice_llvm_ty = try o.lowerType(pt, slice_ptr_ty.childType(zcu));
 
         return self.wip.gepStruct(slice_llvm_ty, slice_ptr, index, "");
     }
@@ -6838,7 +6692,7 @@ pub const FuncGen = struct {
         const slice = try self.resolveInst(bin_op.lhs);
         const index = try self.resolveInst(bin_op.rhs);
         const elem_ty = slice_ty.childType(zcu);
-        const llvm_elem_ty = try o.lowerPtrElemTy(pt, elem_ty);
+        const llvm_elem_ty = try o.lowerType(pt, elem_ty);
         const base_ptr = try self.wip.extractValue(slice, &.{0}, "");
         const ptr = try self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, &.{index}, "");
         if (isByRef(elem_ty, zcu)) {
@@ -6863,7 +6717,7 @@ pub const FuncGen = struct {
 
         const slice = try self.resolveInst(bin_op.lhs);
         const index = try self.resolveInst(bin_op.rhs);
-        const llvm_elem_ty = try o.lowerPtrElemTy(pt, slice_ty.childType(zcu));
+        const llvm_elem_ty = try o.lowerType(pt, slice_ty.childType(zcu));
         const base_ptr = try self.wip.extractValue(slice, &.{0}, "");
         return self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, &.{index}, "");
     }
@@ -6903,7 +6757,7 @@ pub const FuncGen = struct {
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
         const elem_ty = ptr_ty.childType(zcu);
-        const llvm_elem_ty = try o.lowerPtrElemTy(pt, elem_ty);
+        const llvm_elem_ty = try o.lowerType(pt, elem_ty);
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         // TODO: when we go fully opaque pointers in LLVM 16 we can remove this branch
@@ -6930,8 +6784,8 @@ pub const FuncGen = struct {
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = ptr_ty.childType(zcu);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return self.resolveInst(bin_op.lhs);
+        const elem_ty = ptr_ty.indexableElem(zcu);
+        assert(elem_ty.hasRuntimeBits(zcu));
 
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
@@ -6939,12 +6793,8 @@ pub const FuncGen = struct {
         const elem_ptr = ty_pl.ty.toType();
         if (elem_ptr.ptrInfo(zcu).flags.vector_index != .none) return base_ptr;
 
-        const llvm_elem_ty = try o.lowerPtrElemTy(pt, elem_ty);
-        return self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, if (ptr_ty.isSinglePointer(zcu))
-            // If this is a single-item pointer to an array, we need another index in the GEP.
-            &.{ try o.builder.intValue(try o.lowerType(pt, Type.usize), 0), rhs }
-        else
-            &.{rhs}, "");
+        const llvm_elem_ty = try o.lowerType(pt, elem_ty);
+        return self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, &.{rhs}, "");
     }
 
     fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
@@ -6976,7 +6826,7 @@ pub const FuncGen = struct {
         const struct_llvm_val = try self.resolveInst(struct_field.struct_operand);
         const field_index = struct_field.field_index;
         const field_ty = struct_ty.fieldType(field_index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
+        if (!field_ty.hasRuntimeBits(zcu)) return .none;
 
         if (!isByRef(struct_ty, zcu)) {
             assert(!isByRef(field_ty, zcu));
@@ -7037,15 +6887,17 @@ pub const FuncGen = struct {
                 const llvm_field_index = o.llvmFieldIndex(struct_ty, field_index).?;
                 const field_ptr =
                     try self.wip.gepStruct(struct_llvm_ty, struct_llvm_val, llvm_field_index, "");
-                const alignment = struct_ty.fieldAlignment(field_index, zcu);
+                const explicit_alignment = struct_ty.explicitFieldAlignment(field_index, zcu);
                 const field_ptr_ty = try pt.ptrType(.{
                     .child = field_ty.toIntern(),
-                    .flags = .{ .alignment = alignment },
+                    .flags = .{ .alignment = explicit_alignment },
                 });
                 if (isByRef(field_ty, zcu)) {
-                    assert(alignment != .none);
-                    const field_alignment = alignment.toLlvm();
-                    return self.loadByRef(field_ptr, field_ty, field_alignment, .normal);
+                    const alignment = switch (explicit_alignment) {
+                        .none => field_ty.abiAlignment(zcu),
+                        else => |a| a,
+                    };
+                    return self.loadByRef(field_ptr, field_ty, alignment.toLlvm(), .normal);
                 } else {
                     return self.load(field_ptr, field_ptr_ty);
                 }
@@ -7146,7 +6998,7 @@ pub const FuncGen = struct {
             self.file,
             self.scope,
             self.prev_dbg_line,
-            try o.lowerDebugType(pt, ptr_ty.childType(zcu)),
+            try o.getDebugType(pt, ptr_ty.childType(zcu)),
         );
 
         _ = try self.wip.callIntrinsic(
@@ -7179,7 +7031,7 @@ pub const FuncGen = struct {
             self.file,
             self.scope,
             self.prev_dbg_line,
-            try o.lowerDebugType(pt, operand_ty),
+            try o.getDebugType(pt, operand_ty),
             arg_no: {
                 self.arg_inline_index += 1;
                 break :arg_no self.arg_inline_index;
@@ -7189,7 +7041,7 @@ pub const FuncGen = struct {
             self.file,
             self.scope,
             self.prev_dbg_line,
-            try o.lowerDebugType(pt, operand_ty),
+            try o.getDebugType(pt, operand_ty),
         );
 
         const zcu = pt.zcu;
@@ -7280,6 +7132,7 @@ pub const FuncGen = struct {
         const llvm_param_attrs = try arena.alloc(Builder.Type, max_param_count);
         const pt = self.ng.pt;
         const zcu = pt.zcu;
+        const ip = &zcu.intern_pool;
         const target = zcu.getTarget();
 
         var llvm_ret_i: usize = 0;
@@ -7304,7 +7157,7 @@ pub const FuncGen = struct {
                 const output_inst = try self.resolveInst(output.operand);
                 const output_ty = self.typeOf(output.operand);
                 assert(output_ty.zigTypeTag(zcu) == .pointer);
-                const elem_llvm_ty = try o.lowerPtrElemTy(pt, output_ty.childType(zcu));
+                const elem_llvm_ty = try o.lowerType(pt, output_ty.childType(zcu));
 
                 switch (constraint[0]) {
                     '=' => {},
@@ -7422,7 +7275,7 @@ pub const FuncGen = struct {
             llvm_param_attrs[llvm_param_i] = if (constraint[0] == '*') blk: {
                 if (!is_by_ref) self.maybeMarkAllowZeroAccess(arg_ty.ptrInfo(zcu));
 
-                break :blk try o.lowerPtrElemTy(pt, if (is_by_ref) arg_ty else arg_ty.childType(zcu));
+                break :blk try o.lowerType(pt, if (is_by_ref) arg_ty else arg_ty.childType(zcu));
             } else .none;
 
             llvm_param_i += 1;
@@ -7436,7 +7289,7 @@ pub const FuncGen = struct {
             if (constraint[0] != '+') continue;
 
             const rw_ty = self.typeOf(output.operand);
-            const llvm_elem_ty = try o.lowerPtrElemTy(pt, rw_ty.childType(zcu));
+            const llvm_elem_ty = try o.lowerType(pt, rw_ty.childType(zcu));
             if (llvm_ret_indirect[output.index]) {
                 llvm_param_values[llvm_param_i] = llvm_rw_vals[output.index];
                 llvm_param_types[llvm_param_i] = llvm_rw_vals[output.index].typeOfWip(&self.wip);
@@ -7463,7 +7316,7 @@ pub const FuncGen = struct {
             total_i += 1;
         }
 
-        const ip = &zcu.intern_pool;
+        if (total_i != 0) try llvm_constraints.append(gpa, ',');
         const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
         const clobbers_ty = clobbers_val.typeOf(zcu);
         var clobbers_bigint_buf: Value.BigIntSpace = undefined;
@@ -7663,7 +7516,7 @@ pub const FuncGen = struct {
 
         comptime assert(optional_layout_version == 3);
 
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             const loaded = if (operand_is_ptr)
                 try self.wip.load(access_kind, optional_llvm_ty, operand, .default, "")
             else
@@ -7706,7 +7559,7 @@ pub const FuncGen = struct {
 
         if (operand_is_ptr) self.maybeMarkAllowZeroAccess(operand_ty.ptrInfo(zcu));
 
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             const loaded = if (operand_is_ptr)
                 try self.wip.load(access_kind, try o.lowerType(pt, err_union_ty), operand, .default, "")
             else
@@ -7733,7 +7586,7 @@ pub const FuncGen = struct {
         const operand = try self.resolveInst(ty_op.operand);
         const optional_ty = self.typeOf(ty_op.operand).childType(zcu);
         const payload_ty = optional_ty.optionalChild(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             // We have a pointer to a zero-bit value and we need to return
             // a pointer to a zero-bit value.
             return operand;
@@ -7761,7 +7614,7 @@ pub const FuncGen = struct {
         const access_kind: Builder.MemoryAccessKind =
             if (optional_ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
 
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             self.maybeMarkAllowZeroAccess(optional_ptr_ty.ptrInfo(zcu));
 
             // We have a pointer to a i8. We need to set it to 1 and then return the same pointer.
@@ -7797,7 +7650,7 @@ pub const FuncGen = struct {
         const operand = try self.resolveInst(ty_op.operand);
         const optional_ty = self.typeOf(ty_op.operand);
         const payload_ty = self.typeOfIndex(inst);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
+        if (!payload_ty.hasRuntimeBits(zcu)) return .none;
 
         if (optional_ty.optionalReprIsPayload(zcu)) {
             // Payload value is the same as the optional value.
@@ -7819,7 +7672,7 @@ pub const FuncGen = struct {
         const result_ty = self.typeOfIndex(inst);
         const payload_ty = if (operand_is_ptr) result_ty.childType(zcu) else result_ty;
 
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             return if (operand_is_ptr) operand else .none;
         }
         const offset = try errUnionPayloadOffset(payload_ty, pt);
@@ -7863,7 +7716,7 @@ pub const FuncGen = struct {
             if (operand_is_ptr and operand_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
 
         const payload_ty = err_union_ty.errorUnionPayload(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             if (!operand_is_ptr) return operand;
 
             self.maybeMarkAllowZeroAccess(operand_ty.ptrInfo(zcu));
@@ -7899,7 +7752,7 @@ pub const FuncGen = struct {
         const access_kind: Builder.MemoryAccessKind =
             if (err_union_ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
 
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             self.maybeMarkAllowZeroAccess(err_union_ptr_ty.ptrInfo(zcu));
 
             _ = try self.wip.store(access_kind, non_error_val, operand, .default);
@@ -7946,9 +7799,8 @@ pub const FuncGen = struct {
         const struct_llvm_ty = try o.lowerType(pt, struct_ty);
         const llvm_field_index = o.llvmFieldIndex(struct_ty, field_index).?;
         assert(self.err_ret_trace != .none);
-        const field_ptr =
-            try self.wip.gepStruct(struct_llvm_ty, self.err_ret_trace, llvm_field_index, "");
-        const field_alignment = struct_ty.fieldAlignment(field_index, zcu);
+        const field_ptr = try self.wip.gepStruct(struct_llvm_ty, self.err_ret_trace, llvm_field_index, "");
+        const field_alignment = struct_ty.explicitFieldAlignment(field_index, zcu);
         const field_ty = struct_ty.fieldType(field_index, zcu);
         const field_ptr_ty = try pt.ptrType(.{
             .child = field_ty.toIntern(),
@@ -7989,7 +7841,7 @@ pub const FuncGen = struct {
         const payload_ty = self.typeOf(ty_op.operand);
         const non_null_bit = try o.builder.intValue(.i8, 1);
         comptime assert(optional_layout_version == 3);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return non_null_bit;
+        assert(payload_ty.hasRuntimeBits(zcu));
         const operand = try self.resolveInst(ty_op.operand);
         const optional_ty = self.typeOfIndex(inst);
         if (optional_ty.optionalReprIsPayload(zcu)) return operand;
@@ -8023,9 +7875,7 @@ pub const FuncGen = struct {
         const err_un_ty = self.typeOfIndex(inst);
         const operand = try self.resolveInst(ty_op.operand);
         const payload_ty = self.typeOf(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-            return operand;
-        }
+        assert(payload_ty.hasRuntimeBits(zcu));
         const ok_err_code = try o.builder.intValue(try o.errorIntType(pt), 0);
         const err_un_llvm_ty = try o.lowerType(pt, err_un_ty);
 
@@ -8065,7 +7915,7 @@ pub const FuncGen = struct {
         const err_un_ty = self.typeOfIndex(inst);
         const payload_ty = err_un_ty.errorUnionPayload(zcu);
         const operand = try self.resolveInst(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return operand;
+        if (!payload_ty.hasRuntimeBits(zcu)) return operand;
         const err_un_llvm_ty = try o.lowerType(pt, err_un_ty);
 
         const payload_offset = try errUnionPayloadOffset(payload_ty, pt);
@@ -8517,7 +8367,7 @@ pub const FuncGen = struct {
         const ptr = try self.resolveInst(bin_op.lhs);
         const offset = try self.resolveInst(bin_op.rhs);
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const llvm_elem_ty = try o.lowerPtrElemTy(pt, ptr_ty.childType(zcu));
+        const llvm_elem_ty = try o.lowerType(pt, ptr_ty.childType(zcu));
         switch (ptr_ty.ptrSize(zcu)) {
             // It's a pointer to an array, so according to LLVM we need an extra GEP index.
             .one => return self.wip.gep(.inbounds, llvm_elem_ty, ptr, &.{
@@ -8541,7 +8391,7 @@ pub const FuncGen = struct {
         const offset = try self.resolveInst(bin_op.rhs);
         const negative_offset = try self.wip.neg(offset, "");
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const llvm_elem_ty = try o.lowerPtrElemTy(pt, ptr_ty.childType(zcu));
+        const llvm_elem_ty = try o.lowerType(pt, ptr_ty.childType(zcu));
         switch (ptr_ty.ptrSize(zcu)) {
             // It's a pointer to an array, so according to LLVM we need an extra GEP index.
             .one => return self.wip.gep(.inbounds, llvm_elem_ty, ptr, &.{
@@ -9502,7 +9352,7 @@ pub const FuncGen = struct {
             self.file,
             self.scope,
             lbrace_line,
-            try o.lowerDebugType(pt, inst_ty),
+            try o.getDebugType(pt, inst_ty),
             self.arg_index,
         );
 
@@ -9836,7 +9686,7 @@ pub const FuncGen = struct {
         const ptr_ty = self.typeOf(atomic_load.ptr);
         const info = ptr_ty.ptrInfo(zcu);
         const elem_ty = Type.fromInterned(info.child);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
+        if (!elem_ty.hasRuntimeBits(zcu)) return .none;
         const ordering = toLlvmAtomicOrdering(atomic_load.order);
         const llvm_abi_ty = try o.getAtomicAbiType(pt, elem_ty, false);
         const ptr_alignment = (if (info.flags.alignment != .none)
@@ -10304,7 +10154,7 @@ pub const FuncGen = struct {
 
         const target = &zcu.root_mod.resolved_target.result;
         const function_index = try o.builder.addFunction(
-            try o.builder.fnType(.i1, &.{try o.lowerType(pt, Type.fromInterned(enum_type.tag_ty))}, .normal),
+            try o.builder.fnType(.i1, &.{try o.lowerType(pt, Type.fromInterned(enum_type.int_tag_type))}, .normal),
             try o.builder.strtabStringFmt("__zig_is_named_enum_value_{f}", .{enum_type.name.fmt(ip)}),
             toLlvmAddressSpace(.generic, target),
         );
@@ -10325,13 +10175,13 @@ pub const FuncGen = struct {
         defer wip.deinit();
         wip.cursor = .{ .block = try wip.block(0, "Entry") };
 
-        const named_block = try wip.block(@intCast(enum_type.names.len), "Named");
+        const named_block = try wip.block(@intCast(enum_type.field_names.len), "Named");
         const unnamed_block = try wip.block(1, "Unnamed");
         const tag_int_value = wip.arg(0);
-        var wip_switch = try wip.@"switch"(tag_int_value, unnamed_block, @intCast(enum_type.names.len), .none);
+        var wip_switch = try wip.@"switch"(tag_int_value, unnamed_block, @intCast(enum_type.field_names.len), .none);
         defer wip_switch.finish(&wip);
 
-        for (0..enum_type.names.len) |field_index| {
+        for (0..enum_type.field_names.len) |field_index| {
             const this_tag_int_value = try o.lowerValue(
                 pt,
                 (try pt.enumValueFieldIndex(enum_ty, @intCast(field_index))).toIntern(),
@@ -10800,15 +10650,14 @@ pub const FuncGen = struct {
             },
             .@"struct" => {
                 if (zcu.typeToPackedStruct(result_ty)) |struct_type| {
-                    const backing_int_ty = struct_type.backingIntTypeUnordered(ip);
-                    assert(backing_int_ty != .none);
-                    const big_bits = Type.fromInterned(backing_int_ty).bitSize(zcu);
+                    const backing_int_ty: Type = .fromInterned(struct_type.packed_backing_int_type);
+                    const big_bits = backing_int_ty.bitSize(zcu);
                     const int_ty = try o.builder.intType(@intCast(big_bits));
                     comptime assert(Type.packed_struct_layout_version == 2);
                     var running_int = try o.builder.intValue(int_ty, 0);
                     var running_bits: u16 = 0;
                     for (elements, struct_type.field_types.get(ip)) |elem, field_ty| {
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
 
                         const non_int_val = try self.resolveInst(elem);
                         const ty_bit_size: u16 = @intCast(Type.fromInterned(field_ty).bitSize(zcu));
@@ -10840,12 +10689,12 @@ pub const FuncGen = struct {
 
                         const llvm_elem = try self.resolveInst(elem);
                         const llvm_i = o.llvmFieldIndex(result_ty, i).?;
-                        const field_ptr =
-                            try self.wip.gepStruct(llvm_result_ty, alloca_inst, llvm_i, "");
+                        const field_ptr = try self.wip.gepStruct(llvm_result_ty, alloca_inst, llvm_i, "");
+
                         const field_ptr_ty = try pt.ptrType(.{
                             .child = self.typeOf(elem).toIntern(),
                             .flags = .{
-                                .alignment = result_ty.fieldAlignment(i, zcu),
+                                .alignment = result_ty.explicitFieldAlignment(i, zcu),
                             },
                         });
                         try self.store(field_ptr, field_ptr_ty, llvm_elem, .none);
@@ -10910,7 +10759,7 @@ pub const FuncGen = struct {
         const layout = union_ty.unionGetLayout(zcu);
         const union_obj = zcu.typeToUnion(union_ty).?;
 
-        if (union_obj.flagsUnordered(ip).layout == .@"packed") {
+        if (union_obj.layout == .@"packed") {
             const big_bits = union_ty.bitSize(zcu);
             const int_llvm_ty = try o.builder.intType(@intCast(big_bits));
             const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
@@ -10925,10 +10774,8 @@ pub const FuncGen = struct {
 
         const tag_int_val = blk: {
             const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
-            const union_field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
-            const enum_field_index = tag_ty.enumFieldIndex(union_field_name, zcu).?;
-            const tag_val = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
-            break :blk try tag_val.intFromEnum(tag_ty, pt);
+            const tag_val = try pt.enumValueFieldIndex(tag_ty, extra.field_index);
+            break :blk tag_val.intFromEnum(zcu);
         };
         if (layout.payload_size == 0) {
             if (layout.tag_size == 0) {
@@ -10950,16 +10797,14 @@ pub const FuncGen = struct {
         const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
         const field_llvm_ty = try o.lowerType(pt, field_ty);
         const field_size = field_ty.abiSize(zcu);
-        const field_align = union_ty.fieldAlignment(extra.field_index, zcu);
+        const field_align = union_ty.explicitFieldAlignment(extra.field_index, zcu);
         const llvm_usize = try o.lowerType(pt, Type.usize);
         const usize_zero = try o.builder.intValue(llvm_usize, 0);
 
+        assert(field_ty.hasRuntimeBits(zcu));
+
         const llvm_union_ty = t: {
             const payload_ty = p: {
-                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const padding_len = layout.payload_size;
-                    break :p try o.builder.arrayType(padding_len, .i8);
-                }
                 if (field_size == layout.payload_size) {
                     break :p field_llvm_ty;
                 }
@@ -10969,7 +10814,7 @@ pub const FuncGen = struct {
                 });
             };
             if (layout.tag_size == 0) break :t try o.builder.structType(.normal, &.{payload_ty});
-            const tag_ty = try o.lowerType(pt, Type.fromInterned(union_obj.enum_tag_ty));
+            const tag_ty = try o.lowerType(pt, .fromInterned(union_obj.enum_tag_type));
             var fields: [3]Builder.Type = undefined;
             var fields_len: usize = 2;
             if (layout.tag_align.compare(.gte, layout.payload_align)) {
@@ -11010,11 +10855,11 @@ pub const FuncGen = struct {
             const tag_index = @intFromBool(layout.tag_align.compare(.lt, layout.payload_align));
             const indices: [2]Builder.Value = .{ usize_zero, try o.builder.intValue(.i32, tag_index) };
             const field_ptr = try self.wip.gep(.inbounds, llvm_union_ty, result_ptr, &indices, "");
-            const tag_ty = try o.lowerType(pt, Type.fromInterned(union_obj.enum_tag_ty));
+            const tag_ty = try o.lowerType(pt, .fromInterned(union_obj.enum_tag_type));
             var big_int_space: Value.BigIntSpace = undefined;
             const tag_big_int = tag_int_val.toBigInt(&big_int_space, zcu);
             const llvm_tag = try o.builder.bigIntValue(tag_ty, tag_big_int);
-            const tag_alignment = Type.fromInterned(union_obj.enum_tag_ty).abiAlignment(zcu).toLlvm();
+            const tag_alignment = Type.fromInterned(union_obj.enum_tag_type).abiAlignment(zcu).toLlvm();
             _ = try self.wip.store(.normal, llvm_tag, field_ptr, tag_alignment);
         }
 
@@ -11295,8 +11140,10 @@ pub const FuncGen = struct {
                     return self.wip.gep(.inbounds, .i8, struct_ptr, &.{llvm_index}, "");
                 },
                 else => {
-                    const struct_llvm_ty = try o.lowerPtrElemTy(pt, struct_ty);
-
+                    if (!struct_ty.hasRuntimeBits(zcu)) {
+                        return struct_ptr;
+                    }
+                    const struct_llvm_ty = try o.lowerType(pt, struct_ty);
                     if (o.llvmFieldIndex(struct_ty, field_index)) |llvm_field_index| {
                         return self.wip.gepStruct(struct_llvm_ty, struct_ptr, llvm_field_index, "");
                     } else {
@@ -11306,7 +11153,7 @@ pub const FuncGen = struct {
                         // the struct.
                         const llvm_index = try o.builder.intValue(
                             try o.lowerType(pt, Type.usize),
-                            @intFromBool(struct_ty.hasRuntimeBitsIgnoreComptime(zcu)),
+                            @intFromBool(struct_ty.hasRuntimeBits(zcu)),
                         );
                         return self.wip.gep(.inbounds, struct_llvm_ty, struct_ptr, &.{llvm_index}, "");
                     }
@@ -11393,7 +11240,7 @@ pub const FuncGen = struct {
         const zcu = pt.zcu;
         const info = ptr_ty.ptrInfo(zcu);
         const elem_ty = Type.fromInterned(info.child);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
+        if (!elem_ty.hasRuntimeBits(zcu)) return .none;
 
         const ptr_alignment = (if (info.flags.alignment != .none)
             @as(InternPool.Alignment, info.flags.alignment)
@@ -12048,7 +11895,7 @@ fn returnTypeByRef(zcu: *Zcu, target: *const std.Target, ty: Type) bool {
 
 fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: *const std.Target) bool {
     const return_type = Type.fromInterned(fn_info.return_type);
-    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) return false;
+    if (!return_type.hasRuntimeBits(zcu)) return false;
 
     return switch (fn_info.cc) {
         .auto => returnTypeByRef(zcu, target, return_type),
@@ -12088,11 +11935,9 @@ fn firstParamSRetSystemV(ty: Type, zcu: *Zcu, target: *const std.Target) bool {
 fn lowerFnRetTy(o: *Object, pt: Zcu.PerThread, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
     const zcu = pt.zcu;
     const return_type = Type.fromInterned(fn_info.return_type);
-    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
-        // If the return type is an error set or an error union, then we make this
-        // anyerror return type instead, so that it can be coerced into a function
-        // pointer type which has anyerror as the return type.
-        return if (return_type.isError(zcu)) try o.errorIntType(pt) else .void;
+    if (!return_type.hasRuntimeBits(zcu)) {
+        assert(!return_type.isError(zcu));
+        return .void;
     }
     const target = zcu.getTarget();
     switch (fn_info.cc) {
@@ -12136,7 +11981,7 @@ fn lowerFnRetTy(o: *Object, pt: Zcu.PerThread, fn_info: InternPool.Key.FuncType)
                 var types: [8]Builder.Type = undefined;
                 for (0..return_type.structFieldCount(zcu)) |field_index| {
                     const field_ty = return_type.fieldType(field_index, zcu);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                    if (!field_ty.hasRuntimeBits(zcu)) continue;
                     types[types_len] = try o.lowerType(pt, field_ty);
                     types_len += 1;
                 }
@@ -12174,6 +12019,7 @@ fn lowerSystemVFnRetTy(o: *Object, pt: Zcu.PerThread, fn_info: InternPool.Key.Fu
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const return_type = Type.fromInterned(fn_info.return_type);
+    return_type.assertHasLayout(zcu);
     if (isScalar(zcu, return_type)) {
         return o.lowerType(pt, return_type);
     }
@@ -12222,9 +12068,7 @@ fn lowerSystemVFnRetTy(o: *Object, pt: Zcu.PerThread, fn_info: InternPool.Key.Fu
         assert(first_non_integer orelse classes.len == types_index);
         switch (ip.indexToKey(return_type.toIntern())) {
             .struct_type => {
-                const struct_type = ip.loadStructType(return_type.toIntern());
-                assert(struct_type.haveLayout(ip));
-                const size: u64 = struct_type.sizeUnordered(ip);
+                const size = return_type.abiSize(zcu);
                 assert((std.math.divCeil(u64, size, 8) catch unreachable) == types_index);
                 if (size % 8 > 0) {
                     types_buffer[types_index - 1] = try o.builder.intType(@intCast(size % 8 * 8));
@@ -12260,7 +12104,7 @@ const ParamTypeIterator = struct {
         i64_array: u8,
     };
 
-    pub fn next(it: *ParamTypeIterator) Allocator.Error!?Lowering {
+    fn next(it: *ParamTypeIterator) Allocator.Error!?Lowering {
         if (it.zig_index >= it.fn_info.param_types.len) return null;
         const ip = &it.pt.zcu.intern_pool;
         const ty = it.fn_info.param_types.get(ip)[it.zig_index];
@@ -12269,7 +12113,7 @@ const ParamTypeIterator = struct {
     }
 
     /// `airCall` uses this instead of `next` so that it can take into account variadic functions.
-    pub fn nextCall(it: *ParamTypeIterator, fg: *FuncGen, args: []const Air.Inst.Ref) Allocator.Error!?Lowering {
+    fn nextCall(it: *ParamTypeIterator, fg: *FuncGen, args: []const Air.Inst.Ref) Allocator.Error!?Lowering {
         assert(std.meta.eql(it.pt, fg.ng.pt));
         const ip = &it.pt.zcu.intern_pool;
         if (it.zig_index >= it.fn_info.param_types.len) {
@@ -12288,7 +12132,7 @@ const ParamTypeIterator = struct {
         const zcu = pt.zcu;
         const target = zcu.getTarget();
 
-        if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!ty.hasRuntimeBits(zcu)) {
             it.zig_index += 1;
             return .no_bits;
         }
@@ -12383,7 +12227,7 @@ const ParamTypeIterator = struct {
                         it.types_len = 0;
                         for (0..ty.structFieldCount(zcu)) |field_index| {
                             const field_ty = ty.fieldType(field_index, zcu);
-                            if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                            if (!field_ty.hasRuntimeBits(zcu)) continue;
                             it.types_buffer[it.types_len] = try it.object.lowerType(pt, field_ty);
                             it.types_len += 1;
                         }
@@ -12460,6 +12304,7 @@ const ParamTypeIterator = struct {
     fn nextSystemV(it: *ParamTypeIterator, ty: Type) Allocator.Error!?Lowering {
         const zcu = it.pt.zcu;
         const ip = &zcu.intern_pool;
+        ty.assertHasLayout(zcu);
         const classes = x86_64_abi.classifySystemV(ty, zcu, zcu.getTarget(), .arg);
         if (classes[0] == .memory) {
             it.zig_index += 1;
@@ -12531,9 +12376,7 @@ const ParamTypeIterator = struct {
             }
             switch (ip.indexToKey(ty.toIntern())) {
                 .struct_type => {
-                    const struct_type = ip.loadStructType(ty.toIntern());
-                    assert(struct_type.haveLayout(ip));
-                    const size: u64 = struct_type.sizeUnordered(ip);
+                    const size = ty.abiSize(zcu);
                     assert((std.math.divCeil(u64, size, 8) catch unreachable) == types_index);
                     if (size % 8 > 0) {
                         types_buffer[types_index - 1] =
@@ -12707,14 +12550,14 @@ fn isByRef(ty: Type, zcu: *Zcu) bool {
         },
         .error_union => {
             const payload_ty = ty.errorUnionPayload(zcu);
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_ty.hasRuntimeBits(zcu)) {
                 return false;
             }
             return true;
         },
         .optional => {
             const payload_ty = ty.optionalChild(zcu);
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_ty.hasRuntimeBits(zcu)) {
                 return false;
             }
             if (ty.optionalReprIsPayload(zcu)) {
diff --git a/src/codegen/mips/abi.zig b/src/codegen/mips/abi.zig
index 6678b74ebc32dceed774331667cdf9d498855947..a27adb7ace40ff937a820a2e8bdfacea12f85d31 100644
--- a/src/codegen/mips/abi.zig
+++ b/src/codegen/mips/abi.zig
@@ -13,7 +13,7 @@ pub const Context = enum { ret, arg };
 
 pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
     const target = zcu.getTarget();
-    std.debug.assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+    std.debug.assert(ty.hasRuntimeBits(zcu));
 
     const max_direct_size = target.ptrBitWidth() * 2;
     switch (ty.zigTypeTag(zcu)) {
diff --git a/src/codegen/riscv64/abi.zig b/src/codegen/riscv64/abi.zig
index 1a380eab905708b866f18a29762e1653cd0a521b..05164530df958129231fd514f8e4c17dff8e8590 100644
--- a/src/codegen/riscv64/abi.zig
+++ b/src/codegen/riscv64/abi.zig
@@ -11,7 +11,7 @@ pub const Class = enum { memory, byval, integer, double_integer, fields };
 
 pub fn classifyType(ty: Type, zcu: *Zcu) Class {
     const target = zcu.getTarget();
-    std.debug.assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+    std.debug.assert(ty.hasRuntimeBits(zcu));
 
     const max_byval_size = target.ptrBitWidth() * 2;
     switch (ty.zigTypeTag(zcu)) {
@@ -27,7 +27,7 @@ pub fn classifyType(ty: Type, zcu: *Zcu) Class {
                 var field_count: usize = 0;
                 for (0..ty.structFieldCount(zcu)) |field_index| {
                     const field_ty = ty.fieldType(field_index, zcu);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                    if (!field_ty.hasRuntimeBits(zcu)) continue;
                     if (field_ty.isRuntimeFloat())
                         any_fp = true
                     else if (!field_ty.isAbiInt(zcu))
diff --git a/src/codegen/wasm/abi.zig b/src/codegen/wasm/abi.zig
index a1fa8126491def2d9e2717faa0ccedcd2ee24805..d59047044b302fc86485237e03300efb89d7c151 100644
--- a/src/codegen/wasm/abi.zig
+++ b/src/codegen/wasm/abi.zig
@@ -22,7 +22,7 @@ pub const Class = union(enum) {
 /// or returned as value within a wasm function.
 pub fn classifyType(ty: Type, zcu: *const Zcu) Class {
     const ip = &zcu.intern_pool;
-    assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+    assert(ty.hasRuntimeBits(zcu));
     switch (ty.zigTypeTag(zcu)) {
         .int, .@"enum", .error_set => return .{ .direct = ty },
         .float => return .{ .direct = ty },
@@ -47,7 +47,7 @@ pub fn classifyType(ty: Type, zcu: *const Zcu) Class {
                 return .indirect;
             }
             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[0]);
-            const explicit_align = struct_type.fieldAlign(ip, 0);
+            const explicit_align = struct_type.field_aligns.getOrNone(ip, 0);
             if (explicit_align != .none) {
                 if (explicit_align.compareStrict(.gt, field_ty.abiAlignment(zcu)))
                     return .indirect;
@@ -56,7 +56,7 @@ pub fn classifyType(ty: Type, zcu: *const Zcu) Class {
         },
         .@"union" => {
             const union_obj = zcu.typeToUnion(ty).?;
-            if (union_obj.flagsUnordered(ip).layout == .@"packed") {
+            if (union_obj.layout == .@"packed") {
                 return .{ .direct = ty };
             }
             const layout = ty.unionGetLayout(zcu);
diff --git a/src/link.zig b/src/link.zig
index c8ae7a6bb4dbb8cd8d0e782b6e6178dd65f049a7..c81737484e6da4a0b437b2ab1ad93d76ab9ac02a 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -29,6 +29,7 @@ const codegen = @import("codegen.zig");
 pub const aarch64 = @import("link/aarch64.zig");
 pub const LdScript = @import("link/LdScript.zig");
 pub const Queue = @import("link/Queue.zig");
+pub const DebugConstPool = @import("link/DebugConstPool.zig");
 
 pub const Diags = struct {
     /// Stored here so that function definitions can distinguish between
@@ -1587,8 +1588,9 @@ pub fn doZcuTask(comp: *Compilation, tid: Zcu.PerThread.Id, task: ZcuTask) void
             const ty_prog_node = comp.link_prog_node.start(name, 0);
             defer ty_prog_node.end();
             if (zcu.llvm_object) |llvm_object| {
-                _ = llvm_object;
-                @compileError("MLUGG TODO");
+                llvm_object.updateContainerType(pt, container_update.ty, container_update.success) catch |err| switch (err) {
+                    error.OutOfMemory => diags.setAllocFailure(),
+                };
             } else {
                 if (comp.bin_file) |lf| {
                     lf.updateContainerType(pt, container_update.ty, container_update.success) catch |err| switch (err) {
diff --git a/src/link/DebugConstPool.zig b/src/link/DebugConstPool.zig
index ce7f32551b63401a94bce51d02f388398f8912e4..eb8c60b6f9d058d12ddcfecc39b92931f6403998 100644
--- a/src/link/DebugConstPool.zig
+++ b/src/link/DebugConstPool.zig
@@ -13,6 +13,9 @@
 /// * forward `updateContainerType` calls to its `DebugConstPool`
 /// * expose some callback functions---see functions in `DebugInfo`
 /// * ensure that any `get` call is eventually followed by a `flushPending` call
+///
+/// TODO: everything in this file should have the error set 'Allocator.Error', but right now the
+/// self-hosted linkers can return all kinds of crap for some reason. This needs fixing.
 const DebugConstPool = @This();
 
 values: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 3094e8671e72456103a2a9f1e47df1a0816b1800..e64346c17c52d305519b575101d70343cf2ef250 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -18,7 +18,7 @@ const codegen = @import("../codegen.zig");
 const dev = @import("../dev.zig");
 const link = @import("../link.zig");
 const target_info = @import("../target.zig");
-const DebugConstPool = @import("DebugConstPool.zig");
+const DebugConstPool = link.DebugConstPool;
 
 gpa: Allocator,
 bin_file: *link.File,
-- 
2.54.0


From b27c56fe5087872800f6b340ec3d1fc219d0d77b Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 12 Feb 2026 12:30:21 +0000
Subject: [PATCH 456/499] compiler: get everything building

Several backends are crashing right now. I'll need to fix at least the C
backend before this branch is ready to PR.
---
 lib/std/zig/target.zig          |  11 +-
 src/codegen/aarch64/Select.zig  |  89 ++++++-------
 src/codegen/c.zig               | 143 ++++++++-------------
 src/codegen/c/Type.zig          |  59 ++++-----
 src/codegen/riscv64/CodeGen.zig |  53 ++++----
 src/codegen/sparc64/CodeGen.zig |  22 ++--
 src/codegen/spirv/CodeGen.zig   | 115 ++++++++---------
 src/codegen/wasm/CodeGen.zig    | 219 +++++++++++---------------------
 src/link/MachO/Atom.zig         |   2 +-
 src/link/MachO/ZigObject.zig    |   2 +-
 src/link/MachO/file.zig         |   2 +-
 src/link/Wasm.zig               |   4 +-
 src/link/Wasm/Flush.zig         |   6 +-
 src/link/tapi/parse.zig         |   2 +-
 14 files changed, 300 insertions(+), 429 deletions(-)

diff --git a/lib/std/zig/target.zig b/lib/std/zig/target.zig
index f87b93608650fe1e99955695853b2b7aa02acaf9..dee2241667c42db870163f1dbd9579ed7440a70d 100644
--- a/lib/std/zig/target.zig
+++ b/lib/std/zig/target.zig
@@ -519,10 +519,13 @@ pub fn intAlignment(target: *const std.Target, bits: u16) u16 {
             33...64 => 8,
             else => 16,
         },
-        else => return @min(
-            std.math.ceilPowerOfTwoPromote(u16, @as(u16, @intCast((@as(u17, bits) + 7) / 8))),
-            target.cMaxIntAlignment(),
-        ),
+        else => switch (bits) {
+            0 => 1,
+            else => @min(
+                std.math.ceilPowerOfTwoPromote(u16, @intCast((@as(u17, bits) + 7) / 8)),
+                target.cMaxIntAlignment(),
+            ),
+        },
     };
 }
 
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index a95faca765385b3b4b879b0cf5b0e7885adf4e49..ba136872b13f406329d0f35e961a50946076e6ef 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -2791,9 +2791,9 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 } else return isel.fail("invalid constraint: '{s}'", .{constraint});
             }
 
-            const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
+            const clobbers_val: Constant = .fromInterned(unwrapped_asm.clobbers);
             const clobbers_ty = clobbers_val.typeOf(zcu);
-            var clobbers_bigint_buf: Value.BigIntSpace = undefined;
+            var clobbers_bigint_buf: Constant.BigIntSpace = undefined;
             const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
                 assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
@@ -2818,7 +2818,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
                 const limb_bits = @bitSizeOf(std.math.big.Limb);
                 if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
-                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> field_index % limb_bits))) {
+                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
                     0 => continue, // field is false
                     1 => {}, // field is true
                 }
@@ -2871,7 +2871,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
             for (0..clobbers_ty.structFieldCount(zcu)) |field_index| {
                 const limb_bits = @bitSizeOf(std.math.big.Limb);
                 if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
-                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> field_index % limb_bits))) {
+                switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
                     0 => continue, // field is false
                     1 => {}, // field is true
                 }
@@ -3283,8 +3283,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 } else if (dst_ty.isSliceAtRuntime(zcu) and src_ty.isSliceAtRuntime(zcu)) {
                     try dst_vi.value.move(isel, ty_op.operand);
                 } else if (dst_tag == .error_union and src_tag == .error_union) {
-                    assert(dst_ty.errorUnionSet(zcu).hasRuntimeBitsIgnoreComptime(zcu) ==
-                        src_ty.errorUnionSet(zcu).hasRuntimeBitsIgnoreComptime(zcu));
+                    assert(dst_ty.errorUnionSet(zcu).hasRuntimeBits(zcu) ==
+                        src_ty.errorUnionSet(zcu).hasRuntimeBits(zcu));
                     if (dst_ty.errorUnionPayload(zcu).toIntern() == src_ty.errorUnionPayload(zcu).toIntern()) {
                         try dst_vi.value.move(isel, ty_op.operand);
                     } else return isel.fail("bad {t} {f} {f}", .{ air_tag, isel.fmtType(dst_ty), isel.fmtType(src_ty) });
@@ -4562,7 +4562,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 }
                 if (case.ranges.len == 0 and case.items.len == 1 and Constant.fromInterned(
                     case.items[0].toInterned().?,
-                ).orderAgainstZero(zcu).compare(.eq)) {
+                ).compareHetero(.eq, .zero_comptime_int, zcu)) {
                     try isel.emit(.cbnz(
                         cond_reg,
                         @intCast((isel.instructions.items.len + 1 - next_label) << 2),
@@ -6893,11 +6893,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                         var field_it = loaded_struct.iterateRuntimeOrder(ip);
                         while (field_it.next()) |field_index| {
                             const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                            field_offset = field_ty.structFieldAlignment(
-                                loaded_struct.fieldAlign(ip, field_index),
-                                loaded_struct.layout,
-                                zcu,
-                            ).forward(field_offset);
+                            field_offset = loaded_struct.field_offsets.get(ip)[field_index];
                             const field_size = field_ty.abiSize(zcu);
                             if (field_size == 0) continue;
                             var agg_part_it = agg_vi.value.field(agg_ty, field_offset, field_size);
@@ -6905,7 +6901,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                             try agg_part_vi.?.move(isel, elems[field_index]);
                             field_offset += field_size;
                         }
-                        assert(loaded_struct.flagsUnordered(ip).alignment.forward(field_offset) == agg_vi.value.size(isel));
+                        assert(loaded_struct.alignment.forward(field_offset) == agg_vi.value.size(isel));
                     },
                     .tuple_type => |tuple_type| {
                         const elems: []const Air.Inst.Ref =
@@ -6947,23 +6943,23 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
                 const union_layout = ZigType.getUnionLayout(loaded_union, zcu);
 
                 if (union_layout.tag_size > 0) unused_tag: {
-                    const loaded_tag = loaded_union.loadTagType(ip);
+                    const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
                     var tag_it = union_vi.value.field(union_ty, union_layout.tagOffset(), union_layout.tag_size);
                     const tag_vi = try tag_it.only(isel);
                     const tag_ra = try tag_vi.?.defReg(isel) orelse break :unused_tag;
                     switch (union_layout.tag_size) {
                         0 => unreachable,
-                        1...4 => try isel.movImmediate(tag_ra.w(), @as(u32, switch (loaded_tag.values.len) {
+                        1...4 => try isel.movImmediate(tag_ra.w(), @as(u32, switch (loaded_tag.field_values.len) {
                             0 => extra.field_index,
-                            else => switch (ip.indexToKey(loaded_tag.values.get(ip)[extra.field_index]).int.storage) {
+                            else => switch (ip.indexToKey(loaded_tag.field_values.get(ip)[extra.field_index]).int.storage) {
                                 .u64 => |imm| @intCast(imm),
                                 .i64 => |imm| @bitCast(@as(i32, @intCast(imm))),
                                 else => unreachable,
                             },
                         })),
-                        5...8 => try isel.movImmediate(tag_ra.x(), switch (loaded_tag.values.len) {
+                        5...8 => try isel.movImmediate(tag_ra.x(), switch (loaded_tag.field_values.len) {
                             0 => extra.field_index,
-                            else => switch (ip.indexToKey(loaded_tag.values.get(ip)[extra.field_index]).int.storage) {
+                            else => switch (ip.indexToKey(loaded_tag.field_values.get(ip)[extra.field_index]).int.storage) {
                                 .u64 => |imm| imm,
                                 .i64 => |imm| @bitCast(imm),
                                 else => unreachable,
@@ -10391,7 +10387,7 @@ pub const Value = struct {
                         switch (loaded_struct.layout) {
                             .auto, .@"extern" => {},
                             .@"packed" => continue :type_key .{
-                                .int_type = ip.indexToKey(loaded_struct.backingIntTypeUnordered(ip)).int_type,
+                                .int_type = ip.indexToKey(loaded_struct.packed_backing_int_type).int_type,
                             },
                         }
                         const min_part_log2_stride: u5 = if (size > 16) 4 else if (size > 8) 3 else 0;
@@ -10406,7 +10402,7 @@ pub const Value = struct {
                         var field_it = loaded_struct.iterateRuntimeOrder(ip);
                         while (field_it.next()) |field_index| {
                             const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                            const field_begin = switch (loaded_struct.fieldAlign(ip, field_index)) {
+                            const field_begin = switch (loaded_struct.field_aligns.getOrNone(ip, field_index)) {
                                 .none => field_ty.abiAlignment(zcu),
                                 else => |field_align| field_align,
                             }.forward(field_end);
@@ -10504,7 +10500,7 @@ pub const Value = struct {
                     },
                     .union_type => {
                         const loaded_union = ip.loadUnionType(ty.toIntern());
-                        switch (loaded_union.flagsUnordered(ip).layout) {
+                        switch (loaded_union.layout) {
                             .auto, .@"extern" => {},
                             .@"packed" => continue :type_key .{ .int_type = .{
                                 .signedness = .unsigned,
@@ -10539,12 +10535,13 @@ pub const Value = struct {
                             const field_signedness = field_signedness: switch (field) {
                                 .tag => {
                                     if (offset >= field_begin and offset + size <= field_begin + field_size) {
-                                        ty = .fromInterned(loaded_union.enum_tag_ty);
+                                        ty = .fromInterned(loaded_union.enum_tag_type);
                                         ty_size = field_size;
                                         offset -= field_begin;
-                                        continue :type_key ip.indexToKey(loaded_union.enum_tag_ty);
+                                        continue :type_key ip.indexToKey(loaded_union.enum_tag_type);
                                     }
-                                    break :field_signedness ip.indexToKey(loaded_union.loadTagType(ip).tag_ty).int_type.signedness;
+                                    const loaded_enum = ip.loadEnumType(loaded_union.enum_tag_type);
+                                    break :field_signedness ip.indexToKey(loaded_enum.int_tag_type).int_type.signedness;
                                 },
                                 .payload => null,
                             };
@@ -10574,7 +10571,7 @@ pub const Value = struct {
                         }
                     },
                     .opaque_type, .func_type => continue :type_key .{ .simple_type = .anyopaque },
-                    .enum_type => continue :type_key ip.indexToKey(ip.loadEnumType(ty.toIntern()).tag_ty),
+                    .enum_type => continue :type_key ip.indexToKey(ip.loadEnumType(ty.toIntern()).int_tag_type),
                     .error_set_type,
                     .inferred_error_set_type,
                     => continue :type_key .{ .simple_type = .anyerror },
@@ -10740,7 +10737,7 @@ pub const Value = struct {
                                         .storage = .{ .u64 = 0 },
                                     } },
                                 },
-                                .int => |int| break :free storage: switch (int.storage) {
+                                .int => |int| break :free switch (int.storage) {
                                     .u64 => |imm| try isel.movImmediate(switch (size) {
                                         else => unreachable,
                                         1...4 => mat.ra.w(),
@@ -10772,12 +10769,6 @@ pub const Value = struct {
                                         }
                                         try isel.movImmediate(mat.ra.x(), imm);
                                     },
-                                    .lazy_align => |ty| continue :storage .{
-                                        .u64 = ZigType.fromInterned(ty).abiAlignment(zcu).toByteUnits().?,
-                                    },
-                                    .lazy_size => |ty| continue :storage .{
-                                        .u64 = ZigType.fromInterned(ty).abiSize(zcu),
-                                    },
                                 },
                                 .err => |err| continue :constant_key .{ .int = .{
                                     .ty = err.ty,
@@ -11084,13 +11075,9 @@ pub const Value = struct {
                                                 var field_offset: u64 = 0;
                                                 var field_it = loaded_struct.iterateRuntimeOrder(ip);
                                                 while (field_it.next()) |field_index| {
-                                                    if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
+                                                    if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
                                                     const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                                                    field_offset = field_ty.structFieldAlignment(
-                                                        loaded_struct.fieldAlign(ip, field_index),
-                                                        loaded_struct.layout,
-                                                        zcu,
-                                                    ).forward(field_offset);
+                                                    field_offset = loaded_struct.field_offsets.get(ip)[field_index];
                                                     const field_size = field_ty.abiSize(zcu);
                                                     if (offset >= field_offset and offset + size <= field_offset + field_size) {
                                                         offset -= field_offset;
@@ -11132,7 +11119,7 @@ pub const Value = struct {
                                 .un => |un| {
                                     const loaded_union = ip.loadUnionType(un.ty);
                                     const union_layout = ZigType.getUnionLayout(loaded_union, zcu);
-                                    if (loaded_union.hasTag(ip)) {
+                                    if (loaded_union.has_runtime_tag) {
                                         const tag_offset = union_layout.tagOffset();
                                         if (offset >= tag_offset and offset + size <= tag_offset + union_layout.tag_size) {
                                             offset -= tag_offset;
@@ -11477,13 +11464,9 @@ fn writeKeyToMemory(isel: *Select, constant_key: InternPool.Key, buffer: []u8) e
                         var field_offset: u64 = 0;
                         var field_it = loaded_struct.iterateRuntimeOrder(ip);
                         while (field_it.next()) |field_index| {
-                            if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
+                            if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
                             const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                            field_offset = field_ty.structFieldAlignment(
-                                loaded_struct.fieldAlign(ip, field_index),
-                                loaded_struct.layout,
-                                zcu,
-                            ).forward(field_offset);
+                            field_offset = loaded_struct.field_offsets.get(ip)[field_index];
                             const field_size = field_ty.abiSize(zcu);
                             if (!try isel.writeToMemory(.fromInterned(switch (aggregate.storage) {
                                 .bytes => unreachable,
@@ -12082,7 +12065,7 @@ pub const CallAbiIterator = struct {
         const zcu = isel.pt.zcu;
         const ip = &zcu.intern_pool;
 
-        if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
+        if (!ty.hasRuntimeBits(zcu)) return null;
         try isel.values.ensureUnusedCapacity(zcu.gpa, Value.max_parts);
         const wip_vi = isel.initValue(ty);
         type_key: switch (ip.indexToKey(ty.toIntern())) {
@@ -12186,7 +12169,7 @@ pub const CallAbiIterator = struct {
                 switch (loaded_struct.layout) {
                     .auto, .@"extern" => {},
                     .@"packed" => continue :type_key .{
-                        .int_type = ip.indexToKey(loaded_struct.backingIntTypeUnordered(ip)).int_type,
+                        .int_type = ip.indexToKey(loaded_struct.packed_backing_int_type).int_type,
                     },
                 }
                 const size = wip_vi.size(isel);
@@ -12210,7 +12193,7 @@ pub const CallAbiIterator = struct {
                             const field_end = next_field_end;
                             const next_field_begin = if (field_it.next()) |field_index| next_field_begin: {
                                 const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                                const next_field_begin = switch (loaded_struct.fieldAlign(ip, field_index)) {
+                                const next_field_begin = switch (loaded_struct.field_aligns.getOrNone(ip, field_index)) {
                                     .none => field_ty.abiAlignment(zcu),
                                     else => |field_align| field_align,
                                 }.forward(field_end);
@@ -12276,7 +12259,7 @@ pub const CallAbiIterator = struct {
             },
             .union_type => {
                 const loaded_union = ip.loadUnionType(ty.toIntern());
-                switch (loaded_union.flagsUnordered(ip).layout) {
+                switch (loaded_union.layout) {
                     .auto, .@"extern" => {},
                     .@"packed" => continue :type_key .{ .int_type = .{
                         .signedness = .unsigned,
@@ -12309,7 +12292,9 @@ pub const CallAbiIterator = struct {
                 }
             },
             .opaque_type, .func_type => continue :type_key .{ .simple_type = .anyopaque },
-            .enum_type => continue :type_key ip.indexToKey(ip.loadEnumType(ty.toIntern()).tag_ty),
+            .enum_type => continue :type_key .{
+                .int_type = ip.indexToKey(ip.loadEnumType(ty.toIntern()).int_tag_type).int_type,
+            },
             .error_set_type,
             .inferred_error_set_type,
             => continue :type_key .{ .simple_type = .anyerror },
@@ -12414,8 +12399,8 @@ pub const CallAbiIterator = struct {
         const ip = &zcu.intern_pool;
         var common_fdt: ?FundamentalDataType = null;
         for (0.., loaded_struct.field_types.get(ip)) |field_index, field_ty| {
-            if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
-            if (loaded_struct.fieldAlign(ip, field_index) != .none) return null;
+            if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
+            if (loaded_struct.field_aligns.getOrNone(ip, field_index) != .none) return null;
             if (!ZigType.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
             const fdt = homogeneousAggregateBaseType(zcu, field_ty);
             if (common_fdt == null) common_fdt = fdt else if (fdt != common_fdt) return null;
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 879dc0e45a649a24692c7b49d0af71de71f061c8..c8904405e218072fc80d8753603c1e0689022f25 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -1052,17 +1052,7 @@ pub const DeclGen = struct {
             .func,
             .enum_literal,
             => unreachable, // non-runtime values
-            .int => |int| switch (int.storage) {
-                .u64, .i64, .big_int => try w.print("{f}", .{try dg.fmtIntLiteralDec(val, location)}),
-                .lazy_align, .lazy_size => {
-                    try w.writeAll("((");
-                    try dg.renderCType(w, ctype);
-                    try w.print("){f})", .{try dg.fmtIntLiteralHex(
-                        try pt.intValue(.usize, val.toUnsignedInt(zcu)),
-                        .Other,
-                    )});
-                },
-            },
+            .int => try w.print("{f}", .{try dg.fmtIntLiteralDec(val, location)}),
             .err => |err| try dg.renderErrorName(w, err.name),
             .error_union => |error_union| switch (ctype.info(ctype_pool)) {
                 .basic => switch (error_union.val) {
@@ -1338,7 +1328,7 @@ pub const DeclGen = struct {
                         const comptime_val = tuple.values.get(ip)[field_index];
                         if (comptime_val != .none) continue;
                         const field_ty: Type = .fromInterned(tuple.types.get(ip)[field_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!field_ty.hasRuntimeBits(zcu)) continue;
 
                         if (!empty) try w.writeByte(',');
 
@@ -1373,7 +1363,7 @@ pub const DeclGen = struct {
                     var need_comma = false;
                     while (field_it.next()) |field_index| {
                         const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!field_ty.hasRuntimeBits(zcu)) continue;
 
                         if (need_comma) try w.writeByte(',');
                         need_comma = true;
@@ -1396,7 +1386,7 @@ pub const DeclGen = struct {
                 const loaded_union = ip.loadUnionType(ty.toIntern());
                 if (un.tag == .none) {
                     const backing_ty = try ty.externUnionBackingType(pt);
-                    assert(loaded_union.flagsUnordered(ip).layout == .@"extern");
+                    assert(loaded_union.layout == .@"extern");
                     if (location == .StaticInitializer) {
                         return dg.fail("TODO: C backend: implement extern union backing type rendering in static initializers", .{});
                     }
@@ -1418,9 +1408,9 @@ pub const DeclGen = struct {
 
                     const field_index = zcu.unionTagFieldIndex(loaded_union, Value.fromInterned(un.tag)).?;
                     const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                    const field_name = loaded_union.loadTagType(ip).names.get(ip)[field_index];
+                    const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
 
-                    const has_tag = loaded_union.hasTag(ip);
+                    const has_tag = loaded_union.has_runtime_tag;
                     if (has_tag) try w.writeByte('{');
                     const aggregate = ctype.info(ctype_pool).aggregate;
                     for (0..if (has_tag) aggregate.fields.len else 1) |outer_field_index| {
@@ -1597,7 +1587,7 @@ pub const DeclGen = struct {
                             var need_comma = false;
                             while (field_it.next()) |field_index| {
                                 const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                                if (!field_ty.hasRuntimeBits(zcu)) continue;
 
                                 if (need_comma) try w.writeByte(',');
                                 need_comma = true;
@@ -1620,7 +1610,7 @@ pub const DeclGen = struct {
                     for (0..tuple_info.types.len) |field_index| {
                         if (tuple_info.values.get(ip)[field_index] != .none) continue;
                         const field_ty: Type = .fromInterned(tuple_info.types.get(ip)[field_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!field_ty.hasRuntimeBits(zcu)) continue;
 
                         if (need_comma) try w.writeByte(',');
                         need_comma = true;
@@ -1630,7 +1620,7 @@ pub const DeclGen = struct {
                 },
                 .union_type => {
                     const loaded_union = ip.loadUnionType(ty.toIntern());
-                    switch (loaded_union.flagsUnordered(ip).layout) {
+                    switch (loaded_union.layout) {
                         .auto, .@"extern" => {
                             if (!location.isInitializer()) {
                                 try w.writeByte('(');
@@ -1638,7 +1628,7 @@ pub const DeclGen = struct {
                                 try w.writeByte(')');
                             }
 
-                            const has_tag = loaded_union.hasTag(ip);
+                            const has_tag = loaded_union.has_runtime_tag;
                             if (has_tag) try w.writeByte('{');
                             const aggregate = ctype.info(ctype_pool).aggregate;
                             for (0..if (has_tag) aggregate.fields.len else 1) |outer_field_index| {
@@ -1649,7 +1639,7 @@ pub const DeclGen = struct {
                                     .payload) {
                                     .tag => try dg.renderUndefValue(
                                         w,
-                                        .fromInterned(loaded_union.enum_tag_ty),
+                                        .fromInterned(loaded_union.enum_tag_type),
                                         initializer_type,
                                     ),
                                     .payload => {
@@ -1760,6 +1750,7 @@ pub const DeclGen = struct {
                 .opt,
                 .aggregate,
                 .un,
+                .bitpack,
                 .memoized_call,
                 => unreachable, // values, not types
             },
@@ -2797,7 +2788,7 @@ pub fn genLazyFn(o: *Object, lazy_ctype_pool: *const CType.Pool, lazy_fn: LazyFn
                 } });
 
                 try w.print("case {f}: {{", .{
-                    try o.dg.fmtIntLiteralDec(try tag_val.intFromEnum(enum_ty, pt), .Other),
+                    try o.dg.fmtIntLiteralDec(tag_val.intFromEnum(zcu), .Other),
                 });
                 o.indent();
                 try o.newline();
@@ -3599,10 +3590,7 @@ fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const zcu = f.object.dg.pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-    if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
-        return .none;
-    }
+    assert(inst_ty.hasRuntimeBits(zcu));
 
     const ptr = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3629,7 +3617,7 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const ptr_ty = f.typeOf(bin_op.lhs);
-    const elem_has_bits = ptr_ty.indexableElem(zcu).hasRuntimeBitsIgnoreComptime(zcu);
+    assert(ptr_ty.indexableElem(zcu).hasRuntimeBits(zcu));
 
     const ptr = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3643,16 +3631,14 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     try w.writeByte('(');
     try f.renderType(w, inst_ty);
     try w.writeByte(')');
-    if (elem_has_bits) try w.writeByte('&');
-    if (elem_has_bits and ptr_ty.ptrSize(zcu) == .one) {
+    try w.writeByte('&');
+    if (ptr_ty.ptrSize(zcu) == .one) {
         // It's a pointer to an array, so we need to de-reference.
         try f.writeCValueDeref(w, ptr);
     } else try f.writeCValue(w, ptr, .Other);
-    if (elem_has_bits) {
-        try w.writeByte('[');
-        try f.writeCValue(w, index, .Other);
-        try w.writeByte(']');
-    }
+    try w.writeByte('[');
+    try f.writeCValue(w, index, .Other);
+    try w.writeByte(']');
     try a.end(f, w);
     return local;
 }
@@ -3661,10 +3647,7 @@ fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const zcu = f.object.dg.pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-    if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
-        return .none;
-    }
+    assert(inst_ty.hasRuntimeBits(zcu));
 
     const slice = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3692,7 +3675,7 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const inst_ty = f.typeOfIndex(inst);
     const slice_ty = f.typeOf(bin_op.lhs);
     const elem_ty = slice_ty.childType(zcu);
-    const elem_has_bits = elem_ty.hasRuntimeBitsIgnoreComptime(zcu);
+    assert(elem_ty.hasRuntimeBits(zcu));
 
     const slice = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3703,13 +3686,11 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
     try f.writeCValue(w, local, .Other);
     try a.assign(f, w);
-    if (elem_has_bits) try w.writeByte('&');
+    try w.writeByte('&');
     try f.writeCValueMember(w, slice, .{ .identifier = "ptr" });
-    if (elem_has_bits) {
-        try w.writeByte('[');
-        try f.writeCValue(w, index, .Other);
-        try w.writeByte(']');
-    }
+    try w.writeByte('[');
+    try f.writeCValue(w, index, .Other);
+    try w.writeByte(']');
     try a.end(f, w);
     return local;
 }
@@ -3718,10 +3699,7 @@ fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const zcu = f.object.dg.pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const inst_ty = f.typeOfIndex(inst);
-    if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
-        return .none;
-    }
+    assert(inst_ty.hasRuntimeBits(zcu));
 
     const array = try f.resolveInst(bin_op.lhs);
     const index = try f.resolveInst(bin_op.rhs);
@@ -3853,10 +3831,7 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue {
     // bit-pointers we see here are vector element pointers.
     assert(ptr_info.packed_offset.host_size == 0 or ptr_info.flags.vector_index != .none);
 
-    if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        try reap(f, inst, &.{ty_op.operand});
-        return .none;
-    }
+    assert(src_ty.hasRuntimeBits(zcu));
 
     const operand = try f.resolveInst(ty_op.operand);
 
@@ -4456,7 +4431,7 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
     const inst_ty = f.typeOfIndex(inst);
     const inst_scalar_ty = inst_ty.scalarType(zcu);
     const elem_ty = inst_scalar_ty.indexableElem(zcu);
-    if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return f.moveCValue(inst, inst_ty, lhs);
+    assert(elem_ty.hasRuntimeBits(zcu));
     const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
 
     const local = try f.allocLocal(inst, inst_ty);
@@ -4787,7 +4762,7 @@ fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index)
     const w = &f.object.code.writer;
 
     const inst_ty = f.typeOfIndex(inst);
-    const result = if (inst_ty.hasRuntimeBitsIgnoreComptime(zcu) and !f.liveness.isUnused(inst))
+    const result = if (inst_ty.hasRuntimeBits(zcu) and !f.liveness.isUnused(inst))
         try f.allocLocal(inst, inst_ty)
     else
         .none;
@@ -4853,7 +4828,7 @@ fn lowerTry(
     const liveness_condbr = f.liveness.getCondBr(inst);
     const w = &f.object.code.writer;
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
-    const payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
+    const payload_has_bits = payload_ty.hasRuntimeBits(zcu);
 
     if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
         try w.writeAll("if (");
@@ -5393,7 +5368,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
     const result = result: {
         const w = &f.object.code.writer;
         const inst_ty = f.typeOfIndex(inst);
-        const inst_local = if (inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) local: {
+        const inst_local = if (inst_ty.hasRuntimeBits(zcu)) local: {
             const inst_local = try f.allocLocalValue(.{
                 .ctype = try f.ctypeFromType(inst_ty, .complete),
                 .alignas = CType.AlignAs.fromAbiAlignment(inst_ty.abiAlignment(zcu)),
@@ -5820,12 +5795,12 @@ fn fieldLocation(
         .struct_type => {
             const loaded_struct = ip.loadStructType(container_ty.toIntern());
             return switch (loaded_struct.layout) {
-                .auto, .@"extern" => if (!container_ty.hasRuntimeBitsIgnoreComptime(zcu))
+                .auto, .@"extern" => if (!container_ty.hasRuntimeBits(zcu))
                     .begin
-                else if (!field_ptr_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu))
-                    .{ .byte_offset = loaded_struct.offsets.get(ip)[field_index] }
+                else if (!field_ptr_ty.childType(zcu).hasRuntimeBits(zcu))
+                    .{ .byte_offset = loaded_struct.field_offsets.get(ip)[field_index] }
                 else
-                    .{ .field = .{ .identifier = loaded_struct.fieldName(ip, field_index).toSlice(ip) } },
+                    .{ .field = .{ .identifier = loaded_struct.field_names.get(ip)[field_index].toSlice(ip) } },
                 .@"packed" => if (field_ptr_ty.ptrInfo(zcu).packed_offset.host_size == 0)
                     .{ .byte_offset = @divExact(zcu.structPackedFieldBitOffset(loaded_struct, field_index) +
                         container_ptr_ty.ptrInfo(zcu).packed_offset.bit_offset, 8) }
@@ -5833,24 +5808,24 @@ fn fieldLocation(
                     .begin,
             };
         },
-        .tuple_type => return if (!container_ty.hasRuntimeBitsIgnoreComptime(zcu))
+        .tuple_type => return if (!container_ty.hasRuntimeBits(zcu))
             .begin
-        else if (!field_ptr_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu))
+        else if (!field_ptr_ty.childType(zcu).hasRuntimeBits(zcu))
             .{ .byte_offset = container_ty.structFieldOffset(field_index, zcu) }
         else
             .{ .field = .{ .field = field_index } },
         .union_type => {
             const loaded_union = ip.loadUnionType(container_ty.toIntern());
-            switch (loaded_union.flagsUnordered(ip).layout) {
+            switch (loaded_union.layout) {
                 .auto, .@"extern" => {
                     const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu))
+                    if (!field_ty.hasRuntimeBits(zcu))
                         return if (loaded_union.has_runtime_tag and !container_ty.unionHasAllZeroBitFieldTypes(zcu))
                             .{ .field = .{ .identifier = "payload" } }
                         else
                             .begin;
-                    const field_name = loaded_union.loadTagType(ip).names.get(ip)[field_index];
-                    return .{ .field = if (loaded_union.hasTag(ip))
+                    const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
+                    return .{ .field = if (loaded_union.has_runtime_tag)
                         .{ .payload_identifier = field_name.toSlice(ip) }
                     else
                         .{ .identifier = field_name.toSlice(ip) } };
@@ -5996,10 +5971,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const extra = f.air.extraData(Air.StructField, ty_pl.payload).data;
 
     const inst_ty = f.typeOfIndex(inst);
-    if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        try reap(f, inst, &.{extra.struct_operand});
-        return .none;
-    }
+    assert(inst_ty.hasRuntimeBits(zcu));
 
     const struct_byval = try f.resolveInst(extra.struct_operand);
     try reap(f, inst, &.{extra.struct_operand});
@@ -6014,9 +5986,9 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
         .struct_type => .{ .identifier = struct_ty.structFieldName(extra.field_index, zcu).unwrap().?.toSlice(ip) },
         .union_type => name: {
             const union_type = ip.loadUnionType(struct_ty.toIntern());
-            const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_ty);
+            const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
             const field_name_str = enum_tag_ty.enumFieldName(extra.field_index, zcu).toSlice(ip);
-            if (union_type.hasTag(ip)) {
+            if (union_type.has_runtime_tag) {
                 break :name .{ .payload_identifier = field_name_str };
             } else {
                 break :name .{ .identifier = field_name_str };
@@ -6161,7 +6133,7 @@ fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
     const payload_ty = inst_ty.errorUnionPayload(zcu);
-    const repr_is_err = !payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
+    const repr_is_err = !payload_ty.hasRuntimeBits(zcu);
     const err_ty = inst_ty.errorUnionSet(zcu);
     const err = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
@@ -6210,7 +6182,7 @@ fn airErrUnionPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
     try reap(f, inst, &.{ty_op.operand});
 
     // First, set the non-error value.
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!payload_ty.hasRuntimeBits(zcu)) {
         const a = try Assignment.start(f, w, try f.ctypeFromType(operand_ty, .complete));
         try f.writeCValueDeref(w, operand);
         try a.assign(f, w);
@@ -6262,13 +6234,13 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
     const inst_ty = f.typeOfIndex(inst);
     const payload_ty = inst_ty.errorUnionPayload(zcu);
     const payload = try f.resolveInst(ty_op.operand);
-    const repr_is_err = !payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
+    assert(payload_ty.hasRuntimeBits(zcu));
     const err_ty = inst_ty.errorUnionSet(zcu);
     try reap(f, inst, &.{ty_op.operand});
 
     const w = &f.object.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    if (!repr_is_err) {
+    {
         const a = try Assignment.start(f, w, try f.ctypeFromType(payload_ty, .complete));
         try f.writeCValueMember(w, local, .{ .identifier = "payload" });
         try a.assign(f, w);
@@ -6277,10 +6249,7 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
     }
     {
         const a = try Assignment.start(f, w, try f.ctypeFromType(err_ty, .complete));
-        if (repr_is_err)
-            try f.writeCValue(w, local, .Other)
-        else
-            try f.writeCValueMember(w, local, .{ .identifier = "error" });
+        try f.writeCValueMember(w, local, .{ .identifier = "error" });
         try a.assign(f, w);
         try f.object.dg.renderValue(w, try pt.intValue(try pt.errorIntType(), 0), .Other);
         try a.end(f, w);
@@ -7411,10 +7380,10 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
                     var field_it = loaded_struct.iterateRuntimeOrder(ip);
                     while (field_it.next()) |field_index| {
                         const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!field_ty.hasRuntimeBits(zcu)) continue;
 
                         const a = try Assignment.start(f, w, try f.ctypeFromType(field_ty, .complete));
-                        try f.writeCValueMember(w, local, .{ .identifier = loaded_struct.fieldName(ip, field_index).toSlice(ip) });
+                        try f.writeCValueMember(w, local, .{ .identifier = loaded_struct.field_names.get(ip)[field_index].toSlice(ip) });
                         try a.assign(f, w);
                         try f.writeCValue(w, resolved_elements[field_index], .Other);
                         try a.end(f, w);
@@ -7426,7 +7395,7 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
         .tuple_type => |tuple_info| for (0..tuple_info.types.len) |field_index| {
             if (tuple_info.values.get(ip)[field_index] != .none) continue;
             const field_ty: Type = .fromInterned(tuple_info.types.get(ip)[field_index]);
-            if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+            if (!field_ty.hasRuntimeBits(zcu)) continue;
 
             const a = try Assignment.start(f, w, try f.ctypeFromType(field_ty, .complete));
             try f.writeCValueMember(w, local, .{ .field = field_index });
@@ -7449,13 +7418,13 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const union_ty = f.typeOfIndex(inst);
     const loaded_union = ip.loadUnionType(union_ty.toIntern());
-    const field_name = loaded_union.loadTagType(ip).names.get(ip)[extra.field_index];
+    const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[extra.field_index];
     const payload_ty = f.typeOf(extra.init);
     const payload = try f.resolveInst(extra.init);
     try reap(f, inst, &.{extra.init});
 
     const w = &f.object.code.writer;
-    if (loaded_union.flagsUnordered(ip).layout == .@"packed") return f.moveCValue(inst, union_ty, payload);
+    if (loaded_union.layout == .@"packed") return f.moveCValue(inst, union_ty, payload);
 
     const local = try f.allocLocal(inst, union_ty);
 
@@ -7466,7 +7435,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
         const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
         try f.writeCValueMember(w, local, .{ .identifier = "tag" });
         try a.assign(f, w);
-        try w.print("{f}", .{try f.fmtIntLiteralDec(try tag_val.intFromEnum(tag_ty, pt))});
+        try w.print("{f}", .{try f.fmtIntLiteralDec(tag_val.intFromEnum(zcu))});
         try a.end(f, w);
         break :field .{ .payload_identifier = field_name.toSlice(ip) };
     } else .{ .identifier = field_name.toSlice(ip) };
diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig
index f28dd48a1775ad0f4deea189ba22121b0c62af10..a7442a1d49dae8c626c54e448364e6169bf0eff6 100644
--- a/src/codegen/c/Type.zig
+++ b/src/codegen/c/Type.zig
@@ -2558,7 +2558,7 @@ pub const Pool = struct {
                                 .tag = .@"struct",
                                 .name = .{ .index = ip_index },
                             });
-                            if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
+                            if (kind.isForward()) return if (ty.hasRuntimeBits(zcu))
                                 fwd_decl
                             else
                                 .void;
@@ -2584,9 +2584,9 @@ pub const Pool = struct {
                                     kind.noParameter(),
                                 );
                                 if (field_ctype.index == .void) continue;
-                                const field_name = try pool.string(allocator, loaded_struct.fieldName(ip, field_index).toSlice(ip));
+                                const field_name = try pool.string(allocator, loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
                                 const field_alignas = AlignAs.fromAlignment(.{
-                                    .@"align" = loaded_struct.fieldAlign(ip, field_index),
+                                    .@"align" = loaded_struct.field_aligns.getOrNone(ip, field_index),
                                     .abi = field_type.abiAlignment(zcu),
                                 });
                                 pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
@@ -2613,7 +2613,7 @@ pub const Pool = struct {
                         .@"packed" => return pool.fromType(
                             allocator,
                             scratch,
-                            Type.fromInterned(loaded_struct.backingIntTypeUnordered(ip)),
+                            .fromInterned(loaded_struct.packed_backing_int_type),
                             pt,
                             mod,
                             kind,
@@ -2682,17 +2682,17 @@ pub const Pool = struct {
                 },
                 .union_type => {
                     const loaded_union = ip.loadUnionType(ip_index);
-                    switch (loaded_union.flagsUnordered(ip).layout) {
+                    switch (loaded_union.layout) {
                         .auto, .@"extern" => {
                             const fwd_decl = try pool.getFwdDecl(allocator, .{
                                 .tag = if (loaded_union.has_runtime_tag) .@"struct" else .@"union",
                                 .name = .{ .index = ip_index },
                             });
-                            if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
+                            if (kind.isForward()) return if (ty.hasRuntimeBits(zcu))
                                 fwd_decl
                             else
                                 .void;
-                            const loaded_tag = loaded_union.loadTagType(ip);
+                            const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
                             const scratch_top = scratch.items.len;
                             defer scratch.shrinkRetainingCapacity(scratch_top);
                             try scratch.ensureUnusedCapacity(
@@ -2718,10 +2718,10 @@ pub const Pool = struct {
                                 if (field_ctype.index == .void) continue;
                                 const field_name = try pool.string(
                                     allocator,
-                                    loaded_tag.names.get(ip)[field_index].toSlice(ip),
+                                    loaded_tag.field_names.get(ip)[field_index].toSlice(ip),
                                 );
                                 const field_alignas = AlignAs.fromAlignment(.{
-                                    .@"align" = loaded_union.fieldAlign(ip, field_index),
+                                    .@"align" = loaded_union.field_aligns.getOrNone(ip, field_index),
                                     .abi = field_type.abiAlignment(zcu),
                                 });
                                 pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
@@ -2753,24 +2753,22 @@ pub const Pool = struct {
                             try pool.ensureUnusedCapacity(allocator, 2);
                             var struct_fields: [2]Info.Field = undefined;
                             var struct_fields_len: usize = 0;
-                            if (loaded_tag.tag_ty != .comptime_int_type) {
-                                const tag_type = Type.fromInterned(loaded_tag.tag_ty);
-                                const tag_ctype: CType = try pool.fromType(
-                                    allocator,
-                                    scratch,
-                                    tag_type,
-                                    pt,
-                                    mod,
-                                    kind.noParameter(),
-                                );
-                                if (tag_ctype.index != .void) {
-                                    struct_fields[struct_fields_len] = .{
-                                        .name = .{ .index = .tag },
-                                        .ctype = tag_ctype,
-                                        .alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
-                                    };
-                                    struct_fields_len += 1;
-                                }
+                            const tag_type = Type.fromInterned(loaded_tag.int_tag_type);
+                            const tag_ctype: CType = try pool.fromType(
+                                allocator,
+                                scratch,
+                                tag_type,
+                                pt,
+                                mod,
+                                kind.noParameter(),
+                            );
+                            if (tag_ctype.index != .void) {
+                                struct_fields[struct_fields_len] = .{
+                                    .name = .{ .index = .tag },
+                                    .ctype = tag_ctype,
+                                    .alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
+                                };
+                                struct_fields_len += 1;
                             }
                             if (fields_len > 0) {
                                 const payload_ctype = payload_ctype: {
@@ -2823,12 +2821,14 @@ pub const Pool = struct {
                 .enum_type => return pool.fromType(
                     allocator,
                     scratch,
-                    Type.fromInterned(ip.loadEnumType(ip_index).tag_ty),
+                    .fromInterned(ip.loadEnumType(ip_index).int_tag_type),
                     pt,
                     mod,
                     kind,
                 ),
-                .func_type => |func_info| if (func_info.is_generic) return .void else {
+                .func_type => |func_info| {
+                    if (!ty.fnHasRuntimeBits(zcu)) return .void;
+
                     const scratch_top = scratch.items.len;
                     defer scratch.shrinkRetainingCapacity(scratch_top);
                     try scratch.ensureUnusedCapacity(allocator, func_info.param_types.len);
@@ -2894,6 +2894,7 @@ pub const Pool = struct {
                 .opt,
                 .aggregate,
                 .un,
+                .bitpack,
                 .memoized_call,
                 => unreachable, // values, not types
             },
diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig
index 1f5b6224d7ef7fbe1cfe1aaa2fc55889db0676ca..3ad6faf805259154ae35f347e1dee712bea196cf 100644
--- a/src/codegen/riscv64/CodeGen.zig
+++ b/src/codegen/riscv64/CodeGen.zig
@@ -3257,7 +3257,7 @@ fn airOptionalPayload(func: *Func, inst: Air.Inst.Index) !void {
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         const pl_ty = func.typeOfIndex(inst);
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
+        if (!pl_ty.hasRuntimeBits(zcu)) break :result .none;
 
         const opt_mcv = try func.resolveInst(ty_op.operand);
         if (func.reuseOperand(inst, ty_op.operand, 0, opt_mcv)) {
@@ -3331,7 +3331,7 @@ fn airUnwrapErrErr(func: *Func, inst: Air.Inst.Index) !void {
             break :result .{ .immediate = 0 };
         }
 
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             break :result operand;
         }
 
@@ -3384,7 +3384,7 @@ fn genUnwrapErrUnionPayloadMir(
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
 
     const result: MCValue = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
+        if (!payload_ty.hasRuntimeBits(zcu)) break :result .none;
 
         const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
         switch (err_union) {
@@ -3547,7 +3547,7 @@ fn airWrapErrUnionPayload(func: *Func, inst: Air.Inst.Index) !void {
     const operand = try func.resolveInst(ty_op.operand);
 
     const result: MCValue = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .{ .immediate = 0 };
+        if (!pl_ty.hasRuntimeBits(zcu)) break :result .{ .immediate = 0 };
 
         const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
         const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
@@ -3571,7 +3571,7 @@ fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void {
     const err_ty = eu_ty.errorUnionSet(zcu);
 
     const result: MCValue = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result try func.resolveInst(ty_op.operand);
+        if (!pl_ty.hasRuntimeBits(zcu)) break :result try func.resolveInst(ty_op.operand);
 
         const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
         const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
@@ -3761,7 +3761,7 @@ fn airSliceElemVal(func: *Func, inst: Air.Inst.Index) !void {
 
     const result: MCValue = result: {
         const elem_ty = func.typeOfIndex(inst);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
+        assert(elem_ty.hasRuntimeBits(zcu));
 
         const slice_ty = func.typeOf(bin_op.lhs);
         const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
@@ -3914,7 +3914,7 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void {
 
     const result: MCValue = if (!is_volatile and func.liveness.isUnused(inst)) .unreach else result: {
         const elem_ty = base_ptr_ty.indexableElem(zcu);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
+        assert(elem_ty.hasRuntimeBits(zcu));
         const base_ptr_mcv = try func.resolveInst(bin_op.lhs);
         const base_ptr_lock: ?RegisterLock = switch (base_ptr_mcv) {
             .register => |reg| func.register_manager.lockRegAssumeUnused(reg),
@@ -4617,7 +4617,7 @@ fn airStructFieldVal(func: *Func, inst: Air.Inst.Index) !void {
         const src_mcv = try func.resolveInst(operand);
         const struct_ty = func.typeOf(operand);
         const field_ty = struct_ty.fieldType(index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
+        assert(field_ty.hasRuntimeBits(zcu));
 
         const field_off: u32 = switch (struct_ty.containerLayout(zcu)) {
             .auto, .@"extern" => @intCast(struct_ty.structFieldOffset(index, zcu) * 8),
@@ -5126,7 +5126,6 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = func.pt;
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
 
     const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: {
         const lhs_ty = func.typeOf(bin_op.lhs);
@@ -5140,28 +5139,23 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
             .optional,
             .@"struct",
             => {
-                const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
+                const int_ty: Type = switch (lhs_ty.zigTypeTag(zcu)) {
                     .@"enum" => lhs_ty.intTagType(zcu),
                     .int => lhs_ty,
-                    .bool => Type.u1,
-                    .pointer => Type.u64,
-                    .error_set => Type.anyerror,
+                    .bool => .u1,
+                    .pointer => .u64,
+                    .error_set => .anyerror,
                     .optional => blk: {
                         const payload_ty = lhs_ty.optionalChild(zcu);
-                        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                            break :blk Type.u1;
+                        if (!payload_ty.hasRuntimeBits(zcu)) {
+                            break :blk .u1;
                         } else if (lhs_ty.isPtrLikeOptional(zcu)) {
-                            break :blk Type.u64;
+                            break :blk .u64;
                         } else {
                             return func.fail("TODO riscv cmp non-pointer optionals", .{});
                         }
                     },
-                    .@"struct" => blk: {
-                        const struct_obj = ip.loadStructType(lhs_ty.toIntern());
-                        assert(struct_obj.layout == .@"packed");
-                        const backing_index = struct_obj.backingIntTypeUnordered(ip);
-                        break :blk Type.fromInterned(backing_index);
-                    },
+                    .@"struct", .@"union" => lhs_ty.bitpackBackingInt(zcu),
                     else => unreachable,
                 };
 
@@ -5925,8 +5919,7 @@ fn airBr(func: *Func, inst: Air.Inst.Index) !void {
     const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br;
 
     const block_ty = func.typeOfIndex(br.block_inst);
-    const block_unused =
-        !block_ty.hasRuntimeBitsIgnoreComptime(zcu) or func.liveness.isUnused(br.block_inst);
+    const block_unused = !block_ty.hasRuntimeBits(zcu) or func.liveness.isUnused(br.block_inst);
     const block_tracking = func.inst_tracking.getPtr(br.block_inst).?;
     const block_data = func.blocks.getPtr(br.block_inst).?;
     const first_br = block_data.relocs.items.len == 0;
@@ -8249,7 +8242,7 @@ fn resolveCallingConventionValues(
             // Return values
             if (ret_ty.zigTypeTag(zcu) == .noreturn) {
                 result.return_value = InstTracking.init(.unreach);
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            } else if (!ret_ty.hasRuntimeBits(zcu)) {
                 result.return_value = InstTracking.init(.none);
             } else {
                 var ret_tracking: [2]InstTracking = undefined;
@@ -8300,7 +8293,7 @@ fn resolveCallingConventionValues(
             var param_float_reg_i: usize = 0;
 
             for (param_types, result.args) |ty, *arg| {
-                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                if (!ty.hasRuntimeBits(zcu)) {
                     assert(cc == .auto);
                     arg.* = .none;
                     continue;
@@ -8415,10 +8408,10 @@ fn hasFeature(func: *Func, feature: Target.riscv.Feature) bool {
 }
 
 pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
+    if (!payload_ty.hasRuntimeBits(zcu)) return 0;
     const payload_align = payload_ty.abiAlignment(zcu);
     const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBits(zcu)) {
         return 0;
     } else {
         return payload_align.forward(Type.anyerror.abiSize(zcu));
@@ -8426,10 +8419,10 @@ pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
 }
 
 pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
+    if (!payload_ty.hasRuntimeBits(zcu)) return 0;
     const payload_align = payload_ty.abiAlignment(zcu);
     const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBits(zcu)) {
         return error_align.forward(payload_ty.abiSize(zcu));
     } else {
         return 0;
diff --git a/src/codegen/sparc64/CodeGen.zig b/src/codegen/sparc64/CodeGen.zig
index a246df12c59f3277001ba28fd671b6c42fe769e7..3b38d6319ac325cb462b805727197121be348bfd 100644
--- a/src/codegen/sparc64/CodeGen.zig
+++ b/src/codegen/sparc64/CodeGen.zig
@@ -1102,7 +1102,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
 fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
     try self.blocks.putNoClobber(self.gpa, inst, .{
         // A block is a setup to be able to jump to the end.
-        .relocs = .{},
+        .relocs = .empty,
         // It also acts as a receptacle for break operands.
         // Here we use `MCValue.none` to represent a null value so that the first
         // break instruction will choose a MCValue for the block result and overwrite
@@ -1376,19 +1376,19 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
         const rhs = try self.resolveInst(bin_op.rhs);
         const lhs_ty = self.typeOf(bin_op.lhs);
 
-        const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
+        const int_ty: Type = switch (lhs_ty.zigTypeTag(zcu)) {
             .vector => unreachable, // Handled by cmp_vector.
             .@"enum" => lhs_ty.intTagType(zcu),
             .int => lhs_ty,
-            .bool => Type.u1,
-            .pointer => Type.usize,
-            .error_set => Type.u16,
+            .bool => .u1,
+            .pointer => .usize,
+            .error_set => .u16,
             .optional => blk: {
                 const payload_ty = lhs_ty.optionalChild(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    break :blk Type.u1;
+                if (!payload_ty.hasRuntimeBits(zcu)) {
+                    break :blk .u1;
                 } else if (lhs_ty.isPtrLikeOptional(zcu)) {
-                    break :blk Type.usize;
+                    break :blk .usize;
                 } else {
                     return self.fail("TODO SPARCv9 cmp non-pointer optionals", .{});
                 }
@@ -3452,8 +3452,8 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)
     if (err_ty.errorSetIsEmpty(zcu)) {
         return error_union_mcv;
     }
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        return MCValue.none;
+    if (!payload_ty.hasRuntimeBits(zcu)) {
+        return .none;
     }
 
     const payload_offset: u32 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
@@ -4481,7 +4481,7 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
     const ty = self.typeOf(ref);
 
     // If the type has no codegen bits, no need to store it.
-    if (!ty.hasRuntimeBitsIgnoreComptime(pt.zcu)) return .none;
+    if (!ty.hasRuntimeBits(pt.zcu)) return .none;
 
     if (ref.toIndex()) |inst| {
         return self.getResolvedInstValue(inst);
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index d303af6d610ded6effd8ff80e41cdab36650bd90..34a7f99ce4f30d39e8dd4caf710390816abf220f 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -208,7 +208,7 @@ pub fn genNav(cg: *CodeGen, do_codegen: bool) Error!void {
             try cg.args.ensureUnusedCapacity(gpa, fn_info.param_types.len);
             for (fn_info.param_types.get(ip)) |param_ty_index| {
                 const param_ty: Type = .fromInterned(param_ty_index);
-                if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                if (!param_ty.hasRuntimeBits(zcu)) continue;
 
                 const param_type_id = try cg.resolveType(param_ty, .direct);
                 const arg_result_id = cg.module.allocId();
@@ -884,7 +884,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
                 return try cg.constructComposite(comp_ty_id, &constituents);
             },
             .enum_tag => {
-                const int_val = try val.intFromEnum(ty, pt);
+                const int_val = val.intFromEnum(zcu);
                 const int_ty = ty.intTagType(zcu);
                 break :cache try cg.constant(int_ty, int_val, repr);
             },
@@ -959,18 +959,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
                 },
                 .struct_type => {
                     const struct_type = zcu.typeToStruct(ty).?;
-
-                    if (struct_type.layout == .@"packed") {
-                        // TODO: composite int
-                        // TODO: endianness
-                        const bits: u16 = @intCast(ty.bitSize(zcu));
-                        const bytes = std.mem.alignForward(u16, cg.module.backingIntBits(bits).@"0", 8) / 8;
-                        var limbs: [8]u8 = undefined;
-                        @memset(&limbs, 0);
-                        val.writeToPackedMemory(pt, limbs[0..bytes], 0) catch unreachable;
-                        const backing_ty: Type = .fromInterned(struct_type.backingIntTypeUnordered(ip));
-                        return try cg.constInt(backing_ty, @as(u64, @bitCast(limbs)));
-                    }
+                    assert(struct_type.layout != .@"packed"); // packed structs use `bitpack`
 
                     var types = std.array_list.Managed(Type).init(gpa);
                     defer types.deinit();
@@ -981,7 +970,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
                     var it = struct_type.iterateRuntimeOrder(ip);
                     while (it.next()) |field_index| {
                         const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+                        if (!field_ty.hasRuntimeBits(zcu)) {
                             // This is a zero-bit field - we only needed it for the alignment.
                             continue;
                         }
@@ -1001,20 +990,24 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
                 else => unreachable,
             },
             .un => |un| {
+                assert(ty.containerLayout(zcu) != .@"packed"); // packed unions use `bitpack`
                 if (un.tag == .none) {
-                    assert(ty.containerLayout(zcu) == .@"packed"); // TODO
-                    const int_ty = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
-                    return try cg.constInt(int_ty, Value.toUnsignedInt(.fromInterned(un.val), zcu));
+                    @panic("TODO");
                 }
                 const active_field = ty.unionTagFieldIndex(.fromInterned(un.tag), zcu).?;
                 const union_obj = zcu.typeToUnion(ty).?;
                 const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[active_field]);
-                const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu))
+                const payload = if (field_ty.hasRuntimeBits(zcu))
                     try cg.constant(field_ty, .fromInterned(un.val), .direct)
                 else
                     null;
                 return try cg.unionInit(ty, active_field, payload);
             },
+            .bitpack => |bitpack| {
+                const int_val: Value = .fromInterned(bitpack.backing_int_val);
+                break :cache try cg.constant(int_val.typeOf(zcu), int_val, repr);
+            },
+
             .memoized_call => unreachable,
         }
     };
@@ -1255,17 +1248,16 @@ fn resolveTypeName(cg: *CodeGen, ty: Type) ![]const u8 {
 fn resolveUnionType(cg: *CodeGen, ty: Type) !Id {
     const gpa = cg.module.gpa;
     const zcu = cg.module.zcu;
-    const ip = &zcu.intern_pool;
     const union_obj = zcu.typeToUnion(ty).?;
 
-    if (union_obj.flagsUnordered(ip).layout == .@"packed") {
+    if (union_obj.layout == .@"packed") {
         return try cg.module.intType(.unsigned, @intCast(ty.bitSize(zcu)));
     }
 
     const layout = cg.unionLayout(ty);
     if (!layout.has_payload) {
         // No payload, so represent this as just the tag type.
-        return try cg.resolveType(.fromInterned(union_obj.enum_tag_ty), .indirect);
+        return try cg.resolveType(.fromInterned(union_obj.enum_tag_type), .indirect);
     }
 
     var member_types: [4]Id = undefined;
@@ -1274,7 +1266,7 @@ fn resolveUnionType(cg: *CodeGen, ty: Type) !Id {
     const u8_ty_id = try cg.resolveType(.u8, .direct);
 
     if (layout.tag_size != 0) {
-        const tag_ty_id = try cg.resolveType(.fromInterned(union_obj.enum_tag_ty), .indirect);
+        const tag_ty_id = try cg.resolveType(.fromInterned(union_obj.enum_tag_type), .indirect);
         member_types[layout.tag_index] = tag_ty_id;
         member_names[layout.tag_index] = "(tag)";
     }
@@ -1315,7 +1307,7 @@ fn resolveUnionType(cg: *CodeGen, ty: Type) !Id {
 
 fn resolveFnReturnType(cg: *CodeGen, ret_ty: Type) !Id {
     const zcu = cg.module.zcu;
-    if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!ret_ty.hasRuntimeBits(zcu)) {
         // If the return type is an error set or an error union, then we make this
         // anyerror return type instead, so that it can be coerced into a function
         // pointer type which has anyerror as the return type.
@@ -1389,7 +1381,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
                 return cg.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(zcu)});
             };
 
-            if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!elem_ty.hasRuntimeBits(zcu)) {
                 assert(repr == .indirect);
                 if (target.os.tag != .opencl) return cg.fail("cannot generate opaque type", .{});
                 return try cg.module.opaqueType("zero-sized-array");
@@ -1453,7 +1445,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
                 var param_index: usize = 0;
                 for (fn_info.param_types.get(ip)) |param_ty_index| {
                     const param_ty: Type = .fromInterned(param_ty_index);
-                    if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                    if (!param_ty.hasRuntimeBits(zcu)) continue;
 
                     param_ty_ids[param_index] = try cg.resolveType(param_ty, .direct);
                     param_index += 1;
@@ -1518,7 +1510,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
             };
 
             if (struct_type.layout == .@"packed") {
-                return try cg.resolveType(.fromInterned(struct_type.backingIntTypeUnordered(ip)), .direct);
+                return try cg.resolveType(.fromInterned(struct_type.packed_backing_int_type), .direct);
             }
 
             var member_types = std.array_list.Managed(Id).init(gpa);
@@ -1533,9 +1525,9 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
             var it = struct_type.iterateRuntimeOrder(ip);
             while (it.next()) |field_index| {
                 const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
-                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                if (!field_ty.hasRuntimeBits(zcu)) continue;
 
-                const field_name = struct_type.fieldName(ip, field_index);
+                const field_name = struct_type.field_names.get(ip)[field_index];
                 try member_types.append(try cg.resolveType(field_ty, .indirect));
                 try member_names.append(field_name.toSlice(ip));
                 try member_offsets.append(@intCast(ty.structFieldOffset(field_index, zcu)));
@@ -1556,7 +1548,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
         },
         .optional => {
             const payload_ty = ty.optionalChild(zcu);
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_ty.hasRuntimeBits(zcu)) {
                 // Just use a bool.
                 // Note: Always generate the bool with indirect format, to save on some sanity
                 // Perform the conversion to a direct bool when the field is extracted.
@@ -1653,7 +1645,7 @@ fn errorUnionLayout(cg: *CodeGen, payload_ty: Type) ErrorUnionLayout {
 
     const error_first = error_align.compare(.gt, payload_align);
     return .{
-        .payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu),
+        .payload_has_bits = payload_ty.hasRuntimeBits(zcu),
         .error_first = error_first,
     };
 }
@@ -3724,7 +3716,6 @@ fn cmp(
     const gpa = cg.module.gpa;
     const pt = cg.pt;
     const zcu = cg.module.zcu;
-    const ip = &zcu.intern_pool;
     const scalar_ty = lhs.ty.scalarType(zcu);
     const is_vector = lhs.ty.isVector(zcu);
 
@@ -3737,7 +3728,7 @@ fn cmp(
         },
         .@"struct" => {
             const struct_ty = zcu.typeToPackedStruct(scalar_ty).?;
-            const ty: Type = .fromInterned(struct_ty.backingIntTypeUnordered(ip));
+            const ty: Type = .fromInterned(struct_ty.packed_backing_int_type);
             return try cg.cmp(op, lhs.pun(ty), rhs.pun(ty));
         },
         .error_set => {
@@ -3778,7 +3769,7 @@ fn cmp(
 
             const payload_ty = ty.optionalChild(zcu);
             if (ty.optionalReprIsPayload(zcu)) {
-                assert(payload_ty.hasRuntimeBitsIgnoreComptime(zcu));
+                assert(payload_ty.hasRuntimeBits(zcu));
                 assert(!payload_ty.isSlice(zcu));
 
                 return try cg.cmp(op, lhs.pun(payload_ty), rhs.pun(payload_ty));
@@ -3787,12 +3778,12 @@ fn cmp(
             const lhs_id = try lhs.materialize(cg);
             const rhs_id = try rhs.materialize(cg);
 
-            const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
+            const lhs_valid_id = if (payload_ty.hasRuntimeBits(zcu))
                 try cg.extractField(.bool, lhs_id, 1)
             else
                 try cg.convertToDirect(.bool, lhs_id);
 
-            const rhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
+            const rhs_valid_id = if (payload_ty.hasRuntimeBits(zcu))
                 try cg.extractField(.bool, rhs_id, 1)
             else
                 try cg.convertToDirect(.bool, rhs_id);
@@ -3800,7 +3791,7 @@ fn cmp(
             const lhs_valid: Temporary = .init(.bool, lhs_valid_id);
             const rhs_valid: Temporary = .init(.bool, rhs_valid_id);
 
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_ty.hasRuntimeBits(zcu)) {
                 return try cg.cmp(op, lhs_valid, rhs_valid);
             }
 
@@ -4138,7 +4129,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const array_ptr_id = try cg.resolve(ty_op.operand);
     const len_id = try cg.constInt(.usize, array_ty.arrayLen(zcu));
 
-    const elem_ptr_id = if (!array_ty.hasRuntimeBitsIgnoreComptime(zcu))
+    const elem_ptr_id = if (!array_ty.hasRuntimeBits(zcu))
         // Note: The pointer is something like *opaque{}, so we need to bitcast it to the element type.
         try cg.bitCast(elem_ptr_ty, array_ptr_ty, array_ptr_id)
     else
@@ -4174,12 +4165,12 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
         .@"struct" => {
             if (zcu.typeToPackedStruct(result_ty)) |struct_type| {
                 comptime assert(Type.packed_struct_layout_version == 2);
-                const backing_int_ty: Type = .fromInterned(struct_type.backingIntTypeUnordered(ip));
+                const backing_int_ty: Type = .fromInterned(struct_type.packed_backing_int_type);
                 var running_int_id = try cg.constInt(backing_int_ty, 0);
                 var running_bits: u16 = 0;
                 for (struct_type.field_types.get(ip), elements) |field_ty_ip, element| {
                     const field_ty: Type = .fromInterned(field_ty_ip);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                    if (!field_ty.hasRuntimeBits(zcu)) continue;
                     const field_id = try cg.resolve(element);
                     const ty_bit_size: u16 = @intCast(field_ty.bitSize(zcu));
                     const field_int_ty = try cg.pt.intType(.unsigned, ty_bit_size);
@@ -4239,7 +4230,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
                         const field_index = it.next().?;
                         if ((try result_ty.structFieldValueComptime(pt, i)) != null) continue;
                         const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
-                        assert(field_ty.hasRuntimeBitsIgnoreComptime(zcu));
+                        assert(field_ty.hasRuntimeBits(zcu));
 
                         const id = try cg.resolve(element);
                         types[index] = field_ty;
@@ -4399,10 +4390,7 @@ fn airPtrElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const elem_ty = src_ptr_ty.childType(zcu);
     const ptr_id = try cg.resolve(bin_op.lhs);
 
-    if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        const dst_ptr_ty = cg.typeOfIndex(inst);
-        return try cg.bitCast(dst_ptr_ty, src_ptr_ty, ptr_id);
-    }
+    assert(elem_ty.hasRuntimeBits(zcu));
 
     const index_id = try cg.resolve(bin_op.rhs);
     return try cg.ptrElemPtr(src_ptr_ty, ptr_id, index_id);
@@ -4526,13 +4514,13 @@ fn unionInit(
     const zcu = cg.module.zcu;
     const ip = &zcu.intern_pool;
     const union_ty = zcu.typeToUnion(ty).?;
-    const tag_ty: Type = .fromInterned(union_ty.enum_tag_ty);
+    const tag_ty: Type = .fromInterned(union_ty.enum_tag_type);
 
     const layout = cg.unionLayout(ty);
     const payload_ty: Type = .fromInterned(union_ty.field_types.get(ip)[active_field]);
 
-    if (union_ty.flagsUnordered(ip).layout == .@"packed") {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (union_ty.layout == .@"packed") {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             const int_ty = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
             return cg.constInt(int_ty, 0);
         }
@@ -4558,7 +4546,7 @@ fn unionInit(
 
     const tag_int = if (layout.tag_size != 0) blk: {
         const tag_val = try pt.enumValueFieldIndex(tag_ty, active_field);
-        const tag_int_val = try tag_val.intFromEnum(tag_ty, pt);
+        const tag_int_val = tag_val.intFromEnum(zcu);
         break :blk tag_int_val.toUnsignedInt(zcu);
     } else 0;
 
@@ -4577,7 +4565,7 @@ fn unionInit(
         try cg.store(tag_ty, ptr_id, tag_id, .{});
     }
 
-    if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (payload_ty.hasRuntimeBits(zcu)) {
         const layout_payload_ty_id = try cg.resolveType(layout.payload_ty, .indirect);
         const pl_ptr_ty_id = try cg.module.ptrType(layout_payload_ty_id, .function);
         const pl_ptr_id = try cg.accessChain(pl_ptr_ty_id, tmp_id, &.{layout.payload_index});
@@ -4613,7 +4601,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
 
     const union_obj = zcu.typeToUnion(ty).?;
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
-    const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu))
+    const payload = if (field_ty.hasRuntimeBits(zcu))
         try cg.resolve(extra.init)
     else
         null;
@@ -4631,7 +4619,7 @@ fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const field_index = struct_field.field_index;
     const field_ty = object_ty.fieldType(field_index, zcu);
 
-    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
+    assert(field_ty.hasRuntimeBits(zcu));
 
     switch (object_ty.zigTypeTag(zcu)) {
         .@"struct" => switch (object_ty.containerLayout(zcu)) {
@@ -5332,7 +5320,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) !void {
     const zcu = cg.module.zcu;
     const operand = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const ret_ty = cg.typeOf(operand);
-    if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!ret_ty.hasRuntimeBits(zcu)) {
         const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
         if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
             // Functions with an empty error set are emitted with an error code
@@ -5356,7 +5344,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) !void {
     const ptr_ty = cg.typeOf(un_op);
     const ret_ty = ptr_ty.childType(zcu);
 
-    if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!ret_ty.hasRuntimeBits(zcu)) {
         const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
         if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
             // Functions with an empty error set are emitted with an error code
@@ -5573,7 +5561,7 @@ fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum {
 
     const is_non_null_id = blk: {
         if (is_pointer) {
-            if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (payload_ty.hasRuntimeBits(zcu)) {
                 const storage_class = cg.module.storageClass(operand_ty.ptrAddressSpace(zcu));
                 const bool_indirect_ty_id = try cg.resolveType(.bool, .indirect);
                 const bool_ptr_ty_id = try cg.module.ptrType(bool_indirect_ty_id, storage_class);
@@ -5584,7 +5572,7 @@ fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum {
             break :blk try cg.load(.bool, operand_id, .{});
         }
 
-        break :blk if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
+        break :blk if (payload_ty.hasRuntimeBits(zcu))
             try cg.extractField(.bool, operand_id, 1)
         else
             // Optional representation is bool indicating whether the optional is set
@@ -5653,7 +5641,7 @@ fn airUnwrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const optional_ty = cg.typeOf(ty_op.operand);
     const payload_ty = cg.typeOfIndex(inst);
 
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
+    if (!payload_ty.hasRuntimeBits(zcu)) return null;
 
     if (optional_ty.optionalReprIsPayload(zcu)) {
         return operand_id;
@@ -5672,7 +5660,7 @@ fn airUnwrapOptionalPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const result_ty = cg.typeOfIndex(inst);
     const result_ty_id = try cg.resolveType(result_ty, .direct);
 
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!payload_ty.hasRuntimeBits(zcu)) {
         // There is no payload, but we still need to return a valid pointer.
         // We can just return anything here, so just return a pointer to the operand.
         return try cg.bitCast(result_ty, operand_ty, operand_id);
@@ -5691,9 +5679,7 @@ fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
     const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const payload_ty = cg.typeOf(ty_op.operand);
 
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        return try cg.constBool(true, .indirect);
-    }
+    assert(payload_ty.hasRuntimeBits(zcu));
 
     const operand_id = try cg.resolve(ty_op.operand);
 
@@ -5789,8 +5775,7 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
                 const int_val: u64 = switch (cond_ty.zigTypeTag(zcu)) {
                     .bool, .int => if (cond_ty.isSignedInt(zcu)) @bitCast(value.toSignedInt(zcu)) else value.toUnsignedInt(zcu),
                     .@"enum" => blk: {
-                        // TODO: figure out of cond_ty is correct (something with enum literals)
-                        break :blk (try value.intFromEnum(cond_ty, pt)).toUnsignedInt(zcu); // TODO: composite integer constants
+                        break :blk value.intFromEnum(zcu).toUnsignedInt(zcu); // TODO: composite integer constants
                     },
                     .error_set => value.getErrorInt(zcu),
                     .pointer => value.toUnsignedInt(zcu),
@@ -6067,7 +6052,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
         // before starting to emit OpFunctionCall instructions. Hence the
         // temporary params buffer.
         const arg_ty = cg.typeOf(arg);
-        if (!arg_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+        if (!arg_ty.hasRuntimeBits(zcu)) continue;
         const arg_id = try cg.resolve(arg);
 
         params[n_params] = arg_id;
@@ -6081,7 +6066,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
         .id_ref_3 = params[0..n_params],
     });
 
-    if (cg.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (cg.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBits(zcu)) {
         return null;
     }
 
diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig
index 6b5cd3c1c556aaf63343a2fe33e4966f96203a01..a8f374772e3e042f0bd32a3eb29c5cd39141092d 100644
--- a/src/codegen/wasm/CodeGen.zig
+++ b/src/codegen/wasm/CodeGen.zig
@@ -759,7 +759,7 @@ fn resolveInst(cg: *CodeGen, ref: Air.Inst.Ref) InnerError!WValue {
     const zcu = pt.zcu;
     const val = (try cg.air.value(ref, pt)).?;
     const ty = cg.typeOf(ref);
-    if (!ty.hasRuntimeBitsIgnoreComptime(zcu) and !ty.isInt(zcu) and !ty.isError(zcu)) {
+    if (!ty.hasRuntimeBits(zcu) and !ty.isInt(zcu) and !ty.isError(zcu)) {
         gop.value_ptr.* = .none;
         return .none;
     }
@@ -773,7 +773,7 @@ fn resolveInst(cg: *CodeGen, ref: Air.Inst.Ref) InnerError!WValue {
     const result: WValue = if (isByRef(ty, zcu, cg.target))
         .{ .uav_ref = .{ .ip_index = val.toIntern() } }
     else
-        try cg.lowerConstant(val, ty);
+        try cg.lowerConstant(val);
 
     gop.value_ptr.* = result;
     return result;
@@ -786,7 +786,7 @@ fn resolveValue(cg: *CodeGen, val: Value) InnerError!WValue {
     return if (isByRef(ty, zcu, cg.target))
         .{ .uav_ref = .{ .ip_index = val.toIntern() } }
     else
-        try cg.lowerConstant(val, ty);
+        try cg.lowerConstant(val);
 }
 
 /// NOTE: if result == .stack, it will be stored in .local
@@ -980,7 +980,6 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 {
 
 /// For `std.builtin.CallingConvention.auto`.
 pub fn typeToValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) std.wasm.Valtype {
-    const ip = &zcu.intern_pool;
     return switch (ty.zigTypeTag(zcu)) {
         .float => switch (ty.floatBits(target)) {
             16 => .i32, // stored/loaded as u16
@@ -994,25 +993,13 @@ pub fn typeToValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) std.w
             33...64 => .i64,
             else => .i32,
         },
-        .@"struct" => blk: {
-            if (zcu.typeToPackedStruct(ty)) |packed_struct| {
-                const backing_int_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
-                break :blk typeToValtype(backing_int_ty, zcu, target);
-            } else {
-                break :blk .i32;
-            }
-        },
         .vector => switch (CodeGen.determineSimdStoreStrategy(ty, zcu, target)) {
             .direct => .v128,
             .unrolled => .i32,
         },
-        .@"union" => switch (ty.containerLayout(zcu)) {
-            .@"packed" => switch (ty.bitSize(zcu)) {
-                0...32 => .i32,
-                33...64 => .i64,
-                else => .i32,
-            },
-            else => .i32,
+        .@"union", .@"struct" => switch (ty.containerLayout(zcu)) {
+            .@"packed" => typeToValtype(ty.bitpackBackingInt(zcu), zcu, target),
+            .auto, .@"extern" => .i32,
         },
         else => .i32, // all represented as reference/immediate
     };
@@ -1185,7 +1172,7 @@ pub fn generate(
     const fn_ty = zcu.navValue(cg.owner_nav).typeOf(zcu);
     const fn_info = zcu.typeToFunc(fn_ty).?;
     const ret_ty: Type = .fromInterned(fn_info.return_type);
-    const any_returns = !firstParamSRet(fn_info.cc, ret_ty, zcu, target) and ret_ty.hasRuntimeBitsIgnoreComptime(zcu);
+    const any_returns = !firstParamSRet(fn_info.cc, ret_ty, zcu, target) and ret_ty.hasRuntimeBits(zcu);
 
     var cc_result = try resolveCallingConventionValues(zcu, fn_ty, target);
     defer cc_result.deinit(gpa);
@@ -1244,7 +1231,7 @@ fn generateInner(cg: *CodeGen, any_returns: bool) InnerError!Mir {
     if (any_returns and cg.air.instructions.len > 0) {
         const inst: Air.Inst.Index = @enumFromInt(cg.air.instructions.len - 1);
         const last_inst_ty = cg.typeOfIndex(inst);
-        if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!last_inst_ty.hasRuntimeBits(zcu)) {
             try cg.addTag(.@"unreachable");
         }
     }
@@ -1316,7 +1303,7 @@ fn resolveCallingConventionValues(
     switch (cc) {
         .auto => {
             for (fn_info.param_types.get(ip)) |ty| {
-                if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(zcu)) {
+                if (!Type.fromInterned(ty).hasRuntimeBits(zcu)) {
                     continue;
                 }
 
@@ -1326,7 +1313,7 @@ fn resolveCallingConventionValues(
         },
         .wasm_mvp => {
             for (fn_info.param_types.get(ip)) |ty| {
-                if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(zcu)) {
+                if (!Type.fromInterned(ty).hasRuntimeBits(zcu)) {
                     continue;
                 }
                 switch (abi.classifyType(.fromInterned(ty), zcu)) {
@@ -1357,7 +1344,7 @@ pub fn firstParamSRet(
     zcu: *const Zcu,
     target: *const std.Target,
 ) bool {
-    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) return false;
+    if (!return_type.hasRuntimeBits(zcu)) return false;
     switch (cc) {
         .@"inline" => unreachable,
         .auto => return isByRef(return_type, zcu, target),
@@ -1457,7 +1444,7 @@ fn restoreStackPointer(cg: *CodeGen) !void {
 fn allocStack(cg: *CodeGen, ty: Type) !WValue {
     const pt = cg.pt;
     const zcu = pt.zcu;
-    assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
+    assert(ty.hasRuntimeBits(zcu));
     if (cg.initial_stack_value == .none) {
         try cg.initializeStack();
     }
@@ -1491,7 +1478,7 @@ fn allocStackPtr(cg: *CodeGen, inst: Air.Inst.Index) !WValue {
         try cg.initializeStack();
     }
 
-    if (!pointee_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!pointee_ty.hasRuntimeBits(zcu)) {
         return cg.allocStack(Type.usize); // create a value containing just the stack pointer.
     }
 
@@ -1676,7 +1663,6 @@ fn ptrSize(cg: *const CodeGen) u16 {
 /// For a given `Type`, will return true when the type will be passed
 /// by reference, rather than by value
 fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool {
-    const ip = &zcu.intern_pool;
     switch (ty.zigTypeTag(zcu)) {
         .type,
         .comptime_int,
@@ -1697,20 +1683,10 @@ fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool {
 
         .array,
         .frame,
-        => return ty.hasRuntimeBitsIgnoreComptime(zcu),
-        .@"union" => {
-            if (zcu.typeToUnion(ty)) |union_obj| {
-                if (union_obj.flagsUnordered(ip).layout == .@"packed") {
-                    return ty.abiSize(zcu) > 8;
-                }
-            }
-            return ty.hasRuntimeBitsIgnoreComptime(zcu);
-        },
-        .@"struct" => {
-            if (zcu.typeToPackedStruct(ty)) |packed_struct| {
-                return isByRef(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), zcu, target);
-            }
-            return ty.hasRuntimeBitsIgnoreComptime(zcu);
+        => return ty.hasRuntimeBits(zcu),
+        .@"struct", .@"union" => switch (ty.containerLayout(zcu)) {
+            .@"packed" => return isByRef(ty.bitpackBackingInt(zcu), zcu, target),
+            .@"extern", .auto => return ty.hasRuntimeBits(zcu),
         },
         .vector => return determineSimdStoreStrategy(ty, zcu, target) == .unrolled,
         .int => return ty.intInfo(zcu).bits > 64,
@@ -1718,7 +1694,7 @@ fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool {
         .float => return ty.floatBits(target) > 64,
         .error_union => {
             const pl_ty = ty.errorUnionPayload(zcu);
-            if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!pl_ty.hasRuntimeBits(zcu)) {
                 return false;
             }
             return true;
@@ -1727,7 +1703,7 @@ fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool {
             if (ty.isPtrLikeOptional(zcu)) return false;
             const pl_type = ty.optionalChild(zcu);
             if (pl_type.zigTypeTag(zcu) == .error_set) return false;
-            return pl_type.hasRuntimeBitsIgnoreComptime(zcu);
+            return pl_type.hasRuntimeBits(zcu);
         },
         .pointer => {
             // Slices act like struct and will be passed by reference
@@ -2069,7 +2045,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     // to the stack instead
     if (cg.return_value != .none) {
         try cg.store(cg.return_value, operand, ret_ty, 0);
-    } else if (fn_info.cc == .wasm_mvp and ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    } else if (fn_info.cc == .wasm_mvp and ret_ty.hasRuntimeBits(zcu)) {
         switch (abi.classifyType(ret_ty, zcu)) {
             .direct => |scalar_type| {
                 assert(!abi.lowerAsDoubleI64(scalar_type, zcu));
@@ -2082,7 +2058,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             .indirect => unreachable,
         }
     } else {
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and ret_ty.isError(zcu)) {
+        if (!ret_ty.hasRuntimeBits(zcu) and ret_ty.isError(zcu)) {
             try cg.addImm32(0);
         } else {
             try cg.emitWValue(operand);
@@ -2121,7 +2097,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ret_ty = cg.typeOf(un_op).childType(zcu);
 
     const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
-    if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!ret_ty.hasRuntimeBits(zcu)) {
         if (ret_ty.isError(zcu)) {
             try cg.addImm32(0);
         }
@@ -2177,7 +2153,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
         const arg_val = try cg.resolveInst(arg);
 
         const arg_ty = cg.typeOf(arg);
-        if (!arg_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+        if (!arg_ty.hasRuntimeBits(zcu)) continue;
 
         try cg.lowerArg(zcu.typeToFunc(fn_ty).?.cc, arg_ty, arg_val);
     }
@@ -2199,7 +2175,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
     }
 
     const result_value = result_value: {
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
+        if (!ret_ty.hasRuntimeBits(zcu) and !ret_ty.isError(zcu)) {
             break :result_value .none;
         } else if (first_param_sret) {
             break :result_value sret;
@@ -2320,12 +2296,12 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr
     const zcu = pt.zcu;
     const abi_size = ty.abiSize(zcu);
 
-    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
+    if (!ty.hasRuntimeBits(zcu)) return;
 
     switch (ty.zigTypeTag(zcu)) {
         .error_union => {
             const pl_ty = ty.errorUnionPayload(zcu);
-            if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!pl_ty.hasRuntimeBits(zcu)) {
                 return cg.store(lhs, rhs, Type.anyerror, offset);
             }
 
@@ -2338,7 +2314,7 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr
                 return cg.store(lhs, rhs, Type.usize, offset);
             }
             const pl_ty = ty.optionalChild(zcu);
-            if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!pl_ty.hasRuntimeBits(zcu)) {
                 return cg.store(lhs, rhs, Type.u8, offset);
             }
             if (pl_ty.zigTypeTag(zcu) == .error_set) {
@@ -2438,7 +2414,7 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ptr_ty = cg.typeOf(ty_op.operand);
     const ptr_info = ptr_ty.ptrInfo(zcu);
 
-    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});
+    if (!ty.hasRuntimeBits(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});
 
     const result = result: {
         if (isByRef(ty, zcu, cg.target)) {
@@ -3089,7 +3065,7 @@ fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerErro
     return switch (ptr.base_addr) {
         .nav => |nav| return .{ .nav_ref = .{ .nav_index = nav, .offset = @intCast(offset) } },
         .uav => |uav| return .{ .uav_ref = .{ .ip_index = uav.val, .offset = @intCast(offset), .orig_ptr_ty = uav.orig_ty } },
-        .int => return cg.lowerConstant(try pt.intValue(Type.usize, offset), Type.usize),
+        .int => return cg.lowerConstant(try pt.intValue(.usize, offset)),
         .eu_payload => |eu_ptr| try cg.lowerPtr(
             eu_ptr,
             offset + codegen.errUnionPayloadOffset(
@@ -3126,10 +3102,11 @@ fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerErro
     };
 }
 
-/// Asserts that `isByRef` returns `false` for `ty`.
-fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
+/// Asserts that `isByRef` returns `false` for `val.typeOf(zcu)`.
+fn lowerConstant(cg: *CodeGen, val: Value) InnerError!WValue {
     const pt = cg.pt;
     const zcu = pt.zcu;
+    const ty = val.typeOf(zcu);
     assert(!isByRef(ty, zcu, cg.target));
     const ip = &zcu.intern_pool;
     if (val.isUndef(zcu)) return cg.emitUndefined(ty);
@@ -3191,31 +3168,22 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
         },
         .error_union => |error_union| {
             const err_int_ty = try pt.errorIntType();
-            const err_ty, const err_val = switch (error_union.val) {
-                .err_name => |err_name| .{
-                    ty.errorUnionSet(zcu),
-                    Value.fromInterned(try pt.intern(.{ .err = .{
-                        .ty = ty.errorUnionSet(zcu).toIntern(),
-                        .name = err_name,
-                    } })),
-                },
-                .payload => .{
-                    err_int_ty,
-                    try pt.intValue(err_int_ty, 0),
-                },
+            const err_val: Value = switch (error_union.val) {
+                .err_name => |err_name| .fromInterned(try pt.intern(.{ .err = .{
+                    .ty = ty.errorUnionSet(zcu).toIntern(),
+                    .name = err_name,
+                } })),
+                .payload => try pt.intValue(err_int_ty, 0),
             };
             const payload_type = ty.errorUnionPayload(zcu);
-            if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+            if (!payload_type.hasRuntimeBits(zcu)) {
                 // We use the error type directly as the type.
-                return cg.lowerConstant(err_val, err_ty);
+                return cg.lowerConstant(err_val);
             }
 
             return cg.fail("Wasm TODO: lowerConstant error union with non-zero-bit payload type", .{});
         },
-        .enum_tag => |enum_tag| {
-            const int_tag_ty = ip.typeOf(enum_tag.int);
-            return cg.lowerConstant(Value.fromInterned(enum_tag.int), Type.fromInterned(int_tag_ty));
-        },
+        .enum_tag => |enum_tag| return cg.lowerConstant(.fromInterned(enum_tag.int)),
         .float => |float| switch (float.storage) {
             .f16 => |f16_val| return .{ .imm32 = @as(u16, @bitCast(f16_val)) },
             .f32 => |f32_val| return .{ .float32 = f32_val },
@@ -3225,9 +3193,8 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
         .slice => unreachable, // isByRef == true
         .ptr => return cg.lowerPtr(val.toIntern(), 0),
         .opt => if (ty.optionalReprIsPayload(zcu)) {
-            const pl_ty = ty.optionalChild(zcu);
             if (val.optionalValue(zcu)) |payload| {
-                return cg.lowerConstant(payload, pl_ty);
+                return cg.lowerConstant(payload);
             } else {
                 return .{ .imm32 = 0 };
             }
@@ -3242,33 +3209,11 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
                 val.writeToMemory(pt, &buf) catch unreachable;
                 return cg.storeSimdImmd(buf);
             },
-            .struct_type => {
-                const struct_type = ip.loadStructType(ty.toIntern());
-                // non-packed structs are not handled in this function because they
-                // are by-ref types.
-                assert(struct_type.layout == .@"packed");
-                var buf: [8]u8 = .{0} ** 8; // zero the buffer so we do not read 0xaa as integer
-                val.writeToPackedMemory(pt, &buf, 0) catch unreachable;
-                const backing_int_ty = Type.fromInterned(struct_type.backingIntTypeUnordered(ip));
-                const int_val = try pt.intValue(
-                    backing_int_ty,
-                    mem.readInt(u64, &buf, .little),
-                );
-                return cg.lowerConstant(int_val, backing_int_ty);
-            },
+            .struct_type => unreachable, // packed structs use `bitpack`
             else => unreachable,
         },
-        .un => {
-            const int_type = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
-
-            var buf: [8]u8 = .{0} ** 8; // zero the buffer so we do not read 0xaa as integer
-            val.writeToPackedMemory(pt, &buf, 0) catch unreachable;
-            const int_val = try pt.intValue(
-                int_type,
-                mem.readInt(u64, &buf, .little),
-            );
-            return cg.lowerConstant(int_val, int_type);
-        },
+        .un => unreachable, // packed unions use `bitpack`
+        .bitpack => |bitpack| return cg.lowerConstant(.fromInterned(bitpack.backing_int_val)),
         .memoized_call => unreachable,
     }
 }
@@ -3283,7 +3228,6 @@ fn storeSimdImmd(cg: *CodeGen, value: [16]u8) !WValue {
 
 fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue {
     const zcu = cg.pt.zcu;
-    const ip = &zcu.intern_pool;
     switch (ty.zigTypeTag(zcu)) {
         .bool, .error_set => return .{ .imm32 = 0xaaaaaaaa },
         .int, .@"enum" => switch (ty.intInfo(zcu).bits) {
@@ -3311,17 +3255,9 @@ fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue {
         .error_union => {
             return .{ .imm32 = 0xaaaaaaaa };
         },
-        .@"struct" => {
-            const packed_struct = zcu.typeToPackedStruct(ty).?;
-            return cg.emitUndefined(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)));
-        },
-        .@"union" => switch (ty.containerLayout(zcu)) {
-            .@"packed" => switch (ty.bitSize(zcu)) {
-                0...32 => return .{ .imm32 = 0xaaaaaaaa },
-                33...64 => return .{ .imm64 = 0xaaaaaaaaaaaaaaaa },
-                else => unreachable,
-            },
-            else => unreachable,
+        .@"struct", .@"union" => {
+            const backing_int_ty = ty.bitpackBackingInt(zcu);
+            return cg.emitUndefined(backing_int_ty);
         },
         else => return cg.fail("Wasm TODO: emitUndefined for type: {t}\n", .{ty.zigTypeTag(zcu)}),
     }
@@ -3335,7 +3271,7 @@ fn airBlock(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, block_ty: Type, body: []const Air.Inst.Index) InnerError!void {
     const zcu = cg.pt.zcu;
     // if wasm_block_ty is non-empty, we create a register to store the temporary value
-    const block_result: WValue = if (block_ty.hasRuntimeBitsIgnoreComptime(zcu))
+    const block_result: WValue = if (block_ty.hasRuntimeBits(zcu))
         try cg.allocLocal(block_ty)
     else
         .none;
@@ -3449,7 +3385,7 @@ fn cmp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOpe
     const zcu = cg.pt.zcu;
     if (ty.zigTypeTag(zcu) == .optional and !ty.optionalReprIsPayload(zcu)) {
         const payload_ty = ty.optionalChild(zcu);
-        if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (payload_ty.hasRuntimeBits(zcu)) {
             // When we hit this case, we must check the value of optionals
             // that are not pointers. This means first checking against non-null for
             // both lhs and rhs, as well as checking the payload are matching of lhs and rhs
@@ -3792,7 +3728,6 @@ fn structFieldPtr(
 fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = cg.pt;
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
     const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
 
@@ -3800,14 +3735,14 @@ fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const operand = try cg.resolveInst(struct_field.struct_operand);
     const field_index = struct_field.field_index;
     const field_ty = struct_ty.fieldType(field_index, zcu);
-    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return cg.finishAir(inst, .none, &.{struct_field.struct_operand});
+    if (!field_ty.hasRuntimeBits(zcu)) return cg.finishAir(inst, .none, &.{struct_field.struct_operand});
 
     const result: WValue = switch (struct_ty.containerLayout(zcu)) {
         .@"packed" => switch (struct_ty.zigTypeTag(zcu)) {
             .@"struct" => result: {
                 const packed_struct = zcu.typeToPackedStruct(struct_ty).?;
                 const offset = zcu.structPackedFieldBitOffset(packed_struct, field_index);
-                const backing_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
+                const backing_ty = Type.fromInterned(packed_struct.packed_backing_int_type);
                 const host_bits = backing_ty.intInfo(zcu).bits;
 
                 const const_wvalue: WValue = if (33 <= host_bits and host_bits <= 64)
@@ -3885,7 +3820,7 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index, is_dispatch_loop: bool) Inner
     const switch_br = cg.air.unwrapSwitch(inst);
     const target_ty = cg.typeOf(switch_br.operand);
 
-    assert(target_ty.hasRuntimeBitsIgnoreComptime(zcu));
+    assert(target_ty.hasRuntimeBits(zcu));
 
     // swap target value with placeholder local, for dispatching
     const target = if (is_dispatch_loop) target: {
@@ -4119,7 +4054,7 @@ fn airIsErr(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind
         }
 
         try cg.emitWValue(operand);
-        if (op_kind == .ptr or pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (op_kind == .ptr or pl_ty.hasRuntimeBits(zcu)) {
             try cg.addMemArg(.i32_load16_u, .{
                 .offset = operand.offset() + @as(u32, @intCast(errUnionErrorOffset(pl_ty, zcu))),
                 .alignment = @intCast(Type.anyerror.abiAlignment(zcu).toByteUnits().?),
@@ -4146,7 +4081,7 @@ fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
     const payload_ty = eu_ty.errorUnionPayload(zcu);
 
     const result: WValue = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             if (op_is_ptr) {
                 break :result cg.reuseOperand(ty_op.operand, operand);
             } else {
@@ -4166,7 +4101,7 @@ fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
 }
 
 /// E!T -> E op_is_ptr == false
-/// *(E!T) -> E op_is_prt == true
+/// *(E!T) -> E op_is_ptr == true
 /// NOTE: op_is_ptr will not change return type
 fn airUnwrapErrUnionError(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void {
     const zcu = cg.pt.zcu;
@@ -4186,7 +4121,7 @@ fn airUnwrapErrUnionError(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) I
         if (op_is_ptr or isByRef(eu_ty, zcu, cg.target)) {
             break :result try cg.load(operand, Type.anyerror, err_offset);
         } else {
-            assert(!payload_ty.hasRuntimeBitsIgnoreComptime(zcu));
+            assert(!payload_ty.hasRuntimeBits(zcu));
             break :result cg.reuseOperand(ty_op.operand, operand);
         }
     };
@@ -4202,7 +4137,7 @@ fn airWrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 
     const pl_ty = cg.typeOf(ty_op.operand);
     const result = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!pl_ty.hasRuntimeBits(zcu)) {
             break :result cg.reuseOperand(ty_op.operand, operand);
         }
 
@@ -4232,7 +4167,7 @@ fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pl_ty = err_ty.errorUnionPayload(zcu);
 
     const result = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!pl_ty.hasRuntimeBits(zcu)) {
             break :result cg.reuseOperand(ty_op.operand, operand);
         }
 
@@ -4348,7 +4283,7 @@ fn isNull(cg: *CodeGen, operand: WValue, optional_ty: Type, opcode: std.wasm.Opc
     if (!optional_ty.optionalReprIsPayload(zcu)) {
         // When payload is zero-bits, we can treat operand as a value, rather than
         // a pointer to the stack value
-        if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (payload_ty.hasRuntimeBits(zcu)) {
             const offset = std.math.cast(u32, payload_ty.abiSize(zcu)) orelse {
                 return cg.fail("Optional type {f} too big to fit into stack frame", .{optional_ty.fmt(pt)});
             };
@@ -4373,7 +4308,7 @@ fn airOptionalPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const opt_ty = cg.typeOf(ty_op.operand);
     const payload_ty = cg.typeOfIndex(inst);
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!payload_ty.hasRuntimeBits(zcu)) {
         return cg.finishAir(inst, .none, &.{ty_op.operand});
     }
 
@@ -4398,7 +4333,7 @@ fn airOptionalPayloadPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 
     const result = result: {
         const payload_ty = opt_ty.optionalChild(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu) or opt_ty.optionalReprIsPayload(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu) or opt_ty.optionalReprIsPayload(zcu)) {
             break :result cg.reuseOperand(ty_op.operand, operand);
         }
 
@@ -4438,7 +4373,7 @@ fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const zcu = pt.zcu;
 
     const result = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             const non_null_bit = try cg.allocStack(Type.u1);
             try cg.emitWValue(non_null_bit);
             try cg.addImm32(1);
@@ -4606,7 +4541,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const slice_local = try cg.allocStack(slice_ty);
 
     // store the array ptr in the slice
-    if (array_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (array_ty.hasRuntimeBits(zcu)) {
         try cg.store(slice_local, operand, Type.usize, 0);
     }
 
@@ -5105,7 +5040,7 @@ fn airShuffleOne(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try cg.emitWValue(dest_alloc);
         const elem_val = switch (mask_elem.unwrap()) {
             .elem => |idx| try cg.load(operand, elem_ty, @intCast(elem_size * idx)),
-            .value => |val| try cg.lowerConstant(.fromInterned(val), elem_ty),
+            .value => |val| try cg.lowerConstant(.fromInterned(val)),
         };
         try cg.store(.stack, elem_val, elem_ty, @intCast(dest_alloc.offset() + elem_size * out_idx));
     }
@@ -5246,7 +5181,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     }
                     const packed_struct = zcu.typeToPackedStruct(result_ty).?;
                     const field_types = packed_struct.field_types;
-                    const backing_type = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
+                    const backing_type = Type.fromInterned(packed_struct.packed_backing_int_type);
 
                     // ensure the result is zero'd
                     const result = try cg.allocLocal(backing_type);
@@ -5259,7 +5194,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     var current_bit: u16 = 0;
                     for (elements, 0..) |elem, elem_index| {
                         const field_ty = Type.fromInterned(field_types.get(ip)[elem_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+                        if (!field_ty.hasRuntimeBits(zcu)) continue;
 
                         const shift_val: WValue = if (backing_type.bitSize(zcu) <= 32)
                             .{ .imm32 = current_bit }
@@ -5332,13 +5267,13 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         const layout = union_ty.unionGetLayout(zcu);
         const union_obj = zcu.typeToUnion(union_ty).?;
         const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
-        const field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
+        const field_name = ip.loadEnumType(union_obj.enum_tag_type).field_names.get(ip)[extra.field_index];
 
         const tag_int = blk: {
-            const tag_ty = union_ty.unionTagTypeRuntime(zcu).?;
+            const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
             const enum_field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
             const tag_val = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
-            break :blk try cg.lowerConstant(tag_val, tag_ty);
+            break :blk try cg.lowerConstant(tag_val);
         };
         if (layout.payload_size == 0) {
             if (layout.tag_size == 0) {
@@ -5360,7 +5295,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 }
 
                 if (layout.tag_size > 0) {
-                    try cg.store(result_ptr, tag_int, Type.fromInterned(union_obj.enum_tag_ty), 0);
+                    try cg.store(result_ptr, tag_int, .fromInterned(union_obj.enum_tag_type), 0);
                 }
             } else {
                 try cg.store(result_ptr, payload, field_ty, 0);
@@ -5368,7 +5303,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     try cg.store(
                         result_ptr,
                         tag_int,
-                        Type.fromInterned(union_obj.enum_tag_ty),
+                        .fromInterned(union_obj.enum_tag_type),
                         @intCast(layout.payload_size),
                     );
                 }
@@ -5415,7 +5350,7 @@ fn airWasmMemoryGrow(cg: *CodeGen, inst: Air.Inst.Index) !void {
 
 fn cmpOptionals(cg: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
     const zcu = cg.pt.zcu;
-    assert(operand_ty.hasRuntimeBitsIgnoreComptime(zcu));
+    assert(operand_ty.hasRuntimeBits(zcu));
     assert(op == .eq or op == .neq);
     const payload_ty = operand_ty.optionalChild(zcu);
     assert(!isByRef(payload_ty, zcu, cg.target));
@@ -5669,7 +5604,7 @@ fn airErrUnionPayloadPtrSet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void
     );
 
     const result = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             break :result cg.reuseOperand(ty_op.operand, operand);
         }
 
@@ -6458,7 +6393,7 @@ fn lowerTry(
     const zcu = cg.pt.zcu;
 
     const pl_ty = err_union_ty.errorUnionPayload(zcu);
-    const pl_has_bits = pl_ty.hasRuntimeBitsIgnoreComptime(zcu);
+    const pl_has_bits = pl_ty.hasRuntimeBits(zcu);
 
     if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
         // Block we can jump out of when error is not set
@@ -7096,13 +7031,13 @@ fn callIntrinsic(
     // Lower all arguments to the stack before we call our function
     for (args, 0..) |arg, arg_i| {
         assert(!(want_sret_param and arg == .stack));
-        assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBitsIgnoreComptime(zcu));
+        assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBits(zcu));
         try cg.lowerArg(.{ .wasm_mvp = .{} }, Type.fromInterned(param_types[arg_i]), arg);
     }
 
     try cg.addInst(.{ .tag = .call_intrinsic, .data = .{ .intrinsic = intrinsic } });
 
-    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+    if (!return_type.hasRuntimeBits(zcu)) {
         return .none;
     } else if (want_sret_param) {
         return sret;
diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig
index 8f0f8019493d82a4eec9718e0f95344b48bf1d48..df9dc381ab025711c7086515e71af1c3303251ca 100644
--- a/src/link/MachO/Atom.zig
+++ b/src/link/MachO/Atom.zig
@@ -561,7 +561,7 @@ fn reportUndefSymbol(self: Atom, rel: Relocation, macho_file: *MachO) !bool {
         defer macho_file.undefs_mutex.unlock(io);
         const gop = try macho_file.undefs.getOrPut(gpa, file.getGlobals()[rel.target]);
         if (!gop.found_existing) {
-            gop.value_ptr.* = .{ .refs = .{} };
+            gop.value_ptr.* = .{ .refs = .empty };
         }
         try gop.value_ptr.refs.append(gpa, .{ .index = self.atom_index, .file = self.file });
         return true;
diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig
index b17dc099077f15af9be3f6913419b0a4507eb7d9..5d71e46eaaf90e3d3b34c2a81db173dddc1ccdb2 100644
--- a/src/link/MachO/ZigObject.zig
+++ b/src/link/MachO/ZigObject.zig
@@ -150,7 +150,7 @@ fn newAtom(self: *ZigObject, allocator: Allocator, name: MachO.String, macho_fil
     atom.name = name;
 
     const relocs_index = @as(u32, @intCast(self.relocs.items.len));
-    self.relocs.addOneAssumeCapacity().* = .{};
+    self.relocs.addOneAssumeCapacity().* = .empty;
     atom.addExtra(.{ .rel_index = relocs_index, .rel_count = 0 }, macho_file);
 
     return index;
diff --git a/src/link/MachO/file.zig b/src/link/MachO/file.zig
index cd687a4941b2e73915a7daafe31b8d996cee37a5..4f6f70debeef007b915bfeb07d5317b87fffabc2 100644
--- a/src/link/MachO/file.zig
+++ b/src/link/MachO/file.zig
@@ -258,7 +258,7 @@ pub const File = union(enum) {
 
             const gop = try macho_file.dupes.getOrPut(gpa, file.getGlobals()[i]);
             if (!gop.found_existing) {
-                gop.value_ptr.* = .{};
+                gop.value_ptr.* = .empty;
             }
             try gop.value_ptr.append(gpa, file.getIndex());
         }
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index a9e7f35c2118d313cdcd40d99a4dd6aa1141cea5..1975ad9ba9dc15477e3510377701e5666539bec6 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -4226,7 +4226,7 @@ fn convertZcuFnType(
 
     if (CodeGen.firstParamSRet(cc, return_type, zcu, target)) {
         try params_buffer.append(gpa, .i32); // memory address is always a 32-bit handle
-    } else if (return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
+    } else if (return_type.hasRuntimeBits(zcu)) {
         if (cc == .wasm_mvp) {
             switch (abi.classifyType(return_type, zcu)) {
                 .direct => |scalar_ty| {
@@ -4245,7 +4245,7 @@ fn convertZcuFnType(
     // param types
     for (params) |param_type_ip| {
         const param_type = Zcu.Type.fromInterned(param_type_ip);
-        if (!param_type.hasRuntimeBitsIgnoreComptime(zcu)) continue;
+        if (!param_type.hasRuntimeBits(zcu)) continue;
 
         switch (cc) {
             .wasm_mvp => {
diff --git a/src/link/Wasm/Flush.zig b/src/link/Wasm/Flush.zig
index 8197d35b724f6278d0edf4a719319fadd3cda270..5d19f5b159badbaaab884523b875996547df76ad 100644
--- a/src/link/Wasm/Flush.zig
+++ b/src/link/Wasm/Flush.zig
@@ -154,7 +154,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void {
                         .type_index = try wasm.internFunctionType(.auto, &.{int_tag_ty.ip_index}, .slice_const_u8_sentinel_0, target),
                         .table_index = @intCast(wasm.tag_name_offs.items.len),
                     } };
-                    const tag_names = ip.loadEnumType(data.ip_index).names;
+                    const tag_names = ip.loadEnumType(data.ip_index).field_names;
                     for (tag_names.get(ip)) |tag_name| {
                         const slice = tag_name.toSlice(ip);
                         try wasm.tag_name_offs.append(gpa, @intCast(wasm.tag_name_bytes.items.len));
@@ -1869,7 +1869,7 @@ fn emitTagNameFunction(
     const zcu = comp.zcu.?;
     const ip = &zcu.intern_pool;
     const enum_type = ip.loadEnumType(enum_type_ip);
-    const tag_values = enum_type.values.get(ip);
+    const tag_values = enum_type.field_values.get(ip);
 
     const slice_abi_size = 8;
     const encoded_alignment = @ctz(@as(u32, 4));
@@ -1908,7 +1908,7 @@ fn emitTagNameFunction(
         return;
     }
 
-    const int_info = Zcu.Type.intInfo(.fromInterned(enum_type.tag_ty), zcu);
+    const int_info = Zcu.Type.intInfo(.fromInterned(enum_type.int_tag_type), zcu);
     const outer_block_type: std.wasm.BlockType = switch (int_info.bits) {
         0...32 => .i32,
         33...64 => .i64,
diff --git a/src/link/tapi/parse.zig b/src/link/tapi/parse.zig
index 4483d359eb002e95823a4d6e1ecd64fefddfc0ec..487b609bcab3bd93fa38a2fa25026ebfc93cff85 100644
--- a/src/link/tapi/parse.zig
+++ b/src/link/tapi/parse.zig
@@ -530,7 +530,7 @@ const Parser = struct {
     fn leaf_value(self: *Parser) ParseError!*Node {
         const node = try self.allocator.create(Node.Value);
         errdefer self.allocator.destroy(node);
-        node.* = .{ .string_value = .{} };
+        node.* = .{ .string_value = .empty };
         node.base.tree = self.tree;
         node.base.start = self.token_it.pos;
         errdefer node.string_value.deinit(self.allocator);
-- 
2.54.0


From 986a4f1445e3ed1a6227a24d78b2154239ccdb31 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 12 Feb 2026 20:37:28 +0000
Subject: [PATCH 457/499] Sema: fix illegal comparison to undefined

---
 src/Sema.zig | 52 ++++++++++++++++++++++++----------------------------
 1 file changed, 24 insertions(+), 28 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index f1f2d895165a9408b06b2672dadfb52000d81ff1..ccb6f31aae4872cdcc3c86d9a1641292913cc0af 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -10374,7 +10374,7 @@ fn analyzeSwitchBlock(
                     assert(case.range_infos.len == 0);
                     for (case.item_infos, item_refs) |item_info, item_ref| {
                         if (item_info.bodyLen()) |body_len| extra_index += body_len;
-                        if (sema.wantSwitchProngBodyAnalysis(block, item_ref, operand_ty, false, true, prong_info.is_comptime_unreach)) {
+                        if (sema.wantSwitchProngBodyAnalysis(item_ref, operand_ty, false, true, prong_info.is_comptime_unreach)) {
                             break :skip_case;
                         }
                     }
@@ -10390,7 +10390,7 @@ fn analyzeSwitchBlock(
             unreachable; // malformed validated switch
         };
 
-        const analyze_body = sema.wantSwitchProngBodyAnalysis(block, .fromValue(item_opv), operand_ty, union_originally, err_set, false);
+        const analyze_body = sema.wantSwitchProngBodyAnalysis(.fromValue(item_opv), operand_ty, union_originally, err_set, false);
         if (!analyze_body) return .unreachable_value;
 
         if (!(err_set and
@@ -10648,7 +10648,7 @@ fn finishSwitchBr(
             if (item_ref == .none) is_under_prong = true;
             if (item_info.bodyLen()) |body_len| extra_index += body_len;
 
-            const analyze_body = sema.wantSwitchProngBodyAnalysis(block, item_ref, operand_ty, union_originally, err_set, prong_info.is_comptime_unreach);
+            const analyze_body = sema.wantSwitchProngBodyAnalysis(item_ref, operand_ty, union_originally, err_set, prong_info.is_comptime_unreach);
             if (analyze_body) any_analyze_body = true;
 
             if (prong_info.is_inline) {
@@ -10708,8 +10708,8 @@ fn finishSwitchBr(
             any_analyze_body = true; // always an integer range, always needs analysis
 
             if (prong_info.is_inline) {
-                var item = sema.resolveConstDefinedValue(block, .unneeded, range_ref[0], undefined) catch unreachable;
-                const item_last = sema.resolveConstDefinedValue(block, .unneeded, range_ref[1], undefined) catch unreachable;
+                var item = sema.resolveValue(range_ref[0]).?;
+                const item_last = sema.resolveValue(range_ref[1]).?;
 
                 if (item.getUnsignedInt(zcu)) |first_int| {
                     if (item_last.getUnsignedInt(zcu)) |last_int| {
@@ -10887,7 +10887,7 @@ fn finishSwitchBr(
 
                 const item_ref: Air.Inst.Ref = .fromValue(item_val);
 
-                const analyze_body = sema.wantSwitchProngBodyAnalysis(block, item_ref, operand_ty, union_originally, err_set, false);
+                const analyze_body = sema.wantSwitchProngBodyAnalysis(item_ref, operand_ty, union_originally, err_set, false);
 
                 if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src);
                 emit_bb = true;
@@ -11820,7 +11820,7 @@ fn resolveSwitchBlock(
                 };
                 continue;
             }
-            const item_val = sema.resolveConstDefinedValue(child_block, .unneeded, item_ref, undefined) catch unreachable;
+            const item_val = sema.resolveValue(item_ref).?;
             if (cond_val.eql(item_val, item_ty, zcu)) {
                 if (err_set) try sema.maybeErrorUnwrapComptime(child_block, prong_body, cond_ref);
                 if (union_originally and operand_ty.unionFieldType(item_val, zcu).?.isNoReturn(zcu)) {
@@ -11853,8 +11853,8 @@ fn resolveSwitchBlock(
             }
         }
         for (range_refs) |range_ref| {
-            const first_val = sema.resolveConstDefinedValue(child_block, .unneeded, range_ref[0], undefined) catch unreachable;
-            const last_val = sema.resolveConstDefinedValue(child_block, .unneeded, range_ref[1], undefined) catch unreachable;
+            const first_val = sema.resolveValue(range_ref[0]).?;
+            const last_val = sema.resolveValue(range_ref[1]).?;
             if ((try sema.compareAll(cond_val, .gte, first_val, item_ty)) and
                 (try sema.compareAll(cond_val, .lte, last_val, item_ty)))
             {
@@ -12063,7 +12063,6 @@ fn resolveSwitchProng(
 
 fn wantSwitchProngBodyAnalysis(
     sema: *Sema,
-    block: *Block,
     item_ref: Air.Inst.Ref,
     operand_ty: Type,
     union_originally: bool,
@@ -12072,12 +12071,12 @@ fn wantSwitchProngBodyAnalysis(
 ) bool {
     const zcu = sema.pt.zcu;
     if (union_originally) {
-        const item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
+        const item_val = sema.resolveValue(item_ref).?;
         const field_ty = operand_ty.unionFieldType(item_val, zcu).?;
         if (field_ty.isNoReturn(zcu)) return false;
     }
     if (err_set and prong_is_comptime_unreach) {
-        const item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable;
+        const item_val = sema.resolveValue(item_ref).?;
         const err_name = item_val.getErrorName(zcu).unwrap().?;
         if (!operand_ty.errorSetHasField(err_name, zcu)) return false;
     }
@@ -12252,7 +12251,7 @@ fn analyzeSwitchPayloadCapture(
     const switch_node_offset = operand_src.offset.node_offset_switch_operand;
 
     if (kind == .inline_ref) {
-        const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, kind.inline_ref, undefined) catch unreachable;
+        const item_val = sema.resolveValue(kind.inline_ref).?;
         if (operand_ty.zigTypeTag(zcu) == .@"union") {
             const field_index: u32 = @intCast(operand_ty.unionTagFieldIndex(item_val, zcu).?);
             const union_obj = zcu.typeToUnion(operand_ty).?;
@@ -12303,14 +12302,14 @@ fn analyzeSwitchPayloadCapture(
             const case_vals = kind.item_refs;
 
             const union_obj = zcu.typeToUnion(operand_ty).?;
-            const first_item_val = sema.resolveConstDefinedValue(case_block, .unneeded, case_vals[0], undefined) catch unreachable;
+            const first_item_val = sema.resolveValue(case_vals[0]).?;
 
             const first_field_index: u32 = zcu.unionTagFieldIndex(union_obj, first_item_val).?;
             const first_field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[first_field_index]);
 
             const field_indices = try sema.arena.alloc(u32, case_vals.len);
             for (case_vals, field_indices) |item, *field_idx| {
-                const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, item, undefined) catch unreachable;
+                const item_val = sema.resolveValue(item).?;
                 field_idx.* = zcu.unionTagFieldIndex(union_obj, item_val).?;
             }
 
@@ -12592,7 +12591,7 @@ fn analyzeSwitchPayloadCapture(
 
             const case_vals = kind.item_refs;
             if (case_vals.len == 1) {
-                const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, case_vals[0], undefined) catch unreachable;
+                const item_val = sema.resolveValue(case_vals[0]).?;
                 const item_ty = try pt.singleErrorSetType(item_val.getErrorName(zcu).unwrap().?);
                 return sema.bitCast(case_block, item_ty, .fromValue(item_val), operand_src, null);
             }
@@ -12600,7 +12599,7 @@ fn analyzeSwitchPayloadCapture(
             var names: InferredErrorSet.NameMap = .{};
             try names.ensureUnusedCapacity(sema.arena, case_vals.len);
             for (case_vals) |err| {
-                const err_val = sema.resolveConstDefinedValue(case_block, .unneeded, err, undefined) catch unreachable;
+                const err_val = sema.resolveValue(err).?;
                 names.putAssumeCapacityNoClobber(err_val.getErrorName(zcu).unwrap().?, {});
             }
             const error_ty = try pt.errorSetFromUnsortedNames(names.keys());
@@ -13731,26 +13730,24 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const lhs_elem_i = elem_i;
                 const elem_default_val: ?Value = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, zcu) else null;
                 const elem_val = elem_default_val orelse try lhs_sub_val.elemValue(pt, lhs_elem_i);
-                const elem_val_inst = Air.internedToRef(elem_val.toIntern());
                 const operand_src = block.src(.{ .array_cat_lhs = .{
                     .array_cat_offset = inst_data.src_node,
                     .elem_index = elem_i,
                 } });
-                const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, operand_src);
-                const coerced_elem_val = try sema.resolveConstValue(block, operand_src, coerced_elem_val_inst, undefined);
+                const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, .fromValue(elem_val), operand_src);
+                const coerced_elem_val = sema.resolveValue(coerced_elem_val_inst).?;
                 element_vals[elem_i] = coerced_elem_val.toIntern();
             }
             while (elem_i < result_len) : (elem_i += 1) {
                 const rhs_elem_i = elem_i - lhs_len;
                 const elem_default_val: ?Value = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, zcu) else null;
                 const elem_val = elem_default_val orelse try rhs_sub_val.elemValue(pt, rhs_elem_i);
-                const elem_val_inst = Air.internedToRef(elem_val.toIntern());
                 const operand_src = block.src(.{ .array_cat_rhs = .{
                     .array_cat_offset = inst_data.src_node,
                     .elem_index = @intCast(rhs_elem_i),
                 } });
-                const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, operand_src);
-                const coerced_elem_val = try sema.resolveConstValue(block, operand_src, coerced_elem_val_inst, undefined);
+                const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, .fromValue(elem_val), operand_src);
+                const coerced_elem_val = sema.resolveValue(coerced_elem_val_inst).?;
                 element_vals[elem_i] = coerced_elem_val.toIntern();
             }
             return sema.addConstantMaybeRef(
@@ -25886,7 +25883,6 @@ fn fieldPtr(
             }
         },
         .type => {
-            _ = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, object_ptr, undefined);
             const result = try sema.analyzeLoad(block, src, object_ptr, object_ptr_src);
             const inner = if (is_pointer_to)
                 try sema.analyzeLoad(block, src, result, object_ptr_src)
@@ -27361,7 +27357,7 @@ fn coerceExtra(
 
             // Function body to function pointer.
             if (inst_ty.zigTypeTag(zcu) == .@"fn") {
-                const fn_val = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, inst, undefined);
+                const fn_val = sema.resolveValue(inst).?;
                 const fn_nav = switch (zcu.intern_pool.indexToKey(fn_val.toIntern())) {
                     .func => |f| f.owner_nav,
                     .@"extern" => |e| e.owner_nav,
@@ -27667,7 +27663,7 @@ fn coerceExtra(
         },
         .float, .comptime_float => switch (inst_ty.zigTypeTag(zcu)) {
             .comptime_float => {
-                const val = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, inst, undefined);
+                const val = sema.resolveValue(inst).?;
                 const result_val = try val.floatCast(dest_ty, pt);
                 return Air.internedToRef(result_val.toIntern());
             },
@@ -27753,7 +27749,7 @@ fn coerceExtra(
         .@"enum" => switch (inst_ty.zigTypeTag(zcu)) {
             .enum_literal => {
                 // enum literal to enum
-                const val = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, inst, undefined);
+                const val = sema.resolveValue(inst).?;
                 const string = zcu.intern_pool.indexToKey(val.toIntern()).enum_literal;
                 const field_index = dest_ty.enumFieldIndex(string, zcu) orelse {
                     return sema.fail(block, inst_src, "no field named '{f}' in enum '{f}'", .{
@@ -28965,7 +28961,7 @@ fn coerceVarArgParam(
             .{},
         ),
         .@"fn" => fn_ptr: {
-            const fn_val = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, inst, undefined);
+            const fn_val = sema.resolveValue(inst).?;
             const fn_nav = zcu.funcInfo(fn_val.toIntern()).owner_nav;
             break :fn_ptr try sema.analyzeNavRef(block, inst_src, fn_nav);
         },
-- 
2.54.0


From 7ca061f3d68ff936dd77a58402c817b0aa1044e6 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 12 Feb 2026 23:33:04 +0000
Subject: [PATCH 458/499] compiler: rework and simplify main loop

---
 src/Compilation.zig   | 511 ++-----------------------------------
 src/Sema.zig          |   6 +-
 src/Zcu.zig           |   2 +
 src/Zcu/PerThread.zig | 580 +++++++++++++++++++++++++++++++++---------
 4 files changed, 484 insertions(+), 615 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 66483ebd727709e21a586c354137269303b8cd3a..45d0aa6e97fbb735127efa5f1d399731d6bde4a6 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -21,7 +21,6 @@ const introspect = @import("introspect.zig");
 const link = @import("link.zig");
 const tracy = @import("tracy.zig");
 const trace = tracy.trace;
-const traceNamed = tracy.traceNamed;
 const build_options = @import("build_options");
 const LibCInstallation = std.zig.LibCInstallation;
 const glibc = @import("libs/glibc.zig");
@@ -89,6 +88,9 @@ framework_dirs: []const []const u8,
 /// These are only for DLLs dependencies fulfilled by the `.def` files shipped
 /// with Zig. Static libraries are provided as `link.Input` values.
 windows_libs: std.StringArrayHashMapUnmanaged(void),
+/// The number of items in `windows_libs` which we have already built. All items at or after this
+/// index will be built in `performAllTheWork`.
+windows_libs_num_done: u32,
 version: ?std.SemanticVersion,
 libc_installation: ?*const LibCInstallation,
 skip_linker_dependencies: bool,
@@ -126,8 +128,6 @@ oneshot_prelink_tasks: std.ArrayList(link.PrelinkTask),
 /// work is queued or not.
 queued_jobs: QueuedJobs,
 
-work_queues: [2]std.Deque(Job),
-
 /// These jobs are to invoke the Clang compiler to create an object file, which
 /// gets linked with the Compilation.
 c_object_work_queue: std.Deque(*CObject),
@@ -954,51 +954,6 @@ pub const RcSourceFile = struct {
     extra_flags: []const []const u8 = &.{},
 };
 
-const Job = union(enum) {
-    /// Given the generated AIR for a function, put it onto the code generation queue.
-    /// MLUGG TODO: because type resolution is no longer necessary, we can remove this now
-    /// If the backend does not support `Zcu.Feature.separate_thread`, codegen and linking happen immediately.
-    /// Before queueing this `Job`, increase the estimated total item count for both
-    /// `comp.zcu.?.codegen_prog_node` and `comp.link_prog_node`.
-    codegen_func: struct {
-        func: InternPool.Index,
-        /// The AIR emitted from analyzing `func`; owned by this `Job` in `gpa`.
-        air: Air,
-    },
-    /// Queue a `link.ZcuTask` to emit this non-function `Nav` into the output binary.
-    /// MLUGG TODO: because type resolution is no longer necessary, we can remove this now
-    /// If the backend does not support `Zcu.Feature.separate_thread`, the task is run immediately.
-    /// Before queueing this `Job`, increase the estimated total item count for `comp.link_prog_node`.
-    link_nav: InternPool.Nav.Index,
-    /// Before queueing this `Job`, increase the estimated total item count for `comp.link_prog_node`.
-    update_line_number: InternPool.TrackedInst.Index,
-    /// The `AnalUnit`, which is *not* a `func`, must be semantically analyzed.
-    /// This may be its first time being analyzed, or it may be outdated.
-    /// If the unit is a function, a `codegen_func` job will be queued after analysis completes.
-    /// If the unit is a *test* function, an `analyze_func` job will also be queued.
-    analyze_unit: InternPool.AnalUnit,
-    /// The main source file for the module needs to be analyzed.
-    /// For every module which is an analysis root, analyze the main struct type of the module's
-    /// root source file. This is how semantic analysis begins.
-    analyze_roots,
-
-    /// The value is the index into `windows_libs`.
-    windows_import_lib: usize,
-
-    fn stage(job: *const Job) usize {
-        // Prioritize functions so that codegen can get to work on them on a
-        // separate thread, while Sema goes back to its own work.
-        return switch (job.*) {
-            .codegen_func => 0,
-            .analyze_unit => |unit| switch (unit.unwrap()) {
-                .func => 0,
-                else => 1,
-            },
-            else => 1,
-        };
-    }
-};
-
 pub const CObject = struct {
     /// Relative to cwd. Owned by arena.
     src: CSourceFile,
@@ -2274,7 +2229,6 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             .root_mod = options.root_mod,
             .config = options.config,
             .dirs = options.dirs,
-            .work_queues = @splat(.empty),
             .c_object_work_queue = .empty,
             .win32_resource_work_queue = .empty,
             .c_source_files = options.c_source_files,
@@ -2308,6 +2262,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             .root_name = root_name,
             .sysroot = sysroot,
             .windows_libs = .empty,
+            .windows_libs_num_done = 0,
             .version = options.version,
             .libc_installation = libc_dirs.libc_installation,
             .compiler_rt_strat = compiler_rt_strat,
@@ -2670,16 +2625,6 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
                 }
             }
 
-            // Generate Windows import libs.
-            if (target.os.tag == .windows) {
-                const count = comp.windows_libs.count();
-                for (0..count) |i| {
-                    try comp.queueJob(.{ .windows_import_lib = i });
-                }
-                // when integrating coff linker with prelink, the above `queueJob` will need to move
-                // to something in `dispatchPrelinkWork`, which must queue all prelink link tasks
-                // *before* we begin working on the main job queue.
-            }
             if (comp.wantBuildLibUnwindFromSource()) {
                 comp.queued_jobs.libunwind = true;
             }
@@ -2763,7 +2708,6 @@ pub fn destroy(comp: *Compilation) void {
     if (comp.zcu) |zcu| zcu.deinit();
     comp.cache_use.deinit(io);
 
-    for (&comp.work_queues) |*work_queue| work_queue.deinit(gpa);
     comp.c_object_work_queue.deinit(gpa);
     comp.win32_resource_work_queue.deinit(gpa);
 
@@ -4563,13 +4507,7 @@ fn performAllTheWork(
     comp: *Compilation,
     main_progress_node: std.Progress.Node,
     update_arena: Allocator,
-) JobError!void {
-    defer if (comp.zcu) |zcu| {
-        zcu.codegen_task_pool.cancel(zcu);
-        // Regardless of errors, `comp.zcu` needs to update its generation number.
-        zcu.generation += 1;
-    };
-
+) (Allocator.Error || Io.Cancelable)!void {
     const io = comp.io;
 
     // This is awkward: we don't want to start the timer until later, but we won't want to stop it
@@ -4602,207 +4540,33 @@ fn performAllTheWork(
         misc_group.async(io, workerDocsWasm, .{ comp, main_progress_node });
     }
 
-    if (comp.zcu) |zcu| {
-        const tracy_trace = traceNamed(@src(), "astgen");
-        defer tracy_trace.end();
-
-        const zir_prog_node = main_progress_node.start("AST Lowering", 0);
-        defer zir_prog_node.end();
-
-        var timer = comp.startTimer();
-        defer if (timer.finish(io)) |ns| {
-            comp.mutex.lockUncancelable(io);
-            defer comp.mutex.unlock(io);
-            comp.time_report.?.stats.real_ns_files = ns;
-        };
-
-        const gpa = comp.gpa;
-
-        var astgen_group: Io.Group = .init;
-        defer astgen_group.cancel(io);
-
-        // We cannot reference `zcu.import_table` after we spawn any `workerUpdateFile` jobs,
-        // because on single-threaded targets the worker will be run eagerly, meaning the
-        // `import_table` could be mutated, and not even holding `comp.mutex` will save us. So,
-        // build up a list of the files to update *before* we spawn any jobs.
-        var astgen_work_items: std.MultiArrayList(struct {
-            file_index: Zcu.File.Index,
-            file: *Zcu.File,
-        }) = .empty;
-        defer astgen_work_items.deinit(gpa);
-        // Not every item in `import_table` will need updating, because some are builtin.zig
-        // files. However, most will, so let's just reserve sufficient capacity upfront.
-        try astgen_work_items.ensureTotalCapacity(gpa, zcu.import_table.count());
-        for (zcu.import_table.keys()) |file_index| {
-            const file = zcu.fileByIndex(file_index);
-            if (file.is_builtin) {
-                // This is a `builtin.zig`, so updating is redundant. However, we want to make
-                // sure the file contents are still correct on disk, since it can improve the
-                // debugging experience better. That job only needs `file`, so we can kick it
-                // off right now.
-                astgen_group.async(io, workerUpdateBuiltinFile, .{ comp, file });
-                continue;
-            }
-            astgen_work_items.appendAssumeCapacity(.{
-                .file_index = file_index,
-                .file = file,
-            });
-        }
-
-        // Now that we're not going to touch `zcu.import_table` again, we can spawn `workerUpdateFile` jobs.
-        for (astgen_work_items.items(.file_index), astgen_work_items.items(.file)) |file_index, file| {
-            astgen_group.async(io, workerUpdateFile, .{
-                comp, file, file_index, zir_prog_node, &astgen_group,
-            });
-        }
-
-        // On the other hand, it's fine to directly iterate `zcu.embed_table.keys()` here
-        // because `workerUpdateEmbedFile` can't invalidate it. The different here is that one
-        // `@embedFile` can't trigger analysis of a new `@embedFile`!
-        for (0.., zcu.embed_table.keys()) |ef_index_usize, ef| {
-            const ef_index: Zcu.EmbedFile.Index = @enumFromInt(ef_index_usize);
-            astgen_group.async(io, workerUpdateEmbedFile, .{
-                comp, ef_index, ef,
-            });
-        }
-
-        try astgen_group.await(io);
-    }
-
+    defer if (comp.zcu) |zcu| zcu.codegen_task_pool.cancel(zcu);
     if (comp.zcu) |zcu| {
         const pt: Zcu.PerThread = .activate(zcu, .main);
-        defer pt.deactivate();
-
-        const gpa = zcu.gpa;
-
-        // On an incremental update, a source file might become "dead", in that all imports of
-        // the file were removed. This could even change what module the file belongs to! As such,
-        // we do a traversal over the files, to figure out which ones are alive and the modules
-        // they belong to.
-        const any_fatal_files = try pt.computeAliveFiles();
-
-        // If the cache mode is `whole`, add every alive source file to the manifest.
-        switch (comp.cache_use) {
-            .whole => |whole| if (whole.cache_manifest) |man| {
-                for (zcu.alive_files.keys()) |file_index| {
-                    const file = zcu.fileByIndex(file_index);
-
-                    switch (file.status) {
-                        .never_loaded => unreachable, // AstGen tried to load it
-                        .retryable_failure => continue, // the file cannot be read; this is a guaranteed error
-                        .astgen_failure, .success => {}, // the file was read successfully
-                    }
-
-                    const path = try file.path.toAbsolute(comp.dirs, gpa);
-                    defer gpa.free(path);
-
-                    const result = res: {
-                        try whole.cache_manifest_mutex.lock(io);
-                        defer whole.cache_manifest_mutex.unlock(io);
-                        if (file.source) |source| {
-                            break :res man.addFilePostContents(path, source, file.stat);
-                        } else {
-                            break :res man.addFilePost(path);
-                        }
-                    };
-                    result catch |err| switch (err) {
-                        error.OutOfMemory => |e| return e,
-                        else => {
-                            try pt.reportRetryableFileError(file_index, "unable to update cache: {s}", .{@errorName(err)});
-                            continue;
-                        },
-                    };
-                }
-            },
-            .none, .incremental => {},
+        defer {
+            pt.deactivate();
+            // Regardless of errors, `comp.zcu` needs to update its generation number.
+            zcu.generation += 1;
         }
-
-        if (any_fatal_files or
-            zcu.multi_module_err != null or
-            zcu.failed_imports.items.len > 0 or
-            comp.alloc_failure_occurred)
-        {
-            // We give up right now! No updating of ZIR refs, no nothing. The idea is that this prevents
-            // us from invalidating lots of incremental dependencies due to files with e.g. parse errors.
-            // However, this means our analysis data is invalid, so we want to omit all analysis errors.
-            zcu.skip_analysis_this_update = true;
-            // Since we're skipping analysis, there are no ZCU link tasks.
-            comp.link_queue.finishZcuQueue(comp);
-            // Let other compilation work finish to collect as many errors as possible.
-            try misc_group.await(io);
-            comp.link_queue.wait(io);
-            return;
-        }
-
-        if (comp.time_report) |*tr| {
-            tr.stats.n_reachable_files = @intCast(zcu.alive_files.count());
-        }
-
-        if (comp.config.incremental) {
-            const update_zir_refs_node = main_progress_node.start("Update ZIR References", 0);
-            defer update_zir_refs_node.end();
-            try pt.updateZirRefs();
-        }
-        try zcu.flushRetryableFailures();
-
-        // It's analysis time! Queue up our initial analysis.
-        try comp.queueJob(.analyze_roots);
-
-        zcu.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
-        if (comp.bin_file != null) {
-            zcu.codegen_prog_node = main_progress_node.start("Code Generation", 0);
-        }
-        // We increment `pending_codegen_jobs` so that it doesn't reach 0 until after analysis finishes.
-        // That prevents the "Code Generation" node from constantly disappearing and reappearing when
-        // we're probably going to analyze more functions at some point.
-        assert(zcu.pending_codegen_jobs.swap(1, .monotonic) == 0); // don't let this become 0 until analysis finishes
-    }
-    // When analysis ends, delete the progress nodes for "Semantic Analysis" and possibly "Code Generation".
-    defer if (comp.zcu) |zcu| {
-        zcu.sema_prog_node.end();
-        zcu.sema_prog_node = .none;
-        if (zcu.pending_codegen_jobs.fetchSub(1, .monotonic) == 1) {
-            // Decremented to 0, so all done.
-            zcu.codegen_prog_node.end();
-            zcu.codegen_prog_node = .none;
-        }
-    };
-
-    if (comp.zcu) |zcu| {
-        if (!zcu.backendSupportsFeature(.separate_thread)) {
-            // Close the ZCU task queue. Prelink may still be running, but the closed
-            // queue will cause the linker task to exit once prelink finishes. The
-            // closed queue also communicates to `enqueueZcu` that it should wait for
-            // the linker task to finish and then run ZCU tasks serially.
-            comp.link_queue.finishZcuQueue(comp);
-        }
-    }
-
-    if (comp.zcu != null) {
-        // Start the timer for the "decls" part of the pipeline (Sema, CodeGen, link).
-        decl_work_timer = comp.startTimer();
-    }
-
-    work: while (true) {
-        for (&comp.work_queues) |*work_queue| if (work_queue.popFront()) |job| {
-            try processOneJob(.main, comp, job);
-            continue :work;
-        };
-        if (comp.zcu) |zcu| {
-            // If there's no work queued, check if there's anything outdated
-            // which we need to work on, and queue it if so.
-            if (try zcu.findOutdatedToAnalyze()) |outdated| {
-                try comp.queueJob(.{ .analyze_unit = outdated });
-                continue;
-            }
-            zcu.sema_prog_node.end();
-            zcu.sema_prog_node = .none;
-        }
-        break;
+        try pt.update(main_progress_node, &decl_work_timer);
     }
 
     comp.link_queue.finishZcuQueue(comp);
 
+    // This has to happen after the main semantic analysis loop because it is possible for Sema to
+    // call `addLinkLib` and hence add more items to `comp.windows_libs`.
+    for (comp.windows_libs.keys()[comp.windows_libs_num_done..]) |link_lib| {
+        mingw.buildImportLib(comp, link_lib) catch |err| {
+            // TODO Surface more error details.
+            comp.lockAndSetMiscFailure(
+                .windows_import_lib,
+                "unable to generate DLL import .lib file for {s}: {t}",
+                .{ link_lib, err },
+            );
+        };
+    }
+    comp.windows_libs_num_done = @intCast(comp.windows_libs.count());
+
     // Main thread work is all done, now just wait for all async work.
     try misc_group.await(io);
     comp.link_queue.wait(io);
@@ -5032,121 +4796,6 @@ fn dispatchPrelinkWork(comp: *Compilation, main_progress_node: std.Progress.Node
     };
 }
 
-const JobError = Allocator.Error || Io.Cancelable;
-
-pub fn queueJob(comp: *Compilation, job: Job) !void {
-    try comp.work_queues[job.stage()].pushBack(comp.gpa, job);
-}
-
-pub fn queueJobs(comp: *Compilation, jobs: []const Job) !void {
-    for (jobs) |job| try comp.queueJob(job);
-}
-
-fn processOneJob(tid: Zcu.PerThread.Id, comp: *Compilation, job: Job) JobError!void {
-    switch (job) {
-        .codegen_func => |func| {
-            const zcu = comp.zcu.?;
-            const gpa = zcu.gpa;
-            var owned_air: ?Air = func.air;
-            defer if (owned_air) |*air| air.deinit(gpa);
-
-            // Some linkers need to refer to the AIR. In that case, the linker is not running
-            // concurrently, so we'll just keep ownership of the AIR for ourselves instead of
-            // letting the codegen job destroy it.
-            const disown_air = zcu.backendSupportsFeature(.separate_thread);
-
-            // Begin the codegen task. If the codegen/link queue is backed up, this might
-            // block until the linker is able to process some tasks.
-            const codegen_task = try zcu.codegen_task_pool.start(zcu, func.func, &owned_air.?, disown_air);
-            if (disown_air) owned_air = null;
-
-            try comp.link_queue.enqueueZcu(comp, tid, .{ .link_func = codegen_task });
-        },
-        .link_nav => |nav_index| {
-            const zcu = comp.zcu.?;
-            const nav = zcu.intern_pool.getNav(nav_index);
-            if (nav.analysis != null) {
-                const unit: InternPool.AnalUnit = .wrap(.{ .nav_val = nav_index });
-                if (zcu.failed_analysis.contains(unit) or zcu.transitive_failed_analysis.contains(unit)) {
-                    comp.link_prog_node.completeOne();
-                    return;
-                }
-            }
-            assert(nav.status == .fully_resolved);
-            try comp.link_queue.enqueueZcu(comp, tid, .{ .link_nav = nav_index });
-        },
-        .update_line_number => |tracked_inst| {
-            try comp.link_queue.enqueueZcu(comp, tid, .{ .debug_update_line_number = tracked_inst });
-        },
-        .analyze_unit => |unit| {
-            const tracy_trace = traceNamed(@src(), "analyze_unit");
-            defer tracy_trace.end();
-
-            const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
-            defer pt.deactivate();
-
-            const maybe_err: Zcu.SemaError!void = switch (unit.unwrap()) {
-                .@"comptime" => |cu| pt.ensureComptimeUnitUpToDate(cu),
-                .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav, null),
-                .nav_val => |nav| pt.ensureNavValUpToDate(nav, null),
-                .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty), null),
-                .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage, null),
-                .func => |func| pt.ensureFuncBodyUpToDate(func, null),
-            };
-            maybe_err catch |err| switch (err) {
-                error.OutOfMemory => |e| return e,
-                error.Canceled => |e| return e,
-                error.AnalysisFail => return,
-            };
-
-            queue_test_analysis: {
-                if (!comp.config.is_test) break :queue_test_analysis;
-                const nav = switch (unit.unwrap()) {
-                    .nav_val => |nav| nav,
-                    else => break :queue_test_analysis,
-                };
-
-                // Check if this is a test function.
-                const ip = &pt.zcu.intern_pool;
-                if (!pt.zcu.test_functions.contains(nav)) {
-                    break :queue_test_analysis;
-                }
-
-                // Tests are always emitted in test binaries. The decl_refs are created by
-                // Zcu.populateTestFunctions, but this will not queue body analysis, so do
-                // that now.
-                try pt.zcu.ensureFuncBodyAnalysisQueued(ip.getNav(nav).status.fully_resolved.val);
-            }
-        },
-        .analyze_roots => {
-            const tracy_trace = traceNamed(@src(), "analyze_roots");
-            defer tracy_trace.end();
-
-            const zcu = comp.zcu.?;
-            const pt: Zcu.PerThread = .activate(zcu, tid);
-            defer pt.deactivate();
-            for (zcu.analysisRoots()) |analysis_root_mod| {
-                const analysis_root_file = zcu.module_roots.get(analysis_root_mod).?.unwrap().?;
-                try pt.ensureFileAnalyzed(analysis_root_file);
-            }
-        },
-        .windows_import_lib => |index| {
-            const tracy_trace = traceNamed(@src(), "windows_import_lib");
-            defer tracy_trace.end();
-
-            const link_lib = comp.windows_libs.keys()[index];
-            mingw.buildImportLib(comp, link_lib) catch |err| {
-                // TODO Surface more error details.
-                comp.lockAndSetMiscFailure(
-                    .windows_import_lib,
-                    "unable to generate DLL import .lib file for {s}: {t}",
-                    .{ link_lib, err },
-                );
-            };
-        },
-    }
-}
-
 fn createDepFile(comp: *Compilation, dep_file: []const u8, bin_file: Cache.Path) anyerror!void {
     const io = comp.io;
 
@@ -5474,112 +5123,6 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) SubU
     };
 }
 
-fn workerUpdateFile(
-    comp: *Compilation,
-    file: *Zcu.File,
-    file_index: Zcu.File.Index,
-    prog_node: std.Progress.Node,
-    group: *Io.Group,
-) void {
-    const io = comp.io;
-    const tid: Zcu.PerThread.Id = .acquire(io);
-    defer tid.release(io);
-
-    const child_prog_node = prog_node.start(fs.path.basename(file.path.sub_path), 0);
-    defer child_prog_node.end();
-
-    const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
-    defer pt.deactivate();
-    pt.updateFile(file_index, file) catch |err| {
-        pt.reportRetryableFileError(file_index, "unable to load '{s}': {s}", .{ fs.path.basename(file.path.sub_path), @errorName(err) }) catch |oom| switch (oom) {
-            error.OutOfMemory => {
-                comp.mutex.lockUncancelable(io);
-                defer comp.mutex.unlock(io);
-                comp.setAllocFailure();
-            },
-        };
-        return;
-    };
-
-    switch (file.getMode()) {
-        .zig => {}, // continue to logic below
-        .zon => return, // ZON can't import anything so we're done
-    }
-
-    // Discover all imports in the file. Imports of modules we ignore for now since we don't
-    // know which module we're in, but imports of file paths might need us to queue up other
-    // AstGen jobs.
-    const imports_index = file.zir.?.extra[@intFromEnum(Zir.ExtraIndex.imports)];
-    if (imports_index != 0) {
-        const extra = file.zir.?.extraData(Zir.Inst.Imports, imports_index);
-        var import_i: u32 = 0;
-        var extra_index = extra.end;
-
-        while (import_i < extra.data.imports_len) : (import_i += 1) {
-            const item = file.zir.?.extraData(Zir.Inst.Imports.Item, extra_index);
-            extra_index = item.end;
-
-            const import_path = file.zir.?.nullTerminatedString(item.data.name);
-
-            if (pt.discoverImport(file.path, import_path)) |res| switch (res) {
-                .module, .existing_file => {},
-                .new_file => |new| {
-                    group.async(io, workerUpdateFile, .{
-                        comp, new.file, new.index, prog_node, group,
-                    });
-                },
-            } else |err| switch (err) {
-                error.OutOfMemory => {
-                    comp.mutex.lockUncancelable(io);
-                    defer comp.mutex.unlock(io);
-                    comp.setAllocFailure();
-                },
-            }
-        }
-    }
-}
-
-fn workerUpdateBuiltinFile(comp: *Compilation, file: *Zcu.File) void {
-    Builtin.updateFileOnDisk(file, comp) catch |err| comp.lockAndSetMiscFailure(
-        .write_builtin_zig,
-        "unable to write '{f}': {s}",
-        .{ file.path.fmt(comp), @errorName(err) },
-    );
-}
-
-fn workerUpdateEmbedFile(comp: *Compilation, ef_index: Zcu.EmbedFile.Index, ef: *Zcu.EmbedFile) void {
-    const io = comp.io;
-    const tid: Zcu.PerThread.Id = .acquire(io);
-    defer tid.release(io);
-    comp.detectEmbedFileUpdate(tid, ef_index, ef) catch |err| switch (err) {
-        error.OutOfMemory => {
-            comp.mutex.lockUncancelable(io);
-            defer comp.mutex.unlock(io);
-            comp.setAllocFailure();
-        },
-    };
-}
-
-fn detectEmbedFileUpdate(comp: *Compilation, tid: Zcu.PerThread.Id, ef_index: Zcu.EmbedFile.Index, ef: *Zcu.EmbedFile) !void {
-    const io = comp.io;
-    const zcu = comp.zcu.?;
-    const pt: Zcu.PerThread = .activate(zcu, tid);
-    defer pt.deactivate();
-
-    const old_val = ef.val;
-    const old_err = ef.err;
-
-    try pt.updateEmbedFile(ef, null);
-
-    if (ef.val != .none and ef.val == old_val) return; // success, value unchanged
-    if (ef.val == .none and old_val == .none and ef.err == old_err) return; // failure, error unchanged
-
-    comp.mutex.lockUncancelable(io);
-    defer comp.mutex.unlock(io);
-
-    try zcu.markDependeeOutdated(.not_marked_po, .{ .embed_file = ef_index });
-}
-
 pub fn obtainCObjectCacheManifest(
     comp: *const Compilation,
     owner_mod: *Package.Module,
@@ -8208,12 +7751,10 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
     // If we haven't seen this library yet and we're targeting Windows, we need
     // to queue up a work item to produce the DLL import library for this.
     const gop = try comp.windows_libs.getOrPut(comp.gpa, lib_name);
-    if (gop.found_existing) return;
-    {
+    if (!gop.found_existing) {
         errdefer _ = comp.windows_libs.pop();
         gop.key_ptr.* = try comp.gpa.dupe(u8, lib_name);
     }
-    try comp.queueJob(.{ .windows_import_lib = gop.index });
 }
 
 /// This decides the optimization mode for all zig-provided libraries, including
diff --git a/src/Sema.zig b/src/Sema.zig
index ccb6f31aae4872cdcc3c86d9a1641292913cc0af..79a97a3e379615f3787072565454acdc501d1fba 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5362,7 +5362,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
     pt.updateFile(new_file_index, zcu.fileByIndex(new_file_index)) catch |err|
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
 
-    try pt.ensureFileAnalyzed(new_file_index);
+    try pt.ensureFilePopulated(new_file_index);
     const ty: Type = .fromInterned(zcu.fileRootType(new_file_index));
     try sema.addTypeReferenceEntry(src, ty);
     return .fromType(ty);
@@ -13005,7 +13005,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const file = zcu.fileByIndex(file_index);
     switch (file.getMode()) {
         .zig => {
-            try pt.ensureFileAnalyzed(file_index);
+            try pt.ensureFilePopulated(file_index);
             const ty: Type = .fromInterned(zcu.fileRootType(file_index));
             try sema.addTypeReferenceEntry(operand_src, ty);
             // No need for `ensureNamespaceUpToDate`, because `Zcu.PerThread.updateFileNamespace`
@@ -34002,7 +34002,7 @@ pub fn analyzeMemoizedState(sema: *Sema, stage: InternPool.MemoizedStateStage) C
         // Get the main struct type of the root source file of `std`. No need for a reference entry
         // because `std` is always an analysis root.
         const std_file_index = zcu.module_roots.get(zcu.std_mod).?.unwrap().?;
-        try pt.ensureFileAnalyzed(std_file_index);
+        try pt.ensureFilePopulated(std_file_index);
         const std_type: Type = .fromInterned(zcu.fileRootType(std_file_index));
         break :block .{
             .parent = null,
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 4e48ff694602c4fb3833e9b133279aea76aa588d..658a6513a84d4236095ccc5e5b46b5392d9748cb 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -3208,6 +3208,8 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
 /// recursive analysis (all of its previously-marked dependencies are already up-to-date), because
 /// recursive analysis can cause over-analysis on incremental updates.
 pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
+    // MLUGG TODO: priorize `func` units, just like we used to do in the Compilation job queue.
+
     if (zcu.outdated_ready.count() > 0) {
         const unit = zcu.outdated_ready.keys()[0];
         log.debug("findOutdatedToAnalyze: {f}", .{zcu.fmtAnalUnit(unit)});
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 73cb527f79791881e05d28cdb18f0bb63ec43737..ef22213c9a9b143c2a3ce47ca46b99e362c51765 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -27,7 +27,9 @@ const introspect = @import("../introspect.zig");
 const Module = @import("../Package.zig").Module;
 const Sema = @import("../Sema.zig");
 const target_util = @import("../target.zig");
-const trace = @import("../tracy.zig").trace;
+const tracy = @import("../tracy.zig");
+const trace = tracy.trace;
+const traceNamed = tracy.traceNamed;
 const Type = @import("../Type.zig");
 const Value = @import("../Value.zig");
 const Zcu = @import("../Zcu.zig");
@@ -125,6 +127,318 @@ pub fn deactivate(pt: Zcu.PerThread) void {
     pt.zcu.intern_pool.deactivate();
 }
 
+/// Called from `Compilation.performAllTheWork`. Performs one incremental update of the ZCU: detects
+/// changes to files, runs AstGen, and then enters the main semantic analysis loop, where we build
+/// up a graph of declarations, functions, etc, while also sending declarations and functions to
+/// codegen as they are analyzed.
+pub fn update(
+    pt: Zcu.PerThread,
+    main_progress_node: std.Progress.Node,
+    decl_work_timer: *?Compilation.Timer,
+) (Allocator.Error || Io.Cancelable)!void {
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
+
+    {
+        const tracy_trace = traceNamed(@src(), "astgen");
+        defer tracy_trace.end();
+
+        const zir_prog_node = main_progress_node.start("AST Lowering", 0);
+        defer zir_prog_node.end();
+
+        var timer = comp.startTimer();
+        defer if (timer.finish(io)) |ns| {
+            comp.mutex.lockUncancelable(io);
+            defer comp.mutex.unlock(io);
+            comp.time_report.?.stats.real_ns_files = ns;
+        };
+
+        var astgen_group: Io.Group = .init;
+        defer astgen_group.cancel(io);
+
+        // We cannot reference `zcu.import_table` after we spawn any `workerUpdateFile` jobs,
+        // because on single-threaded targets the worker will be run eagerly, meaning the
+        // `import_table` could be mutated, and not even holding `comp.mutex` will save us. So,
+        // build up a list of the files to update *before* we spawn any jobs.
+        var astgen_work_items: std.MultiArrayList(struct {
+            file_index: Zcu.File.Index,
+            file: *Zcu.File,
+        }) = .empty;
+        defer astgen_work_items.deinit(gpa);
+        // Not every item in `import_table` will need updating, because some are builtin.zig
+        // files. However, most will, so let's just reserve sufficient capacity upfront.
+        try astgen_work_items.ensureTotalCapacity(gpa, zcu.import_table.count());
+        for (zcu.import_table.keys()) |file_index| {
+            const file = zcu.fileByIndex(file_index);
+            if (file.is_builtin) {
+                // This is a `builtin.zig`, so updating is redundant. However, we want to make
+                // sure the file contents are still correct on disk, since it can improve the
+                // debugging experience better. That job only needs `file`, so we can kick it
+                // off right now.
+                astgen_group.async(io, workerUpdateBuiltinFile, .{ comp, file });
+                continue;
+            }
+            astgen_work_items.appendAssumeCapacity(.{
+                .file_index = file_index,
+                .file = file,
+            });
+        }
+
+        // Now that we're not going to touch `zcu.import_table` again, we can spawn `workerUpdateFile` jobs.
+        for (astgen_work_items.items(.file_index), astgen_work_items.items(.file)) |file_index, file| {
+            astgen_group.async(io, workerUpdateFile, .{
+                comp, file, file_index, zir_prog_node, &astgen_group,
+            });
+        }
+
+        // On the other hand, it's fine to directly iterate `zcu.embed_table.keys()` here
+        // because `workerUpdateEmbedFile` can't invalidate it. The different here is that one
+        // `@embedFile` can't trigger analysis of a new `@embedFile`!
+        for (0.., zcu.embed_table.keys()) |ef_index_usize, ef| {
+            const ef_index: Zcu.EmbedFile.Index = @enumFromInt(ef_index_usize);
+            astgen_group.async(io, workerUpdateEmbedFile, .{
+                comp, ef_index, ef,
+            });
+        }
+
+        try astgen_group.await(io);
+    }
+
+    // On an incremental update, a source file might become "dead", in that all imports of
+    // the file were removed. This could even change what module the file belongs to! As such,
+    // we do a traversal over the files, to figure out which ones are alive and the modules
+    // they belong to.
+    const any_fatal_files = try pt.computeAliveFiles();
+
+    // If the cache mode is `whole`, add every alive source file to the manifest.
+    switch (comp.cache_use) {
+        .whole => |whole| if (whole.cache_manifest) |man| {
+            for (zcu.alive_files.keys()) |file_index| {
+                const file = zcu.fileByIndex(file_index);
+
+                switch (file.status) {
+                    .never_loaded => unreachable, // AstGen tried to load it
+                    .retryable_failure => continue, // the file cannot be read; this is a guaranteed error
+                    .astgen_failure, .success => {}, // the file was read successfully
+                }
+
+                const path = try file.path.toAbsolute(comp.dirs, gpa);
+                defer gpa.free(path);
+
+                const result = res: {
+                    try whole.cache_manifest_mutex.lock(io);
+                    defer whole.cache_manifest_mutex.unlock(io);
+                    if (file.source) |source| {
+                        break :res man.addFilePostContents(path, source, file.stat);
+                    } else {
+                        break :res man.addFilePost(path);
+                    }
+                };
+                result catch |err| switch (err) {
+                    error.OutOfMemory => |e| return e,
+                    else => {
+                        try pt.reportRetryableFileError(file_index, "unable to update cache: {s}", .{@errorName(err)});
+                        continue;
+                    },
+                };
+            }
+        },
+        .none, .incremental => {},
+    }
+
+    if (comp.time_report) |*tr| {
+        tr.stats.n_reachable_files = @intCast(zcu.alive_files.count());
+    }
+
+    if (any_fatal_files or
+        zcu.multi_module_err != null or
+        zcu.failed_imports.items.len > 0 or
+        comp.alloc_failure_occurred)
+    {
+        // We give up right now! No updating of ZIR refs, no nothing. The idea is that this prevents
+        // us from invalidating lots of incremental dependencies due to files with e.g. parse errors.
+        // However, this means our analysis data is invalid, so we want to omit all analysis errors.
+        zcu.skip_analysis_this_update = true;
+        return;
+    }
+
+    if (comp.config.incremental) {
+        const update_zir_refs_node = main_progress_node.start("Update ZIR References", 0);
+        defer update_zir_refs_node.end();
+        try pt.updateZirRefs();
+    }
+
+    try zcu.flushRetryableFailures();
+
+    if (!zcu.backendSupportsFeature(.separate_thread)) {
+        // Close the ZCU task queue. Prelink may still be running, but the closed
+        // queue will cause the linker task to exit once prelink finishes. The
+        // closed queue also communicates to `enqueueZcu` that it should wait for
+        // the linker task to finish and then run ZCU tasks serially.
+        comp.link_queue.finishZcuQueue(comp);
+    }
+
+    zcu.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
+    if (comp.bin_file != null) {
+        zcu.codegen_prog_node = main_progress_node.start("Code Generation", 0);
+    }
+    // We increment `pending_codegen_jobs` so that it doesn't reach 0 until after analysis finishes.
+    // That prevents the "Code Generation" node from constantly disappearing and reappearing when
+    // we're probably going to analyze more functions at some point.
+    assert(zcu.pending_codegen_jobs.swap(1, .monotonic) == 0); // don't let this become 0 until analysis finishes
+
+    defer {
+        zcu.sema_prog_node.end();
+        zcu.sema_prog_node = .none;
+        if (zcu.pending_codegen_jobs.fetchSub(1, .monotonic) == 1) {
+            // Decremented to 0, so all done.
+            zcu.codegen_prog_node.end();
+            zcu.codegen_prog_node = .none;
+        }
+    }
+
+    // Start the timer for the "decls" part of the pipeline (Sema, CodeGen, link).
+    decl_work_timer.* = comp.startTimer();
+
+    // To kick off semantic analysis, populate the root source file of any module we have marked
+    // as an analysis root. Declarations in these files which want eager analysis---those being
+    // `comptime` declarations, any declarations marked `export`, and `test` declarations in the
+    // main module if this is a test compilation---become referenced, and so will be picked up
+    // up by the main semantic analysis loop below.
+    for (zcu.analysisRoots()) |analysis_root_mod| {
+        const analysis_root_file = zcu.module_roots.get(analysis_root_mod).?.unwrap().?;
+        try pt.ensureFilePopulated(analysis_root_file);
+    }
+
+    // This is the main semantic analysis loop, which is essentially the main loop of the whole
+    // Zig compilation pipeline. It selects some `AnalUnit` which we know needs to be analyzed,
+    // and analyzes it, which may in turn discover more `AnalUnit`s which we need to analyze.
+    while (try zcu.findOutdatedToAnalyze()) |unit| {
+        const tracy_trace = traceNamed(@src(), "analyze_outdated");
+        defer tracy_trace.end();
+
+        const maybe_err: Zcu.SemaError!void = switch (unit.unwrap()) {
+            .@"comptime" => |cu| pt.ensureComptimeUnitUpToDate(cu),
+            .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav, null),
+            .nav_val => |nav| pt.ensureNavValUpToDate(nav, null),
+            .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty), null),
+            .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage, null),
+            .func => |func| pt.ensureFuncBodyUpToDate(func, null),
+        };
+        maybe_err catch |err| switch (err) {
+            error.OutOfMemory,
+            error.Canceled,
+            => |e| return e,
+
+            error.AnalysisFail => {}, // already reported
+        };
+    }
+}
+fn workerUpdateBuiltinFile(comp: *Compilation, file: *Zcu.File) void {
+    Builtin.updateFileOnDisk(file, comp) catch |err| comp.lockAndSetMiscFailure(
+        .write_builtin_zig,
+        "unable to write '{f}': {s}",
+        .{ file.path.fmt(comp), @errorName(err) },
+    );
+}
+fn workerUpdateFile(
+    comp: *Compilation,
+    file: *Zcu.File,
+    file_index: Zcu.File.Index,
+    prog_node: std.Progress.Node,
+    group: *Io.Group,
+) void {
+    const io = comp.io;
+    const tid: Zcu.PerThread.Id = .acquire(io);
+    defer tid.release(io);
+
+    const child_prog_node = prog_node.start(std.fs.path.basename(file.path.sub_path), 0);
+    defer child_prog_node.end();
+
+    const pt: Zcu.PerThread = .activate(comp.zcu.?, tid);
+    defer pt.deactivate();
+    pt.updateFile(file_index, file) catch |err| {
+        pt.reportRetryableFileError(file_index, "unable to load '{s}': {s}", .{ std.fs.path.basename(file.path.sub_path), @errorName(err) }) catch |oom| switch (oom) {
+            error.OutOfMemory => {
+                comp.mutex.lockUncancelable(io);
+                defer comp.mutex.unlock(io);
+                comp.setAllocFailure();
+            },
+        };
+        return;
+    };
+
+    switch (file.getMode()) {
+        .zig => {}, // continue to logic below
+        .zon => return, // ZON can't import anything so we're done
+    }
+
+    // Discover all imports in the file. Imports of modules we ignore for now since we don't
+    // know which module we're in, but imports of file paths might need us to queue up other
+    // AstGen jobs.
+    const imports_index = file.zir.?.extra[@intFromEnum(Zir.ExtraIndex.imports)];
+    if (imports_index != 0) {
+        const extra = file.zir.?.extraData(Zir.Inst.Imports, imports_index);
+        var import_i: u32 = 0;
+        var extra_index = extra.end;
+
+        while (import_i < extra.data.imports_len) : (import_i += 1) {
+            const item = file.zir.?.extraData(Zir.Inst.Imports.Item, extra_index);
+            extra_index = item.end;
+
+            const import_path = file.zir.?.nullTerminatedString(item.data.name);
+
+            if (pt.discoverImport(file.path, import_path)) |res| switch (res) {
+                .module, .existing_file => {},
+                .new_file => |new| {
+                    group.async(io, workerUpdateFile, .{
+                        comp, new.file, new.index, prog_node, group,
+                    });
+                },
+            } else |err| switch (err) {
+                error.OutOfMemory => {
+                    comp.mutex.lockUncancelable(io);
+                    defer comp.mutex.unlock(io);
+                    comp.setAllocFailure();
+                },
+            }
+        }
+    }
+}
+fn workerUpdateEmbedFile(comp: *Compilation, ef_index: Zcu.EmbedFile.Index, ef: *Zcu.EmbedFile) void {
+    const io = comp.io;
+    const tid: Zcu.PerThread.Id = .acquire(io);
+    defer tid.release(io);
+    detectEmbedFileUpdate(comp, tid, ef_index, ef) catch |err| switch (err) {
+        error.OutOfMemory => {
+            comp.mutex.lockUncancelable(io);
+            defer comp.mutex.unlock(io);
+            comp.setAllocFailure();
+        },
+    };
+}
+fn detectEmbedFileUpdate(comp: *Compilation, tid: Zcu.PerThread.Id, ef_index: Zcu.EmbedFile.Index, ef: *Zcu.EmbedFile) !void {
+    const io = comp.io;
+    const zcu = comp.zcu.?;
+    const pt: Zcu.PerThread = .activate(zcu, tid);
+    defer pt.deactivate();
+
+    const old_val = ef.val;
+    const old_err = ef.err;
+
+    try pt.updateEmbedFile(ef, null);
+
+    if (ef.val != .none and ef.val == old_val) return; // success, value unchanged
+    if (ef.val == .none and old_val == .none and ef.err == old_err) return; // failure, error unchanged
+
+    comp.mutex.lockUncancelable(io);
+    defer comp.mutex.unlock(io);
+
+    try zcu.markDependeeOutdated(.not_marked_po, .{ .embed_file = ef_index });
+}
+
 fn deinitFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -156,8 +470,8 @@ pub fn updateFile(
 ) !void {
     dev.check(.ast_gen);
 
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -484,7 +798,7 @@ fn cleanupUpdatedFiles(gpa: Allocator, updated_files: *std.AutoArrayHashMapUnman
     updated_files.deinit(gpa);
 }
 
-pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
+fn updateZirRefs(pt: Zcu.PerThread) (Io.Cancelable || Allocator.Error)!void {
     assert(pt.tid == .main);
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -566,7 +880,7 @@ pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
                     const old_line = old_zir.getDeclaration(old_inst).src_line;
                     const new_line = new_zir.getDeclaration(new_inst).src_line;
                     if (old_line != new_line) {
-                        try comp.queueJob(.{ .update_line_number = tracked_inst_index });
+                        try comp.link_queue.enqueueZcu(comp, pt.tid, .{ .debug_update_line_number = tracked_inst_index });
                     }
                 },
                 else => {},
@@ -674,11 +988,11 @@ pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
 /// Typical Zig compilations begin by claling this function on the root source file of the standard
 /// library, `lib/std/std.zig`. The resulting namespace scan discovers a `comptime` declaration in
 /// that file, which is queued for analysis, and everything goes from there.
-pub fn ensureFileAnalyzed(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Allocator.Error || Io.Cancelable)!void {
+pub fn ensureFilePopulated(pt: Zcu.PerThread, file_index: Zcu.File.Index) (Allocator.Error || Io.Cancelable)!void {
     dev.check(.sema);
 
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -734,8 +1048,8 @@ pub fn ensureMemoizedStateUpToDate(
     /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
     reason: ?*const Zcu.DependencyReason,
 ) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -844,8 +1158,8 @@ fn analyzeMemoizedState(
 /// if necessary. Returns `error.AnalysisFail` if an analysis error is encountered; the caller is
 /// free to ignore this, since the error is already registered.
 pub fn ensureComptimeUnitUpToDate(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -1008,8 +1322,8 @@ pub fn ensureTypeLayoutUpToDate(
     /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
     reason: ?*const Zcu.DependencyReason,
 ) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -1121,8 +1435,8 @@ pub fn ensureNavValUpToDate(
     /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
     reason: ?*const Zcu.DependencyReason,
 ) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -1457,12 +1771,20 @@ fn analyzeNavVal(
         if (!queue_linker_work) break :queue_codegen;
 
         if (!nav_ty.hasRuntimeBits(zcu)) {
-            if (zcu.comp.config.use_llvm) break :queue_codegen;
+            if (comp.config.use_llvm) break :queue_codegen;
             if (file.mod.?.strip) break :queue_codegen;
         }
 
-        zcu.comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try zcu.comp.queueJob(.{ .link_nav = nav_id });
+        comp.link_prog_node.increaseEstimatedTotalItems(1);
+        try comp.link_queue.enqueueZcu(comp, pt.tid, .{ .link_nav = nav_id });
+    }
+
+    if (comp.config.is_test and zcu.test_functions.contains(nav_id)) {
+        // We just analyzed a test function's "value" (essentially its signature); now we need to
+        // implicitly reference the function *body*. `Zcu.resolveReferences` knows about this rule,
+        // so we don't need to mark an explicit reference, but we do need to make sure that the test
+        // body will actually get analyzed!
+        try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern());
     }
 
     switch (old_nav.status) {
@@ -1477,8 +1799,8 @@ pub fn ensureNavTypeUpToDate(
     /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
     reason: ?*const Zcu.DependencyReason,
 ) Zcu.SemaError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -1719,8 +2041,8 @@ pub fn ensureFuncBodyUpToDate(
 ) Zcu.SemaError!void {
     dev.check(.sema);
 
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -1846,7 +2168,8 @@ fn analyzeFuncBody(
     log.debug("analyze and generate fn body {f}", .{zcu.fmtAnalUnit(anal_unit)});
 
     var air = try pt.analyzeFuncBodyInner(func_index, reason);
-    errdefer air.deinit(gpa);
+    var air_owned = true;
+    errdefer if (air_owned) air.deinit(gpa);
 
     const ies_outdated = !func.analysisUnordered(ip).inferred_error_set or
         func.resolvedErrorSetUnordered(ip) != old_resolved_ies;
@@ -1856,18 +2179,23 @@ fn analyzeFuncBody(
     const dump_air = build_options.enable_debug_extensions and comp.verbose_air;
     const dump_llvm_ir = build_options.enable_debug_extensions and (comp.verbose_llvm_ir != null or comp.verbose_llvm_bc != null);
 
-    if (comp.bin_file == null and zcu.llvm_object == null and !dump_air and !dump_llvm_ir) {
-        air.deinit(gpa);
-        return .{ .ies_outdated = ies_outdated };
+    if (comp.bin_file != null or zcu.llvm_object != null or dump_air or dump_llvm_ir) {
+        zcu.codegen_prog_node.increaseEstimatedTotalItems(1);
+        comp.link_prog_node.increaseEstimatedTotalItems(1);
+
+        // Some linkers need to refer to the AIR. In that case, the linker is not running
+        // concurrently, so we'll just keep ownership of the AIR for ourselves instead of
+        // letting the codegen job destroy it.
+        const disown_air = zcu.backendSupportsFeature(.separate_thread);
+
+        // Begin the codegen task. If the codegen/link queue is backed up, this might
+        // block until the linker is able to process some tasks.
+        const codegen_task = try zcu.codegen_task_pool.start(zcu, func_index, &air, disown_air);
+        if (disown_air) air_owned = false;
+
+        try comp.link_queue.enqueueZcu(comp, pt.tid, .{ .link_func = codegen_task });
     }
 
-    zcu.codegen_prog_node.increaseEstimatedTotalItems(1);
-    comp.link_prog_node.increaseEstimatedTotalItems(1);
-    try comp.queueJob(.{ .codegen_func = .{
-        .func = func_index,
-        .air = air,
-    } });
-
     return .{ .ies_outdated = ies_outdated };
 }
 
@@ -2121,7 +2449,7 @@ pub fn populateModuleRootTable(pt: Zcu.PerThread) error{
 /// modify `pt.zcu.skip_analysis_this_update`.
 ///
 /// If an error is returned, `pt.zcu.alive_files` might contain undefined values.
-pub fn computeAliveFiles(pt: Zcu.PerThread) Allocator.Error!bool {
+fn computeAliveFiles(pt: Zcu.PerThread) Allocator.Error!bool {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = zcu.gpa;
@@ -2562,8 +2890,8 @@ pub fn scanNamespace(
     namespace_index: Zcu.Namespace.Index,
     decls: []const Zir.Inst.Index,
 ) Allocator.Error!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -2659,8 +2987,8 @@ const ScanDeclIter = struct {
     }
 
     fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void {
-        const tracy = trace(@src());
-        defer tracy.end();
+        const tracy_trace = trace(@src());
+        defer tracy_trace.end();
 
         const pt = iter.pt;
         const zcu = pt.zcu;
@@ -2713,77 +3041,65 @@ const ScanDeclIter = struct {
 
         const existing_unit = iter.existing_by_inst.get(tracked_inst);
 
-        const unit: AnalUnit, const want_analysis = switch (decl.kind) {
-            .@"comptime" => unit: {
-                const cu = if (existing_unit) |eu|
-                    eu.unwrap().@"comptime"
-                else
-                    try ip.createComptimeUnit(gpa, io, pt.tid, tracked_inst, namespace_index);
-
+        const name = maybe_name.unwrap() orelse {
+            // Only `comptime` declarations are unnamed.
+            assert(decl.kind == .@"comptime");
+            if (existing_unit) |unit| {
+                try namespace.comptime_decls.append(gpa, unit.unwrap().@"comptime");
+            } else {
+                const cu = try ip.createComptimeUnit(gpa, io, pt.tid, tracked_inst, namespace_index);
+                try zcu.queueComptimeUnitAnalysis(cu);
                 try namespace.comptime_decls.append(gpa, cu);
+            }
+            return;
+        };
 
-                if (existing_unit == null) {
-                    // For a `comptime` declaration, whether to analyze is based solely on whether the unit
-                    // is outdated. So, add this fresh one to `outdated` and `outdated_ready`.
-                    try zcu.queueComptimeUnitAnalysis(cu);
-                }
-
-                break :unit .{ .wrap(.{ .@"comptime" = cu }), true };
-            },
-            else => unit: {
-                const name = maybe_name.unwrap().?;
-                const fqn = try namespace.internFullyQualifiedName(ip, gpa, io, pt.tid, name);
-                const nav = if (existing_unit) |eu| eu.unwrap().nav_val else nav: {
-                    const nav = try ip.createDeclNav(gpa, io, pt.tid, name, fqn, tracked_inst, namespace_index);
-                    if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newNav(zcu, nav);
-                    break :nav nav;
-                };
-
-                const unit: AnalUnit = .wrap(.{ .nav_val = nav });
+        const fqn = try namespace.internFullyQualifiedName(ip, gpa, io, pt.tid, name);
 
-                assert(ip.getNav(nav).name == name);
-                assert(ip.getNav(nav).fqn == fqn);
+        const nav = if (existing_unit) |unit| nav: {
+            const nav = unit.unwrap().nav_val;
+            assert(ip.getNav(nav).name == name);
+            assert(ip.getNav(nav).fqn == fqn);
+            break :nav nav;
+        } else nav: {
+            const nav = try ip.createDeclNav(gpa, io, pt.tid, name, fqn, tracked_inst, namespace_index);
+            if (zcu.comp.debugIncremental()) try zcu.incremental_debug_state.newNav(zcu, nav);
+            break :nav nav;
+        };
 
-                const want_analysis = switch (decl.kind) {
-                    .@"comptime" => unreachable,
-                    .unnamed_test, .@"test", .decltest => a: {
-                        const is_named = decl.kind != .unnamed_test;
-                        try namespace.test_decls.append(gpa, nav);
-                        // TODO: incremental compilation!
-                        // * remove from `test_functions` if no longer matching filter
-                        // * add to `test_functions` if newly passing filter
-                        // This logic is unaware of incremental: we'll end up with duplicates.
-                        // Perhaps we should add all test indiscriminately and filter at the end of the update.
-                        if (!comp.config.is_test) break :a false;
-                        if (file.mod != zcu.main_mod) break :a false;
-                        if (is_named and comp.test_filters.len > 0) {
-                            const fqn_slice = fqn.toSlice(ip);
-                            for (comp.test_filters) |test_filter| {
-                                if (std.mem.indexOf(u8, fqn_slice, test_filter) != null) break;
-                            } else break :a false;
-                        }
-                        try zcu.test_functions.put(gpa, nav, {});
-                        break :a true;
-                    },
-                    .@"const", .@"var" => a: {
-                        if (decl.is_pub) {
-                            try namespace.pub_decls.putContext(gpa, nav, {}, .{ .zcu = zcu });
-                        } else {
-                            try namespace.priv_decls.putContext(gpa, nav, {}, .{ .zcu = zcu });
-                        }
-                        break :a false;
-                    },
-                };
-                break :unit .{ unit, want_analysis };
+        const want_analysis: bool = switch (decl.kind) {
+            .@"comptime" => unreachable,
+            .unnamed_test, .@"test", .decltest => a: {
+                const is_named = decl.kind != .unnamed_test;
+                try namespace.test_decls.append(gpa, nav);
+                // TODO: incremental compilation!
+                // * remove from `test_functions` if no longer matching filter
+                // * add to `test_functions` if newly passing filter
+                // This logic is unaware of incremental: we'll end up with duplicates.
+                // Perhaps we should add all test indiscriminately and filter at the end of the update.
+                if (!comp.config.is_test) break :a false;
+                if (file.mod != zcu.main_mod) break :a false;
+                if (is_named and comp.test_filters.len > 0) {
+                    const fqn_slice = fqn.toSlice(ip);
+                    for (comp.test_filters) |test_filter| {
+                        if (std.mem.indexOf(u8, fqn_slice, test_filter) != null) break;
+                    } else break :a false;
+                }
+                try zcu.test_functions.put(gpa, nav, {});
+                break :a true;
+            },
+            .@"const", .@"var" => a: {
+                if (decl.is_pub) {
+                    try namespace.pub_decls.putContext(gpa, nav, {}, .{ .zcu = zcu });
+                } else {
+                    try namespace.priv_decls.putContext(gpa, nav, {}, .{ .zcu = zcu });
+                }
+                break :a false;
             },
         };
 
-        if (existing_unit == null and (want_analysis or decl.linkage == .@"export")) {
-            log.debug(
-                "scanDecl queue analyze_unit file='{s}' unit={f}",
-                .{ namespace.fileScope(zcu).sub_file_path, zcu.fmtAnalUnit(unit) },
-            );
-            try comp.queueJob(.{ .analyze_unit = unit });
+        if (want_analysis or decl.linkage == .@"export") {
+            try zcu.ensureNavValAnalysisQueued(nav);
         }
     }
 };
@@ -2793,8 +3109,8 @@ fn analyzeFuncBodyInner(
     func_index: InternPool.Index,
     reason: ?*const Zcu.DependencyReason,
 ) Zcu.SemaError!Air {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
 
     const zcu = pt.zcu;
     const comp = zcu.comp;
@@ -3437,36 +3753,45 @@ pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool
 
 /// Essentially a shortcut for calling `intern_pool.getCoerced`.
 /// However, this function also allows coercing `extern`s. The `InternPool` function can't do
-/// this because it requires potentially pushing to the job queue.
+/// this because it requires potentially queueing a link task.
 pub fn getCoerced(pt: Zcu.PerThread, val: Value, new_ty: Type) Allocator.Error!Value {
     const ip = &pt.zcu.intern_pool;
     const comp = pt.zcu.comp;
     const gpa = comp.gpa;
     const io = comp.io;
     switch (ip.indexToKey(val.toIntern())) {
-        .@"extern" => |e| {
-            const coerced = try pt.getExtern(.{
-                .name = e.name,
+        .@"extern" => |@"extern"| {
+            // TODO: it's awkward to make this function cancelable. The problem is really that
+            // `getCoerced` is a bad API: it should be replaced with smaller, more specialized
+            // functions, so that this cancel point is only possible in the rare case that you
+            // may actually need to coerce an extern!
+            const old_prot = io.swapCancelProtection(.blocked);
+            defer _ = io.swapCancelProtection(old_prot);
+            const coerced = pt.getExtern(.{
+                .name = @"extern".name,
                 .ty = new_ty.toIntern(),
-                .lib_name = e.lib_name,
-                .is_const = e.is_const,
-                .is_threadlocal = e.is_threadlocal,
-                .linkage = e.linkage,
-                .visibility = e.visibility,
-                .is_dll_import = e.is_dll_import,
-                .relocation = e.relocation,
-                .decoration = e.decoration,
-                .alignment = e.alignment,
-                .@"addrspace" = e.@"addrspace",
-                .zir_index = e.zir_index,
+                .lib_name = @"extern".lib_name,
+                .is_const = @"extern".is_const,
+                .is_threadlocal = @"extern".is_threadlocal,
+                .linkage = @"extern".linkage,
+                .visibility = @"extern".visibility,
+                .is_dll_import = @"extern".is_dll_import,
+                .relocation = @"extern".relocation,
+                .decoration = @"extern".decoration,
+                .alignment = @"extern".alignment,
+                .@"addrspace" = @"extern".@"addrspace",
+                .zir_index = @"extern".zir_index,
                 .owner_nav = undefined, // ignored by `getExtern`.
-                .source = e.source,
-            });
-            return Value.fromInterned(coerced);
+                .source = @"extern".source,
+            }) catch |err| switch (err) {
+                error.Canceled => unreachable, // blocked above
+                error.OutOfMemory => |e| return e,
+            };
+            return .fromInterned(coerced);
         },
         else => {},
     }
-    return Value.fromInterned(try ip.getCoerced(gpa, io, pt.tid, val.toIntern(), new_ty.toIntern()));
+    return .fromInterned(try ip.getCoerced(gpa, io, pt.tid, val.toIntern(), new_ty.toIntern()));
 }
 
 pub fn intType(pt: Zcu.PerThread, signedness: std.builtin.Signedness, bits: u16) Allocator.Error!Type {
@@ -3865,14 +4190,15 @@ pub fn navPtrType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Allocator.Err
 /// Intern an `.@"extern"`, creating a corresponding owner `Nav` if necessary.
 /// If necessary, the new `Nav` is queued for codegen.
 /// `key.owner_nav` is ignored and may be `undefined`.
-pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!InternPool.Index {
+pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) (Io.Cancelable || Allocator.Error)!InternPool.Index {
     const zcu = pt.zcu;
     const comp = zcu.comp;
+    Type.fromInterned(key.ty).assertHasLayout(zcu);
     const result = try zcu.intern_pool.getExtern(comp.gpa, comp.io, pt.tid, key);
     if (result.new_nav.unwrap()) |nav| {
-        comp.link_prog_node.increaseEstimatedTotalItems(1);
-        try comp.queueJob(.{ .link_nav = nav });
         if (comp.debugIncremental()) try zcu.incremental_debug_state.newNav(zcu, nav);
+        comp.link_prog_node.increaseEstimatedTotalItems(1);
+        try comp.link_queue.enqueueZcu(comp, pt.tid, .{ .link_nav = nav });
     }
     return result.index;
 }
-- 
2.54.0


From 6402e119e8d21403cbafc4a6c8ca353b894592ba Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 13 Feb 2026 09:31:36 +0000
Subject: [PATCH 459/499] Zcu: prioritize analyzing function bodies

...so that they can be sent to the codegen backend and linker ASAP.
---
 src/Zcu.zig | 88 ++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 63 insertions(+), 25 deletions(-)

diff --git a/src/Zcu.zig b/src/Zcu.zig
index 658a6513a84d4236095ccc5e5b46b5392d9748cb..481ea0d62ad312d3a0e9ce5f6d84f8ea13635841 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -275,10 +275,16 @@ potentially_outdated: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .empty,
 /// Value is the number of PO dependencies of this AnalUnit.
 /// Once this value drops to 0, the AnalUnit is a candidate for re-analysis.
 outdated: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .empty,
-/// This contains all `AnalUnit`s in `outdated` whose PO dependency count is 0.
+/// This is the set of all `AnalUnit`s in `outdated` whose PO dependency count is 0.
 /// Such `AnalUnit`s are ready for immediate re-analysis.
 /// See `findOutdatedToAnalyze` for details.
-outdated_ready: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
+outdated_ready: struct {
+    /// These are separate from other units because it allows `findOutdatedToAnalyze` to prioritize
+    /// functions, which is useful because it means they will be sent to codegen more quickly.
+    funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+    /// Does not contain `.func` units.
+    other: std.AutoArrayHashMapUnmanaged(AnalUnit, void),
+} = .{ .funcs = .empty, .other = .empty },
 /// This contains a list of AnalUnit whose analysis or codegen failed, but the
 /// failure was something like running out of disk space, and trying again may
 /// succeed. On the next update, we will flush this list, marking all members of
@@ -2835,7 +2841,8 @@ pub fn deinit(zcu: *Zcu) void {
 
         zcu.potentially_outdated.deinit(gpa);
         zcu.outdated.deinit(gpa);
-        zcu.outdated_ready.deinit(gpa);
+        zcu.outdated_ready.funcs.deinit(gpa);
+        zcu.outdated_ready.other.deinit(gpa);
         zcu.retryable_failures.deinit(gpa);
 
         zcu.test_functions.deinit(gpa);
@@ -3065,6 +3072,7 @@ pub fn markDependeeOutdated(
     marked_po: enum { not_marked_po, marked_po },
     dependee: InternPool.Dependee,
 ) !void {
+    const gpa = zcu.comp.gpa;
     deps_log.debug("outdated dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = zcu.intern_pool.dependencyIterator(dependee);
     if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
@@ -3078,7 +3086,10 @@ pub fn markDependeeOutdated(
                     deps_log.debug("outdated {f} => already outdated {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), po_dep_count.* });
                     if (po_dep_count.* == 0) {
                         deps_log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
-                        try zcu.outdated_ready.put(zcu.gpa, depender, {});
+                        switch (depender.unwrap()) {
+                            .func => |func| try zcu.outdated_ready.funcs.put(gpa, func, {}),
+                            else => try zcu.outdated_ready.other.put(gpa, depender, {}),
+                        }
                     }
                 },
             }
@@ -3094,14 +3105,17 @@ pub fn markDependeeOutdated(
             },
         };
         try zcu.outdated.putNoClobber(
-            zcu.gpa,
+            gpa,
             depender,
             new_po_dep_count,
         );
         deps_log.debug("outdated {f} => new outdated {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), new_po_dep_count });
         if (new_po_dep_count == 0) {
             deps_log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
-            try zcu.outdated_ready.put(zcu.gpa, depender, {});
+            switch (depender.unwrap()) {
+                .func => |func| try zcu.outdated_ready.funcs.put(gpa, func, {}),
+                else => try zcu.outdated_ready.other.put(gpa, depender, {}),
+            }
         }
         // If this is a Decl and was not previously PO, we must recursively
         // mark dependencies on its tyval as PO.
@@ -3119,6 +3133,7 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
 }
 /// Assumes that `zcu.outdated_lock` is already held exclusively.
 fn markPoDependeeUpToDateInner(zcu: *Zcu, dependee: InternPool.Dependee) !void {
+    const gpa = zcu.comp.gpa;
     deps_log.debug("up-to-date dependee: {f}", .{zcu.fmtDependee(dependee)});
     var it = zcu.intern_pool.dependencyIterator(dependee);
     while (it.next()) |depender| {
@@ -3129,7 +3144,10 @@ fn markPoDependeeUpToDateInner(zcu: *Zcu, dependee: InternPool.Dependee) !void {
             deps_log.debug("up-to-date {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(depender), po_dep_count.* });
             if (po_dep_count.* == 0) {
                 deps_log.debug("outdated ready: {f}", .{zcu.fmtAnalUnit(depender)});
-                try zcu.outdated_ready.put(zcu.gpa, depender, {});
+                switch (depender.unwrap()) {
+                    .func => |func| try zcu.outdated_ready.funcs.put(gpa, func, {}),
+                    else => try zcu.outdated_ready.other.put(gpa, depender, {}),
+                }
             }
             continue;
         }
@@ -3167,7 +3185,8 @@ fn markPoDependeeUpToDateInner(zcu: *Zcu, dependee: InternPool.Dependee) !void {
 /// in turn be PO, due to a dependency on the original AnalUnit's tyval or IES.
 ///
 /// Assumes that `zcu.outdated_lock` is already held exclusively.
-fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUnit) !void {
+fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUnit) Allocator.Error!void {
+    const gpa = zcu.comp.gpa;
     const ip = &zcu.intern_pool;
     const dependee: InternPool.Dependee = switch (maybe_outdated.unwrap()) {
         .@"comptime" => return, // analysis of a comptime decl can't outdate any dependencies
@@ -3181,10 +3200,12 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
     var it = ip.dependencyIterator(dependee);
     while (it.next()) |po| {
         if (zcu.outdated.getPtr(po)) |po_dep_count| {
-            // This dependency is already outdated, but it now has one more PO
-            // dependency.
+            // This dependency is already outdated, but it now has one more PO dependency.
             if (po_dep_count.* == 0) {
-                _ = zcu.outdated_ready.swapRemove(po);
+                switch (po.unwrap()) {
+                    .func => |func| _ = zcu.outdated_ready.funcs.swapRemove(func),
+                    else => _ = zcu.outdated_ready.other.swapRemove(po),
+                }
             }
             po_dep_count.* += 1;
             deps_log.debug("po {f} => {f} [outdated] po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po), po_dep_count.* });
@@ -3196,7 +3217,7 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
             deps_log.debug("po {f} => {f} po_deps={}", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po), n.* });
             continue;
         }
-        try zcu.potentially_outdated.putNoClobber(zcu.gpa, po, 1);
+        try zcu.potentially_outdated.putNoClobber(gpa, po, 1);
         deps_log.debug("po {f} => {f} po_deps=1", .{ zcu.fmtDependee(dependee), zcu.fmtAnalUnit(po) });
         // This AnalUnit was not already PO, so we must recursively mark its dependers as also PO.
         try zcu.markTransitiveDependersPotentiallyOutdated(po);
@@ -3208,10 +3229,20 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
 /// recursive analysis (all of its previously-marked dependencies are already up-to-date), because
 /// recursive analysis can cause over-analysis on incremental updates.
 pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
-    // MLUGG TODO: priorize `func` units, just like we used to do in the Compilation job queue.
+    // We prioritize functions, because the sooner they get analyzed, the sooner they can be send to
+    // the codegen backend and linker, which are usually running in parallel (so this can increase
+    // parallelism).
+    // TODO: perhaps we should also experiment with *avoiding* functions if the codegen/link queue
+    // is backed up (for instance due to a very large function). That could help minimize blocking
+    // on the main thread in `CodegenTaskPool.start` waiting for the linker to catch up.
+    if (zcu.outdated_ready.funcs.count() > 0) {
+        const unit: AnalUnit = .wrap(.{ .func = zcu.outdated_ready.funcs.keys()[0] });
+        log.debug("findOutdatedToAnalyze: {f}", .{zcu.fmtAnalUnit(unit)});
+        return unit;
+    }
 
-    if (zcu.outdated_ready.count() > 0) {
-        const unit = zcu.outdated_ready.keys()[0];
+    if (zcu.outdated_ready.other.count() > 0) {
+        const unit = zcu.outdated_ready.other.keys()[0];
         log.debug("findOutdatedToAnalyze: {f}", .{zcu.fmtAnalUnit(unit)});
         return unit;
     }
@@ -3502,13 +3533,12 @@ pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func: InternPool.Index) !void {
     assert(func == ip.unwrapCoercedFunc(func)); // analyze the body of the original function, not a coerced one
     if (ip.setWantRuntimeFnAnalysis(io, func)) {
         // This is the first reference to this function, so we must ensure it will be analyzed.
-        const unit: AnalUnit = .wrap(.{ .func = func });
         if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
         defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
         try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-        try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
-        zcu.outdated.putAssumeCapacityNoClobber(unit, 0);
-        zcu.outdated_ready.putAssumeCapacityNoClobber(unit, {});
+        try zcu.outdated_ready.funcs.ensureUnusedCapacity(gpa, 1);
+        zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .func = func }), 0);
+        zcu.outdated_ready.funcs.putAssumeCapacityNoClobber(func, {});
     }
 }
 
@@ -3522,11 +3552,11 @@ pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav: InternPool.Nav.Index) !void {
         if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
         defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
         try zcu.outdated.ensureUnusedCapacity(gpa, 2);
-        try zcu.outdated_ready.ensureUnusedCapacity(gpa, 2);
+        try zcu.outdated_ready.other.ensureUnusedCapacity(gpa, 2);
         zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .nav_val = nav }), 0);
         zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .nav_ty = nav }), 0);
-        zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .nav_val = nav }), {});
-        zcu.outdated_ready.putAssumeCapacityNoClobber(.wrap(.{ .nav_ty = nav }), {});
+        zcu.outdated_ready.other.putAssumeCapacityNoClobber(.wrap(.{ .nav_val = nav }), {});
+        zcu.outdated_ready.other.putAssumeCapacityNoClobber(.wrap(.{ .nav_ty = nav }), {});
     }
 }
 
@@ -3540,9 +3570,9 @@ pub fn queueComptimeUnitAnalysis(zcu: *Zcu, cu: InternPool.ComptimeUnit.Id) Allo
     if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(io);
     defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(io);
     try zcu.outdated.ensureUnusedCapacity(gpa, 1);
-    try zcu.outdated_ready.ensureUnusedCapacity(gpa, 1);
+    try zcu.outdated_ready.other.ensureUnusedCapacity(gpa, 1);
     zcu.outdated.putAssumeCapacityNoClobber(unit, 0);
-    zcu.outdated_ready.putAssumeCapacityNoClobber(unit, {});
+    zcu.outdated_ready.other.putAssumeCapacityNoClobber(unit, {});
 }
 
 /// If `unit` was marked as outdated or porentially outdated, clears that status and returns `true`.
@@ -3552,7 +3582,15 @@ pub fn clearOutdatedState(zcu: *Zcu, unit: AnalUnit) bool {
     if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(io);
     defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(io);
     if (zcu.outdated.fetchSwapRemove(unit)) |kv| {
-        if (kv.value == 0) assert(zcu.outdated_ready.swapRemove(unit));
+        const was_ready = switch (unit.unwrap()) {
+            .func => |func| zcu.outdated_ready.funcs.swapRemove(func),
+            else => zcu.outdated_ready.other.swapRemove(unit),
+        };
+        if (kv.value == 0) {
+            assert(was_ready);
+        } else {
+            assert(!was_ready);
+        }
         return true;
     } else if (zcu.potentially_outdated.swapRemove(unit)) {
         return true;
-- 
2.54.0


From 2b8feabb8f2b3a3c96d2d8e74393e0c8dfa17390 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 13 Feb 2026 11:48:56 +0000
Subject: [PATCH 460/499] llvm: some more improvements to debug info

Most importantly, adds support for `DW_TAG_typedef` to `llvm.Builder`,
and uses it to define error sets and optional pointers/errors.

Also deletes some random dead code I found.
---
 lib/std/zig/llvm/Builder.zig |  58 ++++++++
 src/codegen/llvm.zig         | 257 ++++++++++++-----------------------
 2 files changed, 142 insertions(+), 173 deletions(-)

diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index 81b99c25725a20f0bbb7ed61ac611974e98d6dac..f40b63c85fdb0536b7b75cc9915de558d0f105fb 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -8021,6 +8021,7 @@ pub const Metadata = packed struct(u32) {
         composite_vector_type,
         derived_pointer_type,
         derived_member_type,
+        derived_typedef_type,
         subroutine_type,
         enumerator_unsigned,
         enumerator_signed_positive,
@@ -8064,6 +8065,7 @@ pub const Metadata = packed struct(u32) {
                 .composite_vector_type,
                 .derived_pointer_type,
                 .derived_member_type,
+                .derived_typedef_type,
                 .subroutine_type,
                 .enumerator_unsigned,
                 .enumerator_signed_positive,
@@ -10463,15 +10465,18 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                 },
                 .derived_pointer_type,
                 .derived_member_type,
+                .derived_typedef_type,
                 => |kind| {
                     const extra = self.metadataExtraData(Metadata.DerivedType, metadata_item.data);
                     try metadata_formatter.specialized(.@"!", .DIDerivedType, .{
                         .tag = @as(enum {
                             DW_TAG_pointer_type,
                             DW_TAG_member,
+                            DW_TAG_typedef,
                         }, switch (kind) {
                             .derived_pointer_type => .DW_TAG_pointer_type,
                             .derived_member_type => .DW_TAG_member,
+                            .derived_typedef_type => .DW_TAG_typedef,
                             else => unreachable,
                         }),
                         .name = extra.name,
@@ -12360,6 +12365,30 @@ pub fn debugMemberType(
     );
 }
 
+pub fn debugTypedefType(
+    self: *Builder,
+    name: ?Metadata.String,
+    file: ?Metadata,
+    scope: ?Metadata,
+    line: u32,
+    underlying_type: ?Metadata,
+    size_in_bits: u64,
+    align_in_bits: u64,
+    offset_in_bits: u64,
+) Allocator.Error!Metadata {
+    try self.ensureUnusedMetadataCapacity(1, Metadata.DerivedType, 0);
+    return self.debugTypedefTypeAssumeCapacity(
+        name,
+        file,
+        scope,
+        line,
+        underlying_type,
+        size_in_bits,
+        align_in_bits,
+        offset_in_bits,
+    );
+}
+
 pub fn debugSubroutineType(self: *Builder, types_tuple: ?Metadata) Allocator.Error!Metadata {
     try self.ensureUnusedMetadataCapacity(1, Metadata.SubroutineType, 0);
     return self.debugSubroutineTypeAssumeCapacity(types_tuple);
@@ -12875,6 +12904,33 @@ fn debugMemberTypeAssumeCapacity(
     });
 }
 
+fn debugTypedefTypeAssumeCapacity(
+    self: *Builder,
+    name: ?Metadata.String,
+    file: ?Metadata,
+    scope: ?Metadata,
+    line: u32,
+    underlying_type: ?Metadata,
+    size_in_bits: u64,
+    align_in_bits: u64,
+    offset_in_bits: u64,
+) Metadata {
+    assert(!self.strip);
+    return self.metadataSimpleAssumeCapacity(.derived_typedef_type, Metadata.DerivedType{
+        .name = .wrap(name),
+        .file = .wrap(file),
+        .scope = .wrap(scope),
+        .line = line,
+        .underlying_type = .wrap(underlying_type),
+        .size_in_bits_lo = @truncate(size_in_bits),
+        .size_in_bits_hi = @truncate(size_in_bits >> 32),
+        .align_in_bits_lo = @truncate(align_in_bits),
+        .align_in_bits_hi = @truncate(align_in_bits >> 32),
+        .offset_in_bits_lo = @truncate(offset_in_bits),
+        .offset_in_bits_hi = @truncate(offset_in_bits >> 32),
+    });
+}
+
 fn debugSubroutineTypeAssumeCapacity(self: *Builder, types_tuple: ?Metadata) Metadata {
     assert(!self.strip);
     return self.metadataSimpleAssumeCapacity(.subroutine_type, Metadata.SubroutineType{
@@ -14223,12 +14279,14 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                     },
                     .derived_pointer_type,
                     .derived_member_type,
+                    .derived_typedef_type,
                     => |kind| {
                         const extra = self.metadataExtraData(Metadata.DerivedType, data);
                         try metadata_block.writeAbbrevAdapted(MetadataBlock.DerivedType{
                             .tag = switch (kind) {
                                 .derived_pointer_type => DW.TAG.pointer_type,
                                 .derived_member_type => DW.TAG.member,
+                                .derived_typedef_type => DW.TAG.typedef,
                                 else => unreachable,
                             },
                             .name = extra.name,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 185dcb0fe1702e632661b49b8c1d80250c5a7b4a..5735fe5e51a665a46e965cd3f01a26bdb57ac094 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1914,6 +1914,15 @@ pub const Object = struct {
 
         const name = try o.builder.metadataStringFmt("{f}", .{ty.fmt(pt)});
 
+        // lldb cannot handle non-byte-sized types, so in the logic below, bit sizes are padded up.
+        // For instance, `bool` is considered to be 8 bits, and `u60` is considered to be 64 bits.
+
+        // I tried using variants (DW_TAG_variant_part + DW_TAG_variant) to encode error unions,
+        // tagged unions, etc; this would have told debuggers which field was active, which could
+        // improve UX significantly. GDB handles this perfectly fine, but unfortunately, LLDB has no
+        // handling for variants at all, and will never print fields in them, so I opted not to use
+        // them for now.
+
         switch (ty.zigTypeTag(zcu)) {
             .void,
             .noreturn,
@@ -1925,23 +1934,19 @@ pub const Object = struct {
             .enum_literal,
             => return o.builder.debugSignedType(name, 0),
 
+            .float => return o.builder.debugFloatType(name, ty.floatBits(target)),
+
+            .bool => return o.builder.debugBoolType(name, 8),
+
             .int => {
                 const info = ty.intInfo(zcu);
-                const bits = ty.abiSize(zcu) * 8; // lldb cannot handle non-byte sized types
+                const bits = ty.abiSize(zcu) * 8;
                 return switch (info.signedness) {
                     .signed => try o.builder.debugSignedType(name, bits),
                     .unsigned => try o.builder.debugUnsignedType(name, bits),
                 };
             },
-            .float => {
-                return o.builder.debugFloatType(name, ty.floatBits(target));
-            },
-            .bool => {
-                return o.builder.debugBoolType(
-                    name,
-                    8, // lldb cannot handle non-byte sized types
-                );
-            },
+
             .pointer => {
                 const ptr_size = Type.ptrAbiSize(zcu.getTarget());
                 const ptr_align = Type.ptrAbiAlignment(zcu.getTarget());
@@ -1949,20 +1954,20 @@ pub const Object = struct {
                 if (ty.isSlice(zcu)) {
                     const debug_ptr_type = try o.builder.debugMemberType(
                         try o.builder.metadataString("ptr"),
-                        null, // File
+                        null, // file
                         ty_fwd_ref,
-                        0, // Line
+                        0, // line
                         try o.getDebugType(pt, ty.slicePtrFieldType(zcu)),
                         ptr_size * 8,
                         ptr_align.toByteUnits().? * 8,
-                        0, // Offset
+                        0, // offset
                     );
 
                     const debug_len_type = try o.builder.debugMemberType(
                         try o.builder.metadataString("len"),
-                        null, // File
+                        null, // file
                         ty_fwd_ref,
-                        0, // Line
+                        0, // line
                         try o.getDebugType(pt, .usize),
                         ptr_size * 8,
                         ptr_align.toByteUnits().? * 8,
@@ -1971,10 +1976,10 @@ pub const Object = struct {
 
                     return o.builder.debugStructType(
                         name,
-                        null, // File
-                        o.debug_compile_unit.unwrap().?, // Scope
-                        0, // Line
-                        null, // Underlying type
+                        null, // file
+                        o.debug_compile_unit.unwrap().?, // scope
+                        0, // line
+                        null, // underlying type
                         ptr_size * 2 * 8,
                         ptr_align.toByteUnits().? * 8,
                         try o.builder.metadataTuple(&.{
@@ -1986,36 +1991,34 @@ pub const Object = struct {
 
                 return o.builder.debugPointerType(
                     name,
-                    null, // File
-                    null, // Scope
-                    0, // Line
+                    null, // file
+                    o.debug_compile_unit.unwrap().?, // scope
+                    0, // line
                     try o.getDebugType(pt, ty.childType(zcu)),
                     ptr_size * 8,
                     ptr_align.toByteUnits().? * 8,
-                    0, // Offset
-                );
-            },
-            .array => {
-                return o.builder.debugArrayType(
-                    null, // Name
-                    null, // File
-                    null, // Scope
-                    0, // Line
-                    try o.getDebugType(pt, ty.childType(zcu)),
-                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
-                    try o.builder.metadataTuple(&.{
-                        try o.builder.debugSubrange(
-                            try o.builder.metadataConstant(try o.builder.intConst(.i64, 0)),
-                            try o.builder.metadataConstant(try o.builder.intConst(.i64, ty.arrayLen(zcu))),
-                        ),
-                    }),
+                    0, // offset
                 );
             },
+            .array => return o.builder.debugArrayType(
+                name,
+                null, // file
+                o.debug_compile_unit.unwrap().?, // scope
+                0, // line
+                try o.getDebugType(pt, ty.childType(zcu)),
+                ty.abiSize(zcu) * 8,
+                ty.abiAlignment(zcu).toByteUnits().? * 8,
+                try o.builder.metadataTuple(&.{
+                    try o.builder.debugSubrange(
+                        try o.builder.metadataConstant(try o.builder.intConst(.i64, 0)),
+                        try o.builder.metadataConstant(try o.builder.intConst(.i64, ty.arrayLen(zcu))),
+                    ),
+                }),
+            ),
             .vector => {
                 const elem_ty = ty.childType(zcu);
                 // Vector elements cannot be padded since that would make
-                // @bitSizOf(elem) * len > @bitSizOf(vec).
+                // @bitSizeOf(elem) * len > @bitSizOf(vec).
                 // Neither gdb nor lldb seem to be able to display non-byte sized
                 // vectors properly.
                 const debug_elem_type = switch (elem_ty.zigTypeTag(zcu)) {
@@ -2027,18 +2030,19 @@ pub const Object = struct {
                         };
                     },
                     .bool => try o.builder.debugBoolType(try o.builder.metadataString("bool"), 1),
+                    // We don't pad pointers or floats, so we can lower those normally.
                     .pointer, .optional, .float => try o.getDebugType(pt, elem_ty),
                     else => unreachable,
                 };
 
                 return o.builder.debugVectorType(
-                    null, // Name
-                    null, // File
-                    null, // Scope
-                    0, // Line
+                    name,
+                    null, // file
+                    o.debug_compile_unit.unwrap().?, // scope
+                    0, // line
                     debug_elem_type,
                     ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
                     try o.builder.metadataTuple(&.{
                         try o.builder.debugSubrange(
                             try o.builder.metadataConstant(try o.builder.intConst(.i64, 0)),
@@ -2050,26 +2054,15 @@ pub const Object = struct {
             .optional => {
                 const payload_ty = ty.optionalChild(zcu);
                 if (ty.optionalReprIsPayload(zcu)) {
-                    // MLUGG TODO: these should use DW_TAG_typedef instead, but std.zig.llvm.Builder currently lacks support for those.
-                    const payload_member = try o.builder.debugMemberType(
-                        try o.builder.metadataString("payload"),
-                        null, // file
-                        ty_fwd_ref,
-                        0, // line
-                        try o.getDebugType(pt, .anyerror),
-                        ty.abiSize(zcu) * 8,
-                        ty.abiAlignment(zcu).toByteUnits().? * 8,
-                        0, // offset
-                    );
-                    return o.builder.debugStructType(
+                    return o.builder.debugTypedefType(
                         name,
                         null, // file
                         o.debug_compile_unit.unwrap().?, // scope
                         0, // line
-                        null, // underlying type
+                        try o.getDebugType(pt, payload_ty),
                         ty.abiSize(zcu) * 8,
                         ty.abiAlignment(zcu).toByteUnits().? * 8,
-                        try o.builder.metadataTuple(&.{payload_member}),
+                        0, // offset
                     );
                 }
 
@@ -2083,7 +2076,7 @@ pub const Object = struct {
                 const debug_payload_type = try o.builder.debugMemberType(
                     try o.builder.metadataString("payload"),
                     null, // file
-                    ty_fwd_ref,
+                    ty_fwd_ref, // scope
                     0, // line
                     try o.getDebugType(pt, payload_ty),
                     payload_size * 8,
@@ -2104,12 +2097,12 @@ pub const Object = struct {
 
                 return o.builder.debugStructType(
                     name,
-                    null, // File
-                    o.debug_compile_unit.unwrap().?, // Scope
-                    0, // Line
-                    null, // Underlying type
+                    null, // file
+                    o.debug_compile_unit.unwrap().?, // scope
+                    0, // line
+                    null, // underlying type
                     ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
+                    ty.abiAlignment(zcu).toByteUnits().? * 8,
                     try o.builder.metadataTuple(&.{
                         debug_payload_type,
                         debug_some_type,
@@ -2125,30 +2118,29 @@ pub const Object = struct {
                 const payload_size = payload_ty.abiSize(zcu);
                 const payload_align = payload_ty.abiAlignment(zcu);
 
-                const error_index: u1, const payload_index: u1, const error_offset: u64, const payload_offset: u64 = fields: {
+                const error_offset: u64, const payload_offset: u64 = offsets: {
                     if (error_align.compare(.gt, payload_align)) {
-                        break :fields .{ 0, 1, 0, payload_align.forward(error_size) };
+                        break :offsets .{ 0, payload_align.forward(error_size) };
                     } else {
-                        break :fields .{ 1, 0, error_align.forward(payload_size), 0 };
+                        break :offsets .{ error_align.forward(payload_size), 0 };
                     }
                 };
 
-                var fields: [2]Builder.Metadata = undefined;
-                fields[error_index] = try o.builder.debugMemberType(
+                const error_field = try o.builder.debugMemberType(
                     try o.builder.metadataString("error"),
-                    null, // File
+                    null, // file
                     ty_fwd_ref,
-                    0, // Line
+                    0, // line
                     try o.getDebugType(pt, error_ty),
                     error_size * 8,
                     error_align.toByteUnits().? * 8,
                     error_offset * 8,
                 );
-                fields[payload_index] = try o.builder.debugMemberType(
+                const payload_field = try o.builder.debugMemberType(
                     try o.builder.metadataString("payload"),
-                    null, // File
-                    ty_fwd_ref,
-                    0, // Line
+                    null, // file
+                    ty_fwd_ref, // scope
+                    0, // line
                     try o.getDebugType(pt, payload_ty),
                     payload_size * 8,
                     payload_align.toByteUnits().? * 8,
@@ -2163,33 +2155,22 @@ pub const Object = struct {
                     null, // Underlying type
                     ty.abiSize(zcu) * 8,
                     ty.abiAlignment(zcu).toByteUnits().? * 8,
-                    try o.builder.metadataTuple(&fields),
+                    try o.builder.metadataTuple(&.{ error_field, payload_field }),
                 );
             },
             .error_set => {
                 assert(ty.toIntern() != .anyerror_type); // handled specially in `updateConst`; will be populated by `emit` instead
                 // Error sets are just named wrappers around `anyerror`.
-                // MLUGG TODO: these should use DW_TAG_typedef instead, but std.zig.llvm.Builder currently lacks support for those.
-                const anyerror_member = try o.builder.debugMemberType(
-                    try o.builder.metadataString("error"),
+                return o.builder.debugTypedefType(
+                    name,
                     null, // file
-                    ty_fwd_ref,
+                    o.debug_compile_unit.unwrap().?, // scope
                     0, // line
                     try o.getDebugType(pt, .anyerror),
                     ty.abiSize(zcu) * 8,
                     ty.abiAlignment(zcu).toByteUnits().? * 8,
                     0, // offset
                 );
-                return o.builder.debugStructType(
-                    name,
-                    null, // file
-                    o.debug_compile_unit.unwrap().?, // scope
-                    0, // line
-                    null, // underlying type
-                    ty.abiSize(zcu) * 8,
-                    ty.abiAlignment(zcu).toByteUnits().? * 8,
-                    try o.builder.metadataTuple(&.{anyerror_member}),
-                );
             },
             .@"fn" => {
                 if (!ty.fnHasRuntimeBits(zcu)) {
@@ -2570,14 +2551,22 @@ pub const Object = struct {
         const error_set_bits = zcu.errorSetBits();
         const error_names = ip.global_error_set.getNamesFromMainThread();
 
-        const enumerators = try gpa.alloc(Builder.Metadata, error_names.len);
+        const enumerators = try gpa.alloc(Builder.Metadata, error_names.len + 1);
         defer gpa.free(enumerators);
 
-        for (enumerators, error_names, 1..) |*out, error_name, error_value| {
+        // The value 0 means "no error" in optionals and error unions.
+        enumerators[0] = try o.builder.debugEnumerator(
+            try o.builder.metadataString("null"),
+            true, // unsigned,
+            error_set_bits,
+            .{ .limbs = &.{0}, .positive = true }, // zero
+        );
+
+        for (enumerators[1..], error_names, 1..) |*out, error_name, error_value| {
             var space: Value.BigIntSpace = undefined;
             var bigint: std.math.big.int.Mutable = .init(&space.limbs, error_value);
             out.* = try o.builder.debugEnumerator(
-                try o.builder.metadataString(error_name.toSlice(ip)),
+                try o.builder.metadataStringFmt("error.{f}", .{error_name.fmtId(ip)}),
                 true, // unsigned
                 error_set_bits,
                 bigint.toConst(),
@@ -3452,84 +3441,6 @@ pub const Object = struct {
         );
     }
 
-    fn lowerValueToInt(o: *Object, pt: Zcu.PerThread, llvm_int_ty: Builder.Type, arg_val: InternPool.Index) Error!Builder.Constant {
-        const zcu = pt.zcu;
-        const ip = &zcu.intern_pool;
-        const target = zcu.getTarget();
-
-        const val = Value.fromInterned(arg_val);
-        const val_key = ip.indexToKey(val.toIntern());
-
-        if (val.isUndef(zcu)) return o.builder.undefConst(llvm_int_ty);
-
-        const ty = Type.fromInterned(val_key.typeOf());
-        switch (val_key) {
-            .@"extern" => |@"extern"| {
-                const function_index = try o.resolveLlvmFunction(pt, @"extern".owner_nav);
-                const ptr = function_index.ptrConst(&o.builder).global.toConst();
-                return o.builder.convConst(ptr, llvm_int_ty);
-            },
-            .func => |func| {
-                const function_index = try o.resolveLlvmFunction(pt, func.owner_nav);
-                const ptr = function_index.ptrConst(&o.builder).global.toConst();
-                return o.builder.convConst(ptr, llvm_int_ty);
-            },
-            .ptr => return o.builder.convConst(try o.lowerPtr(pt, arg_val, 0), llvm_int_ty),
-            .aggregate => switch (ip.indexToKey(ty.toIntern())) {
-                .struct_type, .vector_type => {},
-                else => unreachable,
-            },
-            .un => |un| {
-                const layout = ty.unionGetLayout(zcu);
-                if (layout.payload_size == 0) return o.lowerValue(pt, un.tag);
-
-                const union_obj = zcu.typeToUnion(ty).?;
-                const container_layout = union_obj.layout;
-
-                assert(container_layout == .@"packed");
-
-                var need_unnamed = false;
-                if (un.tag == .none) {
-                    assert(layout.tag_size == 0);
-                    const union_val = try o.lowerValueToInt(pt, llvm_int_ty, un.val);
-
-                    need_unnamed = true;
-                    return union_val;
-                }
-                const field_index = zcu.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
-                const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-                if (!field_ty.hasRuntimeBits(zcu)) return o.builder.intConst(llvm_int_ty, 0);
-                return o.lowerValueToInt(pt, llvm_int_ty, un.val);
-            },
-            .simple_value => |simple_value| switch (simple_value) {
-                .false, .true => {},
-                else => unreachable,
-            },
-            .int,
-            .float,
-            .enum_tag,
-            => {},
-            .opt => {}, // pointer like optional expected
-            else => unreachable,
-        }
-        var stack = std.heap.stackFallback(32, o.gpa);
-        const allocator = stack.get();
-
-        const bits: usize = @intCast(ty.bitSize(zcu));
-
-        const buffer = try allocator.alloc(u8, (bits + 7) / 8);
-        defer allocator.free(buffer);
-        const limbs = try allocator.alloc(std.math.big.Limb, std.math.big.int.calcTwosCompLimbCount(bits));
-        defer allocator.free(limbs);
-
-        val.writeToPackedMemory(pt, buffer, 0) catch unreachable;
-
-        var big: std.math.big.int.Mutable = .init(limbs, 0);
-        big.readTwosComplement(buffer, bits, target.cpu.arch.endian(), .unsigned);
-
-        return o.builder.bigIntConst(llvm_int_ty, big.toConst());
-    }
-
     fn lowerValue(o: *Object, pt: Zcu.PerThread, arg_val: InternPool.Index) Error!Builder.Constant {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
-- 
2.54.0


From 5cc12da1c0b9e516e356d4d13c48ae671d2e17ff Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 19 Feb 2026 13:05:25 +0000
Subject: [PATCH 461/499] cbe: rework CType and other major refactors

The goal of these changes is to allow the C backend to support the new
lazier type resolution system implemented by the frontend. This required
a full rewrite of the `CType` abstraction, and major changes to the C
backend "linker".

The `DebugConstPool` abstraction introduced in a previous commit turns
out to be useful for the C backend to codegen types. Because this use
case is not debug information but rather general linking (albeit when
targeting an unusual object format), I have renamed the abstraction to
`ConstPool`. With it, the C linker is told when a type's layout becomes
known, and can at that point generate the corresponding C definitions,
rather than deferring this work until `flush`.

The work done in `flush` is now more-or-less *solely* focused on
collecting all of the buffers into a big array for a vectored write.
This does unfortunately involve a non-trivial graph traversal to emit
type definitions in an appropriate order, but it's still quite fast in
practice, and it operates on fairly compact dependency data. We don't
generate the actual type *definitions* in `flush`; that happens during
compilation using `ConstPool` as discussed above. (We do generate the
typedefs for underaligned types in `flush`, but that's a trivial amount
of work in most cases.)

`CType` is now an ephemeral type: it is created only when we render a
type (the logic for which has been pushed into just 2 or 3 functions in
`codegen.c`---most of the backend now operates on unmolested Zig `Type`s
instead). C types are no longer stored in a "pool", although the type
"dependencies" of generated C code (that is, the struct, unions, and
typedefs which the generated code references) are tracked (in some
simple hash sets) and given to the linker so it can codegen the types.
---
 lib/zig.h                                     |    2 +-
 src/Compilation.zig                           |    3 -
 src/InternPool.zig                            |    2 +-
 src/Type.zig                                  |    4 +-
 src/Value.zig                                 |    8 +-
 src/Zcu.zig                                   |    4 +-
 src/codegen/c.zig                             | 5289 +++++++----------
 src/codegen/c/Type.zig                        | 3471 -----------
 src/codegen/c/type.zig                        | 1013 ++++
 src/codegen/c/type/render_defs.zig            |  651 ++
 src/codegen/llvm.zig                          |   32 +-
 src/link.zig                                  |    4 +-
 src/link/C.zig                                | 1891 ++++--
 .../{DebugConstPool.zig => ConstPool.zig}     |   70 +-
 src/link/Dwarf.zig                            |   37 +-
 src/link/Elf.zig                              |   11 -
 16 files changed, 5299 insertions(+), 7193 deletions(-)
 delete mode 100644 src/codegen/c/Type.zig
 create mode 100644 src/codegen/c/type.zig
 create mode 100644 src/codegen/c/type/render_defs.zig
 rename src/link/{DebugConstPool.zig => ConstPool.zig} (83%)

diff --git a/lib/zig.h b/lib/zig.h
index 81a815ab5568b57f5d48c8da91a04b761d4f9a2a..f8744966c68276a8e160e77eb186d08f54caa8cb 100644
--- a/lib/zig.h
+++ b/lib/zig.h
@@ -259,7 +259,7 @@
 #endif
 
 #if zig_has_attribute(packed) || defined(zig_tinyc)
-#define zig_packed(definition) __attribute__((packed)) definition
+#define zig_packed(definition) definition __attribute__((packed))
 #elif defined(zig_msvc)
 #define zig_packed(definition) __pragma(pack(1)) definition __pragma(pack())
 #else
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 45d0aa6e97fbb735127efa5f1d399731d6bde4a6..a4e712826d4a04f3ca0e6f15475def928a3562ad 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3382,9 +3382,6 @@ fn flush(comp: *Compilation, arena: Allocator, tid: Zcu.PerThread.Id) (Io.Cancel
             error.OutOfMemory, error.Canceled => |e| return e,
         };
     }
-    if (comp.zcu) |zcu| {
-        try link.File.C.flushEmitH(zcu);
-    }
 }
 
 /// This function is called by the frontend before flush(). It communicates that
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 388d0a04f74fd88f6b479395044c84a90d351469..ffabc7371b0c9d7221475b966fa059eccf275a48 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -3403,7 +3403,7 @@ pub const LoadedStructType = struct {
     /// Iterates over non-comptime fields in the order they are laid out in memory at runtime.
     /// May or may not include zero-bit fields.
     /// Asserts the struct is not packed.
-    pub fn iterateRuntimeOrder(s: *const LoadedStructType, ip: *InternPool) RuntimeOrderIterator {
+    pub fn iterateRuntimeOrder(s: *const LoadedStructType, ip: *const InternPool) RuntimeOrderIterator {
         switch (s.layout) {
             .auto => {
                 const ro = std.mem.sliceTo(s.field_runtime_order.get(ip), .omitted);
diff --git a/src/Type.zig b/src/Type.zig
index 0fe87e983b065cb43124eb1b6adc5b7c0a4888cd..1eab734882f8d25b246e4bc754004d4ca2397e39 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -789,7 +789,7 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
 /// Determines whether a function type has runtime bits, i.e. whether a
 /// function with this type can exist at runtime.
 /// Asserts that `ty` is a function type.
-pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *Zcu) bool {
+pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *const Zcu) bool {
     assertHasLayout(fn_ty, zcu);
     const fn_info = zcu.typeToFunc(fn_ty).?;
     if (fn_info.comptime_bits != 0) return false;
@@ -830,7 +830,7 @@ pub fn fnHasRuntimeBits(fn_ty: Type, zcu: *Zcu) bool {
 }
 
 /// Like `hasRuntimeBits`, but also returns `true` for runtime functions.
-pub fn isRuntimeFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
+pub fn isRuntimeFnOrHasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
     switch (ty.zigTypeTag(zcu)) {
         .@"fn" => return ty.fnHasRuntimeBits(zcu),
         else => return ty.hasRuntimeBits(zcu),
diff --git a/src/Value.zig b/src/Value.zig
index cf8d0acc67377b3a871fe15cbd55cac4d0ef7221..6a474c282133e10e15cfdd423b309df986bbf034 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -151,7 +151,7 @@ pub fn intFromEnum(val: Value, zcu: *const Zcu) Value {
 }
 
 /// Asserts that `val` is an integer.
-pub fn toBigInt(val: Value, space: *BigIntSpace, zcu: *Zcu) BigIntConst {
+pub fn toBigInt(val: Value, space: *BigIntSpace, zcu: *const Zcu) BigIntConst {
     if (val.getUnsignedInt(zcu)) |x| {
         return BigIntMutable.init(&space.limbs, x).toConst();
     }
@@ -669,7 +669,7 @@ pub fn floatCast(val: Value, dest_ty: Type, pt: Zcu.PerThread) !Value {
 }
 
 /// Asserts the value is comparable. Supports comparisons between heterogeneous types.
-pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value, zcu: *Zcu) bool {
+pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value, zcu: *const Zcu) bool {
     if (lhs.pointerNav(zcu)) |lhs_nav| {
         if (rhs.pointerNav(zcu)) |rhs_nav| {
             switch (op) {
@@ -695,7 +695,7 @@ pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value, zcu:
     return order(lhs, rhs, zcu).compare(op);
 }
 
-pub fn order(lhs: Value, rhs: Value, zcu: *Zcu) std.math.Order {
+pub fn order(lhs: Value, rhs: Value, zcu: *const Zcu) std.math.Order {
     if (lhs.isFloat(zcu) or rhs.isFloat(zcu)) {
         const lhs_f128 = lhs.toFloat(f128, zcu);
         const rhs_f128 = rhs.toFloat(f128, zcu);
@@ -805,7 +805,7 @@ pub fn canMutateComptimeVarState(val: Value, zcu: *Zcu) bool {
 /// Gets the `Nav` referenced by this pointer.  If the pointer does not point
 /// to a `Nav`, or if it points to some part of one (like a field or element),
 /// returns null.
-pub fn pointerNav(val: Value, zcu: *Zcu) ?InternPool.Nav.Index {
+pub fn pointerNav(val: Value, zcu: *const Zcu) ?InternPool.Nav.Index {
     return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
         // TODO: these 3 cases are weird; these aren't pointer values!
         .variable => |v| v.owner_nav,
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 481ea0d62ad312d3a0e9ce5f6d84f8ea13635841..faa535da5d6e12ae12c1ba6aaed1341fde2147d6 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4113,13 +4113,13 @@ pub const ResolvedReference = struct {
 /// If an `AnalUnit` is not in the returned map, it is unreferenced.
 /// The returned hashmap is owned by the `Zcu`, so should not be freed by the caller.
 /// This hashmap is cached, so repeated calls to this function are cheap.
-pub fn resolveReferences(zcu: *Zcu) !*const std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
+pub fn resolveReferences(zcu: *Zcu) Allocator.Error!*const std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
     if (zcu.resolved_references == null) {
         zcu.resolved_references = try zcu.resolveReferencesInner();
     }
     return &zcu.resolved_references.?;
 }
-fn resolveReferencesInner(zcu: *Zcu) !std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
+fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
     const gpa = zcu.gpa;
     const comp = zcu.comp;
     const ip = &zcu.intern_pool;
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index c8904405e218072fc80d8753603c1e0689022f25..b31b0a40da9a5c9663bf7d3392bef966e6eed1a9 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -50,32 +50,39 @@ pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features {
 /// * The types used, so declarations can be emitted in `flush`
 /// * The lazy functions used, so definitions can be emitted in `flush`
 pub const Mir = struct {
-    /// This map contains all the UAVs we saw generating this function.
-    /// `link.C` will merge them into its `uavs`/`aligned_uavs` fields.
-    /// Key is the value of the UAV; value is the UAV's alignment, or
-    /// `.none` for natural alignment. The specified alignment is never
-    /// less than the natural alignment.
-    uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
     // These remaining fields are essentially just an owned version of `link.C.AvBlock`.
+    fwd_decl: []u8,
     code_header: []u8,
     code: []u8,
-    fwd_decl: []u8,
-    ctype_pool: CType.Pool,
-    lazy_fns: LazyFnMap,
+    /// This map contains all the UAVs we saw generating this function.
+    /// `link.C` will merge them into its `uavs`/`aligned_uavs` fields.
+    /// Key is the value of the UAV; value is the UAV's alignment, or
+    /// `.none` for natural alignment. The specified alignment is never
+    /// less than the natural alignment.
+    need_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
+    ctype_deps: CType.Dependencies,
+    /// Key is an enum type for which we need a generated `@tagName` function.
+    need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+    /// Key is a function Nav for which we need a generated `zig_never_tail` wrapper.
+    need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
+    /// Key is a function Nav for which we need a generated `zig_never_inline` wrapper.
+    need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
 
     pub fn deinit(mir: *Mir, gpa: Allocator) void {
-        mir.uavs.deinit(gpa);
+        gpa.free(mir.fwd_decl);
         gpa.free(mir.code_header);
         gpa.free(mir.code);
-        gpa.free(mir.fwd_decl);
-        mir.ctype_pool.deinit(gpa);
-        mir.lazy_fns.deinit(gpa);
+        mir.need_uavs.deinit(gpa);
+        mir.ctype_deps.deinit(gpa);
+        mir.need_tag_name_funcs.deinit(gpa);
+        mir.need_never_tail_funcs.deinit(gpa);
+        mir.need_never_inline_funcs.deinit(gpa);
     }
 };
 
-pub const Error = Writer.Error || std.mem.Allocator.Error || error{AnalysisFail};
+pub const Error = Writer.Error || Allocator.Error || error{AnalysisFail};
 
-pub const CType = @import("c/Type.zig");
+pub const CType = @import("c/type.zig").CType;
 
 pub const CValue = union(enum) {
     none: void,
@@ -87,8 +94,6 @@ pub const CValue = union(enum) {
     constant: Value,
     /// Index into the parameters
     arg: usize,
-    /// The array field of a parameter
-    arg_array: usize,
     /// Index into a tuple's fields
     field: usize,
     /// By-value
@@ -100,8 +105,6 @@ pub const CValue = union(enum) {
     identifier: []const u8,
     /// Rendered as "payload." followed by as identifier (using fmtIdent)
     payload_identifier: []const u8,
-    /// Rendered with fmtCTypePoolString
-    ctype_pool_string: CType.Pool.String,
 
     fn eql(lhs: CValue, rhs: CValue) bool {
         return switch (lhs) {
@@ -122,10 +125,6 @@ pub const CValue = union(enum) {
                 .arg => |rhs_arg_index| lhs_arg_index == rhs_arg_index,
                 else => false,
             },
-            .arg_array => |lhs_arg_index| switch (rhs) {
-                .arg_array => |rhs_arg_index| lhs_arg_index == rhs_arg_index,
-                else => false,
-            },
             .field => |lhs_field_index| switch (rhs) {
                 .field => |rhs_field_index| lhs_field_index == rhs_field_index,
                 else => false,
@@ -150,10 +149,6 @@ pub const CValue = union(enum) {
                 .payload_identifier => |rhs_id| std.mem.eql(u8, lhs_id, rhs_id),
                 else => false,
             },
-            .ctype_pool_string => |lhs_str| switch (rhs) {
-                .ctype_pool_string => |rhs_str| lhs_str.index == rhs_str.index,
-                else => false,
-            },
         };
     }
 };
@@ -163,53 +158,24 @@ const BlockData = struct {
     result: CValue,
 };
 
-pub const CValueMap = std.AutoHashMap(Air.Inst.Ref, CValue);
-
-pub const LazyFnKey = union(enum) {
-    tag_name: InternPool.Index,
-    never_tail: InternPool.Nav.Index,
-    never_inline: InternPool.Nav.Index,
-};
-pub const LazyFnValue = struct {
-    fn_name: CType.Pool.String,
-};
-pub const LazyFnMap = std.AutoArrayHashMapUnmanaged(LazyFnKey, LazyFnValue);
-
-const Local = struct {
-    ctype: CType,
-    flags: packed struct(u32) {
-        alignas: CType.AlignAs,
-        _: u20 = undefined,
-    },
-
-    fn getType(local: Local) LocalType {
-        return .{ .ctype = local.ctype, .alignas = local.flags.alignas };
-    }
+const LocalType = struct {
+    type: Type,
+    alignment: Alignment,
 };
 
 const LocalIndex = u16;
-const LocalType = struct { ctype: CType, alignas: CType.AlignAs };
 const LocalsList = std.AutoArrayHashMapUnmanaged(LocalIndex, void);
 const LocalsMap = std.AutoArrayHashMapUnmanaged(LocalType, LocalsList);
 
 const ValueRenderLocation = enum {
-    FunctionArgument,
-    Initializer,
-    StaticInitializer,
-    Other,
+    initializer,
+    static_initializer,
+    other,
 
     fn isInitializer(loc: ValueRenderLocation) bool {
         return switch (loc) {
-            .Initializer, .StaticInitializer => true,
-            else => false,
-        };
-    }
-
-    fn toCTypeKind(loc: ValueRenderLocation) CType.Kind {
-        return switch (loc) {
-            .FunctionArgument => .parameter,
-            .Initializer, .Other => .complete,
-            .StaticInitializer => .global,
+            .initializer, .static_initializer => true,
+            .other => false,
         };
     }
 };
@@ -334,16 +300,31 @@ const reserved_idents = std.StaticStringMap(void).initComptime(.{
 });
 
 fn isReservedIdent(ident: []const u8) bool {
-    if (ident.len >= 2 and ident[0] == '_') { // C language
+    // C language
+    if (ident.len >= 2 and ident[0] == '_') {
         switch (ident[1]) {
             'A'...'Z', '_' => return true,
-            else => return false,
+            else => {},
         }
-    } else if (mem.startsWith(u8, ident, "DUMMYSTRUCTNAME") or
+    }
+
+    // windows.h
+    if (mem.startsWith(u8, ident, "DUMMYSTRUCTNAME") or
         mem.startsWith(u8, ident, "DUMMYUNIONNAME"))
-    { // windows.h
+    {
         return true;
-    } else return reserved_idents.has(ident);
+    }
+
+    // CType
+    if (mem.startsWith(u8, ident, "enum__") or
+        mem.startsWith(u8, ident, "bitpack__") or
+        mem.startsWith(u8, ident, "aligned__") or
+        mem.startsWith(u8, ident, "fn__"))
+    {
+        return true;
+    }
+
+    return reserved_idents.has(ident);
 }
 
 fn formatIdentSolo(ident: []const u8, w: *Writer) Writer.Error!void {
@@ -361,7 +342,7 @@ fn formatIdentOptions(ident: []const u8, w: *Writer, solo: bool) Writer.Error!vo
     for (ident, 0..) |c, i| {
         switch (c) {
             'a'...'z', 'A'...'Z', '_' => try w.writeByte(c),
-            '.' => try w.writeByte('_'),
+            '.', ' ' => try w.writeByte('_'),
             '0'...'9' => if (i == 0) {
                 try w.print("_{x:2}", .{c});
             } else {
@@ -380,29 +361,6 @@ pub fn fmtIdentUnsolo(ident: []const u8) std.fmt.Alt([]const u8, formatIdentUnso
     return .{ .data = ident };
 }
 
-const CTypePoolStringFormatData = struct {
-    ctype_pool_string: CType.Pool.String,
-    ctype_pool: *const CType.Pool,
-    solo: bool,
-};
-fn formatCTypePoolString(data: CTypePoolStringFormatData, w: *Writer) Writer.Error!void {
-    if (data.ctype_pool_string.toSlice(data.ctype_pool)) |slice|
-        try formatIdentOptions(slice, w, data.solo)
-    else
-        try w.print("{f}", .{data.ctype_pool_string.fmt(data.ctype_pool)});
-}
-pub fn fmtCTypePoolString(
-    ctype_pool_string: CType.Pool.String,
-    ctype_pool: *const CType.Pool,
-    solo: bool,
-) std.fmt.Alt(CTypePoolStringFormatData, formatCTypePoolString) {
-    return .{ .data = .{
-        .ctype_pool_string = ctype_pool_string,
-        .ctype_pool = ctype_pool,
-        .solo = solo,
-    } };
-}
-
 // Returns true if `formatIdent` would make any edits to ident.
 // This must be kept in sync with `formatIdent`.
 pub fn isMangledIdent(ident: []const u8, solo: bool) bool {
@@ -417,21 +375,26 @@ pub fn isMangledIdent(ident: []const u8, solo: bool) bool {
     return false;
 }
 
-/// This data is available when outputting .c code for a `InternPool.Index`
-/// that corresponds to `func`.
-/// It is not available when generating .h file.
+/// This data is available when rendering C source code for an interned function.
 pub const Function = struct {
     air: Air,
     liveness: Air.Liveness,
-    value_map: CValueMap,
+    value_map: std.AutoHashMap(Air.Inst.Ref, CValue),
     blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, BlockData) = .empty,
     next_arg_index: u32 = 0,
     next_block_index: u32 = 0,
-    object: Object,
-    lazy_fns: LazyFnMap,
+    dg: DeclGen,
+    code: Writer.Allocating,
+    indent_counter: usize,
+    /// Key is an enum type for which we need a generated `@tagName` function.
+    need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+    /// Key is a function Nav for which we need a generated `zig_never_tail` wrapper.
+    need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
+    /// Key is a function Nav for which we need a generated `zig_never_inline` wrapper.
+    need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
     func_index: InternPool.Index,
     /// All the locals, to be emitted at the top of the function.
-    locals: std.ArrayList(Local) = .empty,
+    locals: std.ArrayList(LocalType) = .empty,
     /// Which locals are available for reuse, based on Type.
     free_locals_map: LocalsMap = .{},
     /// Locals which will not be freed by Liveness. This is used after a
@@ -445,37 +408,41 @@ pub const Function = struct {
     /// for the switch cond. Dispatches should set this local to the new cond.
     loop_switch_conds: std.AutoHashMapUnmanaged(Air.Inst.Index, LocalIndex) = .empty,
 
+    const indent_width = 1;
+    const indent_char = ' ';
+
+    fn newline(f: *Function) !void {
+        const w = &f.code.writer;
+        try w.writeByte('\n');
+        try w.splatByteAll(indent_char, f.indent_counter);
+    }
+    fn indent(f: *Function) void {
+        f.indent_counter += indent_width;
+    }
+    fn outdent(f: *Function) !void {
+        f.indent_counter -= indent_width;
+        const written = f.code.written();
+        switch (written[written.len - 1]) {
+            indent_char => f.code.shrinkRetainingCapacity(written.len - indent_width),
+            '\n' => try f.code.writer.splatByteAll(indent_char, f.indent_counter),
+            else => {
+                std.debug.print("\"{f}\"\n", .{std.zig.fmtString(written[written.len -| 100..])});
+                unreachable;
+            },
+        }
+    }
+
     fn resolveInst(f: *Function, ref: Air.Inst.Ref) !CValue {
         const gop = try f.value_map.getOrPut(ref);
-        if (gop.found_existing) return gop.value_ptr.*;
-
-        const pt = f.object.dg.pt;
-        const zcu = pt.zcu;
-        const val = (try f.air.value(ref, pt)).?;
-        const ty = f.typeOf(ref);
-
-        const result: CValue = if (lowersToArray(ty, zcu)) result: {
-            const ch = &f.object.code_header.writer;
-            const decl_c_value = try f.allocLocalValue(.{
-                .ctype = try f.ctypeFromType(ty, .complete),
-                .alignas = CType.AlignAs.fromAbiAlignment(ty.abiAlignment(zcu)),
-            });
-            const gpa = f.object.dg.gpa;
-            try f.allocs.put(gpa, decl_c_value.new_local, false);
-            try ch.writeAll("static ");
-            try f.object.dg.renderTypeAndName(ch, ty, decl_c_value, Const, .none, .complete);
-            try ch.writeAll(" = ");
-            try f.object.dg.renderValue(ch, val, .StaticInitializer);
-            try ch.writeAll(";\n ");
-            break :result .{ .local = decl_c_value.new_local };
-        } else .{ .constant = val };
-
-        gop.value_ptr.* = result;
-        return result;
+        if (!gop.found_existing) {
+            const val = try f.air.value(ref, f.dg.pt);
+            gop.value_ptr.* = .{ .constant = val.? };
+        }
+        return gop.value_ptr.*;
     }
 
     fn wantSafety(f: *Function) bool {
-        return switch (f.object.dg.pt.zcu.optimizeMode()) {
+        return switch (f.dg.pt.zcu.optimizeMode()) {
             .Debug, .ReleaseSafe => true,
             .ReleaseFast, .ReleaseSmall => false,
         };
@@ -485,18 +452,16 @@ pub const Function = struct {
     /// those which go into `allocs`. This function does not add the resulting local into `allocs`;
     /// that responsibility lies with the caller.
     fn allocLocalValue(f: *Function, local_type: LocalType) !CValue {
-        try f.locals.ensureUnusedCapacity(f.object.dg.gpa, 1);
-        defer f.locals.appendAssumeCapacity(.{
-            .ctype = local_type.ctype,
-            .flags = .{ .alignas = local_type.alignas },
-        });
-        return .{ .new_local = @intCast(f.locals.items.len) };
+        try f.locals.ensureUnusedCapacity(f.dg.gpa, 1);
+        const index = f.locals.items.len;
+        f.locals.appendAssumeCapacity(local_type);
+        return .{ .new_local = @intCast(index) };
     }
 
     fn allocLocal(f: *Function, inst: ?Air.Inst.Index, ty: Type) !CValue {
         return f.allocAlignedLocal(inst, .{
-            .ctype = try f.ctypeFromType(ty, .complete),
-            .alignas = CType.AlignAs.fromAbiAlignment(ty.abiAlignment(f.object.dg.pt.zcu)),
+            .type = ty,
+            .alignment = .none,
         });
     }
 
@@ -524,11 +489,10 @@ pub const Function = struct {
             .none => unreachable,
             .new_local, .local => |i| try w.print("t{d}", .{i}),
             .local_ref => |i| try w.print("&t{d}", .{i}),
-            .constant => |val| try f.object.dg.renderValue(w, val, location),
+            .constant => |val| try f.dg.renderValue(w, val, location),
             .arg => |i| try w.print("a{d}", .{i}),
-            .arg_array => |i| try f.writeCValueMember(w, .{ .arg = i }, .{ .identifier = "array" }),
-            .undef => |ty| try f.object.dg.renderUndefValue(w, ty, location),
-            else => try f.object.dg.writeCValue(w, c_value),
+            .undef => |ty| try f.dg.renderUndefValue(w, ty, location),
+            else => try f.dg.writeCValue(w, c_value),
         }
     }
 
@@ -537,17 +501,12 @@ pub const Function = struct {
             .none => unreachable,
             .new_local, .local, .constant => {
                 try w.writeAll("(*");
-                try f.writeCValue(w, c_value, .Other);
+                try f.writeCValue(w, c_value, .other);
                 try w.writeByte(')');
             },
             .local_ref => |i| try w.print("t{d}", .{i}),
             .arg => |i| try w.print("(*a{d})", .{i}),
-            .arg_array => |i| {
-                try w.writeAll("(*");
-                try f.writeCValueMember(w, .{ .arg = i }, .{ .identifier = "array" });
-                try w.writeByte(')');
-            },
-            else => try f.object.dg.writeCValueDeref(w, c_value),
+            else => try f.dg.writeCValueDeref(w, c_value),
         }
     }
 
@@ -558,119 +517,77 @@ pub const Function = struct {
         member: CValue,
     ) Error!void {
         switch (c_value) {
-            .new_local, .local, .local_ref, .constant, .arg, .arg_array => {
-                try f.writeCValue(w, c_value, .Other);
+            .new_local, .local, .local_ref, .constant, .arg => {
+                try f.writeCValue(w, c_value, .other);
                 try w.writeByte('.');
-                try f.writeCValue(w, member, .Other);
+                try f.writeCValue(w, member, .other);
             },
-            else => return f.object.dg.writeCValueMember(w, c_value, member),
+            else => return f.dg.writeCValueMember(w, c_value, member),
         }
     }
 
     fn writeCValueDerefMember(f: *Function, w: *Writer, c_value: CValue, member: CValue) !void {
         switch (c_value) {
-            .new_local, .local, .arg, .arg_array => {
-                try f.writeCValue(w, c_value, .Other);
+            .new_local, .local, .arg => {
+                try f.writeCValue(w, c_value, .other);
                 try w.writeAll("->");
             },
             .constant => {
                 try w.writeByte('(');
-                try f.writeCValue(w, c_value, .Other);
+                try f.writeCValue(w, c_value, .other);
                 try w.writeAll(")->");
             },
             .local_ref => {
                 try f.writeCValueDeref(w, c_value);
                 try w.writeByte('.');
             },
-            else => return f.object.dg.writeCValueDerefMember(w, c_value, member),
+            else => return f.dg.writeCValueDerefMember(w, c_value, member),
         }
-        try f.writeCValue(w, member, .Other);
+        try f.writeCValue(w, member, .other);
     }
 
     fn fail(f: *Function, comptime format: []const u8, args: anytype) Error {
-        return f.object.dg.fail(format, args);
+        return f.dg.fail(format, args);
     }
 
-    fn ctypeFromType(f: *Function, ty: Type, kind: CType.Kind) !CType {
-        return f.object.dg.ctypeFromType(ty, kind);
-    }
-
-    fn byteSize(f: *Function, ctype: CType) u64 {
-        return f.object.dg.byteSize(ctype);
-    }
-
-    fn renderType(f: *Function, w: *Writer, ctype: Type) !void {
-        return f.object.dg.renderType(w, ctype);
-    }
-
-    fn renderCType(f: *Function, w: *Writer, ctype: CType) !void {
-        return f.object.dg.renderCType(w, ctype);
+    fn renderType(f: *Function, w: *Writer, ty: Type) !void {
+        return f.dg.renderType(w, ty);
     }
 
     fn renderIntCast(f: *Function, w: *Writer, dest_ty: Type, src: CValue, v: Vectorize, src_ty: Type, location: ValueRenderLocation) !void {
-        return f.object.dg.renderIntCast(w, dest_ty, .{ .c_value = .{ .f = f, .value = src, .v = v } }, src_ty, location);
+        return f.dg.renderIntCast(w, dest_ty, .{ .c_value = .{ .f = f, .value = src, .v = v } }, src_ty, location);
     }
 
     fn fmtIntLiteralDec(f: *Function, val: Value) !std.fmt.Alt(FormatIntLiteralContext, formatIntLiteral) {
-        return f.object.dg.fmtIntLiteralDec(val, .Other);
+        return f.dg.fmtIntLiteralDec(val, .other);
     }
 
     fn fmtIntLiteralHex(f: *Function, val: Value) !std.fmt.Alt(FormatIntLiteralContext, formatIntLiteral) {
-        return f.object.dg.fmtIntLiteralHex(val, .Other);
-    }
-
-    fn getLazyFnName(f: *Function, key: LazyFnKey) ![]const u8 {
-        const gpa = f.object.dg.gpa;
-        const pt = f.object.dg.pt;
-        const zcu = pt.zcu;
-        const ip = &zcu.intern_pool;
-        const ctype_pool = &f.object.dg.ctype_pool;
-
-        const gop = try f.lazy_fns.getOrPut(gpa, key);
-        if (!gop.found_existing) {
-            errdefer _ = f.lazy_fns.pop();
-
-            gop.value_ptr.* = .{
-                .fn_name = switch (key) {
-                    .tag_name,
-                    => |enum_ty| try ctype_pool.fmt(gpa, "zig_{s}_{f}__{d}", .{
-                        @tagName(key),
-                        fmtIdentUnsolo(ip.loadEnumType(enum_ty).name.toSlice(ip)),
-                        @intFromEnum(enum_ty),
-                    }),
-                    .never_tail,
-                    .never_inline,
-                    => |owner_nav| try ctype_pool.fmt(gpa, "zig_{s}_{f}__{d}", .{
-                        @tagName(key),
-                        fmtIdentUnsolo(ip.getNav(owner_nav).name.toSlice(ip)),
-                        @intFromEnum(owner_nav),
-                    }),
-                },
-            };
-        }
-        return gop.value_ptr.fn_name.toSlice(ctype_pool).?;
+        return f.dg.fmtIntLiteralHex(val, .other);
     }
 
     pub fn deinit(f: *Function) void {
-        const gpa = f.object.dg.gpa;
+        const gpa = f.dg.gpa;
         f.allocs.deinit(gpa);
         f.locals.deinit(gpa);
         deinitFreeLocalsMap(gpa, &f.free_locals_map);
         f.blocks.deinit(gpa);
         f.value_map.deinit();
-        f.lazy_fns.deinit(gpa);
+        f.need_tag_name_funcs.deinit(gpa);
+        f.need_never_tail_funcs.deinit(gpa);
+        f.need_never_inline_funcs.deinit(gpa);
         f.loop_switch_conds.deinit(gpa);
     }
 
     fn typeOf(f: *Function, inst: Air.Inst.Ref) Type {
-        return f.air.typeOf(inst, &f.object.dg.pt.zcu.intern_pool);
+        return f.air.typeOf(inst, &f.dg.pt.zcu.intern_pool);
     }
 
     fn typeOfIndex(f: *Function, inst: Air.Inst.Index) Type {
-        return f.air.typeOfIndex(inst, &f.object.dg.pt.zcu.intern_pool);
+        return f.air.typeOfIndex(inst, &f.dg.pt.zcu.intern_pool);
     }
 
-    fn copyCValue(f: *Function, ctype: CType, dst: CValue, src: CValue) !void {
+    fn copyCValue(f: *Function, dst: CValue, src: CValue) !void {
         switch (dst) {
             .new_local, .local => |dst_local_index| switch (src) {
                 .new_local, .local => |src_local_index| if (dst_local_index == src_local_index) return,
@@ -678,12 +595,12 @@ pub const Function = struct {
             },
             else => {},
         }
-        const w = &f.object.code.writer;
-        const a = try Assignment.start(f, w, ctype);
-        try f.writeCValue(w, dst, .Other);
-        try a.assign(f, w);
-        try f.writeCValue(w, src, .Other);
-        try a.end(f, w);
+        const w = &f.code.writer;
+        try f.writeCValue(w, dst, .other);
+        try w.writeAll(" = ");
+        try f.writeCValue(w, src, .other);
+        try w.writeByte(';');
+        try f.newline();
     }
 
     fn moveCValue(f: *Function, inst: Air.Inst.Index, ty: Type, src: CValue) !CValue {
@@ -694,7 +611,7 @@ pub const Function = struct {
             else => {
                 try freeCValue(f, inst, src);
                 const dst = try f.allocLocal(inst, ty);
-                try f.copyCValue(try f.ctypeFromType(ty, .complete), dst, src);
+                try f.copyCValue(dst, src);
                 return dst;
             },
         }
@@ -708,51 +625,17 @@ pub const Function = struct {
     }
 };
 
-/// This data is available when outputting .c code for a `Zcu`.
-/// It is not available when generating .h file.
-pub const Object = struct {
-    dg: DeclGen,
-    code_header: Writer.Allocating,
-    code: Writer.Allocating,
-    indent_counter: usize,
-
-    const indent_width = 1;
-    const indent_char = ' ';
-
-    fn newline(o: *Object) !void {
-        const w = &o.code.writer;
-        try w.writeByte('\n');
-        try w.splatByteAll(indent_char, o.indent_counter);
-    }
-    fn indent(o: *Object) void {
-        o.indent_counter += indent_width;
-    }
-    fn outdent(o: *Object) !void {
-        o.indent_counter -= indent_width;
-        const written = o.code.written();
-        switch (written[written.len - 1]) {
-            indent_char => o.code.shrinkRetainingCapacity(written.len - indent_width),
-            '\n' => try o.code.writer.splatByteAll(indent_char, o.indent_counter),
-            else => {
-                std.debug.print("\"{f}\"\n", .{std.zig.fmtString(written[written.len -| 100..])});
-                unreachable;
-            },
-        }
-    }
-};
-
-/// This data is available both when outputting .c code and when outputting an .h file.
+/// This data is available when rendering *any* C source code (function or otherwise).
 pub const DeclGen = struct {
     gpa: Allocator,
+    arena: Allocator,
     pt: Zcu.PerThread,
     mod: *Module,
-    pass: Pass,
+    owner_nav: InternPool.Nav.Index.Optional,
     is_naked_fn: bool,
     expected_block: ?u32,
-    fwd_decl: Writer.Allocating,
     error_msg: ?*Zcu.ErrorMsg,
-    ctype_pool: CType.Pool,
-    scratch: std.ArrayList(u32),
+    ctype_deps: CType.Dependencies,
     /// This map contains all the UAVs we saw generating this function.
     /// `link.C` will merge them into its `uavs`/`aligned_uavs` fields.
     /// Key is the value of the UAV; value is the UAV's alignment, or
@@ -760,16 +643,10 @@ pub const DeclGen = struct {
     /// less than the natural alignment.
     uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
 
-    pub const Pass = union(enum) {
-        nav: InternPool.Nav.Index,
-        uav: InternPool.Index,
-        flush,
-    };
-
     fn fail(dg: *DeclGen, comptime format: []const u8, args: anytype) Error {
         @branchHint(.cold);
         const zcu = dg.pt.zcu;
-        const src_loc = zcu.navSrcLoc(dg.pass.nav);
+        const src_loc = zcu.navSrcLoc(dg.owner_nav.unwrap().?);
         dg.error_msg = try Zcu.ErrorMsg.create(dg.gpa, src_loc, format, args);
         return error.AnalysisFail;
     }
@@ -783,14 +660,13 @@ pub const DeclGen = struct {
         const pt = dg.pt;
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
-        const ctype_pool = &dg.ctype_pool;
         const uav_val = Value.fromInterned(uav.val);
         const uav_ty = uav_val.typeOf(zcu);
 
         // Render an undefined pointer if we have a pointer to a zero-bit or comptime type.
         const ptr_ty: Type = .fromInterned(uav.orig_ty);
         if (ptr_ty.isPtrAtRuntime(zcu) and !uav_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
-            return dg.writeCValue(w, .{ .undef = ptr_ty });
+            return dg.renderUndefValue(w, ptr_ty, location);
         }
 
         // Chase function values in order to be able to reference the original function.
@@ -805,14 +681,12 @@ pub const DeclGen = struct {
         // them).  The analysis until now should ensure that the C function
         // pointers are compatible.  If they are not, then there is a bug
         // somewhere and we should let the C compiler tell us about it.
-        const ptr_ctype = try dg.ctypeFromType(ptr_ty, .complete);
-        const elem_ctype = ptr_ctype.info(ctype_pool).pointer.elem_ctype;
-        const uav_ctype = try dg.ctypeFromType(uav_ty, .complete);
-        const need_cast = !elem_ctype.eql(uav_ctype) and
-            (elem_ctype.info(ctype_pool) != .function or uav_ctype.info(ctype_pool) != .function);
+        const elem_ty = ptr_ty.childType(zcu);
+        const need_cast = elem_ty.toIntern() != uav_ty.toIntern() and
+            elem_ty.zigTypeTag(zcu) != .@"fn" or uav_ty.zigTypeTag(zcu) != .@"fn";
         if (need_cast) {
             try w.writeAll("((");
-            try dg.renderCType(w, ptr_ctype);
+            try dg.renderType(w, ptr_ty);
             try w.writeByte(')');
         }
         try w.writeByte('&');
@@ -842,11 +716,9 @@ pub const DeclGen = struct {
         nav_index: InternPool.Nav.Index,
         location: ValueRenderLocation,
     ) Error!void {
-        _ = location;
         const pt = dg.pt;
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
-        const ctype_pool = &dg.ctype_pool;
 
         // Chase function values in order to be able to reference the original function.
         const owner_nav = switch (ip.getNav(nav_index).status) {
@@ -863,25 +735,23 @@ pub const DeclGen = struct {
         const nav_ty: Type = .fromInterned(ip.getNav(owner_nav).typeOf(ip));
         const ptr_ty = try pt.navPtrType(owner_nav);
         if (!nav_ty.isRuntimeFnOrHasRuntimeBits(zcu)) {
-            return dg.writeCValue(w, .{ .undef = ptr_ty });
+            return dg.renderUndefValue(w, ptr_ty, location);
         }
 
         // We shouldn't cast C function pointers as this is UB (when you call
         // them).  The analysis until now should ensure that the C function
         // pointers are compatible.  If they are not, then there is a bug
         // somewhere and we should let the C compiler tell us about it.
-        const ctype = try dg.ctypeFromType(ptr_ty, .complete);
-        const elem_ctype = ctype.info(ctype_pool).pointer.elem_ctype;
-        const nav_ctype = try dg.ctypeFromType(nav_ty, .complete);
-        const need_cast = !elem_ctype.eql(nav_ctype) and
-            (elem_ctype.info(ctype_pool) != .function or nav_ctype.info(ctype_pool) != .function);
+        const elem_ty = ptr_ty.childType(zcu);
+        const need_cast = elem_ty.toIntern() != nav_ty.toIntern() and
+            elem_ty.zigTypeTag(zcu) != .@"fn" or nav_ty.zigTypeTag(zcu) != .@"fn";
         if (need_cast) {
             try w.writeAll("((");
-            try dg.renderCType(w, ctype);
+            try dg.renderType(w, ptr_ty);
             try w.writeByte(')');
         }
         try w.writeByte('&');
-        try dg.renderNavName(w, owner_nav);
+        try renderNavName(w, owner_nav, ip);
         if (need_cast) try w.writeByte(')');
     }
 
@@ -896,11 +766,10 @@ pub const DeclGen = struct {
         switch (derivation) {
             .comptime_alloc_ptr, .comptime_field_ptr => unreachable,
             .int => |int| {
-                const ptr_ctype = try dg.ctypeFromType(int.ptr_ty, .complete);
                 const addr_val = try pt.intValue(.usize, int.addr);
                 try w.writeByte('(');
-                try dg.renderCType(w, ptr_ctype);
-                try w.print("){f}", .{try dg.fmtIntLiteralHex(addr_val, .Other)});
+                try dg.renderType(w, int.ptr_ty);
+                try w.print("){f}", .{try dg.fmtIntLiteralHex(addr_val, .other)});
             },
 
             .nav_ptr => |nav| try dg.renderNav(w, nav, location),
@@ -915,14 +784,10 @@ pub const DeclGen = struct {
             .field_ptr => |field| {
                 const parent_ptr_ty = try field.parent.ptrType(pt);
 
-                // Ensure complete type definition is available before accessing fields.
-                _ = try dg.ctypeFromType(parent_ptr_ty.childType(zcu), .complete);
-
                 switch (fieldLocation(parent_ptr_ty, field.result_ptr_ty, field.field_idx, zcu)) {
                     .begin => {
-                        const ptr_ctype = try dg.ctypeFromType(field.result_ptr_ty, .complete);
                         try w.writeByte('(');
-                        try dg.renderCType(w, ptr_ctype);
+                        try dg.renderType(w, field.result_ptr_ty);
                         try w.writeByte(')');
                         try dg.renderPointer(w, field.parent.*, location);
                     },
@@ -933,51 +798,40 @@ pub const DeclGen = struct {
                         try dg.writeCValue(w, name);
                     },
                     .byte_offset => |byte_offset| {
-                        const ptr_ctype = try dg.ctypeFromType(field.result_ptr_ty, .complete);
                         try w.writeByte('(');
-                        try dg.renderCType(w, ptr_ctype);
+                        try dg.renderType(w, field.result_ptr_ty);
                         try w.writeByte(')');
                         const offset_val = try pt.intValue(.usize, byte_offset);
                         try w.writeAll("((char *)");
                         try dg.renderPointer(w, field.parent.*, location);
-                        try w.print(" + {f})", .{try dg.fmtIntLiteralDec(offset_val, .Other)});
+                        try w.print(" + {f})", .{try dg.fmtIntLiteralDec(offset_val, .other)});
                     },
                 }
             },
 
             .elem_ptr => |elem| if (!(try elem.parent.ptrType(pt)).childType(zcu).hasRuntimeBits(zcu)) {
                 // Element type is zero-bit, so lowers to `void`. The index is irrelevant; just cast the pointer.
-                const ptr_ctype = try dg.ctypeFromType(elem.result_ptr_ty, .complete);
                 try w.writeByte('(');
-                try dg.renderCType(w, ptr_ctype);
+                try dg.renderType(w, elem.result_ptr_ty);
                 try w.writeByte(')');
                 try dg.renderPointer(w, elem.parent.*, location);
             } else {
                 const index_val = try pt.intValue(.usize, elem.elem_idx);
-                // We want to do pointer arithmetic on a pointer to the element type.
-                // We might have a pointer-to-array. In this case, we must cast first.
-                const result_ctype = try dg.ctypeFromType(elem.result_ptr_ty, .complete);
-                const parent_ctype = try dg.ctypeFromType(try elem.parent.ptrType(pt), .complete);
-                if (result_ctype.eql(parent_ctype)) {
-                    // The pointer already has an appropriate type - just do the arithmetic.
+                try w.writeByte('(');
+                // We want to do pointer arithmetic on a pointer to the element type, but the parent
+                // might be a pointer-to-array, in which case we must cast it.
+                if (elem.result_ptr_ty.toIntern() != (try elem.parent.ptrType(pt)).toIntern()) {
                     try w.writeByte('(');
-                    try dg.renderPointer(w, elem.parent.*, location);
-                    try w.print(" + {f})", .{try dg.fmtIntLiteralDec(index_val, .Other)});
-                } else {
-                    // We probably have an array pointer `T (*)[n]`. Cast to an element pointer,
-                    // and *then* apply the index.
-                    try w.writeAll("((");
-                    try dg.renderCType(w, result_ctype);
+                    try dg.renderType(w, elem.result_ptr_ty);
                     try w.writeByte(')');
-                    try dg.renderPointer(w, elem.parent.*, location);
-                    try w.print(" + {f})", .{try dg.fmtIntLiteralDec(index_val, .Other)});
                 }
+                try dg.renderPointer(w, elem.parent.*, location);
+                try w.print(" + {f})", .{try dg.fmtIntLiteralDec(index_val, .other)});
             },
 
             .offset_and_cast => |oac| {
-                const ptr_ctype = try dg.ctypeFromType(oac.new_ptr_ty, .complete);
                 try w.writeByte('(');
-                try dg.renderCType(w, ptr_ctype);
+                try dg.renderType(w, oac.new_ptr_ty);
                 try w.writeByte(')');
                 if (oac.byte_offset == 0) {
                     try dg.renderPointer(w, oac.parent.*, location);
@@ -985,14 +839,40 @@ pub const DeclGen = struct {
                     const offset_val = try pt.intValue(.usize, oac.byte_offset);
                     try w.writeAll("((char *)");
                     try dg.renderPointer(w, oac.parent.*, location);
-                    try w.print(" + {f})", .{try dg.fmtIntLiteralDec(offset_val, .Other)});
+                    try w.print(" + {f})", .{try dg.fmtIntLiteralDec(offset_val, .other)});
                 }
             },
         }
     }
 
-    fn renderErrorName(dg: *DeclGen, w: *Writer, err_name: InternPool.NullTerminatedString) !void {
-        try w.print("zig_error_{f}", .{fmtIdentUnsolo(err_name.toSlice(&dg.pt.zcu.intern_pool))});
+    fn renderValueAsLvalue(
+        dg: *DeclGen,
+        w: *Writer,
+        val: Value,
+    ) Error!void {
+        const zcu = dg.pt.zcu;
+
+        // If the type of `val` lowers to a C struct or union type, then `renderValue` will render
+        // it as a compound literal, and compound literals are already lvalues.
+        const ty = val.typeOf(zcu);
+        const is_aggregate: bool = switch (ty.zigTypeTag(zcu)) {
+            .@"struct", .@"union" => switch (ty.containerLayout(zcu)) {
+                .auto, .@"extern" => true,
+                .@"packed" => false,
+            },
+            .array,
+            .vector,
+            .error_union,
+            .optional,
+            => true,
+            else => false,
+        };
+        if (is_aggregate) return renderValue(dg, w, val, .other);
+
+        // Otherwise, use a UAV.
+        const gop = try dg.uavs.getOrPut(dg.gpa, val.toIntern());
+        if (!gop.found_existing) gop.value_ptr.* = .none;
+        try renderUavName(w, val);
     }
 
     fn renderValue(
@@ -1005,16 +885,13 @@ pub const DeclGen = struct {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
         const target = &dg.mod.resolved_target.result;
-        const ctype_pool = &dg.ctype_pool;
 
         const initializer_type: ValueRenderLocation = switch (location) {
-            .StaticInitializer => .StaticInitializer,
-            else => .Initializer,
+            .static_initializer => .static_initializer,
+            else => .initializer,
         };
 
         const ty = val.typeOf(zcu);
-        if (val.isUndef(zcu)) return dg.renderUndefValue(w, ty, location);
-        const ctype = try dg.ctypeFromType(ty, location.toCTypeKind());
         switch (ip.indexToKey(val.toIntern())) {
             // types, not values
             .int_type,
@@ -1037,7 +914,7 @@ pub const DeclGen = struct {
             .memoized_call,
             => unreachable,
 
-            .undef => unreachable, // handled above
+            .undef => try dg.renderUndefValue(w, ty, location),
             .simple_value => |simple_value| switch (simple_value) {
                 // non-runtime values
                 .void => unreachable,
@@ -1053,46 +930,28 @@ pub const DeclGen = struct {
             .enum_literal,
             => unreachable, // non-runtime values
             .int => try w.print("{f}", .{try dg.fmtIntLiteralDec(val, location)}),
-            .err => |err| try dg.renderErrorName(w, err.name),
-            .error_union => |error_union| switch (ctype.info(ctype_pool)) {
-                .basic => switch (error_union.val) {
-                    .err_name => |err_name| try dg.renderErrorName(w, err_name),
+            .err => |err| try renderErrorName(w, err.name.toSlice(ip)),
+            .error_union => |error_union| {
+                if (!location.isInitializer()) {
+                    try w.writeByte('(');
+                    try dg.renderType(w, ty);
+                    try w.writeByte(')');
+                }
+                try w.writeAll("{ .error = ");
+                switch (error_union.val) {
+                    .err_name => |err_name| try renderErrorName(w, err_name.toSlice(ip)),
                     .payload => try w.writeByte('0'),
-                },
-                .pointer, .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-                .aggregate => |aggregate| {
-                    if (!location.isInitializer()) {
-                        try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
-                        try w.writeByte(')');
+                }
+                if (ty.errorUnionPayload(zcu).hasRuntimeBits(zcu)) {
+                    try w.writeAll(", .payload = ");
+                    switch (error_union.val) {
+                        .err_name => try dg.renderUndefValue(w, ty.errorUnionPayload(zcu), initializer_type),
+                        .payload => |payload| try dg.renderValue(w, .fromInterned(payload), initializer_type),
                     }
-                    try w.writeByte('{');
-                    for (0..aggregate.fields.len) |field_index| {
-                        if (field_index > 0) try w.writeByte(',');
-                        switch (aggregate.fields.at(field_index, ctype_pool).name.index) {
-                            .@"error" => switch (error_union.val) {
-                                .err_name => |err_name| try dg.renderErrorName(w, err_name),
-                                .payload => try w.writeByte('0'),
-                            },
-                            .payload => switch (error_union.val) {
-                                .err_name => try dg.renderUndefValue(
-                                    w,
-                                    ty.errorUnionPayload(zcu),
-                                    initializer_type,
-                                ),
-                                .payload => |payload| try dg.renderValue(
-                                    w,
-                                    Value.fromInterned(payload),
-                                    initializer_type,
-                                ),
-                            },
-                            else => unreachable,
-                        }
-                    }
-                    try w.writeByte('}');
-                },
+                }
+                try w.writeAll(" }");
             },
-            .enum_tag => |enum_tag| try dg.renderValue(w, Value.fromInterned(enum_tag.int), location),
+            .enum_tag => |enum_tag| try dg.renderValue(w, .fromInterned(enum_tag.int), location),
             .float => {
                 const bits = ty.floatBits(target);
                 const f128_val = val.toFloat(f128, zcu);
@@ -1143,7 +1002,7 @@ pub const DeclGen = struct {
                     else
                         unreachable;
 
-                    if (location == .StaticInitializer) {
+                    if (location == .static_initializer) {
                         if (!std.math.isNan(f128_val) and std.math.isSignalNan(f128_val))
                             return dg.fail("TODO: C backend: implement nans rendering in static initializers", .{});
 
@@ -1154,9 +1013,11 @@ pub const DeclGen = struct {
                         //     return dg.fail("Only quiet nans are supported in global variable initializers", .{});
                     }
 
-                    try w.writeAll("zig_");
-                    try w.writeAll(if (location == .StaticInitializer) "init" else "make");
-                    try w.writeAll("_special_");
+                    if (location == .static_initializer) {
+                        try w.writeAll("zig_init_special_");
+                    } else {
+                        try w.writeAll("zig_make_special_");
+                    }
                     try dg.renderTypeForBuiltinFnName(w, ty);
                     try w.writeByte('(');
                     if (std.math.signbit(f128_val)) try w.writeByte('-');
@@ -1183,105 +1044,85 @@ pub const DeclGen = struct {
                 if (!empty) try w.writeByte(')');
             },
             .slice => |slice| {
-                const aggregate = ctype.info(ctype_pool).aggregate;
                 if (!location.isInitializer()) {
                     try w.writeByte('(');
-                    try dg.renderCType(w, ctype);
+                    try dg.renderType(w, ty);
                     try w.writeByte(')');
                 }
                 try w.writeByte('{');
-                for (0..aggregate.fields.len) |field_index| {
-                    if (field_index > 0) try w.writeByte(',');
-                    try dg.renderValue(w, Value.fromInterned(
-                        switch (aggregate.fields.at(field_index, ctype_pool).name.index) {
-                            .ptr => slice.ptr,
-                            .len => slice.len,
-                            else => unreachable,
-                        },
-                    ), initializer_type);
-                }
+                try dg.renderValue(w, .fromInterned(slice.ptr), initializer_type);
+                try w.writeByte(',');
+                try dg.renderValue(w, .fromInterned(slice.len), initializer_type);
                 try w.writeByte('}');
             },
             .ptr => {
-                var arena = std.heap.ArenaAllocator.init(zcu.gpa);
-                defer arena.deinit();
-                const derivation = try val.pointerDerivation(arena.allocator(), pt, null);
+                const derivation = try val.pointerDerivation(dg.arena, pt, null);
+                try w.writeByte('(');
                 try dg.renderPointer(w, derivation, location);
+                try w.writeByte(')');
             },
-            .opt => |opt| switch (ctype.info(ctype_pool)) {
-                .basic => if (ctype.isBool()) try w.writeAll(switch (opt.val) {
-                    .none => "true",
-                    else => "false",
-                }) else switch (opt.val) {
+            .opt => |opt| switch (CType.classifyOptional(ty, zcu)) {
+                .npv_payload => unreachable, // opv optional
+                .opv_payload => {
+                    if (!location.isInitializer()) {
+                        try w.writeByte('(');
+                        try dg.renderType(w, ty);
+                        try w.writeByte(')');
+                    }
+                    try w.writeAll(switch (opt.val) {
+                        .none => "{.is_null = true}",
+                        else => "{.is_null = false}",
+                    });
+                },
+                .error_set => switch (opt.val) {
                     .none => try w.writeByte('0'),
-                    else => |payload| switch (ip.indexToKey(payload)) {
-                        .undef => |err_ty| try dg.renderUndefValue(
-                            w,
-                            .fromInterned(err_ty),
-                            location,
-                        ),
-                        .err => |err| try dg.renderErrorName(w, err.name),
-                        else => unreachable,
-                    },
+                    else => |payload_val| try dg.renderValue(w, .fromInterned(payload_val), location),
                 },
-                .pointer => switch (opt.val) {
+                .ptr_like => switch (opt.val) {
                     .none => try w.writeAll("NULL"),
-                    else => |payload| try dg.renderValue(w, Value.fromInterned(payload), location),
+                    else => |payload_val| try dg.renderValue(w, .fromInterned(payload_val), location),
                 },
-                .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-                .aggregate => |aggregate| {
+                .slice_like => switch (opt.val) {
+                    .none => {
+                        if (!location.isInitializer()) {
+                            try w.writeByte('(');
+                            try dg.renderType(w, ty);
+                            try w.writeByte(')');
+                        }
+                        try w.writeAll("{NULL,");
+                        try dg.renderUndefValue(w, .usize, initializer_type);
+                        try w.writeByte('}');
+                    },
+                    else => |payload_val| try dg.renderValue(w, .fromInterned(payload_val), location),
+                },
+                .@"struct" => {
+                    if (!location.isInitializer()) {
+                        try w.writeByte('(');
+                        try dg.renderType(w, ty);
+                        try w.writeByte(')');
+                    }
                     switch (opt.val) {
-                        .none => {},
-                        else => |payload| switch (aggregate.fields.at(0, ctype_pool).name.index) {
-                            .is_null, .payload => {},
-                            .ptr, .len => return dg.renderValue(
-                                w,
-                                Value.fromInterned(payload),
-                                location,
-                            ),
-                            else => unreachable,
+                        .none => {
+                            try w.writeAll("{ .is_null = true, .payload = ");
+                            try dg.renderUndefValue(w, ty.optionalChild(zcu), initializer_type);
+                            try w.writeAll(" }");
+                        },
+                        else => |payload_val| {
+                            try w.writeAll("{ .is_null = false, .payload = ");
+                            try dg.renderValue(w, .fromInterned(payload_val), initializer_type);
+                            try w.writeAll(" }");
                         },
                     }
-                    if (!location.isInitializer()) {
-                        try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
-                        try w.writeByte(')');
-                    }
-                    try w.writeByte('{');
-                    for (0..aggregate.fields.len) |field_index| {
-                        if (field_index > 0) try w.writeByte(',');
-                        switch (aggregate.fields.at(field_index, ctype_pool).name.index) {
-                            .is_null => try w.writeAll(switch (opt.val) {
-                                .none => "true",
-                                else => "false",
-                            }),
-                            .payload => switch (opt.val) {
-                                .none => try dg.renderUndefValue(
-                                    w,
-                                    ty.optionalChild(zcu),
-                                    initializer_type,
-                                ),
-                                else => |payload| try dg.renderValue(
-                                    w,
-                                    Value.fromInterned(payload),
-                                    initializer_type,
-                                ),
-                            },
-                            .ptr => try w.writeAll("NULL"),
-                            .len => try dg.renderUndefValue(w, .usize, initializer_type),
-                            else => unreachable,
-                        }
-                    }
-                    try w.writeByte('}');
                 },
             },
             .aggregate => switch (ip.indexToKey(ty.toIntern())) {
                 .array_type, .vector_type => {
-                    if (location == .FunctionArgument) {
+                    if (!location.isInitializer()) {
                         try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
+                        try dg.renderType(w, ty);
                         try w.writeByte(')');
                     }
+                    try w.writeByte('{');
                     const ai = ty.arrayInfo(zcu);
                     if (ai.elem_type.eql(.u8, zcu)) {
                         var literal: StringLiteral = .init(w, @intCast(ty.arrayLenIncludingSentinel(zcu)));
@@ -1314,11 +1155,12 @@ pub const DeclGen = struct {
                         }
                         try w.writeByte('}');
                     }
+                    try w.writeByte('}');
                 },
                 .tuple_type => |tuple| {
                     if (!location.isInitializer()) {
                         try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
+                        try dg.renderType(w, ty);
                         try w.writeByte(')');
                     }
 
@@ -1354,7 +1196,7 @@ pub const DeclGen = struct {
 
                     if (!location.isInitializer()) {
                         try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
+                        try dg.renderType(w, ty);
                         try w.writeByte(')');
                     }
 
@@ -1385,69 +1227,60 @@ pub const DeclGen = struct {
             .un => |un| {
                 const loaded_union = ip.loadUnionType(ty.toIntern());
                 if (un.tag == .none) {
-                    const backing_ty = try ty.externUnionBackingType(pt);
                     assert(loaded_union.layout == .@"extern");
-                    if (location == .StaticInitializer) {
+                    if (location == .static_initializer) {
                         return dg.fail("TODO: C backend: implement extern union backing type rendering in static initializers", .{});
                     }
 
                     const ptr_ty = try pt.singleConstPtrType(ty);
-                    try w.writeAll("*((");
+                    try w.writeAll("*(");
                     try dg.renderType(w, ptr_ty);
-                    try w.writeAll(")(");
-                    try dg.renderType(w, backing_ty);
-                    try w.writeAll("){");
-                    try dg.renderValue(w, Value.fromInterned(un.val), location);
-                    try w.writeAll("})");
+                    try w.writeAll(")&");
+                    // We need an lvalue for '&'.
+                    try dg.renderValueAsLvalue(w, .fromInterned(un.val));
                 } else {
                     if (!location.isInitializer()) {
                         try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
+                        try dg.renderType(w, ty);
                         try w.writeByte(')');
                     }
+                    if (ty.unionHasAllZeroBitFieldTypes(zcu)) {
+                        assert(loaded_union.has_runtime_tag); // otherwise it does not have runtime bits
+                        try w.writeAll("{ .tag = ");
+                        try dg.renderValue(w, .fromInterned(un.tag), initializer_type);
+                        try w.writeAll(" }");
+                        return;
+                    }
+
+                    if (loaded_union.layout == .auto) try w.writeByte('{');
 
-                    const field_index = zcu.unionTagFieldIndex(loaded_union, Value.fromInterned(un.tag)).?;
-                    const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                    const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
+                    if (loaded_union.has_runtime_tag) {
+                        try w.writeAll(" .tag = ");
+                        try dg.renderValue(w, .fromInterned(un.tag), initializer_type);
+                        try w.writeAll(", .payload = ");
+                    }
 
-                    const has_tag = loaded_union.has_runtime_tag;
-                    if (has_tag) try w.writeByte('{');
-                    const aggregate = ctype.info(ctype_pool).aggregate;
-                    for (0..if (has_tag) aggregate.fields.len else 1) |outer_field_index| {
-                        if (outer_field_index > 0) try w.writeByte(',');
-                        switch (if (has_tag)
-                            aggregate.fields.at(outer_field_index, ctype_pool).name.index
-                        else
-                            .payload) {
-                            .tag => try dg.renderValue(
-                                w,
-                                Value.fromInterned(un.tag),
-                                initializer_type,
-                            ),
-                            .payload => {
-                                try w.writeByte('{');
-                                if (field_ty.hasRuntimeBits(zcu)) {
-                                    try w.print(" .{f} = ", .{fmtIdentSolo(field_name.toSlice(ip))});
-                                    try dg.renderValue(
-                                        w,
-                                        Value.fromInterned(un.val),
-                                        initializer_type,
-                                    );
-                                    try w.writeByte(' ');
-                                } else for (0..loaded_union.field_types.len) |inner_field_index| {
-                                    const inner_field_ty: Type = .fromInterned(
-                                        loaded_union.field_types.get(ip)[inner_field_index],
-                                    );
-                                    if (!inner_field_ty.hasRuntimeBits(zcu)) continue;
-                                    try dg.renderUndefValue(w, inner_field_ty, initializer_type);
-                                    break;
-                                }
-                                try w.writeByte('}');
-                            },
-                            else => unreachable,
-                        }
+                    const enum_tag_ty: Type = .fromInterned(loaded_union.enum_tag_type);
+                    const active_field_index = enum_tag_ty.enumTagFieldIndex(.fromInterned(un.tag), zcu).?;
+                    const active_field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[active_field_index]);
+                    if (active_field_ty.hasRuntimeBits(zcu)) {
+                        const active_field_name = enum_tag_ty.enumFieldName(active_field_index, zcu);
+                        try w.print("{{ .{f} = ", .{fmtIdentSolo(active_field_name.toSlice(ip))});
+                        try dg.renderValue(w, .fromInterned(un.val), initializer_type);
+                        try w.writeAll(" }");
+                    } else {
+                        const first_field_ty: Type = for (loaded_union.field_types.get(ip)) |field_ty_ip| {
+                            const field_ty: Type = .fromInterned(field_ty_ip);
+                            if (!field_ty.hasRuntimeBits(pt.zcu)) continue;
+                            break field_ty;
+                        } else unreachable;
+                        try w.writeByte('{');
+                        try dg.renderUndefValue(w, first_field_ty, initializer_type);
+                        try w.writeByte('}');
                     }
-                    if (has_tag) try w.writeByte('}');
+
+                    if (loaded_union.has_runtime_tag) try w.writeByte(' ');
+                    if (loaded_union.layout == .auto) try w.writeByte('}');
                 }
             },
         }
@@ -1463,11 +1296,10 @@ pub const DeclGen = struct {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
         const target = &dg.mod.resolved_target.result;
-        const ctype_pool = &dg.ctype_pool;
 
         const initializer_type: ValueRenderLocation = switch (location) {
-            .StaticInitializer => .StaticInitializer,
-            else => .Initializer,
+            .static_initializer => .static_initializer,
+            else => .initializer,
         };
 
         const safety_on = switch (zcu.optimizeMode()) {
@@ -1475,7 +1307,6 @@ pub const DeclGen = struct {
             .ReleaseFast, .ReleaseSmall => false,
         };
 
-        const ctype = try dg.ctypeFromType(ty, location.toCTypeKind());
         switch (ty.toIntern()) {
             .c_longdouble_type,
             .f16_type,
@@ -1500,88 +1331,120 @@ pub const DeclGen = struct {
                     else => unreachable,
                 }
                 try w.writeAll(", ");
-                try dg.renderUndefValue(w, repr_ty, .FunctionArgument);
+                try dg.renderUndefValue(w, repr_ty, .other);
                 return w.writeByte(')');
             },
             .bool_type => try w.writeAll(if (safety_on) "0xaa" else "false"),
             else => switch (ip.indexToKey(ty.toIntern())) {
-                .simple_type,
+                .simple_type, // anyerror, c_char (etc), usize, isize
                 .int_type,
                 .enum_type,
                 .error_set_type,
                 .inferred_error_set_type,
-                => return w.print("{f}", .{
-                    try dg.fmtIntLiteralHex(try pt.undefValue(ty), location),
-                }),
+                => switch (CType.classifyInt(ty, zcu)) {
+                    .void => unreachable, // opv
+                    .small => |s| {
+                        const int = ty.intInfo(zcu);
+                        var buf: [std.math.big.int.calcTwosCompLimbCount(128)]std.math.big.Limb = undefined;
+                        var bigint: std.math.big.int.Mutable = .init(&buf, undefPattern(u128));
+                        bigint.truncate(bigint.toConst(), int.signedness, int.bits);
+                        const fmt_undef: FormatInt128 = .{
+                            .target = zcu.getTarget(),
+                            .int_cty = s,
+                            .val = bigint.toConst(),
+                            .is_global = location == .static_initializer,
+                            .base = 16,
+                            .case = .lower,
+                        };
+                        try w.print("{f}", .{fmt_undef});
+                    },
+                    .big => |big| {
+                        var buf: [std.math.big.int.calcTwosCompLimbCount(128)]std.math.big.Limb = undefined;
+                        var limb_bigint: std.math.big.int.Mutable = .init(&buf, undefPattern(u128));
+                        limb_bigint.truncate(limb_bigint.toConst(), .unsigned, big.limb_size.bits());
+                        const fmt_undef_limb: FormatInt128 = .{
+                            .target = zcu.getTarget(),
+                            .int_cty = big.limb_size.unsigned(),
+                            .val = limb_bigint.toConst(),
+                            .is_global = location == .static_initializer,
+                            .base = 16,
+                            .case = .lower,
+                        };
+
+                        if (!location.isInitializer()) {
+                            try w.writeByte('(');
+                            try dg.renderType(w, ty);
+                            try w.writeByte(')');
+                        }
+                        try w.writeAll("{{");
+                        try w.print("{f}", .{fmt_undef_limb});
+                        for (1..big.limbs_len) |_| {
+                            try w.print(",{f}", .{fmt_undef_limb});
+                        }
+                        try w.writeAll("}}");
+                    },
+                },
                 .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
                     .one, .many, .c => {
                         try w.writeAll("((");
-                        try dg.renderCType(w, ctype);
-                        return w.print("){f})", .{
-                            try dg.fmtIntLiteralHex(.undef_usize, .Other),
-                        });
+                        try dg.renderType(w, ty);
+                        try w.writeByte(')');
+                        try dg.renderUndefValue(w, .usize, location);
+                        try w.writeByte(')');
                     },
                     .slice => {
                         if (!location.isInitializer()) {
                             try w.writeByte('(');
-                            try dg.renderCType(w, ctype);
+                            try dg.renderType(w, ty);
                             try w.writeByte(')');
                         }
 
-                        try w.writeAll("{(");
-                        const ptr_ty = ty.slicePtrFieldType(zcu);
-                        try dg.renderType(w, ptr_ty);
-                        return w.print("){f}, {0f}}}", .{
-                            try dg.fmtIntLiteralHex(.undef_usize, .Other),
-                        });
-                    },
-                },
-                .opt_type => |child_type| switch (ctype.info(ctype_pool)) {
-                    .basic, .pointer => try dg.renderUndefValue(
-                        w,
-                        .fromInterned(if (ctype.isBool()) .bool_type else child_type),
-                        location,
-                    ),
-                    .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-                    .aggregate => |aggregate| {
-                        switch (aggregate.fields.at(0, ctype_pool).name.index) {
-                            .is_null, .payload => {},
-                            .ptr, .len => return dg.renderUndefValue(
-                                w,
-                                .fromInterned(child_type),
-                                location,
-                            ),
-                            else => unreachable,
-                        }
-                        if (!location.isInitializer()) {
-                            try w.writeByte('(');
-                            try dg.renderCType(w, ctype);
-                            try w.writeByte(')');
-                        }
                         try w.writeByte('{');
-                        for (0..aggregate.fields.len) |field_index| {
-                            if (field_index > 0) try w.writeByte(',');
-                            try dg.renderUndefValue(w, .fromInterned(
-                                switch (aggregate.fields.at(field_index, ctype_pool).name.index) {
-                                    .is_null => .bool_type,
-                                    .payload => child_type,
-                                    else => unreachable,
-                                },
-                            ), initializer_type);
-                        }
+                        try dg.renderUndefValue(w, ty.slicePtrFieldType(zcu), initializer_type);
+                        try w.writeByte(',');
+                        try dg.renderUndefValue(w, .usize, initializer_type);
                         try w.writeByte('}');
                     },
                 },
+                .opt_type => |child_type| switch (CType.classifyOptional(ty, zcu)) {
+                    .npv_payload => unreachable, // opv optional
+
+                    .error_set,
+                    .ptr_like,
+                    .slice_like,
+                    => try dg.renderUndefValue(w, .fromInterned(child_type), location),
+
+                    .opv_payload => {
+                        if (!location.isInitializer()) {
+                            try w.writeByte('(');
+                            try dg.renderType(w, ty);
+                            try w.writeByte(')');
+                        }
+                        try w.writeAll(if (safety_on) "{.is_null=0xaa}" else "{.is_null=false}");
+                    },
+
+                    .@"struct" => {
+                        if (!location.isInitializer()) {
+                            try w.writeByte('(');
+                            try dg.renderType(w, ty);
+                            try w.writeByte(')');
+                        }
+                        try w.writeAll("{ .is_null = ");
+                        try dg.renderUndefValue(w, .bool, initializer_type);
+                        try w.writeAll(", .payload = ");
+                        try dg.renderUndefValue(w, .fromInterned(child_type), initializer_type);
+                        try w.writeAll(" }");
+                    },
+                },
                 .struct_type => {
                     const loaded_struct = ip.loadStructType(ty.toIntern());
                     switch (loaded_struct.layout) {
                         .auto, .@"extern" => {
                             if (!location.isInitializer()) {
                                 try w.writeByte('(');
-                                try dg.renderCType(w, ctype);
+                                try dg.renderType(w, ty);
                                 try w.writeByte(')');
                             }
-
                             try w.writeByte('{');
                             var field_it = loaded_struct.iterateRuntimeOrder(ip);
                             var need_comma = false;
@@ -1601,7 +1464,7 @@ pub const DeclGen = struct {
                 .tuple_type => |tuple_info| {
                     if (!location.isInitializer()) {
                         try w.writeByte('(');
-                        try dg.renderCType(w, ctype);
+                        try dg.renderType(w, ty);
                         try w.writeByte(')');
                     }
 
@@ -1624,80 +1487,61 @@ pub const DeclGen = struct {
                         .auto, .@"extern" => {
                             if (!location.isInitializer()) {
                                 try w.writeByte('(');
-                                try dg.renderCType(w, ctype);
+                                try dg.renderType(w, ty);
                                 try w.writeByte(')');
                             }
 
-                            const has_tag = loaded_union.has_runtime_tag;
-                            if (has_tag) try w.writeByte('{');
-                            const aggregate = ctype.info(ctype_pool).aggregate;
-                            for (0..if (has_tag) aggregate.fields.len else 1) |outer_field_index| {
-                                if (outer_field_index > 0) try w.writeByte(',');
-                                switch (if (has_tag)
-                                    aggregate.fields.at(outer_field_index, ctype_pool).name.index
-                                else
-                                    .payload) {
-                                    .tag => try dg.renderUndefValue(
-                                        w,
-                                        .fromInterned(loaded_union.enum_tag_type),
-                                        initializer_type,
-                                    ),
-                                    .payload => {
-                                        try w.writeByte('{');
-                                        for (0..loaded_union.field_types.len) |inner_field_index| {
-                                            const inner_field_ty: Type = .fromInterned(
-                                                loaded_union.field_types.get(ip)[inner_field_index],
-                                            );
-                                            if (!inner_field_ty.hasRuntimeBits(pt.zcu)) continue;
-                                            try dg.renderUndefValue(
-                                                w,
-                                                inner_field_ty,
-                                                initializer_type,
-                                            );
-                                            break;
-                                        }
-                                        try w.writeByte('}');
-                                    },
-                                    else => unreachable,
-                                }
+                            const first_field_ty: Type = for (loaded_union.field_types.get(ip)) |field_ty_ip| {
+                                const field_ty: Type = .fromInterned(field_ty_ip);
+                                if (!field_ty.hasRuntimeBits(pt.zcu)) continue;
+                                break field_ty;
+                            } else {
+                                assert(loaded_union.has_runtime_tag); // otherwise it does not have runtime bits
+                                try w.writeAll("{ .tag = ");
+                                try dg.renderUndefValue(w, .fromInterned(loaded_union.enum_tag_type), initializer_type);
+                                try w.writeAll(" }");
+                                return;
+                            };
+
+                            if (loaded_union.layout == .auto) try w.writeByte('{');
+
+                            if (loaded_union.has_runtime_tag) {
+                                try w.writeAll(" .tag = ");
+                                try dg.renderUndefValue(w, .fromInterned(loaded_union.enum_tag_type), initializer_type);
+                                try w.writeAll(", .payload = ");
                             }
-                            if (has_tag) try w.writeByte('}');
+
+                            try w.writeByte('{');
+                            try dg.renderUndefValue(w, first_field_ty, initializer_type);
+                            try w.writeByte('}');
+
+                            if (loaded_union.has_runtime_tag) try w.writeByte(' ');
+                            if (loaded_union.layout == .auto) try w.writeByte('}');
                         },
                         .@"packed" => return dg.renderUndefValue(w, ty.bitpackBackingInt(zcu), location),
                     }
                 },
-                .error_union_type => |error_union_type| switch (ctype.info(ctype_pool)) {
-                    .basic => try dg.renderUndefValue(
-                        w,
-                        .fromInterned(error_union_type.error_set_type),
-                        location,
-                    ),
-                    .pointer, .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-                    .aggregate => |aggregate| {
-                        if (!location.isInitializer()) {
-                            try w.writeByte('(');
-                            try dg.renderCType(w, ctype);
-                            try w.writeByte(')');
-                        }
-                        try w.writeByte('{');
-                        for (0..aggregate.fields.len) |field_index| {
-                            if (field_index > 0) try w.writeByte(',');
-                            try dg.renderUndefValue(
-                                w,
-                                .fromInterned(
-                                    switch (aggregate.fields.at(field_index, ctype_pool).name.index) {
-                                        .@"error" => error_union_type.error_set_type,
-                                        .payload => error_union_type.payload_type,
-                                        else => unreachable,
-                                    },
-                                ),
-                                initializer_type,
-                            );
-                        }
-                        try w.writeByte('}');
-                    },
+                .error_union_type => |error_union| {
+                    if (!location.isInitializer()) {
+                        try w.writeByte('(');
+                        try dg.renderType(w, ty);
+                        try w.writeByte(')');
+                    }
+                    try w.writeAll("{ .error = ");
+                    try dg.renderUndefValue(w, .fromInterned(error_union.error_set_type), initializer_type);
+                    if (Type.fromInterned(error_union.payload_type).hasRuntimeBits(zcu)) {
+                        try w.writeAll(", .payload = ");
+                        try dg.renderUndefValue(w, .fromInterned(error_union.payload_type), initializer_type);
+                    }
+                    try w.writeAll(" }");
                 },
                 .array_type, .vector_type => {
+                    if (!location.isInitializer()) {
+                        try w.writeByte('(');
+                        try dg.renderType(w, ty);
+                        try w.writeByte(')');
+                    }
+                    try w.writeByte('{');
                     const ai = ty.arrayInfo(zcu);
                     if (ai.elem_type.eql(.u8, zcu)) {
                         var literal: StringLiteral = .init(w, @intCast(ty.arrayLenIncludingSentinel(zcu)));
@@ -1708,14 +1552,8 @@ pub const DeclGen = struct {
                             const s_u8: u8 = @intCast(s.toUnsignedInt(zcu));
                             if (s_u8 != 0) try literal.writeChar(s_u8);
                         }
-                        return literal.end();
+                        try literal.end();
                     } else {
-                        if (!location.isInitializer()) {
-                            try w.writeByte('(');
-                            try dg.renderCType(w, ctype);
-                            try w.writeByte(')');
-                        }
-
                         try w.writeByte('{');
                         var index: u64 = 0;
                         while (index < ai.len) : (index += 1) {
@@ -1726,8 +1564,9 @@ pub const DeclGen = struct {
                             if (index > 0) try w.writeAll(", ");
                             try dg.renderValue(w, s, location);
                         }
-                        return w.writeByte('}');
+                        try w.writeByte('}');
                     }
+                    try w.writeByte('}');
                 },
                 .anyframe_type,
                 .opaque_type,
@@ -1762,10 +1601,11 @@ pub const DeclGen = struct {
         w: *Writer,
         fn_val: Value,
         fn_align: InternPool.Alignment,
-        kind: CType.Kind,
+        kind: enum { forward_decl, definition },
         name: union(enum) {
             nav: InternPool.Nav.Index,
-            fmt_ctype_pool_string: std.fmt.Alt(CTypePoolStringFormatData, formatCTypePoolString),
+            nav_never_tail: InternPool.Nav.Index,
+            nav_never_inline: InternPool.Nav.Index,
             @"export": struct {
                 main_name: InternPool.NullTerminatedString,
                 extern_name: InternPool.NullTerminatedString,
@@ -1776,14 +1616,12 @@ pub const DeclGen = struct {
         const ip = &zcu.intern_pool;
 
         const fn_ty = fn_val.typeOf(zcu);
-        const fn_ctype = try dg.ctypeFromType(fn_ty, kind);
 
         const fn_info = zcu.typeToFunc(fn_ty).?;
         if (fn_info.cc == .naked) {
             switch (kind) {
-                .forward => try w.writeAll("zig_naked_decl "),
-                .complete => try w.writeAll("zig_naked "),
-                else => unreachable,
+                .forward_decl => try w.writeAll("zig_naked_decl "),
+                .definition => try w.writeAll("zig_naked "),
             }
         }
 
@@ -1793,45 +1631,63 @@ pub const DeclGen = struct {
             if (func_analysis.branch_hint == .cold)
                 try w.writeAll("zig_cold ");
 
-            if (kind == .complete and func_analysis.disable_intrinsics or dg.mod.no_builtin)
+            if (kind == .definition and func_analysis.disable_intrinsics or dg.mod.no_builtin)
                 try w.writeAll("zig_no_builtin ");
         }
 
         if (fn_info.return_type == .noreturn_type) try w.writeAll("zig_noreturn ");
 
-        var trailing = try renderTypePrefix(dg.pass, &dg.ctype_pool, zcu, w, fn_ctype, .suffix, .{});
+        // While incomplete types are usually an acceptable substitute for "void", this is not true
+        // in function return types, where "void" is the only incomplete type permitted.
+        const actual_return_type: Type = .fromInterned(fn_info.return_type);
+        const effective_return_type: Type = switch (actual_return_type.classify(zcu)) {
+            .no_possible_value => .noreturn,
+            .one_possible_value, .fully_comptime => .void, // no runtime bits
+            .partially_comptime, .runtime => actual_return_type, // yes runtime bits
+        };
 
+        const ret_cty: CType = try .lower(effective_return_type, &dg.ctype_deps, dg.arena, zcu);
+        try w.print("{f}", .{ret_cty.fmtDeclaratorPrefix(zcu)});
         if (toCallingConvention(fn_info.cc, zcu)) |call_conv| {
-            try w.print("{f}zig_callconv({s})", .{ trailing, call_conv });
-            trailing = .maybe_space;
+            try w.print("zig_callconv({s}) ", .{call_conv});
         }
-
-        try w.print("{f}", .{trailing});
         switch (name) {
-            .nav => |nav| try dg.renderNavName(w, nav),
-            .fmt_ctype_pool_string => |fmt| try w.print("{f}", .{fmt}),
+            .nav => |nav| try renderNavName(w, nav, ip),
+            .nav_never_tail => |nav| try w.print("zig_never_tail_{f}__{d}", .{
+                fmtIdentUnsolo(ip.getNav(nav).name.toSlice(ip)), @intFromEnum(nav),
+            }),
+            .nav_never_inline => |nav| try w.print("zig_never_inline_{f}__{d}", .{
+                fmtIdentUnsolo(ip.getNav(nav).name.toSlice(ip)), @intFromEnum(nav),
+            }),
             .@"export" => |@"export"| try w.print("{f}", .{fmtIdentSolo(@"export".extern_name.toSlice(ip))}),
         }
-
-        try renderTypeSuffix(
-            dg.pass,
-            &dg.ctype_pool,
-            zcu,
-            w,
-            fn_ctype,
-            .suffix,
-            CQualifiers.init(.{ .@"const" = switch (kind) {
-                .forward => false,
-                .complete => true,
-                else => unreachable,
-            } }),
-        );
+        {
+            try w.writeByte('(');
+            var c_param_index: u32 = 0;
+            for (fn_info.param_types.get(ip)) |param_ty_ip| {
+                const param_ty: Type = .fromInterned(param_ty_ip);
+                if (!param_ty.hasRuntimeBits(zcu)) continue;
+                if (c_param_index != 0) try w.writeAll(", ");
+                try dg.renderTypeAndName(w, param_ty, .{ .arg = c_param_index }, .{
+                    .@"const" = kind == .definition,
+                }, .none);
+                c_param_index += 1;
+            }
+            if (fn_info.is_var_args) {
+                if (c_param_index != 0) try w.writeAll(", ");
+                try w.writeAll("...");
+            } else if (c_param_index == 0) {
+                try w.writeAll("void");
+            }
+            try w.writeByte(')');
+        }
+        try w.print("{f}", .{ret_cty.fmtDeclaratorSuffixIgnoreNonstring(zcu)});
 
         switch (kind) {
-            .forward => {
+            .forward_decl => {
                 if (fn_align.toByteUnits()) |a| try w.print(" zig_align_fn({})", .{a});
                 switch (name) {
-                    .nav, .fmt_ctype_pool_string => {},
+                    .nav, .nav_never_tail, .nav_never_inline => {},
                     .@"export" => |@"export"| {
                         const extern_name = @"export".extern_name.toSlice(ip);
                         const is_mangled = isMangledIdent(extern_name, true);
@@ -1855,38 +1711,16 @@ pub const DeclGen = struct {
                     },
                 }
             },
-            .complete => {},
-            else => unreachable,
+            .definition => {},
         }
     }
 
-    fn ctypeFromType(dg: *DeclGen, ty: Type, kind: CType.Kind) !CType {
-        defer std.debug.assert(dg.scratch.items.len == 0);
-        return dg.ctype_pool.fromType(dg.gpa, &dg.scratch, ty, dg.pt, dg.mod, kind);
-    }
-
-    fn byteSize(dg: *DeclGen, ctype: CType) u64 {
-        return ctype.byteSize(&dg.ctype_pool, dg.mod);
-    }
-
-    /// Renders a type as a single identifier, generating intermediate typedefs
-    /// if necessary.
-    ///
-    /// This is guaranteed to be valid in both typedefs and declarations/definitions.
-    ///
-    /// There are three type formats in total that we support rendering:
-    ///   | Function            | Example 1 (*u8) | Example 2 ([10]*u8) |
-    ///   |---------------------|-----------------|---------------------|
-    ///   | `renderTypeAndName` | "uint8_t *name" | "uint8_t *name[10]" |
-    ///   | `renderType`        | "uint8_t *"     | "uint8_t *[10]"     |
-    ///
-    fn renderType(dg: *DeclGen, w: *Writer, t: Type) Error!void {
-        try dg.renderCType(w, try dg.ctypeFromType(t, .complete));
-    }
-
-    fn renderCType(dg: *DeclGen, w: *Writer, ctype: CType) Error!void {
-        _ = try renderTypePrefix(dg.pass, &dg.ctype_pool, dg.pt.zcu, w, ctype, .suffix, .{});
-        try renderTypeSuffix(dg.pass, &dg.ctype_pool, dg.pt.zcu, w, ctype, .suffix, .{});
+    /// Renders the C lowering of the given Zig type to `w`. This renders the type name---to render
+    /// a declarator with this type, see instead `renderTypeAndName`.
+    fn renderType(dg: *DeclGen, w: *Writer, ty: Type) (Writer.Error || Allocator.Error)!void {
+        const zcu = dg.pt.zcu;
+        const cty: CType = try .lower(ty, &dg.ctype_deps, dg.arena, zcu);
+        try w.print("{f}", .{cty.fmtTypeName(zcu)});
     }
 
     const IntCastContext = union(enum) {
@@ -1990,7 +1824,7 @@ pub const DeclGen = struct {
             try w.writeAll("zig_lo_");
             try dg.renderTypeForBuiltinFnName(w, src_eff_ty);
             try w.writeByte('(');
-            try context.writeValue(dg, w, .FunctionArgument);
+            try context.writeValue(dg, w, .other);
             try w.writeByte(')');
         } else if (dest_bits > 64 and src_bits <= 64) {
             try w.writeAll("zig_make_");
@@ -2001,7 +1835,7 @@ pub const DeclGen = struct {
                 try dg.renderType(w, src_eff_ty);
                 try w.writeByte(')');
             }
-            try context.writeValue(dg, w, .FunctionArgument);
+            try context.writeValue(dg, w, .other);
             try w.writeByte(')');
         } else {
             assert(!src_is_ptr);
@@ -2010,23 +1844,16 @@ pub const DeclGen = struct {
             try w.writeAll("(zig_hi_");
             try dg.renderTypeForBuiltinFnName(w, src_eff_ty);
             try w.writeByte('(');
-            try context.writeValue(dg, w, .FunctionArgument);
+            try context.writeValue(dg, w, .other);
             try w.writeAll("), zig_lo_");
             try dg.renderTypeForBuiltinFnName(w, src_eff_ty);
             try w.writeByte('(');
-            try context.writeValue(dg, w, .FunctionArgument);
+            try context.writeValue(dg, w, .other);
             try w.writeAll("))");
         }
     }
 
-    /// Renders a type and name in field declaration/definition format.
-    ///
-    /// There are three type formats in total that we support rendering:
-    ///   | Function            | Example 1 (*u8) | Example 2 ([10]*u8) |
-    ///   |---------------------|-----------------|---------------------|
-    ///   | `renderTypeAndName` | "uint8_t *name" | "uint8_t *name[10]" |
-    ///   | `renderType`        | "uint8_t *"     | "uint8_t *[10]"     |
-    ///
+    /// Renders to `w` a C declarator whose type is the C lowering of the given Zig type.
     fn renderTypeAndName(
         dg: *DeclGen,
         w: *Writer,
@@ -2034,73 +1861,47 @@ pub const DeclGen = struct {
         name: CValue,
         qualifiers: CQualifiers,
         alignment: Alignment,
-        kind: CType.Kind,
-    ) !void {
-        try dg.renderCTypeAndName(
-            w,
-            try dg.ctypeFromType(ty, kind),
-            name,
-            qualifiers,
-            CType.AlignAs.fromAlignment(.{
-                .@"align" = alignment,
-                .abi = ty.abiAlignment(dg.pt.zcu),
-            }),
-        );
-    }
-
-    fn renderCTypeAndName(
-        dg: *DeclGen,
-        w: *Writer,
-        ctype: CType,
-        name: CValue,
-        qualifiers: CQualifiers,
-        alignas: CType.AlignAs,
     ) !void {
         const zcu = dg.pt.zcu;
-        switch (alignas.abiOrder()) {
-            .lt => try w.print("zig_under_align({}) ", .{alignas.toByteUnits()}),
+        const ip = &zcu.intern_pool;
+        const cty: CType = try .lower(ty, &dg.ctype_deps, dg.arena, zcu);
+        try w.print("{f}", .{cty.fmtDeclaratorPrefix(zcu)});
+        if (alignment != .none) switch (alignment.order(ty.abiAlignment(zcu))) {
+            .lt => try w.print("zig_under_align({d}) ", .{alignment.toByteUnits().?}),
             .eq => {},
-            .gt => try w.print("zig_align({}) ", .{alignas.toByteUnits()}),
-        }
-
-        try w.print("{f}", .{
-            try renderTypePrefix(dg.pass, &dg.ctype_pool, zcu, w, ctype, .suffix, qualifiers),
-        });
-        try dg.writeName(w, name);
-        try renderTypeSuffix(dg.pass, &dg.ctype_pool, zcu, w, ctype, .suffix, .{});
-        if (ctype.isNonString(&dg.ctype_pool)) try w.writeAll(" zig_nonstring");
-    }
-
-    fn writeName(dg: *DeclGen, w: *Writer, c_value: CValue) !void {
-        switch (c_value) {
+            .gt => try w.print("zig_align({d}) ", .{alignment.toByteUnits().?}),
+        };
+        if (qualifiers.@"const") try w.writeAll("const ");
+        if (qualifiers.@"volatile") try w.writeAll("volatile ");
+        if (qualifiers.restrict) try w.writeAll("restrict ");
+        switch (name) {
             .new_local, .local => |i| try w.print("t{d}", .{i}),
+            .arg => |i| try w.print("a{d}", .{i}),
             .constant => |uav| try renderUavName(w, uav),
-            .nav => |nav| try dg.renderNavName(w, nav),
+            .nav => |nav| try renderNavName(w, nav, ip),
             .identifier => |ident| try w.print("{f}", .{fmtIdentSolo(ident)}),
             else => unreachable,
         }
+        try w.print("{f}", .{cty.fmtDeclaratorSuffix(zcu)});
     }
 
     fn writeCValue(dg: *DeclGen, w: *Writer, c_value: CValue) Error!void {
         switch (c_value) {
             .none, .new_local, .local, .local_ref => unreachable,
             .constant => |uav| try renderUavName(w, uav),
-            .arg, .arg_array => unreachable,
+            .arg => unreachable,
             .field => |i| try w.print("f{d}", .{i}),
-            .nav => |nav| try dg.renderNavName(w, nav),
+            .nav => |nav| try renderNavName(w, nav, &dg.pt.zcu.intern_pool),
             .nav_ref => |nav| {
                 try w.writeByte('&');
-                try dg.renderNavName(w, nav);
+                try renderNavName(w, nav, &dg.pt.zcu.intern_pool);
             },
-            .undef => |ty| try dg.renderUndefValue(w, ty, .Other),
+            .undef => |ty| try dg.renderUndefValue(w, ty, .other),
             .identifier => |ident| try w.print("{f}", .{fmtIdentSolo(ident)}),
             .payload_identifier => |ident| try w.print("{f}.{f}", .{
                 fmtIdentSolo("payload"),
                 fmtIdentSolo(ident),
             }),
-            .ctype_pool_string => |string| try w.print("{f}", .{
-                fmtCTypePoolString(string, &dg.ctype_pool, true),
-            }),
         }
     }
 
@@ -2112,16 +1913,14 @@ pub const DeclGen = struct {
             .local_ref,
             .constant,
             .arg,
-            .arg_array,
-            .ctype_pool_string,
             => unreachable,
             .field => |i| try w.print("f{d}", .{i}),
             .nav => |nav| {
                 try w.writeAll("(*");
-                try dg.renderNavName(w, nav);
+                try renderNavName(w, nav, &dg.pt.zcu.intern_pool);
                 try w.writeByte(')');
             },
-            .nav_ref => |nav| try dg.renderNavName(w, nav),
+            .nav_ref => |nav| try renderNavName(w, nav, &dg.pt.zcu.intern_pool),
             .undef => unreachable,
             .identifier => |ident| try w.print("(*{f})", .{fmtIdentSolo(ident)}),
             .payload_identifier => |ident| try w.print("(*{f}.{f})", .{
@@ -2157,8 +1956,6 @@ pub const DeclGen = struct {
             .field,
             .undef,
             .arg,
-            .arg_array,
-            .ctype_pool_string,
             => unreachable,
             .nav, .identifier, .payload_identifier => {
                 try dg.writeCValue(w, c_value);
@@ -2172,101 +1969,36 @@ pub const DeclGen = struct {
         try dg.writeCValue(w, member);
     }
 
-    fn renderFwdDecl(
-        dg: *DeclGen,
-        nav_index: InternPool.Nav.Index,
-        flags: packed struct {
-            is_const: bool,
-            is_threadlocal: bool,
-            linkage: std.builtin.GlobalLinkage,
-            visibility: std.builtin.SymbolVisibility,
-        },
-    ) !void {
-        const zcu = dg.pt.zcu;
-        const ip = &zcu.intern_pool;
-        const nav = ip.getNav(nav_index);
-        const fwd = &dg.fwd_decl.writer;
-        try fwd.writeAll(switch (flags.linkage) {
-            .internal => "static ",
-            .strong, .weak, .link_once => "zig_extern ",
-        });
-        switch (flags.linkage) {
-            .internal, .strong => {},
-            .weak => try fwd.writeAll("zig_weak_linkage "),
-            .link_once => return dg.fail("TODO: CBE: implement linkonce linkage?", .{}),
-        }
-        switch (flags.linkage) {
-            .internal => {},
-            .strong, .weak, .link_once => try fwd.print("zig_visibility({s}) ", .{@tagName(flags.visibility)}),
-        }
-        if (flags.is_threadlocal and !dg.mod.single_threaded) try fwd.writeAll("zig_threadlocal ");
-        try dg.renderTypeAndName(
-            fwd,
-            .fromInterned(nav.typeOf(ip)),
-            .{ .nav = nav_index },
-            CQualifiers.init(.{ .@"const" = flags.is_const }),
-            nav.getAlignment(),
-            .complete,
-        );
-        try fwd.writeAll(";\n");
-    }
-
-    fn renderNavName(dg: *DeclGen, w: *Writer, nav_index: InternPool.Nav.Index) !void {
-        const zcu = dg.pt.zcu;
-        const ip = &zcu.intern_pool;
-        const nav = ip.getNav(nav_index);
-        if (nav.getExtern(ip)) |@"extern"| {
-            try w.print("{f}", .{
-                fmtIdentSolo(ip.getNav(@"extern".owner_nav).name.toSlice(ip)),
-            });
-        } else {
-            // MSVC has a limit of 4095 character token length limit, and fmtIdent can (worst case),
-            // expand to 3x the length of its input, but let's cut it off at a much shorter limit.
-            const fqn_slice = ip.getNav(nav_index).fqn.toSlice(ip);
-            try w.print("{f}__{d}", .{
-                fmtIdentUnsolo(fqn_slice[0..@min(fqn_slice.len, 100)]),
-                @intFromEnum(nav_index),
-            });
-        }
-    }
-
-    fn renderUavName(w: *Writer, uav: Value) !void {
-        try w.print("__anon_{d}", .{@intFromEnum(uav.toIntern())});
-    }
-
     fn renderTypeForBuiltinFnName(dg: *DeclGen, w: *Writer, ty: Type) !void {
-        try dg.renderCTypeForBuiltinFnName(w, try dg.ctypeFromType(ty, .complete));
-    }
-
-    fn renderCTypeForBuiltinFnName(dg: *DeclGen, w: *Writer, ctype: CType) !void {
-        switch (ctype.info(&dg.ctype_pool)) {
-            else => |ctype_info| try w.print("{c}{d}", .{
-                if (ctype.isBool())
-                    signAbbrev(.unsigned)
-                else if (ctype.isInteger())
-                    signAbbrev(ctype.signedness(dg.mod))
-                else if (ctype.isFloat())
-                    @as(u8, 'f')
-                else if (ctype_info == .pointer)
-                    @as(u8, 'p')
-                else
-                    return dg.fail("TODO: CBE: implement renderTypeForBuiltinFnName for {s} type", .{@tagName(ctype_info)}),
-                if (ctype.isFloat()) ctype.floatActiveBits(dg.mod) else dg.byteSize(ctype) * 8,
+        const zcu = dg.pt.zcu;
+        switch (ty.zigTypeTag(zcu)) {
+            .bool => return w.writeAll("u8"),
+            .float => return w.print("f{d}", .{ty.floatBits(zcu.getTarget())}),
+            else => {},
+        }
+        if (ty.isPtrAtRuntime(zcu)) {
+            return w.print("p{d}", .{zcu.getTarget().ptrBitWidth()});
+        }
+        switch (CType.classifyInt(ty, zcu)) {
+            .void => unreachable, // opv
+            .small => try w.print("{c}{d}", .{
+                signAbbrev(ty.intInfo(zcu).signedness),
+                ty.abiSize(zcu) * 8,
             }),
-            .array => try w.writeAll("big"),
+            .big => try w.writeAll("big"),
         }
     }
 
     fn renderBuiltinInfo(dg: *DeclGen, w: *Writer, ty: Type, info: BuiltinInfo) !void {
-        const ctype = try dg.ctypeFromType(ty, .complete);
-        const is_big = ctype.info(&dg.ctype_pool) == .array;
+        const pt = dg.pt;
+        const zcu = pt.zcu;
+
+        const is_big = lowersToBigInt(ty, zcu);
         switch (info) {
             .none => if (!is_big) return,
             .bits => {},
         }
 
-        const pt = dg.pt;
-        const zcu = pt.zcu;
         const int_info: std.builtin.Type.Int = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else .{
             .signedness = .unsigned,
             .bits = @intCast(ty.bitSize(zcu)),
@@ -2275,7 +2007,7 @@ pub const DeclGen = struct {
         if (is_big) try w.print(", {}", .{int_info.signedness == .signed});
         try w.print(", {f}", .{try dg.fmtIntLiteralDec(
             try pt.intValue(if (is_big) .u16 else .u8, int_info.bits),
-            .FunctionArgument,
+            .other,
         )});
     }
 
@@ -2286,15 +2018,13 @@ pub const DeclGen = struct {
         base: u8,
         case: std.fmt.Case,
     ) !std.fmt.Alt(FormatIntLiteralContext, formatIntLiteral) {
-        const zcu = dg.pt.zcu;
-        const kind = loc.toCTypeKind();
-        const ty = val.typeOf(zcu);
+        // If there's a bigint type involved, mark a dependency on it.
+        const cty: CType = try .lower(val.typeOf(dg.pt.zcu), &dg.ctype_deps, dg.arena, dg.pt.zcu);
         return .{ .data = .{
             .dg = dg,
-            .int_info = ty.intInfo(zcu),
-            .kind = kind,
-            .ctype = try dg.ctypeFromType(ty, kind),
+            .loc = loc,
             .val = val,
+            .cty = cty,
             .base = base,
             .case = case,
         } };
@@ -2317,339 +2047,11 @@ pub const DeclGen = struct {
     }
 };
 
-const CTypeFix = enum { prefix, suffix };
-const CQualifiers = std.enums.EnumSet(enum { @"const", @"volatile", restrict });
-const Const = CQualifiers.init(.{ .@"const" = true });
-const RenderCTypeTrailing = enum {
-    no_space,
-    maybe_space,
-
-    pub fn format(self: @This(), w: *Writer) Writer.Error!void {
-        switch (self) {
-            .no_space => {},
-            .maybe_space => try w.writeByte(' '),
-        }
-    }
+const CQualifiers = packed struct {
+    @"const": bool = false,
+    @"volatile": bool = false,
+    restrict: bool = false,
 };
-fn renderAlignedTypeName(w: *Writer, ctype: CType) !void {
-    try w.print("anon__aligned_{d}", .{@intFromEnum(ctype.index)});
-}
-fn renderFwdDeclTypeName(
-    zcu: *Zcu,
-    w: *Writer,
-    ctype: CType,
-    fwd_decl: CType.Info.FwdDecl,
-    attributes: []const u8,
-) !void {
-    const ip = &zcu.intern_pool;
-    try w.print("{s} {s}", .{ @tagName(fwd_decl.tag), attributes });
-    switch (fwd_decl.name) {
-        .anon => try w.print("anon__lazy_{d}", .{@intFromEnum(ctype.index)}),
-        .index => |index| try w.print("{f}__{d}", .{
-            fmtIdentUnsolo(Type.fromInterned(index).containerTypeName(ip).toSlice(&zcu.intern_pool)),
-            @intFromEnum(index),
-        }),
-    }
-}
-fn renderTypePrefix(
-    pass: DeclGen.Pass,
-    ctype_pool: *const CType.Pool,
-    zcu: *Zcu,
-    w: *Writer,
-    ctype: CType,
-    parent_fix: CTypeFix,
-    qualifiers: CQualifiers,
-) Writer.Error!RenderCTypeTrailing {
-    var trailing = RenderCTypeTrailing.maybe_space;
-    switch (ctype.info(ctype_pool)) {
-        .basic => |basic_info| try w.writeAll(@tagName(basic_info)),
-
-        .pointer => |pointer_info| {
-            try w.print("{f}*", .{try renderTypePrefix(
-                pass,
-                ctype_pool,
-                zcu,
-                w,
-                pointer_info.elem_ctype,
-                .prefix,
-                CQualifiers.init(.{
-                    .@"const" = pointer_info.@"const",
-                    .@"volatile" = pointer_info.@"volatile",
-                }),
-            )});
-            trailing = .no_space;
-        },
-
-        .aligned => switch (pass) {
-            .nav => |nav| try w.print("nav__{d}_{d}", .{
-                @intFromEnum(nav), @intFromEnum(ctype.index),
-            }),
-            .uav => |uav| try w.print("uav__{d}_{d}", .{
-                @intFromEnum(uav), @intFromEnum(ctype.index),
-            }),
-            .flush => try renderAlignedTypeName(w, ctype),
-        },
-
-        .array, .vector => |sequence_info| {
-            const child_trailing = try renderTypePrefix(
-                pass,
-                ctype_pool,
-                zcu,
-                w,
-                sequence_info.elem_ctype,
-                .suffix,
-                qualifiers,
-            );
-            switch (parent_fix) {
-                .prefix => {
-                    try w.print("{f}(", .{child_trailing});
-                    return .no_space;
-                },
-                .suffix => return child_trailing,
-            }
-        },
-
-        .fwd_decl => |fwd_decl_info| switch (fwd_decl_info.name) {
-            .anon => switch (pass) {
-                .nav => |nav| try w.print("nav__{d}_{d}", .{
-                    @intFromEnum(nav), @intFromEnum(ctype.index),
-                }),
-                .uav => |uav| try w.print("uav__{d}_{d}", .{
-                    @intFromEnum(uav), @intFromEnum(ctype.index),
-                }),
-                .flush => try renderFwdDeclTypeName(zcu, w, ctype, fwd_decl_info, ""),
-            },
-            .index => try renderFwdDeclTypeName(zcu, w, ctype, fwd_decl_info, ""),
-        },
-
-        .aggregate => |aggregate_info| switch (aggregate_info.name) {
-            .anon => {
-                try w.print("{s} {s}", .{
-                    @tagName(aggregate_info.tag),
-                    if (aggregate_info.@"packed") "zig_packed(" else "",
-                });
-                try renderFields(zcu, w, ctype_pool, aggregate_info, 1);
-                if (aggregate_info.@"packed") try w.writeByte(')');
-            },
-            .fwd_decl => |fwd_decl| return renderTypePrefix(
-                pass,
-                ctype_pool,
-                zcu,
-                w,
-                fwd_decl,
-                parent_fix,
-                qualifiers,
-            ),
-        },
-
-        .function => |function_info| {
-            const child_trailing = try renderTypePrefix(
-                pass,
-                ctype_pool,
-                zcu,
-                w,
-                function_info.return_ctype,
-                .suffix,
-                .{},
-            );
-            switch (parent_fix) {
-                .prefix => {
-                    try w.print("{f}(", .{child_trailing});
-                    return .no_space;
-                },
-                .suffix => return child_trailing,
-            }
-        },
-    }
-    var qualifier_it = qualifiers.iterator();
-    while (qualifier_it.next()) |qualifier| {
-        try w.print("{f}{s}", .{ trailing, @tagName(qualifier) });
-        trailing = .maybe_space;
-    }
-    return trailing;
-}
-fn renderTypeSuffix(
-    pass: DeclGen.Pass,
-    ctype_pool: *const CType.Pool,
-    zcu: *Zcu,
-    w: *Writer,
-    ctype: CType,
-    parent_fix: CTypeFix,
-    qualifiers: CQualifiers,
-) Writer.Error!void {
-    switch (ctype.info(ctype_pool)) {
-        .basic, .aligned, .fwd_decl, .aggregate => {},
-        .pointer => |pointer_info| try renderTypeSuffix(
-            pass,
-            ctype_pool,
-            zcu,
-            w,
-            pointer_info.elem_ctype,
-            .prefix,
-            .{},
-        ),
-        .array, .vector => |sequence_info| {
-            switch (parent_fix) {
-                .prefix => try w.writeByte(')'),
-                .suffix => {},
-            }
-
-            try w.print("[{}]", .{sequence_info.len});
-            try renderTypeSuffix(pass, ctype_pool, zcu, w, sequence_info.elem_ctype, .suffix, .{});
-        },
-        .function => |function_info| {
-            switch (parent_fix) {
-                .prefix => try w.writeByte(')'),
-                .suffix => {},
-            }
-
-            try w.writeByte('(');
-            var need_comma = false;
-            for (0..function_info.param_ctypes.len) |param_index| {
-                const param_type = function_info.param_ctypes.at(param_index, ctype_pool);
-                if (need_comma) try w.writeAll(", ");
-                need_comma = true;
-                const trailing =
-                    try renderTypePrefix(pass, ctype_pool, zcu, w, param_type, .suffix, qualifiers);
-                if (qualifiers.contains(.@"const")) try w.print("{f}a{d}", .{ trailing, param_index });
-                try renderTypeSuffix(pass, ctype_pool, zcu, w, param_type, .suffix, .{});
-            }
-            if (function_info.varargs) {
-                if (need_comma) try w.writeAll(", ");
-                need_comma = true;
-                try w.writeAll("...");
-            }
-            if (!need_comma) try w.writeAll("void");
-            try w.writeByte(')');
-
-            try renderTypeSuffix(pass, ctype_pool, zcu, w, function_info.return_ctype, .suffix, .{});
-        },
-    }
-}
-fn renderFields(
-    zcu: *Zcu,
-    w: *Writer,
-    ctype_pool: *const CType.Pool,
-    aggregate_info: CType.Info.Aggregate,
-    indent: usize,
-) !void {
-    try w.writeAll("{\n");
-    for (0..aggregate_info.fields.len) |field_index| {
-        const field_info = aggregate_info.fields.at(field_index, ctype_pool);
-        try w.splatByteAll(' ', indent + 1);
-        switch (field_info.alignas.abiOrder()) {
-            .lt => {
-                std.debug.assert(aggregate_info.@"packed");
-                if (field_info.alignas.@"align" != .@"1") try w.print("zig_under_align({}) ", .{
-                    field_info.alignas.toByteUnits(),
-                });
-            },
-            .eq => if (aggregate_info.@"packed" and field_info.alignas.@"align" != .@"1")
-                try w.print("zig_align({}) ", .{field_info.alignas.toByteUnits()}),
-            .gt => {
-                std.debug.assert(field_info.alignas.@"align" != .@"1");
-                try w.print("zig_align({}) ", .{field_info.alignas.toByteUnits()});
-            },
-        }
-        const trailing = try renderTypePrefix(
-            .flush,
-            ctype_pool,
-            zcu,
-            w,
-            field_info.ctype,
-            .suffix,
-            .{},
-        );
-        try w.print("{f}{f}", .{ trailing, fmtCTypePoolString(field_info.name, ctype_pool, true) });
-        try renderTypeSuffix(.flush, ctype_pool, zcu, w, field_info.ctype, .suffix, .{});
-        if (field_info.ctype.isNonString(ctype_pool)) try w.writeAll(" zig_nonstring");
-        try w.writeAll(";\n");
-    }
-    try w.splatByteAll(' ', indent);
-    try w.writeByte('}');
-}
-
-pub fn genTypeDecl(
-    zcu: *Zcu,
-    w: *Writer,
-    global_ctype_pool: *const CType.Pool,
-    global_ctype: CType,
-    pass: DeclGen.Pass,
-    decl_ctype_pool: *const CType.Pool,
-    decl_ctype: CType,
-    found_existing: bool,
-) !void {
-    switch (global_ctype.info(global_ctype_pool)) {
-        .basic, .pointer, .array, .vector, .function => {},
-        .aligned => |aligned_info| {
-            if (!found_existing) {
-                std.debug.assert(aligned_info.alignas.abiOrder().compare(.lt));
-                try w.print("typedef zig_under_align({d}) ", .{aligned_info.alignas.toByteUnits()});
-                try w.print("{f}", .{try renderTypePrefix(
-                    .flush,
-                    global_ctype_pool,
-                    zcu,
-                    w,
-                    aligned_info.ctype,
-                    .suffix,
-                    .{},
-                )});
-                try renderAlignedTypeName(w, global_ctype);
-                try renderTypeSuffix(.flush, global_ctype_pool, zcu, w, aligned_info.ctype, .suffix, .{});
-                try w.writeAll(";\n");
-            }
-            switch (pass) {
-                .nav, .uav => {
-                    try w.writeAll("typedef ");
-                    _ = try renderTypePrefix(.flush, global_ctype_pool, zcu, w, global_ctype, .suffix, .{});
-                    try w.writeByte(' ');
-                    _ = try renderTypePrefix(pass, decl_ctype_pool, zcu, w, decl_ctype, .suffix, .{});
-                    try w.writeAll(";\n");
-                },
-                .flush => {},
-            }
-        },
-        .fwd_decl => |fwd_decl_info| switch (fwd_decl_info.name) {
-            .anon => switch (pass) {
-                .nav, .uav => {
-                    try w.writeAll("typedef ");
-                    _ = try renderTypePrefix(.flush, global_ctype_pool, zcu, w, global_ctype, .suffix, .{});
-                    try w.writeByte(' ');
-                    _ = try renderTypePrefix(pass, decl_ctype_pool, zcu, w, decl_ctype, .suffix, .{});
-                    try w.writeAll(";\n");
-                },
-                .flush => {},
-            },
-            .index => |index| if (!found_existing) {
-                const ip = &zcu.intern_pool;
-                const ty: Type = .fromInterned(index);
-                _ = try renderTypePrefix(.flush, global_ctype_pool, zcu, w, global_ctype, .suffix, .{});
-                try w.writeByte(';');
-                const file_scope = ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip);
-                if (!zcu.fileByIndex(file_scope).mod.?.strip) try w.print(" /* {f} */", .{
-                    ty.containerTypeName(ip).fmt(ip),
-                });
-                try w.writeByte('\n');
-            },
-        },
-        .aggregate => |aggregate_info| switch (aggregate_info.name) {
-            .anon => {},
-            .fwd_decl => |fwd_decl| if (!found_existing) {
-                try renderFwdDeclTypeName(
-                    zcu,
-                    w,
-                    fwd_decl,
-                    fwd_decl.info(global_ctype_pool).fwd_decl,
-                    if (aggregate_info.@"packed") "zig_packed(" else "",
-                );
-                try w.writeByte(' ');
-                try renderFields(zcu, w, global_ctype_pool, aggregate_info, 0);
-                if (aggregate_info.@"packed") try w.writeByte(')');
-                try w.writeAll(";\n");
-            },
-        },
-    }
-}
 
 pub fn genGlobalAsm(zcu: *Zcu, w: *Writer) !void {
     for (zcu.global_assembly.values()) |asm_source| {
@@ -2657,200 +2059,128 @@ pub fn genGlobalAsm(zcu: *Zcu, w: *Writer) !void {
     }
 }
 
-pub fn genErrDecls(o: *Object) Error!void {
-    const pt = o.dg.pt;
-    const zcu = pt.zcu;
+pub fn genErrDecls(
+    zcu: *const Zcu,
+    w: *Writer,
+    slice_const_u8_sentinel_0_type_name: []const u8,
+) Writer.Error!void {
     const ip = &zcu.intern_pool;
-    const w = &o.code.writer;
 
-    var max_name_len: usize = 0;
-    // do not generate an invalid empty enum when the global error set is empty
     const names = ip.global_error_set.getNamesFromMainThread();
+    // Don't generate an invalid empty enum if the global error set is empty!
     if (names.len > 0) {
-        try w.writeAll("enum {");
-        o.indent();
-        try o.newline();
+        try w.writeAll("enum {\n");
         for (names, 1..) |name_nts, value| {
-            const name = name_nts.toSlice(ip);
-            max_name_len = @max(name.len, max_name_len);
-            const err_val = try pt.intern(.{ .err = .{
-                .ty = .anyerror_type,
-                .name = name_nts,
-            } });
-            try o.dg.renderValue(w, Value.fromInterned(err_val), .Other);
-            try w.print(" = {d}u,", .{value});
-            try o.newline();
+            try w.writeByte(' ');
+            try renderErrorName(w, name_nts.toSlice(ip));
+            try w.print(" = {d}u,\n", .{value});
         }
-        try o.outdent();
-        try w.writeAll("};");
-        try o.newline();
+        try w.writeAll("};\n");
     }
-    const array_identifier = "zig_errorName";
-    const name_prefix = array_identifier ++ "_";
-    const name_buf = try o.dg.gpa.alloc(u8, name_prefix.len + max_name_len);
-    defer o.dg.gpa.free(name_buf);
 
-    @memcpy(name_buf[0..name_prefix.len], name_prefix);
-    for (names) |name| {
-        const name_slice = name.toSlice(ip);
-        @memcpy(name_buf[name_prefix.len..][0..name_slice.len], name_slice);
-        const identifier = name_buf[0 .. name_prefix.len + name_slice.len];
-
-        const name_ty = try pt.arrayType(.{
-            .len = name_slice.len,
-            .child = .u8_type,
-            .sentinel = .zero_u8,
-        });
-        const name_val = try pt.intern(.{ .aggregate = .{
-            .ty = name_ty.toIntern(),
-            .storage = .{ .bytes = name.toString() },
-        } });
-
-        try w.writeAll("static ");
-        try o.dg.renderTypeAndName(
-            w,
-            name_ty,
-            .{ .identifier = identifier },
-            Const,
-            .none,
-            .complete,
+    for (names) |name_nts| {
+        const name = name_nts.toSlice(ip);
+        try w.print(
+            "static uint8_t const zig_errorName_{f}[] = {f};\n",
+            .{ fmtIdentUnsolo(name), fmtStringLiteral(name, 0) },
         );
-        try w.writeAll(" = ");
-        try o.dg.renderValue(w, Value.fromInterned(name_val), .StaticInitializer);
-        try w.writeByte(';');
-        try o.newline();
     }
 
-    const name_array_ty = try pt.arrayType(.{
-        .len = 1 + names.len,
-        .child = .slice_const_u8_sentinel_0_type,
-    });
-
-    try w.writeAll("static ");
-    try o.dg.renderTypeAndName(
-        w,
-        name_array_ty,
-        .{ .identifier = array_identifier },
-        Const,
-        .none,
-        .complete,
+    try w.print(
+        "static {s} const zig_errorName[{d}] = {{",
+        .{ slice_const_u8_sentinel_0_type_name, names.len },
     );
-    try w.writeAll(" = {");
-    for (names, 1..) |name_nts, val| {
+    if (names.len > 0) try w.writeByte('\n');
+    for (names) |name_nts| {
         const name = name_nts.toSlice(ip);
-        if (val > 1) try w.writeAll(", ");
-        try w.print("{{" ++ name_prefix ++ "{f}, {f}}}", .{
-            fmtIdentUnsolo(name),
-            try o.dg.fmtIntLiteralDec(try pt.intValue(.usize, name.len), .StaticInitializer),
-        });
+        try w.print(
+            " {{zig_errorName_{f},{d}}},\n",
+            .{ fmtIdentUnsolo(name), name.len },
+        );
     }
-    try w.writeAll("};");
-    try o.newline();
+    try w.writeAll("};\n");
 }
 
-pub fn genLazyFn(o: *Object, lazy_ctype_pool: *const CType.Pool, lazy_fn: LazyFnMap.Entry) Error!void {
-    const pt = o.dg.pt;
-    const zcu = pt.zcu;
+pub fn genTagNameFn(
+    zcu: *const Zcu,
+    w: *Writer,
+    slice_const_u8_sentinel_0_type_name: []const u8,
+    enum_ty: Type,
+    enum_type_name: []const u8,
+) Writer.Error!void {
     const ip = &zcu.intern_pool;
-    const ctype_pool = &o.dg.ctype_pool;
-    const w = &o.code.writer;
-    const key = lazy_fn.key_ptr.*;
-    const val = lazy_fn.value_ptr;
-    switch (key) {
-        .tag_name => |enum_ty_ip| {
-            const enum_ty: Type = .fromInterned(enum_ty_ip);
-            const name_slice_ty: Type = .slice_const_u8_sentinel_0;
+    const loaded_enum = ip.loadEnumType(enum_ty.toIntern());
+    assert(loaded_enum.field_names.len > 0);
+    if (Type.fromInterned(loaded_enum.int_tag_type).bitSize(zcu) > 64) {
+        @panic("TODO CBE: tagName for enum over 128 bits");
+    }
 
-            try w.writeAll("static ");
-            try o.dg.renderType(w, name_slice_ty);
-            try w.print(" {f}(", .{val.fn_name.fmt(lazy_ctype_pool)});
-            try o.dg.renderTypeAndName(w, enum_ty, .{ .identifier = "tag" }, Const, .none, .complete);
-            try w.writeAll(") {");
-            o.indent();
-            try o.newline();
-            try w.writeAll("switch (tag) {");
-            o.indent();
-            try o.newline();
-            const tag_names = enum_ty.enumFields(zcu);
-            for (0..tag_names.len) |tag_index| {
-                const tag_name = tag_names.get(ip)[tag_index];
-                const tag_name_len = tag_name.length(ip);
-                const tag_val = try pt.enumValueFieldIndex(enum_ty, @intCast(tag_index));
+    try w.print("static {s} zig_tagName_{f}__{d}({s} tag) {{\n", .{
+        slice_const_u8_sentinel_0_type_name,
+        fmtIdentUnsolo(loaded_enum.name.toSlice(ip)),
+        @intFromEnum(enum_ty.toIntern()),
+        enum_type_name,
+    });
+    for (loaded_enum.field_names.get(ip), 0..) |field_name, field_index| {
+        try w.print(" static uint8_t const name{d}[] = {f};\n", .{
+            field_index, fmtStringLiteral(field_name.toSlice(ip), 0),
+        });
+    }
 
-                const name_ty = try pt.arrayType(.{
-                    .len = tag_name_len,
-                    .child = .u8_type,
-                    .sentinel = .zero_u8,
-                });
-                const name_val = try pt.intern(.{ .aggregate = .{
-                    .ty = name_ty.toIntern(),
-                    .storage = .{ .bytes = tag_name.toString() },
-                } });
+    try w.writeAll(" switch (tag) {\n");
+    const field_values = loaded_enum.field_values.get(ip);
+    for (loaded_enum.field_names.get(ip), 0..) |field_name, field_index| {
+        const field_int: u64 = int: {
+            if (field_values.len == 0) break :int field_index;
+            const field_val: Value = .fromInterned(field_values[field_index]);
+            break :int field_val.toUnsignedInt(zcu);
+        };
+        try w.print("  case {d}: return ({s}){{name{d},{d}}};\n", .{
+            field_int,
+            slice_const_u8_sentinel_0_type_name,
+            field_index,
+            field_name.toSlice(ip).len,
+        });
+    }
+    try w.writeAll(
+        \\ }
+        \\ zig_unreachable();
+        \\}
+        \\
+    );
+}
 
-                try w.print("case {f}: {{", .{
-                    try o.dg.fmtIntLiteralDec(tag_val.intFromEnum(zcu), .Other),
-                });
-                o.indent();
-                try o.newline();
-                try w.writeAll("static ");
-                try o.dg.renderTypeAndName(w, name_ty, .{ .identifier = "name" }, Const, .none, .complete);
-                try w.writeAll(" = ");
-                try o.dg.renderValue(w, Value.fromInterned(name_val), .StaticInitializer);
-                try w.writeByte(';');
-                try o.newline();
-                try w.writeAll("return (");
-                try o.dg.renderType(w, name_slice_ty);
-                try w.print("){{{f}, {f}}};", .{
-                    fmtIdentUnsolo("name"),
-                    try o.dg.fmtIntLiteralDec(try pt.intValue(.usize, tag_name_len), .Other),
-                });
-                try o.newline();
-                try o.outdent();
-                try w.writeByte('}');
-                try o.newline();
-            }
-            try o.outdent();
-            try w.writeByte('}');
-            try o.newline();
-            try airUnreach(o);
-            try o.outdent();
-            try w.writeByte('}');
-            try o.newline();
-        },
-        .never_tail, .never_inline => |fn_nav_index| {
-            const fn_val = zcu.navValue(fn_nav_index);
-            const fn_ctype = try o.dg.ctypeFromType(fn_val.typeOf(zcu), .complete);
-            const fn_info = fn_ctype.info(ctype_pool).function;
-            const fn_name = fmtCTypePoolString(val.fn_name, lazy_ctype_pool, true);
+pub fn genLazyCallModifierFn(
+    dg: *DeclGen,
+    fn_nav: InternPool.Nav.Index,
+    kind: enum { never_tail, never_inline },
+    w: *Writer,
+) Error!void {
+    const zcu = dg.pt.zcu;
+    const ip = &zcu.intern_pool;
 
-            const fwd = &o.dg.fwd_decl.writer;
-            try fwd.print("static zig_{s} ", .{@tagName(key)});
-            try o.dg.renderFunctionSignature(fwd, fn_val, ip.getNav(fn_nav_index).getAlignment(), .forward, .{
-                .fmt_ctype_pool_string = fn_name,
-            });
-            try fwd.writeAll(";\n");
+    const fn_val = zcu.navValue(fn_nav);
 
-            try w.print("zig_{s} ", .{@tagName(key)});
-            try o.dg.renderFunctionSignature(w, fn_val, .none, .complete, .{
-                .fmt_ctype_pool_string = fn_name,
-            });
-            try w.writeAll(" {");
-            o.indent();
-            try o.newline();
-            try w.writeAll("return ");
-            try o.dg.renderNavName(w, fn_nav_index);
-            try w.writeByte('(');
-            for (0..fn_info.param_ctypes.len) |arg| {
-                if (arg > 0) try w.writeAll(", ");
-                try w.print("a{d}", .{arg});
-            }
-            try w.writeAll(");");
-            try o.newline();
-            try o.outdent();
-            try w.writeByte('}');
-            try o.newline();
-        },
+    try w.print("static zig_{t} ", .{kind});
+    try dg.renderFunctionSignature(w, fn_val, .none, .definition, switch (kind) {
+        .never_tail => .{ .nav_never_tail = fn_nav },
+        .never_inline => .{ .nav_never_inline = fn_nav },
+    });
+    try w.writeAll(" {\n return ");
+    try renderNavName(w, fn_nav, ip);
+    try w.writeByte('(');
+    {
+        const func_type = ip.indexToKey(fn_val.typeOf(zcu).toIntern()).func_type;
+        var c_param_index: u32 = 0;
+        for (func_type.param_types.get(ip)) |param_ty_ip| {
+            const param_ty: Type = .fromInterned(param_ty_ip);
+            if (!param_ty.hasRuntimeBits(zcu)) continue;
+            if (c_param_index != 0) try w.writeAll(", ");
+            try w.print("a{d}", .{c_param_index});
+            c_param_index += 1;
+        }
     }
+    try w.writeAll(");\n}\n");
 }
 
 pub fn generate(
@@ -2869,110 +2199,109 @@ pub fn generate(
 
     const func = zcu.funcInfo(func_index);
 
+    var arena: std.heap.ArenaAllocator = .init(gpa);
+    defer arena.deinit();
+
     var function: Function = .{
         .value_map = .init(gpa),
         .air = air.*,
         .liveness = liveness.*.?,
         .func_index = func_index,
-        .object = .{
-            .dg = .{
-                .gpa = gpa,
-                .pt = pt,
-                .mod = zcu.navFileScope(func.owner_nav).mod.?,
-                .error_msg = null,
-                .pass = .{ .nav = func.owner_nav },
-                .is_naked_fn = Type.fromInterned(func.ty).fnCallingConvention(zcu) == .naked,
-                .expected_block = null,
-                .fwd_decl = .init(gpa),
-                .ctype_pool = .empty,
-                .scratch = .empty,
-                .uavs = .empty,
-            },
-            .code_header = .init(gpa),
-            .code = .init(gpa),
-            .indent_counter = 0,
+        .dg = .{
+            .gpa = gpa,
+            .arena = arena.allocator(),
+            .pt = pt,
+            .mod = zcu.navFileScope(func.owner_nav).mod.?,
+            .error_msg = null,
+            .owner_nav = func.owner_nav.toOptional(),
+            .is_naked_fn = Type.fromInterned(func.ty).fnCallingConvention(zcu) == .naked,
+            .expected_block = null,
+            .ctype_deps = .empty,
+            .uavs = .empty,
         },
-        .lazy_fns = .empty,
+        .code = .init(gpa),
+        .indent_counter = 0,
+        .need_tag_name_funcs = .empty,
+        .need_never_tail_funcs = .empty,
+        .need_never_inline_funcs = .empty,
     };
     defer {
-        function.object.code_header.deinit();
-        function.object.code.deinit();
-        function.object.dg.fwd_decl.deinit();
-        function.object.dg.ctype_pool.deinit(gpa);
-        function.object.dg.scratch.deinit(gpa);
-        function.object.dg.uavs.deinit(gpa);
+        function.code.deinit();
+        function.dg.ctype_deps.deinit(gpa);
+        function.dg.uavs.deinit(gpa);
         function.deinit();
     }
-    try function.object.dg.ctype_pool.init(gpa);
 
-    genFunc(&function) catch |err| switch (err) {
-        error.AnalysisFail => return zcu.codegenFailMsg(func.owner_nav, function.object.dg.error_msg.?),
-        error.OutOfMemory => return error.OutOfMemory,
+    var fwd_decl: Writer.Allocating = .init(gpa);
+    defer fwd_decl.deinit();
+
+    var code_header: Writer.Allocating = .init(gpa);
+    defer code_header.deinit();
+
+    genFunc(&function, &fwd_decl.writer, &code_header.writer) catch |err| switch (err) {
+        error.AnalysisFail => return zcu.codegenFailMsg(func.owner_nav, function.dg.error_msg.?),
         error.WriteFailed => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
     };
 
     var mir: Mir = .{
-        .uavs = .empty,
-        .code = &.{},
-        .code_header = &.{},
         .fwd_decl = &.{},
-        .ctype_pool = .empty,
-        .lazy_fns = .empty,
+        .code_header = &.{},
+        .code = &.{},
+        .ctype_deps = function.dg.ctype_deps.move(),
+        .need_uavs = function.dg.uavs.move(),
+        .need_tag_name_funcs = function.need_tag_name_funcs.move(),
+        .need_never_tail_funcs = function.need_never_tail_funcs.move(),
+        .need_never_inline_funcs = function.need_never_inline_funcs.move(),
     };
     errdefer mir.deinit(gpa);
-    mir.uavs = function.object.dg.uavs.move();
-    mir.code_header = try function.object.code_header.toOwnedSlice();
-    mir.code = try function.object.code.toOwnedSlice();
-    mir.fwd_decl = try function.object.dg.fwd_decl.toOwnedSlice();
-    mir.ctype_pool = function.object.dg.ctype_pool.move();
-    mir.lazy_fns = function.lazy_fns.move();
+    mir.fwd_decl = try fwd_decl.toOwnedSlice();
+    mir.code_header = try code_header.toOwnedSlice();
+    mir.code = try function.code.toOwnedSlice();
     return mir;
 }
 
-pub fn genFunc(f: *Function) Error!void {
+pub fn genFunc(f: *Function, fwd_decl_writer: *Writer, header_writer: *Writer) Error!void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const o = &f.object;
-    const zcu = o.dg.pt.zcu;
+    const zcu = f.dg.pt.zcu;
     const ip = &zcu.intern_pool;
-    const gpa = o.dg.gpa;
-    const nav_index = o.dg.pass.nav;
+    const gpa = f.dg.gpa;
+    const nav_index = f.dg.owner_nav.unwrap().?;
     const nav_val = zcu.navValue(nav_index);
     const nav = ip.getNav(nav_index);
 
-    const fwd = &o.dg.fwd_decl.writer;
-    try fwd.writeAll("static ");
-    try o.dg.renderFunctionSignature(
-        fwd,
+    try fwd_decl_writer.writeAll("static ");
+    try f.dg.renderFunctionSignature(
+        fwd_decl_writer,
         nav_val,
         nav.status.fully_resolved.alignment,
-        .forward,
+        .forward_decl,
         .{ .nav = nav_index },
     );
-    try fwd.writeAll(";\n");
+    try fwd_decl_writer.writeAll(";\n");
 
-    const ch = &o.code_header.writer;
     if (nav.status.fully_resolved.@"linksection".toSlice(ip)) |s|
-        try ch.print("zig_linksection_fn({f}) ", .{fmtStringLiteral(s, null)});
-    try o.dg.renderFunctionSignature(
-        ch,
+        try header_writer.print("zig_linksection_fn({f}) ", .{fmtStringLiteral(s, null)});
+    try f.dg.renderFunctionSignature(
+        header_writer,
         nav_val,
         .none,
-        .complete,
+        .definition,
         .{ .nav = nav_index },
     );
-    try ch.writeAll(" {\n ");
+    try header_writer.writeAll(" {\n ");
 
     f.free_locals_map.clearRetainingCapacity();
 
     const main_body = f.air.getMainBody();
-    o.indent();
+    f.indent();
     try genBodyResolveState(f, undefined, &.{}, main_body, true);
-    try o.outdent();
-    try o.code.writer.writeByte('}');
-    try o.newline();
-    if (o.dg.expected_block) |_|
+    try f.outdent();
+    try f.code.writer.writeByte('}');
+    try f.newline();
+    if (f.dg.expected_block) |_|
         return f.fail("runtime code not allowed in naked function", .{});
 
     // Take advantage of the free_locals map to bucket locals per type. All
@@ -2986,155 +2315,204 @@ pub fn genFunc(f: *Function) Error!void {
         if (!should_emit) continue;
         const local = f.locals.items[local_index];
         log.debug("inserting local {d} into free_locals", .{local_index});
-        const gop = try free_locals.getOrPut(gpa, local.getType());
+        const gop = try free_locals.getOrPut(gpa, local);
         if (!gop.found_existing) gop.value_ptr.* = .{};
         try gop.value_ptr.putNoClobber(gpa, local_index, {});
     }
 
     const SortContext = struct {
+        zcu: *const Zcu,
         keys: []const LocalType,
 
         pub fn lessThan(ctx: @This(), lhs_index: usize, rhs_index: usize) bool {
-            const lhs_ty = ctx.keys[lhs_index];
-            const rhs_ty = ctx.keys[rhs_index];
-            return lhs_ty.alignas.order(rhs_ty.alignas).compare(.gt);
+            const lhs = ctx.keys[lhs_index];
+            const rhs = ctx.keys[rhs_index];
+            const lhs_align = switch (lhs.alignment) {
+                .none => lhs.type.abiAlignment(ctx.zcu),
+                else => |a| a,
+            };
+            const rhs_align = switch (rhs.alignment) {
+                .none => rhs.type.abiAlignment(ctx.zcu),
+                else => |a| a,
+            };
+            return Alignment.compareStrict(lhs_align, .gt, rhs_align);
         }
     };
-    free_locals.sort(SortContext{ .keys = free_locals.keys() });
+    free_locals.sort(SortContext{
+        .zcu = zcu,
+        .keys = free_locals.keys(),
+    });
 
     for (free_locals.values()) |list| {
         for (list.keys()) |local_index| {
             const local = f.locals.items[local_index];
-            try o.dg.renderCTypeAndName(ch, local.ctype, .{ .local = local_index }, .{}, local.flags.alignas);
-            try ch.writeAll(";\n ");
+            try f.dg.renderTypeAndName(header_writer, local.type, .{ .local = local_index }, .{}, local.alignment);
+            try header_writer.writeAll(";\n ");
         }
     }
 }
 
-pub fn genDecl(o: *Object) Error!void {
+pub fn genDecl(dg: *DeclGen, w: *Writer) Error!void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const pt = o.dg.pt;
+    const pt = dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const nav = ip.getNav(o.dg.pass.nav);
+    const nav = ip.getNav(dg.owner_nav.unwrap().?);
     const nav_ty: Type = .fromInterned(nav.typeOf(ip));
 
-    if (!nav_ty.hasRuntimeBits(zcu)) return;
-    switch (ip.indexToKey(nav.status.fully_resolved.val)) {
-        .@"extern" => |@"extern"| {
-            if (!ip.isFunctionType(nav_ty.toIntern())) return o.dg.renderFwdDecl(o.dg.pass.nav, .{
-                .is_const = @"extern".is_const,
-                .is_threadlocal = @"extern".is_threadlocal,
-                .linkage = @"extern".linkage,
-                .visibility = @"extern".visibility,
-            });
+    const is_const: bool, const is_threadlocal: bool, const init_val: Value = switch (ip.indexToKey(nav.status.fully_resolved.val)) {
+        else => .{ true, false, .fromInterned(nav.status.fully_resolved.val) },
+        .variable => |v| .{ false, v.is_threadlocal, .fromInterned(v.init) },
+        .@"extern" => return,
+    };
 
-            const fwd = &o.dg.fwd_decl.writer;
-            try fwd.writeAll("zig_extern ");
-            try o.dg.renderFunctionSignature(
-                fwd,
-                Value.fromInterned(nav.status.fully_resolved.val),
-                nav.status.fully_resolved.alignment,
-                .forward,
-                .{ .@"export" = .{
-                    .main_name = nav.name,
-                    .extern_name = nav.name,
-                } },
-            );
-            try fwd.writeAll(";\n");
-        },
-        .variable => |variable| {
-            try o.dg.renderFwdDecl(o.dg.pass.nav, .{
-                .is_const = false,
-                .is_threadlocal = variable.is_threadlocal,
-                .linkage = .internal,
-                .visibility = .default,
-            });
-            const w = &o.code.writer;
-            if (variable.is_threadlocal and !o.dg.mod.single_threaded) try w.writeAll("zig_threadlocal ");
-            if (nav.status.fully_resolved.@"linksection".toSlice(&zcu.intern_pool)) |s|
-                try w.print("zig_linksection({f}) ", .{fmtStringLiteral(s, null)});
-            try o.dg.renderTypeAndName(
-                w,
-                nav_ty,
-                .{ .nav = o.dg.pass.nav },
-                .{},
-                nav.status.fully_resolved.alignment,
-                .complete,
-            );
-            try w.writeAll(" = ");
-            try o.dg.renderValue(w, Value.fromInterned(variable.init), .StaticInitializer);
-            try w.writeByte(';');
-            try o.newline();
-        },
-        else => try genDeclValue(
-            o,
-            Value.fromInterned(nav.status.fully_resolved.val),
-            .{ .nav = o.dg.pass.nav },
-            nav.status.fully_resolved.alignment,
-            nav.status.fully_resolved.@"linksection",
-        ),
-    }
-}
-
-pub fn genDeclValue(
-    o: *Object,
-    val: Value,
-    decl_c_value: CValue,
-    alignment: Alignment,
-    @"linksection": InternPool.OptionalNullTerminatedString,
-) Error!void {
-    const zcu = o.dg.pt.zcu;
-    const ty = val.typeOf(zcu);
-
-    const fwd = &o.dg.fwd_decl.writer;
-    try fwd.writeAll("static ");
-    try o.dg.renderTypeAndName(fwd, ty, decl_c_value, Const, alignment, .complete);
-    try fwd.writeAll(";\n");
-
-    const w = &o.code.writer;
-    if (@"linksection".toSlice(&zcu.intern_pool)) |s|
+    if (nav.status.fully_resolved.@"linksection".toSlice(ip)) |s| {
         try w.print("zig_linksection({f}) ", .{fmtStringLiteral(s, null)});
-    try o.dg.renderTypeAndName(w, ty, decl_c_value, Const, alignment, .complete);
+    }
+
+    // We don't bother underaligning---it's unnecessary and hurts compatibility.
+    const a = nav.status.fully_resolved.alignment;
+    if (a != .none and a.compareStrict(.gt, nav_ty.abiAlignment(zcu))) {
+        try w.print("zig_align({d}) ", .{a.toByteUnits().?});
+    }
+
+    try genDeclValue(dg, w, .{
+        .name = .{ .nav = dg.owner_nav.unwrap().? },
+        .@"const" = is_const,
+        .@"threadlocal" = is_threadlocal,
+        .init_val = init_val,
+    });
+}
+pub fn genDeclFwd(dg: *DeclGen, w: *Writer) Error!void {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const pt = dg.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const nav = ip.getNav(dg.owner_nav.unwrap().?);
+    const nav_ty: Type = .fromInterned(nav.typeOf(ip));
+
+    const is_const: bool, const is_threadlocal: bool, const init_val: Value = switch (ip.indexToKey(nav.status.fully_resolved.val)) {
+        else => .{ true, false, .fromInterned(nav.status.fully_resolved.val) },
+        .variable => |v| .{ false, v.is_threadlocal, .fromInterned(v.init) },
+
+        .@"extern" => |@"extern"| switch (nav_ty.zigTypeTag(zcu)) {
+            .@"fn" => {
+                try w.writeAll("zig_extern ");
+                try dg.renderFunctionSignature(
+                    w,
+                    Value.fromInterned(nav.status.fully_resolved.val),
+                    nav.status.fully_resolved.alignment,
+                    .forward_decl,
+                    .{ .@"export" = .{
+                        .main_name = nav.name,
+                        .extern_name = nav.name,
+                    } },
+                );
+                try w.writeAll(";\n");
+                return;
+            },
+            else => {
+                switch (@"extern".linkage) {
+                    .internal => try w.writeAll("static "),
+                    .strong => try w.print("zig_extern zig_visibility({t}) ", .{@"extern".visibility}),
+                    .weak => try w.print("zig_extern zig_weak_linkage zig_visibility({t}) ", .{@"extern".visibility}),
+                    .link_once => return dg.fail("TODO: CBE: implement linkonce linkage?", .{}),
+                }
+                if (@"extern".is_threadlocal and !dg.mod.single_threaded) {
+                    try w.writeAll("zig_threadlocal ");
+                }
+                try dg.renderTypeAndName(
+                    w,
+                    .fromInterned(nav.typeOf(ip)),
+                    .{ .nav = dg.owner_nav.unwrap().? },
+                    .{ .@"const" = @"extern".is_const },
+                    nav.getAlignment(),
+                );
+                try w.writeAll(";\n");
+                return;
+            },
+        },
+    };
+
+    // We don't bother underaligning---it's unnecessary and hurts compatibility.
+    const a = nav.status.fully_resolved.alignment;
+    if (a != .none and a.compareStrict(.gt, nav_ty.abiAlignment(zcu))) {
+        try w.print("zig_align({d}) ", .{a.toByteUnits().?});
+    }
+
+    try genDeclValueFwd(dg, w, .{
+        .name = .{ .nav = dg.owner_nav.unwrap().? },
+        .@"const" = is_const,
+        .@"threadlocal" = is_threadlocal,
+        .init_val = init_val,
+    });
+}
+pub fn genDeclValue(dg: *DeclGen, w: *Writer, options: struct {
+    name: CValue,
+    @"const": bool,
+    @"threadlocal": bool,
+    init_val: Value,
+}) Error!void {
+    const zcu = dg.pt.zcu;
+    const ty = options.init_val.typeOf(zcu);
+    if (options.@"threadlocal" and !dg.mod.single_threaded) {
+        try w.writeAll("zig_threadlocal ");
+    }
+    try dg.renderTypeAndName(w, ty, options.name, .{ .@"const" = options.@"const" }, .none);
     try w.writeAll(" = ");
-    try o.dg.renderValue(w, val, .StaticInitializer);
-    try w.writeByte(';');
-    try o.newline();
+    try dg.renderValue(w, options.init_val, .static_initializer);
+    try w.writeAll(";\n");
+}
+pub fn genDeclValueFwd(dg: *DeclGen, w: *Writer, options: struct {
+    name: CValue,
+    @"const": bool,
+    @"threadlocal": bool,
+    init_val: Value,
+}) Error!void {
+    const zcu = dg.pt.zcu;
+    const ty = options.init_val.typeOf(zcu);
+    try w.writeAll("static ");
+    if (options.@"threadlocal" and !dg.mod.single_threaded) {
+        try w.writeAll("zig_threadlocal ");
+    }
+    try dg.renderTypeAndName(w, ty, options.name, .{ .@"const" = options.@"const" }, .none);
+    try w.writeAll(";\n");
 }
 
-pub fn genExports(dg: *DeclGen, exported: Zcu.Exported, export_indices: []const Zcu.Export.Index) !void {
+pub fn genExports(dg: *DeclGen, w: *Writer, exported: Zcu.Exported, export_indices: []const Zcu.Export.Index) !void {
     const zcu = dg.pt.zcu;
     const ip = &zcu.intern_pool;
-    const fwd = &dg.fwd_decl.writer;
 
     const main_name = export_indices[0].ptr(zcu).opts.name;
-    try fwd.writeAll("#define ");
+    try w.writeAll("#define ");
     switch (exported) {
-        .nav => |nav| try dg.renderNavName(fwd, nav),
-        .uav => |uav| try DeclGen.renderUavName(fwd, Value.fromInterned(uav)),
+        .nav => |nav| try renderNavName(w, nav, ip),
+        .uav => |uav| try renderUavName(w, Value.fromInterned(uav)),
     }
-    try fwd.writeByte(' ');
-    try fwd.print("{f}", .{fmtIdentSolo(main_name.toSlice(ip))});
-    try fwd.writeByte('\n');
+    try w.writeByte(' ');
+    try w.print("{f}", .{fmtIdentSolo(main_name.toSlice(ip))});
+    try w.writeByte('\n');
 
     const exported_val = exported.getValue(zcu);
     if (ip.isFunctionType(exported_val.typeOf(zcu).toIntern())) return for (export_indices) |export_index| {
         const @"export" = export_index.ptr(zcu);
-        try fwd.writeAll("zig_extern ");
-        if (@"export".opts.linkage == .weak) try fwd.writeAll("zig_weak_linkage_fn ");
+        try w.writeAll("zig_extern ");
+        if (@"export".opts.linkage == .weak) try w.writeAll("zig_weak_linkage_fn ");
         try dg.renderFunctionSignature(
-            fwd,
+            w,
             exported.getValue(zcu),
             exported.getAlign(zcu),
-            .forward,
+            .forward_decl,
             .{ .@"export" = .{
                 .main_name = main_name,
                 .extern_name = @"export".opts.name,
             } },
         );
-        try fwd.writeAll(";\n");
+        try w.writeAll(";\n");
     };
     const is_const = switch (ip.indexToKey(exported_val.toIntern())) {
         .func => unreachable,
@@ -3144,39 +2522,38 @@ pub fn genExports(dg: *DeclGen, exported: Zcu.Exported, export_indices: []const
     };
     for (export_indices) |export_index| {
         const @"export" = export_index.ptr(zcu);
-        try fwd.writeAll("zig_extern ");
-        if (@"export".opts.linkage == .weak) try fwd.writeAll("zig_weak_linkage ");
-        if (@"export".opts.section.toSlice(ip)) |s| try fwd.print("zig_linksection({f}) ", .{
+        try w.writeAll("zig_extern ");
+        if (@"export".opts.linkage == .weak) try w.writeAll("zig_weak_linkage ");
+        if (@"export".opts.section.toSlice(ip)) |s| try w.print("zig_linksection({f}) ", .{
             fmtStringLiteral(s, null),
         });
         const extern_name = @"export".opts.name.toSlice(ip);
         const is_mangled = isMangledIdent(extern_name, true);
         const is_export = @"export".opts.name != main_name;
         try dg.renderTypeAndName(
-            fwd,
+            w,
             exported.getValue(zcu).typeOf(zcu),
             .{ .identifier = extern_name },
-            CQualifiers.init(.{ .@"const" = is_const }),
+            .{ .@"const" = is_const },
             exported.getAlign(zcu),
-            .complete,
         );
         if (is_mangled and is_export) {
-            try fwd.print(" zig_mangled_export({f}, {f}, {f})", .{
+            try w.print(" zig_mangled_export({f}, {f}, {f})", .{
                 fmtIdentSolo(extern_name),
                 fmtStringLiteral(extern_name, null),
                 fmtStringLiteral(main_name.toSlice(ip), null),
             });
         } else if (is_mangled) {
-            try fwd.print(" zig_mangled({f}, {f})", .{
+            try w.print(" zig_mangled({f}, {f})", .{
                 fmtIdentSolo(extern_name), fmtStringLiteral(extern_name, null),
             });
         } else if (is_export) {
-            try fwd.print(" zig_export({f}, {f})", .{
+            try w.print(" zig_export({f}, {f})", .{
                 fmtStringLiteral(main_name.toSlice(ip), null),
                 fmtStringLiteral(extern_name, null),
             });
         }
-        try fwd.writeAll(";\n");
+        try w.writeAll(";\n");
     }
 }
 
@@ -3185,15 +2562,15 @@ pub fn genExports(dg: *DeclGen, exported: Zcu.Exported, export_indices: []const
 /// have been added to `free_locals_map`. For a version of this function that restores this state,
 /// see `genBodyResolveState`.
 fn genBody(f: *Function, body: []const Air.Inst.Index) Error!void {
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     if (body.len == 0) {
         try w.writeAll("{}");
     } else {
         try w.writeByte('{');
-        f.object.indent();
-        try f.object.newline();
+        f.indent();
+        try f.newline();
         try genBodyInner(f, body);
-        try f.object.outdent();
+        try f.outdent();
         try w.writeByte('}');
     }
 }
@@ -3207,13 +2584,13 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) Error!void {
 fn genBodyResolveState(f: *Function, inst: Air.Inst.Index, leading_deaths: []const Air.Inst.Index, body: []const Air.Inst.Index, inner: bool) Error!void {
     if (body.len == 0) {
         // Don't go to the expense of cloning everything!
-        if (!inner) try f.object.code.writer.writeAll("{}");
+        if (!inner) try f.code.writer.writeAll("{}");
         return;
     }
 
     // TODO: we can probably avoid the copies in some other common cases too.
 
-    const gpa = f.object.dg.gpa;
+    const gpa = f.dg.gpa;
 
     // Save the original value_map and free_locals_map so that we can restore them after the body.
     var old_value_map = try f.value_map.clone();
@@ -3254,13 +2631,13 @@ fn genBodyResolveState(f: *Function, inst: Air.Inst.Index, leading_deaths: []con
 }
 
 fn genBodyInner(f: *Function, body: []const Air.Inst.Index) Error!void {
-    const zcu = f.object.dg.pt.zcu;
+    const zcu = f.dg.pt.zcu;
     const ip = &zcu.intern_pool;
     const air_tags = f.air.instructions.items(.tag);
     const air_datas = f.air.instructions.items(.data);
 
     for (body) |inst| {
-        if (f.object.dg.expected_block) |_|
+        if (f.dg.expected_block) |_|
             return f.fail("runtime code not allowed in naked function", .{});
         if (f.liveness.isUnused(inst) and !f.air.mustLower(inst, ip))
             continue;
@@ -3529,8 +2906,8 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) Error!void {
             .ret             => return airRet(f, inst, false),
             .ret_safe        => return airRet(f, inst, false), // TODO
             .ret_load        => return airRet(f, inst, true),
-            .trap            => return airTrap(f, &f.object.code.writer),
-            .unreach         => return airUnreach(&f.object),
+            .trap            => return airTrap(f),
+            .unreach         => return airUnreach(f),
 
             // Instructions which may be `noreturn`.
             .block => res: {
@@ -3573,21 +2950,21 @@ fn airSliceField(f: *Function, inst: Air.Inst.Index, is_ptr: bool, field_name: [
     const operand = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     if (is_ptr) {
         try w.writeByte('&');
         try f.writeCValueDerefMember(w, operand, .{ .identifier = field_name });
     } else try f.writeCValueMember(w, operand, .{ .identifier = field_name });
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
-    const zcu = f.object.dg.pt.zcu;
+    const zcu = f.dg.pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     assert(inst_ty.hasRuntimeBits(zcu));
@@ -3596,21 +2973,24 @@ fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const index = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
-    try f.writeCValue(w, ptr, .Other);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
+    switch (f.typeOf(bin_op.lhs).ptrSize(zcu)) {
+        .one => try f.writeCValueDerefMember(w, ptr, .{ .identifier = "array" }),
+        .many, .c => try f.writeCValue(w, ptr, .other),
+        .slice => unreachable,
+    }
     try w.writeByte('[');
-    try f.writeCValue(w, index, .Other);
-    try w.writeByte(']');
-    try a.end(f, w);
+    try f.writeCValue(w, index, .other);
+    try w.writeAll("];");
+    try f.newline();
     return local;
 }
 
 fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -3623,28 +3003,26 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const index = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
-    try w.writeByte('(');
-    try f.renderType(w, inst_ty);
-    try w.writeByte(')');
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     try w.writeByte('&');
     if (ptr_ty.ptrSize(zcu) == .one) {
-        // It's a pointer to an array, so we need to de-reference.
-        try f.writeCValueDeref(w, ptr);
-    } else try f.writeCValue(w, ptr, .Other);
+        // `*[n]T` was turned into a pointer to `struct { T array[n]; }`
+        try f.writeCValueDerefMember(w, ptr, .{ .identifier = "array" });
+    } else {
+        try f.writeCValue(w, ptr, .other);
+    }
     try w.writeByte('[');
-    try f.writeCValue(w, index, .Other);
-    try w.writeByte(']');
-    try a.end(f, w);
+    try f.writeCValue(w, index, .other);
+    try w.writeAll("];");
+    try f.newline();
     return local;
 }
 
 fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
-    const zcu = f.object.dg.pt.zcu;
+    const zcu = f.dg.pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     assert(inst_ty.hasRuntimeBits(zcu));
@@ -3653,21 +3031,20 @@ fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const index = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     try f.writeCValueMember(w, slice, .{ .identifier = "ptr" });
     try w.writeByte('[');
-    try f.writeCValue(w, index, .Other);
-    try w.writeByte(']');
-    try a.end(f, w);
+    try f.writeCValue(w, index, .other);
+    try w.writeAll("];");
+    try f.newline();
     return local;
 }
 
 fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -3681,22 +3058,21 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const index = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     try w.writeByte('&');
     try f.writeCValueMember(w, slice, .{ .identifier = "ptr" });
     try w.writeByte('[');
-    try f.writeCValue(w, index, .Other);
-    try w.writeByte(']');
-    try a.end(f, w);
+    try f.writeCValue(w, index, .other);
+    try w.writeAll("];");
+    try f.newline();
     return local;
 }
 
 fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
-    const zcu = f.object.dg.pt.zcu;
+    const zcu = f.dg.pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const inst_ty = f.typeOfIndex(inst);
     assert(inst_ty.hasRuntimeBits(zcu));
@@ -3705,32 +3081,28 @@ fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const index = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
-    try f.writeCValue(w, array, .Other);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
+    try f.writeCValueMember(w, array, .{ .identifier = "array" });
     try w.writeByte('[');
-    try f.writeCValue(w, index, .Other);
-    try w.writeByte(']');
-    try a.end(f, w);
+    try f.writeCValue(w, index, .other);
+    try w.writeAll("];");
+    try f.newline();
     return local;
 }
 
 fn airAlloc(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const elem_ty = inst_ty.childType(zcu);
     if (!elem_ty.hasRuntimeBits(zcu)) return .{ .undef = inst_ty };
 
     const local = try f.allocLocalValue(.{
-        .ctype = try f.ctypeFromType(elem_ty, .complete),
-        .alignas = CType.AlignAs.fromAlignment(.{
-            .@"align" = inst_ty.ptrInfo(zcu).flags.alignment,
-            .abi = elem_ty.abiAlignment(zcu),
-        }),
+        .type = elem_ty,
+        .alignment = inst_ty.ptrInfo(zcu).flags.alignment,
     });
     log.debug("%{d}: allocated unfreeable t{d}", .{ inst, local.new_local });
     try f.allocs.put(zcu.gpa, local.new_local, true);
@@ -3741,11 +3113,11 @@ fn airAlloc(f: *Function, inst: Air.Inst.Index) !CValue {
                 // For packed aggregates, we zero-initialize to try and work around a design flaw
                 // related to how `packed`, `undefined`, and RLS interact. See comment in `airStore`
                 // for details.
-                const w = &f.object.code.writer;
+                const w = &f.code.writer;
                 try w.print("memset(&t{d}, 0x00, sizeof(", .{local.new_local});
                 try f.renderType(w, elem_ty);
                 try w.writeAll("));");
-                try f.object.newline();
+                try f.newline();
             },
             .auto, .@"extern" => {},
         },
@@ -3756,18 +3128,15 @@ fn airAlloc(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airRetPtr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
     const elem_ty = inst_ty.childType(zcu);
     if (!elem_ty.hasRuntimeBits(zcu)) return .{ .undef = inst_ty };
 
     const local = try f.allocLocalValue(.{
-        .ctype = try f.ctypeFromType(elem_ty, .complete),
-        .alignas = CType.AlignAs.fromAlignment(.{
-            .@"align" = inst_ty.ptrInfo(zcu).flags.alignment,
-            .abi = elem_ty.abiAlignment(zcu),
-        }),
+        .type = elem_ty,
+        .alignment = inst_ty.ptrInfo(zcu).flags.alignment,
     });
     log.debug("%{d}: allocated unfreeable t{d}", .{ inst, local.new_local });
     try f.allocs.put(zcu.gpa, local.new_local, true);
@@ -3778,11 +3147,11 @@ fn airRetPtr(f: *Function, inst: Air.Inst.Index) !CValue {
                 // For packed aggregates, we zero-initialize to try and work around a design flaw
                 // related to how `packed`, `undefined`, and RLS interact. See comment in `airStore`
                 // for details.
-                const w = &f.object.code.writer;
+                const w = &f.code.writer;
                 try w.print("memset(&t{d}, 0x00, sizeof(", .{local.new_local});
                 try f.renderType(w, elem_ty);
                 try w.writeAll("));");
-                try f.object.newline();
+                try f.newline();
             },
             .auto, .@"extern" => {},
         },
@@ -3793,24 +3162,18 @@ fn airRetPtr(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airArg(f: *Function, inst: Air.Inst.Index) !CValue {
-    const inst_ty = f.typeOfIndex(inst);
-    const inst_ctype = try f.ctypeFromType(inst_ty, .parameter);
-
     const i = f.next_arg_index;
     f.next_arg_index += 1;
-    const result: CValue = if (inst_ctype.eql(try f.ctypeFromType(inst_ty, .complete)))
-        .{ .arg = i }
-    else
-        .{ .arg_array = i };
+    const result: CValue = .{ .arg = i };
 
     if (f.liveness.isUnused(inst)) {
-        const w = &f.object.code.writer;
+        const w = &f.code.writer;
         try w.writeByte('(');
         try f.renderType(w, .void);
         try w.writeByte(')');
-        try f.writeCValue(w, result, .Other);
+        try f.writeCValue(w, result, .other);
         try w.writeByte(';');
-        try f.object.newline();
+        try f.newline();
         return .none;
     }
 
@@ -3818,7 +3181,7 @@ fn airArg(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -3841,94 +3204,69 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue {
         ptr_info.flags.alignment.order(src_ty.abiAlignment(zcu)).compare(.gte)
     else
         true;
-    const is_array = lowersToArray(src_ty, zcu);
-    const need_memcpy = !is_aligned or is_array;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, src_ty);
     const v = try Vectorize.start(f, inst, w, ptr_ty);
 
-    if (need_memcpy) {
-        try w.writeAll("memcpy(");
-        if (!is_array) try w.writeByte('&');
-        try f.writeCValue(w, local, .Other);
+    if (!is_aligned) {
+        try w.writeAll("memcpy(&");
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(", (const char *)");
-        try f.writeCValue(w, operand, .Other);
+        try f.writeCValue(w, operand, .other);
         try v.elem(f, w);
         try w.writeAll(", sizeof(");
         try f.renderType(w, src_ty);
         try w.writeAll("))");
     } else {
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(" = ");
         try f.writeCValueDeref(w, operand);
         try v.elem(f, w);
     }
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
 }
 
 fn airRet(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !void {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const op_inst = un_op.toIndex();
     const op_ty = f.typeOf(un_op);
     const ret_ty = if (is_ptr) op_ty.childType(zcu) else op_ty;
-    const ret_ctype = try f.ctypeFromType(ret_ty, .parameter);
 
     if (op_inst != null and f.air.instructions.items(.tag)[@intFromEnum(op_inst.?)] == .call_always_tail) {
         try reap(f, inst, &.{un_op});
         _ = try airCall(f, op_inst.?, .always_tail);
-    } else if (ret_ctype.index != .void) {
+    } else if (ret_ty.hasRuntimeBits(zcu)) {
         const operand = try f.resolveInst(un_op);
         try reap(f, inst, &.{un_op});
-        var deref = is_ptr;
-        const is_array = lowersToArray(ret_ty, zcu);
-        const ret_val = if (is_array) ret_val: {
-            const array_local = try f.allocAlignedLocal(inst, .{
-                .ctype = ret_ctype,
-                .alignas = CType.AlignAs.fromAbiAlignment(ret_ty.abiAlignment(zcu)),
-            });
-            try w.writeAll("memcpy(");
-            try f.writeCValueMember(w, array_local, .{ .identifier = "array" });
-            try w.writeAll(", ");
-            if (deref)
-                try f.writeCValueDeref(w, operand)
-            else
-                try f.writeCValue(w, operand, .FunctionArgument);
-            deref = false;
-            try w.writeAll(", sizeof(");
-            try f.renderType(w, ret_ty);
-            try w.writeAll("));");
-            try f.object.newline();
-            break :ret_val array_local;
-        } else operand;
 
         try w.writeAll("return ");
-        if (deref)
-            try f.writeCValueDeref(w, ret_val)
-        else
-            try f.writeCValue(w, ret_val, .Other);
-        try w.writeAll(";\n");
-        if (is_array) {
-            try freeLocal(f, inst, ret_val.new_local, null);
+        if (is_ptr) {
+            try f.writeCValueDeref(w, operand);
+        } else switch (operand) {
+            // Instead of 'return &local', emit 'return undefined'.
+            .local_ref => try f.dg.renderUndefValue(w, ret_ty, .other),
+            else => try f.writeCValue(w, operand, .other),
         }
+        try w.writeAll(";\n");
     } else {
         try reap(f, inst, &.{un_op});
         // Not even allowed to return void in a naked function.
-        if (!f.object.dg.is_naked_fn) try w.writeAll("return;\n");
+        if (!f.dg.is_naked_fn) try w.writeAll("return;\n");
     }
 }
 
 fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -3940,23 +3278,23 @@ fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue {
     const operand_ty = f.typeOf(ty_op.operand);
     const scalar_ty = operand_ty.scalarType(zcu);
 
-    if (f.object.dg.intCastIsNoop(inst_scalar_ty, scalar_ty)) return f.moveCValue(inst, inst_ty, operand);
+    if (f.dg.intCastIsNoop(inst_scalar_ty, scalar_ty)) return f.moveCValue(inst, inst_ty, operand);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(scalar_ty, .complete));
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
-    try a.assign(f, w);
-    try f.renderIntCast(w, inst_scalar_ty, operand, v, scalar_ty, .Other);
-    try a.end(f, w);
+    try w.writeAll(" = ");
+    try f.renderIntCast(w, inst_scalar_ty, operand, v, scalar_ty, .other);
+    try w.writeByte(';');
+    try f.newline();
     try v.end(f, inst, w);
     return local;
 }
 
 fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -3978,13 +3316,12 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
     const need_mask = dest_bits < 8 or !std.math.isPowerOfTwo(dest_bits);
     if (!need_cast and !need_lo and !need_mask) return f.moveCValue(inst, inst_ty, operand);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_scalar_ty, .complete));
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
-    try a.assign(f, w);
+    try w.writeAll(" = ");
     if (need_cast) {
         try w.writeByte('(');
         try f.renderType(w, inst_scalar_ty);
@@ -3992,18 +3329,18 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
     }
     if (need_lo) {
         try w.writeAll("zig_lo_");
-        try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+        try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
         try w.writeByte('(');
     }
     if (!need_mask) {
-        try f.writeCValue(w, operand, .Other);
+        try f.writeCValue(w, operand, .other);
         try v.elem(f, w);
     } else switch (dest_int_info.signedness) {
         .unsigned => {
             try w.writeAll("zig_and_");
-            try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+            try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
             try w.writeByte('(');
-            try f.writeCValue(w, operand, .FunctionArgument);
+            try f.writeCValue(w, operand, .other);
             try v.elem(f, w);
             try w.print(", {f})", .{
                 try f.fmtIntLiteralHex(try inst_scalar_ty.maxIntScalar(pt, scalar_ty)),
@@ -4015,7 +3352,7 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
             const shift_val = try pt.intValue(.u8, c_bits - dest_bits);
 
             try w.writeAll("zig_shr_");
-            try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+            try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
             if (c_bits == 128) {
                 try w.print("(zig_bitCast_i{d}(", .{c_bits});
             } else {
@@ -4027,7 +3364,7 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
             } else {
                 try w.print("(uint{d}_t)", .{c_bits});
             }
-            try f.writeCValue(w, operand, .FunctionArgument);
+            try f.writeCValue(w, operand, .other);
             try v.elem(f, w);
             if (c_bits == 128) try w.writeByte(')');
             try w.print(", {f})", .{try f.fmtIntLiteralDec(shift_val)});
@@ -4036,13 +3373,14 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
         },
     }
     if (need_lo) try w.writeByte(')');
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     try v.end(f, inst, w);
     return local;
 }
 
 fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     // *a = b;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
@@ -4060,7 +3398,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
 
     const val_is_undef = if (try f.air.value(bin_op.rhs, pt)) |v| v.isUndef(zcu) else false;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     if (val_is_undef) {
         try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
         if (safety and ptr_info.packed_offset.host_size == 0) {
@@ -4080,11 +3418,11 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
                 },
             };
             try w.writeAll("memset(");
-            try f.writeCValue(w, ptr_val, .FunctionArgument);
+            try f.writeCValue(w, ptr_val, .other);
             try w.print(", {s}, sizeof(", .{byte_str});
             try f.renderType(w, .fromInterned(ptr_info.child));
             try w.writeAll("));");
-            try f.object.newline();
+            try f.newline();
         }
         return .none;
     }
@@ -4093,46 +3431,29 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
         ptr_info.flags.alignment.order(src_ty.abiAlignment(zcu)).compare(.gte)
     else
         true;
-    const is_array = lowersToArray(.fromInterned(ptr_info.child), zcu);
-    const need_memcpy = !is_aligned or is_array;
 
     const src_val = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const src_scalar_ctype = try f.ctypeFromType(src_ty.scalarType(zcu), .complete);
-    if (need_memcpy) {
+    if (!is_aligned) {
         // For this memcpy to safely work we need the rhs to have the same
         // underlying type as the lhs (i.e. they must both be arrays of the same underlying type).
         assert(src_ty.eql(.fromInterned(ptr_info.child), zcu));
 
-        // If the source is a constant, writeCValue will emit a brace initialization
-        // so work around this by initializing into new local.
-        // TODO this should be done by manually initializing elements of the dest array
-        const array_src = if (src_val == .constant) blk: {
-            const new_local = try f.allocLocal(inst, src_ty);
-            try f.writeCValue(w, new_local, .Other);
-            try w.writeAll(" = ");
-            try f.writeCValue(w, src_val, .Other);
-            try w.writeByte(';');
-            try f.object.newline();
-
-            break :blk new_local;
-        } else src_val;
-
         const v = try Vectorize.start(f, inst, w, ptr_ty);
         try w.writeAll("memcpy((char *)");
-        try f.writeCValue(w, ptr_val, .FunctionArgument);
+        try f.writeCValue(w, ptr_val, .other);
         try v.elem(f, w);
-        try w.writeAll(", ");
-        if (!is_array) try w.writeByte('&');
-        try f.writeCValue(w, array_src, .FunctionArgument);
+        try w.writeAll(", &");
+        switch (src_val) {
+            .constant => |val| try f.dg.renderValueAsLvalue(w, val),
+            else => try f.writeCValue(w, src_val, .other),
+        }
         try v.elem(f, w);
         try w.writeAll(", sizeof(");
         try f.renderType(w, src_ty);
-        try w.writeAll("))");
-        try f.freeCValue(inst, array_src);
-        try w.writeByte(';');
-        try f.object.newline();
+        try w.writeAll("));");
+        try f.newline();
         try v.end(f, inst, w);
     } else {
         switch (ptr_val) {
@@ -4144,20 +3465,20 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
             else => {},
         }
         const v = try Vectorize.start(f, inst, w, ptr_ty);
-        const a = try Assignment.start(f, w, src_scalar_ctype);
         try f.writeCValueDeref(w, ptr_val);
         try v.elem(f, w);
-        try a.assign(f, w);
-        try f.writeCValue(w, src_val, .Other);
+        try w.writeAll(" = ");
+        try f.writeCValue(w, src_val, .other);
         try v.elem(f, w);
-        try a.end(f, w);
+        try w.writeByte(';');
+        try f.newline();
         try v.end(f, inst, w);
     }
     return .none;
 }
 
 fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info: BuiltinInfo) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -4170,7 +3491,7 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info:
     const operand_ty = f.typeOf(bin_op.lhs);
     const scalar_ty = operand_ty.scalarType(zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
     try f.writeCValueMember(w, local, .{ .field = 1 });
@@ -4178,26 +3499,26 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info:
     try w.writeAll(" = zig_");
     try w.writeAll(operation);
     try w.writeAll("o_");
-    try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+    try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
     try w.writeAll("(&");
     try f.writeCValueMember(w, local, .{ .field = 0 });
     try v.elem(f, w);
     try w.writeAll(", ");
-    try f.writeCValue(w, lhs, .FunctionArgument);
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeAll(", ");
-    try f.writeCValue(w, rhs, .FunctionArgument);
+    try f.writeCValue(w, rhs, .other);
     if (f.typeOf(bin_op.rhs).isVector(zcu)) try v.elem(f, w);
-    try f.object.dg.renderBuiltinInfo(w, scalar_ty, info);
+    try f.dg.renderBuiltinInfo(w, scalar_ty, info);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
 }
 
 fn airNot(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand_ty = f.typeOf(ty_op.operand);
@@ -4209,17 +3530,17 @@ fn airNot(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
     try w.writeAll(" = ");
     try w.writeByte('!');
-    try f.writeCValue(w, op, .Other);
+    try f.writeCValue(w, op, .other);
     try v.elem(f, w);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -4232,7 +3553,7 @@ fn airBinOp(
     operation: []const u8,
     info: BuiltinInfo,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const operand_ty = f.typeOf(bin_op.lhs);
@@ -4246,21 +3567,21 @@ fn airBinOp(
 
     const inst_ty = f.typeOfIndex(inst);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
     try w.writeAll(" = ");
-    try f.writeCValue(w, lhs, .Other);
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeByte(' ');
     try w.writeAll(operator);
     try w.writeByte(' ');
-    try f.writeCValue(w, rhs, .Other);
+    try f.writeCValue(w, rhs, .other);
     try v.elem(f, w);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -4272,7 +3593,7 @@ fn airCmpOp(
     data: anytype,
     operator: std.math.CompareOperator,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const lhs_ty = f.typeOf(data.lhs);
     const scalar_ty = lhs_ty.scalarType(zcu);
@@ -4297,26 +3618,26 @@ fn airCmpOp(
 
     const rhs_ty = f.typeOf(data.rhs);
     const need_cast = lhs_ty.isSinglePointer(zcu) or rhs_ty.isSinglePointer(zcu);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, lhs_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(scalar_ty, .complete));
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
-    try a.assign(f, w);
+    try w.writeAll(" = ");
     if (lhs != .undef and lhs.eql(rhs)) try w.writeAll(switch (operator) {
         .lt, .neq, .gt => "false",
         .lte, .eq, .gte => "true",
     }) else {
         if (need_cast) try w.writeAll("(void*)");
-        try f.writeCValue(w, lhs, .Other);
+        try f.writeCValue(w, lhs, .other);
         try v.elem(f, w);
         try w.writeAll(compareOperatorC(operator));
         if (need_cast) try w.writeAll("(void*)");
-        try f.writeCValue(w, rhs, .Other);
+        try f.writeCValue(w, rhs, .other);
         try v.elem(f, w);
     }
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -4327,9 +3648,8 @@ fn airEquality(
     inst: Air.Inst.Index,
     operator: std.math.CompareOperator,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const ctype_pool = &f.object.dg.ctype_pool;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
 
     const operand_ty = f.typeOf(bin_op.lhs);
@@ -4350,54 +3670,64 @@ fn airEquality(
     const rhs = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    if (lhs.eql(rhs)) {
+        // Avoid emitting a tautological comparison.
+        return .{ .constant = .makeBool(switch (operator) {
+            .eq, .lte, .gte => true,
+            .neq, .lt, .gt => false,
+        }) };
+    }
+
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, .bool);
-    const a = try Assignment.start(f, w, .bool);
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
 
-    const operand_ctype = try f.ctypeFromType(operand_ty, .complete);
-    if (lhs != .undef and lhs.eql(rhs)) try w.writeAll(switch (operator) {
-        .lt, .lte, .gte, .gt => unreachable,
-        .neq => "false",
-        .eq => "true",
-    }) else switch (operand_ctype.info(ctype_pool)) {
-        .basic, .pointer => {
-            try f.writeCValue(w, lhs, .Other);
-            try w.writeAll(compareOperatorC(operator));
-            try f.writeCValue(w, rhs, .Other);
-        },
-        .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-        .aggregate => |aggregate| if (aggregate.fields.len == 2 and
-            (aggregate.fields.at(0, ctype_pool).name.index == .is_null or
-                aggregate.fields.at(1, ctype_pool).name.index == .is_null))
-        {
-            try f.writeCValueMember(w, lhs, .{ .identifier = "is_null" });
-            try w.writeAll(" || ");
-            try f.writeCValueMember(w, rhs, .{ .identifier = "is_null" });
-            try w.writeAll(" ? ");
-            try f.writeCValueMember(w, lhs, .{ .identifier = "is_null" });
-            try w.writeAll(compareOperatorC(operator));
-            try f.writeCValueMember(w, rhs, .{ .identifier = "is_null" });
-            try w.writeAll(" : ");
-            try f.writeCValueMember(w, lhs, .{ .identifier = "payload" });
-            try w.writeAll(compareOperatorC(operator));
-            try f.writeCValueMember(w, rhs, .{ .identifier = "payload" });
-        } else for (0..aggregate.fields.len) |field_index| {
-            if (field_index > 0) try w.writeAll(switch (operator) {
-                .lt, .lte, .gte, .gt => unreachable,
-                .eq => " && ",
-                .neq => " || ",
-            });
-            const field_name: CValue = .{
-                .ctype_pool_string = aggregate.fields.at(field_index, ctype_pool).name,
-            };
-            try f.writeCValueMember(w, lhs, field_name);
-            try w.writeAll(compareOperatorC(operator));
-            try f.writeCValueMember(w, rhs, field_name);
+    switch (operand_ty.zigTypeTag(zcu)) {
+        .optional => switch (CType.classifyOptional(operand_ty, zcu)) {
+            .npv_payload => unreachable, // opv optional
+
+            .error_set, .ptr_like => {},
+
+            .slice_like => unreachable, // equality is not defined on slices
+
+            .opv_payload => {
+                try f.writeCValueMember(w, lhs, .{ .identifier = "is_null" });
+                try w.writeAll(compareOperatorC(operator));
+                try f.writeCValueMember(w, rhs, .{ .identifier = "is_null" });
+                try w.writeByte(';');
+                try f.newline();
+                return local;
+            },
+
+            .@"struct" => {
+                // `lhs.is_null || rhs.is_null ? lhs.is_null == rhs.is_null : lhs.payload == rhs.payload`
+                try f.writeCValueMember(w, lhs, .{ .identifier = "is_null" });
+                try w.writeAll(" || ");
+                try f.writeCValueMember(w, rhs, .{ .identifier = "is_null" });
+                try w.writeAll(" ? ");
+                try f.writeCValueMember(w, lhs, .{ .identifier = "is_null" });
+                try w.writeAll(compareOperatorC(operator));
+                try f.writeCValueMember(w, rhs, .{ .identifier = "is_null" });
+                try w.writeAll(" : ");
+                try f.writeCValueMember(w, lhs, .{ .identifier = "payload" });
+                try w.writeAll(compareOperatorC(operator));
+                try f.writeCValueMember(w, rhs, .{ .identifier = "payload" });
+                try w.writeByte(';');
+                try f.newline();
+                return local;
+            },
         },
+        .bool, .int, .pointer, .@"enum", .error_set => {},
+        .@"struct", .@"union" => assert(operand_ty.containerLayout(zcu) == .@"packed"),
+        else => unreachable,
     }
-    try a.end(f, w);
+
+    try f.writeCValue(w, lhs, .other);
+    try w.writeAll(compareOperatorC(operator));
+    try f.writeCValue(w, rhs, .other);
+    try w.writeByte(';');
+    try f.newline();
 
     return local;
 }
@@ -4408,18 +3738,18 @@ fn airCmpLtErrorsLen(f: *Function, inst: Air.Inst.Index) !CValue {
     const operand = try f.resolveInst(un_op);
     try reap(f, inst, &.{un_op});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, .bool);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = ");
-    try f.writeCValue(w, operand, .Other);
+    try f.writeCValue(w, operand, .other);
     try w.print(" < sizeof({f}) / sizeof(*{0f});", .{fmtIdentSolo("zig_errorName")});
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -4432,38 +3762,34 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
     const inst_scalar_ty = inst_ty.scalarType(zcu);
     const elem_ty = inst_scalar_ty.indexableElem(zcu);
     assert(elem_ty.hasRuntimeBits(zcu));
-    const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
 
     const local = try f.allocLocal(inst, inst_ty);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const v = try Vectorize.start(f, inst, w, inst_ty);
-    const a = try Assignment.start(f, w, inst_scalar_ctype);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
-    try a.assign(f, w);
+    try w.writeAll(" = ");
     // We must convert to and from integer types to prevent UB if the operation
     // results in a NULL pointer, or if LHS is NULL. The operation is only UB
     // if the result is NULL and then dereferenced.
     try w.writeByte('(');
-    try f.renderCType(w, inst_scalar_ctype);
+    try f.renderType(w, inst_scalar_ty);
     try w.writeAll(")(((uintptr_t)");
-    try f.writeCValue(w, lhs, .Other);
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
-    try w.writeAll(") ");
-    try w.writeByte(operator);
-    try w.writeAll(" (");
-    try f.writeCValue(w, rhs, .Other);
+    try w.print(") {c} (", .{operator});
+    try f.writeCValue(w, rhs, .other);
     try v.elem(f, w);
     try w.writeAll("*sizeof(");
     try f.renderType(w, elem_ty);
-    try w.writeAll(")))");
-    try a.end(f, w);
+    try w.writeAll(")));");
+    try f.newline();
     try v.end(f, inst, w);
     return local;
 }
 
 fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []const u8) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
 
@@ -4477,36 +3803,34 @@ fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []cons
     const rhs = try f.resolveInst(bin_op.rhs);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
     // (lhs <> rhs) ? lhs : rhs
     try w.writeAll(" = (");
-    try f.writeCValue(w, lhs, .Other);
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeByte(' ');
     try w.writeByte(operator);
     try w.writeByte(' ');
-    try f.writeCValue(w, rhs, .Other);
+    try f.writeCValue(w, rhs, .other);
     try v.elem(f, w);
     try w.writeAll(") ? ");
-    try f.writeCValue(w, lhs, .Other);
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeAll(" : ");
-    try f.writeCValue(w, rhs, .Other);
+    try f.writeCValue(w, rhs, .other);
     try v.elem(f, w);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
 }
 
 fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
 
@@ -4515,24 +3839,22 @@ fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue {
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
     const inst_ty = f.typeOfIndex(inst);
-    const ptr_ty = inst_ty.slicePtrFieldType(zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(ptr_ty, .complete));
-        try f.writeCValueMember(w, local, .{ .identifier = "ptr" });
-        try a.assign(f, w);
-        try f.writeCValue(w, ptr, .Other);
-        try a.end(f, w);
-    }
-    {
-        const a = try Assignment.start(f, w, .usize);
-        try f.writeCValueMember(w, local, .{ .identifier = "len" });
-        try a.assign(f, w);
-        try f.writeCValue(w, len, .Other);
-        try a.end(f, w);
-    }
+
+    try f.writeCValueMember(w, local, .{ .identifier = "ptr" });
+    try w.writeAll(" = ");
+    try f.writeCValue(w, ptr, .other);
+    try w.writeByte(';');
+    try f.newline();
+
+    try f.writeCValueMember(w, local, .{ .identifier = "len" });
+    try w.writeAll(" = ");
+    try f.writeCValue(w, len, .other);
+    try w.writeByte(';');
+    try f.newline();
+
     return local;
 }
 
@@ -4541,14 +3863,14 @@ fn airCall(
     inst: Air.Inst.Index,
     modifier: std.builtin.CallModifier,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     // Not even allowed to call panic in a naked function.
-    if (f.object.dg.is_naked_fn) return .none;
+    if (f.dg.is_naked_fn) return .none;
 
-    const gpa = f.object.dg.gpa;
-    const w = &f.object.code.writer;
+    const gpa = f.dg.gpa;
+    const w = &f.code.writer;
 
     const call = f.air.unwrapCall(inst);
     const args = call.args;
@@ -4557,27 +3879,11 @@ fn airCall(
     defer gpa.free(resolved_args);
     for (resolved_args, args) |*resolved_arg, arg| {
         const arg_ty = f.typeOf(arg);
-        const arg_ctype = try f.ctypeFromType(arg_ty, .parameter);
-        if (arg_ctype.index == .void) {
+        if (!arg_ty.hasRuntimeBits(zcu)) {
             resolved_arg.* = .none;
             continue;
         }
         resolved_arg.* = try f.resolveInst(arg);
-        if (!arg_ctype.eql(try f.ctypeFromType(arg_ty, .complete))) {
-            const array_local = try f.allocAlignedLocal(inst, .{
-                .ctype = arg_ctype,
-                .alignas = CType.AlignAs.fromAbiAlignment(arg_ty.abiAlignment(zcu)),
-            });
-            try w.writeAll("memcpy(");
-            try f.writeCValueMember(w, array_local, .{ .identifier = "array" });
-            try w.writeAll(", ");
-            try f.writeCValue(w, resolved_arg.*, .FunctionArgument);
-            try w.writeAll(", sizeof(");
-            try f.renderCType(w, arg_ctype);
-            try w.writeAll("));");
-            try f.object.newline();
-            resolved_arg.* = array_local;
-        }
     }
 
     const callee = try f.resolveInst(call.callee);
@@ -4596,28 +3902,22 @@ fn airCall(
     };
     const fn_info = zcu.typeToFunc(if (callee_is_ptr) callee_ty.childType(zcu) else callee_ty).?;
     const ret_ty: Type = .fromInterned(fn_info.return_type);
-    const ret_ctype: CType = if (ret_ty.isNoReturn(zcu))
-        .void
-    else
-        try f.ctypeFromType(ret_ty, .parameter);
 
     const result_local = result: {
         if (modifier == .always_tail) {
             try w.writeAll("zig_always_tail return ");
             break :result .none;
-        } else if (ret_ctype.index == .void) {
+        } else if (!ret_ty.hasRuntimeBits(zcu)) {
             break :result .none;
         } else if (f.liveness.isUnused(inst)) {
-            try w.writeByte('(');
-            try f.renderCType(w, .void);
-            try w.writeByte(')');
+            try w.writeAll("(void)");
             break :result .none;
         } else {
             const local = try f.allocAlignedLocal(inst, .{
-                .ctype = ret_ctype,
-                .alignas = CType.AlignAs.fromAbiAlignment(ret_ty.abiAlignment(zcu)),
+                .type = ret_ty,
+                .alignment = .none,
             });
-            try f.writeCValue(w, local, .Other);
+            try f.writeCValue(w, local, .other);
             try w.writeAll(" = ");
             break :result local;
         }
@@ -4644,8 +3944,19 @@ fn airCall(
                 if (!callee_is_ptr) try w.writeByte('&');
             }
             switch (modifier) {
-                .auto, .always_tail => try f.object.dg.renderNavName(w, fn_nav),
-                inline .never_tail, .never_inline => |m| try w.writeAll(try f.getLazyFnName(@unionInit(LazyFnKey, @tagName(m), fn_nav))),
+                .auto, .always_tail => try renderNavName(w, fn_nav, ip),
+                .never_tail => {
+                    try f.need_never_tail_funcs.put(gpa, fn_nav, {});
+                    try w.print("zig_never_tail_{f}__{d}", .{
+                        fmtIdentUnsolo(ip.getNav(fn_nav).name.toSlice(ip)), @intFromEnum(fn_nav),
+                    });
+                },
+                .never_inline => {
+                    try f.need_never_inline_funcs.put(gpa, fn_nav, {});
+                    try w.print("zig_never_inline_{f}__{d}", .{
+                        fmtIdentUnsolo(ip.getNav(fn_nav).name.toSlice(ip)), @intFromEnum(fn_nav),
+                    });
+                },
                 else => unreachable,
             }
             if (need_cast) try w.writeByte(')');
@@ -4658,7 +3969,7 @@ fn airCall(
             else => unreachable,
         }
         // Fall back to function pointer call.
-        try f.writeCValue(w, callee, .Other);
+        try f.writeCValue(w, callee, .other);
     }
 
     try w.writeByte('(');
@@ -4667,38 +3978,20 @@ fn airCall(
         if (resolved_arg == .none) continue;
         if (need_comma) try w.writeAll(", ");
         need_comma = true;
-        try f.writeCValue(w, resolved_arg, .FunctionArgument);
-        try f.freeCValue(inst, resolved_arg);
+        try f.writeCValue(w, resolved_arg, .other);
     }
     try w.writeAll(");");
     switch (modifier) {
         .always_tail => try w.writeByte('\n'),
-        else => try f.object.newline(),
+        else => try f.newline(),
     }
 
-    const result = result: {
-        if (result_local == .none or !lowersToArray(ret_ty, zcu))
-            break :result result_local;
-
-        const array_local = try f.allocLocal(inst, ret_ty);
-        try w.writeAll("memcpy(");
-        try f.writeCValue(w, array_local, .FunctionArgument);
-        try w.writeAll(", ");
-        try f.writeCValueMember(w, result_local, .{ .identifier = "array" });
-        try w.writeAll(", sizeof(");
-        try f.renderType(w, ret_ty);
-        try w.writeAll("));");
-        try f.object.newline();
-        try freeLocal(f, inst, result_local.new_local, null);
-        break :result array_local;
-    };
-
-    return result;
+    return result_local;
 }
 
 fn airDbgStmt(f: *Function, inst: Air.Inst.Index) !CValue {
     const dbg_stmt = f.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     // TODO re-evaluate whether to emit these or not. If we naively emit
     // these directives, the output file will report bogus line numbers because
     // every newline after the #line directive adds one to the line.
@@ -4707,32 +4000,32 @@ fn airDbgStmt(f: *Function, inst: Air.Inst.Index) !CValue {
     // newlines until the next dbg_stmt occurs.
     // Perhaps an additional compilation option is in order?
     //try w.print("#line {d}", .{dbg_stmt.line + 1});
-    //try f.object.newline();
+    //try f.newline();
     try w.print("/* file:{d}:{d} */", .{ dbg_stmt.line + 1, dbg_stmt.column + 1 });
-    try f.object.newline();
+    try f.newline();
     return .none;
 }
 
 fn airDbgEmptyStmt(f: *Function, _: Air.Inst.Index) !CValue {
-    try f.object.code.writer.writeAll("(void)0;");
-    try f.object.newline();
+    try f.code.writer.writeAll("(void)0;");
+    try f.newline();
     return .none;
 }
 
 fn airDbgInlineBlock(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const block = f.air.unwrapDbgBlock(inst);
     const owner_nav = ip.getNav(zcu.funcInfo(block.func).owner_nav);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     try w.print("/* inline:{f} */", .{owner_nav.fqn.fmt(&zcu.intern_pool)});
-    try f.object.newline();
+    try f.newline();
     return lowerBlock(f, inst, block.body);
 }
 
 fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const tag = f.air.instructions.items(.tag)[@intFromEnum(inst)];
     const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
@@ -4741,9 +4034,9 @@ fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue {
     if (!operand_is_undef) _ = try f.resolveInst(pl_op.operand);
 
     try reap(f, inst, &.{pl_op.operand});
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     try w.print("/* {s}:{s} */", .{ @tagName(tag), name.toSlice(f.air) });
-    try f.object.newline();
+    try f.newline();
     return .none;
 }
 
@@ -4753,13 +4046,13 @@ fn airBlock(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const liveness_block = f.liveness.getBlock(inst);
 
     const block_id = f.next_block_index;
     f.next_block_index += 1;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     const inst_ty = f.typeOfIndex(inst);
     const result = if (inst_ty.hasRuntimeBits(zcu) and !f.liveness.isUnused(inst))
@@ -4767,7 +4060,7 @@ fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index)
     else
         .none;
 
-    try f.blocks.putNoClobber(f.object.dg.gpa, inst, .{
+    try f.blocks.putNoClobber(f.dg.gpa, inst, .{
         .block_id = block_id,
         .result = result,
     });
@@ -4782,23 +4075,23 @@ fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index)
     }
 
     // noreturn blocks have no `br` instructions reaching them, so we don't want a label
-    if (f.object.dg.is_naked_fn) {
-        if (f.object.dg.expected_block) |expected_block| {
+    if (f.dg.is_naked_fn) {
+        if (f.dg.expected_block) |expected_block| {
             if (block_id != expected_block)
                 return f.fail("runtime code not allowed in naked function", .{});
-            f.object.dg.expected_block = null;
+            f.dg.expected_block = null;
         }
     } else if (!f.typeOfIndex(inst).isNoReturn(zcu)) {
         // label must be followed by an expression, include an empty one.
         try w.print("\nzig_block_{d}:;", .{block_id});
-        try f.object.newline();
+        try f.newline();
     }
 
     return result;
 }
 
 fn airTry(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const unwrapped_try = f.air.unwrapTry(inst);
     const body = unwrapped_try.else_body;
     const err_union_ty = f.air.typeOf(unwrapped_try.error_union, &pt.zcu.intern_pool);
@@ -4806,7 +4099,7 @@ fn airTry(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airTryPtr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const unwrapped_try = f.air.unwrapTryPtr(inst);
     const body = unwrapped_try.else_body;
     const err_union_ty = f.air.typeOf(unwrapped_try.error_union_ptr, &pt.zcu.intern_pool).childType(pt.zcu);
@@ -4821,46 +4114,38 @@ fn lowerTry(
     err_union_ty: Type,
     is_ptr: bool,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const err_union = try f.resolveInst(operand);
     const inst_ty = f.typeOfIndex(inst);
     const liveness_condbr = f.liveness.getCondBr(inst);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
-    const payload_has_bits = payload_ty.hasRuntimeBits(zcu);
 
-    if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
-        try w.writeAll("if (");
-        if (!payload_has_bits) {
-            if (is_ptr)
-                try f.writeCValueDeref(w, err_union)
-            else
-                try f.writeCValue(w, err_union, .Other);
-        } else {
-            // Reap the operand so that it can be reused inside genBody.
-            // Remember we must avoid calling reap() twice for the same operand
-            // in this function.
-            try reap(f, inst, &.{operand});
-            if (is_ptr)
-                try f.writeCValueDerefMember(w, err_union, .{ .identifier = "error" })
-            else
-                try f.writeCValueMember(w, err_union, .{ .identifier = "error" });
-        }
-        try w.writeAll(") ");
+    try w.writeAll("if (");
 
-        try genBodyResolveState(f, inst, liveness_condbr.else_deaths, body, false);
-        try f.object.newline();
-        if (f.object.dg.expected_block) |_|
-            return f.fail("runtime code not allowed in naked function", .{});
-    }
+    // Reap the operand so that it can be reused inside genBody.
+    // Remember we must avoid calling reap() twice for the same operand
+    // in this function.
+    try reap(f, inst, &.{operand});
+    if (is_ptr)
+        try f.writeCValueDerefMember(w, err_union, .{ .identifier = "error" })
+    else
+        try f.writeCValueMember(w, err_union, .{ .identifier = "error" });
+
+    try w.writeAll(") ");
+
+    try genBodyResolveState(f, inst, liveness_condbr.else_deaths, body, false);
+    try f.newline();
+    if (f.dg.expected_block) |_|
+        return f.fail("runtime code not allowed in naked function", .{});
 
     // Now we have the "then branch" (in terms of the liveness data); process any deaths.
     for (liveness_condbr.then_deaths) |death| {
         try die(f, inst, death.toRef());
     }
 
-    if (!payload_has_bits) {
+    if (!payload_ty.hasRuntimeBits(zcu)) {
         if (!is_ptr) {
             return .none;
         } else {
@@ -4873,14 +4158,14 @@ fn lowerTry(
     if (f.liveness.isUnused(inst)) return .none;
 
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     if (is_ptr) {
         try w.writeByte('&');
         try f.writeCValueDerefMember(w, err_union, .{ .identifier = "payload" });
     } else try f.writeCValueMember(w, err_union, .{ .identifier = "payload" });
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
@@ -4888,25 +4173,24 @@ fn airBr(f: *Function, inst: Air.Inst.Index) !void {
     const branch = f.air.instructions.items(.data)[@intFromEnum(inst)].br;
     const block = f.blocks.get(branch.block_inst).?;
     const result = block.result;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
-    if (f.object.dg.is_naked_fn) {
+    if (f.dg.is_naked_fn) {
         if (result != .none) return f.fail("runtime code not allowed in naked function", .{});
-        f.object.dg.expected_block = block.block_id;
+        f.dg.expected_block = block.block_id;
         return;
     }
 
     // If result is .none then the value of the block is unused.
     if (result != .none) {
-        const operand_ty = f.typeOf(branch.operand);
         const operand = try f.resolveInst(branch.operand);
         try reap(f, inst, &.{branch.operand});
 
-        const a = try Assignment.start(f, w, try f.ctypeFromType(operand_ty, .complete));
-        try f.writeCValue(w, result, .Other);
-        try a.assign(f, w);
-        try f.writeCValue(w, operand, .Other);
-        try a.end(f, w);
+        try f.writeCValue(w, result, .other);
+        try w.writeAll(" = ");
+        try f.writeCValue(w, operand, .other);
+        try w.writeByte(';');
+        try f.newline();
     }
 
     try w.print("goto zig_block_{d};\n", .{block.block_id});
@@ -4914,14 +4198,14 @@ fn airBr(f: *Function, inst: Air.Inst.Index) !void {
 
 fn airRepeat(f: *Function, inst: Air.Inst.Index) !void {
     const repeat = f.air.instructions.items(.data)[@intFromEnum(inst)].repeat;
-    try f.object.code.writer.print("goto zig_loop_{d};\n", .{@intFromEnum(repeat.loop_inst)});
+    try f.code.writer.print("goto zig_loop_{d};\n", .{@intFromEnum(repeat.loop_inst)});
 }
 
 fn airSwitchDispatch(f: *Function, inst: Air.Inst.Index) !void {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const br = f.air.instructions.items(.data)[@intFromEnum(inst)].br;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     if (try f.air.value(br.operand, pt)) |cond_val| {
         // Comptime-known dispatch. Iterate the cases to find the correct
@@ -4950,11 +4234,11 @@ fn airSwitchDispatch(f: *Function, inst: Air.Inst.Index) !void {
     // Runtime-known dispatch. Set the switch condition, and branch back.
     const cond = try f.resolveInst(br.operand);
     const cond_local = f.loop_switch_conds.get(br.block_inst).?;
-    try f.writeCValue(w, .{ .local = cond_local }, .Other);
+    try f.writeCValue(w, .{ .local = cond_local }, .other);
     try w.writeAll(" = ");
-    try f.writeCValue(w, cond, .Other);
+    try f.writeCValue(w, cond, .other);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try w.print("goto zig_switch_{d}_loop;\n", .{@intFromEnum(br.block_inst)});
 }
 
@@ -4971,11 +4255,10 @@ fn airBitcast(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const target = &f.object.dg.mod.resolved_target.result;
-    const ctype_pool = &f.object.dg.ctype_pool;
-    const w = &f.object.code.writer;
+    const target = &f.dg.mod.resolved_target.result;
+    const w = &f.code.writer;
 
     if (operand_ty.isAbiInt(zcu) and dest_ty.isAbiInt(zcu)) {
         const src_info = dest_ty.intInfo(zcu);
@@ -4986,26 +4269,16 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !CVal
 
     if (dest_ty.isPtrAtRuntime(zcu) or operand_ty.isPtrAtRuntime(zcu)) {
         const local = try f.allocLocal(null, dest_ty);
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try w.writeAll(" = (");
         try f.renderType(w, dest_ty);
         try w.writeByte(')');
-        try f.writeCValue(w, operand, .Other);
+        try f.writeCValue(w, operand, .other);
         try w.writeByte(';');
-        try f.object.newline();
+        try f.newline();
         return local;
     }
 
-    const operand_lval = if (operand == .constant) blk: {
-        const operand_local = try f.allocLocal(null, operand_ty);
-        try f.writeCValue(w, operand_local, .Other);
-        try w.writeAll(" = ");
-        try f.writeCValue(w, operand, .Other);
-        try w.writeByte(';');
-        try f.object.newline();
-        break :blk operand_local;
-    } else operand;
-
     const local = try f.allocLocal(null, dest_ty);
     // On big-endian targets, copying ABI integers with padding bits is awkward, because the padding bits are at the low bytes of the value.
     // We need to offset the source or destination pointer appropriately and copy the right number of bytes.
@@ -5013,141 +4286,134 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !CVal
         // e.g. [10]u8 -> u80. We need to offset the destination so that we copy to the least significant bits of the integer.
         const offset = dest_ty.abiSize(zcu) - operand_ty.abiSize(zcu);
         try w.writeAll("memcpy((char *)&");
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try w.print(" + {d}, &", .{offset});
-        try f.writeCValue(w, operand_lval, .Other);
+        switch (operand) {
+            .constant => |val| try f.dg.renderValueAsLvalue(w, val),
+            else => try f.writeCValue(w, operand, .other),
+        }
         try w.print(", {d});", .{operand_ty.abiSize(zcu)});
     } else if (target.cpu.arch.endian() == .big and operand_ty.isAbiInt(zcu) and !dest_ty.isAbiInt(zcu)) {
         // e.g. u80 -> [10]u8. We need to offset the source so that we copy from the least significant bits of the integer.
         const offset = operand_ty.abiSize(zcu) - dest_ty.abiSize(zcu);
         try w.writeAll("memcpy(&");
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try w.writeAll(", (const char *)&");
-        try f.writeCValue(w, operand_lval, .Other);
+        switch (operand) {
+            .constant => |val| try f.dg.renderValueAsLvalue(w, val),
+            else => try f.writeCValue(w, operand, .other),
+        }
         try w.print(" + {d}, {d});", .{ offset, dest_ty.abiSize(zcu) });
     } else {
         try w.writeAll("memcpy(&");
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try w.writeAll(", &");
-        try f.writeCValue(w, operand_lval, .Other);
+        switch (operand) {
+            .constant => |val| try f.dg.renderValueAsLvalue(w, val),
+            else => try f.writeCValue(w, operand, .other),
+        }
         try w.print(", {d});", .{@min(dest_ty.abiSize(zcu), operand_ty.abiSize(zcu))});
     }
 
-    try f.object.newline();
+    try f.newline();
 
     // Ensure padding bits have the expected value.
     if (dest_ty.isAbiInt(zcu)) {
-        const dest_ctype = try f.ctypeFromType(dest_ty, .complete);
-        const dest_info = dest_ty.intInfo(zcu);
-        var bits: u16 = dest_info.bits;
-        var wrap_ctype: ?CType = null;
-        var need_bitcasts = false;
-
-        try f.writeCValue(w, local, .Other);
-        switch (dest_ctype.info(ctype_pool)) {
-            else => {},
-            .array => |array_info| {
-                try w.print("[{d}]", .{switch (target.cpu.arch.endian()) {
-                    .little => array_info.len - 1,
-                    .big => 0,
-                }});
-                wrap_ctype = array_info.elem_ctype.toSignedness(dest_info.signedness);
-                need_bitcasts = wrap_ctype.?.index == .zig_i128;
-                bits -= 1;
-                bits %= @as(u16, @intCast(f.byteSize(array_info.elem_ctype) * 8));
-                bits += 1;
+        switch (CType.classifyInt(dest_ty, zcu)) {
+            .void => unreachable, // opv
+            .small => {
+                try f.writeCValue(w, local, .other);
+                try w.writeAll(" = zig_wrap_");
+                try f.dg.renderTypeForBuiltinFnName(w, dest_ty);
+                try w.writeByte('(');
+                try f.writeCValue(w, local, .other);
+                try f.dg.renderBuiltinInfo(w, dest_ty, .bits);
+                try w.writeAll(");");
+                try f.newline();
             },
-        }
-        try w.writeAll(" = ");
-        if (need_bitcasts) {
-            try w.writeAll("zig_bitCast_");
-            try f.object.dg.renderCTypeForBuiltinFnName(w, wrap_ctype.?.toUnsigned());
-            try w.writeByte('(');
-        }
-        try w.writeAll("zig_wrap_");
-        const info_ty = try pt.intType(dest_info.signedness, bits);
-        if (wrap_ctype) |ctype|
-            try f.object.dg.renderCTypeForBuiltinFnName(w, ctype)
-        else
-            try f.object.dg.renderTypeForBuiltinFnName(w, info_ty);
-        try w.writeByte('(');
-        if (need_bitcasts) {
-            try w.writeAll("zig_bitCast_");
-            try f.object.dg.renderCTypeForBuiltinFnName(w, wrap_ctype.?);
-            try w.writeByte('(');
-        }
-        try f.writeCValue(w, local, .Other);
-        switch (dest_ctype.info(ctype_pool)) {
-            else => {},
-            .array => |array_info| try w.print("[{d}]", .{
-                switch (target.cpu.arch.endian()) {
-                    .little => array_info.len - 1,
+            .big => |big| {
+                const dest_info = dest_ty.intInfo(zcu);
+                const padding_index: u16 = switch (target.cpu.arch.endian()) {
+                    .little => big.limbs_len - 1,
                     .big => 0,
-                },
-            }),
+                };
+                const wrap_bits = ((dest_info.bits - 1) % big.limb_size.bits()) + 1;
+                if (big.limb_size != .@"128" or dest_info.signedness == .unsigned) {
+                    try f.writeCValueMember(w, local, .{ .identifier = "limbs" });
+                    try w.print("[{d}] = zig_wrap_{c}{d}(", .{
+                        padding_index,
+                        signAbbrev(dest_info.signedness),
+                        big.limb_size.bits(),
+                    });
+                    try f.writeCValueMember(w, local, .{ .identifier = "limbs" });
+                    try w.print("[{d}], {d});", .{ padding_index, wrap_bits });
+                } else {
+                    try f.writeCValueMember(w, local, .{ .identifier = "limbs" });
+                    try w.print("[{d}] = zig_bitCast_u128(zig_wrap_i128(zig_bitCast_i128(", .{
+                        padding_index,
+                    });
+                    try f.writeCValueMember(w, local, .{ .identifier = "limbs" });
+                    try w.print("[{d}]), {d}));", .{ padding_index, wrap_bits });
+                    try f.newline();
+                }
+            },
         }
-        if (need_bitcasts) try w.writeByte(')');
-        try f.object.dg.renderBuiltinInfo(w, info_ty, .bits);
-        if (need_bitcasts) try w.writeByte(')');
-        try w.writeAll(");");
-        try f.object.newline();
     }
 
-    try f.freeCValue(null, operand_lval);
     return local;
 }
 
-fn airTrap(f: *Function, w: *Writer) !void {
+fn airTrap(f: *Function) !void {
     // Not even allowed to call trap in a naked function.
-    if (f.object.dg.is_naked_fn) return;
-    try w.writeAll("zig_trap();\n");
+    if (f.dg.is_naked_fn) return;
+    try f.code.writer.writeAll("zig_trap();\n");
 }
 
 fn airBreakpoint(f: *Function) !CValue {
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     try w.writeAll("zig_breakpoint();");
-    try f.object.newline();
+    try f.newline();
     return .none;
 }
 
 fn airRetAddr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, .usize);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = (");
     try f.renderType(w, .usize);
     try w.writeAll(")zig_return_address();");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airFrameAddress(f: *Function, inst: Air.Inst.Index) !CValue {
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, .usize);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = (");
     try f.renderType(w, .usize);
     try w.writeAll(")zig_frame_address();");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
-fn airUnreach(o: *Object) !void {
+fn airUnreach(f: *Function) !void {
     // Not even allowed to call unreachable in a naked function.
-    if (o.dg.is_naked_fn) return;
-    try o.code.writer.writeAll("zig_unreachable();\n");
+    if (f.dg.is_naked_fn) return;
+    try f.code.writer.writeAll("zig_unreachable();\n");
 }
 
 fn airLoop(f: *Function, inst: Air.Inst.Index) !void {
     const block = f.air.unwrapBlock(inst);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     // `repeat` instructions matching this loop will branch to
     // this label. Since we need a label for arbitrary `repeat`
     // anyway, there's actually no need to use a "real" looping
     // construct at all!
     try w.print("zig_loop_{d}:", .{@intFromEnum(inst)});
-    try f.object.newline();
+    try f.newline();
     try genBodyInner(f, block.body); // no need to restore state, we're noreturn
 }
 
@@ -5158,15 +4424,15 @@ fn airCondBr(f: *Function, inst: Air.Inst.Index) !void {
     const then_body = cond_br.then_body;
     const else_body = cond_br.else_body;
     const liveness_condbr = f.liveness.getCondBr(inst);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     try w.writeAll("if (");
-    try f.writeCValue(w, cond, .Other);
+    try f.writeCValue(w, cond, .other);
     try w.writeAll(") ");
 
     try genBodyResolveState(f, inst, liveness_condbr.then_deaths, then_body, false);
-    try f.object.newline();
-    if (else_body.len > 0) if (f.object.dg.expected_block) |_|
+    try f.newline();
+    if (else_body.len > 0) if (f.dg.expected_block) |_|
         return f.fail("runtime code not allowed in naked function", .{});
 
     // We don't need to use `genBodyResolveState` for the else block, because this instruction is
@@ -5184,23 +4450,23 @@ fn airCondBr(f: *Function, inst: Air.Inst.Index) !void {
 }
 
 fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const gpa = f.object.dg.gpa;
+    const gpa = f.dg.gpa;
     const switch_br = f.air.unwrapSwitch(inst);
     const init_condition = try f.resolveInst(switch_br.operand);
     try reap(f, inst, &.{switch_br.operand});
     const condition_ty = f.typeOf(switch_br.operand);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     // For dispatches, we will create a local alloc to contain the condition value.
     // This may not result in optimal codegen for switch loops, but it minimizes the
     // amount of C code we generate, which is probably more desirable here (and is simpler).
     const condition = if (is_dispatch_loop) cond: {
         const new_local = try f.allocLocal(inst, condition_ty);
-        try f.copyCValue(try f.ctypeFromType(condition_ty, .complete), new_local, init_condition);
+        try f.copyCValue(new_local, init_condition);
         try w.print("zig_switch_{d}_loop:", .{@intFromEnum(inst)});
-        try f.object.newline();
+        try f.newline();
         try f.loop_switch_conds.put(gpa, inst, new_local.new_local);
         break :cond new_local;
     } else init_condition;
@@ -5222,9 +4488,9 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void
         try f.renderType(w, lowered_condition_ty);
         try w.writeByte(')');
     }
-    try f.writeCValue(w, condition, .Other);
+    try f.writeCValue(w, condition, .other);
     try w.writeAll(") {");
-    f.object.indent();
+    f.indent();
 
     const liveness = try f.liveness.getSwitchBr(gpa, inst, switch_br.cases_len + 1);
     defer gpa.free(liveness.deaths);
@@ -5237,7 +4503,7 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void
             continue;
         }
         for (case.items) |item| {
-            try f.object.newline();
+            try f.newline();
             try w.writeAll("case ");
             const item_value = try f.air.value(item, pt);
             // If `item_value` is a pointer with a known integer address, print the address
@@ -5254,28 +4520,28 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void
                     try f.renderType(w, .usize);
                     try w.writeByte(')');
                 }
-                try f.object.dg.renderValue(w, (try f.air.value(item, pt)).?, .Other);
+                try f.dg.renderValue(w, (try f.air.value(item, pt)).?, .other);
             }
             try w.writeByte(':');
         }
         try w.writeAll(" {");
-        f.object.indent();
-        try f.object.newline();
+        f.indent();
+        try f.newline();
         if (is_dispatch_loop) {
             try w.print("zig_switch_{d}_dispatch_{d}:;", .{ @intFromEnum(inst), case.idx });
-            try f.object.newline();
+            try f.newline();
         }
         try genBodyResolveState(f, inst, liveness.deaths[case.idx], case.body, true);
-        try f.object.outdent();
+        try f.outdent();
         try w.writeByte('}');
-        if (f.object.dg.expected_block) |_|
+        if (f.dg.expected_block) |_|
             return f.fail("runtime code not allowed in naked function", .{});
 
         // The case body must be noreturn so we don't need to insert a break.
     }
 
     const else_body = it.elseBody();
-    try f.object.newline();
+    try f.newline();
 
     try w.writeAll("default: ");
     if (any_range_cases) {
@@ -5288,33 +4554,33 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void
             try w.writeAll("if (");
             for (case.items, 0..) |item, item_i| {
                 if (item_i != 0) try w.writeAll(" || ");
-                try f.writeCValue(w, condition, .Other);
+                try f.writeCValue(w, condition, .other);
                 try w.writeAll(" == ");
-                try f.object.dg.renderValue(w, (try f.air.value(item, pt)).?, .Other);
+                try f.dg.renderValue(w, (try f.air.value(item, pt)).?, .other);
             }
             for (case.ranges, 0..) |range, range_i| {
                 if (case.items.len != 0 or range_i != 0) try w.writeAll(" || ");
                 // "(x >= lower && x <= upper)"
                 try w.writeByte('(');
-                try f.writeCValue(w, condition, .Other);
+                try f.writeCValue(w, condition, .other);
                 try w.writeAll(" >= ");
-                try f.object.dg.renderValue(w, (try f.air.value(range[0], pt)).?, .Other);
+                try f.dg.renderValue(w, (try f.air.value(range[0], pt)).?, .other);
                 try w.writeAll(" && ");
-                try f.writeCValue(w, condition, .Other);
+                try f.writeCValue(w, condition, .other);
                 try w.writeAll(" <= ");
-                try f.object.dg.renderValue(w, (try f.air.value(range[1], pt)).?, .Other);
+                try f.dg.renderValue(w, (try f.air.value(range[1], pt)).?, .other);
                 try w.writeByte(')');
             }
             try w.writeAll(") {");
-            f.object.indent();
-            try f.object.newline();
+            f.indent();
+            try f.newline();
             if (is_dispatch_loop) {
                 try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @intFromEnum(inst), case.idx });
             }
             try genBodyResolveState(f, inst, liveness.deaths[case.idx], case.body, true);
-            try f.object.outdent();
+            try f.outdent();
             try w.writeByte('}');
-            if (f.object.dg.expected_block) |_|
+            if (f.dg.expected_block) |_|
                 return f.fail("runtime code not allowed in naked function", .{});
         }
     }
@@ -5328,16 +4594,16 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void
             try die(f, inst, death.toRef());
         }
         try genBody(f, else_body);
-        if (f.object.dg.expected_block) |_|
+        if (f.dg.expected_block) |_|
             return f.fail("runtime code not allowed in naked function", .{});
-    } else try airUnreach(&f.object);
-    try f.object.newline();
-    try f.object.outdent();
+    } else try airUnreach(f);
+    try f.newline();
+    try f.outdent();
     try w.writeAll("}\n");
 }
 
 fn asmInputNeedsLocal(f: *Function, constraint: []const u8, value: CValue) bool {
-    const dg = f.object.dg;
+    const dg = f.dg;
     const target = &dg.mod.resolved_target.result;
     return switch (constraint[0]) {
         '{' => true,
@@ -5357,28 +4623,28 @@ fn asmInputNeedsLocal(f: *Function, constraint: []const u8, value: CValue) bool
 }
 
 fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const unwrapped_asm = f.air.unwrapAsm(inst);
     const is_volatile = unwrapped_asm.is_volatile;
-    const gpa = f.object.dg.gpa;
+    const gpa = f.dg.gpa;
     const outputs = unwrapped_asm.outputs;
     const inputs = unwrapped_asm.inputs;
 
     const result = result: {
-        const w = &f.object.code.writer;
+        const w = &f.code.writer;
         const inst_ty = f.typeOfIndex(inst);
         const inst_local = if (inst_ty.hasRuntimeBits(zcu)) local: {
             const inst_local = try f.allocLocalValue(.{
-                .ctype = try f.ctypeFromType(inst_ty, .complete),
-                .alignas = CType.AlignAs.fromAbiAlignment(inst_ty.abiAlignment(zcu)),
+                .type = inst_ty,
+                .alignment = .none,
             });
             if (f.wantSafety()) {
-                try f.writeCValue(w, inst_local, .Other);
+                try f.writeCValue(w, inst_local, .other);
                 try w.writeAll(" = ");
-                try f.writeCValue(w, .{ .undef = inst_ty }, .Other);
+                try f.writeCValue(w, .{ .undef = inst_ty }, .other);
                 try w.writeByte(';');
-                try f.object.newline();
+                try f.newline();
             }
             break :local inst_local;
         } else .none;
@@ -5399,20 +4665,20 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
                 const output_ty = if (output.operand == .none) inst_ty else f.typeOf(output.operand).childType(zcu);
                 try w.writeAll("register ");
                 const output_local = try f.allocLocalValue(.{
-                    .ctype = try f.ctypeFromType(output_ty, .complete),
-                    .alignas = CType.AlignAs.fromAbiAlignment(output_ty.abiAlignment(zcu)),
+                    .type = output_ty,
+                    .alignment = .none,
                 });
                 try f.allocs.put(gpa, output_local.new_local, false);
-                try f.object.dg.renderTypeAndName(w, output_ty, output_local, .{}, .none, .complete);
+                try f.dg.renderTypeAndName(w, output_ty, output_local, .{}, .none);
                 try w.writeAll(" __asm(\"");
                 try w.writeAll(constraint["={".len .. constraint.len - "}".len]);
                 try w.writeAll("\")");
                 if (f.wantSafety()) {
                     try w.writeAll(" = ");
-                    try f.writeCValue(w, .{ .undef = output_ty }, .Other);
+                    try f.writeCValue(w, .{ .undef = output_ty }, .other);
                 }
                 try w.writeByte(';');
-                try f.object.newline();
+                try f.newline();
             }
         }
 
@@ -5432,29 +4698,29 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
                 const input_ty = f.typeOf(input.operand);
                 if (is_reg) try w.writeAll("register ");
                 const input_local = try f.allocLocalValue(.{
-                    .ctype = try f.ctypeFromType(input_ty, .complete),
-                    .alignas = CType.AlignAs.fromAbiAlignment(input_ty.abiAlignment(zcu)),
+                    .type = input_ty,
+                    .alignment = .none,
                 });
                 try f.allocs.put(gpa, input_local.new_local, false);
                 // Do not render the declaration as `const` qualified if we're generating an
                 // explicit `register` local, as GCC will ignore the constraint completely.
-                try f.object.dg.renderTypeAndName(w, input_ty, input_local, if (is_reg) .{} else Const, .none, .complete);
+                try f.dg.renderTypeAndName(w, input_ty, input_local, .{ .@"const" = is_reg }, .none);
                 if (is_reg) {
                     try w.writeAll(" __asm(\"");
                     try w.writeAll(constraint["{".len .. constraint.len - "}".len]);
                     try w.writeAll("\")");
                 }
                 try w.writeAll(" = ");
-                try f.writeCValue(w, input_val, .Other);
+                try f.writeCValue(w, input_val, .other);
                 try w.writeByte(';');
-                try f.object.newline();
+                try f.newline();
             }
         }
 
         {
             const asm_source = unwrapped_asm.source;
 
-            var stack = std.heap.stackFallback(256, f.object.dg.gpa);
+            var stack = std.heap.stackFallback(256, f.dg.gpa);
             const allocator = stack.get();
             const fixed_asm_source = try allocator.alloc(u8, asm_source.len);
             defer allocator.free(fixed_asm_source);
@@ -5520,10 +4786,10 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
             const is_reg = constraint[1] == '{';
             try w.print("{f}(", .{fmtStringLiteral(if (is_reg) "=r" else constraint, null)});
             if (is_reg) {
-                try f.writeCValue(w, .{ .local = locals_index }, .Other);
+                try f.writeCValue(w, .{ .local = locals_index }, .other);
                 locals_index += 1;
             } else if (output.operand == .none) {
-                try f.writeCValue(w, inst_local, .FunctionArgument);
+                try f.writeCValue(w, inst_local, .other);
             } else {
                 try f.writeCValueDeref(w, try f.resolveInst(output.operand));
             }
@@ -5547,7 +4813,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
                 const input_local_idx = locals_index;
                 locals_index += 1;
                 break :local .{ .local = input_local_idx };
-            } else input_val, .Other);
+            } else input_val, .other);
             try w.writeByte(')');
         }
         try w.writeByte(':');
@@ -5567,7 +4833,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
             const field_name = clobbers_ty.structFieldName(field_index, zcu).toSlice(ip).?;
             assert(field_name.len != 0);
 
-            const target = &f.object.dg.mod.resolved_target.result;
+            const target = &f.dg.mod.resolved_target.result;
             var c_name_buf: [16]u8 = undefined;
             const name =
                 if ((target.cpu.arch.isMIPS() or target.cpu.arch == .alpha) and field_name[0] == 'r') name: {
@@ -5594,7 +4860,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
         }
         w.undo(1); // erase the last comma
         try w.writeAll(");");
-        try f.object.newline();
+        try f.newline();
 
         locals_index = locals_begin;
         it = unwrapped_asm.iterateOutputs();
@@ -5608,10 +4874,10 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
                 else
                     try f.resolveInst(output.operand));
                 try w.writeAll(" = ");
-                try f.writeCValue(w, .{ .local = locals_index }, .Other);
+                try f.writeCValue(w, .{ .local = locals_index }, .other);
                 locals_index += 1;
                 try w.writeByte(';');
-                try f.object.newline();
+                try f.newline();
             }
         }
 
@@ -5633,147 +4899,145 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
 fn airIsNull(
     f: *Function,
     inst: Air.Inst.Index,
-    operator: std.math.CompareOperator,
+    operator: enum { eq, neq },
     is_ptr: bool,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const ctype_pool = &f.object.dg.ctype_pool;
     const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const operand = try f.resolveInst(un_op);
     try reap(f, inst, &.{un_op});
 
     const local = try f.allocLocal(inst, .bool);
-    const a = try Assignment.start(f, w, .bool);
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
 
     const operand_ty = f.typeOf(un_op);
     const optional_ty = if (is_ptr) operand_ty.childType(zcu) else operand_ty;
-    const opt_ctype = try f.ctypeFromType(optional_ty, .complete);
-    const rhs = switch (opt_ctype.info(ctype_pool)) {
-        .basic, .pointer => rhs: {
-            if (is_ptr)
-                try f.writeCValueDeref(w, operand)
-            else
-                try f.writeCValue(w, operand, .Other);
-            break :rhs if (opt_ctype.isBool())
-                "true"
-            else if (opt_ctype.isInteger())
-                "0"
-            else
-                "NULL";
+
+    const pre: []const u8, const maybe_field: ?[]const u8, const post: []const u8 = switch (operator) {
+        // zig fmt: off
+        .eq => switch (CType.classifyOptional(optional_ty, zcu)) {
+            .npv_payload => unreachable, // opv optional
+            .error_set   => .{ "", null,      " == 0" },
+            .ptr_like    => .{ "", null,      " == NULL" },
+            .slice_like  => .{ "", "ptr",     " == NULL" },
+            .opv_payload => .{ "", "is_null", "" },
+            .@"struct"   => .{ "", "is_null", "" },
         },
-        .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-        .aggregate => |aggregate| switch (aggregate.fields.at(0, ctype_pool).name.index) {
-            .is_null, .payload => rhs: {
-                if (is_ptr)
-                    try f.writeCValueDerefMember(w, operand, .{ .identifier = "is_null" })
-                else
-                    try f.writeCValueMember(w, operand, .{ .identifier = "is_null" });
-                break :rhs "true";
-            },
-            .ptr, .len => rhs: {
-                if (is_ptr)
-                    try f.writeCValueDerefMember(w, operand, .{ .identifier = "ptr" })
-                else
-                    try f.writeCValueMember(w, operand, .{ .identifier = "ptr" });
-                break :rhs "NULL";
-            },
-            else => unreachable,
+        .neq => switch (CType.classifyOptional(optional_ty, zcu)) {
+            .npv_payload => unreachable, // opv optional
+            .error_set   => .{ "",  null,      " != 0" },
+            .ptr_like    => .{ "",  null,      " != NULL" },
+            .slice_like  => .{ "",  "ptr",     " != NULL" },
+            .opv_payload => .{ "!", "is_null", "" },
+            .@"struct"   => .{ "!", "is_null", "" },
         },
+        // zig fmt: on
     };
-    try w.writeAll(compareOperatorC(operator));
-    try w.writeAll(rhs);
-    try a.end(f, w);
+
+    try w.writeAll(pre);
+    if (maybe_field) |field| {
+        if (is_ptr) {
+            try f.writeCValueDerefMember(w, operand, .{ .identifier = field });
+        } else {
+            try f.writeCValueMember(w, operand, .{ .identifier = field });
+        }
+    } else {
+        if (is_ptr) {
+            try f.writeCValueDeref(w, operand);
+        } else {
+            try f.writeCValue(w, operand, .other);
+        }
+    }
+    try w.writeAll(post);
+
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 fn airOptionalPayload(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const ctype_pool = &f.object.dg.ctype_pool;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
     const inst_ty = f.typeOfIndex(inst);
     const operand_ty = f.typeOf(ty_op.operand);
     const opt_ty = if (is_ptr) operand_ty.childType(zcu) else operand_ty;
-    const opt_ctype = try f.ctypeFromType(opt_ty, .complete);
-    if (opt_ctype.isBool()) return if (is_ptr) .{ .undef = inst_ty } else .none;
 
     const operand = try f.resolveInst(ty_op.operand);
-    switch (opt_ctype.info(ctype_pool)) {
-        .basic, .pointer => return f.moveCValue(inst, inst_ty, operand),
-        .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-        .aggregate => |aggregate| switch (aggregate.fields.at(0, ctype_pool).name.index) {
-            .is_null, .payload => {
-                const w = &f.object.code.writer;
-                const local = try f.allocLocal(inst, inst_ty);
-                const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-                try f.writeCValue(w, local, .Other);
-                try a.assign(f, w);
-                if (is_ptr) {
-                    try w.writeByte('&');
-                    try f.writeCValueDerefMember(w, operand, .{ .identifier = "payload" });
-                } else try f.writeCValueMember(w, operand, .{ .identifier = "payload" });
-                try a.end(f, w);
-                return local;
-            },
-            .ptr, .len => return f.moveCValue(inst, inst_ty, operand),
-            else => unreachable,
+
+    switch (CType.classifyOptional(opt_ty, zcu)) {
+        .npv_payload => unreachable, // opv optional
+
+        .opv_payload => return if (is_ptr) .{ .undef = inst_ty } else .none,
+
+        .error_set,
+        .ptr_like,
+        .slice_like,
+        => return f.moveCValue(inst, inst_ty, operand),
+
+        .@"struct" => {
+            const w = &f.code.writer;
+            const local = try f.allocLocal(inst, inst_ty);
+            try f.writeCValue(w, local, .other);
+            try w.writeAll(" = ");
+            if (is_ptr) {
+                try w.writeByte('&');
+                try f.writeCValueDerefMember(w, operand, .{ .identifier = "payload" });
+            } else try f.writeCValueMember(w, operand, .{ .identifier = "payload" });
+            try w.writeByte(';');
+            try f.newline();
+            return local;
         },
     }
 }
 
 fn airOptionalPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const operand = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
     const operand_ty = f.typeOf(ty_op.operand);
+    const opt_ty = operand_ty.childType(zcu);
 
     const inst_ty = f.typeOfIndex(inst);
-    const opt_ctype = try f.ctypeFromType(operand_ty.childType(zcu), .complete);
-    switch (opt_ctype.info(&f.object.dg.ctype_pool)) {
-        .basic => {
-            const a = try Assignment.start(f, w, opt_ctype);
-            try f.writeCValueDeref(w, operand);
-            try a.assign(f, w);
-            try f.object.dg.renderValue(w, Value.false, .Other);
-            try a.end(f, w);
-            return .none;
+
+    switch (CType.classifyOptional(opt_ty, zcu)) {
+        .npv_payload => unreachable, // opv optional
+
+        .opv_payload => {
+            try f.writeCValueDerefMember(w, operand, .{ .identifier = "is_null" });
+            try w.writeAll(" = ");
+            try f.dg.renderValue(w, .false, .other);
+            try w.writeByte(';');
+            try f.newline();
+            return .{ .undef = inst_ty };
         },
-        .pointer => {
+
+        .error_set,
+        .ptr_like,
+        .slice_like,
+        => return f.moveCValue(inst, inst_ty, operand),
+
+        .@"struct" => {
+            try f.writeCValueDerefMember(w, operand, .{ .identifier = "is_null" });
+            try w.writeAll(" = ");
+            try f.dg.renderValue(w, .false, .other);
+            try w.writeByte(';');
+            try f.newline();
             if (f.liveness.isUnused(inst)) return .none;
             const local = try f.allocLocal(inst, inst_ty);
-            const a = try Assignment.start(f, w, opt_ctype);
-            try f.writeCValue(w, local, .Other);
-            try a.assign(f, w);
-            try f.writeCValue(w, operand, .Other);
-            try a.end(f, w);
-            return local;
-        },
-        .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-        .aggregate => {
-            {
-                const a = try Assignment.start(f, w, opt_ctype);
-                try f.writeCValueDerefMember(w, operand, .{ .identifier = "is_null" });
-                try a.assign(f, w);
-                try f.object.dg.renderValue(w, Value.false, .Other);
-                try a.end(f, w);
-            }
-            if (f.liveness.isUnused(inst)) return .none;
-            const local = try f.allocLocal(inst, inst_ty);
-            const a = try Assignment.start(f, w, opt_ctype);
-            try f.writeCValue(w, local, .Other);
-            try a.assign(f, w);
-            try w.writeByte('&');
+            try f.writeCValue(w, local, .other);
+            try w.writeAll(" = &");
             try f.writeCValueDerefMember(w, operand, .{ .identifier = "payload" });
-            try a.end(f, w);
+            try w.writeByte(';');
+            try f.newline();
             return local;
         },
     }
@@ -5817,18 +5081,20 @@ fn fieldLocation(
         .union_type => {
             const loaded_union = ip.loadUnionType(container_ty.toIntern());
             switch (loaded_union.layout) {
-                .auto, .@"extern" => {
+                .auto => {
                     const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                    if (!field_ty.hasRuntimeBits(zcu))
-                        return if (loaded_union.has_runtime_tag and !container_ty.unionHasAllZeroBitFieldTypes(zcu))
-                            .{ .field = .{ .identifier = "payload" } }
-                        else
-                            .begin;
+                    if (!field_ty.hasRuntimeBits(zcu)) {
+                        if (container_ty.unionHasAllZeroBitFieldTypes(zcu)) return .begin;
+                        return .{ .field = .{ .identifier = "payload" } };
+                    }
                     const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
-                    return .{ .field = if (loaded_union.has_runtime_tag)
-                        .{ .payload_identifier = field_name.toSlice(ip) }
-                    else
-                        .{ .identifier = field_name.toSlice(ip) } };
+                    return .{ .field = .{ .payload_identifier = field_name.toSlice(ip) } };
+                },
+                .@"extern" => {
+                    const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
+                    if (!field_ty.hasRuntimeBits(zcu)) return .begin;
+                    const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
+                    return .{ .field = .{ .identifier = field_name.toSlice(ip) } };
                 },
                 .@"packed" => return .begin,
             }
@@ -5865,7 +5131,7 @@ fn airStructFieldPtrIndex(f: *Function, inst: Air.Inst.Index, index: u8) !CValue
 }
 
 fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = f.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
@@ -5877,26 +5143,26 @@ fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const field_ptr_val = try f.resolveInst(extra.field_ptr);
     try reap(f, inst, &.{extra.field_ptr});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, container_ptr_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = (");
     try f.renderType(w, container_ptr_ty);
     try w.writeByte(')');
 
     switch (fieldLocation(container_ptr_ty, field_ptr_ty, extra.field_index, zcu)) {
-        .begin => try f.writeCValue(w, field_ptr_val, .Other),
+        .begin => try f.writeCValue(w, field_ptr_val, .other),
         .field => |field| {
             const u8_ptr_ty = try pt.adjustPtrTypeChild(field_ptr_ty, .u8);
 
             try w.writeAll("((");
             try f.renderType(w, u8_ptr_ty);
             try w.writeByte(')');
-            try f.writeCValue(w, field_ptr_val, .Other);
+            try f.writeCValue(w, field_ptr_val, .other);
             try w.writeAll(" - offsetof(");
             try f.renderType(w, container_ty);
             try w.writeAll(", ");
-            try f.writeCValue(w, field, .Other);
+            try f.writeCValue(w, field, .other);
             try w.writeAll("))");
         },
         .byte_offset => |byte_offset| {
@@ -5905,7 +5171,7 @@ fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
             try w.writeAll("((");
             try f.renderType(w, u8_ptr_ty);
             try w.writeByte(')');
-            try f.writeCValue(w, field_ptr_val, .Other);
+            try f.writeCValue(w, field_ptr_val, .other);
             try w.print(" - {f})", .{
                 try f.fmtIntLiteralDec(try pt.intValue(.usize, byte_offset)),
             });
@@ -5913,7 +5179,7 @@ fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     }
 
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
@@ -5924,23 +5190,19 @@ fn fieldPtr(
     container_ptr_val: CValue,
     field_index: u32,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const container_ty = container_ptr_ty.childType(zcu);
     const field_ptr_ty = f.typeOfIndex(inst);
 
-    // Ensure complete type definition is visible before accessing fields.
-    _ = try f.ctypeFromType(container_ty, .complete);
-
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, field_ptr_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = (");
     try f.renderType(w, field_ptr_ty);
     try w.writeByte(')');
 
     switch (fieldLocation(container_ptr_ty, field_ptr_ty, field_index, zcu)) {
-        .begin => try f.writeCValue(w, container_ptr_val, .Other),
+        .begin => try f.writeCValue(w, container_ptr_val, .other),
         .field => |field| {
             try w.writeByte('&');
             try f.writeCValueDerefMember(w, container_ptr_val, field);
@@ -5951,7 +5213,7 @@ fn fieldPtr(
             try w.writeAll("((");
             try f.renderType(w, u8_ptr_ty);
             try w.writeByte(')');
-            try f.writeCValue(w, container_ptr_val, .Other);
+            try f.writeCValue(w, container_ptr_val, .other);
             try w.print(" + {f})", .{
                 try f.fmtIntLiteralDec(try pt.intValue(.usize, byte_offset)),
             });
@@ -5959,12 +5221,12 @@ fn fieldPtr(
     }
 
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
@@ -5976,10 +5238,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const struct_byval = try f.resolveInst(extra.struct_operand);
     try reap(f, inst, &.{extra.struct_operand});
     const struct_ty = f.typeOf(extra.struct_operand);
-    const w = &f.object.code.writer;
-
-    // Ensure complete type definition is visible before accessing fields.
-    _ = try f.ctypeFromType(struct_ty, .complete);
+    const w = &f.code.writer;
 
     assert(struct_ty.containerLayout(zcu) != .@"packed"); // `Air.Legalize.Feature.expand_packed_struct_field_val` handles this case
     const field_name: CValue = switch (ip.indexToKey(struct_ty.toIntern())) {
@@ -5988,29 +5247,25 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
             const union_type = ip.loadUnionType(struct_ty.toIntern());
             const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
             const field_name_str = enum_tag_ty.enumFieldName(extra.field_index, zcu).toSlice(ip);
-            if (union_type.has_runtime_tag) {
-                break :name .{ .payload_identifier = field_name_str };
-            } else {
-                break :name .{ .identifier = field_name_str };
-            }
+            break :name .{ .payload_identifier = field_name_str };
         },
         .tuple_type => .{ .field = extra.field_index },
         else => unreachable,
     };
 
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     try f.writeCValueMember(w, struct_byval, field_name);
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 /// *(E!T) -> E
 /// Note that the result is never a pointer.
 fn airUnwrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -6020,37 +5275,23 @@ fn airUnwrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
     try reap(f, inst, &.{ty_op.operand});
 
     const operand_is_ptr = operand_ty.zigTypeTag(zcu) == .pointer;
-    const error_union_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty;
-    const error_ty = error_union_ty.errorUnionSet(zcu);
-    const payload_ty = error_union_ty.errorUnionPayload(zcu);
     const local = try f.allocLocal(inst, inst_ty);
 
-    if (!payload_ty.hasRuntimeBits(zcu) and operand == .local and operand.local == local.new_local) {
-        // The store will be 'x = x'; elide it.
-        return local;
-    }
-
-    const w = &f.object.code.writer;
-    try f.writeCValue(w, local, .Other);
+    const w = &f.code.writer;
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = ");
 
-    if (!payload_ty.hasRuntimeBits(zcu))
-        try f.writeCValue(w, operand, .Other)
-    else if (error_ty.errorSetIsEmpty(zcu))
-        try w.print("{f}", .{
-            try f.fmtIntLiteralDec(try pt.intValue(try pt.errorIntType(), 0)),
-        })
-    else if (operand_is_ptr)
+    if (operand_is_ptr)
         try f.writeCValueDerefMember(w, operand, .{ .identifier = "error" })
     else
         try f.writeCValueMember(w, operand, .{ .identifier = "error" });
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airUnwrapErrUnionPay(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -6060,154 +5301,124 @@ fn airUnwrapErrUnionPay(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValu
     const operand_ty = f.typeOf(ty_op.operand);
     const error_union_ty = if (is_ptr) operand_ty.childType(zcu) else operand_ty;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     if (!error_union_ty.errorUnionPayload(zcu).hasRuntimeBits(zcu)) {
-        if (!is_ptr) return .none;
-
+        assert(is_ptr); // opv bug in sema
         const local = try f.allocLocal(inst, inst_ty);
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try w.writeAll(" = (");
         try f.renderType(w, inst_ty);
         try w.writeByte(')');
-        try f.writeCValue(w, operand, .Other);
+        try f.writeCValue(w, operand, .other);
         try w.writeByte(';');
-        try f.object.newline();
+        try f.newline();
         return local;
     }
 
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     if (is_ptr) {
         try w.writeByte('&');
         try f.writeCValueDerefMember(w, operand, .{ .identifier = "payload" });
     } else try f.writeCValueMember(w, operand, .{ .identifier = "payload" });
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 fn airWrapOptional(f: *Function, inst: Air.Inst.Index) !CValue {
-    const ctype_pool = &f.object.dg.ctype_pool;
+    const zcu = f.dg.pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
     const inst_ty = f.typeOfIndex(inst);
-    const inst_ctype = try f.ctypeFromType(inst_ty, .complete);
-    if (inst_ctype.isBool()) return .{ .constant = Value.true };
 
     const operand = try f.resolveInst(ty_op.operand);
-    switch (inst_ctype.info(ctype_pool)) {
-        .basic, .pointer => return f.moveCValue(inst, inst_ty, operand),
-        .aligned, .array, .vector, .fwd_decl, .function => unreachable,
-        .aggregate => |aggregate| switch (aggregate.fields.at(0, ctype_pool).name.index) {
-            .is_null, .payload => {
-                const operand_ctype = try f.ctypeFromType(f.typeOf(ty_op.operand), .complete);
-                const w = &f.object.code.writer;
-                const local = try f.allocLocal(inst, inst_ty);
-                {
-                    const a = try Assignment.start(f, w, .bool);
-                    try f.writeCValueMember(w, local, .{ .identifier = "is_null" });
-                    try a.assign(f, w);
-                    try w.writeAll("false");
-                    try a.end(f, w);
-                }
-                {
-                    const a = try Assignment.start(f, w, operand_ctype);
-                    try f.writeCValueMember(w, local, .{ .identifier = "payload" });
-                    try a.assign(f, w);
-                    try f.writeCValue(w, operand, .Other);
-                    try a.end(f, w);
-                }
-                return local;
-            },
-            .ptr, .len => return f.moveCValue(inst, inst_ty, operand),
-            else => unreachable,
+
+    switch (CType.classifyOptional(inst_ty, zcu)) {
+        .npv_payload => unreachable, // opv optional
+
+        .opv_payload => unreachable, // opv bug in Sema
+
+        .error_set,
+        .ptr_like,
+        .slice_like,
+        => return f.moveCValue(inst, inst_ty, operand),
+
+        .@"struct" => {
+            const w = &f.code.writer;
+            const local = try f.allocLocal(inst, inst_ty);
+
+            try f.writeCValueMember(w, local, .{ .identifier = "is_null" });
+            try w.writeAll(" = false;");
+            try f.newline();
+
+            try f.writeCValueMember(w, local, .{ .identifier = "payload" });
+            try w.writeAll(" = ");
+            try f.writeCValue(w, operand, .other);
+            try w.writeByte(';');
+            try f.newline();
+
+            return local;
         },
     }
 }
 
 fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
     const inst_ty = f.typeOfIndex(inst);
     const payload_ty = inst_ty.errorUnionPayload(zcu);
-    const repr_is_err = !payload_ty.hasRuntimeBits(zcu);
-    const err_ty = inst_ty.errorUnionSet(zcu);
     const err = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
 
-    if (repr_is_err and err == .local and err.local == local.new_local) {
-        // The store will be 'x = x'; elide it.
-        return local;
-    }
-
-    if (!repr_is_err) {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(payload_ty, .complete));
+    if (payload_ty.hasRuntimeBits(zcu)) {
         try f.writeCValueMember(w, local, .{ .identifier = "payload" });
-        try a.assign(f, w);
-        try f.object.dg.renderUndefValue(w, payload_ty, .Other);
-        try a.end(f, w);
-    }
-    {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(err_ty, .complete));
-        if (repr_is_err)
-            try f.writeCValue(w, local, .Other)
-        else
-            try f.writeCValueMember(w, local, .{ .identifier = "error" });
-        try a.assign(f, w);
-        try f.writeCValue(w, err, .Other);
-        try a.end(f, w);
+        try w.writeAll(" = ");
+        try f.dg.renderUndefValue(w, payload_ty, .other);
+        try w.writeByte(';');
+        try f.newline();
     }
+
+    try f.writeCValueMember(w, local, .{ .identifier = "error" });
+    try w.writeAll(" = ");
+    try f.writeCValue(w, err, .other);
+    try w.writeByte(';');
+    try f.newline();
+
     return local;
 }
 
 fn airErrUnionPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
-    const w = &f.object.code.writer;
+    const pt = f.dg.pt;
+    const w = &f.code.writer;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const inst_ty = f.typeOfIndex(inst);
     const operand = try f.resolveInst(ty_op.operand);
-    const operand_ty = f.typeOf(ty_op.operand);
-    const error_union_ty = operand_ty.childType(zcu);
 
-    const payload_ty = error_union_ty.errorUnionPayload(zcu);
     const err_int_ty = try pt.errorIntType();
     const no_err = try pt.intValue(err_int_ty, 0);
     try reap(f, inst, &.{ty_op.operand});
 
     // First, set the non-error value.
-    if (!payload_ty.hasRuntimeBits(zcu)) {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(operand_ty, .complete));
-        try f.writeCValueDeref(w, operand);
-        try a.assign(f, w);
-        try w.print("{f}", .{try f.fmtIntLiteralDec(no_err)});
-        try a.end(f, w);
-        return .none;
-    }
-    {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(err_int_ty, .complete));
-        try f.writeCValueDerefMember(w, operand, .{ .identifier = "error" });
-        try a.assign(f, w);
-        try w.print("{f}", .{try f.fmtIntLiteralDec(no_err)});
-        try a.end(f, w);
-    }
+    try f.writeCValueDerefMember(w, operand, .{ .identifier = "error" });
+    try w.print(" = {f};", .{try f.fmtIntLiteralDec(no_err)});
+    try f.newline();
 
     // Then return the payload pointer (only if it is used)
     if (f.liveness.isUnused(inst)) return .none;
 
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
-    try w.writeByte('&');
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = &");
     try f.writeCValueDerefMember(w, operand, .{ .identifier = "payload" });
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
@@ -6227,7 +5438,7 @@ fn airSaveErrReturnTraceIndex(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -6235,120 +5446,88 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
     const payload_ty = inst_ty.errorUnionPayload(zcu);
     const payload = try f.resolveInst(ty_op.operand);
     assert(payload_ty.hasRuntimeBits(zcu));
-    const err_ty = inst_ty.errorUnionSet(zcu);
     try reap(f, inst, &.{ty_op.operand});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(payload_ty, .complete));
-        try f.writeCValueMember(w, local, .{ .identifier = "payload" });
-        try a.assign(f, w);
-        try f.writeCValue(w, payload, .Other);
-        try a.end(f, w);
-    }
-    {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(err_ty, .complete));
-        try f.writeCValueMember(w, local, .{ .identifier = "error" });
-        try a.assign(f, w);
-        try f.object.dg.renderValue(w, try pt.intValue(try pt.errorIntType(), 0), .Other);
-        try a.end(f, w);
-    }
+
+    try f.writeCValueMember(w, local, .{ .identifier = "payload" });
+    try w.writeAll(" = ");
+    try f.writeCValue(w, payload, .other);
+    try w.writeByte(';');
+    try f.newline();
+
+    try f.writeCValueMember(w, local, .{ .identifier = "error" });
+    try w.writeAll(" = ");
+    try f.dg.renderValue(w, try pt.intValue(try pt.errorIntType(), 0), .other);
+    try w.writeByte(';');
+    try f.newline();
+
     return local;
 }
 
 fn airIsErr(f: *Function, inst: Air.Inst.Index, is_ptr: bool, operator: []const u8) !CValue {
-    const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
+    const pt = f.dg.pt;
     const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const operand = try f.resolveInst(un_op);
     try reap(f, inst, &.{un_op});
-    const operand_ty = f.typeOf(un_op);
     const local = try f.allocLocal(inst, .bool);
-    const err_union_ty = if (is_ptr) operand_ty.childType(zcu) else operand_ty;
-    const payload_ty = err_union_ty.errorUnionPayload(zcu);
-    const error_ty = err_union_ty.errorUnionSet(zcu);
 
-    const a = try Assignment.start(f, w, .bool);
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     const err_int_ty = try pt.errorIntType();
-    if (!error_ty.errorSetIsEmpty(zcu))
-        if (payload_ty.hasRuntimeBits(zcu))
-            if (is_ptr)
-                try f.writeCValueDerefMember(w, operand, .{ .identifier = "error" })
-            else
-                try f.writeCValueMember(w, operand, .{ .identifier = "error" })
-        else
-            try f.writeCValue(w, operand, .Other)
+    if (is_ptr)
+        try f.writeCValueDerefMember(w, operand, .{ .identifier = "error" })
     else
-        try f.object.dg.renderValue(w, try pt.intValue(err_int_ty, 0), .Other);
-    try w.writeByte(' ');
-    try w.writeAll(operator);
-    try w.writeByte(' ');
-    try f.object.dg.renderValue(w, try pt.intValue(err_int_ty, 0), .Other);
-    try a.end(f, w);
+        try f.writeCValueMember(w, operand, .{ .identifier = "error" });
+    try w.print(" {s} ", .{operator});
+    try f.dg.renderValue(w, try pt.intValue(err_int_ty, 0), .other);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
-    const ctype_pool = &f.object.dg.ctype_pool;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
     const operand = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
     const inst_ty = f.typeOfIndex(inst);
-    const ptr_ty = inst_ty.slicePtrFieldType(zcu);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const operand_ty = f.typeOf(ty_op.operand);
     const array_ty = operand_ty.childType(zcu);
 
-    {
-        const a = try Assignment.start(f, w, try f.ctypeFromType(ptr_ty, .complete));
-        try f.writeCValueMember(w, local, .{ .identifier = "ptr" });
-        try a.assign(f, w);
-        if (operand == .undef) {
-            try f.writeCValue(w, .{ .undef = inst_ty.slicePtrFieldType(zcu) }, .Other);
-        } else {
-            const ptr_ctype = try f.ctypeFromType(ptr_ty, .complete);
-            const ptr_child_ctype = ptr_ctype.info(ctype_pool).pointer.elem_ctype;
-            const elem_ty = array_ty.childType(zcu);
-            const elem_ctype = try f.ctypeFromType(elem_ty, .complete);
-            if (!ptr_child_ctype.eql(elem_ctype)) {
-                try w.writeByte('(');
-                try f.renderCType(w, ptr_ctype);
-                try w.writeByte(')');
-            }
-            const operand_ctype = try f.ctypeFromType(operand_ty, .complete);
-            const operand_child_ctype = operand_ctype.info(ctype_pool).pointer.elem_ctype;
-            if (operand_child_ctype.info(ctype_pool) == .array) {
-                try w.writeByte('&');
-                try f.writeCValueDeref(w, operand);
-                try w.print("[{f}]", .{try f.fmtIntLiteralDec(.zero_usize)});
-            } else try f.writeCValue(w, operand, .Other);
-        }
-        try a.end(f, w);
-    }
-    {
-        const a = try Assignment.start(f, w, .usize);
-        try f.writeCValueMember(w, local, .{ .identifier = "len" });
-        try a.assign(f, w);
-        try w.print("{f}", .{
-            try f.fmtIntLiteralDec(try pt.intValue(.usize, array_ty.arrayLen(zcu))),
-        });
-        try a.end(f, w);
-    }
+    // We have a `*[n]T`, which was turned into to a pointer to `struct { T array[n]; }`.
+    // Ideally we would want to use 'operand->array' to convert to a `T *` (we get a `T []`
+    // which decays to a pointer), but if the element type is zero-bit or the array length is
+    // zero, there will not be an `array` member (the array type lowers to `void`). We cannot
+    // check the type layout here because it may not be resolved, so in this instance, we must
+    // use a pointer cast.
+    try f.writeCValueMember(w, local, .{ .identifier = "ptr" });
+    try w.writeAll(" = (");
+    try f.dg.renderType(w, inst_ty.slicePtrFieldType(zcu));
+    try w.writeByte(')');
+    try f.writeCValue(w, operand, .other);
+    try w.writeByte(';');
+    try f.newline();
+
+    try f.writeCValueMember(w, local, .{ .identifier = "len" });
+    try w.print(" = {f}", .{
+        try f.fmtIntLiteralDec(try pt.intValue(.usize, array_ty.arrayLen(zcu))),
+    });
+    try w.writeByte(';');
+    try f.newline();
 
     return local;
 }
 
 fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -6358,7 +5537,7 @@ fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
     try reap(f, inst, &.{ty_op.operand});
     const operand_ty = f.typeOf(ty_op.operand);
     const scalar_ty = operand_ty.scalarType(zcu);
-    const target = &f.object.dg.mod.resolved_target.result;
+    const target = &f.dg.mod.resolved_target.result;
     const operation = if (inst_scalar_ty.isRuntimeFloat() and scalar_ty.isRuntimeFloat())
         if (inst_scalar_ty.floatBits(target) < scalar_ty.floatBits(target)) "trunc" else "extend"
     else if (inst_scalar_ty.isInt(zcu) and scalar_ty.isRuntimeFloat())
@@ -6368,16 +5547,15 @@ fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
     else
         unreachable;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(scalar_ty, .complete));
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
-    try a.assign(f, w);
+    try w.writeAll(" = ");
     if (inst_scalar_ty.isInt(zcu) and scalar_ty.isRuntimeFloat()) {
         try w.writeAll("zig_wrap_");
-        try f.object.dg.renderTypeForBuiltinFnName(w, inst_scalar_ty);
+        try f.dg.renderTypeForBuiltinFnName(w, inst_scalar_ty);
         try w.writeByte('(');
     }
     try w.writeAll("zig_");
@@ -6385,14 +5563,15 @@ fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
     try w.writeAll(compilerRtAbbrev(scalar_ty, zcu, target));
     try w.writeAll(compilerRtAbbrev(inst_scalar_ty, zcu, target));
     try w.writeByte('(');
-    try f.writeCValue(w, operand, .FunctionArgument);
+    try f.writeCValue(w, operand, .other);
     try v.elem(f, w);
     try w.writeByte(')');
     if (inst_scalar_ty.isInt(zcu) and scalar_ty.isRuntimeFloat()) {
-        try f.object.dg.renderBuiltinInfo(w, inst_scalar_ty, .bits);
+        try f.dg.renderBuiltinInfo(w, inst_scalar_ty, .bits);
         try w.writeByte(')');
     }
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -6405,7 +5584,7 @@ fn airUnBuiltinCall(
     operation: []const u8,
     info: BuiltinInfo,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
 
     const operand = try f.resolveInst(operand_ref);
@@ -6415,30 +5594,32 @@ fn airUnBuiltinCall(
     const operand_ty = f.typeOf(operand_ref);
     const scalar_ty = operand_ty.scalarType(zcu);
 
-    const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
-    const ref_ret = inst_scalar_ctype.info(&f.object.dg.ctype_pool) == .array;
+    const ref_ret = lowersToBigInt(inst_scalar_ty, zcu);
+    const ref_arg = lowersToBigInt(scalar_ty, zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
     if (!ref_ret) {
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(" = ");
     }
     try w.print("zig_{s}_", .{operation});
-    try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+    try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
     try w.writeByte('(');
     if (ref_ret) {
-        try f.writeCValue(w, local, .FunctionArgument);
+        try w.writeByte('&');
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(", ");
     }
-    try f.writeCValue(w, operand, .FunctionArgument);
+    if (ref_arg) try w.writeByte('&');
+    try f.writeCValue(w, operand, .other);
     try v.elem(f, w);
-    try f.object.dg.renderBuiltinInfo(w, scalar_ty, info);
+    try f.dg.renderBuiltinInfo(w, scalar_ty, info);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -6450,13 +5631,12 @@ fn airBinBuiltinCall(
     operation: []const u8,
     info: BuiltinInfo,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
 
     const operand_ty = f.typeOf(bin_op.lhs);
-    const operand_ctype = try f.ctypeFromType(operand_ty, .complete);
-    const is_big = operand_ctype.info(&f.object.dg.ctype_pool) == .array;
+    const is_big = lowersToBigInt(operand_ty, zcu);
 
     const lhs = try f.resolveInst(bin_op.lhs);
     const rhs = try f.resolveInst(bin_op.rhs);
@@ -6466,32 +5646,35 @@ fn airBinBuiltinCall(
     const inst_scalar_ty = inst_ty.scalarType(zcu);
     const scalar_ty = operand_ty.scalarType(zcu);
 
-    const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
-    const ref_ret = inst_scalar_ctype.info(&f.object.dg.ctype_pool) == .array;
+    const ref_ret = lowersToBigInt(inst_scalar_ty, zcu);
+    const ref_arg = lowersToBigInt(scalar_ty, zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     if (is_big) try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
     const v = try Vectorize.start(f, inst, w, operand_ty);
     if (!ref_ret) {
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(" = ");
     }
     try w.print("zig_{s}_", .{operation});
-    try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+    try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
     try w.writeByte('(');
     if (ref_ret) {
-        try f.writeCValue(w, local, .FunctionArgument);
+        try w.writeByte('&');
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(", ");
     }
-    try f.writeCValue(w, lhs, .FunctionArgument);
+    if (ref_arg) try w.writeByte('&');
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeAll(", ");
-    try f.writeCValue(w, rhs, .FunctionArgument);
+    if (ref_arg) try w.writeByte('&');
+    try f.writeCValue(w, rhs, .other);
     if (f.typeOf(bin_op.rhs).isVector(zcu)) try v.elem(f, w);
-    try f.object.dg.renderBuiltinInfo(w, scalar_ty, info);
+    try f.dg.renderBuiltinInfo(w, scalar_ty, info);
     try w.writeAll(");\n");
     try v.end(f, inst, w);
 
@@ -6506,7 +5689,7 @@ fn airCmpBuiltinCall(
     operation: enum { cmp, operator },
     info: BuiltinInfo,
 ) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const lhs = try f.resolveInst(data.lhs);
     const rhs = try f.resolveInst(data.rhs);
@@ -6517,14 +5700,14 @@ fn airCmpBuiltinCall(
     const operand_ty = f.typeOf(data.lhs);
     const scalar_ty = operand_ty.scalarType(zcu);
 
-    const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
-    const ref_ret = inst_scalar_ctype.info(&f.object.dg.ctype_pool) == .array;
+    const ref_ret = lowersToBigInt(inst_scalar_ty, zcu);
+    const ref_arg = lowersToBigInt(scalar_ty, zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
     if (!ref_ret) {
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(" = ");
     }
@@ -6532,33 +5715,36 @@ fn airCmpBuiltinCall(
         else => @tagName(operation),
         .operator => compareOperatorAbbrev(operator),
     }});
-    try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+    try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
     try w.writeByte('(');
     if (ref_ret) {
-        try f.writeCValue(w, local, .FunctionArgument);
+        try w.writeByte('&');
+        try f.writeCValue(w, local, .other);
         try v.elem(f, w);
         try w.writeAll(", ");
     }
-    try f.writeCValue(w, lhs, .FunctionArgument);
+    if (ref_arg) try w.writeByte('&');
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeAll(", ");
-    try f.writeCValue(w, rhs, .FunctionArgument);
+    if (ref_arg) try w.writeByte('&');
+    try f.writeCValue(w, rhs, .other);
     try v.elem(f, w);
-    try f.object.dg.renderBuiltinInfo(w, scalar_ty, info);
+    try f.dg.renderBuiltinInfo(w, scalar_ty, info);
     try w.writeByte(')');
     if (!ref_ret) try w.print("{s}{f}", .{
         compareOperatorC(operator),
         try f.fmtIntLiteralDec(try pt.intValue(.i32, 0)),
     });
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
 }
 
 fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = f.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
@@ -6568,9 +5754,8 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
     const new_value = try f.resolveInst(extra.new_value);
     const ptr_ty = f.typeOf(extra.ptr);
     const ty = ptr_ty.childType(zcu);
-    const ctype = try f.ctypeFromType(ty, .complete);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const new_value_mat = try Materialize.start(f, inst, ty, new_value);
     try reap(f, inst, &.{ extra.ptr, extra.expected_value, extra.new_value });
 
@@ -6581,13 +5766,11 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
 
     const local = try f.allocLocal(inst, inst_ty);
     if (inst_ty.isPtrLikeOptional(zcu)) {
-        {
-            const a = try Assignment.start(f, w, ctype);
-            try f.writeCValue(w, local, .Other);
-            try a.assign(f, w);
-            try f.writeCValue(w, expected_value, .Other);
-            try a.end(f, w);
-        }
+        try f.writeCValue(w, local, .other);
+        try w.writeAll(" = ");
+        try f.writeCValue(w, expected_value, .other);
+        try w.writeByte(';');
+        try f.newline();
 
         try w.writeAll("if (");
         try w.print("zig_cmpxchg_{s}((zig_atomic(", .{flavor});
@@ -6595,9 +5778,9 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
         try w.writeByte(')');
         if (ptr_ty.isVolatilePtr(zcu)) try w.writeAll(" volatile");
         try w.writeAll(" *)");
-        try f.writeCValue(w, ptr, .Other);
+        try f.writeCValue(w, ptr, .other);
         try w.writeAll(", ");
-        try f.writeCValue(w, local, .FunctionArgument);
+        try f.writeCValue(w, local, .other);
         try w.writeAll(", ");
         try new_value_mat.mat(f, w);
         try w.writeAll(", ");
@@ -6605,56 +5788,49 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
         try w.writeAll(", ");
         try writeMemoryOrder(w, extra.failureOrder());
         try w.writeAll(", ");
-        try f.object.dg.renderTypeForBuiltinFnName(w, ty);
+        try f.dg.renderTypeForBuiltinFnName(w, ty);
         try w.writeAll(", ");
         try f.renderType(w, repr_ty);
         try w.writeByte(')');
         try w.writeAll(") {");
-        f.object.indent();
-        try f.object.newline();
-        {
-            const a = try Assignment.start(f, w, ctype);
-            try f.writeCValue(w, local, .Other);
-            try a.assign(f, w);
-            try w.writeAll("NULL");
-            try a.end(f, w);
-        }
-        try f.object.outdent();
+        f.indent();
+        try f.newline();
+
+        try f.writeCValue(w, local, .other);
+        try w.writeAll(" = NULL;");
+        try f.newline();
+
+        try f.outdent();
         try w.writeByte('}');
-        try f.object.newline();
+        try f.newline();
     } else {
-        {
-            const a = try Assignment.start(f, w, ctype);
-            try f.writeCValueMember(w, local, .{ .identifier = "payload" });
-            try a.assign(f, w);
-            try f.writeCValue(w, expected_value, .Other);
-            try a.end(f, w);
-        }
-        {
-            const a = try Assignment.start(f, w, .bool);
-            try f.writeCValueMember(w, local, .{ .identifier = "is_null" });
-            try a.assign(f, w);
-            try w.print("zig_cmpxchg_{s}((zig_atomic(", .{flavor});
-            try f.renderType(w, ty);
-            try w.writeByte(')');
-            if (ptr_ty.isVolatilePtr(zcu)) try w.writeAll(" volatile");
-            try w.writeAll(" *)");
-            try f.writeCValue(w, ptr, .Other);
-            try w.writeAll(", ");
-            try f.writeCValueMember(w, local, .{ .identifier = "payload" });
-            try w.writeAll(", ");
-            try new_value_mat.mat(f, w);
-            try w.writeAll(", ");
-            try writeMemoryOrder(w, extra.successOrder());
-            try w.writeAll(", ");
-            try writeMemoryOrder(w, extra.failureOrder());
-            try w.writeAll(", ");
-            try f.object.dg.renderTypeForBuiltinFnName(w, ty);
-            try w.writeAll(", ");
-            try f.renderType(w, repr_ty);
-            try w.writeByte(')');
-            try a.end(f, w);
-        }
+        try f.writeCValueMember(w, local, .{ .identifier = "payload" });
+        try w.writeAll(" = ");
+        try f.writeCValue(w, expected_value, .other);
+        try w.writeByte(';');
+        try f.newline();
+
+        try f.writeCValueMember(w, local, .{ .identifier = "is_null" });
+        try w.print(" = zig_cmpxchg_{s}((zig_atomic(", .{flavor});
+        try f.renderType(w, ty);
+        try w.writeByte(')');
+        if (ptr_ty.isVolatilePtr(zcu)) try w.writeAll(" volatile");
+        try w.writeAll(" *)");
+        try f.writeCValue(w, ptr, .other);
+        try w.writeAll(", ");
+        try f.writeCValueMember(w, local, .{ .identifier = "payload" });
+        try w.writeAll(", ");
+        try new_value_mat.mat(f, w);
+        try w.writeAll(", ");
+        try writeMemoryOrder(w, extra.successOrder());
+        try w.writeAll(", ");
+        try writeMemoryOrder(w, extra.failureOrder());
+        try w.writeAll(", ");
+        try f.dg.renderTypeForBuiltinFnName(w, ty);
+        try w.writeAll(", ");
+        try f.renderType(w, repr_ty);
+        try w.writeAll(");");
+        try f.newline();
     }
     try new_value_mat.end(f, inst);
 
@@ -6667,7 +5843,7 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
 }
 
 fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const extra = f.air.extraData(Air.AtomicRmw, pl_op.payload).data;
@@ -6677,7 +5853,7 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
     const ptr = try f.resolveInst(pl_op.operand);
     const operand = try f.resolveInst(extra.operand);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const operand_mat = try Materialize.start(f, inst, ty, operand);
     try reap(f, inst, &.{ pl_op.operand, extra.operand });
 
@@ -6690,7 +5866,7 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
     try w.print("zig_atomicrmw_{s}", .{toAtomicRmwSuffix(extra.op())});
     if (is_float) try w.writeAll("_float") else if (is_128) try w.writeAll("_int128");
     try w.writeByte('(');
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(", (");
     const use_atomic = switch (extra.op()) {
         else => true,
@@ -6702,17 +5878,17 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
     if (use_atomic) try w.writeByte(')');
     if (ptr_ty.isVolatilePtr(zcu)) try w.writeAll(" volatile");
     try w.writeAll(" *)");
-    try f.writeCValue(w, ptr, .Other);
+    try f.writeCValue(w, ptr, .other);
     try w.writeAll(", ");
     try operand_mat.mat(f, w);
     try w.writeAll(", ");
     try writeMemoryOrder(w, extra.ordering());
     try w.writeAll(", ");
-    try f.object.dg.renderTypeForBuiltinFnName(w, ty);
+    try f.dg.renderTypeForBuiltinFnName(w, ty);
     try w.writeAll(", ");
     try f.renderType(w, repr_ty);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     try operand_mat.end(f, inst);
 
     if (f.liveness.isUnused(inst)) {
@@ -6724,7 +5900,7 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airAtomicLoad(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const atomic_load = f.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
     const ptr = try f.resolveInst(atomic_load.ptr);
@@ -6738,31 +5914,31 @@ fn airAtomicLoad(f: *Function, inst: Air.Inst.Index) !CValue {
         ty;
 
     const inst_ty = f.typeOfIndex(inst);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
 
     try w.writeAll("zig_atomic_load(");
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(", (zig_atomic(");
     try f.renderType(w, ty);
     try w.writeByte(')');
     if (ptr_ty.isVolatilePtr(zcu)) try w.writeAll(" volatile");
     try w.writeAll(" *)");
-    try f.writeCValue(w, ptr, .Other);
+    try f.writeCValue(w, ptr, .other);
     try w.writeAll(", ");
     try writeMemoryOrder(w, atomic_load.order);
     try w.writeAll(", ");
-    try f.object.dg.renderTypeForBuiltinFnName(w, ty);
+    try f.dg.renderTypeForBuiltinFnName(w, ty);
     try w.writeAll(", ");
     try f.renderType(w, repr_ty);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
 
     return local;
 }
 
 fn airAtomicStore(f: *Function, inst: Air.Inst.Index, order: [*:0]const u8) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ptr_ty = f.typeOf(bin_op.lhs);
@@ -6770,7 +5946,7 @@ fn airAtomicStore(f: *Function, inst: Air.Inst.Index, order: [*:0]const u8) !CVa
     const ptr = try f.resolveInst(bin_op.lhs);
     const element = try f.resolveInst(bin_op.rhs);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const element_mat = try Materialize.start(f, inst, ty, element);
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
@@ -6784,32 +5960,22 @@ fn airAtomicStore(f: *Function, inst: Air.Inst.Index, order: [*:0]const u8) !CVa
     try w.writeByte(')');
     if (ptr_ty.isVolatilePtr(zcu)) try w.writeAll(" volatile");
     try w.writeAll(" *)");
-    try f.writeCValue(w, ptr, .Other);
+    try f.writeCValue(w, ptr, .other);
     try w.writeAll(", ");
     try element_mat.mat(f, w);
     try w.print(", {s}, ", .{order});
-    try f.object.dg.renderTypeForBuiltinFnName(w, ty);
+    try f.dg.renderTypeForBuiltinFnName(w, ty);
     try w.writeAll(", ");
     try f.renderType(w, repr_ty);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     try element_mat.end(f, inst);
 
     return .none;
 }
 
-fn writeSliceOrPtr(f: *Function, w: *Writer, ptr: CValue, ptr_ty: Type) !void {
-    const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
-    if (ptr_ty.isSlice(zcu)) {
-        try f.writeCValueMember(w, ptr, .{ .identifier = "ptr" });
-    } else {
-        try f.writeCValue(w, ptr, .FunctionArgument);
-    }
-}
-
 fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const dest_ty = f.typeOf(bin_op.lhs);
@@ -6818,7 +5984,7 @@ fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
     const elem_ty = f.typeOf(bin_op.rhs);
     const elem_abi_size = elem_ty.abiSize(zcu);
     const val_is_undef = if (try f.air.value(bin_op.rhs, pt)) |val| val.isUndef(zcu) else false;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     if (val_is_undef) {
         if (!safety) {
@@ -6832,153 +5998,128 @@ fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
                 try f.writeCValueMember(w, dest_slice, .{ .identifier = "ptr" });
                 try w.writeAll(", 0xaa, ");
                 try f.writeCValueMember(w, dest_slice, .{ .identifier = "len" });
-                if (elem_abi_size > 1) {
-                    try w.print(" * {d}", .{elem_abi_size});
-                }
-                try w.writeAll(");");
-                try f.object.newline();
             },
             .one => {
-                const array_ty = dest_ty.childType(zcu);
-                const len = array_ty.arrayLen(zcu) * elem_abi_size;
-
-                try f.writeCValue(w, dest_slice, .FunctionArgument);
-                try w.print(", 0xaa, {d});", .{len});
-                try f.object.newline();
+                try f.writeCValue(w, dest_slice, .other);
+                try w.print(", 0xaa, {d}", .{dest_ty.childType(zcu).arrayLen(zcu)});
             },
             .many, .c => unreachable,
         }
+        if (elem_abi_size > 0) try w.print(" * {d}", .{elem_abi_size});
+        try w.writeAll(");");
+        try f.newline();
         try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
         return .none;
     }
 
-    if (elem_abi_size > 1 or dest_ty.isVolatilePtr(zcu)) {
-        // For the assignment in this loop, the array pointer needs to get
-        // casted to a regular pointer, otherwise an error like this occurs:
-        // error: array type 'uint32_t[20]' (aka 'unsigned int[20]') is not assignable
-        const elem_ptr_ty = try pt.ptrType(.{
-            .child = elem_ty.toIntern(),
-            .flags = .{
-                .size = .c,
-            },
-        });
-
-        const index = try f.allocLocal(inst, .usize);
-
-        try w.writeAll("for (");
-        try f.writeCValue(w, index, .Other);
-        try w.writeAll(" = ");
-        try f.object.dg.renderValue(w, .zero_usize, .Other);
-        try w.writeAll("; ");
-        try f.writeCValue(w, index, .Other);
-        try w.writeAll(" != ");
+    if (elem_abi_size == 1 and !dest_ty.isVolatilePtr(zcu)) {
+        const bitcasted = try bitcast(f, .u8, value, elem_ty);
+        try w.writeAll("memset(");
         switch (dest_ty.ptrSize(zcu)) {
             .slice => {
+                try f.writeCValueMember(w, dest_slice, .{ .identifier = "ptr" });
+                try w.writeAll(", ");
+                try f.writeCValue(w, bitcasted, .other);
+                try w.writeAll(", ");
                 try f.writeCValueMember(w, dest_slice, .{ .identifier = "len" });
             },
             .one => {
-                const array_ty = dest_ty.childType(zcu);
-                try w.print("{d}", .{array_ty.arrayLen(zcu)});
+                try f.writeCValue(w, dest_slice, .other);
+                try w.writeAll(", ");
+                try f.writeCValue(w, bitcasted, .other);
+                try w.print(", {d}", .{dest_ty.childType(zcu).arrayLen(zcu)});
             },
             .many, .c => unreachable,
         }
-        try w.writeAll("; ++");
-        try f.writeCValue(w, index, .Other);
-        try w.writeAll(") ");
-
-        const a = try Assignment.start(f, w, try f.ctypeFromType(elem_ty, .complete));
-        try w.writeAll("((");
-        try f.renderType(w, elem_ptr_ty);
-        try w.writeByte(')');
-        try writeSliceOrPtr(f, w, dest_slice, dest_ty);
-        try w.writeAll(")[");
-        try f.writeCValue(w, index, .Other);
-        try w.writeByte(']');
-        try a.assign(f, w);
-        try f.writeCValue(w, value, .Other);
-        try a.end(f, w);
-
+        try w.writeAll(");");
+        try f.newline();
+        try f.freeCValue(inst, bitcasted);
         try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
-        try freeLocal(f, inst, index.new_local, null);
-
         return .none;
     }
 
-    const bitcasted = try bitcast(f, .u8, value, elem_ty);
+    // Fallback path: use a `for` loop.
 
-    try w.writeAll("memset(");
+    const index = try f.allocLocal(inst, .usize);
+
+    try w.writeAll("for (");
+    try f.writeCValue(w, index, .other);
+    try w.writeAll(" = ");
+    try f.dg.renderValue(w, .zero_usize, .other);
+    try w.writeAll("; ");
+    try f.writeCValue(w, index, .other);
+    try w.writeAll(" != ");
     switch (dest_ty.ptrSize(zcu)) {
-        .slice => {
-            try f.writeCValueMember(w, dest_slice, .{ .identifier = "ptr" });
-            try w.writeAll(", ");
-            try f.writeCValue(w, bitcasted, .FunctionArgument);
-            try w.writeAll(", ");
-            try f.writeCValueMember(w, dest_slice, .{ .identifier = "len" });
-            try w.writeAll(");");
-            try f.object.newline();
-        },
-        .one => {
-            const array_ty = dest_ty.childType(zcu);
-            const len = array_ty.arrayLen(zcu) * elem_abi_size;
+        .slice => try f.writeCValueMember(w, dest_slice, .{ .identifier = "len" }),
+        .one => try w.print("{d}", .{dest_ty.childType(zcu).arrayLen(zcu)}),
+        .many, .c => unreachable,
+    }
+    try w.writeAll("; ++");
+    try f.writeCValue(w, index, .other);
+    try w.writeAll(") ");
 
-            try f.writeCValue(w, dest_slice, .FunctionArgument);
-            try w.writeAll(", ");
-            try f.writeCValue(w, bitcasted, .FunctionArgument);
-            try w.print(", {d});", .{len});
-            try f.object.newline();
-        },
+    switch (dest_ty.ptrSize(zcu)) {
+        .slice => try f.writeCValueMember(w, dest_slice, .{ .identifier = "ptr" }),
+        .one => try f.writeCValueDerefMember(w, dest_slice, .{ .identifier = "array" }),
         .many, .c => unreachable,
     }
-    try f.freeCValue(inst, bitcasted);
+    try w.writeByte('[');
+    try f.writeCValue(w, index, .other);
+    try w.writeAll("] = ");
+    try f.writeCValue(w, value, .other);
+    try w.writeByte(';');
+    try f.newline();
+
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
+    try freeLocal(f, inst, index.new_local, null);
+
     return .none;
 }
 
 fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const dest_ptr = try f.resolveInst(bin_op.lhs);
     const src_ptr = try f.resolveInst(bin_op.rhs);
     const dest_ty = f.typeOf(bin_op.lhs);
     const src_ty = f.typeOf(bin_op.rhs);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     if (dest_ty.ptrSize(zcu) != .one) {
         try w.writeAll("if (");
-        try writeArrayLen(f, dest_ptr, dest_ty);
+        try f.writeCValueMember(w, dest_ptr, .{ .identifier = "len" });
         try w.writeAll(" != 0) ");
     }
     try w.writeAll(function_paren);
-    try writeSliceOrPtr(f, w, dest_ptr, dest_ty);
+    switch (dest_ty.ptrSize(zcu)) {
+        .slice => try f.writeCValueMember(w, dest_ptr, .{ .identifier = "ptr" }),
+        .one => try f.writeCValueDerefMember(w, dest_ptr, .{ .identifier = "array" }),
+        .many, .c => unreachable,
+    }
     try w.writeAll(", ");
-    try writeSliceOrPtr(f, w, src_ptr, src_ty);
+    switch (src_ty.ptrSize(zcu)) {
+        .slice => try f.writeCValueMember(w, src_ptr, .{ .identifier = "ptr" }),
+        .one => try f.writeCValueDerefMember(w, src_ptr, .{ .identifier = "array" }),
+        .many, .c => try f.writeCValue(w, src_ptr, .other),
+    }
     try w.writeAll(", ");
-    try writeArrayLen(f, dest_ptr, dest_ty);
+    switch (dest_ty.ptrSize(zcu)) {
+        .slice => try f.writeCValueMember(w, dest_ptr, .{ .identifier = "len" }),
+        .one => try w.print("{d}", .{dest_ty.childType(zcu).arrayLen(zcu)}),
+        .many, .c => unreachable,
+    }
     try w.writeAll(" * sizeof(");
     try f.renderType(w, dest_ty.indexableElem(zcu));
     try w.writeAll("));");
-    try f.object.newline();
+    try f.newline();
 
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
     return .none;
 }
 
-fn writeArrayLen(f: *Function, dest_ptr: CValue, dest_ty: Type) !void {
-    const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
-    const w = &f.object.code.writer;
-    switch (dest_ty.ptrSize(zcu)) {
-        .one => try w.print("{f}", .{
-            try f.fmtIntLiteralDec(try pt.intValue(.usize, dest_ty.childType(zcu).arrayLen(zcu))),
-        }),
-        .many, .c => unreachable,
-        .slice => try f.writeCValueMember(w, dest_ptr, .{ .identifier = "len" }),
-    }
-}
-
 fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const union_ptr = try f.resolveInst(bin_op.lhs);
@@ -6988,19 +6129,18 @@ fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
     const union_ty = f.typeOf(bin_op.lhs).childType(zcu);
     const layout = union_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) return .none;
-    const tag_ty = union_ty.unionTagTypeRuntime(zcu).?;
 
-    const w = &f.object.code.writer;
-    const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
+    const w = &f.code.writer;
     try f.writeCValueDerefMember(w, union_ptr, .{ .identifier = "tag" });
-    try a.assign(f, w);
-    try f.writeCValue(w, new_tag, .Other);
-    try a.end(f, w);
+    try w.writeAll(" = ");
+    try f.writeCValue(w, new_tag, .other);
+    try w.writeByte(';');
+    try f.newline();
     return .none;
 }
 
 fn airGetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
@@ -7012,17 +6152,20 @@ fn airGetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
     if (layout.tag_size == 0) return .none;
 
     const inst_ty = f.typeOfIndex(inst);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
-    try f.writeCValue(w, local, .Other);
-    try a.assign(f, w);
+    try f.writeCValue(w, local, .other);
+    try w.writeAll(" = ");
     try f.writeCValueMember(w, operand, .{ .identifier = "tag" });
-    try a.end(f, w);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue {
+    const zcu = f.dg.pt.zcu;
+    const ip = &zcu.intern_pool;
+    const gpa = zcu.comp.gpa;
     const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
 
     const inst_ty = f.typeOfIndex(inst);
@@ -7030,15 +6173,17 @@ fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue {
     const operand = try f.resolveInst(un_op);
     try reap(f, inst, &.{un_op});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    try f.writeCValue(w, local, .Other);
-    try w.print(" = {s}(", .{
-        try f.getLazyFnName(.{ .tag_name = enum_ty.toIntern() }),
+    try f.writeCValue(w, local, .other);
+    try f.need_tag_name_funcs.put(gpa, enum_ty.toIntern(), {});
+    try w.print(" = zig_tagName_{f}__{d}(", .{
+        fmtIdentUnsolo(enum_ty.containerTypeName(ip).toSlice(ip)),
+        @intFromEnum(enum_ty.toIntern()),
     });
-    try f.writeCValue(w, operand, .Other);
+    try f.writeCValue(w, operand, .other);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
 
     return local;
 }
@@ -7046,40 +6191,37 @@ fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue {
 fn airErrorName(f: *Function, inst: Air.Inst.Index) !CValue {
     const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const inst_ty = f.typeOfIndex(inst);
     const operand = try f.resolveInst(un_op);
     try reap(f, inst, &.{un_op});
     const local = try f.allocLocal(inst, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
 
     try w.writeAll(" = zig_errorName[");
-    try f.writeCValue(w, operand, .Other);
+    try f.writeCValue(w, operand, .other);
     try w.writeAll(" - 1];");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airSplat(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
-    const zcu = pt.zcu;
     const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
     const operand = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
 
     const inst_ty = f.typeOfIndex(inst);
-    const inst_scalar_ty = inst_ty.scalarType(zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, inst_ty);
-    const a = try Assignment.start(f, w, try f.ctypeFromType(inst_scalar_ty, .complete));
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
-    try a.assign(f, w);
-    try f.writeCValue(w, operand, .Other);
-    try a.end(f, w);
+    try w.writeAll(" = ");
+    try f.writeCValue(w, operand, .other);
+    try w.writeByte(';');
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -7096,29 +6238,29 @@ fn airSelect(f: *Function, inst: Air.Inst.Index) !CValue {
 
     const inst_ty = f.typeOfIndex(inst);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
     try w.writeAll(" = ");
-    try f.writeCValue(w, pred, .Other);
+    try f.writeCValue(w, pred, .other);
     try v.elem(f, w);
     try w.writeAll(" ? ");
-    try f.writeCValue(w, lhs, .Other);
+    try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeAll(" : ");
-    try f.writeCValue(w, rhs, .Other);
+    try f.writeCValue(w, rhs, .other);
     try v.elem(f, w);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
 }
 
 fn airShuffleOne(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
 
     const unwrapped = f.air.unwrapShuffleOne(zcu, inst);
@@ -7126,22 +6268,22 @@ fn airShuffleOne(f: *Function, inst: Air.Inst.Index) !CValue {
     const operand = try f.resolveInst(unwrapped.operand);
     const inst_ty = unwrapped.result_ty;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     try reap(f, inst, &.{unwrapped.operand}); // local cannot alias operand
     for (mask, 0..) |mask_elem, out_idx| {
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValueMember(w, local, .{ .identifier = "array" });
         try w.writeByte('[');
-        try f.object.dg.renderValue(w, try pt.intValue(.usize, out_idx), .Other);
+        try f.dg.renderValue(w, try pt.intValue(.usize, out_idx), .other);
         try w.writeAll("] = ");
         switch (mask_elem.unwrap()) {
             .elem => |src_idx| {
-                try f.writeCValue(w, operand, .Other);
+                try f.writeCValueMember(w, operand, .{ .identifier = "array" });
                 try w.writeByte('[');
-                try f.object.dg.renderValue(w, try pt.intValue(.usize, src_idx), .Other);
+                try f.dg.renderValue(w, try pt.intValue(.usize, src_idx), .other);
                 try w.writeByte(']');
             },
-            .value => |val| try f.object.dg.renderValue(w, .fromInterned(val), .Other),
+            .value => |val| try f.dg.renderValue(w, .fromInterned(val), .other),
         }
         try w.writeAll(";\n");
     }
@@ -7150,7 +6292,7 @@ fn airShuffleOne(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airShuffleTwo(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
 
     const unwrapped = f.air.unwrapShuffleTwo(zcu, inst);
@@ -7160,38 +6302,38 @@ fn airShuffleTwo(f: *Function, inst: Air.Inst.Index) !CValue {
     const inst_ty = unwrapped.result_ty;
     const elem_ty = inst_ty.childType(zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     try reap(f, inst, &.{ unwrapped.operand_a, unwrapped.operand_b }); // local cannot alias operands
     for (mask, 0..) |mask_elem, out_idx| {
-        try f.writeCValue(w, local, .Other);
+        try f.writeCValueMember(w, local, .{ .identifier = "array" });
         try w.writeByte('[');
-        try f.object.dg.renderValue(w, try pt.intValue(.usize, out_idx), .Other);
+        try f.dg.renderValue(w, try pt.intValue(.usize, out_idx), .other);
         try w.writeAll("] = ");
         switch (mask_elem.unwrap()) {
             .a_elem => |src_idx| {
-                try f.writeCValue(w, operand_a, .Other);
+                try f.writeCValueMember(w, operand_a, .{ .identifier = "array" });
                 try w.writeByte('[');
-                try f.object.dg.renderValue(w, try pt.intValue(.usize, src_idx), .Other);
+                try f.dg.renderValue(w, try pt.intValue(.usize, src_idx), .other);
                 try w.writeByte(']');
             },
             .b_elem => |src_idx| {
-                try f.writeCValue(w, operand_b, .Other);
+                try f.writeCValueMember(w, operand_b, .{ .identifier = "array" });
                 try w.writeByte('[');
-                try f.object.dg.renderValue(w, try pt.intValue(.usize, src_idx), .Other);
+                try f.dg.renderValue(w, try pt.intValue(.usize, src_idx), .other);
                 try w.writeByte(']');
             },
-            .undef => try f.object.dg.renderUndefValue(w, elem_ty, .Other),
+            .undef => try f.dg.renderUndefValue(w, elem_ty, .other),
         }
         try w.writeByte(';');
-        try f.object.newline();
+        try f.newline();
     }
 
     return local;
 }
 
 fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const reduce = f.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
 
@@ -7199,7 +6341,7 @@ fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
     const operand = try f.resolveInst(reduce.operand);
     try reap(f, inst, &.{reduce.operand});
     const operand_ty = f.typeOf(reduce.operand);
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
 
     const use_operator = scalar_ty.bitSize(zcu) <= 64;
     const op: union(enum) {
@@ -7246,10 +6388,10 @@ fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
     //   }
 
     const accum = try f.allocLocal(inst, scalar_ty);
-    try f.writeCValue(w, accum, .Other);
+    try f.writeCValue(w, accum, .other);
     try w.writeAll(" = ");
 
-    try f.object.dg.renderValue(w, switch (reduce.operation) {
+    try f.dg.renderValue(w, switch (reduce.operation) {
         .Or, .Xor => switch (scalar_ty.zigTypeTag(zcu)) {
             .bool => Value.false,
             .int => try pt.intValue(scalar_ty, 0),
@@ -7285,58 +6427,58 @@ fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
             .float => try pt.floatValue(scalar_ty, std.math.nan(f128)),
             else => unreachable,
         },
-    }, .Other);
+    }, .other);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
 
     const v = try Vectorize.start(f, inst, w, operand_ty);
-    try f.writeCValue(w, accum, .Other);
+    try f.writeCValue(w, accum, .other);
     switch (op) {
         .builtin => |func| {
             try w.print(" = zig_{s}_", .{func.operation});
-            try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
+            try f.dg.renderTypeForBuiltinFnName(w, scalar_ty);
             try w.writeByte('(');
-            try f.writeCValue(w, accum, .FunctionArgument);
+            try f.writeCValue(w, accum, .other);
             try w.writeAll(", ");
-            try f.writeCValue(w, operand, .Other);
+            try f.writeCValue(w, operand, .other);
             try v.elem(f, w);
-            try f.object.dg.renderBuiltinInfo(w, scalar_ty, func.info);
+            try f.dg.renderBuiltinInfo(w, scalar_ty, func.info);
             try w.writeByte(')');
         },
         .infix => |ass| {
             try w.writeAll(ass);
-            try f.writeCValue(w, operand, .Other);
+            try f.writeCValue(w, operand, .other);
             try v.elem(f, w);
         },
         .ternary => |cmp| {
             try w.writeAll(" = ");
-            try f.writeCValue(w, accum, .Other);
+            try f.writeCValue(w, accum, .other);
             try w.writeAll(cmp);
-            try f.writeCValue(w, operand, .Other);
+            try f.writeCValue(w, operand, .other);
             try v.elem(f, w);
             try w.writeAll(" ? ");
-            try f.writeCValue(w, accum, .Other);
+            try f.writeCValue(w, accum, .other);
             try w.writeAll(" : ");
-            try f.writeCValue(w, operand, .Other);
+            try f.writeCValue(w, operand, .other);
             try v.elem(f, w);
         },
     }
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return accum;
 }
 
 fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const inst_ty = f.typeOfIndex(inst);
     const len: usize = @intCast(inst_ty.arrayLen(zcu));
     const elements: []const Air.Inst.Ref = @ptrCast(f.air.extra.items[ty_pl.payload..][0..len]);
-    const gpa = f.object.dg.gpa;
+    const gpa = f.dg.gpa;
     const resolved_elements = try gpa.alloc(CValue, elements.len);
     defer gpa.free(resolved_elements);
     for (resolved_elements, elements) |*resolved_element, element| {
@@ -7349,28 +6491,23 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
         }
     }
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     switch (ip.indexToKey(inst_ty.toIntern())) {
         inline .array_type, .vector_type => |info, tag| {
-            const a: Assignment = .{
-                .ctype = try f.ctypeFromType(.fromInterned(info.child), .complete),
-            };
             for (resolved_elements, 0..) |element, i| {
-                try a.restart(f, w);
-                try f.writeCValue(w, local, .Other);
-                try w.print("[{d}]", .{i});
-                try a.assign(f, w);
-                try f.writeCValue(w, element, .Other);
-                try a.end(f, w);
+                try f.writeCValueMember(w, local, .{ .identifier = "array" });
+                try w.print("[{d}] = ", .{i});
+                try f.writeCValue(w, element, .other);
+                try w.writeByte(';');
+                try f.newline();
             }
             if (tag == .array_type and info.sentinel != .none) {
-                try a.restart(f, w);
-                try f.writeCValue(w, local, .Other);
-                try w.print("[{d}]", .{info.len});
-                try a.assign(f, w);
-                try f.object.dg.renderValue(w, Value.fromInterned(info.sentinel), .Other);
-                try a.end(f, w);
+                try f.writeCValueMember(w, local, .{ .identifier = "array" });
+                try w.print("[{d}] = ", .{info.len});
+                try f.dg.renderValue(w, Value.fromInterned(info.sentinel), .other);
+                try w.writeByte(';');
+                try f.newline();
             }
         },
         .struct_type => {
@@ -7382,11 +6519,11 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
                         const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                         if (!field_ty.hasRuntimeBits(zcu)) continue;
 
-                        const a = try Assignment.start(f, w, try f.ctypeFromType(field_ty, .complete));
                         try f.writeCValueMember(w, local, .{ .identifier = loaded_struct.field_names.get(ip)[field_index].toSlice(ip) });
-                        try a.assign(f, w);
-                        try f.writeCValue(w, resolved_elements[field_index], .Other);
-                        try a.end(f, w);
+                        try w.writeAll(" = ");
+                        try f.writeCValue(w, resolved_elements[field_index], .other);
+                        try w.writeByte(';');
+                        try f.newline();
                     }
                 },
                 .@"packed" => unreachable, // `Air.Legalize.Feature.expand_packed_struct_init` handles this case
@@ -7397,11 +6534,11 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
             const field_ty: Type = .fromInterned(tuple_info.types.get(ip)[field_index]);
             if (!field_ty.hasRuntimeBits(zcu)) continue;
 
-            const a = try Assignment.start(f, w, try f.ctypeFromType(field_ty, .complete));
             try f.writeCValueMember(w, local, .{ .field = field_index });
-            try a.assign(f, w);
-            try f.writeCValue(w, resolved_elements[field_index], .Other);
-            try a.end(f, w);
+            try w.writeAll(" = ");
+            try f.writeCValue(w, resolved_elements[field_index], .other);
+            try w.writeByte(';');
+            try f.newline();
         },
         else => unreachable,
     }
@@ -7410,46 +6547,52 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 
 fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = f.air.extraData(Air.UnionInit, ty_pl.payload).data;
+    const field_index = extra.field_index;
 
     const union_ty = f.typeOfIndex(inst);
     const loaded_union = ip.loadUnionType(union_ty.toIntern());
-    const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[extra.field_index];
-    const payload_ty = f.typeOf(extra.init);
+    const loaded_enum = ip.loadEnumType(loaded_union.enum_tag_type);
+
     const payload = try f.resolveInst(extra.init);
     try reap(f, inst, &.{extra.init});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     if (loaded_union.layout == .@"packed") return f.moveCValue(inst, union_ty, payload);
 
     const local = try f.allocLocal(inst, union_ty);
 
-    const field: CValue = if (union_ty.unionTagTypeRuntime(zcu)) |tag_ty| field: {
-        assert(union_ty.unionGetLayout(zcu).tag_size != 0);
-        const field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
-        const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
-        const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
+    if (loaded_union.has_runtime_tag) {
         try f.writeCValueMember(w, local, .{ .identifier = "tag" });
-        try a.assign(f, w);
-        try w.print("{f}", .{try f.fmtIntLiteralDec(tag_val.intFromEnum(zcu))});
-        try a.end(f, w);
-        break :field .{ .payload_identifier = field_name.toSlice(ip) };
-    } else .{ .identifier = field_name.toSlice(ip) };
+        if (loaded_enum.field_values.len == 0) {
+            // auto-numbered
+            try w.print(" = {d};", .{field_index});
+        } else {
+            const tag_int_val: Value = .fromInterned(loaded_enum.field_values.get(ip)[field_index]);
+            try w.print(" = {f};", .{try f.fmtIntLiteralDec(tag_int_val)});
+        }
+        try f.newline();
+    }
 
-    const a = try Assignment.start(f, w, try f.ctypeFromType(payload_ty, .complete));
-    try f.writeCValueMember(w, local, field);
-    try a.assign(f, w);
-    try f.writeCValue(w, payload, .Other);
-    try a.end(f, w);
+    const field_name_slice = loaded_enum.field_names.get(ip)[field_index].toSlice(ip);
+    switch (loaded_union.layout) {
+        .auto => try f.writeCValueMember(w, local, .{ .payload_identifier = field_name_slice }),
+        .@"extern" => try f.writeCValueMember(w, local, .{ .identifier = field_name_slice }),
+        .@"packed" => unreachable,
+    }
+    try w.writeAll(" = ");
+    try f.writeCValue(w, payload, .other);
+    try w.writeByte(';');
+    try f.newline();
     return local;
 }
 
 fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const prefetch = f.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
 
@@ -7457,16 +6600,16 @@ fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue {
     const ptr = try f.resolveInst(prefetch.ptr);
     try reap(f, inst, &.{prefetch.ptr});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     switch (prefetch.cache) {
         .data => {
             try w.writeAll("zig_prefetch(");
             if (ptr_ty.isSlice(zcu))
                 try f.writeCValueMember(w, ptr, .{ .identifier = "ptr" })
             else
-                try f.writeCValue(w, ptr, .FunctionArgument);
+                try f.writeCValue(w, ptr, .other);
             try w.print(", {d}, {d});", .{ @intFromEnum(prefetch.rw), prefetch.locality });
-            try f.object.newline();
+            try f.newline();
         },
         // The available prefetch intrinsics do not accept a cache argument; only
         // address, rw, and locality.
@@ -7479,14 +6622,14 @@ fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue {
 fn airWasmMemorySize(f: *Function, inst: Air.Inst.Index) !CValue {
     const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const inst_ty = f.typeOfIndex(inst);
     const local = try f.allocLocal(inst, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
 
     try w.writeAll(" = ");
     try w.print("zig_wasm_memory_size({d});", .{pl_op.payload});
-    try f.object.newline();
+    try f.newline();
 
     return local;
 }
@@ -7494,23 +6637,23 @@ fn airWasmMemorySize(f: *Function, inst: Air.Inst.Index) !CValue {
 fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue {
     const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const inst_ty = f.typeOfIndex(inst);
     const operand = try f.resolveInst(pl_op.operand);
     try reap(f, inst, &.{pl_op.operand});
     const local = try f.allocLocal(inst, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
 
     try w.writeAll(" = ");
     try w.print("zig_wasm_memory_grow({d}, ", .{pl_op.payload});
-    try f.writeCValue(w, operand, .FunctionArgument);
+    try f.writeCValue(w, operand, .other);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const bin_op = f.air.extraData(Air.Bin, pl_op.payload).data;
@@ -7523,24 +6666,24 @@ fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {
     const inst_ty = f.typeOfIndex(inst);
     const inst_scalar_ty = inst_ty.scalarType(zcu);
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try v.elem(f, w);
     try w.writeAll(" = zig_fma_");
-    try f.object.dg.renderTypeForBuiltinFnName(w, inst_scalar_ty);
+    try f.dg.renderTypeForBuiltinFnName(w, inst_scalar_ty);
     try w.writeByte('(');
-    try f.writeCValue(w, mulend1, .FunctionArgument);
+    try f.writeCValue(w, mulend1, .other);
     try v.elem(f, w);
     try w.writeAll(", ");
-    try f.writeCValue(w, mulend2, .FunctionArgument);
+    try f.writeCValue(w, mulend2, .other);
     try v.elem(f, w);
     try w.writeAll(", ");
-    try f.writeCValue(w, addend, .FunctionArgument);
+    try f.writeCValue(w, addend, .other);
     try v.elem(f, w);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     try v.end(f, inst, w);
 
     return local;
@@ -7548,34 +6691,33 @@ fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {
 
 fn airRuntimeNavPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const ty_nav = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, .fromInterned(ty_nav.ty));
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = ");
-    try f.object.dg.renderNav(w, ty_nav.nav, .Other);
+    try f.dg.renderNav(w, ty_nav.nav, .other);
     try w.writeByte(';');
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
 fn airCVaStart(f: *Function, inst: Air.Inst.Index) !CValue {
-    const pt = f.object.dg.pt;
+    const pt = f.dg.pt;
     const zcu = pt.zcu;
     const inst_ty = f.typeOfIndex(inst);
-    const function_ty = zcu.navValue(f.object.dg.pass.nav).typeOf(zcu);
-    const function_info = (try f.ctypeFromType(function_ty, .complete)).info(&f.object.dg.ctype_pool).function;
-    assert(function_info.varargs);
 
-    const w = &f.object.code.writer;
+    assert(Value.fromInterned(f.func_index).typeOf(zcu).fnIsVarArgs(zcu));
+
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     try w.writeAll("va_start(*(va_list *)&");
-    try f.writeCValue(w, local, .Other);
-    if (function_info.param_ctypes.len > 0) {
+    try f.writeCValue(w, local, .other);
+    if (f.next_arg_index > 0) {
         try w.writeAll(", ");
-        try f.writeCValue(w, .{ .arg = function_info.param_ctypes.len - 1 }, .FunctionArgument);
+        try f.writeCValue(w, .{ .arg = f.next_arg_index - 1 }, .other);
     }
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
@@ -7586,15 +6728,15 @@ fn airCVaArg(f: *Function, inst: Air.Inst.Index) !CValue {
     const va_list = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(" = va_arg(*(va_list *)");
-    try f.writeCValue(w, va_list, .Other);
+    try f.writeCValue(w, va_list, .other);
     try w.writeAll(", ");
     try f.renderType(w, ty_op.ty.toType());
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
@@ -7604,11 +6746,11 @@ fn airCVaEnd(f: *Function, inst: Air.Inst.Index) !CValue {
     const va_list = try f.resolveInst(un_op);
     try reap(f, inst, &.{un_op});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     try w.writeAll("va_end(*(va_list *)");
-    try f.writeCValue(w, va_list, .Other);
+    try f.writeCValue(w, va_list, .other);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     return .none;
 }
 
@@ -7619,14 +6761,14 @@ fn airCVaCopy(f: *Function, inst: Air.Inst.Index) !CValue {
     const va_list = try f.resolveInst(ty_op.operand);
     try reap(f, inst, &.{ty_op.operand});
 
-    const w = &f.object.code.writer;
+    const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     try w.writeAll("va_copy(*(va_list *)&");
-    try f.writeCValue(w, local, .Other);
+    try f.writeCValue(w, local, .other);
     try w.writeAll(", *(va_list *)");
-    try f.writeCValue(w, va_list, .Other);
+    try f.writeCValue(w, va_list, .other);
     try w.writeAll(");");
-    try f.object.newline();
+    try f.newline();
     return local;
 }
 
@@ -7943,103 +7085,193 @@ fn undefPattern(comptime IntType: type) IntType {
 
 const FormatIntLiteralContext = struct {
     dg: *DeclGen,
-    int_info: InternPool.Key.IntType,
-    kind: CType.Kind,
-    ctype: CType,
+    loc: ValueRenderLocation,
     val: Value,
+    cty: CType,
     base: u8,
     case: std.fmt.Case,
 };
 fn formatIntLiteral(data: FormatIntLiteralContext, w: *Writer) Writer.Error!void {
-    const pt = data.dg.pt;
-    const zcu = pt.zcu;
-    const target = &data.dg.mod.resolved_target.result;
-    const ctype_pool = &data.dg.ctype_pool;
-
-    const ExpectedContents = struct {
-        const base = 10;
-        const bits = 128;
-        const limbs_count = BigInt.calcTwosCompLimbCount(bits);
-
-        undef_limbs: [limbs_count]BigIntLimb,
-        wrap_limbs: [limbs_count]BigIntLimb,
-        to_string_buf: [bits]u8,
-        to_string_limbs: [BigInt.calcToStringLimbsBufferLen(limbs_count, base)]BigIntLimb,
-    };
-    var stack align(@alignOf(ExpectedContents)) =
-        std.heap.stackFallback(@sizeOf(ExpectedContents), data.dg.gpa);
-    const allocator = stack.get();
-
-    var undef_limbs: []BigIntLimb = &.{};
-    defer allocator.free(undef_limbs);
-
-    var int_buf: Value.BigIntSpace = undefined;
-    const int = if (data.val.isUndef(zcu)) blk: {
-        undef_limbs = allocator.alloc(BigIntLimb, BigInt.calcTwosCompLimbCount(data.int_info.bits)) catch return error.WriteFailed;
-        @memset(undef_limbs, undefPattern(BigIntLimb));
-
-        var undef_int = BigInt.Mutable{
-            .limbs = undef_limbs,
-            .len = undef_limbs.len,
-            .positive = true,
-        };
-        undef_int.truncate(undef_int.toConst(), data.int_info.signedness, data.int_info.bits);
-        break :blk undef_int.toConst();
-    } else data.val.toBigInt(&int_buf, zcu);
-    assert(int.fitsInTwosComp(data.int_info.signedness, data.int_info.bits));
-
-    const c_bits: usize = @intCast(data.ctype.byteSize(ctype_pool, data.dg.mod) * 8);
-    var one_limbs: [BigInt.calcLimbLen(1)]BigIntLimb = undefined;
-    const one = BigInt.Mutable.init(&one_limbs, 1).toConst();
-
-    var wrap = BigInt.Mutable{
-        .limbs = allocator.alloc(BigIntLimb, BigInt.calcTwosCompLimbCount(c_bits)) catch return error.WriteFailed,
-        .len = undefined,
-        .positive = undefined,
-    };
-    defer allocator.free(wrap.limbs);
-
-    const c_limb_info: struct {
-        ctype: CType,
-        count: usize,
-        endian: std.builtin.Endian,
-        homogeneous: bool,
-    } = switch (data.ctype.info(ctype_pool)) {
-        .basic => |basic_info| switch (basic_info) {
-            else => .{
-                .ctype = .void,
-                .count = 1,
-                .endian = .little,
-                .homogeneous = true,
+    const dg = data.dg;
+    const zcu = dg.pt.zcu;
+    const target = &dg.mod.resolved_target.result;
+
+    const val = data.val;
+    const ty = val.typeOf(zcu);
+
+    assert(!val.isUndef(zcu));
+
+    var space: Value.BigIntSpace = undefined;
+    const val_bigint = val.toBigInt(&space, zcu);
+
+    switch (CType.classifyInt(ty, zcu)) {
+        .void => unreachable, // opv
+        .small => |int_cty| return FormatInt128.format(.{
+            .target = zcu.getTarget(),
+            .int_cty = int_cty,
+            .val = val_bigint,
+            .is_global = data.loc == .static_initializer,
+            .base = data.base,
+            .case = data.case,
+        }, w),
+        .big => |big| {
+            if (!data.loc.isInitializer()) {
+                // Use `CType.fmtTypeName` directly to avoid the possibility of `error.OutOfMemory`.
+                try w.print("({f})", .{data.cty.fmtTypeName(zcu)});
+            }
+
+            try w.writeAll("{{");
+
+            var limb_buf: [std.math.big.int.calcTwosCompLimbCount(65535)]std.math.big.Limb = undefined;
+            for (0..big.limbs_len) |limb_index| {
+                if (limb_index != 0) try w.writeAll(", ");
+                const limb_bit_offset: u64 = switch (target.cpu.arch.endian()) {
+                    .little => limb_index * big.limb_size.bits(),
+                    .big => (big.limbs_len - limb_index - 1) * big.limb_size.bits(),
+                };
+                var limb_bigint: std.math.big.int.Mutable = .{
+                    .limbs = &limb_buf,
+                    .len = undefined,
+                    .positive = undefined,
+                };
+                limb_bigint.shiftRight(val_bigint, limb_bit_offset);
+                limb_bigint.truncate(limb_bigint.toConst(), .unsigned, big.limb_size.bits());
+                try FormatInt128.format(.{
+                    .target = zcu.getTarget(),
+                    .int_cty = big.limb_size.unsigned(),
+                    .val = limb_bigint.toConst(),
+                    .is_global = data.loc == .static_initializer,
+                    .base = data.base,
+                    .case = data.case,
+                }, w);
+            }
+
+            try w.writeAll("}}");
+        },
+    }
+}
+const FormatInt128 = struct {
+    target: *const std.Target,
+    int_cty: CType.Int,
+    val: std.math.big.int.Const,
+    is_global: bool,
+    base: u8,
+    case: std.fmt.Case,
+    pub fn format(data: FormatInt128, w: *Writer) Writer.Error!void {
+        const target = data.target;
+
+        const val = data.val;
+        const is_global = data.is_global;
+        const base = data.base;
+        const case = data.case;
+
+        switch (data.int_cty) {
+            .uint8_t,
+            .uint16_t,
+            .uint32_t,
+            .uint64_t,
+            .@"unsigned short",
+            .@"unsigned int",
+            .@"unsigned long",
+            .@"unsigned long long",
+            .uintptr_t,
+            => |t| try w.print("{f}", .{
+                fmtUnsignedIntLiteralSmall(target, t, val.toInt(u64) catch unreachable, is_global, base, case),
+            }),
+
+            .int8_t,
+            .int16_t,
+            .int32_t,
+            .int64_t,
+            .char,
+            .@"signed short",
+            .@"signed int",
+            .@"signed long",
+            .@"signed long long",
+            .intptr_t,
+            => |t| try w.print("{f}", .{
+                fmtSignedIntLiteralSmall(target, t, val.toInt(i64) catch unreachable, is_global, base, case),
+            }),
+
+            .zig_u128 => {
+                const raw = val.toInt(u128) catch unreachable;
+                const lo: u64 = @truncate(raw);
+                const hi: u64 = @intCast(raw >> 64);
+                const macro_name: []const u8 = if (is_global) "zig_init_u128" else "zig_make_u128";
+                try w.print("{s}({f}, {f})", .{
+                    macro_name,
+                    fmtUnsignedIntLiteralSmall(target, .uint64_t, hi, is_global, base, case),
+                    fmtUnsignedIntLiteralSmall(target, .uint64_t, lo, is_global, base, case),
+                });
             },
-            .zig_u128, .zig_i128 => .{
-                .ctype = .u64,
-                .count = 2,
-                .endian = .big,
-                .homogeneous = false,
+
+            .zig_i128 => {
+                const raw = val.toInt(i128) catch unreachable;
+                const lo: u64 = @truncate(@as(u128, @bitCast(raw)));
+                const hi: i64 = @intCast(raw >> 64);
+                const macro_name: []const u8 = if (is_global) "zig_init_i128" else "zig_make_i128";
+                try w.print("{s}({f}, {f})", .{
+                    macro_name,
+                    fmtSignedIntLiteralSmall(target, .int64_t, hi, is_global, base, case),
+                    fmtUnsignedIntLiteralSmall(target, .uint64_t, lo, is_global, base, case),
+                });
             },
-        },
-        .array => |array_info| .{
-            .ctype = array_info.elem_ctype,
-            .count = @intCast(array_info.len),
-            .endian = target.cpu.arch.endian(),
-            .homogeneous = true,
-        },
-        else => unreachable,
+        }
+    }
+};
+fn fmtUnsignedIntLiteralSmall(
+    target: *const std.Target,
+    int_cty: CType.Int,
+    val: u64,
+    is_global: bool,
+    base: u8,
+    case: std.fmt.Case,
+) FormatUnsignedIntLiteralSmall {
+    return .{
+        .target = target,
+        .int_cty = int_cty,
+        .val = val,
+        .is_global = is_global,
+        .base = base,
+        .case = case,
+    };
+}
+fn fmtSignedIntLiteralSmall(
+    target: *const std.Target,
+    int_cty: CType.Int,
+    val: i64,
+    is_global: bool,
+    base: u8,
+    case: std.fmt.Case,
+) FormatSignedIntLiteralSmall {
+    return .{
+        .target = target,
+        .int_cty = int_cty,
+        .val = val,
+        .is_global = is_global,
+        .base = base,
+        .case = case,
     };
-    if (c_limb_info.count == 1) {
-        if (wrap.addWrap(int, one, data.int_info.signedness, c_bits) or
-            data.int_info.signedness == .signed and wrap.subWrap(int, one, data.int_info.signedness, c_bits))
-            return w.print("{s}_{s}", .{
-                data.ctype.getStandardDefineAbbrev() orelse return w.print("zig_{s}Int_{c}{d}", .{
-                    if (int.positive) "max" else "min", signAbbrev(data.int_info.signedness), c_bits,
-                }),
-                if (int.positive) "MAX" else "MIN",
-            });
-
-        if (!int.positive) try w.writeByte('-');
-        try data.ctype.renderLiteralPrefix(w, data.kind, ctype_pool);
+}
 
+const FormatSignedIntLiteralSmall = struct {
+    target: *const std.Target,
+    int_cty: CType.Int,
+    val: i64,
+    is_global: bool,
+    base: u8,
+    case: std.fmt.Case,
+    pub fn format(data: FormatSignedIntLiteralSmall, w: *Writer) Writer.Error!void {
+        const bits = data.int_cty.bits(data.target);
+        const max_int: i64 = @bitCast((@as(u64, 1) << @intCast(bits - 1)) - 1);
+        const min_int: i64 = @bitCast(@as(u64, 1) << @intCast(bits - 1));
+        if (data.val == max_int) {
+            return w.print("{s}_MAX", .{minMaxMacroPrefix(data.int_cty)});
+        } else if (data.val == min_int) {
+            return w.print("{s}_MIN", .{minMaxMacroPrefix(data.int_cty)});
+        }
+        if (data.val < 0) try w.writeByte('-');
+        try w.writeAll(intLiteralPrefix(data.int_cty, data.is_global));
         switch (data.base) {
             2 => try w.writeAll("0b"),
             8 => try w.writeByte('0'),
@@ -8047,68 +7279,131 @@ fn formatIntLiteral(data: FormatIntLiteralContext, w: *Writer) Writer.Error!void
             16 => try w.writeAll("0x"),
             else => unreachable,
         }
-        const string = int.abs().toStringAlloc(allocator, data.base, data.case) catch
-            return error.WriteFailed;
-        defer allocator.free(string);
-        try w.writeAll(string);
-    } else {
-        try data.ctype.renderLiteralPrefix(w, data.kind, ctype_pool);
-        wrap.truncate(int, .unsigned, c_bits);
-        @memset(wrap.limbs[wrap.len..], 0);
-        wrap.len = wrap.limbs.len;
-        const limbs_per_c_limb = @divExact(wrap.len, c_limb_info.count);
-
-        var c_limb_int_info: std.builtin.Type.Int = .{
-            .signedness = undefined,
-            .bits = @intCast(@divExact(c_bits, c_limb_info.count)),
-        };
-        var c_limb_ctype: CType = undefined;
-
-        var limb_offset: usize = 0;
-        const most_significant_limb_i = wrap.len - limbs_per_c_limb;
-        while (limb_offset < wrap.len) : (limb_offset += limbs_per_c_limb) {
-            const limb_i = switch (c_limb_info.endian) {
-                .little => limb_offset,
-                .big => most_significant_limb_i - limb_offset,
-            };
-            var c_limb_mut = BigInt.Mutable{
-                .limbs = wrap.limbs[limb_i..][0..limbs_per_c_limb],
-                .len = undefined,
-                .positive = true,
-            };
-            c_limb_mut.normalize(limbs_per_c_limb);
-
-            if (limb_i == most_significant_limb_i and
-                !c_limb_info.homogeneous and data.int_info.signedness == .signed)
-            {
-                // most significant limb is actually signed
-                c_limb_int_info.signedness = .signed;
-                c_limb_ctype = c_limb_info.ctype.toSigned();
-
-                c_limb_mut.truncate(
-                    c_limb_mut.toConst(),
-                    .signed,
-                    data.int_info.bits - limb_i * @bitSizeOf(BigIntLimb),
-                );
-            } else {
-                c_limb_int_info.signedness = .unsigned;
-                c_limb_ctype = c_limb_info.ctype;
-            }
-
-            if (limb_offset > 0) try w.writeAll(", ");
-            try formatIntLiteral(.{
-                .dg = data.dg,
-                .int_info = c_limb_int_info,
-                .kind = data.kind,
-                .ctype = c_limb_ctype,
-                .val = pt.intValue_big(.comptime_int, c_limb_mut.toConst()) catch
-                    return error.WriteFailed,
-                .base = data.base,
-                .case = data.case,
-            }, w);
+        // This `@abs` is safe thanks to the `min_int` case above.
+        try w.printInt(@abs(data.val), data.base, data.case, .{});
+        try w.writeAll(intLiteralSuffix(data.int_cty));
+    }
+};
+const FormatUnsignedIntLiteralSmall = struct {
+    target: *const std.Target,
+    int_cty: CType.Int,
+    val: u64,
+    is_global: bool,
+    base: u8,
+    case: std.fmt.Case,
+    pub fn format(data: FormatUnsignedIntLiteralSmall, w: *Writer) Writer.Error!void {
+        const bits = data.int_cty.bits(data.target);
+        const max_int: u64 = @as(u64, std.math.maxInt(u64)) >> @intCast(64 - bits);
+        if (data.val == max_int) {
+            return w.print("{s}_MAX", .{minMaxMacroPrefix(data.int_cty)});
         }
+        try w.writeAll(intLiteralPrefix(data.int_cty, data.is_global));
+        switch (data.base) {
+            2 => try w.writeAll("0b"),
+            8 => try w.writeByte('0'),
+            10 => {},
+            16 => try w.writeAll("0x"),
+            else => unreachable,
+        }
+        try w.printInt(data.val, data.base, data.case, .{});
+        try w.writeAll(intLiteralSuffix(data.int_cty));
     }
-    try data.ctype.renderLiteralSuffix(w, ctype_pool);
+};
+fn minMaxMacroPrefix(int_cty: CType.Int) []const u8 {
+    return switch (int_cty) {
+        // zig fmt: off
+        .char => "CHAR",
+
+        .@"unsigned short"     => "USHRT",
+        .@"unsigned int"       => "UINT",
+        .@"unsigned long"      => "ULONG",
+        .@"unsigned long long" => "ULLONG",
+
+        .@"signed short"     => "SHRT",
+        .@"signed int"       => "INT",
+        .@"signed long"      => "LONG",
+        .@"signed long long" => "LLONG",
+
+        .uint8_t  => "UINT8",
+        .uint16_t => "UINT16",
+        .uint32_t => "UINT32",
+        .uint64_t => "UINT64",
+        .zig_u128 => unreachable,
+
+        .int8_t   => "INT8",
+        .int16_t  => "INT16",
+        .int32_t  => "INT32",
+        .int64_t  => "INT64",
+        .zig_i128 => unreachable,
+
+        .uintptr_t => "UINTPTR",
+        .intptr_t  => "INTPTR",
+        // zig fmt: on
+    };
+}
+fn intLiteralPrefix(cty: CType.Int, is_global: bool) []const u8 {
+    return switch (cty) {
+        // zig fmt: off
+        .char              => if (is_global) "" else "(char)",
+
+        .@"unsigned short"     => if (is_global) "" else "(unsigned short)",
+        .@"unsigned int"       => "",
+        .@"unsigned long"      => "",
+        .@"unsigned long long" => "",
+
+        .@"signed short"     => if (is_global) "" else "(signed short)",
+        .@"signed int"       => "",
+        .@"signed long"      => "",
+        .@"signed long long" => "",
+
+        .uint8_t  =>  "UINT8_C(",
+        .uint16_t => "UINT16_C(",
+        .uint32_t => "UINT32_C(",
+        .uint64_t => "UINT64_C(",
+        .zig_u128 => unreachable,
+
+        .int8_t   =>  "INT8_C(",
+        .int16_t  => "INT16_C(",
+        .int32_t  => "INT32_C(",
+        .int64_t  => "INT64_C(",
+        .zig_i128 => unreachable,
+
+        .uintptr_t => if (is_global) "" else "(uintptr_t)",
+        .intptr_t  => if (is_global) "" else "(intptr_t)",
+        // zig fmt: on
+    };
+}
+fn intLiteralSuffix(cty: CType.Int) []const u8 {
+    return switch (cty) {
+        // zig fmt: off
+        .char      => "",
+
+        .@"unsigned short"     => "u",
+        .@"unsigned int"       => "u",
+        .@"unsigned long"      => "ul",
+        .@"unsigned long long" => "ull",
+
+        .@"signed short"     => "",
+        .@"signed int"       => "",
+        .@"signed long"      => "l",
+        .@"signed long long" => "ll",
+
+        .uint8_t  => ")",
+        .uint16_t => ")",
+        .uint32_t => ")",
+        .uint64_t => ")",
+        .zig_u128 => unreachable,
+
+        .int8_t   => ")",
+        .int16_t  => ")",
+        .int32_t  => ")",
+        .int64_t  => ")",
+        .zig_i128 => unreachable,
+
+        .uintptr_t => "ul",
+        .intptr_t  => "",
+        // zig fmt: on
+    };
 }
 
 const Materialize = struct {
@@ -8123,7 +7418,7 @@ const Materialize = struct {
     }
 
     pub fn mat(self: Materialize, f: *Function, w: *Writer) !void {
-        try f.writeCValue(w, self.local, .Other);
+        try f.writeCValue(w, self.local, .other);
     }
 
     pub fn end(self: Materialize, f: *Function, inst: Air.Inst.Index) !void {
@@ -8131,95 +7426,52 @@ const Materialize = struct {
     }
 };
 
-const Assignment = struct {
-    ctype: CType,
-
-    pub fn start(f: *Function, w: *Writer, ctype: CType) !Assignment {
-        const self: Assignment = .{ .ctype = ctype };
-        try self.restart(f, w);
-        return self;
-    }
-
-    pub fn restart(self: Assignment, f: *Function, w: *Writer) !void {
-        switch (self.strategy(f)) {
-            .assign => {},
-            .memcpy => try w.writeAll("memcpy("),
-        }
-    }
-
-    pub fn assign(self: Assignment, f: *Function, w: *Writer) !void {
-        switch (self.strategy(f)) {
-            .assign => try w.writeAll(" = "),
-            .memcpy => try w.writeAll(", "),
-        }
-    }
-
-    pub fn end(self: Assignment, f: *Function, w: *Writer) !void {
-        switch (self.strategy(f)) {
-            .assign => {},
-            .memcpy => {
-                try w.writeAll(", sizeof(");
-                try f.renderCType(w, self.ctype);
-                try w.writeAll("))");
-            },
-        }
-        try w.writeByte(';');
-        try f.object.newline();
-    }
-
-    fn strategy(self: Assignment, f: *Function) enum { assign, memcpy } {
-        return switch (self.ctype.info(&f.object.dg.ctype_pool)) {
-            else => .assign,
-            .array, .vector => .memcpy,
-        };
-    }
-};
-
 const Vectorize = struct {
     index: CValue = .none,
 
     pub fn start(f: *Function, inst: Air.Inst.Index, w: *Writer, ty: Type) !Vectorize {
-        const pt = f.object.dg.pt;
+        const pt = f.dg.pt;
         const zcu = pt.zcu;
-        return if (ty.zigTypeTag(zcu) == .vector) index: {
-            const local = try f.allocLocal(inst, .usize);
-
-            try w.writeAll("for (");
-            try f.writeCValue(w, local, .Other);
-            try w.print(" = {f}; ", .{try f.fmtIntLiteralDec(.zero_usize)});
-            try f.writeCValue(w, local, .Other);
-            try w.print(" < {f}; ", .{try f.fmtIntLiteralDec(try pt.intValue(.usize, ty.vectorLen(zcu)))});
-            try f.writeCValue(w, local, .Other);
-            try w.print(" += {f}) {{\n", .{try f.fmtIntLiteralDec(.one_usize)});
-            f.object.indent();
-            try f.object.newline();
-
-            break :index .{ .index = local };
-        } else .{};
+        switch (ty.zigTypeTag(zcu)) {
+            else => return .{ .index = .none },
+            .vector => {
+                const local = try f.allocLocal(inst, .usize);
+                try w.writeAll("for (");
+                try f.writeCValue(w, local, .other);
+                try w.print(" = {f}; ", .{try f.fmtIntLiteralDec(.zero_usize)});
+                try f.writeCValue(w, local, .other);
+                try w.print(" < {f}; ", .{try f.fmtIntLiteralDec(try pt.intValue(.usize, ty.vectorLen(zcu)))});
+                try f.writeCValue(w, local, .other);
+                try w.print(" += {f}) {{", .{try f.fmtIntLiteralDec(.one_usize)});
+                f.indent();
+                try f.newline();
+                return .{ .index = local };
+            },
+        }
     }
 
     pub fn elem(self: Vectorize, f: *Function, w: *Writer) !void {
         if (self.index != .none) {
-            try w.writeByte('[');
-            try f.writeCValue(w, self.index, .Other);
+            try w.writeAll(".array[");
+            try f.writeCValue(w, self.index, .other);
             try w.writeByte(']');
         }
     }
 
     pub fn end(self: Vectorize, f: *Function, inst: Air.Inst.Index, w: *Writer) !void {
         if (self.index != .none) {
-            try f.object.outdent();
+            try f.outdent();
             try w.writeByte('}');
-            try f.object.newline();
+            try f.newline();
             try freeLocal(f, inst, self.index.new_local, null);
         }
     }
 };
 
-fn lowersToArray(ty: Type, zcu: *Zcu) bool {
+fn lowersToBigInt(ty: Type, zcu: *const Zcu) bool {
     return switch (ty.zigTypeTag(zcu)) {
-        .array, .vector => return true,
-        else => return ty.isAbiInt(zcu) and toCIntBits(@as(u32, @intCast(ty.bitSize(zcu)))) == null,
+        .int, .@"enum", .@"struct", .@"union" => CType.classifyInt(ty, zcu) == .big,
+        else => false,
     };
 }
 
@@ -8245,8 +7497,8 @@ fn die(f: *Function, inst: Air.Inst.Index, ref: Air.Inst.Ref) !void {
 }
 
 fn freeLocal(f: *Function, inst: ?Air.Inst.Index, local_index: LocalIndex, ref_inst: ?Air.Inst.Index) !void {
-    const gpa = f.object.dg.gpa;
-    const local = &f.locals.items[local_index];
+    const gpa = f.dg.gpa;
+    const local = f.locals.items[local_index];
     if (inst) |i| {
         if (ref_inst) |operand| {
             log.debug("%{d}: freeing t{d} (operand %{d})", .{ @intFromEnum(i), local_index, operand });
@@ -8260,7 +7512,7 @@ fn freeLocal(f: *Function, inst: ?Air.Inst.Index, local_index: LocalIndex, ref_i
             log.debug("freeing t{d}", .{local_index});
         }
     }
-    const gop = try f.free_locals_map.getOrPut(gpa, local.getType());
+    const gop = try f.free_locals_map.getOrPut(gpa, local);
     if (!gop.found_existing) gop.value_ptr.* = .{};
     if (std.debug.runtime_safety) {
         // If this trips, an unfreeable allocation was attempted to be freed.
@@ -8317,3 +7569,28 @@ fn deinitFreeLocalsMap(gpa: Allocator, map: *LocalsMap) void {
     }
     map.deinit(gpa);
 }
+
+fn renderErrorName(w: *Writer, err_name: []const u8) Writer.Error!void {
+    try w.print("zig_error_{f}", .{fmtIdentUnsolo(err_name)});
+}
+
+fn renderNavName(w: *Writer, nav_index: InternPool.Nav.Index, ip: *const InternPool) !void {
+    const nav = ip.getNav(nav_index);
+    if (nav.getExtern(ip)) |@"extern"| {
+        try w.print("{f}", .{
+            fmtIdentSolo(ip.getNav(@"extern".owner_nav).name.toSlice(ip)),
+        });
+    } else {
+        // MSVC has a limit of 4095 character token length limit, and fmtIdent can (worst case),
+        // expand to 3x the length of its input, but let's cut it off at a much shorter limit.
+        const fqn_slice = ip.getNav(nav_index).fqn.toSlice(ip);
+        try w.print("{f}__{d}", .{
+            fmtIdentUnsolo(fqn_slice[0..@min(fqn_slice.len, 100)]),
+            @intFromEnum(nav_index),
+        });
+    }
+}
+
+fn renderUavName(w: *Writer, uav: Value) !void {
+    try w.print("__anon_{d}", .{@intFromEnum(uav.toIntern())});
+}
diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig
deleted file mode 100644
index a7442a1d49dae8c626c54e448364e6169bf0eff6..0000000000000000000000000000000000000000
--- a/src/codegen/c/Type.zig
+++ /dev/null
@@ -1,3471 +0,0 @@
-index: CType.Index,
-
-pub const @"void": CType = .{ .index = .void };
-pub const @"bool": CType = .{ .index = .bool };
-pub const @"i8": CType = .{ .index = .int8_t };
-pub const @"u8": CType = .{ .index = .uint8_t };
-pub const @"i16": CType = .{ .index = .int16_t };
-pub const @"u16": CType = .{ .index = .uint16_t };
-pub const @"i32": CType = .{ .index = .int32_t };
-pub const @"u32": CType = .{ .index = .uint32_t };
-pub const @"i64": CType = .{ .index = .int64_t };
-pub const @"u64": CType = .{ .index = .uint64_t };
-pub const @"i128": CType = .{ .index = .zig_i128 };
-pub const @"u128": CType = .{ .index = .zig_u128 };
-pub const @"isize": CType = .{ .index = .intptr_t };
-pub const @"usize": CType = .{ .index = .uintptr_t };
-pub const @"f16": CType = .{ .index = .zig_f16 };
-pub const @"f32": CType = .{ .index = .zig_f32 };
-pub const @"f64": CType = .{ .index = .zig_f64 };
-pub const @"f80": CType = .{ .index = .zig_f80 };
-pub const @"f128": CType = .{ .index = .zig_f128 };
-
-pub fn fromPoolIndex(pool_index: usize) CType {
-    return .{ .index = @enumFromInt(CType.Index.first_pool_index + pool_index) };
-}
-
-pub fn toPoolIndex(ctype: CType) ?u32 {
-    const pool_index, const is_null =
-        @subWithOverflow(@intFromEnum(ctype.index), CType.Index.first_pool_index);
-    return switch (is_null) {
-        0 => pool_index,
-        1 => null,
-    };
-}
-
-pub fn eql(lhs: CType, rhs: CType) bool {
-    return lhs.index == rhs.index;
-}
-
-pub fn isBool(ctype: CType) bool {
-    return switch (ctype.index) {
-        ._Bool, .bool => true,
-        else => false,
-    };
-}
-
-pub fn isInteger(ctype: CType) bool {
-    return switch (ctype.index) {
-        .char,
-        .@"signed char",
-        .short,
-        .int,
-        .long,
-        .@"long long",
-        .@"unsigned char",
-        .@"unsigned short",
-        .@"unsigned int",
-        .@"unsigned long",
-        .@"unsigned long long",
-        .size_t,
-        .ptrdiff_t,
-        .uint8_t,
-        .int8_t,
-        .uint16_t,
-        .int16_t,
-        .uint32_t,
-        .int32_t,
-        .uint64_t,
-        .int64_t,
-        .uintptr_t,
-        .intptr_t,
-        .zig_u128,
-        .zig_i128,
-        => true,
-        else => false,
-    };
-}
-
-pub fn signedness(ctype: CType, mod: *Module) std.builtin.Signedness {
-    return switch (ctype.index) {
-        .char => mod.resolved_target.result.cCharSignedness(),
-        .@"signed char",
-        .short,
-        .int,
-        .long,
-        .@"long long",
-        .ptrdiff_t,
-        .int8_t,
-        .int16_t,
-        .int32_t,
-        .int64_t,
-        .intptr_t,
-        .zig_i128,
-        => .signed,
-        .@"unsigned char",
-        .@"unsigned short",
-        .@"unsigned int",
-        .@"unsigned long",
-        .@"unsigned long long",
-        .size_t,
-        .uint8_t,
-        .uint16_t,
-        .uint32_t,
-        .uint64_t,
-        .uintptr_t,
-        .zig_u128,
-        => .unsigned,
-        else => unreachable,
-    };
-}
-
-pub fn isFloat(ctype: CType) bool {
-    return switch (ctype.index) {
-        .float,
-        .double,
-        .@"long double",
-        .zig_f16,
-        .zig_f32,
-        .zig_f64,
-        .zig_f80,
-        .zig_f128,
-        .zig_c_longdouble,
-        => true,
-        else => false,
-    };
-}
-
-pub fn toSigned(ctype: CType) CType {
-    return switch (ctype.index) {
-        .char, .@"signed char", .@"unsigned char" => .{ .index = .@"signed char" },
-        .short, .@"unsigned short" => .{ .index = .short },
-        .int, .@"unsigned int" => .{ .index = .int },
-        .long, .@"unsigned long" => .{ .index = .long },
-        .@"long long", .@"unsigned long long" => .{ .index = .@"long long" },
-        .size_t, .ptrdiff_t => .{ .index = .ptrdiff_t },
-        .uint8_t, .int8_t => .{ .index = .int8_t },
-        .uint16_t, .int16_t => .{ .index = .int16_t },
-        .uint32_t, .int32_t => .{ .index = .int32_t },
-        .uint64_t, .int64_t => .{ .index = .int64_t },
-        .uintptr_t, .intptr_t => .{ .index = .intptr_t },
-        .zig_u128, .zig_i128 => .{ .index = .zig_i128 },
-        .float,
-        .double,
-        .@"long double",
-        .zig_f16,
-        .zig_f32,
-        .zig_f80,
-        .zig_f128,
-        .zig_c_longdouble,
-        => ctype,
-        else => unreachable,
-    };
-}
-
-pub fn toUnsigned(ctype: CType) CType {
-    return switch (ctype.index) {
-        .char, .@"signed char", .@"unsigned char" => .{ .index = .@"unsigned char" },
-        .short, .@"unsigned short" => .{ .index = .@"unsigned short" },
-        .int, .@"unsigned int" => .{ .index = .@"unsigned int" },
-        .long, .@"unsigned long" => .{ .index = .@"unsigned long" },
-        .@"long long", .@"unsigned long long" => .{ .index = .@"unsigned long long" },
-        .size_t, .ptrdiff_t => .{ .index = .size_t },
-        .uint8_t, .int8_t => .{ .index = .uint8_t },
-        .uint16_t, .int16_t => .{ .index = .uint16_t },
-        .uint32_t, .int32_t => .{ .index = .uint32_t },
-        .uint64_t, .int64_t => .{ .index = .uint64_t },
-        .uintptr_t, .intptr_t => .{ .index = .uintptr_t },
-        .zig_u128, .zig_i128 => .{ .index = .zig_u128 },
-        else => unreachable,
-    };
-}
-
-pub fn toSignedness(ctype: CType, s: std.builtin.Signedness) CType {
-    return switch (s) {
-        .unsigned => ctype.toUnsigned(),
-        .signed => ctype.toSigned(),
-    };
-}
-
-pub fn isAnyChar(ctype: CType) bool {
-    return switch (ctype.index) {
-        else => false,
-        .char, .@"signed char", .@"unsigned char", .uint8_t, .int8_t => true,
-    };
-}
-
-pub fn isString(ctype: CType, pool: *const Pool) bool {
-    return info: switch (ctype.info(pool)) {
-        .basic, .fwd_decl, .aggregate, .function => false,
-        .pointer => |pointer_info| pointer_info.elem_ctype.isAnyChar(),
-        .aligned => |aligned_info| continue :info aligned_info.ctype.info(pool),
-        .array, .vector => |sequence_info| sequence_info.elem_type.isAnyChar(),
-    };
-}
-
-pub fn isNonString(ctype: CType, pool: *const Pool) bool {
-    var allow_pointer = true;
-    return info: switch (ctype.info(pool)) {
-        .basic, .fwd_decl, .aggregate, .function => false,
-        .pointer => |pointer_info| allow_pointer and pointer_info.nonstring,
-        .aligned => |aligned_info| continue :info aligned_info.ctype.info(pool),
-        .array, .vector => |sequence_info| sequence_info.nonstring or {
-            allow_pointer = false;
-            continue :info sequence_info.elem_ctype.info(pool);
-        },
-    };
-}
-
-pub fn getStandardDefineAbbrev(ctype: CType) ?[]const u8 {
-    return switch (ctype.index) {
-        .char => "CHAR",
-        .@"signed char" => "SCHAR",
-        .short => "SHRT",
-        .int => "INT",
-        .long => "LONG",
-        .@"long long" => "LLONG",
-        .@"unsigned char" => "UCHAR",
-        .@"unsigned short" => "USHRT",
-        .@"unsigned int" => "UINT",
-        .@"unsigned long" => "ULONG",
-        .@"unsigned long long" => "ULLONG",
-        .float => "FLT",
-        .double => "DBL",
-        .@"long double" => "LDBL",
-        .size_t => "SIZE",
-        .ptrdiff_t => "PTRDIFF",
-        .uint8_t => "UINT8",
-        .int8_t => "INT8",
-        .uint16_t => "UINT16",
-        .int16_t => "INT16",
-        .uint32_t => "UINT32",
-        .int32_t => "INT32",
-        .uint64_t => "UINT64",
-        .int64_t => "INT64",
-        .uintptr_t => "UINTPTR",
-        .intptr_t => "INTPTR",
-        else => null,
-    };
-}
-
-pub fn renderLiteralPrefix(ctype: CType, w: *Writer, kind: Kind, pool: *const Pool) Writer.Error!void {
-    switch (ctype.info(pool)) {
-        .basic => |basic_info| switch (basic_info) {
-            .void => unreachable,
-            ._Bool,
-            .char,
-            .@"signed char",
-            .short,
-            .@"unsigned short",
-            .bool,
-            .size_t,
-            .ptrdiff_t,
-            .uintptr_t,
-            .intptr_t,
-            => switch (kind) {
-                else => try w.print("({s})", .{@tagName(basic_info)}),
-                .global => {},
-            },
-            .int,
-            .long,
-            .@"long long",
-            .@"unsigned char",
-            .@"unsigned int",
-            .@"unsigned long",
-            .@"unsigned long long",
-            .float,
-            .double,
-            .@"long double",
-            => {},
-            .uint8_t,
-            .int8_t,
-            .uint16_t,
-            .int16_t,
-            .uint32_t,
-            .int32_t,
-            .uint64_t,
-            .int64_t,
-            => try w.print("{s}_C(", .{ctype.getStandardDefineAbbrev().?}),
-            .zig_u128,
-            .zig_i128,
-            .zig_f16,
-            .zig_f32,
-            .zig_f64,
-            .zig_f80,
-            .zig_f128,
-            .zig_c_longdouble,
-            => try w.print("zig_{s}_{s}(", .{
-                switch (kind) {
-                    else => "make",
-                    .global => "init",
-                },
-                @tagName(basic_info)["zig_".len..],
-            }),
-            .va_list => unreachable,
-            _ => unreachable,
-        },
-        .array, .vector => try w.writeByte('{'),
-        else => unreachable,
-    }
-}
-
-pub fn renderLiteralSuffix(ctype: CType, w: *Writer, pool: *const Pool) Writer.Error!void {
-    switch (ctype.info(pool)) {
-        .basic => |basic_info| switch (basic_info) {
-            .void => unreachable,
-            ._Bool => {},
-            .char,
-            .@"signed char",
-            .short,
-            .int,
-            => {},
-            .long => try w.writeByte('l'),
-            .@"long long" => try w.writeAll("ll"),
-            .@"unsigned char",
-            .@"unsigned short",
-            .@"unsigned int",
-            => try w.writeByte('u'),
-            .@"unsigned long",
-            .size_t,
-            .uintptr_t,
-            => try w.writeAll("ul"),
-            .@"unsigned long long" => try w.writeAll("ull"),
-            .float => try w.writeByte('f'),
-            .double => {},
-            .@"long double" => try w.writeByte('l'),
-            .bool,
-            .ptrdiff_t,
-            .intptr_t,
-            => {},
-            .uint8_t,
-            .int8_t,
-            .uint16_t,
-            .int16_t,
-            .uint32_t,
-            .int32_t,
-            .uint64_t,
-            .int64_t,
-            .zig_u128,
-            .zig_i128,
-            .zig_f16,
-            .zig_f32,
-            .zig_f64,
-            .zig_f80,
-            .zig_f128,
-            .zig_c_longdouble,
-            => try w.writeByte(')'),
-            .va_list => unreachable,
-            _ => unreachable,
-        },
-        .array, .vector => try w.writeByte('}'),
-        else => unreachable,
-    }
-}
-
-pub fn floatActiveBits(ctype: CType, mod: *Module) u16 {
-    const target = &mod.resolved_target.result;
-    return switch (ctype.index) {
-        .float => target.cTypeBitSize(.float),
-        .double => target.cTypeBitSize(.double),
-        .@"long double", .zig_c_longdouble => target.cTypeBitSize(.longdouble),
-        .zig_f16 => 16,
-        .zig_f32 => 32,
-        .zig_f64 => 64,
-        .zig_f80 => 80,
-        .zig_f128 => 128,
-        else => unreachable,
-    };
-}
-
-pub fn byteSize(ctype: CType, pool: *const Pool, mod: *Module) u64 {
-    const target = &mod.resolved_target.result;
-    return switch (ctype.info(pool)) {
-        .basic => |basic_info| switch (basic_info) {
-            .void => 0,
-            .char, .@"signed char", ._Bool, .@"unsigned char", .bool, .uint8_t, .int8_t => 1,
-            .short => target.cTypeByteSize(.short),
-            .int => target.cTypeByteSize(.int),
-            .long => target.cTypeByteSize(.long),
-            .@"long long" => target.cTypeByteSize(.longlong),
-            .@"unsigned short" => target.cTypeByteSize(.ushort),
-            .@"unsigned int" => target.cTypeByteSize(.uint),
-            .@"unsigned long" => target.cTypeByteSize(.ulong),
-            .@"unsigned long long" => target.cTypeByteSize(.ulonglong),
-            .float => target.cTypeByteSize(.float),
-            .double => target.cTypeByteSize(.double),
-            .@"long double" => target.cTypeByteSize(.longdouble),
-            .size_t,
-            .ptrdiff_t,
-            .uintptr_t,
-            .intptr_t,
-            => @divExact(target.ptrBitWidth(), 8),
-            .uint16_t, .int16_t, .zig_f16 => 2,
-            .uint32_t, .int32_t, .zig_f32 => 4,
-            .uint64_t, .int64_t, .zig_f64 => 8,
-            .zig_u128, .zig_i128, .zig_f128 => 16,
-            .zig_f80 => if (target.cTypeBitSize(.longdouble) == 80)
-                target.cTypeByteSize(.longdouble)
-            else
-                16,
-            .zig_c_longdouble => target.cTypeByteSize(.longdouble),
-            .va_list => unreachable,
-            _ => unreachable,
-        },
-        .pointer => @divExact(target.ptrBitWidth(), 8),
-        .array, .vector => |sequence_info| sequence_info.elem_ctype.byteSize(pool, mod) * sequence_info.len,
-        else => unreachable,
-    };
-}
-
-pub fn info(ctype: CType, pool: *const Pool) Info {
-    const pool_index = ctype.toPoolIndex() orelse return .{ .basic = ctype.index };
-    const item = pool.items.get(pool_index);
-    switch (item.tag) {
-        .basic => unreachable,
-        .pointer => return .{ .pointer = .{
-            .elem_ctype = .{ .index = @enumFromInt(item.data) },
-        } },
-        .pointer_const => return .{ .pointer = .{
-            .elem_ctype = .{ .index = @enumFromInt(item.data) },
-            .@"const" = true,
-        } },
-        .pointer_volatile => return .{ .pointer = .{
-            .elem_ctype = .{ .index = @enumFromInt(item.data) },
-            .@"volatile" = true,
-        } },
-        .pointer_const_volatile => return .{ .pointer = .{
-            .elem_ctype = .{ .index = @enumFromInt(item.data) },
-            .@"const" = true,
-            .@"volatile" = true,
-        } },
-        .aligned => {
-            const extra = pool.getExtra(Pool.Aligned, item.data);
-            return .{ .aligned = .{
-                .ctype = .{ .index = extra.ctype },
-                .alignas = extra.flags.alignas,
-            } };
-        },
-        .array_small => {
-            const extra = pool.getExtra(Pool.SequenceSmall, item.data);
-            return .{ .array = .{
-                .elem_ctype = .{ .index = extra.elem_ctype },
-                .len = extra.len,
-            } };
-        },
-        .array_large => {
-            const extra = pool.getExtra(Pool.SequenceLarge, item.data);
-            return .{ .array = .{
-                .elem_ctype = .{ .index = extra.elem_ctype },
-                .len = extra.len(),
-            } };
-        },
-        .vector => {
-            const extra = pool.getExtra(Pool.SequenceSmall, item.data);
-            return .{ .vector = .{
-                .elem_ctype = .{ .index = extra.elem_ctype },
-                .len = extra.len,
-            } };
-        },
-        .nonstring => {
-            var child_info = info(.{ .index = @enumFromInt(item.data) }, pool);
-            switch (child_info) {
-                else => unreachable,
-                .pointer => |*pointer_info| pointer_info.nonstring = true,
-                .array, .vector => |*sequence_info| sequence_info.nonstring = true,
-            }
-            return child_info;
-        },
-        .fwd_decl_struct_anon => {
-            const extra_trail = pool.getExtraTrail(Pool.FwdDeclAnon, item.data);
-            return .{ .fwd_decl = .{
-                .tag = .@"struct",
-                .name = .{ .anon = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                } },
-            } };
-        },
-        .fwd_decl_union_anon => {
-            const extra_trail = pool.getExtraTrail(Pool.FwdDeclAnon, item.data);
-            return .{ .fwd_decl = .{
-                .tag = .@"union",
-                .name = .{ .anon = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                } },
-            } };
-        },
-        .fwd_decl_struct => return .{ .fwd_decl = .{
-            .tag = .@"struct",
-            .name = .{ .index = @enumFromInt(item.data) },
-        } },
-        .fwd_decl_union => return .{ .fwd_decl = .{
-            .tag = .@"union",
-            .name = .{ .index = @enumFromInt(item.data) },
-        } },
-        .aggregate_struct_anon => {
-            const extra_trail = pool.getExtraTrail(Pool.AggregateAnon, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"struct",
-                .name = .{ .anon = .{
-                    .index = extra_trail.extra.index,
-                    .id = extra_trail.extra.id,
-                } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_union_anon => {
-            const extra_trail = pool.getExtraTrail(Pool.AggregateAnon, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"union",
-                .name = .{ .anon = .{
-                    .index = extra_trail.extra.index,
-                    .id = extra_trail.extra.id,
-                } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_struct_packed_anon => {
-            const extra_trail = pool.getExtraTrail(Pool.AggregateAnon, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"struct",
-                .@"packed" = true,
-                .name = .{ .anon = .{
-                    .index = extra_trail.extra.index,
-                    .id = extra_trail.extra.id,
-                } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_union_packed_anon => {
-            const extra_trail = pool.getExtraTrail(Pool.AggregateAnon, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"union",
-                .@"packed" = true,
-                .name = .{ .anon = .{
-                    .index = extra_trail.extra.index,
-                    .id = extra_trail.extra.id,
-                } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_struct => {
-            const extra_trail = pool.getExtraTrail(Pool.Aggregate, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"struct",
-                .name = .{ .fwd_decl = .{ .index = extra_trail.extra.fwd_decl } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_union => {
-            const extra_trail = pool.getExtraTrail(Pool.Aggregate, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"union",
-                .name = .{ .fwd_decl = .{ .index = extra_trail.extra.fwd_decl } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_struct_packed => {
-            const extra_trail = pool.getExtraTrail(Pool.Aggregate, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"struct",
-                .@"packed" = true,
-                .name = .{ .fwd_decl = .{ .index = extra_trail.extra.fwd_decl } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .aggregate_union_packed => {
-            const extra_trail = pool.getExtraTrail(Pool.Aggregate, item.data);
-            return .{ .aggregate = .{
-                .tag = .@"union",
-                .@"packed" = true,
-                .name = .{ .fwd_decl = .{ .index = extra_trail.extra.fwd_decl } },
-                .fields = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.fields_len,
-                },
-            } };
-        },
-        .function => {
-            const extra_trail = pool.getExtraTrail(Pool.Function, item.data);
-            return .{ .function = .{
-                .return_ctype = .{ .index = extra_trail.extra.return_ctype },
-                .param_ctypes = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.param_ctypes_len,
-                },
-                .varargs = false,
-            } };
-        },
-        .function_varargs => {
-            const extra_trail = pool.getExtraTrail(Pool.Function, item.data);
-            return .{ .function = .{
-                .return_ctype = .{ .index = extra_trail.extra.return_ctype },
-                .param_ctypes = .{
-                    .extra_index = extra_trail.trail.extra_index,
-                    .len = extra_trail.extra.param_ctypes_len,
-                },
-                .varargs = true,
-            } };
-        },
-    }
-}
-
-pub fn hash(ctype: CType, pool: *const Pool) Pool.Map.Hash {
-    return if (ctype.toPoolIndex()) |pool_index|
-        pool.map.entries.items(.hash)[pool_index]
-    else
-        CType.Index.basic_hashes[@intFromEnum(ctype.index)];
-}
-
-fn toForward(ctype: CType, pool: *Pool, allocator: std.mem.Allocator) !CType {
-    return switch (ctype.info(pool)) {
-        .basic, .pointer, .fwd_decl => ctype,
-        .aligned => |aligned_info| pool.getAligned(allocator, .{
-            .ctype = try aligned_info.ctype.toForward(pool, allocator),
-            .alignas = aligned_info.alignas,
-        }),
-        .array => |array_info| pool.getArray(allocator, .{
-            .elem_ctype = try array_info.elem_ctype.toForward(pool, allocator),
-            .len = array_info.len,
-            .nonstring = array_info.nonstring,
-        }),
-        .vector => |vector_info| pool.getVector(allocator, .{
-            .elem_ctype = try vector_info.elem_ctype.toForward(pool, allocator),
-            .len = vector_info.len,
-            .nonstring = vector_info.nonstring,
-        }),
-        .aggregate => |aggregate_info| switch (aggregate_info.name) {
-            .anon => ctype,
-            .fwd_decl => |fwd_decl| fwd_decl,
-        },
-        .function => unreachable,
-    };
-}
-
-const Index = enum(u32) {
-    void,
-
-    // C basic types
-    char,
-
-    @"signed char",
-    short,
-    int,
-    long,
-    @"long long",
-
-    _Bool,
-    @"unsigned char",
-    @"unsigned short",
-    @"unsigned int",
-    @"unsigned long",
-    @"unsigned long long",
-
-    float,
-    double,
-    @"long double",
-
-    // C header types
-    //  - stdbool.h
-    bool,
-    //  - stddef.h
-    size_t,
-    ptrdiff_t,
-    //  - stdint.h
-    uint8_t,
-    int8_t,
-    uint16_t,
-    int16_t,
-    uint32_t,
-    int32_t,
-    uint64_t,
-    int64_t,
-    uintptr_t,
-    intptr_t,
-    //  - stdarg.h
-    va_list,
-
-    // zig.h types
-    zig_u128,
-    zig_i128,
-    zig_f16,
-    zig_f32,
-    zig_f64,
-    zig_f80,
-    zig_f128,
-    zig_c_longdouble,
-
-    _,
-
-    const first_pool_index: u32 = @typeInfo(CType.Index).@"enum".fields.len;
-    const basic_hashes = init: {
-        @setEvalBranchQuota(1_600);
-        var basic_hashes_init: [first_pool_index]Pool.Map.Hash = undefined;
-        for (&basic_hashes_init, 0..) |*basic_hash, index| {
-            const ctype_index: CType.Index = @enumFromInt(index);
-            var hasher = Pool.Hasher.init;
-            hasher.update(@intFromEnum(ctype_index));
-            basic_hash.* = hasher.final(.basic);
-        }
-        break :init basic_hashes_init;
-    };
-};
-
-const Slice = struct {
-    extra_index: Pool.ExtraIndex,
-    len: u32,
-
-    pub fn at(slice: CType.Slice, index: usize, pool: *const Pool) CType {
-        var extra: Pool.ExtraTrail = .{ .extra_index = slice.extra_index };
-        return .{ .index = extra.next(slice.len, CType.Index, pool)[index] };
-    }
-};
-
-pub const Kind = enum {
-    forward,
-    forward_parameter,
-    complete,
-    global,
-    parameter,
-
-    pub fn isForward(kind: Kind) bool {
-        return switch (kind) {
-            .forward, .forward_parameter => true,
-            .complete, .global, .parameter => false,
-        };
-    }
-
-    pub fn isParameter(kind: Kind) bool {
-        return switch (kind) {
-            .forward_parameter, .parameter => true,
-            .forward, .complete, .global => false,
-        };
-    }
-
-    pub fn asParameter(kind: Kind) Kind {
-        return switch (kind) {
-            .forward, .forward_parameter => .forward_parameter,
-            .complete, .parameter, .global => .parameter,
-        };
-    }
-
-    pub fn noParameter(kind: Kind) Kind {
-        return switch (kind) {
-            .forward, .forward_parameter => .forward,
-            .complete, .parameter => .complete,
-            .global => .global,
-        };
-    }
-
-    pub fn asComplete(kind: Kind) Kind {
-        return switch (kind) {
-            .forward, .complete => .complete,
-            .forward_parameter, .parameter => .parameter,
-            .global => .global,
-        };
-    }
-};
-
-pub const Info = union(enum) {
-    basic: CType.Index,
-    pointer: Pointer,
-    aligned: Aligned,
-    array: Sequence,
-    vector: Sequence,
-    fwd_decl: FwdDecl,
-    aggregate: Aggregate,
-    function: Function,
-
-    const Tag = @typeInfo(Info).@"union".tag_type.?;
-
-    pub const Pointer = struct {
-        elem_ctype: CType,
-        @"const": bool = false,
-        @"volatile": bool = false,
-        nonstring: bool = false,
-
-        fn tag(pointer_info: Pointer) Pool.Tag {
-            return @enumFromInt(@intFromEnum(Pool.Tag.pointer) +
-                @as(u2, @bitCast(packed struct(u2) {
-                    @"const": bool,
-                    @"volatile": bool,
-                }{
-                    .@"const" = pointer_info.@"const",
-                    .@"volatile" = pointer_info.@"volatile",
-                })));
-        }
-    };
-
-    pub const Aligned = struct {
-        ctype: CType,
-        alignas: AlignAs,
-    };
-
-    pub const Sequence = struct {
-        elem_ctype: CType,
-        len: u64,
-        nonstring: bool = false,
-    };
-
-    pub const AggregateTag = enum { @"enum", @"struct", @"union" };
-
-    pub const Field = struct {
-        name: Pool.String,
-        ctype: CType,
-        alignas: AlignAs,
-
-        pub const Slice = struct {
-            extra_index: Pool.ExtraIndex,
-            len: u32,
-
-            pub fn at(slice: Field.Slice, index: usize, pool: *const Pool) Field {
-                assert(index < slice.len);
-                const extra = pool.getExtra(Pool.Field, @intCast(slice.extra_index +
-                    index * @typeInfo(Pool.Field).@"struct".fields.len));
-                return .{
-                    .name = .{ .index = extra.name },
-                    .ctype = .{ .index = extra.ctype },
-                    .alignas = extra.flags.alignas,
-                };
-            }
-
-            fn eqlAdapted(
-                lhs_slice: Field.Slice,
-                lhs_pool: *const Pool,
-                rhs_slice: Field.Slice,
-                rhs_pool: *const Pool,
-                pool_adapter: anytype,
-            ) bool {
-                if (lhs_slice.len != rhs_slice.len) return false;
-                for (0..lhs_slice.len) |index| {
-                    if (!lhs_slice.at(index, lhs_pool).eqlAdapted(
-                        lhs_pool,
-                        rhs_slice.at(index, rhs_pool),
-                        rhs_pool,
-                        pool_adapter,
-                    )) return false;
-                }
-                return true;
-            }
-        };
-
-        fn eqlAdapted(
-            lhs_field: Field,
-            lhs_pool: *const Pool,
-            rhs_field: Field,
-            rhs_pool: *const Pool,
-            pool_adapter: anytype,
-        ) bool {
-            if (!std.meta.eql(lhs_field.alignas, rhs_field.alignas)) return false;
-            if (!pool_adapter.eql(lhs_field.ctype, rhs_field.ctype)) return false;
-            return if (lhs_field.name.toPoolSlice(lhs_pool)) |lhs_name|
-                if (rhs_field.name.toPoolSlice(rhs_pool)) |rhs_name|
-                    std.mem.eql(u8, lhs_name, rhs_name)
-                else
-                    false
-            else
-                lhs_field.name.index == rhs_field.name.index;
-        }
-    };
-
-    pub const FwdDecl = struct {
-        tag: AggregateTag,
-        name: union(enum) {
-            anon: Field.Slice,
-            index: InternPool.Index,
-        },
-    };
-
-    pub const Aggregate = struct {
-        tag: AggregateTag,
-        @"packed": bool = false,
-        name: union(enum) {
-            anon: struct {
-                index: InternPool.Index,
-                id: u32,
-            },
-            fwd_decl: CType,
-        },
-        fields: Field.Slice,
-    };
-
-    pub const Function = struct {
-        return_ctype: CType,
-        param_ctypes: CType.Slice,
-        varargs: bool = false,
-    };
-
-    pub fn eqlAdapted(
-        lhs_info: Info,
-        lhs_pool: *const Pool,
-        rhs_ctype: CType,
-        rhs_pool: *const Pool,
-        pool_adapter: anytype,
-    ) bool {
-        const rhs_info = rhs_ctype.info(rhs_pool);
-        if (@as(Info.Tag, lhs_info) != @as(Info.Tag, rhs_info)) return false;
-        return switch (lhs_info) {
-            .basic => |lhs_basic_info| lhs_basic_info == rhs_info.basic,
-            .pointer => |lhs_pointer_info| lhs_pointer_info.@"const" == rhs_info.pointer.@"const" and
-                lhs_pointer_info.@"volatile" == rhs_info.pointer.@"volatile" and
-                lhs_pointer_info.nonstring == rhs_info.pointer.nonstring and
-                pool_adapter.eql(lhs_pointer_info.elem_ctype, rhs_info.pointer.elem_ctype),
-            .aligned => |lhs_aligned_info| std.meta.eql(lhs_aligned_info.alignas, rhs_info.aligned.alignas) and
-                pool_adapter.eql(lhs_aligned_info.ctype, rhs_info.aligned.ctype),
-            .array => |lhs_array_info| lhs_array_info.len == rhs_info.array.len and
-                lhs_array_info.nonstring == rhs_info.array.nonstring and
-                pool_adapter.eql(lhs_array_info.elem_ctype, rhs_info.array.elem_ctype),
-            .vector => |lhs_vector_info| lhs_vector_info.len == rhs_info.vector.len and
-                lhs_vector_info.nonstring == rhs_info.vector.nonstring and
-                pool_adapter.eql(lhs_vector_info.elem_ctype, rhs_info.vector.elem_ctype),
-            .fwd_decl => |lhs_fwd_decl_info| lhs_fwd_decl_info.tag == rhs_info.fwd_decl.tag and
-                switch (lhs_fwd_decl_info.name) {
-                    .anon => |lhs_anon| rhs_info.fwd_decl.name == .anon and lhs_anon.eqlAdapted(
-                        lhs_pool,
-                        rhs_info.fwd_decl.name.anon,
-                        rhs_pool,
-                        pool_adapter,
-                    ),
-                    .index => |lhs_index| rhs_info.fwd_decl.name == .index and
-                        lhs_index == rhs_info.fwd_decl.name.index,
-                },
-            .aggregate => |lhs_aggregate_info| lhs_aggregate_info.tag == rhs_info.aggregate.tag and
-                lhs_aggregate_info.@"packed" == rhs_info.aggregate.@"packed" and
-                switch (lhs_aggregate_info.name) {
-                    .anon => |lhs_anon| rhs_info.aggregate.name == .anon and
-                        lhs_anon.index == rhs_info.aggregate.name.anon.index and
-                        lhs_anon.id == rhs_info.aggregate.name.anon.id,
-                    .fwd_decl => |lhs_fwd_decl| rhs_info.aggregate.name == .fwd_decl and
-                        pool_adapter.eql(lhs_fwd_decl, rhs_info.aggregate.name.fwd_decl),
-                } and lhs_aggregate_info.fields.eqlAdapted(
-                lhs_pool,
-                rhs_info.aggregate.fields,
-                rhs_pool,
-                pool_adapter,
-            ),
-            .function => |lhs_function_info| lhs_function_info.param_ctypes.len ==
-                rhs_info.function.param_ctypes.len and
-                pool_adapter.eql(lhs_function_info.return_ctype, rhs_info.function.return_ctype) and
-                for (0..lhs_function_info.param_ctypes.len) |param_index| {
-                    if (!pool_adapter.eql(
-                        lhs_function_info.param_ctypes.at(param_index, lhs_pool),
-                        rhs_info.function.param_ctypes.at(param_index, rhs_pool),
-                    )) break false;
-                } else true,
-        };
-    }
-};
-
-pub const Pool = struct {
-    map: Map,
-    items: std.MultiArrayList(Item),
-    extra: std.ArrayList(u32),
-
-    string_map: Map,
-    string_indices: std.ArrayList(u32),
-    string_bytes: std.ArrayList(u8),
-
-    const Map = std.AutoArrayHashMapUnmanaged(void, void);
-
-    pub const String = struct {
-        index: String.Index,
-
-        const FormatData = struct { string: String, pool: *const Pool };
-        fn format(data: FormatData, writer: *Writer) Writer.Error!void {
-            if (data.string.toSlice(data.pool)) |slice|
-                try writer.writeAll(slice)
-            else
-                try writer.print("f{d}", .{@intFromEnum(data.string.index)});
-        }
-        pub fn fmt(str: String, pool: *const Pool) std.fmt.Alt(FormatData, format) {
-            return .{ .data = .{ .string = str, .pool = pool } };
-        }
-
-        fn fromUnnamed(index: u31) String {
-            return .{ .index = @enumFromInt(index) };
-        }
-
-        fn isNamed(str: String) bool {
-            return @intFromEnum(str.index) >= String.Index.first_named_index;
-        }
-
-        pub fn toSlice(str: String, pool: *const Pool) ?[]const u8 {
-            return str.toPoolSlice(pool) orelse if (str.isNamed()) @tagName(str.index) else null;
-        }
-
-        fn toPoolSlice(str: String, pool: *const Pool) ?[]const u8 {
-            if (str.toPoolIndex()) |pool_index| {
-                const start = pool.string_indices.items[pool_index + 0];
-                const end = pool.string_indices.items[pool_index + 1];
-                return pool.string_bytes.items[start..end];
-            } else return null;
-        }
-
-        fn fromPoolIndex(pool_index: usize) String {
-            return .{ .index = @enumFromInt(String.Index.first_pool_index + pool_index) };
-        }
-
-        fn toPoolIndex(str: String) ?u32 {
-            const pool_index, const is_null =
-                @subWithOverflow(@intFromEnum(str.index), String.Index.first_pool_index);
-            return switch (is_null) {
-                0 => pool_index,
-                1 => null,
-            };
-        }
-
-        const Index = enum(u32) {
-            array = first_named_index,
-            @"error",
-            is_null,
-            len,
-            payload,
-            ptr,
-            tag,
-            _,
-
-            const first_named_index: u32 = 1 << 31;
-            const first_pool_index: u32 = first_named_index + @typeInfo(String.Index).@"enum".fields.len;
-        };
-
-        const Adapter = struct {
-            pool: *const Pool,
-            pub fn hash(_: @This(), slice: []const u8) Map.Hash {
-                return @truncate(Hasher.Impl.hash(1, slice));
-            }
-            pub fn eql(string_adapter: @This(), lhs_slice: []const u8, _: void, rhs_index: usize) bool {
-                const rhs_string = String.fromPoolIndex(rhs_index);
-                const rhs_slice = rhs_string.toPoolSlice(string_adapter.pool).?;
-                return std.mem.eql(u8, lhs_slice, rhs_slice);
-            }
-        };
-    };
-
-    pub const empty: Pool = .{
-        .map = .empty,
-        .items = .empty,
-        .extra = .empty,
-
-        .string_map = .empty,
-        .string_indices = .empty,
-        .string_bytes = .empty,
-    };
-
-    pub fn init(pool: *Pool, allocator: std.mem.Allocator) !void {
-        if (pool.string_indices.items.len == 0)
-            try pool.string_indices.append(allocator, 0);
-    }
-
-    pub fn deinit(pool: *Pool, allocator: std.mem.Allocator) void {
-        pool.map.deinit(allocator);
-        pool.items.deinit(allocator);
-        pool.extra.deinit(allocator);
-
-        pool.string_map.deinit(allocator);
-        pool.string_indices.deinit(allocator);
-        pool.string_bytes.deinit(allocator);
-
-        pool.* = undefined;
-    }
-
-    pub fn move(pool: *Pool) Pool {
-        defer pool.* = empty;
-        return pool.*;
-    }
-
-    pub fn clearRetainingCapacity(pool: *Pool) void {
-        pool.map.clearRetainingCapacity();
-        pool.items.shrinkRetainingCapacity(0);
-        pool.extra.clearRetainingCapacity();
-
-        pool.string_map.clearRetainingCapacity();
-        pool.string_indices.shrinkRetainingCapacity(1);
-        pool.string_bytes.clearRetainingCapacity();
-    }
-
-    pub fn freeUnusedCapacity(pool: *Pool, allocator: std.mem.Allocator) void {
-        pool.map.shrinkAndFree(allocator, pool.map.count());
-        pool.items.shrinkAndFree(allocator, pool.items.len);
-        pool.extra.shrinkAndFree(allocator, pool.extra.items.len);
-
-        pool.string_map.shrinkAndFree(allocator, pool.string_map.count());
-        pool.string_indices.shrinkAndFree(allocator, pool.string_indices.items.len);
-        pool.string_bytes.shrinkAndFree(allocator, pool.string_bytes.items.len);
-    }
-
-    pub fn getPointer(pool: *Pool, allocator: std.mem.Allocator, pointer_info: Info.Pointer) !CType {
-        var hasher = Hasher.init;
-        hasher.update(pointer_info.elem_ctype.hash(pool));
-        return pool.getNonString(allocator, try pool.tagData(
-            allocator,
-            hasher,
-            pointer_info.tag(),
-            @intFromEnum(pointer_info.elem_ctype.index),
-        ), pointer_info.nonstring);
-    }
-
-    pub fn getAligned(pool: *Pool, allocator: std.mem.Allocator, aligned_info: Info.Aligned) !CType {
-        return pool.tagExtra(allocator, .aligned, Aligned, .{
-            .ctype = aligned_info.ctype.index,
-            .flags = .{ .alignas = aligned_info.alignas },
-        });
-    }
-
-    pub fn getArray(pool: *Pool, allocator: std.mem.Allocator, array_info: Info.Sequence) !CType {
-        return pool.getNonString(allocator, if (std.math.cast(u32, array_info.len)) |small_len|
-            try pool.tagExtra(allocator, .array_small, SequenceSmall, .{
-                .elem_ctype = array_info.elem_ctype.index,
-                .len = small_len,
-            })
-        else
-            try pool.tagExtra(allocator, .array_large, SequenceLarge, .{
-                .elem_ctype = array_info.elem_ctype.index,
-                .len_lo = @truncate(array_info.len >> 0),
-                .len_hi = @truncate(array_info.len >> 32),
-            }), array_info.nonstring);
-    }
-
-    pub fn getVector(pool: *Pool, allocator: std.mem.Allocator, vector_info: Info.Sequence) !CType {
-        return pool.getNonString(allocator, try pool.tagExtra(allocator, .vector, SequenceSmall, .{
-            .elem_ctype = vector_info.elem_ctype.index,
-            .len = @intCast(vector_info.len),
-        }), vector_info.nonstring);
-    }
-
-    pub fn getNonString(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        child_ctype: CType,
-        nonstring: bool,
-    ) !CType {
-        if (!nonstring) return child_ctype;
-        var hasher = Hasher.init;
-        hasher.update(child_ctype.hash(pool));
-        return pool.tagData(allocator, hasher, .nonstring, @intFromEnum(child_ctype.index));
-    }
-
-    pub fn getFwdDecl(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        fwd_decl_info: struct {
-            tag: Info.AggregateTag,
-            name: union(enum) {
-                anon: []const Info.Field,
-                index: InternPool.Index,
-            },
-        },
-    ) !CType {
-        var hasher = Hasher.init;
-        switch (fwd_decl_info.name) {
-            .anon => |fields| {
-                const ExpectedContents = [32]CType;
-                var stack align(@max(
-                    @alignOf(std.heap.StackFallbackAllocator(0)),
-                    @alignOf(ExpectedContents),
-                )) = std.heap.stackFallback(@sizeOf(ExpectedContents), allocator);
-                const stack_allocator = stack.get();
-                const field_ctypes = try stack_allocator.alloc(CType, fields.len);
-                defer stack_allocator.free(field_ctypes);
-                for (field_ctypes, fields) |*field_ctype, field|
-                    field_ctype.* = try field.ctype.toForward(pool, allocator);
-                const extra: FwdDeclAnon = .{ .fields_len = @intCast(fields.len) };
-                const extra_index = try pool.addExtra(
-                    allocator,
-                    FwdDeclAnon,
-                    extra,
-                    fields.len * @typeInfo(Field).@"struct".fields.len,
-                );
-                for (fields, field_ctypes) |field, field_ctype| pool.addHashedExtraAssumeCapacity(
-                    &hasher,
-                    Field,
-                    .{
-                        .name = field.name.index,
-                        .ctype = field_ctype.index,
-                        .flags = .{ .alignas = field.alignas },
-                    },
-                );
-                hasher.updateExtra(FwdDeclAnon, extra, pool);
-                return pool.tagTrailingExtra(allocator, hasher, switch (fwd_decl_info.tag) {
-                    .@"struct" => .fwd_decl_struct_anon,
-                    .@"union" => .fwd_decl_union_anon,
-                    .@"enum" => unreachable,
-                }, extra_index);
-            },
-            .index => |index| {
-                hasher.update(index);
-                return pool.tagData(allocator, hasher, switch (fwd_decl_info.tag) {
-                    .@"struct" => .fwd_decl_struct,
-                    .@"union" => .fwd_decl_union,
-                    .@"enum" => unreachable,
-                }, @intFromEnum(index));
-            },
-        }
-    }
-
-    pub fn getAggregate(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        aggregate_info: struct {
-            tag: Info.AggregateTag,
-            @"packed": bool = false,
-            name: union(enum) {
-                anon: struct {
-                    index: InternPool.Index,
-                    id: u32,
-                },
-                fwd_decl: CType,
-            },
-            fields: []const Info.Field,
-        },
-    ) !CType {
-        var hasher = Hasher.init;
-        switch (aggregate_info.name) {
-            .anon => |anon| {
-                const extra: AggregateAnon = .{
-                    .index = anon.index,
-                    .id = anon.id,
-                    .fields_len = @intCast(aggregate_info.fields.len),
-                };
-                const extra_index = try pool.addExtra(
-                    allocator,
-                    AggregateAnon,
-                    extra,
-                    aggregate_info.fields.len * @typeInfo(Field).@"struct".fields.len,
-                );
-                for (aggregate_info.fields) |field| pool.addHashedExtraAssumeCapacity(&hasher, Field, .{
-                    .name = field.name.index,
-                    .ctype = field.ctype.index,
-                    .flags = .{ .alignas = field.alignas },
-                });
-                hasher.updateExtra(AggregateAnon, extra, pool);
-                return pool.tagTrailingExtra(allocator, hasher, switch (aggregate_info.tag) {
-                    .@"struct" => switch (aggregate_info.@"packed") {
-                        false => .aggregate_struct_anon,
-                        true => .aggregate_struct_packed_anon,
-                    },
-                    .@"union" => switch (aggregate_info.@"packed") {
-                        false => .aggregate_union_anon,
-                        true => .aggregate_union_packed_anon,
-                    },
-                    .@"enum" => unreachable,
-                }, extra_index);
-            },
-            .fwd_decl => |fwd_decl| {
-                const extra: Aggregate = .{
-                    .fwd_decl = fwd_decl.index,
-                    .fields_len = @intCast(aggregate_info.fields.len),
-                };
-                const extra_index = try pool.addExtra(
-                    allocator,
-                    Aggregate,
-                    extra,
-                    aggregate_info.fields.len * @typeInfo(Field).@"struct".fields.len,
-                );
-                for (aggregate_info.fields) |field| pool.addHashedExtraAssumeCapacity(&hasher, Field, .{
-                    .name = field.name.index,
-                    .ctype = field.ctype.index,
-                    .flags = .{ .alignas = field.alignas },
-                });
-                hasher.updateExtra(Aggregate, extra, pool);
-                return pool.tagTrailingExtra(allocator, hasher, switch (aggregate_info.tag) {
-                    .@"struct" => switch (aggregate_info.@"packed") {
-                        false => .aggregate_struct,
-                        true => .aggregate_struct_packed,
-                    },
-                    .@"union" => switch (aggregate_info.@"packed") {
-                        false => .aggregate_union,
-                        true => .aggregate_union_packed,
-                    },
-                    .@"enum" => unreachable,
-                }, extra_index);
-            },
-        }
-    }
-
-    pub fn getFunction(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        function_info: struct {
-            return_ctype: CType,
-            param_ctypes: []const CType,
-            varargs: bool = false,
-        },
-    ) !CType {
-        var hasher = Hasher.init;
-        const extra: Function = .{
-            .return_ctype = function_info.return_ctype.index,
-            .param_ctypes_len = @intCast(function_info.param_ctypes.len),
-        };
-        const extra_index = try pool.addExtra(allocator, Function, extra, function_info.param_ctypes.len);
-        for (function_info.param_ctypes) |param_ctype| {
-            hasher.update(param_ctype.hash(pool));
-            pool.extra.appendAssumeCapacity(@intFromEnum(param_ctype.index));
-        }
-        hasher.updateExtra(Function, extra, pool);
-        return pool.tagTrailingExtra(allocator, hasher, switch (function_info.varargs) {
-            false => .function,
-            true => .function_varargs,
-        }, extra_index);
-    }
-
-    pub fn fromFields(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        tag: Info.AggregateTag,
-        fields: []Info.Field,
-        kind: Kind,
-    ) !CType {
-        sortFields(fields);
-        const fwd_decl = try pool.getFwdDecl(allocator, .{
-            .tag = tag,
-            .name = .{ .anon = fields },
-        });
-        return if (kind.isForward()) fwd_decl else pool.getAggregate(allocator, .{
-            .tag = tag,
-            .name = .{ .fwd_decl = fwd_decl },
-            .fields = fields,
-        });
-    }
-
-    pub fn fromIntInfo(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        int_info: std.builtin.Type.Int,
-        mod: *Module,
-        kind: Kind,
-    ) !CType {
-        switch (int_info.bits) {
-            0 => return .void,
-            1...8 => switch (int_info.signedness) {
-                .signed => return .i8,
-                .unsigned => return .u8,
-            },
-            9...16 => switch (int_info.signedness) {
-                .signed => return .i16,
-                .unsigned => return .u16,
-            },
-            17...32 => switch (int_info.signedness) {
-                .signed => return .i32,
-                .unsigned => return .u32,
-            },
-            33...64 => switch (int_info.signedness) {
-                .signed => return .i64,
-                .unsigned => return .u64,
-            },
-            65...128 => switch (int_info.signedness) {
-                .signed => return .i128,
-                .unsigned => return .u128,
-            },
-            else => {
-                const target = &mod.resolved_target.result;
-                const abi_align_bytes = std.zig.target.intAlignment(target, int_info.bits);
-                const limb_ctype = try pool.fromIntInfo(allocator, .{
-                    .signedness = .unsigned,
-                    .bits = @intCast(abi_align_bytes * 8),
-                }, mod, kind.noParameter());
-                const array_ctype = try pool.getArray(allocator, .{
-                    .len = @divExact(std.zig.target.intByteSize(target, int_info.bits), abi_align_bytes),
-                    .elem_ctype = limb_ctype,
-                    .nonstring = limb_ctype.isAnyChar(),
-                });
-                if (!kind.isParameter()) return array_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = array_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(.fromByteUnits(abi_align_bytes)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-        }
-    }
-
-    pub fn fromType(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        scratch: *std.ArrayList(u32),
-        ty: Type,
-        pt: Zcu.PerThread,
-        mod: *Module,
-        kind: Kind,
-    ) !CType {
-        const ip = &pt.zcu.intern_pool;
-        const zcu = pt.zcu;
-        switch (ty.toIntern()) {
-            .u0_type,
-            .i0_type,
-            .anyopaque_type,
-            .void_type,
-            .empty_tuple_type,
-            .type_type,
-            .comptime_int_type,
-            .comptime_float_type,
-            .null_type,
-            .undefined_type,
-            .enum_literal_type,
-            .optional_type_type,
-            .manyptr_const_type_type,
-            .slice_const_type_type,
-            => return .void,
-            .u1_type, .u8_type => return .u8,
-            .i8_type => return .i8,
-            .u16_type => return .u16,
-            .i16_type => return .i16,
-            .u29_type, .u32_type => return .u32,
-            .i32_type => return .i32,
-            .u64_type => return .u64,
-            .i64_type => return .i64,
-            .u80_type, .u128_type => return .u128,
-            .i128_type => return .i128,
-            .u256_type => return pool.fromIntInfo(allocator, .{
-                .signedness = .unsigned,
-                .bits = 256,
-            }, mod, kind),
-            .usize_type => return .usize,
-            .isize_type => return .isize,
-            .c_char_type => return .{ .index = .char },
-            .c_short_type => return .{ .index = .short },
-            .c_ushort_type => return .{ .index = .@"unsigned short" },
-            .c_int_type => return .{ .index = .int },
-            .c_uint_type => return .{ .index = .@"unsigned int" },
-            .c_long_type => return .{ .index = .long },
-            .c_ulong_type => return .{ .index = .@"unsigned long" },
-            .c_longlong_type => return .{ .index = .@"long long" },
-            .c_ulonglong_type => return .{ .index = .@"unsigned long long" },
-            .c_longdouble_type => return .{ .index = .@"long double" },
-            .f16_type => return .f16,
-            .f32_type => return .f32,
-            .f64_type => return .f64,
-            .f80_type => return .f80,
-            .f128_type => return .f128,
-            .bool_type, .optional_noreturn_type => return .bool,
-            .noreturn_type,
-            .anyframe_type,
-            .generic_poison_type,
-            => unreachable,
-            .anyerror_type,
-            .anyerror_void_error_union_type,
-            .adhoc_inferred_error_set_type,
-            => return pool.fromIntInfo(allocator, .{
-                .signedness = .unsigned,
-                .bits = pt.zcu.errorSetBits(),
-            }, mod, kind),
-
-            .ptr_usize_type => return pool.getPointer(allocator, .{
-                .elem_ctype = .usize,
-            }),
-            .ptr_const_comptime_int_type => return pool.getPointer(allocator, .{
-                .elem_ctype = .void,
-                .@"const" = true,
-            }),
-            .manyptr_u8_type => return pool.getPointer(allocator, .{
-                .elem_ctype = .u8,
-                .nonstring = true,
-            }),
-            .manyptr_const_u8_type => return pool.getPointer(allocator, .{
-                .elem_ctype = .u8,
-                .@"const" = true,
-                .nonstring = true,
-            }),
-            .manyptr_const_u8_sentinel_0_type => return pool.getPointer(allocator, .{
-                .elem_ctype = .u8,
-                .@"const" = true,
-            }),
-            .slice_const_u8_type => {
-                const target = &mod.resolved_target.result;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .ptr },
-                        .ctype = try pool.getPointer(allocator, .{
-                            .elem_ctype = .u8,
-                            .@"const" = true,
-                            .nonstring = true,
-                        }),
-                        .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)),
-                    },
-                    .{
-                        .name = .{ .index = .len },
-                        .ctype = .usize,
-                        .alignas = AlignAs.fromAbiAlignment(
-                            .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
-                        ),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .slice_const_u8_sentinel_0_type => {
-                const target = &mod.resolved_target.result;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .ptr },
-                        .ctype = try pool.getPointer(allocator, .{
-                            .elem_ctype = .u8,
-                            .@"const" = true,
-                        }),
-                        .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)),
-                    },
-                    .{
-                        .name = .{ .index = .len },
-                        .ctype = .usize,
-                        .alignas = AlignAs.fromAbiAlignment(
-                            .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
-                        ),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-
-            .manyptr_const_slice_const_u8_type => {
-                const target = &mod.resolved_target.result;
-                var fields: [2]Info.Field = .{
-                    .{
-                        .name = .{ .index = .ptr },
-                        .ctype = try pool.getPointer(allocator, .{
-                            .elem_ctype = .u8,
-                            .@"const" = true,
-                            .nonstring = true,
-                        }),
-                        .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)),
-                    },
-                    .{
-                        .name = .{ .index = .len },
-                        .ctype = .usize,
-                        .alignas = AlignAs.fromAbiAlignment(
-                            .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
-                        ),
-                    },
-                };
-                const slice_const_u8 = try pool.fromFields(allocator, .@"struct", &fields, kind);
-                return pool.getPointer(allocator, .{
-                    .elem_ctype = slice_const_u8,
-                    .@"const" = true,
-                });
-            },
-            .slice_const_slice_const_u8_type => {
-                const target = &mod.resolved_target.result;
-                var fields: [2]Info.Field = .{
-                    .{
-                        .name = .{ .index = .ptr },
-                        .ctype = try pool.getPointer(allocator, .{
-                            .elem_ctype = .u8,
-                            .@"const" = true,
-                            .nonstring = true,
-                        }),
-                        .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)),
-                    },
-                    .{
-                        .name = .{ .index = .len },
-                        .ctype = .usize,
-                        .alignas = AlignAs.fromAbiAlignment(
-                            .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
-                        ),
-                    },
-                };
-                const slice_const_u8 = try pool.fromFields(allocator, .@"struct", &fields, .forward);
-                fields = .{
-                    .{
-                        .name = .{ .index = .ptr },
-                        .ctype = try pool.getPointer(allocator, .{
-                            .elem_ctype = slice_const_u8,
-                            .@"const" = true,
-                        }),
-                        .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)),
-                    },
-                    .{
-                        .name = .{ .index = .len },
-                        .ctype = .usize,
-                        .alignas = AlignAs.fromAbiAlignment(
-                            .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
-                        ),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-
-            .vector_8_i8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i8,
-                    .len = 8,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_i8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i8,
-                    .len = 16,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_32_i8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i8,
-                    .len = 32,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_64_i8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i8,
-                    .len = 64,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_1_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 1,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 2,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 4,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 8,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 16,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_32_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 32,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_64_u8_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u8,
-                    .len = 64,
-                    .nonstring = true,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_i16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i16,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_i16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i16,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_i16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i16,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_i16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i16,
-                    .len = 16,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_32_i16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i16,
-                    .len = 32,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_u16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u16,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_u16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u16,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_u16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u16,
-                    .len = 16,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_32_u16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u16,
-                    .len = 32,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_i32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i32,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_i32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i32,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_i32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i32,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_i32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i32,
-                    .len = 16,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_u32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u32,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_u32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u32,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_u32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u32,
-                    .len = 16,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_i64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i64,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_i64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i64,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_i64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .i64,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.i64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_u64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u64,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_u64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u64,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_u64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u64,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_1_u128_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u128,
-                    .len = 1,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u128.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_u128_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .u128,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u128.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_1_u256_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = try pool.fromIntInfo(allocator, .{
-                        .signedness = .unsigned,
-                        .bits = 256,
-                    }, mod, kind),
-                    .len = 1,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.u256.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_f16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f16,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_f16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f16,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_f16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f16,
-                    .len = 16,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_32_f16_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f16,
-                    .len = 32,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f16.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_f32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f32,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_f32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f32,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_f32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f32,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_16_f32_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f32,
-                    .len = 16,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f32.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_2_f64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f64,
-                    .len = 2,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_4_f64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f64,
-                    .len = 4,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-            .vector_8_f64_type => {
-                const vector_ctype = try pool.getVector(allocator, .{
-                    .elem_ctype = .f64,
-                    .len = 8,
-                });
-                if (!kind.isParameter()) return vector_ctype;
-                var fields = [_]Info.Field{
-                    .{
-                        .name = .{ .index = .array },
-                        .ctype = vector_ctype,
-                        .alignas = AlignAs.fromAbiAlignment(Type.f64.abiAlignment(zcu)),
-                    },
-                };
-                return pool.fromFields(allocator, .@"struct", &fields, kind);
-            },
-
-            .undef,
-            .undef_bool,
-            .undef_usize,
-            .undef_u1,
-            .zero,
-            .zero_usize,
-            .zero_u1,
-            .zero_u8,
-            .one,
-            .one_usize,
-            .one_u1,
-            .one_u8,
-            .four_u8,
-            .negative_one,
-            .void_value,
-            .unreachable_value,
-            .null_value,
-            .bool_true,
-            .bool_false,
-            .empty_tuple,
-            .none,
-            => unreachable, // values, not types
-
-            _ => |ip_index| switch (ip.indexToKey(ip_index)) {
-                .int_type => |int_info| return pool.fromIntInfo(allocator, int_info, mod, kind),
-                .ptr_type => |ptr_info| switch (ptr_info.flags.size) {
-                    .one, .many, .c => {
-                        const elem_ctype = elem_ctype: {
-                            if (ptr_info.packed_offset.host_size > 0 and
-                                ptr_info.flags.vector_index == .none)
-                                break :elem_ctype try pool.fromIntInfo(allocator, .{
-                                    .signedness = .unsigned,
-                                    .bits = ptr_info.packed_offset.host_size * 8,
-                                }, mod, .forward);
-                            const elem: Info.Aligned = .{
-                                .ctype = try pool.fromType(
-                                    allocator,
-                                    scratch,
-                                    Type.fromInterned(ptr_info.child),
-                                    pt,
-                                    mod,
-                                    .forward,
-                                ),
-                                .alignas = AlignAs.fromAlignment(.{
-                                    .@"align" = ptr_info.flags.alignment,
-                                    .abi = Type.fromInterned(ptr_info.child).abiAlignment(zcu),
-                                }),
-                            };
-                            break :elem_ctype if (elem.alignas.abiOrder().compare(.gte))
-                                elem.ctype
-                            else
-                                try pool.getAligned(allocator, elem);
-                        };
-                        const elem_tag: Info.Tag = switch (elem_ctype.info(pool)) {
-                            .aligned => |aligned_info| aligned_info.ctype.info(pool),
-                            else => |elem_tag| elem_tag,
-                        };
-                        return pool.getPointer(allocator, .{
-                            .elem_ctype = elem_ctype,
-                            .@"const" = switch (elem_tag) {
-                                .basic,
-                                .pointer,
-                                .aligned,
-                                .array,
-                                .vector,
-                                .fwd_decl,
-                                .aggregate,
-                                => ptr_info.flags.is_const,
-                                .function => false,
-                            },
-                            .@"volatile" = ptr_info.flags.is_volatile,
-                            .nonstring = elem_ctype.isAnyChar() and switch (ptr_info.sentinel) {
-                                .none => true,
-                                .zero_u8 => false,
-                                else => |sentinel| !Value.fromInterned(sentinel).compareAllWithZero(.eq, zcu),
-                            },
-                        });
-                    },
-                    .slice => {
-                        const target = &mod.resolved_target.result;
-                        var fields = [_]Info.Field{
-                            .{
-                                .name = .{ .index = .ptr },
-                                .ctype = try pool.fromType(
-                                    allocator,
-                                    scratch,
-                                    Type.fromInterned(ip.slicePtrType(ip_index)),
-                                    pt,
-                                    mod,
-                                    kind,
-                                ),
-                                .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)),
-                            },
-                            .{
-                                .name = .{ .index = .len },
-                                .ctype = .usize,
-                                .alignas = AlignAs.fromAbiAlignment(
-                                    .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())),
-                                ),
-                            },
-                        };
-                        return pool.fromFields(allocator, .@"struct", &fields, kind);
-                    },
-                },
-                .array_type => |array_info| {
-                    const len = array_info.lenIncludingSentinel();
-                    if (len == 0) return .void;
-                    const elem_type = Type.fromInterned(array_info.child);
-                    const elem_ctype = try pool.fromType(
-                        allocator,
-                        scratch,
-                        elem_type,
-                        pt,
-                        mod,
-                        kind.noParameter().asComplete(),
-                    );
-                    if (elem_ctype.index == .void) return .void;
-                    const array_ctype = try pool.getArray(allocator, .{
-                        .elem_ctype = elem_ctype,
-                        .len = len,
-                        .nonstring = elem_ctype.isAnyChar() and switch (array_info.sentinel) {
-                            .none => true,
-                            .zero_u8 => false,
-                            else => |sentinel| !Value.fromInterned(sentinel).compareAllWithZero(.eq, zcu),
-                        },
-                    });
-                    if (!kind.isParameter()) return array_ctype;
-                    var fields = [_]Info.Field{
-                        .{
-                            .name = .{ .index = .array },
-                            .ctype = array_ctype,
-                            .alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(zcu)),
-                        },
-                    };
-                    return pool.fromFields(allocator, .@"struct", &fields, kind);
-                },
-                .vector_type => |vector_info| {
-                    if (vector_info.len == 0) return .void;
-                    const elem_type = Type.fromInterned(vector_info.child);
-                    const elem_ctype = try pool.fromType(
-                        allocator,
-                        scratch,
-                        elem_type,
-                        pt,
-                        mod,
-                        kind.noParameter().asComplete(),
-                    );
-                    if (elem_ctype.index == .void) return .void;
-                    const vector_ctype = try pool.getVector(allocator, .{
-                        .elem_ctype = elem_ctype,
-                        .len = vector_info.len,
-                        .nonstring = elem_ctype.isAnyChar(),
-                    });
-                    if (!kind.isParameter()) return vector_ctype;
-                    var fields = [_]Info.Field{
-                        .{
-                            .name = .{ .index = .array },
-                            .ctype = vector_ctype,
-                            .alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(zcu)),
-                        },
-                    };
-                    return pool.fromFields(allocator, .@"struct", &fields, kind);
-                },
-                .opt_type => |payload_type| {
-                    if (Type.fromInterned(payload_type).isNoReturn(zcu)) return .void;
-                    const payload_ctype = try pool.fromType(
-                        allocator,
-                        scratch,
-                        Type.fromInterned(payload_type),
-                        pt,
-                        mod,
-                        kind.noParameter(),
-                    );
-                    if (payload_ctype.index == .void) return .bool;
-                    switch (payload_type) {
-                        .anyerror_type => return payload_ctype,
-                        else => switch (ip.indexToKey(payload_type)) {
-                            .ptr_type => |payload_ptr_info| if (payload_ptr_info.flags.size != .c and
-                                !payload_ptr_info.flags.is_allowzero) return payload_ctype,
-                            .error_set_type, .inferred_error_set_type => return payload_ctype,
-                            else => {},
-                        },
-                    }
-                    var fields = [_]Info.Field{
-                        .{
-                            .name = .{ .index = .is_null },
-                            .ctype = .bool,
-                            .alignas = AlignAs.fromAbiAlignment(.@"1"),
-                        },
-                        .{
-                            .name = .{ .index = .payload },
-                            .ctype = payload_ctype,
-                            .alignas = AlignAs.fromAbiAlignment(
-                                Type.fromInterned(payload_type).abiAlignment(zcu),
-                            ),
-                        },
-                    };
-                    return pool.fromFields(allocator, .@"struct", &fields, kind);
-                },
-                .anyframe_type => unreachable,
-                .error_union_type => |error_union_info| {
-                    const error_set_bits = pt.zcu.errorSetBits();
-                    const error_set_ctype = try pool.fromIntInfo(allocator, .{
-                        .signedness = .unsigned,
-                        .bits = error_set_bits,
-                    }, mod, kind);
-                    if (Type.fromInterned(error_union_info.payload_type).isNoReturn(zcu)) return error_set_ctype;
-                    const payload_type = Type.fromInterned(error_union_info.payload_type);
-                    const payload_ctype = try pool.fromType(
-                        allocator,
-                        scratch,
-                        payload_type,
-                        pt,
-                        mod,
-                        kind.noParameter(),
-                    );
-                    if (payload_ctype.index == .void) return error_set_ctype;
-                    const target = &mod.resolved_target.result;
-                    var fields = [_]Info.Field{
-                        .{
-                            .name = .{ .index = .@"error" },
-                            .ctype = error_set_ctype,
-                            .alignas = AlignAs.fromAbiAlignment(
-                                .fromByteUnits(std.zig.target.intAlignment(target, error_set_bits)),
-                            ),
-                        },
-                        .{
-                            .name = .{ .index = .payload },
-                            .ctype = payload_ctype,
-                            .alignas = AlignAs.fromAbiAlignment(payload_type.abiAlignment(zcu)),
-                        },
-                    };
-                    return pool.fromFields(allocator, .@"struct", &fields, kind);
-                },
-                .simple_type => unreachable,
-                .struct_type => {
-                    const loaded_struct = ip.loadStructType(ip_index);
-                    switch (loaded_struct.layout) {
-                        .auto, .@"extern" => {
-                            const fwd_decl = try pool.getFwdDecl(allocator, .{
-                                .tag = .@"struct",
-                                .name = .{ .index = ip_index },
-                            });
-                            if (kind.isForward()) return if (ty.hasRuntimeBits(zcu))
-                                fwd_decl
-                            else
-                                .void;
-                            const scratch_top = scratch.items.len;
-                            defer scratch.shrinkRetainingCapacity(scratch_top);
-                            try scratch.ensureUnusedCapacity(
-                                allocator,
-                                loaded_struct.field_types.len * @typeInfo(Field).@"struct".fields.len,
-                            );
-                            var hasher = Hasher.init;
-                            var tag: Pool.Tag = .aggregate_struct;
-                            var field_it = loaded_struct.iterateRuntimeOrder(ip);
-                            while (field_it.next()) |field_index| {
-                                const field_type = Type.fromInterned(
-                                    loaded_struct.field_types.get(ip)[field_index],
-                                );
-                                const field_ctype = try pool.fromType(
-                                    allocator,
-                                    scratch,
-                                    field_type,
-                                    pt,
-                                    mod,
-                                    kind.noParameter(),
-                                );
-                                if (field_ctype.index == .void) continue;
-                                const field_name = try pool.string(allocator, loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
-                                const field_alignas = AlignAs.fromAlignment(.{
-                                    .@"align" = loaded_struct.field_aligns.getOrNone(ip, field_index),
-                                    .abi = field_type.abiAlignment(zcu),
-                                });
-                                pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
-                                    .name = field_name.index,
-                                    .ctype = field_ctype.index,
-                                    .flags = .{ .alignas = field_alignas },
-                                });
-                                if (field_alignas.abiOrder().compare(.lt))
-                                    tag = .aggregate_struct_packed;
-                            }
-                            const fields_len: u32 = @intCast(@divExact(
-                                scratch.items.len - scratch_top,
-                                @typeInfo(Field).@"struct".fields.len,
-                            ));
-                            if (fields_len == 0) return .void;
-                            try pool.ensureUnusedCapacity(allocator, 1);
-                            const extra_index = try pool.addHashedExtra(allocator, &hasher, Aggregate, .{
-                                .fwd_decl = fwd_decl.index,
-                                .fields_len = fields_len,
-                            }, fields_len * @typeInfo(Field).@"struct".fields.len);
-                            pool.extra.appendSliceAssumeCapacity(scratch.items[scratch_top..]);
-                            return pool.tagTrailingExtraAssumeCapacity(hasher, tag, extra_index);
-                        },
-                        .@"packed" => return pool.fromType(
-                            allocator,
-                            scratch,
-                            .fromInterned(loaded_struct.packed_backing_int_type),
-                            pt,
-                            mod,
-                            kind,
-                        ),
-                    }
-                },
-                .tuple_type => |tuple_info| {
-                    const scratch_top = scratch.items.len;
-                    defer scratch.shrinkRetainingCapacity(scratch_top);
-                    try scratch.ensureUnusedCapacity(allocator, tuple_info.types.len *
-                        @typeInfo(Field).@"struct".fields.len);
-                    var hasher = Hasher.init;
-                    for (0..tuple_info.types.len) |field_index| {
-                        if (tuple_info.values.get(ip)[field_index] != .none) continue;
-                        const field_type = Type.fromInterned(
-                            tuple_info.types.get(ip)[field_index],
-                        );
-                        const field_ctype = try pool.fromType(
-                            allocator,
-                            scratch,
-                            field_type,
-                            pt,
-                            mod,
-                            kind.noParameter(),
-                        );
-                        if (field_ctype.index == .void) continue;
-                        const field_name = try pool.fmt(allocator, "f{d}", .{field_index});
-                        pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
-                            .name = field_name.index,
-                            .ctype = field_ctype.index,
-                            .flags = .{ .alignas = AlignAs.fromAbiAlignment(
-                                field_type.abiAlignment(zcu),
-                            ) },
-                        });
-                    }
-                    const fields_len: u32 = @intCast(@divExact(
-                        scratch.items.len - scratch_top,
-                        @typeInfo(Field).@"struct".fields.len,
-                    ));
-                    if (fields_len == 0) return .void;
-                    if (kind.isForward()) {
-                        try pool.ensureUnusedCapacity(allocator, 1);
-                        const extra_index = try pool.addHashedExtra(
-                            allocator,
-                            &hasher,
-                            FwdDeclAnon,
-                            .{ .fields_len = fields_len },
-                            fields_len * @typeInfo(Field).@"struct".fields.len,
-                        );
-                        pool.extra.appendSliceAssumeCapacity(scratch.items[scratch_top..]);
-                        return pool.tagTrailingExtra(
-                            allocator,
-                            hasher,
-                            .fwd_decl_struct_anon,
-                            extra_index,
-                        );
-                    }
-                    const fwd_decl = try pool.fromType(allocator, scratch, ty, pt, mod, .forward);
-                    try pool.ensureUnusedCapacity(allocator, 1);
-                    const extra_index = try pool.addHashedExtra(allocator, &hasher, Aggregate, .{
-                        .fwd_decl = fwd_decl.index,
-                        .fields_len = fields_len,
-                    }, fields_len * @typeInfo(Field).@"struct".fields.len);
-                    pool.extra.appendSliceAssumeCapacity(scratch.items[scratch_top..]);
-                    return pool.tagTrailingExtraAssumeCapacity(hasher, .aggregate_struct, extra_index);
-                },
-                .union_type => {
-                    const loaded_union = ip.loadUnionType(ip_index);
-                    switch (loaded_union.layout) {
-                        .auto, .@"extern" => {
-                            const fwd_decl = try pool.getFwdDecl(allocator, .{
-                                .tag = if (loaded_union.has_runtime_tag) .@"struct" else .@"union",
-                                .name = .{ .index = ip_index },
-                            });
-                            if (kind.isForward()) return if (ty.hasRuntimeBits(zcu))
-                                fwd_decl
-                            else
-                                .void;
-                            const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
-                            const scratch_top = scratch.items.len;
-                            defer scratch.shrinkRetainingCapacity(scratch_top);
-                            try scratch.ensureUnusedCapacity(
-                                allocator,
-                                loaded_union.field_types.len * @typeInfo(Field).@"struct".fields.len,
-                            );
-                            var hasher = Hasher.init;
-                            var tag: Pool.Tag = .aggregate_union;
-                            var payload_align: InternPool.Alignment = .@"1";
-                            for (0..loaded_union.field_types.len) |field_index| {
-                                const field_type = Type.fromInterned(
-                                    loaded_union.field_types.get(ip)[field_index],
-                                );
-                                if (field_type.isNoReturn(zcu)) continue;
-                                const field_ctype = try pool.fromType(
-                                    allocator,
-                                    scratch,
-                                    field_type,
-                                    pt,
-                                    mod,
-                                    kind.noParameter(),
-                                );
-                                if (field_ctype.index == .void) continue;
-                                const field_name = try pool.string(
-                                    allocator,
-                                    loaded_tag.field_names.get(ip)[field_index].toSlice(ip),
-                                );
-                                const field_alignas = AlignAs.fromAlignment(.{
-                                    .@"align" = loaded_union.field_aligns.getOrNone(ip, field_index),
-                                    .abi = field_type.abiAlignment(zcu),
-                                });
-                                pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
-                                    .name = field_name.index,
-                                    .ctype = field_ctype.index,
-                                    .flags = .{ .alignas = field_alignas },
-                                });
-                                if (field_alignas.abiOrder().compare(.lt))
-                                    tag = .aggregate_union_packed;
-                                payload_align = payload_align.maxStrict(field_alignas.@"align");
-                            }
-                            const fields_len: u32 = @intCast(@divExact(
-                                scratch.items.len - scratch_top,
-                                @typeInfo(Field).@"struct".fields.len,
-                            ));
-                            if (!loaded_union.has_runtime_tag) {
-                                if (fields_len == 0) return .void;
-                                try pool.ensureUnusedCapacity(allocator, 1);
-                                const extra_index = try pool.addHashedExtra(
-                                    allocator,
-                                    &hasher,
-                                    Aggregate,
-                                    .{ .fwd_decl = fwd_decl.index, .fields_len = fields_len },
-                                    fields_len * @typeInfo(Field).@"struct".fields.len,
-                                );
-                                pool.extra.appendSliceAssumeCapacity(scratch.items[scratch_top..]);
-                                return pool.tagTrailingExtraAssumeCapacity(hasher, tag, extra_index);
-                            }
-                            try pool.ensureUnusedCapacity(allocator, 2);
-                            var struct_fields: [2]Info.Field = undefined;
-                            var struct_fields_len: usize = 0;
-                            const tag_type = Type.fromInterned(loaded_tag.int_tag_type);
-                            const tag_ctype: CType = try pool.fromType(
-                                allocator,
-                                scratch,
-                                tag_type,
-                                pt,
-                                mod,
-                                kind.noParameter(),
-                            );
-                            if (tag_ctype.index != .void) {
-                                struct_fields[struct_fields_len] = .{
-                                    .name = .{ .index = .tag },
-                                    .ctype = tag_ctype,
-                                    .alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
-                                };
-                                struct_fields_len += 1;
-                            }
-                            if (fields_len > 0) {
-                                const payload_ctype = payload_ctype: {
-                                    const extra_index = try pool.addHashedExtra(
-                                        allocator,
-                                        &hasher,
-                                        AggregateAnon,
-                                        .{
-                                            .index = ip_index,
-                                            .id = 0,
-                                            .fields_len = fields_len,
-                                        },
-                                        fields_len * @typeInfo(Field).@"struct".fields.len,
-                                    );
-                                    pool.extra.appendSliceAssumeCapacity(scratch.items[scratch_top..]);
-                                    break :payload_ctype pool.tagTrailingExtraAssumeCapacity(
-                                        hasher,
-                                        switch (tag) {
-                                            .aggregate_union => .aggregate_union_anon,
-                                            .aggregate_union_packed => .aggregate_union_packed_anon,
-                                            else => unreachable,
-                                        },
-                                        extra_index,
-                                    );
-                                };
-                                if (payload_ctype.index != .void) {
-                                    struct_fields[struct_fields_len] = .{
-                                        .name = .{ .index = .payload },
-                                        .ctype = payload_ctype,
-                                        .alignas = AlignAs.fromAbiAlignment(payload_align),
-                                    };
-                                    struct_fields_len += 1;
-                                }
-                            }
-                            if (struct_fields_len == 0) return .void;
-                            sortFields(struct_fields[0..struct_fields_len]);
-                            return pool.getAggregate(allocator, .{
-                                .tag = .@"struct",
-                                .name = .{ .fwd_decl = fwd_decl },
-                                .fields = struct_fields[0..struct_fields_len],
-                            });
-                        },
-                        .@"packed" => return pool.fromIntInfo(allocator, .{
-                            .signedness = .unsigned,
-                            .bits = @intCast(ty.bitSize(zcu)),
-                        }, mod, kind),
-                    }
-                },
-                .opaque_type => return .void,
-                .enum_type => return pool.fromType(
-                    allocator,
-                    scratch,
-                    .fromInterned(ip.loadEnumType(ip_index).int_tag_type),
-                    pt,
-                    mod,
-                    kind,
-                ),
-                .func_type => |func_info| {
-                    if (!ty.fnHasRuntimeBits(zcu)) return .void;
-
-                    const scratch_top = scratch.items.len;
-                    defer scratch.shrinkRetainingCapacity(scratch_top);
-                    try scratch.ensureUnusedCapacity(allocator, func_info.param_types.len);
-                    var hasher = Hasher.init;
-                    const return_type = Type.fromInterned(func_info.return_type);
-                    const return_ctype: CType =
-                        if (!Type.fromInterned(func_info.return_type).isNoReturn(zcu)) try pool.fromType(
-                            allocator,
-                            scratch,
-                            return_type,
-                            pt,
-                            mod,
-                            kind.asParameter(),
-                        ) else .void;
-                    for (0..func_info.param_types.len) |param_index| {
-                        const param_type = Type.fromInterned(
-                            func_info.param_types.get(ip)[param_index],
-                        );
-                        const param_ctype = try pool.fromType(
-                            allocator,
-                            scratch,
-                            param_type,
-                            pt,
-                            mod,
-                            kind.asParameter(),
-                        );
-                        if (param_ctype.index == .void) continue;
-                        hasher.update(param_ctype.hash(pool));
-                        scratch.appendAssumeCapacity(@intFromEnum(param_ctype.index));
-                    }
-                    const param_ctypes_len: u32 = @intCast(scratch.items.len - scratch_top);
-                    try pool.ensureUnusedCapacity(allocator, 1);
-                    const extra_index = try pool.addHashedExtra(allocator, &hasher, Function, .{
-                        .return_ctype = return_ctype.index,
-                        .param_ctypes_len = param_ctypes_len,
-                    }, param_ctypes_len);
-                    pool.extra.appendSliceAssumeCapacity(scratch.items[scratch_top..]);
-                    return pool.tagTrailingExtraAssumeCapacity(hasher, switch (func_info.is_var_args) {
-                        false => .function,
-                        true => .function_varargs,
-                    }, extra_index);
-                },
-                .error_set_type,
-                .inferred_error_set_type,
-                => return pool.fromIntInfo(allocator, .{
-                    .signedness = .unsigned,
-                    .bits = pt.zcu.errorSetBits(),
-                }, mod, kind),
-
-                .undef,
-                .simple_value,
-                .variable,
-                .@"extern",
-                .func,
-                .int,
-                .err,
-                .error_union,
-                .enum_literal,
-                .enum_tag,
-                .float,
-                .ptr,
-                .slice,
-                .opt,
-                .aggregate,
-                .un,
-                .bitpack,
-                .memoized_call,
-                => unreachable, // values, not types
-            },
-        }
-    }
-
-    pub fn getOrPutAdapted(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        source_pool: *const Pool,
-        source_ctype: CType,
-        pool_adapter: anytype,
-    ) !struct { CType, bool } {
-        const tag = source_pool.items.items(.tag)[
-            source_ctype.toPoolIndex() orelse return .{ source_ctype, true }
-        ];
-        try pool.ensureUnusedCapacity(allocator, 1);
-        const CTypeAdapter = struct {
-            pool: *const Pool,
-            source_pool: *const Pool,
-            source_info: Info,
-            pool_adapter: @TypeOf(pool_adapter),
-            pub fn hash(map_adapter: @This(), key_ctype: CType) Map.Hash {
-                return key_ctype.hash(map_adapter.source_pool);
-            }
-            pub fn eql(map_adapter: @This(), _: CType, _: void, pool_index: usize) bool {
-                return map_adapter.source_info.eqlAdapted(
-                    map_adapter.source_pool,
-                    .fromPoolIndex(pool_index),
-                    map_adapter.pool,
-                    map_adapter.pool_adapter,
-                );
-            }
-        };
-        const source_info = source_ctype.info(source_pool);
-        const gop = pool.map.getOrPutAssumeCapacityAdapted(source_ctype, CTypeAdapter{
-            .pool = pool,
-            .source_pool = source_pool,
-            .source_info = source_info,
-            .pool_adapter = pool_adapter,
-        });
-        errdefer _ = pool.map.pop();
-        const ctype: CType = .fromPoolIndex(gop.index);
-        if (!gop.found_existing) switch (source_info) {
-            .basic => unreachable,
-            .pointer => |pointer_info| pool.items.appendAssumeCapacity(switch (pointer_info.nonstring) {
-                false => .{
-                    .tag = tag,
-                    .data = @intFromEnum(pool_adapter.copy(pointer_info.elem_ctype).index),
-                },
-                true => .{
-                    .tag = .nonstring,
-                    .data = @intFromEnum(pool_adapter.copy(.{ .index = @enumFromInt(
-                        source_pool.items.items(.data)[source_ctype.toPoolIndex().?],
-                    ) }).index),
-                },
-            }),
-            .aligned => |aligned_info| pool.items.appendAssumeCapacity(.{
-                .tag = tag,
-                .data = try pool.addExtra(allocator, Aligned, .{
-                    .ctype = pool_adapter.copy(aligned_info.ctype).index,
-                    .flags = .{ .alignas = aligned_info.alignas },
-                }, 0),
-            }),
-            .array, .vector => |sequence_info| pool.items.appendAssumeCapacity(switch (sequence_info.nonstring) {
-                false => .{
-                    .tag = tag,
-                    .data = switch (tag) {
-                        .array_small, .vector => try pool.addExtra(allocator, SequenceSmall, .{
-                            .elem_ctype = pool_adapter.copy(sequence_info.elem_ctype).index,
-                            .len = @intCast(sequence_info.len),
-                        }, 0),
-                        .array_large => try pool.addExtra(allocator, SequenceLarge, .{
-                            .elem_ctype = pool_adapter.copy(sequence_info.elem_ctype).index,
-                            .len_lo = @truncate(sequence_info.len >> 0),
-                            .len_hi = @truncate(sequence_info.len >> 32),
-                        }, 0),
-                        else => unreachable,
-                    },
-                },
-                true => .{
-                    .tag = .nonstring,
-                    .data = @intFromEnum(pool_adapter.copy(.{ .index = @enumFromInt(
-                        source_pool.items.items(.data)[source_ctype.toPoolIndex().?],
-                    ) }).index),
-                },
-            }),
-            .fwd_decl => |fwd_decl_info| switch (fwd_decl_info.name) {
-                .anon => |fields| {
-                    pool.items.appendAssumeCapacity(.{
-                        .tag = tag,
-                        .data = try pool.addExtra(allocator, FwdDeclAnon, .{
-                            .fields_len = fields.len,
-                        }, fields.len * @typeInfo(Field).@"struct".fields.len),
-                    });
-                    for (0..fields.len) |field_index| {
-                        const field = fields.at(field_index, source_pool);
-                        const field_name = if (field.name.toPoolSlice(source_pool)) |slice|
-                            try pool.string(allocator, slice)
-                        else
-                            field.name;
-                        pool.addExtraAssumeCapacity(Field, .{
-                            .name = field_name.index,
-                            .ctype = pool_adapter.copy(field.ctype).index,
-                            .flags = .{ .alignas = field.alignas },
-                        });
-                    }
-                },
-                .index => |index| pool.items.appendAssumeCapacity(.{
-                    .tag = tag,
-                    .data = @intFromEnum(index),
-                }),
-            },
-            .aggregate => |aggregate_info| {
-                pool.items.appendAssumeCapacity(.{
-                    .tag = tag,
-                    .data = switch (aggregate_info.name) {
-                        .anon => |anon| try pool.addExtra(allocator, AggregateAnon, .{
-                            .index = anon.index,
-                            .id = anon.id,
-                            .fields_len = aggregate_info.fields.len,
-                        }, aggregate_info.fields.len * @typeInfo(Field).@"struct".fields.len),
-                        .fwd_decl => |fwd_decl| try pool.addExtra(allocator, Aggregate, .{
-                            .fwd_decl = pool_adapter.copy(fwd_decl).index,
-                            .fields_len = aggregate_info.fields.len,
-                        }, aggregate_info.fields.len * @typeInfo(Field).@"struct".fields.len),
-                    },
-                });
-                for (0..aggregate_info.fields.len) |field_index| {
-                    const field = aggregate_info.fields.at(field_index, source_pool);
-                    const field_name = if (field.name.toPoolSlice(source_pool)) |slice|
-                        try pool.string(allocator, slice)
-                    else
-                        field.name;
-                    pool.addExtraAssumeCapacity(Field, .{
-                        .name = field_name.index,
-                        .ctype = pool_adapter.copy(field.ctype).index,
-                        .flags = .{ .alignas = field.alignas },
-                    });
-                }
-            },
-            .function => |function_info| {
-                pool.items.appendAssumeCapacity(.{
-                    .tag = tag,
-                    .data = try pool.addExtra(allocator, Function, .{
-                        .return_ctype = pool_adapter.copy(function_info.return_ctype).index,
-                        .param_ctypes_len = function_info.param_ctypes.len,
-                    }, function_info.param_ctypes.len),
-                });
-                for (0..function_info.param_ctypes.len) |param_index| pool.extra.appendAssumeCapacity(
-                    @intFromEnum(pool_adapter.copy(
-                        function_info.param_ctypes.at(param_index, source_pool),
-                    ).index),
-                );
-            },
-        };
-        assert(source_info.eqlAdapted(source_pool, ctype, pool, pool_adapter));
-        assert(source_ctype.hash(source_pool) == ctype.hash(pool));
-        return .{ ctype, gop.found_existing };
-    }
-
-    pub fn string(pool: *Pool, allocator: std.mem.Allocator, slice: []const u8) !String {
-        try pool.string_bytes.appendSlice(allocator, slice);
-        return pool.trailingString(allocator);
-    }
-
-    pub fn fmt(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        comptime fmt_str: []const u8,
-        fmt_args: anytype,
-    ) !String {
-        try pool.string_bytes.print(allocator, fmt_str, fmt_args);
-        return pool.trailingString(allocator);
-    }
-
-    fn ensureUnusedCapacity(pool: *Pool, allocator: std.mem.Allocator, len: u32) !void {
-        try pool.map.ensureUnusedCapacity(allocator, len);
-        try pool.items.ensureUnusedCapacity(allocator, len);
-    }
-
-    const Hasher = struct {
-        const Impl = std.hash.Wyhash;
-        impl: Impl,
-
-        const init: Hasher = .{ .impl = Impl.init(0) };
-
-        fn updateExtra(hasher: *Hasher, comptime Extra: type, extra: Extra, pool: *const Pool) void {
-            inline for (@typeInfo(Extra).@"struct".fields) |field| {
-                const value = @field(extra, field.name);
-                switch (field.type) {
-                    Pool.Tag, String, CType => unreachable,
-                    CType.Index => hasher.update((CType{ .index = value }).hash(pool)),
-                    String.Index => if ((String{ .index = value }).toPoolSlice(pool)) |slice|
-                        hasher.update(slice)
-                    else
-                        hasher.update(@intFromEnum(value)),
-                    else => hasher.update(value),
-                }
-            }
-        }
-        fn update(hasher: *Hasher, data: anytype) void {
-            switch (@TypeOf(data)) {
-                Pool.Tag => @compileError("pass tag to final"),
-                CType, CType.Index => @compileError("hash ctype.hash(pool) instead"),
-                String, String.Index => @compileError("hash string.slice(pool) instead"),
-                u32, InternPool.Index, Aligned.Flags => hasher.impl.update(std.mem.asBytes(&data)),
-                []const u8 => hasher.impl.update(data),
-                else => @compileError("unhandled type: " ++ @typeName(@TypeOf(data))),
-            }
-        }
-
-        fn final(hasher: Hasher, tag: Pool.Tag) Map.Hash {
-            var impl = hasher.impl;
-            impl.update(std.mem.asBytes(&tag));
-            return @truncate(impl.final());
-        }
-    };
-
-    fn tagData(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        hasher: Hasher,
-        tag: Pool.Tag,
-        data: u32,
-    ) !CType {
-        try pool.ensureUnusedCapacity(allocator, 1);
-        const Key = struct { hash: Map.Hash, tag: Pool.Tag, data: u32 };
-        const CTypeAdapter = struct {
-            pool: *const Pool,
-            pub fn hash(_: @This(), key: Key) Map.Hash {
-                return key.hash;
-            }
-            pub fn eql(ctype_adapter: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
-                const rhs_item = ctype_adapter.pool.items.get(rhs_index);
-                return lhs_key.tag == rhs_item.tag and lhs_key.data == rhs_item.data;
-            }
-        };
-        const gop = pool.map.getOrPutAssumeCapacityAdapted(
-            Key{ .hash = hasher.final(tag), .tag = tag, .data = data },
-            CTypeAdapter{ .pool = pool },
-        );
-        if (!gop.found_existing) pool.items.appendAssumeCapacity(.{ .tag = tag, .data = data });
-        return .fromPoolIndex(gop.index);
-    }
-
-    fn tagExtra(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        tag: Pool.Tag,
-        comptime Extra: type,
-        extra: Extra,
-    ) !CType {
-        var hasher = Hasher.init;
-        hasher.updateExtra(Extra, extra, pool);
-        return pool.tagTrailingExtra(
-            allocator,
-            hasher,
-            tag,
-            try pool.addExtra(allocator, Extra, extra, 0),
-        );
-    }
-
-    fn tagTrailingExtra(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        hasher: Hasher,
-        tag: Pool.Tag,
-        extra_index: ExtraIndex,
-    ) !CType {
-        try pool.ensureUnusedCapacity(allocator, 1);
-        return pool.tagTrailingExtraAssumeCapacity(hasher, tag, extra_index);
-    }
-
-    fn tagTrailingExtraAssumeCapacity(
-        pool: *Pool,
-        hasher: Hasher,
-        tag: Pool.Tag,
-        extra_index: ExtraIndex,
-    ) CType {
-        const Key = struct { hash: Map.Hash, tag: Pool.Tag, extra: []const u32 };
-        const CTypeAdapter = struct {
-            pool: *const Pool,
-            pub fn hash(_: @This(), key: Key) Map.Hash {
-                return key.hash;
-            }
-            pub fn eql(ctype_adapter: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
-                const rhs_item = ctype_adapter.pool.items.get(rhs_index);
-                if (lhs_key.tag != rhs_item.tag) return false;
-                const rhs_extra = ctype_adapter.pool.extra.items[rhs_item.data..];
-                return std.mem.startsWith(u32, rhs_extra, lhs_key.extra);
-            }
-        };
-        const gop = pool.map.getOrPutAssumeCapacityAdapted(
-            Key{ .hash = hasher.final(tag), .tag = tag, .extra = pool.extra.items[extra_index..] },
-            CTypeAdapter{ .pool = pool },
-        );
-        if (gop.found_existing)
-            pool.extra.shrinkRetainingCapacity(extra_index)
-        else
-            pool.items.appendAssumeCapacity(.{ .tag = tag, .data = extra_index });
-        return .fromPoolIndex(gop.index);
-    }
-
-    fn sortFields(fields: []Info.Field) void {
-        std.mem.sort(Info.Field, fields, {}, struct {
-            fn before(_: void, lhs_field: Info.Field, rhs_field: Info.Field) bool {
-                return lhs_field.alignas.order(rhs_field.alignas).compare(.gt);
-            }
-        }.before);
-    }
-
-    fn trailingString(pool: *Pool, allocator: std.mem.Allocator) !String {
-        const start = pool.string_indices.getLast();
-        const slice: []const u8 = pool.string_bytes.items[start..];
-        if (slice.len >= 2 and slice[0] == 'f' and switch (slice[1]) {
-            '0' => slice.len == 2,
-            '1'...'9' => true,
-            else => false,
-        }) if (std.fmt.parseInt(u31, slice[1..], 10)) |unnamed| {
-            pool.string_bytes.shrinkRetainingCapacity(start);
-            return String.fromUnnamed(unnamed);
-        } else |_| {};
-        if (std.meta.stringToEnum(String.Index, slice)) |index| {
-            pool.string_bytes.shrinkRetainingCapacity(start);
-            return .{ .index = index };
-        }
-
-        try pool.string_map.ensureUnusedCapacity(allocator, 1);
-        try pool.string_indices.ensureUnusedCapacity(allocator, 1);
-
-        const gop = pool.string_map.getOrPutAssumeCapacityAdapted(slice, String.Adapter{ .pool = pool });
-        if (gop.found_existing)
-            pool.string_bytes.shrinkRetainingCapacity(start)
-        else
-            pool.string_indices.appendAssumeCapacity(@intCast(pool.string_bytes.items.len));
-        return String.fromPoolIndex(gop.index);
-    }
-
-    const Item = struct {
-        tag: Pool.Tag,
-        data: u32,
-    };
-
-    const ExtraIndex = u32;
-
-    const Tag = enum(u8) {
-        basic,
-        pointer,
-        pointer_const,
-        pointer_volatile,
-        pointer_const_volatile,
-        aligned,
-        array_small,
-        array_large,
-        vector,
-        nonstring,
-        fwd_decl_struct_anon,
-        fwd_decl_union_anon,
-        fwd_decl_struct,
-        fwd_decl_union,
-        aggregate_struct_anon,
-        aggregate_struct_packed_anon,
-        aggregate_union_anon,
-        aggregate_union_packed_anon,
-        aggregate_struct,
-        aggregate_struct_packed,
-        aggregate_union,
-        aggregate_union_packed,
-        function,
-        function_varargs,
-    };
-
-    const Aligned = struct {
-        ctype: CType.Index,
-        flags: Flags,
-
-        const Flags = packed struct(u32) {
-            alignas: AlignAs,
-            _: u20 = 0,
-        };
-    };
-
-    const SequenceSmall = struct {
-        elem_ctype: CType.Index,
-        len: u32,
-    };
-
-    const SequenceLarge = struct {
-        elem_ctype: CType.Index,
-        len_lo: u32,
-        len_hi: u32,
-
-        fn len(extra: SequenceLarge) u64 {
-            return @as(u64, extra.len_lo) << 0 |
-                @as(u64, extra.len_hi) << 32;
-        }
-    };
-
-    const Field = struct {
-        name: String.Index,
-        ctype: CType.Index,
-        flags: Flags,
-
-        const Flags = Aligned.Flags;
-    };
-
-    const FwdDeclAnon = struct {
-        fields_len: u32,
-    };
-
-    const AggregateAnon = struct {
-        index: InternPool.Index,
-        id: u32,
-        fields_len: u32,
-    };
-
-    const Aggregate = struct {
-        fwd_decl: CType.Index,
-        fields_len: u32,
-    };
-
-    const Function = struct {
-        return_ctype: CType.Index,
-        param_ctypes_len: u32,
-    };
-
-    fn addExtra(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        comptime Extra: type,
-        extra: Extra,
-        trailing_len: usize,
-    ) !ExtraIndex {
-        try pool.extra.ensureUnusedCapacity(
-            allocator,
-            @typeInfo(Extra).@"struct".fields.len + trailing_len,
-        );
-        defer pool.addExtraAssumeCapacity(Extra, extra);
-        return @intCast(pool.extra.items.len);
-    }
-    fn addExtraAssumeCapacity(pool: *Pool, comptime Extra: type, extra: Extra) void {
-        addExtraAssumeCapacityTo(&pool.extra, Extra, extra);
-    }
-    fn addExtraAssumeCapacityTo(
-        array: *std.ArrayList(u32),
-        comptime Extra: type,
-        extra: Extra,
-    ) void {
-        inline for (@typeInfo(Extra).@"struct".fields) |field| {
-            const value = @field(extra, field.name);
-            array.appendAssumeCapacity(switch (field.type) {
-                u32 => value,
-                CType.Index, String.Index, InternPool.Index => @intFromEnum(value),
-                Aligned.Flags => @bitCast(value),
-                else => @compileError("bad field type: " ++ field.name ++ ": " ++
-                    @typeName(field.type)),
-            });
-        }
-    }
-
-    fn addHashedExtra(
-        pool: *Pool,
-        allocator: std.mem.Allocator,
-        hasher: *Hasher,
-        comptime Extra: type,
-        extra: Extra,
-        trailing_len: usize,
-    ) !ExtraIndex {
-        hasher.updateExtra(Extra, extra, pool);
-        return pool.addExtra(allocator, Extra, extra, trailing_len);
-    }
-    fn addHashedExtraAssumeCapacity(
-        pool: *Pool,
-        hasher: *Hasher,
-        comptime Extra: type,
-        extra: Extra,
-    ) void {
-        hasher.updateExtra(Extra, extra, pool);
-        pool.addExtraAssumeCapacity(Extra, extra);
-    }
-    fn addHashedExtraAssumeCapacityTo(
-        pool: *Pool,
-        array: *std.ArrayList(u32),
-        hasher: *Hasher,
-        comptime Extra: type,
-        extra: Extra,
-    ) void {
-        hasher.updateExtra(Extra, extra, pool);
-        addExtraAssumeCapacityTo(array, Extra, extra);
-    }
-
-    const ExtraTrail = struct {
-        extra_index: ExtraIndex,
-
-        fn next(
-            extra_trail: *ExtraTrail,
-            len: u32,
-            comptime Extra: type,
-            pool: *const Pool,
-        ) []const Extra {
-            defer extra_trail.extra_index += @intCast(len);
-            return @ptrCast(pool.extra.items[extra_trail.extra_index..][0..len]);
-        }
-    };
-
-    fn getExtraTrail(
-        pool: *const Pool,
-        comptime Extra: type,
-        extra_index: ExtraIndex,
-    ) struct { extra: Extra, trail: ExtraTrail } {
-        var extra: Extra = undefined;
-        const fields = @typeInfo(Extra).@"struct".fields;
-        inline for (fields, pool.extra.items[extra_index..][0..fields.len]) |field, value|
-            @field(extra, field.name) = switch (field.type) {
-                u32 => value,
-                CType.Index, String.Index, InternPool.Index => @enumFromInt(value),
-                Aligned.Flags => @bitCast(value),
-                else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
-            };
-        return .{
-            .extra = extra,
-            .trail = .{ .extra_index = extra_index + @as(ExtraIndex, @intCast(fields.len)) },
-        };
-    }
-
-    fn getExtra(pool: *const Pool, comptime Extra: type, extra_index: ExtraIndex) Extra {
-        return pool.getExtraTrail(Extra, extra_index).extra;
-    }
-};
-
-pub const AlignAs = packed struct {
-    @"align": InternPool.Alignment,
-    abi: InternPool.Alignment,
-
-    pub fn fromAlignment(alignas: AlignAs) AlignAs {
-        assert(alignas.abi != .none);
-        return .{
-            .@"align" = if (alignas.@"align" != .none) alignas.@"align" else alignas.abi,
-            .abi = alignas.abi,
-        };
-    }
-    pub fn fromAbiAlignment(abi: InternPool.Alignment) AlignAs {
-        assert(abi != .none);
-        return .{ .@"align" = abi, .abi = abi };
-    }
-    pub fn fromByteUnits(@"align": u64, abi: u64) AlignAs {
-        return fromAlignment(.{
-            .@"align" = InternPool.Alignment.fromByteUnits(@"align"),
-            .abi = InternPool.Alignment.fromNonzeroByteUnits(abi),
-        });
-    }
-
-    pub fn order(lhs: AlignAs, rhs: AlignAs) std.math.Order {
-        return lhs.@"align".order(rhs.@"align");
-    }
-    pub fn abiOrder(alignas: AlignAs) std.math.Order {
-        return alignas.@"align".order(alignas.abi);
-    }
-    pub fn toByteUnits(alignas: AlignAs) u64 {
-        return alignas.@"align".toByteUnits().?;
-    }
-};
-
-const std = @import("std");
-const assert = std.debug.assert;
-const Writer = std.Io.Writer;
-
-const CType = @This();
-const InternPool = @import("../../InternPool.zig");
-const Module = @import("../../Package/Module.zig");
-const Type = @import("../../Type.zig");
-const Value = @import("../../Value.zig");
-const Zcu = @import("../../Zcu.zig");
diff --git a/src/codegen/c/type.zig b/src/codegen/c/type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..64e63e4d6733980ea6cca735f53c82cb041e36d8
--- /dev/null
+++ b/src/codegen/c/type.zig
@@ -0,0 +1,1013 @@
+pub const CType = union(enum) {
+    pub const render_defs = @import("type/render_defs.zig");
+
+    // The first nodes are primitive types (or standard typedefs).
+
+    void,
+    bool,
+    int: Int,
+    float: Float,
+
+    // These next nodes are all typedefs, structs, or unions.
+
+    @"fn": Type,
+    @"enum": Type,
+    bitpack: Type,
+    @"struct": Type,
+    union_auto: Type,
+    union_extern: Type,
+    slice: Type,
+    opt: Type,
+    arr: Type,
+    vec: Type,
+    errunion: struct { payload_ty: Type },
+    aligned: struct {
+        ty: Type,
+        alignment: InternPool.Alignment,
+    },
+    bigint: BigInt,
+
+    // The remaining nodes have children.
+
+    pointer: struct {
+        @"const": bool,
+        @"volatile": bool,
+        elem_ty: *const CType,
+        nonstring: bool,
+    },
+    array: struct {
+        len: u64,
+        elem_ty: *const CType,
+        nonstring: bool,
+    },
+    function: struct {
+        param_tys: []const CType,
+        ret_ty: *const CType,
+        varargs: bool,
+    },
+
+    /// Returns `true` if this node has a postfix operator, meaning an `[...]` or `(...)` appears
+    /// after the identifier in a declarator with this type. In this case, if this node is wrapped
+    /// in a pointer type, we will need to add parentheses due to operator precedence.
+    ///
+    /// For instance, when lowering a Zig declaration `foo: *const fn (c_int) void`, it would be a
+    /// bug to write the C declarator as `void *foo(int)`, because the `(int)` suffix declaring the
+    /// function type has higher precedence than the `*` prefix declaring the pointer type. Instead,
+    /// this type must be lowered as `void (*foo)(int)`.
+    fn kind(cty: *const CType) enum {
+        /// `cty` is just a C type specifier, i.e. a typedef or a named struct/union type.
+        specifier,
+        /// `cty` is a C function or array type. It will have a postfix "operator" in its suffix to
+        /// declare the type, either `(...)` (for a function type) or `[...]` (for an array type).
+        postfix_op,
+        /// `cty` is a C pointer type. Its prefix will end with "*".
+        pointer,
+    } {
+        return switch (cty.*) {
+            .void,
+            .bool,
+            .int,
+            .float,
+            .@"fn",
+            .@"enum",
+            .bitpack,
+            .@"struct",
+            .union_auto,
+            .union_extern,
+            .slice,
+            .opt,
+            .arr,
+            .vec,
+            .errunion,
+            .aligned,
+            .bigint,
+            => .specifier,
+
+            .array,
+            .function,
+            => .postfix_op,
+
+            .pointer => .pointer,
+        };
+    }
+
+    pub const Int = enum {
+        char,
+
+        @"unsigned short",
+        @"unsigned int",
+        @"unsigned long",
+        @"unsigned long long",
+
+        @"signed short",
+        @"signed int",
+        @"signed long",
+        @"signed long long",
+
+        uint8_t,
+        uint16_t,
+        uint32_t,
+        uint64_t,
+        zig_u128,
+
+        int8_t,
+        int16_t,
+        int32_t,
+        int64_t,
+        zig_i128,
+
+        uintptr_t,
+        intptr_t,
+
+        pub fn bits(int: Int, target: *const std.Target) u16 {
+            return switch (int) {
+                // zig fmt: off
+            .char => target.cTypeBitSize(.char),
+
+            .@"unsigned short"     => target.cTypeBitSize(.ushort),
+            .@"unsigned int"       => target.cTypeBitSize(.uint),
+            .@"unsigned long"      => target.cTypeBitSize(.ulong),
+            .@"unsigned long long" => target.cTypeBitSize(.ulonglong),
+
+            .@"signed short"     => target.cTypeBitSize(.short),
+            .@"signed int"       => target.cTypeBitSize(.int),
+            .@"signed long"      => target.cTypeBitSize(.long),
+            .@"signed long long" => target.cTypeBitSize(.longlong),
+
+            .uintptr_t, .intptr_t => target.ptrBitWidth(),
+
+            .uint8_t,  .int8_t   => 8,
+            .uint16_t, .int16_t  => 16,
+            .uint32_t, .int32_t  => 32,
+            .uint64_t, .int64_t  => 64,
+            .zig_u128, .zig_i128 => 128,
+            // zig fmt: on
+            };
+        }
+    };
+
+    pub const BigInt = struct {
+        limb_size: LimbSize,
+        /// Always greater than 1.
+        limbs_len: u16,
+
+        pub const LimbSize = enum {
+            @"8",
+            @"16",
+            @"32",
+            @"64",
+            @"128",
+            pub fn bits(s: LimbSize) u8 {
+                return switch (s) {
+                    .@"8" => 8,
+                    .@"16" => 16,
+                    .@"32" => 32,
+                    .@"64" => 64,
+                    .@"128" => 128,
+                };
+            }
+            pub fn unsigned(s: LimbSize) Int {
+                return switch (s) {
+                    .@"8" => .uint8_t,
+                    .@"16" => .uint16_t,
+                    .@"32" => .uint32_t,
+                    .@"64" => .uint64_t,
+                    .@"128" => .zig_u128,
+                };
+            }
+            pub fn signed(s: LimbSize) Int {
+                return switch (s) {
+                    .@"8" => .int8_t,
+                    .@"16" => .int16_t,
+                    .@"32" => .int32_t,
+                    .@"64" => .int64_t,
+                    .@"128" => .zig_i128,
+                };
+            }
+        };
+    };
+
+    pub const Float = enum {
+        @"long double",
+        zig_f16,
+        zig_f32,
+        zig_f64,
+        zig_f80,
+        zig_f128,
+        zig_u128,
+        zig_i128,
+    };
+
+    pub fn isStringElem(cty: CType) bool {
+        return switch (cty) {
+            .int => |int| switch (int) {
+                .char, .int8_t, .uint8_t => true,
+                else => false,
+            },
+            else => false,
+        };
+    }
+
+    pub fn lower(
+        ty: Type,
+        deps: *Dependencies,
+        arena: Allocator,
+        zcu: *const Zcu,
+    ) Allocator.Error!CType {
+        return lowerInner(ty, false, deps, arena, zcu);
+    }
+    fn lowerInner(
+        start_ty: Type,
+        allow_incomplete: bool,
+        deps: *Dependencies,
+        arena: Allocator,
+        zcu: *const Zcu,
+    ) Allocator.Error!CType {
+        const gpa = zcu.comp.gpa;
+        const ip = &zcu.intern_pool;
+        var cur_ty = start_ty;
+        while (true) {
+            switch (cur_ty.zigTypeTag(zcu)) {
+                .type,
+                .comptime_int,
+                .comptime_float,
+                .undefined,
+                .null,
+                .enum_literal,
+                .@"opaque",
+                .noreturn,
+                .void,
+                => return .void,
+
+                .bool => return .bool,
+
+                .int, .error_set => switch (classifyInt(cur_ty, zcu)) {
+                    .void => return .void,
+                    .small => |s| return .{ .int = s },
+                    .big => |big| {
+                        try deps.bigint.put(gpa, big, {});
+                        return .{ .bigint = big };
+                    },
+                },
+
+                .float => return .{ .float = switch (cur_ty.toIntern()) {
+                    .c_longdouble_type => .@"long double",
+                    .f16_type => .zig_f16,
+                    .f32_type => .zig_f32,
+                    .f64_type => .zig_f64,
+                    .f80_type => .zig_f80,
+                    .f128_type => .zig_f128,
+                    else => unreachable,
+                } },
+                .vector => {
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    return .{ .vec = cur_ty };
+                },
+                .array => {
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    return .{ .arr = cur_ty };
+                },
+
+                .pointer => {
+                    const ptr = cur_ty.ptrInfo(zcu);
+                    switch (ptr.flags.size) {
+                        .slice => {
+                            try deps.addType(gpa, cur_ty, allow_incomplete);
+                            return .{ .slice = cur_ty };
+                        },
+                        .one, .many, .c => {
+                            const elem_ty: Type = .fromInterned(ptr.child);
+                            const is_fn_ptr = elem_ty.zigTypeTag(zcu) == .@"fn";
+                            const elem_cty: CType = elem_cty: {
+                                if (ptr.packed_offset.host_size > 0 and ptr.flags.vector_index == .none) {
+                                    switch (classifyBitInt(.unsigned, ptr.packed_offset.host_size * 8, zcu)) {
+                                        .void => break :elem_cty .void,
+                                        .small => |s| break :elem_cty .{ .int = s },
+                                        .big => |big| {
+                                            try deps.bigint.put(gpa, big, {});
+                                            break :elem_cty .{ .bigint = big };
+                                        },
+                                    }
+                                }
+                                if (ptr.flags.alignment != .none and !is_fn_ptr) {
+                                    // The pointer has an explicit alignment---if it's an underalignment
+                                    // then we need to use an "aligned" typedef.
+                                    const ptr_align = ptr.flags.alignment;
+                                    if (!alwaysHasLayout(elem_ty, ip) or
+                                        ptr_align.compareStrict(.lt, elem_ty.abiAlignment(zcu)))
+                                    {
+                                        const gop = try deps.aligned_type_fwd.getOrPut(gpa, elem_ty.toIntern());
+                                        if (!gop.found_existing) gop.value_ptr.* = 0;
+                                        gop.value_ptr.* |= @as(u64, 1) << ptr_align.toLog2Units();
+                                        break :elem_cty .{ .aligned = .{
+                                            .ty = elem_ty,
+                                            .alignment = ptr_align,
+                                        } };
+                                    }
+                                }
+                                break :elem_cty try .lowerInner(elem_ty, true, deps, arena, zcu);
+                            };
+                            const elem_cty_buf = try arena.create(CType);
+                            elem_cty_buf.* = elem_cty;
+                            return .{ .pointer = .{
+                                .@"const" = ptr.flags.is_const and !is_fn_ptr,
+                                .@"volatile" = ptr.flags.is_volatile and !is_fn_ptr,
+                                .elem_ty = elem_cty_buf,
+                                .nonstring = nonstring: {
+                                    if (!elem_cty.isStringElem()) break :nonstring false;
+                                    if (ptr.sentinel == .none) break :nonstring true;
+                                    break :nonstring Value.compareHetero(
+                                        .fromInterned(ptr.sentinel),
+                                        .neq,
+                                        .zero_comptime_int,
+                                        zcu,
+                                    );
+                                },
+                            } };
+                        },
+                    }
+                },
+
+                .@"fn" => {
+                    const func_type = ip.indexToKey(cur_ty.toIntern()).func_type;
+                    direct: {
+                        const ret_ty: Type = .fromInterned(func_type.return_type);
+                        if (!alwaysHasLayout(ret_ty, ip)) break :direct;
+                        var params_len: usize = 0; // only counts parameter types with runtime bits
+                        for (func_type.param_types.get(ip)) |param_ty_ip| {
+                            const param_ty: Type = .fromInterned(param_ty_ip);
+                            if (!alwaysHasLayout(param_ty, ip)) break :direct;
+                            if (param_ty.hasRuntimeBits(zcu)) params_len += 1;
+                        }
+                        // We can actually write this function type directly!
+                        if (!cur_ty.fnHasRuntimeBits(zcu)) return .void;
+                        const ret_cty_buf = try arena.create(CType);
+                        if (!ret_ty.hasRuntimeBits(zcu)) {
+                            // Incomplete function return types must always be `void`.
+                            ret_cty_buf.* = .void;
+                        } else {
+                            ret_cty_buf.* = try .lowerInner(ret_ty, allow_incomplete, deps, arena, zcu);
+                        }
+                        const param_cty_buf = try arena.alloc(CType, params_len);
+                        var param_index: usize = 0;
+                        for (func_type.param_types.get(ip)) |param_ty_ip| {
+                            const param_ty: Type = .fromInterned(param_ty_ip);
+                            if (!param_ty.hasRuntimeBits(zcu)) continue;
+                            param_cty_buf[param_index] = try .lowerInner(param_ty, allow_incomplete, deps, arena, zcu);
+                            param_index += 1;
+                        }
+                        assert(param_index == params_len);
+                        return .{ .function = .{
+                            .ret_ty = ret_cty_buf,
+                            .param_tys = param_cty_buf,
+                            .varargs = func_type.is_var_args,
+                        } };
+                    }
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    return .{ .@"fn" = cur_ty };
+                },
+
+                .@"struct" => {
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    switch (cur_ty.containerLayout(zcu)) {
+                        .auto, .@"extern" => return .{ .@"struct" = cur_ty },
+                        .@"packed" => return .{ .bitpack = cur_ty },
+                    }
+                },
+                .@"union" => {
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    switch (cur_ty.containerLayout(zcu)) {
+                        .auto => return .{ .union_auto = cur_ty },
+                        .@"extern" => return .{ .union_extern = cur_ty },
+                        .@"packed" => return .{ .bitpack = cur_ty },
+                    }
+                },
+                .@"enum" => {
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    return .{ .@"enum" = cur_ty };
+                },
+
+                .optional => {
+                    // This query does not require any type resolution.
+                    if (cur_ty.optionalReprIsPayload(zcu)) {
+                        // Either a pointer-like optional, or an optional error set. Just lower the payload.
+                        cur_ty = cur_ty.optionalChild(zcu);
+                        continue;
+                    }
+                    if (alwaysHasLayout(cur_ty, ip)) switch (classifyOptional(cur_ty, zcu)) {
+                        .error_set, .ptr_like, .slice_like => unreachable, // handled above
+                        .npv_payload => return .void,
+                        .opv_payload, .@"struct" => {},
+                    };
+                    try deps.addType(gpa, cur_ty, allow_incomplete);
+                    return .{ .opt = cur_ty };
+                },
+
+                .error_union => {
+                    const payload_ty = cur_ty.errorUnionPayload(zcu);
+                    if (allow_incomplete) {
+                        try deps.errunion_type_fwd.put(gpa, payload_ty.toIntern(), {});
+                    } else {
+                        try deps.errunion_type.put(gpa, payload_ty.toIntern(), {});
+                    }
+                    return .{ .errunion = .{
+                        .payload_ty = payload_ty,
+                    } };
+                },
+
+                .frame,
+                .@"anyframe",
+                => unreachable,
+            }
+            comptime unreachable;
+        }
+    }
+
+    pub fn classifyOptional(opt_ty: Type, zcu: *const Zcu) enum {
+        /// The optional is something like `?noreturn`; it lowers to `void`.
+        npv_payload,
+        /// The payload type is an error set; the representation matches that of the error set, with
+        /// the value 0 representing `null`.
+        error_set,
+        /// The payload type is a non-optional pointer; the NULL pointer is used for `null`.
+        ptr_like,
+        /// The payload type is a non-optional slice; a NULL pointer field is used for `null`.
+        slice_like,
+        /// The optional is something like `?void`; it lowers to a struct, but one containing only
+        /// one field `is_null` (the payload is omitted).
+        opv_payload,
+        /// The optional uses the "default" lowering of a struct with two fields, like this:
+        ///   struct optional_1234 { payload_ty payload; bool is_null; }
+        @"struct",
+    } {
+        const payload_ty = opt_ty.optionalChild(zcu);
+        if (opt_ty.optionalReprIsPayload(zcu)) {
+            return switch (payload_ty.zigTypeTag(zcu)) {
+                .error_set => .error_set,
+                .pointer => if (payload_ty.isSlice(zcu)) .slice_like else .ptr_like,
+                else => unreachable,
+            };
+        } else {
+            return switch (payload_ty.classify(zcu)) {
+                .no_possible_value => .npv_payload,
+                .one_possible_value => .opv_payload,
+                else => .@"struct",
+            };
+        }
+    }
+
+    pub const IntClass = union(enum) {
+        /// The integer type is zero-bit, so lowers to `void`.
+        void,
+        /// The integer is under 128 bits long, so lowers to this C integer type.
+        small: Int,
+        /// The integer is over 128 bits long, so lowers to an array of limbs.
+        big: BigInt,
+    };
+
+    /// Asserts that `ty` is an integer, enum, bitpack, or error set.
+    pub fn classifyInt(ty: Type, zcu: *const Zcu) IntClass {
+        const int_ty: Type = switch (ty.zigTypeTag(zcu)) {
+            .error_set => return classifyBitInt(.unsigned, zcu.errorSetBits(), zcu),
+            .@"enum" => ty.intTagType(zcu),
+            .@"struct", .@"union" => ty.bitpackBackingInt(zcu),
+            .int => ty,
+            else => unreachable,
+        };
+        switch (int_ty.toIntern()) {
+            // zig fmt: off
+        .usize_type => return .{ .small = .uintptr_t },
+        .isize_type => return .{ .small = .intptr_t },
+
+        .c_char_type => return .{ .small = .char },
+
+        .c_short_type    => return .{ .small = .@"signed short" },
+        .c_int_type      => return .{ .small = .@"signed int" },
+        .c_long_type     => return .{ .small = .@"signed long" },
+        .c_longlong_type => return .{ .small = .@"signed long long" },
+
+        .c_ushort_type    => return .{ .small = .@"unsigned short" },
+        .c_uint_type      => return .{ .small = .@"unsigned int" },
+        .c_ulong_type     => return .{ .small = .@"unsigned long" },
+        .c_ulonglong_type => return .{ .small = .@"unsigned long long" },
+        // zig fmt: on
+
+            else => {
+                const int = ty.intInfo(zcu);
+                return classifyBitInt(int.signedness, int.bits, zcu);
+            },
+        }
+    }
+    fn classifyBitInt(signedness: std.builtin.Signedness, bits: u16, zcu: *const Zcu) IntClass {
+        return switch (bits) {
+            0 => .void,
+            1...8 => switch (signedness) {
+                .unsigned => .{ .small = .uint8_t },
+                .signed => .{ .small = .int8_t },
+            },
+            9...16 => switch (signedness) {
+                .unsigned => .{ .small = .uint16_t },
+                .signed => .{ .small = .int16_t },
+            },
+            17...32 => switch (signedness) {
+                .unsigned => .{ .small = .uint32_t },
+                .signed => .{ .small = .int32_t },
+            },
+            33...64 => switch (signedness) {
+                .unsigned => .{ .small = .uint64_t },
+                .signed => .{ .small = .int64_t },
+            },
+            65...128 => switch (signedness) {
+                .unsigned => .{ .small = .zig_u128 },
+                .signed => .{ .small = .zig_i128 },
+            },
+            else => {
+                @branchHint(.unlikely);
+                const target = zcu.getTarget();
+                const limb_bytes = std.zig.target.intAlignment(target, bits);
+                return .{ .big = .{
+                    .limb_size = switch (limb_bytes) {
+                        1 => .@"8",
+                        2 => .@"16",
+                        4 => .@"32",
+                        8 => .@"64",
+                        16 => .@"128",
+                        else => unreachable,
+                    },
+                    .limbs_len = @divExact(
+                        std.zig.target.intByteSize(target, bits),
+                        limb_bytes,
+                    ),
+                } };
+            },
+        };
+    }
+
+    /// Describes a set of types which must be declared or completed in the C source file before
+    /// some string of rendered C code (such as a function), due to said C code using these types.
+    pub const Dependencies = struct {
+        /// Key is any Zig type which corresponds to a C `struct`, `union`, or `typedef`. That C
+        /// type must be declared and complete.
+        type: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+
+        /// Key is a Zig type which is the *payload* of an error union. The C `struct` type
+        /// corresponding to such an error union must be declared and complete.
+        ///
+        /// These are separate from `type` to avoid redundant types for every different error set
+        /// used with the same payload type---for instance a different C type for every `E!void`.
+        errunion_type: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+
+        /// Like `type`, but the type does not necessarily need to be completed yet: a forward
+        /// declaration is sufficient.
+        type_fwd: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+
+        /// Like `errunion_type`, but the type does not necessarily need to be completed yet: a
+        /// forward declaration is sufficient.
+        errunion_type_fwd: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+
+        /// Key is a Zig type; value is a bitmask of alignments. For every bit which is set, an
+        /// aligned typedef is required. For instance, if bit 3 is set, the C type 'aligned__8_foo'
+        /// must be declared through `typedef` (but not necessarily completed yet).
+        aligned_type_fwd: std.AutoArrayHashMapUnmanaged(InternPool.Index, u64),
+
+        /// Key specifies a big-int type whose C `struct` must be declared and complete.
+        bigint: std.AutoArrayHashMapUnmanaged(BigInt, void),
+
+        pub const empty: Dependencies = .{
+            .type = .empty,
+            .errunion_type = .empty,
+            .type_fwd = .empty,
+            .errunion_type_fwd = .empty,
+            .aligned_type_fwd = .empty,
+            .bigint = .empty,
+        };
+
+        pub fn deinit(deps: *Dependencies, gpa: Allocator) void {
+            deps.type.deinit(gpa);
+            deps.errunion_type.deinit(gpa);
+            deps.type_fwd.deinit(gpa);
+            deps.errunion_type_fwd.deinit(gpa);
+            deps.aligned_type_fwd.deinit(gpa);
+            deps.bigint.deinit(gpa);
+        }
+
+        pub fn clearRetainingCapacity(deps: *Dependencies) void {
+            deps.type.clearRetainingCapacity();
+            deps.errunion_type.clearRetainingCapacity();
+            deps.type_fwd.clearRetainingCapacity();
+            deps.errunion_type_fwd.clearRetainingCapacity();
+            deps.aligned_type_fwd.clearRetainingCapacity();
+            deps.bigint.clearRetainingCapacity();
+        }
+
+        pub fn move(deps: *Dependencies) Dependencies {
+            const moved = deps.*;
+            deps.* = .empty;
+            return moved;
+        }
+
+        fn addType(deps: *Dependencies, gpa: Allocator, ty: Type, allow_incomplete: bool) Allocator.Error!void {
+            if (allow_incomplete) {
+                try deps.type_fwd.put(gpa, ty.toIntern(), {});
+            } else {
+                try deps.type.put(gpa, ty.toIntern(), {});
+            }
+        }
+    };
+
+    /// Formats the bytes which appear *before* the identifier in a declarator. This includes the
+    /// type specifier and all "prefix type operators" in the declarator. e.g:
+    /// * for the declarator "int foo", writes "int "
+    /// * for the declarator "struct thing *foo", writes "struct thing *"
+    /// * for the declarator "void *(*foo)(int)", writes "void *(*"
+    pub fn fmtDeclaratorPrefix(cty: CType, zcu: *const Zcu) Formatter {
+        return .{
+            .cty = cty,
+            .zcu = zcu,
+            .kind = .declarator_prefix,
+        };
+    }
+    /// Formats the bytes which appear *before* the identifier in a declarator. This includes the
+    /// type specifier and all "prefix type operators" in the declarator. e.g:
+    /// * for the declarator "int foo", writes ""
+    /// * for the declarator "struct thing *foo", writes ""
+    /// * for the declarator "void *(*foo)(int)", writes ")(int)"
+    pub fn fmtDeclaratorSuffix(cty: CType, zcu: *const Zcu) Formatter {
+        return .{
+            .cty = cty,
+            .zcu = zcu,
+            .kind = .declarator_suffix,
+        };
+    }
+    /// Like `fmtDeclaratorSuffix`, except never emits a `zig_nonstring` annotation.
+    pub fn fmtDeclaratorSuffixIgnoreNonstring(cty: CType, zcu: *const Zcu) Formatter {
+        return .{
+            .cty = cty,
+            .zcu = zcu,
+            .kind = .declarator_suffix_ignore_nonstring,
+        };
+    }
+    /// Formats a type's full name, e.g. "int", "struct foo *", "void *(uint32_t)".
+    ///
+    /// This is almost identical to `fmtDeclaratorPrefix` followed by `fmtDeclaratorSuffix`, but
+    /// that sequence of calls may emit trailing whitespace where this one does not---for instance,
+    /// those calls would write the type "void" as "void ".
+    pub fn fmtTypeName(cty: CType, zcu: *const Zcu) Formatter {
+        return .{
+            .cty = cty,
+            .zcu = zcu,
+            .kind = .type_name,
+        };
+    }
+
+    const Formatter = struct {
+        cty: CType,
+        zcu: *const Zcu,
+        kind: enum { type_name, declarator_prefix, declarator_suffix, declarator_suffix_ignore_nonstring },
+
+        pub fn format(ctx: Formatter, w: *Writer) Writer.Error!void {
+            switch (ctx.kind) {
+                .type_name => {
+                    try ctx.cty.writeTypePrefix(w, ctx.zcu);
+                    try ctx.cty.writeTypeSuffix(w, ctx.zcu);
+                },
+                .declarator_prefix => {
+                    try ctx.cty.writeTypePrefix(w, ctx.zcu);
+                    switch (ctx.cty.kind()) {
+                        .specifier => try w.writeByte(' '), // write "int " rather than "int"
+                        .pointer => {}, // we already have something like "foo *"
+                        .postfix_op => {}, // we already have something like "ret_ty "
+                    }
+                },
+                .declarator_suffix => {
+                    try ctx.cty.writeTypeSuffix(w, ctx.zcu);
+                    const nonstring = switch (ctx.cty) {
+                        .array => |arr| arr.nonstring,
+                        .pointer => |ptr| ptr.nonstring,
+                        else => false,
+                    };
+                    if (nonstring) try w.writeAll(" zig_nonstring");
+                },
+                .declarator_suffix_ignore_nonstring => {
+                    try ctx.cty.writeTypeSuffix(w, ctx.zcu);
+                },
+            }
+        }
+    };
+
+    fn writeTypePrefix(cty: CType, w: *Writer, zcu: *const Zcu) Writer.Error!void {
+        switch (cty) {
+            .void => try w.writeAll("void"),
+            .bool => try w.writeAll("bool"),
+            .int => |int| try w.writeAll(@tagName(int)),
+            .float => |float| try w.writeAll(@tagName(float)),
+            .@"fn" => |ty| try w.print("{f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .@"enum" => |ty| try w.print("enum__{f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .bitpack => |ty| try w.print("bitpack__{f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .@"struct" => |ty| try w.print("struct {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .union_auto => |ty| try w.print("struct {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .union_extern => |ty| try w.print("union {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .slice => |ty| try w.print("struct {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .opt => |ty| try w.print("struct {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .arr => |ty| try w.print("struct {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .vec => |ty| try w.print("struct {f}_{d}", .{ fmtZigType(ty, zcu), ty.toIntern() }),
+            .errunion => |eu| try w.print("struct errunion_{f}_{d}", .{
+                fmtZigType(eu.payload_ty, zcu),
+                eu.payload_ty.toIntern(),
+            }),
+            .aligned => |aligned| try w.print("aligned__{d}_{f}_{d}", .{
+                aligned.alignment.toByteUnits().?,
+                fmtZigType(aligned.ty, zcu),
+                aligned.ty.toIntern(),
+            }),
+            .bigint => |bigint| try w.print("struct int_{d}x{d}", .{
+                bigint.limb_size.bits(),
+                bigint.limbs_len,
+            }),
+
+            .pointer => |ptr| {
+                try ptr.elem_ty.writeTypePrefix(w, zcu);
+                switch (ptr.elem_ty.kind()) {
+                    .pointer, .postfix_op => {},
+                    .specifier => {
+                        // We want "foo *" or "foo const *" rather than "foo*" or "fooconst *".
+                        try w.writeByte(' ');
+                    },
+                }
+                if (ptr.@"const") try w.writeAll("const ");
+                if (ptr.@"volatile") try w.writeAll("volatile ");
+                switch (ptr.elem_ty.kind()) {
+                    .specifier, .pointer => {},
+                    .postfix_op => {
+                        // Prefix "*" is lower precedence than postfix "(x)" or "[x]" so use parens
+                        // to disambiguate; e.g. "void (*foo)(int)" instead of "void *foo(int)".
+                        try w.writeByte('(');
+                    },
+                }
+                try w.writeByte('*');
+            },
+
+            .array => |array| {
+                try array.elem_ty.writeTypePrefix(w, zcu);
+                switch (array.elem_ty.kind()) {
+                    .pointer, .postfix_op => {},
+                    .specifier => {
+                        // We want e.g. "struct foo [5]" rather than "struct foo[5]".
+                        try w.writeByte(' ');
+                    },
+                }
+            },
+
+            .function => |function| {
+                try function.ret_ty.writeTypePrefix(w, zcu);
+                switch (function.ret_ty.kind()) {
+                    .pointer, .postfix_op => {},
+                    .specifier => {
+                        // We want e.g. "struct foo (void)" rather than "struct foo(void)".
+                        try w.writeByte(' ');
+                    },
+                }
+            },
+        }
+    }
+    fn writeTypeSuffix(cty: CType, w: *Writer, zcu: *const Zcu) Writer.Error!void {
+        switch (cty) {
+            // simple type specifiers
+            .void,
+            .bool,
+            .int,
+            .float,
+            .@"fn",
+            .@"enum",
+            .bitpack,
+            .@"struct",
+            .union_auto,
+            .union_extern,
+            .slice,
+            .opt,
+            .arr,
+            .vec,
+            .errunion,
+            .aligned,
+            .bigint,
+            => {},
+
+            .pointer => |ptr| {
+                // Match opening paren "(" write `writeTypePrefix`.
+                switch (ptr.elem_ty.kind()) {
+                    .specifier, .pointer => {},
+                    .postfix_op => try w.writeByte(')'),
+                }
+                try ptr.elem_ty.writeTypeSuffix(w, zcu);
+            },
+
+            .array => |array| {
+                try w.print("[{d}]", .{array.len});
+                try array.elem_ty.writeTypeSuffix(w, zcu);
+            },
+
+            .function => |function| {
+                if (function.param_tys.len == 0 and !function.varargs) {
+                    try w.writeAll("(void)");
+                } else {
+                    try w.writeByte('(');
+                    for (function.param_tys, 0..) |param_ty, param_index| {
+                        if (param_index > 0) try w.writeAll(", ");
+                        try param_ty.writeTypePrefix(w, zcu);
+                        try param_ty.writeTypeSuffix(w, zcu);
+                    }
+                    if (function.varargs) {
+                        if (function.param_tys.len > 0) try w.writeAll(", ");
+                        try w.writeAll("...");
+                    }
+                    try w.writeByte(')');
+                }
+                try function.ret_ty.writeTypeSuffix(w, zcu);
+            },
+        }
+    }
+
+    /// Renders Zig types using only bytes allowed in C identifiers in a somewhat-understandable
+    /// way. The output is *not* guaranteed to be unique.
+    fn fmtZigType(ty: Type, zcu: *const Zcu) FormatZigType {
+        return .{ .ty = ty, .zcu = zcu };
+    }
+    const FormatZigType = struct {
+        ty: Type,
+        zcu: *const Zcu,
+        pub fn format(ctx: FormatZigType, w: *Writer) Writer.Error!void {
+            const ty = ctx.ty;
+            const zcu = ctx.zcu;
+            const ip = &zcu.intern_pool;
+            switch (ty.zigTypeTag(zcu)) {
+                .frame => unreachable,
+                .@"anyframe" => unreachable,
+
+                .type => try w.writeAll("type"),
+                .void => try w.writeAll("void"),
+                .bool => try w.writeAll("bool"),
+                .noreturn => try w.writeAll("noreturn"),
+                .comptime_int => try w.writeAll("comptime_int"),
+                .comptime_float => try w.writeAll("comptime_float"),
+                .enum_literal => try w.writeAll("enum_literal"),
+                .undefined => try w.writeAll("undefined"),
+                .null => try w.writeAll("null"),
+
+                .int => switch (ty.toIntern()) {
+                    .usize_type => try w.writeAll("usize"),
+                    .isize_type => try w.writeAll("isize"),
+                    .c_char_type => try w.writeAll("c_char"),
+                    .c_short_type => try w.writeAll("c_short"),
+                    .c_ushort_type => try w.writeAll("c_ushort"),
+                    .c_int_type => try w.writeAll("c_int"),
+                    .c_uint_type => try w.writeAll("c_uint"),
+                    .c_long_type => try w.writeAll("c_long"),
+                    .c_ulong_type => try w.writeAll("c_ulong"),
+                    .c_longlong_type => try w.writeAll("c_longlong"),
+                    .c_ulonglong_type => try w.writeAll("c_ulonglong"),
+                    else => {
+                        const info = ty.intInfo(zcu);
+                        switch (info.signedness) {
+                            .unsigned => try w.print("u{d}", .{info.bits}),
+                            .signed => try w.print("i{d}", .{info.bits}),
+                        }
+                    },
+                },
+                .float => switch (ty.toIntern()) {
+                    .c_longdouble_type => try w.writeAll("c_longdouble"),
+                    .f16_type => try w.writeAll("f16"),
+                    .f32_type => try w.writeAll("f32"),
+                    .f64_type => try w.writeAll("f64"),
+                    .f80_type => try w.writeAll("f80"),
+                    .f128_type => try w.writeAll("f128"),
+                    else => unreachable,
+                },
+                .error_set => switch (ty.toIntern()) {
+                    .anyerror_type => try w.writeAll("anyerror"),
+                    else => try w.print("error_{d}", .{@intFromEnum(ty.toIntern())}),
+                },
+                .optional => try w.print("opt_{f}", .{fmtZigType(ty.optionalChild(zcu), zcu)}),
+                .error_union => try w.print("errunion_{f}", .{fmtZigType(ty.errorUnionPayload(zcu), zcu)}),
+
+                .pointer => switch (ty.ptrSize(zcu)) {
+                    .one, .many, .c => try w.print("ptr_{f}", .{fmtZigType(ty.childType(zcu), zcu)}),
+                    .slice => try w.print("slice_{f}", .{fmtZigType(ty.childType(zcu), zcu)}),
+                },
+                .@"fn" => {
+                    const func_type = ip.indexToKey(ty.toIntern()).func_type;
+                    try w.writeAll("fn_"); // intentional double underscore to start
+                    for (func_type.param_types.get(ip)) |param_ty_ip| {
+                        const param_ty: Type = .fromInterned(param_ty_ip);
+                        try w.print("_P{f}", .{fmtZigType(param_ty, zcu)});
+                    }
+                    if (func_type.is_var_args) {
+                        try w.writeAll("_VA");
+                    }
+                    const ret_ty: Type = .fromInterned(func_type.return_type);
+                    try w.print("_R{f}", .{fmtZigType(ret_ty, zcu)});
+                },
+
+                .vector => try w.print("vec_{d}_{f}", .{
+                    ty.arrayLen(zcu),
+                    fmtZigType(ty.childType(zcu), zcu),
+                }),
+
+                .array => if (ty.sentinel(zcu)) |s| try w.print("arr_{d}s{d}_{f}", .{
+                    ty.arrayLen(zcu),
+                    @intFromEnum(s.toIntern()),
+                    fmtZigType(ty.childType(zcu), zcu),
+                }) else try w.print("arr_{d}_{f}", .{
+                    ty.arrayLen(zcu),
+                    fmtZigType(ty.childType(zcu), zcu),
+                }),
+
+                .@"struct" => if (ty.isTuple(zcu)) {
+                    const len = ty.structFieldCount(zcu);
+                    try w.print("tuple_{d}", .{len});
+                    for (0..len) |field_index| {
+                        const field_ty = ty.fieldType(field_index, zcu);
+                        try w.print("_{f}", .{fmtZigType(field_ty, zcu)});
+                    }
+                } else {
+                    const name = ty.containerTypeName(ip).toSlice(ip);
+                    try w.print("{f}", .{@import("../c.zig").fmtIdentUnsolo(name)});
+                },
+                .@"opaque" => if (ty.toIntern() == .anyopaque_type) {
+                    try w.writeAll("anyopaque");
+                } else {
+                    const name = ty.containerTypeName(ip).toSlice(ip);
+                    try w.print("{f}", .{@import("../c.zig").fmtIdentUnsolo(name)});
+                },
+                .@"union", .@"enum" => {
+                    const name = ty.containerTypeName(ip).toSlice(ip);
+                    try w.print("{f}", .{@import("../c.zig").fmtIdentUnsolo(name)});
+                },
+            }
+        }
+    };
+
+    /// Returns `true` if the layout of `ty` is known without any type resolution required. This
+    /// allows some types to be lowered directly where 'typedef' would otherwise be necessary.
+    fn alwaysHasLayout(ty: Type, ip: *const InternPool) bool {
+        return switch (ip.indexToKey(ty.toIntern())) {
+            .int_type,
+            .ptr_type,
+            .anyframe_type,
+            .simple_type,
+            .opaque_type,
+            .error_set_type,
+            .inferred_error_set_type,
+            => true,
+
+            .struct_type,
+            .union_type,
+            .enum_type,
+            => false,
+
+            .array_type => |arr| alwaysHasLayout(.fromInterned(arr.child), ip),
+            .vector_type => |vec| alwaysHasLayout(.fromInterned(vec.child), ip),
+            .opt_type => |child| alwaysHasLayout(.fromInterned(child), ip),
+            .error_union_type => |eu| alwaysHasLayout(.fromInterned(eu.payload_type), ip),
+
+            .tuple_type => |tuple| for (tuple.types.get(ip)) |field_ty| {
+                if (!alwaysHasLayout(.fromInterned(field_ty), ip)) break false;
+            } else true,
+
+            .func_type => |f| for (f.param_types.get(ip)) |param_ty| {
+                if (!alwaysHasLayout(.fromInterned(param_ty), ip)) break false;
+            } else alwaysHasLayout(.fromInterned(f.return_type), ip),
+
+            // values, not types
+            .undef,
+            .simple_value,
+            .variable,
+            .@"extern",
+            .func,
+            .int,
+            .err,
+            .error_union,
+            .enum_literal,
+            .enum_tag,
+            .float,
+            .ptr,
+            .slice,
+            .opt,
+            .aggregate,
+            .un,
+            .bitpack,
+            // memoization, not types
+            .memoized_call,
+            => unreachable,
+        };
+    }
+};
+
+const Zcu = @import("../../Zcu.zig");
+const Type = @import("../../Type.zig");
+const Value = @import("../../Value.zig");
+const InternPool = @import("../../InternPool.zig");
+
+const std = @import("std");
+const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;
+const Writer = std.Io.Writer;
diff --git a/src/codegen/c/type/render_defs.zig b/src/codegen/c/type/render_defs.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a34b0d6d3ce720663b63202e7e4260243f9bbb0f
--- /dev/null
+++ b/src/codegen/c/type/render_defs.zig
@@ -0,0 +1,651 @@
+/// Renders the `typedef` for an aligned type.
+pub fn defineAligned(
+    ty: Type,
+    alignment: Alignment,
+    complete: bool,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+
+    const name_cty: CType = .{ .aligned = .{
+        .ty = ty,
+        .alignment = alignment,
+    } };
+
+    const cty: CType = try .lower(ty, deps, arena, zcu);
+
+    try w.writeAll("typedef ");
+    if (complete and alignment.compareStrict(.lt, ty.abiAlignment(zcu))) {
+        try w.print("zig_under_align({d}) ", .{alignment.toByteUnits().?});
+    }
+    try w.print("{f}{f}{f}; /* align({d}) {f} */\n", .{
+        cty.fmtDeclaratorPrefix(zcu),
+        name_cty.fmtTypeName(zcu),
+        cty.fmtDeclaratorSuffix(zcu),
+        alignment.toByteUnits().?,
+        ty.fmt(pt),
+    });
+}
+/// Renders the definition of a big-int `struct`.
+pub fn defineBigInt(big: CType.BigInt, w: *Writer, zcu: *const Zcu) Writer.Error!void {
+    const name_cty: CType = .{ .bigint = .{
+        .limb_size = big.limb_size,
+        .limbs_len = big.limbs_len,
+    } };
+    const limb_cty: CType = .{ .int = big.limb_size.unsigned() };
+    const array_cty: CType = .{ .array = .{
+        .len = big.limbs_len,
+        .elem_ty = &limb_cty,
+        .nonstring = limb_cty.isStringElem(),
+    } };
+    try w.print("{f} {{ {f}limbs{f}; }}; /* {d} bits */\n", .{
+        name_cty.fmtTypeName(zcu),
+        array_cty.fmtDeclaratorPrefix(zcu),
+        array_cty.fmtDeclaratorSuffix(zcu),
+        big.limb_size.bits() * @as(u17, big.limbs_len),
+    });
+}
+
+/// Renders a forward declaration of the `struct` which represents an error union whose payload type
+/// is `payload_ty` (the error set type is unspecified).
+pub fn errunionFwdDecl(payload_ty: Type, w: *Writer, zcu: *const Zcu) Writer.Error!void {
+    const name_cty: CType = .{ .errunion = .{
+        .payload_ty = payload_ty,
+    } };
+    try w.print("{f};\n", .{name_cty.fmtTypeName(zcu)});
+}
+/// Renders the definition of the `struct` which represents an error union whose payload type is
+/// `payload_ty` (the error set type is unspecified).
+///
+/// Asserts that the layout of `payload_ty` is resolved.
+pub fn errunionDefineComplete(
+    payload_ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+
+    payload_ty.assertHasLayout(zcu);
+
+    const name_cty: CType = .{ .errunion = .{
+        .payload_ty = payload_ty,
+    } };
+
+    const error_cty: CType = try .lower(.anyerror, deps, arena, zcu);
+
+    if (payload_ty.hasRuntimeBits(zcu)) {
+        const payload_cty: CType = try .lower(payload_ty, deps, arena, zcu);
+        try w.print(
+            \\{f} {{ /* anyerror!{f} */
+            \\ {f}payload{f};
+            \\ {f}error{f};
+            \\}};
+            \\
+        , .{
+            name_cty.fmtTypeName(zcu),
+            payload_ty.fmt(pt),
+            payload_cty.fmtDeclaratorPrefix(zcu),
+            payload_cty.fmtDeclaratorSuffix(zcu),
+            error_cty.fmtDeclaratorPrefix(zcu),
+            error_cty.fmtDeclaratorSuffix(zcu),
+        });
+    } else {
+        try w.print("{f} {{ {f}error{f}; }}; /* anyerror!{f} */\n", .{
+            name_cty.fmtTypeName(zcu),
+            error_cty.fmtDeclaratorPrefix(zcu),
+            error_cty.fmtDeclaratorSuffix(zcu),
+            payload_ty.fmt(pt),
+        });
+    }
+}
+
+/// If the Zig type `ty` lowers to a `struct` or `union` type, renders a forward declaration of that
+/// type. Does not write anything for error union types, because their forward declarations are
+/// instead rendered by `errunionFwdDecl`.
+pub fn fwdDecl(ty: Type, w: *Writer, zcu: *const Zcu) Writer.Error!void {
+    const name_cty: CType = switch (ty.zigTypeTag(zcu)) {
+        .@"struct" => switch (ty.containerLayout(zcu)) {
+            .auto, .@"extern" => .{ .@"struct" = ty },
+            .@"packed" => return,
+        },
+        .@"union" => switch (ty.containerLayout(zcu)) {
+            .auto => .{ .union_auto = ty },
+            .@"extern" => .{ .union_extern = ty },
+            .@"packed" => return,
+        },
+        .pointer => if (ty.isSlice(zcu)) .{ .slice = ty } else return,
+        .optional => .{ .opt = ty },
+        .array => .{ .arr = ty },
+        .vector => .{ .vec = ty },
+        else => return,
+    };
+    try w.print("{f};\n", .{name_cty.fmtTypeName(zcu)});
+}
+
+/// If the Zig type `ty` lowers to a `typedef`, renders a typedef of that type to `void`, because
+/// the type's layout is not resolved. This is only necessary for `typedef`s because a `struct` or
+/// `union` which is never defined is already an incomplete type, just like `void`.
+pub fn defineIncomplete(ty: Type, w: *Writer, pt: Zcu.PerThread) Writer.Error!void {
+    const zcu = pt.zcu;
+    const name_cty: CType = switch (ty.zigTypeTag(zcu)) {
+        .@"fn" => .{ .@"fn" = ty },
+        .@"enum" => .{ .@"enum" = ty },
+        .@"struct", .@"union" => switch (ty.containerLayout(zcu)) {
+            .auto, .@"extern" => return,
+            .@"packed" => .{ .bitpack = ty },
+        },
+        else => return,
+    };
+    try w.print("typedef void {f}; /* {f} */\n", .{
+        name_cty.fmtTypeName(zcu),
+        ty.fmt(pt),
+    });
+}
+
+/// If the Zig type `ty` lowers to a `struct` or `union` type, or to a `typedef`, renders the
+/// definition of that type. Does not write anything for error union types, because their
+/// definitions are instead rendered by `errunionDefine`.
+///
+/// Asserts that the layout of `ty` is resolved.
+pub fn defineComplete(
+    ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+
+    ty.assertHasLayout(zcu);
+
+    switch (ty.zigTypeTag(zcu)) {
+        .@"fn" => if (!ty.fnHasRuntimeBits(zcu)) {
+            const name_cty: CType = .{ .@"fn" = ty };
+            try w.print("typedef void {f}; /* {f} */\n", .{
+                name_cty.fmtTypeName(zcu),
+                ty.fmt(pt),
+            });
+        } else {
+            const ip = &zcu.intern_pool;
+            const func_type = ip.indexToKey(ty.toIntern()).func_type;
+
+            // While incomplete types are usually an acceptable substitute for "void", this is not
+            // true in function return types, where "void" is the only incomplete type permitted.
+            const actual_ret_ty: Type = .fromInterned(func_type.return_type);
+            const effective_ret_ty: Type = switch (actual_ret_ty.classify(zcu)) {
+                .no_possible_value => .noreturn,
+                .one_possible_value, .fully_comptime => .void, // no runtime bits
+                .partially_comptime, .runtime => actual_ret_ty, // yes runtime bits
+            };
+
+            const name_cty: CType = .{ .@"fn" = ty };
+            const ret_cty: CType = try .lower(effective_ret_ty, deps, arena, zcu);
+
+            try w.print("typedef {f}{f}(", .{
+                ret_cty.fmtDeclaratorPrefix(zcu),
+                name_cty.fmtTypeName(zcu),
+            });
+            var any_params = false;
+            for (func_type.param_types.get(ip)) |param_ty_ip| {
+                const param_ty: Type = .fromInterned(param_ty_ip);
+                if (!param_ty.hasRuntimeBits(zcu)) continue;
+                if (any_params) try w.writeAll(", ");
+                any_params = true;
+                const param_cty: CType = try .lower(param_ty, deps, arena, zcu);
+                try w.print("{f}", .{param_cty.fmtTypeName(zcu)});
+            }
+            if (func_type.is_var_args) {
+                if (any_params) try w.writeAll(", ");
+                try w.writeAll("...");
+            } else if (!any_params) {
+                try w.writeAll("void");
+            }
+            try w.print("){f}; /* {f} */\n", .{
+                ret_cty.fmtDeclaratorSuffixIgnoreNonstring(zcu),
+                ty.fmt(pt),
+            });
+        },
+        .@"enum" => {
+            const name_cty: CType = .{ .@"enum" = ty };
+            const cty: CType = try .lower(ty.intTagType(zcu), deps, arena, zcu);
+            try w.print("typedef {f}{f}{f}; /* {f} */\n", .{
+                cty.fmtDeclaratorPrefix(zcu),
+                name_cty.fmtTypeName(zcu),
+                cty.fmtDeclaratorSuffix(zcu),
+                ty.fmt(pt),
+            });
+        },
+        .@"struct" => if (ty.isTuple(zcu)) {
+            try defineTuple(ty, deps, arena, w, pt);
+        } else switch (ty.containerLayout(zcu)) {
+            .auto, .@"extern" => try defineStruct(ty, deps, arena, w, pt),
+            .@"packed" => try defineBitpack(ty, deps, arena, w, pt),
+        },
+        .@"union" => switch (ty.containerLayout(zcu)) {
+            .auto => try defineUnionAuto(ty, deps, arena, w, pt),
+            .@"extern" => try defineUnionExtern(ty, deps, arena, w, pt),
+            .@"packed" => try defineBitpack(ty, deps, arena, w, pt),
+        },
+        .pointer => if (ty.isSlice(zcu)) {
+            const name_cty: CType = .{ .slice = ty };
+            const ptr_cty: CType = try .lower(ty.slicePtrFieldType(zcu), deps, arena, zcu);
+            try w.print(
+                \\{f} {{ /* {f} */
+                \\ {f}ptr{f};
+                \\ size_t len;
+                \\}};
+                \\
+            , .{
+                name_cty.fmtTypeName(zcu),
+                ty.fmt(pt),
+                ptr_cty.fmtDeclaratorPrefix(zcu),
+                ptr_cty.fmtDeclaratorSuffix(zcu),
+            });
+        },
+        .optional => switch (CType.classifyOptional(ty, zcu)) {
+            .error_set,
+            .ptr_like,
+            .slice_like,
+            .npv_payload,
+            => {},
+
+            .opv_payload => {
+                const name_cty: CType = .{ .opt = ty };
+                try w.print("{f} {{ bool is_null; }}; /* {f} */\n", .{
+                    name_cty.fmtTypeName(zcu),
+                    ty.fmt(pt),
+                });
+            },
+
+            .@"struct" => {
+                const name_cty: CType = .{ .opt = ty };
+                const payload_cty: CType = try .lower(ty.optionalChild(zcu), deps, arena, zcu);
+                try w.print(
+                    \\{f} {{ /* {f} */
+                    \\ {f}payload{f};
+                    \\ bool is_null;
+                    \\}};
+                    \\
+                , .{
+                    name_cty.fmtTypeName(zcu),
+                    ty.fmt(pt),
+                    payload_cty.fmtDeclaratorPrefix(zcu),
+                    payload_cty.fmtDeclaratorSuffix(zcu),
+                });
+            },
+        },
+        .array => if (ty.hasRuntimeBits(zcu)) {
+            const name_cty: CType = .{ .arr = ty };
+            const elem_cty: CType = try .lower(ty.childType(zcu), deps, arena, zcu);
+            const array_cty: CType = .{ .array = .{
+                .len = ty.arrayLenIncludingSentinel(zcu),
+                .elem_ty = &elem_cty,
+                .nonstring = nonstring: {
+                    if (!elem_cty.isStringElem()) break :nonstring false;
+                    const s = ty.sentinel(zcu) orelse break :nonstring true;
+                    break :nonstring Value.compareHetero(s, .neq, .zero_comptime_int, zcu);
+                },
+            } };
+            try w.print("{f} {{ {f}array{f}; }}; /* {f} */\n", .{
+                name_cty.fmtTypeName(zcu),
+                array_cty.fmtDeclaratorPrefix(zcu),
+                array_cty.fmtDeclaratorSuffix(zcu),
+                ty.fmt(pt),
+            });
+        },
+        .vector => if (ty.hasRuntimeBits(zcu)) {
+            const name_cty: CType = .{ .vec = ty };
+            const elem_cty: CType = try .lower(ty.childType(zcu), deps, arena, zcu);
+            const array_cty: CType = .{ .array = .{
+                .len = ty.arrayLenIncludingSentinel(zcu),
+                .elem_ty = &elem_cty,
+                .nonstring = elem_cty.isStringElem(),
+            } };
+            try w.print("{f} {{ {f}array{f}; }}; /* {f} */\n", .{
+                name_cty.fmtTypeName(zcu),
+                array_cty.fmtDeclaratorPrefix(zcu),
+                array_cty.fmtDeclaratorSuffix(zcu),
+                ty.fmt(pt),
+            });
+        },
+        else => {},
+    }
+}
+fn defineBitpack(
+    ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+    const name_cty: CType = .{ .bitpack = ty };
+    const cty: CType = try .lower(ty.bitpackBackingInt(zcu), deps, arena, zcu);
+    try w.print("typedef {f}{f}{f}; /* {f} */\n", .{
+        cty.fmtDeclaratorPrefix(zcu),
+        name_cty.fmtTypeName(zcu),
+        cty.fmtDeclaratorSuffix(zcu),
+        ty.fmt(pt),
+    });
+}
+fn defineTuple(
+    ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+    if (!ty.hasRuntimeBits(zcu)) return;
+    const ip = &zcu.intern_pool;
+    const tuple = ip.indexToKey(ty.toIntern()).tuple_type;
+
+    // Fields cannot be underaligned, because tuple fields cannot have specified alignments.
+    // However, overaligned fields are possible thanks to intermediate zero-bit fields.
+
+    const tuple_align = ty.abiAlignment(zcu);
+
+    // If the alignment of other fields would not give the tuple sufficient alignment, we
+    // need to align the first field (which does not affect its offset, because 0 is always
+    // well-aligned) to indirectly specify the tuple alignment.
+    const overalign: bool = for (tuple.types.get(ip)) |field_ty_ip| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
+        const natural_align = field_ty.defaultStructFieldAlignment(.auto, zcu);
+        if (natural_align.compareStrict(.gte, tuple_align)) break false;
+    } else true;
+
+    const name_cty: CType = .{ .@"struct" = ty };
+    try w.print("{f} {{ /* {f} */\n", .{
+        name_cty.fmtTypeName(zcu),
+        ty.fmt(pt),
+    });
+    var zig_offset: u64 = 0;
+    var c_offset: u64 = 0;
+    for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty_ip, field_val_ip, field_index| {
+        if (field_val_ip != .none) continue; // `comptime` field
+        const field_ty: Type = .fromInterned(field_ty_ip);
+        const field_align = field_ty.abiAlignment(zcu);
+        zig_offset = field_align.forward(zig_offset);
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
+        c_offset = field_align.forward(c_offset);
+        if (zig_offset == 0 and overalign) {
+            // This is the first field; specify its alignment to align the tuple.
+            try w.print(" zig_align({d})", .{tuple_align.toByteUnits().?});
+        } else if (zig_offset > c_offset) {
+            // This field needs to be overaligned compared to what its offset would otherwise be.
+            const need_align: Alignment = .fromLog2Units(@ctz(zig_offset));
+            try w.print(" zig_align({d})", .{need_align.toByteUnits().?});
+            c_offset = need_align.forward(c_offset);
+            assert(c_offset == zig_offset);
+        }
+        const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
+        try w.print(" {f}f{d}{f};\n", .{
+            field_cty.fmtDeclaratorPrefix(zcu),
+            field_index,
+            field_cty.fmtDeclaratorSuffix(zcu),
+        });
+        const field_size = field_ty.abiSize(zcu);
+        zig_offset += field_size;
+        c_offset += field_size;
+    }
+    try w.writeAll("};\n");
+}
+fn defineStruct(
+    ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+    if (!ty.hasRuntimeBits(zcu)) return;
+    const ip = &zcu.intern_pool;
+
+    const struct_type = ip.loadStructType(ty.toIntern());
+
+    // If there are any underaligned fields, we need to byte-pack the struct.
+    const pack: bool = pack: {
+        var it = struct_type.iterateRuntimeOrder(ip);
+        var offset: u64 = 0;
+        while (it.next()) |field_index| {
+            const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
+            if (!field_ty.hasRuntimeBits(zcu)) continue;
+            const natural_align = field_ty.defaultStructFieldAlignment(struct_type.layout, zcu);
+            const natural_offset = natural_align.forward(offset);
+            const actual_offset = struct_type.field_offsets.get(ip)[field_index];
+            if (actual_offset < natural_offset) break :pack true;
+            offset = actual_offset + field_ty.abiSize(zcu);
+        }
+        break :pack false;
+    };
+
+    // If the alignment of other fields would not give the struct sufficient alignment, we
+    // need to align the first field (which does not affect its offset, because 0 is always
+    // well-aligned) to indirectly specify the struct alignment.
+    const overalign: bool = switch (pack) {
+        true => struct_type.alignment.compareStrict(.gt, .@"1"),
+        false => overalign: {
+            var it = struct_type.iterateRuntimeOrder(ip);
+            while (it.next()) |field_index| {
+                const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
+                if (!field_ty.hasRuntimeBits(zcu)) continue;
+                const natural_align = field_ty.defaultStructFieldAlignment(struct_type.layout, zcu);
+                if (natural_align.compareStrict(.gte, struct_type.alignment)) break :overalign false;
+            }
+            break :overalign true;
+        },
+    };
+
+    if (pack) try w.writeAll("zig_packed(");
+    const name_cty: CType = .{ .@"struct" = ty };
+    try w.print("{f} {{ /* {f} */\n", .{
+        name_cty.fmtTypeName(zcu),
+        ty.fmt(pt),
+    });
+    var it = struct_type.iterateRuntimeOrder(ip);
+    var offset: u64 = 0;
+    while (it.next()) |field_index| {
+        const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
+        const natural_align = field_ty.defaultStructFieldAlignment(struct_type.layout, zcu);
+        const natural_offset = switch (pack) {
+            true => offset,
+            false => natural_align.forward(offset),
+        };
+        const actual_offset = struct_type.field_offsets.get(ip)[field_index];
+        if (actual_offset == 0 and overalign) {
+            // This is the first field; specify its alignment to align the struct.
+            try w.print(" zig_align({d})", .{struct_type.alignment.toByteUnits().?});
+        } else if (actual_offset > natural_offset) {
+            // This field needs to be underaligned or overaligned compared to what its
+            // offset would otherwise be.
+            const need_align: Alignment = .fromLog2Units(@ctz(actual_offset));
+            if (need_align.compareStrict(.lt, natural_align)) {
+                try w.print(" zig_under_align({d})", .{need_align.toByteUnits().?});
+            } else {
+                try w.print(" zig_align({d})", .{need_align.toByteUnits().?});
+            }
+        }
+        const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
+        const field_name = struct_type.field_names.get(ip)[field_index].toSlice(ip);
+        try w.print(" {f}{f}{f};\n", .{
+            field_cty.fmtDeclaratorPrefix(zcu),
+            fmtIdentSolo(field_name),
+            field_cty.fmtDeclaratorSuffix(zcu),
+        });
+        offset = actual_offset + field_ty.abiSize(zcu);
+    }
+    assert(struct_type.alignment.forward(offset) == struct_type.size);
+    try w.writeByte('}');
+    if (pack) try w.writeByte(')');
+    try w.writeAll(";\n");
+}
+fn defineUnionAuto(
+    ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+    if (!ty.hasRuntimeBits(zcu)) return;
+    const ip = &zcu.intern_pool;
+
+    const union_type = ip.loadUnionType(ty.toIntern());
+    const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
+
+    // If there are any underaligned fields, we need to byte-pack the union.
+    const pack: bool = for (union_type.field_types.get(ip)) |field_ty_ip| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
+        const natural_align = field_ty.abiAlignment(zcu);
+        if (natural_align.compareStrict(.gt, union_type.alignment)) break true;
+    } else false;
+
+    // If the alignment of other fields would not give the union sufficient alignment, we
+    // need to align the first field (which does not affect its offset, because 0 is always
+    // well-aligned) to indirectly specify the union alignment.
+    const overalign: bool = switch (pack) {
+        true => union_type.alignment.compareStrict(.gt, .@"1"),
+        false => for (union_type.field_types.get(ip)) |field_ty_ip| {
+            const field_ty: Type = .fromInterned(field_ty_ip);
+            if (!field_ty.hasRuntimeBits(zcu)) continue;
+            const natural_align = field_ty.abiAlignment(zcu);
+            if (natural_align.compareStrict(.gte, union_type.alignment)) break false;
+        } else overalign: {
+            if (union_type.has_runtime_tag) {
+                const tag_align = enum_tag_ty.abiAlignment(zcu);
+                if (tag_align.compareStrict(.gte, union_type.alignment)) break :overalign false;
+            }
+            break :overalign true;
+        },
+    };
+
+    const payload_has_bits = !union_type.has_runtime_tag or union_type.size > enum_tag_ty.abiSize(zcu);
+
+    const name_cty: CType = .{ .union_auto = ty };
+    try w.print("{f} {{ /* {f} */\n", .{
+        name_cty.fmtTypeName(zcu),
+        ty.fmt(pt),
+    });
+    if (payload_has_bits) {
+        try w.writeByte(' ');
+        if (pack) try w.writeAll("zig_packed(");
+        try w.writeAll("union {\n");
+        for (0..enum_tag_ty.enumFieldCount(zcu)) |field_index| {
+            const field_ty = ty.fieldType(field_index, zcu);
+            if (!field_ty.hasRuntimeBits(zcu)) continue;
+            const field_name = enum_tag_ty.enumFieldName(field_index, zcu).toSlice(ip);
+            const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
+            try w.writeAll("  ");
+            if (overalign and field_index == 0) {
+                // This is the first field; specify its alignment to align the union.
+                try w.print("zig_align({d}) ", .{union_type.alignment.toByteUnits().?});
+            }
+            try w.print("{f}{f}{f};\n", .{
+                field_cty.fmtDeclaratorPrefix(zcu),
+                fmtIdentSolo(field_name),
+                field_cty.fmtDeclaratorSuffix(zcu),
+            });
+        }
+        try w.writeAll(" }");
+        if (pack) try w.writeByte(')');
+        try w.writeAll(" payload;\n");
+    }
+    if (union_type.has_runtime_tag) {
+        const tag_cty: CType = try .lower(enum_tag_ty, deps, arena, zcu);
+        try w.print(" {f}tag{f};\n", .{
+            tag_cty.fmtDeclaratorPrefix(zcu),
+            tag_cty.fmtDeclaratorSuffix(zcu),
+        });
+    }
+    try w.writeAll("};\n");
+}
+fn defineUnionExtern(
+    ty: Type,
+    deps: *CType.Dependencies,
+    arena: Allocator,
+    w: *Writer,
+    pt: Zcu.PerThread,
+) (Allocator.Error || Writer.Error)!void {
+    const zcu = pt.zcu;
+    if (!ty.hasRuntimeBits(zcu)) return;
+    const ip = &zcu.intern_pool;
+
+    const union_type = ip.loadUnionType(ty.toIntern());
+    assert(!union_type.has_runtime_tag);
+    const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
+
+    // If there are any underaligned fields, we need to byte-pack the union.
+    const pack: bool = for (union_type.field_types.get(ip)) |field_ty_ip| {
+        const field_ty: Type = .fromInterned(field_ty_ip);
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
+        const natural_align = field_ty.abiAlignment(zcu);
+        if (natural_align.compareStrict(.gt, union_type.alignment)) break true;
+    } else false;
+
+    // If the alignment of other fields would not give the union sufficient alignment, we
+    // need to align the first field (which does not affect its offset, because 0 is always
+    // well-aligned) to indirectly specify the union alignment.
+    const overalign: bool = switch (pack) {
+        true => union_type.alignment.compareStrict(.gt, .@"1"),
+        false => for (union_type.field_types.get(ip)) |field_ty_ip| {
+            const field_ty: Type = .fromInterned(field_ty_ip);
+            if (!field_ty.hasRuntimeBits(zcu)) continue;
+            const natural_align = field_ty.abiAlignment(zcu);
+            if (natural_align.compareStrict(.gte, union_type.alignment)) break false;
+        } else overalign: {
+            if (union_type.has_runtime_tag) {
+                const tag_align = enum_tag_ty.abiAlignment(zcu);
+                if (tag_align.compareStrict(.gte, union_type.alignment)) break :overalign false;
+            }
+            break :overalign true;
+        },
+    };
+
+    if (pack) try w.writeAll("zig_packed(");
+
+    const name_cty: CType = .{ .union_extern = ty };
+    try w.print("{f} {{ /* {f} */\n", .{
+        name_cty.fmtTypeName(zcu),
+        ty.fmt(pt),
+    });
+
+    for (0..enum_tag_ty.enumFieldCount(zcu)) |field_index| {
+        const field_ty = ty.fieldType(field_index, zcu);
+        if (!field_ty.hasRuntimeBits(zcu)) continue;
+        const field_name = enum_tag_ty.enumFieldName(field_index, zcu).toSlice(ip);
+        const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
+        if (overalign and field_index == 0) {
+            // This is the first field; specify its alignment to align the union.
+            try w.print(" zig_align({d})", .{union_type.alignment.toByteUnits().?});
+        }
+        try w.print(" {f}{f}{f};\n", .{
+            field_cty.fmtDeclaratorPrefix(zcu),
+            fmtIdentSolo(field_name),
+            field_cty.fmtDeclaratorSuffix(zcu),
+        });
+    }
+    try w.writeByte('}');
+    if (pack) try w.writeByte(')');
+    try w.writeAll(";\n");
+}
+
+const std = @import("std");
+const assert = std.debug.assert;
+const Writer = std.Io.Writer;
+const Allocator = std.mem.Allocator;
+
+const Zcu = @import("../../../Zcu.zig");
+const Type = @import("../../../Type.zig");
+const Value = @import("../../../Value.zig");
+const CType = @import("../type.zig").CType;
+const Alignment = @import("../../../InternPool.zig").Alignment;
+
+const fmtIdentSolo = @import("../../c.zig").fmtIdentSolo;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 5735fe5e51a665a46e965cd3f01a26bdb57ac094..f8d1310b1c7693c8b2f46fb03debc802d7eba69b 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -23,7 +23,6 @@ const Package = @import("../Package.zig");
 const Air = @import("../Air.zig");
 const Value = @import("../Value.zig");
 const Type = @import("../Type.zig");
-const DebugConstPool = link.DebugConstPool;
 const codegen = @import("../codegen.zig");
 const x86_64_abi = @import("x86_64/abi.zig");
 const wasm_c_abi = @import("wasm/abi.zig");
@@ -532,8 +531,8 @@ pub const Object = struct {
     debug_file_map: std.AutoHashMapUnmanaged(Zcu.File.Index, Builder.Metadata),
 
     /// This pool *only* contains types (and does not contain `@as(type, undefined)`).
-    debug_type_pool: DebugConstPool,
-    /// Keyed on `DebugConstPool.Index`.
+    debug_type_pool: link.ConstPool,
+    /// Keyed on `link.ConstPool.Index`.
     debug_types: std.ArrayList(Builder.Metadata),
     /// Initially `.none`, set if the type `anyerror` is lowered to a debug type. The type will not
     /// actually be created until `emit`, which must resolve this reference with an appropriate enum
@@ -1622,10 +1621,7 @@ pub const Object = struct {
     }
 
     fn flushPendingDebugTypes(o: *Object, pt: Zcu.PerThread) Allocator.Error!void {
-        o.debug_type_pool.flushPending(pt, .{ .llvm = o }) catch |err| switch (err) {
-            error.OutOfMemory => |e| return e,
-            else => unreachable, // TODO: stop self-hosted backends from returning all of this crap!
-        };
+        try o.debug_type_pool.flushPending(pt, .{ .llvm = o });
     }
 
     pub fn updateExports(
@@ -1823,17 +1819,14 @@ pub const Object = struct {
 
     pub fn updateContainerType(o: *Object, pt: Zcu.PerThread, ty: InternPool.Index, success: bool) Allocator.Error!void {
         if (!o.builder.strip) {
-            o.debug_type_pool.updateContainerType(pt, .{ .llvm = o }, ty, success) catch |err| switch (err) {
-                error.OutOfMemory => |e| return e,
-                else => unreachable, // TODO: stop self-hosted backends from returning all of this crap!
-            };
+            try o.debug_type_pool.updateContainerType(pt, .{ .llvm = o }, ty, success);
         }
     }
 
-    /// Should only be called by the `DebugConstPool` implementation.
+    /// Should only be called by the `link.ConstPool` implementation.
     ///
     /// `val` is always a type because `o.debug_type_pool` only contains types.
-    pub fn addConst(o: *Object, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+    pub fn addConst(o: *Object, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
         const zcu = pt.zcu;
         const gpa = zcu.comp.gpa;
         assert(zcu.intern_pool.typeOf(val) == .type_type);
@@ -1846,10 +1839,10 @@ pub const Object = struct {
             o.debug_anyerror_fwd_ref = fwd_ref.toOptional();
         }
     }
-    /// Should only be called by the `DebugConstPool` implementation.
+    /// Should only be called by the `link.ConstPool` implementation.
     ///
     /// `val` is always a type because `o.debug_type_pool` only contains types.
-    pub fn updateConstIncomplete(o: *Object, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+    pub fn updateConstIncomplete(o: *Object, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
         assert(pt.zcu.intern_pool.typeOf(val) == .type_type);
         const fwd_ref = o.debug_types.items[@intFromEnum(index)];
         assert(val != .anyerror_type);
@@ -1857,10 +1850,10 @@ pub const Object = struct {
         const debug_incomplete_type = try o.builder.debugSignedType(name_str, 0);
         o.builder.resolveDebugForwardReference(fwd_ref, debug_incomplete_type);
     }
-    /// Should only be called by the `DebugConstPool` implementation.
+    /// Should only be called by the `link.ConstPool` implementation.
     ///
     /// `val` is always a type because `o.debug_type_pool` only contains types.
-    pub fn updateConst(o: *Object, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+    pub fn updateConst(o: *Object, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
         assert(pt.zcu.intern_pool.typeOf(val) == .type_type);
         const fwd_ref = o.debug_types.items[@intFromEnum(index)];
         if (val == .anyerror_type) {
@@ -1890,10 +1883,7 @@ pub const Object = struct {
 
     fn getDebugType(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error!Builder.Metadata {
         assert(!o.builder.strip);
-        const index = o.debug_type_pool.get(pt, .{ .llvm = o }, ty.toIntern()) catch |err| switch (err) {
-            error.OutOfMemory => |e| return e,
-            else => unreachable, // TODO: stop self-hosted backends from returning all of this crap!
-        };
+        const index = try o.debug_type_pool.get(pt, .{ .llvm = o }, ty.toIntern());
         return o.debug_types.items[@intFromEnum(index)];
     }
 
diff --git a/src/link.zig b/src/link.zig
index c81737484e6da4a0b437b2ab1ad93d76ab9ac02a..3eb4add772149d4a5e149ecf842156cde14d0849 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -29,7 +29,7 @@ const codegen = @import("codegen.zig");
 pub const aarch64 = @import("link/aarch64.zig");
 pub const LdScript = @import("link/LdScript.zig");
 pub const Queue = @import("link/Queue.zig");
-pub const DebugConstPool = @import("link/DebugConstPool.zig");
+pub const ConstPool = @import("link/ConstPool.zig");
 
 pub const Diags = struct {
     /// Stored here so that function definitions can distinguish between
@@ -804,7 +804,7 @@ pub const File = struct {
         switch (base.tag) {
             .lld => unreachable,
             else => {},
-            inline .elf => |tag| {
+            inline .elf, .c => |tag| {
                 dev.check(tag.devFeature());
                 return @as(*tag.Type(), @fieldParentPtr("base", base)).updateContainerType(pt, ty, success);
             },
diff --git a/src/link/C.zig b/src/link/C.zig
index 93e771ebfc3d01a61f7fb5268bd84fe8b639f489..3c71206cc70db582e6d1d462cb49bcb80e51da7b 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -1,3 +1,9 @@
+/// Unlike other linker implementations, `link.C` does not attempt to incrementally link its output,
+/// because C has many language rules which make that impractical. Instead, we individually generate
+/// each declaration (NAV), and the output is stitched together (alongside types and UAVs) in an
+/// appropriate order in `flush`.
+const C = @This();
+
 const std = @import("std");
 const mem = std.mem;
 const assert = std.debug.assert;
@@ -5,7 +11,6 @@ const Allocator = std.mem.Allocator;
 const fs = std.fs;
 const Path = std.Build.Cache.Path;
 
-const C = @This();
 const build_options = @import("build_options");
 const Zcu = @import("../Zcu.zig");
 const Module = @import("../Package/Module.zig");
@@ -19,40 +24,45 @@ const Type = @import("../Type.zig");
 const Value = @import("../Value.zig");
 const AnyMir = @import("../codegen.zig").AnyMir;
 
-pub const zig_h = "#include \"zig.h\"\n";
-
 base: link.File,
-/// This linker backend does not try to incrementally link output C source code.
-/// Instead, it tracks all declarations in this table, and iterates over it
-/// in the flush function, stitching pre-rendered pieces of C code together.
-navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, AvBlock),
-/// All the string bytes of rendered C code, all squished into one array.
-/// While in progress, a separate buffer is used, and then when finished, the
-/// buffer is copied into this one.
+
+/// All the string bytes of rendered C code, all squished into one array. `String` is used to refer
+/// to specific slices of this array, used for the rendered C code of an individual UAV/NAV/type.
+///
+/// During code generation for functions, a separate buffer is used, and the contents of that buffer
+/// are copied into `string_bytes` when the function is emitted by `updateFunc`.
 string_bytes: std.ArrayList(u8),
-/// Tracks all the anonymous decls that are used by all the decls so they can
-/// be rendered during flush().
-uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, AvBlock),
-/// Sparse set of uavs that are overaligned. Underaligned anon decls are
-/// lowered the same as ABI-aligned anon decls. The keys here are a subset of
-/// the keys of `uavs`.
-aligned_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
 
-exported_navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, ExportedBlock),
-exported_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, ExportedBlock),
+/// Like with `string_bytes`, we concatenate all type dependencies into one array, and slice into it
+/// for specific groups of dependencies. These values are indices into `type_pool`, and thus also
+/// into `types`. We store these instead of `InternPool.Index` because it lets us avoid some hash
+/// map lookups in `flush`.
+type_dependencies: std.ArrayList(link.ConstPool.Index),
+/// For storing dependencies on "aligned" versions of types, we must associate each type with a
+/// bitmask of required alignments. As with `type_dependencies`, we concatenate all such masks into
+/// one array.
+align_dependency_masks: std.ArrayList(u64),
 
-/// Optimization, `updateDecl` reuses this buffer rather than creating a new
-/// one with every call.
-fwd_decl_buf: []u8,
-/// Optimization, `updateDecl` reuses this buffer rather than creating a new
-/// one with every call.
-code_header_buf: []u8,
-/// Optimization, `updateDecl` reuses this buffer rather than creating a new
-/// one with every call.
-code_buf: []u8,
-/// Optimization, `flush` reuses this buffer rather than creating a new
-/// one with every call.
-scratch_buf: []u32,
+/// All NAVs, regardless of whether they are functions or simple constants, are put in this map.
+navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, RenderedDecl),
+/// All UAVs which may be referenced are in this map. The UAV alignment is not included in the
+/// rendered C code stored here, because we don't know the alignment a UAV needs until `flush`.
+uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, RenderedDecl),
+/// Contains all types which are needed by some other rendered code. Does not contain any constants
+/// other than types.
+type_pool: link.ConstPool,
+/// Indices are `link.ConstPool.Index` from `type_pool`. Contains rendered C code for every type
+/// which may be referenced. Logic in `flush` will perform the appropriate topological sort to emit
+/// these type definitions in an order which C allows.
+types: std.ArrayList(RenderedType),
+
+/// The set of big int types required by *any* generated code so far. These are always safe to emit,
+/// so they do not participate in the dependency graph traversal in `flush`. Therefore, redundant
+/// big-int types may be emitted under incremental compilation.
+bigint_types: std.AutoArrayHashMapUnmanaged(codegen.CType.BigInt, void),
+
+exported_navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, String),
+exported_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, String),
 
 /// A reference into `string_bytes`.
 const String = extern struct {
@@ -64,50 +74,320 @@ const String = extern struct {
         .len = 0,
     };
 
-    fn concat(lhs: String, rhs: String) String {
-        assert(lhs.start + lhs.len == rhs.start);
+    fn get(s: String, c: *C) []const u8 {
+        return c.string_bytes.items[s.start..][0..s.len];
+    }
+};
+
+const CTypeDependencies = struct {
+    len: u32,
+    errunion_len: u32,
+    fwd_len: u32,
+    errunion_fwd_len: u32,
+    aligned_fwd_len: u32,
+
+    /// Index into `C.type_dependencies`. Starting at this index are:
+    /// * `len` dependencies on complete types
+    /// * `errunion_len` dependencies on complete error union types
+    /// * `fwd_len` dependencies on forward-declared types
+    /// * `errunion_fwd_len` dependencies on forward-declared error union types
+    /// * `aligned_fwd_len` dependencies on aligned types
+    type_start: u32,
+    /// Index into `C.align_dependency_masks`. Starting at this index are `aligned_type_fwd_len`
+    /// items containing the bitmasks for each aligned type (in `C.type_dependencies`).
+    align_mask_start: u32,
+
+    const Resolved = struct {
+        type: []const link.ConstPool.Index,
+        errunion_type: []const link.ConstPool.Index,
+        type_fwd: []const link.ConstPool.Index,
+        errunion_type_fwd: []const link.ConstPool.Index,
+        aligned_type_fwd: []const link.ConstPool.Index,
+        aligned_type_masks: []const u64,
+    };
+
+    fn get(td: *const CTypeDependencies, c: *const C) Resolved {
+        const types_overlong = c.type_dependencies.items[td.type_start..];
         return .{
-            .start = lhs.start,
-            .len = lhs.len + rhs.len,
+            .type = types_overlong[0..td.len],
+            .errunion_type = types_overlong[td.len..][0..td.errunion_len],
+            .type_fwd = types_overlong[td.len + td.errunion_len ..][0..td.fwd_len],
+            .errunion_type_fwd = types_overlong[td.len + td.errunion_len + td.fwd_len ..][0..td.errunion_fwd_len],
+            .aligned_type_fwd = types_overlong[td.len + td.errunion_len + td.fwd_len + td.errunion_fwd_len ..][0..td.aligned_fwd_len],
+            .aligned_type_masks = c.align_dependency_masks.items[td.align_mask_start..][0..td.aligned_fwd_len],
         };
     }
+
+    const empty: CTypeDependencies = .{
+        .len = 0,
+        .errunion_len = 0,
+        .fwd_len = 0,
+        .errunion_fwd_len = 0,
+        .aligned_fwd_len = 0,
+        .type_start = 0,
+        .align_mask_start = 0,
+    };
 };
 
-/// Per-declaration data.
-pub const AvBlock = struct {
-    fwd_decl: String = .empty,
-    code: String = .empty,
-    /// Each `Decl` stores a set of used `CType`s.  In `flush()`, we iterate
-    /// over each `Decl` and generate the definition for each used `CType` once.
-    ctype_pool: codegen.CType.Pool = .empty,
-    /// May contain string references to ctype_pool
-    lazy_fns: codegen.LazyFnMap = .{},
-
-    fn deinit(ab: *AvBlock, gpa: Allocator) void {
-        ab.lazy_fns.deinit(gpa);
-        ab.ctype_pool.deinit(gpa);
-        ab.* = undefined;
+const RenderedDecl = struct {
+    fwd_decl: String,
+    code: String,
+    ctype_deps: CTypeDependencies,
+    need_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
+    need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
+    need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
+    need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
+
+    const init: RenderedDecl = .{
+        .fwd_decl = .empty,
+        .code = .empty,
+        .ctype_deps = .empty,
+        .need_uavs = .empty,
+        .need_tag_name_funcs = .empty,
+        .need_never_tail_funcs = .empty,
+        .need_never_inline_funcs = .empty,
+    };
+
+    fn deinit(rd: *RenderedDecl, gpa: Allocator) void {
+        rd.need_uavs.deinit(gpa);
+        rd.need_tag_name_funcs.deinit(gpa);
+        rd.need_never_tail_funcs.deinit(gpa);
+        rd.need_never_inline_funcs.deinit(gpa);
+        rd.* = undefined;
+    }
+
+    /// We are about to re-render this declaration, but we want to reuse the existing buffers, so
+    /// call `clearRetainCapacity` on the containers. Sets `fwd_decl` and `code` to `undefined`,
+    /// because we shouldn't be using the old values any longer.
+    fn clearRetainingCapacity(rd: *RenderedDecl) void {
+        rd.fwd_decl = undefined;
+        rd.code = undefined;
+        rd.need_uavs.clearRetainingCapacity();
+        rd.need_tag_name_funcs.clearRetainingCapacity();
+        rd.need_never_tail_funcs.clearRetainingCapacity();
+        rd.need_never_inline_funcs.clearRetainingCapacity();
     }
 };
 
-/// Per-exported-symbol data.
-pub const ExportedBlock = struct {
-    fwd_decl: String = .empty,
+const RenderedType = struct {
+    /// If this type lowers to an aggregate, this is a forward declaration of its struct/union tag.
+    /// Otherwise, this is `.empty`.
+    ///
+    /// Populated immediately and never changes.
+    fwd_decl: String,
+
+    /// A forward declaration of an error union type with this type as its *payload*.
+    ///
+    /// Populated immediately and never changes.
+    errunion_fwd_decl: String,
+
+    /// If this type lowers to an aggregate, this is the struct/union definition.
+    /// If this type lowers to a typedef, this is that typedef.
+    /// Otherwise, this is `.empty`.
+    definition: String,
+    /// The `struct` definition for an error union type with this type as its *payload*.
+    ///
+    /// This string is empty iff the payload type does not have a resolved layout. If the layout is
+    /// resolved, the error union struct is defined, even if the payload type lacks runtime bits.
+    errunion_definition: String,
+
+    /// Dependencies which must be satisfied before emitting the name of this type. As such, they
+    /// must be satisfied before emitting `errunion_definition` or any aligned typedef.
+    ///
+    /// Populated immediately and never changes.
+    deps: CTypeDependencies,
+
+    /// Dependencies which must be satisfied before emitting `definition`.
+    definition_deps: CTypeDependencies,
 };
 
-pub fn getString(this: C, s: String) []const u8 {
-    return this.string_bytes.items[s.start..][0..s.len];
+/// Only called by `link.ConstPool` due to `c.type_pool`, so `val` is always a type.
+pub fn addConst(
+    c: *C,
+    pt: Zcu.PerThread,
+    pool_index: link.ConstPool.Index,
+    val: InternPool.Index,
+) Allocator.Error!void {
+    const zcu = pt.zcu;
+    const gpa = zcu.comp.gpa;
+    assert(zcu.intern_pool.typeOf(val) == .type_type);
+    assert(@intFromEnum(pool_index) == c.types.items.len);
+
+    const ty: Type = .fromInterned(val);
+
+    const fwd_decl: String = fwd_decl: {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.CType.render_defs.fwdDecl(ty, &aw.writer, zcu) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+        };
+        break :fwd_decl .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
+    };
+
+    const errunion_fwd_decl: String = errunion_fwd_decl: {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.CType.render_defs.errunionFwdDecl(ty, &aw.writer, zcu) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+        };
+        break :errunion_fwd_decl .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
+    };
+
+    try c.types.append(gpa, .{
+        .fwd_decl = fwd_decl,
+        .errunion_fwd_decl = errunion_fwd_decl,
+        // This field will be populated just below.
+        .deps = undefined,
+        // The remaining fields will be populated later by either `updateConstIncomplete` or
+        // `updateConstComplete` (it is guaranteed that at least one will be called).
+        .definition = undefined,
+        .errunion_definition = undefined,
+        .definition_deps = undefined,
+    });
+
+    {
+        // Find the dependencies required to just render the type `ty`.
+        var arena: std.heap.ArenaAllocator = .init(gpa);
+        defer arena.deinit();
+        var deps: codegen.CType.Dependencies = .empty;
+        defer deps.deinit(gpa);
+        _ = try codegen.CType.lower(ty, &deps, arena.allocator(), zcu);
+        // This call may add more items to `c.types`.
+        const type_deps = try c.addCTypeDependencies(pt, &deps);
+        c.types.items[@intFromEnum(pool_index)].deps = type_deps;
+    }
 }
 
-pub fn addString(this: *C, s: []const u8) Allocator.Error!String {
-    const comp = this.base.comp;
-    const gpa = comp.gpa;
-    try this.string_bytes.appendSlice(gpa, s);
-    return .{
-        .start = @intCast(this.string_bytes.items.len - s.len),
-        .len = @intCast(s.len),
+/// Only called by `link.ConstPool` due to `c.type_pool`, so `val` is always a type.
+pub fn updateConstIncomplete(
+    c: *C,
+    pt: Zcu.PerThread,
+    index: link.ConstPool.Index,
+    val: InternPool.Index,
+) Allocator.Error!void {
+    const zcu = pt.zcu;
+    const gpa = zcu.comp.gpa;
+
+    assert(zcu.intern_pool.typeOf(val) == .type_type);
+    const ty: Type = .fromInterned(val);
+
+    const rendered: *RenderedType = &c.types.items[@intFromEnum(index)];
+
+    rendered.errunion_definition = .empty;
+    rendered.definition_deps = .empty;
+    rendered.definition = definition: {
+        if (rendered.fwd_decl.len != 0) {
+            // This is a struct or union type. We will never complete it, but we must forward
+            // declare it to ensure that its first usage does not appear in a different scope.
+            break :definition rendered.fwd_decl;
+        }
+        // Otherwise, we might need to `typedef` to `void`.
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.CType.render_defs.defineIncomplete(ty, &aw.writer, pt) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+        };
+        break :definition .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
     };
 }
+/// Only called by `link.ConstPool` due to `c.type_pool`, so `val` is always a type.
+pub fn updateConst(
+    c: *C,
+    pt: Zcu.PerThread,
+    index: link.ConstPool.Index,
+    val: InternPool.Index,
+) Allocator.Error!void {
+    const zcu = pt.zcu;
+    const gpa = zcu.comp.gpa;
+
+    assert(zcu.intern_pool.typeOf(val) == .type_type);
+    const ty: Type = .fromInterned(val);
+
+    const rendered: *RenderedType = &c.types.items[@intFromEnum(index)];
+
+    var arena: std.heap.ArenaAllocator = .init(gpa);
+    defer arena.deinit();
+
+    var deps: codegen.CType.Dependencies = .empty;
+    defer deps.deinit(gpa);
+
+    {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.CType.render_defs.errunionDefineComplete(
+            ty,
+            &deps,
+            arena.allocator(),
+            &aw.writer,
+            pt,
+        ) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
+        };
+        rendered.errunion_definition = .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
+    }
+
+    deps.clearRetainingCapacity();
+
+    {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.CType.render_defs.defineComplete(
+            ty,
+            &deps,
+            arena.allocator(),
+            &aw.writer,
+            pt,
+        ) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
+        };
+        // Remove dependency on a forward declaration of ourselves; we're defining this type so that
+        // forward declaration obviously exists!
+        _ = deps.type_fwd.swapRemove(ty.toIntern());
+        rendered.definition = .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
+    }
+
+    {
+        // This call invalidates `rendered`.
+        const definition_deps = try c.addCTypeDependencies(pt, &deps);
+        c.types.items[@intFromEnum(index)].definition_deps = definition_deps;
+    }
+}
+
+fn addString(c: *C, vec: []const []const u8) Allocator.Error!String {
+    const gpa = c.base.comp.gpa;
+
+    var len: u32 = 0;
+    for (vec) |s| len += @intCast(s.len);
+    try c.string_bytes.ensureUnusedCapacity(gpa, len);
+
+    const start: u32 = @intCast(c.string_bytes.items.len);
+    for (vec) |s| c.string_bytes.appendSliceAssumeCapacity(s);
+    assert(c.string_bytes.items.len == start + len);
+
+    return .{ .start = start, .len = len };
+}
 
 pub fn open(
     arena: Allocator,
@@ -156,267 +436,622 @@ pub fn createEmpty(
             .file = file,
             .build_id = options.build_id,
         },
-        .navs = .empty,
         .string_bytes = .empty,
+        .type_dependencies = .empty,
+        .align_dependency_masks = .empty,
+        .navs = .empty,
         .uavs = .empty,
-        .aligned_uavs = .empty,
+        .type_pool = .empty,
+        .types = .empty,
+        .bigint_types = .empty,
         .exported_navs = .empty,
         .exported_uavs = .empty,
-        .fwd_decl_buf = &.{},
-        .code_header_buf = &.{},
-        .code_buf = &.{},
-        .scratch_buf = &.{},
     };
 
     return c_file;
 }
 
-pub fn deinit(self: *C) void {
-    const gpa = self.base.comp.gpa;
+pub fn deinit(c: *C) void {
+    const gpa = c.base.comp.gpa;
 
-    for (self.navs.values()) |*db| {
-        db.deinit(gpa);
-    }
-    self.navs.deinit(gpa);
+    for (c.navs.values()) |*r| r.deinit(gpa);
+    for (c.uavs.values()) |*r| r.deinit(gpa);
 
-    for (self.uavs.values()) |*db| {
-        db.deinit(gpa);
-    }
-    self.uavs.deinit(gpa);
-    self.aligned_uavs.deinit(gpa);
+    c.string_bytes.deinit(gpa);
+    c.type_dependencies.deinit(gpa);
+    c.align_dependency_masks.deinit(gpa);
+    c.navs.deinit(gpa);
+    c.uavs.deinit(gpa);
+    c.type_pool.deinit(gpa);
+    c.types.deinit(gpa);
+    c.bigint_types.deinit(gpa);
+    c.exported_navs.deinit(gpa);
+    c.exported_uavs.deinit(gpa);
+}
 
-    self.exported_navs.deinit(gpa);
-    self.exported_uavs.deinit(gpa);
-
-    self.string_bytes.deinit(gpa);
-    gpa.free(self.fwd_decl_buf);
-    gpa.free(self.code_header_buf);
-    gpa.free(self.code_buf);
-    gpa.free(self.scratch_buf);
+pub fn updateContainerType(
+    c: *C,
+    pt: Zcu.PerThread,
+    ty: InternPool.Index,
+    success: bool,
+) link.File.UpdateContainerTypeError!void {
+    try c.type_pool.updateContainerType(pt, .{ .c = c }, ty, success);
 }
 
 pub fn updateFunc(
-    self: *C,
+    c: *C,
     pt: Zcu.PerThread,
     func_index: InternPool.Index,
     mir: *AnyMir,
-) link.File.UpdateNavError!void {
+) Allocator.Error!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
-    const func = zcu.funcInfo(func_index);
+    const nav = zcu.funcInfo(func_index).owner_nav;
 
-    const gop = try self.navs.getOrPut(gpa, func.owner_nav);
-    if (gop.found_existing) gop.value_ptr.deinit(gpa);
-    gop.value_ptr.* = .{
-        .code = .empty,
-        .fwd_decl = .empty,
-        .ctype_pool = mir.c.ctype_pool.move(),
-        .lazy_fns = mir.c.lazy_fns.move(),
+    const rendered_decl: *RenderedDecl = rd: {
+        const gop = try c.navs.getOrPut(gpa, nav);
+        if (gop.found_existing) gop.value_ptr.deinit(gpa);
+        break :rd gop.value_ptr;
     };
-    gop.value_ptr.fwd_decl = try self.addString(mir.c.fwd_decl);
-    const code_header = try self.addString(mir.c.code_header);
-    const code = try self.addString(mir.c.code);
-    gop.value_ptr.code = code_header.concat(code);
-    try self.addUavsFromCodegen(&mir.c.uavs);
-}
+    c.navs.lockPointers();
+    defer c.navs.unlockPointers();
 
-fn updateUav(self: *C, pt: Zcu.PerThread, i: usize) link.File.FlushError!void {
-    const gpa = self.base.comp.gpa;
-    const uav = self.uavs.keys()[i];
-
-    var object: codegen.Object = .{
-        .dg = .{
-            .gpa = gpa,
-            .pt = pt,
-            .mod = pt.zcu.root_mod,
-            .error_msg = null,
-            .pass = .{ .uav = uav },
-            .is_naked_fn = false,
-            .expected_block = null,
-            .fwd_decl = undefined,
-            .ctype_pool = .empty,
-            .scratch = .initBuffer(self.scratch_buf),
-            .uavs = .empty,
-        },
-        .code_header = undefined,
-        .code = undefined,
-        .indent_counter = 0,
+    rendered_decl.* = .{
+        .fwd_decl = try c.addString(&.{mir.c.fwd_decl}),
+        .code = try c.addString(&.{ mir.c.code_header, mir.c.code }),
+        .ctype_deps = try c.addCTypeDependencies(pt, &mir.c.ctype_deps),
+        .need_uavs = mir.c.need_uavs.move(),
+        .need_tag_name_funcs = mir.c.need_tag_name_funcs.move(),
+        .need_never_tail_funcs = mir.c.need_never_tail_funcs.move(),
+        .need_never_inline_funcs = mir.c.need_never_inline_funcs.move(),
     };
-    object.dg.fwd_decl = .initOwnedSlice(gpa, self.fwd_decl_buf);
-    object.code = .initOwnedSlice(gpa, self.code_buf);
-    defer {
-        object.dg.uavs.deinit(gpa);
-        object.dg.ctype_pool.deinit(object.dg.gpa);
 
-        self.fwd_decl_buf = object.dg.fwd_decl.toArrayList().allocatedSlice();
-        self.code_buf = object.code.toArrayList().allocatedSlice();
-        self.scratch_buf = object.dg.scratch.allocatedSlice();
+    const old_uavs_len = c.uavs.count();
+    try c.uavs.ensureUnusedCapacity(gpa, rendered_decl.need_uavs.count());
+    for (rendered_decl.need_uavs.keys()) |val| {
+        const gop = c.uavs.getOrPutAssumeCapacity(val);
+        if (gop.found_existing) {
+            assert(gop.index < old_uavs_len);
+        } else {
+            assert(gop.index >= old_uavs_len);
+        }
     }
-    try object.dg.ctype_pool.init(gpa);
+    try c.updateNewUavs(pt, old_uavs_len);
 
-    const c_value: codegen.CValue = .{ .constant = Value.fromInterned(uav) };
-    const alignment: Alignment = self.aligned_uavs.get(uav) orelse .none;
-    codegen.genDeclValue(&object, c_value.constant, c_value, alignment, .none) catch |err| switch (err) {
-        error.AnalysisFail => {
-            @panic("TODO: C backend AnalysisFail on anonymous decl");
-            //try zcu.failed_decls.put(gpa, decl_index, object.dg.error_msg.?);
-            //return;
-        },
-        error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
-    };
-
-    try self.addUavsFromCodegen(&object.dg.uavs);
-
-    object.dg.ctype_pool.freeUnusedCapacity(gpa);
-    self.uavs.values()[i] = .{
-        .fwd_decl = try self.addString(object.dg.fwd_decl.written()),
-        .code = try self.addString(object.code.written()),
-        .ctype_pool = object.dg.ctype_pool.move(),
-    };
+    try c.type_pool.flushPending(pt, .{ .c = c });
 }
 
-pub fn updateNav(self: *C, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) link.File.UpdateNavError!void {
+pub fn updateNav(
+    c: *C,
+    pt: Zcu.PerThread,
+    nav_index: InternPool.Nav.Index,
+) Allocator.Error!void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const gpa = self.base.comp.gpa;
+    const gpa = c.base.comp.gpa;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
     const nav = ip.getNav(nav_index);
-    const nav_init = switch (ip.indexToKey(nav.status.fully_resolved.val)) {
+    switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .func => return,
-        .@"extern" => .none,
-        .variable => |variable| variable.init,
-        else => nav.status.fully_resolved.val,
+        .@"extern" => {},
+        else => {
+            const nav_ty: Type = .fromInterned(nav.typeOf(ip));
+            if (!nav_ty.hasRuntimeBits(zcu)) {
+                if (c.navs.fetchSwapRemove(nav_index)) |kv| {
+                    var old_rendered = kv.value;
+                    old_rendered.deinit(gpa);
+                }
+                return;
+            }
+        },
+    }
+
+    const rendered_decl: *RenderedDecl = rd: {
+        const gop = try c.navs.getOrPut(gpa, nav_index);
+        if (gop.found_existing) {
+            gop.value_ptr.clearRetainingCapacity();
+        } else {
+            gop.value_ptr.* = .init;
+        }
+        break :rd gop.value_ptr;
     };
-    if (nav_init != .none and !Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) return;
+    c.navs.lockPointers();
+    defer c.navs.unlockPointers();
 
-    const gop = try self.navs.getOrPut(gpa, nav_index);
-    errdefer _ = self.navs.pop();
-    if (!gop.found_existing) gop.value_ptr.* = .{};
-    const ctype_pool = &gop.value_ptr.ctype_pool;
-    try ctype_pool.init(gpa);
-    ctype_pool.clearRetainingCapacity();
+    {
+        var arena: std.heap.ArenaAllocator = .init(gpa);
+        defer arena.deinit();
 
-    var object: codegen.Object = .{
-        .dg = .{
+        var dg: codegen.DeclGen = .{
             .gpa = gpa,
+            .arena = arena.allocator(),
             .pt = pt,
             .mod = zcu.navFileScope(nav_index).mod.?,
             .error_msg = null,
-            .pass = .{ .nav = nav_index },
+            .owner_nav = nav_index.toOptional(),
             .is_naked_fn = false,
             .expected_block = null,
-            .fwd_decl = undefined,
-            .ctype_pool = ctype_pool.*,
-            .scratch = .initBuffer(self.scratch_buf),
-            .uavs = .empty,
-        },
-        .code_header = undefined,
-        .code = undefined,
-        .indent_counter = 0,
+            .ctype_deps = .empty,
+            .uavs = rendered_decl.need_uavs.move(),
+        };
+
+        defer {
+            rendered_decl.need_uavs = dg.uavs.move();
+            dg.ctype_deps.deinit(gpa);
+        }
+
+        rendered_decl.fwd_decl = fwd_decl: {
+            var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+            defer c.string_bytes = aw.toArrayList();
+            const start = aw.written().len;
+            codegen.genDeclFwd(&dg, &aw.writer) catch |err| switch (err) {
+                error.AnalysisFail => switch (zcu.codegenFailMsg(nav_index, dg.error_msg.?)) {
+                    error.CodegenFail => return,
+                    error.OutOfMemory => |e| return e,
+                },
+                error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
+            };
+            break :fwd_decl .{
+                .start = @intCast(start),
+                .len = @intCast(aw.written().len - start),
+            };
+        };
+
+        rendered_decl.code = code: {
+            var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+            defer c.string_bytes = aw.toArrayList();
+            const start = aw.written().len;
+            codegen.genDecl(&dg, &aw.writer) catch |err| switch (err) {
+                error.AnalysisFail => switch (zcu.codegenFailMsg(nav_index, dg.error_msg.?)) {
+                    error.CodegenFail => return,
+                    error.OutOfMemory => |e| return e,
+                },
+                error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
+            };
+            break :code .{
+                .start = @intCast(start),
+                .len = @intCast(aw.written().len - start),
+            };
+        };
+
+        rendered_decl.ctype_deps = try c.addCTypeDependencies(pt, &dg.ctype_deps);
+    }
+
+    const old_uavs_len = c.uavs.count();
+    try c.uavs.ensureUnusedCapacity(gpa, rendered_decl.need_uavs.count());
+    for (rendered_decl.need_uavs.keys()) |val| {
+        const gop = c.uavs.getOrPutAssumeCapacity(val);
+        if (gop.found_existing) {
+            assert(gop.index < old_uavs_len);
+        } else {
+            assert(gop.index >= old_uavs_len);
+        }
+    }
+    try c.updateNewUavs(pt, old_uavs_len);
+
+    try c.type_pool.flushPending(pt, .{ .c = c });
+}
+
+/// Unlike `updateNav` and `updateFunc`, this does *not* add newly-discovered UAVs to `c.uavs`. The
+/// caller is instead responsible for doing that (by iterating `rendered_decl.need_uavs`). However,
+/// this function *does* still add newly-discovered *types* to `c.type_pool`.
+///
+/// This function does not accept an alignment for the UAV, because the alignment needed on a UAV is
+/// not known until `flush` (since we need to have seen all uses of the UAV first). Instead, `flush`
+/// will prefix the UAV definition with an appropriate alignment annotation if necessary.
+fn updateUav(
+    c: *C,
+    pt: Zcu.PerThread,
+    val: Value,
+    rendered_decl: *RenderedDecl,
+) Allocator.Error!void {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const gpa = c.base.comp.gpa;
+
+    var arena: std.heap.ArenaAllocator = .init(gpa);
+    defer arena.deinit();
+
+    var dg: codegen.DeclGen = .{
+        .gpa = gpa,
+        .arena = arena.allocator(),
+        .pt = pt,
+        .mod = pt.zcu.root_mod,
+        .error_msg = null,
+        .owner_nav = .none,
+        .is_naked_fn = false,
+        .expected_block = null,
+        .ctype_deps = .empty,
+        .uavs = .empty,
     };
-    object.dg.fwd_decl = .initOwnedSlice(gpa, self.fwd_decl_buf);
-    object.code = .initOwnedSlice(gpa, self.code_buf);
     defer {
-        object.dg.uavs.deinit(gpa);
-        ctype_pool.* = object.dg.ctype_pool.move();
-        ctype_pool.freeUnusedCapacity(gpa);
-
-        self.fwd_decl_buf = object.dg.fwd_decl.toArrayList().allocatedSlice();
-        self.code_buf = object.code.toArrayList().allocatedSlice();
-        self.scratch_buf = object.dg.scratch.allocatedSlice();
+        rendered_decl.need_uavs = dg.uavs.move();
+        dg.ctype_deps.deinit(gpa);
     }
 
-    codegen.genDecl(&object) catch |err| switch (err) {
-        error.AnalysisFail => switch (zcu.codegenFailMsg(nav_index, object.dg.error_msg.?)) {
-            error.CodegenFail => return,
-            error.OutOfMemory => |e| return e,
-        },
-        error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
+    rendered_decl.fwd_decl = fwd_decl: {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.genDeclValueFwd(&dg, &aw.writer, .{
+            .name = .{ .constant = val },
+            .@"const" = true,
+            .@"threadlocal" = false,
+            .init_val = val,
+        }) catch |err| switch (err) {
+            error.AnalysisFail => {
+                @panic("TODO: CBE error.AnalysisFail on uav");
+            },
+            error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
+        };
+        break :fwd_decl .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
     };
-    gop.value_ptr.fwd_decl = try self.addString(object.dg.fwd_decl.written());
-    gop.value_ptr.code = try self.addString(object.code.written());
-    try self.addUavsFromCodegen(&object.dg.uavs);
+
+    rendered_decl.code = code: {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.genDeclValue(&dg, &aw.writer, .{
+            .name = .{ .constant = val },
+            .@"const" = true,
+            .@"threadlocal" = false,
+            .init_val = val,
+        }) catch |err| switch (err) {
+            error.AnalysisFail => {
+                @panic("TODO: CBE error.AnalysisFail on uav");
+            },
+            error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
+        };
+        break :code .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
+    };
+
+    rendered_decl.ctype_deps = try c.addCTypeDependencies(pt, &dg.ctype_deps);
 }
 
-pub fn updateLineNumber(self: *C, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) !void {
-    // The C backend does not have the ability to fix line numbers without re-generating
-    // the entire Decl.
-    _ = self;
+pub fn updateLineNumber(c: *C, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) error{}!void {
+    // The C backend does not currently emit "#line" directives. Even if it did, it would not be
+    // capable of updating those line numbers without re-generating the entire declaration.
+    _ = c;
     _ = pt;
     _ = ti_id;
 }
 
-fn abiDefines(w: *std.Io.Writer, target: *const std.Target) !void {
-    switch (target.abi) {
-        .msvc, .itanium => try w.writeAll("#define ZIG_TARGET_ABI_MSVC\n"),
-        else => {},
-    }
-    try w.print("#define ZIG_TARGET_MAX_INT_ALIGNMENT {d}\n", .{
-        target.cMaxIntAlignment(),
-    });
-}
-
-pub fn flush(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
-    _ = arena; // Has the same lifetime as the call to Compilation.update.
-
+pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const sub_prog_node = prog_node.start("Flush Module", 0);
     defer sub_prog_node.end();
 
-    const comp = self.base.comp;
+    const comp = c.base.comp;
     const diags = &comp.link_diags;
     const gpa = comp.gpa;
     const io = comp.io;
-    const zcu = self.base.comp.zcu.?;
+    const zcu = c.base.comp.zcu.?;
     const ip = &zcu.intern_pool;
+    const target = zcu.getTarget();
     const pt: Zcu.PerThread = .activate(zcu, tid);
     defer pt.deactivate();
 
+    // If it's somehow not made it into the pool, we need to generate the type `[:0]const u8` for
+    // error names.
+    const slice_const_u8_sentinel_0_pool_index = try c.type_pool.get(
+        pt,
+        .{ .c = c },
+        .slice_const_u8_sentinel_0_type,
+    );
+    try c.type_pool.flushPending(pt, .{ .c = c });
+
+    // Find the set of referenced NAVs; these are the ones we'll emit. It is important in this
+    // backend that we only emit referenced NAVs, because other ones may contain code from past
+    // incremental updates which is invalid C (due to e.g. types changing). Machine code backends
+    // don't have this problem because there are, of course, no type checking performed when you
+    // *execute* a binary!
+    var need_navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty;
+    defer need_navs.deinit(gpa);
     {
-        var i: usize = 0;
-        while (i < self.uavs.count()) : (i += 1) {
-            try self.updateUav(pt, i);
+        const unit_references = try zcu.resolveReferences();
+        for (c.navs.keys()) |nav| {
+            const nav_val = ip.getNav(nav).status.fully_resolved.val;
+            const check_unit: ?InternPool.AnalUnit = switch (ip.indexToKey(nav_val)) {
+                else => .wrap(.{ .nav_val = nav }),
+                .func => .wrap(.{ .func = nav_val }),
+                // TODO: this is a hack to deal with the fact that there's currently no good way to
+                // know which `extern`s are alive. This can and will break in certain patterns of
+                // incremental update. We kind of need to think a bit more about how the frontend
+                // actually represents `extern`, it's a bit awkward right now.
+                .@"extern" => null,
+            };
+            if (check_unit) |u| {
+                if (!unit_references.contains(u)) continue;
+            }
+            try need_navs.putNoClobber(gpa, nav, {});
         }
     }
 
-    // This code path happens exclusively with -ofmt=c. The flush logic for
-    // emit-h is in `flushEmitH` below.
+    // Using our knowledge of which NAVs are referenced, we now need to discover the set of UAVs and
+    // C types which are referenced (and hence must be emitted). As above, this is necessary to make
+    // sure we only emit valid C code.
+    //
+    // At the same time, we will discover the set of lazy functions which are referenced.
+
+    var need_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment) = .empty;
+    defer need_uavs.deinit(gpa);
+
+    var need_types: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void) = .empty;
+    defer need_types.deinit(gpa);
+    var need_errunion_types: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void) = .empty;
+    defer need_errunion_types.deinit(gpa);
+    var need_aligned_types: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, u64) = .empty;
+    defer need_aligned_types.deinit(gpa);
+
+    var need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty;
+    defer need_tag_name_funcs.deinit(gpa);
+
+    var need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty;
+    defer need_never_tail_funcs.deinit(gpa);
+
+    var need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty;
+    defer need_never_inline_funcs.deinit(gpa);
+
+    // As mentioned above, we need this type for error names.
+    try need_types.put(gpa, slice_const_u8_sentinel_0_pool_index, {});
+
+    // Every exported NAV should have been discovered via `zcu.resolveReferences`...
+    for (c.exported_navs.keys()) |nav| assert(need_navs.contains(nav));
+    // ...but we *do* need to add exported UAVs to the set.
+    try need_uavs.ensureUnusedCapacity(gpa, c.exported_uavs.count());
+    for (c.exported_uavs.keys()) |uav| {
+        const gop = need_uavs.getOrPutAssumeCapacity(uav);
+        if (!gop.found_existing) gop.value_ptr.* = .none;
+    }
+
+    // For every referenced NAV, some UAVs, C types, and lazy functions may be referenced.
+    for (need_navs.keys()) |nav| {
+        const rendered = c.navs.getPtr(nav).?;
+        try mergeNeededCTypes(
+            c,
+            &need_types,
+            &need_errunion_types,
+            &need_aligned_types,
+            &rendered.ctype_deps,
+        );
+        try mergeNeededUavs(zcu, &need_uavs, &rendered.need_uavs);
+
+        try need_tag_name_funcs.ensureUnusedCapacity(gpa, rendered.need_tag_name_funcs.count());
+        for (rendered.need_tag_name_funcs.keys()) |enum_type| {
+            need_tag_name_funcs.putAssumeCapacity(enum_type, {});
+        }
+
+        try need_never_tail_funcs.ensureUnusedCapacity(gpa, rendered.need_never_tail_funcs.count());
+        for (rendered.need_never_tail_funcs.keys()) |fn_nav| {
+            need_never_tail_funcs.putAssumeCapacity(fn_nav, {});
+        }
 
-    var f: Flush = .{
-        .ctype_pool = .empty,
-        .ctype_global_from_decl_map = .empty,
-        .ctypes = .empty,
+        try need_never_inline_funcs.ensureUnusedCapacity(gpa, rendered.need_never_inline_funcs.count());
+        for (rendered.need_never_inline_funcs.keys()) |fn_nav| {
+            need_never_inline_funcs.putAssumeCapacity(fn_nav, {});
+        }
+    }
+
+    // UAVs may reference other UAVs or C types.
+    {
+        var index: usize = 0;
+        while (need_uavs.count() > index) : (index += 1) {
+            const val = need_uavs.keys()[index];
+            const rendered = c.uavs.getPtr(val).?;
+            try mergeNeededCTypes(
+                c,
+                &need_types,
+                &need_errunion_types,
+                &need_aligned_types,
+                &rendered.ctype_deps,
+            );
+            try mergeNeededUavs(zcu, &need_uavs, &rendered.need_uavs);
+        }
+    }
+
+    // Finally, C types may reference other C types.
+    {
+        var index: usize = 0;
+        var errunion_index: usize = 0;
+        var aligned_index: usize = 0;
+        while (true) {
+            if (index < need_types.count()) {
+                const pool_index = need_types.keys()[index];
+                const rendered = &c.types.items[@intFromEnum(pool_index)];
+                try mergeNeededCTypes(
+                    c,
+                    &need_types,
+                    &need_errunion_types,
+                    &need_aligned_types,
+                    &rendered.definition_deps, // we're tasked with emitting the *definition* of this type
+                );
+                index += 1;
+                continue;
+            }
+
+            if (errunion_index < need_errunion_types.count()) {
+                const payload_pool_index = need_errunion_types.keys()[errunion_index];
+                const rendered = &c.types.items[@intFromEnum(payload_pool_index)];
+                try mergeNeededCTypes(
+                    c,
+                    &need_types,
+                    &need_errunion_types,
+                    &need_aligned_types,
+                    &rendered.deps, // the error union type requires emitting this type's *name*
+                );
+                errunion_index += 1;
+                continue;
+            }
+
+            if (aligned_index < need_aligned_types.count()) {
+                const pool_index = need_aligned_types.keys()[aligned_index];
+                const rendered = &c.types.items[@intFromEnum(pool_index)];
+                try mergeNeededCTypes(
+                    c,
+                    &need_types,
+                    &need_errunion_types,
+                    &need_aligned_types,
+                    &rendered.deps, // an aligned typedef requires emitting this type's *name*
+                );
+                aligned_index += 1;
+                continue;
+            }
+
+            break;
+        }
+    }
+
+    // Now that we know which types are required, generate aligned typedefs. One buffer per aligned
+    // type, with *all* aligned typedefs for that type.
+    const aligned_type_strings = try arena.alloc([]const u8, need_aligned_types.count());
+    {
+        var aw: std.Io.Writer.Allocating = .init(gpa);
+        defer aw.deinit();
+        var unused_deps: codegen.CType.Dependencies = .empty;
+        defer unused_deps.deinit(gpa);
+        for (
+            need_aligned_types.keys(),
+            need_aligned_types.values(),
+            aligned_type_strings,
+        ) |pool_index, align_mask, *str_out| {
+            const ty: Type = .fromInterned(pool_index.val(&c.type_pool));
+            const has_layout = c.types.items[@intFromEnum(pool_index)].errunion_definition.len > 0;
+            for (0..@bitSizeOf(@TypeOf(align_mask))) |bit_index| {
+                switch (@as(u1, @truncate(align_mask >> @intCast(bit_index)))) {
+                    0 => continue,
+                    1 => {},
+                }
+                codegen.CType.render_defs.defineAligned(
+                    ty,
+                    .fromLog2Units(@intCast(bit_index)),
+                    has_layout,
+                    &unused_deps,
+                    arena,
+                    &aw.writer,
+                    pt,
+                ) catch |err| switch (err) {
+                    error.WriteFailed => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
+                };
+            }
+            str_out.* = try arena.dupe(u8, aw.written());
+            aw.clearRetainingCapacity();
+        }
+    }
 
-        .lazy_ctype_pool = .empty,
-        .lazy_fns = .empty,
-        .lazy_fwd_decl = .empty,
-        .lazy_code = .empty,
+    // We have discovered the full set of NAVs, UAVs, and types we need to emit, and will now begin
+    // to build the output buffer. Our strategy is to emit the C source in this order:
+    //
+    // * ABI defines and `#include "zig.h"`
+    // * Big-int type definitions
+    // * Other CType definitions (traversing the dependency graph to sort topologically)
+    // * Global assembly
+    // * UAV exports
+    // * NAV exports
+    // * UAV forward declarations
+    // * NAV forward declarations
+    // * Lazy declarations (error names; @tagName functions; never_tail/never_inline wrappers)
+    // * UAV definitions
+    // * NAV definitions
+    //
+    // Most of these sections are order-independent within themselves, with the exception of the
+    // type definitions, which must be ordered to avoid a struct/union from embedding a type which
+    // is currently incomplete.
+    //
+    // When emitting UAV forward declarations, if the UAV requires alignment, we must prefix it with
+    // an alignment annotation. We couldn't emit the alignment into the UAV's `RenderedDecl` because
+    // we couldn't have known the required alignment until now!
 
-        .all_buffers = .empty,
-        .file_size = 0,
-    };
+    var f: Flush = .{ .all_buffers = .empty, .file_size = 0 };
     defer f.deinit(gpa);
 
-    var abi_defines_aw: std.Io.Writer.Allocating = .init(gpa);
-    defer abi_defines_aw.deinit();
-    abiDefines(&abi_defines_aw.writer, zcu.getTarget()) catch |err| switch (err) {
-        error.WriteFailed => return error.OutOfMemory,
-    };
+    // We know exactly what we'll be emitting, so can reserve capacity for all of our buffers!
 
-    // Covers defines, zig.h, ctypes, asm, lazy fwd.
-    try f.all_buffers.ensureUnusedCapacity(gpa, 5);
+    try f.all_buffers.ensureUnusedCapacity(gpa, 3 + // ABI defines and `#include "zig.h"`
+        1 + // Big-int type definitions
+        need_types.count() + // `RenderedType.fwd_decl` (worst-case)
+        need_types.count() + // `RenderedType.definition`
+        need_errunion_types.count() + // `RenderedType.errunion_fwd_decl` (worst-case)
+        need_errunion_types.count() + // `RenderedType.errunion_definition`
+        need_aligned_types.count() + // `aligned_type_strings`
+        1 + // Global assembly
+        c.exported_uavs.count() + // UAV export block
+        c.exported_navs.count() + // NAV export block
+        need_uavs.count() + // UAV forward declarations
+        need_navs.count() + // NAV forward declarations
+        1 + // Lazy declarations
+        need_uavs.count() * 3 + // UAV definitions ("static ", "zig_align(4)", "<definition body>")
+        need_navs.count() * 2); // NAV definitions ("static ", "<definition body>")
 
-    f.appendBufAssumeCapacity(abi_defines_aw.written());
-    f.appendBufAssumeCapacity(zig_h);
+    // ABI defines and `#include "zig.h"`
+    switch (target.abi) {
+        .msvc, .itanium => f.appendBufAssumeCapacity("#define ZIG_TARGET_ABI_MSVC\n"),
+        else => {},
+    }
+    f.appendBufAssumeCapacity(try std.fmt.allocPrint(
+        arena,
+        "#define ZIG_TARGET_MAX_INT_ALIGNMENT {d}\n",
+        .{target.cMaxIntAlignment()},
+    ));
+    f.appendBufAssumeCapacity(
+        \\#include "zig.h"
+        \\
+    );
 
-    const ctypes_index = f.all_buffers.items.len;
-    f.all_buffers.items.len += 1;
+    // Big-int type definitions
+    var bigint_aw: std.Io.Writer.Allocating = .init(gpa);
+    defer bigint_aw.deinit();
+    for (c.bigint_types.keys()) |bigint| {
+        codegen.CType.render_defs.defineBigInt(bigint, &bigint_aw.writer, zcu) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+        };
+    }
+    f.appendBufAssumeCapacity(bigint_aw.written());
 
+    // CType definitions
+    {
+        var ft: FlushTypes = .{
+            .c = c,
+            .f = &f,
+            .aligned_types = &need_aligned_types,
+            .aligned_type_strings = aligned_type_strings,
+            .status = .empty,
+            .errunion_status = .empty,
+            .aligned_status = .empty,
+        };
+        defer {
+            ft.status.deinit(gpa);
+            ft.errunion_status.deinit(gpa);
+            ft.aligned_status.deinit(gpa);
+        }
+        try ft.status.ensureUnusedCapacity(gpa, need_types.count());
+        try ft.errunion_status.ensureUnusedCapacity(gpa, need_errunion_types.count());
+        try ft.aligned_status.ensureUnusedCapacity(gpa, need_aligned_types.count());
+
+        for (need_types.keys()) |pool_index| {
+            ft.doType(pool_index);
+        }
+        for (need_errunion_types.keys()) |pool_index| {
+            ft.doErrunionType(pool_index);
+        }
+        for (need_aligned_types.keys()) |pool_index| {
+            ft.doAlignedTypeFwd(pool_index);
+        }
+    }
+
+    // Global assembly
     var asm_aw: std.Io.Writer.Allocating = .init(gpa);
     defer asm_aw.deinit();
     codegen.genGlobalAsm(zcu, &asm_aw.writer) catch |err| switch (err) {
@@ -424,435 +1059,228 @@ pub fn flush(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.P
     };
     f.appendBufAssumeCapacity(asm_aw.written());
 
-    const lazy_index = f.all_buffers.items.len;
-    f.all_buffers.items.len += 1;
+    var export_names: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, void) = .empty;
+    defer export_names.deinit(gpa);
+    try export_names.ensureTotalCapacity(gpa, @intCast(zcu.single_exports.count()));
+    for (zcu.single_exports.values()) |export_index| {
+        export_names.putAssumeCapacity(export_index.ptr(zcu).opts.name, {});
+    }
+    for (zcu.multi_exports.values()) |info| {
+        try export_names.ensureUnusedCapacity(gpa, info.len);
+        for (zcu.all_exports.items[info.index..][0..info.len]) |@"export"| {
+            export_names.putAssumeCapacity(@"export".opts.name, {});
+        }
+    }
 
-    try f.lazy_ctype_pool.init(gpa);
-    try self.flushErrDecls(pt, &f);
+    // UAV export block
+    for (c.exported_uavs.values()) |code| {
+        f.appendBufAssumeCapacity(code.get(c));
+    }
 
-    // Unlike other backends, the .c code we are emitting has order-dependent decls.
-    // `CType`s, forward decls, and non-functions first.
+    // NAV export block
+    for (c.exported_navs.values()) |code| {
+        f.appendBufAssumeCapacity(code.get(c));
+    }
 
-    {
-        var export_names: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, void) = .empty;
-        defer export_names.deinit(gpa);
-        try export_names.ensureTotalCapacity(gpa, @intCast(zcu.single_exports.count()));
-        for (zcu.single_exports.values()) |export_index| {
-            export_names.putAssumeCapacity(export_index.ptr(zcu).opts.name, {});
-        }
-        for (zcu.multi_exports.values()) |info| {
-            try export_names.ensureUnusedCapacity(gpa, info.len);
-            for (zcu.all_exports.items[info.index..][0..info.len]) |@"export"| {
-                export_names.putAssumeCapacity(@"export".opts.name, {});
-            }
+    // UAV forward declarations
+    for (need_uavs.keys()) |val| {
+        if (c.exported_uavs.contains(val)) continue; // the export was the declaration
+        const fwd_decl = c.uavs.getPtr(val).?.fwd_decl;
+        f.appendBufAssumeCapacity(fwd_decl.get(c));
+    }
+
+    // NAV forward declarations
+    for (need_navs.keys()) |nav| {
+        if (c.exported_navs.contains(nav)) continue; // the export was the declaration
+        if (ip.getNav(nav).getExtern(ip)) |e| {
+            if (export_names.contains(e.name)) continue;
         }
+        const fwd_decl = c.navs.getPtr(nav).?.fwd_decl;
+        f.appendBufAssumeCapacity(fwd_decl.get(c));
+    }
 
-        for (self.uavs.keys(), self.uavs.values()) |uav, *av_block| try self.flushAvBlock(
-            pt,
-            zcu.root_mod,
-            &f,
-            av_block,
-            self.exported_uavs.getPtr(uav),
-            export_names,
-            .none,
+    // Lazy declarations
+    var lazy_decls_aw: std.Io.Writer.Allocating = .init(gpa);
+    defer lazy_decls_aw.deinit();
+    {
+        var lazy_dg: codegen.DeclGen = .{
+            .gpa = gpa,
+            .arena = arena,
+            .pt = pt,
+            .mod = pt.zcu.root_mod,
+            .owner_nav = .none,
+            .is_naked_fn = false,
+            .expected_block = null,
+            .error_msg = null,
+            .ctype_deps = .empty,
+            .uavs = .empty,
+        };
+        defer {
+            assert(lazy_dg.uavs.count() == 0);
+            lazy_dg.ctype_deps.deinit(gpa);
+        }
+        const slice_const_u8_sentinel_0_cty: codegen.CType = try .lower(
+            .slice_const_u8_sentinel_0,
+            &lazy_dg.ctype_deps,
+            arena,
+            zcu,
         );
-
-        for (self.navs.keys(), self.navs.values()) |nav, *av_block| try self.flushAvBlock(
-            pt,
-            zcu.navFileScope(nav).mod.?,
-            &f,
-            av_block,
-            self.exported_navs.getPtr(nav),
-            export_names,
-            if (ip.getNav(nav).getExtern(ip) != null)
-                ip.getNav(nav).name.toOptional()
-            else
-                .none,
+        const slice_const_u8_sentinel_0_name = try std.fmt.allocPrint(
+            arena,
+            "{f}",
+            .{slice_const_u8_sentinel_0_cty.fmtTypeName(zcu)},
         );
+        codegen.genErrDecls(zcu, &lazy_decls_aw.writer, slice_const_u8_sentinel_0_name) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+        };
+        for (need_tag_name_funcs.keys()) |enum_ty_ip| {
+            const enum_ty: Type = .fromInterned(enum_ty_ip);
+            const enum_cty: codegen.CType = try .lower(
+                enum_ty,
+                &lazy_dg.ctype_deps,
+                arena,
+                zcu,
+            );
+            codegen.genTagNameFn(
+                zcu,
+                &lazy_decls_aw.writer,
+                slice_const_u8_sentinel_0_name,
+                enum_ty,
+                try std.fmt.allocPrint(arena, "{f}", .{enum_cty.fmtTypeName(zcu)}),
+            ) catch |err| switch (err) {
+                error.WriteFailed => return error.OutOfMemory,
+            };
+        }
+        for (need_never_tail_funcs.keys()) |fn_nav| {
+            codegen.genLazyCallModifierFn(&lazy_dg, fn_nav, .never_tail, &lazy_decls_aw.writer) catch |err| switch (err) {
+                error.WriteFailed => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
+                error.AnalysisFail => unreachable,
+            };
+        }
+        for (need_never_inline_funcs.keys()) |fn_nav| {
+            codegen.genLazyCallModifierFn(&lazy_dg, fn_nav, .never_inline, &lazy_decls_aw.writer) catch |err| switch (err) {
+                error.WriteFailed => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
+                error.AnalysisFail => unreachable,
+            };
+        }
     }
+    f.appendBufAssumeCapacity(lazy_decls_aw.written());
 
-    {
-        // We need to flush lazy ctypes after flushing all decls but before flushing any decl ctypes.
-        // This ensures that every lazy CType.Index exactly matches the global CType.Index.
-        try f.ctype_pool.init(gpa);
-        try self.flushCTypes(zcu, &f, .flush, &f.lazy_ctype_pool);
-
-        for (self.uavs.keys(), self.uavs.values()) |uav, av_block| {
-            try self.flushCTypes(zcu, &f, .{ .uav = uav }, &av_block.ctype_pool);
+    // UAV definitions
+    for (need_uavs.keys(), need_uavs.values()) |val, overalign| {
+        const code = c.uavs.getPtr(val).?.code;
+        if (code.len == 0) continue;
+        if (!c.exported_uavs.contains(val)) {
+            f.appendBufAssumeCapacity("static ");
         }
-
-        for (self.navs.keys(), self.navs.values()) |nav, av_block| {
-            try self.flushCTypes(zcu, &f, .{ .nav = nav }, &av_block.ctype_pool);
+        if (overalign != .none) {
+            // As long as `Alignment` isn't too big, it's reasonable to just generate all possible
+            // alignment annotations statically into a LUT, which avoids allocating strings on this
+            // path.
+            comptime assert(@bitSizeOf(Alignment) < 8);
+            const table_len = (1 << @bitSizeOf(Alignment)) - 1;
+            const table: [table_len][]const u8 = comptime table: {
+                @setEvalBranchQuota(16_000);
+                var table: [table_len][]const u8 = undefined;
+                for (&table, 0..) |*str, log2_align| {
+                    const byte_align = Alignment.fromLog2Units(log2_align).toByteUnits().?;
+                    str.* = std.fmt.comptimePrint("zig_align({d}) ", .{byte_align});
+                }
+                break :table table;
+            };
+            f.appendBufAssumeCapacity(table[overalign.toLog2Units()]);
         }
+        f.appendBufAssumeCapacity(code.get(c));
     }
 
-    f.all_buffers.items[ctypes_index] = f.ctypes.items;
-    f.file_size += f.ctypes.items.len;
-
-    f.all_buffers.items[lazy_index] = f.lazy_fwd_decl.items;
-    f.file_size += f.lazy_fwd_decl.items.len;
-
-    // Now the code.
-    try f.all_buffers.ensureUnusedCapacity(gpa, 1 + (self.uavs.count() + self.navs.count()) * 2);
-    f.appendBufAssumeCapacity(f.lazy_code.items);
-    for (self.uavs.keys(), self.uavs.values()) |uav, av_block| f.appendCodeAssumeCapacity(
-        if (self.exported_uavs.contains(uav)) .default else switch (ip.indexToKey(uav)) {
-            .@"extern" => .zig_extern,
-            else => .static,
-        },
-        self.getString(av_block.code),
-    );
-    for (self.navs.keys(), self.navs.values()) |nav, av_block| f.appendCodeAssumeCapacity(storage: {
-        if (self.exported_navs.contains(nav)) break :storage .default;
-        if (ip.getNav(nav).getExtern(ip) != null) break :storage .zig_extern;
-        break :storage .static;
-    }, self.getString(av_block.code));
+    // NAV definitions
+    for (need_navs.keys()) |nav| {
+        const code = c.navs.getPtr(nav).?.code;
+        if (code.len == 0) continue;
+        if (!c.exported_navs.contains(nav)) {
+            const is_extern = ip.getNav(nav).getExtern(ip) != null;
+            f.appendBufAssumeCapacity(if (is_extern) "zig_extern " else "static ");
+        }
+        f.appendBufAssumeCapacity(code.get(c));
+    }
 
-    const file = self.base.file.?;
+    // We've collected all of our buffers; it's now time to actually write the file!
+    const file = c.base.file.?;
     file.setLength(io, f.file_size) catch |err| return diags.fail("failed to allocate file: {t}", .{err});
     var fw = file.writer(io, &.{});
     var w = &fw.interface;
     w.writeVecAll(f.all_buffers.items) catch |err| switch (err) {
         error.WriteFailed => return diags.fail("failed to write to '{f}': {s}", .{
-            std.fmt.alt(self.base.emit, .formatEscapeChar), @errorName(fw.err.?),
+            std.fmt.alt(c.base.emit, .formatEscapeChar), @errorName(fw.err.?),
         }),
     };
 }
 
 const Flush = struct {
-    ctype_pool: codegen.CType.Pool,
-    ctype_global_from_decl_map: std.ArrayList(codegen.CType),
-    ctypes: std.ArrayList(u8),
-
-    lazy_ctype_pool: codegen.CType.Pool,
-    lazy_fns: LazyFns,
-    lazy_fwd_decl: std.ArrayList(u8),
-    lazy_code: std.ArrayList(u8),
-
     /// We collect a list of buffers to write, and write them all at once with pwritev 😎
     all_buffers: std.ArrayList([]const u8),
     /// Keeps track of the total bytes of `all_buffers`.
     file_size: u64,
 
-    const LazyFns = std.AutoHashMapUnmanaged(codegen.LazyFnKey, void);
-
     fn appendBufAssumeCapacity(f: *Flush, buf: []const u8) void {
         if (buf.len == 0) return;
         f.all_buffers.appendAssumeCapacity(buf);
         f.file_size += buf.len;
     }
 
-    fn appendCodeAssumeCapacity(f: *Flush, storage: enum { default, zig_extern, static }, code: []const u8) void {
-        if (code.len == 0) return;
-        f.appendBufAssumeCapacity(switch (storage) {
-            .default => "\n",
-            .zig_extern => "\nzig_extern ",
-            .static => "\nstatic ",
-        });
-        f.appendBufAssumeCapacity(code);
-    }
-
     fn deinit(f: *Flush, gpa: Allocator) void {
-        f.ctype_pool.deinit(gpa);
-        assert(f.ctype_global_from_decl_map.items.len == 0);
-        f.ctype_global_from_decl_map.deinit(gpa);
-        f.ctypes.deinit(gpa);
-        f.lazy_ctype_pool.deinit(gpa);
-        f.lazy_fns.deinit(gpa);
-        f.lazy_fwd_decl.deinit(gpa);
-        f.lazy_code.deinit(gpa);
         f.all_buffers.deinit(gpa);
     }
 };
 
-const FlushDeclError = error{
-    OutOfMemory,
-};
-
-fn flushCTypes(
-    self: *C,
-    zcu: *Zcu,
-    f: *Flush,
-    pass: codegen.DeclGen.Pass,
-    decl_ctype_pool: *const codegen.CType.Pool,
-) FlushDeclError!void {
-    const gpa = self.base.comp.gpa;
-    const global_ctype_pool = &f.ctype_pool;
-
-    const global_from_decl_map = &f.ctype_global_from_decl_map;
-    assert(global_from_decl_map.items.len == 0);
-    try global_from_decl_map.ensureTotalCapacity(gpa, decl_ctype_pool.items.len);
-    defer global_from_decl_map.clearRetainingCapacity();
-
-    var ctypes_aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &f.ctypes);
-    const ctypes_bw = &ctypes_aw.writer;
-    defer f.ctypes = ctypes_aw.toArrayList();
-
-    for (0..decl_ctype_pool.items.len) |decl_ctype_pool_index| {
-        const PoolAdapter = struct {
-            global_from_decl_map: []const codegen.CType,
-            pub fn eql(pool_adapter: @This(), decl_ctype: codegen.CType, global_ctype: codegen.CType) bool {
-                return if (decl_ctype.toPoolIndex()) |decl_pool_index|
-                    decl_pool_index < pool_adapter.global_from_decl_map.len and
-                        pool_adapter.global_from_decl_map[decl_pool_index].eql(global_ctype)
-                else
-                    decl_ctype.index == global_ctype.index;
-            }
-            pub fn copy(pool_adapter: @This(), decl_ctype: codegen.CType) codegen.CType {
-                return if (decl_ctype.toPoolIndex()) |decl_pool_index|
-                    pool_adapter.global_from_decl_map[decl_pool_index]
-                else
-                    decl_ctype;
-            }
-        };
-        const decl_ctype = codegen.CType.fromPoolIndex(decl_ctype_pool_index);
-        const global_ctype, const found_existing = try global_ctype_pool.getOrPutAdapted(
-            gpa,
-            decl_ctype_pool,
-            decl_ctype,
-            PoolAdapter{ .global_from_decl_map = global_from_decl_map.items },
-        );
-        global_from_decl_map.appendAssumeCapacity(global_ctype);
-        codegen.genTypeDecl(
-            zcu,
-            ctypes_bw,
-            global_ctype_pool,
-            global_ctype,
-            pass,
-            decl_ctype_pool,
-            decl_ctype,
-            found_existing,
-        ) catch |err| switch (err) {
-            error.WriteFailed => return error.OutOfMemory,
-        };
-    }
-}
-
-fn flushErrDecls(self: *C, pt: Zcu.PerThread, f: *Flush) FlushDeclError!void {
-    const gpa = self.base.comp.gpa;
-
-    var object: codegen.Object = .{
-        .dg = .{
-            .gpa = gpa,
-            .pt = pt,
-            .mod = pt.zcu.root_mod,
-            .error_msg = null,
-            .pass = .flush,
-            .is_naked_fn = false,
-            .expected_block = null,
-            .fwd_decl = undefined,
-            .ctype_pool = f.lazy_ctype_pool,
-            .scratch = .initBuffer(self.scratch_buf),
-            .uavs = .empty,
-        },
-        .code_header = undefined,
-        .code = undefined,
-        .indent_counter = 0,
-    };
-    object.dg.fwd_decl = .fromArrayList(gpa, &f.lazy_fwd_decl);
-    object.code = .fromArrayList(gpa, &f.lazy_code);
-    defer {
-        object.dg.uavs.deinit(gpa);
-        f.lazy_ctype_pool = object.dg.ctype_pool.move();
-        f.lazy_ctype_pool.freeUnusedCapacity(gpa);
-
-        f.lazy_fwd_decl = object.dg.fwd_decl.toArrayList();
-        f.lazy_code = object.code.toArrayList();
-        self.scratch_buf = object.dg.scratch.allocatedSlice();
-    }
-
-    codegen.genErrDecls(&object) catch |err| switch (err) {
-        error.AnalysisFail => unreachable,
-        error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
-    };
-
-    try self.addUavsFromCodegen(&object.dg.uavs);
-}
-
-fn flushLazyFn(
-    self: *C,
-    pt: Zcu.PerThread,
-    mod: *Module,
-    f: *Flush,
-    lazy_ctype_pool: *const codegen.CType.Pool,
-    lazy_fn: codegen.LazyFnMap.Entry,
-) FlushDeclError!void {
-    const gpa = self.base.comp.gpa;
-
-    var object: codegen.Object = .{
-        .dg = .{
-            .gpa = gpa,
-            .pt = pt,
-            .mod = mod,
-            .error_msg = null,
-            .pass = .flush,
-            .is_naked_fn = false,
-            .expected_block = null,
-            .fwd_decl = undefined,
-            .ctype_pool = f.lazy_ctype_pool,
-            .scratch = .initBuffer(self.scratch_buf),
-            .uavs = .empty,
-        },
-        .code_header = undefined,
-        .code = undefined,
-        .indent_counter = 0,
-    };
-    object.dg.fwd_decl = .fromArrayList(gpa, &f.lazy_fwd_decl);
-    object.code = .fromArrayList(gpa, &f.lazy_code);
-    defer {
-        // If this assert trips just handle the anon_decl_deps the same as
-        // `updateFunc()` does.
-        assert(object.dg.uavs.count() == 0);
-        f.lazy_ctype_pool = object.dg.ctype_pool.move();
-        f.lazy_ctype_pool.freeUnusedCapacity(gpa);
-
-        f.lazy_fwd_decl = object.dg.fwd_decl.toArrayList();
-        f.lazy_code = object.code.toArrayList();
-        self.scratch_buf = object.dg.scratch.allocatedSlice();
-    }
-
-    codegen.genLazyFn(&object, lazy_ctype_pool, lazy_fn) catch |err| switch (err) {
-        error.AnalysisFail => unreachable,
-        error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
-    };
-}
-
-fn flushLazyFns(
-    self: *C,
-    pt: Zcu.PerThread,
-    mod: *Module,
-    f: *Flush,
-    lazy_ctype_pool: *const codegen.CType.Pool,
-    lazy_fns: codegen.LazyFnMap,
-) FlushDeclError!void {
-    const gpa = self.base.comp.gpa;
-    try f.lazy_fns.ensureUnusedCapacity(gpa, @intCast(lazy_fns.count()));
-
-    var it = lazy_fns.iterator();
-    while (it.next()) |entry| {
-        const gop = f.lazy_fns.getOrPutAssumeCapacity(entry.key_ptr.*);
-        if (gop.found_existing) continue;
-        gop.value_ptr.* = {};
-        try self.flushLazyFn(pt, mod, f, lazy_ctype_pool, entry);
-    }
-}
-
-fn flushAvBlock(
-    self: *C,
-    pt: Zcu.PerThread,
-    mod: *Module,
-    f: *Flush,
-    av_block: *const AvBlock,
-    exported_block: ?*const ExportedBlock,
-    export_names: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, void),
-    extern_name: InternPool.OptionalNullTerminatedString,
-) FlushDeclError!void {
-    const gpa = self.base.comp.gpa;
-    try self.flushLazyFns(pt, mod, f, &av_block.ctype_pool, av_block.lazy_fns);
-    try f.all_buffers.ensureUnusedCapacity(gpa, 1);
-    // avoid emitting extern decls that are already exported
-    if (extern_name.unwrap()) |name| if (export_names.contains(name)) return;
-    f.appendBufAssumeCapacity(self.getString(if (exported_block) |exported|
-        exported.fwd_decl
-    else
-        av_block.fwd_decl));
-}
-
-pub fn flushEmitH(zcu: *Zcu) !void {
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    if (true) return; // emit-h is regressed
-
-    const emit_h = zcu.emit_h orelse return;
-    const io = zcu.comp.io;
-
-    // We collect a list of buffers to write, and write them all at once with pwritev 😎
-    const num_buffers = emit_h.decl_table.count() + 1;
-    var all_buffers = try std.array_list.Managed(std.posix.iovec_const).initCapacity(zcu.gpa, num_buffers);
-    defer all_buffers.deinit();
-
-    var file_size: u64 = zig_h.len;
-    if (zig_h.len != 0) {
-        all_buffers.appendAssumeCapacity(.{
-            .base = zig_h,
-            .len = zig_h.len,
-        });
-    }
-
-    for (emit_h.decl_table.keys()) |decl_index| {
-        const decl_emit_h = emit_h.declPtr(decl_index);
-        const buf = decl_emit_h.fwd_decl.items;
-        if (buf.len != 0) {
-            all_buffers.appendAssumeCapacity(.{
-                .base = buf.ptr,
-                .len = buf.len,
-            });
-            file_size += buf.len;
-        }
-    }
-
-    const directory = emit_h.loc.directory orelse zcu.comp.local_cache_directory;
-    const file = try directory.handle.createFile(io, emit_h.loc.basename, .{
-        // We set the end position explicitly below; by not truncating the file, we possibly
-        // make it easier on the file system by doing 1 reallocation instead of two.
-        .truncate = false,
-    });
-    defer file.close(io);
-
-    try file.setLength(io, file_size);
-    try file.pwritevAll(all_buffers.items, 0);
-}
-
 pub fn updateExports(
-    self: *C,
+    c: *C,
     pt: Zcu.PerThread,
     exported: Zcu.Exported,
     export_indices: []const Zcu.Export.Index,
-) !void {
+) Allocator.Error!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
-    const mod, const pass: codegen.DeclGen.Pass, const decl_block, const exported_block = switch (exported) {
-        .nav => |nav| .{
-            zcu.navFileScope(nav).mod.?,
-            .{ .nav = nav },
-            self.navs.getPtr(nav).?,
-            (try self.exported_navs.getOrPut(gpa, nav)).value_ptr,
-        },
-        .uav => |uav| .{
-            zcu.root_mod,
-            .{ .uav = uav },
-            self.uavs.getPtr(uav).?,
-            (try self.exported_uavs.getOrPut(gpa, uav)).value_ptr,
-        },
-    };
-    const ctype_pool = &decl_block.ctype_pool;
+
+    var arena: std.heap.ArenaAllocator = .init(gpa);
+    defer arena.deinit();
+
     var dg: codegen.DeclGen = .{
         .gpa = gpa,
+        .arena = arena.allocator(),
         .pt = pt,
-        .mod = mod,
-        .error_msg = null,
-        .pass = pass,
+        .mod = zcu.root_mod,
+        .owner_nav = .none,
         .is_naked_fn = false,
         .expected_block = null,
-        .fwd_decl = undefined,
-        .ctype_pool = decl_block.ctype_pool,
-        .scratch = .initBuffer(self.scratch_buf),
+        .error_msg = null,
+        .ctype_deps = .empty,
         .uavs = .empty,
     };
-    dg.fwd_decl = .initOwnedSlice(gpa, self.fwd_decl_buf);
     defer {
         assert(dg.uavs.count() == 0);
-        ctype_pool.* = dg.ctype_pool.move();
-        ctype_pool.freeUnusedCapacity(gpa);
+        dg.ctype_deps.deinit(gpa);
+    }
 
-        self.fwd_decl_buf = dg.fwd_decl.toArrayList().allocatedSlice();
-        self.scratch_buf = dg.scratch.allocatedSlice();
-    }
-    codegen.genExports(&dg, exported, export_indices) catch |err| switch (err) {
-        error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
+    const code: String = code: {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, &c.string_bytes);
+        defer c.string_bytes = aw.toArrayList();
+        const start = aw.written().len;
+        codegen.genExports(&dg, &aw.writer, exported, export_indices) catch |err| switch (err) {
+            error.WriteFailed => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
+        };
+        break :code .{
+            .start = @intCast(start),
+            .len = @intCast(aw.written().len - start),
+        };
     };
-    exported_block.* = .{ .fwd_decl = try self.addString(dg.fwd_decl.written()) };
+    switch (exported) {
+        .nav => |nav| try c.exported_navs.put(gpa, nav, code),
+        .uav => |uav| try c.exported_uavs.put(gpa, uav, code),
+    }
 }
 
 pub fn deleteExport(
@@ -866,20 +1294,237 @@ pub fn deleteExport(
     }
 }
 
-fn addUavsFromCodegen(c: *C, uavs: *const std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment)) Allocator.Error!void {
+fn mergeNeededCTypes(
+    c: *C,
+    need_types: *std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void),
+    need_errunion_types: *std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void),
+    need_aligned_types: *std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, u64),
+    deps: *const CTypeDependencies,
+) Allocator.Error!void {
     const gpa = c.base.comp.gpa;
-    try c.uavs.ensureUnusedCapacity(gpa, uavs.count());
-    try c.aligned_uavs.ensureUnusedCapacity(gpa, uavs.count());
-    for (uavs.keys(), uavs.values()) |uav_val, uav_align| {
-        {
-            const gop = c.uavs.getOrPutAssumeCapacity(uav_val);
-            if (!gop.found_existing) gop.value_ptr.* = .{};
+
+    const resolved = deps.get(c);
+
+    try need_types.ensureUnusedCapacity(gpa, resolved.type.len + resolved.type_fwd.len);
+    try need_errunion_types.ensureUnusedCapacity(gpa, resolved.errunion_type.len + resolved.errunion_type_fwd.len);
+    try need_aligned_types.ensureUnusedCapacity(gpa, resolved.aligned_type_fwd.len);
+
+    for (resolved.type) |index| need_types.putAssumeCapacity(index, {});
+    for (resolved.type_fwd) |index| need_types.putAssumeCapacity(index, {});
+
+    for (resolved.errunion_type) |index| need_errunion_types.putAssumeCapacity(index, {});
+    for (resolved.errunion_type_fwd) |index| need_errunion_types.putAssumeCapacity(index, {});
+
+    for (resolved.aligned_type_fwd, resolved.aligned_type_masks) |ty_index, align_mask| {
+        const gop = need_aligned_types.getOrPutAssumeCapacity(ty_index);
+        if (!gop.found_existing) gop.value_ptr.* = 0;
+        gop.value_ptr.* |= align_mask;
+    }
+}
+
+fn mergeNeededUavs(
+    zcu: *const Zcu,
+    global: *std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
+    new: *const std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
+) Allocator.Error!void {
+    const gpa = zcu.comp.gpa;
+
+    try global.ensureUnusedCapacity(gpa, new.count());
+    for (new.keys(), new.values()) |uav_val, need_align| {
+        const gop = global.getOrPutAssumeCapacity(uav_val);
+        if (!gop.found_existing) gop.value_ptr.* = .none;
+
+        if (need_align != .none) {
+            const cur_align = switch (gop.value_ptr.*) {
+                .none => Value.fromInterned(uav_val).typeOf(zcu).abiAlignment(zcu),
+                else => |a| a,
+            };
+            if (need_align.compareStrict(.gt, cur_align)) {
+                gop.value_ptr.* = need_align;
+            }
         }
-        if (uav_align != .none) {
-            const gop = c.aligned_uavs.getOrPutAssumeCapacity(uav_val);
-            gop.value_ptr.* = if (gop.found_existing) max: {
-                break :max gop.value_ptr.*.maxStrict(uav_align);
-            } else uav_align;
+    }
+}
+
+fn addCTypeDependencies(
+    c: *C,
+    pt: Zcu.PerThread,
+    deps: *const codegen.CType.Dependencies,
+) Allocator.Error!CTypeDependencies {
+    const gpa = pt.zcu.comp.gpa;
+
+    try c.bigint_types.ensureUnusedCapacity(gpa, deps.bigint.count());
+    for (deps.bigint.keys()) |bigint| c.bigint_types.putAssumeCapacity(bigint, {});
+
+    const type_start = c.type_dependencies.items.len;
+    const errunion_type_start = type_start + deps.type.count();
+    const type_fwd_start = errunion_type_start + deps.errunion_type.count();
+    const errunion_type_fwd_start = type_fwd_start + deps.type_fwd.count();
+    const aligned_type_fwd_start = errunion_type_fwd_start + deps.errunion_type_fwd.count();
+    try c.type_dependencies.appendNTimes(gpa, undefined, deps.type.count() +
+        deps.errunion_type.count() +
+        deps.type_fwd.count() +
+        deps.errunion_type_fwd.count() +
+        deps.aligned_type_fwd.count());
+
+    const align_mask_start = c.align_dependency_masks.items.len;
+    try c.align_dependency_masks.appendSlice(gpa, deps.aligned_type_fwd.values());
+
+    for (deps.type.keys(), type_start..) |ty, i| {
+        const pool_index = try c.type_pool.get(pt, .{ .c = c }, ty);
+        c.type_dependencies.items[i] = pool_index;
+    }
+
+    for (deps.errunion_type.keys(), errunion_type_start..) |ty, i| {
+        const pool_index = try c.type_pool.get(pt, .{ .c = c }, ty);
+        c.type_dependencies.items[i] = pool_index;
+    }
+
+    for (deps.type_fwd.keys(), type_fwd_start..) |ty, i| {
+        const pool_index = try c.type_pool.get(pt, .{ .c = c }, ty);
+        c.type_dependencies.items[i] = pool_index;
+    }
+
+    for (deps.errunion_type_fwd.keys(), errunion_type_fwd_start..) |ty, i| {
+        const pool_index = try c.type_pool.get(pt, .{ .c = c }, ty);
+        c.type_dependencies.items[i] = pool_index;
+    }
+
+    for (deps.aligned_type_fwd.keys(), aligned_type_fwd_start..) |ty, i| {
+        const pool_index = try c.type_pool.get(pt, .{ .c = c }, ty);
+        c.type_dependencies.items[i] = pool_index;
+    }
+
+    return .{
+        .len = @intCast(deps.type.count()),
+        .errunion_len = @intCast(deps.errunion_type.count()),
+        .fwd_len = @intCast(deps.type_fwd.count()),
+        .errunion_fwd_len = @intCast(deps.errunion_type_fwd.count()),
+        .aligned_fwd_len = @intCast(deps.aligned_type_fwd.count()),
+        .type_start = @intCast(type_start),
+        .align_mask_start = @intCast(align_mask_start),
+    };
+}
+
+fn updateNewUavs(c: *C, pt: Zcu.PerThread, old_uavs_len: usize) Allocator.Error!void {
+    const gpa = pt.zcu.comp.gpa;
+    var index = old_uavs_len;
+    while (index < c.uavs.count()) : (index += 1) {
+        // `new_uavs` is UAVs discovered while lowering *this* UAV.
+        const new_uavs: []const InternPool.Index = new: {
+            c.uavs.lockPointers();
+            defer c.uavs.unlockPointers();
+            const val: Value = .fromInterned(c.uavs.keys()[index]);
+            const rendered_decl = &c.uavs.values()[index];
+            rendered_decl.* = .init;
+            try c.updateUav(pt, val, rendered_decl);
+            break :new rendered_decl.need_uavs.keys();
+        };
+        try c.uavs.ensureUnusedCapacity(gpa, new_uavs.len);
+        for (new_uavs) |val| {
+            const gop = c.uavs.getOrPutAssumeCapacity(val);
+            if (!gop.found_existing) {
+                assert(gop.index > index);
+            }
         }
     }
 }
+
+const FlushTypes = struct {
+    c: *C,
+    f: *Flush,
+
+    aligned_types: *const std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, u64),
+    aligned_type_strings: []const []const u8,
+
+    status: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, bool),
+    errunion_status: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, bool),
+    aligned_status: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void),
+
+    fn processDeps(ft: *FlushTypes, deps: *const CTypeDependencies) void {
+        const resolved = deps.get(ft.c);
+        for (resolved.type) |pool_index| ft.doType(pool_index);
+        for (resolved.type_fwd) |pool_index| ft.doTypeFwd(pool_index);
+        for (resolved.errunion_type) |pool_index| ft.doErrunionType(pool_index);
+        for (resolved.errunion_type_fwd) |pool_index| ft.doErrunionTypeFwd(pool_index);
+        for (resolved.aligned_type_fwd) |pool_index| ft.doAlignedTypeFwd(pool_index);
+    }
+    fn processDepsAsFwd(ft: *FlushTypes, deps: *const CTypeDependencies) void {
+        const resolved = deps.get(ft.c);
+        for (resolved.type) |pool_index| ft.doTypeFwd(pool_index);
+        for (resolved.type_fwd) |pool_index| ft.doTypeFwd(pool_index);
+        for (resolved.errunion_type) |pool_index| ft.doErrunionTypeFwd(pool_index);
+        for (resolved.errunion_type_fwd) |pool_index| ft.doErrunionTypeFwd(pool_index);
+        for (resolved.aligned_type_fwd) |pool_index| ft.doAlignedTypeFwd(pool_index);
+    }
+
+    fn doAlignedTypeFwd(ft: *FlushTypes, pool_index: link.ConstPool.Index) void {
+        const c = ft.c;
+        if (ft.aligned_status.contains(pool_index)) return;
+        if (ft.aligned_types.getIndex(pool_index)) |i| {
+            const rendered = &c.types.items[@intFromEnum(pool_index)];
+            ft.processDepsAsFwd(&rendered.deps);
+            ft.f.appendBufAssumeCapacity(ft.aligned_type_strings[i]);
+        }
+        ft.aligned_status.putAssumeCapacity(pool_index, {});
+    }
+    fn doTypeFwd(ft: *FlushTypes, pool_index: link.ConstPool.Index) void {
+        const c = ft.c;
+        if (ft.status.contains(pool_index)) return;
+        const rendered = &c.types.items[@intFromEnum(pool_index)];
+        if (rendered.fwd_decl.len > 0) {
+            ft.f.appendBufAssumeCapacity(rendered.fwd_decl.get(c));
+            ft.status.putAssumeCapacityNoClobber(pool_index, false);
+        } else {
+            ft.processDepsAsFwd(&rendered.definition_deps);
+            const gop = ft.status.getOrPutAssumeCapacity(pool_index);
+            if (!gop.found_existing) {
+                gop.value_ptr.* = false;
+                ft.f.appendBufAssumeCapacity(rendered.definition.get(c));
+            }
+        }
+    }
+    fn doType(ft: *FlushTypes, pool_index: link.ConstPool.Index) void {
+        const c = ft.c;
+        if (ft.status.get(pool_index)) |completed| {
+            if (completed) return;
+        }
+        const rendered = &c.types.items[@intFromEnum(pool_index)];
+        ft.processDeps(&rendered.definition_deps);
+        if (rendered.fwd_decl.len == 0 and ft.status.contains(pool_index)) {
+            // `doTypeFwd` already rendered the defintion, we just had to complete the type by
+            // fully resolving its dependencies.
+        } else if (rendered.definition.len > 0) {
+            ft.f.appendBufAssumeCapacity(rendered.definition.get(c));
+        } else if (!ft.status.contains(pool_index)) {
+            // The type will never be completed, but it must be forward declared to avoid it being
+            // declared in the wrong scope.
+            ft.f.appendBufAssumeCapacity(rendered.fwd_decl.get(c));
+        }
+        ft.status.putAssumeCapacity(pool_index, true);
+    }
+    fn doErrunionTypeFwd(ft: *FlushTypes, pool_index: link.ConstPool.Index) void {
+        const c = ft.c;
+        const gop = ft.errunion_status.getOrPutAssumeCapacity(pool_index);
+        if (gop.found_existing) return;
+        const rendered = &c.types.items[@intFromEnum(pool_index)];
+        ft.f.appendBufAssumeCapacity(rendered.errunion_fwd_decl.get(c));
+        gop.value_ptr.* = false;
+    }
+    fn doErrunionType(ft: *FlushTypes, pool_index: link.ConstPool.Index) void {
+        const c = ft.c;
+        if (ft.errunion_status.get(pool_index)) |completed| {
+            if (completed) return;
+        }
+        const rendered = &c.types.items[@intFromEnum(pool_index)];
+        ft.processDeps(&rendered.deps);
+        if (rendered.errunion_definition.len > 0) {
+            ft.f.appendBufAssumeCapacity(rendered.errunion_definition.get(c));
+        } else {
+            // The error union type will never be completed, but forward declare it to avoid the
+            // type being first declared in a different scope.
+            ft.f.appendBufAssumeCapacity(rendered.errunion_fwd_decl.get(c));
+        }
+        ft.errunion_status.putAssumeCapacity(pool_index, true);
+    }
+};
diff --git a/src/link/DebugConstPool.zig b/src/link/ConstPool.zig
similarity index 83%
rename from src/link/DebugConstPool.zig
rename to src/link/ConstPool.zig
index eb8c60b6f9d058d12ddcfecc39b92931f6403998..1282ad67c4b5fc49bac914bfeede2da46301ee91 100644
--- a/src/link/DebugConstPool.zig
+++ b/src/link/ConstPool.zig
@@ -9,14 +9,11 @@
 /// Indices into the pool are dense, and constants are never removed from the pool, so the debug
 /// info implementation can store information for each one with a simple `ArrayList`.
 ///
-/// To use `DebugConstPool`, the debug info implementation is required to:
-/// * forward `updateContainerType` calls to its `DebugConstPool`
-/// * expose some callback functions---see functions in `DebugInfo`
+/// To use `ConstPool`, the debug info implementation is required to:
+/// * forward `updateContainerType` calls to its `ConstPool`
+/// * expose some callback functions---see functions in `User`
 /// * ensure that any `get` call is eventually followed by a `flushPending` call
-///
-/// TODO: everything in this file should have the error set 'Allocator.Error', but right now the
-/// self-hosted linkers can return all kinds of crap for some reason. This needs fixing.
-const DebugConstPool = @This();
+const ConstPool = @This();
 
 values: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
 pending: std.ArrayList(Index),
@@ -24,7 +21,7 @@ complete_containers: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
 container_deps: std.AutoArrayHashMapUnmanaged(InternPool.Index, ContainerDepEntry.Index),
 container_dep_entries: std.ArrayList(ContainerDepEntry),
 
-pub const empty: DebugConstPool = .{
+pub const empty: ConstPool = .{
     .values = .empty,
     .pending = .empty,
     .complete_containers = .empty,
@@ -32,7 +29,7 @@ pub const empty: DebugConstPool = .{
     .container_dep_entries = .empty,
 };
 
-pub fn deinit(pool: *DebugConstPool, gpa: Allocator) void {
+pub fn deinit(pool: *ConstPool, gpa: Allocator) void {
     pool.values.deinit(gpa);
     pool.pending.deinit(gpa);
     pool.complete_containers.deinit(gpa);
@@ -42,13 +39,14 @@ pub fn deinit(pool: *DebugConstPool, gpa: Allocator) void {
 
 pub const Index = enum(u32) {
     _,
-    pub fn val(i: Index, pool: *const DebugConstPool) InternPool.Index {
+    pub fn val(i: Index, pool: *const ConstPool) InternPool.Index {
         return pool.values.keys()[@intFromEnum(i)];
     }
 };
 
-pub const DebugInfo = union(enum) {
+pub const User = union(enum) {
     dwarf: *@import("Dwarf.zig"),
+    c: *@import("C.zig"),
     llvm: @import("../codegen/llvm.zig").Object.Ptr,
 
     /// Inform the debug info implementation that the new constant `val` was added to the pool at
@@ -56,12 +54,12 @@ pub const DebugInfo = union(enum) {
     /// that there will eventually be a call to either `updateConst` or `updateConstIncomplete`
     /// following the `addConst` call, to actually populate the constant's debug info.
     fn addConst(
-        di: DebugInfo,
+        user: User,
         pt: Zcu.PerThread,
         index: Index,
         val: InternPool.Index,
-    ) !void {
-        switch (di) {
+    ) Allocator.Error!void {
+        switch (user) {
             inline else => |impl| return impl.addConst(pt, index, val),
         }
     }
@@ -71,12 +69,12 @@ pub const DebugInfo = union(enum) {
     /// * If it is a type, its layout is known.
     /// * Otherwise, the layout of its type is known.
     fn updateConst(
-        di: DebugInfo,
+        user: User,
         pt: Zcu.PerThread,
         index: Index,
         val: InternPool.Index,
-    ) !void {
-        switch (di) {
+    ) Allocator.Error!void {
+        switch (user) {
             inline else => |impl| return impl.updateConst(pt, index, val),
         }
     }
@@ -87,12 +85,12 @@ pub const DebugInfo = union(enum) {
     /// initialized so never had its layout resolved). Instead, the implementation must emit some
     /// form of placeholder entry representing an incomplete/unknown constant.
     fn updateConstIncomplete(
-        di: DebugInfo,
+        user: User,
         pt: Zcu.PerThread,
         index: Index,
         val: InternPool.Index,
-    ) !void {
-        switch (di) {
+    ) Allocator.Error!void {
+        switch (user) {
             inline else => |impl| return impl.updateConstIncomplete(pt, index, val),
         }
     }
@@ -100,7 +98,7 @@ pub const DebugInfo = union(enum) {
 
 const ContainerDepEntry = extern struct {
     next: ContainerDepEntry.Index.Optional,
-    depender: DebugConstPool.Index,
+    depender: ConstPool.Index,
     const Index = enum(u32) {
         _,
         const Optional = enum(u32) {
@@ -116,7 +114,7 @@ const ContainerDepEntry = extern struct {
         fn toOptional(i: ContainerDepEntry.Index) Optional {
             return @enumFromInt(@intFromEnum(i));
         }
-        fn ptr(i: ContainerDepEntry.Index, pool: *DebugConstPool) *ContainerDepEntry {
+        fn ptr(i: ContainerDepEntry.Index, pool: *ConstPool) *ContainerDepEntry {
             return &pool.container_dep_entries.items[@intFromEnum(i)];
         }
     };
@@ -125,12 +123,12 @@ const ContainerDepEntry = extern struct {
 /// Calls to `link.File.updateContainerType` must be forwarded to this function so that the debug
 /// constant pool has up-to-date information about the resolution status of types.
 pub fn updateContainerType(
-    pool: *DebugConstPool,
+    pool: *ConstPool,
     pt: Zcu.PerThread,
-    di: DebugInfo,
+    user: User,
     container_ty: InternPool.Index,
     success: bool,
-) !void {
+) Allocator.Error!void {
     if (success) {
         const gpa = pt.zcu.comp.gpa;
         try pool.complete_containers.put(gpa, container_ty, {});
@@ -139,18 +137,18 @@ pub fn updateContainerType(
     }
     var opt_dep = pool.container_deps.get(container_ty);
     while (opt_dep) |dep| : (opt_dep = dep.ptr(pool).next.unwrap()) {
-        try pool.update(pt, di, dep.ptr(pool).depender);
+        try pool.update(pt, user, dep.ptr(pool).depender);
     }
 }
 
 /// After this is called, there may be a constant for which debug information (complete or not) has
 /// not yet been emitted, so the user must call `flushPending` at some point after this call.
-pub fn get(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo, val: InternPool.Index) !DebugConstPool.Index {
+pub fn get(pool: *ConstPool, pt: Zcu.PerThread, user: User, val: InternPool.Index) Allocator.Error!ConstPool.Index {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const gpa = zcu.comp.gpa;
     const gop = try pool.values.getOrPut(gpa, val);
-    const index: DebugConstPool.Index = @enumFromInt(gop.index);
+    const index: ConstPool.Index = @enumFromInt(gop.index);
     if (!gop.found_existing) {
         const ty: Type = switch (ip.typeOf(val)) {
             .type_type => if (ip.isUndef(val)) .type else .fromInterned(val),
@@ -158,17 +156,17 @@ pub fn get(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo, val: InternP
         };
         try pool.registerTypeDeps(index, ty, zcu);
         try pool.pending.append(gpa, index);
-        try di.addConst(pt, index, val);
+        try user.addConst(pt, index, val);
     }
     return index;
 }
-pub fn flushPending(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo) !void {
+pub fn flushPending(pool: *ConstPool, pt: Zcu.PerThread, user: User) Allocator.Error!void {
     while (pool.pending.pop()) |pending_ty| {
-        try pool.update(pt, di, pending_ty);
+        try pool.update(pt, user, pending_ty);
     }
 }
 
-fn update(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo, index: DebugConstPool.Index) !void {
+fn update(pool: *ConstPool, pt: Zcu.PerThread, user: User, index: ConstPool.Index) Allocator.Error!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const val = index.val(pool);
@@ -177,12 +175,12 @@ fn update(pool: *DebugConstPool, pt: Zcu.PerThread, di: DebugInfo, index: DebugC
         else => |ty| .fromInterned(ty),
     };
     if (pool.checkType(ty, zcu)) {
-        try di.updateConst(pt, index, val);
+        try user.updateConst(pt, index, val);
     } else {
-        try di.updateConstIncomplete(pt, index, val);
+        try user.updateConstIncomplete(pt, index, val);
     }
 }
-fn checkType(pool: *const DebugConstPool, ty: Type, zcu: *const Zcu) bool {
+fn checkType(pool: *const ConstPool, ty: Type, zcu: *const Zcu) bool {
     if (ty.isGenericPoison()) return true;
     return switch (ty.zigTypeTag(zcu)) {
         .type,
@@ -227,7 +225,7 @@ fn checkType(pool: *const DebugConstPool, ty: Type, zcu: *const Zcu) bool {
         },
     };
 }
-fn registerTypeDeps(pool: *DebugConstPool, root: Index, ty: Type, zcu: *const Zcu) Allocator.Error!void {
+fn registerTypeDeps(pool: *ConstPool, root: Index, ty: Type, zcu: *const Zcu) Allocator.Error!void {
     if (ty.isGenericPoison()) return;
     switch (ty.zigTypeTag(zcu)) {
         .type,
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index e64346c17c52d305519b575101d70343cf2ef250..38021aa42f0a4b4211889afeb514e6ed3cda6933 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -18,7 +18,6 @@ const codegen = @import("../codegen.zig");
 const dev = @import("../dev.zig");
 const link = @import("../link.zig");
 const target_info = @import("../target.zig");
-const DebugConstPool = link.DebugConstPool;
 
 gpa: Allocator,
 bin_file: *link.File,
@@ -26,10 +25,10 @@ format: DW.Format,
 endian: std.builtin.Endian,
 address_size: AddressSize,
 
-const_pool: DebugConstPool,
+const_pool: link.ConstPool,
 
 mods: std.AutoArrayHashMapUnmanaged(*Module, ModInfo),
-/// Indices are `DebugConstPool.Index`.
+/// Indices are `link.ConstPool.Index`.
 values: std.ArrayList(struct { Unit.Index, Entry.Index }),
 navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, Entry.Index),
 decls: std.AutoArrayHashMapUnmanaged(InternPool.TrackedInst.Index, Entry.Index),
@@ -1038,7 +1037,7 @@ const Entry = struct {
             const zcu = dwarf.bin_file.comp.zcu.?;
             const ip = &zcu.intern_pool;
             for (0.., dwarf.values.items) |raw_index, unit_and_entry| {
-                const index: DebugConstPool.Index = @enumFromInt(raw_index);
+                const index: link.ConstPool.Index = @enumFromInt(raw_index);
                 const val = index.val(&dwarf.const_pool);
                 const val_unit, const val_entry = unit_and_entry;
                 if (sec.getUnit(val_unit) == unit and unit.getEntry(val_entry) == entry)
@@ -3291,8 +3290,14 @@ pub fn updateContainerType(
 ) !void {
     try dwarf.const_pool.updateContainerType(pt, .{ .dwarf = dwarf }, ty, success);
 }
-/// Should only be called by the `DebugConstPool` implementation.
-pub fn addConst(dwarf: *Dwarf, pt: Zcu.PerThread, index: DebugConstPool.Index, val: InternPool.Index) !void {
+/// Should only be called by the `link.ConstPool` implementation.
+pub fn addConst(dwarf: *Dwarf, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
+    addConstInner(dwarf, pt, index, val) catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        else => |e| std.debug.panic("DWARF TODO: '{t}' while registering constant\n", .{e}),
+    };
+}
+fn addConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) !void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
@@ -3321,11 +3326,17 @@ pub fn addConst(dwarf: *Dwarf, pt: Zcu.PerThread, index: DebugConstPool.Index, v
     assert(@intFromEnum(index) == dwarf.values.items.len);
     try dwarf.values.append(dwarf.gpa, .{ unit, entry });
 }
-/// Should only be called by the `DebugConstPool` implementation.
+/// Should only be called by the `link.ConstPool` implementation.
 ///
 /// Emits a "dummy" DIE for the given comptime-only value (which may be a type). For types, this is
 /// an opaque type. Otherwise, it is an undefined value of the value's type.
-pub fn updateConstIncomplete(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: DebugConstPool.Index, value_index: InternPool.Index) !void {
+pub fn updateConstIncomplete(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.ConstPool.Index, value_index: InternPool.Index) Allocator.Error!void {
+    updateConstIncompleteInner(dwarf, pt, debug_const_index, value_index) catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        else => |e| std.debug.panic("DWARF TODO: '{t}' while updating incomplete constant\n", .{e}),
+    };
+}
+fn updateConstIncompleteInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.ConstPool.Index, value_index: InternPool.Index) !void {
     const zcu = pt.zcu;
 
     const val: Value = .fromInterned(value_index);
@@ -3380,10 +3391,16 @@ pub fn updateConstIncomplete(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index
     try dwarf.debug_info.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_info.written());
     try dwarf.debug_loclists.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_loclists.written());
 }
-/// Should only be called by the `DebugConstPool` implementation.
+/// Should only be called by the `link.ConstPool` implementation.
 ///
 /// Emits a DIE for the given comptime-only value (which may be a type).
-pub fn updateConst(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: DebugConstPool.Index, value_index: InternPool.Index) !void {
+pub fn updateConst(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.ConstPool.Index, value_index: InternPool.Index) Allocator.Error!void {
+    updateConstInner(dwarf, pt, debug_const_index, value_index) catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        else => |e| std.debug.panic("DWARF TODO: '{t}' while updating constant\n", .{e}),
+    };
+}
+fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.ConstPool.Index, value_index: InternPool.Index) !void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index dd4c2abd248eafea4b6705a79a5c15eaf3b409d2..c45f73d97a35c8e6435bfded3f5f2defddd55ac4 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1716,19 +1716,8 @@ pub fn updateContainerType(
     if (build_options.skip_non_native and builtin.object_format != .elf) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    const zcu = pt.zcu;
-    const gpa = zcu.gpa;
     return self.zigObjectPtr().?.updateContainerType(pt, ty, success) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-        else => |e| {
-            try zcu.failed_types.putNoClobber(gpa, ty, try Zcu.ErrorMsg.create(
-                gpa,
-                zcu.typeSrcLoc(ty),
-                "failed to update container type: {s}",
-                .{@errorName(e)},
-            ));
-            return error.TypeFailureReported;
-        },
     };
 }
 
-- 
2.54.0


From 7bfe96fddcdc27db58a9a758b9e9aed2ed3370cc Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 22 Feb 2026 19:43:10 +0000
Subject: [PATCH 462/499] frontend: fix bugs

did you know that if semantic analysis fails you should return
error.AnalysisFail?
---
 src/Sema.zig          | 17 +++++++++++------
 src/Zcu/PerThread.zig | 12 +++++++-----
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 79a97a3e379615f3787072565454acdc501d1fba..38fada09b0357a8a5c1012d5fc2d3c3d7d959a60 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -23393,8 +23393,13 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     const field_name_src = block.builtinCallArgSrc(extra.src_node, 0);
     const field_ptr_src = block.builtinCallArgSrc(extra.src_node, 1);
 
-    const parent_ptr_ty = try sema.resolveDestType(block, inst_src, extra.parent_ptr_type, .remove_eu, "@fieldParentPtr");
-    try sema.checkPtrType(block, inst_src, parent_ptr_ty, true);
+    const maybe_opt_parent_ptr_ty = try sema.resolveDestType(block, inst_src, extra.parent_ptr_type, .remove_eu, "@fieldParentPtr");
+    try sema.checkPtrType(block, inst_src, maybe_opt_parent_ptr_ty, true);
+    const parent_ptr_ty = switch (maybe_opt_parent_ptr_ty.zigTypeTag(zcu)) {
+        .optional => maybe_opt_parent_ptr_ty.optionalChild(zcu),
+        .pointer => maybe_opt_parent_ptr_ty,
+        else => unreachable,
+    };
     const parent_ptr_info = parent_ptr_ty.ptrInfo(zcu);
     if (parent_ptr_info.flags.size != .one) {
         return sema.fail(block, inst_src, "expected single pointer type, found '{f}'", .{parent_ptr_ty.fmt(pt)});
@@ -23441,7 +23446,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     );
 
     const unaligned_parent_ptr_ty = try pt.ptrType(info: {
-        var info = parent_ptr_ty.ptrInfo(zcu);
+        var info = parent_ptr_info;
         info.flags.alignment = hypothetical_field_ptr_ty.ptrAlignment(zcu);
         break :info info;
     });
@@ -23512,7 +23517,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     // a field pointer of type `*align(1) u16`.
     switch (hypothetical_field_ptr_ty.ptrAlignment(zcu).order(parent_ptr_ty.ptrAlignment(zcu))) {
         .gt => unreachable, // getting a field pointer can never increase alignment
-        .eq => return unaligned_parent_ptr,
+        .eq => return sema.coerce(block, maybe_opt_parent_ptr_ty, unaligned_parent_ptr, inst_src),
         .lt => if (flags.align_cast) {
             // Go through `ptrCastFull` for the safety check.
             return sema.ptrCastFull(
@@ -23521,7 +23526,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
                 inst_src,
                 unaligned_parent_ptr,
                 inst_src,
-                parent_ptr_ty,
+                maybe_opt_parent_ptr_ty,
                 "@fieldParentPtr",
             );
         } else return sema.failWithOwnedErrorMsg(block, msg: {
@@ -25184,7 +25189,7 @@ pub fn explainWhyTypeIsNotExtern(
             }
         },
         .@"union" => {
-            const union_obj = zcu.intern_pool.loadStructType(ty.toIntern());
+            const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
             switch (union_obj.layout) {
                 .auto => try sema.errNote(src_loc, msg, "union with automatic layout has no guaranteed in-memory representation", .{}),
                 .@"extern" => unreachable,
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index ef22213c9a9b143c2a3ce47ca46b99e362c51765..06377692c95e30cdd59fe374b49e09a3cd23995e 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -1393,17 +1393,17 @@ pub fn ensureTypeLayoutUpToDate(
         .@"union" => Sema.type_resolution.resolveUnionLayout(&sema, ty),
         else => unreachable,
     };
-    const new_success: bool = if (result) s: {
-        break :s true;
+    const new_failed: bool = if (result) failed: {
+        break :failed false;
     } else |err| switch (err) {
-        error.AnalysisFail => success: {
+        error.AnalysisFail => failed: {
             if (!zcu.failed_analysis.contains(anal_unit)) {
                 // If this unit caused the error, it would have an entry in `failed_analysis`.
                 // Since it does not, this must be a transitive failure.
                 try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
                 log.debug("mark transitive analysis failure for {f}", .{zcu.fmtAnalUnit(anal_unit)});
             }
-            break :success false;
+            break :failed true;
         },
         error.OutOfMemory,
         error.Canceled,
@@ -1422,8 +1422,10 @@ pub fn ensureTypeLayoutUpToDate(
     comp.link_prog_node.increaseEstimatedTotalItems(1);
     try comp.link_queue.enqueueZcu(comp, pt.tid, .{ .debug_update_container_type = .{
         .ty = ty.toIntern(),
-        .success = new_success,
+        .success = !new_failed,
     } });
+
+    if (new_failed) return error.AnalysisFail;
 }
 
 /// Ensures that the resolved value of the given `Nav` is fully up-to-date, performing re-analysis
-- 
2.54.0


From 160da8d6a4b82fa54f33e15025aaccc6f36f896f Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 23 Feb 2026 11:53:29 +0000
Subject: [PATCH 463/499] Dwarf: be even dumber about source locations

---
 src/link/Dwarf.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 38021aa42f0a4b4211889afeb514e6ed3cda6933..806a85ff23cb3a0b8ead4e6716b24de3b70995f5 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -3461,7 +3461,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co
     // without trying to tie them to a bogus source location.
     const src_loc: Zcu.LazySrcLoc = .{
         .base_node_inst = inst: {
-            const mod_root_file_index = zcu.module_roots.get(dwarf.getUnitModule(unit)).?.unwrap().?;
+            const mod_root_file_index = zcu.module_roots.get(zcu.std_mod).?.unwrap().?;
             const mod_root_type_index = zcu.fileRootType(mod_root_file_index);
             break :inst ip.loadStructType(mod_root_type_index).zir_index;
         },
-- 
2.54.0


From 2651b5ccdf2485172e9ba0345b9529733ee39273 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 23 Feb 2026 13:24:05 +0000
Subject: [PATCH 464/499] llvm: fix some bugs

---
 src/Sema.zig          | 10 ++++++++++
 src/Zcu/PerThread.zig | 10 ++++++++++
 src/codegen/llvm.zig  | 44 +++++++++++++++++++++++++++----------------
 3 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 38fada09b0357a8a5c1012d5fc2d3c3d7d959a60..fc5b147759df31eead062d8980961059ab7e5a2c 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -24756,6 +24756,16 @@ fn zirBuiltinExtern(
     }
     const ptr_info = ty.ptrInfo(zcu);
 
+    if (Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .@"fn") {
+        const func_type = ip.indexToKey(ptr_info.child).func_type;
+        for (func_type.param_types.get(ip)) |param_ty_ip| {
+            const param_ty: Type = .fromInterned(param_ty_ip);
+            if (param_ty.isPtrAtRuntime(zcu) or param_ty.isSliceAtRuntime(zcu)) {
+                // LLVM wants this information for an "align" attribute on the parameter.
+                try sema.ensureLayoutResolved(param_ty.nullablePtrElem(zcu), ty_src, .parameter);
+            }
+        }
+    }
     const extern_val = try pt.getExtern(.{
         .name = options.name,
         .ty = ptr_info.child,
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 06377692c95e30cdd59fe374b49e09a3cd23995e..ee788c884e327fffe1fe5a1e6f09854ba6932803 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -1691,6 +1691,16 @@ fn analyzeNavVal(
                 const lib_name_src = block.src(.{ .node_offset_lib_name = .zero });
                 try sema.handleExternLibName(&block, lib_name_src, l);
             }
+            if (nav_ty.zigTypeTag(zcu) == .@"fn") {
+                const func_type = ip.indexToKey(nav_ty.toIntern()).func_type;
+                for (func_type.param_types.get(ip)) |param_ty_ip| {
+                    const param_ty: Type = .fromInterned(param_ty_ip);
+                    if (param_ty.isPtrAtRuntime(zcu) or param_ty.isSliceAtRuntime(zcu)) {
+                        // LLVM wants this information for an "align" attribute on the parameter.
+                        try sema.ensureLayoutResolved(param_ty.nullablePtrElem(zcu), ty_src, .parameter);
+                    }
+                }
+            }
             break :val .fromInterned(try pt.getExtern(.{
                 .name = old_nav.name,
                 .ty = nav_ty.toIntern(),
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index f8d1310b1c7693c8b2f46fb03debc802d7eba69b..972a536eef0989e5c8f3055a4635f1e0397d32ba 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -2327,16 +2327,21 @@ pub const Object = struct {
                 const layout = Type.getUnionLayout(union_type, zcu);
 
                 if (layout.payload_size == 0) {
-                    const tag_member = try o.builder.debugMemberType(
-                        try o.builder.metadataString("tag"),
-                        null, // file
-                        ty_fwd_ref,
-                        0, // line
-                        try o.getDebugType(pt, enum_tag_ty),
-                        layout.tag_size * 8,
-                        layout.tag_align.toByteUnits().? * 8,
-                        0, // offset
-                    );
+                    const fields_tuple: ?Builder.Metadata = fields: {
+                        if (layout.tag_size == 0) break :fields null;
+                        break :fields try o.builder.metadataTuple(&.{
+                            try o.builder.debugMemberType(
+                                try o.builder.metadataString("tag"),
+                                null, // file
+                                ty_fwd_ref,
+                                0, // line
+                                try o.getDebugType(pt, enum_tag_ty),
+                                layout.tag_size * 8,
+                                layout.tag_align.toByteUnits().? * 8,
+                                0, // offset
+                            ),
+                        });
+                    };
                     return o.builder.debugStructType(
                         name,
                         file,
@@ -2345,7 +2350,7 @@ pub const Object = struct {
                         null, // underlying type
                         ty.abiSize(zcu) * 8,
                         ty.abiAlignment(zcu).toByteUnits().? * 8,
-                        try o.builder.metadataTuple(&.{tag_member}),
+                        fields_tuple,
                     );
                 }
 
@@ -3141,12 +3146,16 @@ pub const Object = struct {
                     var struct_kind: Builder.Type.Structure.Kind = .normal;
                     // When we encounter a zero-bit field, we place it here so we know to map it to the next non-zero-bit field (if any).
                     var it = struct_type.iterateRuntimeOrder(ip);
+                    var max_field_ty_align: InternPool.Alignment = .@"1";
                     while (it.next()) |field_index| {
                         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
+                        const field_ty_align = field_ty.abiAlignment(zcu);
+                        max_field_ty_align = max_field_ty_align.maxStrict(field_ty_align);
+
                         const prev_offset = offset;
                         offset = struct_type.field_offsets.get(ip)[field_index];
-                        if (@ctz(offset) < field_ty.abiAlignment(zcu).toLog2Units()) {
-                            struct_kind = .@"packed";
+                        if (@ctz(offset) < field_ty_align.toLog2Units()) {
+                            struct_kind = .@"packed"; // prevent unexpected padding before this field
                         }
 
                         const padding_len = offset - prev_offset;
@@ -3184,6 +3193,9 @@ pub const Object = struct {
                             o.gpa,
                             try o.builder.arrayType(padding_len, .i8),
                         );
+                        if (@ctz(offset) < max_field_ty_align.toLog2Units()) {
+                            struct_kind = .@"packed"; // prevent unexpected trailing padding
+                        }
                     }
 
                     const ty = try o.builder.opaqueType(try o.builder.string(t.containerTypeName(ip).toSlice(ip)));
@@ -3883,7 +3895,7 @@ pub const Object = struct {
                     const payload = try o.lowerValue(pt, un.val);
                     const payload_ty = payload.typeOf(&o.builder);
                     if (payload_ty != union_ty.structFields(&o.builder)[
-                        @intFromBool(layout.tag_align.compare(.gte, layout.payload_align))
+                        @intFromBool(layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align))
                     ]) need_unnamed = true;
                     const field_size = field_ty.abiSize(zcu);
                     if (field_size == layout.payload_size) break :p payload;
@@ -6806,7 +6818,7 @@ pub const FuncGen = struct {
             .@"union" => {
                 const union_llvm_ty = try o.lowerType(pt, struct_ty);
                 const layout = struct_ty.unionGetLayout(zcu);
-                const payload_index = @intFromBool(layout.tag_align.compare(.gte, layout.payload_align));
+                const payload_index = @intFromBool(layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align));
                 const field_ptr =
                     try self.wip.gepStruct(union_llvm_ty, struct_llvm_val, payload_index, "");
                 const payload_alignment = layout.payload_align.toLlvm();
@@ -11063,7 +11075,7 @@ pub const FuncGen = struct {
             .@"union" => {
                 const layout = struct_ty.unionGetLayout(zcu);
                 if (layout.payload_size == 0 or struct_ty.containerLayout(zcu) == .@"packed") return struct_ptr;
-                const payload_index = @intFromBool(layout.tag_align.compare(.gte, layout.payload_align));
+                const payload_index = @intFromBool(layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align));
                 const union_llvm_ty = try o.lowerType(pt, struct_ty);
                 return self.wip.gepStruct(union_llvm_ty, struct_ptr, payload_index, "");
             },
-- 
2.54.0


From 82be338964ed5bbc596a48075e52724fdf92cde4 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 23 Feb 2026 13:24:54 +0000
Subject: [PATCH 465/499] aro: stop depending on ArrayList default field values

---
 lib/compiler/aro/aro/InitList.zig  | 20 +++++++++++++-------
 lib/compiler/aro/aro/Parser.zig    |  6 +++---
 lib/compiler/aro/aro/Toolchain.zig |  6 +++---
 3 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/lib/compiler/aro/aro/InitList.zig b/lib/compiler/aro/aro/InitList.zig
index 9d8af869d75851b43b752427423f872b0493932e..ed7af8f998b9e37acd6d83e6c73ec6370b071783 100644
--- a/lib/compiler/aro/aro/InitList.zig
+++ b/lib/compiler/aro/aro/InitList.zig
@@ -22,9 +22,15 @@ const Item = struct {
 
 const InitList = @This();
 
-list: std.ArrayList(Item) = .empty,
-node: Node.OptIndex = .null,
-tok: TokenIndex = 0,
+list: std.ArrayList(Item),
+node: Node.OptIndex,
+tok: TokenIndex,
+
+pub const empty: InitList = .{
+    .list = .empty,
+    .node = .null,
+    .tok = 0,
+};
 
 /// Deinitialize freeing all memory.
 pub fn deinit(il: *InitList, gpa: Allocator) void {
@@ -43,7 +49,7 @@ pub fn find(il: *InitList, gpa: Allocator, index: u64) !*InitList {
     if (il.list.items.len == 0) {
         const item = try il.list.addOne(gpa);
         item.* = .{
-            .list = .{},
+            .list = .empty,
             .index = index,
         };
         return &item.list;
@@ -51,7 +57,7 @@ pub fn find(il: *InitList, gpa: Allocator, index: u64) !*InitList {
         // Append a new value to the end of the list.
         const new = try il.list.addOne(gpa);
         new.* = .{
-            .list = .{},
+            .list = .empty,
             .index = index,
         };
         return &new.list;
@@ -70,7 +76,7 @@ pub fn find(il: *InitList, gpa: Allocator, index: u64) !*InitList {
 
     // Insert a new value into a sorted position.
     try il.list.insert(gpa, left, .{
-        .list = .{},
+        .list = .empty,
         .index = index,
     });
     return &il.list.items[left].list;
@@ -78,7 +84,7 @@ pub fn find(il: *InitList, gpa: Allocator, index: u64) !*InitList {
 
 test "basic usage" {
     const gpa = testing.allocator;
-    var il: InitList = .{};
+    var il: InitList = .empty;
     defer il.deinit(gpa);
 
     {
diff --git a/lib/compiler/aro/aro/Parser.zig b/lib/compiler/aro/aro/Parser.zig
index fc21ee4d0b5f25f8f28b08c157d80a59b83adda8..6e60dbd623e6c729375c4e522cd4fbd43cb43b4c 100644
--- a/lib/compiler/aro/aro/Parser.zig
+++ b/lib/compiler/aro/aro/Parser.zig
@@ -3977,7 +3977,7 @@ fn initializer(p: *Parser, init_qt: QualType) Error!Result {
         final_init_qt = .invalid;
     }
 
-    var il: InitList = .{};
+    var il: InitList = .empty;
     defer il.deinit(p.comp.gpa);
 
     try p.initializerItem(&il, final_init_qt, l_brace);
@@ -4028,12 +4028,12 @@ fn initializerItem(p: *Parser, il: *InitList, init_qt: QualType, l_brace: TokenI
                     try p.err(first_tok, .initializer_overrides, .{});
                     try p.err(item.il.tok, .previous_initializer, .{});
                     item.il.deinit(gpa);
-                    item.il.* = .{};
+                    item.il.* = .empty;
                 }
                 try p.initializerItem(item.il, item.qt, inner_l_brace);
             } else {
                 // discard further values
-                var tmp_il: InitList = .{};
+                var tmp_il: InitList = .empty;
                 defer tmp_il.deinit(gpa);
                 try p.initializerItem(&tmp_il, .invalid, inner_l_brace);
                 if (!warned_excess) try p.err(first_tok, switch (init_qt.base(p.comp).type) {
diff --git a/lib/compiler/aro/aro/Toolchain.zig b/lib/compiler/aro/aro/Toolchain.zig
index 0aa9d76fc88a176f9ac5690fbf40dd0563b48aab..9a923c08461ddb36dc055f81de813ddaac90e99c 100644
--- a/lib/compiler/aro/aro/Toolchain.zig
+++ b/lib/compiler/aro/aro/Toolchain.zig
@@ -43,13 +43,13 @@ const Toolchain = @This();
 driver: *Driver,
 
 /// The list of toolchain specific path prefixes to search for libraries.
-library_paths: PathList = .{},
+library_paths: PathList = .empty,
 
 /// The list of toolchain specific path prefixes to search for files.
-file_paths: PathList = .{},
+file_paths: PathList = .empty,
 
 /// The list of toolchain specific path prefixes to search for programs.
-program_paths: PathList = .{},
+program_paths: PathList = .empty,
 
 selected_multilib: Multilib = .{},
 
-- 
2.54.0


From 0075c5a1d5ad1198b16e6a1c390c985a8e4354de Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 27 Feb 2026 10:27:29 +0000
Subject: [PATCH 466/499] Type: tiny refactors

---
 src/Type.zig | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/Type.zig b/src/Type.zig
index 1eab734882f8d25b246e4bc754004d4ca2397e39..60adb6f10ffb7601d85eb337ff05cafe452b1cba 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -690,9 +690,9 @@ pub fn hasRuntimeBits(ty: Type, zcu: *const Zcu) bool {
     };
 }
 
-/// true if and only if the type has a well-defined memory layout
-/// readFrom/writeToMemory are supported only for types with a well-
-/// defined memory layout
+/// Returns `true` iff the memory layout of `ty` is defined by the Zig language specification.
+///
+/// Does not require `ty` to be resolved.
 pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
@@ -3140,9 +3140,16 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
                 },
             };
         },
-        .array => {
-            if (position == .ret_ty or position == .param_ty) return false;
-            return ty.childType(zcu).validateExtern(.element, zcu);
+        .array => switch (position) {
+            .ret_ty,
+            .param_ty,
+            => false,
+
+            .union_field,
+            .struct_field,
+            .element,
+            .other,
+            => ty.childType(zcu).validateExtern(.element, zcu),
         },
         .vector => ty.childType(zcu).validateExtern(.element, zcu),
         .optional => ty.isPtrLikeOptional(zcu),
-- 
2.54.0


From 51c23f7ba4f09f26f53b21299a456f2ed9d7839e Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 27 Feb 2026 10:40:12 +0000
Subject: [PATCH 467/499] compiler: split default field values back out from
 layout resolution

I was trying out combining struct layout resolution with resolution of
default field values, but it broke a few cases which it's not clear we
want to break. The simplest such case was a struct with a field which
was a slice of itself, with a default value of `&.{}`.

So, at least for now, I'm accepting defeat and splitting this back out.
This allows a couple of behavior tests which were removed to be
re-introduced---I will do that in the commit following this one.

I have *not* made this separate phase of resolution "lazy": instead, it
is tied to layout resolution, in the sense that if a struct's layout is
referenced, then its default field values are also referenced. I chose
this approach for simplicity---not of the implementation (it's actually
slightly *more* code to do it this way!), but in terms of the language
specification. I think this behavior is easier to understand and keep in
your head. It can be easily changed in future if we decide we want to.

This partially reverts the commit titled "compiler: merge struct default
value resolution into layout resolution".
---
 src/Compilation.zig            |   6 +-
 src/IncrementalDebugServer.zig |   4 +-
 src/InternPool.zig             |  18 ++-
 src/Sema.zig                   |  56 ++++++----
 src/Sema/LowerZon.zig          |   1 +
 src/Sema/type_resolution.zig   | 198 ++++++++++++++++++++++++++-------
 src/Zcu.zig                    |  28 ++++-
 src/Zcu/PerThread.zig          | 147 +++++++++++++++++++++++-
 src/link/Dwarf.zig             |  10 +-
 9 files changed, 396 insertions(+), 72 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index a4e712826d4a04f3ca0e6f15475def928a3562ad..dad807fcbef769a4f92cc38848f2292481866e95 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3647,6 +3647,7 @@ const Header = extern struct {
         nav_val_deps_len: u32,
         nav_ty_deps_len: u32,
         type_layout_deps_len: u32,
+        struct_defaults_deps_len: u32,
         func_ies_deps_len: u32,
         zon_file_deps_len: u32,
         embed_file_deps_len: u32,
@@ -3696,6 +3697,7 @@ pub fn saveState(comp: *Compilation) !void {
                 .nav_val_deps_len = @intCast(ip.nav_val_deps.count()),
                 .nav_ty_deps_len = @intCast(ip.nav_ty_deps.count()),
                 .type_layout_deps_len = @intCast(ip.type_layout_deps.count()),
+                .struct_defaults_deps_len = @intCast(ip.struct_defaults_deps.count()),
                 .func_ies_deps_len = @intCast(ip.func_ies_deps.count()),
                 .zon_file_deps_len = @intCast(ip.zon_file_deps.count()),
                 .embed_file_deps_len = @intCast(ip.embed_file_deps.count()),
@@ -3720,7 +3722,7 @@ pub fn saveState(comp: *Compilation) !void {
             },
         });
 
-        try bufs.ensureTotalCapacityPrecise(24 + 9 * pt_headers.items.len);
+        try bufs.ensureTotalCapacityPrecise(26 + 9 * pt_headers.items.len);
         addBuf(&bufs, mem.asBytes(&header));
         addBuf(&bufs, @ptrCast(pt_headers.items));
 
@@ -3732,6 +3734,8 @@ pub fn saveState(comp: *Compilation) !void {
         addBuf(&bufs, @ptrCast(ip.nav_ty_deps.values()));
         addBuf(&bufs, @ptrCast(ip.type_layout_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.type_layout_deps.values()));
+        addBuf(&bufs, @ptrCast(ip.struct_defaults_deps.keys()));
+        addBuf(&bufs, @ptrCast(ip.struct_defaults_deps.values()));
         addBuf(&bufs, @ptrCast(ip.func_ies_deps.keys()));
         addBuf(&bufs, @ptrCast(ip.func_ies_deps.values()));
         addBuf(&bufs, @ptrCast(ip.zon_file_deps.keys()));
diff --git a/src/IncrementalDebugServer.zig b/src/IncrementalDebugServer.zig
index 782b34320586299b259336e70cca63d9fba32376..7d0dc8e89b6fd9fd257733839e924de1ce92a25f 100644
--- a/src/IncrementalDebugServer.zig
+++ b/src/IncrementalDebugServer.zig
@@ -307,7 +307,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const
             switch (dependee) {
                 .src_hash, .namespace, .namespace_name, .zon_file, .embed_file => try w.print("{f}", .{zcu.fmtDependee(dependee)}),
                 .nav_val, .nav_ty => |nav| try w.print("{t} {d}", .{ dependee, @intFromEnum(nav) }),
-                .type_layout, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
+                .type_layout, .struct_defaults, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }),
                 .memoized_state => |stage| try w.print("memoized_state {s}", .{@tagName(stage)}),
             }
             try w.writeByte('\n');
@@ -374,6 +374,8 @@ fn parseAnalUnit(str: []const u8) ?AnalUnit {
         return .wrap(.{ .nav_ty = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "type_layout")) {
         return .wrap(.{ .type_layout = @enumFromInt(parseIndex(idx_str) orelse return null) });
+    } else if (std.mem.eql(u8, kind, "struct_defaults")) {
+        return .wrap(.{ .struct_defaults = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "func")) {
         return .wrap(.{ .func = @enumFromInt(parseIndex(idx_str) orelse return null) });
     } else if (std.mem.eql(u8, kind, "memoized_state")) {
diff --git a/src/InternPool.zig b/src/InternPool.zig
index ffabc7371b0c9d7221475b966fa059eccf275a48..da95ed6cc7a40f96b08a7e3a589afb5f93d568df 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -54,6 +54,9 @@ func_ies_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
 /// Dependencies on the resolved layout of a `struct`, `union`, or `enum` type.
 /// Value is index into `dep_entries` of the first dependency on this type's layout.
 type_layout_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
+/// Dependencies on the resolved default field values of a `struct` type.
+/// Value is index into `dep_entries` of the first dependency on this type's inits.
+struct_defaults_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
 /// Dependencies on a ZON file. Triggered by `@import` of ZON.
 /// Value is index into `dep_entries` of the first dependency on this ZON file.
 zon_file_deps: std.AutoArrayHashMapUnmanaged(FileIndex, DepEntry.Index),
@@ -108,6 +111,7 @@ pub const empty: InternPool = .{
     .nav_ty_deps = .empty,
     .func_ies_deps = .empty,
     .type_layout_deps = .empty,
+    .struct_defaults_deps = .empty,
     .zon_file_deps = .empty,
     .embed_file_deps = .empty,
     .namespace_deps = .empty,
@@ -419,6 +423,7 @@ pub const AnalUnit = packed struct(u64) {
         nav_val,
         nav_ty,
         type_layout,
+        struct_defaults,
         func,
         memoized_state,
     };
@@ -432,6 +437,8 @@ pub const AnalUnit = packed struct(u64) {
         nav_ty: Nav.Index,
         /// This `AnalUnit` resolves the layout of the given `struct`, `union`, or `enum` type.
         type_layout: InternPool.Index,
+        /// This `AnalUnit` resolves the default field values of the given `struct` type.
+        struct_defaults: InternPool.Index,
         /// This `AnalUnit` analyzes the body of the given runtime function.
         func: InternPool.Index,
         /// This `AnalUnit` resolves all state which is memoized in fields on `Zcu`.
@@ -851,6 +858,7 @@ pub const Dependee = union(enum) {
     /// Index is the function, not its IES.
     func_ies: Index,
     type_layout: Index,
+    struct_defaults: Index,
     zon_file: FileIndex,
     embed_file: Zcu.EmbedFile.Index,
     namespace: TrackedInst.Index,
@@ -904,6 +912,7 @@ pub fn dependencyIterator(ip: *const InternPool, dependee: Dependee) DependencyI
         .nav_ty => |x| ip.nav_ty_deps.get(x),
         .func_ies => |x| ip.func_ies_deps.get(x),
         .type_layout => |x| ip.type_layout_deps.get(x),
+        .struct_defaults => |x| ip.struct_defaults_deps.get(x),
         .zon_file => |x| ip.zon_file_deps.get(x),
         .embed_file => |x| ip.embed_file_deps.get(x),
         .namespace => |x| ip.namespace_deps.get(x),
@@ -978,6 +987,7 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend
                 .nav_ty => ip.nav_ty_deps,
                 .func_ies => ip.func_ies_deps,
                 .type_layout => ip.type_layout_deps,
+                .struct_defaults => ip.struct_defaults_deps,
                 .zon_file => ip.zon_file_deps,
                 .embed_file => ip.embed_file_deps,
                 .namespace => ip.namespace_deps,
@@ -6454,6 +6464,7 @@ pub fn deinit(ip: *InternPool, gpa: Allocator, io: Io) void {
     ip.nav_ty_deps.deinit(gpa);
     ip.func_ies_deps.deinit(gpa);
     ip.type_layout_deps.deinit(gpa);
+    ip.struct_defaults_deps.deinit(gpa);
     ip.zon_file_deps.deinit(gpa);
     ip.embed_file_deps.deinit(gpa);
     ip.namespace_deps.deinit(gpa);
@@ -10619,6 +10630,7 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
     const nav_ty_deps_len = ip.nav_ty_deps.count();
     const func_ies_deps_len = ip.func_ies_deps.count();
     const type_layout_deps_len = ip.type_layout_deps.count();
+    const struct_defaults_deps_len = ip.struct_defaults_deps.count();
     const zon_file_deps_len = ip.zon_file_deps.count();
     const embed_file_deps_len = ip.embed_file_deps.count();
     const namespace_deps_len = ip.namespace_deps.count();
@@ -10629,6 +10641,7 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
     const nav_ty_deps_size = nav_ty_deps_len * 8;
     const func_ies_deps_size = func_ies_deps_len * 8;
     const type_layout_deps_size = type_layout_deps_len * 8;
+    const struct_defaults_deps_size = struct_defaults_deps_len * 8;
     const zon_file_deps_size = zon_file_deps_len * 8;
     const embed_file_deps_size = embed_file_deps_len * 8;
     const namespace_deps_size = namespace_deps_len * 8;
@@ -10642,6 +10655,7 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
         \\  {d} nav_ty: {d} bytes
         \\  {d} func_ies: {d} bytes
         \\  {d} type_layout: {d} bytes
+        \\  {d} struct_defaults: {d} bytes
         \\  {d} zon_file: {d} bytes
         \\  {d} embed_file: {d} bytes
         \\  {d} namespace: {d} bytes
@@ -10649,7 +10663,7 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
         \\
     , .{
         dep_entries_size + src_hash_deps_size + nav_val_deps_size + nav_ty_deps_size +
-            func_ies_deps_size + type_layout_deps_size + zon_file_deps_size +
+            func_ies_deps_size + type_layout_deps_size + struct_defaults_deps_size + zon_file_deps_size +
             embed_file_deps_size + namespace_deps_size + namespace_name_deps_size,
         dep_entries_len,
         dep_entries_size,
@@ -10663,6 +10677,8 @@ fn dumpDependencyStatsFallible(ip: *const InternPool, w: *Io.Writer) !void {
         func_ies_deps_size,
         type_layout_deps_len,
         type_layout_deps_size,
+        struct_defaults_deps_len,
+        struct_defaults_deps_size,
         zon_file_deps_len,
         zon_file_deps_size,
         embed_file_deps_len,
diff --git a/src/Sema.zig b/src/Sema.zig
index fc5b147759df31eead062d8980961059ab7e5a2c..337f0d07cda987e326bdf5869949734578fcb9d7 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -4533,6 +4533,10 @@ fn validateStructInit(
         if (explicit) continue;
         if (struct_ty.structFieldIsComptime(i, zcu)) continue;
 
+        if (!struct_ty.isTuple(zcu)) {
+            try sema.ensureStructDefaultsResolved(struct_ty, init_src);
+        }
+
         const default_val = struct_ty.structFieldDefaultValue(i, zcu) orelse {
             const field_name = struct_ty.structFieldName(i, zcu).unwrap() orelse {
                 const template = "missing tuple field with index {d}";
@@ -5850,6 +5854,7 @@ fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
         .nav_val,
         .nav_ty,
         .type_layout,
+        .struct_defaults,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -5868,6 +5873,7 @@ fn zirDisableIntrinsics(sema: *Sema) CompileError!void {
         .nav_val,
         .nav_ty,
         .type_layout,
+        .struct_defaults,
         .memoized_state,
         => return, // does nothing outside a function
     };
@@ -7091,7 +7097,14 @@ fn analyzeCall(
         });
         if (func_ty_info.cc == .auto) {
             switch (sema.owner.unwrap()) {
-                .@"comptime", .nav_ty, .nav_val, .type_layout, .memoized_state => {},
+                .@"comptime",
+                .nav_ty,
+                .nav_val,
+                .type_layout,
+                .struct_defaults,
+                .memoized_state,
+                => {},
+
                 .func => |owner_func| ip.funcSetHasErrorTrace(io, owner_func, true),
             }
         }
@@ -16907,6 +16920,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .struct_type => ip.loadStructType(ty.toIntern()),
                     else => unreachable,
                 };
+                try sema.ensureStructDefaultsResolved(ty, src); // can't do this sooner, since it's not allowed on tuples
                 struct_field_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len);
 
                 for (struct_field_vals, 0..) |*field_val, field_index| {
@@ -18788,6 +18802,8 @@ fn finishStructInit(
                     continue;
                 }
 
+                try sema.ensureStructDefaultsResolved(struct_ty, init_src);
+
                 const field_default: InternPool.Index = d: {
                     if (struct_type.field_defaults.len == 0) break :d .none;
                     break :d struct_type.field_defaults.get(ip)[i];
@@ -19454,7 +19470,14 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
         .func => |func| if (ip.funcAnalysisUnordered(func).has_error_trace and block.ownerModule().error_tracing) {
             return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
         },
-        .@"comptime", .nav_ty, .nav_val, .type_layout, .memoized_state => {},
+
+        .@"comptime",
+        .nav_ty,
+        .nav_val,
+        .type_layout,
+        .struct_defaults,
+        .memoized_state,
+        => {},
     }
     return Air.internedToRef(try pt.intern(.{ .opt = .{
         .ty = opt_ptr_stack_trace_ty.toIntern(),
@@ -24784,7 +24807,7 @@ fn zirBuiltinExtern(
         // So, for now, just use our containing `declaration`.
         .zir_index = switch (sema.owner.unwrap()) {
             .@"comptime" => |cu| ip.getComptimeUnit(cu).zir_index,
-            .type_layout => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
+            .type_layout, .struct_defaults => |owner_ty| Type.fromInterned(owner_ty).typeDeclInstAllowGeneratedTag(zcu).?,
             .memoized_state => unreachable,
             .nav_ty, .nav_val => |nav| ip.getNav(nav).analysis.?.zir_index,
             .func => |func| zir_index: {
@@ -25276,7 +25299,14 @@ fn getPanicIdFunc(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !In
     try sema.ensureMemoizedStateResolved(src, .panic);
     const panic_fn_index = zcu.builtin_decl_values.get(panic_id.toBuiltin());
     switch (sema.owner.unwrap()) {
-        .@"comptime", .nav_ty, .nav_val, .type_layout, .memoized_state => {},
+        .@"comptime",
+        .nav_ty,
+        .nav_val,
+        .type_layout,
+        .struct_defaults,
+        .memoized_state,
+        => {},
+
         .func => |owner_func| zcu.intern_pool.funcSetHasErrorTrace(io, owner_func, true),
     }
     return panic_fn_index;
@@ -33541,23 +33571,6 @@ pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {
     const gop = try sema.dependencies.getOrPut(sema.gpa, dependee);
     if (gop.found_existing) return;
 
-    // Avoid creating dependencies on ourselves. This situation can arise when we analyze the fields
-    // of a type and they use `@This()`. This dependency would be unnecessary, and in fact would
-    // just result in over-analysis since `Zcu.findOutdatedToAnalyze` would never be able to resolve
-    // the loop.
-    // Note that this also disallows a `nav_val`
-    switch (sema.owner.unwrap()) {
-        .nav_val => |this_nav| switch (dependee) {
-            .nav_val => |other_nav| if (this_nav == other_nav) return,
-            else => {},
-        },
-        .nav_ty => |this_nav| switch (dependee) {
-            .nav_ty => |other_nav| if (this_nav == other_nav) return,
-            else => {},
-        },
-        else => {},
-    }
-
     try pt.addDependency(sema.owner, dependee);
 }
 
@@ -33923,6 +33936,7 @@ const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStor
 
 pub const type_resolution = @import("Sema/type_resolution.zig");
 pub const ensureLayoutResolved = type_resolution.ensureLayoutResolved;
+pub const ensureStructDefaultsResolved = type_resolution.ensureStructDefaultsResolved;
 
 pub fn getBuiltinType(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) SemaError!Type {
     assert(decl.kind() == .type);
diff --git a/src/Sema/LowerZon.zig b/src/Sema/LowerZon.zig
index 06218806a44b24cf4433ed9b7738b27515a55154..2012d5167c2111f133aac6916d7aa6e697395f2a 100644
--- a/src/Sema/LowerZon.zig
+++ b/src/Sema/LowerZon.zig
@@ -758,6 +758,7 @@ fn lowerStruct(self: *LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool
     const ip = &pt.zcu.intern_pool;
 
     try self.sema.ensureLayoutResolved(res_ty, self.import_loc, .init);
+    try self.sema.ensureStructDefaultsResolved(res_ty, self.import_loc);
     const struct_info = self.sema.pt.zcu.typeToStruct(res_ty).?;
 
     const fields: @FieldType(Zoir.Node, "struct_literal") = switch (node.get(self.file.zoir.?)) {
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 5e4e8a4ccd84e8080f71162262560a934977b34f..717d5b8b96e34893007f4f9e80fd100c3ce7b241 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -134,6 +134,33 @@ fn ensureLayoutResolvedInner(sema: *Sema, ty: Type, orig_ty: Type, reason: *cons
     }
 }
 
+/// Asserts that `ty` is a non-tuple `struct` type, and ensures that its fields' default values
+/// are resolved. Adds incremental dependencies tracking the required type resolution.
+///
+/// It is not necessary to call this function to query the values of comptime fields: those values
+/// are available from type *layout* resolution, see `ensureLayoutResolved`.
+///
+/// Asserts that the *layout* of `ty` has already been resolved---see `ensureLayoutResolved`.
+pub fn ensureStructDefaultsResolved(sema: *Sema, ty: Type, src: LazySrcLoc) SemaError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+
+    assert(ip.indexToKey(ty.toIntern()) == .struct_type);
+    if (zcu.comp.config.incremental) assert(sema.dependencies.contains(.{ .type_layout = ty.toIntern() }));
+
+    try sema.declareDependency(.{ .struct_defaults = ty.toIntern() });
+    try sema.addReferenceEntry(null, src, .wrap(.{ .struct_defaults = ty.toIntern() }));
+
+    const reason: Zcu.DependencyReason = .{ .src = src, .type_layout_reason = undefined };
+
+    if (zcu.analysis_in_progress.contains(.wrap(.{ .struct_defaults = ty.toIntern() }))) {
+        return sema.failWithDependencyLoop(.wrap(.{ .struct_defaults = ty.toIntern() }), &reason);
+    }
+
+    try pt.ensureStructDefaultsUpToDate(ty, &reason);
+}
+
 /// Asserts that `struct_ty` is a non-packed non-tuple struct, and that `sema.owner` is that type.
 /// This function *does* register the `src_hash` dependency on the struct.
 pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
@@ -193,14 +220,8 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
         @memset(struct_obj.field_is_comptime_bits.getAll(ip), 0);
 
         const zir_struct = sema.code.getStructDecl(zir_index);
-
-        // If we have any default values to resolve, we'll need to map the struct decl instruction
-        // to the result type.
-        if (zir_struct.field_default_body_lens != null) {
-            try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
-        }
-
         var field_it = zir_struct.iterateFields();
+        var any_comptime_fields = false;
         while (field_it.next()) |zir_field| {
             {
                 const name_slice = sema.code.nullTerminatedString(zir_field.name);
@@ -212,18 +233,21 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 const bit_bag_index = zir_field.idx / 32;
                 const mask = @as(u32, 1) << @intCast(zir_field.idx % 32);
                 struct_obj.field_is_comptime_bits.getAll(ip)[bit_bag_index] |= mask;
+                any_comptime_fields = true;
             }
 
-            const field_ty: Type = field_ty: {
+            {
                 const field_ty_src = block.src(.{ .container_field_type = zir_field.idx });
-                block.comptime_reason = .{ .reason = .{
-                    .src = field_ty_src,
-                    .r = .{ .simple = .struct_field_types },
-                } };
-                const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
-                break :field_ty try sema.analyzeAsType(&block, field_ty_src, .struct_field_types, type_ref);
-            };
-            struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+                const field_ty: Type = field_ty: {
+                    block.comptime_reason = .{ .reason = .{
+                        .src = field_ty_src,
+                        .r = .{ .simple = .struct_field_types },
+                    } };
+                    const type_ref = try sema.resolveInlineBody(&block, zir_field.type_body, zir_index);
+                    break :field_ty try sema.analyzeAsType(&block, field_ty_src, .struct_field_types, type_ref);
+                };
+                struct_obj.field_types.get(ip)[zir_field.idx] = field_ty.toIntern();
+            }
 
             if (struct_obj.field_aligns.len == 0) {
                 assert(zir_field.align_body == null);
@@ -240,31 +264,13 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
                 };
                 struct_obj.field_aligns.get(ip)[zir_field.idx] = field_align;
             }
+        }
 
-            if (struct_obj.field_defaults.len == 0) {
-                assert(zir_field.default_body == null);
-            } else {
-                const field_default_src = block.src(.{ .container_field_value = zir_field.idx });
-                const field_default: InternPool.Index = d: {
-                    block.comptime_reason = .{ .reason = .{
-                        .src = field_default_src,
-                        .r = .{ .simple = .struct_field_default_value },
-                    } };
-                    const default_body = zir_field.default_body orelse break :d .none;
-                    // Provide the result type
-                    sema.inst_map.putAssumeCapacity(zir_index, .fromType(field_ty));
-                    defer assert(sema.inst_map.remove(zir_index));
-                    const uncoerced_default_val = try sema.resolveInlineBody(&block, default_body, zir_index);
-                    const coerced_default_val = try sema.coerce(&block, field_ty, uncoerced_default_val, field_default_src);
-                    const default_val = try sema.resolveConstValue(&block, field_default_src, coerced_default_val, null);
-                    if (default_val.canMutateComptimeVarState(zcu)) {
-                        const field_name = struct_obj.field_names.get(ip)[zir_field.idx];
-                        return sema.failWithContainsReferenceToComptimeVar(&block, field_default_src, field_name, "field default value", default_val);
-                    }
-                    break :d default_val.toIntern();
-                };
-                struct_obj.field_defaults.get(ip)[zir_field.idx] = field_default;
-            }
+        // We also resolve the default values of any `comptime` fields now. This is not necessary in
+        // the case of a reified struct because the the default values were already poulated and
+        // validated by `Sema.zirReifyStruct`.
+        if (any_comptime_fields) {
+            try resolveStructDefaultsInner(sema, &block, &struct_obj, .comptime_fields);
         }
     }
 
@@ -523,6 +529,118 @@ fn resolvePackedStructLayout(
     );
 }
 
+/// Asserts that `struct_ty` is a non-tuple struct, and that `sema.owner` is that type.
+///
+/// Also asserts that the layout of `struct_ty` has *already* been resolved (though it is okay for
+/// that resolution to have failed). This requirement exists to ensure better error messages in the
+/// event of a dependency loop.
+///
+/// This function *does* register the `src_hash` dependency on the struct.
+pub fn resolveStructDefaults(sema: *Sema, struct_ty: Type) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(sema.owner.unwrap().struct_defaults == struct_ty.toIntern());
+
+    // We always depend on the layout of `struct_ty`. However, we don't actually need to resolve it
+    // now, because the caller has done so for us. Just mark the dependency so that the incremental
+    // compilation handling understands the dependency graph.
+    try sema.declareDependency(.{ .type_layout = struct_ty.toIntern() });
+    struct_ty.assertHasLayout(zcu);
+    const layout_unit: InternPool.AnalUnit = .wrap(.{ .type_layout = struct_ty.toIntern() });
+    if (zcu.failed_analysis.contains(layout_unit) or zcu.transitive_failed_analysis.contains(layout_unit)) {
+        return error.AnalysisFail;
+    }
+
+    const struct_obj = ip.loadStructType(struct_ty.toIntern());
+    assert(struct_obj.want_layout);
+
+    if (struct_obj.is_reified) {
+        // `Sema.zirReifyStruct` has already populated the default field values *and* (by loading
+        // the default values from pointers) validated their types, so we have nothing to do.
+        return;
+    }
+
+    try sema.declareDependency(.{ .src_hash = struct_obj.zir_index });
+
+    if (struct_obj.field_defaults.len == 0) {
+        // The struct has no default field values, so the slice has been omitted.
+        return;
+    }
+
+    var block: Block = .{
+        .parent = null,
+        .sema = sema,
+        .namespace = struct_obj.namespace,
+        .instructions = .empty,
+        .inlining = null,
+        .comptime_reason = undefined, // always set before using `block`
+        .src_base_inst = struct_obj.zir_index,
+        .type_name_ctx = struct_obj.name,
+    };
+    defer block.instructions.deinit(gpa);
+
+    return resolveStructDefaultsInner(sema, &block, &struct_obj, .normal_fields);
+}
+
+/// Asserts that the struct is not reified, and that `struct_obj.field_defaults.len` is non-zero.
+fn resolveStructDefaultsInner(
+    sema: *Sema,
+    block: *Block,
+    struct_obj: *const InternPool.LoadedStructType,
+    mode: enum { comptime_fields, normal_fields },
+) CompileError!void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+    const ip = &zcu.intern_pool;
+
+    assert(struct_obj.field_defaults.len > 0);
+
+    // We'll need to map the struct decl instruction to provide result types
+    const zir_index = struct_obj.zir_index.resolve(ip) orelse return error.AnalysisFail;
+    try sema.inst_map.ensureSpaceForInstructions(gpa, &.{zir_index});
+
+    const field_types = struct_obj.field_types.get(ip);
+
+    const zir_struct = sema.code.getStructDecl(zir_index);
+    var field_it = zir_struct.iterateFields();
+    while (field_it.next()) |zir_field| {
+        switch (mode) {
+            .comptime_fields => if (!zir_field.is_comptime) continue,
+            .normal_fields => if (zir_field.is_comptime) continue,
+        }
+
+        const default_val_src = block.src(.{ .container_field_value = zir_field.idx });
+        block.comptime_reason = .{ .reason = .{
+            .src = default_val_src,
+            .r = .{ .simple = .struct_field_default_value },
+        } };
+        const default_body = zir_field.default_body orelse {
+            struct_obj.field_defaults.get(ip)[zir_field.idx] = .none;
+            continue;
+        };
+        const field_ty: Type = .fromInterned(field_types[zir_field.idx]);
+        const uncoerced = ref: {
+            // Provide the result type
+            sema.inst_map.putAssumeCapacity(zir_index, .fromIntern(field_ty.toIntern()));
+            defer assert(sema.inst_map.remove(zir_index));
+            break :ref try sema.resolveInlineBody(block, default_body, zir_index);
+        };
+        const coerced = try sema.coerce(block, field_ty, uncoerced, default_val_src);
+        const default_val = try sema.resolveConstValue(block, default_val_src, coerced, null);
+        if (default_val.canMutateComptimeVarState(zcu)) {
+            const field_name = struct_obj.field_names.get(ip)[zir_field.idx];
+            return sema.failWithContainsReferenceToComptimeVar(block, default_val_src, field_name, "field default value", default_val);
+        }
+        struct_obj.field_defaults.get(ip)[zir_field.idx] = default_val.toIntern();
+    }
+}
+
 /// This logic must be kept in sync with `Type.getUnionLayout`.
 pub fn resolveUnionLayout(sema: *Sema, union_ty: Type) CompileError!void {
     const pt = sema.pt;
diff --git a/src/Zcu.zig b/src/Zcu.zig
index faa535da5d6e12ae12c1ba6aaed1341fde2147d6..c623c1ec49f110d79676431c59481e6339613948 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -3175,6 +3175,7 @@ fn markPoDependeeUpToDateInner(zcu: *Zcu, dependee: InternPool.Dependee) !void {
             .nav_val => |nav| try zcu.markPoDependeeUpToDateInner(.{ .nav_val = nav }),
             .nav_ty => |nav| try zcu.markPoDependeeUpToDateInner(.{ .nav_ty = nav }),
             .type_layout => |ty| try zcu.markPoDependeeUpToDateInner(.{ .type_layout = ty }),
+            .struct_defaults => |ty| try zcu.markPoDependeeUpToDateInner(.{ .struct_defaults = ty }),
             .func => |func| try zcu.markPoDependeeUpToDateInner(.{ .func_ies = func }),
             .memoized_state => |stage| try zcu.markPoDependeeUpToDateInner(.{ .memoized_state = stage }),
         }
@@ -3193,6 +3194,7 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
         .nav_val => |nav| .{ .nav_val = nav },
         .nav_ty => |nav| .{ .nav_ty = nav },
         .type_layout => |ty| .{ .type_layout = ty },
+        .struct_defaults => |ty| .{ .struct_defaults = ty },
         .func => |func_index| .{ .func_ies = func_index },
         .memoized_state => |stage| .{ .memoized_state = stage },
     };
@@ -4249,11 +4251,18 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.AutoArrayHashMapUnmanag
             unit_idx += 1;
 
             // `nav_val` and `nav_ty` reference each other *implicitly* to save memory.
+            // Likewise for `type_layout` and `struct_defaults` of a struct type.
             queue_paired: {
                 const other: AnalUnit = .wrap(switch (unit.unwrap()) {
                     .nav_val => |n| .{ .nav_ty = n },
                     .nav_ty => |n| .{ .nav_val = n },
-                    .@"comptime", .type_layout, .func, .memoized_state => break :queue_paired,
+                    .struct_defaults => |ty| .{ .type_layout = ty },
+                    .type_layout => |ty| switch (ip.indexToKey(ty)) {
+                        .struct_type => .{ .struct_defaults = ty },
+                        .union_type, .enum_type, .opaque_type => break :queue_paired,
+                        else => unreachable,
+                    },
+                    .@"comptime", .func, .memoized_state => break :queue_paired,
                 });
                 const gop = try units.getOrPut(gpa, other);
                 if (gop.found_existing) break :queue_paired;
@@ -4406,7 +4415,7 @@ fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void
             }
         },
         .nav_val, .nav_ty => |nav, tag| return writer.print("{t}('{f}' [{}])", .{ tag, ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }),
-        .type_layout => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
+        .type_layout, .struct_defaults => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }),
         .func => |func| {
             const nav = zcu.funcInfo(func).owner_nav;
             return writer.print("func('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(func) });
@@ -4431,7 +4440,7 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void
             const fqn = ip.getNav(nav).fqn;
             return writer.print("{t}('{f}')", .{ tag, fqn.fmt(ip) });
         },
-        .type_layout => |ip_index, tag| {
+        .type_layout, .struct_defaults => |ip_index, tag| {
             const name = Type.fromInterned(ip_index).containerTypeName(ip);
             return writer.print("{t}('{f}')", .{ tag, name.fmt(ip) });
         },
@@ -4920,6 +4929,10 @@ fn addDependencyLoopErrorLine(
             fmt_source,
             dep_node.reason.type_layout_reason.msg(),
         }),
+        .struct_defaults => |ty| try eb.printString(
+            "default field values of '{f}' depend on themselves for initialization here",
+            .{Type.fromInterned(ty).containerTypeName(ip).fmt(ip)},
+        ),
     } else switch (dep_node.unit.unwrap()) {
         .@"comptime" => unreachable, // cannot be involved in a dependency loop
         .nav_val => |nav| try eb.printString("{f} uses value of declaration '{f}' here", .{
@@ -4940,6 +4953,10 @@ fn addDependencyLoopErrorLine(
             Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
             dep_node.reason.type_layout_reason.msg(),
         }),
+        .struct_defaults => |ty| try eb.printString(
+            "{f} uses default field values of '{f}' here",
+            .{ fmt_source, Type.fromInterned(ty).containerTypeName(ip).fmt(ip) },
+        ),
     };
 
     const src_loc = dep_node.reason.src.upgrade(zcu);
@@ -4982,6 +4999,9 @@ fn formatDependencyLoopSourceUnit(data: FormatAnalUnit, w: *Io.Writer) Io.Writer
         .type_layout => |ty| try w.print("type '{f}'", .{
             Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
         }),
+        .struct_defaults => |ty| try w.print("default field value of '{f}'", .{
+            Type.fromInterned(ty).containerTypeName(ip).fmt(ip),
+        }),
         .func => |func| try w.print("function '{f}'", .{
             ip.getNav(zcu.funcInfo(func).owner_nav).fqn.fmt(ip),
         }),
@@ -5030,7 +5050,7 @@ pub fn populateReferenceTrace(
             const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
                 .@"comptime" => "comptime",
                 .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
-                .type_layout => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
+                .type_layout, .struct_defaults => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
                 .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
                 .memoized_state => null,
             };
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index ee788c884e327fffe1fe5a1e6f09854ba6932803..8a786edb4903b031464efdadf108966bd8f63af0 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -324,6 +324,17 @@ pub fn update(
             .nav_ty => |nav| pt.ensureNavTypeUpToDate(nav, null),
             .nav_val => |nav| pt.ensureNavValUpToDate(nav, null),
             .type_layout => |ty| pt.ensureTypeLayoutUpToDate(.fromInterned(ty), null),
+            .struct_defaults => |ty| res: {
+                // Unlike the other functions, this one requires that the type layout is resolved first.
+                pt.ensureTypeLayoutUpToDate(.fromInterned(ty), null) catch |err| switch (err) {
+                    error.OutOfMemory,
+                    error.Canceled,
+                    => |e| return e,
+
+                    error.AnalysisFail => {}, // already reported
+                };
+                break :res pt.ensureStructDefaultsUpToDate(.fromInterned(ty), null);
+            },
             .memoized_state => |stage| pt.ensureMemoizedStateUpToDate(stage, null),
             .func => |func| pt.ensureFuncBodyUpToDate(func, null),
         };
@@ -1326,6 +1337,7 @@ pub fn ensureTypeLayoutUpToDate(
     defer tracy_trace.end();
 
     const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
     const comp = zcu.comp;
     const gpa = comp.gpa;
 
@@ -1335,8 +1347,23 @@ pub fn ensureTypeLayoutUpToDate(
 
     assert(!zcu.analysis_in_progress.contains(anal_unit));
 
-    const was_outdated = zcu.clearOutdatedState(anal_unit) or
-        zcu.intern_pool.setWantTypeLayout(comp.io, ty.toIntern());
+    const was_outdated: bool = outdated: {
+        if (zcu.clearOutdatedState(anal_unit)) break :outdated true;
+        if (ip.setWantTypeLayout(comp.io, ty.toIntern())) {
+            // We'll analyze the layout for the first time, but if this is a struct type then its
+            // default field values also need to be analyzed.
+            if (ip.indexToKey(ty.toIntern()) == .struct_type) {
+                if (std.debug.runtime_safety) zcu.outdated_lock.lockUncancelable(zcu.comp.io);
+                defer if (std.debug.runtime_safety) zcu.outdated_lock.unlock(zcu.comp.io);
+                try zcu.outdated.ensureUnusedCapacity(gpa, 1);
+                try zcu.outdated_ready.other.ensureUnusedCapacity(gpa, 1);
+                zcu.outdated.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = ty.toIntern() }), 0);
+                zcu.outdated_ready.other.putAssumeCapacityNoClobber(.wrap(.{ .struct_defaults = ty.toIntern() }), {});
+            }
+            break :outdated true;
+        }
+        break :outdated false;
+    };
 
     if (was_outdated) {
         // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
@@ -1359,7 +1386,7 @@ pub fn ensureTypeLayoutUpToDate(
         info.deps.clearRetainingCapacity();
     }
 
-    const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(&zcu.intern_pool).toSlice(&zcu.intern_pool), null);
+    const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(ip).toSlice(ip), null);
     defer unit_tracking.end(zcu);
 
     try zcu.analysis_in_progress.put(gpa, anal_unit, reason);
@@ -1428,6 +1455,120 @@ pub fn ensureTypeLayoutUpToDate(
     if (new_failed) return error.AnalysisFail;
 }
 
+/// Ensures that the default field values of the given `struct` type are fully up-to-date,
+/// performing re-analysis if necessary. Asserts that `ty` is a struct (not a tuple!) type. Unlike
+/// the other "ensure X up to date" functions, this particular function also asserts that the
+/// *layout* of `ty` is *already* up-to-date (though it is okay for that resolution to have failed).
+/// Returns `error.AnalysisFail` if an analysis error is encountered while resolving the default
+/// field values; the caller is free to ignore this, since the error is already registered.
+pub fn ensureStructDefaultsUpToDate(
+    pt: Zcu.PerThread,
+    ty: Type,
+    /// `null` is valid only for the "root" analysis, i.e. called from `Compilation.processOneJob`.
+    reason: ?*const Zcu.DependencyReason,
+) Zcu.SemaError!void {
+    const tracy_trace = trace(@src());
+    defer tracy_trace.end();
+
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const comp = zcu.comp;
+    const gpa = comp.gpa;
+
+    assert(ip.indexToKey(ty.toIntern()) == .struct_type);
+
+    const anal_unit: AnalUnit = .wrap(.{ .struct_defaults = ty.toIntern() });
+
+    log.debug("ensureStructDefaultsUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)});
+
+    assert(!zcu.analysis_in_progress.contains(anal_unit));
+
+    const was_outdated: bool = outdated: {
+        if (zcu.clearOutdatedState(anal_unit)) break :outdated true;
+        // The type layout should already be marked as "wanted" by this point, because a struct's
+        // layout must always be analyzed before its default values are.
+        assert(!ip.setWantTypeLayout(comp.io, ty.toIntern()));
+        break :outdated false;
+    };
+
+    if (was_outdated) {
+        // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
+        if (dev.env.supports(.incremental)) {
+            zcu.resetUnit(anal_unit);
+        }
+        // For types, we already know that we have to invalidate all dependees.
+        // TODO: we actually *could* detect whether everything was the same. should we bother?
+        try zcu.markDependeeOutdated(.marked_po, .{ .struct_defaults = ty.toIntern() });
+    } else {
+        // We can trust the current information about this unit.
+        if (zcu.failed_analysis.contains(anal_unit)) return error.AnalysisFail;
+        if (zcu.transitive_failed_analysis.contains(anal_unit)) return error.AnalysisFail;
+        return;
+    }
+
+    if (zcu.comp.debugIncremental()) {
+        const info = try zcu.incremental_debug_state.getUnitInfo(gpa, anal_unit);
+        info.last_update_gen = zcu.generation;
+        info.deps.clearRetainingCapacity();
+    }
+
+    const unit_tracking = zcu.trackUnitSema(ty.containerTypeName(ip).toSlice(ip), null);
+    defer unit_tracking.end(zcu);
+
+    try zcu.analysis_in_progress.put(gpa, anal_unit, reason);
+    defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
+
+    var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
+    defer analysis_arena.deinit();
+
+    var comptime_err_ret_trace: std.array_list.Managed(Zcu.LazySrcLoc) = .init(gpa);
+    defer comptime_err_ret_trace.deinit();
+
+    const file = zcu.namespacePtr(ty.getNamespaceIndex(zcu)).fileScope(zcu);
+
+    var sema: Sema = .{
+        .pt = pt,
+        .gpa = gpa,
+        .arena = analysis_arena.allocator(),
+        .code = file.zir.?,
+        .owner = anal_unit,
+        .func_index = .none,
+        .func_is_naked = false,
+        .fn_ret_ty = .void,
+        .fn_ret_ty_ies = null,
+        .comptime_err_ret_trace = &comptime_err_ret_trace,
+    };
+    defer sema.deinit();
+
+    const new_failed: bool = if (Sema.type_resolution.resolveStructDefaults(&sema, ty)) failed: {
+        break :failed false;
+    } else |err| switch (err) {
+        error.AnalysisFail => failed: {
+            if (!zcu.failed_analysis.contains(anal_unit)) {
+                // If this unit caused the error, it would have an entry in `failed_analysis`.
+                // Since it does not, this must be a transitive failure.
+                try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
+                log.debug("mark transitive analysis failure for {f}", .{zcu.fmtAnalUnit(anal_unit)});
+            }
+            break :failed true;
+        },
+        error.OutOfMemory,
+        error.Canceled,
+        => |e| return e,
+        error.ComptimeReturn => unreachable,
+        error.ComptimeBreak => unreachable,
+    };
+
+    sema.flushExports() catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+    };
+
+    // We don't need to `markDependeeOutdated`/`markPoDependeeUpToDate` here, because we already
+    // marked the struct defaults as outdated at the top of this function.
+
+    if (new_failed) return error.AnalysisFail;
+}
+
 /// Ensures that the resolved value of the given `Nav` is fully up-to-date, performing re-analysis
 /// if necessary. Returns `error.AnalysisFail` if an analysis error is encountered; the caller is
 /// free to ignore this, since the error is already registered.
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 806a85ff23cb3a0b8ead4e6716b24de3b70995f5..d09012fe948ba1a70b1b93fb99a8966abf89c8bc 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -3827,7 +3827,15 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co
                         try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
                         for (0..loaded_struct.field_types.len) |field_index| {
                             const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
-                            const field_init = loaded_struct.field_defaults.getOrNone(ip, field_index);
+                            // TODO: we currently don't emit information about default values for
+                            // non-`comptime` fields, because these default values are resolved at a
+                            // separate time in the compiler frontend. To emit this information, the
+                            // frontend needs to tell us when the default values are available: like
+                            // how `Zcu.PerThread.ensureTypeLayoutUpToDate` enqueues a link task to
+                            // indicate completion of the type's layout, a task should be enqueued
+                            // by `Zcu.PerThread.ensureStructDefaultsUpToDate`, and upon receiving
+                            // it we should patch the correct default field values in.
+                            const field_init: InternPool.Index = if (is_comptime) loaded_struct.field_defaults.getOrNone(ip, field_index) else .none;
                             assert(!(is_comptime and field_init == .none));
                             const field_type: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
                             const has_runtime_bits, const has_comptime_state = switch (field_init) {
-- 
2.54.0


From bb78871aa44594a1b4782792942664e532491d5a Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 27 Feb 2026 11:23:05 +0000
Subject: [PATCH 468/499] behavior: re-introduce some previously-removed tests

Now that struct default value resolution is separate from struct layout
resolution, a handful of old behavior tests are now once again valid.

This partially reverts the commit titled "behavior: update for changes
to struct field default value resolution".
---
 test/behavior/struct.zig | 58 +++++++++++++++++++++++++++++++++++++---
 test/behavior/union.zig  | 49 +++++++++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 3 deletions(-)

diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 37dc873d60385608367b1841362aaadb21254e5c..e6a355864629600f6294492ee11e4cf7c73f5674 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -1249,6 +1249,20 @@ test "store to comptime field" {
     }
 }
 
+test "struct field init value is size of the struct" {
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+
+    const namespace = struct {
+        const S = extern struct {
+            size: u8 = @sizeOf(S),
+            blah: u16,
+        };
+    };
+    var s: namespace.S = .{ .blah = 1234 };
+    _ = &s;
+    try expect(s.size == 4);
+}
+
 test "under-aligned struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1696,19 +1710,41 @@ test "comptimeness of optional and error union payload is analyzed properly" {
     try std.testing.expectEqual(3, x);
 }
 
+test "initializer uses own alignment" {
+    const S = struct {
+        x: u32 = @alignOf(@This()) + 1,
+    };
+
+    var s: S = .{};
+    _ = &s;
+    try expectEqual(4, @alignOf(S));
+    try expectEqual(@as(usize, 5), s.x);
+}
+
+test "initializer uses own size" {
+    const S = struct {
+        x: u32 = @sizeOf(@This()) + 1,
+    };
+
+    var s: S = .{};
+    _ = &s;
+    try expectEqual(4, @sizeOf(S));
+    try expectEqual(@as(usize, 5), s.x);
+}
+
 test "initializer takes a pointer to a variable inside its struct" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const namespace = struct {
         const S = struct {
-            x: *u32 = &S.int,
-            var int: u32 = undefined;
+            s: *S = &S.instance,
+            var instance: S = undefined;
         };
 
         fn doTheTest() !void {
             var foo: S = .{};
             _ = &foo;
-            try expectEqual(&S.int, foo.x);
+            try expectEqual(&S.instance, foo.s);
         }
     };
 
@@ -1739,6 +1775,22 @@ test "circular dependency through pointer field of a struct" {
     try expect(outer.middle.inner == null);
 }
 
+test "field calls do not force struct field init resolution" {
+    const S = struct {
+        x: u32 = blk: {
+            _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
+            break :blk 123;
+        },
+        dummyFn: *const fn () void = undefined,
+        fn make() @This() {
+            return .{};
+        }
+    };
+    var s: S = .{};
+    _ = &s;
+    try expect(s.x == 123);
+}
+
 test "tuple with comptime-only field" {
     const S = struct {
         fn getTuple() struct { comptime_int } {
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index b081d9b33a06e41df101c7f55f2d716821be30fe..9badc9dabd11bd6709c95ae32ba755f6cc3b9bd2 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1796,6 +1796,55 @@ test "reinterpret packed union inside packed struct" {
     try S.doTheTest();
 }
 
+test "inner struct initializer uses union layout" {
+    const namespace = struct {
+        const U = union {
+            a: struct {
+                x: u32 = @alignOf(U) + 1,
+            },
+            b: struct {
+                y: u16 = @sizeOf(U) + 2,
+            },
+        };
+    };
+
+    {
+        const u: namespace.U = .{ .a = .{} };
+        try expectEqual(4, @alignOf(namespace.U));
+        try expectEqual(@as(usize, 5), u.a.x);
+    }
+
+    {
+        const u: namespace.U = .{ .b = .{} };
+        try expectEqual(@as(usize, @sizeOf(namespace.U) + 2), u.b.y);
+    }
+}
+
+test "inner struct initializer uses packed union layout" {
+    const namespace = struct {
+        const U = packed union {
+            a: packed struct {
+                x: u32 = @alignOf(U) + 1,
+            },
+            b: packed struct(u32) {
+                y: u16 = @sizeOf(U) + 2,
+                padding: u16 = 0,
+            },
+        };
+    };
+
+    {
+        const u: namespace.U = .{ .a = .{} };
+        try expectEqual(4, @alignOf(namespace.U));
+        try expectEqual(@as(usize, 5), u.a.x);
+    }
+
+    {
+        const u: namespace.U = .{ .b = .{} };
+        try expectEqual(@as(usize, @sizeOf(namespace.U) + 2), u.b.y);
+    }
+}
+
 test "extern union initialized via reintepreted struct field initializer" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
-- 
2.54.0


From d462794e20127f396753c7d6064a9d2b4e0304d9 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 27 Feb 2026 14:40:01 +0000
Subject: [PATCH 469/499] get the compiler building

The change in codegen/x86_64/CodeGen.zig was not strictly necessary (the
Sema change I did solves the error I was getting there), I just think
it's better style anyway.
---
 lib/std/os/windows.zig         | 10 +++----
 src/Sema.zig                   | 52 ++++++++++++++++++++--------------
 src/Sema/type_resolution.zig   |  2 +-
 src/Zcu/PerThread.zig          | 22 +++++++++++++-
 src/codegen/spirv/CodeGen.zig  |  2 +-
 src/codegen/x86_64/CodeGen.zig |  2 +-
 6 files changed, 59 insertions(+), 31 deletions(-)

diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 8832b1add949df3245eed397ff6f614c54c33d6e..6f2c8f49381ca695d388f87a4be5070e42271959 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -4160,7 +4160,7 @@ pub const RUNTIME_FUNCTION = switch (native_arch) {
         BeginAddress: DWORD,
         DUMMYUNIONNAME: extern union {
             UnwindData: DWORD,
-            DUMMYSTRUCTNAME: packed struct {
+            DUMMYSTRUCTNAME: packed struct(u32) {
                 Flag: u2,
                 FunctionLength: u11,
                 Ret: u2,
@@ -4177,7 +4177,7 @@ pub const RUNTIME_FUNCTION = switch (native_arch) {
         BeginAddress: DWORD,
         DUMMYUNIONNAME: extern union {
             UnwindData: DWORD,
-            DUMMYSTRUCTNAME: packed struct {
+            DUMMYSTRUCTNAME: packed struct(u32) {
                 Flag: u2,
                 FunctionLength: u11,
                 RegF: u3,
@@ -5013,7 +5013,7 @@ pub const KUSER_SHARED_DATA = extern struct {
     KdDebuggerEnabled: BOOLEAN,
     DummyUnion1: extern union {
         MitigationPolicies: UCHAR,
-        Alt: packed struct {
+        Alt: packed struct(u8) {
             NXSupportPolicy: u2,
             SEHValidationPolicy: u2,
             CurDirDevicesSkippedForDlls: u2,
@@ -5029,7 +5029,7 @@ pub const KUSER_SHARED_DATA = extern struct {
     SafeBootMode: BOOLEAN,
     DummyUnion2: extern union {
         VirtualizationFlags: UCHAR,
-        Alt: packed struct {
+        Alt: packed struct(u8) {
             ArchStartedInEl2: u1,
             QcSlIsSupported: u1,
             SpareBits: u6,
@@ -5038,7 +5038,7 @@ pub const KUSER_SHARED_DATA = extern struct {
     Reserved12: [2]UCHAR,
     DummyUnion3: extern union {
         SharedDataFlags: ULONG,
-        Alt: packed struct {
+        Alt: packed struct(u32) {
             DbgErrorPortPresent: u1,
             DbgElevationEnabled: u1,
             DbgVirtEnabled: u1,
diff --git a/src/Sema.zig b/src/Sema.zig
index 337f0d07cda987e326bdf5869949734578fcb9d7..02c2efd2ee7f27c1312ed8d04ed808debeca71f1 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3081,7 +3081,7 @@ fn zirRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
     const operand = sema.resolveInst(inst_data.operand);
-    return sema.analyzeRef(block, block.tokenOffset(inst_data.src_tok), operand);
+    return sema.analyzeRef(block, block.tokenOffset(inst_data.src_tok), operand, .none);
 }
 
 fn zirEnsureResultUsed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
@@ -18690,7 +18690,7 @@ fn zirStructInit(
             const union_val = try sema.bitCast(block, resolved_ty, init_inst, src, field_src);
             const result_val = try sema.coerce(block, result_ty, union_val, src);
             if (is_ref) {
-                return sema.analyzeRef(block, src, result_val);
+                return sema.analyzeRef(block, src, result_val, .none);
             } else {
                 return result_val;
             }
@@ -24192,7 +24192,7 @@ fn zirMemcpy(
         }
     } else if (dest_len == .none and len_val == null) {
         // Change the dest to a slice, since its type must have the length.
-        const dest_ptr_ptr = try sema.analyzeRef(block, dest_src, new_dest_ptr);
+        const dest_ptr_ptr = try sema.analyzeRef(block, dest_src, new_dest_ptr, .none);
         new_dest_ptr = try sema.analyzeSlice(block, dest_src, dest_ptr_ptr, .zero, src_len, .none, LazySrcLoc.unneeded, dest_src, dest_src, dest_src, false);
         const new_src_ptr_ty = sema.typeOf(new_src_ptr);
         if (new_src_ptr_ty.isSlice(zcu)) {
@@ -26301,7 +26301,7 @@ fn structFieldPtr(
     const field_index: u32 = if (struct_ty.isTuple(zcu)) field_index: {
         if (field_name.eqlSlice("len", ip)) {
             const len_inst = try pt.intRef(.usize, struct_ty.structFieldCount(zcu));
-            return sema.analyzeRef(block, src, len_inst);
+            return sema.analyzeRef(block, src, len_inst, .none);
         }
         break :field_index try sema.tupleFieldIndex(block, struct_ty, field_name, field_name_src);
     } else field_index: {
@@ -29787,10 +29787,7 @@ fn coerceTupleToSlicePtrs(
         .child = slice_info.child,
     });
     const array_inst = try sema.coerceTupleToArray(block, array_ty, slice_ty_src, tuple, tuple_src);
-    if (slice_info.flags.alignment != .none) {
-        return sema.fail(block, slice_ty_src, "TODO: override the alignment of the array decl we create here", .{});
-    }
-    const ptr_array = try sema.analyzeRef(block, slice_ty_src, array_inst);
+    const ptr_array = try sema.analyzeRef(block, slice_ty_src, array_inst, slice_info.flags.alignment);
     return sema.coerceArrayPtrToSlice(block, slice_ty, ptr_array, slice_ty_src);
 }
 
@@ -29809,10 +29806,7 @@ fn coerceTupleToArrayPtrs(
     const ptr_info = ptr_array_ty.ptrInfo(zcu);
     const array_ty: Type = .fromInterned(ptr_info.child);
     const array_inst = try sema.coerceTupleToArray(block, array_ty, array_ty_src, tuple, tuple_src);
-    if (ptr_info.flags.alignment != .none) {
-        return sema.fail(block, array_ty_src, "TODO: override the alignment of the array decl we create here", .{});
-    }
-    const ptr_array = try sema.analyzeRef(block, array_ty_src, array_inst);
+    const ptr_array = try sema.analyzeRef(block, array_ty_src, array_inst, ptr_info.flags.alignment);
     return ptr_array;
 }
 
@@ -30137,33 +30131,47 @@ fn analyzeRef(
     block: *Block,
     src: LazySrcLoc,
     operand: Air.Inst.Ref,
+    alignment: Alignment,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
 
+    const address_space = target_util.defaultAddressSpace(zcu.getTarget(), .local);
+    const ptr_type = try pt.ptrType(.{
+        .child = operand_ty.toIntern(),
+        .flags = .{
+            .alignment = alignment,
+            .is_const = true,
+            .address_space = address_space,
+        },
+    });
+
     if (sema.resolveValue(operand)) |val| {
         switch (zcu.intern_pool.indexToKey(val.toIntern())) {
             .@"extern" => |e| return sema.analyzeNavRef(block, src, e.owner_nav),
             .func => |f| return sema.analyzeNavRef(block, src, f.owner_nav),
-            else => return uavRef(sema, val),
+            else => return .fromIntern(try pt.intern(.{ .ptr = .{
+                .ty = ptr_type.toIntern(),
+                .base_addr = .{ .uav = .{
+                    .val = val.toIntern(),
+                    .orig_ty = ptr_type.toIntern(),
+                } },
+                .byte_offset = 0,
+            } })),
         }
     }
 
     // No `requireRuntimeBlock`; it's okay to `ref` to a runtime value in a comptime context,
     // it's just that we can only use the *type* of the result, since the value is runtime-known.
 
-    const address_space = target_util.defaultAddressSpace(zcu.getTarget(), .local);
-    const ptr_type = try pt.ptrType(.{
-        .child = operand_ty.toIntern(),
-        .flags = .{
-            .is_const = true,
-            .address_space = address_space,
-        },
-    });
     const mut_ptr_type = try pt.ptrType(.{
         .child = operand_ty.toIntern(),
-        .flags = .{ .address_space = address_space },
+        .flags = .{
+            .alignment = alignment,
+            .is_const = false,
+            .address_space = address_space,
+        },
     });
     const alloc = try block.addTy(.alloc, mut_ptr_type);
 
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 717d5b8b96e34893007f4f9e80fd100c3ce7b241..8009838a8837025a3895e90207dd95cc922559a1 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -147,7 +147,7 @@ pub fn ensureStructDefaultsResolved(sema: *Sema, ty: Type, src: LazySrcLoc) Sema
     const ip = &zcu.intern_pool;
 
     assert(ip.indexToKey(ty.toIntern()) == .struct_type);
-    if (zcu.comp.config.incremental) assert(sema.dependencies.contains(.{ .type_layout = ty.toIntern() }));
+    ty.assertHasLayout(zcu);
 
     try sema.declareDependency(.{ .struct_defaults = ty.toIntern() });
     try sema.addReferenceEntry(null, src, .wrap(.{ .struct_defaults = ty.toIntern() }));
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 8a786edb4903b031464efdadf108966bd8f63af0..bf45502faceaabe69c5fc10a3d4aa020224c0276 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -4112,7 +4112,27 @@ pub fn enumValueFieldIndex(pt: Zcu.PerThread, ty: Type, field_index: u32) Alloca
 
 pub fn undefValue(pt: Zcu.PerThread, ty: Type) Allocator.Error!Value {
     if (std.debug.runtime_safety) {
-        assert(ty.classify(pt.zcu) != .one_possible_value);
+        // TODO: values of type `struct { comptime x: u8 = undefined }` are currently represented as
+        // undef. This is wrong: they should really be represented as empty aggregates instead,
+        // because `comptime` fields shouldn't factor into that decision! This is implemented
+        // through logic in `aggregateValue` and requires this weird workaround in what ought to be
+        // a straightforward assertion:
+        //assert(ty.classify(pt.zcu) != .one_possible_value);
+        if (ty.classify(pt.zcu) == .one_possible_value) {
+            const ip = &pt.zcu.intern_pool;
+            switch (ip.indexToKey(ty.toIntern())) {
+                else => unreachable, // assertion failure
+                .struct_type => {
+                    const comptime_bits = ip.loadStructType(ty.toIntern()).field_is_comptime_bits.getAll(ip);
+                    for (comptime_bits) |bag| {
+                        if (@popCount(bag) > 0) break;
+                    } else unreachable; // assertion failure
+                },
+                .tuple_type => |tuple| for (tuple.values.get(ip)) |val| {
+                    if (val != .none) break;
+                } else unreachable, // assertion failure
+            }
+        }
     }
     return .fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
 }
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index 34a7f99ce4f30d39e8dd4caf710390816abf220f..71cd46be02740ea78411ff0f8bed98d92ed7ef3d 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -689,7 +689,7 @@ fn constInt(cg: *CodeGen, ty: Type, value: anytype) !Id {
         .comptime_int => if (value < 0) .signed else .unsigned,
         else => unreachable,
     };
-    if (@sizeOf(@TypeOf(value)) >= 4 and big_int) {
+    if (@TypeOf(value) != comptime_int and @sizeOf(@TypeOf(value)) >= 4 and big_int) {
         const value64: u64 = switch (signedness) {
             .signed => @bitCast(@as(i64, @intCast(value))),
             .unsigned => @as(u64, @intCast(value)),
diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index f46f87ccff5846df798fc470fbb97e06c3cd59e7..7bd81c13ffeb499bfd44209daee0204bd08f4865 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -181111,7 +181111,7 @@ fn resolveCallingConventionValues(
                 var ret_sse = abi.getCAbiSseReturnRegs(cc);
                 var ret_x87 = abi.getCAbiX87ReturnRegs(cc);
 
-                const classes = switch (cc) {
+                const classes: []const abi.Class = switch (cc) {
                     .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, cg.target, .ret), .none),
                     .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu, cg.target, .ret)},
                     else => unreachable,
-- 
2.54.0


From 0a246f5e67118328a11df51cd6dfa419793ebeb1 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 28 Feb 2026 10:10:15 +0000
Subject: [PATCH 470/499] compiler: stop LLVM bossing the frontend around

I previously wrote some weird code in the compiler frontend solely
because the LLVM backend has some weird requirements, but the better
solution is to avoid those requirements. This commit does that by
introducing "alignment forward references" to `std.zig.llvm.Builder`.
Much like debug forward references, they allow you to reference an
alignment value which will be populated at a later time (and which can
be updated many times, which is important for incremental compilation).
Then, when we want to reference a type's ABI alignment while the type is
not necessarily resolved (required for `@"align"` attributes on function
parameters and function call arguments), we create a forward reference
and use `link.ConstPool` to populate it when ready.

This allows us to remove from the compiler frontend some extremely
arbitrary calls to `Sema.ensureLayoutResolved`, so that the language
specification is not being built around the particular needs of our
compiler implementation's LLVM code generation backend.
---
 lib/std/zig/llvm/Builder.zig | 217 ++++++++++++++++++++++-------------
 src/Sema.zig                 |  15 ---
 src/Zcu/PerThread.zig        |  14 ---
 src/codegen/llvm.zig         | 154 ++++++++++++++++---------
 4 files changed, 237 insertions(+), 163 deletions(-)

diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index f40b63c85fdb0536b7b75cc9915de558d0f105fb..5001a0c375a55f2c49a26e5f697086d65f34c2dd 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -7,6 +7,7 @@ const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const DW = std.dwarf;
 const log = std.log.scoped(.llvm);
+const maxInt = std.math.maxInt;
 const Writer = std.Io.Writer;
 
 const bitcode_writer = @import("bitcode_writer.zig");
@@ -55,6 +56,8 @@ constant_items: std.MultiArrayList(Constant.Item),
 constant_extra: std.ArrayList(u32),
 constant_limbs: std.ArrayList(std.math.big.Limb),
 
+alignment_forward_references: std.ArrayList(Alignment),
+
 metadata_map: std.AutoArrayHashMapUnmanaged(void, void),
 metadata_items: std.MultiArrayList(Metadata.Item),
 metadata_extra: std.ArrayList(u32),
@@ -85,7 +88,7 @@ pub const Options = struct {
 };
 
 pub const String = enum(u32) {
-    none = std.math.maxInt(u31),
+    none = maxInt(u31),
     empty,
     _,
 
@@ -245,7 +248,7 @@ pub const Type = enum(u32) {
     ptr,
     @"ptr addrspace(4)",
 
-    none = std.math.maxInt(u32),
+    none = maxInt(u32),
     _,
 
     pub const ptr_amdgpu_constant =
@@ -941,7 +944,7 @@ pub const Attribute = union(Kind) {
     inalloca: Type,
     sret: Type,
     elementtype: Type,
-    @"align": Alignment,
+    @"align": Alignment.Lazy,
     @"noalias",
     nocapture,
     nofree,
@@ -956,7 +959,7 @@ pub const Attribute = union(Kind) {
     immarg,
     noundef,
     nofpclass: FpClass,
-    alignstack: Alignment,
+    alignstack: Alignment.Lazy,
     allocalign,
     allocptr,
     readnone,
@@ -964,7 +967,7 @@ pub const Attribute = union(Kind) {
     writeonly,
 
     // Function Attributes
-    //alignstack: Alignment,
+    //alignstack: Alignment.Lazy,
     allockind: AllocKind,
     allocsize: AllocSize,
     alwaysinline,
@@ -1145,7 +1148,7 @@ pub const Attribute = union(Kind) {
                     return @unionInit(Attribute, field.name, switch (field.type) {
                         void => {},
                         u32 => storage.value,
-                        Alignment, String, Type, UwTable => @enumFromInt(storage.value),
+                        Alignment.Lazy, String, Type, UwTable => @enumFromInt(storage.value),
                         AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(storage.value),
                         else => @compileError("bad payload type: " ++ field.name ++ ": " ++
                             @typeName(field.type)),
@@ -1246,7 +1249,7 @@ pub const Attribute = union(Kind) {
                 .sret,
                 .elementtype,
                 => |ty| try w.print(" {s}({f})", .{ @tagName(attribute), ty.fmt(data.builder, .percent) }),
-                .@"align" => |alignment| try w.print("{f}", .{alignment.fmt(" ")}),
+                .@"align" => |alignment| try w.print("{f}", .{alignment.resolve(data.builder).fmt(" ")}),
                 .dereferenceable,
                 .dereferenceable_or_null,
                 => |size| try w.print(" {s}({d})", .{ @tagName(attribute), size }),
@@ -1270,7 +1273,7 @@ pub const Attribute = union(Kind) {
                 },
                 .alignstack => |alignment| {
                     try w.print(" {t}", .{attribute});
-                    const alignment_bytes = alignment.toByteUnits() orelse return;
+                    const alignment_bytes = alignment.resolve(data.builder).toByteUnits() orelse return;
                     if (data.flags.pound) {
                         try w.print("={d}", .{alignment_bytes});
                     } else {
@@ -1435,8 +1438,8 @@ pub const Attribute = union(Kind) {
         //sanitize_memtag,
         sanitize_address_dyninit = 102,
 
-        string = std.math.maxInt(u31),
-        none = std.math.maxInt(u32),
+        string = maxInt(u31),
+        none = maxInt(u32),
         _,
 
         pub const len = @typeInfo(Kind).@"enum".fields.len - 2;
@@ -1516,12 +1519,12 @@ pub const Attribute = union(Kind) {
         elem_size: u16,
         num_elems: u16,
 
-        pub const none = std.math.maxInt(u16);
+        pub const none = maxInt(u16);
 
         fn toLlvm(self: AllocSize) packed struct(u64) { num_elems: u32, elem_size: u32 } {
             return .{ .num_elems = switch (self.num_elems) {
                 else => self.num_elems,
-                none => std.math.maxInt(u32),
+                none => maxInt(u32),
             }, .elem_size = self.elem_size };
         }
     };
@@ -1577,7 +1580,7 @@ pub const Attribute = union(Kind) {
             inline else => |value, tag| .{ .kind = @as(Kind, self), .value = switch (@TypeOf(value)) {
                 void => 0,
                 u32 => value,
-                Alignment, String, Type, UwTable => @intFromEnum(value),
+                Alignment.Lazy, String, Type, UwTable => @intFromEnum(value),
                 AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(value),
                 else => @compileError("bad payload type: " ++ @tagName(tag) ++ @typeName(@TypeOf(value))),
             } },
@@ -2017,9 +2020,32 @@ pub const ExternallyInitialized = enum {
 };
 
 pub const Alignment = enum(u6) {
-    default = std.math.maxInt(u6),
+    default = maxInt(u6),
     _,
 
+    pub const Lazy = enum(u32) {
+        /// Values which fit in a `u6` are already-resolved `Alignment` values. Other values are
+        /// indices into `Builder.alignment_forward_references`, offset by `maxInt(u6)`.
+        _,
+
+        pub fn wrap(a: Alignment) Lazy {
+            return @enumFromInt(@intFromEnum(a));
+        }
+        pub fn resolve(l: Lazy, b: *const Builder) Alignment {
+            return switch (@intFromEnum(l)) {
+                0...maxInt(u6) => |raw| @enumFromInt(raw),
+                else => |offset_index| b.alignment_forward_references.items[offset_index - maxInt(u6)],
+            };
+        }
+
+        fn fromFwdRefIndex(index: usize) Lazy {
+            return @enumFromInt(index + maxInt(u6));
+        }
+        fn toFwdRefIndex(l: Lazy) usize {
+            return @intFromEnum(l) - maxInt(u6);
+        }
+    };
+
     pub fn fromByteUnits(bytes: u64) Alignment {
         if (bytes == 0) return .default;
         assert(std.math.isPowerOfTwo(bytes));
@@ -2028,11 +2054,17 @@ pub const Alignment = enum(u6) {
     }
 
     pub fn toByteUnits(self: Alignment) ?u64 {
-        return if (self == .default) null else @as(u64, 1) << @intFromEnum(self);
+        return switch (self) {
+            .default => null,
+            else => @as(u64, 1) << @intFromEnum(self),
+        };
     }
 
     pub fn toLlvm(self: Alignment) u6 {
-        return if (self == .default) 0 else (@intFromEnum(self) + 1);
+        return switch (self) {
+            .default => 0,
+            else => @intFromEnum(self) + 1,
+        };
     }
 
     pub const Prefixed = struct {
@@ -2180,7 +2212,7 @@ pub const CallConv = enum(u10) {
 };
 
 pub const StrtabString = enum(u32) {
-    none = std.math.maxInt(u31),
+    none = maxInt(u31),
     empty,
     _,
 
@@ -2308,7 +2340,7 @@ pub const Global = struct {
     },
 
     pub const Index = enum(u32) {
-        none = std.math.maxInt(u32),
+        none = maxInt(u32),
         _,
 
         pub fn unwrap(self: Index, builder: *const Builder) Index {
@@ -2478,7 +2510,7 @@ pub const Alias = struct {
     aliasee: Constant = .no_init,
 
     pub const Index = enum(u32) {
-        none = std.math.maxInt(u32),
+        none = maxInt(u32),
         _,
 
         pub fn ptr(self: Index, builder: *Builder) *Alias {
@@ -2530,7 +2562,7 @@ pub const Variable = struct {
     alignment: Alignment = .default,
 
     pub const Index = enum(u32) {
-        none = std.math.maxInt(u32),
+        none = maxInt(u32),
         _,
 
         pub fn ptr(self: Index, builder: *Builder) *Variable {
@@ -3949,7 +3981,7 @@ pub const Intrinsic = enum {
             .params = &.{
                 .{
                     .kind = .{ .type = Type.ptr_amdgpu_constant },
-                    .attrs = &.{.{ .@"align" = Builder.Alignment.fromByteUnits(4) }},
+                    .attrs = &.{.{ .@"align" = .wrap(.fromByteUnits(4)) }},
                 },
             },
             .attrs = &.{ .nocallback, .nofree, .nosync, .nounwind, .speculatable, .willreturn, .{ .memory = Attribute.Memory.all(.none) } },
@@ -4057,7 +4089,7 @@ pub const Function = struct {
     extra: []const u32 = &.{},
 
     pub const Index = enum(u32) {
-        none = std.math.maxInt(u32),
+        none = maxInt(u32),
         _,
 
         pub fn ptr(self: Index, builder: *Builder) *Function {
@@ -4411,7 +4443,7 @@ pub const Function = struct {
         };
 
         pub const Index = enum(u32) {
-            none = std.math.maxInt(u31),
+            none = maxInt(u31),
             _,
 
             pub fn name(self: Instruction.Index, function: *const Function) String {
@@ -5007,7 +5039,7 @@ pub const Function = struct {
                 fsub = 12,
                 fmax = 13,
                 fmin = 14,
-                none = std.math.maxInt(u5),
+                none = maxInt(u5),
             };
         };
 
@@ -6132,8 +6164,8 @@ pub const WipFunction = struct {
         kind: MemoryAccessKind,
         @"inline": bool,
     ) Allocator.Error!Instruction.Index {
-        var dst_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = dst_align })};
-        var src_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = src_align })};
+        var dst_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = .wrap(dst_align) })};
+        var src_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = .wrap(src_align) })};
         const value = try self.callIntrinsic(
             .normal,
             try self.builder.fnAttrs(&.{
@@ -6162,8 +6194,8 @@ pub const WipFunction = struct {
         len: Value,
         kind: MemoryAccessKind,
     ) Allocator.Error!Instruction.Index {
-        var dst_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = dst_align })};
-        var src_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = src_align })};
+        var dst_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = .wrap(dst_align) })};
+        var src_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = .wrap(src_align) })};
         const value = try self.callIntrinsic(
             .normal,
             try self.builder.fnAttrs(&.{
@@ -6192,7 +6224,7 @@ pub const WipFunction = struct {
         kind: MemoryAccessKind,
         @"inline": bool,
     ) Allocator.Error!Instruction.Index {
-        var dst_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = dst_align })};
+        var dst_attrs = [_]Attribute.Index{try self.builder.attr(.{ .@"align" = .wrap(dst_align) })};
         const value = try self.callIntrinsic(
             .normal,
             try self.builder.fnAttrs(&.{ .none, .none, try self.builder.attrs(&dst_attrs) }),
@@ -7329,7 +7361,7 @@ pub const Constant = enum(u32) {
         //indices: [info.indices_len]Constant,
 
         pub const Kind = enum { normal, inbounds };
-        pub const InRangeIndex = enum(u16) { none = std.math.maxInt(u16), _ };
+        pub const InRangeIndex = enum(u16) { none = maxInt(u16), _ };
         pub const Info = packed struct(u32) { indices_len: u16, inrange: InRangeIndex };
     };
 
@@ -7579,7 +7611,7 @@ pub const Constant = enum(u32) {
                             string: [
                                 (std.math.big.int.Const{
                                     .limbs = &([1]std.math.big.Limb{
-                                        std.math.maxInt(std.math.big.Limb),
+                                        maxInt(std.math.big.Limb),
                                     } ** expected_limbs),
                                     .positive = false,
                                 }).sizeInBaseUpperBound(10)
@@ -7643,7 +7675,7 @@ pub const Constant = enum(u32) {
                                     std.math.minInt(Exponent64),
                                 else => @as(Exponent64, repr.exponent) +
                                     (std.math.floatExponentMax(f64) - std.math.floatExponentMax(f32)),
-                                std.math.maxInt(Exponent32) => std.math.maxInt(Exponent64),
+                                maxInt(Exponent32) => maxInt(Exponent64),
                             },
                             .sign = repr.sign,
                         }))});
@@ -7820,7 +7852,7 @@ pub const Constant = enum(u32) {
 };
 
 pub const Value = enum(u32) {
-    none = std.math.maxInt(u31),
+    none = maxInt(u31),
     false = first_constant + @intFromEnum(Constant.false),
     true = first_constant + @intFromEnum(Constant.true),
     @"0" = first_constant + @intFromEnum(Constant.@"0"),
@@ -8688,6 +8720,8 @@ pub fn init(options: Options) Allocator.Error!Builder {
         .constant_extra = .empty,
         .constant_limbs = .empty,
 
+        .alignment_forward_references = .empty,
+
         .metadata_map = .empty,
         .metadata_items = .empty,
         .metadata_extra = .empty,
@@ -8800,51 +8834,55 @@ pub fn clearAndFree(self: *Builder) void {
 }
 
 pub fn deinit(self: *Builder) void {
-    self.module_asm.deinit(self.gpa);
-
-    self.string_map.deinit(self.gpa);
-    self.string_indices.deinit(self.gpa);
-    self.string_bytes.deinit(self.gpa);
-
-    self.types.deinit(self.gpa);
-    self.next_unique_type_id.deinit(self.gpa);
-    self.type_map.deinit(self.gpa);
-    self.type_items.deinit(self.gpa);
-    self.type_extra.deinit(self.gpa);
-
-    self.attributes.deinit(self.gpa);
-    self.attributes_map.deinit(self.gpa);
-    self.attributes_indices.deinit(self.gpa);
-    self.attributes_extra.deinit(self.gpa);
-
-    self.function_attributes_set.deinit(self.gpa);
-
-    self.globals.deinit(self.gpa);
-    self.next_unique_global_id.deinit(self.gpa);
-    self.aliases.deinit(self.gpa);
-    self.variables.deinit(self.gpa);
-    for (self.functions.items) |*function| function.deinit(self.gpa);
-    self.functions.deinit(self.gpa);
-
-    self.strtab_string_map.deinit(self.gpa);
-    self.strtab_string_indices.deinit(self.gpa);
-    self.strtab_string_bytes.deinit(self.gpa);
-
-    self.constant_map.deinit(self.gpa);
-    self.constant_items.deinit(self.gpa);
-    self.constant_extra.deinit(self.gpa);
-    self.constant_limbs.deinit(self.gpa);
-
-    self.metadata_map.deinit(self.gpa);
-    self.metadata_items.deinit(self.gpa);
-    self.metadata_extra.deinit(self.gpa);
-    self.metadata_limbs.deinit(self.gpa);
-    self.metadata_forward_references.deinit(self.gpa);
-    self.metadata_named.deinit(self.gpa);
-
-    self.metadata_string_map.deinit(self.gpa);
-    self.metadata_string_indices.deinit(self.gpa);
-    self.metadata_string_bytes.deinit(self.gpa);
+    const gpa = self.gpa;
+
+    self.module_asm.deinit(gpa);
+
+    self.string_map.deinit(gpa);
+    self.string_indices.deinit(gpa);
+    self.string_bytes.deinit(gpa);
+
+    self.types.deinit(gpa);
+    self.next_unique_type_id.deinit(gpa);
+    self.type_map.deinit(gpa);
+    self.type_items.deinit(gpa);
+    self.type_extra.deinit(gpa);
+
+    self.attributes.deinit(gpa);
+    self.attributes_map.deinit(gpa);
+    self.attributes_indices.deinit(gpa);
+    self.attributes_extra.deinit(gpa);
+
+    self.function_attributes_set.deinit(gpa);
+
+    self.globals.deinit(gpa);
+    self.next_unique_global_id.deinit(gpa);
+    self.aliases.deinit(gpa);
+    self.variables.deinit(gpa);
+    for (self.functions.items) |*function| function.deinit(gpa);
+    self.functions.deinit(gpa);
+
+    self.strtab_string_map.deinit(gpa);
+    self.strtab_string_indices.deinit(gpa);
+    self.strtab_string_bytes.deinit(gpa);
+
+    self.constant_map.deinit(gpa);
+    self.constant_items.deinit(gpa);
+    self.constant_extra.deinit(gpa);
+    self.constant_limbs.deinit(gpa);
+
+    self.alignment_forward_references.deinit(gpa);
+
+    self.metadata_map.deinit(gpa);
+    self.metadata_items.deinit(gpa);
+    self.metadata_extra.deinit(gpa);
+    self.metadata_limbs.deinit(gpa);
+    self.metadata_forward_references.deinit(gpa);
+    self.metadata_named.deinit(gpa);
+
+    self.metadata_string_map.deinit(gpa);
+    self.metadata_string_indices.deinit(gpa);
+    self.metadata_string_bytes.deinit(gpa);
 
     self.* = undefined;
 }
@@ -8962,7 +9000,7 @@ pub fn structType(
 pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
     try self.string_map.ensureUnusedCapacity(self.gpa, 1);
     if (name.slice(self)) |id| {
-        const count: usize = comptime std.fmt.count("{d}", .{std.math.maxInt(u32)});
+        const count: usize = comptime std.fmt.count("{d}", .{maxInt(u32)});
         try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len + count);
     }
     try self.string_indices.ensureUnusedCapacity(self.gpa, 1);
@@ -9578,6 +9616,21 @@ pub fn asmValue(
     return (try self.asmConst(ty, info, assembly, constraints)).toValue();
 }
 
+/// The initial "resolved" value of the forward reference is `Alignment.default`.
+pub fn alignmentForwardReference(b: *Builder) Allocator.Error!Alignment.Lazy {
+    const index = b.alignment_forward_references.items.len;
+    try b.alignment_forward_references.append(b.gpa, .default);
+    return .fromFwdRefIndex(index);
+}
+
+/// Updates the "resolved" value of the alignment forward reference `fwd_ref` to `value`.
+///
+/// Asserts that `fwd_ref` is a forward reference, as opposed to a resolved alignment value.
+pub fn resolveAlignmentForwardReference(b: *Builder, fwd_ref: Alignment.Lazy, value: Alignment) void {
+    const index = fwd_ref.toFwdRefIndex();
+    b.alignment_forward_references.items[index] = value;
+}
+
 pub fn dump(b: *Builder, io: Io) void {
     var buffer: [4000]u8 = undefined;
     const stderr: Io.File = .stderr();
@@ -10515,7 +10568,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                         string: [
                             (std.math.big.int.Const{
                                 .limbs = &([1]std.math.big.Limb{
-                                    std.math.maxInt(std.math.big.Limb),
+                                    maxInt(std.math.big.Limb),
                                 } ** expected_limbs),
                                 .positive = false,
                             }).sizeInBaseUpperBound(10)
@@ -10665,7 +10718,7 @@ fn printEscapedString(slice: []const u8, quotes: QuoteBehavior, w: *Writer) Writ
 fn ensureUnusedGlobalCapacity(self: *Builder, name: StrtabString) Allocator.Error!void {
     try self.strtab_string_map.ensureUnusedCapacity(self.gpa, 1);
     if (name.slice(self)) |id| {
-        const count: usize = comptime std.fmt.count("{d}", .{std.math.maxInt(u32)});
+        const count: usize = comptime std.fmt.count("{d}", .{maxInt(u32)});
         try self.strtab_string_bytes.ensureUnusedCapacity(self.gpa, id.len + count);
     }
     try self.strtab_string_indices.ensureUnusedCapacity(self.gpa, 1);
@@ -13518,7 +13571,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                                 try record.ensureUnusedCapacity(self.gpa, 3);
                                 record.appendAssumeCapacity(1);
                                 record.appendAssumeCapacity(@intFromEnum(kind));
-                                record.appendAssumeCapacity(alignment.toByteUnits() orelse 0);
+                                record.appendAssumeCapacity(alignment.resolve(self).toByteUnits() orelse 0);
                             },
                             .dereferenceable,
                             .dereferenceable_or_null,
diff --git a/src/Sema.zig b/src/Sema.zig
index 02c2efd2ee7f27c1312ed8d04ed808debeca71f1..9e3024b7eda20650eb9bbf1978658a3061d5c742 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7110,12 +7110,7 @@ fn analyzeCall(
         }
         for (args, 0..) |arg, arg_idx| {
             const arg_src = args_info.argSrc(block, arg_idx);
-            const arg_ty = sema.typeOf(arg);
             try sema.validateRuntimeValue(block, arg_src, arg);
-            if (arg_ty.isPtrAtRuntime(zcu) or arg_ty.isSliceAtRuntime(zcu)) {
-                // LLVM wants this information for an "align" attribute on the argument.
-                try sema.ensureLayoutResolved(arg_ty.nullablePtrElem(zcu), arg_src, .init);
-            }
         }
         const runtime_func: Air.Inst.Ref, const runtime_args: []const Air.Inst.Ref = func: {
             if (!any_generic_types and !any_comptime_params) break :func .{ callee, args };
@@ -24779,16 +24774,6 @@ fn zirBuiltinExtern(
     }
     const ptr_info = ty.ptrInfo(zcu);
 
-    if (Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .@"fn") {
-        const func_type = ip.indexToKey(ptr_info.child).func_type;
-        for (func_type.param_types.get(ip)) |param_ty_ip| {
-            const param_ty: Type = .fromInterned(param_ty_ip);
-            if (param_ty.isPtrAtRuntime(zcu) or param_ty.isSliceAtRuntime(zcu)) {
-                // LLVM wants this information for an "align" attribute on the parameter.
-                try sema.ensureLayoutResolved(param_ty.nullablePtrElem(zcu), ty_src, .parameter);
-            }
-        }
-    }
     const extern_val = try pt.getExtern(.{
         .name = options.name,
         .ty = ptr_info.child,
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index bf45502faceaabe69c5fc10a3d4aa020224c0276..9fde840232d2ec4d598ef192a6379bb86138af5b 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -1832,16 +1832,6 @@ fn analyzeNavVal(
                 const lib_name_src = block.src(.{ .node_offset_lib_name = .zero });
                 try sema.handleExternLibName(&block, lib_name_src, l);
             }
-            if (nav_ty.zigTypeTag(zcu) == .@"fn") {
-                const func_type = ip.indexToKey(nav_ty.toIntern()).func_type;
-                for (func_type.param_types.get(ip)) |param_ty_ip| {
-                    const param_ty: Type = .fromInterned(param_ty_ip);
-                    if (param_ty.isPtrAtRuntime(zcu) or param_ty.isSliceAtRuntime(zcu)) {
-                        // LLVM wants this information for an "align" attribute on the parameter.
-                        try sema.ensureLayoutResolved(param_ty.nullablePtrElem(zcu), ty_src, .parameter);
-                    }
-                }
-            }
             break :val .fromInterned(try pt.getExtern(.{
                 .name = old_nav.name,
                 .ty = nav_ty.toIntern(),
@@ -3398,10 +3388,6 @@ fn analyzeFuncBodyInner(
         const param_ty_src = inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) });
 
         try sema.ensureLayoutResolved(param_ty, param_ty_src, .parameter);
-        if (param_ty.isPtrAtRuntime(zcu) or param_ty.isSliceAtRuntime(zcu)) {
-            // LLVM wants this information for an "align" attribute on the parameter.
-            try sema.ensureLayoutResolved(param_ty.nullablePtrElem(zcu), param_ty_src, .parameter);
-        }
         if (try param_ty.onePossibleValue(pt)) |opv| {
             gop.value_ptr.* = .fromValue(opv);
             continue;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 972a536eef0989e5c8f3055a4635f1e0397d32ba..009e472d06f4229c067d4e96f0dee78bc0f22aa3 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -520,6 +520,21 @@ pub const Object = struct {
     gpa: Allocator,
     builder: Builder,
 
+    /// This pool contains only types (and not `@as(type, undefined)`). It has two purposes:
+    ///
+    /// * Lazily tracking ABI alignment of types, so that `@"align"` attributes can be set to a
+    ///   type's ABI alignment before that type is fully resolved. Each type in the pool has a
+    ///   corresponding entry in `lazy_abi_aligns`.
+    ///
+    /// * If `!Object.builder.strip`, lazily tracking debug information types, so that debug
+    ///   information can handle indirect self-reference (and so that debug information works
+    ///   correctly across incremental updates). Each type has a corresponding entry in
+    ///   `debug_types`, provided that `Object.builder.strip` is `false`.
+    type_pool: link.ConstPool,
+
+    /// Keyed on `link.ConstPool.Index`.
+    lazy_abi_aligns: std.ArrayList(Builder.Alignment.Lazy),
+
     debug_compile_unit: Builder.Metadata.Optional,
 
     debug_enums_fwd_ref: Builder.Metadata.Optional,
@@ -530,8 +545,6 @@ pub const Object = struct {
 
     debug_file_map: std.AutoHashMapUnmanaged(Zcu.File.Index, Builder.Metadata),
 
-    /// This pool *only* contains types (and does not contain `@as(type, undefined)`).
-    debug_type_pool: link.ConstPool,
     /// Keyed on `link.ConstPool.Index`.
     debug_types: std.ArrayList(Builder.Metadata),
     /// Initially `.none`, set if the type `anyerror` is lowered to a debug type. The type will not
@@ -660,13 +673,14 @@ pub const Object = struct {
         obj.* = .{
             .gpa = gpa,
             .builder = builder,
+            .type_pool = .empty,
+            .lazy_abi_aligns = .empty,
             .debug_compile_unit = debug_compile_unit,
             .debug_enums_fwd_ref = debug_enums_fwd_ref,
             .debug_globals_fwd_ref = debug_globals_fwd_ref,
             .debug_enums = .empty,
             .debug_globals = .empty,
             .debug_file_map = .empty,
-            .debug_type_pool = .empty,
             .debug_types = .empty,
             .debug_anyerror_fwd_ref = .none,
             .target = target,
@@ -685,10 +699,11 @@ pub const Object = struct {
 
     pub fn deinit(self: *Object) void {
         const gpa = self.gpa;
+        self.type_pool.deinit(gpa);
+        self.lazy_abi_aligns.deinit(gpa);
         self.debug_enums.deinit(gpa);
         self.debug_globals.deinit(gpa);
         self.debug_file_map.deinit(gpa);
-        self.debug_type_pool.deinit(gpa);
         self.debug_types.deinit(gpa);
         self.nav_map.deinit(gpa);
         self.uav_map.deinit(gpa);
@@ -836,7 +851,7 @@ pub const Object = struct {
                     o.builder.resolveDebugForwardReference(fwd_ref, debug_anyerror_type);
                 }
 
-                try o.flushPendingDebugTypes(pt);
+                try o.flushTypePool(pt);
 
                 o.builder.resolveDebugForwardReference(
                     o.debug_enums_fwd_ref.unwrap().?,
@@ -1396,10 +1411,10 @@ pub const Object = struct {
                         if (ptr_info.flags.is_const) {
                             try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
                         }
-                        const elem_align = (if (ptr_info.flags.alignment != .none)
-                            @as(InternPool.Alignment, ptr_info.flags.alignment)
-                        else
-                            Type.fromInterned(ptr_info.child).abiAlignment(zcu).max(.@"1")).toLlvm();
+                        const elem_align: Builder.Alignment.Lazy = switch (ptr_info.flags.alignment) {
+                            else => |a| .wrap(a.toLlvm()),
+                            .none => try o.lazyAbiAlignment(pt, .fromInterned(ptr_info.child)),
+                        };
                         try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
                         const ptr_param = wip.arg(llvm_arg_i);
                         llvm_arg_i += 1;
@@ -1600,7 +1615,7 @@ pub const Object = struct {
         }
 
         try fg.wip.finish();
-        try o.flushPendingDebugTypes(pt);
+        try o.flushTypePool(pt);
     }
 
     pub fn updateNav(self: *Object, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void {
@@ -1617,11 +1632,11 @@ pub const Object = struct {
             },
             else => |e| return e,
         };
-        try self.flushPendingDebugTypes(pt);
+        try self.flushTypePool(pt);
     }
 
-    fn flushPendingDebugTypes(o: *Object, pt: Zcu.PerThread) Allocator.Error!void {
-        try o.debug_type_pool.flushPending(pt, .{ .llvm = o });
+    fn flushTypePool(o: *Object, pt: Zcu.PerThread) Allocator.Error!void {
+        try o.type_pool.flushPending(pt, .{ .llvm = o });
     }
 
     pub fn updateExports(
@@ -1818,51 +1833,81 @@ pub const Object = struct {
     }
 
     pub fn updateContainerType(o: *Object, pt: Zcu.PerThread, ty: InternPool.Index, success: bool) Allocator.Error!void {
-        if (!o.builder.strip) {
-            try o.debug_type_pool.updateContainerType(pt, .{ .llvm = o }, ty, success);
-        }
+        try o.type_pool.updateContainerType(pt, .{ .llvm = o }, ty, success);
     }
 
     /// Should only be called by the `link.ConstPool` implementation.
     ///
-    /// `val` is always a type because `o.debug_type_pool` only contains types.
+    /// `val` is always a type because `o.type_pool` only contains types.
     pub fn addConst(o: *Object, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
         const zcu = pt.zcu;
         const gpa = zcu.comp.gpa;
         assert(zcu.intern_pool.typeOf(val) == .type_type);
-        assert(@intFromEnum(index) == o.debug_types.items.len);
-        try o.debug_types.ensureUnusedCapacity(gpa, 1);
-        const fwd_ref = try o.builder.debugForwardReference();
-        o.debug_types.appendAssumeCapacity(fwd_ref);
-        if (val == .anyerror_type) {
-            assert(o.debug_anyerror_fwd_ref.is_none);
-            o.debug_anyerror_fwd_ref = fwd_ref.toOptional();
+
+        {
+            assert(@intFromEnum(index) == o.lazy_abi_aligns.items.len);
+            try o.lazy_abi_aligns.ensureUnusedCapacity(gpa, 1);
+            const fwd_ref = try o.builder.alignmentForwardReference();
+            o.lazy_abi_aligns.appendAssumeCapacity(fwd_ref);
+        }
+
+        if (!o.builder.strip) {
+            assert(@intFromEnum(index) == o.debug_types.items.len);
+            try o.debug_types.ensureUnusedCapacity(gpa, 1);
+            const fwd_ref = try o.builder.debugForwardReference();
+            o.debug_types.appendAssumeCapacity(fwd_ref);
+            if (val == .anyerror_type) {
+                assert(o.debug_anyerror_fwd_ref.is_none);
+                o.debug_anyerror_fwd_ref = fwd_ref.toOptional();
+            }
         }
     }
     /// Should only be called by the `link.ConstPool` implementation.
     ///
-    /// `val` is always a type because `o.debug_type_pool` only contains types.
+    /// `val` is always a type because `o.type_pool` only contains types.
     pub fn updateConstIncomplete(o: *Object, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
-        assert(pt.zcu.intern_pool.typeOf(val) == .type_type);
-        const fwd_ref = o.debug_types.items[@intFromEnum(index)];
-        assert(val != .anyerror_type);
-        const name_str = try o.builder.metadataStringFmt("{f}", .{Type.fromInterned(val).fmt(pt)});
-        const debug_incomplete_type = try o.builder.debugSignedType(name_str, 0);
-        o.builder.resolveDebugForwardReference(fwd_ref, debug_incomplete_type);
+        const zcu = pt.zcu;
+        assert(zcu.intern_pool.typeOf(val) == .type_type);
+
+        const ty: Type = .fromInterned(val);
+
+        {
+            const fwd_ref = o.lazy_abi_aligns.items[@intFromEnum(index)];
+            o.builder.resolveAlignmentForwardReference(fwd_ref, .fromByteUnits(1));
+        }
+
+        if (!o.builder.strip) {
+            assert(val != .anyerror_type);
+            const fwd_ref = o.debug_types.items[@intFromEnum(index)];
+            const name_str = try o.builder.metadataStringFmt("{f}", .{ty.fmt(pt)});
+            const debug_incomplete_type = try o.builder.debugSignedType(name_str, 0);
+            o.builder.resolveDebugForwardReference(fwd_ref, debug_incomplete_type);
+        }
     }
     /// Should only be called by the `link.ConstPool` implementation.
     ///
-    /// `val` is always a type because `o.debug_type_pool` only contains types.
+    /// `val` is always a type because `o.type_pool` only contains types.
     pub fn updateConst(o: *Object, pt: Zcu.PerThread, index: link.ConstPool.Index, val: InternPool.Index) Allocator.Error!void {
-        assert(pt.zcu.intern_pool.typeOf(val) == .type_type);
-        const fwd_ref = o.debug_types.items[@intFromEnum(index)];
-        if (val == .anyerror_type) {
-            // Don't lower this now; it will be populated in `emit` instead.
-            assert(o.debug_anyerror_fwd_ref == fwd_ref.toOptional());
-            return;
+        const zcu = pt.zcu;
+        assert(zcu.intern_pool.typeOf(val) == .type_type);
+
+        const ty: Type = .fromInterned(val);
+
+        {
+            const fwd_ref = o.lazy_abi_aligns.items[@intFromEnum(index)];
+            o.builder.resolveAlignmentForwardReference(fwd_ref, ty.abiAlignment(zcu).toLlvm());
+        }
+
+        if (!o.builder.strip) {
+            const fwd_ref = o.debug_types.items[@intFromEnum(index)];
+            if (val == .anyerror_type) {
+                // Don't lower this now; it will be populated in `emit` instead.
+                assert(o.debug_anyerror_fwd_ref == fwd_ref.toOptional());
+            } else {
+                const debug_type = try o.lowerDebugType(pt, ty, fwd_ref);
+                o.builder.resolveDebugForwardReference(fwd_ref, debug_type);
+            }
         }
-        const debug_type = try o.lowerDebugType(pt, .fromInterned(val), fwd_ref);
-        o.builder.resolveDebugForwardReference(fwd_ref, debug_type);
     }
 
     fn getDebugFile(o: *Object, pt: Zcu.PerThread, file_index: Zcu.File.Index) Allocator.Error!Builder.Metadata {
@@ -1883,7 +1928,7 @@ pub const Object = struct {
 
     fn getDebugType(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error!Builder.Metadata {
         assert(!o.builder.strip);
-        const index = try o.debug_type_pool.get(pt, .{ .llvm = o }, ty.toIntern());
+        const index = try o.type_pool.get(pt, .{ .llvm = o }, ty.toIntern());
         return o.debug_types.items[@intFromEnum(index)];
     }
 
@@ -2680,7 +2725,7 @@ pub const Object = struct {
             function_index.setCallConv(cc_info.llvm_cc, &o.builder);
 
             if (cc_info.align_stack) {
-                try attributes.addFnAttr(.{ .alignstack = .fromByteUnits(target.stackAlignment()) }, &o.builder);
+                try attributes.addFnAttr(.{ .alignstack = .wrap(.fromByteUnits(target.stackAlignment())) }, &o.builder);
             } else {
                 _ = try attributes.removeFnAttr(.alignstack);
             }
@@ -4166,11 +4211,11 @@ pub const Object = struct {
             if (ptr_info.flags.is_const) {
                 try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
             }
-            const elem_align = if (ptr_info.flags.alignment != .none)
-                ptr_info.flags.alignment
-            else
-                Type.fromInterned(ptr_info.child).abiAlignment(zcu).max(.@"1");
-            try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align.toLlvm() }, &o.builder);
+            const elem_align: Builder.Alignment.Lazy = switch (ptr_info.flags.alignment) {
+                else => |a| .wrap(a.toLlvm()),
+                .none => try o.lazyAbiAlignment(pt, .fromInterned(ptr_info.child)),
+            };
+            try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
         } else if (ccAbiPromoteInt(fn_info.cc, zcu, param_ty)) |s| switch (s) {
             .signed => try attributes.addParamAttr(llvm_arg_i, .signext, &o.builder),
             .unsigned => try attributes.addParamAttr(llvm_arg_i, .zeroext, &o.builder),
@@ -4187,7 +4232,7 @@ pub const Object = struct {
     ) Allocator.Error!void {
         try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
         try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
-        try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = alignment }, &o.builder);
+        try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = .wrap(alignment) }, &o.builder);
         if (byval) try attributes.addParamAttr(llvm_arg_i, .{ .byval = param_llvm_ty }, &o.builder);
     }
 
@@ -4297,6 +4342,11 @@ pub const Object = struct {
         try wip.finish();
         return function_index;
     }
+
+    fn lazyAbiAlignment(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error!Builder.Alignment.Lazy {
+        const index = try o.type_pool.get(pt, .{ .llvm = o }, ty.toIntern());
+        return o.lazy_abi_aligns.items[@intFromEnum(index)];
+    }
 };
 
 pub const NavGen = struct {
@@ -5259,10 +5309,10 @@ pub const FuncGen = struct {
                     if (ptr_info.flags.is_const) {
                         try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
                     }
-                    const elem_align = (if (ptr_info.flags.alignment != .none)
-                        @as(InternPool.Alignment, ptr_info.flags.alignment)
-                    else
-                        Type.fromInterned(ptr_info.child).abiAlignment(zcu).max(.@"1")).toLlvm();
+                    const elem_align: Builder.Alignment.Lazy = switch (ptr_info.flags.alignment) {
+                        else => |a| .wrap(a.toLlvm()),
+                        .none => try o.lazyAbiAlignment(pt, .fromInterned(ptr_info.child)),
+                    };
                     try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
                 },
             };
-- 
2.54.0


From 978f7fb1ff1cdb36f48b774516aa09ab6a1dfbc0 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 28 Feb 2026 11:40:25 +0000
Subject: [PATCH 471/499] Zcu: improve error message sorting

---
 src/Compilation.zig | 55 ++++++++-------------------------------------
 src/Zcu.zig         | 53 ++++++++++++++++++++++++-------------------
 2 files changed, 39 insertions(+), 69 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index dad807fcbef769a4f92cc38848f2292481866e95..9bf91302d891715a058ee152eecb35e8157b70e6 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -4054,21 +4054,12 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
             const SortOrder = struct {
                 zcu: *Zcu,
                 errors: []const *Zcu.ErrorMsg,
-                read_err: *?ReadError,
-                const ReadError = struct {
-                    file: *Zcu.File,
-                    err: Zcu.File.GetSourceError,
-                };
                 pub fn lessThan(ctx: @This(), lhs_index: usize, rhs_index: usize) bool {
-                    if (ctx.read_err.* != null) return lhs_index < rhs_index;
-                    var bad_file: *Zcu.File = undefined;
-                    return ctx.errors[lhs_index].src_loc.lessThan(ctx.errors[rhs_index].src_loc, ctx.zcu, &bad_file) catch |err| {
-                        ctx.read_err.* = .{
-                            .file = bad_file,
-                            .err = err,
-                        };
-                        return lhs_index < rhs_index;
-                    };
+                    return Zcu.ErrorMsg.order(
+                        ctx.errors[lhs_index],
+                        ctx.errors[rhs_index],
+                        ctx.zcu,
+                    ).compare(.lt);
                 }
             };
 
@@ -4078,16 +4069,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
             var entries = try zcu.failed_analysis.entries.clone(gpa);
             errdefer entries.deinit(gpa);
 
-            var read_err: ?SortOrder.ReadError = null;
             entries.sort(SortOrder{
                 .zcu = zcu,
                 .errors = entries.items(.value),
-                .read_err = &read_err,
             });
-            if (read_err) |e| {
-                try unableToLoadZcuFile(zcu, &bundle, e.file, e.err);
-                break :zcu_errors;
-            }
             break :s entries.slice();
         };
         defer sorted_failed_analysis.deinit(gpa);
@@ -4208,33 +4193,11 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
 
         // Okay, there *are* referenced compile logs. Sort them into a consistent order.
 
-        {
-            const SortContext = struct {
-                zcu: *Zcu,
-                read_err: *?ReadError,
-                const ReadError = struct {
-                    file: *Zcu.File,
-                    err: Zcu.File.GetSourceError,
-                };
-                fn lessThan(ctx: @This(), lhs: Zcu.ErrorMsg, rhs: Zcu.ErrorMsg) bool {
-                    if (ctx.read_err.* != null) return false;
-                    var bad_file: *Zcu.File = undefined;
-                    return lhs.src_loc.lessThan(rhs.src_loc, ctx.zcu, &bad_file) catch |err| {
-                        ctx.read_err.* = .{
-                            .file = bad_file,
-                            .err = err,
-                        };
-                        return false;
-                    };
-                }
-            };
-            var read_err: ?SortContext.ReadError = null;
-            std.mem.sort(Zcu.ErrorMsg, messages.items, @as(SortContext, .{ .read_err = &read_err, .zcu = zcu }), SortContext.lessThan);
-            if (read_err) |e| {
-                try unableToLoadZcuFile(zcu, &bundle, e.file, e.err);
-                break :compile_log_text "";
+        std.mem.sort(Zcu.ErrorMsg, messages.items, zcu, struct {
+            fn lessThan(zcu_inner: *Zcu, lhs: Zcu.ErrorMsg, rhs: Zcu.ErrorMsg) bool {
+                return Zcu.ErrorMsg.order(&lhs, &rhs, zcu_inner).compare(.lt);
             }
-        }
+        }.lessThan);
 
         var log_text: std.ArrayList(u8) = .empty;
         defer log_text.deinit(gpa);
diff --git a/src/Zcu.zig b/src/Zcu.zig
index c623c1ec49f110d79676431c59481e6339613948..eb4b8bdb05be4006f163fe2e48ff5746537a8905 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -1250,6 +1250,15 @@ pub const ErrorMsg = struct {
     notes: []ErrorMsg = &.{},
     reference_trace_root: AnalUnit.Optional = .none,
 
+    pub fn order(lhs: *const ErrorMsg, rhs: *const ErrorMsg, zcu: *Zcu) std.math.Order {
+        return lhs.src_loc.order(rhs.src_loc, zcu).differ() orelse
+            std.mem.order(u8, lhs.msg, rhs.msg).differ() orelse
+            std.math.order(lhs.notes.len, rhs.notes.len).differ() orelse
+            for (lhs.notes, rhs.notes) |*lhs_note, *rhs_note| {
+                if (order(lhs_note, rhs_note, zcu).differ()) |o| break o;
+            } else .eq;
+    }
+
     pub fn create(
         gpa: Allocator,
         src_loc: LazySrcLoc,
@@ -2724,36 +2733,34 @@ pub const LazySrcLoc = struct {
         };
     }
 
-    /// Used to sort error messages, so that they're printed in a consistent order.
-    /// If an error is returned, a file could not be read in order to resolve a source location.
-    /// In that case, `bad_file_out` is populated, and sorting is impossible.
-    pub fn lessThan(lhs_lazy: LazySrcLoc, rhs_lazy: LazySrcLoc, zcu: *Zcu, bad_file_out: **Zcu.File) File.GetSourceError!bool {
-        const lhs_src = lhs_lazy.upgradeOrLost(zcu) orelse {
+    pub fn order(lhs: LazySrcLoc, rhs: LazySrcLoc, zcu: *Zcu) std.math.Order {
+        const lhs_resolved = lhs.upgradeOrLost(zcu) orelse {
             // LHS source location lost, so should never be referenced. Just sort it to the end.
-            return false;
+            return .gt;
         };
-        const rhs_src = rhs_lazy.upgradeOrLost(zcu) orelse {
+        const rhs_resolved = rhs.upgradeOrLost(zcu) orelse {
             // RHS source location lost, so should never be referenced. Just sort it to the end.
-            return true;
+            return .lt;
         };
-        if (lhs_src.file_scope != rhs_src.file_scope) {
-            const lhs_path = lhs_src.file_scope.path;
-            const rhs_path = rhs_src.file_scope.path;
-            if (lhs_path.root != rhs_path.root) {
-                return @intFromEnum(lhs_path.root) < @intFromEnum(rhs_path.root);
-            }
-            return std.mem.order(u8, lhs_path.sub_path, rhs_path.sub_path).compare(.lt);
+        if (lhs_resolved.file_scope != rhs_resolved.file_scope) {
+            const lhs_path = lhs_resolved.file_scope.path;
+            const rhs_path = rhs_resolved.file_scope.path;
+            return std.math.order(@intFromEnum(lhs_path.root), @intFromEnum(rhs_path.root)).differ() orelse
+                std.mem.order(u8, lhs_path.sub_path, rhs_path.sub_path).differ().?;
         }
-
-        const lhs_span = lhs_src.span(zcu) catch |err| {
-            bad_file_out.* = lhs_src.file_scope;
-            return err;
+        const prev_prot = zcu.comp.io.swapCancelProtection(.blocked);
+        defer _ = zcu.comp.io.swapCancelProtection(prev_prot);
+        const lhs_span = lhs_resolved.span(zcu) catch |err| {
+            assert(err != error.Canceled); // we're protected
+            // Failed to read LHS, so we'll get a transient error. Just sort it to the end.
+            return .gt;
         };
-        const rhs_span = rhs_src.span(zcu) catch |err| {
-            bad_file_out.* = rhs_src.file_scope;
-            return err;
+        const rhs_span = rhs_resolved.span(zcu) catch |err| {
+            assert(err != error.Canceled); // we're protected
+            // Failed to read RHS, so we'll get a transient error. Just sort it to the end.
+            return .lt;
         };
-        return lhs_span.main < rhs_span.main;
+        return std.math.order(lhs_span.main, rhs_span.main);
     }
 };
 
-- 
2.54.0


From c64755fb2f3178b4f593ef9f2cb54beef03af36f Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 28 Feb 2026 11:58:23 +0000
Subject: [PATCH 472/499] Type: fix assertion failure

---
 src/Type.zig | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/Type.zig b/src/Type.zig
index 60adb6f10ffb7601d85eb337ff05cafe452b1cba..4aca4ed834a968cebfb940e7e912809e75dbc5f1 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -3094,7 +3094,7 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
             if (ty.isSlice(zcu)) return false;
             const child_ty = ty.childType(zcu);
             if (child_ty.zigTypeTag(zcu) == .@"fn") {
-                return ty.isConstPtr(zcu) and child_ty.validateExtern(.other, zcu);
+                return ty.isConstPtr(zcu) and validateExternCallconv(child_ty.fnCallingConvention(zcu));
             }
             return true;
         },
@@ -3104,12 +3104,7 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
         },
         .@"fn" => {
             if (position != .other) return false;
-            // For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI.
-            // The goal is to experiment with more integrated CPU/GPU code.
-            if (ty.fnCallingConvention(zcu) == .nvptx_kernel) {
-                return true;
-            }
-            return !target_util.fnCallConvAllowsZigTypes(ty.fnCallingConvention(zcu));
+            return validateExternCallconv(ty.fnCallingConvention(zcu));
         },
         .@"enum" => {
             const enum_obj = zcu.intern_pool.loadEnumType(ty.toIntern());
@@ -3155,6 +3150,14 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
         .optional => ty.isPtrLikeOptional(zcu),
     };
 }
+fn validateExternCallconv(cc: std.builtin.CallingConvention) bool {
+    return switch (cc) {
+        // For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI.
+        // The goal is to experiment with more integrated CPU/GPU code.
+        .nvptx_kernel => true,
+        else => !target_util.fnCallConvAllowsZigTypes(cc),
+    };
+}
 
 /// Asserts that `ty` has resolved layout.
 pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
-- 
2.54.0


From 4eb8360911d80d4891be6ed47792121a2ccde353 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 1 Mar 2026 07:32:09 +0000
Subject: [PATCH 473/499] compiler: various lil' fixes

---
 lib/compiler/objcopy.zig     |   4 +-
 lib/std/pdb.zig              |   4 +-
 lib/std/zig/AstGen.zig       |   5 +
 src/Compilation.zig          |   3 +-
 src/Sema.zig                 | 191 +++++++++++++++++------------------
 src/Sema/arith.zig           |   3 +
 src/Sema/type_resolution.zig |  46 ++++++---
 src/Type.zig                 |  14 ++-
 src/Value.zig                |  14 ++-
 src/Zcu.zig                  |  44 +++++++-
 src/Zcu/PerThread.zig        |  97 +++++++++++-------
 src/codegen/c.zig            |  15 ++-
 src/codegen/c/type.zig       |  14 ++-
 src/codegen/llvm.zig         |  32 ++----
 src/link/Dwarf.zig           |   6 ++
 src/print_value.zig          |  23 ++++-
 16 files changed, 312 insertions(+), 203 deletions(-)

diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig
index 57d019bc95b8887c9bce708d6be08fb3abc9205a..9c3fffc67f07b8e6c918d554747ba6a421ba026d 100644
--- a/lib/compiler/objcopy.zig
+++ b/lib/compiler/objcopy.zig
@@ -388,8 +388,8 @@ const BinaryElfOutput = struct {
 
     pub fn parse(allocator: Allocator, in: *File.Reader, elf_hdr: elf.Header) !Self {
         var self: Self = .{
-            .segments = .{},
-            .sections = .{},
+            .segments = .empty,
+            .sections = .empty,
             .allocator = allocator,
             .shstrtab = null,
         };
diff --git a/lib/std/pdb.zig b/lib/std/pdb.zig
index 7e479de8d4fe196594c6184b9721d11f31e2051d..094537972b3c7e7e560019f56178631f52663312 100644
--- a/lib/std/pdb.zig
+++ b/lib/std/pdb.zig
@@ -332,7 +332,7 @@ pub const ProcSym = extern struct {
     name: [1]u8, // null-terminated
 };
 
-pub const ProcSymFlags = packed struct {
+pub const ProcSymFlags = packed struct(u8) {
     has_fp: bool,
     has_iret: bool,
     has_fret: bool,
@@ -373,7 +373,7 @@ pub const LineFragmentHeader = extern struct {
     code_size: u32,
 };
 
-pub const LineFlags = packed struct {
+pub const LineFlags = packed struct(u16) {
     /// CV_LINES_HAVE_COLUMNS
     have_columns: bool,
     unused: u15,
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 1fcb9f5eb2aac77802763ac742913899c71ede4e..377c9fb8dc6eda208b5581264399180cec8388f8 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -5513,6 +5513,11 @@ fn containerDecl(
                     if (next_field_idx != fields_len) {
                         return astgen.failNode(member_node, "'_' field of non-exhaustive enum must be last", .{});
                     }
+                    if (tag_type_body_len == null) {
+                        return astgen.failNodeNotes(node, "non-exhaustive enum missing integer tag type", .{}, &.{
+                            try astgen.errNoteNode(member_node, "marked non-exhaustive here", .{}),
+                        });
+                    }
                     opt_nonexhaustive_node = member_node.toOptional();
                     continue;
                 }
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 9bf91302d891715a058ee152eecb35e8157b70e6..9fbc36f070b5239b2a2d2ff0ec113055b929c79d 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -4180,7 +4180,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
             if (!refs.contains(logging_unit)) continue;
             try messages.append(gpa, .{
                 .src_loc = compile_log.src(),
-                .msg = undefined, // populated later
+                .msg = "", // populated later, but must be valid for `sort` call below
                 .notes = &.{},
                 // We actually clear this later for most of these, but we populate
                 // this field for now to avoid having to allocate more data to track
@@ -4221,6 +4221,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
 
         break :compile_log_text try log_text.toOwnedSlice(gpa);
     };
+    defer gpa.free(compile_log_text);
 
     // TODO: eventually, this should be behind `std.debug.runtime_safety`. But right now, this is a
     // very common way for incremental compilation bugs to manifest, so let's always check it.
diff --git a/src/Sema.zig b/src/Sema.zig
index 9e3024b7eda20650eb9bbf1978658a3061d5c742..2af1c8cf107895931f393e0298defc8bd6ddcbda 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -416,7 +416,7 @@ pub const Block = struct {
         return block.comptime_reason != null;
     }
 
-    fn builtinCallArgSrc(block: *Block, builtin_call_node: std.zig.Ast.Node.Offset, arg_index: u32) LazySrcLoc {
+    pub fn builtinCallArgSrc(block: *Block, builtin_call_node: std.zig.Ast.Node.Offset, arg_index: u32) LazySrcLoc {
         return block.src(.{ .node_offset_builtin_call_arg = .{
             .builtin_call_node = builtin_call_node,
             .arg_index = arg_index,
@@ -4654,47 +4654,14 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
         .slice => return sema.fail(block, src, "index syntax required for slice type '{f}'", .{operand_ty.fmt(pt)}),
     }
 
-    const elem_ty = operand_ty.childType(zcu);
-    try sema.ensureLayoutResolved(elem_ty, src, .ptr_access);
-
-    const need_comptime = switch (elem_ty.classify(zcu)) {
-        .no_possible_value => return sema.fail(block, src, "cannot load {s} type '{f}'", .{
-            if (elem_ty.zigTypeTag(zcu) == .@"opaque") "opaque" else "uninstantiable",
-            elem_ty.fmt(pt),
-        }),
-        .one_possible_value => return, // no need to validate the actual pointer value!
-        .runtime => false,
-        .partially_comptime, .fully_comptime => true,
-    };
-
     if (sema.resolveValue(operand)) |val| {
-        if (val.isUndef(zcu)) {
+        // Error for deref of undef pointer, unless the pointee is OPV in which case it's legal.
+        if (val.isUndef(zcu) and operand_ty.childType(zcu).classify(zcu) != .one_possible_value) {
             return sema.fail(block, src, "cannot dereference undefined value", .{});
         }
-    } else if (need_comptime) {
-        const msg = msg: {
-            const msg = try sema.errMsg(
-                src,
-                "values of type '{f}' must be comptime-known, but operand value is runtime-known",
-                .{elem_ty.fmt(pt)},
-            );
-            errdefer msg.destroy(sema.gpa);
-
-            try sema.explainWhyTypeIsComptime(msg, src, elem_ty);
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(block, msg);
     }
 }
 
-fn typeIsDestructurable(ty: Type, zcu: *const Zcu) bool {
-    return switch (ty.zigTypeTag(zcu)) {
-        .array, .vector => true,
-        .@"struct" => ty.isTuple(zcu),
-        else => false,
-    };
-}
-
 fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -4705,14 +4672,14 @@ fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const operand = sema.resolveInst(extra.operand);
     const operand_ty = sema.typeOf(operand);
 
-    if (!typeIsDestructurable(operand_ty, zcu)) {
+    if (!operand_ty.destructurable(zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "type '{f}' cannot be destructured", .{operand_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
             try sema.errNote(destructure_src, msg, "result destructured here", .{});
             if (operand_ty.zigTypeTag(pt.zcu) == .error_union) {
                 const base_op_ty = operand_ty.errorUnionPayload(zcu);
-                if (typeIsDestructurable(base_op_ty, zcu))
+                if (base_op_ty.destructurable(zcu))
                     try sema.errNote(src, msg, "consider using 'try', 'catch', or 'if'", .{});
             }
             break :msg msg;
@@ -8247,8 +8214,15 @@ fn zirOptionalPayload(
         else => return sema.failWithExpectedOptionalType(block, src, operand_ty),
     };
 
-    if (try sema.resolveDefinedValue(block, src, operand)) |val| {
-        if (val.optionalValue(zcu)) |payload| return Air.internedToRef(payload.toIntern());
+    ct: {
+        if (try sema.resolveDefinedValue(block, src, operand)) |val| {
+            if (val.optionalValue(zcu)) |payload| return .fromValue(payload); // comptime-known payload
+        } else if (try sema.resolveIsNullFromType(block, src, operand_ty)) |is_null| {
+            if (!is_null) break :ct; // fully runtime-known
+        } else {
+            break :ct; // fully runtime-known
+        }
+        // Comptime-known to be `null`.
         if (block.isComptime()) return sema.fail(block, src, "unable to unwrap null", .{});
         if (safety_check and block.wantSafety()) {
             try sema.safetyPanic(block, src, .unwrap_null);
@@ -21085,7 +21059,8 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
                 continue :check ip.funcIesResolvedUnordered(func_index);
             },
             .error_set_type => |dest| {
-                if (operand_err_ty.isAnyError(zcu)) break :check .superset;
+                if (dest.names.len == 0) break :check .disjoint; // dest is 'error{}'
+                if (operand_err_ty.isAnyError(zcu)) break :check .overlap; // anyerror -> error{...} (non-empty)
                 var dest_has_all = true;
                 var dest_has_any = false;
                 for (operand_err_ty.errorSetNames(zcu).get(ip)) |operand_err_name| {
@@ -24741,15 +24716,30 @@ fn zirBuiltinExtern(
     const ty_src = block.builtinCallArgSrc(extra.node, 0);
     const options_src = block.builtinCallArgSrc(extra.node, 1);
 
-    var ty = try sema.resolveType(block, ty_src, extra.lhs);
-    if (!ty.isPtrAtRuntime(zcu)) {
+    const ptr_ty = try sema.resolveType(block, ty_src, extra.lhs);
+    if (!ptr_ty.isPtrAtRuntime(zcu)) {
         return sema.fail(block, ty_src, "expected (optional) pointer", .{});
     }
-    if (!ty.validateExtern(.other, zcu)) {
+
+    const ptr_info = ptr_ty.ptrInfo(zcu);
+
+    const elem_ty: Type = .fromInterned(ptr_info.child);
+    try sema.ensureLayoutResolved(elem_ty, src, .@"extern");
+
+    if (!elem_ty.validateExtern(.other, zcu)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(ty_src, "extern symbol cannot have type '{f}'", .{ty.fmt(pt)});
+            const msg = try sema.errMsg(ty_src, "extern symbol cannot have type '{f}'", .{ptr_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
-            try sema.explainWhyTypeIsNotExtern(msg, ty_src, ty, .other);
+            try sema.errNote(ty_src, msg, "pointer element type '{f}' is not extern compatible", .{elem_ty.fmt(pt)});
+            try sema.explainWhyTypeIsNotExtern(msg, ty_src, elem_ty, .other);
+            break :msg msg;
+        });
+    }
+    if (elem_ty.zigTypeTag(zcu) == .@"fn" and !ptr_info.flags.is_const) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(ty_src, "extern symbol cannot have type '{f}'", .{ptr_ty.fmt(pt)});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(ty_src, msg, "pointer to extern function must be 'const'", .{});
             break :msg msg;
         });
     }
@@ -24769,14 +24759,9 @@ fn zirBuiltinExtern(
 
     // TODO: error for threadlocal functions, non-const functions, etc
 
-    if (options.linkage == .weak and !ty.ptrAllowsZero(zcu)) {
-        ty = try pt.optionalType(ty.toIntern());
-    }
-    const ptr_info = ty.ptrInfo(zcu);
-
     const extern_val = try pt.getExtern(.{
         .name = options.name,
-        .ty = ptr_info.child,
+        .ty = elem_ty.toIntern(),
         .lib_name = options.library_name,
         .linkage = options.linkage,
         .visibility = options.visibility,
@@ -24807,13 +24792,17 @@ fn zirBuiltinExtern(
         .source = .builtin,
     });
 
+    // For a weak symbol where the given type is not nullable, make the pointer optional.
+    const result_ptr_ty: Type = if (options.linkage == .weak and !ptr_ty.ptrAllowsZero(zcu)) ty: {
+        break :ty try pt.optionalType(ptr_ty.toIntern());
+    } else ptr_ty;
+
     const uncasted_ptr = try sema.analyzeNavRef(block, src, ip.indexToKey(extern_val).@"extern".owner_nav);
-    // We want to cast to `ty`, but that isn't necessarily an allowed coercion.
     if (sema.resolveValue(uncasted_ptr)) |uncasted_ptr_val| {
-        const casted_ptr_val = try pt.getCoerced(uncasted_ptr_val, ty);
+        const casted_ptr_val = try pt.getCoerced(uncasted_ptr_val, result_ptr_ty);
         return Air.internedToRef(casted_ptr_val.toIntern());
     } else {
-        return block.addBitCast(ty, uncasted_ptr);
+        return block.addBitCast(result_ptr_ty, uncasted_ptr);
     }
 }
 
@@ -25258,6 +25247,7 @@ pub fn explainWhyTypeIsUnpackable(
             try sema.errNote(src, msg, "non-packed unions do not have a bit-packed representation", .{});
             try sema.addDeclaredHereNote(msg, union_ty);
         },
+        .slice => try sema.errNote(src, msg, "slices do not have a bit-packed representation", .{}),
         .other => try sema.errNote(src, msg, "type does not have a bit-packed representation", .{}),
     }
 }
@@ -25501,7 +25491,10 @@ fn addSafetyCheckSentinelMismatch(
     };
     assert(sema.typeOf(actual_sentinel).toIntern() == sentinel_ty.toIntern());
     assert(sentinel_ty.isSelfComparable(zcu, true));
-    const ok = try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel);
+    const ok: Air.Inst.Ref = if (sentinel_ty.zigTypeTag(zcu) == .vector) ok: {
+        const elementwise = try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq);
+        break :ok try parent_block.addReduce(elementwise, .And);
+    } else try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel);
 
     return addSafetyCheckCall(sema, parent_block, src, ok, .@"panic.sentinelMismatch", &.{
         expected_sentinel, actual_sentinel,
@@ -26574,8 +26567,13 @@ fn unionFieldVal(
                 const active_tag_val = union_val.unionTag(zcu).?;
                 const active_index = enum_tag_ty.enumTagFieldIndex(active_tag_val, zcu).?;
                 if (active_index == field_index) return .fromValue(union_val.unionPayload(zcu));
-                return sema.fail(block, src, "access of union field '{f}' while field '{f}' is active", .{
-                    field_name.fmt(ip), enum_tag_ty.enumFieldName(active_index, zcu).fmt(ip),
+                return sema.failWithOwnedErrorMsg(block, msg: {
+                    const msg = try sema.errMsg(src, "access of union field '{f}' while field '{f}' is active", .{
+                        field_name.fmt(ip), enum_tag_ty.enumFieldName(active_index, zcu).fmt(ip),
+                    });
+                    errdefer msg.destroy(zcu.comp.gpa);
+                    try sema.addDeclaredHereNote(msg, union_ty);
+                    break :msg msg;
                 });
             },
             .@"extern" => if (try sema.bitCastVal(union_val, field_ty, 0, 0, 0)) |field_val| {
@@ -26745,9 +26743,17 @@ fn elemVal(
                         return sema.analyzeLoad(block, src, .fromValue(elem_ptr_val), indexable_src);
                     }
 
-                    if (try child_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+                    try sema.validateRuntimeElemAccess(block, elem_index_src, child_ty, indexable_ty, src);
+                    switch (child_ty.classify(zcu)) {
+                        .runtime => {},
+                        .one_possible_value => return .fromValue((try child_ty.onePossibleValue(pt)).?),
+                        .no_possible_value => switch (child_ty.zigTypeTag(zcu)) {
+                            .@"opaque" => return sema.fail(block, src, "cannot load opaque type '{f}'", .{child_ty.fmt(pt)}),
+                            else => return sema.fail(block, src, "cannot load uninstantiable type '{f}'", .{child_ty.fmt(pt)}),
+                        },
+                        .partially_comptime, .fully_comptime => unreachable, // caught by `validateRuntimeElemAccess`
+                    }
 
-                    try sema.checkLogicalPtrOperation(block, src, indexable_ty);
                     return block.addBinOp(.ptr_elem_val, indexable, elem_index);
                 },
                 .one => {
@@ -29082,31 +29088,6 @@ fn storePtr2(
 
     const elem_ty = ptr_ty.childType(zcu);
 
-    // To generate better code for tuples, we detect a tuple operand here, and
-    // analyze field loads and stores directly. This avoids an extra allocation + memcpy
-    // which would occur if we used `coerce`.
-    // However, we avoid this mechanism if the destination element type is a tuple,
-    // because the regular store will be better for this case.
-    // If the destination type is a struct we don't want this mechanism to trigger, because
-    // this code does not handle tuple-to-struct coercion which requires dealing with missing
-    // fields.
-    const operand_ty = sema.typeOf(uncasted_operand);
-    if (operand_ty.isTuple(zcu) and elem_ty.zigTypeTag(zcu) == .array) {
-        const field_count = operand_ty.structFieldCount(zcu);
-        var i: u32 = 0;
-        while (i < field_count) : (i += 1) {
-            const elem_src = operand_src; // TODO better source location
-            const elem = try sema.tupleField(block, operand_src, uncasted_operand, elem_src, i);
-            const elem_index = try pt.intRef(.usize, i);
-            const elem_ptr = try sema.elemPtr(block, ptr_src, ptr, elem_index, elem_src, false, true);
-            try sema.storePtr2(block, src, elem_ptr, elem_src, elem, elem_src, .store);
-        }
-        return;
-    }
-
-    // TODO do the same thing for anon structs as for tuples above.
-    // However, beware of the need to handle missing/extra fields.
-
     const is_ret = air_tag == .ret_ptr;
 
     const operand = sema.coerceExtra(block, elem_ty, uncasted_operand, operand_src, .{ .is_ret = is_ret }) catch |err| switch (err) {
@@ -29129,16 +29110,13 @@ fn storePtr2(
         return sema.storePtrVal(block, src, ptr_val, operand_val, elem_ty);
     };
 
-    // We're performing the store at runtime; as such, we need to make sure the pointee type
-    // is not comptime-only. We can hit this case with a `@ptrFromInt` pointer.
-    if (comptime_only) {
-        return sema.failWithOwnedErrorMsg(block, msg: {
-            const msg = try sema.errMsg(src, "cannot store comptime-only type '{f}' at runtime", .{elem_ty.fmt(pt)});
-            errdefer msg.destroy(sema.gpa);
-            try sema.errNote(ptr_src, msg, "operation is runtime due to this pointer", .{});
-            break :msg msg;
-        });
-    }
+    // We're performing the store at runtime, so the pointee type must not be comptime-only.
+    if (comptime_only) return sema.failWithOwnedErrorMsg(block, msg: {
+        const msg = try sema.errMsg(src, "cannot store comptime-only type '{f}' at runtime", .{elem_ty.fmt(pt)});
+        errdefer msg.destroy(sema.gpa);
+        try sema.errNote(ptr_src, msg, "operation is runtime due to this pointer", .{});
+        break :msg msg;
+    });
 
     try sema.requireRuntimeBlock(block, src, runtime_src);
 
@@ -29556,7 +29534,10 @@ fn coerceEnumToUnion(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
-    if (union_ty.unionHasAllZeroBitFieldTypes(zcu)) {
+    for (union_obj.field_types.get(ip)) |field_ty_ip| {
+        if (Type.fromInterned(field_ty_ip).classify(zcu) != .one_possible_value) break;
+    } else {
+        // All fields are OPV, so the coercion is okay.
         if (try union_ty.onePossibleValue(pt)) |opv| {
             // The tag had redundant bits, but we've omitted the tag from the union's runtime layout, so the union is OPV and hence runtime-known.
             return .fromValue(opv);
@@ -29566,6 +29547,8 @@ fn coerceEnumToUnion(
         }
     }
 
+    // The coercion is invalid because one or more fields is not OPV.
+
     const msg = msg: {
         const msg = try sema.errMsg(
             inst_src,
@@ -30186,12 +30169,18 @@ fn analyzeLoad(
         .pointer => ptr_ty.childType(zcu),
         else => return sema.fail(block, ptr_src, "expected pointer, found '{f}'", .{ptr_ty.fmt(pt)}),
     };
-    if (elem_ty.zigTypeTag(zcu) == .@"opaque") {
-        return sema.fail(block, ptr_src, "cannot load opaque type '{f}'", .{elem_ty.fmt(pt)});
-    }
 
     try sema.ensureLayoutResolved(elem_ty, src, .ptr_access);
-    if (try elem_ty.onePossibleValue(pt)) |opv| return .fromValue(opv);
+
+    const comptime_only = switch (elem_ty.classify(zcu)) {
+        .no_possible_value => switch (elem_ty.zigTypeTag(zcu)) {
+            .@"opaque" => return sema.fail(block, src, "cannot load opaque type '{f}'", .{elem_ty.fmt(pt)}),
+            else => return sema.fail(block, src, "cannot load uninstantiable type '{f}'", .{elem_ty.fmt(pt)}),
+        },
+        .one_possible_value => return .fromValue((try elem_ty.onePossibleValue(pt)).?),
+        .runtime => false,
+        .partially_comptime, .fully_comptime => true,
+    };
 
     if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
         if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |elem_val| {
@@ -30199,7 +30188,7 @@ fn analyzeLoad(
         }
     }
 
-    if (elem_ty.comptimeOnly(zcu)) return sema.failWithOwnedErrorMsg(block, msg: {
+    if (comptime_only) return sema.failWithOwnedErrorMsg(block, msg: {
         const msg = try sema.errMsg(src, "cannot load comptime-only type '{f}'", .{elem_ty.fmt(pt)});
         errdefer msg.destroy(zcu.gpa);
         try sema.errNote(ptr_src, msg, "pointer of type '{f}' is runtime-known", .{ptr_ty.fmt(pt)});
diff --git a/src/Sema/arith.zig b/src/Sema/arith.zig
index 161b6e1ce03ad4ffd9ee8372f49fb39a8a279207..024fc5da62cfb75b87d2f822b3450e8a5f431241 100644
--- a/src/Sema/arith.zig
+++ b/src/Sema/arith.zig
@@ -20,6 +20,9 @@ pub fn incrementDefinedInt(
     const zcu = pt.zcu;
     assert(prev_val.typeOf(zcu).toIntern() == ty.toIntern());
     assert(!prev_val.isUndef(zcu));
+    if (ty.intInfo(zcu).bits == 0) {
+        return .{ .overflow = true, .val = try comptimeIntAdd(sema, prev_val, .one_comptime_int) };
+    }
     const res = try intAdd(sema, prev_val, try pt.intValue(ty, 1), ty);
     return .{ .overflow = res.overflow, .val = res.val };
 }
diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig
index 8009838a8837025a3895e90207dd95cc922559a1..032f299531509224da563a7347ecd4c2459d8fd3 100644
--- a/src/Sema/type_resolution.zig
+++ b/src/Sema/type_resolution.zig
@@ -33,6 +33,7 @@ pub const LayoutResolveReason = enum {
     align_check,
     bit_ptr_child,
     @"export",
+    @"extern",
     builtin_type,
 
     /// Written after string: "while resolving type 'T' "
@@ -58,6 +59,7 @@ pub const LayoutResolveReason = enum {
             .align_check   => "for alignment check here",
             .bit_ptr_child => "for bit size check here",
             .@"export"     => "for export here",
+            .@"extern"     => "for extern declaration here",
             .builtin_type  => "from 'std.builtin'",
             // zig fmt: on
         };
@@ -198,7 +200,7 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void {
             const name = struct_obj.field_names.get(ip)[field_index];
             if (ip.addFieldName(struct_obj.field_names, struct_obj.field_name_map, name)) |prev_field_index| {
                 return sema.failWithOwnedErrorMsg(&block, msg: {
-                    const src = block.nodeOffset(.zero);
+                    const src = block.builtinCallArgSrc(.zero, 2);
                     const msg = try sema.errMsg(src, "duplicate struct field '{f}' at index '{d}", .{ name.fmt(ip), field_index });
                     errdefer msg.destroy(gpa);
                     try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_index});
@@ -494,20 +496,22 @@ fn resolvePackedStructLayout(
 
     // Finally, either validate or infer the backing int type.
     const backing_int_ty: Type = if (explicit_backing_int_ty) |backing_ty| ty: {
-        // We only need to validate the type.
-        if (backing_ty.zigTypeTag(zcu) != .int) return sema.failWithOwnedErrorMsg(block, msg: {
-            const src = struct_ty.srcLoc(zcu);
-            const msg = try sema.errMsg(src, "expected backing integer type, found '{f}'", .{backing_ty.fmt(pt)});
-            errdefer msg.destroy(gpa);
-            try sema.errNote(src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) });
-            try sema.errNote(src, msg, "struct fields have total bit width '{d}'", .{field_bits});
-            break :msg msg;
-        });
+        if (backing_ty.zigTypeTag(zcu) != .int) return sema.fail(
+            block,
+            block.src(.container_arg),
+            "expected backing integer type, found '{f}'",
+            .{backing_ty.fmt(pt)},
+        );
         if (field_bits != backing_ty.intInfo(zcu).bits) return sema.failWithOwnedErrorMsg(block, msg: {
             const src = struct_ty.srcLoc(zcu);
             const msg = try sema.errMsg(src, "backing integer bit width does not match total bit width of fields", .{});
             errdefer msg.destroy(gpa);
-            try sema.errNote(src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) });
+            try sema.errNote(
+                block.src(.container_arg),
+                msg,
+                "backing integer '{f}' has bit width '{d}'",
+                .{ backing_ty.fmt(pt), backing_ty.bitSize(zcu) },
+            );
             try sema.errNote(src, msg, "struct fields have total bit width '{d}'", .{field_bits});
             break :msg msg;
         });
@@ -1033,7 +1037,6 @@ fn resolvePackedUnionLayout(
             const msg = try sema.errMsg(field_ty_src, "packed unions cannot contain fields of type '{f}'", .{field_ty.fmt(pt)});
             errdefer msg.destroy(gpa);
             try sema.explainWhyTypeIsUnpackable(msg, field_ty_src, reason);
-            try sema.addDeclaredHereNote(msg, field_ty);
             break :msg msg;
         });
         assert(!field_ty.comptimeOnly(zcu)); // packable types are not comptime-only
@@ -1062,6 +1065,12 @@ fn resolvePackedUnionLayout(
 
     // Finally, either validate or infer the backing int type.
     const backing_int_ty: Type = if (explicit_backing_int_ty) |backing_ty| ty: {
+        if (backing_ty.zigTypeTag(zcu) != .int) return sema.fail(
+            block,
+            block.src(.container_arg),
+            "expected backing integer type, found '{f}'",
+            .{backing_ty.fmt(pt)},
+        );
         const backing_int_bits = backing_ty.intInfo(zcu).bits;
         for (union_obj.field_types.get(ip), 0..) |field_type_ip, field_idx| {
             const field_type: Type = .fromInterned(field_type_ip);
@@ -1071,7 +1080,12 @@ fn resolvePackedUnionLayout(
                 const msg = try sema.errMsg(field_ty_src, "field bit width does not match backing integer", .{});
                 errdefer msg.destroy(gpa);
                 try sema.errNote(field_ty_src, msg, "field type '{f}' has bit width '{d}'", .{ field_type.fmt(pt), field_bits });
-                try sema.errNote(field_ty_src, msg, "backing integer '{f}' has bit width '{d}'", .{ backing_ty.fmt(pt), backing_int_bits });
+                try sema.errNote(
+                    block.src(.container_arg),
+                    msg,
+                    "backing integer '{f}' has bit width '{d}'",
+                    .{ backing_ty.fmt(pt), backing_int_bits },
+                );
                 try sema.errNote(field_ty_src, msg, "all fields in a packed union must have the same bit width", .{});
                 break :msg msg;
             });
@@ -1157,7 +1171,7 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
                 const name = enum_obj.field_names.get(ip)[field_index];
                 if (ip.addFieldName(enum_obj.field_names, enum_obj.field_name_map, name)) |prev_field_index| {
                     return sema.failWithOwnedErrorMsg(&block, msg: {
-                        const src = block.nodeOffset(.zero);
+                        const src = block.builtinCallArgSrc(.zero, 2);
                         const msg = try sema.errMsg(src, "duplicate union field '{f}' at index '{d}", .{ name.fmt(ip), field_index });
                         errdefer msg.destroy(gpa);
                         try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_index});
@@ -1183,8 +1197,8 @@ pub fn resolveEnumLayout(sema: *Sema, enum_ty: Type) CompileError!void {
                 const name = enum_obj.field_names.get(ip)[field_index];
                 if (ip.addFieldName(enum_obj.field_names, enum_obj.field_name_map, name)) |prev_field_index| {
                     return sema.failWithOwnedErrorMsg(&block, msg: {
-                        const src = block.nodeOffset(.zero);
-                        const msg = try sema.errMsg(src, "duplicate enum field '{f}' at index '{d}", .{ name.fmt(ip), field_index });
+                        const src = block.builtinCallArgSrc(.zero, 2);
+                        const msg = try sema.errMsg(src, "duplicate enum field '{f}' at index '{d}'", .{ name.fmt(ip), field_index });
                         errdefer msg.destroy(gpa);
                         try sema.errNote(src, msg, "previous field at index '{d}'", .{prev_field_index});
                         break :msg msg;
diff --git a/src/Type.zig b/src/Type.zig
index 4aca4ed834a968cebfb940e7e912809e75dbc5f1..ea92d6befdc5202a8dd21ad01d5f5ac66fb3af9d 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -2985,12 +2985,21 @@ pub fn containerTypeName(ty: Type, ip: *const InternPool) InternPool.NullTermina
     };
 }
 
+pub fn destructurable(ty: Type, zcu: *const Zcu) bool {
+    return switch (ty.zigTypeTag(zcu)) {
+        .array, .vector => true,
+        .@"struct" => ty.isTuple(zcu),
+        else => false,
+    };
+}
+
 pub const UnpackableReason = union(enum) {
     comptime_only,
     pointer,
     enum_inferred_int_tag: Type,
     non_packed_struct: Type,
     non_packed_union: Type,
+    slice,
     other,
 };
 
@@ -3027,7 +3036,10 @@ pub fn unpackable(ty: Type, zcu: *const Zcu) ?UnpackableReason {
         else
             .other,
 
-        .pointer => .pointer,
+        .pointer => switch (ty.ptrSize(zcu)) {
+            .slice => .slice,
+            .one, .many, .c => .pointer,
+        },
 
         .@"enum" => switch (zcu.intern_pool.loadEnumType(ty.toIntern()).int_tag_mode) {
             .explicit => null,
diff --git a/src/Value.zig b/src/Value.zig
index 6a474c282133e10e15cfdd423b309df986bbf034..4cd7995b712a0c05b9e98960bc5198523bc21099 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -2014,7 +2014,11 @@ pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, op
         },
         .field => |field| base: {
             const base_ptr = Value.fromInterned(field.base);
-            const base_ptr_ty = base_ptr.typeOf(zcu);
+            const base_ptr_ty = try pt.ptrType(info: {
+                var info = base_ptr.typeOf(zcu).ptrInfo(zcu);
+                info.flags.size = .one;
+                break :info info;
+            });
             const parent_step = try arena.create(PointerDeriveStep);
             parent_step.* = try pointerDerivation(base_ptr, arena, pt, opt_sema);
             break :base .{ .field_ptr = .{
@@ -2155,13 +2159,17 @@ pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, op
                     const start_off = cur_ty.structFieldOffset(field_idx, zcu);
                     const end_off = start_off + field_ty.abiSize(zcu);
                     if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
-                        const old_ptr_ty = try cur_derive.ptrType(pt);
+                        const base_ptr_ty = try pt.ptrType(info: {
+                            var info = (try cur_derive.ptrType(pt)).ptrInfo(zcu);
+                            info.flags.size = .one;
+                            break :info info;
+                        });
                         const parent = try arena.create(PointerDeriveStep);
                         parent.* = cur_derive;
                         cur_derive = .{ .field_ptr = .{
                             .parent = parent,
                             .field_idx = @intCast(field_idx),
-                            .result_ptr_ty = try old_ptr_ty.fieldPtrType(@intCast(field_idx), pt),
+                            .result_ptr_ty = try base_ptr_ty.fieldPtrType(@intCast(field_idx), pt),
                         } };
                         cur_offset -= start_off;
                         break;
diff --git a/src/Zcu.zig b/src/Zcu.zig
index eb4b8bdb05be4006f163fe2e48ff5746537a8905..78144bac16a817a931a23e5d1ba346f7aee374af 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -2028,9 +2028,15 @@ pub const SrcLoc = struct {
                 const tree = try src_loc.file_scope.getTree(zcu);
                 const node = src_loc.base_node;
                 var buf: [2]Ast.Node.Index = undefined;
-                const container_decl = tree.fullContainerDecl(&buf, node) orelse return tree.nodeToSpan(node);
-                const arg_node = container_decl.ast.arg.unwrap() orelse return tree.nodeToSpan(node);
-                return tree.nodeToSpan(arg_node);
+                if (tree.fullContainerDecl(&buf, node)) |container_decl| {
+                    const arg_node = container_decl.ast.arg.unwrap() orelse return tree.nodeToSpan(node);
+                    return tree.nodeToSpan(arg_node);
+                } else if (tree.builtinCallParams(&buf, node)) |args| {
+                    // Builtin calls (`@Enum` etc) should use the first argument.
+                    return tree.nodeToSpan(if (args.len > 0) args[0] else node);
+                } else {
+                    return tree.nodeToSpan(node);
+                }
             },
             .container_field_name,
             .container_field_value,
@@ -2040,8 +2046,38 @@ pub const SrcLoc = struct {
                 const tree = try src_loc.file_scope.getTree(zcu);
                 const node = src_loc.base_node;
                 var buf: [2]Ast.Node.Index = undefined;
-                const container_decl = tree.fullContainerDecl(&buf, node) orelse
+                const container_decl = tree.fullContainerDecl(&buf, node) orelse {
+                    // This could be a reification builtin. These are the args we care about:
+                    // * `@Enum(_, _, names, values)`
+                    // * `@Struct(_, _, names, types, values_and_aligns)`
+                    // * `@Union(_, _, names, types, aligns)`
+                    if (tree.builtinCallParams(&buf, node)) |args| {
+                        const builtin_name = tree.tokenSlice(tree.firstToken(node));
+                        const arg_index: ?u3 = if (std.mem.eql(u8, builtin_name, "@Enum")) switch (src_loc.lazy) {
+                            .container_field_name => 2,
+                            .container_field_value => 3,
+                            .container_field_type => null,
+                            .container_field_align => null,
+                            else => unreachable,
+                        } else if (std.mem.eql(u8, builtin_name, "@Struct")) switch (src_loc.lazy) {
+                            .container_field_name => 2,
+                            .container_field_value => 4,
+                            .container_field_type => 3,
+                            .container_field_align => 4,
+                            else => unreachable,
+                        } else if (std.mem.eql(u8, builtin_name, "@Union")) switch (src_loc.lazy) {
+                            .container_field_name => 2,
+                            .container_field_value => 4,
+                            .container_field_type => 3,
+                            .container_field_align => null,
+                            else => unreachable,
+                        } else null;
+                        if (arg_index) |i| {
+                            if (args.len >= i) return tree.nodeToSpan(args[i]);
+                        }
+                    }
                     return tree.nodeToSpan(node);
+                };
 
                 var cur_field_idx: usize = 0;
                 for (container_decl.ast.members) |member_node| {
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 9fde840232d2ec4d598ef192a6379bb86138af5b..6a7054246eae094e485909243e340bd6865bc5cf 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -2176,6 +2176,9 @@ fn analyzeNavType(
     return .{ .type_changed = true };
 }
 
+/// If `func_index` is not a runtime function (e.g. it has a comptime-only parameter type) then it
+/// is still valid to call this function and use its `func_body` unit in general---analysis of the
+/// runtime function body will simply fail.
 pub fn ensureFuncBodyUpToDate(
     pt: Zcu.PerThread,
     func_index: InternPool.Index,
@@ -2278,29 +2281,6 @@ fn analyzeFuncBody(
     const func = zcu.funcInfo(func_index);
     const anal_unit = AnalUnit.wrap(.{ .func = func_index });
 
-    // Make sure that this function is still owned by the same `Nav`. Otherwise, analyzing
-    // it would be a waste of time in the best case, and could cause codegen to give bogus
-    // results in the worst case.
-
-    if (func.generic_owner == .none) {
-        // Among another things, this ensures that the function's `zir_body_inst` is correct.
-        try pt.ensureNavValUpToDate(func.owner_nav, reason);
-        if (ip.getNav(func.owner_nav).status.fully_resolved.val != func_index) {
-            // This function is no longer referenced! There's no point in re-analyzing it.
-            // Just mark a transitive failure and move on.
-            return error.AnalysisFail;
-        }
-    } else {
-        const go_nav = zcu.funcInfo(func.generic_owner).owner_nav;
-        // Among another things, this ensures that the function's `zir_body_inst` is correct.
-        try pt.ensureNavValUpToDate(go_nav, reason);
-        if (ip.getNav(go_nav).status.fully_resolved.val != func.generic_owner) {
-            // The generic owner is no longer referenced, so this function is also unreferenced.
-            // There's no point in re-analyzing it. Just mark a transitive failure and move on.
-            return error.AnalysisFail;
-        }
-    }
-
     // We'll want to remember what the IES used to be before the update for
     // dependency invalidation purposes.
     const old_resolved_ies = if (func.analysisUnordered(ip).inferred_error_set)
@@ -3263,29 +3243,25 @@ fn analyzeFuncBodyInner(
 
     const anal_unit = AnalUnit.wrap(.{ .func = func_index });
     const func = zcu.funcInfo(func_index);
-    const inst_info = func.zir_body_inst.resolveFull(ip) orelse return error.AnalysisFail;
-    const file = zcu.fileByIndex(inst_info.file);
+
+    // This is the `Nav` corresponding to the `declaration` instruction which the function or its generic owner originates from.
+    const decl_analysis = if (func.generic_owner == .none)
+        ip.getNav(func.owner_nav).analysis.?
+    else
+        ip.getNav(zcu.funcInfo(func.generic_owner).owner_nav).analysis.?;
+
+    const file = zcu.fileByIndex(decl_analysis.zir_index.resolveFile(ip));
     const zir = file.zir.?;
 
     try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, reason);
     defer assert(zcu.analysis_in_progress.swapRemove(anal_unit));
 
-    if (func.analysisUnordered(ip).inferred_error_set) {
-        func.setResolvedErrorSet(ip, io, .none);
-    }
-
     if (zcu.comp.time_report) |*tr| {
         if (func.generic_owner != .none) {
             tr.stats.n_generic_instances += 1;
         }
     }
 
-    // This is the `Nau` corresponding to the `declaration` instruction which the function or its generic owner originates from.
-    const decl_nav = ip.getNav(if (func.generic_owner == .none)
-        func.owner_nav
-    else
-        zcu.funcInfo(func.generic_owner).owner_nav);
-
     const func_nav = ip.getNav(func.owner_nav);
 
     var analysis_arena = std.heap.ArenaAllocator.init(gpa);
@@ -3319,9 +3295,30 @@ fn analyzeFuncBodyInner(
 
     // Every runtime function has a dependency on the source of the Decl it originates from.
     // It also depends on the value of its owner Decl.
-    try sema.declareDependency(.{ .src_hash = decl_nav.analysis.?.zir_index });
+    try sema.declareDependency(.{ .src_hash = decl_analysis.zir_index });
     try sema.declareDependency(.{ .nav_val = func.owner_nav });
 
+    // Make sure that the declaration `Nav` still refers to this function (or its generic owner).
+    // This will not be the case if the incremental update has changed a function type or turned a
+    // `fn` decl into some other declaration. In that case, we must not run analysis: this function
+    // will not be referenced this update, and trying to generate it could be problematic since we
+    // assume the owner NAV actually, um, owns us.
+    //
+    // If we *are* still owned by the right NAV, this analysis updates `zir_body_inst` if necessary.
+
+    if (func.generic_owner == .none) {
+        try pt.ensureNavValUpToDate(func.owner_nav, reason);
+        if (ip.getNav(func.owner_nav).status.fully_resolved.val != func_index) {
+            return error.AnalysisFail;
+        }
+    } else {
+        const go_nav = zcu.funcInfo(func.generic_owner).owner_nav;
+        try pt.ensureNavValUpToDate(go_nav, reason);
+        if (ip.getNav(go_nav).status.fully_resolved.val != func.generic_owner) {
+            return error.AnalysisFail;
+        }
+    }
+
     if (func.analysisUnordered(ip).inferred_error_set) {
         const ies = try analysis_arena.allocator().create(Sema.InferredErrorSet);
         ies.* = .{ .func = func_index };
@@ -3339,11 +3336,11 @@ fn analyzeFuncBodyInner(
     var inner_block: Sema.Block = .{
         .parent = null,
         .sema = &sema,
-        .namespace = decl_nav.analysis.?.namespace,
+        .namespace = decl_analysis.namespace,
         .instructions = .empty,
         .inlining = null,
         .comptime_reason = null,
-        .src_base_inst = decl_nav.analysis.?.zir_index,
+        .src_base_inst = decl_analysis.zir_index,
         .type_name_ctx = func_nav.fqn,
     };
     defer inner_block.instructions.deinit(gpa);
@@ -3385,6 +3382,13 @@ fn analyzeFuncBodyInner(
         const param_ty: Type = .fromInterned(fn_ty_info.param_types.get(ip)[runtime_param_index]);
         runtime_param_index += 1;
 
+        if (param_ty.isGenericPoison()) {
+            // We're guaranteed to get a compile error on the `fnHasRuntimeBits` check after this
+            // loop (the generic poison means this is a generic function). But `continue` here to
+            // avoid an illegal call to `onePossibleValue` below.
+            continue;
+        }
+
         const param_ty_src = inner_block.src(.{ .func_decl_param_ty = @intCast(zir_param_index) });
 
         try sema.ensureLayoutResolved(param_ty, param_ty_src, .parameter);
@@ -3406,6 +3410,23 @@ fn analyzeFuncBodyInner(
 
     try sema.ensureLayoutResolved(sema.fn_ret_ty, inner_block.src(.{ .node_offset_fn_type_ret_ty = .zero }), .return_type);
 
+    // The function type is now resolved, so we're ready to check whether it even makes sense to ask
+    // for it to be analyzed at runtime.
+    if (!fn_ty.fnHasRuntimeBits(zcu)) {
+        const description: []const u8 = switch (fn_ty_info.cc) {
+            .@"inline" => "inline",
+            else => "generic",
+        };
+        // This error makes sense because the only reason this analysis would ever be requested is
+        // for IES resolution.
+        return sema.fail(
+            &inner_block,
+            inner_block.nodeOffset(.zero),
+            "cannot resolve inferred error set of {s} function type '{f}'",
+            .{ description, fn_ty.fmt(pt) },
+        );
+    }
+
     const last_arg_index = inner_block.instructions.items.len;
 
     // Save the error trace as our first action in the function.
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index b31b0a40da9a5c9663bf7d3392bef966e6eed1a9..13e07dfcd05aa6a3f31b7de7ee49805f1225cecc 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -2112,7 +2112,7 @@ pub fn genTagNameFn(
     const loaded_enum = ip.loadEnumType(enum_ty.toIntern());
     assert(loaded_enum.field_names.len > 0);
     if (Type.fromInterned(loaded_enum.int_tag_type).bitSize(zcu) > 64) {
-        @panic("TODO CBE: tagName for enum over 128 bits");
+        @panic("TODO CBE: tagName for enum over 64 bits");
     }
 
     try w.print("static {s} zig_tagName_{f}__{d}({s} tag) {{\n", .{
@@ -2130,10 +2130,10 @@ pub fn genTagNameFn(
     try w.writeAll(" switch (tag) {\n");
     const field_values = loaded_enum.field_values.get(ip);
     for (loaded_enum.field_names.get(ip), 0..) |field_name, field_index| {
-        const field_int: u64 = int: {
+        const field_int: i65 = int: {
             if (field_values.len == 0) break :int field_index;
             const field_val: Value = .fromInterned(field_values[field_index]);
-            break :int field_val.toUnsignedInt(zcu);
+            break :int field_val.getUnsignedInt(zcu) orelse field_val.toSignedInt(zcu);
         };
         try w.print("  case {d}: return ({s}){{name{d},{d}}};\n", .{
             field_int,
@@ -3278,7 +3278,10 @@ fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue {
     const operand_ty = f.typeOf(ty_op.operand);
     const scalar_ty = operand_ty.scalarType(zcu);
 
-    if (f.dg.intCastIsNoop(inst_scalar_ty, scalar_ty)) return f.moveCValue(inst, inst_ty, operand);
+    // `intCastIsNoop` doesn't apply to vectors because every vector lowers to a different C struct.
+    if (inst_ty.zigTypeTag(zcu) != .vector and f.dg.intCastIsNoop(inst_scalar_ty, scalar_ty)) {
+        return f.moveCValue(inst, inst_ty, operand);
+    }
 
     const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
@@ -3491,6 +3494,8 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info:
     const operand_ty = f.typeOf(bin_op.lhs);
     const scalar_ty = operand_ty.scalarType(zcu);
 
+    const ref_arg = lowersToBigInt(scalar_ty, zcu);
+
     const w = &f.code.writer;
     const local = try f.allocLocal(inst, inst_ty);
     const v = try Vectorize.start(f, inst, w, operand_ty);
@@ -3504,9 +3509,11 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info:
     try f.writeCValueMember(w, local, .{ .field = 0 });
     try v.elem(f, w);
     try w.writeAll(", ");
+    if (ref_arg) try w.writeByte('&');
     try f.writeCValue(w, lhs, .other);
     try v.elem(f, w);
     try w.writeAll(", ");
+    if (ref_arg) try w.writeByte('&');
     try f.writeCValue(w, rhs, .other);
     if (f.typeOf(bin_op.rhs).isVector(zcu)) try v.elem(f, w);
     try f.dg.renderBuiltinInfo(w, scalar_ty, info);
diff --git a/src/codegen/c/type.zig b/src/codegen/c/type.zig
index 64e63e4d6733980ea6cca735f53c82cb041e36d8..7a12a343f999179845a96febeaa15557605162e1 100644
--- a/src/codegen/c/type.zig
+++ b/src/codegen/c/type.zig
@@ -898,13 +898,23 @@ pub const CType = union(enum) {
                     try w.writeAll("fn_"); // intentional double underscore to start
                     for (func_type.param_types.get(ip)) |param_ty_ip| {
                         const param_ty: Type = .fromInterned(param_ty_ip);
-                        try w.print("_P{f}", .{fmtZigType(param_ty, zcu)});
+                        if (param_ty.isGenericPoison()) {
+                            try w.writeAll("_Pgeneric");
+                        } else {
+                            try w.print("_P{f}", .{fmtZigType(param_ty, zcu)});
+                        }
                     }
                     if (func_type.is_var_args) {
                         try w.writeAll("_VA");
                     }
                     const ret_ty: Type = .fromInterned(func_type.return_type);
-                    try w.print("_R{f}", .{fmtZigType(ret_ty, zcu)});
+                    if (ret_ty.isGenericPoison()) {
+                        try w.writeAll("_Rgeneric");
+                    } else if (ret_ty.zigTypeTag(zcu) == .error_union and ret_ty.errorUnionPayload(zcu).isGenericPoison()) {
+                        try w.writeAll("_Rgeneric_ies");
+                    } else {
+                        try w.print("_R{f}", .{fmtZigType(ret_ty, zcu)});
+                    }
                 },
 
                 .vector => try w.print("vec_{d}_{f}", .{
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 009e472d06f4229c067d4e96f0dee78bc0f22aa3..938706a42b82cdaf8639cd58738bd0fc3ad613a7 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3436,9 +3436,9 @@ pub const Object = struct {
         }
 
         if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) {
-            const stack_trace_ty = zcu.builtin_decl_values.get(.StackTrace);
-            const ptr_ty = try pt.ptrType(.{ .child = stack_trace_ty });
-            try llvm_params.append(o.gpa, try o.lowerType(pt, ptr_ty));
+            // First parameter is a pointer to `std.builtin.StackTrace`.
+            const llvm_ptr_ty = try o.builder.ptrType(toLlvmAddressSpace(.generic, target));
+            try llvm_params.append(o.gpa, llvm_ptr_ty);
         }
 
         var it = iterateParamTypes(o, pt, fn_info);
@@ -6719,16 +6719,11 @@ pub const FuncGen = struct {
         const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = ptr_ty.childType(zcu);
+        const elem_ty = ptr_ty.indexableElem(zcu);
         const llvm_elem_ty = try o.lowerType(pt, elem_ty);
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
-        // TODO: when we go fully opaque pointers in LLVM 16 we can remove this branch
-        const ptr = try self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, if (ptr_ty.isSinglePointer(zcu))
-            // If this is a single-item pointer to an array, we need another index in the GEP.
-            &.{ try o.builder.intValue(try o.lowerType(pt, Type.usize), 0), rhs }
-        else
-            &.{rhs}, "");
+        const ptr = try self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, &.{rhs}, "");
         if (isByRef(elem_ty, zcu)) {
             self.maybeMarkAllowZeroAccess(ptr_ty.ptrInfo(zcu));
             const ptr_align = (ptr_ty.ptrAlignment(zcu).min(elem_ty.abiAlignment(zcu))).toLlvm();
@@ -6808,11 +6803,6 @@ pub const FuncGen = struct {
                             const truncated_int =
                                 try self.wip.cast(.trunc, shifted_value, same_size_int, "");
                             return self.wip.cast(.bitcast, truncated_int, elem_llvm_ty, "");
-                        } else if (field_ty.isPtrAtRuntime(zcu)) {
-                            const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
-                            const truncated_int =
-                                try self.wip.cast(.trunc, shifted_value, same_size_int, "");
-                            return self.wip.cast(.inttoptr, truncated_int, elem_llvm_ty, "");
                         }
                         return self.wip.cast(.trunc, shifted_value, elem_llvm_ty, "");
                     },
@@ -6830,11 +6820,6 @@ pub const FuncGen = struct {
                         const truncated_int =
                             try self.wip.cast(.trunc, containing_int, same_size_int, "");
                         return self.wip.cast(.bitcast, truncated_int, elem_llvm_ty, "");
-                    } else if (field_ty.isPtrAtRuntime(zcu)) {
-                        const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
-                        const truncated_int =
-                            try self.wip.cast(.trunc, containing_int, same_size_int, "");
-                        return self.wip.cast(.inttoptr, truncated_int, elem_llvm_ty, "");
                     }
                     return self.wip.cast(.trunc, containing_int, elem_llvm_ty, "");
                 },
@@ -10110,7 +10095,7 @@ pub const FuncGen = struct {
         const ip = &zcu.intern_pool;
         const enum_type = ip.loadEnumType(enum_ty.toIntern());
 
-        // TODO: detect when the type changes and re-emit this function.
+        // TODO: detect when the type changes (`updateContainerType` will be called) and re-emit this function
         const gop = try o.named_enum_map.getOrPut(o.gpa, enum_ty.toIntern());
         if (gop.found_existing) return gop.value_ptr.*;
         errdefer assert(o.named_enum_map.remove(enum_ty.toIntern()));
@@ -10728,10 +10713,7 @@ pub const FuncGen = struct {
             const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
             const non_int_val = try self.resolveInst(extra.init);
             const small_int_ty = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
-            const small_int_val = if (field_ty.isPtrAtRuntime(zcu))
-                try self.wip.cast(.ptrtoint, non_int_val, small_int_ty, "")
-            else
-                try self.wip.cast(.bitcast, non_int_val, small_int_ty, "");
+            const small_int_val = try self.wip.cast(.bitcast, non_int_val, small_int_ty, "");
             return self.wip.conv(.unsigned, small_int_val, int_llvm_ty, "");
         }
 
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index d09012fe948ba1a70b1b93fb99a8966abf89c8bc..97fb0294eb617c509e965995587ee6049a661941 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -2252,6 +2252,12 @@ pub const WipNav = struct {
                     .generic_decl_const,
                     .generic_decl_func,
                     => true,
+
+                    // This comes from a decl which was previously generated as an incomplete value
+                    // (I think that must mean either a function or an extern which previously had
+                    // incomplete types).
+                    .undefined_comptime_value => false,
+
                     else => |t| std.debug.panic("bad decl abbrev code: {t}", .{t}),
                 };
             if (parent_type.getCaptures(zcu).len == 0) {
diff --git a/src/print_value.zig b/src/print_value.zig
index 46fbe63a6b12c2d755efffb62c2ef98a590af966..626a11e1b335a197b855af6051e03adf760fba99 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -113,7 +113,7 @@ pub fn print(
                 if (slice.len == .zero_usize) {
                     return writer.writeAll("&.{}");
                 }
-                try print(.fromInterned(slice.ptr), writer, level - 1, pt, opt_sema);
+                try print(.fromInterned(slice.ptr), writer, level, pt, opt_sema);
             } else {
                 const print_contents = switch (ip.getBackingAddrTag(slice.ptr).?) {
                     .field, .arr_elem, .eu_payload, .opt_payload => unreachable,
@@ -170,6 +170,9 @@ pub fn print(
             }
         },
         .bitpack => |bitpack| {
+            if (level == 0) {
+                return writer.writeAll(".{ ... }");
+            }
             const ty: Type = .fromInterned(bitpack.ty);
             switch (ty.zigTypeTag(zcu)) {
                 .@"struct" => {
@@ -464,18 +467,30 @@ pub fn printPtrDerivation(
             .uav_ptr => |uav| {
                 const ty = Value.fromInterned(uav.val).typeOf(zcu);
                 try writer.print("@as({f}, ", .{ty.fmt(pt)});
-                try print(Value.fromInterned(uav.val), writer, x.level - 1, pt, x.opt_sema);
+                if (x.level == 0) {
+                    try writer.writeAll("...");
+                } else {
+                    try print(Value.fromInterned(uav.val), writer, x.level - 1, pt, x.opt_sema);
+                }
                 try writer.writeByte(')');
             },
             .comptime_alloc_ptr => |info| {
                 try writer.print("@as({f}, ", .{info.val.typeOf(zcu).fmt(pt)});
-                try print(info.val, writer, x.level - 1, pt, x.opt_sema);
+                if (x.level == 0) {
+                    try writer.writeAll("...");
+                } else {
+                    try print(info.val, writer, x.level - 1, pt, x.opt_sema);
+                }
                 try writer.writeByte(')');
             },
             .comptime_field_ptr => |val| {
                 const ty = val.typeOf(zcu);
                 try writer.print("@as({f}, ", .{ty.fmt(pt)});
-                try print(val, writer, x.level - 1, pt, x.opt_sema);
+                if (x.level == 0) {
+                    try writer.writeAll("...");
+                } else {
+                    try print(val, writer, x.level - 1, pt, x.opt_sema);
+                }
                 try writer.writeByte(')');
             },
             else => unreachable,
-- 
2.54.0


From 6d997ebe47d91641e70971bf3c227df6cbae041a Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 1 Mar 2026 19:18:04 +0000
Subject: [PATCH 474/499] tests: get cases passing (and a few other bits)

---
 test/c_abi/main.zig                           |    4 +-
 .../compile_errors/@import_zon_bad_type.zig   |    8 +-
 .../compile_errors/@import_zon_opt_in_err.zig |   20 +-
 .../@import_zon_opt_in_err_struct.zig         |    8 +-
 .../@intFromPtr_with_bad_type.zig             |    9 -
 ..._ABI_compatible_type_or_has_align_attr.zig |   12 -
 .../compile_errors/aggregate_too_large.zig    |   16 +-
 .../cases/compile_errors/alignOf_bad_type.zig |    2 +-
 test/cases/compile_errors/align_zero.zig      |    8 +-
 .../assign_inline_fn_to_non-comptime_var.zig  |   10 -
 .../compile_errors/bit_ptr_non_packed.zig     |    8 +-
 ...of_packed_struct_checks_backing_int_ty.zig |    4 +-
 .../compile_errors/c_pointer_to_void.zig      |    9 -
 .../call_runtime_known_inline_fn_ptr.zig      |   11 +
 .../compile_errors/coerce_int_to_float.zig    |   12 +-
 .../comptime_var_referenced_by_type.zig       |    2 +-
 .../compile_errors/direct_struct_loop.zig     |    2 +-
 ...edding_opaque_type_in_struct_and_union.zig |    6 +-
 .../enum_field_value_references_enum.zig      |   12 +-
 ..._value_references_nonexistent_circular.zig |    2 +-
 .../enum_value_already_taken.zig              |    4 +-
 .../compile_errors/error_set_membership.zig   |    3 +-
 ...ig => fn_body_in_struct_runtime_known.zig} |    0
 .../compile_errors/function_ptr_alignment.zig |    2 +-
 ...non-extern_non-packed_struct_parameter.zig |    2 +-
 ..._non-extern_non-packed_union_parameter.zig |    2 +-
 ...generic_function_returning_opaque_type.zig |    2 +-
 .../indexing_an_array_of_size_zero.zig        |    2 +-
 ..._array_of_size_zero_with_runtime_index.zig |    2 +-
 .../compile_errors/indirect_struct_loop.zig   |    6 +-
 .../compile_errors/initialize_empty_union.zig |   36 +-
 ...an_invalid_struct_that_contains_itself.zig |    2 +-
 ..._an_invalid_union_that_contains_itself.zig |    2 +-
 .../invalid_dependency_on_struct_size.zig     |   22 +-
 ...invalid_optional_type_in_extern_struct.zig |    4 +-
 .../invalid_pointer_arithmetic.zig            |    8 +-
 .../invalid_type_in_builtin_extern.zig        |   14 +-
 ...of_things_that_require_const_variables.zig |   41 +-
 ...xhaustive_enum_marker_assigned_a_value.zig |   11 -
 .../non-exhaustive_enum_missing_tag_type.zig  |   10 +
 ...-exhaustive_enum_specifies_every_value.zig |    2 +-
 ..._loop_on_a_type_that_requires_comptime.zig |    2 +-
 .../non_constant_expression_in_array_size.zig |    2 +-
 .../compile_errors/noreturn_struct_field.zig  |   10 -
 .../old_fn_ptr_in_extern_context.zig          |    6 -
 .../overflow_in_enum_value_allocation.zig     |    2 +-
 .../packed_struct_backing_int_wrong.zig       |    8 +-
 ...truct_with_fields_of_not_allowed_types.zig |   27 +-
 .../packed_union_fields_mismatch.zig          |   10 +-
 .../packed_union_given_enum_tag_type.zig      |   18 -
 ...union_with_fields_of_not_allowed_types.zig |   15 +-
 .../compile_errors/pointer_in_bitpack.zig     |   22 +
 .../reify_enum_with_duplicate_field.zig       |    7 +-
 .../reify_enum_with_duplicate_tag_value.zig   |    7 +-
 ...austive_enum_with_non-integer_tag_type.zig |    2 +-
 .../reify_type_for_tagged_packed_union.zig    |   11 -
 ...for_tagged_union_with_extra_enum_field.zig |    5 +-
 ..._for_tagged_union_with_no_union_fields.zig |    6 +-
 ...reify_type_for_union_with_opaque_field.zig |    8 +-
 ...eify_type_with_invalid_field_alignment.zig |    8 +-
 ...solve_inferred_error_set_of_generic_fn.zig |    3 +-
 ...time_@ptrFromInt_to_comptime_only_type.zig |    5 +-
 ...time_index_into_comptime_only_many_ptr.zig |    6 +-
 ...runtime_index_into_comptime_type_slice.zig |    3 +-
 .../runtime_indexing_comptime_array.zig       |    6 +-
 .../runtime_operation_in_comptime_scope.zig   |    8 +-
 ...f_referential_struct_requires_comptime.zig |    1 -
 ...lf_referential_union_requires_comptime.zig |    1 -
 test/cases/compile_errors/sizeOf_bad_type.zig |    2 +
 .../sizeof_alignof_empty_union.zig            |   24 +-
 .../slice_used_as_extern_fn_param.zig         |    2 +-
 ...pecify_enum_tag_type_that_is_too_small.zig |   18 +-
 ..._comptime_only_type_to_runtime_pointer.zig |   11 +-
 ...epends_on_itself_via_non_initial_field.zig |    4 +-
 ...t_depends_on_itself_via_optional_field.zig |    5 +-
 .../struct_depends_on_pointer_alignment.zig   |   11 -
 .../compile_errors/too_big_packed_struct.zig  |    2 +-
 .../top_level_decl_dependency_loop.zig        |    7 +-
 .../unable_to_evaluate_comptime_expr.zig      |   19 -
 .../compile_errors/undef_arith_is_illegal.zig | 3016 ++++++++---------
 .../undef_arith_returns_undef.zig             | 3000 ++++++++--------
 .../undef_shifts_are_illegal.zig              | 1174 +++----
 .../union_auto-enum_value_already_taken.zig   |    4 +-
 .../union_depends_on_pointer_alignment.zig    |   11 -
 .../union_enum_field_missing.zig              |    5 +-
 ...on_field_ordered_differently_than_enum.zig |    7 +-
 .../union_noreturn_field_initialized.zig      |   12 +-
 .../union_with_specified_enum_omits_field.zig |    5 +-
 ...ith_too_small_explicit_signed_tag_type.zig |    3 +-
 ...h_too_small_explicit_unsigned_tag_type.zig |    3 +-
 .../untagged_union_integer_conversion.zig     |    2 +-
 .../variadic_arg_validation.zig               |    2 +-
 .../zero_width_nonexhaustive_enum.zig         |   15 +-
 test/incremental/change_enum_tag_type         |    2 +-
 94 files changed, 3919 insertions(+), 3998 deletions(-)
 delete mode 100644 test/cases/compile_errors/@intFromPtr_with_bad_type.zig
 delete mode 100644 test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
 delete mode 100644 test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
 delete mode 100644 test/cases/compile_errors/c_pointer_to_void.zig
 create mode 100644 test/cases/compile_errors/call_runtime_known_inline_fn_ptr.zig
 rename test/cases/compile_errors/{AstGen_comptime_known_struct_is_resolved_before_error.zig => fn_body_in_struct_runtime_known.zig} (100%)
 create mode 100644 test/cases/compile_errors/non-exhaustive_enum_missing_tag_type.zig
 delete mode 100644 test/cases/compile_errors/noreturn_struct_field.zig
 delete mode 100644 test/cases/compile_errors/packed_union_given_enum_tag_type.zig
 create mode 100644 test/cases/compile_errors/pointer_in_bitpack.zig
 delete mode 100644 test/cases/compile_errors/reify_type_for_tagged_packed_union.zig
 delete mode 100644 test/cases/compile_errors/struct_depends_on_pointer_alignment.zig
 delete mode 100644 test/cases/compile_errors/union_depends_on_pointer_alignment.zig

diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig
index 5d02e5e87dda46805e24dd64bb3e741dff161e60..218c75189e11ac0f9369ea8de3cf865766a8b7fe 100644
--- a/test/c_abi/main.zig
+++ b/test/c_abi/main.zig
@@ -718,7 +718,7 @@ export fn zig_med_struct_ints(s: MedStructInts) void {
     expect(s.z == 3) catch @panic("test failure");
 }
 
-const SmallPackedStruct = packed struct {
+const SmallPackedStruct = packed struct(u8) {
     a: u2,
     b: u2,
     c: u2,
@@ -744,7 +744,7 @@ test "C ABI small packed struct" {
     try expect(s2.d == 3);
 }
 
-const BigPackedStruct = packed struct {
+const BigPackedStruct = packed struct(u128) {
     a: u64,
     b: u64,
 };
diff --git a/test/cases/compile_errors/@import_zon_bad_type.zig b/test/cases/compile_errors/@import_zon_bad_type.zig
index 9fe3c887213b9f8972ee829c90f6c0e69fa6b53d..bcb1de5d4249cbdb50ba3ae7de4acb8395954602 100644
--- a/test/cases/compile_errors/@import_zon_bad_type.zig
+++ b/test/cases/compile_errors/@import_zon_bad_type.zig
@@ -116,13 +116,13 @@ export fn testMutablePointer() void {
 // tmp.zig:85:26: note: ZON does not allow nested optionals
 // tmp.zig:90:29: error: type '*i32' is not available in ZON
 // tmp.zig:90:29: note: ZON does not allow mutable pointers
-// neg_inf.zon:1:1: error: expected type '@EnumLiteral()'
-// tmp.zig:37:38: note: imported here
 // neg_inf.zon:1:1: error: expected type '?u8'
 // tmp.zig:57:28: note: imported here
+// neg_inf.zon:1:1: error: expected type '@EnumLiteral()'
+// tmp.zig:37:38: note: imported here
 // neg_inf.zon:1:1: error: expected type 'tmp.E'
 // tmp.zig:63:26: note: imported here
-// neg_inf.zon:1:1: error: expected type 'tmp.U'
-// tmp.zig:69:26: note: imported here
 // neg_inf.zon:1:1: error: expected type 'tmp.EU'
 // tmp.zig:75:27: note: imported here
+// neg_inf.zon:1:1: error: expected type 'tmp.U'
+// tmp.zig:69:26: note: imported here
diff --git a/test/cases/compile_errors/@import_zon_opt_in_err.zig b/test/cases/compile_errors/@import_zon_opt_in_err.zig
index 29cf412eab32989359bd57ed259598865064337a..f975a3fa1e25d53facf9f2366dcfac1004387a95 100644
--- a/test/cases/compile_errors/@import_zon_opt_in_err.zig
+++ b/test/cases/compile_errors/@import_zon_opt_in_err.zig
@@ -58,25 +58,25 @@ export fn testVector() void {
 // error
 // imports=zon/vec2.zon
 //
-// vec2.zon:1:2: error: expected type '?f32'
-// tmp.zig:2:29: note: imported here
 // vec2.zon:1:2: error: expected type '*const ?f32'
 // tmp.zig:7:36: note: imported here
 // vec2.zon:1:2: error: expected type '?*const f32'
 // tmp.zig:12:36: note: imported here
+// vec2.zon:1:2: error: expected type '?@EnumLiteral()'
+// tmp.zig:33:39: note: imported here
+// vec2.zon:1:2: error: expected type '?@Vector(3, f32)'
+// tmp.zig:54:41: note: imported here
+// vec2.zon:1:2: error: expected type '?[1]u8'
+// tmp.zig:38:31: note: imported here
+// vec2.zon:1:2: error: expected type '?[]const u8'
+// tmp.zig:49:36: note: imported here
 // vec2.zon:1:2: error: expected type '?bool'
 // tmp.zig:17:30: note: imported here
+// vec2.zon:1:2: error: expected type '?f32'
+// tmp.zig:2:29: note: imported here
 // vec2.zon:1:2: error: expected type '?i32'
 // tmp.zig:22:29: note: imported here
 // vec2.zon:1:2: error: expected type '?tmp.Enum'
 // tmp.zig:28:30: note: imported here
-// vec2.zon:1:2: error: expected type '?@EnumLiteral()'
-// tmp.zig:33:39: note: imported here
-// vec2.zon:1:2: error: expected type '?[1]u8'
-// tmp.zig:38:31: note: imported here
 // vec2.zon:1:2: error: expected type '?tmp.Union'
 // tmp.zig:44:31: note: imported here
-// vec2.zon:1:2: error: expected type '?[]const u8'
-// tmp.zig:49:36: note: imported here
-// vec2.zon:1:2: error: expected type '?@Vector(3, f32)'
-// tmp.zig:54:41: note: imported here
diff --git a/test/cases/compile_errors/@import_zon_opt_in_err_struct.zig b/test/cases/compile_errors/@import_zon_opt_in_err_struct.zig
index a284fd7c6dd6e2eac930fe48f74ad3fcff3d364a..a931f5a8cd305ae33bcc9e68ca296c74406134a7 100644
--- a/test/cases/compile_errors/@import_zon_opt_in_err_struct.zig
+++ b/test/cases/compile_errors/@import_zon_opt_in_err_struct.zig
@@ -13,7 +13,7 @@ export fn testTuple() void {
 // error
 // imports=zon/nan.zon
 //
-//nan.zon:1:1: error: expected type '?tmp.Struct'
-//tmp.zig:3:32: note: imported here
-//nan.zon:1:1: error: expected type '?struct { bool }'
-//tmp.zig:9:31: note: imported here
+// nan.zon:1:1: error: expected type '?struct { bool }'
+// tmp.zig:9:31: note: imported here
+// nan.zon:1:1: error: expected type '?tmp.Struct'
+// tmp.zig:3:32: note: imported here
diff --git a/test/cases/compile_errors/@intFromPtr_with_bad_type.zig b/test/cases/compile_errors/@intFromPtr_with_bad_type.zig
deleted file mode 100644
index ec98c1bc14425d91c36a56735502cdefc5d0eba4..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/@intFromPtr_with_bad_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const x = 42;
-const y = @intFromPtr(&x);
-pub export fn entry() void {
-    _ = y;
-}
-
-// error
-//
-// :2:23: error: comptime-only type 'comptime_int' has no pointer address
diff --git a/test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig b/test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
deleted file mode 100644
index a578ebd84b758fb18e4f688982f917dc5639a0b1..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = struct { a: u32 };
-export fn a() void {
-    const T = [*c]Foo;
-    const t: T = undefined;
-    _ = t;
-}
-
-// error
-//
-// :3:19: error: C pointers cannot point to non-C-ABI-compatible type 'tmp.Foo'
-// :3:19: note: only extern structs and ABI sized packed structs are extern compatible
-// :1:13: note: struct declared here
diff --git a/test/cases/compile_errors/aggregate_too_large.zig b/test/cases/compile_errors/aggregate_too_large.zig
index 4a4daeda939c6711fd1dd31ece3ad396f838815c..ecab43d01109669047fc167d811df43456df0105 100644
--- a/test/cases/compile_errors/aggregate_too_large.zig
+++ b/test/cases/compile_errors/aggregate_too_large.zig
@@ -12,16 +12,14 @@ const U = union {
     b: [1 << 32]u8,
 };
 
-const V = union {
-    a: u32,
-    b: T,
-};
-
 comptime {
-    _ = S;
-    _ = T;
-    _ = U;
-    _ = V;
+    _ = @as(S, undefined);
+}
+comptime {
+    _ = @as(T, undefined);
+}
+comptime {
+    _ = @as(U, undefined);
 }
 
 // error
diff --git a/test/cases/compile_errors/alignOf_bad_type.zig b/test/cases/compile_errors/alignOf_bad_type.zig
index 93dcfa3b94922a74c2edb4720cd0232ddabbb795..4689fad821bd31e66f136101d1d1612c153ec9d0 100644
--- a/test/cases/compile_errors/alignOf_bad_type.zig
+++ b/test/cases/compile_errors/alignOf_bad_type.zig
@@ -9,5 +9,5 @@ export fn entry1() usize {
 // error
 //
 // :2:21: error: no align available for uninstantiable type 'noreturn'
-// :6:21: error: no align available for uninstantiable type 'alignOf_bad_type.S'
+// :6:21: error: no align available for uninstantiable type 'tmp.S'
 // :4:11: note: struct declared here
diff --git a/test/cases/compile_errors/align_zero.zig b/test/cases/compile_errors/align_zero.zig
index 632d146dc5c44ce161c54a425c7755f8686ba3f2..7b68dee5e44e13cf94437d5c885f8831befa9f8f 100644
--- a/test/cases/compile_errors/align_zero.zig
+++ b/test/cases/compile_errors/align_zero.zig
@@ -30,11 +30,11 @@ export fn g() void {
 }
 
 export fn h() void {
-    _ = struct { field: i32 align(0) };
+    _ = @as(struct { field: i32 align(0) }, undefined);
 }
 
 export fn i() void {
-    _ = union { field: i32 align(0) };
+    _ = @as(union { field: i32 align(0) }, undefined);
 }
 
 export fn j() void {
@@ -54,7 +54,7 @@ export fn k() void {
 // :20:30: error: alignment must be >= 1
 // :25:16: error: alignment must be >= 1
 // :29:17: error: alignment must be >= 1
-// :33:35: error: alignment must be >= 1
-// :37:34: error: alignment must be >= 1
+// :33:39: error: alignment must be >= 1
+// :37:38: error: alignment must be >= 1
 // :41:51: error: alignment must be >= 1
 // :45:25: error: alignment must be >= 1
diff --git a/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig b/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
deleted file mode 100644
index ee666a028b1c633f35ae87e3de37ae0ff5126048..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var a = &b;
-    _ = &a;
-}
-inline fn b() void {}
-
-// error
-//
-// :2:9: error: variable of type '*const fn () callconv(.@"inline") void' must be const or comptime
-// :2:9: note: function has inline calling convention
diff --git a/test/cases/compile_errors/bit_ptr_non_packed.zig b/test/cases/compile_errors/bit_ptr_non_packed.zig
index 2b8190836906e8f6975d135d7bdce0452de2c90c..706dc12b9963168cd79d4fc474c4e73fe129dbcd 100644
--- a/test/cases/compile_errors/bit_ptr_non_packed.zig
+++ b/test/cases/compile_errors/bit_ptr_non_packed.zig
@@ -16,7 +16,11 @@ export fn entry3() void {
 // error
 //
 // :3:23: error: bit-pointer cannot refer to value of type 'tmp.entry1.S'
-// :3:23: note: only packed structs layout are allowed in packed types
+// :3:23: note: non-packed structs do not have a bit-packed representation
+// :2:22: note: struct declared here
 // :8:36: error: bit-pointer cannot refer to value of type 'tmp.entry2.S'
-// :8:36: note: only packed structs layout are allowed in packed types
+// :8:36: note: non-packed structs do not have a bit-packed representation
+// :7:15: note: struct declared here
 // :13:23: error: bit-pointer cannot refer to value of type 'tmp.entry3.E'
+// :12:15: note: integer tag type of enum is inferred
+// :12:15: note: consider explicitly specifying the integer tag type
diff --git a/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig b/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
index 9ee45b63565e0df5f6ceaa981c21f39578964ae4..f833ee08fe3056eb66d7d88feef4537a0a8a540e 100644
--- a/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
+++ b/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
@@ -8,4 +8,6 @@ pub export fn entry() void {
 
 // error
 //
-// :1:27: error: backing integer type 'u32' has bit size 32 but the struct fields have a total bit size of 1
+// :1:20: error: backing integer bit width does not match total bit width of fields
+// :1:27: note: backing integer 'u32' has bit width '32'
+// :1:20: note: struct fields have total bit width '1'
diff --git a/test/cases/compile_errors/c_pointer_to_void.zig b/test/cases/compile_errors/c_pointer_to_void.zig
deleted file mode 100644
index 4a532a22ae1f1e914bd669294bb90513f65e6dc5..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/c_pointer_to_void.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    const a: [*c]void = undefined;
-    _ = a;
-}
-
-// error
-//
-// :2:18: error: C pointers cannot point to non-C-ABI-compatible type 'void'
-// :2:18: note: 'void' is a zero bit type; for C 'void' use 'anyopaque'
diff --git a/test/cases/compile_errors/call_runtime_known_inline_fn_ptr.zig b/test/cases/compile_errors/call_runtime_known_inline_fn_ptr.zig
new file mode 100644
index 0000000000000000000000000000000000000000..635b169df01fdc2498c537160e47bdceea6e39cd
--- /dev/null
+++ b/test/cases/compile_errors/call_runtime_known_inline_fn_ptr.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    var a = &b;
+    a = a;
+    a();
+}
+inline fn b() void {}
+
+// error
+//
+// :4:5: error: unable to resolve comptime value
+// :4:5: note: function being called inline must be comptime-known
diff --git a/test/cases/compile_errors/coerce_int_to_float.zig b/test/cases/compile_errors/coerce_int_to_float.zig
index bd167b36ad2b7a1947e23a1f422a7a7882b4220f..d1bf6eb2be077f38245412ee237a9c84f8291fbe 100644
--- a/test/cases/compile_errors/coerce_int_to_float.zig
+++ b/test/cases/compile_errors/coerce_int_to_float.zig
@@ -40,13 +40,13 @@ export fn entry() void {
 
 // error
 //
-// :6:20: error: expected type 'f16', found 'u12'
+// :6:20: error: expected type 'f128', found 'i115'
+// :6:20: error: expected type 'f128', found 'u114'
 // :6:20: error: expected type 'f16', found 'i13'
-// :6:20: error: expected type 'f32', found 'u25'
+// :6:20: error: expected type 'f16', found 'u12'
 // :6:20: error: expected type 'f32', found 'i26'
-// :6:20: error: expected type 'f64', found 'u54'
+// :6:20: error: expected type 'f32', found 'u25'
 // :6:20: error: expected type 'f64', found 'i55'
-// :6:20: error: expected type 'f80', found 'u65'
+// :6:20: error: expected type 'f64', found 'u54'
 // :6:20: error: expected type 'f80', found 'i66'
-// :6:20: error: expected type 'f128', found 'u114'
-// :6:20: error: expected type 'f128', found 'i115'
+// :6:20: error: expected type 'f80', found 'u65'
diff --git a/test/cases/compile_errors/comptime_var_referenced_by_type.zig b/test/cases/compile_errors/comptime_var_referenced_by_type.zig
index 1b476d9cdef1af9269ebe8ef4619dbf6a67e6bc9..62af2aed48b7446d40ede9c59864e50e1fe2f309 100644
--- a/test/cases/compile_errors/comptime_var_referenced_by_type.zig
+++ b/test/cases/compile_errors/comptime_var_referenced_by_type.zig
@@ -21,6 +21,6 @@ comptime {
 // error
 //
 // :7:16: error: captured value contains reference to comptime var
-// :7:16: note: 'wrapper' points to '@as(*const tmp.Wrapper, @ptrCast(&v0)).*', where
+// :7:16: note: 'wrapper' points to 'v0', where
 // :16:5: note: 'v0.ptr' points to comptime var declared here
 // :17:29: note: called at comptime here
diff --git a/test/cases/compile_errors/direct_struct_loop.zig b/test/cases/compile_errors/direct_struct_loop.zig
index 4abd10da714e359a4b7561775df063c6e42bd1e6..e50867d36a943c4a7a7f121fa3ed86e5661ca49e 100644
--- a/test/cases/compile_errors/direct_struct_loop.zig
+++ b/test/cases/compile_errors/direct_struct_loop.zig
@@ -7,4 +7,4 @@ export fn entry() usize {
 
 // error
 //
-// :1:11: error: struct 'tmp.A' depends on itself
+// :2:8: error: type 'tmp.A' depends on itself for field declared here
diff --git a/test/cases/compile_errors/directly_embedding_opaque_type_in_struct_and_union.zig b/test/cases/compile_errors/directly_embedding_opaque_type_in_struct_and_union.zig
index 7c5085daf03627737f765638539c5c775bdfa732..ff3edd5fc96c339bbb84d1a981d4fead2e68a851 100644
--- a/test/cases/compile_errors/directly_embedding_opaque_type_in_struct_and_union.zig
+++ b/test/cases/compile_errors/directly_embedding_opaque_type_in_struct_and_union.zig
@@ -26,9 +26,11 @@ export fn d() void {
 
 // error
 //
-// :3:8: error: opaque types have unknown size and therefore cannot be directly embedded in structs
+// :3:8: error: cannot directly embed opaque type 'tmp.O' in struct
+// :3:8: note: opaque types have unknown size
 // :1:11: note: opaque declared here
-// :7:10: error: opaque types have unknown size and therefore cannot be directly embedded in unions
+// :7:10: error: cannot directly embed opaque type 'tmp.O' in union
+// :7:10: note: opaque types have unknown size
 // :1:11: note: opaque declared here
 // :18:24: error: cannot cast to opaque type 'tmp.O'
 // :1:11: note: opaque declared here
diff --git a/test/cases/compile_errors/enum_field_value_references_enum.zig b/test/cases/compile_errors/enum_field_value_references_enum.zig
index 29150487089ec1e4f45f50080dec181d8dd72141..ba07e80bf8e058d273f9beb151059f8914aa118a 100644
--- a/test/cases/compile_errors/enum_field_value_references_enum.zig
+++ b/test/cases/compile_errors/enum_field_value_references_enum.zig
@@ -1,15 +1,11 @@
 pub const Foo = enum(c_int) {
-    A = Foo.B,
-    C = D,
-
-    pub const B = 0;
+    a = 10,
+    b = @intFromEnum(Foo.a) - 1,
 };
 export fn entry() void {
-    const s: Foo = Foo.E;
-    _ = s;
+    _ = @as(Foo, .a);
 }
-const D = 1;
 
 // error
 //
-// :1:5: error: dependency loop detected
+// :3:25: error: type 'tmp.Foo' depends on itself for field usage here
diff --git a/test/cases/compile_errors/enum_field_value_references_nonexistent_circular.zig b/test/cases/compile_errors/enum_field_value_references_nonexistent_circular.zig
index d658876cf63ab6c11a1bbf6862f3e723681ec148..69b6111bbf98285ea7067260a4099e8cf00d4828 100644
--- a/test/cases/compile_errors/enum_field_value_references_nonexistent_circular.zig
+++ b/test/cases/compile_errors/enum_field_value_references_nonexistent_circular.zig
@@ -10,4 +10,4 @@ const D = 1;
 
 // error
 //
-// :1:5: error: dependency loop detected
+// :2:12: error: type 'tmp.Foo' depends on itself for field usage here
diff --git a/test/cases/compile_errors/enum_value_already_taken.zig b/test/cases/compile_errors/enum_value_already_taken.zig
index 30e332b3be2cf931b2353f61efa9b57bfc997a4e..b83217ce788d97a32bbc6cdb3f7d58dc0f92d98e 100644
--- a/test/cases/compile_errors/enum_value_already_taken.zig
+++ b/test/cases/compile_errors/enum_value_already_taken.zig
@@ -12,5 +12,5 @@ export fn entry() void {
 
 // error
 //
-// :6:9: error: enum tag value 60 already taken
-// :4:9: note: other occurrence here
+// :6:9: error: enum tag value '60' for field 'E' already taken
+// :4:9: note: previous occurrence in field 'C'
diff --git a/test/cases/compile_errors/error_set_membership.zig b/test/cases/compile_errors/error_set_membership.zig
index 96c50a8ee6dc806a118431db096498af97e9547b..5caf26d46921cba6a2bbde4abc87da90ca6a4d50 100644
--- a/test/cases/compile_errors/error_set_membership.zig
+++ b/test/cases/compile_errors/error_set_membership.zig
@@ -26,5 +26,6 @@ pub fn main() Error!void {
 // error
 // target=x86_64-linux
 //
-// :23:29: error: expected type 'error{InvalidCharacter}', found '@typeInfo(@typeInfo(@TypeOf(tmp.fooey)).@"fn".return_type.?).error_union.error_set'
+// :23:29: error: expected type 'error{InvalidCharacter}!void', found '@typeInfo(@typeInfo(@TypeOf(tmp.fooey)).@"fn".return_type.?).error_union.error_set'
 // :23:29: note: 'error.InvalidDirection' not a member of destination error set
+// :22:20: note: function return type declared here
diff --git a/test/cases/compile_errors/AstGen_comptime_known_struct_is_resolved_before_error.zig b/test/cases/compile_errors/fn_body_in_struct_runtime_known.zig
similarity index 100%
rename from test/cases/compile_errors/AstGen_comptime_known_struct_is_resolved_before_error.zig
rename to test/cases/compile_errors/fn_body_in_struct_runtime_known.zig
diff --git a/test/cases/compile_errors/function_ptr_alignment.zig b/test/cases/compile_errors/function_ptr_alignment.zig
index 66e80a95a6deaee73187dd3a4970685923d50a43..6396a08009a978d784698025616e9167eab397cf 100644
--- a/test/cases/compile_errors/function_ptr_alignment.zig
+++ b/test/cases/compile_errors/function_ptr_alignment.zig
@@ -11,5 +11,5 @@ comptime {
 // error
 // target=x86_64-linux
 //
-// :8:41: error: expected type '*align(2) const fn () void', found '*const fn () void'
+// :8:41: error: expected type '*align(2) const fn () void', found '*align(1) const fn () void'
 // :8:41: note: pointer alignment '1' cannot cast into pointer alignment '2'
diff --git a/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig b/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
index bb41a2ddb981ef7eaa99bc5b45ae0f6cb8c85a9e..d3e995734fe20899d04201fc0ca33bbd148c9a64 100644
--- a/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
+++ b/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
@@ -11,5 +11,5 @@ export fn entry(foo: Foo) void {
 // target=x86_64-linux
 //
 // :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'x86_64_sysv'
-// :6:17: note: only extern structs and ABI sized packed structs are extern compatible
+// :6:17: note: struct with automatic layout has no guaranteed in-memory representation
 // :1:13: note: struct declared here
diff --git a/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig b/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
index 220dbd146d714e4697264b627476f3cb77cbf543..e02e072aa05cf25c432637ee602eda0f975feec0 100644
--- a/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
+++ b/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
@@ -11,5 +11,5 @@ export fn entry(foo: Foo) void {
 // target=x86_64-linux
 //
 // :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'x86_64_sysv'
-// :6:17: note: only extern unions and ABI sized packed unions are extern compatible
+// :6:17: note: union with automatic layout has no guaranteed in-memory representation
 // :1:13: note: union declared here
diff --git a/test/cases/compile_errors/generic_function_returning_opaque_type.zig b/test/cases/compile_errors/generic_function_returning_opaque_type.zig
index 78ffde8961669985cf82192137bab6048197d6db..b3f4b757e1c43c7b9af8692452b283acde889992 100644
--- a/test/cases/compile_errors/generic_function_returning_opaque_type.zig
+++ b/test/cases/compile_errors/generic_function_returning_opaque_type.zig
@@ -11,6 +11,6 @@ export fn bar() void {
 
 // error
 //
+// :1:30: error: opaque return type 'anyopaque' not allowed
 // :1:30: error: opaque return type 'tmp.MyOpaque' not allowed
 // :4:18: note: opaque declared here
-// :1:30: error: opaque return type 'anyopaque' not allowed
diff --git a/test/cases/compile_errors/indexing_an_array_of_size_zero.zig b/test/cases/compile_errors/indexing_an_array_of_size_zero.zig
index 356425d8152c2d9847eeceaaa6f50fd9264fe246..92ded154c130014da0ab0206c44c260c63a448ab 100644
--- a/test/cases/compile_errors/indexing_an_array_of_size_zero.zig
+++ b/test/cases/compile_errors/indexing_an_array_of_size_zero.zig
@@ -6,4 +6,4 @@ export fn foo() void {
 
 // error
 //
-// :3:27: error: indexing into empty array is not allowed
+// :3:27: error: cannot index into empty array
diff --git a/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig b/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig
index 29d522aad96879fbaf79b175baf2408c76b50da2..b06b7bed554c13518c9a277557477f87ba630333 100644
--- a/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig
+++ b/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig
@@ -8,4 +8,4 @@ export fn foo() void {
 
 // error
 //
-// :5:27: error: indexing into empty array is not allowed
+// :5:27: error: cannot index into empty array
diff --git a/test/cases/compile_errors/indirect_struct_loop.zig b/test/cases/compile_errors/indirect_struct_loop.zig
index 7975ecddf5716171d803cc2549b7a59e4b864521..ac85a64a0c64ae17a78621f6b22bc8efd3c25c97 100644
--- a/test/cases/compile_errors/indirect_struct_loop.zig
+++ b/test/cases/compile_errors/indirect_struct_loop.zig
@@ -13,4 +13,8 @@ export fn entry() usize {
 
 // error
 //
-// :1:11: error: struct 'tmp.A' depends on itself
+// error: dependency loop with length 3
+// :2:8: note: type 'tmp.A' depends on type 'tmp.B' for field declared here
+// :5:8: note: type 'tmp.B' depends on type 'tmp.C' for field declared here
+// :8:8: note: type 'tmp.C' depends on type 'tmp.A' for field declared here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/initialize_empty_union.zig b/test/cases/compile_errors/initialize_empty_union.zig
index c84633da268c5f4e885ffa33a993cb0d3eeeecf5..2847446b2516a1eb4f968a8bb31b24abc7bd132d 100644
--- a/test/cases/compile_errors/initialize_empty_union.zig
+++ b/test/cases/compile_errors/initialize_empty_union.zig
@@ -49,33 +49,33 @@ export fn deref5(ptr: *const U5) void {
 
 // error
 //
-// :13:17: error: expected type 'initialize_empty_union.U0', found '@TypeOf(undefined)'
-// :13:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U0'
+// :13:17: error: expected type 'tmp.U0', found '@TypeOf(undefined)'
+// :13:17: note: cannot coerce to uninstantiable type 'tmp.U0'
 // :5:12: note: union declared here
-// :16:17: error: expected type 'initialize_empty_union.U1', found '@TypeOf(undefined)'
-// :16:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U1'
+// :16:17: error: expected type 'tmp.U1', found '@TypeOf(undefined)'
+// :16:17: note: cannot coerce to uninstantiable type 'tmp.U1'
 // :6:12: note: union declared here
-// :19:17: error: expected type 'initialize_empty_union.U2', found '@TypeOf(undefined)'
-// :19:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U2'
+// :19:17: error: expected type 'tmp.U2', found '@TypeOf(undefined)'
+// :19:17: note: cannot coerce to uninstantiable type 'tmp.U2'
 // :7:12: note: union declared here
-// :22:17: error: expected type 'initialize_empty_union.U3', found '@TypeOf(undefined)'
-// :22:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U3'
+// :22:17: error: expected type 'tmp.U3', found '@TypeOf(undefined)'
+// :22:17: note: cannot coerce to uninstantiable type 'tmp.U3'
 // :8:12: note: union declared here
-// :25:17: error: expected type 'initialize_empty_union.U4', found '@TypeOf(undefined)'
-// :25:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U4'
+// :25:17: error: expected type 'tmp.U4', found '@TypeOf(undefined)'
+// :25:17: note: cannot coerce to uninstantiable type 'tmp.U4'
 // :9:12: note: union declared here
-// :28:17: error: expected type 'initialize_empty_union.U5', found '@TypeOf(undefined)'
-// :28:17: note: cannot coerce to uninstantiable type 'initialize_empty_union.U5'
+// :28:17: error: expected type 'tmp.U5', found '@TypeOf(undefined)'
+// :28:17: note: cannot coerce to uninstantiable type 'tmp.U5'
 // :10:12: note: union declared here
-// :32:12: error: cannot load uninstantiable type 'initialize_empty_union.U0'
+// :32:12: error: cannot load uninstantiable type 'tmp.U0'
 // :5:12: note: union declared here
-// :35:12: error: cannot load uninstantiable type 'initialize_empty_union.U1'
+// :35:12: error: cannot load uninstantiable type 'tmp.U1'
 // :6:12: note: union declared here
-// :38:12: error: cannot load uninstantiable type 'initialize_empty_union.U2'
+// :38:12: error: cannot load uninstantiable type 'tmp.U2'
 // :7:12: note: union declared here
-// :41:12: error: cannot load uninstantiable type 'initialize_empty_union.U3'
+// :41:12: error: cannot load uninstantiable type 'tmp.U3'
 // :8:12: note: union declared here
-// :44:12: error: cannot load uninstantiable type 'initialize_empty_union.U4'
+// :44:12: error: cannot load uninstantiable type 'tmp.U4'
 // :9:12: note: union declared here
-// :47:12: error: cannot load uninstantiable type 'initialize_empty_union.U5'
+// :47:12: error: cannot load uninstantiable type 'tmp.U5'
 // :10:12: note: union declared here
diff --git a/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig b/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
index 5507dbc34e3d8243162cab38e7b9606d3856daa1..2e602ee6a6dd7d8bba15f763709350c3530bd325 100644
--- a/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
+++ b/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
@@ -10,4 +10,4 @@ export fn entry() usize {
 
 // error
 //
-// :1:13: error: struct 'tmp.Foo' depends on itself
+// :2:8: error: type 'tmp.Foo' depends on itself for field declared here
diff --git a/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_union_that_contains_itself.zig b/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_union_that_contains_itself.zig
index 9886c42bae362bbcdab8c490dfae04c0f0d4d86a..c503c0b3da6b991a661023701dfef7e09a05580a 100644
--- a/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_union_that_contains_itself.zig
+++ b/test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_union_that_contains_itself.zig
@@ -10,4 +10,4 @@ export fn entry() usize {
 
 // error
 //
-// :1:13: error: union 'tmp.Foo' depends on itself
+// :2:8: error: type 'tmp.Foo' depends on itself for field declared here
diff --git a/test/cases/compile_errors/invalid_dependency_on_struct_size.zig b/test/cases/compile_errors/invalid_dependency_on_struct_size.zig
index 14cd363a1426188858d321d616f299e2e3607dc8..39fc37ab3e5520d1224cc83b08e9f27afb09d738 100644
--- a/test/cases/compile_errors/invalid_dependency_on_struct_size.zig
+++ b/test/cases/compile_errors/invalid_dependency_on_struct_size.zig
@@ -1,16 +1,18 @@
+const S = struct {
+    const Foo = struct {
+        y: Bar,
+    };
+    const Bar = struct {
+        y: if (@sizeOf(Foo) == 0) u64 else void,
+    };
+};
 comptime {
-    const S = struct {
-        const Foo = struct {
-            y: Bar,
-        };
-        const Bar = struct {
-            y: if (@sizeOf(Foo) == 0) u64 else void,
-        };
-    };
-
     _ = @sizeOf(S.Foo) + 1;
 }
 
 // error
 //
-// :6:21: error: struct layout depends on it having runtime bits
+// error: dependency loop with length 2
+// :3:12: note: type 'tmp.S.Foo' depends on type 'tmp.S.Bar' for field declared here
+// :6:24: note: type 'tmp.S.Bar' depends on type 'tmp.S.Foo' for size query here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/invalid_optional_type_in_extern_struct.zig b/test/cases/compile_errors/invalid_optional_type_in_extern_struct.zig
index 68d4603a4af51511417c417fe42be863c343e0f0..dfb497660015537a2d05a877430f776df61331a6 100644
--- a/test/cases/compile_errors/invalid_optional_type_in_extern_struct.zig
+++ b/test/cases/compile_errors/invalid_optional_type_in_extern_struct.zig
@@ -2,10 +2,10 @@ const stroo = extern struct {
     moo: ?[*c]u8,
 };
 export fn testf(fluff: *stroo) void {
-    _ = fluff;
+    _ = fluff.*;
 }
 
 // error
 //
 // :2:10: error: extern structs cannot contain fields of type '?[*c]u8'
-// :2:10: note: only pointer like optionals are extern compatible
+// :2:10: note: non-pointer optionals have no guaranteed in-memory representation
diff --git a/test/cases/compile_errors/invalid_pointer_arithmetic.zig b/test/cases/compile_errors/invalid_pointer_arithmetic.zig
index a571d5d4c2771a1931d7ca4eb29cdfb399caad06..e590087dffdba353d60d60c36247978100045687 100644
--- a/test/cases/compile_errors/invalid_pointer_arithmetic.zig
+++ b/test/cases/compile_errors/invalid_pointer_arithmetic.zig
@@ -26,11 +26,6 @@ comptime {
     _ = x - y;
 }
 
-comptime {
-    const x: [*]u0 = @ptrFromInt(1);
-    _ = x + 1;
-}
-
 comptime {
     const x: *u0 = @ptrFromInt(1);
     const y: *u0 = @ptrFromInt(2);
@@ -46,5 +41,4 @@ comptime {
 // :12:11: error: invalid operands to binary expression: 'pointer' and 'pointer'
 // :20:11: error: incompatible pointer arithmetic operands '[*]u8' and '[*]u16'
 // :26:11: error: incompatible pointer arithmetic operands '*u8' and '*u16'
-// :31:11: error: pointer arithmetic requires element type 'u0' to have runtime bits
-// :37:11: error: pointer arithmetic requires element type 'u0' to have runtime bits
+// :32:11: error: pointer subtraction requires element type 'u0' to have runtime bits
diff --git a/test/cases/compile_errors/invalid_type_in_builtin_extern.zig b/test/cases/compile_errors/invalid_type_in_builtin_extern.zig
index 5528c9c7132f197b9e702a7029c50bd49166be9f..444ab528b337a85ec6b776c37e15b8c513d7f3ea 100644
--- a/test/cases/compile_errors/invalid_type_in_builtin_extern.zig
+++ b/test/cases/compile_errors/invalid_type_in_builtin_extern.zig
@@ -1,16 +1,22 @@
 const x = @extern(*comptime_int, .{ .name = "foo" });
 const y = @extern(*fn (u8) u8, .{ .name = "bar" });
-pub export fn entry() void {
+const z = @extern(*fn (u8) callconv(.c) u8, .{ .name = "bar" });
+comptime {
     _ = x;
 }
-pub export fn entry2() void {
+comptime {
     _ = y;
 }
+comptime {
+    _ = z;
+}
 
 // error
 //
 // :1:19: error: extern symbol cannot have type '*comptime_int'
-// :1:19: note: pointer to comptime-only type 'comptime_int'
+// :1:19: note: pointer element type 'comptime_int' is not extern compatible
 // :2:19: error: extern symbol cannot have type '*fn (u8) u8'
-// :2:19: note: pointer to extern function must be 'const'
+// :2:19: note: pointer element type 'fn (u8) u8' is not extern compatible
 // :2:19: note: extern function must specify calling convention
+// :3:19: error: extern symbol cannot have type '*fn (u8) callconv(.c) u8'
+// :3:19: note: pointer to extern function must be 'const'
diff --git a/test/cases/compile_errors/non-const_variables_of_things_that_require_const_variables.zig b/test/cases/compile_errors/non-const_variables_of_things_that_require_const_variables.zig
index 373ac8e2d92f1bd5e18a14f324e374bfae90337c..66fb6c6cec77ea4423874ca288abba11737c3a67 100644
--- a/test/cases/compile_errors/non-const_variables_of_things_that_require_const_variables.zig
+++ b/test/cases/compile_errors/non-const_variables_of_things_that_require_const_variables.zig
@@ -1,49 +1,44 @@
-export fn entry1() void {
-    var m2 = &2;
-    _ = &m2;
-}
-export fn entry2() void {
+export fn entry0() void {
     var a = undefined;
     _ = &a;
 }
-export fn entry3() void {
+export fn entry1() void {
     var b = 1;
     _ = &b;
 }
-export fn entry4() void {
+export fn entry2() void {
     var c = 1.0;
     _ = &c;
 }
-export fn entry5() void {
+export fn entry3() void {
     var d = null;
     _ = &d;
 }
-export fn entry6(opaque_: *Opaque) void {
+export fn entry4(opaque_: *Opaque) void {
     var e = opaque_.*;
     _ = &e;
 }
-export fn entry7() void {
+export fn entry5() void {
     var f = i32;
     _ = &f;
 }
 const Opaque = opaque {};
-export fn entry8() void {
+export fn entry6() void {
     var e: Opaque = undefined;
     _ = &e;
 }
 
 // error
 //
-// :2:9: error: variable of type '*const comptime_int' must be const or comptime
-// :6:9: error: variable of type '@TypeOf(undefined)' must be const or comptime
-// :10:9: error: variable of type 'comptime_int' must be const or comptime
+// :2:9: error: variable of type '@TypeOf(undefined)' must be const or comptime
+// :6:9: error: variable of type 'comptime_int' must be const or comptime
+// :6:9: note: to modify this variable at runtime, it must be given an explicit fixed-size number type
+// :10:9: error: variable of type 'comptime_float' must be const or comptime
 // :10:9: note: to modify this variable at runtime, it must be given an explicit fixed-size number type
-// :14:9: error: variable of type 'comptime_float' must be const or comptime
-// :14:9: note: to modify this variable at runtime, it must be given an explicit fixed-size number type
-// :18:9: error: variable of type '@TypeOf(null)' must be const or comptime
-// :22:20: error: cannot load opaque type 'tmp.Opaque'
-// :29:16: note: opaque declared here
-// :26:9: error: variable of type 'type' must be const or comptime
-// :26:9: note: types are not available at runtime
-// :31:12: error: non-extern variable with opaque type 'tmp.Opaque'
-// :29:16: note: opaque declared here
+// :14:9: error: variable of type '@TypeOf(null)' must be const or comptime
+// :18:20: error: cannot load opaque type 'tmp.Opaque'
+// :25:16: note: opaque declared here
+// :22:9: error: variable of type 'type' must be const or comptime
+// :22:9: note: types are not available at runtime
+// :27:12: error: non-extern variable with opaque type 'tmp.Opaque'
+// :25:16: note: opaque declared here
diff --git a/test/cases/compile_errors/non-exhaustive_enum_marker_assigned_a_value.zig b/test/cases/compile_errors/non-exhaustive_enum_marker_assigned_a_value.zig
index bd659f8e32a2808cdfe63c4d987443aac7925ee0..01b999e924a65cf53a064d375f4ca52ee2c8386b 100644
--- a/test/cases/compile_errors/non-exhaustive_enum_marker_assigned_a_value.zig
+++ b/test/cases/compile_errors/non-exhaustive_enum_marker_assigned_a_value.zig
@@ -3,18 +3,7 @@ const A = enum {
     b,
     _ = 1,
 };
-const B = enum {
-    a,
-    b,
-    _,
-};
-comptime {
-    _ = A;
-    _ = B;
-}
 
 // error
 //
 // :4:9: error: '_' is used to mark an enum as non-exhaustive and cannot be assigned a value
-// :6:11: error: non-exhaustive enum missing integer tag type
-// :9:5: note: marked non-exhaustive here
diff --git a/test/cases/compile_errors/non-exhaustive_enum_missing_tag_type.zig b/test/cases/compile_errors/non-exhaustive_enum_missing_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fa0b9d432dd65bf8203dd39cbadcad909b8024ed
--- /dev/null
+++ b/test/cases/compile_errors/non-exhaustive_enum_missing_tag_type.zig
@@ -0,0 +1,10 @@
+const E = enum {
+    a,
+    b,
+    _,
+};
+
+// error
+//
+// :1:11: error: non-exhaustive enum missing integer tag type
+// :4:5: note: marked non-exhaustive here
diff --git a/test/cases/compile_errors/non-exhaustive_enum_specifies_every_value.zig b/test/cases/compile_errors/non-exhaustive_enum_specifies_every_value.zig
index 8adaac649f2297ece6a93388a80c7e4e779800b7..6c4902ba5c2733d12efeed907309bbc0a1d15547 100644
--- a/test/cases/compile_errors/non-exhaustive_enum_specifies_every_value.zig
+++ b/test/cases/compile_errors/non-exhaustive_enum_specifies_every_value.zig
@@ -4,7 +4,7 @@ const C = enum(u1) {
     _,
 };
 pub export fn entry() void {
-    _ = C;
+    _ = C.a;
 }
 
 // error
diff --git a/test/cases/compile_errors/non-inline_for_loop_on_a_type_that_requires_comptime.zig b/test/cases/compile_errors/non-inline_for_loop_on_a_type_that_requires_comptime.zig
index adb6583757e58518f1200100d504eebbcb9259b4..a895c263a0e2acd38c343166cd9afbb65e569ac5 100644
--- a/test/cases/compile_errors/non-inline_for_loop_on_a_type_that_requires_comptime.zig
+++ b/test/cases/compile_errors/non-inline_for_loop_on_a_type_that_requires_comptime.zig
@@ -11,6 +11,6 @@ export fn entry() void {
 
 // error
 //
-// :7:10: error: values of type '[2]tmp.Foo' must be comptime-known, but index value is runtime-known
+// :7:10: error: values of type 'tmp.Foo' must be comptime-known, but index value is runtime-known
 // :3:8: note: struct requires comptime because of this field
 // :3:8: note: types are not available at runtime
diff --git a/test/cases/compile_errors/non_constant_expression_in_array_size.zig b/test/cases/compile_errors/non_constant_expression_in_array_size.zig
index 0f64e1263b2e2475c8335c0a0ae333a987ce4ca0..6b344ba4a1d6a3abc7e7bc36d7fc895a5dc73d01 100644
--- a/test/cases/compile_errors/non_constant_expression_in_array_size.zig
+++ b/test/cases/compile_errors/non_constant_expression_in_array_size.zig
@@ -14,4 +14,4 @@ export fn entry() usize {
 //
 // :6:12: error: unable to resolve comptime value
 // :2:12: note: called at comptime from here
-// :1:13: note: types must be comptime-known
+// :2:8: note: struct field types must be comptime-known
diff --git a/test/cases/compile_errors/noreturn_struct_field.zig b/test/cases/compile_errors/noreturn_struct_field.zig
deleted file mode 100644
index 8a68496bdedc29169071432fa7af33410c1c33fa..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/noreturn_struct_field.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const S = struct {
-    s: noreturn,
-};
-comptime {
-    _ = @typeInfo(S);
-}
-
-// error
-//
-// :2:8: error: struct fields cannot be 'noreturn'
diff --git a/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig b/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
index 701636e7636541cb7e54d1b50107ab83f6dd71c6..85ff0539804cdcb553dfe521aa6f908148ecdb82 100644
--- a/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
+++ b/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
@@ -4,15 +4,9 @@ const S = extern struct {
 comptime {
     _ = @sizeOf(S) == 1;
 }
-comptime {
-    _ = [*c][4]fn () callconv(.c) void;
-}
 
 // error
 //
 // :2:8: error: extern structs cannot contain fields of type 'fn () callconv(.c) void'
 // :2:8: note: type has no guaranteed in-memory representation
 // :2:8: note: use '*const ' to make a function pointer type
-// :8:13: error: C pointers cannot point to non-C-ABI-compatible type '[4]fn () callconv(.c) void'
-// :8:13: note: type has no guaranteed in-memory representation
-// :8:13: note: use '*const ' to make a function pointer type
diff --git a/test/cases/compile_errors/overflow_in_enum_value_allocation.zig b/test/cases/compile_errors/overflow_in_enum_value_allocation.zig
index 35f3c193dfe343fdc387c972f7fb145af8f4190d..fdf2cf4efb9ca5f02199f071ffe9550b597ac45f 100644
--- a/test/cases/compile_errors/overflow_in_enum_value_allocation.zig
+++ b/test/cases/compile_errors/overflow_in_enum_value_allocation.zig
@@ -9,4 +9,4 @@ pub export fn entry() void {
 
 // error
 //
-// :3:5: error: enumeration value '256' too large for type 'u8'
+// :3:5: error: enum tag value '256' too large for type 'u8'
diff --git a/test/cases/compile_errors/packed_struct_backing_int_wrong.zig b/test/cases/compile_errors/packed_struct_backing_int_wrong.zig
index 25872cbf7e8c975e74cfb3760f8faa382024eedc..5fa4f258d53e2d92c861f312e97e8bee68f866ff 100644
--- a/test/cases/compile_errors/packed_struct_backing_int_wrong.zig
+++ b/test/cases/compile_errors/packed_struct_backing_int_wrong.zig
@@ -44,8 +44,12 @@ export fn entry7() void {
 
 // error
 //
-// :2:31: error: backing integer type 'u32' has bit size 32 but the struct fields have a total bit size of 29
-// :9:31: error: backing integer type 'i31' has bit size 31 but the struct fields have a total bit size of 32
+// :2:24: error: backing integer bit width does not match total bit width of fields
+// :2:31: note: backing integer 'u32' has bit width '32'
+// :2:24: note: struct fields have total bit width '29'
+// :9:24: error: backing integer bit width does not match total bit width of fields
+// :9:31: note: backing integer 'i31' has bit width '31'
+// :9:24: note: struct fields have total bit width '32'
 // :17:31: error: expected backing integer type, found 'void'
 // :23:31: error: expected backing integer type, found 'void'
 // :27:31: error: expected backing integer type, found 'noreturn'
diff --git a/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig b/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig
index 5f4482421d65b8144ace994483cf8342aa35006b..d7a5d355c9d26a565b179d3610255a55bafaaab7 100644
--- a/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig
+++ b/test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig
@@ -85,29 +85,32 @@ export fn entry15() void {
 // error
 //
 // :3:12: error: packed structs cannot contain fields of type 'anyerror'
-// :3:12: note: type has no guaranteed in-memory representation
+// :3:12: note: type does not have a bit-packed representation
 // :8:12: error: packed structs cannot contain fields of type '[2]u24'
-// :8:12: note: type has no guaranteed in-memory representation
+// :8:12: note: type does not have a bit-packed representation
 // :13:20: error: packed structs cannot contain fields of type 'anyerror!u32'
-// :13:20: note: type has no guaranteed in-memory representation
+// :13:20: note: type does not have a bit-packed representation
 // :18:12: error: packed structs cannot contain fields of type 'tmp.S'
-// :18:12: note: only packed structs layout are allowed in packed types
+// :18:12: note: non-packed structs do not have a bit-packed representation
 // :56:11: note: struct declared here
 // :23:12: error: packed structs cannot contain fields of type 'tmp.U'
-// :23:12: note: only packed unions layout are allowed in packed types
+// :23:12: note: non-packed unions do not have a bit-packed representation
 // :59:18: note: union declared here
 // :28:12: error: packed structs cannot contain fields of type '?anyerror'
-// :28:12: note: type has no guaranteed in-memory representation
+// :28:12: note: type does not have a bit-packed representation
 // :38:12: error: packed structs cannot contain fields of type 'fn () void'
-// :38:12: note: type has no guaranteed in-memory representation
-// :38:12: note: use '*const ' to make a function pointer type
+// :38:12: note: type does not have a bit-packed representation
+// :43:12: error: packed structs cannot contain fields of type '*const fn () void'
+// :43:12: note: pointers cannot be directly bitpacked
+// :43:12: note: consider using 'usize' and '@intFromPtr'
 // :65:31: error: packed structs cannot contain fields of type '[]u8'
-// :65:31: note: slices have no guaranteed in-memory representation
+// :65:31: note: slices do not have a bit-packed representation
 // :70:12: error: packed structs cannot contain fields of type '*type'
-// :70:12: note: comptime-only pointer has no guaranteed in-memory representation
-// :70:12: note: types are not available at runtime
+// :70:12: note: pointers cannot be directly bitpacked
+// :70:12: note: consider using 'usize' and '@intFromPtr'
 // :76:12: error: packed structs cannot contain fields of type 'tmp.entry14.E'
-// :74:15: note: enum declared here
+// :74:15: note: integer tag type of enum is inferred
+// :74:15: note: consider explicitly specifying the integer tag type
 // :81:12: error: packed structs cannot contain fields of type '*const u32'
 // :81:12: note: pointers cannot be directly bitpacked
 // :81:12: note: consider using 'usize' and '@intFromPtr'
diff --git a/test/cases/compile_errors/packed_union_fields_mismatch.zig b/test/cases/compile_errors/packed_union_fields_mismatch.zig
index 7f5ac456bfe246c5a69c9b00545d64749d27871f..1e815838a9b948b4fceb619a9ef78dc6c5feaafd 100644
--- a/test/cases/compile_errors/packed_union_fields_mismatch.zig
+++ b/test/cases/compile_errors/packed_union_fields_mismatch.zig
@@ -1,12 +1,14 @@
 export fn entry1() void {
-    _ = packed union {
+    const U = packed union {
         a: u1,
         b: u2,
     };
+    _ = @as(U, undefined);
 }
 
 // error
 //
-// :2:16: error: packed union has fields with mismatching bit sizes
-// :3:12: note: 1 bits here
-// :4:12: note: 2 bits here
+// :4:12: error: field bit width does not match earlier field
+// :4:12: note: field type 'u2' has bit width '2'
+// :3:12: note: other field type 'u1' has bit width '1'
+// :4:12: note: all fields in a packed union must have the same bit width
diff --git a/test/cases/compile_errors/packed_union_given_enum_tag_type.zig b/test/cases/compile_errors/packed_union_given_enum_tag_type.zig
deleted file mode 100644
index f95c1739c0cd3dcd3cfc865ab20415c9b95fddf1..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/packed_union_given_enum_tag_type.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Letter = enum {
-    A,
-    B,
-    C,
-};
-const Payload = packed union(Letter) {
-    A: i32,
-    B: f64,
-    C: bool,
-};
-export fn entry() void {
-    const a: Payload = .{ .A = 1234 };
-    _ = a;
-}
-
-// error
-//
-// :6:30: error: packed union does not support enum tag type
diff --git a/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig b/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig
index cfbdf4e90aeaab22aa6637066e68d1a1ce0348ac..d0e09742b5080e165af9fc105ff62fad177ff993 100644
--- a/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig
+++ b/test/cases/compile_errors/packed_union_with_fields_of_not_allowed_types.zig
@@ -1,6 +1,7 @@
+const S = struct { a: u32 };
 export fn entry0() void {
     _ = @sizeOf(packed union {
-        foo: struct { a: u32 },
+        foo: S,
         bar: bool,
     });
 }
@@ -12,9 +13,9 @@ export fn entry1() void {
 
 // error
 //
-// :3:14: error: packed unions cannot contain fields of type 'packed_union_with_fields_of_not_allowed_types.entry0__union_180__struct_182'
-// :3:14: note: non-packed structs do not have a bit-packed representation
-// :3:14: note: struct declared here
-// :9:12: error: packed unions cannot contain fields of type '*const u32'
-// :9:12: note: pointers cannot be directly bitpacked
-// :9:12: note: consider using 'usize' and '@intFromPtr'
+// :4:14: error: packed unions cannot contain fields of type 'tmp.S'
+// :4:14: note: non-packed structs do not have a bit-packed representation
+// :1:11: note: struct declared here
+// :10:12: error: packed unions cannot contain fields of type '*const u32'
+// :10:12: note: pointers cannot be directly bitpacked
+// :10:12: note: consider using 'usize' and '@intFromPtr'
diff --git a/test/cases/compile_errors/pointer_in_bitpack.zig b/test/cases/compile_errors/pointer_in_bitpack.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fa3d8130fa11ea0e44562266b39dc6bc9ce67df9
--- /dev/null
+++ b/test/cases/compile_errors/pointer_in_bitpack.zig
@@ -0,0 +1,22 @@
+const S = packed struct {
+    ptr: *u32,
+};
+export fn foo() void {
+    _ = @as(S, undefined);
+}
+
+const U = packed union {
+    ptr: *u32,
+};
+export fn bar() void {
+    _ = @as(U, undefined);
+}
+
+// error
+//
+// :2:10: error: packed structs cannot contain fields of type '*u32'
+// :2:10: note: pointers cannot be directly bitpacked
+// :2:10: note: consider using 'usize' and '@intFromPtr'
+// :9:10: error: packed unions cannot contain fields of type '*u32'
+// :9:10: note: pointers cannot be directly bitpacked
+// :9:10: note: consider using 'usize' and '@intFromPtr'
diff --git a/test/cases/compile_errors/reify_enum_with_duplicate_field.zig b/test/cases/compile_errors/reify_enum_with_duplicate_field.zig
index 73df5e1a869a3fe6c8255945fc6e98f8d82e2a85..efa0e51dee32d9058fc2f1f73d46cb3aaa953b6f 100644
--- a/test/cases/compile_errors/reify_enum_with_duplicate_field.zig
+++ b/test/cases/compile_errors/reify_enum_with_duplicate_field.zig
@@ -1,8 +1,9 @@
 export fn entry() void {
-    _ = @Enum(u32, .nonexhaustive, &.{ "A", "A" }, &.{ 0, 1 });
+    const E = @Enum(u32, .nonexhaustive, &.{ "A", "A" }, &.{ 0, 1 });
+    _ = @as(E, undefined);
 }
 
 // error
 //
-// :2:36: error: duplicate enum field 'A'
-// :2:36: note: other field here
+// :2:42: error: duplicate enum field 'A' at index '1'
+// :2:42: note: previous field at index '0'
diff --git a/test/cases/compile_errors/reify_enum_with_duplicate_tag_value.zig b/test/cases/compile_errors/reify_enum_with_duplicate_tag_value.zig
index 6343782ca7b2e53a9c0f1bfe2b5f3189b7cd5b0b..c60589f7e02075a59a82f0f02423312b5c709c88 100644
--- a/test/cases/compile_errors/reify_enum_with_duplicate_tag_value.zig
+++ b/test/cases/compile_errors/reify_enum_with_duplicate_tag_value.zig
@@ -1,8 +1,9 @@
 export fn entry() void {
-    _ = @Enum(u32, .nonexhaustive, &.{ "A", "B" }, &.{ 10, 10 });
+    const E = @Enum(u32, .nonexhaustive, &.{ "a", "b" }, &.{ 10, 10 });
+    _ = E.a;
 }
 
 // error
 //
-// :2:52: error: enum tag value 10 already taken
-// :2:52: note: other enum tag value here
+// :2:58: error: enum tag value '10' for field 'b' already taken
+// :2:58: note: previous occurrence in field 'a'
diff --git a/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig b/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
index d74e0b2b53104178bae00a1799d6013a76f6df28..8e684cba560d5af4f7189fc9d0d16ed554e0e5e4 100644
--- a/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
+++ b/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
@@ -5,4 +5,4 @@ export fn entry() void {
 
 // error
 //
-// :1:19: error: tag type must be an integer type
+// :1:19: error: expected integer tag type, found 'bool'
diff --git a/test/cases/compile_errors/reify_type_for_tagged_packed_union.zig b/test/cases/compile_errors/reify_type_for_tagged_packed_union.zig
deleted file mode 100644
index f602771bc68874789ce8b2f79afbe12cdc571f5b..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/reify_type_for_tagged_packed_union.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Tag = @Enum(u2, .exhaustive, &.{ "signed", "unsigned" }, &.{ 0, 1 });
-const Packed = @Union(.@"packed", Tag, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &@splat(.{}));
-
-export fn entry() void {
-    const tagged: Packed = .{ .signed = -1 };
-    _ = tagged;
-}
-
-// error
-//
-// :2:35: error: packed union does not support enum tag type
diff --git a/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_enum_field.zig b/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_enum_field.zig
index 5b56a98eb3d9c058708f2685738d518e36759a8d..0b62e7b6d945bcb1808710411ce4f465cd859b1e 100644
--- a/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_enum_field.zig
+++ b/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_enum_field.zig
@@ -7,6 +7,5 @@ export fn entry() void {
 
 // error
 //
-// :2:35: error: 1 enum fields missing in union
-// :1:13: note: field 'arst' missing, declared here
-// :1:13: note: enum declared here
+// :2:16: error: enum field 'arst' missing from union
+// :1:36: note: enum field here
diff --git a/test/cases/compile_errors/reify_type_for_tagged_union_with_no_union_fields.zig b/test/cases/compile_errors/reify_type_for_tagged_union_with_no_union_fields.zig
index 245bd472ccfdc6b1be0d3f78c7fa63f649e97f4b..ae4903c4d8739f08607d656306b9f013f21ccefc 100644
--- a/test/cases/compile_errors/reify_type_for_tagged_union_with_no_union_fields.zig
+++ b/test/cases/compile_errors/reify_type_for_tagged_union_with_no_union_fields.zig
@@ -7,7 +7,5 @@ export fn entry() void {
 
 // error
 //
-// :2:35: error: 2 enum fields missing in union
-// :1:13: note: field 'signed' missing, declared here
-// :1:13: note: field 'unsigned' missing, declared here
-// :1:13: note: enum declared here
+// :2:16: error: enum field 'signed' missing from union
+// :1:36: note: enum field here
diff --git a/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig b/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig
index e2be15f1a4239d4cd3721dc05652a203e8754d07..3a1b64e58ef3303189d885c757b25459a1668e3c 100644
--- a/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig
+++ b/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig
@@ -1,9 +1,11 @@
-const Untagged = @Union(.auto, null, &.{"foo"}, &.{opaque {}}, &.{.{}});
+const Opaque = opaque {};
+const Untagged = @Union(.auto, null, &.{"foo"}, &.{Opaque}, &.{.{}});
 export fn entry() usize {
     return @sizeOf(Untagged);
 }
 
 // error
 //
-// :1:49: error: opaque types have unknown size and therefore cannot be directly embedded in unions
-// :1:52: note: opaque declared here
+// :2:49: error: cannot directly embed opaque type 'tmp.Opaque' in union
+// :2:49: note: opaque types have unknown size
+// :1:16: note: opaque declared here
diff --git a/test/cases/compile_errors/reify_type_with_invalid_field_alignment.zig b/test/cases/compile_errors/reify_type_with_invalid_field_alignment.zig
index e6b9e1435a68f238a977042f4349d8b124682f74..b71480ed265099f5a5e88ddd407369b0b8431831 100644
--- a/test/cases/compile_errors/reify_type_with_invalid_field_alignment.zig
+++ b/test/cases/compile_errors/reify_type_with_invalid_field_alignment.zig
@@ -2,7 +2,11 @@ comptime {
     _ = @Union(.auto, null, &.{"foo"}, &.{usize}, &.{.{ .@"align" = 3 }});
 }
 comptime {
-    _ = @Struct(.auto, null, &.{"a"}, &.{u32}, &.{.{ .@"comptime" = true, .@"align" = 5 }});
+    _ = @Struct(.auto, null, &.{"a"}, &.{u32}, &.{.{
+        .@"comptime" = true,
+        .@"align" = 5,
+        .default_value_ptr = &@as(u32, 0),
+    }});
 }
 comptime {
     _ = @Pointer(.many, .{ .@"align" = 7 }, u8, null);
@@ -12,4 +16,4 @@ comptime {
 //
 // :2:51: error: alignment value '3' is not a power of two
 // :5:48: error: alignment value '5' is not a power of two
-// :8:26: error: alignment value '7' is not a power of two
+// :12:26: error: alignment value '7' is not a power of two
diff --git a/test/cases/compile_errors/resolve_inferred_error_set_of_generic_fn.zig b/test/cases/compile_errors/resolve_inferred_error_set_of_generic_fn.zig
index f6c98d68b1e8aa8bc0b939e96dfca4f2ca479197..91ece712e03db5d6370c71e64623a46d9f213d37 100644
--- a/test/cases/compile_errors/resolve_inferred_error_set_of_generic_fn.zig
+++ b/test/cases/compile_errors/resolve_inferred_error_set_of_generic_fn.zig
@@ -12,5 +12,4 @@ export fn entry() void {
 
 // error
 //
-// :10:15: error: unable to resolve inferred error set of generic function
-// :1:1: note: generic function declared here
+// :1:1: error: cannot resolve inferred error set of generic function type 'fn (anytype) @typeInfo(@typeInfo(@TypeOf(tmp.foo)).@"fn".return_type.?).error_union.error_set!void'
diff --git a/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig b/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
index 04dc92f86ba16035fc5cd5f118b1e310e5617ff6..6e21501dcffbe65ccc1dddfe25508f5ad006f0ef 100644
--- a/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
+++ b/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
@@ -10,6 +10,5 @@ pub export fn callbackFin(id: c_int, arg: ?*anyopaque) void {
 
 // error
 //
-// :5:54: error: pointer to comptime-only type '?*tmp.GuSettings' must be comptime-known, but operand is runtime-known
-// :2:10: note: struct requires comptime because of this field
-// :2:10: note: use '*const fn (c_int) callconv(.c) void' for a function pointer type
+// :6:19: error: cannot load comptime-only type '?fn (c_int) callconv(.c) void'
+// :6:20: note: pointer of type '*?fn (c_int) callconv(.c) void' is runtime-known
diff --git a/test/cases/compile_errors/runtime_index_into_comptime_only_many_ptr.zig b/test/cases/compile_errors/runtime_index_into_comptime_only_many_ptr.zig
index 4a2d475b1f14451e0a0370ba315d54b5f4ad66dd..3f645862fa7be40c0ed11d0e6c9505b00870f4f4 100644
--- a/test/cases/compile_errors/runtime_index_into_comptime_only_many_ptr.zig
+++ b/test/cases/compile_errors/runtime_index_into_comptime_only_many_ptr.zig
@@ -1,10 +1,10 @@
 var rt: usize = 0;
 export fn foo() void {
     const x: [*]const type = &.{ u8, u16 };
-    _ = &x[rt];
+    _ = x[rt];
 }
 
 // error
 //
-// :4:12: error: values of type '[*]const type' must be comptime-known, but index value is runtime-known
-// :4:11: note: types are not available at runtime
+// :4:11: error: values of type 'type' must be comptime-known, but index value is runtime-known
+// :4:10: note: types are not available at runtime
diff --git a/test/cases/compile_errors/runtime_index_into_comptime_type_slice.zig b/test/cases/compile_errors/runtime_index_into_comptime_type_slice.zig
index b4781a3c680abe53388eed2196ceeaa13c216527..b4cf100c19978597ccf5f987f69fdebe1345a848 100644
--- a/test/cases/compile_errors/runtime_index_into_comptime_type_slice.zig
+++ b/test/cases/compile_errors/runtime_index_into_comptime_type_slice.zig
@@ -12,7 +12,6 @@ export fn entry() void {
 
 // error
 //
-// :9:54: error: values of type '[]const builtin.Type.StructField' must be comptime-known, but index value is runtime-known
+// :9:54: error: values of type 'builtin.Type.StructField' must be comptime-known, but index value is runtime-known
 // : note: struct requires comptime because of this field
 // : note: types are not available at runtime
-// : struct requires comptime because of this field
diff --git a/test/cases/compile_errors/runtime_indexing_comptime_array.zig b/test/cases/compile_errors/runtime_indexing_comptime_array.zig
index 3fcf57dd47bfe4883850f96fd955f481a8768b36..f82991dd3974cdfc754ae4746cc0ac6847f4829a 100644
--- a/test/cases/compile_errors/runtime_indexing_comptime_array.zig
+++ b/test/cases/compile_errors/runtime_indexing_comptime_array.zig
@@ -24,9 +24,9 @@ pub export fn entry3() void {
 }
 // error
 //
-// :7:10: error: values of type '[2]fn () void' must be comptime-known, but index value is runtime-known
+// :7:10: error: values of type 'fn () void' must be comptime-known, but index value is runtime-known
 // :7:10: note: use '*const fn () void' for a function pointer type
-// :15:18: error: values of type '[2]fn () void' must be comptime-known, but index value is runtime-known
+// :15:18: error: values of type 'fn () void' must be comptime-known, but index value is runtime-known
 // :15:17: note: use '*const fn () void' for a function pointer type
-// :22:19: error: values of type '[2]fn () void' must be comptime-known, but index value is runtime-known
+// :22:19: error: values of type 'fn () void' must be comptime-known, but index value is runtime-known
 // :22:18: note: use '*const fn () void' for a function pointer type
diff --git a/test/cases/compile_errors/runtime_operation_in_comptime_scope.zig b/test/cases/compile_errors/runtime_operation_in_comptime_scope.zig
index 73220b0ba4e1de7273b2bb2c7b85ef232d225596..1631fc07fc41aee4e21324478e9d294b0bb6459a 100644
--- a/test/cases/compile_errors/runtime_operation_in_comptime_scope.zig
+++ b/test/cases/compile_errors/runtime_operation_in_comptime_scope.zig
@@ -25,13 +25,13 @@ var rt: u32 = undefined;
 //
 // :19:8: error: unable to evaluate comptime expression
 // :19:5: note: operation is runtime due to this operand
+// :6:8: note: called at comptime from here
+// :5:1: note: 'comptime' keyword forces comptime evaluation
+// :19:8: error: unable to evaluate comptime expression
+// :19:5: note: operation is runtime due to this operand
 // :14:8: note: called at comptime from here
 // :10:12: note: called at comptime from here
 // :10:12: note: call to function with comptime-only return type 'type' is evaluated at comptime
 // :13:10: note: return type declared here
 // :10:12: note: types are not available at runtime
 // :2:8: note: called inline here
-// :19:8: error: unable to evaluate comptime expression
-// :19:5: note: operation is runtime due to this operand
-// :6:8: note: called at comptime from here
-// :5:1: note: 'comptime' keyword forces comptime evaluation
diff --git a/test/cases/compile_errors/self_referential_struct_requires_comptime.zig b/test/cases/compile_errors/self_referential_struct_requires_comptime.zig
index 5205702b679e3ca9d09351af5f8a76b7687983fb..81a0813d9b63b49cbda15cc79ba7b3bf4c67d5ec 100644
--- a/test/cases/compile_errors/self_referential_struct_requires_comptime.zig
+++ b/test/cases/compile_errors/self_referential_struct_requires_comptime.zig
@@ -12,4 +12,3 @@ pub export fn entry() void {
 // :6:12: error: variable of type 'tmp.S' must be const or comptime
 // :2:8: note: struct requires comptime because of this field
 // :2:8: note: use '*const fn () void' for a function pointer type
-// :3:8: note: struct requires comptime because of this field
diff --git a/test/cases/compile_errors/self_referential_union_requires_comptime.zig b/test/cases/compile_errors/self_referential_union_requires_comptime.zig
index 6ab0af996596a9bc021466ff95d71c2ff6ec79db..fbf00ce69a6b4ccfeb763b394d9581377a81b16e 100644
--- a/test/cases/compile_errors/self_referential_union_requires_comptime.zig
+++ b/test/cases/compile_errors/self_referential_union_requires_comptime.zig
@@ -12,4 +12,3 @@ pub export fn entry() void {
 // :6:12: error: variable of type 'tmp.U' must be const or comptime
 // :2:8: note: union requires comptime because of this field
 // :2:8: note: use '*const fn () void' for a function pointer type
-// :3:8: note: union requires comptime because of this field
diff --git a/test/cases/compile_errors/sizeOf_bad_type.zig b/test/cases/compile_errors/sizeOf_bad_type.zig
index c81ad7450f3d34e9af7e0eabcc2917e4303027f1..6d20251064f5be10e258283aaa6facb6451403c4 100644
--- a/test/cases/compile_errors/sizeOf_bad_type.zig
+++ b/test/cases/compile_errors/sizeOf_bad_type.zig
@@ -22,4 +22,6 @@ export fn entry4() usize {
 // :5:20: error: no size available for comptime-only type 'comptime_int'
 // :8:20: error: no size available for uninstantiable type 'noreturn'
 // :12:20: error: no size available for comptime-only type 'tmp.S3'
+// :10:12: note: struct declared here
 // :16:20: error: no size available for uninstantiable type 'tmp.S4'
+// :14:12: note: struct declared here
diff --git a/test/cases/compile_errors/sizeof_alignof_empty_union.zig b/test/cases/compile_errors/sizeof_alignof_empty_union.zig
index 920b3b5af8a6281cce83860996d8af8eca3011f4..58e6aa635088c30cab0c1d7306f088406fcb34d1 100644
--- a/test/cases/compile_errors/sizeof_alignof_empty_union.zig
+++ b/test/cases/compile_errors/sizeof_alignof_empty_union.zig
@@ -49,27 +49,27 @@ export fn align5() void {
 
 // error
 //
-// :13:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U0'
+// :13:17: error: no size available for uninstantiable type 'tmp.U0'
 // :5:12: note: union declared here
-// :16:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U1'
+// :16:17: error: no size available for uninstantiable type 'tmp.U1'
 // :6:12: note: union declared here
-// :19:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U2'
+// :19:17: error: no size available for uninstantiable type 'tmp.U2'
 // :7:12: note: union declared here
-// :22:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U3'
+// :22:17: error: no size available for uninstantiable type 'tmp.U3'
 // :8:12: note: union declared here
-// :25:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U4'
+// :25:17: error: no size available for uninstantiable type 'tmp.U4'
 // :9:12: note: union declared here
-// :28:17: error: no size available for uninstantiable type 'sizeof_alignof_empty_union.U5'
+// :28:17: error: no size available for uninstantiable type 'tmp.U5'
 // :10:12: note: union declared here
-// :32:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U0'
+// :32:18: error: no align available for uninstantiable type 'tmp.U0'
 // :5:12: note: union declared here
-// :35:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U1'
+// :35:18: error: no align available for uninstantiable type 'tmp.U1'
 // :6:12: note: union declared here
-// :38:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U2'
+// :38:18: error: no align available for uninstantiable type 'tmp.U2'
 // :7:12: note: union declared here
-// :41:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U3'
+// :41:18: error: no align available for uninstantiable type 'tmp.U3'
 // :8:12: note: union declared here
-// :44:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U4'
+// :44:18: error: no align available for uninstantiable type 'tmp.U4'
 // :9:12: note: union declared here
-// :47:18: error: no align available for uninstantiable type 'sizeof_alignof_empty_union.U5'
+// :47:18: error: no align available for uninstantiable type 'tmp.U5'
 // :10:12: note: union declared here
diff --git a/test/cases/compile_errors/slice_used_as_extern_fn_param.zig b/test/cases/compile_errors/slice_used_as_extern_fn_param.zig
index 522e4eba8ce278e56afc5643813d84db253bc0ea..e056aa23800a0a9810d3da6b3c66ce8ad82ac31d 100644
--- a/test/cases/compile_errors/slice_used_as_extern_fn_param.zig
+++ b/test/cases/compile_errors/slice_used_as_extern_fn_param.zig
@@ -1,6 +1,6 @@
 extern fn Text(str: []const u8, num: i32) callconv(.c) void;
 export fn entry() void {
-    _ = Text;
+    Text(undefined, undefined);
 }
 
 // error
diff --git a/test/cases/compile_errors/specify_enum_tag_type_that_is_too_small.zig b/test/cases/compile_errors/specify_enum_tag_type_that_is_too_small.zig
index f00c363aae5fad3620c6d5c54625153b44ac3740..b6d9bd7d21ad217efe00ba4fa88c1cbe440d75a3 100644
--- a/test/cases/compile_errors/specify_enum_tag_type_that_is_too_small.zig
+++ b/test/cases/compile_errors/specify_enum_tag_type_that_is_too_small.zig
@@ -1,9 +1,9 @@
 const Small = enum(u2) {
-    One,
-    Two,
-    Three,
-    Four,
-    Five,
+    one,
+    two,
+    three,
+    four,
+    five,
 };
 
 const SmallUnion = union(enum(u2)) {
@@ -14,13 +14,13 @@ const SmallUnion = union(enum(u2)) {
 };
 
 comptime {
-    _ = Small;
+    _ = Small.one;
 }
 comptime {
-    _ = SmallUnion;
+    _ = SmallUnion.one;
 }
 
 // error
 //
-// :6:5: error: enumeration value '4' too large for type 'u2'
-// :13:5: error: enumeration value '4' too large for type 'u2'
+// :6:5: error: enum tag value '4' too large for type 'u2'
+// :13:5: error: enum tag value '4' too large for type 'u2'
diff --git a/test/cases/compile_errors/store_comptime_only_type_to_runtime_pointer.zig b/test/cases/compile_errors/store_comptime_only_type_to_runtime_pointer.zig
index af30c80f7040e148eadb1e0965c9d3b24c81c15f..05ae6f920205b98525020c71038b593a7d487f9b 100644
--- a/test/cases/compile_errors/store_comptime_only_type_to_runtime_pointer.zig
+++ b/test/cases/compile_errors/store_comptime_only_type_to_runtime_pointer.zig
@@ -21,22 +21,15 @@ export fn e() void {
     p.* = undefined;
 }
 
-export fn f() void {
-    const p: **comptime_int = @ptrFromInt(16); // double pointer ('*comptime_int' is comptime-only)
-    p.* = undefined;
-}
-
 // error
 //
 // :3:9: error: cannot store comptime-only type 'fn () void' at runtime
 // :3:6: note: operation is runtime due to this pointer
 // :7:11: error: expected type 'anyopaque', found '@TypeOf(undefined)'
-// :7:11: note: cannot coerce to 'anyopaque'
+// :7:11: note: cannot coerce to uninstantiable type 'anyopaque'
 // :11:12: error: cannot load opaque type 'anyopaque'
 // :16:11: error: expected type 'tmp.Opaque', found '@TypeOf(undefined)'
-// :16:11: note: cannot coerce to 'tmp.Opaque'
+// :16:11: note: cannot coerce to uninstantiable type 'tmp.Opaque'
 // :14:16: note: opaque declared here
 // :21:9: error: cannot store comptime-only type 'comptime_int' at runtime
 // :21:6: note: operation is runtime due to this pointer
-// :26:9: error: cannot store comptime-only type '*comptime_int' at runtime
-// :26:6: note: operation is runtime due to this pointer
diff --git a/test/cases/compile_errors/struct_depends_on_itself_via_non_initial_field.zig b/test/cases/compile_errors/struct_depends_on_itself_via_non_initial_field.zig
index b514bc10e7bf8c1ced988e2b14e6c80afcc40605..7d2ddaa2096fd10f1be1f6c113bcf236ecd58ef5 100644
--- a/test/cases/compile_errors/struct_depends_on_itself_via_non_initial_field.zig
+++ b/test/cases/compile_errors/struct_depends_on_itself_via_non_initial_field.zig
@@ -4,9 +4,9 @@ const A = struct {
 };
 
 comptime {
-    _ = A;
+    _ = @as(A, undefined);
 }
 
 // error
 //
-// :1:11: error: struct 'tmp.A' depends on itself
+// :3:21: error: type 'tmp.A' depends on itself for size query here
diff --git a/test/cases/compile_errors/struct_depends_on_itself_via_optional_field.zig b/test/cases/compile_errors/struct_depends_on_itself_via_optional_field.zig
index a8614baf79d03384d38c67044a32920a260b7ec2..bc4ad96555a6f9ff02d95637a74342104cb0566a 100644
--- a/test/cases/compile_errors/struct_depends_on_itself_via_optional_field.zig
+++ b/test/cases/compile_errors/struct_depends_on_itself_via_optional_field.zig
@@ -12,4 +12,7 @@ export fn entry() void {
 
 // error
 //
-// :1:17: error: struct 'tmp.LhsExpr' depends on itself
+// error: dependency loop with length 2
+// :2:14: note: type 'tmp.LhsExpr' depends on type 'tmp.AstObject' for field declared here
+// :5:14: note: type 'tmp.AstObject' depends on type 'tmp.LhsExpr' for field declared here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/struct_depends_on_pointer_alignment.zig b/test/cases/compile_errors/struct_depends_on_pointer_alignment.zig
deleted file mode 100644
index ca15cc6bf26d17527cd77fe73200130ab130609c..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/struct_depends_on_pointer_alignment.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const S = struct {
-    next: ?*align(1) S align(128),
-};
-
-export fn entry() usize {
-    return @alignOf(S);
-}
-
-// error
-//
-// :1:11: error: struct layout depends on being pointer aligned
diff --git a/test/cases/compile_errors/too_big_packed_struct.zig b/test/cases/compile_errors/too_big_packed_struct.zig
index b5b585b70ca1f5a71867f8afe3751733bfea8f02..425442ae179ee3649a9247a8f8fa1d550ee5bebe 100644
--- a/test/cases/compile_errors/too_big_packed_struct.zig
+++ b/test/cases/compile_errors/too_big_packed_struct.zig
@@ -8,4 +8,4 @@ pub export fn entry() void {
 
 // error
 //
-// :2:22: error: size of packed struct '131070' exceeds maximum bit width of 65535
+// :2:22: error: packed struct bit width '131070' exceeds maximum bit width of 65535
diff --git a/test/cases/compile_errors/top_level_decl_dependency_loop.zig b/test/cases/compile_errors/top_level_decl_dependency_loop.zig
index fbfd0e9cb376a385b2f19c0edc239d97e6777a38..4412c38f6e672b4a6ca8e2e26dca77ba1fee3bb8 100644
--- a/test/cases/compile_errors/top_level_decl_dependency_loop.zig
+++ b/test/cases/compile_errors/top_level_decl_dependency_loop.zig
@@ -7,4 +7,9 @@ export fn entry() void {
 
 // error
 //
-// :1:1: error: dependency loop detected
+// error: dependency loop with length 4
+// :1:23: note: value of declaration 'tmp.a' uses type of declaration 'tmp.a' here
+// :1:18: note: type of declaration 'tmp.a' uses value of declaration 'tmp.b' here
+// :2:23: note: value of declaration 'tmp.b' uses type of declaration 'tmp.b' here
+// :2:18: note: type of declaration 'tmp.b' uses value of declaration 'tmp.a' here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/unable_to_evaluate_comptime_expr.zig b/test/cases/compile_errors/unable_to_evaluate_comptime_expr.zig
index ba9de49ebca46fe46ae1fb823f399b8926e978ae..e1cff784d522ac3fad1806c93fd3999eb379e930 100644
--- a/test/cases/compile_errors/unable_to_evaluate_comptime_expr.zig
+++ b/test/cases/compile_errors/unable_to_evaluate_comptime_expr.zig
@@ -16,22 +16,6 @@ pub export fn entry2() void {
     _ = b;
 }
 
-const Int = @typeInfo(bar).@"struct".backing_integer.?;
-
-const foo = enum(Int) {
-    c = @bitCast(bar{
-        .name = "test",
-    }),
-};
-
-const bar = packed struct {
-    name: [*:0]const u8,
-};
-
-pub export fn entry3() void {
-    _ = @field(foo, "c");
-}
-
 // error
 //
 // :7:13: error: unable to evaluate comptime expression
@@ -40,6 +24,3 @@ pub export fn entry3() void {
 // :13:13: error: unable to evaluate comptime expression
 // :13:16: note: operation is runtime due to this operand
 // :13:13: note: initializer of container-level variable must be comptime-known
-// :22:9: error: unable to evaluate comptime expression
-// :22:21: note: operation is runtime due to this operand
-// :21:13: note: enum field values must be comptime-known
diff --git a/test/cases/compile_errors/undef_arith_is_illegal.zig b/test/cases/compile_errors/undef_arith_is_illegal.zig
index 21ca597e878507ab1d723017e061d3a201cdef6b..92279a055835346547e5143a031aa8f0612278bc 100644
--- a/test/cases/compile_errors/undef_arith_is_illegal.zig
+++ b/test/cases/compile_errors/undef_arith_is_illegal.zig
@@ -192,50 +192,30 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
@@ -244,10 +224,6 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
-// :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
-// :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
@@ -256,7 +232,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -266,9 +244,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -278,7 +256,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -288,9 +268,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -300,7 +280,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -310,9 +292,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -322,7 +304,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -332,9 +316,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -344,7 +328,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -354,9 +340,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -366,7 +352,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -376,9 +364,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '1'
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -388,7 +376,9 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '0'
 // :65:17: error: use of undefined value here causes illegal behavior
@@ -402,35 +392,45 @@ const std = @import("std");
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
 // :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
 // :65:17: error: use of undefined value here causes illegal behavior
-// :65:17: note: when computing vector element at index '0'
+// :65:17: note: when computing vector element at index '1'
+// :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '1'
+// :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '1'
+// :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '1'
+// :65:17: error: use of undefined value here causes illegal behavior
+// :65:17: note: when computing vector element at index '1'
 // :65:21: error: use of undefined value here causes illegal behavior
 // :65:21: note: when computing vector element at index '0'
 // :65:21: error: use of undefined value here causes illegal behavior
@@ -478,50 +478,30 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
@@ -530,10 +510,6 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
-// :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
-// :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
@@ -542,7 +518,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -552,9 +530,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -564,7 +542,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -574,9 +554,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -586,7 +566,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -596,9 +578,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -608,7 +590,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -618,9 +602,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -630,7 +614,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -640,9 +626,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -652,7 +638,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -662,9 +650,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '1'
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -674,7 +662,9 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '0'
 // :69:27: error: use of undefined value here causes illegal behavior
@@ -688,35 +678,45 @@ const std = @import("std");
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
 // :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
 // :69:27: error: use of undefined value here causes illegal behavior
-// :69:27: note: when computing vector element at index '0'
+// :69:27: note: when computing vector element at index '1'
+// :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '1'
+// :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '1'
+// :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '1'
+// :69:27: error: use of undefined value here causes illegal behavior
+// :69:27: note: when computing vector element at index '1'
 // :69:30: error: use of undefined value here causes illegal behavior
 // :69:30: note: when computing vector element at index '0'
 // :69:30: error: use of undefined value here causes illegal behavior
@@ -764,50 +764,30 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
@@ -816,10 +796,6 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
-// :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
-// :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
@@ -828,7 +804,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -838,9 +816,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -850,7 +828,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -860,9 +840,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -872,7 +852,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -882,9 +864,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -894,7 +876,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -904,9 +888,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -916,7 +900,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -926,9 +912,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -938,7 +924,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -948,9 +936,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -960,7 +948,9 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -974,35 +964,45 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
+// :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
+// :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
+// :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
+// :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:30: error: use of undefined value here causes illegal behavior
 // :73:30: note: when computing vector element at index '0'
 // :73:30: error: use of undefined value here causes illegal behavior
@@ -1050,50 +1050,30 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
@@ -1102,10 +1082,6 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
-// :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
-// :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
@@ -1114,7 +1090,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1124,9 +1102,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1136,7 +1114,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1146,9 +1126,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1158,7 +1138,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1168,9 +1150,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1180,7 +1162,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1190,9 +1174,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1202,7 +1186,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1212,9 +1198,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1224,7 +1210,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1234,9 +1222,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '1'
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1246,7 +1234,9 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '0'
 // :77:27: error: use of undefined value here causes illegal behavior
@@ -1260,35 +1250,45 @@ const std = @import("std");
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
 // :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
 // :77:27: error: use of undefined value here causes illegal behavior
-// :77:27: note: when computing vector element at index '0'
+// :77:27: note: when computing vector element at index '1'
+// :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '1'
+// :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '1'
+// :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '1'
+// :77:27: error: use of undefined value here causes illegal behavior
+// :77:27: note: when computing vector element at index '1'
 // :77:30: error: use of undefined value here causes illegal behavior
 // :77:30: note: when computing vector element at index '0'
 // :77:30: error: use of undefined value here causes illegal behavior
@@ -1336,50 +1336,30 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
@@ -1388,10 +1368,6 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
-// :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
-// :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
@@ -1400,7 +1376,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1410,9 +1388,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1422,7 +1400,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1432,9 +1412,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1444,7 +1424,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1454,9 +1436,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1466,7 +1448,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1476,9 +1460,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1488,7 +1472,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1498,9 +1484,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1510,7 +1496,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1520,9 +1508,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '1'
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1532,7 +1520,9 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '0'
 // :81:17: error: use of undefined value here causes illegal behavior
@@ -1546,35 +1536,45 @@ const std = @import("std");
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
 // :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
 // :81:17: error: use of undefined value here causes illegal behavior
-// :81:17: note: when computing vector element at index '0'
+// :81:17: note: when computing vector element at index '1'
+// :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '1'
+// :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '1'
+// :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '1'
+// :81:17: error: use of undefined value here causes illegal behavior
+// :81:17: note: when computing vector element at index '1'
 // :81:21: error: use of undefined value here causes illegal behavior
 // :81:21: note: when computing vector element at index '0'
 // :81:21: error: use of undefined value here causes illegal behavior
@@ -1622,39 +1622,25 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1664,7 +1650,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1674,9 +1662,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1686,7 +1674,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1696,9 +1686,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1708,7 +1698,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1718,10 +1710,6 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
-// :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
-// :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
@@ -1730,8 +1718,6 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
@@ -1740,10 +1726,6 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
-// :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
-// :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
@@ -1752,7 +1734,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1762,9 +1746,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1774,7 +1758,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1784,9 +1770,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1796,7 +1782,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1806,9 +1794,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '1'
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1818,7 +1806,9 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '0'
 // :85:22: error: use of undefined value here causes illegal behavior
@@ -1832,35 +1822,45 @@ const std = @import("std");
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
 // :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
 // :85:22: error: use of undefined value here causes illegal behavior
-// :85:22: note: when computing vector element at index '0'
+// :85:22: note: when computing vector element at index '1'
+// :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '1'
+// :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '1'
+// :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '1'
+// :85:22: error: use of undefined value here causes illegal behavior
+// :85:22: note: when computing vector element at index '1'
 // :85:25: error: use of undefined value here causes illegal behavior
 // :85:25: note: when computing vector element at index '0'
 // :85:25: error: use of undefined value here causes illegal behavior
@@ -1908,50 +1908,30 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
@@ -1960,10 +1940,6 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
-// :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
-// :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
@@ -1972,7 +1948,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -1982,9 +1960,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -1994,7 +1972,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2004,9 +1984,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2016,7 +1996,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2026,9 +2008,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2038,7 +2020,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2048,9 +2032,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2060,7 +2044,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2070,9 +2056,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2082,7 +2068,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2092,9 +2080,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '1'
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2104,7 +2092,9 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '0'
 // :89:22: error: use of undefined value here causes illegal behavior
@@ -2118,35 +2108,45 @@ const std = @import("std");
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
 // :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
 // :89:22: error: use of undefined value here causes illegal behavior
-// :89:22: note: when computing vector element at index '0'
+// :89:22: note: when computing vector element at index '1'
+// :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '1'
+// :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '1'
+// :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '1'
+// :89:22: error: use of undefined value here causes illegal behavior
+// :89:22: note: when computing vector element at index '1'
 // :89:25: error: use of undefined value here causes illegal behavior
 // :89:25: note: when computing vector element at index '0'
 // :89:25: error: use of undefined value here causes illegal behavior
@@ -2198,21 +2198,13 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2220,21 +2212,13 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2242,21 +2226,13 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2264,21 +2240,13 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2286,13 +2254,9 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2302,19 +2266,21 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
-// :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
-// :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2324,19 +2290,25 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2346,19 +2318,25 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '1'
+// :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2368,11 +2346,17 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '0'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2382,19 +2366,25 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2404,19 +2394,25 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
@@ -2426,13 +2422,17 @@ const std = @import("std");
 // :95:17: error: use of undefined value here causes illegal behavior
 // :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
 // :95:17: error: use of undefined value here causes illegal behavior
-// :95:17: note: when computing vector element at index '0'
+// :95:17: note: when computing vector element at index '1'
+// :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
+// :95:17: error: use of undefined value here causes illegal behavior
+// :95:17: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2440,21 +2440,13 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2462,21 +2454,13 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2484,21 +2468,13 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2506,21 +2482,13 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2528,13 +2496,9 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2544,19 +2508,21 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
-// :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
-// :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2566,19 +2532,25 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2588,19 +2560,25 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2610,11 +2588,17 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2624,19 +2608,25 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2646,19 +2636,25 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2668,13 +2664,17 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
+// :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
+// :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2682,21 +2682,13 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2704,21 +2696,13 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2726,21 +2710,13 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2748,21 +2724,13 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2770,13 +2738,9 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2786,19 +2750,21 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
-// :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
-// :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2808,19 +2774,25 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2830,19 +2802,25 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '1'
+// :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2852,11 +2830,17 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '0'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2866,19 +2850,25 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2888,19 +2878,25 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
@@ -2910,13 +2906,17 @@ const std = @import("std");
 // :103:27: error: use of undefined value here causes illegal behavior
 // :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
 // :103:27: error: use of undefined value here causes illegal behavior
-// :103:27: note: when computing vector element at index '0'
+// :103:27: note: when computing vector element at index '1'
+// :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
+// :103:27: error: use of undefined value here causes illegal behavior
+// :103:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -2924,21 +2924,13 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -2946,21 +2938,13 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -2968,21 +2952,13 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -2990,21 +2966,13 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3012,13 +2980,9 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3028,19 +2992,21 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
-// :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
-// :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3050,19 +3016,25 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3072,19 +3044,25 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '1'
+// :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3094,11 +3072,17 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '0'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3108,19 +3092,25 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3130,19 +3120,29 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
+// :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
+// :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
@@ -3152,13 +3152,13 @@ const std = @import("std");
 // :107:27: error: use of undefined value here causes illegal behavior
 // :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :107:27: error: use of undefined value here causes illegal behavior
-// :107:27: note: when computing vector element at index '0'
+// :107:27: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3166,21 +3166,13 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3188,21 +3180,13 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3210,21 +3194,13 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3232,21 +3208,13 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3254,13 +3222,9 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3270,19 +3234,21 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
-// :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
-// :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3292,19 +3258,25 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3314,19 +3286,25 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '1'
+// :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3336,11 +3314,17 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '0'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3350,19 +3334,25 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3372,19 +3362,25 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
@@ -3394,13 +3390,17 @@ const std = @import("std");
 // :111:22: error: use of undefined value here causes illegal behavior
 // :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
 // :111:22: error: use of undefined value here causes illegal behavior
-// :111:22: note: when computing vector element at index '0'
+// :111:22: note: when computing vector element at index '1'
+// :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
+// :111:22: error: use of undefined value here causes illegal behavior
+// :111:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3408,21 +3408,13 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3430,21 +3422,13 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3452,21 +3436,13 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3474,21 +3450,13 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3496,13 +3464,9 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3512,19 +3476,21 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
-// :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
-// :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3534,19 +3500,25 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3556,19 +3528,25 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '1'
+// :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3578,11 +3556,17 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '0'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3592,19 +3576,25 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3614,19 +3604,27 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
+// :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
@@ -3636,37 +3634,32 @@ const std = @import("std");
 // :115:22: error: use of undefined value here causes illegal behavior
 // :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
 // :115:22: error: use of undefined value here causes illegal behavior
-// :115:22: note: when computing vector element at index '0'
+// :115:22: note: when computing vector element at index '1'
+// :115:22: error: use of undefined value here causes illegal behavior
+// :115:22: note: when computing vector element at index '1'
+// :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3674,6 +3667,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3681,7 +3675,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3689,6 +3683,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3696,7 +3691,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3704,6 +3699,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3711,7 +3707,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3719,6 +3715,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3726,7 +3723,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3734,6 +3731,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3741,7 +3739,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3749,6 +3747,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3756,7 +3755,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3764,6 +3763,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3771,7 +3771,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '1'
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3779,6 +3779,7 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '0'
 // :121:17: error: use of undefined value here causes illegal behavior
@@ -3788,126 +3789,120 @@ const std = @import("std");
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
-// :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
 // :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:17: error: use of undefined value here causes illegal behavior
-// :121:17: note: when computing vector element at index '0'
+// :121:17: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
-// :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '1'
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '0'
 // :121:21: error: use of undefined value here causes illegal behavior
@@ -3915,44 +3910,42 @@ const std = @import("std");
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
+// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
+// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
+// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
+// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
 // :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
+// :121:21: note: when computing vector element at index '1'
 // :121:21: error: use of undefined value here causes illegal behavior
-// :121:21: note: when computing vector element at index '0'
+// :121:21: note: when computing vector element at index '1'
+// :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '1'
+// :121:21: error: use of undefined value here causes illegal behavior
+// :121:21: note: when computing vector element at index '1'
+// :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -3960,6 +3953,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -3967,7 +3961,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -3975,6 +3969,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -3982,7 +3977,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -3990,6 +3985,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -3997,7 +3993,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4005,6 +4001,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4012,7 +4009,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4020,6 +4017,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4027,7 +4025,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4035,6 +4033,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4042,7 +4041,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4050,6 +4049,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4057,7 +4057,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '1'
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4065,6 +4065,7 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '0'
 // :125:27: error: use of undefined value here causes illegal behavior
@@ -4074,126 +4075,120 @@ const std = @import("std");
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
-// :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
 // :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:27: error: use of undefined value here causes illegal behavior
-// :125:27: note: when computing vector element at index '0'
+// :125:27: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
-// :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '1'
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '0'
 // :125:30: error: use of undefined value here causes illegal behavior
@@ -4201,44 +4196,42 @@ const std = @import("std");
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
+// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
+// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
+// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
+// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
 // :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
+// :125:30: note: when computing vector element at index '1'
 // :125:30: error: use of undefined value here causes illegal behavior
-// :125:30: note: when computing vector element at index '0'
+// :125:30: note: when computing vector element at index '1'
+// :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '1'
+// :125:30: error: use of undefined value here causes illegal behavior
+// :125:30: note: when computing vector element at index '1'
+// :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4246,6 +4239,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4253,7 +4247,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4261,6 +4255,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4268,7 +4263,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4276,6 +4271,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4283,7 +4279,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4291,6 +4287,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4298,7 +4295,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4306,6 +4303,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4313,7 +4311,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4321,6 +4319,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4328,7 +4327,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4336,6 +4335,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4343,7 +4343,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '1'
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4351,6 +4351,7 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '0'
 // :129:27: error: use of undefined value here causes illegal behavior
@@ -4360,126 +4361,120 @@ const std = @import("std");
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
-// :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
 // :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:27: error: use of undefined value here causes illegal behavior
-// :129:27: note: when computing vector element at index '0'
+// :129:27: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
-// :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '1'
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '0'
 // :129:30: error: use of undefined value here causes illegal behavior
@@ -4487,44 +4482,42 @@ const std = @import("std");
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
+// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
+// :129:30: note: when computing vector element at index '1'
+// :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
+// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
+// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
 // :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
+// :129:30: note: when computing vector element at index '1'
 // :129:30: error: use of undefined value here causes illegal behavior
-// :129:30: note: when computing vector element at index '0'
+// :129:30: note: when computing vector element at index '1'
+// :129:30: error: use of undefined value here causes illegal behavior
+// :129:30: note: when computing vector element at index '1'
+// :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4532,6 +4525,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4539,7 +4533,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4547,6 +4541,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4554,7 +4549,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4562,6 +4557,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4569,7 +4565,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4577,6 +4573,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4584,7 +4581,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4592,6 +4589,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4599,7 +4597,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4607,6 +4605,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4614,7 +4613,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4622,6 +4621,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4629,7 +4629,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '1'
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4637,6 +4637,7 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '0'
 // :133:27: error: use of undefined value here causes illegal behavior
@@ -4646,126 +4647,120 @@ const std = @import("std");
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
-// :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
 // :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:27: error: use of undefined value here causes illegal behavior
-// :133:27: note: when computing vector element at index '0'
+// :133:27: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
-// :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '1'
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '0'
 // :133:30: error: use of undefined value here causes illegal behavior
@@ -4773,44 +4768,42 @@ const std = @import("std");
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
+// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
+// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
+// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
+// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
 // :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
+// :133:30: note: when computing vector element at index '1'
 // :133:30: error: use of undefined value here causes illegal behavior
-// :133:30: note: when computing vector element at index '0'
+// :133:30: note: when computing vector element at index '1'
+// :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '1'
+// :133:30: error: use of undefined value here causes illegal behavior
+// :133:30: note: when computing vector element at index '1'
+// :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4818,6 +4811,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4825,7 +4819,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4833,6 +4827,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4840,7 +4835,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4848,6 +4843,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4855,7 +4851,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4863,6 +4859,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4870,7 +4867,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4878,6 +4875,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4885,7 +4883,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4893,6 +4891,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4900,7 +4899,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4908,6 +4907,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4915,7 +4915,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '1'
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4923,6 +4923,7 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '0'
 // :137:17: error: use of undefined value here causes illegal behavior
@@ -4932,126 +4933,120 @@ const std = @import("std");
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
-// :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
 // :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:17: error: use of undefined value here causes illegal behavior
-// :137:17: note: when computing vector element at index '0'
+// :137:17: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
-// :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '1'
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '0'
 // :137:21: error: use of undefined value here causes illegal behavior
@@ -5059,44 +5054,42 @@ const std = @import("std");
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
+// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
+// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
+// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
+// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
 // :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
+// :137:21: note: when computing vector element at index '1'
 // :137:21: error: use of undefined value here causes illegal behavior
-// :137:21: note: when computing vector element at index '0'
+// :137:21: note: when computing vector element at index '1'
+// :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '1'
+// :137:21: error: use of undefined value here causes illegal behavior
+// :137:21: note: when computing vector element at index '1'
+// :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5104,6 +5097,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5111,7 +5105,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5119,6 +5113,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5126,7 +5121,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5134,6 +5129,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5141,7 +5137,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5149,6 +5145,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5156,7 +5153,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5164,6 +5161,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5171,7 +5169,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5179,6 +5177,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5186,7 +5185,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5194,6 +5193,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5201,7 +5201,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '1'
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5209,6 +5209,7 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '0'
 // :141:22: error: use of undefined value here causes illegal behavior
@@ -5218,126 +5219,120 @@ const std = @import("std");
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
-// :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
 // :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:22: error: use of undefined value here causes illegal behavior
-// :141:22: note: when computing vector element at index '0'
+// :141:22: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
-// :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '1'
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '0'
 // :141:25: error: use of undefined value here causes illegal behavior
@@ -5345,44 +5340,42 @@ const std = @import("std");
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
+// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
+// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
+// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
+// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
 // :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
+// :141:25: note: when computing vector element at index '1'
 // :141:25: error: use of undefined value here causes illegal behavior
-// :141:25: note: when computing vector element at index '0'
+// :141:25: note: when computing vector element at index '1'
+// :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '1'
+// :141:25: error: use of undefined value here causes illegal behavior
+// :141:25: note: when computing vector element at index '1'
+// :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5390,6 +5383,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5397,7 +5391,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5405,6 +5399,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5412,7 +5407,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5420,6 +5415,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5427,7 +5423,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5435,6 +5431,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5442,7 +5439,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5450,6 +5447,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5457,7 +5455,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5465,6 +5463,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5472,7 +5471,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5480,6 +5479,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5487,7 +5487,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '1'
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5495,6 +5495,7 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '0'
 // :145:22: error: use of undefined value here causes illegal behavior
@@ -5504,126 +5505,120 @@ const std = @import("std");
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
-// :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
 // :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:22: error: use of undefined value here causes illegal behavior
-// :145:22: note: when computing vector element at index '0'
+// :145:22: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
-// :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '1'
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '0'
 // :145:25: error: use of undefined value here causes illegal behavior
@@ -5631,20 +5626,25 @@ const std = @import("std");
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
+// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
+// :145:25: note: when computing vector element at index '1'
+// :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
+// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
+// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
 // :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
+// :145:25: note: when computing vector element at index '1'
 // :145:25: error: use of undefined value here causes illegal behavior
-// :145:25: note: when computing vector element at index '0'
+// :145:25: note: when computing vector element at index '1'
+// :145:25: error: use of undefined value here causes illegal behavior
+// :145:25: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5652,21 +5652,13 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5674,21 +5666,13 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5696,21 +5680,13 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5718,21 +5694,13 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5740,13 +5708,9 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5756,19 +5720,21 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
-// :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
-// :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5778,19 +5744,25 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5800,19 +5772,25 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '1'
+// :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5822,11 +5800,17 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '0'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5836,19 +5820,25 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5858,19 +5848,25 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
@@ -5880,13 +5876,17 @@ const std = @import("std");
 // :151:21: error: use of undefined value here causes illegal behavior
 // :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
 // :151:21: error: use of undefined value here causes illegal behavior
-// :151:21: note: when computing vector element at index '0'
+// :151:21: note: when computing vector element at index '1'
+// :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
+// :151:21: error: use of undefined value here causes illegal behavior
+// :151:21: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -5894,21 +5894,13 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -5916,21 +5908,13 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -5938,21 +5922,13 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -5960,21 +5936,13 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -5982,13 +5950,9 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -5998,19 +5962,21 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
-// :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
-// :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -6020,19 +5986,25 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -6042,19 +6014,25 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '1'
+// :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -6064,11 +6042,17 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '0'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -6078,19 +6062,25 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -6100,19 +6090,25 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
@@ -6122,13 +6118,17 @@ const std = @import("std");
 // :155:30: error: use of undefined value here causes illegal behavior
 // :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
 // :155:30: error: use of undefined value here causes illegal behavior
-// :155:30: note: when computing vector element at index '0'
+// :155:30: note: when computing vector element at index '1'
+// :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
+// :155:30: error: use of undefined value here causes illegal behavior
+// :155:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6136,21 +6136,13 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6158,21 +6150,13 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6180,21 +6164,13 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6202,21 +6178,13 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6224,13 +6192,9 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6240,19 +6204,21 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
-// :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
-// :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6262,19 +6228,25 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6284,19 +6256,25 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '1'
+// :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6306,11 +6284,17 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '0'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6320,19 +6304,25 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6342,19 +6332,27 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
+// :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
@@ -6364,13 +6362,15 @@ const std = @import("std");
 // :159:30: error: use of undefined value here causes illegal behavior
 // :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
 // :159:30: error: use of undefined value here causes illegal behavior
-// :159:30: note: when computing vector element at index '0'
+// :159:30: note: when computing vector element at index '1'
+// :159:30: error: use of undefined value here causes illegal behavior
+// :159:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6378,21 +6378,13 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6400,21 +6392,13 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6422,21 +6406,13 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6444,21 +6420,13 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6466,13 +6434,9 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6482,19 +6446,21 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
-// :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
-// :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6504,19 +6470,25 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6526,19 +6498,25 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '1'
+// :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6548,11 +6526,19 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '0'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
+// :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6562,19 +6548,27 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
+// :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6584,19 +6578,25 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
@@ -6606,13 +6606,13 @@ const std = @import("std");
 // :163:30: error: use of undefined value here causes illegal behavior
 // :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :163:30: error: use of undefined value here causes illegal behavior
-// :163:30: note: when computing vector element at index '0'
+// :163:30: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6620,21 +6620,13 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6642,21 +6634,13 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6664,21 +6648,13 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6686,21 +6662,13 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6708,13 +6676,9 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6724,19 +6688,21 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
-// :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
-// :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6746,19 +6712,25 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6768,19 +6740,25 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '1'
+// :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6790,11 +6768,21 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '0'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
+// :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
+// :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6804,19 +6792,25 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6826,19 +6820,25 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
@@ -6848,13 +6848,13 @@ const std = @import("std");
 // :167:25: error: use of undefined value here causes illegal behavior
 // :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :167:25: error: use of undefined value here causes illegal behavior
-// :167:25: note: when computing vector element at index '0'
+// :167:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6862,21 +6862,13 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6884,21 +6876,13 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6906,21 +6890,13 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6928,21 +6904,13 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6950,13 +6918,9 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6966,19 +6930,21 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
-// :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
-// :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -6988,19 +6954,25 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -7010,19 +6982,25 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '1'
+// :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -7032,11 +7010,17 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '0'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -7046,19 +7030,25 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -7068,19 +7058,25 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
@@ -7090,37 +7086,33 @@ const std = @import("std");
 // :171:25: error: use of undefined value here causes illegal behavior
 // :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
 // :171:25: error: use of undefined value here causes illegal behavior
-// :171:25: note: when computing vector element at index '0'
+// :171:25: note: when computing vector element at index '1'
+// :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
+// :171:25: error: use of undefined value here causes illegal behavior
+// :171:25: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7130,9 +7122,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7142,7 +7134,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7152,9 +7146,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7164,7 +7158,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7174,9 +7170,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7186,7 +7182,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7196,9 +7194,9 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '1'
+// :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
@@ -7208,27 +7206,29 @@ const std = @import("std");
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '0'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
 // :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:17: error: use of undefined value here causes illegal behavior
-// :177:17: note: when computing vector element at index '0'
+// :177:17: note: when computing vector element at index '1'
 // :177:21: error: use of undefined value here causes illegal behavior
 // :177:21: note: when computing vector element at index '0'
 // :177:21: error: use of undefined value here causes illegal behavior
@@ -7256,27 +7256,19 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7286,9 +7278,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7298,7 +7290,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7308,9 +7302,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7320,7 +7314,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7330,9 +7326,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7342,7 +7338,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7352,9 +7350,9 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '1'
+// :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
@@ -7364,27 +7362,29 @@ const std = @import("std");
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '0'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
 // :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:17: error: use of undefined value here causes illegal behavior
-// :180:17: note: when computing vector element at index '0'
+// :180:17: note: when computing vector element at index '1'
 // :180:21: error: use of undefined value here causes illegal behavior
 // :180:21: note: when computing vector element at index '0'
 // :180:21: error: use of undefined value here causes illegal behavior
@@ -7412,27 +7412,19 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7442,9 +7434,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7454,7 +7446,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7464,9 +7458,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7476,7 +7470,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7486,9 +7482,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7498,7 +7494,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7508,9 +7506,9 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '1'
+// :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
@@ -7520,27 +7518,29 @@ const std = @import("std");
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '0'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
 // :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:17: error: use of undefined value here causes illegal behavior
-// :183:17: note: when computing vector element at index '0'
+// :183:17: note: when computing vector element at index '1'
 // :183:21: error: use of undefined value here causes illegal behavior
 // :183:21: note: when computing vector element at index '0'
 // :183:21: error: use of undefined value here causes illegal behavior
diff --git a/test/cases/compile_errors/undef_arith_returns_undef.zig b/test/cases/compile_errors/undef_arith_returns_undef.zig
index 4c2c096b98ebc47c05bc9246e08e047d1b312119..40dbe1671523e24358e9260f9d90a9ef70afdbec 100644
--- a/test/cases/compile_errors/undef_arith_returns_undef.zig
+++ b/test/cases/compile_errors/undef_arith_returns_undef.zig
@@ -681,810 +681,260 @@ inline fn testFloatWithValue(comptime Float: type, x: Float) void {
 // @as(@Vector(2, u8), undefined)
 // @as(@Vector(2, u8), [runtime value])
 // @as(@Vector(2, u8), [runtime value])
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 6, undefined })
-// @as(@Vector(2, i8), .{ undefined, 6 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 6, undefined })
-// @as(@Vector(2, i8), .{ 6, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 6 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 6 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 6, undefined })
-// @as(@Vector(2, i8), .{ undefined, 6 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 6, undefined })
-// @as(@Vector(2, i8), .{ 6, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 6 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 6 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 9, undefined })
-// @as(@Vector(2, i8), .{ undefined, 9 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 9, undefined })
-// @as(@Vector(2, i8), .{ 9, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 9 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 9 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 9, undefined })
-// @as(@Vector(2, i8), .{ undefined, 9 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 9, undefined })
-// @as(@Vector(2, i8), .{ 9, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 9 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 9 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), .{ 0, undefined })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), .{ undefined, 0 })
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, [runtime value])
-// @as(i8, [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), [runtime value])
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(i8, undefined)
-// @as(@Vector(2, i8), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 6, undefined })
-// @as(@Vector(2, u32), .{ undefined, 6 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 6, undefined })
-// @as(@Vector(2, u32), .{ 6, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 6 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 6 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 6, undefined })
-// @as(@Vector(2, u32), .{ undefined, 6 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 6, undefined })
-// @as(@Vector(2, u32), .{ 6, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 6 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 6 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 9, undefined })
-// @as(@Vector(2, u32), .{ undefined, 9 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 9, undefined })
-// @as(@Vector(2, u32), .{ 9, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 9 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 9 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 9, undefined })
-// @as(@Vector(2, u32), .{ undefined, 9 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 9, undefined })
-// @as(@Vector(2, u32), .{ 9, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 9 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 9 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 24, undefined })
-// @as(@Vector(2, u32), .{ undefined, 24 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 24, undefined })
-// @as(@Vector(2, u32), .{ 24, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 24 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 24 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), .{ 0, undefined })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), .{ undefined, 0 })
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u1, undefined)
-// @as(@Vector(2, u1), .{ 1, undefined })
-// @as(@Vector(2, u1), .{ undefined, 1 })
-// @as(@Vector(2, u1), undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, [runtime value])
-// @as(u32, [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), [runtime value])
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u32, undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(u1, undefined)
-// @as(@Vector(2, u1), [runtime value])
-// @as(@Vector(2, u1), [runtime value])
-// @as(@Vector(2, u1), undefined)
-// @as(u32, undefined)
-// @as(@Vector(2, u32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 6, undefined })
-// @as(@Vector(2, i32), .{ undefined, 6 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 6, undefined })
-// @as(@Vector(2, i32), .{ 6, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 6 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 6 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 6, undefined })
-// @as(@Vector(2, i32), .{ undefined, 6 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 6, undefined })
-// @as(@Vector(2, i32), .{ 6, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 6 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 6 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 9, undefined })
-// @as(@Vector(2, i32), .{ undefined, 9 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 9, undefined })
-// @as(@Vector(2, i32), .{ 9, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 9 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 9 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 9, undefined })
-// @as(@Vector(2, i32), .{ undefined, 9 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 9, undefined })
-// @as(@Vector(2, i32), .{ 9, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 9 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 9 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), .{ 0, undefined })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), .{ undefined, 0 })
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, [runtime value])
-// @as(i32, [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), [runtime value])
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(@Vector(2, i32), undefined)
-// @as(i32, undefined)
-// @as(@Vector(2, i32), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, [runtime value])
+// @as(i500, [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(@Vector(2, i500), undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), undefined)
 // @as(u500, undefined)
 // @as(u500, undefined)
 // @as(@Vector(2, u500), .{ 6, undefined })
@@ -1779,702 +1229,812 @@ inline fn testFloatWithValue(comptime Float: type, x: Float) void {
 // @as(@Vector(2, u1), [runtime value])
 // @as(@Vector(2, u1), [runtime value])
 // @as(@Vector(2, u1), undefined)
-// @as(u500, undefined)
-// @as(@Vector(2, u500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 6, undefined })
-// @as(@Vector(2, i500), .{ undefined, 6 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 6, undefined })
-// @as(@Vector(2, i500), .{ 6, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 6 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 6 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 6, undefined })
-// @as(@Vector(2, i500), .{ undefined, 6 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 6, undefined })
-// @as(@Vector(2, i500), .{ 6, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 6 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 6 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 9, undefined })
-// @as(@Vector(2, i500), .{ undefined, 9 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 9, undefined })
-// @as(@Vector(2, i500), .{ 9, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 9 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 9 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 9, undefined })
-// @as(@Vector(2, i500), .{ undefined, 9 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 9, undefined })
-// @as(@Vector(2, i500), .{ 9, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 9 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 9 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), .{ 0, undefined })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), .{ undefined, 0 })
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, [runtime value])
-// @as(i500, [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), [runtime value])
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(i500, undefined)
-// @as(@Vector(2, i500), undefined)
-// @as(f16, undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), .{ 6, undefined })
-// @as(@Vector(2, f16), .{ undefined, 6 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ 6, undefined })
-// @as(@Vector(2, f16), .{ 6, undefined })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ undefined, 6 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ undefined, 6 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), .{ 0, undefined })
-// @as(@Vector(2, f16), .{ undefined, 0 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ 0, undefined })
-// @as(@Vector(2, f16), .{ 0, undefined })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ undefined, 0 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ undefined, 0 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), .{ 9, undefined })
-// @as(@Vector(2, f16), .{ undefined, 9 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ 9, undefined })
-// @as(@Vector(2, f16), .{ 9, undefined })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ undefined, 9 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), .{ undefined, 9 })
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), .{ -3, undefined })
-// @as(@Vector(2, f16), .{ undefined, -3 })
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(@Vector(2, f16), undefined)
-// @as(f16, undefined)
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), [runtime value])
-// @as(@Vector(2, f16), undefined)
-// @as(f32, undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), .{ 6, undefined })
-// @as(@Vector(2, f32), .{ undefined, 6 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ 6, undefined })
-// @as(@Vector(2, f32), .{ 6, undefined })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ undefined, 6 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ undefined, 6 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), .{ 0, undefined })
-// @as(@Vector(2, f32), .{ undefined, 0 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ 0, undefined })
-// @as(@Vector(2, f32), .{ 0, undefined })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ undefined, 0 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ undefined, 0 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), .{ 9, undefined })
-// @as(@Vector(2, f32), .{ undefined, 9 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ 9, undefined })
-// @as(@Vector(2, f32), .{ 9, undefined })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ undefined, 9 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), .{ undefined, 9 })
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), .{ -3, undefined })
-// @as(@Vector(2, f32), .{ undefined, -3 })
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(@Vector(2, f32), undefined)
-// @as(f32, undefined)
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), [runtime value])
-// @as(@Vector(2, f32), undefined)
-// @as(f64, undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), .{ 6, undefined })
-// @as(@Vector(2, f64), .{ undefined, 6 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ 6, undefined })
-// @as(@Vector(2, f64), .{ 6, undefined })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ undefined, 6 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ undefined, 6 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), .{ 0, undefined })
-// @as(@Vector(2, f64), .{ undefined, 0 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ 0, undefined })
-// @as(@Vector(2, f64), .{ 0, undefined })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ undefined, 0 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ undefined, 0 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), .{ 9, undefined })
-// @as(@Vector(2, f64), .{ undefined, 9 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ 9, undefined })
-// @as(@Vector(2, f64), .{ 9, undefined })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ undefined, 9 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), .{ undefined, 9 })
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), .{ -3, undefined })
-// @as(@Vector(2, f64), .{ undefined, -3 })
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(@Vector(2, f64), undefined)
-// @as(f64, undefined)
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), [runtime value])
-// @as(@Vector(2, f64), undefined)
-// @as(f80, undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), .{ 6, undefined })
-// @as(@Vector(2, f80), .{ undefined, 6 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ 6, undefined })
-// @as(@Vector(2, f80), .{ 6, undefined })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ undefined, 6 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ undefined, 6 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), .{ 0, undefined })
-// @as(@Vector(2, f80), .{ undefined, 0 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ 0, undefined })
-// @as(@Vector(2, f80), .{ 0, undefined })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ undefined, 0 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ undefined, 0 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), .{ 9, undefined })
-// @as(@Vector(2, f80), .{ undefined, 9 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ 9, undefined })
-// @as(@Vector(2, f80), .{ 9, undefined })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ undefined, 9 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), .{ undefined, 9 })
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), .{ -3, undefined })
-// @as(@Vector(2, f80), .{ undefined, -3 })
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(@Vector(2, f80), undefined)
-// @as(f80, undefined)
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), [runtime value])
-// @as(@Vector(2, f80), undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, [runtime value])
+// @as(i32, [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 24, undefined })
+// @as(@Vector(2, u32), .{ undefined, 24 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 24, undefined })
+// @as(@Vector(2, u32), .{ 24, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 24 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 24 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u1, undefined)
+// @as(@Vector(2, u1), .{ 1, undefined })
+// @as(@Vector(2, u1), .{ undefined, 1 })
+// @as(@Vector(2, u1), undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, [runtime value])
+// @as(u32, [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(u1, undefined)
+// @as(@Vector(2, u1), [runtime value])
+// @as(@Vector(2, u1), [runtime value])
+// @as(@Vector(2, u1), undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, [runtime value])
+// @as(i8, [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(@Vector(2, i8), undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), undefined)
 // @as(f128, undefined)
 // @as(f128, undefined)
 // @as(@Vector(2, f128), .{ 6, undefined })
@@ -2585,3 +2145,443 @@ inline fn testFloatWithValue(comptime Float: type, x: Float) void {
 // @as(@Vector(2, f128), [runtime value])
 // @as(@Vector(2, f128), [runtime value])
 // @as(@Vector(2, f128), undefined)
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ 6, undefined })
+// @as(@Vector(2, f80), .{ undefined, 6 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ 6, undefined })
+// @as(@Vector(2, f80), .{ 6, undefined })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ undefined, 6 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ undefined, 6 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ 0, undefined })
+// @as(@Vector(2, f80), .{ undefined, 0 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ 0, undefined })
+// @as(@Vector(2, f80), .{ 0, undefined })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ undefined, 0 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ undefined, 0 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ 9, undefined })
+// @as(@Vector(2, f80), .{ undefined, 9 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ 9, undefined })
+// @as(@Vector(2, f80), .{ 9, undefined })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ undefined, 9 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), .{ undefined, 9 })
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ -3, undefined })
+// @as(@Vector(2, f80), .{ undefined, -3 })
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(@Vector(2, f80), undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), undefined)
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ 6, undefined })
+// @as(@Vector(2, f64), .{ undefined, 6 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ 6, undefined })
+// @as(@Vector(2, f64), .{ 6, undefined })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ undefined, 6 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ undefined, 6 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ 0, undefined })
+// @as(@Vector(2, f64), .{ undefined, 0 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ 0, undefined })
+// @as(@Vector(2, f64), .{ 0, undefined })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ undefined, 0 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ undefined, 0 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ 9, undefined })
+// @as(@Vector(2, f64), .{ undefined, 9 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ 9, undefined })
+// @as(@Vector(2, f64), .{ 9, undefined })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ undefined, 9 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), .{ undefined, 9 })
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ -3, undefined })
+// @as(@Vector(2, f64), .{ undefined, -3 })
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(@Vector(2, f64), undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), undefined)
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ 6, undefined })
+// @as(@Vector(2, f32), .{ undefined, 6 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ 6, undefined })
+// @as(@Vector(2, f32), .{ 6, undefined })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ undefined, 6 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ undefined, 6 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ 0, undefined })
+// @as(@Vector(2, f32), .{ undefined, 0 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ 0, undefined })
+// @as(@Vector(2, f32), .{ 0, undefined })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ undefined, 0 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ undefined, 0 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ 9, undefined })
+// @as(@Vector(2, f32), .{ undefined, 9 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ 9, undefined })
+// @as(@Vector(2, f32), .{ 9, undefined })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ undefined, 9 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), .{ undefined, 9 })
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ -3, undefined })
+// @as(@Vector(2, f32), .{ undefined, -3 })
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(@Vector(2, f32), undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), undefined)
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ 6, undefined })
+// @as(@Vector(2, f16), .{ undefined, 6 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ 6, undefined })
+// @as(@Vector(2, f16), .{ 6, undefined })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ undefined, 6 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ undefined, 6 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ 0, undefined })
+// @as(@Vector(2, f16), .{ undefined, 0 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ 0, undefined })
+// @as(@Vector(2, f16), .{ 0, undefined })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ undefined, 0 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ undefined, 0 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ 9, undefined })
+// @as(@Vector(2, f16), .{ undefined, 9 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ 9, undefined })
+// @as(@Vector(2, f16), .{ 9, undefined })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ undefined, 9 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), .{ undefined, 9 })
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ -3, undefined })
+// @as(@Vector(2, f16), .{ undefined, -3 })
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(@Vector(2, f16), undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), undefined)
diff --git a/test/cases/compile_errors/undef_shifts_are_illegal.zig b/test/cases/compile_errors/undef_shifts_are_illegal.zig
index 20c4571408db755b1d38f99585342106b7a94d0c..518da69194e8c43a831a8745cf985780307ab5d9 100644
--- a/test/cases/compile_errors/undef_shifts_are_illegal.zig
+++ b/test/cases/compile_errors/undef_shifts_are_illegal.zig
@@ -125,27 +125,19 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -155,9 +147,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -167,7 +159,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -177,9 +171,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -189,7 +183,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -199,9 +195,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -211,7 +207,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -221,9 +219,9 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '1'
+// :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
@@ -233,27 +231,29 @@ const std = @import("std");
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '0'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
 // :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:17: error: use of undefined value here causes illegal behavior
-// :53:17: note: when computing vector element at index '0'
+// :53:17: note: when computing vector element at index '1'
 // :53:22: error: use of undefined value here causes illegal behavior
 // :53:22: note: when computing vector element at index '0'
 // :53:22: error: use of undefined value here causes illegal behavior
@@ -281,27 +281,19 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -311,9 +303,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -323,7 +315,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -333,9 +327,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -345,7 +339,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -355,9 +351,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -367,7 +363,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -377,9 +375,9 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '1'
+// :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
@@ -389,27 +387,29 @@ const std = @import("std");
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '0'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
 // :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:27: error: use of undefined value here causes illegal behavior
-// :56:27: note: when computing vector element at index '0'
+// :56:27: note: when computing vector element at index '1'
 // :56:30: error: use of undefined value here causes illegal behavior
 // :56:30: note: when computing vector element at index '0'
 // :56:30: error: use of undefined value here causes illegal behavior
@@ -437,27 +437,19 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -467,9 +459,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -479,7 +471,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -489,9 +483,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -501,7 +495,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -511,9 +507,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -523,7 +519,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -533,9 +531,9 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '1'
+// :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
@@ -545,27 +543,29 @@ const std = @import("std");
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '0'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
 // :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:34: error: use of undefined value here causes illegal behavior
-// :59:34: note: when computing vector element at index '0'
+// :59:34: note: when computing vector element at index '1'
 // :59:37: error: use of undefined value here causes illegal behavior
 // :59:37: note: when computing vector element at index '0'
 // :59:37: error: use of undefined value here causes illegal behavior
@@ -593,27 +593,19 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -623,9 +615,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -635,7 +627,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -645,9 +639,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -657,7 +651,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -667,9 +663,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -679,7 +675,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -689,9 +687,9 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '1'
+// :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
@@ -701,27 +699,29 @@ const std = @import("std");
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '0'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
 // :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:17: error: use of undefined value here causes illegal behavior
-// :62:17: note: when computing vector element at index '0'
+// :62:17: note: when computing vector element at index '1'
 // :62:22: error: use of undefined value here causes illegal behavior
 // :62:22: note: when computing vector element at index '0'
 // :62:22: error: use of undefined value here causes illegal behavior
@@ -749,27 +749,19 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -779,9 +771,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -791,7 +783,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -801,9 +795,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -813,7 +807,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -823,9 +819,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -835,7 +831,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -845,9 +843,9 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '1'
+// :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
@@ -857,27 +855,29 @@ const std = @import("std");
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '0'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
 // :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:27: error: use of undefined value here causes illegal behavior
-// :65:27: note: when computing vector element at index '0'
+// :65:27: note: when computing vector element at index '1'
 // :65:30: error: use of undefined value here causes illegal behavior
 // :65:30: note: when computing vector element at index '0'
 // :65:30: error: use of undefined value here causes illegal behavior
@@ -909,21 +909,13 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
@@ -931,21 +923,13 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
@@ -953,13 +937,11 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
@@ -969,19 +951,25 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '1'
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
@@ -991,11 +979,17 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '0'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
@@ -1005,19 +999,25 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
@@ -1027,13 +1027,13 @@ const std = @import("std");
 // :70:17: error: use of undefined value here causes illegal behavior
 // :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :70:17: error: use of undefined value here causes illegal behavior
-// :70:17: note: when computing vector element at index '0'
+// :70:17: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1041,21 +1041,13 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1063,21 +1055,13 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1085,13 +1069,11 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1101,19 +1083,25 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '1'
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1123,11 +1111,17 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '0'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1137,19 +1131,25 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
@@ -1159,13 +1159,13 @@ const std = @import("std");
 // :73:27: error: use of undefined value here causes illegal behavior
 // :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :73:27: error: use of undefined value here causes illegal behavior
-// :73:27: note: when computing vector element at index '0'
+// :73:27: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1173,21 +1173,13 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1195,21 +1187,13 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1217,13 +1201,11 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1233,19 +1215,25 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '1'
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1255,11 +1243,17 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '0'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1269,19 +1263,25 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
@@ -1291,13 +1291,13 @@ const std = @import("std");
 // :76:34: error: use of undefined value here causes illegal behavior
 // :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :76:34: error: use of undefined value here causes illegal behavior
-// :76:34: note: when computing vector element at index '0'
+// :76:34: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1305,21 +1305,13 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1327,21 +1319,13 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1349,13 +1333,11 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1365,19 +1347,25 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '1'
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1387,11 +1375,17 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '0'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1401,19 +1395,25 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
@@ -1423,13 +1423,13 @@ const std = @import("std");
 // :79:17: error: use of undefined value here causes illegal behavior
 // :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :79:17: error: use of undefined value here causes illegal behavior
-// :79:17: note: when computing vector element at index '0'
+// :79:17: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1437,21 +1437,13 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1459,21 +1451,13 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1481,13 +1465,11 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1497,19 +1479,25 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '1'
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1519,11 +1507,17 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '0'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1533,19 +1527,25 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
@@ -1555,44 +1555,37 @@ const std = @import("std");
 // :82:27: error: use of undefined value here causes illegal behavior
 // :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :82:27: error: use of undefined value here causes illegal behavior
-// :82:27: note: when computing vector element at index '0'
+// :82:27: note: when computing vector element at index '1'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '1'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '1'
-// :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1600,7 +1593,7 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '1'
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1608,6 +1601,7 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1615,7 +1609,7 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '1'
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1623,6 +1617,7 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1630,7 +1625,7 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '1'
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1638,6 +1633,7 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
+// :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '0'
 // :87:17: error: use of undefined value here causes illegal behavior
@@ -1647,108 +1643,105 @@ const std = @import("std");
 // :87:17: error: use of undefined value here causes illegal behavior
 // :87:17: note: when computing vector element at index '1'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
+// :87:17: note: when computing vector element at index '1'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
+// :87:17: note: when computing vector element at index '1'
 // :87:17: error: use of undefined value here causes illegal behavior
-// :87:17: note: when computing vector element at index '0'
+// :87:17: note: when computing vector element at index '1'
+// :87:17: error: use of undefined value here causes illegal behavior
+// :87:17: note: when computing vector element at index '1'
+// :87:17: error: use of undefined value here causes illegal behavior
+// :87:17: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '1'
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '1'
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '1'
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '1'
+// :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '0'
 // :87:22: error: use of undefined value here causes illegal behavior
+// :87:22: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
+// :87:22: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
+// :87:22: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
 // :87:22: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
+// :87:22: note: when computing vector element at index '1'
 // :87:22: error: use of undefined value here causes illegal behavior
-// :87:22: note: when computing vector element at index '0'
+// :87:22: note: when computing vector element at index '1'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '1'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '1'
-// :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1756,7 +1749,7 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '1'
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1764,6 +1757,7 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1771,7 +1765,7 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '1'
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1779,6 +1773,7 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1786,7 +1781,7 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '1'
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1794,6 +1789,7 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
+// :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '0'
 // :90:27: error: use of undefined value here causes illegal behavior
@@ -1803,108 +1799,105 @@ const std = @import("std");
 // :90:27: error: use of undefined value here causes illegal behavior
 // :90:27: note: when computing vector element at index '1'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
+// :90:27: note: when computing vector element at index '1'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
+// :90:27: note: when computing vector element at index '1'
 // :90:27: error: use of undefined value here causes illegal behavior
-// :90:27: note: when computing vector element at index '0'
+// :90:27: note: when computing vector element at index '1'
+// :90:27: error: use of undefined value here causes illegal behavior
+// :90:27: note: when computing vector element at index '1'
+// :90:27: error: use of undefined value here causes illegal behavior
+// :90:27: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '1'
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '1'
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '1'
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '1'
+// :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '0'
 // :90:30: error: use of undefined value here causes illegal behavior
+// :90:30: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
+// :90:30: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
+// :90:30: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
 // :90:30: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
+// :90:30: note: when computing vector element at index '1'
 // :90:30: error: use of undefined value here causes illegal behavior
-// :90:30: note: when computing vector element at index '0'
+// :90:30: note: when computing vector element at index '1'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '1'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '1'
-// :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1912,7 +1905,7 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '1'
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1920,6 +1913,7 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1927,7 +1921,7 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '1'
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1935,6 +1929,7 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1942,7 +1937,7 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '1'
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1950,6 +1945,7 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
+// :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '0'
 // :93:34: error: use of undefined value here causes illegal behavior
@@ -1959,108 +1955,105 @@ const std = @import("std");
 // :93:34: error: use of undefined value here causes illegal behavior
 // :93:34: note: when computing vector element at index '1'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
+// :93:34: note: when computing vector element at index '1'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
+// :93:34: note: when computing vector element at index '1'
 // :93:34: error: use of undefined value here causes illegal behavior
-// :93:34: note: when computing vector element at index '0'
+// :93:34: note: when computing vector element at index '1'
+// :93:34: error: use of undefined value here causes illegal behavior
+// :93:34: note: when computing vector element at index '1'
+// :93:34: error: use of undefined value here causes illegal behavior
+// :93:34: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '1'
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '1'
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '1'
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '1'
+// :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '0'
 // :93:37: error: use of undefined value here causes illegal behavior
+// :93:37: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
+// :93:37: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
+// :93:37: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
 // :93:37: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
+// :93:37: note: when computing vector element at index '1'
 // :93:37: error: use of undefined value here causes illegal behavior
-// :93:37: note: when computing vector element at index '0'
+// :93:37: note: when computing vector element at index '1'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '1'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '1'
-// :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2068,7 +2061,7 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '1'
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2076,6 +2069,7 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2083,7 +2077,7 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '1'
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2091,6 +2085,7 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2098,7 +2093,7 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '1'
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2106,6 +2101,7 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
+// :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '0'
 // :96:17: error: use of undefined value here causes illegal behavior
@@ -2115,67 +2111,65 @@ const std = @import("std");
 // :96:17: error: use of undefined value here causes illegal behavior
 // :96:17: note: when computing vector element at index '1'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
+// :96:17: note: when computing vector element at index '1'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
+// :96:17: note: when computing vector element at index '1'
 // :96:17: error: use of undefined value here causes illegal behavior
-// :96:17: note: when computing vector element at index '0'
-// :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
+// :96:17: note: when computing vector element at index '1'
+// :96:17: error: use of undefined value here causes illegal behavior
+// :96:17: note: when computing vector element at index '1'
+// :96:17: error: use of undefined value here causes illegal behavior
+// :96:17: note: when computing vector element at index '1'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '1'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '1'
-// :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '1'
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '1'
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '1'
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '0'
 // :96:22: error: use of undefined value here causes illegal behavior
@@ -2183,40 +2177,39 @@ const std = @import("std");
 // :96:22: error: use of undefined value here causes illegal behavior
 // :96:22: note: when computing vector element at index '1'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
+// :96:22: note: when computing vector element at index '1'
 // :96:22: error: use of undefined value here causes illegal behavior
-// :96:22: note: when computing vector element at index '0'
+// :96:22: note: when computing vector element at index '1'
+// :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '1'
+// :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '1'
+// :96:22: error: use of undefined value here causes illegal behavior
+// :96:22: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
-// :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2224,7 +2217,7 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2232,6 +2225,7 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2239,7 +2233,7 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2247,6 +2241,7 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2254,7 +2249,7 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '1'
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2262,6 +2257,7 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '0'
 // :99:27: error: use of undefined value here causes illegal behavior
@@ -2271,77 +2267,81 @@ const std = @import("std");
 // :99:27: error: use of undefined value here causes illegal behavior
 // :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
 // :99:27: error: use of undefined value here causes illegal behavior
-// :99:27: note: when computing vector element at index '0'
+// :99:27: note: when computing vector element at index '1'
+// :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
+// :99:27: error: use of undefined value here causes illegal behavior
+// :99:27: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '1'
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '1'
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '1'
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '1'
+// :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '0'
 // :99:30: error: use of undefined value here causes illegal behavior
+// :99:30: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
+// :99:30: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
+// :99:30: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
 // :99:30: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
+// :99:30: note: when computing vector element at index '1'
 // :99:30: error: use of undefined value here causes illegal behavior
-// :99:30: note: when computing vector element at index '0'
+// :99:30: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2349,21 +2349,13 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2371,21 +2363,13 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2393,13 +2377,11 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2409,19 +2391,25 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '1'
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2431,11 +2419,17 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '0'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2445,19 +2439,25 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
@@ -2467,13 +2467,13 @@ const std = @import("std");
 // :104:22: error: use of undefined value here causes illegal behavior
 // :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :104:22: error: use of undefined value here causes illegal behavior
-// :104:22: note: when computing vector element at index '0'
+// :104:22: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2481,21 +2481,13 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2503,21 +2495,13 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2525,13 +2509,11 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2541,19 +2523,25 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '1'
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2563,11 +2551,17 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '0'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2577,19 +2571,25 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
@@ -2599,13 +2599,13 @@ const std = @import("std");
 // :107:30: error: use of undefined value here causes illegal behavior
 // :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :107:30: error: use of undefined value here causes illegal behavior
-// :107:30: note: when computing vector element at index '0'
+// :107:30: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2613,21 +2613,13 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2635,21 +2627,13 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2657,13 +2641,11 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2673,19 +2655,25 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '1'
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2695,11 +2683,17 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '0'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2709,19 +2703,25 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
@@ -2731,13 +2731,13 @@ const std = @import("std");
 // :110:37: error: use of undefined value here causes illegal behavior
 // :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :110:37: error: use of undefined value here causes illegal behavior
-// :110:37: note: when computing vector element at index '0'
+// :110:37: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2745,21 +2745,13 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2767,21 +2759,13 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2789,13 +2773,11 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2805,19 +2787,25 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '1'
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2827,11 +2815,17 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '0'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2841,19 +2835,25 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
@@ -2863,13 +2863,13 @@ const std = @import("std");
 // :113:22: error: use of undefined value here causes illegal behavior
 // :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :113:22: error: use of undefined value here causes illegal behavior
-// :113:22: note: when computing vector element at index '0'
+// :113:22: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2877,21 +2877,13 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2899,21 +2891,13 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2921,13 +2905,11 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2937,19 +2919,25 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '1'
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2959,11 +2947,17 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '0'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2973,19 +2967,25 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
@@ -2995,10 +2995,10 @@ const std = @import("std");
 // :116:30: error: use of undefined value here causes illegal behavior
 // :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
 // :116:30: error: use of undefined value here causes illegal behavior
-// :116:30: note: when computing vector element at index '0'
+// :116:30: note: when computing vector element at index '1'
diff --git a/test/cases/compile_errors/union_auto-enum_value_already_taken.zig b/test/cases/compile_errors/union_auto-enum_value_already_taken.zig
index 214fd1bdacd8144e9323c7b451d050c4cec3844f..8756e8400ff263abc78db857a657fbc56bef419d 100644
--- a/test/cases/compile_errors/union_auto-enum_value_already_taken.zig
+++ b/test/cases/compile_errors/union_auto-enum_value_already_taken.zig
@@ -12,5 +12,5 @@ export fn entry() void {
 
 // error
 //
-// :6:9: error: enum tag value 60 already taken
-// :4:9: note: other occurrence here
+// :6:9: error: enum tag value '60' for field 'E' already taken
+// :4:9: note: previous occurrence in field 'C'
diff --git a/test/cases/compile_errors/union_depends_on_pointer_alignment.zig b/test/cases/compile_errors/union_depends_on_pointer_alignment.zig
deleted file mode 100644
index 2b97a3fb54207efde38a61c0fc505f7b0721b984..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/union_depends_on_pointer_alignment.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const U = union {
-    next: ?*align(1) U align(128),
-};
-
-export fn entry() usize {
-    return @alignOf(U);
-}
-
-// error
-//
-// :1:11: error: union layout depends on being pointer aligned
diff --git a/test/cases/compile_errors/union_enum_field_missing.zig b/test/cases/compile_errors/union_enum_field_missing.zig
index c376b72da18c895b2c6c565014f6cc38737f0147..6261d452960947b8ab9e8f8ff1ac17ca3abed35c 100644
--- a/test/cases/compile_errors/union_enum_field_missing.zig
+++ b/test/cases/compile_errors/union_enum_field_missing.zig
@@ -15,6 +15,5 @@ export fn entry() usize {
 
 // error
 //
-// :7:11: error: enum field(s) missing in union
-// :4:5: note: field 'c' missing, declared here
-// :1:11: note: enum declared here
+// :7:11: error: enum field 'c' missing from union
+// :4:5: note: enum field here
diff --git a/test/cases/compile_errors/union_field_ordered_differently_than_enum.zig b/test/cases/compile_errors/union_field_ordered_differently_than_enum.zig
index 5c86fb4080cd7f25cccb3a44c0f9b6415be07b4f..6c1e1ccea8608307964a43ac2347d120b4ed4926 100644
--- a/test/cases/compile_errors/union_field_ordered_differently_than_enum.zig
+++ b/test/cases/compile_errors/union_field_ordered_differently_than_enum.zig
@@ -21,7 +21,6 @@ export fn entry() usize {
 
 // error
 //
-// :4:5: error: union field 'b' ordered differently than corresponding enum field
-// :1:23: note: enum field here
-// :14:5: error: union field 'b' ordered differently than corresponding enum field
-// :10:5: note: enum field here
+// :3:15: error: union field order does not match tag enum field order
+// :5:5: note: union field 'a' is index 1
+// :1:20: note: enum field 'a' is index 0
diff --git a/test/cases/compile_errors/union_noreturn_field_initialized.zig b/test/cases/compile_errors/union_noreturn_field_initialized.zig
index 3fdc1958703ea9076a0399fac46b8bfdae50b822..da0bd8c5d89613e9e9a026d526491f65a1162055 100644
--- a/test/cases/compile_errors/union_noreturn_field_initialized.zig
+++ b/test/cases/compile_errors/union_noreturn_field_initialized.zig
@@ -15,8 +15,8 @@ pub export fn entry2() void {
     const U = union(enum) {
         a: noreturn,
     };
-    var u: U = undefined;
-    u = .a;
+    const u: U = .a;
+    _ = u;
 }
 pub export fn entry3() void {
     const U = union(enum) {
@@ -30,12 +30,12 @@ pub export fn entry3() void {
 
 // error
 //
-// :11:14: error: cannot initialize 'noreturn' field of union
+// :11:14: error: cannot initialize union field with uninstantiable type 'noreturn'
 // :4:9: note: field 'b' declared here
 // :2:15: note: union declared here
-// :19:10: error: cannot initialize 'noreturn' field of union
+// :18:19: error: cannot initialize union field with uninstantiable type 'noreturn'
 // :16:9: note: field 'a' declared here
 // :15:15: note: union declared here
-// :28:13: error: runtime coercion from enum '@typeInfo(tmp.entry3.U).@"union".tag_type.?' to union 'tmp.entry3.U' which has a 'noreturn' field
-// :23:9: note: 'noreturn' field here
+// :28:13: error: runtime coercion from enum '@typeInfo(tmp.entry3.U).@"union".tag_type.?' to union 'tmp.entry3.U' which has non-void fields
+// :23:9: note: field 'a' has uninstantiable type 'noreturn'
 // :22:15: note: union declared here
diff --git a/test/cases/compile_errors/union_with_specified_enum_omits_field.zig b/test/cases/compile_errors/union_with_specified_enum_omits_field.zig
index bae2cf2957016281fced4d06bb6464e644851869..e90e60494558730285faa258fab24e8e5253b9a6 100644
--- a/test/cases/compile_errors/union_with_specified_enum_omits_field.zig
+++ b/test/cases/compile_errors/union_with_specified_enum_omits_field.zig
@@ -13,6 +13,5 @@ export fn entry() usize {
 
 // error
 //
-// :6:17: error: enum field(s) missing in union
-// :4:5: note: field 'C' missing, declared here
-// :1:16: note: enum declared here
+// :6:17: error: enum field 'C' missing from union
+// :4:5: note: enum field here
diff --git a/test/cases/compile_errors/union_with_too_small_explicit_signed_tag_type.zig b/test/cases/compile_errors/union_with_too_small_explicit_signed_tag_type.zig
index 6a6076e9465e594ea0403ad156d6c1fc8f45b6de..fb9e7091017241c16ce3bf8554102ddf7d6fe64b 100644
--- a/test/cases/compile_errors/union_with_too_small_explicit_signed_tag_type.zig
+++ b/test/cases/compile_errors/union_with_too_small_explicit_signed_tag_type.zig
@@ -10,5 +10,4 @@ export fn entry() void {
 
 // error
 //
-// :1:22: error: specified integer tag type cannot represent every field
-// :1:22: note: type 'i2' cannot fit values in range 0...3
+// :4:5: error: enum tag value '2' too large for type 'i2'
diff --git a/test/cases/compile_errors/union_with_too_small_explicit_unsigned_tag_type.zig b/test/cases/compile_errors/union_with_too_small_explicit_unsigned_tag_type.zig
index 830c5634a1281e73b8d1a453a5276503a0e88658..2df10ea0748171a74255c856e8072a2c2d7ab2b7 100644
--- a/test/cases/compile_errors/union_with_too_small_explicit_unsigned_tag_type.zig
+++ b/test/cases/compile_errors/union_with_too_small_explicit_unsigned_tag_type.zig
@@ -11,5 +11,4 @@ export fn entry() void {
 
 // error
 //
-// :1:22: error: specified integer tag type cannot represent every field
-// :1:22: note: type 'u2' cannot fit values in range 0...4
+// :6:5: error: enum tag value '4' too large for type 'u2'
diff --git a/test/cases/compile_errors/untagged_union_integer_conversion.zig b/test/cases/compile_errors/untagged_union_integer_conversion.zig
index e469cd125bc9a957cb9efe5a0e9922d45530cfdb..0a8fb54602598dfdc07f28c75ae06f8c3cd2b783 100644
--- a/test/cases/compile_errors/untagged_union_integer_conversion.zig
+++ b/test/cases/compile_errors/untagged_union_integer_conversion.zig
@@ -1,4 +1,4 @@
-const UntaggedUnion = union {};
+const UntaggedUnion = union { a: void };
 comptime {
     @intFromEnum(@as(UntaggedUnion, undefined));
 }
diff --git a/test/cases/compile_errors/variadic_arg_validation.zig b/test/cases/compile_errors/variadic_arg_validation.zig
index c7a8219f2f54889aa132458828a989856709db90..f28622426f76e7757b4bfa253ae7aac86a3250c9 100644
--- a/test/cases/compile_errors/variadic_arg_validation.zig
+++ b/test/cases/compile_errors/variadic_arg_validation.zig
@@ -25,4 +25,4 @@ pub export fn entry3() void {
 // :14:24: error: cannot pass 'u48' to variadic function
 // :14:24: note: only integers with 0 or power of two bits are extern compatible
 // :18:24: error: cannot pass 'void' to variadic function
-// :18:24: note: 'void' is a zero bit type; for C 'void' use 'anyopaque'
+// :18:24: note: 'void' is a zero bit type
diff --git a/test/cases/compile_errors/zero_width_nonexhaustive_enum.zig b/test/cases/compile_errors/zero_width_nonexhaustive_enum.zig
index a38c5f357adc794b0049473eea29e636bbad0203..4ec7297dce19ae33d988ffc96868f44552ff6752 100644
--- a/test/cases/compile_errors/zero_width_nonexhaustive_enum.zig
+++ b/test/cases/compile_errors/zero_width_nonexhaustive_enum.zig
@@ -1,17 +1,20 @@
 comptime {
-    _ = enum(i0) { a, _ };
+    const E = enum(i0) { a, _ };
+    _ = @as(E, undefined);
 }
 
 comptime {
-    _ = enum(u0) { a, _ };
+    const E = enum(u0) { a, _ };
+    _ = @as(E, undefined);
 }
 
 comptime {
-    _ = enum(u0) { a, b, _ };
+    const E = enum(u0) { a, b, _ };
+    _ = @as(E, undefined);
 }
 
 // error
 //
-// :2:9: error: non-exhaustive enum specifies every value
-// :6:9: error: non-exhaustive enum specifies every value
-// :10:23: error: enumeration value '1' too large for type 'u0'
+// :2:15: error: non-exhaustive enum specifies every value
+// :7:15: error: non-exhaustive enum specifies every value
+// :12:29: error: enum tag value '1' too large for type 'u0'
diff --git a/test/incremental/change_enum_tag_type b/test/incremental/change_enum_tag_type
index 97103351995157bd82b99b96913ffaa6165d2f96..46681407cb6a259e44b1e6071281ecc302b14967 100644
--- a/test/incremental/change_enum_tag_type
+++ b/test/incremental/change_enum_tag_type
@@ -44,7 +44,7 @@ comptime {
 }
 const std = @import("std");
 const io = std.Io.Threaded.global_single_threaded.io();
-#expect_error=main.zig:7:5: error: enumeration value '4' too large for type 'u2'
+#expect_error=main.zig:7:5: error: enum tag value '4' too large for type 'u2'
 #update=increase tag size
 #file=main.zig
 const Tag = u3;
-- 
2.54.0


From 9c9a5e722b84d12de34d16f53355adbe1f5e11d3 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 2 Mar 2026 15:45:35 +0000
Subject: [PATCH 475/499] Sema: match master's weird pointer difference
 semantics for now

...except for master's handling of pointers to vectors, because that was
unambiguously a bug.
---
 src/Sema.zig | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 2af1c8cf107895931f393e0298defc8bd6ddcbda..644bad5dcaf48938a4ecf925f54dbee7d4e1de86 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -15249,15 +15249,25 @@ fn analyzeArithmetic(
                     return sema.failWithInvalidPtrArithmetic(block, src, "pointer-pointer", "subtraction");
                 }
 
-                // MLUGG TODO: these semantics are insane and matching them is causing my soul to fragment into a thousand pieces
+                // TODO: these semantics are really weird. Pointer subtraction works in increments
+                // of the pointer child for indexable pointers (excluding pointers to vectors),
+                // which makes sense, but we also allow it for arbitrary single-item pointers, which
+                // leads to the weird result that subtraction of '*T' works completely differently
+                // depending on whether 'T' is an array. That seems dangerous and confusing, and
+                // requires the odd logic below. This behavior originally came from a now-removed
+                // function `Type.elemType2`, which was removed precisely *because* the thing it did
+                // wasn't really well-defined; for that reason, these semantics were probably
+                // largely accidental to begin with. We should change the langauge to avoid this
+                // confusing behavior. For instance, perhaps pointer subtraction should only work on
+                // indexable pointers.
                 const lhs_elem_ty = ty: {
                     const ptr_elem_ty = lhs_ty.childType(zcu);
-                    if (lhs_ty.ptrSize(zcu) == .one and ptr_elem_ty.isArrayOrVector(zcu)) break :ty ptr_elem_ty.childType(zcu);
+                    if (lhs_ty.ptrSize(zcu) == .one and ptr_elem_ty.zigTypeTag(zcu) == .array) break :ty ptr_elem_ty.childType(zcu);
                     break :ty ptr_elem_ty;
                 };
                 const rhs_elem_ty = ty: {
                     const ptr_elem_ty = rhs_ty.childType(zcu);
-                    if (rhs_ty.ptrSize(zcu) == .one and ptr_elem_ty.isArrayOrVector(zcu)) break :ty ptr_elem_ty.childType(zcu);
+                    if (rhs_ty.ptrSize(zcu) == .one and ptr_elem_ty.zigTypeTag(zcu) == .array) break :ty ptr_elem_ty.childType(zcu);
                     break :ty ptr_elem_ty;
                 };
                 if (lhs_elem_ty.toIntern() != rhs_elem_ty.toIntern()) {
-- 
2.54.0


From c2b42383eb058f4c2bd17738cd73382e6a6672eb Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 2 Mar 2026 17:35:02 +0000
Subject: [PATCH 476/499] compiler,std: various little fixes

---
 lib/std/hash_map.zig  |   6 +--
 src/InternPool.zig    |  16 +++++-
 src/Sema.zig          |  92 ++++++++++++++++++----------------
 src/Value.zig         |   4 +-
 src/Zcu.zig           |   7 ++-
 src/Zcu/PerThread.zig |  80 ++++++++++++++++++++----------
 src/codegen/c.zig     |   6 +--
 src/codegen/llvm.zig  |   2 +-
 src/link.zig          |   5 +-
 src/link/Dwarf.zig    | 112 ++++++++++++++++++++++++++++++++++++++----
 tools/incr-check.zig  |  16 +++---
 11 files changed, 247 insertions(+), 99 deletions(-)

diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
index 58c9397a6b9955a7c0aefc2368a49cbd160cf68d..cb74cbc08b6eb554ff20eb5fe0c920a821ec51e0 100644
--- a/lib/std/hash_map.zig
+++ b/lib/std/hash_map.zig
@@ -1526,9 +1526,9 @@ pub fn HashMapUnmanaged(
         }
 
         comptime {
-            if (!builtin.strip_debug_info) _ = switch (builtin.zig_backend) {
-                .stage2_llvm => &dbHelper,
-                .stage2_x86_64 => KV,
+            if (!builtin.strip_debug_info) switch (builtin.zig_backend) {
+                .stage2_llvm => _ = &dbHelper,
+                .stage2_x86_64 => _ = @as(KV, undefined),
                 else => {},
             };
         }
diff --git a/src/InternPool.zig b/src/InternPool.zig
index da95ed6cc7a40f96b08a7e3a589afb5f93d568df..7a561d6ca246553d16cc11f9f9a00c67e977ddfb 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -3334,11 +3334,17 @@ pub const LoadedStructType = struct {
     field_defaults: Index.Slice,
     field_aligns: Alignment.Slice,
     field_is_comptime_bits: ComptimeBits,
+    /// If `layout` is `.@"packed"`, this is `.empty`.
     field_runtime_order: RuntimeOrder.Slice,
+    /// If `layout` is `.@"packed"`, this is `.empty`.
     field_offsets: Offsets,
+    /// Only valid if `layout` is `.@"packed"`.
     packed_backing_int_type: Index,
+    /// Only valid if `layout` is *not* `.@"packed"`.
     class: TypeClass,
+    /// Only valid if `layout` is *not* `.@"packed"`.
     size: u32,
+    /// Only valid if `layout` is *not* `.@"packed"`.
     alignment: Alignment,
 
     pub const ComptimeBits = struct {
@@ -3516,15 +3522,21 @@ pub const LoadedUnionType = struct {
     tag_usage: TagUsage,
     /// While `tag_usage` indicates whether the union should logically contain a tag, it may be
     /// omitted if the union layout is resolved as OPV or NPV. This field is `true` iff there is an
-    /// actual runtime tag in the union layout.
+    /// actual runtime tag, with one or more runtime bits, in the union layout. It is always `false`
+    /// if `layout` is not `.auto`.
     has_runtime_tag: bool,
     /// Even if `tag_usage == .none` and `has_runtime_tag == false`, this is still populated with
     /// the union's "hypothetical" tag type.
     enum_tag_type: Index,
+    /// Only valid if `layout` is `.@"packed"`.
     packed_backing_int_type: Index,
+    /// Not valid if `layout` is `.@"packed"`.
     class: TypeClass,
+    /// Not valid if `layout` is `.@"packed"`.
     size: u32,
+    /// Not valid if `layout` is `.@"packed"`.
     padding: u32,
+    /// Not valid if `layout` is `.@"packed"`.
     alignment: Alignment,
 
     pub const TagUsage = enum(u2) {
@@ -3898,7 +3910,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType {
         .want_layout = extra.data.bits.want_layout,
         .field_types = field_types,
         .field_aligns = .empty,
-        .has_runtime_tag = undefined,
+        .has_runtime_tag = false,
         .class = undefined,
         .size = undefined,
         .padding = undefined,
diff --git a/src/Sema.zig b/src/Sema.zig
index 644bad5dcaf48938a4ecf925f54dbee7d4e1de86..b266940c0e91e309c788d156f3ab99d760d8d6ff 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -13777,45 +13777,44 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const many_alloc = try block.addBitCast(many_ty, mutable_alloc);
 
             // lhs_dest_slice = dest[0..lhs.len]
-            const slice_ty_ref = Air.internedToRef(slice_ty.toIntern());
-            const lhs_len_ref = try pt.intRef(.usize, lhs_len);
-            const lhs_dest_slice = try block.addInst(.{
-                .tag = .slice,
-                .data = .{ .ty_pl = .{
-                    .ty = slice_ty_ref,
-                    .payload = try sema.addExtra(Air.Bin{
-                        .lhs = many_alloc,
-                        .rhs = lhs_len_ref,
-                    }),
-                } },
-            });
-
-            _ = try block.addBinOp(.memcpy, lhs_dest_slice, lhs);
+            if (lhs_len > 0) {
+                const lhs_dest_slice = try block.addInst(.{
+                    .tag = .slice,
+                    .data = .{ .ty_pl = .{
+                        .ty = .fromType(slice_ty),
+                        .payload = try sema.addExtra(Air.Bin{
+                            .lhs = many_alloc,
+                            .rhs = try pt.intRef(.usize, lhs_len),
+                        }),
+                    } },
+                });
+                _ = try block.addBinOp(.memcpy, lhs_dest_slice, lhs);
+            }
 
             // rhs_dest_slice = dest[lhs.len..][0..rhs.len]
-            const rhs_len_ref = try pt.intRef(.usize, rhs_len);
-            const rhs_dest_offset = try block.addInst(.{
-                .tag = .ptr_add,
-                .data = .{ .ty_pl = .{
-                    .ty = Air.internedToRef(many_ty.toIntern()),
-                    .payload = try sema.addExtra(Air.Bin{
-                        .lhs = many_alloc,
-                        .rhs = lhs_len_ref,
-                    }),
-                } },
-            });
-            const rhs_dest_slice = try block.addInst(.{
-                .tag = .slice,
-                .data = .{ .ty_pl = .{
-                    .ty = slice_ty_ref,
-                    .payload = try sema.addExtra(Air.Bin{
-                        .lhs = rhs_dest_offset,
-                        .rhs = rhs_len_ref,
-                    }),
-                } },
-            });
-
-            _ = try block.addBinOp(.memcpy, rhs_dest_slice, rhs);
+            if (rhs_len > 0) {
+                const rhs_dest_offset = try block.addInst(.{
+                    .tag = .ptr_add,
+                    .data = .{ .ty_pl = .{
+                        .ty = Air.internedToRef(many_ty.toIntern()),
+                        .payload = try sema.addExtra(Air.Bin{
+                            .lhs = many_alloc,
+                            .rhs = try pt.intRef(.usize, lhs_len),
+                        }),
+                    } },
+                });
+                const rhs_dest_slice = try block.addInst(.{
+                    .tag = .slice,
+                    .data = .{ .ty_pl = .{
+                        .ty = .fromType(slice_ty),
+                        .payload = try sema.addExtra(Air.Bin{
+                            .lhs = rhs_dest_offset,
+                            .rhs = try pt.intRef(.usize, rhs_len),
+                        }),
+                    } },
+                });
+                _ = try block.addBinOp(.memcpy, rhs_dest_slice, rhs);
+            }
 
             if (res_sent_val) |sent_val| {
                 const elem_index = try pt.intRef(.usize, result_len);
@@ -18829,7 +18828,7 @@ fn finishStructInit(
             return sema.addConstantMaybeRef(sema.resolveValue(final_val_ref).?, is_ref);
         },
         .@"packed" => {
-            const buf = try sema.arena.alloc(u8, (struct_ty.bitSize(zcu) + 7) / 8);
+            const buf = try sema.arena.alloc(u8, @intCast((struct_ty.bitSize(zcu) + 7) / 8));
             var bit_offset: u16 = 0;
             for (field_inits) |field_init| {
                 const field_val = sema.resolveValue(field_init).?;
@@ -21113,7 +21112,7 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
             else => unreachable,
         };
 
-        if (!dest_err_ty.isAnyError(zcu) and !dest_err_ty.errorSetHasField(err_name, zcu)) {
+        if (result != .superset and !dest_err_ty.errorSetHasField(err_name, zcu)) {
             return sema.fail(block, src, "'error.{f}' not a member of error set '{f}'", .{
                 err_name.fmt(ip), dest_err_ty.fmt(pt),
             });
@@ -25186,9 +25185,18 @@ pub fn explainWhyTypeIsNotExtern(
             else => |cc| try sema.errNote(src_loc, msg, "{t} function cannot be extern", .{cc}),
         },
         .@"enum" => {
-            const tag_ty = ty.intTagType(zcu);
-            try sema.errNote(src_loc, msg, "enum tag type '{f}' is not extern compatible", .{tag_ty.fmt(pt)});
-            try sema.explainWhyTypeIsNotExtern(msg, src_loc, tag_ty, position);
+            const enum_obj = zcu.intern_pool.loadEnumType(ty.toIntern());
+            switch (enum_obj.int_tag_mode) {
+                .auto => {
+                    try sema.errNote(ty.srcLoc(zcu), msg, "integer tag type of enum is inferred", .{});
+                    try sema.errNote(ty.srcLoc(zcu), msg, "consider explicitly specifying the integer tag type", .{});
+                },
+                .explicit => {
+                    const tag_ty: Type = .fromInterned(enum_obj.int_tag_type);
+                    try sema.errNote(ty.srcLoc(zcu), msg, "enum tag type '{f}' is not extern compatible", .{tag_ty.fmt(pt)});
+                    try sema.explainWhyTypeIsNotExtern(msg, ty.srcLoc(zcu), tag_ty, position);
+                },
+            }
         },
         .@"struct" => {
             const struct_obj = zcu.intern_pool.loadStructType(ty.toIntern());
diff --git a/src/Value.zig b/src/Value.zig
index 4cd7995b712a0c05b9e98960bc5198523bc21099..3176520d3628f07050a6821e9040b8a7c12449db 100644
--- a/src/Value.zig
+++ b/src/Value.zig
@@ -895,7 +895,7 @@ pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {
             // Avoid hitting gpa for accesses to small packed structs
             var sfba_state = std.heap.stackFallback(128, zcu.comp.gpa);
             const sfba = sfba_state.get();
-            const buf = try sfba.alloc(u8, (ty.bitSize(zcu) + 7) / 8);
+            const buf = try sfba.alloc(u8, @intCast((ty.bitSize(zcu) + 7) / 8));
             defer sfba.free(buf);
             int_val.writeToPackedMemory(pt, buf, 0) catch |err| switch (err) {
                 error.ReinterpretDeclRef => unreachable, // it's an integer
@@ -2419,7 +2419,7 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory
                 }
                 for (field_vals, 0..) |*field_val, field_idx| {
                     if (field_val.* == .none) {
-                        const default_init = struct_obj.field_inits.get(ip)[field_idx];
+                        const default_init = struct_obj.field_defaults.get(ip)[field_idx];
                         if (default_init == .none) return error.TypeMismatch;
                         field_val.* = default_init;
                     }
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 78144bac16a817a931a23e5d1ba346f7aee374af..0ab053b696e8a63de410bb15310ada4e80cd5e38 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -3686,6 +3686,11 @@ pub const ImportResult = struct {
 pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void {
     const gpa = zcu.comp.gpa;
 
+    if (!dev.env.supports(.incremental)) {
+        // This is the first time `unit` is being analyzed, so there is no stale data to clear.
+        return;
+    }
+
     // Compile errors
     if (zcu.failed_analysis.fetchSwapRemove(unit)) |kv| {
         kv.value.destroy(gpa);
@@ -4309,7 +4314,7 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.AutoArrayHashMapUnmanag
                 });
                 const gop = try units.getOrPut(gpa, other);
                 if (gop.found_existing) break :queue_paired;
-                gop.value_ptr.* = units.values()[unit_idx]; // same reference location
+                gop.value_ptr.* = units.values()[unit_idx - 1]; // same reference location
             }
 
             refs_log.debug("handle unit '{f}'", .{zcu.fmtAnalUnit(unit)});
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 6a7054246eae094e485909243e340bd6865bc5cf..4abfb5157ce8538a27dd8cbeec9d3a0ac6852901 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -1075,7 +1075,6 @@ pub fn ensureMemoizedStateUpToDate(
     const prev_failed = zcu.failed_analysis.contains(unit) or zcu.transitive_failed_analysis.contains(unit);
 
     if (was_outdated) {
-        dev.check(.incremental);
         zcu.resetUnit(unit);
     } else {
         if (prev_failed) return error.AnalysisFail;
@@ -1193,10 +1192,7 @@ pub fn ensureComptimeUnitUpToDate(pt: Zcu.PerThread, cu_id: InternPool.ComptimeU
     const was_outdated = zcu.clearOutdatedState(anal_unit);
 
     if (was_outdated) {
-        // `was_outdated` can be true in the initial update for comptime units, so this isn't a `dev.check`.
-        if (dev.env.supports(.incremental)) {
-            zcu.resetUnit(anal_unit);
-        }
+        zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
         if (zcu.failed_analysis.contains(anal_unit)) return error.AnalysisFail;
@@ -1366,10 +1362,7 @@ pub fn ensureTypeLayoutUpToDate(
     };
 
     if (was_outdated) {
-        // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
-        if (dev.env.supports(.incremental)) {
-            zcu.resetUnit(anal_unit);
-        }
+        zcu.resetUnit(anal_unit);
         // For types, we already know that we have to invalidate all dependees.
         // TODO: we actually *could* detect whether everything was the same. should we bother?
         try zcu.markDependeeOutdated(.marked_po, .{ .type_layout = ty.toIntern() });
@@ -1492,10 +1485,7 @@ pub fn ensureStructDefaultsUpToDate(
     };
 
     if (was_outdated) {
-        // `was_outdated` is true in the initial update, so this isn't a `dev.check`.
-        if (dev.env.supports(.incremental)) {
-            zcu.resetUnit(anal_unit);
-        }
+        zcu.resetUnit(anal_unit);
         // For types, we already know that we have to invalidate all dependees.
         // TODO: we actually *could* detect whether everything was the same. should we bother?
         try zcu.markDependeeOutdated(.marked_po, .{ .struct_defaults = ty.toIntern() });
@@ -1609,7 +1599,6 @@ pub fn ensureNavValUpToDate(
         zcu.transitive_failed_analysis.contains(anal_unit);
 
     if (was_outdated) {
-        dev.check(.incremental);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
@@ -1893,6 +1882,30 @@ fn analyzeNavVal(
         }
     }
 
+    // We're about to resolve the value of the Nav. This causes the information about what the value
+    // was last update to be lost; therefore, if the `nav_ty` is currently out of date, it would
+    // incorrectly think it was unchanged when eventually analyzed. To avoid this, we need to detect
+    // that case and invalidate the dependee right now.
+    if (zcu.clearOutdatedState(.wrap(.{ .nav_ty = nav_id }))) {
+        assert(zir_decl.type_body == null); // otherwise we already resolved it with `Sema.ensureNavResolved`
+        zcu.resetUnit(.wrap(.{ .nav_ty = nav_id }));
+        try pt.addDependency(.wrap(.{ .nav_ty = nav_id }), .{ .nav_val = nav_id }); // inferred type depends on the value (that's us!)
+        if (comp.debugIncremental()) {
+            const info = try zcu.incremental_debug_state.getUnitInfo(gpa, .wrap(.{ .nav_ty = nav_id }));
+            info.last_update_gen = zcu.generation;
+            info.deps.clearRetainingCapacity();
+        }
+        const type_changed: bool = switch (old_nav.status) {
+            .unresolved => true,
+            .type_resolved => |old| old.type != nav_ty.toIntern(),
+            .fully_resolved => |old| ip.typeOf(old.val) != nav_ty.toIntern(),
+        };
+        if (type_changed) {
+            try zcu.markDependeeOutdated(.marked_po, .{ .nav_ty = nav_id });
+        } else {
+            try zcu.markPoDependeeUpToDate(.{ .nav_ty = nav_id });
+        }
+    }
     ip.resolveNavValue(io, nav_id, .{
         .val = nav_val.toIntern(),
         .is_const = is_const,
@@ -1930,10 +1943,10 @@ fn analyzeNavVal(
         try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern());
     }
 
-    switch (old_nav.status) {
-        .unresolved, .type_resolved => return .{ .val_changed = true },
-        .fully_resolved => |old| return .{ .val_changed = old.val != nav_val.toIntern() },
-    }
+    return switch (old_nav.status) {
+        .unresolved, .type_resolved => .{ .val_changed = true },
+        .fully_resolved => |old| .{ .val_changed = old.val != nav_val.toIntern() },
+    };
 }
 
 pub fn ensureNavTypeUpToDate(
@@ -1973,7 +1986,6 @@ pub fn ensureNavTypeUpToDate(
         zcu.transitive_failed_analysis.contains(anal_unit);
 
     if (was_outdated) {
-        dev.check(.incremental);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this unit.
@@ -2107,12 +2119,29 @@ fn analyzeNavType(
 
     const type_body = zir_decl.type_body orelse {
         // There is no type annotation, so we just need to use the declaration's value.
+        // If the value had already been re-analyzed, it would have resolved the `nav_ty` unit as
+        // either outdated or up-to-date. So we know that `old_nav` does contain information from
+        // the previous update. As such, after this call, we will be able to determine whether the
+        // type changed.
         try sema.ensureNavResolved(&block, init_src, nav_id, .fully);
-        // We don't actually know what the type of this Nav was before it was resolved, so we just
-        // have to assume we were outdated. This isn't too bad, because assuming there was also no
-        // type annotation last update, we should only be re-analyzed if the value changes (it's our
-        // only dependency), or if there was a dependency loop.
-        return .{ .type_changed = true };
+        const new = ip.getNav(nav_id).status.fully_resolved;
+        const new_is_extern_decl = ip.indexToKey(new.val) == .@"extern";
+        const changed = switch (old_nav.status) {
+            .unresolved => true,
+            .type_resolved => |r| r.type != ip.typeOf(new.val) or
+                r.alignment != new.alignment or
+                r.@"linksection" != new.@"linksection" or
+                r.@"addrspace" != new.@"addrspace" or
+                r.is_const != new.is_const or
+                r.is_extern_decl != new_is_extern_decl,
+            .fully_resolved => |r| ip.typeOf(r.val) != ip.typeOf(new.val) or
+                r.alignment != new.alignment or
+                r.@"linksection" != new.@"linksection" or
+                r.@"addrspace" != new.@"addrspace" or
+                r.is_const != new.is_const or
+                (old_nav.getExtern(ip) != null) != new_is_extern_decl,
+        };
+        return .{ .type_changed = changed };
     };
 
     block.comptime_reason = .{ .reason = .{
@@ -2210,7 +2239,6 @@ pub fn ensureFuncBodyUpToDate(
     const prev_failed = zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit);
 
     if (was_outdated) {
-        dev.check(.incremental);
         zcu.resetUnit(anal_unit);
     } else {
         // We can trust the current information about this function.
@@ -2292,7 +2320,7 @@ fn analyzeFuncBody(
 
     var air = try pt.analyzeFuncBodyInner(func_index, reason);
     var air_owned = true;
-    errdefer if (air_owned) air.deinit(gpa);
+    defer if (air_owned) air.deinit(gpa);
 
     const ies_outdated = !func.analysisUnordered(ip).inferred_error_set or
         func.resolvedErrorSetUnordered(ip) != old_resolved_ies;
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 13e07dfcd05aa6a3f31b7de7ee49805f1225cecc..97e5ca22498df706b2fff70e5aebe7f1bf892ec3 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -7132,9 +7132,9 @@ fn formatIntLiteral(data: FormatIntLiteralContext, w: *Writer) Writer.Error!void
             var limb_buf: [std.math.big.int.calcTwosCompLimbCount(65535)]std.math.big.Limb = undefined;
             for (0..big.limbs_len) |limb_index| {
                 if (limb_index != 0) try w.writeAll(", ");
-                const limb_bit_offset: u64 = switch (target.cpu.arch.endian()) {
-                    .little => limb_index * big.limb_size.bits(),
-                    .big => (big.limbs_len - limb_index - 1) * big.limb_size.bits(),
+                const limb_bit_offset: u16 = switch (target.cpu.arch.endian()) {
+                    .little => @intCast(limb_index * big.limb_size.bits()),
+                    .big => @intCast((big.limbs_len - limb_index - 1) * big.limb_size.bits()),
                 };
                 var limb_bigint: std.math.big.int.Mutable = .{
                     .limbs = &limb_buf,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 938706a42b82cdaf8639cd58738bd0fc3ad613a7..7bcd60d8a7964c4edfb1623b9ed9def47f8efa87 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -2432,7 +2432,7 @@ pub const Object = struct {
                 const debug_payload_type = try o.builder.debugUnionType(
                     payload_name: {
                         if (layout.tag_size == 0) break :payload_name name;
-                        break :payload_name try o.builder.metadataStringFmt("{s}:Payload", .{name.slice(&o.builder)});
+                        break :payload_name try o.builder.metadataStringFmt("{f}:Payload", .{ty.fmt(pt)});
                     },
                     file,
                     scope,
diff --git a/src/link.zig b/src/link.zig
index 3eb4add772149d4a5e149ecf842156cde14d0849..80141676d414a40cf3cbbd29c213afe62a65d20d 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -1557,7 +1557,10 @@ pub fn doZcuTask(comp: *Compilation, tid: Zcu.PerThread.Id, task: ZcuTask) void
         .link_func => |codegen_task| nav: {
             timer.pause(io);
             const func, var mir = codegen_task.wait(&zcu.codegen_task_pool, io) catch |err| switch (err) {
-                error.Canceled, error.AlreadyReported => return,
+                error.Canceled, error.AlreadyReported => {
+                    comp.link_prog_node.completeOne();
+                    return;
+                },
             };
             defer mir.deinit(zcu);
             timer.@"resume"(io);
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 97fb0294eb617c509e965995587ee6049a661941..fac71faf56ab2f6572f86e7ce71e66451eaddd58 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -3344,6 +3344,7 @@ pub fn updateConstIncomplete(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index
 }
 fn updateConstIncompleteInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.ConstPool.Index, value_index: InternPool.Index) !void {
     const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
 
     const val: Value = .fromInterned(value_index);
 
@@ -3383,20 +3384,109 @@ fn updateConstIncompleteInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_inde
         .debug_loclists = .init(dwarf.gpa),
     };
     defer wip_nav.deinit();
-    switch (val.typeOf(zcu).toIntern()) {
-        .type_type => {
-            try wip_nav.abbrevCode(.generated_empty_struct_type);
-            try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
-            try wip_nav.debug_info.writer.writeByte(@intFromBool(true));
-        },
-        else => |ty| {
-            try wip_nav.abbrevCode(.undefined_comptime_value);
-            try wip_nav.refType(.fromInterned(ty));
+
+    switch (ip.indexToKey(value_index)) {
+        // Container types still need to be valid namespaces.
+        .struct_type => {
+            const loaded_struct = ip.loadStructType(value_index);
+            const root_of_file: ?Zcu.File.Index = if (loaded_struct.zir_index.resolveFull(ip)) |r| f: {
+                if (r.inst != .main_struct_inst) break :f null;
+                break :f r.file;
+            } else null;
+            if (root_of_file) |file_index| {
+                assert(loaded_struct.name_nav == .none);
+                const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file_index);
+                try wip_nav.abbrevCode(.empty_file);
+                try wip_nav.debug_info.writer.writeUleb128(file_gop.index);
+                try wip_nav.strp(loaded_struct.name.toSlice(ip));
+            } else {
+                try dwarf.emitIncompleteContainerType(
+                    &wip_nav,
+                    loaded_struct.zir_index,
+                    loaded_struct.name,
+                    loaded_struct.name_nav,
+                );
+            }
+        },
+        .union_type => {
+            const loaded_union = ip.loadUnionType(value_index);
+            try dwarf.emitIncompleteContainerType(
+                &wip_nav,
+                loaded_union.zir_index,
+                loaded_union.name,
+                loaded_union.name_nav,
+            );
+        },
+        .enum_type => {
+            const loaded_enum = ip.loadEnumType(value_index);
+            if (loaded_enum.zir_index.unwrap()) |zir_index| {
+                try dwarf.emitIncompleteContainerType(
+                    &wip_nav,
+                    zir_index,
+                    loaded_enum.name,
+                    loaded_enum.name_nav,
+                );
+            } else {
+                try wip_nav.abbrevCode(.generated_empty_struct_type);
+                try wip_nav.strp(loaded_enum.name.toSlice(ip));
+                try wip_nav.debug_info.writer.writeByte(@intFromBool(true));
+            }
+        },
+        .opaque_type => {
+            const loaded_opaque = ip.loadOpaqueType(value_index);
+            try dwarf.emitIncompleteContainerType(
+                &wip_nav,
+                loaded_opaque.zir_index,
+                loaded_opaque.name,
+                loaded_opaque.name_nav,
+            );
+        },
+        // Not a container type, so just emit a dummy entry. If `val` happens to be a type, we'll
+        // emit it as if it were an opaque type so that we can name it.
+        else => |val_key| switch (val_key.typeOf()) {
+            .type_type => {
+                try wip_nav.abbrevCode(.generated_empty_struct_type);
+                try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
+                try wip_nav.debug_info.writer.writeByte(@intFromBool(true));
+            },
+            else => |ty| {
+                try wip_nav.abbrevCode(.undefined_comptime_value);
+                try wip_nav.refType(.fromInterned(ty));
+            },
         },
     }
     try dwarf.debug_info.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_info.written());
     try dwarf.debug_loclists.section.replaceEntry(unit, entry, dwarf, wip_nav.debug_loclists.written());
 }
+fn emitIncompleteContainerType(
+    dwarf: *Dwarf,
+    wip_nav: *WipNav,
+    zir_index: InternPool.TrackedInst.Index,
+    name: InternPool.NullTerminatedString,
+    name_nav: InternPool.Nav.Index.Optional,
+) !void {
+    const zcu = wip_nav.pt.zcu;
+    const ip = &zcu.intern_pool;
+    const file = zir_index.resolveFile(ip);
+    if (name_nav.unwrap()) |nav_index| {
+        const nav = ip.getNav(nav_index);
+        const decl_inst = nav.srcInst(ip).resolve(ip).?;
+        const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+        try wip_nav.declCommon(.{
+            .decl = .decl_namespace_struct,
+            .generic_decl = .generic_decl_const,
+            .decl_instance = .decl_instance_namespace_struct,
+        }, &nav, file, &decl);
+        try wip_nav.debug_info.writer.writeByte(@intFromBool(true));
+    } else {
+        const diw = &wip_nav.debug_info.writer;
+        const file_gop = try dwarf.getModInfo(wip_nav.unit).files.getOrPut(dwarf.gpa, file);
+        try wip_nav.abbrevCode(.empty_struct_type);
+        try diw.writeUleb128(file_gop.index);
+        try wip_nav.strp(name.toSlice(ip));
+        try diw.writeByte(@intFromBool(true));
+    }
+}
 /// Should only be called by the `link.ConstPool` implementation.
 ///
 /// Emits a DIE for the given comptime-only value (which may be a type).
@@ -3418,6 +3508,8 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co
         val.typeOf(zcu).assertHasLayout(zcu);
     }
 
+    if (value_index == .anyerror_type) return; // handled in `flush` instead
+
     const value_ip_key = ip.indexToKey(value_index);
     switch (value_ip_key) {
         .func => return, // populated by the Nav instead (`updateComptimeNav` or `initWipNav`)
@@ -3746,7 +3838,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co
                 try wip_nav.abbrevCode(.void_type);
                 try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
             },
-            .anyerror => return, // delay until flush
+            .anyerror => unreachable, // already did early return above
             .adhoc_inferred_error_set => unreachable,
         },
         .tuple_type => |tuple_type| if (tuple_type.types.len == 0) {
diff --git a/tools/incr-check.zig b/tools/incr-check.zig
index 6b3351b315a3c23a443faca94c61bae0367a304e..8eb985408e54ba63be587055d8c559f9852fe4c4 100644
--- a/tools/incr-check.zig
+++ b/tools/incr-check.zig
@@ -311,12 +311,12 @@ const Eval = struct {
                 .error_bundle => {
                     const result_error_bundle = try std.zig.Server.allocErrorBundle(arena, body);
                     if (stderr.bufferedLen() > 0) {
-                        const stderr_data = try mr.toOwnedSlice(1);
                         if (eval.allow_stderr) {
-                            std.log.info("error_bundle stderr:\n{s}", .{stderr_data});
+                            std.log.info("error_bundle stderr:\n{s}", .{stderr.buffered()});
                         } else {
-                            eval.fatal("error_bundle unexpected stderr:\n{s}", .{stderr_data});
+                            eval.fatal("error_bundle unexpected stderr:\n{s}", .{stderr.buffered()});
                         }
+                        stderr.tossBuffered();
                     }
                     if (result_error_bundle.errorMessageCount() != 0) {
                         try eval.checkErrorOutcome(update, result_error_bundle);
@@ -327,15 +327,15 @@ const Eval = struct {
                 .emit_digest => {
                     var r: std.Io.Reader = .fixed(body);
                     _ = r.takeStruct(std.zig.Server.Message.EmitDigest, .little) catch unreachable;
+
                     if (stderr.bufferedLen() > 0) {
-                        const stderr_data = try mr.toOwnedSlice(1);
                         if (eval.allow_stderr) {
-                            std.log.info("emit_digest stderr:\n{s}", .{stderr_data});
+                            std.log.info("emit_digest stderr:\n{s}", .{stderr.buffered()});
                         } else {
-                            eval.fatal("emit_digest unexpected stderr:\n{s}", .{stderr_data});
+                            eval.fatal("emit_digest unexpected stderr:\n{s}", .{stderr.buffered()});
                         }
+                        stderr.tossBuffered();
                     }
-
                     if (eval.target.backend == .sema) {
                         try eval.checkSuccessOutcome(update, null, prog_node);
                         continue;
@@ -369,7 +369,7 @@ const Eval = struct {
         }
 
         waitChild(eval.child, eval);
-        eval.fatal("compiler failed to send error_bundle or emit_bin_path", .{});
+        eval.fatal("compiler failed to send terminating error_bundle", .{});
     }
 
     fn checkErrorOutcome(eval: *Eval, update: Case.Update, error_bundle: std.zig.ErrorBundle) !void {
-- 
2.54.0


From 3a3ac1034519d1b0c58279345e7e0f6272bccbee Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 3 Mar 2026 13:14:05 +0000
Subject: [PATCH 477/499] cbe: fix type layouts, and statically assert them

---
 lib/zig.h                          |   8 +++
 src/codegen/c/type/render_defs.zig | 101 +++++++++++++++++++++++------
 2 files changed, 88 insertions(+), 21 deletions(-)

diff --git a/lib/zig.h b/lib/zig.h
index f8744966c68276a8e160e77eb186d08f54caa8cb..0b9c6e58ca6d9f1800fd8059e5db9d3636faa35c 100644
--- a/lib/zig.h
+++ b/lib/zig.h
@@ -151,6 +151,14 @@
 #define zig_has_attribute(attribute) 0
 #endif
 
+#if __STDC_VERSION__ >= 201112L
+#define zig_static_assert(cond, msg) _Static_assert(cond, msg)
+#elif zig_has_attribute(unused)
+#define zig_static_assert(cond, _) typedef char zig_expand_concat(zig_static_assert_fail_, __LINE__)[!!(cond)] __attribute__((unused))
+#else
+#define zig_static_assert(cond, _) typedef char zig_expand_concat(zig_static_assert_fail_, __LINE__)[!!(cond)]
+#endif
+
 #if __STDC_VERSION__ >= 202311L
 #define zig_threadlocal thread_local
 #elif __STDC_VERSION__ >= 201112L
diff --git a/src/codegen/c/type/render_defs.zig b/src/codegen/c/type/render_defs.zig
index a34b0d6d3ce720663b63202e7e4260243f9bbb0f..52bf57306426156917bcfbcda475d57edd972e06 100644
--- a/src/codegen/c/type/render_defs.zig
+++ b/src/codegen/c/type/render_defs.zig
@@ -246,6 +246,8 @@ pub fn defineComplete(
                 ptr_cty.fmtDeclaratorPrefix(zcu),
                 ptr_cty.fmtDeclaratorSuffix(zcu),
             });
+            // Don't bother with `writeStaticAssertLayout`---there's not really any way we could mess
+            // slices up, and they're all obviously the same layout.
         },
         .optional => switch (CType.classifyOptional(ty, zcu)) {
             .error_set,
@@ -260,6 +262,7 @@ pub fn defineComplete(
                     name_cty.fmtTypeName(zcu),
                     ty.fmt(pt),
                 });
+                try writeStaticAssertLayout(ty, name_cty, w, zcu);
             },
 
             .@"struct" => {
@@ -277,6 +280,7 @@ pub fn defineComplete(
                     payload_cty.fmtDeclaratorPrefix(zcu),
                     payload_cty.fmtDeclaratorSuffix(zcu),
                 });
+                try writeStaticAssertLayout(ty, name_cty, w, zcu);
             },
         },
         .array => if (ty.hasRuntimeBits(zcu)) {
@@ -297,6 +301,7 @@ pub fn defineComplete(
                 array_cty.fmtDeclaratorSuffix(zcu),
                 ty.fmt(pt),
             });
+            try writeStaticAssertLayout(ty, name_cty, w, zcu);
         },
         .vector => if (ty.hasRuntimeBits(zcu)) {
             const name_cty: CType = .{ .vec = ty };
@@ -312,6 +317,7 @@ pub fn defineComplete(
                 array_cty.fmtDeclaratorSuffix(zcu),
                 ty.fmt(pt),
             });
+            try writeStaticAssertLayout(ty, name_cty, w, zcu);
         },
         else => {},
     }
@@ -374,18 +380,21 @@ fn defineTuple(
         zig_offset = field_align.forward(zig_offset);
         if (!field_ty.hasRuntimeBits(zcu)) continue;
         c_offset = field_align.forward(c_offset);
+        try w.writeByte(' ');
         if (zig_offset == 0 and overalign) {
             // This is the first field; specify its alignment to align the tuple.
-            try w.print(" zig_align({d})", .{tuple_align.toByteUnits().?});
+            try writeFieldAlign(field_ty, tuple_align, w, zcu);
         } else if (zig_offset > c_offset) {
             // This field needs to be overaligned compared to what its offset would otherwise be.
-            const need_align: Alignment = .fromLog2Units(@ctz(zig_offset));
-            try w.print(" zig_align({d})", .{need_align.toByteUnits().?});
+            const need_align: Alignment = .minStrict(
+                tuple_align, // don't make the struct more aligned than it should be
+                .fromLog2Units(@ctz(zig_offset)),
+            );
+            try writeFieldAlign(field_ty, need_align, w, zcu);
             c_offset = need_align.forward(c_offset);
-            assert(c_offset == zig_offset);
         }
         const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
-        try w.print(" {f}f{d}{f};\n", .{
+        try w.print("{f}f{d}{f};\n", .{
             field_cty.fmtDeclaratorPrefix(zcu),
             field_index,
             field_cty.fmtDeclaratorSuffix(zcu),
@@ -395,6 +404,8 @@ fn defineTuple(
         c_offset += field_size;
     }
     try w.writeAll("};\n");
+
+    try writeStaticAssertLayout(ty, name_cty, w, zcu);
 }
 fn defineStruct(
     ty: Type,
@@ -420,6 +431,8 @@ fn defineStruct(
             const natural_offset = natural_align.forward(offset);
             const actual_offset = struct_type.field_offsets.get(ip)[field_index];
             if (actual_offset < natural_offset) break :pack true;
+            // Also pack if any field is more aligned than the struct should be.
+            if (natural_align.compareStrict(.gt, struct_type.alignment)) break :pack true;
             offset = actual_offset + field_ty.abiSize(zcu);
         }
         break :pack false;
@@ -459,22 +472,22 @@ fn defineStruct(
             false => natural_align.forward(offset),
         };
         const actual_offset = struct_type.field_offsets.get(ip)[field_index];
+        try w.writeByte(' ');
         if (actual_offset == 0 and overalign) {
             // This is the first field; specify its alignment to align the struct.
-            try w.print(" zig_align({d})", .{struct_type.alignment.toByteUnits().?});
+            try writeFieldAlign(field_ty, struct_type.alignment, w, zcu);
         } else if (actual_offset > natural_offset) {
             // This field needs to be underaligned or overaligned compared to what its
             // offset would otherwise be.
-            const need_align: Alignment = .fromLog2Units(@ctz(actual_offset));
-            if (need_align.compareStrict(.lt, natural_align)) {
-                try w.print(" zig_under_align({d})", .{need_align.toByteUnits().?});
-            } else {
-                try w.print(" zig_align({d})", .{need_align.toByteUnits().?});
-            }
+            const need_align: Alignment = .minStrict(
+                struct_type.alignment, // don't make the struct more aligned than it should be
+                .fromLog2Units(@ctz(actual_offset)),
+            );
+            try writeFieldAlign(field_ty, need_align, w, zcu);
         }
         const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
         const field_name = struct_type.field_names.get(ip)[field_index].toSlice(ip);
-        try w.print(" {f}{f}{f};\n", .{
+        try w.print("{f}{f}{f};\n", .{
             field_cty.fmtDeclaratorPrefix(zcu),
             fmtIdentSolo(field_name),
             field_cty.fmtDeclaratorSuffix(zcu),
@@ -485,6 +498,8 @@ fn defineStruct(
     try w.writeByte('}');
     if (pack) try w.writeByte(')');
     try w.writeAll(";\n");
+
+    try writeStaticAssertLayout(ty, name_cty, w, zcu);
 }
 fn defineUnionAuto(
     ty: Type,
@@ -500,12 +515,20 @@ fn defineUnionAuto(
     const union_type = ip.loadUnionType(ty.toIntern());
     const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
 
+    const layout = Type.getUnionLayout(union_type, zcu);
+
     // If there are any underaligned fields, we need to byte-pack the union.
     const pack: bool = for (union_type.field_types.get(ip)) |field_ty_ip| {
         const field_ty: Type = .fromInterned(field_ty_ip);
         if (!field_ty.hasRuntimeBits(zcu)) continue;
         const natural_align = field_ty.abiAlignment(zcu);
         if (natural_align.compareStrict(.gt, union_type.alignment)) break true;
+        // The tag will immediately follow the payload. This layout may put the tag in what would
+        // otherwise be padding on the payload union, because if the most-aligned union field is not
+        // the largest one, a larger field may make the payload "underaligned" overall. As such, we
+        // need to check whether this field is okay with the payload size, and if not then we must
+        // byte-pack.
+        if (!natural_align.check(layout.payload_size)) break true;
     } else false;
 
     // If the alignment of other fields would not give the union sufficient alignment, we
@@ -536,6 +559,10 @@ fn defineUnionAuto(
     });
     if (payload_has_bits) {
         try w.writeByte(' ');
+        if (overalign) {
+            // Specify the alignment of `union { ... } payload;` to align the union's `struct`.
+            try w.print("zig_align({d}) ", .{union_type.alignment.toByteUnits().?});
+        }
         if (pack) try w.writeAll("zig_packed(");
         try w.writeAll("union {\n");
         for (0..enum_tag_ty.enumFieldCount(zcu)) |field_index| {
@@ -543,12 +570,7 @@ fn defineUnionAuto(
             if (!field_ty.hasRuntimeBits(zcu)) continue;
             const field_name = enum_tag_ty.enumFieldName(field_index, zcu).toSlice(ip);
             const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
-            try w.writeAll("  ");
-            if (overalign and field_index == 0) {
-                // This is the first field; specify its alignment to align the union.
-                try w.print("zig_align({d}) ", .{union_type.alignment.toByteUnits().?});
-            }
-            try w.print("{f}{f}{f};\n", .{
+            try w.print("  {f}{f}{f};\n", .{
                 field_cty.fmtDeclaratorPrefix(zcu),
                 fmtIdentSolo(field_name),
                 field_cty.fmtDeclaratorSuffix(zcu),
@@ -566,6 +588,8 @@ fn defineUnionAuto(
         });
     }
     try w.writeAll("};\n");
+
+    try writeStaticAssertLayout(ty, name_cty, w, zcu);
 }
 fn defineUnionExtern(
     ty: Type,
@@ -622,11 +646,12 @@ fn defineUnionExtern(
         if (!field_ty.hasRuntimeBits(zcu)) continue;
         const field_name = enum_tag_ty.enumFieldName(field_index, zcu).toSlice(ip);
         const field_cty: CType = try .lower(field_ty, deps, arena, zcu);
+        try w.writeByte(' ');
         if (overalign and field_index == 0) {
             // This is the first field; specify its alignment to align the union.
-            try w.print(" zig_align({d})", .{union_type.alignment.toByteUnits().?});
+            try writeFieldAlign(field_ty, union_type.alignment, w, zcu);
         }
-        try w.print(" {f}{f}{f};\n", .{
+        try w.print("{f}{f}{f};\n", .{
             field_cty.fmtDeclaratorPrefix(zcu),
             fmtIdentSolo(field_name),
             field_cty.fmtDeclaratorSuffix(zcu),
@@ -635,6 +660,40 @@ fn defineUnionExtern(
     try w.writeByte('}');
     if (pack) try w.writeByte(')');
     try w.writeAll(";\n");
+
+    try writeStaticAssertLayout(ty, name_cty, w, zcu);
+}
+
+/// Writes an annotation which, placed before a struct/union field declaration with field type `ty`,
+/// will specify that field as having the given alignment.
+fn writeFieldAlign(
+    ty: Type,
+    alignment: Alignment,
+    w: *Writer,
+    zcu: *const Zcu,
+) Writer.Error!void {
+    if (alignment.compareStrict(.lt, ty.abiAlignment(zcu))) {
+        try w.print("zig_under_align({d}) ", .{alignment.toByteUnits().?});
+    } else {
+        try w.print("zig_align({d}) ", .{alignment.toByteUnits().?});
+    }
+}
+
+/// Emits static assertions that the size and alignment of `cty` match those of the Zig type `ty`.
+fn writeStaticAssertLayout(
+    ty: Type,
+    cty: CType,
+    w: *Writer,
+    zcu: *const Zcu,
+) Writer.Error!void {
+    try w.print(
+        \\zig_static_assert(sizeof ({f}) == {d}, "incorrect size");
+        \\zig_static_assert(_Alignof ({f}) == {d}, "incorrect alignment");
+        \\
+    , .{
+        cty.fmtTypeName(zcu), ty.abiSize(zcu),
+        cty.fmtTypeName(zcu), ty.abiAlignment(zcu).toByteUnits().?,
+    });
 }
 
 const std = @import("std");
-- 
2.54.0


From 0f3c883245f27870472978f738d6e81958e15c52 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Mar 2026 13:49:24 +0000
Subject: [PATCH 478/499] Sema: always track references

I think not tracking these already causes some bugs on master with
`-freference-trace=0`, but it now definitely causes bugs, because we
want the reference information to decide how to write dependency loop
errors. Let's begin to lean into the incremental-by-default future by
disabling this small optimization---the compiler is starting to use a
lot of the "incremental" logic even in non-incremental builds at this
point, so the separation is becoming less and less! This particular
optimization wasn't even that useful, because it's very rare for users
to build with `-freference-trace=0`.
---
 src/Sema.zig | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index b266940c0e91e309c788d156f3ab99d760d8d6ff..aa3bae74687d6774a75c4dd708187fbe1a4cf1cf 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -29920,7 +29920,6 @@ pub fn addReferenceEntry(
         .func => |f| assert(ip.unwrapCoercedFunc(f) == f), // for `.{ .func = f }`, `f` must be uncoerced
         else => {},
     }
-    if (!zcu.comp.config.incremental and zcu.comp.reference_trace == 0) return;
     const gop = try sema.references.getOrPut(sema.gpa, referenced_unit);
     if (gop.found_existing) return;
     try zcu.addUnitReference(sema.owner, referenced_unit, src, inline_frame: {
@@ -29937,7 +29936,6 @@ pub fn addTypeReferenceEntry(
     referenced_type: Type,
 ) !void {
     const zcu = sema.pt.zcu;
-    if (!zcu.comp.config.incremental and zcu.comp.reference_trace == 0) return;
     const gop = try sema.type_references.getOrPut(sema.gpa, referenced_type.toIntern());
     if (gop.found_existing) return;
     try zcu.addTypeReference(sema.owner, referenced_type.toIntern(), src);
-- 
2.54.0


From ea7e34224a8c3c0551e17a60fd849efee82447f7 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Mar 2026 10:51:45 +0000
Subject: [PATCH 479/499] compiler: don't call `getUnionLayout` on packed
 unions

---
 src/Type.zig                  |   4 +
 src/codegen/llvm.zig          | 131 ++++++++++++++++-----------------
 src/codegen/spirv/CodeGen.zig |  72 +++++++-----------
 src/link/Dwarf.zig            | 133 +++++++++++++++++++---------------
 4 files changed, 168 insertions(+), 172 deletions(-)

diff --git a/src/Type.zig b/src/Type.zig
index ea92d6befdc5202a8dd21ad01d5f5ac66fb3af9d..6442a13efaafbd68385233f49a52b4c2abc1c3c8 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -1571,6 +1571,7 @@ pub fn externUnionBackingType(ty: Type, pt: Zcu.PerThread) !Type {
     }
 }
 
+/// Asserts that `ty` is a non-packed union type.
 pub fn unionGetLayout(ty: Type, zcu: *const Zcu) Zcu.UnionLayout {
     assertHasLayout(ty, zcu);
     const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
@@ -2689,7 +2690,10 @@ pub fn arrayBase(ty: Type, zcu: *const Zcu) struct { Type, u64 } {
     return .{ cur_ty, cur_len };
 }
 
+/// Asserts that `loaded_union.layout` is not `.@"packed"`.
 pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu) Zcu.UnionLayout {
+    assert(loaded_union.layout != .@"packed");
+
     const ip = &zcu.intern_pool;
     var most_aligned_field: u32 = 0;
     var most_aligned_field_align: InternPool.Alignment = .@"1";
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 7bcd60d8a7964c4edfb1623b9ed9def47f8efa87..fc487d5a2618d3357f8fa422fcd79760f835d916 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -2369,6 +2369,30 @@ pub const Object = struct {
                 const line = ty.typeDeclSrcLine(zcu).? + 1;
 
                 const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
+
+                if (union_type.layout == .@"packed") {
+                    const bitpack_field = try o.builder.debugMemberType(
+                        try o.builder.metadataString("bits"),
+                        null, // file
+                        ty_fwd_ref,
+                        0, // line
+                        try o.getDebugType(pt, .fromInterned(union_type.packed_backing_int_type)),
+                        ty.abiSize(zcu) * 8,
+                        ty.abiAlignment(zcu).toByteUnits().? * 8,
+                        0, // offset
+                    );
+                    return o.builder.debugStructType(
+                        name,
+                        file,
+                        scope,
+                        line,
+                        null, // underlying type
+                        ty.abiSize(zcu) * 8,
+                        ty.abiAlignment(zcu).toByteUnits().? * 8,
+                        try o.builder.metadataTuple(&.{bitpack_field}),
+                    );
+                }
+
                 const layout = Type.getUnionLayout(union_type, zcu);
 
                 if (layout.payload_size == 0) {
@@ -2411,10 +2435,7 @@ pub const Object = struct {
                     const field_ty = union_type.field_types.get(ip)[field_index];
 
                     const field_size = Type.fromInterned(field_ty).abiSize(zcu);
-                    const field_align: InternPool.Alignment = switch (union_type.layout) {
-                        .@"packed" => .none,
-                        .auto, .@"extern" => ty.explicitFieldAlignment(field_index, zcu),
-                    };
+                    const field_align: InternPool.Alignment = ty.explicitFieldAlignment(field_index, zcu);
 
                     const field_name = enum_tag_ty.enumFieldName(field_index, zcu);
                     fields.appendAssumeCapacity(try o.builder.debugMemberType(
@@ -3318,7 +3339,6 @@ pub const Object = struct {
                     if (o.type_map.get(t.toIntern())) |value| return value;
 
                     const union_obj = ip.loadUnionType(t.toIntern());
-                    const layout = Type.getUnionLayout(union_obj, zcu);
 
                     if (union_obj.layout == .@"packed") {
                         const int_ty = try o.lowerType(pt, .fromInterned(union_obj.packed_backing_int_type));
@@ -3326,6 +3346,8 @@ pub const Object = struct {
                         return int_ty;
                     }
 
+                    const layout = Type.getUnionLayout(union_obj, zcu);
+
                     if (layout.payload_size == 0) {
                         const enum_tag_ty = try o.lowerType(pt, .fromInterned(union_obj.enum_tag_type));
                         try o.type_map.put(o.gpa, t.toIntern(), enum_tag_ty);
@@ -6760,7 +6782,7 @@ pub const FuncGen = struct {
         const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
         const struct_ptr = try self.resolveInst(struct_field.struct_operand);
         const struct_ptr_ty = self.typeOf(struct_field.struct_operand);
-        return self.fieldPtr(inst, struct_ptr, struct_ptr_ty, struct_field.field_index);
+        return self.fieldPtr(struct_ptr, struct_ptr_ty, struct_field.field_index);
     }
 
     fn airStructFieldPtrIndex(
@@ -6771,7 +6793,7 @@ pub const FuncGen = struct {
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const struct_ptr = try self.resolveInst(ty_op.operand);
         const struct_ptr_ty = self.typeOf(ty_op.operand);
-        return self.fieldPtr(inst, struct_ptr, struct_ptr_ty, field_index);
+        return self.fieldPtr(struct_ptr, struct_ptr_ty, field_index);
     }
 
     fn airStructFieldVal(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
@@ -10704,18 +10726,11 @@ pub const FuncGen = struct {
         const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
         const union_ty = self.typeOfIndex(inst);
         const union_llvm_ty = try o.lowerType(pt, union_ty);
-        const layout = union_ty.unionGetLayout(zcu);
         const union_obj = zcu.typeToUnion(union_ty).?;
 
-        if (union_obj.layout == .@"packed") {
-            const big_bits = union_ty.bitSize(zcu);
-            const int_llvm_ty = try o.builder.intType(@intCast(big_bits));
-            const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
-            const non_int_val = try self.resolveInst(extra.init);
-            const small_int_ty = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
-            const small_int_val = try self.wip.cast(.bitcast, non_int_val, small_int_ty, "");
-            return self.wip.conv(.unsigned, small_int_val, int_llvm_ty, "");
-        }
+        assert(union_obj.layout != .@"packed");
+
+        const layout = Type.getUnionLayout(union_obj, zcu);
 
         const tag_int_val = blk: {
             const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
@@ -11051,65 +11066,45 @@ pub const FuncGen = struct {
 
     fn fieldPtr(
         self: *FuncGen,
-        inst: Air.Inst.Index,
-        struct_ptr: Builder.Value,
-        struct_ptr_ty: Type,
+        aggregate_ptr: Builder.Value,
+        aggregate_ptr_ty: Type,
         field_index: u32,
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = self.ng.pt;
         const zcu = pt.zcu;
-        const struct_ty = struct_ptr_ty.childType(zcu);
-        switch (struct_ty.zigTypeTag(zcu)) {
-            .@"struct" => switch (struct_ty.containerLayout(zcu)) {
-                .@"packed" => {
-                    const result_ty = self.typeOfIndex(inst);
-                    const result_ty_info = result_ty.ptrInfo(zcu);
-                    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(zcu);
-                    const struct_type = zcu.typeToStruct(struct_ty).?;
-
-                    if (result_ty_info.packed_offset.host_size != 0) {
-                        // From LLVM's perspective, a pointer to a packed struct and a pointer
-                        // to a field of a packed struct are the same. The difference is in the
-                        // Zig pointer type which provides information for how to mask and shift
-                        // out the relevant bits when accessing the pointee.
-                        return struct_ptr;
-                    }
-
-                    // We have a pointer to a packed struct field that happens to be byte-aligned.
-                    // Offset our operand pointer by the correct number of bytes.
-                    const byte_offset = @divExact(zcu.structPackedFieldBitOffset(struct_type, field_index) + struct_ptr_ty_info.packed_offset.bit_offset, 8);
-                    if (byte_offset == 0) return struct_ptr;
-                    const usize_ty = try o.lowerType(pt, Type.usize);
-                    const llvm_index = try o.builder.intValue(usize_ty, byte_offset);
-                    return self.wip.gep(.inbounds, .i8, struct_ptr, &.{llvm_index}, "");
-                },
-                else => {
-                    if (!struct_ty.hasRuntimeBits(zcu)) {
-                        return struct_ptr;
-                    }
-                    const struct_llvm_ty = try o.lowerType(pt, struct_ty);
-                    if (o.llvmFieldIndex(struct_ty, field_index)) |llvm_field_index| {
-                        return self.wip.gepStruct(struct_llvm_ty, struct_ptr, llvm_field_index, "");
-                    } else {
-                        // If we found no index then this means this is a zero sized field at the
-                        // end of the struct. Treat our struct pointer as an array of two and get
-                        // the index to the element at index `1` to get a pointer to the end of
-                        // the struct.
-                        const llvm_index = try o.builder.intValue(
-                            try o.lowerType(pt, Type.usize),
-                            @intFromBool(struct_ty.hasRuntimeBits(zcu)),
-                        );
-                        return self.wip.gep(.inbounds, struct_llvm_ty, struct_ptr, &.{llvm_index}, "");
-                    }
-                },
+        const aggregate_ty = aggregate_ptr_ty.childType(zcu);
+        if (aggregate_ty.containerLayout(zcu) == .@"packed") {
+            // A pointer to a bitpack field is equivalent to a pointer to the whole bitpack; the
+            // bit offset is represented in the pointer *type*.
+            return aggregate_ptr;
+        }
+        switch (aggregate_ty.zigTypeTag(zcu)) {
+            .@"struct" => {
+                if (!aggregate_ty.hasRuntimeBits(zcu)) {
+                    return aggregate_ptr;
+                }
+                const struct_llvm_ty = try o.lowerType(pt, aggregate_ty);
+                if (o.llvmFieldIndex(aggregate_ty, field_index)) |llvm_field_index| {
+                    return self.wip.gepStruct(struct_llvm_ty, aggregate_ptr, llvm_field_index, "");
+                } else {
+                    // If we found no index then this means this is a zero sized field at the
+                    // end of the struct. Treat our struct pointer as an array of two and get
+                    // the index to the element at index `1` to get a pointer to the end of
+                    // the struct.
+                    const llvm_index = try o.builder.intValue(
+                        try o.lowerType(pt, Type.usize),
+                        @intFromBool(aggregate_ty.hasRuntimeBits(zcu)),
+                    );
+                    return self.wip.gep(.inbounds, struct_llvm_ty, aggregate_ptr, &.{llvm_index}, "");
+                }
             },
             .@"union" => {
-                const layout = struct_ty.unionGetLayout(zcu);
-                if (layout.payload_size == 0 or struct_ty.containerLayout(zcu) == .@"packed") return struct_ptr;
+                const layout = aggregate_ty.unionGetLayout(zcu);
+                if (layout.payload_size == 0) return aggregate_ptr;
                 const payload_index = @intFromBool(layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align));
-                const union_llvm_ty = try o.lowerType(pt, struct_ty);
-                return self.wip.gepStruct(union_llvm_ty, struct_ptr, payload_index, "");
+                const union_llvm_ty = try o.lowerType(pt, aggregate_ty);
+                return self.wip.gepStruct(union_llvm_ty, aggregate_ptr, payload_index, "");
             },
             else => unreachable,
         }
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig
index 71cd46be02740ea78411ff0f8bed98d92ed7ef3d..d071952924eb9542036f80f13a2fc2dc3bf86d40 100644
--- a/src/codegen/spirv/CodeGen.zig
+++ b/src/codegen/spirv/CodeGen.zig
@@ -4519,30 +4519,7 @@ fn unionInit(
     const layout = cg.unionLayout(ty);
     const payload_ty: Type = .fromInterned(union_ty.field_types.get(ip)[active_field]);
 
-    if (union_ty.layout == .@"packed") {
-        if (!payload_ty.hasRuntimeBits(zcu)) {
-            const int_ty = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
-            return cg.constInt(int_ty, 0);
-        }
-
-        assert(payload != null);
-        if (payload_ty.isInt(zcu)) {
-            if (ty.bitSize(zcu) == payload_ty.bitSize(zcu)) {
-                return cg.bitCast(ty, payload_ty, payload.?);
-            }
-
-            const trunc = try cg.buildConvert(ty, .{ .ty = payload_ty, .value = .{ .singleton = payload.? } });
-            return try trunc.materialize(cg);
-        }
-
-        const payload_int_ty = try pt.intType(.unsigned, @intCast(payload_ty.bitSize(zcu)));
-        const payload_int = if (payload_ty.ip_index == .bool_type)
-            try cg.convertToIndirect(payload_ty, payload.?)
-        else
-            try cg.bitCast(payload_int_ty, payload_ty, payload.?);
-        const trunc = try cg.buildConvert(ty, .{ .ty = payload_int_ty, .value = .{ .singleton = payload_int } });
-        return try trunc.materialize(cg);
-    }
+    assert(union_ty.layout != .@"packed");
 
     const tag_int = if (layout.tag_size != 0) blk: {
         const tag_val = try pt.enumValueFieldIndex(tag_ty, active_field);
@@ -4761,33 +4738,36 @@ fn structFieldPtr(
         },
         .@"struct" => switch (object_ty.containerLayout(zcu)) {
             .@"packed" => return cg.todo("implement field access for packed structs", .{}),
-            else => {
+            .auto, .@"extern" => {
                 return try cg.accessChain(result_ty_id, object_ptr, &.{field_index});
             },
         },
-        .@"union" => {
-            const layout = cg.unionLayout(object_ty);
-            if (!layout.has_payload) {
-                // Asked to get a pointer to a zero-sized field. Just lower this
-                // to undefined, there is no reason to make it be a valid pointer.
-                return try cg.module.constUndef(result_ty_id);
-            }
+        .@"union" => switch (object_ty.containerLayout(zcu)) {
+            .@"packed" => return cg.todo("implement field access for packed unions", .{}),
+            .auto, .@"extern" => {
+                const layout = cg.unionLayout(object_ty);
+                if (!layout.has_payload) {
+                    // Asked to get a pointer to a zero-sized field. Just lower this
+                    // to undefined, there is no reason to make it be a valid pointer.
+                    return try cg.module.constUndef(result_ty_id);
+                }
 
-            const storage_class = cg.module.storageClass(object_ptr_ty.ptrAddressSpace(zcu));
-            const layout_payload_ty_id = try cg.resolveType(layout.payload_ty, .indirect);
-            const pl_ptr_ty_id = try cg.module.ptrType(layout_payload_ty_id, storage_class);
-            const pl_ptr_id = blk: {
-                if (object_ty.containerLayout(zcu) == .@"packed") break :blk object_ptr;
-                break :blk try cg.accessChain(pl_ptr_ty_id, object_ptr, &.{layout.payload_index});
-            };
+                const storage_class = cg.module.storageClass(object_ptr_ty.ptrAddressSpace(zcu));
+                const layout_payload_ty_id = try cg.resolveType(layout.payload_ty, .indirect);
+                const pl_ptr_ty_id = try cg.module.ptrType(layout_payload_ty_id, storage_class);
+                const pl_ptr_id = blk: {
+                    if (object_ty.containerLayout(zcu) == .@"packed") break :blk object_ptr;
+                    break :blk try cg.accessChain(pl_ptr_ty_id, object_ptr, &.{layout.payload_index});
+                };
 
-            const active_pl_ptr_id = cg.module.allocId();
-            try cg.body.emit(cg.module.gpa, .OpBitcast, .{
-                .id_result_type = result_ty_id,
-                .id_result = active_pl_ptr_id,
-                .operand = pl_ptr_id,
-            });
-            return active_pl_ptr_id;
+                const active_pl_ptr_id = cg.module.allocId();
+                try cg.body.emit(cg.module.gpa, .OpBitcast, .{
+                    .id_result_type = result_ty_id,
+                    .id_result = active_pl_ptr_id,
+                    .operand = pl_ptr_id,
+                });
+                return active_pl_ptr_id;
+            },
         },
         else => unreachable,
     }
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index fac71faf56ab2f6572f86e7ce71e66451eaddd58..4260ffb9e9d11ad488ef132553b82180bdc6d64a 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -4009,69 +4009,86 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co
         .union_type => {
             const loaded_union = ip.loadUnionType(value_index);
             const file = loaded_union.zir_index.resolveFile(ip);
-            const need_terminator: bool = if (loaded_union.name_nav.unwrap()) |nav_index| t: {
-                const nav = ip.getNav(nav_index);
-                const decl_inst = nav.srcInst(ip).resolve(ip).?;
-                const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
-                try wip_nav.declCommon(.{
-                    .decl = .decl_union,
-                    .generic_decl = .generic_decl_const,
-                    .decl_instance = .decl_instance_union,
-                }, &nav, file, &decl);
-                break :t true;
-            } else t: {
-                const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
-                try wip_nav.abbrevCode(if (loaded_union.field_types.len > 0) .union_type else .empty_union_type);
-                try diw.writeUleb128(file_gop.index);
-                try wip_nav.strp(loaded_union.name.toSlice(ip));
-                break :t loaded_union.field_types.len > 0;
-            };
-            const union_layout = Type.getUnionLayout(loaded_union, zcu);
-            try diw.writeUleb128(union_layout.abi_size);
-            try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
-            const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
-            if (loaded_union.has_runtime_tag) {
-                try wip_nav.abbrevCode(.tagged_union);
-                try wip_nav.infoSectionOffset(
-                    .debug_info,
-                    wip_nav.unit,
-                    wip_nav.entry,
-                    @intCast(diw.end + dwarf.sectionOffsetBytes()),
-                );
-                {
-                    try wip_nav.abbrevCode(.generated_field);
-                    try wip_nav.strp("tag");
-                    try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
-                    try diw.writeUleb128(union_layout.tagOffset());
-
-                    for (0..loaded_union.field_types.len) |field_index| {
-                        try wip_nav.enumConstValue(loaded_tag, .{
-                            .sdata = .signed_tagged_union_field,
-                            .udata = .unsigned_tagged_union_field,
-                            .block = .big_tagged_union_field,
-                        }, field_index);
+            switch (loaded_union.layout) {
+                .auto, .@"extern" => {
+                    const need_terminator: bool = if (loaded_union.name_nav.unwrap()) |nav_index| t: {
+                        const nav = ip.getNav(nav_index);
+                        const decl_inst = nav.srcInst(ip).resolve(ip).?;
+                        const decl = zcu.fileByIndex(file).zir.?.getDeclaration(decl_inst);
+                        try wip_nav.declCommon(.{
+                            .decl = .decl_union,
+                            .generic_decl = .generic_decl_const,
+                            .decl_instance = .decl_instance_union,
+                        }, &nav, file, &decl);
+                        break :t true;
+                    } else t: {
+                        const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, file);
+                        try wip_nav.abbrevCode(if (loaded_union.field_types.len > 0) .union_type else .empty_union_type);
+                        try diw.writeUleb128(file_gop.index);
+                        try wip_nav.strp(loaded_union.name.toSlice(ip));
+                        break :t loaded_union.field_types.len > 0;
+                    };
+                    const union_layout = Type.getUnionLayout(loaded_union, zcu);
+                    try diw.writeUleb128(union_layout.abi_size);
+                    try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
+                    const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
+                    if (loaded_union.has_runtime_tag) {
+                        try wip_nav.abbrevCode(.tagged_union);
+                        try wip_nav.infoSectionOffset(
+                            .debug_info,
+                            wip_nav.unit,
+                            wip_nav.entry,
+                            @intCast(diw.end + dwarf.sectionOffsetBytes()),
+                        );
                         {
-                            try wip_nav.abbrevCode(.struct_field);
-                            try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
-                            const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                            try wip_nav.refType(field_type);
-                            try diw.writeUleb128(union_layout.payloadOffset());
-                            try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                                if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
+                            try wip_nav.abbrevCode(.generated_field);
+                            try wip_nav.strp("tag");
+                            try wip_nav.refType(.fromInterned(loaded_union.enum_tag_type));
+                            try diw.writeUleb128(union_layout.tagOffset());
+
+                            for (0..loaded_union.field_types.len) |field_index| {
+                                try wip_nav.enumConstValue(loaded_tag, .{
+                                    .sdata = .signed_tagged_union_field,
+                                    .udata = .unsigned_tagged_union_field,
+                                    .block = .big_tagged_union_field,
+                                }, field_index);
+                                {
+                                    try wip_nav.abbrevCode(.struct_field);
+                                    try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
+                                    const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
+                                    try wip_nav.refType(field_type);
+                                    try diw.writeUleb128(union_layout.payloadOffset());
+                                    try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
+                                        if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
+                                }
+                                try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                            }
                         }
                         try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                    } else for (0..loaded_union.field_types.len) |field_index| {
+                        try wip_nav.abbrevCode(.untagged_union_field);
+                        try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
+                        const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
+                        try wip_nav.refType(field_type);
+                        try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
+                            if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
                     }
-                }
-                try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
-            } else for (0..loaded_union.field_types.len) |field_index| {
-                try wip_nav.abbrevCode(.untagged_union_field);
-                try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
-                const field_type: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
-                try wip_nav.refType(field_type);
-                try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
-                    if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?);
+                    if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
+                },
+                .@"packed" => {
+                    // TODO: debug info for packed unions
+                    try wip_nav.abbrevCode(.numeric_type);
+                    try wip_nav.strp(loaded_union.name.toSlice(ip));
+                    const backing_int_ty: Type = .fromInterned(loaded_union.packed_backing_int_type);
+                    const int_info = backing_int_ty.intInfo(zcu);
+                    try diw.writeByte(switch (int_info.signedness) {
+                        inline .signed, .unsigned => |signedness| @field(DW.ATE, @tagName(signedness)),
+                    });
+                    try diw.writeUleb128(int_info.bits);
+                    try diw.writeUleb128(backing_int_ty.abiSize(zcu));
+                    try diw.writeUleb128(backing_int_ty.abiAlignment(zcu).toByteUnits().?);
+                },
             }
-            if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
         },
         .enum_type => {
             const loaded_enum = ip.loadEnumType(value_index);
-- 
2.54.0


From c73db56b4543776ce157626361f1cb66df1dac69 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 5 Mar 2026 19:00:38 +0000
Subject: [PATCH 480/499] compiler: small optimizations

With these optimizations in place, this branch is faster than master in
ReleaseFast, and... not too much slower than master in ReleaseSafe.
---
 src/Sema.zig |   6 +-
 src/Type.zig | 167 ++++++++++++++++++++++++++++++++++-----------------
 2 files changed, 117 insertions(+), 56 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index aa3bae74687d6774a75c4dd708187fbe1a4cf1cf..1e86fddb842377766fa0934a0115d35c38edd077 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2287,13 +2287,15 @@ fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) ?Value {
             .inferred_alloc_comptime => unreachable, // assertion failure
             else => {},
         }
-        switch (sema.typeOf(inst).classify(zcu)) {
+        // LLVM fails to eliminate this `classify` call in ReleaseFast, which hurts performance, so
+        // we must explicitly check for `std.debug.runtime_safety`.
+        if (std.debug.runtime_safety) switch (sema.typeOf(inst).classify(zcu)) {
             .no_possible_value => unreachable, // values of this type do not exist
             .one_possible_value => unreachable, // the value should be comptime-known
             .partially_comptime => unreachable, // the value should be comptime-known
             .fully_comptime => unreachable, // the value should be comptime-known
             .runtime => {},
-        }
+        };
         return null;
     }
 }
diff --git a/src/Type.zig b/src/Type.zig
index 6442a13efaafbd68385233f49a52b4c2abc1c3c8..841ca38b0e536b79ca44817eb55941b864ac3f56 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -112,10 +112,17 @@ pub const Class = enum(u3) {
 };
 
 /// Returns the `Class` for the type `ty`. Asserts that the layout of `ty` is resolved.
-pub fn classify(ty: Type, zcu: *const Zcu) Class {
-    ty.assertHasLayout(zcu);
+pub fn classify(start_ty: Type, zcu: *const Zcu) Class {
     const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
+
+    // We avoid recursion in most cases to make us more optimizer-friendly because this can be a
+    // very hot code path. The only case where recursion is necessary is tuples, so that case is
+    // outlined into a separate function; see `classifyTuple`.
+
+    var extra_states: enum { none, one, many } = .none;
+
+    var cur_ty = start_ty;
+    const base: Class = while (true) break switch (ip.indexToKey(cur_ty.toIntern())) {
         .simple_type => |t| switch (t) {
             .f16,
             .f32,
@@ -165,17 +172,10 @@ pub fn classify(ty: Type, zcu: *const Zcu) Class {
 
         .opaque_type => .no_possible_value,
 
-        .error_union_type => |eu| switch (Type.fromInterned(eu.payload_type).classify(zcu)) {
-            .no_possible_value,
-            .one_possible_value,
-            .runtime,
-            => .runtime,
-
-            .partially_comptime => .partially_comptime,
-            // It may seem that this should be `.partially_comptime` due to the error set, however
-            // there is no way to take a pointer to the error set of an error union, so it does not
-            // actually necessitate runtime bits.
-            .fully_comptime => .fully_comptime,
+        .error_union_type => |eu| {
+            extra_states = .many;
+            cur_ty = .fromInterned(eu.payload_type);
+            continue;
         },
 
         .int_type => |int| switch (int.bits) {
@@ -183,55 +183,58 @@ pub fn classify(ty: Type, zcu: *const Zcu) Class {
             else => .runtime,
         },
         .array_type => |arr| {
-            if (arr.len == 0 and arr.sentinel == .none) return .one_possible_value;
-            return Type.fromInterned(arr.child).classify(zcu);
+            if (arr.len == 0 and arr.sentinel == .none) break .one_possible_value;
+            cur_ty = .fromInterned(arr.child);
+            continue;
         },
         .vector_type => |vec| {
-            if (vec.len == 0) return .one_possible_value;
-            return Type.fromInterned(vec.child).classify(zcu);
+            if (vec.len == 0) break .one_possible_value;
+            cur_ty = .fromInterned(vec.child);
+            continue;
         },
-        .opt_type => |child| switch (Type.fromInterned(child).classify(zcu)) {
-            .no_possible_value => .one_possible_value,
-            .one_possible_value => .runtime,
-            else => |class| class,
+        .opt_type => |child_ty_ip| {
+            extra_states = switch (extra_states) {
+                .none => .one,
+                .one, .many => .many,
+            };
+            cur_ty = .fromInterned(child_ty_ip);
+            continue;
         },
         .tuple_type => |tuple| {
-            var has_runtime_state = false;
-            var has_comptime_state = false;
-            for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, field_comptime_val| {
-                if (field_comptime_val != .none) continue;
-                switch (Type.fromInterned(field_ty).classify(zcu)) {
-                    .no_possible_value => return .no_possible_value,
-                    .one_possible_value => {},
-                    .runtime => has_runtime_state = true,
-                    .fully_comptime => has_comptime_state = true,
-                    .partially_comptime => {
-                        has_runtime_state = true;
-                        has_comptime_state = true;
-                    },
-                }
-            }
-            if (has_comptime_state) {
-                return if (has_runtime_state) .partially_comptime else .fully_comptime;
-            } else {
-                return if (has_runtime_state) .runtime else .one_possible_value;
-            }
+            @branchHint(.unlikely);
+            break classifyTuple(tuple.types.get(ip), tuple.values.get(ip), zcu);
         },
         .struct_type => {
-            const struct_obj = ip.loadStructType(ty.toIntern());
-            return switch (struct_obj.layout) {
-                .auto, .@"extern" => struct_obj.class,
-                .@"packed" => Type.fromInterned(struct_obj.packed_backing_int_type).classify(zcu),
-            };
+            const struct_obj = ip.loadStructType(cur_ty.toIntern());
+            switch (struct_obj.layout) {
+                .auto, .@"extern" => {
+                    zcu.assertUpToDate(.wrap(.{ .type_layout = cur_ty.toIntern() }));
+                    break struct_obj.class;
+                },
+                .@"packed" => {
+                    cur_ty = .fromInterned(struct_obj.packed_backing_int_type);
+                    continue;
+                },
+            }
         },
         .union_type => {
-            const union_obj = ip.loadUnionType(ty.toIntern());
-            return switch (union_obj.layout) {
-                .auto, .@"extern" => union_obj.class,
-                .@"packed" => Type.fromInterned(union_obj.packed_backing_int_type).classify(zcu),
-            };
+            const union_obj = ip.loadUnionType(cur_ty.toIntern());
+            switch (union_obj.layout) {
+                .auto, .@"extern" => {
+                    zcu.assertUpToDate(.wrap(.{ .type_layout = cur_ty.toIntern() }));
+                    break union_obj.class;
+                },
+                .@"packed" => {
+                    cur_ty = .fromInterned(union_obj.packed_backing_int_type);
+                    continue;
+                },
+            }
+        },
+        .enum_type => {
+            zcu.assertUpToDate(.wrap(.{ .type_layout = cur_ty.toIntern() }));
+            cur_ty = .fromInterned(ip.loadEnumType(cur_ty.toIntern()).int_tag_type);
+            continue;
         },
-        .enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).int_tag_type).classify(zcu),
 
         // values, not types
         .undef,
@@ -255,6 +258,53 @@ pub fn classify(ty: Type, zcu: *const Zcu) Class {
         .memoized_call,
         => unreachable,
     };
+
+    return switch (base) {
+        .runtime => .runtime, // extra states are irrelevant, we already have many!
+        .partially_comptime => .partially_comptime, // likewise
+        .fully_comptime => {
+            // We do not need to change to `.partially_comptime` here because the extra states do
+            // not necessarily require runtime bits. This is because Zig does not provide a way to
+            // take the address of the "is null" bit of an optional or the error set "inside" of an
+            // error union.
+            return .fully_comptime;
+        },
+
+        .no_possible_value => switch (extra_states) {
+            .none => .no_possible_value,
+            .one => .one_possible_value,
+            .many => .runtime,
+        },
+
+        .one_possible_value => switch (extra_states) {
+            .none => .one_possible_value,
+            .one, .many => .runtime,
+        },
+    };
+}
+/// This is a separate function to `classify` to avoid recursion in the main `classify` function,
+/// which can encourage the optimizer to e.g. inline `classify` where it would be beneficial.
+fn classifyTuple(types: []const InternPool.Index, values: []const InternPool.Index, zcu: *const Zcu) Class {
+    var has_runtime_state = false;
+    var has_comptime_state = false;
+    for (types, values) |field_ty, field_comptime_val| {
+        if (field_comptime_val != .none) continue;
+        switch (Type.fromInterned(field_ty).classify(zcu)) {
+            .no_possible_value => return .no_possible_value,
+            .one_possible_value => {},
+            .runtime => has_runtime_state = true,
+            .fully_comptime => has_comptime_state = true,
+            .partially_comptime => {
+                has_runtime_state = true;
+                has_comptime_state = true;
+            },
+        }
+    }
+    if (has_comptime_state) {
+        return if (has_runtime_state) .partially_comptime else .fully_comptime;
+    } else {
+        return if (has_runtime_state) .runtime else .one_possible_value;
+    }
 }
 
 /// Asserts the type is resolved.
@@ -1061,7 +1111,10 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
         .error_union_type => |error_union| {
             const payload_ty: Type = .fromInterned(error_union.payload_type);
             switch (payload_ty.classify(zcu)) {
-                .fully_comptime => return 0, // error set does not require runtime bits, see comment in `classify`
+                // Zig has no way to take the address of the error set "in" an error union (giving
+                // implementations more freedom in terms of data layout), so if the payload type is
+                // fully comptime, we don't need to dedicate runtime bits to the error set.
+                .fully_comptime => return 0,
                 else => {},
             }
             // The layout will either be (code, payload, padding) or (payload, code, padding)
@@ -3177,6 +3230,12 @@ fn validateExternCallconv(cc: std.builtin.CallingConvention) bool {
 
 /// Asserts that `ty` has resolved layout.
 pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
+    if (!std.debug.runtime_safety) {
+        // This early exit isn't necessary (`Zcu.assertUpToDate` checks `std.debug.runtime_safety`
+        // itself), but LLVM has been observed to fail at optimizing away this safety check, which
+        // has a major performance impact on ReleaseFast compiler builds.
+        return;
+    }
     switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
         .int_type,
         .ptr_type,
-- 
2.54.0


From a5219cd288c322f5f5bda89d608af5b243e9fd6f Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Mar 2026 10:52:54 +0000
Subject: [PATCH 481/499] bootstrap: work around GCC bug

GCC bug 119085, which affects versions 13.0--15.1, is being triggered by
the C backend, resulting in a (small but critical) miscompilation in
zig2. Unfortunately, we can't really work around that bug without a
command-line flag, because the bug is sensitive to things like the order
in which `struct` types are defined.

Therefore, I have added an option to `bootstrap.c` which causes it to
pass the appropriate flag to `gcc` to disable the optimization pass in
question. This flag can likely be removed in future, once the affected
GCC versions become less common.

At least one of our x86_64-linux CI machines is using an affected GCC
version, so I also updated the relevant CI script to pass this flag when
testing no-LLVM bootstrap.

CMakeLists also has a workaround, but no user intervention is required
there: the GCC version range is automatically detected by CMakeLists.
---
 CMakeLists.txt             | 12 ++++++++++--
 bootstrap.c                | 21 +++++++++++++++++++++
 ci/x86_64-linux-release.sh |  3 ++-
 3 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 06cc1cd8ddba43e22ee6dd1a39eab58d67851132..146e507930706d8d779ce6a3977b39d7f9d9b78c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -330,7 +330,6 @@ set(ZIG_STAGE2_SOURCES
     src/Air/Liveness.zig
     src/Air/Liveness/Verify.zig
     src/Air/print.zig
-    src/Air/types_resolved.zig
     src/Builtin.zig
     src/Compilation.zig
     src/Compilation/Config.zig
@@ -344,6 +343,7 @@ set(ZIG_STAGE2_SOURCES
     src/Sema.zig
     src/Sema/bitcast.zig
     src/Sema/comptime_ptr_access.zig
+    src/Sema/type_resolution.zig
     src/Type.zig
     src/Value.zig
     src/Zcu.zig
@@ -360,7 +360,8 @@ set(ZIG_STAGE2_SOURCES
     src/codegen/aarch64/Mir.zig
     src/codegen/aarch64/Select.zig
     src/codegen/c.zig
-    src/codegen/c/Type.zig
+    src/codegen/c/type.zig
+    src/codegen/c/type/render_defs.zig
     src/codegen/llvm.zig
     src/codegen/llvm/bindings.zig
     src/crash_report.zig
@@ -375,6 +376,7 @@ set(ZIG_STAGE2_SOURCES
     src/libs/libunwind.zig
     src/link.zig
     src/link/C.zig
+    src/link/ConstPool.zig
     src/link/Coff.zig
     src/link/Dwarf.zig
     src/link/Elf.zig
@@ -623,6 +625,12 @@ else()
   else()
     set(ZIG2_LINK_FLAGS "-Wl,-z,stack-size=0x10000000")
   endif()
+  # Prevent GCC from miscompiling 'zig2.c'. See also 'workaround_gcc_sra_miscomp' in 'bootstrap.c'.
+  if (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND
+      CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "13.0" AND
+      CMAKE_C_COMPILER_VERSION VERSION_LESS_EQUAL "15.2")
+    set(ZIG2_COMPILE_FLAGS "${ZIG2_COMPILE_FLAGS} -fno-tree-sra")
+  endif()
 endif()
 
 set(ZIG1_WASM_MODULE "${PROJECT_SOURCE_DIR}/stage1/zig1.wasm")
diff --git a/bootstrap.c b/bootstrap.c
index 44ba0714764a387eff427c118e4a66c8bcfb3a69..329a1af10e5d9c4c61d5dc851587c1d80c0e0aa5 100644
--- a/bootstrap.c
+++ b/bootstrap.c
@@ -102,6 +102,26 @@ int main(int argc, char **argv) {
     const char *cc = get_c_compiler();
     const char *host_triple = get_host_triple();
 
+    // GCC versions 13.0--14.1 have a miscompilation where some bytes of a union may get clobbered
+    // depending on the union layout and the order in which types are defined. This miscompilation
+    // affects the output of the C backend, and thus can affect the bootstrap process. Specifically,
+    // we observe that using the self-hosted x86_64 backend in 'zig2' will cause all function calls
+    // to be relocated incorrectly, causing immediate crashes on any binary produced by it.
+    //
+    // The only reliable workaround for this bug is to disable the optimization pass containing it,
+    // so here we check for a CLI flag requesting that workaround.
+    //
+    // The upstream bug is fixed in GCC version 15.2 onwards (and was also backported to the 13 and
+    // 14 branches). Once this bug is no longer widespread, we can remove this CLI flag.
+    //
+    // Upstream bug report: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119085
+    bool workaround_gcc_sra_miscomp = false;
+    for (int i = 1; i < argc; ++i) {
+        if (!strcmp(argv[i], "--workaround-gcc-sra-miscomp")) {
+            workaround_gcc_sra_miscomp = true;
+        }
+    }
+
     {
         const char *child_argv[] = {
             cc, "-o", "zig-wasm2c", "stage1/wasm2c.c", "-O2", "-std=c99", NULL,
@@ -193,6 +213,7 @@ int main(int argc, char **argv) {
 #if defined(__GNUC__)
             "-pthread",
 #endif
+            workaround_gcc_sra_miscomp ? "-fno-tree-sra" : NULL,
             NULL,
         };
         print_and_run(child_argv);
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 21411ab2af64258aff7910c2dcd3abcdb834cbf3..0317ad55fc4b795de5e5671d987880a610c577c8 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -21,7 +21,8 @@ export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
 
 # Test building from source without LLVM.
 cc -o bootstrap bootstrap.c
-./bootstrap
+# See comments in bootstrap.c for an explanation of the flag given here.
+./bootstrap --workaround-gcc-sra-miscomp
 ./zig2 build -Dno-lib
 ./zig-out/bin/zig test test/behavior.zig
 
-- 
2.54.0


From 4a310ce7c13c9aa485200a2b712562ba20854272 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Mar 2026 16:31:39 +0000
Subject: [PATCH 482/499] Sema: expect 'alignment' fields in 'std.builtin.Type'
 to be '?usize'

This is a language change which works nicely alongside some of the other
changes in this branch. It will help to resolve the remaining couple of
failures in the std and behavior tests.

The actual std.builtin change is not in this commit, because we must
update zig1.wasm first.
---
 src/Sema.zig | 98 ++++++++++++++++++++++++++++++++--------------------
 1 file changed, 60 insertions(+), 38 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 1e86fddb842377766fa0934a0115d35c38edd077..f2c52697b420eeca9674ed4f2e5f75060a67809a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -16250,11 +16250,6 @@ fn zirBuiltinSrc(
     return Air.internedToRef((try pt.aggregateValue(src_loc_ty, &fields)).toIntern());
 }
 
-/// MLUGG TODO: once this branch is in a more stable state, I need to make a language change so that
-/// `std.builtin.Type` makes all `alignment` fields `?usize` instead of `comptime_int`, to prevent
-/// explicit alignment annotations from sneaking in without the user requesting any; but doing that
-/// right now would be really annoying because it would break the base compiler. I need to have the
-/// compiler more-or-less fully migrated first.
 fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -16432,12 +16427,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         },
         .pointer => {
             const info = ty.ptrInfo(zcu);
-            const alignment_val = try pt.intValue(.comptime_int, bytes: {
-                if (info.flags.alignment.toByteUnits()) |b| break :bytes b;
-                const elem_ty: Type = .fromInterned(info.child);
-                try sema.ensureLayoutResolved(elem_ty, src, .type_info);
-                break :bytes elem_ty.abiAlignment(zcu).toByteUnits().?;
-            });
+            const alignment_ty = try pt.optionalType(.usize_type);
+            const alignment_val: Value = val: {
+                const bytes = info.flags.alignment.toByteUnits() orelse {
+                    break :val try pt.nullValue(alignment_ty);
+                };
+                const int_val = try pt.intValue(.usize, bytes);
+                break :val .fromInterned(try pt.intern(.{ .opt = .{
+                    .ty = alignment_ty.toIntern(),
+                    .val = int_val.toIntern(),
+                } }));
+            };
 
             const addrspace_ty = try sema.getBuiltinType(src, .AddressSpace);
             const pointer_ty = try sema.getBuiltinType(src, .@"Type.Pointer");
@@ -16450,7 +16450,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 Value.makeBool(info.flags.is_const).toIntern(),
                 // is_volatile: bool,
                 Value.makeBool(info.flags.is_volatile).toIntern(),
-                // alignment: comptime_int,
+                // alignment: ?usize,
                 alignment_val.toIntern(),
                 // address_space: AddressSpace
                 (try pt.enumValueFieldIndex(addrspace_ty, @intFromEnum(info.flags.address_space))).toIntern(),
@@ -16766,12 +16766,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
                 const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
 
-                const alignment = switch (layout) {
-                    .auto, .@"extern" => switch (ty.explicitFieldAlignment(field_index, zcu)) {
-                        .none => field_ty.abiAlignment(zcu),
-                        else => |a| a,
-                    },
-                    .@"packed" => .none,
+                const alignment_ty = try pt.optionalType(.usize_type);
+                const alignment_val: Value = val: {
+                    const a: Alignment = switch (layout) {
+                        .auto, .@"extern" => ty.explicitFieldAlignment(field_index, zcu),
+                        .@"packed" => .none,
+                    };
+                    const bytes = a.toByteUnits() orelse {
+                        break :val try pt.nullValue(alignment_ty);
+                    };
+                    const int_val = try pt.intValue(.usize, bytes);
+                    break :val .fromInterned(try pt.intern(.{ .opt = .{
+                        .ty = alignment_ty.toIntern(),
+                        .val = int_val.toIntern(),
+                    } }));
                 };
 
                 const union_field_fields = .{
@@ -16779,8 +16787,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     name_val,
                     // type: type,
                     field_ty.toIntern(),
-                    // alignment: comptime_int,
-                    (try pt.intValue(.comptime_int, alignment.toByteUnits() orelse 0)).toIntern(),
+                    // alignment: ?usize,
+                    alignment_val.toIntern(),
                 };
                 field_val.* = (try pt.aggregateValue(union_field_ty, &union_field_fields)).toIntern();
             }
@@ -16881,6 +16889,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                             const is_comptime = field_val != .none;
                             const opt_default_val = if (is_comptime) Value.fromInterned(field_val) else null;
                             const default_val_ptr = try sema.optRefValue(opt_default_val);
+
                             const struct_field_fields = .{
                                 // name: [:0]const u8,
                                 name_val,
@@ -16890,8 +16899,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                                 default_val_ptr.toIntern(),
                                 // is_comptime: bool,
                                 Value.makeBool(is_comptime).toIntern(),
-                                // alignment: comptime_int,
-                                (try pt.intValue(.comptime_int, Type.fromInterned(field_ty).abiAlignment(zcu).toByteUnits() orelse 0)).toIntern(),
+                                // alignment: ?usize,
+                                (try pt.nullValue(try pt.optionalType(.usize_type))).toIntern(),
                             };
                             struct_field_val.* = (try pt.aggregateValue(struct_field_ty, &struct_field_fields)).toIntern();
                         }
@@ -16937,12 +16946,21 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
                     const opt_default_val: ?Value = if (field_default == .none) null else .fromInterned(field_default);
                     const default_val_ptr = try sema.optRefValue(opt_default_val);
-                    const alignment = switch (struct_type.layout) {
-                        .auto, .@"extern" => switch (ty.explicitFieldAlignment(field_index, zcu)) {
-                            .none => field_ty.defaultStructFieldAlignment(struct_type.layout, zcu),
-                            else => |a| a,
-                        },
-                        .@"packed" => .none,
+
+                    const alignment_ty = try pt.optionalType(.usize_type);
+                    const alignment_val: Value = val: {
+                        const a: Alignment = switch (struct_type.layout) {
+                            .auto, .@"extern" => ty.explicitFieldAlignment(field_index, zcu),
+                            .@"packed" => .none,
+                        };
+                        const bytes = a.toByteUnits() orelse {
+                            break :val try pt.nullValue(alignment_ty);
+                        };
+                        const int_val = try pt.intValue(.usize, bytes);
+                        break :val .fromInterned(try pt.intern(.{ .opt = .{
+                            .ty = alignment_ty.toIntern(),
+                            .val = int_val.toIntern(),
+                        } }));
                     };
 
                     const struct_field_fields = .{
@@ -16954,8 +16972,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         default_val_ptr.toIntern(),
                         // is_comptime: bool,
                         Value.makeBool(field_is_comptime).toIntern(),
-                        // alignment: comptime_int,
-                        (try pt.intValue(.comptime_int, alignment.toByteUnits() orelse 0)).toIntern(),
+                        // alignment: ?usize,
+                        alignment_val.toIntern(),
                     };
                     field_val.* = (try pt.aggregateValue(struct_field_ty, &struct_field_fields)).toIntern();
                 }
@@ -27434,7 +27452,7 @@ fn coerceExtra(
                 const array_elem_ty = array_ty.childType(zcu);
                 if (array_ty.arrayLen(zcu) != 1) break :single_item;
                 const dest_is_mut = !dest_info.flags.is_const;
-                switch (try sema.coerceInMemoryAllowed(block, array_elem_ty, ptr_elem_ty, dest_is_mut, target, dest_ty_src, inst_src, maybe_inst_val)) {
+                switch (try sema.coerceInMemoryAllowed(block, array_elem_ty, ptr_elem_ty, dest_is_mut, target, dest_ty_src, inst_src, null)) {
                     .ok => {},
                     else => break :single_item,
                 }
@@ -27452,7 +27470,7 @@ fn coerceExtra(
                 const dest_is_mut = !dest_info.flags.is_const;
 
                 const dst_elem_type: Type = .fromInterned(dest_info.child);
-                const elem_res = try sema.coerceInMemoryAllowed(block, dst_elem_type, array_elem_type, dest_is_mut, target, dest_ty_src, inst_src, maybe_inst_val);
+                const elem_res = try sema.coerceInMemoryAllowed(block, dst_elem_type, array_elem_type, dest_is_mut, target, dest_ty_src, inst_src, null);
                 switch (elem_res) {
                     .ok => {},
                     else => {
@@ -27513,7 +27531,7 @@ fn coerceExtra(
                 const src_elem_ty = inst_ty.childType(zcu);
                 const dest_is_mut = !dest_info.flags.is_const;
                 const dst_elem_type: Type = .fromInterned(dest_info.child);
-                switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, src_elem_ty, dest_is_mut, target, dest_ty_src, inst_src, maybe_inst_val)) {
+                switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, src_elem_ty, dest_is_mut, target, dest_ty_src, inst_src, null)) {
                     .ok => {},
                     else => break :src_c_ptr,
                 }
@@ -27584,7 +27602,7 @@ fn coerceExtra(
                             target,
                             dest_ty_src,
                             inst_src,
-                            maybe_inst_val,
+                            null,
                         )) {
                             .ok => {},
                             else => break :p,
@@ -27655,7 +27673,7 @@ fn coerceExtra(
                         target,
                         dest_ty_src,
                         inst_src,
-                        maybe_inst_val,
+                        null,
                     )) {
                         .ok => {},
                         else => break :p,
@@ -27861,7 +27879,7 @@ fn coerceExtra(
                     target,
                     dest_ty_src,
                     inst_src,
-                    maybe_inst_val,
+                    null,
                 )) {
                     break :array_to_array;
                 }
@@ -27940,7 +27958,7 @@ fn coerceExtra(
 
         // E!T to T
         if (inst_ty.zigTypeTag(zcu) == .error_union and
-            (try sema.coerceInMemoryAllowed(block, inst_ty.errorUnionPayload(zcu), dest_ty, false, target, dest_ty_src, inst_src, maybe_inst_val)) == .ok)
+            (try sema.coerceInMemoryAllowed(block, inst_ty.errorUnionPayload(zcu), dest_ty, false, target, dest_ty_src, inst_src, null)) == .ok)
         {
             try sema.errNote(inst_src, msg, "cannot convert error union to payload type", .{});
             try sema.errNote(inst_src, msg, "consider using 'try', 'catch', or 'if'", .{});
@@ -27948,7 +27966,7 @@ fn coerceExtra(
 
         // ?T to T
         if (inst_ty.zigTypeTag(zcu) == .optional and
-            (try sema.coerceInMemoryAllowed(block, inst_ty.optionalChild(zcu), dest_ty, false, target, dest_ty_src, inst_src, maybe_inst_val)) == .ok)
+            (try sema.coerceInMemoryAllowed(block, inst_ty.optionalChild(zcu), dest_ty, false, target, dest_ty_src, inst_src, null)) == .ok)
         {
             try sema.errNote(inst_src, msg, "cannot convert optional to payload type", .{});
             try sema.errNote(inst_src, msg, "consider using '.?', 'orelse', or 'if'", .{});
@@ -28395,6 +28413,10 @@ pub fn coerceInMemoryAllowed(
     const pt = sema.pt;
     const zcu = pt.zcu;
 
+    if (src_val) |val| {
+        assert(val.typeOf(zcu).toIntern() == src_ty.toIntern());
+    }
+
     if (dest_ty.eql(src_ty, zcu))
         return .ok;
 
-- 
2.54.0


From 793fa93d9f99b49a6d91bd40195f5fcc783014d5 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Tue, 10 Mar 2026 10:38:21 +0000
Subject: [PATCH 483/499] stage1: update zig1.wasm

Generated using a compiler bootstrapped from the merge base of this
branch, and wasm-opt version 118.

Signed-off-by: Matthew Lugg <mlugg@mlugg.co.uk>
---
 stage1/zig.h     |  10 +++++++++-
 stage1/zig1.wasm | Bin 3183342 -> 3177173 bytes
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/stage1/zig.h b/stage1/zig.h
index 81a815ab5568b57f5d48c8da91a04b761d4f9a2a..0b9c6e58ca6d9f1800fd8059e5db9d3636faa35c 100644
--- a/stage1/zig.h
+++ b/stage1/zig.h
@@ -151,6 +151,14 @@
 #define zig_has_attribute(attribute) 0
 #endif
 
+#if __STDC_VERSION__ >= 201112L
+#define zig_static_assert(cond, msg) _Static_assert(cond, msg)
+#elif zig_has_attribute(unused)
+#define zig_static_assert(cond, _) typedef char zig_expand_concat(zig_static_assert_fail_, __LINE__)[!!(cond)] __attribute__((unused))
+#else
+#define zig_static_assert(cond, _) typedef char zig_expand_concat(zig_static_assert_fail_, __LINE__)[!!(cond)]
+#endif
+
 #if __STDC_VERSION__ >= 202311L
 #define zig_threadlocal thread_local
 #elif __STDC_VERSION__ >= 201112L
@@ -259,7 +267,7 @@
 #endif
 
 #if zig_has_attribute(packed) || defined(zig_tinyc)
-#define zig_packed(definition) __attribute__((packed)) definition
+#define zig_packed(definition) definition __attribute__((packed))
 #elif defined(zig_msvc)
 #define zig_packed(definition) __pragma(pack(1)) definition __pragma(pack())
 #else
diff --git a/stage1/zig1.wasm b/stage1/zig1.wasm
index 0c68522efc27ffeefbdc88b1591ea60c7ff102fc..11942012c73145171942c837b7c61c783f13203b 100644
GIT binary patch
literal 3177173
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
NQjSM23g(4`{s+!$CY=BP

literal 3183342
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%0DO)Baoojc*KUMJ9D#)G6^50o``dw4~(XvI(
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%0D1nRo?kLDyJ&C8{u5tc=7zvnf}XB&jzew8`1v&+
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
NK|e^t;`G`1e*w~!hAIF6

-- 
2.54.0


From 5ec3a0cd54351494dfc64a4d91f72a6020505c1d Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Mar 2026 16:33:51 +0000
Subject: [PATCH 484/499] std: update for language changes

Now that zig1.wasm is updated, apply the matching standard library
changes.

The main one is in `std.builtin.Type`, where `alignment` fields now have
type `?usize` rather than `comptime_int`.

Additionally, we need to add explicit backing integers to some packed
unions, because (due to https://github.com/ziglang/zig/issues/24714)
they need explicit backing integers to be used in `extern` contexts.
This change could not happen before now, because prior to this branch,
packed unions did not allow explicit backing integer types (that is,
this branch implemented https://github.com/ziglang/zig/issues/25350).
---
 lib/compiler/resinator/cvtres.zig |  2 +-
 lib/std/builtin.zig               | 12 ++--
 lib/std/c/darwin.zig              |  2 +-
 lib/std/c/darwin/dispatch.zig     |  2 +-
 lib/std/macho.zig                 |  2 +-
 lib/std/mem.zig                   | 16 +++--
 lib/std/mem/Allocator.zig         | 97 ++++++++++++++++---------------
 lib/std/meta.zig                  |  2 +-
 lib/std/multi_array_list.zig      |  4 +-
 lib/std/zon/parse.zig             |  6 +-
 10 files changed, 81 insertions(+), 64 deletions(-)

diff --git a/lib/compiler/resinator/cvtres.zig b/lib/compiler/resinator/cvtres.zig
index 26b6620af23224ab147ad7ceeafe802bfcb1ae46..6973be714c66540f51a6633ba8c9affff6085a26 100644
--- a/lib/compiler/resinator/cvtres.zig
+++ b/lib/compiler/resinator/cvtres.zig
@@ -410,7 +410,7 @@ pub const ResourceDirectoryTable = extern struct {
 };
 
 pub const ResourceDirectoryEntry = extern struct {
-    entry: packed union {
+    entry: packed union(u32) {
         name_offset: packed struct(u32) {
             address: u31,
             /// This is undocumented in the PE/COFF spec, but the high bit
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index e10935f0c6a6fa15da09bf0611463a4d4347e6cc..00ae6199d1d9cdf96e8202a29b3f0b7385b5d387 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -592,8 +592,8 @@ pub const Type = union(enum) {
         size: Size,
         is_const: bool,
         is_volatile: bool,
-        /// TODO make this u16 instead of comptime_int
-        alignment: comptime_int,
+        /// `null` means implicit alignment, which is equivalent to `@alignOf(child)`.
+        alignment: ?usize,
         address_space: AddressSpace,
         child: type,
         is_allowzero: bool,
@@ -670,7 +670,9 @@ pub const Type = union(enum) {
         /// See also: `defaultValue`.
         default_value_ptr: ?*const anyopaque,
         is_comptime: bool,
-        alignment: comptime_int,
+        /// `null` means the field alignment was not explicitly specified. The
+        /// field will still be aligned to at least `@alignOf` its `type`.
+        alignment: ?usize,
 
         /// Loads the field's default value from `default_value_ptr`.
         /// Returns `null` if the field has no default value.
@@ -747,7 +749,9 @@ pub const Type = union(enum) {
     pub const UnionField = struct {
         name: [:0]const u8,
         type: type,
-        alignment: comptime_int,
+        /// `null` means the field alignment was not explicitly specified. The
+        /// field will still be aligned to at least `@alignOf` its `type`.
+        alignment: ?usize,
 
         /// This data structure is used by the Zig language code generation and
         /// therefore must be kept in sync with the compiler implementation.
diff --git a/lib/std/c/darwin.zig b/lib/std/c/darwin.zig
index f18b61187c92fb2ddfb2ed4d4e922aaa957632fc..452411c52e94af5122ce5265edf95689f54f2b5c 100644
--- a/lib/std/c/darwin.zig
+++ b/lib/std/c/darwin.zig
@@ -436,7 +436,7 @@ pub const thread_state_flavor_t = c_int;
 pub const ipc_space_t = mach_port_t;
 pub const ipc_space_port_t = ipc_space_t;
 
-pub const mach_msg_option_t = packed union {
+pub const mach_msg_option_t = packed union(integer_t) {
     RCV: MACH.RCV,
     SEND: MACH.SEND,
 
diff --git a/lib/std/c/darwin/dispatch.zig b/lib/std/c/darwin/dispatch.zig
index 68b0b48782b02295064a6362b9ed0e249a92659e..770eadf7170f915d877d3d079c7d13b9585ae0a1 100644
--- a/lib/std/c/darwin/dispatch.zig
+++ b/lib/std/c/darwin/dispatch.zig
@@ -210,7 +210,7 @@ pub const source_timer_flags_t = packed struct(usize) {
     STRICT: bool = false,
     unused1: @Int(.unsigned, @bitSizeOf(usize) - 1) = 0,
 };
-pub const source_flags_t = packed union {
+pub const source_flags_t = packed union(usize) {
     raw: usize,
     MACH_SEND: source_mach_send_flags_t,
     MACH_RECV: source_mach_recv_flags_t,
diff --git a/lib/std/macho.zig b/lib/std/macho.zig
index 57f892bdf7bb3f3be0c8b32a798b8fd305c14e15..9fdce9dd6605f450ab7eb9fee2b19b4f3787783d 100644
--- a/lib/std/macho.zig
+++ b/lib/std/macho.zig
@@ -851,7 +851,7 @@ pub const nlist = extern struct {
 
 pub const nlist_64 = extern struct {
     n_strx: u32,
-    n_type: packed union {
+    n_type: packed union(u8) {
         bits: packed struct(u8) {
             ext: bool,
             type: enum(u3) {
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index cc03e5b2c54ccd67ccefe7e854a4385f614f1dae..4b34ad12385bc77b2d67f988d60cde2d9a277027 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -38,6 +38,10 @@ pub const Alignment = enum(math.Log2Int(usize)) {
         return @enumFromInt(@ctz(n));
     }
 
+    pub fn fromByteUnitsOptional(maybe_n: ?usize) ?Alignment {
+        return if (maybe_n) |n| .fromByteUnits(n) else null;
+    }
+
     pub inline fn of(comptime T: type) Alignment {
         return comptime fromByteUnits(@alignOf(T));
     }
@@ -2287,8 +2291,8 @@ pub fn byteSwapAllFieldsAligned(comptime S: type, comptime a: Alignment, ptr: *a
                 ptr.* = @bitCast(@byteSwap(@as(Int, @bitCast(ptr.*))));
             } else inline for (std.meta.fields(S)) |f| {
                 switch (@typeInfo(f.type)) {
-                    .@"struct" => byteSwapAllFieldsAligned(f.type, .fromByteUnits(f.alignment), &@field(ptr, f.name)),
-                    .@"union", .array => byteSwapAllFieldsAligned(f.type, .fromByteUnits(f.alignment), &@field(ptr, f.name)),
+                    .@"struct" => byteSwapAllFieldsAligned(f.type, .fromByteUnits(f.alignment orelse @alignOf(f.type)), &@field(ptr, f.name)),
+                    .@"union", .array => byteSwapAllFieldsAligned(f.type, .fromByteUnits(f.alignment orelse @alignOf(f.type)), &@field(ptr, f.name)),
                     .@"enum" => {
                         @field(ptr, f.name) = @enumFromInt(@byteSwap(@intFromEnum(@field(ptr, f.name))));
                     },
@@ -4330,7 +4334,7 @@ pub fn alignPointerOffset(ptr: anytype, align_to: usize) ?usize {
         @compileError("expected many item pointer, got " ++ @typeName(T));
 
     // Do nothing if the pointer is already well-aligned.
-    if (align_to <= info.pointer.alignment)
+    if (align_to <= info.pointer.alignment orelse @alignOf(info.pointer.child))
         return 0;
 
     // Calculate the aligned base address with an eye out for overflow.
@@ -4388,7 +4392,11 @@ fn CopyPtrAttrs(
         .@"const" = ptr.is_const,
         .@"volatile" = ptr.is_volatile,
         .@"allowzero" = ptr.is_allowzero,
-        .@"align" = ptr.alignment,
+        .@"align" = ptr.alignment orelse a: {
+            // If the new child is aligned differently than the old one, explicitly align the type.
+            const want = @alignOf(ptr.child);
+            break :a if (@alignOf(child) == want) null else want;
+        },
         .@"addrspace" = ptr.address_space,
     }, child, null);
 }
diff --git a/lib/std/mem/Allocator.zig b/lib/std/mem/Allocator.zig
index db1ea978eaf21d31fa846db8dc591fb9749f746d..caf049f296fbc3f9a7fb1d92dc0dd0aa98e571ff 100644
--- a/lib/std/mem/Allocator.zig
+++ b/lib/std/mem/Allocator.zig
@@ -179,7 +179,11 @@ pub fn destroy(self: Allocator, ptr: anytype) void {
     const T = info.child;
     if (@sizeOf(T) == 0) return;
     const non_const_ptr = @as([*]u8, @ptrCast(@constCast(ptr)));
-    self.rawFree(non_const_ptr[0..@sizeOf(T)], .fromByteUnits(info.alignment), @returnAddress());
+    self.rawFree(
+        non_const_ptr[0..@sizeOf(T)],
+        .fromByteUnits(info.alignment orelse @alignOf(T)),
+        @returnAddress(),
+    );
 }
 
 /// Allocates an array of `n` items of type `T` and sets all the
@@ -266,7 +270,7 @@ pub inline fn allocAdvancedWithRetAddr(
     n: usize,
     return_address: usize,
 ) Error![]align(if (alignment) |a| a.toByteUnits() else @alignOf(T)) T {
-    const a = comptime (alignment orelse Alignment.of(T));
+    const a: Alignment = alignment orelse comptime .of(T);
     const ptr: [*]align(a.toByteUnits()) T = @ptrCast(try self.allocWithSizeAndAlignment(@sizeOf(T), a, n, return_address));
     return ptr[0..n];
 }
@@ -278,7 +282,7 @@ fn allocWithSizeAndAlignment(
     n: usize,
     return_address: usize,
 ) Error![*]align(alignment.toByteUnits()) u8 {
-    const byte_count = math.mul(usize, size, n) catch return Error.OutOfMemory;
+    const byte_count = math.mul(usize, size, n) catch return error.OutOfMemory;
     return self.allocBytesWithAlignment(alignment, byte_count, return_address);
 }
 
@@ -293,7 +297,7 @@ fn allocBytesWithAlignment(
         return @as([*]align(alignment.toByteUnits()) u8, @ptrFromInt(ptr));
     }
 
-    const byte_ptr = self.rawAlloc(byte_count, alignment, return_address) orelse return Error.OutOfMemory;
+    const byte_ptr = self.rawAlloc(byte_count, alignment, return_address) orelse return error.OutOfMemory;
     @memset(byte_ptr[0..byte_count], undefined);
     return @alignCast(byte_ptr);
 }
@@ -308,9 +312,9 @@ fn allocBytesWithAlignment(
 ///
 /// `new_len` may be zero, in which case the allocation is freed.
 pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
-    const Slice = @typeInfo(@TypeOf(allocation)).pointer;
-    const T = Slice.child;
-    const alignment = Slice.alignment;
+    const slice_info = @typeInfo(@TypeOf(allocation)).pointer;
+    comptime assert(slice_info.size == .slice);
+    const T = slice_info.child;
     if (new_len == 0) {
         self.free(allocation);
         return true;
@@ -323,7 +327,12 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
     const new_len_bytes = math.mul(usize, @sizeOf(T), new_len) catch return false;
-    return self.rawResize(old_memory, .fromByteUnits(alignment), new_len_bytes, @returnAddress());
+    return self.rawResize(
+        old_memory,
+        .fromByteUnits(slice_info.alignment orelse @alignOf(T)),
+        new_len_bytes,
+        @returnAddress(),
+    );
 }
 
 /// Request to modify the size of an allocation, allowing relocation.
@@ -342,14 +351,11 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
 /// `new_len` may be zero, in which case the allocation is freed.
 ///
 /// If the allocation's elements' type is zero bytes sized, `allocation.len` is set to `new_len`.
-pub fn remap(self: Allocator, allocation: anytype, new_len: usize) t: {
-    const Slice = @typeInfo(@TypeOf(allocation)).pointer;
-    break :t ?[]align(Slice.alignment) Slice.child;
-} {
-    const Slice = @typeInfo(@TypeOf(allocation)).pointer;
-    const T = Slice.child;
+pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allocation) {
+    const slice_info = @typeInfo(@TypeOf(allocation)).pointer;
+    comptime assert(slice_info.size == .slice);
+    const T = slice_info.child;
 
-    const alignment = Slice.alignment;
     if (new_len == 0) {
         self.free(allocation);
         return allocation[0..0];
@@ -367,9 +373,13 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) t: {
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
     const new_len_bytes = math.mul(usize, @sizeOf(T), new_len) catch return null;
-    const new_ptr = self.rawRemap(old_memory, .fromByteUnits(alignment), new_len_bytes, @returnAddress()) orelse return null;
-    const new_memory: []align(alignment) u8 = @alignCast(new_ptr[0..new_len_bytes]);
-    return mem.bytesAsSlice(T, new_memory);
+    const new_ptr = self.rawRemap(
+        old_memory,
+        .fromByteUnits(slice_info.alignment orelse @alignOf(T)),
+        new_len_bytes,
+        @returnAddress(),
+    ) orelse return null;
+    return @ptrCast(@alignCast(new_ptr[0..new_len_bytes]));
 }
 
 /// This function requests a new size for an existing allocation, which
@@ -386,10 +396,7 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) t: {
 ///   do the realloc more efficiently than the caller
 /// * `resize` which returns `false` when the `Allocator` implementation cannot
 ///   change the size without relocating the allocation.
-pub fn realloc(self: Allocator, old_mem: anytype, new_n: usize) t: {
-    const Slice = @typeInfo(@TypeOf(old_mem)).pointer;
-    break :t Error![]align(Slice.alignment) Slice.child;
-} {
+pub fn realloc(self: Allocator, old_mem: anytype, new_n: usize) Error!@TypeOf(old_mem) {
     return self.reallocAdvanced(old_mem, new_n, @returnAddress());
 }
 
@@ -398,51 +405,49 @@ pub fn reallocAdvanced(
     old_mem: anytype,
     new_n: usize,
     return_address: usize,
-) t: {
-    const Slice = @typeInfo(@TypeOf(old_mem)).pointer;
-    break :t Error![]align(Slice.alignment) Slice.child;
-} {
-    const Slice = @typeInfo(@TypeOf(old_mem)).pointer;
-    const T = Slice.child;
+) Error!@TypeOf(old_mem) {
+    const slice_info = @typeInfo(@TypeOf(old_mem)).pointer;
+    comptime assert(slice_info.size == .slice);
+    const T = slice_info.child;
     if (old_mem.len == 0) {
-        return self.allocAdvancedWithRetAddr(T, .fromByteUnits(Slice.alignment), new_n, return_address);
+        return self.allocAdvancedWithRetAddr(T, .fromByteUnitsOptional(slice_info.alignment), new_n, return_address);
     }
     if (new_n == 0) {
         self.free(old_mem);
-        const ptr = comptime std.mem.alignBackward(usize, math.maxInt(usize), Slice.alignment);
-        return @as([*]align(Slice.alignment) T, @ptrFromInt(ptr))[0..0];
+        const alignment = slice_info.alignment orelse @alignOf(T);
+        const addr = comptime std.mem.alignBackward(usize, math.maxInt(usize), alignment);
+        const ptr: *align(alignment) [0]T = @ptrFromInt(addr);
+        return ptr;
     }
 
     const old_byte_slice = mem.sliceAsBytes(old_mem);
-    const byte_count = math.mul(usize, @sizeOf(T), new_n) catch return Error.OutOfMemory;
+    const byte_count = math.mul(usize, @sizeOf(T), new_n) catch return error.OutOfMemory;
     // Note: can't set shrunk memory to undefined as memory shouldn't be modified on realloc failure
-    if (self.rawRemap(old_byte_slice, .fromByteUnits(Slice.alignment), byte_count, return_address)) |p| {
-        const new_bytes: []align(Slice.alignment) u8 = @alignCast(p[0..byte_count]);
-        return mem.bytesAsSlice(T, new_bytes);
+    if (self.rawRemap(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), byte_count, return_address)) |p| {
+        return @ptrCast(@alignCast(p[0..byte_count]));
     }
 
-    const new_mem = self.rawAlloc(byte_count, .fromByteUnits(Slice.alignment), return_address) orelse
+    const new_mem = self.rawAlloc(byte_count, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), return_address) orelse
         return error.OutOfMemory;
     const copy_len = @min(byte_count, old_byte_slice.len);
     @memcpy(new_mem[0..copy_len], old_byte_slice[0..copy_len]);
     @memset(old_byte_slice, undefined);
-    self.rawFree(old_byte_slice, .fromByteUnits(Slice.alignment), return_address);
+    self.rawFree(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), return_address);
 
-    const new_bytes: []align(Slice.alignment) u8 = @alignCast(new_mem[0..byte_count]);
-    return mem.bytesAsSlice(T, new_bytes);
+    return @ptrCast(@alignCast(new_mem[0..byte_count]));
 }
 
 /// Free an array allocated with `alloc`.
 /// If memory has length 0, free is a no-op.
 /// To free a single item, see `destroy`.
 pub fn free(self: Allocator, memory: anytype) void {
-    const Slice = @typeInfo(@TypeOf(memory)).pointer;
-    const bytes = mem.sliceAsBytes(memory);
-    const bytes_len = bytes.len + if (Slice.sentinel() != null) @sizeOf(Slice.child) else 0;
-    if (bytes_len == 0) return;
-    const non_const_ptr = @constCast(bytes.ptr);
-    @memset(non_const_ptr[0..bytes_len], undefined);
-    self.rawFree(non_const_ptr[0..bytes_len], .fromByteUnits(Slice.alignment), @returnAddress());
+    const slice_info = @typeInfo(@TypeOf(memory)).pointer;
+    comptime assert(slice_info.size == .slice);
+    const mem_with_sent = memory[0 .. memory.len + @intFromBool(slice_info.sentinel() != null)];
+    const bytes: []u8 = @ptrCast(@constCast(mem_with_sent));
+    if (bytes.len == 0) return;
+    @memset(bytes, undefined);
+    self.rawFree(bytes, .fromByteUnits(slice_info.alignment orelse @alignOf(slice_info.child)), @returnAddress());
 }
 
 /// Copies `m` to newly allocated memory. Caller owns the memory.
diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index 6236f1a56bfc9c841044d35362699d555df19cff..632c65678f28107c8f20444c68a74d27cae02309 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -63,7 +63,7 @@ pub fn alignment(comptime T: type) comptime_int {
             .pointer, .@"fn" => alignment(info.child),
             else => @alignOf(T),
         },
-        .pointer => |info| info.alignment,
+        .pointer => |info| info.alignment orelse @alignOf(info.child),
         else => @alignOf(T),
     };
 }
diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig
index 92d094f0cc93e96600b03d33f46db1c298c159c1..fde7e93ed652c3d6d360516e9441ece0ca88dacc 100644
--- a/lib/std/multi_array_list.zig
+++ b/lib/std/multi_array_list.zig
@@ -194,9 +194,9 @@ pub fn MultiArrayList(comptime T: type) type {
                 data[i] = .{
                     .size = @sizeOf(field_info.type),
                     .size_index = i,
-                    .alignment = if (@sizeOf(field_info.type) == 0) 1 else field_info.alignment,
+                    .alignment = field_info.alignment orelse @alignOf(field_info.type),
                 };
-                big_align = @max(big_align, @alignOf(field_info.type));
+                big_align = @max(big_align, data[i].alignment);
             }
             const Sort = struct {
                 fn lessThan(context: void, lhs: Data, rhs: Data) bool {
diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig
index 3527f03342b64f5c6f19bad7e163873aeeabcd2b..9f492ddbea6eafdf1841d86cb0d9f383c42b8638 100644
--- a/lib/std/zon/parse.zig
+++ b/lib/std/zon/parse.zig
@@ -591,7 +591,7 @@ const Parser = struct {
                     if (pointer.child == u8 and
                         pointer.is_const and
                         (pointer.sentinel() == null or pointer.sentinel() == 0) and
-                        pointer.alignment == 1)
+                        (pointer.alignment == null or pointer.alignment == 1))
                     {
                         if (opt) {
                             return self.failNode(node, "expected optional string");
@@ -717,7 +717,7 @@ const Parser = struct {
             pointer.size != .slice or
             !pointer.is_const or
             (pointer.sentinel() != null and pointer.sentinel() != 0) or
-            pointer.alignment != 1)
+            (pointer.alignment != null and pointer.alignment != 1))
         {
             return error.WrongType;
         }
@@ -742,7 +742,7 @@ const Parser = struct {
         const slice = try self.gpa.allocWithOptions(
             pointer.child,
             nodes.len,
-            .fromByteUnits(pointer.alignment),
+            .fromByteUnitsOptional(pointer.alignment),
             pointer.sentinel(),
         );
         errdefer self.gpa.free(slice);
-- 
2.54.0


From ce1f28a7497903cf00431d6976c162c37683232a Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Wed, 4 Mar 2026 16:34:09 +0000
Subject: [PATCH 485/499] behavior: update for `std.builtin.Type` changes

---
 test/behavior/tuple_declarations.zig |  4 ++--
 test/behavior/type_info.zig          | 16 ++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/test/behavior/tuple_declarations.zig b/test/behavior/tuple_declarations.zig
index 643d79baa1c84073b106b70cdd3fc5509f4e0c42..cc87913975fdd126f85239fa83765d34f7d5c80c 100644
--- a/test/behavior/tuple_declarations.zig
+++ b/test/behavior/tuple_declarations.zig
@@ -22,13 +22,13 @@ test "tuple declaration type info" {
         try expect(info.fields[0].type == u32);
         try expect(info.fields[0].defaultValue() == 1);
         try expect(info.fields[0].is_comptime);
-        try expect(info.fields[0].alignment == @alignOf(u32));
+        try expect(info.fields[0].alignment == null);
 
         try expectEqualStrings(info.fields[1].name, "1");
         try expect(info.fields[1].type == []const u8);
         try expect(info.fields[1].defaultValue() == null);
         try expect(!info.fields[1].is_comptime);
-        try expect(info.fields[1].alignment == @alignOf([]const u8));
+        try expect(info.fields[1].alignment == null);
     }
 }
 
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index 48b10c458aa325007a6975dbf78373248d717ee3..cd1455e5235a5bacd1a783f2309a0c4fe30839bd 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -82,7 +82,7 @@ fn testPointer() !void {
     try expect(u32_ptr_info.pointer.size == .one);
     try expect(u32_ptr_info.pointer.is_const == false);
     try expect(u32_ptr_info.pointer.is_volatile == false);
-    try expect(u32_ptr_info.pointer.alignment == @alignOf(u32));
+    try expect(u32_ptr_info.pointer.alignment == null);
     try expect(u32_ptr_info.pointer.child == u32);
     try expect(u32_ptr_info.pointer.sentinel() == null);
 }
@@ -99,7 +99,7 @@ fn testUnknownLenPtr() !void {
     try expect(u32_ptr_info.pointer.is_const == true);
     try expect(u32_ptr_info.pointer.is_volatile == true);
     try expect(u32_ptr_info.pointer.sentinel() == null);
-    try expect(u32_ptr_info.pointer.alignment == @alignOf(f64));
+    try expect(u32_ptr_info.pointer.alignment == null);
     try expect(u32_ptr_info.pointer.child == f64);
 }
 
@@ -130,7 +130,7 @@ fn testSlice() !void {
     try expect(u32_slice_info.pointer.size == .slice);
     try expect(u32_slice_info.pointer.is_const == false);
     try expect(u32_slice_info.pointer.is_volatile == false);
-    try expect(u32_slice_info.pointer.alignment == 4);
+    try expect(u32_slice_info.pointer.alignment == null);
     try expect(u32_slice_info.pointer.child == u32);
 }
 
@@ -266,9 +266,9 @@ fn testUnion() !void {
     try expect(notag_union_info.@"union".tag_type == null);
     try expect(notag_union_info.@"union".layout == .auto);
     try expect(notag_union_info.@"union".fields.len == 2);
-    try expect(notag_union_info.@"union".fields[0].alignment == @alignOf(void));
+    try expect(notag_union_info.@"union".fields[0].alignment == null);
     try expect(notag_union_info.@"union".fields[1].type == u32);
-    try expect(notag_union_info.@"union".fields[1].alignment == @alignOf(u32));
+    try expect(notag_union_info.@"union".fields[1].alignment == null);
 
     const TestExternUnion = extern union {
         foo: *anyopaque,
@@ -292,7 +292,7 @@ fn testStruct() !void {
     const unpacked_struct_info = @typeInfo(TestStruct);
     try expect(unpacked_struct_info.@"struct".is_tuple == false);
     try expect(unpacked_struct_info.@"struct".backing_integer == null);
-    try expect(unpacked_struct_info.@"struct".fields[0].alignment == @alignOf(u32));
+    try expect(unpacked_struct_info.@"struct".fields[0].alignment == null);
     try expect(unpacked_struct_info.@"struct".fields[0].defaultValue().? == 4);
     try expect(mem.eql(u8, "foobar", unpacked_struct_info.@"struct".fields[1].defaultValue().?));
 }
@@ -314,11 +314,11 @@ fn testPackedStruct() !void {
     try expect(struct_info.@"struct".layout == .@"packed");
     try expect(struct_info.@"struct".backing_integer == u128);
     try expect(struct_info.@"struct".fields.len == 4);
-    try expect(struct_info.@"struct".fields[0].alignment == 0);
+    try expect(struct_info.@"struct".fields[0].alignment == null);
     try expect(struct_info.@"struct".fields[2].type == f32);
     try expect(struct_info.@"struct".fields[2].defaultValue() == null);
     try expect(struct_info.@"struct".fields[3].defaultValue().? == 4);
-    try expect(struct_info.@"struct".fields[3].alignment == 0);
+    try expect(struct_info.@"struct".fields[3].alignment == null);
     try expect(struct_info.@"struct".decls.len == 1);
 }
 
-- 
2.54.0


From 34d780f4bbefa8344cae5da49fe84bed83d8274f Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Thu, 5 Mar 2026 22:13:22 +0000
Subject: [PATCH 486/499] langref: update for language changes

---
 doc/langref.html.in                              |  5 +++--
 doc/langref/test_comptime_invalid_error_code.zig |  7 ++-----
 doc/langref/test_missized_packed_struct.zig      |  2 +-
 doc/langref/test_variable_alignment.zig          | 15 ++++++++++-----
 4 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index e87decdf4a9ab51de65bc8ae0c8d6a8378b47dcd..643c948b68e99e11236f9c24e180af848736a820 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -2103,8 +2103,9 @@ or
       less than {#syntax#}1 << 29{#endsyntax#}.
       </p>
       <p>
-      In Zig, a pointer type has an alignment value. If the value is equal to the
-      alignment of the underlying type, it can be omitted from the type:
+      Pointer types may explicitly specify an alignment in bytes. If it is not
+      specified, the alignment is assumed to be equal to the alignment of the
+      underlying type.
       </p>
       {#code|test_variable_alignment.zig#}
 
diff --git a/doc/langref/test_comptime_invalid_error_code.zig b/doc/langref/test_comptime_invalid_error_code.zig
index ebc6314764b399fcbbb5a1b03225e4d9611f5f21..e4fedf5812a972af6168e26c7689de92a204165c 100644
--- a/doc/langref/test_comptime_invalid_error_code.zig
+++ b/doc/langref/test_comptime_invalid_error_code.zig
@@ -1,8 +1,5 @@
 comptime {
-    const err = error.AnError;
-    const number = @intFromError(err) + 10;
-    const invalid_err = @errorFromInt(number);
-    _ = invalid_err;
+    _ = @errorFromInt(12345);
 }
 
-// test_error=integer value '11' represents no error
+// test_error=integer value '12345' represents no error
diff --git a/doc/langref/test_missized_packed_struct.zig b/doc/langref/test_missized_packed_struct.zig
index 791f97cc311b6f33b5859e1612c684cde6d0d6c3..df323244d4bebdf34dd6dde9bdbdfe6d8720dfd2 100644
--- a/doc/langref/test_missized_packed_struct.zig
+++ b/doc/langref/test_missized_packed_struct.zig
@@ -3,4 +3,4 @@ test "missized packed struct" {
     _ = S{ .a = 4, .b = 2 };
 }
 
-// test_error=backing integer type 'u32' has bit size 32 but the struct fields have a total bit size of 24
+// test_error=backing integer bit width does not match total bit width of fields
diff --git a/doc/langref/test_variable_alignment.zig b/doc/langref/test_variable_alignment.zig
index 01768e29eb0e81d5924644fbbbbd6739047fb690..d0a4560fa2954930d7d2f460c2d74d6b64b0d3cf 100644
--- a/doc/langref/test_variable_alignment.zig
+++ b/doc/langref/test_variable_alignment.zig
@@ -1,15 +1,20 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 test "variable alignment" {
     var x: i32 = 1234;
-    const align_of_i32 = @alignOf(@TypeOf(x));
+
     try expectEqual(*i32, @TypeOf(&x));
-    try expectEqual(*align(align_of_i32) i32, *i32);
-    if (builtin.target.cpu.arch == .x86_64) {
-        try expectEqual(4, @typeInfo(*i32).pointer.alignment);
-    }
+
+    try expect(@intFromPtr(&x) % @alignOf(i32) == 0);
+
+    // The implicitly-aligned pointer can be coerced to be explicitly-aligned to
+    // the alignment of the underlying type `i32`:
+    const ptr: *align(@alignOf(i32)) i32 = &x;
+
+    try expectEqual(1234, ptr.*);
 }
 
 // test
-- 
2.54.0


From 1293f080fdfc74966b541b44f0a907561df3d617 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 6 Mar 2026 12:47:11 +0000
Subject: [PATCH 487/499] build.zig: bump max_rss values

---
 build.zig | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/build.zig b/build.zig
index 06ba1aab65bb127957fb1abb3ba8dafc3d40db9d..4e6efa41a6e6dbca14bf3d37f17117a61f1fcb85 100644
--- a/build.zig
+++ b/build.zig
@@ -568,7 +568,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = 8_500_000_000,
+        .max_rss = 9_300_000_000,
     }));
 
     const unit_tests_step = b.step("test-unit", "Run the compiler source unit tests");
@@ -584,7 +584,7 @@ pub fn build(b: *std.Build) !void {
         .use_llvm = use_llvm,
         .use_lld = use_llvm,
         .zig_lib_dir = b.path("lib"),
-        .max_rss = 2_500_000_000,
+        .max_rss = 2_700_000_000,
     });
     if (link_libc) {
         unit_tests.root_module.link_libc = true;
@@ -611,7 +611,7 @@ pub fn build(b: *std.Build) !void {
         .skip_linux = skip_linux,
         .skip_llvm = skip_llvm,
         .skip_release = skip_release,
-        .max_rss = 3_000_000_000,
+        .max_rss = 3_300_000_000,
     }));
     test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows));
     test_step.dependOn(tests.addStackTraceTests(b, test_filters, skip_non_native));
@@ -767,7 +767,7 @@ fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Modu
 fn addCompilerStep(b: *std.Build, options: AddCompilerModOptions) *std.Build.Step.Compile {
     const exe = b.addExecutable(.{
         .name = "zig",
-        .max_rss = 7_900_000_000,
+        .max_rss = 8_700_000_000,
         .root_module = addCompilerMod(b, options),
     });
     exe.stack_size = stack_size;
-- 
2.54.0


From f92b998f9fe985d554d6078bb2bb11d094d94b91 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Fri, 6 Mar 2026 16:30:56 +0000
Subject: [PATCH 488/499] behavior: disable some tests under the C backend
 targeting MSVC

The bugs here actually exist on master branch too, but they are being
caught by the new static assertions which check type size and alignment.
It turns out that MSVC's struct/union "pack" pragma and its "align"
declspec interact in undocumented ways which are extremely problematic
for generated code. Solving this will require changing how the C backend
lowers various types; the disabled tests are all tagged unions, but
there are also issues with structs with underaligned fields which the
behavior tests just happen to not currently be triggering.
---
 test/behavior/align.zig | 1 +
 test/behavior/union.zig | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index a59bed56ba8c4e46892b25ca834cf7f45e54ec21..550d7008b419474cbb9b207fc2b22fcd5549960f 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -18,6 +18,7 @@ test "global variable alignment" {
 test "large alignment of local constant" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
+    if (builtin.zig_backend == .stage2_c and builtin.target.abi == .msvc) return error.SkipZigTest;
 
     const x: f32 align(128) = 12.34;
     try std.testing.expect(@intFromPtr(&x) % 128 == 0);
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 9badc9dabd11bd6709c95ae32ba755f6cc3b9bd2..faa3f42ea5f8f1415efdf5dcf2b887a0ba0066c4 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -148,6 +148,7 @@ const err = @as(anyerror!Agg, Agg{
 const array = [_]Value{ v1, v2, v1, v2 };
 
 test "unions embedded in aggregate types" {
+    if (builtin.zig_backend == .stage2_c and builtin.target.abi == .msvc) return error.SkipZigTest;
     switch (array[1]) {
         Value.Array => |arr| try expect(arr[4] == 3),
         else => unreachable,
@@ -2022,6 +2023,7 @@ test "runtime union init, most-aligned field != largest" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and builtin.target.abi == .msvc) return error.SkipZigTest;
 
     const U = union(enum) {
         x: u128,
-- 
2.54.0


From a3d2f2999f9708cbcc6f3082547b5f68a3b593cd Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Mar 2026 16:18:18 +0000
Subject: [PATCH 489/499] tests: add new tests

Some for bugs which have been fixed, some for language changes.
---
 test/behavior/alignof.zig                     |  5 ++
 test/behavior/enum.zig                        | 15 ++++++
 test/behavior/error.zig                       | 33 ++++++++++++
 test/behavior/packed-union.zig                | 22 ++++++++
 test/behavior/struct.zig                      | 51 +++++++++++++++++++
 test/behavior/tuple.zig                       | 11 ++++
 .../compile_errors/enum_uses_own_typeinfo.zig | 15 ++++++
 ...enum_without_explicit_integer_tag_type.zig |  4 +-
 ...mpatible_but_inferred_integer_tag_type.zig | 45 ----------------
 ...non-extern-compatible_integer_tag_type.zig |  4 +-
 .../fn_type_returning_pointer_to_itself.zig   |  8 +++
 ...h_non-extern_non-packed_enum_parameter.zig |  4 +-
 ...mplicit_backing_type_in_extern_context.zig | 51 +++++++++++++++++++
 .../packed_struct_uses_own_size.zig           | 10 ++++
 .../packed_struct_uses_own_typeinfo.zig       | 13 +++++
 .../compile_errors/simple_struct_loop.zig     | 16 ++++++
 test/cases/compile_errors/sizeOf_bad_type.zig |  4 ++
 ...truct_field_queries_hasfield_of_itself.zig | 14 +++++
 ...ed_type_which_queries_struct_alignment.zig | 13 +++++
 .../struct_uses_sizeof_self_as_array_len.zig  | 10 ++++
 20 files changed, 297 insertions(+), 51 deletions(-)
 create mode 100644 test/cases/compile_errors/enum_uses_own_typeinfo.zig
 delete mode 100644 test/cases/compile_errors/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
 create mode 100644 test/cases/compile_errors/fn_type_returning_pointer_to_itself.zig
 create mode 100644 test/cases/compile_errors/implicit_backing_type_in_extern_context.zig
 create mode 100644 test/cases/compile_errors/packed_struct_uses_own_size.zig
 create mode 100644 test/cases/compile_errors/packed_struct_uses_own_typeinfo.zig
 create mode 100644 test/cases/compile_errors/simple_struct_loop.zig
 create mode 100644 test/cases/compile_errors/struct_field_queries_hasfield_of_itself.zig
 create mode 100644 test/cases/compile_errors/struct_uses_reified_type_which_queries_struct_alignment.zig
 create mode 100644 test/cases/compile_errors/struct_uses_sizeof_self_as_array_len.zig

diff --git a/test/behavior/alignof.zig b/test/behavior/alignof.zig
index 7adec6168fa79169d21894fe63116f32b49c286d..f8914ead80b5dc4ee8eed3039e0ad96d7f880961 100644
--- a/test/behavior/alignof.zig
+++ b/test/behavior/alignof.zig
@@ -39,3 +39,8 @@ test "correct alignment for elements and slices of aligned array" {
     try expect(@alignOf(@TypeOf(&buf[start..end])) == @alignOf(*u8));
     try expect(@alignOf(@TypeOf(&buf[start])) == @alignOf(*u8));
 }
+
+test "@alignOf(anyerror!noreturn)" {
+    try expect(@alignOf(anyerror!noreturn) == @alignOf(anyerror));
+    try expect(@alignOf(anyerror!anyerror!noreturn) == @alignOf(anyerror));
+}
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index 4dd5ae08da6e0bf73f81b148ae060c99b7ca2be2..9ec1ed8c35b920957ed77582a56775c6b0618519 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -1354,3 +1354,18 @@ test "empty enum passed as argument" {
     };
     E.f(@as(E, undefined));
 }
+
+test "enum int tag type uses declaration inside the enum" {
+    const static = struct {
+        const E = enum(E.IntTag) {
+            const IntTag = u8;
+            a,
+            b,
+            c,
+        };
+    };
+    try expect(@sizeOf(static.E) == @sizeOf(u8));
+    const val: static.E = .b;
+    try expect(val == .b);
+    try expect(@intFromEnum(val) == 1);
+}
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index d74a7668a97eb29982a0ebf50a87948b8a629ee5..0679736ac34d478cdaa2212e4836670ce9d3fabb 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -1109,3 +1109,36 @@ test "'if' ignores error via local while 'else' ignores error directly" {
     try S.testOne(false);
     try S.testOne(true);
 }
+
+test "@errorCast into own inferred error set" {
+    const static = struct {
+        fn foo(b: bool) !void {
+            if (b) {
+                return @errorCast(error.Bad);
+            }
+        }
+    };
+    try static.foo(false);
+    if (static.foo(true)) {
+        return error.ExpectedError;
+    } else |err| {
+        try expect(err == error.Bad);
+    }
+
+    const errors = @typeInfo(@typeInfo(@TypeOf(static.foo(false))).error_union.error_set).error_set.?;
+    comptime assert(errors.len == 1);
+    comptime assert(std.mem.eql(u8, errors[0].name, "Bad"));
+}
+
+test "@errorCast into other inferred error set" {
+    const static = struct {
+        fn foo() !void {
+            return error.Bad;
+        }
+    };
+    const Ies = @typeInfo(@TypeOf(static.foo())).error_union.error_set;
+    const err: Ies = @errorCast(error.Bad);
+    try expect(err == error.Bad);
+    const non_err: Ies!u32 = @errorCast(@as(error{}!u32, 123));
+    try expect(try non_err == 123);
+}
diff --git a/test/behavior/packed-union.zig b/test/behavior/packed-union.zig
index f625c8b0733ba6b0819feaf568ab6e4796f6cf47..330a4853b13383b05fc4b7363c8b35e916085d9f 100644
--- a/test/behavior/packed-union.zig
+++ b/test/behavior/packed-union.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const assert = std.debug.assert;
+const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 test "flags in packed union" {
@@ -177,3 +178,24 @@ test "assigning to non-active field at comptime" {
         test_bits.bits = .{};
     }
 }
+
+test "packed union with explicit backing integer" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
+    const U = packed union(i32) {
+        raw: i32,
+        unsigned_halves: packed struct { low: u16, high: u16 },
+
+        fn check(val: @This()) !void {
+            try expect(@as(i32, @bitCast(val)) == -2);
+            try expect(@as(u32, @bitCast(val)) == 0xFFFFFFFE);
+            try expect(val.raw == -2);
+            try expect(val.unsigned_halves.low == 0xFFFE);
+            try expect(val.unsigned_halves.high == 0xFFFF);
+        }
+    };
+    try U.check(.{ .raw = -2 });
+    try comptime U.check(.{ .raw = -2 });
+}
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index e6a355864629600f6294492ee11e4cf7c73f5674..3c2d01f6a4014556c4b87ef66a804e5eacb381af 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -2254,3 +2254,54 @@ test "runtime-known slice of comptime-only struct" {
         .{ .index = 15, .T = Mixed },
     });
 }
+
+test "struct contains aligned pointer to itself through type decl" {
+    const Slab = struct {
+        const Ptr = *align(64) const @This();
+        next: Ptr,
+    };
+    // We intentionally use `Slab.Ptr` before `Slab`.
+    var ptr: Slab.Ptr = undefined;
+    var slab: Slab align(64) = undefined;
+    ptr = &slab;
+    slab.next = ptr;
+
+    try expect(ptr == &slab);
+    try expect(slab.next == &slab);
+    try expect(slab.next.next == &slab);
+    try expect(slab.next.next.next == &slab);
+}
+
+test "struct contains underaligned field with overaligned pointer to itself" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    const S = struct {
+        ptr: *align(8) @This() align(1),
+    };
+    var val: S align(8) = undefined;
+    val.ptr = &val;
+    try expect(val.ptr == &val);
+    try expect(val.ptr.ptr == &val);
+    try expect(val.ptr.ptr.ptr == &val);
+}
+
+test "struct contains pointer to function accepting that struct" {
+    const S = struct {
+        const FnPtr = ?*const fn (@This()) void;
+        fn_ptr: FnPtr,
+    };
+    const dummy_fn_ptr: S.FnPtr = @ptrFromInt(0x100000);
+    const dummy_s: S = .{ .fn_ptr = dummy_fn_ptr };
+    try expect(dummy_s.fn_ptr == dummy_fn_ptr);
+    try expect(@TypeOf(dummy_s.fn_ptr.?) == *const fn (S) void);
+}
+
+test "struct queries typeinfo of struct containing pointer back to first struct" {
+    const static = struct {
+        const A = struct { b: *B };
+        const B = struct { a: T: {
+            _ = @typeInfo(A);
+            break :T u32;
+        } };
+    };
+    _ = @as(static.A, undefined);
+}
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index a88a99171b9ed3e7106d48abf76f1c57afce0da0..75cf4515a514512b24fff32410d0d3ccb397552c 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -592,3 +592,14 @@ test "array of tuples that end with a zero-bit field followed by padding" {
     try expect(S.foo[1][1] == 4);
     try expect(S.foo[1][2] == {});
 }
+
+test "call function at comptime through container-level const tuple" {
+    const static = struct {
+        const MyTuple = struct { (fn () u32) };
+        const val: MyTuple = .{foo};
+        fn foo() u32 {
+            return 1234;
+        }
+    };
+    comptime assert(static.val[0]() == 1234);
+}
diff --git a/test/cases/compile_errors/enum_uses_own_typeinfo.zig b/test/cases/compile_errors/enum_uses_own_typeinfo.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5906ba6bcb386e4f36bb1f7d343675e5ba8c248e
--- /dev/null
+++ b/test/cases/compile_errors/enum_uses_own_typeinfo.zig
@@ -0,0 +1,15 @@
+const E = enum(u9) {
+    const a_val: @typeInfo(E).@"enum".tag_type = 0;
+    a = a_val,
+};
+comptime {
+    _ = E.a;
+}
+
+// error
+//
+// error: dependency loop with length 3
+// :3:9: note: type 'tmp.E' uses value of declaration 'tmp.E.a_val' here
+// :2:50: note: value of declaration 'tmp.E.a_val' uses type of declaration 'tmp.E.a_val' here
+// :2:18: note: type of declaration 'tmp.E.a_val' depends on type 'tmp.E' for type information query here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/exported_enum_without_explicit_integer_tag_type.zig b/test/cases/compile_errors/exported_enum_without_explicit_integer_tag_type.zig
index 3ff9961de81d96f945efd09d7eee724ca0bcaf2c..aa79ee1ad631d7658cd64346ad84d8fe531db306 100644
--- a/test/cases/compile_errors/exported_enum_without_explicit_integer_tag_type.zig
+++ b/test/cases/compile_errors/exported_enum_without_explicit_integer_tag_type.zig
@@ -11,6 +11,6 @@ comptime {
 //
 // :3:5: error: unable to export type 'type'
 // :7:5: error: unable to export type 'tmp.E'
-// :7:5: note: enum tag type 'u1' is not extern compatible
-// :7:5: note: only integers with 0, 8, 16, 32, 64 and 128 bits are extern compatible
+// :1:11: note: integer tag type of enum is inferred
+// :1:11: note: consider explicitly specifying the integer tag type
 // :1:11: note: enum declared here
diff --git a/test/cases/compile_errors/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig b/test/cases/compile_errors/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
deleted file mode 100644
index a0e476f087629eb0e720a4f06e8db692d46508e6..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
+++ /dev/null
@@ -1,45 +0,0 @@
-// zig fmt: off
-pub const E = enum {
-@"0",@"1",@"2",@"3",@"4",@"5",@"6",@"7",@"8",@"9",@"10",@"11",@"12",
-@"13",@"14",@"15",@"16",@"17",@"18",@"19",@"20",@"21",@"22",@"23",
-@"24",@"25",@"26",@"27",@"28",@"29",@"30",@"31",@"32",@"33",@"34",
-@"35",@"36",@"37",@"38",@"39",@"40",@"41",@"42",@"43",@"44",@"45",
-@"46",@"47",@"48",@"49",@"50",@"51",@"52",@"53",@"54",@"55",@"56",
-@"57",@"58",@"59",@"60",@"61",@"62",@"63",@"64",@"65",@"66",@"67",
-@"68",@"69",@"70",@"71",@"72",@"73",@"74",@"75",@"76",@"77",@"78",
-@"79",@"80",@"81",@"82",@"83",@"84",@"85",@"86",@"87",@"88",@"89",
-@"90",@"91",@"92",@"93",@"94",@"95",@"96",@"97",@"98",@"99",@"100",
-@"101",@"102",@"103",@"104",@"105",@"106",@"107",@"108",@"109",
-@"110",@"111",@"112",@"113",@"114",@"115",@"116",@"117",@"118",
-@"119",@"120",@"121",@"122",@"123",@"124",@"125",@"126",@"127",
-@"128",@"129",@"130",@"131",@"132",@"133",@"134",@"135",@"136",
-@"137",@"138",@"139",@"140",@"141",@"142",@"143",@"144",@"145",
-@"146",@"147",@"148",@"149",@"150",@"151",@"152",@"153",@"154",
-@"155",@"156",@"157",@"158",@"159",@"160",@"161",@"162",@"163",
-@"164",@"165",@"166",@"167",@"168",@"169",@"170",@"171",@"172",
-@"173",@"174",@"175",@"176",@"177",@"178",@"179",@"180",@"181",
-@"182",@"183",@"184",@"185",@"186",@"187",@"188",@"189",@"190",
-@"191",@"192",@"193",@"194",@"195",@"196",@"197",@"198",@"199",
-@"200",@"201",@"202",@"203",@"204",@"205",@"206",@"207",@"208",
-@"209",@"210",@"211",@"212",@"213",@"214",@"215",@"216",@"217",
-@"218",@"219",@"220",@"221",@"222",@"223",@"224",@"225",@"226",
-@"227",@"228",@"229",@"230",@"231",@"232",@"233",@"234",@"235",
-@"236",@"237",@"238",@"239",@"240",@"241",@"242",@"243",@"244",
-@"245",@"246",@"247",@"248",@"249",@"250",@"251",@"252",@"253",
-@"254",@"255", @"256"
-};
-// zig fmt: on
-pub const S = extern struct {
-    e: E,
-};
-export fn entry() void {
-    const s: S = undefined;
-    _ = s;
-}
-
-// error
-//
-// :33:8: error: extern structs cannot contain fields of type 'tmp.E'
-// :33:8: note: enum tag type 'u9' is not extern compatible
-// :33:8: note: only integers with 0 or power of two bits are extern compatible
-// :2:15: note: enum declared here
diff --git a/test/cases/compile_errors/extern_struct_with_non-extern-compatible_integer_tag_type.zig b/test/cases/compile_errors/extern_struct_with_non-extern-compatible_integer_tag_type.zig
index 373f10444d3ce322d0c3822a031461a74c2d97ed..fdf0f9aadd08021eb5a34367e80b93ade4ea1b3b 100644
--- a/test/cases/compile_errors/extern_struct_with_non-extern-compatible_integer_tag_type.zig
+++ b/test/cases/compile_errors/extern_struct_with_non-extern-compatible_integer_tag_type.zig
@@ -10,6 +10,6 @@ export fn entry() void {
 // error
 //
 // :3:8: error: extern structs cannot contain fields of type 'tmp.E'
-// :3:8: note: enum tag type 'u31' is not extern compatible
-// :3:8: note: only integers with 0 or power of two bits are extern compatible
+// :1:15: note: enum tag type 'u31' is not extern compatible
+// :1:15: note: only integers with 0 or power of two bits are extern compatible
 // :1:15: note: enum declared here
diff --git a/test/cases/compile_errors/fn_type_returning_pointer_to_itself.zig b/test/cases/compile_errors/fn_type_returning_pointer_to_itself.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4afacccc8d813ddaa9a7cdd0e2641e4f6d492de0
--- /dev/null
+++ b/test/cases/compile_errors/fn_type_returning_pointer_to_itself.zig
@@ -0,0 +1,8 @@
+const MyFn = fn () ?*const MyFn;
+comptime {
+    _ = MyFn;
+}
+
+// error
+//
+// :1:28: error: value of declaration 'tmp.MyFn' depends on itself here
diff --git a/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig b/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
index 8122a89adc26bafa30189e9a3217b2e1dd19d372..ed9828c6921f5e46fc658d2857dc4f06f6971687 100644
--- a/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
+++ b/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
@@ -7,6 +7,6 @@ export fn entry(foo: Foo) void {
 // target=x86_64-linux
 //
 // :2:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'x86_64_sysv'
-// :2:17: note: enum tag type 'u2' is not extern compatible
-// :2:17: note: only integers with 0, 8, 16, 32, 64 and 128 bits are extern compatible
+// :1:13: note: integer tag type of enum is inferred
+// :1:13: note: consider explicitly specifying the integer tag type
 // :1:13: note: enum declared here
diff --git a/test/cases/compile_errors/implicit_backing_type_in_extern_context.zig b/test/cases/compile_errors/implicit_backing_type_in_extern_context.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5d1b8e75ae054a60dbccb25435130acbfe6039f8
--- /dev/null
+++ b/test/cases/compile_errors/implicit_backing_type_in_extern_context.zig
@@ -0,0 +1,51 @@
+const PackedStruct = packed struct { x: u32 };
+const PackedUnion = packed union { x: u32 };
+
+/// This enum has 256 fields, so `u8` will be its inferred tag type.
+const Enum = enum {
+    // zig fmt: off
+    _00, _01, _02, _03, _04, _05, _06, _07, _08, _09, _0a, _0b, _0c, _0d, _0e, _0f,
+    _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _1a, _1b, _1c, _1d, _1e, _1f,
+    _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _2a, _2b, _2c, _2d, _2e, _2f,
+    _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _3a, _3b, _3c, _3d, _3e, _3f,
+    _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _4a, _4b, _4c, _4d, _4e, _4f,
+    _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _5a, _5b, _5c, _5d, _5e, _5f,
+    _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _6a, _6b, _6c, _6d, _6e, _6f,
+    _70, _71, _72, _73, _74, _75, _76, _77, _78, _79, _7a, _7b, _7c, _7d, _7e, _7f,
+    _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _8a, _8b, _8c, _8d, _8e, _8f,
+    _90, _91, _92, _93, _94, _95, _96, _97, _98, _99, _9a, _9b, _9c, _9d, _9e, _9f,
+    _a0, _a1, _a2, _a3, _a4, _a5, _a6, _a7, _a8, _a9, _aa, _ab, _ac, _ad, _ae, _af,
+    _b0, _b1, _b2, _b3, _b4, _b5, _b6, _b7, _b8, _b9, _ba, _bb, _bc, _bd, _be, _bf,
+    _c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8, _c9, _ca, _cb, _cc, _cd, _ce, _cf,
+    _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7, _d8, _d9, _da, _db, _dc, _dd, _de, _df,
+    _e0, _e1, _e2, _e3, _e4, _e5, _e6, _e7, _e8, _e9, _ea, _eb, _ec, _ed, _ee, _ef,
+    _f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _fa, _fb, _fc, _fd, _fe, _ff,
+    // zig fmt: on
+};
+
+const Extern0 = extern struct { val: PackedStruct };
+const Extern1 = extern struct { val: PackedUnion };
+const Extern2 = extern struct { val: Enum };
+
+comptime {
+    _ = @as(Extern0, undefined);
+}
+comptime {
+    _ = @as(Extern1, undefined);
+}
+comptime {
+    _ = @as(Extern2, undefined);
+}
+
+// error
+//
+// :26:38: error: extern structs cannot contain fields of type 'tmp.PackedStruct'
+// :26:38: note: inferred backing integer of packed struct has unspecified signedness
+// :1:29: note: struct declared here
+// :27:38: error: extern structs cannot contain fields of type 'tmp.PackedUnion'
+// :27:38: note: inferred backing integer of packed union has unspecified signedness
+// :2:28: note: union declared here
+// :28:38: error: extern structs cannot contain fields of type 'tmp.Enum'
+// :5:14: note: integer tag type of enum is inferred
+// :5:14: note: consider explicitly specifying the integer tag type
+// :5:14: note: enum declared here
diff --git a/test/cases/compile_errors/packed_struct_uses_own_size.zig b/test/cases/compile_errors/packed_struct_uses_own_size.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d5a7613df01e43086ba47b73ff741ece4e0ab04
--- /dev/null
+++ b/test/cases/compile_errors/packed_struct_uses_own_size.zig
@@ -0,0 +1,10 @@
+const S = packed struct {
+    x: @Int(.unsigned, @sizeOf(S)),
+};
+comptime {
+    _ = @as(S, undefined);
+}
+
+// error
+//
+// :2:32: error: type 'tmp.S' depends on itself for size query here
diff --git a/test/cases/compile_errors/packed_struct_uses_own_typeinfo.zig b/test/cases/compile_errors/packed_struct_uses_own_typeinfo.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6a1fe41eb9463f994ae44f7e12c02cb5b57f230e
--- /dev/null
+++ b/test/cases/compile_errors/packed_struct_uses_own_typeinfo.zig
@@ -0,0 +1,13 @@
+const S = packed struct(u16) {
+    a: bool,
+    b: bool,
+    _padding: @Int(.unsigned, 17 - @typeInfo(S).Struct.fields.len) = 0,
+};
+
+comptime {
+    _ = @as(S, .{ .a = true, .b = true });
+}
+
+// error
+//
+// :4:36: error: type 'tmp.S' depends on itself for type information query here
diff --git a/test/cases/compile_errors/simple_struct_loop.zig b/test/cases/compile_errors/simple_struct_loop.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ae0b2ed82862430fcfaf2f301cae7c4eadc7d09
--- /dev/null
+++ b/test/cases/compile_errors/simple_struct_loop.zig
@@ -0,0 +1,16 @@
+const A = struct {
+    b: B,
+};
+const B = struct {
+    a: A,
+};
+comptime {
+    _ = @as(A, undefined);
+}
+
+// error
+//
+// error: dependency loop with length 2
+// :2:8: note: type 'tmp.A' depends on type 'tmp.B' for field declared here
+// :5:8: note: type 'tmp.B' depends on type 'tmp.A' for field declared here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/sizeOf_bad_type.zig b/test/cases/compile_errors/sizeOf_bad_type.zig
index 6d20251064f5be10e258283aaa6facb6451403c4..08ce7f4358f19781ba6fa007f5120978894c049b 100644
--- a/test/cases/compile_errors/sizeOf_bad_type.zig
+++ b/test/cases/compile_errors/sizeOf_bad_type.zig
@@ -15,6 +15,9 @@ const S4 = struct { a: u32, b: noreturn };
 export fn entry4() usize {
     return @sizeOf(S4);
 }
+export fn entry5() usize {
+    return @sizeOf([1]fn () void);
+}
 
 // error
 //
@@ -25,3 +28,4 @@ export fn entry4() usize {
 // :10:12: note: struct declared here
 // :16:20: error: no size available for uninstantiable type 'tmp.S4'
 // :14:12: note: struct declared here
+// :19:20: error: no size available for comptime-only type '[1]fn () void'
diff --git a/test/cases/compile_errors/struct_field_queries_hasfield_of_itself.zig b/test/cases/compile_errors/struct_field_queries_hasfield_of_itself.zig
new file mode 100644
index 0000000000000000000000000000000000000000..593b440149a93b4a1d0f2aec20ad1b58b6f2bdff
--- /dev/null
+++ b/test/cases/compile_errors/struct_field_queries_hasfield_of_itself.zig
@@ -0,0 +1,14 @@
+const Foo = packed struct {
+    bar: (T: {
+        _ = @hasField(Foo, "bar");
+        break :T void;
+    }),
+};
+
+comptime {
+    _ = @as(Foo, undefined);
+}
+
+// error
+//
+// :3:23: error: type 'tmp.Foo' depends on itself for field query here
diff --git a/test/cases/compile_errors/struct_uses_reified_type_which_queries_struct_alignment.zig b/test/cases/compile_errors/struct_uses_reified_type_which_queries_struct_alignment.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f3f7361de750573d0fc15298c42ae95c7c3873f0
--- /dev/null
+++ b/test/cases/compile_errors/struct_uses_reified_type_which_queries_struct_alignment.zig
@@ -0,0 +1,13 @@
+const A = struct { b: *B };
+const B = @Struct(.auto, null, &.{"x"}, &.{A}, &.{.{ .@"align" = @alignOf(A) }});
+comptime {
+    _ = @as(A, undefined);
+    _ = @as(B, undefined);
+}
+
+// error
+//
+// error: dependency loop with length 2
+// :1:24: note: type 'tmp.A' uses value of declaration 'tmp.B' here
+// :2:75: note: value of declaration 'tmp.B' depends on type 'tmp.A' for alignment query here
+// note: eliminate any one of these dependencies to break the loop
diff --git a/test/cases/compile_errors/struct_uses_sizeof_self_as_array_len.zig b/test/cases/compile_errors/struct_uses_sizeof_self_as_array_len.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a8e0183465c2f643d026231f7ad6b28f0879f345
--- /dev/null
+++ b/test/cases/compile_errors/struct_uses_sizeof_self_as_array_len.zig
@@ -0,0 +1,10 @@
+const S = struct {
+    a: *[@sizeOf(S)]u8,
+};
+comptime {
+    _ = @as(S, undefined);
+}
+
+// error
+//
+// :2:18: error: type 'tmp.S' depends on itself for size query here
-- 
2.54.0


From 57114044db85717bea7204f2693d6c8a62111635 Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sun, 8 Mar 2026 16:21:19 +0000
Subject: [PATCH 490/499] Revert "ci: disable incremental tests"

Since we don't know what causes the various flaky test-incremental
failures we've seen, and this branch changes a bunch of incremental
stuff, let's try turning these back on... maybe they'll magically work
now!

This reverts commit 953ca759c2446adc21648a9017b656ac84171291.
---
 ci/aarch64-freebsd-debug.sh     | 1 -
 ci/aarch64-freebsd-release.sh   | 1 -
 ci/aarch64-linux-debug.sh       | 1 -
 ci/aarch64-linux-release.sh     | 1 -
 ci/aarch64-macos-debug.sh       | 1 -
 ci/aarch64-macos-release.sh     | 1 -
 ci/aarch64-netbsd-debug.sh      | 1 -
 ci/aarch64-netbsd-release.sh    | 1 -
 ci/aarch64-windows.ps1          | 1 -
 ci/loongarch64-linux-debug.sh   | 1 -
 ci/loongarch64-linux-release.sh | 1 -
 ci/powerpc64le-linux-debug.sh   | 1 -
 ci/powerpc64le-linux-release.sh | 1 -
 ci/s390x-linux-debug.sh         | 1 -
 ci/s390x-linux-release.sh       | 1 -
 ci/x86_64-freebsd-debug.sh      | 1 -
 ci/x86_64-freebsd-release.sh    | 1 -
 ci/x86_64-linux-debug-llvm.sh   | 1 -
 ci/x86_64-linux-debug.sh        | 1 -
 ci/x86_64-linux-release.sh      | 1 -
 ci/x86_64-netbsd-debug.sh       | 1 -
 ci/x86_64-netbsd-release.sh     | 1 -
 ci/x86_64-openbsd-debug.sh      | 1 -
 ci/x86_64-openbsd-release.sh    | 1 -
 24 files changed, 24 deletions(-)

diff --git a/ci/aarch64-freebsd-debug.sh b/ci/aarch64-freebsd-debug.sh
index c296a50fd15388ae07286336b32bd0b9157849ec..87ffb3110223a6dfb7192833c0f3d7fd91f2c947 100755
--- a/ci/aarch64-freebsd-debug.sh
+++ b/ci/aarch64-freebsd-debug.sh
@@ -47,7 +47,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/aarch64-freebsd-release.sh b/ci/aarch64-freebsd-release.sh
index 1686327fb0b7da983d1f98fbd5d4188f01768d62..d5911241d6150e43e7273142c2882e956956fed2 100755
--- a/ci/aarch64-freebsd-release.sh
+++ b/ci/aarch64-freebsd-release.sh
@@ -47,7 +47,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/aarch64-linux-debug.sh b/ci/aarch64-linux-debug.sh
index 37a09b539845be9864c06f336eca482ab02983c9..7a4a6daa2aef60e1a9194184b1307f85992db3de 100755
--- a/ci/aarch64-linux-debug.sh
+++ b/ci/aarch64-linux-debug.sh
@@ -47,7 +47,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/aarch64-linux-release.sh b/ci/aarch64-linux-release.sh
index 8cde024ab11450376913d68816fd9d02a3a9c00e..39ad9767ab62264b19846ef8bc22e2d6ad23ed85 100755
--- a/ci/aarch64-linux-release.sh
+++ b/ci/aarch64-linux-release.sh
@@ -47,7 +47,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/aarch64-macos-debug.sh b/ci/aarch64-macos-debug.sh
index 369afc8d9e94a02ed77965bffc9692a5b5e344c4..7dc60c1f4ed13f8835538a2609955423ef8d551e 100755
--- a/ci/aarch64-macos-debug.sh
+++ b/ci/aarch64-macos-debug.sh
@@ -47,7 +47,6 @@ stage3-debug/bin/zig build test docs \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --test-timeout 2m
 
diff --git a/ci/aarch64-macos-release.sh b/ci/aarch64-macos-release.sh
index f7e6ae6fd3f4dba1970b94f6bc8e98305b2585be..00b6571f170a7fece1dcfb53755f9b271f438aae 100755
--- a/ci/aarch64-macos-release.sh
+++ b/ci/aarch64-macos-release.sh
@@ -46,7 +46,6 @@ stage3-release/bin/zig build test docs \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --test-timeout 2m
 
diff --git a/ci/aarch64-netbsd-debug.sh b/ci/aarch64-netbsd-debug.sh
index 5c87d14f47d15ab5bb82158ef0aa28c2dbafdb07..4f5eb0d41089778c97d4fe8e4eea70d1e88cea62 100755
--- a/ci/aarch64-netbsd-debug.sh
+++ b/ci/aarch64-netbsd-debug.sh
@@ -47,7 +47,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 4m
diff --git a/ci/aarch64-netbsd-release.sh b/ci/aarch64-netbsd-release.sh
index bf54c10efc835b51f87731bfd082132a7ec8fd19..d9d9477904cc721a9c40080e3d5470d129e0b8b0 100755
--- a/ci/aarch64-netbsd-release.sh
+++ b/ci/aarch64-netbsd-release.sh
@@ -47,7 +47,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 4m
diff --git a/ci/aarch64-windows.ps1 b/ci/aarch64-windows.ps1
index 57d77993519f230c2fc6e14de5a7e6957c51062a..96e07642565019c9a805ecc8c5ac29f461341df1 100644
--- a/ci/aarch64-windows.ps1
+++ b/ci/aarch64-windows.ps1
@@ -60,7 +60,6 @@ Write-Output "Main test suite..."
   --search-prefix "$PREFIX_PATH" `
   -Dstatic-llvm `
   -Dskip-non-native `
-  -Dskip-test-incremental `
   -Denable-symlinks-windows `
   --test-timeout 30m
 CheckLastExitCode
diff --git a/ci/loongarch64-linux-debug.sh b/ci/loongarch64-linux-debug.sh
index 2d966f37427b1408febbc92abd516cebca096047..4cba17b0319039daf2d132ece4908cfdf542cffa 100755
--- a/ci/loongarch64-linux-debug.sh
+++ b/ci/loongarch64-linux-debug.sh
@@ -48,7 +48,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/loongarch64-linux-release.sh b/ci/loongarch64-linux-release.sh
index 558177a8d99ea2c6885cb2ab0d405cecf4cb8ca5..5b05284d26668d01020f204f09d3a73921883ce5 100755
--- a/ci/loongarch64-linux-release.sh
+++ b/ci/loongarch64-linux-release.sh
@@ -48,7 +48,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/powerpc64le-linux-debug.sh b/ci/powerpc64le-linux-debug.sh
index 2875dcba955eeee80cda7eeadc38b3a0526f01be..1b9a51e44debff61729207ec1529e1d494b8c84b 100755
--- a/ci/powerpc64le-linux-debug.sh
+++ b/ci/powerpc64le-linux-debug.sh
@@ -48,7 +48,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   -Dcpu=native+longcall \
   --search-prefix "$PREFIX" \
diff --git a/ci/powerpc64le-linux-release.sh b/ci/powerpc64le-linux-release.sh
index fffcbe2bd2c8bc72f18f21db76b557df1f1b8798..77e1ca803ae27db49ed7a2b8fed48392f485c4d4 100755
--- a/ci/powerpc64le-linux-release.sh
+++ b/ci/powerpc64le-linux-release.sh
@@ -48,7 +48,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   -Dcpu=native+longcall \
   --search-prefix "$PREFIX" \
diff --git a/ci/s390x-linux-debug.sh b/ci/s390x-linux-debug.sh
index a76ed6f04df534ee6d124bc0848a0d8ce3b0669f..ffe4d0f02b3cada3b36e24fcc3572a1a14d5b389 100755
--- a/ci/s390x-linux-debug.sh
+++ b/ci/s390x-linux-debug.sh
@@ -48,7 +48,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/s390x-linux-release.sh b/ci/s390x-linux-release.sh
index 0a9b82620d5a9176a3542b5fd953054ee4f1feed..7fb6cd3641fa73752ca4f6eb1967f1a2de9dd8bf 100755
--- a/ci/s390x-linux-release.sh
+++ b/ci/s390x-linux-release.sh
@@ -48,7 +48,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-freebsd-debug.sh b/ci/x86_64-freebsd-debug.sh
index 8bf492540eadd7cc68db8d43d06a5c0296165ab3..a4d7034325b33dc92b9d8ba97442d4449ad6a4c5 100755
--- a/ci/x86_64-freebsd-debug.sh
+++ b/ci/x86_64-freebsd-debug.sh
@@ -53,7 +53,6 @@ stage3-debug/bin/zig build test docs \
   -Dskip-openbsd \
   -Dskip-windows \
   -Dskip-darwin \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-freebsd-release.sh b/ci/x86_64-freebsd-release.sh
index 44c4e76da2558d4fd399cee1452f4bc76ea8404d..0ce708c63d7715c4e6ad4e4e3927d4a100b9f65e 100755
--- a/ci/x86_64-freebsd-release.sh
+++ b/ci/x86_64-freebsd-release.sh
@@ -53,7 +53,6 @@ stage3-release/bin/zig build test docs \
   -Dskip-openbsd \
   -Dskip-windows \
   -Dskip-darwin \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-linux-debug-llvm.sh b/ci/x86_64-linux-debug-llvm.sh
index a37fc6c2a6214888856401ee0d7f1ba1939eb38b..96bb795e18e23d72eb8715951a1c9bfc9e28243d 100755
--- a/ci/x86_64-linux-debug-llvm.sh
+++ b/ci/x86_64-linux-debug-llvm.sh
@@ -64,7 +64,6 @@ stage3-debug/bin/zig build test docs \
   -Dskip-openbsd \
   -Dskip-windows \
   -Dskip-darwin \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index 60203bdcd0c4a66929be7b4d55bdfe416744a20b..aeaf5b8678badc181f79fdc76597edf1fa8ed203 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -63,7 +63,6 @@ stage3-debug/bin/zig build test docs \
   -Dskip-windows \
   -Dskip-darwin \
   -Dskip-llvm \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 0317ad55fc4b795de5e5671d987880a610c577c8..b1f6b84dcd10681631d1ad5fde7e36356d042ac4 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -65,7 +65,6 @@ stage3-release/bin/zig build test docs \
   --libc-runtimes $HOME/deps/glibc-2.43-musl-1.2.5 \
   -fwasmtime \
   -Dstatic-llvm \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
diff --git a/ci/x86_64-netbsd-debug.sh b/ci/x86_64-netbsd-debug.sh
index 416ab6a5e0168464e4295d1dc54c5e2c19ac4366..68e9081f3ba040c83e4116b194ba17a46692798e 100755
--- a/ci/x86_64-netbsd-debug.sh
+++ b/ci/x86_64-netbsd-debug.sh
@@ -47,7 +47,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-netbsd-release.sh b/ci/x86_64-netbsd-release.sh
index d8c54ca28d095b3a7e65a53fab1f572162fc4ea5..225a527686ac06cc1da2241f0fb624956f2d5a58 100755
--- a/ci/x86_64-netbsd-release.sh
+++ b/ci/x86_64-netbsd-release.sh
@@ -47,7 +47,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-openbsd-debug.sh b/ci/x86_64-openbsd-debug.sh
index 58363e52d3b9339395b4270f35f9e6b9427d7df1..133c8dd4d642a9d4a019d297a3648567231d6078 100755
--- a/ci/x86_64-openbsd-debug.sh
+++ b/ci/x86_64-openbsd-debug.sh
@@ -47,7 +47,6 @@ stage3-debug/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
diff --git a/ci/x86_64-openbsd-release.sh b/ci/x86_64-openbsd-release.sh
index ebdaac1ee0c4e0c092929534517096bd5051a450..535b1a147166a1b724dd39358db56f18f17e09cd 100755
--- a/ci/x86_64-openbsd-release.sh
+++ b/ci/x86_64-openbsd-release.sh
@@ -47,7 +47,6 @@ stage3-release/bin/zig build test docs \
   --maxrss ${ZSF_MAX_RSS:-0} \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
   --test-timeout 2m
-- 
2.54.0


From 79e7b719a362959fd172bbe7f7d9abe3e2f6f0cc Mon Sep 17 00:00:00 2001
From: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Mon, 9 Mar 2026 12:02:58 +0000
Subject: [PATCH 491/499] bootstrap: disable strict aliasing

The C backend has always gleefully violated C's strict aliasing rules,
and I just got bitten by it for the first time when bootstrapping on
macOS. This probably hasn't been helping with some of the weird
bootstrap-related CI failures we've seen. So, update `bootstrap.c` and
`CMakeLists.txt` to tell GCC/Clang to disable type-based alias analysis.

No change is needed to the MSVC flags because MSVC does not, and never
has, implemented TBAA.
---
 CMakeLists.txt | 4 ++--
 bootstrap.c    | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 146e507930706d8d779ce6a3977b39d7f9d9b78c..af1f64bd83e317f91670a19b3a95113639f59193 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -608,8 +608,8 @@ if(MSVC)
   set(ZIG2_LINK_FLAGS "/STACK:16777216 /FORCE:MULTIPLE")
 else()
   set(ZIG_WASM2C_COMPILE_FLAGS "-std=c99 -O2")
-  set(ZIG1_COMPILE_FLAGS "-std=c99 -Os")
-  set(ZIG2_COMPILE_FLAGS "-std=c99 -O0 -fno-sanitize=undefined -fno-stack-protector")
+  set(ZIG1_COMPILE_FLAGS "-std=c99 -Os -fno-strict-aliasing")
+  set(ZIG2_COMPILE_FLAGS "-std=c99 -O0 -fno-sanitize=undefined -fno-stack-protector -fno-strict-aliasing")
   # Must match the condition in build.zig.
   if(ZIG_HOST_TARGET_ARCH MATCHES "^(arm|thumb)(eb)?$" OR ZIG_HOST_TARGET_ARCH MATCHES "^powerpc(64)?(le)?$")
     set(ZIG1_COMPILE_FLAGS "${ZIG1_COMPILE_FLAGS} -ffunction-sections -fdata-sections")
diff --git a/bootstrap.c b/bootstrap.c
index 329a1af10e5d9c4c61d5dc851587c1d80c0e0aa5..ad4ccec54a67fd3b94f880d0669be25303afd14f 100644
--- a/bootstrap.c
+++ b/bootstrap.c
@@ -136,7 +136,7 @@ int main(int argc, char **argv) {
     }
     {
         const char *child_argv[] = {
-            cc, "-o", "zig1", "zig1.c", "stage1/wasi.c", "-std=c99", "-Os", "-lm", NULL,
+            cc, "-o", "zig1", "zig1.c", "stage1/wasi.c", "-std=c99", "-Os", "-fno-strict-aliasing", "-lm", NULL,
         };
         print_and_run(child_argv);
     }
@@ -213,6 +213,7 @@ int main(int argc, char **argv) {
 #if defined(__GNUC__)
             "-pthread",
 #endif
+            "-fno-strict-aliasing",
             workaround_gcc_sra_miscomp ? "-fno-tree-sra" : NULL,
             NULL,
         };
-- 
2.54.0


From 502cab9ae30b001a8da2f724711330a73e7e2e4f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Mon, 9 Mar 2026 22:41:21 +0100
Subject: [PATCH 492/499] test_runner: actually print the error that caused a
 runner failure

part of the Stop Throwing Away Useful Information initiative
---
 lib/compiler/test_runner.zig | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig
index 899b5dafbfb7fa2683854b81ff198eb2a7be4573..db8958519a4d44ef96cd006980146276b93d29cf 100644
--- a/lib/compiler/test_runner.zig
+++ b/lib/compiler/test_runner.zig
@@ -38,10 +38,10 @@ pub fn main(init: std.process.Init.Minimal) void {
     }
 
     if (need_simple) {
-        return mainSimple() catch @panic("test failure");
+        return mainSimple() catch |err| std.debug.panic("test failure: {t}", .{err});
     }
 
-    const args = init.args.toSlice(fba.allocator()) catch @panic("unable to parse command line args");
+    const args = init.args.toSlice(fba.allocator()) catch |err| std.debug.panic("unable to parse command line args: {t}", .{err});
 
     var listen = false;
     var opt_cache_dir: ?[]const u8 = null;
@@ -55,7 +55,7 @@ pub fn main(init: std.process.Init.Minimal) void {
         } else if (std.mem.startsWith(u8, arg, "--cache-dir")) {
             opt_cache_dir = arg["--cache-dir=".len..];
         } else {
-            @panic("unrecognized command line argument");
+            std.debug.panic("unrecognized command line argument: {s}", .{arg});
         }
     }
 
@@ -65,7 +65,7 @@ pub fn main(init: std.process.Init.Minimal) void {
     }
 
     if (listen) {
-        return mainServer(init) catch @panic("internal test runner failure");
+        return mainServer(init) catch |err| std.debug.panic("internal test runner failure: {t}", .{err});
     } else {
         return mainTerminal(init);
     }
-- 
2.54.0


From d70bd0b37eafb82e3020f163ebcbaa2c13791e75 Mon Sep 17 00:00:00 2001
From: GasInfinity <me@gasinfinity.dev>
Date: Tue, 10 Mar 2026 19:46:56 +0100
Subject: [PATCH 493/499] fix: use `cmpxchgStrong` in `std.atomic.Mutex`

* same reason as 048e38624e1b7c1ad140e253f1e5e7c868658089
---
 lib/std/atomic.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/atomic.zig b/lib/std/atomic.zig
index 0040dbf735eeaabad5c5d532663757bfb5de5491..89f22a89ccc72b1a962a5f781a7c9692b6174a6c 100644
--- a/lib/std/atomic.zig
+++ b/lib/std/atomic.zig
@@ -509,7 +509,7 @@ pub const Mutex = enum(u8) {
     locked,
 
     pub fn tryLock(m: *Mutex) bool {
-        return @cmpxchgWeak(Mutex, m, .unlocked, .locked, .acquire, .monotonic) == null;
+        return @cmpxchgStrong(Mutex, m, .unlocked, .locked, .acquire, .monotonic) == null;
     }
 
     pub fn unlock(m: *Mutex) void {
-- 
2.54.0


From 6015192fb62f4dac430a23227df21ab6368e8e07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Tue, 10 Mar 2026 23:36:22 +0100
Subject: [PATCH 494/499] test-libc: disable pthread_cond_wait-cancel_ignored.c

It's flaky under heavy load: https://codeberg.org/ziglang/zig/actions/runs/2208/jobs/20/attempt/1
---
 test/libc.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/libc.zig b/test/libc.zig
index f2c34af560947dae39d56ea5f184c8ceeadb5903..2e499d4b2d7d06bd3b7b2457398f493b2187d488 100644
--- a/test/libc.zig
+++ b/test/libc.zig
@@ -105,7 +105,7 @@ pub fn addCases(cases: *tests.LibcContext) void {
     cases.addLibcTestCase("regression/pthread_atfork-errno-clobber.c", false, .{});
     cases.addLibcTestCase("regression/pthread_cancel-sem_wait.c", false, .{});
     cases.addLibcTestCase("regression/pthread_cond-smasher.c", false, .{});
-    cases.addLibcTestCase("regression/pthread_cond_wait-cancel_ignored.c", false, .{});
+    // Flaky under heavy load: cases.addLibcTestCase("regression/pthread_cond_wait-cancel_ignored.c", false, .{});
     cases.addLibcTestCase("regression/pthread_condattr_setclock.c", false, .{});
     // "regression/pthread_create-oom.c": QEMU OOM
     cases.addLibcTestCase("regression/pthread_exit-cancel.c", false, .{});
-- 
2.54.0


From bd5dc75068dcfb3dcd6b8197ee5d941cacb15cb9 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Tue, 10 Mar 2026 14:17:40 -0700
Subject: [PATCH 495/499] std: remove GeneralPurposeAllocator alias

---
 doc/langref.html.in                        | 2 +-
 lib/compiler/aro/main.zig                  | 2 +-
 lib/std/hash/benchmark.zig                 | 2 +-
 lib/std/heap.zig                           | 6 +-----
 lib/std/testing.zig                        | 4 ++--
 test/standalone/child_process/main.zig     | 2 +-
 tools/generate_c_size_and_align_checks.zig | 2 +-
 7 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 643c948b68e99e11236f9c24e180af848736a820..85ec580b4dfc039facf494eb7fa460baf1edad6e 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -6368,7 +6368,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       </p>
       <p>
       Zig has a general purpose allocator available to be imported
-      with {#syntax#}std.heap.GeneralPurposeAllocator{#endsyntax#}. However, it is still recommended to
+      with {#syntax#}std.heap.DebugAllocator{#endsyntax#}. However, it is still recommended to
       follow the {#link|Choosing an Allocator#} guide.
       </p>
 
diff --git a/lib/compiler/aro/main.zig b/lib/compiler/aro/main.zig
index dcc07eaca64c9c69ce67ef7121128c026e4c3cda..eafddba8778f78d9d0165594547cd04c4087219c 100644
--- a/lib/compiler/aro/main.zig
+++ b/lib/compiler/aro/main.zig
@@ -13,7 +13,7 @@ const assembly_backend = @import("assembly_backend");
 var debug_allocator: std.heap.DebugAllocator(.{
     .stack_trace_frames = 0,
     // A unique value so that when a default-constructed
-    // GeneralPurposeAllocator is incorrectly passed to testing allocator, or
+    // DebugAllocator is incorrectly passed to testing allocator, or
     // vice versa, panic occurs.
     .canary = @truncate(0xc647026dc6875134),
 }) = .{};
diff --git a/lib/std/hash/benchmark.zig b/lib/std/hash/benchmark.zig
index 3e48351137abf57a35d9581bc5b6a820d3c5bec1..4b900a94a141a2ca24200181bdd4811b98538b3b 100644
--- a/lib/std/hash/benchmark.zig
+++ b/lib/std/hash/benchmark.zig
@@ -440,7 +440,7 @@ pub fn main(init: std.process.Init) !void {
         std.process.exit(1);
     }
 
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
+    var gpa: std.heap.DebugAllocator(.{}) = .init;
     defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak");
     const allocator = gpa.allocator();
 
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index cc8693f650c2d703542788971c132efed020d230..854a6e61335dfb6cec9a7f3cacaa97d6af00b6f5 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -19,10 +19,6 @@ pub const BrkAllocator = @import("heap/BrkAllocator.zig");
 pub const DebugAllocatorConfig = @import("heap/debug_allocator.zig").Config;
 pub const DebugAllocator = @import("heap/debug_allocator.zig").DebugAllocator;
 pub const Check = enum { ok, leak };
-/// Deprecated; to be removed after 0.14.0 is tagged.
-pub const GeneralPurposeAllocatorConfig = DebugAllocatorConfig;
-/// Deprecated; to be removed after 0.14.0 is tagged.
-pub const GeneralPurposeAllocator = DebugAllocator;
 
 /// A memory pool that can allocate objects of a single type very quickly.
 /// Use this when you need to allocate a lot of objects of the same type,
@@ -1006,7 +1002,7 @@ const page_size_max_default: ?usize = switch (builtin.os.tag) {
 test {
     _ = @import("heap/memory_pool.zig");
     _ = ArenaAllocator;
-    _ = GeneralPurposeAllocator;
+    _ = DebugAllocator(.{});
     _ = FixedBufferAllocator;
     if (builtin.single_threaded) {
         if (builtin.cpu.arch.isWasm() or (builtin.os.tag == .linux and !builtin.link_libc)) {
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index bfb50039ea2272242ec911d739b00830bbc4360f..29e1fc8d61a7b4809f00ef1af9527d6da659a594 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -19,11 +19,11 @@ var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
 
 /// This should only be used in temporary test programs.
 pub const allocator = allocator_instance.allocator();
-pub var allocator_instance: std.heap.GeneralPurposeAllocator(.{
+pub var allocator_instance: std.heap.DebugAllocator(.{
     .stack_trace_frames = if (std.debug.sys_can_stack_trace) 10 else 0,
     .resize_stack_traces = true,
     // A unique value so that when a default-constructed
-    // GeneralPurposeAllocator is incorrectly passed to testing allocator, or
+    // DebugAllocator is incorrectly passed to testing allocator, or
     // vice versa, panic occurs.
     .canary = @truncate(0x2731e675c3a701ba),
 }) = b: {
diff --git a/test/standalone/child_process/main.zig b/test/standalone/child_process/main.zig
index d252ee414d48a546654c939a411bddf99788f57c..c772d1b8215f891ac2c47d7a8212c47eb3273d80 100644
--- a/test/standalone/child_process/main.zig
+++ b/test/standalone/child_process/main.zig
@@ -3,7 +3,7 @@ const Io = std.Io;
 
 pub fn main(init: std.process.Init.Minimal) !void {
     // make sure safety checks are enabled even in release modes
-    var gpa_state: std.heap.GeneralPurposeAllocator(.{ .safety = true }) = .{};
+    var gpa_state: std.heap.DebugAllocator(.{ .safety = true }) = .{};
     defer if (gpa_state.deinit() != .ok) {
         @panic("found memory leaks");
     };
diff --git a/tools/generate_c_size_and_align_checks.zig b/tools/generate_c_size_and_align_checks.zig
index 6041a550da6f3ac04cf366cf9d1913c3cbbed5da..7f562dcac4d46bf1abca7e016d82587d10739129 100644
--- a/tools/generate_c_size_and_align_checks.zig
+++ b/tools/generate_c_size_and_align_checks.zig
@@ -26,7 +26,7 @@ fn cName(ty: std.Target.CType) []const u8 {
     };
 }
 
-var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
+var general_purpose_allocator: std.heap.DebugAllocator(.{}) = .init;
 
 pub fn main(init: std.process.Init) !void {
     const args = try init.minimal.args.toSlice(init.arena.allocator());
-- 
2.54.0


From 6e5a95bd7c1f6b6bb659908fc7ba70cb5fd1b42c Mon Sep 17 00:00:00 2001
From: Kendall Condon <goon.pri.low@gmail.com>
Date: Fri, 6 Mar 2026 19:10:47 -0500
Subject: [PATCH 496/499] implement proper deflate flush semantics

To end a flate stream, `finish` must now be called. `flush` now follows
regular semantics and byte-aligns the stream.

Byte-aligning the stream is done with empty fixed or store blocks. To
implement flush, a variable history length was added and it is tracked
if the final bytes of history have been hashed yet.
---
 lib/std/compress/flate/Compress.zig | 319 ++++++++++++++++++----------
 src/Package/Fetch.zig               |   2 +-
 2 files changed, 210 insertions(+), 111 deletions(-)

diff --git a/lib/std/compress/flate/Compress.zig b/lib/std/compress/flate/Compress.zig
index 9f470706068b66244c0a406d5e8355450179dd1d..1f39580372aa873dda57d8719fa8c547ce04adf2 100644
--- a/lib/std/compress/flate/Compress.zig
+++ b/lib/std/compress/flate/Compress.zig
@@ -2,7 +2,8 @@
 //!
 //! The source of an `error.WriteFailed` is always the backing writer. After an
 //! `error.WriteFailed`, the `.writer` becomes `.failing` and is unrecoverable.
-//! After a `flush`, the writer also becomes `.failing` since the stream has
+//!
+//! After `finish`, the writer also becomes `.failing` since the stream has
 //! been finished. This behavior also applies to `Raw` and `Huffman`.
 
 // Implementation details:
@@ -43,9 +44,10 @@ const PackedOptionalU15 = packed struct(u16) {
     pub const null_bit: PackedOptionalU15 = .{ .value = 0, .is_null = true };
 };
 
-/// After `flush` is called, all vtable calls with result in `error.WriteFailed.`
+/// After `finish` is called, all vtable calls with result in `error.WriteFailed`.
 writer: Writer,
-has_history: bool,
+history_len: u16,
+history_end_unhashed: bool,
 bit_writer: BitWriter,
 buffered_tokens: struct {
     /// List of `TokenBufferEntryHeader`s and their trailing data.
@@ -108,7 +110,7 @@ const BitWriter = struct {
         b.buffered = @intCast(combined >> (combined_bits - b.buffered_n));
     }
 
-    /// Assserts one byte can be written to `b.otuput` without rebasing.
+    /// Asserts one byte can be written to `b.output` without rebasing.
     pub fn byteAlign(b: *BitWriter) void {
         b.output.unusedCapacitySlice()[0] = b.buffered;
         b.output.advance(@intFromBool(b.buffered_n != 0));
@@ -116,6 +118,35 @@ const BitWriter = struct {
         b.buffered_n = 0;
     }
 
+    /// Byte align using only empty flate blocks
+    pub fn byteAlignBlocks(b: *BitWriter) Writer.Error!void {
+        if (b.buffered_n == 0) return;
+
+        // There are two methods to do this:
+        // 1. A store block (5 or 6 bytes)
+        // 2. Outputting empty 10-bit fixed blocks until aligned
+        //
+        // Fixed blocks advance the bit alignment by two, and so can only used for even numbers
+        // requiring a maximum of four bytes (three blocks = 30 bits) to which is always more
+        // efficient than store blocks.
+        if (b.buffered_n & 1 == 0) {
+            const splat = (8 - @as(u5, b.buffered_n)) >> 1;
+            const bits = splat * 10;
+            // fixed eos code is 0, so the only bits are for the block header
+            const pattern: u32 = BlockHeader.int(.{ .kind = .fixed, .final = false });
+            const splatted = ((pattern << 20) | (pattern << 10) | pattern) >> (30 - bits);
+            try b.write(splatted, bits);
+        } else {
+            try b.write(BlockHeader.int(.{ .kind = .stored, .final = false }), 3);
+            try b.output.rebase(0, 5);
+            b.byteAlign();
+            b.output.writeInt(u16, 0x0000, .little) catch unreachable;
+            b.output.writeInt(u16, 0xffff, .little) catch unreachable;
+        }
+
+        assert(b.buffered_n == 0);
+    }
+
     pub fn writeClen(
         b: *BitWriter,
         hclen: u4,
@@ -159,9 +190,9 @@ const BitWriter = struct {
 /// The maximum value is `math.maxInt(u16) - 1` since one token is reserved for end-of-block.
 const block_tokens: u16 = 1 << 15;
 const lookup_hash_bits = 15;
-const Hash = u16; // `u[lookup_hash_bits]` is not used due to worse optimization (with LLVM 21)
+const Hash = u16; // `@Int(.unsigned, lookup_hash_bits)` is not used due to worse optimization (with LLVM 21)
 const seq_bytes = 3; // not intended to be changed
-const Seq = std.meta.Int(.unsigned, seq_bytes * 8);
+const Seq = @Int(.unsigned, seq_bytes * 8);
 
 const TokenBufferEntryHeader = packed struct(u16) {
     kind: enum(u1) {
@@ -295,7 +326,8 @@ pub fn init(
                 .rebase = rebase,
             },
         },
-        .has_history = false,
+        .history_len = 0,
+        .history_end_unhashed = false,
         .bit_writer = .init(output),
         .buffered_tokens = .empty,
         .lookup = .{
@@ -314,68 +346,110 @@ fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize
     errdefer w.* = .failing;
     // There may have not been enough space in the buffer and the write was sent directly here.
     // However, it is required that all data goes through the buffer to keep a history.
-    //
-    // Additionally, ensuring the buffer is always full ensures there is always a full history
-    // after.
     const data_n = w.buffer.len - w.end;
     _ = w.fixedDrain(data, splat) catch {};
     assert(w.end == w.buffer.len);
-    try rebaseInner(w, 0, 1, false);
+    try rebaseInner(w, 0, 1, false, false);
     return data_n;
 }
 
 fn flush(w: *Writer) Writer.Error!void {
-    defer w.* = .failing;
+    errdefer w.* = .failing;
+    try rebaseInner(w, 0, w.buffer.len - flate.history_len, true, false);
     const c: *Compress = @fieldParentPtr("writer", w);
-    try rebaseInner(w, 0, w.buffer.len - flate.history_len, true);
+    try c.bit_writer.byteAlignBlocks();
+}
+
+pub fn finish(c: *Compress) Writer.Error!void {
+    defer c.writer = .failing;
+    try rebaseInner(&c.writer, 0, c.writer.buffer.len - flate.history_len, true, true);
     try c.bit_writer.output.rebase(0, 1);
     c.bit_writer.byteAlign();
     try c.hasher.writeFooter(c.bit_writer.output);
 }
 
 fn rebase(w: *Writer, preserve: usize, capacity: usize) Writer.Error!void {
-    return rebaseInner(w, preserve, capacity, false);
+    errdefer w.* = .failing;
+    return rebaseInner(w, preserve, capacity, false, false);
 }
 
 pub const rebase_min_preserve = flate.history_len;
 pub const rebase_reserved_capacity = (token.max_length + 1) + seq_bytes;
 
-fn rebaseInner(w: *Writer, preserve: usize, capacity: usize, eos: bool) Writer.Error!void {
-    if (!eos) {
+fn rebaseInner(
+    w: *Writer,
+    preserve: usize,
+    capacity: usize,
+    is_flush: bool,
+    is_finish: bool,
+) Writer.Error!void {
+    if (!is_flush) {
         assert(@max(preserve, rebase_min_preserve) + (capacity + rebase_reserved_capacity) <= w.buffer.len);
-        assert(w.end >= flate.history_len + rebase_reserved_capacity); // Above assert should
-        // fail since rebase is only called when `capacity` is not present. This assertion is
-        // important because a full history is required at the end.
     } else {
+        // Preverse is not considered for `matching_end`
         assert(preserve == 0 and capacity == w.buffer.len - flate.history_len);
     }
+    if (is_finish) assert(is_flush);
 
     const c: *Compress = @fieldParentPtr("writer", w);
     const buffered = w.buffered();
 
-    const start = @as(usize, flate.history_len) * @intFromBool(c.has_history);
-    const lit_end: usize = if (!eos)
+    const start: usize = c.history_len;
+    const hashable_len = buffered.len -| (seq_bytes - 1);
+    const matching_end: usize = if (!is_flush)
         buffered.len - rebase_reserved_capacity - (preserve -| flate.history_len)
     else
-        buffered.len -| (seq_bytes - 1);
+        hashable_len;
 
     var i = start;
     var last_unmatched = i;
-    // Read from `w.buffer` instead of `buffered` since the latter may not
-    // have enough bytes. If this is the case, this variable is not used.
-    var seq: Seq = mem.readInt(
-        std.meta.Int(.unsigned, (seq_bytes - 1) * 8),
-        w.buffer[i..][0 .. seq_bytes - 1],
-        .big,
-    );
-    if (buffered[i..].len < seq_bytes - 1) {
-        @branchHint(.unlikely);
-        assert(eos);
-        seq = undefined;
-        assert(i >= lit_end);
-    }
-
-    while (i < lit_end) {
+    var seq: Seq = start_seq: {
+        if (c.history_end_unhashed) {
+            @branchHint(.unlikely);
+
+            assert(i != 0);
+            i -|= seq_bytes - 1;
+            var seq: Seq = mem.readInt(
+                @Int(.unsigned, (seq_bytes - 1) * 8),
+                w.buffer[i..][0 .. seq_bytes - 1],
+                .big,
+            );
+
+            while (i < @min(start, hashable_len)) {
+                seq <<= 8;
+                seq |= buffered[i + (seq_bytes - 1)];
+                c.addHash(i, hash(seq));
+                i += 1;
+            }
+
+            if (i < start) {
+                @branchHint(.unlikely);
+                i = start;
+                assert(i >= hashable_len);
+                assert(i >= matching_end);
+                assert(is_flush);
+                break :start_seq undefined; // Unused
+            }
+
+            c.history_end_unhashed = false;
+            break :start_seq seq;
+        }
+
+        if (i >= hashable_len) {
+            @branchHint(.unlikely);
+            assert(i >= matching_end);
+            assert(is_flush);
+            break :start_seq undefined; // Unused
+        }
+
+        break :start_seq mem.readInt(
+            @Int(.unsigned, (seq_bytes - 1) * 8),
+            buffered[i..][0 .. seq_bytes - 1],
+            .big,
+        );
+    };
+
+    while (i < matching_end) {
         var match_start = i;
         seq <<= 8;
         seq |= buffered[i + (seq_bytes - 1)];
@@ -420,43 +494,50 @@ fn rebaseInner(w: *Writer, preserve: usize, capacity: usize, eos: bool) Writer.E
 
         try c.outputBytes(buffered[last_unmatched..match_start]);
         try c.outputMatch(@intCast(match.dist), @intCast(match.len - 3));
-
         last_unmatched = match_start + match.len;
-        if (last_unmatched + seq_bytes >= w.end) {
-            @branchHint(.unlikely);
-            assert(eos);
-            i = undefined;
-            break;
-        }
 
-        while (true) {
+        while (i < hashable_len) {
             seq <<= 8;
             seq |= buffered[i + (seq_bytes - 1)];
-            _ = c.addHash(i, hash(seq));
+            c.addHash(i, hash(seq));
             i += 1;
 
             match_unadded -= 1;
             if (match_unadded == 0) break;
+        } else {
+            @branchHint(.unlikely);
+            assert(is_flush);
+            // `c.history_end_unhashed` is set down below
+            break;
         }
         assert(i == match_start + match.len);
     }
 
-    if (eos) {
-        i = undefined; // (from match hashing logic)
+    if (is_flush) {
         try c.outputBytes(buffered[last_unmatched..]);
         c.hasher.update(buffered[start..]);
-        try c.writeBlock(true);
-        return;
+
+        if (is_finish) {
+            try c.writeBlock(true);
+            return; // Other state does not need updated since the writer transitions to `.failing`
+        }
+
+        i = buffered.len;
+        c.history_end_unhashed = i != 0;
+
+        if (c.buffered_tokens.n != 0) {
+            try c.writeBlock(false);
+        }
+    } else {
+        try c.outputBytes(buffered[last_unmatched..i]);
+        c.hasher.update(buffered[start..i]);
     }
 
-    try c.outputBytes(buffered[last_unmatched..i]);
-    c.hasher.update(buffered[start..i]);
-
-    const preserved = buffered[i - flate.history_len ..];
-    assert(preserved.len > @max(rebase_min_preserve, preserve));
+    c.history_len = @min(i, flate.history_len);
+    const preserved = buffered[i - c.history_len ..];
+    if (!is_flush) assert(preserved.len >= @max(rebase_min_preserve, preserve));
     @memmove(w.buffer[0..preserved.len], preserved);
     w.end = preserved.len;
-    c.has_history = true;
 }
 
 fn addHash(c: *Compress, i: usize, h: Hash) void {
@@ -499,7 +580,7 @@ fn betterMatchLen(old: u16, prev: []const u8, bytes: []const u8) u16 {
     assert(bytes.len >= token.min_length);
 
     var i: u16 = 0;
-    const Block = std.meta.Int(.unsigned, @min(math.divCeil(
+    const Block = @Int(.unsigned, @min(math.divCeil(
         comptime_int,
         math.ceilPowerOfTwoAssert(usize, @bitSizeOf(usize)),
         8,
@@ -798,7 +879,6 @@ test buildClen {
 
 fn writeBlock(c: *Compress, eos: bool) Writer.Error!void {
     const toks = &c.buffered_tokens;
-    if (!eos) assert(toks.n == block_tokens);
     assert(toks.lit_freqs[256] == 0);
     toks.lit_freqs[256] = 1;
 
@@ -1438,20 +1518,8 @@ fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith
         .chain = chain,
     });
 
-    // It is ensured that more bytes are not written then this to ensure this run
-    // does not take too long and that `flate_buf` does not run out of space.
-    const flate_buf_blocks = flate_buf.len / block_tokens;
-    // Allow a max overhead of 64 bytes per block since the implementation does not gaurauntee it
-    // writes store blocks when optimal. This comes from taking less than 32 bytes to write an
-    // optimal dynamic block header of mostly bitlen 8 codes and the end of block literal plus
-    // `(65536 / 256) / 8`, which is is the maximum number of extra bytes from bitlen 9 codes. An
-    // extra 32 bytes is reserved on top of that for container headers and footers.
-    const max_size = flate_buf.len - (flate_buf_blocks * 64 + 32);
-
+    var max_output: usize = 32; // Headers / footer
     while (!smith.eosWeightedSimple(7, 1)) {
-        const max_bytes = max_size -| expected_size;
-        if (max_bytes == 0) break;
-
         const buffered = deflate_w.writer.buffered();
         // Required for repeating patterns and since writing from `buffered` is illegal
         var copy_buf: [512]u8 = undefined;
@@ -1459,13 +1527,13 @@ fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith
         const bytes = bytes: switch (smith.valueRangeAtMost(
             u2,
             @intFromBool(buffered.len == 0),
-            2,
+            3,
         )) {
             0 => { // Copy
                 const start = smith.valueRangeLessThan(u32, 0, @intCast(buffered.len));
                 // Reuse the implementation's history; otherwise, our own would need maintained.
                 const from = buffered[start..];
-                const len = smith.valueRangeAtMost(u16, 1, @min(copy_buf.len, max_bytes));
+                const len = smith.valueRangeAtMost(u16, 1, copy_buf.len);
 
                 const history_bytes = from[0..@min(from.len, len)];
                 @memcpy(copy_buf[0..history_bytes.len], history_bytes);
@@ -1485,7 +1553,7 @@ fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith
                         .value(FreqBufIndex, .random, 1),
                     })
                 ];
-                const len = smith.valueRangeAtMost(u32, 1, @min(fbuf.len, max_bytes));
+                const len = smith.valueRangeAtMost(u32, 1, fbuf.len);
                 const off = smith.valueRangeAtMost(u32, 0, @intCast(fbuf.len - len));
                 break :bytes fbuf[off..][0..len];
             },
@@ -1493,25 +1561,42 @@ fn testFuzzedCompressInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith
                 const rebaseable = bufsize - rebase_reserved_capacity;
                 const capacity = smith.valueRangeAtMost(u32, 1, rebaseable - rebase_min_preserve);
                 const preserve = smith.valueRangeAtMost(u32, 0, rebaseable - capacity);
-                try deflate_w.writer.rebase(preserve, capacity);
+                const failed = deflate_w.writer.rebase(preserve, capacity);
+                if (flate_w.buffered().len > max_output) return error.OverheadTooLarge;
+                failed catch return; // Wrote too much data and ran out of space
+                continue;
+            },
+            3 => { // Flush
+                max_output += 8; // Alignment data
+                const failed = deflate_w.writer.flush();
+                if (flate_w.buffered().len > max_output) return error.OverheadTooLarge;
+                failed catch return; // Wrote too much data and ran out of space
                 continue;
             },
-            else => unreachable,
         };
 
-        assert(bytes.len <= max_bytes);
-        try deflate_w.writer.writeAll(bytes);
+        // An overhead of 64 bytes is given for each block since the implementation does not
+        // gaurauntee it writes store blocks when optimal. This comes from taking less than 32
+        // bytes to write an optimal dynamic block header of mostly bitlen 8 codes and the end
+        // of block literal plus `(65536 / 256) / 8`, which is is the maximum number of extra
+        // bytes from bitlen 9 codes.
+        max_output += bytes.len + ((bytes.len + flate_buf.len - 1) / block_tokens) * 64;
+        const failed = deflate_w.writer.writeAll(bytes);
+        if (flate_w.buffered().len > max_output) return error.OverheadTooLarge;
+        failed catch return; // Wrote too much data and ran out of space
         expected_hash.update(bytes);
         expected_size += @intCast(bytes.len);
     }
 
-    try deflate_w.writer.flush();
+    const failed = deflate_w.finish();
+    if (flate_w.buffered().len > max_output) return error.OverheadTooLarge;
+    failed catch return; // Wrote too much data and ran out of space
     try testingCheckDecompressedMatches(flate_w.buffered(), expected_size, expected_hash);
 }
 
 /// Does not compress data
 pub const Raw = struct {
-    /// After `flush` is called, all vtable calls with result in `error.WriteFailed.`
+    /// After `finish` is called, all vtable calls with result in `error.WriteFailed`.
     writer: Writer,
     output: *Writer,
     hasher: flate.Container.Hasher,
@@ -1654,8 +1739,12 @@ pub const Raw = struct {
     }
 
     fn flush(w: *Writer) Writer.Error!void {
-        defer w.* = .failing;
-        try Raw.rebaseInner(w, 0, w.buffer.len, true);
+        errdefer w.* = .failing;
+        try Raw.rebaseInner(w, 0, w.buffer.len, false);
+    }
+
+    fn finish(r: *Raw) Writer.Error!void {
+        try Raw.rebaseInner(&r.writer, 0, r.writer.buffer.len, true);
     }
 
     fn rebase(w: *Writer, preserve: usize, capacity: usize) Writer.Error!void {
@@ -1899,19 +1988,21 @@ fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, smith: *std.testing.Smith)
         const Op = packed struct {
             drain: bool = false,
             add_vec: bool = false,
-            rebase: bool = false,
+            rebase: enum(u2) { none, rebase, flush } = .none,
 
             pub const drain_only: @This() = .{ .drain = true };
             pub const add_vec_only: @This() = .{ .add_vec = true };
             pub const add_vec_and_drain: @This() = .{ .add_vec = true, .drain = true };
-            pub const drain_and_rebase: @This() = .{ .drain = true, .rebase = true };
+            pub const drain_and_rebase: @This() = .{ .drain = true, .rebase = .rebase };
+            pub const drain_and_flush: @This() = .{ .drain = true, .rebase = .flush };
         };
 
         const is_eos = expected_size == max_size or smith.eosWeightedSimple(7, 1);
         var op: Op = if (!is_eos) smith.valueWeighted(Op, &.{
-            .value(Op, .add_vec_only, 6),
+            .value(Op, .add_vec_only, 5),
             .value(Op, .add_vec_and_drain, 1),
             .value(Op, .drain_and_rebase, 1),
+            .value(Op, .drain_and_flush, 1),
         }) else .drain_only;
 
         if (op.add_vec) {
@@ -1965,16 +2056,20 @@ fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, smith: *std.testing.Smith)
             vecs_n = 0;
         }
 
-        if (op.rebase) {
-            const capacity = smith.valueRangeAtMost(u32, 0, raw_buf_len);
-            const preserve = smith.valueRangeAtMost(u32, 0, raw_buf_len - capacity);
-            try raw.writer.rebase(preserve, capacity);
+        switch (op.rebase) {
+            .none => {},
+            .rebase => {
+                const capacity = smith.valueRangeAtMost(u32, 0, raw_buf_len);
+                const preserve = smith.valueRangeAtMost(u32, 0, raw_buf_len - capacity);
+                try raw.writer.rebase(preserve, capacity);
+            },
+            .flush => try raw.writer.flush(),
         }
 
         if (is_eos) break;
     }
 
-    try raw.writer.flush();
+    try raw.finish();
     try output.writer.flush();
 
     try std.testing.expectEqual(.end, output.state);
@@ -1997,6 +2092,7 @@ fn testFuzzedRawInput(data_buf: *const [4 * 65536]u8, smith: *std.testing.Smith)
 
 /// Only performs huffman compression on data, does no matching.
 pub const Huffman = struct {
+    /// After `finish` is called, all vtable calls with result in `error.WriteFailed`.
     writer: Writer,
     bit_writer: BitWriter,
     hasher: flate.Container.Hasher,
@@ -2026,12 +2122,6 @@ pub const Huffman = struct {
     }
 
     fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize {
-        {
-            //std.debug.print("drain {} (buffered)", .{w.buffered().len});
-            //for (data) |d| std.debug.print("\n\t+ {}", .{d.len});
-            //std.debug.print(" x {}\n\n", .{splat});
-        }
-
         const h: *Huffman = @fieldParentPtr("writer", w);
         const min_block = @min(w.buffer.len, max_tokens);
         const pattern = data[data.len - 1];
@@ -2238,9 +2328,15 @@ pub const Huffman = struct {
     }
 
     fn flush(w: *Writer) Writer.Error!void {
-        defer w.* = .failing;
+        errdefer w.* = .failing;
         const h: *Huffman = @fieldParentPtr("writer", w);
-        try Huffman.rebaseInner(w, 0, w.buffer.len, true);
+        try Huffman.rebaseInner(w, 0, w.buffer.len, false);
+        try h.bit_writer.byteAlignBlocks();
+    }
+
+    fn finish(h: *Huffman) Writer.Error!void {
+        defer h.writer = .failing;
+        try Huffman.rebaseInner(&h.writer, 0, h.writer.buffer.len, true);
         try h.bit_writer.output.rebase(0, 1);
         h.bit_writer.byteAlign();
         try h.hasher.writeFooter(h.bit_writer.output);
@@ -2359,9 +2455,6 @@ pub const Huffman = struct {
             break :n stored_align_bits + @as(u32, 32) + @as(u32, bytes) * 8;
         };
 
-        //std.debug.print("@ {}{{{}}} ", .{ h.bit_writer.output.end, h.bit_writer.buffered_n });
-        //std.debug.print("#{} -> s {} f {} d {}\n", .{ bytes, stored_bitsize, fixed_bitsize, dynamic_bitsize });
-
         if (stored_bitsize <= @min(dynamic_bitsize, fixed_bitsize)) {
             try h.bit_writer.write(BlockHeader.int(.{ .kind = .stored, .final = eos }), 3);
             try h.bit_writer.output.rebase(0, 5);
@@ -2434,19 +2527,21 @@ fn testFuzzedHuffmanInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith)
         const Op = packed struct {
             drain: bool = false,
             add_vec: bool = false,
-            rebase: bool = false,
+            rebase: enum(u2) { none, rebase, flush } = .none,
 
             pub const drain_only: @This() = .{ .drain = true };
             pub const add_vec_only: @This() = .{ .add_vec = true };
             pub const add_vec_and_drain: @This() = .{ .add_vec = true, .drain = true };
-            pub const drain_and_rebase: @This() = .{ .drain = true, .rebase = true };
+            pub const drain_and_rebase: @This() = .{ .drain = true, .rebase = .rebase };
+            pub const drain_and_flush: @This() = .{ .drain = true, .rebase = .flush };
         };
 
         const is_eos = expected_size == max_size or smith.eosWeightedSimple(7, 1);
         var op: Op = if (!is_eos) smith.valueWeighted(Op, &.{
-            .value(Op, .add_vec_only, 6),
+            .value(Op, .add_vec_only, 5),
             .value(Op, .add_vec_and_drain, 1),
             .value(Op, .drain_and_rebase, 1),
+            .value(Op, .drain_and_flush, 1),
         }) else .drain_only;
 
         if (op.add_vec) {
@@ -2517,7 +2612,7 @@ fn testFuzzedHuffmanInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith)
             vecs_n = 0;
         }
 
-        if (op.rebase) {
+        if (op.rebase != .none) {
             const capacity = smith.valueRangeAtMost(u32, 0, h_buf_len);
             const preserve = smith.valueRangeAtMost(u32, 0, h_buf_len - capacity);
 
@@ -2525,9 +2620,14 @@ fn testFuzzedHuffmanInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith)
                 h.writer.buffered().len,
                 flate_w.buffered().len,
                 false,
-            );
-            h.writer.rebase(preserve, capacity) catch
-                return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {};
+            ) + @as(usize, 8) * @intFromBool(op.rebase == .flush); // Overhead from byte alignment
+            switch (op.rebase) {
+                .none => unreachable,
+                .rebase => h.writer.rebase(preserve, capacity) catch
+                    return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {},
+                .flush => h.writer.flush() catch
+                    return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {},
+            }
             if (flate_w.buffered().len > max_space) return error.OverheadTooLarge;
         }
 
@@ -2539,8 +2639,7 @@ fn testFuzzedHuffmanInput(fbufs: *const [2][65536]u8, smith: *std.testing.Smith)
         flate_w.buffered().len,
         true,
     );
-    h.writer.flush() catch
-        return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {};
+    h.finish() catch return if (max_space <= flate_w.buffer.len) error.OverheadTooLarge else {};
     if (flate_w.buffered().len > max_space) return error.OverheadTooLarge;
 
     try testingCheckDecompressedMatches(flate_w.buffered(), expected_size, expected_hash);
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index fe57f487b8e614271d409741a57c1f44f40f3f70..9fb2ba4f9870192e0de6a73ac10f93e41d6bd7ff 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -447,7 +447,7 @@ pub const JobQueue = struct {
 
         // intentionally omitting the pointless trailer
         //try archiver.finish();
-        compress.writer.flush() catch |err| switch (err) {
+        compress.finish() catch |err| switch (err) {
             error.WriteFailed => return file_writer.err.?,
         };
         try file_writer.flush();
-- 
2.54.0


From acde20a14804dd3c6dcc7940cdf49af240c74f58 Mon Sep 17 00:00:00 2001
From: Techatrix <techatrix@mailbox.org>
Date: Tue, 10 Mar 2026 16:12:43 +0100
Subject: [PATCH 497/499] fetch: fix incorrect error about unneeded lazy
 dependency in system mode

---
 src/Package/Fetch.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 9fb2ba4f9870192e0de6a73ac10f93e41d6bd7ff..0b8e0c367bd319aafaad2c28ddb39f24494b8ed6 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -602,7 +602,7 @@ pub fn run(f: *Fetch) RunError!void {
         } else |err| switch (err) {
             error.FileNotFound => {
                 log.debug("FileNotFound: {f}", .{package_root});
-                if (job_queue.read_only) return f.fail(
+                if (job_queue.read_only and f.lazy_status == .eager) return f.fail(
                     f.name_tok,
                     try eb.printString("package not found at '{f}'", .{package_root}),
                 );
-- 
2.54.0


From 1a8ed9a6580453e6aa8133d716692e7bad34be14 Mon Sep 17 00:00:00 2001
From: Techatrix <techatrix@mailbox.org>
Date: Tue, 10 Mar 2026 17:28:04 +0100
Subject: [PATCH 498/499] checkAllAllocationFailures: provide result type to
 'extra_args'

---
 lib/std/testing.zig | 95 ++++++++++++++++++++++++++-------------------
 1 file changed, 55 insertions(+), 40 deletions(-)

diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 29e1fc8d61a7b4809f00ef1af9527d6da659a594..df3cfddb1db4ba93dfa985197d683ab18b27f76c 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -1112,48 +1112,16 @@ test {
 ///     defer allocator.free(bar);
 /// }
 /// ```
-pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime test_fn: anytype, extra_args: anytype) !void {
-    switch (@typeInfo(@typeInfo(@TypeOf(test_fn)).@"fn".return_type.?)) {
-        .error_union => |info| {
-            if (info.payload != void) {
-                @compileError("Return type must be !void");
-            }
-        },
-        else => @compileError("Return type must be !void"),
-    }
-    if (@typeInfo(@TypeOf(extra_args)) != .@"struct") {
-        @compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(extra_args)));
-    }
-
-    const ArgsTuple = std.meta.ArgsTuple(@TypeOf(test_fn));
-    const fn_args_fields = @typeInfo(ArgsTuple).@"struct".fields;
-    if (fn_args_fields.len == 0 or fn_args_fields[0].type != std.mem.Allocator) {
-        @compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
-    }
-    const expected_args_tuple_len = fn_args_fields.len - 1;
-    if (extra_args.len != expected_args_tuple_len) {
-        @compileError("The provided function expects " ++ std.fmt.comptimePrint("{d}", .{expected_args_tuple_len}) ++ " extra arguments, but the provided tuple contains " ++ std.fmt.comptimePrint("{d}", .{extra_args.len}));
-    }
-
-    // Setup the tuple that will actually be used with @call (we'll need to insert
-    // the failing allocator in field @"0" before each @call)
-    var args: ArgsTuple = undefined;
-    inline for (@typeInfo(@TypeOf(extra_args)).@"struct".fields, 0..) |field, i| {
-        const arg_i_str = comptime str: {
-            var str_buf: [100]u8 = undefined;
-            const args_i = i + 1;
-            const str_len = std.fmt.printInt(&str_buf, args_i, 10, .lower, .{});
-            break :str str_buf[0..str_len];
-        };
-        @field(args, arg_i_str) = @field(extra_args, field.name);
-    }
-
+pub fn checkAllAllocationFailures(
+    backing_allocator: std.mem.Allocator,
+    comptime test_fn: anytype,
+    extra_args: CheckAllAllocationFailuresExtraArgs(@TypeOf(test_fn)),
+) !void {
     // Try it once with unlimited memory, make sure it works
     const needed_alloc_count = x: {
         var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{});
-        args.@"0" = failing_allocator_inst.allocator();
 
-        try @call(.auto, test_fn, args);
+        try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);
         break :x failing_allocator_inst.alloc_index;
     };
 
@@ -1161,9 +1129,8 @@ pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime
         var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{
             .fail_index = fail_index,
         });
-        args.@"0" = failing_allocator_inst.allocator();
 
-        if (@call(.auto, test_fn, args)) |_| {
+        if (@call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args)) |_| {
             if (failing_allocator_inst.has_induced_failure) {
                 return error.SwallowedOutOfMemoryError;
             } else {
@@ -1194,6 +1161,54 @@ pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime
     }
 }
 
+fn CheckAllAllocationFailuresExtraArgs(comptime TestFn: type) type {
+    switch (@typeInfo(@typeInfo(TestFn).@"fn".return_type.?)) {
+        .error_union => |info| {
+            if (info.payload != void) {
+                @compileError("Return type must be !void");
+            }
+        },
+        else => @compileError("Return type must be !void"),
+    }
+
+    const ArgsTuple = std.meta.ArgsTuple(TestFn);
+
+    const fields = @typeInfo(ArgsTuple).@"struct".fields;
+    if (fields.len == 0 or fields[0].type != std.mem.Allocator) {
+        @compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
+    }
+
+    var extra_args: [fields.len - 1]type = undefined;
+    for (&extra_args, fields[1..]) |*arg, field| {
+        arg.* = field.type;
+    }
+
+    return @Tuple(&extra_args);
+}
+
+test "checkAllAllocationFailures provide result type to 'extra_args' argument" {
+    try checkAllAllocationFailures(
+        std.testing.allocator,
+        struct {
+            fn f(ally: std.mem.Allocator, params: struct {
+                foo_len: u32,
+                bar_len: u32,
+            }) !void {
+                const foo = try ally.alloc(u8, params.foo_len);
+                defer ally.free(foo);
+                const bar = try ally.alloc(u8, params.bar_len);
+                defer ally.free(bar);
+            }
+        }.f,
+        .{
+            .{
+                .foo_len = 3,
+                .bar_len = 5,
+            },
+        },
+    );
+}
+
 /// Given a type, references all the declarations inside, so that the semantic analyzer sees them.
 pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;
-- 
2.54.0


From c01b9b1ab5bb0e9cd6eb1792cd20a643907008ad Mon Sep 17 00:00:00 2001
From: FnControlOption <fncontroloption@noreply.codeberg.org>
Date: Fri, 6 Mar 2026 22:33:28 +0100
Subject: [PATCH 499/499] langref: replace `std.meta.Int` with `@Int`

---
 doc/langref.html.in | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 85ec580b4dfc039facf494eb7fa460baf1edad6e..7118d01c9173a0544b8ba4030321125f49a62863 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -4866,7 +4866,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_close#}
 
       {#header_open|@errorFromInt#}
-      <pre>{#syntax#}@errorFromInt(value: std.meta.Int(.unsigned, @bitSizeOf(anyerror))) anyerror{#endsyntax#}</pre>
+      <pre>{#syntax#}@errorFromInt(value: @Int(.unsigned, @bitSizeOf(anyerror))) anyerror{#endsyntax#}</pre>
       <p>
       Converts from the integer representation of an error into {#link|The Global Error Set#} type.
       </p>
@@ -5107,7 +5107,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_close#}
 
       {#header_open|@intFromError#}
-      <pre>{#syntax#}@intFromError(err: anytype) std.meta.Int(.unsigned, @bitSizeOf(anyerror)){#endsyntax#}</pre>
+      <pre>{#syntax#}@intFromError(err: anytype) @Int(.unsigned, @bitSizeOf(anyerror)){#endsyntax#}</pre>
       <p>
       Supports the following types:
       </p>
-- 
2.54.0